From 903420268a5aabbab9acdf8788b4344c395ee597 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Sun, 12 Jan 2020 11:24:13 -0800
Subject: [PATCH 001/345] Checklist to precede pull requests

I added a checklist to the C++ Style document for things to check before
submitting a pull request or when responding to a request for comments
on a pull request.
---
 documentation/PullRequestChecklist.md | 44 +++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 documentation/PullRequestChecklist.md

diff --git a/documentation/PullRequestChecklist.md b/documentation/PullRequestChecklist.md
new file mode 100644
index 000000000000..782c3b61ca0e
--- /dev/null
+++ b/documentation/PullRequestChecklist.md
@@ -0,0 +1,44 @@
+<!--===- documentation/PullRequestChecklist.md 
+
+   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
+
+-->
+
+# Pull request checklist
+Please review the following items before submitting a pull request.  This list
+can also be used when reviewing pull requests.
+*  Verify that new files have a license with correct file name.
+*  Run `git diff` on all modified files to look for spurious changes such as
+   `#include <iostream>`.
+*  If you added code that causes the compiler to emit a new error message, make
+   sure that you also added a test that causes that error message to appear
+   and verifies its correctness.
+*  Annotate the code and tests with appropriate references to constraint and
+   requirement numbers from the Fortran standard.
+*  Check dereferences of pointers and optionals where necessary.
+*  Ensure that the scopes of all functions and variables are as local as
+   possible.
+*  Try to make all functions fit on a screen (40 lines).
+*  Build and test with both GNU and clang compilers.
+*  When submitting an update to a pull request, review previous pull request
+   comments and make sure that you've actually made all of the changes that
+   were requested.
+
+## Follow the style guide
+The following items are taken from the [C++ style guide](C++style.md).  But
+even though I've read the style guide, they regularly trip me up.
+*  Run clang-format version 7 on all .cc and .h files.
+*  Make sure that all source lines have 80 or fewer characters.  Note that
+   clang-format will do this for most code.  But you may need to break up long
+   strings.
+*  Review declarations for proper use of `constexpr` and `const`.
+*  Follow the C++ naming guidelines.  Ensure that the names evoke their
+   purpose and are consistent with existing code.
+*  Review pointer and reference types to make sure that you're using them
+   appropriately.  Note that the [C++ style guide](C++style.md) contains a
+   section that describes all of the pointer types along with their
+   characteristics.
+*  Declare non-member functions ```static``` when possible.  Prefer
+   ```static``` functions over functions in anonymous namespaces.

From 25dc49b6e9cf5bce61d6d655ab242609cbd28e13 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 14 Jan 2020 17:31:25 -0800
Subject: [PATCH 002/345] Add `std::string ExpressionBase::AsFortran()`

This is easier to use when including an expression in an error message
and also useful when debugging for dumping expressions.

Fix up several places that no longer need to use a temporary
std::stringstream.

Also change some references to `operator<<` in `formatting.cc` and
`symbol.cc` that became ambiguous with this change.
---
 lib/evaluate/characteristics.cc    | 13 +++----------
 lib/evaluate/expression.h          |  1 +
 lib/evaluate/fold-implementation.h |  9 ++-------
 lib/evaluate/formatting.cc         | 28 ++++++++++++++++------------
 lib/semantics/check-call.cc        |  7 ++-----
 lib/semantics/symbol.cc            | 22 +++++++++++++++-------
 lib/semantics/type.cc              | 10 +++-------
 test/evaluate/expression.cc        | 23 ++++++++---------------
 8 files changed, 50 insertions(+), 63 deletions(-)

diff --git a/lib/evaluate/characteristics.cc b/lib/evaluate/characteristics.cc
index de03d7d03174..83c79461b792 100644
--- a/lib/evaluate/characteristics.cc
+++ b/lib/evaluate/characteristics.cc
@@ -155,13 +155,10 @@ bool TypeAndShape::IsCompatibleWith(parser::ContextualMessages &messages,
     bool isElemental) const {
   const auto &len{that.LEN()};
   if (!type_.IsTypeCompatibleWith(that.type_)) {
-    std::stringstream lenstr;
-    if (len) {
-      len->AsFortran(lenstr);
-    }
     messages.Say(
         "%1$s type '%2$s' is not compatible with %3$s type '%4$s'"_err_en_US,
-        thatIs, that.type_.AsFortran(lenstr.str()), thisIs, type_.AsFortran());
+        thatIs, that.type_.AsFortran(len ? len->AsFortran() : ""), thisIs,
+        type_.AsFortran());
     return false;
   }
   return isElemental ||
@@ -213,11 +210,7 @@ void TypeAndShape::AcquireLEN() {
 }
 
 std::ostream &TypeAndShape::Dump(std::ostream &o) const {
-  std::stringstream LENstr;
-  if (LEN_) {
-    LEN_->AsFortran(LENstr);
-  }
-  o << type_.AsFortran(LENstr.str());
+  o << type_.AsFortran(LEN_ ? LEN_->AsFortran() : "");
   attrs_.Dump(o, EnumToString);
   if (!shape_.empty()) {
     o << " dimension(";
diff --git a/lib/evaluate/expression.h b/lib/evaluate/expression.h
index c5003ca6e20e..f10ba21e9224 100644
--- a/lib/evaluate/expression.h
+++ b/lib/evaluate/expression.h
@@ -89,6 +89,7 @@ template<typename RESULT> class ExpressionBase {
 
   std::optional<DynamicType> GetType() const;
   int Rank() const;
+  std::string AsFortran() const;
   std::ostream &AsFortran(std::ostream &) const;
   static Derived Rewrite(FoldingContext &, Derived &&);
 };
diff --git a/lib/evaluate/fold-implementation.h b/lib/evaluate/fold-implementation.h
index 688dee505401..d78c52785276 100644
--- a/lib/evaluate/fold-implementation.h
+++ b/lib/evaluate/fold-implementation.h
@@ -35,7 +35,6 @@
 #include <complex>
 #include <cstdio>
 #include <optional>
-#include <sstream>
 #include <type_traits>
 #include <variant>
 
@@ -185,18 +184,14 @@ std::optional<Expr<T>> Folder<T>::GetNamedConstantValue(const Symbol &symbol0) {
               }
               mutableObject->set_init(std::nullopt);
             } else {
-              std::stringstream ss;
-              unwrapped->AsFortran(ss);
               context_.messages().Say(symbol.name(),
                   "Initialization expression for PARAMETER '%s' (%s) cannot be computed as a constant value"_err_en_US,
-                  symbol.name(), ss.str());
+                  symbol.name(), unwrapped->AsFortran());
             }
           } else {
-            std::stringstream ss;
-            init->AsFortran(ss);
             context_.messages().Say(symbol.name(),
                 "Initialization expression for PARAMETER '%s' (%s) cannot be converted to its type (%s)"_err_en_US,
-                symbol.name(), ss.str(), dyType->AsFortran());
+                symbol.name(), init->AsFortran(), dyType->AsFortran());
           }
         }
       }
diff --git a/lib/evaluate/formatting.cc b/lib/evaluate/formatting.cc
index 73b087881d79..67320ac7a826 100644
--- a/lib/evaluate/formatting.cc
+++ b/lib/evaluate/formatting.cc
@@ -14,6 +14,7 @@
 #include "tools.h"
 #include "../parser/characters.h"
 #include "../semantics/symbol.h"
+#include <sstream>
 
 namespace Fortran::evaluate {
 
@@ -314,24 +315,24 @@ std::ostream &Operation<D, R, O...>::AsFortran(std::ostream &o) const {
   Precedence thisPrec{ToPrecedence(derived())};
   if constexpr (operands == 1) {
     if (thisPrec != Precedence::Top && lhsPrec < thisPrec) {
-      o << '(' << left() << ')';
+      left().AsFortran(o << '(') << ')';
     } else {
-      o << left();
+      left().AsFortran(o);
     }
   } else {
     if (thisPrec != Precedence::Top &&
         (lhsPrec < thisPrec ||
             (lhsPrec == Precedence::Power && thisPrec == Precedence::Power))) {
-      o << '(' << left() << ')';
+      left().AsFortran(o << '(') << ')';
     } else {
-      o << left();
+      left().AsFortran(o);
     }
     o << spelling.infix;
     Precedence rhsPrec{ToPrecedence(right())};
     if (thisPrec != Precedence::Top && rhsPrec < thisPrec) {
-      o << '(' << right() << ')';
+      right().AsFortran(o << '(') << ')';
     } else {
-      o << right();
+      right().AsFortran(o);
     }
   }
   return o << spelling.suffix;
@@ -403,9 +404,7 @@ std::ostream &ArrayConstructor<T>::AsFortran(std::ostream &o) const {
 template<int KIND>
 std::ostream &ArrayConstructor<Type<TypeCategory::Character, KIND>>::AsFortran(
     std::ostream &o) const {
-  std::stringstream len;
-  LEN().AsFortran(len);
-  o << '[' << GetType().AsFortran(len.str()) << "::";
+  o << '[' << GetType().AsFortran(LEN().AsFortran()) << "::";
   EmitArray(o, *this);
   return o << ']';
 }
@@ -416,6 +415,13 @@ std::ostream &ArrayConstructor<SomeDerived>::AsFortran(std::ostream &o) const {
   return o << ']';
 }
 
+template<typename RESULT>
+std::string ExpressionBase<RESULT>::AsFortran() const {
+  std::ostringstream ss;
+  AsFortran(ss);
+  return ss.str();
+}
+
 template<typename RESULT>
 std::ostream &ExpressionBase<RESULT>::AsFortran(std::ostream &o) const {
   std::visit(
@@ -459,9 +465,7 @@ std::string DynamicType::AsFortran() const {
     } else if (charLength_->isDeferred()) {
       result += ':';
     } else if (const auto &length{charLength_->GetExplicit()}) {
-      std::stringstream ss;
-      length->AsFortran(ss);
-      result += ss.str();
+      result += length->AsFortran();
     }
     return result + ')';
   } else if (IsUnlimitedPolymorphic()) {
diff --git a/lib/semantics/check-call.cc b/lib/semantics/check-call.cc
index 1888249a063d..a643c384d589 100644
--- a/lib/semantics/check-call.cc
+++ b/lib/semantics/check-call.cc
@@ -160,13 +160,10 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
           "dummy argument", "actual argument");
     }
   } else {
-    std::stringstream lenStr;
-    if (const auto &len{actualType.LEN()}) {
-      len->AsFortran(lenStr);
-    }
+    const auto &len{actualType.LEN()};
     messages.Say(
         "Actual argument type '%s' is not compatible with dummy argument type '%s'"_err_en_US,
-        actualType.type().AsFortran(lenStr.str()),
+        actualType.type().AsFortran(len ? len->AsFortran() : ""),
         dummy.type.type().AsFortran());
   }
 
diff --git a/lib/semantics/symbol.cc b/lib/semantics/symbol.cc
index 9646059c0dba..4015cf754103 100644
--- a/lib/semantics/symbol.cc
+++ b/lib/semantics/symbol.cc
@@ -11,6 +11,7 @@
 #include "semantics.h"
 #include "tools.h"
 #include "../common/idioms.h"
+#include "../evaluate/expression.h"
 #include <ostream>
 #include <string>
 
@@ -22,6 +23,13 @@ static void DumpOptional(std::ostream &os, const char *label, const T &x) {
     os << ' ' << label << ':' << *x;
   }
 }
+template<typename T>
+static void DumpExpr(std::ostream &os, const char *label,
+    const std::optional<evaluate::Expr<T>> &x) {
+  if (x) {
+    x->AsFortran(os << ' ' << label << ':');
+  }
+}
 
 static void DumpBool(std::ostream &os, const char *label, bool x) {
   if (x) {
@@ -84,7 +92,7 @@ void ModuleDetails::set_scope(const Scope *scope) {
 
 std::ostream &operator<<(std::ostream &os, const SubprogramDetails &x) {
   DumpBool(os, "isInterface", x.isInterface_);
-  DumpOptional(os, "bindName", x.bindName_);
+  DumpExpr(os, "bindName", x.bindName_);
   if (x.result_) {
     os << " result:" << x.result_->name();
     if (!x.result_->attrs().empty()) {
@@ -336,7 +344,7 @@ std::ostream &operator<<(std::ostream &os, const EntityDetails &x) {
   if (x.type()) {
     os << " type: " << *x.type();
   }
-  DumpOptional(os, "bindName", x.bindName_);
+  DumpExpr(os, "bindName", x.bindName_);
   return os;
 }
 
@@ -344,13 +352,13 @@ std::ostream &operator<<(std::ostream &os, const ObjectEntityDetails &x) {
   os << *static_cast<const EntityDetails *>(&x);
   DumpList(os, "shape", x.shape());
   DumpList(os, "coshape", x.coshape());
-  DumpOptional(os, "init", x.init_);
+  DumpExpr(os, "init", x.init_);
   return os;
 }
 
 std::ostream &operator<<(std::ostream &os, const AssocEntityDetails &x) {
   os << *static_cast<const EntityDetails *>(&x);
-  DumpOptional(os, "expr", x.expr());
+  DumpExpr(os, "expr", x.expr());
   return os;
 }
 
@@ -360,7 +368,7 @@ std::ostream &operator<<(std::ostream &os, const ProcEntityDetails &x) {
   } else {
     DumpType(os, x.interface_.type());
   }
-  DumpOptional(os, "bindName", x.bindName());
+  DumpExpr(os, "bindName", x.bindName());
   DumpOptional(os, "passName", x.passName());
   if (x.init()) {
     if (const Symbol * target{*x.init()}) {
@@ -409,7 +417,7 @@ std::ostream &operator<<(std::ostream &os, const Details &details) {
               os << dummy->name();
             }
             os << ')';
-            DumpOptional(os, "bindName", x.bindName());
+            DumpExpr(os, "bindName", x.bindName());
             if (x.isFunction()) {
               os << " result(";
               DumpType(os, x.result());
@@ -455,7 +463,7 @@ std::ostream &operator<<(std::ostream &os, const Details &details) {
           [&](const TypeParamDetails &x) {
             DumpOptional(os, "type", x.type());
             os << ' ' << common::EnumToString(x.attr());
-            DumpOptional(os, "init", x.init());
+            DumpExpr(os, "init", x.init());
           },
           [&](const MiscDetails &x) {
             os << ' ' << MiscDetails::EnumToString(x.kind());
diff --git a/lib/semantics/type.cc b/lib/semantics/type.cc
index e680697b8e49..3e96186f6563 100644
--- a/lib/semantics/type.cc
+++ b/lib/semantics/type.cc
@@ -122,11 +122,9 @@ void DerivedTypeSpec::EvaluateParameters(
             continue;
           }
         }
-        std::stringstream fortran;
-        expr->AsFortran(fortran);
         evaluate::SayWithDeclaration(messages, symbol,
             "Value of type parameter '%s' (%s) is not convertible to its type"_err_en_US,
-            name, fortran.str());
+            name, expr->AsFortran());
       }
     }
   }
@@ -243,12 +241,10 @@ void DerivedTypeSpec::Instantiate(
               if (expr->Rank() == 0 &&
                   maybeDynamicType->category() == TypeCategory::Integer) {
                 if (!evaluate::ToInt64(*expr)) {
-                  std::stringstream fortran;
-                  fortran << *expr;
                   if (auto *msg{foldingContext.messages().Say(
                           "Value of kind type parameter '%s' (%s) is not "
                           "a scalar INTEGER constant"_err_en_US,
-                          name, fortran.str())}) {
+                          name, expr->AsFortran())}) {
                     msg->Attach(name, "declared here"_en_US);
                   }
                 }
@@ -322,7 +318,7 @@ std::ostream &operator<<(std::ostream &o, const Bound &x) {
   } else if (x.isDeferred()) {
     o << ':';
   } else if (x.expr_) {
-    o << x.expr_;
+    x.expr_->AsFortran(o);
   } else {
     o << "<no-expr>";
   }
diff --git a/test/evaluate/expression.cc b/test/evaluate/expression.cc
index 3145769e175b..24a6e0f5f5d7 100644
--- a/test/evaluate/expression.cc
+++ b/test/evaluate/expression.cc
@@ -6,37 +6,30 @@
 #include "../../lib/parser/message.h"
 #include <cstdio>
 #include <cstdlib>
-#include <sstream>
 #include <string>
 
 using namespace Fortran::evaluate;
 
-template<typename A> std::string AsFortran(const A &x) {
-  std::stringstream ss;
-  ss << x;
-  return ss.str();
-}
-
 int main() {
   using DefaultIntegerExpr = Expr<Type<TypeCategory::Integer, 4>>;
   TEST(DefaultIntegerExpr::Result::AsFortran() == "INTEGER(4)");
-  MATCH("666_4", AsFortran(DefaultIntegerExpr{666}));
-  MATCH("-1_4", AsFortran(-DefaultIntegerExpr{1}));
+  MATCH("666_4", DefaultIntegerExpr{666}.AsFortran());
+  MATCH("-1_4", (-DefaultIntegerExpr{1}).AsFortran());
   auto ex1{
       DefaultIntegerExpr{2} + DefaultIntegerExpr{3} * -DefaultIntegerExpr{4}};
-  MATCH("2_4+3_4*(-4_4)", AsFortran(ex1));
+  MATCH("2_4+3_4*(-4_4)", ex1.AsFortran());
   Fortran::common::IntrinsicTypeDefaultKinds defaults;
   auto intrinsics{Fortran::evaluate::IntrinsicProcTable::Configure(defaults)};
   FoldingContext context{
       Fortran::parser::ContextualMessages{nullptr}, defaults, intrinsics};
   ex1 = Fold(context, std::move(ex1));
-  MATCH("-10_4", AsFortran(ex1));
-  MATCH("1_4/2_4", AsFortran(DefaultIntegerExpr{1} / DefaultIntegerExpr{2}));
+  MATCH("-10_4", ex1.AsFortran());
+  MATCH("1_4/2_4", (DefaultIntegerExpr{1} / DefaultIntegerExpr{2}).AsFortran());
   DefaultIntegerExpr a{1};
   DefaultIntegerExpr b{2};
-  MATCH("1_4", AsFortran(a));
+  MATCH("1_4", a.AsFortran());
   a = b;
-  MATCH("2_4", AsFortran(a));
-  MATCH("2_4", AsFortran(b));
+  MATCH("2_4", a.AsFortran());
+  MATCH("2_4", b.AsFortran());
   return testing::Complete();
 }

From 3b865d7703f53099cd491ed1aa9b80b46fee9f58 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 14 Jan 2020 17:39:29 -0800
Subject: [PATCH 003/345] Make GenericAssignmentWrapper more like
 GenericExprWrapper

Have it wrap an optional Assignment so that we can distinguish between
unanalyzed and analyzed with error.

Change analysis of PointerAssignmentStmt to proceed with bounds even
if the DataRef or Expr has an error. Otherwise any bounds expressions
won't be analyzed in that case.

In GetExpr() and GetAssignment() if we get an internal error due to an
unanalyzed expression, dump the parse tree for the expression so we have
some context for the error. They should only be called after the
expression analysis phase. At that point, every expression and assignment
should be analyzed, though some may have resulted in errors(indicated by
returning `nullptr`).
---
 lib/evaluate/expression.h   |  3 +-
 lib/semantics/expression.cc | 81 ++++++++++++++++++++-----------------
 lib/semantics/tools.cc      | 29 +++++++++++--
 lib/semantics/tools.h       |  8 +---
 tools/f18/f18.cc            |  6 ++-
 5 files changed, 78 insertions(+), 49 deletions(-)

diff --git a/lib/evaluate/expression.h b/lib/evaluate/expression.h
index f10ba21e9224..00363b523d5d 100644
--- a/lib/evaluate/expression.h
+++ b/lib/evaluate/expression.h
@@ -847,9 +847,10 @@ struct GenericExprWrapper {
 
 // Like GenericExprWrapper but for analyzed assignments
 struct GenericAssignmentWrapper {
+  GenericAssignmentWrapper() {}
   explicit GenericAssignmentWrapper(Assignment &&x) : v{std::move(x)} {}
   ~GenericAssignmentWrapper();
-  Assignment v;
+  std::optional<Assignment> v;  // vacant if error
 };
 
 FOR_EACH_CATEGORY_TYPE(extern template class Expr, )
diff --git a/lib/semantics/expression.cc b/lib/semantics/expression.cc
index a5eb00b7b6f4..e24b31045184 100644
--- a/lib/semantics/expression.cc
+++ b/lib/semantics/expression.cc
@@ -1915,7 +1915,9 @@ const Assignment *ExpressionAnalyzer::Analyze(const parser::AssignmentStmt &x) {
     ArgumentAnalyzer analyzer{*this};
     analyzer.Analyze(std::get<parser::Variable>(x.t));
     analyzer.Analyze(std::get<parser::Expr>(x.t));
-    if (!analyzer.fatalErrors()) {
+    if (analyzer.fatalErrors()) {
+      x.typedAssignment.reset(new GenericAssignmentWrapper{});
+    } else {
       std::optional<ProcedureRef> procRef{analyzer.TryDefinedAssignment()};
       x.typedAssignment.reset(new GenericAssignmentWrapper{procRef
               ? Assignment{std::move(*procRef)}
@@ -1923,50 +1925,55 @@ const Assignment *ExpressionAnalyzer::Analyze(const parser::AssignmentStmt &x) {
                     Fold(analyzer.MoveExpr(0)), Fold(analyzer.MoveExpr(1))}}});
     }
   }
-  return x.typedAssignment ? &x.typedAssignment->v : nullptr;
+  return common::GetPtrFromOptional(x.typedAssignment->v);
 }
 
 const Assignment *ExpressionAnalyzer::Analyze(
     const parser::PointerAssignmentStmt &x) {
-  MaybeExpr lhs{Analyze(std::get<parser::DataRef>(x.t))};
-  MaybeExpr rhs{Analyze(std::get<parser::Expr>(x.t))};
-  if (!lhs || !rhs) {
-    return nullptr;
-  }
-  Assignment::PointerAssignment assignment{
-      Fold(std::move(*lhs)), Fold(std::move(*rhs))};
-  std::visit(
-      common::visitors{
-          [&](const std::list<parser::BoundsRemapping> &list) {
-            if (!list.empty()) {
-              Assignment::PointerAssignment::BoundsRemapping bounds;
-              for (const auto &elem : list) {
-                auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
-                auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
-                if (lower && upper) {
-                  bounds.emplace_back(
-                      Fold(std::move(*lower)), Fold(std::move(*upper)));
+  if (!x.typedAssignment) {
+    MaybeExpr lhs{Analyze(std::get<parser::DataRef>(x.t))};
+    MaybeExpr rhs{Analyze(std::get<parser::Expr>(x.t))};
+    decltype(Assignment::PointerAssignment::bounds) pointerBounds;
+    std::visit(
+        common::visitors{
+            [&](const std::list<parser::BoundsRemapping> &list) {
+              if (!list.empty()) {
+                Assignment::PointerAssignment::BoundsRemapping bounds;
+                for (const auto &elem : list) {
+                  auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
+                  auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
+                  if (lower && upper) {
+                    bounds.emplace_back(
+                        Fold(std::move(*lower)), Fold(std::move(*upper)));
+                  }
                 }
+                pointerBounds = bounds;
               }
-              assignment.bounds = bounds;
-            }
-          },
-          [&](const std::list<parser::BoundsSpec> &list) {
-            if (!list.empty()) {
-              Assignment::PointerAssignment::BoundsSpec bounds;
-              for (const auto &bound : list) {
-                if (auto lower{AsSubscript(Analyze(bound.v))}) {
-                  bounds.emplace_back(Fold(std::move(*lower)));
+            },
+            [&](const std::list<parser::BoundsSpec> &list) {
+              if (!list.empty()) {
+                Assignment::PointerAssignment::BoundsSpec bounds;
+                for (const auto &bound : list) {
+                  if (auto lower{AsSubscript(Analyze(bound.v))}) {
+                    bounds.emplace_back(Fold(std::move(*lower)));
+                  }
                 }
+                pointerBounds = bounds;
               }
-              assignment.bounds = bounds;
-            }
-          },
-      },
-      std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
-  x.typedAssignment.reset(
-      new GenericAssignmentWrapper{Assignment{std::move(assignment)}});
-  return &x.typedAssignment->v;
+            },
+        },
+        std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
+    if (!lhs || !rhs) {
+      x.typedAssignment.reset(new GenericAssignmentWrapper{});
+    } else {
+      Assignment::PointerAssignment assignment{
+          Fold(std::move(*lhs)), Fold(std::move(*rhs))};
+      assignment.bounds = pointerBounds;
+      x.typedAssignment.reset(
+          new GenericAssignmentWrapper{Assignment{std::move(assignment)}});
+    }
+  }
+  return common::GetPtrFromOptional(x.typedAssignment->v);
 }
 
 static bool IsExternalCalledImplicitly(
diff --git a/lib/semantics/tools.cc b/lib/semantics/tools.cc
index 18c5c827987d..8342e4126259 100644
--- a/lib/semantics/tools.cc
+++ b/lib/semantics/tools.cc
@@ -13,11 +13,13 @@
 #include "type.h"
 #include "../common/Fortran.h"
 #include "../common/indirection.h"
+#include "../parser/dump-parse-tree.h"
 #include "../parser/message.h"
 #include "../parser/parse-tree.h"
 #include "../parser/tools.h"
 #include <algorithm>
 #include <set>
+#include <sstream>
 #include <variant>
 
 namespace Fortran::semantics {
@@ -383,14 +385,33 @@ bool ExprTypeKindIsDefault(
       dynamicType->kind() == context.GetDefaultKind(dynamicType->category());
 }
 
+// If an analyzed expr or assignment is missing, dump the node and die.
+template<typename T> static void CheckMissingAnalysis(bool absent, const T &x) {
+  if (absent) {
+    std::ostringstream ss;
+    ss << "node has not been analyzed:\n";
+    parser::DumpTree(ss, x);
+    common::die(ss.str().c_str());
+  }
+}
+
+const SomeExpr *GetExprHelper::Get(const parser::Expr &x) {
+  CheckMissingAnalysis(!x.typedExpr, x);
+  return common::GetPtrFromOptional(x.typedExpr->v);
+}
+const SomeExpr *GetExprHelper::Get(const parser::Variable &x) {
+  CheckMissingAnalysis(!x.typedExpr, x);
+  return common::GetPtrFromOptional(x.typedExpr->v);
+}
+
 const evaluate::Assignment *GetAssignment(const parser::AssignmentStmt &x) {
-  const auto &typed{x.typedAssignment};
-  return typed ? &typed->v : nullptr;
+  CheckMissingAnalysis(!x.typedAssignment, x);
+  return common::GetPtrFromOptional(x.typedAssignment->v);
 }
 const evaluate::Assignment *GetAssignment(
     const parser::PointerAssignmentStmt &x) {
-  const auto &typed{x.typedAssignment};
-  return typed ? &typed->v : nullptr;
+  CheckMissingAnalysis(!x.typedAssignment, x);
+  return common::GetPtrFromOptional(x.typedAssignment->v);
 }
 
 const Symbol *FindInterface(const Symbol &symbol) {
diff --git a/lib/semantics/tools.h b/lib/semantics/tools.h
index d857654f0576..83741bdddafe 100644
--- a/lib/semantics/tools.h
+++ b/lib/semantics/tools.h
@@ -226,12 +226,8 @@ bool ExprTypeKindIsDefault(
     const SomeExpr &expr, const SemanticsContext &context);
 
 struct GetExprHelper {
-  const SomeExpr *Get(const parser::Expr::TypedExpr &x) {
-    CHECK(x);
-    return x && x->v ? &*x->v : nullptr;
-  }
-  const SomeExpr *Get(const parser::Expr &x) { return Get(x.typedExpr); }
-  const SomeExpr *Get(const parser::Variable &x) { return Get(x.typedExpr); }
+  const SomeExpr *Get(const parser::Expr &);
+  const SomeExpr *Get(const parser::Variable &);
   template<typename T> const SomeExpr *Get(const common::Indirection<T> &x) {
     return Get(x.value());
   }
diff --git a/tools/f18/f18.cc b/tools/f18/f18.cc
index f23f6e4f9b93..6e6854051b4c 100644
--- a/tools/f18/f18.cc
+++ b/tools/f18/f18.cc
@@ -172,7 +172,11 @@ static Fortran::parser::AnalyzedObjectsAsFortran asFortran{
       }
     },
     [](std::ostream &o, const Fortran::evaluate::GenericAssignmentWrapper &x) {
-      x.v.AsFortran(o);
+      if (x.v) {
+        x.v->AsFortran(o);
+      } else {
+        o << "(bad assignment)";
+      }
     },
     [](std::ostream &o, const Fortran::evaluate::ProcedureRef &x) {
       x.AsFortran(o << "CALL ");

From bdf3d3a292b5f9ce4241e3d63b759bd61838cf18 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Thu, 16 Jan 2020 12:43:48 -0800
Subject: [PATCH 004/345] Refactor Analyze(PointerAssignmentStmt)

Use early returns to reduce the indentation.
Check LHS is a pointer as early as possible.
A PointerAssignmentStmt can only have a typedAssignment that
represents a PointerAssignment. So assert that is the case and
don't worry about the other cases.
---
 lib/semantics/assignment.cc         | 112 +++++++++++++---------------
 lib/semantics/pointer-assignment.cc |  22 +++---
 2 files changed, 62 insertions(+), 72 deletions(-)

diff --git a/lib/semantics/assignment.cc b/lib/semantics/assignment.cc
index 064d6f86dbe5..53724af627d7 100644
--- a/lib/semantics/assignment.cc
+++ b/lib/semantics/assignment.cc
@@ -158,66 +158,60 @@ void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
 }
 
 void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
+  using PointerAssignment = evaluate::Assignment::PointerAssignment;
   CHECK(!where_);
-  if (const evaluate::Assignment * asst{GetAssignment(stmt)}) {
-    bool hasBounds{false};
-    auto [lhs, rhs]{std::visit(
-        common::visitors{
-            [&](const evaluate::Assignment::IntrinsicAssignment &x) {
-              return std::make_pair(&x.lhs, &x.rhs);
-            },
-            [&](const evaluate::ProcedureRef &x) {
-              return std::make_pair(x.arguments()[0]->UnwrapExpr(),
-                  x.arguments()[1]->UnwrapExpr());
-            },
-            [&](const evaluate::Assignment::PointerAssignment &x) {
-              std::visit(
-                  common::visitors{
-                      [&](const evaluate::Assignment::PointerAssignment::
-                              BoundsSpec &bounds) {
-                        hasBounds = !bounds.empty();
-                        for (const auto &bound : bounds) {
-                          CheckForImpureCall(SomeExpr{bound});
-                        }
-                      },
-                      [&](const evaluate::Assignment::PointerAssignment::
-                              BoundsRemapping &bounds) {
-                        hasBounds = !bounds.empty();
-                        for (const auto &bound : bounds) {
-                          CheckForImpureCall(SomeExpr{bound.first});
-                          CheckForImpureCall(SomeExpr{bound.second});
-                        }
-                      },
-                  },
-                  x.bounds);
-              return std::make_pair(&x.lhs, &x.rhs);
-            },
-        },
-        asst->u)};
-    CheckForImpureCall(lhs);
-    CheckForImpureCall(rhs);
-    if (forall_) {
-      // TODO: Warn if some name in forall_->activeNames or its outer
-      // contexts does not appear on LHS
-    }
-    if (lhs && rhs) {
-      CheckForPureContext(
-          *lhs, *rhs, std::get<parser::Expr>(stmt.t).source, true /* => */);
-      const Symbol *pointer{GetLastSymbol(lhs)};
-      if (pointer && pointer->has<ProcEntityDetails>() &&
-          evaluate::ExtractCoarrayRef(*lhs)) {
-        context_.Say(  // C1027
-            "Procedure pointer may not be a coindexed object"_err_en_US);
-      }
-      if (hasBounds) {
-        // TODO cases with bounds-spec and bounds-remapping
-      } else {
-        auto &foldingContext{context_.foldingContext()};
-        auto restorer{
-            foldingContext.messages().SetLocation(context_.location().value())};
-        CheckPointerAssignment(foldingContext, *pointer, *rhs);
-      }
-    }
+  const evaluate::Assignment *assign{GetAssignment(stmt)};
+  if (!assign) {
+    return;
+  }
+  const auto &ptrAssign{std::get<PointerAssignment>(assign->u)};
+  const SomeExpr &lhs{ptrAssign.lhs};
+  const SomeExpr &rhs{ptrAssign.rhs};
+  std::size_t numBounds{std::visit(
+      common::visitors{
+          [&](const PointerAssignment::BoundsSpec &bounds) {
+            for (const auto &bound : bounds) {
+              CheckForImpureCall(SomeExpr{bound});
+            }
+            return bounds.size();
+          },
+          [&](const PointerAssignment::BoundsRemapping &bounds) {
+            for (const auto &bound : bounds) {
+              CheckForImpureCall(SomeExpr{bound.first});
+              CheckForImpureCall(SomeExpr{bound.second});
+            }
+            return bounds.size();
+          },
+      },
+      ptrAssign.bounds)};
+  const Symbol *pointer{GetLastSymbol(lhs)};
+  if (!pointer) {
+    return;  // error was reported
+  }
+  auto &foldingContext{context_.foldingContext()};
+  auto restorer{
+      foldingContext.messages().SetLocation(context_.location().value())};
+  if (!IsPointer(*pointer)) {
+    evaluate::SayWithDeclaration(foldingContext.messages(), *pointer,
+        "'%s' is not a pointer"_err_en_US, pointer->name());
+    return;
+  }
+  CheckForImpureCall(lhs);
+  CheckForImpureCall(rhs);
+  if (forall_) {
+    // TODO: Warn if some name in forall_->activeNames or its outer
+    // contexts does not appear on LHS
+  }
+  CheckForPureContext(lhs, rhs, std::get<parser::Expr>(stmt.t).source,
+      true /* isPointerAssignment */);
+  if (pointer->has<ProcEntityDetails>() && evaluate::ExtractCoarrayRef(lhs)) {
+    context_.Say(  // C1027
+        "Procedure pointer may not be a coindexed object"_err_en_US);
+  }
+  if (numBounds > 0) {
+    // TODO cases with bounds-spec and bounds-remapping
+  } else {
+    CheckPointerAssignment(foldingContext, *pointer, rhs);
   }
 }
 
diff --git a/lib/semantics/pointer-assignment.cc b/lib/semantics/pointer-assignment.cc
index 57b7d8cb4acc..88a4b065c65f 100644
--- a/lib/semantics/pointer-assignment.cc
+++ b/lib/semantics/pointer-assignment.cc
@@ -326,19 +326,15 @@ void CheckPointerAssignment(
     evaluate::FoldingContext &context, const Symbol &lhs, const SomeExpr &rhs) {
   // TODO: Acquire values of deferred type parameters &/or array bounds
   // from the RHS.
-  if (!IsPointer(lhs)) {
-    evaluate::SayWithDeclaration(
-        context.messages(), lhs, "'%s' is not a pointer"_err_en_US, lhs.name());
-  } else {
-    std::string description{"pointer '"s + lhs.name().ToString() + '\''};
-    PointerAssignmentChecker{lhs.name(), description, context}
-        .set_lhsType(TypeAndShape::Characterize(lhs, context))
-        .set_procedure(Procedure::Characterize(lhs, context.intrinsics()))
-        .set_lhs(lhs)
-        .set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS))
-        .set_isVolatile(lhs.attrs().test(Attr::VOLATILE))
-        .Check(rhs);
-  }
+  CHECK(IsPointer(lhs));
+  std::string description{"pointer '"s + lhs.name().ToString() + '\''};
+  PointerAssignmentChecker{lhs.name(), description, context}
+      .set_lhsType(TypeAndShape::Characterize(lhs, context))
+      .set_procedure(Procedure::Characterize(lhs, context.intrinsics()))
+      .set_lhs(lhs)
+      .set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS))
+      .set_isVolatile(lhs.attrs().test(Attr::VOLATILE))
+      .Check(rhs);
 }
 
 void CheckPointerAssignment(evaluate::FoldingContext &context,

From 7489b3539224f8ad7a55873916e5854510236218 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 21 Jan 2020 17:15:21 -0800
Subject: [PATCH 005/345] Check bounds on pointer assignment

Perform checks on bounds-spec and bounds-remapping in a pointer
assignment statement:
- check that the rank of the bounds specified matches the rank of the
  pointer
- for bounds-spec, check that the pointer rank matches the target rank
- for bounds-remapping:
  - check that the target is rank 1 or simply contiguous
  - check that there are sufficient elements on the RHS for the bounds
    specified, when it can be determined at compile time

Move more of the pointer-specific checking from `assignment.cc`
to `pointer-assignment.cc`.
---
 lib/semantics/assignment.cc         |  34 ++----
 lib/semantics/pointer-assignment.cc | 169 +++++++++++++++++++++-------
 lib/semantics/pointer-assignment.h  |   3 +
 test/semantics/assign02.f90         |  10 +-
 test/semantics/assign03.f90         |  26 +++++
 5 files changed, 172 insertions(+), 70 deletions(-)

diff --git a/lib/semantics/assignment.cc b/lib/semantics/assignment.cc
index 53724af627d7..d7b9d91ed739 100644
--- a/lib/semantics/assignment.cc
+++ b/lib/semantics/assignment.cc
@@ -167,52 +167,32 @@ void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
   const auto &ptrAssign{std::get<PointerAssignment>(assign->u)};
   const SomeExpr &lhs{ptrAssign.lhs};
   const SomeExpr &rhs{ptrAssign.rhs};
-  std::size_t numBounds{std::visit(
+  CheckForImpureCall(lhs);
+  CheckForImpureCall(rhs);
+  std::visit(
       common::visitors{
           [&](const PointerAssignment::BoundsSpec &bounds) {
             for (const auto &bound : bounds) {
               CheckForImpureCall(SomeExpr{bound});
             }
-            return bounds.size();
           },
           [&](const PointerAssignment::BoundsRemapping &bounds) {
             for (const auto &bound : bounds) {
               CheckForImpureCall(SomeExpr{bound.first});
               CheckForImpureCall(SomeExpr{bound.second});
             }
-            return bounds.size();
           },
       },
-      ptrAssign.bounds)};
-  const Symbol *pointer{GetLastSymbol(lhs)};
-  if (!pointer) {
-    return;  // error was reported
-  }
-  auto &foldingContext{context_.foldingContext()};
-  auto restorer{
-      foldingContext.messages().SetLocation(context_.location().value())};
-  if (!IsPointer(*pointer)) {
-    evaluate::SayWithDeclaration(foldingContext.messages(), *pointer,
-        "'%s' is not a pointer"_err_en_US, pointer->name());
-    return;
-  }
-  CheckForImpureCall(lhs);
-  CheckForImpureCall(rhs);
+      ptrAssign.bounds);
   if (forall_) {
     // TODO: Warn if some name in forall_->activeNames or its outer
     // contexts does not appear on LHS
   }
   CheckForPureContext(lhs, rhs, std::get<parser::Expr>(stmt.t).source,
       true /* isPointerAssignment */);
-  if (pointer->has<ProcEntityDetails>() && evaluate::ExtractCoarrayRef(lhs)) {
-    context_.Say(  // C1027
-        "Procedure pointer may not be a coindexed object"_err_en_US);
-  }
-  if (numBounds > 0) {
-    // TODO cases with bounds-spec and bounds-remapping
-  } else {
-    CheckPointerAssignment(foldingContext, *pointer, rhs);
-  }
+  auto restorer{context_.foldingContext().messages().SetLocation(
+      context_.location().value())};
+  CheckPointerAssignment(context_.foldingContext(), ptrAssign);
 }
 
 void AssignmentContext::Analyze(const parser::WhereStmt &stmt) {
diff --git a/lib/semantics/pointer-assignment.cc b/lib/semantics/pointer-assignment.cc
index 88a4b065c65f..017d0e80e033 100644
--- a/lib/semantics/pointer-assignment.cc
+++ b/lib/semantics/pointer-assignment.cc
@@ -33,21 +33,31 @@ using evaluate::characteristics::DummyDataObject;
 using evaluate::characteristics::FunctionResult;
 using evaluate::characteristics::Procedure;
 using evaluate::characteristics::TypeAndShape;
+using parser::MessageFixedText;
+using parser::MessageFormattedText;
+using PointerAssignment = evaluate::Assignment::PointerAssignment;
 
 class PointerAssignmentChecker {
 public:
-  PointerAssignmentChecker(parser::CharBlock source,
-      const std::string &description, evaluate::FoldingContext &context)
-    : source_{source}, description_{description}, context_{context} {}
-  PointerAssignmentChecker &set_lhs(const Symbol &);
+  PointerAssignmentChecker(evaluate::FoldingContext &context,
+      parser::CharBlock source, const std::string &description)
+    : context_{context}, source_{source}, description_{description} {}
+  PointerAssignmentChecker(evaluate::FoldingContext &context, const Symbol &lhs)
+    : context_{context}, source_{lhs.name()},
+      description_{"pointer '"s + lhs.name().ToString() + '\''}, lhs_{&lhs},
+      procedure_{Procedure::Characterize(lhs, context.intrinsics())} {
+    set_lhsType(TypeAndShape::Characterize(lhs, context));
+    set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS));
+    set_isVolatile(lhs.attrs().test(Attr::VOLATILE));
+  }
   PointerAssignmentChecker &set_lhsType(std::optional<TypeAndShape> &&);
-  PointerAssignmentChecker &set_procedure(std::optional<Procedure> &&);
   PointerAssignmentChecker &set_isContiguous(bool);
   PointerAssignmentChecker &set_isVolatile(bool);
+  PointerAssignmentChecker &set_isBoundsRemapping(bool);
   void Check(const SomeExpr &);
 
 private:
-  template<typename A> void Check(const A &);
+  template<typename T> void Check(const T &);
   template<typename T> void Check(const evaluate::Expr<T> &);
   template<typename T> void Check(const evaluate::FunctionRef<T> &);
   template<typename T> void Check(const evaluate::Designator<T> &);
@@ -60,33 +70,23 @@ class PointerAssignmentChecker {
   bool LhsOkForUnlimitedPoly() const;
   template<typename... A> parser::Message *Say(A &&...);
 
-  const parser::CharBlock source_;
-  const std::string &description_;
   evaluate::FoldingContext &context_;
+  const parser::CharBlock source_;
+  const std::string description_;
   const Symbol *lhs_{nullptr};
   std::optional<TypeAndShape> lhsType_;
   std::optional<Procedure> procedure_;
   bool isContiguous_{false};
   bool isVolatile_{false};
+  bool isBoundsRemapping_{false};
 };
 
-PointerAssignmentChecker &PointerAssignmentChecker::set_lhs(const Symbol &lhs) {
-  lhs_ = &lhs;
-  return *this;
-}
-
 PointerAssignmentChecker &PointerAssignmentChecker::set_lhsType(
     std::optional<TypeAndShape> &&lhsType) {
   lhsType_ = std::move(lhsType);
   return *this;
 }
 
-PointerAssignmentChecker &PointerAssignmentChecker::set_procedure(
-    std::optional<Procedure> &&procedure) {
-  procedure_ = std::move(procedure);
-  return *this;
-}
-
 PointerAssignmentChecker &PointerAssignmentChecker::set_isContiguous(
     bool isContiguous) {
   isContiguous_ = isContiguous;
@@ -99,7 +99,13 @@ PointerAssignmentChecker &PointerAssignmentChecker::set_isVolatile(
   return *this;
 }
 
-template<typename A> void PointerAssignmentChecker::Check(const A &) {
+PointerAssignmentChecker &PointerAssignmentChecker::set_isBoundsRemapping(
+    bool isBoundsRemapping) {
+  isBoundsRemapping_ = isBoundsRemapping;
+  return *this;
+}
+
+template<typename T> void PointerAssignmentChecker::Check(const T &) {
   // Catch-all case for really bad target expression
   Say("Target associated with %s must be a designator or a call to a"
       " pointer-valued function"_err_en_US,
@@ -138,7 +144,7 @@ void PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
   if (!proc) {
     return;
   }
-  std::optional<parser::MessageFixedText> msg;
+  std::optional<MessageFixedText> msg;
   const auto &funcResult{proc->functionResult};  // C1025
   if (!funcResult) {
     msg = "%s is associated with the non-existent result of reference to"
@@ -180,7 +186,7 @@ void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
     context_.messages().Say("Pointer target is not a named entity"_err_en_US);
     return;
   }
-  std::optional<parser::MessageFixedText> msg;
+  std::optional<std::variant<MessageFixedText, MessageFormattedText>> msg;
   if (procedure_) {
     // Shouldn't be here in this function unless lhs is an object pointer.
     msg = "In assignment to procedure %s, the target is not a procedure or"
@@ -208,14 +214,31 @@ void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
               " derived type when target is unlimited polymorphic"_err_en_US;
       }
     } else {
-      lhsType_->IsCompatibleWith(context_.messages(), *rhsType);
+      if (!lhsType_->type().IsTypeCompatibleWith(rhsType->type())) {
+        msg = MessageFormattedText{
+            "Target type %s is not compatible with pointer type %s"_err_en_US,
+            rhsType->type().AsFortran(), lhsType_->type().AsFortran()};
+
+      } else if (!isBoundsRemapping_) {
+        std::size_t lhsRank{lhsType_->shape().size()};
+        std::size_t rhsRank{rhsType->shape().size()};
+        if (lhsRank != rhsRank) {
+          msg = MessageFormattedText{
+              "Pointer has rank %d but target has rank %d"_err_en_US, lhsRank,
+              rhsRank};
+        }
+      }
     }
   }
   if (msg) {
-    std::ostringstream ss;
-    d.AsFortran(ss);
     auto restorer{common::ScopedSet(lhs_, last)};
-    Say(*msg, description_, ss.str());
+    if (auto *m{std::get_if<MessageFixedText>(&*msg)}) {
+      std::ostringstream ss;
+      d.AsFortran(ss);
+      Say(*m, description_, ss.str());
+    } else {
+      Say(std::get<MessageFormattedText>(*msg));
+    }
   }
 }
 
@@ -235,7 +258,7 @@ static bool CharacteristicsMatch(const Procedure &lhs, const Procedure &rhs) {
 // Common handling for procedure pointer right-hand sides
 void PointerAssignmentChecker::Check(
     parser::CharBlock rhsName, bool isCall, const Procedure *rhsProcedure) {
-  std::optional<parser::MessageFixedText> msg;
+  std::optional<MessageFixedText> msg;
   if (!procedure_) {
     msg = "In assignment to object %s, the target '%s' is a procedure"
           " designator"_err_en_US;
@@ -322,25 +345,95 @@ parser::Message *PointerAssignmentChecker::Say(A &&... x) {
   return msg;
 }
 
+// Verify that any bounds on the LHS of a pointer assignment are valid.
+// Return true if it is a bound-remapping so we can perform further checks.
+static bool CheckPointerBounds(
+    evaluate::FoldingContext &context, const PointerAssignment &assignment) {
+  auto &messages{context.messages()};
+  const SomeExpr &lhs{assignment.lhs};
+  const SomeExpr &rhs{assignment.rhs};
+  bool isBoundsRemapping{false};
+  std::size_t numBounds{std::visit(
+      common::visitors{
+          [&](const PointerAssignment::BoundsSpec &bounds) {
+            return bounds.size();
+          },
+          [&](const PointerAssignment::BoundsRemapping &bounds) {
+            isBoundsRemapping = true;
+            evaluate::ExtentExpr lhsSizeExpr{1};
+            for (const auto &bound : bounds) {
+              lhsSizeExpr = std::move(lhsSizeExpr) *
+                  (common::Clone(bound.second) - common::Clone(bound.first) +
+                      evaluate::ExtentExpr{1});
+            }
+            if (std::optional<std::int64_t> lhsSize{evaluate::ToInt64(
+                    evaluate::Fold(context, std::move(lhsSizeExpr)))}) {
+              if (auto shape{evaluate::GetShape(context, rhs)}) {
+                if (std::optional<std::int64_t> rhsSize{
+                        evaluate::ToInt64(evaluate::Fold(
+                            context, evaluate::GetSize(std::move(*shape))))}) {
+                  if (*lhsSize > *rhsSize) {
+                    messages.Say(
+                        "Pointer bounds require %d elements but target has"
+                        " only %d"_err_en_US,
+                        *lhsSize, *rhsSize);  // 10.2.2.3(9)
+                  }
+                }
+              }
+            }
+            return bounds.size();
+          },
+      },
+      assignment.bounds)};
+  if (numBounds > 0) {
+    if (lhs.Rank() != static_cast<int>(numBounds)) {
+      messages.Say("Pointer '%s' has rank %d but the number of bounds specified"
+                   " is %d"_err_en_US,
+          lhs.AsFortran(), lhs.Rank(), numBounds);  // C1018
+    }
+  }
+  if (isBoundsRemapping && rhs.Rank() != 1 &&
+      !evaluate::IsSimplyContiguous(rhs, context.intrinsics())) {
+    messages.Say("Pointer bounds remapping target must have rank 1 or be"
+                 " simply contiguous"_err_en_US);  // 10.2.2.3(9)
+  }
+  return isBoundsRemapping;
+}
+
+void CheckPointerAssignment(
+    evaluate::FoldingContext &context, const PointerAssignment &assignment) {
+  const SomeExpr &lhs{assignment.lhs};
+  const SomeExpr &rhs{assignment.rhs};
+  const Symbol *pointer{GetLastSymbol(lhs)};
+  if (!pointer) {
+    return;  // error was reported
+  }
+  if (!IsPointer(*pointer)) {
+    evaluate::SayWithDeclaration(context.messages(), *pointer,
+        "'%s' is not a pointer"_err_en_US, pointer->name());
+    return;
+  }
+  if (pointer->has<ProcEntityDetails>() && evaluate::ExtractCoarrayRef(lhs)) {
+    context.messages().Say(  // C1027
+        "Procedure pointer may not be a coindexed object"_err_en_US);
+    return;
+  }
+  bool isBoundsRemapping{CheckPointerBounds(context, assignment)};
+  PointerAssignmentChecker{context, *pointer}
+      .set_isBoundsRemapping(isBoundsRemapping)
+      .Check(rhs);
+}
+
 void CheckPointerAssignment(
     evaluate::FoldingContext &context, const Symbol &lhs, const SomeExpr &rhs) {
-  // TODO: Acquire values of deferred type parameters &/or array bounds
-  // from the RHS.
   CHECK(IsPointer(lhs));
-  std::string description{"pointer '"s + lhs.name().ToString() + '\''};
-  PointerAssignmentChecker{lhs.name(), description, context}
-      .set_lhsType(TypeAndShape::Characterize(lhs, context))
-      .set_procedure(Procedure::Characterize(lhs, context.intrinsics()))
-      .set_lhs(lhs)
-      .set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS))
-      .set_isVolatile(lhs.attrs().test(Attr::VOLATILE))
-      .Check(rhs);
+  PointerAssignmentChecker{context, lhs}.Check(rhs);
 }
 
 void CheckPointerAssignment(evaluate::FoldingContext &context,
     parser::CharBlock source, const std::string &description,
     const DummyDataObject &lhs, const SomeExpr &rhs) {
-  PointerAssignmentChecker{source, description, context}
+  PointerAssignmentChecker{context, source, description}
       .set_lhsType(common::Clone(lhs.type))
       .set_isContiguous(lhs.attrs.test(DummyDataObject::Attr::Contiguous))
       .set_isVolatile(lhs.attrs.test(DummyDataObject::Attr::Volatile))
diff --git a/lib/semantics/pointer-assignment.h b/lib/semantics/pointer-assignment.h
index 268a5592a59d..83652aef550c 100644
--- a/lib/semantics/pointer-assignment.h
+++ b/lib/semantics/pointer-assignment.h
@@ -10,6 +10,7 @@
 #define FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
 
 #include "type.h"
+#include "../evaluate/expression.h"
 #include "../parser/char-block.h"
 #include <string>
 
@@ -25,6 +26,8 @@ namespace Fortran::semantics {
 
 class Symbol;
 
+void CheckPointerAssignment(evaluate::FoldingContext &,
+    const evaluate::Assignment::PointerAssignment &);
 void CheckPointerAssignment(
     evaluate::FoldingContext &, const Symbol &lhs, const SomeExpr &rhs);
 void CheckPointerAssignment(evaluate::FoldingContext &,
diff --git a/test/semantics/assign02.f90 b/test/semantics/assign02.f90
index 60f560b69e7f..5b3fa4f6da2b 100644
--- a/test/semantics/assign02.f90
+++ b/test/semantics/assign02.f90
@@ -30,18 +30,18 @@ subroutine s1
     logical, target :: l
     real, pointer :: p
     p => r
-    !ERROR: TARGET type 'REAL(8)' is not compatible with POINTER type 'REAL(4)'
+    !ERROR: Target type REAL(8) is not compatible with pointer type REAL(4)
     p => r8
-    !ERROR: TARGET type 'LOGICAL(4)' is not compatible with POINTER type 'REAL(4)'
+    !ERROR: Target type LOGICAL(4) is not compatible with pointer type REAL(4)
     p => l
   end
 
-  ! C1015
+  ! C1019
   subroutine s2
     real, target :: r1(4), r2(4,4)
     real, pointer :: p(:)
     p => r1
-    !ERROR: Rank of POINTER is 1, but TARGET has rank 2
+    !ERROR: Pointer has rank 1 but target has rank 2
     p => r2
   end
 
@@ -51,7 +51,7 @@ subroutine s3
     type(t(2)), target :: x2
     type(t(1)), pointer :: p
     p => x1
-    !ERROR: TARGET type 't(k=2_4)' is not compatible with POINTER type 't(k=1_4)'
+    !ERROR: Target type t(k=2_4) is not compatible with pointer type t(k=1_4)
     p => x2
   end
 
diff --git a/test/semantics/assign03.f90 b/test/semantics/assign03.f90
index da8ffcb70590..54112f4f4097 100644
--- a/test/semantics/assign03.f90
+++ b/test/semantics/assign03.f90
@@ -108,4 +108,30 @@ subroutine s7
     p_f => s_external
   end
 
+  ! C1017: bounds-spec
+  subroutine s8
+    real, target :: x(10, 10)
+    real, pointer :: p(:, :)
+    p(2:,3:) => x
+    !ERROR: Pointer 'p' has rank 2 but the number of bounds specified is 1
+    p(2:) => x
+  end
+
+  ! bounds-remapping
+  subroutine s9
+    real, target :: x(10, 10), y(100)
+    real, pointer :: p(:, :)
+    ! C1018
+    !ERROR: Pointer 'p' has rank 2 but the number of bounds specified is 1
+    p(1:100) => x
+    ! 10.2.2.3(9)
+    !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
+    p(1:5,1:5) => x(1:10,::2)
+    ! 10.2.2.3(9)
+    !ERROR: Pointer bounds require 25 elements but target has only 20
+    p(1:5,1:5) => x(:,1:2)
+    !OK - rhs has rank 1 and enough elements
+    p(1:5,1:5) => y(1:100:2)
+  end
+
 end

From 195d807ff221e4247ec5609e8e816e81dab5df94 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Fri, 24 Jan 2020 12:08:24 -0800
Subject: [PATCH 006/345] More checklist items

I added more items when reviewing some actual pull request comments.
---
 documentation/PullRequestChecklist.md | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/documentation/PullRequestChecklist.md b/documentation/PullRequestChecklist.md
index 782c3b61ca0e..46cef0c4c778 100644
--- a/documentation/PullRequestChecklist.md
+++ b/documentation/PullRequestChecklist.md
@@ -16,7 +16,9 @@ can also be used when reviewing pull requests.
    sure that you also added a test that causes that error message to appear
    and verifies its correctness.
 *  Annotate the code and tests with appropriate references to constraint and
-   requirement numbers from the Fortran standard.
+   requirement numbers from the Fortran standard.  Do not include the text of
+   the constraint or requirement, just its number.
+*  Alphabetize arbitrary lists of names.
 *  Check dereferences of pointers and optionals where necessary.
 *  Ensure that the scopes of all functions and variables are as local as
    possible.
@@ -34,8 +36,9 @@ even though I've read the style guide, they regularly trip me up.
    clang-format will do this for most code.  But you may need to break up long
    strings.
 *  Review declarations for proper use of `constexpr` and `const`.
-*  Follow the C++ naming guidelines.  Ensure that the names evoke their
-   purpose and are consistent with existing code.
+*  Follow the C++ [naming guidelines](C++style.md#naming).
+*  Ensure that the names evoke their purpose and are consistent with existing code.
+*  Used braced initializers.
 *  Review pointer and reference types to make sure that you're using them
    appropriately.  Note that the [C++ style guide](C++style.md) contains a
    section that describes all of the pointer types along with their

From 839a91f1d699cd839767407bcdb1e384f2d2b730 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Thu, 16 Jan 2020 13:51:25 -0800
Subject: [PATCH 007/345] Drill down to a working implementation of the APIs
 for an internal formatted WRITE with no data list items.

Improve argument names in io-api.h

Bump up error number to not conflict with errno values

Use Fortran::runtime::io namespace

Add wrapper around malloc/free, allow use of unique_ptr with wrapper

IoErrorHandler

Revamp FormatContext, use virtual member functions

Update comment syntax, allow for old C

12HHELLO, WORLD

Remove files not yet ready for review

Use std::forward

Fix gcc build warnings

Fix redundant filename in license boilerplate

Reduce runtime dependence on compiler binary libraries, fixing shared lib builds
---
 include/flang/ISO_Fortran_binding.h |   5 +-
 runtime/CMakeLists.txt              |   7 +-
 runtime/entry-names.h               |   6 +-
 runtime/format.cc                   | 173 ++++++++++++++--------------
 runtime/format.h                    |  44 ++++---
 runtime/io-api.cc                   |  31 +++++
 runtime/io-api.h                    |  61 +++++-----
 runtime/io-error.cc                 |  67 +++++++++++
 runtime/io-error.h                  |  50 ++++++++
 runtime/io-stmt.cc                  |  88 ++++++++++++++
 runtime/io-stmt.h                   |  64 ++++++++++
 runtime/magic-numbers.h             |   4 +-
 runtime/main.cc                     |  40 +++++--
 runtime/main.h                      |  14 ++-
 runtime/memory.cc                   |  33 ++++++
 runtime/memory.h                    |  43 +++++++
 runtime/terminator.cc               |   6 +
 runtime/terminator.h                |   8 ++
 runtime/transformational.cc         |  15 +--
 test/runtime/CMakeLists.txt         |  10 ++
 test/runtime/format.cc              |  87 ++++++++------
 test/runtime/hello.cc               |  33 ++++++
 22 files changed, 686 insertions(+), 203 deletions(-)
 create mode 100644 runtime/io-api.cc
 create mode 100644 runtime/io-error.cc
 create mode 100644 runtime/io-error.h
 create mode 100644 runtime/io-stmt.cc
 create mode 100644 runtime/io-stmt.h
 create mode 100644 runtime/memory.cc
 create mode 100644 runtime/memory.h
 create mode 100644 test/runtime/hello.cc

diff --git a/include/flang/ISO_Fortran_binding.h b/include/flang/ISO_Fortran_binding.h
index 0a014817db0e..b54f778fdec8 100644
--- a/include/flang/ISO_Fortran_binding.h
+++ b/include/flang/ISO_Fortran_binding.h
@@ -30,8 +30,9 @@ inline namespace Fortran_2018 {
 #define CFI_MAX_RANK 15
 typedef unsigned char CFI_rank_t;
 
-// This type is probably larger than a default Fortran INTEGER
-// and should be used for all array indexing and loop bound calculations.
+/* This type is probably larger than a default Fortran INTEGER
+ * and should be used for all array indexing and loop bound calculations.
+ */
 typedef ptrdiff_t CFI_index_t;
 
 typedef unsigned char CFI_attribute_t;
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index 523c7aac9ba9..3253f4b30899 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -11,7 +11,11 @@ add_library(FortranRuntime
   derived-type.cc
   descriptor.cc
   format.cc
+  io-api.cc
+  io-error.cc
+  io-stmt.cc
   main.cc
+  memory.cc
   stop.cc
   terminator.cc
   transformational.cc
@@ -19,5 +23,6 @@ add_library(FortranRuntime
 )
 
 target_link_libraries(FortranRuntime
-  FortranEvaluate
+  FortranCommon
+  FortranDecimal
 )
diff --git a/runtime/entry-names.h b/runtime/entry-names.h
index db80fee10525..e2581ca33c9d 100644
--- a/runtime/entry-names.h
+++ b/runtime/entry-names.h
@@ -16,7 +16,7 @@
 // runtime library must change in some way that breaks backward compatibility.
 
 #ifndef RTNAME
-#define PREFIX _Fortran
-#define REVISION A
-#define RTNAME(name) PREFIX##REVISION##name
+#define NAME_WITH_PREFIX_AND_REVISION(prefix, revision, name) \
+  prefix##revision##name
+#define RTNAME(name) NAME_WITH_PREFIX_AND_REVISION(_Fortran, A, name)
 #endif
diff --git a/runtime/format.cc b/runtime/format.cc
index b7a175dd220b..9324d1528a65 100644
--- a/runtime/format.cc
+++ b/runtime/format.cc
@@ -7,23 +7,43 @@
 //===----------------------------------------------------------------------===//
 
 #include "format.h"
+#include "io-stmt.h"
 #include "../lib/common/format.h"
 #include "../lib/decimal/decimal.h"
 #include <limits>
 
-namespace Fortran::runtime {
+namespace Fortran::runtime::io {
+
+// Default FormatContext virtual member functions
+void FormatContext::Emit(const char *, std::size_t) {
+  Crash("Cannot emit data from this FORMAT string");
+}
+void FormatContext::Emit(const char16_t *, std::size_t) {
+  Crash("Cannot emit data from this FORMAT string");
+}
+void FormatContext::Emit(const char32_t *, std::size_t) {
+  Crash("Cannot emit data from this FORMAT string");
+}
+void FormatContext::HandleSlash(int) {
+  Crash("A / control edit descriptor may not appear in this FORMAT string");
+}
+void FormatContext::HandleAbsolutePosition(int) {
+  Crash("A Tn control edit descriptor may not appear in this FORMAT string");
+}
+void FormatContext::HandleRelativePosition(int) {
+  Crash("An nX, TLn, or TRn control edit descriptor may not appear in this "
+        "FORMAT string");
+}
 
 template<typename CHAR>
-FormatControl<CHAR>::FormatControl(FormatContext &context, const CHAR *format,
-    std::size_t formatLength, const MutableModes &modes, int maxHeight)
-  : context_{context}, modes_{modes}, maxHeight_{static_cast<std::uint8_t>(
-                                          maxHeight)},
-    format_{format}, formatLength_{static_cast<int>(formatLength)} {
+FormatControl<CHAR>::FormatControl(Terminator &terminator, const CHAR *format,
+    std::size_t formatLength, int maxHeight)
+  : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
+    formatLength_{static_cast<int>(formatLength)} {
   // The additional two items are for the whole string and a
   // repeated non-parenthesized edit descriptor.
   if (maxHeight > std::numeric_limits<std::int8_t>::max()) {
-    context_.terminator.Crash(
-        "internal Fortran runtime error: maxHeight %d", maxHeight);
+    terminator.Crash("internal Fortran runtime error: maxHeight %d", maxHeight);
   }
   stack_[0].start = offset_;
   stack_[0].remaining = Iteration::unlimited;  // 13.4(8)
@@ -43,38 +63,23 @@ int FormatControl<CHAR>::GetMaxParenthesisNesting(
   return validator.maxNesting();
 }
 
-static void HandleCharacterLiteral(
-    FormatContext &context, const char *str, std::size_t chars) {
-  if (context.handleCharacterLiteral1) {
-    context.handleCharacterLiteral1(str, chars);
-  }
-}
-
-static void HandleCharacterLiteral(
-    FormatContext &context, const char16_t *str, std::size_t chars) {
-  if (context.handleCharacterLiteral2) {
-    context.handleCharacterLiteral2(str, chars);
-  }
-}
-
-static void HandleCharacterLiteral(
-    FormatContext &context, const char32_t *str, std::size_t chars) {
-  if (context.handleCharacterLiteral4) {
-    context.handleCharacterLiteral4(str, chars);
-  }
-}
-
-template<typename CHAR> int FormatControl<CHAR>::GetIntField(CHAR firstCh) {
+template<typename CHAR>
+int FormatControl<CHAR>::GetIntField(Terminator &terminator, CHAR firstCh) {
   CHAR ch{firstCh ? firstCh : PeekNext()};
-  if (ch < '0' || ch > '9') {
-    context_.terminator.Crash(
+  if (ch != '-' && ch != '+' && (ch < '0' || ch > '9')) {
+    terminator.Crash(
         "Invalid FORMAT: integer expected at '%c'", static_cast<char>(ch));
   }
   int result{0};
+  bool negate{ch == '-'};
+  if (negate) {
+    firstCh = '\0';
+    ch = PeekNext();
+  }
   while (ch >= '0' && ch <= '9') {
     if (result >
         std::numeric_limits<int>::max() / 10 - (static_cast<int>(ch) - '0')) {
-      context_.terminator.Crash("FORMAT integer field out of range");
+      terminator.Crash("FORMAT integer field out of range");
     }
     result = 10 * result + ch - '0';
     if (firstCh) {
@@ -84,11 +89,15 @@ template<typename CHAR> int FormatControl<CHAR>::GetIntField(CHAR firstCh) {
     }
     ch = PeekNext();
   }
+  if (negate && (result *= -1) > 0) {
+    terminator.Crash("FORMAT integer field out of range");
+  }
   return result;
 }
 
-static void HandleControl(MutableModes &modes, std::uint16_t &scale,
-    FormatContext &context, char ch, char next, int n) {
+static void HandleControl(
+    FormatContext &context, std::uint16_t &scale, char ch, char next, int n) {
+  MutableModes &modes{context.mutableModes()};
   switch (ch) {
   case 'B':
     if (next == 'Z') {
@@ -130,9 +139,7 @@ static void HandleControl(MutableModes &modes, std::uint16_t &scale,
     break;
   case 'X':
     if (!next) {
-      if (context.handleRelativePosition) {
-        context.handleRelativePosition(n);
-      }
+      context.HandleRelativePosition(n);
       return;
     }
     break;
@@ -148,25 +155,20 @@ static void HandleControl(MutableModes &modes, std::uint16_t &scale,
     break;
   case 'T': {
     if (!next) {  // Tn
-      if (context.handleAbsolutePosition) {
-        context.handleAbsolutePosition(n);
-      }
+      context.HandleAbsolutePosition(n);
       return;
     }
     if (next == 'L' || next == 'R') {  // TLn & TRn
-      if (context.handleRelativePosition) {
-        context.handleRelativePosition(next == 'L' ? -n : n);
-      }
+      context.HandleRelativePosition(next == 'L' ? -n : n);
       return;
     }
   } break;
   default: break;
   }
   if (next) {
-    context.terminator.Crash(
-        "Unknown '%c%c' edit descriptor in FORMAT", ch, next);
+    context.Crash("Unknown '%c%c' edit descriptor in FORMAT", ch, next);
   } else {
-    context.terminator.Crash("Unknown '%c' edit descriptor in FORMAT", ch);
+    context.Crash("Unknown '%c' edit descriptor in FORMAT", ch);
   }
 }
 
@@ -174,35 +176,34 @@ static void HandleControl(MutableModes &modes, std::uint16_t &scale,
 // Handles all repetition counts and control edit descriptors.
 // Generally assumes that the format string has survived the common
 // format validator gauntlet.
-template<typename CHAR> int FormatControl<CHAR>::CueUpNextDataEdit(bool stop) {
+template<typename CHAR>
+int FormatControl<CHAR>::CueUpNextDataEdit(FormatContext &context, bool stop) {
   int unlimitedLoopCheck{-1};
   while (true) {
     std::optional<int> repeat;
     bool unlimited{false};
-    CHAR ch{Capitalize(GetNextChar())};
+    CHAR ch{Capitalize(GetNextChar(context))};
     while (ch == ',' || ch == ':') {
       // Skip commas, and don't complain if they're missing; the format
       // validator does that.
       if (stop && ch == ':') {
         return 0;
       }
-      ch = Capitalize(GetNextChar());
+      ch = Capitalize(GetNextChar(context));
     }
-    if (ch >= '0' && ch <= '9') {  // repeat count
-      repeat = GetIntField(ch);
-      ch = GetNextChar();
+    if (ch == '-' || ch == '+' || (ch >= '0' && ch <= '9')) {
+      repeat = GetIntField(context, ch);
+      ch = GetNextChar(context);
     } else if (ch == '*') {
       unlimited = true;
-      ch = GetNextChar();
+      ch = GetNextChar(context);
       if (ch != '(') {
-        context_.terminator.Crash(
-            "Invalid FORMAT: '*' may appear only before '('");
+        context.Crash("Invalid FORMAT: '*' may appear only before '('");
       }
     }
     if (ch == '(') {
       if (height_ >= maxHeight_) {
-        context_.terminator.Crash(
-            "FORMAT stack overflow: too many nested parentheses");
+        context.Crash("FORMAT stack overflow: too many nested parentheses");
       }
       stack_[height_].start = offset_ - 1;  // the '('
       if (unlimited || height_ == 0) {
@@ -218,15 +219,18 @@ template<typename CHAR> int FormatControl<CHAR>::CueUpNextDataEdit(bool stop) {
       }
       ++height_;
     } else if (height_ == 0) {
-      context_.terminator.Crash("FORMAT lacks initial '('");
+      context.Crash("FORMAT lacks initial '('");
     } else if (ch == ')') {
-      if (height_ == 1 && stop) {
-        return 0;  // end of FORMAT and no data items remain
+      if (height_ == 1) {
+        if (stop) {
+          return 0;  // end of FORMAT and no data items remain
+        }
+        context.HandleSlash();  // implied / before rightmost )
       }
       if (stack_[height_ - 1].remaining == Iteration::unlimited) {
         offset_ = stack_[height_ - 1].start + 1;
         if (offset_ == unlimitedLoopCheck) {
-          context_.terminator.Crash(
+          context.Crash(
               "Unlimited repetition in FORMAT lacks data edit descriptors");
         }
       } else if (stack_[height_ - 1].remaining-- > 0) {
@@ -242,8 +246,7 @@ template<typename CHAR> int FormatControl<CHAR>::CueUpNextDataEdit(bool stop) {
         ++offset_;
       }
       if (offset_ >= formatLength_) {
-        context_.terminator.Crash(
-            "FORMAT missing closing quote on character literal");
+        context.Crash("FORMAT missing closing quote on character literal");
       }
       ++offset_;
       std::size_t chars{
@@ -255,14 +258,13 @@ template<typename CHAR> int FormatControl<CHAR>::CueUpNextDataEdit(bool stop) {
       } else {
         --chars;
       }
-      HandleCharacterLiteral(context_, format_ + start, chars);
+      context.Emit(format_ + start, chars);
     } else if (ch == 'H') {
       // 9HHOLLERITH
       if (!repeat || *repeat < 1 || offset_ + *repeat > formatLength_) {
-        context_.terminator.Crash("Invalid width on Hollerith in FORMAT");
+        context.Crash("Invalid width on Hollerith in FORMAT");
       }
-      HandleCharacterLiteral(
-          context_, format_ + offset_, static_cast<std::size_t>(*repeat));
+      context.Emit(format_ + offset_, static_cast<std::size_t>(*repeat));
       offset_ += *repeat;
     } else if (ch >= 'A' && ch <= 'Z') {
       int start{offset_ - 1};
@@ -276,35 +278,33 @@ template<typename CHAR> int FormatControl<CHAR>::CueUpNextDataEdit(bool stop) {
                   ch == 'F' || ch == 'D' || ch == 'G'))) {
         // Data edit descriptor found
         offset_ = start;
-        return repeat ? *repeat : 1;
+        return repeat && *repeat > 0 ? *repeat : 1;
       } else {
         // Control edit descriptor
         if (ch == 'T') {  // Tn, TLn, TRn
-          repeat = GetIntField();
+          repeat = GetIntField(context);
         }
-        HandleControl(modes_, scale_, context_, static_cast<char>(ch),
-            static_cast<char>(next), repeat ? *repeat : 1);
+        HandleControl(context, scale_, static_cast<char>(ch),
+            static_cast<char>(next), repeat && *repeat > 0 ? *repeat : 1);
       }
     } else if (ch == '/') {
-      if (context_.handleSlash) {
-        context_.handleSlash();
-      }
+      context.HandleSlash(repeat && *repeat > 0 ? *repeat : 1);
     } else {
-      context_.terminator.Crash(
-          "Invalid character '%c' in FORMAT", static_cast<char>(ch));
+      context.Crash("Invalid character '%c' in FORMAT", static_cast<char>(ch));
     }
   }
 }
 
 template<typename CHAR>
-void FormatControl<CHAR>::GetNext(DataEdit &edit, int maxRepeat) {
+void FormatControl<CHAR>::GetNext(
+    FormatContext &context, DataEdit &edit, int maxRepeat) {
 
   // TODO: DT editing
 
   // Return the next data edit descriptor
-  int repeat{CueUpNextDataEdit()};
+  int repeat{CueUpNextDataEdit(context)};
   auto start{offset_};
-  edit.descriptor = static_cast<char>(Capitalize(GetNextChar()));
+  edit.descriptor = static_cast<char>(Capitalize(GetNextChar(context)));
   if (edit.descriptor == 'E') {
     edit.variation = static_cast<char>(Capitalize(PeekNext()));
     if (edit.variation >= 'A' && edit.variation <= 'Z') {
@@ -316,15 +316,15 @@ void FormatControl<CHAR>::GetNext(DataEdit &edit, int maxRepeat) {
     edit.variation = '\0';
   }
 
-  edit.width = GetIntField();
-  edit.modes = modes_;
+  edit.width = GetIntField(context);
+  edit.modes = context.mutableModes();
   if (PeekNext() == '.') {
     ++offset_;
-    edit.digits = GetIntField();
+    edit.digits = GetIntField(context);
     CHAR ch{PeekNext()};
     if (ch == 'e' || ch == 'E' || ch == 'd' || ch == 'D') {
       ++offset_;
-      edit.expoDigits = GetIntField();
+      edit.expoDigits = GetIntField(context);
     } else {
       edit.expoDigits.reset();
     }
@@ -355,8 +355,9 @@ void FormatControl<CHAR>::GetNext(DataEdit &edit, int maxRepeat) {
   }
 }
 
-template<typename CHAR> void FormatControl<CHAR>::FinishOutput() {
-  CueUpNextDataEdit(true /* stop at colon or end of FORMAT */);
+template<typename CHAR>
+void FormatControl<CHAR>::FinishOutput(FormatContext &context) {
+  CueUpNextDataEdit(context, true /* stop at colon or end of FORMAT */);
 }
 
 template class FormatControl<char>;
diff --git a/runtime/format.h b/runtime/format.h
index 94025f6760db..1f576d24bb46 100644
--- a/runtime/format.h
+++ b/runtime/format.h
@@ -16,7 +16,7 @@
 #include <cinttypes>
 #include <optional>
 
-namespace Fortran::runtime {
+namespace Fortran::runtime::io {
 
 enum EditingFlags {
   blankZero = 1,  // BLANK=ZERO or BZ edit
@@ -27,6 +27,8 @@ enum EditingFlags {
 struct MutableModes {
   std::uint8_t editingFlags{0};  // BN, DP, SS
   common::RoundingMode roundingMode{common::RoundingMode::TiesToEven};  // RN
+  bool pad{false};  // PAD= mode on READ
+  char delim{'\0'};  // DELIM=
 };
 
 // A single edit descriptor extracted from a FORMAT
@@ -40,14 +42,20 @@ struct DataEdit {
   int repeat{1};
 };
 
-struct FormatContext {
-  Terminator &terminator;
-  void (*handleCharacterLiteral1)(const char *, std::size_t){nullptr};
-  void (*handleCharacterLiteral2)(const char16_t *, std::size_t){nullptr};
-  void (*handleCharacterLiteral4)(const char32_t *, std::size_t){nullptr};
-  void (*handleSlash)(){nullptr};
-  void (*handleAbsolutePosition)(int){nullptr};  // Tn
-  void (*handleRelativePosition)(int){nullptr};  // nX, TRn, TLn (negated)
+class FormatContext : virtual public Terminator {
+public:
+  FormatContext() {}
+  explicit FormatContext(const MutableModes &modes) : mutableModes_{modes} {}
+  virtual void Emit(const char *, std::size_t);
+  virtual void Emit(const char16_t *, std::size_t);
+  virtual void Emit(const char32_t *, std::size_t);
+  virtual void HandleSlash(int = 1);
+  virtual void HandleRelativePosition(int);
+  virtual void HandleAbsolutePosition(int);
+  MutableModes &mutableModes() { return mutableModes_; }
+
+private:
+  MutableModes mutableModes_;
 };
 
 // Generates a sequence of DataEdits from a FORMAT statement or
@@ -55,8 +63,8 @@ struct FormatContext {
 // Errors are fatal.  See clause 13.4 in Fortran 2018 for background.
 template<typename CHAR = char> class FormatControl {
 public:
-  FormatControl(FormatContext &, const CHAR *format, std::size_t formatLength,
-      const MutableModes &initialModes, int maxHeight = maxMaxHeight);
+  FormatControl(Terminator &, const CHAR *format, std::size_t formatLength,
+      int maxHeight = maxMaxHeight);
 
   // Determines the max parenthesis nesting level by scanning and validating
   // the FORMAT string.
@@ -71,10 +79,10 @@ template<typename CHAR = char> class FormatControl {
 
   // Extracts the next data edit descriptor, handling control edit descriptors
   // along the way.
-  void GetNext(DataEdit &, int maxRepeat = 1);
+  void GetNext(FormatContext &, DataEdit &, int maxRepeat = 1);
 
   // Emit any remaining character literals after the last data item.
-  void FinishOutput();
+  void FinishOutput(FormatContext &);
 
 private:
   static constexpr std::uint8_t maxMaxHeight{100};
@@ -94,21 +102,21 @@ template<typename CHAR = char> class FormatControl {
     SkipBlanks();
     return offset_ < formatLength_ ? format_[offset_] : '\0';
   }
-  CHAR GetNextChar() {
+  CHAR GetNextChar(Terminator &terminator) {
     SkipBlanks();
     if (offset_ >= formatLength_) {
-      context_.terminator.Crash("FORMAT missing at least one ')'");
+      terminator.Crash("FORMAT missing at least one ')'");
     }
     return format_[offset_++];
   }
-  int GetIntField(CHAR firstCh = '\0');
+  int GetIntField(Terminator &, CHAR firstCh = '\0');
 
   // Advances through the FORMAT until the next data edit
   // descriptor has been found; handles control edit descriptors
   // along the way.  Returns the repeat count that appeared
   // before the descriptor (defaulting to 1) and leaves offset_
   // pointing to the data edit.
-  int CueUpNextDataEdit(bool stop = false);
+  int CueUpNextDataEdit(FormatContext &, bool stop = false);
 
   static constexpr CHAR Capitalize(CHAR ch) {
     return ch >= 'a' && ch <= 'z' ? ch + 'A' - 'a' : ch;
@@ -117,8 +125,6 @@ template<typename CHAR = char> class FormatControl {
   // Data members are arranged and typed so as to reduce size.
   // This structure may be allocated in stack space loaned by the
   // user program for internal I/O.
-  FormatContext &context_;
-  MutableModes modes_;
   std::uint16_t scale_{0};  // kP
   const std::uint8_t maxHeight_{maxMaxHeight};
   std::uint8_t height_{0};
diff --git a/runtime/io-api.cc b/runtime/io-api.cc
new file mode 100644
index 000000000000..a140e0e8cf99
--- /dev/null
+++ b/runtime/io-api.cc
@@ -0,0 +1,31 @@
+//===-- runtime/io.cc -------------------------------------------*- 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 "io-api.h"
+#include "format.h"
+#include "io-stmt.h"
+#include "memory.h"
+#include "terminator.h"
+#include <cstdlib>
+#include <memory>
+
+namespace Fortran::runtime::io {
+
+Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
+    std::size_t internalLength, const char *format, std::size_t formatLength,
+    void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
+    const char *sourceFile, int sourceLine) {
+  Terminator oom{sourceFile, sourceLine};
+  return &New<InternalFormattedIoStatementState<false>>{}(oom, internal,
+      internalLength, format, formatLength, sourceFile, sourceLine);
+}
+
+enum Iostat IONAME(EndIoStatement)(Cookie io) {
+  return static_cast<enum Iostat>(io->EndIoStatement());
+}
+}
diff --git a/runtime/io-api.h b/runtime/io-api.h
index f41308592a44..20f0f218e041 100644
--- a/runtime/io-api.h
+++ b/runtime/io-api.h
@@ -19,7 +19,7 @@
 namespace Fortran::runtime {
 class Descriptor;
 class NamelistGroup;
-};
+}
 
 namespace Fortran::runtime::io {
 
@@ -60,30 +60,32 @@ Cookie IONAME(BeginInternalArrayListInput)(const Descriptor &,
     void **scratchArea = nullptr, std::size_t scratchBytes = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginInternalArrayFormattedOutput)(const Descriptor &,
-    const char *format, std::size_t formatBytes, void **scratchArea = nullptr,
+    const char *format, std::size_t formatLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
 Cookie IONAME(BeginInternalArrayFormattedInput)(const Descriptor &,
-    const char *format, std::size_t formatBytes, void **scratchArea = nullptr,
+    const char *format, std::size_t formatLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
 
 // Internal I/O to/from a default-kind character scalar can avoid a
 // descriptor.
-Cookie IONAME(BeginInternalListOutput)(char *internal, std::size_t bytes,
-    void **scratchArea = nullptr, std::size_t scratchBytes = 0,
-    const char *sourceFile = nullptr, int sourceLine = 0);
-Cookie IONAME(BeginInternalListInput)(char *internal, std::size_t bytes,
-    void **scratchArea = nullptr, std::size_t scratchBytes = 0,
-    const char *sourceFile = nullptr, int sourceLine = 0);
-Cookie IONAME(BeginInternalFormattedOutput)(char *internal, std::size_t bytes,
-    const char *format, std::size_t formatBytes, void **scratchArea = nullptr,
+Cookie IONAME(BeginInternalListOutput)(char *internal,
+    std::size_t internalLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
-Cookie IONAME(BeginInternalFormattedInput)(char *internal, std::size_t bytes,
-    const char *format, std::size_t formatBytes, void **scratchArea = nullptr,
+Cookie IONAME(BeginInternalListInput)(char *internal,
+    std::size_t internalLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
+Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
+    std::size_t internalLength, const char *format, std::size_t formatLength,
+    void **scratchArea = nullptr, std::size_t scratchBytes = 0,
+    const char *sourceFile = nullptr, int sourceLine = 0);
+Cookie IONAME(BeginInternalFormattedInput)(char *internal,
+    std::size_t internalLength, const char *format, std::size_t formatLength,
+    void **scratchArea = nullptr, std::size_t scratchBytes = 0,
+    const char *sourceFile = nullptr, int sourceLine = 0);
 
 // Internal namelist I/O
 Cookie IONAME(BeginInternalNamelistOutput)(const Descriptor &,
@@ -110,10 +112,10 @@ Cookie IONAME(BeginUnformattedOutput)(ExternalUnit = DefaultUnit,
     const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginUnformattedInput)(ExternalUnit = DefaultUnit,
     const char *sourceFile = nullptr, int sourceLine = 0);
-Cookie IONAME(BeginNamelistOutput)(const NamelistGroup &,
+Cookie IONAME(BeginExternalNamelistOutput)(const NamelistGroup &,
     ExternalUnit = DefaultUnit, const char *sourceFile = nullptr,
     int sourceLine = 0);
-Cookie IONAME(BeginNamelistInput)(const NamelistGroup &,
+Cookie IONAME(BeginExternalNamelistInput)(const NamelistGroup &,
     ExternalUnit = DefaultUnit, const char *sourceFile = nullptr,
     int sourceLine = 0);
 
@@ -150,7 +152,8 @@ Cookie IONAME(BeginInquireUnit)(
     ExternalUnit, const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginInquireFile)(const char *, std::size_t, int kind = 1,
     const char *sourceFile = nullptr, int sourceLine = 0);
-Cookie IONAME(BeginInquireIoLength(const char *sourceFile = nullptr, int sourceLine = 0);
+Cookie IONAME(BeginInquireIoLength)(
+    const char *sourceFile = nullptr, int sourceLine = 0);
 
 // If an I/O statement has any IOSTAT=, ERR=, END=, or EOR= specifiers,
 // call EnableHandlers() immediately after the Begin...() call.
@@ -228,28 +231,28 @@ bool IONAME(InputLogical)(Cookie, bool &);
 // SetDelim(), GetIoMsg(), SetPad(), SetRound(), & SetSign()
 // are also acceptable for OPEN.
 // ACCESS=SEQUENTIAL, DIRECT, STREAM
-bool IONAME(SetAccess, Cookie, const char *, std::size_t);
+bool IONAME(SetAccess)(Cookie, const char *, std::size_t);
 // ACTION=READ, WRITE, or READWRITE
-bool IONAME(SetAction, Cookie, const char *, std::size_t);
+bool IONAME(SetAction)(Cookie, const char *, std::size_t);
 // ASYNCHRONOUS=YES, NO
-bool IONAME(SetAsynchronous, Cookie, const char *, std::size_t);
+bool IONAME(SetAsynchronous)(Cookie, const char *, std::size_t);
 // ENCODING=UTF-8, DEFAULT
-bool IONAME(SetEncoding, Cookie, const char *, std::size_t);
+bool IONAME(SetEncoding)(Cookie, const char *, std::size_t);
 // FORM=FORMATTED, UNFORMATTED
-bool IONAME(SetForm, Cookie, const char *, std::size_t);
+bool IONAME(SetForm)(Cookie, const char *, std::size_t);
 // POSITION=ASIS, REWIND, APPEND
-bool IONAME(SetPosition, Cookie, const char *, std::size_t);
-bool IONAME(SetRecl, Cookie, std::size_t);  // RECL=
+bool IONAME(SetPosition)(Cookie, const char *, std::size_t);
+bool IONAME(SetRecl)(Cookie, std::size_t);  // RECL=
 
 // STATUS can be set during an OPEN or CLOSE statement.
 // For OPEN: STATUS=OLD, NEW, SCRATCH, REPLACE, UNKNOWN
 // For CLOSE: STATUS=KEEP, DELETE
-bool IONAME(SetStatus, Cookie, const char *, std::size_t);
+bool IONAME(SetStatus)(Cookie, const char *, std::size_t);
 
 // SetFile() may pass a CHARACTER argument of non-default kind,
 // and such filenames are converted to UTF-8 before being
 // presented to the filesystem.
-bool IONAME(SetFile, Cookie, const char *, std::size_t, int kind = 1);
+bool IONAME(SetFile)(Cookie, const char *, std::size_t, int kind = 1);
 
 // GetNewUnit() must not be called until after all Set...()
 // connection list specifiers have been called after
@@ -271,13 +274,15 @@ void IONAME(GetIoMsg)(Cookie, char *, std::size_t);  // IOMSG=
 // ACCESS, ACTION, ASYNCHRONOUS, BLANK, DECIMAL, DELIM, DIRECT, ENCODING,
 // FORM, FORMATTED, NAME, PAD, POSITION, READ, READWRITE, ROUND,
 // SEQUENTIAL, SIGN, STREAM, UNFORMATTED, WRITE:
-bool IONAME(InquireCharacter)(Cookie, const char *specifier, char *, std::size_t);
+bool IONAME(InquireCharacter)(
+    Cookie, const char *specifier, char *, std::size_t);
 // EXIST, NAMED, OPENED, and PENDING (without ID):
 bool IONAME(InquireLogical)(Cookie, const char *specifier, bool &);
 // PENDING with ID
 bool IONAME(InquirePendingId)(Cookie, std::int64_t, bool &);
 // NEXTREC, NUMBER, POS, RECL, SIZE
-bool IONAME(InquireInteger64)(Cookie, const char *specifier, std::int64_t &, int kind = 8);
+bool IONAME(InquireInteger64)(
+    Cookie, const char *specifier, std::int64_t &, int kind = 8);
 
 // The value of IOSTAT= is zero when no error, end-of-record,
 // or end-of-file condition has arisen; errors are positive values.
@@ -307,6 +312,6 @@ enum Iostat {
 // rather than by terminating the image.
 enum Iostat IONAME(EndIoStatement)(Cookie);
 
-};  // extern "C"
+}  // extern "C"
 }
 #endif
diff --git a/runtime/io-error.cc b/runtime/io-error.cc
new file mode 100644
index 000000000000..74dcef8f3c3e
--- /dev/null
+++ b/runtime/io-error.cc
@@ -0,0 +1,67 @@
+//===-- runtime/io-error.cc -------------------------------------*- 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 "io-error.h"
+#include "magic-numbers.h"
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+
+namespace Fortran::runtime::io {
+
+void IoErrorHandler::Begin(const char *sourceFileName, int sourceLine) {
+  flags_ = 0;
+  ioStat_ = 0;
+  hitEnd_ = false;
+  hitEor_ = false;
+  SetLocation(sourceFileName, sourceLine);
+}
+
+void IoErrorHandler::SignalError(int iostatOrErrno) {
+  if (iostatOrErrno != 0) {
+    if (flags_ & hasIoStat) {
+      if (!ioStat_) {
+        ioStat_ = iostatOrErrno;
+      }
+    } else if (iostatOrErrno == FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT) {
+      Crash("INQUIRE on internal unit");
+    } else {
+      Crash("I/O error %d: %s", iostatOrErrno, std::strerror(iostatOrErrno));
+    }
+  }
+}
+
+void IoErrorHandler::SignalEnd() {
+  if (flags_ & hasEnd) {
+    hitEnd_ = true;
+  } else {
+    Crash("End of file");
+  }
+}
+
+void IoErrorHandler::SignalEor() {
+  if (flags_ & hasEor) {
+    hitEor_ = true;
+  } else {
+    Crash("End of record");
+  }
+}
+
+int IoErrorHandler::GetIoStat() const {
+  if (ioStat_) {
+    return ioStat_;
+  } else if (hitEnd_) {
+    return FORTRAN_RUNTIME_IOSTAT_END;
+  } else if (hitEor_) {
+    return FORTRAN_RUNTIME_IOSTAT_EOR;
+  } else {
+    return 0;
+  }
+}
+
+}
diff --git a/runtime/io-error.h b/runtime/io-error.h
new file mode 100644
index 000000000000..08aea4e9a506
--- /dev/null
+++ b/runtime/io-error.h
@@ -0,0 +1,50 @@
+//===-- runtime/io-error.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
+//
+//===----------------------------------------------------------------------===//
+
+// Distinguishes I/O error conditions; fatal ones lead to termination,
+// and those that the user program has chosen to handle are recorded
+// so that the highest-priority one can be returned as IOSTAT=.
+
+#ifndef FORTRAN_RUNTIME_IO_ERROR_H_
+#define FORTRAN_RUNTIME_IO_ERROR_H_
+
+#include "terminator.h"
+#include <cinttypes>
+
+namespace Fortran::runtime::io {
+
+class IoErrorHandler : virtual public Terminator {
+public:
+  using Terminator::Terminator;
+  void Begin(const char *sourceFileName, int sourceLine);
+  void HasIoStat() { flags_ |= hasIoStat; }
+  void HasErrLabel() { flags_ |= hasErr; }
+  void HasEndLabel() { flags_ |= hasEnd; }
+  void HasEorLabel() { flags_ |= hasEor; }
+
+  void SignalError(int iostatOrErrno);
+  void SignalEnd();
+  void SignalEor();
+
+  int GetIoStat() const;
+
+private:
+  enum Flag : std::uint8_t {
+    hasIoStat = 1,  // IOSTAT=
+    hasErr = 2,  // ERR=
+    hasEnd = 4,  // END=
+    hasEor = 8,  // EOR=
+  };
+  std::uint8_t flags_{0};
+  bool hitEnd_{false};
+  bool hitEor_{false};
+  int ioStat_{0};
+};
+
+}
+#endif  // FORTRAN_RUNTIME_IO_ERROR_H_
diff --git a/runtime/io-stmt.cc b/runtime/io-stmt.cc
new file mode 100644
index 000000000000..221cd2de9c97
--- /dev/null
+++ b/runtime/io-stmt.cc
@@ -0,0 +1,88 @@
+//===-- runtime/io-stmt.cc --------------------------------------*- 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 "io-stmt.h"
+#include "memory.h"
+#include <algorithm>
+#include <cstring>
+
+namespace Fortran::runtime::io {
+
+int IoStatementState::EndIoStatement() { return GetIoStat(); }
+
+int InternalIoStatementState::EndIoStatement() {
+  auto result{GetIoStat()};
+  if (free_) {
+    FreeMemory(this);
+  }
+  return result;
+}
+
+InternalIoStatementState::InternalIoStatementState(
+    const char *sourceFile, int sourceLine)
+  : IoStatementState(sourceFile, sourceLine) {}
+
+template<bool isInput, typename CHAR>
+InternalFormattedIoStatementState<isInput,
+    CHAR>::InternalFormattedIoStatementState(Buffer internal,
+    std::size_t internalLength, const CHAR *format, std::size_t formatLength,
+    const char *sourceFile, int sourceLine)
+  : InternalIoStatementState{sourceFile, sourceLine}, FormatContext{},
+    internal_{internal}, internalLength_{internalLength}, format_{*this, format,
+                                                              formatLength} {
+  std::fill_n(internal_, internalLength_, static_cast<CHAR>(' '));
+}
+
+template<bool isInput, typename CHAR>
+void InternalFormattedIoStatementState<isInput, CHAR>::Emit(
+    const CHAR *data, std::size_t chars) {
+  if constexpr (isInput) {
+    FormatContext::Emit(data, chars);  // default Crash()
+  } else if (at_ + chars > internalLength_) {
+    SignalEor();
+  } else {
+    std::memcpy(internal_ + at_, data, chars * sizeof(CHAR));
+    at_ += chars;
+  }
+}
+
+template<bool isInput, typename CHAR>
+void InternalFormattedIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
+    int n) {
+  if (n < 0 || static_cast<std::size_t>(n) >= internalLength_) {
+    Crash("T%d control edit descriptor is out of range", n);
+  } else {
+    at_ = n;
+  }
+}
+
+template<bool isInput, typename CHAR>
+void InternalFormattedIoStatementState<isInput, CHAR>::HandleRelativePosition(
+    int n) {
+  if (n < 0) {
+    at_ -= std::min(at_, -static_cast<std::size_t>(n));
+  } else {
+    at_ += n;
+    if (at_ > internalLength_) {
+      Crash("TR%d control edit descriptor is out of range", n);
+    }
+  }
+}
+
+template<bool isInput, typename CHAR>
+int InternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
+  format_.FinishOutput(*this);
+  auto result{GetIoStat()};
+  if (free_) {
+    FreeMemory(this);
+  }
+  return result;
+}
+
+template class InternalFormattedIoStatementState<false>;
+}
diff --git a/runtime/io-stmt.h b/runtime/io-stmt.h
new file mode 100644
index 000000000000..2e70efa591be
--- /dev/null
+++ b/runtime/io-stmt.h
@@ -0,0 +1,64 @@
+//===-- runtime/io-stmt.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
+//
+//===----------------------------------------------------------------------===//
+
+// Represents state of an I/O statement in progress
+
+#ifndef FORTRAN_RUNTIME_IO_STMT_H_
+#define FORTRAN_RUNTIME_IO_STMT_H_
+
+#include "descriptor.h"
+#include "format.h"
+#include "io-error.h"
+#include <type_traits>
+
+namespace Fortran::runtime::io {
+
+class IoStatementState : public IoErrorHandler {
+public:
+  using IoErrorHandler::IoErrorHandler;
+  virtual int EndIoStatement();
+
+protected:
+};
+
+class InternalIoStatementState : public IoStatementState {
+public:
+  InternalIoStatementState(const char *sourceFile, int sourceLine);
+  virtual int EndIoStatement();
+
+protected:
+  bool free_{true};
+};
+
+template<bool IsInput, typename CHAR = char>
+class InternalFormattedIoStatementState : public InternalIoStatementState,
+                                          private FormatContext {
+private:
+  using Buffer = std::conditional_t<IsInput, const CHAR *, CHAR *>;
+
+public:
+  InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
+      const CHAR *format, std::size_t formatLength,
+      const char *sourceFile = nullptr, int sourceLine = 0);
+  void Emit(const CHAR *, std::size_t chars);
+  // TODO pmk: void HandleSlash(int);
+  void HandleRelativePosition(int);
+  void HandleAbsolutePosition(int);
+  int EndIoStatement();
+
+private:
+  Buffer internal_;
+  std::size_t internalLength_;
+  std::size_t at_{0};
+  FormatControl<CHAR> format_;  // must be last, may be partial
+};
+
+extern template class InternalFormattedIoStatementState<false>;
+
+}
+#endif  // FORTRAN_RUNTIME_IO_STMT_H_
diff --git a/runtime/magic-numbers.h b/runtime/magic-numbers.h
index b41666a89130..b60722894009 100644
--- a/runtime/magic-numbers.h
+++ b/runtime/magic-numbers.h
@@ -17,6 +17,8 @@ These include:
    to an IOSTAT= or STAT= specifier on a Fortran I/O statement
    or coindexed data reference (see Fortran 2018 12.11.5,
    16.10.2, and 16.10.2.33)
+Codes from <errno.h>, e.g. ENOENT, are assumed to be positive
+and are used "raw" as IOSTAT values.
 #endif
 #ifndef FORTRAN_RUNTIME_MAGIC_NUMBERS_H_
 #define FORTRAN_RUNTIME_MAGIC_NUMBERS_H_
@@ -24,7 +26,7 @@ These include:
 #define FORTRAN_RUNTIME_IOSTAT_END (-1)
 #define FORTRAN_RUNTIME_IOSTAT_EOR (-2)
 #define FORTRAN_RUNTIME_IOSTAT_FLUSH (-3)
-#define FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT 1
+#define FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT 255
 
 #define FORTRAN_RUNTIME_STAT_FAILED_IMAGE 10
 #define FORTRAN_RUNTIME_STAT_LOCKED 11
diff --git a/runtime/main.cc b/runtime/main.cc
index 125261409bda..ce36bc2b9bfa 100644
--- a/runtime/main.cc
+++ b/runtime/main.cc
@@ -7,24 +7,37 @@
 //===----------------------------------------------------------------------===//
 
 #include "main.h"
+#include "io-stmt.h"
 #include "terminator.h"
 #include <cfenv>
+#include <cstdio>
 #include <cstdlib>
+#include <limits>
 
 namespace Fortran::runtime {
-int argc;
-const char **argv;
-const char **envp;
-}
+ExecutionEnvironment executionEnvironment;
 
-extern "C" {
+void ExecutionEnvironment::Configure(
+    int ac, const char *av[], const char *env[]) {
+  argc = ac;
+  argv = av;
+  envp = env;
+  listDirectedOutputLineLengthLimit = 79;  // PGI default
 
-void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[]) {
-
-  Fortran::runtime::argc = argc;
-  Fortran::runtime::argv = argv;
-  Fortran::runtime::envp = envp;
+  if (auto *x{std::getenv("FORT_FMT_RECL")}) {
+    char *end;
+    auto n{std::strtol(x, &end, 10)};
+    if (n > 0 && n < std::numeric_limits<int>::max() && *end == '\0') {
+      listDirectedOutputLineLengthLimit = n;
+    } else {
+      std::fprintf(
+          stderr, "Fortran runtime: FORT_FMT_RECL=%s is invalid; ignored\n", x);
+    }
+  }
+}
+}
 
+static void ConfigureFloatingPoint() {
 #ifdef feclearexcept  // a macro in some environments; omit std::
   feclearexcept(FE_ALL_EXCEPT);
 #else
@@ -35,8 +48,13 @@ void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[]) {
 #else
   std::fesetround(FE_TONEAREST);
 #endif
+}
 
+extern "C" {
+
+void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[]) {
   std::atexit(Fortran::runtime::NotifyOtherImagesOfNormalEnd);
-  // TODO: Runtime configuration settings from environment
+  Fortran::runtime::executionEnvironment.Configure(argc, argv, envp);
+  ConfigureFloatingPoint();
 }
 }
diff --git a/runtime/main.h b/runtime/main.h
index 9a076b96cb7d..c966a3674351 100644
--- a/runtime/main.h
+++ b/runtime/main.h
@@ -1,4 +1,4 @@
-//===-- runtime/main.cc -----------------------------------------*- C++ -*-===//
+//===-- runtime/main.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.
@@ -12,9 +12,15 @@
 #include "entry-names.h"
 
 namespace Fortran::runtime {
-extern int argc;
-extern const char **argv;
-extern const char **envp;
+struct ExecutionEnvironment {
+  void Configure(int argc, const char *argv[], const char *envp[]);
+
+  int argc;
+  const char **argv;
+  const char **envp;
+  int listDirectedOutputLineLengthLimit;
+};
+extern ExecutionEnvironment executionEnvironment;
 }
 
 extern "C" {
diff --git a/runtime/memory.cc b/runtime/memory.cc
new file mode 100644
index 000000000000..ab7c63c24b74
--- /dev/null
+++ b/runtime/memory.cc
@@ -0,0 +1,33 @@
+//===-- runtime/memory.cc ---------------------------------------*- 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 "memory.h"
+#include "terminator.h"
+#include <cstdlib>
+
+namespace Fortran::runtime {
+
+void *AllocateMemoryOrCrash(Terminator &terminator, std::size_t bytes) {
+  if (void *p{std::malloc(bytes)}) {
+    return p;
+  }
+  if (bytes > 0) {
+    terminator.Crash(
+        "Fortran runtime internal error: out of memory, needed %zd bytes",
+        bytes);
+  }
+  return nullptr;
+}
+
+void FreeMemory(void *p) { std::free(p); }
+
+void FreeMemoryAndNullify(void *&p) {
+  std::free(p);
+  p = nullptr;
+}
+}
diff --git a/runtime/memory.h b/runtime/memory.h
new file mode 100644
index 000000000000..f44ceedb3cd1
--- /dev/null
+++ b/runtime/memory.h
@@ -0,0 +1,43 @@
+//===-- runtime/memory.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
+//
+//===----------------------------------------------------------------------===//
+
+// Thin wrapper around malloc()/free() to isolate the dependency,
+// ease porting, and provide an owning pointer.
+
+#ifndef FORTRAN_RUNTIME_MEMORY_H_
+#define FORTRAN_RUNTIME_MEMORY_H_
+
+#include <memory>
+
+namespace Fortran::runtime {
+
+class Terminator;
+
+void *AllocateMemoryOrCrash(Terminator &, std::size_t bytes);
+template<typename A> A &AllocateOrCrash(Terminator &t) {
+  return *reinterpret_cast<A *>(AllocateMemoryOrCrash(t, sizeof(A)));
+}
+void FreeMemory(void *);
+void FreeMemoryAndNullify(void *&);
+
+template<typename A> struct New {
+  template<typename... X> A &operator()(Terminator &terminator, X&&... x) {
+    return *new (AllocateMemoryOrCrash(terminator, sizeof(A))) A{std::forward<X>(x)...};
+  }
+};
+
+namespace {
+template<typename A> class OwningPtrDeleter {
+  void operator()(A *p) { FreeMemory(p); }
+};
+}
+
+template<typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
+}
+
+#endif  // FORTRAN_RUNTIME_MEMORY_H_
diff --git a/runtime/terminator.cc b/runtime/terminator.cc
index 797763854ad6..e2e9b7b327b1 100644
--- a/runtime/terminator.cc
+++ b/runtime/terminator.cc
@@ -35,6 +35,12 @@ namespace Fortran::runtime {
   std::abort();
 }
 
+[[noreturn]] void Terminator::CheckFailed(
+    const char *predicate, const char *file, int line) {
+  Crash("Internal error: RUNTIME_CHECK(%s) failed at %s(%d)", predicate, file,
+      line);
+}
+
 void NotifyOtherImagesOfNormalEnd() {
   // TODO
 }
diff --git a/runtime/terminator.h b/runtime/terminator.h
index 99e0723e7fde..5fe381e5167a 100644
--- a/runtime/terminator.h
+++ b/runtime/terminator.h
@@ -29,12 +29,20 @@ class Terminator {
   }
   [[noreturn]] void Crash(const char *message, ...);
   [[noreturn]] void CrashArgs(const char *message, va_list &);
+  [[noreturn]] void CheckFailed(
+      const char *predicate, const char *file, int line);
 
 private:
   const char *sourceFileName_{nullptr};
   int sourceLine_{0};
 };
 
+#define RUNTIME_CHECK(terminator, pred) \
+  if (pred) \
+    ; \
+  else \
+    (terminator).CheckFailed(#pred, __FILE__, __LINE__)
+
 void NotifyOtherImagesOfNormalEnd();
 void NotifyOtherImagesOfFailImageStatement();
 void NotifyOtherImagesOfErrorTermination();
diff --git a/runtime/transformational.cc b/runtime/transformational.cc
index 7a02bd7edb18..6c1144717e6c 100644
--- a/runtime/transformational.cc
+++ b/runtime/transformational.cc
@@ -8,7 +8,6 @@
 
 #include "transformational.h"
 #include "../lib/common/idioms.h"
-#include "../lib/evaluate/integer.h"
 #include <algorithm>
 #include <bitset>
 #include <cinttypes>
@@ -16,18 +15,12 @@
 
 namespace Fortran::runtime {
 
-template<int BITS> inline std::int64_t LoadInt64(const char *p) {
-  using Int = const evaluate::value::Integer<BITS>;
-  Int *ip{reinterpret_cast<Int *>(p)};
-  return ip->ToInt64();
-}
-
 static inline std::int64_t GetInt64(const char *p, std::size_t bytes) {
   switch (bytes) {
-  case 1: return LoadInt64<8>(p);
-  case 2: return LoadInt64<16>(p);
-  case 4: return LoadInt64<32>(p);
-  case 8: return LoadInt64<64>(p);
+  case 1: return *reinterpret_cast<const std::int8_t *>(p);
+  case 2: return *reinterpret_cast<const std::int16_t *>(p);
+  case 4: return *reinterpret_cast<const std::int32_t *>(p);
+  case 8: return *reinterpret_cast<const std::int64_t *>(p);
   default: CRASH_NO_CASE;
   }
 }
diff --git a/test/runtime/CMakeLists.txt b/test/runtime/CMakeLists.txt
index a9ef7c4ef342..5cbc230d7eed 100644
--- a/test/runtime/CMakeLists.txt
+++ b/test/runtime/CMakeLists.txt
@@ -19,3 +19,13 @@ target_link_libraries(format-test
 )
 
 add_test(Format format-test)
+
+add_executable(hello-world
+  hello.cc
+)
+
+target_link_libraries(hello-world
+  FortranRuntime
+)
+
+add_test(HelloWorld hello-world)
diff --git a/test/runtime/format.cc b/test/runtime/format.cc
index 95d44f16fa9b..50381e85ed05 100644
--- a/test/runtime/format.cc
+++ b/test/runtime/format.cc
@@ -1,5 +1,6 @@
 // Test basic FORMAT string traversal
 #include "../runtime/format.h"
+#include "../runtime/terminator.h"
 #include <cstdarg>
 #include <cstring>
 #include <iostream>
@@ -7,24 +8,50 @@
 #include <string>
 
 using namespace Fortran::runtime;
+using namespace Fortran::runtime::io;
 using namespace std::literals::string_literals;
 
 static int failures{0};
 using Results = std::list<std::string>;
-static Results results;
 
-static void handleCharacterLiteral(const char *s, std::size_t len) {
+// Test harness context for format control
+struct TestFormatContext : virtual public Terminator, public FormatContext {
+  TestFormatContext() : Terminator{"format.cc", 1} {}
+  void Emit(const char *, std::size_t);
+  void HandleSlash(int = 1);
+  void HandleRelativePosition(int);
+  void HandleAbsolutePosition(int);
+  void Report(const DataEdit &);
+  void Check(Results &);
+  Results results;
+};
+
+// Override the runtime's Crash() for testing purposes
+[[noreturn]] void Fortran::runtime::Terminator::Crash(const char *message, ...) {
+  std::va_list ap;
+  va_start(ap, message);
+  char buffer[1000];
+  std::vsnprintf(buffer, sizeof buffer, message, ap);
+  va_end(ap);
+  throw std::string{buffer};
+}
+
+void TestFormatContext::Emit(const char *s, std::size_t len) {
   std::string str{s, len};
   results.push_back("'"s + str + '\'');
 }
 
-static void handleSlash() { results.emplace_back("/"); }
+void TestFormatContext::HandleSlash(int n) {
+  while (n-- > 0) {
+    results.emplace_back("/");
+  }
+}
 
-static void handleAbsolutePosition(int n) {
+void TestFormatContext::HandleAbsolutePosition(int n) {
   results.push_back("T"s + std::to_string(n));
 }
 
-static void handleRelativePosition(int n) {
+void TestFormatContext::HandleRelativePosition(int n) {
   if (n < 0) {
     results.push_back("TL"s + std::to_string(-n));
   } else {
@@ -32,7 +59,7 @@ static void handleRelativePosition(int n) {
   }
 }
 
-static void Report(const DataEdit &edit) {
+void TestFormatContext::Report(const DataEdit &edit) {
   std::string str{edit.descriptor};
   if (edit.repeat != 1) {
     str = std::to_string(edit.repeat) + '*' + str;
@@ -51,17 +78,7 @@ static void Report(const DataEdit &edit) {
   results.push_back(str);
 }
 
-// Override the Crash() in the runtime library
-void Terminator::Crash(const char *message, ...) {
-  std::va_list ap;
-  va_start(ap, message);
-  char buffer[1000];
-  std::vsnprintf(buffer, sizeof buffer, message, ap);
-  va_end(ap);
-  throw std::string{buffer};
-}
-
-static void Check(Results &expect) {
+void TestFormatContext::Check(Results &expect) {
   if (expect != results) {
     std::cerr << "expected:";
     for (const std::string &s : expect) {
@@ -78,37 +95,33 @@ static void Check(Results &expect) {
   results.clear();
 }
 
-static void Test(FormatContext &context, int n, const char *format,
-    Results &&expect, int repeat = 1) {
-  MutableModes modes;
-  FormatControl control{context, format, std::strlen(format), modes};
+static void Test(int n, const char *format, Results &&expect, int repeat = 1) {
+  TestFormatContext context;
+  FormatControl control{context, format, std::strlen(format)};
   try {
     for (int j{0}; j < n; ++j) {
       DataEdit edit;
-      control.GetNext(edit, repeat);
-      Report(edit);
+      control.GetNext(context, edit, repeat);
+      context.Report(edit);
     }
-    control.FinishOutput();
+    control.FinishOutput(context);
   } catch (const std::string &crash) {
-    results.push_back("Crash:"s + crash);
+    context.results.push_back("Crash:"s + crash);
   }
-  Check(expect);
+  context.Check(expect);
 }
 
 int main() {
-  Terminator terminator{"source", 1};
-  FormatContext context{terminator, &handleCharacterLiteral, nullptr, nullptr,
-      &handleSlash, &handleAbsolutePosition, &handleRelativePosition};
-  Test(context, 1, "('PI=',F9.7)", Results{"'PI='", "F9.7"});
-  Test(context, 1, "(3HPI=F9.7)", Results{"'PI='", "F9.7"});
-  Test(context, 1, "(3HPI=/F9.7)", Results{"'PI='", "/", "F9.7"});
-  Test(context, 2, "('PI=',F9.7)", Results{"'PI='", "F9.7", "'PI='", "F9.7"});
-  Test(context, 2, "(2('PI=',F9.7),'done')",
+  Test(1, "('PI=',F9.7)", Results{"'PI='", "F9.7"});
+  Test(1, "(3HPI=F9.7)", Results{"'PI='", "F9.7"});
+  Test(1, "(3HPI=/F9.7)", Results{"'PI='", "/", "F9.7"});
+  Test(2, "('PI=',F9.7)", Results{"'PI='", "F9.7", "/", "'PI='", "F9.7"});
+  Test(2, "(2('PI=',F9.7),'done')",
       Results{"'PI='", "F9.7", "'PI='", "F9.7", "'done'"});
-  Test(context, 2, "(3('PI=',F9.7,:),'tooFar')",
+  Test(2, "(3('PI=',F9.7,:),'tooFar')",
       Results{"'PI='", "F9.7", "'PI='", "F9.7"});
-  Test(context, 2, "(*('PI=',F9.7,:),'tooFar')",
+  Test(2, "(*('PI=',F9.7,:),'tooFar')",
       Results{"'PI='", "F9.7", "'PI='", "F9.7"});
-  Test(context, 1, "(3F9.7)", Results{"2*F9.7"}, 2);
+  Test(1, "(3F9.7)", Results{"2*F9.7"}, 2);
   return failures > 0;
 }
diff --git a/test/runtime/hello.cc b/test/runtime/hello.cc
new file mode 100644
index 000000000000..9c52a01b26a9
--- /dev/null
+++ b/test/runtime/hello.cc
@@ -0,0 +1,33 @@
+// Basic tests of I/O API
+
+#include "../../runtime/io-api.h"
+#include <cstring>
+#include <iostream>
+
+using namespace Fortran::runtime::io;
+
+static int failures{0};
+
+int main() {
+  char buffer[32];
+  const char *format1{"(12HHELLO, WORLD)"};
+  auto cookie{IONAME(BeginInternalFormattedOutput)(buffer, sizeof buffer, format1, std::strlen(format1))};
+  if (auto status{IONAME(EndIoStatement)(cookie)}) {
+    std::cerr << "format1 failed, status " << static_cast<int>(status) << '\n';
+    ++failures;
+  }
+  std::string got1{buffer, sizeof buffer};
+  std::string expect1{"HELLO, WORLD"};
+  expect1.resize(got1.length(), ' ');
+  if (got1 != expect1) {
+    std::cerr << "format1 failed, got '" << got1 << "', expected '" << expect1 << "'\n";
+    ++failures;
+  }
+
+  if (failures == 0) {
+    std::cout << "PASS\n";
+  } else {
+    std::cout << "FAIL " << failures << " tests\n";
+  }
+  return failures > 0;
+}

From 81a5488ee62b4324d002c348464712c930095a32 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Sat, 25 Jan 2020 08:15:17 -0800
Subject: [PATCH 008/345] Fix bugs detecting impure calls

Change Traverse to visit the actual arguments of structure constructors.

Change FindImpureCallHelper to visit the actual arguments of a call to a
pure procedure in case one of them makes a call to an impure function.
---
 lib/evaluate/tools.cc     |  2 +-
 lib/evaluate/traverse.h   | 17 +++++++++++++++--
 test/semantics/call11.f90 | 20 ++++++++++++++++++++
 3 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/lib/evaluate/tools.cc b/lib/evaluate/tools.cc
index 2ea4719b9c1b..2b1b9074aba2 100644
--- a/lib/evaluate/tools.cc
+++ b/lib/evaluate/tools.cc
@@ -828,7 +828,7 @@ class FindImpureCallHelper
     if (auto chars{characteristics::Procedure::Characterize(
             call.proc(), intrinsics_)}) {
       if (chars->attrs.test(characteristics::Procedure::Attr::Pure)) {
-        return std::nullopt;
+        return (*this)(call.arguments());
       }
     }
     return call.proc().GetName();
diff --git a/lib/evaluate/traverse.h b/lib/evaluate/traverse.h
index 9300c9d24d49..2fa8995bf70e 100644
--- a/lib/evaluate/traverse.h
+++ b/lib/evaluate/traverse.h
@@ -85,8 +85,21 @@ template<typename Visitor, typename Result> class Traverse {
     return visitor_.Default();
   }
   Result operator()(const NullPointer &) const { return visitor_.Default(); }
-  template<typename T> Result operator()(const Constant<T> &) const {
-    return visitor_.Default();
+  template<typename T> Result operator()(const Constant<T> &x) const {
+    if constexpr (T::category == TypeCategory::Derived) {
+      std::optional<Result> result;
+      for (const StructureConstructorValues &map : x.values()) {
+        for (const auto &pair : map) {
+          auto value{visitor_(pair.second.value())};
+          result = result
+              ? visitor_.Combine(std::move(*result), std::move(value))
+              : std::move(value);
+        }
+      }
+      return result ? *result : visitor_.Default();
+    } else {
+      return visitor_.Default();
+    }
   }
   Result operator()(const Symbol &) const { return visitor_.Default(); }
   Result operator()(const StaticDataObject &) const {
diff --git a/test/semantics/call11.f90 b/test/semantics/call11.f90
index 2ff18a0b552a..061b73d2d374 100644
--- a/test/semantics/call11.f90
+++ b/test/semantics/call11.f90
@@ -32,12 +32,17 @@ subroutine test
       !ERROR: Impure procedure 'impure' may not be referenced in a FORALL
       a(j) = impure(j) ! C1037
     end forall
+    forall (j=1:1)
+      !ERROR: Impure procedure 'impure' may not be referenced in a FORALL
+      a(j) = pure(impure(j)) ! C1037
+    end forall
     !ERROR: Concurrent-header mask expression cannot reference an impure procedure
     do concurrent (j=1:1, impure(j) /= 0) ! C1121
       !ERROR: Call to an impure procedure is not allowed in DO CONCURRENT
       a(j) = impure(j) ! C1139
     end do
   end subroutine
+
   subroutine test2
     type(t) :: x
     real :: a(x%tbp_pure(1)) ! ok
@@ -59,4 +64,19 @@ subroutine test2
       a(j) = x%tbp_impure(j) ! C1139
     end do
   end subroutine
+
+  subroutine test3
+    type :: t
+      integer :: i
+    end type
+    type(t) :: a(10), b
+    forall (i=1:10)
+      a(i) = t(pure(i))  ! OK
+    end forall
+    forall (i=1:10)
+      !ERROR: Impure procedure 'impure' may not be referenced in a FORALL
+      a(i) = t(impure(i))  ! C1037
+    end forall
+  end subroutine
+
 end module

From 3ba77a0c2035644485737a025cc8912485b56225 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Thu, 23 Jan 2020 16:10:00 -0800
Subject: [PATCH 009/345] Basic file operation wrapper

Asynchronous interfaces and locking
---
 runtime/CMakeLists.txt |   2 +
 runtime/file.cc        | 326 +++++++++++++++++++++++++++++++++++++++++
 runtime/file.h         |  77 ++++++++++
 runtime/io-api.h       |   1 +
 runtime/io-error.cc    |  35 ++---
 runtime/io-error.h     |   5 +-
 runtime/lock.h         |  47 ++++++
 runtime/memory.h       |   9 +-
 runtime/tools.cc       |  51 +++++++
 runtime/tools.h        |  25 ++++
 10 files changed, 550 insertions(+), 28 deletions(-)
 create mode 100644 runtime/file.cc
 create mode 100644 runtime/file.h
 create mode 100644 runtime/lock.h
 create mode 100644 runtime/tools.cc
 create mode 100644 runtime/tools.h

diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index 3253f4b30899..ce42973a7b9c 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -10,6 +10,7 @@ add_library(FortranRuntime
   ISO_Fortran_binding.cc
   derived-type.cc
   descriptor.cc
+  file.cc
   format.cc
   io-api.cc
   io-error.cc
@@ -18,6 +19,7 @@ add_library(FortranRuntime
   memory.cc
   stop.cc
   terminator.cc
+  tools.cc
   transformational.cc
   type-code.cc
 )
diff --git a/runtime/file.cc b/runtime/file.cc
new file mode 100644
index 000000000000..c99db0976690
--- /dev/null
+++ b/runtime/file.cc
@@ -0,0 +1,326 @@
+//===-- runtime/file.cc -----------------------------------------*- 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 "file.h"
+#include "magic-numbers.h"
+#include "memory.h"
+#include "tools.h"
+#include <cerrno>
+#include <cstring>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+namespace Fortran::runtime::io {
+
+void OpenFile::Open(const char *path, std::size_t pathLength,
+    const char *status, std::size_t statusLength, const char *action,
+    std::size_t actionLength, IoErrorHandler &handler) {
+  CriticalSection criticalSection{lock_};
+  RUNTIME_CHECK(handler, fd_ < 0);
+  int flags{0};
+  static const char *actions[]{"READ", "WRITE", "READWRITE", nullptr};
+  switch (IdentifyValue(action, actionLength, actions)) {
+  case 0: flags = O_RDONLY; break;
+  case 1: flags = O_WRONLY; break;
+  case 2: flags = O_RDWR; break;
+  default:
+    handler.Crash(
+        "Invalid ACTION='%.*s'", action, static_cast<int>(actionLength));
+  }
+  if (!status) {
+    status = "UNKNOWN", statusLength = 7;
+  }
+  static const char *statuses[]{
+      "OLD", "NEW", "SCRATCH", "REPLACE", "UNKNOWN", nullptr};
+  switch (IdentifyValue(status, statusLength, statuses)) {
+  case 0:  // STATUS='OLD'
+    if (!path && fd_ >= 0) {
+      // TODO: Update OpenFile in situ; can ACTION be changed?
+      return;
+    }
+    break;
+  case 1:  // STATUS='NEW'
+    flags |= O_CREAT | O_EXCL;
+    break;
+  case 2:  // STATUS='SCRATCH'
+    if (path_.get()) {
+      handler.Crash("FILE= must not appear with STATUS='SCRATCH'");
+      path_.reset();
+    }
+    {
+      char path[]{"/tmp/Fortran-Scratch-XXXXXX"};
+      fd_ = ::mkstemp(path);
+      if (fd_ < 0) {
+        handler.SignalErrno();
+      }
+      ::unlink(path);
+    }
+    return;
+  case 3:  // STATUS='REPLACE'
+    flags |= O_CREAT | O_TRUNC;
+    break;
+  case 4:  // STATUS='UNKNOWN'
+    if (fd_ >= 0) {
+      return;
+    }
+    flags |= O_CREAT;
+    break;
+  default:
+    handler.Crash(
+        "Invalid STATUS='%.*s'", status, static_cast<int>(statusLength));
+  }
+  // If we reach this point, we're opening a new file
+  if (fd_ >= 0) {
+    if (::close(fd_) != 0) {
+      handler.SignalErrno();
+    }
+  }
+  path_ = SaveDefaultCharacter(path, pathLength, handler);
+  if (!path_.get()) {
+    handler.Crash(
+        "FILE= is required unless STATUS='OLD' and unit is connected");
+  }
+  fd_ = ::open(path_.get(), flags, 0600);
+  if (fd_ < 0) {
+    handler.SignalErrno();
+  }
+  pending_.reset();
+  knownSize_.reset();
+}
+
+void OpenFile::Close(
+    const char *status, std::size_t statusLength, IoErrorHandler &handler) {
+  CriticalSection criticalSection{lock_};
+  CheckOpen(handler);
+  pending_.reset();
+  knownSize_.reset();
+  static const char *statuses[]{"KEEP", "DELETE", nullptr};
+  switch (IdentifyValue(status, statusLength, statuses)) {
+  case 0: break;
+  case 1:
+    if (path_.get()) {
+      ::unlink(path_.get());
+    }
+    break;
+  default:
+    if (status) {
+      handler.Crash(
+          "Invalid STATUS='%.*s'", status, static_cast<int>(statusLength));
+    }
+  }
+  path_.reset();
+  if (fd_ >= 0) {
+    if (::close(fd_) != 0) {
+      handler.SignalErrno();
+    }
+    fd_ = -1;
+  }
+}
+
+std::size_t OpenFile::Read(Offset at, char *buffer, std::size_t minBytes,
+    std::size_t maxBytes, IoErrorHandler &handler) {
+  if (maxBytes == 0) {
+    return 0;
+  }
+  CriticalSection criticalSection{lock_};
+  CheckOpen(handler);
+  if (!Seek(at, handler)) {
+    return 0;
+  }
+  if (maxBytes < minBytes) {
+    minBytes = maxBytes;
+  }
+  std::size_t got{0};
+  while (got < minBytes) {
+    auto chunk{::read(fd_, buffer + got, maxBytes - got)};
+    if (chunk == 0) {
+      handler.SignalEnd();
+      break;
+    }
+    if (chunk < 0) {
+      auto err{errno};
+      if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
+        handler.SignalError(err);
+        break;
+      }
+    } else {
+      position_ += chunk;
+      got += chunk;
+    }
+  }
+  return got;
+}
+
+std::size_t OpenFile::Write(
+    Offset at, const char *buffer, std::size_t bytes, IoErrorHandler &handler) {
+  if (bytes == 0) {
+    return 0;
+  }
+  CriticalSection criticalSection{lock_};
+  CheckOpen(handler);
+  if (!Seek(at, handler)) {
+    return 0;
+  }
+  std::size_t put{0};
+  while (put < bytes) {
+    auto chunk{::write(fd_, buffer + put, bytes - put)};
+    if (chunk >= 0) {
+      position_ += chunk;
+      put += chunk;
+    } else {
+      auto err{errno};
+      if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
+        handler.SignalError(err);
+        break;
+      }
+    }
+  }
+  if (knownSize_ && position_ > *knownSize_) {
+    knownSize_ = position_;
+  }
+  return put;
+}
+
+void OpenFile::Truncate(Offset at, IoErrorHandler &handler) {
+  CriticalSection criticalSection{lock_};
+  CheckOpen(handler);
+  if (!knownSize_ || *knownSize_ != at) {
+    if (::ftruncate(fd_, at) != 0) {
+      handler.SignalErrno();
+    }
+    knownSize_ = at;
+  }
+}
+
+// The operation is performed immediately; the results are saved
+// to be claimed by a later WAIT statement.
+// TODO: True asynchronicity
+int OpenFile::ReadAsynchronously(
+    Offset at, char *buffer, std::size_t bytes, IoErrorHandler &handler) {
+  CriticalSection criticalSection{lock_};
+  CheckOpen(handler);
+  int iostat{0};
+  for (std::size_t got{0}; got < bytes;) {
+#if _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
+    auto chunk{::pread(fd_, buffer + got, bytes - got, at)};
+#else
+    auto chunk{RawSeek(at) ? ::read(fd_, buffer + got, bytes - got) : -1};
+#endif
+    if (chunk == 0) {
+      iostat = FORTRAN_RUNTIME_IOSTAT_END;
+      break;
+    }
+    if (chunk < 0) {
+      auto err{errno};
+      if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
+        iostat = err;
+        break;
+      }
+    } else {
+      at += chunk;
+      got += chunk;
+    }
+  }
+  return PendingResult(handler, iostat);
+}
+
+// TODO: True asynchronicity
+int OpenFile::WriteAsynchronously(
+    Offset at, const char *buffer, std::size_t bytes, IoErrorHandler &handler) {
+  CriticalSection criticalSection{lock_};
+  CheckOpen(handler);
+  int iostat{0};
+  for (std::size_t put{0}; put < bytes;) {
+#if _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
+    auto chunk{::pwrite(fd_, buffer + put, bytes - put, at)};
+#else
+    auto chunk{RawSeek(at) ? ::write(fd_, buffer + put, bytes - put) : -1};
+#endif
+    if (chunk >= 0) {
+      at += chunk;
+      put += chunk;
+    } else {
+      auto err{errno};
+      if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
+        iostat = err;
+        break;
+      }
+    }
+  }
+  return PendingResult(handler, iostat);
+}
+
+void OpenFile::Wait(int id, IoErrorHandler &handler) {
+  std::optional<int> ioStat;
+  {
+    CriticalSection criticalSection{lock_};
+    Pending *prev{nullptr};
+    for (Pending *p{pending_.get()}; p; p = (prev = p)->next.get()) {
+      if (p->id == id) {
+        ioStat = p->ioStat;
+        if (prev) {
+          prev->next.reset(p->next.release());
+        } else {
+          pending_.reset(p->next.release());
+        }
+        break;
+      }
+    }
+  }
+  if (ioStat) {
+    handler.SignalError(*ioStat);
+  }
+}
+
+void OpenFile::WaitAll(IoErrorHandler &handler) {
+  while (true) {
+    int ioStat;
+    {
+      CriticalSection criticalSection{lock_};
+      if (pending_) {
+        ioStat = pending_->ioStat;
+        pending_.reset(pending_->next.release());
+      } else {
+        return;
+      }
+    }
+    handler.SignalError(ioStat);
+  }
+}
+
+void OpenFile::CheckOpen(Terminator &terminator) {
+  RUNTIME_CHECK(terminator, fd_ >= 0);
+}
+
+bool OpenFile::Seek(Offset at, IoErrorHandler &handler) {
+  if (at == position_) {
+    return true;
+  } else if (RawSeek(at)) {
+    position_ = at;
+    return true;
+  } else {
+    handler.SignalErrno();
+    return false;
+  }
+}
+
+bool OpenFile::RawSeek(Offset at) {
+#ifdef _LARGEFILE64_SOURCE
+  return ::lseek64(fd_, at, SEEK_SET) == 0;
+#else
+  return ::lseek(fd_, at, SEEK_SET) == 0;
+#endif
+}
+
+int OpenFile::PendingResult(Terminator &terminator, int iostat) {
+  int id{nextId_++};
+  pending_.reset(&New<Pending>{}(terminator, id, iostat, std::move(pending_)));
+  return id;
+}
+}
diff --git a/runtime/file.h b/runtime/file.h
new file mode 100644
index 000000000000..1c0a10d8f754
--- /dev/null
+++ b/runtime/file.h
@@ -0,0 +1,77 @@
+//===-- runtime/file.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
+//
+//===----------------------------------------------------------------------===//
+
+// Raw system I/O wrappers
+
+#ifndef FORTRAN_RUNTIME_FILE_H_
+#define FORTRAN_RUNTIME_FILE_H_
+
+#include "io-error.h"
+#include "lock.h"
+#include "memory.h"
+#include "terminator.h"
+#include <cinttypes>
+#include <optional>
+
+namespace Fortran::runtime::io {
+
+class OpenFile {
+public:
+  using Offset = std::uint64_t;
+
+  Offset position() const { return position_; }
+
+  void Open(const char *path, std::size_t pathLength, const char *status,
+      std::size_t statusLength, const char *action, std::size_t actionLength,
+      IoErrorHandler &);
+  void Close(const char *action, std::size_t actionLength, IoErrorHandler &);
+
+  // Reads data into memory; returns amount acquired.  Synchronous.
+  // Partial reads (less than minBytes) signify end-of-file.  If the
+  // buffer is larger than minBytes, and extra returned data will be
+  // preserved for future consumption, set maxBytes larger than minBytes
+  // to reduce system calls  This routine handles EAGAIN/EWOULDBLOCK and EINTR.
+  std::size_t Read(Offset, char *, std::size_t minBytes, std::size_t maxBytes,
+      IoErrorHandler &);
+
+  // Writes data.  Synchronous.  Partial writes indicate program-handled
+  // error conditions.
+  std::size_t Write(Offset, const char *, std::size_t, IoErrorHandler &);
+
+  // Truncates the file
+  void Truncate(Offset, IoErrorHandler &);
+
+  // Asynchronous transfers
+  int ReadAsynchronously(Offset, char *, std::size_t, IoErrorHandler &);
+  int WriteAsynchronously(Offset, const char *, std::size_t, IoErrorHandler &);
+  void Wait(int id, IoErrorHandler &);
+  void WaitAll(IoErrorHandler &);
+
+private:
+  struct Pending {
+    int id;
+    int ioStat{0};
+    OwningPtr<Pending> next;
+  };
+
+  // lock_ must be held for these
+  void CheckOpen(Terminator &);
+  bool Seek(Offset, IoErrorHandler &);
+  bool RawSeek(Offset);
+  int PendingResult(Terminator &, int);
+
+  Lock lock_;
+  int fd_{-1};
+  OwningPtr<char> path_;
+  Offset position_{0};
+  std::optional<Offset> knownSize_;
+  int nextId_;
+  OwningPtr<Pending> pending_;
+};
+}
+#endif  // FORTRAN_RUNTIME_FILE_H_
diff --git a/runtime/io-api.h b/runtime/io-api.h
index 20f0f218e041..1c1f81ea4c6f 100644
--- a/runtime/io-api.h
+++ b/runtime/io-api.h
@@ -127,6 +127,7 @@ AsynchronousId IONAME(BeginAsynchronousOutput)(ExternalUnit, std::int64_t REC,
 AsynchronousId IONAME(BeginAsynchronousInput)(ExternalUnit, std::int64_t REC,
     char *, std::size_t, const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginWait)(ExternalUnit, AsynchronousId);
+Cookie IONAME(BeginWaitAll)(ExternalUnit);
 
 // Other I/O statements
 Cookie IONAME(BeginClose)(
diff --git a/runtime/io-error.cc b/runtime/io-error.cc
index 74dcef8f3c3e..ccf143ae7b1b 100644
--- a/runtime/io-error.cc
+++ b/runtime/io-error.cc
@@ -17,16 +17,18 @@ namespace Fortran::runtime::io {
 void IoErrorHandler::Begin(const char *sourceFileName, int sourceLine) {
   flags_ = 0;
   ioStat_ = 0;
-  hitEnd_ = false;
-  hitEor_ = false;
   SetLocation(sourceFileName, sourceLine);
 }
 
 void IoErrorHandler::SignalError(int iostatOrErrno) {
-  if (iostatOrErrno != 0) {
+  if (iostatOrErrno == FORTRAN_RUNTIME_IOSTAT_END) {
+    SignalEnd();
+  } else if (iostatOrErrno == FORTRAN_RUNTIME_IOSTAT_EOR) {
+    SignalEor();
+  } else if (iostatOrErrno != 0) {
     if (flags_ & hasIoStat) {
-      if (!ioStat_) {
-        ioStat_ = iostatOrErrno;
+      if (ioStat_ <= 0) {
+        ioStat_ = iostatOrErrno;  // priority over END=/EOR=
       }
     } else if (iostatOrErrno == FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT) {
       Crash("INQUIRE on internal unit");
@@ -36,9 +38,13 @@ void IoErrorHandler::SignalError(int iostatOrErrno) {
   }
 }
 
+void IoErrorHandler::SignalErrno() { SignalError(errno); }
+
 void IoErrorHandler::SignalEnd() {
   if (flags_ & hasEnd) {
-    hitEnd_ = true;
+    if (!ioStat_ || ioStat_ < FORTRAN_RUNTIME_IOSTAT_END) {
+      ioStat_ = FORTRAN_RUNTIME_IOSTAT_END;
+    }
   } else {
     Crash("End of file");
   }
@@ -46,22 +52,11 @@ void IoErrorHandler::SignalEnd() {
 
 void IoErrorHandler::SignalEor() {
   if (flags_ & hasEor) {
-    hitEor_ = true;
+    if (!ioStat_ || ioStat_ < FORTRAN_RUNTIME_IOSTAT_EOR) {
+      ioStat_ = FORTRAN_RUNTIME_IOSTAT_EOR;  // least priority
+    }
   } else {
     Crash("End of record");
   }
 }
-
-int IoErrorHandler::GetIoStat() const {
-  if (ioStat_) {
-    return ioStat_;
-  } else if (hitEnd_) {
-    return FORTRAN_RUNTIME_IOSTAT_END;
-  } else if (hitEor_) {
-    return FORTRAN_RUNTIME_IOSTAT_EOR;
-  } else {
-    return 0;
-  }
-}
-
 }
diff --git a/runtime/io-error.h b/runtime/io-error.h
index 08aea4e9a506..6cab725186e3 100644
--- a/runtime/io-error.h
+++ b/runtime/io-error.h
@@ -28,10 +28,11 @@ class IoErrorHandler : virtual public Terminator {
   void HasEorLabel() { flags_ |= hasEor; }
 
   void SignalError(int iostatOrErrno);
+  void SignalErrno();
   void SignalEnd();
   void SignalEor();
 
-  int GetIoStat() const;
+  int GetIoStat() const { return ioStat_; }
 
 private:
   enum Flag : std::uint8_t {
@@ -41,8 +42,6 @@ class IoErrorHandler : virtual public Terminator {
     hasEor = 8,  // EOR=
   };
   std::uint8_t flags_{0};
-  bool hitEnd_{false};
-  bool hitEor_{false};
   int ioStat_{0};
 };
 
diff --git a/runtime/lock.h b/runtime/lock.h
new file mode 100644
index 000000000000..19f0cea79b01
--- /dev/null
+++ b/runtime/lock.h
@@ -0,0 +1,47 @@
+//===-- runtime/lock.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
+//
+//===----------------------------------------------------------------------===//
+
+// Wraps pthread_mutex_t (or whatever)
+
+#ifndef FORTRAN_RUNTIME_LOCK_H_
+#define FORTRAN_RUNTIME_LOCK_H_
+
+#include <pthread.h>
+
+namespace Fortran::runtime {
+
+class Lock {
+public:
+  Lock() { pthread_mutex_init(&mutex_, nullptr); }
+  ~Lock() { pthread_mutex_destroy(&mutex_); }
+  void Take() { pthread_mutex_lock(&mutex_); }
+  bool Try() { return pthread_mutex_trylock(&mutex_) != 0; }
+  void Drop() { pthread_mutex_unlock(&mutex_); }
+
+  void CheckLocked(Terminator &terminator) {
+    if (Try()) {
+      Drop();
+      terminator.Crash("Lock::CheckLocked() failed");
+    }
+  }
+
+private:
+  pthread_mutex_t mutex_;
+};
+
+class CriticalSection {
+public:
+  explicit CriticalSection(Lock &lock) : lock_{lock} { lock_.Take(); }
+  ~CriticalSection() { lock_.Drop(); }
+
+private:
+  Lock &lock_;
+};
+}
+
+#endif  // FORTRAN_RUNTIME_LOCK_H_
diff --git a/runtime/memory.h b/runtime/memory.h
index f44ceedb3cd1..3e65a98fb224 100644
--- a/runtime/memory.h
+++ b/runtime/memory.h
@@ -26,16 +26,15 @@ void FreeMemory(void *);
 void FreeMemoryAndNullify(void *&);
 
 template<typename A> struct New {
-  template<typename... X> A &operator()(Terminator &terminator, X&&... x) {
-    return *new (AllocateMemoryOrCrash(terminator, sizeof(A))) A{std::forward<X>(x)...};
+  template<typename... X> A &operator()(Terminator &terminator, X &&... x) {
+    return *new (AllocateMemoryOrCrash(terminator, sizeof(A)))
+        A{std::forward<X>(x)...};
   }
 };
 
-namespace {
-template<typename A> class OwningPtrDeleter {
+template<typename A> struct OwningPtrDeleter {
   void operator()(A *p) { FreeMemory(p); }
 };
-}
 
 template<typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
 }
diff --git a/runtime/tools.cc b/runtime/tools.cc
new file mode 100644
index 000000000000..8a9980fa50c7
--- /dev/null
+++ b/runtime/tools.cc
@@ -0,0 +1,51 @@
+//===-- runtime/tools.cc ----------------------------------------*- 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 "tools.h"
+#include <cstring>
+
+namespace Fortran::runtime {
+
+OwningPtr<char> SaveDefaultCharacter(
+    const char *s, std::size_t length, Terminator &terminator) {
+  if (s) {
+    auto *p{static_cast<char *>(AllocateMemoryOrCrash(terminator, length + 1))};
+    std::memcpy(p, s, length);
+    p[length] = '\0';
+    return OwningPtr<char>{p};
+  } else {
+    return OwningPtr<char>{};
+  }
+}
+
+static bool CaseInsensitiveMatch(
+    const char *value, std::size_t length, const char *possibility) {
+  for (; length-- > 0; ++value, ++possibility) {
+    char ch{*value};
+    if (ch >= 'a' && ch <= 'z') {
+      ch += 'A' - 'a';
+    }
+    if (*possibility == '\0' || ch != *possibility) {
+      return false;
+    }
+  }
+  return *possibility == '\0';
+}
+
+int IdentifyValue(
+    const char *value, std::size_t length, const char *possibilities[]) {
+  if (value) {
+    for (int j{0}; possibilities[j]; ++j) {
+      if (CaseInsensitiveMatch(value, length, possibilities[j])) {
+        return j;
+      }
+    }
+  }
+  return -1;
+}
+}
diff --git a/runtime/tools.h b/runtime/tools.h
new file mode 100644
index 000000000000..184f6af63f8e
--- /dev/null
+++ b/runtime/tools.h
@@ -0,0 +1,25 @@
+//===-- runtime/tools.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_RUNTIME_TOOLS_H_
+#define FORTRAN_RUNTIME_TOOLS_H_
+#include "memory.h"
+namespace Fortran::runtime {
+
+class Terminator;
+
+OwningPtr<char> SaveDefaultCharacter(const char *, std::size_t, Terminator &);
+
+// For validating and recognizing default CHARACTER values in a
+// case-insensitive manner.  Returns the zero-based index into the
+// null-terminated array of upper-case possibilities when the value is valid,
+// or -1 when it has no match.
+int IdentifyValue(
+    const char *value, std::size_t length, const char *possibilities[]);
+}
+#endif  // FORTRAN_RUNTIME_TOOLS_H_

From 27d76da2a44614b2c4cf4d576410372cabf66577 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Sun, 26 Jan 2020 10:42:34 -0800
Subject: [PATCH 010/345] Fix bug detecting simply contiguous component

We were always return false when testing a component for simple
contiguity. Change to check that the component is an array that is
simply continguous. Also treat a scalar component of scalar as simply
contiguous.

A pointer with bounds remapping to a complex part is a similar case
so add a test for that too.
---
 lib/evaluate/check-expression.cc |  4 +++-
 test/semantics/assign03.f90      | 25 +++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/lib/evaluate/check-expression.cc b/lib/evaluate/check-expression.cc
index d9b81bd4977f..92dbb76fe15a 100644
--- a/lib/evaluate/check-expression.cc
+++ b/lib/evaluate/check-expression.cc
@@ -283,7 +283,9 @@ class IsSimplyContiguousHelper
   Result operator()(const CoarrayRef &x) const {
     return CheckSubscripts(x.subscript());
   }
-  Result operator()(const Component &) const { return false; }
+  Result operator()(const Component &x) const {
+    return x.base().Rank() == 0 && (*this)(x.GetLastSymbol());
+  }
   Result operator()(const ComplexPart &) const { return false; }
   Result operator()(const Substring &) const { return false; }
 
diff --git a/test/semantics/assign03.f90 b/test/semantics/assign03.f90
index 54112f4f4097..08070fd3ac55 100644
--- a/test/semantics/assign03.f90
+++ b/test/semantics/assign03.f90
@@ -134,4 +134,29 @@ subroutine s9
     p(1:5,1:5) => y(1:100:2)
   end
 
+  subroutine s10
+    integer, pointer :: p(:)
+    type :: t
+      integer :: a(4, 4)
+      integer :: b
+    end type
+    type(t), target :: x
+    type(t), target :: y(10,10)
+    p(1:16) => x%a
+    p(1:1) => x%b  ! We treat scalars as simply contiguous
+    !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
+    p(1:4) => x%a(::2,::2)
+    !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
+    p(1:100) => y(:,:)%b
+  end
+
+  subroutine s11
+    complex, target :: x(10,10)
+    complex, pointer :: p(:)
+    real, pointer :: q(:)
+    p(1:100) => x(:,:)
+    !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
+    q(1:100) => x(:,:)%re
+  end
+
 end

From 21adbc7e05b2454ba3fc725b4697748f98599471 Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Mon, 27 Jan 2020 20:57:59 +0000
Subject: [PATCH 011/345] Moved public headers to include/flang (#943)

---
 .clang-format                                 |  2 +-
 .../flang}/common/Fortran-features.h          |  8 ++--
 {lib => include/flang}/common/Fortran.h       |  2 +-
 .../flang}/common/bit-population-count.h      |  2 +-
 .../flang}/common/constexpr-bitset.h          |  2 +-
 {lib => include/flang}/common/default-kinds.h |  4 +-
 {lib => include/flang}/common/enum-set.h      |  2 +-
 {lib => include/flang}/common/format.h        |  4 +-
 {lib => include/flang}/common/idioms.h        |  2 +-
 {lib => include/flang}/common/indirection.h   |  2 +-
 {lib => include/flang}/common/interval.h      |  2 +-
 .../flang}/common/leading-zero-bit-count.h    |  2 +-
 .../flang}/common/reference-counted.h         |  2 +-
 {lib => include/flang}/common/reference.h     |  2 +-
 {lib => include/flang}/common/restorer.h      |  2 +-
 {lib => include/flang}/common/template.h      |  3 +-
 {lib => include/flang}/common/uint128.h       |  2 +-
 .../flang}/common/unsigned-const-division.h   |  2 +-
 {lib => include/flang}/common/unwrap.h        |  2 +-
 .../flang}/decimal/binary-floating-point.h    |  4 +-
 {lib => include/flang}/decimal/decimal.h      |  2 +-
 {lib => include/flang}/evaluate/call.h        | 10 ++---
 .../flang}/evaluate/characteristics.h         | 14 +++----
 .../flang}/evaluate/check-expression.h        |  2 +-
 {lib => include/flang}/evaluate/common.h      | 18 ++++-----
 {lib => include/flang}/evaluate/complex.h     |  2 +-
 {lib => include/flang}/evaluate/constant.h    |  6 +--
 {lib => include/flang}/evaluate/expression.h  | 12 +++---
 {lib => include/flang}/evaluate/fold.h        |  2 +-
 {lib => include/flang}/evaluate/formatting.h  |  4 +-
 {lib => include/flang}/evaluate/integer.h     |  8 ++--
 .../flang}/evaluate/intrinsics-library.h      |  2 +-
 {lib => include/flang}/evaluate/intrinsics.h  |  8 ++--
 {lib => include/flang}/evaluate/logical.h     |  2 +-
 {lib => include/flang}/evaluate/real.h        |  4 +-
 .../flang}/evaluate/rounding-bits.h           |  2 +-
 {lib => include/flang}/evaluate/shape.h       |  8 ++--
 {lib => include/flang}/evaluate/static-data.h |  4 +-
 {lib => include/flang}/evaluate/tools.h       | 18 ++++-----
 {lib => include/flang}/evaluate/traverse.h    |  6 +--
 {lib => include/flang}/evaluate/type.h        |  8 ++--
 {lib => include/flang}/evaluate/variable.h    | 10 ++---
 {lib => include/flang}/parser/char-block.h    |  4 +-
 {lib => include/flang}/parser/char-buffer.h   |  2 +-
 {lib => include/flang}/parser/char-set.h      |  2 +-
 {lib => include/flang}/parser/characters.h    |  2 +-
 .../flang}/parser/dump-parse-tree.h           |  6 +--
 .../flang}/parser/format-specification.h      |  2 +-
 .../flang}/parser/instrumented-parser.h       |  6 +--
 {lib => include/flang}/parser/message.h       |  8 ++--
 {lib => include/flang}/parser/parse-state.h   | 12 +++---
 .../flang}/parser/parse-tree-visitor.h        |  2 +-
 {lib => include/flang}/parser/parse-tree.h    |  8 ++--
 {lib => include/flang}/parser/parsing.h       |  4 +-
 {lib => include/flang}/parser/provenance.h    |  6 +--
 {lib => include/flang}/parser/source.h        |  2 +-
 {lib => include/flang}/parser/tools.h         |  2 +-
 {lib => include/flang}/parser/unparse.h       |  2 +-
 {lib => include/flang}/parser/user-state.h    | 10 ++---
 {lib => include/flang}/semantics/attr.h       |  6 +--
 {lib => include/flang}/semantics/expression.h | 24 +++++------
 {lib => include/flang}/semantics/scope.h      | 12 +++---
 {lib => include/flang}/semantics/semantics.h  | 10 ++---
 {lib => include/flang}/semantics/symbol.h     |  8 ++--
 {lib => include/flang}/semantics/tools.h      | 20 +++++-----
 {lib => include/flang}/semantics/type.h       | 10 ++---
 .../flang}/semantics/unparse-with-symbols.h   |  4 +-
 lib/common/Fortran-features.cc                |  6 +--
 lib/common/Fortran.cc                         |  2 +-
 lib/common/default-kinds.cc                   |  4 +-
 lib/common/idioms.cc                          |  2 +-
 lib/decimal/big-radix-floating-point.h        | 12 +++---
 lib/decimal/binary-to-decimal.cc              |  2 +-
 lib/decimal/decimal-to-binary.cc              |  8 ++--
 lib/evaluate/call.cc                          | 12 +++---
 lib/evaluate/character.h                      |  2 +-
 lib/evaluate/characteristics.cc               | 20 +++++-----
 lib/evaluate/check-expression.cc              | 10 ++---
 lib/evaluate/common.cc                        |  4 +-
 lib/evaluate/complex.cc                       |  2 +-
 lib/evaluate/constant.cc                      |  8 ++--
 lib/evaluate/expression.cc                    | 12 +++---
 lib/evaluate/fold-implementation.h            | 34 ++++++++--------
 lib/evaluate/fold-logical.cc                  |  2 +-
 lib/evaluate/fold.cc                          |  2 +-
 lib/evaluate/formatting.cc                    | 16 ++++----
 lib/evaluate/host.cc                          |  2 +-
 lib/evaluate/host.h                           |  2 +-
 lib/evaluate/int-power.h                      |  2 +-
 lib/evaluate/integer.cc                       |  2 +-
 lib/evaluate/intrinsics-library-templates.h   |  6 +--
 lib/evaluate/intrinsics.cc                    | 20 +++++-----
 lib/evaluate/logical.cc                       |  2 +-
 lib/evaluate/real.cc                          |  8 ++--
 lib/evaluate/shape.cc                         | 20 +++++-----
 lib/evaluate/static-data.cc                   |  4 +-
 lib/evaluate/tools.cc                         | 10 ++---
 lib/evaluate/type.cc                          | 20 +++++-----
 lib/evaluate/variable.cc                      | 16 ++++----
 lib/parser/Fortran-parsers.cc                 |  4 +-
 lib/parser/basic-parsers.h                    | 16 ++++----
 lib/parser/char-block.cc                      |  2 +-
 lib/parser/char-buffer.cc                     |  4 +-
 lib/parser/char-set.cc                        |  2 +-
 lib/parser/characters.cc                      |  4 +-
 lib/parser/debug-parser.cc                    |  2 +-
 lib/parser/debug-parser.h                     |  2 +-
 lib/parser/executable-parsers.cc              |  4 +-
 lib/parser/expr-parsers.cc                    |  4 +-
 lib/parser/expr-parsers.h                     |  2 +-
 lib/parser/instrumented-parser.cc             |  6 +--
 lib/parser/io-parsers.cc                      |  4 +-
 lib/parser/message.cc                         |  6 +--
 lib/parser/misc-parsers.h                     |  4 +-
 lib/parser/openmp-parsers.cc                  |  2 +-
 lib/parser/parse-tree.cc                      |  8 ++--
 lib/parser/parsing.cc                         |  8 ++--
 lib/parser/preprocessor.cc                    |  6 +--
 lib/parser/preprocessor.h                     |  4 +-
 lib/parser/prescan.cc                         |  8 ++--
 lib/parser/prescan.h                          |  8 ++--
 lib/parser/program-parsers.cc                 |  4 +-
 lib/parser/provenance.cc                      |  4 +-
 lib/parser/source.cc                          |  6 +--
 lib/parser/token-parsers.h                    | 10 ++---
 lib/parser/token-sequence.cc                  |  2 +-
 lib/parser/token-sequence.h                   |  4 +-
 lib/parser/tools.cc                           |  2 +-
 lib/parser/type-parsers.h                     |  4 +-
 lib/parser/unparse.cc                         | 14 +++----
 lib/parser/user-state.cc                      |  4 +-
 lib/semantics/assignment.cc                   | 23 ++++++-----
 lib/semantics/assignment.h                    |  8 ++--
 lib/semantics/attr.cc                         |  4 +-
 lib/semantics/canonicalize-do.cc              |  2 +-
 lib/semantics/canonicalize-omp.cc             |  2 +-
 lib/semantics/check-allocate.cc               | 16 ++++----
 lib/semantics/check-allocate.h                |  2 +-
 lib/semantics/check-arithmeticif.cc           |  6 +--
 lib/semantics/check-arithmeticif.h            |  2 +-
 lib/semantics/check-call.cc                   | 16 ++++----
 lib/semantics/check-call.h                    |  2 +-
 lib/semantics/check-coarray.cc                | 14 +++----
 lib/semantics/check-coarray.h                 |  2 +-
 lib/semantics/check-deallocate.cc             |  8 ++--
 lib/semantics/check-deallocate.h              |  2 +-
 lib/semantics/check-declarations.cc           | 16 ++++----
 lib/semantics/check-do.cc                     | 26 ++++++------
 lib/semantics/check-do.h                      |  4 +-
 lib/semantics/check-if-stmt.cc                |  6 +--
 lib/semantics/check-if-stmt.h                 |  2 +-
 lib/semantics/check-io.cc                     |  8 ++--
 lib/semantics/check-io.h                      |  8 ++--
 lib/semantics/check-nullify.cc                | 10 ++---
 lib/semantics/check-nullify.h                 |  2 +-
 lib/semantics/check-omp-structure.cc          |  4 +-
 lib/semantics/check-omp-structure.h           |  6 +--
 lib/semantics/check-purity.cc                 |  4 +-
 lib/semantics/check-purity.h                  |  2 +-
 lib/semantics/check-return.cc                 |  9 +++--
 lib/semantics/check-return.h                  |  2 +-
 lib/semantics/check-stop.cc                   | 10 ++---
 lib/semantics/check-stop.h                    |  2 +-
 lib/semantics/expression.cc                   | 26 ++++++------
 lib/semantics/mod-file.cc                     | 14 +++----
 lib/semantics/mod-file.h                      |  2 +-
 lib/semantics/pointer-assignment.cc           | 24 +++++------
 lib/semantics/pointer-assignment.h            |  6 +--
 lib/semantics/program-tree.cc                 |  6 +--
 lib/semantics/program-tree.h                  |  4 +-
 lib/semantics/resolve-labels.cc               |  8 ++--
 lib/semantics/resolve-names-utils.cc          | 22 +++++-----
 lib/semantics/resolve-names-utils.h           |  8 ++--
 lib/semantics/resolve-names.cc                | 40 +++++++++----------
 lib/semantics/rewrite-parse-tree.cc           | 16 ++++----
 lib/semantics/scope.cc                        |  8 ++--
 lib/semantics/semantics.cc                    | 14 +++----
 lib/semantics/symbol.cc                       | 12 +++---
 lib/semantics/tools.cc                        | 26 ++++++------
 lib/semantics/type.cc                         | 12 +++---
 lib/semantics/unparse-with-symbols.cc         | 10 ++---
 runtime/derived-type.h                        |  2 +-
 runtime/descriptor.cc                         |  2 +-
 runtime/descriptor.h                          |  2 +-
 runtime/format.cc                             |  4 +-
 runtime/format.h                              |  2 +-
 runtime/transformational.cc                   |  3 +-
 runtime/type-code.h                           |  4 +-
 test/decimal/quick-sanity-test.cc             |  2 +-
 test/decimal/thorough-test.cc                 |  2 +-
 test/evaluate/bit-population-count.cc         |  2 +-
 test/evaluate/expression.cc                   | 10 ++---
 test/evaluate/folding.cc                      | 10 ++---
 test/evaluate/fp-testing.h                    |  2 +-
 test/evaluate/integer.cc                      |  2 +-
 test/evaluate/intrinsics.cc                   | 10 ++---
 test/evaluate/leading-zero-bit-count.cc       |  2 +-
 test/evaluate/logical.cc                      |  2 +-
 test/evaluate/real.cc                         |  2 +-
 test/evaluate/uint128.cc                      |  2 +-
 tools/f18/f18-parse-demo.cc                   | 20 +++++-----
 tools/f18/f18.cc                              | 28 ++++++-------
 tools/f18/stub-evaluate.cc                    |  2 +-
 203 files changed, 713 insertions(+), 709 deletions(-)
 rename {lib => include/flang}/common/Fortran-features.h (94%)
 rename {lib => include/flang}/common/Fortran.h (97%)
 rename {lib => include/flang}/common/bit-population-count.h (98%)
 rename {lib => include/flang}/common/constexpr-bitset.h (98%)
 rename {lib => include/flang}/common/default-kinds.h (96%)
 rename {lib => include/flang}/common/enum-set.h (99%)
 rename {lib => include/flang}/common/format.h (99%)
 rename {lib => include/flang}/common/idioms.h (98%)
 rename {lib => include/flang}/common/indirection.h (98%)
 rename {lib => include/flang}/common/interval.h (98%)
 rename {lib => include/flang}/common/leading-zero-bit-count.h (98%)
 rename {lib => include/flang}/common/reference-counted.h (96%)
 rename {lib => include/flang}/common/reference.h (96%)
 rename {lib => include/flang}/common/restorer.h (95%)
 rename {lib => include/flang}/common/template.h (99%)
 rename {lib => include/flang}/common/uint128.h (99%)
 rename {lib => include/flang}/common/unsigned-const-division.h (97%)
 rename {lib => include/flang}/common/unwrap.h (98%)
 rename {lib => include/flang}/decimal/binary-floating-point.h (97%)
 rename {lib => include/flang}/decimal/decimal.h (98%)
 rename {lib => include/flang}/evaluate/call.h (97%)
 rename {lib => include/flang}/evaluate/characteristics.h (97%)
 rename {lib => include/flang}/evaluate/check-expression.h (97%)
 rename {lib => include/flang}/evaluate/common.h (96%)
 rename {lib => include/flang}/evaluate/complex.h (98%)
 rename {lib => include/flang}/evaluate/constant.h (98%)
 rename {lib => include/flang}/evaluate/expression.h (99%)
 rename {lib => include/flang}/evaluate/fold.h (97%)
 rename {lib => include/flang}/evaluate/formatting.h (94%)
 rename {lib => include/flang}/evaluate/integer.h (99%)
 rename {lib => include/flang}/evaluate/intrinsics-library.h (98%)
 rename {lib => include/flang}/evaluate/intrinsics.h (93%)
 rename {lib => include/flang}/evaluate/logical.h (97%)
 rename {lib => include/flang}/evaluate/real.h (99%)
 rename {lib => include/flang}/evaluate/rounding-bits.h (97%)
 rename {lib => include/flang}/evaluate/shape.h (97%)
 rename {lib => include/flang}/evaluate/static-data.h (95%)
 rename {lib => include/flang}/evaluate/tools.h (98%)
 rename {lib => include/flang}/evaluate/traverse.h (98%)
 rename {lib => include/flang}/evaluate/type.h (99%)
 rename {lib => include/flang}/evaluate/variable.h (98%)
 rename {lib => include/flang}/parser/char-block.h (98%)
 rename {lib => include/flang}/parser/char-buffer.h (97%)
 rename {lib => include/flang}/parser/char-set.h (97%)
 rename {lib => include/flang}/parser/characters.h (99%)
 rename {lib => include/flang}/parser/dump-parse-tree.h (99%)
 rename {lib => include/flang}/parser/format-specification.h (98%)
 rename {lib => include/flang}/parser/instrumented-parser.h (94%)
 rename {lib => include/flang}/parser/message.h (98%)
 rename {lib => include/flang}/parser/parse-state.h (96%)
 rename {lib => include/flang}/parser/parse-tree-visitor.h (99%)
 rename {lib => include/flang}/parser/parse-tree.h (99%)
 rename {lib => include/flang}/parser/parsing.h (95%)
 rename {lib => include/flang}/parser/provenance.h (98%)
 rename {lib => include/flang}/parser/source.h (97%)
 rename {lib => include/flang}/parser/tools.h (97%)
 rename {lib => include/flang}/parser/unparse.h (95%)
 rename {lib => include/flang}/parser/user-state.h (94%)
 rename {lib => include/flang}/semantics/attr.h (92%)
 rename {lib => include/flang}/semantics/expression.h (97%)
 rename {lib => include/flang}/semantics/scope.h (97%)
 rename {lib => include/flang}/semantics/semantics.h (97%)
 rename {lib => include/flang}/semantics/symbol.h (99%)
 rename {lib => include/flang}/semantics/tools.h (98%)
 rename {lib => include/flang}/semantics/type.h (98%)
 rename {lib => include/flang}/semantics/unparse-with-symbols.h (87%)

diff --git a/.clang-format b/.clang-format
index eb459959d4d8..21fb1ae51ac5 100644
--- a/.clang-format
+++ b/.clang-format
@@ -18,7 +18,7 @@ IncludeCategories:
     Priority:        4
   - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
     Priority:        3
-  - Regex:           '^"\.\./'
+  - Regex:           '^"(flang|\.\.)/'
     Priority:        2
   - Regex:           '.*'
     Priority:        1
diff --git a/lib/common/Fortran-features.h b/include/flang/common/Fortran-features.h
similarity index 94%
rename from lib/common/Fortran-features.h
rename to include/flang/common/Fortran-features.h
index bca723d5a793..0b318e90e3af 100644
--- a/lib/common/Fortran-features.h
+++ b/include/flang/common/Fortran-features.h
@@ -1,4 +1,4 @@
-//===-- lib/common/Fortran-features.h ---------------------------*- C++ -*-===//
+//===-- include/flang/common/Fortran-features.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.
@@ -9,9 +9,9 @@
 #ifndef FORTRAN_COMMON_FORTRAN_FEATURES_H_
 #define FORTRAN_COMMON_FORTRAN_FEATURES_H_
 
-#include "Fortran.h"
-#include "enum-set.h"
-#include "idioms.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/enum-set.h"
+#include "flang/common/idioms.h"
 
 namespace Fortran::common {
 
diff --git a/lib/common/Fortran.h b/include/flang/common/Fortran.h
similarity index 97%
rename from lib/common/Fortran.h
rename to include/flang/common/Fortran.h
index c4f367769836..9c73c32dcebb 100644
--- a/lib/common/Fortran.h
+++ b/include/flang/common/Fortran.h
@@ -1,4 +1,4 @@
-//===-- lib/common/Fortran.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/common/Fortran.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.
diff --git a/lib/common/bit-population-count.h b/include/flang/common/bit-population-count.h
similarity index 98%
rename from lib/common/bit-population-count.h
rename to include/flang/common/bit-population-count.h
index fb580efae8bf..0a95643eb71d 100644
--- a/lib/common/bit-population-count.h
+++ b/include/flang/common/bit-population-count.h
@@ -1,4 +1,4 @@
-//===-- lib/common/bit-population-count.h -----------------------*- C++ -*-===//
+//===-- include/flang/common/bit-population-count.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.
diff --git a/lib/common/constexpr-bitset.h b/include/flang/common/constexpr-bitset.h
similarity index 98%
rename from lib/common/constexpr-bitset.h
rename to include/flang/common/constexpr-bitset.h
index 100b5c346b61..1125655adbab 100644
--- a/lib/common/constexpr-bitset.h
+++ b/include/flang/common/constexpr-bitset.h
@@ -1,4 +1,4 @@
-//===-- lib/common/constexpr-bitset.h ---------------------------*- C++ -*-===//
+//===-- include/flang/common/constexpr-bitset.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.
diff --git a/lib/common/default-kinds.h b/include/flang/common/default-kinds.h
similarity index 96%
rename from lib/common/default-kinds.h
rename to include/flang/common/default-kinds.h
index a888e58c5e81..e9532ad8ddcb 100644
--- a/lib/common/default-kinds.h
+++ b/include/flang/common/default-kinds.h
@@ -1,4 +1,4 @@
-//===-- lib/common/default-kinds.h ------------------------------*- C++ -*-===//
+//===-- include/flang/common/default-kinds.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_COMMON_DEFAULT_KINDS_H_
 #define FORTRAN_COMMON_DEFAULT_KINDS_H_
 
-#include "Fortran.h"
+#include "flang/common/Fortran.h"
 #include <cstdint>
 
 namespace Fortran::common {
diff --git a/lib/common/enum-set.h b/include/flang/common/enum-set.h
similarity index 99%
rename from lib/common/enum-set.h
rename to include/flang/common/enum-set.h
index d3f55b34d732..04141808a5b8 100644
--- a/lib/common/enum-set.h
+++ b/include/flang/common/enum-set.h
@@ -1,4 +1,4 @@
-//===-- lib/common/enum-set.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/common/enum-set.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.
diff --git a/lib/common/format.h b/include/flang/common/format.h
similarity index 99%
rename from lib/common/format.h
rename to include/flang/common/format.h
index df056f8a4451..92cd0e94fad9 100644
--- a/lib/common/format.h
+++ b/include/flang/common/format.h
@@ -1,4 +1,4 @@
-//===-- lib/common/format.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/common/format.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.
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_COMMON_FORMAT_H_
 #define FORTRAN_COMMON_FORMAT_H_
 
-#include "Fortran.h"
 #include "enum-set.h"
+#include "flang/common/Fortran.h"
 #include <cstring>
 
 // Define a FormatValidator class template to validate a format expression
diff --git a/lib/common/idioms.h b/include/flang/common/idioms.h
similarity index 98%
rename from lib/common/idioms.h
rename to include/flang/common/idioms.h
index 9e1ea7cf0d61..8debe21acb66 100644
--- a/lib/common/idioms.h
+++ b/include/flang/common/idioms.h
@@ -1,4 +1,4 @@
-//===-- lib/common/idioms.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/common/idioms.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.
diff --git a/lib/common/indirection.h b/include/flang/common/indirection.h
similarity index 98%
rename from lib/common/indirection.h
rename to include/flang/common/indirection.h
index 4e8ea324379d..fcf05549ae7e 100644
--- a/lib/common/indirection.h
+++ b/include/flang/common/indirection.h
@@ -1,4 +1,4 @@
-//===-- lib/common/indirection.h --------------------------------*- C++ -*-===//
+//===-- include/flang/common/indirection.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.
diff --git a/lib/common/interval.h b/include/flang/common/interval.h
similarity index 98%
rename from lib/common/interval.h
rename to include/flang/common/interval.h
index ca8a346c12fe..144f719de7b3 100644
--- a/lib/common/interval.h
+++ b/include/flang/common/interval.h
@@ -1,4 +1,4 @@
-//===-- lib/common/interval.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/common/interval.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.
diff --git a/lib/common/leading-zero-bit-count.h b/include/flang/common/leading-zero-bit-count.h
similarity index 98%
rename from lib/common/leading-zero-bit-count.h
rename to include/flang/common/leading-zero-bit-count.h
index 909ccedbbd3c..fe7bf00378e0 100644
--- a/lib/common/leading-zero-bit-count.h
+++ b/include/flang/common/leading-zero-bit-count.h
@@ -1,4 +1,4 @@
-//===-- lib/common/leading-zero-bit-count.h ---------------------*- C++ -*-===//
+//===-- include/flang/common/leading-zero-bit-count.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.
diff --git a/lib/common/reference-counted.h b/include/flang/common/reference-counted.h
similarity index 96%
rename from lib/common/reference-counted.h
rename to include/flang/common/reference-counted.h
index 64065ff347ee..d7dc68c76492 100644
--- a/lib/common/reference-counted.h
+++ b/include/flang/common/reference-counted.h
@@ -1,4 +1,4 @@
-//===-- lib/common/reference-counted.h --------------------------*- C++ -*-===//
+//===-- include/flang/common/reference-counted.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.
diff --git a/lib/common/reference.h b/include/flang/common/reference.h
similarity index 96%
rename from lib/common/reference.h
rename to include/flang/common/reference.h
index 053f290b06e8..8f01b6587c23 100644
--- a/lib/common/reference.h
+++ b/include/flang/common/reference.h
@@ -1,4 +1,4 @@
-//===-- lib/common/reference.h ----------------------------------*- C++ -*-===//
+//===-- include/flang/common/reference.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.
diff --git a/lib/common/restorer.h b/include/flang/common/restorer.h
similarity index 95%
rename from lib/common/restorer.h
rename to include/flang/common/restorer.h
index 46773450ac25..95b730b83513 100644
--- a/lib/common/restorer.h
+++ b/include/flang/common/restorer.h
@@ -1,4 +1,4 @@
-//===-- lib/common/restorer.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/common/restorer.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.
diff --git a/lib/common/template.h b/include/flang/common/template.h
similarity index 99%
rename from lib/common/template.h
rename to include/flang/common/template.h
index 0d344bbe9e8a..c8a18e704fb4 100644
--- a/lib/common/template.h
+++ b/include/flang/common/template.h
@@ -1,4 +1,4 @@
-//===-- lib/common/template.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/common/template.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.
@@ -9,6 +9,7 @@
 #ifndef FORTRAN_COMMON_TEMPLATE_H_
 #define FORTRAN_COMMON_TEMPLATE_H_
 
+#include "flang/common/idioms.h"
 #include <functional>
 #include <optional>
 #include <tuple>
diff --git a/lib/common/uint128.h b/include/flang/common/uint128.h
similarity index 99%
rename from lib/common/uint128.h
rename to include/flang/common/uint128.h
index 51c29a507789..0129101a1ce9 100644
--- a/lib/common/uint128.h
+++ b/include/flang/common/uint128.h
@@ -1,4 +1,4 @@
-//===-- lib/common/uint128.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/common/uint128.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.
diff --git a/lib/common/unsigned-const-division.h b/include/flang/common/unsigned-const-division.h
similarity index 97%
rename from lib/common/unsigned-const-division.h
rename to include/flang/common/unsigned-const-division.h
index 4e61f0a7f550..749983e8464c 100644
--- a/lib/common/unsigned-const-division.h
+++ b/include/flang/common/unsigned-const-division.h
@@ -1,4 +1,4 @@
-//===-- lib/common/unsigned-const-division.h --------------------*- C++ -*-===//
+//===-- include/flang/common/unsigned-const-division.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.
diff --git a/lib/common/unwrap.h b/include/flang/common/unwrap.h
similarity index 98%
rename from lib/common/unwrap.h
rename to include/flang/common/unwrap.h
index ce066b9f8512..1370b1425202 100644
--- a/lib/common/unwrap.h
+++ b/include/flang/common/unwrap.h
@@ -1,4 +1,4 @@
-//===-- lib/common/unwrap.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/common/unwrap.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.
diff --git a/lib/decimal/binary-floating-point.h b/include/flang/decimal/binary-floating-point.h
similarity index 97%
rename from lib/decimal/binary-floating-point.h
rename to include/flang/decimal/binary-floating-point.h
index ece7518bb9e0..3da4a336c50e 100644
--- a/lib/decimal/binary-floating-point.h
+++ b/include/flang/decimal/binary-floating-point.h
@@ -1,4 +1,4 @@
-//===-- lib/decimal/binary-floating-point.h ---------------------*- C++ -*-===//
+//===-- include/flang/decimal/binary-floating-point.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.
@@ -12,7 +12,7 @@
 // Access and manipulate the fields of an IEEE-754 binary
 // floating-point value via a generalized template.
 
-#include "../common/uint128.h"
+#include "flang/common/uint128.h"
 #include <cinttypes>
 #include <climits>
 #include <cstring>
diff --git a/lib/decimal/decimal.h b/include/flang/decimal/decimal.h
similarity index 98%
rename from lib/decimal/decimal.h
rename to include/flang/decimal/decimal.h
index a8f46f95a1c5..812d08fe8d09 100644
--- a/lib/decimal/decimal.h
+++ b/include/flang/decimal/decimal.h
@@ -1,4 +1,4 @@
-/*===-- lib/decimal/decimal.h -------------------------------------*- C++ -*-===
+/*===-- include/flang/decimal/decimal.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.
diff --git a/lib/evaluate/call.h b/include/flang/evaluate/call.h
similarity index 97%
rename from lib/evaluate/call.h
rename to include/flang/evaluate/call.h
index 5a048da773ac..97d1ea1b04f9 100644
--- a/lib/evaluate/call.h
+++ b/include/flang/evaluate/call.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/call.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/call.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.
@@ -13,10 +13,10 @@
 #include "constant.h"
 #include "formatting.h"
 #include "type.h"
-#include "../common/indirection.h"
-#include "../common/reference.h"
-#include "../parser/char-block.h"
-#include "../semantics/attr.h"
+#include "flang/common/indirection.h"
+#include "flang/common/reference.h"
+#include "flang/parser/char-block.h"
+#include "flang/semantics/attr.h"
 #include <optional>
 #include <ostream>
 #include <vector>
diff --git a/lib/evaluate/characteristics.h b/include/flang/evaluate/characteristics.h
similarity index 97%
rename from lib/evaluate/characteristics.h
rename to include/flang/evaluate/characteristics.h
index 3da4d63c5fd3..9e61602579e7 100644
--- a/lib/evaluate/characteristics.h
+++ b/include/flang/evaluate/characteristics.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/characteristics.h --------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/characteristics.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.
@@ -17,12 +17,12 @@
 #include "expression.h"
 #include "shape.h"
 #include "type.h"
-#include "../common/Fortran.h"
-#include "../common/enum-set.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
-#include "../parser/char-block.h"
-#include "../semantics/symbol.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/enum-set.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
+#include "flang/parser/char-block.h"
+#include "flang/semantics/symbol.h"
 #include <optional>
 #include <ostream>
 #include <string>
diff --git a/lib/evaluate/check-expression.h b/include/flang/evaluate/check-expression.h
similarity index 97%
rename from lib/evaluate/check-expression.h
rename to include/flang/evaluate/check-expression.h
index b19d747729e6..31a79fb19585 100644
--- a/lib/evaluate/check-expression.h
+++ b/include/flang/evaluate/check-expression.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/check-expression.h -------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/check-expression.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.
diff --git a/lib/evaluate/common.h b/include/flang/evaluate/common.h
similarity index 96%
rename from lib/evaluate/common.h
rename to include/flang/evaluate/common.h
index e716d2198c4e..f24e93d7cd33 100644
--- a/lib/evaluate/common.h
+++ b/include/flang/evaluate/common.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/common.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/common.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.
@@ -10,14 +10,14 @@
 #define FORTRAN_EVALUATE_COMMON_H_
 
 #include "intrinsics-library.h"
-#include "../common/Fortran.h"
-#include "../common/default-kinds.h"
-#include "../common/enum-set.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
-#include "../common/restorer.h"
-#include "../parser/char-block.h"
-#include "../parser/message.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/default-kinds.h"
+#include "flang/common/enum-set.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
+#include "flang/common/restorer.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/message.h"
 #include <cinttypes>
 #include <map>
 
diff --git a/lib/evaluate/complex.h b/include/flang/evaluate/complex.h
similarity index 98%
rename from lib/evaluate/complex.h
rename to include/flang/evaluate/complex.h
index 8d3520363b73..201cbcea60ab 100644
--- a/lib/evaluate/complex.h
+++ b/include/flang/evaluate/complex.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/complex.h ----------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/complex.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.
diff --git a/lib/evaluate/constant.h b/include/flang/evaluate/constant.h
similarity index 98%
rename from lib/evaluate/constant.h
rename to include/flang/evaluate/constant.h
index 290343b98d75..833702a03c91 100644
--- a/lib/evaluate/constant.h
+++ b/include/flang/evaluate/constant.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/constant.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/constant.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.
@@ -11,8 +11,8 @@
 
 #include "formatting.h"
 #include "type.h"
-#include "../common/default-kinds.h"
-#include "../common/reference.h"
+#include "flang/common/default-kinds.h"
+#include "flang/common/reference.h"
 #include <map>
 #include <ostream>
 #include <vector>
diff --git a/lib/evaluate/expression.h b/include/flang/evaluate/expression.h
similarity index 99%
rename from lib/evaluate/expression.h
rename to include/flang/evaluate/expression.h
index 00363b523d5d..b06119107ef8 100644
--- a/lib/evaluate/expression.h
+++ b/include/flang/evaluate/expression.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/expression.h -------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/expression.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.
@@ -21,11 +21,11 @@
 #include "formatting.h"
 #include "type.h"
 #include "variable.h"
-#include "../common/Fortran.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
-#include "../common/template.h"
-#include "../parser/char-block.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
+#include "flang/common/template.h"
+#include "flang/parser/char-block.h"
 #include <algorithm>
 #include <list>
 #include <ostream>
diff --git a/lib/evaluate/fold.h b/include/flang/evaluate/fold.h
similarity index 97%
rename from lib/evaluate/fold.h
rename to include/flang/evaluate/fold.h
index 88daa51ee18b..5f33d69a2fe6 100644
--- a/lib/evaluate/fold.h
+++ b/include/flang/evaluate/fold.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/fold.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.
diff --git a/lib/evaluate/formatting.h b/include/flang/evaluate/formatting.h
similarity index 94%
rename from lib/evaluate/formatting.h
rename to include/flang/evaluate/formatting.h
index 4774b4bbd27a..a2b8458d042f 100644
--- a/lib/evaluate/formatting.h
+++ b/include/flang/evaluate/formatting.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/formatting.h -------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/formatting.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.
@@ -19,7 +19,7 @@
 // This header is meant to be included by the headers that define the several
 // representational class templates that need it, not by external clients.
 
-#include "../common/indirection.h"
+#include "flang/common/indirection.h"
 #include <optional>
 #include <ostream>
 #include <type_traits>
diff --git a/lib/evaluate/integer.h b/include/flang/evaluate/integer.h
similarity index 99%
rename from lib/evaluate/integer.h
rename to include/flang/evaluate/integer.h
index 78f9b84d4a21..1bff2bb7b7ca 100644
--- a/lib/evaluate/integer.h
+++ b/include/flang/evaluate/integer.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/integer.h ----------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/integer.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.
@@ -17,9 +17,9 @@
 // (*"Signed" here means two's-complement, just to be clear.  Ones'-complement
 // and signed-magnitude encodings appear to be extinct in 2018.)
 
-#include "common.h"
-#include "../common/bit-population-count.h"
-#include "../common/leading-zero-bit-count.h"
+#include "flang/common/bit-population-count.h"
+#include "flang/common/leading-zero-bit-count.h"
+#include "flang/evaluate/common.h"
 #include <cinttypes>
 #include <climits>
 #include <cstddef>
diff --git a/lib/evaluate/intrinsics-library.h b/include/flang/evaluate/intrinsics-library.h
similarity index 98%
rename from lib/evaluate/intrinsics-library.h
rename to include/flang/evaluate/intrinsics-library.h
index a558add87069..a7a1959a22bb 100644
--- a/lib/evaluate/intrinsics-library.h
+++ b/include/flang/evaluate/intrinsics-library.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/intrinsics-library.h -----------------------*- C++ -*-===//
+//===-- include/flang/evaluate/intrinsics-library.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.
diff --git a/lib/evaluate/intrinsics.h b/include/flang/evaluate/intrinsics.h
similarity index 93%
rename from lib/evaluate/intrinsics.h
rename to include/flang/evaluate/intrinsics.h
index 036a401edc47..525e0907a159 100644
--- a/lib/evaluate/intrinsics.h
+++ b/include/flang/evaluate/intrinsics.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/intrinsics.h -------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/intrinsics.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.
@@ -12,9 +12,9 @@
 #include "call.h"
 #include "characteristics.h"
 #include "type.h"
-#include "../common/default-kinds.h"
-#include "../parser/char-block.h"
-#include "../parser/message.h"
+#include "flang/common/default-kinds.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/message.h"
 #include <optional>
 #include <ostream>
 #include <string>
diff --git a/lib/evaluate/logical.h b/include/flang/evaluate/logical.h
similarity index 97%
rename from lib/evaluate/logical.h
rename to include/flang/evaluate/logical.h
index e98637acf553..d76abf854d6a 100644
--- a/lib/evaluate/logical.h
+++ b/include/flang/evaluate/logical.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/logical.h ----------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/logical.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.
diff --git a/lib/evaluate/real.h b/include/flang/evaluate/real.h
similarity index 99%
rename from lib/evaluate/real.h
rename to include/flang/evaluate/real.h
index 92bb7d19d33a..84e2d556baf3 100644
--- a/lib/evaluate/real.h
+++ b/include/flang/evaluate/real.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/real.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/real.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.
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_EVALUATE_REAL_H_
 #define FORTRAN_EVALUATE_REAL_H_
 
-#include "common.h"
 #include "formatting.h"
 #include "integer.h"
 #include "rounding-bits.h"
+#include "flang/evaluate/common.h"
 #include <cinttypes>
 #include <limits>
 #include <ostream>
diff --git a/lib/evaluate/rounding-bits.h b/include/flang/evaluate/rounding-bits.h
similarity index 97%
rename from lib/evaluate/rounding-bits.h
rename to include/flang/evaluate/rounding-bits.h
index 07db7ce40d13..bc5771659595 100644
--- a/lib/evaluate/rounding-bits.h
+++ b/include/flang/evaluate/rounding-bits.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/rounding-bits.h ----------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/rounding-bits.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.
diff --git a/lib/evaluate/shape.h b/include/flang/evaluate/shape.h
similarity index 97%
rename from lib/evaluate/shape.h
rename to include/flang/evaluate/shape.h
index 15e16eb4665e..ca9700b02583 100644
--- a/lib/evaluate/shape.h
+++ b/include/flang/evaluate/shape.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/shape.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/shape.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.
@@ -13,11 +13,11 @@
 #define FORTRAN_EVALUATE_SHAPE_H_
 
 #include "expression.h"
-#include "tools.h"
 #include "traverse.h"
-#include "type.h"
 #include "variable.h"
-#include "../common/indirection.h"
+#include "flang/common/indirection.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/type.h"
 #include <optional>
 #include <variant>
 
diff --git a/lib/evaluate/static-data.h b/include/flang/evaluate/static-data.h
similarity index 95%
rename from lib/evaluate/static-data.h
rename to include/flang/evaluate/static-data.h
index 902dcff20eed..ce66351ba140 100644
--- a/lib/evaluate/static-data.h
+++ b/include/flang/evaluate/static-data.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/static-data.h ------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/static-data.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.
@@ -13,7 +13,7 @@
 
 #include "formatting.h"
 #include "type.h"
-#include "../common/idioms.h"
+#include "flang/common/idioms.h"
 #include <cinttypes>
 #include <memory>
 #include <optional>
diff --git a/lib/evaluate/tools.h b/include/flang/evaluate/tools.h
similarity index 98%
rename from lib/evaluate/tools.h
rename to include/flang/evaluate/tools.h
index 5b2824a41bfb..9a473619d5b0 100644
--- a/lib/evaluate/tools.h
+++ b/include/flang/evaluate/tools.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/tools.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/tools.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.
@@ -9,15 +9,15 @@
 #ifndef FORTRAN_EVALUATE_TOOLS_H_
 #define FORTRAN_EVALUATE_TOOLS_H_
 
-#include "constant.h"
-#include "expression.h"
 #include "traverse.h"
-#include "../common/idioms.h"
-#include "../common/template.h"
-#include "../common/unwrap.h"
-#include "../parser/message.h"
-#include "../semantics/attr.h"
-#include "../semantics/symbol.h"
+#include "flang/common/idioms.h"
+#include "flang/common/template.h"
+#include "flang/common/unwrap.h"
+#include "flang/evaluate/constant.h"
+#include "flang/evaluate/expression.h"
+#include "flang/parser/message.h"
+#include "flang/semantics/attr.h"
+#include "flang/semantics/symbol.h"
 #include <array>
 #include <optional>
 #include <set>
diff --git a/lib/evaluate/traverse.h b/include/flang/evaluate/traverse.h
similarity index 98%
rename from lib/evaluate/traverse.h
rename to include/flang/evaluate/traverse.h
index 2fa8995bf70e..326104b1e1ce 100644
--- a/lib/evaluate/traverse.h
+++ b/include/flang/evaluate/traverse.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/traverse.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/traverse.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.
@@ -35,8 +35,8 @@
 // - Overloads of operator() in each visitor handle the cases of interest.
 
 #include "expression.h"
-#include "../semantics/symbol.h"
-#include "../semantics/type.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/type.h"
 #include <set>
 #include <type_traits>
 
diff --git a/lib/evaluate/type.h b/include/flang/evaluate/type.h
similarity index 99%
rename from lib/evaluate/type.h
rename to include/flang/evaluate/type.h
index 91a7c6011065..29dde4eeb1a4 100644
--- a/lib/evaluate/type.h
+++ b/include/flang/evaluate/type.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/type.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/type.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.
@@ -22,9 +22,9 @@
 #include "integer.h"
 #include "logical.h"
 #include "real.h"
-#include "../common/Fortran.h"
-#include "../common/idioms.h"
-#include "../common/template.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/idioms.h"
+#include "flang/common/template.h"
 #include <cinttypes>
 #include <optional>
 #include <string>
diff --git a/lib/evaluate/variable.h b/include/flang/evaluate/variable.h
similarity index 98%
rename from lib/evaluate/variable.h
rename to include/flang/evaluate/variable.h
index 15cd63874968..bbbdd7c74903 100644
--- a/lib/evaluate/variable.h
+++ b/include/flang/evaluate/variable.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/variable.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/evaluate/variable.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.
@@ -20,10 +20,10 @@
 #include "formatting.h"
 #include "static-data.h"
 #include "type.h"
-#include "../common/idioms.h"
-#include "../common/reference.h"
-#include "../common/template.h"
-#include "../parser/char-block.h"
+#include "flang/common/idioms.h"
+#include "flang/common/reference.h"
+#include "flang/common/template.h"
+#include "flang/parser/char-block.h"
 #include <optional>
 #include <ostream>
 #include <variant>
diff --git a/lib/parser/char-block.h b/include/flang/parser/char-block.h
similarity index 98%
rename from lib/parser/char-block.h
rename to include/flang/parser/char-block.h
index 3f5585e868bb..f05211fa8845 100644
--- a/lib/parser/char-block.h
+++ b/include/flang/parser/char-block.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-block.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/parser/char-block.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.
@@ -11,7 +11,7 @@
 
 // Describes a contiguous block of characters; does not own their storage.
 
-#include "../common/interval.h"
+#include "flang/common/interval.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
diff --git a/lib/parser/char-buffer.h b/include/flang/parser/char-buffer.h
similarity index 97%
rename from lib/parser/char-buffer.h
rename to include/flang/parser/char-buffer.h
index c5c0c8a51078..b9f66c6f3dde 100644
--- a/lib/parser/char-buffer.h
+++ b/include/flang/parser/char-buffer.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-buffer.h --------------------------------*- C++ -*-===//
+//===-- include/flang/parser/char-buffer.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.
diff --git a/lib/parser/char-set.h b/include/flang/parser/char-set.h
similarity index 97%
rename from lib/parser/char-set.h
rename to include/flang/parser/char-set.h
index 6f041b241c0a..9bac7ea01180 100644
--- a/lib/parser/char-set.h
+++ b/include/flang/parser/char-set.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-set.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/parser/char-set.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.
diff --git a/lib/parser/characters.h b/include/flang/parser/characters.h
similarity index 99%
rename from lib/parser/characters.h
rename to include/flang/parser/characters.h
index ceb7aa18d4bc..102d886d3a0b 100644
--- a/lib/parser/characters.h
+++ b/include/flang/parser/characters.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/characters.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/parser/characters.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.
diff --git a/lib/parser/dump-parse-tree.h b/include/flang/parser/dump-parse-tree.h
similarity index 99%
rename from lib/parser/dump-parse-tree.h
rename to include/flang/parser/dump-parse-tree.h
index 1ebbbbd6c7ea..aca18137f955 100644
--- a/lib/parser/dump-parse-tree.h
+++ b/include/flang/parser/dump-parse-tree.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/dump-parse-tree.h ----------------------------*- C++ -*-===//
+//===-- include/flang/parser/dump-parse-tree.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.
@@ -13,8 +13,8 @@
 #include "parse-tree-visitor.h"
 #include "parse-tree.h"
 #include "unparse.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
 #include <ostream>
 #include <sstream>
 #include <string>
diff --git a/lib/parser/format-specification.h b/include/flang/parser/format-specification.h
similarity index 98%
rename from lib/parser/format-specification.h
rename to include/flang/parser/format-specification.h
index 64bce964a8ec..6f1de183a30e 100644
--- a/lib/parser/format-specification.h
+++ b/include/flang/parser/format-specification.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/format-specification.h -----------------------*- C++ -*-===//
+//===-- include/flang/parser/format-specification.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.
diff --git a/lib/parser/instrumented-parser.h b/include/flang/parser/instrumented-parser.h
similarity index 94%
rename from lib/parser/instrumented-parser.h
rename to include/flang/parser/instrumented-parser.h
index 66bb73e5fbf1..ec760a610a08 100644
--- a/lib/parser/instrumented-parser.h
+++ b/include/flang/parser/instrumented-parser.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/instrumented-parser.h ------------------------*- C++ -*-===//
+//===-- include/flang/parser/instrumented-parser.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.
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_PARSER_INSTRUMENTED_PARSER_H_
 #define FORTRAN_PARSER_INSTRUMENTED_PARSER_H_
 
-#include "message.h"
 #include "parse-state.h"
-#include "provenance.h"
 #include "user-state.h"
+#include "flang/parser/message.h"
+#include "flang/parser/provenance.h"
 #include <cstddef>
 #include <map>
 #include <ostream>
diff --git a/lib/parser/message.h b/include/flang/parser/message.h
similarity index 98%
rename from lib/parser/message.h
rename to include/flang/parser/message.h
index eb946c2bb2fd..fd62f4671f55 100644
--- a/lib/parser/message.h
+++ b/include/flang/parser/message.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/message.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/parser/message.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.
@@ -15,9 +15,9 @@
 #include "char-block.h"
 #include "char-set.h"
 #include "provenance.h"
-#include "../common/idioms.h"
-#include "../common/reference-counted.h"
-#include "../common/restorer.h"
+#include "flang/common/idioms.h"
+#include "flang/common/reference-counted.h"
+#include "flang/common/restorer.h"
 #include <cstddef>
 #include <cstring>
 #include <forward_list>
diff --git a/lib/parser/parse-state.h b/include/flang/parser/parse-state.h
similarity index 96%
rename from lib/parser/parse-state.h
rename to include/flang/parser/parse-state.h
index 03bfaba96d42..afd4516403a3 100644
--- a/lib/parser/parse-state.h
+++ b/include/flang/parser/parse-state.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/parse-state.h --------------------------------*- C++ -*-===//
+//===-- include/flang/parser/parse-state.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.
@@ -15,12 +15,12 @@
 // attempts.  Must be efficient to duplicate and assign for backtracking
 // and recovery during parsing!
 
-#include "characters.h"
-#include "message.h"
-#include "provenance.h"
 #include "user-state.h"
-#include "../common/Fortran-features.h"
-#include "../common/idioms.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/message.h"
+#include "flang/parser/provenance.h"
 #include <cstddef>
 #include <cstring>
 #include <list>
diff --git a/lib/parser/parse-tree-visitor.h b/include/flang/parser/parse-tree-visitor.h
similarity index 99%
rename from lib/parser/parse-tree-visitor.h
rename to include/flang/parser/parse-tree-visitor.h
index 2fac69278593..b2c49fe48034 100644
--- a/lib/parser/parse-tree-visitor.h
+++ b/include/flang/parser/parse-tree-visitor.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/parse-tree-visitor.h -------------------------*- C++ -*-===//
+//===-- include/flang/parser/parse-tree-visitor.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.
diff --git a/lib/parser/parse-tree.h b/include/flang/parser/parse-tree.h
similarity index 99%
rename from lib/parser/parse-tree.h
rename to include/flang/parser/parse-tree.h
index e94432e0bad5..29638957f35b 100644
--- a/lib/parser/parse-tree.h
+++ b/include/flang/parser/parse-tree.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/parse-tree.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/parser/parse-tree.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.
@@ -22,9 +22,9 @@
 #include "format-specification.h"
 #include "message.h"
 #include "provenance.h"
-#include "../common/Fortran.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
 #include <cinttypes>
 #include <list>
 #include <memory>
diff --git a/lib/parser/parsing.h b/include/flang/parser/parsing.h
similarity index 95%
rename from lib/parser/parsing.h
rename to include/flang/parser/parsing.h
index d251b62daa00..a163a77e5856 100644
--- a/lib/parser/parsing.h
+++ b/include/flang/parser/parsing.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/parsing.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/parser/parsing.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.
@@ -14,7 +14,7 @@
 #include "message.h"
 #include "parse-tree.h"
 #include "provenance.h"
-#include "../common/Fortran-features.h"
+#include "flang/common/Fortran-features.h"
 #include <optional>
 #include <ostream>
 #include <string>
diff --git a/lib/parser/provenance.h b/include/flang/parser/provenance.h
similarity index 98%
rename from lib/parser/provenance.h
rename to include/flang/parser/provenance.h
index 52e6d74b2015..08cdf51345d3 100644
--- a/lib/parser/provenance.h
+++ b/include/flang/parser/provenance.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/provenance.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/parser/provenance.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.
@@ -13,8 +13,8 @@
 #include "char-buffer.h"
 #include "characters.h"
 #include "source.h"
-#include "../common/idioms.h"
-#include "../common/interval.h"
+#include "flang/common/idioms.h"
+#include "flang/common/interval.h"
 #include <cstddef>
 #include <map>
 #include <memory>
diff --git a/lib/parser/source.h b/include/flang/parser/source.h
similarity index 97%
rename from lib/parser/source.h
rename to include/flang/parser/source.h
index 1b809e7911d1..5eb000da2163 100644
--- a/lib/parser/source.h
+++ b/include/flang/parser/source.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/source.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/parser/source.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.
diff --git a/lib/parser/tools.h b/include/flang/parser/tools.h
similarity index 97%
rename from lib/parser/tools.h
rename to include/flang/parser/tools.h
index 461b0f2584e8..447d08c1f496 100644
--- a/lib/parser/tools.h
+++ b/include/flang/parser/tools.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/tools.h --------------------------------------*- C++ -*-===//
+//===-- include/flang/parser/tools.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.
diff --git a/lib/parser/unparse.h b/include/flang/parser/unparse.h
similarity index 95%
rename from lib/parser/unparse.h
rename to include/flang/parser/unparse.h
index 08d8b8405d23..0055ce30a701 100644
--- a/lib/parser/unparse.h
+++ b/include/flang/parser/unparse.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/unparse.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/parser/unparse.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.
diff --git a/lib/parser/user-state.h b/include/flang/parser/user-state.h
similarity index 94%
rename from lib/parser/user-state.h
rename to include/flang/parser/user-state.h
index cb14ae35690b..aaf86720d749 100644
--- a/lib/parser/user-state.h
+++ b/include/flang/parser/user-state.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/user-state.h ---------------------------------*- C++ -*-===//
+//===-- include/flang/parser/user-state.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.
@@ -14,10 +14,10 @@
 // parse tree construction so as to avoid any need for representing
 // state in static data.
 
-#include "char-block.h"
-#include "parse-tree.h"
-#include "../common/Fortran-features.h"
-#include "../common/idioms.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/parse-tree.h"
 #include <cinttypes>
 #include <optional>
 #include <ostream>
diff --git a/lib/semantics/attr.h b/include/flang/semantics/attr.h
similarity index 92%
rename from lib/semantics/attr.h
rename to include/flang/semantics/attr.h
index 99db4c82329f..475d6891d528 100644
--- a/lib/semantics/attr.h
+++ b/include/flang/semantics/attr.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/attr.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/semantics/attr.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.
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_SEMANTICS_ATTR_H_
 #define FORTRAN_SEMANTICS_ATTR_H_
 
-#include "../common/enum-set.h"
-#include "../common/idioms.h"
+#include "flang/common/enum-set.h"
+#include "flang/common/idioms.h"
 #include <cinttypes>
 #include <string>
 
diff --git a/lib/semantics/expression.h b/include/flang/semantics/expression.h
similarity index 97%
rename from lib/semantics/expression.h
rename to include/flang/semantics/expression.h
index bac545b08f26..110a0bdb0853 100644
--- a/lib/semantics/expression.h
+++ b/include/flang/semantics/expression.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/expression.h ------------------------------*- C++ -*-===//
+//===-- include/flang/semantics/expression.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.
@@ -10,17 +10,17 @@
 #define FORTRAN_SEMANTICS_EXPRESSION_H_
 
 #include "semantics.h"
-#include "../common/Fortran.h"
-#include "../common/indirection.h"
-#include "../evaluate/characteristics.h"
-#include "../evaluate/check-expression.h"
-#include "../evaluate/expression.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/tools.h"
-#include "../evaluate/type.h"
-#include "../parser/char-block.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/indirection.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/check-expression.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/type.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
 #include <map>
 #include <optional>
 #include <variant>
diff --git a/lib/semantics/scope.h b/include/flang/semantics/scope.h
similarity index 97%
rename from lib/semantics/scope.h
rename to include/flang/semantics/scope.h
index c44a68726e51..1de11bb53171 100644
--- a/lib/semantics/scope.h
+++ b/include/flang/semantics/scope.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/scope.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/semantics/scope.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.
@@ -11,11 +11,11 @@
 
 #include "attr.h"
 #include "symbol.h"
-#include "../common/Fortran.h"
-#include "../common/idioms.h"
-#include "../common/reference.h"
-#include "../parser/message.h"
-#include "../parser/provenance.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/idioms.h"
+#include "flang/common/reference.h"
+#include "flang/parser/message.h"
+#include "flang/parser/provenance.h"
 #include <list>
 #include <map>
 #include <optional>
diff --git a/lib/semantics/semantics.h b/include/flang/semantics/semantics.h
similarity index 97%
rename from lib/semantics/semantics.h
rename to include/flang/semantics/semantics.h
index d7ebb5a9e553..e823f48dc397 100644
--- a/lib/semantics/semantics.h
+++ b/include/flang/semantics/semantics.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/semantics.h -------------------------------*- C++ -*-===//
+//===-- include/flang/semantics/semantics.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.
@@ -11,10 +11,10 @@
 
 #include "scope.h"
 #include "symbol.h"
-#include "../common/Fortran-features.h"
-#include "../evaluate/common.h"
-#include "../evaluate/intrinsics.h"
-#include "../parser/message.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/evaluate/common.h"
+#include "flang/evaluate/intrinsics.h"
+#include "flang/parser/message.h"
 #include <iosfwd>
 #include <string>
 #include <vector>
diff --git a/lib/semantics/symbol.h b/include/flang/semantics/symbol.h
similarity index 99%
rename from lib/semantics/symbol.h
rename to include/flang/semantics/symbol.h
index b37e560f9f75..335e6ed936a5 100644
--- a/lib/semantics/symbol.h
+++ b/include/flang/semantics/symbol.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/symbol.h ----------------------------------*- C++ -*-===//
+//===-- include/flang/semantics/symbol.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.
@@ -10,9 +10,9 @@
 #define FORTRAN_SEMANTICS_SYMBOL_H_
 
 #include "type.h"
-#include "../common/Fortran.h"
-#include "../common/enum-set.h"
-#include "../common/reference.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/enum-set.h"
+#include "flang/common/reference.h"
 #include <list>
 #include <optional>
 #include <set>
diff --git a/lib/semantics/tools.h b/include/flang/semantics/tools.h
similarity index 98%
rename from lib/semantics/tools.h
rename to include/flang/semantics/tools.h
index 83741bdddafe..5f56325cc913 100644
--- a/lib/semantics/tools.h
+++ b/include/flang/semantics/tools.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/tools.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/semantics/tools.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.
@@ -12,15 +12,15 @@
 // Simple predicates and look-up functions that are best defined
 // canonically for use in semantic checking.
 
-#include "attr.h"
-#include "expression.h"
-#include "semantics.h"
-#include "../common/Fortran.h"
-#include "../evaluate/expression.h"
-#include "../evaluate/type.h"
-#include "../evaluate/variable.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/Fortran.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/type.h"
+#include "flang/evaluate/variable.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/attr.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/semantics.h"
 #include <functional>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/type.h b/include/flang/semantics/type.h
similarity index 98%
rename from lib/semantics/type.h
rename to include/flang/semantics/type.h
index 9a3142389c5a..19d02000c45c 100644
--- a/lib/semantics/type.h
+++ b/include/flang/semantics/type.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/type.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/semantics/type.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.
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_SEMANTICS_TYPE_H_
 #define FORTRAN_SEMANTICS_TYPE_H_
 
-#include "../common/Fortran.h"
-#include "../common/idioms.h"
-#include "../evaluate/expression.h"
-#include "../parser/char-block.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/expression.h"
+#include "flang/parser/char-block.h"
 #include <algorithm>
 #include <iosfwd>
 #include <map>
diff --git a/lib/semantics/unparse-with-symbols.h b/include/flang/semantics/unparse-with-symbols.h
similarity index 87%
rename from lib/semantics/unparse-with-symbols.h
rename to include/flang/semantics/unparse-with-symbols.h
index 727dc89b9955..8a6760f0094b 100644
--- a/lib/semantics/unparse-with-symbols.h
+++ b/include/flang/semantics/unparse-with-symbols.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/unparse-with-symbols.h --------------------*- C++ -*-===//
+//===-- include/flang/semantics/unparse-with-symbols.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
 #define FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
 
-#include "../parser/characters.h"
+#include "flang/parser/characters.h"
 #include <iosfwd>
 
 namespace Fortran::parser {
diff --git a/lib/common/Fortran-features.cc b/lib/common/Fortran-features.cc
index 8e5e08e68fbd..f92162673e46 100644
--- a/lib/common/Fortran-features.cc
+++ b/lib/common/Fortran-features.cc
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "Fortran-features.h"
-#include "Fortran.h"
-#include "idioms.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/idioms.h"
 
 namespace Fortran::common {
 
diff --git a/lib/common/Fortran.cc b/lib/common/Fortran.cc
index 35d61f0d2360..8b915bbee6dd 100644
--- a/lib/common/Fortran.cc
+++ b/lib/common/Fortran.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "Fortran.h"
+#include "flang/common/Fortran.h"
 
 namespace Fortran::common {
 
diff --git a/lib/common/default-kinds.cc b/lib/common/default-kinds.cc
index 4b40c4976ffd..1f459935961e 100644
--- a/lib/common/default-kinds.cc
+++ b/lib/common/default-kinds.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "default-kinds.h"
-#include "idioms.h"
+#include "flang/common/default-kinds.h"
+#include "flang/common/idioms.h"
 
 namespace Fortran::common {
 
diff --git a/lib/common/idioms.cc b/lib/common/idioms.cc
index d942269f3670..f27f7b1a0030 100644
--- a/lib/common/idioms.cc
+++ b/lib/common/idioms.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "idioms.h"
+#include "flang/common/idioms.h"
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
diff --git a/lib/decimal/big-radix-floating-point.h b/lib/decimal/big-radix-floating-point.h
index 7b84015bd257..51eb9ec8c5b6 100644
--- a/lib/decimal/big-radix-floating-point.h
+++ b/lib/decimal/big-radix-floating-point.h
@@ -21,12 +21,12 @@
 // for conversions between binary and decimal representations; it is not
 // a general-purpose facility.
 
-#include "binary-floating-point.h"
-#include "decimal.h"
-#include "../common/bit-population-count.h"
-#include "../common/leading-zero-bit-count.h"
-#include "../common/uint128.h"
-#include "../common/unsigned-const-division.h"
+#include "flang/common/bit-population-count.h"
+#include "flang/common/leading-zero-bit-count.h"
+#include "flang/common/uint128.h"
+#include "flang/common/unsigned-const-division.h"
+#include "flang/decimal/binary-floating-point.h"
+#include "flang/decimal/decimal.h"
 #include <cinttypes>
 #include <limits>
 #include <type_traits>
diff --git a/lib/decimal/binary-to-decimal.cc b/lib/decimal/binary-to-decimal.cc
index 50bca7327640..53b00c39e4ed 100644
--- a/lib/decimal/binary-to-decimal.cc
+++ b/lib/decimal/binary-to-decimal.cc
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "big-radix-floating-point.h"
-#include "../decimal/decimal.h"
+#include "flang/decimal/decimal.h"
 
 namespace Fortran::decimal {
 
diff --git a/lib/decimal/decimal-to-binary.cc b/lib/decimal/decimal-to-binary.cc
index 34ecb7cc664e..3f57a3bb41f1 100644
--- a/lib/decimal/decimal-to-binary.cc
+++ b/lib/decimal/decimal-to-binary.cc
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "big-radix-floating-point.h"
-#include "binary-floating-point.h"
-#include "decimal.h"
-#include "../common/bit-population-count.h"
-#include "../common/leading-zero-bit-count.h"
+#include "flang/common/bit-population-count.h"
+#include "flang/common/leading-zero-bit-count.h"
+#include "flang/decimal/binary-floating-point.h"
+#include "flang/decimal/decimal.h"
 #include <cinttypes>
 #include <cstring>
 #include <ctype.h>
diff --git a/lib/evaluate/call.cc b/lib/evaluate/call.cc
index ceb595360fad..a61f679935f0 100644
--- a/lib/evaluate/call.cc
+++ b/lib/evaluate/call.cc
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "call.h"
-#include "characteristics.h"
-#include "expression.h"
-#include "tools.h"
-#include "../common/idioms.h"
-#include "../semantics/symbol.h"
+#include "flang/evaluate/call.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/tools.h"
+#include "flang/semantics/symbol.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/character.h b/lib/evaluate/character.h
index 032f729b1514..be1303eacca8 100644
--- a/lib/evaluate/character.h
+++ b/lib/evaluate/character.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_EVALUATE_CHARACTER_H_
 #define FORTRAN_EVALUATE_CHARACTER_H_
 
-#include "type.h"
+#include "flang/evaluate/type.h"
 #include <string>
 
 // Provides implementations of intrinsic functions operating on character
diff --git a/lib/evaluate/characteristics.cc b/lib/evaluate/characteristics.cc
index 83c79461b792..1e4f2825ba08 100644
--- a/lib/evaluate/characteristics.cc
+++ b/lib/evaluate/characteristics.cc
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "characteristics.h"
-#include "check-expression.h"
-#include "fold.h"
-#include "intrinsics.h"
-#include "tools.h"
-#include "type.h"
-#include "../common/indirection.h"
-#include "../parser/message.h"
-#include "../semantics/scope.h"
-#include "../semantics/symbol.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/common/indirection.h"
+#include "flang/evaluate/check-expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/intrinsics.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/type.h"
+#include "flang/parser/message.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/symbol.h"
 #include <initializer_list>
 #include <ostream>
 
diff --git a/lib/evaluate/check-expression.cc b/lib/evaluate/check-expression.cc
index 92dbb76fe15a..31d1454ff176 100644
--- a/lib/evaluate/check-expression.cc
+++ b/lib/evaluate/check-expression.cc
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "check-expression.h"
-#include "traverse.h"
-#include "type.h"
-#include "../semantics/symbol.h"
-#include "../semantics/tools.h"
+#include "flang/evaluate/check-expression.h"
+#include "flang/evaluate/traverse.h"
+#include "flang/evaluate/type.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/common.cc b/lib/evaluate/common.cc
index 5bf76ecbccf9..a1f7cbbf6005 100644
--- a/lib/evaluate/common.cc
+++ b/lib/evaluate/common.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "common.h"
-#include "../common/idioms.h"
+#include "flang/evaluate/common.h"
+#include "flang/common/idioms.h"
 
 using namespace Fortran::parser::literals;
 
diff --git a/lib/evaluate/complex.cc b/lib/evaluate/complex.cc
index c68228f8f698..e93245997cd2 100644
--- a/lib/evaluate/complex.cc
+++ b/lib/evaluate/complex.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "complex.h"
+#include "flang/evaluate/complex.h"
 
 namespace Fortran::evaluate::value {
 
diff --git a/lib/evaluate/constant.cc b/lib/evaluate/constant.cc
index d49d93f00712..4c83e34c8c68 100644
--- a/lib/evaluate/constant.cc
+++ b/lib/evaluate/constant.cc
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "constant.h"
-#include "expression.h"
-#include "shape.h"
-#include "type.h"
+#include "flang/evaluate/constant.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/shape.h"
+#include "flang/evaluate/type.h"
 #include <string>
 
 namespace Fortran::evaluate {
diff --git a/lib/evaluate/expression.cc b/lib/evaluate/expression.cc
index 39aa4dc0f087..21a0176e32ac 100644
--- a/lib/evaluate/expression.cc
+++ b/lib/evaluate/expression.cc
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "expression.h"
-#include "common.h"
+#include "flang/evaluate/expression.h"
 #include "int-power.h"
-#include "tools.h"
-#include "variable.h"
-#include "../common/idioms.h"
-#include "../parser/message.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/common.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/variable.h"
+#include "flang/parser/message.h"
 #include <string>
 #include <type_traits>
 
diff --git a/lib/evaluate/fold-implementation.h b/lib/evaluate/fold-implementation.h
index d78c52785276..fdb85dfb0a7f 100644
--- a/lib/evaluate/fold-implementation.h
+++ b/lib/evaluate/fold-implementation.h
@@ -10,26 +10,26 @@
 #define FORTRAN_EVALUATE_FOLD_IMPLEMENTATION_H_
 
 #include "character.h"
-#include "characteristics.h"
-#include "common.h"
-#include "constant.h"
-#include "expression.h"
-#include "fold.h"
-#include "formatting.h"
 #include "host.h"
 #include "int-power.h"
 #include "intrinsics-library-templates.h"
-#include "shape.h"
-#include "tools.h"
-#include "traverse.h"
-#include "type.h"
-#include "../common/indirection.h"
-#include "../common/template.h"
-#include "../common/unwrap.h"
-#include "../parser/message.h"
-#include "../semantics/scope.h"
-#include "../semantics/symbol.h"
-#include "../semantics/tools.h"
+#include "flang/common/indirection.h"
+#include "flang/common/template.h"
+#include "flang/common/unwrap.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/common.h"
+#include "flang/evaluate/constant.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/formatting.h"
+#include "flang/evaluate/shape.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/traverse.h"
+#include "flang/evaluate/type.h"
+#include "flang/parser/message.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 #include <algorithm>
 #include <cmath>
 #include <complex>
diff --git a/lib/evaluate/fold-logical.cc b/lib/evaluate/fold-logical.cc
index fd67fb10f77c..649f745897b8 100644
--- a/lib/evaluate/fold-logical.cc
+++ b/lib/evaluate/fold-logical.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "check-expression.h"
 #include "fold-implementation.h"
+#include "flang/evaluate/check-expression.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/fold.cc b/lib/evaluate/fold.cc
index 0a36c91a5139..af1de4094daf 100644
--- a/lib/evaluate/fold.cc
+++ b/lib/evaluate/fold.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fold.h"
+#include "flang/evaluate/fold.h"
 #include "fold-implementation.h"
 
 namespace Fortran::evaluate {
diff --git a/lib/evaluate/formatting.cc b/lib/evaluate/formatting.cc
index 67320ac7a826..6eb43a4e4967 100644
--- a/lib/evaluate/formatting.cc
+++ b/lib/evaluate/formatting.cc
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "formatting.h"
-#include "call.h"
-#include "constant.h"
-#include "expression.h"
-#include "fold.h"
-#include "tools.h"
-#include "../parser/characters.h"
-#include "../semantics/symbol.h"
+#include "flang/evaluate/formatting.h"
+#include "flang/evaluate/call.h"
+#include "flang/evaluate/constant.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/characters.h"
+#include "flang/semantics/symbol.h"
 #include <sstream>
 
 namespace Fortran::evaluate {
diff --git a/lib/evaluate/host.cc b/lib/evaluate/host.cc
index 718bc7a5474f..62dd44863989 100644
--- a/lib/evaluate/host.cc
+++ b/lib/evaluate/host.cc
@@ -8,7 +8,7 @@
 
 #include "host.h"
 
-#include "../common/idioms.h"
+#include "flang/common/idioms.h"
 #include <cerrno>
 #include <cfenv>
 
diff --git a/lib/evaluate/host.h b/lib/evaluate/host.h
index fb3059083500..f2d8c1dc37b4 100644
--- a/lib/evaluate/host.h
+++ b/lib/evaluate/host.h
@@ -17,7 +17,7 @@
 // hardware type maps to Fortran intrinsic type T. Then HostType<T> can be used
 // to safely refer to this hardware type.
 
-#include "type.h"
+#include "flang/evaluate/type.h"
 #include <cfenv>
 #include <complex>
 #include <cstdint>
diff --git a/lib/evaluate/int-power.h b/lib/evaluate/int-power.h
index 01b090856543..6a6fe831a7c4 100644
--- a/lib/evaluate/int-power.h
+++ b/lib/evaluate/int-power.h
@@ -11,7 +11,7 @@
 
 // Computes an integer power of a real or complex value.
 
-#include "common.h"
+#include "flang/evaluate/common.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/integer.cc b/lib/evaluate/integer.cc
index abc94739bfd7..30484d90664a 100644
--- a/lib/evaluate/integer.cc
+++ b/lib/evaluate/integer.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "integer.h"
+#include "flang/evaluate/integer.h"
 
 namespace Fortran::evaluate::value {
 
diff --git a/lib/evaluate/intrinsics-library-templates.h b/lib/evaluate/intrinsics-library-templates.h
index 78b0c6746770..4ab657da01e0 100644
--- a/lib/evaluate/intrinsics-library-templates.h
+++ b/lib/evaluate/intrinsics-library-templates.h
@@ -17,9 +17,9 @@
 // which version should be instantiated in a generic way.
 
 #include "host.h"
-#include "intrinsics-library.h"
-#include "type.h"
-#include "../common/template.h"
+#include "flang/common/template.h"
+#include "flang/evaluate/intrinsics-library.h"
+#include "flang/evaluate/type.h"
 
 #include <tuple>
 #include <type_traits>
diff --git a/lib/evaluate/intrinsics.cc b/lib/evaluate/intrinsics.cc
index e57bfcd58481..1a8b5ba3248b 100644
--- a/lib/evaluate/intrinsics.cc
+++ b/lib/evaluate/intrinsics.cc
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "intrinsics.h"
-#include "common.h"
-#include "expression.h"
-#include "fold.h"
-#include "shape.h"
-#include "tools.h"
-#include "type.h"
-#include "../common/Fortran.h"
-#include "../common/enum-set.h"
-#include "../common/idioms.h"
+#include "flang/evaluate/intrinsics.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/enum-set.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/common.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/shape.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/type.h"
 #include <algorithm>
 #include <map>
 #include <ostream>
diff --git a/lib/evaluate/logical.cc b/lib/evaluate/logical.cc
index e3fcc0e128b1..bdbfedb05d7f 100644
--- a/lib/evaluate/logical.cc
+++ b/lib/evaluate/logical.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "logical.h"
+#include "flang/evaluate/logical.h"
 
 namespace Fortran::evaluate::value {
 
diff --git a/lib/evaluate/real.cc b/lib/evaluate/real.cc
index 44b7cbe121b0..b803a8ea1de3 100644
--- a/lib/evaluate/real.cc
+++ b/lib/evaluate/real.cc
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "real.h"
+#include "flang/evaluate/real.h"
 #include "int-power.h"
-#include "../common/idioms.h"
-#include "../decimal/decimal.h"
-#include "../parser/characters.h"
+#include "flang/common/idioms.h"
+#include "flang/decimal/decimal.h"
+#include "flang/parser/characters.h"
 #include <limits>
 
 namespace Fortran::evaluate::value {
diff --git a/lib/evaluate/shape.cc b/lib/evaluate/shape.cc
index 1ccbfea9e891..62bc879895de 100644
--- a/lib/evaluate/shape.cc
+++ b/lib/evaluate/shape.cc
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "shape.h"
-#include "characteristics.h"
-#include "fold.h"
-#include "intrinsics.h"
-#include "tools.h"
-#include "type.h"
-#include "../common/idioms.h"
-#include "../common/template.h"
-#include "../parser/message.h"
-#include "../semantics/symbol.h"
+#include "flang/evaluate/shape.h"
+#include "flang/common/idioms.h"
+#include "flang/common/template.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/intrinsics.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/type.h"
+#include "flang/parser/message.h"
+#include "flang/semantics/symbol.h"
 #include <functional>
 
 using namespace std::placeholders;  // _1, _2, &c. for std::bind()
diff --git a/lib/evaluate/static-data.cc b/lib/evaluate/static-data.cc
index 3b08ddb426e9..f5311cee1a95 100644
--- a/lib/evaluate/static-data.cc
+++ b/lib/evaluate/static-data.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "static-data.h"
-#include "../parser/characters.h"
+#include "flang/evaluate/static-data.h"
+#include "flang/parser/characters.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/tools.cc b/lib/evaluate/tools.cc
index 2b1b9074aba2..4710343f4ad2 100644
--- a/lib/evaluate/tools.cc
+++ b/lib/evaluate/tools.cc
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "tools.h"
-#include "characteristics.h"
-#include "traverse.h"
-#include "../common/idioms.h"
-#include "../parser/message.h"
+#include "flang/evaluate/tools.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/traverse.h"
+#include "flang/parser/message.h"
 #include <algorithm>
 #include <variant>
 
diff --git a/lib/evaluate/type.cc b/lib/evaluate/type.cc
index c78c8eebdcf8..bf7e8012e0ff 100644
--- a/lib/evaluate/type.cc
+++ b/lib/evaluate/type.cc
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "type.h"
-#include "expression.h"
-#include "fold.h"
-#include "../common/idioms.h"
-#include "../common/template.h"
-#include "../parser/characters.h"
-#include "../semantics/scope.h"
-#include "../semantics/symbol.h"
-#include "../semantics/tools.h"
-#include "../semantics/type.h"
+#include "flang/evaluate/type.h"
+#include "flang/common/idioms.h"
+#include "flang/common/template.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/parser/characters.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
+#include "flang/semantics/type.h"
 #include <algorithm>
 #include <optional>
 #include <sstream>
diff --git a/lib/evaluate/variable.cc b/lib/evaluate/variable.cc
index a0f16853ba71..0922ba659cd5 100644
--- a/lib/evaluate/variable.cc
+++ b/lib/evaluate/variable.cc
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "variable.h"
-#include "fold.h"
-#include "tools.h"
-#include "../common/idioms.h"
-#include "../parser/char-block.h"
-#include "../parser/characters.h"
-#include "../parser/message.h"
-#include "../semantics/symbol.h"
+#include "flang/evaluate/variable.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/message.h"
+#include "flang/semantics/symbol.h"
 #include <ostream>
 #include <type_traits>
 
diff --git a/lib/parser/Fortran-parsers.cc b/lib/parser/Fortran-parsers.cc
index 9efa895e24b8..bfc7122a4dd5 100644
--- a/lib/parser/Fortran-parsers.cc
+++ b/lib/parser/Fortran-parsers.cc
@@ -33,11 +33,11 @@
 #include "basic-parsers.h"
 #include "expr-parsers.h"
 #include "misc-parsers.h"
-#include "parse-tree.h"
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
-#include "user-state.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/user-state.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/basic-parsers.h b/lib/parser/basic-parsers.h
index 3cad01164395..31491a238363 100644
--- a/lib/parser/basic-parsers.h
+++ b/lib/parser/basic-parsers.h
@@ -22,14 +22,14 @@
 // This header defines the fundamental parser class templates and helper
 // template functions.  See parser-combinators.txt for documentation.
 
-#include "char-block.h"
-#include "message.h"
-#include "parse-state.h"
-#include "provenance.h"
-#include "user-state.h"
-#include "../common/Fortran-features.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-state.h"
+#include "flang/parser/provenance.h"
+#include "flang/parser/user-state.h"
 #include <cstring>
 #include <functional>
 #include <list>
diff --git a/lib/parser/char-block.cc b/lib/parser/char-block.cc
index e8254d09f66a..8c9784e55ad1 100644
--- a/lib/parser/char-block.cc
+++ b/lib/parser/char-block.cc
@@ -6,7 +6,7 @@
 //
 //----------------------------------------------------------------------------//
 
-#include "char-block.h"
+#include "flang/parser/char-block.h"
 #include <ostream>
 
 namespace Fortran::parser {
diff --git a/lib/parser/char-buffer.cc b/lib/parser/char-buffer.cc
index 5cfddb875443..6c426243ce3f 100644
--- a/lib/parser/char-buffer.cc
+++ b/lib/parser/char-buffer.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "char-buffer.h"
-#include "../common/idioms.h"
+#include "flang/parser/char-buffer.h"
+#include "flang/common/idioms.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
diff --git a/lib/parser/char-set.cc b/lib/parser/char-set.cc
index ae56e9a955e6..c8a324f5ae9e 100644
--- a/lib/parser/char-set.cc
+++ b/lib/parser/char-set.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "char-set.h"
+#include "flang/parser/char-set.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/characters.cc b/lib/parser/characters.cc
index 89f16ecea214..d6fc0d6464f7 100644
--- a/lib/parser/characters.cc
+++ b/lib/parser/characters.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "characters.h"
-#include "../common/idioms.h"
+#include "flang/parser/characters.h"
+#include "flang/common/idioms.h"
 #include <algorithm>
 #include <cstddef>
 #include <optional>
diff --git a/lib/parser/debug-parser.cc b/lib/parser/debug-parser.cc
index 1f2a9101d0c2..97fdf2820141 100644
--- a/lib/parser/debug-parser.cc
+++ b/lib/parser/debug-parser.cc
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug-parser.h"
-#include "user-state.h"
+#include "flang/parser/user-state.h"
 #include <ostream>
 #include <string>
 
diff --git a/lib/parser/debug-parser.h b/lib/parser/debug-parser.h
index 82871646f95a..dbb812c9cec7 100644
--- a/lib/parser/debug-parser.h
+++ b/lib/parser/debug-parser.h
@@ -14,7 +14,7 @@
 // flow of the parsers.  Not to be used in production.
 
 #include "basic-parsers.h"
-#include "parse-state.h"
+#include "flang/parser/parse-state.h"
 #include <cstddef>
 #include <optional>
 
diff --git a/lib/parser/executable-parsers.cc b/lib/parser/executable-parsers.cc
index 1cbc4936dcf1..a1557a0e0e46 100644
--- a/lib/parser/executable-parsers.cc
+++ b/lib/parser/executable-parsers.cc
@@ -9,14 +9,14 @@
 // Per-type parsers for executable statements
 
 #include "basic-parsers.h"
-#include "characters.h"
 #include "debug-parser.h"
 #include "expr-parsers.h"
 #include "misc-parsers.h"
-#include "parse-tree.h"
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/expr-parsers.cc b/lib/parser/expr-parsers.cc
index 4989a6b8e30a..14bc391691ee 100644
--- a/lib/parser/expr-parsers.cc
+++ b/lib/parser/expr-parsers.cc
@@ -10,13 +10,13 @@
 
 #include "expr-parsers.h"
 #include "basic-parsers.h"
-#include "characters.h"
 #include "debug-parser.h"
 #include "misc-parsers.h"
-#include "parse-tree.h"
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/expr-parsers.h b/lib/parser/expr-parsers.h
index 3ed9a2c7096d..fcaeedad3994 100644
--- a/lib/parser/expr-parsers.h
+++ b/lib/parser/expr-parsers.h
@@ -10,9 +10,9 @@
 #define FORTRAN_PARSER_EXPR_PARSERS_H_
 
 #include "basic-parsers.h"
-#include "parse-tree.h"
 #include "token-parsers.h"
 #include "type-parsers.h"
+#include "flang/parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/instrumented-parser.cc b/lib/parser/instrumented-parser.cc
index 24a59cc735dd..b845b22dffdd 100644
--- a/lib/parser/instrumented-parser.cc
+++ b/lib/parser/instrumented-parser.cc
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "instrumented-parser.h"
-#include "message.h"
-#include "provenance.h"
+#include "flang/parser/instrumented-parser.h"
+#include "flang/parser/message.h"
+#include "flang/parser/provenance.h"
 #include <map>
 #include <ostream>
 
diff --git a/lib/parser/io-parsers.cc b/lib/parser/io-parsers.cc
index 95770081c02c..5488a32c4769 100644
--- a/lib/parser/io-parsers.cc
+++ b/lib/parser/io-parsers.cc
@@ -9,14 +9,14 @@
 // Per-type parsers for I/O statements and FORMAT
 
 #include "basic-parsers.h"
-#include "characters.h"
 #include "debug-parser.h"
 #include "expr-parsers.h"
 #include "misc-parsers.h"
-#include "parse-tree.h"
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/parse-tree.h"
 
 namespace Fortran::parser {
 // R1201 io-unit -> file-unit-number | * | internal-file-variable
diff --git a/lib/parser/message.cc b/lib/parser/message.cc
index a8a321a50dcc..5589707effc2 100644
--- a/lib/parser/message.cc
+++ b/lib/parser/message.cc
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "message.h"
-#include "char-set.h"
-#include "../common/idioms.h"
+#include "flang/parser/message.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/char-set.h"
 #include <algorithm>
 #include <cstdarg>
 #include <cstddef>
diff --git a/lib/parser/misc-parsers.h b/lib/parser/misc-parsers.h
index 62589bb4d5fb..1a7c641557a5 100644
--- a/lib/parser/misc-parsers.h
+++ b/lib/parser/misc-parsers.h
@@ -13,10 +13,10 @@
 #define FORTRAN_PARSER_MISC_PARSERS_H_
 
 #include "basic-parsers.h"
-#include "message.h"
-#include "parse-tree.h"
 #include "token-parsers.h"
 #include "type-parsers.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/openmp-parsers.cc b/lib/parser/openmp-parsers.cc
index d30a93a33569..4a5a083747bd 100644
--- a/lib/parser/openmp-parsers.cc
+++ b/lib/parser/openmp-parsers.cc
@@ -12,10 +12,10 @@
 #include "basic-parsers.h"
 #include "expr-parsers.h"
 #include "misc-parsers.h"
-#include "parse-tree.h"
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
+#include "flang/parser/parse-tree.h"
 
 // OpenMP Directives and Clauses
 namespace Fortran::parser {
diff --git a/lib/parser/parse-tree.cc b/lib/parser/parse-tree.cc
index afd2c68323ce..6e0e017570b5 100644
--- a/lib/parser/parse-tree.cc
+++ b/lib/parser/parse-tree.cc
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "parse-tree.h"
-#include "user-state.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
+#include "flang/parser/user-state.h"
 #include <algorithm>
 
 // So "delete Expr;" calls an external destructor for its typedExpr.
diff --git a/lib/parser/parsing.cc b/lib/parser/parsing.cc
index e42752926810..c2b96ab8b383 100644
--- a/lib/parser/parsing.cc
+++ b/lib/parser/parsing.cc
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "parsing.h"
-#include "message.h"
+#include "flang/parser/parsing.h"
 #include "preprocessor.h"
 #include "prescan.h"
-#include "provenance.h"
-#include "source.h"
 #include "type-parsers.h"
+#include "flang/parser/message.h"
+#include "flang/parser/provenance.h"
+#include "flang/parser/source.h"
 #include <sstream>
 
 namespace Fortran::parser {
diff --git a/lib/parser/preprocessor.cc b/lib/parser/preprocessor.cc
index 27ce7f17e647..270e72ca3735 100644
--- a/lib/parser/preprocessor.cc
+++ b/lib/parser/preprocessor.cc
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "preprocessor.h"
-#include "characters.h"
-#include "message.h"
 #include "prescan.h"
-#include "../common/idioms.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/message.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
diff --git a/lib/parser/preprocessor.h b/lib/parser/preprocessor.h
index 1a0189629ea8..523c880316c2 100644
--- a/lib/parser/preprocessor.h
+++ b/lib/parser/preprocessor.h
@@ -15,9 +15,9 @@
 // performed, so that special compiler command options &/or source file name
 // extensions for preprocessing will not be necessary.
 
-#include "char-block.h"
-#include "provenance.h"
 #include "token-sequence.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/provenance.h"
 #include <cstddef>
 #include <list>
 #include <stack>
diff --git a/lib/parser/prescan.cc b/lib/parser/prescan.cc
index 2af12df9aa9b..07f294a9eb77 100644
--- a/lib/parser/prescan.cc
+++ b/lib/parser/prescan.cc
@@ -7,12 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "prescan.h"
-#include "characters.h"
-#include "message.h"
 #include "preprocessor.h"
-#include "source.h"
 #include "token-sequence.h"
-#include "../common/idioms.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/message.h"
+#include "flang/parser/source.h"
 #include <cstddef>
 #include <cstring>
 #include <sstream>
diff --git a/lib/parser/prescan.h b/lib/parser/prescan.h
index a399cabf1273..1b13cb7feac5 100644
--- a/lib/parser/prescan.h
+++ b/lib/parser/prescan.h
@@ -16,11 +16,11 @@
 // fixed form character literals on truncated card images, file
 // inclusion, and driving the Fortran source preprocessor.
 
-#include "characters.h"
-#include "message.h"
-#include "provenance.h"
 #include "token-sequence.h"
-#include "../common/Fortran-features.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/message.h"
+#include "flang/parser/provenance.h"
 #include <bitset>
 #include <optional>
 #include <string>
diff --git a/lib/parser/program-parsers.cc b/lib/parser/program-parsers.cc
index bded0cba5658..f19824248181 100644
--- a/lib/parser/program-parsers.cc
+++ b/lib/parser/program-parsers.cc
@@ -9,14 +9,14 @@
 // Per-type parsers for program units
 
 #include "basic-parsers.h"
-#include "characters.h"
 #include "debug-parser.h"
 #include "expr-parsers.h"
 #include "misc-parsers.h"
-#include "parse-tree.h"
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/provenance.cc b/lib/parser/provenance.cc
index bfa5133b2e81..9ad864e0da95 100644
--- a/lib/parser/provenance.cc
+++ b/lib/parser/provenance.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "provenance.h"
-#include "../common/idioms.h"
+#include "flang/parser/provenance.h"
+#include "flang/common/idioms.h"
 #include <algorithm>
 #include <utility>
 
diff --git a/lib/parser/source.cc b/lib/parser/source.cc
index 6dc6c7108b28..4e4c2736781f 100644
--- a/lib/parser/source.cc
+++ b/lib/parser/source.cc
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "source.h"
-#include "char-buffer.h"
-#include "../common/idioms.h"
+#include "flang/parser/source.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/char-buffer.h"
 #include <algorithm>
 #include <cerrno>
 #include <cstddef>
diff --git a/lib/parser/token-parsers.h b/lib/parser/token-parsers.h
index 6b4ce9ec55d9..d36d78906954 100644
--- a/lib/parser/token-parsers.h
+++ b/lib/parser/token-parsers.h
@@ -13,12 +13,12 @@
 // the prescanned character stream and recognize context-sensitive tokens.
 
 #include "basic-parsers.h"
-#include "char-set.h"
-#include "characters.h"
-#include "instrumented-parser.h"
-#include "provenance.h"
 #include "type-parsers.h"
-#include "../common/idioms.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/char-set.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/instrumented-parser.h"
+#include "flang/parser/provenance.h"
 #include <cctype>
 #include <cstddef>
 #include <cstring>
diff --git a/lib/parser/token-sequence.cc b/lib/parser/token-sequence.cc
index 6270d3fbf212..d6337f475cec 100644
--- a/lib/parser/token-sequence.cc
+++ b/lib/parser/token-sequence.cc
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "token-sequence.h"
-#include "characters.h"
+#include "flang/parser/characters.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/token-sequence.h b/lib/parser/token-sequence.h
index d1896928f89e..e4b7dce8b6ad 100644
--- a/lib/parser/token-sequence.h
+++ b/lib/parser/token-sequence.h
@@ -13,8 +13,8 @@
 // and a partitioning thereof into preprocessing tokens, along with their
 // associated provenances.
 
-#include "char-block.h"
-#include "provenance.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/provenance.h"
 #include <cstddef>
 #include <cstring>
 #include <ostream>
diff --git a/lib/parser/tools.cc b/lib/parser/tools.cc
index ab0ab153b8ba..1ef05b427a25 100644
--- a/lib/parser/tools.cc
+++ b/lib/parser/tools.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "tools.h"
+#include "flang/parser/tools.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/type-parsers.h b/lib/parser/type-parsers.h
index 7a18b3c671af..82273a374274 100644
--- a/lib/parser/type-parsers.h
+++ b/lib/parser/type-parsers.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_PARSER_TYPE_PARSERS_H_
 #define FORTRAN_PARSER_TYPE_PARSERS_H_
 
-#include "instrumented-parser.h"
-#include "parse-tree.h"
+#include "flang/parser/instrumented-parser.h"
+#include "flang/parser/parse-tree.h"
 #include <optional>
 
 namespace Fortran::parser {
diff --git a/lib/parser/unparse.cc b/lib/parser/unparse.cc
index 6e63962a3fbe..6550efa65880 100644
--- a/lib/parser/unparse.cc
+++ b/lib/parser/unparse.cc
@@ -9,13 +9,13 @@
 // Generates Fortran from the content of a parse tree, using the
 // traversal templates in parse-tree-visitor.h.
 
-#include "unparse.h"
-#include "characters.h"
-#include "parse-tree-visitor.h"
-#include "parse-tree.h"
-#include "../common/Fortran.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
+#include "flang/parser/unparse.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
diff --git a/lib/parser/user-state.cc b/lib/parser/user-state.cc
index a0f2ea6cd4bc..b23b8f579c84 100644
--- a/lib/parser/user-state.cc
+++ b/lib/parser/user-state.cc
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "user-state.h"
-#include "parse-state.h"
+#include "flang/parser/user-state.h"
 #include "stmt-parser.h"
 #include "type-parsers.h"
+#include "flang/parser/parse-state.h"
 #include <optional>
 
 namespace Fortran::parser {
diff --git a/lib/semantics/assignment.cc b/lib/semantics/assignment.cc
index d7b9d91ed739..70f2f655a41b 100644
--- a/lib/semantics/assignment.cc
+++ b/lib/semantics/assignment.cc
@@ -7,18 +7,19 @@
 //===----------------------------------------------------------------------===//
 
 #include "assignment.h"
-#include "expression.h"
 #include "pointer-assignment.h"
-#include "symbol.h"
-#include "tools.h"
-#include "../common/idioms.h"
-#include "../common/restorer.h"
-#include "../evaluate/expression.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/tools.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/idioms.h"
+#include "flang/common/restorer.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 #include <optional>
 #include <set>
 #include <string>
diff --git a/lib/semantics/assignment.h b/lib/semantics/assignment.h
index d963b6a4e2d9..4bce8cb16dd5 100644
--- a/lib/semantics/assignment.h
+++ b/lib/semantics/assignment.h
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_SEMANTICS_ASSIGNMENT_H_
 #define FORTRAN_SEMANTICS_ASSIGNMENT_H_
 
-#include "semantics.h"
-#include "tools.h"
-#include "../common/indirection.h"
-#include "../evaluate/expression.h"
+#include "flang/common/indirection.h"
+#include "flang/evaluate/expression.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/tools.h"
 #include <string>
 
 namespace Fortran::parser {
diff --git a/lib/semantics/attr.cc b/lib/semantics/attr.cc
index 765569a9736d..25d9201f3fb7 100644
--- a/lib/semantics/attr.cc
+++ b/lib/semantics/attr.cc
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "attr.h"
-#include "../common/idioms.h"
+#include "flang/semantics/attr.h"
+#include "flang/common/idioms.h"
 #include <ostream>
 #include <stddef.h>
 
diff --git a/lib/semantics/canonicalize-do.cc b/lib/semantics/canonicalize-do.cc
index 0f813a6f05a0..b4ac3771e8e8 100644
--- a/lib/semantics/canonicalize-do.cc
+++ b/lib/semantics/canonicalize-do.cc
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "canonicalize-do.h"
-#include "../parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree-visitor.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/semantics/canonicalize-omp.cc b/lib/semantics/canonicalize-omp.cc
index ae57d3f46770..cbd26d19b763 100644
--- a/lib/semantics/canonicalize-omp.cc
+++ b/lib/semantics/canonicalize-omp.cc
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "canonicalize-omp.h"
-#include "../parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree-visitor.h"
 
 // After Loop Canonicalization, rewrite OpenMP parse tree to make OpenMP
 // Constructs more structured which provide explicit scopes for later
diff --git a/lib/semantics/check-allocate.cc b/lib/semantics/check-allocate.cc
index e72d3bdb9bad..4db1434f5cee 100644
--- a/lib/semantics/check-allocate.cc
+++ b/lib/semantics/check-allocate.cc
@@ -8,14 +8,14 @@
 
 #include "check-allocate.h"
 #include "assignment.h"
-#include "attr.h"
-#include "expression.h"
-#include "tools.h"
-#include "type.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/type.h"
-#include "../parser/parse-tree.h"
-#include "../parser/tools.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/type.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/attr.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/tools.h"
+#include "flang/semantics/type.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-allocate.h b/lib/semantics/check-allocate.h
index 79e0af5a6797..2d495b13746c 100644
--- a/lib/semantics/check-allocate.h
+++ b/lib/semantics/check-allocate.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
 #define FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct AllocateStmt;
diff --git a/lib/semantics/check-arithmeticif.cc b/lib/semantics/check-arithmeticif.cc
index e6e05f82806b..fd293ce5e3c8 100644
--- a/lib/semantics/check-arithmeticif.cc
+++ b/lib/semantics/check-arithmeticif.cc
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-arithmeticif.h"
-#include "tools.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-arithmeticif.h b/lib/semantics/check-arithmeticif.h
index 26a04400d37d..32e2b354cf22 100644
--- a/lib/semantics/check-arithmeticif.h
+++ b/lib/semantics/check-arithmeticif.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
 #define FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct ArithmeticIfStmt;
diff --git a/lib/semantics/check-call.cc b/lib/semantics/check-call.cc
index a643c384d589..164dbc86f898 100644
--- a/lib/semantics/check-call.cc
+++ b/lib/semantics/check-call.cc
@@ -8,14 +8,14 @@
 
 #include "check-call.h"
 #include "pointer-assignment.h"
-#include "scope.h"
-#include "tools.h"
-#include "../evaluate/characteristics.h"
-#include "../evaluate/check-expression.h"
-#include "../evaluate/shape.h"
-#include "../evaluate/tools.h"
-#include "../parser/characters.h"
-#include "../parser/message.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/check-expression.h"
+#include "flang/evaluate/shape.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/message.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/tools.h"
 #include <map>
 #include <string>
 
diff --git a/lib/semantics/check-call.h b/lib/semantics/check-call.h
index 89953ae6d726..68c5b53b078a 100644
--- a/lib/semantics/check-call.h
+++ b/lib/semantics/check-call.h
@@ -11,7 +11,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_CALL_H_
 #define FORTRAN_SEMANTICS_CHECK_CALL_H_
 
-#include "../evaluate/call.h"
+#include "flang/evaluate/call.h"
 
 namespace Fortran::parser {
 class Messages;
diff --git a/lib/semantics/check-coarray.cc b/lib/semantics/check-coarray.cc
index 1df756a5bfea..44f8cf4e89c0 100644
--- a/lib/semantics/check-coarray.cc
+++ b/lib/semantics/check-coarray.cc
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-coarray.h"
-#include "expression.h"
-#include "tools.h"
-#include "../common/indirection.h"
-#include "../evaluate/expression.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
-#include "../parser/tools.h"
+#include "flang/common/indirection.h"
+#include "flang/evaluate/expression.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-coarray.h b/lib/semantics/check-coarray.h
index a843105b6817..fe4176c1d943 100644
--- a/lib/semantics/check-coarray.h
+++ b/lib/semantics/check-coarray.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_COARRAY_H_
 #define FORTRAN_SEMANTICS_CHECK_COARRAY_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 #include <list>
 
 namespace Fortran::parser {
diff --git a/lib/semantics/check-deallocate.cc b/lib/semantics/check-deallocate.cc
index 0d8238262019..7e66fcdfbdbf 100644
--- a/lib/semantics/check-deallocate.cc
+++ b/lib/semantics/check-deallocate.cc
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-deallocate.h"
-#include "expression.h"
-#include "tools.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-deallocate.h b/lib/semantics/check-deallocate.h
index 1ad9f3d7d759..6855055bd65d 100644
--- a/lib/semantics/check-deallocate.h
+++ b/lib/semantics/check-deallocate.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
 #define FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct DeallocateStmt;
diff --git a/lib/semantics/check-declarations.cc b/lib/semantics/check-declarations.cc
index 752a73e25453..a3352d94f907 100644
--- a/lib/semantics/check-declarations.cc
+++ b/lib/semantics/check-declarations.cc
@@ -9,14 +9,14 @@
 // Static declaration checking
 
 #include "check-declarations.h"
-#include "scope.h"
-#include "semantics.h"
-#include "symbol.h"
-#include "tools.h"
-#include "type.h"
-#include "../evaluate/check-expression.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/tools.h"
+#include "flang/evaluate/check-expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
+#include "flang/semantics/type.h"
 #include <algorithm>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-do.cc b/lib/semantics/check-do.cc
index d614751612ad..8112c631a12c 100644
--- a/lib/semantics/check-do.cc
+++ b/lib/semantics/check-do.cc
@@ -7,19 +7,19 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-do.h"
-#include "attr.h"
-#include "scope.h"
-#include "semantics.h"
-#include "symbol.h"
-#include "tools.h"
-#include "type.h"
-#include "../common/template.h"
-#include "../evaluate/call.h"
-#include "../evaluate/expression.h"
-#include "../evaluate/tools.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/tools.h"
+#include "flang/common/template.h"
+#include "flang/evaluate/call.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/attr.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
+#include "flang/semantics/type.h"
 
 namespace Fortran::evaluate {
 using ActualArgumentRef = common::Reference<const ActualArgument>;
diff --git a/lib/semantics/check-do.h b/lib/semantics/check-do.h
index 8d6cfeebf1e7..03d8c75212b1 100644
--- a/lib/semantics/check-do.h
+++ b/lib/semantics/check-do.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_DO_H_
 #define FORTRAN_SEMANTICS_CHECK_DO_H_
 
-#include "semantics.h"
-#include "../common/idioms.h"
+#include "flang/common/idioms.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct AssignmentStmt;
diff --git a/lib/semantics/check-if-stmt.cc b/lib/semantics/check-if-stmt.cc
index b77f11ec5214..ec423e35301c 100644
--- a/lib/semantics/check-if-stmt.cc
+++ b/lib/semantics/check-if-stmt.cc
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-if-stmt.h"
-#include "tools.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-if-stmt.h b/lib/semantics/check-if-stmt.h
index 7e6326e7d2da..01aac0ec5cf1 100644
--- a/lib/semantics/check-if-stmt.h
+++ b/lib/semantics/check-if-stmt.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
 #define FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct IfStmt;
diff --git a/lib/semantics/check-io.cc b/lib/semantics/check-io.cc
index 929907f5db0a..dc6ef9ef240f 100644
--- a/lib/semantics/check-io.cc
+++ b/lib/semantics/check-io.cc
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-io.h"
-#include "expression.h"
-#include "tools.h"
-#include "../common/format.h"
-#include "../parser/tools.h"
+#include "flang/common/format.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/tools.h"
 #include <unordered_map>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-io.h b/lib/semantics/check-io.h
index e8d61c659dbd..96315d5d865e 100644
--- a/lib/semantics/check-io.h
+++ b/lib/semantics/check-io.h
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_IO_H_
 #define FORTRAN_SEMANTICS_CHECK_IO_H_
 
-#include "semantics.h"
-#include "tools.h"
-#include "../common/enum-set.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/enum-set.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-nullify.cc b/lib/semantics/check-nullify.cc
index 7c570dad9abd..9951a1627686 100644
--- a/lib/semantics/check-nullify.cc
+++ b/lib/semantics/check-nullify.cc
@@ -8,11 +8,11 @@
 
 #include "check-nullify.h"
 #include "assignment.h"
-#include "expression.h"
-#include "tools.h"
-#include "../evaluate/expression.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
+#include "flang/evaluate/expression.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-nullify.h b/lib/semantics/check-nullify.h
index c034db7ea7ab..f06fc662c8d0 100644
--- a/lib/semantics/check-nullify.h
+++ b/lib/semantics/check-nullify.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
 #define FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct NullifyStmt;
diff --git a/lib/semantics/check-omp-structure.cc b/lib/semantics/check-omp-structure.cc
index 1c1ed3320e86..15b51d3bcdb2 100644
--- a/lib/semantics/check-omp-structure.cc
+++ b/lib/semantics/check-omp-structure.cc
@@ -7,8 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-omp-structure.h"
-#include "tools.h"
-#include "../parser/parse-tree.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/tools.h"
 #include <unordered_map>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-omp-structure.h b/lib/semantics/check-omp-structure.h
index a08884c450b9..cfe4a2f0cda5 100644
--- a/lib/semantics/check-omp-structure.h
+++ b/lib/semantics/check-omp-structure.h
@@ -14,9 +14,9 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
 #define FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
 
-#include "semantics.h"
-#include "../common/enum-set.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/enum-set.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-purity.cc b/lib/semantics/check-purity.cc
index 6d33aa1e8946..541696f4d807 100644
--- a/lib/semantics/check-purity.cc
+++ b/lib/semantics/check-purity.cc
@@ -7,8 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-purity.h"
-#include "tools.h"
-#include "../parser/parse-tree.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 void PurityChecker::Enter(const parser::ExecutableConstruct &exec) {
diff --git a/lib/semantics/check-purity.h b/lib/semantics/check-purity.h
index 80e6d7796725..189f72ca0396 100644
--- a/lib/semantics/check-purity.h
+++ b/lib/semantics/check-purity.h
@@ -8,7 +8,7 @@
 
 #ifndef FORTRAN_SEMANTICS_CHECK_PURITY_H_
 #define FORTRAN_SEMANTICS_CHECK_PURITY_H_
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 #include <list>
 namespace Fortran::parser {
 struct ExecutableConstruct;
diff --git a/lib/semantics/check-return.cc b/lib/semantics/check-return.cc
index 939bb8b37828..fc2f2cfccb1f 100644
--- a/lib/semantics/check-return.cc
+++ b/lib/semantics/check-return.cc
@@ -7,10 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-return.h"
-#include "semantics.h"
-#include "tools.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-return.h b/lib/semantics/check-return.h
index 176d9458485c..b2f4f0655e82 100644
--- a/lib/semantics/check-return.h
+++ b/lib/semantics/check-return.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_RETURN_H_
 #define FORTRAN_SEMANTICS_CHECK_RETURN_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct ReturnStmt;
diff --git a/lib/semantics/check-stop.cc b/lib/semantics/check-stop.cc
index 7655ab7365c4..0cf56e9a6085 100644
--- a/lib/semantics/check-stop.cc
+++ b/lib/semantics/check-stop.cc
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-stop.h"
-#include "semantics.h"
-#include "tools.h"
-#include "../common/Fortran.h"
-#include "../evaluate/expression.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/Fortran.h"
+#include "flang/evaluate/expression.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/tools.h"
 #include <optional>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-stop.h b/lib/semantics/check-stop.h
index 957555de0dea..3daf7da12110 100644
--- a/lib/semantics/check-stop.h
+++ b/lib/semantics/check-stop.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_STOP_H_
 #define FORTRAN_SEMANTICS_CHECK_STOP_H_
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 
 namespace Fortran::parser {
 struct StopStmt;
diff --git a/lib/semantics/expression.cc b/lib/semantics/expression.cc
index e24b31045184..3334bf27dce2 100644
--- a/lib/semantics/expression.cc
+++ b/lib/semantics/expression.cc
@@ -6,21 +6,21 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "expression.h"
+#include "flang/semantics/expression.h"
 #include "check-call.h"
 #include "pointer-assignment.h"
-#include "scope.h"
-#include "semantics.h"
-#include "symbol.h"
-#include "tools.h"
-#include "../common/idioms.h"
-#include "../evaluate/common.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/tools.h"
-#include "../parser/characters.h"
-#include "../parser/dump-parse-tree.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/common.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/dump-parse-tree.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 #include <algorithm>
 #include <functional>
 #include <optional>
diff --git a/lib/semantics/mod-file.cc b/lib/semantics/mod-file.cc
index 6846e2827f41..e0a18b28ede0 100644
--- a/lib/semantics/mod-file.cc
+++ b/lib/semantics/mod-file.cc
@@ -8,13 +8,13 @@
 
 #include "mod-file.h"
 #include "resolve-names.h"
-#include "scope.h"
-#include "semantics.h"
-#include "symbol.h"
-#include "tools.h"
-#include "../evaluate/tools.h"
-#include "../parser/message.h"
-#include "../parser/parsing.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parsing.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 #include <algorithm>
 #include <cerrno>
 #include <fstream>
diff --git a/lib/semantics/mod-file.h b/lib/semantics/mod-file.h
index 4d5afae0d5be..ba6bae0d014d 100644
--- a/lib/semantics/mod-file.h
+++ b/lib/semantics/mod-file.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_MOD_FILE_H_
 #define FORTRAN_SEMANTICS_MOD_FILE_H_
 
-#include "attr.h"
+#include "flang/semantics/attr.h"
 #include <sstream>
 #include <string>
 
diff --git a/lib/semantics/pointer-assignment.cc b/lib/semantics/pointer-assignment.cc
index 017d0e80e033..bf93bdba3998 100644
--- a/lib/semantics/pointer-assignment.cc
+++ b/lib/semantics/pointer-assignment.cc
@@ -7,18 +7,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "pointer-assignment.h"
-#include "expression.h"
-#include "symbol.h"
-#include "tools.h"
-#include "../common/idioms.h"
-#include "../common/restorer.h"
-#include "../evaluate/characteristics.h"
-#include "../evaluate/expression.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/tools.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/idioms.h"
+#include "flang/common/restorer.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 #include <optional>
 #include <set>
 #include <string>
diff --git a/lib/semantics/pointer-assignment.h b/lib/semantics/pointer-assignment.h
index 83652aef550c..70c805683016 100644
--- a/lib/semantics/pointer-assignment.h
+++ b/lib/semantics/pointer-assignment.h
@@ -9,9 +9,9 @@
 #ifndef FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
 #define FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
 
-#include "type.h"
-#include "../evaluate/expression.h"
-#include "../parser/char-block.h"
+#include "flang/evaluate/expression.h"
+#include "flang/parser/char-block.h"
+#include "flang/semantics/type.h"
 #include <string>
 
 namespace Fortran::evaluate::characteristics {
diff --git a/lib/semantics/program-tree.cc b/lib/semantics/program-tree.cc
index a026f749368d..f20819132ef4 100644
--- a/lib/semantics/program-tree.cc
+++ b/lib/semantics/program-tree.cc
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "program-tree.h"
-#include "scope.h"
-#include "../common/idioms.h"
-#include "../parser/char-block.h"
+#include "flang/common/idioms.h"
+#include "flang/parser/char-block.h"
+#include "flang/semantics/scope.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/program-tree.h b/lib/semantics/program-tree.h
index 8df2f9b960ac..88a274999361 100644
--- a/lib/semantics/program-tree.h
+++ b/lib/semantics/program-tree.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_SEMANTICS_PROGRAM_TREE_H_
 #define FORTRAN_SEMANTICS_PROGRAM_TREE_H_
 
-#include "symbol.h"
-#include "../parser/parse-tree.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/symbol.h"
 #include <variant>
 
 // A ProgramTree represents a tree of program units and their contained
diff --git a/lib/semantics/resolve-labels.cc b/lib/semantics/resolve-labels.cc
index c8c2c4293366..0c09fb41c335 100644
--- a/lib/semantics/resolve-labels.cc
+++ b/lib/semantics/resolve-labels.cc
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "resolve-labels.h"
-#include "semantics.h"
-#include "../common/enum-set.h"
-#include "../common/template.h"
-#include "../parser/parse-tree-visitor.h"
+#include "flang/common/enum-set.h"
+#include "flang/common/template.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/semantics/semantics.h"
 #include <cctype>
 #include <cstdarg>
 #include <type_traits>
diff --git a/lib/semantics/resolve-names-utils.cc b/lib/semantics/resolve-names-utils.cc
index 4fc70a6bb5ae..dd8c85d9ffa4 100644
--- a/lib/semantics/resolve-names-utils.cc
+++ b/lib/semantics/resolve-names-utils.cc
@@ -7,17 +7,17 @@
 //===----------------------------------------------------------------------===//
 
 #include "resolve-names-utils.h"
-#include "expression.h"
-#include "semantics.h"
-#include "tools.h"
-#include "../common/Fortran-features.h"
-#include "../common/idioms.h"
-#include "../common/indirection.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/tools.h"
-#include "../evaluate/type.h"
-#include "../parser/char-block.h"
-#include "../parser/parse-tree.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/idioms.h"
+#include "flang/common/indirection.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/type.h"
+#include "flang/parser/char-block.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/tools.h"
 #include <initializer_list>
 #include <ostream>
 #include <variant>
diff --git a/lib/semantics/resolve-names-utils.h b/lib/semantics/resolve-names-utils.h
index 05ca093efc71..0036cb7eb0b7 100644
--- a/lib/semantics/resolve-names-utils.h
+++ b/lib/semantics/resolve-names-utils.h
@@ -11,10 +11,10 @@
 
 // Utility functions and class for use in resolve-names.cc.
 
-#include "scope.h"
-#include "symbol.h"
-#include "type.h"
-#include "../parser/message.h"
+#include "flang/parser/message.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/type.h"
 #include <forward_list>
 
 namespace Fortran::parser {
diff --git a/lib/semantics/resolve-names.cc b/lib/semantics/resolve-names.cc
index 002024a2143d..ae20be1e942b 100644
--- a/lib/semantics/resolve-names.cc
+++ b/lib/semantics/resolve-names.cc
@@ -8,30 +8,30 @@
 
 #include "resolve-names.h"
 #include "assignment.h"
-#include "attr.h"
-#include "expression.h"
 #include "mod-file.h"
 #include "program-tree.h"
 #include "resolve-names-utils.h"
 #include "rewrite-parse-tree.h"
-#include "scope.h"
-#include "semantics.h"
-#include "symbol.h"
-#include "tools.h"
-#include "type.h"
-#include "../common/Fortran.h"
-#include "../common/default-kinds.h"
-#include "../common/indirection.h"
-#include "../common/restorer.h"
-#include "../evaluate/characteristics.h"
-#include "../evaluate/common.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/intrinsics.h"
-#include "../evaluate/tools.h"
-#include "../evaluate/type.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/parse-tree.h"
-#include "../parser/tools.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/default-kinds.h"
+#include "flang/common/indirection.h"
+#include "flang/common/restorer.h"
+#include "flang/evaluate/characteristics.h"
+#include "flang/evaluate/common.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/intrinsics.h"
+#include "flang/evaluate/tools.h"
+#include "flang/evaluate/type.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/attr.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
+#include "flang/semantics/type.h"
 #include <list>
 #include <map>
 #include <ostream>
diff --git a/lib/semantics/rewrite-parse-tree.cc b/lib/semantics/rewrite-parse-tree.cc
index c23aad7e6fe3..932a6ecd1e3e 100644
--- a/lib/semantics/rewrite-parse-tree.cc
+++ b/lib/semantics/rewrite-parse-tree.cc
@@ -7,14 +7,14 @@
 //===----------------------------------------------------------------------===//
 
 #include "rewrite-parse-tree.h"
-#include "scope.h"
-#include "semantics.h"
-#include "symbol.h"
-#include "tools.h"
-#include "../common/indirection.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/parse-tree.h"
-#include "../parser/tools.h"
+#include "flang/common/indirection.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 #include <list>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/scope.cc b/lib/semantics/scope.cc
index 9173d9499000..23166b15cfeb 100644
--- a/lib/semantics/scope.cc
+++ b/lib/semantics/scope.cc
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "scope.h"
-#include "symbol.h"
-#include "type.h"
-#include "../parser/characters.h"
+#include "flang/semantics/scope.h"
+#include "flang/parser/characters.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/type.h"
 #include <algorithm>
 #include <memory>
 #include <sstream>
diff --git a/lib/semantics/semantics.cc b/lib/semantics/semantics.cc
index cac83ec28b73..7642366ccd17 100644
--- a/lib/semantics/semantics.cc
+++ b/lib/semantics/semantics.cc
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "semantics.h"
+#include "flang/semantics/semantics.h"
 #include "assignment.h"
 #include "canonicalize-do.h"
 #include "canonicalize-omp.h"
@@ -23,16 +23,16 @@
 #include "check-purity.h"
 #include "check-return.h"
 #include "check-stop.h"
-#include "expression.h"
 #include "mod-file.h"
 #include "resolve-labels.h"
 #include "resolve-names.h"
 #include "rewrite-parse-tree.h"
-#include "scope.h"
-#include "symbol.h"
-#include "../common/default-kinds.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/tools.h"
+#include "flang/common/default-kinds.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/symbol.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/symbol.cc b/lib/semantics/symbol.cc
index 4015cf754103..6393fa115709 100644
--- a/lib/semantics/symbol.cc
+++ b/lib/semantics/symbol.cc
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "symbol.h"
-#include "scope.h"
-#include "semantics.h"
-#include "tools.h"
-#include "../common/idioms.h"
-#include "../evaluate/expression.h"
+#include "flang/semantics/symbol.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/expression.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/tools.h"
 #include <ostream>
 #include <string>
 
diff --git a/lib/semantics/tools.cc b/lib/semantics/tools.cc
index 8342e4126259..24b87b496e2d 100644
--- a/lib/semantics/tools.cc
+++ b/lib/semantics/tools.cc
@@ -6,17 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "tools.h"
-#include "scope.h"
-#include "semantics.h"
-#include "symbol.h"
-#include "type.h"
-#include "../common/Fortran.h"
-#include "../common/indirection.h"
-#include "../parser/dump-parse-tree.h"
-#include "../parser/message.h"
-#include "../parser/parse-tree.h"
-#include "../parser/tools.h"
+#include "flang/parser/tools.h"
+#include "flang/common/Fortran.h"
+#include "flang/common/indirection.h"
+#include "flang/parser/dump-parse-tree.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
+#include "flang/semantics/type.h"
 #include <algorithm>
 #include <set>
 #include <sstream>
@@ -83,7 +83,8 @@ Tristate IsDefinedAssignment(
     const auto *lhsDerived{evaluate::GetDerivedTypeSpec(lhsType)};
     const auto *rhsDerived{evaluate::GetDerivedTypeSpec(rhsType)};
     if (lhsDerived && rhsDerived && *lhsDerived == *rhsDerived) {
-      return Tristate::Maybe;  // TYPE(t) = TYPE(t) can be defined or intrinsic
+      return Tristate::Maybe;  // TYPE(t) = TYPE(t) can be defined or
+                               // intrinsic
     } else {
       return Tristate::Yes;
     }
@@ -1275,5 +1276,4 @@ void LabelEnforce::SayWithConstruct(SemanticsContext &context,
   context.Say(stmtLocation, message)
       .Attach(constructLocation, GetEnclosingConstructMsg());
 }
-
 }
diff --git a/lib/semantics/type.cc b/lib/semantics/type.cc
index 3e96186f6563..0f196dbeb369 100644
--- a/lib/semantics/type.cc
+++ b/lib/semantics/type.cc
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "type.h"
-#include "scope.h"
-#include "symbol.h"
-#include "tools.h"
-#include "../evaluate/fold.h"
-#include "../parser/characters.h"
+#include "flang/semantics/type.h"
+#include "flang/evaluate/fold.h"
+#include "flang/parser/characters.h"
+#include "flang/semantics/scope.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/tools.h"
 #include <ostream>
 #include <sstream>
 
diff --git a/lib/semantics/unparse-with-symbols.cc b/lib/semantics/unparse-with-symbols.cc
index 67d27f9c7057..70ed49d4fa22 100644
--- a/lib/semantics/unparse-with-symbols.cc
+++ b/lib/semantics/unparse-with-symbols.cc
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "unparse-with-symbols.h"
-#include "symbol.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../parser/parse-tree.h"
-#include "../parser/unparse.h"
+#include "flang/semantics/unparse-with-symbols.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/unparse.h"
+#include "flang/semantics/symbol.h"
 #include <map>
 #include <ostream>
 #include <set>
diff --git a/runtime/derived-type.h b/runtime/derived-type.h
index e55c770b5d29..1d0e8502745e 100644
--- a/runtime/derived-type.h
+++ b/runtime/derived-type.h
@@ -10,7 +10,7 @@
 #define FORTRAN_RUNTIME_DERIVED_TYPE_H_
 
 #include "type-code.h"
-#include "../include/flang/ISO_Fortran_binding.h"
+#include "flang/ISO_Fortran_binding.h"
 #include <cinttypes>
 #include <cstddef>
 
diff --git a/runtime/descriptor.cc b/runtime/descriptor.cc
index 8cd66bf48c95..e412df410dd7 100644
--- a/runtime/descriptor.cc
+++ b/runtime/descriptor.cc
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "descriptor.h"
-#include "../lib/common/idioms.h"
+#include "flang/common/idioms.h"
 #include <cassert>
 #include <cstdlib>
 
diff --git a/runtime/descriptor.h b/runtime/descriptor.h
index 5d5dd094ea8e..3a4f2ce3a29c 100644
--- a/runtime/descriptor.h
+++ b/runtime/descriptor.h
@@ -20,7 +20,7 @@
 
 #include "derived-type.h"
 #include "type-code.h"
-#include "../include/flang/ISO_Fortran_binding.h"
+#include "flang/ISO_Fortran_binding.h"
 #include <cassert>
 #include <cinttypes>
 #include <cstddef>
diff --git a/runtime/format.cc b/runtime/format.cc
index 9324d1528a65..2dd76e389bb3 100644
--- a/runtime/format.cc
+++ b/runtime/format.cc
@@ -8,8 +8,8 @@
 
 #include "format.h"
 #include "io-stmt.h"
-#include "../lib/common/format.h"
-#include "../lib/decimal/decimal.h"
+#include "flang/common/format.h"
+#include "flang/decimal/decimal.h"
 #include <limits>
 
 namespace Fortran::runtime::io {
diff --git a/runtime/format.h b/runtime/format.h
index 1f576d24bb46..ed164e8902d1 100644
--- a/runtime/format.h
+++ b/runtime/format.h
@@ -12,7 +12,7 @@
 #define FORTRAN_RUNTIME_FORMAT_H_
 
 #include "terminator.h"
-#include "../lib/common/Fortran.h"
+#include "flang/common/Fortran.h"
 #include <cinttypes>
 #include <optional>
 
diff --git a/runtime/transformational.cc b/runtime/transformational.cc
index 6c1144717e6c..bd408dec02ee 100644
--- a/runtime/transformational.cc
+++ b/runtime/transformational.cc
@@ -7,7 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "transformational.h"
-#include "../lib/common/idioms.h"
+#include "flang/common/idioms.h"
+#include "flang/evaluate/integer.h"
 #include <algorithm>
 #include <bitset>
 #include <cinttypes>
diff --git a/runtime/type-code.h b/runtime/type-code.h
index 497549997ac1..b04d45388371 100644
--- a/runtime/type-code.h
+++ b/runtime/type-code.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_RUNTIME_TYPE_CODE_H_
 #define FORTRAN_RUNTIME_TYPE_CODE_H_
 
-#include "../include/flang/ISO_Fortran_binding.h"
-#include "../lib/common/Fortran.h"
+#include "flang/ISO_Fortran_binding.h"
+#include "flang/common/Fortran.h"
 
 namespace Fortran::runtime {
 
diff --git a/test/decimal/quick-sanity-test.cc b/test/decimal/quick-sanity-test.cc
index 49c8ada29452..d9ebf8d3a0dd 100644
--- a/test/decimal/quick-sanity-test.cc
+++ b/test/decimal/quick-sanity-test.cc
@@ -1,4 +1,4 @@
-#include "../../lib/decimal/decimal.h"
+#include "flang/decimal/decimal.h"
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
diff --git a/test/decimal/thorough-test.cc b/test/decimal/thorough-test.cc
index 40e37adf22dc..f5e3274d3208 100644
--- a/test/decimal/thorough-test.cc
+++ b/test/decimal/thorough-test.cc
@@ -1,4 +1,4 @@
-#include "../../lib/decimal/decimal.h"
+#include "flang/decimal/decimal.h"
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
diff --git a/test/evaluate/bit-population-count.cc b/test/evaluate/bit-population-count.cc
index 162ea7835ab8..0b98f644c215 100644
--- a/test/evaluate/bit-population-count.cc
+++ b/test/evaluate/bit-population-count.cc
@@ -1,4 +1,4 @@
-#include "../../lib/common/bit-population-count.h"
+#include "flang/common/bit-population-count.h"
 #include "testing.h"
 
 using Fortran::common::BitPopulationCount;
diff --git a/test/evaluate/expression.cc b/test/evaluate/expression.cc
index 24a6e0f5f5d7..ced868d5a5e2 100644
--- a/test/evaluate/expression.cc
+++ b/test/evaluate/expression.cc
@@ -1,9 +1,9 @@
-#include "../../lib/evaluate/expression.h"
+#include "flang/evaluate/expression.h"
 #include "testing.h"
-#include "../../lib/evaluate/fold.h"
-#include "../../lib/evaluate/intrinsics.h"
-#include "../../lib/evaluate/tools.h"
-#include "../../lib/parser/message.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/intrinsics.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/message.h"
 #include <cstdio>
 #include <cstdlib>
 #include <string>
diff --git a/test/evaluate/folding.cc b/test/evaluate/folding.cc
index 83ec52aa92fe..f72670ed60eb 100644
--- a/test/evaluate/folding.cc
+++ b/test/evaluate/folding.cc
@@ -1,11 +1,11 @@
 #include "testing.h"
-#include "../../lib/evaluate/call.h"
-#include "../../lib/evaluate/expression.h"
-#include "../../lib/evaluate/fold.h"
 #include "../../lib/evaluate/host.h"
 #include "../../lib/evaluate/intrinsics-library-templates.h"
-#include "../../lib/evaluate/intrinsics.h"
-#include "../../lib/evaluate/tools.h"
+#include "flang/evaluate/call.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/intrinsics.h"
+#include "flang/evaluate/tools.h"
 #include <tuple>
 
 using namespace Fortran::evaluate;
diff --git a/test/evaluate/fp-testing.h b/test/evaluate/fp-testing.h
index acb2d68d3eb4..c86fbbaa2700 100644
--- a/test/evaluate/fp-testing.h
+++ b/test/evaluate/fp-testing.h
@@ -1,7 +1,7 @@
 #ifndef FORTRAN_TEST_EVALUATE_FP_TESTING_H_
 #define FORTRAN_TEST_EVALUATE_FP_TESTING_H_
 
-#include "../../lib/evaluate/common.h"
+#include "flang/evaluate/common.h"
 #include <fenv.h>
 
 using Fortran::common::RoundingMode;
diff --git a/test/evaluate/integer.cc b/test/evaluate/integer.cc
index db024184f723..e31f230cb88a 100644
--- a/test/evaluate/integer.cc
+++ b/test/evaluate/integer.cc
@@ -1,4 +1,4 @@
-#include "../../lib/evaluate/integer.h"
+#include "flang/evaluate/integer.h"
 #include "testing.h"
 #include <cstdio>
 #include <string>
diff --git a/test/evaluate/intrinsics.cc b/test/evaluate/intrinsics.cc
index cb9260b4c2d1..1826a4691b9d 100644
--- a/test/evaluate/intrinsics.cc
+++ b/test/evaluate/intrinsics.cc
@@ -1,9 +1,9 @@
-#include "../../lib/evaluate/intrinsics.h"
+#include "flang/evaluate/intrinsics.h"
 #include "testing.h"
-#include "../../lib/evaluate/common.h"
-#include "../../lib/evaluate/expression.h"
-#include "../../lib/evaluate/tools.h"
-#include "../../lib/parser/provenance.h"
+#include "flang/evaluate/common.h"
+#include "flang/evaluate/expression.h"
+#include "flang/evaluate/tools.h"
+#include "flang/parser/provenance.h"
 #include <initializer_list>
 #include <iostream>
 #include <map>
diff --git a/test/evaluate/leading-zero-bit-count.cc b/test/evaluate/leading-zero-bit-count.cc
index 2ab53aa605a2..1abd0f7b6c11 100644
--- a/test/evaluate/leading-zero-bit-count.cc
+++ b/test/evaluate/leading-zero-bit-count.cc
@@ -1,4 +1,4 @@
-#include "../../lib/common/leading-zero-bit-count.h"
+#include "flang/common/leading-zero-bit-count.h"
 #include "testing.h"
 
 using Fortran::common::LeadingZeroBitCount;
diff --git a/test/evaluate/logical.cc b/test/evaluate/logical.cc
index 8b37a79c78db..3edbd6afd142 100644
--- a/test/evaluate/logical.cc
+++ b/test/evaluate/logical.cc
@@ -1,5 +1,5 @@
 #include "testing.h"
-#include "../../lib/evaluate/type.h"
+#include "flang/evaluate/type.h"
 #include <cstdio>
 
 template<int KIND> void testKind() {
diff --git a/test/evaluate/real.cc b/test/evaluate/real.cc
index 7ac487866c78..919bc3ca87c7 100644
--- a/test/evaluate/real.cc
+++ b/test/evaluate/real.cc
@@ -1,6 +1,6 @@
 #include "fp-testing.h"
 #include "testing.h"
-#include "../../lib/evaluate/type.h"
+#include "flang/evaluate/type.h"
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
diff --git a/test/evaluate/uint128.cc b/test/evaluate/uint128.cc
index 3b693bc91485..6a20d32de92a 100644
--- a/test/evaluate/uint128.cc
+++ b/test/evaluate/uint128.cc
@@ -1,5 +1,5 @@
 #define AVOID_NATIVE_UINT128_T 1
-#include "../../lib/common/uint128.h"
+#include "flang/common/uint128.h"
 #include "testing.h"
 #include <cinttypes>
 #include <iostream>
diff --git a/tools/f18/f18-parse-demo.cc b/tools/f18/f18-parse-demo.cc
index 4bb30f9767e3..f65b47b78341 100644
--- a/tools/f18/f18-parse-demo.cc
+++ b/tools/f18/f18-parse-demo.cc
@@ -21,16 +21,16 @@
 // scaffolding compiler driver that can test some semantic passes of the
 // F18 compiler under development.
 
-#include "../../lib/common/Fortran-features.h"
-#include "../../lib/common/default-kinds.h"
-#include "../../lib/parser/characters.h"
-#include "../../lib/parser/dump-parse-tree.h"
-#include "../../lib/parser/message.h"
-#include "../../lib/parser/parse-tree-visitor.h"
-#include "../../lib/parser/parse-tree.h"
-#include "../../lib/parser/parsing.h"
-#include "../../lib/parser/provenance.h"
-#include "../../lib/parser/unparse.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/default-kinds.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/dump-parse-tree.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/parsing.h"
+#include "flang/parser/provenance.h"
+#include "flang/parser/unparse.h"
 #include <cerrno>
 #include <cstdio>
 #include <cstring>
diff --git a/tools/f18/f18.cc b/tools/f18/f18.cc
index 6e6854051b4c..32a5cd4dce81 100644
--- a/tools/f18/f18.cc
+++ b/tools/f18/f18.cc
@@ -8,20 +8,20 @@
 
 // Temporary Fortran front end driver main program for development scaffolding.
 
-#include "../../lib/common/Fortran-features.h"
-#include "../../lib/common/default-kinds.h"
-#include "../../lib/evaluate/expression.h"
-#include "../../lib/parser/characters.h"
-#include "../../lib/parser/dump-parse-tree.h"
-#include "../../lib/parser/message.h"
-#include "../../lib/parser/parse-tree-visitor.h"
-#include "../../lib/parser/parse-tree.h"
-#include "../../lib/parser/parsing.h"
-#include "../../lib/parser/provenance.h"
-#include "../../lib/parser/unparse.h"
-#include "../../lib/semantics/expression.h"
-#include "../../lib/semantics/semantics.h"
-#include "../../lib/semantics/unparse-with-symbols.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/default-kinds.h"
+#include "flang/evaluate/expression.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/dump-parse-tree.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/parsing.h"
+#include "flang/parser/provenance.h"
+#include "flang/parser/unparse.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/unparse-with-symbols.h"
 #include <cerrno>
 #include <cstdio>
 #include <cstring>
diff --git a/tools/f18/stub-evaluate.cc b/tools/f18/stub-evaluate.cc
index 14f16c7bda62..0b2020383b71 100644
--- a/tools/f18/stub-evaluate.cc
+++ b/tools/f18/stub-evaluate.cc
@@ -11,7 +11,7 @@
 // libraries, as here, we need to stub out the dependences on the external
 // destructors, which will never actually be called.
 
-#include "../../lib/common/indirection.h"
+#include "flang/common/indirection.h"
 
 namespace Fortran::evaluate {
 struct GenericExprWrapper {

From ae7721e611918631d1e3821dbb60f5ffcd9a69b1 Mon Sep 17 00:00:00 2001
From: Alexis Perry <AlexisPerry@users.noreply.github.com>
Date: Mon, 27 Jan 2020 19:18:45 -0700
Subject: [PATCH 012/345] Changed *.cc file extension to *.cpp (updated
 scripts) (#958)

Updated CMake files accordingly, using better regex
Updated license headers to match new extension and fit within 80 columns
Updated other comments within files that referred to the old extension
---
 documentation/C++style.md                     |  8 +--
 documentation/PullRequestChecklist.md         |  2 +-
 include/flang/evaluate/traverse.h             |  2 +-
 lib/common/CMakeLists.txt                     |  8 +--
 ...rtran-features.cc => Fortran-features.cpp} |  2 +-
 lib/common/{Fortran.cc => Fortran.cpp}        |  2 +-
 .../{default-kinds.cc => default-kinds.cpp}   |  2 +-
 lib/common/{idioms.cc => idioms.cpp}          |  2 +-
 lib/decimal/CMakeLists.txt                    |  4 +-
 ...ry-to-decimal.cc => binary-to-decimal.cpp} |  2 +-
 ...mal-to-binary.cc => decimal-to-binary.cpp} |  2 +-
 lib/evaluate/CMakeLists.txt                   | 50 +++++++--------
 lib/evaluate/{call.cc => call.cpp}            |  2 +-
 ...characteristics.cc => characteristics.cpp} |  2 +-
 ...eck-expression.cc => check-expression.cpp} |  2 +-
 lib/evaluate/{common.cc => common.cpp}        |  2 +-
 lib/evaluate/{complex.cc => complex.cpp}      |  2 +-
 lib/evaluate/{constant.cc => constant.cpp}    |  2 +-
 .../{expression.cc => expression.cpp}         |  2 +-
 .../{fold-character.cc => fold-character.cpp} |  2 +-
 .../{fold-complex.cc => fold-complex.cpp}     |  2 +-
 .../{fold-integer.cc => fold-integer.cpp}     |  2 +-
 .../{fold-logical.cc => fold-logical.cpp}     |  2 +-
 lib/evaluate/{fold-real.cc => fold-real.cpp}  |  2 +-
 lib/evaluate/{fold.cc => fold.cpp}            |  2 +-
 .../{formatting.cc => formatting.cpp}         |  2 +-
 lib/evaluate/{host.cc => host.cpp}            |  2 +-
 lib/evaluate/{integer.cc => integer.cpp}      |  2 +-
 lib/evaluate/intrinsics-library-templates.h   |  2 +-
 ...sics-library.cc => intrinsics-library.cpp} |  2 +-
 .../{intrinsics.cc => intrinsics.cpp}         |  2 +-
 lib/evaluate/{logical.cc => logical.cpp}      |  2 +-
 lib/evaluate/{real.cc => real.cpp}            |  2 +-
 lib/evaluate/{shape.cc => shape.cpp}          |  2 +-
 .../{static-data.cc => static-data.cpp}       |  2 +-
 lib/evaluate/{tools.cc => tools.cpp}          |  2 +-
 lib/evaluate/{type.cc => type.cpp}            |  2 +-
 lib/evaluate/{variable.cc => variable.cpp}    |  2 +-
 lib/parser/CMakeLists.txt                     | 46 ++++++-------
 ...Fortran-parsers.cc => Fortran-parsers.cpp} | 12 ++--
 lib/parser/{char-block.cc => char-block.cpp}  |  2 +-
 .../{char-buffer.cc => char-buffer.cpp}       |  2 +-
 lib/parser/{char-set.cc => char-set.cpp}      |  2 +-
 lib/parser/{characters.cc => characters.cpp}  |  2 +-
 .../{debug-parser.cc => debug-parser.cpp}     |  2 +-
 ...able-parsers.cc => executable-parsers.cpp} |  2 +-
 .../{expr-parsers.cc => expr-parsers.cpp}     |  2 +-
 ...nted-parser.cc => instrumented-parser.cpp} |  2 +-
 lib/parser/{io-parsers.cc => io-parsers.cpp}  |  2 +-
 lib/parser/{message.cc => message.cpp}        |  2 +-
 .../{openmp-parsers.cc => openmp-parsers.cpp} |  2 +-
 lib/parser/{parse-tree.cc => parse-tree.cpp}  |  2 +-
 lib/parser/{parsing.cc => parsing.cpp}        |  2 +-
 .../{preprocessor.cc => preprocessor.cpp}     |  2 +-
 lib/parser/{prescan.cc => prescan.cpp}        |  2 +-
 ...program-parsers.cc => program-parsers.cpp} |  2 +-
 lib/parser/{provenance.cc => provenance.cpp}  |  2 +-
 lib/parser/{source.cc => source.cpp}          |  2 +-
 .../{token-sequence.cc => token-sequence.cpp} |  2 +-
 lib/parser/{tools.cc => tools.cpp}            |  2 +-
 lib/parser/{unparse.cc => unparse.cpp}        |  2 +-
 lib/parser/{user-state.cc => user-state.cpp}  |  2 +-
 lib/semantics/CMakeLists.txt                  | 64 +++++++++----------
 .../{assignment.cc => assignment.cpp}         |  4 +-
 lib/semantics/{attr.cc => attr.cpp}           |  2 +-
 ...canonicalize-do.cc => canonicalize-do.cpp} |  2 +-
 ...nonicalize-omp.cc => canonicalize-omp.cpp} |  2 +-
 .../{check-allocate.cc => check-allocate.cpp} |  2 +-
 ...arithmeticif.cc => check-arithmeticif.cpp} |  2 +-
 .../{check-call.cc => check-call.cpp}         |  2 +-
 .../{check-coarray.cc => check-coarray.cpp}   |  2 +-
 ...eck-deallocate.cc => check-deallocate.cpp} |  2 +-
 ...declarations.cc => check-declarations.cpp} |  4 +-
 lib/semantics/{check-do.cc => check-do.cpp}   |  2 +-
 .../{check-if-stmt.cc => check-if-stmt.cpp}   |  2 +-
 lib/semantics/{check-io.cc => check-io.cpp}   |  2 +-
 .../{check-nullify.cc => check-nullify.cpp}   |  2 +-
 ...p-structure.cc => check-omp-structure.cpp} |  2 +-
 .../{check-purity.cc => check-purity.cpp}     |  2 +-
 .../{check-return.cc => check-return.cpp}     |  2 +-
 .../{check-stop.cc => check-stop.cpp}         |  2 +-
 .../{expression.cc => expression.cpp}         |  2 +-
 lib/semantics/{mod-file.cc => mod-file.cpp}   |  2 +-
 ...r-assignment.cc => pointer-assignment.cpp} |  2 +-
 .../{program-tree.cc => program-tree.cpp}     |  2 +-
 .../{resolve-labels.cc => resolve-labels.cpp} |  2 +-
 ...names-utils.cc => resolve-names-utils.cpp} |  2 +-
 lib/semantics/resolve-names-utils.h           |  2 +-
 .../{resolve-names.cc => resolve-names.cpp}   |  4 +-
 ...e-parse-tree.cc => rewrite-parse-tree.cpp} |  2 +-
 lib/semantics/{scope.cc => scope.cpp}         |  2 +-
 lib/semantics/{semantics.cc => semantics.cpp} |  2 +-
 lib/semantics/{symbol.cc => symbol.cpp}       |  2 +-
 lib/semantics/{tools.cc => tools.cpp}         |  2 +-
 lib/semantics/{type.cc => type.cpp}           |  2 +-
 ...th-symbols.cc => unparse-with-symbols.cpp} |  2 +-
 runtime/CMakeLists.txt                        | 30 ++++-----
 ...ran_binding.cc => ISO_Fortran_binding.cpp} |  2 +-
 runtime/{derived-type.cc => derived-type.cpp} |  2 +-
 runtime/{descriptor.cc => descriptor.cpp}     |  2 +-
 runtime/{file.cc => file.cpp}                 |  2 +-
 runtime/{format.cc => format.cpp}             |  2 +-
 runtime/{io-api.cc => io-api.cpp}             |  2 +-
 runtime/{io-error.cc => io-error.cpp}         |  2 +-
 runtime/{io-stmt.cc => io-stmt.cpp}           |  2 +-
 runtime/{main.cc => main.cpp}                 |  2 +-
 runtime/{memory.cc => memory.cpp}             |  2 +-
 runtime/{stop.cc => stop.cpp}                 |  2 +-
 runtime/{terminator.cc => terminator.cpp}     |  2 +-
 runtime/{tools.cc => tools.cpp}               |  2 +-
 ...ansformational.cc => transformational.cpp} |  2 +-
 runtime/{type-code.cc => type-code.cpp}       |  2 +-
 test/decimal/CMakeLists.txt                   |  4 +-
 ...k-sanity-test.cc => quick-sanity-test.cpp} |  0
 .../{thorough-test.cc => thorough-test.cpp}   |  0
 test/evaluate/CMakeLists.txt                  | 28 ++++----
 ...ran-binding.cc => ISO-Fortran-binding.cpp} |  0
 ...tion-count.cc => bit-population-count.cpp} |  0
 .../{expression.cc => expression.cpp}         |  0
 test/evaluate/{folding.cc => folding.cpp}     |  2 +-
 .../{fp-testing.cc => fp-testing.cpp}         |  0
 test/evaluate/{integer.cc => integer.cpp}     |  0
 .../{intrinsics.cc => intrinsics.cpp}         |  0
 ...it-count.cc => leading-zero-bit-count.cpp} |  0
 test/evaluate/{logical.cc => logical.cpp}     |  0
 test/evaluate/{real.cc => real.cpp}           |  0
 test/evaluate/{reshape.cc => reshape.cpp}     |  0
 test/evaluate/{testing.cc => testing.cpp}     |  0
 test/evaluate/{uint128.cc => uint128.cpp}     |  0
 test/runtime/CMakeLists.txt                   |  4 +-
 test/runtime/{format.cc => format.cpp}        |  2 +-
 test/runtime/{hello.cc => hello.cpp}          |  0
 tools/f18/CMakeLists.txt                      |  8 +--
 tools/f18/{dump.cc => dump.cpp}               |  2 +-
 .../{f18-parse-demo.cc => f18-parse-demo.cpp} |  4 +-
 tools/f18/{f18.cc => f18.cpp}                 |  2 +-
 .../{stub-evaluate.cc => stub-evaluate.cpp}   |  2 +-
 137 files changed, 247 insertions(+), 247 deletions(-)
 rename lib/common/{Fortran-features.cc => Fortran-features.cpp} (96%)
 rename lib/common/{Fortran.cc => Fortran.cpp} (95%)
 rename lib/common/{default-kinds.cc => default-kinds.cpp} (96%)
 rename lib/common/{idioms.cc => idioms.cpp} (94%)
 rename lib/decimal/{binary-to-decimal.cc => binary-to-decimal.cpp} (99%)
 rename lib/decimal/{decimal-to-binary.cc => decimal-to-binary.cpp} (99%)
 rename lib/evaluate/{call.cc => call.cpp} (99%)
 rename lib/evaluate/{characteristics.cc => characteristics.cpp} (99%)
 rename lib/evaluate/{check-expression.cc => check-expression.cpp} (99%)
 rename lib/evaluate/{common.cc => common.cpp} (96%)
 rename lib/evaluate/{complex.cc => complex.cpp} (98%)
 rename lib/evaluate/{constant.cc => constant.cpp} (99%)
 rename lib/evaluate/{expression.cc => expression.cpp} (99%)
 rename lib/evaluate/{fold-character.cc => fold-character.cpp} (98%)
 rename lib/evaluate/{fold-complex.cc => fold-complex.cpp} (98%)
 rename lib/evaluate/{fold-integer.cc => fold-integer.cpp} (99%)
 rename lib/evaluate/{fold-logical.cc => fold-logical.cpp} (99%)
 rename lib/evaluate/{fold-real.cc => fold-real.cpp} (99%)
 rename lib/evaluate/{fold.cc => fold.cpp} (99%)
 rename lib/evaluate/{formatting.cc => formatting.cpp} (99%)
 rename lib/evaluate/{host.cc => host.cpp} (98%)
 rename lib/evaluate/{integer.cc => integer.cpp} (94%)
 rename lib/evaluate/{intrinsics-library.cc => intrinsics-library.cpp} (99%)
 rename lib/evaluate/{intrinsics.cc => intrinsics.cpp} (99%)
 rename lib/evaluate/{logical.cc => logical.cpp} (88%)
 rename lib/evaluate/{real.cc => real.cpp} (99%)
 rename lib/evaluate/{shape.cc => shape.cpp} (99%)
 rename lib/evaluate/{static-data.cc => static-data.cpp} (97%)
 rename lib/evaluate/{tools.cc => tools.cpp} (99%)
 rename lib/evaluate/{type.cc => type.cpp} (99%)
 rename lib/evaluate/{variable.cc => variable.cpp} (99%)
 rename lib/parser/{Fortran-parsers.cc => Fortran-parsers.cpp} (99%)
 rename lib/parser/{char-block.cc => char-block.cpp} (88%)
 rename lib/parser/{char-buffer.cc => char-buffer.cpp} (97%)
 rename lib/parser/{char-set.cc => char-set.cpp} (90%)
 rename lib/parser/{characters.cc => characters.cpp} (99%)
 rename lib/parser/{debug-parser.cc => debug-parser.cpp} (92%)
 rename lib/parser/{executable-parsers.cc => executable-parsers.cpp} (99%)
 rename lib/parser/{expr-parsers.cc => expr-parsers.cpp} (99%)
 rename lib/parser/{instrumented-parser.cc => instrumented-parser.cpp} (97%)
 rename lib/parser/{io-parsers.cc => io-parsers.cpp} (99%)
 rename lib/parser/{message.cc => message.cpp} (99%)
 rename lib/parser/{openmp-parsers.cc => openmp-parsers.cpp} (99%)
 rename lib/parser/{parse-tree.cc => parse-tree.cpp} (99%)
 rename lib/parser/{parsing.cc => parsing.cpp} (98%)
 rename lib/parser/{preprocessor.cc => preprocessor.cpp} (99%)
 rename lib/parser/{prescan.cc => prescan.cpp} (99%)
 rename lib/parser/{program-parsers.cc => program-parsers.cpp} (99%)
 rename lib/parser/{provenance.cc => provenance.cpp} (99%)
 rename lib/parser/{source.cc => source.cpp} (99%)
 rename lib/parser/{token-sequence.cc => token-sequence.cpp} (99%)
 rename lib/parser/{tools.cc => tools.cpp} (97%)
 rename lib/parser/{unparse.cc => unparse.cpp} (99%)
 rename lib/parser/{user-state.cc => user-state.cpp} (97%)
 rename lib/semantics/{assignment.cc => assignment.cpp} (99%)
 rename lib/semantics/{attr.cc => attr.cpp} (95%)
 rename lib/semantics/{canonicalize-do.cc => canonicalize-do.cpp} (98%)
 rename lib/semantics/{canonicalize-omp.cc => canonicalize-omp.cpp} (98%)
 rename lib/semantics/{check-allocate.cc => check-allocate.cpp} (99%)
 rename lib/semantics/{check-arithmeticif.cc => check-arithmeticif.cpp} (96%)
 rename lib/semantics/{check-call.cc => check-call.cpp} (99%)
 rename lib/semantics/{check-coarray.cc => check-coarray.cpp} (98%)
 rename lib/semantics/{check-deallocate.cc => check-deallocate.cpp} (97%)
 rename lib/semantics/{check-declarations.cc => check-declarations.cpp} (99%)
 rename lib/semantics/{check-do.cc => check-do.cpp} (99%)
 rename lib/semantics/{check-if-stmt.cc => check-if-stmt.cpp} (93%)
 rename lib/semantics/{check-io.cc => check-io.cpp} (99%)
 rename lib/semantics/{check-nullify.cc => check-nullify.cpp} (97%)
 rename lib/semantics/{check-omp-structure.cc => check-omp-structure.cpp} (99%)
 rename lib/semantics/{check-purity.cc => check-purity.cpp} (97%)
 rename lib/semantics/{check-return.cc => check-return.cpp} (96%)
 rename lib/semantics/{check-stop.cc => check-stop.cpp} (95%)
 rename lib/semantics/{expression.cc => expression.cpp} (99%)
 rename lib/semantics/{mod-file.cc => mod-file.cpp} (99%)
 rename lib/semantics/{pointer-assignment.cc => pointer-assignment.cpp} (99%)
 rename lib/semantics/{program-tree.cc => program-tree.cpp} (99%)
 rename lib/semantics/{resolve-labels.cc => resolve-labels.cpp} (99%)
 rename lib/semantics/{resolve-names-utils.cc => resolve-names-utils.cpp} (99%)
 rename lib/semantics/{resolve-names.cc => resolve-names.cpp} (99%)
 rename lib/semantics/{rewrite-parse-tree.cc => rewrite-parse-tree.cpp} (98%)
 rename lib/semantics/{scope.cc => scope.cpp} (99%)
 rename lib/semantics/{semantics.cc => semantics.cpp} (99%)
 rename lib/semantics/{symbol.cc => symbol.cpp} (99%)
 rename lib/semantics/{tools.cc => tools.cpp} (99%)
 rename lib/semantics/{type.cc => type.cpp} (99%)
 rename lib/semantics/{unparse-with-symbols.cc => unparse-with-symbols.cpp} (98%)
 rename runtime/{ISO_Fortran_binding.cc => ISO_Fortran_binding.cpp} (99%)
 rename runtime/{derived-type.cc => derived-type.cpp} (97%)
 rename runtime/{descriptor.cc => descriptor.cpp} (98%)
 rename runtime/{file.cc => file.cpp} (99%)
 rename runtime/{format.cc => format.cpp} (99%)
 rename runtime/{io-api.cc => io-api.cpp} (94%)
 rename runtime/{io-error.cc => io-error.cpp} (96%)
 rename runtime/{io-stmt.cc => io-stmt.cpp} (97%)
 rename runtime/{main.cc => main.cpp} (96%)
 rename runtime/{memory.cc => memory.cpp} (92%)
 rename runtime/{stop.cc => stop.cpp} (96%)
 rename runtime/{terminator.cc => terminator.cpp} (95%)
 rename runtime/{tools.cc => tools.cpp} (95%)
 rename runtime/{transformational.cc => transformational.cpp} (98%)
 rename runtime/{type-code.cc => type-code.cpp} (96%)
 rename test/decimal/{quick-sanity-test.cc => quick-sanity-test.cpp} (100%)
 rename test/decimal/{thorough-test.cc => thorough-test.cpp} (100%)
 rename test/evaluate/{ISO-Fortran-binding.cc => ISO-Fortran-binding.cpp} (100%)
 rename test/evaluate/{bit-population-count.cc => bit-population-count.cpp} (100%)
 rename test/evaluate/{expression.cc => expression.cpp} (100%)
 rename test/evaluate/{folding.cc => folding.cpp} (98%)
 rename test/evaluate/{fp-testing.cc => fp-testing.cpp} (100%)
 rename test/evaluate/{integer.cc => integer.cpp} (100%)
 rename test/evaluate/{intrinsics.cc => intrinsics.cpp} (100%)
 rename test/evaluate/{leading-zero-bit-count.cc => leading-zero-bit-count.cpp} (100%)
 rename test/evaluate/{logical.cc => logical.cpp} (100%)
 rename test/evaluate/{real.cc => real.cpp} (100%)
 rename test/evaluate/{reshape.cc => reshape.cpp} (100%)
 rename test/evaluate/{testing.cc => testing.cpp} (100%)
 rename test/evaluate/{uint128.cc => uint128.cpp} (100%)
 rename test/runtime/{format.cc => format.cpp} (98%)
 rename test/runtime/{hello.cc => hello.cpp} (100%)
 rename tools/f18/{dump.cc => dump.cpp} (95%)
 rename tools/f18/{f18-parse-demo.cc => f18-parse-demo.cpp} (99%)
 rename tools/f18/{f18.cc => f18.cpp} (99%)
 rename tools/f18/{stub-evaluate.cc => stub-evaluate.cpp} (94%)

diff --git a/documentation/C++style.md b/documentation/C++style.md
index fb835856800d..9136a3f21e6a 100644
--- a/documentation/C++style.md
+++ b/documentation/C++style.md
@@ -36,7 +36,7 @@ unless they introduce ambiguity.
 
 ### Files
 1. File names should use dashes, not underscores.  C++ sources have the
-extension ".cc", not ".C" or ".cpp" or ".cxx".  Don't create needless
+extension ".cpp", not ".C" or ".cc" or ".cxx".  Don't create needless
 source directory hierarchies.
 1. Header files should be idempotent.  Use the usual technique:
 ```
@@ -46,11 +46,11 @@ source directory hierarchies.
 #endif  // FORTRAN_header_H_
 ```
 1. `#include` every header defining an entity that your project header or source
-file actually uses directly.  (Exception: when foo.cc starts, as it should,
+file actually uses directly.  (Exception: when foo.cpp starts, as it should,
 with `#include "foo.h"`, and foo.h includes bar.h in order to define the
 interface to the module foo, you don't have to redundantly `#include "bar.h"`
-in foo.cc.)
-1. In the source file "foo.cc", put its corresponding `#include "foo.h"`
+in foo.cpp.)
+1. In the source file "foo.cpp", put its corresponding `#include "foo.h"`
 first in the sequence of inclusions.
 Then `#include` other project headers in alphabetic order; then C++ standard
 headers, also alphabetically; then C and system headers.
diff --git a/documentation/PullRequestChecklist.md b/documentation/PullRequestChecklist.md
index 782c3b61ca0e..041ec500280c 100644
--- a/documentation/PullRequestChecklist.md
+++ b/documentation/PullRequestChecklist.md
@@ -29,7 +29,7 @@ can also be used when reviewing pull requests.
 ## Follow the style guide
 The following items are taken from the [C++ style guide](C++style.md).  But
 even though I've read the style guide, they regularly trip me up.
-*  Run clang-format version 7 on all .cc and .h files.
+*  Run clang-format version 7 on all .cpp and .h files.
 *  Make sure that all source lines have 80 or fewer characters.  Note that
    clang-format will do this for most code.  But you may need to break up long
    strings.
diff --git a/include/flang/evaluate/traverse.h b/include/flang/evaluate/traverse.h
index 326104b1e1ce..d85afac239e0 100644
--- a/include/flang/evaluate/traverse.h
+++ b/include/flang/evaluate/traverse.h
@@ -25,7 +25,7 @@
 // - overrides for "Result operator()"
 //
 // Boilerplate classes also appear below to ease construction of visitors.
-// See CheckSpecificationExpr() in check-expression.cc for an example client.
+// See CheckSpecificationExpr() in check-expression.cpp for an example client.
 //
 // How this works:
 // - The operator() overloads in Traverse<> invoke the visitor's Default() for
diff --git a/lib/common/CMakeLists.txt b/lib/common/CMakeLists.txt
index c72efd4dc414..bfa8bf7953e0 100644
--- a/lib/common/CMakeLists.txt
+++ b/lib/common/CMakeLists.txt
@@ -7,10 +7,10 @@
 #===------------------------------------------------------------------------===#
 
 add_library(FortranCommon
-  Fortran.cc
-  Fortran-features.cc
-  default-kinds.cc
-  idioms.cc
+  Fortran.cpp
+  Fortran-features.cpp
+  default-kinds.cpp
+  idioms.cpp
 )
 
 install (TARGETS FortranCommon
diff --git a/lib/common/Fortran-features.cc b/lib/common/Fortran-features.cpp
similarity index 96%
rename from lib/common/Fortran-features.cc
rename to lib/common/Fortran-features.cpp
index f92162673e46..62c3e505ea17 100644
--- a/lib/common/Fortran-features.cc
+++ b/lib/common/Fortran-features.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/Fortran-features.cc ------------------------------------===//
+//===-- lib/common/Fortran-features.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/common/Fortran.cc b/lib/common/Fortran.cpp
similarity index 95%
rename from lib/common/Fortran.cc
rename to lib/common/Fortran.cpp
index 8b915bbee6dd..61ff0ee2f6e9 100644
--- a/lib/common/Fortran.cc
+++ b/lib/common/Fortran.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/Fortran.cc ---------------------------------------------===//
+//===-- lib/common/Fortran.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/common/default-kinds.cc b/lib/common/default-kinds.cpp
similarity index 96%
rename from lib/common/default-kinds.cc
rename to lib/common/default-kinds.cpp
index 1f459935961e..490f4dc1f156 100644
--- a/lib/common/default-kinds.cc
+++ b/lib/common/default-kinds.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/default-kinds.cc ---------------------------------------===//
+//===-- lib/common/default-kinds.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/common/idioms.cc b/lib/common/idioms.cpp
similarity index 94%
rename from lib/common/idioms.cc
rename to lib/common/idioms.cpp
index f27f7b1a0030..d28d76fe83b8 100644
--- a/lib/common/idioms.cc
+++ b/lib/common/idioms.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/idioms.cc ----------------------------------------------===//
+//===-- lib/common/idioms.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/decimal/CMakeLists.txt b/lib/decimal/CMakeLists.txt
index d28a1f9ae168..28c9c828ac3a 100644
--- a/lib/decimal/CMakeLists.txt
+++ b/lib/decimal/CMakeLists.txt
@@ -7,8 +7,8 @@
 #===------------------------------------------------------------------------===#
 
 add_library(FortranDecimal
-  binary-to-decimal.cc
-  decimal-to-binary.cc
+  binary-to-decimal.cpp
+  decimal-to-binary.cpp
 )
 
 install (TARGETS FortranDecimal
diff --git a/lib/decimal/binary-to-decimal.cc b/lib/decimal/binary-to-decimal.cpp
similarity index 99%
rename from lib/decimal/binary-to-decimal.cc
rename to lib/decimal/binary-to-decimal.cpp
index 53b00c39e4ed..fbc043eed374 100644
--- a/lib/decimal/binary-to-decimal.cc
+++ b/lib/decimal/binary-to-decimal.cpp
@@ -1,4 +1,4 @@
-//===-- lib/decimal/binary-to-decimal.cc ----------------------------------===//
+//===-- lib/decimal/binary-to-decimal.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/decimal/decimal-to-binary.cc b/lib/decimal/decimal-to-binary.cpp
similarity index 99%
rename from lib/decimal/decimal-to-binary.cc
rename to lib/decimal/decimal-to-binary.cpp
index 3f57a3bb41f1..de15833098f5 100644
--- a/lib/decimal/decimal-to-binary.cc
+++ b/lib/decimal/decimal-to-binary.cpp
@@ -1,4 +1,4 @@
-//===-- lib/decimal/decimal-to-binary.cc ----------------------------------===//
+//===-- lib/decimal/decimal-to-binary.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/CMakeLists.txt b/lib/evaluate/CMakeLists.txt
index 54d5d834252e..8714819c49a8 100644
--- a/lib/evaluate/CMakeLists.txt
+++ b/lib/evaluate/CMakeLists.txt
@@ -7,31 +7,31 @@
 #===------------------------------------------------------------------------===#
 
 add_library(FortranEvaluate
-  call.cc
-  characteristics.cc
-  check-expression.cc
-  common.cc
-  complex.cc
-  constant.cc
-  expression.cc
-  fold.cc
-  fold-character.cc
-  fold-complex.cc
-  fold-integer.cc
-  fold-logical.cc
-  fold-real.cc
-  formatting.cc
-  host.cc
-  integer.cc
-  intrinsics.cc
-  intrinsics-library.cc
-  logical.cc
-  real.cc
-  shape.cc
-  static-data.cc
-  tools.cc
-  type.cc
-  variable.cc
+  call.cpp
+  characteristics.cpp
+  check-expression.cpp
+  common.cpp
+  complex.cpp
+  constant.cpp
+  expression.cpp
+  fold.cpp
+  fold-character.cpp
+  fold-complex.cpp
+  fold-integer.cpp
+  fold-logical.cpp
+  fold-real.cpp
+  formatting.cpp
+  host.cpp
+  integer.cpp
+  intrinsics.cpp
+  intrinsics-library.cpp
+  logical.cpp
+  real.cpp
+  shape.cpp
+  static-data.cpp
+  tools.cpp
+  type.cpp
+  variable.cpp
 )
 
 target_link_libraries(FortranEvaluate
diff --git a/lib/evaluate/call.cc b/lib/evaluate/call.cpp
similarity index 99%
rename from lib/evaluate/call.cc
rename to lib/evaluate/call.cpp
index a61f679935f0..d1272af63484 100644
--- a/lib/evaluate/call.cc
+++ b/lib/evaluate/call.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/call.cc ----------------------------------------------===//
+//===-- lib/evaluate/call.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/characteristics.cc b/lib/evaluate/characteristics.cpp
similarity index 99%
rename from lib/evaluate/characteristics.cc
rename to lib/evaluate/characteristics.cpp
index 1e4f2825ba08..ac18b5a1730b 100644
--- a/lib/evaluate/characteristics.cc
+++ b/lib/evaluate/characteristics.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/characteristics.cc -----------------------------------===//
+//===-- lib/evaluate/characteristics.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/check-expression.cc b/lib/evaluate/check-expression.cpp
similarity index 99%
rename from lib/evaluate/check-expression.cc
rename to lib/evaluate/check-expression.cpp
index 31d1454ff176..34b9025abf25 100644
--- a/lib/evaluate/check-expression.cc
+++ b/lib/evaluate/check-expression.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/check-expression.cc ----------------------------------===//
+//===-- lib/evaluate/check-expression.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/common.cc b/lib/evaluate/common.cpp
similarity index 96%
rename from lib/evaluate/common.cc
rename to lib/evaluate/common.cpp
index a1f7cbbf6005..9c45e668767d 100644
--- a/lib/evaluate/common.cc
+++ b/lib/evaluate/common.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/common.cc --------------------------------------------===//
+//===-- lib/evaluate/common.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/complex.cc b/lib/evaluate/complex.cpp
similarity index 98%
rename from lib/evaluate/complex.cc
rename to lib/evaluate/complex.cpp
index e93245997cd2..210fd1fb54c5 100644
--- a/lib/evaluate/complex.cc
+++ b/lib/evaluate/complex.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/complex.cc -------------------------------------------===//
+//===-- lib/evaluate/complex.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/constant.cc b/lib/evaluate/constant.cpp
similarity index 99%
rename from lib/evaluate/constant.cc
rename to lib/evaluate/constant.cpp
index 4c83e34c8c68..65da1378f10f 100644
--- a/lib/evaluate/constant.cc
+++ b/lib/evaluate/constant.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/constant.cc ------------------------------------------===//
+//===-- lib/evaluate/constant.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/expression.cc b/lib/evaluate/expression.cpp
similarity index 99%
rename from lib/evaluate/expression.cc
rename to lib/evaluate/expression.cpp
index 21a0176e32ac..fbf20daba7af 100644
--- a/lib/evaluate/expression.cc
+++ b/lib/evaluate/expression.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/expression.cc ----------------------------------------===//
+//===-- lib/evaluate/expression.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-character.cc b/lib/evaluate/fold-character.cpp
similarity index 98%
rename from lib/evaluate/fold-character.cc
rename to lib/evaluate/fold-character.cpp
index 73711ec61a9f..0c99b96df71b 100644
--- a/lib/evaluate/fold-character.cc
+++ b/lib/evaluate/fold-character.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-character.cc ------------------------------------===//
+//===-- lib/evaluate/fold-character.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-complex.cc b/lib/evaluate/fold-complex.cpp
similarity index 98%
rename from lib/evaluate/fold-complex.cc
rename to lib/evaluate/fold-complex.cpp
index e96bc9dbc359..d4c5f00873a4 100644
--- a/lib/evaluate/fold-complex.cc
+++ b/lib/evaluate/fold-complex.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-complex.cc --------------------------------------===//
+//===-- lib/evaluate/fold-complex.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-integer.cc b/lib/evaluate/fold-integer.cpp
similarity index 99%
rename from lib/evaluate/fold-integer.cc
rename to lib/evaluate/fold-integer.cpp
index aa696dd3582c..cda0a39e616f 100644
--- a/lib/evaluate/fold-integer.cc
+++ b/lib/evaluate/fold-integer.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-integer.cc --------------------------------------===//
+//===-- lib/evaluate/fold-integer.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-logical.cc b/lib/evaluate/fold-logical.cpp
similarity index 99%
rename from lib/evaluate/fold-logical.cc
rename to lib/evaluate/fold-logical.cpp
index 649f745897b8..cf1bb9a1374c 100644
--- a/lib/evaluate/fold-logical.cc
+++ b/lib/evaluate/fold-logical.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-logical.cc --------------------------------------===//
+//===-- lib/evaluate/fold-logical.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-real.cc b/lib/evaluate/fold-real.cpp
similarity index 99%
rename from lib/evaluate/fold-real.cc
rename to lib/evaluate/fold-real.cpp
index 05b719e6cb42..b1d3ed33ca44 100644
--- a/lib/evaluate/fold-real.cc
+++ b/lib/evaluate/fold-real.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-real.cc -----------------------------------------===//
+//===-- lib/evaluate/fold-real.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold.cc b/lib/evaluate/fold.cpp
similarity index 99%
rename from lib/evaluate/fold.cc
rename to lib/evaluate/fold.cpp
index af1de4094daf..4a7263f1ffce 100644
--- a/lib/evaluate/fold.cc
+++ b/lib/evaluate/fold.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold.cc ----------------------------------------------===//
+//===-- lib/evaluate/fold.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/formatting.cc b/lib/evaluate/formatting.cpp
similarity index 99%
rename from lib/evaluate/formatting.cc
rename to lib/evaluate/formatting.cpp
index 6eb43a4e4967..5bc627748675 100644
--- a/lib/evaluate/formatting.cc
+++ b/lib/evaluate/formatting.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/formatting.cc ----------------------------------------===//
+//===-- lib/evaluate/formatting.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/host.cc b/lib/evaluate/host.cpp
similarity index 98%
rename from lib/evaluate/host.cc
rename to lib/evaluate/host.cpp
index 62dd44863989..47685e08b762 100644
--- a/lib/evaluate/host.cc
+++ b/lib/evaluate/host.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/host.cc ----------------------------------------------===//
+//===-- lib/evaluate/host.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/integer.cc b/lib/evaluate/integer.cpp
similarity index 94%
rename from lib/evaluate/integer.cc
rename to lib/evaluate/integer.cpp
index 30484d90664a..06503e6f42b8 100644
--- a/lib/evaluate/integer.cc
+++ b/lib/evaluate/integer.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/integer.cc -------------------------------------------===//
+//===-- lib/evaluate/integer.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/intrinsics-library-templates.h b/lib/evaluate/intrinsics-library-templates.h
index 4ab657da01e0..65d3de7e05f9 100644
--- a/lib/evaluate/intrinsics-library-templates.h
+++ b/lib/evaluate/intrinsics-library-templates.h
@@ -13,7 +13,7 @@
 // function of the structures defined in intrinsics-library.h. It should only be
 // included if these member functions are used, else intrinsics-library.h is
 // sufficient. This is to avoid circular dependencies. The below implementation
-// cannot be defined in .cc file because it would be too cumbersome to decide
+// cannot be defined in .cpp file because it would be too cumbersome to decide
 // which version should be instantiated in a generic way.
 
 #include "host.h"
diff --git a/lib/evaluate/intrinsics-library.cc b/lib/evaluate/intrinsics-library.cpp
similarity index 99%
rename from lib/evaluate/intrinsics-library.cc
rename to lib/evaluate/intrinsics-library.cpp
index 4a8e4c6f61b1..bfddcb366b8f 100644
--- a/lib/evaluate/intrinsics-library.cc
+++ b/lib/evaluate/intrinsics-library.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/intrinsics-library.cc --------------------------------===//
+//===-- lib/evaluate/intrinsics-library.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/intrinsics.cc b/lib/evaluate/intrinsics.cpp
similarity index 99%
rename from lib/evaluate/intrinsics.cc
rename to lib/evaluate/intrinsics.cpp
index 1a8b5ba3248b..93b2f864ae41 100644
--- a/lib/evaluate/intrinsics.cc
+++ b/lib/evaluate/intrinsics.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/intrinsics.cc ----------------------------------------===//
+//===-- lib/evaluate/intrinsics.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/logical.cc b/lib/evaluate/logical.cpp
similarity index 88%
rename from lib/evaluate/logical.cc
rename to lib/evaluate/logical.cpp
index bdbfedb05d7f..8bd3a3b7524a 100644
--- a/lib/evaluate/logical.cc
+++ b/lib/evaluate/logical.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/logical.cc -------------------------------------------===//
+//===-- lib/evaluate/logical.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/real.cc b/lib/evaluate/real.cpp
similarity index 99%
rename from lib/evaluate/real.cc
rename to lib/evaluate/real.cpp
index b803a8ea1de3..ec9ab1dd4373 100644
--- a/lib/evaluate/real.cc
+++ b/lib/evaluate/real.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/real.cc ----------------------------------------------===//
+//===-- lib/evaluate/real.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/shape.cc b/lib/evaluate/shape.cpp
similarity index 99%
rename from lib/evaluate/shape.cc
rename to lib/evaluate/shape.cpp
index 62bc879895de..ea14c4b244ad 100644
--- a/lib/evaluate/shape.cc
+++ b/lib/evaluate/shape.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/shape.cc ---------------------------------------------===//
+//===-- lib/evaluate/shape.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/static-data.cc b/lib/evaluate/static-data.cpp
similarity index 97%
rename from lib/evaluate/static-data.cc
rename to lib/evaluate/static-data.cpp
index f5311cee1a95..668fcb47191f 100644
--- a/lib/evaluate/static-data.cc
+++ b/lib/evaluate/static-data.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/static-data.cc ---------------------------------------===//
+//===-- lib/evaluate/static-data.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/tools.cc b/lib/evaluate/tools.cpp
similarity index 99%
rename from lib/evaluate/tools.cc
rename to lib/evaluate/tools.cpp
index 4710343f4ad2..8f9af2e1fa34 100644
--- a/lib/evaluate/tools.cc
+++ b/lib/evaluate/tools.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/tools.cc ---------------------------------------------===//
+//===-- lib/evaluate/tools.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/type.cc b/lib/evaluate/type.cpp
similarity index 99%
rename from lib/evaluate/type.cc
rename to lib/evaluate/type.cpp
index bf7e8012e0ff..11f800349ca6 100644
--- a/lib/evaluate/type.cc
+++ b/lib/evaluate/type.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/type.cc ----------------------------------------------===//
+//===-- lib/evaluate/type.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/variable.cc b/lib/evaluate/variable.cpp
similarity index 99%
rename from lib/evaluate/variable.cc
rename to lib/evaluate/variable.cpp
index 0922ba659cd5..f10b0a6ee2f2 100644
--- a/lib/evaluate/variable.cc
+++ b/lib/evaluate/variable.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/variable.cc ------------------------------------------===//
+//===-- lib/evaluate/variable.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/CMakeLists.txt b/lib/parser/CMakeLists.txt
index 96306019633d..72ced8cc9e45 100644
--- a/lib/parser/CMakeLists.txt
+++ b/lib/parser/CMakeLists.txt
@@ -7,29 +7,29 @@
 #===------------------------------------------------------------------------===#
 
 add_library(FortranParser
-  Fortran-parsers.cc
-  char-buffer.cc
-  char-block.cc
-  char-set.cc
-  characters.cc
-  debug-parser.cc
-  executable-parsers.cc
-  expr-parsers.cc
-  instrumented-parser.cc
-  io-parsers.cc
-  message.cc
-  openmp-parsers.cc
-  parse-tree.cc
-  parsing.cc
-  preprocessor.cc
-  prescan.cc
-  program-parsers.cc
-  provenance.cc
-  source.cc
-  token-sequence.cc
-  tools.cc
-  unparse.cc
-  user-state.cc
+  Fortran-parsers.cpp
+  char-buffer.cpp
+  char-block.cpp
+  char-set.cpp
+  characters.cpp
+  debug-parser.cpp
+  executable-parsers.cpp
+  expr-parsers.cpp
+  instrumented-parser.cpp
+  io-parsers.cpp
+  message.cpp
+  openmp-parsers.cpp
+  parse-tree.cpp
+  parsing.cpp
+  preprocessor.cpp
+  prescan.cpp
+  program-parsers.cpp
+  provenance.cpp
+  source.cpp
+  token-sequence.cpp
+  tools.cpp
+  unparse.cpp
+  user-state.cpp
 )
 
 target_link_libraries(FortranParser
diff --git a/lib/parser/Fortran-parsers.cc b/lib/parser/Fortran-parsers.cpp
similarity index 99%
rename from lib/parser/Fortran-parsers.cc
rename to lib/parser/Fortran-parsers.cpp
index bfc7122a4dd5..f895189aa99a 100644
--- a/lib/parser/Fortran-parsers.cc
+++ b/lib/parser/Fortran-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/Fortran-parsers.cc -------------------------------------===//
+//===-- lib/parser/Fortran-parsers.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -24,11 +24,11 @@
 // various per-type parsers are partitioned into several C++ source
 // files.  This file contains parsers for constants, types, declarations,
 // and misfits (mostly clauses 7, 8, & 9 of Fortran 2018).  The others:
-//  executable-parsers.cc  Executable statements
-//  expr-parsers.cc        Expressions
-//  io-parsers.cc          I/O statements and FORMAT
-//  openmp-parsers.cc      OpenMP directives
-//  program-parsers.cc     Program units
+//  executable-parsers.cpp  Executable statements
+//  expr-parsers.cpp        Expressions
+//  io-parsers.cpp          I/O statements and FORMAT
+//  openmp-parsers.cpp      OpenMP directives
+//  program-parsers.cpp     Program units
 
 #include "basic-parsers.h"
 #include "expr-parsers.h"
diff --git a/lib/parser/char-block.cc b/lib/parser/char-block.cpp
similarity index 88%
rename from lib/parser/char-block.cc
rename to lib/parser/char-block.cpp
index 8c9784e55ad1..a3cb60a9b13f 100644
--- a/lib/parser/char-block.cc
+++ b/lib/parser/char-block.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-block.cc --------------------------------*- C++ -*-===//
+//===-- lib/parser/char-block.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.
diff --git a/lib/parser/char-buffer.cc b/lib/parser/char-buffer.cpp
similarity index 97%
rename from lib/parser/char-buffer.cc
rename to lib/parser/char-buffer.cpp
index 6c426243ce3f..3de83ec87b5a 100644
--- a/lib/parser/char-buffer.cc
+++ b/lib/parser/char-buffer.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-buffer.cc -----------------------------------------===//
+//===-- lib/parser/char-buffer.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/char-set.cc b/lib/parser/char-set.cpp
similarity index 90%
rename from lib/parser/char-set.cc
rename to lib/parser/char-set.cpp
index c8a324f5ae9e..1390f5ca35f6 100644
--- a/lib/parser/char-set.cc
+++ b/lib/parser/char-set.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-set.cc --------------------------------------------===//
+//===-- lib/parser/char-set.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/characters.cc b/lib/parser/characters.cpp
similarity index 99%
rename from lib/parser/characters.cc
rename to lib/parser/characters.cpp
index d6fc0d6464f7..f4703565a7d4 100644
--- a/lib/parser/characters.cc
+++ b/lib/parser/characters.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/characters.cc ------------------------------------------===//
+//===-- lib/parser/characters.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/debug-parser.cc b/lib/parser/debug-parser.cpp
similarity index 92%
rename from lib/parser/debug-parser.cc
rename to lib/parser/debug-parser.cpp
index 97fdf2820141..4957ce1dcbd5 100644
--- a/lib/parser/debug-parser.cc
+++ b/lib/parser/debug-parser.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/debug-parser.cc ----------------------------------------===//
+//===-- lib/parser/debug-parser.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/executable-parsers.cc b/lib/parser/executable-parsers.cpp
similarity index 99%
rename from lib/parser/executable-parsers.cc
rename to lib/parser/executable-parsers.cpp
index a1557a0e0e46..72408f1da2f5 100644
--- a/lib/parser/executable-parsers.cc
+++ b/lib/parser/executable-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/executable-parsers.cc ----------------------------------===//
+//===-- lib/parser/executable-parsers.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/expr-parsers.cc b/lib/parser/expr-parsers.cpp
similarity index 99%
rename from lib/parser/expr-parsers.cc
rename to lib/parser/expr-parsers.cpp
index 14bc391691ee..11e94fc0da2d 100644
--- a/lib/parser/expr-parsers.cc
+++ b/lib/parser/expr-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/expr-parsers.cc ----------------------------------------===//
+//===-- lib/parser/expr-parsers.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/instrumented-parser.cc b/lib/parser/instrumented-parser.cpp
similarity index 97%
rename from lib/parser/instrumented-parser.cc
rename to lib/parser/instrumented-parser.cpp
index b845b22dffdd..fc5e14867032 100644
--- a/lib/parser/instrumented-parser.cc
+++ b/lib/parser/instrumented-parser.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/instrumented-parser.cc ---------------------------------===//
+//===-- lib/parser/instrumented-parser.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/io-parsers.cc b/lib/parser/io-parsers.cpp
similarity index 99%
rename from lib/parser/io-parsers.cc
rename to lib/parser/io-parsers.cpp
index 5488a32c4769..a9ccbb75566d 100644
--- a/lib/parser/io-parsers.cc
+++ b/lib/parser/io-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/io-parsers.cc ------------------------------------------===//
+//===-- lib/parser/io-parsers.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/message.cc b/lib/parser/message.cpp
similarity index 99%
rename from lib/parser/message.cc
rename to lib/parser/message.cpp
index 5589707effc2..2f5655eb1e48 100644
--- a/lib/parser/message.cc
+++ b/lib/parser/message.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/message.cc ---------------------------------------------===//
+//===-- lib/parser/message.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/openmp-parsers.cc b/lib/parser/openmp-parsers.cpp
similarity index 99%
rename from lib/parser/openmp-parsers.cc
rename to lib/parser/openmp-parsers.cpp
index 4a5a083747bd..076c3e8218a3 100644
--- a/lib/parser/openmp-parsers.cc
+++ b/lib/parser/openmp-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/openmp-parsers.cc --------------------------------------===//
+//===-- lib/parser/openmp-parsers.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/parse-tree.cc b/lib/parser/parse-tree.cpp
similarity index 99%
rename from lib/parser/parse-tree.cc
rename to lib/parser/parse-tree.cpp
index 6e0e017570b5..c412214b7432 100644
--- a/lib/parser/parse-tree.cc
+++ b/lib/parser/parse-tree.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/parse-tree.cc ------------------------------------------===//
+//===-- lib/parser/parse-tree.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/parsing.cc b/lib/parser/parsing.cpp
similarity index 98%
rename from lib/parser/parsing.cc
rename to lib/parser/parsing.cpp
index c2b96ab8b383..ab39c2b1f25c 100644
--- a/lib/parser/parsing.cc
+++ b/lib/parser/parsing.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/parsing.cc ---------------------------------------------===//
+//===-- lib/parser/parsing.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/preprocessor.cc b/lib/parser/preprocessor.cpp
similarity index 99%
rename from lib/parser/preprocessor.cc
rename to lib/parser/preprocessor.cpp
index 270e72ca3735..cd5cee714af8 100644
--- a/lib/parser/preprocessor.cc
+++ b/lib/parser/preprocessor.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/preprocessor.cc ----------------------------------------===//
+//===-- lib/parser/preprocessor.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/prescan.cc b/lib/parser/prescan.cpp
similarity index 99%
rename from lib/parser/prescan.cc
rename to lib/parser/prescan.cpp
index 07f294a9eb77..679f136305cb 100644
--- a/lib/parser/prescan.cc
+++ b/lib/parser/prescan.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/prescan.cc ---------------------------------------------===//
+//===-- lib/parser/prescan.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/program-parsers.cc b/lib/parser/program-parsers.cpp
similarity index 99%
rename from lib/parser/program-parsers.cc
rename to lib/parser/program-parsers.cpp
index f19824248181..f0e4e69498b1 100644
--- a/lib/parser/program-parsers.cc
+++ b/lib/parser/program-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/program-parsers.cc -------------------------------------===//
+//===-- lib/parser/program-parsers.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/provenance.cc b/lib/parser/provenance.cpp
similarity index 99%
rename from lib/parser/provenance.cc
rename to lib/parser/provenance.cpp
index 9ad864e0da95..391e650e1b30 100644
--- a/lib/parser/provenance.cc
+++ b/lib/parser/provenance.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/provenance.cc ------------------------------------------===//
+//===-- lib/parser/provenance.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/source.cc b/lib/parser/source.cpp
similarity index 99%
rename from lib/parser/source.cc
rename to lib/parser/source.cpp
index 4e4c2736781f..e6635e9f10d5 100644
--- a/lib/parser/source.cc
+++ b/lib/parser/source.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/source.cc ----------------------------------------------===//
+//===-- lib/parser/source.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/token-sequence.cc b/lib/parser/token-sequence.cpp
similarity index 99%
rename from lib/parser/token-sequence.cc
rename to lib/parser/token-sequence.cpp
index d6337f475cec..3f984e1f3838 100644
--- a/lib/parser/token-sequence.cc
+++ b/lib/parser/token-sequence.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/token-sequence.cc --------------------------------------===//
+//===-- lib/parser/token-sequence.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/tools.cc b/lib/parser/tools.cpp
similarity index 97%
rename from lib/parser/tools.cc
rename to lib/parser/tools.cpp
index 1ef05b427a25..522bd3afc642 100644
--- a/lib/parser/tools.cc
+++ b/lib/parser/tools.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/tools.cc -----------------------------------------------===//
+//===-- lib/parser/tools.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/unparse.cc b/lib/parser/unparse.cpp
similarity index 99%
rename from lib/parser/unparse.cc
rename to lib/parser/unparse.cpp
index 6550efa65880..82d52960f5f2 100644
--- a/lib/parser/unparse.cc
+++ b/lib/parser/unparse.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/unparse.cc ---------------------------------------------===//
+//===-- lib/parser/unparse.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/user-state.cc b/lib/parser/user-state.cpp
similarity index 97%
rename from lib/parser/user-state.cc
rename to lib/parser/user-state.cpp
index b23b8f579c84..bd84463d9ab0 100644
--- a/lib/parser/user-state.cc
+++ b/lib/parser/user-state.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/user-state.cc ------------------------------------------===//
+//===-- lib/parser/user-state.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/CMakeLists.txt b/lib/semantics/CMakeLists.txt
index 1f0fa359e11e..14e636e177d5 100644
--- a/lib/semantics/CMakeLists.txt
+++ b/lib/semantics/CMakeLists.txt
@@ -7,38 +7,38 @@
 #===------------------------------------------------------------------------===#
 
 add_library(FortranSemantics
-  assignment.cc
-  attr.cc
-  canonicalize-do.cc
-  canonicalize-omp.cc
-  check-allocate.cc
-  check-arithmeticif.cc
-  check-call.cc
-  check-coarray.cc
-  check-deallocate.cc
-  check-declarations.cc
-  check-do.cc
-  check-if-stmt.cc
-  check-io.cc
-  check-nullify.cc
-  check-omp-structure.cc
-  check-purity.cc
-  check-return.cc
-  check-stop.cc
-  expression.cc
-  mod-file.cc
-  pointer-assignment.cc
-  program-tree.cc
-  resolve-labels.cc
-  resolve-names.cc
-  resolve-names-utils.cc
-  rewrite-parse-tree.cc
-  scope.cc
-  semantics.cc
-  symbol.cc
-  tools.cc
-  type.cc
-  unparse-with-symbols.cc
+  assignment.cpp
+  attr.cpp
+  canonicalize-do.cpp
+  canonicalize-omp.cpp
+  check-allocate.cpp
+  check-arithmeticif.cpp
+  check-call.cpp
+  check-coarray.cpp
+  check-deallocate.cpp
+  check-declarations.cpp
+  check-do.cpp
+  check-if-stmt.cpp
+  check-io.cpp
+  check-nullify.cpp
+  check-omp-structure.cpp
+  check-purity.cpp
+  check-return.cpp
+  check-stop.cpp
+  expression.cpp
+  mod-file.cpp
+  pointer-assignment.cpp
+  program-tree.cpp
+  resolve-labels.cpp
+  resolve-names.cpp
+  resolve-names-utils.cpp
+  rewrite-parse-tree.cpp
+  scope.cpp
+  semantics.cpp
+  symbol.cpp
+  tools.cpp
+  type.cpp
+  unparse-with-symbols.cpp
 )
 
 target_link_libraries(FortranSemantics
diff --git a/lib/semantics/assignment.cc b/lib/semantics/assignment.cpp
similarity index 99%
rename from lib/semantics/assignment.cc
rename to lib/semantics/assignment.cpp
index 70f2f655a41b..362df0465480 100644
--- a/lib/semantics/assignment.cc
+++ b/lib/semantics/assignment.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/assignment.cc ---------------------------------------===//
+//===-- lib/semantics/assignment.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -139,7 +139,7 @@ class AssignmentContext {
 };
 
 void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
-  // Assignment statement analysis is in expression.cc where user-defined
+  // Assignment statement analysis is in expression.cpp where user-defined
   // assignments can be recognized and replaced.
   if (const evaluate::Assignment * asst{GetAssignment(stmt)}) {
     if (const auto *intrinsicAsst{
diff --git a/lib/semantics/attr.cc b/lib/semantics/attr.cpp
similarity index 95%
rename from lib/semantics/attr.cc
rename to lib/semantics/attr.cpp
index 25d9201f3fb7..65623442a2d6 100644
--- a/lib/semantics/attr.cc
+++ b/lib/semantics/attr.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/attr.cc ---------------------------------------------===//
+//===-- lib/semantics/attr.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/canonicalize-do.cc b/lib/semantics/canonicalize-do.cpp
similarity index 98%
rename from lib/semantics/canonicalize-do.cc
rename to lib/semantics/canonicalize-do.cpp
index b4ac3771e8e8..45353c97c1f8 100644
--- a/lib/semantics/canonicalize-do.cc
+++ b/lib/semantics/canonicalize-do.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/canonicalize-do.cc ----------------------------------===//
+//===-- lib/semantics/canonicalize-do.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/canonicalize-omp.cc b/lib/semantics/canonicalize-omp.cpp
similarity index 98%
rename from lib/semantics/canonicalize-omp.cc
rename to lib/semantics/canonicalize-omp.cpp
index cbd26d19b763..1af2f3be6277 100644
--- a/lib/semantics/canonicalize-omp.cc
+++ b/lib/semantics/canonicalize-omp.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/canonicalize-omp.cc ---------------------------------===//
+//===-- lib/semantics/canonicalize-omp.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-allocate.cc b/lib/semantics/check-allocate.cpp
similarity index 99%
rename from lib/semantics/check-allocate.cc
rename to lib/semantics/check-allocate.cpp
index 4db1434f5cee..83f3ae9ebfc6 100644
--- a/lib/semantics/check-allocate.cc
+++ b/lib/semantics/check-allocate.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-allocate.cc -----------------------------------===//
+//===-- lib/semantics/check-allocate.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-arithmeticif.cc b/lib/semantics/check-arithmeticif.cpp
similarity index 96%
rename from lib/semantics/check-arithmeticif.cc
rename to lib/semantics/check-arithmeticif.cpp
index fd293ce5e3c8..d0b08a3e062a 100644
--- a/lib/semantics/check-arithmeticif.cc
+++ b/lib/semantics/check-arithmeticif.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-arithmeticif.cc -------------------------------===//
+//===-- lib/semantics/check-arithmeticif.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-call.cc b/lib/semantics/check-call.cpp
similarity index 99%
rename from lib/semantics/check-call.cc
rename to lib/semantics/check-call.cpp
index 164dbc86f898..2afd00f4627e 100644
--- a/lib/semantics/check-call.cc
+++ b/lib/semantics/check-call.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-call.cc ---------------------------------------===//
+//===-- lib/semantics/check-call.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-coarray.cc b/lib/semantics/check-coarray.cpp
similarity index 98%
rename from lib/semantics/check-coarray.cc
rename to lib/semantics/check-coarray.cpp
index 44f8cf4e89c0..0e43314de40d 100644
--- a/lib/semantics/check-coarray.cc
+++ b/lib/semantics/check-coarray.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-coarray.cc ------------------------------------===//
+//===-- lib/semantics/check-coarray.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-deallocate.cc b/lib/semantics/check-deallocate.cpp
similarity index 97%
rename from lib/semantics/check-deallocate.cc
rename to lib/semantics/check-deallocate.cpp
index 7e66fcdfbdbf..3f48fb4cd03f 100644
--- a/lib/semantics/check-deallocate.cc
+++ b/lib/semantics/check-deallocate.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-deallocate.cc ---------------------------------===//
+//===-- lib/semantics/check-deallocate.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-declarations.cc b/lib/semantics/check-declarations.cpp
similarity index 99%
rename from lib/semantics/check-declarations.cc
rename to lib/semantics/check-declarations.cpp
index a3352d94f907..a96bc6fb056b 100644
--- a/lib/semantics/check-declarations.cc
+++ b/lib/semantics/check-declarations.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-declarations.cc -------------------------------===//
+//===-- lib/semantics/check-declarations.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -1074,7 +1074,7 @@ void CheckHelper::CheckEquivalenceSet(const EquivalenceSet &set) {
       }
     }
   }
-  // TODO: Move C8106 (&al.) checks here from resolve-names-utils.cc
+  // TODO: Move C8106 (&al.) checks here from resolve-names-utils.cpp
 }
 
 void CheckHelper::CheckBlockData(const Scope &scope) {
diff --git a/lib/semantics/check-do.cc b/lib/semantics/check-do.cpp
similarity index 99%
rename from lib/semantics/check-do.cc
rename to lib/semantics/check-do.cpp
index 8112c631a12c..96c8ba73f35a 100644
--- a/lib/semantics/check-do.cc
+++ b/lib/semantics/check-do.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-do.cc -----------------------------------------===//
+//===-- lib/semantics/check-do.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-if-stmt.cc b/lib/semantics/check-if-stmt.cpp
similarity index 93%
rename from lib/semantics/check-if-stmt.cc
rename to lib/semantics/check-if-stmt.cpp
index ec423e35301c..589caf2abb7e 100644
--- a/lib/semantics/check-if-stmt.cc
+++ b/lib/semantics/check-if-stmt.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-if-stmt.cc ------------------------------------===//
+//===-- lib/semantics/check-if-stmt.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-io.cc b/lib/semantics/check-io.cpp
similarity index 99%
rename from lib/semantics/check-io.cc
rename to lib/semantics/check-io.cpp
index dc6ef9ef240f..6f824a3164a1 100644
--- a/lib/semantics/check-io.cc
+++ b/lib/semantics/check-io.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-io.cc -----------------------------------------===//
+//===-- lib/semantics/check-io.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-nullify.cc b/lib/semantics/check-nullify.cpp
similarity index 97%
rename from lib/semantics/check-nullify.cc
rename to lib/semantics/check-nullify.cpp
index 9951a1627686..06a551ffe656 100644
--- a/lib/semantics/check-nullify.cc
+++ b/lib/semantics/check-nullify.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-nullify.cc ------------------------------------===//
+//===-- lib/semantics/check-nullify.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-omp-structure.cc b/lib/semantics/check-omp-structure.cpp
similarity index 99%
rename from lib/semantics/check-omp-structure.cc
rename to lib/semantics/check-omp-structure.cpp
index 15b51d3bcdb2..8d22d422e909 100644
--- a/lib/semantics/check-omp-structure.cc
+++ b/lib/semantics/check-omp-structure.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-omp-structure.cc ------------------------------===//
+//===-- lib/semantics/check-omp-structure.cpp -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-purity.cc b/lib/semantics/check-purity.cpp
similarity index 97%
rename from lib/semantics/check-purity.cc
rename to lib/semantics/check-purity.cpp
index 541696f4d807..986a22ad0080 100644
--- a/lib/semantics/check-purity.cc
+++ b/lib/semantics/check-purity.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-purity.cc -------------------------------------===//
+//===-- lib/semantics/check-purity.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-return.cc b/lib/semantics/check-return.cpp
similarity index 96%
rename from lib/semantics/check-return.cc
rename to lib/semantics/check-return.cpp
index fc2f2cfccb1f..0fb3b6159aa8 100644
--- a/lib/semantics/check-return.cc
+++ b/lib/semantics/check-return.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-return.cc -------------------------------------===//
+//===-- lib/semantics/check-return.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-stop.cc b/lib/semantics/check-stop.cpp
similarity index 95%
rename from lib/semantics/check-stop.cc
rename to lib/semantics/check-stop.cpp
index 0cf56e9a6085..105f0df27b4d 100644
--- a/lib/semantics/check-stop.cc
+++ b/lib/semantics/check-stop.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-stop.cc ---------------------------------------===//
+//===-- lib/semantics/check-stop.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/expression.cc b/lib/semantics/expression.cpp
similarity index 99%
rename from lib/semantics/expression.cc
rename to lib/semantics/expression.cpp
index 3334bf27dce2..59593ae90e8f 100644
--- a/lib/semantics/expression.cc
+++ b/lib/semantics/expression.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/expression.cc ---------------------------------------===//
+//===-- lib/semantics/expression.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/mod-file.cc b/lib/semantics/mod-file.cpp
similarity index 99%
rename from lib/semantics/mod-file.cc
rename to lib/semantics/mod-file.cpp
index e0a18b28ede0..857c52b2b461 100644
--- a/lib/semantics/mod-file.cc
+++ b/lib/semantics/mod-file.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/mod-file.cc -----------------------------------------===//
+//===-- lib/semantics/mod-file.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/pointer-assignment.cc b/lib/semantics/pointer-assignment.cpp
similarity index 99%
rename from lib/semantics/pointer-assignment.cc
rename to lib/semantics/pointer-assignment.cpp
index bf93bdba3998..8e111eff4061 100644
--- a/lib/semantics/pointer-assignment.cc
+++ b/lib/semantics/pointer-assignment.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/pointer-assignment.cc -------------------------------===//
+//===-- lib/semantics/pointer-assignment.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/program-tree.cc b/lib/semantics/program-tree.cpp
similarity index 99%
rename from lib/semantics/program-tree.cc
rename to lib/semantics/program-tree.cpp
index f20819132ef4..74381e18cf42 100644
--- a/lib/semantics/program-tree.cc
+++ b/lib/semantics/program-tree.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/program-tree.cc -------------------------------------===//
+//===-- lib/semantics/program-tree.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/resolve-labels.cc b/lib/semantics/resolve-labels.cpp
similarity index 99%
rename from lib/semantics/resolve-labels.cc
rename to lib/semantics/resolve-labels.cpp
index 0c09fb41c335..87cacb8376c3 100644
--- a/lib/semantics/resolve-labels.cc
+++ b/lib/semantics/resolve-labels.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-labels.cc -----------------------------------===//
+//===-- lib/semantics/resolve-labels.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/resolve-names-utils.cc b/lib/semantics/resolve-names-utils.cpp
similarity index 99%
rename from lib/semantics/resolve-names-utils.cc
rename to lib/semantics/resolve-names-utils.cpp
index dd8c85d9ffa4..3b1a0b6cd824 100644
--- a/lib/semantics/resolve-names-utils.cc
+++ b/lib/semantics/resolve-names-utils.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-names-utils.cc ------------------------------===//
+//===-- lib/semantics/resolve-names-utils.cpp -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/resolve-names-utils.h b/lib/semantics/resolve-names-utils.h
index 0036cb7eb0b7..b0748c263016 100644
--- a/lib/semantics/resolve-names-utils.h
+++ b/lib/semantics/resolve-names-utils.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_RESOLVE_NAMES_UTILS_H_
 #define FORTRAN_SEMANTICS_RESOLVE_NAMES_UTILS_H_
 
-// Utility functions and class for use in resolve-names.cc.
+// Utility functions and class for use in resolve-names.cpp.
 
 #include "flang/parser/message.h"
 #include "flang/semantics/scope.h"
diff --git a/lib/semantics/resolve-names.cc b/lib/semantics/resolve-names.cpp
similarity index 99%
rename from lib/semantics/resolve-names.cc
rename to lib/semantics/resolve-names.cpp
index ae20be1e942b..e6a9b7f9bfeb 100644
--- a/lib/semantics/resolve-names.cc
+++ b/lib/semantics/resolve-names.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-names.cc ------------------------------------===//
+//===-- lib/semantics/resolve-names.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -3762,7 +3762,7 @@ bool DeclarationVisitor::Pre(const parser::StructureConstructor &x) {
 
   // N.B C7102 is implicitly enforced by having inaccessible types not
   // being found in resolution.
-  // More constraints are enforced in expression.cc so that they
+  // More constraints are enforced in expression.cpp so that they
   // can apply to structure constructors that have been converted
   // from misparsed function references.
   for (const auto &component :
diff --git a/lib/semantics/rewrite-parse-tree.cc b/lib/semantics/rewrite-parse-tree.cpp
similarity index 98%
rename from lib/semantics/rewrite-parse-tree.cc
rename to lib/semantics/rewrite-parse-tree.cpp
index 932a6ecd1e3e..37c55376d1a7 100644
--- a/lib/semantics/rewrite-parse-tree.cc
+++ b/lib/semantics/rewrite-parse-tree.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/rewrite-parse-tree.cc -------------------------------===//
+//===-- lib/semantics/rewrite-parse-tree.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/scope.cc b/lib/semantics/scope.cpp
similarity index 99%
rename from lib/semantics/scope.cc
rename to lib/semantics/scope.cpp
index 23166b15cfeb..96400b626f03 100644
--- a/lib/semantics/scope.cc
+++ b/lib/semantics/scope.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/scope.cc --------------------------------------------===//
+//===-- lib/semantics/scope.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/semantics.cc b/lib/semantics/semantics.cpp
similarity index 99%
rename from lib/semantics/semantics.cc
rename to lib/semantics/semantics.cpp
index 7642366ccd17..1f9958e08469 100644
--- a/lib/semantics/semantics.cc
+++ b/lib/semantics/semantics.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/semantics.cc ----------------------------------------===//
+//===-- lib/semantics/semantics.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/symbol.cc b/lib/semantics/symbol.cpp
similarity index 99%
rename from lib/semantics/symbol.cc
rename to lib/semantics/symbol.cpp
index 6393fa115709..d513962b021c 100644
--- a/lib/semantics/symbol.cc
+++ b/lib/semantics/symbol.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/symbol.cc -------------------------------------------===//
+//===-- lib/semantics/symbol.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/tools.cc b/lib/semantics/tools.cpp
similarity index 99%
rename from lib/semantics/tools.cc
rename to lib/semantics/tools.cpp
index 24b87b496e2d..a39ff409db04 100644
--- a/lib/semantics/tools.cc
+++ b/lib/semantics/tools.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/tools.cc --------------------------------------------===//
+//===-- lib/semantics/tools.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/type.cc b/lib/semantics/type.cpp
similarity index 99%
rename from lib/semantics/type.cc
rename to lib/semantics/type.cpp
index 0f196dbeb369..b216261f8e4a 100644
--- a/lib/semantics/type.cc
+++ b/lib/semantics/type.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/type.cc ---------------------------------------------===//
+//===-- lib/semantics/type.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/unparse-with-symbols.cc b/lib/semantics/unparse-with-symbols.cpp
similarity index 98%
rename from lib/semantics/unparse-with-symbols.cc
rename to lib/semantics/unparse-with-symbols.cpp
index 70ed49d4fa22..1af5c2a5638f 100644
--- a/lib/semantics/unparse-with-symbols.cc
+++ b/lib/semantics/unparse-with-symbols.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/unparse-with-symbols.cc -----------------------------===//
+//===-- lib/semantics/unparse-with-symbols.cpp ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index ce42973a7b9c..a9a71b9f17ce 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -7,21 +7,21 @@
 #===------------------------------------------------------------------------===#
 
 add_library(FortranRuntime
-  ISO_Fortran_binding.cc
-  derived-type.cc
-  descriptor.cc
-  file.cc
-  format.cc
-  io-api.cc
-  io-error.cc
-  io-stmt.cc
-  main.cc
-  memory.cc
-  stop.cc
-  terminator.cc
-  tools.cc
-  transformational.cc
-  type-code.cc
+  ISO_Fortran_binding.cpp
+  derived-type.cpp
+  descriptor.cpp
+  file.cpp
+  format.cpp
+  io-api.cpp
+  io-error.cpp
+  io-stmt.cpp
+  main.cpp
+  memory.cpp
+  stop.cpp
+  terminator.cpp
+  tools.cpp
+  transformational.cpp
+  type-code.cpp
 )
 
 target_link_libraries(FortranRuntime
diff --git a/runtime/ISO_Fortran_binding.cc b/runtime/ISO_Fortran_binding.cpp
similarity index 99%
rename from runtime/ISO_Fortran_binding.cc
rename to runtime/ISO_Fortran_binding.cpp
index 2a72aeac1db8..bcb0d055a740 100644
--- a/runtime/ISO_Fortran_binding.cc
+++ b/runtime/ISO_Fortran_binding.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/ISO_Fortran_binding.cc ------------------------------------===//
+//===-- runtime/ISO_Fortran_binding.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/runtime/derived-type.cc b/runtime/derived-type.cpp
similarity index 97%
rename from runtime/derived-type.cc
rename to runtime/derived-type.cpp
index 69b3292ea0c3..fb0e5a88277d 100644
--- a/runtime/derived-type.cc
+++ b/runtime/derived-type.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/derived-type.cc -------------------------------------------===//
+//===-- runtime/derived-type.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/runtime/descriptor.cc b/runtime/descriptor.cpp
similarity index 98%
rename from runtime/descriptor.cc
rename to runtime/descriptor.cpp
index e412df410dd7..c8895dd6d246 100644
--- a/runtime/descriptor.cc
+++ b/runtime/descriptor.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/descriptor.cc ---------------------------------------------===//
+//===-- runtime/descriptor.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/runtime/file.cc b/runtime/file.cpp
similarity index 99%
rename from runtime/file.cc
rename to runtime/file.cpp
index c99db0976690..3936bcdfcfa6 100644
--- a/runtime/file.cc
+++ b/runtime/file.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/file.cc -----------------------------------------*- C++ -*-===//
+//===-- runtime/file.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.
diff --git a/runtime/format.cc b/runtime/format.cpp
similarity index 99%
rename from runtime/format.cc
rename to runtime/format.cpp
index 2dd76e389bb3..46ad2ea2b5d0 100644
--- a/runtime/format.cc
+++ b/runtime/format.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/format.cc ---------------------------------------*- C++ -*-===//
+//===-- runtime/format.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.
diff --git a/runtime/io-api.cc b/runtime/io-api.cpp
similarity index 94%
rename from runtime/io-api.cc
rename to runtime/io-api.cpp
index a140e0e8cf99..56e6dff932c5 100644
--- a/runtime/io-api.cc
+++ b/runtime/io-api.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/io.cc -------------------------------------------*- C++ -*-===//
+//===-- runtime/io.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.
diff --git a/runtime/io-error.cc b/runtime/io-error.cpp
similarity index 96%
rename from runtime/io-error.cc
rename to runtime/io-error.cpp
index ccf143ae7b1b..52fff2d10cfa 100644
--- a/runtime/io-error.cc
+++ b/runtime/io-error.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/io-error.cc -------------------------------------*- C++ -*-===//
+//===-- runtime/io-error.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.
diff --git a/runtime/io-stmt.cc b/runtime/io-stmt.cpp
similarity index 97%
rename from runtime/io-stmt.cc
rename to runtime/io-stmt.cpp
index 221cd2de9c97..617e3e697a14 100644
--- a/runtime/io-stmt.cc
+++ b/runtime/io-stmt.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/io-stmt.cc --------------------------------------*- C++ -*-===//
+//===-- runtime/io-stmt.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.
diff --git a/runtime/main.cc b/runtime/main.cpp
similarity index 96%
rename from runtime/main.cc
rename to runtime/main.cpp
index ce36bc2b9bfa..25b3b02001bf 100644
--- a/runtime/main.cc
+++ b/runtime/main.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/main.cc -----------------------------------------*- C++ -*-===//
+//===-- runtime/main.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.
diff --git a/runtime/memory.cc b/runtime/memory.cpp
similarity index 92%
rename from runtime/memory.cc
rename to runtime/memory.cpp
index ab7c63c24b74..e2d997caea78 100644
--- a/runtime/memory.cc
+++ b/runtime/memory.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/memory.cc ---------------------------------------*- C++ -*-===//
+//===-- runtime/memory.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.
diff --git a/runtime/stop.cc b/runtime/stop.cpp
similarity index 96%
rename from runtime/stop.cc
rename to runtime/stop.cpp
index a1f421a0c3a6..8bf665f82512 100644
--- a/runtime/stop.cc
+++ b/runtime/stop.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/stop.cc -----------------------------------------*- C++ -*-===//
+//===-- runtime/stop.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.
diff --git a/runtime/terminator.cc b/runtime/terminator.cpp
similarity index 95%
rename from runtime/terminator.cc
rename to runtime/terminator.cpp
index e2e9b7b327b1..c516af3c854a 100644
--- a/runtime/terminator.cc
+++ b/runtime/terminator.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/terminate.cc ------------------------------------*- C++ -*-===//
+//===-- runtime/terminate.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.
diff --git a/runtime/tools.cc b/runtime/tools.cpp
similarity index 95%
rename from runtime/tools.cc
rename to runtime/tools.cpp
index 8a9980fa50c7..43a0f68b0fe8 100644
--- a/runtime/tools.cc
+++ b/runtime/tools.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/tools.cc ----------------------------------------*- C++ -*-===//
+//===-- runtime/tools.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.
diff --git a/runtime/transformational.cc b/runtime/transformational.cpp
similarity index 98%
rename from runtime/transformational.cc
rename to runtime/transformational.cpp
index bd408dec02ee..42a05e627962 100644
--- a/runtime/transformational.cc
+++ b/runtime/transformational.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/transformational.cc ---------------------------------------===//
+//===-- runtime/transformational.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/runtime/type-code.cc b/runtime/type-code.cpp
similarity index 96%
rename from runtime/type-code.cc
rename to runtime/type-code.cpp
index d4fbced71a37..8b57cdb4e5a7 100644
--- a/runtime/type-code.cc
+++ b/runtime/type-code.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/type-code.cc ----------------------------------------------===//
+//===-- runtime/type-code.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/test/decimal/CMakeLists.txt b/test/decimal/CMakeLists.txt
index 19050bafba45..d1210ba1f4ac 100644
--- a/test/decimal/CMakeLists.txt
+++ b/test/decimal/CMakeLists.txt
@@ -7,7 +7,7 @@
 #===------------------------------------------------------------------------===#
 
 add_executable(quick-sanity-test
-  quick-sanity-test.cc
+  quick-sanity-test.cpp
 )
 
 target_link_libraries(quick-sanity-test
@@ -15,7 +15,7 @@ target_link_libraries(quick-sanity-test
 )
 
 add_executable(thorough-test
-  thorough-test.cc
+  thorough-test.cpp
 )
 
 target_link_libraries(thorough-test
diff --git a/test/decimal/quick-sanity-test.cc b/test/decimal/quick-sanity-test.cpp
similarity index 100%
rename from test/decimal/quick-sanity-test.cc
rename to test/decimal/quick-sanity-test.cpp
diff --git a/test/decimal/thorough-test.cc b/test/decimal/thorough-test.cpp
similarity index 100%
rename from test/decimal/thorough-test.cc
rename to test/decimal/thorough-test.cpp
diff --git a/test/evaluate/CMakeLists.txt b/test/evaluate/CMakeLists.txt
index 47b1f780543f..088280f9277b 100644
--- a/test/evaluate/CMakeLists.txt
+++ b/test/evaluate/CMakeLists.txt
@@ -7,12 +7,12 @@
 #===------------------------------------------------------------------------===#
 
 add_library(FortranEvaluateTesting
-  testing.cc
-  fp-testing.cc
+  testing.cpp
+  fp-testing.cpp
 )
 
 add_executable(leading-zero-bit-count-test
-  leading-zero-bit-count.cc
+  leading-zero-bit-count.cpp
 )
 
 target_link_libraries(leading-zero-bit-count-test
@@ -20,7 +20,7 @@ target_link_libraries(leading-zero-bit-count-test
 )
 
 add_executable(bit-population-count-test
-  bit-population-count.cc
+  bit-population-count.cpp
 )
 
 target_link_libraries(bit-population-count-test
@@ -28,7 +28,7 @@ target_link_libraries(bit-population-count-test
 )
 
 add_executable(uint128-test
-  uint128.cc
+  uint128.cpp
 )
 
 target_link_libraries(uint128-test
@@ -41,7 +41,7 @@ add_test(Leadz leading-zero-bit-count-test)
 add_test(PopPar bit-population-count-test)
 
 add_executable(expression-test
-  expression.cc
+  expression.cpp
 )
 
 target_link_libraries(expression-test
@@ -52,7 +52,7 @@ target_link_libraries(expression-test
 )
 
 add_executable(integer-test
-  integer.cc
+  integer.cpp
 )
 
 target_link_libraries(integer-test
@@ -62,7 +62,7 @@ target_link_libraries(integer-test
 )
 
 add_executable(intrinsics-test
-  intrinsics.cc
+  intrinsics.cpp
 )
 
 target_link_libraries(intrinsics-test
@@ -75,7 +75,7 @@ target_link_libraries(intrinsics-test
 )
 
 add_executable(logical-test
-  logical.cc
+  logical.cpp
 )
 
 target_link_libraries(logical-test
@@ -88,9 +88,9 @@ target_link_libraries(logical-test
 # IEEE exception flags (different use of the word "exception")
 # in the actual hardware floating-point status register, so ensure that
 # C++ exceptions are enabled for this test.
-set_source_files_properties(real.cc PROPERTIES COMPILE_FLAGS -fexceptions)
+set_source_files_properties(real.cpp PROPERTIES COMPILE_FLAGS -fexceptions)
 add_executable(real-test
-  real.cc
+  real.cpp
 )
 
 target_link_libraries(real-test
@@ -102,7 +102,7 @@ target_link_libraries(real-test
 )
 
 add_executable(reshape-test
-  reshape.cc
+  reshape.cpp
 )
 
 target_link_libraries(reshape-test
@@ -113,7 +113,7 @@ target_link_libraries(reshape-test
 )
 
 add_executable(ISO-Fortran-binding-test
-  ISO-Fortran-binding.cc
+  ISO-Fortran-binding.cpp
 )
 
 target_link_libraries(ISO-Fortran-binding-test
@@ -124,7 +124,7 @@ target_link_libraries(ISO-Fortran-binding-test
 )
 
 add_executable(folding-test
-  folding.cc
+  folding.cpp
 )
 
 target_link_libraries(folding-test
diff --git a/test/evaluate/ISO-Fortran-binding.cc b/test/evaluate/ISO-Fortran-binding.cpp
similarity index 100%
rename from test/evaluate/ISO-Fortran-binding.cc
rename to test/evaluate/ISO-Fortran-binding.cpp
diff --git a/test/evaluate/bit-population-count.cc b/test/evaluate/bit-population-count.cpp
similarity index 100%
rename from test/evaluate/bit-population-count.cc
rename to test/evaluate/bit-population-count.cpp
diff --git a/test/evaluate/expression.cc b/test/evaluate/expression.cpp
similarity index 100%
rename from test/evaluate/expression.cc
rename to test/evaluate/expression.cpp
diff --git a/test/evaluate/folding.cc b/test/evaluate/folding.cpp
similarity index 98%
rename from test/evaluate/folding.cc
rename to test/evaluate/folding.cpp
index f72670ed60eb..bf68a74e0976 100644
--- a/test/evaluate/folding.cc
+++ b/test/evaluate/folding.cpp
@@ -41,7 +41,7 @@ static FunctionRef<T> CreateIntrinsicElementalCall(
 }
 
 // Test flushSubnormalsToZero when folding with host runtime.
-// Subnormal value flushing on host is handle in host.cc
+// Subnormal value flushing on host is handle in host.cpp
 // HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment
 
 // Dummy host runtime functions where subnormal flushing matters
diff --git a/test/evaluate/fp-testing.cc b/test/evaluate/fp-testing.cpp
similarity index 100%
rename from test/evaluate/fp-testing.cc
rename to test/evaluate/fp-testing.cpp
diff --git a/test/evaluate/integer.cc b/test/evaluate/integer.cpp
similarity index 100%
rename from test/evaluate/integer.cc
rename to test/evaluate/integer.cpp
diff --git a/test/evaluate/intrinsics.cc b/test/evaluate/intrinsics.cpp
similarity index 100%
rename from test/evaluate/intrinsics.cc
rename to test/evaluate/intrinsics.cpp
diff --git a/test/evaluate/leading-zero-bit-count.cc b/test/evaluate/leading-zero-bit-count.cpp
similarity index 100%
rename from test/evaluate/leading-zero-bit-count.cc
rename to test/evaluate/leading-zero-bit-count.cpp
diff --git a/test/evaluate/logical.cc b/test/evaluate/logical.cpp
similarity index 100%
rename from test/evaluate/logical.cc
rename to test/evaluate/logical.cpp
diff --git a/test/evaluate/real.cc b/test/evaluate/real.cpp
similarity index 100%
rename from test/evaluate/real.cc
rename to test/evaluate/real.cpp
diff --git a/test/evaluate/reshape.cc b/test/evaluate/reshape.cpp
similarity index 100%
rename from test/evaluate/reshape.cc
rename to test/evaluate/reshape.cpp
diff --git a/test/evaluate/testing.cc b/test/evaluate/testing.cpp
similarity index 100%
rename from test/evaluate/testing.cc
rename to test/evaluate/testing.cpp
diff --git a/test/evaluate/uint128.cc b/test/evaluate/uint128.cpp
similarity index 100%
rename from test/evaluate/uint128.cc
rename to test/evaluate/uint128.cpp
diff --git a/test/runtime/CMakeLists.txt b/test/runtime/CMakeLists.txt
index 5cbc230d7eed..fda3776cc906 100644
--- a/test/runtime/CMakeLists.txt
+++ b/test/runtime/CMakeLists.txt
@@ -11,7 +11,7 @@ if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
 endif()
 
 add_executable(format-test
-  format.cc
+  format.cpp
 )
 
 target_link_libraries(format-test
@@ -21,7 +21,7 @@ target_link_libraries(format-test
 add_test(Format format-test)
 
 add_executable(hello-world
-  hello.cc
+  hello.cpp
 )
 
 target_link_libraries(hello-world
diff --git a/test/runtime/format.cc b/test/runtime/format.cpp
similarity index 98%
rename from test/runtime/format.cc
rename to test/runtime/format.cpp
index 50381e85ed05..937a4434b8d7 100644
--- a/test/runtime/format.cc
+++ b/test/runtime/format.cpp
@@ -16,7 +16,7 @@ using Results = std::list<std::string>;
 
 // Test harness context for format control
 struct TestFormatContext : virtual public Terminator, public FormatContext {
-  TestFormatContext() : Terminator{"format.cc", 1} {}
+  TestFormatContext() : Terminator{"format.cpp", 1} {}
   void Emit(const char *, std::size_t);
   void HandleSlash(int = 1);
   void HandleRelativePosition(int);
diff --git a/test/runtime/hello.cc b/test/runtime/hello.cpp
similarity index 100%
rename from test/runtime/hello.cc
rename to test/runtime/hello.cpp
diff --git a/tools/f18/CMakeLists.txt b/tools/f18/CMakeLists.txt
index 1a4c97ec03a5..676549c95cf4 100644
--- a/tools/f18/CMakeLists.txt
+++ b/tools/f18/CMakeLists.txt
@@ -10,8 +10,8 @@ file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include")
 
 add_executable(f18
-  f18.cc
-  dump.cc
+  f18.cpp
+  dump.cpp
 )
 
 target_link_libraries(f18
@@ -21,8 +21,8 @@ target_link_libraries(f18
 )
 
 add_executable(f18-parse-demo
-  f18-parse-demo.cc
-  stub-evaluate.cc
+  f18-parse-demo.cpp
+  stub-evaluate.cpp
 )
 
 target_link_libraries(f18-parse-demo
diff --git a/tools/f18/dump.cc b/tools/f18/dump.cpp
similarity index 95%
rename from tools/f18/dump.cc
rename to tools/f18/dump.cpp
index fd2c75e8f4b5..26f4d730f959 100644
--- a/tools/f18/dump.cc
+++ b/tools/f18/dump.cpp
@@ -1,4 +1,4 @@
-//===-- tools/f18/dump.cc -------------------------------------------------===//
+//===-- tools/f18/dump.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/tools/f18/f18-parse-demo.cc b/tools/f18/f18-parse-demo.cpp
similarity index 99%
rename from tools/f18/f18-parse-demo.cc
rename to tools/f18/f18-parse-demo.cpp
index f65b47b78341..d52499e16416 100644
--- a/tools/f18/f18-parse-demo.cc
+++ b/tools/f18/f18-parse-demo.cpp
@@ -1,4 +1,4 @@
-//===-- tools/f18/f18-parse-demo.cc ---------------------------------------===//
+//===-- tools/f18/f18-parse-demo.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -17,7 +17,7 @@
 // always run, whatever the case of the source file extension.  Unrecognized
 // options are passed through to the underlying Fortran compiler.
 //
-// This program is actually a stripped-down variant of f18.cc, a temporary
+// This program is actually a stripped-down variant of f18.cpp, a temporary
 // scaffolding compiler driver that can test some semantic passes of the
 // F18 compiler under development.
 
diff --git a/tools/f18/f18.cc b/tools/f18/f18.cpp
similarity index 99%
rename from tools/f18/f18.cc
rename to tools/f18/f18.cpp
index 32a5cd4dce81..56f008ba6fe1 100644
--- a/tools/f18/f18.cc
+++ b/tools/f18/f18.cpp
@@ -1,4 +1,4 @@
-//===-- tools/f18/f18.cc --------------------------------------------------===//
+//===-- tools/f18/f18.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/tools/f18/stub-evaluate.cc b/tools/f18/stub-evaluate.cpp
similarity index 94%
rename from tools/f18/stub-evaluate.cc
rename to tools/f18/stub-evaluate.cpp
index 0b2020383b71..99e2635430c0 100644
--- a/tools/f18/stub-evaluate.cc
+++ b/tools/f18/stub-evaluate.cpp
@@ -1,4 +1,4 @@
-//===-- tools/f18/stub-evaluate.cc ----------------------------------------===//
+//===-- tools/f18/stub-evaluate.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.

From 0c3c39d30e3f166a6a1303337c5fd7eead720fd0 Mon Sep 17 00:00:00 2001
From: "Jinxin (Brian) Yang" <jinxiny@nvidia.com>
Date: Tue, 28 Jan 2020 12:51:35 -0800
Subject: [PATCH 013/345] [OpenMP] Name Resolution for OpenMP constructs (#940)

This is an extended framework based on the previous work that addresses
the NR on OpenMP directives/clauses (b2ea520). In this change:
  * New `OmpVisitor` is created (ResolveNamesVisitor derives from it) to
    create necessary scopes for certain OpenMP constructs. This is along
    with the regular Fortran NR process.
  * Old `OmpVisitor` is adjusted and converted to a standalone visitor--
    `OmpAttributeVisitor`. This is used to walk through the OpenMP constructs
    and do the NR for variables on the OpenMP directives or data references
    within the OpenMP constructs. "Do the NR" here means that based on the NR
    results of the regular Fortran NR, fix the symbols of `Names` related
    to the OpenMP constructs. Note that there is an `OmpContext` in this
    visitor (similar to the one in `OmpStructureChecker`), this is necessary
    when dealing with the nested OpenMP constructs in the future.

Given an OpenMP code:
```
real*8 a, b
  a = 1.
  b = 2.
  !$omp parallel private(a)
  a = 3.
  b = 4.
  !$omp end parallel
  print *, a, b
end
```

w/o -fopenmp:
```
real*8 a, b
 !REF: /MainProgram1/a
 a = 1.
 !REF: /MainProgram1/b
 b = 2.
 !!!! OMP parallel
 !REF: /MainProgram1/a
 a = 3.
 !REF: /MainProgram1/b
 b = 4.
 !!!! OMP end parallel
 !REF: /MainProgram1/a
 !REF: /MainProgram1/b
 print *, a, b
end
```

w/ -fopenmp:
```
real*8 a, b
 !REF: /MainProgram1/a
 a = 1.
 !REF: /MainProgram1/b
 b = 2.
!$omp parallel  private(a)   <-- new Symbol for 'a' created
 !DEF: /MainProgram1/Block1/a (OmpPrivate) HostAssoc REAL(8)
 a = 3.   <-- fix the old symbol with new Symbol in parallel scope
 !REF: /MainProgram1/b
 b = 4.   <-- do nothing because by default it is shared in this scope
!$omp end parallel
 !REF: /MainProgram1/a
 !REF: /MainProgram1/b
 print *, a, b
end
```

Please note that this is a framework update, there are still many
things on the TODO list for finishing the NR for OpenMP (based on
the `OpenMP-semantics.md` design doc), which will be on top of this
framework.

Some TODO items:
- Create a generic function to go through all the rules for deciding
  `predetermined`, `explicitly determined`, and `implicitly determined`
  data-sharing attributes. (This is the next biggest part)
- Handle `Array Sections` and `Array or Structure Element`.
- Take association into consideration for example Pointer association,
  `ASSOCIATE` construct, and etc.
- Handle all the name resolution for directives/clauses that have
  `parser::Name`.

* N.B. Extend `AddSourceRange` to apply to current and parent scopes
  - motivated by a few cases that need to call `AddSourceRange`
    for current & parent scopes; the extension should be safe
  - global scope is not included
---
 include/flang/parser/parse-tree.h        |   6 +
 include/flang/semantics/symbol.h         |   2 +-
 lib/parser/openmp-parsers.cpp            |  24 +-
 lib/semantics/resolve-names.cpp          | 679 ++++++++++++++++-------
 lib/semantics/scope.cpp                  |   5 +-
 test/semantics/CMakeLists.txt            |   2 +
 test/semantics/omp-device-constructs.f90 |   2 +-
 test/semantics/omp-resolve05.f90         |  23 +
 test/semantics/omp-symbol07.f90          |  37 ++
 9 files changed, 569 insertions(+), 211 deletions(-)
 create mode 100644 test/semantics/omp-resolve05.f90
 create mode 100644 test/semantics/omp-symbol07.f90

diff --git a/include/flang/parser/parse-tree.h b/include/flang/parser/parse-tree.h
index 29638957f35b..57093e3903cb 100644
--- a/include/flang/parser/parse-tree.h
+++ b/include/flang/parser/parse-tree.h
@@ -3498,10 +3498,12 @@ struct OmpSectionsDirective {
 struct OmpBeginSectionsDirective {
   TUPLE_CLASS_BOILERPLATE(OmpBeginSectionsDirective);
   std::tuple<OmpSectionsDirective, OmpClauseList> t;
+  CharBlock source;
 };
 struct OmpEndSectionsDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndSectionsDirective);
   std::tuple<OmpSectionsDirective, OmpClauseList> t;
+  CharBlock source;
 };
 
 // [!$omp section]
@@ -3742,21 +3744,25 @@ struct OpenMPStandaloneConstruct {
 struct OmpBeginLoopDirective {
   TUPLE_CLASS_BOILERPLATE(OmpBeginLoopDirective);
   std::tuple<OmpLoopDirective, OmpClauseList> t;
+  CharBlock source;
 };
 
 struct OmpEndLoopDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndLoopDirective);
   std::tuple<OmpLoopDirective, OmpClauseList> t;
+  CharBlock source;
 };
 
 struct OmpBeginBlockDirective {
   TUPLE_CLASS_BOILERPLATE(OmpBeginBlockDirective);
   std::tuple<OmpBlockDirective, OmpClauseList> t;
+  CharBlock source;
 };
 
 struct OmpEndBlockDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndBlockDirective);
   std::tuple<OmpBlockDirective, OmpClauseList> t;
+  CharBlock source;
 };
 
 struct OpenMPBlockConstruct {
diff --git a/include/flang/semantics/symbol.h b/include/flang/semantics/symbol.h
index 335e6ed936a5..faef1ca7af2b 100644
--- a/include/flang/semantics/symbol.h
+++ b/include/flang/semantics/symbol.h
@@ -467,7 +467,7 @@ class Symbol {
       // OpenMP miscellaneous flags
       OmpCommonBlock, OmpReduction, OmpDeclareSimd, OmpDeclareTarget,
       OmpThreadprivate, OmpDeclareReduction, OmpFlushed, OmpCriticalLock,
-      OmpIfSpecified);
+      OmpIfSpecified, OmpNone);
   using Flags = common::EnumSet<Flag, Flag_enumSize>;
 
   const Scope &owner() const { return *owner_; }
diff --git a/lib/parser/openmp-parsers.cpp b/lib/parser/openmp-parsers.cpp
index 076c3e8218a3..fd1b96191b24 100644
--- a/lib/parser/openmp-parsers.cpp
+++ b/lib/parser/openmp-parsers.cpp
@@ -280,8 +280,8 @@ TYPE_PARSER(sourced(construct<OmpLoopDirective>(first(
         pure(OmpLoopDirective::Directive::TeamsDistributeSimd),
     "TEAMS DISTRIBUTE" >> pure(OmpLoopDirective::Directive::TeamsDistribute)))))
 
-TYPE_PARSER(construct<OmpBeginLoopDirective>(
-    sourced(Parser<OmpLoopDirective>{}), Parser<OmpClauseList>{}))
+TYPE_PARSER(sourced(construct<OmpBeginLoopDirective>(
+    sourced(Parser<OmpLoopDirective>{}), Parser<OmpClauseList>{})))
 
 // 2.14.1 construct-type-clause -> PARALLEL | SECTIONS | DO | TASKGROUP
 TYPE_PARSER(sourced(construct<OmpCancelType>(
@@ -345,8 +345,8 @@ TYPE_PARSER(construct<OmpBlockDirective>(
         "TEAMS" >> pure(OmpBlockDirective::Directive::Teams),
         "WORKSHARE" >> pure(OmpBlockDirective::Directive::Workshare))))
 
-TYPE_PARSER(construct<OmpBeginBlockDirective>(
-    sourced(Parser<OmpBlockDirective>{}), Parser<OmpClauseList>{}))
+TYPE_PARSER(sourced(construct<OmpBeginBlockDirective>(
+    sourced(Parser<OmpBlockDirective>{}), Parser<OmpClauseList>{})))
 
 TYPE_PARSER(construct<OmpReductionInitializerClause>(
     "INITIALIZER" >> parenthesized("OMP_PRIV =" >> expr)))
@@ -482,12 +482,12 @@ TYPE_PARSER(construct<OmpSectionsDirective>(
             pure(OmpSectionsDirective::Directive::ParallelSections))))
 
 // OMP BEGIN and END SECTIONS Directive
-TYPE_PARSER(construct<OmpBeginSectionsDirective>(
-    sourced(Parser<OmpSectionsDirective>{}), Parser<OmpClauseList>{}))
+TYPE_PARSER(sourced(construct<OmpBeginSectionsDirective>(
+    sourced(Parser<OmpSectionsDirective>{}), Parser<OmpClauseList>{})))
 TYPE_PARSER(
-    startOmpLine >> construct<OmpEndSectionsDirective>(
+    startOmpLine >> sourced(construct<OmpEndSectionsDirective>(
                         sourced("END"_tok >> Parser<OmpSectionsDirective>{}),
-                        Parser<OmpClauseList>{}))
+                        Parser<OmpClauseList>{})))
 
 // OMP SECTION-BLOCK
 TYPE_PARSER(maybe(startOmpLine >> "SECTION"_tok / endOmpLine) >>
@@ -512,15 +512,15 @@ TYPE_CONTEXT_PARSER("OpenMP construct"_en_US,
 
 // END OMP Block directives
 TYPE_PARSER(
-    startOmpLine >> construct<OmpEndBlockDirective>(
+    startOmpLine >> sourced(construct<OmpEndBlockDirective>(
                         sourced("END"_tok >> Parser<OmpBlockDirective>{}),
-                        Parser<OmpClauseList>{}))
+                        Parser<OmpClauseList>{})))
 
 // END OMP Loop directives
 TYPE_PARSER(
-    startOmpLine >> construct<OmpEndLoopDirective>(
+    startOmpLine >> sourced(construct<OmpEndLoopDirective>(
                         sourced("END"_tok >> Parser<OmpLoopDirective>{}),
-                        Parser<OmpClauseList>{}))
+                        Parser<OmpClauseList>{})))
 
 TYPE_PARSER(construct<OpenMPLoopConstruct>(
     Parser<OmpBeginLoopDirective>{} / endOmpLine))
diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index e6a9b7f9bfeb..ca8e26700128 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -8,6 +8,7 @@
 
 #include "resolve-names.h"
 #include "assignment.h"
+#include "check-omp-structure.h"
 #include "mod-file.h"
 #include "program-tree.h"
 #include "resolve-names-utils.h"
@@ -444,12 +445,7 @@ class ScopeHandler : public ImplicitRulesVisitor {
 
   template<typename T> bool Pre(const parser::Statement<T> &x) {
     messageHandler().set_currStmtSource(x.source);
-    for (auto *scope = currScope_; scope; scope = &scope->parent()) {
-      scope->AddSourceRange(x.source);
-      if (scope->IsGlobal()) {
-        break;
-      }
-    }
+    currScope_->AddSourceRange(x.source);
     return true;
   }
   template<typename T> void Post(const parser::Statement<T> &) {
@@ -786,6 +782,8 @@ class DeclarationVisitor : public ArraySpecVisitor,
   void CheckExplicitInterface(const parser::Name &);
   void CheckBindings(const parser::TypeBoundProcedureStmt::WithoutInterface &);
 
+  const parser::Name *ResolveDesignator(const parser::Designator &);
+
 protected:
   bool BeginDecl();
   void EndDecl();
@@ -814,7 +812,6 @@ class DeclarationVisitor : public ArraySpecVisitor,
   // or nullptr in case of error.
   const parser::Name *ResolveStructureComponent(
       const parser::StructureComponent &);
-  const parser::Name *ResolveDesignator(const parser::Designator &);
   const parser::Name *ResolveDataRef(const parser::DataRef &);
   const parser::Name *ResolveVariable(const parser::Variable &);
   const parser::Name *ResolveName(const parser::Name &);
@@ -1045,43 +1042,132 @@ class ConstructVisitor : public virtual DeclarationVisitor {
   void PopAssociation();
 };
 
-// Resolve OpenMP construct entities and statement (TODO) entities
+// Create scopes for OpenMP constructs
 class OmpVisitor : public virtual DeclarationVisitor {
 public:
-  static const parser::Name *GetDesignatorNameIfDataRef(
-      const parser::Designator &designator) {
-    const auto *dataRef{std::get_if<parser::DataRef>(&designator.u)};
-    return dataRef ? std::get_if<parser::Name>(&dataRef->u) : nullptr;
-  }
+  void AddOmpSourceRange(const parser::CharBlock &);
 
-  bool Pre(const parser::OpenMPBlockConstruct &) {
-    PushScope(Scope::Kind::Block, nullptr);
+  static bool NeedsScope(const parser::OpenMPBlockConstruct &);
+
+  bool Pre(const parser::OpenMPBlockConstruct &);
+  void Post(const parser::OpenMPBlockConstruct &);
+  bool Pre(const parser::OmpBeginBlockDirective &x) {
+    AddOmpSourceRange(x.source);
     return true;
   }
-  void Post(const parser::OpenMPBlockConstruct &) { PopScope(); }
-  bool Pre(const parser::OmpBeginBlockDirective &) {
-    ClearDataSharingAttributeObjects();
+  void Post(const parser::OmpBeginBlockDirective &) {
+    messageHandler().set_currStmtSource(std::nullopt);
+  }
+  bool Pre(const parser::OmpEndBlockDirective &x) {
+    AddOmpSourceRange(x.source);
     return true;
   }
+  void Post(const parser::OmpEndBlockDirective &) {
+    messageHandler().set_currStmtSource(std::nullopt);
+  }
 
   bool Pre(const parser::OpenMPLoopConstruct &) {
     PushScope(Scope::Kind::Block, nullptr);
     return true;
   }
   void Post(const parser::OpenMPLoopConstruct &) { PopScope(); }
-  bool Pre(const parser::OmpBeginLoopDirective &) {
-    ClearDataSharingAttributeObjects();
+  bool Pre(const parser::OmpBeginLoopDirective &x) {
+    AddOmpSourceRange(x.source);
+    return true;
+  }
+  void Post(const parser::OmpBeginLoopDirective &) {
+    messageHandler().set_currStmtSource(std::nullopt);
+  }
+  bool Pre(const parser::OmpEndLoopDirective &x) {
+    AddOmpSourceRange(x.source);
+    return true;
+  }
+  void Post(const parser::OmpEndLoopDirective &) {
+    messageHandler().set_currStmtSource(std::nullopt);
+  }
+
+  bool Pre(const parser::OpenMPSectionsConstruct &) {
+    PushScope(Scope::Kind::Block, nullptr);
+    return true;
+  }
+  void Post(const parser::OpenMPSectionsConstruct &) { PopScope(); }
+  bool Pre(const parser::OmpBeginSectionsDirective &x) {
+    AddOmpSourceRange(x.source);
+    return true;
+  }
+  void Post(const parser::OmpBeginSectionsDirective &) {
+    messageHandler().set_currStmtSource(std::nullopt);
+  }
+  bool Pre(const parser::OmpEndSectionsDirective &x) {
+    AddOmpSourceRange(x.source);
     return true;
   }
+  void Post(const parser::OmpEndSectionsDirective &) {
+    messageHandler().set_currStmtSource(std::nullopt);
+  }
+};
+
+bool OmpVisitor::NeedsScope(const parser::OpenMPBlockConstruct &x) {
+  const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
+  const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
+  switch (beginDir.v) {
+  case parser::OmpBlockDirective::Directive::TargetData:
+  case parser::OmpBlockDirective::Directive::Master:
+  case parser::OmpBlockDirective::Directive::Ordered: return false;
+  default: return true;
+  }
+}
 
-  bool Pre(const parser::OpenMPThreadprivate &x) {
+void OmpVisitor::AddOmpSourceRange(const parser::CharBlock &source) {
+  messageHandler().set_currStmtSource(source);
+  currScope().AddSourceRange(source);
+}
+
+bool OmpVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
+  if (NeedsScope(x)) {
     PushScope(Scope::Kind::Block, nullptr);
-    const auto &list{std::get<parser::OmpObjectList>(x.t)};
-    ResolveOmpObjectList(list, Symbol::Flag::OmpThreadprivate);
+  }
+  return true;
+}
+
+void OmpVisitor::Post(const parser::OpenMPBlockConstruct &x) {
+  if (NeedsScope(x)) {
     PopScope();
-    return false;
   }
+}
+
+// Data-sharing and Data-mapping attributes for data-refs in OpenMP construct
+class OmpAttributeVisitor {
+public:
+  explicit OmpAttributeVisitor(
+      SemanticsContext &context, ResolveNamesVisitor &resolver)
+    : context_{context}, resolver_{resolver} {}
+
+  template<typename A> void Walk(const A &x) { parser::Walk(x, *this); }
+
+  template<typename A> bool Pre(const A &) { return true; }
+  template<typename A> void Post(const A &) {}
+
+  bool Pre(const parser::OpenMPBlockConstruct &);
+  void Post(const parser::OpenMPBlockConstruct &) { PopContext(); }
+  void Post(const parser::OmpBeginBlockDirective &) {
+    GetContext().withinConstruct = true;
+  }
+
+  bool Pre(const parser::OpenMPLoopConstruct &);
+  void Post(const parser::OpenMPLoopConstruct &) { PopContext(); }
+  void Post(const parser::OmpBeginLoopDirective &) {
+    GetContext().withinConstruct = true;
+  }
+
+  bool Pre(const parser::OpenMPSectionsConstruct &);
+  void Post(const parser::OpenMPSectionsConstruct &) { PopContext(); }
+
+  bool Pre(const parser::OpenMPThreadprivate &);
+  void Post(const parser::OpenMPThreadprivate &) { PopContext(); }
 
+  // 2.15.3 Data-Sharing Attribute Clauses
+  void Post(const parser::OmpDefaultClause &);
   bool Pre(const parser::OmpClause::Shared &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpShared);
     return false;
@@ -1099,7 +1185,60 @@ class OmpVisitor : public virtual DeclarationVisitor {
     return false;
   }
 
+  void Post(const parser::Name &);
+
 private:
+  struct OmpContext {
+    OmpContext(const parser::CharBlock &source, OmpDirective d, Scope &s)
+      : directiveSource{source}, directive{d}, scope{s} {}
+    parser::CharBlock directiveSource;
+    OmpDirective directive;
+    Scope &scope;
+    // TODO: default DSA is implicitly determined in different ways
+    Symbol::Flag defaultDSA{Symbol::Flag::OmpShared};
+    // variables on Data-sharing attribute clauses
+    std::map<const Symbol *, Symbol::Flag> objectWithDSA;
+    bool withinConstruct{false};
+  };
+  // back() is the top of the stack
+  OmpContext &GetContext() {
+    CHECK(!ompContext_.empty());
+    return ompContext_.back();
+  }
+  void PushContext(const parser::CharBlock &source, OmpDirective dir) {
+    ompContext_.emplace_back(source, dir, context_.FindScope(source));
+  }
+  void PopContext() { ompContext_.pop_back(); }
+  void SetContextDirectiveSource(parser::CharBlock &dir) {
+    GetContext().directiveSource = dir;
+  }
+  void SetContextDirectiveEnum(OmpDirective dir) {
+    GetContext().directive = dir;
+  }
+  const Scope &currScope() { return GetContext().scope; }
+  void SetContextDefaultDSA(Symbol::Flag flag) {
+    GetContext().defaultDSA = flag;
+  }
+  void AddToContextObjectWithDSA(const Symbol &symbol, Symbol::Flag flag) {
+    GetContext().objectWithDSA.emplace(&symbol, flag);
+  }
+  bool IsObjectWithDSA(const Symbol &symbol) {
+    auto it{GetContext().objectWithDSA.find(&symbol)};
+    return it != GetContext().objectWithDSA.end();
+  }
+
+  Symbol &MakeAssocSymbol(const SourceName &name, Symbol &prev) {
+    const auto pair{
+        GetContext().scope.try_emplace(name, Attrs{}, HostAssocDetails{prev})};
+    return *pair.first->second;
+  }
+
+  static const parser::Name *GetDesignatorNameIfDataRef(
+      const parser::Designator &designator) {
+    const auto *dataRef{std::get_if<parser::DataRef>(&designator.u)};
+    return dataRef ? std::get_if<parser::Name>(&dataRef->u) : nullptr;
+  }
+
   static constexpr Symbol::Flags dataSharingAttributeFlags{
       Symbol::Flag::OmpShared, Symbol::Flag::OmpPrivate,
       Symbol::Flag::OmpFirstPrivate, Symbol::Flag::OmpLastPrivate,
@@ -1121,185 +1260,23 @@ class OmpVisitor : public virtual DeclarationVisitor {
   }
   bool HasDataSharingAttributeObject(const Symbol &);
 
-  // TODO: resolve variables referenced in the OpenMP region
   void ResolveOmpObjectList(const parser::OmpObjectList &, Symbol::Flag);
   void ResolveOmpObject(const parser::OmpObject &, Symbol::Flag);
-  Symbol &ResolveOmp(const parser::Name &, Symbol::Flag);
-  Symbol &ResolveOmp(Symbol &, Symbol::Flag);
+  Symbol *ResolveOmp(const parser::Name &, Symbol::Flag);
+  Symbol *ResolveOmp(Symbol &, Symbol::Flag);
   Symbol *ResolveOmpCommonBlockName(const parser::Name *);
-  Symbol &DeclarePrivateAccessEntity(const parser::Name &, Symbol::Flag);
-  Symbol &DeclarePrivateAccessEntity(Symbol &, Symbol::Flag);
-  Symbol &DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
-  Symbol &DeclareOrMarkOtherAccessEntity(Symbol &, Symbol::Flag);
+  Symbol *DeclarePrivateAccessEntity(const parser::Name &, Symbol::Flag);
+  Symbol *DeclarePrivateAccessEntity(Symbol &, Symbol::Flag);
+  Symbol *DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
+  Symbol *DeclareOrMarkOtherAccessEntity(Symbol &, Symbol::Flag);
   void CheckMultipleAppearances(
       const parser::Name &, const Symbol &, Symbol::Flag);
-
   SymbolSet dataSharingAttributeObjects_;  // on one directive
-};
-
-bool OmpVisitor::HasDataSharingAttributeObject(const Symbol &object) {
-  auto it{dataSharingAttributeObjects_.find(object)};
-  return it != dataSharingAttributeObjects_.end();
-}
-
-Symbol *OmpVisitor::ResolveOmpCommonBlockName(const parser::Name *name) {
-  if (auto *prev{name ? currScope().parent().FindCommonBlock(name->source)
-                      : nullptr}) {
-    name->symbol = prev;
-    return prev;
-  } else {
-    return nullptr;
-  }
-}
 
-void OmpVisitor::ResolveOmpObjectList(
-    const parser::OmpObjectList &ompObjectList, Symbol::Flag ompFlag) {
-  for (const auto &ompObject : ompObjectList.v) {
-    ResolveOmpObject(ompObject, ompFlag);
-  }
-}
-
-void OmpVisitor::ResolveOmpObject(
-    const parser::OmpObject &ompObject, Symbol::Flag ompFlag) {
-  std::visit(
-      common::visitors{
-          [&](const parser::Designator &designator) {
-            if (const auto *name{GetDesignatorNameIfDataRef(designator)}) {
-              auto &symbol{ResolveOmp(*name, ompFlag)};
-              if (dataSharingAttributeFlags.test(ompFlag)) {
-                CheckMultipleAppearances(*name, symbol, ompFlag);
-              }
-            } else if (const auto *name{ResolveDesignator(designator)};
-                       name && name->symbol) {
-              // Array sections to be changed to substrings as needed
-              if (AnalyzeExpr(context(), designator)) {
-                if (std::holds_alternative<parser::Substring>(designator.u)) {
-                  Say(designator.source,
-                      "Substrings are not allowed on OpenMP "
-                      "directives or clauses"_err_en_US);
-                  return;
-                }
-              }
-              // other checks, more TBD
-              if (const auto *details{
-                      name->symbol->detailsIf<ObjectEntityDetails>()}) {
-                if (details->IsArray()) {
-                  // TODO: check Array Sections
-                } else if (name->symbol->owner().IsDerivedType()) {
-                  // TODO: check Structure Component
-                }
-              }
-            }
-          },
-          [&](const parser::Name &name) {  // common block
-            if (auto *symbol{ResolveOmpCommonBlockName(&name)}) {
-              CheckMultipleAppearances(
-                  name, *symbol, Symbol::Flag::OmpCommonBlock);
-              // 2.15.3 When a named common block appears in a list, it has the
-              // same meaning as if every explicit member of the common block
-              // appeared in the list
-              for (const Symbol &object :
-                  symbol->get<CommonBlockDetails>().objects()) {
-                Symbol &mutableObject{const_cast<Symbol &>(object)};
-                ResolveOmp(mutableObject, ompFlag);
-              }
-            } else {
-              Say(name.source,  // 2.15.3
-                  "COMMON block must be declared in the same scoping unit "
-                  "in which the OpenMP directive or clause appears"_err_en_US);
-            }
-          },
-      },
-      ompObject.u);
-}
-
-Symbol &OmpVisitor::ResolveOmp(const parser::Name &name, Symbol::Flag ompFlag) {
-  if (ompFlagsRequireNewSymbol.test(ompFlag)) {
-    return DeclarePrivateAccessEntity(name, ompFlag);
-  } else {
-    return DeclareOrMarkOtherAccessEntity(name, ompFlag);
-  }
-}
-
-Symbol &OmpVisitor::ResolveOmp(Symbol &symbol, Symbol::Flag ompFlag) {
-  if (ompFlagsRequireNewSymbol.test(ompFlag)) {
-    return DeclarePrivateAccessEntity(symbol, ompFlag);
-  } else {
-    return DeclareOrMarkOtherAccessEntity(symbol, ompFlag);
-  }
-}
-
-Symbol &OmpVisitor::DeclarePrivateAccessEntity(
-    const parser::Name &name, Symbol::Flag ompFlag) {
-  Symbol &prev{FindOrDeclareEnclosingEntity(name)};
-  if (prev.owner() != currScope()) {
-    auto &symbol{MakeSymbol(name, HostAssocDetails{prev})};
-    symbol.set(ompFlag);
-    name.symbol = &symbol;  // override resolution to parent
-    return symbol;
-  } else {
-    prev.set(ompFlag);
-    return prev;
-  }
-}
-
-Symbol &OmpVisitor::DeclarePrivateAccessEntity(
-    Symbol &object, Symbol::Flag ompFlag) {
-  if (object.owner() != currScope() &&
-      !FindInScope(currScope(), object.name())) {
-    auto &symbol{MakeSymbol(object.name(), Attrs{}, HostAssocDetails{object})};
-    symbol.set(ompFlag);
-    return symbol;
-  } else {
-    object.set(ompFlag);
-    return object;
-  }
-}
-
-Symbol &OmpVisitor::DeclareOrMarkOtherAccessEntity(
-    const parser::Name &name, Symbol::Flag ompFlag) {
-  Symbol &prev{FindOrDeclareEnclosingEntity(name)};
-  name.symbol = &prev;
-  if (ompFlagsRequireMark.test(ompFlag)) {
-    prev.set(ompFlag);
-  }
-  return prev;
-}
-
-Symbol &OmpVisitor::DeclareOrMarkOtherAccessEntity(
-    Symbol &object, Symbol::Flag ompFlag) {
-  if (ompFlagsRequireMark.test(ompFlag)) {
-    object.set(ompFlag);
-  }
-  return object;
-}
-
-static bool WithMultipleAppearancesException(
-    const Symbol &symbol, Symbol::Flag ompFlag) {
-  return (ompFlag == Symbol::Flag::OmpFirstPrivate &&
-             symbol.test(Symbol::Flag::OmpLastPrivate)) ||
-      (ompFlag == Symbol::Flag::OmpLastPrivate &&
-          symbol.test(Symbol::Flag::OmpFirstPrivate));
-}
-
-void OmpVisitor::CheckMultipleAppearances(
-    const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
-  const auto *target{&symbol};
-  if (ompFlagsRequireNewSymbol.test(ompFlag)) {
-    if (const auto *details{symbol.detailsIf<HostAssocDetails>()}) {
-      target = &details->symbol();
-    }
-  }
-  if (HasDataSharingAttributeObject(*target) &&
-      !WithMultipleAppearancesException(symbol, ompFlag)) {
-    Say(name.source,
-        "'%s' appears in more than one data-sharing clause "
-        "on the same OpenMP directive"_err_en_US,
-        name.ToString());
-  } else {
-    AddDataSharingAttributeObject(*target);
-  }
-}
+  SemanticsContext &context_;
+  ResolveNamesVisitor &resolver_;
+  std::vector<OmpContext> ompContext_;  // used as a stack
+};
 
 // Walk the parse tree and resolve names to symbols.
 class ResolveNamesVisitor : public virtual ScopeHandler,
@@ -5730,6 +5707,7 @@ bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
   ResolveSpecificationParts(root);
   FinishSpecificationParts(root);
   ResolveExecutionParts(root);
+  OmpAttributeVisitor{context(), *this}.Walk(x);
   return false;
 }
 
@@ -5915,6 +5893,315 @@ class DeferredCheckVisitor {
   bool pushedScope_{false};
 };
 
+bool OmpAttributeVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
+  const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
+  const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
+  switch (beginDir.v) {
+  case parser::OmpBlockDirective::Directive::Master:
+    PushContext(beginDir.source, OmpDirective::MASTER);
+    break;
+  case parser::OmpBlockDirective::Directive::Ordered:
+    PushContext(beginDir.source, OmpDirective::ORDERED);
+    break;
+  case parser::OmpBlockDirective::Directive::Parallel:
+    PushContext(beginDir.source, OmpDirective::PARALLEL);
+    break;
+  case parser::OmpBlockDirective::Directive::Single:
+    PushContext(beginDir.source, OmpDirective::SINGLE);
+    break;
+  case parser::OmpBlockDirective::Directive::Target:
+    PushContext(beginDir.source, OmpDirective::TARGET);
+    break;
+  case parser::OmpBlockDirective::Directive::TargetData:
+    PushContext(beginDir.source, OmpDirective::TARGET_DATA);
+    break;
+  case parser::OmpBlockDirective::Directive::Task:
+    PushContext(beginDir.source, OmpDirective::TASK);
+    break;
+  case parser::OmpBlockDirective::Directive::Teams:
+    PushContext(beginDir.source, OmpDirective::TEAMS);
+    break;
+  case parser::OmpBlockDirective::Directive::Workshare:
+    PushContext(beginDir.source, OmpDirective::WORKSHARE);
+    break;
+  default:
+    // TODO others
+    break;
+  }
+  ClearDataSharingAttributeObjects();
+  return true;
+}
+
+bool OmpAttributeVisitor::Pre(const parser::OpenMPLoopConstruct &x) {
+  const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
+  const auto &beginDir{std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
+  switch (beginDir.v) {
+  case parser::OmpLoopDirective::Directive::Distribute:
+    PushContext(beginDir.source, OmpDirective::DISTRIBUTE);
+    break;
+  case parser::OmpLoopDirective::Directive::Do:
+    PushContext(beginDir.source, OmpDirective::DO);
+    break;
+  case parser::OmpLoopDirective::Directive::DoSimd:
+    PushContext(beginDir.source, OmpDirective::DO_SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::ParallelDo:
+    PushContext(beginDir.source, OmpDirective::PARALLEL_DO);
+    break;
+  case parser::OmpLoopDirective::Directive::ParallelDoSimd:
+    PushContext(beginDir.source, OmpDirective::PARALLEL_DO_SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::Simd:
+    PushContext(beginDir.source, OmpDirective::SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::Taskloop:
+    PushContext(beginDir.source, OmpDirective::TASKLOOP);
+    break;
+  case parser::OmpLoopDirective::Directive::TaskloopSimd:
+    PushContext(beginDir.source, OmpDirective::TASKLOOP_SIMD);
+    break;
+  default:
+    // TODO others
+    break;
+  }
+  ClearDataSharingAttributeObjects();
+  return true;
+}
+
+bool OmpAttributeVisitor::Pre(const parser::OpenMPSectionsConstruct &x) {
+  const auto &beginSectionsDir{
+      std::get<parser::OmpBeginSectionsDirective>(x.t)};
+  const auto &beginDir{
+      std::get<parser::OmpSectionsDirective>(beginSectionsDir.t)};
+  switch (beginDir.v) {
+  case parser::OmpSectionsDirective::Directive::ParallelSections:
+    PushContext(beginDir.source, OmpDirective::PARALLEL_SECTIONS);
+    break;
+  case parser::OmpSectionsDirective::Directive::Sections:
+    PushContext(beginDir.source, OmpDirective::SECTIONS);
+    break;
+  default: break;
+  }
+  ClearDataSharingAttributeObjects();
+  return true;
+}
+
+bool OmpAttributeVisitor::Pre(const parser::OpenMPThreadprivate &x) {
+  PushContext(x.source, OmpDirective::THREADPRIVATE);
+  const auto &list{std::get<parser::OmpObjectList>(x.t)};
+  ResolveOmpObjectList(list, Symbol::Flag::OmpThreadprivate);
+  return false;
+}
+
+void OmpAttributeVisitor::Post(const parser::OmpDefaultClause &x) {
+  if (!ompContext_.empty()) {
+    switch (x.v) {
+    case parser::OmpDefaultClause::Type::Private:
+      SetContextDefaultDSA(Symbol::Flag::OmpPrivate);
+      break;
+    case parser::OmpDefaultClause::Type::Firstprivate:
+      SetContextDefaultDSA(Symbol::Flag::OmpFirstPrivate);
+      break;
+    case parser::OmpDefaultClause::Type::Shared:
+      SetContextDefaultDSA(Symbol::Flag::OmpShared);
+      break;
+    case parser::OmpDefaultClause::Type::None:
+      SetContextDefaultDSA(Symbol::Flag::OmpNone);
+      break;
+    }
+  }
+}
+
+// For OpenMP constructs, check all the data-refs within the constructs
+// and adjust the symbol for each Name if necessary
+void OmpAttributeVisitor::Post(const parser::Name &name) {
+  auto *symbol{name.symbol};
+  if (symbol && !ompContext_.empty() && GetContext().withinConstruct) {
+    if (!symbol->owner().IsDerivedType() && !symbol->has<ProcEntityDetails>() &&
+        !IsObjectWithDSA(*symbol)) {
+      // TODO: create a separate function to go through the rules for
+      //       predetermined, explicitly determined, and implicitly
+      //       determined data-sharing attributes (2.15.1.1).
+      if (Symbol * found{currScope().FindSymbol(name.source)}) {
+        if (IsObjectWithDSA(*found)) {
+          name.symbol = found;  // adjust the symbol within region
+        } else if (GetContext().defaultDSA == Symbol::Flag::OmpNone) {
+          context_.Say(name.source,
+              "The DEFAULT(NONE) clause requires that '%s' must be listed in "
+              "a data-sharing attribute clause"_err_en_US,
+              symbol->name());
+        }
+      }
+    }
+  }  // within OpenMP construct
+}
+
+bool OmpAttributeVisitor::HasDataSharingAttributeObject(const Symbol &object) {
+  auto it{dataSharingAttributeObjects_.find(object)};
+  return it != dataSharingAttributeObjects_.end();
+}
+
+Symbol *OmpAttributeVisitor::ResolveOmpCommonBlockName(
+    const parser::Name *name) {
+  if (auto *prev{name
+              ? GetContext().scope.parent().FindCommonBlock(name->source)
+              : nullptr}) {
+    name->symbol = prev;
+    return prev;
+  } else {
+    return nullptr;
+  }
+}
+
+void OmpAttributeVisitor::ResolveOmpObjectList(
+    const parser::OmpObjectList &ompObjectList, Symbol::Flag ompFlag) {
+  for (const auto &ompObject : ompObjectList.v) {
+    ResolveOmpObject(ompObject, ompFlag);
+  }
+}
+
+void OmpAttributeVisitor::ResolveOmpObject(
+    const parser::OmpObject &ompObject, Symbol::Flag ompFlag) {
+  std::visit(
+      common::visitors{
+          [&](const parser::Designator &designator) {
+            if (const auto *name{GetDesignatorNameIfDataRef(designator)}) {
+              if (auto *symbol{ResolveOmp(*name, ompFlag)}) {
+                AddToContextObjectWithDSA(*symbol, ompFlag);
+                if (dataSharingAttributeFlags.test(ompFlag)) {
+                  CheckMultipleAppearances(*name, *symbol, ompFlag);
+                }
+              }
+            } else if (const auto *designatorName{
+                           resolver_.ResolveDesignator(designator)};
+                       designatorName->symbol) {
+              // Array sections to be changed to substrings as needed
+              if (AnalyzeExpr(context_, designator)) {
+                if (std::holds_alternative<parser::Substring>(designator.u)) {
+                  context_.Say(designator.source,
+                      "Substrings are not allowed on OpenMP "
+                      "directives or clauses"_err_en_US);
+                }
+              }
+              // other checks, more TBD
+              if (const auto *details{designatorName->symbol
+                                          ->detailsIf<ObjectEntityDetails>()}) {
+                if (details->IsArray()) {
+                  // TODO: check Array Sections
+                } else if (designatorName->symbol->owner().IsDerivedType()) {
+                  // TODO: check Structure Component
+                }
+              }
+            }
+          },
+          [&](const parser::Name &name) {  // common block
+            if (auto *symbol{ResolveOmpCommonBlockName(&name)}) {
+              CheckMultipleAppearances(
+                  name, *symbol, Symbol::Flag::OmpCommonBlock);
+              // 2.15.3 When a named common block appears in a list, it has the
+              // same meaning as if every explicit member of the common block
+              // appeared in the list
+              for (const Symbol &object :
+                  symbol->get<CommonBlockDetails>().objects()) {
+                Symbol &mutableObject{const_cast<Symbol &>(object)};
+                if (auto *resolvedObject{ResolveOmp(mutableObject, ompFlag)}) {
+                  AddToContextObjectWithDSA(*resolvedObject, ompFlag);
+                }
+              }
+            } else {
+              context_.Say(name.source,  // 2.15.3
+                  "COMMON block must be declared in the same scoping unit "
+                  "in which the OpenMP directive or clause appears"_err_en_US);
+            }
+          },
+      },
+      ompObject.u);
+}
+
+Symbol *OmpAttributeVisitor::ResolveOmp(
+    const parser::Name &name, Symbol::Flag ompFlag) {
+  if (ompFlagsRequireNewSymbol.test(ompFlag)) {
+    return DeclarePrivateAccessEntity(name, ompFlag);
+  } else {
+    return DeclareOrMarkOtherAccessEntity(name, ompFlag);
+  }
+}
+
+Symbol *OmpAttributeVisitor::ResolveOmp(Symbol &symbol, Symbol::Flag ompFlag) {
+  if (ompFlagsRequireNewSymbol.test(ompFlag)) {
+    return DeclarePrivateAccessEntity(symbol, ompFlag);
+  } else {
+    return DeclareOrMarkOtherAccessEntity(symbol, ompFlag);
+  }
+}
+
+Symbol *OmpAttributeVisitor::DeclarePrivateAccessEntity(
+    const parser::Name &name, Symbol::Flag ompFlag) {
+  if (!name.symbol) {
+    return nullptr;  // not resolved by Name Resolution step, do nothing
+  }
+  name.symbol = DeclarePrivateAccessEntity(*name.symbol, ompFlag);
+  return name.symbol;
+}
+
+Symbol *OmpAttributeVisitor::DeclarePrivateAccessEntity(
+    Symbol &object, Symbol::Flag ompFlag) {
+  if (object.owner() != currScope()) {
+    auto &symbol{MakeAssocSymbol(object.name(), object)};
+    symbol.set(ompFlag);
+    return &symbol;
+  } else {
+    object.set(ompFlag);
+    return &object;
+  }
+}
+
+Symbol *OmpAttributeVisitor::DeclareOrMarkOtherAccessEntity(
+    const parser::Name &name, Symbol::Flag ompFlag) {
+  Symbol *prev{currScope().FindSymbol(name.source)};
+  if (!name.symbol || !prev) {
+    return nullptr;
+  } else if (prev != name.symbol) {
+    name.symbol = prev;
+  }
+  return DeclareOrMarkOtherAccessEntity(*prev, ompFlag);
+}
+
+Symbol *OmpAttributeVisitor::DeclareOrMarkOtherAccessEntity(
+    Symbol &object, Symbol::Flag ompFlag) {
+  if (ompFlagsRequireMark.test(ompFlag)) {
+    object.set(ompFlag);
+  }
+  return &object;
+}
+
+static bool WithMultipleAppearancesException(
+    const Symbol &symbol, Symbol::Flag ompFlag) {
+  return (ompFlag == Symbol::Flag::OmpFirstPrivate &&
+             symbol.test(Symbol::Flag::OmpLastPrivate)) ||
+      (ompFlag == Symbol::Flag::OmpLastPrivate &&
+          symbol.test(Symbol::Flag::OmpFirstPrivate));
+}
+
+void OmpAttributeVisitor::CheckMultipleAppearances(
+    const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
+  const auto *target{&symbol};
+  if (ompFlagsRequireNewSymbol.test(ompFlag)) {
+    if (const auto *details{symbol.detailsIf<HostAssocDetails>()}) {
+      target = &details->symbol();
+    }
+  }
+  if (HasDataSharingAttributeObject(*target) &&
+      !WithMultipleAppearancesException(symbol, ompFlag)) {
+    context_.Say(name.source,
+        "'%s' appears in more than one data-sharing clause "
+        "on the same OpenMP directive"_err_en_US,
+        name.ToString());
+  } else {
+    AddDataSharingAttributeObject(*target);
+  }
+}
+
 // Perform checks and completions that need to happen after all of
 // the specification parts but before any of the execution parts.
 void ResolveNamesVisitor::FinishSpecificationParts(const ProgramTree &node) {
diff --git a/lib/semantics/scope.cpp b/lib/semantics/scope.cpp
index 96400b626f03..9db599560650 100644
--- a/lib/semantics/scope.cpp
+++ b/lib/semantics/scope.cpp
@@ -244,7 +244,10 @@ Scope *Scope::FindScope(parser::CharBlock source) {
 }
 
 void Scope::AddSourceRange(const parser::CharBlock &source) {
-  sourceRange_.ExtendToCover(source);
+  for (auto *scope = this; !scope->IsGlobal();
+       scope = &scope->parent()) {
+    scope->sourceRange_.ExtendToCover(source);
+  }
 }
 
 std::ostream &operator<<(std::ostream &os, const Scope &scope) {
diff --git a/test/semantics/CMakeLists.txt b/test/semantics/CMakeLists.txt
index 1765b4367ef0..5dfbcb2bf928 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/semantics/CMakeLists.txt
@@ -163,6 +163,7 @@ set(ERROR_TESTS
   omp-resolve02.f90
   omp-resolve03.f90
   omp-resolve04.f90
+  omp-resolve05.f90
   omp-clause-validity01.f90
   omp-loop-association.f90
 #  omp-nested01.f90
@@ -227,6 +228,7 @@ set(SYMBOL_TESTS
   omp-symbol04.f90
   omp-symbol05.f90
   omp-symbol06.f90
+  omp-symbol07.f90
   kinds01.f90
   kinds03.f90
   procinterface01.f90
diff --git a/test/semantics/omp-device-constructs.f90 b/test/semantics/omp-device-constructs.f90
index ca9468707253..118e49c9afc9 100644
--- a/test/semantics/omp-device-constructs.f90
+++ b/test/semantics/omp-device-constructs.f90
@@ -91,7 +91,7 @@ program main
   !$omp end teams
 
   !ERROR: At most one DEFAULT clause can appear on the TEAMS directive
-  !$omp teams default(shared) default(none)
+  !$omp teams default(shared) default(private)
   do i = 1, N
      a = 3.14
   enddo
diff --git a/test/semantics/omp-resolve05.f90 b/test/semantics/omp-resolve05.f90
new file mode 100644
index 000000000000..0ba4fd816d92
--- /dev/null
+++ b/test/semantics/omp-resolve05.f90
@@ -0,0 +1,23 @@
+!OPTIONS: -fopenmp
+
+! 2.15.3 Data-Sharing Attribute Clauses
+! 2.15.3.1 default Clause
+
+subroutine default_none()
+  integer a(3)
+
+  A = 1
+  B = 2
+  !$omp parallel default(none) private(c)
+  !ERROR: The DEFAULT(NONE) clause requires that 'a' must be listed in a data-sharing attribute clause
+  A(1:2) = 3
+  !ERROR: The DEFAULT(NONE) clause requires that 'b' must be listed in a data-sharing attribute clause
+  B = 4
+  C = 5
+  !$omp end parallel
+end subroutine default_none
+
+program mm
+  call default_none()
+  !TODO: private, firstprivate, shared
+end
diff --git a/test/semantics/omp-symbol07.f90 b/test/semantics/omp-symbol07.f90
new file mode 100644
index 000000000000..170452959e01
--- /dev/null
+++ b/test/semantics/omp-symbol07.f90
@@ -0,0 +1,37 @@
+!OPTIONS: -fopenmp
+
+! Generic tests
+!   1. subroutine or function calls should not be fixed for DSA or DMA
+
+!DEF: /foo (Function) Subprogram REAL(4)
+!DEF: /foo/rnum ObjectEntity REAL(4)
+function foo(rnum)
+  !REF: /foo/rnum
+  real rnum
+  !REF: /foo/rnum
+  rnum = rnum+1.
+end function foo
+!DEF: /function_call_in_region EXTERNAL (Subroutine) Subprogram
+subroutine function_call_in_region
+  implicit none
+  !DEF: /function_call_in_region/foo (Function) ProcEntity REAL(4)
+  real foo
+  !DEF: /function_call_in_region/a ObjectEntity REAL(4)
+  real :: a = 0.
+  !DEF: /function_call_in_region/b ObjectEntity REAL(4)
+  real :: b = 5.
+  !$omp parallel  default(none) private(a) shared(b)
+  !DEF: /function_call_in_region/Block1/a (OmpPrivate) HostAssoc REAL(4)
+  !REF: /function_call_in_region/foo
+  !REF: /function_call_in_region/b
+  a = foo(b)
+  !$omp end parallel
+  !REF: /function_call_in_region/a
+  !REF: /function_call_in_region/b
+  print *, a, b
+end subroutine function_call_in_region
+!DEF: /mm MainProgram
+program mm
+  !REF: /function_call_in_region
+  call function_call_in_region
+end program mm

From 3f37e0dbaf32f1127553be2149915cab1b93cdcf Mon Sep 17 00:00:00 2001
From: Jinxin Yang <jinxiny@nvidia.com>
Date: Tue, 28 Jan 2020 13:58:14 -0800
Subject: [PATCH 014/345] Remove `default` case for OmpSectionsDirective (only
 two enum values)

---
 lib/semantics/resolve-names.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index ca8e26700128..5ab1424b246f 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -5980,7 +5980,6 @@ bool OmpAttributeVisitor::Pre(const parser::OpenMPSectionsConstruct &x) {
   case parser::OmpSectionsDirective::Directive::Sections:
     PushContext(beginDir.source, OmpDirective::SECTIONS);
     break;
-  default: break;
   }
   ClearDataSharingAttributeObjects();
   return true;

From d2294ff511aebd64889df57d02325bd6fcdf914a Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Mon, 27 Jan 2020 14:12:35 -0800
Subject: [PATCH 015/345] Semantic checks for deallocating entities with IMPURE
 FINAL procedures

You cannot call an IMPURE procedure in a DO CONCURRENT construct.  One
way that can happen is if an entity with an IMPURE FINAL procedure gets
deallocated.  Similar to the checks for deallocating coarrays, there are
three ways that an entity can get deallocated that are applicable to DO
CONCURRENT constructs -- an actual DEALLOCATE statement, block exit, and
assignment.

This change depends on the utility function `HasImpureFinal()` in tools.h to
determine if an entity has a derived type with an IMPURE FINAL
procedure.  In the course of testing this change, I realized that this
check is incorrect, but the code specific to DO CONCURRENT is
independent of the check, so I might as well implement it.
---
 include/flang/semantics/tools.h   |  2 +-
 lib/semantics/check-do.cpp        | 68 ++++++++++++++++++++-------
 lib/semantics/tools.cpp           |  4 +-
 test/semantics/doconcurrent08.f90 | 76 +++++++++++++++++++++++++++++--
 4 files changed, 128 insertions(+), 22 deletions(-)

diff --git a/include/flang/semantics/tools.h b/include/flang/semantics/tools.h
index 5f56325cc913..59e41700c211 100644
--- a/include/flang/semantics/tools.h
+++ b/include/flang/semantics/tools.h
@@ -48,7 +48,7 @@ const DeclTypeSpec *FindParentTypeSpec(const DerivedTypeSpec &);
 const DeclTypeSpec *FindParentTypeSpec(const DeclTypeSpec &);
 const DeclTypeSpec *FindParentTypeSpec(const Scope &);
 const DeclTypeSpec *FindParentTypeSpec(const Symbol &);
-
+ 
 // Return the Symbol of the variable of a construct association, if it exists
 const Symbol *GetAssociationRoot(const Symbol &);
 
diff --git a/lib/semantics/check-do.cpp b/lib/semantics/check-do.cpp
index 96c8ba73f35a..75acd1b887f6 100644
--- a/lib/semantics/check-do.cpp
+++ b/lib/semantics/check-do.cpp
@@ -95,15 +95,33 @@ class DoConcurrentBodyEnforce {
     return true;
   }
 
+  template<typename T> bool Pre(const parser::UnlabeledStatement<T> &stmt) {
+    currentStatementSourcePosition_ = stmt.source;
+    return true;
+  }
+
   // C1140 -- Can't deallocate a polymorphic entity in a DO CONCURRENT.
   // Deallocation can be caused by exiting a block that declares an allocatable
   // entity, assignment to an allocatable variable, or an actual DEALLOCATE
   // statement
   //
   // Note also that the deallocation of a derived type entity might cause the
-  // invocation of an IMPURE final subroutine.
+  // invocation of an IMPURE final subroutine. (C1139)
   //
 
+  // Only to be called for symbols with ObjectEntityDetails
+  static bool HasImpureFinal(const Symbol &symbol) {
+    if (const Symbol * root{GetAssociationRoot(symbol)}) {
+      CHECK(root->has<ObjectEntityDetails>());
+      if (const DeclTypeSpec * symType{root->GetType()}) {
+        if (const DerivedTypeSpec * derived{symType->AsDerived()}) {
+          return semantics::HasImpureFinal(*derived);
+        }
+      }
+    }
+    return false;
+  }
+
   // Predicate for deallocations caused by block exit and direct deallocation
   static bool DeallocateAll(const Symbol &) { return true; }
 
@@ -143,6 +161,21 @@ class DoConcurrentBodyEnforce {
     return false;
   }
 
+  void SayDeallocateWithImpureFinal(const Symbol &entity, const char *reason) {
+    context_.SayWithDecl(entity, currentStatementSourcePosition_,
+        "Deallocation of an entity with an IMPURE FINAL procedure"
+        " caused by %s not allowed in DO CONCURRENT"_err_en_US,
+        reason);
+  }
+
+  void SayDeallocateOfPolymorph(
+      parser::CharBlock location, const Symbol &entity, const char *reason) {
+    context_.SayWithDecl(entity, location,
+        "Deallocation of a polymorphic entity caused by %s"
+        " not allowed in DO CONCURRENT"_err_en_US,
+        reason);
+  }
+
   // Deallocation caused by block exit
   // Allocatable entities and all of their allocatable subcomponents will be
   // deallocated.  This test is different from the other two because it does
@@ -154,16 +187,16 @@ class DoConcurrentBodyEnforce {
     const Scope &blockScope{context_.FindScope(endBlockStmt.source)};
     const Scope &doScope{context_.FindScope(doConcurrentSourcePosition_)};
     if (DoesScopeContain(&doScope, blockScope)) {
+      const char *reason{"block exit"};
       for (auto &pair : blockScope) {
-        Symbol &entity{*pair.second};
+        const Symbol &entity{*pair.second};
         if (IsAllocatable(entity) && !entity.attrs().test(Attr::SAVE) &&
             MightDeallocatePolymorphic(entity, DeallocateAll)) {
-          context_.SayWithDecl(entity, endBlockStmt.source,
-              "Deallocation of a polymorphic entity caused by block"
-              " exit not allowed in DO CONCURRENT"_err_en_US);
+          SayDeallocateOfPolymorph(endBlockStmt.source, entity, reason);
+        }
+        if (HasImpureFinal(entity)) {
+          SayDeallocateWithImpureFinal(entity, reason);
         }
-        // TODO: Check for deallocation of a variable with an IMPURE FINAL
-        // subroutine
       }
     }
   }
@@ -173,12 +206,12 @@ class DoConcurrentBodyEnforce {
   void Post(const parser::AssignmentStmt &stmt) {
     const auto &variable{std::get<parser::Variable>(stmt.t)};
     if (const Symbol * entity{GetLastName(variable).symbol}) {
+      const char *reason{"assignment"};
       if (MightDeallocatePolymorphic(*entity, DeallocateNonCoarray)) {
-        context_.SayWithDecl(*entity, variable.GetSource(),
-            "Deallocation of a polymorphic entity caused by "
-            "assignment not allowed in DO CONCURRENT"_err_en_US);
-        // TODO: Check for deallocation of a variable with an IMPURE FINAL
-        // subroutine
+        SayDeallocateOfPolymorph(variable.GetSource(), *entity, reason);
+      }
+      if (HasImpureFinal(*entity)) {
+        SayDeallocateWithImpureFinal(*entity, reason);
       }
     }
   }
@@ -191,17 +224,18 @@ class DoConcurrentBodyEnforce {
         std::get<std::list<parser::AllocateObject>>(stmt.t)};
     for (const auto &allocateObject : allocateObjectList) {
       const parser::Name &name{GetLastName(allocateObject)};
+      const char *reason{"a DEALLOCATE statement"};
       if (name.symbol) {
         const Symbol &entity{*name.symbol};
         const DeclTypeSpec *entityType{entity.GetType()};
         if ((entityType && entityType->IsPolymorphic()) ||  // POINTER case
             MightDeallocatePolymorphic(entity, DeallocateAll)) {
-          context_.SayWithDecl(entity, currentStatementSourcePosition_,
-              "Deallocation of a polymorphic entity not allowed in DO"
-              " CONCURRENT"_err_en_US);
+          SayDeallocateOfPolymorph(
+              currentStatementSourcePosition_, entity, reason);
+        }
+        if (HasImpureFinal(entity)) {
+          SayDeallocateWithImpureFinal(entity, reason);
         }
-        // TODO: Check for deallocation of a variable with an IMPURE FINAL
-        // subroutine
       }
     }
   }
diff --git a/lib/semantics/tools.cpp b/lib/semantics/tools.cpp
index a39ff409db04..8e31a81a0573 100644
--- a/lib/semantics/tools.cpp
+++ b/lib/semantics/tools.cpp
@@ -508,7 +508,7 @@ const DeclTypeSpec *FindParentTypeSpec(const Symbol &symbol) {
   return nullptr;
 }
 
-// When an construct association maps to a variable, and that variable
+// When a construct association maps to a variable, and that variable
 // is not an array with a vector-valued subscript, return the base
 // Symbol of that variable, else nullptr.  Descends into other construct
 // associations when one associations maps to another.
@@ -665,6 +665,8 @@ bool IsFinalizable(const DerivedTypeSpec &derived) {
       components.end();
 }
 
+// TODO The following function returns true for all types with FINAL procedures
+// This is because we don't yet fill in the data for FinalProcDetails
 bool HasImpureFinal(const DerivedTypeSpec &derived) {
   ScopeComponentIterator components{derived};
   return std::find_if(
diff --git a/test/semantics/doconcurrent08.f90 b/test/semantics/doconcurrent08.f90
index b4b5d413e9a0..b42ab6160a9f 100644
--- a/test/semantics/doconcurrent08.f90
+++ b/test/semantics/doconcurrent08.f90
@@ -188,18 +188,88 @@ subroutine s3()
 
   do concurrent (i = 1:10)
     ! Bad because deallocation of a polymorphic entity
-!ERROR: Deallocation of a polymorphic entity not allowed in DO CONCURRENT
+!ERROR: Deallocation of a polymorphic entity caused by a DEALLOCATE statement not allowed in DO CONCURRENT
     deallocate(polyVar)
 
     ! Bad, deallocation of an entity with a polymorphic component
-!ERROR: Deallocation of a polymorphic entity not allowed in DO CONCURRENT
+!ERROR: Deallocation of a polymorphic entity caused by a DEALLOCATE statement not allowed in DO CONCURRENT
     deallocate(polyComponentVar)
 
     ! Bad, deallocation of a pointer to an entity with a polymorphic component
-!ERROR: Deallocation of a polymorphic entity not allowed in DO CONCURRENT
+!ERROR: Deallocation of a polymorphic entity caused by a DEALLOCATE statement not allowed in DO CONCURRENT
     deallocate(pointerPolyComponentVar)
 
     ! Deallocation of a nonpolymorphic entity
     deallocate(nonPolyVar)
   end do
 end subroutine s3
+
+module m2
+  type :: impureFinal
+   contains
+    final :: impureSub
+  end type
+
+  type :: pureFinal
+   contains
+    final :: pureSub
+  end type
+
+ contains
+
+  impure subroutine impureSub(x)
+    type(impureFinal), intent(in) :: x
+  end subroutine
+
+  pure subroutine pureSub(x)
+    type(pureFinal), intent(in) :: x
+  end subroutine
+
+  subroutine s4()
+    type(impureFinal), allocatable :: ifVar, ifvar1
+    type(pureFinal), allocatable :: pfVar
+    allocate(ifVar)
+    allocate(ifVar1)
+    allocate(pfVar)
+
+    ! OK for an ordinary DO loop
+    do i = 1,10
+      if (i .eq. 1) deallocate(ifVar)
+    end do
+
+    ! OK to invoke a PURE FINAL procedure in a DO CONCURRENT
+    ! This case does not work currently because the compiler's test for
+    ! HasImpureFinal() in .../lib/semantics/tools.cc doesn't work correctly
+!    do concurrent (i = 1:10)
+!      if (i .eq. 1) deallocate(pfVar)
+!    end do
+
+    ! Error to invoke an IMPURE FINAL procedure in a DO CONCURRENT
+    do concurrent (i = 1:10)
+          !ERROR: Deallocation of an entity with an IMPURE FINAL procedure caused by a DEALLOCATE statement not allowed in DO CONCURRENT
+      if (i .eq. 1) deallocate(ifVar)
+    end do
+
+    do concurrent (i = 1:10)
+      if (i .eq. 1) then
+        block
+          type(impureFinal), allocatable :: ifVar
+          allocate(ifVar)
+          ! Error here because exiting this scope causes the finalization of 
+          !ifvar which causes the invocation of an IMPURE FINAL procedure
+          !ERROR: Deallocation of an entity with an IMPURE FINAL procedure caused by block exit not allowed in DO CONCURRENT
+        end block
+      end if
+    end do
+
+    do concurrent (i = 1:10)
+      if (i .eq. 1) then
+        ! Error here because the assignment statement causes the finalization 
+        ! of ifvar which causes the invocation of an IMPURE FINAL procedure
+!ERROR: Deallocation of an entity with an IMPURE FINAL procedure caused by assignment not allowed in DO CONCURRENT
+        ifvar = ifvar1
+      end if
+    end do
+  end subroutine s4
+
+end module m2

From aa0a0887325bd1fc6c3a1ad40fc6711d2e458a1c Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 28 Jan 2020 15:06:03 -0800
Subject: [PATCH 016/345] Fix another bug checking simple contiguity

The test still wasn't correct for structure components. If the last
part-ref is a non-array or a single array element, but the whole
ArrayRef has non-zero rank, it is not contiguous. Otherwise, if there
are subscripts on the last part-ref they can be checked normally.

Add some tests for cases that were previously failing, and also for
cases with vector subscripts.
---
 lib/evaluate/check-expression.cpp | 29 +++++++++++++++++++--------
 test/semantics/assign03.f90       | 33 +++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 8 deletions(-)

diff --git a/lib/evaluate/check-expression.cpp b/lib/evaluate/check-expression.cpp
index 34b9025abf25..b809211dbdb4 100644
--- a/lib/evaluate/check-expression.cpp
+++ b/lib/evaluate/check-expression.cpp
@@ -277,11 +277,18 @@ class IsSimplyContiguousHelper
   }
 
   Result operator()(const ArrayRef &x) const {
-    return (x.base().IsSymbol() || x.base().Rank() == 0) &&
-        CheckSubscripts(x.subscript()) && (*this)(x.base());
+    const auto &symbol{x.GetLastSymbol()};
+    if (!(*this)(symbol)) {
+      return false;
+    } else if (auto rank{CheckSubscripts(x.subscript())}) {
+      // a(:)%b(1,1) is not contiguous; a(1)%b(:,:) is
+      return *rank > 0 || x.Rank() == 0;
+    } else {
+      return false;
+    }
   }
   Result operator()(const CoarrayRef &x) const {
-    return CheckSubscripts(x.subscript());
+    return CheckSubscripts(x.subscript()).has_value();
   }
   Result operator()(const Component &x) const {
     return x.base().Rank() == 0 && (*this)(x.GetLastSymbol());
@@ -304,24 +311,30 @@ class IsSimplyContiguousHelper
   }
 
 private:
-  static bool CheckSubscripts(const std::vector<Subscript> &subscript) {
+  // If the subscripts can possibly be on a simply-contiguous array reference,
+  // return the rank.
+  static std::optional<int> CheckSubscripts(
+      const std::vector<Subscript> &subscript) {
     bool anyTriplet{false};
+    int rank{0};
     for (auto j{subscript.size()}; j-- > 0;) {
       if (const auto *triplet{std::get_if<Triplet>(&subscript[j].u)}) {
         if (!triplet->IsStrideOne()) {
-          return false;
+          return std::nullopt;
         } else if (anyTriplet) {
           if (triplet->lower() || triplet->upper()) {
-            return false;  // all triplets before the last one must be just ":"
+            // all triplets before the last one must be just ":"
+            return std::nullopt;
           }
         } else {
           anyTriplet = true;
         }
+        ++rank;
       } else if (anyTriplet || subscript[j].Rank() > 0) {
-        return false;
+        return std::nullopt;
       }
     }
-    return true;
+    return rank;
   }
 
   const IntrinsicProcTable &table_;
diff --git a/test/semantics/assign03.f90 b/test/semantics/assign03.f90
index 08070fd3ac55..7c4895368c52 100644
--- a/test/semantics/assign03.f90
+++ b/test/semantics/assign03.f90
@@ -142,12 +142,22 @@ subroutine s10
     end type
     type(t), target :: x
     type(t), target :: y(10,10)
+    integer :: v(10)
     p(1:16) => x%a
+    p(1:8) => x%a(:,3:4)
     p(1:1) => x%b  ! We treat scalars as simply contiguous
+    p(1:1) => x%a(1,1)
+    p(1:1) => y(1,1)%a(1,1)
+    p(1:1) => y(:,1)%a(1,1)  ! Rank 1 RHS
     !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
     p(1:4) => x%a(::2,::2)
     !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
     p(1:100) => y(:,:)%b
+    !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
+    p(1:100) => y(:,:)%a(1,1)
+    !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
+    !ERROR: An array section with a vector subscript may not be a pointer target
+    p(1:4) => x%a(:,v)
   end
 
   subroutine s11
@@ -155,8 +165,31 @@ subroutine s11
     complex, pointer :: p(:)
     real, pointer :: q(:)
     p(1:100) => x(:,:)
+    q(1:10) => x(1,:)%im
     !ERROR: Pointer bounds remapping target must have rank 1 or be simply contiguous
     q(1:100) => x(:,:)%re
   end
 
+  ! Check is_contiguous, which is usually the same as when pointer bounds
+  ! remapping is used. If it's not simply contiguous it's not constant so
+  ! an error is reported.
+  subroutine s12
+    integer, pointer :: p(:)
+    type :: t
+      integer :: a(4, 4)
+      integer :: b
+    end type
+    type(t), target :: x
+    type(t), target :: y(10,10)
+    integer :: v(10)
+    logical, parameter :: l1 = is_contiguous(x%a(:,:))
+    logical, parameter :: l2 = is_contiguous(y(1,1)%a(1,1))
+    !ERROR: Must be a constant value
+    logical, parameter :: l3 = is_contiguous(y(:,1)%a(1,1))
+    !ERROR: Must be a constant value
+    logical, parameter :: l4 = is_contiguous(x%a(:,v))
+    !ERROR: Must be a constant value
+    logical, parameter :: l5 = is_contiguous(y(v,1)%a(1,1))
+  end
+
 end

From 889f90913f280f285eb9960a0e0baadfd43a555f Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Wed, 15 Jan 2020 16:25:26 -0800
Subject: [PATCH 017/345] Explanation of how to implement a semantic check

This is the story of implementing semantic checks for passing DO
variables to functions with dummy arguments with INTENT(OUT) or
INTENT(INOUT).
---
 documentation/ImplementingASemanticCheck.md | 833 ++++++++++++++++++++
 1 file changed, 833 insertions(+)
 create mode 100644 documentation/ImplementingASemanticCheck.md

diff --git a/documentation/ImplementingASemanticCheck.md b/documentation/ImplementingASemanticCheck.md
new file mode 100644
index 000000000000..cc5ff7f62667
--- /dev/null
+++ b/documentation/ImplementingASemanticCheck.md
@@ -0,0 +1,833 @@
+<!--===- documentation/ImplementingASemanticCheck.md 
+  
+   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
+  
+-->
+# Introduction
+I recently added a semantic check to the f18 compiler front end.  This document
+describes my thought process and the resulting implementation.
+
+For more information about the compiler, start with the 
+[compiler overview](Overview.md).
+
+# Problem definition
+
+In the 2018 Fortran standard, section 11.1.7.4.3, paragraph 2, states that:
+
+```
+Except for the incrementation of the DO variable that occurs in step (3), the DO variable 
+shall neither be redefined nor become undefined while the DO construct is active.
+```
+One of the ways that DO variables might be redefined is if they are passed to
+functions with dummy arguments whose `INTENT` is `INTENT(OUT)` or
+`INTENT(INOUT)`.  I implemented this semantic check.  Specifically, I changed
+the compiler to emit an error message if an active DO variable was passed to a
+dummy argument of a FUNCTION with INTENT(OUT).  Similarly, I had the compiler
+emit a warning if an active DO variable was passed to a dummy argument with
+INTENT(INOUT).  Previously, I had implemented similar checks for SUBROUTINE
+calls.
+
+# Creating a test
+
+My first step was to create a test case to cause the problem.  I called it testfun.f90 and used it to check the behavior of other Fortran compilers.  Here's the initial version:
+
+```fortran
+  subroutine s()
+    Integer :: ivar, jvar
+
+    do ivar = 1, 10
+      jvar = intentOutFunc(ivar) ! Error since ivar is a DO variable
+    end do
+
+  contains
+    function intentOutFunc(dummyArg)
+      integer, intent(out) :: dummyArg
+      integer  :: intentOutFunc
+
+      dummyArg = 216
+    end function intentOutFunc
+  end subroutine s
+```
+
+I verified that other Fortran compilers produced an error message at the point
+of the call to `intentOutFunc()`:
+
+```fortran
+      jvar = intentOutFunc(ivar) ! Error since ivar is a DO variable
+```
+
+
+I also used this program to produce a parse tree for the program using the command:
+```bash
+  f18 -fdebug-dump-parse-tree -fparse-only testfun.f90
+```
+
+Here's the relevant fragment of the parse tree produced by the compiler:
+
+```
+| | ExecutionPartConstruct -> ExecutableConstruct -> DoConstruct
+| | | NonLabelDoStmt
+| | | | LoopControl -> LoopBounds
+| | | | | Scalar -> Name = 'ivar'
+| | | | | Scalar -> Expr = '1_4'
+| | | | | | LiteralConstant -> IntLiteralConstant = '1'
+| | | | | Scalar -> Expr = '10_4'
+| | | | | | LiteralConstant -> IntLiteralConstant = '10'
+| | | Block
+| | | | ExecutionPartConstruct -> ExecutableConstruct -> ActionStmt -> AssignmentStmt = 'jvar=intentoutfunc(ivar)'
+| | | | | Variable -> Designator -> DataRef -> Name = 'jvar'
+| | | | | Expr = 'intentoutfunc(ivar)'
+| | | | | | FunctionReference -> Call
+| | | | | | | ProcedureDesignator -> Name = 'intentoutfunc'
+| | | | | | | ActualArgSpec
+| | | | | | | | ActualArg -> Expr = 'ivar'
+| | | | | | | | | Designator -> DataRef -> Name = 'ivar'
+| | | EndDoStmt -> 
+```
+
+Note that this fragment of the tree only shows four `parser::Expr` nodes,
+but the full parse tree also contained a fifth `parser::Expr` node for the
+constant 216 in the statement:
+
+```fortran
+      dummyArg = 216
+```
+# Analysis and implementation planning
+
+I then considered what I needed to do.  I needed to detect situations where an
+active DO variable was passed to a dummy argument with `INTENT(OUT)` or
+`INTENT(INOUT)`.  Once I detected such a situation, I needed to produce a
+message that highlighted the erroneous source code.  
+
+## Deciding where to add the code to the compiler
+This new semantic check would depend on several types of information -- the
+parse tree, source code location information, symbols, and expressions.  Thus I
+needed to put my new code in a place in the compiler after the parse tree had
+been created, name resolution had already happened, and expression semantic
+checking had already taken place.
+
+Most semantic checks for statements are implemented by walking the parse tree
+and performing analysis on the nodes they visit.  My plan was to use this
+method.  The infrastructure for walking the parse tree for statement semantic
+checking is implemented in the files `lib/semantics/semantics.cpp`.
+Here's a fragment of the declaration of the framework's parse tree visitor from
+`lib/semantics/semantics.cpp`:
+
+```C++
+  // A parse tree visitor that calls Enter/Leave functions from each checker
+  // class C supplied as template parameters. Enter is called before the node's
+  // children are visited, Leave is called after. No two checkers may have the
+  // same Enter or Leave function. Each checker must be constructible from
+  // SemanticsContext and have BaseChecker as a virtual base class.
+  template<typename... C> class SemanticsVisitor : public virtual C... {
+  public:
+    using C::Enter...;
+    using C::Leave...;
+    using BaseChecker::Enter;
+    using BaseChecker::Leave;
+    SemanticsVisitor(SemanticsContext &context)
+      : C{context}..., context_{context} {}
+      ...
+
+```
+
+Since FUNCTION calls are a kind of expression, I was planning to base my
+implementation on the contents of `parser::Expr` nodes.  I would need to define
+either an `Enter()` or `Leave()` function whose parameter was a `parser::Expr`
+node.  Here's the declaration I put into `lib/semantics/check-do.h`:
+
+```C++
+  void Leave(const parser::Expr &);
+```
+The `Enter()` functions get called at the time the node is first visited --
+that is, before its children.  The `Leave()` function gets called after the
+children are visited.  For my check the visitation order didn't matter, so I
+arbitrarily chose to implement the `Leave()` function to visit the parse tree
+node.
+
+Since my semantic check was focused on DO CONCURRENT statements, I added it to
+the file `lib/semantics/check-do.cpp` where most of the semantic checking for
+DO statements already lived.
+
+## Taking advantage of prior work
+When implementing a similar check for SUBROUTINE calls, I created a utility
+functions in `lib/semantics/semantics.cpp` to emit messages if
+a symbol corresponding to an active DO variable was being potentially modified:
+
+```C++
+  void WarnDoVarRedefine(const parser::CharBlock &location, const Symbol &var);
+  void CheckDoVarRedefine(const parser::CharBlock &location, const Symbol &var);
+```
+
+The first function is intended for dummy arguments of `INTENT(INOUT)` and
+the second for `INTENT(OUT)`.
+
+Thus I needed three pieces of
+information -- 
+1. the source location of the erroneous text, 
+2. the `INTENT` of the associated dummy argument, and
+3. the relevant symbol passed as the actual argument.
+
+The first and third are needed since they're required to call the utility
+functions.  The second is needed to determine whether to call them.
+
+## Finding the source location
+The source code location information that I'd need for the error message must
+come from the parse tree.  I looked in the file
+`include/flang/parser/parse-tree.h` and determined that a `struct Expr`
+contained source location information since it had the field `CharBlock
+source`.  Thus, if I visited a `parser::Expr` node, I could get the source
+location information for the associated expression.
+
+## Determining the `INTENT`
+I knew that I could find the `INTENT` of the dummy argument associated with the
+actual argument from the function called `dummyIntent()` in the class
+`evaluate::ActualArgument` in the file `include/flang/evaluate/call.h`.  So
+if I could find an `evaluate::ActualArgument` in an expression, I could
+  determine the `INTENT` of the associated dummy argument.  I knew that it was
+  valid to call `dummyIntent()` because the data on which `dummyIntent()`
+  depends is established during semantic processing for expressions, and the
+  semantic processing for expressions happens before semantic checking for DO
+  constructs.
+
+In my prior work on checking the INTENT of arguments for SUBROUTINE calls,
+the parse tree held a node for the call (a `parser::CallStmt`) that contained
+an `evaluate::ProcedureRef` node.
+```C++
+  struct CallStmt {
+    WRAPPER_CLASS_BOILERPLATE(CallStmt, Call);
+    mutable std::unique_ptr<evaluate::ProcedureRef,
+        common::Deleter<evaluate::ProcedureRef>>
+        typedCall;  // filled by semantics
+  };
+```
+The `evaluate::ProcedureRef` contains a list of `evaluate::ActualArgument`
+nodes.  I could then find the INTENT of a dummy argument from the
+`evaluate::ActualArgument` node.
+
+For a FUNCTION call, though, there is no similar way to get from a parse tree
+node to an `evaluate::ProcedureRef` node.  But I knew that there was an
+existing framework used in DO construct semantic checking that traversed an
+`evaluate::Expr` node collecting `semantics::Symbol` nodes.  I guessed that I'd
+be able to use a similar framework to traverse an `evaluate::Expr`  node to
+find all of the `evaluate::ActualArgument` nodes.  
+
+Note that there are two distinct data types in the compiler called `Expr`.  One
+is in the `parser` namespace.  `parser::Expr` is defined in the file
+`include/flang/parser/parse-tree.h`.  It represents a parsed expression that
+maps directly to the source code and has fields that specify any operators in
+the expression, the operands, and the source position of the expression.
+
+The second `Expr` type is in the `evaluate` namespace.   The `evaluate`
+namespace contains many types associated with semantic checking of expressions.
+`evaluate::Expr` is defined in the file `include/flang/evaluate/expression.h`.
+It represents an expression after it has undergone semantic checking and
+contains information that is only available after semantic analysis.  This
+information includes the Fortran type of the expression, whether it's a
+reference to a function, whether it's an actual argument, etc.  After an
+expression has undergone semantic analysis, the field `typedExpr` in the
+`parser::Expr` node is filled in with a pointer to the analyzed expression in
+`evaluate::Expr`.
+
+All of the declarations associated with both FUNCTION and SUBROUTINE calls are
+in `include/flang/evaluate/call.h`.  An `evaluate::FunctionRef` inherits from
+an `evaluate::ProcedureRef` which contains the list of
+`evaluate::ActualArgument` nodes.  But the relationship between an
+`evaluate::FunctionRef` node and its associated arguments is not relevant.  I
+only needed to find the `evaluate::ActualArgument` nodes in an expression.
+They hold all of the information I needed.
+
+So my plan was to start with the `parser::Expr` node and extract its
+associated `evaluate::Expr` field.  I would then traverse the
+`evaluate::Expr` tree collecting all of the `evaluate::ActualArgument`
+nodes.  I would look at each of these nodes to determine the `INTENT` of
+the associated dummy argument.
+
+This combination of the traversal framework and `dummyIntent()` would give
+me the `INTENT` of all of the dummy arguments in a FUNCTION call.  Thus, I
+would have the second piece of information I needed.
+
+## Determining if the actual argument is a variable
+I also guessed that I could determine if the `evaluate::ActualArgument`
+consisted of a variable.  
+
+Once I had a symbol for the variable, I could call one of the functions:
+```C++
+  void WarnDoVarRedefine(const parser::CharBlock &, const Symbol &);
+  void CheckDoVarRedefine(const parser::CharBlock &, const Symbol &);
+```
+to emit the messages.
+
+If my plans worked out, this would give me the three pieces of information I
+needed -- the source location of the erroneous text, the `INTENT` of the dummy
+argument, and a symbol that I could use to determine whether the actual
+argument was an active DO variable.
+
+# Implementation
+
+## Adding a parse tree visitor
+I started my implementation by adding a visitor for `parser::Expr` nodes.
+Since this analysis is part of DO construct checking, I did this in
+`lib/semantics/check-do.cpp`.  I added a print statement to the visitor to
+verify that my new code was actually getting executed.  
+
+In `lib/semantics/check-do.h`, I added the declaration for the visitor:
+
+```C++
+  void Leave(const parser::Expr &);
+```
+
+In `lib/semantics/check-do.cpp`, I added an (almost empty) implementation:
+
+```C++
+  void DoChecker::Leave(const parser::Expr &) {
+    std::cout << "In Leave for parser::Expr\n";
+  }
+```
+
+I then built the compiler with these changes and ran it on my test program.
+This time, I made sure to invoke semantic checking.  Here's the command I used:
+```bash
+  f18 -fdebug-resolve-names -fdebug-dump-parse-tree -funparse-with-symbols testfun.f90
+```
+
+This produced the output:
+
+```
+  In Leave for parser::Expr
+  In Leave for parser::Expr
+  In Leave for parser::Expr
+  In Leave for parser::Expr
+  In Leave for parser::Expr
+```
+
+This made sense since the parse tree contained five `parser::Expr` nodes.
+So far, so good.  Note that a `parse::Expr` node has a field with the
+source position of the associated expression (`CharBlock source`).  So I
+now had one of the three pieces of information needed to detect and report
+errors.
+
+## Collecting the actual arguments
+To get the `INTENT` of the dummy arguments and the `semantics::Symbol` associated with the
+actual argument, I needed to find all of the actual arguments embedded in an
+expression that contained a FUNCTION call.  So my next step was to write the
+framework to walk the `evaluate::Expr` to gather all of the
+`evaluate::ActualArgument` nodes.  The code that I planned to model it on
+was the existing infrastructure that collected all of the `semantics::Symbol` nodes from an
+`evaluate::Expr`.  I found this implementation in
+`lib/evaluate/tools.cpp`:
+
+```C++
+  struct CollectSymbolsHelper
+    : public SetTraverse<CollectSymbolsHelper, semantics::SymbolSet> {
+    using Base = SetTraverse<CollectSymbolsHelper, semantics::SymbolSet>;
+    CollectSymbolsHelper() : Base{*this} {}
+    using Base::operator();
+    semantics::SymbolSet operator()(const Symbol &symbol) const {
+      return {symbol};
+    }
+  };
+  template<typename A> semantics::SymbolSet CollectSymbols(const A &x) {
+    return CollectSymbolsHelper{}(x);
+  }
+```
+
+Note that the `CollectSymbols()` function returns a `semantics::Symbolset`,
+which is declared in `include/flang/semantics/symbol.h`:
+
+```C++
+  using SymbolSet = std::set<SymbolRef>;
+```
+
+This infrastructure yields a collection based on `std::set<>`.  Using an
+`std::set<>` means that if the same object is inserted twice, the
+collection only gets one copy.  This was the behavior that I wanted.
+
+Here's a sample invocation of `CollectSymbols()` that I found:
+```C++
+    if (const auto *expr{GetExpr(parsedExpr)}) {
+      for (const Symbol &symbol : evaluate::CollectSymbols(*expr)) {
+```
+
+I noted that a `SymbolSet` did not actually contain an
+`std::set<Symbol>`.  This wasn't surprising since we don't want to put the
+full `semantics::Symbol` objects into the set.  Ideally, we would be able to create an
+`std::set<Symbol &>` (a set of C++ references to symbols).  But C++ doesn't
+support sets that contain references.  This limitation is part of the rationale
+for the f18 implementation of type `common::Reference`, which is defined in
+  `include/flang/common/reference.h`.
+
+`SymbolRef`, the specialization of the template `common::Reference` for
+`semantics::Symbol`, is declared in the file
+`include/flang/semantics/symbol.h`:
+
+```C++
+  using SymbolRef = common::Reference<const Symbol>;
+```
+
+So to implement something that would collect `evaluate::ActualArgument`
+nodes from an `evaluate::Expr`, I first defined the required types
+`ActualArgumentRef` and `ActualArgumentSet`.  Since these are being
+used exclusively for DO construct semantic checking (currently), I put their
+definitions into `lib/semantics/check-do.cpp`:
+
+
+```C++
+  namespace Fortran::evaluate {
+    using ActualArgumentRef = common::Reference<const ActualArgument>;
+  }
+
+
+  using ActualArgumentSet = std::set<evaluate::ActualArgumentRef>;
+```
+
+Since `ActualArgument` is in the namespace `evaluate`, I put the
+definition for `ActualArgumentRef` in that namespace, too.
+
+I then modeled the code to create an `ActualArgumentSet` after the code to
+collect a `SymbolSet` and put it into `lib/semantics/check-do.cpp`:
+
+
+```C++
+  struct CollectActualArgumentsHelper
+    : public evaluate::SetTraverse<CollectActualArgumentsHelper,
+          ActualArgumentSet> {
+    using Base = SetTraverse<CollectActualArgumentsHelper, ActualArgumentSet>;
+    CollectActualArgumentsHelper() : Base{*this} {}
+    using Base::operator();
+    ActualArgumentSet operator()(const evaluate::ActualArgument &arg) const {
+      return ActualArgumentSet{arg};
+    }
+  };
+
+  template<typename A> ActualArgumentSet CollectActualArguments(const A &x) {
+    return CollectActualArgumentsHelper{}(x);
+  }
+
+  template ActualArgumentSet CollectActualArguments(const SomeExpr &);
+```
+
+Unfortunately, when I tried to build this code, I got an error message saying
+`std::set` requires the `<` operator to be defined for its contents.
+To fix this, I added a definition for `<`.  I didn't care how `<` was
+defined, so I just used the address of the object:
+
+```C++
+  inline bool operator<(ActualArgumentRef x, ActualArgumentRef y) {
+    return &*x < &*y;
+  }
+```
+
+I was surprised when this did not make the error message saying that I needed
+the `<` operator go away.  Eventually, I figured out that the definition of
+the `<` operator needed to be in the `evaluate` namespace.  Once I put
+it there, everything compiled successfully.  Here's the code that worked:
+
+```C++
+  namespace Fortran::evaluate {
+  using ActualArgumentRef = common::Reference<const ActualArgument>;
+
+  inline bool operator<(ActualArgumentRef x, ActualArgumentRef y) {
+    return &*x < &*y;
+  }
+  }
+```
+
+I then modified my visitor for the parser::Expr to invoke my new collection
+framework.  To verify that it was actually doing something, I printed out the
+number of `evaluate::ActualArgument` nodes that it collected.  Note the
+call to `GetExpr()` in the invocation of `CollectActualArguments()`.  I
+modeled this on similar code that collected a `SymbolSet` described above:
+
+```C++
+  void DoChecker::Leave(const parser::Expr &parsedExpr) {
+    std::cout << "In Leave for parser::Expr\n";
+    ActualArgumentSet argSet{CollectActualArguments(GetExpr(parsedExpr))};
+    std::cout << "Number of arguments: " << argSet.size() << "\n";
+  }
+```
+
+I compiled and tested this code on my little test program.  Here's the output that I got:
+```
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 1
+  In Leave for parser::Expr
+  Number of arguments: 0
+```
+
+So most of the `parser::Expr`nodes contained no actual arguments, but the
+fourth expression in the parse tree walk contained a single argument.  This may
+seem wrong since the third `parser::Expr` node in the file contains the
+`FunctionReference` node along with the arguments that we're gathering.
+But since the tree walk function is being called upon leaving a
+`parser::Expr` node, the function visits the `parser::Expr` node
+associated with the `parser::ActualArg` node before it visits the
+`parser::Expr` node associated with the `parser::FunctionReference`
+node.
+
+So far, so good.
+
+## Finding the `INTENT` of the dummy argument
+I now wanted to find the `INTENT` of the dummy argument associated with the
+arguments in the set.  As mentioned earlier, the type
+`evaluate::ActualArgument` has a member function called `dummyIntent()`
+that gives this value.  So I augmented my code to print out the `INTENT`:
+
+```C++
+  void DoChecker::Leave(const parser::Expr &parsedExpr) {
+    std::cout << "In Leave for parser::Expr\n";
+    ActualArgumentSet argSet{CollectActualArguments(GetExpr(parsedExpr))};
+    std::cout << "Number of arguments: " << argSet.size() << "\n";
+    for (const evaluate::ActualArgumentRef &argRef : argSet) {
+      common::Intent intent{argRef->dummyIntent()};
+      switch (intent) {
+        case common::Intent::In: std::cout << "INTENT(IN)\n"; break;
+        case common::Intent::Out: std::cout << "INTENT(OUT)\n"; break;
+        case common::Intent::InOut: std::cout << "INTENT(INOUT)\n"; break;
+        default: std::cout << "default INTENT\n";
+      }
+    }
+  }
+```
+
+I then rebuilt my compiler and ran it on my test case.  This produced the following output:
+
+```
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 1
+  INTENT(OUT)
+  In Leave for parser::Expr
+  Number of arguments: 0
+```
+
+I then modified my test case to convince myself that I was getting the correct
+`INTENT` for `IN`, `INOUT`, and default cases.
+
+So far, so good.
+
+## Finding the symbols for arguments that are variables
+The third and last piece of information I needed was to determine if a variable
+was being passed as an actual argument.  In such cases, I wanted to get the
+symbol table node (`semantics::Symbol`) for the variable.  My starting point was the
+`evaluate::ActualArgument` node.  
+
+I was unsure of how to do this, so I browsed through existing code to look for
+how it treated `evaluate::ActualArgument` objects.  Since most of the code that deals with the `evaluate` namespace is in the lib/evaluate directory, I looked there.  I ran `grep` on all of the `.cpp` files looking for
+uses of `ActualArgument`.  One of the first hits I got was in `lib/evaluate/call.cpp` in the definition of `ActualArgument::GetType()`:
+
+```C++
+std::optional<DynamicType> ActualArgument::GetType() const {
+  if (const Expr<SomeType> *expr{UnwrapExpr()}) {
+    return expr->GetType();
+  } else if (std::holds_alternative<AssumedType>(u_)) {
+    return DynamicType::AssumedType();
+  } else {
+    return std::nullopt;
+  }
+}
+```
+
+I noted the call to `UnwrapExpr()` that yielded a value of
+`Expr<SomeType>`.  So I guessed that I could use this member function to
+get an `evaluate::Expr<SomeType>` on which I could perform further analysis.
+
+I also knew that the header file `include/flang/evaluate/tools.h` held many
+utility functions for dealing with `evaluate::Expr` objects.  I was hoping to
+find something that would determine if an `evaluate::Expr` was a variable.  So
+I searched for `IsVariable` and got a hit immediately.  
+```C++
+  template<typename A> bool IsVariable(const A &x) {
+    if (auto known{IsVariableHelper{}(x)}) {
+      return *known;
+    } else {
+      return false;
+    }
+  }
+```
+
+But I actually needed more than just the knowledge that an `evaluate::Expr` was
+a variable.  I needed the `semantics::Symbol` associated with the variable.  So
+I searched in `include/flang/evaluate/tools.h` for functions that returned a
+`semantics::Symbol`.  I found the following:
+
+```C++
+// If an expression is simply a whole symbol data designator,
+// extract and return that symbol, else null.
+template<typename A> const Symbol *UnwrapWholeSymbolDataRef(const A &x) {
+  if (auto dataRef{ExtractDataRef(x)}) {
+    if (const SymbolRef * p{std::get_if<SymbolRef>(&dataRef->u)}) {
+      return &p->get();
+    }
+  }
+  return nullptr;
+}
+```
+
+This was exactly what I wanted.  DO variables must be whole symbols.  So I
+could try to extract a whole `semantics::Symbol` from the `evaluate::Expr` in my
+`evaluate::ActualArgument`.  If this extraction resulted in a `semantics::Symbol`
+that wasn't a `nullptr`, I could then conclude if it was a variable that I
+could pass to existing functions that would determine if it was an active DO
+variable.
+
+I then modified the compiler to perform the analysis that I'd guessed would
+work:
+
+```C++
+  void DoChecker::Leave(const parser::Expr &parsedExpr) {
+    std::cout << "In Leave for parser::Expr\n";
+    ActualArgumentSet argSet{CollectActualArguments(GetExpr(parsedExpr))};
+    std::cout << "Number of arguments: " << argSet.size() << "\n";
+    for (const evaluate::ActualArgumentRef &argRef : argSet) {
+      if (const SomeExpr * argExpr{argRef->UnwrapExpr()}) {
+        std::cout << "Got an unwrapped Expr\n";
+        if (const Symbol * var{evaluate::UnwrapWholeSymbolDataRef(*argExpr)}) {
+          std::cout << "Found a whole variable: " << *var << "\n";
+        }
+      }
+      common::Intent intent{argRef->dummyIntent()};
+      switch (intent) {
+        case common::Intent::In: std::cout << "INTENT(IN)\n"; break;
+        case common::Intent::Out: std::cout << "INTENT(OUT)\n"; break;
+        case common::Intent::InOut: std::cout << "INTENT(INOUT)\n"; break;
+        default: std::cout << "default INTENT\n";
+      }
+    }
+  }
+```  
+
+Note the line that prints out the symbol table entry for the variable:
+
+```C++
+          std::cout << "Found a whole variable: " << *var << "\n";
+```  
+
+The compiler defines the "<<" operator for `semantics::Symbol`, which is handy
+for analyzing the compiler's behavior.
+
+Here's the result of running the modified compiler on my Fortran test case:
+
+```
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 1
+  Got an unwrapped Expr
+  Found a whole variable: ivar: ObjectEntity type: INTEGER(4)
+  INTENT(OUT)
+  In Leave for parser::Expr
+  Number of arguments: 0
+```
+
+Sweet.
+
+## Emitting the messages
+At this point, using the source location information from the original
+`parser::Expr`, I had enough information to plug into the exiting
+interfaces for emitting messages for active DO variables.  I modified the
+compiler code accordingly:
+
+
+```C++
+  void DoChecker::Leave(const parser::Expr &parsedExpr) {
+    std::cout << "In Leave for parser::Expr\n";
+    ActualArgumentSet argSet{CollectActualArguments(GetExpr(parsedExpr))};
+    std::cout << "Number of arguments: " << argSet.size() << "\n";
+    for (const evaluate::ActualArgumentRef &argRef : argSet) {
+      if (const SomeExpr * argExpr{argRef->UnwrapExpr()}) {
+        std::cout << "Got an unwrapped Expr\n";
+        if (const Symbol * var{evaluate::UnwrapWholeSymbolDataRef(*argExpr)}) {
+          std::cout << "Found a whole variable: " << *var << "\n";
+          common::Intent intent{argRef->dummyIntent()};
+          switch (intent) {
+            case common::Intent::In: std::cout << "INTENT(IN)\n"; break;
+            case common::Intent::Out: 
+              std::cout << "INTENT(OUT)\n"; 
+              context_.CheckDoVarRedefine(parsedExpr.source, *var);
+              break;
+            case common::Intent::InOut: 
+              std::cout << "INTENT(INOUT)\n"; 
+              context_.WarnDoVarRedefine(parsedExpr.source, *var);
+              break;
+            default: std::cout << "default INTENT\n";
+          }
+        }
+      }
+    }
+  }
+```  
+
+I then ran this code on my test case, and miraculously, got the following
+output:
+
+```
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 0
+  In Leave for parser::Expr
+  Number of arguments: 1
+  Got an unwrapped Expr
+  Found a whole variable: ivar: ObjectEntity type: INTEGER(4)
+  INTENT(OUT)
+  In Leave for parser::Expr
+  Number of arguments: 0
+  testfun.f90:6:12: error: Cannot redefine DO variable 'ivar'
+        jvar = intentOutFunc(ivar)
+               ^^^^^^^^^^^^^^^^^^^
+  testfun.f90:5:6: Enclosing DO construct
+      do ivar = 1, 10
+         ^^^^
+```
+
+Even sweeter.
+
+# Improving the test case
+At this point, my implementation seemed to be working.  But I was concerned
+about the limitations of my test case.  So I augmented it to include arguments
+other than `INTENT(OUT)` and more complex expressions.  Luckily, my
+augmented test did not reveal any new problems.   
+
+Here's the test I ended up with:
+
+```Fortran
+  subroutine s()
+
+    Integer :: ivar, jvar
+
+    ! This one is OK
+    do ivar = 1, 10
+      jvar = intentInFunc(ivar)
+    end do
+
+    ! Error for passing a DO variable to an INTENT(OUT) dummy
+    do ivar = 1, 10
+      jvar = intentOutFunc(ivar)
+    end do
+
+    ! Error for passing a DO variable to an INTENT(OUT) dummy, more complex 
+    ! expression
+    do ivar = 1, 10
+      jvar = 83 + intentInFunc(intentOutFunc(ivar))
+    end do
+
+    ! Warning for passing a DO variable to an INTENT(INOUT) dummy
+    do ivar = 1, 10
+      jvar = intentInOutFunc(ivar)
+    end do
+
+  contains
+    function intentInFunc(dummyArg)
+      integer, intent(in) :: dummyArg
+      integer  :: intentInFunc
+
+      intentInFunc = 343
+    end function intentInFunc
+
+    function intentOutFunc(dummyArg)
+      integer, intent(out) :: dummyArg
+      integer  :: intentOutFunc
+
+      dummyArg = 216
+      intentOutFunc = 343
+    end function intentOutFunc
+
+    function intentInOutFunc(dummyArg)
+      integer, intent(inout) :: dummyArg
+      integer  :: intentInOutFunc
+
+      dummyArg = 216
+      intentInOutFunc = 343
+    end function intentInOutFunc
+
+  end subroutine s
+```
+
+# Submitting the pull request
+At this point, my implementation seemed functionally complete, so I stripped out all of the debug statements, ran `clang-format` on it and reviewed it
+to make sure that the names were clear.  Here's what I ended up with:
+
+```C++
+  void DoChecker::Leave(const parser::Expr &parsedExpr) {
+    ActualArgumentSet argSet{CollectActualArguments(GetExpr(parsedExpr))};
+    for (const evaluate::ActualArgumentRef &argRef : argSet) {
+      if (const SomeExpr * argExpr{argRef->UnwrapExpr()}) {
+        if (const Symbol * var{evaluate::UnwrapWholeSymbolDataRef(*argExpr)}) {
+          common::Intent intent{argRef->dummyIntent()};
+          switch (intent) {
+            case common::Intent::Out: 
+              context_.CheckDoVarRedefine(parsedExpr.source, *var);
+              break;
+            case common::Intent::InOut: 
+              context_.WarnDoVarRedefine(parsedExpr.source, *var);
+              break;
+            default:; // INTENT(IN) or default intent
+          }
+        }
+      }
+    }
+  }
+```
+
+I then created a pull request to get review comments.  
+
+# Responding to pull request comments
+I got feedback suggesting that I use an `if` statement rather than a
+`case` statement.  Another comment reminded me that I should look at the
+code I'd previously writted to do a similar check for SUBROUTINE calls to see
+if there was an opportunity to share code.  This examination resulted in
+  converting my existing code to the following pair of functions:
+
+
+```C++
+  static void CheckIfArgIsDoVar(const evaluate::ActualArgument &arg,
+      const parser::CharBlock location, SemanticsContext &context) {
+    common::Intent intent{arg.dummyIntent()};
+    if (intent == common::Intent::Out || intent == common::Intent::InOut) {
+      if (const SomeExpr * argExpr{arg.UnwrapExpr()}) {
+        if (const Symbol * var{evaluate::UnwrapWholeSymbolDataRef(*argExpr)}) {
+          if (intent == common::Intent::Out) {
+            context.CheckDoVarRedefine(location, *var);
+          } else {
+            context.WarnDoVarRedefine(location, *var);  // INTENT(INOUT)
+          }
+        }
+      }
+    }
+  }
+
+  void DoChecker::Leave(const parser::Expr &parsedExpr) {
+    if (const SomeExpr * expr{GetExpr(parsedExpr)}) {
+      ActualArgumentSet argSet{CollectActualArguments(*expr)};
+      for (const evaluate::ActualArgumentRef &argRef : argSet) {
+        CheckIfArgIsDoVar(*argRef, parsedExpr.source, context_);
+      }
+    }
+  }
+```
+
+The function `CheckIfArgIsDoVar()` was shared with the checks for DO
+variables being passed to SUBROUTINE calls.
+
+At this point, my pull request was approved, and I merged it and deleted the
+associated branch.

From 4542cb57082eaf578799c76482d4b706ae5da077 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 4 Feb 2020 10:30:16 -0800
Subject: [PATCH 018/345] Fix template step limit issue with clang

While working on PR 959, I instanciated a `common::TupleToVariant`
with ~50+ types inside the tuple. Clang would then crash after
1hr compilation with message:
"constexpr evaluation hit maximum step limit; possible infinite loop"
After investigating, it turned out clang handles very badly the way
`common::AreTypesDistinctHelper` was implemented.
Its "number of steps" was exponential with the number of types.
This fix makes this number quadratic which solves the issue.
---
 include/flang/common/template.h | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/include/flang/common/template.h b/include/flang/common/template.h
index c8a18e704fb4..460f1a8bdaed 100644
--- a/include/flang/common/template.h
+++ b/include/flang/common/template.h
@@ -153,15 +153,12 @@ template<typename... Ts> struct VariantToTupleHelper<std::variant<Ts...>> {
 template<typename VARIANT>
 using VariantToTuple = typename VariantToTupleHelper<VARIANT>::type;
 
-template<typename A, typename B, typename... REST>
-struct AreTypesDistinctHelper {
+template<typename A, typename... REST> struct AreTypesDistinctHelper {
   static constexpr bool value() {
-    if constexpr (std::is_same_v<A, B>) {
-      return false;
-    }
     if constexpr (sizeof...(REST) > 0) {
-      return AreTypesDistinctHelper<A, REST...>::value() &&
-          AreTypesDistinctHelper<B, REST...>::value();
+      // extra () for clang-format
+      return ((... && !std::is_same_v<A, REST>)) &&
+          AreTypesDistinctHelper<REST...>::value();
     }
     return true;
   }

From c3f1774f8eee903928b7e46636edfb03425eabc0 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Thu, 23 Jan 2020 16:59:27 -0800
Subject: [PATCH 019/345] Initial buffer framing code

Address review comments

Integer output data editing (I,B,O,Z)

Full integer output formatting

Stub out some work in progress

Progress on E output data editing

E, D, EN, and ES output editing done

Fw.d output editing

Real G output editing

G output editing for reals

Make environment a distinct module

CHARACTER and LOGICAL output editing

Minimal decimal representations for E0, F0, G0 editing

Move real output editing code into its own file

Fix/dodge some GCC build problems

Prep work for external I/O statement state

External HELLO, WORLD

Fix build problem with GCC

Add virtual destructors where needed

Add new test
---
 lib/decimal/binary-to-decimal.cpp |  14 +-
 runtime/CMakeLists.txt            |   3 +
 runtime/buffer.cpp                |  23 ++
 runtime/buffer.h                  | 178 ++++++++++++
 runtime/environment.cpp           |  37 +++
 runtime/environment.h             |  26 ++
 runtime/file.cpp                  |  55 +++-
 runtime/file.h                    |  39 ++-
 runtime/format.cpp                |  59 ++--
 runtime/format.h                  |  28 +-
 runtime/io-api.cpp                |  63 ++++-
 runtime/io-stmt.cpp               | 192 ++++++++++---
 runtime/io-stmt.h                 |  87 ++++--
 runtime/main.cpp                  |  29 +-
 runtime/main.h                    |  17 +-
 runtime/memory.cpp                |   5 -
 runtime/memory.h                  |  31 ++-
 runtime/numeric-output.h          | 449 ++++++++++++++++++++++++++++++
 runtime/stop.cpp                  |   8 +
 runtime/stop.h                    |   1 +
 runtime/tools.h                   |  11 +
 runtime/unit.cpp                  | 137 +++++++++
 runtime/unit.h                    | 114 ++++++++
 test/runtime/CMakeLists.txt       |   8 +
 test/runtime/external-hello.cpp   |  15 +
 test/runtime/format.cpp           |  40 ++-
 test/runtime/hello.cpp            | 332 +++++++++++++++++++++-
 27 files changed, 1797 insertions(+), 204 deletions(-)
 create mode 100644 runtime/buffer.cpp
 create mode 100644 runtime/buffer.h
 create mode 100644 runtime/environment.cpp
 create mode 100644 runtime/environment.h
 create mode 100644 runtime/numeric-output.h
 create mode 100644 runtime/unit.cpp
 create mode 100644 runtime/unit.h
 create mode 100644 test/runtime/external-hello.cpp

diff --git a/lib/decimal/binary-to-decimal.cpp b/lib/decimal/binary-to-decimal.cpp
index fbc043eed374..ba061856b089 100644
--- a/lib/decimal/binary-to-decimal.cpp
+++ b/lib/decimal/binary-to-decimal.cpp
@@ -108,7 +108,7 @@ template<int PREC, int LOG10RADIX>
 ConversionToDecimalResult
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
     std::size_t n, enum DecimalConversionFlags flags, int maxDigits) const {
-  if (n < static_cast<std::size_t>(3 + digits_ * LOG10RADIX) || maxDigits < 1) {
+  if (n < static_cast<std::size_t>(3 + digits_ * LOG10RADIX)) {
     return {nullptr, 0, 0, Overflow};
   }
   char *start{buffer};
@@ -160,18 +160,21 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
   while (p[-1] == '0') {
     --p;
   }
-  if (p <= start + maxDigits) {
+  char *end{start + maxDigits};
+  if (maxDigits == 0) {
+    p = end;
+  }
+  if (p <= end) {
     *p = '\0';
     return {buffer, static_cast<std::size_t>(p - buffer), expo, Exact};
   } else {
     // Apply a digit limit, possibly with rounding.
-    char *end{start + maxDigits};
     bool incr{false};
     switch (rounding_) {
     case RoundNearest:
     case RoundDefault:
-      incr =
-          *end > '5' || (*end == '5' && (p > end || ((p[-1] - '0') & 1) != 0));
+      incr = *end > '5' ||
+          (*end == '5' && (p > end + 1 || ((end[-1] - '0') & 1) != 0));
       break;
     case RoundUp: incr = !isNegative_; break;
     case RoundDown: incr = isNegative_; break;
@@ -190,6 +193,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
         ++p[-1];
       }
     }
+
     *p = '\0';
     return {buffer, static_cast<std::size_t>(p - buffer), expo, Inexact};
   }
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index a9a71b9f17ce..4c1ecf0be736 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -8,8 +8,10 @@
 
 add_library(FortranRuntime
   ISO_Fortran_binding.cpp
+  buffer.cpp
   derived-type.cpp
   descriptor.cpp
+  environment.cpp
   file.cpp
   format.cpp
   io-api.cpp
@@ -22,6 +24,7 @@ add_library(FortranRuntime
   tools.cpp
   transformational.cpp
   type-code.cpp
+  unit.cpp
 )
 
 target_link_libraries(FortranRuntime
diff --git a/runtime/buffer.cpp b/runtime/buffer.cpp
new file mode 100644
index 000000000000..607bbfcc9ec2
--- /dev/null
+++ b/runtime/buffer.cpp
@@ -0,0 +1,23 @@
+//===-- runtime/buffer.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 "buffer.h"
+#include <algorithm>
+
+namespace Fortran::runtime::io {
+
+// Here's a very old trick for shifting circular buffer data cheaply
+// without a need for a temporary array.
+void LeftShiftBufferCircularly(
+    char *buffer, std::size_t bytes, std::size_t shift) {
+  // Assume that we start with "efgabcd" and the left shift is 3.
+  std::reverse(buffer, buffer + shift);  // "gfeabcd"
+  std::reverse(buffer, buffer + bytes);  // "dcbaefg"
+  std::reverse(buffer, buffer + bytes - shift);  // "abcdefg"
+}
+}
diff --git a/runtime/buffer.h b/runtime/buffer.h
new file mode 100644
index 000000000000..a7b31848df8d
--- /dev/null
+++ b/runtime/buffer.h
@@ -0,0 +1,178 @@
+//===-- runtime/buffer.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
+//
+//===----------------------------------------------------------------------===//
+
+// External file buffering
+
+#ifndef FORTRAN_RUNTIME_BUFFER_H_
+#define FORTRAN_RUNTIME_BUFFER_H_
+
+#include "io-error.h"
+#include "memory.h"
+#include <algorithm>
+#include <cinttypes>
+#include <cstring>
+
+namespace Fortran::runtime::io {
+
+void LeftShiftBufferCircularly(char *, std::size_t bytes, std::size_t shift);
+
+// Maintains a view of a contiguous region of a file in a memory buffer.
+// The valid data in the buffer may be circular, but any active frame
+// will also be contiguous in memory.  The requirement stems from the need to
+// preserve read data that may be reused by means of Tn/TLn edit descriptors
+// without needing to position the file (which may not always be possible,
+// e.g. a socket) and a general desire to reduce system call counts.
+template<typename STORE> class FileFrame {
+public:
+  using FileOffset = std::int64_t;
+
+  ~FileFrame() { FreeMemoryAndNullify(buffer_); }
+
+  // The valid data in the buffer begins at buffer_[start_] and proceeds
+  // with possible wrap-around for length_ bytes.  The current frame
+  // is offset by frame_ bytes into that region and is guaranteed to
+  // be contiguous for at least as many bytes as were requested.
+
+  FileOffset FrameAt() const { return fileOffset_ + frame_; }
+  char *Frame() const { return buffer_ + start_ + frame_; }
+  std::size_t FrameLength() const {
+    return std::min(
+        static_cast<std::size_t>(length_ - frame_), size_ - (start_ + frame_));
+  }
+
+  // Returns a short frame at a non-fatal EOF.  Can return a long frame as well.
+  std::size_t ReadFrame(
+      FileOffset at, std::size_t bytes, IoErrorHandler &handler) {
+    Flush(handler);
+    Reallocate(bytes, handler);
+    if (at < fileOffset_ || at > fileOffset_ + length_) {
+      Reset(at);
+    }
+    frame_ = static_cast<std::size_t>(at - fileOffset_);
+    if (start_ + frame_ + bytes > size_) {
+      DiscardLeadingBytes(frame_, handler);
+      if (start_ + bytes > size_) {
+        // Frame would wrap around; shift current data (if any) to force
+        // contiguity.
+        RUNTIME_CHECK(handler, length_ < size_);
+        if (start_ + length_ <= size_) {
+          // [......abcde..] -> [abcde........]
+          std::memmove(buffer_, buffer_ + start_, length_);
+        } else {
+          // [cde........ab] -> [abcde........]
+          auto n{start_ + length_ - size_};  // 3 for cde
+          auto gap{size_ - length_};  // 13 - 5 = 8
+          RUNTIME_CHECK(handler, length_ >= n);
+          std::memmove(buffer_ + n, buffer_ + start_, length_ - n);  // cdeab
+          LeftShiftBufferCircularly(buffer_, length_, n);  // abcde
+        }
+        start_ = 0;
+      }
+    }
+    while (FrameLength() < bytes) {
+      auto next{start_ + length_};
+      RUNTIME_CHECK(handler, next < size_);
+      auto minBytes{bytes - FrameLength()};
+      auto maxBytes{size_ - next};
+      auto got{Store().Read(
+          fileOffset_ + length_, buffer_ + next, minBytes, maxBytes, handler)};
+      length_ += got;
+      RUNTIME_CHECK(handler, length_ < size_);
+      if (got < minBytes) {
+        break;  // error or EOF & program can handle it
+      }
+    }
+    return FrameLength();
+  }
+
+  void WriteFrame(FileOffset at, std::size_t bytes, IoErrorHandler &handler) {
+    if (!dirty_ || at < fileOffset_ || at > fileOffset_ + length_ ||
+        start_ + (at - fileOffset_) + bytes > size_) {
+      Flush(handler);
+      fileOffset_ = at;
+      Reallocate(bytes, handler);
+    }
+    dirty_ = true;
+    frame_ = at - fileOffset_;
+    length_ = std::max(length_, static_cast<std::int64_t>(frame_ + bytes));
+  }
+
+  void Flush(IoErrorHandler &handler) {
+    if (dirty_) {
+      while (length_ > 0) {
+        std::size_t chunk{std::min(static_cast<std::size_t>(length_),
+            static_cast<std::size_t>(size_ - start_))};
+        std::size_t put{
+            Store().Write(fileOffset_, buffer_ + start_, chunk, handler)};
+        length_ -= put;
+        start_ += put;
+        fileOffset_ += put;
+        if (put < chunk) {
+          break;
+        }
+      }
+      Reset(fileOffset_);
+    }
+  }
+
+private:
+  STORE &Store() { return static_cast<STORE &>(*this); }
+
+  void Reallocate(std::size_t bytes, Terminator &terminator) {
+    if (bytes > size_) {
+      char *old{buffer_};
+      auto oldSize{size_};
+      size_ = std::max(bytes, minBuffer);
+      buffer_ =
+          reinterpret_cast<char *>(AllocateMemoryOrCrash(terminator, size_));
+      auto chunk{
+          std::min(length_, static_cast<std::int64_t>(oldSize - start_))};
+      std::memcpy(buffer_, old + start_, chunk);
+      start_ = 0;
+      std::memcpy(buffer_ + chunk, old, length_ - chunk);
+      FreeMemory(old);
+    }
+  }
+
+  void Reset(FileOffset at) {
+    start_ = length_ = frame_ = 0;
+    fileOffset_ = at;
+    dirty_ = false;
+  }
+
+  void DiscardLeadingBytes(std::size_t n, Terminator &terminator) {
+    RUNTIME_CHECK(terminator, length_ >= n);
+    length_ -= n;
+    if (length_ == 0) {
+      start_ = 0;
+    } else {
+      start_ += n;
+      if (start_ >= size_) {
+        start_ -= size_;
+      }
+    }
+    if (frame_ >= n) {
+      frame_ -= n;
+    } else {
+      frame_ = 0;
+    }
+    fileOffset_ += n;
+  }
+
+  static constexpr std::size_t minBuffer{64 << 10};
+
+  char *buffer_{nullptr};
+  std::size_t size_{0};  // current allocated buffer size
+  FileOffset fileOffset_{0};  // file offset corresponding to buffer valid data
+  std::int64_t start_{0};  // buffer_[] offset of valid data
+  std::int64_t length_{0};  // valid data length (can wrap)
+  std::int64_t frame_{0};  // offset of current frame in valid data
+  bool dirty_{false};
+};
+}
+#endif  // FORTRAN_RUNTIME_BUFFER_H_
diff --git a/runtime/environment.cpp b/runtime/environment.cpp
new file mode 100644
index 000000000000..5ce55ab47459
--- /dev/null
+++ b/runtime/environment.cpp
@@ -0,0 +1,37 @@
+//===-- runtime/environment.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 "environment.h"
+#include <cstdlib>
+#include <limits>
+
+namespace Fortran::runtime {
+ExecutionEnvironment executionEnvironment;
+
+void ExecutionEnvironment::Configure(
+    int ac, const char *av[], const char *env[]) {
+  argc = ac;
+  argv = av;
+  envp = env;
+  listDirectedOutputLineLengthLimit = 79;  // PGI default
+  defaultOutputRoundingMode = common::RoundingMode::TiesToEven;  // RP=RN
+
+  if (auto *x{std::getenv("FORT_FMT_RECL")}) {
+    char *end;
+    auto n{std::strtol(x, &end, 10)};
+    if (n > 0 && n < std::numeric_limits<int>::max() && *end == '\0') {
+      listDirectedOutputLineLengthLimit = n;
+    } else {
+      std::fprintf(
+          stderr, "Fortran runtime: FORT_FMT_RECL=%s is invalid; ignored\n", x);
+    }
+  }
+
+  // TODO: Set RP/ROUND='PROCESSOR_DEFINED' from environment
+}
+}
diff --git a/runtime/environment.h b/runtime/environment.h
new file mode 100644
index 000000000000..25a98959b741
--- /dev/null
+++ b/runtime/environment.h
@@ -0,0 +1,26 @@
+//===-- runtime/environment.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_RUNTIME_ENVIRONMENT_H_
+#define FORTRAN_RUNTIME_ENVIRONMENT_H_
+
+#include "flang/common/Fortran.h"
+
+namespace Fortran::runtime {
+struct ExecutionEnvironment {
+  void Configure(int argc, const char *argv[], const char *envp[]);
+
+  int argc;
+  const char **argv;
+  const char **envp;
+  int listDirectedOutputLineLengthLimit;
+  common::RoundingMode defaultOutputRoundingMode;
+};
+extern ExecutionEnvironment executionEnvironment;
+}
+#endif  // FORTRAN_RUNTIME_ENVIRONMENT_H_
diff --git a/runtime/file.cpp b/runtime/file.cpp
index 3936bcdfcfa6..f9c18c741734 100644
--- a/runtime/file.cpp
+++ b/runtime/file.cpp
@@ -22,13 +22,25 @@ void OpenFile::Open(const char *path, std::size_t pathLength,
     const char *status, std::size_t statusLength, const char *action,
     std::size_t actionLength, IoErrorHandler &handler) {
   CriticalSection criticalSection{lock_};
-  RUNTIME_CHECK(handler, fd_ < 0);
+  RUNTIME_CHECK(handler, fd_ < 0);  // TODO handle re-openings
   int flags{0};
   static const char *actions[]{"READ", "WRITE", "READWRITE", nullptr};
   switch (IdentifyValue(action, actionLength, actions)) {
-  case 0: flags = O_RDONLY; break;
-  case 1: flags = O_WRONLY; break;
-  case 2: flags = O_RDWR; break;
+  case 0:
+    flags = O_RDONLY;
+    mayRead_ = true;
+    mayWrite_ = false;
+    break;
+  case 1:
+    flags = O_WRONLY;
+    mayRead_ = false;
+    mayWrite_ = true;
+    break;
+  case 2:
+    mayRead_ = true;
+    mayWrite_ = true;
+    flags = O_RDWR;
+    break;
   default:
     handler.Crash(
         "Invalid ACTION='%.*s'", action, static_cast<int>(actionLength));
@@ -82,6 +94,7 @@ void OpenFile::Open(const char *path, std::size_t pathLength,
     }
   }
   path_ = SaveDefaultCharacter(path, pathLength, handler);
+  pathLength_ = pathLength;
   if (!path_.get()) {
     handler.Crash(
         "FILE= is required unless STATUS='OLD' and unit is connected");
@@ -94,6 +107,17 @@ void OpenFile::Open(const char *path, std::size_t pathLength,
   knownSize_.reset();
 }
 
+void OpenFile::Predefine(int fd) {
+  CriticalSection criticalSection{lock_};
+  fd_ = fd;
+  path_.reset();
+  pathLength_ = 0;
+  position_ = 0;
+  knownSize_.reset();
+  nextId_ = 0;
+  pending_.reset();
+}
+
 void OpenFile::Close(
     const char *status, std::size_t statusLength, IoErrorHandler &handler) {
   CriticalSection criticalSection{lock_};
@@ -123,7 +147,7 @@ void OpenFile::Close(
   }
 }
 
-std::size_t OpenFile::Read(Offset at, char *buffer, std::size_t minBytes,
+std::size_t OpenFile::Read(FileOffset at, char *buffer, std::size_t minBytes,
     std::size_t maxBytes, IoErrorHandler &handler) {
   if (maxBytes == 0) {
     return 0;
@@ -157,8 +181,8 @@ std::size_t OpenFile::Read(Offset at, char *buffer, std::size_t minBytes,
   return got;
 }
 
-std::size_t OpenFile::Write(
-    Offset at, const char *buffer, std::size_t bytes, IoErrorHandler &handler) {
+std::size_t OpenFile::Write(FileOffset at, const char *buffer,
+    std::size_t bytes, IoErrorHandler &handler) {
   if (bytes == 0) {
     return 0;
   }
@@ -187,7 +211,7 @@ std::size_t OpenFile::Write(
   return put;
 }
 
-void OpenFile::Truncate(Offset at, IoErrorHandler &handler) {
+void OpenFile::Truncate(FileOffset at, IoErrorHandler &handler) {
   CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   if (!knownSize_ || *knownSize_ != at) {
@@ -202,7 +226,7 @@ void OpenFile::Truncate(Offset at, IoErrorHandler &handler) {
 // to be claimed by a later WAIT statement.
 // TODO: True asynchronicity
 int OpenFile::ReadAsynchronously(
-    Offset at, char *buffer, std::size_t bytes, IoErrorHandler &handler) {
+    FileOffset at, char *buffer, std::size_t bytes, IoErrorHandler &handler) {
   CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   int iostat{0};
@@ -210,7 +234,7 @@ int OpenFile::ReadAsynchronously(
 #if _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
     auto chunk{::pread(fd_, buffer + got, bytes - got, at)};
 #else
-    auto chunk{RawSeek(at) ? ::read(fd_, buffer + got, bytes - got) : -1};
+    auto chunk{Seek(at, handler) ? ::read(fd_, buffer + got, bytes - got) : -1};
 #endif
     if (chunk == 0) {
       iostat = FORTRAN_RUNTIME_IOSTAT_END;
@@ -231,8 +255,8 @@ int OpenFile::ReadAsynchronously(
 }
 
 // TODO: True asynchronicity
-int OpenFile::WriteAsynchronously(
-    Offset at, const char *buffer, std::size_t bytes, IoErrorHandler &handler) {
+int OpenFile::WriteAsynchronously(FileOffset at, const char *buffer,
+    std::size_t bytes, IoErrorHandler &handler) {
   CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   int iostat{0};
@@ -240,7 +264,8 @@ int OpenFile::WriteAsynchronously(
 #if _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
     auto chunk{::pwrite(fd_, buffer + put, bytes - put, at)};
 #else
-    auto chunk{RawSeek(at) ? ::write(fd_, buffer + put, bytes - put) : -1};
+    auto chunk{
+        Seek(at, handler) ? ::write(fd_, buffer + put, bytes - put) : -1};
 #endif
     if (chunk >= 0) {
       at += chunk;
@@ -298,7 +323,7 @@ void OpenFile::CheckOpen(Terminator &terminator) {
   RUNTIME_CHECK(terminator, fd_ >= 0);
 }
 
-bool OpenFile::Seek(Offset at, IoErrorHandler &handler) {
+bool OpenFile::Seek(FileOffset at, IoErrorHandler &handler) {
   if (at == position_) {
     return true;
   } else if (RawSeek(at)) {
@@ -310,7 +335,7 @@ bool OpenFile::Seek(Offset at, IoErrorHandler &handler) {
   }
 }
 
-bool OpenFile::RawSeek(Offset at) {
+bool OpenFile::RawSeek(FileOffset at) {
 #ifdef _LARGEFILE64_SOURCE
   return ::lseek64(fd_, at, SEEK_SET) == 0;
 #else
diff --git a/runtime/file.h b/runtime/file.h
index 1c0a10d8f754..d5e521756653 100644
--- a/runtime/file.h
+++ b/runtime/file.h
@@ -14,7 +14,6 @@
 #include "io-error.h"
 #include "lock.h"
 #include "memory.h"
-#include "terminator.h"
 #include <cinttypes>
 #include <optional>
 
@@ -22,33 +21,43 @@ namespace Fortran::runtime::io {
 
 class OpenFile {
 public:
-  using Offset = std::uint64_t;
+  using FileOffset = std::int64_t;
 
-  Offset position() const { return position_; }
+  FileOffset position() const { return position_; }
 
   void Open(const char *path, std::size_t pathLength, const char *status,
       std::size_t statusLength, const char *action, std::size_t actionLength,
       IoErrorHandler &);
+  void Predefine(int fd);
   void Close(const char *action, std::size_t actionLength, IoErrorHandler &);
 
+  int fd() const { return fd_; }
+  bool mayRead() const { return mayRead_; }
+  bool mayWrite() const { return mayWrite_; }
+  bool mayPosition() const { return mayPosition_; }
+  void set_mayRead(bool yes) { mayRead_ = yes; }
+  void set_mayWrite(bool yes) { mayWrite_ = yes; }
+  void set_mayPosition(bool yes) { mayPosition_ = yes; }
+
   // Reads data into memory; returns amount acquired.  Synchronous.
   // Partial reads (less than minBytes) signify end-of-file.  If the
   // buffer is larger than minBytes, and extra returned data will be
   // preserved for future consumption, set maxBytes larger than minBytes
   // to reduce system calls  This routine handles EAGAIN/EWOULDBLOCK and EINTR.
-  std::size_t Read(Offset, char *, std::size_t minBytes, std::size_t maxBytes,
-      IoErrorHandler &);
+  std::size_t Read(FileOffset, char *, std::size_t minBytes,
+      std::size_t maxBytes, IoErrorHandler &);
 
   // Writes data.  Synchronous.  Partial writes indicate program-handled
   // error conditions.
-  std::size_t Write(Offset, const char *, std::size_t, IoErrorHandler &);
+  std::size_t Write(FileOffset, const char *, std::size_t, IoErrorHandler &);
 
   // Truncates the file
-  void Truncate(Offset, IoErrorHandler &);
+  void Truncate(FileOffset, IoErrorHandler &);
 
   // Asynchronous transfers
-  int ReadAsynchronously(Offset, char *, std::size_t, IoErrorHandler &);
-  int WriteAsynchronously(Offset, const char *, std::size_t, IoErrorHandler &);
+  int ReadAsynchronously(FileOffset, char *, std::size_t, IoErrorHandler &);
+  int WriteAsynchronously(
+      FileOffset, const char *, std::size_t, IoErrorHandler &);
   void Wait(int id, IoErrorHandler &);
   void WaitAll(IoErrorHandler &);
 
@@ -61,15 +70,19 @@ class OpenFile {
 
   // lock_ must be held for these
   void CheckOpen(Terminator &);
-  bool Seek(Offset, IoErrorHandler &);
-  bool RawSeek(Offset);
+  bool Seek(FileOffset, IoErrorHandler &);
+  bool RawSeek(FileOffset);
   int PendingResult(Terminator &, int);
 
   Lock lock_;
   int fd_{-1};
   OwningPtr<char> path_;
-  Offset position_{0};
-  std::optional<Offset> knownSize_;
+  std::size_t pathLength_;
+  bool mayRead_{false};
+  bool mayWrite_{false};
+  bool mayPosition_{false};
+  FileOffset position_{0};
+  std::optional<FileOffset> knownSize_;
   int nextId_;
   OwningPtr<Pending> pending_;
 };
diff --git a/runtime/format.cpp b/runtime/format.cpp
index 46ad2ea2b5d0..f31139ebb5ac 100644
--- a/runtime/format.cpp
+++ b/runtime/format.cpp
@@ -8,43 +8,25 @@
 
 #include "format.h"
 #include "io-stmt.h"
+#include "main.h"
 #include "flang/common/format.h"
 #include "flang/decimal/decimal.h"
 #include <limits>
 
 namespace Fortran::runtime::io {
 
-// Default FormatContext virtual member functions
-void FormatContext::Emit(const char *, std::size_t) {
-  Crash("Cannot emit data from this FORMAT string");
-}
-void FormatContext::Emit(const char16_t *, std::size_t) {
-  Crash("Cannot emit data from this FORMAT string");
-}
-void FormatContext::Emit(const char32_t *, std::size_t) {
-  Crash("Cannot emit data from this FORMAT string");
-}
-void FormatContext::HandleSlash(int) {
-  Crash("A / control edit descriptor may not appear in this FORMAT string");
-}
-void FormatContext::HandleAbsolutePosition(int) {
-  Crash("A Tn control edit descriptor may not appear in this FORMAT string");
-}
-void FormatContext::HandleRelativePosition(int) {
-  Crash("An nX, TLn, or TRn control edit descriptor may not appear in this "
-        "FORMAT string");
-}
-
 template<typename CHAR>
 FormatControl<CHAR>::FormatControl(Terminator &terminator, const CHAR *format,
     std::size_t formatLength, int maxHeight)
   : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
     formatLength_{static_cast<int>(formatLength)} {
-  // The additional two items are for the whole string and a
-  // repeated non-parenthesized edit descriptor.
-  if (maxHeight > std::numeric_limits<std::int8_t>::max()) {
+  if (maxHeight != maxHeight_) {
     terminator.Crash("internal Fortran runtime error: maxHeight %d", maxHeight);
   }
+  if (formatLength != static_cast<std::size_t>(formatLength_)) {
+    terminator.Crash(
+        "internal Fortran runtime error: formatLength %zd", formatLength);
+  }
   stack_[0].start = offset_;
   stack_[0].remaining = Iteration::unlimited;  // 13.4(8)
 }
@@ -95,8 +77,7 @@ int FormatControl<CHAR>::GetIntField(Terminator &terminator, CHAR firstCh) {
   return result;
 }
 
-static void HandleControl(
-    FormatContext &context, std::uint16_t &scale, char ch, char next, int n) {
+static void HandleControl(FormatContext &context, char ch, char next, int n) {
   MutableModes &modes{context.mutableModes()};
   switch (ch) {
   case 'B':
@@ -121,7 +102,7 @@ static void HandleControl(
     break;
   case 'P':
     if (!next) {
-      scale = n;  // kP - decimal scaling by 10**k (TODO)
+      modes.scale = n;  // kP - decimal scaling by 10**k
       return;
     }
     break;
@@ -134,6 +115,9 @@ static void HandleControl(
     case 'C':
       modes.roundingMode = common::RoundingMode::TiesAwayFromZero;
       return;
+    case 'P':
+      modes.roundingMode = executionEnvironment.defaultOutputRoundingMode;
+      return;
     default: break;
     }
     break;
@@ -269,13 +253,15 @@ int FormatControl<CHAR>::CueUpNextDataEdit(FormatContext &context, bool stop) {
     } else if (ch >= 'A' && ch <= 'Z') {
       int start{offset_ - 1};
       CHAR next{Capitalize(PeekNext())};
-      if (next < 'A' || next > 'Z') {
+      if (next >= 'A' && next <= 'Z') {
+        ++offset_;
+      } else {
         next = '\0';
       }
       if (ch == 'E' ||
           (!next &&
               (ch == 'A' || ch == 'I' || ch == 'B' || ch == 'O' || ch == 'Z' ||
-                  ch == 'F' || ch == 'D' || ch == 'G'))) {
+                  ch == 'F' || ch == 'D' || ch == 'G' || ch == 'L'))) {
         // Data edit descriptor found
         offset_ = start;
         return repeat && *repeat > 0 ? *repeat : 1;
@@ -284,8 +270,8 @@ int FormatControl<CHAR>::CueUpNextDataEdit(FormatContext &context, bool stop) {
         if (ch == 'T') {  // Tn, TLn, TRn
           repeat = GetIntField(context);
         }
-        HandleControl(context, scale_, static_cast<char>(ch),
-            static_cast<char>(next), repeat && *repeat > 0 ? *repeat : 1);
+        HandleControl(context, static_cast<char>(ch), static_cast<char>(next),
+            repeat ? *repeat : 1);
       }
     } else if (ch == '/') {
       context.HandleSlash(repeat && *repeat > 0 ? *repeat : 1);
@@ -316,7 +302,16 @@ void FormatControl<CHAR>::GetNext(
     edit.variation = '\0';
   }
 
-  edit.width = GetIntField(context);
+  if (edit.descriptor == 'A') {  // width is optional for A[w]
+    auto ch{PeekNext()};
+    if (ch >= '0' && ch <= '9') {
+      edit.width = GetIntField(context);
+    } else {
+      edit.width.reset();
+    }
+  } else {
+    edit.width = GetIntField(context);
+  }
   edit.modes = context.mutableModes();
   if (PeekNext() == '.') {
     ++offset_;
diff --git a/runtime/format.h b/runtime/format.h
index ed164e8902d1..c954c7f3872f 100644
--- a/runtime/format.h
+++ b/runtime/format.h
@@ -11,6 +11,7 @@
 #ifndef FORTRAN_RUNTIME_FORMAT_H_
 #define FORTRAN_RUNTIME_FORMAT_H_
 
+#include "environment.h"
 #include "terminator.h"
 #include "flang/common/Fortran.h"
 #include <cinttypes>
@@ -26,16 +27,19 @@ enum EditingFlags {
 
 struct MutableModes {
   std::uint8_t editingFlags{0};  // BN, DP, SS
-  common::RoundingMode roundingMode{common::RoundingMode::TiesToEven};  // RN
+  common::RoundingMode roundingMode{
+      executionEnvironment
+          .defaultOutputRoundingMode};  // RP/ROUND='PROCESSOR_DEFAULT'
   bool pad{false};  // PAD= mode on READ
   char delim{'\0'};  // DELIM=
+  short scale{0};  // kP
 };
 
 // A single edit descriptor extracted from a FORMAT
 struct DataEdit {
   char descriptor;  // capitalized: one of A, I, B, O, Z, F, E(N/S/X), D, G
   char variation{'\0'};  // N, S, or X for EN, ES, EX
-  int width;  // the 'w' field
+  std::optional<int> width;  // the 'w' field; optional for A
   std::optional<int> digits;  // the 'm' or 'd' field
   std::optional<int> expoDigits;  // 'Ee' field
   MutableModes modes;
@@ -45,13 +49,14 @@ struct DataEdit {
 class FormatContext : virtual public Terminator {
 public:
   FormatContext() {}
+  virtual ~FormatContext() {}
   explicit FormatContext(const MutableModes &modes) : mutableModes_{modes} {}
-  virtual void Emit(const char *, std::size_t);
-  virtual void Emit(const char16_t *, std::size_t);
-  virtual void Emit(const char32_t *, std::size_t);
-  virtual void HandleSlash(int = 1);
-  virtual void HandleRelativePosition(int);
-  virtual void HandleAbsolutePosition(int);
+  virtual bool Emit(const char *, std::size_t) = 0;
+  virtual bool Emit(const char16_t *, std::size_t) = 0;
+  virtual bool Emit(const char32_t *, std::size_t) = 0;
+  virtual bool HandleSlash(int = 1) = 0;
+  virtual bool HandleRelativePosition(std::int64_t) = 0;
+  virtual bool HandleAbsolutePosition(std::int64_t) = 0;
   MutableModes &mutableModes() { return mutableModes_; }
 
 private:
@@ -63,6 +68,8 @@ class FormatContext : virtual public Terminator {
 // Errors are fatal.  See clause 13.4 in Fortran 2018 for background.
 template<typename CHAR = char> class FormatControl {
 public:
+  FormatControl() {}
+  // TODO: make 'format' a reference here and below
   FormatControl(Terminator &, const CHAR *format, std::size_t formatLength,
       int maxHeight = maxMaxHeight);
 
@@ -125,11 +132,10 @@ template<typename CHAR = char> class FormatControl {
   // Data members are arranged and typed so as to reduce size.
   // This structure may be allocated in stack space loaned by the
   // user program for internal I/O.
-  std::uint16_t scale_{0};  // kP
   const std::uint8_t maxHeight_{maxMaxHeight};
   std::uint8_t height_{0};
-  const CHAR *format_;
-  int formatLength_;
+  const CHAR *format_{nullptr};
+  int formatLength_{0};
   int offset_{0};  // next item is at format_[offset_]
 
   // must be last, may be incomplete
diff --git a/runtime/io-api.cpp b/runtime/io-api.cpp
index 56e6dff932c5..d5840a03b75d 100644
--- a/runtime/io-api.cpp
+++ b/runtime/io-api.cpp
@@ -6,11 +6,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+// Implements the I/O statement API
+
 #include "io-api.h"
 #include "format.h"
 #include "io-stmt.h"
 #include "memory.h"
+#include "numeric-output.h"
 #include "terminator.h"
+#include "unit.h"
 #include <cstdlib>
 #include <memory>
 
@@ -25,7 +29,62 @@ Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
       internalLength, format, formatLength, sourceFile, sourceLine);
 }
 
-enum Iostat IONAME(EndIoStatement)(Cookie io) {
-  return static_cast<enum Iostat>(io->EndIoStatement());
+Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
+    std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
+    int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
+  int unit{unitNumber == DefaultUnit ? 6 : unitNumber};
+  ExternalFile &file{ExternalFile::LookUpOrCrash(unit, terminator)};
+  return &file.BeginIoStatement<ExternalFormattedIoStatementState<false>>(
+      file, format, formatLength, sourceFile, sourceLine);
+}
+
+bool IONAME(OutputInteger64)(Cookie cookie, std::int64_t n) {
+  IoStatementState &io{*cookie};
+  DataEdit edit;
+  io.GetNext(edit);
+  return EditIntegerOutput(io, edit, n);
+}
+
+bool IONAME(OutputReal64)(Cookie cookie, double x) {
+  IoStatementState &io{*cookie};
+  DataEdit edit;
+  io.GetNext(edit);
+  return RealOutputEditing<double, 15, 53, 1024>{io, x}.Edit(edit);
+}
+
+bool IONAME(OutputAscii)(Cookie cookie, const char *x, std::size_t length) {
+  IoStatementState &io{*cookie};
+  DataEdit edit;
+  io.GetNext(edit);
+  if (edit.descriptor != 'A' && edit.descriptor != 'G') {
+    io.Crash(
+        "Data edit descriptor '%c' may not be used with a CHARACTER data item",
+        edit.descriptor);
+    return false;
+  }
+  int len{static_cast<int>(length)};
+  int width{edit.width.value_or(len)};
+  return EmitRepeated(io, ' ', std::max(0, width - len)) &&
+      io.Emit(x, std::min(width, len));
+}
+
+bool IONAME(OutputLogical)(Cookie cookie, bool truth) {
+  IoStatementState &io{*cookie};
+  DataEdit edit;
+  io.GetNext(edit);
+  if (edit.descriptor != 'L' && edit.descriptor != 'G') {
+    io.Crash(
+        "Data edit descriptor '%c' may not be used with a LOGICAL data item",
+        edit.descriptor);
+    return false;
+  }
+  return EmitRepeated(io, ' ', std::max(0, edit.width.value_or(1) - 1)) &&
+      io.Emit(truth ? "T" : "F", 1);
+}
+
+enum Iostat IONAME(EndIoStatement)(Cookie cookie) {
+  IoStatementState &io{*cookie};
+  return static_cast<enum Iostat>(io.EndIoStatement());
 }
 }
diff --git a/runtime/io-stmt.cpp b/runtime/io-stmt.cpp
index 617e3e697a14..e54a67a328e2 100644
--- a/runtime/io-stmt.cpp
+++ b/runtime/io-stmt.cpp
@@ -8,81 +8,193 @@
 
 #include "io-stmt.h"
 #include "memory.h"
+#include "unit.h"
 #include <algorithm>
 #include <cstring>
 
 namespace Fortran::runtime::io {
 
+IoStatementState::IoStatementState(const char *sourceFile, int sourceLine)
+  : IoErrorHandler{sourceFile, sourceLine} {}
+
 int IoStatementState::EndIoStatement() { return GetIoStat(); }
 
-int InternalIoStatementState::EndIoStatement() {
-  auto result{GetIoStat()};
-  if (free_) {
-    FreeMemory(this);
-  }
-  return result;
+// Defaults
+void IoStatementState::GetNext(DataEdit &, int) {
+  Crash("GetNext() called for I/O statement that is not a formatted data "
+        "transfer statement");
+}
+bool IoStatementState::Emit(const char *, std::size_t) {
+  Crash("Emit() called for I/O statement that is not an output statement");
+  return false;
+}
+bool IoStatementState::Emit(const char16_t *, std::size_t) {
+  Crash("Emit() called for I/O statement that is not an output statement");
+  return false;
+}
+bool IoStatementState::Emit(const char32_t *, std::size_t) {
+  Crash("Emit() called for I/O statement that is not an output statement");
+  return false;
+}
+bool IoStatementState::HandleSlash(int) {
+  Crash("HandleSlash() called for I/O statement that is not a formatted data "
+        "transfer statement");
+  return false;
+}
+bool IoStatementState::HandleRelativePosition(std::int64_t) {
+  Crash("HandleRelativePosition() called for I/O statement that is not a "
+        "formatted data transfer statement");
+  return false;
+}
+bool IoStatementState::HandleAbsolutePosition(std::int64_t) {
+  Crash("HandleAbsolutePosition() called for I/O statement that is not a "
+        "formatted data transfer statement");
+  return false;
 }
-
-InternalIoStatementState::InternalIoStatementState(
-    const char *sourceFile, int sourceLine)
-  : IoStatementState(sourceFile, sourceLine) {}
 
 template<bool isInput, typename CHAR>
-InternalFormattedIoStatementState<isInput,
-    CHAR>::InternalFormattedIoStatementState(Buffer internal,
-    std::size_t internalLength, const CHAR *format, std::size_t formatLength,
-    const char *sourceFile, int sourceLine)
-  : InternalIoStatementState{sourceFile, sourceLine}, FormatContext{},
-    internal_{internal}, internalLength_{internalLength}, format_{*this, format,
-                                                              formatLength} {
-  std::fill_n(internal_, internalLength_, static_cast<CHAR>(' '));
+FixedRecordIoStatementState<isInput, CHAR>::FixedRecordIoStatementState(
+    Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
+  : IoStatementState{sourceFile, sourceLine}, buffer_{buffer}, length_{length} {
 }
 
 template<bool isInput, typename CHAR>
-void InternalFormattedIoStatementState<isInput, CHAR>::Emit(
+bool FixedRecordIoStatementState<isInput, CHAR>::Emit(
     const CHAR *data, std::size_t chars) {
   if constexpr (isInput) {
-    FormatContext::Emit(data, chars);  // default Crash()
-  } else if (at_ + chars > internalLength_) {
+    IoStatementState::Emit(data, chars);  // default Crash()
+    return false;
+  } else if (at_ + chars > length_) {
     SignalEor();
+    if (at_ < length_) {
+      std::memcpy(buffer_ + at_, data, (length_ - at_) * sizeof(CHAR));
+      at_ = furthest_ = length_;
+    }
+    return false;
   } else {
-    std::memcpy(internal_ + at_, data, chars * sizeof(CHAR));
+    std::memcpy(buffer_ + at_, data, chars * sizeof(CHAR));
     at_ += chars;
+    furthest_ = std::max(furthest_, at_);
+    return true;
   }
 }
 
 template<bool isInput, typename CHAR>
-void InternalFormattedIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
-    int n) {
-  if (n < 0 || static_cast<std::size_t>(n) >= internalLength_) {
-    Crash("T%d control edit descriptor is out of range", n);
-  } else {
-    at_ = n;
+bool FixedRecordIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
+    std::int64_t n) {
+  if (n < 0) {
+    n = 0;
   }
+  n += leftTabLimit_;
+  bool ok{true};
+  if (static_cast<std::size_t>(n) > length_) {
+    SignalEor();
+    n = length_;
+    ok = false;
+  }
+  if constexpr (!isInput) {
+    if (static_cast<std::size_t>(n) > furthest_) {
+      std::fill_n(buffer_ + furthest_, n - furthest_, static_cast<CHAR>(' '));
+    }
+  }
+  at_ = n;
+  furthest_ = std::max(furthest_, at_);
+  return ok;
 }
 
 template<bool isInput, typename CHAR>
-void InternalFormattedIoStatementState<isInput, CHAR>::HandleRelativePosition(
-    int n) {
-  if (n < 0) {
-    at_ -= std::min(at_, -static_cast<std::size_t>(n));
-  } else {
-    at_ += n;
-    if (at_ > internalLength_) {
-      Crash("TR%d control edit descriptor is out of range", n);
-    }
+bool FixedRecordIoStatementState<isInput, CHAR>::HandleRelativePosition(
+    std::int64_t n) {
+  return HandleAbsolutePosition(n + at_ - leftTabLimit_);
+}
+
+template<bool isInput, typename CHAR>
+int FixedRecordIoStatementState<isInput, CHAR>::EndIoStatement() {
+  if constexpr (!isInput) {
+    HandleAbsolutePosition(length_ - leftTabLimit_);  // fill
   }
+  return GetIoStat();
 }
 
 template<bool isInput, typename CHAR>
-int InternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
-  format_.FinishOutput(*this);
-  auto result{GetIoStat()};
+int InternalIoStatementState<isInput, CHAR>::EndIoStatement() {
+  auto result{FixedRecordIoStatementState<isInput, CHAR>::EndIoStatement()};
   if (free_) {
     FreeMemory(this);
   }
   return result;
 }
 
+template<bool isInput, typename CHAR>
+InternalIoStatementState<isInput, CHAR>::InternalIoStatementState(
+    Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
+  : FixedRecordIoStatementState<isInput, CHAR>(
+        buffer, length, sourceFile, sourceLine) {}
+
+template<bool isInput, typename CHAR>
+InternalFormattedIoStatementState<isInput,
+    CHAR>::InternalFormattedIoStatementState(Buffer buffer, std::size_t length,
+    const CHAR *format, std::size_t formatLength, const char *sourceFile,
+    int sourceLine)
+  : InternalIoStatementState<isInput, CHAR>{buffer, length, sourceFile,
+        sourceLine},
+    format_{*this, format, formatLength} {}
+
+template<bool isInput, typename CHAR>
+int InternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
+  format_.FinishOutput(*this);
+  return InternalIoStatementState<isInput, CHAR>::EndIoStatement();
+}
+
+template<bool isInput, typename CHAR>
+ExternalFormattedIoStatementState<isInput,
+    CHAR>::ExternalFormattedIoStatementState(ExternalFile &file,
+    const CHAR *format, std::size_t formatLength, const char *sourceFile,
+    int sourceLine)
+  : IoStatementState{sourceFile, sourceLine}, file_{file}, format_{*this,
+                                                               format,
+                                                               formatLength} {}
+
+template<bool isInput, typename CHAR>
+bool ExternalFormattedIoStatementState<isInput, CHAR>::Emit(
+    const CHAR *data, std::size_t chars) {
+  // TODO: UTF-8 encoding of 2- and 4-byte characters
+  return file_.Emit(data, chars * sizeof(CHAR), *this);
+}
+
+template<bool isInput, typename CHAR>
+bool ExternalFormattedIoStatementState<isInput, CHAR>::HandleSlash(int n) {
+  while (n-- > 0) {
+    if (!file_.NextOutputRecord(*this)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template<bool isInput, typename CHAR>
+bool ExternalFormattedIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
+    std::int64_t n) {
+  return file_.HandleAbsolutePosition(n, *this);
+}
+
+template<bool isInput, typename CHAR>
+bool ExternalFormattedIoStatementState<isInput, CHAR>::HandleRelativePosition(
+    std::int64_t n) {
+  return file_.HandleRelativePosition(n, *this);
+}
+
+template<bool isInput, typename CHAR>
+int ExternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
+  format_.FinishOutput(*this);
+  if constexpr (!isInput) {
+    file_.NextOutputRecord(*this);  // TODO: non-advancing I/O
+  }
+  int result{GetIoStat()};
+  file_.EndIoStatement();  // annihilates *this in file_.u_
+  return result;
+}
+
 template class InternalFormattedIoStatementState<false>;
+template class ExternalFormattedIoStatementState<false>;
 }
diff --git a/runtime/io-stmt.h b/runtime/io-stmt.h
index 2e70efa591be..002f38e82596 100644
--- a/runtime/io-stmt.h
+++ b/runtime/io-stmt.h
@@ -18,47 +18,100 @@
 
 namespace Fortran::runtime::io {
 
-class IoStatementState : public IoErrorHandler {
+class ExternalFile;
+
+class IoStatementState : public IoErrorHandler, public FormatContext {
 public:
-  using IoErrorHandler::IoErrorHandler;
+  IoStatementState(const char *sourceFile, int sourceLine);
+  virtual ~IoStatementState() {}
+
   virtual int EndIoStatement();
 
+  // Default (crashing) callback overrides for FormatContext
+  virtual void GetNext(DataEdit &, int maxRepeat = 1);
+  virtual bool Emit(const char *, std::size_t);
+  virtual bool Emit(const char16_t *, std::size_t);
+  virtual bool Emit(const char32_t *, std::size_t);
+  virtual bool HandleSlash(int);
+  virtual bool HandleRelativePosition(std::int64_t);
+  virtual bool HandleAbsolutePosition(std::int64_t);
+};
+
+template<bool IsInput, typename CHAR = char>
+class FixedRecordIoStatementState : public IoStatementState {
 protected:
+  using Buffer = std::conditional_t<IsInput, const CHAR *, CHAR *>;
+
+public:
+  FixedRecordIoStatementState(
+      Buffer, std::size_t, const char *sourceFile, int sourceLine);
+
+  virtual bool Emit(const CHAR *, std::size_t chars /* not bytes */);
+  // TODO virtual void HandleSlash(int);
+  virtual bool HandleRelativePosition(std::int64_t);
+  virtual bool HandleAbsolutePosition(std::int64_t);
+  virtual int EndIoStatement();
+
+private:
+  Buffer buffer_{nullptr};
+  std::size_t length_;  // RECL= or internal I/O character variable length
+  std::size_t leftTabLimit_{0};  // nonzero only when non-advancing
+  std::size_t at_{0};
+  std::size_t furthest_{0};
 };
 
-class InternalIoStatementState : public IoStatementState {
+template<bool isInput, typename CHAR = char>
+class InternalIoStatementState
+  : public FixedRecordIoStatementState<isInput, CHAR> {
 public:
-  InternalIoStatementState(const char *sourceFile, int sourceLine);
+  using typename FixedRecordIoStatementState<isInput, CHAR>::Buffer;
+  InternalIoStatementState(Buffer, std::size_t,
+      const char *sourceFile = nullptr, int sourceLine = 0);
   virtual int EndIoStatement();
 
 protected:
   bool free_{true};
 };
 
-template<bool IsInput, typename CHAR = char>
-class InternalFormattedIoStatementState : public InternalIoStatementState,
-                                          private FormatContext {
-private:
-  using Buffer = std::conditional_t<IsInput, const CHAR *, CHAR *>;
-
+template<bool isInput, typename CHAR = char>
+class InternalFormattedIoStatementState
+  : public InternalIoStatementState<isInput, CHAR> {
 public:
+  using typename InternalIoStatementState<isInput, CHAR>::Buffer;
   InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
       const CHAR *format, std::size_t formatLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
-  void Emit(const CHAR *, std::size_t chars);
-  // TODO pmk: void HandleSlash(int);
-  void HandleRelativePosition(int);
-  void HandleAbsolutePosition(int);
+  void GetNext(DataEdit &edit, int maxRepeat = 1) {
+    format_.GetNext(*this, edit, maxRepeat);
+  }
   int EndIoStatement();
 
 private:
-  Buffer internal_;
-  std::size_t internalLength_;
-  std::size_t at_{0};
   FormatControl<CHAR> format_;  // must be last, may be partial
 };
 
+template<bool isInput, typename CHAR = char>
+class ExternalFormattedIoStatementState : public IoStatementState {
+public:
+  ExternalFormattedIoStatementState(ExternalFile &, const CHAR *format,
+      std::size_t formatLength, const char *sourceFile = nullptr,
+      int sourceLine = 0);
+  void GetNext(DataEdit &edit, int maxRepeat = 1) {
+    format_.GetNext(*this, edit, maxRepeat);
+  }
+  bool Emit(const CHAR *, std::size_t chars /* not bytes */);
+  bool HandleSlash(int);
+  bool HandleRelativePosition(std::int64_t);
+  bool HandleAbsolutePosition(std::int64_t);
+  int EndIoStatement();
+
+private:
+  ExternalFile &file_;
+  FormatControl<CHAR> format_;
+};
+
 extern template class InternalFormattedIoStatementState<false>;
+extern template class ExternalFormattedIoStatementState<false>;
 
 }
 #endif  // FORTRAN_RUNTIME_IO_STMT_H_
diff --git a/runtime/main.cpp b/runtime/main.cpp
index 25b3b02001bf..8c2caa570df5 100644
--- a/runtime/main.cpp
+++ b/runtime/main.cpp
@@ -7,35 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "main.h"
-#include "io-stmt.h"
+#include "environment.h"
 #include "terminator.h"
+#include "unit.h"
 #include <cfenv>
 #include <cstdio>
 #include <cstdlib>
-#include <limits>
-
-namespace Fortran::runtime {
-ExecutionEnvironment executionEnvironment;
-
-void ExecutionEnvironment::Configure(
-    int ac, const char *av[], const char *env[]) {
-  argc = ac;
-  argv = av;
-  envp = env;
-  listDirectedOutputLineLengthLimit = 79;  // PGI default
-
-  if (auto *x{std::getenv("FORT_FMT_RECL")}) {
-    char *end;
-    auto n{std::strtol(x, &end, 10)};
-    if (n > 0 && n < std::numeric_limits<int>::max() && *end == '\0') {
-      listDirectedOutputLineLengthLimit = n;
-    } else {
-      std::fprintf(
-          stderr, "Fortran runtime: FORT_FMT_RECL=%s is invalid; ignored\n", x);
-    }
-  }
-}
-}
 
 static void ConfigureFloatingPoint() {
 #ifdef feclearexcept  // a macro in some environments; omit std::
@@ -56,5 +33,7 @@ void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[]) {
   std::atexit(Fortran::runtime::NotifyOtherImagesOfNormalEnd);
   Fortran::runtime::executionEnvironment.Configure(argc, argv, envp);
   ConfigureFloatingPoint();
+  Fortran::runtime::Terminator terminator{"ProgramStart()"};
+  Fortran::runtime::io::ExternalFile::InitializePredefinedUnits(terminator);
 }
 }
diff --git a/runtime/main.h b/runtime/main.h
index c966a3674351..2f2504826465 100644
--- a/runtime/main.h
+++ b/runtime/main.h
@@ -9,22 +9,11 @@
 #ifndef FORTRAN_RUNTIME_MAIN_H_
 #define FORTRAN_RUNTIME_MAIN_H_
 
+#include "c-or-cpp.h"
 #include "entry-names.h"
 
-namespace Fortran::runtime {
-struct ExecutionEnvironment {
-  void Configure(int argc, const char *argv[], const char *envp[]);
-
-  int argc;
-  const char **argv;
-  const char **envp;
-  int listDirectedOutputLineLengthLimit;
-};
-extern ExecutionEnvironment executionEnvironment;
-}
-
-extern "C" {
+EXTERN_C_BEGIN
 void RTNAME(ProgramStart)(int, const char *[], const char *[]);
-}
+EXTERN_C_END
 
 #endif  // FORTRAN_RUNTIME_MAIN_H_
diff --git a/runtime/memory.cpp b/runtime/memory.cpp
index e2d997caea78..ac456a5dd9d1 100644
--- a/runtime/memory.cpp
+++ b/runtime/memory.cpp
@@ -25,9 +25,4 @@ void *AllocateMemoryOrCrash(Terminator &terminator, std::size_t bytes) {
 }
 
 void FreeMemory(void *p) { std::free(p); }
-
-void FreeMemoryAndNullify(void *&p) {
-  std::free(p);
-  p = nullptr;
-}
 }
diff --git a/runtime/memory.h b/runtime/memory.h
index 3e65a98fb224..d41f5f95407e 100644
--- a/runtime/memory.h
+++ b/runtime/memory.h
@@ -18,15 +18,22 @@ namespace Fortran::runtime {
 
 class Terminator;
 
-void *AllocateMemoryOrCrash(Terminator &, std::size_t bytes);
-template<typename A> A &AllocateOrCrash(Terminator &t) {
+[[nodiscard]] void *AllocateMemoryOrCrash(Terminator &, std::size_t bytes);
+template<typename A>[[nodiscard]] A &AllocateOrCrash(Terminator &t) {
   return *reinterpret_cast<A *>(AllocateMemoryOrCrash(t, sizeof(A)));
 }
 void FreeMemory(void *);
-void FreeMemoryAndNullify(void *&);
+template<typename A> void FreeMemory(A *p) {
+  FreeMemory(reinterpret_cast<void *>(p));
+}
+template<typename A> void FreeMemoryAndNullify(A *&p) {
+  FreeMemory(p);
+  p = nullptr;
+}
 
 template<typename A> struct New {
-  template<typename... X> A &operator()(Terminator &terminator, X &&... x) {
+  template<typename... X>
+  [[nodiscard]] A &operator()(Terminator &terminator, X &&... x) {
     return *new (AllocateMemoryOrCrash(terminator, sizeof(A)))
         A{std::forward<X>(x)...};
   }
@@ -37,6 +44,22 @@ template<typename A> struct OwningPtrDeleter {
 };
 
 template<typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
+
+template<typename A> struct Allocator {
+  using value_type = A;
+  explicit Allocator(Terminator &t) : terminator{t} {}
+  template<typename B>
+  explicit constexpr Allocator(const Allocator<B> &that) noexcept
+    : terminator{that.terminator} {}
+  Allocator(const Allocator &) = default;
+  Allocator(Allocator &&) = default;
+  [[nodiscard]] constexpr A *allocate(std::size_t n) {
+    return reinterpret_cast<A *>(
+        AllocateMemoryOrCrash(terminator, n * sizeof(A)));
+  }
+  constexpr void deallocate(A *p, std::size_t) { FreeMemory(p); }
+  Terminator &terminator;
+};
 }
 
 #endif  // FORTRAN_RUNTIME_MEMORY_H_
diff --git a/runtime/numeric-output.h b/runtime/numeric-output.h
new file mode 100644
index 000000000000..a0f40c700b7b
--- /dev/null
+++ b/runtime/numeric-output.h
@@ -0,0 +1,449 @@
+//===-- runtime/numeric-output.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_RUNTIME_NUMERIC_OUTPUT_H_
+#define FORTRAN_RUNTIME_NUMERIC_OUTPUT_H_
+
+// Output data editing templates implementing the FORMAT data editing
+// descriptors E, EN, ES, EX, D, F, and G for REAL data (and COMPLEX
+// components, I and G for INTEGER, and B/O/Z for both.
+// See subclauses in 13.7.2.3 of Fortran 2018 for the
+// detailed specifications of these descriptors.
+// Drives the same binary-to-decimal formatting templates used
+// by the f18 compiler.
+
+#include "format.h"
+#include "flang/common/unsigned-const-division.h"
+#include "flang/decimal/decimal.h"
+
+namespace Fortran::runtime::io {
+
+class IoStatementState;
+
+// Utility subroutines
+static bool EmitRepeated(IoStatementState &io, char ch, int n) {
+  while (n-- > 0) {
+    if (!io.Emit(&ch, 1)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool EmitField(
+    IoStatementState &io, const char *p, std::size_t length, int width) {
+  if (width <= 0) {
+    width = static_cast<int>(length);
+  }
+  if (length > static_cast<std::size_t>(width)) {
+    return EmitRepeated(io, '*', width);
+  } else {
+    return EmitRepeated(io, ' ', static_cast<int>(width - length)) &&
+        io.Emit(p, length);
+  }
+}
+
+// I, B, O, Z, and (for INTEGER) G output editing.
+// edit is const here so that a repeated edit descriptor may safely serve
+// multiple array elements
+static bool EditIntegerOutput(
+    IoStatementState &io, const DataEdit &edit, std::int64_t n) {
+  char buffer[66], *end = &buffer[sizeof buffer], *p = end;
+  std::uint64_t un{static_cast<std::uint64_t>(n < 0 ? -n : n)};
+  int signChars{0};
+  switch (edit.descriptor) {
+  case 'G':
+  case 'I':
+    if (n < 0 || (edit.modes.editingFlags & signPlus)) {
+      signChars = 1;  // '-' or '+'
+    }
+    while (un > 0) {
+      auto quotient{common::DivideUnsignedBy<std::uint64_t, 10>(un)};
+      *--p = '0' + un - 10 * quotient;
+      un = quotient;
+    }
+    break;
+  case 'B':
+    for (; un > 0; un >>= 1) {
+      *--p = '0' + (un & 1);
+    }
+    break;
+  case 'O':
+    for (; un > 0; un >>= 3) {
+      *--p = '0' + (un & 7);
+    }
+    break;
+  case 'Z':
+    for (; un > 0; un >>= 4) {
+      int digit = un & 0xf;
+      *--p = digit >= 10 ? 'A' + (digit - 10) : '0' + digit;
+    }
+    break;
+  default:
+    io.Crash(
+        "Data edit descriptor '%c' may not be used with an INTEGER data item",
+        edit.descriptor);
+    return false;
+  }
+
+  int digits = end - p;
+  int leadingZeroes{0};
+  int editWidth{edit.width.value_or(0)};
+  if (edit.digits && digits <= *edit.digits) {  // Iw.m
+    if (*edit.digits == 0 && n == 0) {
+      // Iw.0 with zero value: output field must be blank.  For I0.0
+      // and a zero value, emit one blank character.
+      signChars = 0;  // in case of SP
+      editWidth = std::max(1, editWidth);
+    } else {
+      leadingZeroes = *edit.digits - digits;
+    }
+  } else if (n == 0) {
+    leadingZeroes = 1;
+  }
+  int total{signChars + leadingZeroes + digits};
+  if (edit.width > 0 && total > editWidth) {
+    return EmitRepeated(io, '*', editWidth);
+  }
+  if (total < editWidth) {
+    EmitRepeated(io, '*', editWidth - total);
+    return false;
+  }
+  if (signChars) {
+    if (!io.Emit(n < 0 ? "-" : "+", 1)) {
+      return false;
+    }
+  }
+  return EmitRepeated(io, '0', leadingZeroes) && io.Emit(p, digits);
+}
+
+// Encapsulates the state of a REAL output conversion.
+template<typename FLOAT = double, int decimalPrecision = 15,
+    int binaryPrecision = 53, std::size_t bufferSize = 1024>
+class RealOutputEditing {
+public:
+  RealOutputEditing(IoStatementState &io, FLOAT x) : io_{io}, x_{x} {}
+  bool Edit(const DataEdit &edit);
+
+private:
+  // The DataEdit arguments here are const references or copies so that
+  // the original DataEdit can safely serve multiple array elements if
+  // it has a repeat count.
+  bool EditEorDOutput(const DataEdit &);
+  bool EditFOutput(const DataEdit &);
+  DataEdit EditForGOutput(DataEdit);  // returns an E or F edit
+  bool EditEXOutput(const DataEdit &);
+
+  bool IsZero() const { return x_ == 0; }
+  const char *FormatExponent(int, const DataEdit &edit, int &length);
+
+  static enum decimal::FortranRounding SetRounding(
+      common::RoundingMode rounding) {
+    switch (rounding) {
+    case common::RoundingMode::TiesToEven: break;
+    case common::RoundingMode::Up: return decimal::RoundUp;
+    case common::RoundingMode::Down: return decimal::RoundDown;
+    case common::RoundingMode::ToZero: return decimal::RoundToZero;
+    case common::RoundingMode::TiesAwayFromZero:
+      return decimal::RoundCompatible;
+    }
+    return decimal::RoundNearest;  // arranged thus to dodge bogus G++ warning
+  }
+
+  static bool IsDecimalNumber(const char *p) {
+    if (!p) {
+      return false;
+    }
+    if (*p == '-' || *p == '+') {
+      ++p;
+    }
+    return *p >= '0' && *p <= '9';
+  }
+
+  decimal::ConversionToDecimalResult Convert(
+      int significantDigits, const DataEdit &, int flags = 0);
+
+  IoStatementState &io_;
+  FLOAT x_;
+  char buffer_[bufferSize];
+  int trailingBlanks_{0};  // created when G editing maps to F
+  char exponent_[16];
+};
+
+template<typename FLOAT, int decimalPrecision, int binaryPrecision,
+    std::size_t bufferSize>
+decimal::ConversionToDecimalResult RealOutputEditing<FLOAT, decimalPrecision,
+    binaryPrecision, bufferSize>::Convert(int significantDigits,
+    const DataEdit &edit, int flags) {
+  if (edit.modes.editingFlags & signPlus) {
+    flags |= decimal::AlwaysSign;
+  }
+  auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_, bufferSize,
+      static_cast<enum decimal::DecimalConversionFlags>(flags),
+      significantDigits, SetRounding(edit.modes.roundingMode),
+      decimal::BinaryFloatingPointNumber<binaryPrecision>(x_))};
+  if (!converted.str) {  // overflow
+    io_.Crash("RealOutputEditing::Convert : buffer size %zd was insufficient",
+        bufferSize);
+  }
+  return converted;
+}
+
+// 13.7.2.3.3 in F'2018
+template<typename FLOAT, int decimalPrecision, int binaryPrecision,
+    std::size_t bufferSize>
+bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
+    bufferSize>::EditEorDOutput(const DataEdit &edit) {
+  int editDigits{edit.digits.value_or(0)};  // 'd' field
+  int editWidth{edit.width.value_or(0)};  // 'w' field
+  int significantDigits{editDigits};
+  int flags{0};
+  if (editWidth == 0) {  // "the processor selects the field width"
+    if (edit.digits.has_value()) {  // E0.d
+      editWidth = editDigits + 6;  // -.666E+ee
+    } else {  // E0
+      flags |= decimal::Minimize;
+      significantDigits =
+          bufferSize - 5;  // sign, NUL, + 3 extra for EN scaling
+    }
+  }
+  bool isEN{edit.variation == 'N'};
+  bool isES{edit.variation == 'S'};
+  int scale{isEN || isES ? 1 : edit.modes.scale};  // 'kP' value
+  int zeroesAfterPoint{0};
+  if (scale < 0) {
+    zeroesAfterPoint = -scale;
+    significantDigits = std::max(0, significantDigits - zeroesAfterPoint);
+  } else if (scale > 0) {
+    ++significantDigits;
+    scale = std::min(scale, significantDigits + 1);
+  }
+  // In EN editing, multiple attempts may be necessary, so it's in a loop.
+  while (true) {
+    decimal::ConversionToDecimalResult converted{
+        Convert(significantDigits, edit, flags)};
+    if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
+      return EmitField(io_, converted.str, converted.length, editWidth);
+    }
+    if (!IsZero()) {
+      converted.decimalExponent -= scale;
+    }
+    if (isEN && scale < 3 && (converted.decimalExponent % 3) != 0) {
+      // EN mode: boost the scale and significant digits, try again; need
+      // an effective exponent field that's a multiple of three.
+      ++scale;
+      ++significantDigits;
+      continue;
+    }
+    // Format the exponent (see table 13.1 for all the cases)
+    int expoLength{0};
+    const char *exponent{
+        FormatExponent(converted.decimalExponent, edit, expoLength)};
+    int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
+    int convertedDigits{static_cast<int>(converted.length) - signLength};
+    int zeroesBeforePoint{std::max(0, scale - convertedDigits)};
+    int digitsBeforePoint{std::max(0, scale - zeroesBeforePoint)};
+    int digitsAfterPoint{convertedDigits - digitsBeforePoint};
+    int trailingZeroes{flags & decimal::Minimize
+            ? 0
+            : std::max(0,
+                  significantDigits - (convertedDigits + zeroesBeforePoint))};
+    int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
+        1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes +
+        expoLength};
+    int width{editWidth > 0 ? editWidth : totalLength};
+    if (totalLength > width) {
+      return EmitRepeated(io_, '*', width);
+    }
+    if (totalLength < width && digitsBeforePoint == 0 &&
+        zeroesBeforePoint == 0) {
+      zeroesBeforePoint = 1;
+      ++totalLength;
+    }
+    return EmitRepeated(io_, ' ', width - totalLength) &&
+        io_.Emit(converted.str, signLength + digitsBeforePoint) &&
+        EmitRepeated(io_, '0', zeroesBeforePoint) &&
+        io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
+        EmitRepeated(io_, '0', zeroesAfterPoint) &&
+        io_.Emit(
+            converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
+        EmitRepeated(io_, '0', trailingZeroes) &&
+        io_.Emit(exponent, expoLength);
+  }
+}
+
+// Formats the exponent (see table 13.1 for all the cases)
+template<typename FLOAT, int decimalPrecision, int binaryPrecision,
+    std::size_t bufferSize>
+const char *RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
+    bufferSize>::FormatExponent(int expo, const DataEdit &edit, int &length) {
+  char *eEnd{&exponent_[sizeof exponent_]};
+  char *exponent{eEnd};
+  for (unsigned e{static_cast<unsigned>(std::abs(expo))}; e > 0;) {
+    unsigned quotient{common::DivideUnsignedBy<unsigned, 10>(e)};
+    *--exponent = '0' + e - 10 * quotient;
+    e = quotient;
+  }
+  if (edit.expoDigits) {
+    if (int ed{*edit.expoDigits}) {  // Ew.dEe with e > 0
+      while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
+        *--exponent = '0';
+      }
+    } else if (exponent == eEnd) {
+      *--exponent = '0';  // Ew.dE0 with zero-valued exponent
+    }
+  } else {  // ensure at least two exponent digits
+    while (exponent + 2 > eEnd) {
+      *--exponent = '0';
+    }
+  }
+  *--exponent = expo < 0 ? '-' : '+';
+  if (edit.expoDigits || exponent + 3 == eEnd) {
+    *--exponent = edit.descriptor == 'D' ? 'D' : 'E';  // not 'G'
+  }
+  length = eEnd - exponent;
+  return exponent;
+}
+
+// 13.7.2.3.2 in F'2018
+template<typename FLOAT, int decimalPrecision, int binaryPrecision,
+    std::size_t bufferSize>
+bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
+    bufferSize>::EditFOutput(const DataEdit &edit) {
+  int fracDigits{edit.digits.value_or(0)};  // 'd' field
+  int extraDigits{0};
+  int editWidth{edit.width.value_or(0)};  // 'w' field
+  int flags{0};
+  if (editWidth == 0) {  // "the processor selects the field width"
+    if (!edit.digits.has_value()) {  // F0
+      flags |= decimal::Minimize;
+      fracDigits = bufferSize - 2;  // sign & NUL
+    }
+  }
+  // Multiple conversions may be needed to get the right number of
+  // effective rounded fractional digits.
+  while (true) {
+    decimal::ConversionToDecimalResult converted{
+        Convert(extraDigits + fracDigits, edit, flags)};
+    if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
+      return EmitField(io_, converted.str, converted.length, editWidth);
+    }
+    int scale{IsZero() ? -1 : edit.modes.scale};
+    int expo{converted.decimalExponent - scale};
+    if (expo > extraDigits) {
+      extraDigits = expo;
+      if (flags & decimal::Minimize) {
+        fracDigits = bufferSize - extraDigits - 2;  // sign & NUL
+      }
+      continue;  // try again
+    }
+    int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
+    int convertedDigits{static_cast<int>(converted.length) - signLength};
+    int digitsBeforePoint{std::max(0, std::min(expo, convertedDigits))};
+    int zeroesBeforePoint{std::max(0, expo - digitsBeforePoint)};
+    int zeroesAfterPoint{std::max(0, -expo)};
+    int digitsAfterPoint{convertedDigits - digitsBeforePoint};
+    int trailingZeroes{flags & decimal::Minimize
+            ? 0
+            : std::max(0, fracDigits - (zeroesAfterPoint + digitsAfterPoint))};
+    if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
+            digitsAfterPoint + trailingZeroes ==
+        0) {
+      ++zeroesBeforePoint;  // "." -> "0."
+    }
+    int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
+        1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes};
+    int width{editWidth > 0 ? editWidth : totalLength};
+    if (totalLength > width) {
+      return EmitRepeated(io_, '*', width);
+    }
+    if (totalLength < width && digitsBeforePoint + zeroesBeforePoint == 0) {
+      zeroesBeforePoint = 1;
+      ++totalLength;
+    }
+    return EmitRepeated(io_, ' ', width - totalLength) &&
+        io_.Emit(converted.str, signLength + digitsBeforePoint) &&
+        EmitRepeated(io_, '0', zeroesBeforePoint) &&
+        io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
+        EmitRepeated(io_, '0', zeroesAfterPoint) &&
+        io_.Emit(
+            converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
+        EmitRepeated(io_, '0', trailingZeroes) &&
+        EmitRepeated(io_, ' ', trailingBlanks_);
+  }
+}
+
+// 13.7.5.2.3 in F'2018
+template<typename FLOAT, int decimalPrecision, int binaryPrecision,
+    std::size_t bufferSize>
+DataEdit RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
+    bufferSize>::EditForGOutput(DataEdit edit) {
+  edit.descriptor = 'E';
+  if (!edit.width.has_value() ||
+      (*edit.width > 0 && edit.digits.value_or(-1) == 0)) {
+    return edit;  // Gw.0 -> Ew.0 for w > 0
+  }
+  decimal::ConversionToDecimalResult converted{Convert(1, edit)};
+  if (!IsDecimalNumber(converted.str)) {  // Inf, NaN
+    return edit;
+  }
+  int expo{IsZero() ? 1 : converted.decimalExponent};  // 's'
+  int significantDigits{edit.digits.value_or(decimalPrecision)};  // 'd'
+  if (expo < 0 || expo > significantDigits) {
+    return edit;  // Ew.d
+  }
+  edit.descriptor = 'F';
+  edit.modes.scale = 0;  // kP is ignored for G when no exponent field
+  trailingBlanks_ = 0;
+  int editWidth{edit.width.value_or(0)};
+  if (editWidth > 0) {
+    int expoDigits{edit.expoDigits.value_or(0)};
+    trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4;  // 'n'
+    *edit.width = std::max(0, editWidth - trailingBlanks_);
+  }
+  if (edit.digits.has_value()) {
+    *edit.digits = std::max(0, *edit.digits - expo);
+  }
+  return edit;
+}
+
+// 13.7.5.2.6 in F'2018
+template<typename FLOAT, int decimalPrecision, int binaryPrecision,
+    std::size_t bufferSize>
+bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
+    bufferSize>::EditEXOutput(const DataEdit &) {
+  io_.Crash("EX output editing is not yet implemented");  // TODO
+}
+
+template<typename FLOAT, int decimalPrecision, int binaryPrecision,
+    std::size_t bufferSize>
+bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
+    bufferSize>::Edit(const DataEdit &edit) {
+  switch (edit.descriptor) {
+  case 'D': return EditEorDOutput(edit);
+  case 'E':
+    if (edit.variation == 'X') {
+      return EditEXOutput(edit);
+    } else {
+      return EditEorDOutput(edit);
+    }
+  case 'F': return EditFOutput(edit);
+  case 'B':
+  case 'O':
+  case 'Z':
+    return EditIntegerOutput(io_, edit, decimal::BinaryFloatingPointNumber<binaryPrecision>{x_}.raw);
+  case 'G': return Edit(EditForGOutput(edit));
+  default:
+    io_.Crash("Data edit descriptor '%c' may not be used with a REAL data item",
+        edit.descriptor);
+    return false;
+  }
+  return false;
+}
+}
+#endif  // FORTRAN_RUNTIME_NUMERIC_OUTPUT_H_
diff --git a/runtime/stop.cpp b/runtime/stop.cpp
index 8bf665f82512..85bf9c4a14ac 100644
--- a/runtime/stop.cpp
+++ b/runtime/stop.cpp
@@ -7,7 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "stop.h"
+#include "io-error.h"
 #include "terminator.h"
+#include "unit.h"
 #include <cfenv>
 #include <cstdio>
 #include <cstdlib>
@@ -66,4 +68,10 @@ static void DescribeIEEESignaledExceptions() {
   Fortran::runtime::NotifyOtherImagesOfFailImageStatement();
   std::exit(EXIT_FAILURE);
 }
+
+[[noreturn]] void RTNAME(ProgramEndStatement)() {
+  Fortran::runtime::io::IoErrorHandler handler{"END statement"};
+  Fortran::runtime::io::ExternalFile::CloseAll(handler);
+  std::exit(EXIT_SUCCESS);
+}
 }
diff --git a/runtime/stop.h b/runtime/stop.h
index b3d8e32c5de4..8fb1d8d4cffd 100644
--- a/runtime/stop.h
+++ b/runtime/stop.h
@@ -21,6 +21,7 @@ NORETURN void RTNAME(StopStatement)(int code DEFAULT_VALUE(EXIT_SUCCESS),
 NORETURN void RTNAME(StopStatementText)(const char *,
     bool isErrorStop DEFAULT_VALUE(false), bool quiet DEFAULT_VALUE(false));
 NORETURN void RTNAME(FailImageStatement)(NO_ARGUMENTS);
+NORETURN void RTNAME(ProgramEndStatement)(NO_ARGUMENTS);
 
 EXTERN_C_END
 
diff --git a/runtime/tools.h b/runtime/tools.h
index 184f6af63f8e..d1b90b1ad3c9 100644
--- a/runtime/tools.h
+++ b/runtime/tools.h
@@ -8,7 +8,12 @@
 
 #ifndef FORTRAN_RUNTIME_TOOLS_H_
 #define FORTRAN_RUNTIME_TOOLS_H_
+
 #include "memory.h"
+#include <functional>
+#include <map>
+#include <type_traits>
+
 namespace Fortran::runtime {
 
 class Terminator;
@@ -21,5 +26,11 @@ OwningPtr<char> SaveDefaultCharacter(const char *, std::size_t, Terminator &);
 // or -1 when it has no match.
 int IdentifyValue(
     const char *value, std::size_t length, const char *possibilities[]);
+
+// A std::map<> customized to use the runtime's memory allocator
+template<typename KEY, typename VALUE>
+using MapAllocator = Allocator<std::pair<std::add_const_t<KEY>, VALUE>>;
+template<typename KEY, typename VALUE, typename COMPARE = std::less<KEY>>
+using Map = std::map<KEY, VALUE, COMPARE, MapAllocator<KEY, VALUE>>;
 }
 #endif  // FORTRAN_RUNTIME_TOOLS_H_
diff --git a/runtime/unit.cpp b/runtime/unit.cpp
new file mode 100644
index 000000000000..f7a342ccbb73
--- /dev/null
+++ b/runtime/unit.cpp
@@ -0,0 +1,137 @@
+//===-- runtime/unit.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 "unit.h"
+#include "lock.h"
+#include "memory.h"
+#include "tools.h"
+#include <cerrno>
+#include <type_traits>
+
+namespace Fortran::runtime::io {
+
+static Lock mapLock;
+static Terminator mapTerminator;
+static Map<int, ExternalFile> unitMap{MapAllocator<int, ExternalFile>{mapTerminator}};
+
+ExternalFile *ExternalFile::LookUp(int unit) {
+  CriticalSection criticalSection{mapLock};
+  auto iter{unitMap.find(unit)};
+  return iter == unitMap.end() ? nullptr : &iter->second;
+}
+
+ExternalFile &ExternalFile::LookUpOrCrash(int unit, Terminator &terminator) {
+  CriticalSection criticalSection{mapLock};
+  ExternalFile *file{LookUp(unit)};
+  if (!file) {
+    terminator.Crash("Not an open I/O unit number: %d", unit);
+  }
+  return *file;
+}
+
+ExternalFile &ExternalFile::Create(int unit, Terminator &terminator) {
+  CriticalSection criticalSection{mapLock};
+  auto pair{unitMap.emplace(unit, unit)};
+  if (!pair.second) {
+    terminator.Crash("Already opened I/O unit number: %d", unit);
+  }
+  return pair.first->second;
+}
+
+void ExternalFile::CloseUnit(IoErrorHandler &handler) {
+  CriticalSection criticalSection{mapLock};
+  Flush(handler);
+  auto iter{unitMap.find(unitNumber_)};
+  if (iter != unitMap.end()) {
+    unitMap.erase(iter);
+  }
+}
+
+void ExternalFile::InitializePredefinedUnits(Terminator &terminator) {
+  ExternalFile &out{ExternalFile::Create(6, terminator)};
+  out.Predefine(1);
+  out.set_mayRead(false);
+  out.set_mayWrite(true);
+  out.set_mayPosition(false);
+  ExternalFile &in{ExternalFile::Create(5, terminator)};
+  in.Predefine(0);
+  in.set_mayRead(true);
+  in.set_mayWrite(false);
+  in.set_mayPosition(false);
+  // TODO: Set UTF-8 mode from the environment
+}
+
+void ExternalFile::CloseAll(IoErrorHandler &handler) {
+  CriticalSection criticalSection{mapLock};
+  while (!unitMap.empty()) {
+    auto &pair{*unitMap.begin()};
+    pair.second.CloseUnit(handler);
+  }
+}
+
+bool ExternalFile::SetPositionInRecord(std::int64_t n, IoErrorHandler &handler) {
+  n = std::max(std::int64_t{0}, n);
+  bool ok{true};
+  if (n > recordLength.value_or(n)) {
+    handler.SignalEor();
+    n = *recordLength;
+    ok = false;
+  }
+  if (n > furthestPositionInRecord) {
+    if (!isReading_ && ok) {
+      WriteFrame(recordOffsetInFile, n, handler);
+      std::fill_n(Frame() + furthestPositionInRecord, n - furthestPositionInRecord, ' ');
+    }
+    furthestPositionInRecord = n;
+  }
+  positionInRecord = n;
+  return ok;
+}
+
+bool ExternalFile::Emit(const char *data, std::size_t bytes, IoErrorHandler &handler) {
+  auto furthestAfter{std::max(furthestPositionInRecord, positionInRecord + static_cast<std::int64_t>(bytes))};
+  WriteFrame(recordOffsetInFile, furthestAfter, handler);
+  std::memcpy(Frame() + positionInRecord, data, bytes);
+  positionInRecord += bytes;
+  furthestPositionInRecord = furthestAfter;
+  return true;
+}
+
+void ExternalFile::SetLeftTabLimit() {
+  leftTabLimit = furthestPositionInRecord;
+  positionInRecord = furthestPositionInRecord;
+}
+
+bool ExternalFile::NextOutputRecord(IoErrorHandler &handler) {
+  bool ok{true};
+  if (recordLength.has_value()) {  // fill fixed-size record
+    ok &= SetPositionInRecord(*recordLength, handler);
+  } else if (!unformatted && !isReading_) {
+    ok &= SetPositionInRecord(furthestPositionInRecord, handler) &&
+      Emit("\n", 1, handler);
+  }
+  recordOffsetInFile += furthestPositionInRecord;
+  ++currentRecordNumber;
+  positionInRecord = 0;
+  positionInRecord = furthestPositionInRecord = 0;
+  leftTabLimit.reset();
+  return ok;
+}
+
+bool ExternalFile::HandleAbsolutePosition(std::int64_t n, IoErrorHandler &handler) {
+  return SetPositionInRecord(std::max(n, std::int64_t{0}) + leftTabLimit.value_or(0), handler);
+}
+
+bool ExternalFile::HandleRelativePosition(std::int64_t n, IoErrorHandler &handler) {
+  return HandleAbsolutePosition(positionInRecord + n, handler);
+}
+
+void ExternalFile::EndIoStatement() {
+  u_.emplace<std::monostate>();
+}
+}
diff --git a/runtime/unit.h b/runtime/unit.h
new file mode 100644
index 000000000000..a6b80b22587e
--- /dev/null
+++ b/runtime/unit.h
@@ -0,0 +1,114 @@
+//===-- runtime/unit.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
+//
+//===----------------------------------------------------------------------===//
+
+// Fortran I/O units
+
+#ifndef FORTRAN_RUNTIME_IO_UNIT_H_
+#define FORTRAN_RUNTIME_IO_UNIT_H_
+
+#include "buffer.h"
+#include "descriptor.h"
+#include "file.h"
+#include "format.h"
+#include "io-error.h"
+#include "io-stmt.h"
+#include "lock.h"
+#include "memory.h"
+#include "terminator.h"
+#include <cstdlib>
+#include <cstring>
+#include <optional>
+#include <variant>
+
+namespace Fortran::runtime::io {
+
+enum class Access { Sequential, Direct, Stream };
+
+inline bool IsRecordFile(Access a) { return a != Access::Stream; }
+
+// These characteristics of a connection are immutable after being
+// established in an OPEN statement.
+struct ConnectionAttributes {
+  Access access{Access::Sequential};  // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
+  std::optional<std::int64_t> recordLength;  // RECL= when fixed-length
+  bool unformatted{false};  // FORM='UNFORMATTED'
+  bool isUTF8{false};  // ENCODING='UTF-8'
+  bool asynchronousAllowed{false};  // ASYNCHRONOUS='YES'
+};
+
+struct ConnectionState : public ConnectionAttributes {
+  // Positions in a record file (sequential or direct, but not stream)
+  std::int64_t recordOffsetInFile{0};
+  std::int64_t currentRecordNumber{1};  // 1 is first
+  std::int64_t positionInRecord{0};  // offset in current record
+  std::int64_t furthestPositionInRecord{0};  // max(positionInRecord)
+  std::optional<std::int64_t> leftTabLimit;  // offset in current record
+  // nextRecord value captured after ENDFILE/REWIND/BACKSPACE statement
+  // on a sequential access file
+  std::optional<std::int64_t> endfileRecordNumber;
+  // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
+  MutableModes modes;  // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
+};
+
+class InternalUnit : public ConnectionState, public IoErrorHandler {
+public:
+  InternalUnit(Descriptor &, const char *sourceFile, int sourceLine)
+    : IoErrorHandler{sourceFile, sourceLine} {
+// TODO pmk    descriptor_.Establish(...);
+    descriptor_.GetLowerBounds(at_);
+    recordLength = descriptor_.ElementBytes();
+    endfileRecordNumber = descriptor_.Elements();
+  }
+  ~InternalUnit() {
+    if (!doNotFree_) {
+      std::free(this);
+    }
+  }
+
+private:
+  bool doNotFree_{false};
+  Descriptor descriptor_;
+  SubscriptValue at_[maxRank];
+};
+
+class ExternalFile : public ConnectionState,  // TODO: privatize these
+                     public OpenFile,
+                     public FileFrame<ExternalFile> {
+public:
+  explicit ExternalFile(int unitNumber) : unitNumber_{unitNumber} {}
+  static ExternalFile *LookUp(int unit);
+  static ExternalFile &LookUpOrCrash(int unit, Terminator &);
+  static ExternalFile &Create(int unit, Terminator &);
+  static void InitializePredefinedUnits(Terminator &);
+  static void CloseAll(IoErrorHandler &);
+
+  void CloseUnit(IoErrorHandler &);
+
+  // TODO: accessors & mutators for many OPEN() specifiers
+  template<typename A, typename... X> A &BeginIoStatement(X&&... xs) {
+    // TODO: lock_.Take() here, and keep it until EndIoStatement()?
+    // Nested I/O from derived types wouldn't work, though.
+    return u_.emplace<A>(std::forward<X>(xs)...);
+  }
+  void EndIoStatement();
+
+  bool SetPositionInRecord(std::int64_t, IoErrorHandler &);
+  bool Emit(const char *, std::size_t bytes, IoErrorHandler &);
+  void SetLeftTabLimit();
+  bool NextOutputRecord(IoErrorHandler &);
+  bool HandleAbsolutePosition(std::int64_t, IoErrorHandler &);
+  bool HandleRelativePosition(std::int64_t, IoErrorHandler &);
+private:
+  int unitNumber_{-1};
+  Lock lock_;
+  bool isReading_{false};
+  std::variant<std::monostate, ExternalFormattedIoStatementState<false>> u_;
+};
+
+}
+#endif  // FORTRAN_RUNTIME_IO_UNIT_H_
diff --git a/test/runtime/CMakeLists.txt b/test/runtime/CMakeLists.txt
index fda3776cc906..feadddfa880a 100644
--- a/test/runtime/CMakeLists.txt
+++ b/test/runtime/CMakeLists.txt
@@ -29,3 +29,11 @@ target_link_libraries(hello-world
 )
 
 add_test(HelloWorld hello-world)
+
+add_executable(external-hello-world
+  external-hello.cpp
+)
+
+target_link_libraries(external-hello-world
+  FortranRuntime
+)
diff --git a/test/runtime/external-hello.cpp b/test/runtime/external-hello.cpp
new file mode 100644
index 000000000000..af7151f6c44e
--- /dev/null
+++ b/test/runtime/external-hello.cpp
@@ -0,0 +1,15 @@
+#include "../../runtime/io-api.h"
+#include "../../runtime/main.h"
+#include "../../runtime/stop.h"
+#include <cstring>
+
+using namespace Fortran::runtime::io;
+
+int main(int argc, const char *argv[], const char *envp[]) {
+  static const char *format{"(12HHELLO, WORLD)"};
+  RTNAME(ProgramStart)(argc, argv, envp);
+  auto *io{IONAME(BeginExternalFormattedOutput)(format, std::strlen(format))};
+  IONAME(EndIoStatement)(io);
+  RTNAME(ProgramEndStatement)();
+  return 0;
+}
diff --git a/test/runtime/format.cpp b/test/runtime/format.cpp
index 937a4434b8d7..31e3261d8f88 100644
--- a/test/runtime/format.cpp
+++ b/test/runtime/format.cpp
@@ -1,4 +1,5 @@
-// Test basic FORMAT string traversal
+// Tests basic FORMAT string traversal
+
 #include "../runtime/format.h"
 #include "../runtime/terminator.h"
 #include <cstdarg>
@@ -17,17 +18,20 @@ using Results = std::list<std::string>;
 // Test harness context for format control
 struct TestFormatContext : virtual public Terminator, public FormatContext {
   TestFormatContext() : Terminator{"format.cpp", 1} {}
-  void Emit(const char *, std::size_t);
-  void HandleSlash(int = 1);
-  void HandleRelativePosition(int);
-  void HandleAbsolutePosition(int);
+  bool Emit(const char *, std::size_t);
+  bool Emit(const char16_t *, std::size_t);
+  bool Emit(const char32_t *, std::size_t);
+  bool HandleSlash(int = 1);
+  bool HandleRelativePosition(std::int64_t);
+  bool HandleAbsolutePosition(std::int64_t);
   void Report(const DataEdit &);
   void Check(Results &);
   Results results;
 };
 
 // Override the runtime's Crash() for testing purposes
-[[noreturn]] void Fortran::runtime::Terminator::Crash(const char *message, ...) {
+[[noreturn]] void Fortran::runtime::Terminator::Crash(
+    const char *message, ...) {
   std::va_list ap;
   va_start(ap, message);
   char buffer[1000];
@@ -36,27 +40,39 @@ struct TestFormatContext : virtual public Terminator, public FormatContext {
   throw std::string{buffer};
 }
 
-void TestFormatContext::Emit(const char *s, std::size_t len) {
+bool TestFormatContext::Emit(const char *s, std::size_t len) {
   std::string str{s, len};
   results.push_back("'"s + str + '\'');
+  return true;
+}
+bool TestFormatContext::Emit(const char16_t *, std::size_t) {
+  Crash("TestFormatContext::Emit(const char16_t *) called");
+  return false;
+}
+bool TestFormatContext::Emit(const char32_t *, std::size_t) {
+  Crash("TestFormatContext::Emit(const char32_t *) called");
+  return false;
 }
 
-void TestFormatContext::HandleSlash(int n) {
+bool TestFormatContext::HandleSlash(int n) {
   while (n-- > 0) {
     results.emplace_back("/");
   }
+  return true;
 }
 
-void TestFormatContext::HandleAbsolutePosition(int n) {
+bool TestFormatContext::HandleAbsolutePosition(std::int64_t n) {
   results.push_back("T"s + std::to_string(n));
+  return true;
 }
 
-void TestFormatContext::HandleRelativePosition(int n) {
+bool TestFormatContext::HandleRelativePosition(std::int64_t n) {
   if (n < 0) {
     results.push_back("TL"s + std::to_string(-n));
   } else {
     results.push_back(std::to_string(n) + 'X');
   }
+  return true;
 }
 
 void TestFormatContext::Report(const DataEdit &edit) {
@@ -67,7 +83,9 @@ void TestFormatContext::Report(const DataEdit &edit) {
   if (edit.variation) {
     str += edit.variation;
   }
-  str += std::to_string(edit.width);
+  if (edit.width) {
+    str += std::to_string(*edit.width);
+  }
   if (edit.digits) {
     str += "."s + std::to_string(*edit.digits);
   }
diff --git a/test/runtime/hello.cpp b/test/runtime/hello.cpp
index 9c52a01b26a9..86354a36de5e 100644
--- a/test/runtime/hello.cpp
+++ b/test/runtime/hello.cpp
@@ -1,4 +1,4 @@
-// Basic tests of I/O API
+// Basic sanity tests of I/O API; exhaustive testing will be done in Fortran
 
 #include "../../runtime/io-api.h"
 #include <cstring>
@@ -8,22 +8,334 @@ using namespace Fortran::runtime::io;
 
 static int failures{0};
 
-int main() {
+static void test(const char *format, const char *expect, std::string &&got) {
+  std::string want{expect};
+  want.resize(got.length(), ' ');
+  if (got != want) {
+    std::cerr << '\'' << format << "' failed;\n     got '" << got
+              << "',\nexpected '" << want << "'\n";
+    ++failures;
+  }
+}
+
+static void hello() {
   char buffer[32];
-  const char *format1{"(12HHELLO, WORLD)"};
-  auto cookie{IONAME(BeginInternalFormattedOutput)(buffer, sizeof buffer, format1, std::strlen(format1))};
+  const char *format{"(6HHELLO,,A6,2X,I3,1X,'0x',Z8,1X,L1)"};
+  auto cookie{IONAME(BeginInternalFormattedOutput)(
+      buffer, sizeof buffer, format, std::strlen(format))};
+  IONAME(OutputAscii)(cookie, "WORLD", 5);
+  IONAME(OutputInteger64)(cookie, 678);
+  IONAME(OutputInteger64)(cookie, 0xfeedface);
+  IONAME(OutputLogical)(cookie, true);
   if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    std::cerr << "format1 failed, status " << static_cast<int>(status) << '\n';
+    std::cerr << '\'' << format << "' failed, status "
+              << static_cast<int>(status) << '\n';
     ++failures;
+  } else {
+    test(format, "HELLO, WORLD  678 0xFEEDFACE T",
+        std::string{buffer, sizeof buffer});
   }
-  std::string got1{buffer, sizeof buffer};
-  std::string expect1{"HELLO, WORLD"};
-  expect1.resize(got1.length(), ' ');
-  if (got1 != expect1) {
-    std::cerr << "format1 failed, got '" << got1 << "', expected '" << expect1 << "'\n";
+}
+
+static void realTest(const char *format, double x, const char *expect) {
+  char buffer[800];
+  auto cookie{IONAME(BeginInternalFormattedOutput)(
+      buffer, sizeof buffer, format, std::strlen(format))};
+  IONAME(OutputReal64)(cookie, x);
+  if (auto status{IONAME(EndIoStatement)(cookie)}) {
+    std::cerr << '\'' << format << "' failed, status "
+              << static_cast<int>(status) << '\n';
     ++failures;
+  } else {
+    test(format, expect, std::string{buffer, sizeof buffer});
+  }
+}
+
+int main() {
+  hello();
+
+  static const char *zeroes[][2]{
+      {"(E32.17,';')", "         0.00000000000000000E+00;"},
+      {"(F32.17,';')", "             0.00000000000000000;"},
+      {"(G32.17,';')", "          0.0000000000000000    ;"},
+      {"(DC,E32.17,';')", "         0,00000000000000000E+00;"},
+      {"(DC,F32.17,';')", "             0,00000000000000000;"},
+      {"(DC,G32.17,';')", "          0,0000000000000000    ;"},
+      {"(D32.17,';')", "         0.00000000000000000D+00;"},
+      {"(E32.17E1,';')", "          0.00000000000000000E+0;"},
+      {"(G32.17E1,';')", "           0.0000000000000000   ;"},
+      {"(E32.17E0,';')", "          0.00000000000000000E+0;"},
+      {"(G32.17E0,';')", "          0.0000000000000000    ;"},
+      {"(1P,E32.17,';')", "         0.00000000000000000E+00;"},
+      {"(1P,F32.17,';')", "             0.00000000000000000;"},
+      {"(1P,G32.17,';')", "          0.0000000000000000    ;"},
+      {"(2P,E32.17,';')", "         00.0000000000000000E+00;"},
+      {"(-1P,E32.17,';')", "         0.00000000000000000E+00;"},
+      {"(G0,';')", "0.;"}, {}};
+  for (int j{0}; zeroes[j][0]; ++j) {
+    realTest(zeroes[j][0], 0.0, zeroes[j][1]);
+  }
+
+  static const char *ones[][2]{
+      {"(E32.17,';')", "         0.10000000000000000E+01;"},
+      {"(F32.17,';')", "             1.00000000000000000;"},
+      {"(G32.17,';')", "          1.0000000000000000    ;"},
+      {"(E32.17E1,';')", "          0.10000000000000000E+1;"},
+      {"(G32.17E1,';')", "           1.0000000000000000   ;"},
+      {"(E32.17E0,';')", "          0.10000000000000000E+1;"},
+      {"(G32.17E0,';')", "          1.0000000000000000    ;"},
+      {"(E32.17E4,';')", "       0.10000000000000000E+0001;"},
+      {"(G32.17E4,';')", "        1.0000000000000000      ;"},
+      {"(1P,E32.17,';')", "         1.00000000000000000E+00;"},
+      {"(1P,F32.17,';')", "             0.10000000000000000;"},
+      {"(1P,G32.17,';')", "          1.0000000000000000    ;"},
+      {"(ES32.17,';')", "         1.00000000000000000E+00;"},
+      {"(2P,E32.17,';')", "         10.0000000000000000E-01;"},
+      {"(2P,G32.17,';')", "          1.0000000000000000    ;"},
+      {"(-1P,E32.17,';')", "         0.01000000000000000E+02;"},
+      {"(-1P,G32.17,';')", "          1.0000000000000000    ;"},
+      {"(G0,';')", "1.;"}, {}};
+  for (int j{0}; ones[j][0]; ++j) {
+    realTest(ones[j][0], 1.0, ones[j][1]);
   }
 
+  realTest("(E32.17,';')", -1.0, "        -0.10000000000000000E+01;");
+  realTest("(F32.17,';')", -1.0, "            -1.00000000000000000;");
+  realTest("(G32.17,';')", -1.0, "         -1.0000000000000000    ;");
+  realTest("(G0,';')", -1.0, "-1.;");
+
+  volatile union {
+    double d;
+    std::uint64_t n;
+  } u;
+  u.n = 0x8000000000000000;  // -0
+  realTest("(E9.1,';')", u.d, " -0.0E+00;");
+  realTest("(F4.0,';')", u.d, " -0.;");
+  realTest("(G8.0,';')", u.d, "-0.0E+00;");
+  realTest("(G8.1,';')", u.d, " -0.    ;");
+  realTest("(G0,';')", u.d, "-0.;");
+  u.n = 0x7ff0000000000000;  // +Inf
+  realTest("(E9.1,';')", u.d, "      Inf;");
+  realTest("(F9.1,';')", u.d, "      Inf;");
+  realTest("(G9.1,';')", u.d, "      Inf;");
+  realTest("(SP,E9.1,';')", u.d, "     +Inf;");
+  realTest("(SP,F9.1,';')", u.d, "     +Inf;");
+  realTest("(SP,G9.1,';')", u.d, "     +Inf;");
+  realTest("(G0,';')", u.d, "Inf;");
+  u.n = 0xfff0000000000000;  // -Inf
+  realTest("(E9.1,';')", u.d, "     -Inf;");
+  realTest("(F9.1,';')", u.d, "     -Inf;");
+  realTest("(G9.1,';')", u.d, "     -Inf;");
+  realTest("(G0,';')", u.d, "-Inf;");
+  u.n = 0x7ff0000000000001;  // NaN
+  realTest("(E9.1,';')", u.d, "      NaN;");
+  realTest("(F9.1,';')", u.d, "      NaN;");
+  realTest("(G9.1,';')", u.d, "      NaN;");
+  realTest("(G0,';')", u.d, "NaN;");
+  u.n = 0xfff0000000000001;  // NaN (sign irrelevant)
+  realTest("(E9.1,';')", u.d, "      NaN;");
+  realTest("(F9.1,';')", u.d, "      NaN;");
+  realTest("(G9.1,';')", u.d, "      NaN;");
+  realTest("(SP,E9.1,';')", u.d, "      NaN;");
+  realTest("(SP,F9.1,';')", u.d, "      NaN;");
+  realTest("(SP,G9.1,';')", u.d, "      NaN;");
+  realTest("(G0,';')", u.d, "NaN;");
+
+  u.n = 0x3fb999999999999a;  // 0.1 rounded
+  realTest("(E62.55,';')", u.d,
+      " 0.1000000000000000055511151231257827021181583404541015625E+00;");
+  realTest("(E0.0,';')", u.d, "0.E+00;");
+  realTest("(E0.55,';')", u.d,
+      "0.1000000000000000055511151231257827021181583404541015625E+00;");
+  realTest("(E0,';')", u.d, ".1E+00;");
+  realTest("(F58.55,';')", u.d,
+      " 0.1000000000000000055511151231257827021181583404541015625;");
+  realTest("(F0.0,';')", u.d, "0.;");
+  realTest("(F0.55,';')", u.d,
+      ".1000000000000000055511151231257827021181583404541015625;");
+  realTest("(F0,';')", u.d, ".1;");
+  realTest("(G62.55,';')", u.d,
+      " 0.1000000000000000055511151231257827021181583404541015625    ;");
+  realTest("(G0.0,';')", u.d, "0.;");
+  realTest("(G0.55,';')", u.d,
+      ".1000000000000000055511151231257827021181583404541015625;");
+  realTest("(G0,';')", u.d, ".1;");
+
+  u.n = 0x3ff8000000000000;  // 1.5
+  realTest("(E9.2,';')", u.d, " 0.15E+01;");
+  realTest("(F4.1,';')", u.d, " 1.5;");
+  realTest("(G7.1,';')", u.d, " 2.    ;");
+  realTest("(RN,E8.1,';')", u.d, " 0.2E+01;");
+  realTest("(RN,F3.0,';')", u.d, " 2.;");
+  realTest("(RN,G7.0,';')", u.d, " 0.E+01;");
+  realTest("(RN,G7.1,';')", u.d, " 2.    ;");
+  realTest("(RD,E8.1,';')", u.d, " 0.1E+01;");
+  realTest("(RD,F3.0,';')", u.d, " 1.;");
+  realTest("(RD,G7.0,';')", u.d, " 0.E+01;");
+  realTest("(RD,G7.1,';')", u.d, " 1.    ;");
+  realTest("(RU,E8.1,';')", u.d, " 0.2E+01;");
+  realTest("(RU,G7.0,';')", u.d, " 0.E+01;");
+  realTest("(RU,G7.1,';')", u.d, " 2.    ;");
+  realTest("(RZ,E8.1,';')", u.d, " 0.1E+01;");
+  realTest("(RZ,F3.0,';')", u.d, " 1.;");
+  realTest("(RZ,G7.0,';')", u.d, " 0.E+01;");
+  realTest("(RZ,G7.1,';')", u.d, " 1.    ;");
+  realTest("(RC,E8.1,';')", u.d, " 0.2E+01;");
+  realTest("(RC,F3.0,';')", u.d, " 2.;");
+  realTest("(RC,G7.0,';')", u.d, " 0.E+01;");
+  realTest("(RC,G7.1,';')", u.d, " 2.    ;");
+
+  // TODO continue F and G editing tests on these data
+
+  u.n = 0xbff8000000000000;  // -1.5
+  realTest("(E9.2,';')", u.d, "-0.15E+01;");
+  realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
+  realTest("(RD,E8.1,';')", u.d, "-0.2E+01;");
+  realTest("(RU,E8.1,';')", u.d, "-0.1E+01;");
+  realTest("(RZ,E8.1,';')", u.d, "-0.1E+01;");
+  realTest("(RC,E8.1,';')", u.d, "-0.2E+01;");
+
+  u.n = 0x4004000000000000;  // 2.5
+  realTest("(E9.2,';')", u.d, " 0.25E+01;");
+  realTest("(RN,E8.1,';')", u.d, " 0.2E+01;");
+  realTest("(RD,E8.1,';')", u.d, " 0.2E+01;");
+  realTest("(RU,E8.1,';')", u.d, " 0.3E+01;");
+  realTest("(RZ,E8.1,';')", u.d, " 0.2E+01;");
+  realTest("(RC,E8.1,';')", u.d, " 0.3E+01;");
+
+  u.n = 0xc004000000000000;  // -2.5
+  realTest("(E9.2,';')", u.d, "-0.25E+01;");
+  realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
+  realTest("(RD,E8.1,';')", u.d, "-0.3E+01;");
+  realTest("(RU,E8.1,';')", u.d, "-0.2E+01;");
+  realTest("(RZ,E8.1,';')", u.d, "-0.2E+01;");
+  realTest("(RC,E8.1,';')", u.d, "-0.3E+01;");
+
+  u.n = 1;  // least positive nonzero subnormal
+  realTest("(E32.17,';')", u.d, "         0.49406564584124654-323;");
+  realTest("(ES32.17,';')", u.d, "         4.94065645841246544-324;");
+  realTest("(EN32.17,';')", u.d, "         4.94065645841246544-324;");
+  realTest("(E759.752,';')", u.d,
+      " 0."
+      "494065645841246544176568792868221372365059802614324764425585682500675507"
+      "270208751865299836361635992379796564695445717730926656710355939796398774"
+      "796010781878126300713190311404527845817167848982103688718636056998730723"
+      "050006387409153564984387312473397273169615140031715385398074126238565591"
+      "171026658556686768187039560310624931945271591492455329305456544401127480"
+      "129709999541931989409080416563324524757147869014726780159355238611550134"
+      "803526493472019379026810710749170333222684475333572083243193609238289345"
+      "836806010601150616980975307834227731832924790498252473077637592724787465"
+      "608477820373446969953364701797267771758512566055119913150489110145103786"
+      "273816725095583738973359899366480994116420570263709027924276754456522908"
+      "75386825064197182655334472656250-323;");
+  realTest("(G0,';')", u.d, ".5-323;");
+  realTest("(E757.750,';')", u.d,
+      " 0."
+      "494065645841246544176568792868221372365059802614324764425585682500675507"
+      "270208751865299836361635992379796564695445717730926656710355939796398774"
+      "796010781878126300713190311404527845817167848982103688718636056998730723"
+      "050006387409153564984387312473397273169615140031715385398074126238565591"
+      "171026658556686768187039560310624931945271591492455329305456544401127480"
+      "129709999541931989409080416563324524757147869014726780159355238611550134"
+      "803526493472019379026810710749170333222684475333572083243193609238289345"
+      "836806010601150616980975307834227731832924790498252473077637592724787465"
+      "608477820373446969953364701797267771758512566055119913150489110145103786"
+      "273816725095583738973359899366480994116420570263709027924276754456522908"
+      "753868250641971826553344726562-323;");
+  realTest("(RN,E757.750,';')", u.d,
+      " 0."
+      "494065645841246544176568792868221372365059802614324764425585682500675507"
+      "270208751865299836361635992379796564695445717730926656710355939796398774"
+      "796010781878126300713190311404527845817167848982103688718636056998730723"
+      "050006387409153564984387312473397273169615140031715385398074126238565591"
+      "171026658556686768187039560310624931945271591492455329305456544401127480"
+      "129709999541931989409080416563324524757147869014726780159355238611550134"
+      "803526493472019379026810710749170333222684475333572083243193609238289345"
+      "836806010601150616980975307834227731832924790498252473077637592724787465"
+      "608477820373446969953364701797267771758512566055119913150489110145103786"
+      "273816725095583738973359899366480994116420570263709027924276754456522908"
+      "753868250641971826553344726562-323;");
+  realTest("(RD,E757.750,';')", u.d,
+      " 0."
+      "494065645841246544176568792868221372365059802614324764425585682500675507"
+      "270208751865299836361635992379796564695445717730926656710355939796398774"
+      "796010781878126300713190311404527845817167848982103688718636056998730723"
+      "050006387409153564984387312473397273169615140031715385398074126238565591"
+      "171026658556686768187039560310624931945271591492455329305456544401127480"
+      "129709999541931989409080416563324524757147869014726780159355238611550134"
+      "803526493472019379026810710749170333222684475333572083243193609238289345"
+      "836806010601150616980975307834227731832924790498252473077637592724787465"
+      "608477820373446969953364701797267771758512566055119913150489110145103786"
+      "273816725095583738973359899366480994116420570263709027924276754456522908"
+      "753868250641971826553344726562-323;");
+  realTest("(RU,E757.750,';')", u.d,
+      " 0."
+      "494065645841246544176568792868221372365059802614324764425585682500675507"
+      "270208751865299836361635992379796564695445717730926656710355939796398774"
+      "796010781878126300713190311404527845817167848982103688718636056998730723"
+      "050006387409153564984387312473397273169615140031715385398074126238565591"
+      "171026658556686768187039560310624931945271591492455329305456544401127480"
+      "129709999541931989409080416563324524757147869014726780159355238611550134"
+      "803526493472019379026810710749170333222684475333572083243193609238289345"
+      "836806010601150616980975307834227731832924790498252473077637592724787465"
+      "608477820373446969953364701797267771758512566055119913150489110145103786"
+      "273816725095583738973359899366480994116420570263709027924276754456522908"
+      "753868250641971826553344726563-323;");
+  realTest("(RC,E757.750,';')", u.d,
+      " 0."
+      "494065645841246544176568792868221372365059802614324764425585682500675507"
+      "270208751865299836361635992379796564695445717730926656710355939796398774"
+      "796010781878126300713190311404527845817167848982103688718636056998730723"
+      "050006387409153564984387312473397273169615140031715385398074126238565591"
+      "171026658556686768187039560310624931945271591492455329305456544401127480"
+      "129709999541931989409080416563324524757147869014726780159355238611550134"
+      "803526493472019379026810710749170333222684475333572083243193609238289345"
+      "836806010601150616980975307834227731832924790498252473077637592724787465"
+      "608477820373446969953364701797267771758512566055119913150489110145103786"
+      "273816725095583738973359899366480994116420570263709027924276754456522908"
+      "753868250641971826553344726563-323;");
+
+  u.n = 0x10000000000000;  // least positive nonzero normal
+  realTest("(E723.716,';')", u.d,
+      " 0."
+      "222507385850720138309023271733240406421921598046233183055332741688720443"
+      "481391819585428315901251102056406733973103581100515243416155346010885601"
+      "238537771882113077799353200233047961014744258363607192156504694250373420"
+      "837525080665061665815894872049117996859163964850063590877011830487479978"
+      "088775374994945158045160505091539985658247081864511353793580499211598108"
+      "576605199243335211435239014879569960959128889160299264151106346631339366"
+      "347758651302937176204732563178148566435087212282863764204484681140761391"
+      "147706280168985324411002416144742161856716615054015428508471675290190316"
+      "132277889672970737312333408698898317506783884692609277397797285865965494"
+      "10913690954061364675687023986783152906809846172109246253967285156250-"
+      "307;");
+  realTest("(G0,';')", u.d, ".22250738585072014-307;");
+
+  u.n = 0x7fefffffffffffffuLL;  // greatest finite
+  realTest("(E32.17,';')", u.d, "         0.17976931348623157+309;");
+  realTest("(E317.310,';')", u.d,
+      " 0."
+      "179769313486231570814527423731704356798070567525844996598917476803157260"
+      "780028538760589558632766878171540458953514382464234321326889464182768467"
+      "546703537516986049910576551282076245490090389328944075868508455133942304"
+      "583236903222948165808559332123348274797826204144723168738177180919299881"
+      "2504040261841248583680+309;");
+  realTest("(ES317.310,';')", u.d,
+      " 1."
+      "797693134862315708145274237317043567980705675258449965989174768031572607"
+      "800285387605895586327668781715404589535143824642343213268894641827684675"
+      "467035375169860499105765512820762454900903893289440758685084551339423045"
+      "832369032229481658085593321233482747978262041447231687381771809192998812"
+      "5040402618412485836800+308;");
+  realTest("(EN319.310,';')", u.d,
+      " 179."
+      "769313486231570814527423731704356798070567525844996598917476803157260780"
+      "028538760589558632766878171540458953514382464234321326889464182768467546"
+      "703537516986049910576551282076245490090389328944075868508455133942304583"
+      "236903222948165808559332123348274797826204144723168738177180919299881250"
+      "4040261841248583680000+306;");
+  realTest("(G0,';')", u.d, ".17976931348623157+309;");
+
   if (failures == 0) {
     std::cout << "PASS\n";
   } else {

From 572a57d3d0d785bb3f2aad9e890ef498c1214309 Mon Sep 17 00:00:00 2001
From: "Jinxin (Brian) Yang" <jinxiny@nvidia.com>
Date: Wed, 5 Feb 2020 10:13:43 -0800
Subject: [PATCH 020/345] [OpenMP] Predetermined rules for loop index variables
 (#962)

This refers to three rules in OpenMP 4.5 Spec 2.15.1.1:
  * The loop iteration variable(s) in the associated do-loop(s) of a do,
    parallel do, taskloop, or distribute construct is (are) private.
  * The loop iteration variable in the associated do-loop of a simd
    construct with just one associated do-loop is linear with a linear-step
    that is the increment of the associated do-loop.
  * The loop iteration variables in the associated do-loops of a simd
    construct with multiple associated do-loops are lastprivate.

A simple example:
```
implicit none
  integer :: N = 1024
  integer i, j, k
  !$omp parallel do collapse(3)
  do i=1, N  <- i is private
     do j=1, N  <- j is private
        do k=1, N  <- k is private
        enddo
     enddo
  enddo
end
```

If `collapse` clause is not present, the associated do-loop for construct
`parallel do` is only `i` loop. With `collapse(n)`, `i`, `j`, and `k` are
all associated do-loops and the loop index variables are private to the
OpenMP construct:

```
implicit none
 !DEF: /MainProgram1/n ObjectEntity INTEGER(4)
 integer :: n = 1024
 !DEF: /MainProgram1/i ObjectEntity INTEGER(4)
 !DEF: /MainProgram1/j ObjectEntity INTEGER(4)
 !DEF: /MainProgram1/k ObjectEntity INTEGER(4)
 integer i, j, k
!$omp parallel do  collapse(3)
 !DEF: /MainProgram1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
 !REF: /MainProgram1/n
 do i=1,n
  !DEF: /MainProgram1/Block1/j (OmpPrivate) HostAssoc INTEGER(4)
  !REF: /MainProgram1/n
  do j=1,n
   !DEF: /MainProgram1/Block1/k (OmpPrivate) HostAssoc INTEGER(4)
   !REF: /MainProgram1/n
   do k=1,n
   end do
  end do
 end do
end program
```

This implementation assumes that the structural checks for do-loops
are done at this point, for example the `n` in `collapse(n)` should
be no more than the number of actual perfectly nested do-loops, etc..
---
 lib/semantics/check-omp-structure.cpp    |  43 -----
 lib/semantics/check-omp-structure.h      |  43 +++++
 lib/semantics/resolve-names.cpp          | 145 +++++++++++++++-
 test/semantics/CMakeLists.txt            |   1 +
 test/semantics/omp-clause-validity01.f90 |  10 +-
 test/semantics/omp-device-constructs.f90 |   6 +-
 test/semantics/omp-symbol01.f90          |   8 +-
 test/semantics/omp-symbol04.f90          |   2 +-
 test/semantics/omp-symbol06.f90          |   2 +-
 test/semantics/omp-symbol08.f90          | 209 +++++++++++++++++++++++
 10 files changed, 414 insertions(+), 55 deletions(-)
 create mode 100644 test/semantics/omp-symbol08.f90

diff --git a/lib/semantics/check-omp-structure.cpp b/lib/semantics/check-omp-structure.cpp
index 8d22d422e909..c8493c05b22c 100644
--- a/lib/semantics/check-omp-structure.cpp
+++ b/lib/semantics/check-omp-structure.cpp
@@ -13,49 +13,6 @@
 
 namespace Fortran::semantics {
 
-static constexpr OmpDirectiveSet parallelSet{
-    OmpDirective::DISTRIBUTE_PARALLEL_DO,
-    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::PARALLEL,
-    OmpDirective::PARALLEL_DO, OmpDirective::PARALLEL_DO_SIMD,
-    OmpDirective::PARALLEL_SECTIONS, OmpDirective::PARALLEL_WORKSHARE,
-    OmpDirective::TARGET_PARALLEL, OmpDirective::TARGET_PARALLEL_DO,
-    OmpDirective::TARGET_PARALLEL_DO_SIMD,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
-    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO,
-    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD};
-static constexpr OmpDirectiveSet doSet{OmpDirective::DISTRIBUTE_PARALLEL_DO,
-    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::PARALLEL_DO,
-    OmpDirective::PARALLEL_DO_SIMD, OmpDirective::DO, OmpDirective::DO_SIMD,
-    OmpDirective::TARGET_PARALLEL_DO, OmpDirective::TARGET_PARALLEL_DO_SIMD,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
-    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO,
-    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD};
-static constexpr OmpDirectiveSet simdSet{
-    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::DISTRIBUTE_SIMD,
-    OmpDirective::PARALLEL_DO_SIMD, OmpDirective::DO_SIMD, OmpDirective::SIMD,
-    OmpDirective::TARGET_PARALLEL_DO_SIMD,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_SIMD, OmpDirective::TARGET_SIMD,
-    OmpDirective::TASKLOOP_SIMD,
-    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
-    OmpDirective::TEAMS_DISTRIBUTE_SIMD};
-static constexpr OmpDirectiveSet doSimdSet{
-    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::PARALLEL_DO_SIMD,
-    OmpDirective::DO_SIMD, OmpDirective::TARGET_PARALLEL_DO_SIMD,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
-    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD};
-static constexpr OmpDirectiveSet taskloopSet{
-    OmpDirective::TASKLOOP, OmpDirective::TASKLOOP_SIMD};
-static constexpr OmpDirectiveSet targetSet{OmpDirective::TARGET,
-    OmpDirective::TARGET_PARALLEL, OmpDirective::TARGET_PARALLEL_DO,
-    OmpDirective::TARGET_PARALLEL_DO_SIMD, OmpDirective::TARGET_SIMD,
-    OmpDirective::TARGET_TEAMS, OmpDirective::TARGET_TEAMS_DISTRIBUTE,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
-    OmpDirective::TARGET_TEAMS_DISTRIBUTE_SIMD};
-
 std::string OmpStructureChecker::ContextDirectiveAsFortran() {
   auto dir{EnumToString(GetContext().directive)};
   std::replace(dir.begin(), dir.end(), '_', ' ');
diff --git a/lib/semantics/check-omp-structure.h b/lib/semantics/check-omp-structure.h
index cfe4a2f0cda5..b20c32550769 100644
--- a/lib/semantics/check-omp-structure.h
+++ b/lib/semantics/check-omp-structure.h
@@ -46,6 +46,49 @@ ENUM_CLASS(OmpClause, ALIGNED, COLLAPSE, COPYIN, COPYPRIVATE, DEFAULT,
 
 using OmpClauseSet = common::EnumSet<OmpClause, OmpClause_enumSize>;
 
+static constexpr OmpDirectiveSet parallelSet{
+    OmpDirective::DISTRIBUTE_PARALLEL_DO,
+    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::PARALLEL,
+    OmpDirective::PARALLEL_DO, OmpDirective::PARALLEL_DO_SIMD,
+    OmpDirective::PARALLEL_SECTIONS, OmpDirective::PARALLEL_WORKSHARE,
+    OmpDirective::TARGET_PARALLEL, OmpDirective::TARGET_PARALLEL_DO,
+    OmpDirective::TARGET_PARALLEL_DO_SIMD,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
+    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO,
+    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD};
+static constexpr OmpDirectiveSet doSet{OmpDirective::DISTRIBUTE_PARALLEL_DO,
+    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::PARALLEL_DO,
+    OmpDirective::PARALLEL_DO_SIMD, OmpDirective::DO, OmpDirective::DO_SIMD,
+    OmpDirective::TARGET_PARALLEL_DO, OmpDirective::TARGET_PARALLEL_DO_SIMD,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
+    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO,
+    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD};
+static constexpr OmpDirectiveSet doSimdSet{
+    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::PARALLEL_DO_SIMD,
+    OmpDirective::DO_SIMD, OmpDirective::TARGET_PARALLEL_DO_SIMD,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
+    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD};
+static constexpr OmpDirectiveSet taskloopSet{
+    OmpDirective::TASKLOOP, OmpDirective::TASKLOOP_SIMD};
+static constexpr OmpDirectiveSet targetSet{OmpDirective::TARGET,
+    OmpDirective::TARGET_PARALLEL, OmpDirective::TARGET_PARALLEL_DO,
+    OmpDirective::TARGET_PARALLEL_DO_SIMD, OmpDirective::TARGET_SIMD,
+    OmpDirective::TARGET_TEAMS, OmpDirective::TARGET_TEAMS_DISTRIBUTE,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_SIMD};
+static constexpr OmpDirectiveSet simdSet{
+    OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD, OmpDirective::DISTRIBUTE_SIMD,
+    OmpDirective::PARALLEL_DO_SIMD, OmpDirective::DO_SIMD, OmpDirective::SIMD,
+    OmpDirective::TARGET_PARALLEL_DO_SIMD,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
+    OmpDirective::TARGET_TEAMS_DISTRIBUTE_SIMD, OmpDirective::TARGET_SIMD,
+    OmpDirective::TASKLOOP_SIMD,
+    OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
+    OmpDirective::TEAMS_DISTRIBUTE_SIMD};
+
 class OmpStructureChecker : public virtual BaseChecker {
 public:
   OmpStructureChecker(SemanticsContext &context) : context_{context} {}
diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index 5ab1424b246f..a7b76d61843c 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -1148,6 +1148,11 @@ class OmpAttributeVisitor {
   template<typename A> bool Pre(const A &) { return true; }
   template<typename A> void Post(const A &) {}
 
+  bool Pre(const parser::SpecificationPart &x) {
+    Walk(std::get<std::list<parser::OpenMPDeclarativeConstruct>>(x.t));
+    return false;
+  }
+
   bool Pre(const parser::OpenMPBlockConstruct &);
   void Post(const parser::OpenMPBlockConstruct &) { PopContext(); }
   void Post(const parser::OmpBeginBlockDirective &) {
@@ -1199,6 +1204,7 @@ class OmpAttributeVisitor {
     // variables on Data-sharing attribute clauses
     std::map<const Symbol *, Symbol::Flag> objectWithDSA;
     bool withinConstruct{false};
+    std::size_t associatedLoopLevel{0};
   };
   // back() is the top of the stack
   OmpContext &GetContext() {
@@ -1226,6 +1232,10 @@ class OmpAttributeVisitor {
     auto it{GetContext().objectWithDSA.find(&symbol)};
     return it != GetContext().objectWithDSA.end();
   }
+  void SetContextAssociatedLoopLevel(std::size_t level) {
+    GetContext().associatedLoopLevel = level;
+  }
+  std::size_t GetAssociatedLoopLevelFromClauses(const parser::OmpClauseList &);
 
   Symbol &MakeAssocSymbol(const SourceName &name, Symbol &prev) {
     const auto pair{
@@ -1260,6 +1270,11 @@ class OmpAttributeVisitor {
   }
   bool HasDataSharingAttributeObject(const Symbol &);
 
+  const parser::DoConstruct *GetDoConstructIf(
+      const parser::ExecutionPartConstruct &);
+  // Predetermined DSA rules
+  void PrivatizeAssociatedLoopIndex(const parser::OpenMPLoopConstruct &);
+
   void ResolveOmpObjectList(const parser::OmpObjectList &, Symbol::Flag);
   void ResolveOmpObject(const parser::OmpObject &, Symbol::Flag);
   Symbol *ResolveOmp(const parser::Name &, Symbol::Flag);
@@ -5935,10 +5950,20 @@ bool OmpAttributeVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
 bool OmpAttributeVisitor::Pre(const parser::OpenMPLoopConstruct &x) {
   const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
+  const auto &clauseList{std::get<parser::OmpClauseList>(beginLoopDir.t)};
   switch (beginDir.v) {
   case parser::OmpLoopDirective::Directive::Distribute:
     PushContext(beginDir.source, OmpDirective::DISTRIBUTE);
     break;
+  case parser::OmpLoopDirective::Directive::DistributeParallelDo:
+    PushContext(beginDir.source, OmpDirective::DISTRIBUTE_PARALLEL_DO);
+    break;
+  case parser::OmpLoopDirective::Directive::DistributeParallelDoSimd:
+    PushContext(beginDir.source, OmpDirective::DISTRIBUTE_PARALLEL_DO_SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::DistributeSimd:
+    PushContext(beginDir.source, OmpDirective::DISTRIBUTE_SIMD);
+    break;
   case parser::OmpLoopDirective::Directive::Do:
     PushContext(beginDir.source, OmpDirective::DO);
     break;
@@ -5954,20 +5979,136 @@ bool OmpAttributeVisitor::Pre(const parser::OpenMPLoopConstruct &x) {
   case parser::OmpLoopDirective::Directive::Simd:
     PushContext(beginDir.source, OmpDirective::SIMD);
     break;
+  case parser::OmpLoopDirective::Directive::TargetParallelDo:
+    PushContext(beginDir.source, OmpDirective::TARGET_PARALLEL_DO);
+    break;
+  case parser::OmpLoopDirective::Directive::TargetParallelDoSimd:
+    PushContext(beginDir.source, OmpDirective::TARGET_PARALLEL_DO_SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::TargetTeamsDistribute:
+    PushContext(beginDir.source, OmpDirective::TARGET_TEAMS_DISTRIBUTE);
+    break;
+  case parser::OmpLoopDirective::Directive::TargetTeamsDistributeParallelDo:
+    PushContext(
+        beginDir.source, OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO);
+    break;
+  case parser::OmpLoopDirective::Directive::TargetTeamsDistributeParallelDoSimd:
+    PushContext(beginDir.source,
+        OmpDirective::TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::TargetTeamsDistributeSimd:
+    PushContext(beginDir.source, OmpDirective::TARGET_TEAMS_DISTRIBUTE_SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::TargetSimd:
+    PushContext(beginDir.source, OmpDirective::TARGET_SIMD);
+    break;
   case parser::OmpLoopDirective::Directive::Taskloop:
     PushContext(beginDir.source, OmpDirective::TASKLOOP);
     break;
   case parser::OmpLoopDirective::Directive::TaskloopSimd:
     PushContext(beginDir.source, OmpDirective::TASKLOOP_SIMD);
     break;
-  default:
-    // TODO others
+  case parser::OmpLoopDirective::Directive::TeamsDistribute:
+    PushContext(beginDir.source, OmpDirective::TEAMS_DISTRIBUTE);
+    break;
+  case parser::OmpLoopDirective::Directive::TeamsDistributeParallelDo:
+    PushContext(beginDir.source, OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO);
+    break;
+  case parser::OmpLoopDirective::Directive::TeamsDistributeParallelDoSimd:
+    PushContext(
+        beginDir.source, OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD);
+    break;
+  case parser::OmpLoopDirective::Directive::TeamsDistributeSimd:
+    PushContext(beginDir.source, OmpDirective::TEAMS_DISTRIBUTE_SIMD);
     break;
   }
   ClearDataSharingAttributeObjects();
+  SetContextAssociatedLoopLevel(GetAssociatedLoopLevelFromClauses(clauseList));
+  PrivatizeAssociatedLoopIndex(x);
   return true;
 }
 
+const parser::DoConstruct *OmpAttributeVisitor::GetDoConstructIf(
+    const parser::ExecutionPartConstruct &x) {
+  if (auto *y{std::get_if<parser::ExecutableConstruct>(&x.u)}) {
+    if (auto *z{std::get_if<Indirection<parser::DoConstruct>>(&y->u)}) {
+      return &z->value();
+    }
+  }
+  return nullptr;
+}
+
+std::size_t OmpAttributeVisitor::GetAssociatedLoopLevelFromClauses(
+    const parser::OmpClauseList &x) {
+  std::size_t orderedLevel{0};
+  std::size_t collapseLevel{0};
+  for (const auto &clause : x.v) {
+    if (const auto *orderedClause{
+            std::get_if<parser::OmpClause::Ordered>(&clause.u)}) {
+      if (const auto v{
+              evaluate::ToInt64(resolver_.EvaluateIntExpr(orderedClause->v))}) {
+        orderedLevel = *v;
+      }
+    }
+    if (const auto *collapseClause{
+            std::get_if<parser::OmpClause::Collapse>(&clause.u)}) {
+      if (const auto v{evaluate::ToInt64(
+              resolver_.EvaluateIntExpr(collapseClause->v))}) {
+        collapseLevel = *v;
+      }
+    }
+  }
+
+  if (orderedLevel && (!collapseLevel || orderedLevel >= collapseLevel)) {
+    return orderedLevel;
+  } else if (!orderedLevel && collapseLevel) {
+    return collapseLevel;
+  }  // orderedLevel < collapseLevel is an error handled in structural checks
+  return 1;  // default is outermost loop
+}
+
+// 2.15.1.1 Data-sharing Attribute Rules - Predetermined
+//   - The loop iteration variable(s) in the associated do-loop(s) of a do,
+//     parallel do, taskloop, or distribute construct is (are) private.
+//   - The loop iteration variable in the associated do-loop of a simd construct
+//     with just one associated do-loop is linear with a linear-step that is the
+//     increment of the associated do-loop.
+//   - The loop iteration variables in the associated do-loops of a simd
+//     construct with multiple associated do-loops are lastprivate.
+//
+// TODO: This assumes that the do-loops association for collapse/ordered
+//       clause has been performed (the number of nested do-loops >= n).
+void OmpAttributeVisitor::PrivatizeAssociatedLoopIndex(
+    const parser::OpenMPLoopConstruct &x) {
+  std::size_t level{GetContext().associatedLoopLevel};
+  Symbol::Flag ivDSA{Symbol::Flag::OmpPrivate};
+  if (simdSet.test(GetContext().directive)) {
+    if (level == 1) {
+      ivDSA = Symbol::Flag::OmpLinear;
+    } else {
+      ivDSA = Symbol::Flag::OmpLastPrivate;
+    }
+  }
+
+  auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
+  for (const parser::DoConstruct *loop{&*outer}; loop && level > 0; --level) {
+    // go through all the nested do-loops and resolve index variables
+    auto &loopControl{loop->GetLoopControl().value()};
+    using Bounds = parser::LoopControl::Bounds;
+    const Bounds &bounds{std::get<Bounds>(loopControl.u)};
+    const parser::Name &iv{bounds.name.thing};
+    if (auto *symbol{ResolveOmp(iv, ivDSA)}) {
+      iv.symbol = symbol;  // adjust the symbol within region
+      AddToContextObjectWithDSA(*symbol, ivDSA);
+    }
+
+    const auto &block{std::get<parser::Block>(loop->t)};
+    const auto it{block.begin()};
+    loop = it != block.end() ? GetDoConstructIf(*it) : nullptr;
+  }
+  CHECK(level == 0);
+}
+
 bool OmpAttributeVisitor::Pre(const parser::OpenMPSectionsConstruct &x) {
   const auto &beginSectionsDir{
       std::get<parser::OmpBeginSectionsDirective>(x.t)};
diff --git a/test/semantics/CMakeLists.txt b/test/semantics/CMakeLists.txt
index 5dfbcb2bf928..2dd11981577b 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/semantics/CMakeLists.txt
@@ -229,6 +229,7 @@ set(SYMBOL_TESTS
   omp-symbol05.f90
   omp-symbol06.f90
   omp-symbol07.f90
+  omp-symbol08.f90
   kinds01.f90
   kinds03.f90
   procinterface01.f90
diff --git a/test/semantics/omp-clause-validity01.f90 b/test/semantics/omp-clause-validity01.f90
index 08abc1f032ce..d624564cd20b 100644
--- a/test/semantics/omp-clause-validity01.f90
+++ b/test/semantics/omp-clause-validity01.f90
@@ -43,7 +43,9 @@
   !ERROR: COLLAPSE clause is not allowed on the PARALLEL directive
   !$omp parallel collapse(2)
   do i = 1, N
-     a = 3.14
+     do j = 1, N
+        a = 3.14
+     enddo
   enddo
   !$omp end parallel
 
@@ -143,7 +145,7 @@
   enddo
 
   !ERROR: The parameter of the ORDERED clause must be greater than or equal to the parameter of the COLLAPSE clause
-  !$omp do collapse(num) ordered(1+2+3+4)
+  !$omp do collapse(num-14) ordered(1)
   do i = 1, N
      do j = 1, N
         do k = 1, N
@@ -309,7 +311,9 @@
   !ERROR: NOGROUP clause is not allowed on the DO SIMD directive
   !$omp do simd ordered(2) NOGROUP
   do i = 1, N
-     a = 3.14
+     do j = 1, N
+        a = 3.14
+     enddo
   enddo
   !$omp end parallel
 
diff --git a/test/semantics/omp-device-constructs.f90 b/test/semantics/omp-device-constructs.f90
index 118e49c9afc9..e87cb119dba4 100644
--- a/test/semantics/omp-device-constructs.f90
+++ b/test/semantics/omp-device-constructs.f90
@@ -149,7 +149,11 @@ program main
   !ERROR: At most one COLLAPSE clause can appear on the DISTRIBUTE directive
   !$omp distribute collapse(2) collapse(3)
   do i = 1, N
-     a = 3.14
+     do j = 1, N
+        do k = 1, N
+           a = 3.14
+        enddo
+     enddo
   enddo
   !$omp end distribute
   !$omp end target
diff --git a/test/semantics/omp-symbol01.f90 b/test/semantics/omp-symbol01.f90
index 2286bcc5a35e..eca885565fba 100644
--- a/test/semantics/omp-symbol01.f90
+++ b/test/semantics/omp-symbol01.f90
@@ -45,21 +45,21 @@ program mm
  !DEF: /mm/c (Implicit) ObjectEntity REAL(4)
  c = 2.0
 !$omp parallel do  private(a,t,/c/) shared(c)
- !DEF: /mm/i (Implicit) ObjectEntity INTEGER(4)
+ !DEF: /mm/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
  do i=1,10
   !DEF: /mm/Block1/a (OmpPrivate) HostAssoc REAL(4)
   !REF: /mm/b
-  !REF: /mm/i
+  !REF: /mm/Block1/i
   a = a+b(i)
   !DEF: /mm/Block1/t (OmpPrivate) HostAssoc TYPE(myty)
   !REF: /md/myty/a
-  !REF: /mm/i
+  !REF: /mm/Block1/i
   t%a = i
   !DEF: /mm/Block1/y (OmpPrivate) HostAssoc REAL(4)
   y = 0.
   !DEF: /mm/Block1/x (OmpPrivate) HostAssoc REAL(4)
   !REF: /mm/Block1/a
-  !REF: /mm/i
+  !REF: /mm/Block1/i
   !REF: /mm/Block1/y
   x = a+i+y
   !REF: /mm/c
diff --git a/test/semantics/omp-symbol04.f90 b/test/semantics/omp-symbol04.f90
index d97768d9396c..9daacfb49854 100644
--- a/test/semantics/omp-symbol04.f90
+++ b/test/semantics/omp-symbol04.f90
@@ -12,7 +12,7 @@
   !DEF: /MainProgram1/Block1/a (OmpPrivate) HostAssoc REAL(8)
   a = 2.
   !$omp do  private(a)
-  !DEF: /MainProgram1/i (Implicit) ObjectEntity INTEGER(4)
+  !DEF: /MainProgram1/Block1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
   do i=1,10
      !DEF: /MainProgram1/Block1/Block1/a (OmpPrivate) HostAssoc REAL(8)
      a = 1.
diff --git a/test/semantics/omp-symbol06.f90 b/test/semantics/omp-symbol06.f90
index d343d084c44d..3b82fc88e598 100644
--- a/test/semantics/omp-symbol06.f90
+++ b/test/semantics/omp-symbol06.f90
@@ -8,7 +8,7 @@
   !DEF: /MainProgram1/a (Implicit) ObjectEntity REAL(4)
   a = 1.
   !$omp parallel do  firstprivate(a) lastprivate(a)
-  !DEF: /MainProgram1/i (Implicit) ObjectEntity INTEGER(4)
+  !DEF: /MainProgram1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
   do i=1,10
      !DEF: /MainProgram1/Block1/a (OmpFirstPrivate, OmpLastPrivate) HostAssoc REAL(4)
      a = 2.
diff --git a/test/semantics/omp-symbol08.f90 b/test/semantics/omp-symbol08.f90
new file mode 100644
index 000000000000..eaf8ff2eaa9d
--- /dev/null
+++ b/test/semantics/omp-symbol08.f90
@@ -0,0 +1,209 @@
+!OPTIONS: -fopenmp
+
+! 2.15.1.1 Predetermined rules for associated do-loops index variable
+!   a) The loop iteration variable(s) in the associated do-loop(s) of a do,
+!      parallel do, taskloop, or distribute construct is (are) private.
+!   b) The loop iteration variable in the associated do-loop of a simd construct
+!      with just one associated do-loop is linear with a linear-step that is the
+!      increment of the associated do-loop.
+!   c) The loop iteration variables in the associated do-loops of a simd
+!      construct with multiple associated do-loops are lastprivate.
+!   - TBD
+
+! All the tests assume that the do-loops association for collapse/ordered
+! clause has been performed (the number of nested do-loops >= n).
+
+! Rule a)
+! TODO: nested constructs (k should be private too)
+!DEF: /test_do (Subroutine) Subprogram
+subroutine test_do
+ implicit none
+ !DEF: /test_do/a ObjectEntity REAL(4)
+ real a(20,20,20)
+ !DEF: /test_do/i ObjectEntity INTEGER(4)
+ !DEF: /test_do/j ObjectEntity INTEGER(4)
+ !DEF: /test_do/k ObjectEntity INTEGER(4)
+ integer i, j, k
+!$omp parallel
+ !REF: /test_do/i
+ i = 99
+!$omp do  collapse(2)
+ !DEF: /test_do/Block1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+ do i=1,5
+  !DEF: /test_do/Block1/Block1/j (OmpPrivate) HostAssoc INTEGER(4)
+  do j=6,10
+   !REF: /test_do/a
+   a(1,1,1) = 0.
+   !REF: /test_do/k
+   do k=11,15
+    !REF: /test_do/a
+    !REF: /test_do/k
+    !REF: /test_do/Block1/Block1/j
+    !REF: /test_do/Block1/Block1/i
+    a(k,j,i) = 1.
+   end do
+  end do
+ end do
+!$omp end parallel
+end subroutine test_do
+
+! Rule a)
+!DEF: /test_pardo (Subroutine) Subprogram
+subroutine test_pardo
+ implicit none
+ !DEF: /test_pardo/a ObjectEntity REAL(4)
+ real a(20,20,20)
+ !DEF: /test_pardo/i ObjectEntity INTEGER(4)
+ !DEF: /test_pardo/j ObjectEntity INTEGER(4)
+ !DEF: /test_pardo/k ObjectEntity INTEGER(4)
+ integer i, j, k
+!$omp parallel do  collapse(2) private(k) ordered(2)
+ !DEF: /test_pardo/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+ do i=1,5
+  !DEF: /test_pardo/Block1/j (OmpPrivate) HostAssoc INTEGER(4)
+  do j=6,10
+   !REF: /test_pardo/a
+   a(1,1,1) = 0.
+   !DEF: /test_pardo/Block1/k (OmpPrivate) HostAssoc INTEGER(4)
+   do k=11,15
+    !REF: /test_pardo/a
+    !REF: /test_pardo/Block1/k
+    !REF: /test_pardo/Block1/j
+    !REF: /test_pardo/Block1/i
+    a(k,j,i) = 1.
+   end do
+  end do
+ end do
+end subroutine test_pardo
+
+! Rule a)
+!DEF: /test_taskloop (Subroutine) Subprogram
+subroutine test_taskloop
+ implicit none
+ !DEF: /test_taskloop/a ObjectEntity REAL(4)
+ real a(5,5)
+ !DEF: /test_taskloop/i ObjectEntity INTEGER(4)
+ !DEF: /test_taskloop/j ObjectEntity INTEGER(4)
+ integer i, j
+!$omp taskloop  private(j)
+ !DEF: /test_taskloop/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+ do i=1,5
+  !DEF: /test_taskloop/Block1/j (OmpPrivate) HostAssoc INTEGER(4)
+  !REF: /test_taskloop/Block1/i
+  do j=1,i
+   !REF: /test_taskloop/a
+   !REF: /test_taskloop/Block1/j
+   !REF: /test_taskloop/Block1/i
+   a(j,i) = 3.14
+  end do
+ end do
+!$omp end taskloop
+end subroutine test_taskloop
+
+! Rule a); OpenMP 4.5 Examples teams.2.f90
+! TODO: reduction; data-mapping attributes
+!DEF: /dotprod (Subroutine) Subprogram
+!DEF: /dotprod/b ObjectEntity REAL(4)
+!DEF: /dotprod/c ObjectEntity REAL(4)
+!DEF: /dotprod/n ObjectEntity INTEGER(4)
+!DEF: /dotprod/block_size ObjectEntity INTEGER(4)
+!DEF: /dotprod/num_teams ObjectEntity INTEGER(4)
+!DEF: /dotprod/block_threads ObjectEntity INTEGER(4)
+subroutine dotprod (b, c, n, block_size, num_teams, block_threads)
+ implicit none
+ !REF: /dotprod/n
+ integer n
+ !REF: /dotprod/b
+ !REF: /dotprod/n
+ !REF: /dotprod/c
+ !DEF: /dotprod/sum ObjectEntity REAL(4)
+ real b(n), c(n), sum
+ !REF: /dotprod/block_size
+ !REF: /dotprod/num_teams
+ !REF: /dotprod/block_threads
+ !DEF: /dotprod/i ObjectEntity INTEGER(4)
+ !DEF: /dotprod/i0 ObjectEntity INTEGER(4)
+ integer block_size, num_teams, block_threads, i, i0
+ !REF: /dotprod/sum
+ sum = 0.0e0
+!$omp target  map(to:b,c)  map(tofrom:sum)
+!$omp teams  num_teams(num_teams) thread_limit(block_threads) reduction(+:sum)
+!$omp distribute
+ !DEF: /dotprod/Block1/Block1/Block1/i0 (OmpPrivate) HostAssoc INTEGER(4)
+ !REF: /dotprod/n
+ !REF: /dotprod/block_size
+ do i0=1,n,block_size
+!$omp parallel do  reduction(+:sum)
+  !DEF: /dotprod/Block1/Block1/Block1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+  !REF: /dotprod/i0
+  !DEF: /dotprod/min INTRINSIC (Function) ProcEntity
+  !REF: /dotprod/block_size
+  !REF: /dotprod/n
+  do i=i0,min(i0+block_size, n)
+   !REF: /dotprod/sum
+   !REF: /dotprod/b
+   !REF: /dotprod/Block1/Block1/Block1/Block1/i
+   !REF: /dotprod/c
+   sum = sum+b(i)*c(i)
+  end do
+ end do
+!$omp end teams
+!$omp end target
+ !REF: /dotprod/sum
+ print *, sum
+end subroutine dotprod
+
+! Rule b)
+! TODO: nested constructs (j, k should be private too)
+!DEF: /test_simd (Subroutine) Subprogram
+subroutine test_simd
+ implicit none
+ !DEF: /test_simd/a ObjectEntity REAL(4)
+ real a(20,20,20)
+ !DEF: /test_simd/i ObjectEntity INTEGER(4)
+ !DEF: /test_simd/j ObjectEntity INTEGER(4)
+ !DEF: /test_simd/k ObjectEntity INTEGER(4)
+ integer i, j, k
+!$omp parallel do simd
+ !DEF: /test_simd/Block1/i (OmpLinear) HostAssoc INTEGER(4)
+ do i=1,5
+  !REF: /test_simd/j
+  do j=6,10
+   !REF: /test_simd/k
+   do k=11,15
+    !REF: /test_simd/a
+    !REF: /test_simd/k
+    !REF: /test_simd/j
+    !REF: /test_simd/Block1/i
+    a(k,j,i) = 3.14
+   end do
+  end do
+ end do
+end subroutine test_simd
+
+! Rule c)
+!DEF: /test_simd_multi (Subroutine) Subprogram
+subroutine test_simd_multi
+ implicit none
+ !DEF: /test_simd_multi/a ObjectEntity REAL(4)
+ real a(20,20,20)
+ !DEF: /test_simd_multi/i ObjectEntity INTEGER(4)
+ !DEF: /test_simd_multi/j ObjectEntity INTEGER(4)
+ !DEF: /test_simd_multi/k ObjectEntity INTEGER(4)
+ integer i, j, k
+!$omp parallel do simd  collapse(3)
+ !DEF: /test_simd_multi/Block1/i (OmpLastPrivate) HostAssoc INTEGER(4)
+ do i=1,5
+  !DEF: /test_simd_multi/Block1/j (OmpLastPrivate) HostAssoc INTEGER(4)
+  do j=6,10
+   !DEF: /test_simd_multi/Block1/k (OmpLastPrivate) HostAssoc INTEGER(4)
+   do k=11,15
+    !REF: /test_simd_multi/a
+    !REF: /test_simd_multi/Block1/k
+    !REF: /test_simd_multi/Block1/j
+    !REF: /test_simd_multi/Block1/i
+    a(k,j,i) = 3.14
+   end do
+  end do
+ end do
+end subroutine test_simd_multi

From a1a95bfcd1811d697f1386fe57af664b8a16ffb5 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Thu, 6 Feb 2020 12:26:51 -0800
Subject: [PATCH 021/345] Semantic checks for C702 C702 (R701) A colon shall
 not be used as a type-param-value except in the declaration of an entity that
 has the POINTER or ALLOCATABLE attribute.

I added code to the visitor for a TypeDeclarationStmt to check for the
'LEN' type parameter for strings and to loop over the type parameters
for derived types.

I also ran into a few situations where previous tests had erroneously
used a colon for type parameters without either the POINTER or
ALLOCATABLE attribute and fixed them up.
---
 lib/semantics/resolve-names.cpp |  27 +++++++++++++++++--
 test/evaluate/folding05.f90     | Bin 9530 -> 9530 bytes
 test/semantics/CMakeLists.txt   |   1 +
 test/semantics/allocate03.f90   |   2 +-
 test/semantics/allocate09.f90   |   8 +++---
 test/semantics/modfile28.f90    |  12 ++++-----
 test/semantics/resolve37.f90    |   2 ++
 test/semantics/resolve69.f90    |  45 ++++++++++++++++++++++++++++++++
 8 files changed, 84 insertions(+), 13 deletions(-)
 create mode 100644 test/semantics/resolve69.f90

diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index a7b76d61843c..a964f85943a1 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -720,7 +720,7 @@ class DeclarationVisitor : public ArraySpecVisitor,
   void Post(const parser::DimensionStmt::Declaration &);
   void Post(const parser::CodimensionDecl &);
   bool Pre(const parser::TypeDeclarationStmt &) { return BeginDecl(); }
-  void Post(const parser::TypeDeclarationStmt &) { EndDecl(); }
+  void Post(const parser::TypeDeclarationStmt &);
   void Post(const parser::IntegerTypeSpec &);
   void Post(const parser::IntrinsicTypeSpec::Real &);
   void Post(const parser::IntrinsicTypeSpec::Complex &);
@@ -2889,6 +2889,29 @@ bool DeclarationVisitor::CheckAccessibleComponent(
   return false;
 }
 
+void DeclarationVisitor::Post(const parser::TypeDeclarationStmt &) {
+  if (!GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {  // C702
+    if (const auto *typeSpec{GetDeclTypeSpec()}) {
+      if (typeSpec->category() == DeclTypeSpec::Character) {
+        if (typeSpec->characterTypeSpec().length().isDeferred()) {
+          Say("The type parameter LEN cannot be deferred without"
+              " the POINTER or ALLOCATABLE attribute"_err_en_US);
+        }
+      } else if (const DerivedTypeSpec * derivedSpec{typeSpec->AsDerived()}) {
+        for (const auto &pair : derivedSpec->parameters()) {
+          if (pair.second.isDeferred()) {
+            Say(currStmtSource().value(),
+                "The value of type parameter '%s' cannot be deferred"
+                " without the POINTER or ALLOCATABLE attribute"_err_en_US,
+                pair.first);
+          }
+        }
+      }
+    }
+  }
+  EndDecl();
+}
+
 void DeclarationVisitor::Post(const parser::DimensionStmt::Declaration &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   DeclareObjectEntity(name, Attrs{});
@@ -3522,7 +3545,7 @@ bool DeclarationVisitor::Pre(const parser::DataComponentDefStmt &x) {
   // so POINTER & ALLOCATABLE enable forward references to derived types.
   Walk(std::get<std::list<parser::ComponentAttrSpec>>(x.t));
   set_allowForwardReferenceToDerivedType(
-      GetAttrs().test(Attr::POINTER) || GetAttrs().test(Attr::ALLOCATABLE));
+      GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE}));
   Walk(std::get<parser::DeclarationTypeSpec>(x.t));
   set_allowForwardReferenceToDerivedType(false);
   Walk(std::get<std::list<parser::ComponentDecl>>(x.t));
diff --git a/test/evaluate/folding05.f90 b/test/evaluate/folding05.f90
index d6d8a45673822b31959a962829fd3a147889a315..5e5e5c576976724256e3c150f56be5df2efaf023 100644
GIT binary patch
delta 35
mcmdnxwaaV6NoGc^&8L_rG6Ja>)*3b-b(7l>Bq+@<F9rbRT?)nk

delta 35
mcmdnxwaaV6NoGc?&8L_rG6Ja>)*3b-b(7l>Bq+@<F9rbVeG3Kv

diff --git a/test/semantics/CMakeLists.txt b/test/semantics/CMakeLists.txt
index 2dd11981577b..c69569bc33e3 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/semantics/CMakeLists.txt
@@ -99,6 +99,7 @@ set(ERROR_TESTS
   resolve66.f90
   resolve67.f90
   resolve68.f90
+  resolve69.f90
   stop01.f90
   structconst01.f90
   structconst02.f90
diff --git a/test/semantics/allocate03.f90 b/test/semantics/allocate03.f90
index dcdb2d5d4312..f86b44ceca2e 100644
--- a/test/semantics/allocate03.f90
+++ b/test/semantics/allocate03.f90
@@ -34,7 +34,7 @@ subroutine C933_a(b1, ca3, ca4, cp3, cp3mold, cp4, cp7, cp8, bsrc)
   type(SomeType(1, l1=3)), pointer :: cp9, cp10(:)
 
   type(B(*)) b1
-  type(B(:)) b2
+  type(B(:)), allocatable :: b2
   type(B(5)) b3
 
   type(SomeType(4, *, 8)) bsrc
diff --git a/test/semantics/allocate09.f90 b/test/semantics/allocate09.f90
index ca83b685675f..49736f905743 100644
--- a/test/semantics/allocate09.f90
+++ b/test/semantics/allocate09.f90
@@ -26,12 +26,12 @@ subroutine C946(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
   real(kind=8) srcx8, srcx8_array(10)
   class(WithParam(4, 2)) src_a_4_2
   type(WithParam(8, 2)) src_a_8_2
-  class(WithParam(4, :)) src_a_4_def
-  class(WithParam(8, :)) src_a_8_def
+  class(WithParam(4, :)), allocatable :: src_a_4_def
+  class(WithParam(8, :)), allocatable :: src_a_8_def
   type(WithParamExtent(4, 2, 8, 3)) src_b_4_2_8_3
-  class(WithParamExtent(4, :, 8, 3)) src_b_4_def_8_3
+  class(WithParamExtent(4, :, 8, 3)), allocatable :: src_b_4_def_8_3
   type(WithParamExtent(8, 2, 8, 3)) src_b_8_2_8_3
-  class(WithParamExtent(8, :, 8, 3)) src_b_8_def_8_3
+  class(WithParamExtent(8, :, 8, 3)), allocatable :: src_b_8_def_8_3
   type(WithParamExtent2(k1=4, l1=5, k2=5, l2=6, l3=8 )) src_c_4_5_5_6_8_8
   class(WithParamExtent2(k1=4, l1=2, k2=5, l2=6, k3=5, l3=8)) src_c_4_2_5_6_5_8
   class(WithParamExtent2(k2=5, l2=6, k3=5, l3=8)) src_c_1_2_5_6_5_8
diff --git a/test/semantics/modfile28.f90 b/test/semantics/modfile28.f90
index 12c17b1184f9..c53ab04dfc2d 100644
--- a/test/semantics/modfile28.f90
+++ b/test/semantics/modfile28.f90
@@ -3,20 +3,20 @@
 ! Note: Module files are encoded in UTF-8.
 
 module m
-character(kind=4,len=:), parameter :: c4 = 4_"Hi! 你好!"
+character(kind=4,len=*), parameter :: c4 = 4_"Hi! 你好!"
 ! In CHARACTER(1) literals, codepoints > 0xff are serialized into UTF-8;
 ! each of those bytes then gets encoded into UTF-8 for the module file.
-character(kind=1,len=:), parameter :: c1 = 1_"Hi! 你好!"
-character(kind=4,len=:), parameter :: c4a(*) = [4_"一", 4_"二", 4_"三", 4_"四", 4_"五"]
+character(kind=1,len=*), parameter :: c1 = 1_"Hi! 你好!"
+character(kind=4,len=*), parameter :: c4a(*) = [4_"一", 4_"二", 4_"三", 4_"四", 4_"五"]
 integer, parameter :: lc4 = len(c4)
 integer, parameter :: lc1 = len(c1)
 end module m
 
 !Expect: m.mod
 !module m
-!character(:,4),parameter::c4=4_"Hi! \344\275\240\345\245\275!"
-!character(:,1),parameter::c1=1_"Hi! \344\275\240\345\245\275!"
-!character(:,4),parameter::c4a(1_8:*)=[CHARACTER(KIND=4,LEN=1)::4_"\344\270\200",4_"\344\272\214",4_"\344\270\211",4_"\345\233\233",4_"\344\272\224"]
+!character(*,4),parameter::c4=4_"Hi! \344\275\240\345\245\275!"
+!character(*,1),parameter::c1=1_"Hi! \344\275\240\345\245\275!"
+!character(*,4),parameter::c4a(1_8:*)=[CHARACTER(KIND=4,LEN=1)::4_"\344\270\200",4_"\344\272\214",4_"\344\270\211",4_"\345\233\233",4_"\344\272\224"]
 !integer(4),parameter::lc4=7_4
 !intrinsic::len
 !integer(4),parameter::lc1=11_4
diff --git a/test/semantics/resolve37.f90 b/test/semantics/resolve37.f90
index e2d5f124bed4..a33e3700a932 100644
--- a/test/semantics/resolve37.f90
+++ b/test/semantics/resolve37.f90
@@ -1,3 +1,5 @@
+! C701 The type-param-value for a kind type parameter shall be a constant
+! expression.  This constraint looks like a mistake in the standard.
 integer, parameter :: k = 8
 real, parameter :: l = 8.0
 integer :: n = 2
diff --git a/test/semantics/resolve69.f90 b/test/semantics/resolve69.f90
new file mode 100644
index 000000000000..5950f66e4741
--- /dev/null
+++ b/test/semantics/resolve69.f90
@@ -0,0 +1,45 @@
+subroutine s1()
+  ! C701 (R701) The type-param-value for a kind type parameter shall be a
+  ! constant expression.
+  ! C702 (R701) A colon shall not be used as a type-param-value except in the 
+  ! declaration of an entity that has the POINTER or ALLOCATABLE attribute.
+  integer, parameter :: constVal = 1
+  integer :: nonConstVal = 1
+!ERROR: Invalid specification expression: reference to local entity 'nonconstval'
+  character(nonConstVal) :: colonString1
+  character(len=20, kind=constVal + 1) :: constKindString
+  character(len=:, kind=constVal + 1), pointer :: constKindString1
+!ERROR: The type parameter LEN cannot be deferred without the POINTER or ALLOCATABLE attribute
+  character(len=:, kind=constVal + 1) :: constKindString2
+!ERROR: Must be a constant value
+  character(len=20, kind=nonConstVal) :: nonConstKindString
+!ERROR: The type parameter LEN cannot be deferred without the POINTER or ALLOCATABLE attribute
+  character(len=:) :: deferredString
+!ERROR: The type parameter LEN cannot be deferred without the POINTER or ALLOCATABLE attribute
+  character(:) :: colonString2
+  !OK because of the allocatable attribute
+  character(:), allocatable :: colonString3
+
+  type derived(typeKind, typeLen)
+    integer, kind :: typeKind
+    integer, len :: typeLen
+  end type derived
+
+  type (derived(constVal, 3)) :: constDerivedKind
+!ERROR: Value of kind type parameter 'typekind' (nonconstval) is not a scalar INTEGER constant
+!ERROR: Invalid specification expression: reference to local entity 'nonconstval'
+  type (derived(nonConstVal, 3)) :: nonConstDerivedKind
+
+  !OK because all type-params are constants
+  type (derived(3, constVal)) :: constDerivedLen
+
+!ERROR: Invalid specification expression: reference to local entity 'nonconstval'
+  type (derived(3, nonConstVal)) :: nonConstDerivedLen
+!ERROR: The value of type parameter 'typelen' cannot be deferred without the POINTER or ALLOCATABLE attribute
+  type (derived(3, :)) :: colonDerivedLen
+!ERROR: The value of type parameter 'typekind' cannot be deferred without the POINTER or ALLOCATABLE attribute
+!ERROR: The value of type parameter 'typelen' cannot be deferred without the POINTER or ALLOCATABLE attribute
+  type (derived( :, :)) :: colonDerivedLen1
+  type (derived( :, :)), pointer :: colonDerivedLen2
+  type (derived(4, :)), pointer :: colonDerivedLen3
+end subroutine s1

From 16543d22f74e9421ecb4078818f4c1970bac0a5d Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 6 Feb 2020 03:27:36 -0800
Subject: [PATCH 022/345] Fix issues comming from clang-10 warnings

- Remove SubprogramDetails copy ctor
- Prevent copies in range based loops over symbols
- Remove unsued var
---
 include/flang/semantics/symbol.h | 4 ----
 lib/semantics/mod-file.cpp       | 4 ++--
 lib/semantics/resolve-labels.cpp | 2 +-
 lib/semantics/resolve-names.cpp  | 2 +-
 lib/semantics/semantics.cpp      | 2 +-
 runtime/buffer.h                 | 1 -
 6 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/include/flang/semantics/symbol.h b/include/flang/semantics/symbol.h
index faef1ca7af2b..a27a935bdb00 100644
--- a/include/flang/semantics/symbol.h
+++ b/include/flang/semantics/symbol.h
@@ -52,10 +52,6 @@ class MainProgramDetails {
 
 class SubprogramDetails {
 public:
-  SubprogramDetails() {}
-  SubprogramDetails(const SubprogramDetails &that)
-    : dummyArgs_{that.dummyArgs_}, result_{that.result_} {}
-
   bool isFunction() const { return result_ != nullptr; }
   bool isInterface() const { return isInterface_; }
   void set_isInterface(bool value = true) { isInterface_ = value; }
diff --git a/lib/semantics/mod-file.cpp b/lib/semantics/mod-file.cpp
index 857c52b2b461..1f89c56e9870 100644
--- a/lib/semantics/mod-file.cpp
+++ b/lib/semantics/mod-file.cpp
@@ -915,10 +915,10 @@ void SubprogramSymbolCollector::DoType(const DeclTypeSpec *type) {
       if (const DerivedTypeSpec * extends{typeSymbol.GetParentTypeSpec()}) {
         DoSymbol(extends->name(), extends->typeSymbol());
       }
-      for (const auto pair : derived->parameters()) {
+      for (const auto &pair : derived->parameters()) {
         DoParamValue(pair.second);
       }
-      for (const auto pair : *typeSymbol.scope()) {
+      for (const auto &pair : *typeSymbol.scope()) {
         const Symbol &comp{*pair.second};
         DoSymbol(comp);
       }
diff --git a/lib/semantics/resolve-labels.cpp b/lib/semantics/resolve-labels.cpp
index 87cacb8376c3..723762706a85 100644
--- a/lib/semantics/resolve-labels.cpp
+++ b/lib/semantics/resolve-labels.cpp
@@ -824,7 +824,7 @@ void CheckBranchesIntoDoBody(const SourceStmtList &branches,
     if (HasScope(branchTarget.proxyForScope)) {
       const auto &fromPosition{branch.parserCharBlock};
       const auto &toPosition{branchTarget.parserCharBlock};
-      for (const auto body : loopBodies) {
+      for (const auto &body : loopBodies) {
         if (!InBody(fromPosition, body) && InBody(toPosition, body)) {
           context.Say(fromPosition, "branch into loop body from outside"_en_US)
               .Attach(body.first, "the loop branched into"_en_US);
diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index a964f85943a1..197a32b4fee2 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -4099,7 +4099,7 @@ void DeclarationVisitor::SetSaveAttr(Symbol &symbol) {
 // Check types of common block objects, now that they are known.
 void DeclarationVisitor::CheckCommonBlocks() {
   // check for empty common blocks
-  for (const auto pair : currScope().commonBlocks()) {
+  for (const auto &pair : currScope().commonBlocks()) {
     const auto &symbol{*pair.second};
     if (symbol.get<CommonBlockDetails>().objects().empty() &&
         symbol.attrs().test(Attr::BIND_C)) {
diff --git a/lib/semantics/semantics.cpp b/lib/semantics/semantics.cpp
index 1f9958e08469..8c5bece6f72e 100644
--- a/lib/semantics/semantics.cpp
+++ b/lib/semantics/semantics.cpp
@@ -294,7 +294,7 @@ void Semantics::DumpSymbols(std::ostream &os) {
 void Semantics::DumpSymbolsSources(std::ostream &os) const {
   NameToSymbolMap symbols;
   GetSymbolNames(context_.globalScope(), symbols);
-  for (const auto pair : symbols) {
+  for (const auto &pair : symbols) {
     const Symbol &symbol{pair.second};
     if (auto sourceInfo{cooked_.GetSourcePositionRange(symbol.name())}) {
       os << symbol.name().ToString() << ": " << sourceInfo->first.file.path()
diff --git a/runtime/buffer.h b/runtime/buffer.h
index a7b31848df8d..ec39bacd6ec6 100644
--- a/runtime/buffer.h
+++ b/runtime/buffer.h
@@ -66,7 +66,6 @@ template<typename STORE> class FileFrame {
         } else {
           // [cde........ab] -> [abcde........]
           auto n{start_ + length_ - size_};  // 3 for cde
-          auto gap{size_ - length_};  // 13 - 5 = 8
           RUNTIME_CHECK(handler, length_ >= n);
           std::memmove(buffer_ + n, buffer_ + start_, length_ - n);  // cdeab
           LeftShiftBufferCircularly(buffer_, length_, n);  // abcde

From c342575a9e0217fa3252b70b8ef3eac0236a58e3 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Mon, 10 Feb 2020 10:55:24 -0800
Subject: [PATCH 023/345] Fix compilation error on macOS

The call to `std::min` failed to compile with GCC on macOS due to type
inference because `std::size_t` is `long unsigned int` but `std::int64_t`
is `long long int`.
---
 runtime/buffer.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/runtime/buffer.h b/runtime/buffer.h
index a7b31848df8d..8a1fd9b39df5 100644
--- a/runtime/buffer.h
+++ b/runtime/buffer.h
@@ -41,8 +41,7 @@ template<typename STORE> class FileFrame {
   FileOffset FrameAt() const { return fileOffset_ + frame_; }
   char *Frame() const { return buffer_ + start_ + frame_; }
   std::size_t FrameLength() const {
-    return std::min(
-        static_cast<std::size_t>(length_ - frame_), size_ - (start_ + frame_));
+    return std::min<std::size_t>(length_ - frame_, size_ - (start_ + frame_));
   }
 
   // Returns a short frame at a non-fatal EOF.  Can return a long frame as well.

From 75adddd504577a295f0c906aa049bd47ce2b4f2e Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Mon, 3 Feb 2020 10:31:30 -0800
Subject: [PATCH 024/345] Updated the description of `evaluate::Expr` types

---
 documentation/ImplementingASemanticCheck.md | 23 ++++++++++-----------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/documentation/ImplementingASemanticCheck.md b/documentation/ImplementingASemanticCheck.md
index cc5ff7f62667..736202abaa1f 100644
--- a/documentation/ImplementingASemanticCheck.md
+++ b/documentation/ImplementingASemanticCheck.md
@@ -214,22 +214,21 @@ existing framework used in DO construct semantic checking that traversed an
 be able to use a similar framework to traverse an `evaluate::Expr`  node to
 find all of the `evaluate::ActualArgument` nodes.  
 
-Note that there are two distinct data types in the compiler called `Expr`.  One
-is in the `parser` namespace.  `parser::Expr` is defined in the file
+Note that the compiler has multiple types called `Expr`.  One is in the
+`parser` namespace.  `parser::Expr` is defined in the file
 `include/flang/parser/parse-tree.h`.  It represents a parsed expression that
 maps directly to the source code and has fields that specify any operators in
 the expression, the operands, and the source position of the expression.
 
-The second `Expr` type is in the `evaluate` namespace.   The `evaluate`
-namespace contains many types associated with semantic checking of expressions.
-`evaluate::Expr` is defined in the file `include/flang/evaluate/expression.h`.
-It represents an expression after it has undergone semantic checking and
-contains information that is only available after semantic analysis.  This
-information includes the Fortran type of the expression, whether it's a
-reference to a function, whether it's an actual argument, etc.  After an
-expression has undergone semantic analysis, the field `typedExpr` in the
-`parser::Expr` node is filled in with a pointer to the analyzed expression in
-`evaluate::Expr`.
+Additionally, in the namespace `evaluate`, there are `evaluate::Expr<T>`
+template classes defined in the file `include/flang/evaluate/expression.h`.
+These are parameterized over the various types of Fortran and constitute a
+suite of strongly-typed representations of valid Fortran expressions of type
+`T` that have been fully elaborated with conversion operations and subjected to
+constant folding.  After an expression has undergone semantic analysis, the
+field `typedExpr` in the `parser::Expr` node is filled in with a pointer that
+owns an instance of `evaluate::Expr<SomeType>`, the most general representation
+of an analyzed expression.
 
 All of the declarations associated with both FUNCTION and SUBROUTINE calls are
 in `include/flang/evaluate/call.h`.  An `evaluate::FunctionRef` inherits from

From 49a64c4c2374e930f6890b270289a6f49ba63edd Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Mon, 10 Feb 2020 13:24:32 -0800
Subject: [PATCH 025/345] Semantic checks for constraints on types I
 implemented and added tests for constraints C703, C704, C705, C706, and C796.
  In some cases, the code and/or test already existed, and all I did was add a
 notation indicating the associated constraint.

---
 lib/semantics/check-declarations.cpp |  2 +-
 lib/semantics/resolve-names.cpp      | 33 ++++++++++++++--
 test/semantics/CMakeLists.txt        |  1 +
 test/semantics/allocate04.f90        |  2 +-
 test/semantics/resolve52.f90         |  1 +
 test/semantics/resolve69.f90         |  9 +++++
 test/semantics/resolve70.f90         | 58 ++++++++++++++++++++++++++++
 test/semantics/structconst01.f90     |  4 +-
 8 files changed, 103 insertions(+), 7 deletions(-)
 create mode 100644 test/semantics/resolve70.f90

diff --git a/lib/semantics/check-declarations.cpp b/lib/semantics/check-declarations.cpp
index a96bc6fb056b..7cd81c91c348 100644
--- a/lib/semantics/check-declarations.cpp
+++ b/lib/semantics/check-declarations.cpp
@@ -495,7 +495,7 @@ void CheckHelper::CheckDerivedType(
   }
   if (const DeclTypeSpec * parent{FindParentTypeSpec(symbol)}) {
     const DerivedTypeSpec *parentDerived{parent->AsDerived()};
-    if (!IsExtensibleType(parentDerived)) {
+    if (!IsExtensibleType(parentDerived)) {  // C705
       messages_.Say("The parent type is not extensible"_err_en_US);
     }
     if (!symbol.attrs().test(Attr::ABSTRACT) && parentDerived &&
diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index 197a32b4fee2..f075fa30a4b8 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -343,6 +343,7 @@ class DeclTypeSpecVisitor : public AttrsVisitor {
   }
   KindExpr GetKindParamExpr(
       TypeCategory, const std::optional<parser::KindSelector> &);
+  void CheckForAbstractType(const Symbol &typeSymbol);
 
 private:
   State state_;
@@ -731,7 +732,9 @@ class DeclarationVisitor : public ArraySpecVisitor,
   void Post(const parser::LengthSelector &);
   bool Pre(const parser::KindParam &);
   bool Pre(const parser::DeclarationTypeSpec::Type &);
+  void Post(const parser::DeclarationTypeSpec::Type &);
   bool Pre(const parser::DeclarationTypeSpec::Class &);
+  void Post(const parser::DeclarationTypeSpec::Class &);
   bool Pre(const parser::DeclarationTypeSpec::Record &);
   void Post(const parser::DerivedTypeSpec &);
   bool Pre(const parser::DerivedTypeDef &);
@@ -1590,9 +1593,7 @@ void DeclTypeSpecVisitor::Post(const parser::TypeSpec &typeSpec) {
     case DeclTypeSpec::Character: typeSpec.declTypeSpec = spec; break;
     case DeclTypeSpec::TypeDerived:
       if (const DerivedTypeSpec * derived{spec->AsDerived()}) {
-        if (derived->typeSymbol().attrs().test(Attr::ABSTRACT)) {
-          Say("ABSTRACT derived type may not be used here"_err_en_US);
-        }
+        CheckForAbstractType(derived->typeSymbol());  // C703
         typeSpec.declTypeSpec = spec;
       }
       break;
@@ -1613,6 +1614,12 @@ void DeclTypeSpecVisitor::MakeNumericType(TypeCategory category, int kind) {
   SetDeclTypeSpec(context().MakeNumericType(category, kind));
 }
 
+void DeclTypeSpecVisitor::CheckForAbstractType(const Symbol &typeSymbol) {
+  if (typeSymbol.attrs().test(Attr::ABSTRACT)) {
+    Say("ABSTRACT derived type may not be used here"_err_en_US);
+  }
+}
+
 void DeclTypeSpecVisitor::Post(const parser::DeclarationTypeSpec::ClassStar &) {
   SetDeclTypeSpec(context().globalScope().MakeClassStarType());
 }
@@ -3287,11 +3294,29 @@ bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Type &) {
   return true;
 }
 
+void DeclarationVisitor::Post(const parser::DeclarationTypeSpec::Type &type) {
+  const parser::Name &derivedName{std::get<parser::Name>(type.derived.t)};
+  if (const Symbol * derivedSymbol{derivedName.symbol}) {
+    CheckForAbstractType(*derivedSymbol);  // C706
+  }
+}
+
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Class &) {
   SetDeclTypeSpecCategory(DeclTypeSpec::Category::ClassDerived);
   return true;
 }
 
+void DeclarationVisitor::Post(
+    const parser::DeclarationTypeSpec::Class &parsedClass) {
+  const auto &typeName{std::get<parser::Name>(parsedClass.derived.t)};
+  if (auto spec{ResolveDerivedType(typeName)};
+      spec && !IsExtensibleType(&*spec)) {  // C705
+    SayWithDecl(typeName, *typeName.symbol,
+        "Non-extensible derived type '%s' may not be used with CLASS"
+        " keyword"_err_en_US);
+  }
+}
+
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Record &) {
   // TODO
   return true;
@@ -4501,7 +4526,7 @@ ParamValue DeclarationVisitor::GetParamValue(
     const parser::TypeParamValue &x, common::TypeParamAttr attr) {
   return std::visit(
       common::visitors{
-          [=](const parser::ScalarIntExpr &x) {
+          [=](const parser::ScalarIntExpr &x) {  // C704
             return ParamValue{EvaluateIntExpr(x), attr};
           },
           [=](const parser::Star &) { return ParamValue::Assumed(attr); },
diff --git a/test/semantics/CMakeLists.txt b/test/semantics/CMakeLists.txt
index c69569bc33e3..4873a0f50ebd 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/semantics/CMakeLists.txt
@@ -100,6 +100,7 @@ set(ERROR_TESTS
   resolve67.f90
   resolve68.f90
   resolve69.f90
+  resolve70.f90
   stop01.f90
   structconst01.f90
   structconst02.f90
diff --git a/test/semantics/allocate04.f90 b/test/semantics/allocate04.f90
index 4ccf01413c88..3b7ce25bf00e 100644
--- a/test/semantics/allocate04.f90
+++ b/test/semantics/allocate04.f90
@@ -47,7 +47,7 @@ subroutine C933_b(n)
   allocate(p3%y)
   !ERROR: Either type-spec or source-expr must appear in ALLOCATE when allocatable object is of abstract type
   allocate(p4(2)%y)
-  !WRONG allocate(Base:: u1) !C703
+  !WRONG allocate(Base:: u1)
 
   ! No error expected
   allocate(real:: u1, u2(2))
diff --git a/test/semantics/resolve52.f90 b/test/semantics/resolve52.f90
index 3df7f7fae628..3ee41dd3503f 100644
--- a/test/semantics/resolve52.f90
+++ b/test/semantics/resolve52.f90
@@ -114,6 +114,7 @@ module m7
   end type
 contains
   subroutine s(x)
+    !ERROR: Non-extensible derived type 't' may not be used with CLASS keyword
     class(t) :: x
   end
 end
diff --git a/test/semantics/resolve69.f90 b/test/semantics/resolve69.f90
index 5950f66e4741..bf08c3a706b0 100644
--- a/test/semantics/resolve69.f90
+++ b/test/semantics/resolve69.f90
@@ -1,8 +1,14 @@
 subroutine s1()
   ! C701 (R701) The type-param-value for a kind type parameter shall be a
   ! constant expression.
+  !
   ! C702 (R701) A colon shall not be used as a type-param-value except in the 
   ! declaration of an entity that has the POINTER or ALLOCATABLE attribute.
+  !
+  ! C704 (R703) In a declaration-type-spec, every type-param-value that is 
+  ! not a colon or an asterisk shall be a specification expression.
+  !   Section 10.1.11 defines specification expressions
+  !
   integer, parameter :: constVal = 1
   integer :: nonConstVal = 1
 !ERROR: Invalid specification expression: reference to local entity 'nonconstval'
@@ -20,6 +26,9 @@ subroutine s1()
   !OK because of the allocatable attribute
   character(:), allocatable :: colonString3
 
+!ERROR: Must have INTEGER type, but is REAL(4)
+  character(3.5) :: badParamValue
+
   type derived(typeKind, typeLen)
     integer, kind :: typeKind
     integer, len :: typeLen
diff --git a/test/semantics/resolve70.f90 b/test/semantics/resolve70.f90
new file mode 100644
index 000000000000..b771fd0677be
--- /dev/null
+++ b/test/semantics/resolve70.f90
@@ -0,0 +1,58 @@
+! C703 (R702) The derived-type-spec shall not specify an abstract type (7.5.7).
+! This constraint refers to the derived-type-spec in a type-spec.  A type-spec
+! can appear in an ALLOCATE statement, an ac-spec for an array constructor, and
+! in the type specifier of a TYPE GUARD statement
+!
+! C706 TYPE(derived-type-spec) shall not specify an abstract type (7.5.7).
+!   This is for a declaration-type-spec
+!
+! C796 (R756) The derived-type-spec shall not specify an abstract type (7.5.7).
+!
+! C705 (R703) In a declaration-type-spec that uses the CLASS keyword, 
+! derived-type-spec shall specify an extensible type (7.5.7).
+subroutine s()
+  type, abstract :: abstractType
+  end type abstractType
+
+  type, extends(abstractType) :: concreteType
+  end type concreteType
+
+  ! declaration-type-spec
+  !ERROR: ABSTRACT derived type may not be used here
+  type (abstractType), allocatable :: abstractVar
+
+  ! ac-spec for an array constructor
+  !ERROR: ABSTRACT derived type may not be used here
+  !ERROR: ABSTRACT derived type may not be used here
+  type (abstractType), parameter :: abstractArray(*) = (/ abstractType :: /)
+
+  class(*), allocatable :: selector
+
+  ! Structure constructor
+  !ERROR: ABSTRACT derived type may not be used here
+  !ERROR: ABSTRACT derived type 'abstracttype' may not be used in a structure constructor
+  type (abstractType) :: abstractVar1 = abstractType()
+
+  ! Allocate statement
+  !ERROR: ABSTRACT derived type may not be used here
+  allocate(abstractType :: abstractVar)
+
+  select type(selector)
+    ! Type specifier for a type guard statement
+    !ERROR: ABSTRACT derived type may not be used here
+    type is (abstractType)
+  end select
+end subroutine s
+
+subroutine s1()
+  type :: extensible
+  end type
+  type, bind(c) :: inextensible
+  end type
+
+  ! This one's OK
+  class(extensible) :: y
+
+  !ERROR: Non-extensible derived type 'inextensible' may not be used with CLASS keyword
+  class(inextensible) :: x
+end subroutine s1
diff --git a/test/semantics/structconst01.f90 b/test/semantics/structconst01.f90
index 5a4bd7bad346..a83286c422ab 100644
--- a/test/semantics/structconst01.f90
+++ b/test/semantics/structconst01.f90
@@ -3,6 +3,8 @@
 ! errors meant to be caught by expression semantic analysis, as well as
 ! acceptable use cases.
 ! Type parameters are used here to make the parses unambiguous.
+! C796 (R756) The derived-type-spec shall not specify an abstract type (7.5.7).
+!   This refers to a derived-type-spec used in a structure constructor
 
 module module1
   type :: type1(j)
@@ -29,7 +31,7 @@ subroutine type2arg(x)
     type(type2(0,0)), intent(in) :: x
   end subroutine type2arg
   subroutine abstractarg(x)
-    type(abstract(0)), intent(in) :: x
+    class(abstract(0)), intent(in) :: x
   end subroutine abstractarg
   subroutine errors
     call type1arg(type1(0)())

From 9c4bba11cf2329575ea9ee446f69e9caa797135c Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Tue, 4 Feb 2020 16:55:45 -0800
Subject: [PATCH 026/345] Progress on Fortran I/O runtime

Use internal units for internal I/O state

Replace use of virtual functions

reference_wrapper

Internal formatted output to array descriptor

Delete dead code

Begin list-directed internal output

Refactorings and renamings for clarity

List-directed external I/O (character)

COMPLEX list-directed output

Control list items

First cut at unformatted I/O

More OPEN statement work; rename class to ExternalFileUnit

Complete OPEN (exc. for POSITION=), add CLOSE()

OPEN(POSITION=)

Flush buffers on crash and for terminal output; clean up

Documentation

Fix backquote in documentation

Fix typo in comment

Begin implementation of input

Refactor binary floating-point properties to a new header, simplify numeric output editing

Dodge spurious GCC 7.2 build warning

Address review comments
---
 documentation/FortranForCProgrammers.md       |   6 +-
 documentation/IORuntimeInternals.md           | 341 ++++++++++
 include/flang/common/real.h                   |  86 +++
 include/flang/decimal/binary-floating-point.h |  39 +-
 include/flang/decimal/decimal.h               |   9 +
 include/flang/evaluate/common.h               |   4 +-
 include/flang/evaluate/complex.h              |   2 +-
 include/flang/evaluate/integer.h              |   2 +-
 include/flang/evaluate/real.h                 |  58 +-
 include/flang/evaluate/type.h                 |   2 +-
 lib/decimal/big-radix-floating-point.h        |   3 +-
 lib/decimal/binary-to-decimal.cpp             |  24 +-
 lib/decimal/decimal-to-binary.cpp             |   6 +-
 lib/evaluate/characteristics.cpp              |  29 -
 lib/evaluate/complex.cpp                      |   2 +-
 lib/evaluate/real.cpp                         |  52 +-
 module/iso_fortran_env.f90                    |   3 +-
 runtime/CMakeLists.txt                        |   3 +
 runtime/buffer.h                              |  12 +-
 runtime/connection.cpp                        |  19 +
 runtime/connection.h                          |  50 ++
 runtime/descriptor.cpp                        |   5 +
 runtime/descriptor.h                          |   1 +
 runtime/environment.cpp                       |   4 +-
 runtime/environment.h                         |   5 +-
 runtime/file.cpp                              | 110 ++--
 runtime/file.h                                |  38 +-
 runtime/format-implementation.h               | 355 ++++++++++
 runtime/format.cpp                            | 390 ++---------
 runtime/format.h                              |  72 +-
 runtime/internal-unit.cpp                     | 129 ++++
 runtime/internal-unit.h                       |  46 ++
 runtime/io-api.cpp                            | 614 +++++++++++++++++-
 runtime/io-api.h                              |  15 +-
 runtime/io-error.h                            |   3 +-
 runtime/io-stmt.cpp                           | 402 ++++++++----
 runtime/io-stmt.h                             | 312 +++++++--
 runtime/lock.h                                |   2 +-
 runtime/main.cpp                              |   3 +-
 runtime/memory.cpp                            |   2 +-
 runtime/memory.h                              |  11 +-
 runtime/numeric-output.cpp                    | 152 +++++
 runtime/numeric-output.h                      | 324 ++++-----
 runtime/stop.cpp                              |   2 +-
 runtime/terminator.cpp                        |  21 +-
 runtime/terminator.h                          |  12 +-
 runtime/tools.cpp                             |   2 +-
 runtime/tools.h                               |   3 +-
 runtime/unit.cpp                              | 118 +++-
 runtime/unit.h                                | 106 ++-
 test/evaluate/real.cpp                        |   2 +-
 test/runtime/external-hello.cpp               |  15 +-
 test/runtime/format.cpp                       |  29 +-
 test/runtime/hello.cpp                        |  48 +-
 54 files changed, 2928 insertions(+), 1177 deletions(-)
 create mode 100644 documentation/IORuntimeInternals.md
 create mode 100644 include/flang/common/real.h
 create mode 100644 runtime/connection.cpp
 create mode 100644 runtime/connection.h
 create mode 100644 runtime/format-implementation.h
 create mode 100644 runtime/internal-unit.cpp
 create mode 100644 runtime/internal-unit.h
 create mode 100644 runtime/numeric-output.cpp

diff --git a/documentation/FortranForCProgrammers.md b/documentation/FortranForCProgrammers.md
index db8345477ba5..6038c7ce348a 100644
--- a/documentation/FortranForCProgrammers.md
+++ b/documentation/FortranForCProgrammers.md
@@ -1,9 +1,9 @@
-<!--===- documentation/FortranForCProgrammers.md 
-  
+<!--===- documentation/FortranForCProgrammers.md
+
    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
-  
+
 -->
 
 Fortran For C Programmers
diff --git a/documentation/IORuntimeInternals.md b/documentation/IORuntimeInternals.md
new file mode 100644
index 000000000000..70dd0941ac76
--- /dev/null
+++ b/documentation/IORuntimeInternals.md
@@ -0,0 +1,341 @@
+<!--===- documentation/IORuntimeInternals.md
+
+   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
+
+-->
+
+Fortran I/O Runtime Library Internal Design
+===========================================
+
+This note is meant to be an overview of the design of the *implementation*
+of the f18 Fortran compiler's runtime support library for I/O statements.
+
+The *interface* to the I/O runtime support library is defined in the
+C++ header file `runtime/io-api.h`.
+This interface was designed to minimize the amount of complexity exposed
+to its clients, which are of course the sequences of calls generated by
+the compiler to implement each I/O statement.
+By keeping this interface as simple as possible, we hope that we have
+lowered the risk of future incompatible changes that would necessitate
+recompilation of Fortran codes in order to link with later versions of
+the runtime library.
+As one will see in `io-api.h`, the interface is also directly callable
+from C and C++ programs.
+
+The I/O facilities of the Fortran 2018 language are specified in the
+language standard in its clauses 12 (I/O statements) and 13 (`FORMAT`).
+It's a complicated collection of language features:
+ * Files can comprise *records* or *streams*.
+ * Records can be fixed-length or variable-length.
+ * Record files can be accessed sequentially or directly (random access).
+ * Files can be *formatted*, or *unformatted* raw bits.
+ * `CHARACTER` scalars and arrays can be used as if they were
+fixed-length formatted sequential record files.
+ * Formatted I/O can be under control of a `FORMAT` statement
+or `FMT=` specifier, *list-directed* with default formatting chosen
+by the runtime, or `NAMELIST`, in which a collection of variables
+can be given a name and passed as a group to the runtime library.
+ * Sequential records of a file can be partially processed by one
+or more *non-advancing* I/O statements and eventually completed by
+another.
+ * `FORMAT` strings can manipulate the position in the current
+record arbitrarily, causing re-reading or overwriting.
+ * Floating-point output formatting supports more rounding modes
+than the IEEE standard for floating-point arithmetic.
+
+The Fortran I/O runtime support library is written in C++17, and
+uses some C++17 standard library facilities, but it is intended
+to not have any link-time dependences on the C++ runtime support
+library or any LLVM libraries.
+This is important because there are at least two C++ runtime support
+libraries, and we don't want Fortran application builders to have to
+build multiple versions of their codes; neither do we want to require
+them to ship LLVM libraries along with their products.
+
+Consequently, dynamic memory allocation in the Fortran runtime
+uses only C's `malloc()` and `free()` functions, and the few
+C++ standard class templates that we instantiate in the library have been
+modified with optional template arguments that override their
+allocators and deallocators.
+
+Conversions between the many binary floating-point formats supported
+by f18 and their decimal representations are performed with the same
+template library of fast conversion algorithms used to interpret
+floating-point values in Fortran source programs and to emit them
+to module files.
+
+Overview of Classes
+===================
+
+A suite of C++ classes and class templates are composed to construct
+the Fortran I/O runtime support library.
+They (mostly) reside in the C++ namespace `Fortran::runtime::io`.
+They are summarized here in a bottom-up order of dependence.
+
+The header and C++ implementation source file names of these
+classes are in the process of being vigorously rearranged and
+modified; use `grep` or an IDE to discover these classes in
+the source for now.  (Sorry!)
+
+`Terminator`
+----------
+A general facility for the entire library, `Terminator` latches a
+source program statement location in terms of an unowned pointer to
+its source file path name and line number and uses them to construct
+a fatal error message if needed.
+It is used for both user program errors and internal runtime library crashes.
+
+`IoErrorHandler`
+--------------
+When I/O error conditions arise at runtime that the Fortran program
+might have the privilege to handle itself via `ERR=`, `END=`, or
+`EOR=` labels and/or by an `IOSTAT=` variable, this subclass of
+`Terminator` is used to either latch the error indication or to crash.
+It sorts out priorities in the case of multiple errors and determines
+the final `IOSTAT=` value at the end of an I/O statement.
+
+`MutableModes`
+------------
+Fortran's formatted I/O statements are affected by a suite of
+modes that can be configured by `OPEN` statements, overridden by
+data transfer I/O statement control lists, and further overridden
+between data items with control edit descriptors in a `FORMAT` string.
+These modes are represented with a `MutableModes` instance, and these
+are instantiated and copied where one would expect them to be in
+order to properly isolate their modifications.
+The modes in force at the time each data item is processed constitute
+a member of each `DataEdit`.
+
+`DataEdit`
+--------
+Represents a single data edit descriptor from a `FORMAT` statement
+or `FMT=` character value, with some hidden extensions to also
+support formatting of list-directed transfers.
+It holds an instance of `MutableModes`, and also has a repetition
+count for when an array appears as a data item in the *io-list*.
+For simplicity and efficiency, each data edit descriptor is
+encoded in the `DataEdit` as a simple capitalized character
+(or two) and some optional field widths.
+
+`FormatControl<>`
+---------------
+This class template traverses a `FORMAT` statement's contents (or `FMT=`
+character value) to extract data edit descriptors like `E20.14` to
+serve each item in an I/O data transfer statement's *io-list*,
+making callbacks to an instance of its class template argument
+along the way to effect character literal output and record
+positioning.
+The Fortran language standard defines formatted I/O as if the `FORMAT`
+string were driving the traversal of the data items in the *io-list*,
+but our implementation reverses that perspective to allow a more
+convenient (for the compiler) I/O runtime support library API design
+in which each data item is presented to the library with a distinct
+type-dependent call.
+
+Clients of `FormatControl` instantiations call its `GetNextDataEdit()`
+member function to acquire the next data edit descriptor to be processed
+from the format, and `FinishOutput()` to flush out any remaining
+output strings or record positionings at the end of the *io-list*.
+
+The `DefaultFormatControlCallbacks` structure summarizes the API
+expected by `FormatControl` from its class template actual arguments.
+
+`OpenFile`
+--------
+This class encapsulates all (I hope) the operating system interfaces
+used to interact with the host's filesystems for operations on
+external units.
+Asynchronous I/O interfaces are faked for now with synchronous
+operations and deferred results.
+
+`ConnectionState`
+---------------
+An active connection to an external or internal unit maintains
+the common parts of its state in this subclass of `ConnectionAttributes`.
+The base class holds state that should not change during the
+lifetime of the connection, while the subclass maintains state
+that may change during I/O statement execution.
+
+`InternalDescriptorUnit`
+----------------------
+When I/O is being performed from/to a Fortran `CHARACTER` array
+rather than an external file, this class manages the standard
+interoperable descriptor used to access its elements as records.
+It has the necessary interfaces to serve as an actual argument
+to the `FormatControl` class template.
+
+`FileFrame<>`
+-----------
+This CRTP class template isolates all of the complexity involved between
+an external unit's `OpenFile` and the buffering requirements
+imposed by the capabilities of Fortran `FORMAT` control edit
+descriptors that allow repositioning within the current record.
+Its interface enables its clients to define a "frame" (my term,
+not Fortran's) that is a contiguous range of bytes that are
+or may soon be in the file.
+This frame is defined as a file offset and a byte size.
+The `FileFrame` instance manages an internal circular buffer
+with two essential guarantees:
+
+1. The most recently requested frame is present in the buffer
+and contiguous in memory.
+1. Any extra data after the frame that may have been read from
+the external unit will be preserved, so that it's safe to
+read from a socket, pipe, or tape and not have to worry about
+repositioning and rereading.
+
+In end-of-file situations, it's possible that a request to read
+a frame may come up short.
+
+As a CRTP class template, `FileFrame` accesses the raw filesystem
+facilities it needs from `*this`.
+
+`ExternalFileUnit`
+----------------
+This class mixes in `ConnectionState`, `OpenFile`, and
+`FileFrame<ExternalFileUnit>` to represent the state of an open
+(or soon to be opened) external file descriptor as a Fortran
+I/O unit.
+It has the contextual APIs required to serve as a template actual
+argument to `FormatControl`.
+And it contains a `std::variant<>` suitable for holding the
+state of the active I/O statement in progress on the unit
+(see below).
+
+`ExternalFileUnit` instances reside in a `Map` that is allocated
+as a static variable and indexed by Fortran unit number.
+Static member functions `LookUp()`, `LookUpOrCrash()`, and `LookUpOrCreate()`
+probe the map to convert Fortran `UNIT=` numbers from I/O statements
+into references to active units.
+
+`IoStatementBase`
+---------------
+The subclasses of `IoStatementBase` each encapsulate and maintain
+the state of one active Fortran I/O statement across the several
+I/O runtime library API function calls it may comprise.
+The subclasses handle the distinctions between internal vs. external I/O,
+formatted vs. list-directed vs. unformatted I/O, input vs. output,
+and so on.
+
+`IoStatementBase` inherits default `FORMAT` processing callbacks and
+an `IoErrorHandler`.
+Each of the `IoStatementBase` classes that pertain to formatted I/O
+support the contextual callback interfaces needed by `FormatControl`,
+overriding the default callbacks of the base class, which crash if
+called inappropriately (e.g., if a `CLOSE` statement somehow
+passes a data item from an *io-list*).
+
+The lifetimes of these subclasses' instances each begin with a user
+program call to an I/O API routine with a name like `BeginExternalListOutput()`
+and persist until `EndIoStatement()` is called.
+
+To reduce dynamic memory allocation, *external* I/O statements allocate
+their per-statement state class instances in space reserved in the
+`ExternalFileUnit` instance.
+Internal I/O statements currently use dynamic allocation, but
+the I/O API supports a means whereby the code generated for the Fortran
+program may supply stack space to the I/O runtime support library
+for this purpose.
+
+`IoStatementState`
+----------------
+F18's Fortran I/O runtime support library defines and implements an API
+that uses a sequence of function calls to implement each Fortran I/O
+statement.
+The state of each I/O statement in progress is maintained in some
+subclass of `IoStatementBase`, as noted above.
+The purpose of `IoStatementState` is to provide generic access
+to the specific state classes without recourse to C++ `virtual`
+functions or function pointers, language features that may not be
+available to us in some important execution environments.
+`IoStatementState` comprises a `std::variant<>` of wrapped references
+to the various possibilities, and uses `std::visit()` to
+access them as needed by the I/O API calls that process each specifier
+in the I/O *control-list* and each item in the *io-list*.
+
+Pointers to `IoStatementState` instances are the `Cookie` type returned
+in the I/O API for `Begin...` I/O statement calls, passed back for
+the *control-list* specifiers and *io-list* data items, and consumed
+by the `EndIoStatement()` call at the end of the statement.
+
+Storage for `IoStatementState` is reserved in `ExternalFileUnit` for
+external I/O units, and in the various final subclasses for internal
+I/O statement states otherwise.
+
+Since Fortran permits a `CLOSE` statement to reference a nonexistent
+unit, the library has to treat that (expected to be rare) situation
+as a weird variation of internal I/O since there's no `ExternalFileUnit`
+available to hold its `IoStatementBase` subclass or `IoStatementState`.
+
+A Narrative Overview Of `PRINT *, 'HELLO, WORLD'`
+=================================================
+1. When the compiled Fortran program begins execution at the `main()`
+entry point exported from its main program, it calls `ProgramStart()`
+with its arguments and environment.  `ProgramStart()` calls
+`ExternalFileUnit::InitializePredefinedUnits()` to create and
+initialize Fortran units 5 and 6 and connect them with the
+standard input and output file descriptors (respectively).
+1. The generated code calls `BeginExternalListOutput()` to
+start the sequence of calls that implement the `PRINT` statement.
+The default unit code is converted to 6 and passed to
+`ExternalFileUnit::LookUpOrCrash()`, which returns a reference to
+unit 6's instance.
+1. We check that the unit was opened for formatted I/O.
+1. `ExternalFileUnit::BeginIoStatement<>()` is called to initialize
+an instance of `ExternalListIoStatementState<false>` in the unit,
+point to it with an `IoStatementState`, and return a reference to
+that object whose address will be the `Cookie` for this statement.
+1. The generated code calls `OutputAscii()` with that cookie and the
+address and length of the string.
+1. `OutputAscii()` confirms that the cookie corresponds to an output
+statement and determines that it's list-directed.
+1. `ListDirectedStatementState<false>::EmitLeadingSpaceOrAdvance()`
+emits the required initial space on the new current output record
+by calling `IoStatementState::GetConnectionState()` to locate
+the connection state, determining from the record position state
+that the space is necessary, and calling `IoStatementState::Emit()`
+to cough it out.  That call is redirected to `ExternalFileUnit::Emit()`,
+which calls `FileFrame<ExternalFileUnit>::WriteFrame()` to extend
+the frame of the current record and then `memcpy()` to fill its
+first byte with the space.
+1. Back in `OutputAscii()`, the mutable modes and connection state
+of the `IoStatementState` are queried to see whether we're in an
+`WRITE(UNIT=,FMT=,DELIM=)` statement with a delimited specifier.
+If we were, the library would emit the appropriate quote marks,
+double up any instances of that character in the text, and split the
+text over multiple records if it's long.
+1. But we don't have a delimiter, so `OutputAscii()` just carves
+up the text into record-sized chunks and emits them.  There's just
+one chunk for our short `CHARACTER` string value in this example.
+It's passed to `IoStatementState::Emit()`, which (as above) is
+redirected to `ExternalFileUnit::Emit()`, which interacts with the
+frame to extend the frame and `memcpy` data into the buffer.
+1. A flag is set in `ListDirectedStatementState<false>` to remember
+that the last item emitted in this list-directed output statement
+was an undelimited `CHARACTER` value, so that if the next item is
+also an undelimited `CHARACTER`, no interposing space will be emitted
+between them.
+1. `OutputAscii()` return `true` to its caller.
+1. The generated code calls `EndIoStatement()`, which is redirected to
+`ExternalIoStatementState<false>`'s override of that function.
+As this is not a non-advancing I/O statement, `ExternalFileUnit::AdvanceRecord()`
+is called to end the record.  Since this is a sequential formatted
+file, a newline is emitted.
+1. If unit 6 is connected to a terminal, the buffer is flushed.
+`FileFrame<ExternalFileUnit>::Flush()` drives `ExternalFileUnit::Write()`
+to push out the data in maximal contiguous chunks, dealing with any
+short writes that might occur, and collecting I/O errors along the way.
+This statement has no `ERR=` label or `IOSTAT=` specifier, so errors
+arriving at `IoErrorHandler::SignalErrno()` will cause an immediate
+crash.
+1. `ExternalIoStatementBase::EndIoStatement()` is called.
+It gets the final `IOSTAT=` value from `IoStatementBase::EndIoStatement()`,
+tells the `ExternalFileUnit` that no I/O statement remains active, and
+returns the I/O status value back to the program.
+1. Eventually, the program calls `ProgramEndStatement()`, which
+calls `ExternalFileUnit::CloseAll()`, which flushes and closes all
+open files.  If the standard output were not a terminal, the output
+would be written now with the same sequence of calls as above.
+1. `exit(EXIT_SUCCESS)`.
diff --git a/include/flang/common/real.h b/include/flang/common/real.h
new file mode 100644
index 000000000000..d15de663a92b
--- /dev/null
+++ b/include/flang/common/real.h
@@ -0,0 +1,86 @@
+//===-- include/flang/common/real.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_COMMON_REAL_H_
+#define FORTRAN_COMMON_REAL_H_
+
+// Characteristics of IEEE-754 & related binary floating-point numbers.
+// The various representations are distinguished by their binary precisions
+// (number of explicit significand bits and any implicit MSB in the fraction).
+
+#include <cinttypes>
+
+namespace Fortran::common {
+
+// Total representation size in bits for each type
+static constexpr int BitsForBinaryPrecision(int binaryPrecision) {
+  switch (binaryPrecision) {
+  case 8: return 16;  // IEEE single (truncated): 1+8+7
+  case 11: return 16;  // IEEE half precision: 1+5+10
+  case 24: return 32;  // IEEE single precision: 1+8+23
+  case 53: return 64;  // IEEE double precision: 1+11+52
+  case 64: return 80;  // x87 extended precision: 1+15+64
+  case 106: return 128;  // "double-double": 2*(1+11+52)
+  case 112: return 128;  // IEEE quad precision: 1+16+111
+  default: return -1;
+  }
+}
+
+// Number of significant decimal digits in the fraction of the
+// exact conversion of the least nonzero (subnormal) value
+// in each type; i.e., a 128-bit quad value can be formatted
+// exactly with FORMAT(E0.22981).
+static constexpr int MaxDecimalConversionDigits(int binaryPrecision) {
+  switch (binaryPrecision) {
+  case 8: return 93;
+  case 11: return 17;
+  case 24: return 105;
+  case 53: return 751;
+  case 64: return 11495;
+  case 106: return 2 * 751;
+  case 112: return 22981;
+  default: return -1;
+  }
+}
+
+template<int BINARY_PRECISION> class RealDetails {
+private:
+  // Converts bit widths to whole decimal digits
+  static constexpr int LogBaseTwoToLogBaseTen(int logb2) {
+    constexpr std::int64_t LogBaseTenOfTwoTimesTenToThe12th{301029995664};
+    constexpr std::int64_t TenToThe12th{1000000000000};
+    std::int64_t logb10{
+        (logb2 * LogBaseTenOfTwoTimesTenToThe12th) / TenToThe12th};
+    return static_cast<int>(logb10);
+  }
+
+public:
+  static constexpr int binaryPrecision{BINARY_PRECISION};
+  static constexpr int bits{BitsForBinaryPrecision(binaryPrecision)};
+  static constexpr bool isImplicitMSB{binaryPrecision != 64 /*x87*/};
+  static constexpr int significandBits{binaryPrecision - isImplicitMSB};
+  static constexpr int exponentBits{bits - significandBits - 1 /*sign*/};
+  static constexpr int maxExponent{(1 << exponentBits) - 1};
+  static constexpr int exponentBias{maxExponent / 2};
+
+  static constexpr int decimalPrecision{
+      LogBaseTwoToLogBaseTen(binaryPrecision - 1)};
+  static constexpr int decimalRange{LogBaseTwoToLogBaseTen(exponentBias - 1)};
+
+  // Number of significant decimal digits in the fraction of the
+  // exact conversion of the least nonzero subnormal.
+  static constexpr int maxDecimalConversionDigits{
+      MaxDecimalConversionDigits(binaryPrecision)};
+
+  static_assert(binaryPrecision > 0);
+  static_assert(exponentBits > 1);
+  static_assert(exponentBits <= 16);
+};
+
+}
+#endif  // FORTRAN_COMMON_REAL_H_
diff --git a/include/flang/decimal/binary-floating-point.h b/include/flang/decimal/binary-floating-point.h
index 3da4a336c50e..bf467c5cbb70 100644
--- a/include/flang/decimal/binary-floating-point.h
+++ b/include/flang/decimal/binary-floating-point.h
@@ -12,6 +12,7 @@
 // Access and manipulate the fields of an IEEE-754 binary
 // floating-point value via a generalized template.
 
+#include "flang/common/real.h"
 #include "flang/common/uint128.h"
 #include <cinttypes>
 #include <climits>
@@ -20,34 +21,24 @@
 
 namespace Fortran::decimal {
 
-static constexpr int BitsForPrecision(int prec) {
-  switch (prec) {
-  case 8: return 16;
-  case 11: return 16;
-  case 24: return 32;
-  case 53: return 64;
-  case 64: return 80;
-  case 112: return 128;
-  default: return -1;
-  }
-}
+template<int BINARY_PRECISION>
+struct BinaryFloatingPointNumber
+  : public common::RealDetails<BINARY_PRECISION> {
 
-// LOG10(2.)*1E12
-static constexpr std::int64_t ScaledLogBaseTenOfTwo{301029995664};
+  using Details = common::RealDetails<BINARY_PRECISION>;
+  using Details::bits;
+  using Details::decimalPrecision;
+  using Details::decimalRange;
+  using Details::exponentBias;
+  using Details::exponentBits;
+  using Details::isImplicitMSB;
+  using Details::maxDecimalConversionDigits;
+  using Details::maxExponent;
+  using Details::significandBits;
 
-template<int PRECISION> struct BinaryFloatingPointNumber {
-  static constexpr int precision{PRECISION};
-  static constexpr int bits{BitsForPrecision(precision)};
   using RawType = common::HostUnsignedIntType<bits>;
   static_assert(CHAR_BIT * sizeof(RawType) >= bits);
-  static constexpr bool implicitMSB{precision != 64 /*x87*/};
-  static constexpr int significandBits{precision - implicitMSB};
-  static constexpr int exponentBits{bits - 1 - significandBits};
-  static constexpr int maxExponent{(1 << exponentBits) - 1};
-  static constexpr int exponentBias{maxExponent / 2};
   static constexpr RawType significandMask{(RawType{1} << significandBits) - 1};
-  static constexpr int RANGE{static_cast<int>(
-      (exponentBias - 1) * ScaledLogBaseTenOfTwo / 1000000000000)};
 
   constexpr BinaryFloatingPointNumber() {}  // zero
   constexpr BinaryFloatingPointNumber(
@@ -76,7 +67,7 @@ template<int PRECISION> struct BinaryFloatingPointNumber {
   constexpr RawType Significand() const { return raw & significandMask; }
   constexpr RawType Fraction() const {
     RawType sig{Significand()};
-    if (implicitMSB && BiasedExponent() > 0) {
+    if (isImplicitMSB && BiasedExponent() > 0) {
       sig |= RawType{1} << significandBits;
     }
     return sig;
diff --git a/include/flang/decimal/decimal.h b/include/flang/decimal/decimal.h
index 812d08fe8d09..c9aad161f4dd 100644
--- a/include/flang/decimal/decimal.h
+++ b/include/flang/decimal/decimal.h
@@ -62,6 +62,15 @@ enum DecimalConversionFlags {
   AlwaysSign = 2, /* emit leading '+' if not negative */
 };
 
+/*
+ * When allocating decimal conversion output buffers, use the maximum
+ * number of significant decimal digits in the representation of the
+ * least nonzero value, and add this extra space for a sign, a NUL, and
+ * some extra due to the library working internally in base 10**16
+ * and computing its output size in multiples of 16.
+ */
+#define EXTRA_DECIMAL_CONVERSION_SPACE (1 + 1 + 16 - 1)
+
 #ifdef __cplusplus
 template<int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *, size_t,
diff --git a/include/flang/evaluate/common.h b/include/flang/evaluate/common.h
index f24e93d7cd33..b7ea530e712f 100644
--- a/include/flang/evaluate/common.h
+++ b/include/flang/evaluate/common.h
@@ -130,9 +130,9 @@ struct Rounding {
 static constexpr Rounding defaultRounding;
 
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-constexpr bool IsHostLittleEndian{false};
+constexpr bool isHostLittleEndian{false};
 #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-constexpr bool IsHostLittleEndian{true};
+constexpr bool isHostLittleEndian{true};
 #else
 #error host endianness is not known
 #endif
diff --git a/include/flang/evaluate/complex.h b/include/flang/evaluate/complex.h
index 201cbcea60ab..16559e9f0962 100644
--- a/include/flang/evaluate/complex.h
+++ b/include/flang/evaluate/complex.h
@@ -95,7 +95,7 @@ extern template class Complex<Real<Integer<16>, 11>>;
 extern template class Complex<Real<Integer<16>, 8>>;
 extern template class Complex<Real<Integer<32>, 24>>;
 extern template class Complex<Real<Integer<64>, 53>>;
-extern template class Complex<Real<Integer<80>, 64, false>>;
+extern template class Complex<Real<Integer<80>, 64>>;
 extern template class Complex<Real<Integer<128>, 112>>;
 }
 #endif  // FORTRAN_EVALUATE_COMPLEX_H_
diff --git a/include/flang/evaluate/integer.h b/include/flang/evaluate/integer.h
index 1bff2bb7b7ca..46478f7e6106 100644
--- a/include/flang/evaluate/integer.h
+++ b/include/flang/evaluate/integer.h
@@ -49,7 +49,7 @@ namespace Fortran::evaluate::value {
 // Member functions that correspond to Fortran intrinsic functions are
 // named accordingly in ALL CAPS so that they can be referenced easily in
 // the language standard.
-template<int BITS, bool IS_LITTLE_ENDIAN = IsHostLittleEndian,
+template<int BITS, bool IS_LITTLE_ENDIAN = isHostLittleEndian,
     int PARTBITS = BITS <= 32 ? BITS : 32,
     typename PART = HostUnsignedInt<PARTBITS>,
     typename BIGPART = HostUnsignedInt<PARTBITS * 2>>
diff --git a/include/flang/evaluate/real.h b/include/flang/evaluate/real.h
index 84e2d556baf3..bcc73cb54b73 100644
--- a/include/flang/evaluate/real.h
+++ b/include/flang/evaluate/real.h
@@ -12,6 +12,7 @@
 #include "formatting.h"
 #include "integer.h"
 #include "rounding-bits.h"
+#include "flang/common/real.h"
 #include "flang/evaluate/common.h"
 #include <cinttypes>
 #include <limits>
@@ -30,26 +31,25 @@ static constexpr std::int64_t ScaledLogBaseTenOfTwo{301029995664};
 // Models IEEE binary floating-point numbers (IEEE 754-2008,
 // ISO/IEC/IEEE 60559.2011).  The first argument to this
 // class template must be (or look like) an instance of Integer<>;
-// the second specifies the number of effective bits in the fraction;
-// the third, if true, indicates that the most significant position of the
-// fraction is an implicit bit whose value is assumed to be 1 in a finite
-// normal number.
-template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
+// the second specifies the number of effective bits (binary precision)
+// in the fraction.
+template<typename WORD, int PREC>
+class Real : public common::RealDetails<PREC> {
 public:
   using Word = WORD;
+  static constexpr int binaryPrecision{PREC};
+  using Details = common::RealDetails<PREC>;
+  using Details::exponentBias;
+  using Details::exponentBits;
+  using Details::isImplicitMSB;
+  using Details::maxExponent;
+  using Details::significandBits;
+
   static constexpr int bits{Word::bits};
-  static constexpr int precision{PREC};
-  using Fraction = Integer<precision>;  // all bits made explicit
-  static constexpr bool implicitMSB{IMPLICIT_MSB};
-  static constexpr int significandBits{precision - implicitMSB};
-  static constexpr int exponentBits{bits - significandBits - 1 /*sign*/};
-  static_assert(precision > 0);
-  static_assert(exponentBits > 1);
-  static_assert(exponentBits <= 16);
-  static constexpr int maxExponent{(1 << exponentBits) - 1};
-  static constexpr int exponentBias{maxExponent / 2};
-
-  template<typename W, int P, bool I> friend class Real;
+  static_assert(bits >= Details::bits);
+  using Fraction = Integer<binaryPrecision>;  // all bits made explicit
+
+  template<typename W, int P> friend class Real;
 
   constexpr Real() {}  // +0.0
   constexpr Real(const Real &) = default;
@@ -130,12 +130,13 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
 
   static constexpr Real EPSILON() {
     Real epsilon;
-    epsilon.Normalize(false, exponentBias - precision, Fraction::MASKL(1));
+    epsilon.Normalize(
+        false, exponentBias - binaryPrecision, Fraction::MASKL(1));
     return epsilon;
   }
   static constexpr Real HUGE() {
     Real huge;
-    huge.Normalize(false, maxExponent - 1, Fraction::MASKR(precision));
+    huge.Normalize(false, maxExponent - 1, Fraction::MASKR(binaryPrecision));
     return huge;
   }
   static constexpr Real TINY() {
@@ -144,11 +145,9 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     return tiny;
   }
 
-  static constexpr int DIGITS{precision};
-  static constexpr int PRECISION{static_cast<int>(
-      (precision - 1) * ScaledLogBaseTenOfTwo / 1000000000000)};
-  static constexpr int RANGE{static_cast<int>(
-      (exponentBias - 1) * ScaledLogBaseTenOfTwo / 1000000000000)};
+  static constexpr int DIGITS{binaryPrecision};
+  static constexpr int PRECISION{Details::decimalPrecision};
+  static constexpr int RANGE{Details::decimalRange};
   static constexpr int MAXEXPONENT{maxExponent - 1 - exponentBias};
   static constexpr int MINEXPONENT{1 - exponentBias};
 
@@ -190,7 +189,7 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     }
     ValueWithRealFlags<Real> result;
     int exponent{exponentBias + absN.bits - leadz - 1};
-    int bitsNeeded{absN.bits - (leadz + implicitMSB)};
+    int bitsNeeded{absN.bits - (leadz + isImplicitMSB)};
     int bitsLost{bitsNeeded - significandBits};
     if (bitsLost <= 0) {
       Fraction fraction{Fraction::ConvertUnsigned(absN).value};
@@ -224,7 +223,8 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     result.flags.set(
         RealFlag::Overflow, exponent >= exponentBias + result.value.bits);
     result.flags |= intPart.flags;
-    int shift{exponent - exponentBias - precision + 1};  // positive -> left
+    int shift{
+        exponent - exponentBias - binaryPrecision + 1};  // positive -> left
     result.value =
         result.value.ConvertUnsigned(intPart.value.GetFraction().SHIFTR(-shift))
             .value.SHIFTL(shift);
@@ -252,7 +252,7 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
     }
     ValueWithRealFlags<Real> result;
     int exponent{exponentBias + x.UnbiasedExponent()};
-    int bitsLost{A::precision - precision};
+    int bitsLost{A::binaryPrecision - binaryPrecision};
     if (exponent < 1) {
       bitsLost += 1 - exponent;
       exponent = 1;
@@ -282,7 +282,7 @@ template<typename WORD, int PREC, bool IMPLICIT_MSB = true> class Real {
   // Extracts the fraction; any implied bit is made explicit.
   constexpr Fraction GetFraction() const {
     Fraction result{Fraction::ConvertUnsigned(word_).value};
-    if constexpr (!implicitMSB) {
+    if constexpr (!isImplicitMSB) {
       return result;
     } else {
       int exponent{Exponent()};
@@ -366,7 +366,7 @@ extern template class Real<Integer<16>, 11>;  // IEEE half format
 extern template class Real<Integer<16>, 8>;  // the "other" half format
 extern template class Real<Integer<32>, 24>;  // IEEE single
 extern template class Real<Integer<64>, 53>;  // IEEE double
-extern template class Real<Integer<80>, 64, false>;  // 80387 extended precision
+extern template class Real<Integer<80>, 64>;  // 80387 extended precision
 extern template class Real<Integer<128>, 112>;  // IEEE quad
 // N.B. No "double-double" support.
 }
diff --git a/include/flang/evaluate/type.h b/include/flang/evaluate/type.h
index 29dde4eeb1a4..a558928d4893 100644
--- a/include/flang/evaluate/type.h
+++ b/include/flang/evaluate/type.h
@@ -268,7 +268,7 @@ class Type<TypeCategory::Real, 8> : public TypeBase<TypeCategory::Real, 8> {
 template<>
 class Type<TypeCategory::Real, 10> : public TypeBase<TypeCategory::Real, 10> {
 public:
-  using Scalar = value::Real<value::Integer<80>, 64, false>;
+  using Scalar = value::Real<value::Integer<80>, 64>;
 };
 
 // REAL(KIND=16) is IEEE quad precision (128 bits)
diff --git a/lib/decimal/big-radix-floating-point.h b/lib/decimal/big-radix-floating-point.h
index 51eb9ec8c5b6..35f0a2e8c31f 100644
--- a/lib/decimal/big-radix-floating-point.h
+++ b/lib/decimal/big-radix-floating-point.h
@@ -58,7 +58,8 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 
   // The base-2 logarithm of the least significant bit that can arise
   // in a subnormal IEEE floating-point number.
-  static constexpr int minLog2AnyBit{-Real::exponentBias - Real::precision};
+  static constexpr int minLog2AnyBit{
+      -Real::exponentBias - Real::binaryPrecision};
 
   // The number of Digits needed to represent the smallest subnormal.
   static constexpr int maxDigits{3 - minLog2AnyBit / log10Radix};
diff --git a/lib/decimal/binary-to-decimal.cpp b/lib/decimal/binary-to-decimal.cpp
index ba061856b089..d15aab5ff638 100644
--- a/lib/decimal/binary-to-decimal.cpp
+++ b/lib/decimal/binary-to-decimal.cpp
@@ -25,7 +25,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::BigRadixFloatingPointNumber(
   }
   int twoPow{x.UnbiasedExponent()};
   twoPow -= x.bits - 1;
-  if (!x.implicitMSB) {
+  if (!x.isImplicitMSB) {
     ++twoPow;
   }
   int lshift{x.exponentBits};
@@ -317,7 +317,7 @@ void BigRadixFloatingPointNumber<PREC,
 }
 
 template<int PREC>
-ConversionToDecimalResult ConvertToDecimal(char *buffer, size_t size,
+ConversionToDecimalResult ConvertToDecimal(char *buffer, std::size_t size,
     enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, BinaryFloatingPointNumber<PREC> x) {
   if (x.IsNaN()) {
@@ -355,34 +355,34 @@ ConversionToDecimalResult ConvertToDecimal(char *buffer, size_t size,
   }
 }
 
-template ConversionToDecimalResult ConvertToDecimal<8>(char *, size_t,
+template ConversionToDecimalResult ConvertToDecimal<8>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<8>);
-template ConversionToDecimalResult ConvertToDecimal<11>(char *, size_t,
+template ConversionToDecimalResult ConvertToDecimal<11>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<11>);
-template ConversionToDecimalResult ConvertToDecimal<24>(char *, size_t,
+template ConversionToDecimalResult ConvertToDecimal<24>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<24>);
-template ConversionToDecimalResult ConvertToDecimal<53>(char *, size_t,
+template ConversionToDecimalResult ConvertToDecimal<53>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<53>);
-template ConversionToDecimalResult ConvertToDecimal<64>(char *, size_t,
+template ConversionToDecimalResult ConvertToDecimal<64>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<64>);
-template ConversionToDecimalResult ConvertToDecimal<112>(char *, size_t,
+template ConversionToDecimalResult ConvertToDecimal<112>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<112>);
 
 extern "C" {
-ConversionToDecimalResult ConvertFloatToDecimal(char *buffer, size_t size,
+ConversionToDecimalResult ConvertFloatToDecimal(char *buffer, std::size_t size,
     enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, float x) {
   return Fortran::decimal::ConvertToDecimal(buffer, size, flags, digits,
       rounding, Fortran::decimal::BinaryFloatingPointNumber<24>(x));
 }
 
-ConversionToDecimalResult ConvertDoubleToDecimal(char *buffer, size_t size,
+ConversionToDecimalResult ConvertDoubleToDecimal(char *buffer, std::size_t size,
     enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, double x) {
   return Fortran::decimal::ConvertToDecimal(buffer, size, flags, digits,
@@ -390,8 +390,8 @@ ConversionToDecimalResult ConvertDoubleToDecimal(char *buffer, size_t size,
 }
 
 #if __x86_64__
-ConversionToDecimalResult ConvertLongDoubleToDecimal(char *buffer, size_t size,
-    enum DecimalConversionFlags flags, int digits,
+ConversionToDecimalResult ConvertLongDoubleToDecimal(char *buffer,
+    std::size_t size, enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, long double x) {
   return Fortran::decimal::ConvertToDecimal(buffer, size, flags, digits,
       rounding, Fortran::decimal::BinaryFloatingPointNumber<64>(x));
diff --git a/lib/decimal/decimal-to-binary.cpp b/lib/decimal/decimal-to-binary.cpp
index de15833098f5..a07cd570d8c3 100644
--- a/lib/decimal/decimal-to-binary.cpp
+++ b/lib/decimal/decimal-to-binary.cpp
@@ -122,7 +122,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
         // The decimal->binary conversion routine will cope with
         // returning 0 or Inf, but we must ensure that "expo" didn't
         // overflow back around to something legal.
-        expo = 10 * Real::RANGE;
+        expo = 10 * Real::decimalRange;
         exponent_ = 0;
       }
       p = q;  // exponent was valid
@@ -256,7 +256,7 @@ ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
   using Raw = typename Binary::RawType;
   Raw raw = static_cast<Raw>(isNegative) << (Binary::bits - 1);
   raw |= static_cast<Raw>(expo) << Binary::significandBits;
-  if constexpr (Binary::implicitMSB) {
+  if constexpr (Binary::isImplicitMSB) {
     fraction &= ~topBit;
   }
   raw |= fraction;
@@ -278,7 +278,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   // it sits to the *left* of the digits: i.e., x = .D * 10.**E
   exponent_ += digits_ * log10Radix;
   // Sanity checks for ridiculous exponents
-  static constexpr int crazy{2 * Real::RANGE + log10Radix};
+  static constexpr int crazy{2 * Real::decimalRange + log10Radix};
   if (exponent_ < -crazy) {  // underflow to +/-0.
     return {Real{SignBit()}, Inexact};
   } else if (exponent_ > crazy) {  // overflow to +/-Inf.
diff --git a/lib/evaluate/characteristics.cpp b/lib/evaluate/characteristics.cpp
index ac18b5a1730b..3197c46863fa 100644
--- a/lib/evaluate/characteristics.cpp
+++ b/lib/evaluate/characteristics.cpp
@@ -121,35 +121,6 @@ std::optional<TypeAndShape> TypeAndShape::Characterize(
   }
 }
 
-#if 0  // pmk
-std::optional<TypeAndShape> TypeAndShape::Characterize(
-    const Expr<SomeType> &expr, FoldingContext &context) {
-  if (const auto *symbol{UnwrapWholeSymbolDataRef(expr)}) {
-    if (const auto *object{
-            symbol->detailsIf<semantics::ObjectEntityDetails>()}) {
-      return Characterize(*object);
-    } else if (const auto *assoc{
-                   symbol->detailsIf<semantics::AssocEntityDetails>()}) {
-      return Characterize(*assoc, context);
-    }
-  }
-  if (auto type{expr.GetType()}) {
-    if (auto shape{GetShape(context, expr)}) {
-      TypeAndShape result{*type, std::move(*shape)};
-      if (type->category() == TypeCategory::Character) {
-        if (const auto *chExpr{UnwrapExpr<Expr<SomeCharacter>>(expr)}) {
-          if (auto length{chExpr->LEN()}) {
-            result.set_LEN(Expr<SomeInteger>{std::move(*length)});
-          }
-        }
-      }
-      return result;
-    }
-  }
-  return std::nullopt;
-}
-#endif  // pmk
-
 bool TypeAndShape::IsCompatibleWith(parser::ContextualMessages &messages,
     const TypeAndShape &that, const char *thisIs, const char *thatIs,
     bool isElemental) const {
diff --git a/lib/evaluate/complex.cpp b/lib/evaluate/complex.cpp
index 210fd1fb54c5..a2dca42e4e0b 100644
--- a/lib/evaluate/complex.cpp
+++ b/lib/evaluate/complex.cpp
@@ -100,6 +100,6 @@ template class Complex<Real<Integer<16>, 11>>;
 template class Complex<Real<Integer<16>, 8>>;
 template class Complex<Real<Integer<32>, 24>>;
 template class Complex<Real<Integer<64>, 53>>;
-template class Complex<Real<Integer<80>, 64, false>>;
+template class Complex<Real<Integer<80>, 64>>;
 template class Complex<Real<Integer<128>, 112>>;
 }
diff --git a/lib/evaluate/real.cpp b/lib/evaluate/real.cpp
index ec9ab1dd4373..29ad1e0aa5a3 100644
--- a/lib/evaluate/real.cpp
+++ b/lib/evaluate/real.cpp
@@ -15,8 +15,7 @@
 
 namespace Fortran::evaluate::value {
 
-template<typename W, int P, bool IM>
-Relation Real<W, P, IM>::Compare(const Real &y) const {
+template<typename W, int P> Relation Real<W, P>::Compare(const Real &y) const {
   if (IsNotANumber() || y.IsNotANumber()) {  // NaN vs x, x vs NaN
     return Relation::Unordered;
   } else if (IsInfinite()) {
@@ -53,8 +52,8 @@ Relation Real<W, P, IM>::Compare(const Real &y) const {
   }
 }
 
-template<typename W, int P, bool IM>
-ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::Add(
+template<typename W, int P>
+ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
@@ -133,8 +132,8 @@ ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::Add(
   return result;
 }
 
-template<typename W, int P, bool IM>
-ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::Multiply(
+template<typename W, int P>
+ValueWithRealFlags<Real<W, P>> Real<W, P>::Multiply(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
@@ -193,8 +192,8 @@ ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::Multiply(
   return result;
 }
 
-template<typename W, int P, bool IM>
-ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::Divide(
+template<typename W, int P>
+ValueWithRealFlags<Real<W, P>> Real<W, P>::Divide(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
@@ -261,8 +260,8 @@ ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::Divide(
   return result;
 }
 
-template<typename W, int P, bool IM>
-ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::ToWholeNumber(
+template<typename W, int P>
+ValueWithRealFlags<Real<W, P>> Real<W, P>::ToWholeNumber(
     common::RoundingMode mode) const {
   ValueWithRealFlags<Real> result{*this};
   if (IsNotANumber()) {
@@ -271,7 +270,7 @@ ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::ToWholeNumber(
   } else if (IsInfinite()) {
     result.flags.set(RealFlag::Overflow);
   } else {
-    constexpr int noClipExponent{exponentBias + precision - 1};
+    constexpr int noClipExponent{exponentBias + binaryPrecision - 1};
     if (Exponent() < noClipExponent) {
       Real adjust;  // ABS(EPSILON(adjust)) == 0.5
       adjust.Normalize(IsSignBitSet(), noClipExponent, Fraction::MASKL(1));
@@ -287,8 +286,8 @@ ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::ToWholeNumber(
   return result;
 }
 
-template<typename W, int P, bool IM>
-RealFlags Real<W, P, IM>::Normalize(bool negative, int exponent,
+template<typename W, int P>
+RealFlags Real<W, P>::Normalize(bool negative, int exponent,
     const Fraction &fraction, Rounding rounding, RoundingBits *roundingBits) {
   int lshift{fraction.LEADZ()};
   if (lshift == fraction.bits /* fraction is zero */ &&
@@ -337,7 +336,7 @@ RealFlags Real<W, P, IM>::Normalize(bool negative, int exponent,
       }
     }
   }
-  if constexpr (implicitMSB) {
+  if constexpr (isImplicitMSB) {
     word_ = word_.IBCLR(significandBits);
   }
   word_ = word_.IOR(Word{exponent}.SHIFTL(significandBits));
@@ -347,8 +346,8 @@ RealFlags Real<W, P, IM>::Normalize(bool negative, int exponent,
   return {};
 }
 
-template<typename W, int P, bool IM>
-RealFlags Real<W, P, IM>::Round(
+template<typename W, int P>
+RealFlags Real<W, P>::Round(
     Rounding rounding, const RoundingBits &bits, bool multiply) {
   int origExponent{Exponent()};
   RealFlags flags;
@@ -363,7 +362,7 @@ RealFlags Real<W, P, IM>::Round(
     int newExponent{origExponent};
     if (sum.carry) {
       // The fraction was all ones before rounding; sum.value is now zero
-      sum.value = sum.value.IBSET(precision - 1);
+      sum.value = sum.value.IBSET(binaryPrecision - 1);
       if (++newExponent >= maxExponent) {
         flags.set(RealFlag::Overflow);  // rounded away to an infinity
       }
@@ -388,8 +387,8 @@ RealFlags Real<W, P, IM>::Round(
   return flags;
 }
 
-template<typename W, int P, bool IM>
-void Real<W, P, IM>::NormalizeAndRound(ValueWithRealFlags<Real> &result,
+template<typename W, int P>
+void Real<W, P>::NormalizeAndRound(ValueWithRealFlags<Real> &result,
     bool isNegative, int exponent, const Fraction &fraction, Rounding rounding,
     RoundingBits roundingBits, bool multiply) {
   result.flags |= result.value.Normalize(
@@ -423,17 +422,16 @@ inline RealFlags MapFlags(decimal::ConversionResultFlags flags) {
   return result;
 }
 
-template<typename W, int P, bool IM>
-ValueWithRealFlags<Real<W, P, IM>> Real<W, P, IM>::Read(
+template<typename W, int P>
+ValueWithRealFlags<Real<W, P>> Real<W, P>::Read(
     const char *&p, Rounding rounding) {
   auto converted{
       decimal::ConvertToBinary<P>(p, MapRoundingMode(rounding.mode))};
-  const auto *value{reinterpret_cast<Real<W, P, IM> *>(&converted.binary)};
+  const auto *value{reinterpret_cast<Real<W, P> *>(&converted.binary)};
   return {*value, MapFlags(converted.flags)};
 }
 
-template<typename W, int P, bool IM>
-std::string Real<W, P, IM>::DumpHexadecimal() const {
+template<typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
   if (IsNotANumber()) {
     return "NaN 0x"s + word_.Hexadecimal();
   } else if (IsNegative()) {
@@ -479,8 +477,8 @@ std::string Real<W, P, IM>::DumpHexadecimal() const {
   }
 }
 
-template<typename W, int P, bool IM>
-std::ostream &Real<W, P, IM>::AsFortran(
+template<typename W, int P>
+std::ostream &Real<W, P>::AsFortran(
     std::ostream &o, int kind, bool minimal) const {
   if (IsNotANumber()) {
     o << "(0._" << kind << "/0.)";
@@ -521,6 +519,6 @@ template class Real<Integer<16>, 11>;
 template class Real<Integer<16>, 8>;
 template class Real<Integer<32>, 24>;
 template class Real<Integer<64>, 53>;
-template class Real<Integer<80>, 64, false>;
+template class Real<Integer<80>, 64>;
 template class Real<Integer<128>, 112>;
 }
diff --git a/module/iso_fortran_env.f90 b/module/iso_fortran_env.f90
index 01676cd7f894..957c3ec88131 100644
--- a/module/iso_fortran_env.f90
+++ b/module/iso_fortran_env.f90
@@ -128,7 +128,8 @@ module iso_fortran_env
 
   integer, parameter :: current_team = -1, initial_team = -2, parent_team = -3
 
-  integer, parameter :: input_unit = 5, output_unit = 6, error_unit = 0
+  integer, parameter :: input_unit = 5, output_unit = 6
+  integer, parameter :: error_unit = output_unit
   integer, parameter :: iostat_end = -1, iostat_eor = -2
   integer, parameter :: iostat_inquire_internal_unit = -1
 
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index 4c1ecf0be736..571775ce8984 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -9,16 +9,19 @@
 add_library(FortranRuntime
   ISO_Fortran_binding.cpp
   buffer.cpp
+  connection.cpp
   derived-type.cpp
   descriptor.cpp
   environment.cpp
   file.cpp
   format.cpp
+  internal-unit.cpp
   io-api.cpp
   io-error.cpp
   io-stmt.cpp
   main.cpp
   memory.cpp
+  numeric-output.cpp
   stop.cpp
   terminator.cpp
   tools.cpp
diff --git a/runtime/buffer.h b/runtime/buffer.h
index 57c740fabfa8..a956a3bbae1d 100644
--- a/runtime/buffer.h
+++ b/runtime/buffer.h
@@ -97,14 +97,13 @@ template<typename STORE> class FileFrame {
     }
     dirty_ = true;
     frame_ = at - fileOffset_;
-    length_ = std::max(length_, static_cast<std::int64_t>(frame_ + bytes));
+    length_ = std::max<std::int64_t>(length_, frame_ + bytes);
   }
 
   void Flush(IoErrorHandler &handler) {
     if (dirty_) {
       while (length_ > 0) {
-        std::size_t chunk{std::min(static_cast<std::size_t>(length_),
-            static_cast<std::size_t>(size_ - start_))};
+        std::size_t chunk{std::min<std::size_t>(length_, size_ - start_)};
         std::size_t put{
             Store().Write(fileOffset_, buffer_ + start_, chunk, handler)};
         length_ -= put;
@@ -121,15 +120,14 @@ template<typename STORE> class FileFrame {
 private:
   STORE &Store() { return static_cast<STORE &>(*this); }
 
-  void Reallocate(std::size_t bytes, Terminator &terminator) {
+  void Reallocate(std::size_t bytes, const Terminator &terminator) {
     if (bytes > size_) {
       char *old{buffer_};
       auto oldSize{size_};
       size_ = std::max(bytes, minBuffer);
       buffer_ =
           reinterpret_cast<char *>(AllocateMemoryOrCrash(terminator, size_));
-      auto chunk{
-          std::min(length_, static_cast<std::int64_t>(oldSize - start_))};
+      auto chunk{std::min<std::int64_t>(length_, oldSize - start_)};
       std::memcpy(buffer_, old + start_, chunk);
       start_ = 0;
       std::memcpy(buffer_ + chunk, old, length_ - chunk);
@@ -143,7 +141,7 @@ template<typename STORE> class FileFrame {
     dirty_ = false;
   }
 
-  void DiscardLeadingBytes(std::size_t n, Terminator &terminator) {
+  void DiscardLeadingBytes(std::size_t n, const Terminator &terminator) {
     RUNTIME_CHECK(terminator, length_ >= n);
     length_ -= n;
     if (length_ == 0) {
diff --git a/runtime/connection.cpp b/runtime/connection.cpp
new file mode 100644
index 000000000000..ff15a40819ab
--- /dev/null
+++ b/runtime/connection.cpp
@@ -0,0 +1,19 @@
+//===-- runtime/connection.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 "connection.h"
+#include "environment.h"
+
+namespace Fortran::runtime::io {
+
+std::size_t ConnectionState::RemainingSpaceInRecord() const {
+  return recordLength.value_or(
+             executionEnvironment.listDirectedOutputLineLengthLimit) -
+      positionInRecord;
+}
+}
diff --git a/runtime/connection.h b/runtime/connection.h
new file mode 100644
index 000000000000..85372dfa610d
--- /dev/null
+++ b/runtime/connection.h
@@ -0,0 +1,50 @@
+//===-- runtime/connection.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
+//
+//===----------------------------------------------------------------------===//
+
+// Fortran I/O connection state (internal & external)
+
+#ifndef FORTRAN_RUNTIME_IO_CONNECTION_H_
+#define FORTRAN_RUNTIME_IO_CONNECTION_H_
+
+#include "format.h"
+#include <cinttypes>
+#include <optional>
+
+namespace Fortran::runtime::io {
+
+enum class Access { Sequential, Direct, Stream };
+
+inline bool IsRecordFile(Access a) { return a != Access::Stream; }
+
+// These characteristics of a connection are immutable after being
+// established in an OPEN statement.
+struct ConnectionAttributes {
+  Access access{Access::Sequential};  // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
+  std::optional<std::size_t> recordLength;  // RECL= when fixed-length
+  bool isUnformatted{false};  // FORM='UNFORMATTED'
+  bool isUTF8{false};  // ENCODING='UTF-8'
+};
+
+struct ConnectionState : public ConnectionAttributes {
+  std::size_t RemainingSpaceInRecord() const;
+  // Positions in a record file (sequential or direct, but not stream)
+  std::int64_t recordOffsetInFile{0};
+  std::int64_t currentRecordNumber{1};  // 1 is first
+  std::int64_t positionInRecord{0};  // offset in current record
+  std::int64_t furthestPositionInRecord{0};  // max(positionInRecord)
+  bool nonAdvancing{false};  // ADVANCE='NO'
+  // Set at end of non-advancing I/O data transfer
+  std::optional<std::int64_t> leftTabLimit;  // offset in current record
+  // currentRecordNumber value captured after ENDFILE/REWIND/BACKSPACE statement
+  // on a sequential access file
+  std::optional<std::int64_t> endfileRecordNumber;
+  // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
+  MutableModes modes;  // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
+};
+}
+#endif  // FORTRAN_RUNTIME_IO_CONNECTION_H_
diff --git a/runtime/descriptor.cpp b/runtime/descriptor.cpp
index c8895dd6d246..ca065246d522 100644
--- a/runtime/descriptor.cpp
+++ b/runtime/descriptor.cpp
@@ -10,9 +10,14 @@
 #include "flang/common/idioms.h"
 #include <cassert>
 #include <cstdlib>
+#include <cstring>
 
 namespace Fortran::runtime {
 
+Descriptor::Descriptor(const Descriptor &that) {
+  std::memcpy(this, &that, that.SizeInBytes());
+}
+
 Descriptor::~Descriptor() {
   if (raw_.attribute != CFI_attribute_pointer) {
     Deallocate();
diff --git a/runtime/descriptor.h b/runtime/descriptor.h
index 3a4f2ce3a29c..bb8a428c83ec 100644
--- a/runtime/descriptor.h
+++ b/runtime/descriptor.h
@@ -125,6 +125,7 @@ class Descriptor {
     raw_.base_addr = nullptr;
     raw_.f18Addendum = false;
   }
+  Descriptor(const Descriptor &);
 
   ~Descriptor();
 
diff --git a/runtime/environment.cpp b/runtime/environment.cpp
index 5ce55ab47459..735312b9f57c 100644
--- a/runtime/environment.cpp
+++ b/runtime/environment.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "environment.h"
+#include <cstdio>
 #include <cstdlib>
 #include <limits>
 
@@ -19,7 +20,8 @@ void ExecutionEnvironment::Configure(
   argv = av;
   envp = env;
   listDirectedOutputLineLengthLimit = 79;  // PGI default
-  defaultOutputRoundingMode = common::RoundingMode::TiesToEven;  // RP=RN
+  defaultOutputRoundingMode =
+      decimal::FortranRounding::RoundNearest;  // RP(==RN)
 
   if (auto *x{std::getenv("FORT_FMT_RECL")}) {
     char *end;
diff --git a/runtime/environment.h b/runtime/environment.h
index 25a98959b741..056a13829b2a 100644
--- a/runtime/environment.h
+++ b/runtime/environment.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_RUNTIME_ENVIRONMENT_H_
 #define FORTRAN_RUNTIME_ENVIRONMENT_H_
 
-#include "flang/common/Fortran.h"
+#include "flang/decimal/decimal.h"
 
 namespace Fortran::runtime {
 struct ExecutionEnvironment {
@@ -19,8 +19,9 @@ struct ExecutionEnvironment {
   const char **argv;
   const char **envp;
   int listDirectedOutputLineLengthLimit;
-  common::RoundingMode defaultOutputRoundingMode;
+  enum decimal::FortranRounding defaultOutputRoundingMode;
 };
 extern ExecutionEnvironment executionEnvironment;
 }
+
 #endif  // FORTRAN_RUNTIME_ENVIRONMENT_H_
diff --git a/runtime/file.cpp b/runtime/file.cpp
index f9c18c741734..9ee4ae3c4318 100644
--- a/runtime/file.cpp
+++ b/runtime/file.cpp
@@ -9,7 +9,6 @@
 #include "file.h"
 #include "magic-numbers.h"
 #include "memory.h"
-#include "tools.h"
 #include <cerrno>
 #include <cstring>
 #include <fcntl.h>
@@ -18,49 +17,22 @@
 
 namespace Fortran::runtime::io {
 
-void OpenFile::Open(const char *path, std::size_t pathLength,
-    const char *status, std::size_t statusLength, const char *action,
-    std::size_t actionLength, IoErrorHandler &handler) {
-  CriticalSection criticalSection{lock_};
-  RUNTIME_CHECK(handler, fd_ < 0);  // TODO handle re-openings
-  int flags{0};
-  static const char *actions[]{"READ", "WRITE", "READWRITE", nullptr};
-  switch (IdentifyValue(action, actionLength, actions)) {
-  case 0:
-    flags = O_RDONLY;
-    mayRead_ = true;
-    mayWrite_ = false;
-    break;
-  case 1:
-    flags = O_WRONLY;
-    mayRead_ = false;
-    mayWrite_ = true;
-    break;
-  case 2:
-    mayRead_ = true;
-    mayWrite_ = true;
-    flags = O_RDWR;
-    break;
-  default:
-    handler.Crash(
-        "Invalid ACTION='%.*s'", action, static_cast<int>(actionLength));
-  }
-  if (!status) {
-    status = "UNKNOWN", statusLength = 7;
-  }
-  static const char *statuses[]{
-      "OLD", "NEW", "SCRATCH", "REPLACE", "UNKNOWN", nullptr};
-  switch (IdentifyValue(status, statusLength, statuses)) {
-  case 0:  // STATUS='OLD'
-    if (!path && fd_ >= 0) {
-      // TODO: Update OpenFile in situ; can ACTION be changed?
+void OpenFile::set_path(OwningPtr<char> &&path, std::size_t bytes) {
+  path_ = std::move(path);
+  pathLength_ = bytes;
+}
+
+void OpenFile::Open(
+    OpenStatus status, Position position, IoErrorHandler &handler) {
+  int flags{mayRead_ ? mayWrite_ ? O_RDWR : O_RDONLY : O_WRONLY};
+  switch (status) {
+  case OpenStatus::Old:
+    if (fd_ >= 0) {
       return;
     }
     break;
-  case 1:  // STATUS='NEW'
-    flags |= O_CREAT | O_EXCL;
-    break;
-  case 2:  // STATUS='SCRATCH'
+  case OpenStatus::New: flags |= O_CREAT | O_EXCL; break;
+  case OpenStatus::Scratch:
     if (path_.get()) {
       handler.Crash("FILE= must not appear with STATUS='SCRATCH'");
       path_.reset();
@@ -74,27 +46,22 @@ void OpenFile::Open(const char *path, std::size_t pathLength,
       ::unlink(path);
     }
     return;
-  case 3:  // STATUS='REPLACE'
-    flags |= O_CREAT | O_TRUNC;
-    break;
-  case 4:  // STATUS='UNKNOWN'
+  case OpenStatus::Replace: flags |= O_CREAT | O_TRUNC; break;
+  case OpenStatus::Unknown:
     if (fd_ >= 0) {
       return;
     }
     flags |= O_CREAT;
     break;
-  default:
-    handler.Crash(
-        "Invalid STATUS='%.*s'", status, static_cast<int>(statusLength));
   }
   // If we reach this point, we're opening a new file
   if (fd_ >= 0) {
-    if (::close(fd_) != 0) {
+    if (fd_ <= 2) {
+      // don't actually close a standard file descriptor, we might need it
+    } else if (::close(fd_) != 0) {
       handler.SignalErrno();
     }
   }
-  path_ = SaveDefaultCharacter(path, pathLength, handler);
-  pathLength_ = pathLength;
   if (!path_.get()) {
     handler.Crash(
         "FILE= is required unless STATUS='OLD' and unit is connected");
@@ -105,6 +72,10 @@ void OpenFile::Open(const char *path, std::size_t pathLength,
   }
   pending_.reset();
   knownSize_.reset();
+  if (position == Position::Append && !RawSeekToEnd()) {
+    handler.SignalErrno();
+  }
+  isTerminal_ = ::isatty(fd_) == 1;
 }
 
 void OpenFile::Predefine(int fd) {
@@ -118,25 +89,18 @@ void OpenFile::Predefine(int fd) {
   pending_.reset();
 }
 
-void OpenFile::Close(
-    const char *status, std::size_t statusLength, IoErrorHandler &handler) {
+void OpenFile::Close(CloseStatus status, IoErrorHandler &handler) {
   CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   pending_.reset();
   knownSize_.reset();
-  static const char *statuses[]{"KEEP", "DELETE", nullptr};
-  switch (IdentifyValue(status, statusLength, statuses)) {
-  case 0: break;
-  case 1:
+  switch (status) {
+  case CloseStatus::Keep: break;
+  case CloseStatus::Delete:
     if (path_.get()) {
       ::unlink(path_.get());
     }
     break;
-  default:
-    if (status) {
-      handler.Crash(
-          "Invalid STATUS='%.*s'", status, static_cast<int>(statusLength));
-    }
   }
   path_.reset();
   if (fd_ >= 0) {
@@ -319,7 +283,7 @@ void OpenFile::WaitAll(IoErrorHandler &handler) {
   }
 }
 
-void OpenFile::CheckOpen(Terminator &terminator) {
+void OpenFile::CheckOpen(const Terminator &terminator) {
   RUNTIME_CHECK(terminator, fd_ >= 0);
 }
 
@@ -337,13 +301,27 @@ bool OpenFile::Seek(FileOffset at, IoErrorHandler &handler) {
 
 bool OpenFile::RawSeek(FileOffset at) {
 #ifdef _LARGEFILE64_SOURCE
-  return ::lseek64(fd_, at, SEEK_SET) == 0;
+  return ::lseek64(fd_, at, SEEK_SET) == at;
 #else
-  return ::lseek(fd_, at, SEEK_SET) == 0;
+  return ::lseek(fd_, at, SEEK_SET) == at;
 #endif
 }
 
-int OpenFile::PendingResult(Terminator &terminator, int iostat) {
+bool OpenFile::RawSeekToEnd() {
+#ifdef _LARGEFILE64_SOURCE
+  std::int64_t at{::lseek64(fd_, 0, SEEK_END)};
+#else
+  std::int64_t at{::lseek(fd_, 0, SEEK_END)};
+#endif
+  if (at >= 0) {
+    knownSize_ = at;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+int OpenFile::PendingResult(const Terminator &terminator, int iostat) {
   int id{nextId_++};
   pending_.reset(&New<Pending>{}(terminator, id, iostat, std::move(pending_)));
   return id;
diff --git a/runtime/file.h b/runtime/file.h
index d5e521756653..9ed1c250364a 100644
--- a/runtime/file.h
+++ b/runtime/file.h
@@ -19,25 +19,33 @@
 
 namespace Fortran::runtime::io {
 
+enum class OpenStatus { Old, New, Scratch, Replace, Unknown };
+enum class CloseStatus { Keep, Delete };
+enum class Position { AsIs, Rewind, Append };
+
 class OpenFile {
 public:
   using FileOffset = std::int64_t;
 
-  FileOffset position() const { return position_; }
-
-  void Open(const char *path, std::size_t pathLength, const char *status,
-      std::size_t statusLength, const char *action, std::size_t actionLength,
-      IoErrorHandler &);
-  void Predefine(int fd);
-  void Close(const char *action, std::size_t actionLength, IoErrorHandler &);
-
-  int fd() const { return fd_; }
+  Lock &lock() { return lock_; }
+  const char *path() const { return path_.get(); }
+  void set_path(OwningPtr<char> &&, std::size_t bytes);
+  std::size_t pathLength() const { return pathLength_; }
   bool mayRead() const { return mayRead_; }
-  bool mayWrite() const { return mayWrite_; }
-  bool mayPosition() const { return mayPosition_; }
   void set_mayRead(bool yes) { mayRead_ = yes; }
+  bool mayWrite() const { return mayWrite_; }
   void set_mayWrite(bool yes) { mayWrite_ = yes; }
+  bool mayAsynchronous() const { return mayAsynchronous_; }
+  void set_mayAsynchronous(bool yes) { mayAsynchronous_ = yes; }
+  bool mayPosition() const { return mayPosition_; }
   void set_mayPosition(bool yes) { mayPosition_ = yes; }
+  FileOffset position() const { return position_; }
+  bool isTerminal() const { return isTerminal_; }
+
+  bool IsOpen() const { return fd_ >= 0; }
+  void Open(OpenStatus, Position, IoErrorHandler &);
+  void Predefine(int fd);
+  void Close(CloseStatus, IoErrorHandler &);
 
   // Reads data into memory; returns amount acquired.  Synchronous.
   // Partial reads (less than minBytes) signify end-of-file.  If the
@@ -69,10 +77,11 @@ class OpenFile {
   };
 
   // lock_ must be held for these
-  void CheckOpen(Terminator &);
+  void CheckOpen(const Terminator &);
   bool Seek(FileOffset, IoErrorHandler &);
   bool RawSeek(FileOffset);
-  int PendingResult(Terminator &, int);
+  bool RawSeekToEnd();
+  int PendingResult(const Terminator &, int);
 
   Lock lock_;
   int fd_{-1};
@@ -81,8 +90,11 @@ class OpenFile {
   bool mayRead_{false};
   bool mayWrite_{false};
   bool mayPosition_{false};
+  bool mayAsynchronous_{false};
   FileOffset position_{0};
   std::optional<FileOffset> knownSize_;
+  bool isTerminal_{false};
+
   int nextId_;
   OwningPtr<Pending> pending_;
 };
diff --git a/runtime/format-implementation.h b/runtime/format-implementation.h
new file mode 100644
index 000000000000..cb5fc2dfd8b5
--- /dev/null
+++ b/runtime/format-implementation.h
@@ -0,0 +1,355 @@
+//===-- runtime/format-implementation.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
+//
+//===----------------------------------------------------------------------===//
+
+// Implements out-of-line member functions of template class FormatControl
+
+#ifndef FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
+#define FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
+
+#include "format.h"
+#include "io-stmt.h"
+#include "main.h"
+#include "flang/common/format.h"
+#include "flang/decimal/decimal.h"
+#include <limits>
+
+namespace Fortran::runtime::io {
+
+template<typename CONTEXT>
+FormatControl<CONTEXT>::FormatControl(const Terminator &terminator,
+    const CharType *format, std::size_t formatLength, int maxHeight)
+  : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
+    formatLength_{static_cast<int>(formatLength)} {
+  if (maxHeight != maxHeight_) {
+    terminator.Crash("internal Fortran runtime error: maxHeight %d", maxHeight);
+  }
+  if (formatLength != static_cast<std::size_t>(formatLength_)) {
+    terminator.Crash(
+        "internal Fortran runtime error: formatLength %zd", formatLength);
+  }
+  stack_[0].start = offset_;
+  stack_[0].remaining = Iteration::unlimited;  // 13.4(8)
+}
+
+template<typename CONTEXT>
+int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
+    const Terminator &terminator, const CharType *format,
+    std::size_t formatLength) {
+  using Validator = common::FormatValidator<CharType>;
+  typename Validator::Reporter reporter{
+      [&](const common::FormatMessage &message) {
+        terminator.Crash(message.text, message.arg);
+        return false;  // crashes on error above
+      }};
+  Validator validator{format, formatLength, reporter};
+  validator.Check();
+  return validator.maxNesting();
+}
+
+template<typename CONTEXT>
+int FormatControl<CONTEXT>::GetIntField(
+    const Terminator &terminator, CharType firstCh) {
+  CharType ch{firstCh ? firstCh : PeekNext()};
+  if (ch != '-' && ch != '+' && (ch < '0' || ch > '9')) {
+    terminator.Crash(
+        "Invalid FORMAT: integer expected at '%c'", static_cast<char>(ch));
+  }
+  int result{0};
+  bool negate{ch == '-'};
+  if (negate) {
+    firstCh = '\0';
+    ch = PeekNext();
+  }
+  while (ch >= '0' && ch <= '9') {
+    if (result >
+        std::numeric_limits<int>::max() / 10 - (static_cast<int>(ch) - '0')) {
+      terminator.Crash("FORMAT integer field out of range");
+    }
+    result = 10 * result + ch - '0';
+    if (firstCh) {
+      firstCh = '\0';
+    } else {
+      ++offset_;
+    }
+    ch = PeekNext();
+  }
+  if (negate && (result *= -1) > 0) {
+    terminator.Crash("FORMAT integer field out of range");
+  }
+  return result;
+}
+
+template<typename CONTEXT>
+static void HandleControl(CONTEXT &context, char ch, char next, int n) {
+  MutableModes &modes{context.mutableModes()};
+  switch (ch) {
+  case 'B':
+    if (next == 'Z') {
+      modes.editingFlags |= blankZero;
+      return;
+    }
+    if (next == 'N') {
+      modes.editingFlags &= ~blankZero;
+      return;
+    }
+    break;
+  case 'D':
+    if (next == 'C') {
+      modes.editingFlags |= decimalComma;
+      return;
+    }
+    if (next == 'P') {
+      modes.editingFlags &= ~decimalComma;
+      return;
+    }
+    break;
+  case 'P':
+    if (!next) {
+      modes.scale = n;  // kP - decimal scaling by 10**k
+      return;
+    }
+    break;
+  case 'R':
+    switch (next) {
+    case 'N': modes.round = decimal::RoundNearest; return;
+    case 'Z': modes.round = decimal::RoundToZero; return;
+    case 'U': modes.round = decimal::RoundUp; return;
+    case 'D': modes.round = decimal::RoundDown; return;
+    case 'C': modes.round = decimal::RoundCompatible; return;
+    case 'P':
+      modes.round = executionEnvironment.defaultOutputRoundingMode;
+      return;
+    default: break;
+    }
+    break;
+  case 'X':
+    if (!next) {
+      context.HandleRelativePosition(n);
+      return;
+    }
+    break;
+  case 'S':
+    if (next == 'P') {
+      modes.editingFlags |= signPlus;
+      return;
+    }
+    if (!next || next == 'S') {
+      modes.editingFlags &= ~signPlus;
+      return;
+    }
+    break;
+  case 'T': {
+    if (!next) {  // Tn
+      context.HandleAbsolutePosition(n - 1);  // convert 1-based to 0-based
+      return;
+    }
+    if (next == 'L' || next == 'R') {  // TLn & TRn
+      context.HandleRelativePosition(next == 'L' ? -n : n);
+      return;
+    }
+  } break;
+  default: break;
+  }
+  if (next) {
+    context.Crash("Unknown '%c%c' edit descriptor in FORMAT", ch, next);
+  } else {
+    context.Crash("Unknown '%c' edit descriptor in FORMAT", ch);
+  }
+}
+
+// Locates the next data edit descriptor in the format.
+// Handles all repetition counts and control edit descriptors.
+// Generally assumes that the format string has survived the common
+// format validator gauntlet.
+template<typename CONTEXT>
+int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
+  int unlimitedLoopCheck{-1};
+  while (true) {
+    std::optional<int> repeat;
+    bool unlimited{false};
+    CharType ch{Capitalize(GetNextChar(context))};
+    while (ch == ',' || ch == ':') {
+      // Skip commas, and don't complain if they're missing; the format
+      // validator does that.
+      if (stop && ch == ':') {
+        return 0;
+      }
+      ch = Capitalize(GetNextChar(context));
+    }
+    if (ch == '-' || ch == '+' || (ch >= '0' && ch <= '9')) {
+      repeat = GetIntField(context, ch);
+      ch = GetNextChar(context);
+    } else if (ch == '*') {
+      unlimited = true;
+      ch = GetNextChar(context);
+      if (ch != '(') {
+        context.Crash("Invalid FORMAT: '*' may appear only before '('");
+      }
+    }
+    if (ch == '(') {
+      if (height_ >= maxHeight_) {
+        context.Crash("FORMAT stack overflow: too many nested parentheses");
+      }
+      stack_[height_].start = offset_ - 1;  // the '('
+      if (unlimited || height_ == 0) {
+        stack_[height_].remaining = Iteration::unlimited;
+        unlimitedLoopCheck = offset_ - 1;
+      } else if (repeat) {
+        if (*repeat <= 0) {
+          *repeat = 1;  // error recovery
+        }
+        stack_[height_].remaining = *repeat - 1;
+      } else {
+        stack_[height_].remaining = 0;
+      }
+      ++height_;
+    } else if (height_ == 0) {
+      context.Crash("FORMAT lacks initial '('");
+    } else if (ch == ')') {
+      if (height_ == 1) {
+        if (stop) {
+          return 0;  // end of FORMAT and no data items remain
+        }
+        context.AdvanceRecord();  // implied / before rightmost )
+      }
+      if (stack_[height_ - 1].remaining == Iteration::unlimited) {
+        offset_ = stack_[height_ - 1].start + 1;
+        if (offset_ == unlimitedLoopCheck) {
+          context.Crash(
+              "Unlimited repetition in FORMAT lacks data edit descriptors");
+        }
+      } else if (stack_[height_ - 1].remaining-- > 0) {
+        offset_ = stack_[height_ - 1].start + 1;
+      } else {
+        --height_;
+      }
+    } else if (ch == '\'' || ch == '"') {
+      // Quoted 'character literal'
+      CharType quote{ch};
+      auto start{offset_};
+      while (offset_ < formatLength_ && format_[offset_] != quote) {
+        ++offset_;
+      }
+      if (offset_ >= formatLength_) {
+        context.Crash("FORMAT missing closing quote on character literal");
+      }
+      ++offset_;
+      std::size_t chars{
+          static_cast<std::size_t>(&format_[offset_] - &format_[start])};
+      if (PeekNext() == quote) {
+        // subtle: handle doubled quote character in a literal by including
+        // the first in the output, then treating the second as the start
+        // of another character literal.
+      } else {
+        --chars;
+      }
+      context.Emit(format_ + start, chars);
+    } else if (ch == 'H') {
+      // 9HHOLLERITH
+      if (!repeat || *repeat < 1 || offset_ + *repeat > formatLength_) {
+        context.Crash("Invalid width on Hollerith in FORMAT");
+      }
+      context.Emit(format_ + offset_, static_cast<std::size_t>(*repeat));
+      offset_ += *repeat;
+    } else if (ch >= 'A' && ch <= 'Z') {
+      int start{offset_ - 1};
+      CharType next{Capitalize(PeekNext())};
+      if (next >= 'A' && next <= 'Z') {
+        ++offset_;
+      } else {
+        next = '\0';
+      }
+      if (ch == 'E' ||
+          (!next &&
+              (ch == 'A' || ch == 'I' || ch == 'B' || ch == 'O' || ch == 'Z' ||
+                  ch == 'F' || ch == 'D' || ch == 'G' || ch == 'L'))) {
+        // Data edit descriptor found
+        offset_ = start;
+        return repeat && *repeat > 0 ? *repeat : 1;
+      } else {
+        // Control edit descriptor
+        if (ch == 'T') {  // Tn, TLn, TRn
+          repeat = GetIntField(context);
+        }
+        HandleControl(context, static_cast<char>(ch), static_cast<char>(next),
+            repeat ? *repeat : 1);
+      }
+    } else if (ch == '/') {
+      context.AdvanceRecord(repeat && *repeat > 0 ? *repeat : 1);
+    } else {
+      context.Crash("Invalid character '%c' in FORMAT", static_cast<char>(ch));
+    }
+  }
+}
+
+template<typename CONTEXT>
+DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
+    Context &context, int maxRepeat) {
+
+  // TODO: DT editing
+
+  // Return the next data edit descriptor
+  int repeat{CueUpNextDataEdit(context)};
+  auto start{offset_};
+  DataEdit edit;
+  edit.descriptor = static_cast<char>(Capitalize(GetNextChar(context)));
+  if (edit.descriptor == 'E') {
+    edit.variation = static_cast<char>(Capitalize(PeekNext()));
+    if (edit.variation >= 'A' && edit.variation <= 'Z') {
+      ++offset_;
+    }
+  }
+
+  if (edit.descriptor == 'A') {  // width is optional for A[w]
+    auto ch{PeekNext()};
+    if (ch >= '0' && ch <= '9') {
+      edit.width = GetIntField(context);
+    }
+  } else {
+    edit.width = GetIntField(context);
+  }
+  edit.modes = context.mutableModes();
+  if (PeekNext() == '.') {
+    ++offset_;
+    edit.digits = GetIntField(context);
+    CharType ch{PeekNext()};
+    if (ch == 'e' || ch == 'E' || ch == 'd' || ch == 'D') {
+      ++offset_;
+      edit.expoDigits = GetIntField(context);
+    }
+  }
+
+  // Handle repeated nonparenthesized edit descriptors
+  if (repeat > 1) {
+    stack_[height_].start = start;  // after repeat count
+    stack_[height_].remaining = repeat;  // full count
+    ++height_;
+  }
+  edit.repeat = 1;
+  if (height_ > 1) {
+    int start{stack_[height_ - 1].start};
+    if (format_[start] != '(') {
+      if (stack_[height_ - 1].remaining > maxRepeat) {
+        edit.repeat = maxRepeat;
+        stack_[height_ - 1].remaining -= maxRepeat;
+        offset_ = start;  // repeat same edit descriptor next time
+      } else {
+        edit.repeat = stack_[height_ - 1].remaining;
+        --height_;
+      }
+    }
+  }
+  return edit;
+}
+
+template<typename CONTEXT>
+void FormatControl<CONTEXT>::FinishOutput(Context &context) {
+  CueUpNextDataEdit(context, true /* stop at colon or end of FORMAT */);
+}
+}
+#endif  // FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
diff --git a/runtime/format.cpp b/runtime/format.cpp
index f31139ebb5ac..91a6b6749514 100644
--- a/runtime/format.cpp
+++ b/runtime/format.cpp
@@ -6,356 +6,48 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "format.h"
-#include "io-stmt.h"
-#include "main.h"
-#include "flang/common/format.h"
-#include "flang/decimal/decimal.h"
-#include <limits>
+#include "format-implementation.h"
 
 namespace Fortran::runtime::io {
 
-template<typename CHAR>
-FormatControl<CHAR>::FormatControl(Terminator &terminator, const CHAR *format,
-    std::size_t formatLength, int maxHeight)
-  : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
-    formatLength_{static_cast<int>(formatLength)} {
-  if (maxHeight != maxHeight_) {
-    terminator.Crash("internal Fortran runtime error: maxHeight %d", maxHeight);
-  }
-  if (formatLength != static_cast<std::size_t>(formatLength_)) {
-    terminator.Crash(
-        "internal Fortran runtime error: formatLength %zd", formatLength);
-  }
-  stack_[0].start = offset_;
-  stack_[0].remaining = Iteration::unlimited;  // 13.4(8)
-}
-
-template<typename CHAR>
-int FormatControl<CHAR>::GetMaxParenthesisNesting(
-    Terminator &terminator, const CHAR *format, std::size_t formatLength) {
-  using Validator = common::FormatValidator<CHAR>;
-  typename Validator::Reporter reporter{
-      [&](const common::FormatMessage &message) {
-        terminator.Crash(message.text, message.arg);
-        return false;  // crashes on error above
-      }};
-  Validator validator{format, formatLength, reporter};
-  validator.Check();
-  return validator.maxNesting();
-}
-
-template<typename CHAR>
-int FormatControl<CHAR>::GetIntField(Terminator &terminator, CHAR firstCh) {
-  CHAR ch{firstCh ? firstCh : PeekNext()};
-  if (ch != '-' && ch != '+' && (ch < '0' || ch > '9')) {
-    terminator.Crash(
-        "Invalid FORMAT: integer expected at '%c'", static_cast<char>(ch));
-  }
-  int result{0};
-  bool negate{ch == '-'};
-  if (negate) {
-    firstCh = '\0';
-    ch = PeekNext();
-  }
-  while (ch >= '0' && ch <= '9') {
-    if (result >
-        std::numeric_limits<int>::max() / 10 - (static_cast<int>(ch) - '0')) {
-      terminator.Crash("FORMAT integer field out of range");
-    }
-    result = 10 * result + ch - '0';
-    if (firstCh) {
-      firstCh = '\0';
-    } else {
-      ++offset_;
-    }
-    ch = PeekNext();
-  }
-  if (negate && (result *= -1) > 0) {
-    terminator.Crash("FORMAT integer field out of range");
-  }
-  return result;
-}
-
-static void HandleControl(FormatContext &context, char ch, char next, int n) {
-  MutableModes &modes{context.mutableModes()};
-  switch (ch) {
-  case 'B':
-    if (next == 'Z') {
-      modes.editingFlags |= blankZero;
-      return;
-    }
-    if (next == 'N') {
-      modes.editingFlags &= ~blankZero;
-      return;
-    }
-    break;
-  case 'D':
-    if (next == 'C') {
-      modes.editingFlags |= decimalComma;
-      return;
-    }
-    if (next == 'P') {
-      modes.editingFlags &= ~decimalComma;
-      return;
-    }
-    break;
-  case 'P':
-    if (!next) {
-      modes.scale = n;  // kP - decimal scaling by 10**k
-      return;
-    }
-    break;
-  case 'R':
-    switch (next) {
-    case 'N': modes.roundingMode = common::RoundingMode::TiesToEven; return;
-    case 'Z': modes.roundingMode = common::RoundingMode::ToZero; return;
-    case 'U': modes.roundingMode = common::RoundingMode::Up; return;
-    case 'D': modes.roundingMode = common::RoundingMode::Down; return;
-    case 'C':
-      modes.roundingMode = common::RoundingMode::TiesAwayFromZero;
-      return;
-    case 'P':
-      modes.roundingMode = executionEnvironment.defaultOutputRoundingMode;
-      return;
-    default: break;
-    }
-    break;
-  case 'X':
-    if (!next) {
-      context.HandleRelativePosition(n);
-      return;
-    }
-    break;
-  case 'S':
-    if (next == 'P') {
-      modes.editingFlags |= signPlus;
-      return;
-    }
-    if (!next || next == 'S') {
-      modes.editingFlags &= ~signPlus;
-      return;
-    }
-    break;
-  case 'T': {
-    if (!next) {  // Tn
-      context.HandleAbsolutePosition(n);
-      return;
-    }
-    if (next == 'L' || next == 'R') {  // TLn & TRn
-      context.HandleRelativePosition(next == 'L' ? -n : n);
-      return;
-    }
-  } break;
-  default: break;
-  }
-  if (next) {
-    context.Crash("Unknown '%c%c' edit descriptor in FORMAT", ch, next);
-  } else {
-    context.Crash("Unknown '%c' edit descriptor in FORMAT", ch);
-  }
-}
-
-// Locates the next data edit descriptor in the format.
-// Handles all repetition counts and control edit descriptors.
-// Generally assumes that the format string has survived the common
-// format validator gauntlet.
-template<typename CHAR>
-int FormatControl<CHAR>::CueUpNextDataEdit(FormatContext &context, bool stop) {
-  int unlimitedLoopCheck{-1};
-  while (true) {
-    std::optional<int> repeat;
-    bool unlimited{false};
-    CHAR ch{Capitalize(GetNextChar(context))};
-    while (ch == ',' || ch == ':') {
-      // Skip commas, and don't complain if they're missing; the format
-      // validator does that.
-      if (stop && ch == ':') {
-        return 0;
-      }
-      ch = Capitalize(GetNextChar(context));
-    }
-    if (ch == '-' || ch == '+' || (ch >= '0' && ch <= '9')) {
-      repeat = GetIntField(context, ch);
-      ch = GetNextChar(context);
-    } else if (ch == '*') {
-      unlimited = true;
-      ch = GetNextChar(context);
-      if (ch != '(') {
-        context.Crash("Invalid FORMAT: '*' may appear only before '('");
-      }
-    }
-    if (ch == '(') {
-      if (height_ >= maxHeight_) {
-        context.Crash("FORMAT stack overflow: too many nested parentheses");
-      }
-      stack_[height_].start = offset_ - 1;  // the '('
-      if (unlimited || height_ == 0) {
-        stack_[height_].remaining = Iteration::unlimited;
-        unlimitedLoopCheck = offset_ - 1;
-      } else if (repeat) {
-        if (*repeat <= 0) {
-          *repeat = 1;  // error recovery
-        }
-        stack_[height_].remaining = *repeat - 1;
-      } else {
-        stack_[height_].remaining = 0;
-      }
-      ++height_;
-    } else if (height_ == 0) {
-      context.Crash("FORMAT lacks initial '('");
-    } else if (ch == ')') {
-      if (height_ == 1) {
-        if (stop) {
-          return 0;  // end of FORMAT and no data items remain
-        }
-        context.HandleSlash();  // implied / before rightmost )
-      }
-      if (stack_[height_ - 1].remaining == Iteration::unlimited) {
-        offset_ = stack_[height_ - 1].start + 1;
-        if (offset_ == unlimitedLoopCheck) {
-          context.Crash(
-              "Unlimited repetition in FORMAT lacks data edit descriptors");
-        }
-      } else if (stack_[height_ - 1].remaining-- > 0) {
-        offset_ = stack_[height_ - 1].start + 1;
-      } else {
-        --height_;
-      }
-    } else if (ch == '\'' || ch == '"') {
-      // Quoted 'character literal'
-      CHAR quote{ch};
-      auto start{offset_};
-      while (offset_ < formatLength_ && format_[offset_] != quote) {
-        ++offset_;
-      }
-      if (offset_ >= formatLength_) {
-        context.Crash("FORMAT missing closing quote on character literal");
-      }
-      ++offset_;
-      std::size_t chars{
-          static_cast<std::size_t>(&format_[offset_] - &format_[start])};
-      if (PeekNext() == quote) {
-        // subtle: handle doubled quote character in a literal by including
-        // the first in the output, then treating the second as the start
-        // of another character literal.
-      } else {
-        --chars;
-      }
-      context.Emit(format_ + start, chars);
-    } else if (ch == 'H') {
-      // 9HHOLLERITH
-      if (!repeat || *repeat < 1 || offset_ + *repeat > formatLength_) {
-        context.Crash("Invalid width on Hollerith in FORMAT");
-      }
-      context.Emit(format_ + offset_, static_cast<std::size_t>(*repeat));
-      offset_ += *repeat;
-    } else if (ch >= 'A' && ch <= 'Z') {
-      int start{offset_ - 1};
-      CHAR next{Capitalize(PeekNext())};
-      if (next >= 'A' && next <= 'Z') {
-        ++offset_;
-      } else {
-        next = '\0';
-      }
-      if (ch == 'E' ||
-          (!next &&
-              (ch == 'A' || ch == 'I' || ch == 'B' || ch == 'O' || ch == 'Z' ||
-                  ch == 'F' || ch == 'D' || ch == 'G' || ch == 'L'))) {
-        // Data edit descriptor found
-        offset_ = start;
-        return repeat && *repeat > 0 ? *repeat : 1;
-      } else {
-        // Control edit descriptor
-        if (ch == 'T') {  // Tn, TLn, TRn
-          repeat = GetIntField(context);
-        }
-        HandleControl(context, static_cast<char>(ch), static_cast<char>(next),
-            repeat ? *repeat : 1);
-      }
-    } else if (ch == '/') {
-      context.HandleSlash(repeat && *repeat > 0 ? *repeat : 1);
-    } else {
-      context.Crash("Invalid character '%c' in FORMAT", static_cast<char>(ch));
-    }
-  }
-}
-
-template<typename CHAR>
-void FormatControl<CHAR>::GetNext(
-    FormatContext &context, DataEdit &edit, int maxRepeat) {
-
-  // TODO: DT editing
-
-  // Return the next data edit descriptor
-  int repeat{CueUpNextDataEdit(context)};
-  auto start{offset_};
-  edit.descriptor = static_cast<char>(Capitalize(GetNextChar(context)));
-  if (edit.descriptor == 'E') {
-    edit.variation = static_cast<char>(Capitalize(PeekNext()));
-    if (edit.variation >= 'A' && edit.variation <= 'Z') {
-      ++offset_;
-    } else {
-      edit.variation = '\0';
-    }
-  } else {
-    edit.variation = '\0';
-  }
-
-  if (edit.descriptor == 'A') {  // width is optional for A[w]
-    auto ch{PeekNext()};
-    if (ch >= '0' && ch <= '9') {
-      edit.width = GetIntField(context);
-    } else {
-      edit.width.reset();
-    }
-  } else {
-    edit.width = GetIntField(context);
-  }
-  edit.modes = context.mutableModes();
-  if (PeekNext() == '.') {
-    ++offset_;
-    edit.digits = GetIntField(context);
-    CHAR ch{PeekNext()};
-    if (ch == 'e' || ch == 'E' || ch == 'd' || ch == 'D') {
-      ++offset_;
-      edit.expoDigits = GetIntField(context);
-    } else {
-      edit.expoDigits.reset();
-    }
-  } else {
-    edit.digits.reset();
-    edit.expoDigits.reset();
-  }
-
-  // Handle repeated nonparenthesized edit descriptors
-  if (repeat > 1) {
-    stack_[height_].start = start;  // after repeat count
-    stack_[height_].remaining = repeat;  // full count
-    ++height_;
-  }
-  edit.repeat = 1;
-  if (height_ > 1) {
-    int start{stack_[height_ - 1].start};
-    if (format_[start] != '(') {
-      if (stack_[height_ - 1].remaining > maxRepeat) {
-        edit.repeat = maxRepeat;
-        stack_[height_ - 1].remaining -= maxRepeat;
-        offset_ = start;  // repeat same edit descriptor next time
-      } else {
-        edit.repeat = stack_[height_ - 1].remaining;
-        --height_;
-      }
-    }
-  }
-}
-
-template<typename CHAR>
-void FormatControl<CHAR>::FinishOutput(FormatContext &context) {
-  CueUpNextDataEdit(context, true /* stop at colon or end of FORMAT */);
-}
-
-template class FormatControl<char>;
-template class FormatControl<char16_t>;
-template class FormatControl<char32_t>;
+DataEdit DefaultFormatControlCallbacks::GetNextDataEdit(int) {
+  Crash("DefaultFormatControlCallbacks::GetNextDataEdit() called for "
+        "non-formatted I/O statement");
+  return {};
+}
+bool DefaultFormatControlCallbacks::Emit(const char *, std::size_t) {
+  Crash("DefaultFormatControlCallbacks::Emit(char) called for non-output I/O "
+        "statement");
+  return {};
+}
+bool DefaultFormatControlCallbacks::Emit(const char16_t *, std::size_t) {
+  Crash("DefaultFormatControlCallbacks::Emit(char16_t) called for non-output "
+        "I/O statement");
+  return {};
+}
+bool DefaultFormatControlCallbacks::Emit(const char32_t *, std::size_t) {
+  Crash("DefaultFormatControlCallbacks::Emit(char32_t) called for non-output "
+        "I/O statement");
+  return {};
+}
+bool DefaultFormatControlCallbacks::AdvanceRecord(int) {
+  Crash("DefaultFormatControlCallbacks::AdvanceRecord() called unexpectedly");
+  return {};
+}
+bool DefaultFormatControlCallbacks::HandleAbsolutePosition(std::int64_t) {
+  Crash("DefaultFormatControlCallbacks::HandleAbsolutePosition() called for "
+        "non-formatted "
+        "I/O statement");
+  return {};
+}
+bool DefaultFormatControlCallbacks::HandleRelativePosition(std::int64_t) {
+  Crash("DefaultFormatControlCallbacks::HandleRelativePosition() called for "
+        "non-formatted "
+        "I/O statement");
+  return {};
+}
+
+template class FormatControl<InternalFormattedIoStatementState<false>>;
+template class FormatControl<InternalFormattedIoStatementState<true>>;
+template class FormatControl<ExternalFormattedIoStatementState<false>>;
 }
diff --git a/runtime/format.h b/runtime/format.h
index c954c7f3872f..c072b3b9805d 100644
--- a/runtime/format.h
+++ b/runtime/format.h
@@ -12,8 +12,10 @@
 #define FORTRAN_RUNTIME_FORMAT_H_
 
 #include "environment.h"
+#include "io-error.h"
 #include "terminator.h"
 #include "flang/common/Fortran.h"
+#include "flang/decimal/decimal.h"
 #include <cinttypes>
 #include <optional>
 
@@ -27,7 +29,7 @@ enum EditingFlags {
 
 struct MutableModes {
   std::uint8_t editingFlags{0};  // BN, DP, SS
-  common::RoundingMode roundingMode{
+  enum decimal::FortranRounding round{
       executionEnvironment
           .defaultOutputRoundingMode};  // RP/ROUND='PROCESSOR_DEFAULT'
   bool pad{false};  // PAD= mode on READ
@@ -38,6 +40,16 @@ struct MutableModes {
 // A single edit descriptor extracted from a FORMAT
 struct DataEdit {
   char descriptor;  // capitalized: one of A, I, B, O, Z, F, E(N/S/X), D, G
+
+  // Special internal data edit descriptors to distinguish list-directed I/O
+  static constexpr char ListDirected{'g'};  // non-COMPLEX list-directed
+  static constexpr char ListDirectedRealPart{'r'};  // emit "(r," or "(r;"
+  static constexpr char ListDirectedImaginaryPart{'z'};  // emit "z)"
+  constexpr bool IsListDirected() const {
+    return descriptor == ListDirected || descriptor == ListDirectedRealPart ||
+        descriptor == ListDirectedImaginaryPart;
+  }
+
   char variation{'\0'};  // N, S, or X for EN, ES, EX
   std::optional<int> width;  // the 'w' field; optional for A
   std::optional<int> digits;  // the 'm' or 'd' field
@@ -46,37 +58,35 @@ struct DataEdit {
   int repeat{1};
 };
 
-class FormatContext : virtual public Terminator {
-public:
-  FormatContext() {}
-  virtual ~FormatContext() {}
-  explicit FormatContext(const MutableModes &modes) : mutableModes_{modes} {}
-  virtual bool Emit(const char *, std::size_t) = 0;
-  virtual bool Emit(const char16_t *, std::size_t) = 0;
-  virtual bool Emit(const char32_t *, std::size_t) = 0;
-  virtual bool HandleSlash(int = 1) = 0;
-  virtual bool HandleRelativePosition(std::int64_t) = 0;
-  virtual bool HandleAbsolutePosition(std::int64_t) = 0;
-  MutableModes &mutableModes() { return mutableModes_; }
-
-private:
-  MutableModes mutableModes_;
+// FormatControl<A> requires that A have these member functions;
+// these default implementations just crash if called.
+struct DefaultFormatControlCallbacks : public IoErrorHandler {
+  using IoErrorHandler::IoErrorHandler;
+  DataEdit GetNextDataEdit(int = 1);
+  bool Emit(const char *, std::size_t);
+  bool Emit(const char16_t *, std::size_t);
+  bool Emit(const char32_t *, std::size_t);
+  bool AdvanceRecord(int = 1);
+  bool HandleAbsolutePosition(std::int64_t);
+  bool HandleRelativePosition(std::int64_t);
 };
 
 // Generates a sequence of DataEdits from a FORMAT statement or
 // default-CHARACTER string.  Driven by I/O item list processing.
 // Errors are fatal.  See clause 13.4 in Fortran 2018 for background.
-template<typename CHAR = char> class FormatControl {
+template<typename CONTEXT> class FormatControl {
 public:
+  using Context = CONTEXT;
+  using CharType = typename Context::CharType;
+
   FormatControl() {}
-  // TODO: make 'format' a reference here and below
-  FormatControl(Terminator &, const CHAR *format, std::size_t formatLength,
-      int maxHeight = maxMaxHeight);
+  FormatControl(const Terminator &, const CharType *format,
+      std::size_t formatLength, int maxHeight = maxMaxHeight);
 
   // Determines the max parenthesis nesting level by scanning and validating
   // the FORMAT string.
   static int GetMaxParenthesisNesting(
-      Terminator &, const CHAR *format, std::size_t formatLength);
+      const Terminator &, const CharType *format, std::size_t formatLength);
 
   // For attempting to allocate in a user-supplied stack area
   static std::size_t GetNeededSize(int maxHeight) {
@@ -86,10 +96,10 @@ template<typename CHAR = char> class FormatControl {
 
   // Extracts the next data edit descriptor, handling control edit descriptors
   // along the way.
-  void GetNext(FormatContext &, DataEdit &, int maxRepeat = 1);
+  DataEdit GetNextDataEdit(Context &, int maxRepeat = 1);
 
   // Emit any remaining character literals after the last data item.
-  void FinishOutput(FormatContext &);
+  void FinishOutput(Context &);
 
 private:
   static constexpr std::uint8_t maxMaxHeight{100};
@@ -105,27 +115,27 @@ template<typename CHAR = char> class FormatControl {
       ++offset_;
     }
   }
-  CHAR PeekNext() {
+  CharType PeekNext() {
     SkipBlanks();
     return offset_ < formatLength_ ? format_[offset_] : '\0';
   }
-  CHAR GetNextChar(Terminator &terminator) {
+  CharType GetNextChar(const Terminator &terminator) {
     SkipBlanks();
     if (offset_ >= formatLength_) {
       terminator.Crash("FORMAT missing at least one ')'");
     }
     return format_[offset_++];
   }
-  int GetIntField(Terminator &, CHAR firstCh = '\0');
+  int GetIntField(const Terminator &, CharType firstCh = '\0');
 
   // Advances through the FORMAT until the next data edit
   // descriptor has been found; handles control edit descriptors
   // along the way.  Returns the repeat count that appeared
   // before the descriptor (defaulting to 1) and leaves offset_
   // pointing to the data edit.
-  int CueUpNextDataEdit(FormatContext &, bool stop = false);
+  int CueUpNextDataEdit(Context &, bool stop = false);
 
-  static constexpr CHAR Capitalize(CHAR ch) {
+  static constexpr CharType Capitalize(CharType ch) {
     return ch >= 'a' && ch <= 'z' ? ch + 'A' - 'a' : ch;
   }
 
@@ -134,16 +144,12 @@ template<typename CHAR = char> class FormatControl {
   // user program for internal I/O.
   const std::uint8_t maxHeight_{maxMaxHeight};
   std::uint8_t height_{0};
-  const CHAR *format_{nullptr};
+  const CharType *format_{nullptr};
   int formatLength_{0};
   int offset_{0};  // next item is at format_[offset_]
 
   // must be last, may be incomplete
   Iteration stack_[maxMaxHeight];
 };
-
-extern template class FormatControl<char>;
-extern template class FormatControl<char16_t>;
-extern template class FormatControl<char32_t>;
 }
 #endif  // FORTRAN_RUNTIME_FORMAT_H_
diff --git a/runtime/internal-unit.cpp b/runtime/internal-unit.cpp
new file mode 100644
index 000000000000..737f0856e33f
--- /dev/null
+++ b/runtime/internal-unit.cpp
@@ -0,0 +1,129 @@
+//===-- runtime/internal-unit.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 "internal-unit.h"
+#include "descriptor.h"
+#include "io-error.h"
+#include <algorithm>
+#include <type_traits>
+
+namespace Fortran::runtime::io {
+
+template<bool isInput>
+InternalDescriptorUnit<isInput>::InternalDescriptorUnit(
+    Scalar scalar, std::size_t length) {
+  recordLength = length;
+  endfileRecordNumber = 2;
+  void *pointer{reinterpret_cast<void *>(const_cast<char *>(scalar))};
+  descriptor().Establish(TypeCode{CFI_type_char}, length, pointer, 0, nullptr,
+      CFI_attribute_pointer);
+}
+
+template<bool isInput>
+InternalDescriptorUnit<isInput>::InternalDescriptorUnit(
+    const Descriptor &that, const Terminator &terminator) {
+  RUNTIME_CHECK(terminator, that.type().IsCharacter());
+  Descriptor &d{descriptor()};
+  RUNTIME_CHECK(
+      terminator, that.SizeInBytes() <= d.SizeInBytes(maxRank, true, 0));
+  new (&d) Descriptor{that};
+  d.Check();
+  recordLength = d.ElementBytes();
+  endfileRecordNumber = d.Elements() + 1;
+  d.GetLowerBounds(at_);
+}
+
+template<bool isInput> void InternalDescriptorUnit<isInput>::EndIoStatement() {
+  if constexpr (!isInput) {
+    // blank fill
+    while (currentRecordNumber < endfileRecordNumber.value_or(0)) {
+      char *record{descriptor().template Element<char>(at_)};
+      std::fill_n(record + furthestPositionInRecord,
+          recordLength.value_or(0) - furthestPositionInRecord, ' ');
+      furthestPositionInRecord = 0;
+      ++currentRecordNumber;
+      descriptor().IncrementSubscripts(at_);
+    }
+  }
+}
+
+template<bool isInput>
+bool InternalDescriptorUnit<isInput>::Emit(
+    const char *data, std::size_t bytes, IoErrorHandler &handler) {
+  if constexpr (isInput) {
+    handler.Crash(
+        "InternalDescriptorUnit<true>::Emit() called for an input statement");
+    return false;
+  }
+  if (currentRecordNumber >= endfileRecordNumber.value_or(0)) {
+    handler.SignalEnd();
+    return false;
+  }
+  char *record{descriptor().template Element<char>(at_)};
+  auto furthestAfter{std::max(furthestPositionInRecord,
+      positionInRecord + static_cast<std::int64_t>(bytes))};
+  bool ok{true};
+  if (furthestAfter > static_cast<std::int64_t>(recordLength.value_or(0))) {
+    handler.SignalEor();
+    furthestAfter = recordLength.value_or(0);
+    bytes = std::max(std::int64_t{0}, furthestAfter - positionInRecord);
+    ok = false;
+  }
+  std::memcpy(record + positionInRecord, data, bytes);
+  positionInRecord += bytes;
+  furthestPositionInRecord = furthestAfter;
+  return ok;
+}
+
+template<bool isInput>
+bool InternalDescriptorUnit<isInput>::AdvanceRecord(IoErrorHandler &handler) {
+  if (currentRecordNumber >= endfileRecordNumber.value_or(0)) {
+    handler.SignalEnd();
+    return false;
+  }
+  if (!HandleAbsolutePosition(recordLength.value_or(0), handler)) {
+    return false;
+  }
+  ++currentRecordNumber;
+  descriptor().IncrementSubscripts(at_);
+  positionInRecord = 0;
+  furthestPositionInRecord = 0;
+  return true;
+}
+
+template<bool isInput>
+bool InternalDescriptorUnit<isInput>::HandleAbsolutePosition(
+    std::int64_t n, IoErrorHandler &handler) {
+  n = std::max<std::int64_t>(0, n);
+  bool ok{true};
+  if (n > static_cast<std::int64_t>(recordLength.value_or(n))) {
+    handler.SignalEor();
+    n = *recordLength;
+    ok = false;
+  }
+  if (n > furthestPositionInRecord && ok) {
+    if constexpr (!isInput) {
+      char *record{descriptor().template Element<char>(at_)};
+      std::fill_n(
+          record + furthestPositionInRecord, n - furthestPositionInRecord, ' ');
+    }
+    furthestPositionInRecord = n;
+  }
+  positionInRecord = n;
+  return ok;
+}
+
+template<bool isInput>
+bool InternalDescriptorUnit<isInput>::HandleRelativePosition(
+    std::int64_t n, IoErrorHandler &handler) {
+  return HandleAbsolutePosition(positionInRecord + n, handler);
+}
+
+template class InternalDescriptorUnit<false>;
+template class InternalDescriptorUnit<true>;
+}
diff --git a/runtime/internal-unit.h b/runtime/internal-unit.h
new file mode 100644
index 000000000000..837ddc6f588f
--- /dev/null
+++ b/runtime/internal-unit.h
@@ -0,0 +1,46 @@
+//===-- runtime/internal-unit.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
+//
+//===----------------------------------------------------------------------===//
+
+// Fortran internal I/O "units"
+
+#ifndef FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
+#define FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
+
+#include "connection.h"
+#include "descriptor.h"
+#include <cinttypes>
+#include <type_traits>
+
+namespace Fortran::runtime::io {
+
+class IoErrorHandler;
+
+// Points to (but does not own) a CHARACTER scalar or array for internal I/O.
+// Does not buffer.
+template<bool isInput> class InternalDescriptorUnit : public ConnectionState {
+public:
+  using Scalar = std::conditional_t<isInput, const char *, char *>;
+  InternalDescriptorUnit(Scalar, std::size_t);
+  InternalDescriptorUnit(const Descriptor &, const Terminator &);
+  void EndIoStatement();
+
+  bool Emit(const char *, std::size_t bytes, IoErrorHandler &);
+  bool AdvanceRecord(IoErrorHandler &);
+  bool HandleAbsolutePosition(std::int64_t, IoErrorHandler &);
+  bool HandleRelativePosition(std::int64_t, IoErrorHandler &);
+
+private:
+  Descriptor &descriptor() { return staticDescriptor_.descriptor(); }
+  StaticDescriptor<maxRank, true /*addendum*/> staticDescriptor_;
+  SubscriptValue at_[maxRank];
+};
+
+extern template class InternalDescriptorUnit<false>;
+extern template class InternalDescriptorUnit<true>;
+}
+#endif  // FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
diff --git a/runtime/io-api.cpp b/runtime/io-api.cpp
index d5840a03b75d..969315a49fa7 100644
--- a/runtime/io-api.cpp
+++ b/runtime/io-api.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/io.cpp ------------------------------------------*- C++ -*-===//
+//===-- runtime/io-api.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.
@@ -9,24 +9,76 @@
 // Implements the I/O statement API
 
 #include "io-api.h"
+#include "environment.h"
 #include "format.h"
 #include "io-stmt.h"
 #include "memory.h"
 #include "numeric-output.h"
 #include "terminator.h"
+#include "tools.h"
 #include "unit.h"
 #include <cstdlib>
 #include <memory>
 
 namespace Fortran::runtime::io {
 
+Cookie IONAME(BeginInternalArrayListOutput)(const Descriptor &descriptor,
+    void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
+    const char *sourceFile, int sourceLine) {
+  Terminator oom{sourceFile, sourceLine};
+  return &New<InternalListIoStatementState<false>>{}(
+      oom, descriptor, sourceFile, sourceLine)
+              .ioStatementState();
+}
+
+Cookie IONAME(BeginInternalArrayFormattedOutput)(const Descriptor &descriptor,
+    const char *format, std::size_t formatLength, void ** /*scratchArea*/,
+    std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
+  Terminator oom{sourceFile, sourceLine};
+  return &New<InternalFormattedIoStatementState<false>>{}(
+      oom, descriptor, format, formatLength, sourceFile, sourceLine)
+              .ioStatementState();
+}
+
+Cookie IONAME(BeginInternalListOutput)(char *internal,
+    std::size_t internalLength, void ** /*scratchArea*/,
+    std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
+  Terminator oom{sourceFile, sourceLine};
+  return &New<InternalListIoStatementState<false>>{}(
+      oom, internal, internalLength, sourceFile, sourceLine)
+              .ioStatementState();
+}
+
 Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
     void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
     const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
   return &New<InternalFormattedIoStatementState<false>>{}(oom, internal,
-      internalLength, format, formatLength, sourceFile, sourceLine);
+      internalLength, format, formatLength, sourceFile, sourceLine)
+              .ioStatementState();
+}
+
+Cookie IONAME(BeginInternalFormattedInput)(char *internal,
+    std::size_t internalLength, const char *format, std::size_t formatLength,
+    void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
+    const char *sourceFile, int sourceLine) {
+  Terminator oom{sourceFile, sourceLine};
+  return &New<InternalFormattedIoStatementState<true>>{}(oom, internal,
+      internalLength, format, formatLength, sourceFile, sourceLine)
+              .ioStatementState();
+}
+
+Cookie IONAME(BeginExternalListOutput)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
+  int unit{unitNumber == DefaultUnit ? 6 : unitNumber};
+  ExternalFileUnit &file{ExternalFileUnit::LookUpOrCrash(unit, terminator)};
+  if (file.isUnformatted) {
+    terminator.Crash("List-directed output attempted to unformatted file");
+  }
+  return &file.BeginIoStatement<ExternalListIoStatementState<false>>(
+      file, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
@@ -34,53 +86,557 @@ Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
     int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   int unit{unitNumber == DefaultUnit ? 6 : unitNumber};
-  ExternalFile &file{ExternalFile::LookUpOrCrash(unit, terminator)};
-  return &file.BeginIoStatement<ExternalFormattedIoStatementState<false>>(
-      file, format, formatLength, sourceFile, sourceLine);
+  ExternalFileUnit &file{ExternalFileUnit::LookUpOrCrash(unit, terminator)};
+  if (file.isUnformatted) {
+    terminator.Crash("Formatted output attempted to unformatted file");
+  }
+  IoStatementState &io{
+      file.BeginIoStatement<ExternalFormattedIoStatementState<false>>(
+          file, format, formatLength, sourceFile, sourceLine)};
+  return &io;
+}
+
+Cookie IONAME(BeginUnformattedOutput)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
+  ExternalFileUnit &file{
+      ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
+  if (!file.isUnformatted) {
+    terminator.Crash("Unformatted output attempted to formatted file");
+  }
+  IoStatementState &io{
+      file.BeginIoStatement<UnformattedIoStatementState<false>>(
+          file, sourceFile, sourceLine)};
+  if (file.access == Access::Sequential && !file.recordLength.has_value()) {
+    // Filled in by UnformattedIoStatementState<false>::EndIoStatement()
+    io.Emit("\0\0\0\0", 4);  // placeholder for record length header
+  }
+  return &io;
+}
+
+Cookie IONAME(BeginOpenUnit)(  // OPEN(without NEWUNIT=)
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  bool wasExtant{false};
+  ExternalFileUnit &unit{
+      ExternalFileUnit::LookUpOrCreate(unitNumber, &wasExtant)};
+  return &unit.BeginIoStatement<OpenStatementState>(
+      unit, wasExtant, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginOpenNewUnit)(  // OPEN(NEWUNIT=j)
+    const char *sourceFile, int sourceLine) {
+  return IONAME(BeginOpenUnit)(
+      ExternalFileUnit::NewUnit(), sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginClose)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
+    return &unit->BeginIoStatement<CloseStatementState>(
+        *unit, sourceFile, sourceLine);
+  } else {
+    // CLOSE(UNIT=bad unit) is just a no-op
+    Terminator oom{sourceFile, sourceLine};
+    return &New<NoopCloseStatementState>{}(oom, sourceFile, sourceLine)
+                .ioStatementState();
+  }
+}
+
+// Control list items
+
+void IONAME(EnableHandlers)(
+    Cookie cookie, bool hasIoStat, bool hasErr, bool hasEnd, bool hasEor) {
+  IoErrorHandler &handler{cookie->GetIoErrorHandler()};
+  if (hasIoStat) {
+    handler.HasIoStat();
+  }
+  if (hasErr) {
+    handler.HasErrLabel();
+  }
+  if (hasEnd) {
+    handler.HasEndLabel();
+  }
+  if (hasEor) {
+    handler.HasEorLabel();
+  }
+}
+
+static bool YesOrNo(const char *keyword, std::size_t length, const char *what,
+    const Terminator &terminator) {
+  static const char *keywords[]{"YES", "NO", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: return true;
+  case 1: return false;
+  default:
+    terminator.Crash(
+        "Invalid %s='%.*s'", what, static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
+bool IONAME(SetAdvance)(
+    Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  connection.nonAdvancing =
+      !YesOrNo(keyword, length, "ADVANCE", io.GetIoErrorHandler());
+  return true;
+}
+
+bool IONAME(SetBlank)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  static const char *keywords[]{"NULL", "ZERO", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: connection.modes.editingFlags &= ~blankZero; return true;
+  case 1: connection.modes.editingFlags |= blankZero; return true;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Invalid BLANK='%.*s'", static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
+bool IONAME(SetDecimal)(
+    Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  static const char *keywords[]{"COMMA", "POINT", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: connection.modes.editingFlags |= decimalComma; return true;
+  case 1: connection.modes.editingFlags &= ~decimalComma; return true;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Invalid DECIMAL='%.*s'", static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
+bool IONAME(SetDelim)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  static const char *keywords[]{"APOSTROPHE", "QUOTE", "NONE", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: connection.modes.delim = '\''; return true;
+  case 1: connection.modes.delim = '"'; return true;
+  case 2: connection.modes.delim = '\0'; return true;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Invalid DELIM='%.*s'", static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
+bool IONAME(SetPad)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  connection.modes.pad =
+      YesOrNo(keyword, length, "PAD", io.GetIoErrorHandler());
+  return true;
+}
+
+// TODO: SetPos (stream I/O)
+// TODO: SetRec (direct I/O)
+
+bool IONAME(SetRound)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  static const char *keywords[]{"UP", "DOWN", "ZERO", "NEAREST", "COMPATIBLE",
+      "PROCESSOR_DEFINED", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: connection.modes.round = decimal::RoundUp; return true;
+  case 1: connection.modes.round = decimal::RoundDown; return true;
+  case 2: connection.modes.round = decimal::RoundToZero; return true;
+  case 3: connection.modes.round = decimal::RoundNearest; return true;
+  case 4: connection.modes.round = decimal::RoundCompatible; return true;
+  case 5:
+    connection.modes.round = executionEnvironment.defaultOutputRoundingMode;
+    return true;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Invalid ROUND='%.*s'", static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
+bool IONAME(SetSign)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  static const char *keywords[]{"PLUS", "YES", "PROCESSOR_DEFINED", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: connection.modes.editingFlags |= signPlus; return true;
+  case 1:
+  case 2:  // processor default is SS
+    connection.modes.editingFlags &= ~signPlus;
+    return true;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Invalid SIGN='%.*s'", static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
+bool IONAME(SetAccess)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetAccess() called when not in an OPEN statement");
+  }
+  ConnectionState &connection{open->GetConnectionState()};
+  Access access{connection.access};
+  static const char *keywords[]{"SEQUENTIAL", "DIRECT", "STREAM", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: access = Access::Sequential; break;
+  case 1: access = Access::Direct; break;
+  case 2: access = Access::Stream; break;
+  default:
+    open->Crash("Invalid ACCESS='%.*s'", static_cast<int>(length), keyword);
+  }
+  if (access != connection.access) {
+    if (open->wasExtant()) {
+      open->Crash("ACCESS= may not be changed on an open unit");
+    }
+    connection.access = access;
+  }
+  return true;
+}
+
+bool IONAME(SetAction)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetAction() called when not in an OPEN statement");
+  }
+  bool mayRead{true};
+  bool mayWrite{true};
+  static const char *keywords[]{"READ", "WRITE", "READWRITE", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: mayWrite = false; break;
+  case 1: mayRead = false; break;
+  case 2: break;
+  default:
+    open->Crash("Invalid ACTION='%.*s'", static_cast<int>(length), keyword);
+    return false;
+  }
+  if (mayRead != open->unit().mayRead() ||
+      mayWrite != open->unit().mayWrite()) {
+    if (open->wasExtant()) {
+      open->Crash("ACTION= may not be changed on an open unit");
+    }
+    open->unit().set_mayRead(mayRead);
+    open->unit().set_mayWrite(mayWrite);
+  }
+  return true;
+}
+
+bool IONAME(SetAsynchronous)(
+    Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetAsynchronous() called when not in an OPEN statement");
+  }
+  static const char *keywords[]{"YES", "NO", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: open->unit().set_mayAsynchronous(true); return true;
+  case 1: open->unit().set_mayAsynchronous(false); return true;
+  default:
+    open->Crash(
+        "Invalid ASYNCHRONOUS='%.*s'", static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
+bool IONAME(SetEncoding)(
+    Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetEncoding() called when not in an OPEN statement");
+  }
+  bool isUTF8{false};
+  static const char *keywords[]{"UTF-8", "DEFAULT", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: isUTF8 = true; break;
+  case 1: isUTF8 = false; break;
+  default:
+    open->Crash("Invalid ENCODING='%.*s'", static_cast<int>(length), keyword);
+  }
+  if (isUTF8 != open->unit().isUTF8) {
+    if (open->wasExtant()) {
+      open->Crash("ENCODING= may not be changed on an open unit");
+    }
+    open->unit().isUTF8 = isUTF8;
+  }
+  return true;
+}
+
+bool IONAME(SetForm)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetEncoding() called when not in an OPEN statement");
+  }
+  bool isUnformatted{false};
+  static const char *keywords[]{"FORMATTED", "UNFORMATTED", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0: isUnformatted = false; break;
+  case 1: isUnformatted = true; break;
+  default:
+    open->Crash("Invalid FORM='%.*s'", static_cast<int>(length), keyword);
+  }
+  if (isUnformatted != open->unit().isUnformatted) {
+    if (open->wasExtant()) {
+      open->Crash("FORM= may not be changed on an open unit");
+    }
+    open->unit().isUnformatted = isUnformatted;
+  }
+  return true;
+}
+
+bool IONAME(SetPosition)(
+    Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetPosition() called when not in an OPEN statement");
+  }
+  static const char *positions[]{"ASIS", "REWIND", "APPEND", nullptr};
+  switch (IdentifyValue(keyword, length, positions)) {
+  case 0: open->set_position(Position::AsIs); return true;
+  case 1: open->set_position(Position::Rewind); return true;
+  case 2: open->set_position(Position::Append); return true;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Invalid POSITION='%.*s'", static_cast<int>(length), keyword);
+  }
+  return true;
+}
+
+bool IONAME(SetRecl)(Cookie cookie, std::size_t n) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetRecl() called when not in an OPEN statement");
+  }
+  if (open->wasExtant() && open->unit().recordLength.has_value() &&
+      *open->unit().recordLength != n) {
+    open->Crash("RECL= may not be changed for an open unit");
+  }
+  open->unit().recordLength = n;
+  return true;
+}
+
+bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  if (auto *open{io.get_if<OpenStatementState>()}) {
+    static const char *statuses[]{
+        "OLD", "NEW", "SCRATCH", "REPLACE", "UNKNOWN", nullptr};
+    switch (IdentifyValue(keyword, length, statuses)) {
+    case 0: open->set_status(OpenStatus::Old); return true;
+    case 1: open->set_status(OpenStatus::New); return true;
+    case 2: open->set_status(OpenStatus::Scratch); return true;
+    case 3: open->set_status(OpenStatus::Replace); return true;
+    case 4: open->set_status(OpenStatus::Unknown); return true;
+    default:
+      io.GetIoErrorHandler().Crash(
+          "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
+    }
+    return false;
+  }
+  if (auto *close{io.get_if<CloseStatementState>()}) {
+    static const char *statuses[]{"KEEP", "DELETE", nullptr};
+    switch (IdentifyValue(keyword, length, statuses)) {
+    case 0: close->set_status(CloseStatus::Keep); return true;
+    case 1: close->set_status(CloseStatus::Delete); return true;
+    default:
+      io.GetIoErrorHandler().Crash(
+          "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
+    }
+    return false;
+  }
+  if (io.get_if<NoopCloseStatementState>()) {
+    return true;  // don't bother validating STATUS= in a no-op CLOSE
+  }
+  io.GetIoErrorHandler().Crash(
+      "SetStatus() called when not in an OPEN or CLOSE statement");
+}
+
+bool IONAME(SetFile)(
+    Cookie cookie, const char *path, std::size_t chars, int kind) {
+  IoStatementState &io{*cookie};
+  if (auto *open{io.get_if<OpenStatementState>()}) {
+    open->set_path(path, chars, kind);
+    return true;
+  }
+  io.GetIoErrorHandler().Crash(
+      "SetFile() called when not in an OPEN statement");
+  return false;
+}
+
+static bool SetInteger(int &x, int kind, int value) {
+  switch (kind) {
+  case 1: reinterpret_cast<std::int8_t &>(x) = value; return true;
+  case 2: reinterpret_cast<std::int16_t &>(x) = value; return true;
+  case 4: x = value; return true;
+  case 8: reinterpret_cast<std::int64_t &>(x) = value; return true;
+  default: return false;
+  }
+}
+
+bool IONAME(GetNewUnit)(Cookie cookie, int &unit, int kind) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "GetNewUnit() called when not in an OPEN statement");
+  }
+  if (!SetInteger(unit, kind, open->unit().unitNumber())) {
+    open->Crash("GetNewUnit(): Bad INTEGER kind(%d) for result");
+  }
+  return true;
+}
+
+// Data transfers
+// TODO: Input
+
+bool IONAME(OutputDescriptor)(Cookie cookie, const Descriptor &) {
+  IoStatementState &io{*cookie};
+  io.GetIoErrorHandler().Crash(
+      "OutputDescriptor: not yet implemented");  // TODO
+}
+
+bool IONAME(OutputUnformattedBlock)(
+    Cookie cookie, const char *x, std::size_t length) {
+  IoStatementState &io{*cookie};
+  if (auto *unf{io.get_if<UnformattedIoStatementState<false>>()}) {
+    return unf->Emit(x, length);
+  }
+  io.GetIoErrorHandler().Crash("OutputUnformatted() called for an I/O "
+                               "statement that is not unformatted output");
+  return false;
 }
 
 bool IONAME(OutputInteger64)(Cookie cookie, std::int64_t n) {
   IoStatementState &io{*cookie};
-  DataEdit edit;
-  io.GetNext(edit);
-  return EditIntegerOutput(io, edit, n);
+  if (!io.get_if<OutputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "OutputInteger64() called for a non-output I/O statement");
+    return false;
+  }
+  return EditIntegerOutput(io, io.GetNextDataEdit(), n);
 }
 
 bool IONAME(OutputReal64)(Cookie cookie, double x) {
   IoStatementState &io{*cookie};
-  DataEdit edit;
-  io.GetNext(edit);
-  return RealOutputEditing<double, 15, 53, 1024>{io, x}.Edit(edit);
+  if (!io.get_if<OutputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "OutputReal64() called for a non-output I/O statement");
+    return false;
+  }
+  return RealOutputEditing<53>{io, x}.Edit(io.GetNextDataEdit());
+}
+
+bool IONAME(OutputComplex64)(Cookie cookie, double r, double z) {
+  IoStatementState &io{*cookie};
+  if (io.get_if<ListDirectedStatementState<false>>()) {
+    DataEdit real, imaginary;
+    real.descriptor = DataEdit::ListDirectedRealPart;
+    imaginary.descriptor = DataEdit::ListDirectedImaginaryPart;
+    return RealOutputEditing<53>{io, r}.Edit(real) &&
+        RealOutputEditing<53>{io, z}.Edit(imaginary);
+  }
+  return IONAME(OutputReal64)(cookie, r) && IONAME(OutputReal64)(cookie, z);
 }
 
 bool IONAME(OutputAscii)(Cookie cookie, const char *x, std::size_t length) {
   IoStatementState &io{*cookie};
-  DataEdit edit;
-  io.GetNext(edit);
-  if (edit.descriptor != 'A' && edit.descriptor != 'G') {
-    io.Crash(
-        "Data edit descriptor '%c' may not be used with a CHARACTER data item",
-        edit.descriptor);
+  if (!io.get_if<OutputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "OutputAscii() called for a non-output I/O statement");
     return false;
   }
-  int len{static_cast<int>(length)};
-  int width{edit.width.value_or(len)};
-  return EmitRepeated(io, ' ', std::max(0, width - len)) &&
-      io.Emit(x, std::min(width, len));
+  bool ok{true};
+  if (auto *list{io.get_if<ListDirectedStatementState<false>>()}) {
+    // List-directed default CHARACTER output
+    ok &= list->EmitLeadingSpaceOrAdvance(io, length, true);
+    MutableModes &modes{io.mutableModes()};
+    ConnectionState &connection{io.GetConnectionState()};
+    if (modes.delim) {
+      ok &= io.Emit(&modes.delim, 1);
+      for (std::size_t j{0}; j < length; ++j) {
+        if (list->NeedAdvance(connection, 2)) {
+          ok &= io.Emit(&modes.delim, 1) && io.AdvanceRecord() &&
+              io.Emit(&modes.delim, 1);
+        }
+        if (x[j] == modes.delim) {
+          ok &= io.EmitRepeated(modes.delim, 2);
+        } else {
+          ok &= io.Emit(&x[j], 1);
+        }
+      }
+      ok &= io.Emit(&modes.delim, 1);
+    } else {
+      std::size_t put{0};
+      while (put < length) {
+        auto chunk{std::min(length - put, connection.RemainingSpaceInRecord())};
+        ok &= io.Emit(x + put, chunk);
+        put += chunk;
+        if (put < length) {
+          ok &= io.AdvanceRecord() && io.Emit(" ", 1);
+        }
+      }
+      list->lastWasUndelimitedCharacter = true;
+    }
+  } else {
+    // Formatted default CHARACTER output
+    DataEdit edit{io.GetNextDataEdit()};
+    if (edit.descriptor != 'A' && edit.descriptor != 'G') {
+      io.GetIoErrorHandler().Crash("Data edit descriptor '%c' may not be used "
+                                   "with a CHARACTER data item",
+          edit.descriptor);
+      return false;
+    }
+    int len{static_cast<int>(length)};
+    int width{edit.width.value_or(len)};
+    ok &= io.EmitRepeated(' ', std::max(0, width - len)) &&
+        io.Emit(x, std::min(width, len));
+  }
+  return ok;
 }
 
 bool IONAME(OutputLogical)(Cookie cookie, bool truth) {
   IoStatementState &io{*cookie};
-  DataEdit edit;
-  io.GetNext(edit);
-  if (edit.descriptor != 'L' && edit.descriptor != 'G') {
-    io.Crash(
-        "Data edit descriptor '%c' may not be used with a LOGICAL data item",
-        edit.descriptor);
+  if (!io.get_if<OutputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "OutputLogical() called for a non-output I/O statement");
     return false;
   }
-  return EmitRepeated(io, ' ', std::max(0, edit.width.value_or(1) - 1)) &&
-      io.Emit(truth ? "T" : "F", 1);
+  if (auto *unf{io.get_if<UnformattedIoStatementState<false>>()}) {
+    char x = truth;
+    return unf->Emit(&x, 1);
+  }
+  bool ok{true};
+  if (auto *list{io.get_if<ListDirectedStatementState<false>>()}) {
+    ok &= list->EmitLeadingSpaceOrAdvance(io, 1);
+  } else {
+    DataEdit edit{io.GetNextDataEdit()};
+    if (edit.descriptor != 'L' && edit.descriptor != 'G') {
+      io.GetIoErrorHandler().Crash(
+          "Data edit descriptor '%c' may not be used with a LOGICAL data item",
+          edit.descriptor);
+      return false;
+    }
+    ok &= io.EmitRepeated(' ', std::max(0, edit.width.value_or(1) - 1));
+  }
+  return ok && io.Emit(truth ? "T" : "F", 1);
 }
 
 enum Iostat IONAME(EndIoStatement)(Cookie cookie) {
diff --git a/runtime/io-api.h b/runtime/io-api.h
index 1c1f81ea4c6f..417c0b5a3981 100644
--- a/runtime/io-api.h
+++ b/runtime/io-api.h
@@ -51,8 +51,7 @@ constexpr std::size_t RecommendedInternalIoScratchAreaBytes(
 }
 
 // Internal I/O to/from character arrays &/or non-default-kind character
-// requires a descriptor, which must remain unchanged until the I/O
-// statement is complete.
+// requires a descriptor, which is copied.
 Cookie IONAME(BeginInternalArrayListOutput)(const Descriptor &,
     void **scratchArea = nullptr, std::size_t scratchBytes = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
@@ -172,8 +171,8 @@ Cookie IONAME(BeginInquireIoLength)(
 //     }
 //   }
 //   if (EndIoStatement(cookie) == FORTRAN_RUTIME_IOSTAT_END) goto label666;
-void IONAME(EnableHandlers)(Cookie, bool HasIostat = false, bool HasErr = false,
-    bool HasEnd = false, bool HasEor = false);
+void IONAME(EnableHandlers)(Cookie, bool hasIoStat = false, bool hasErr = false,
+    bool hasEnd = false, bool hasEor = false);
 
 // Control list options.  These return false on a error that the
 // Begin...() call has specified will be handled by the caller.
@@ -253,12 +252,10 @@ bool IONAME(SetStatus)(Cookie, const char *, std::size_t);
 // SetFile() may pass a CHARACTER argument of non-default kind,
 // and such filenames are converted to UTF-8 before being
 // presented to the filesystem.
-bool IONAME(SetFile)(Cookie, const char *, std::size_t, int kind = 1);
+bool IONAME(SetFile)(Cookie, const char *, std::size_t chars, int kind = 1);
 
-// GetNewUnit() must not be called until after all Set...()
-// connection list specifiers have been called after
-// BeginOpenNewUnit().
-bool IONAME(GetNewUnit)(Cookie, int &, int kind = 4);  // NEWUNIT=
+// Acquires the runtime-created unit number for OPEN(NEWUNIT=)
+bool IONAME(GetNewUnit)(Cookie, int &, int kind = 4);
 
 // READ(SIZE=), after all input items
 bool IONAME(GetSize)(Cookie, std::int64_t, int kind = 8);
diff --git a/runtime/io-error.h b/runtime/io-error.h
index 6cab725186e3..80f5fa817910 100644
--- a/runtime/io-error.h
+++ b/runtime/io-error.h
@@ -18,9 +18,10 @@
 
 namespace Fortran::runtime::io {
 
-class IoErrorHandler : virtual public Terminator {
+class IoErrorHandler : public Terminator {
 public:
   using Terminator::Terminator;
+  explicit IoErrorHandler(const Terminator &that) : Terminator{that} {}
   void Begin(const char *sourceFileName, int sourceLine);
   void HasIoStat() { flags_ |= hasIoStat; }
   void HasErrLabel() { flags_ |= hasErr; }
diff --git a/runtime/io-stmt.cpp b/runtime/io-stmt.cpp
index e54a67a328e2..adc9bae6c150 100644
--- a/runtime/io-stmt.cpp
+++ b/runtime/io-stmt.cpp
@@ -7,130 +7,66 @@
 //===----------------------------------------------------------------------===//
 
 #include "io-stmt.h"
+#include "connection.h"
+#include "format.h"
 #include "memory.h"
+#include "tools.h"
 #include "unit.h"
 #include <algorithm>
 #include <cstring>
+#include <limits>
 
 namespace Fortran::runtime::io {
 
-IoStatementState::IoStatementState(const char *sourceFile, int sourceLine)
-  : IoErrorHandler{sourceFile, sourceLine} {}
+int IoStatementBase::EndIoStatement() { return GetIoStat(); }
 
-int IoStatementState::EndIoStatement() { return GetIoStat(); }
-
-// Defaults
-void IoStatementState::GetNext(DataEdit &, int) {
-  Crash("GetNext() called for I/O statement that is not a formatted data "
-        "transfer statement");
-}
-bool IoStatementState::Emit(const char *, std::size_t) {
-  Crash("Emit() called for I/O statement that is not an output statement");
-  return false;
-}
-bool IoStatementState::Emit(const char16_t *, std::size_t) {
-  Crash("Emit() called for I/O statement that is not an output statement");
-  return false;
-}
-bool IoStatementState::Emit(const char32_t *, std::size_t) {
-  Crash("Emit() called for I/O statement that is not an output statement");
-  return false;
-}
-bool IoStatementState::HandleSlash(int) {
-  Crash("HandleSlash() called for I/O statement that is not a formatted data "
-        "transfer statement");
-  return false;
-}
-bool IoStatementState::HandleRelativePosition(std::int64_t) {
-  Crash("HandleRelativePosition() called for I/O statement that is not a "
-        "formatted data transfer statement");
-  return false;
-}
-bool IoStatementState::HandleAbsolutePosition(std::int64_t) {
-  Crash("HandleAbsolutePosition() called for I/O statement that is not a "
-        "formatted data transfer statement");
-  return false;
+DataEdit IoStatementBase::GetNextDataEdit(int) {
+  Crash("IoStatementBase::GetNextDataEdit() called for non-formatted I/O "
+        "statement");
 }
 
 template<bool isInput, typename CHAR>
-FixedRecordIoStatementState<isInput, CHAR>::FixedRecordIoStatementState(
-    Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
-  : IoStatementState{sourceFile, sourceLine}, buffer_{buffer}, length_{length} {
-}
+InternalIoStatementState<isInput, CHAR>::InternalIoStatementState(
+    Buffer scalar, std::size_t length, const char *sourceFile, int sourceLine)
+  : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length} {}
+
+template<bool isInput, typename CHAR>
+InternalIoStatementState<isInput, CHAR>::InternalIoStatementState(
+    const Descriptor &d, const char *sourceFile, int sourceLine)
+  : IoStatementBase{sourceFile, sourceLine}, unit_{d, *this} {}
 
 template<bool isInput, typename CHAR>
-bool FixedRecordIoStatementState<isInput, CHAR>::Emit(
-    const CHAR *data, std::size_t chars) {
+bool InternalIoStatementState<isInput, CHAR>::Emit(
+    const CharType *data, std::size_t chars) {
   if constexpr (isInput) {
-    IoStatementState::Emit(data, chars);  // default Crash()
+    Crash("InternalIoStatementState<true>::Emit() called for input statement");
     return false;
-  } else if (at_ + chars > length_) {
-    SignalEor();
-    if (at_ < length_) {
-      std::memcpy(buffer_ + at_, data, (length_ - at_) * sizeof(CHAR));
-      at_ = furthest_ = length_;
-    }
-    return false;
-  } else {
-    std::memcpy(buffer_ + at_, data, chars * sizeof(CHAR));
-    at_ += chars;
-    furthest_ = std::max(furthest_, at_);
-    return true;
   }
+  return unit_.Emit(data, chars, *this);
 }
 
 template<bool isInput, typename CHAR>
-bool FixedRecordIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
-    std::int64_t n) {
-  if (n < 0) {
-    n = 0;
-  }
-  n += leftTabLimit_;
-  bool ok{true};
-  if (static_cast<std::size_t>(n) > length_) {
-    SignalEor();
-    n = length_;
-    ok = false;
-  }
-  if constexpr (!isInput) {
-    if (static_cast<std::size_t>(n) > furthest_) {
-      std::fill_n(buffer_ + furthest_, n - furthest_, static_cast<CHAR>(' '));
+bool InternalIoStatementState<isInput, CHAR>::AdvanceRecord(int n) {
+  while (n-- > 0) {
+    if (!unit_.AdvanceRecord(*this)) {
+      return false;
     }
   }
-  at_ = n;
-  furthest_ = std::max(furthest_, at_);
-  return ok;
-}
-
-template<bool isInput, typename CHAR>
-bool FixedRecordIoStatementState<isInput, CHAR>::HandleRelativePosition(
-    std::int64_t n) {
-  return HandleAbsolutePosition(n + at_ - leftTabLimit_);
+  return true;
 }
 
 template<bool isInput, typename CHAR>
-int FixedRecordIoStatementState<isInput, CHAR>::EndIoStatement() {
+int InternalIoStatementState<isInput, CHAR>::EndIoStatement() {
   if constexpr (!isInput) {
-    HandleAbsolutePosition(length_ - leftTabLimit_);  // fill
+    unit_.EndIoStatement();  // fill
   }
-  return GetIoStat();
-}
-
-template<bool isInput, typename CHAR>
-int InternalIoStatementState<isInput, CHAR>::EndIoStatement() {
-  auto result{FixedRecordIoStatementState<isInput, CHAR>::EndIoStatement()};
+  auto result{IoStatementBase::EndIoStatement()};
   if (free_) {
     FreeMemory(this);
   }
   return result;
 }
 
-template<bool isInput, typename CHAR>
-InternalIoStatementState<isInput, CHAR>::InternalIoStatementState(
-    Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
-  : FixedRecordIoStatementState<isInput, CHAR>(
-        buffer, length, sourceFile, sourceLine) {}
-
 template<bool isInput, typename CHAR>
 InternalFormattedIoStatementState<isInput,
     CHAR>::InternalFormattedIoStatementState(Buffer buffer, std::size_t length,
@@ -138,63 +74,289 @@ InternalFormattedIoStatementState<isInput,
     int sourceLine)
   : InternalIoStatementState<isInput, CHAR>{buffer, length, sourceFile,
         sourceLine},
-    format_{*this, format, formatLength} {}
+    ioStatementState_{*this}, format_{*this, format, formatLength} {}
+
+template<bool isInput, typename CHAR>
+InternalFormattedIoStatementState<isInput,
+    CHAR>::InternalFormattedIoStatementState(const Descriptor &d,
+    const CHAR *format, std::size_t formatLength, const char *sourceFile,
+    int sourceLine)
+  : InternalIoStatementState<isInput, CHAR>{d, sourceFile, sourceLine},
+    ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
 template<bool isInput, typename CHAR>
 int InternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
-  format_.FinishOutput(*this);
+  if constexpr (!isInput) {
+    format_.FinishOutput(*this);
+  }
   return InternalIoStatementState<isInput, CHAR>::EndIoStatement();
 }
 
 template<bool isInput, typename CHAR>
-ExternalFormattedIoStatementState<isInput,
-    CHAR>::ExternalFormattedIoStatementState(ExternalFile &file,
-    const CHAR *format, std::size_t formatLength, const char *sourceFile,
-    int sourceLine)
-  : IoStatementState{sourceFile, sourceLine}, file_{file}, format_{*this,
-                                                               format,
-                                                               formatLength} {}
+bool InternalFormattedIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
+    std::int64_t n) {
+  return unit_.HandleAbsolutePosition(n, *this);
+}
 
 template<bool isInput, typename CHAR>
-bool ExternalFormattedIoStatementState<isInput, CHAR>::Emit(
-    const CHAR *data, std::size_t chars) {
-  // TODO: UTF-8 encoding of 2- and 4-byte characters
-  return file_.Emit(data, chars * sizeof(CHAR), *this);
+bool InternalFormattedIoStatementState<isInput, CHAR>::HandleRelativePosition(
+    std::int64_t n) {
+  return unit_.HandleRelativePosition(n, *this);
 }
 
 template<bool isInput, typename CHAR>
-bool ExternalFormattedIoStatementState<isInput, CHAR>::HandleSlash(int n) {
+InternalListIoStatementState<isInput, CHAR>::InternalListIoStatementState(
+    Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
+  : InternalIoStatementState<isInput, CharType>{buffer, length, sourceFile,
+        sourceLine},
+    ioStatementState_{*this} {}
+
+template<bool isInput, typename CHAR>
+InternalListIoStatementState<isInput, CHAR>::InternalListIoStatementState(
+    const Descriptor &d, const char *sourceFile, int sourceLine)
+  : InternalIoStatementState<isInput, CharType>{d, sourceFile, sourceLine},
+    ioStatementState_{*this} {}
+
+ExternalIoStatementBase::ExternalIoStatementBase(
+    ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
+  : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
+
+MutableModes &ExternalIoStatementBase::mutableModes() { return unit_.modes; }
+
+ConnectionState &ExternalIoStatementBase::GetConnectionState() { return unit_; }
+
+int ExternalIoStatementBase::EndIoStatement() {
+  if (unit_.nonAdvancing) {
+    unit_.leftTabLimit = unit_.furthestPositionInRecord;
+    unit_.nonAdvancing = false;
+  } else {
+    unit_.leftTabLimit.reset();
+  }
+  auto result{IoStatementBase::EndIoStatement()};
+  unit_.EndIoStatement();  // annihilates *this in unit_.u_
+  return result;
+}
+
+void OpenStatementState::set_path(
+    const char *path, std::size_t length, int kind) {
+  if (kind != 1) {  // TODO
+    Crash("OPEN: FILE= with unimplemented: CHARACTER(KIND=%d)", kind);
+  }
+  std::size_t bytes{length * kind};  // TODO: UTF-8 encoding of Unicode path
+  path_ = SaveDefaultCharacter(path, bytes, *this);
+  pathLength_ = length;
+}
+
+int OpenStatementState::EndIoStatement() {
+  if (wasExtant_ && status_ != OpenStatus::Old) {
+    Crash("OPEN statement for connected unit must have STATUS='OLD'");
+  }
+  unit().OpenUnit(status_, position_, std::move(path_), pathLength_, *this);
+  return IoStatementBase::EndIoStatement();
+}
+
+int CloseStatementState::EndIoStatement() {
+  unit().CloseUnit(status_, *this);
+  return IoStatementBase::EndIoStatement();
+}
+
+int NoopCloseStatementState::EndIoStatement() {
+  auto result{IoStatementBase::EndIoStatement()};
+  FreeMemory(this);
+  return result;
+}
+
+template<bool isInput> int ExternalIoStatementState<isInput>::EndIoStatement() {
+  if constexpr (!isInput) {
+    if (!unit().nonAdvancing) {
+      unit().AdvanceRecord(*this);
+    }
+    unit().FlushIfTerminal(*this);
+  }
+  return ExternalIoStatementBase::EndIoStatement();
+}
+
+template<bool isInput>
+bool ExternalIoStatementState<isInput>::Emit(
+    const char *data, std::size_t chars) {
+  if (isInput) {
+    Crash("ExternalIoStatementState::Emit called for input statement");
+  }
+  return unit().Emit(data, chars * sizeof(*data), *this);
+}
+
+template<bool isInput>
+bool ExternalIoStatementState<isInput>::Emit(
+    const char16_t *data, std::size_t chars) {
+  if (isInput) {
+    Crash("ExternalIoStatementState::Emit called for input statement");
+  }
+  // TODO: UTF-8 encoding
+  return unit().Emit(
+      reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
+}
+
+template<bool isInput>
+bool ExternalIoStatementState<isInput>::Emit(
+    const char32_t *data, std::size_t chars) {
+  if (isInput) {
+    Crash("ExternalIoStatementState::Emit called for input statement");
+  }
+  // TODO: UTF-8 encoding
+  return unit().Emit(
+      reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
+}
+
+template<bool isInput>
+bool ExternalIoStatementState<isInput>::AdvanceRecord(int n) {
   while (n-- > 0) {
-    if (!file_.NextOutputRecord(*this)) {
+    if (!unit().AdvanceRecord(*this)) {
       return false;
     }
   }
   return true;
 }
 
-template<bool isInput, typename CHAR>
-bool ExternalFormattedIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
-    std::int64_t n) {
-  return file_.HandleAbsolutePosition(n, *this);
+template<bool isInput>
+bool ExternalIoStatementState<isInput>::HandleAbsolutePosition(std::int64_t n) {
+  return unit().HandleAbsolutePosition(n, *this);
 }
 
-template<bool isInput, typename CHAR>
-bool ExternalFormattedIoStatementState<isInput, CHAR>::HandleRelativePosition(
-    std::int64_t n) {
-  return file_.HandleRelativePosition(n, *this);
+template<bool isInput>
+bool ExternalIoStatementState<isInput>::HandleRelativePosition(std::int64_t n) {
+  return unit().HandleRelativePosition(n, *this);
 }
 
+template<bool isInput, typename CHAR>
+ExternalFormattedIoStatementState<isInput,
+    CHAR>::ExternalFormattedIoStatementState(ExternalFileUnit &unit,
+    const CHAR *format, std::size_t formatLength, const char *sourceFile,
+    int sourceLine)
+  : ExternalIoStatementState<isInput>{unit, sourceFile, sourceLine},
+    mutableModes_{unit.modes}, format_{*this, format, formatLength} {}
+
 template<bool isInput, typename CHAR>
 int ExternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
   format_.FinishOutput(*this);
-  if constexpr (!isInput) {
-    file_.NextOutputRecord(*this);  // TODO: non-advancing I/O
+  return ExternalIoStatementState<isInput>::EndIoStatement();
+}
+
+DataEdit IoStatementState::GetNextDataEdit(int n) {
+  return std::visit([&](auto &x) { return x.get().GetNextDataEdit(n); }, u_);
+}
+
+bool IoStatementState::Emit(const char *data, std::size_t n) {
+  return std::visit([=](auto &x) { return x.get().Emit(data, n); }, u_);
+}
+
+bool IoStatementState::AdvanceRecord(int n) {
+  return std::visit([=](auto &x) { return x.get().AdvanceRecord(n); }, u_);
+}
+
+int IoStatementState::EndIoStatement() {
+  return std::visit([](auto &x) { return x.get().EndIoStatement(); }, u_);
+}
+
+ConnectionState &IoStatementState::GetConnectionState() {
+  return std::visit(
+      [](auto &x) -> ConnectionState & { return x.get().GetConnectionState(); },
+      u_);
+}
+
+MutableModes &IoStatementState::mutableModes() {
+  return std::visit(
+      [](auto &x) -> MutableModes & { return x.get().mutableModes(); }, u_);
+}
+
+IoErrorHandler &IoStatementState::GetIoErrorHandler() const {
+  return std::visit(
+      [](auto &x) -> IoErrorHandler & {
+        return static_cast<IoErrorHandler &>(x.get());
+      },
+      u_);
+}
+
+bool IoStatementState::EmitRepeated(char ch, std::size_t n) {
+  return std::visit(
+      [=](auto &x) {
+        for (std::size_t j{0}; j < n; ++j) {
+          if (!x.get().Emit(&ch, 1)) {
+            return false;
+          }
+        }
+        return true;
+      },
+      u_);
+}
+
+bool IoStatementState::EmitField(
+    const char *p, std::size_t length, std::size_t width) {
+  if (width <= 0) {
+    width = static_cast<int>(length);
   }
-  int result{GetIoStat()};
-  file_.EndIoStatement();  // annihilates *this in file_.u_
-  return result;
+  if (length > static_cast<std::size_t>(width)) {
+    return EmitRepeated('*', width);
+  } else {
+    return EmitRepeated(' ', static_cast<int>(width - length)) &&
+        Emit(p, length);
+  }
+}
+
+bool ListDirectedStatementState<false>::NeedAdvance(
+    const ConnectionState &connection, std::size_t width) const {
+  return connection.positionInRecord > 0 &&
+      width > connection.RemainingSpaceInRecord();
+}
+
+bool ListDirectedStatementState<false>::EmitLeadingSpaceOrAdvance(
+    IoStatementState &io, std::size_t length, bool isCharacter) {
+  if (length == 0) {
+    return true;
+  }
+  const ConnectionState &connection{io.GetConnectionState()};
+  int space{connection.positionInRecord == 0 ||
+      !(isCharacter && lastWasUndelimitedCharacter)};
+  lastWasUndelimitedCharacter = false;
+  if (NeedAdvance(connection, space + length)) {
+    return io.AdvanceRecord();
+  }
+  if (space) {
+    return io.Emit(" ", 1);
+  }
+  return true;
+}
+
+template<bool isInput>
+int UnformattedIoStatementState<isInput>::EndIoStatement() {
+  auto &ext{static_cast<ExternalIoStatementState<isInput> &>(*this)};
+  ExternalFileUnit &unit{ext.unit()};
+  if (unit.access == Access::Sequential && !unit.recordLength.has_value()) {
+    // Overwrite the first four bytes of the record with its length,
+    // and also append the length.  These four bytes were skipped over
+    // in BeginUnformattedOutput().
+    // TODO: Break very large records up into subrecords with negative
+    // headers &/or footers
+    union {
+      std::uint32_t u;
+      char c[sizeof u];
+    } u;
+    u.u = unit.furthestPositionInRecord - sizeof u.c;
+    // TODO: Convert record length to little-endian on big-endian host?
+    if (!(ext.Emit(u.c, sizeof u.c) && ext.HandleAbsolutePosition(0) &&
+            ext.Emit(u.c, sizeof u.c) && ext.AdvanceRecord())) {
+      return false;
+    }
+  }
+  return ext.EndIoStatement();
 }
 
+template class InternalIoStatementState<false>;
+template class InternalIoStatementState<true>;
 template class InternalFormattedIoStatementState<false>;
+template class InternalFormattedIoStatementState<true>;
+template class InternalListIoStatementState<false>;
+template class ExternalIoStatementState<false>;
 template class ExternalFormattedIoStatementState<false>;
+template class ExternalListIoStatementState<false>;
+template class UnformattedIoStatementState<false>;
 }
diff --git a/runtime/io-stmt.h b/runtime/io-stmt.h
index 002f38e82596..17549388b060 100644
--- a/runtime/io-stmt.h
+++ b/runtime/io-stmt.h
@@ -6,112 +6,312 @@
 //
 //===----------------------------------------------------------------------===//
 
-// Represents state of an I/O statement in progress
+// Representations of the state of an I/O statement in progress
 
 #ifndef FORTRAN_RUNTIME_IO_STMT_H_
 #define FORTRAN_RUNTIME_IO_STMT_H_
 
 #include "descriptor.h"
+#include "file.h"
 #include "format.h"
+#include "internal-unit.h"
 #include "io-error.h"
+#include <functional>
 #include <type_traits>
+#include <variant>
 
 namespace Fortran::runtime::io {
 
-class ExternalFile;
+struct ConnectionState;
+class ExternalFileUnit;
 
-class IoStatementState : public IoErrorHandler, public FormatContext {
+class OpenStatementState;
+class CloseStatementState;
+class NoopCloseStatementState;
+template<bool isInput, typename CHAR = char>
+class InternalFormattedIoStatementState;
+template<bool isInput, typename CHAR = char> class InternalListIoStatementState;
+template<bool isInput, typename CHAR = char>
+class ExternalFormattedIoStatementState;
+template<bool isInput> class ExternalListIoStatementState;
+template<bool isInput> class UnformattedIoStatementState;
+
+// The Cookie type in the I/O API is a pointer (for C) to this class.
+class IoStatementState {
 public:
-  IoStatementState(const char *sourceFile, int sourceLine);
-  virtual ~IoStatementState() {}
-
-  virtual int EndIoStatement();
-
-  // Default (crashing) callback overrides for FormatContext
-  virtual void GetNext(DataEdit &, int maxRepeat = 1);
-  virtual bool Emit(const char *, std::size_t);
-  virtual bool Emit(const char16_t *, std::size_t);
-  virtual bool Emit(const char32_t *, std::size_t);
-  virtual bool HandleSlash(int);
-  virtual bool HandleRelativePosition(std::int64_t);
-  virtual bool HandleAbsolutePosition(std::int64_t);
-};
+  template<typename A> explicit IoStatementState(A &x) : u_{x} {}
 
-template<bool IsInput, typename CHAR = char>
-class FixedRecordIoStatementState : public IoStatementState {
-protected:
-  using Buffer = std::conditional_t<IsInput, const CHAR *, CHAR *>;
+  // These member functions each project themselves into the active alternative.
+  // They're used by per-data-item routines in the I/O API(e.g., OutputReal64)
+  // to interact with the state of the I/O statement in progress.
+  // This design avoids virtual member functions and function pointers,
+  // which may not have good support in some use cases.
+  DataEdit GetNextDataEdit(int = 1);
+  bool Emit(const char *, std::size_t);
+  bool AdvanceRecord(int = 1);
+  int EndIoStatement();
+  ConnectionState &GetConnectionState();
+  MutableModes &mutableModes();
 
-public:
-  FixedRecordIoStatementState(
-      Buffer, std::size_t, const char *sourceFile, int sourceLine);
+  // N.B.: this also works with base classes
+  template<typename A> A *get_if() const {
+    return std::visit(
+        [](auto &x) -> A * {
+          if constexpr (std::is_convertible_v<decltype(x.get()), A &>) {
+            return &x.get();
+          }
+          return nullptr;
+        },
+        u_);
+  }
+  IoErrorHandler &GetIoErrorHandler() const;
 
-  virtual bool Emit(const CHAR *, std::size_t chars /* not bytes */);
-  // TODO virtual void HandleSlash(int);
-  virtual bool HandleRelativePosition(std::int64_t);
-  virtual bool HandleAbsolutePosition(std::int64_t);
-  virtual int EndIoStatement();
+  bool EmitRepeated(char, std::size_t);
+  bool EmitField(const char *, std::size_t length, std::size_t width);
 
 private:
-  Buffer buffer_{nullptr};
-  std::size_t length_;  // RECL= or internal I/O character variable length
-  std::size_t leftTabLimit_{0};  // nonzero only when non-advancing
-  std::size_t at_{0};
-  std::size_t furthest_{0};
+  std::variant<std::reference_wrapper<OpenStatementState>,
+      std::reference_wrapper<CloseStatementState>,
+      std::reference_wrapper<NoopCloseStatementState>,
+      std::reference_wrapper<InternalFormattedIoStatementState<false>>,
+      std::reference_wrapper<InternalFormattedIoStatementState<true>>,
+      std::reference_wrapper<InternalListIoStatementState<false>>,
+      std::reference_wrapper<ExternalFormattedIoStatementState<false>>,
+      std::reference_wrapper<ExternalListIoStatementState<false>>,
+      std::reference_wrapper<UnformattedIoStatementState<false>>>
+      u_;
+};
+
+// Base class for all per-I/O statement state classes.
+// Inherits IoErrorHandler from its base.
+struct IoStatementBase : public DefaultFormatControlCallbacks {
+  using DefaultFormatControlCallbacks::DefaultFormatControlCallbacks;
+  int EndIoStatement();
+  DataEdit GetNextDataEdit(int = 1);  // crashing default
+};
+
+struct InputStatementState {};
+struct OutputStatementState {};
+template<bool isInput>
+using IoDirectionState =
+    std::conditional_t<isInput, InputStatementState, OutputStatementState>;
+
+struct FormattedStatementState {};
+
+template<bool isInput> struct ListDirectedStatementState {};
+template<> struct ListDirectedStatementState<false /*output*/> {
+  static std::size_t RemainingSpaceInRecord(const ConnectionState &);
+  bool NeedAdvance(const ConnectionState &, std::size_t) const;
+  bool EmitLeadingSpaceOrAdvance(
+      IoStatementState &, std::size_t, bool isCharacter = false);
+  bool lastWasUndelimitedCharacter{false};
 };
 
 template<bool isInput, typename CHAR = char>
-class InternalIoStatementState
-  : public FixedRecordIoStatementState<isInput, CHAR> {
+class InternalIoStatementState : public IoStatementBase,
+                                 public IoDirectionState<isInput> {
 public:
-  using typename FixedRecordIoStatementState<isInput, CHAR>::Buffer;
+  using CharType = CHAR;
+  using Buffer = std::conditional_t<isInput, const CharType *, CharType *>;
   InternalIoStatementState(Buffer, std::size_t,
       const char *sourceFile = nullptr, int sourceLine = 0);
-  virtual int EndIoStatement();
+  InternalIoStatementState(
+      const Descriptor &, const char *sourceFile = nullptr, int sourceLine = 0);
+  int EndIoStatement();
+  bool Emit(const CharType *, std::size_t chars /* not bytes */);
+  bool AdvanceRecord(int = 1);
+  ConnectionState &GetConnectionState() { return unit_; }
+  MutableModes &mutableModes() { return unit_.modes; }
 
 protected:
   bool free_{true};
+  InternalDescriptorUnit<isInput> unit_;
 };
 
-template<bool isInput, typename CHAR = char>
+template<bool isInput, typename CHAR>
 class InternalFormattedIoStatementState
-  : public InternalIoStatementState<isInput, CHAR> {
+  : public InternalIoStatementState<isInput, CHAR>,
+    public FormattedStatementState {
 public:
-  using typename InternalIoStatementState<isInput, CHAR>::Buffer;
+  using CharType = CHAR;
+  using typename InternalIoStatementState<isInput, CharType>::Buffer;
   InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
-      const CHAR *format, std::size_t formatLength,
+      const CharType *format, std::size_t formatLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
-  void GetNext(DataEdit &edit, int maxRepeat = 1) {
-    format_.GetNext(*this, edit, maxRepeat);
+  InternalFormattedIoStatementState(const Descriptor &, const CharType *format,
+      std::size_t formatLength, const char *sourceFile = nullptr,
+      int sourceLine = 0);
+  IoStatementState &ioStatementState() { return ioStatementState_; }
+  int EndIoStatement();
+  DataEdit GetNextDataEdit(int maxRepeat = 1) {
+    return format_.GetNextDataEdit(*this, maxRepeat);
   }
+  bool HandleRelativePosition(std::int64_t);
+  bool HandleAbsolutePosition(std::int64_t);
+
+private:
+  IoStatementState ioStatementState_;  // points to *this
+  using InternalIoStatementState<isInput, CharType>::unit_;
+  // format_ *must* be last; it may be partial someday
+  FormatControl<InternalFormattedIoStatementState> format_;
+};
+
+template<bool isInput, typename CHAR>
+class InternalListIoStatementState
+  : public InternalIoStatementState<isInput, CHAR>,
+    public ListDirectedStatementState<isInput> {
+public:
+  using CharType = CHAR;
+  using typename InternalIoStatementState<isInput, CharType>::Buffer;
+  InternalListIoStatementState(Buffer internal, std::size_t internalLength,
+      const char *sourceFile = nullptr, int sourceLine = 0);
+  InternalListIoStatementState(
+      const Descriptor &, const char *sourceFile = nullptr, int sourceLine = 0);
+  IoStatementState &ioStatementState() { return ioStatementState_; }
+  DataEdit GetNextDataEdit(int maxRepeat = 1) {
+    DataEdit edit;
+    edit.descriptor = DataEdit::ListDirected;
+    edit.repeat = maxRepeat;
+    edit.modes = InternalIoStatementState<isInput, CharType>::mutableModes();
+    return edit;
+  }
+
+private:
+  using InternalIoStatementState<isInput, CharType>::unit_;
+  IoStatementState ioStatementState_;  // points to *this
+};
+
+class ExternalIoStatementBase : public IoStatementBase {
+public:
+  ExternalIoStatementBase(
+      ExternalFileUnit &, const char *sourceFile = nullptr, int sourceLine = 0);
+  ExternalFileUnit &unit() { return unit_; }
+  MutableModes &mutableModes();
+  ConnectionState &GetConnectionState();
   int EndIoStatement();
 
 private:
-  FormatControl<CHAR> format_;  // must be last, may be partial
+  ExternalFileUnit &unit_;
 };
 
-template<bool isInput, typename CHAR = char>
-class ExternalFormattedIoStatementState : public IoStatementState {
+template<bool isInput>
+class ExternalIoStatementState : public ExternalIoStatementBase,
+                                 public IoDirectionState<isInput> {
 public:
-  ExternalFormattedIoStatementState(ExternalFile &, const CHAR *format,
+  using ExternalIoStatementBase::ExternalIoStatementBase;
+  int EndIoStatement();
+  bool Emit(const char *, std::size_t chars /* not bytes */);
+  bool Emit(const char16_t *, std::size_t chars /* not bytes */);
+  bool Emit(const char32_t *, std::size_t chars /* not bytes */);
+  bool AdvanceRecord(int = 1);
+  bool HandleRelativePosition(std::int64_t);
+  bool HandleAbsolutePosition(std::int64_t);
+};
+
+template<bool isInput, typename CHAR>
+class ExternalFormattedIoStatementState
+  : public ExternalIoStatementState<isInput>,
+    public FormattedStatementState {
+public:
+  using CharType = CHAR;
+  ExternalFormattedIoStatementState(ExternalFileUnit &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,
       int sourceLine = 0);
-  void GetNext(DataEdit &edit, int maxRepeat = 1) {
-    format_.GetNext(*this, edit, maxRepeat);
+  MutableModes &mutableModes() { return mutableModes_; }
+  int EndIoStatement();
+  DataEdit GetNextDataEdit(int maxRepeat = 1) {
+    return format_.GetNextDataEdit(*this, maxRepeat);
   }
-  bool Emit(const CHAR *, std::size_t chars /* not bytes */);
-  bool HandleSlash(int);
-  bool HandleRelativePosition(std::int64_t);
-  bool HandleAbsolutePosition(std::int64_t);
+
+private:
+  // These are forked from ConnectionState's modes at the beginning
+  // of each formatted I/O statement so they may be overridden by control
+  // edit descriptors during the statement.
+  MutableModes mutableModes_;
+  FormatControl<ExternalFormattedIoStatementState> format_;
+};
+
+template<bool isInput>
+class ExternalListIoStatementState
+  : public ExternalIoStatementState<isInput>,
+    public ListDirectedStatementState<isInput> {
+public:
+  using ExternalIoStatementState<isInput>::ExternalIoStatementState;
+  DataEdit GetNextDataEdit(int maxRepeat = 1) {
+    DataEdit edit;
+    edit.descriptor = DataEdit::ListDirected;
+    edit.repeat = maxRepeat;
+    edit.modes = ExternalIoStatementState<isInput>::mutableModes();
+    return edit;
+  }
+};
+
+template<bool isInput>
+class UnformattedIoStatementState : public ExternalIoStatementState<isInput> {
+public:
+  using ExternalIoStatementState<isInput>::ExternalIoStatementState;
+  int EndIoStatement();
+};
+
+class OpenStatementState : public ExternalIoStatementBase {
+public:
+  OpenStatementState(ExternalFileUnit &unit, bool wasExtant,
+      const char *sourceFile = nullptr, int sourceLine = 0)
+    : ExternalIoStatementBase{unit, sourceFile, sourceLine}, wasExtant_{
+                                                                 wasExtant} {}
+  bool wasExtant() const { return wasExtant_; }
+  void set_status(OpenStatus status) { status_ = status; }
+  void set_path(const char *, std::size_t, int kind);  // FILE=
+  void set_position(Position position) { position_ = position; }  // POSITION=
+  int EndIoStatement();
+
+private:
+  bool wasExtant_;
+  OpenStatus status_{OpenStatus::Unknown};
+  Position position_{Position::AsIs};
+  OwningPtr<char> path_;
+  std::size_t pathLength_;
+};
+
+class CloseStatementState : public ExternalIoStatementBase {
+public:
+  CloseStatementState(ExternalFileUnit &unit, const char *sourceFile = nullptr,
+      int sourceLine = 0)
+    : ExternalIoStatementBase{unit, sourceFile, sourceLine} {}
+  void set_status(CloseStatus status) { status_ = status; }
+  int EndIoStatement();
+
+private:
+  CloseStatus status_{CloseStatus::Keep};
+};
+
+class NoopCloseStatementState : public IoStatementBase {
+public:
+  NoopCloseStatementState(const char *sourceFile, int sourceLine)
+    : IoStatementBase{sourceFile, sourceLine}, ioStatementState_{*this} {}
+  IoStatementState &ioStatementState() { return ioStatementState_; }
+  void set_status(CloseStatus) {}  // discards
+  MutableModes &mutableModes() { return connection_.modes; }
+  ConnectionState &GetConnectionState() { return connection_; }
   int EndIoStatement();
 
 private:
-  ExternalFile &file_;
-  FormatControl<CHAR> format_;
+  IoStatementState ioStatementState_;  // points to *this
+  ConnectionState connection_;
 };
 
+extern template class InternalIoStatementState<false>;
+extern template class InternalIoStatementState<true>;
 extern template class InternalFormattedIoStatementState<false>;
+extern template class InternalFormattedIoStatementState<true>;
+extern template class InternalListIoStatementState<false>;
+extern template class ExternalIoStatementState<false>;
 extern template class ExternalFormattedIoStatementState<false>;
+extern template class ExternalListIoStatementState<false>;
+extern template class UnformattedIoStatementState<false>;
+extern template class FormatControl<InternalFormattedIoStatementState<false>>;
+extern template class FormatControl<InternalFormattedIoStatementState<true>>;
+extern template class FormatControl<ExternalFormattedIoStatementState<false>>;
 
 }
 #endif  // FORTRAN_RUNTIME_IO_STMT_H_
diff --git a/runtime/lock.h b/runtime/lock.h
index 19f0cea79b01..a26c96542c88 100644
--- a/runtime/lock.h
+++ b/runtime/lock.h
@@ -23,7 +23,7 @@ class Lock {
   bool Try() { return pthread_mutex_trylock(&mutex_) != 0; }
   void Drop() { pthread_mutex_unlock(&mutex_); }
 
-  void CheckLocked(Terminator &terminator) {
+  void CheckLocked(const Terminator &terminator) {
     if (Try()) {
       Drop();
       terminator.Crash("Lock::CheckLocked() failed");
diff --git a/runtime/main.cpp b/runtime/main.cpp
index 8c2caa570df5..e7f4200b2777 100644
--- a/runtime/main.cpp
+++ b/runtime/main.cpp
@@ -33,7 +33,6 @@ void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[]) {
   std::atexit(Fortran::runtime::NotifyOtherImagesOfNormalEnd);
   Fortran::runtime::executionEnvironment.Configure(argc, argv, envp);
   ConfigureFloatingPoint();
-  Fortran::runtime::Terminator terminator{"ProgramStart()"};
-  Fortran::runtime::io::ExternalFile::InitializePredefinedUnits(terminator);
+  Fortran::runtime::io::ExternalFileUnit::InitializePredefinedUnits();
 }
 }
diff --git a/runtime/memory.cpp b/runtime/memory.cpp
index ac456a5dd9d1..84fd35da48ef 100644
--- a/runtime/memory.cpp
+++ b/runtime/memory.cpp
@@ -12,7 +12,7 @@
 
 namespace Fortran::runtime {
 
-void *AllocateMemoryOrCrash(Terminator &terminator, std::size_t bytes) {
+void *AllocateMemoryOrCrash(const Terminator &terminator, std::size_t bytes) {
   if (void *p{std::malloc(bytes)}) {
     return p;
   }
diff --git a/runtime/memory.h b/runtime/memory.h
index d41f5f95407e..1bd5bca1b78a 100644
--- a/runtime/memory.h
+++ b/runtime/memory.h
@@ -18,8 +18,9 @@ namespace Fortran::runtime {
 
 class Terminator;
 
-[[nodiscard]] void *AllocateMemoryOrCrash(Terminator &, std::size_t bytes);
-template<typename A>[[nodiscard]] A &AllocateOrCrash(Terminator &t) {
+[[nodiscard]] void *AllocateMemoryOrCrash(
+    const Terminator &, std::size_t bytes);
+template<typename A>[[nodiscard]] A &AllocateOrCrash(const Terminator &t) {
   return *reinterpret_cast<A *>(AllocateMemoryOrCrash(t, sizeof(A)));
 }
 void FreeMemory(void *);
@@ -33,7 +34,7 @@ template<typename A> void FreeMemoryAndNullify(A *&p) {
 
 template<typename A> struct New {
   template<typename... X>
-  [[nodiscard]] A &operator()(Terminator &terminator, X &&... x) {
+  [[nodiscard]] A &operator()(const Terminator &terminator, X &&... x) {
     return *new (AllocateMemoryOrCrash(terminator, sizeof(A)))
         A{std::forward<X>(x)...};
   }
@@ -47,7 +48,7 @@ template<typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
 
 template<typename A> struct Allocator {
   using value_type = A;
-  explicit Allocator(Terminator &t) : terminator{t} {}
+  explicit Allocator(const Terminator &t) : terminator{t} {}
   template<typename B>
   explicit constexpr Allocator(const Allocator<B> &that) noexcept
     : terminator{that.terminator} {}
@@ -58,7 +59,7 @@ template<typename A> struct Allocator {
         AllocateMemoryOrCrash(terminator, n * sizeof(A)));
   }
   constexpr void deallocate(A *p, std::size_t) { FreeMemory(p); }
-  Terminator &terminator;
+  const Terminator &terminator;
 };
 }
 
diff --git a/runtime/numeric-output.cpp b/runtime/numeric-output.cpp
new file mode 100644
index 000000000000..daef7aba879a
--- /dev/null
+++ b/runtime/numeric-output.cpp
@@ -0,0 +1,152 @@
+//===-- runtime/numeric-output.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 "numeric-output.h"
+#include "flang/common/unsigned-const-division.h"
+
+namespace Fortran::runtime::io {
+
+bool EditIntegerOutput(
+    IoStatementState &io, const DataEdit &edit, std::int64_t n) {
+  char buffer[66], *end = &buffer[sizeof buffer], *p = end;
+  std::uint64_t un{static_cast<std::uint64_t>(n < 0 ? -n : n)};
+  int signChars{0};
+  switch (edit.descriptor) {
+  case DataEdit::ListDirected:
+  case 'G':
+  case 'I':
+    if (n < 0 || (edit.modes.editingFlags & signPlus)) {
+      signChars = 1;  // '-' or '+'
+    }
+    while (un > 0) {
+      auto quotient{common::DivideUnsignedBy<std::uint64_t, 10>(un)};
+      *--p = '0' + un - 10 * quotient;
+      un = quotient;
+    }
+    break;
+  case 'B':
+    for (; un > 0; un >>= 1) {
+      *--p = '0' + (un & 1);
+    }
+    break;
+  case 'O':
+    for (; un > 0; un >>= 3) {
+      *--p = '0' + (un & 7);
+    }
+    break;
+  case 'Z':
+    for (; un > 0; un >>= 4) {
+      int digit = un & 0xf;
+      *--p = digit >= 10 ? 'A' + (digit - 10) : '0' + digit;
+    }
+    break;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Data edit descriptor '%c' may not be used with an INTEGER data item",
+        edit.descriptor);
+    return false;
+  }
+
+  int digits = end - p;
+  int leadingZeroes{0};
+  int editWidth{edit.width.value_or(0)};
+  if (edit.digits && digits <= *edit.digits) {  // Iw.m
+    if (*edit.digits == 0 && n == 0) {
+      // Iw.0 with zero value: output field must be blank.  For I0.0
+      // and a zero value, emit one blank character.
+      signChars = 0;  // in case of SP
+      editWidth = std::max(1, editWidth);
+    } else {
+      leadingZeroes = *edit.digits - digits;
+    }
+  } else if (n == 0) {
+    leadingZeroes = 1;
+  }
+  int total{signChars + leadingZeroes + digits};
+  if (editWidth > 0 && total > editWidth) {
+    return io.EmitRepeated('*', editWidth);
+  }
+  int leadingSpaces{std::max(0, editWidth - total)};
+  if (edit.IsListDirected()) {
+    if (static_cast<std::size_t>(total) >
+            io.GetConnectionState().RemainingSpaceInRecord() &&
+        !io.AdvanceRecord()) {
+      return false;
+    }
+    leadingSpaces = 1;
+  }
+  return io.EmitRepeated(' ', leadingSpaces) &&
+      io.Emit(n < 0 ? "-" : "+", signChars) &&
+      io.EmitRepeated('0', leadingZeroes) && io.Emit(p, digits);
+}
+
+// Formats the exponent (see table 13.1 for all the cases)
+const char *RealOutputEditingBase::FormatExponent(
+    int expo, const DataEdit &edit, int &length) {
+  char *eEnd{&exponent_[sizeof exponent_]};
+  char *exponent{eEnd};
+  for (unsigned e{static_cast<unsigned>(std::abs(expo))}; e > 0;) {
+    unsigned quotient{common::DivideUnsignedBy<unsigned, 10>(e)};
+    *--exponent = '0' + e - 10 * quotient;
+    e = quotient;
+  }
+  if (edit.expoDigits) {
+    if (int ed{*edit.expoDigits}) {  // Ew.dEe with e > 0
+      while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
+        *--exponent = '0';
+      }
+    } else if (exponent == eEnd) {
+      *--exponent = '0';  // Ew.dE0 with zero-valued exponent
+    }
+  } else {  // ensure at least two exponent digits
+    while (exponent + 2 > eEnd) {
+      *--exponent = '0';
+    }
+  }
+  *--exponent = expo < 0 ? '-' : '+';
+  if (edit.expoDigits || exponent + 3 == eEnd) {
+    *--exponent = edit.descriptor == 'D' ? 'D' : 'E';  // not 'G'
+  }
+  length = eEnd - exponent;
+  return exponent;
+}
+
+bool RealOutputEditingBase::EmitPrefix(
+    const DataEdit &edit, std::size_t length, std::size_t width) {
+  if (edit.IsListDirected()) {
+    int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart
+            ? 2
+            : edit.descriptor == DataEdit::ListDirectedImaginaryPart ? 0 : 1};
+    int suffixLength{edit.descriptor == DataEdit::ListDirectedRealPart ||
+                edit.descriptor == DataEdit::ListDirectedImaginaryPart
+            ? 1
+            : 0};
+    length += prefixLength + suffixLength;
+    ConnectionState &connection{io_.GetConnectionState()};
+    return (connection.positionInRecord == 0 ||
+               length <= connection.RemainingSpaceInRecord() ||
+               io_.AdvanceRecord()) &&
+        io_.Emit(" (", prefixLength);
+  } else if (width > length) {
+    return io_.EmitRepeated(' ', width - length);
+  } else {
+    return true;
+  }
+}
+
+bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) {
+  if (edit.descriptor == DataEdit::ListDirectedRealPart) {
+    return io_.Emit(edit.modes.editingFlags & decimalComma ? ";" : ",", 1);
+  } else if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) {
+    return io_.Emit(")", 1);
+  } else {
+    return true;
+  }
+}
+
+}
diff --git a/runtime/numeric-output.h b/runtime/numeric-output.h
index a0f40c700b7b..f8c5437ca31b 100644
--- a/runtime/numeric-output.h
+++ b/runtime/numeric-output.h
@@ -14,191 +14,99 @@
 // components, I and G for INTEGER, and B/O/Z for both.
 // See subclauses in 13.7.2.3 of Fortran 2018 for the
 // detailed specifications of these descriptors.
-// Drives the same binary-to-decimal formatting templates used
-// by the f18 compiler.
+// List-directed output (13.10.4) for numeric types is also done here.
+// Drives the same fast binary-to-decimal formatting templates used
+// in the f18 front-end.
 
 #include "format.h"
-#include "flang/common/unsigned-const-division.h"
+#include "io-stmt.h"
 #include "flang/decimal/decimal.h"
 
 namespace Fortran::runtime::io {
 
 class IoStatementState;
 
-// Utility subroutines
-static bool EmitRepeated(IoStatementState &io, char ch, int n) {
-  while (n-- > 0) {
-    if (!io.Emit(&ch, 1)) {
-      return false;
-    }
-  }
-  return true;
-}
+// I, B, O, Z, and G output editing for INTEGER.
+// edit is const here (and elsewhere in this header) so that one
+// edit descriptor with a repeat factor may safely serve to edit
+// multiple elements of an array.
+bool EditIntegerOutput(IoStatementState &, const DataEdit &, std::int64_t);
 
-static bool EmitField(
-    IoStatementState &io, const char *p, std::size_t length, int width) {
-  if (width <= 0) {
-    width = static_cast<int>(length);
-  }
-  if (length > static_cast<std::size_t>(width)) {
-    return EmitRepeated(io, '*', width);
-  } else {
-    return EmitRepeated(io, ' ', static_cast<int>(width - length)) &&
-        io.Emit(p, length);
-  }
-}
+// Encapsulates the state of a REAL output conversion.
+class RealOutputEditingBase {
+protected:
+  explicit RealOutputEditingBase(IoStatementState &io) : io_{io} {}
 
-// I, B, O, Z, and (for INTEGER) G output editing.
-// edit is const here so that a repeated edit descriptor may safely serve
-// multiple array elements
-static bool EditIntegerOutput(
-    IoStatementState &io, const DataEdit &edit, std::int64_t n) {
-  char buffer[66], *end = &buffer[sizeof buffer], *p = end;
-  std::uint64_t un{static_cast<std::uint64_t>(n < 0 ? -n : n)};
-  int signChars{0};
-  switch (edit.descriptor) {
-  case 'G':
-  case 'I':
-    if (n < 0 || (edit.modes.editingFlags & signPlus)) {
-      signChars = 1;  // '-' or '+'
-    }
-    while (un > 0) {
-      auto quotient{common::DivideUnsignedBy<std::uint64_t, 10>(un)};
-      *--p = '0' + un - 10 * quotient;
-      un = quotient;
-    }
-    break;
-  case 'B':
-    for (; un > 0; un >>= 1) {
-      *--p = '0' + (un & 1);
-    }
-    break;
-  case 'O':
-    for (; un > 0; un >>= 3) {
-      *--p = '0' + (un & 7);
+  static bool IsDecimalNumber(const char *p) {
+    if (!p) {
+      return false;
     }
-    break;
-  case 'Z':
-    for (; un > 0; un >>= 4) {
-      int digit = un & 0xf;
-      *--p = digit >= 10 ? 'A' + (digit - 10) : '0' + digit;
+    if (*p == '-' || *p == '+') {
+      ++p;
     }
-    break;
-  default:
-    io.Crash(
-        "Data edit descriptor '%c' may not be used with an INTEGER data item",
-        edit.descriptor);
-    return false;
+    return *p >= '0' && *p <= '9';
   }
 
-  int digits = end - p;
-  int leadingZeroes{0};
-  int editWidth{edit.width.value_or(0)};
-  if (edit.digits && digits <= *edit.digits) {  // Iw.m
-    if (*edit.digits == 0 && n == 0) {
-      // Iw.0 with zero value: output field must be blank.  For I0.0
-      // and a zero value, emit one blank character.
-      signChars = 0;  // in case of SP
-      editWidth = std::max(1, editWidth);
-    } else {
-      leadingZeroes = *edit.digits - digits;
-    }
-  } else if (n == 0) {
-    leadingZeroes = 1;
-  }
-  int total{signChars + leadingZeroes + digits};
-  if (edit.width > 0 && total > editWidth) {
-    return EmitRepeated(io, '*', editWidth);
-  }
-  if (total < editWidth) {
-    EmitRepeated(io, '*', editWidth - total);
-    return false;
-  }
-  if (signChars) {
-    if (!io.Emit(n < 0 ? "-" : "+", 1)) {
-      return false;
-    }
-  }
-  return EmitRepeated(io, '0', leadingZeroes) && io.Emit(p, digits);
-}
+  const char *FormatExponent(int, const DataEdit &edit, int &length);
+  bool EmitPrefix(const DataEdit &, std::size_t length, std::size_t width);
+  bool EmitSuffix(const DataEdit &);
 
-// Encapsulates the state of a REAL output conversion.
-template<typename FLOAT = double, int decimalPrecision = 15,
-    int binaryPrecision = 53, std::size_t bufferSize = 1024>
-class RealOutputEditing {
+  IoStatementState &io_;
+  int trailingBlanks_{0};  // created when Gw editing maps to Fw
+  char exponent_[16];
+};
+
+template<int binaryPrecision = 53>
+class RealOutputEditing : public RealOutputEditingBase {
 public:
-  RealOutputEditing(IoStatementState &io, FLOAT x) : io_{io}, x_{x} {}
-  bool Edit(const DataEdit &edit);
+  template<typename A>
+  RealOutputEditing(IoStatementState &io, A x)
+    : RealOutputEditingBase{io}, x_{x} {}
+  bool Edit(const DataEdit &);
 
 private:
+  using BinaryFloatingPoint =
+      decimal::BinaryFloatingPointNumber<binaryPrecision>;
+
   // The DataEdit arguments here are const references or copies so that
-  // the original DataEdit can safely serve multiple array elements if
+  // the original DataEdit can safely serve multiple array elements when
   // it has a repeat count.
   bool EditEorDOutput(const DataEdit &);
   bool EditFOutput(const DataEdit &);
   DataEdit EditForGOutput(DataEdit);  // returns an E or F edit
   bool EditEXOutput(const DataEdit &);
+  bool EditListDirectedOutput(const DataEdit &);
 
-  bool IsZero() const { return x_ == 0; }
-  const char *FormatExponent(int, const DataEdit &edit, int &length);
-
-  static enum decimal::FortranRounding SetRounding(
-      common::RoundingMode rounding) {
-    switch (rounding) {
-    case common::RoundingMode::TiesToEven: break;
-    case common::RoundingMode::Up: return decimal::RoundUp;
-    case common::RoundingMode::Down: return decimal::RoundDown;
-    case common::RoundingMode::ToZero: return decimal::RoundToZero;
-    case common::RoundingMode::TiesAwayFromZero:
-      return decimal::RoundCompatible;
-    }
-    return decimal::RoundNearest;  // arranged thus to dodge bogus G++ warning
-  }
-
-  static bool IsDecimalNumber(const char *p) {
-    if (!p) {
-      return false;
-    }
-    if (*p == '-' || *p == '+') {
-      ++p;
-    }
-    return *p >= '0' && *p <= '9';
-  }
+  bool IsZero() const { return x_.IsZero(); }
 
   decimal::ConversionToDecimalResult Convert(
       int significantDigits, const DataEdit &, int flags = 0);
 
-  IoStatementState &io_;
-  FLOAT x_;
-  char buffer_[bufferSize];
-  int trailingBlanks_{0};  // created when G editing maps to F
-  char exponent_[16];
+  BinaryFloatingPoint x_;
+  char buffer_[BinaryFloatingPoint::maxDecimalConversionDigits +
+      EXTRA_DECIMAL_CONVERSION_SPACE];
 };
 
-template<typename FLOAT, int decimalPrecision, int binaryPrecision,
-    std::size_t bufferSize>
-decimal::ConversionToDecimalResult RealOutputEditing<FLOAT, decimalPrecision,
-    binaryPrecision, bufferSize>::Convert(int significantDigits,
-    const DataEdit &edit, int flags) {
+template<int binaryPrecision>
+decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
+    int significantDigits, const DataEdit &edit, int flags) {
   if (edit.modes.editingFlags & signPlus) {
     flags |= decimal::AlwaysSign;
   }
-  auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_, bufferSize,
-      static_cast<enum decimal::DecimalConversionFlags>(flags),
-      significantDigits, SetRounding(edit.modes.roundingMode),
-      decimal::BinaryFloatingPointNumber<binaryPrecision>(x_))};
+  auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_,
+      sizeof buffer_, static_cast<enum decimal::DecimalConversionFlags>(flags),
+      significantDigits, edit.modes.round, x_)};
   if (!converted.str) {  // overflow
-    io_.Crash("RealOutputEditing::Convert : buffer size %zd was insufficient",
-        bufferSize);
+    io_.GetIoErrorHandler().Crash(
+        "RealOutputEditing::Convert : buffer size %zd was insufficient",
+        sizeof buffer_);
   }
   return converted;
 }
 
 // 13.7.2.3.3 in F'2018
-template<typename FLOAT, int decimalPrecision, int binaryPrecision,
-    std::size_t bufferSize>
-bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
-    bufferSize>::EditEorDOutput(const DataEdit &edit) {
+template<int binaryPrecision>
+bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   int editDigits{edit.digits.value_or(0)};  // 'd' field
   int editWidth{edit.width.value_or(0)};  // 'w' field
   int significantDigits{editDigits};
@@ -209,7 +117,7 @@ bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
     } else {  // E0
       flags |= decimal::Minimize;
       significantDigits =
-          bufferSize - 5;  // sign, NUL, + 3 extra for EN scaling
+          sizeof buffer_ - 5;  // sign, NUL, + 3 extra for EN scaling
     }
   }
   bool isEN{edit.variation == 'N'};
@@ -228,7 +136,8 @@ bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
     decimal::ConversionToDecimalResult converted{
         Convert(significantDigits, edit, flags)};
     if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
-      return EmitField(io_, converted.str, converted.length, editWidth);
+      return EmitPrefix(edit, converted.length, editWidth) &&
+          io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
     if (!IsZero()) {
       converted.decimalExponent -= scale;
@@ -258,63 +167,28 @@ bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
         expoLength};
     int width{editWidth > 0 ? editWidth : totalLength};
     if (totalLength > width) {
-      return EmitRepeated(io_, '*', width);
+      return io_.EmitRepeated('*', width);
     }
     if (totalLength < width && digitsBeforePoint == 0 &&
         zeroesBeforePoint == 0) {
       zeroesBeforePoint = 1;
       ++totalLength;
     }
-    return EmitRepeated(io_, ' ', width - totalLength) &&
+    return EmitPrefix(edit, totalLength, width) &&
         io_.Emit(converted.str, signLength + digitsBeforePoint) &&
-        EmitRepeated(io_, '0', zeroesBeforePoint) &&
+        io_.EmitRepeated('0', zeroesBeforePoint) &&
         io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
-        EmitRepeated(io_, '0', zeroesAfterPoint) &&
+        io_.EmitRepeated('0', zeroesAfterPoint) &&
         io_.Emit(
             converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
-        EmitRepeated(io_, '0', trailingZeroes) &&
-        io_.Emit(exponent, expoLength);
-  }
-}
-
-// Formats the exponent (see table 13.1 for all the cases)
-template<typename FLOAT, int decimalPrecision, int binaryPrecision,
-    std::size_t bufferSize>
-const char *RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
-    bufferSize>::FormatExponent(int expo, const DataEdit &edit, int &length) {
-  char *eEnd{&exponent_[sizeof exponent_]};
-  char *exponent{eEnd};
-  for (unsigned e{static_cast<unsigned>(std::abs(expo))}; e > 0;) {
-    unsigned quotient{common::DivideUnsignedBy<unsigned, 10>(e)};
-    *--exponent = '0' + e - 10 * quotient;
-    e = quotient;
-  }
-  if (edit.expoDigits) {
-    if (int ed{*edit.expoDigits}) {  // Ew.dEe with e > 0
-      while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
-        *--exponent = '0';
-      }
-    } else if (exponent == eEnd) {
-      *--exponent = '0';  // Ew.dE0 with zero-valued exponent
-    }
-  } else {  // ensure at least two exponent digits
-    while (exponent + 2 > eEnd) {
-      *--exponent = '0';
-    }
+        io_.EmitRepeated('0', trailingZeroes) &&
+        io_.Emit(exponent, expoLength) && EmitSuffix(edit);
   }
-  *--exponent = expo < 0 ? '-' : '+';
-  if (edit.expoDigits || exponent + 3 == eEnd) {
-    *--exponent = edit.descriptor == 'D' ? 'D' : 'E';  // not 'G'
-  }
-  length = eEnd - exponent;
-  return exponent;
 }
 
 // 13.7.2.3.2 in F'2018
-template<typename FLOAT, int decimalPrecision, int binaryPrecision,
-    std::size_t bufferSize>
-bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
-    bufferSize>::EditFOutput(const DataEdit &edit) {
+template<int binaryPrecision>
+bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
   int fracDigits{edit.digits.value_or(0)};  // 'd' field
   int extraDigits{0};
   int editWidth{edit.width.value_or(0)};  // 'w' field
@@ -322,7 +196,7 @@ bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
   if (editWidth == 0) {  // "the processor selects the field width"
     if (!edit.digits.has_value()) {  // F0
       flags |= decimal::Minimize;
-      fracDigits = bufferSize - 2;  // sign & NUL
+      fracDigits = sizeof buffer_ - 2;  // sign & NUL
     }
   }
   // Multiple conversions may be needed to get the right number of
@@ -331,14 +205,15 @@ bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
     decimal::ConversionToDecimalResult converted{
         Convert(extraDigits + fracDigits, edit, flags)};
     if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
-      return EmitField(io_, converted.str, converted.length, editWidth);
+      return EmitPrefix(edit, converted.length, editWidth) &&
+          io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
     int scale{IsZero() ? -1 : edit.modes.scale};
     int expo{converted.decimalExponent - scale};
     if (expo > extraDigits) {
       extraDigits = expo;
       if (flags & decimal::Minimize) {
-        fracDigits = bufferSize - extraDigits - 2;  // sign & NUL
+        fracDigits = sizeof buffer_ - extraDigits - 2;  // sign & NUL
       }
       continue;  // try again
     }
@@ -360,29 +235,27 @@ bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
         1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes};
     int width{editWidth > 0 ? editWidth : totalLength};
     if (totalLength > width) {
-      return EmitRepeated(io_, '*', width);
+      return io_.EmitRepeated('*', width);
     }
     if (totalLength < width && digitsBeforePoint + zeroesBeforePoint == 0) {
       zeroesBeforePoint = 1;
       ++totalLength;
     }
-    return EmitRepeated(io_, ' ', width - totalLength) &&
+    return EmitPrefix(edit, totalLength, width) &&
         io_.Emit(converted.str, signLength + digitsBeforePoint) &&
-        EmitRepeated(io_, '0', zeroesBeforePoint) &&
+        io_.EmitRepeated('0', zeroesBeforePoint) &&
         io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
-        EmitRepeated(io_, '0', zeroesAfterPoint) &&
+        io_.EmitRepeated('0', zeroesAfterPoint) &&
         io_.Emit(
             converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
-        EmitRepeated(io_, '0', trailingZeroes) &&
-        EmitRepeated(io_, ' ', trailingBlanks_);
+        io_.EmitRepeated('0', trailingZeroes) &&
+        io_.EmitRepeated(' ', trailingBlanks_) && EmitSuffix(edit);
   }
 }
 
 // 13.7.5.2.3 in F'2018
-template<typename FLOAT, int decimalPrecision, int binaryPrecision,
-    std::size_t bufferSize>
-DataEdit RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
-    bufferSize>::EditForGOutput(DataEdit edit) {
+template<int binaryPrecision>
+DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   edit.descriptor = 'E';
   if (!edit.width.has_value() ||
       (*edit.width > 0 && edit.digits.value_or(-1) == 0)) {
@@ -393,7 +266,8 @@ DataEdit RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
     return edit;
   }
   int expo{IsZero() ? 1 : converted.decimalExponent};  // 's'
-  int significantDigits{edit.digits.value_or(decimalPrecision)};  // 'd'
+  int significantDigits{
+      edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)};  // 'd'
   if (expo < 0 || expo > significantDigits) {
     return edit;  // Ew.d
   }
@@ -412,18 +286,32 @@ DataEdit RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
   return edit;
 }
 
+// 13.10.4 in F'2018
+template<int binaryPrecision>
+bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
+    const DataEdit &edit) {
+  decimal::ConversionToDecimalResult converted{Convert(1, edit)};
+  if (!IsDecimalNumber(converted.str)) {  // Inf, NaN
+    return EditEorDOutput(edit);
+  }
+  int expo{converted.decimalExponent};
+  if (expo < 0 || expo > BinaryFloatingPoint::decimalPrecision) {
+    DataEdit copy{edit};
+    copy.modes.scale = 1;  // 1P
+    return EditEorDOutput(copy);
+  }
+  return EditFOutput(edit);
+}
+
 // 13.7.5.2.6 in F'2018
-template<typename FLOAT, int decimalPrecision, int binaryPrecision,
-    std::size_t bufferSize>
-bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
-    bufferSize>::EditEXOutput(const DataEdit &) {
-  io_.Crash("EX output editing is not yet implemented");  // TODO
+template<int binaryPrecision>
+bool RealOutputEditing<binaryPrecision>::EditEXOutput(const DataEdit &) {
+  io_.GetIoErrorHandler().Crash(
+      "EX output editing is not yet implemented");  // TODO
 }
 
-template<typename FLOAT, int decimalPrecision, int binaryPrecision,
-    std::size_t bufferSize>
-bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
-    bufferSize>::Edit(const DataEdit &edit) {
+template<int binaryPrecision>
+bool RealOutputEditing<binaryPrecision>::Edit(const DataEdit &edit) {
   switch (edit.descriptor) {
   case 'D': return EditEorDOutput(edit);
   case 'E':
@@ -436,14 +324,20 @@ bool RealOutputEditing<FLOAT, decimalPrecision, binaryPrecision,
   case 'B':
   case 'O':
   case 'Z':
-    return EditIntegerOutput(io_, edit, decimal::BinaryFloatingPointNumber<binaryPrecision>{x_}.raw);
+    return EditIntegerOutput(
+        io_, edit, decimal::BinaryFloatingPointNumber<binaryPrecision>{x_}.raw);
   case 'G': return Edit(EditForGOutput(edit));
   default:
-    io_.Crash("Data edit descriptor '%c' may not be used with a REAL data item",
+    if (edit.IsListDirected()) {
+      return EditListDirectedOutput(edit);
+    }
+    io_.GetIoErrorHandler().Crash(
+        "Data edit descriptor '%c' may not be used with a REAL data item",
         edit.descriptor);
     return false;
   }
   return false;
 }
+
 }
 #endif  // FORTRAN_RUNTIME_NUMERIC_OUTPUT_H_
diff --git a/runtime/stop.cpp b/runtime/stop.cpp
index 85bf9c4a14ac..46ad558dfe4c 100644
--- a/runtime/stop.cpp
+++ b/runtime/stop.cpp
@@ -71,7 +71,7 @@ static void DescribeIEEESignaledExceptions() {
 
 [[noreturn]] void RTNAME(ProgramEndStatement)() {
   Fortran::runtime::io::IoErrorHandler handler{"END statement"};
-  Fortran::runtime::io::ExternalFile::CloseAll(handler);
+  Fortran::runtime::io::ExternalFileUnit::CloseAll(handler);
   std::exit(EXIT_SUCCESS);
 }
 }
diff --git a/runtime/terminator.cpp b/runtime/terminator.cpp
index c516af3c854a..74594ba65d84 100644
--- a/runtime/terminator.cpp
+++ b/runtime/terminator.cpp
@@ -12,13 +12,14 @@
 
 namespace Fortran::runtime {
 
-[[noreturn]] void Terminator::Crash(const char *message, ...) {
+[[noreturn]] void Terminator::Crash(const char *message, ...) const {
   va_list ap;
   va_start(ap, message);
   CrashArgs(message, ap);
 }
 
-[[noreturn]] void Terminator::CrashArgs(const char *message, va_list &ap) {
+[[noreturn]] void Terminator::CrashArgs(
+    const char *message, va_list &ap) const {
   std::fputs("\nfatal Fortran runtime error", stderr);
   if (sourceFileName_) {
     std::fprintf(stderr, "(%s", sourceFileName_);
@@ -31,23 +32,19 @@ namespace Fortran::runtime {
   std::vfprintf(stderr, message, ap);
   fputc('\n', stderr);
   va_end(ap);
+  io::FlushOutputOnCrash(*this);
   NotifyOtherImagesOfErrorTermination();
   std::abort();
 }
 
 [[noreturn]] void Terminator::CheckFailed(
-    const char *predicate, const char *file, int line) {
+    const char *predicate, const char *file, int line) const {
   Crash("Internal error: RUNTIME_CHECK(%s) failed at %s(%d)", predicate, file,
       line);
 }
 
-void NotifyOtherImagesOfNormalEnd() {
-  // TODO
-}
-void NotifyOtherImagesOfFailImageStatement() {
-  // TODO
-}
-void NotifyOtherImagesOfErrorTermination() {
-  // TODO
-}
+// TODO: These will be defined in the coarray runtime library
+void NotifyOtherImagesOfNormalEnd() {}
+void NotifyOtherImagesOfFailImageStatement() {}
+void NotifyOtherImagesOfErrorTermination() {}
 }
diff --git a/runtime/terminator.h b/runtime/terminator.h
index 5fe381e5167a..8cfc5cc8b123 100644
--- a/runtime/terminator.h
+++ b/runtime/terminator.h
@@ -21,16 +21,17 @@ namespace Fortran::runtime {
 class Terminator {
 public:
   Terminator() {}
+  Terminator(const Terminator &) = default;
   explicit Terminator(const char *sourceFileName, int sourceLine = 0)
     : sourceFileName_{sourceFileName}, sourceLine_{sourceLine} {}
   void SetLocation(const char *sourceFileName = nullptr, int sourceLine = 0) {
     sourceFileName_ = sourceFileName;
     sourceLine_ = sourceLine;
   }
-  [[noreturn]] void Crash(const char *message, ...);
-  [[noreturn]] void CrashArgs(const char *message, va_list &);
+  [[noreturn]] void Crash(const char *message, ...) const;
+  [[noreturn]] void CrashArgs(const char *message, va_list &) const;
   [[noreturn]] void CheckFailed(
-      const char *predicate, const char *file, int line);
+      const char *predicate, const char *file, int line) const;
 
 private:
   const char *sourceFileName_{nullptr};
@@ -47,4 +48,9 @@ void NotifyOtherImagesOfNormalEnd();
 void NotifyOtherImagesOfFailImageStatement();
 void NotifyOtherImagesOfErrorTermination();
 }
+
+namespace Fortran::runtime::io {
+void FlushOutputOnCrash(const Terminator &);
+}
+
 #endif  // FORTRAN_RUNTIME_TERMINATOR_H_
diff --git a/runtime/tools.cpp b/runtime/tools.cpp
index 43a0f68b0fe8..b254baf07b46 100644
--- a/runtime/tools.cpp
+++ b/runtime/tools.cpp
@@ -12,7 +12,7 @@
 namespace Fortran::runtime {
 
 OwningPtr<char> SaveDefaultCharacter(
-    const char *s, std::size_t length, Terminator &terminator) {
+    const char *s, std::size_t length, const Terminator &terminator) {
   if (s) {
     auto *p{static_cast<char *>(AllocateMemoryOrCrash(terminator, length + 1))};
     std::memcpy(p, s, length);
diff --git a/runtime/tools.h b/runtime/tools.h
index d1b90b1ad3c9..99571782dc07 100644
--- a/runtime/tools.h
+++ b/runtime/tools.h
@@ -18,7 +18,8 @@ namespace Fortran::runtime {
 
 class Terminator;
 
-OwningPtr<char> SaveDefaultCharacter(const char *, std::size_t, Terminator &);
+OwningPtr<char> SaveDefaultCharacter(
+    const char *, std::size_t, const Terminator &);
 
 // For validating and recognizing default CHARACTER values in a
 // case-insensitive manner.  Returns the zero-based index into the
diff --git a/runtime/unit.cpp b/runtime/unit.cpp
index f7a342ccbb73..277d36b39a08 100644
--- a/runtime/unit.cpp
+++ b/runtime/unit.cpp
@@ -10,55 +10,98 @@
 #include "lock.h"
 #include "memory.h"
 #include "tools.h"
-#include <cerrno>
+#include <algorithm>
 #include <type_traits>
 
 namespace Fortran::runtime::io {
 
 static Lock mapLock;
 static Terminator mapTerminator;
-static Map<int, ExternalFile> unitMap{MapAllocator<int, ExternalFile>{mapTerminator}};
+static Map<int, ExternalFileUnit> unitMap{
+    MapAllocator<int, ExternalFileUnit>{mapTerminator}};
+static ExternalFileUnit *defaultOutput{nullptr};
+
+void FlushOutputOnCrash(const Terminator &terminator) {
+  if (defaultOutput) {
+    IoErrorHandler handler{terminator};
+    handler.HasIoStat();  // prevent nested crash if flush has error
+    defaultOutput->Flush(handler);
+  }
+}
 
-ExternalFile *ExternalFile::LookUp(int unit) {
+ExternalFileUnit *ExternalFileUnit::LookUp(int unit) {
   CriticalSection criticalSection{mapLock};
   auto iter{unitMap.find(unit)};
   return iter == unitMap.end() ? nullptr : &iter->second;
 }
 
-ExternalFile &ExternalFile::LookUpOrCrash(int unit, Terminator &terminator) {
+ExternalFileUnit &ExternalFileUnit::LookUpOrCrash(
+    int unit, const Terminator &terminator) {
   CriticalSection criticalSection{mapLock};
-  ExternalFile *file{LookUp(unit)};
+  ExternalFileUnit *file{LookUp(unit)};
   if (!file) {
     terminator.Crash("Not an open I/O unit number: %d", unit);
   }
   return *file;
 }
 
-ExternalFile &ExternalFile::Create(int unit, Terminator &terminator) {
+ExternalFileUnit &ExternalFileUnit::LookUpOrCreate(int unit, bool *wasExtant) {
   CriticalSection criticalSection{mapLock};
   auto pair{unitMap.emplace(unit, unit)};
-  if (!pair.second) {
-    terminator.Crash("Already opened I/O unit number: %d", unit);
+  if (wasExtant) {
+    *wasExtant = !pair.second;
   }
   return pair.first->second;
 }
 
-void ExternalFile::CloseUnit(IoErrorHandler &handler) {
+int ExternalFileUnit::NewUnit() {
+  CriticalSection criticalSection{mapLock};
+  static int nextNewUnit{-1000};  // see 12.5.6.12 in Fortran 2018
+  return --nextNewUnit;
+}
+
+void ExternalFileUnit::OpenUnit(OpenStatus status, Position position,
+    OwningPtr<char> &&newPath, std::size_t newPathLength,
+    IoErrorHandler &handler) {
+  CriticalSection criticalSection{lock()};
+  if (IsOpen()) {
+    if (status == OpenStatus::Old &&
+        (!newPath.get() ||
+            (path() && pathLength() == newPathLength &&
+                std::memcmp(path(), newPath.get(), newPathLength) == 0))) {
+      // OPEN of existing unit, STATUS='OLD', not new FILE=
+      newPath.reset();
+      return;
+    }
+    // Otherwise, OPEN on open unit with new FILE= implies CLOSE
+    Flush(handler);
+    Close(CloseStatus::Keep, handler);
+  }
+  set_path(std::move(newPath), newPathLength);
+  Open(status, position, handler);
+}
+
+void ExternalFileUnit::CloseUnit(CloseStatus status, IoErrorHandler &handler) {
+  {
+    CriticalSection criticalSection{lock()};
+    Flush(handler);
+    Close(status, handler);
+  }
   CriticalSection criticalSection{mapLock};
-  Flush(handler);
   auto iter{unitMap.find(unitNumber_)};
   if (iter != unitMap.end()) {
     unitMap.erase(iter);
   }
 }
 
-void ExternalFile::InitializePredefinedUnits(Terminator &terminator) {
-  ExternalFile &out{ExternalFile::Create(6, terminator)};
+void ExternalFileUnit::InitializePredefinedUnits() {
+  ExternalFileUnit &out{ExternalFileUnit::LookUpOrCreate(6)};
   out.Predefine(1);
   out.set_mayRead(false);
   out.set_mayWrite(true);
   out.set_mayPosition(false);
-  ExternalFile &in{ExternalFile::Create(5, terminator)};
+  defaultOutput = &out;
+  ExternalFileUnit &in{ExternalFileUnit::LookUpOrCreate(5)};
   in.Predefine(0);
   in.set_mayRead(true);
   in.set_mayWrite(false);
@@ -66,18 +109,20 @@ void ExternalFile::InitializePredefinedUnits(Terminator &terminator) {
   // TODO: Set UTF-8 mode from the environment
 }
 
-void ExternalFile::CloseAll(IoErrorHandler &handler) {
+void ExternalFileUnit::CloseAll(IoErrorHandler &handler) {
   CriticalSection criticalSection{mapLock};
+  defaultOutput = nullptr;
   while (!unitMap.empty()) {
     auto &pair{*unitMap.begin()};
-    pair.second.CloseUnit(handler);
+    pair.second.CloseUnit(CloseStatus::Keep, handler);
   }
 }
 
-bool ExternalFile::SetPositionInRecord(std::int64_t n, IoErrorHandler &handler) {
-  n = std::max(std::int64_t{0}, n);
+bool ExternalFileUnit::SetPositionInRecord(
+    std::int64_t n, IoErrorHandler &handler) {
+  n = std::max<std::int64_t>(0, n);
   bool ok{true};
-  if (n > recordLength.value_or(n)) {
+  if (n > static_cast<std::int64_t>(recordLength.value_or(n))) {
     handler.SignalEor();
     n = *recordLength;
     ok = false;
@@ -85,7 +130,8 @@ bool ExternalFile::SetPositionInRecord(std::int64_t n, IoErrorHandler &handler)
   if (n > furthestPositionInRecord) {
     if (!isReading_ && ok) {
       WriteFrame(recordOffsetInFile, n, handler);
-      std::fill_n(Frame() + furthestPositionInRecord, n - furthestPositionInRecord, ' ');
+      std::fill_n(Frame() + furthestPositionInRecord,
+          n - furthestPositionInRecord, ' ');
     }
     furthestPositionInRecord = n;
   }
@@ -93,8 +139,10 @@ bool ExternalFile::SetPositionInRecord(std::int64_t n, IoErrorHandler &handler)
   return ok;
 }
 
-bool ExternalFile::Emit(const char *data, std::size_t bytes, IoErrorHandler &handler) {
-  auto furthestAfter{std::max(furthestPositionInRecord, positionInRecord + static_cast<std::int64_t>(bytes))};
+bool ExternalFileUnit::Emit(
+    const char *data, std::size_t bytes, IoErrorHandler &handler) {
+  auto furthestAfter{std::max(furthestPositionInRecord,
+      positionInRecord + static_cast<std::int64_t>(bytes))};
   WriteFrame(recordOffsetInFile, furthestAfter, handler);
   std::memcpy(Frame() + positionInRecord, data, bytes);
   positionInRecord += bytes;
@@ -102,36 +150,46 @@ bool ExternalFile::Emit(const char *data, std::size_t bytes, IoErrorHandler &han
   return true;
 }
 
-void ExternalFile::SetLeftTabLimit() {
+void ExternalFileUnit::SetLeftTabLimit() {
   leftTabLimit = furthestPositionInRecord;
   positionInRecord = furthestPositionInRecord;
 }
 
-bool ExternalFile::NextOutputRecord(IoErrorHandler &handler) {
+bool ExternalFileUnit::AdvanceRecord(IoErrorHandler &handler) {
   bool ok{true};
   if (recordLength.has_value()) {  // fill fixed-size record
     ok &= SetPositionInRecord(*recordLength, handler);
-  } else if (!unformatted && !isReading_) {
+  } else if (!isUnformatted && !isReading_) {
     ok &= SetPositionInRecord(furthestPositionInRecord, handler) &&
-      Emit("\n", 1, handler);
+        Emit("\n", 1, handler);
   }
   recordOffsetInFile += furthestPositionInRecord;
   ++currentRecordNumber;
   positionInRecord = 0;
-  positionInRecord = furthestPositionInRecord = 0;
+  furthestPositionInRecord = 0;
   leftTabLimit.reset();
   return ok;
 }
 
-bool ExternalFile::HandleAbsolutePosition(std::int64_t n, IoErrorHandler &handler) {
-  return SetPositionInRecord(std::max(n, std::int64_t{0}) + leftTabLimit.value_or(0), handler);
+bool ExternalFileUnit::HandleAbsolutePosition(
+    std::int64_t n, IoErrorHandler &handler) {
+  return SetPositionInRecord(
+      std::max(n, std::int64_t{0}) + leftTabLimit.value_or(0), handler);
 }
 
-bool ExternalFile::HandleRelativePosition(std::int64_t n, IoErrorHandler &handler) {
+bool ExternalFileUnit::HandleRelativePosition(
+    std::int64_t n, IoErrorHandler &handler) {
   return HandleAbsolutePosition(positionInRecord + n, handler);
 }
 
-void ExternalFile::EndIoStatement() {
+void ExternalFileUnit::FlushIfTerminal(IoErrorHandler &handler) {
+  if (isTerminal()) {
+    Flush(handler);
+  }
+}
+
+void ExternalFileUnit::EndIoStatement() {
+  io_.reset();
   u_.emplace<std::monostate>();
 }
 }
diff --git a/runtime/unit.h b/runtime/unit.h
index a6b80b22587e..62f664b8f32a 100644
--- a/runtime/unit.h
+++ b/runtime/unit.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-// Fortran I/O units
+// Fortran external I/O units
 
 #ifndef FORTRAN_RUNTIME_IO_UNIT_H_
 #define FORTRAN_RUNTIME_IO_UNIT_H_
 
 #include "buffer.h"
-#include "descriptor.h"
+#include "connection.h"
 #include "file.h"
 #include "format.h"
 #include "io-error.h"
@@ -27,87 +27,57 @@
 
 namespace Fortran::runtime::io {
 
-enum class Access { Sequential, Direct, Stream };
-
-inline bool IsRecordFile(Access a) { return a != Access::Stream; }
-
-// These characteristics of a connection are immutable after being
-// established in an OPEN statement.
-struct ConnectionAttributes {
-  Access access{Access::Sequential};  // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
-  std::optional<std::int64_t> recordLength;  // RECL= when fixed-length
-  bool unformatted{false};  // FORM='UNFORMATTED'
-  bool isUTF8{false};  // ENCODING='UTF-8'
-  bool asynchronousAllowed{false};  // ASYNCHRONOUS='YES'
-};
-
-struct ConnectionState : public ConnectionAttributes {
-  // Positions in a record file (sequential or direct, but not stream)
-  std::int64_t recordOffsetInFile{0};
-  std::int64_t currentRecordNumber{1};  // 1 is first
-  std::int64_t positionInRecord{0};  // offset in current record
-  std::int64_t furthestPositionInRecord{0};  // max(positionInRecord)
-  std::optional<std::int64_t> leftTabLimit;  // offset in current record
-  // nextRecord value captured after ENDFILE/REWIND/BACKSPACE statement
-  // on a sequential access file
-  std::optional<std::int64_t> endfileRecordNumber;
-  // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
-  MutableModes modes;  // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
-};
-
-class InternalUnit : public ConnectionState, public IoErrorHandler {
+class ExternalFileUnit : public ConnectionState,
+                         public OpenFile,
+                         public FileFrame<ExternalFileUnit> {
 public:
-  InternalUnit(Descriptor &, const char *sourceFile, int sourceLine)
-    : IoErrorHandler{sourceFile, sourceLine} {
-// TODO pmk    descriptor_.Establish(...);
-    descriptor_.GetLowerBounds(at_);
-    recordLength = descriptor_.ElementBytes();
-    endfileRecordNumber = descriptor_.Elements();
-  }
-  ~InternalUnit() {
-    if (!doNotFree_) {
-      std::free(this);
-    }
-  }
+  explicit ExternalFileUnit(int unitNumber) : unitNumber_{unitNumber} {}
+  int unitNumber() const { return unitNumber_; }
 
-private:
-  bool doNotFree_{false};
-  Descriptor descriptor_;
-  SubscriptValue at_[maxRank];
-};
-
-class ExternalFile : public ConnectionState,  // TODO: privatize these
-                     public OpenFile,
-                     public FileFrame<ExternalFile> {
-public:
-  explicit ExternalFile(int unitNumber) : unitNumber_{unitNumber} {}
-  static ExternalFile *LookUp(int unit);
-  static ExternalFile &LookUpOrCrash(int unit, Terminator &);
-  static ExternalFile &Create(int unit, Terminator &);
-  static void InitializePredefinedUnits(Terminator &);
+  static ExternalFileUnit *LookUp(int unit);
+  static ExternalFileUnit &LookUpOrCrash(int unit, const Terminator &);
+  static ExternalFileUnit &LookUpOrCreate(int unit, bool *wasExtant = nullptr);
+  static int NewUnit();
+  static void InitializePredefinedUnits();
   static void CloseAll(IoErrorHandler &);
 
-  void CloseUnit(IoErrorHandler &);
+  void OpenUnit(OpenStatus, Position, OwningPtr<char> &&path,
+      std::size_t pathLength, IoErrorHandler &);
+  void CloseUnit(CloseStatus, IoErrorHandler &);
 
-  // TODO: accessors & mutators for many OPEN() specifiers
-  template<typename A, typename... X> A &BeginIoStatement(X&&... xs) {
-    // TODO: lock_.Take() here, and keep it until EndIoStatement()?
+  template<typename A, typename... X>
+  IoStatementState &BeginIoStatement(X &&... xs) {
+    // TODO: lock().Take() here, and keep it until EndIoStatement()?
     // Nested I/O from derived types wouldn't work, though.
-    return u_.emplace<A>(std::forward<X>(xs)...);
+    A &state{u_.emplace<A>(std::forward<X>(xs)...)};
+    if constexpr (!std::is_same_v<A, OpenStatementState>) {
+      state.mutableModes() = ConnectionState::modes;
+    }
+    io_.emplace(state);
+    return *io_;
   }
-  void EndIoStatement();
 
-  bool SetPositionInRecord(std::int64_t, IoErrorHandler &);
   bool Emit(const char *, std::size_t bytes, IoErrorHandler &);
   void SetLeftTabLimit();
-  bool NextOutputRecord(IoErrorHandler &);
+  bool AdvanceRecord(IoErrorHandler &);
   bool HandleAbsolutePosition(std::int64_t, IoErrorHandler &);
   bool HandleRelativePosition(std::int64_t, IoErrorHandler &);
+
+  void FlushIfTerminal(IoErrorHandler &);
+  void EndIoStatement();
+
 private:
+  bool SetPositionInRecord(std::int64_t, IoErrorHandler &);
+
   int unitNumber_{-1};
-  Lock lock_;
   bool isReading_{false};
-  std::variant<std::monostate, ExternalFormattedIoStatementState<false>> u_;
+  // When an I/O statement is in progress on this unit, holds its state.
+  std::variant<std::monostate, OpenStatementState, CloseStatementState,
+      ExternalFormattedIoStatementState<false>,
+      ExternalListIoStatementState<false>, UnformattedIoStatementState<false>>
+      u_;
+  // Points to the active alternative, if any, in u_, for use as a Cookie
+  std::optional<IoStatementState> io_;
 };
 
 }
diff --git a/test/evaluate/real.cpp b/test/evaluate/real.cpp
index 919bc3ca87c7..85101e513726 100644
--- a/test/evaluate/real.cpp
+++ b/test/evaluate/real.cpp
@@ -91,7 +91,7 @@ template<typename R> void basicTests(int rm, Rounding rounding) {
   TEST(nan.Compare(zero) == Relation::Unordered)(desc);
   TEST(nan.Compare(minusZero) == Relation::Unordered)(desc);
   TEST(nan.Compare(nan) == Relation::Unordered)(desc);
-  int significandBits{R::precision - R::implicitMSB};
+  int significandBits{R::binaryPrecision - R::isImplicitMSB};
   int exponentBits{R::bits - significandBits - 1};
   std::uint64_t maxExponent{(std::uint64_t{1} << exponentBits) - 1};
   MATCH(nan.Exponent(), maxExponent)(desc);
diff --git a/test/runtime/external-hello.cpp b/test/runtime/external-hello.cpp
index af7151f6c44e..400d345e1b39 100644
--- a/test/runtime/external-hello.cpp
+++ b/test/runtime/external-hello.cpp
@@ -6,9 +6,20 @@
 using namespace Fortran::runtime::io;
 
 int main(int argc, const char *argv[], const char *envp[]) {
-  static const char *format{"(12HHELLO, WORLD)"};
   RTNAME(ProgramStart)(argc, argv, envp);
-  auto *io{IONAME(BeginExternalFormattedOutput)(format, std::strlen(format))};
+  auto *io{IONAME(BeginExternalListOutput)()};
+  const char str[]{"Hello, world!"};
+  IONAME(OutputAscii)(io, str, std::strlen(str));
+  IONAME(OutputInteger64)(io, 678);
+  IONAME(OutputReal64)(io, 0.0);
+  IONAME(OutputReal64)(io, 2.0 / 3.0);
+  IONAME(OutputReal64)(io, 1.0e99);
+  IONAME(OutputReal64)(io, 1.0 / 0.0);
+  IONAME(OutputReal64)(io, -1.0 / 0.0);
+  IONAME(OutputReal64)(io, 0.0 / 0.0);
+  IONAME(OutputComplex64)(io, 123.0, -234.0);
+  IONAME(OutputLogical)(io, false);
+  IONAME(OutputLogical)(io, true);
   IONAME(EndIoStatement)(io);
   RTNAME(ProgramEndStatement)();
   return 0;
diff --git a/test/runtime/format.cpp b/test/runtime/format.cpp
index 31e3261d8f88..05ec9d3e280b 100644
--- a/test/runtime/format.cpp
+++ b/test/runtime/format.cpp
@@ -1,37 +1,43 @@
 // Tests basic FORMAT string traversal
 
-#include "../runtime/format.h"
+#include "../runtime/format-implementation.h"
 #include "../runtime/terminator.h"
 #include <cstdarg>
 #include <cstring>
 #include <iostream>
-#include <list>
 #include <string>
+#include <vector>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 using namespace std::literals::string_literals;
 
 static int failures{0};
-using Results = std::list<std::string>;
+using Results = std::vector<std::string>;
 
-// Test harness context for format control
-struct TestFormatContext : virtual public Terminator, public FormatContext {
+// A test harness context for testing FormatControl
+class TestFormatContext : public Terminator {
+public:
+  using CharType = char;
   TestFormatContext() : Terminator{"format.cpp", 1} {}
   bool Emit(const char *, std::size_t);
   bool Emit(const char16_t *, std::size_t);
   bool Emit(const char32_t *, std::size_t);
-  bool HandleSlash(int = 1);
+  bool AdvanceRecord(int = 1);
   bool HandleRelativePosition(std::int64_t);
   bool HandleAbsolutePosition(std::int64_t);
   void Report(const DataEdit &);
   void Check(Results &);
   Results results;
+  MutableModes &mutableModes() { return mutableModes_; }
+
+private:
+  MutableModes mutableModes_;
 };
 
 // Override the runtime's Crash() for testing purposes
 [[noreturn]] void Fortran::runtime::Terminator::Crash(
-    const char *message, ...) {
+    const char *message, ...) const {
   std::va_list ap;
   va_start(ap, message);
   char buffer[1000];
@@ -54,7 +60,7 @@ bool TestFormatContext::Emit(const char32_t *, std::size_t) {
   return false;
 }
 
-bool TestFormatContext::HandleSlash(int n) {
+bool TestFormatContext::AdvanceRecord(int n) {
   while (n-- > 0) {
     results.emplace_back("/");
   }
@@ -115,12 +121,11 @@ void TestFormatContext::Check(Results &expect) {
 
 static void Test(int n, const char *format, Results &&expect, int repeat = 1) {
   TestFormatContext context;
-  FormatControl control{context, format, std::strlen(format)};
+  FormatControl<TestFormatContext> control{
+      context, format, std::strlen(format)};
   try {
     for (int j{0}; j < n; ++j) {
-      DataEdit edit;
-      control.GetNext(context, edit, repeat);
-      context.Report(edit);
+      context.Report(control.GetNextDataEdit(context, repeat));
     }
     control.FinishOutput(context);
   } catch (const std::string &crash) {
diff --git a/test/runtime/hello.cpp b/test/runtime/hello.cpp
index 86354a36de5e..4bb65acd565e 100644
--- a/test/runtime/hello.cpp
+++ b/test/runtime/hello.cpp
@@ -1,9 +1,11 @@
 // Basic sanity tests of I/O API; exhaustive testing will be done in Fortran
 
+#include "../../runtime/descriptor.h"
 #include "../../runtime/io-api.h"
 #include <cstring>
 #include <iostream>
 
+using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 
 static int failures{0};
@@ -28,7 +30,7 @@ static void hello() {
   IONAME(OutputInteger64)(cookie, 0xfeedface);
   IONAME(OutputLogical)(cookie, true);
   if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    std::cerr << '\'' << format << "' failed, status "
+    std::cerr << "hello: '" << format << "' failed, status "
               << static_cast<int>(status) << '\n';
     ++failures;
   } else {
@@ -37,6 +39,49 @@ static void hello() {
   }
 }
 
+static void multiline() {
+  char buffer[4][32];
+  StaticDescriptor<1> staticDescriptor[2];
+  Descriptor &whole{staticDescriptor[0].descriptor()};
+  SubscriptValue extent[]{4};
+  whole.Establish(TypeCode{CFI_type_char}, sizeof buffer[0], &buffer, 1, extent,
+      CFI_attribute_pointer);
+  //  whole.Dump(std::cout);
+  whole.Check();
+  Descriptor &section{staticDescriptor[1].descriptor()};
+  SubscriptValue lowers[]{0}, uppers[]{3}, strides[]{1};
+  section.Establish(whole.type(), whole.ElementBytes(), nullptr, 1, extent,
+      CFI_attribute_pointer);
+  //  section.Dump(std::cout);
+  section.Check();
+  if (auto error{
+          CFI_section(&section.raw(), &whole.raw(), lowers, uppers, strides)}) {
+    std::cerr << "multiline: CFI_section failed: " << error << '\n';
+    ++failures;
+    return;
+  }
+  section.Dump(std::cout);
+  section.Check();
+  const char *format{"('?abcde,',T1,'>',T9,A,TL12,A,TR25,'<'//G0,25X,'done')"};
+  auto cookie{IONAME(BeginInternalArrayFormattedOutput)(
+      section, format, std::strlen(format))};
+  IONAME(OutputAscii)(cookie, "WORLD", 5);
+  IONAME(OutputAscii)(cookie, "HELLO", 5);
+  IONAME(OutputInteger64)(cookie, 789);
+  if (auto status{IONAME(EndIoStatement)(cookie)}) {
+    std::cerr << "multiline: '" << format << "' failed, status "
+              << static_cast<int>(status) << '\n';
+    ++failures;
+  } else {
+    test(format,
+        ">HELLO, WORLD                  <"
+        "                                "
+        "789                         done"
+        "                                ",
+        std::string{buffer[0], sizeof buffer});
+  }
+}
+
 static void realTest(const char *format, double x, const char *expect) {
   char buffer[800];
   auto cookie{IONAME(BeginInternalFormattedOutput)(
@@ -53,6 +98,7 @@ static void realTest(const char *format, double x, const char *expect) {
 
 int main() {
   hello();
+  multiline();
 
   static const char *zeroes[][2]{
       {"(E32.17,';')", "         0.00000000000000000E+00;"},

From 403faf847d0beacac26421bc82318aaef0e973c9 Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Fri, 14 Feb 2020 04:46:29 +0000
Subject: [PATCH 027/345] Add zlib to drone files so that linking LLVM works.
 (#983)

---
 .drone.star | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.drone.star b/.drone.star
index f08549f289d1..5911a5b15bc4 100644
--- a/.drone.star
+++ b/.drone.star
@@ -7,7 +7,7 @@ def clang(arch):
                 "name": "test",
                 "image": "ubuntu",
                 "commands": [
-                    "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-dev libc++-8-dev libc++abi-8-dev",
+                    "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-dev libc++-8-dev libc++abi-8-dev libz-dev",
                     "mkdir build && cd build",
                     'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..',
                     "ninja -j8",
@@ -27,7 +27,7 @@ def gcc(arch):
                     "name": "test",
                     "image": "gcc",
                     "commands": [
-			"apt-get update && apt-get install -y cmake ninja-build llvm-dev",
+			"apt-get update && apt-get install -y cmake ninja-build llvm-dev libz-dev",
                         "mkdir build && cd build",
                         'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..',
                         "ninja -j8",

From 5dd0b0bbe811a908374b2907bb38c75ca76127d2 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Tue, 11 Feb 2020 12:14:04 -0800
Subject: [PATCH 028/345] Semantic check for C708

An entity declared with the CLASS keyword shall be a dummy argument or
have the ALLOCATABLE or POINTER attribute.

Implementing this check revealed a problem in the test resolve44.cpp.
It also showed that we were doing semantic checking on the entities
created by the compiler for LOCAL and LOCAL_INIT locality-specs.  So I
changed the creation of symbols associated with LOCAL and LOCAL_INIT
locality-specs to be host associated with the outer symbol rather than
new object entities.  In the process, I also changed things so that the
`parser::Name` associated with the newly created symbols was set to the
symbol rather than being set to nullptr.
---
 lib/semantics/check-declarations.cpp |  8 ++++++++
 lib/semantics/resolve-names.cpp      |  8 ++------
 test/semantics/CMakeLists.txt        |  1 +
 test/semantics/allocate01.f90        |  3 ++-
 test/semantics/allocate09.f90        |  8 +++++---
 test/semantics/resolve44.f90         |  3 +++
 test/semantics/resolve70.f90         |  4 ++--
 test/semantics/resolve71.f90         | 23 +++++++++++++++++++++++
 test/semantics/symbol09.f90          |  4 ++--
 9 files changed, 48 insertions(+), 14 deletions(-)
 create mode 100644 test/semantics/resolve71.f90

diff --git a/lib/semantics/check-declarations.cpp b/lib/semantics/check-declarations.cpp
index 7cd81c91c348..57f4d788bcc7 100644
--- a/lib/semantics/check-declarations.cpp
+++ b/lib/semantics/check-declarations.cpp
@@ -371,6 +371,14 @@ void CheckHelper::CheckObjectEntity(
       }
     }
   }
+  if (const DeclTypeSpec * type{details.type()}) {  // C708
+    if (type->IsPolymorphic() &&
+        !(IsAllocatableOrPointer(symbol) || symbol.IsDummy())) {
+      messages_.Say("CLASS entity '%s' must be a dummy argument or have "
+                    "ALLOCATABLE or POINTER attribute"_err_en_US,
+          symbol.name());
+    }
+  }
 }
 
 // The six different kinds of array-specs:
diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index f075fa30a4b8..61e9ed02711d 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -4314,12 +4314,8 @@ Symbol *DeclarationVisitor::DeclareLocalEntity(const parser::Name &name) {
   if (!PassesLocalityChecks(name, prev)) {
     return nullptr;
   }
-  name.symbol = nullptr;
-  Symbol &symbol{DeclareEntity<ObjectEntityDetails>(name, {})};
-  if (auto *type{prev.GetType()}) {
-    symbol.SetType(*type);
-    symbol.set(Symbol::Flag::Implicit, prev.test(Symbol::Flag::Implicit));
-  }
+  Symbol &symbol{MakeSymbol(name, HostAssocDetails{prev})};
+  name.symbol = &symbol;
   return &symbol;
 }
 
diff --git a/test/semantics/CMakeLists.txt b/test/semantics/CMakeLists.txt
index 4873a0f50ebd..c29282442cd9 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/semantics/CMakeLists.txt
@@ -101,6 +101,7 @@ set(ERROR_TESTS
   resolve68.f90
   resolve69.f90
   resolve70.f90
+  resolve71.f90
   stop01.f90
   structconst01.f90
   structconst02.f90
diff --git a/test/semantics/allocate01.f90 b/test/semantics/allocate01.f90
index 137286e47cf6..6944e2b30090 100644
--- a/test/semantics/allocate01.f90
+++ b/test/semantics/allocate01.f90
@@ -16,7 +16,8 @@ module m
 
 contains
   function mfoo(x)
-    class(a_type) :: foo, x
+    class(a_type) :: x
+    class(a_type), allocatable :: foo
     foo = x
   end function
   subroutine mbar(x)
diff --git a/test/semantics/allocate09.f90 b/test/semantics/allocate09.f90
index 49736f905743..e47cd8134b49 100644
--- a/test/semantics/allocate09.f90
+++ b/test/semantics/allocate09.f90
@@ -24,7 +24,7 @@ subroutine C946(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
 
   real(kind=4) srcx, srcx_array(10)
   real(kind=8) srcx8, srcx8_array(10)
-  class(WithParam(4, 2)) src_a_4_2
+  class(WithParam(4, 2)), allocatable :: src_a_4_2
   type(WithParam(8, 2)) src_a_8_2
   class(WithParam(4, :)), allocatable :: src_a_4_def
   class(WithParam(8, :)), allocatable :: src_a_8_def
@@ -33,8 +33,10 @@ subroutine C946(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
   type(WithParamExtent(8, 2, 8, 3)) src_b_8_2_8_3
   class(WithParamExtent(8, :, 8, 3)), allocatable :: src_b_8_def_8_3
   type(WithParamExtent2(k1=4, l1=5, k2=5, l2=6, l3=8 )) src_c_4_5_5_6_8_8
-  class(WithParamExtent2(k1=4, l1=2, k2=5, l2=6, k3=5, l3=8)) src_c_4_2_5_6_5_8
-  class(WithParamExtent2(k2=5, l2=6, k3=5, l3=8)) src_c_1_2_5_6_5_8
+  class(WithParamExtent2(k1=4, l1=2, k2=5, l2=6, k3=5, l3=8)), &
+      allocatable :: src_c_4_2_5_6_5_8
+  class(WithParamExtent2(k2=5, l2=6, k3=5, l3=8)), &
+      allocatable :: src_c_1_2_5_6_5_8
   type(WithParamExtent2(k1=5, l1=5, k2=5, l2=6, l3=8 )) src_c_5_5_5_6_8_8
   type(WithParamExtent2(k1=5, l1=2, k2=5, l2=6, k3=5, l3=8)) src_c_5_2_5_6_5_8
 
diff --git a/test/semantics/resolve44.f90 b/test/semantics/resolve44.f90
index af6a40dff6b4..f6e7a89ba5c3 100644
--- a/test/semantics/resolve44.f90
+++ b/test/semantics/resolve44.f90
@@ -7,6 +7,7 @@ program main
     type(recursive1), pointer :: ok1
     type(recursive1), allocatable :: ok2
     !ERROR: Recursive use of the derived type requires POINTER or ALLOCATABLE
+    !ERROR: CLASS entity 'bad2' must be a dummy argument or have ALLOCATABLE or POINTER attribute
     class(recursive1) :: bad2
     class(recursive1), pointer :: ok3
     class(recursive1), allocatable :: ok4
@@ -19,6 +20,7 @@ program main
     type(recursive2(kind,len)), pointer :: ok1
     type(recursive2(kind,len)), allocatable :: ok2
     !ERROR: Recursive use of the derived type requires POINTER or ALLOCATABLE
+    !ERROR: CLASS entity 'bad2' must be a dummy argument or have ALLOCATABLE or POINTER attribute
     class(recursive2(kind,len)) :: bad2
     class(recursive2(kind,len)), pointer :: ok3
     class(recursive2(kind,len)), allocatable :: ok4
@@ -31,6 +33,7 @@ program main
     type(recursive3), pointer :: ok1
     type(recursive3), allocatable :: ok2
     !ERROR: Recursive use of the derived type requires POINTER or ALLOCATABLE
+    !ERROR: CLASS entity 'bad2' must be a dummy argument or have ALLOCATABLE or POINTER attribute
     class(recursive3) :: bad2
     class(recursive3), pointer :: ok3
     class(recursive3), allocatable :: ok4
diff --git a/test/semantics/resolve70.f90 b/test/semantics/resolve70.f90
index b771fd0677be..8824ea4249af 100644
--- a/test/semantics/resolve70.f90
+++ b/test/semantics/resolve70.f90
@@ -51,8 +51,8 @@ subroutine s1()
   end type
 
   ! This one's OK
-  class(extensible) :: y
+  class(extensible), allocatable :: y
 
   !ERROR: Non-extensible derived type 'inextensible' may not be used with CLASS keyword
-  class(inextensible) :: x
+  class(inextensible), allocatable :: x
 end subroutine s1
diff --git a/test/semantics/resolve71.f90 b/test/semantics/resolve71.f90
new file mode 100644
index 000000000000..d570233d4633
--- /dev/null
+++ b/test/semantics/resolve71.f90
@@ -0,0 +1,23 @@
+! C708 An entity declared with the CLASS keyword shall be a dummy argument 
+! or have the ALLOCATABLE or POINTER attribute.
+subroutine s()
+  type :: parentType
+  end type
+
+  class(parentType), pointer :: pvar
+  class(parentType), allocatable :: avar
+  class(*), allocatable :: starAllocatableVar
+  class(*), pointer :: starPointerVar
+  !ERROR: CLASS entity 'barevar' must be a dummy argument or have ALLOCATABLE or POINTER attribute
+  class(parentType) :: bareVar
+  !ERROR: CLASS entity 'starvar' must be a dummy argument or have ALLOCATABLE or POINTER attribute
+  class(*) :: starVar
+
+    contains
+      subroutine inner(arg1, arg2, arg3, arg4, arg5)
+        class (parenttype) :: arg1, arg3
+        type(parentType) :: arg2
+        class (parenttype), pointer :: arg4
+        class (parenttype), allocatable :: arg5
+      end subroutine inner
+end subroutine s
diff --git a/test/semantics/symbol09.f90 b/test/semantics/symbol09.f90
index 480f7198c8b0..8dca1332a538 100644
--- a/test/semantics/symbol09.f90
+++ b/test/semantics/symbol09.f90
@@ -104,8 +104,8 @@ subroutine s6
  !DEF: /s6/a ObjectEntity INTEGER(4)
  integer :: a(5) = 1
  !DEF: /s6/Block1/i ObjectEntity INTEGER(4)
- !DEF: /s6/Block1/j (LocalityLocal) ObjectEntity INTEGER(8)
- !DEF: /s6/Block1/k (Implicit, LocalityLocalInit) ObjectEntity INTEGER(4)
+ !DEF: /s6/Block1/j (LocalityLocal) HostAssoc INTEGER(8)
+ !DEF: /s6/Block1/k (LocalityLocalInit) HostAssoc INTEGER(4)
   !DEF: /s6/Block1/a (LocalityShared) HostAssoc INTEGER(4)
  do concurrent(integer::i=1:5)local(j)local_init(k)shared(a)
   !REF: /s6/Block1/a

From 00d8d5121cdaed09e584a0aea7d59baf322bfaa3 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 21 Jan 2020 07:41:52 -0800
Subject: [PATCH 029/345] Add clang-format files for FIR source (LLVM style)

Note:
This commit does not reflect an actual work log, it is a feature based split of the
changes done in the FIR experimental branch. The related work log can be found in the commits between:
https://github.com/schweitzpgi/f18/commit/8c320e3bf2c3e9cdac66c81db3bf4634bf972e1d
and:
https://github.com/schweitzpgi/f18/commit/9b9ea05f9a75608c7bb5372c56bf7b9363569a69
---
 include/fir/.clang-format             | 2 ++
 include/flang/lower/.clang-format     | 2 ++
 include/flang/optimizer/.clang-format | 2 ++
 lib/fir/.clang-format                 | 2 ++
 lib/lower/.clang-format               | 2 ++
 lib/optimizer/.clang-format           | 2 ++
 tools/bbc/.clang-format               | 2 ++
 tools/tco/.clang-format               | 2 ++
 8 files changed, 16 insertions(+)
 create mode 100644 include/fir/.clang-format
 create mode 100644 include/flang/lower/.clang-format
 create mode 100644 include/flang/optimizer/.clang-format
 create mode 100644 lib/fir/.clang-format
 create mode 100644 lib/lower/.clang-format
 create mode 100644 lib/optimizer/.clang-format
 create mode 100644 tools/bbc/.clang-format
 create mode 100644 tools/tco/.clang-format

diff --git a/include/fir/.clang-format b/include/fir/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/include/fir/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/include/flang/lower/.clang-format b/include/flang/lower/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/include/flang/lower/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/include/flang/optimizer/.clang-format b/include/flang/optimizer/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/include/flang/optimizer/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/lib/fir/.clang-format b/lib/fir/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/lib/fir/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/lib/lower/.clang-format b/lib/lower/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/lib/lower/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/lib/optimizer/.clang-format b/lib/optimizer/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/lib/optimizer/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/tools/bbc/.clang-format b/tools/bbc/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/tools/bbc/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/tools/tco/.clang-format b/tools/tco/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/tools/tco/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes

From edb0943bca4b81689f320bda341040bf255d6e2e Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 28 Jan 2020 04:58:30 -0800
Subject: [PATCH 030/345] Add Pre-FIR Tree structure to help lowering the
 parse-tree

The Pre-FIR Tree structure is a transient data structure that
is meant to be built from the parse tree just before lowering to
FIR and that will be deleted just afterwards. It is not meant to perfrom
optimization analysis and transformations. It only provides temporary
information, such as label target information or parse tree parent nodes,
that is meant to be used to lower the parse tree structure into
FIR operations.
A PFTBuilder class builds the Pre-Fir Tree from the parse-tree.
A pretty printer is available to visualize this data structure.

- Lit tests are added to:
  1. that the PFT tree structure is as expected
  2. that the PFT captures all intented nodes

- Cmake changes: Prevent warnings inisde LLVM headers when compiling flang

The issue is that some LLVM headers  define functions where the usage of
the parameters depend on environment ifdef. See for instance Size in:
https://github.com/llvm/llvm-project/blob/5f940220bf9438e95ffa4a627ac1591be1e1ba6e/llvm/include/llvm/Support/Compiler.h#L574

Because flang is build with -Werror and -Wunused-parameter is default in
clang, this may breaks build in some environments (like with clang9 on macos).
A solution would be to add -Wno-unused-parameter to flang CmakLists.txt,
but it is wished to keep this warning on flang sources for quality purposes.
Fixing LLVM headers is not an easy task and `[[maybe_unused]]` is C++17 and
cannot be used yet in LLVM headers.
Hence, this fix simply silence warnings coming from LLVM headers by telling
CMake they are to be considered as if they were system headers.

- drone.io changes: remove llvm 6.0 from clang config in drone.io and link
flang with libstdc++ instead of libc++

llvm-dev resolved to llvm-6.0 in clang builds on drone.io. llvm 6.0 too old.
LLVM packages are linked with libstdc++ standard library whereas libc++ was
used for flang. This caused link time failure when building clang. Change
frone.io to build flang with libc++.

Note:
This commit does not reflect an actual work log, it is a feature based split of the
changes done in the FIR experimental branch. The related work log can be found in the
commits between:
864898cbe509d032abfe1172ec367dbd3dd92bc1
and
137c23da9c64cf90584cf81fd646053a69e91f63

Other changes come from https://github.com/flang-compiler/f18/pull/959 review.
---
 .drone.star                            |   4 +-
 CMakeLists.txt                         |   9 +-
 include/flang/lower/PFTBuilder.h       | 394 ++++++++++++++
 include/flang/parser/dump-parse-tree.h |   6 +-
 lib/CMakeLists.txt                     |   1 +
 lib/lower/CMakeLists.txt               |  13 +
 lib/lower/PFTBuilder.cpp               | 697 +++++++++++++++++++++++++
 test-lit/CMakeLists.txt                |   2 +
 test-lit/lit.cfg.py                    |   5 +-
 test-lit/lit.site.cfg.py.in            |   1 +
 test-lit/lower/pre-fir-tree01.f90      | 130 +++++
 test-lit/lower/pre-fir-tree02.f90      | 334 ++++++++++++
 test-lit/lower/pre-fir-tree03.f90      |  60 +++
 test-lit/lower/pre-fir-tree04.f90      |  70 +++
 tools/f18/CMakeLists.txt               |   2 +
 tools/f18/f18.cpp                      |  14 +
 16 files changed, 1735 insertions(+), 7 deletions(-)
 create mode 100644 include/flang/lower/PFTBuilder.h
 create mode 100644 lib/lower/CMakeLists.txt
 create mode 100644 lib/lower/PFTBuilder.cpp
 create mode 100644 test-lit/lower/pre-fir-tree01.f90
 create mode 100644 test-lit/lower/pre-fir-tree02.f90
 create mode 100644 test-lit/lower/pre-fir-tree03.f90
 create mode 100644 test-lit/lower/pre-fir-tree04.f90

diff --git a/.drone.star b/.drone.star
index 5911a5b15bc4..47dfca7c2460 100644
--- a/.drone.star
+++ b/.drone.star
@@ -7,9 +7,9 @@ def clang(arch):
                 "name": "test",
                 "image": "ubuntu",
                 "commands": [
-                    "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-dev libc++-8-dev libc++abi-8-dev libz-dev",
+                    "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-8-dev libc++-8-dev libc++abi-8-dev libz-dev",
                     "mkdir build && cd build",
-                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..',
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..',
                     "ninja -j8",
                     "ctest --output-on-failure -j24",
                 ],
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 999fd1f252c4..2b7a823f7ec3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -70,7 +70,14 @@ include(AddLLVM)
 #  https://stackoverflow.com/questions/41924375/llvm-how-to-specify-all-link-libraries-as-input-to-llvm-map-components-to-libna
 #  https://stackoverflow.com/questions/33948633/how-do-i-link-when-building-with-llvm-libraries
 
-include_directories(${LLVM_INCLUDE_DIRS})
+# Add LLVM include files as if they were SYSTEM because there are complex unused
+# parameter issues that may or may not appear depending on the environments and
+# compilers (ifdefs are involved). This allows warnings from LLVM headers to be
+# ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
+# This may have to be fine-tuned if flang headers are consider part of this
+# LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
+# should not be suppressed).
+include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
 add_definitions(${LLVM_DEFINITIONS})
 
 # LLVM_LIT_EXTERNAL store in cache so it could be used by AddLLVM.cmake
diff --git a/include/flang/lower/PFTBuilder.h b/include/flang/lower/PFTBuilder.h
new file mode 100644
index 000000000000..0b1345ef8bee
--- /dev/null
+++ b/include/flang/lower/PFTBuilder.h
@@ -0,0 +1,394 @@
+//===-- include/flang/lower/PFTBuilder.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_PFT_BUILDER_H_
+#define FORTRAN_LOWER_PFT_BUILDER_H_
+
+#include "flang/common/template.h"
+#include "flang/parser/parse-tree.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+
+/// Build a light-weight tree over the parse-tree to help with lowering to FIR.
+/// It is named Pre-FIR Tree (PFT) to underline it has no other usage than
+/// helping lowering to FIR.
+/// The PFT will capture pointers back into the parse tree, so the parse tree
+/// data structure may <em>not</em> be changed between the construction of the
+/// PFT and all of its uses.
+///
+/// The PFT captures a structured view of the program.  The program is a list of
+/// units.  Function like units will contain lists of evaluations.  Evaluations
+/// are either statements or constructs, where a construct contains a list of
+/// evaluations. The resulting PFT structure can then be used to create FIR.
+
+namespace Fortran::lower {
+namespace pft {
+
+struct Evaluation;
+struct Program;
+struct ModuleLikeUnit;
+struct FunctionLikeUnit;
+
+// TODO: A collection of Evaluations can obviously be any of the container
+// types; leaving this as a std::list _for now_ because we reserve the right to
+// insert PFT nodes in any order in O(1) time.
+using EvaluationCollection = std::list<Evaluation>;
+
+struct ParentType {
+  template <typename A>
+  ParentType(A &parent) : p{&parent} {}
+  const std::variant<Program *, ModuleLikeUnit *, FunctionLikeUnit *,
+                     Evaluation *>
+      p;
+};
+
+/// Flags to describe the impact of parse-trees nodes on the program
+/// control flow. These annotations to parse-tree nodes are later used to
+/// build the control flow graph when lowering to FIR.
+enum class CFGAnnotation {
+  None,            // Node does not impact control flow.
+  Goto,            // Node acts like a goto on the control flow.
+  CondGoto,        // Node acts like a conditional goto on the control flow.
+  IndGoto,         // Node acts like an indirect goto on the control flow.
+  IoSwitch,        // Node is an IO statement with ERR, END, or EOR specifier.
+  Switch,          // Node acts like a switch on the control flow.
+  Iterative,       // Node creates iterations in the control flow.
+  FirStructuredOp, // Node is a structured loop.
+  Return,          // Node triggers a return from the current procedure.
+  Terminate        // Node terminates the program.
+};
+
+/// Compiler-generated jump
+///
+/// This is used to convert implicit control-flow edges to explicit form in the
+/// decorated PFT
+struct CGJump {
+  CGJump(Evaluation &to) : target{to} {}
+  Evaluation &target;
+};
+
+/// Classify the parse-tree nodes from ExecutablePartConstruct
+
+using ActionStmts = std::tuple<
+    parser::AllocateStmt, parser::AssignmentStmt, parser::BackspaceStmt,
+    parser::CallStmt, parser::CloseStmt, parser::ContinueStmt,
+    parser::CycleStmt, parser::DeallocateStmt, parser::EndfileStmt,
+    parser::EventPostStmt, parser::EventWaitStmt, parser::ExitStmt,
+    parser::FailImageStmt, parser::FlushStmt, parser::FormTeamStmt,
+    parser::GotoStmt, parser::IfStmt, parser::InquireStmt, parser::LockStmt,
+    parser::NullifyStmt, parser::OpenStmt, parser::PointerAssignmentStmt,
+    parser::PrintStmt, parser::ReadStmt, parser::ReturnStmt, parser::RewindStmt,
+    parser::StopStmt, parser::SyncAllStmt, parser::SyncImagesStmt,
+    parser::SyncMemoryStmt, parser::SyncTeamStmt, parser::UnlockStmt,
+    parser::WaitStmt, parser::WhereStmt, parser::WriteStmt,
+    parser::ComputedGotoStmt, parser::ForallStmt, parser::ArithmeticIfStmt,
+    parser::AssignStmt, parser::AssignedGotoStmt, parser::PauseStmt>;
+
+using OtherStmts = std::tuple<parser::FormatStmt, parser::EntryStmt,
+                              parser::DataStmt, parser::NamelistStmt>;
+
+using Constructs =
+    std::tuple<parser::AssociateConstruct, parser::BlockConstruct,
+               parser::CaseConstruct, parser::ChangeTeamConstruct,
+               parser::CriticalConstruct, parser::DoConstruct,
+               parser::IfConstruct, parser::SelectRankConstruct,
+               parser::SelectTypeConstruct, parser::WhereConstruct,
+               parser::ForallConstruct, parser::CompilerDirective,
+               parser::OpenMPConstruct, parser::OmpEndLoopDirective>;
+
+using ConstructStmts = std::tuple<
+    parser::AssociateStmt, parser::EndAssociateStmt, parser::BlockStmt,
+    parser::EndBlockStmt, parser::SelectCaseStmt, parser::CaseStmt,
+    parser::EndSelectStmt, parser::ChangeTeamStmt, parser::EndChangeTeamStmt,
+    parser::CriticalStmt, parser::EndCriticalStmt, parser::NonLabelDoStmt,
+    parser::EndDoStmt, parser::IfThenStmt, parser::ElseIfStmt, parser::ElseStmt,
+    parser::EndIfStmt, parser::SelectRankStmt, parser::SelectRankCaseStmt,
+    parser::SelectTypeStmt, parser::TypeGuardStmt, parser::WhereConstructStmt,
+    parser::MaskedElsewhereStmt, parser::ElsewhereStmt, parser::EndWhereStmt,
+    parser::ForallConstructStmt, parser::EndForallStmt>;
+
+template <typename A>
+constexpr static bool isActionStmt{common::HasMember<A, ActionStmts>};
+
+template <typename A>
+constexpr static bool isConstruct{common::HasMember<A, Constructs>};
+
+template <typename A>
+constexpr static bool isConstructStmt{common::HasMember<A, ConstructStmts>};
+
+template <typename A>
+constexpr static bool isOtherStmt{common::HasMember<A, OtherStmts>};
+
+template <typename A>
+constexpr static bool isGenerated{std::is_same_v<A, CGJump>};
+
+template <typename A>
+constexpr static bool isFunctionLike{common::HasMember<
+    A, std::tuple<parser::MainProgram, parser::FunctionSubprogram,
+                  parser::SubroutineSubprogram,
+                  parser::SeparateModuleSubprogram>>};
+
+/// Function-like units can contains lists of evaluations.  These can be
+/// (simple) statements or constructs, where a construct contains its own
+/// evaluations.
+struct Evaluation {
+  using EvalTuple = common::CombineTuples<ActionStmts, OtherStmts, Constructs,
+                                          ConstructStmts>;
+
+  /// Hide non-nullable pointers to the parse-tree node.
+  template <typename A>
+  using MakeRefType = const A *const;
+  using EvalVariant =
+      common::CombineVariants<common::MapTemplate<MakeRefType, EvalTuple>,
+                              std::variant<CGJump>>;
+  template <typename A>
+  constexpr auto visit(A visitor) const {
+    return std::visit(common::visitors{
+                          [&](const auto *p) { return visitor(*p); },
+                          [&](auto &r) { return visitor(r); },
+                      },
+                      u);
+  }
+  template <typename A>
+  constexpr const A *getIf() const {
+    if constexpr (!std::is_same_v<A, CGJump>) {
+      if (auto *ptr{std::get_if<MakeRefType<A>>(&u)}) {
+        return *ptr;
+      }
+    } else {
+      return std::get_if<CGJump>(&u);
+    }
+    return nullptr;
+  }
+  template <typename A>
+  constexpr bool isA() const {
+    if constexpr (!std::is_same_v<A, CGJump>) {
+      return std::holds_alternative<MakeRefType<A>>(u);
+    }
+    return std::holds_alternative<CGJump>(u);
+  }
+
+  Evaluation() = delete;
+  Evaluation(const Evaluation &) = delete;
+  Evaluation(Evaluation &&) = default;
+
+  /// General ctor
+  template <typename A>
+  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &pos,
+             const std::optional<parser::Label> &lab)
+      : u{&a}, parent{p}, pos{pos}, lab{lab} {}
+
+  /// Compiler-generated jump
+  Evaluation(const CGJump &jump, const ParentType &p)
+      : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
+
+  /// Construct ctor
+  template <typename A>
+  Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
+    static_assert(pft::isConstruct<A>, "must be a construct");
+  }
+
+  constexpr bool isActionOrGenerated() const {
+    return visit(common::visitors{
+        [](auto &r) {
+          using T = std::decay_t<decltype(r)>;
+          return isActionStmt<T> || isGenerated<T>;
+        },
+    });
+  }
+
+  constexpr bool isStmt() const {
+    return visit(common::visitors{
+        [](auto &r) {
+          using T = std::decay_t<decltype(r)>;
+          static constexpr bool isStmt{isActionStmt<T> || isOtherStmt<T> ||
+                                       isConstructStmt<T>};
+          static_assert(!(isStmt && pft::isConstruct<T>),
+                        "statement classification is inconsistent");
+          return isStmt;
+        },
+    });
+  }
+  constexpr bool isConstruct() const { return !isStmt(); }
+
+  /// Set the type of originating control flow type for this evaluation.
+  void setCFG(CFGAnnotation a, Evaluation *cstr) {
+    cfg = a;
+    setBranches(cstr);
+  }
+
+  /// Is this evaluation a control-flow origin? (The PFT must be annotated)
+  bool isControlOrigin() const { return cfg != CFGAnnotation::None; }
+
+  /// Is this evaluation a control-flow target? (The PFT must be annotated)
+  bool isControlTarget() const { return isTarget; }
+
+  /// Set the containsBranches flag iff this evaluation (a construct) contains
+  /// control flow
+  void setBranches() { containsBranches = true; }
+
+  EvaluationCollection *getConstructEvals() {
+    auto *evals{subs.get()};
+    if (isStmt() && !evals) {
+      return nullptr;
+    }
+    if (isConstruct() && evals) {
+      return evals;
+    }
+    llvm_unreachable("evaluation subs is inconsistent");
+    return nullptr;
+  }
+
+  /// Set that the construct `cstr` (if not a nullptr) has branches.
+  static void setBranches(Evaluation *cstr) {
+    if (cstr)
+      cstr->setBranches();
+  }
+
+  EvalVariant u;
+  ParentType parent;
+  parser::CharBlock pos;
+  std::optional<parser::Label> lab;
+  std::unique_ptr<EvaluationCollection> subs; // construct sub-statements
+  CFGAnnotation cfg{CFGAnnotation::None};
+  bool isTarget{false};         // this evaluation is a control target
+  bool containsBranches{false}; // construct contains branches
+};
+
+/// A program is a list of program units.
+/// These units can be function like, module like, or block data
+struct ProgramUnit {
+  template <typename A>
+  ProgramUnit(const A &ptr, const ParentType &parent)
+      : p{&ptr}, parent{parent} {}
+  ProgramUnit(ProgramUnit &&) = default;
+  ProgramUnit(const ProgramUnit &) = delete;
+
+  const std::variant<
+      const parser::MainProgram *, const parser::FunctionSubprogram *,
+      const parser::SubroutineSubprogram *, const parser::Module *,
+      const parser::Submodule *, const parser::SeparateModuleSubprogram *,
+      const parser::BlockData *>
+      p;
+  ParentType parent;
+};
+
+/// Function-like units have similar structure. They all can contain executable
+/// statements as well as other function-like units (internal procedures and
+/// function statements).
+struct FunctionLikeUnit : public ProgramUnit {
+  // wrapper statements for function-like syntactic structures
+  using FunctionStatement =
+      std::variant<const parser::Statement<parser::ProgramStmt> *,
+                   const parser::Statement<parser::EndProgramStmt> *,
+                   const parser::Statement<parser::FunctionStmt> *,
+                   const parser::Statement<parser::EndFunctionStmt> *,
+                   const parser::Statement<parser::SubroutineStmt> *,
+                   const parser::Statement<parser::EndSubroutineStmt> *,
+                   const parser::Statement<parser::MpSubprogramStmt> *,
+                   const parser::Statement<parser::EndMpSubprogramStmt> *>;
+
+  FunctionLikeUnit(const parser::MainProgram &f, const ParentType &parent);
+  FunctionLikeUnit(const parser::FunctionSubprogram &f,
+                   const ParentType &parent);
+  FunctionLikeUnit(const parser::SubroutineSubprogram &f,
+                   const ParentType &parent);
+  FunctionLikeUnit(const parser::SeparateModuleSubprogram &f,
+                   const ParentType &parent);
+  FunctionLikeUnit(FunctionLikeUnit &&) = default;
+  FunctionLikeUnit(const FunctionLikeUnit &) = delete;
+
+  bool isMainProgram() {
+    return std::holds_alternative<
+        const parser::Statement<parser::EndProgramStmt> *>(endStmt);
+  }
+  const parser::FunctionStmt *getFunction() {
+    return getA<parser::FunctionStmt>();
+  }
+  const parser::SubroutineStmt *getSubroutine() {
+    return getA<parser::SubroutineStmt>();
+  }
+  const parser::MpSubprogramStmt *getMPSubp() {
+    return getA<parser::MpSubprogramStmt>();
+  }
+
+  /// Anonymous programs do not have a begin statement
+  std::optional<FunctionStatement> beginStmt;
+  FunctionStatement endStmt;
+  EvaluationCollection evals;        // statements
+  std::list<FunctionLikeUnit> funcs; // internal procedures
+
+private:
+  template <typename A>
+  const A *getA() {
+    if (beginStmt) {
+      if (auto p =
+              std::get_if<const parser::Statement<A> *>(&beginStmt.value()))
+        return &(*p)->statement;
+    }
+    return nullptr;
+  }
+};
+
+/// Module-like units have similar structure. They all can contain a list of
+/// function-like units.
+struct ModuleLikeUnit : public ProgramUnit {
+  // wrapper statements for module-like syntactic structures
+  using ModuleStatement =
+      std::variant<const parser::Statement<parser::ModuleStmt> *,
+                   const parser::Statement<parser::EndModuleStmt> *,
+                   const parser::Statement<parser::SubmoduleStmt> *,
+                   const parser::Statement<parser::EndSubmoduleStmt> *>;
+
+  ModuleLikeUnit(const parser::Module &m, const ParentType &parent);
+  ModuleLikeUnit(const parser::Submodule &m, const ParentType &parent);
+  ~ModuleLikeUnit() = default;
+  ModuleLikeUnit(ModuleLikeUnit &&) = default;
+  ModuleLikeUnit(const ModuleLikeUnit &) = delete;
+
+  ModuleStatement beginStmt;
+  ModuleStatement endStmt;
+  std::list<FunctionLikeUnit> funcs;
+};
+
+struct BlockDataUnit : public ProgramUnit {
+  BlockDataUnit(const parser::BlockData &bd, const ParentType &parent);
+  BlockDataUnit(BlockDataUnit &&) = default;
+  BlockDataUnit(const BlockDataUnit &) = delete;
+};
+
+/// A Program is the top-level PFT
+struct Program {
+  using Units = std::variant<FunctionLikeUnit, ModuleLikeUnit, BlockDataUnit>;
+
+  Program() = default;
+  Program(Program &&) = default;
+  Program(const Program &) = delete;
+
+  std::list<Units> &getUnits() { return units; }
+
+private:
+  std::list<Units> units;
+};
+
+} // namespace pft
+
+/// Create an PFT from the parse tree
+std::unique_ptr<pft::Program> createPFT(const parser::Program &root);
+
+/// Decorate the PFT with control flow annotations
+///
+/// The PFT must be decorated with control-flow annotations to prepare it for
+/// use in generating a CFG-like structure.
+void annotateControl(pft::Program &);
+
+void dumpPFT(llvm::raw_ostream &o, pft::Program &);
+
+} // namespace Fortran::lower
+
+#endif // FORTRAN_LOWER_PFT_BUILDER_H_
diff --git a/include/flang/parser/dump-parse-tree.h b/include/flang/parser/dump-parse-tree.h
index aca18137f955..a6181834c94f 100644
--- a/include/flang/parser/dump-parse-tree.h
+++ b/include/flang/parser/dump-parse-tree.h
@@ -40,11 +40,11 @@ class ParseTreeDumper {
       std::ostream &out, const AnalyzedObjectsAsFortran *asFortran = nullptr)
     : out_(out), asFortran_{asFortran} {}
 
-  constexpr const char *GetNodeName(const char *) { return "char *"; }
+  static constexpr const char *GetNodeName(const char *) { return "char *"; }
 #define NODE_NAME(T, N) \
-  constexpr const char *GetNodeName(const T &) { return N; }
+  static constexpr const char *GetNodeName(const T &) { return N; }
 #define NODE_ENUM(T, E) \
-  std::string GetNodeName(const T::E &x) { \
+  static std::string GetNodeName(const T::E &x) { \
     return #E " = "s + T::EnumToString(x); \
   }
 #define NODE(T1, T2) NODE_NAME(T1::T2, #T2)
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 343195bae2b0..35c3e139b1bf 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -9,5 +9,6 @@
 add_subdirectory(common)
 add_subdirectory(evaluate)
 add_subdirectory(decimal)
+add_subdirectory(lower)
 add_subdirectory(parser)
 add_subdirectory(semantics)
diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
new file mode 100644
index 000000000000..87131cd9fa53
--- /dev/null
+++ b/lib/lower/CMakeLists.txt
@@ -0,0 +1,13 @@
+add_library(FortranLower
+  PFTBuilder.cpp
+)
+
+target_link_libraries(FortranLower
+  LLVMSupport
+)
+
+install (TARGETS FortranLower
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+  RUNTIME DESTINATION bin
+)
diff --git a/lib/lower/PFTBuilder.cpp b/lib/lower/PFTBuilder.cpp
new file mode 100644
index 000000000000..d7998e259f78
--- /dev/null
+++ b/lib/lower/PFTBuilder.cpp
@@ -0,0 +1,697 @@
+//===-- lib/lower/PFTBuilder.cc -------------------------------------------===//
+//
+// 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/lower/PFTBuilder.h"
+#include "flang/parser/dump-parse-tree.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "llvm/ADT/DenseMap.h"
+#include <algorithm>
+#include <cassert>
+#include <utility>
+
+namespace Fortran::lower {
+namespace {
+
+/// Helpers to unveil parser node inside parser::Statement<>,
+/// parser::UnlabeledStatement, and common::Indirection<>
+template <typename A>
+struct RemoveIndirectionHelper {
+  using Type = A;
+  static constexpr const Type &unwrap(const A &a) { return a; }
+};
+template <typename A>
+struct RemoveIndirectionHelper<common::Indirection<A>> {
+  using Type = A;
+  static constexpr const Type &unwrap(const common::Indirection<A> &a) {
+    return a.value();
+  }
+};
+
+template <typename A>
+const auto &removeIndirection(const A &a) {
+  return RemoveIndirectionHelper<A>::unwrap(a);
+}
+
+template <typename A>
+struct UnwrapStmt {
+  static constexpr bool isStmt{false};
+};
+template <typename A>
+struct UnwrapStmt<parser::Statement<A>> {
+  static constexpr bool isStmt{true};
+  using Type = typename RemoveIndirectionHelper<A>::Type;
+  constexpr UnwrapStmt(const parser::Statement<A> &a)
+      : unwrapped{removeIndirection(a.statement)}, pos{a.source}, lab{a.label} {
+  }
+  const Type &unwrapped;
+  parser::CharBlock pos;
+  std::optional<parser::Label> lab;
+};
+template <typename A>
+struct UnwrapStmt<parser::UnlabeledStatement<A>> {
+  static constexpr bool isStmt{true};
+  using Type = typename RemoveIndirectionHelper<A>::Type;
+  constexpr UnwrapStmt(const parser::UnlabeledStatement<A> &a)
+      : unwrapped{removeIndirection(a.statement)}, pos{a.source} {}
+  const Type &unwrapped;
+  parser::CharBlock pos;
+  std::optional<parser::Label> lab;
+};
+
+/// The instantiation of a parse tree visitor (Pre and Post) is extremely
+/// expensive in terms of compile and link time, so one goal here is to limit
+/// the bridge to one such instantiation.
+class PFTBuilder {
+public:
+  PFTBuilder() : pgm{new pft::Program}, parents{*pgm.get()} {}
+
+  /// Get the result
+  std::unique_ptr<pft::Program> result() { return std::move(pgm); }
+
+  template <typename A>
+  constexpr bool Pre(const A &a) {
+    bool visit{true};
+    if constexpr (pft::isFunctionLike<A>) {
+      return enterFunc(a);
+    } else if constexpr (pft::isConstruct<A>) {
+      return enterConstruct(a);
+    } else if constexpr (UnwrapStmt<A>::isStmt) {
+      using T = typename UnwrapStmt<A>::Type;
+      // Node "a" being visited has one of the following types:
+      // Statement<T>, Statement<Indirection<T>, UnlabeledStatement<T>,
+      // or UnlabeledStatement<Indirection<T>>
+      auto stmt{UnwrapStmt<A>(a)};
+      if constexpr (pft::isConstructStmt<T> || pft::isOtherStmt<T>) {
+        addEval(pft::Evaluation{stmt.unwrapped, parents.back(), stmt.pos,
+                                stmt.lab});
+        visit = false;
+      } else if constexpr (std::is_same_v<T, parser::ActionStmt>) {
+        addEval(makeEvalAction(stmt.unwrapped, stmt.pos, stmt.lab));
+        visit = false;
+      }
+    }
+    return visit;
+  }
+
+  template <typename A>
+  constexpr void Post(const A &) {
+    if constexpr (pft::isFunctionLike<A>) {
+      exitFunc();
+    } else if constexpr (pft::isConstruct<A>) {
+      exitConstruct();
+    }
+  }
+
+  // Module like
+  bool Pre(const parser::Module &node) { return enterModule(node); }
+  bool Pre(const parser::Submodule &node) { return enterModule(node); }
+
+  void Post(const parser::Module &) { exitModule(); }
+  void Post(const parser::Submodule &) { exitModule(); }
+
+  // Block data
+  bool Pre(const parser::BlockData &node) {
+    addUnit(pft::BlockDataUnit{node, parents.back()});
+    return false;
+  }
+
+  // Get rid of production wrapper
+  bool Pre(const parser::UnlabeledStatement<parser::ForallAssignmentStmt>
+               &statement) {
+    addEval(std::visit(
+        [&](const auto &x) {
+          return pft::Evaluation{x, parents.back(), statement.source, {}};
+        },
+        statement.statement.u));
+    return false;
+  }
+  bool Pre(const parser::Statement<parser::ForallAssignmentStmt> &statement) {
+    addEval(std::visit(
+        [&](const auto &x) {
+          return pft::Evaluation{x, parents.back(), statement.source,
+                                 statement.label};
+        },
+        statement.statement.u));
+    return false;
+  }
+  bool Pre(const parser::WhereBodyConstruct &whereBody) {
+    return std::visit(
+        common::visitors{
+            [&](const parser::Statement<parser::AssignmentStmt> &stmt) {
+              // Not caught as other AssignmentStmt because it is not
+              // wrapped in a parser::ActionStmt.
+              addEval(pft::Evaluation{stmt.statement, parents.back(),
+                                      stmt.source, stmt.label});
+              return false;
+            },
+            [&](const auto &) { return true; },
+        },
+        whereBody.u);
+  }
+
+private:
+  // ActionStmt has a couple of non-conforming cases, which get handled
+  // explicitly here.  The other cases use an Indirection, which we discard in
+  // the PFT.
+  pft::Evaluation makeEvalAction(const parser::ActionStmt &statement,
+                                 parser::CharBlock pos,
+                                 std::optional<parser::Label> lab) {
+    return std::visit(
+        common::visitors{
+            [&](const auto &x) {
+              return pft::Evaluation{removeIndirection(x), parents.back(), pos,
+                                     lab};
+            },
+        },
+        statement.u);
+  }
+
+  // When we enter a function-like structure, we want to build a new unit and
+  // set the builder's cursors to point to it.
+  template <typename A>
+  bool enterFunc(const A &func) {
+    auto &unit = addFunc(pft::FunctionLikeUnit{func, parents.back()});
+    funclist = &unit.funcs;
+    pushEval(&unit.evals);
+    parents.emplace_back(unit);
+    return true;
+  }
+  /// Make funclist to point to current parent function list if it exists.
+  void setFunctListToParentFuncs() {
+    if (!parents.empty()) {
+      std::visit(common::visitors{
+                     [&](pft::FunctionLikeUnit *p) { funclist = &p->funcs; },
+                     [&](pft::ModuleLikeUnit *p) { funclist = &p->funcs; },
+                     [&](auto *) { funclist = nullptr; },
+                 },
+                 parents.back().p);
+    }
+  }
+
+  void exitFunc() {
+    popEval();
+    parents.pop_back();
+    setFunctListToParentFuncs();
+  }
+
+  // When we enter a construct structure, we want to build a new construct and
+  // set the builder's evaluation cursor to point to it.
+  template <typename A>
+  bool enterConstruct(const A &construct) {
+    auto &con = addEval(pft::Evaluation{construct, parents.back()});
+    con.subs.reset(new pft::EvaluationCollection);
+    pushEval(con.subs.get());
+    parents.emplace_back(con);
+    return true;
+  }
+
+  void exitConstruct() {
+    popEval();
+    parents.pop_back();
+  }
+
+  // When we enter a module structure, we want to build a new module and
+  // set the builder's function cursor to point to it.
+  template <typename A>
+  bool enterModule(const A &func) {
+    auto &unit = addUnit(pft::ModuleLikeUnit{func, parents.back()});
+    funclist = &unit.funcs;
+    parents.emplace_back(unit);
+    return true;
+  }
+
+  void exitModule() {
+    parents.pop_back();
+    setFunctListToParentFuncs();
+  }
+
+  template <typename A>
+  A &addUnit(A &&unit) {
+    pgm->getUnits().emplace_back(std::move(unit));
+    return std::get<A>(pgm->getUnits().back());
+  }
+
+  template <typename A>
+  A &addFunc(A &&func) {
+    if (funclist) {
+      funclist->emplace_back(std::move(func));
+      return funclist->back();
+    }
+    return addUnit(std::move(func));
+  }
+
+  /// move the Evaluation to the end of the current list
+  pft::Evaluation &addEval(pft::Evaluation &&eval) {
+    assert(funclist && "not in a function");
+    assert(evallist.size() > 0);
+    evallist.back()->emplace_back(std::move(eval));
+    return evallist.back()->back();
+  }
+
+  /// push a new list on the stack of Evaluation lists
+  void pushEval(pft::EvaluationCollection *eval) {
+    assert(funclist && "not in a function");
+    assert(eval && eval->empty() && "evaluation list isn't correct");
+    evallist.emplace_back(eval);
+  }
+
+  /// pop the current list and return to the last Evaluation list
+  void popEval() {
+    assert(funclist && "not in a function");
+    evallist.pop_back();
+  }
+
+  std::unique_ptr<pft::Program> pgm;
+  /// funclist points to FunctionLikeUnit::funcs list (resp.
+  /// ModuleLikeUnit::funcs) when building a FunctionLikeUnit (resp.
+  /// ModuleLikeUnit) to store internal procedures (resp. module procedures).
+  /// Otherwise (e.g. when building the top level Program), it is null.
+  std::list<pft::FunctionLikeUnit> *funclist{nullptr};
+  /// evallist is a stack of pointer to FunctionLikeUnit::evals (or
+  /// Evaluation::subs) that are being build.
+  std::vector<pft::EvaluationCollection *> evallist;
+  std::vector<pft::ParentType> parents;
+};
+
+template <typename Label, typename A>
+constexpr bool hasLabel(const A &stmt) {
+  auto isLabel{
+      [](const auto &v) { return std::holds_alternative<Label>(v.u); }};
+  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
+                std::is_same_v<A, parser::WriteStmt>) {
+    return std::any_of(std::begin(stmt.controls), std::end(stmt.controls),
+                       isLabel);
+  }
+  if constexpr (std::is_same_v<A, parser::WaitStmt>) {
+    return std::any_of(std::begin(stmt.v), std::end(stmt.v), isLabel);
+  }
+  if constexpr (std::is_same_v<Label, parser::ErrLabel>) {
+    if constexpr (common::HasMember<
+                      A, std::tuple<parser::OpenStmt, parser::CloseStmt,
+                                    parser::BackspaceStmt, parser::EndfileStmt,
+                                    parser::RewindStmt, parser::FlushStmt>>)
+      return std::any_of(std::begin(stmt.v), std::end(stmt.v), isLabel);
+    if constexpr (std::is_same_v<A, parser::InquireStmt>) {
+      const auto &specifiers{std::get<std::list<parser::InquireSpec>>(stmt.u)};
+      return std::any_of(std::begin(specifiers), std::end(specifiers), isLabel);
+    }
+  }
+  return false;
+}
+
+bool hasAltReturns(const parser::CallStmt &callStmt) {
+  const auto &args{std::get<std::list<parser::ActualArgSpec>>(callStmt.v.t)};
+  for (const auto &arg : args) {
+    const auto &actual{std::get<parser::ActualArg>(arg.t)};
+    if (std::holds_alternative<parser::AltReturnSpec>(actual.u))
+      return true;
+  }
+  return false;
+}
+
+/// Determine if `callStmt` has alternate returns and if so set `e` to be the
+/// origin of a switch-like control flow
+///
+/// \param cstr points to the current construct. It may be null at the top-level
+/// of a FunctionLikeUnit.
+void altRet(pft::Evaluation &evaluation, const parser::CallStmt &callStmt,
+            pft::Evaluation *cstr) {
+  if (hasAltReturns(callStmt))
+    evaluation.setCFG(pft::CFGAnnotation::Switch, cstr);
+}
+
+/// \param cstr points to the current construct. It may be null at the top-level
+/// of a FunctionLikeUnit.
+void annotateEvalListCFG(pft::EvaluationCollection &evaluationCollection,
+                         pft::Evaluation *cstr) {
+  bool nextIsTarget = false;
+  for (auto &eval : evaluationCollection) {
+    eval.isTarget = nextIsTarget;
+    nextIsTarget = false;
+    if (auto *subs{eval.getConstructEvals()}) {
+      annotateEvalListCFG(*subs, &eval);
+      // assume that the entry and exit are both possible branch targets
+      nextIsTarget = true;
+    }
+
+    if (eval.isActionOrGenerated() && eval.lab.has_value())
+      eval.isTarget = true;
+    eval.visit(common::visitors{
+        [&](const parser::CallStmt &statement) {
+          altRet(eval, statement, cstr);
+        },
+        [&](const parser::CycleStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+        },
+        [&](const parser::ExitStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+        },
+        [&](const parser::FailImageStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
+        },
+        [&](const parser::GotoStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+        },
+        [&](const parser::IfStmt &) {
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+        },
+        [&](const parser::ReturnStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Return, cstr);
+        },
+        [&](const parser::StopStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
+        },
+        [&](const parser::ArithmeticIfStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+        },
+        [&](const parser::AssignedGotoStmt &) {
+          eval.setCFG(pft::CFGAnnotation::IndGoto, cstr);
+        },
+        [&](const parser::ComputedGotoStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+        },
+        [&](const parser::WhereStmt &) {
+          // fir.loop + fir.where around the next stmt
+          eval.isTarget = true;
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+        },
+        [&](const parser::ForallStmt &) {
+          // fir.loop around the next stmt
+          eval.isTarget = true;
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+        },
+        [&](pft::CGJump &) { eval.setCFG(pft::CFGAnnotation::Goto, cstr); },
+        [&](const parser::SelectCaseStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+        },
+        [&](const parser::NonLabelDoStmt &) {
+          eval.isTarget = true;
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+        },
+        [&](const parser::EndDoStmt &) {
+          eval.isTarget = true;
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+        },
+        [&](const parser::IfThenStmt &) {
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+        },
+        [&](const parser::ElseIfStmt &) {
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+        },
+        [&](const parser::SelectRankStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+        },
+        [&](const parser::SelectTypeStmt &) {
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+        },
+        [&](const parser::WhereConstruct &) {
+          // mark the WHERE as if it were a DO loop
+          eval.isTarget = true;
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+        },
+        [&](const parser::WhereConstructStmt &) {
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+        },
+        [&](const parser::MaskedElsewhereStmt &) {
+          eval.isTarget = true;
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+        },
+        [&](const parser::ForallConstructStmt &) {
+          eval.isTarget = true;
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+        },
+
+        [&](const auto &stmt) {
+          // Handle statements with similar impact on control flow
+          using IoStmts = std::tuple<parser::BackspaceStmt, parser::CloseStmt,
+                                     parser::EndfileStmt, parser::FlushStmt,
+                                     parser::InquireStmt, parser::OpenStmt,
+                                     parser::ReadStmt, parser::RewindStmt,
+                                     parser::WaitStmt, parser::WriteStmt>;
+
+          using TargetStmts =
+              std::tuple<parser::EndAssociateStmt, parser::EndBlockStmt,
+                         parser::CaseStmt, parser::EndSelectStmt,
+                         parser::EndChangeTeamStmt, parser::EndCriticalStmt,
+                         parser::ElseStmt, parser::EndIfStmt,
+                         parser::SelectRankCaseStmt, parser::TypeGuardStmt,
+                         parser::ElsewhereStmt, parser::EndWhereStmt,
+                         parser::EndForallStmt>;
+
+          using DoNothingConstructStmts =
+              std::tuple<parser::BlockStmt, parser::AssociateStmt,
+                         parser::CriticalStmt, parser::ChangeTeamStmt>;
+
+          using A = std::decay_t<decltype(stmt)>;
+          if constexpr (common::HasMember<A, IoStmts>) {
+            if (hasLabel<parser::ErrLabel>(stmt) ||
+                hasLabel<parser::EorLabel>(stmt) ||
+                hasLabel<parser::EndLabel>(stmt))
+              eval.setCFG(pft::CFGAnnotation::IoSwitch, cstr);
+          } else if constexpr (common::HasMember<A, TargetStmts>) {
+            eval.isTarget = true;
+          } else if constexpr (common::HasMember<A, DoNothingConstructStmts>) {
+            // Explicitly do nothing for these construct statements
+          } else {
+            static_assert(!pft::isConstructStmt<A>,
+                          "All ConstructStmts impact on the control flow "
+                          "should be explicitly handled");
+          }
+          /* else do nothing */
+        },
+    });
+  }
+}
+
+/// Annotate the PFT with CFG source decorations (see CFGAnnotation) and mark
+/// potential branch targets
+inline void annotateFuncCFG(pft::FunctionLikeUnit &functionLikeUnit) {
+  annotateEvalListCFG(functionLikeUnit.evals, nullptr);
+  for (auto &internalFunc : functionLikeUnit.funcs)
+    annotateFuncCFG(internalFunc);
+}
+
+class PFTDumper {
+public:
+  void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
+    for (auto &unit : pft.getUnits()) {
+      std::visit(common::visitors{
+                     [&](pft::BlockDataUnit &unit) {
+                       outputStream << getNodeIndex(unit) << " ";
+                       outputStream << "BlockData: ";
+                       outputStream << "\nEndBlockData\n\n";
+                     },
+                     [&](pft::FunctionLikeUnit &func) {
+                       dumpFunctionLikeUnit(outputStream, func);
+                     },
+                     [&](pft::ModuleLikeUnit &unit) {
+                       dumpModuleLikeUnit(outputStream, unit);
+                     },
+                 },
+                 unit);
+    }
+    resetIndexes();
+  }
+
+  llvm::StringRef evalName(pft::Evaluation &eval) {
+    return eval.visit(common::visitors{
+        [](const pft::CGJump) { return "CGJump"; },
+        [](const auto &parseTreeNode) {
+          return parser::ParseTreeDumper::GetNodeName(parseTreeNode);
+        },
+    });
+  }
+
+  void dumpEvalList(llvm::raw_ostream &outputStream,
+                    pft::EvaluationCollection &evaluationCollection,
+                    int indent = 1) {
+    static const std::string white{"                                      ++"};
+    std::string indentString{white.substr(0, indent * 2)};
+    for (pft::Evaluation &eval : evaluationCollection) {
+      outputStream << indentString << getNodeIndex(eval) << " ";
+      llvm::StringRef name{evalName(eval)};
+      if (auto *subs{eval.getConstructEvals()}) {
+        outputStream << "<<" << name << ">>";
+        outputStream << "\n";
+        dumpEvalList(outputStream, *subs, indent + 1);
+        outputStream << indentString << "<<End" << name << ">>\n";
+      } else {
+        outputStream << name;
+        outputStream << ": " << eval.pos.ToString() + "\n";
+      }
+    }
+  }
+
+  void dumpFunctionLikeUnit(llvm::raw_ostream &outputStream,
+                            pft::FunctionLikeUnit &functionLikeUnit) {
+    outputStream << getNodeIndex(functionLikeUnit) << " ";
+    llvm::StringRef unitKind{};
+    std::string name{};
+    std::string header{};
+    if (functionLikeUnit.beginStmt) {
+      std::visit(
+          common::visitors{
+              [&](const parser::Statement<parser::ProgramStmt> *statement) {
+                unitKind = "Program";
+                name = statement->statement.v.ToString();
+              },
+              [&](const parser::Statement<parser::FunctionStmt> *statement) {
+                unitKind = "Function";
+                name =
+                    std::get<parser::Name>(statement->statement.t).ToString();
+                header = statement->source.ToString();
+              },
+              [&](const parser::Statement<parser::SubroutineStmt> *statement) {
+                unitKind = "Subroutine";
+                name =
+                    std::get<parser::Name>(statement->statement.t).ToString();
+                header = statement->source.ToString();
+              },
+              [&](const parser::Statement<parser::MpSubprogramStmt>
+                      *statement) {
+                unitKind = "MpSubprogram";
+                name = statement->statement.v.ToString();
+                header = statement->source.ToString();
+              },
+              [&](auto *) {},
+          },
+          *functionLikeUnit.beginStmt);
+    } else {
+      unitKind = "Program";
+      name = "<anonymous>";
+    }
+    outputStream << unitKind << ' ' << name;
+    if (header.size())
+      outputStream << ": " << header;
+    outputStream << '\n';
+    dumpEvalList(outputStream, functionLikeUnit.evals);
+    if (!functionLikeUnit.funcs.empty()) {
+      outputStream << "\nContains\n";
+      for (auto &func : functionLikeUnit.funcs)
+        dumpFunctionLikeUnit(outputStream, func);
+      outputStream << "EndContains\n";
+    }
+    outputStream << "End" << unitKind << ' ' << name << "\n\n";
+  }
+
+  void dumpModuleLikeUnit(llvm::raw_ostream &outputStream,
+                          pft::ModuleLikeUnit &moduleLikeUnit) {
+    outputStream << getNodeIndex(moduleLikeUnit) << " ";
+    outputStream << "ModuleLike: ";
+    outputStream << "\nContains\n";
+    for (auto &func : moduleLikeUnit.funcs)
+      dumpFunctionLikeUnit(outputStream, func);
+    outputStream << "EndContains\nEndModuleLike\n\n";
+  }
+
+  template <typename T>
+  std::size_t getNodeIndex(const T &node) {
+    auto addr{static_cast<const void *>(&node)};
+    auto it{nodeIndexes.find(addr)};
+    if (it != nodeIndexes.end()) {
+      return it->second;
+    }
+    nodeIndexes.try_emplace(addr, nextIndex);
+    return nextIndex++;
+  }
+  std::size_t getNodeIndex(const pft::Program &) { return 0; }
+
+  void resetIndexes() {
+    nodeIndexes.clear();
+    nextIndex = 1;
+  }
+
+private:
+  llvm::DenseMap<const void *, std::size_t> nodeIndexes;
+  std::size_t nextIndex{1}; // 0 is the root
+};
+
+template <typename A, typename T>
+pft::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
+  return pft::FunctionLikeUnit::FunctionStatement{
+      &std::get<parser::Statement<A>>(func.t)};
+}
+template <typename A, typename T>
+pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
+  return pft::ModuleLikeUnit::ModuleStatement{
+      &std::get<parser::Statement<A>>(mod.t)};
+}
+
+} // namespace
+
+pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
+                                        const pft::ParentType &parent)
+    : ProgramUnit{func, parent} {
+  auto &ps{
+      std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t)};
+  if (ps.has_value()) {
+    const parser::Statement<parser::ProgramStmt> &statement{ps.value()};
+    beginStmt = &statement;
+  }
+  endStmt = getFunctionStmt<parser::EndProgramStmt>(func);
+}
+
+pft::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,
+                                        const pft::ParentType &parent)
+    : ProgramUnit{func, parent},
+      beginStmt{getFunctionStmt<parser::FunctionStmt>(func)},
+      endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)} {}
+
+pft::FunctionLikeUnit::FunctionLikeUnit(
+    const parser::SubroutineSubprogram &func, const pft::ParentType &parent)
+    : ProgramUnit{func, parent},
+      beginStmt{getFunctionStmt<parser::SubroutineStmt>(func)},
+      endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)} {}
+
+pft::FunctionLikeUnit::FunctionLikeUnit(
+    const parser::SeparateModuleSubprogram &func, const pft::ParentType &parent)
+    : ProgramUnit{func, parent},
+      beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
+      endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {}
+
+pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Module &m,
+                                    const pft::ParentType &parent)
+    : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::ModuleStmt>(m)},
+      endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {}
+
+pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Submodule &m,
+                                    const pft::ParentType &parent)
+    : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::SubmoduleStmt>(
+                                  m)},
+      endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {}
+
+pft::BlockDataUnit::BlockDataUnit(const parser::BlockData &bd,
+                                  const pft::ParentType &parent)
+    : ProgramUnit{bd, parent} {}
+
+std::unique_ptr<pft::Program> createPFT(const parser::Program &root) {
+  PFTBuilder walker;
+  Walk(root, walker);
+  return walker.result();
+}
+
+void annotateControl(pft::Program &pft) {
+  for (auto &unit : pft.getUnits()) {
+    std::visit(common::visitors{
+                   [](pft::BlockDataUnit &) {},
+                   [](pft::FunctionLikeUnit &func) { annotateFuncCFG(func); },
+                   [](pft::ModuleLikeUnit &unit) {
+                     for (auto &func : unit.funcs)
+                       annotateFuncCFG(func);
+                   },
+               },
+               unit);
+  }
+}
+
+/// Dump a PFT.
+void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
+  PFTDumper{}.dumpPFT(outputStream, pft);
+}
+
+} // namespace Fortran::lower
diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index 0819e57b81f3..111814303b0b 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -1,6 +1,8 @@
 # Test runner infrastructure for Flang. This configures the Flang test trees
 # for use by Lit, and delegates to LLVM's lit test handlers.
 
+set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/tools/f18/include)
+
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
diff --git a/test-lit/lit.cfg.py b/test-lit/lit.cfg.py
index c27e6a616b85..3ca3c8ad23f7 100644
--- a/test-lit/lit.cfg.py
+++ b/test-lit/lit.cfg.py
@@ -61,9 +61,12 @@
 # to search to ensure that we get the tools just built and not some random
 # tools that might happen to be in the user's PATH.
 tool_dirs = [config.llvm_tools_dir, config.flang_tools_dir]
+flang_includes = "-I" + config.flang_intrinsic_modules_dir
 
 tools = [ToolSubst('%flang', command=FindTool('flang'), unresolved='fatal'),
-         ToolSubst('%f18', command=FindTool('f18'), unresolved='fatal')]
+         ToolSubst('%f18', command=FindTool('f18'), unresolved='fatal'),
+         ToolSubst('%f18_with_includes', command=FindTool('f18'),
+         extra_args=[flang_includes], unresolved='fatal')]
 
 llvm_config.add_tool_substitutions(tools, tool_dirs)
 
diff --git a/test-lit/lit.site.cfg.py.in b/test-lit/lit.site.cfg.py.in
index ad31bf1594f9..d00f3856fb41 100644
--- a/test-lit/lit.site.cfg.py.in
+++ b/test-lit/lit.site.cfg.py.in
@@ -6,6 +6,7 @@ config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
+config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 
 # Support substitution of the tools_dir with user parameters. This is
diff --git a/test-lit/lower/pre-fir-tree01.f90 b/test-lit/lower/pre-fir-tree01.f90
new file mode 100644
index 000000000000..97f15eea052e
--- /dev/null
+++ b/test-lit/lower/pre-fir-tree01.f90
@@ -0,0 +1,130 @@
+! RUN: %f18 -fdebug-pre-fir-tree -fparse-only %s | FileCheck %s
+
+! Test structure of the Pre-FIR tree
+
+! CHECK: Subroutine foo
+subroutine foo()
+  ! CHECK: <<DoConstruct>>
+  ! CHECK: NonLabelDoStmt
+  do i=1,5
+    ! CHECK: PrintStmt
+    print *, "hey"
+    ! CHECK: <<DoConstruct>>
+    ! CHECK: NonLabelDoStmt
+    do j=1,5
+      ! CHECK: PrintStmt
+      print *, "hello", i, j
+    ! CHECK: EndDoStmt
+    end do
+    ! CHECK: <<EndDoConstruct>>
+  ! CHECK: EndDoStmt
+  end do
+  ! CHECK: <<EndDoConstruct>>
+end subroutine
+! CHECK: EndSubroutine foo
+
+! CHECK: BlockData
+block data
+  integer, parameter :: n = 100
+  integer, dimension(n) :: a, b, c
+  common /arrays/ a, b, c
+end
+! CHECK: EndBlockData
+
+! CHECK: ModuleLike
+module test_mod
+interface
+  ! check specification parts are not part of the PFT.
+  ! CHECK-NOT: node
+  module subroutine dump()
+  end subroutine
+end interface
+ integer :: xdim
+ real, allocatable :: pressure(:)
+contains
+  ! CHECK: Subroutine foo
+  subroutine foo()
+    contains
+    ! CHECK: Subroutine subfoo
+    subroutine subfoo()
+    end subroutine
+    ! CHECK: EndSubroutine subfoo
+    ! CHECK: Function subfoo2
+    function subfoo2()
+    end function
+    ! CHECK: EndFunction subfoo2
+  end subroutine
+  ! CHECK: EndSubroutine foo
+
+  ! CHECK: Function foo2
+  function foo2(i, j)
+    integer i, j, foo2
+    ! CHECK: AssignmentStmt
+    foo2 = i + j
+    contains
+    ! CHECK: Subroutine subfoo
+    subroutine subfoo()
+    end subroutine
+    ! CHECK: EndSubroutine subfoo
+  end function
+  ! CHECK: EndFunction foo2
+end module
+! CHECK: EndModuleLike
+
+! CHECK: ModuleLike
+submodule (test_mod) test_mod_impl
+contains
+  ! CHECK: Subroutine foo
+  subroutine foo()
+    contains
+    ! CHECK: Subroutine subfoo
+    subroutine subfoo()
+    end subroutine
+    ! CHECK: EndSubroutine subfoo
+    ! CHECK: Function subfoo2
+    function subfoo2()
+    end function
+    ! CHECK: EndFunction subfoo2
+  end subroutine
+  ! CHECK: EndSubroutine foo
+  ! CHECK: MpSubprogram dump
+  module procedure dump
+    ! CHECK: FormatStmt
+11  format (2E16.4, I6)
+    ! CHECK: <<IfConstruct>>
+    ! CHECK: IfThenStmt
+    if (xdim > 100) then
+      ! CHECK: PrintStmt
+      print *, "test: ", xdim
+    ! CHECK: ElseStmt
+    else
+      ! CHECK: WriteStmt
+      write (*, 11) "test: ", xdim, pressure
+    ! CHECK: EndIfStmt
+    end if
+    ! CHECK: <<EndIfConstruct>>
+  end procedure
+end submodule
+! CHECK: EndModuleLike
+
+! CHECK: BlockData
+block data named_block
+ integer i, j, k
+ common /indexes/ i, j, k
+end
+! CHECK: EndBlockData
+
+! CHECK: Function bar
+function bar()
+end function
+! CHECK: EndFunction bar
+
+! CHECK: Program <anonymous>
+  ! check specification parts are not part of the PFT.
+  ! CHECK-NOT: node
+  use test_mod
+  real, allocatable :: x(:)
+  ! CHECK: AllocateStmt
+  allocate(x(foo2(10, 30)))
+end
+! CHECK: EndProgram
diff --git a/test-lit/lower/pre-fir-tree02.f90 b/test-lit/lower/pre-fir-tree02.f90
new file mode 100644
index 000000000000..ec9077a550a2
--- /dev/null
+++ b/test-lit/lower/pre-fir-tree02.f90
@@ -0,0 +1,334 @@
+! RUN: %f18 -fdebug-pre-fir-tree -fparse-only %s | FileCheck %s
+
+! Test Pre-FIR Tree captures all the intended nodes from the parse-tree
+! Coarray and OpenMP related nodes are tested in other files.
+
+! CHECK: Program test_prog
+program test_prog
+  ! Check specification part is not part of the tree.
+  interface
+    subroutine incr(i)
+      integer, intent(inout) :: i
+    end subroutine
+  end interface
+  integer :: i, j, k
+  real, allocatable, target :: x(:)
+  real :: y(100)
+  ! CHECK-NOT: node
+  ! CHECK: <<DoConstruct>>
+  ! CHECK: NonLabelDoStmt
+  do i=1,5
+    ! CHECK: PrintStmt
+    print *, "hey"
+    ! CHECK: <<DoConstruct>>
+    ! CHECK: NonLabelDoStmt
+    do j=1,5
+      ! CHECK: PrintStmt
+      print *, "hello", i, j
+    ! CHECK: EndDoStmt
+    end do
+    ! CHECK: <<EndDoConstruct>>
+  ! CHECK: EndDoStmt
+  end do
+  ! CHECK: <<EndDoConstruct>>
+
+  ! CHECK: <<AssociateConstruct>>
+  ! CHECK: AssociateStmt
+  associate (k => i + j)
+    ! CHECK: AllocateStmt
+    allocate(x(k))
+  ! CHECK: EndAssociateStmt
+  end associate
+  ! CHECK: <<EndAssociateConstruct>>
+
+  ! CHECK: <<BlockConstruct>>
+  ! CHECK: BlockStmt
+  block
+    integer :: k, l
+    real, pointer :: p(:)
+    ! CHECK: PointerAssignmentStmt
+    p => x
+    ! CHECK: AssignmentStmt
+    k = size(p)
+    ! CHECK: AssignmentStmt
+    l = 1
+    ! CHECK: <<CaseConstruct>>
+    ! CHECK: SelectCaseStmt
+    select case (k)
+      ! CHECK: CaseStmt
+      case (:0)
+        ! CHECK: NullifyStmt
+        nullify(p)
+      ! CHECK: CaseStmt
+      case (1)
+        ! CHECK: <<IfConstruct>>
+        ! CHECK: IfThenStmt
+        if (p(1)>0.) then
+          ! CHECK: PrintStmt
+          print *, "+"
+        ! CHECK: ElseIfStmt
+        else if (p(1)==0.) then
+          ! CHECK: PrintStmt
+          print *, "0."
+        ! CHECK: ElseStmt
+        else
+          ! CHECK: PrintStmt
+          print *, "-"
+        ! CHECK: EndIfStmt
+        end if
+        ! CHECK: <<EndIfConstruct>>
+        ! CHECK: CaseStmt
+      case (2:10)
+      ! CHECK: CaseStmt
+      case default
+        ! Note: label-do-loop are canonicalized into do constructs
+        ! CHECK: <<DoConstruct>>
+        ! CHECK: NonLabelDoStmt
+        do 22 while(l<=k)
+          ! CHECK: IfStmt
+          if (p(l)<0.) p(l)=cos(p(l))
+          ! CHECK: CallStmt
+22        call incr(l)
+        ! CHECK: EndDoStmt
+       ! CHECK: <<EndDoConstruct>>
+      ! CHECK: CaseStmt
+      case (100:)
+    ! CHECK: EndSelectStmt
+    end select
+  ! CHECK: <<EndCaseConstruct>>
+  ! CHECK: EndBlockStmt
+  end block
+  ! CHECK: <<EndBlockConstruct>>
+
+  ! CHECK-NOT: WhereConstruct
+  ! CHECK: WhereStmt
+  where (x > 1.) x = x/2.
+
+  ! CHECK: <<WhereConstruct>>
+  ! CHECK: WhereConstructStmt
+  where (x == 0.)
+    ! CHECK: AssignmentStmt
+    x = 0.01
+  ! CHECK: MaskedElsewhereStmt
+  elsewhere (x < 0.5)
+    ! CHECK: AssignmentStmt
+    x = x*2.
+    ! CHECK: <<WhereConstruct>>
+    where (y > 0.4)
+      ! CHECK: AssignmentStmt
+      y = y/2.
+    end where
+    ! CHECK: <<EndWhereConstruct>>
+  ! CHECK: ElsewhereStmt
+  elsewhere
+    ! CHECK: AssignmentStmt
+    x = x + 1.
+  ! CHECK: EndWhereStmt
+  end where
+  ! CHECK: <<EndWhereConstruct>>
+
+  ! CHECK-NOT: ForAllConstruct
+  ! CHECK: ForallStmt
+  forall (i = 1:5) x(i) = y(i)
+
+  ! CHECK: <<ForallConstruct>>
+  ! CHECK: ForallConstructStmt
+  forall (i = 1:5)
+    ! CHECK: AssignmentStmt
+    x(i) = x(i) + y(10*i)
+  ! CHECK: EndForallStmt
+  end forall
+  ! CHECK: <<EndForallConstruct>>
+
+  ! CHECK: DeallocateStmt
+  deallocate(x)
+end
+
+! CHECK: ModuleLike
+module test
+  type :: a_type
+    integer :: x
+  end type
+  type, extends(a_type) :: b_type
+    integer :: y
+  end type
+contains
+  ! CHECK: Function foo
+  function foo(x)
+    real x(..)
+    integer :: foo
+    ! CHECK: <<SelectRankConstruct>>
+    ! CHECK: SelectRankStmt
+    select rank(x)
+      ! CHECK: SelectRankCaseStmt
+      rank (0)
+        ! CHECK: AssignmentStmt
+        foo = 0
+      ! CHECK: SelectRankCaseStmt
+      rank (*)
+        ! CHECK: AssignmentStmt
+        foo = -1
+      ! CHECK: SelectRankCaseStmt
+      rank (1)
+        ! CHECK: AssignmentStmt
+        foo = 1
+      ! CHECK: SelectRankCaseStmt
+      rank default
+        ! CHECK: AssignmentStmt
+        foo = 2
+    ! CHECK: EndSelectStmt
+    end select
+    ! CHECK: <<EndSelectRankConstruct>>
+  end function
+
+  ! CHECK: Function bar
+  function bar(x)
+    class(*) :: x
+    ! CHECK: <<SelectTypeConstruct>>
+    ! CHECK: SelectTypeStmt
+    select type(x)
+      ! CHECK: TypeGuardStmt
+      type is (integer)
+        ! CHECK: AssignmentStmt
+        bar = 0
+      ! CHECK: TypeGuardStmt
+      class is (a_type)
+        ! CHECK: AssignmentStmt
+        bar = 1
+        ! CHECK: ReturnStmt
+        return
+      ! CHECK: TypeGuardStmt
+      class default
+        ! CHECK: AssignmentStmt
+        bar = -1
+    ! CHECK: EndSelectStmt
+    end select
+    ! CHECK: <<EndSelectTypeConstruct>>
+  end function
+
+  ! CHECK: Subroutine sub
+  subroutine sub(a)
+    real(4):: a
+    ! CompilerDirective
+    ! CHECK: <<CompilerDirective>>
+    !DIR$ IGNORE_TKR a
+  end subroutine
+
+
+end module
+
+! CHECK: Subroutine altreturn
+subroutine altreturn(i, j, *, *)
+  ! CHECK: <<IfConstruct>>
+  if (i>j) then
+    ! CHECK: ReturnStmt
+    return 1
+  else
+    ! CHECK: ReturnStmt
+    return 2
+  end if
+  ! CHECK: <<EndIfConstruct>>
+end subroutine
+
+
+! Remaining TODO
+
+! CHECK: Subroutine iostmts
+subroutine iostmts(filename, a, b, c)
+  character(*) :: filename
+  integer :: length
+  logical :: file_is_opened
+  real, a, b ,c
+  ! CHECK: InquireStmt
+  inquire(file=filename, opened=file_is_opened)
+  ! CHECK: <<IfConstruct>>
+  if (file_is_opened) then
+    ! CHECK: OpenStmt
+    open(10, FILE=filename)
+  end if
+  ! CHECK: <<EndIfConstruct>>
+  ! CHECK: ReadStmt
+  read(10, *) length
+  ! CHECK: RewindStmt
+  rewind 10
+  ! CHECK: NamelistStmt
+  namelist /nlist/ a, b, c
+  ! CHECK: WriteStmt
+  write(10, NML=nlist)
+  ! CHECK: BackspaceStmt
+  backspace(10)
+  ! CHECK: FormatStmt
+1 format (1PE12.4)
+  ! CHECK: WriteStmt
+  write (10, 1) a
+  ! CHECK: EndfileStmt
+  endfile 10
+  ! CHECK: FlushStmt
+  flush 10
+  ! CHECK: WaitStmt
+  wait(10)
+  ! CHECK: CloseStmt
+  close(10)
+end subroutine
+
+
+! CHECK: Subroutine sub2
+subroutine sub2()
+  integer :: i, j, k, l
+  i = 0
+1 j = i
+  ! CHECK: ContinueStmt
+2 continue
+  i = i+1
+3 j = j+1
+! CHECK: ArithmeticIfStmt
+  if (j-i) 3, 4, 5
+  ! CHECK: GotoStmt
+4  goto 6
+
+! FIXME: is name resolution on assigned goto broken/todo ?
+! WILLCHECK: AssignStmt
+!55 assign 6 to label
+! WILLCHECK: AssignedGotoStmt
+!66  go to label (5, 6)
+
+! CHECK: ComputedGotoStmt
+  go to (5, 6), 1 + mod(i, 2)
+5 j = j + 1
+6 i = i + j/2
+
+  ! CHECK: <<DoConstruct>>
+  do1: do k=1,10
+    ! CHECK: <<DoConstruct>>
+    do2: do l=5,20
+      ! CHECK: CycleStmt
+      cycle do1
+      ! CHECK: ExitStmt
+      exit do2
+    end do do2
+    ! CHECK: <<EndDoConstruct>>
+  end do do1
+  ! CHECK: <<EndDoConstruct>>
+
+  ! CHECK: PauseStmt
+  pause 7
+  ! CHECK: StopStmt
+  stop
+end subroutine
+
+
+! CHECK: Subroutine sub3
+subroutine sub3()
+ print *, "normal"
+  ! CHECK: EntryStmt
+ entry sub4entry()
+ print *, "test"
+end subroutine
+
+! CHECK: Subroutine sub4
+subroutine sub4(i, j)
+  integer :: i
+  print*, "test"
+  ! CHECK: DataStmt
+  data i /1/
+end subroutine
diff --git a/test-lit/lower/pre-fir-tree03.f90 b/test-lit/lower/pre-fir-tree03.f90
new file mode 100644
index 000000000000..2eedfe7610ce
--- /dev/null
+++ b/test-lit/lower/pre-fir-tree03.f90
@@ -0,0 +1,60 @@
+! RUN: %f18 -fdebug-pre-fir-tree -fparse-only -fopenmp %s | FileCheck %s
+
+! Test Pre-FIR Tree captures OpenMP related constructs
+
+! CHECK: Program test_omp
+program test_omp
+  ! CHECK: PrintStmt
+  print *, "sequential"
+
+  ! CHECK: <<OpenMPConstruct>>
+  !$omp parallel
+    ! CHECK: PrintStmt
+    print *, "in omp //"
+    ! CHECK: <<OpenMPConstruct>>
+    !$omp do
+    ! CHECK: <<DoConstruct>>
+    ! CHECK: LabelDoStmt
+    do i=1,100
+      ! CHECK: PrintStmt
+      print *, "in omp do"
+    ! CHECK: EndDoStmt
+    end do
+    ! CHECK: <<EndDoConstruct>>
+    ! CHECK: OmpEndLoopDirective
+    !$omp end do
+    ! CHECK: <<EndOpenMPConstruct>>
+
+    ! CHECK: PrintStmt
+    print *, "not in omp do"
+
+    ! CHECK: <<OpenMPConstruct>>
+    !$omp do
+    ! CHECK: <<DoConstruct>>
+    ! CHECK: LabelDoStmt
+    do i=1,100
+      ! CHECK: PrintStmt
+      print *, "in omp do"
+    ! CHECK: EndDoStmt
+    end do
+    ! CHECK: <<EndDoConstruct>>
+    ! CHECK: <<EndOpenMPConstruct>>
+    ! CHECK-NOT: OmpEndLoopDirective
+    ! CHECK: PrintStmt
+    print *, "no in omp do"
+  !$omp end parallel
+    ! CHECK: <<EndOpenMPConstruct>>
+
+  ! CHECK: PrintStmt
+  print *, "sequential again"
+
+  ! CHECK: <<OpenMPConstruct>>
+  !$omp task
+    ! CHECK: PrintStmt
+    print *, "in task"
+  !$omp end task
+  ! CHECK: <<EndOpenMPConstruct>>
+
+  ! CHECK: PrintStmt
+  print *, "sequential again"
+end program
diff --git a/test-lit/lower/pre-fir-tree04.f90 b/test-lit/lower/pre-fir-tree04.f90
new file mode 100644
index 000000000000..3e8516e57bbb
--- /dev/null
+++ b/test-lit/lower/pre-fir-tree04.f90
@@ -0,0 +1,70 @@
+! RUN: %f18_with_includes -fdebug-pre-fir-tree -fparse-only %s | FileCheck %s
+
+! Test Pre-FIR Tree captures all the coarray related statements
+
+! CHECK: Subroutine test_coarray
+Subroutine test_coarray
+  use iso_fortran_env, only: team_type, event_type, lock_type
+  type(team_type) :: t
+  type(event_type) :: done
+  type(lock_type) :: alock
+  real :: y[10,*]
+  integer :: counter[*]
+  logical :: is_master
+  ! CHECK: <<ChangeTeamConstruct>>
+  change team(t, x[5,*] => y)
+    ! CHECK: AssignmentStmt
+    x = x[4, 1]
+  end team
+  ! CHECK: <<EndChangeTeamConstruct>>
+  ! CHECK: FormTeamStmt
+  form team(1, t)
+
+  ! CHECK: <<IfConstruct>>
+  if (this_image() == 1) then
+    ! CHECK: EventPostStmt
+    event post (done)
+  else
+    ! CHECK: EventWaitStmt
+    event wait (done)
+  end if
+  ! CHECK: <<EndIfConstruct>>
+
+  ! CHECK: <<CriticalConstruct>>
+  critical
+    ! CHECK: AssignmentStmt
+    counter[1] = counter[1] + 1
+  end critical
+  ! CHECK: <<EndCriticalConstruct>>
+
+  ! CHECK: LockStmt
+  lock(alock)
+  ! CHECK: PrintStmt
+  print *, "I have the lock"
+  ! CHECK: UnlockStmt
+  unlock(alock)
+
+  ! CHECK: SyncAllStmt
+  sync all
+  ! CHECK: SyncMemoryStmt
+  sync memory
+  ! CHECK: SyncTeamStmt
+  sync team(t)
+
+  ! CHECK: <<IfConstruct>>
+  if (this_image() == 1) then
+    ! CHECK: SyncImagesStmt
+    sync images(*)
+  else
+    ! CHECK: SyncImagesStmt
+    sync images(1)
+  end if
+  ! CHECK: <<EndIfConstruct>>
+
+  ! CHECK: <<IfConstruct>>
+  if (y<0.) then
+    ! CHECK: FailImageStmt
+   fail image
+  end if
+  ! CHECK: <<EndIfConstruct>>
+end
diff --git a/tools/f18/CMakeLists.txt b/tools/f18/CMakeLists.txt
index 676549c95cf4..79f5c52d6a6c 100644
--- a/tools/f18/CMakeLists.txt
+++ b/tools/f18/CMakeLists.txt
@@ -18,6 +18,8 @@ target_link_libraries(f18
   FortranParser
   FortranEvaluate
   FortranSemantics
+  LLVMSupport
+  FortranLower
 )
 
 add_executable(f18-parse-demo
diff --git a/tools/f18/f18.cpp b/tools/f18/f18.cpp
index 56f008ba6fe1..b54d1a9e2d11 100644
--- a/tools/f18/f18.cpp
+++ b/tools/f18/f18.cpp
@@ -11,6 +11,7 @@
 #include "flang/common/Fortran-features.h"
 #include "flang/common/default-kinds.h"
 #include "flang/evaluate/expression.h"
+#include "flang/lower/PFTBuilder.h"
 #include "flang/parser/characters.h"
 #include "flang/parser/dump-parse-tree.h"
 #include "flang/parser/message.h"
@@ -22,6 +23,7 @@
 #include "flang/semantics/expression.h"
 #include "flang/semantics/semantics.h"
 #include "flang/semantics/unparse-with-symbols.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cerrno>
 #include <cstdio>
 #include <cstring>
@@ -92,6 +94,7 @@ struct DriverOptions {
   bool dumpUnparse{false};
   bool dumpUnparseWithSymbols{false};
   bool dumpParseTree{false};
+  bool dumpPreFirTree{false};
   bool dumpSymbols{false};
   bool debugResolveNames{false};
   bool debugNoSemantics{false};
@@ -308,6 +311,15 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
         nullptr /* action before each statement */, &asFortran);
     return {};
   }
+  if (driver.dumpPreFirTree) {
+    if (auto ast{Fortran::lower::createPFT(parseTree)}) {
+      Fortran::lower::annotateControl(*ast);
+      Fortran::lower::dumpPFT(llvm::outs(), *ast);
+    } else {
+      std::cerr << "Pre FIR Tree is NULL.\n";
+      exitStatus = EXIT_FAILURE;
+    }
+  }
   if (driver.parseOnly) {
     return {};
   }
@@ -475,6 +487,8 @@ int main(int argc, char *const argv[]) {
       options.needProvenanceRangeToCharBlockMappings = true;
     } else if (arg == "-fdebug-dump-parse-tree") {
       driver.dumpParseTree = true;
+    } else if (arg == "-fdebug-pre-fir-tree") {
+      driver.dumpPreFirTree = true;
     } else if (arg == "-fdebug-dump-symbols") {
       driver.dumpSymbols = true;
     } else if (arg == "-fdebug-resolve-names") {

From fb87d16a868112e26ade0ad696b2232d8cf3a524 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 18 Feb 2020 15:20:28 -0800
Subject: [PATCH 031/345] Reorganize evaluate::Assignment

Every analyzed assignment represented by `evaluate::Assignment` has
a LHS and RHS expression. These need to be checked uniformly in various
places. So change Assignment always to have those data members, with
the variant determining which kinds of assignment it is: intrinsic,
user-defined, or pointer.
---
 include/flang/evaluate/expression.h  | 34 +++++++---------
 lib/evaluate/expression.cpp          | 59 ++++++++++++----------------
 lib/semantics/assignment.cpp         | 48 ++++++++++------------
 lib/semantics/expression.cpp         | 57 +++++++++++++--------------
 lib/semantics/pointer-assignment.cpp | 14 ++++---
 lib/semantics/pointer-assignment.h   |  4 +-
 6 files changed, 99 insertions(+), 117 deletions(-)

diff --git a/include/flang/evaluate/expression.h b/include/flang/evaluate/expression.h
index b06119107ef8..019858a6e3da 100644
--- a/include/flang/evaluate/expression.h
+++ b/include/flang/evaluate/expression.h
@@ -811,28 +811,24 @@ template<> class Expr<SomeType> : public ExpressionBase<SomeType> {
   common::CombineVariants<TypelessExpression, CategoryExpression> u;
 };
 
-// An assignment is either intrinsic (with lhs and rhs) or user-defined,
-// represented as a ProcedureRef. A pointer assignment optionally also has
-// a bounds-spec or bounds-remapping.
+// An assignment is either intrinsic, user-defined (with a ProcedureRef to
+// specify the procedure to call), or pointer assignment (with possibly empty
+// BoundsSpec or non-empty BoundsRemapping). In all cases there are Exprs
+// representing the LHS and RHS of the assignment.
 class Assignment {
 public:
-  UNION_CONSTRUCTORS(Assignment)
-  struct IntrinsicAssignment {
-    Expr<SomeType> lhs;
-    Expr<SomeType> rhs;
-  };
-  struct PointerAssignment {
-    using BoundsSpec = std::vector<Expr<SubscriptInteger>>;
-    using BoundsRemapping =
-        std::vector<std::pair<Expr<SubscriptInteger>, Expr<SubscriptInteger>>>;
-    PointerAssignment(Expr<SomeType> &&lhs, Expr<SomeType> &&rhs)
-      : lhs{std::move(lhs)}, rhs{std::move(rhs)} {}
-    Expr<SomeType> lhs;
-    Expr<SomeType> rhs;
-    std::variant<BoundsSpec, BoundsRemapping> bounds;
-  };
+  Assignment(Expr<SomeType> &&lhs, Expr<SomeType> &&rhs)
+    : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
+
+  struct Intrinsic {};
+  using BoundsSpec = std::vector<Expr<SubscriptInteger>>;
+  using BoundsRemapping =
+      std::vector<std::pair<Expr<SubscriptInteger>, Expr<SubscriptInteger>>>;
   std::ostream &AsFortran(std::ostream &) const;
-  std::variant<IntrinsicAssignment, ProcedureRef, PointerAssignment> u;
+
+  Expr<SomeType> lhs;
+  Expr<SomeType> rhs;
+  std::variant<Intrinsic, ProcedureRef, BoundsSpec, BoundsRemapping> u;
 };
 
 // This wrapper class is used, by means of a forward reference with
diff --git a/lib/evaluate/expression.cpp b/lib/evaluate/expression.cpp
index fbf20daba7af..c80599670f9e 100644
--- a/lib/evaluate/expression.cpp
+++ b/lib/evaluate/expression.cpp
@@ -168,40 +168,33 @@ GenericExprWrapper::~GenericExprWrapper() {}
 std::ostream &Assignment::AsFortran(std::ostream &o) const {
   std::visit(
       common::visitors{
-          [&](const evaluate::Assignment::IntrinsicAssignment &x) {
-            x.rhs.AsFortran(x.lhs.AsFortran(o) << '=');
+          [&](const Assignment::Intrinsic &) {
+            rhs.AsFortran(lhs.AsFortran(o) << '=');
           },
-          [&](const evaluate::ProcedureRef &x) { x.AsFortran(o << "CALL "); },
-          [&](const evaluate::Assignment::PointerAssignment &x) {
-            x.lhs.AsFortran(o);
-            std::visit(
-                common::visitors{
-                    [&](const evaluate::Assignment::PointerAssignment::
-                            BoundsSpec &bounds) {
-                      if (!bounds.empty()) {
-                        char sep{'('};
-                        for (const auto &bound : bounds) {
-                          bound.AsFortran(o << sep) << ':';
-                          sep = ',';
-                        }
-                        o << ')';
-                      }
-                    },
-                    [&](const evaluate::Assignment::PointerAssignment::
-                            BoundsRemapping &bounds) {
-                      if (!bounds.empty()) {
-                        char sep{'('};
-                        for (const auto &bound : bounds) {
-                          bound.first.AsFortran(o << sep) << ':';
-                          bound.second.AsFortran(o);
-                          sep = ',';
-                        }
-                        o << ')';
-                      }
-                    },
-                },
-                x.bounds);
-            x.rhs.AsFortran(o << " => ");
+          [&](const ProcedureRef &proc) { proc.AsFortran(o << "CALL "); },
+          [&](const BoundsSpec &bounds) {
+            lhs.AsFortran(o);
+            if (!bounds.empty()) {
+              char sep{'('};
+              for (const auto &bound : bounds) {
+                bound.AsFortran(o << sep) << ':';
+                sep = ',';
+              }
+              o << ')';
+            }
+          },
+          [&](const BoundsRemapping &bounds) {
+            lhs.AsFortran(o);
+            if (!bounds.empty()) {
+              char sep{'('};
+              for (const auto &bound : bounds) {
+                bound.first.AsFortran(o << sep) << ':';
+                bound.second.AsFortran(o);
+                sep = ',';
+              }
+              o << ')';
+            }
+            rhs.AsFortran(o << " => ");
           },
       },
       u);
diff --git a/lib/semantics/assignment.cpp b/lib/semantics/assignment.cpp
index 362df0465480..cb727efb2b66 100644
--- a/lib/semantics/assignment.cpp
+++ b/lib/semantics/assignment.cpp
@@ -141,50 +141,44 @@ class AssignmentContext {
 void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
   // Assignment statement analysis is in expression.cpp where user-defined
   // assignments can be recognized and replaced.
-  if (const evaluate::Assignment * asst{GetAssignment(stmt)}) {
-    if (const auto *intrinsicAsst{
-            std::get_if<evaluate::Assignment::IntrinsicAssignment>(&asst->u)}) {
-      CheckForImpureCall(intrinsicAsst->lhs);
-      CheckForImpureCall(intrinsicAsst->rhs);
-      if (forall_) {
-        // TODO: Warn if some name in forall_->activeNames or its outer
-        // contexts does not appear on LHS
-      }
-      CheckForPureContext(intrinsicAsst->lhs, intrinsicAsst->rhs,
-          std::get<parser::Expr>(stmt.t).source, false /* not => */);
+  if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
+    CheckForImpureCall(assignment->lhs);
+    CheckForImpureCall(assignment->rhs);
+    if (forall_) {
+      // TODO: Warn if some name in forall_->activeNames or its outer
+      // contexts does not appear on LHS
     }
+    CheckForPureContext(assignment->lhs, assignment->rhs,
+        std::get<parser::Expr>(stmt.t).source, false /* not => */);
   }
   // TODO: Fortran 2003 ALLOCATABLE assignment semantics (automatic
   // (re)allocation of LHS array when unallocated or nonconformable)
 }
 
 void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
-  using PointerAssignment = evaluate::Assignment::PointerAssignment;
   CHECK(!where_);
-  const evaluate::Assignment *assign{GetAssignment(stmt)};
-  if (!assign) {
+  const evaluate::Assignment *assignment{GetAssignment(stmt)};
+  if (!assignment) {
     return;
   }
-  const auto &ptrAssign{std::get<PointerAssignment>(assign->u)};
-  const SomeExpr &lhs{ptrAssign.lhs};
-  const SomeExpr &rhs{ptrAssign.rhs};
+  const SomeExpr &lhs{assignment->lhs};
+  const SomeExpr &rhs{assignment->rhs};
   CheckForImpureCall(lhs);
   CheckForImpureCall(rhs);
   std::visit(
-      common::visitors{
-          [&](const PointerAssignment::BoundsSpec &bounds) {
-            for (const auto &bound : bounds) {
-              CheckForImpureCall(SomeExpr{bound});
-            }
-          },
-          [&](const PointerAssignment::BoundsRemapping &bounds) {
+      common::visitors{[&](const evaluate::Assignment::BoundsSpec &bounds) {
+                         for (const auto &bound : bounds) {
+                           CheckForImpureCall(SomeExpr{bound});
+                         }
+                       },
+          [&](const evaluate::Assignment::BoundsRemapping &bounds) {
             for (const auto &bound : bounds) {
               CheckForImpureCall(SomeExpr{bound.first});
               CheckForImpureCall(SomeExpr{bound.second});
             }
           },
-      },
-      ptrAssign.bounds);
+          [](const auto &) { DIE("not valid for pointer assignment"); }},
+      assignment->u);
   if (forall_) {
     // TODO: Warn if some name in forall_->activeNames or its outer
     // contexts does not appear on LHS
@@ -193,7 +187,7 @@ void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
       true /* isPointerAssignment */);
   auto restorer{context_.foldingContext().messages().SetLocation(
       context_.location().value())};
-  CheckPointerAssignment(context_.foldingContext(), ptrAssign);
+  CheckPointerAssignment(context_.foldingContext(), *assignment);
 }
 
 void AssignmentContext::Analyze(const parser::WhereStmt &stmt) {
diff --git a/lib/semantics/expression.cpp b/lib/semantics/expression.cpp
index 59593ae90e8f..3aa03893290e 100644
--- a/lib/semantics/expression.cpp
+++ b/lib/semantics/expression.cpp
@@ -1919,10 +1919,13 @@ const Assignment *ExpressionAnalyzer::Analyze(const parser::AssignmentStmt &x) {
       x.typedAssignment.reset(new GenericAssignmentWrapper{});
     } else {
       std::optional<ProcedureRef> procRef{analyzer.TryDefinedAssignment()};
-      x.typedAssignment.reset(new GenericAssignmentWrapper{procRef
-              ? Assignment{std::move(*procRef)}
-              : Assignment{Assignment::IntrinsicAssignment{
-                    Fold(analyzer.MoveExpr(0)), Fold(analyzer.MoveExpr(1))}}});
+      Assignment assignment{
+          Fold(analyzer.MoveExpr(0)), Fold(analyzer.MoveExpr(1))};
+      if (procRef) {
+        assignment.u = std::move(*procRef);
+      }
+      x.typedAssignment.reset(
+          new GenericAssignmentWrapper{std::move(assignment)});
     }
   }
   return common::GetPtrFromOptional(x.typedAssignment->v);
@@ -1933,12 +1936,14 @@ const Assignment *ExpressionAnalyzer::Analyze(
   if (!x.typedAssignment) {
     MaybeExpr lhs{Analyze(std::get<parser::DataRef>(x.t))};
     MaybeExpr rhs{Analyze(std::get<parser::Expr>(x.t))};
-    decltype(Assignment::PointerAssignment::bounds) pointerBounds;
-    std::visit(
-        common::visitors{
-            [&](const std::list<parser::BoundsRemapping> &list) {
-              if (!list.empty()) {
-                Assignment::PointerAssignment::BoundsRemapping bounds;
+    if (!lhs || !rhs) {
+      x.typedAssignment.reset(new GenericAssignmentWrapper{});
+    } else {
+      Assignment assignment{std::move(*lhs), std::move(*rhs)};
+      std::visit(
+          common::visitors{
+              [&](const std::list<parser::BoundsRemapping> &list) {
+                Assignment::BoundsRemapping bounds;
                 for (const auto &elem : list) {
                   auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
                   auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
@@ -1947,30 +1952,21 @@ const Assignment *ExpressionAnalyzer::Analyze(
                         Fold(std::move(*lower)), Fold(std::move(*upper)));
                   }
                 }
-                pointerBounds = bounds;
-              }
-            },
-            [&](const std::list<parser::BoundsSpec> &list) {
-              if (!list.empty()) {
-                Assignment::PointerAssignment::BoundsSpec bounds;
+                assignment.u = std::move(bounds);
+              },
+              [&](const std::list<parser::BoundsSpec> &list) {
+                Assignment::BoundsSpec bounds;
                 for (const auto &bound : list) {
                   if (auto lower{AsSubscript(Analyze(bound.v))}) {
                     bounds.emplace_back(Fold(std::move(*lower)));
                   }
                 }
-                pointerBounds = bounds;
-              }
-            },
-        },
-        std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
-    if (!lhs || !rhs) {
-      x.typedAssignment.reset(new GenericAssignmentWrapper{});
-    } else {
-      Assignment::PointerAssignment assignment{
-          Fold(std::move(*lhs)), Fold(std::move(*rhs))};
-      assignment.bounds = pointerBounds;
+                assignment.u = std::move(bounds);
+              },
+          },
+          std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
       x.typedAssignment.reset(
-          new GenericAssignmentWrapper{Assignment{std::move(assignment)}});
+          new GenericAssignmentWrapper{std::move(assignment)});
     }
   }
   return common::GetPtrFromOptional(x.typedAssignment->v);
@@ -2784,8 +2780,9 @@ std::optional<ProcedureRef> ArgumentAnalyzer::GetDefinedAssignmentProc() {
     }
   }
   if (proc) {
-    actuals_[1]->Parenthesize();
-    return ProcedureRef{ProcedureDesignator{*proc}, std::move(actuals_)};
+    ActualArguments actualsCopy{actuals_};
+    actualsCopy[1]->Parenthesize();
+    return ProcedureRef{ProcedureDesignator{*proc}, std::move(actualsCopy)};
   } else {
     return std::nullopt;
   }
diff --git a/lib/semantics/pointer-assignment.cpp b/lib/semantics/pointer-assignment.cpp
index 8e111eff4061..d3b3ec7f76ad 100644
--- a/lib/semantics/pointer-assignment.cpp
+++ b/lib/semantics/pointer-assignment.cpp
@@ -35,7 +35,6 @@ using evaluate::characteristics::Procedure;
 using evaluate::characteristics::TypeAndShape;
 using parser::MessageFixedText;
 using parser::MessageFormattedText;
-using PointerAssignment = evaluate::Assignment::PointerAssignment;
 
 class PointerAssignmentChecker {
 public:
@@ -348,17 +347,17 @@ parser::Message *PointerAssignmentChecker::Say(A &&... x) {
 // Verify that any bounds on the LHS of a pointer assignment are valid.
 // Return true if it is a bound-remapping so we can perform further checks.
 static bool CheckPointerBounds(
-    evaluate::FoldingContext &context, const PointerAssignment &assignment) {
+    evaluate::FoldingContext &context, const evaluate::Assignment &assignment) {
   auto &messages{context.messages()};
   const SomeExpr &lhs{assignment.lhs};
   const SomeExpr &rhs{assignment.rhs};
   bool isBoundsRemapping{false};
   std::size_t numBounds{std::visit(
       common::visitors{
-          [&](const PointerAssignment::BoundsSpec &bounds) {
+          [&](const evaluate::Assignment::BoundsSpec &bounds) {
             return bounds.size();
           },
-          [&](const PointerAssignment::BoundsRemapping &bounds) {
+          [&](const evaluate::Assignment::BoundsRemapping &bounds) {
             isBoundsRemapping = true;
             evaluate::ExtentExpr lhsSizeExpr{1};
             for (const auto &bound : bounds) {
@@ -383,8 +382,11 @@ static bool CheckPointerBounds(
             }
             return bounds.size();
           },
+          [](const auto &) -> std::size_t {
+            DIE("not valid for pointer assignment");
+          },
       },
-      assignment.bounds)};
+      assignment.u)};
   if (numBounds > 0) {
     if (lhs.Rank() != static_cast<int>(numBounds)) {
       messages.Say("Pointer '%s' has rank %d but the number of bounds specified"
@@ -401,7 +403,7 @@ static bool CheckPointerBounds(
 }
 
 void CheckPointerAssignment(
-    evaluate::FoldingContext &context, const PointerAssignment &assignment) {
+    evaluate::FoldingContext &context, const evaluate::Assignment &assignment) {
   const SomeExpr &lhs{assignment.lhs};
   const SomeExpr &rhs{assignment.rhs};
   const Symbol *pointer{GetLastSymbol(lhs)};
diff --git a/lib/semantics/pointer-assignment.h b/lib/semantics/pointer-assignment.h
index 70c805683016..a9efc59994ac 100644
--- a/lib/semantics/pointer-assignment.h
+++ b/lib/semantics/pointer-assignment.h
@@ -26,8 +26,8 @@ namespace Fortran::semantics {
 
 class Symbol;
 
-void CheckPointerAssignment(evaluate::FoldingContext &,
-    const evaluate::Assignment::PointerAssignment &);
+void CheckPointerAssignment(
+    evaluate::FoldingContext &, const evaluate::Assignment &);
 void CheckPointerAssignment(
     evaluate::FoldingContext &, const Symbol &lhs, const SomeExpr &rhs);
 void CheckPointerAssignment(evaluate::FoldingContext &,

From 69a845283b058a3644053ec58b00d3361f4d4a59 Mon Sep 17 00:00:00 2001
From: "Jinxin (Brian) Yang" <jinxiny@nvidia.com>
Date: Tue, 18 Feb 2020 16:27:43 -0800
Subject: [PATCH 032/345] [OpenMP] Predetermined rule for sequential loop index
 (#976)

This commit implements rule:
A loop iteration variable for a sequential loop in a parallel or
task generating construct is private in the innermost such construct
that encloses the loop.

A Simple example:
```
  i = -1                    <== Scope 0
  j = -1
  !$omp parallel            <== Scope 1
  print *,i,j      <-- both are shared (Scope 0)
  !$omp parallel            <== Scope 2
  print *,i,j      <-- a) i is shared (Scope 0), j is private (Scope 2)
  !$omp do                  <== Scope 3
  do i=1, 10       <-- i is private (Scope 3)
     do j=1, 10    <-- b) j is private (Scope 2, not 3!)
     enddo
  enddo
  print *,i,j      <-- c) i is shared (Scope 0), j is private (Scope 2)
  !$omp end parallel
  print *,i,j      <-- both are shared (Scope 0)
  !$omp end parallel
  print *,i,j      <-- both are shared (Scope 0)
end
```

Ideally the above rule solves a), b), and c) but a) is left as a TODO
because it is better to handle the data-sharing attribute conflicts
along with the rules for "Predetermined DSA on Clauses".

The basic idea is when visiting the `DoConstruct` node within an OpenMP
construct, if the do-loop is not associated (like `i` loop is associated
with `!$omp do`) AND the do-loop is in the parallel/task generating
construct, resolve the loop index to be private to that innermost construct.

In the above example, `j` loop is not associated (then it is sequential) and
the innermost parallel/task generating construct that encloses the `j` loop
is the `parallel` construct marked with `<== Scope 2`, so `j` is private
to that construct. To do that, I also need to change the prototype of those
`ResolveOmp*` functions to allow specifiying the `scope` because the new
symbol for `j` should be created in Scope 2 and all the `symbol` field of
`Name j` in that `parallel` construct should be fixed, such as c).
---
 include/flang/semantics/symbol.h    |   2 +-
 lib/semantics/check-omp-structure.h |   2 +
 lib/semantics/resolve-names.cpp     | 123 ++++++++++++++++++++++------
 test/semantics/omp-symbol01.f90     |   2 +-
 test/semantics/omp-symbol04.f90     |   2 +-
 test/semantics/omp-symbol06.f90     |   2 +-
 test/semantics/omp-symbol08.f90     |  84 ++++++++++++++-----
 7 files changed, 166 insertions(+), 51 deletions(-)

diff --git a/include/flang/semantics/symbol.h b/include/flang/semantics/symbol.h
index a27a935bdb00..5c45a8c5ad06 100644
--- a/include/flang/semantics/symbol.h
+++ b/include/flang/semantics/symbol.h
@@ -463,7 +463,7 @@ class Symbol {
       // OpenMP miscellaneous flags
       OmpCommonBlock, OmpReduction, OmpDeclareSimd, OmpDeclareTarget,
       OmpThreadprivate, OmpDeclareReduction, OmpFlushed, OmpCriticalLock,
-      OmpIfSpecified, OmpNone);
+      OmpIfSpecified, OmpNone, OmpPreDetermined);
   using Flags = common::EnumSet<Flag, Flag_enumSize>;
 
   const Scope &owner() const { return *owner_; }
diff --git a/lib/semantics/check-omp-structure.h b/lib/semantics/check-omp-structure.h
index b20c32550769..e265b6bda909 100644
--- a/lib/semantics/check-omp-structure.h
+++ b/lib/semantics/check-omp-structure.h
@@ -88,6 +88,8 @@ static constexpr OmpDirectiveSet simdSet{
     OmpDirective::TASKLOOP_SIMD,
     OmpDirective::TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
     OmpDirective::TEAMS_DISTRIBUTE_SIMD};
+static constexpr OmpDirectiveSet taskGeneratingSet{
+    OmpDirectiveSet{OmpDirective::TASK} | taskloopSet};
 
 class OmpStructureChecker : public virtual BaseChecker {
 public:
diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index 61e9ed02711d..b98b7bc14a8d 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -1167,6 +1167,7 @@ class OmpAttributeVisitor {
   void Post(const parser::OmpBeginLoopDirective &) {
     GetContext().withinConstruct = true;
   }
+  bool Pre(const parser::DoConstruct &);
 
   bool Pre(const parser::OpenMPSectionsConstruct &);
   void Post(const parser::OpenMPSectionsConstruct &) { PopContext(); }
@@ -1224,27 +1225,34 @@ class OmpAttributeVisitor {
   void SetContextDirectiveEnum(OmpDirective dir) {
     GetContext().directive = dir;
   }
-  const Scope &currScope() { return GetContext().scope; }
+  Scope &currScope() { return GetContext().scope; }
   void SetContextDefaultDSA(Symbol::Flag flag) {
     GetContext().defaultDSA = flag;
   }
+  void AddToContextObjectWithDSA(
+      const Symbol &symbol, Symbol::Flag flag, OmpContext &context) {
+    context.objectWithDSA.emplace(&symbol, flag);
+  }
   void AddToContextObjectWithDSA(const Symbol &symbol, Symbol::Flag flag) {
-    GetContext().objectWithDSA.emplace(&symbol, flag);
+    AddToContextObjectWithDSA(symbol, flag, GetContext());
   }
   bool IsObjectWithDSA(const Symbol &symbol) {
     auto it{GetContext().objectWithDSA.find(&symbol)};
     return it != GetContext().objectWithDSA.end();
   }
+
   void SetContextAssociatedLoopLevel(std::size_t level) {
     GetContext().associatedLoopLevel = level;
   }
   std::size_t GetAssociatedLoopLevelFromClauses(const parser::OmpClauseList &);
 
-  Symbol &MakeAssocSymbol(const SourceName &name, Symbol &prev) {
-    const auto pair{
-        GetContext().scope.try_emplace(name, Attrs{}, HostAssocDetails{prev})};
+  Symbol &MakeAssocSymbol(const SourceName &name, Symbol &prev, Scope &scope) {
+    const auto pair{scope.try_emplace(name, Attrs{}, HostAssocDetails{prev})};
     return *pair.first->second;
   }
+  Symbol &MakeAssocSymbol(const SourceName &name, Symbol &prev) {
+    return MakeAssocSymbol(name, prev, currScope());
+  }
 
   static const parser::Name *GetDesignatorNameIfDataRef(
       const parser::Designator &designator) {
@@ -1277,14 +1285,17 @@ class OmpAttributeVisitor {
       const parser::ExecutionPartConstruct &);
   // Predetermined DSA rules
   void PrivatizeAssociatedLoopIndex(const parser::OpenMPLoopConstruct &);
+  const parser::Name &GetLoopIndex(const parser::DoConstruct &);
+  void ResolveSeqLoopIndexInParallelOrTaskConstruct(const parser::Name &);
 
   void ResolveOmpObjectList(const parser::OmpObjectList &, Symbol::Flag);
   void ResolveOmpObject(const parser::OmpObject &, Symbol::Flag);
-  Symbol *ResolveOmp(const parser::Name &, Symbol::Flag);
-  Symbol *ResolveOmp(Symbol &, Symbol::Flag);
+  Symbol *ResolveOmp(const parser::Name &, Symbol::Flag, Scope &);
+  Symbol *ResolveOmp(Symbol &, Symbol::Flag, Scope &);
   Symbol *ResolveOmpCommonBlockName(const parser::Name *);
-  Symbol *DeclarePrivateAccessEntity(const parser::Name &, Symbol::Flag);
-  Symbol *DeclarePrivateAccessEntity(Symbol &, Symbol::Flag);
+  Symbol *DeclarePrivateAccessEntity(
+      const parser::Name &, Symbol::Flag, Scope &);
+  Symbol *DeclarePrivateAccessEntity(Symbol &, Symbol::Flag, Scope &);
   Symbol *DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
   Symbol *DeclareOrMarkOtherAccessEntity(Symbol &, Symbol::Flag);
   void CheckMultipleAppearances(
@@ -1380,6 +1391,7 @@ class ResolveNamesVisitor : public virtual ScopeHandler,
   void FinishSpecificationParts(const ProgramTree &);
   void FinishDerivedTypeInstantiation(Scope &);
   void ResolveExecutionParts(const ProgramTree &);
+  void ResolveOmpParts(const parser::ProgramUnit &);
 };
 
 // ImplicitRules implementation
@@ -5766,7 +5778,7 @@ bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
   ResolveSpecificationParts(root);
   FinishSpecificationParts(root);
   ResolveExecutionParts(root);
-  OmpAttributeVisitor{context(), *this}.Walk(x);
+  ResolveOmpParts(x);
   return false;
 }
 
@@ -6072,6 +6084,53 @@ bool OmpAttributeVisitor::Pre(const parser::OpenMPLoopConstruct &x) {
   return true;
 }
 
+const parser::Name &OmpAttributeVisitor::GetLoopIndex(
+    const parser::DoConstruct &x) {
+  auto &loopControl{x.GetLoopControl().value()};
+  using Bounds = parser::LoopControl::Bounds;
+  const Bounds &bounds{std::get<Bounds>(loopControl.u)};
+  return bounds.name.thing;
+}
+
+void OmpAttributeVisitor::ResolveSeqLoopIndexInParallelOrTaskConstruct(
+    const parser::Name &iv) {
+  auto targetIt{ompContext_.rbegin()};
+  for (;; ++targetIt) {
+    if (targetIt == ompContext_.rend()) {
+      return;
+    }
+    if (parallelSet.test(targetIt->directive) ||
+        taskGeneratingSet.test(targetIt->directive)) {
+      break;
+    }
+  }
+  if (auto *symbol{ResolveOmp(iv, Symbol::Flag::OmpPrivate, targetIt->scope)}) {
+    targetIt++;
+    symbol->set(Symbol::Flag::OmpPreDetermined);
+    iv.symbol = symbol;  // adjust the symbol within region
+    for (auto it{ompContext_.rbegin()}; it != targetIt; ++it) {
+      AddToContextObjectWithDSA(*symbol, Symbol::Flag::OmpPrivate, *it);
+    }
+  }
+}
+
+// 2.15.1.1 Data-sharing Attribute Rules - Predetermined
+//   - A loop iteration variable for a sequential loop in a parallel
+//     or task generating construct is private in the innermost such
+//     construct that encloses the loop
+bool OmpAttributeVisitor::Pre(const parser::DoConstruct &x) {
+  if (!ompContext_.empty() && GetContext().withinConstruct) {
+    if (const auto &iv{GetLoopIndex(x)}; iv.symbol) {
+      if (!iv.symbol->test(Symbol::Flag::OmpPreDetermined)) {
+        ResolveSeqLoopIndexInParallelOrTaskConstruct(iv);
+      } else {
+        // TODO: conflict checks with explicitly determined DSA
+      }
+    }
+  }
+  return true;
+}
+
 const parser::DoConstruct *OmpAttributeVisitor::GetDoConstructIf(
     const parser::ExecutionPartConstruct &x) {
   if (auto *y{std::get_if<parser::ExecutableConstruct>(&x.u)}) {
@@ -6137,11 +6196,9 @@ void OmpAttributeVisitor::PrivatizeAssociatedLoopIndex(
   auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
   for (const parser::DoConstruct *loop{&*outer}; loop && level > 0; --level) {
     // go through all the nested do-loops and resolve index variables
-    auto &loopControl{loop->GetLoopControl().value()};
-    using Bounds = parser::LoopControl::Bounds;
-    const Bounds &bounds{std::get<Bounds>(loopControl.u)};
-    const parser::Name &iv{bounds.name.thing};
-    if (auto *symbol{ResolveOmp(iv, ivDSA)}) {
+    const parser::Name &iv{GetLoopIndex(*loop)};
+    if (auto *symbol{ResolveOmp(iv, ivDSA, currScope())}) {
+      symbol->set(Symbol::Flag::OmpPreDetermined);
       iv.symbol = symbol;  // adjust the symbol within region
       AddToContextObjectWithDSA(*symbol, ivDSA);
     }
@@ -6207,7 +6264,7 @@ void OmpAttributeVisitor::Post(const parser::Name &name) {
       //       predetermined, explicitly determined, and implicitly
       //       determined data-sharing attributes (2.15.1.1).
       if (Symbol * found{currScope().FindSymbol(name.source)}) {
-        if (IsObjectWithDSA(*found)) {
+        if (symbol != found) {
           name.symbol = found;  // adjust the symbol within region
         } else if (GetContext().defaultDSA == Symbol::Flag::OmpNone) {
           context_.Say(name.source,
@@ -6250,7 +6307,7 @@ void OmpAttributeVisitor::ResolveOmpObject(
       common::visitors{
           [&](const parser::Designator &designator) {
             if (const auto *name{GetDesignatorNameIfDataRef(designator)}) {
-              if (auto *symbol{ResolveOmp(*name, ompFlag)}) {
+              if (auto *symbol{ResolveOmp(*name, ompFlag, currScope())}) {
                 AddToContextObjectWithDSA(*symbol, ompFlag);
                 if (dataSharingAttributeFlags.test(ompFlag)) {
                   CheckMultipleAppearances(*name, *symbol, ompFlag);
@@ -6288,7 +6345,8 @@ void OmpAttributeVisitor::ResolveOmpObject(
               for (const Symbol &object :
                   symbol->get<CommonBlockDetails>().objects()) {
                 Symbol &mutableObject{const_cast<Symbol &>(object)};
-                if (auto *resolvedObject{ResolveOmp(mutableObject, ompFlag)}) {
+                if (auto *resolvedObject{
+                        ResolveOmp(mutableObject, ompFlag, currScope())}) {
                   AddToContextObjectWithDSA(*resolvedObject, ompFlag);
                 }
               }
@@ -6303,35 +6361,36 @@ void OmpAttributeVisitor::ResolveOmpObject(
 }
 
 Symbol *OmpAttributeVisitor::ResolveOmp(
-    const parser::Name &name, Symbol::Flag ompFlag) {
+    const parser::Name &name, Symbol::Flag ompFlag, Scope &scope) {
   if (ompFlagsRequireNewSymbol.test(ompFlag)) {
-    return DeclarePrivateAccessEntity(name, ompFlag);
+    return DeclarePrivateAccessEntity(name, ompFlag, scope);
   } else {
     return DeclareOrMarkOtherAccessEntity(name, ompFlag);
   }
 }
 
-Symbol *OmpAttributeVisitor::ResolveOmp(Symbol &symbol, Symbol::Flag ompFlag) {
+Symbol *OmpAttributeVisitor::ResolveOmp(
+    Symbol &symbol, Symbol::Flag ompFlag, Scope &scope) {
   if (ompFlagsRequireNewSymbol.test(ompFlag)) {
-    return DeclarePrivateAccessEntity(symbol, ompFlag);
+    return DeclarePrivateAccessEntity(symbol, ompFlag, scope);
   } else {
     return DeclareOrMarkOtherAccessEntity(symbol, ompFlag);
   }
 }
 
 Symbol *OmpAttributeVisitor::DeclarePrivateAccessEntity(
-    const parser::Name &name, Symbol::Flag ompFlag) {
+    const parser::Name &name, Symbol::Flag ompFlag, Scope &scope) {
   if (!name.symbol) {
     return nullptr;  // not resolved by Name Resolution step, do nothing
   }
-  name.symbol = DeclarePrivateAccessEntity(*name.symbol, ompFlag);
+  name.symbol = DeclarePrivateAccessEntity(*name.symbol, ompFlag, scope);
   return name.symbol;
 }
 
 Symbol *OmpAttributeVisitor::DeclarePrivateAccessEntity(
-    Symbol &object, Symbol::Flag ompFlag) {
+    Symbol &object, Symbol::Flag ompFlag, Scope &scope) {
   if (object.owner() != currScope()) {
-    auto &symbol{MakeAssocSymbol(object.name(), object)};
+    auto &symbol{MakeAssocSymbol(object.name(), object, scope)};
     symbol.set(ompFlag);
     return &symbol;
   } else {
@@ -6455,6 +6514,18 @@ void ResolveNamesVisitor::ResolveExecutionParts(const ProgramTree &node) {
   }
 }
 
+void ResolveNamesVisitor::ResolveOmpParts(const parser::ProgramUnit &node) {
+  OmpAttributeVisitor{context(), *this}.Walk(node);
+  if (!context().AnyFatalError()) {
+    // The data-sharing attribute of the loop iteration variable for a
+    // sequential loop (2.15.1.1) can only be determined when visiting
+    // the corresponding DoConstruct, a second walk is to adjust the
+    // symbols for all the data-refs of that loop iteration variable
+    // prior to the DoConstruct.
+    OmpAttributeVisitor{context(), *this}.Walk(node);
+  }
+}
+
 void ResolveNamesVisitor::Post(const parser::Program &) {
   // ensure that all temps were deallocated
   CHECK(!attrs_);
diff --git a/test/semantics/omp-symbol01.f90 b/test/semantics/omp-symbol01.f90
index eca885565fba..bec8e0450dd5 100644
--- a/test/semantics/omp-symbol01.f90
+++ b/test/semantics/omp-symbol01.f90
@@ -45,7 +45,7 @@ program mm
  !DEF: /mm/c (Implicit) ObjectEntity REAL(4)
  c = 2.0
 !$omp parallel do  private(a,t,/c/) shared(c)
- !DEF: /mm/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+ !DEF: /mm/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
  do i=1,10
   !DEF: /mm/Block1/a (OmpPrivate) HostAssoc REAL(4)
   !REF: /mm/b
diff --git a/test/semantics/omp-symbol04.f90 b/test/semantics/omp-symbol04.f90
index 9daacfb49854..4824c78dc92b 100644
--- a/test/semantics/omp-symbol04.f90
+++ b/test/semantics/omp-symbol04.f90
@@ -12,7 +12,7 @@
   !DEF: /MainProgram1/Block1/a (OmpPrivate) HostAssoc REAL(8)
   a = 2.
   !$omp do  private(a)
-  !DEF: /MainProgram1/Block1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+  !DEF: /MainProgram1/Block1/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do i=1,10
      !DEF: /MainProgram1/Block1/Block1/a (OmpPrivate) HostAssoc REAL(8)
      a = 1.
diff --git a/test/semantics/omp-symbol06.f90 b/test/semantics/omp-symbol06.f90
index 3b82fc88e598..c1d7581db8be 100644
--- a/test/semantics/omp-symbol06.f90
+++ b/test/semantics/omp-symbol06.f90
@@ -8,7 +8,7 @@
   !DEF: /MainProgram1/a (Implicit) ObjectEntity REAL(4)
   a = 1.
   !$omp parallel do  firstprivate(a) lastprivate(a)
-  !DEF: /MainProgram1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+  !DEF: /MainProgram1/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do i=1,10
      !DEF: /MainProgram1/Block1/a (OmpFirstPrivate, OmpLastPrivate) HostAssoc REAL(4)
      a = 2.
diff --git a/test/semantics/omp-symbol08.f90 b/test/semantics/omp-symbol08.f90
index eaf8ff2eaa9d..ac09e1690677 100644
--- a/test/semantics/omp-symbol08.f90
+++ b/test/semantics/omp-symbol08.f90
@@ -8,6 +8,9 @@
 !      increment of the associated do-loop.
 !   c) The loop iteration variables in the associated do-loops of a simd
 !      construct with multiple associated do-loops are lastprivate.
+!   d) A loop iteration variable for a sequential loop in a parallel or task
+!      generating construct is private in the innermost such construct that
+!      encloses the loop.
 !   - TBD
 
 ! All the tests assume that the do-loops association for collapse/ordered
@@ -28,16 +31,16 @@ subroutine test_do
  !REF: /test_do/i
  i = 99
 !$omp do  collapse(2)
- !DEF: /test_do/Block1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+ !DEF: /test_do/Block1/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
  do i=1,5
-  !DEF: /test_do/Block1/Block1/j (OmpPrivate) HostAssoc INTEGER(4)
+  !DEF: /test_do/Block1/Block1/j (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do j=6,10
    !REF: /test_do/a
    a(1,1,1) = 0.
-   !REF: /test_do/k
+   !DEF: /test_do/Block1/k (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
    do k=11,15
     !REF: /test_do/a
-    !REF: /test_do/k
+    !REF: /test_do/Block1/k
     !REF: /test_do/Block1/Block1/j
     !REF: /test_do/Block1/Block1/i
     a(k,j,i) = 1.
@@ -58,13 +61,13 @@ subroutine test_pardo
  !DEF: /test_pardo/k ObjectEntity INTEGER(4)
  integer i, j, k
 !$omp parallel do  collapse(2) private(k) ordered(2)
- !DEF: /test_pardo/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+ !DEF: /test_pardo/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
  do i=1,5
-  !DEF: /test_pardo/Block1/j (OmpPrivate) HostAssoc INTEGER(4)
-  do j=6,10
+   !DEF: /test_pardo/Block1/j (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
+    do j=6,10
    !REF: /test_pardo/a
    a(1,1,1) = 0.
-   !DEF: /test_pardo/Block1/k (OmpPrivate) HostAssoc INTEGER(4)
+   !DEF: /test_pardo/Block1/k (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
    do k=11,15
     !REF: /test_pardo/a
     !REF: /test_pardo/Block1/k
@@ -86,9 +89,9 @@ subroutine test_taskloop
  !DEF: /test_taskloop/j ObjectEntity INTEGER(4)
  integer i, j
 !$omp taskloop  private(j)
- !DEF: /test_taskloop/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
+ !DEF: /test_taskloop/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
  do i=1,5
-  !DEF: /test_taskloop/Block1/j (OmpPrivate) HostAssoc INTEGER(4)
+  !DEF: /test_taskloop/Block1/j (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   !REF: /test_taskloop/Block1/i
   do j=1,i
    !REF: /test_taskloop/a
@@ -129,13 +132,13 @@ subroutine dotprod (b, c, n, block_size, num_teams, block_threads)
 !$omp target  map(to:b,c)  map(tofrom:sum)
 !$omp teams  num_teams(num_teams) thread_limit(block_threads) reduction(+:sum)
 !$omp distribute
- !DEF: /dotprod/Block1/Block1/Block1/i0 (OmpPrivate) HostAssoc INTEGER(4)
+ !DEF: /dotprod/Block1/Block1/Block1/i0 (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
  !REF: /dotprod/n
  !REF: /dotprod/block_size
  do i0=1,n,block_size
 !$omp parallel do  reduction(+:sum)
-  !DEF: /dotprod/Block1/Block1/Block1/Block1/i (OmpPrivate) HostAssoc INTEGER(4)
-  !REF: /dotprod/i0
+  !DEF: /dotprod/Block1/Block1/Block1/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
+  !REF: /dotprod/Block1/Block1/Block1/i0
   !DEF: /dotprod/min INTRINSIC (Function) ProcEntity
   !REF: /dotprod/block_size
   !REF: /dotprod/n
@@ -165,15 +168,15 @@ subroutine test_simd
  !DEF: /test_simd/k ObjectEntity INTEGER(4)
  integer i, j, k
 !$omp parallel do simd
- !DEF: /test_simd/Block1/i (OmpLinear) HostAssoc INTEGER(4)
+ !DEF: /test_simd/Block1/i (OmpLinear, OmpPreDetermined) HostAssoc INTEGER(4)
  do i=1,5
-  !REF: /test_simd/j
+  !DEF: /test_simd/Block1/j (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do j=6,10
-   !REF: /test_simd/k
+   !DEF: /test_simd/Block1/k (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
    do k=11,15
     !REF: /test_simd/a
-    !REF: /test_simd/k
-    !REF: /test_simd/j
+    !REF: /test_simd/Block1/k
+    !REF: /test_simd/Block1/j
     !REF: /test_simd/Block1/i
     a(k,j,i) = 3.14
    end do
@@ -192,11 +195,11 @@ subroutine test_simd_multi
  !DEF: /test_simd_multi/k ObjectEntity INTEGER(4)
  integer i, j, k
 !$omp parallel do simd  collapse(3)
- !DEF: /test_simd_multi/Block1/i (OmpLastPrivate) HostAssoc INTEGER(4)
+ !DEF: /test_simd_multi/Block1/i (OmpLastPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
  do i=1,5
-  !DEF: /test_simd_multi/Block1/j (OmpLastPrivate) HostAssoc INTEGER(4)
+  !DEF: /test_simd_multi/Block1/j (OmpLastPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do j=6,10
-   !DEF: /test_simd_multi/Block1/k (OmpLastPrivate) HostAssoc INTEGER(4)
+   !DEF: /test_simd_multi/Block1/k (OmpLastPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
    do k=11,15
     !REF: /test_simd_multi/a
     !REF: /test_simd_multi/Block1/k
@@ -207,3 +210,42 @@ subroutine test_simd_multi
   end do
  end do
 end subroutine test_simd_multi
+
+! Rule d)
+!DEF: /test_seq_loop (Subroutine) Subprogram
+subroutine test_seq_loop
+  implicit none
+  !DEF: /test_seq_loop/i ObjectEntity INTEGER(4)
+  !DEF: /test_seq_loop/j ObjectEntity INTEGER(4)
+  integer i, j
+  !REF: /test_seq_loop/i
+  i = -1
+  !REF: /test_seq_loop/j
+  j = -1
+  !$omp parallel
+  !REF: /test_seq_loop/i
+  !REF: /test_seq_loop/j
+  print *, i, j
+  !$omp parallel
+  !REF: /test_seq_loop/i
+  !DEF: /test_seq_loop/Block1/Block1/j (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
+  print *, i, j
+  !$omp do
+  !DEF: /test_seq_loop/Block1/Block1/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
+  do i=1,10
+   !REF: /test_seq_loop/Block1/Block1/j
+   do j=1,10
+   end do
+  end do
+  !REF: /test_seq_loop/i
+  !REF: /test_seq_loop/Block1/Block1/j
+  print *, i, j
+  !$omp end parallel
+  !REF: /test_seq_loop/i
+  !REF: /test_seq_loop/j
+  print *, i, j
+  !$omp end parallel
+  !REF: /test_seq_loop/i
+  !REF: /test_seq_loop/j
+  print *, i, j
+end subroutine test_seq_loop

From 84752c492e910573e2f0ede1ed3c0417aac363b9 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 18 Feb 2020 17:14:24 -0800
Subject: [PATCH 033/345] Add FORALL checking to DoChecker

FORALL statements and constructs require a lot of the same checking
as DO CONCURRENT, so do the checks in DoChecker so that code can be
shared where possible. This requires some reorganization there.
Remove code from AssignmentChecker that did some of these checks.

Change names that contain `DoVar` or `DoVariable` to `IndexVar` to
reflect the fact that they may be DO or FORALL index variables.
Distinguish between the two when necessary with enum `IndexVarKind`.

Change some messages that referred to "concurrent-header" or
"concurrent-control" to specifically say "DO CONCURRENT" or "FORALL".
---
 include/flang/evaluate/tools.h      |   3 +
 include/flang/semantics/semantics.h |  27 ++--
 lib/evaluate/tools.cpp              |   4 +
 lib/semantics/assignment.cpp        | 124 ---------------
 lib/semantics/assignment.h          |  17 +--
 lib/semantics/check-allocate.cpp    |   2 +-
 lib/semantics/check-deallocate.cpp  |   2 +-
 lib/semantics/check-do.cpp          | 229 ++++++++++++++++++++--------
 lib/semantics/check-do.h            |   8 +
 lib/semantics/check-io.cpp          |   4 +-
 lib/semantics/semantics.cpp         |  71 ++++-----
 test/semantics/call11.f90           |   4 +-
 test/semantics/dosemantics02.f90    |   6 +-
 test/semantics/dosemantics04.f90    |  12 +-
 test/semantics/dosemantics05.f90    |   2 +-
 test/semantics/dosemantics09.f90    |  12 +-
 test/semantics/forall01.f90         |  52 +++++++
 test/semantics/resolve35.f90        |   8 -
 18 files changed, 300 insertions(+), 287 deletions(-)

diff --git a/include/flang/evaluate/tools.h b/include/flang/evaluate/tools.h
index 9a473619d5b0..d992e8eacff5 100644
--- a/include/flang/evaluate/tools.h
+++ b/include/flang/evaluate/tools.h
@@ -843,5 +843,8 @@ parser::Message *SayWithDeclaration(
 // of one to complain about, if any exist.
 std::optional<std::string> FindImpureCall(
     const IntrinsicProcTable &, const Expr<SomeType> &);
+std::optional<std::string> FindImpureCall(
+    const IntrinsicProcTable &, const ProcedureRef &);
+
 }
 #endif  // FORTRAN_EVALUATE_TOOLS_H_
diff --git a/include/flang/semantics/semantics.h b/include/flang/semantics/semantics.h
index e823f48dc397..b13f617108b4 100644
--- a/include/flang/semantics/semantics.h
+++ b/include/flang/semantics/semantics.h
@@ -150,19 +150,18 @@ class SemanticsContext {
   }
   void PopConstruct();
 
-  // Check to see if a variable being redefined is a DO variable.  If so, emit
-  // a message
-  void WarnDoVarRedefine(const parser::CharBlock &, const Symbol &);
-  void CheckDoVarRedefine(const parser::CharBlock &, const Symbol &);
-  void CheckDoVarRedefine(const parser::Variable &);
-  void CheckDoVarRedefine(const parser::Name &);
-  void ActivateDoVariable(const parser::Name &);
-  void DeactivateDoVariable(const parser::Name &);
-  bool IsActiveDoVariable(const Symbol &);
+  ENUM_CLASS(IndexVarKind, DO, FORALL)
+  // Check to see if a variable being redefined is a DO or FORALL index.
+  // If so, emit a message.
+  void WarnIndexVarRedefine(const parser::CharBlock &, const Symbol &);
+  void CheckIndexVarRedefine(const parser::CharBlock &, const Symbol &);
+  void CheckIndexVarRedefine(const parser::Variable &);
+  void CheckIndexVarRedefine(const parser::Name &);
+  void ActivateIndexVar(const parser::Name &, IndexVarKind);
+  void DeactivateIndexVar(const parser::Name &);
 
 private:
-  parser::CharBlock GetDoVariableLocation(const Symbol &);
-  void CheckDoVarRedefine(
+  void CheckIndexVarRedefine(
       const parser::CharBlock &, const Symbol &, parser::MessageFixedText &&);
   const common::IntrinsicTypeDefaultKinds &defaultKinds_;
   const common::LanguageFeatureControl languageFeatures_;
@@ -180,7 +179,11 @@ class SemanticsContext {
 
   bool CheckError(bool);
   ConstructStack constructStack_;
-  std::map<SymbolRef, const parser::CharBlock> activeDoVariables_;
+  struct IndexVarInfo {
+    parser::CharBlock location;
+    IndexVarKind kind;
+  };
+  std::map<SymbolRef, const IndexVarInfo> activeIndexVars_;
 };
 
 class Semantics {
diff --git a/lib/evaluate/tools.cpp b/lib/evaluate/tools.cpp
index 8f9af2e1fa34..f082c496aee5 100644
--- a/lib/evaluate/tools.cpp
+++ b/lib/evaluate/tools.cpp
@@ -842,5 +842,9 @@ std::optional<std::string> FindImpureCall(
     const IntrinsicProcTable &intrinsics, const Expr<SomeType> &expr) {
   return FindImpureCallHelper{intrinsics}(expr);
 }
+std::optional<std::string> FindImpureCall(
+    const IntrinsicProcTable &intrinsics, const ProcedureRef &proc) {
+  return FindImpureCallHelper{intrinsics}(proc);
+}
 
 }
diff --git a/lib/semantics/assignment.cpp b/lib/semantics/assignment.cpp
index cb727efb2b66..aee651e42b19 100644
--- a/lib/semantics/assignment.cpp
+++ b/lib/semantics/assignment.cpp
@@ -46,20 +46,8 @@ struct Control {
 struct ForallContext {
   explicit ForallContext(const ForallContext *that) : outer{that} {}
 
-  std::optional<int> GetActiveIntKind(const parser::CharBlock &name) const {
-    const auto iter{activeNames.find(name)};
-    if (iter != activeNames.cend()) {
-      return {integerKind};
-    } else if (outer) {
-      return outer->GetActiveIntKind(name);
-    } else {
-      return std::nullopt;
-    }
-  }
-
   const ForallContext *outer{nullptr};
   std::optional<parser::CharBlock> constructName;
-  int integerKind;
   std::vector<Control> control;
   std::optional<MaskExpr> maskExpr;
   std::set<parser::CharBlock> activeNames;
@@ -89,10 +77,7 @@ class AssignmentContext {
   void Analyze(const parser::PointerAssignmentStmt &);
   void Analyze(const parser::WhereStmt &);
   void Analyze(const parser::WhereConstruct &);
-  void Analyze(const parser::ForallStmt &);
   void Analyze(const parser::ForallConstruct &);
-  void Analyze(const parser::ForallConstructStmt &);
-  void Analyze(const parser::ConcurrentHeader &);
 
   template<typename A> void Analyze(const parser::UnlabeledStatement<A> &stmt) {
     context_.set_location(stmt.source);
@@ -120,9 +105,6 @@ class AssignmentContext {
   void Analyze(const parser::MaskedElsewhereStmt &);
   void Analyze(const parser::WhereConstruct::Elsewhere &);
 
-  int GetIntegerKind(const std::optional<parser::IntegerTypeSpec> &);
-  void CheckForImpureCall(const SomeExpr &);
-  void CheckForImpureCall(const SomeExpr *);
   void CheckForPureContext(const SomeExpr &lhs, const SomeExpr &rhs,
       parser::CharBlock rhsSource, bool isPointerAssignment);
 
@@ -142,8 +124,6 @@ void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
   // Assignment statement analysis is in expression.cpp where user-defined
   // assignments can be recognized and replaced.
   if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
-    CheckForImpureCall(assignment->lhs);
-    CheckForImpureCall(assignment->rhs);
     if (forall_) {
       // TODO: Warn if some name in forall_->activeNames or its outer
       // contexts does not appear on LHS
@@ -163,22 +143,6 @@ void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
   }
   const SomeExpr &lhs{assignment->lhs};
   const SomeExpr &rhs{assignment->rhs};
-  CheckForImpureCall(lhs);
-  CheckForImpureCall(rhs);
-  std::visit(
-      common::visitors{[&](const evaluate::Assignment::BoundsSpec &bounds) {
-                         for (const auto &bound : bounds) {
-                           CheckForImpureCall(SomeExpr{bound});
-                         }
-                       },
-          [&](const evaluate::Assignment::BoundsRemapping &bounds) {
-            for (const auto &bound : bounds) {
-              CheckForImpureCall(SomeExpr{bound.first});
-              CheckForImpureCall(SomeExpr{bound.second});
-            }
-          },
-          [](const auto &) { DIE("not valid for pointer assignment"); }},
-      assignment->u);
   if (forall_) {
     // TODO: Warn if some name in forall_->activeNames or its outer
     // contexts does not appear on LHS
@@ -216,32 +180,6 @@ void AssignmentContext::Analyze(const parser::WhereConstruct &construct) {
       std::get<std::optional<parser::WhereConstruct::Elsewhere>>(construct.t));
 }
 
-void AssignmentContext::Analyze(const parser::ForallStmt &stmt) {
-  CHECK(!where_);
-  ForallContext forall{forall_};
-  AssignmentContext nested{*this, forall};
-  nested.Analyze(
-      std::get<common::Indirection<parser::ConcurrentHeader>>(stmt.t));
-  nested.Analyze(
-      std::get<parser::UnlabeledStatement<parser::ForallAssignmentStmt>>(
-          stmt.t));
-}
-
-// N.B. Construct name matching is checked during label resolution;
-// index name distinction is checked during name resolution.
-void AssignmentContext::Analyze(const parser::ForallConstruct &construct) {
-  CHECK(!where_);
-  ForallContext forall{forall_};
-  AssignmentContext nested{*this, forall};
-  nested.Analyze(
-      std::get<parser::Statement<parser::ForallConstructStmt>>(construct.t));
-  nested.Analyze(std::get<std::list<parser::ForallBodyConstruct>>(construct.t));
-}
-
-void AssignmentContext::Analyze(const parser::ForallConstructStmt &stmt) {
-  Analyze(std::get<common::Indirection<parser::ConcurrentHeader>>(stmt.t));
-}
-
 void AssignmentContext::Analyze(
     const parser::WhereConstruct::MaskedElsewhere &elsewhere) {
   CHECK(where_);
@@ -279,56 +217,6 @@ void AssignmentContext::Analyze(
   Analyze(std::get<std::list<parser::WhereBodyConstruct>>(elsewhere.t));
 }
 
-void AssignmentContext::Analyze(const parser::ConcurrentHeader &header) {
-  DEREF(forall_).integerKind = GetIntegerKind(
-      std::get<std::optional<parser::IntegerTypeSpec>>(header.t));
-  for (const auto &control :
-      std::get<std::list<parser::ConcurrentControl>>(header.t)) {
-    const parser::Name &name{std::get<parser::Name>(control.t)};
-    bool inserted{forall_->activeNames.insert(name.source).second};
-    CHECK(inserted || context_.HasError(name));
-    CheckForImpureCall(GetExpr(std::get<1>(control.t)));
-    CheckForImpureCall(GetExpr(std::get<2>(control.t)));
-    if (const auto &stride{std::get<3>(control.t)}) {
-      CheckForImpureCall(GetExpr(*stride));
-    }
-  }
-  if (const auto &mask{
-          std::get<std::optional<parser::ScalarLogicalExpr>>(header.t)}) {
-    CheckForImpureCall(GetExpr(*mask));
-  }
-}
-
-int AssignmentContext::GetIntegerKind(
-    const std::optional<parser::IntegerTypeSpec> &spec) {
-  std::optional<parser::KindSelector> empty;
-  evaluate::Expr<evaluate::SubscriptInteger> kind{AnalyzeKindSelector(
-      context_, TypeCategory::Integer, spec ? spec->v : empty)};
-  if (auto value{evaluate::ToInt64(kind)}) {
-    return static_cast<int>(*value);
-  } else {
-    context_.Say("Kind of INTEGER type must be a constant value"_err_en_US);
-    return context_.GetDefaultKind(TypeCategory::Integer);
-  }
-}
-
-void AssignmentContext::CheckForImpureCall(const SomeExpr &expr) {
-  if (forall_) {
-    const auto &intrinsics{context_.foldingContext().intrinsics()};
-    if (auto bad{FindImpureCall(intrinsics, expr)}) {
-      context_.Say(
-          "Impure procedure '%s' may not be referenced in a FORALL"_err_en_US,
-          *bad);
-    }
-  }
-}
-
-void AssignmentContext::CheckForImpureCall(const SomeExpr *expr) {
-  if (expr) {
-    CheckForImpureCall(*expr);
-  }
-}
-
 // C1594 checks
 static bool IsPointerDummyOfPureFunction(const Symbol &x) {
   return IsPointerDummy(x) && FindPureProcedureContaining(x.owner()) &&
@@ -449,18 +337,12 @@ MaskExpr AssignmentContext::GetMask(
     const parser::LogicalExpr &logicalExpr, bool defaultValue) {
   MaskExpr mask{defaultValue};
   if (const SomeExpr * expr{GetExpr(logicalExpr)}) {
-    CheckForImpureCall(*expr);
     auto *logical{std::get_if<evaluate::Expr<evaluate::SomeLogical>>(&expr->u)};
     mask = evaluate::ConvertTo(mask, common::Clone(DEREF(logical)));
   }
   return mask;
 }
 
-void AnalyzeConcurrentHeader(
-    SemanticsContext &context, const parser::ConcurrentHeader &header) {
-  AssignmentContext{context}.Analyze(header);
-}
-
 AssignmentChecker::~AssignmentChecker() {}
 
 AssignmentChecker::AssignmentChecker(SemanticsContext &context)
@@ -477,12 +359,6 @@ void AssignmentChecker::Enter(const parser::WhereStmt &x) {
 void AssignmentChecker::Enter(const parser::WhereConstruct &x) {
   context_.value().Analyze(x);
 }
-void AssignmentChecker::Enter(const parser::ForallStmt &x) {
-  context_.value().Analyze(x);
-}
-void AssignmentChecker::Enter(const parser::ForallConstruct &x) {
-  context_.value().Analyze(x);
-}
 
 }
 template class Fortran::common::Indirection<
diff --git a/lib/semantics/assignment.h b/lib/semantics/assignment.h
index 4bce8cb16dd5..d86bd45b1823 100644
--- a/lib/semantics/assignment.h
+++ b/lib/semantics/assignment.h
@@ -12,24 +12,20 @@
 #include "flang/common/indirection.h"
 #include "flang/evaluate/expression.h"
 #include "flang/semantics/semantics.h"
-#include "flang/semantics/tools.h"
-#include <string>
 
 namespace Fortran::parser {
-template<typename> struct Statement;
+class ContextualMessages;
 struct AssignmentStmt;
-struct ConcurrentHeader;
-struct ForallStmt;
 struct PointerAssignmentStmt;
-struct Program;
 struct WhereStmt;
 struct WhereConstruct;
-struct ForallConstruct;
 }
 
 namespace Fortran::semantics {
 
 class AssignmentContext;
+class Scope;
+class Symbol;
 
 // Applies checks from C1594(1-2) on definitions in pure subprograms
 void CheckDefinabilityInPureScope(parser::ContextualMessages &, const Symbol &,
@@ -46,18 +42,11 @@ class AssignmentChecker : public virtual BaseChecker {
   void Enter(const parser::PointerAssignmentStmt &);
   void Enter(const parser::WhereStmt &);
   void Enter(const parser::WhereConstruct &);
-  void Enter(const parser::ForallStmt &);
-  void Enter(const parser::ForallConstruct &);
 
 private:
   common::Indirection<AssignmentContext> context_;
 };
 
-// R1125 concurrent-header is used in FORALL statements & constructs as
-// well as in DO CONCURRENT loops.
-void AnalyzeConcurrentHeader(
-    SemanticsContext &, const parser::ConcurrentHeader &);
-
 }
 
 extern template class Fortran::common::Indirection<
diff --git a/lib/semantics/check-allocate.cpp b/lib/semantics/check-allocate.cpp
index 83f3ae9ebfc6..32ceb3805729 100644
--- a/lib/semantics/check-allocate.cpp
+++ b/lib/semantics/check-allocate.cpp
@@ -531,7 +531,7 @@ bool AllocationCheckerHelper::RunChecks(SemanticsContext &context) {
             "Allocatable object declared here with rank %d"_en_US, rank_);
     return false;
   }
-  context.CheckDoVarRedefine(name_);
+  context.CheckIndexVarRedefine(name_);
   return RunCoarrayRelatedChecks(context);
 }
 
diff --git a/lib/semantics/check-deallocate.cpp b/lib/semantics/check-deallocate.cpp
index 3f48fb4cd03f..6a0ea45ebb43 100644
--- a/lib/semantics/check-deallocate.cpp
+++ b/lib/semantics/check-deallocate.cpp
@@ -30,7 +30,7 @@ void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
                 context_.Say(name.source,
                     "name in DEALLOCATE statement must have the ALLOCATABLE or POINTER attribute"_err_en_US);
               } else {
-                context_.CheckDoVarRedefine(name);
+                context_.CheckIndexVarRedefine(name);
               }
             },
             [&](const parser::StructureComponent &structureComponent) {
diff --git a/lib/semantics/check-do.cpp b/lib/semantics/check-do.cpp
index 75acd1b887f6..10596c31cd21 100644
--- a/lib/semantics/check-do.cpp
+++ b/lib/semantics/check-do.cpp
@@ -34,13 +34,31 @@ namespace Fortran::semantics {
 using namespace parser::literals;
 
 using Bounds = parser::LoopControl::Bounds;
+using IndexVarKind = SemanticsContext::IndexVarKind;
 
-static const std::list<parser::ConcurrentControl> &GetControls(
+static const parser::ConcurrentHeader &GetConcurrentHeader(
     const parser::LoopControl &loopControl) {
   const auto &concurrent{
       std::get<parser::LoopControl::Concurrent>(loopControl.u)};
-  const auto &header{std::get<parser::ConcurrentHeader>(concurrent.t)};
-  return std::get<std::list<parser::ConcurrentControl>>(header.t);
+  return std::get<parser::ConcurrentHeader>(concurrent.t);
+}
+static const parser::ConcurrentHeader &GetConcurrentHeader(
+    const parser::ForallConstruct &construct) {
+  const auto &stmt{
+      std::get<parser::Statement<parser::ForallConstructStmt>>(construct.t)};
+  return std::get<common::Indirection<parser::ConcurrentHeader>>(
+      stmt.statement.t)
+      .value();
+}
+static const parser::ConcurrentHeader &GetConcurrentHeader(
+    const parser::ForallStmt &stmt) {
+  return std::get<common::Indirection<parser::ConcurrentHeader>>(stmt.t)
+      .value();
+}
+template<typename T>
+static const std::list<parser::ConcurrentControl> &GetControls(const T &x) {
+  return std::get<std::list<parser::ConcurrentControl>>(
+      GetConcurrentHeader(x).t);
 }
 
 static const Bounds &GetBounds(const parser::DoConstruct &doConstruct) {
@@ -366,10 +384,11 @@ class DoConcurrentVariableEnforce {
   const Scope &blockScope_;
 };  // class DoConcurrentVariableEnforce
 
-// Find a DO statement and enforce semantics checks on its body
+// Find a DO or FORALL and enforce semantics checks on its body
 class DoContext {
 public:
-  DoContext(SemanticsContext &context) : context_{context} {}
+  DoContext(SemanticsContext &context, IndexVarKind kind)
+    : context_{context}, kind_{kind} {}
 
   // Mark this DO construct as a point of definition for the DO variables
   // or index-names it contains.  If they're already defined, emit an error
@@ -378,13 +397,10 @@ class DoContext {
   // the DO construct and use its location in error messages.
   void DefineDoVariables(const parser::DoConstruct &doConstruct) {
     if (doConstruct.IsDoNormal()) {
-      context_.ActivateDoVariable(GetDoVariable(doConstruct));
+      context_.ActivateIndexVar(GetDoVariable(doConstruct), IndexVarKind::DO);
     } else if (doConstruct.IsDoConcurrent()) {
       if (const auto &loopControl{doConstruct.GetLoopControl()}) {
-        const auto &controls{GetControls(*loopControl)};
-        for (const parser::ConcurrentControl &control : controls) {
-          context_.ActivateDoVariable(std::get<parser::Name>(control.t));
-        }
+        ActivateIndexVars(GetControls(*loopControl));
       }
     }
   }
@@ -392,17 +408,26 @@ class DoContext {
   // Called at the end of a DO construct to deactivate the DO construct
   void ResetDoVariables(const parser::DoConstruct &doConstruct) {
     if (doConstruct.IsDoNormal()) {
-      context_.DeactivateDoVariable(GetDoVariable(doConstruct));
+      context_.DeactivateIndexVar(GetDoVariable(doConstruct));
     } else if (doConstruct.IsDoConcurrent()) {
       if (const auto &loopControl{doConstruct.GetLoopControl()}) {
-        const auto &controls{GetControls(*loopControl)};
-        for (const parser::ConcurrentControl &control : controls) {
-          context_.DeactivateDoVariable(std::get<parser::Name>(control.t));
-        }
+        DeactivateIndexVars(GetControls(*loopControl));
       }
     }
   }
 
+  void ActivateIndexVars(const std::list<parser::ConcurrentControl> &controls) {
+    for (const auto &control : controls) {
+      context_.ActivateIndexVar(std::get<parser::Name>(control.t), kind_);
+    }
+  }
+  void DeactivateIndexVars(
+      const std::list<parser::ConcurrentControl> &controls) {
+    for (const auto &control : controls) {
+      context_.DeactivateIndexVar(std::get<parser::Name>(control.t));
+    }
+  }
+
   void Check(const parser::DoConstruct &doConstruct) {
     if (doConstruct.IsDoConcurrent()) {
       CheckDoConcurrent(doConstruct);
@@ -415,6 +440,46 @@ class DoContext {
     // TODO: handle the other cases
   }
 
+  void Check(const parser::ForallStmt &stmt) {
+    CheckConcurrentHeader(GetConcurrentHeader(stmt));
+  }
+  void Check(const parser::ForallConstruct &construct) {
+    CheckConcurrentHeader(GetConcurrentHeader(construct));
+  }
+
+  void Check(const parser::ForallAssignmentStmt &stmt) {
+    const evaluate::Assignment *assignment{std::visit(
+        common::visitors{[&](const auto &x) { return GetAssignment(x); }},
+        stmt.u)};
+    if (assignment) {
+      CheckForImpureCall(assignment->lhs);
+      CheckForImpureCall(assignment->rhs);
+      if (const auto *proc{
+              std::get_if<evaluate::ProcedureRef>(&assignment->u)}) {
+        CheckForImpureCall(*proc);
+      }
+      std::visit(
+          common::visitors{
+              [](const evaluate::Assignment::Intrinsic &) {},
+              [&](const evaluate::ProcedureRef &proc) {
+                CheckForImpureCall(proc);
+              },
+              [&](const evaluate::Assignment::BoundsSpec &bounds) {
+                for (const auto &bound : bounds) {
+                  CheckForImpureCall(SomeExpr{bound});
+                }
+              },
+              [&](const evaluate::Assignment::BoundsRemapping &bounds) {
+                for (const auto &bound : bounds) {
+                  CheckForImpureCall(SomeExpr{bound.first});
+                  CheckForImpureCall(SomeExpr{bound.second});
+                }
+              },
+          },
+          assignment->u);
+    }
+  }
+
 private:
   void SayBadDoControl(parser::CharBlock sourceLocation) {
     context_.Say(sourceLocation, "DO controls should be INTEGER"_err_en_US);
@@ -493,11 +558,9 @@ class DoContext {
         "DO CONCURRENT"};
     parser::Walk(block, doConcurrentLabelEnforce);
 
-    const auto &loopControl{
-        std::get<std::optional<parser::LoopControl>>(doStmt.statement.t)};
-    const auto &concurrent{
-        std::get<parser::LoopControl::Concurrent>(loopControl->u)};
-    CheckConcurrentLoopControl(concurrent, block);
+    const auto &loopControl{doConstruct.GetLoopControl()};
+    CheckConcurrentLoopControl(*loopControl);
+    CheckLocalitySpecs(*loopControl, block);
   }
 
   // Return a set of symbols whose names are in a Local locality-spec.  Look
@@ -543,9 +606,9 @@ class DoContext {
     SymbolSet references{GatherSymbolsFromExpression(mask.thing.thing.value())};
     for (const Symbol &ref : references) {
       if (IsProcedure(ref) && !IsPureProcedure(ref)) {
-        context_.SayWithDecl(ref, currentStatementSourcePosition_,
-            "Concurrent-header mask expression cannot reference an impure"
-            " procedure"_err_en_US);
+        context_.SayWithDecl(ref, parser::Unwrap<parser::Expr>(mask)->source,
+            "%s mask expression may not reference impure procedure '%s'"_err_en_US,
+            LoopKindName(), ref.name());
         return;
       }
     }
@@ -556,8 +619,8 @@ class DoContext {
       const parser::CharBlock &refPosition) const {
     for (const Symbol &ref : refs) {
       if (uses.find(ref) != uses.end()) {
-        context_.SayWithDecl(
-            ref, refPosition, std::move(errorMessage), ref.name());
+        context_.SayWithDecl(ref, refPosition, std::move(errorMessage),
+            LoopKindName(), ref.name());
         return;
       }
     }
@@ -567,7 +630,7 @@ class DoContext {
       const SymbolSet &indexNames, const parser::ScalarIntExpr &expr) const {
     CheckNoCollisions(GatherSymbolsFromExpression(expr.thing.thing.value()),
         indexNames,
-        "concurrent-control expression references index-name '%s'"_err_en_US,
+        "%s limit expression may not reference index variable '%s'"_err_en_US,
         expr.thing.thing.value().source);
   }
 
@@ -576,7 +639,7 @@ class DoContext {
       const parser::ScalarLogicalExpr &mask, const SymbolSet &localVars) const {
     CheckNoCollisions(GatherSymbolsFromExpression(mask.thing.thing.value()),
         localVars,
-        "concurrent-header mask-expr references variable '%s'"
+        "%s mask expression references variable '%s'"
         " in LOCAL locality-spec"_err_en_US,
         mask.thing.thing.value().source);
   }
@@ -587,7 +650,7 @@ class DoContext {
       const parser::ScalarIntExpr &expr, const SymbolSet &localVars) const {
     CheckNoCollisions(GatherSymbolsFromExpression(expr.thing.thing.value()),
         localVars,
-        "concurrent-header expression references variable '%s'"
+        "%s expression references variable '%s'"
         " in LOCAL locality-spec"_err_en_US,
         expr.thing.thing.value().source);
   }
@@ -618,40 +681,47 @@ class DoContext {
 
   // C1123, concurrent limit or step expressions can't reference index-names
   void CheckConcurrentHeader(const parser::ConcurrentHeader &header) const {
+    if (const auto &mask{
+            std::get<std::optional<parser::ScalarLogicalExpr>>(header.t)}) {
+      CheckMaskIsPure(*mask);
+    }
     auto &controls{std::get<std::list<parser::ConcurrentControl>>(header.t)};
     SymbolSet indexNames;
-    for (const auto &c : controls) {
-      const auto &indexName{std::get<parser::Name>(c.t)};
+    for (const parser::ConcurrentControl &control : controls) {
+      const auto &indexName{std::get<parser::Name>(control.t)};
       if (indexName.symbol) {
         indexNames.insert(*indexName.symbol);
       }
     }
     if (!indexNames.empty()) {
-      for (const auto &c : controls) {
-        HasNoReferences(indexNames, std::get<1>(c.t));
-        HasNoReferences(indexNames, std::get<2>(c.t));
-        if (const auto &expr{
-                std::get<std::optional<parser::ScalarIntExpr>>(c.t)}) {
-          HasNoReferences(indexNames, *expr);
-          if (IsZero(*expr)) {
-            context_.Say(expr->thing.thing.value().source,
-                "DO CONCURRENT step expression should not be zero"_err_en_US);
+      for (const parser::ConcurrentControl &control : controls) {
+        HasNoReferences(indexNames, std::get<1>(control.t));
+        HasNoReferences(indexNames, std::get<2>(control.t));
+        if (const auto &intExpr{
+                std::get<std::optional<parser::ScalarIntExpr>>(control.t)}) {
+          const parser::Expr &expr{intExpr->thing.thing.value()};
+          CheckNoCollisions(GatherSymbolsFromExpression(expr), indexNames,
+              "%s step expression may not reference index variable '%s'"_err_en_US,
+              expr.source);
+          if (IsZero(expr)) {
+            context_.Say(expr.source,
+                "%s step expression may not be zero"_err_en_US, LoopKindName());
           }
         }
       }
     }
   }
 
-  void CheckLocalitySpecs(const parser::LoopControl::Concurrent &concurrent,
-      const parser::Block &block) const {
+  void CheckLocalitySpecs(
+      const parser::LoopControl &control, const parser::Block &block) const {
+    const auto &concurrent{
+        std::get<parser::LoopControl::Concurrent>(control.u)};
     const auto &header{std::get<parser::ConcurrentHeader>(concurrent.t)};
-    const auto &controls{
-        std::get<std::list<parser::ConcurrentControl>>(header.t)};
     const auto &localitySpecs{
         std::get<std::list<parser::LocalitySpec>>(concurrent.t)};
     if (!localitySpecs.empty()) {
       const SymbolSet &localVars{GatherLocals(localitySpecs)};
-      for (const auto &c : controls) {
+      for (const auto &c : GetControls(control)) {
         CheckExprDoesNotReferenceLocal(std::get<1>(c.t), localVars);
         CheckExprDoesNotReferenceLocal(std::get<2>(c.t), localVars);
         if (const auto &expr{
@@ -668,35 +738,66 @@ class DoContext {
   }
 
   // check constraints [C1121 .. C1130]
-  void CheckConcurrentLoopControl(
-      const parser::LoopControl::Concurrent &concurrent,
-      const parser::Block &block) const {
+  void CheckConcurrentLoopControl(const parser::LoopControl &control) const {
+    const auto &concurrent{
+        std::get<parser::LoopControl::Concurrent>(control.u)};
+    CheckConcurrentHeader(std::get<parser::ConcurrentHeader>(concurrent.t));
+  }
 
-    const auto &header{std::get<parser::ConcurrentHeader>(concurrent.t)};
-    const auto &mask{
-        std::get<std::optional<parser::ScalarLogicalExpr>>(header.t)};
-    if (mask) {
-      CheckMaskIsPure(*mask);
+  template<typename T> void CheckForImpureCall(const T &x) {
+    const auto &intrinsics{context_.foldingContext().intrinsics()};
+    if (auto bad{FindImpureCall(intrinsics, x)}) {
+      context_.Say(
+          "Impure procedure '%s' may not be referenced in a %s"_err_en_US, *bad,
+          LoopKindName());
     }
-    CheckConcurrentHeader(header);
-    CheckLocalitySpecs(concurrent, block);
+  }
+
+  // For messages where the DO loop must be DO CONCURRENT, make that explicit.
+  const char *LoopKindName() const {
+    return kind_ == IndexVarKind::DO ? "DO CONCURRENT" : "FORALL";
   }
 
   SemanticsContext &context_;
+  const IndexVarKind kind_;
   parser::CharBlock currentStatementSourcePosition_;
 };  // class DoContext
 
 void DoChecker::Enter(const parser::DoConstruct &doConstruct) {
-  DoContext doContext{context_};
+  DoContext doContext{context_, IndexVarKind::DO};
   doContext.DefineDoVariables(doConstruct);
 }
 
 void DoChecker::Leave(const parser::DoConstruct &doConstruct) {
-  DoContext doContext{context_};
+  DoContext doContext{context_, IndexVarKind::DO};
   doContext.Check(doConstruct);
   doContext.ResetDoVariables(doConstruct);
 }
 
+void DoChecker::Enter(const parser::ForallConstruct &construct) {
+  DoContext doContext{context_, IndexVarKind::FORALL};
+  doContext.ActivateIndexVars(GetControls(construct));
+}
+void DoChecker::Leave(const parser::ForallConstruct &construct) {
+  DoContext doContext{context_, IndexVarKind::FORALL};
+  doContext.Check(construct);
+  doContext.DeactivateIndexVars(GetControls(construct));
+}
+
+void DoChecker::Enter(const parser::ForallStmt &stmt) {
+  DoContext doContext{context_, IndexVarKind::FORALL};
+  doContext.ActivateIndexVars(GetControls(stmt));
+}
+void DoChecker::Leave(const parser::ForallStmt &stmt) {
+  DoContext doContext{context_, IndexVarKind::FORALL};
+  doContext.Check(stmt);
+  doContext.DeactivateIndexVars(GetControls(stmt));
+}
+void DoChecker::Leave(const parser::ForallAssignmentStmt &stmt) {
+  DoContext doContext{context_, IndexVarKind::FORALL};
+  doContext.Check(stmt);
+}
+
 // Return the (possibly null) name of the ConstructNode
 static const parser::Name *MaybeGetNodeName(const ConstructNode &construct) {
   return std::visit(
@@ -819,7 +920,7 @@ void DoChecker::Enter(const parser::ExitStmt &exitStmt) {
 
 void DoChecker::Leave(const parser::AssignmentStmt &stmt) {
   const auto &variable{std::get<parser::Variable>(stmt.t)};
-  context_.CheckDoVarRedefine(variable);
+  context_.CheckIndexVarRedefine(variable);
 }
 
 static void CheckIfArgIsDoVar(const evaluate::ActualArgument &arg,
@@ -829,9 +930,9 @@ static void CheckIfArgIsDoVar(const evaluate::ActualArgument &arg,
     if (const SomeExpr * argExpr{arg.UnwrapExpr()}) {
       if (const Symbol * var{evaluate::UnwrapWholeSymbolDataRef(*argExpr)}) {
         if (intent == common::Intent::Out) {
-          context.CheckDoVarRedefine(location, *var);
+          context.CheckIndexVarRedefine(location, *var);
         } else {
-          context.WarnDoVarRedefine(location, *var);  // INTENT(INOUT)
+          context.WarnIndexVarRedefine(location, *var);  // INTENT(INOUT)
         }
       }
     }
@@ -873,7 +974,7 @@ void DoChecker::Leave(const parser::ConnectSpec &connectSpec) {
   const auto *newunit{
       std::get_if<parser::ConnectSpec::Newunit>(&connectSpec.u)};
   if (newunit) {
-    context_.CheckDoVarRedefine(newunit->v.thing.thing);
+    context_.CheckIndexVarRedefine(newunit->v.thing.thing);
   }
 }
 
@@ -909,25 +1010,25 @@ void DoChecker::Leave(const parser::InquireSpec &inquireSpec) {
   const auto *intVar{std::get_if<parser::InquireSpec::IntVar>(&inquireSpec.u)};
   if (intVar) {
     const auto &scalar{std::get<parser::ScalarIntVariable>(intVar->t)};
-    context_.CheckDoVarRedefine(scalar.thing.thing);
+    context_.CheckIndexVarRedefine(scalar.thing.thing);
   }
 }
 
 void DoChecker::Leave(const parser::IoControlSpec &ioControlSpec) {
   const auto *size{std::get_if<parser::IoControlSpec::Size>(&ioControlSpec.u)};
   if (size) {
-    context_.CheckDoVarRedefine(size->v.thing.thing);
+    context_.CheckIndexVarRedefine(size->v.thing.thing);
   }
 }
 
 void DoChecker::Leave(const parser::OutputImpliedDo &outputImpliedDo) {
   const auto &control{std::get<parser::IoImpliedDoControl>(outputImpliedDo.t)};
   const parser::Name &name{control.name.thing.thing};
-  context_.CheckDoVarRedefine(name.source, *name.symbol);
+  context_.CheckIndexVarRedefine(name.source, *name.symbol);
 }
 
 void DoChecker::Leave(const parser::StatVariable &statVariable) {
-  context_.CheckDoVarRedefine(statVariable.v.thing.thing);
+  context_.CheckIndexVarRedefine(statVariable.v.thing.thing);
 }
 
 }  // namespace Fortran::semantics
diff --git a/lib/semantics/check-do.h b/lib/semantics/check-do.h
index 03d8c75212b1..fb3a4be9b082 100644
--- a/lib/semantics/check-do.h
+++ b/lib/semantics/check-do.h
@@ -20,6 +20,9 @@ struct CycleStmt;
 struct DoConstruct;
 struct ExitStmt;
 struct Expr;
+struct ForallAssignmentStmt;
+struct ForallConstruct;
+struct ForallStmt;
 struct InquireSpec;
 struct IoControlSpec;
 struct OutputImpliedDo;
@@ -40,6 +43,11 @@ class DoChecker : public virtual BaseChecker {
   void Enter(const parser::CycleStmt &);
   void Enter(const parser::DoConstruct &);
   void Leave(const parser::DoConstruct &);
+  void Enter(const parser::ForallConstruct &);
+  void Leave(const parser::ForallConstruct &);
+  void Enter(const parser::ForallStmt &);
+  void Leave(const parser::ForallStmt &);
+  void Leave(const parser::ForallAssignmentStmt &s);
   void Enter(const parser::ExitStmt &);
   void Leave(const parser::Expr &);
   void Leave(const parser::InquireSpec &);
diff --git a/lib/semantics/check-io.cpp b/lib/semantics/check-io.cpp
index 6f824a3164a1..abbf915b675f 100644
--- a/lib/semantics/check-io.cpp
+++ b/lib/semantics/check-io.cpp
@@ -509,7 +509,7 @@ static void CheckForDoVariableInNamelist(const Symbol &namelist,
     SemanticsContext &context, parser::CharBlock namelistLocation) {
   const auto &details{namelist.GetUltimate().get<NamelistDetails>()};
   for (const Symbol &object : details.objects()) {
-    context.CheckDoVarRedefine(namelistLocation, object);
+    context.CheckIndexVarRedefine(namelistLocation, object);
   }
 }
 
@@ -532,7 +532,7 @@ static void CheckForDoVariable(
   for (const auto &item : items) {
     if (const parser::Variable *
         variable{std::get_if<parser::Variable>(&item.u)}) {
-      context.CheckDoVarRedefine(*variable);
+      context.CheckIndexVarRedefine(*variable);
     }
   }
 }
diff --git a/lib/semantics/semantics.cpp b/lib/semantics/semantics.cpp
index 8c5bece6f72e..c6353a7b0d44 100644
--- a/lib/semantics/semantics.cpp
+++ b/lib/semantics/semantics.cpp
@@ -203,78 +203,63 @@ void SemanticsContext::PopConstruct() {
   constructStack_.pop_back();
 }
 
-void SemanticsContext::CheckDoVarRedefine(const parser::CharBlock &location,
+void SemanticsContext::CheckIndexVarRedefine(const parser::CharBlock &location,
     const Symbol &variable, parser::MessageFixedText &&message) {
   if (const Symbol * root{GetAssociationRoot(variable)}) {
-    if (IsActiveDoVariable(*root)) {
-      parser::CharBlock doLoc{GetDoVariableLocation(*root)};
-      CHECK(doLoc != parser::CharBlock{});
-      Say(location, std::move(message), root->name())
-          .Attach(doLoc, "Enclosing DO construct"_en_US);
+    auto it{activeIndexVars_.find(*root)};
+    if (it != activeIndexVars_.end()) {
+      std::string kind{EnumToString(it->second.kind)};
+      Say(location, std::move(message), kind, root->name())
+          .Attach(it->second.location, "Enclosing %s construct"_en_US, kind);
     }
   }
 }
 
-void SemanticsContext::WarnDoVarRedefine(
+void SemanticsContext::WarnIndexVarRedefine(
     const parser::CharBlock &location, const Symbol &variable) {
-  CheckDoVarRedefine(
-      location, variable, "Possible redefinition of DO variable '%s'"_en_US);
+  CheckIndexVarRedefine(
+      location, variable, "Possible redefinition of %s variable '%s'"_en_US);
 }
 
-void SemanticsContext::CheckDoVarRedefine(
+void SemanticsContext::CheckIndexVarRedefine(
     const parser::CharBlock &location, const Symbol &variable) {
-  CheckDoVarRedefine(
-      location, variable, "Cannot redefine DO variable '%s'"_err_en_US);
+  CheckIndexVarRedefine(
+      location, variable, "Cannot redefine %s variable '%s'"_err_en_US);
 }
 
-void SemanticsContext::CheckDoVarRedefine(const parser::Variable &variable) {
+void SemanticsContext::CheckIndexVarRedefine(const parser::Variable &variable) {
   if (const Symbol * entity{GetLastName(variable).symbol}) {
-    const parser::CharBlock &sourceLocation{variable.GetSource()};
-    CheckDoVarRedefine(sourceLocation, *entity);
+    CheckIndexVarRedefine(variable.GetSource(), *entity);
   }
 }
 
-void SemanticsContext::CheckDoVarRedefine(const parser::Name &name) {
-  const parser::CharBlock &sourceLocation{name.source};
+void SemanticsContext::CheckIndexVarRedefine(const parser::Name &name) {
   if (const Symbol * entity{name.symbol}) {
-    CheckDoVarRedefine(sourceLocation, *entity);
+    CheckIndexVarRedefine(name.source, *entity);
   }
 }
 
-void SemanticsContext::ActivateDoVariable(const parser::Name &name) {
-  CheckDoVarRedefine(name);
-  if (const Symbol * doVariable{name.symbol}) {
-    if (const Symbol * root{GetAssociationRoot(*doVariable)}) {
-      if (!IsActiveDoVariable(*root)) {
-        activeDoVariables_.emplace(*root, name.source);
-      }
+void SemanticsContext::ActivateIndexVar(
+    const parser::Name &name, IndexVarKind kind) {
+  CheckIndexVarRedefine(name);
+  if (const Symbol * indexVar{name.symbol}) {
+    if (const Symbol * root{GetAssociationRoot(*indexVar)}) {
+      activeIndexVars_.emplace(*root, IndexVarInfo{name.source, kind});
     }
   }
 }
 
-void SemanticsContext::DeactivateDoVariable(const parser::Name &name) {
-  if (Symbol * doVariable{name.symbol}) {
-    if (const Symbol * root{GetAssociationRoot(*doVariable)}) {
-      if (name.source == GetDoVariableLocation(*root)) {
-        activeDoVariables_.erase(*root);
+void SemanticsContext::DeactivateIndexVar(const parser::Name &name) {
+  if (Symbol * indexVar{name.symbol}) {
+    if (const Symbol * root{GetAssociationRoot(*indexVar)}) {
+      auto it{activeIndexVars_.find(*root)};
+      if (it != activeIndexVars_.end() && it->second.location == name.source) {
+        activeIndexVars_.erase(it);
       }
     }
   }
 }
 
-bool SemanticsContext::IsActiveDoVariable(const Symbol &variable) {
-  return activeDoVariables_.find(variable) != activeDoVariables_.end();
-}
-
-parser::CharBlock SemanticsContext::GetDoVariableLocation(
-    const Symbol &variable) {
-  if (IsActiveDoVariable(variable)) {
-    return activeDoVariables_[variable];
-  } else {
-    return parser::CharBlock{};
-  }
-}
-
 bool Semantics::Perform() {
   return ValidateLabels(context_, program_) &&
       parser::CanonicalizeDo(program_) &&  // force line break
diff --git a/test/semantics/call11.f90 b/test/semantics/call11.f90
index 061b73d2d374..254566fa38b8 100644
--- a/test/semantics/call11.f90
+++ b/test/semantics/call11.f90
@@ -36,7 +36,7 @@ subroutine test
       !ERROR: Impure procedure 'impure' may not be referenced in a FORALL
       a(j) = pure(impure(j)) ! C1037
     end forall
-    !ERROR: Concurrent-header mask expression cannot reference an impure procedure
+    !ERROR: DO CONCURRENT mask expression may not reference impure procedure 'impure'
     do concurrent (j=1:1, impure(j) /= 0) ! C1121
       !ERROR: Call to an impure procedure is not allowed in DO CONCURRENT
       a(j) = impure(j) ! C1139
@@ -58,7 +58,7 @@ subroutine test2
     do concurrent (j=1:1, x%tbp_pure(j) /= 0) ! ok
       a(j) = x%tbp_pure(j) ! ok
     end do
-    !ERROR: Concurrent-header mask expression cannot reference an impure procedure
+    !ERROR: DO CONCURRENT mask expression may not reference impure procedure 'impure'
     do concurrent (j=1:1, x%tbp_impure(j) /= 0) ! C1121
       !ERROR: Call to an impure procedure component is not allowed in DO CONCURRENT
       a(j) = x%tbp_impure(j) ! C1139
diff --git a/test/semantics/dosemantics02.f90 b/test/semantics/dosemantics02.f90
index 0e7c23c97bc0..0b3165a88270 100644
--- a/test/semantics/dosemantics02.f90
+++ b/test/semantics/dosemantics02.f90
@@ -6,7 +6,7 @@
 SUBROUTINE do_concurrent_c1121(i,n)
   IMPLICIT NONE
   INTEGER :: i, n, flag
-!ERROR: Concurrent-header mask expression cannot reference an impure procedure
+  !ERROR: DO CONCURRENT mask expression may not reference impure procedure 'random'
   DO CONCURRENT (i = 1:n, random() < 3)
     flag = 3
   END DO
@@ -30,12 +30,12 @@ SUBROUTINE s1()
   20 CONTINUE
 
   ! Error, no compatibility requirement for DO CONCURRENT
-!ERROR: DO CONCURRENT step expression should not be zero
+  !ERROR: DO CONCURRENT step expression may not be zero
   DO CONCURRENT (I = 1 : 10 : 0)
   END DO
 
   ! Error, this time with an integer constant
-!ERROR: DO CONCURRENT step expression should not be zero
+  !ERROR: DO CONCURRENT step expression may not be zero
   DO CONCURRENT (I = 1 : 10 : constInt)
   END DO
 end subroutine s1
diff --git a/test/semantics/dosemantics04.f90 b/test/semantics/dosemantics04.f90
index 5b9b5f4b01a9..7c0743517f17 100644
--- a/test/semantics/dosemantics04.f90
+++ b/test/semantics/dosemantics04.f90
@@ -4,32 +4,32 @@ PROGRAM dosemantics04
   IMPLICIT NONE
   INTEGER :: a, i, j, k, n
 
-!ERROR: concurrent-header mask-expr references variable 'n' in LOCAL locality-spec
+  !ERROR: DO CONCURRENT mask expression references variable 'n' in LOCAL locality-spec
   DO CONCURRENT (INTEGER *2 :: i = 1:10, i < j + n) LOCAL(n)
     PRINT *, "hello"
   END DO
 
-!ERROR: concurrent-header mask-expr references variable 'a' in LOCAL locality-spec
+  !ERROR: DO CONCURRENT mask expression references variable 'a' in LOCAL locality-spec
   DO 30 CONCURRENT (i = 1:n:1, j=1:n:2, k=1:n:3, a<3) LOCAL (a)
     PRINT *, "hello"
 30 END DO
 
 ! Initial expression
-!ERROR: concurrent-control expression references index-name 'j'
+  !ERROR: DO CONCURRENT limit expression may not reference index variable 'j'
   DO CONCURRENT (i = j:3, j=1:3)
   END DO
 
 ! Final expression
-!ERROR: concurrent-control expression references index-name 'j'
+  !ERROR: DO CONCURRENT limit expression may not reference index variable 'j'
   DO CONCURRENT (i = 1:j, j=1:3)
   END DO
 
 ! Step expression
-!ERROR: concurrent-control expression references index-name 'j'
+  !ERROR: DO CONCURRENT step expression may not reference index variable 'j'
   DO CONCURRENT (i = 1:3:j, j=1:3)
   END DO
 
-!ERROR: concurrent-control expression references index-name 'i'
+  !ERROR: DO CONCURRENT limit expression may not reference index variable 'i'
   DO CONCURRENT (INTEGER*2 :: i = 1:3, j=i:3)
   END DO
 
diff --git a/test/semantics/dosemantics05.f90 b/test/semantics/dosemantics05.f90
index 9f5f71ee478e..c7e27d53aec4 100644
--- a/test/semantics/dosemantics05.f90
+++ b/test/semantics/dosemantics05.f90
@@ -47,7 +47,7 @@ subroutine s1()
   end associate
   
   associate (avar => ivar)
-!ERROR: DO CONCURRENT step expression should not be zero
+!ERROR: DO CONCURRENT step expression may not be zero
     do concurrent (i = 1:2:0) default(none) shared(jvar) local(kvar)
 !ERROR: Variable 'ivar' from an enclosing scope referenced in DO CONCURRENT with DEFAULT(NONE) must appear in a locality-spec
       ivar =  &
diff --git a/test/semantics/dosemantics09.f90 b/test/semantics/dosemantics09.f90
index 8a4ef4741af0..425e71e3db54 100644
--- a/test/semantics/dosemantics09.f90
+++ b/test/semantics/dosemantics09.f90
@@ -18,7 +18,7 @@ subroutine s2()
 end subroutine s2
 
 subroutine s4()
-!ERROR: concurrent-header expression references variable 'i' in LOCAL locality-spec
+!ERROR: DO CONCURRENT expression references variable 'i' in LOCAL locality-spec
   do concurrent (j=i:10) local(i)
   end do
 end subroutine s4
@@ -36,7 +36,7 @@ subroutine s6()
 end subroutine s6
 
 subroutine s7()
-!ERROR: concurrent-header expression references variable 'i' in LOCAL locality-spec
+!ERROR: DO CONCURRENT expression references variable 'i' in LOCAL locality-spec
   do concurrent (j=1:i) local(i)
   end do
 end subroutine s7
@@ -54,7 +54,7 @@ subroutine s9()
 end subroutine s9
 
 subroutine s10()
-!ERROR: concurrent-header expression references variable 'i' in LOCAL locality-spec
+!ERROR: DO CONCURRENT expression references variable 'i' in LOCAL locality-spec
   do concurrent (j=1:10:i) local(i)
   end do
 end subroutine s10
@@ -75,7 +75,7 @@ subroutine s13()
   ! Test construct-association, in this case, established by the "shared"
   integer :: ivar
   associate (avar => ivar)
-!ERROR: concurrent-header expression references variable 'ivar' in LOCAL locality-spec
+!ERROR: DO CONCURRENT expression references variable 'ivar' in LOCAL locality-spec
     do concurrent (j=1:10:avar) local(avar)
     end do
   end associate
@@ -88,7 +88,7 @@ subroutine s14()
   ! Test use-association, in this case, established by the "shared"
   use m1
 
-!ERROR: concurrent-header expression references variable 'mvar' in LOCAL locality-spec
+!ERROR: DO CONCURRENT expression references variable 'mvar' in LOCAL locality-spec
   do concurrent (k=mvar:10) local(mvar)
   end do
 end subroutine s14
@@ -98,7 +98,7 @@ subroutine s15()
   ! locality-spec
   ivar = 3
   do concurrent (j=ivar:10) shared(ivar)
-!ERROR: concurrent-header expression references variable 'ivar' in LOCAL locality-spec
+!ERROR: DO CONCURRENT expression references variable 'ivar' in LOCAL locality-spec
     do concurrent (k=ivar:10) local(ivar)
     end do
   end do
diff --git a/test/semantics/forall01.f90 b/test/semantics/forall01.f90
index aa509b0125d6..bd665e2a5283 100644
--- a/test/semantics/forall01.f90
+++ b/test/semantics/forall01.f90
@@ -1,14 +1,22 @@
 subroutine forall1
   real :: a(9)
   !ERROR: 'i' is already declared in this scoping unit
+  !ERROR: Cannot redefine FORALL variable 'i'
   forall (i=1:8, i=1:9)  a(i) = i
+  !ERROR: 'i' is already declared in this scoping unit
+  !ERROR: Cannot redefine FORALL variable 'i'
+  forall (i=1:8, i=1:9)
+    a(i) = i
+  end forall
   forall (j=1:8)
     !ERROR: 'j' is already declared in this scoping unit
+    !ERROR: Cannot redefine FORALL variable 'j'
     forall (j=1:9)
     end forall
   end forall
 end
 
+
 subroutine forall2
   integer, pointer :: a(:)
   integer, target :: b(10,10)
@@ -16,8 +24,52 @@ subroutine forall2
     !ERROR: Impure procedure 'f_impure' may not be referenced in a FORALL
     a(f_impure(i):) => b(i,:)
   end forall
+  !ERROR: FORALL mask expression may not reference impure procedure 'f_impure'
+  forall (j=1:10, f_impure(1)>2)
+  end forall
 contains
   impure integer function f_impure(i)
     f_impure = i
   end
 end
+
+subroutine forall3
+  real :: x
+  forall(i=1:10)
+    !ERROR: Cannot redefine FORALL variable 'i'
+    i = 1
+  end forall
+  forall(i=1:10)
+    forall(j=1:10)
+      !ERROR: Cannot redefine FORALL variable 'i'
+      i = 1
+    end forall
+  end forall
+  !ERROR: Cannot redefine FORALL variable 'i'
+  forall(i=1:10) i = 1
+end
+
+subroutine forall4
+  integer, parameter :: zero = 0
+  integer :: a(10)
+
+  !ERROR: FORALL limit expression may not reference index variable 'i'
+  forall(i=1:i)
+    a(i) = i
+  end forall
+  !ERROR: FORALL step expression may not reference index variable 'i'
+  forall(i=1:10:i)
+    a(i) = i
+  end forall
+  !ERROR: FORALL step expression may not be zero
+  forall(i=1:10:zero)
+    a(i) = i
+  end forall
+
+  !ERROR: FORALL limit expression may not reference index variable 'i'
+  forall(i=1:i) a(i) = i
+  !ERROR: FORALL step expression may not reference index variable 'i'
+  forall(i=1:10:i) a(i) = i
+  !ERROR: FORALL step expression may not be zero
+  forall(i=1:10:zero) a(i) = i
+end
diff --git a/test/semantics/resolve35.f90 b/test/semantics/resolve35.f90
index bb93ab98131b..2598d9ca82e8 100644
--- a/test/semantics/resolve35.f90
+++ b/test/semantics/resolve35.f90
@@ -50,14 +50,6 @@ subroutine s4
   end forall
 end
 
-subroutine s5
-  real :: a(10), b(10)
-  !ERROR: 'i' is already declared in this scoping unit
-  forall(i=1:10, i=1:10)
-    a(i) = b(i)
-  end forall
-end
-
 subroutine s6
   integer, parameter :: n = 4
   real, dimension(n) :: x

From bbbbe9c1aa2fd38dc2164a6440290dbbea1518e2 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 19 Feb 2020 05:19:08 -0800
Subject: [PATCH 034/345] Fix issues with -DBUILD_SHARED_LIBS=On

This re-ordering allows building f18 with shared library using and LLVM build
with static libraries.

This reordering (that also made sens form an alphabetical point of view)
works here to do such "shared+archive" compiling because the current
dependency on LLVM is simple (only one f18 lib + an executable depends on LLVM).
As soon as two f18 libraries will depend on LLVM, one will have to use an LLVM
version built with -DBUILD_SHARED_LIBS=On if one wants to use this option
to compile f18.
---
 tools/f18/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/f18/CMakeLists.txt b/tools/f18/CMakeLists.txt
index 79f5c52d6a6c..b2f8e129e83a 100644
--- a/tools/f18/CMakeLists.txt
+++ b/tools/f18/CMakeLists.txt
@@ -18,8 +18,8 @@ target_link_libraries(f18
   FortranParser
   FortranEvaluate
   FortranSemantics
-  LLVMSupport
   FortranLower
+  LLVMSupport
 )
 
 add_executable(f18-parse-demo

From 4a703f2b5a6484208a059dc0b456363c138a661d Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Fri, 14 Feb 2020 15:53:11 -0800
Subject: [PATCH 035/345] Semantic checks for C709, C710, and C711

C709 An assumed-type entity shall be a dummy data object that does not
have the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE
attribute and is not an explicit-shape array.

C710 An assumed-type variable name shall not appear in a designator or
expression except as an actual argument corresponding to a dummy
argument that is assumed-type, or as the first argument to the intrinsic
function IS_CONTIGUOUS, LBOUND, PRESENT, RANK, SHAPE, SIZE, or UBOUND,
or the function C_LOC from the intrinsic module ISO_C_BINDING.

C711 An assumed-type actual argument that corresponds to an assumed-rank
dummy argument shall be assumed-shape or assumed-rank.

For C709 I added code to check-declarations.cpp.  For this, I had to
distinguish between polymorphic types and assumed-type types to
eliminate multiple messages on the same line.

C710 was already checked, but I added a notation in the source.

For C711 I added code to check-call.cpp and the test call15.f90.
---
 include/flang/semantics/type.h       |  3 ++
 lib/semantics/check-call.cpp         | 20 +++++++++---
 lib/semantics/check-declarations.cpp | 49 +++++++++++++++++++++++++++-
 lib/semantics/expression.cpp         |  2 +-
 module/iso_c_binding.f90             |  2 +-
 test/semantics/CMakeLists.txt        |  2 ++
 test/semantics/call15.f90            | 17 ++++++++++
 test/semantics/modfile12.f90         |  8 +++--
 test/semantics/resolve72.f90         | 25 ++++++++++++++
 9 files changed, 119 insertions(+), 9 deletions(-)
 create mode 100644 test/semantics/call15.f90
 create mode 100644 test/semantics/resolve72.f90

diff --git a/include/flang/semantics/type.h b/include/flang/semantics/type.h
index 19d02000c45c..bbd5f47f3a0d 100644
--- a/include/flang/semantics/type.h
+++ b/include/flang/semantics/type.h
@@ -327,6 +327,9 @@ class DeclTypeSpec {
   bool IsUnlimitedPolymorphic() const {
     return category_ == TypeStar || category_ == ClassStar;
   }
+  bool IsAssumedType() const {
+    return category_ == TypeStar;
+  }
   bool IsNumeric(TypeCategory) const;
   const NumericTypeSpec &numericTypeSpec() const;
   const LogicalTypeSpec &logicalTypeSpec() const;
diff --git a/lib/semantics/check-call.cpp b/lib/semantics/check-call.cpp
index 2afd00f4627e..f03f30e14d5e 100644
--- a/lib/semantics/check-call.cpp
+++ b/lib/semantics/check-call.cpp
@@ -610,11 +610,23 @@ static void CheckExplicitInterfaceArg(evaluate::ActualArgument &arg,
                 messages.Say(
                     "Actual argument is not a variable or typed expression"_err_en_US);
               }
-            } else if (!object.type.type().IsAssumedType()) {
+            } else {
               const Symbol &assumed{DEREF(arg.GetAssumedTypeDummy())};
-              messages.Say(
-                  "Assumed-type TYPE(*) '%s' may be associated only with an assumed-TYPE(*) %s"_err_en_US,
-                  assumed.name(), dummyName);
+              if (!object.type.type().IsAssumedType()) {
+                messages.Say(
+                    "Assumed-type TYPE(*) '%s' may be associated only with an"
+                    " assumed-TYPE(*) %s"_err_en_US,
+                    assumed.name(), dummyName);
+              } else if (const auto *details{
+                             assumed.detailsIf<ObjectEntityDetails>()}) {
+                if (!(details->IsAssumedShape() || details->IsAssumedRank())) {
+                  messages.Say(  // C711
+                      "Assumed-type TYPE(*) '%s' must be either assumed "
+                      "shape or assumed rank to be associated with TYPE(*) "
+                      "%s"_err_en_US,
+                      assumed.name(), dummyName);
+                }
+              }
             }
           },
           [&](const characteristics::DummyProcedure &proc) {
diff --git a/lib/semantics/check-declarations.cpp b/lib/semantics/check-declarations.cpp
index 57f4d788bcc7..7c27fcba91d1 100644
--- a/lib/semantics/check-declarations.cpp
+++ b/lib/semantics/check-declarations.cpp
@@ -59,6 +59,7 @@ class CheckHelper {
   void CheckObjectEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckArraySpec(const Symbol &, const ArraySpec &);
   void CheckProcEntity(const Symbol &, const ProcEntityDetails &);
+  void CheckAssumedTypeEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckDerivedType(const Symbol &, const DerivedTypeDetails &);
   void CheckGeneric(const Symbol &, const GenericDetails &);
   std::optional<std::vector<Procedure>> Characterize(const SymbolVector &);
@@ -293,11 +294,56 @@ void CheckHelper::CheckValue(
   }
 }
 
+void CheckHelper::CheckAssumedTypeEntity(  // C709
+    const Symbol &symbol, const ObjectEntityDetails &details) {
+  if (const DeclTypeSpec * type{symbol.GetType()};
+      type && type->category() == DeclTypeSpec::TypeStar) {
+    if (!symbol.IsDummy()) {
+      messages_.Say(
+          "Assumed-type entity '%s' must be a dummy argument"_err_en_US,
+          symbol.name());
+    } else {
+      if (symbol.attrs().test(Attr::ALLOCATABLE)) {
+        messages_.Say("Assumed-type argument '%s' cannot have the ALLOCATABLE"
+                      " attribute"_err_en_US,
+            symbol.name());
+      }
+      if (symbol.attrs().test(Attr::POINTER)) {
+        messages_.Say("Assumed-type argument '%s' cannot have the POINTER"
+                      " attribute"_err_en_US,
+            symbol.name());
+      }
+      if (symbol.attrs().test(Attr::VALUE)) {
+        messages_.Say("Assumed-type argument '%s' cannot have the VALUE"
+                      " attribute"_err_en_US,
+            symbol.name());
+      }
+      if (symbol.attrs().test(Attr::INTENT_OUT)) {
+        messages_.Say(
+            "Assumed-type argument '%s' cannot be INTENT(OUT)"_err_en_US,
+            symbol.name());
+      }
+      if (IsCoarray(symbol)) {
+        messages_.Say(
+            "Assumed-type argument '%s' cannot be a coarray"_err_en_US,
+            symbol.name());
+      }
+      if (details.IsArray() &&
+          !(details.IsAssumedShape() || details.IsAssumedSize())) {
+        messages_.Say("Assumed-type argument '%s' must be assumed shape"
+                      " or assumed size array"_err_en_US,
+            symbol.name());
+      }
+    }
+  }
+}
+
 void CheckHelper::CheckObjectEntity(
     const Symbol &symbol, const ObjectEntityDetails &details) {
   CheckArraySpec(symbol, details.shape());
   Check(details.shape());
   Check(details.coshape());
+  CheckAssumedTypeEntity(symbol, details);
   if (!details.coshape().empty()) {
     if (IsAllocatable(symbol)) {
       if (!details.coshape().IsDeferredShape()) {  // C827
@@ -373,7 +419,8 @@ void CheckHelper::CheckObjectEntity(
   }
   if (const DeclTypeSpec * type{details.type()}) {  // C708
     if (type->IsPolymorphic() &&
-        !(IsAllocatableOrPointer(symbol) || symbol.IsDummy())) {
+        !(type->IsAssumedType() || IsAllocatableOrPointer(symbol) ||
+            symbol.IsDummy())) {
       messages_.Say("CLASS entity '%s' must be a dummy argument or have "
                     "ALLOCATABLE or POINTER attribute"_err_en_US,
           symbol.name());
diff --git a/lib/semantics/expression.cpp b/lib/semantics/expression.cpp
index 59593ae90e8f..32e6692bce95 100644
--- a/lib/semantics/expression.cpp
+++ b/lib/semantics/expression.cpp
@@ -2344,7 +2344,7 @@ MaybeExpr ExpressionAnalyzer::ExprOrVariable(const PARSED &x) {
   if (!x.typedExpr) {
     FixMisparsedFunctionReference(context_, x.u);
     MaybeExpr result;
-    if (AssumedTypeDummy(x)) {
+    if (AssumedTypeDummy(x)) {  // C710
       Say("TYPE(*) dummy argument may only be used as an actual argument"_err_en_US);
     } else {
       if constexpr (std::is_same_v<PARSED, parser::Expr>) {
diff --git a/module/iso_c_binding.f90 b/module/iso_c_binding.f90
index 7d7a5a29da9e..d1cb001c2a54 100644
--- a/module/iso_c_binding.f90
+++ b/module/iso_c_binding.f90
@@ -91,7 +91,7 @@ end function c_associated
 
   function c_loc(x)
     type(c_ptr) :: c_loc
-    type(*), intent(in) :: x
+    type(*), dimension(:), intent(in) :: x
     c_loc = c_ptr(loc(x))
   end function c_loc
 
diff --git a/test/semantics/CMakeLists.txt b/test/semantics/CMakeLists.txt
index c29282442cd9..7d6ca5fe79e0 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/semantics/CMakeLists.txt
@@ -102,6 +102,7 @@ set(ERROR_TESTS
   resolve69.f90
   resolve70.f90
   resolve71.f90
+  resolve72.f90
   stop01.f90
   structconst01.f90
   structconst02.f90
@@ -195,6 +196,7 @@ set(ERROR_TESTS
   call12.f90
   call13.f90
   call14.f90
+  call15.f90
   forall01.f90
   misc-declarations.f90
   separate-module-procs.f90
diff --git a/test/semantics/call15.f90 b/test/semantics/call15.f90
new file mode 100644
index 000000000000..204a0e6c6237
--- /dev/null
+++ b/test/semantics/call15.f90
@@ -0,0 +1,17 @@
+! C711 An assumed-type actual argument that corresponds to an assumed-rank 
+! dummy argument shall be assumed-shape or assumed-rank.
+subroutine s(arg1, arg2, arg3)
+  type(*), dimension(..) :: arg1 ! assumed rank
+  type(*), dimension(:) :: arg2 ! assumed shape
+  type(*) :: arg3
+
+  call inner(arg1) ! OK, assumed rank
+  call inner(arg2) ! OK, assumed shape
+  !ERROR: Assumed-type TYPE(*) 'arg3' must be either assumed shape or assumed rank to be associated with TYPE(*) dummy argument 'dummy='
+  call inner(arg3)
+
+    contains
+      subroutine inner(dummy)
+        type(*), dimension(..) :: dummy
+      end subroutine inner
+end subroutine s
diff --git a/test/semantics/modfile12.f90 b/test/semantics/modfile12.f90
index e6b00cc7c3f7..89f43ad350eb 100644
--- a/test/semantics/modfile12.f90
+++ b/test/semantics/modfile12.f90
@@ -9,7 +9,6 @@ module m
   end type
   type(t(a+3,:)), allocatable :: z
   class(t(a+4,:)), allocatable :: z2
-  type(*), allocatable :: z3
   class(*), allocatable :: z4
   real*2 :: f
   complex*32 :: g
@@ -25,6 +24,9 @@ subroutine foo(x)
   subroutine bar(x)
     real :: x(..)
   end
+  subroutine baz(x)
+    type(*) :: x
+  end
 end
 
 !Expect: m.mod
@@ -42,7 +44,6 @@ subroutine bar(x)
 !  end type
 !  type(t(c=4_4,d=:)),allocatable::z
 !  class(t(c=5_4,d=:)),allocatable::z2
-!  type(*),allocatable::z3
 !  class(*),allocatable::z4
 !  real(2)::f
 !  complex(16)::g
@@ -58,4 +59,7 @@ subroutine bar(x)
 !  subroutine bar(x)
 !    real(4)::x(..)
 !  end
+!  subroutine baz(x)
+!    type(*)::x
+!  end
 !end
diff --git a/test/semantics/resolve72.f90 b/test/semantics/resolve72.f90
new file mode 100644
index 000000000000..fdead88c8fe8
--- /dev/null
+++ b/test/semantics/resolve72.f90
@@ -0,0 +1,25 @@
+! C709 An assumed-type entity shall be a dummy data object that does not have 
+! the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and 
+! is not an explicit-shape array.
+subroutine s()
+  !ERROR: Assumed-type entity 'starvar' must be a dummy argument
+  type(*) :: starVar
+
+    contains
+      subroutine inner1(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+        type(*) :: arg1 ! OK        
+        type(*), dimension(*) :: arg2 ! OK        
+        !ERROR: Assumed-type argument 'arg3' cannot have the ALLOCATABLE attribute
+        type(*), allocatable :: arg3
+        !ERROR: Assumed-type argument 'arg4' cannot be a coarray
+        type(*), codimension[*] :: arg4
+        !ERROR: Assumed-type argument 'arg5' cannot be INTENT(OUT)
+        type(*), intent(out) :: arg5
+        !ERROR: Assumed-type argument 'arg6' cannot have the POINTER attribute
+        type(*), pointer :: arg6
+        !ERROR: Assumed-type argument 'arg7' cannot have the VALUE attribute
+        type(*), value :: arg7
+        !ERROR: Assumed-type argument 'arg8' must be assumed shape or assumed size array
+        type(*), dimension(3) :: arg8
+      end subroutine inner1
+end subroutine s

From 8ecb6a279f53ff4cc9493506370664fb1923470a Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Wed, 19 Feb 2020 13:28:19 -0800
Subject: [PATCH 036/345] Rename DoChecker to DoForallChecker

This reflects the fact that it now performs checks on both DO
and FORALL constructs. Rename the source files as well.
---
 lib/semantics/CMakeLists.txt                  |  2 +-
 .../{check-do.cpp => check-do-forall.cpp}     | 48 +++++++++----------
 .../{check-do.h => check-do-forall.h}         | 13 ++---
 lib/semantics/semantics.cpp                   | 11 +++--
 4 files changed, 38 insertions(+), 36 deletions(-)
 rename lib/semantics/{check-do.cpp => check-do-forall.cpp} (96%)
 rename lib/semantics/{check-do.h => check-do-forall.h} (84%)

diff --git a/lib/semantics/CMakeLists.txt b/lib/semantics/CMakeLists.txt
index 14e636e177d5..d06c8a2b5779 100644
--- a/lib/semantics/CMakeLists.txt
+++ b/lib/semantics/CMakeLists.txt
@@ -17,7 +17,7 @@ add_library(FortranSemantics
   check-coarray.cpp
   check-deallocate.cpp
   check-declarations.cpp
-  check-do.cpp
+  check-do-forall.cpp
   check-if-stmt.cpp
   check-io.cpp
   check-nullify.cpp
diff --git a/lib/semantics/check-do.cpp b/lib/semantics/check-do-forall.cpp
similarity index 96%
rename from lib/semantics/check-do.cpp
rename to lib/semantics/check-do-forall.cpp
index 10596c31cd21..1b1abfd10a84 100644
--- a/lib/semantics/check-do.cpp
+++ b/lib/semantics/check-do-forall.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-do.cpp ----------------------------------------===//
+//===-- lib/semantics/check-do-forall.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "check-do.h"
+#include "check-do-forall.h"
 #include "flang/common/template.h"
 #include "flang/evaluate/call.h"
 #include "flang/evaluate/expression.h"
@@ -763,37 +763,37 @@ class DoContext {
   parser::CharBlock currentStatementSourcePosition_;
 };  // class DoContext
 
-void DoChecker::Enter(const parser::DoConstruct &doConstruct) {
+void DoForallChecker::Enter(const parser::DoConstruct &doConstruct) {
   DoContext doContext{context_, IndexVarKind::DO};
   doContext.DefineDoVariables(doConstruct);
 }
 
-void DoChecker::Leave(const parser::DoConstruct &doConstruct) {
+void DoForallChecker::Leave(const parser::DoConstruct &doConstruct) {
   DoContext doContext{context_, IndexVarKind::DO};
   doContext.Check(doConstruct);
   doContext.ResetDoVariables(doConstruct);
 }
 
-void DoChecker::Enter(const parser::ForallConstruct &construct) {
+void DoForallChecker::Enter(const parser::ForallConstruct &construct) {
   DoContext doContext{context_, IndexVarKind::FORALL};
   doContext.ActivateIndexVars(GetControls(construct));
 }
-void DoChecker::Leave(const parser::ForallConstruct &construct) {
+void DoForallChecker::Leave(const parser::ForallConstruct &construct) {
   DoContext doContext{context_, IndexVarKind::FORALL};
   doContext.Check(construct);
   doContext.DeactivateIndexVars(GetControls(construct));
 }
 
-void DoChecker::Enter(const parser::ForallStmt &stmt) {
+void DoForallChecker::Enter(const parser::ForallStmt &stmt) {
   DoContext doContext{context_, IndexVarKind::FORALL};
   doContext.ActivateIndexVars(GetControls(stmt));
 }
-void DoChecker::Leave(const parser::ForallStmt &stmt) {
+void DoForallChecker::Leave(const parser::ForallStmt &stmt) {
   DoContext doContext{context_, IndexVarKind::FORALL};
   doContext.Check(stmt);
   doContext.DeactivateIndexVars(GetControls(stmt));
 }
-void DoChecker::Leave(const parser::ForallAssignmentStmt &stmt) {
+void DoForallChecker::Leave(const parser::ForallAssignmentStmt &stmt) {
   DoContext doContext{context_, IndexVarKind::FORALL};
   doContext.Check(stmt);
 }
@@ -813,8 +813,8 @@ static parser::CharBlock GetNodePosition(const ConstructNode &construct) {
       [&](const auto &x) { return GetConstructPosition(*x); }, construct);
 }
 
-void DoChecker::SayBadLeave(StmtType stmtType, const char *enclosingStmtName,
-    const ConstructNode &construct) const {
+void DoForallChecker::SayBadLeave(StmtType stmtType,
+    const char *enclosingStmtName, const ConstructNode &construct) const {
   context_
       .Say("%s must not leave a %s statement"_err_en_US, EnumToString(stmtType),
           enclosingStmtName)
@@ -838,7 +838,7 @@ static bool ConstructIsDoConcurrent(const ConstructNode &construct) {
 
 // Check that CYCLE and EXIT statements do not cause flow of control to
 // leave DO CONCURRENT, CRITICAL, or CHANGE TEAM constructs.
-void DoChecker::CheckForBadLeave(
+void DoForallChecker::CheckForBadLeave(
     StmtType stmtType, const ConstructNode &construct) const {
   std::visit(
       common::visitors{
@@ -876,7 +876,7 @@ static bool StmtMatchesConstruct(const parser::Name *stmtName,
 }
 
 // C1167 Can't EXIT from a DO CONCURRENT
-void DoChecker::CheckDoConcurrentExit(
+void DoForallChecker::CheckDoConcurrentExit(
     StmtType stmtType, const ConstructNode &construct) const {
   if (stmtType == StmtType::EXIT && ConstructIsDoConcurrent(construct)) {
     SayBadLeave(StmtType::EXIT, "DO CONCURRENT", construct);
@@ -887,7 +887,7 @@ void DoChecker::CheckDoConcurrentExit(
 // nesting levels looking for a construct that matches the CYCLE or EXIT
 // statment.  At every construct, check for a violation.  If we find a match
 // without finding a violation, the check is complete.
-void DoChecker::CheckNesting(
+void DoForallChecker::CheckNesting(
     StmtType stmtType, const parser::Name *stmtName) const {
   const ConstructStack &stack{context_.constructStack()};
   for (auto iter{stack.cend()}; iter-- != stack.cbegin();) {
@@ -909,16 +909,16 @@ void DoChecker::CheckNesting(
 }
 
 // C1135 -- Nesting for CYCLE statements
-void DoChecker::Enter(const parser::CycleStmt &cycleStmt) {
+void DoForallChecker::Enter(const parser::CycleStmt &cycleStmt) {
   CheckNesting(StmtType::CYCLE, common::GetPtrFromOptional(cycleStmt.v));
 }
 
 // C1167 and C1168 -- Nesting for EXIT statements
-void DoChecker::Enter(const parser::ExitStmt &exitStmt) {
+void DoForallChecker::Enter(const parser::ExitStmt &exitStmt) {
   CheckNesting(StmtType::EXIT, common::GetPtrFromOptional(exitStmt.v));
 }
 
-void DoChecker::Leave(const parser::AssignmentStmt &stmt) {
+void DoForallChecker::Leave(const parser::AssignmentStmt &stmt) {
   const auto &variable{std::get<parser::Variable>(stmt.t)};
   context_.CheckIndexVarRedefine(variable);
 }
@@ -947,7 +947,7 @@ static void CheckIfArgIsDoVar(const evaluate::ActualArgument &arg,
 // the same time, we need to iterate over the parser::Expr versions of the
 // actual arguments to get their source locations of the arguments for the
 // messages.
-void DoChecker::Leave(const parser::CallStmt &callStmt) {
+void DoForallChecker::Leave(const parser::CallStmt &callStmt) {
   if (const auto &typedCall{callStmt.typedCall}) {
     const auto &parsedArgs{
         std::get<std::list<parser::ActualArgSpec>>(callStmt.v.t)};
@@ -970,7 +970,7 @@ void DoChecker::Leave(const parser::CallStmt &callStmt) {
   }
 }
 
-void DoChecker::Leave(const parser::ConnectSpec &connectSpec) {
+void DoForallChecker::Leave(const parser::ConnectSpec &connectSpec) {
   const auto *newunit{
       std::get_if<parser::ConnectSpec::Newunit>(&connectSpec.u)};
   if (newunit) {
@@ -997,7 +997,7 @@ template<typename A> ActualArgumentSet CollectActualArguments(const A &x) {
 
 template ActualArgumentSet CollectActualArguments(const SomeExpr &);
 
-void DoChecker::Leave(const parser::Expr &parsedExpr) {
+void DoForallChecker::Leave(const parser::Expr &parsedExpr) {
   if (const SomeExpr * expr{GetExpr(parsedExpr)}) {
     ActualArgumentSet argSet{CollectActualArguments(*expr)};
     for (const evaluate::ActualArgumentRef &argRef : argSet) {
@@ -1006,7 +1006,7 @@ void DoChecker::Leave(const parser::Expr &parsedExpr) {
   }
 }
 
-void DoChecker::Leave(const parser::InquireSpec &inquireSpec) {
+void DoForallChecker::Leave(const parser::InquireSpec &inquireSpec) {
   const auto *intVar{std::get_if<parser::InquireSpec::IntVar>(&inquireSpec.u)};
   if (intVar) {
     const auto &scalar{std::get<parser::ScalarIntVariable>(intVar->t)};
@@ -1014,20 +1014,20 @@ void DoChecker::Leave(const parser::InquireSpec &inquireSpec) {
   }
 }
 
-void DoChecker::Leave(const parser::IoControlSpec &ioControlSpec) {
+void DoForallChecker::Leave(const parser::IoControlSpec &ioControlSpec) {
   const auto *size{std::get_if<parser::IoControlSpec::Size>(&ioControlSpec.u)};
   if (size) {
     context_.CheckIndexVarRedefine(size->v.thing.thing);
   }
 }
 
-void DoChecker::Leave(const parser::OutputImpliedDo &outputImpliedDo) {
+void DoForallChecker::Leave(const parser::OutputImpliedDo &outputImpliedDo) {
   const auto &control{std::get<parser::IoImpliedDoControl>(outputImpliedDo.t)};
   const parser::Name &name{control.name.thing.thing};
   context_.CheckIndexVarRedefine(name.source, *name.symbol);
 }
 
-void DoChecker::Leave(const parser::StatVariable &statVariable) {
+void DoForallChecker::Leave(const parser::StatVariable &statVariable) {
   context_.CheckIndexVarRedefine(statVariable.v.thing.thing);
 }
 
diff --git a/lib/semantics/check-do.h b/lib/semantics/check-do-forall.h
similarity index 84%
rename from lib/semantics/check-do.h
rename to lib/semantics/check-do-forall.h
index fb3a4be9b082..1ba9b6b81060 100644
--- a/lib/semantics/check-do.h
+++ b/lib/semantics/check-do-forall.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-do.h --------------------------------*- C++ -*-===//
+//===-- lib/semantics/check-do-forall.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_SEMANTICS_CHECK_DO_H_
-#define FORTRAN_SEMANTICS_CHECK_DO_H_
+#ifndef FORTRAN_SEMANTICS_CHECK_DO_FORALL_H_
+#define FORTRAN_SEMANTICS_CHECK_DO_FORALL_H_
 
 #include "flang/common/idioms.h"
 #include "flang/semantics/semantics.h"
@@ -34,9 +34,10 @@ namespace Fortran::semantics {
 // To specify different statement types used in semantic checking.
 ENUM_CLASS(StmtType, CYCLE, EXIT)
 
-class DoChecker : public virtual BaseChecker {
+// Perform semantic checks on DO and FORALL constructs and statements.
+class DoForallChecker : public virtual BaseChecker {
 public:
-  explicit DoChecker(SemanticsContext &context) : context_{context} {}
+  explicit DoForallChecker(SemanticsContext &context) : context_{context} {}
   void Leave(const parser::AssignmentStmt &);
   void Leave(const parser::CallStmt &);
   void Leave(const parser::ConnectSpec &);
@@ -65,4 +66,4 @@ class DoChecker : public virtual BaseChecker {
   void CheckNesting(StmtType, const parser::Name *) const;
 };
 }
-#endif  // FORTRAN_SEMANTICS_CHECK_DO_H_
+#endif
diff --git a/lib/semantics/semantics.cpp b/lib/semantics/semantics.cpp
index c6353a7b0d44..dcb119813a0e 100644
--- a/lib/semantics/semantics.cpp
+++ b/lib/semantics/semantics.cpp
@@ -15,7 +15,7 @@
 #include "check-coarray.h"
 #include "check-deallocate.h"
 #include "check-declarations.h"
-#include "check-do.h"
+#include "check-do-forall.h"
 #include "check-if-stmt.h"
 #include "check-io.h"
 #include "check-nullify.h"
@@ -110,10 +110,11 @@ template<typename... C> class SemanticsVisitor : public virtual C... {
 };
 
 using StatementSemanticsPass1 = ExprChecker;
-using StatementSemanticsPass2 = SemanticsVisitor<AllocateChecker,
-    ArithmeticIfStmtChecker, AssignmentChecker, CoarrayChecker,
-    DeallocateChecker, DoChecker, IfStmtChecker, IoChecker, NullifyChecker,
-    OmpStructureChecker, PurityChecker, ReturnStmtChecker, StopChecker>;
+using StatementSemanticsPass2 = SemanticsVisitor<  //
+    AllocateChecker, ArithmeticIfStmtChecker, AssignmentChecker, CoarrayChecker,
+    DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
+    NullifyChecker, OmpStructureChecker, PurityChecker, ReturnStmtChecker,
+    StopChecker>;
 
 static bool PerformStatementSemantics(
     SemanticsContext &context, parser::Program &program) {

From 2c1fc63758eac43eb4d2fd4fdf1e7b0e63d52f70 Mon Sep 17 00:00:00 2001
From: Isuru Fernando <isuruf@gmail.com>
Date: Thu, 20 Feb 2020 13:33:43 -0600
Subject: [PATCH 037/345] Disable 80-bit extended precision if on MSVC (#1003)

---
 include/flang/decimal/decimal.h   | 4 ++--
 lib/decimal/binary-to-decimal.cpp | 2 +-
 lib/decimal/decimal-to-binary.cpp | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/flang/decimal/decimal.h b/include/flang/decimal/decimal.h
index c9aad161f4dd..05ed0068d95c 100644
--- a/include/flang/decimal/decimal.h
+++ b/include/flang/decimal/decimal.h
@@ -130,7 +130,7 @@ struct NS(ConversionToDecimalResult)
 struct NS(ConversionToDecimalResult)
     ConvertDoubleToDecimal(char *, size_t, enum NS(DecimalConversionFlags),
         int digits, enum NS(FortranRounding), double);
-#if __x86_64__
+#if __x86_64__ && !defined(_MSC_VER)
 struct NS(ConversionToDecimalResult)
     ConvertLongDoubleToDecimal(char *, size_t, enum NS(DecimalConversionFlags),
         int digits, enum NS(FortranRounding), long double);
@@ -140,7 +140,7 @@ enum NS(ConversionResultFlags)
     ConvertDecimalToFloat(const char **, float *, enum NS(FortranRounding));
 enum NS(ConversionResultFlags)
     ConvertDecimalToDouble(const char **, double *, enum NS(FortranRounding));
-#if __x86_64__
+#if __x86_64__ && !defined(_MSC_VER)
 enum NS(ConversionResultFlags) ConvertDecimalToLongDouble(
     const char **, long double *, enum NS(FortranRounding));
 #endif
diff --git a/lib/decimal/binary-to-decimal.cpp b/lib/decimal/binary-to-decimal.cpp
index d15aab5ff638..f4b644045648 100644
--- a/lib/decimal/binary-to-decimal.cpp
+++ b/lib/decimal/binary-to-decimal.cpp
@@ -389,7 +389,7 @@ ConversionToDecimalResult ConvertDoubleToDecimal(char *buffer, std::size_t size,
       rounding, Fortran::decimal::BinaryFloatingPointNumber<53>(x));
 }
 
-#if __x86_64__
+#if __x86_64__ && !defined(_MSC_VER)
 ConversionToDecimalResult ConvertLongDoubleToDecimal(char *buffer,
     std::size_t size, enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, long double x) {
diff --git a/lib/decimal/decimal-to-binary.cpp b/lib/decimal/decimal-to-binary.cpp
index a07cd570d8c3..f71ca941e8a7 100644
--- a/lib/decimal/decimal-to-binary.cpp
+++ b/lib/decimal/decimal-to-binary.cpp
@@ -417,7 +417,7 @@ enum ConversionResultFlags ConvertDecimalToDouble(
       reinterpret_cast<const void *>(&result.binary), sizeof *d);
   return result.flags;
 }
-#if __x86_64__
+#if __x86_64__ && !defined(_MSC_VER)
 enum ConversionResultFlags ConvertDecimalToLongDouble(
     const char **p, long double *ld, enum FortranRounding rounding) {
   auto result{Fortran::decimal::ConvertToBinary<64>(*p, rounding)};

From de801a0db7614c93abc8239d02a453d60c9ea8a1 Mon Sep 17 00:00:00 2001
From: Isuru Fernando <isuruf@gmail.com>
Date: Thu, 20 Feb 2020 15:12:49 -0600
Subject: [PATCH 038/345] Add missing array include (#1004)

---
 include/flang/semantics/symbol.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/flang/semantics/symbol.h b/include/flang/semantics/symbol.h
index 5c45a8c5ad06..d6ac63f79d25 100644
--- a/include/flang/semantics/symbol.h
+++ b/include/flang/semantics/symbol.h
@@ -13,6 +13,7 @@
 #include "flang/common/Fortran.h"
 #include "flang/common/enum-set.h"
 #include "flang/common/reference.h"
+#include <array>
 #include <list>
 #include <optional>
 #include <set>

From 822129736b6b7a96b6ff3ffe810d842ce42e3672 Mon Sep 17 00:00:00 2001
From: Anchu Rajendran S <59249359+anchu-rajendran@users.noreply.github.com>
Date: Fri, 21 Feb 2020 11:49:14 +0530
Subject: [PATCH 039/345] Issue #992 :  Implementing Semantic checks for DATA
 Statement (C874-C887) (#992)

This commit covers Semantic Constraints C882 - C887

C882 : It was partially Implemented. Finished the implementation
and added test case
C884 : Implemented and added test case
C883 : Implementation was there already. Added test case
C885, C886, C887 : Implementation was there already. Added test case for
data-repeat.
---
 include/flang/semantics/expression.h |  2 +-
 lib/semantics/CMakeLists.txt         |  1 +
 lib/semantics/check-data.cpp         | 50 ++++++++++++++++++++++++++++
 lib/semantics/check-data.h           | 28 ++++++++++++++++
 lib/semantics/expression.cpp         |  2 +-
 lib/semantics/resolve-names.cpp      |  4 +--
 lib/semantics/semantics.cpp          |  5 +--
 test/semantics/CMakeLists.txt        |  1 +
 test/semantics/data01.f90            | 48 ++++++++++++++++++++++++++
 9 files changed, 135 insertions(+), 6 deletions(-)
 create mode 100644 lib/semantics/check-data.cpp
 create mode 100644 lib/semantics/check-data.h
 create mode 100644 test/semantics/data01.f90

diff --git a/include/flang/semantics/expression.h b/include/flang/semantics/expression.h
index 110a0bdb0853..79360fc0bed0 100644
--- a/include/flang/semantics/expression.h
+++ b/include/flang/semantics/expression.h
@@ -186,7 +186,7 @@ class ExpressionAnalyzer {
     auto result{Analyze(x.thing)};
     if (result) {
       *result = Fold(std::move(*result));
-      if (!IsConstantExpr(*result)) {
+      if (!IsConstantExpr(*result)) { //C886,C887
         SayAt(x, "Must be a constant value"_err_en_US);
         ResetExpr(x);
         return std::nullopt;
diff --git a/lib/semantics/CMakeLists.txt b/lib/semantics/CMakeLists.txt
index d06c8a2b5779..5f2e3c686fc4 100644
--- a/lib/semantics/CMakeLists.txt
+++ b/lib/semantics/CMakeLists.txt
@@ -15,6 +15,7 @@ add_library(FortranSemantics
   check-arithmeticif.cpp
   check-call.cpp
   check-coarray.cpp
+  check-data.cpp
   check-deallocate.cpp
   check-declarations.cpp
   check-do-forall.cpp
diff --git a/lib/semantics/check-data.cpp b/lib/semantics/check-data.cpp
new file mode 100644
index 000000000000..e831bf7e3d53
--- /dev/null
+++ b/lib/semantics/check-data.cpp
@@ -0,0 +1,50 @@
+//===-- lib/semantics/check-data.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 "check-data.h"
+
+namespace Fortran::semantics {
+
+void DataChecker::Leave(const parser::DataStmtConstant &dataConst) {
+  if (auto *structure{
+          std::get_if<parser::StructureConstructor>(&dataConst.u)}) {
+    for (const auto &component :
+        std::get<std::list<parser::ComponentSpec>>(structure->t)) {
+      const parser::Expr &parsedExpr{
+          std::get<parser::ComponentDataSource>(component.t).v.value()};
+      if (const auto *expr{GetExpr(parsedExpr)}) {
+        if (!evaluate::IsConstantExpr(*expr)) {  // C884
+          context_.Say(parsedExpr.source,
+              "Structure constructor in data value must be a constant expression"_err_en_US);
+        }
+      }
+    }
+  }
+  // TODO: C886 and C887 for data-stmt-constant
+}
+
+// TODO: C874-C881
+
+void DataChecker::Leave(const parser::DataStmtRepeat &dataRepeat) {
+  if (const auto *designator{parser::Unwrap<parser::Designator>(dataRepeat)}) {
+    if (auto *dataRef{std::get_if<parser::DataRef>(&designator->u)}) {
+      evaluate::ExpressionAnalyzer exprAnalyzer{context_};
+      if (MaybeExpr checked{exprAnalyzer.Analyze(*dataRef)}) {
+        auto expr{
+            evaluate::Fold(context_.foldingContext(), std::move(checked))};
+        if (auto i64{ToInt64(expr)}) {
+          if (*i64 < 0) {  // C882
+            context_.Say(designator->source,
+                "Repeat count for data value must not be negative"_err_en_US);
+          }
+        }
+      }
+    }
+  }
+}
+}
diff --git a/lib/semantics/check-data.h b/lib/semantics/check-data.h
new file mode 100644
index 000000000000..b2e96519a346
--- /dev/null
+++ b/lib/semantics/check-data.h
@@ -0,0 +1,28 @@
+//===-------lib/semantics/check-data.h ------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_SEMANTICS_CHECK_DATA_H_
+#define FORTRAN_SEMANTICS_CHECK_DATA_H_
+
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/tools.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/tools.h"
+
+namespace Fortran::semantics {
+class DataChecker : public virtual BaseChecker {
+public:
+  DataChecker(SemanticsContext &context) : context_{context} {}
+  void Leave(const parser::DataStmtRepeat &);
+  void Leave(const parser::DataStmtConstant &);
+
+private:
+  SemanticsContext &context_;
+};
+}
+#endif  // FORTRAN_SEMANTICS_CHECK_DATA_H_
diff --git a/lib/semantics/expression.cpp b/lib/semantics/expression.cpp
index 054b4d1fdcb5..65e9f7ecdeb3 100644
--- a/lib/semantics/expression.cpp
+++ b/lib/semantics/expression.cpp
@@ -2471,7 +2471,7 @@ bool ExpressionAnalyzer::EnforceTypeConstraint(parser::CharBlock at,
     const MaybeExpr &result, TypeCategory category, bool defaultKind) {
   if (result) {
     if (auto type{result->GetType()}) {
-      if (type->category() != category) {
+      if (type->category() != category) { // C885
         Say(at, "Must have %s type, but is %s"_err_en_US,
             ToUpperCase(EnumToString(category)),
             ToUpperCase(type->AsFortran()));
diff --git a/lib/semantics/resolve-names.cpp b/lib/semantics/resolve-names.cpp
index b98b7bc14a8d..3c322b694014 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/semantics/resolve-names.cpp
@@ -2957,7 +2957,7 @@ void DeclarationVisitor::Post(const parser::EntityDecl &x) {
     if (ConvertToObjectEntity(symbol)) {
       Initialization(name, *init, false);
     }
-  } else if (attrs.test(Attr::PARAMETER)) {
+  } else if (attrs.test(Attr::PARAMETER)) { // C882, C883
     Say(name, "Missing initialization for parameter '%s'"_err_en_US);
   }
 }
@@ -4408,7 +4408,7 @@ std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
       DerivedTypeDetails details;
       details.set_isForwardReferenced();
       symbol->set_details(std::move(details));
-    } else {
+    } else { // C883
       Say(name, "Derived type '%s' not found"_err_en_US);
       return std::nullopt;
     }
diff --git a/lib/semantics/semantics.cpp b/lib/semantics/semantics.cpp
index dcb119813a0e..d64ba6375f33 100644
--- a/lib/semantics/semantics.cpp
+++ b/lib/semantics/semantics.cpp
@@ -13,6 +13,7 @@
 #include "check-allocate.h"
 #include "check-arithmeticif.h"
 #include "check-coarray.h"
+#include "check-data.h"
 #include "check-deallocate.h"
 #include "check-declarations.h"
 #include "check-do-forall.h"
@@ -110,9 +111,9 @@ template<typename... C> class SemanticsVisitor : public virtual C... {
 };
 
 using StatementSemanticsPass1 = ExprChecker;
-using StatementSemanticsPass2 = SemanticsVisitor<  //
+using StatementSemanticsPass2 = SemanticsVisitor<
     AllocateChecker, ArithmeticIfStmtChecker, AssignmentChecker, CoarrayChecker,
-    DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
+    DataChecker, DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
     NullifyChecker, OmpStructureChecker, PurityChecker, ReturnStmtChecker,
     StopChecker>;
 
diff --git a/test/semantics/CMakeLists.txt b/test/semantics/CMakeLists.txt
index 7d6ca5fe79e0..ff5aa3f0e4de 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/semantics/CMakeLists.txt
@@ -207,6 +207,7 @@ set(ERROR_TESTS
   critical02.f90
   critical03.f90
   block-data01.f90
+  data01.f90
 )
 
 # These test files have expected symbols in the source
diff --git a/test/semantics/data01.f90 b/test/semantics/data01.f90
new file mode 100644
index 000000000000..02c4674d241d
--- /dev/null
+++ b/test/semantics/data01.f90
@@ -0,0 +1,48 @@
+!Test for checking data constraints, C882-C887
+module m1
+  type person
+    integer :: age
+    character(len=25) :: name
+  end type
+  integer, parameter::digits(5) = ( /-11,-22,-33,44,55/ )
+  integer ::notConstDigits(5) = ( /-11,-22,-33,44,55/ )
+  real, parameter::numbers(5) = ( /-11.11,-22.22,-33.33,44.44,55.55/ )
+  integer, parameter :: repeat = -1
+  integer :: myAge = 2 
+  type(person) myName
+end
+
+subroutine CheckRepeat
+  use m1
+  !C882
+  !ERROR: Missing initialization for parameter 'uninitialized'
+  integer, parameter :: uninitialized
+  !C882
+  !ERROR: Repeat count for data value must not be negative
+  DATA myName%age / repeat * 35 /
+  !C882
+  !ERROR: Repeat count for data value must not be negative
+  DATA myName%age / digits(1) * 35 /
+  !C882
+  !ERROR: Must be a constant value
+  DATA myName%age / repet * 35 /
+  !C885
+  !ERROR: Must have INTEGER type, but is REAL(4)
+  DATA myName%age / numbers(1) * 35 /
+  !C886
+  !ERROR: Must be a constant value
+  DATA myName%age / notConstDigits(1) * 35 /
+  !C887
+  !ERROR: Must be a constant value
+  DATA myName%age / digits(myAge) * 35 /
+end
+
+subroutine CheckValue
+  use m1
+  !C883
+  !ERROR: Derived type 'persn' not found
+  DATA myname / persn(2, 'Abcd Efgh') /
+  !C884
+  !ERROR: Structure constructor in data value must be a constant expression
+  DATA myname / person(myAge, 'Abcd Ijkl') /
+end

From 04a76b272675d47ec7752420b15976c69a907dab Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Fri, 21 Feb 2020 15:31:12 -0800
Subject: [PATCH 040/345] Fix parsing bug on DATA statement

This DATA statement was getting a parsing error:
`data x /a(i)%b/`

The parser was expecting the ending '/' where the '%' was. The problem
was parsing `a(i)` as a structure constructor. Instead, move the
constant subobject case before structure constructor, but match it only
if not followed by '('. That is because in `data x /a(1)(2)/`, `a(1)` is
a valid structure constructor.

Also, remove the NamedConstant alternative from DataStmtRepeat. A named
constant is always parsed as a ConstantSubobject so it can never occur.
---
 include/flang/parser/parse-tree.h |  4 +---
 lib/parser/Fortran-parsers.cpp    | 10 ++++------
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/include/flang/parser/parse-tree.h b/include/flang/parser/parse-tree.h
index 57093e3903cb..f1e02e0a45d5 100644
--- a/include/flang/parser/parse-tree.h
+++ b/include/flang/parser/parse-tree.h
@@ -1412,9 +1412,7 @@ struct DataStmtConstant {
 // (only literal-constant -> int-literal-constant applies)
 struct DataStmtRepeat {
   UNION_CLASS_BOILERPLATE(DataStmtRepeat);
-  std::variant<IntLiteralConstant, Scalar<Integer<NamedConstant>>,
-      Scalar<Integer<ConstantSubobject>>>
-      u;
+  std::variant<IntLiteralConstant, Scalar<Integer<ConstantSubobject>>> u;
 };
 
 // R843 data-stmt-value -> [data-stmt-repeat *] data-stmt-constant
diff --git a/lib/parser/Fortran-parsers.cpp b/lib/parser/Fortran-parsers.cpp
index f895189aa99a..d15901a74ea7 100644
--- a/lib/parser/Fortran-parsers.cpp
+++ b/lib/parser/Fortran-parsers.cpp
@@ -818,12 +818,10 @@ constexpr auto constantSubobject{constant(indirect(designator))};
 
 // R844 data-stmt-repeat -> scalar-int-constant | scalar-int-constant-subobject
 // R607 int-constant -> constant
-// Factored into:
-//   constant -> literal-constant -> int-literal-constant   and
-//   constant -> named-constant
+// Factored into: constant -> literal-constant -> int-literal-constant
+// The named-constant alternative of constant is subsumed by constant-subobject
 TYPE_PARSER(construct<DataStmtRepeat>(intLiteralConstant) ||
-    construct<DataStmtRepeat>(scalar(integer(constantSubobject))) ||
-    construct<DataStmtRepeat>(scalar(integer(namedConstant))))
+    construct<DataStmtRepeat>(scalar(integer(constantSubobject))))
 
 // R845 data-stmt-constant ->
 //        scalar-constant | scalar-constant-subobject |
@@ -833,8 +831,8 @@ TYPE_PARSER(construct<DataStmtRepeat>(intLiteralConstant) ||
 // references into constant subobjects.
 TYPE_PARSER(first(construct<DataStmtConstant>(scalar(Parser<ConstantValue>{})),
     construct<DataStmtConstant>(nullInit),
+    construct<DataStmtConstant>(scalar(constantSubobject)) / !"("_tok,
     construct<DataStmtConstant>(Parser<StructureConstructor>{}),
-    construct<DataStmtConstant>(scalar(constantSubobject)),
     construct<DataStmtConstant>(signedRealLiteralConstant),
     construct<DataStmtConstant>(signedIntLiteralConstant),
     extension<LanguageFeature::SignedComplexLiteral>(

From 8b04dbebcf5621cfd571a8c45878cebcd1a1bfb0 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Thu, 20 Feb 2020 14:54:46 -0800
Subject: [PATCH 041/345] Add more checks on WHERE and FORALL

Check that masks and LHS of assignments in WHERE statements and
constructs have consistent shapes. They must all have the same rank and
any extents that are compile-time constants must match.

Emit a warning for assignments in FORALL statements and constructs where
the LHS does not reference each of the index variables.
---
 include/flang/semantics/semantics.h |   5 +-
 lib/semantics/assignment.cpp        | 251 +++++++++-------------------
 lib/semantics/assignment.h          |  10 +-
 lib/semantics/check-do-forall.cpp   |  33 ++++
 lib/semantics/semantics.cpp         |  13 +-
 test/semantics/assign01.f90         |  65 +++++--
 test/semantics/forall01.f90         |  32 +++-
 7 files changed, 220 insertions(+), 189 deletions(-)

diff --git a/include/flang/semantics/semantics.h b/include/flang/semantics/semantics.h
index b13f617108b4..0e64e42f742b 100644
--- a/include/flang/semantics/semantics.h
+++ b/include/flang/semantics/semantics.h
@@ -159,10 +159,13 @@ class SemanticsContext {
   void CheckIndexVarRedefine(const parser::Name &);
   void ActivateIndexVar(const parser::Name &, IndexVarKind);
   void DeactivateIndexVar(const parser::Name &);
+  SymbolVector GetIndexVars(IndexVarKind);
 
 private:
   void CheckIndexVarRedefine(
       const parser::CharBlock &, const Symbol &, parser::MessageFixedText &&);
+  bool CheckError(bool);
+
   const common::IntrinsicTypeDefaultKinds &defaultKinds_;
   const common::LanguageFeatureControl languageFeatures_;
   parser::AllSources &allSources_;
@@ -176,8 +179,6 @@ class SemanticsContext {
   Scope globalScope_;
   parser::Messages messages_;
   evaluate::FoldingContext foldingContext_;
-
-  bool CheckError(bool);
   ConstructStack constructStack_;
   struct IndexVarInfo {
     parser::CharBlock location;
diff --git a/lib/semantics/assignment.cpp b/lib/semantics/assignment.cpp
index aee651e42b19..b286f6578168 100644
--- a/lib/semantics/assignment.cpp
+++ b/lib/semantics/assignment.cpp
@@ -29,194 +29,62 @@ using namespace Fortran::parser::literals;
 
 namespace Fortran::semantics {
 
-using ControlExpr = evaluate::Expr<evaluate::SubscriptInteger>;
-using MaskExpr = evaluate::Expr<evaluate::LogicalResult>;
-
-// The context tracks some number of active FORALL statements/constructs
-// and some number of active WHERE statements/constructs.  WHERE can nest
-// in FORALL but not vice versa.  Pointer assignments are allowed in
-// FORALL but not in WHERE.  These constraints are manifest in the grammar
-// and don't need to be rechecked here, since errors cannot appear in the
-// parse tree.
-struct Control {
-  Symbol *name;
-  ControlExpr lower, upper, step;
-};
-
-struct ForallContext {
-  explicit ForallContext(const ForallContext *that) : outer{that} {}
-
-  const ForallContext *outer{nullptr};
-  std::optional<parser::CharBlock> constructName;
-  std::vector<Control> control;
-  std::optional<MaskExpr> maskExpr;
-  std::set<parser::CharBlock> activeNames;
-};
-
-struct WhereContext {
-  WhereContext(MaskExpr &&x, const WhereContext *o, const ForallContext *f)
-    : outer{o}, forall{f}, thisMaskExpr{std::move(x)} {}
-  const WhereContext *outer{nullptr};
-  const ForallContext *forall{nullptr};  // innermost enclosing FORALL
-  std::optional<parser::CharBlock> constructName;
-  MaskExpr thisMaskExpr;  // independent of outer WHERE, if any
-  MaskExpr cumulativeMaskExpr{thisMaskExpr};
-};
-
 class AssignmentContext {
 public:
-  explicit AssignmentContext(SemanticsContext &c) : context_{c} {}
-  AssignmentContext(const AssignmentContext &c, WhereContext &w)
-    : context_{c.context_}, where_{&w} {}
-  AssignmentContext(const AssignmentContext &c, ForallContext &f)
-    : context_{c.context_}, forall_{&f} {}
-
+  explicit AssignmentContext(SemanticsContext &context) : context_{context} {}
+  AssignmentContext(AssignmentContext &&) = default;
+  AssignmentContext(const AssignmentContext &) = delete;
   bool operator==(const AssignmentContext &x) const { return this == &x; }
 
+  template<typename A> void PushWhereContext(const A &);
+  void PopWhereContext();
   void Analyze(const parser::AssignmentStmt &);
   void Analyze(const parser::PointerAssignmentStmt &);
-  void Analyze(const parser::WhereStmt &);
-  void Analyze(const parser::WhereConstruct &);
-  void Analyze(const parser::ForallConstruct &);
-
-  template<typename A> void Analyze(const parser::UnlabeledStatement<A> &stmt) {
-    context_.set_location(stmt.source);
-    Analyze(stmt.statement);
-  }
-  template<typename A> void Analyze(const common::Indirection<A> &x) {
-    Analyze(x.value());
-  }
-  template<typename A> std::enable_if_t<UnionTrait<A>> Analyze(const A &x) {
-    std::visit([&](const auto &y) { Analyze(y); }, x.u);
-  }
-  template<typename A> void Analyze(const std::list<A> &list) {
-    for (const auto &elem : list) {
-      Analyze(elem);
-    }
-  }
-  template<typename A> void Analyze(const std::optional<A> &x) {
-    if (x) {
-      Analyze(*x);
-    }
-  }
+  void Analyze(const parser::ConcurrentControl &);
 
 private:
-  void Analyze(const parser::WhereConstruct::MaskedElsewhere &);
-  void Analyze(const parser::MaskedElsewhereStmt &);
-  void Analyze(const parser::WhereConstruct::Elsewhere &);
-
   void CheckForPureContext(const SomeExpr &lhs, const SomeExpr &rhs,
       parser::CharBlock rhsSource, bool isPointerAssignment);
-
-  MaskExpr GetMask(const parser::LogicalExpr &, bool defaultValue = true);
-
+  void CheckShape(parser::CharBlock, const SomeExpr *);
   template<typename... A>
   parser::Message *Say(parser::CharBlock at, A &&... args) {
     return &context_.Say(at, std::forward<A>(args)...);
   }
+  evaluate::FoldingContext &foldingContext() {
+    return context_.foldingContext();
+  }
 
   SemanticsContext &context_;
-  WhereContext *where_{nullptr};
-  ForallContext *forall_{nullptr};
+  int whereDepth_{0};  // number of WHEREs currently nested in
+  // shape of masks in LHS of assignments in current WHERE:
+  std::vector<std::optional<std::int64_t>> whereExtents_;
 };
 
 void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
-  // Assignment statement analysis is in expression.cpp where user-defined
-  // assignments can be recognized and replaced.
   if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
-    if (forall_) {
-      // TODO: Warn if some name in forall_->activeNames or its outer
-      // contexts does not appear on LHS
+    const SomeExpr &lhs{assignment->lhs};
+    const SomeExpr &rhs{assignment->rhs};
+    auto lhsLoc{std::get<parser::Variable>(stmt.t).GetSource()};
+    auto rhsLoc{std::get<parser::Expr>(stmt.t).source};
+    if (whereDepth_ > 0) {
+      CheckShape(lhsLoc, &lhs);
     }
-    CheckForPureContext(assignment->lhs, assignment->rhs,
-        std::get<parser::Expr>(stmt.t).source, false /* not => */);
+    CheckForPureContext(lhs, rhs, rhsLoc, false);
   }
-  // TODO: Fortran 2003 ALLOCATABLE assignment semantics (automatic
-  // (re)allocation of LHS array when unallocated or nonconformable)
 }
 
 void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
-  CHECK(!where_);
-  const evaluate::Assignment *assignment{GetAssignment(stmt)};
-  if (!assignment) {
-    return;
-  }
-  const SomeExpr &lhs{assignment->lhs};
-  const SomeExpr &rhs{assignment->rhs};
-  if (forall_) {
-    // TODO: Warn if some name in forall_->activeNames or its outer
-    // contexts does not appear on LHS
-  }
-  CheckForPureContext(lhs, rhs, std::get<parser::Expr>(stmt.t).source,
-      true /* isPointerAssignment */);
-  auto restorer{context_.foldingContext().messages().SetLocation(
-      context_.location().value())};
-  CheckPointerAssignment(context_.foldingContext(), *assignment);
-}
-
-void AssignmentContext::Analyze(const parser::WhereStmt &stmt) {
-  WhereContext where{
-      GetMask(std::get<parser::LogicalExpr>(stmt.t)), where_, forall_};
-  AssignmentContext nested{*this, where};
-  nested.Analyze(std::get<parser::AssignmentStmt>(stmt.t));
-}
-
-// N.B. Construct name matching is checked during label resolution.
-void AssignmentContext::Analyze(const parser::WhereConstruct &construct) {
-  const auto &whereStmt{
-      std::get<parser::Statement<parser::WhereConstructStmt>>(construct.t)};
-  WhereContext where{
-      GetMask(std::get<parser::LogicalExpr>(whereStmt.statement.t)), where_,
-      forall_};
-  if (const auto &name{
-          std::get<std::optional<parser::Name>>(whereStmt.statement.t)}) {
-    where.constructName = name->source;
-  }
-  AssignmentContext nested{*this, where};
-  nested.Analyze(std::get<std::list<parser::WhereBodyConstruct>>(construct.t));
-  nested.Analyze(std::get<std::list<parser::WhereConstruct::MaskedElsewhere>>(
-      construct.t));
-  nested.Analyze(
-      std::get<std::optional<parser::WhereConstruct::Elsewhere>>(construct.t));
-}
-
-void AssignmentContext::Analyze(
-    const parser::WhereConstruct::MaskedElsewhere &elsewhere) {
-  CHECK(where_);
-  Analyze(
-      std::get<parser::Statement<parser::MaskedElsewhereStmt>>(elsewhere.t));
-  Analyze(std::get<std::list<parser::WhereBodyConstruct>>(elsewhere.t));
-}
-
-void AssignmentContext::Analyze(const parser::MaskedElsewhereStmt &elsewhere) {
-  MaskExpr mask{GetMask(std::get<parser::LogicalExpr>(elsewhere.t))};
-  MaskExpr copyCumulative{where_->cumulativeMaskExpr};
-  MaskExpr notOldMask{evaluate::LogicalNegation(std::move(copyCumulative))};
-  if (!evaluate::AreConformable(notOldMask, mask)) {
-    context_.Say("mask of ELSEWHERE statement is not conformable with "
-                 "the prior mask(s) in its WHERE construct"_err_en_US);
-  }
-  MaskExpr copyMask{mask};
-  where_->cumulativeMaskExpr =
-      evaluate::BinaryLogicalOperation(evaluate::LogicalOperator::Or,
-          std::move(where_->cumulativeMaskExpr), std::move(copyMask));
-  where_->thisMaskExpr = evaluate::BinaryLogicalOperation(
-      evaluate::LogicalOperator::And, std::move(notOldMask), std::move(mask));
-  if (where_->outer &&
-      !evaluate::AreConformable(
-          where_->outer->thisMaskExpr, where_->thisMaskExpr)) {
-    context_.Say("effective mask of ELSEWHERE statement is not conformable "
-                 "with the mask of the surrounding WHERE construct"_err_en_US);
+  CHECK(whereDepth_ == 0);
+  if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
+    const SomeExpr &lhs{assignment->lhs};
+    const SomeExpr &rhs{assignment->rhs};
+    CheckForPureContext(lhs, rhs, std::get<parser::Expr>(stmt.t).source, true);
+    auto restorer{
+        foldingContext().messages().SetLocation(context_.location().value())};
+    CheckPointerAssignment(foldingContext(), *assignment);
   }
 }
 
-void AssignmentContext::Analyze(
-    const parser::WhereConstruct::Elsewhere &elsewhere) {
-  MaskExpr copyCumulative{DEREF(where_).cumulativeMaskExpr};
-  where_->thisMaskExpr = evaluate::LogicalNegation(std::move(copyCumulative));
-  Analyze(std::get<std::list<parser::WhereBodyConstruct>>(elsewhere.t));
-}
-
 // C1594 checks
 static bool IsPointerDummyOfPureFunction(const Symbol &x) {
   return IsPointerDummy(x) && FindPureProcedureContaining(x.owner()) &&
@@ -333,14 +201,45 @@ void AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
   }
 }
 
-MaskExpr AssignmentContext::GetMask(
-    const parser::LogicalExpr &logicalExpr, bool defaultValue) {
-  MaskExpr mask{defaultValue};
-  if (const SomeExpr * expr{GetExpr(logicalExpr)}) {
-    auto *logical{std::get_if<evaluate::Expr<evaluate::SomeLogical>>(&expr->u)};
-    mask = evaluate::ConvertTo(mask, common::Clone(DEREF(logical)));
+// 10.2.3.1(2) The masks and LHS of assignments must all have the same shape
+void AssignmentContext::CheckShape(parser::CharBlock at, const SomeExpr *expr) {
+  if (auto shape{evaluate::GetShape(foldingContext(), expr)}) {
+    std::size_t size{shape->size()};
+    if (whereDepth_ == 0) {
+      whereExtents_.resize(size);
+    } else if (whereExtents_.size() != size) {
+      Say(at,
+          "Must have rank %zd to match prior mask or assignment of"
+          " WHERE construct"_err_en_US,
+          whereExtents_.size());
+      return;
+    }
+    for (std::size_t i{0}; i < size; ++i) {
+      if (std::optional<std::int64_t> extent{evaluate::ToInt64((*shape)[i])}) {
+        if (!whereExtents_[i]) {
+          whereExtents_[i] = *extent;
+        } else if (*whereExtents_[i] != *extent) {
+          Say(at,
+              "Dimension %d must have extent %jd to match prior mask or"
+              " assignment of WHERE construct"_err_en_US,
+              i + 1, static_cast<std::intmax_t>(*whereExtents_[i]));
+        }
+      }
+    }
+  }
+}
+
+template<typename A> void AssignmentContext::PushWhereContext(const A &x) {
+  const auto &expr{std::get<parser::LogicalExpr>(x.t)};
+  CheckShape(expr.thing.value().source, GetExpr(expr));
+  ++whereDepth_;
+}
+
+void AssignmentContext::PopWhereContext() {
+  --whereDepth_;
+  if (whereDepth_ == 0) {
+    whereExtents_.clear();
   }
-  return mask;
 }
 
 AssignmentChecker::~AssignmentChecker() {}
@@ -354,10 +253,22 @@ void AssignmentChecker::Enter(const parser::PointerAssignmentStmt &x) {
   context_.value().Analyze(x);
 }
 void AssignmentChecker::Enter(const parser::WhereStmt &x) {
-  context_.value().Analyze(x);
+  context_.value().PushWhereContext(x);
 }
-void AssignmentChecker::Enter(const parser::WhereConstruct &x) {
-  context_.value().Analyze(x);
+void AssignmentChecker::Leave(const parser::WhereStmt &) {
+  context_.value().PopWhereContext();
+}
+void AssignmentChecker::Enter(const parser::WhereConstructStmt &x) {
+  context_.value().PushWhereContext(x);
+}
+void AssignmentChecker::Leave(const parser::EndWhereStmt &) {
+  context_.value().PopWhereContext();
+}
+void AssignmentChecker::Enter(const parser::MaskedElsewhereStmt &x) {
+  context_.value().PushWhereContext(x);
+}
+void AssignmentChecker::Leave(const parser::MaskedElsewhereStmt &) {
+  context_.value().PopWhereContext();
 }
 
 }
diff --git a/lib/semantics/assignment.h b/lib/semantics/assignment.h
index d86bd45b1823..51b7c1736635 100644
--- a/lib/semantics/assignment.h
+++ b/lib/semantics/assignment.h
@@ -16,9 +16,11 @@
 namespace Fortran::parser {
 class ContextualMessages;
 struct AssignmentStmt;
+struct EndWhereStmt;
+struct MaskedElsewhereStmt;
 struct PointerAssignmentStmt;
+struct WhereConstructStmt;
 struct WhereStmt;
-struct WhereConstruct;
 }
 
 namespace Fortran::semantics {
@@ -41,7 +43,11 @@ class AssignmentChecker : public virtual BaseChecker {
   void Enter(const parser::AssignmentStmt &);
   void Enter(const parser::PointerAssignmentStmt &);
   void Enter(const parser::WhereStmt &);
-  void Enter(const parser::WhereConstruct &);
+  void Leave(const parser::WhereStmt &);
+  void Enter(const parser::WhereConstructStmt &);
+  void Leave(const parser::EndWhereStmt &);
+  void Enter(const parser::MaskedElsewhereStmt &);
+  void Leave(const parser::MaskedElsewhereStmt &);
 
 private:
   common::Indirection<AssignmentContext> context_;
diff --git a/lib/semantics/check-do-forall.cpp b/lib/semantics/check-do-forall.cpp
index 1b1abfd10a84..071a873d72d2 100644
--- a/lib/semantics/check-do-forall.cpp
+++ b/lib/semantics/check-do-forall.cpp
@@ -452,6 +452,7 @@ class DoContext {
         common::visitors{[&](const auto &x) { return GetAssignment(x); }},
         stmt.u)};
     if (assignment) {
+      CheckForallIndexesUsed(*assignment);
       CheckForImpureCall(assignment->lhs);
       CheckForImpureCall(assignment->rhs);
       if (const auto *proc{
@@ -753,6 +754,38 @@ class DoContext {
     }
   }
 
+  // Each index should be used on the LHS of each assignment in a FORALL
+  void CheckForallIndexesUsed(const evaluate::Assignment &assignment) {
+    SymbolVector indexVars{context_.GetIndexVars(IndexVarKind::FORALL)};
+    if (!indexVars.empty()) {
+      SymbolSet symbols{evaluate::CollectSymbols(assignment.lhs)};
+      std::visit(
+          common::visitors{
+              [&](const evaluate::Assignment::BoundsSpec &spec) {
+                for (const auto &bound : spec) {
+                  symbols.merge(evaluate::CollectSymbols(bound));
+                }
+              },
+              [&](const evaluate::Assignment::BoundsRemapping &remapping) {
+                for (const auto &bounds : remapping) {
+                  symbols.merge(evaluate::CollectSymbols(bounds.first));
+                  symbols.merge(evaluate::CollectSymbols(bounds.second));
+                }
+              },
+              [](const auto &) {},
+          },
+          assignment.u);
+      for (const Symbol &index : indexVars) {
+        if (symbols.count(index) == 0) {
+          context_.Say(
+              "Warning: FORALL index variable '%s' not used on left-hand side"
+              " of assignment"_en_US,
+              index.name());
+        }
+      }
+    }
+  }
+
   // For messages where the DO loop must be DO CONCURRENT, make that explicit.
   const char *LoopKindName() const {
     return kind_ == IndexVarKind::DO ? "DO CONCURRENT" : "FORALL";
diff --git a/lib/semantics/semantics.cpp b/lib/semantics/semantics.cpp
index dcb119813a0e..038209160b57 100644
--- a/lib/semantics/semantics.cpp
+++ b/lib/semantics/semantics.cpp
@@ -122,7 +122,8 @@ static bool PerformStatementSemantics(
   RewriteParseTree(context, program);
   CheckDeclarations(context);
   StatementSemanticsPass1{context}.Walk(program);
-  return StatementSemanticsPass2{context}.Walk(program);
+  StatementSemanticsPass2{context}.Walk(program);
+  return !context.AnyFatalError();
 }
 
 SemanticsContext::SemanticsContext(
@@ -261,6 +262,16 @@ void SemanticsContext::DeactivateIndexVar(const parser::Name &name) {
   }
 }
 
+SymbolVector SemanticsContext::GetIndexVars(IndexVarKind kind) {
+  SymbolVector result;
+  for (const auto &[symbol, info] : activeIndexVars_) {
+    if (info.kind == kind) {
+      result.push_back(symbol);
+    }
+  }
+  return result;
+}
+
 bool Semantics::Perform() {
   return ValidateLabels(context_, program_) &&
       parser::CanonicalizeDo(program_) &&  // force line break
diff --git a/test/semantics/assign01.f90 b/test/semantics/assign01.f90
index c2ab99ca0f0f..b125da87ad22 100644
--- a/test/semantics/assign01.f90
+++ b/test/semantics/assign01.f90
@@ -1,14 +1,53 @@
-integer :: a1(10), a2(10)
-logical :: m1(10), m2(5,5)
-m1 = .true.
-m2 = .false.
-a1 = [((i),i=1,10)]
-where (m1)
-  a2 = 1
-!ERROR: mask of ELSEWHERE statement is not conformable with the prior mask(s) in its WHERE construct
-elsewhere (m2)
-  a2 = 2
-elsewhere
-  a2 = 3
-end where
+! 10.2.3.1(2) All masks and LHS of assignments in a WHERE must conform
+
+subroutine s1
+  integer :: a1(10), a2(10)
+  logical :: m1(10), m2(5,5)
+  m1 = .true.
+  m2 = .false.
+  a1 = [((i),i=1,10)]
+  where (m1)
+    a2 = 1
+  !ERROR: Must have rank 1 to match prior mask or assignment of WHERE construct
+  elsewhere (m2)
+    a2 = 2
+  elsewhere
+    a2 = 3
+  end where
+end
+
+subroutine s2
+  logical, allocatable :: m1(:), m4(:,:)
+  logical :: m2(2), m3(3)
+  where(m1)
+    where(m2)
+    end where
+    !ERROR: Dimension 1 must have extent 2 to match prior mask or assignment of WHERE construct
+    where(m3)
+    end where
+    !ERROR: Must have rank 1 to match prior mask or assignment of WHERE construct
+    where(m4)
+    end where
+  endwhere
+  where(m1)
+    where(m3)
+    end where
+  !ERROR: Dimension 1 must have extent 3 to match prior mask or assignment of WHERE construct
+  elsewhere(m2)
+  end where
+end
+
+subroutine s3
+  logical, allocatable :: m1(:,:)
+  logical :: m2(4,2)
+  real :: x(4,4), y(4,4)
+  real :: a(4,5), b(4,5)
+  where(m1)
+    x = y
+    !ERROR: Dimension 2 must have extent 4 to match prior mask or assignment of WHERE construct
+    a = b
+    !ERROR: Dimension 2 must have extent 4 to match prior mask or assignment of WHERE construct
+    where(m2)
+    end where
+  end where
 end
diff --git a/test/semantics/forall01.f90 b/test/semantics/forall01.f90
index bd665e2a5283..e90a17f62978 100644
--- a/test/semantics/forall01.f90
+++ b/test/semantics/forall01.f90
@@ -16,7 +16,6 @@ subroutine forall1
   end forall
 end
 
-
 subroutine forall2
   integer, pointer :: a(:)
   integer, target :: b(10,10)
@@ -73,3 +72,34 @@ subroutine forall4
   !ERROR: FORALL step expression may not be zero
   forall(i=1:10:zero) a(i) = i
 end
+
+! Note: this gets warnings but not errors
+subroutine forall5
+  real, target :: x(10), y(10)
+  forall(i=1:10)
+    x(i) = y(i)
+  end forall
+  forall(i=1:10)
+    x = y  ! warning: i not used on LHS
+    forall(j=1:10)
+      x(i) = y(i)  ! warning: j not used on LHS
+      x(j) = y(j)  ! warning: i not used on LHS
+    endforall
+  endforall
+  do concurrent(i=1:10)
+    x = y
+    forall(i=1:10) x = y
+  end do
+end
+
+subroutine forall6
+  type t
+    real, pointer :: p
+  end type
+  type(t) :: a(10)
+  real, target :: b(10)
+  forall(i=1:10)
+    a(i)%p => b(i)
+    a(1)%p => b(i)  ! warning: i not used on LHS
+  end forall
+end

From 72aa278f0341f345a12fcd76a6ad1f2045ecc233 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Fri, 21 Feb 2020 16:25:10 -0800
Subject: [PATCH 042/345] Temporarily disable part of data01 test

`data x /a(1)/` is ambiguous. The data value may be an array element
or a structure constructor. We need to parse it as one of these and
then fix up the parse tree when it should have been the other one.

My PR 1012 changed the parser to identify this as an array element.
That makes this test invalid until we have the right parse tree fixup,
so I am disabling it for now.
---
 test/semantics/data01.f90 | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/semantics/data01.f90 b/test/semantics/data01.f90
index 02c4674d241d..db978331d541 100644
--- a/test/semantics/data01.f90
+++ b/test/semantics/data01.f90
@@ -37,12 +37,12 @@ subroutine CheckRepeat
   DATA myName%age / digits(myAge) * 35 /
 end
 
-subroutine CheckValue
-  use m1
-  !C883
-  !ERROR: Derived type 'persn' not found
-  DATA myname / persn(2, 'Abcd Efgh') /
-  !C884
-  !ERROR: Structure constructor in data value must be a constant expression
-  DATA myname / person(myAge, 'Abcd Ijkl') /
-end
+!subroutine CheckValue
+!  use m1
+!  !C883
+!  !ERROR: Derived type 'persn' not found
+!  DATA myname / persn(2, 'Abcd Efgh') /
+!  !C884
+!  !ERROR: Structure constructor in data value must be a constant expression
+!  DATA myname / person(myAge, 'Abcd Ijkl') /
+!end

From d2eb7a1c443d1539ef12b6f027074a0eb15b1ea0 Mon Sep 17 00:00:00 2001
From: CarolineConcatto <51754594+CarolineConcatto@users.noreply.github.com>
Date: Tue, 25 Feb 2020 15:11:52 +0000
Subject: [PATCH 043/345] [LLVMify F18] Compiler module folders should have
 capitalised names (#980)

This patch renames the modules in f18 to use a capital letter in the
module name

Signed-off-by: Caroline Concatto <caroline.concatto@arm.com>
---
 documentation/C++style.md                     |   2 +-
 documentation/ImplementingASemanticCheck.md   |  46 +++++++++---------
 .../{common => Common}/Fortran-features.h     |   8 +--
 include/flang/{common => Common}/Fortran.h    |   2 +-
 .../{common => Common}/bit-population-count.h |   2 +-
 .../{common => Common}/constexpr-bitset.h     |   2 +-
 .../flang/{common => Common}/default-kinds.h  |   4 +-
 include/flang/{common => Common}/enum-set.h   |   2 +-
 include/flang/{common => Common}/format.h     |   4 +-
 include/flang/{common => Common}/idioms.h     |   2 +-
 .../flang/{common => Common}/indirection.h    |   2 +-
 include/flang/{common => Common}/interval.h   |   2 +-
 .../leading-zero-bit-count.h                  |   2 +-
 include/flang/{common => Common}/real.h       |   2 +-
 .../{common => Common}/reference-counted.h    |   2 +-
 include/flang/{common => Common}/reference.h  |   2 +-
 include/flang/{common => Common}/restorer.h   |   2 +-
 include/flang/{common => Common}/template.h   |   4 +-
 include/flang/{common => Common}/uint128.h    |   2 +-
 .../unsigned-const-division.h                 |   2 +-
 include/flang/{common => Common}/unwrap.h     |   2 +-
 .../binary-floating-point.h                   |   6 +--
 include/flang/{decimal => Decimal}/decimal.h  |   2 +-
 include/flang/{evaluate => Evaluate}/call.h   |  10 ++--
 .../{evaluate => Evaluate}/characteristics.h  |  14 +++---
 .../{evaluate => Evaluate}/check-expression.h |   2 +-
 include/flang/{evaluate => Evaluate}/common.h |  18 +++----
 .../flang/{evaluate => Evaluate}/complex.h    |   2 +-
 .../flang/{evaluate => Evaluate}/constant.h   |   6 +--
 .../flang/{evaluate => Evaluate}/expression.h |  12 ++---
 include/flang/{evaluate => Evaluate}/fold.h   |   2 +-
 .../flang/{evaluate => Evaluate}/formatting.h |   6 +--
 .../flang/{evaluate => Evaluate}/integer.h    |   8 +--
 .../intrinsics-library.h                      |   2 +-
 .../flang/{evaluate => Evaluate}/intrinsics.h |   8 +--
 .../flang/{evaluate => Evaluate}/logical.h    |   2 +-
 include/flang/{evaluate => Evaluate}/real.h   |   6 +--
 .../{evaluate => Evaluate}/rounding-bits.h    |   2 +-
 include/flang/{evaluate => Evaluate}/shape.h  |   8 +--
 .../{evaluate => Evaluate}/static-data.h      |   4 +-
 include/flang/{evaluate => Evaluate}/tools.h  |  18 +++----
 .../flang/{evaluate => Evaluate}/traverse.h   |   6 +--
 include/flang/{evaluate => Evaluate}/type.h   |   8 +--
 .../flang/{evaluate => Evaluate}/variable.h   |  10 ++--
 include/flang/{lower => Lower}/.clang-format  |   0
 include/flang/{lower => Lower}/PFTBuilder.h   |   6 +--
 .../{optimizer => Optimizer}/.clang-format    |   0
 include/flang/{parser => Parser}/char-block.h |   4 +-
 .../flang/{parser => Parser}/char-buffer.h    |   2 +-
 include/flang/{parser => Parser}/char-set.h   |   2 +-
 include/flang/{parser => Parser}/characters.h |   2 +-
 .../{parser => Parser}/dump-parse-tree.h      |   6 +--
 .../{parser => Parser}/format-specification.h |   2 +-
 .../{parser => Parser}/instrumented-parser.h  |   6 +--
 include/flang/{parser => Parser}/message.h    |   8 +--
 .../flang/{parser => Parser}/parse-state.h    |  12 ++---
 .../{parser => Parser}/parse-tree-visitor.h   |   2 +-
 include/flang/{parser => Parser}/parse-tree.h |   8 +--
 include/flang/{parser => Parser}/parsing.h    |   4 +-
 include/flang/{parser => Parser}/provenance.h |   6 +--
 include/flang/{parser => Parser}/source.h     |   2 +-
 include/flang/{parser => Parser}/tools.h      |   2 +-
 include/flang/{parser => Parser}/unparse.h    |   2 +-
 include/flang/{parser => Parser}/user-state.h |  10 ++--
 include/flang/{semantics => Semantics}/attr.h |   6 +--
 .../{semantics => Semantics}/expression.h     |  24 ++++-----
 .../flang/{semantics => Semantics}/scope.h    |  12 ++---
 .../{semantics => Semantics}/semantics.h      |  10 ++--
 .../flang/{semantics => Semantics}/symbol.h   |  10 ++--
 .../flang/{semantics => Semantics}/tools.h    |  20 ++++----
 include/flang/{semantics => Semantics}/type.h |  10 ++--
 .../unparse-with-symbols.h                    |   4 +-
 lib/CMakeLists.txt                            |  12 ++---
 lib/{common => Common}/CMakeLists.txt         |   2 +-
 lib/{common => Common}/Fortran-features.cpp   |   8 +--
 lib/{common => Common}/Fortran.cpp            |   4 +-
 lib/{common => Common}/default-kinds.cpp      |   6 +--
 lib/{common => Common}/idioms.cpp             |   4 +-
 lib/{decimal => Decimal}/CMakeLists.txt       |   2 +-
 .../big-radix-floating-point.h                |  14 +++---
 .../binary-to-decimal.cpp                     |   4 +-
 .../decimal-to-binary.cpp                     |  10 ++--
 lib/{evaluate => Evaluate}/CMakeLists.txt     |   2 +-
 lib/{evaluate => Evaluate}/call.cpp           |  14 +++---
 lib/{evaluate => Evaluate}/character.h        |   4 +-
 .../characteristics.cpp                       |  22 ++++-----
 .../check-expression.cpp                      |  12 ++---
 lib/{evaluate => Evaluate}/common.cpp         |   6 +--
 lib/{evaluate => Evaluate}/complex.cpp        |   4 +-
 lib/{evaluate => Evaluate}/constant.cpp       |  10 ++--
 lib/{evaluate => Evaluate}/expression.cpp     |  14 +++---
 lib/{evaluate => Evaluate}/fold-character.cpp |   2 +-
 lib/{evaluate => Evaluate}/fold-complex.cpp   |   2 +-
 .../fold-implementation.h                     |  36 +++++++-------
 lib/{evaluate => Evaluate}/fold-integer.cpp   |   2 +-
 lib/{evaluate => Evaluate}/fold-logical.cpp   |   4 +-
 lib/{evaluate => Evaluate}/fold-real.cpp      |   2 +-
 lib/{evaluate => Evaluate}/fold.cpp           |   4 +-
 lib/{evaluate => Evaluate}/formatting.cpp     |  18 +++----
 lib/{evaluate => Evaluate}/host.cpp           |   4 +-
 lib/{evaluate => Evaluate}/host.h             |   4 +-
 lib/{evaluate => Evaluate}/int-power.h        |   4 +-
 lib/{evaluate => Evaluate}/integer.cpp        |   4 +-
 .../intrinsics-library-templates.h            |   8 +--
 .../intrinsics-library.cpp                    |   2 +-
 lib/{evaluate => Evaluate}/intrinsics.cpp     |  22 ++++-----
 lib/{evaluate => Evaluate}/logical.cpp        |   4 +-
 lib/{evaluate => Evaluate}/real.cpp           |  10 ++--
 lib/{evaluate => Evaluate}/shape.cpp          |  22 ++++-----
 lib/{evaluate => Evaluate}/static-data.cpp    |   6 +--
 lib/{evaluate => Evaluate}/tools.cpp          |  12 ++---
 lib/{evaluate => Evaluate}/type.cpp           |  22 ++++-----
 lib/{evaluate => Evaluate}/variable.cpp       |  18 +++----
 lib/{fir => Fir}/.clang-format                |   0
 lib/{lower => Lower}/.clang-format            |   0
 lib/{lower => Lower}/CMakeLists.txt           |   0
 lib/{lower => Lower}/PFTBuilder.cpp           |   8 +--
 lib/{optimizer => Optimizer}/.clang-format    |   0
 lib/{parser => Parser}/CMakeLists.txt         |   2 +-
 lib/{parser => Parser}/Fortran-parsers.cpp    |   6 +--
 lib/{parser => Parser}/basic-parsers.h        |  18 +++----
 lib/{parser => Parser}/char-block.cpp         |   4 +-
 lib/{parser => Parser}/char-buffer.cpp        |   6 +--
 lib/{parser => Parser}/char-set.cpp           |   4 +-
 lib/{parser => Parser}/characters.cpp         |   6 +--
 lib/{parser => Parser}/debug-parser.cpp       |   4 +-
 lib/{parser => Parser}/debug-parser.h         |   4 +-
 lib/{parser => Parser}/executable-parsers.cpp |   6 +--
 lib/{parser => Parser}/expr-parsers.cpp       |   6 +--
 lib/{parser => Parser}/expr-parsers.h         |   4 +-
 .../instrumented-parser.cpp                   |   8 +--
 lib/{parser => Parser}/io-parsers.cpp         |   6 +--
 lib/{parser => Parser}/message.cpp            |   8 +--
 lib/{parser => Parser}/misc-parsers.h         |   6 +--
 lib/{parser => Parser}/openmp-parsers.cpp     |   4 +-
 lib/{parser => Parser}/parse-tree.cpp         |  10 ++--
 lib/{parser => Parser}/parsing.cpp            |  10 ++--
 lib/{parser => Parser}/preprocessor.cpp       |   8 +--
 lib/{parser => Parser}/preprocessor.h         |   6 +--
 lib/{parser => Parser}/prescan.cpp            |  10 ++--
 lib/{parser => Parser}/prescan.h              |  10 ++--
 lib/{parser => Parser}/program-parsers.cpp    |   6 +--
 lib/{parser => Parser}/provenance.cpp         |   6 +--
 lib/{parser => Parser}/source.cpp             |   8 +--
 lib/{parser => Parser}/stmt-parser.h          |   2 +-
 lib/{parser => Parser}/token-parsers.h        |  12 ++---
 lib/{parser => Parser}/token-sequence.cpp     |   4 +-
 lib/{parser => Parser}/token-sequence.h       |   6 +--
 lib/{parser => Parser}/tools.cpp              |   4 +-
 .../type-parser-implementation.h              |   2 +-
 lib/{parser => Parser}/type-parsers.h         |   6 +--
 lib/{parser => Parser}/unparse.cpp            |  16 +++---
 lib/{parser => Parser}/user-state.cpp         |   6 +--
 lib/{semantics => Semantics}/CMakeLists.txt   |   2 +-
 lib/{semantics => Semantics}/assignment.cpp   |  26 +++++-----
 lib/{semantics => Semantics}/assignment.h     |   8 +--
 lib/{semantics => Semantics}/attr.cpp         |   6 +--
 .../canonicalize-do.cpp                       |   4 +-
 .../canonicalize-do.h                         |   2 +-
 .../canonicalize-omp.cpp                      |   4 +-
 .../canonicalize-omp.h                        |   2 +-
 .../check-allocate.cpp                        |  18 +++----
 lib/{semantics => Semantics}/check-allocate.h |   4 +-
 .../check-arithmeticif.cpp                    |   8 +--
 .../check-arithmeticif.h                      |   4 +-
 lib/{semantics => Semantics}/check-call.cpp   |  18 +++----
 lib/{semantics => Semantics}/check-call.h     |   4 +-
 .../check-coarray.cpp                         |  16 +++---
 lib/{semantics => Semantics}/check-coarray.h  |   4 +-
 lib/{semantics => Semantics}/check-data.cpp   |   2 +-
 lib/{semantics => Semantics}/check-data.h     |  10 ++--
 .../check-deallocate.cpp                      |  10 ++--
 .../check-deallocate.h                        |   4 +-
 .../check-declarations.cpp                    |  18 +++----
 .../check-declarations.h                      |   2 +-
 .../check-do-forall.cpp                       |  28 +++++------
 .../check-do-forall.h                         |   6 +--
 .../check-if-stmt.cpp                         |   8 +--
 lib/{semantics => Semantics}/check-if-stmt.h  |   4 +-
 lib/{semantics => Semantics}/check-io.cpp     |  10 ++--
 lib/{semantics => Semantics}/check-io.h       |  10 ++--
 .../check-nullify.cpp                         |  12 ++---
 lib/{semantics => Semantics}/check-nullify.h  |   4 +-
 .../check-omp-structure.cpp                   |   6 +--
 .../check-omp-structure.h                     |   8 +--
 lib/{semantics => Semantics}/check-purity.cpp |   6 +--
 lib/{semantics => Semantics}/check-purity.h   |   4 +-
 lib/{semantics => Semantics}/check-return.cpp |  12 ++---
 lib/{semantics => Semantics}/check-return.h   |   4 +-
 lib/{semantics => Semantics}/check-stop.cpp   |  12 ++---
 lib/{semantics => Semantics}/check-stop.h     |   4 +-
 lib/{semantics => Semantics}/expression.cpp   |  30 ++++++------
 lib/{semantics => Semantics}/mod-file.cpp     |  16 +++---
 lib/{semantics => Semantics}/mod-file.h       |   4 +-
 .../pointer-assignment.cpp                    |  26 +++++-----
 .../pointer-assignment.h                      |   8 +--
 lib/{semantics => Semantics}/program-tree.cpp |   8 +--
 lib/{semantics => Semantics}/program-tree.h   |   6 +--
 .../resolve-labels.cpp                        |  10 ++--
 lib/{semantics => Semantics}/resolve-labels.h |   2 +-
 .../resolve-names-utils.cpp                   |  24 ++++-----
 .../resolve-names-utils.h                     |  10 ++--
 .../resolve-names.cpp                         |  42 ++++++++--------
 lib/{semantics => Semantics}/resolve-names.h  |   2 +-
 .../rewrite-parse-tree.cpp                    |  18 +++----
 .../rewrite-parse-tree.h                      |   2 +-
 lib/{semantics => Semantics}/scope.cpp        |  10 ++--
 lib/{semantics => Semantics}/semantics.cpp    |  16 +++---
 lib/{semantics => Semantics}/symbol.cpp       |  14 +++---
 lib/{semantics => Semantics}/tools.cpp        |  24 ++++-----
 lib/{semantics => Semantics}/type.cpp         |  14 +++---
 .../unparse-with-symbols.cpp                  |  12 ++---
 runtime/descriptor.cpp                        |   2 +-
 runtime/environment.h                         |   2 +-
 runtime/format-implementation.h               |   4 +-
 runtime/format.h                              |   4 +-
 runtime/numeric-output.cpp                    |   2 +-
 runtime/numeric-output.h                      |   2 +-
 runtime/transformational.cpp                  |   4 +-
 runtime/type-code.h                           |   2 +-
 test-lit/{driver => Driver}/version_test.f90  |   0
 test-lit/{lower => Lower}/pre-fir-tree01.f90  |   0
 test-lit/{lower => Lower}/pre-fir-tree02.f90  |   0
 test-lit/{lower => Lower}/pre-fir-tree03.f90  |   0
 test-lit/{lower => Lower}/pre-fir-tree04.f90  |   0
 test/CMakeLists.txt                           |   8 +--
 test/{decimal => Decimal}/CMakeLists.txt      |   2 +-
 .../quick-sanity-test.cpp                     |   2 +-
 test/{decimal => Decimal}/thorough-test.cpp   |   2 +-
 test/{evaluate => Evaluate}/CMakeLists.txt    |   4 +-
 .../ISO-Fortran-binding.cpp                   |   0
 .../bit-population-count.cpp                  |   2 +-
 test/{evaluate => Evaluate}/expression.cpp    |  10 ++--
 test/{evaluate => Evaluate}/folding.cpp       |  14 +++---
 test/{evaluate => Evaluate}/folding01.f90     |   0
 test/{evaluate => Evaluate}/folding02.f90     |   0
 test/{evaluate => Evaluate}/folding03.f90     |   0
 test/{evaluate => Evaluate}/folding04.f90     |   0
 test/{evaluate => Evaluate}/folding05.f90     | Bin
 test/{evaluate => Evaluate}/folding06.f90     |   0
 test/{evaluate => Evaluate}/folding07.f90     |   0
 test/{evaluate => Evaluate}/folding08.f90     |   0
 test/{evaluate => Evaluate}/folding09.f90     |   0
 test/{evaluate => Evaluate}/fp-testing.cpp    |   0
 test/{evaluate => Evaluate}/fp-testing.h      |   2 +-
 test/{evaluate => Evaluate}/integer.cpp       |   2 +-
 test/{evaluate => Evaluate}/intrinsics.cpp    |  10 ++--
 .../leading-zero-bit-count.cpp                |   2 +-
 test/{evaluate => Evaluate}/logical.cpp       |   2 +-
 test/{evaluate => Evaluate}/real.cpp          |   2 +-
 test/{evaluate => Evaluate}/reshape.cpp       |   0
 test/{evaluate => Evaluate}/test_folding.sh   |   0
 test/{evaluate => Evaluate}/testing.cpp       |   0
 test/{evaluate => Evaluate}/testing.h         |   0
 test/{evaluate => Evaluate}/uint128.cpp       |   2 +-
 test/{preprocessing => Preprocessing}/pp001.F |   0
 test/{preprocessing => Preprocessing}/pp002.F |   0
 test/{preprocessing => Preprocessing}/pp003.F |   0
 test/{preprocessing => Preprocessing}/pp004.F |   0
 test/{preprocessing => Preprocessing}/pp005.F |   0
 test/{preprocessing => Preprocessing}/pp006.F |   0
 test/{preprocessing => Preprocessing}/pp007.F |   0
 test/{preprocessing => Preprocessing}/pp008.F |   0
 test/{preprocessing => Preprocessing}/pp009.F |   0
 test/{preprocessing => Preprocessing}/pp010.F |   0
 test/{preprocessing => Preprocessing}/pp011.F |   0
 test/{preprocessing => Preprocessing}/pp012.F |   0
 test/{preprocessing => Preprocessing}/pp013.F |   0
 test/{preprocessing => Preprocessing}/pp014.F |   0
 test/{preprocessing => Preprocessing}/pp015.F |   0
 test/{preprocessing => Preprocessing}/pp016.F |   0
 test/{preprocessing => Preprocessing}/pp017.F |   0
 test/{preprocessing => Preprocessing}/pp018.F |   0
 test/{preprocessing => Preprocessing}/pp019.F |   0
 test/{preprocessing => Preprocessing}/pp020.F |   0
 test/{preprocessing => Preprocessing}/pp021.F |   0
 test/{preprocessing => Preprocessing}/pp022.F |   0
 test/{preprocessing => Preprocessing}/pp023.F |   0
 test/{preprocessing => Preprocessing}/pp024.F |   0
 test/{preprocessing => Preprocessing}/pp025.F |   0
 test/{preprocessing => Preprocessing}/pp026.F |   0
 test/{preprocessing => Preprocessing}/pp027.F |   0
 test/{preprocessing => Preprocessing}/pp028.F |   0
 test/{preprocessing => Preprocessing}/pp029.F |   0
 test/{preprocessing => Preprocessing}/pp030.F |   0
 test/{preprocessing => Preprocessing}/pp031.F |   0
 test/{preprocessing => Preprocessing}/pp032.F |   0
 test/{preprocessing => Preprocessing}/pp033.F |   0
 test/{preprocessing => Preprocessing}/pp034.F |   0
 test/{preprocessing => Preprocessing}/pp035.F |   0
 test/{preprocessing => Preprocessing}/pp036.F |   0
 test/{preprocessing => Preprocessing}/pp037.F |   0
 test/{preprocessing => Preprocessing}/pp038.F |   0
 test/{preprocessing => Preprocessing}/pp039.F |   0
 test/{preprocessing => Preprocessing}/pp040.F |   0
 test/{preprocessing => Preprocessing}/pp041.F |   0
 test/{preprocessing => Preprocessing}/pp042.F |   0
 test/{preprocessing => Preprocessing}/pp043.F |   0
 test/{preprocessing => Preprocessing}/pp044.F |   0
 .../pp101.F90                                 |   0
 .../pp102.F90                                 |   0
 .../pp103.F90                                 |   0
 .../pp104.F90                                 |   0
 .../pp105.F90                                 |   0
 .../pp106.F90                                 |   0
 .../pp107.F90                                 |   0
 .../pp108.F90                                 |   0
 .../pp109.F90                                 |   0
 .../pp110.F90                                 |   0
 .../pp111.F90                                 |   0
 .../pp112.F90                                 |   0
 .../pp113.F90                                 |   0
 .../pp114.F90                                 |   0
 .../pp115.F90                                 |   0
 .../pp116.F90                                 |   0
 .../pp117.F90                                 |   0
 .../pp118.F90                                 |   0
 .../pp119.F90                                 |   0
 .../pp120.F90                                 |   0
 .../pp121.F90                                 |   0
 .../pp122.F90                                 |   0
 .../pp123.F90                                 |   0
 .../pp124.F90                                 |   0
 .../pp125.F90                                 |   0
 .../pp126.F90                                 |   0
 .../pp127.F90                                 |   0
 .../pp128.F90                                 |   0
 .../pp129.F90                                 |   0
 .../pp130.F90                                 |   0
 test/{runtime => Runtime}/CMakeLists.txt      |   2 +-
 test/{runtime => Runtime}/external-hello.cpp  |   0
 test/{runtime => Runtime}/format.cpp          |   0
 test/{runtime => Runtime}/hello.cpp           |   0
 test/{semantics => Semantics}/CMakeLists.txt  |   2 +-
 test/{semantics => Semantics}/allocate01.f90  |   0
 test/{semantics => Semantics}/allocate02.f90  |   0
 test/{semantics => Semantics}/allocate03.f90  |   0
 test/{semantics => Semantics}/allocate04.f90  |   0
 test/{semantics => Semantics}/allocate05.f90  |   0
 test/{semantics => Semantics}/allocate06.f90  |   0
 test/{semantics => Semantics}/allocate07.f90  |   0
 test/{semantics => Semantics}/allocate08.f90  |   0
 test/{semantics => Semantics}/allocate09.f90  |   0
 test/{semantics => Semantics}/allocate10.f90  |   0
 test/{semantics => Semantics}/allocate11.f90  |   0
 test/{semantics => Semantics}/allocate12.f90  |   0
 test/{semantics => Semantics}/allocate13.f90  |   0
 test/{semantics => Semantics}/altreturn01.f90 |   0
 test/{semantics => Semantics}/altreturn02.f90 |   0
 test/{semantics => Semantics}/altreturn03.f90 |   0
 test/{semantics => Semantics}/altreturn04.f90 |   0
 test/{semantics => Semantics}/altreturn05.f90 |   0
 test/{semantics => Semantics}/assign01.f90    |   0
 test/{semantics => Semantics}/assign02.f90    |   0
 test/{semantics => Semantics}/assign03.f90    |   0
 .../bad-forward-type.f90                      |   0
 test/{semantics => Semantics}/bindings01.f90  |   0
 .../{semantics => Semantics}/block-data01.f90 |   0
 .../blockconstruct01.f90                      |   0
 .../blockconstruct02.f90                      |   0
 .../blockconstruct03.f90                      |   0
 test/{semantics => Semantics}/c_f_pointer.f90 |   0
 test/{semantics => Semantics}/call01.f90      |   0
 test/{semantics => Semantics}/call02.f90      |   0
 test/{semantics => Semantics}/call03.f90      |   0
 test/{semantics => Semantics}/call04.f90      |   0
 test/{semantics => Semantics}/call05.f90      |   0
 test/{semantics => Semantics}/call06.f90      |   0
 test/{semantics => Semantics}/call07.f90      |   0
 test/{semantics => Semantics}/call08.f90      |   0
 test/{semantics => Semantics}/call09.f90      |   0
 test/{semantics => Semantics}/call10.f90      |   0
 test/{semantics => Semantics}/call11.f90      |   0
 test/{semantics => Semantics}/call12.f90      |   0
 test/{semantics => Semantics}/call13.f90      |   0
 test/{semantics => Semantics}/call14.f90      |   0
 test/{semantics => Semantics}/call15.f90      |   0
 test/{semantics => Semantics}/canondo01.f90   |   0
 test/{semantics => Semantics}/canondo02.f90   |   0
 test/{semantics => Semantics}/canondo03.f90   |   0
 test/{semantics => Semantics}/canondo04.f90   |   0
 test/{semantics => Semantics}/canondo05.f90   |   0
 test/{semantics => Semantics}/canondo06.f90   |   0
 test/{semantics => Semantics}/canondo07.f90   |   0
 test/{semantics => Semantics}/canondo08.f90   |   0
 test/{semantics => Semantics}/canondo09.f90   |   0
 test/{semantics => Semantics}/canondo10.f90   |   0
 test/{semantics => Semantics}/canondo11.f90   |   0
 test/{semantics => Semantics}/canondo12.f90   |   0
 test/{semantics => Semantics}/canondo13.f90   |   0
 test/{semantics => Semantics}/canondo14.f90   |   0
 test/{semantics => Semantics}/canondo15.f90   |   0
 test/{semantics => Semantics}/canondo16.f90   |   0
 test/{semantics => Semantics}/canondo17.f90   |   0
 test/{semantics => Semantics}/canondo18.f90   |   0
 test/{semantics => Semantics}/canondo19.f90   |   0
 test/{semantics => Semantics}/coarrays01.f90  |   0
 test/{semantics => Semantics}/common.sh       |   0
 .../computed-goto01.f90                       |   0
 .../computed-goto02.f90                       |   0
 test/{semantics => Semantics}/critical01.f90  |   0
 test/{semantics => Semantics}/critical02.f90  |   0
 test/{semantics => Semantics}/critical03.f90  |   0
 test/{semantics => Semantics}/critical04.f90  |   0
 test/{semantics => Semantics}/data01.f90      |   0
 .../{semantics => Semantics}/deallocate01.f90 |   0
 .../{semantics => Semantics}/deallocate04.f90 |   0
 .../{semantics => Semantics}/deallocate05.f90 |   0
 .../doconcurrent01.f90                        |   0
 .../doconcurrent02.f90                        |   0
 .../doconcurrent03.f90                        |   0
 .../doconcurrent04.f90                        |   0
 .../doconcurrent05.f90                        |   0
 .../doconcurrent06.f90                        |   0
 .../doconcurrent07.f90                        |   0
 .../doconcurrent08.f90                        |   2 +-
 .../dosemantics01.f90                         |   0
 .../dosemantics02.f90                         |   0
 .../dosemantics03.f90                         |   0
 .../dosemantics04.f90                         |   0
 .../dosemantics05.f90                         |   0
 .../dosemantics06.f90                         |   0
 .../dosemantics07.f90                         |   0
 .../dosemantics08.f90                         |   0
 .../dosemantics09.f90                         |   0
 .../dosemantics10.f90                         |   0
 .../dosemantics11.f90                         |   0
 .../dosemantics12.f90                         |   0
 .../equivalence01.f90                         |   0
 .../expr-errors01.f90                         |   0
 .../expr-errors02.f90                         |   0
 test/{semantics => Semantics}/forall01.f90    |   0
 .../getdefinition01.f90                       |   0
 .../getdefinition02.f                         |   0
 .../getdefinition03-a.f90                     |   0
 .../getdefinition03-b.f90                     |   0
 .../getdefinition04.f90                       |   0
 .../getdefinition05.f90                       |   0
 .../{semantics => Semantics}/getsymbols01.f90 |   0
 .../getsymbols02-a.f90                        |   0
 .../getsymbols02-b.f90                        |   0
 .../getsymbols02-c.f90                        |   0
 .../getsymbols03-a.f90                        |   0
 .../getsymbols03-b.f90                        |   0
 .../{semantics => Semantics}/getsymbols04.f90 |   0
 .../{semantics => Semantics}/getsymbols05.f90 |   0
 test/{semantics => Semantics}/if_arith01.f90  |   0
 test/{semantics => Semantics}/if_arith02.f90  |   0
 test/{semantics => Semantics}/if_arith03.f90  |   0
 test/{semantics => Semantics}/if_arith04.f90  |   0
 .../if_construct01.f90                        |   0
 .../if_construct02.f90                        |   0
 test/{semantics => Semantics}/if_stmt01.f90   |   0
 test/{semantics => Semantics}/if_stmt02.f90   |   0
 test/{semantics => Semantics}/if_stmt03.f90   |   0
 test/{semantics => Semantics}/implicit01.f90  |   0
 test/{semantics => Semantics}/implicit02.f90  |   0
 test/{semantics => Semantics}/implicit03.f90  |   0
 test/{semantics => Semantics}/implicit04.f90  |   0
 test/{semantics => Semantics}/implicit05.f90  |   0
 test/{semantics => Semantics}/implicit06.f90  |   0
 test/{semantics => Semantics}/implicit07.f90  |   0
 test/{semantics => Semantics}/implicit08.f90  |   0
 test/{semantics => Semantics}/init01.f90      |   0
 .../{semantics => Semantics}/int-literals.f90 |   0
 test/{semantics => Semantics}/io01.f90        |   0
 test/{semantics => Semantics}/io02.f90        |   0
 test/{semantics => Semantics}/io03.f90        |   0
 test/{semantics => Semantics}/io04.f90        |   0
 test/{semantics => Semantics}/io05.f90        |   0
 test/{semantics => Semantics}/io06.f90        |   0
 test/{semantics => Semantics}/io07.f90        |   0
 test/{semantics => Semantics}/io08.f90        |   0
 test/{semantics => Semantics}/io09.f90        |   0
 test/{semantics => Semantics}/io10.f90        |   0
 test/{semantics => Semantics}/kinds01.f90     |   0
 test/{semantics => Semantics}/kinds02.f90     |   0
 test/{semantics => Semantics}/kinds03.f90     |   0
 test/{semantics => Semantics}/label01.F90     |   0
 test/{semantics => Semantics}/label02.f90     |   0
 test/{semantics => Semantics}/label03.f90     |   0
 test/{semantics => Semantics}/label04.f90     |   0
 test/{semantics => Semantics}/label05.f90     |   0
 test/{semantics => Semantics}/label06.f90     |   0
 test/{semantics => Semantics}/label07.f90     |   0
 test/{semantics => Semantics}/label08.f90     |   0
 test/{semantics => Semantics}/label09.f90     |   0
 test/{semantics => Semantics}/label10.f90     |   0
 test/{semantics => Semantics}/label11.f90     |   0
 test/{semantics => Semantics}/label12.f90     |   0
 test/{semantics => Semantics}/label13.f90     |   0
 test/{semantics => Semantics}/label14.f90     |   0
 .../misc-declarations.f90                     |   0
 test/{semantics => Semantics}/modfile01.f90   |   0
 test/{semantics => Semantics}/modfile02.f90   |   0
 test/{semantics => Semantics}/modfile03.f90   |   0
 test/{semantics => Semantics}/modfile04.f90   |   0
 test/{semantics => Semantics}/modfile05.f90   |   0
 test/{semantics => Semantics}/modfile06.f90   |   0
 test/{semantics => Semantics}/modfile07.f90   |   0
 test/{semantics => Semantics}/modfile08.f90   |   0
 test/{semantics => Semantics}/modfile09-a.f90 |   0
 test/{semantics => Semantics}/modfile09-b.f90 |   0
 test/{semantics => Semantics}/modfile09-c.f90 |   0
 test/{semantics => Semantics}/modfile09-d.f90 |   0
 test/{semantics => Semantics}/modfile10.f90   |   0
 test/{semantics => Semantics}/modfile11.f90   |   0
 test/{semantics => Semantics}/modfile12.f90   |   0
 test/{semantics => Semantics}/modfile13.f90   |   0
 test/{semantics => Semantics}/modfile14.f90   |   0
 test/{semantics => Semantics}/modfile15.f90   |   0
 test/{semantics => Semantics}/modfile16.f90   |   0
 test/{semantics => Semantics}/modfile17.f90   |   0
 test/{semantics => Semantics}/modfile18.f90   |   0
 test/{semantics => Semantics}/modfile19.f90   |   0
 test/{semantics => Semantics}/modfile20.f90   |   0
 test/{semantics => Semantics}/modfile21.f90   |   0
 test/{semantics => Semantics}/modfile22.f90   |   0
 test/{semantics => Semantics}/modfile23.f90   |   0
 test/{semantics => Semantics}/modfile24.f90   |   0
 test/{semantics => Semantics}/modfile25.f90   |   0
 test/{semantics => Semantics}/modfile26.f90   |   0
 test/{semantics => Semantics}/modfile27.f90   |   0
 test/{semantics => Semantics}/modfile28.f90   |   0
 test/{semantics => Semantics}/modfile29.f90   |   0
 test/{semantics => Semantics}/modfile30.f90   |   0
 test/{semantics => Semantics}/modfile31.f90   |   0
 test/{semantics => Semantics}/modfile32.f90   |   0
 test/{semantics => Semantics}/modfile33.f90   |   0
 test/{semantics => Semantics}/modfile34.f90   |   0
 test/{semantics => Semantics}/modfile35.f90   |   0
 test/{semantics => Semantics}/null01.f90      |   0
 test/{semantics => Semantics}/nullify01.f90   |   0
 test/{semantics => Semantics}/nullify02.f90   |   0
 test/{semantics => Semantics}/omp-atomic.f90  |   0
 .../omp-clause-validity01.f90                 |   0
 .../omp-declarative-directive.f90             |   0
 .../omp-device-constructs.f90                 |   0
 .../omp-loop-association.f90                  |   0
 .../{semantics => Semantics}/omp-nested01.f90 |   0
 .../omp-resolve01.f90                         |   0
 .../omp-resolve02.f90                         |   0
 .../omp-resolve03.f90                         |   0
 .../omp-resolve04.f90                         |   0
 .../omp-resolve05.f90                         |   0
 .../{semantics => Semantics}/omp-symbol01.f90 |   0
 .../{semantics => Semantics}/omp-symbol02.f90 |   0
 .../{semantics => Semantics}/omp-symbol03.f90 |   0
 .../{semantics => Semantics}/omp-symbol04.f90 |   0
 .../{semantics => Semantics}/omp-symbol05.f90 |   0
 .../{semantics => Semantics}/omp-symbol06.f90 |   0
 .../{semantics => Semantics}/omp-symbol07.f90 |   0
 .../{semantics => Semantics}/omp-symbol08.f90 |   0
 .../procinterface01.f90                       |   0
 test/{semantics => Semantics}/resolve01.f90   |   0
 test/{semantics => Semantics}/resolve02.f90   |   0
 test/{semantics => Semantics}/resolve03.f90   |   0
 test/{semantics => Semantics}/resolve04.f90   |   0
 test/{semantics => Semantics}/resolve05.f90   |   0
 test/{semantics => Semantics}/resolve06.f90   |   0
 test/{semantics => Semantics}/resolve07.f90   |   0
 test/{semantics => Semantics}/resolve08.f90   |   0
 test/{semantics => Semantics}/resolve09.f90   |   0
 test/{semantics => Semantics}/resolve10.f90   |   0
 test/{semantics => Semantics}/resolve11.f90   |   0
 test/{semantics => Semantics}/resolve12.f90   |   0
 test/{semantics => Semantics}/resolve13.f90   |   0
 test/{semantics => Semantics}/resolve14.f90   |   0
 test/{semantics => Semantics}/resolve15.f90   |   0
 test/{semantics => Semantics}/resolve16.f90   |   0
 test/{semantics => Semantics}/resolve17.f90   |   0
 test/{semantics => Semantics}/resolve18.f90   |   0
 test/{semantics => Semantics}/resolve19.f90   |   0
 test/{semantics => Semantics}/resolve20.f90   |   0
 test/{semantics => Semantics}/resolve21.f90   |   0
 test/{semantics => Semantics}/resolve22.f90   |   0
 test/{semantics => Semantics}/resolve23.f90   |   0
 test/{semantics => Semantics}/resolve24.f90   |   0
 test/{semantics => Semantics}/resolve25.f90   |   0
 test/{semantics => Semantics}/resolve26.f90   |   0
 test/{semantics => Semantics}/resolve27.f90   |   0
 test/{semantics => Semantics}/resolve28.f90   |   0
 test/{semantics => Semantics}/resolve29.f90   |   0
 test/{semantics => Semantics}/resolve30.f90   |   0
 test/{semantics => Semantics}/resolve31.f90   |   0
 test/{semantics => Semantics}/resolve32.f90   |   0
 test/{semantics => Semantics}/resolve33.f90   |   0
 test/{semantics => Semantics}/resolve34.f90   |   0
 test/{semantics => Semantics}/resolve35.f90   |   0
 test/{semantics => Semantics}/resolve36.f90   |   0
 test/{semantics => Semantics}/resolve37.f90   |   0
 test/{semantics => Semantics}/resolve38.f90   |   0
 test/{semantics => Semantics}/resolve39.f90   |   0
 test/{semantics => Semantics}/resolve40.f90   |   0
 test/{semantics => Semantics}/resolve41.f90   |   0
 test/{semantics => Semantics}/resolve42.f90   |   0
 test/{semantics => Semantics}/resolve43.f90   |   0
 test/{semantics => Semantics}/resolve44.f90   |   0
 test/{semantics => Semantics}/resolve45.f90   |   0
 test/{semantics => Semantics}/resolve46.f90   |   0
 test/{semantics => Semantics}/resolve47.f90   |   0
 test/{semantics => Semantics}/resolve48.f90   |   0
 test/{semantics => Semantics}/resolve49.f90   |   0
 test/{semantics => Semantics}/resolve50.f90   |   0
 test/{semantics => Semantics}/resolve51.f90   |   0
 test/{semantics => Semantics}/resolve52.f90   |   0
 test/{semantics => Semantics}/resolve53.f90   |   0
 test/{semantics => Semantics}/resolve54.f90   |   0
 test/{semantics => Semantics}/resolve55.f90   |   0
 test/{semantics => Semantics}/resolve56.f90   |   0
 test/{semantics => Semantics}/resolve57.f90   |   0
 test/{semantics => Semantics}/resolve58.f90   |   0
 test/{semantics => Semantics}/resolve59.f90   |   0
 test/{semantics => Semantics}/resolve60.f90   |   0
 test/{semantics => Semantics}/resolve61.f90   |   0
 test/{semantics => Semantics}/resolve62.f90   |   0
 test/{semantics => Semantics}/resolve63.f90   |   0
 test/{semantics => Semantics}/resolve64.f90   |   0
 test/{semantics => Semantics}/resolve65.f90   |   0
 test/{semantics => Semantics}/resolve66.f90   |   0
 test/{semantics => Semantics}/resolve67.f90   |   0
 test/{semantics => Semantics}/resolve68.f90   |   0
 test/{semantics => Semantics}/resolve69.f90   |   0
 test/{semantics => Semantics}/resolve70.f90   |   0
 test/{semantics => Semantics}/resolve71.f90   |   0
 test/{semantics => Semantics}/resolve72.f90   |   0
 .../separate-module-procs.f90                 |   0
 test/{semantics => Semantics}/stop01.f90      |   0
 .../structconst01.f90                         |   0
 .../structconst02.f90                         |   0
 .../structconst03.f90                         |   2 +-
 .../structconst04.f90                         |   0
 test/{semantics => Semantics}/symbol01.f90    |   0
 test/{semantics => Semantics}/symbol02.f90    |   0
 test/{semantics => Semantics}/symbol03.f90    |   0
 test/{semantics => Semantics}/symbol05.f90    |   0
 test/{semantics => Semantics}/symbol06.f90    |   0
 test/{semantics => Semantics}/symbol07.f90    |   0
 test/{semantics => Semantics}/symbol08.f90    |   0
 test/{semantics => Semantics}/symbol09.f90    |   0
 test/{semantics => Semantics}/symbol10.f90    |   0
 test/{semantics => Semantics}/symbol11.f90    |   0
 test/{semantics => Semantics}/symbol12.f90    |   0
 test/{semantics => Semantics}/symbol13.f90    |   0
 test/{semantics => Semantics}/symbol14.f90    |   0
 test/{semantics => Semantics}/symbol15.f90    |   0
 test/{semantics => Semantics}/symbol16.f90    |   0
 test/{semantics => Semantics}/symbol17.f90    |   0
 test/{semantics => Semantics}/test_any.sh     |   0
 test/{semantics => Semantics}/test_errors.sh  |   0
 test/{semantics => Semantics}/test_modfile.sh |   0
 test/{semantics => Semantics}/test_symbols.sh |   0
 tools/f18/f18-parse-demo.cpp                  |  20 ++++----
 tools/f18/f18.cpp                             |  30 ++++++------
 tools/f18/stub-evaluate.cpp                   |   2 +-
 655 files changed, 905 insertions(+), 905 deletions(-)
 rename include/flang/{common => Common}/Fortran-features.h (94%)
 rename include/flang/{common => Common}/Fortran.h (97%)
 rename include/flang/{common => Common}/bit-population-count.h (98%)
 rename include/flang/{common => Common}/constexpr-bitset.h (98%)
 rename include/flang/{common => Common}/default-kinds.h (96%)
 rename include/flang/{common => Common}/enum-set.h (99%)
 rename include/flang/{common => Common}/format.h (99%)
 rename include/flang/{common => Common}/idioms.h (98%)
 rename include/flang/{common => Common}/indirection.h (98%)
 rename include/flang/{common => Common}/interval.h (98%)
 rename include/flang/{common => Common}/leading-zero-bit-count.h (98%)
 rename include/flang/{common => Common}/real.h (98%)
 rename include/flang/{common => Common}/reference-counted.h (96%)
 rename include/flang/{common => Common}/reference.h (96%)
 rename include/flang/{common => Common}/restorer.h (95%)
 rename include/flang/{common => Common}/template.h (99%)
 rename include/flang/{common => Common}/uint128.h (99%)
 rename include/flang/{common => Common}/unsigned-const-division.h (97%)
 rename include/flang/{common => Common}/unwrap.h (98%)
 rename include/flang/{decimal => Decimal}/binary-floating-point.h (96%)
 rename include/flang/{decimal => Decimal}/decimal.h (98%)
 rename include/flang/{evaluate => Evaluate}/call.h (97%)
 rename include/flang/{evaluate => Evaluate}/characteristics.h (97%)
 rename include/flang/{evaluate => Evaluate}/check-expression.h (97%)
 rename include/flang/{evaluate => Evaluate}/common.h (96%)
 rename include/flang/{evaluate => Evaluate}/complex.h (98%)
 rename include/flang/{evaluate => Evaluate}/constant.h (98%)
 rename include/flang/{evaluate => Evaluate}/expression.h (99%)
 rename include/flang/{evaluate => Evaluate}/fold.h (97%)
 rename include/flang/{evaluate => Evaluate}/formatting.h (90%)
 rename include/flang/{evaluate => Evaluate}/integer.h (99%)
 rename include/flang/{evaluate => Evaluate}/intrinsics-library.h (98%)
 rename include/flang/{evaluate => Evaluate}/intrinsics.h (93%)
 rename include/flang/{evaluate => Evaluate}/logical.h (97%)
 rename include/flang/{evaluate => Evaluate}/real.h (98%)
 rename include/flang/{evaluate => Evaluate}/rounding-bits.h (97%)
 rename include/flang/{evaluate => Evaluate}/shape.h (97%)
 rename include/flang/{evaluate => Evaluate}/static-data.h (95%)
 rename include/flang/{evaluate => Evaluate}/tools.h (98%)
 rename include/flang/{evaluate => Evaluate}/traverse.h (98%)
 rename include/flang/{evaluate => Evaluate}/type.h (99%)
 rename include/flang/{evaluate => Evaluate}/variable.h (98%)
 rename include/flang/{lower => Lower}/.clang-format (100%)
 rename include/flang/{lower => Lower}/PFTBuilder.h (99%)
 rename include/flang/{optimizer => Optimizer}/.clang-format (100%)
 rename include/flang/{parser => Parser}/char-block.h (98%)
 rename include/flang/{parser => Parser}/char-buffer.h (97%)
 rename include/flang/{parser => Parser}/char-set.h (97%)
 rename include/flang/{parser => Parser}/characters.h (99%)
 rename include/flang/{parser => Parser}/dump-parse-tree.h (99%)
 rename include/flang/{parser => Parser}/format-specification.h (98%)
 rename include/flang/{parser => Parser}/instrumented-parser.h (94%)
 rename include/flang/{parser => Parser}/message.h (98%)
 rename include/flang/{parser => Parser}/parse-state.h (96%)
 rename include/flang/{parser => Parser}/parse-tree-visitor.h (99%)
 rename include/flang/{parser => Parser}/parse-tree.h (99%)
 rename include/flang/{parser => Parser}/parsing.h (95%)
 rename include/flang/{parser => Parser}/provenance.h (98%)
 rename include/flang/{parser => Parser}/source.h (97%)
 rename include/flang/{parser => Parser}/tools.h (97%)
 rename include/flang/{parser => Parser}/unparse.h (95%)
 rename include/flang/{parser => Parser}/user-state.h (94%)
 rename include/flang/{semantics => Semantics}/attr.h (92%)
 rename include/flang/{semantics => Semantics}/expression.h (97%)
 rename include/flang/{semantics => Semantics}/scope.h (97%)
 rename include/flang/{semantics => Semantics}/semantics.h (97%)
 rename include/flang/{semantics => Semantics}/symbol.h (99%)
 rename include/flang/{semantics => Semantics}/tools.h (98%)
 rename include/flang/{semantics => Semantics}/type.h (98%)
 rename include/flang/{semantics => Semantics}/unparse-with-symbols.h (87%)
 rename lib/{common => Common}/CMakeLists.txt (88%)
 rename lib/{common => Common}/Fortran-features.cpp (90%)
 rename lib/{common => Common}/Fortran.cpp (93%)
 rename lib/{common => Common}/default-kinds.cpp (93%)
 rename lib/{common => Common}/idioms.cpp (92%)
 rename lib/{decimal => Decimal}/CMakeLists.txt (88%)
 rename lib/{decimal => Decimal}/big-radix-floating-point.h (96%)
 rename lib/{decimal => Decimal}/binary-to-decimal.cpp (99%)
 rename lib/{decimal => Decimal}/decimal-to-binary.cpp (98%)
 rename lib/{evaluate => Evaluate}/CMakeLists.txt (95%)
 rename lib/{evaluate => Evaluate}/call.cpp (95%)
 rename lib/{evaluate => Evaluate}/character.h (97%)
 rename lib/{evaluate => Evaluate}/characteristics.cpp (98%)
 rename lib/{evaluate => Evaluate}/check-expression.cpp (98%)
 rename lib/{evaluate => Evaluate}/common.cpp (92%)
 rename lib/{evaluate => Evaluate}/complex.cpp (97%)
 rename lib/{evaluate => Evaluate}/constant.cpp (97%)
 rename lib/{evaluate => Evaluate}/expression.cpp (96%)
 rename lib/{evaluate => Evaluate}/fold-character.cpp (98%)
 rename lib/{evaluate => Evaluate}/fold-complex.cpp (98%)
 rename lib/{evaluate => Evaluate}/fold-implementation.h (98%)
 rename lib/{evaluate => Evaluate}/fold-integer.cpp (99%)
 rename lib/{evaluate => Evaluate}/fold-logical.cpp (98%)
 rename lib/{evaluate => Evaluate}/fold-real.cpp (99%)
 rename lib/{evaluate => Evaluate}/fold.cpp (98%)
 rename lib/{evaluate => Evaluate}/formatting.cpp (98%)
 rename lib/{evaluate => Evaluate}/host.cpp (97%)
 rename lib/{evaluate => Evaluate}/host.h (98%)
 rename lib/{evaluate => Evaluate}/int-power.h (95%)
 rename lib/{evaluate => Evaluate}/integer.cpp (92%)
 rename lib/{evaluate => Evaluate}/intrinsics-library-templates.h (97%)
 rename lib/{evaluate => Evaluate}/intrinsics-library.cpp (99%)
 rename lib/{evaluate => Evaluate}/intrinsics.cpp (99%)
 rename lib/{evaluate => Evaluate}/logical.cpp (82%)
 rename lib/{evaluate => Evaluate}/real.cpp (98%)
 rename lib/{evaluate => Evaluate}/shape.cpp (98%)
 rename lib/{evaluate => Evaluate}/static-data.cpp (95%)
 rename lib/{evaluate => Evaluate}/tools.cpp (99%)
 rename lib/{evaluate => Evaluate}/type.cpp (97%)
 rename lib/{evaluate => Evaluate}/variable.cpp (98%)
 rename lib/{fir => Fir}/.clang-format (100%)
 rename lib/{lower => Lower}/.clang-format (100%)
 rename lib/{lower => Lower}/CMakeLists.txt (100%)
 rename lib/{lower => Lower}/PFTBuilder.cpp (99%)
 rename lib/{optimizer => Optimizer}/.clang-format (100%)
 rename lib/{parser => Parser}/CMakeLists.txt (93%)
 rename lib/{parser => Parser}/Fortran-parsers.cpp (99%)
 rename lib/{parser => Parser}/basic-parsers.h (98%)
 rename lib/{parser => Parser}/char-block.cpp (81%)
 rename lib/{parser => Parser}/char-buffer.cpp (94%)
 rename lib/{parser => Parser}/char-set.cpp (85%)
 rename lib/{parser => Parser}/characters.cpp (98%)
 rename lib/{parser => Parser}/debug-parser.cpp (88%)
 rename lib/{parser => Parser}/debug-parser.h (91%)
 rename lib/{parser => Parser}/executable-parsers.cpp (99%)
 rename lib/{parser => Parser}/expr-parsers.cpp (99%)
 rename lib/{parser => Parser}/expr-parsers.h (97%)
 rename lib/{parser => Parser}/instrumented-parser.cpp (92%)
 rename lib/{parser => Parser}/io-parsers.cpp (99%)
 rename lib/{parser => Parser}/message.cpp (98%)
 rename lib/{parser => Parser}/misc-parsers.h (92%)
 rename lib/{parser => Parser}/openmp-parsers.cpp (99%)
 rename lib/{parser => Parser}/parse-tree.cpp (97%)
 rename lib/{parser => Parser}/parsing.cpp (95%)
 rename lib/{parser => Parser}/preprocessor.cpp (99%)
 rename lib/{parser => Parser}/preprocessor.h (95%)
 rename lib/{parser => Parser}/prescan.cpp (99%)
 rename lib/{parser => Parser}/prescan.h (97%)
 rename lib/{parser => Parser}/program-parsers.cpp (99%)
 rename lib/{parser => Parser}/provenance.cpp (99%)
 rename lib/{parser => Parser}/source.cpp (97%)
 rename lib/{parser => Parser}/stmt-parser.h (98%)
 rename lib/{parser => Parser}/token-parsers.h (98%)
 rename lib/{parser => Parser}/token-sequence.cpp (98%)
 rename lib/{parser => Parser}/token-sequence.h (96%)
 rename lib/{parser => Parser}/tools.cpp (96%)
 rename lib/{parser => Parser}/type-parser-implementation.h (94%)
 rename lib/{parser => Parser}/type-parsers.h (97%)
 rename lib/{parser => Parser}/unparse.cpp (99%)
 rename lib/{parser => Parser}/user-state.cpp (94%)
 rename lib/{semantics => Semantics}/CMakeLists.txt (94%)
 rename lib/{semantics => Semantics}/assignment.cpp (95%)
 rename lib/{semantics => Semantics}/assignment.h (90%)
 rename lib/{semantics => Semantics}/attr.cpp (90%)
 rename lib/{semantics => Semantics}/canonicalize-do.cpp (98%)
 rename lib/{semantics => Semantics}/canonicalize-do.h (91%)
 rename lib/{semantics => Semantics}/canonicalize-omp.cpp (97%)
 rename lib/{semantics => Semantics}/canonicalize-omp.h (90%)
 rename lib/{semantics => Semantics}/check-allocate.cpp (98%)
 rename lib/{semantics => Semantics}/check-allocate.h (87%)
 rename lib/{semantics => Semantics}/check-arithmeticif.cpp (90%)
 rename lib/{semantics => Semantics}/check-arithmeticif.h (88%)
 rename lib/{semantics => Semantics}/check-call.cpp (98%)
 rename lib/{semantics => Semantics}/check-call.h (94%)
 rename lib/{semantics => Semantics}/check-coarray.cpp (93%)
 rename lib/{semantics => Semantics}/check-coarray.h (92%)
 rename lib/{semantics => Semantics}/check-data.cpp (96%)
 rename lib/{semantics => Semantics}/check-data.h (77%)
 rename lib/{semantics => Semantics}/check-deallocate.cpp (92%)
 rename lib/{semantics => Semantics}/check-deallocate.h (88%)
 rename lib/{semantics => Semantics}/check-declarations.cpp (99%)
 rename lib/{semantics => Semantics}/check-declarations.h (89%)
 rename lib/{semantics => Semantics}/check-do-forall.cpp (98%)
 rename lib/{semantics => Semantics}/check-do-forall.h (94%)
 rename lib/{semantics => Semantics}/check-if-stmt.cpp (82%)
 rename lib/{semantics => Semantics}/check-if-stmt.h (87%)
 rename lib/{semantics => Semantics}/check-io.cpp (99%)
 rename lib/{semantics => Semantics}/check-io.h (96%)
 rename lib/{semantics => Semantics}/check-nullify.cpp (91%)
 rename lib/{semantics => Semantics}/check-nullify.h (87%)
 rename lib/{semantics => Semantics}/check-omp-structure.cpp (99%)
 rename lib/{semantics => Semantics}/check-omp-structure.h (98%)
 rename lib/{semantics => Semantics}/check-purity.cpp (94%)
 rename lib/{semantics => Semantics}/check-purity.h (92%)
 rename lib/{semantics => Semantics}/check-return.cpp (86%)
 rename lib/{semantics => Semantics}/check-return.h (87%)
 rename lib/{semantics => Semantics}/check-stop.cpp (84%)
 rename lib/{semantics => Semantics}/check-stop.h (88%)
 rename lib/{semantics => Semantics}/expression.cpp (99%)
 rename lib/{semantics => Semantics}/mod-file.cpp (99%)
 rename lib/{semantics => Semantics}/mod-file.h (95%)
 rename lib/{semantics => Semantics}/pointer-assignment.cpp (97%)
 rename lib/{semantics => Semantics}/pointer-assignment.h (85%)
 rename lib/{semantics => Semantics}/program-tree.cpp (97%)
 rename lib/{semantics => Semantics}/program-tree.h (96%)
 rename lib/{semantics => Semantics}/resolve-labels.cpp (99%)
 rename lib/{semantics => Semantics}/resolve-labels.h (92%)
 rename lib/{semantics => Semantics}/resolve-names-utils.cpp (98%)
 rename lib/{semantics => Semantics}/resolve-names-utils.h (95%)
 rename lib/{semantics => Semantics}/resolve-names.cpp (99%)
 rename lib/{semantics => Semantics}/resolve-names.h (91%)
 rename lib/{semantics => Semantics}/rewrite-parse-tree.cpp (93%)
 rename lib/{semantics => Semantics}/rewrite-parse-tree.h (91%)
 rename lib/{semantics => Semantics}/scope.cpp (97%)
 rename lib/{semantics => Semantics}/semantics.cpp (97%)
 rename lib/{semantics => Semantics}/symbol.cpp (98%)
 rename lib/{semantics => Semantics}/tools.cpp (98%)
 rename lib/{semantics => Semantics}/type.cpp (98%)
 rename lib/{semantics => Semantics}/unparse-with-symbols.cpp (92%)
 rename test-lit/{driver => Driver}/version_test.f90 (100%)
 rename test-lit/{lower => Lower}/pre-fir-tree01.f90 (100%)
 rename test-lit/{lower => Lower}/pre-fir-tree02.f90 (100%)
 rename test-lit/{lower => Lower}/pre-fir-tree03.f90 (100%)
 rename test-lit/{lower => Lower}/pre-fir-tree04.f90 (100%)
 rename test/{decimal => Decimal}/CMakeLists.txt (89%)
 rename test/{decimal => Decimal}/quick-sanity-test.cpp (99%)
 rename test/{decimal => Decimal}/thorough-test.cpp (98%)
 rename test/{evaluate => Evaluate}/CMakeLists.txt (96%)
 rename test/{evaluate => Evaluate}/ISO-Fortran-binding.cpp (100%)
 rename test/{evaluate => Evaluate}/bit-population-count.cpp (98%)
 rename test/{evaluate => Evaluate}/expression.cpp (85%)
 rename test/{evaluate => Evaluate}/folding.cpp (93%)
 rename test/{evaluate => Evaluate}/folding01.f90 (100%)
 rename test/{evaluate => Evaluate}/folding02.f90 (100%)
 rename test/{evaluate => Evaluate}/folding03.f90 (100%)
 rename test/{evaluate => Evaluate}/folding04.f90 (100%)
 rename test/{evaluate => Evaluate}/folding05.f90 (100%)
 rename test/{evaluate => Evaluate}/folding06.f90 (100%)
 rename test/{evaluate => Evaluate}/folding07.f90 (100%)
 rename test/{evaluate => Evaluate}/folding08.f90 (100%)
 rename test/{evaluate => Evaluate}/folding09.f90 (100%)
 rename test/{evaluate => Evaluate}/fp-testing.cpp (100%)
 rename test/{evaluate => Evaluate}/fp-testing.h (94%)
 rename test/{evaluate => Evaluate}/integer.cpp (99%)
 rename test/{evaluate => Evaluate}/intrinsics.cpp (97%)
 rename test/{evaluate => Evaluate}/leading-zero-bit-count.cpp (95%)
 rename test/{evaluate => Evaluate}/logical.cpp (97%)
 rename test/{evaluate => Evaluate}/real.cpp (99%)
 rename test/{evaluate => Evaluate}/reshape.cpp (100%)
 rename test/{evaluate => Evaluate}/test_folding.sh (100%)
 rename test/{evaluate => Evaluate}/testing.cpp (100%)
 rename test/{evaluate => Evaluate}/testing.h (100%)
 rename test/{evaluate => Evaluate}/uint128.cpp (99%)
 rename test/{preprocessing => Preprocessing}/pp001.F (100%)
 rename test/{preprocessing => Preprocessing}/pp002.F (100%)
 rename test/{preprocessing => Preprocessing}/pp003.F (100%)
 rename test/{preprocessing => Preprocessing}/pp004.F (100%)
 rename test/{preprocessing => Preprocessing}/pp005.F (100%)
 rename test/{preprocessing => Preprocessing}/pp006.F (100%)
 rename test/{preprocessing => Preprocessing}/pp007.F (100%)
 rename test/{preprocessing => Preprocessing}/pp008.F (100%)
 rename test/{preprocessing => Preprocessing}/pp009.F (100%)
 rename test/{preprocessing => Preprocessing}/pp010.F (100%)
 rename test/{preprocessing => Preprocessing}/pp011.F (100%)
 rename test/{preprocessing => Preprocessing}/pp012.F (100%)
 rename test/{preprocessing => Preprocessing}/pp013.F (100%)
 rename test/{preprocessing => Preprocessing}/pp014.F (100%)
 rename test/{preprocessing => Preprocessing}/pp015.F (100%)
 rename test/{preprocessing => Preprocessing}/pp016.F (100%)
 rename test/{preprocessing => Preprocessing}/pp017.F (100%)
 rename test/{preprocessing => Preprocessing}/pp018.F (100%)
 rename test/{preprocessing => Preprocessing}/pp019.F (100%)
 rename test/{preprocessing => Preprocessing}/pp020.F (100%)
 rename test/{preprocessing => Preprocessing}/pp021.F (100%)
 rename test/{preprocessing => Preprocessing}/pp022.F (100%)
 rename test/{preprocessing => Preprocessing}/pp023.F (100%)
 rename test/{preprocessing => Preprocessing}/pp024.F (100%)
 rename test/{preprocessing => Preprocessing}/pp025.F (100%)
 rename test/{preprocessing => Preprocessing}/pp026.F (100%)
 rename test/{preprocessing => Preprocessing}/pp027.F (100%)
 rename test/{preprocessing => Preprocessing}/pp028.F (100%)
 rename test/{preprocessing => Preprocessing}/pp029.F (100%)
 rename test/{preprocessing => Preprocessing}/pp030.F (100%)
 rename test/{preprocessing => Preprocessing}/pp031.F (100%)
 rename test/{preprocessing => Preprocessing}/pp032.F (100%)
 rename test/{preprocessing => Preprocessing}/pp033.F (100%)
 rename test/{preprocessing => Preprocessing}/pp034.F (100%)
 rename test/{preprocessing => Preprocessing}/pp035.F (100%)
 rename test/{preprocessing => Preprocessing}/pp036.F (100%)
 rename test/{preprocessing => Preprocessing}/pp037.F (100%)
 rename test/{preprocessing => Preprocessing}/pp038.F (100%)
 rename test/{preprocessing => Preprocessing}/pp039.F (100%)
 rename test/{preprocessing => Preprocessing}/pp040.F (100%)
 rename test/{preprocessing => Preprocessing}/pp041.F (100%)
 rename test/{preprocessing => Preprocessing}/pp042.F (100%)
 rename test/{preprocessing => Preprocessing}/pp043.F (100%)
 rename test/{preprocessing => Preprocessing}/pp044.F (100%)
 rename test/{preprocessing => Preprocessing}/pp101.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp102.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp103.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp104.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp105.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp106.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp107.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp108.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp109.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp110.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp111.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp112.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp113.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp114.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp115.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp116.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp117.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp118.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp119.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp120.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp121.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp122.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp123.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp124.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp125.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp126.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp127.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp128.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp129.F90 (100%)
 rename test/{preprocessing => Preprocessing}/pp130.F90 (100%)
 rename test/{runtime => Runtime}/CMakeLists.txt (92%)
 rename test/{runtime => Runtime}/external-hello.cpp (100%)
 rename test/{runtime => Runtime}/format.cpp (100%)
 rename test/{runtime => Runtime}/hello.cpp (100%)
 rename test/{semantics => Semantics}/CMakeLists.txt (98%)
 rename test/{semantics => Semantics}/allocate01.f90 (100%)
 rename test/{semantics => Semantics}/allocate02.f90 (100%)
 rename test/{semantics => Semantics}/allocate03.f90 (100%)
 rename test/{semantics => Semantics}/allocate04.f90 (100%)
 rename test/{semantics => Semantics}/allocate05.f90 (100%)
 rename test/{semantics => Semantics}/allocate06.f90 (100%)
 rename test/{semantics => Semantics}/allocate07.f90 (100%)
 rename test/{semantics => Semantics}/allocate08.f90 (100%)
 rename test/{semantics => Semantics}/allocate09.f90 (100%)
 rename test/{semantics => Semantics}/allocate10.f90 (100%)
 rename test/{semantics => Semantics}/allocate11.f90 (100%)
 rename test/{semantics => Semantics}/allocate12.f90 (100%)
 rename test/{semantics => Semantics}/allocate13.f90 (100%)
 rename test/{semantics => Semantics}/altreturn01.f90 (100%)
 rename test/{semantics => Semantics}/altreturn02.f90 (100%)
 rename test/{semantics => Semantics}/altreturn03.f90 (100%)
 rename test/{semantics => Semantics}/altreturn04.f90 (100%)
 rename test/{semantics => Semantics}/altreturn05.f90 (100%)
 rename test/{semantics => Semantics}/assign01.f90 (100%)
 rename test/{semantics => Semantics}/assign02.f90 (100%)
 rename test/{semantics => Semantics}/assign03.f90 (100%)
 rename test/{semantics => Semantics}/bad-forward-type.f90 (100%)
 rename test/{semantics => Semantics}/bindings01.f90 (100%)
 rename test/{semantics => Semantics}/block-data01.f90 (100%)
 rename test/{semantics => Semantics}/blockconstruct01.f90 (100%)
 rename test/{semantics => Semantics}/blockconstruct02.f90 (100%)
 rename test/{semantics => Semantics}/blockconstruct03.f90 (100%)
 rename test/{semantics => Semantics}/c_f_pointer.f90 (100%)
 rename test/{semantics => Semantics}/call01.f90 (100%)
 rename test/{semantics => Semantics}/call02.f90 (100%)
 rename test/{semantics => Semantics}/call03.f90 (100%)
 rename test/{semantics => Semantics}/call04.f90 (100%)
 rename test/{semantics => Semantics}/call05.f90 (100%)
 rename test/{semantics => Semantics}/call06.f90 (100%)
 rename test/{semantics => Semantics}/call07.f90 (100%)
 rename test/{semantics => Semantics}/call08.f90 (100%)
 rename test/{semantics => Semantics}/call09.f90 (100%)
 rename test/{semantics => Semantics}/call10.f90 (100%)
 rename test/{semantics => Semantics}/call11.f90 (100%)
 rename test/{semantics => Semantics}/call12.f90 (100%)
 rename test/{semantics => Semantics}/call13.f90 (100%)
 rename test/{semantics => Semantics}/call14.f90 (100%)
 rename test/{semantics => Semantics}/call15.f90 (100%)
 rename test/{semantics => Semantics}/canondo01.f90 (100%)
 rename test/{semantics => Semantics}/canondo02.f90 (100%)
 rename test/{semantics => Semantics}/canondo03.f90 (100%)
 rename test/{semantics => Semantics}/canondo04.f90 (100%)
 rename test/{semantics => Semantics}/canondo05.f90 (100%)
 rename test/{semantics => Semantics}/canondo06.f90 (100%)
 rename test/{semantics => Semantics}/canondo07.f90 (100%)
 rename test/{semantics => Semantics}/canondo08.f90 (100%)
 rename test/{semantics => Semantics}/canondo09.f90 (100%)
 rename test/{semantics => Semantics}/canondo10.f90 (100%)
 rename test/{semantics => Semantics}/canondo11.f90 (100%)
 rename test/{semantics => Semantics}/canondo12.f90 (100%)
 rename test/{semantics => Semantics}/canondo13.f90 (100%)
 rename test/{semantics => Semantics}/canondo14.f90 (100%)
 rename test/{semantics => Semantics}/canondo15.f90 (100%)
 rename test/{semantics => Semantics}/canondo16.f90 (100%)
 rename test/{semantics => Semantics}/canondo17.f90 (100%)
 rename test/{semantics => Semantics}/canondo18.f90 (100%)
 rename test/{semantics => Semantics}/canondo19.f90 (100%)
 rename test/{semantics => Semantics}/coarrays01.f90 (100%)
 rename test/{semantics => Semantics}/common.sh (100%)
 rename test/{semantics => Semantics}/computed-goto01.f90 (100%)
 rename test/{semantics => Semantics}/computed-goto02.f90 (100%)
 rename test/{semantics => Semantics}/critical01.f90 (100%)
 rename test/{semantics => Semantics}/critical02.f90 (100%)
 rename test/{semantics => Semantics}/critical03.f90 (100%)
 rename test/{semantics => Semantics}/critical04.f90 (100%)
 rename test/{semantics => Semantics}/data01.f90 (100%)
 rename test/{semantics => Semantics}/deallocate01.f90 (100%)
 rename test/{semantics => Semantics}/deallocate04.f90 (100%)
 rename test/{semantics => Semantics}/deallocate05.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent01.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent02.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent03.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent04.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent05.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent06.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent07.f90 (100%)
 rename test/{semantics => Semantics}/doconcurrent08.f90 (99%)
 rename test/{semantics => Semantics}/dosemantics01.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics02.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics03.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics04.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics05.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics06.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics07.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics08.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics09.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics10.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics11.f90 (100%)
 rename test/{semantics => Semantics}/dosemantics12.f90 (100%)
 rename test/{semantics => Semantics}/equivalence01.f90 (100%)
 rename test/{semantics => Semantics}/expr-errors01.f90 (100%)
 rename test/{semantics => Semantics}/expr-errors02.f90 (100%)
 rename test/{semantics => Semantics}/forall01.f90 (100%)
 rename test/{semantics => Semantics}/getdefinition01.f90 (100%)
 rename test/{semantics => Semantics}/getdefinition02.f (100%)
 rename test/{semantics => Semantics}/getdefinition03-a.f90 (100%)
 rename test/{semantics => Semantics}/getdefinition03-b.f90 (100%)
 rename test/{semantics => Semantics}/getdefinition04.f90 (100%)
 rename test/{semantics => Semantics}/getdefinition05.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols01.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols02-a.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols02-b.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols02-c.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols03-a.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols03-b.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols04.f90 (100%)
 rename test/{semantics => Semantics}/getsymbols05.f90 (100%)
 rename test/{semantics => Semantics}/if_arith01.f90 (100%)
 rename test/{semantics => Semantics}/if_arith02.f90 (100%)
 rename test/{semantics => Semantics}/if_arith03.f90 (100%)
 rename test/{semantics => Semantics}/if_arith04.f90 (100%)
 rename test/{semantics => Semantics}/if_construct01.f90 (100%)
 rename test/{semantics => Semantics}/if_construct02.f90 (100%)
 rename test/{semantics => Semantics}/if_stmt01.f90 (100%)
 rename test/{semantics => Semantics}/if_stmt02.f90 (100%)
 rename test/{semantics => Semantics}/if_stmt03.f90 (100%)
 rename test/{semantics => Semantics}/implicit01.f90 (100%)
 rename test/{semantics => Semantics}/implicit02.f90 (100%)
 rename test/{semantics => Semantics}/implicit03.f90 (100%)
 rename test/{semantics => Semantics}/implicit04.f90 (100%)
 rename test/{semantics => Semantics}/implicit05.f90 (100%)
 rename test/{semantics => Semantics}/implicit06.f90 (100%)
 rename test/{semantics => Semantics}/implicit07.f90 (100%)
 rename test/{semantics => Semantics}/implicit08.f90 (100%)
 rename test/{semantics => Semantics}/init01.f90 (100%)
 rename test/{semantics => Semantics}/int-literals.f90 (100%)
 rename test/{semantics => Semantics}/io01.f90 (100%)
 rename test/{semantics => Semantics}/io02.f90 (100%)
 rename test/{semantics => Semantics}/io03.f90 (100%)
 rename test/{semantics => Semantics}/io04.f90 (100%)
 rename test/{semantics => Semantics}/io05.f90 (100%)
 rename test/{semantics => Semantics}/io06.f90 (100%)
 rename test/{semantics => Semantics}/io07.f90 (100%)
 rename test/{semantics => Semantics}/io08.f90 (100%)
 rename test/{semantics => Semantics}/io09.f90 (100%)
 rename test/{semantics => Semantics}/io10.f90 (100%)
 rename test/{semantics => Semantics}/kinds01.f90 (100%)
 rename test/{semantics => Semantics}/kinds02.f90 (100%)
 rename test/{semantics => Semantics}/kinds03.f90 (100%)
 rename test/{semantics => Semantics}/label01.F90 (100%)
 rename test/{semantics => Semantics}/label02.f90 (100%)
 rename test/{semantics => Semantics}/label03.f90 (100%)
 rename test/{semantics => Semantics}/label04.f90 (100%)
 rename test/{semantics => Semantics}/label05.f90 (100%)
 rename test/{semantics => Semantics}/label06.f90 (100%)
 rename test/{semantics => Semantics}/label07.f90 (100%)
 rename test/{semantics => Semantics}/label08.f90 (100%)
 rename test/{semantics => Semantics}/label09.f90 (100%)
 rename test/{semantics => Semantics}/label10.f90 (100%)
 rename test/{semantics => Semantics}/label11.f90 (100%)
 rename test/{semantics => Semantics}/label12.f90 (100%)
 rename test/{semantics => Semantics}/label13.f90 (100%)
 rename test/{semantics => Semantics}/label14.f90 (100%)
 rename test/{semantics => Semantics}/misc-declarations.f90 (100%)
 rename test/{semantics => Semantics}/modfile01.f90 (100%)
 rename test/{semantics => Semantics}/modfile02.f90 (100%)
 rename test/{semantics => Semantics}/modfile03.f90 (100%)
 rename test/{semantics => Semantics}/modfile04.f90 (100%)
 rename test/{semantics => Semantics}/modfile05.f90 (100%)
 rename test/{semantics => Semantics}/modfile06.f90 (100%)
 rename test/{semantics => Semantics}/modfile07.f90 (100%)
 rename test/{semantics => Semantics}/modfile08.f90 (100%)
 rename test/{semantics => Semantics}/modfile09-a.f90 (100%)
 rename test/{semantics => Semantics}/modfile09-b.f90 (100%)
 rename test/{semantics => Semantics}/modfile09-c.f90 (100%)
 rename test/{semantics => Semantics}/modfile09-d.f90 (100%)
 rename test/{semantics => Semantics}/modfile10.f90 (100%)
 rename test/{semantics => Semantics}/modfile11.f90 (100%)
 rename test/{semantics => Semantics}/modfile12.f90 (100%)
 rename test/{semantics => Semantics}/modfile13.f90 (100%)
 rename test/{semantics => Semantics}/modfile14.f90 (100%)
 rename test/{semantics => Semantics}/modfile15.f90 (100%)
 rename test/{semantics => Semantics}/modfile16.f90 (100%)
 rename test/{semantics => Semantics}/modfile17.f90 (100%)
 rename test/{semantics => Semantics}/modfile18.f90 (100%)
 rename test/{semantics => Semantics}/modfile19.f90 (100%)
 rename test/{semantics => Semantics}/modfile20.f90 (100%)
 rename test/{semantics => Semantics}/modfile21.f90 (100%)
 rename test/{semantics => Semantics}/modfile22.f90 (100%)
 rename test/{semantics => Semantics}/modfile23.f90 (100%)
 rename test/{semantics => Semantics}/modfile24.f90 (100%)
 rename test/{semantics => Semantics}/modfile25.f90 (100%)
 rename test/{semantics => Semantics}/modfile26.f90 (100%)
 rename test/{semantics => Semantics}/modfile27.f90 (100%)
 rename test/{semantics => Semantics}/modfile28.f90 (100%)
 rename test/{semantics => Semantics}/modfile29.f90 (100%)
 rename test/{semantics => Semantics}/modfile30.f90 (100%)
 rename test/{semantics => Semantics}/modfile31.f90 (100%)
 rename test/{semantics => Semantics}/modfile32.f90 (100%)
 rename test/{semantics => Semantics}/modfile33.f90 (100%)
 rename test/{semantics => Semantics}/modfile34.f90 (100%)
 rename test/{semantics => Semantics}/modfile35.f90 (100%)
 rename test/{semantics => Semantics}/null01.f90 (100%)
 rename test/{semantics => Semantics}/nullify01.f90 (100%)
 rename test/{semantics => Semantics}/nullify02.f90 (100%)
 rename test/{semantics => Semantics}/omp-atomic.f90 (100%)
 rename test/{semantics => Semantics}/omp-clause-validity01.f90 (100%)
 rename test/{semantics => Semantics}/omp-declarative-directive.f90 (100%)
 rename test/{semantics => Semantics}/omp-device-constructs.f90 (100%)
 rename test/{semantics => Semantics}/omp-loop-association.f90 (100%)
 rename test/{semantics => Semantics}/omp-nested01.f90 (100%)
 rename test/{semantics => Semantics}/omp-resolve01.f90 (100%)
 rename test/{semantics => Semantics}/omp-resolve02.f90 (100%)
 rename test/{semantics => Semantics}/omp-resolve03.f90 (100%)
 rename test/{semantics => Semantics}/omp-resolve04.f90 (100%)
 rename test/{semantics => Semantics}/omp-resolve05.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol01.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol02.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol03.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol04.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol05.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol06.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol07.f90 (100%)
 rename test/{semantics => Semantics}/omp-symbol08.f90 (100%)
 rename test/{semantics => Semantics}/procinterface01.f90 (100%)
 rename test/{semantics => Semantics}/resolve01.f90 (100%)
 rename test/{semantics => Semantics}/resolve02.f90 (100%)
 rename test/{semantics => Semantics}/resolve03.f90 (100%)
 rename test/{semantics => Semantics}/resolve04.f90 (100%)
 rename test/{semantics => Semantics}/resolve05.f90 (100%)
 rename test/{semantics => Semantics}/resolve06.f90 (100%)
 rename test/{semantics => Semantics}/resolve07.f90 (100%)
 rename test/{semantics => Semantics}/resolve08.f90 (100%)
 rename test/{semantics => Semantics}/resolve09.f90 (100%)
 rename test/{semantics => Semantics}/resolve10.f90 (100%)
 rename test/{semantics => Semantics}/resolve11.f90 (100%)
 rename test/{semantics => Semantics}/resolve12.f90 (100%)
 rename test/{semantics => Semantics}/resolve13.f90 (100%)
 rename test/{semantics => Semantics}/resolve14.f90 (100%)
 rename test/{semantics => Semantics}/resolve15.f90 (100%)
 rename test/{semantics => Semantics}/resolve16.f90 (100%)
 rename test/{semantics => Semantics}/resolve17.f90 (100%)
 rename test/{semantics => Semantics}/resolve18.f90 (100%)
 rename test/{semantics => Semantics}/resolve19.f90 (100%)
 rename test/{semantics => Semantics}/resolve20.f90 (100%)
 rename test/{semantics => Semantics}/resolve21.f90 (100%)
 rename test/{semantics => Semantics}/resolve22.f90 (100%)
 rename test/{semantics => Semantics}/resolve23.f90 (100%)
 rename test/{semantics => Semantics}/resolve24.f90 (100%)
 rename test/{semantics => Semantics}/resolve25.f90 (100%)
 rename test/{semantics => Semantics}/resolve26.f90 (100%)
 rename test/{semantics => Semantics}/resolve27.f90 (100%)
 rename test/{semantics => Semantics}/resolve28.f90 (100%)
 rename test/{semantics => Semantics}/resolve29.f90 (100%)
 rename test/{semantics => Semantics}/resolve30.f90 (100%)
 rename test/{semantics => Semantics}/resolve31.f90 (100%)
 rename test/{semantics => Semantics}/resolve32.f90 (100%)
 rename test/{semantics => Semantics}/resolve33.f90 (100%)
 rename test/{semantics => Semantics}/resolve34.f90 (100%)
 rename test/{semantics => Semantics}/resolve35.f90 (100%)
 rename test/{semantics => Semantics}/resolve36.f90 (100%)
 rename test/{semantics => Semantics}/resolve37.f90 (100%)
 rename test/{semantics => Semantics}/resolve38.f90 (100%)
 rename test/{semantics => Semantics}/resolve39.f90 (100%)
 rename test/{semantics => Semantics}/resolve40.f90 (100%)
 rename test/{semantics => Semantics}/resolve41.f90 (100%)
 rename test/{semantics => Semantics}/resolve42.f90 (100%)
 rename test/{semantics => Semantics}/resolve43.f90 (100%)
 rename test/{semantics => Semantics}/resolve44.f90 (100%)
 rename test/{semantics => Semantics}/resolve45.f90 (100%)
 rename test/{semantics => Semantics}/resolve46.f90 (100%)
 rename test/{semantics => Semantics}/resolve47.f90 (100%)
 rename test/{semantics => Semantics}/resolve48.f90 (100%)
 rename test/{semantics => Semantics}/resolve49.f90 (100%)
 rename test/{semantics => Semantics}/resolve50.f90 (100%)
 rename test/{semantics => Semantics}/resolve51.f90 (100%)
 rename test/{semantics => Semantics}/resolve52.f90 (100%)
 rename test/{semantics => Semantics}/resolve53.f90 (100%)
 rename test/{semantics => Semantics}/resolve54.f90 (100%)
 rename test/{semantics => Semantics}/resolve55.f90 (100%)
 rename test/{semantics => Semantics}/resolve56.f90 (100%)
 rename test/{semantics => Semantics}/resolve57.f90 (100%)
 rename test/{semantics => Semantics}/resolve58.f90 (100%)
 rename test/{semantics => Semantics}/resolve59.f90 (100%)
 rename test/{semantics => Semantics}/resolve60.f90 (100%)
 rename test/{semantics => Semantics}/resolve61.f90 (100%)
 rename test/{semantics => Semantics}/resolve62.f90 (100%)
 rename test/{semantics => Semantics}/resolve63.f90 (100%)
 rename test/{semantics => Semantics}/resolve64.f90 (100%)
 rename test/{semantics => Semantics}/resolve65.f90 (100%)
 rename test/{semantics => Semantics}/resolve66.f90 (100%)
 rename test/{semantics => Semantics}/resolve67.f90 (100%)
 rename test/{semantics => Semantics}/resolve68.f90 (100%)
 rename test/{semantics => Semantics}/resolve69.f90 (100%)
 rename test/{semantics => Semantics}/resolve70.f90 (100%)
 rename test/{semantics => Semantics}/resolve71.f90 (100%)
 rename test/{semantics => Semantics}/resolve72.f90 (100%)
 rename test/{semantics => Semantics}/separate-module-procs.f90 (100%)
 rename test/{semantics => Semantics}/stop01.f90 (100%)
 rename test/{semantics => Semantics}/structconst01.f90 (100%)
 rename test/{semantics => Semantics}/structconst02.f90 (100%)
 rename test/{semantics => Semantics}/structconst03.f90 (98%)
 rename test/{semantics => Semantics}/structconst04.f90 (100%)
 rename test/{semantics => Semantics}/symbol01.f90 (100%)
 rename test/{semantics => Semantics}/symbol02.f90 (100%)
 rename test/{semantics => Semantics}/symbol03.f90 (100%)
 rename test/{semantics => Semantics}/symbol05.f90 (100%)
 rename test/{semantics => Semantics}/symbol06.f90 (100%)
 rename test/{semantics => Semantics}/symbol07.f90 (100%)
 rename test/{semantics => Semantics}/symbol08.f90 (100%)
 rename test/{semantics => Semantics}/symbol09.f90 (100%)
 rename test/{semantics => Semantics}/symbol10.f90 (100%)
 rename test/{semantics => Semantics}/symbol11.f90 (100%)
 rename test/{semantics => Semantics}/symbol12.f90 (100%)
 rename test/{semantics => Semantics}/symbol13.f90 (100%)
 rename test/{semantics => Semantics}/symbol14.f90 (100%)
 rename test/{semantics => Semantics}/symbol15.f90 (100%)
 rename test/{semantics => Semantics}/symbol16.f90 (100%)
 rename test/{semantics => Semantics}/symbol17.f90 (100%)
 rename test/{semantics => Semantics}/test_any.sh (100%)
 rename test/{semantics => Semantics}/test_errors.sh (100%)
 rename test/{semantics => Semantics}/test_modfile.sh (100%)
 rename test/{semantics => Semantics}/test_symbols.sh (100%)

diff --git a/documentation/C++style.md b/documentation/C++style.md
index 9136a3f21e6a..f8e58968f330 100644
--- a/documentation/C++style.md
+++ b/documentation/C++style.md
@@ -219,7 +219,7 @@ or assignments should exist for a class, explicitly `=delete` all of them.
 There are many -- perhaps too many -- means of indirect addressing
 data in this project.
 Some of these are standard C++ language and library features,
-while others are local inventions in `lib/common`:
+while others are local inventions in `lib/Common`:
 * Bare pointers (`Foo *p`): these are obviously nullable, non-owning,
 undefined when uninitialized, shallowly copyable, reassignable, and often
 not the right abstraction to use in this project.
diff --git a/documentation/ImplementingASemanticCheck.md b/documentation/ImplementingASemanticCheck.md
index 736202abaa1f..fc2e4f14061e 100644
--- a/documentation/ImplementingASemanticCheck.md
+++ b/documentation/ImplementingASemanticCheck.md
@@ -111,9 +111,9 @@ checking had already taken place.
 Most semantic checks for statements are implemented by walking the parse tree
 and performing analysis on the nodes they visit.  My plan was to use this
 method.  The infrastructure for walking the parse tree for statement semantic
-checking is implemented in the files `lib/semantics/semantics.cpp`.
+checking is implemented in the files `lib/Semantics/semantics.cpp`.
 Here's a fragment of the declaration of the framework's parse tree visitor from
-`lib/semantics/semantics.cpp`:
+`lib/Semantics/semantics.cpp`:
 
 ```C++
   // A parse tree visitor that calls Enter/Leave functions from each checker
@@ -136,7 +136,7 @@ Here's a fragment of the declaration of the framework's parse tree visitor from
 Since FUNCTION calls are a kind of expression, I was planning to base my
 implementation on the contents of `parser::Expr` nodes.  I would need to define
 either an `Enter()` or `Leave()` function whose parameter was a `parser::Expr`
-node.  Here's the declaration I put into `lib/semantics/check-do.h`:
+node.  Here's the declaration I put into `lib/Semantics/check-do.h`:
 
 ```C++
   void Leave(const parser::Expr &);
@@ -148,12 +148,12 @@ arbitrarily chose to implement the `Leave()` function to visit the parse tree
 node.
 
 Since my semantic check was focused on DO CONCURRENT statements, I added it to
-the file `lib/semantics/check-do.cpp` where most of the semantic checking for
+the file `lib/Semantics/check-do.cpp` where most of the semantic checking for
 DO statements already lived.
 
 ## Taking advantage of prior work
 When implementing a similar check for SUBROUTINE calls, I created a utility
-functions in `lib/semantics/semantics.cpp` to emit messages if
+functions in `lib/Semantics/semantics.cpp` to emit messages if
 a symbol corresponding to an active DO variable was being potentially modified:
 
 ```C++
@@ -176,7 +176,7 @@ functions.  The second is needed to determine whether to call them.
 ## Finding the source location
 The source code location information that I'd need for the error message must
 come from the parse tree.  I looked in the file
-`include/flang/parser/parse-tree.h` and determined that a `struct Expr`
+`include/flang/Parser/parse-tree.h` and determined that a `struct Expr`
 contained source location information since it had the field `CharBlock
 source`.  Thus, if I visited a `parser::Expr` node, I could get the source
 location information for the associated expression.
@@ -184,7 +184,7 @@ location information for the associated expression.
 ## Determining the `INTENT`
 I knew that I could find the `INTENT` of the dummy argument associated with the
 actual argument from the function called `dummyIntent()` in the class
-`evaluate::ActualArgument` in the file `include/flang/evaluate/call.h`.  So
+`evaluate::ActualArgument` in the file `include/flang/Evaluate/call.h`.  So
 if I could find an `evaluate::ActualArgument` in an expression, I could
   determine the `INTENT` of the associated dummy argument.  I knew that it was
   valid to call `dummyIntent()` because the data on which `dummyIntent()`
@@ -216,12 +216,12 @@ find all of the `evaluate::ActualArgument` nodes.
 
 Note that the compiler has multiple types called `Expr`.  One is in the
 `parser` namespace.  `parser::Expr` is defined in the file
-`include/flang/parser/parse-tree.h`.  It represents a parsed expression that
+`include/flang/Parser/parse-tree.h`.  It represents a parsed expression that
 maps directly to the source code and has fields that specify any operators in
 the expression, the operands, and the source position of the expression.
 
 Additionally, in the namespace `evaluate`, there are `evaluate::Expr<T>`
-template classes defined in the file `include/flang/evaluate/expression.h`.
+template classes defined in the file `include/flang/Evaluate/expression.h`.
 These are parameterized over the various types of Fortran and constitute a
 suite of strongly-typed representations of valid Fortran expressions of type
 `T` that have been fully elaborated with conversion operations and subjected to
@@ -231,7 +231,7 @@ owns an instance of `evaluate::Expr<SomeType>`, the most general representation
 of an analyzed expression.
 
 All of the declarations associated with both FUNCTION and SUBROUTINE calls are
-in `include/flang/evaluate/call.h`.  An `evaluate::FunctionRef` inherits from
+in `include/flang/Evaluate/call.h`.  An `evaluate::FunctionRef` inherits from
 an `evaluate::ProcedureRef` which contains the list of
 `evaluate::ActualArgument` nodes.  But the relationship between an
 `evaluate::FunctionRef` node and its associated arguments is not relevant.  I
@@ -269,16 +269,16 @@ argument was an active DO variable.
 ## Adding a parse tree visitor
 I started my implementation by adding a visitor for `parser::Expr` nodes.
 Since this analysis is part of DO construct checking, I did this in
-`lib/semantics/check-do.cpp`.  I added a print statement to the visitor to
+`lib/Semantics/check-do.cpp`.  I added a print statement to the visitor to
 verify that my new code was actually getting executed.  
 
-In `lib/semantics/check-do.h`, I added the declaration for the visitor:
+In `lib/Semantics/check-do.h`, I added the declaration for the visitor:
 
 ```C++
   void Leave(const parser::Expr &);
 ```
 
-In `lib/semantics/check-do.cpp`, I added an (almost empty) implementation:
+In `lib/Semantics/check-do.cpp`, I added an (almost empty) implementation:
 
 ```C++
   void DoChecker::Leave(const parser::Expr &) {
@@ -316,7 +316,7 @@ framework to walk the `evaluate::Expr` to gather all of the
 `evaluate::ActualArgument` nodes.  The code that I planned to model it on
 was the existing infrastructure that collected all of the `semantics::Symbol` nodes from an
 `evaluate::Expr`.  I found this implementation in
-`lib/evaluate/tools.cpp`:
+`lib/Evaluate/tools.cpp`:
 
 ```C++
   struct CollectSymbolsHelper
@@ -334,7 +334,7 @@ was the existing infrastructure that collected all of the `semantics::Symbol` no
 ```
 
 Note that the `CollectSymbols()` function returns a `semantics::Symbolset`,
-which is declared in `include/flang/semantics/symbol.h`:
+which is declared in `include/flang/Semantics/symbol.h`:
 
 ```C++
   using SymbolSet = std::set<SymbolRef>;
@@ -356,11 +356,11 @@ full `semantics::Symbol` objects into the set.  Ideally, we would be able to cre
 `std::set<Symbol &>` (a set of C++ references to symbols).  But C++ doesn't
 support sets that contain references.  This limitation is part of the rationale
 for the f18 implementation of type `common::Reference`, which is defined in
-  `include/flang/common/reference.h`.
+  `include/flang/Common/reference.h`.
 
 `SymbolRef`, the specialization of the template `common::Reference` for
 `semantics::Symbol`, is declared in the file
-`include/flang/semantics/symbol.h`:
+`include/flang/Semantics/symbol.h`:
 
 ```C++
   using SymbolRef = common::Reference<const Symbol>;
@@ -370,7 +370,7 @@ So to implement something that would collect `evaluate::ActualArgument`
 nodes from an `evaluate::Expr`, I first defined the required types
 `ActualArgumentRef` and `ActualArgumentSet`.  Since these are being
 used exclusively for DO construct semantic checking (currently), I put their
-definitions into `lib/semantics/check-do.cpp`:
+definitions into `lib/Semantics/check-do.cpp`:
 
 
 ```C++
@@ -386,7 +386,7 @@ Since `ActualArgument` is in the namespace `evaluate`, I put the
 definition for `ActualArgumentRef` in that namespace, too.
 
 I then modeled the code to create an `ActualArgumentSet` after the code to
-collect a `SymbolSet` and put it into `lib/semantics/check-do.cpp`:
+collect a `SymbolSet` and put it into `lib/Semantics/check-do.cpp`:
 
 
 ```C++
@@ -525,8 +525,8 @@ symbol table node (`semantics::Symbol`) for the variable.  My starting point was
 `evaluate::ActualArgument` node.  
 
 I was unsure of how to do this, so I browsed through existing code to look for
-how it treated `evaluate::ActualArgument` objects.  Since most of the code that deals with the `evaluate` namespace is in the lib/evaluate directory, I looked there.  I ran `grep` on all of the `.cpp` files looking for
-uses of `ActualArgument`.  One of the first hits I got was in `lib/evaluate/call.cpp` in the definition of `ActualArgument::GetType()`:
+how it treated `evaluate::ActualArgument` objects.  Since most of the code that deals with the `evaluate` namespace is in the lib/Evaluate directory, I looked there.  I ran `grep` on all of the `.cpp` files looking for
+uses of `ActualArgument`.  One of the first hits I got was in `lib/Evaluate/call.cpp` in the definition of `ActualArgument::GetType()`:
 
 ```C++
 std::optional<DynamicType> ActualArgument::GetType() const {
@@ -544,7 +544,7 @@ I noted the call to `UnwrapExpr()` that yielded a value of
 `Expr<SomeType>`.  So I guessed that I could use this member function to
 get an `evaluate::Expr<SomeType>` on which I could perform further analysis.
 
-I also knew that the header file `include/flang/evaluate/tools.h` held many
+I also knew that the header file `include/flang/Evaluate/tools.h` held many
 utility functions for dealing with `evaluate::Expr` objects.  I was hoping to
 find something that would determine if an `evaluate::Expr` was a variable.  So
 I searched for `IsVariable` and got a hit immediately.  
@@ -560,7 +560,7 @@ I searched for `IsVariable` and got a hit immediately.
 
 But I actually needed more than just the knowledge that an `evaluate::Expr` was
 a variable.  I needed the `semantics::Symbol` associated with the variable.  So
-I searched in `include/flang/evaluate/tools.h` for functions that returned a
+I searched in `include/flang/Evaluate/tools.h` for functions that returned a
 `semantics::Symbol`.  I found the following:
 
 ```C++
diff --git a/include/flang/common/Fortran-features.h b/include/flang/Common/Fortran-features.h
similarity index 94%
rename from include/flang/common/Fortran-features.h
rename to include/flang/Common/Fortran-features.h
index 0b318e90e3af..dfce05c99cd5 100644
--- a/include/flang/common/Fortran-features.h
+++ b/include/flang/Common/Fortran-features.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/Fortran-features.h -----------------*- C++ -*-===//
+//===-- include/flang/Common/Fortran-features.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.
@@ -9,9 +9,9 @@
 #ifndef FORTRAN_COMMON_FORTRAN_FEATURES_H_
 #define FORTRAN_COMMON_FORTRAN_FEATURES_H_
 
-#include "flang/common/Fortran.h"
-#include "flang/common/enum-set.h"
-#include "flang/common/idioms.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Common/idioms.h"
 
 namespace Fortran::common {
 
diff --git a/include/flang/common/Fortran.h b/include/flang/Common/Fortran.h
similarity index 97%
rename from include/flang/common/Fortran.h
rename to include/flang/Common/Fortran.h
index 9c73c32dcebb..20a507aed415 100644
--- a/include/flang/common/Fortran.h
+++ b/include/flang/Common/Fortran.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/Fortran.h --------------------------*- C++ -*-===//
+//===-- include/flang/Common/Fortran.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.
diff --git a/include/flang/common/bit-population-count.h b/include/flang/Common/bit-population-count.h
similarity index 98%
rename from include/flang/common/bit-population-count.h
rename to include/flang/Common/bit-population-count.h
index 0a95643eb71d..af3a1f22fd30 100644
--- a/include/flang/common/bit-population-count.h
+++ b/include/flang/Common/bit-population-count.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/bit-population-count.h -------------*- C++ -*-===//
+//===-- include/flang/Common/bit-population-count.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.
diff --git a/include/flang/common/constexpr-bitset.h b/include/flang/Common/constexpr-bitset.h
similarity index 98%
rename from include/flang/common/constexpr-bitset.h
rename to include/flang/Common/constexpr-bitset.h
index 1125655adbab..eae11f57d1e1 100644
--- a/include/flang/common/constexpr-bitset.h
+++ b/include/flang/Common/constexpr-bitset.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/constexpr-bitset.h -----------------*- C++ -*-===//
+//===-- include/flang/Common/constexpr-bitset.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.
diff --git a/include/flang/common/default-kinds.h b/include/flang/Common/default-kinds.h
similarity index 96%
rename from include/flang/common/default-kinds.h
rename to include/flang/Common/default-kinds.h
index e9532ad8ddcb..c3610b23745f 100644
--- a/include/flang/common/default-kinds.h
+++ b/include/flang/Common/default-kinds.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/default-kinds.h --------------------*- C++ -*-===//
+//===-- include/flang/Common/default-kinds.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_COMMON_DEFAULT_KINDS_H_
 #define FORTRAN_COMMON_DEFAULT_KINDS_H_
 
-#include "flang/common/Fortran.h"
+#include "flang/Common/Fortran.h"
 #include <cstdint>
 
 namespace Fortran::common {
diff --git a/include/flang/common/enum-set.h b/include/flang/Common/enum-set.h
similarity index 99%
rename from include/flang/common/enum-set.h
rename to include/flang/Common/enum-set.h
index 04141808a5b8..4b255c38cc5a 100644
--- a/include/flang/common/enum-set.h
+++ b/include/flang/Common/enum-set.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/enum-set.h -------------------------*- C++ -*-===//
+//===-- include/flang/Common/enum-set.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.
diff --git a/include/flang/common/format.h b/include/flang/Common/format.h
similarity index 99%
rename from include/flang/common/format.h
rename to include/flang/Common/format.h
index 92cd0e94fad9..4cb274c81cd5 100644
--- a/include/flang/common/format.h
+++ b/include/flang/Common/format.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/format.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Common/format.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.
@@ -10,7 +10,7 @@
 #define FORTRAN_COMMON_FORMAT_H_
 
 #include "enum-set.h"
-#include "flang/common/Fortran.h"
+#include "flang/Common/Fortran.h"
 #include <cstring>
 
 // Define a FormatValidator class template to validate a format expression
diff --git a/include/flang/common/idioms.h b/include/flang/Common/idioms.h
similarity index 98%
rename from include/flang/common/idioms.h
rename to include/flang/Common/idioms.h
index 8debe21acb66..84862f4976da 100644
--- a/include/flang/common/idioms.h
+++ b/include/flang/Common/idioms.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/idioms.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Common/idioms.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.
diff --git a/include/flang/common/indirection.h b/include/flang/Common/indirection.h
similarity index 98%
rename from include/flang/common/indirection.h
rename to include/flang/Common/indirection.h
index fcf05549ae7e..a79fc19a388f 100644
--- a/include/flang/common/indirection.h
+++ b/include/flang/Common/indirection.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/indirection.h ----------------------*- C++ -*-===//
+//===-- include/flang/Common/indirection.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.
diff --git a/include/flang/common/interval.h b/include/flang/Common/interval.h
similarity index 98%
rename from include/flang/common/interval.h
rename to include/flang/Common/interval.h
index 144f719de7b3..c1d1cfb890c8 100644
--- a/include/flang/common/interval.h
+++ b/include/flang/Common/interval.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/interval.h -------------------------*- C++ -*-===//
+//===-- include/flang/Common/interval.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.
diff --git a/include/flang/common/leading-zero-bit-count.h b/include/flang/Common/leading-zero-bit-count.h
similarity index 98%
rename from include/flang/common/leading-zero-bit-count.h
rename to include/flang/Common/leading-zero-bit-count.h
index fe7bf00378e0..48fc3f129059 100644
--- a/include/flang/common/leading-zero-bit-count.h
+++ b/include/flang/Common/leading-zero-bit-count.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/leading-zero-bit-count.h -----------*- C++ -*-===//
+//===-- include/flang/Common/leading-zero-bit-count.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.
diff --git a/include/flang/common/real.h b/include/flang/Common/real.h
similarity index 98%
rename from include/flang/common/real.h
rename to include/flang/Common/real.h
index d15de663a92b..158482e6c5c1 100644
--- a/include/flang/common/real.h
+++ b/include/flang/Common/real.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/real.h -----------------------------*- C++ -*-===//
+//===-- include/flang/Common/real.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.
diff --git a/include/flang/common/reference-counted.h b/include/flang/Common/reference-counted.h
similarity index 96%
rename from include/flang/common/reference-counted.h
rename to include/flang/Common/reference-counted.h
index d7dc68c76492..2a96741bb8f7 100644
--- a/include/flang/common/reference-counted.h
+++ b/include/flang/Common/reference-counted.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/reference-counted.h ----------------*- C++ -*-===//
+//===-- include/flang/Common/reference-counted.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.
diff --git a/include/flang/common/reference.h b/include/flang/Common/reference.h
similarity index 96%
rename from include/flang/common/reference.h
rename to include/flang/Common/reference.h
index 8f01b6587c23..37e7ab9ca523 100644
--- a/include/flang/common/reference.h
+++ b/include/flang/Common/reference.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/reference.h ------------------------*- C++ -*-===//
+//===-- include/flang/Common/reference.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.
diff --git a/include/flang/common/restorer.h b/include/flang/Common/restorer.h
similarity index 95%
rename from include/flang/common/restorer.h
rename to include/flang/Common/restorer.h
index 95b730b83513..26ddcfca0820 100644
--- a/include/flang/common/restorer.h
+++ b/include/flang/Common/restorer.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/restorer.h -------------------------*- C++ -*-===//
+//===-- include/flang/Common/restorer.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.
diff --git a/include/flang/common/template.h b/include/flang/Common/template.h
similarity index 99%
rename from include/flang/common/template.h
rename to include/flang/Common/template.h
index 460f1a8bdaed..2f726fe6cc39 100644
--- a/include/flang/common/template.h
+++ b/include/flang/Common/template.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/template.h -------------------------*- C++ -*-===//
+//===-- include/flang/Common/template.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_COMMON_TEMPLATE_H_
 #define FORTRAN_COMMON_TEMPLATE_H_
 
-#include "flang/common/idioms.h"
+#include "flang/Common/idioms.h"
 #include <functional>
 #include <optional>
 #include <tuple>
diff --git a/include/flang/common/uint128.h b/include/flang/Common/uint128.h
similarity index 99%
rename from include/flang/common/uint128.h
rename to include/flang/Common/uint128.h
index 0129101a1ce9..4d4fed94a002 100644
--- a/include/flang/common/uint128.h
+++ b/include/flang/Common/uint128.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/uint128.h --------------------------*- C++ -*-===//
+//===-- include/flang/Common/uint128.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.
diff --git a/include/flang/common/unsigned-const-division.h b/include/flang/Common/unsigned-const-division.h
similarity index 97%
rename from include/flang/common/unsigned-const-division.h
rename to include/flang/Common/unsigned-const-division.h
index 749983e8464c..752bbd94e7fa 100644
--- a/include/flang/common/unsigned-const-division.h
+++ b/include/flang/Common/unsigned-const-division.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/unsigned-const-division.h ----------*- C++ -*-===//
+//===-- include/flang/Common/unsigned-const-division.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.
diff --git a/include/flang/common/unwrap.h b/include/flang/Common/unwrap.h
similarity index 98%
rename from include/flang/common/unwrap.h
rename to include/flang/Common/unwrap.h
index 1370b1425202..8a14bf68fb27 100644
--- a/include/flang/common/unwrap.h
+++ b/include/flang/Common/unwrap.h
@@ -1,4 +1,4 @@
-//===-- include/flang/common/unwrap.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Common/unwrap.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.
diff --git a/include/flang/decimal/binary-floating-point.h b/include/flang/Decimal/binary-floating-point.h
similarity index 96%
rename from include/flang/decimal/binary-floating-point.h
rename to include/flang/Decimal/binary-floating-point.h
index bf467c5cbb70..ad3eb3e47ad1 100644
--- a/include/flang/decimal/binary-floating-point.h
+++ b/include/flang/Decimal/binary-floating-point.h
@@ -1,4 +1,4 @@
-//===-- include/flang/decimal/binary-floating-point.h -----------*- C++ -*-===//
+//===-- include/flang/Decimal/binary-floating-point.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.
@@ -12,8 +12,8 @@
 // Access and manipulate the fields of an IEEE-754 binary
 // floating-point value via a generalized template.
 
-#include "flang/common/real.h"
-#include "flang/common/uint128.h"
+#include "flang/Common/real.h"
+#include "flang/Common/uint128.h"
 #include <cinttypes>
 #include <climits>
 #include <cstring>
diff --git a/include/flang/decimal/decimal.h b/include/flang/Decimal/decimal.h
similarity index 98%
rename from include/flang/decimal/decimal.h
rename to include/flang/Decimal/decimal.h
index 05ed0068d95c..1e792d78cc1f 100644
--- a/include/flang/decimal/decimal.h
+++ b/include/flang/Decimal/decimal.h
@@ -1,4 +1,4 @@
-/*===-- include/flang/decimal/decimal.h ---------------------------*- C++ -*-===
+/*===-- include/flang/Decimal/decimal.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.
diff --git a/include/flang/evaluate/call.h b/include/flang/Evaluate/call.h
similarity index 97%
rename from include/flang/evaluate/call.h
rename to include/flang/Evaluate/call.h
index 97d1ea1b04f9..a792ff4188ec 100644
--- a/include/flang/evaluate/call.h
+++ b/include/flang/Evaluate/call.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/call.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/call.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.
@@ -13,10 +13,10 @@
 #include "constant.h"
 #include "formatting.h"
 #include "type.h"
-#include "flang/common/indirection.h"
-#include "flang/common/reference.h"
-#include "flang/parser/char-block.h"
-#include "flang/semantics/attr.h"
+#include "flang/Common/indirection.h"
+#include "flang/Common/reference.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Semantics/attr.h"
 #include <optional>
 #include <ostream>
 #include <vector>
diff --git a/include/flang/evaluate/characteristics.h b/include/flang/Evaluate/characteristics.h
similarity index 97%
rename from include/flang/evaluate/characteristics.h
rename to include/flang/Evaluate/characteristics.h
index 9e61602579e7..52ac7384815b 100644
--- a/include/flang/evaluate/characteristics.h
+++ b/include/flang/Evaluate/characteristics.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/characteristics.h ----------------*- C++ -*-===//
+//===-- include/flang/Evaluate/characteristics.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.
@@ -17,12 +17,12 @@
 #include "expression.h"
 #include "shape.h"
 #include "type.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/enum-set.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
-#include "flang/parser/char-block.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Semantics/symbol.h"
 #include <optional>
 #include <ostream>
 #include <string>
diff --git a/include/flang/evaluate/check-expression.h b/include/flang/Evaluate/check-expression.h
similarity index 97%
rename from include/flang/evaluate/check-expression.h
rename to include/flang/Evaluate/check-expression.h
index 31a79fb19585..afd730924baf 100644
--- a/include/flang/evaluate/check-expression.h
+++ b/include/flang/Evaluate/check-expression.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/check-expression.h ---------------*- C++ -*-===//
+//===-- include/flang/Evaluate/check-expression.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.
diff --git a/include/flang/evaluate/common.h b/include/flang/Evaluate/common.h
similarity index 96%
rename from include/flang/evaluate/common.h
rename to include/flang/Evaluate/common.h
index b7ea530e712f..d76126b1436b 100644
--- a/include/flang/evaluate/common.h
+++ b/include/flang/Evaluate/common.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/common.h -------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/common.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.
@@ -10,14 +10,14 @@
 #define FORTRAN_EVALUATE_COMMON_H_
 
 #include "intrinsics-library.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/default-kinds.h"
-#include "flang/common/enum-set.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
-#include "flang/common/restorer.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/message.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
+#include "flang/Common/restorer.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/message.h"
 #include <cinttypes>
 #include <map>
 
diff --git a/include/flang/evaluate/complex.h b/include/flang/Evaluate/complex.h
similarity index 98%
rename from include/flang/evaluate/complex.h
rename to include/flang/Evaluate/complex.h
index 16559e9f0962..417d4cfecbbd 100644
--- a/include/flang/evaluate/complex.h
+++ b/include/flang/Evaluate/complex.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/complex.h ------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/complex.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.
diff --git a/include/flang/evaluate/constant.h b/include/flang/Evaluate/constant.h
similarity index 98%
rename from include/flang/evaluate/constant.h
rename to include/flang/Evaluate/constant.h
index 833702a03c91..2a4a8109283f 100644
--- a/include/flang/evaluate/constant.h
+++ b/include/flang/Evaluate/constant.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/constant.h -----------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/constant.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.
@@ -11,8 +11,8 @@
 
 #include "formatting.h"
 #include "type.h"
-#include "flang/common/default-kinds.h"
-#include "flang/common/reference.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Common/reference.h"
 #include <map>
 #include <ostream>
 #include <vector>
diff --git a/include/flang/evaluate/expression.h b/include/flang/Evaluate/expression.h
similarity index 99%
rename from include/flang/evaluate/expression.h
rename to include/flang/Evaluate/expression.h
index 019858a6e3da..52c17a957b9b 100644
--- a/include/flang/evaluate/expression.h
+++ b/include/flang/Evaluate/expression.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/expression.h ---------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/expression.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.
@@ -21,11 +21,11 @@
 #include "formatting.h"
 #include "type.h"
 #include "variable.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
-#include "flang/common/template.h"
-#include "flang/parser/char-block.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
+#include "flang/Common/template.h"
+#include "flang/Parser/char-block.h"
 #include <algorithm>
 #include <list>
 #include <ostream>
diff --git a/include/flang/evaluate/fold.h b/include/flang/Evaluate/fold.h
similarity index 97%
rename from include/flang/evaluate/fold.h
rename to include/flang/Evaluate/fold.h
index 5f33d69a2fe6..85e497464508 100644
--- a/include/flang/evaluate/fold.h
+++ b/include/flang/Evaluate/fold.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/fold.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/fold.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.
diff --git a/include/flang/evaluate/formatting.h b/include/flang/Evaluate/formatting.h
similarity index 90%
rename from include/flang/evaluate/formatting.h
rename to include/flang/Evaluate/formatting.h
index a2b8458d042f..0a1f9517d2d0 100644
--- a/include/flang/evaluate/formatting.h
+++ b/include/flang/Evaluate/formatting.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/formatting.h ---------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/formatting.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.
@@ -11,7 +11,7 @@
 
 // It is inconvenient in C++ to have std::ostream::operator<<() as a direct
 // friend function of a class template with many instantiations, so the
-// various representational class templates in lib/evaluate format themselves
+// various representational class templates in lib/Evaluate format themselves
 // via AsFortran(std::ostream &) member functions, which the operator<<()
 // overload below will call.  Others have AsFortran() member functions that
 // return strings.
@@ -19,7 +19,7 @@
 // This header is meant to be included by the headers that define the several
 // representational class templates that need it, not by external clients.
 
-#include "flang/common/indirection.h"
+#include "flang/Common/indirection.h"
 #include <optional>
 #include <ostream>
 #include <type_traits>
diff --git a/include/flang/evaluate/integer.h b/include/flang/Evaluate/integer.h
similarity index 99%
rename from include/flang/evaluate/integer.h
rename to include/flang/Evaluate/integer.h
index 46478f7e6106..6f997c967e69 100644
--- a/include/flang/evaluate/integer.h
+++ b/include/flang/Evaluate/integer.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/integer.h ------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/integer.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.
@@ -17,9 +17,9 @@
 // (*"Signed" here means two's-complement, just to be clear.  Ones'-complement
 // and signed-magnitude encodings appear to be extinct in 2018.)
 
-#include "flang/common/bit-population-count.h"
-#include "flang/common/leading-zero-bit-count.h"
-#include "flang/evaluate/common.h"
+#include "flang/Common/bit-population-count.h"
+#include "flang/Common/leading-zero-bit-count.h"
+#include "flang/Evaluate/common.h"
 #include <cinttypes>
 #include <climits>
 #include <cstddef>
diff --git a/include/flang/evaluate/intrinsics-library.h b/include/flang/Evaluate/intrinsics-library.h
similarity index 98%
rename from include/flang/evaluate/intrinsics-library.h
rename to include/flang/Evaluate/intrinsics-library.h
index a7a1959a22bb..3e1bf5471c2c 100644
--- a/include/flang/evaluate/intrinsics-library.h
+++ b/include/flang/Evaluate/intrinsics-library.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/intrinsics-library.h -------------*- C++ -*-===//
+//===-- include/flang/Evaluate/intrinsics-library.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.
diff --git a/include/flang/evaluate/intrinsics.h b/include/flang/Evaluate/intrinsics.h
similarity index 93%
rename from include/flang/evaluate/intrinsics.h
rename to include/flang/Evaluate/intrinsics.h
index 525e0907a159..dce5162cb944 100644
--- a/include/flang/evaluate/intrinsics.h
+++ b/include/flang/Evaluate/intrinsics.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/intrinsics.h ---------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/intrinsics.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.
@@ -12,9 +12,9 @@
 #include "call.h"
 #include "characteristics.h"
 #include "type.h"
-#include "flang/common/default-kinds.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/message.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/message.h"
 #include <optional>
 #include <ostream>
 #include <string>
diff --git a/include/flang/evaluate/logical.h b/include/flang/Evaluate/logical.h
similarity index 97%
rename from include/flang/evaluate/logical.h
rename to include/flang/Evaluate/logical.h
index d76abf854d6a..a7813ecfdd70 100644
--- a/include/flang/evaluate/logical.h
+++ b/include/flang/Evaluate/logical.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/logical.h ------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/logical.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.
diff --git a/include/flang/evaluate/real.h b/include/flang/Evaluate/real.h
similarity index 98%
rename from include/flang/evaluate/real.h
rename to include/flang/Evaluate/real.h
index bcc73cb54b73..0624abd3ee93 100644
--- a/include/flang/evaluate/real.h
+++ b/include/flang/Evaluate/real.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/real.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/real.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.
@@ -12,8 +12,8 @@
 #include "formatting.h"
 #include "integer.h"
 #include "rounding-bits.h"
-#include "flang/common/real.h"
-#include "flang/evaluate/common.h"
+#include "flang/Common/real.h"
+#include "flang/Evaluate/common.h"
 #include <cinttypes>
 #include <limits>
 #include <ostream>
diff --git a/include/flang/evaluate/rounding-bits.h b/include/flang/Evaluate/rounding-bits.h
similarity index 97%
rename from include/flang/evaluate/rounding-bits.h
rename to include/flang/Evaluate/rounding-bits.h
index bc5771659595..271d780b923f 100644
--- a/include/flang/evaluate/rounding-bits.h
+++ b/include/flang/Evaluate/rounding-bits.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/rounding-bits.h ------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/rounding-bits.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.
diff --git a/include/flang/evaluate/shape.h b/include/flang/Evaluate/shape.h
similarity index 97%
rename from include/flang/evaluate/shape.h
rename to include/flang/Evaluate/shape.h
index ca9700b02583..c7f453c90f0b 100644
--- a/include/flang/evaluate/shape.h
+++ b/include/flang/Evaluate/shape.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/shape.h --------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/shape.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.
@@ -15,9 +15,9 @@
 #include "expression.h"
 #include "traverse.h"
 #include "variable.h"
-#include "flang/common/indirection.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/type.h"
+#include "flang/Common/indirection.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/type.h"
 #include <optional>
 #include <variant>
 
diff --git a/include/flang/evaluate/static-data.h b/include/flang/Evaluate/static-data.h
similarity index 95%
rename from include/flang/evaluate/static-data.h
rename to include/flang/Evaluate/static-data.h
index ce66351ba140..5a708aa25390 100644
--- a/include/flang/evaluate/static-data.h
+++ b/include/flang/Evaluate/static-data.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/static-data.h --------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/static-data.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.
@@ -13,7 +13,7 @@
 
 #include "formatting.h"
 #include "type.h"
-#include "flang/common/idioms.h"
+#include "flang/Common/idioms.h"
 #include <cinttypes>
 #include <memory>
 #include <optional>
diff --git a/include/flang/evaluate/tools.h b/include/flang/Evaluate/tools.h
similarity index 98%
rename from include/flang/evaluate/tools.h
rename to include/flang/Evaluate/tools.h
index d992e8eacff5..7f867813b2bc 100644
--- a/include/flang/evaluate/tools.h
+++ b/include/flang/Evaluate/tools.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/tools.h --------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/tools.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.
@@ -10,14 +10,14 @@
 #define FORTRAN_EVALUATE_TOOLS_H_
 
 #include "traverse.h"
-#include "flang/common/idioms.h"
-#include "flang/common/template.h"
-#include "flang/common/unwrap.h"
-#include "flang/evaluate/constant.h"
-#include "flang/evaluate/expression.h"
-#include "flang/parser/message.h"
-#include "flang/semantics/attr.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/template.h"
+#include "flang/Common/unwrap.h"
+#include "flang/Evaluate/constant.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Parser/message.h"
+#include "flang/Semantics/attr.h"
+#include "flang/Semantics/symbol.h"
 #include <array>
 #include <optional>
 #include <set>
diff --git a/include/flang/evaluate/traverse.h b/include/flang/Evaluate/traverse.h
similarity index 98%
rename from include/flang/evaluate/traverse.h
rename to include/flang/Evaluate/traverse.h
index d85afac239e0..23b3d4cf682c 100644
--- a/include/flang/evaluate/traverse.h
+++ b/include/flang/Evaluate/traverse.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/traverse.h -----------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/traverse.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.
@@ -35,8 +35,8 @@
 // - Overloads of operator() in each visitor handle the cases of interest.
 
 #include "expression.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/type.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/type.h"
 #include <set>
 #include <type_traits>
 
diff --git a/include/flang/evaluate/type.h b/include/flang/Evaluate/type.h
similarity index 99%
rename from include/flang/evaluate/type.h
rename to include/flang/Evaluate/type.h
index a558928d4893..137cf66e9cd9 100644
--- a/include/flang/evaluate/type.h
+++ b/include/flang/Evaluate/type.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/type.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/type.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.
@@ -22,9 +22,9 @@
 #include "integer.h"
 #include "logical.h"
 #include "real.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/idioms.h"
-#include "flang/common/template.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/template.h"
 #include <cinttypes>
 #include <optional>
 #include <string>
diff --git a/include/flang/evaluate/variable.h b/include/flang/Evaluate/variable.h
similarity index 98%
rename from include/flang/evaluate/variable.h
rename to include/flang/Evaluate/variable.h
index bbbdd7c74903..b39011aeab64 100644
--- a/include/flang/evaluate/variable.h
+++ b/include/flang/Evaluate/variable.h
@@ -1,4 +1,4 @@
-//===-- include/flang/evaluate/variable.h -----------------------*- C++ -*-===//
+//===-- include/flang/Evaluate/variable.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.
@@ -20,10 +20,10 @@
 #include "formatting.h"
 #include "static-data.h"
 #include "type.h"
-#include "flang/common/idioms.h"
-#include "flang/common/reference.h"
-#include "flang/common/template.h"
-#include "flang/parser/char-block.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/reference.h"
+#include "flang/Common/template.h"
+#include "flang/Parser/char-block.h"
 #include <optional>
 #include <ostream>
 #include <variant>
diff --git a/include/flang/lower/.clang-format b/include/flang/Lower/.clang-format
similarity index 100%
rename from include/flang/lower/.clang-format
rename to include/flang/Lower/.clang-format
diff --git a/include/flang/lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
similarity index 99%
rename from include/flang/lower/PFTBuilder.h
rename to include/flang/Lower/PFTBuilder.h
index 0b1345ef8bee..bef98b519038 100644
--- a/include/flang/lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -1,4 +1,4 @@
-//===-- include/flang/lower/PFTBuilder.h ------------------------*- C++ -*-===//
+//===-- include/flang/Lower/PFTBuilder.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.
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_LOWER_PFT_BUILDER_H_
 #define FORTRAN_LOWER_PFT_BUILDER_H_
 
-#include "flang/common/template.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Common/template.h"
+#include "flang/Parser/parse-tree.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
diff --git a/include/flang/optimizer/.clang-format b/include/flang/Optimizer/.clang-format
similarity index 100%
rename from include/flang/optimizer/.clang-format
rename to include/flang/Optimizer/.clang-format
diff --git a/include/flang/parser/char-block.h b/include/flang/Parser/char-block.h
similarity index 98%
rename from include/flang/parser/char-block.h
rename to include/flang/Parser/char-block.h
index f05211fa8845..421bff9dc0d7 100644
--- a/include/flang/parser/char-block.h
+++ b/include/flang/Parser/char-block.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/char-block.h -----------------------*- C++ -*-===//
+//===-- include/flang/Parser/char-block.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.
@@ -11,7 +11,7 @@
 
 // Describes a contiguous block of characters; does not own their storage.
 
-#include "flang/common/interval.h"
+#include "flang/Common/interval.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
diff --git a/include/flang/parser/char-buffer.h b/include/flang/Parser/char-buffer.h
similarity index 97%
rename from include/flang/parser/char-buffer.h
rename to include/flang/Parser/char-buffer.h
index b9f66c6f3dde..a62659b7c69d 100644
--- a/include/flang/parser/char-buffer.h
+++ b/include/flang/Parser/char-buffer.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/char-buffer.h ----------------------*- C++ -*-===//
+//===-- include/flang/Parser/char-buffer.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.
diff --git a/include/flang/parser/char-set.h b/include/flang/Parser/char-set.h
similarity index 97%
rename from include/flang/parser/char-set.h
rename to include/flang/Parser/char-set.h
index 9bac7ea01180..64ff6692b1d1 100644
--- a/include/flang/parser/char-set.h
+++ b/include/flang/Parser/char-set.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/char-set.h -------------------------*- C++ -*-===//
+//===-- include/flang/Parser/char-set.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.
diff --git a/include/flang/parser/characters.h b/include/flang/Parser/characters.h
similarity index 99%
rename from include/flang/parser/characters.h
rename to include/flang/Parser/characters.h
index 102d886d3a0b..02b92ba6f047 100644
--- a/include/flang/parser/characters.h
+++ b/include/flang/Parser/characters.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/characters.h -----------------------*- C++ -*-===//
+//===-- include/flang/Parser/characters.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.
diff --git a/include/flang/parser/dump-parse-tree.h b/include/flang/Parser/dump-parse-tree.h
similarity index 99%
rename from include/flang/parser/dump-parse-tree.h
rename to include/flang/Parser/dump-parse-tree.h
index a6181834c94f..d132e93eeab5 100644
--- a/include/flang/parser/dump-parse-tree.h
+++ b/include/flang/Parser/dump-parse-tree.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/dump-parse-tree.h ------------------*- C++ -*-===//
+//===-- include/flang/Parser/dump-parse-tree.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.
@@ -13,8 +13,8 @@
 #include "parse-tree-visitor.h"
 #include "parse-tree.h"
 #include "unparse.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
 #include <ostream>
 #include <sstream>
 #include <string>
diff --git a/include/flang/parser/format-specification.h b/include/flang/Parser/format-specification.h
similarity index 98%
rename from include/flang/parser/format-specification.h
rename to include/flang/Parser/format-specification.h
index 6f1de183a30e..872d025b5e61 100644
--- a/include/flang/parser/format-specification.h
+++ b/include/flang/Parser/format-specification.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/format-specification.h -------------*- C++ -*-===//
+//===-- include/flang/Parser/format-specification.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.
diff --git a/include/flang/parser/instrumented-parser.h b/include/flang/Parser/instrumented-parser.h
similarity index 94%
rename from include/flang/parser/instrumented-parser.h
rename to include/flang/Parser/instrumented-parser.h
index ec760a610a08..0369a5f363fb 100644
--- a/include/flang/parser/instrumented-parser.h
+++ b/include/flang/Parser/instrumented-parser.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/instrumented-parser.h --------------*- C++ -*-===//
+//===-- include/flang/Parser/instrumented-parser.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.
@@ -11,8 +11,8 @@
 
 #include "parse-state.h"
 #include "user-state.h"
-#include "flang/parser/message.h"
-#include "flang/parser/provenance.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/provenance.h"
 #include <cstddef>
 #include <map>
 #include <ostream>
diff --git a/include/flang/parser/message.h b/include/flang/Parser/message.h
similarity index 98%
rename from include/flang/parser/message.h
rename to include/flang/Parser/message.h
index fd62f4671f55..19b94bb70388 100644
--- a/include/flang/parser/message.h
+++ b/include/flang/Parser/message.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/message.h --------------------------*- C++ -*-===//
+//===-- include/flang/Parser/message.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.
@@ -15,9 +15,9 @@
 #include "char-block.h"
 #include "char-set.h"
 #include "provenance.h"
-#include "flang/common/idioms.h"
-#include "flang/common/reference-counted.h"
-#include "flang/common/restorer.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/reference-counted.h"
+#include "flang/Common/restorer.h"
 #include <cstddef>
 #include <cstring>
 #include <forward_list>
diff --git a/include/flang/parser/parse-state.h b/include/flang/Parser/parse-state.h
similarity index 96%
rename from include/flang/parser/parse-state.h
rename to include/flang/Parser/parse-state.h
index afd4516403a3..d0b304f3c73b 100644
--- a/include/flang/parser/parse-state.h
+++ b/include/flang/Parser/parse-state.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/parse-state.h ----------------------*- C++ -*-===//
+//===-- include/flang/Parser/parse-state.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.
@@ -16,11 +16,11 @@
 // and recovery during parsing!
 
 #include "user-state.h"
-#include "flang/common/Fortran-features.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/message.h"
-#include "flang/parser/provenance.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/provenance.h"
 #include <cstddef>
 #include <cstring>
 #include <list>
diff --git a/include/flang/parser/parse-tree-visitor.h b/include/flang/Parser/parse-tree-visitor.h
similarity index 99%
rename from include/flang/parser/parse-tree-visitor.h
rename to include/flang/Parser/parse-tree-visitor.h
index b2c49fe48034..de8e36ba7fd6 100644
--- a/include/flang/parser/parse-tree-visitor.h
+++ b/include/flang/Parser/parse-tree-visitor.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/parse-tree-visitor.h ---------------*- C++ -*-===//
+//===-- include/flang/Parser/parse-tree-visitor.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.
diff --git a/include/flang/parser/parse-tree.h b/include/flang/Parser/parse-tree.h
similarity index 99%
rename from include/flang/parser/parse-tree.h
rename to include/flang/Parser/parse-tree.h
index f1e02e0a45d5..d7bb1f5686aa 100644
--- a/include/flang/parser/parse-tree.h
+++ b/include/flang/Parser/parse-tree.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/parse-tree.h -----------------------*- C++ -*-===//
+//===-- include/flang/Parser/parse-tree.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.
@@ -22,9 +22,9 @@
 #include "format-specification.h"
 #include "message.h"
 #include "provenance.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
 #include <cinttypes>
 #include <list>
 #include <memory>
diff --git a/include/flang/parser/parsing.h b/include/flang/Parser/parsing.h
similarity index 95%
rename from include/flang/parser/parsing.h
rename to include/flang/Parser/parsing.h
index a163a77e5856..cff2f57b8185 100644
--- a/include/flang/parser/parsing.h
+++ b/include/flang/Parser/parsing.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/parsing.h --------------------------*- C++ -*-===//
+//===-- include/flang/Parser/parsing.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.
@@ -14,7 +14,7 @@
 #include "message.h"
 #include "parse-tree.h"
 #include "provenance.h"
-#include "flang/common/Fortran-features.h"
+#include "flang/Common/Fortran-features.h"
 #include <optional>
 #include <ostream>
 #include <string>
diff --git a/include/flang/parser/provenance.h b/include/flang/Parser/provenance.h
similarity index 98%
rename from include/flang/parser/provenance.h
rename to include/flang/Parser/provenance.h
index 08cdf51345d3..f1f48c07715d 100644
--- a/include/flang/parser/provenance.h
+++ b/include/flang/Parser/provenance.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/provenance.h -----------------------*- C++ -*-===//
+//===-- include/flang/Parser/provenance.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.
@@ -13,8 +13,8 @@
 #include "char-buffer.h"
 #include "characters.h"
 #include "source.h"
-#include "flang/common/idioms.h"
-#include "flang/common/interval.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/interval.h"
 #include <cstddef>
 #include <map>
 #include <memory>
diff --git a/include/flang/parser/source.h b/include/flang/Parser/source.h
similarity index 97%
rename from include/flang/parser/source.h
rename to include/flang/Parser/source.h
index 5eb000da2163..08ce1514c07c 100644
--- a/include/flang/parser/source.h
+++ b/include/flang/Parser/source.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/source.h ---------------------------*- C++ -*-===//
+//===-- include/flang/Parser/source.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.
diff --git a/include/flang/parser/tools.h b/include/flang/Parser/tools.h
similarity index 97%
rename from include/flang/parser/tools.h
rename to include/flang/Parser/tools.h
index 447d08c1f496..dcb503b31b79 100644
--- a/include/flang/parser/tools.h
+++ b/include/flang/Parser/tools.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/tools.h ----------------------------*- C++ -*-===//
+//===-- include/flang/Parser/tools.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.
diff --git a/include/flang/parser/unparse.h b/include/flang/Parser/unparse.h
similarity index 95%
rename from include/flang/parser/unparse.h
rename to include/flang/Parser/unparse.h
index 0055ce30a701..d6bca8d2133c 100644
--- a/include/flang/parser/unparse.h
+++ b/include/flang/Parser/unparse.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/unparse.h --------------------------*- C++ -*-===//
+//===-- include/flang/Parser/unparse.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.
diff --git a/include/flang/parser/user-state.h b/include/flang/Parser/user-state.h
similarity index 94%
rename from include/flang/parser/user-state.h
rename to include/flang/Parser/user-state.h
index aaf86720d749..60a85d1fed6b 100644
--- a/include/flang/parser/user-state.h
+++ b/include/flang/Parser/user-state.h
@@ -1,4 +1,4 @@
-//===-- include/flang/parser/user-state.h -----------------------*- C++ -*-===//
+//===-- include/flang/Parser/user-state.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.
@@ -14,10 +14,10 @@
 // parse tree construction so as to avoid any need for representing
 // state in static data.
 
-#include "flang/common/Fortran-features.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/parse-tree.h"
 #include <cinttypes>
 #include <optional>
 #include <ostream>
diff --git a/include/flang/semantics/attr.h b/include/flang/Semantics/attr.h
similarity index 92%
rename from include/flang/semantics/attr.h
rename to include/flang/Semantics/attr.h
index 475d6891d528..48fec0441cd3 100644
--- a/include/flang/semantics/attr.h
+++ b/include/flang/Semantics/attr.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/attr.h --------------------------*- C++ -*-===//
+//===-- include/flang/Semantics/attr.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.
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_SEMANTICS_ATTR_H_
 #define FORTRAN_SEMANTICS_ATTR_H_
 
-#include "flang/common/enum-set.h"
-#include "flang/common/idioms.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Common/idioms.h"
 #include <cinttypes>
 #include <string>
 
diff --git a/include/flang/semantics/expression.h b/include/flang/Semantics/expression.h
similarity index 97%
rename from include/flang/semantics/expression.h
rename to include/flang/Semantics/expression.h
index 79360fc0bed0..2e135b0885d0 100644
--- a/include/flang/semantics/expression.h
+++ b/include/flang/Semantics/expression.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/expression.h --------------------*- C++ -*-===//
+//===-- include/flang/Semantics/expression.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.
@@ -10,17 +10,17 @@
 #define FORTRAN_SEMANTICS_EXPRESSION_H_
 
 #include "semantics.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/indirection.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/check-expression.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/type.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/indirection.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/check-expression.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
 #include <map>
 #include <optional>
 #include <variant>
diff --git a/include/flang/semantics/scope.h b/include/flang/Semantics/scope.h
similarity index 97%
rename from include/flang/semantics/scope.h
rename to include/flang/Semantics/scope.h
index 1de11bb53171..6f67ecbabf31 100644
--- a/include/flang/semantics/scope.h
+++ b/include/flang/Semantics/scope.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/scope.h -------------------------*- C++ -*-===//
+//===-- include/flang/Semantics/scope.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.
@@ -11,11 +11,11 @@
 
 #include "attr.h"
 #include "symbol.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/idioms.h"
-#include "flang/common/reference.h"
-#include "flang/parser/message.h"
-#include "flang/parser/provenance.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/reference.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/provenance.h"
 #include <list>
 #include <map>
 #include <optional>
diff --git a/include/flang/semantics/semantics.h b/include/flang/Semantics/semantics.h
similarity index 97%
rename from include/flang/semantics/semantics.h
rename to include/flang/Semantics/semantics.h
index 0e64e42f742b..dd384583e549 100644
--- a/include/flang/semantics/semantics.h
+++ b/include/flang/Semantics/semantics.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/semantics.h ---------------------*- C++ -*-===//
+//===-- include/flang/Semantics/semantics.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.
@@ -11,10 +11,10 @@
 
 #include "scope.h"
 #include "symbol.h"
-#include "flang/common/Fortran-features.h"
-#include "flang/evaluate/common.h"
-#include "flang/evaluate/intrinsics.h"
-#include "flang/parser/message.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Parser/message.h"
 #include <iosfwd>
 #include <string>
 #include <vector>
diff --git a/include/flang/semantics/symbol.h b/include/flang/Semantics/symbol.h
similarity index 99%
rename from include/flang/semantics/symbol.h
rename to include/flang/Semantics/symbol.h
index d6ac63f79d25..80f702a98307 100644
--- a/include/flang/semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/symbol.h ------------------------*- C++ -*-===//
+//===-- include/flang/Semantics/symbol.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.
@@ -10,9 +10,9 @@
 #define FORTRAN_SEMANTICS_SYMBOL_H_
 
 #include "type.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/enum-set.h"
-#include "flang/common/reference.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Common/reference.h"
 #include <array>
 #include <list>
 #include <optional>
@@ -702,7 +702,7 @@ template<std::size_t BLOCK_SIZE> class Symbols {
 };
 
 // Define a few member functions here in the header so that they
-// can be used by lib/evaluate without inducing a dependence cycle
+// can be used by lib/Evaluate without inducing a dependence cycle
 // between the two shared libraries.
 
 inline bool ProcEntityDetails::HasExplicitInterface() const {
diff --git a/include/flang/semantics/tools.h b/include/flang/Semantics/tools.h
similarity index 98%
rename from include/flang/semantics/tools.h
rename to include/flang/Semantics/tools.h
index 59e41700c211..69ca0e35dfe9 100644
--- a/include/flang/semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/tools.h -------------------------*- C++ -*-===//
+//===-- include/flang/Semantics/tools.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.
@@ -12,15 +12,15 @@
 // Simple predicates and look-up functions that are best defined
 // canonically for use in semantic checking.
 
-#include "flang/common/Fortran.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/type.h"
-#include "flang/evaluate/variable.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/attr.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/semantics.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Evaluate/variable.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/attr.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/semantics.h"
 #include <functional>
 
 namespace Fortran::semantics {
diff --git a/include/flang/semantics/type.h b/include/flang/Semantics/type.h
similarity index 98%
rename from include/flang/semantics/type.h
rename to include/flang/Semantics/type.h
index bbd5f47f3a0d..935c8dbf7949 100644
--- a/include/flang/semantics/type.h
+++ b/include/flang/Semantics/type.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/type.h --------------------------*- C++ -*-===//
+//===-- include/flang/Semantics/type.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.
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_SEMANTICS_TYPE_H_
 #define FORTRAN_SEMANTICS_TYPE_H_
 
-#include "flang/common/Fortran.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/expression.h"
-#include "flang/parser/char-block.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Parser/char-block.h"
 #include <algorithm>
 #include <iosfwd>
 #include <map>
diff --git a/include/flang/semantics/unparse-with-symbols.h b/include/flang/Semantics/unparse-with-symbols.h
similarity index 87%
rename from include/flang/semantics/unparse-with-symbols.h
rename to include/flang/Semantics/unparse-with-symbols.h
index 8a6760f0094b..6553b7b34de0 100644
--- a/include/flang/semantics/unparse-with-symbols.h
+++ b/include/flang/Semantics/unparse-with-symbols.h
@@ -1,4 +1,4 @@
-//===-- include/flang/semantics/unparse-with-symbols.h ----------*- C++ -*-===//
+//===-- include/flang/Semantics/unparse-with-symbols.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
 #define FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
 
-#include "flang/parser/characters.h"
+#include "flang/Parser/characters.h"
 #include <iosfwd>
 
 namespace Fortran::parser {
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 35c3e139b1bf..fae2eed92fa8 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -6,9 +6,9 @@
 #
 #===------------------------------------------------------------------------===#
 
-add_subdirectory(common)
-add_subdirectory(evaluate)
-add_subdirectory(decimal)
-add_subdirectory(lower)
-add_subdirectory(parser)
-add_subdirectory(semantics)
+add_subdirectory(Common)
+add_subdirectory(Evaluate)
+add_subdirectory(Decimal)
+add_subdirectory(Lower)
+add_subdirectory(Parser)
+add_subdirectory(Semantics)
diff --git a/lib/common/CMakeLists.txt b/lib/Common/CMakeLists.txt
similarity index 88%
rename from lib/common/CMakeLists.txt
rename to lib/Common/CMakeLists.txt
index bfa8bf7953e0..acbe9d125b99 100644
--- a/lib/common/CMakeLists.txt
+++ b/lib/Common/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- lib/common/CMakeLists.txt -------------------------------------------===#
+#===-- lib/Common/CMakeLists.txt -------------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/common/Fortran-features.cpp b/lib/Common/Fortran-features.cpp
similarity index 90%
rename from lib/common/Fortran-features.cpp
rename to lib/Common/Fortran-features.cpp
index 62c3e505ea17..a9e03395cab2 100644
--- a/lib/common/Fortran-features.cpp
+++ b/lib/Common/Fortran-features.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/Fortran-features.cpp -----------------------------------===//
+//===-- lib/Common/Fortran-features.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/common/Fortran-features.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/idioms.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/idioms.h"
 
 namespace Fortran::common {
 
diff --git a/lib/common/Fortran.cpp b/lib/Common/Fortran.cpp
similarity index 93%
rename from lib/common/Fortran.cpp
rename to lib/Common/Fortran.cpp
index 61ff0ee2f6e9..d65a17e6a7b7 100644
--- a/lib/common/Fortran.cpp
+++ b/lib/Common/Fortran.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/Fortran.cpp --------------------------------------------===//
+//===-- lib/Common/Fortran.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/common/Fortran.h"
+#include "flang/Common/Fortran.h"
 
 namespace Fortran::common {
 
diff --git a/lib/common/default-kinds.cpp b/lib/Common/default-kinds.cpp
similarity index 93%
rename from lib/common/default-kinds.cpp
rename to lib/Common/default-kinds.cpp
index 490f4dc1f156..8470cfc6d137 100644
--- a/lib/common/default-kinds.cpp
+++ b/lib/Common/default-kinds.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/default-kinds.cpp --------------------------------------===//
+//===-- lib/Common/default-kinds.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/common/default-kinds.h"
-#include "flang/common/idioms.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Common/idioms.h"
 
 namespace Fortran::common {
 
diff --git a/lib/common/idioms.cpp b/lib/Common/idioms.cpp
similarity index 92%
rename from lib/common/idioms.cpp
rename to lib/Common/idioms.cpp
index d28d76fe83b8..229e1c062d8c 100644
--- a/lib/common/idioms.cpp
+++ b/lib/Common/idioms.cpp
@@ -1,4 +1,4 @@
-//===-- lib/common/idioms.cpp ---------------------------------------------===//
+//===-- lib/Common/idioms.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/common/idioms.h"
+#include "flang/Common/idioms.h"
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
diff --git a/lib/decimal/CMakeLists.txt b/lib/Decimal/CMakeLists.txt
similarity index 88%
rename from lib/decimal/CMakeLists.txt
rename to lib/Decimal/CMakeLists.txt
index 28c9c828ac3a..54542187aea4 100644
--- a/lib/decimal/CMakeLists.txt
+++ b/lib/Decimal/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- lib/decimal/CMakeLists.txt ------------------------------------------===#
+#===-- lib/Decimal/CMakeLists.txt ------------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/decimal/big-radix-floating-point.h b/lib/Decimal/big-radix-floating-point.h
similarity index 96%
rename from lib/decimal/big-radix-floating-point.h
rename to lib/Decimal/big-radix-floating-point.h
index 35f0a2e8c31f..4af217a52b42 100644
--- a/lib/decimal/big-radix-floating-point.h
+++ b/lib/Decimal/big-radix-floating-point.h
@@ -1,4 +1,4 @@
-//===-- lib/decimal/big-radix-floating-point.h ------------------*- C++ -*-===//
+//===-- lib/Decimal/big-radix-floating-point.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.
@@ -21,12 +21,12 @@
 // for conversions between binary and decimal representations; it is not
 // a general-purpose facility.
 
-#include "flang/common/bit-population-count.h"
-#include "flang/common/leading-zero-bit-count.h"
-#include "flang/common/uint128.h"
-#include "flang/common/unsigned-const-division.h"
-#include "flang/decimal/binary-floating-point.h"
-#include "flang/decimal/decimal.h"
+#include "flang/Common/bit-population-count.h"
+#include "flang/Common/leading-zero-bit-count.h"
+#include "flang/Common/uint128.h"
+#include "flang/Common/unsigned-const-division.h"
+#include "flang/Decimal/binary-floating-point.h"
+#include "flang/Decimal/decimal.h"
 #include <cinttypes>
 #include <limits>
 #include <type_traits>
diff --git a/lib/decimal/binary-to-decimal.cpp b/lib/Decimal/binary-to-decimal.cpp
similarity index 99%
rename from lib/decimal/binary-to-decimal.cpp
rename to lib/Decimal/binary-to-decimal.cpp
index f4b644045648..416d85097dda 100644
--- a/lib/decimal/binary-to-decimal.cpp
+++ b/lib/Decimal/binary-to-decimal.cpp
@@ -1,4 +1,4 @@
-//===-- lib/decimal/binary-to-decimal.cpp ---------------------------------===//
+//===-- lib/Decimal/binary-to-decimal.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "big-radix-floating-point.h"
-#include "flang/decimal/decimal.h"
+#include "flang/Decimal/decimal.h"
 
 namespace Fortran::decimal {
 
diff --git a/lib/decimal/decimal-to-binary.cpp b/lib/Decimal/decimal-to-binary.cpp
similarity index 98%
rename from lib/decimal/decimal-to-binary.cpp
rename to lib/Decimal/decimal-to-binary.cpp
index f71ca941e8a7..7deec9f101b2 100644
--- a/lib/decimal/decimal-to-binary.cpp
+++ b/lib/Decimal/decimal-to-binary.cpp
@@ -1,4 +1,4 @@
-//===-- lib/decimal/decimal-to-binary.cpp ---------------------------------===//
+//===-- lib/Decimal/decimal-to-binary.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "big-radix-floating-point.h"
-#include "flang/common/bit-population-count.h"
-#include "flang/common/leading-zero-bit-count.h"
-#include "flang/decimal/binary-floating-point.h"
-#include "flang/decimal/decimal.h"
+#include "flang/Common/bit-population-count.h"
+#include "flang/Common/leading-zero-bit-count.h"
+#include "flang/Decimal/binary-floating-point.h"
+#include "flang/Decimal/decimal.h"
 #include <cinttypes>
 #include <cstring>
 #include <ctype.h>
diff --git a/lib/evaluate/CMakeLists.txt b/lib/Evaluate/CMakeLists.txt
similarity index 95%
rename from lib/evaluate/CMakeLists.txt
rename to lib/Evaluate/CMakeLists.txt
index 8714819c49a8..8da75eddff69 100644
--- a/lib/evaluate/CMakeLists.txt
+++ b/lib/Evaluate/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- lib/evaluate/CMakeLists.txt -----------------------------------------===#
+#===-- lib/Evaluate/CMakeLists.txt -----------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/call.cpp b/lib/Evaluate/call.cpp
similarity index 95%
rename from lib/evaluate/call.cpp
rename to lib/Evaluate/call.cpp
index d1272af63484..52c16f2e3f3b 100644
--- a/lib/evaluate/call.cpp
+++ b/lib/Evaluate/call.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/call.cpp ---------------------------------------------===//
+//===-- lib/Evaluate/call.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/call.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/tools.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Evaluate/call.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Semantics/symbol.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/character.h b/lib/Evaluate/character.h
similarity index 97%
rename from lib/evaluate/character.h
rename to lib/Evaluate/character.h
index be1303eacca8..ef43a2b3afbb 100644
--- a/lib/evaluate/character.h
+++ b/lib/Evaluate/character.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/character.h --------------------------------*- C++ -*-===//
+//===-- lib/Evaluate/character.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_EVALUATE_CHARACTER_H_
 #define FORTRAN_EVALUATE_CHARACTER_H_
 
-#include "flang/evaluate/type.h"
+#include "flang/Evaluate/type.h"
 #include <string>
 
 // Provides implementations of intrinsic functions operating on character
diff --git a/lib/evaluate/characteristics.cpp b/lib/Evaluate/characteristics.cpp
similarity index 98%
rename from lib/evaluate/characteristics.cpp
rename to lib/Evaluate/characteristics.cpp
index 3197c46863fa..dffcf3232936 100644
--- a/lib/evaluate/characteristics.cpp
+++ b/lib/Evaluate/characteristics.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/characteristics.cpp ----------------------------------===//
+//===-- lib/Evaluate/characteristics.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/characteristics.h"
-#include "flang/common/indirection.h"
-#include "flang/evaluate/check-expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/intrinsics.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/type.h"
-#include "flang/parser/message.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Common/indirection.h"
+#include "flang/Evaluate/check-expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/message.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/symbol.h"
 #include <initializer_list>
 #include <ostream>
 
diff --git a/lib/evaluate/check-expression.cpp b/lib/Evaluate/check-expression.cpp
similarity index 98%
rename from lib/evaluate/check-expression.cpp
rename to lib/Evaluate/check-expression.cpp
index b809211dbdb4..fede3aec6e9a 100644
--- a/lib/evaluate/check-expression.cpp
+++ b/lib/Evaluate/check-expression.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/check-expression.cpp ---------------------------------===//
+//===-- lib/Evaluate/check-expression.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/check-expression.h"
-#include "flang/evaluate/traverse.h"
-#include "flang/evaluate/type.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Evaluate/check-expression.h"
+#include "flang/Evaluate/traverse.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/common.cpp b/lib/Evaluate/common.cpp
similarity index 92%
rename from lib/evaluate/common.cpp
rename to lib/Evaluate/common.cpp
index 9c45e668767d..92f7403918ee 100644
--- a/lib/evaluate/common.cpp
+++ b/lib/Evaluate/common.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/common.cpp -------------------------------------------===//
+//===-- lib/Evaluate/common.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/common.h"
-#include "flang/common/idioms.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Common/idioms.h"
 
 using namespace Fortran::parser::literals;
 
diff --git a/lib/evaluate/complex.cpp b/lib/Evaluate/complex.cpp
similarity index 97%
rename from lib/evaluate/complex.cpp
rename to lib/Evaluate/complex.cpp
index a2dca42e4e0b..8f03304b6b05 100644
--- a/lib/evaluate/complex.cpp
+++ b/lib/Evaluate/complex.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/complex.cpp ------------------------------------------===//
+//===-- lib/Evaluate/complex.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/complex.h"
+#include "flang/Evaluate/complex.h"
 
 namespace Fortran::evaluate::value {
 
diff --git a/lib/evaluate/constant.cpp b/lib/Evaluate/constant.cpp
similarity index 97%
rename from lib/evaluate/constant.cpp
rename to lib/Evaluate/constant.cpp
index 65da1378f10f..0d6a780b9879 100644
--- a/lib/evaluate/constant.cpp
+++ b/lib/Evaluate/constant.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/constant.cpp -----------------------------------------===//
+//===-- lib/Evaluate/constant.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/constant.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/shape.h"
-#include "flang/evaluate/type.h"
+#include "flang/Evaluate/constant.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/shape.h"
+#include "flang/Evaluate/type.h"
 #include <string>
 
 namespace Fortran::evaluate {
diff --git a/lib/evaluate/expression.cpp b/lib/Evaluate/expression.cpp
similarity index 96%
rename from lib/evaluate/expression.cpp
rename to lib/Evaluate/expression.cpp
index c80599670f9e..a390c9e4d1b2 100644
--- a/lib/evaluate/expression.cpp
+++ b/lib/Evaluate/expression.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/expression.cpp ---------------------------------------===//
+//===-- lib/Evaluate/expression.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/expression.h"
+#include "flang/Evaluate/expression.h"
 #include "int-power.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/common.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/variable.h"
-#include "flang/parser/message.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/variable.h"
+#include "flang/Parser/message.h"
 #include <string>
 #include <type_traits>
 
diff --git a/lib/evaluate/fold-character.cpp b/lib/Evaluate/fold-character.cpp
similarity index 98%
rename from lib/evaluate/fold-character.cpp
rename to lib/Evaluate/fold-character.cpp
index 0c99b96df71b..7398a1b56d0f 100644
--- a/lib/evaluate/fold-character.cpp
+++ b/lib/Evaluate/fold-character.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-character.cpp -----------------------------------===//
+//===-- lib/Evaluate/fold-character.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-complex.cpp b/lib/Evaluate/fold-complex.cpp
similarity index 98%
rename from lib/evaluate/fold-complex.cpp
rename to lib/Evaluate/fold-complex.cpp
index d4c5f00873a4..f2006daf3b56 100644
--- a/lib/evaluate/fold-complex.cpp
+++ b/lib/Evaluate/fold-complex.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-complex.cpp -------------------------------------===//
+//===-- lib/Evaluate/fold-complex.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-implementation.h b/lib/Evaluate/fold-implementation.h
similarity index 98%
rename from lib/evaluate/fold-implementation.h
rename to lib/Evaluate/fold-implementation.h
index fdb85dfb0a7f..67e541e1204a 100644
--- a/lib/evaluate/fold-implementation.h
+++ b/lib/Evaluate/fold-implementation.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-implementation.h --------------------------------===//
+//===-- lib/Evaluate/fold-implementation.h --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -13,23 +13,23 @@
 #include "host.h"
 #include "int-power.h"
 #include "intrinsics-library-templates.h"
-#include "flang/common/indirection.h"
-#include "flang/common/template.h"
-#include "flang/common/unwrap.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/common.h"
-#include "flang/evaluate/constant.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/formatting.h"
-#include "flang/evaluate/shape.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/traverse.h"
-#include "flang/evaluate/type.h"
-#include "flang/parser/message.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/indirection.h"
+#include "flang/Common/template.h"
+#include "flang/Common/unwrap.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/constant.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/formatting.h"
+#include "flang/Evaluate/shape.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/traverse.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/message.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 #include <algorithm>
 #include <cmath>
 #include <complex>
diff --git a/lib/evaluate/fold-integer.cpp b/lib/Evaluate/fold-integer.cpp
similarity index 99%
rename from lib/evaluate/fold-integer.cpp
rename to lib/Evaluate/fold-integer.cpp
index cda0a39e616f..1e1e06a28681 100644
--- a/lib/evaluate/fold-integer.cpp
+++ b/lib/Evaluate/fold-integer.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-integer.cpp -------------------------------------===//
+//===-- lib/Evaluate/fold-integer.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold-logical.cpp b/lib/Evaluate/fold-logical.cpp
similarity index 98%
rename from lib/evaluate/fold-logical.cpp
rename to lib/Evaluate/fold-logical.cpp
index cf1bb9a1374c..ebffbb20c6f3 100644
--- a/lib/evaluate/fold-logical.cpp
+++ b/lib/Evaluate/fold-logical.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-logical.cpp -------------------------------------===//
+//===-- lib/Evaluate/fold-logical.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "fold-implementation.h"
-#include "flang/evaluate/check-expression.h"
+#include "flang/Evaluate/check-expression.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/fold-real.cpp b/lib/Evaluate/fold-real.cpp
similarity index 99%
rename from lib/evaluate/fold-real.cpp
rename to lib/Evaluate/fold-real.cpp
index b1d3ed33ca44..1a0d1d2cfd45 100644
--- a/lib/evaluate/fold-real.cpp
+++ b/lib/Evaluate/fold-real.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold-real.cpp ----------------------------------------===//
+//===-- lib/Evaluate/fold-real.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/fold.cpp b/lib/Evaluate/fold.cpp
similarity index 98%
rename from lib/evaluate/fold.cpp
rename to lib/Evaluate/fold.cpp
index 4a7263f1ffce..3ec4a2ed213d 100644
--- a/lib/evaluate/fold.cpp
+++ b/lib/Evaluate/fold.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/fold.cpp ---------------------------------------------===//
+//===-- lib/Evaluate/fold.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/fold.h"
+#include "flang/Evaluate/fold.h"
 #include "fold-implementation.h"
 
 namespace Fortran::evaluate {
diff --git a/lib/evaluate/formatting.cpp b/lib/Evaluate/formatting.cpp
similarity index 98%
rename from lib/evaluate/formatting.cpp
rename to lib/Evaluate/formatting.cpp
index 5bc627748675..0b397c92590b 100644
--- a/lib/evaluate/formatting.cpp
+++ b/lib/Evaluate/formatting.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/formatting.cpp ---------------------------------------===//
+//===-- lib/Evaluate/formatting.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/formatting.h"
-#include "flang/evaluate/call.h"
-#include "flang/evaluate/constant.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/characters.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Evaluate/formatting.h"
+#include "flang/Evaluate/call.h"
+#include "flang/Evaluate/constant.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/characters.h"
+#include "flang/Semantics/symbol.h"
 #include <sstream>
 
 namespace Fortran::evaluate {
diff --git a/lib/evaluate/host.cpp b/lib/Evaluate/host.cpp
similarity index 97%
rename from lib/evaluate/host.cpp
rename to lib/Evaluate/host.cpp
index 47685e08b762..c9f48789e218 100644
--- a/lib/evaluate/host.cpp
+++ b/lib/Evaluate/host.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/host.cpp ---------------------------------------------===//
+//===-- lib/Evaluate/host.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,7 +8,7 @@
 
 #include "host.h"
 
-#include "flang/common/idioms.h"
+#include "flang/Common/idioms.h"
 #include <cerrno>
 #include <cfenv>
 
diff --git a/lib/evaluate/host.h b/lib/Evaluate/host.h
similarity index 98%
rename from lib/evaluate/host.h
rename to lib/Evaluate/host.h
index f2d8c1dc37b4..cb7d5806f0cf 100644
--- a/lib/evaluate/host.h
+++ b/lib/Evaluate/host.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/host.h -------------------------------------*- C++ -*-===//
+//===-- lib/Evaluate/host.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.
@@ -17,7 +17,7 @@
 // hardware type maps to Fortran intrinsic type T. Then HostType<T> can be used
 // to safely refer to this hardware type.
 
-#include "flang/evaluate/type.h"
+#include "flang/Evaluate/type.h"
 #include <cfenv>
 #include <complex>
 #include <cstdint>
diff --git a/lib/evaluate/int-power.h b/lib/Evaluate/int-power.h
similarity index 95%
rename from lib/evaluate/int-power.h
rename to lib/Evaluate/int-power.h
index 6a6fe831a7c4..5ab16cd6d209 100644
--- a/lib/evaluate/int-power.h
+++ b/lib/Evaluate/int-power.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/int-power.h --------------------------------*- C++ -*-===//
+//===-- lib/Evaluate/int-power.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.
@@ -11,7 +11,7 @@
 
 // Computes an integer power of a real or complex value.
 
-#include "flang/evaluate/common.h"
+#include "flang/Evaluate/common.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/integer.cpp b/lib/Evaluate/integer.cpp
similarity index 92%
rename from lib/evaluate/integer.cpp
rename to lib/Evaluate/integer.cpp
index 06503e6f42b8..074bee7b9fb8 100644
--- a/lib/evaluate/integer.cpp
+++ b/lib/Evaluate/integer.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/integer.cpp ------------------------------------------===//
+//===-- lib/Evaluate/integer.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/integer.h"
+#include "flang/Evaluate/integer.h"
 
 namespace Fortran::evaluate::value {
 
diff --git a/lib/evaluate/intrinsics-library-templates.h b/lib/Evaluate/intrinsics-library-templates.h
similarity index 97%
rename from lib/evaluate/intrinsics-library-templates.h
rename to lib/Evaluate/intrinsics-library-templates.h
index 65d3de7e05f9..268a50718992 100644
--- a/lib/evaluate/intrinsics-library-templates.h
+++ b/lib/Evaluate/intrinsics-library-templates.h
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/intrinsics-library-templates.h -------------*- C++ -*-===//
+//===-- lib/Evaluate/intrinsics-library-templates.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.
@@ -17,9 +17,9 @@
 // which version should be instantiated in a generic way.
 
 #include "host.h"
-#include "flang/common/template.h"
-#include "flang/evaluate/intrinsics-library.h"
-#include "flang/evaluate/type.h"
+#include "flang/Common/template.h"
+#include "flang/Evaluate/intrinsics-library.h"
+#include "flang/Evaluate/type.h"
 
 #include <tuple>
 #include <type_traits>
diff --git a/lib/evaluate/intrinsics-library.cpp b/lib/Evaluate/intrinsics-library.cpp
similarity index 99%
rename from lib/evaluate/intrinsics-library.cpp
rename to lib/Evaluate/intrinsics-library.cpp
index bfddcb366b8f..9636179d01e4 100644
--- a/lib/evaluate/intrinsics-library.cpp
+++ b/lib/Evaluate/intrinsics-library.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/intrinsics-library.cpp -------------------------------===//
+//===-- lib/Evaluate/intrinsics-library.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/evaluate/intrinsics.cpp b/lib/Evaluate/intrinsics.cpp
similarity index 99%
rename from lib/evaluate/intrinsics.cpp
rename to lib/Evaluate/intrinsics.cpp
index 93b2f864ae41..b5eacb9415ff 100644
--- a/lib/evaluate/intrinsics.cpp
+++ b/lib/Evaluate/intrinsics.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/intrinsics.cpp ---------------------------------------===//
+//===-- lib/Evaluate/intrinsics.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/intrinsics.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/enum-set.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/common.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/shape.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/type.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/shape.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/type.h"
 #include <algorithm>
 #include <map>
 #include <ostream>
diff --git a/lib/evaluate/logical.cpp b/lib/Evaluate/logical.cpp
similarity index 82%
rename from lib/evaluate/logical.cpp
rename to lib/Evaluate/logical.cpp
index 8bd3a3b7524a..c29ed1df33d3 100644
--- a/lib/evaluate/logical.cpp
+++ b/lib/Evaluate/logical.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/logical.cpp ------------------------------------------===//
+//===-- lib/Evaluate/logical.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/logical.h"
+#include "flang/Evaluate/logical.h"
 
 namespace Fortran::evaluate::value {
 
diff --git a/lib/evaluate/real.cpp b/lib/Evaluate/real.cpp
similarity index 98%
rename from lib/evaluate/real.cpp
rename to lib/Evaluate/real.cpp
index 29ad1e0aa5a3..6f9a17c6262e 100644
--- a/lib/evaluate/real.cpp
+++ b/lib/Evaluate/real.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/real.cpp ---------------------------------------------===//
+//===-- lib/Evaluate/real.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/real.h"
+#include "flang/Evaluate/real.h"
 #include "int-power.h"
-#include "flang/common/idioms.h"
-#include "flang/decimal/decimal.h"
-#include "flang/parser/characters.h"
+#include "flang/Common/idioms.h"
+#include "flang/Decimal/decimal.h"
+#include "flang/Parser/characters.h"
 #include <limits>
 
 namespace Fortran::evaluate::value {
diff --git a/lib/evaluate/shape.cpp b/lib/Evaluate/shape.cpp
similarity index 98%
rename from lib/evaluate/shape.cpp
rename to lib/Evaluate/shape.cpp
index ea14c4b244ad..c523f304f84b 100644
--- a/lib/evaluate/shape.cpp
+++ b/lib/Evaluate/shape.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/shape.cpp --------------------------------------------===//
+//===-- lib/Evaluate/shape.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/shape.h"
-#include "flang/common/idioms.h"
-#include "flang/common/template.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/intrinsics.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/type.h"
-#include "flang/parser/message.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Evaluate/shape.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/template.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/message.h"
+#include "flang/Semantics/symbol.h"
 #include <functional>
 
 using namespace std::placeholders;  // _1, _2, &c. for std::bind()
diff --git a/lib/evaluate/static-data.cpp b/lib/Evaluate/static-data.cpp
similarity index 95%
rename from lib/evaluate/static-data.cpp
rename to lib/Evaluate/static-data.cpp
index 668fcb47191f..8de4f3119684 100644
--- a/lib/evaluate/static-data.cpp
+++ b/lib/Evaluate/static-data.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/static-data.cpp --------------------------------------===//
+//===-- lib/Evaluate/static-data.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/static-data.h"
-#include "flang/parser/characters.h"
+#include "flang/Evaluate/static-data.h"
+#include "flang/Parser/characters.h"
 
 namespace Fortran::evaluate {
 
diff --git a/lib/evaluate/tools.cpp b/lib/Evaluate/tools.cpp
similarity index 99%
rename from lib/evaluate/tools.cpp
rename to lib/Evaluate/tools.cpp
index f082c496aee5..cfa675c1bf81 100644
--- a/lib/evaluate/tools.cpp
+++ b/lib/Evaluate/tools.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/tools.cpp --------------------------------------------===//
+//===-- lib/Evaluate/tools.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/tools.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/traverse.h"
-#include "flang/parser/message.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/traverse.h"
+#include "flang/Parser/message.h"
 #include <algorithm>
 #include <variant>
 
diff --git a/lib/evaluate/type.cpp b/lib/Evaluate/type.cpp
similarity index 97%
rename from lib/evaluate/type.cpp
rename to lib/Evaluate/type.cpp
index 11f800349ca6..79f40d0481aa 100644
--- a/lib/evaluate/type.cpp
+++ b/lib/Evaluate/type.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/type.cpp ---------------------------------------------===//
+//===-- lib/Evaluate/type.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/type.h"
-#include "flang/common/idioms.h"
-#include "flang/common/template.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/parser/characters.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
-#include "flang/semantics/type.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/template.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Parser/characters.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
 #include <algorithm>
 #include <optional>
 #include <sstream>
diff --git a/lib/evaluate/variable.cpp b/lib/Evaluate/variable.cpp
similarity index 98%
rename from lib/evaluate/variable.cpp
rename to lib/Evaluate/variable.cpp
index f10b0a6ee2f2..2ed759057820 100644
--- a/lib/evaluate/variable.cpp
+++ b/lib/Evaluate/variable.cpp
@@ -1,4 +1,4 @@
-//===-- lib/evaluate/variable.cpp -----------------------------------------===//
+//===-- lib/Evaluate/variable.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/evaluate/variable.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/message.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Evaluate/variable.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/message.h"
+#include "flang/Semantics/symbol.h"
 #include <ostream>
 #include <type_traits>
 
diff --git a/lib/fir/.clang-format b/lib/Fir/.clang-format
similarity index 100%
rename from lib/fir/.clang-format
rename to lib/Fir/.clang-format
diff --git a/lib/lower/.clang-format b/lib/Lower/.clang-format
similarity index 100%
rename from lib/lower/.clang-format
rename to lib/Lower/.clang-format
diff --git a/lib/lower/CMakeLists.txt b/lib/Lower/CMakeLists.txt
similarity index 100%
rename from lib/lower/CMakeLists.txt
rename to lib/Lower/CMakeLists.txt
diff --git a/lib/lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
similarity index 99%
rename from lib/lower/PFTBuilder.cpp
rename to lib/Lower/PFTBuilder.cpp
index d7998e259f78..5941b570b216 100644
--- a/lib/lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/PFTBuilder.cc -------------------------------------------===//
+//===-- lib/Lower/PFTBuilder.cc -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/PFTBuilder.h"
-#include "flang/parser/dump-parse-tree.h"
-#include "flang/parser/parse-tree-visitor.h"
+#include "flang/Lower/PFTBuilder.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "flang/Parser/parse-tree-visitor.h"
 #include "llvm/ADT/DenseMap.h"
 #include <algorithm>
 #include <cassert>
diff --git a/lib/optimizer/.clang-format b/lib/Optimizer/.clang-format
similarity index 100%
rename from lib/optimizer/.clang-format
rename to lib/Optimizer/.clang-format
diff --git a/lib/parser/CMakeLists.txt b/lib/Parser/CMakeLists.txt
similarity index 93%
rename from lib/parser/CMakeLists.txt
rename to lib/Parser/CMakeLists.txt
index 72ced8cc9e45..5f7ba14b0cc8 100644
--- a/lib/parser/CMakeLists.txt
+++ b/lib/Parser/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- lib/parser/CMakeLists.txt -------------------------------------------===#
+#===-- lib/Parser/CMakeLists.txt -------------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/parser/Fortran-parsers.cpp b/lib/Parser/Fortran-parsers.cpp
similarity index 99%
rename from lib/parser/Fortran-parsers.cpp
rename to lib/Parser/Fortran-parsers.cpp
index d15901a74ea7..1bf5393b9b42 100644
--- a/lib/parser/Fortran-parsers.cpp
+++ b/lib/Parser/Fortran-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/Fortran-parsers.cpp ------------------------------------===//
+//===-- lib/Parser/Fortran-parsers.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -36,8 +36,8 @@
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/user-state.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/user-state.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/basic-parsers.h b/lib/Parser/basic-parsers.h
similarity index 98%
rename from lib/parser/basic-parsers.h
rename to lib/Parser/basic-parsers.h
index 31491a238363..10df4a71bcf9 100644
--- a/lib/parser/basic-parsers.h
+++ b/lib/Parser/basic-parsers.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/basic-parsers.h ------------------------------*- C++ -*-===//
+//===-- lib/Parser/basic-parsers.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.
@@ -22,14 +22,14 @@
 // This header defines the fundamental parser class templates and helper
 // template functions.  See parser-combinators.txt for documentation.
 
-#include "flang/common/Fortran-features.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-state.h"
-#include "flang/parser/provenance.h"
-#include "flang/parser/user-state.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-state.h"
+#include "flang/Parser/provenance.h"
+#include "flang/Parser/user-state.h"
 #include <cstring>
 #include <functional>
 #include <list>
diff --git a/lib/parser/char-block.cpp b/lib/Parser/char-block.cpp
similarity index 81%
rename from lib/parser/char-block.cpp
rename to lib/Parser/char-block.cpp
index a3cb60a9b13f..b68be8a146ef 100644
--- a/lib/parser/char-block.cpp
+++ b/lib/Parser/char-block.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-block.cpp -------------------------------*- C++ -*-===//
+//===-- lib/Parser/char-block.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.
@@ -6,7 +6,7 @@
 //
 //----------------------------------------------------------------------------//
 
-#include "flang/parser/char-block.h"
+#include "flang/Parser/char-block.h"
 #include <ostream>
 
 namespace Fortran::parser {
diff --git a/lib/parser/char-buffer.cpp b/lib/Parser/char-buffer.cpp
similarity index 94%
rename from lib/parser/char-buffer.cpp
rename to lib/Parser/char-buffer.cpp
index 3de83ec87b5a..655dd3173d7f 100644
--- a/lib/parser/char-buffer.cpp
+++ b/lib/Parser/char-buffer.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-buffer.cpp ----------------------------------------===//
+//===-- lib/Parser/char-buffer.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/char-buffer.h"
-#include "flang/common/idioms.h"
+#include "flang/Parser/char-buffer.h"
+#include "flang/Common/idioms.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
diff --git a/lib/parser/char-set.cpp b/lib/Parser/char-set.cpp
similarity index 85%
rename from lib/parser/char-set.cpp
rename to lib/Parser/char-set.cpp
index 1390f5ca35f6..382cc4f430d5 100644
--- a/lib/parser/char-set.cpp
+++ b/lib/Parser/char-set.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/char-set.cpp -------------------------------------------===//
+//===-- lib/Parser/char-set.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/char-set.h"
+#include "flang/Parser/char-set.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/characters.cpp b/lib/Parser/characters.cpp
similarity index 98%
rename from lib/parser/characters.cpp
rename to lib/Parser/characters.cpp
index f4703565a7d4..62df4013332c 100644
--- a/lib/parser/characters.cpp
+++ b/lib/Parser/characters.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/characters.cpp -----------------------------------------===//
+//===-- lib/Parser/characters.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/characters.h"
-#include "flang/common/idioms.h"
+#include "flang/Parser/characters.h"
+#include "flang/Common/idioms.h"
 #include <algorithm>
 #include <cstddef>
 #include <optional>
diff --git a/lib/parser/debug-parser.cpp b/lib/Parser/debug-parser.cpp
similarity index 88%
rename from lib/parser/debug-parser.cpp
rename to lib/Parser/debug-parser.cpp
index 4957ce1dcbd5..b0db22ff143c 100644
--- a/lib/parser/debug-parser.cpp
+++ b/lib/Parser/debug-parser.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/debug-parser.cpp ---------------------------------------===//
+//===-- lib/Parser/debug-parser.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug-parser.h"
-#include "flang/parser/user-state.h"
+#include "flang/Parser/user-state.h"
 #include <ostream>
 #include <string>
 
diff --git a/lib/parser/debug-parser.h b/lib/Parser/debug-parser.h
similarity index 91%
rename from lib/parser/debug-parser.h
rename to lib/Parser/debug-parser.h
index dbb812c9cec7..fb9f208cd2fd 100644
--- a/lib/parser/debug-parser.h
+++ b/lib/Parser/debug-parser.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/debug-parser.h -------------------------------*- C++ -*-===//
+//===-- lib/Parser/debug-parser.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.
@@ -14,7 +14,7 @@
 // flow of the parsers.  Not to be used in production.
 
 #include "basic-parsers.h"
-#include "flang/parser/parse-state.h"
+#include "flang/Parser/parse-state.h"
 #include <cstddef>
 #include <optional>
 
diff --git a/lib/parser/executable-parsers.cpp b/lib/Parser/executable-parsers.cpp
similarity index 99%
rename from lib/parser/executable-parsers.cpp
rename to lib/Parser/executable-parsers.cpp
index 72408f1da2f5..df1e7ba59d44 100644
--- a/lib/parser/executable-parsers.cpp
+++ b/lib/Parser/executable-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/executable-parsers.cpp ---------------------------------===//
+//===-- lib/Parser/executable-parsers.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -15,8 +15,8 @@
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/expr-parsers.cpp b/lib/Parser/expr-parsers.cpp
similarity index 99%
rename from lib/parser/expr-parsers.cpp
rename to lib/Parser/expr-parsers.cpp
index 11e94fc0da2d..79370881759c 100644
--- a/lib/parser/expr-parsers.cpp
+++ b/lib/Parser/expr-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/expr-parsers.cpp ---------------------------------------===//
+//===-- lib/Parser/expr-parsers.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -15,8 +15,8 @@
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/expr-parsers.h b/lib/Parser/expr-parsers.h
similarity index 97%
rename from lib/parser/expr-parsers.h
rename to lib/Parser/expr-parsers.h
index fcaeedad3994..7106352943f9 100644
--- a/lib/parser/expr-parsers.h
+++ b/lib/Parser/expr-parsers.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/expr-parsers.h -------------------------------*- C++ -*-===//
+//===-- lib/Parser/expr-parsers.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.
@@ -12,7 +12,7 @@
 #include "basic-parsers.h"
 #include "token-parsers.h"
 #include "type-parsers.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/instrumented-parser.cpp b/lib/Parser/instrumented-parser.cpp
similarity index 92%
rename from lib/parser/instrumented-parser.cpp
rename to lib/Parser/instrumented-parser.cpp
index fc5e14867032..47ff042b168d 100644
--- a/lib/parser/instrumented-parser.cpp
+++ b/lib/Parser/instrumented-parser.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/instrumented-parser.cpp --------------------------------===//
+//===-- lib/Parser/instrumented-parser.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/instrumented-parser.h"
-#include "flang/parser/message.h"
-#include "flang/parser/provenance.h"
+#include "flang/Parser/instrumented-parser.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/provenance.h"
 #include <map>
 #include <ostream>
 
diff --git a/lib/parser/io-parsers.cpp b/lib/Parser/io-parsers.cpp
similarity index 99%
rename from lib/parser/io-parsers.cpp
rename to lib/Parser/io-parsers.cpp
index a9ccbb75566d..48b383bfd80a 100644
--- a/lib/parser/io-parsers.cpp
+++ b/lib/Parser/io-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/io-parsers.cpp -----------------------------------------===//
+//===-- lib/Parser/io-parsers.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -15,8 +15,8 @@
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/parse-tree.h"
 
 namespace Fortran::parser {
 // R1201 io-unit -> file-unit-number | * | internal-file-variable
diff --git a/lib/parser/message.cpp b/lib/Parser/message.cpp
similarity index 98%
rename from lib/parser/message.cpp
rename to lib/Parser/message.cpp
index 2f5655eb1e48..feb93a76c53e 100644
--- a/lib/parser/message.cpp
+++ b/lib/Parser/message.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/message.cpp --------------------------------------------===//
+//===-- lib/Parser/message.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/message.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/char-set.h"
+#include "flang/Parser/message.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/char-set.h"
 #include <algorithm>
 #include <cstdarg>
 #include <cstddef>
diff --git a/lib/parser/misc-parsers.h b/lib/Parser/misc-parsers.h
similarity index 92%
rename from lib/parser/misc-parsers.h
rename to lib/Parser/misc-parsers.h
index 1a7c641557a5..ca98e691ad82 100644
--- a/lib/parser/misc-parsers.h
+++ b/lib/Parser/misc-parsers.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/misc-parsers.h -------------------------------*- C++ -*-===//
+//===-- lib/Parser/misc-parsers.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.
@@ -15,8 +15,8 @@
 #include "basic-parsers.h"
 #include "token-parsers.h"
 #include "type-parsers.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/openmp-parsers.cpp b/lib/Parser/openmp-parsers.cpp
similarity index 99%
rename from lib/parser/openmp-parsers.cpp
rename to lib/Parser/openmp-parsers.cpp
index fd1b96191b24..407b5125e2b5 100644
--- a/lib/parser/openmp-parsers.cpp
+++ b/lib/Parser/openmp-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/openmp-parsers.cpp -------------------------------------===//
+//===-- lib/Parser/openmp-parsers.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -15,7 +15,7 @@
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/parse-tree.h"
 
 // OpenMP Directives and Clauses
 namespace Fortran::parser {
diff --git a/lib/parser/parse-tree.cpp b/lib/Parser/parse-tree.cpp
similarity index 97%
rename from lib/parser/parse-tree.cpp
rename to lib/Parser/parse-tree.cpp
index c412214b7432..d0722aaa571c 100644
--- a/lib/parser/parse-tree.cpp
+++ b/lib/Parser/parse-tree.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/parse-tree.cpp -----------------------------------------===//
+//===-- lib/Parser/parse-tree.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/parse-tree.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
-#include "flang/parser/user-state.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
+#include "flang/Parser/user-state.h"
 #include <algorithm>
 
 // So "delete Expr;" calls an external destructor for its typedExpr.
diff --git a/lib/parser/parsing.cpp b/lib/Parser/parsing.cpp
similarity index 95%
rename from lib/parser/parsing.cpp
rename to lib/Parser/parsing.cpp
index ab39c2b1f25c..9b77b9f0ada5 100644
--- a/lib/parser/parsing.cpp
+++ b/lib/Parser/parsing.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/parsing.cpp --------------------------------------------===//
+//===-- lib/Parser/parsing.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/parsing.h"
+#include "flang/Parser/parsing.h"
 #include "preprocessor.h"
 #include "prescan.h"
 #include "type-parsers.h"
-#include "flang/parser/message.h"
-#include "flang/parser/provenance.h"
-#include "flang/parser/source.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/provenance.h"
+#include "flang/Parser/source.h"
 #include <sstream>
 
 namespace Fortran::parser {
diff --git a/lib/parser/preprocessor.cpp b/lib/Parser/preprocessor.cpp
similarity index 99%
rename from lib/parser/preprocessor.cpp
rename to lib/Parser/preprocessor.cpp
index cd5cee714af8..f825f561e32b 100644
--- a/lib/parser/preprocessor.cpp
+++ b/lib/Parser/preprocessor.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/preprocessor.cpp ---------------------------------------===//
+//===-- lib/Parser/preprocessor.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,9 +8,9 @@
 
 #include "preprocessor.h"
 #include "prescan.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/message.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/message.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
diff --git a/lib/parser/preprocessor.h b/lib/Parser/preprocessor.h
similarity index 95%
rename from lib/parser/preprocessor.h
rename to lib/Parser/preprocessor.h
index 523c880316c2..9b1b019b8c29 100644
--- a/lib/parser/preprocessor.h
+++ b/lib/Parser/preprocessor.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/preprocessor.h -------------------------------*- C++ -*-===//
+//===-- lib/Parser/preprocessor.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.
@@ -16,8 +16,8 @@
 // extensions for preprocessing will not be necessary.
 
 #include "token-sequence.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/provenance.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/provenance.h"
 #include <cstddef>
 #include <list>
 #include <stack>
diff --git a/lib/parser/prescan.cpp b/lib/Parser/prescan.cpp
similarity index 99%
rename from lib/parser/prescan.cpp
rename to lib/Parser/prescan.cpp
index 679f136305cb..c28fc1535e38 100644
--- a/lib/parser/prescan.cpp
+++ b/lib/Parser/prescan.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/prescan.cpp --------------------------------------------===//
+//===-- lib/Parser/prescan.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,10 +9,10 @@
 #include "prescan.h"
 #include "preprocessor.h"
 #include "token-sequence.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/message.h"
-#include "flang/parser/source.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/source.h"
 #include <cstddef>
 #include <cstring>
 #include <sstream>
diff --git a/lib/parser/prescan.h b/lib/Parser/prescan.h
similarity index 97%
rename from lib/parser/prescan.h
rename to lib/Parser/prescan.h
index 1b13cb7feac5..94098048f23e 100644
--- a/lib/parser/prescan.h
+++ b/lib/Parser/prescan.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/prescan.h ------------------------------------*- C++ -*-===//
+//===-- lib/Parser/prescan.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.
@@ -17,10 +17,10 @@
 // inclusion, and driving the Fortran source preprocessor.
 
 #include "token-sequence.h"
-#include "flang/common/Fortran-features.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/message.h"
-#include "flang/parser/provenance.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/provenance.h"
 #include <bitset>
 #include <optional>
 #include <string>
diff --git a/lib/parser/program-parsers.cpp b/lib/Parser/program-parsers.cpp
similarity index 99%
rename from lib/parser/program-parsers.cpp
rename to lib/Parser/program-parsers.cpp
index f0e4e69498b1..36a9d39d4512 100644
--- a/lib/parser/program-parsers.cpp
+++ b/lib/Parser/program-parsers.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/program-parsers.cpp ------------------------------------===//
+//===-- lib/Parser/program-parsers.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -15,8 +15,8 @@
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/parse-tree.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/provenance.cpp b/lib/Parser/provenance.cpp
similarity index 99%
rename from lib/parser/provenance.cpp
rename to lib/Parser/provenance.cpp
index 391e650e1b30..db61e4e44f2e 100644
--- a/lib/parser/provenance.cpp
+++ b/lib/Parser/provenance.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/provenance.cpp -----------------------------------------===//
+//===-- lib/Parser/provenance.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/provenance.h"
-#include "flang/common/idioms.h"
+#include "flang/Parser/provenance.h"
+#include "flang/Common/idioms.h"
 #include <algorithm>
 #include <utility>
 
diff --git a/lib/parser/source.cpp b/lib/Parser/source.cpp
similarity index 97%
rename from lib/parser/source.cpp
rename to lib/Parser/source.cpp
index e6635e9f10d5..0fbb8e3df1b1 100644
--- a/lib/parser/source.cpp
+++ b/lib/Parser/source.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/source.cpp ---------------------------------------------===//
+//===-- lib/Parser/source.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/source.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/char-buffer.h"
+#include "flang/Parser/source.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/char-buffer.h"
 #include <algorithm>
 #include <cerrno>
 #include <cstddef>
diff --git a/lib/parser/stmt-parser.h b/lib/Parser/stmt-parser.h
similarity index 98%
rename from lib/parser/stmt-parser.h
rename to lib/Parser/stmt-parser.h
index 1a290fdecd0a..ee26e50db119 100644
--- a/lib/parser/stmt-parser.h
+++ b/lib/Parser/stmt-parser.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/stmt-parser.h --------------------------------*- C++ -*-===//
+//===-- lib/Parser/stmt-parser.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.
diff --git a/lib/parser/token-parsers.h b/lib/Parser/token-parsers.h
similarity index 98%
rename from lib/parser/token-parsers.h
rename to lib/Parser/token-parsers.h
index d36d78906954..c34b9785b3fd 100644
--- a/lib/parser/token-parsers.h
+++ b/lib/Parser/token-parsers.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/token-parsers.h ------------------------------*- C++ -*-===//
+//===-- lib/Parser/token-parsers.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.
@@ -14,11 +14,11 @@
 
 #include "basic-parsers.h"
 #include "type-parsers.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/char-set.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/instrumented-parser.h"
-#include "flang/parser/provenance.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/char-set.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/instrumented-parser.h"
+#include "flang/Parser/provenance.h"
 #include <cctype>
 #include <cstddef>
 #include <cstring>
diff --git a/lib/parser/token-sequence.cpp b/lib/Parser/token-sequence.cpp
similarity index 98%
rename from lib/parser/token-sequence.cpp
rename to lib/Parser/token-sequence.cpp
index 3f984e1f3838..23aa450ceb41 100644
--- a/lib/parser/token-sequence.cpp
+++ b/lib/Parser/token-sequence.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/token-sequence.cpp -------------------------------------===//
+//===-- lib/Parser/token-sequence.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "token-sequence.h"
-#include "flang/parser/characters.h"
+#include "flang/Parser/characters.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/token-sequence.h b/lib/Parser/token-sequence.h
similarity index 96%
rename from lib/parser/token-sequence.h
rename to lib/Parser/token-sequence.h
index e4b7dce8b6ad..d0ef0750e2fe 100644
--- a/lib/parser/token-sequence.h
+++ b/lib/Parser/token-sequence.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/token-sequence.h -----------------------------*- C++ -*-===//
+//===-- lib/Parser/token-sequence.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.
@@ -13,8 +13,8 @@
 // and a partitioning thereof into preprocessing tokens, along with their
 // associated provenances.
 
-#include "flang/parser/char-block.h"
-#include "flang/parser/provenance.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/provenance.h"
 #include <cstddef>
 #include <cstring>
 #include <ostream>
diff --git a/lib/parser/tools.cpp b/lib/Parser/tools.cpp
similarity index 96%
rename from lib/parser/tools.cpp
rename to lib/Parser/tools.cpp
index 522bd3afc642..7fb73791b32a 100644
--- a/lib/parser/tools.cpp
+++ b/lib/Parser/tools.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/tools.cpp ----------------------------------------------===//
+//===-- lib/Parser/tools.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/tools.h"
+#include "flang/Parser/tools.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/parser/type-parser-implementation.h b/lib/Parser/type-parser-implementation.h
similarity index 94%
rename from lib/parser/type-parser-implementation.h
rename to lib/Parser/type-parser-implementation.h
index 995c36d95b1b..1bea618f81b0 100644
--- a/lib/parser/type-parser-implementation.h
+++ b/lib/Parser/type-parser-implementation.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/type-parser-implementation.h -----------------*- C++ -*-===//
+//===-- lib/Parser/type-parser-implementation.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.
diff --git a/lib/parser/type-parsers.h b/lib/Parser/type-parsers.h
similarity index 97%
rename from lib/parser/type-parsers.h
rename to lib/Parser/type-parsers.h
index 82273a374274..40e36a8c5a0c 100644
--- a/lib/parser/type-parsers.h
+++ b/lib/Parser/type-parsers.h
@@ -1,4 +1,4 @@
-//===-- lib/parser/type-parsers.h -------------------------------*- C++ -*-===//
+//===-- lib/Parser/type-parsers.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.
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_PARSER_TYPE_PARSERS_H_
 #define FORTRAN_PARSER_TYPE_PARSERS_H_
 
-#include "flang/parser/instrumented-parser.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/instrumented-parser.h"
+#include "flang/Parser/parse-tree.h"
 #include <optional>
 
 namespace Fortran::parser {
diff --git a/lib/parser/unparse.cpp b/lib/Parser/unparse.cpp
similarity index 99%
rename from lib/parser/unparse.cpp
rename to lib/Parser/unparse.cpp
index 82d52960f5f2..45bb54fd58fa 100644
--- a/lib/parser/unparse.cpp
+++ b/lib/Parser/unparse.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/unparse.cpp --------------------------------------------===//
+//===-- lib/Parser/unparse.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,13 +9,13 @@
 // Generates Fortran from the content of a parse tree, using the
 // traversal templates in parse-tree-visitor.h.
 
-#include "flang/parser/unparse.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
+#include "flang/Parser/unparse.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
diff --git a/lib/parser/user-state.cpp b/lib/Parser/user-state.cpp
similarity index 94%
rename from lib/parser/user-state.cpp
rename to lib/Parser/user-state.cpp
index bd84463d9ab0..1140d40214eb 100644
--- a/lib/parser/user-state.cpp
+++ b/lib/Parser/user-state.cpp
@@ -1,4 +1,4 @@
-//===-- lib/parser/user-state.cpp -----------------------------------------===//
+//===-- lib/Parser/user-state.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/user-state.h"
+#include "flang/Parser/user-state.h"
 #include "stmt-parser.h"
 #include "type-parsers.h"
-#include "flang/parser/parse-state.h"
+#include "flang/Parser/parse-state.h"
 #include <optional>
 
 namespace Fortran::parser {
diff --git a/lib/semantics/CMakeLists.txt b/lib/Semantics/CMakeLists.txt
similarity index 94%
rename from lib/semantics/CMakeLists.txt
rename to lib/Semantics/CMakeLists.txt
index 5f2e3c686fc4..7900eeff9da1 100644
--- a/lib/semantics/CMakeLists.txt
+++ b/lib/Semantics/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- lib/semantics/CMakeLists.txt ----------------------------------------===#
+#===-- lib/Semantics/CMakeLists.txt ----------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/assignment.cpp b/lib/Semantics/assignment.cpp
similarity index 95%
rename from lib/semantics/assignment.cpp
rename to lib/Semantics/assignment.cpp
index b286f6578168..dfa11e800804 100644
--- a/lib/semantics/assignment.cpp
+++ b/lib/Semantics/assignment.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/assignment.cpp --------------------------------------===//
+//===-- lib/Semantics/assignment.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,18 +8,18 @@
 
 #include "assignment.h"
 #include "pointer-assignment.h"
-#include "flang/common/idioms.h"
-#include "flang/common/restorer.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/restorer.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 #include <optional>
 #include <set>
 #include <string>
diff --git a/lib/semantics/assignment.h b/lib/Semantics/assignment.h
similarity index 90%
rename from lib/semantics/assignment.h
rename to lib/Semantics/assignment.h
index 51b7c1736635..ad18577ac883 100644
--- a/lib/semantics/assignment.h
+++ b/lib/Semantics/assignment.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/assignment.h ------------------------------*- C++ -*-===//
+//===-- lib/Semantics/assignment.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.
@@ -9,9 +9,9 @@
 #ifndef FORTRAN_SEMANTICS_ASSIGNMENT_H_
 #define FORTRAN_SEMANTICS_ASSIGNMENT_H_
 
-#include "flang/common/indirection.h"
-#include "flang/evaluate/expression.h"
-#include "flang/semantics/semantics.h"
+#include "flang/Common/indirection.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 class ContextualMessages;
diff --git a/lib/semantics/attr.cpp b/lib/Semantics/attr.cpp
similarity index 90%
rename from lib/semantics/attr.cpp
rename to lib/Semantics/attr.cpp
index 65623442a2d6..341fe5e67f89 100644
--- a/lib/semantics/attr.cpp
+++ b/lib/Semantics/attr.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/attr.cpp --------------------------------------------===//
+//===-- lib/Semantics/attr.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/semantics/attr.h"
-#include "flang/common/idioms.h"
+#include "flang/Semantics/attr.h"
+#include "flang/Common/idioms.h"
 #include <ostream>
 #include <stddef.h>
 
diff --git a/lib/semantics/canonicalize-do.cpp b/lib/Semantics/canonicalize-do.cpp
similarity index 98%
rename from lib/semantics/canonicalize-do.cpp
rename to lib/Semantics/canonicalize-do.cpp
index 45353c97c1f8..b50c0ff974af 100644
--- a/lib/semantics/canonicalize-do.cpp
+++ b/lib/Semantics/canonicalize-do.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/canonicalize-do.cpp ---------------------------------===//
+//===-- lib/Semantics/canonicalize-do.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "canonicalize-do.h"
-#include "flang/parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree-visitor.h"
 
 namespace Fortran::parser {
 
diff --git a/lib/semantics/canonicalize-do.h b/lib/Semantics/canonicalize-do.h
similarity index 91%
rename from lib/semantics/canonicalize-do.h
rename to lib/Semantics/canonicalize-do.h
index 4b7c18a5a789..9de5b52c5ed8 100644
--- a/lib/semantics/canonicalize-do.h
+++ b/lib/Semantics/canonicalize-do.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/canonicalize-do.h -------------------------*- C++ -*-===//
+//===-- lib/Semantics/canonicalize-do.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.
diff --git a/lib/semantics/canonicalize-omp.cpp b/lib/Semantics/canonicalize-omp.cpp
similarity index 97%
rename from lib/semantics/canonicalize-omp.cpp
rename to lib/Semantics/canonicalize-omp.cpp
index 1af2f3be6277..9588b037aef0 100644
--- a/lib/semantics/canonicalize-omp.cpp
+++ b/lib/Semantics/canonicalize-omp.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/canonicalize-omp.cpp --------------------------------===//
+//===-- lib/Semantics/canonicalize-omp.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "canonicalize-omp.h"
-#include "flang/parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree-visitor.h"
 
 // After Loop Canonicalization, rewrite OpenMP parse tree to make OpenMP
 // Constructs more structured which provide explicit scopes for later
diff --git a/lib/semantics/canonicalize-omp.h b/lib/Semantics/canonicalize-omp.h
similarity index 90%
rename from lib/semantics/canonicalize-omp.h
rename to lib/Semantics/canonicalize-omp.h
index f1f2cfeb9101..6531851a6675 100644
--- a/lib/semantics/canonicalize-omp.h
+++ b/lib/Semantics/canonicalize-omp.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/canonicalize-omp.h ------------------------*- C++ -*-===//
+//===-- lib/Semantics/canonicalize-omp.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.
diff --git a/lib/semantics/check-allocate.cpp b/lib/Semantics/check-allocate.cpp
similarity index 98%
rename from lib/semantics/check-allocate.cpp
rename to lib/Semantics/check-allocate.cpp
index 32ceb3805729..fdba6151d343 100644
--- a/lib/semantics/check-allocate.cpp
+++ b/lib/Semantics/check-allocate.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-allocate.cpp ----------------------------------===//
+//===-- lib/Semantics/check-allocate.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,14 +8,14 @@
 
 #include "check-allocate.h"
 #include "assignment.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/type.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/attr.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/tools.h"
-#include "flang/semantics/type.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/attr.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-allocate.h b/lib/Semantics/check-allocate.h
similarity index 87%
rename from lib/semantics/check-allocate.h
rename to lib/Semantics/check-allocate.h
index 2d495b13746c..2d7405d3e21d 100644
--- a/lib/semantics/check-allocate.h
+++ b/lib/Semantics/check-allocate.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-allocate.h --------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-allocate.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
 #define FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct AllocateStmt;
diff --git a/lib/semantics/check-arithmeticif.cpp b/lib/Semantics/check-arithmeticif.cpp
similarity index 90%
rename from lib/semantics/check-arithmeticif.cpp
rename to lib/Semantics/check-arithmeticif.cpp
index d0b08a3e062a..efa711319333 100644
--- a/lib/semantics/check-arithmeticif.cpp
+++ b/lib/Semantics/check-arithmeticif.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-arithmeticif.cpp ------------------------------===//
+//===-- lib/Semantics/check-arithmeticif.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-arithmeticif.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/tools.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-arithmeticif.h b/lib/Semantics/check-arithmeticif.h
similarity index 88%
rename from lib/semantics/check-arithmeticif.h
rename to lib/Semantics/check-arithmeticif.h
index 32e2b354cf22..f1b50e10d7d4 100644
--- a/lib/semantics/check-arithmeticif.h
+++ b/lib/Semantics/check-arithmeticif.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-arithmeticif.h ----------------------*- C++ -*-===//
+//===-- lib/Semantics/check-arithmeticif.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
 #define FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct ArithmeticIfStmt;
diff --git a/lib/semantics/check-call.cpp b/lib/Semantics/check-call.cpp
similarity index 98%
rename from lib/semantics/check-call.cpp
rename to lib/Semantics/check-call.cpp
index f03f30e14d5e..bca65e9909b7 100644
--- a/lib/semantics/check-call.cpp
+++ b/lib/Semantics/check-call.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-call.cpp --------------------------------------===//
+//===-- lib/Semantics/check-call.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,14 +8,14 @@
 
 #include "check-call.h"
 #include "pointer-assignment.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/check-expression.h"
-#include "flang/evaluate/shape.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/message.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/tools.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/check-expression.h"
+#include "flang/Evaluate/shape.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/message.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/tools.h"
 #include <map>
 #include <string>
 
diff --git a/lib/semantics/check-call.h b/lib/Semantics/check-call.h
similarity index 94%
rename from lib/semantics/check-call.h
rename to lib/Semantics/check-call.h
index 68c5b53b078a..08bed15cb7ec 100644
--- a/lib/semantics/check-call.h
+++ b/lib/Semantics/check-call.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-call.h ------------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-call.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.
@@ -11,7 +11,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_CALL_H_
 #define FORTRAN_SEMANTICS_CHECK_CALL_H_
 
-#include "flang/evaluate/call.h"
+#include "flang/Evaluate/call.h"
 
 namespace Fortran::parser {
 class Messages;
diff --git a/lib/semantics/check-coarray.cpp b/lib/Semantics/check-coarray.cpp
similarity index 93%
rename from lib/semantics/check-coarray.cpp
rename to lib/Semantics/check-coarray.cpp
index 0e43314de40d..f070ebc61695 100644
--- a/lib/semantics/check-coarray.cpp
+++ b/lib/Semantics/check-coarray.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-coarray.cpp -----------------------------------===//
+//===-- lib/Semantics/check-coarray.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-coarray.h"
-#include "flang/common/indirection.h"
-#include "flang/evaluate/expression.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/indirection.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-coarray.h b/lib/Semantics/check-coarray.h
similarity index 92%
rename from lib/semantics/check-coarray.h
rename to lib/Semantics/check-coarray.h
index fe4176c1d943..dd34f0ae3641 100644
--- a/lib/semantics/check-coarray.h
+++ b/lib/Semantics/check-coarray.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-coarray.h ---------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-coarray.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_COARRAY_H_
 #define FORTRAN_SEMANTICS_CHECK_COARRAY_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 #include <list>
 
 namespace Fortran::parser {
diff --git a/lib/semantics/check-data.cpp b/lib/Semantics/check-data.cpp
similarity index 96%
rename from lib/semantics/check-data.cpp
rename to lib/Semantics/check-data.cpp
index e831bf7e3d53..e7d599eeebe5 100644
--- a/lib/semantics/check-data.cpp
+++ b/lib/Semantics/check-data.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-data.cpp --------------------------------------===//
+//===-- lib/Semantics/check-data.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/semantics/check-data.h b/lib/Semantics/check-data.h
similarity index 77%
rename from lib/semantics/check-data.h
rename to lib/Semantics/check-data.h
index b2e96519a346..80b8edc7f713 100644
--- a/lib/semantics/check-data.h
+++ b/lib/Semantics/check-data.h
@@ -1,4 +1,4 @@
-//===-------lib/semantics/check-data.h ------------------------------------===//
+//===-------lib/Semantics/check-data.h ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_DATA_H_
 #define FORTRAN_SEMANTICS_CHECK_DATA_H_
 
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/tools.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 class DataChecker : public virtual BaseChecker {
diff --git a/lib/semantics/check-deallocate.cpp b/lib/Semantics/check-deallocate.cpp
similarity index 92%
rename from lib/semantics/check-deallocate.cpp
rename to lib/Semantics/check-deallocate.cpp
index 6a0ea45ebb43..646251427db8 100644
--- a/lib/semantics/check-deallocate.cpp
+++ b/lib/Semantics/check-deallocate.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-deallocate.cpp --------------------------------===//
+//===-- lib/Semantics/check-deallocate.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-deallocate.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/tools.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-deallocate.h b/lib/Semantics/check-deallocate.h
similarity index 88%
rename from lib/semantics/check-deallocate.h
rename to lib/Semantics/check-deallocate.h
index 6855055bd65d..f47283a22c29 100644
--- a/lib/semantics/check-deallocate.h
+++ b/lib/Semantics/check-deallocate.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-deallocate.h ------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-deallocate.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
 #define FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct DeallocateStmt;
diff --git a/lib/semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
similarity index 99%
rename from lib/semantics/check-declarations.cpp
rename to lib/Semantics/check-declarations.cpp
index 7c27fcba91d1..4e463319accc 100644
--- a/lib/semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-declarations.cpp ------------------------------===//
+//===-- lib/Semantics/check-declarations.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,14 +9,14 @@
 // Static declaration checking
 
 #include "check-declarations.h"
-#include "flang/evaluate/check-expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
-#include "flang/semantics/type.h"
+#include "flang/Evaluate/check-expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
 #include <algorithm>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-declarations.h b/lib/Semantics/check-declarations.h
similarity index 89%
rename from lib/semantics/check-declarations.h
rename to lib/Semantics/check-declarations.h
index 19d3072d2c5f..98cea3249d4a 100644
--- a/lib/semantics/check-declarations.h
+++ b/lib/Semantics/check-declarations.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-declarations.h ----------------------*- C++ -*-===//
+//===-- lib/Semantics/check-declarations.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.
diff --git a/lib/semantics/check-do-forall.cpp b/lib/Semantics/check-do-forall.cpp
similarity index 98%
rename from lib/semantics/check-do-forall.cpp
rename to lib/Semantics/check-do-forall.cpp
index 071a873d72d2..615e1005e36b 100644
--- a/lib/semantics/check-do-forall.cpp
+++ b/lib/Semantics/check-do-forall.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-do-forall.cpp ---------------------------------===//
+//===-- lib/Semantics/check-do-forall.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,19 +7,19 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-do-forall.h"
-#include "flang/common/template.h"
-#include "flang/evaluate/call.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/attr.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
-#include "flang/semantics/type.h"
+#include "flang/Common/template.h"
+#include "flang/Evaluate/call.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/attr.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
 
 namespace Fortran::evaluate {
 using ActualArgumentRef = common::Reference<const ActualArgument>;
diff --git a/lib/semantics/check-do-forall.h b/lib/Semantics/check-do-forall.h
similarity index 94%
rename from lib/semantics/check-do-forall.h
rename to lib/Semantics/check-do-forall.h
index 1ba9b6b81060..f820926d9199 100644
--- a/lib/semantics/check-do-forall.h
+++ b/lib/Semantics/check-do-forall.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-do-forall.h -------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-do-forall.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.
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_DO_FORALL_H_
 #define FORTRAN_SEMANTICS_CHECK_DO_FORALL_H_
 
-#include "flang/common/idioms.h"
-#include "flang/semantics/semantics.h"
+#include "flang/Common/idioms.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct AssignmentStmt;
diff --git a/lib/semantics/check-if-stmt.cpp b/lib/Semantics/check-if-stmt.cpp
similarity index 82%
rename from lib/semantics/check-if-stmt.cpp
rename to lib/Semantics/check-if-stmt.cpp
index 589caf2abb7e..b9693389f5d9 100644
--- a/lib/semantics/check-if-stmt.cpp
+++ b/lib/Semantics/check-if-stmt.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-if-stmt.cpp -----------------------------------===//
+//===-- lib/Semantics/check-if-stmt.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-if-stmt.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/tools.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-if-stmt.h b/lib/Semantics/check-if-stmt.h
similarity index 87%
rename from lib/semantics/check-if-stmt.h
rename to lib/Semantics/check-if-stmt.h
index 01aac0ec5cf1..21ae269d2049 100644
--- a/lib/semantics/check-if-stmt.h
+++ b/lib/Semantics/check-if-stmt.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-if-stmt.h ---------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-if-stmt.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
 #define FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct IfStmt;
diff --git a/lib/semantics/check-io.cpp b/lib/Semantics/check-io.cpp
similarity index 99%
rename from lib/semantics/check-io.cpp
rename to lib/Semantics/check-io.cpp
index abbf915b675f..a3de44ef8dd0 100644
--- a/lib/semantics/check-io.cpp
+++ b/lib/Semantics/check-io.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-io.cpp ----------------------------------------===//
+//===-- lib/Semantics/check-io.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-io.h"
-#include "flang/common/format.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/format.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/tools.h"
 #include <unordered_map>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-io.h b/lib/Semantics/check-io.h
similarity index 96%
rename from lib/semantics/check-io.h
rename to lib/Semantics/check-io.h
index 96315d5d865e..c43f62b1ae03 100644
--- a/lib/semantics/check-io.h
+++ b/lib/Semantics/check-io.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-io.h --------------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-io.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.
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_IO_H_
 #define FORTRAN_SEMANTICS_CHECK_IO_H_
 
-#include "flang/common/enum-set.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-nullify.cpp b/lib/Semantics/check-nullify.cpp
similarity index 91%
rename from lib/semantics/check-nullify.cpp
rename to lib/Semantics/check-nullify.cpp
index 06a551ffe656..c7595f476d39 100644
--- a/lib/semantics/check-nullify.cpp
+++ b/lib/Semantics/check-nullify.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-nullify.cpp -----------------------------------===//
+//===-- lib/Semantics/check-nullify.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,11 +8,11 @@
 
 #include "check-nullify.h"
 #include "assignment.h"
-#include "flang/evaluate/expression.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/tools.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-nullify.h b/lib/Semantics/check-nullify.h
similarity index 87%
rename from lib/semantics/check-nullify.h
rename to lib/Semantics/check-nullify.h
index f06fc662c8d0..508631a9649b 100644
--- a/lib/semantics/check-nullify.h
+++ b/lib/Semantics/check-nullify.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-nullify.h ---------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-nullify.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
 #define FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct NullifyStmt;
diff --git a/lib/semantics/check-omp-structure.cpp b/lib/Semantics/check-omp-structure.cpp
similarity index 99%
rename from lib/semantics/check-omp-structure.cpp
rename to lib/Semantics/check-omp-structure.cpp
index c8493c05b22c..0e122856985f 100644
--- a/lib/semantics/check-omp-structure.cpp
+++ b/lib/Semantics/check-omp-structure.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-omp-structure.cpp -----------------------------===//
+//===-- lib/Semantics/check-omp-structure.cpp -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,8 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-omp-structure.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/tools.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/tools.h"
 #include <unordered_map>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-omp-structure.h b/lib/Semantics/check-omp-structure.h
similarity index 98%
rename from lib/semantics/check-omp-structure.h
rename to lib/Semantics/check-omp-structure.h
index e265b6bda909..67709e38b5a8 100644
--- a/lib/semantics/check-omp-structure.h
+++ b/lib/Semantics/check-omp-structure.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-omp-structure.h ---------------------*- C++ -*-===//
+//===-- lib/Semantics/check-omp-structure.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.
@@ -14,9 +14,9 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
 #define FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
 
-#include "flang/common/enum-set.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/semantics.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-purity.cpp b/lib/Semantics/check-purity.cpp
similarity index 94%
rename from lib/semantics/check-purity.cpp
rename to lib/Semantics/check-purity.cpp
index 986a22ad0080..9ca56fc04fa1 100644
--- a/lib/semantics/check-purity.cpp
+++ b/lib/Semantics/check-purity.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-purity.cpp ------------------------------------===//
+//===-- lib/Semantics/check-purity.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,8 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-purity.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/tools.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 void PurityChecker::Enter(const parser::ExecutableConstruct &exec) {
diff --git a/lib/semantics/check-purity.h b/lib/Semantics/check-purity.h
similarity index 92%
rename from lib/semantics/check-purity.h
rename to lib/Semantics/check-purity.h
index 189f72ca0396..b4c8272de634 100644
--- a/lib/semantics/check-purity.h
+++ b/lib/Semantics/check-purity.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-purity.h ----------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-purity.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.
@@ -8,7 +8,7 @@
 
 #ifndef FORTRAN_SEMANTICS_CHECK_PURITY_H_
 #define FORTRAN_SEMANTICS_CHECK_PURITY_H_
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 #include <list>
 namespace Fortran::parser {
 struct ExecutableConstruct;
diff --git a/lib/semantics/check-return.cpp b/lib/Semantics/check-return.cpp
similarity index 86%
rename from lib/semantics/check-return.cpp
rename to lib/Semantics/check-return.cpp
index 0fb3b6159aa8..0e0dd2c3e66f 100644
--- a/lib/semantics/check-return.cpp
+++ b/lib/Semantics/check-return.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-return.cpp ------------------------------------===//
+//===-- lib/Semantics/check-return.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-return.h"
-#include "flang/common/Fortran-features.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/check-return.h b/lib/Semantics/check-return.h
similarity index 87%
rename from lib/semantics/check-return.h
rename to lib/Semantics/check-return.h
index b2f4f0655e82..edaf90b4f641 100644
--- a/lib/semantics/check-return.h
+++ b/lib/Semantics/check-return.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-return.h ----------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-return.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_RETURN_H_
 #define FORTRAN_SEMANTICS_CHECK_RETURN_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct ReturnStmt;
diff --git a/lib/semantics/check-stop.cpp b/lib/Semantics/check-stop.cpp
similarity index 84%
rename from lib/semantics/check-stop.cpp
rename to lib/Semantics/check-stop.cpp
index 105f0df27b4d..08487a5c07af 100644
--- a/lib/semantics/check-stop.cpp
+++ b/lib/Semantics/check-stop.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-stop.cpp --------------------------------------===//
+//===-- lib/Semantics/check-stop.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "check-stop.h"
-#include "flang/common/Fortran.h"
-#include "flang/evaluate/expression.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
 #include <optional>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/check-stop.h b/lib/Semantics/check-stop.h
similarity index 88%
rename from lib/semantics/check-stop.h
rename to lib/Semantics/check-stop.h
index 3daf7da12110..ed50830edc4a 100644
--- a/lib/semantics/check-stop.h
+++ b/lib/Semantics/check-stop.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/check-stop.h ------------------------------*- C++ -*-===//
+//===-- lib/Semantics/check-stop.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_CHECK_STOP_H_
 #define FORTRAN_SEMANTICS_CHECK_STOP_H_
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 
 namespace Fortran::parser {
 struct StopStmt;
diff --git a/lib/semantics/expression.cpp b/lib/Semantics/expression.cpp
similarity index 99%
rename from lib/semantics/expression.cpp
rename to lib/Semantics/expression.cpp
index 65e9f7ecdeb3..a41e754d5ade 100644
--- a/lib/semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/expression.cpp --------------------------------------===//
+//===-- lib/Semantics/expression.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,21 +6,21 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/semantics/expression.h"
+#include "flang/Semantics/expression.h"
 #include "check-call.h"
 #include "pointer-assignment.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/common.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/dump-parse-tree.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 #include <algorithm>
 #include <functional>
 #include <optional>
@@ -32,7 +32,7 @@ using MaybeExpr =
     std::optional<Fortran::evaluate::Expr<Fortran::evaluate::SomeType>>;
 
 // Much of the code that implements semantic analysis of expressions is
-// tightly coupled with their typed representations in lib/evaluate,
+// tightly coupled with their typed representations in lib/Evaluate,
 // and appears here in namespace Fortran::evaluate for convenience.
 namespace Fortran::evaluate {
 
diff --git a/lib/semantics/mod-file.cpp b/lib/Semantics/mod-file.cpp
similarity index 99%
rename from lib/semantics/mod-file.cpp
rename to lib/Semantics/mod-file.cpp
index 1f89c56e9870..53f72b4a99a0 100644
--- a/lib/semantics/mod-file.cpp
+++ b/lib/Semantics/mod-file.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/mod-file.cpp ----------------------------------------===//
+//===-- lib/Semantics/mod-file.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,13 +8,13 @@
 
 #include "mod-file.h"
 #include "resolve-names.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parsing.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parsing.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 #include <algorithm>
 #include <cerrno>
 #include <fstream>
diff --git a/lib/semantics/mod-file.h b/lib/Semantics/mod-file.h
similarity index 95%
rename from lib/semantics/mod-file.h
rename to lib/Semantics/mod-file.h
index ba6bae0d014d..1bc356ad1bc1 100644
--- a/lib/semantics/mod-file.h
+++ b/lib/Semantics/mod-file.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/mod-file.h --------------------------------*- C++ -*-===//
+//===-- lib/Semantics/mod-file.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.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_SEMANTICS_MOD_FILE_H_
 #define FORTRAN_SEMANTICS_MOD_FILE_H_
 
-#include "flang/semantics/attr.h"
+#include "flang/Semantics/attr.h"
 #include <sstream>
 #include <string>
 
diff --git a/lib/semantics/pointer-assignment.cpp b/lib/Semantics/pointer-assignment.cpp
similarity index 97%
rename from lib/semantics/pointer-assignment.cpp
rename to lib/Semantics/pointer-assignment.cpp
index d3b3ec7f76ad..b59dc8169aff 100644
--- a/lib/semantics/pointer-assignment.cpp
+++ b/lib/Semantics/pointer-assignment.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/pointer-assignment.cpp ------------------------------===//
+//===-- lib/Semantics/pointer-assignment.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,18 +7,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "pointer-assignment.h"
-#include "flang/common/idioms.h"
-#include "flang/common/restorer.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/restorer.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 #include <optional>
 #include <set>
 #include <string>
diff --git a/lib/semantics/pointer-assignment.h b/lib/Semantics/pointer-assignment.h
similarity index 85%
rename from lib/semantics/pointer-assignment.h
rename to lib/Semantics/pointer-assignment.h
index a9efc59994ac..31131a356e4a 100644
--- a/lib/semantics/pointer-assignment.h
+++ b/lib/Semantics/pointer-assignment.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/pointer-assignment.h --------------------------------===//
+//===-- lib/Semantics/pointer-assignment.h --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,9 +9,9 @@
 #ifndef FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
 #define FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
 
-#include "flang/evaluate/expression.h"
-#include "flang/parser/char-block.h"
-#include "flang/semantics/type.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Semantics/type.h"
 #include <string>
 
 namespace Fortran::evaluate::characteristics {
diff --git a/lib/semantics/program-tree.cpp b/lib/Semantics/program-tree.cpp
similarity index 97%
rename from lib/semantics/program-tree.cpp
rename to lib/Semantics/program-tree.cpp
index 74381e18cf42..9325079655d2 100644
--- a/lib/semantics/program-tree.cpp
+++ b/lib/Semantics/program-tree.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/program-tree.cpp ------------------------------------===//
+//===-- lib/Semantics/program-tree.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "program-tree.h"
-#include "flang/common/idioms.h"
-#include "flang/parser/char-block.h"
-#include "flang/semantics/scope.h"
+#include "flang/Common/idioms.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Semantics/scope.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/program-tree.h b/lib/Semantics/program-tree.h
similarity index 96%
rename from lib/semantics/program-tree.h
rename to lib/Semantics/program-tree.h
index 88a274999361..84e33ba7738d 100644
--- a/lib/semantics/program-tree.h
+++ b/lib/Semantics/program-tree.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/program-tree.h ----------------------------*- C++ -*-===//
+//===-- lib/Semantics/program-tree.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.
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_SEMANTICS_PROGRAM_TREE_H_
 #define FORTRAN_SEMANTICS_PROGRAM_TREE_H_
 
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/symbol.h"
 #include <variant>
 
 // A ProgramTree represents a tree of program units and their contained
diff --git a/lib/semantics/resolve-labels.cpp b/lib/Semantics/resolve-labels.cpp
similarity index 99%
rename from lib/semantics/resolve-labels.cpp
rename to lib/Semantics/resolve-labels.cpp
index 723762706a85..d17352b9a440 100644
--- a/lib/semantics/resolve-labels.cpp
+++ b/lib/Semantics/resolve-labels.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-labels.cpp ----------------------------------===//
+//===-- lib/Semantics/resolve-labels.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "resolve-labels.h"
-#include "flang/common/enum-set.h"
-#include "flang/common/template.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/semantics/semantics.h"
+#include "flang/Common/enum-set.h"
+#include "flang/Common/template.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Semantics/semantics.h"
 #include <cctype>
 #include <cstdarg>
 #include <type_traits>
diff --git a/lib/semantics/resolve-labels.h b/lib/Semantics/resolve-labels.h
similarity index 92%
rename from lib/semantics/resolve-labels.h
rename to lib/Semantics/resolve-labels.h
index 9cb8a9a51a8c..6538a00cf18d 100644
--- a/lib/semantics/resolve-labels.h
+++ b/lib/Semantics/resolve-labels.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-labels.h --------------------------*- C++ -*-===//
+//===-- lib/Semantics/resolve-labels.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.
diff --git a/lib/semantics/resolve-names-utils.cpp b/lib/Semantics/resolve-names-utils.cpp
similarity index 98%
rename from lib/semantics/resolve-names-utils.cpp
rename to lib/Semantics/resolve-names-utils.cpp
index 3b1a0b6cd824..afc0aac5a315 100644
--- a/lib/semantics/resolve-names-utils.cpp
+++ b/lib/Semantics/resolve-names-utils.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-names-utils.cpp -----------------------------===//
+//===-- lib/Semantics/resolve-names-utils.cpp -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,17 +7,17 @@
 //===----------------------------------------------------------------------===//
 
 #include "resolve-names-utils.h"
-#include "flang/common/Fortran-features.h"
-#include "flang/common/idioms.h"
-#include "flang/common/indirection.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/type.h"
-#include "flang/parser/char-block.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/indirection.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/char-block.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
 #include <initializer_list>
 #include <ostream>
 #include <variant>
diff --git a/lib/semantics/resolve-names-utils.h b/lib/Semantics/resolve-names-utils.h
similarity index 95%
rename from lib/semantics/resolve-names-utils.h
rename to lib/Semantics/resolve-names-utils.h
index b0748c263016..055e47db1253 100644
--- a/lib/semantics/resolve-names-utils.h
+++ b/lib/Semantics/resolve-names-utils.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-names-utils.h ---------------------*- C++ -*-===//
+//===-- lib/Semantics/resolve-names-utils.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.
@@ -11,10 +11,10 @@
 
 // Utility functions and class for use in resolve-names.cpp.
 
-#include "flang/parser/message.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/type.h"
+#include "flang/Parser/message.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/type.h"
 #include <forward_list>
 
 namespace Fortran::parser {
diff --git a/lib/semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
similarity index 99%
rename from lib/semantics/resolve-names.cpp
rename to lib/Semantics/resolve-names.cpp
index 3c322b694014..6b9402e7ae8b 100644
--- a/lib/semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-names.cpp -----------------------------------===//
+//===-- lib/Semantics/resolve-names.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -13,26 +13,26 @@
 #include "program-tree.h"
 #include "resolve-names-utils.h"
 #include "rewrite-parse-tree.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/default-kinds.h"
-#include "flang/common/indirection.h"
-#include "flang/common/restorer.h"
-#include "flang/evaluate/characteristics.h"
-#include "flang/evaluate/common.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/intrinsics.h"
-#include "flang/evaluate/tools.h"
-#include "flang/evaluate/type.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/attr.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
-#include "flang/semantics/type.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Common/indirection.h"
+#include "flang/Common/restorer.h"
+#include "flang/Evaluate/characteristics.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/attr.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
 #include <list>
 #include <map>
 #include <ostream>
diff --git a/lib/semantics/resolve-names.h b/lib/Semantics/resolve-names.h
similarity index 91%
rename from lib/semantics/resolve-names.h
rename to lib/Semantics/resolve-names.h
index da4907ebd434..8f233adc5ec3 100644
--- a/lib/semantics/resolve-names.h
+++ b/lib/Semantics/resolve-names.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/resolve-names.h ---------------------------*- C++ -*-===//
+//===-- lib/Semantics/resolve-names.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.
diff --git a/lib/semantics/rewrite-parse-tree.cpp b/lib/Semantics/rewrite-parse-tree.cpp
similarity index 93%
rename from lib/semantics/rewrite-parse-tree.cpp
rename to lib/Semantics/rewrite-parse-tree.cpp
index 37c55376d1a7..761621cf58f0 100644
--- a/lib/semantics/rewrite-parse-tree.cpp
+++ b/lib/Semantics/rewrite-parse-tree.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/rewrite-parse-tree.cpp ------------------------------===//
+//===-- lib/Semantics/rewrite-parse-tree.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,14 +7,14 @@
 //===----------------------------------------------------------------------===//
 
 #include "rewrite-parse-tree.h"
-#include "flang/common/indirection.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Common/indirection.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 #include <list>
 
 namespace Fortran::semantics {
diff --git a/lib/semantics/rewrite-parse-tree.h b/lib/Semantics/rewrite-parse-tree.h
similarity index 91%
rename from lib/semantics/rewrite-parse-tree.h
rename to lib/Semantics/rewrite-parse-tree.h
index e5ef961e8242..7978fd60edda 100644
--- a/lib/semantics/rewrite-parse-tree.h
+++ b/lib/Semantics/rewrite-parse-tree.h
@@ -1,4 +1,4 @@
-//===-- lib/semantics/rewrite-parse-tree.h ----------------------*- C++ -*-===//
+//===-- lib/Semantics/rewrite-parse-tree.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.
diff --git a/lib/semantics/scope.cpp b/lib/Semantics/scope.cpp
similarity index 97%
rename from lib/semantics/scope.cpp
rename to lib/Semantics/scope.cpp
index 9db599560650..16ee107a4612 100644
--- a/lib/semantics/scope.cpp
+++ b/lib/Semantics/scope.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/scope.cpp -------------------------------------------===//
+//===-- lib/Semantics/scope.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/semantics/scope.h"
-#include "flang/parser/characters.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/type.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Parser/characters.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/type.h"
 #include <algorithm>
 #include <memory>
 #include <sstream>
diff --git a/lib/semantics/semantics.cpp b/lib/Semantics/semantics.cpp
similarity index 97%
rename from lib/semantics/semantics.cpp
rename to lib/Semantics/semantics.cpp
index 16d2ebade63b..058bf227a40a 100644
--- a/lib/semantics/semantics.cpp
+++ b/lib/Semantics/semantics.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/semantics.cpp ---------------------------------------===//
+//===-- lib/Semantics/semantics.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/semantics/semantics.h"
+#include "flang/Semantics/semantics.h"
 #include "assignment.h"
 #include "canonicalize-do.h"
 #include "canonicalize-omp.h"
@@ -28,12 +28,12 @@
 #include "resolve-labels.h"
 #include "resolve-names.h"
 #include "rewrite-parse-tree.h"
-#include "flang/common/default-kinds.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/tools.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/tools.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/symbol.h"
 
 namespace Fortran::semantics {
 
diff --git a/lib/semantics/symbol.cpp b/lib/Semantics/symbol.cpp
similarity index 98%
rename from lib/semantics/symbol.cpp
rename to lib/Semantics/symbol.cpp
index d513962b021c..f69748ab9eb9 100644
--- a/lib/semantics/symbol.cpp
+++ b/lib/Semantics/symbol.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/symbol.cpp ------------------------------------------===//
+//===-- lib/Semantics/symbol.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/semantics/symbol.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/expression.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/tools.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
 #include <ostream>
 #include <string>
 
diff --git a/lib/semantics/tools.cpp b/lib/Semantics/tools.cpp
similarity index 98%
rename from lib/semantics/tools.cpp
rename to lib/Semantics/tools.cpp
index 8e31a81a0573..b4a2a281ee7d 100644
--- a/lib/semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/tools.cpp -------------------------------------------===//
+//===-- lib/Semantics/tools.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,17 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/parser/tools.h"
-#include "flang/common/Fortran.h"
-#include "flang/common/indirection.h"
-#include "flang/parser/dump-parse-tree.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
-#include "flang/semantics/type.h"
+#include "flang/Parser/tools.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Common/indirection.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
 #include <algorithm>
 #include <set>
 #include <sstream>
diff --git a/lib/semantics/type.cpp b/lib/Semantics/type.cpp
similarity index 98%
rename from lib/semantics/type.cpp
rename to lib/Semantics/type.cpp
index b216261f8e4a..47158c7af4ab 100644
--- a/lib/semantics/type.cpp
+++ b/lib/Semantics/type.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/type.cpp --------------------------------------------===//
+//===-- lib/Semantics/type.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/semantics/type.h"
-#include "flang/evaluate/fold.h"
-#include "flang/parser/characters.h"
-#include "flang/semantics/scope.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/tools.h"
+#include "flang/Semantics/type.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Parser/characters.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
 #include <ostream>
 #include <sstream>
 
diff --git a/lib/semantics/unparse-with-symbols.cpp b/lib/Semantics/unparse-with-symbols.cpp
similarity index 92%
rename from lib/semantics/unparse-with-symbols.cpp
rename to lib/Semantics/unparse-with-symbols.cpp
index 1af5c2a5638f..b4f89198b347 100644
--- a/lib/semantics/unparse-with-symbols.cpp
+++ b/lib/Semantics/unparse-with-symbols.cpp
@@ -1,4 +1,4 @@
-//===-- lib/semantics/unparse-with-symbols.cpp ----------------------------===//
+//===-- lib/Semantics/unparse-with-symbols.cpp ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/semantics/unparse-with-symbols.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/unparse.h"
-#include "flang/semantics/symbol.h"
+#include "flang/Semantics/unparse-with-symbols.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/unparse.h"
+#include "flang/Semantics/symbol.h"
 #include <map>
 #include <ostream>
 #include <set>
diff --git a/runtime/descriptor.cpp b/runtime/descriptor.cpp
index ca065246d522..9e91c1b80199 100644
--- a/runtime/descriptor.cpp
+++ b/runtime/descriptor.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "descriptor.h"
-#include "flang/common/idioms.h"
+#include "flang/Common/idioms.h"
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
diff --git a/runtime/environment.h b/runtime/environment.h
index 056a13829b2a..93730c180673 100644
--- a/runtime/environment.h
+++ b/runtime/environment.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_RUNTIME_ENVIRONMENT_H_
 #define FORTRAN_RUNTIME_ENVIRONMENT_H_
 
-#include "flang/decimal/decimal.h"
+#include "flang/Decimal/decimal.h"
 
 namespace Fortran::runtime {
 struct ExecutionEnvironment {
diff --git a/runtime/format-implementation.h b/runtime/format-implementation.h
index cb5fc2dfd8b5..e066ba04debc 100644
--- a/runtime/format-implementation.h
+++ b/runtime/format-implementation.h
@@ -14,8 +14,8 @@
 #include "format.h"
 #include "io-stmt.h"
 #include "main.h"
-#include "flang/common/format.h"
-#include "flang/decimal/decimal.h"
+#include "flang/Common/format.h"
+#include "flang/Decimal/decimal.h"
 #include <limits>
 
 namespace Fortran::runtime::io {
diff --git a/runtime/format.h b/runtime/format.h
index c072b3b9805d..a4899f829ea5 100644
--- a/runtime/format.h
+++ b/runtime/format.h
@@ -14,8 +14,8 @@
 #include "environment.h"
 #include "io-error.h"
 #include "terminator.h"
-#include "flang/common/Fortran.h"
-#include "flang/decimal/decimal.h"
+#include "flang/Common/Fortran.h"
+#include "flang/Decimal/decimal.h"
 #include <cinttypes>
 #include <optional>
 
diff --git a/runtime/numeric-output.cpp b/runtime/numeric-output.cpp
index daef7aba879a..c0c617b8c206 100644
--- a/runtime/numeric-output.cpp
+++ b/runtime/numeric-output.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "numeric-output.h"
-#include "flang/common/unsigned-const-division.h"
+#include "flang/Common/unsigned-const-division.h"
 
 namespace Fortran::runtime::io {
 
diff --git a/runtime/numeric-output.h b/runtime/numeric-output.h
index f8c5437ca31b..c3826ffdf563 100644
--- a/runtime/numeric-output.h
+++ b/runtime/numeric-output.h
@@ -20,7 +20,7 @@
 
 #include "format.h"
 #include "io-stmt.h"
-#include "flang/decimal/decimal.h"
+#include "flang/Decimal/decimal.h"
 
 namespace Fortran::runtime::io {
 
diff --git a/runtime/transformational.cpp b/runtime/transformational.cpp
index 42a05e627962..f2abb37c4c43 100644
--- a/runtime/transformational.cpp
+++ b/runtime/transformational.cpp
@@ -7,8 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "transformational.h"
-#include "flang/common/idioms.h"
-#include "flang/evaluate/integer.h"
+#include "flang/Common/idioms.h"
+#include "flang/Evaluate/integer.h"
 #include <algorithm>
 #include <bitset>
 #include <cinttypes>
diff --git a/runtime/type-code.h b/runtime/type-code.h
index b04d45388371..5136bb8d32ff 100644
--- a/runtime/type-code.h
+++ b/runtime/type-code.h
@@ -10,7 +10,7 @@
 #define FORTRAN_RUNTIME_TYPE_CODE_H_
 
 #include "flang/ISO_Fortran_binding.h"
-#include "flang/common/Fortran.h"
+#include "flang/Common/Fortran.h"
 
 namespace Fortran::runtime {
 
diff --git a/test-lit/driver/version_test.f90 b/test-lit/Driver/version_test.f90
similarity index 100%
rename from test-lit/driver/version_test.f90
rename to test-lit/Driver/version_test.f90
diff --git a/test-lit/lower/pre-fir-tree01.f90 b/test-lit/Lower/pre-fir-tree01.f90
similarity index 100%
rename from test-lit/lower/pre-fir-tree01.f90
rename to test-lit/Lower/pre-fir-tree01.f90
diff --git a/test-lit/lower/pre-fir-tree02.f90 b/test-lit/Lower/pre-fir-tree02.f90
similarity index 100%
rename from test-lit/lower/pre-fir-tree02.f90
rename to test-lit/Lower/pre-fir-tree02.f90
diff --git a/test-lit/lower/pre-fir-tree03.f90 b/test-lit/Lower/pre-fir-tree03.f90
similarity index 100%
rename from test-lit/lower/pre-fir-tree03.f90
rename to test-lit/Lower/pre-fir-tree03.f90
diff --git a/test-lit/lower/pre-fir-tree04.f90 b/test-lit/Lower/pre-fir-tree04.f90
similarity index 100%
rename from test-lit/lower/pre-fir-tree04.f90
rename to test-lit/Lower/pre-fir-tree04.f90
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9013757f3cc8..e83f63c8e030 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -6,7 +6,7 @@
 #
 #===------------------------------------------------------------------------===#
 
-add_subdirectory(decimal)
-add_subdirectory(evaluate)
-add_subdirectory(runtime)
-add_subdirectory(semantics)
+add_subdirectory(Decimal)
+add_subdirectory(Evaluate)
+add_subdirectory(Runtime)
+add_subdirectory(Semantics)
diff --git a/test/decimal/CMakeLists.txt b/test/Decimal/CMakeLists.txt
similarity index 89%
rename from test/decimal/CMakeLists.txt
rename to test/Decimal/CMakeLists.txt
index d1210ba1f4ac..46a3d1fd44bf 100644
--- a/test/decimal/CMakeLists.txt
+++ b/test/Decimal/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- test/decimal/CMakeLists.txt -----------------------------------------===#
+#===-- test/Decimal/CMakeLists.txt -----------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/test/decimal/quick-sanity-test.cpp b/test/Decimal/quick-sanity-test.cpp
similarity index 99%
rename from test/decimal/quick-sanity-test.cpp
rename to test/Decimal/quick-sanity-test.cpp
index d9ebf8d3a0dd..47089499d4b5 100644
--- a/test/decimal/quick-sanity-test.cpp
+++ b/test/Decimal/quick-sanity-test.cpp
@@ -1,4 +1,4 @@
-#include "flang/decimal/decimal.h"
+#include "flang/Decimal/decimal.h"
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
diff --git a/test/decimal/thorough-test.cpp b/test/Decimal/thorough-test.cpp
similarity index 98%
rename from test/decimal/thorough-test.cpp
rename to test/Decimal/thorough-test.cpp
index f5e3274d3208..f10467d1300a 100644
--- a/test/decimal/thorough-test.cpp
+++ b/test/Decimal/thorough-test.cpp
@@ -1,4 +1,4 @@
-#include "flang/decimal/decimal.h"
+#include "flang/Decimal/decimal.h"
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
diff --git a/test/evaluate/CMakeLists.txt b/test/Evaluate/CMakeLists.txt
similarity index 96%
rename from test/evaluate/CMakeLists.txt
rename to test/Evaluate/CMakeLists.txt
index 088280f9277b..f1bbc1dfd7c6 100644
--- a/test/evaluate/CMakeLists.txt
+++ b/test/Evaluate/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- test/evaluate/CMakeLists.txt ----------------------------------------===#
+#===-- test/Evaluate/CMakeLists.txt ----------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
@@ -35,7 +35,7 @@ target_link_libraries(uint128-test
   FortranEvaluateTesting
 )
 
-# These routines live in lib/common but we test them here.
+# These routines live in lib/Common but we test them here.
 add_test(UINT128 uint128-test)
 add_test(Leadz leading-zero-bit-count-test)
 add_test(PopPar bit-population-count-test)
diff --git a/test/evaluate/ISO-Fortran-binding.cpp b/test/Evaluate/ISO-Fortran-binding.cpp
similarity index 100%
rename from test/evaluate/ISO-Fortran-binding.cpp
rename to test/Evaluate/ISO-Fortran-binding.cpp
diff --git a/test/evaluate/bit-population-count.cpp b/test/Evaluate/bit-population-count.cpp
similarity index 98%
rename from test/evaluate/bit-population-count.cpp
rename to test/Evaluate/bit-population-count.cpp
index 0b98f644c215..24e721c14f94 100644
--- a/test/evaluate/bit-population-count.cpp
+++ b/test/Evaluate/bit-population-count.cpp
@@ -1,4 +1,4 @@
-#include "flang/common/bit-population-count.h"
+#include "flang/Common/bit-population-count.h"
 #include "testing.h"
 
 using Fortran::common::BitPopulationCount;
diff --git a/test/evaluate/expression.cpp b/test/Evaluate/expression.cpp
similarity index 85%
rename from test/evaluate/expression.cpp
rename to test/Evaluate/expression.cpp
index ced868d5a5e2..47419e410f58 100644
--- a/test/evaluate/expression.cpp
+++ b/test/Evaluate/expression.cpp
@@ -1,9 +1,9 @@
-#include "flang/evaluate/expression.h"
+#include "flang/Evaluate/expression.h"
 #include "testing.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/intrinsics.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/message.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/message.h"
 #include <cstdio>
 #include <cstdlib>
 #include <string>
diff --git a/test/evaluate/folding.cpp b/test/Evaluate/folding.cpp
similarity index 93%
rename from test/evaluate/folding.cpp
rename to test/Evaluate/folding.cpp
index bf68a74e0976..450f87ac2622 100644
--- a/test/evaluate/folding.cpp
+++ b/test/Evaluate/folding.cpp
@@ -1,11 +1,11 @@
 #include "testing.h"
-#include "../../lib/evaluate/host.h"
-#include "../../lib/evaluate/intrinsics-library-templates.h"
-#include "flang/evaluate/call.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/intrinsics.h"
-#include "flang/evaluate/tools.h"
+#include "../../lib/Evaluate/host.h"
+#include "../../lib/Evaluate/intrinsics-library-templates.h"
+#include "flang/Evaluate/call.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/tools.h"
 #include <tuple>
 
 using namespace Fortran::evaluate;
diff --git a/test/evaluate/folding01.f90 b/test/Evaluate/folding01.f90
similarity index 100%
rename from test/evaluate/folding01.f90
rename to test/Evaluate/folding01.f90
diff --git a/test/evaluate/folding02.f90 b/test/Evaluate/folding02.f90
similarity index 100%
rename from test/evaluate/folding02.f90
rename to test/Evaluate/folding02.f90
diff --git a/test/evaluate/folding03.f90 b/test/Evaluate/folding03.f90
similarity index 100%
rename from test/evaluate/folding03.f90
rename to test/Evaluate/folding03.f90
diff --git a/test/evaluate/folding04.f90 b/test/Evaluate/folding04.f90
similarity index 100%
rename from test/evaluate/folding04.f90
rename to test/Evaluate/folding04.f90
diff --git a/test/evaluate/folding05.f90 b/test/Evaluate/folding05.f90
similarity index 100%
rename from test/evaluate/folding05.f90
rename to test/Evaluate/folding05.f90
diff --git a/test/evaluate/folding06.f90 b/test/Evaluate/folding06.f90
similarity index 100%
rename from test/evaluate/folding06.f90
rename to test/Evaluate/folding06.f90
diff --git a/test/evaluate/folding07.f90 b/test/Evaluate/folding07.f90
similarity index 100%
rename from test/evaluate/folding07.f90
rename to test/Evaluate/folding07.f90
diff --git a/test/evaluate/folding08.f90 b/test/Evaluate/folding08.f90
similarity index 100%
rename from test/evaluate/folding08.f90
rename to test/Evaluate/folding08.f90
diff --git a/test/evaluate/folding09.f90 b/test/Evaluate/folding09.f90
similarity index 100%
rename from test/evaluate/folding09.f90
rename to test/Evaluate/folding09.f90
diff --git a/test/evaluate/fp-testing.cpp b/test/Evaluate/fp-testing.cpp
similarity index 100%
rename from test/evaluate/fp-testing.cpp
rename to test/Evaluate/fp-testing.cpp
diff --git a/test/evaluate/fp-testing.h b/test/Evaluate/fp-testing.h
similarity index 94%
rename from test/evaluate/fp-testing.h
rename to test/Evaluate/fp-testing.h
index c86fbbaa2700..9e10561fd9e4 100644
--- a/test/evaluate/fp-testing.h
+++ b/test/Evaluate/fp-testing.h
@@ -1,7 +1,7 @@
 #ifndef FORTRAN_TEST_EVALUATE_FP_TESTING_H_
 #define FORTRAN_TEST_EVALUATE_FP_TESTING_H_
 
-#include "flang/evaluate/common.h"
+#include "flang/Evaluate/common.h"
 #include <fenv.h>
 
 using Fortran::common::RoundingMode;
diff --git a/test/evaluate/integer.cpp b/test/Evaluate/integer.cpp
similarity index 99%
rename from test/evaluate/integer.cpp
rename to test/Evaluate/integer.cpp
index e31f230cb88a..a6111848ab9b 100644
--- a/test/evaluate/integer.cpp
+++ b/test/Evaluate/integer.cpp
@@ -1,4 +1,4 @@
-#include "flang/evaluate/integer.h"
+#include "flang/Evaluate/integer.h"
 #include "testing.h"
 #include <cstdio>
 #include <string>
diff --git a/test/evaluate/intrinsics.cpp b/test/Evaluate/intrinsics.cpp
similarity index 97%
rename from test/evaluate/intrinsics.cpp
rename to test/Evaluate/intrinsics.cpp
index 1826a4691b9d..7a4ca4753b4f 100644
--- a/test/evaluate/intrinsics.cpp
+++ b/test/Evaluate/intrinsics.cpp
@@ -1,9 +1,9 @@
-#include "flang/evaluate/intrinsics.h"
+#include "flang/Evaluate/intrinsics.h"
 #include "testing.h"
-#include "flang/evaluate/common.h"
-#include "flang/evaluate/expression.h"
-#include "flang/evaluate/tools.h"
-#include "flang/parser/provenance.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/tools.h"
+#include "flang/Parser/provenance.h"
 #include <initializer_list>
 #include <iostream>
 #include <map>
diff --git a/test/evaluate/leading-zero-bit-count.cpp b/test/Evaluate/leading-zero-bit-count.cpp
similarity index 95%
rename from test/evaluate/leading-zero-bit-count.cpp
rename to test/Evaluate/leading-zero-bit-count.cpp
index 1abd0f7b6c11..968946b69f27 100644
--- a/test/evaluate/leading-zero-bit-count.cpp
+++ b/test/Evaluate/leading-zero-bit-count.cpp
@@ -1,4 +1,4 @@
-#include "flang/common/leading-zero-bit-count.h"
+#include "flang/Common/leading-zero-bit-count.h"
 #include "testing.h"
 
 using Fortran::common::LeadingZeroBitCount;
diff --git a/test/evaluate/logical.cpp b/test/Evaluate/logical.cpp
similarity index 97%
rename from test/evaluate/logical.cpp
rename to test/Evaluate/logical.cpp
index 3edbd6afd142..f2d171718093 100644
--- a/test/evaluate/logical.cpp
+++ b/test/Evaluate/logical.cpp
@@ -1,5 +1,5 @@
 #include "testing.h"
-#include "flang/evaluate/type.h"
+#include "flang/Evaluate/type.h"
 #include <cstdio>
 
 template<int KIND> void testKind() {
diff --git a/test/evaluate/real.cpp b/test/Evaluate/real.cpp
similarity index 99%
rename from test/evaluate/real.cpp
rename to test/Evaluate/real.cpp
index 85101e513726..732a2de1bec2 100644
--- a/test/evaluate/real.cpp
+++ b/test/Evaluate/real.cpp
@@ -1,6 +1,6 @@
 #include "fp-testing.h"
 #include "testing.h"
-#include "flang/evaluate/type.h"
+#include "flang/Evaluate/type.h"
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
diff --git a/test/evaluate/reshape.cpp b/test/Evaluate/reshape.cpp
similarity index 100%
rename from test/evaluate/reshape.cpp
rename to test/Evaluate/reshape.cpp
diff --git a/test/evaluate/test_folding.sh b/test/Evaluate/test_folding.sh
similarity index 100%
rename from test/evaluate/test_folding.sh
rename to test/Evaluate/test_folding.sh
diff --git a/test/evaluate/testing.cpp b/test/Evaluate/testing.cpp
similarity index 100%
rename from test/evaluate/testing.cpp
rename to test/Evaluate/testing.cpp
diff --git a/test/evaluate/testing.h b/test/Evaluate/testing.h
similarity index 100%
rename from test/evaluate/testing.h
rename to test/Evaluate/testing.h
diff --git a/test/evaluate/uint128.cpp b/test/Evaluate/uint128.cpp
similarity index 99%
rename from test/evaluate/uint128.cpp
rename to test/Evaluate/uint128.cpp
index 6a20d32de92a..07efc31c5a39 100644
--- a/test/evaluate/uint128.cpp
+++ b/test/Evaluate/uint128.cpp
@@ -1,5 +1,5 @@
 #define AVOID_NATIVE_UINT128_T 1
-#include "flang/common/uint128.h"
+#include "flang/Common/uint128.h"
 #include "testing.h"
 #include <cinttypes>
 #include <iostream>
diff --git a/test/preprocessing/pp001.F b/test/Preprocessing/pp001.F
similarity index 100%
rename from test/preprocessing/pp001.F
rename to test/Preprocessing/pp001.F
diff --git a/test/preprocessing/pp002.F b/test/Preprocessing/pp002.F
similarity index 100%
rename from test/preprocessing/pp002.F
rename to test/Preprocessing/pp002.F
diff --git a/test/preprocessing/pp003.F b/test/Preprocessing/pp003.F
similarity index 100%
rename from test/preprocessing/pp003.F
rename to test/Preprocessing/pp003.F
diff --git a/test/preprocessing/pp004.F b/test/Preprocessing/pp004.F
similarity index 100%
rename from test/preprocessing/pp004.F
rename to test/Preprocessing/pp004.F
diff --git a/test/preprocessing/pp005.F b/test/Preprocessing/pp005.F
similarity index 100%
rename from test/preprocessing/pp005.F
rename to test/Preprocessing/pp005.F
diff --git a/test/preprocessing/pp006.F b/test/Preprocessing/pp006.F
similarity index 100%
rename from test/preprocessing/pp006.F
rename to test/Preprocessing/pp006.F
diff --git a/test/preprocessing/pp007.F b/test/Preprocessing/pp007.F
similarity index 100%
rename from test/preprocessing/pp007.F
rename to test/Preprocessing/pp007.F
diff --git a/test/preprocessing/pp008.F b/test/Preprocessing/pp008.F
similarity index 100%
rename from test/preprocessing/pp008.F
rename to test/Preprocessing/pp008.F
diff --git a/test/preprocessing/pp009.F b/test/Preprocessing/pp009.F
similarity index 100%
rename from test/preprocessing/pp009.F
rename to test/Preprocessing/pp009.F
diff --git a/test/preprocessing/pp010.F b/test/Preprocessing/pp010.F
similarity index 100%
rename from test/preprocessing/pp010.F
rename to test/Preprocessing/pp010.F
diff --git a/test/preprocessing/pp011.F b/test/Preprocessing/pp011.F
similarity index 100%
rename from test/preprocessing/pp011.F
rename to test/Preprocessing/pp011.F
diff --git a/test/preprocessing/pp012.F b/test/Preprocessing/pp012.F
similarity index 100%
rename from test/preprocessing/pp012.F
rename to test/Preprocessing/pp012.F
diff --git a/test/preprocessing/pp013.F b/test/Preprocessing/pp013.F
similarity index 100%
rename from test/preprocessing/pp013.F
rename to test/Preprocessing/pp013.F
diff --git a/test/preprocessing/pp014.F b/test/Preprocessing/pp014.F
similarity index 100%
rename from test/preprocessing/pp014.F
rename to test/Preprocessing/pp014.F
diff --git a/test/preprocessing/pp015.F b/test/Preprocessing/pp015.F
similarity index 100%
rename from test/preprocessing/pp015.F
rename to test/Preprocessing/pp015.F
diff --git a/test/preprocessing/pp016.F b/test/Preprocessing/pp016.F
similarity index 100%
rename from test/preprocessing/pp016.F
rename to test/Preprocessing/pp016.F
diff --git a/test/preprocessing/pp017.F b/test/Preprocessing/pp017.F
similarity index 100%
rename from test/preprocessing/pp017.F
rename to test/Preprocessing/pp017.F
diff --git a/test/preprocessing/pp018.F b/test/Preprocessing/pp018.F
similarity index 100%
rename from test/preprocessing/pp018.F
rename to test/Preprocessing/pp018.F
diff --git a/test/preprocessing/pp019.F b/test/Preprocessing/pp019.F
similarity index 100%
rename from test/preprocessing/pp019.F
rename to test/Preprocessing/pp019.F
diff --git a/test/preprocessing/pp020.F b/test/Preprocessing/pp020.F
similarity index 100%
rename from test/preprocessing/pp020.F
rename to test/Preprocessing/pp020.F
diff --git a/test/preprocessing/pp021.F b/test/Preprocessing/pp021.F
similarity index 100%
rename from test/preprocessing/pp021.F
rename to test/Preprocessing/pp021.F
diff --git a/test/preprocessing/pp022.F b/test/Preprocessing/pp022.F
similarity index 100%
rename from test/preprocessing/pp022.F
rename to test/Preprocessing/pp022.F
diff --git a/test/preprocessing/pp023.F b/test/Preprocessing/pp023.F
similarity index 100%
rename from test/preprocessing/pp023.F
rename to test/Preprocessing/pp023.F
diff --git a/test/preprocessing/pp024.F b/test/Preprocessing/pp024.F
similarity index 100%
rename from test/preprocessing/pp024.F
rename to test/Preprocessing/pp024.F
diff --git a/test/preprocessing/pp025.F b/test/Preprocessing/pp025.F
similarity index 100%
rename from test/preprocessing/pp025.F
rename to test/Preprocessing/pp025.F
diff --git a/test/preprocessing/pp026.F b/test/Preprocessing/pp026.F
similarity index 100%
rename from test/preprocessing/pp026.F
rename to test/Preprocessing/pp026.F
diff --git a/test/preprocessing/pp027.F b/test/Preprocessing/pp027.F
similarity index 100%
rename from test/preprocessing/pp027.F
rename to test/Preprocessing/pp027.F
diff --git a/test/preprocessing/pp028.F b/test/Preprocessing/pp028.F
similarity index 100%
rename from test/preprocessing/pp028.F
rename to test/Preprocessing/pp028.F
diff --git a/test/preprocessing/pp029.F b/test/Preprocessing/pp029.F
similarity index 100%
rename from test/preprocessing/pp029.F
rename to test/Preprocessing/pp029.F
diff --git a/test/preprocessing/pp030.F b/test/Preprocessing/pp030.F
similarity index 100%
rename from test/preprocessing/pp030.F
rename to test/Preprocessing/pp030.F
diff --git a/test/preprocessing/pp031.F b/test/Preprocessing/pp031.F
similarity index 100%
rename from test/preprocessing/pp031.F
rename to test/Preprocessing/pp031.F
diff --git a/test/preprocessing/pp032.F b/test/Preprocessing/pp032.F
similarity index 100%
rename from test/preprocessing/pp032.F
rename to test/Preprocessing/pp032.F
diff --git a/test/preprocessing/pp033.F b/test/Preprocessing/pp033.F
similarity index 100%
rename from test/preprocessing/pp033.F
rename to test/Preprocessing/pp033.F
diff --git a/test/preprocessing/pp034.F b/test/Preprocessing/pp034.F
similarity index 100%
rename from test/preprocessing/pp034.F
rename to test/Preprocessing/pp034.F
diff --git a/test/preprocessing/pp035.F b/test/Preprocessing/pp035.F
similarity index 100%
rename from test/preprocessing/pp035.F
rename to test/Preprocessing/pp035.F
diff --git a/test/preprocessing/pp036.F b/test/Preprocessing/pp036.F
similarity index 100%
rename from test/preprocessing/pp036.F
rename to test/Preprocessing/pp036.F
diff --git a/test/preprocessing/pp037.F b/test/Preprocessing/pp037.F
similarity index 100%
rename from test/preprocessing/pp037.F
rename to test/Preprocessing/pp037.F
diff --git a/test/preprocessing/pp038.F b/test/Preprocessing/pp038.F
similarity index 100%
rename from test/preprocessing/pp038.F
rename to test/Preprocessing/pp038.F
diff --git a/test/preprocessing/pp039.F b/test/Preprocessing/pp039.F
similarity index 100%
rename from test/preprocessing/pp039.F
rename to test/Preprocessing/pp039.F
diff --git a/test/preprocessing/pp040.F b/test/Preprocessing/pp040.F
similarity index 100%
rename from test/preprocessing/pp040.F
rename to test/Preprocessing/pp040.F
diff --git a/test/preprocessing/pp041.F b/test/Preprocessing/pp041.F
similarity index 100%
rename from test/preprocessing/pp041.F
rename to test/Preprocessing/pp041.F
diff --git a/test/preprocessing/pp042.F b/test/Preprocessing/pp042.F
similarity index 100%
rename from test/preprocessing/pp042.F
rename to test/Preprocessing/pp042.F
diff --git a/test/preprocessing/pp043.F b/test/Preprocessing/pp043.F
similarity index 100%
rename from test/preprocessing/pp043.F
rename to test/Preprocessing/pp043.F
diff --git a/test/preprocessing/pp044.F b/test/Preprocessing/pp044.F
similarity index 100%
rename from test/preprocessing/pp044.F
rename to test/Preprocessing/pp044.F
diff --git a/test/preprocessing/pp101.F90 b/test/Preprocessing/pp101.F90
similarity index 100%
rename from test/preprocessing/pp101.F90
rename to test/Preprocessing/pp101.F90
diff --git a/test/preprocessing/pp102.F90 b/test/Preprocessing/pp102.F90
similarity index 100%
rename from test/preprocessing/pp102.F90
rename to test/Preprocessing/pp102.F90
diff --git a/test/preprocessing/pp103.F90 b/test/Preprocessing/pp103.F90
similarity index 100%
rename from test/preprocessing/pp103.F90
rename to test/Preprocessing/pp103.F90
diff --git a/test/preprocessing/pp104.F90 b/test/Preprocessing/pp104.F90
similarity index 100%
rename from test/preprocessing/pp104.F90
rename to test/Preprocessing/pp104.F90
diff --git a/test/preprocessing/pp105.F90 b/test/Preprocessing/pp105.F90
similarity index 100%
rename from test/preprocessing/pp105.F90
rename to test/Preprocessing/pp105.F90
diff --git a/test/preprocessing/pp106.F90 b/test/Preprocessing/pp106.F90
similarity index 100%
rename from test/preprocessing/pp106.F90
rename to test/Preprocessing/pp106.F90
diff --git a/test/preprocessing/pp107.F90 b/test/Preprocessing/pp107.F90
similarity index 100%
rename from test/preprocessing/pp107.F90
rename to test/Preprocessing/pp107.F90
diff --git a/test/preprocessing/pp108.F90 b/test/Preprocessing/pp108.F90
similarity index 100%
rename from test/preprocessing/pp108.F90
rename to test/Preprocessing/pp108.F90
diff --git a/test/preprocessing/pp109.F90 b/test/Preprocessing/pp109.F90
similarity index 100%
rename from test/preprocessing/pp109.F90
rename to test/Preprocessing/pp109.F90
diff --git a/test/preprocessing/pp110.F90 b/test/Preprocessing/pp110.F90
similarity index 100%
rename from test/preprocessing/pp110.F90
rename to test/Preprocessing/pp110.F90
diff --git a/test/preprocessing/pp111.F90 b/test/Preprocessing/pp111.F90
similarity index 100%
rename from test/preprocessing/pp111.F90
rename to test/Preprocessing/pp111.F90
diff --git a/test/preprocessing/pp112.F90 b/test/Preprocessing/pp112.F90
similarity index 100%
rename from test/preprocessing/pp112.F90
rename to test/Preprocessing/pp112.F90
diff --git a/test/preprocessing/pp113.F90 b/test/Preprocessing/pp113.F90
similarity index 100%
rename from test/preprocessing/pp113.F90
rename to test/Preprocessing/pp113.F90
diff --git a/test/preprocessing/pp114.F90 b/test/Preprocessing/pp114.F90
similarity index 100%
rename from test/preprocessing/pp114.F90
rename to test/Preprocessing/pp114.F90
diff --git a/test/preprocessing/pp115.F90 b/test/Preprocessing/pp115.F90
similarity index 100%
rename from test/preprocessing/pp115.F90
rename to test/Preprocessing/pp115.F90
diff --git a/test/preprocessing/pp116.F90 b/test/Preprocessing/pp116.F90
similarity index 100%
rename from test/preprocessing/pp116.F90
rename to test/Preprocessing/pp116.F90
diff --git a/test/preprocessing/pp117.F90 b/test/Preprocessing/pp117.F90
similarity index 100%
rename from test/preprocessing/pp117.F90
rename to test/Preprocessing/pp117.F90
diff --git a/test/preprocessing/pp118.F90 b/test/Preprocessing/pp118.F90
similarity index 100%
rename from test/preprocessing/pp118.F90
rename to test/Preprocessing/pp118.F90
diff --git a/test/preprocessing/pp119.F90 b/test/Preprocessing/pp119.F90
similarity index 100%
rename from test/preprocessing/pp119.F90
rename to test/Preprocessing/pp119.F90
diff --git a/test/preprocessing/pp120.F90 b/test/Preprocessing/pp120.F90
similarity index 100%
rename from test/preprocessing/pp120.F90
rename to test/Preprocessing/pp120.F90
diff --git a/test/preprocessing/pp121.F90 b/test/Preprocessing/pp121.F90
similarity index 100%
rename from test/preprocessing/pp121.F90
rename to test/Preprocessing/pp121.F90
diff --git a/test/preprocessing/pp122.F90 b/test/Preprocessing/pp122.F90
similarity index 100%
rename from test/preprocessing/pp122.F90
rename to test/Preprocessing/pp122.F90
diff --git a/test/preprocessing/pp123.F90 b/test/Preprocessing/pp123.F90
similarity index 100%
rename from test/preprocessing/pp123.F90
rename to test/Preprocessing/pp123.F90
diff --git a/test/preprocessing/pp124.F90 b/test/Preprocessing/pp124.F90
similarity index 100%
rename from test/preprocessing/pp124.F90
rename to test/Preprocessing/pp124.F90
diff --git a/test/preprocessing/pp125.F90 b/test/Preprocessing/pp125.F90
similarity index 100%
rename from test/preprocessing/pp125.F90
rename to test/Preprocessing/pp125.F90
diff --git a/test/preprocessing/pp126.F90 b/test/Preprocessing/pp126.F90
similarity index 100%
rename from test/preprocessing/pp126.F90
rename to test/Preprocessing/pp126.F90
diff --git a/test/preprocessing/pp127.F90 b/test/Preprocessing/pp127.F90
similarity index 100%
rename from test/preprocessing/pp127.F90
rename to test/Preprocessing/pp127.F90
diff --git a/test/preprocessing/pp128.F90 b/test/Preprocessing/pp128.F90
similarity index 100%
rename from test/preprocessing/pp128.F90
rename to test/Preprocessing/pp128.F90
diff --git a/test/preprocessing/pp129.F90 b/test/Preprocessing/pp129.F90
similarity index 100%
rename from test/preprocessing/pp129.F90
rename to test/Preprocessing/pp129.F90
diff --git a/test/preprocessing/pp130.F90 b/test/Preprocessing/pp130.F90
similarity index 100%
rename from test/preprocessing/pp130.F90
rename to test/Preprocessing/pp130.F90
diff --git a/test/runtime/CMakeLists.txt b/test/Runtime/CMakeLists.txt
similarity index 92%
rename from test/runtime/CMakeLists.txt
rename to test/Runtime/CMakeLists.txt
index feadddfa880a..239c3f86f52b 100644
--- a/test/runtime/CMakeLists.txt
+++ b/test/Runtime/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- test/runtime/CMakeLists.txt -----------------------------------------===#
+#===-- test/Runtime/CMakeLists.txt -----------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/test/runtime/external-hello.cpp b/test/Runtime/external-hello.cpp
similarity index 100%
rename from test/runtime/external-hello.cpp
rename to test/Runtime/external-hello.cpp
diff --git a/test/runtime/format.cpp b/test/Runtime/format.cpp
similarity index 100%
rename from test/runtime/format.cpp
rename to test/Runtime/format.cpp
diff --git a/test/runtime/hello.cpp b/test/Runtime/hello.cpp
similarity index 100%
rename from test/runtime/hello.cpp
rename to test/Runtime/hello.cpp
diff --git a/test/semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
similarity index 98%
rename from test/semantics/CMakeLists.txt
rename to test/Semantics/CMakeLists.txt
index ff5aa3f0e4de..ac3e9f641c0c 100644
--- a/test/semantics/CMakeLists.txt
+++ b/test/Semantics/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- test/semantics/CMakeLists.txt ---------------------------------------===#
+#===-- test/Semantics/CMakeLists.txt ---------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/test/semantics/allocate01.f90 b/test/Semantics/allocate01.f90
similarity index 100%
rename from test/semantics/allocate01.f90
rename to test/Semantics/allocate01.f90
diff --git a/test/semantics/allocate02.f90 b/test/Semantics/allocate02.f90
similarity index 100%
rename from test/semantics/allocate02.f90
rename to test/Semantics/allocate02.f90
diff --git a/test/semantics/allocate03.f90 b/test/Semantics/allocate03.f90
similarity index 100%
rename from test/semantics/allocate03.f90
rename to test/Semantics/allocate03.f90
diff --git a/test/semantics/allocate04.f90 b/test/Semantics/allocate04.f90
similarity index 100%
rename from test/semantics/allocate04.f90
rename to test/Semantics/allocate04.f90
diff --git a/test/semantics/allocate05.f90 b/test/Semantics/allocate05.f90
similarity index 100%
rename from test/semantics/allocate05.f90
rename to test/Semantics/allocate05.f90
diff --git a/test/semantics/allocate06.f90 b/test/Semantics/allocate06.f90
similarity index 100%
rename from test/semantics/allocate06.f90
rename to test/Semantics/allocate06.f90
diff --git a/test/semantics/allocate07.f90 b/test/Semantics/allocate07.f90
similarity index 100%
rename from test/semantics/allocate07.f90
rename to test/Semantics/allocate07.f90
diff --git a/test/semantics/allocate08.f90 b/test/Semantics/allocate08.f90
similarity index 100%
rename from test/semantics/allocate08.f90
rename to test/Semantics/allocate08.f90
diff --git a/test/semantics/allocate09.f90 b/test/Semantics/allocate09.f90
similarity index 100%
rename from test/semantics/allocate09.f90
rename to test/Semantics/allocate09.f90
diff --git a/test/semantics/allocate10.f90 b/test/Semantics/allocate10.f90
similarity index 100%
rename from test/semantics/allocate10.f90
rename to test/Semantics/allocate10.f90
diff --git a/test/semantics/allocate11.f90 b/test/Semantics/allocate11.f90
similarity index 100%
rename from test/semantics/allocate11.f90
rename to test/Semantics/allocate11.f90
diff --git a/test/semantics/allocate12.f90 b/test/Semantics/allocate12.f90
similarity index 100%
rename from test/semantics/allocate12.f90
rename to test/Semantics/allocate12.f90
diff --git a/test/semantics/allocate13.f90 b/test/Semantics/allocate13.f90
similarity index 100%
rename from test/semantics/allocate13.f90
rename to test/Semantics/allocate13.f90
diff --git a/test/semantics/altreturn01.f90 b/test/Semantics/altreturn01.f90
similarity index 100%
rename from test/semantics/altreturn01.f90
rename to test/Semantics/altreturn01.f90
diff --git a/test/semantics/altreturn02.f90 b/test/Semantics/altreturn02.f90
similarity index 100%
rename from test/semantics/altreturn02.f90
rename to test/Semantics/altreturn02.f90
diff --git a/test/semantics/altreturn03.f90 b/test/Semantics/altreturn03.f90
similarity index 100%
rename from test/semantics/altreturn03.f90
rename to test/Semantics/altreturn03.f90
diff --git a/test/semantics/altreturn04.f90 b/test/Semantics/altreturn04.f90
similarity index 100%
rename from test/semantics/altreturn04.f90
rename to test/Semantics/altreturn04.f90
diff --git a/test/semantics/altreturn05.f90 b/test/Semantics/altreturn05.f90
similarity index 100%
rename from test/semantics/altreturn05.f90
rename to test/Semantics/altreturn05.f90
diff --git a/test/semantics/assign01.f90 b/test/Semantics/assign01.f90
similarity index 100%
rename from test/semantics/assign01.f90
rename to test/Semantics/assign01.f90
diff --git a/test/semantics/assign02.f90 b/test/Semantics/assign02.f90
similarity index 100%
rename from test/semantics/assign02.f90
rename to test/Semantics/assign02.f90
diff --git a/test/semantics/assign03.f90 b/test/Semantics/assign03.f90
similarity index 100%
rename from test/semantics/assign03.f90
rename to test/Semantics/assign03.f90
diff --git a/test/semantics/bad-forward-type.f90 b/test/Semantics/bad-forward-type.f90
similarity index 100%
rename from test/semantics/bad-forward-type.f90
rename to test/Semantics/bad-forward-type.f90
diff --git a/test/semantics/bindings01.f90 b/test/Semantics/bindings01.f90
similarity index 100%
rename from test/semantics/bindings01.f90
rename to test/Semantics/bindings01.f90
diff --git a/test/semantics/block-data01.f90 b/test/Semantics/block-data01.f90
similarity index 100%
rename from test/semantics/block-data01.f90
rename to test/Semantics/block-data01.f90
diff --git a/test/semantics/blockconstruct01.f90 b/test/Semantics/blockconstruct01.f90
similarity index 100%
rename from test/semantics/blockconstruct01.f90
rename to test/Semantics/blockconstruct01.f90
diff --git a/test/semantics/blockconstruct02.f90 b/test/Semantics/blockconstruct02.f90
similarity index 100%
rename from test/semantics/blockconstruct02.f90
rename to test/Semantics/blockconstruct02.f90
diff --git a/test/semantics/blockconstruct03.f90 b/test/Semantics/blockconstruct03.f90
similarity index 100%
rename from test/semantics/blockconstruct03.f90
rename to test/Semantics/blockconstruct03.f90
diff --git a/test/semantics/c_f_pointer.f90 b/test/Semantics/c_f_pointer.f90
similarity index 100%
rename from test/semantics/c_f_pointer.f90
rename to test/Semantics/c_f_pointer.f90
diff --git a/test/semantics/call01.f90 b/test/Semantics/call01.f90
similarity index 100%
rename from test/semantics/call01.f90
rename to test/Semantics/call01.f90
diff --git a/test/semantics/call02.f90 b/test/Semantics/call02.f90
similarity index 100%
rename from test/semantics/call02.f90
rename to test/Semantics/call02.f90
diff --git a/test/semantics/call03.f90 b/test/Semantics/call03.f90
similarity index 100%
rename from test/semantics/call03.f90
rename to test/Semantics/call03.f90
diff --git a/test/semantics/call04.f90 b/test/Semantics/call04.f90
similarity index 100%
rename from test/semantics/call04.f90
rename to test/Semantics/call04.f90
diff --git a/test/semantics/call05.f90 b/test/Semantics/call05.f90
similarity index 100%
rename from test/semantics/call05.f90
rename to test/Semantics/call05.f90
diff --git a/test/semantics/call06.f90 b/test/Semantics/call06.f90
similarity index 100%
rename from test/semantics/call06.f90
rename to test/Semantics/call06.f90
diff --git a/test/semantics/call07.f90 b/test/Semantics/call07.f90
similarity index 100%
rename from test/semantics/call07.f90
rename to test/Semantics/call07.f90
diff --git a/test/semantics/call08.f90 b/test/Semantics/call08.f90
similarity index 100%
rename from test/semantics/call08.f90
rename to test/Semantics/call08.f90
diff --git a/test/semantics/call09.f90 b/test/Semantics/call09.f90
similarity index 100%
rename from test/semantics/call09.f90
rename to test/Semantics/call09.f90
diff --git a/test/semantics/call10.f90 b/test/Semantics/call10.f90
similarity index 100%
rename from test/semantics/call10.f90
rename to test/Semantics/call10.f90
diff --git a/test/semantics/call11.f90 b/test/Semantics/call11.f90
similarity index 100%
rename from test/semantics/call11.f90
rename to test/Semantics/call11.f90
diff --git a/test/semantics/call12.f90 b/test/Semantics/call12.f90
similarity index 100%
rename from test/semantics/call12.f90
rename to test/Semantics/call12.f90
diff --git a/test/semantics/call13.f90 b/test/Semantics/call13.f90
similarity index 100%
rename from test/semantics/call13.f90
rename to test/Semantics/call13.f90
diff --git a/test/semantics/call14.f90 b/test/Semantics/call14.f90
similarity index 100%
rename from test/semantics/call14.f90
rename to test/Semantics/call14.f90
diff --git a/test/semantics/call15.f90 b/test/Semantics/call15.f90
similarity index 100%
rename from test/semantics/call15.f90
rename to test/Semantics/call15.f90
diff --git a/test/semantics/canondo01.f90 b/test/Semantics/canondo01.f90
similarity index 100%
rename from test/semantics/canondo01.f90
rename to test/Semantics/canondo01.f90
diff --git a/test/semantics/canondo02.f90 b/test/Semantics/canondo02.f90
similarity index 100%
rename from test/semantics/canondo02.f90
rename to test/Semantics/canondo02.f90
diff --git a/test/semantics/canondo03.f90 b/test/Semantics/canondo03.f90
similarity index 100%
rename from test/semantics/canondo03.f90
rename to test/Semantics/canondo03.f90
diff --git a/test/semantics/canondo04.f90 b/test/Semantics/canondo04.f90
similarity index 100%
rename from test/semantics/canondo04.f90
rename to test/Semantics/canondo04.f90
diff --git a/test/semantics/canondo05.f90 b/test/Semantics/canondo05.f90
similarity index 100%
rename from test/semantics/canondo05.f90
rename to test/Semantics/canondo05.f90
diff --git a/test/semantics/canondo06.f90 b/test/Semantics/canondo06.f90
similarity index 100%
rename from test/semantics/canondo06.f90
rename to test/Semantics/canondo06.f90
diff --git a/test/semantics/canondo07.f90 b/test/Semantics/canondo07.f90
similarity index 100%
rename from test/semantics/canondo07.f90
rename to test/Semantics/canondo07.f90
diff --git a/test/semantics/canondo08.f90 b/test/Semantics/canondo08.f90
similarity index 100%
rename from test/semantics/canondo08.f90
rename to test/Semantics/canondo08.f90
diff --git a/test/semantics/canondo09.f90 b/test/Semantics/canondo09.f90
similarity index 100%
rename from test/semantics/canondo09.f90
rename to test/Semantics/canondo09.f90
diff --git a/test/semantics/canondo10.f90 b/test/Semantics/canondo10.f90
similarity index 100%
rename from test/semantics/canondo10.f90
rename to test/Semantics/canondo10.f90
diff --git a/test/semantics/canondo11.f90 b/test/Semantics/canondo11.f90
similarity index 100%
rename from test/semantics/canondo11.f90
rename to test/Semantics/canondo11.f90
diff --git a/test/semantics/canondo12.f90 b/test/Semantics/canondo12.f90
similarity index 100%
rename from test/semantics/canondo12.f90
rename to test/Semantics/canondo12.f90
diff --git a/test/semantics/canondo13.f90 b/test/Semantics/canondo13.f90
similarity index 100%
rename from test/semantics/canondo13.f90
rename to test/Semantics/canondo13.f90
diff --git a/test/semantics/canondo14.f90 b/test/Semantics/canondo14.f90
similarity index 100%
rename from test/semantics/canondo14.f90
rename to test/Semantics/canondo14.f90
diff --git a/test/semantics/canondo15.f90 b/test/Semantics/canondo15.f90
similarity index 100%
rename from test/semantics/canondo15.f90
rename to test/Semantics/canondo15.f90
diff --git a/test/semantics/canondo16.f90 b/test/Semantics/canondo16.f90
similarity index 100%
rename from test/semantics/canondo16.f90
rename to test/Semantics/canondo16.f90
diff --git a/test/semantics/canondo17.f90 b/test/Semantics/canondo17.f90
similarity index 100%
rename from test/semantics/canondo17.f90
rename to test/Semantics/canondo17.f90
diff --git a/test/semantics/canondo18.f90 b/test/Semantics/canondo18.f90
similarity index 100%
rename from test/semantics/canondo18.f90
rename to test/Semantics/canondo18.f90
diff --git a/test/semantics/canondo19.f90 b/test/Semantics/canondo19.f90
similarity index 100%
rename from test/semantics/canondo19.f90
rename to test/Semantics/canondo19.f90
diff --git a/test/semantics/coarrays01.f90 b/test/Semantics/coarrays01.f90
similarity index 100%
rename from test/semantics/coarrays01.f90
rename to test/Semantics/coarrays01.f90
diff --git a/test/semantics/common.sh b/test/Semantics/common.sh
similarity index 100%
rename from test/semantics/common.sh
rename to test/Semantics/common.sh
diff --git a/test/semantics/computed-goto01.f90 b/test/Semantics/computed-goto01.f90
similarity index 100%
rename from test/semantics/computed-goto01.f90
rename to test/Semantics/computed-goto01.f90
diff --git a/test/semantics/computed-goto02.f90 b/test/Semantics/computed-goto02.f90
similarity index 100%
rename from test/semantics/computed-goto02.f90
rename to test/Semantics/computed-goto02.f90
diff --git a/test/semantics/critical01.f90 b/test/Semantics/critical01.f90
similarity index 100%
rename from test/semantics/critical01.f90
rename to test/Semantics/critical01.f90
diff --git a/test/semantics/critical02.f90 b/test/Semantics/critical02.f90
similarity index 100%
rename from test/semantics/critical02.f90
rename to test/Semantics/critical02.f90
diff --git a/test/semantics/critical03.f90 b/test/Semantics/critical03.f90
similarity index 100%
rename from test/semantics/critical03.f90
rename to test/Semantics/critical03.f90
diff --git a/test/semantics/critical04.f90 b/test/Semantics/critical04.f90
similarity index 100%
rename from test/semantics/critical04.f90
rename to test/Semantics/critical04.f90
diff --git a/test/semantics/data01.f90 b/test/Semantics/data01.f90
similarity index 100%
rename from test/semantics/data01.f90
rename to test/Semantics/data01.f90
diff --git a/test/semantics/deallocate01.f90 b/test/Semantics/deallocate01.f90
similarity index 100%
rename from test/semantics/deallocate01.f90
rename to test/Semantics/deallocate01.f90
diff --git a/test/semantics/deallocate04.f90 b/test/Semantics/deallocate04.f90
similarity index 100%
rename from test/semantics/deallocate04.f90
rename to test/Semantics/deallocate04.f90
diff --git a/test/semantics/deallocate05.f90 b/test/Semantics/deallocate05.f90
similarity index 100%
rename from test/semantics/deallocate05.f90
rename to test/Semantics/deallocate05.f90
diff --git a/test/semantics/doconcurrent01.f90 b/test/Semantics/doconcurrent01.f90
similarity index 100%
rename from test/semantics/doconcurrent01.f90
rename to test/Semantics/doconcurrent01.f90
diff --git a/test/semantics/doconcurrent02.f90 b/test/Semantics/doconcurrent02.f90
similarity index 100%
rename from test/semantics/doconcurrent02.f90
rename to test/Semantics/doconcurrent02.f90
diff --git a/test/semantics/doconcurrent03.f90 b/test/Semantics/doconcurrent03.f90
similarity index 100%
rename from test/semantics/doconcurrent03.f90
rename to test/Semantics/doconcurrent03.f90
diff --git a/test/semantics/doconcurrent04.f90 b/test/Semantics/doconcurrent04.f90
similarity index 100%
rename from test/semantics/doconcurrent04.f90
rename to test/Semantics/doconcurrent04.f90
diff --git a/test/semantics/doconcurrent05.f90 b/test/Semantics/doconcurrent05.f90
similarity index 100%
rename from test/semantics/doconcurrent05.f90
rename to test/Semantics/doconcurrent05.f90
diff --git a/test/semantics/doconcurrent06.f90 b/test/Semantics/doconcurrent06.f90
similarity index 100%
rename from test/semantics/doconcurrent06.f90
rename to test/Semantics/doconcurrent06.f90
diff --git a/test/semantics/doconcurrent07.f90 b/test/Semantics/doconcurrent07.f90
similarity index 100%
rename from test/semantics/doconcurrent07.f90
rename to test/Semantics/doconcurrent07.f90
diff --git a/test/semantics/doconcurrent08.f90 b/test/Semantics/doconcurrent08.f90
similarity index 99%
rename from test/semantics/doconcurrent08.f90
rename to test/Semantics/doconcurrent08.f90
index b42ab6160a9f..f6773995e202 100644
--- a/test/semantics/doconcurrent08.f90
+++ b/test/Semantics/doconcurrent08.f90
@@ -239,7 +239,7 @@ subroutine s4()
 
     ! OK to invoke a PURE FINAL procedure in a DO CONCURRENT
     ! This case does not work currently because the compiler's test for
-    ! HasImpureFinal() in .../lib/semantics/tools.cc doesn't work correctly
+    ! HasImpureFinal() in .../lib/Semantics/tools.cc doesn't work correctly
 !    do concurrent (i = 1:10)
 !      if (i .eq. 1) deallocate(pfVar)
 !    end do
diff --git a/test/semantics/dosemantics01.f90 b/test/Semantics/dosemantics01.f90
similarity index 100%
rename from test/semantics/dosemantics01.f90
rename to test/Semantics/dosemantics01.f90
diff --git a/test/semantics/dosemantics02.f90 b/test/Semantics/dosemantics02.f90
similarity index 100%
rename from test/semantics/dosemantics02.f90
rename to test/Semantics/dosemantics02.f90
diff --git a/test/semantics/dosemantics03.f90 b/test/Semantics/dosemantics03.f90
similarity index 100%
rename from test/semantics/dosemantics03.f90
rename to test/Semantics/dosemantics03.f90
diff --git a/test/semantics/dosemantics04.f90 b/test/Semantics/dosemantics04.f90
similarity index 100%
rename from test/semantics/dosemantics04.f90
rename to test/Semantics/dosemantics04.f90
diff --git a/test/semantics/dosemantics05.f90 b/test/Semantics/dosemantics05.f90
similarity index 100%
rename from test/semantics/dosemantics05.f90
rename to test/Semantics/dosemantics05.f90
diff --git a/test/semantics/dosemantics06.f90 b/test/Semantics/dosemantics06.f90
similarity index 100%
rename from test/semantics/dosemantics06.f90
rename to test/Semantics/dosemantics06.f90
diff --git a/test/semantics/dosemantics07.f90 b/test/Semantics/dosemantics07.f90
similarity index 100%
rename from test/semantics/dosemantics07.f90
rename to test/Semantics/dosemantics07.f90
diff --git a/test/semantics/dosemantics08.f90 b/test/Semantics/dosemantics08.f90
similarity index 100%
rename from test/semantics/dosemantics08.f90
rename to test/Semantics/dosemantics08.f90
diff --git a/test/semantics/dosemantics09.f90 b/test/Semantics/dosemantics09.f90
similarity index 100%
rename from test/semantics/dosemantics09.f90
rename to test/Semantics/dosemantics09.f90
diff --git a/test/semantics/dosemantics10.f90 b/test/Semantics/dosemantics10.f90
similarity index 100%
rename from test/semantics/dosemantics10.f90
rename to test/Semantics/dosemantics10.f90
diff --git a/test/semantics/dosemantics11.f90 b/test/Semantics/dosemantics11.f90
similarity index 100%
rename from test/semantics/dosemantics11.f90
rename to test/Semantics/dosemantics11.f90
diff --git a/test/semantics/dosemantics12.f90 b/test/Semantics/dosemantics12.f90
similarity index 100%
rename from test/semantics/dosemantics12.f90
rename to test/Semantics/dosemantics12.f90
diff --git a/test/semantics/equivalence01.f90 b/test/Semantics/equivalence01.f90
similarity index 100%
rename from test/semantics/equivalence01.f90
rename to test/Semantics/equivalence01.f90
diff --git a/test/semantics/expr-errors01.f90 b/test/Semantics/expr-errors01.f90
similarity index 100%
rename from test/semantics/expr-errors01.f90
rename to test/Semantics/expr-errors01.f90
diff --git a/test/semantics/expr-errors02.f90 b/test/Semantics/expr-errors02.f90
similarity index 100%
rename from test/semantics/expr-errors02.f90
rename to test/Semantics/expr-errors02.f90
diff --git a/test/semantics/forall01.f90 b/test/Semantics/forall01.f90
similarity index 100%
rename from test/semantics/forall01.f90
rename to test/Semantics/forall01.f90
diff --git a/test/semantics/getdefinition01.f90 b/test/Semantics/getdefinition01.f90
similarity index 100%
rename from test/semantics/getdefinition01.f90
rename to test/Semantics/getdefinition01.f90
diff --git a/test/semantics/getdefinition02.f b/test/Semantics/getdefinition02.f
similarity index 100%
rename from test/semantics/getdefinition02.f
rename to test/Semantics/getdefinition02.f
diff --git a/test/semantics/getdefinition03-a.f90 b/test/Semantics/getdefinition03-a.f90
similarity index 100%
rename from test/semantics/getdefinition03-a.f90
rename to test/Semantics/getdefinition03-a.f90
diff --git a/test/semantics/getdefinition03-b.f90 b/test/Semantics/getdefinition03-b.f90
similarity index 100%
rename from test/semantics/getdefinition03-b.f90
rename to test/Semantics/getdefinition03-b.f90
diff --git a/test/semantics/getdefinition04.f90 b/test/Semantics/getdefinition04.f90
similarity index 100%
rename from test/semantics/getdefinition04.f90
rename to test/Semantics/getdefinition04.f90
diff --git a/test/semantics/getdefinition05.f90 b/test/Semantics/getdefinition05.f90
similarity index 100%
rename from test/semantics/getdefinition05.f90
rename to test/Semantics/getdefinition05.f90
diff --git a/test/semantics/getsymbols01.f90 b/test/Semantics/getsymbols01.f90
similarity index 100%
rename from test/semantics/getsymbols01.f90
rename to test/Semantics/getsymbols01.f90
diff --git a/test/semantics/getsymbols02-a.f90 b/test/Semantics/getsymbols02-a.f90
similarity index 100%
rename from test/semantics/getsymbols02-a.f90
rename to test/Semantics/getsymbols02-a.f90
diff --git a/test/semantics/getsymbols02-b.f90 b/test/Semantics/getsymbols02-b.f90
similarity index 100%
rename from test/semantics/getsymbols02-b.f90
rename to test/Semantics/getsymbols02-b.f90
diff --git a/test/semantics/getsymbols02-c.f90 b/test/Semantics/getsymbols02-c.f90
similarity index 100%
rename from test/semantics/getsymbols02-c.f90
rename to test/Semantics/getsymbols02-c.f90
diff --git a/test/semantics/getsymbols03-a.f90 b/test/Semantics/getsymbols03-a.f90
similarity index 100%
rename from test/semantics/getsymbols03-a.f90
rename to test/Semantics/getsymbols03-a.f90
diff --git a/test/semantics/getsymbols03-b.f90 b/test/Semantics/getsymbols03-b.f90
similarity index 100%
rename from test/semantics/getsymbols03-b.f90
rename to test/Semantics/getsymbols03-b.f90
diff --git a/test/semantics/getsymbols04.f90 b/test/Semantics/getsymbols04.f90
similarity index 100%
rename from test/semantics/getsymbols04.f90
rename to test/Semantics/getsymbols04.f90
diff --git a/test/semantics/getsymbols05.f90 b/test/Semantics/getsymbols05.f90
similarity index 100%
rename from test/semantics/getsymbols05.f90
rename to test/Semantics/getsymbols05.f90
diff --git a/test/semantics/if_arith01.f90 b/test/Semantics/if_arith01.f90
similarity index 100%
rename from test/semantics/if_arith01.f90
rename to test/Semantics/if_arith01.f90
diff --git a/test/semantics/if_arith02.f90 b/test/Semantics/if_arith02.f90
similarity index 100%
rename from test/semantics/if_arith02.f90
rename to test/Semantics/if_arith02.f90
diff --git a/test/semantics/if_arith03.f90 b/test/Semantics/if_arith03.f90
similarity index 100%
rename from test/semantics/if_arith03.f90
rename to test/Semantics/if_arith03.f90
diff --git a/test/semantics/if_arith04.f90 b/test/Semantics/if_arith04.f90
similarity index 100%
rename from test/semantics/if_arith04.f90
rename to test/Semantics/if_arith04.f90
diff --git a/test/semantics/if_construct01.f90 b/test/Semantics/if_construct01.f90
similarity index 100%
rename from test/semantics/if_construct01.f90
rename to test/Semantics/if_construct01.f90
diff --git a/test/semantics/if_construct02.f90 b/test/Semantics/if_construct02.f90
similarity index 100%
rename from test/semantics/if_construct02.f90
rename to test/Semantics/if_construct02.f90
diff --git a/test/semantics/if_stmt01.f90 b/test/Semantics/if_stmt01.f90
similarity index 100%
rename from test/semantics/if_stmt01.f90
rename to test/Semantics/if_stmt01.f90
diff --git a/test/semantics/if_stmt02.f90 b/test/Semantics/if_stmt02.f90
similarity index 100%
rename from test/semantics/if_stmt02.f90
rename to test/Semantics/if_stmt02.f90
diff --git a/test/semantics/if_stmt03.f90 b/test/Semantics/if_stmt03.f90
similarity index 100%
rename from test/semantics/if_stmt03.f90
rename to test/Semantics/if_stmt03.f90
diff --git a/test/semantics/implicit01.f90 b/test/Semantics/implicit01.f90
similarity index 100%
rename from test/semantics/implicit01.f90
rename to test/Semantics/implicit01.f90
diff --git a/test/semantics/implicit02.f90 b/test/Semantics/implicit02.f90
similarity index 100%
rename from test/semantics/implicit02.f90
rename to test/Semantics/implicit02.f90
diff --git a/test/semantics/implicit03.f90 b/test/Semantics/implicit03.f90
similarity index 100%
rename from test/semantics/implicit03.f90
rename to test/Semantics/implicit03.f90
diff --git a/test/semantics/implicit04.f90 b/test/Semantics/implicit04.f90
similarity index 100%
rename from test/semantics/implicit04.f90
rename to test/Semantics/implicit04.f90
diff --git a/test/semantics/implicit05.f90 b/test/Semantics/implicit05.f90
similarity index 100%
rename from test/semantics/implicit05.f90
rename to test/Semantics/implicit05.f90
diff --git a/test/semantics/implicit06.f90 b/test/Semantics/implicit06.f90
similarity index 100%
rename from test/semantics/implicit06.f90
rename to test/Semantics/implicit06.f90
diff --git a/test/semantics/implicit07.f90 b/test/Semantics/implicit07.f90
similarity index 100%
rename from test/semantics/implicit07.f90
rename to test/Semantics/implicit07.f90
diff --git a/test/semantics/implicit08.f90 b/test/Semantics/implicit08.f90
similarity index 100%
rename from test/semantics/implicit08.f90
rename to test/Semantics/implicit08.f90
diff --git a/test/semantics/init01.f90 b/test/Semantics/init01.f90
similarity index 100%
rename from test/semantics/init01.f90
rename to test/Semantics/init01.f90
diff --git a/test/semantics/int-literals.f90 b/test/Semantics/int-literals.f90
similarity index 100%
rename from test/semantics/int-literals.f90
rename to test/Semantics/int-literals.f90
diff --git a/test/semantics/io01.f90 b/test/Semantics/io01.f90
similarity index 100%
rename from test/semantics/io01.f90
rename to test/Semantics/io01.f90
diff --git a/test/semantics/io02.f90 b/test/Semantics/io02.f90
similarity index 100%
rename from test/semantics/io02.f90
rename to test/Semantics/io02.f90
diff --git a/test/semantics/io03.f90 b/test/Semantics/io03.f90
similarity index 100%
rename from test/semantics/io03.f90
rename to test/Semantics/io03.f90
diff --git a/test/semantics/io04.f90 b/test/Semantics/io04.f90
similarity index 100%
rename from test/semantics/io04.f90
rename to test/Semantics/io04.f90
diff --git a/test/semantics/io05.f90 b/test/Semantics/io05.f90
similarity index 100%
rename from test/semantics/io05.f90
rename to test/Semantics/io05.f90
diff --git a/test/semantics/io06.f90 b/test/Semantics/io06.f90
similarity index 100%
rename from test/semantics/io06.f90
rename to test/Semantics/io06.f90
diff --git a/test/semantics/io07.f90 b/test/Semantics/io07.f90
similarity index 100%
rename from test/semantics/io07.f90
rename to test/Semantics/io07.f90
diff --git a/test/semantics/io08.f90 b/test/Semantics/io08.f90
similarity index 100%
rename from test/semantics/io08.f90
rename to test/Semantics/io08.f90
diff --git a/test/semantics/io09.f90 b/test/Semantics/io09.f90
similarity index 100%
rename from test/semantics/io09.f90
rename to test/Semantics/io09.f90
diff --git a/test/semantics/io10.f90 b/test/Semantics/io10.f90
similarity index 100%
rename from test/semantics/io10.f90
rename to test/Semantics/io10.f90
diff --git a/test/semantics/kinds01.f90 b/test/Semantics/kinds01.f90
similarity index 100%
rename from test/semantics/kinds01.f90
rename to test/Semantics/kinds01.f90
diff --git a/test/semantics/kinds02.f90 b/test/Semantics/kinds02.f90
similarity index 100%
rename from test/semantics/kinds02.f90
rename to test/Semantics/kinds02.f90
diff --git a/test/semantics/kinds03.f90 b/test/Semantics/kinds03.f90
similarity index 100%
rename from test/semantics/kinds03.f90
rename to test/Semantics/kinds03.f90
diff --git a/test/semantics/label01.F90 b/test/Semantics/label01.F90
similarity index 100%
rename from test/semantics/label01.F90
rename to test/Semantics/label01.F90
diff --git a/test/semantics/label02.f90 b/test/Semantics/label02.f90
similarity index 100%
rename from test/semantics/label02.f90
rename to test/Semantics/label02.f90
diff --git a/test/semantics/label03.f90 b/test/Semantics/label03.f90
similarity index 100%
rename from test/semantics/label03.f90
rename to test/Semantics/label03.f90
diff --git a/test/semantics/label04.f90 b/test/Semantics/label04.f90
similarity index 100%
rename from test/semantics/label04.f90
rename to test/Semantics/label04.f90
diff --git a/test/semantics/label05.f90 b/test/Semantics/label05.f90
similarity index 100%
rename from test/semantics/label05.f90
rename to test/Semantics/label05.f90
diff --git a/test/semantics/label06.f90 b/test/Semantics/label06.f90
similarity index 100%
rename from test/semantics/label06.f90
rename to test/Semantics/label06.f90
diff --git a/test/semantics/label07.f90 b/test/Semantics/label07.f90
similarity index 100%
rename from test/semantics/label07.f90
rename to test/Semantics/label07.f90
diff --git a/test/semantics/label08.f90 b/test/Semantics/label08.f90
similarity index 100%
rename from test/semantics/label08.f90
rename to test/Semantics/label08.f90
diff --git a/test/semantics/label09.f90 b/test/Semantics/label09.f90
similarity index 100%
rename from test/semantics/label09.f90
rename to test/Semantics/label09.f90
diff --git a/test/semantics/label10.f90 b/test/Semantics/label10.f90
similarity index 100%
rename from test/semantics/label10.f90
rename to test/Semantics/label10.f90
diff --git a/test/semantics/label11.f90 b/test/Semantics/label11.f90
similarity index 100%
rename from test/semantics/label11.f90
rename to test/Semantics/label11.f90
diff --git a/test/semantics/label12.f90 b/test/Semantics/label12.f90
similarity index 100%
rename from test/semantics/label12.f90
rename to test/Semantics/label12.f90
diff --git a/test/semantics/label13.f90 b/test/Semantics/label13.f90
similarity index 100%
rename from test/semantics/label13.f90
rename to test/Semantics/label13.f90
diff --git a/test/semantics/label14.f90 b/test/Semantics/label14.f90
similarity index 100%
rename from test/semantics/label14.f90
rename to test/Semantics/label14.f90
diff --git a/test/semantics/misc-declarations.f90 b/test/Semantics/misc-declarations.f90
similarity index 100%
rename from test/semantics/misc-declarations.f90
rename to test/Semantics/misc-declarations.f90
diff --git a/test/semantics/modfile01.f90 b/test/Semantics/modfile01.f90
similarity index 100%
rename from test/semantics/modfile01.f90
rename to test/Semantics/modfile01.f90
diff --git a/test/semantics/modfile02.f90 b/test/Semantics/modfile02.f90
similarity index 100%
rename from test/semantics/modfile02.f90
rename to test/Semantics/modfile02.f90
diff --git a/test/semantics/modfile03.f90 b/test/Semantics/modfile03.f90
similarity index 100%
rename from test/semantics/modfile03.f90
rename to test/Semantics/modfile03.f90
diff --git a/test/semantics/modfile04.f90 b/test/Semantics/modfile04.f90
similarity index 100%
rename from test/semantics/modfile04.f90
rename to test/Semantics/modfile04.f90
diff --git a/test/semantics/modfile05.f90 b/test/Semantics/modfile05.f90
similarity index 100%
rename from test/semantics/modfile05.f90
rename to test/Semantics/modfile05.f90
diff --git a/test/semantics/modfile06.f90 b/test/Semantics/modfile06.f90
similarity index 100%
rename from test/semantics/modfile06.f90
rename to test/Semantics/modfile06.f90
diff --git a/test/semantics/modfile07.f90 b/test/Semantics/modfile07.f90
similarity index 100%
rename from test/semantics/modfile07.f90
rename to test/Semantics/modfile07.f90
diff --git a/test/semantics/modfile08.f90 b/test/Semantics/modfile08.f90
similarity index 100%
rename from test/semantics/modfile08.f90
rename to test/Semantics/modfile08.f90
diff --git a/test/semantics/modfile09-a.f90 b/test/Semantics/modfile09-a.f90
similarity index 100%
rename from test/semantics/modfile09-a.f90
rename to test/Semantics/modfile09-a.f90
diff --git a/test/semantics/modfile09-b.f90 b/test/Semantics/modfile09-b.f90
similarity index 100%
rename from test/semantics/modfile09-b.f90
rename to test/Semantics/modfile09-b.f90
diff --git a/test/semantics/modfile09-c.f90 b/test/Semantics/modfile09-c.f90
similarity index 100%
rename from test/semantics/modfile09-c.f90
rename to test/Semantics/modfile09-c.f90
diff --git a/test/semantics/modfile09-d.f90 b/test/Semantics/modfile09-d.f90
similarity index 100%
rename from test/semantics/modfile09-d.f90
rename to test/Semantics/modfile09-d.f90
diff --git a/test/semantics/modfile10.f90 b/test/Semantics/modfile10.f90
similarity index 100%
rename from test/semantics/modfile10.f90
rename to test/Semantics/modfile10.f90
diff --git a/test/semantics/modfile11.f90 b/test/Semantics/modfile11.f90
similarity index 100%
rename from test/semantics/modfile11.f90
rename to test/Semantics/modfile11.f90
diff --git a/test/semantics/modfile12.f90 b/test/Semantics/modfile12.f90
similarity index 100%
rename from test/semantics/modfile12.f90
rename to test/Semantics/modfile12.f90
diff --git a/test/semantics/modfile13.f90 b/test/Semantics/modfile13.f90
similarity index 100%
rename from test/semantics/modfile13.f90
rename to test/Semantics/modfile13.f90
diff --git a/test/semantics/modfile14.f90 b/test/Semantics/modfile14.f90
similarity index 100%
rename from test/semantics/modfile14.f90
rename to test/Semantics/modfile14.f90
diff --git a/test/semantics/modfile15.f90 b/test/Semantics/modfile15.f90
similarity index 100%
rename from test/semantics/modfile15.f90
rename to test/Semantics/modfile15.f90
diff --git a/test/semantics/modfile16.f90 b/test/Semantics/modfile16.f90
similarity index 100%
rename from test/semantics/modfile16.f90
rename to test/Semantics/modfile16.f90
diff --git a/test/semantics/modfile17.f90 b/test/Semantics/modfile17.f90
similarity index 100%
rename from test/semantics/modfile17.f90
rename to test/Semantics/modfile17.f90
diff --git a/test/semantics/modfile18.f90 b/test/Semantics/modfile18.f90
similarity index 100%
rename from test/semantics/modfile18.f90
rename to test/Semantics/modfile18.f90
diff --git a/test/semantics/modfile19.f90 b/test/Semantics/modfile19.f90
similarity index 100%
rename from test/semantics/modfile19.f90
rename to test/Semantics/modfile19.f90
diff --git a/test/semantics/modfile20.f90 b/test/Semantics/modfile20.f90
similarity index 100%
rename from test/semantics/modfile20.f90
rename to test/Semantics/modfile20.f90
diff --git a/test/semantics/modfile21.f90 b/test/Semantics/modfile21.f90
similarity index 100%
rename from test/semantics/modfile21.f90
rename to test/Semantics/modfile21.f90
diff --git a/test/semantics/modfile22.f90 b/test/Semantics/modfile22.f90
similarity index 100%
rename from test/semantics/modfile22.f90
rename to test/Semantics/modfile22.f90
diff --git a/test/semantics/modfile23.f90 b/test/Semantics/modfile23.f90
similarity index 100%
rename from test/semantics/modfile23.f90
rename to test/Semantics/modfile23.f90
diff --git a/test/semantics/modfile24.f90 b/test/Semantics/modfile24.f90
similarity index 100%
rename from test/semantics/modfile24.f90
rename to test/Semantics/modfile24.f90
diff --git a/test/semantics/modfile25.f90 b/test/Semantics/modfile25.f90
similarity index 100%
rename from test/semantics/modfile25.f90
rename to test/Semantics/modfile25.f90
diff --git a/test/semantics/modfile26.f90 b/test/Semantics/modfile26.f90
similarity index 100%
rename from test/semantics/modfile26.f90
rename to test/Semantics/modfile26.f90
diff --git a/test/semantics/modfile27.f90 b/test/Semantics/modfile27.f90
similarity index 100%
rename from test/semantics/modfile27.f90
rename to test/Semantics/modfile27.f90
diff --git a/test/semantics/modfile28.f90 b/test/Semantics/modfile28.f90
similarity index 100%
rename from test/semantics/modfile28.f90
rename to test/Semantics/modfile28.f90
diff --git a/test/semantics/modfile29.f90 b/test/Semantics/modfile29.f90
similarity index 100%
rename from test/semantics/modfile29.f90
rename to test/Semantics/modfile29.f90
diff --git a/test/semantics/modfile30.f90 b/test/Semantics/modfile30.f90
similarity index 100%
rename from test/semantics/modfile30.f90
rename to test/Semantics/modfile30.f90
diff --git a/test/semantics/modfile31.f90 b/test/Semantics/modfile31.f90
similarity index 100%
rename from test/semantics/modfile31.f90
rename to test/Semantics/modfile31.f90
diff --git a/test/semantics/modfile32.f90 b/test/Semantics/modfile32.f90
similarity index 100%
rename from test/semantics/modfile32.f90
rename to test/Semantics/modfile32.f90
diff --git a/test/semantics/modfile33.f90 b/test/Semantics/modfile33.f90
similarity index 100%
rename from test/semantics/modfile33.f90
rename to test/Semantics/modfile33.f90
diff --git a/test/semantics/modfile34.f90 b/test/Semantics/modfile34.f90
similarity index 100%
rename from test/semantics/modfile34.f90
rename to test/Semantics/modfile34.f90
diff --git a/test/semantics/modfile35.f90 b/test/Semantics/modfile35.f90
similarity index 100%
rename from test/semantics/modfile35.f90
rename to test/Semantics/modfile35.f90
diff --git a/test/semantics/null01.f90 b/test/Semantics/null01.f90
similarity index 100%
rename from test/semantics/null01.f90
rename to test/Semantics/null01.f90
diff --git a/test/semantics/nullify01.f90 b/test/Semantics/nullify01.f90
similarity index 100%
rename from test/semantics/nullify01.f90
rename to test/Semantics/nullify01.f90
diff --git a/test/semantics/nullify02.f90 b/test/Semantics/nullify02.f90
similarity index 100%
rename from test/semantics/nullify02.f90
rename to test/Semantics/nullify02.f90
diff --git a/test/semantics/omp-atomic.f90 b/test/Semantics/omp-atomic.f90
similarity index 100%
rename from test/semantics/omp-atomic.f90
rename to test/Semantics/omp-atomic.f90
diff --git a/test/semantics/omp-clause-validity01.f90 b/test/Semantics/omp-clause-validity01.f90
similarity index 100%
rename from test/semantics/omp-clause-validity01.f90
rename to test/Semantics/omp-clause-validity01.f90
diff --git a/test/semantics/omp-declarative-directive.f90 b/test/Semantics/omp-declarative-directive.f90
similarity index 100%
rename from test/semantics/omp-declarative-directive.f90
rename to test/Semantics/omp-declarative-directive.f90
diff --git a/test/semantics/omp-device-constructs.f90 b/test/Semantics/omp-device-constructs.f90
similarity index 100%
rename from test/semantics/omp-device-constructs.f90
rename to test/Semantics/omp-device-constructs.f90
diff --git a/test/semantics/omp-loop-association.f90 b/test/Semantics/omp-loop-association.f90
similarity index 100%
rename from test/semantics/omp-loop-association.f90
rename to test/Semantics/omp-loop-association.f90
diff --git a/test/semantics/omp-nested01.f90 b/test/Semantics/omp-nested01.f90
similarity index 100%
rename from test/semantics/omp-nested01.f90
rename to test/Semantics/omp-nested01.f90
diff --git a/test/semantics/omp-resolve01.f90 b/test/Semantics/omp-resolve01.f90
similarity index 100%
rename from test/semantics/omp-resolve01.f90
rename to test/Semantics/omp-resolve01.f90
diff --git a/test/semantics/omp-resolve02.f90 b/test/Semantics/omp-resolve02.f90
similarity index 100%
rename from test/semantics/omp-resolve02.f90
rename to test/Semantics/omp-resolve02.f90
diff --git a/test/semantics/omp-resolve03.f90 b/test/Semantics/omp-resolve03.f90
similarity index 100%
rename from test/semantics/omp-resolve03.f90
rename to test/Semantics/omp-resolve03.f90
diff --git a/test/semantics/omp-resolve04.f90 b/test/Semantics/omp-resolve04.f90
similarity index 100%
rename from test/semantics/omp-resolve04.f90
rename to test/Semantics/omp-resolve04.f90
diff --git a/test/semantics/omp-resolve05.f90 b/test/Semantics/omp-resolve05.f90
similarity index 100%
rename from test/semantics/omp-resolve05.f90
rename to test/Semantics/omp-resolve05.f90
diff --git a/test/semantics/omp-symbol01.f90 b/test/Semantics/omp-symbol01.f90
similarity index 100%
rename from test/semantics/omp-symbol01.f90
rename to test/Semantics/omp-symbol01.f90
diff --git a/test/semantics/omp-symbol02.f90 b/test/Semantics/omp-symbol02.f90
similarity index 100%
rename from test/semantics/omp-symbol02.f90
rename to test/Semantics/omp-symbol02.f90
diff --git a/test/semantics/omp-symbol03.f90 b/test/Semantics/omp-symbol03.f90
similarity index 100%
rename from test/semantics/omp-symbol03.f90
rename to test/Semantics/omp-symbol03.f90
diff --git a/test/semantics/omp-symbol04.f90 b/test/Semantics/omp-symbol04.f90
similarity index 100%
rename from test/semantics/omp-symbol04.f90
rename to test/Semantics/omp-symbol04.f90
diff --git a/test/semantics/omp-symbol05.f90 b/test/Semantics/omp-symbol05.f90
similarity index 100%
rename from test/semantics/omp-symbol05.f90
rename to test/Semantics/omp-symbol05.f90
diff --git a/test/semantics/omp-symbol06.f90 b/test/Semantics/omp-symbol06.f90
similarity index 100%
rename from test/semantics/omp-symbol06.f90
rename to test/Semantics/omp-symbol06.f90
diff --git a/test/semantics/omp-symbol07.f90 b/test/Semantics/omp-symbol07.f90
similarity index 100%
rename from test/semantics/omp-symbol07.f90
rename to test/Semantics/omp-symbol07.f90
diff --git a/test/semantics/omp-symbol08.f90 b/test/Semantics/omp-symbol08.f90
similarity index 100%
rename from test/semantics/omp-symbol08.f90
rename to test/Semantics/omp-symbol08.f90
diff --git a/test/semantics/procinterface01.f90 b/test/Semantics/procinterface01.f90
similarity index 100%
rename from test/semantics/procinterface01.f90
rename to test/Semantics/procinterface01.f90
diff --git a/test/semantics/resolve01.f90 b/test/Semantics/resolve01.f90
similarity index 100%
rename from test/semantics/resolve01.f90
rename to test/Semantics/resolve01.f90
diff --git a/test/semantics/resolve02.f90 b/test/Semantics/resolve02.f90
similarity index 100%
rename from test/semantics/resolve02.f90
rename to test/Semantics/resolve02.f90
diff --git a/test/semantics/resolve03.f90 b/test/Semantics/resolve03.f90
similarity index 100%
rename from test/semantics/resolve03.f90
rename to test/Semantics/resolve03.f90
diff --git a/test/semantics/resolve04.f90 b/test/Semantics/resolve04.f90
similarity index 100%
rename from test/semantics/resolve04.f90
rename to test/Semantics/resolve04.f90
diff --git a/test/semantics/resolve05.f90 b/test/Semantics/resolve05.f90
similarity index 100%
rename from test/semantics/resolve05.f90
rename to test/Semantics/resolve05.f90
diff --git a/test/semantics/resolve06.f90 b/test/Semantics/resolve06.f90
similarity index 100%
rename from test/semantics/resolve06.f90
rename to test/Semantics/resolve06.f90
diff --git a/test/semantics/resolve07.f90 b/test/Semantics/resolve07.f90
similarity index 100%
rename from test/semantics/resolve07.f90
rename to test/Semantics/resolve07.f90
diff --git a/test/semantics/resolve08.f90 b/test/Semantics/resolve08.f90
similarity index 100%
rename from test/semantics/resolve08.f90
rename to test/Semantics/resolve08.f90
diff --git a/test/semantics/resolve09.f90 b/test/Semantics/resolve09.f90
similarity index 100%
rename from test/semantics/resolve09.f90
rename to test/Semantics/resolve09.f90
diff --git a/test/semantics/resolve10.f90 b/test/Semantics/resolve10.f90
similarity index 100%
rename from test/semantics/resolve10.f90
rename to test/Semantics/resolve10.f90
diff --git a/test/semantics/resolve11.f90 b/test/Semantics/resolve11.f90
similarity index 100%
rename from test/semantics/resolve11.f90
rename to test/Semantics/resolve11.f90
diff --git a/test/semantics/resolve12.f90 b/test/Semantics/resolve12.f90
similarity index 100%
rename from test/semantics/resolve12.f90
rename to test/Semantics/resolve12.f90
diff --git a/test/semantics/resolve13.f90 b/test/Semantics/resolve13.f90
similarity index 100%
rename from test/semantics/resolve13.f90
rename to test/Semantics/resolve13.f90
diff --git a/test/semantics/resolve14.f90 b/test/Semantics/resolve14.f90
similarity index 100%
rename from test/semantics/resolve14.f90
rename to test/Semantics/resolve14.f90
diff --git a/test/semantics/resolve15.f90 b/test/Semantics/resolve15.f90
similarity index 100%
rename from test/semantics/resolve15.f90
rename to test/Semantics/resolve15.f90
diff --git a/test/semantics/resolve16.f90 b/test/Semantics/resolve16.f90
similarity index 100%
rename from test/semantics/resolve16.f90
rename to test/Semantics/resolve16.f90
diff --git a/test/semantics/resolve17.f90 b/test/Semantics/resolve17.f90
similarity index 100%
rename from test/semantics/resolve17.f90
rename to test/Semantics/resolve17.f90
diff --git a/test/semantics/resolve18.f90 b/test/Semantics/resolve18.f90
similarity index 100%
rename from test/semantics/resolve18.f90
rename to test/Semantics/resolve18.f90
diff --git a/test/semantics/resolve19.f90 b/test/Semantics/resolve19.f90
similarity index 100%
rename from test/semantics/resolve19.f90
rename to test/Semantics/resolve19.f90
diff --git a/test/semantics/resolve20.f90 b/test/Semantics/resolve20.f90
similarity index 100%
rename from test/semantics/resolve20.f90
rename to test/Semantics/resolve20.f90
diff --git a/test/semantics/resolve21.f90 b/test/Semantics/resolve21.f90
similarity index 100%
rename from test/semantics/resolve21.f90
rename to test/Semantics/resolve21.f90
diff --git a/test/semantics/resolve22.f90 b/test/Semantics/resolve22.f90
similarity index 100%
rename from test/semantics/resolve22.f90
rename to test/Semantics/resolve22.f90
diff --git a/test/semantics/resolve23.f90 b/test/Semantics/resolve23.f90
similarity index 100%
rename from test/semantics/resolve23.f90
rename to test/Semantics/resolve23.f90
diff --git a/test/semantics/resolve24.f90 b/test/Semantics/resolve24.f90
similarity index 100%
rename from test/semantics/resolve24.f90
rename to test/Semantics/resolve24.f90
diff --git a/test/semantics/resolve25.f90 b/test/Semantics/resolve25.f90
similarity index 100%
rename from test/semantics/resolve25.f90
rename to test/Semantics/resolve25.f90
diff --git a/test/semantics/resolve26.f90 b/test/Semantics/resolve26.f90
similarity index 100%
rename from test/semantics/resolve26.f90
rename to test/Semantics/resolve26.f90
diff --git a/test/semantics/resolve27.f90 b/test/Semantics/resolve27.f90
similarity index 100%
rename from test/semantics/resolve27.f90
rename to test/Semantics/resolve27.f90
diff --git a/test/semantics/resolve28.f90 b/test/Semantics/resolve28.f90
similarity index 100%
rename from test/semantics/resolve28.f90
rename to test/Semantics/resolve28.f90
diff --git a/test/semantics/resolve29.f90 b/test/Semantics/resolve29.f90
similarity index 100%
rename from test/semantics/resolve29.f90
rename to test/Semantics/resolve29.f90
diff --git a/test/semantics/resolve30.f90 b/test/Semantics/resolve30.f90
similarity index 100%
rename from test/semantics/resolve30.f90
rename to test/Semantics/resolve30.f90
diff --git a/test/semantics/resolve31.f90 b/test/Semantics/resolve31.f90
similarity index 100%
rename from test/semantics/resolve31.f90
rename to test/Semantics/resolve31.f90
diff --git a/test/semantics/resolve32.f90 b/test/Semantics/resolve32.f90
similarity index 100%
rename from test/semantics/resolve32.f90
rename to test/Semantics/resolve32.f90
diff --git a/test/semantics/resolve33.f90 b/test/Semantics/resolve33.f90
similarity index 100%
rename from test/semantics/resolve33.f90
rename to test/Semantics/resolve33.f90
diff --git a/test/semantics/resolve34.f90 b/test/Semantics/resolve34.f90
similarity index 100%
rename from test/semantics/resolve34.f90
rename to test/Semantics/resolve34.f90
diff --git a/test/semantics/resolve35.f90 b/test/Semantics/resolve35.f90
similarity index 100%
rename from test/semantics/resolve35.f90
rename to test/Semantics/resolve35.f90
diff --git a/test/semantics/resolve36.f90 b/test/Semantics/resolve36.f90
similarity index 100%
rename from test/semantics/resolve36.f90
rename to test/Semantics/resolve36.f90
diff --git a/test/semantics/resolve37.f90 b/test/Semantics/resolve37.f90
similarity index 100%
rename from test/semantics/resolve37.f90
rename to test/Semantics/resolve37.f90
diff --git a/test/semantics/resolve38.f90 b/test/Semantics/resolve38.f90
similarity index 100%
rename from test/semantics/resolve38.f90
rename to test/Semantics/resolve38.f90
diff --git a/test/semantics/resolve39.f90 b/test/Semantics/resolve39.f90
similarity index 100%
rename from test/semantics/resolve39.f90
rename to test/Semantics/resolve39.f90
diff --git a/test/semantics/resolve40.f90 b/test/Semantics/resolve40.f90
similarity index 100%
rename from test/semantics/resolve40.f90
rename to test/Semantics/resolve40.f90
diff --git a/test/semantics/resolve41.f90 b/test/Semantics/resolve41.f90
similarity index 100%
rename from test/semantics/resolve41.f90
rename to test/Semantics/resolve41.f90
diff --git a/test/semantics/resolve42.f90 b/test/Semantics/resolve42.f90
similarity index 100%
rename from test/semantics/resolve42.f90
rename to test/Semantics/resolve42.f90
diff --git a/test/semantics/resolve43.f90 b/test/Semantics/resolve43.f90
similarity index 100%
rename from test/semantics/resolve43.f90
rename to test/Semantics/resolve43.f90
diff --git a/test/semantics/resolve44.f90 b/test/Semantics/resolve44.f90
similarity index 100%
rename from test/semantics/resolve44.f90
rename to test/Semantics/resolve44.f90
diff --git a/test/semantics/resolve45.f90 b/test/Semantics/resolve45.f90
similarity index 100%
rename from test/semantics/resolve45.f90
rename to test/Semantics/resolve45.f90
diff --git a/test/semantics/resolve46.f90 b/test/Semantics/resolve46.f90
similarity index 100%
rename from test/semantics/resolve46.f90
rename to test/Semantics/resolve46.f90
diff --git a/test/semantics/resolve47.f90 b/test/Semantics/resolve47.f90
similarity index 100%
rename from test/semantics/resolve47.f90
rename to test/Semantics/resolve47.f90
diff --git a/test/semantics/resolve48.f90 b/test/Semantics/resolve48.f90
similarity index 100%
rename from test/semantics/resolve48.f90
rename to test/Semantics/resolve48.f90
diff --git a/test/semantics/resolve49.f90 b/test/Semantics/resolve49.f90
similarity index 100%
rename from test/semantics/resolve49.f90
rename to test/Semantics/resolve49.f90
diff --git a/test/semantics/resolve50.f90 b/test/Semantics/resolve50.f90
similarity index 100%
rename from test/semantics/resolve50.f90
rename to test/Semantics/resolve50.f90
diff --git a/test/semantics/resolve51.f90 b/test/Semantics/resolve51.f90
similarity index 100%
rename from test/semantics/resolve51.f90
rename to test/Semantics/resolve51.f90
diff --git a/test/semantics/resolve52.f90 b/test/Semantics/resolve52.f90
similarity index 100%
rename from test/semantics/resolve52.f90
rename to test/Semantics/resolve52.f90
diff --git a/test/semantics/resolve53.f90 b/test/Semantics/resolve53.f90
similarity index 100%
rename from test/semantics/resolve53.f90
rename to test/Semantics/resolve53.f90
diff --git a/test/semantics/resolve54.f90 b/test/Semantics/resolve54.f90
similarity index 100%
rename from test/semantics/resolve54.f90
rename to test/Semantics/resolve54.f90
diff --git a/test/semantics/resolve55.f90 b/test/Semantics/resolve55.f90
similarity index 100%
rename from test/semantics/resolve55.f90
rename to test/Semantics/resolve55.f90
diff --git a/test/semantics/resolve56.f90 b/test/Semantics/resolve56.f90
similarity index 100%
rename from test/semantics/resolve56.f90
rename to test/Semantics/resolve56.f90
diff --git a/test/semantics/resolve57.f90 b/test/Semantics/resolve57.f90
similarity index 100%
rename from test/semantics/resolve57.f90
rename to test/Semantics/resolve57.f90
diff --git a/test/semantics/resolve58.f90 b/test/Semantics/resolve58.f90
similarity index 100%
rename from test/semantics/resolve58.f90
rename to test/Semantics/resolve58.f90
diff --git a/test/semantics/resolve59.f90 b/test/Semantics/resolve59.f90
similarity index 100%
rename from test/semantics/resolve59.f90
rename to test/Semantics/resolve59.f90
diff --git a/test/semantics/resolve60.f90 b/test/Semantics/resolve60.f90
similarity index 100%
rename from test/semantics/resolve60.f90
rename to test/Semantics/resolve60.f90
diff --git a/test/semantics/resolve61.f90 b/test/Semantics/resolve61.f90
similarity index 100%
rename from test/semantics/resolve61.f90
rename to test/Semantics/resolve61.f90
diff --git a/test/semantics/resolve62.f90 b/test/Semantics/resolve62.f90
similarity index 100%
rename from test/semantics/resolve62.f90
rename to test/Semantics/resolve62.f90
diff --git a/test/semantics/resolve63.f90 b/test/Semantics/resolve63.f90
similarity index 100%
rename from test/semantics/resolve63.f90
rename to test/Semantics/resolve63.f90
diff --git a/test/semantics/resolve64.f90 b/test/Semantics/resolve64.f90
similarity index 100%
rename from test/semantics/resolve64.f90
rename to test/Semantics/resolve64.f90
diff --git a/test/semantics/resolve65.f90 b/test/Semantics/resolve65.f90
similarity index 100%
rename from test/semantics/resolve65.f90
rename to test/Semantics/resolve65.f90
diff --git a/test/semantics/resolve66.f90 b/test/Semantics/resolve66.f90
similarity index 100%
rename from test/semantics/resolve66.f90
rename to test/Semantics/resolve66.f90
diff --git a/test/semantics/resolve67.f90 b/test/Semantics/resolve67.f90
similarity index 100%
rename from test/semantics/resolve67.f90
rename to test/Semantics/resolve67.f90
diff --git a/test/semantics/resolve68.f90 b/test/Semantics/resolve68.f90
similarity index 100%
rename from test/semantics/resolve68.f90
rename to test/Semantics/resolve68.f90
diff --git a/test/semantics/resolve69.f90 b/test/Semantics/resolve69.f90
similarity index 100%
rename from test/semantics/resolve69.f90
rename to test/Semantics/resolve69.f90
diff --git a/test/semantics/resolve70.f90 b/test/Semantics/resolve70.f90
similarity index 100%
rename from test/semantics/resolve70.f90
rename to test/Semantics/resolve70.f90
diff --git a/test/semantics/resolve71.f90 b/test/Semantics/resolve71.f90
similarity index 100%
rename from test/semantics/resolve71.f90
rename to test/Semantics/resolve71.f90
diff --git a/test/semantics/resolve72.f90 b/test/Semantics/resolve72.f90
similarity index 100%
rename from test/semantics/resolve72.f90
rename to test/Semantics/resolve72.f90
diff --git a/test/semantics/separate-module-procs.f90 b/test/Semantics/separate-module-procs.f90
similarity index 100%
rename from test/semantics/separate-module-procs.f90
rename to test/Semantics/separate-module-procs.f90
diff --git a/test/semantics/stop01.f90 b/test/Semantics/stop01.f90
similarity index 100%
rename from test/semantics/stop01.f90
rename to test/Semantics/stop01.f90
diff --git a/test/semantics/structconst01.f90 b/test/Semantics/structconst01.f90
similarity index 100%
rename from test/semantics/structconst01.f90
rename to test/Semantics/structconst01.f90
diff --git a/test/semantics/structconst02.f90 b/test/Semantics/structconst02.f90
similarity index 100%
rename from test/semantics/structconst02.f90
rename to test/Semantics/structconst02.f90
diff --git a/test/semantics/structconst03.f90 b/test/Semantics/structconst03.f90
similarity index 98%
rename from test/semantics/structconst03.f90
rename to test/Semantics/structconst03.f90
index 7860e7ce366c..e637bc08d3e3 100644
--- a/test/semantics/structconst03.f90
+++ b/test/Semantics/structconst03.f90
@@ -1,6 +1,6 @@
 ! Error tests for structure constructors: C1594 violations
 ! from assigning globally-visible data to POINTER components.
-! test/semantics/structconst04.f90 is this same test without type
+! test/Semantics/structconst04.f90 is this same test without type
 ! parameters.
 
 module usefrom
diff --git a/test/semantics/structconst04.f90 b/test/Semantics/structconst04.f90
similarity index 100%
rename from test/semantics/structconst04.f90
rename to test/Semantics/structconst04.f90
diff --git a/test/semantics/symbol01.f90 b/test/Semantics/symbol01.f90
similarity index 100%
rename from test/semantics/symbol01.f90
rename to test/Semantics/symbol01.f90
diff --git a/test/semantics/symbol02.f90 b/test/Semantics/symbol02.f90
similarity index 100%
rename from test/semantics/symbol02.f90
rename to test/Semantics/symbol02.f90
diff --git a/test/semantics/symbol03.f90 b/test/Semantics/symbol03.f90
similarity index 100%
rename from test/semantics/symbol03.f90
rename to test/Semantics/symbol03.f90
diff --git a/test/semantics/symbol05.f90 b/test/Semantics/symbol05.f90
similarity index 100%
rename from test/semantics/symbol05.f90
rename to test/Semantics/symbol05.f90
diff --git a/test/semantics/symbol06.f90 b/test/Semantics/symbol06.f90
similarity index 100%
rename from test/semantics/symbol06.f90
rename to test/Semantics/symbol06.f90
diff --git a/test/semantics/symbol07.f90 b/test/Semantics/symbol07.f90
similarity index 100%
rename from test/semantics/symbol07.f90
rename to test/Semantics/symbol07.f90
diff --git a/test/semantics/symbol08.f90 b/test/Semantics/symbol08.f90
similarity index 100%
rename from test/semantics/symbol08.f90
rename to test/Semantics/symbol08.f90
diff --git a/test/semantics/symbol09.f90 b/test/Semantics/symbol09.f90
similarity index 100%
rename from test/semantics/symbol09.f90
rename to test/Semantics/symbol09.f90
diff --git a/test/semantics/symbol10.f90 b/test/Semantics/symbol10.f90
similarity index 100%
rename from test/semantics/symbol10.f90
rename to test/Semantics/symbol10.f90
diff --git a/test/semantics/symbol11.f90 b/test/Semantics/symbol11.f90
similarity index 100%
rename from test/semantics/symbol11.f90
rename to test/Semantics/symbol11.f90
diff --git a/test/semantics/symbol12.f90 b/test/Semantics/symbol12.f90
similarity index 100%
rename from test/semantics/symbol12.f90
rename to test/Semantics/symbol12.f90
diff --git a/test/semantics/symbol13.f90 b/test/Semantics/symbol13.f90
similarity index 100%
rename from test/semantics/symbol13.f90
rename to test/Semantics/symbol13.f90
diff --git a/test/semantics/symbol14.f90 b/test/Semantics/symbol14.f90
similarity index 100%
rename from test/semantics/symbol14.f90
rename to test/Semantics/symbol14.f90
diff --git a/test/semantics/symbol15.f90 b/test/Semantics/symbol15.f90
similarity index 100%
rename from test/semantics/symbol15.f90
rename to test/Semantics/symbol15.f90
diff --git a/test/semantics/symbol16.f90 b/test/Semantics/symbol16.f90
similarity index 100%
rename from test/semantics/symbol16.f90
rename to test/Semantics/symbol16.f90
diff --git a/test/semantics/symbol17.f90 b/test/Semantics/symbol17.f90
similarity index 100%
rename from test/semantics/symbol17.f90
rename to test/Semantics/symbol17.f90
diff --git a/test/semantics/test_any.sh b/test/Semantics/test_any.sh
similarity index 100%
rename from test/semantics/test_any.sh
rename to test/Semantics/test_any.sh
diff --git a/test/semantics/test_errors.sh b/test/Semantics/test_errors.sh
similarity index 100%
rename from test/semantics/test_errors.sh
rename to test/Semantics/test_errors.sh
diff --git a/test/semantics/test_modfile.sh b/test/Semantics/test_modfile.sh
similarity index 100%
rename from test/semantics/test_modfile.sh
rename to test/Semantics/test_modfile.sh
diff --git a/test/semantics/test_symbols.sh b/test/Semantics/test_symbols.sh
similarity index 100%
rename from test/semantics/test_symbols.sh
rename to test/Semantics/test_symbols.sh
diff --git a/tools/f18/f18-parse-demo.cpp b/tools/f18/f18-parse-demo.cpp
index d52499e16416..67bc45eb499a 100644
--- a/tools/f18/f18-parse-demo.cpp
+++ b/tools/f18/f18-parse-demo.cpp
@@ -21,16 +21,16 @@
 // scaffolding compiler driver that can test some semantic passes of the
 // F18 compiler under development.
 
-#include "flang/common/Fortran-features.h"
-#include "flang/common/default-kinds.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/dump-parse-tree.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/parsing.h"
-#include "flang/parser/provenance.h"
-#include "flang/parser/unparse.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/parsing.h"
+#include "flang/Parser/provenance.h"
+#include "flang/Parser/unparse.h"
 #include <cerrno>
 #include <cstdio>
 #include <cstring>
diff --git a/tools/f18/f18.cpp b/tools/f18/f18.cpp
index b54d1a9e2d11..608075aa33d5 100644
--- a/tools/f18/f18.cpp
+++ b/tools/f18/f18.cpp
@@ -8,21 +8,21 @@
 
 // Temporary Fortran front end driver main program for development scaffolding.
 
-#include "flang/common/Fortran-features.h"
-#include "flang/common/default-kinds.h"
-#include "flang/evaluate/expression.h"
-#include "flang/lower/PFTBuilder.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/dump-parse-tree.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/parsing.h"
-#include "flang/parser/provenance.h"
-#include "flang/parser/unparse.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/unparse-with-symbols.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Evaluate/expression.h"
+#include "flang/Lower/PFTBuilder.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/parsing.h"
+#include "flang/Parser/provenance.h"
+#include "flang/Parser/unparse.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/unparse-with-symbols.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cerrno>
 #include <cstdio>
diff --git a/tools/f18/stub-evaluate.cpp b/tools/f18/stub-evaluate.cpp
index 99e2635430c0..dbaa13a338d9 100644
--- a/tools/f18/stub-evaluate.cpp
+++ b/tools/f18/stub-evaluate.cpp
@@ -11,7 +11,7 @@
 // libraries, as here, we need to stub out the dependences on the external
 // destructors, which will never actually be called.
 
-#include "flang/common/indirection.h"
+#include "flang/Common/indirection.h"
 
 namespace Fortran::evaluate {
 struct GenericExprWrapper {

From 97efc0194d411a17ec47edf5e27157d1a1afa3bc Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Tue, 25 Feb 2020 15:59:50 +0000
Subject: [PATCH 044/345] Replace module writer posix file handling with llvm
 file handling. (#993)

NOTE: This commit introduces a dependency on LLVM HEAD
---
 .drone.star                                   |  20 ++-
 include/flang/Semantics/semantics.h           |  10 +-
 lib/Semantics/CMakeLists.txt                  |   1 +
 lib/Semantics/mod-file.cpp                    | 125 ++++++++----------
 .../Semantics/Inputs/mod-file-changed.f90     |   5 +
 .../Semantics/Inputs/mod-file-unchanged.f90   |   5 +
 test-lit/Semantics/mod-file-rewriter.f90      |  12 ++
 tools/f18/f18.cpp                             |   7 +-
 8 files changed, 111 insertions(+), 74 deletions(-)
 create mode 100644 test-lit/Semantics/Inputs/mod-file-changed.f90
 create mode 100644 test-lit/Semantics/Inputs/mod-file-unchanged.f90
 create mode 100644 test-lit/Semantics/mod-file-rewriter.f90

diff --git a/.drone.star b/.drone.star
index 47dfca7c2460..7d09fdab0977 100644
--- a/.drone.star
+++ b/.drone.star
@@ -7,11 +7,17 @@ def clang(arch):
                 "name": "test",
                 "image": "ubuntu",
                 "commands": [
-                    "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-8-dev libc++-8-dev libc++abi-8-dev libz-dev",
+                    "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-8-dev libc++-8-dev libc++abi-8-dev libz-dev git",
+                    "git clone https://github.com/llvm/llvm-project",
+                    "mkdir llvm-project/build && cd llvm-project/build",
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="clang;mlir" ../llvm',
+                    "ninja install",
+                    "cd ../..",
                     "mkdir build && cd build",
-                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..',
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
                     "ninja -j8",
                     "ctest --output-on-failure -j24",
+                    "ninja check-all",
                 ],
             },
         ],
@@ -27,11 +33,17 @@ def gcc(arch):
                     "name": "test",
                     "image": "gcc",
                     "commands": [
-			"apt-get update && apt-get install -y cmake ninja-build llvm-dev libz-dev",
+			"apt-get update && apt-get install -y cmake ninja-build llvm-dev libz-dev git",
+		        "git clone https://github.com/llvm/llvm-project",
+		        "mkdir llvm-project/build && cd llvm-project/build",
+		        'env CC=gcc CXX=g++ LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="clang;mlir" ../llvm',
+                        "ninja install",
+                        "cd ../..",
                         "mkdir build && cd build",
-                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..',
+                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
                         "ninja -j8",
                         "ctest --output-on-failure -j24",
+                        "ninja check-all",
                     ],
                 },
             ],
diff --git a/include/flang/Semantics/semantics.h b/include/flang/Semantics/semantics.h
index dd384583e549..b88bcc4563ed 100644
--- a/include/flang/Semantics/semantics.h
+++ b/include/flang/Semantics/semantics.h
@@ -80,6 +80,7 @@ class SemanticsContext {
   const std::string &moduleFileSuffix() const { return moduleFileSuffix_; }
   bool warnOnNonstandardUsage() const { return warnOnNonstandardUsage_; }
   bool warningsAreErrors() const { return warningsAreErrors_; }
+  bool debugModuleWriter() const { return debugModuleWriter_; }
   const evaluate::IntrinsicProcTable &intrinsics() const { return intrinsics_; }
   Scope &globalScope() { return globalScope_; }
   parser::Messages &messages() { return messages_; }
@@ -112,6 +113,11 @@ class SemanticsContext {
     return *this;
   }
 
+  SemanticsContext &set_debugModuleWriter(bool x) {
+    debugModuleWriter_ = x;
+    return *this;
+  }
+
   const DeclTypeSpec &MakeNumericType(TypeCategory, int kind = 0);
   const DeclTypeSpec &MakeLogicalType(int kind = 0);
 
@@ -175,6 +181,7 @@ class SemanticsContext {
   std::string moduleFileSuffix_{".mod"};
   bool warnOnNonstandardUsage_{false};
   bool warningsAreErrors_{false};
+  bool debugModuleWriter_{false};
   const evaluate::IntrinsicProcTable intrinsics_;
   Scope globalScope_;
   parser::Messages messages_;
@@ -190,8 +197,9 @@ class SemanticsContext {
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
-      parser::CookedSource &cooked)
+      parser::CookedSource &cooked, bool debugModuleWriter = false)
     : context_{context}, program_{program}, cooked_{cooked} {
+    context.set_debugModuleWriter(debugModuleWriter);
     context.globalScope().AddSourceRange(parser::CharBlock{cooked.data()});
   }
 
diff --git a/lib/Semantics/CMakeLists.txt b/lib/Semantics/CMakeLists.txt
index 7900eeff9da1..0c6b612586de 100644
--- a/lib/Semantics/CMakeLists.txt
+++ b/lib/Semantics/CMakeLists.txt
@@ -45,6 +45,7 @@ add_library(FortranSemantics
 target_link_libraries(FortranSemantics
   FortranCommon
   FortranEvaluate
+  LLVMSupport
 )
 
 install (TARGETS FortranSemantics
diff --git a/lib/Semantics/mod-file.cpp b/lib/Semantics/mod-file.cpp
index 53f72b4a99a0..2810c3542446 100644
--- a/lib/Semantics/mod-file.cpp
+++ b/lib/Semantics/mod-file.cpp
@@ -15,16 +15,14 @@
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cerrno>
 #include <fstream>
 #include <ostream>
 #include <set>
 #include <string_view>
-#include <sys/file.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 #include <vector>
 
 namespace Fortran::semantics {
@@ -62,10 +60,10 @@ static std::ostream &PutAttrs(std::ostream &, Attrs,
 static std::ostream &PutAttr(std::ostream &, Attr);
 static std::ostream &PutType(std::ostream &, const DeclTypeSpec &);
 static std::ostream &PutLower(std::ostream &, const std::string &);
-static int WriteFile(const std::string &, const std::string &);
+static std::error_code WriteFile(
+    const std::string &, const std::string &, bool = true);
 static bool FileContentsMatch(
     const std::string &, const std::string &, const std::string &);
-static std::size_t GetFileSize(const std::string &);
 static std::string CheckSum(const std::string_view &);
 
 // Collect symbols needed for a subprogram interface
@@ -135,9 +133,10 @@ void ModFileWriter::Write(const Symbol &symbol) {
   auto path{context_.moduleDirectory() + '/' +
       ModFileName(symbol.name(), ancestorName, context_.moduleFileSuffix())};
   PutSymbols(DEREF(symbol.scope()));
-  if (int error{WriteFile(path, GetAsString(symbol))}) {
-    context_.Say(symbol.name(), "Error writing %s: %s"_err_en_US, path,
-        std::strerror(error));
+  if (std::error_code error{
+          WriteFile(path, GetAsString(symbol), context_.debugModuleWriter())}) {
+    context_.Say(
+        symbol.name(), "Error writing %s: %s"_err_en_US, path, error.message());
   }
 }
 
@@ -618,53 +617,67 @@ std::ostream &PutLower(std::ostream &os, const std::string &str) {
 }
 
 struct Temp {
-  Temp() = delete;
+  Temp(llvm::sys::fs::file_t fd, std::string path) : fd{fd}, path{path} {}
+  Temp(Temp &&t) : fd{std::exchange(t.fd, -1)}, path{std::move(t.path)} {}
   ~Temp() {
-    close(fd);
-    unlink(path.c_str());
+    if (fd >= 0) {
+      llvm::sys::fs::closeFile(fd);
+      llvm::sys::fs::remove(path.c_str());
+    }
   }
-  int fd;
+  llvm::sys::fs::file_t fd;
   std::string path;
 };
 
 // Create a temp file in the same directory and with the same suffix as path.
 // Return an open file descriptor and its path.
-static Temp MkTemp(const std::string &path) {
+static llvm::ErrorOr<Temp> MkTemp(const std::string &path) {
   auto length{path.length()};
   auto dot{path.find_last_of("./")};
-  std::string suffix{dot < length && path[dot] == '.' ? path.substr(dot) : ""};
+  std::string suffix{
+      dot < length && path[dot] == '.' ? path.substr(dot + 1) : ""};
   CHECK(length > suffix.length() &&
       path.substr(length - suffix.length()) == suffix);
-  auto tempPath{path.substr(0, length - suffix.length()) + "XXXXXX" + suffix};
-  int fd{mkstemps(&tempPath[0], suffix.length())};
-  auto mask{umask(0777)};
-  umask(mask);
-  chmod(tempPath.c_str(), 0666 & ~mask);  // temp is created with mode 0600
-  return Temp{fd, tempPath};
+  auto prefix{path.substr(0, length - suffix.length())};
+  llvm::sys::fs::file_t fd;
+  llvm::SmallString<16> tempPath;
+  if (std::error_code err{llvm::sys::fs::createUniqueFile(
+          prefix + "%%%%%%" + suffix, fd, tempPath)}) {
+    return err;
+  }
+  return Temp{fd, tempPath.c_str()};
 }
 
 // Write the module file at path, prepending header. If an error occurs,
 // return errno, otherwise 0.
-static int WriteFile(const std::string &path, const std::string &contents) {
+static std::error_code WriteFile(
+    const std::string &path, const std::string &contents, bool debug) {
   auto header{std::string{ModHeader::bom} + ModHeader::magic +
       CheckSum(contents) + ModHeader::terminator};
+  if (debug) {
+    llvm::dbgs() << "Processing module " << path << ": ";
+  }
   if (FileContentsMatch(path, header, contents)) {
-    return 0;
+    if (debug) {
+      llvm::dbgs() << "module unchanged, not writing\n";
+    }
+    return {};
   }
-  Temp temp{MkTemp(path)};
-  if (temp.fd < 0) {
-    return errno;
+  llvm::ErrorOr<Temp> temp{MkTemp(path)};
+  if (!temp) {
+    return temp.getError();
   }
-  if (write(temp.fd, header.c_str(), header.size()) !=
-          static_cast<ssize_t>(header.size()) ||
-      write(temp.fd, contents.c_str(), contents.size()) !=
-          static_cast<ssize_t>(contents.size())) {
-    return errno;
+  llvm::raw_fd_ostream writer(temp->fd, /*shouldClose=*/false);
+  writer << header;
+  writer << contents;
+  writer.flush();
+  if (writer.has_error()) {
+    return writer.error();
   }
-  if (std::rename(temp.path.c_str(), path.c_str()) == -1) {
-    return errno;
+  if (debug) {
+    llvm::dbgs() << "module written\n";
   }
-  return 0;
+  return llvm::sys::fs::rename(temp->path, path);
 }
 
 // Return true if the stream matches what we would write for the mod file.
@@ -672,34 +685,21 @@ static bool FileContentsMatch(const std::string &path,
     const std::string &header, const std::string &contents) {
   std::size_t hsize{header.size()};
   std::size_t csize{contents.size()};
-  if (GetFileSize(path) != hsize + csize) {
+  auto buf_or{llvm::MemoryBuffer::getFile(path)};
+  if (!buf_or) {
     return false;
   }
-  int fd{open(path.c_str(), O_RDONLY)};
-  if (fd < 0) {
+  auto buf = std::move(buf_or.get());
+  if (buf->getBufferSize() != hsize + csize) {
     return false;
   }
-  constexpr std::size_t bufSize{4096};
-  std::string buffer(bufSize, '\0');
-  if (read(fd, &buffer[0], hsize) != static_cast<ssize_t>(hsize) ||
-      std::memcmp(&buffer[0], &header[0], hsize) != 0) {
-    close(fd);
-    return false;  // header doesn't match
-  }
-  for (auto remaining{csize};;) {
-    auto bytes{std::min(bufSize, remaining)};
-    auto got{read(fd, &buffer[0], bytes)};
-    if (got != static_cast<ssize_t>(bytes) ||
-        std::memcmp(&buffer[0], &contents[csize - remaining], bytes) != 0) {
-      close(fd);
-      return false;
-    }
-    if (bytes == 0 && remaining == 0) {
-      close(fd);
-      return true;
-    }
-    remaining -= bytes;
+  if (!std::equal(header.begin(), header.end(), buf->getBufferStart(),
+          buf->getBufferStart() + hsize)) {
+    return false;
   }
+
+  return std::equal(contents.begin(), contents.end(),
+      buf->getBufferStart() + hsize, buf->getBufferEnd());
 }
 
 // Compute a simple hash of the contents of a module file and
@@ -729,15 +729,6 @@ static bool VerifyHeader(const char *content, std::size_t len) {
   return expectSum == actualSum;
 }
 
-static std::size_t GetFileSize(const std::string &path) {
-  struct stat statbuf;
-  if (stat(path.c_str(), &statbuf) == 0) {
-    return static_cast<std::size_t>(statbuf.st_size);
-  } else {
-    return 0;
-  }
-}
-
 Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
   std::string ancestorName;  // empty for module
   if (ancestor) {
diff --git a/test-lit/Semantics/Inputs/mod-file-changed.f90 b/test-lit/Semantics/Inputs/mod-file-changed.f90
new file mode 100644
index 000000000000..028203853fdc
--- /dev/null
+++ b/test-lit/Semantics/Inputs/mod-file-changed.f90
@@ -0,0 +1,5 @@
+module m
+  dimension :: x(10)
+  private :: x
+  real :: x
+end module m
diff --git a/test-lit/Semantics/Inputs/mod-file-unchanged.f90 b/test-lit/Semantics/Inputs/mod-file-unchanged.f90
new file mode 100644
index 000000000000..46c208aeb67a
--- /dev/null
+++ b/test-lit/Semantics/Inputs/mod-file-unchanged.f90
@@ -0,0 +1,5 @@
+module m
+  dimension :: x(10)
+  public :: x
+  real :: x
+end module m
diff --git a/test-lit/Semantics/mod-file-rewriter.f90 b/test-lit/Semantics/mod-file-rewriter.f90
new file mode 100644
index 000000000000..81252910e690
--- /dev/null
+++ b/test-lit/Semantics/mod-file-rewriter.f90
@@ -0,0 +1,12 @@
+! RUN: rm -fr %t && mkdir %t && cd %t
+! RUN: %f18 -fparse-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+! RUN: %f18 -fparse-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %f18 -fparse-only -fdebug-module-writer %p/Inputs/mod-file-unchanged.f90 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %f18 -fparse-only -fdebug-module-writer %p/Inputs/mod-file-changed.f90 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+
+module m
+  real :: x(10)
+end module m
+
+! CHECK_CHANGED: Processing module {{.*}}.mod: module written
+! CHECK_UNCHANGED: Processing module {{.*}}.mod: module unchanged, not writing
diff --git a/tools/f18/f18.cpp b/tools/f18/f18.cpp
index 608075aa33d5..fe7bd8a1946f 100644
--- a/tools/f18/f18.cpp
+++ b/tools/f18/f18.cpp
@@ -98,6 +98,7 @@ struct DriverOptions {
   bool dumpSymbols{false};
   bool debugResolveNames{false};
   bool debugNoSemantics{false};
+  bool debugModuleWriter{false};
   bool measureTree{false};
   bool unparseTypedExprsToPGF90{false};
   std::vector<std::string> pgf90Args;
@@ -251,8 +252,8 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   if (!driver.debugNoSemantics || driver.debugResolveNames ||
       driver.dumpSymbols || driver.dumpUnparseWithSymbols ||
       driver.getDefinition || driver.getSymbolsSources) {
-    Fortran::semantics::Semantics semantics{
-        semanticsContext, parseTree, parsing.cooked()};
+    Fortran::semantics::Semantics semantics{semanticsContext, parseTree,
+        parsing.cooked(), driver.debugModuleWriter};
     semantics.Perform();
     semantics.EmitMessages(std::cerr);
     if (driver.dumpSymbols) {
@@ -493,6 +494,8 @@ int main(int argc, char *const argv[]) {
       driver.dumpSymbols = true;
     } else if (arg == "-fdebug-resolve-names") {
       driver.debugResolveNames = true;
+    } else if (arg == "-fdebug-module-writer") {
+      driver.debugModuleWriter = true;
     } else if (arg == "-fdebug-measure-parse-tree") {
       driver.measureTree = true;
     } else if (arg == "-fdebug-instrumented-parse") {

From a759204db583d337dda886acf748e0fe135c6259 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Mon, 24 Feb 2020 18:55:53 -0800
Subject: [PATCH 045/345] Allow for access-stmt before namelist-stmt

You can declare a name in an access statement and then declare it as
a namelist group name. We weren't allowing that because we didn't
convert a symbol with UnknownDetails to one with NamelistDetails.

Fixes #1022.
---
 lib/Semantics/resolve-names.cpp | 12 +++++-------
 test/Semantics/resolve40.f90    | 16 ++++++++++++++++
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 6b9402e7ae8b..f0cfd8f8269f 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -2957,7 +2957,7 @@ void DeclarationVisitor::Post(const parser::EntityDecl &x) {
     if (ConvertToObjectEntity(symbol)) {
       Initialization(name, *init, false);
     }
-  } else if (attrs.test(Attr::PARAMETER)) { // C882, C883
+  } else if (attrs.test(Attr::PARAMETER)) {  // C882, C883
     Say(name, "Missing initialization for parameter '%s'"_err_en_US);
   }
 }
@@ -3925,13 +3925,11 @@ bool DeclarationVisitor::Pre(const parser::NamelistStmt::Group &x) {
 
   const auto &groupName{std::get<parser::Name>(x.t)};
   auto *groupSymbol{FindInScope(currScope(), groupName)};
-  if (!groupSymbol) {
+  if (!groupSymbol || !groupSymbol->has<NamelistDetails>()) {
     groupSymbol = &MakeSymbol(groupName, std::move(details));
-  } else if (groupSymbol->has<NamelistDetails>()) {
-    groupSymbol->get<NamelistDetails>().add_objects(details.objects());
-  } else {
-    SayAlreadyDeclared(groupName, *groupSymbol);
+    groupSymbol->ReplaceName(groupName.source);
   }
+  groupSymbol->get<NamelistDetails>().add_objects(details.objects());
   return false;
 }
 
@@ -4408,7 +4406,7 @@ std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
       DerivedTypeDetails details;
       details.set_isForwardReferenced();
       symbol->set_details(std::move(details));
-    } else { // C883
+    } else {  // C883
       Say(name, "Derived type '%s' not found"_err_en_US);
       return std::nullopt;
     }
diff --git a/test/Semantics/resolve40.f90 b/test/Semantics/resolve40.f90
index 83522c62fff6..1137126740af 100644
--- a/test/Semantics/resolve40.f90
+++ b/test/Semantics/resolve40.f90
@@ -72,3 +72,19 @@ subroutine s9
   !ERROR: 'i' is already declared in this scoping unit
   data ((x(i,i),i=1,2),i=1,2)/4*0.0/
 end
+
+module m10
+  integer :: x
+  public :: nl
+  namelist /nl/ x
+end
+
+subroutine s11
+  integer :: nl2
+  !ERROR: 'nl2' is already declared in this scoping unit
+  namelist /nl2/x
+  namelist /nl3/x
+  !ERROR: 'nl3' is already declared in this scoping unit
+  integer :: nl3
+  nl2 = 1
+end

From a2b2a330e7dbb8d719fdab9bb28921cf84f503ca Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 25 Feb 2020 17:13:56 -0800
Subject: [PATCH 046/345] Fix misparsed structure constructor in data stmt

In a data statement like `data x / a(1) /`, `a(1)` may be an array
element or a structure constructor. It is parsed as an array element
so if it turns out `a` is a derived type it must be rewritten as a
strucutre constructor.
---
 include/flang/Parser/parse-tree.h |  2 ++
 include/flang/Parser/tools.h      |  3 +++
 lib/Parser/parse-tree.cpp         | 14 ++++++++++++++
 lib/Semantics/resolve-names.cpp   | 19 +++++++++++++++++++
 test/Semantics/data01.f90         | 31 ++++++++++++++++++++++---------
 5 files changed, 60 insertions(+), 9 deletions(-)

diff --git a/include/flang/Parser/parse-tree.h b/include/flang/Parser/parse-tree.h
index d7bb1f5686aa..1d93c13cada6 100644
--- a/include/flang/Parser/parse-tree.h
+++ b/include/flang/Parser/parse-tree.h
@@ -1818,6 +1818,8 @@ struct ArrayElement {
   ArrayElement(DataRef &&dr, std::list<SectionSubscript> &&ss)
     : base{std::move(dr)}, subscripts(std::move(ss)) {}
   Substring ConvertToSubstring();
+  StructureConstructor ConvertToStructureConstructor(
+      const semantics::DerivedTypeSpec &);
   DataRef base;
   std::list<SectionSubscript> subscripts;
 };
diff --git a/include/flang/Parser/tools.h b/include/flang/Parser/tools.h
index dcb503b31b79..9112cc4a4886 100644
--- a/include/flang/Parser/tools.h
+++ b/include/flang/Parser/tools.h
@@ -79,6 +79,9 @@ struct UnwrapperHelper {
 template<typename A, typename B> const A *Unwrap(const B &x) {
   return UnwrapperHelper::Unwrap<A>(x);
 }
+template<typename A, typename B> A *Unwrap(B &x) {
+  return const_cast<A *>(Unwrap<A, B>(const_cast<const B &>(x)));
+}
 
 // Get the CoindexedNamedObject if the entity is a coindexed object.
 const CoindexedNamedObject *GetCoindexedNamedObject(const AllocateObject &);
diff --git a/lib/Parser/parse-tree.cpp b/lib/Parser/parse-tree.cpp
index d0722aaa571c..181bf066c587 100644
--- a/lib/Parser/parse-tree.cpp
+++ b/lib/Parser/parse-tree.cpp
@@ -9,6 +9,7 @@
 #include "flang/Parser/parse-tree.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/indirection.h"
+#include "flang/Parser/tools.h"
 #include "flang/Parser/user-state.h"
 #include <algorithm>
 
@@ -186,6 +187,19 @@ StructureConstructor FunctionReference::ConvertToStructureConstructor(
   return StructureConstructor{std::move(spec), std::move(components)};
 }
 
+StructureConstructor ArrayElement::ConvertToStructureConstructor(
+    const semantics::DerivedTypeSpec &derived) {
+  Name name{std::get<parser::Name>(base.u)};
+  std::list<ComponentSpec> components;
+  for (auto &subscript : subscripts) {
+    components.emplace_back(std::optional<Keyword>{},
+        ComponentDataSource{std::move(*Unwrap<Expr>(subscript))});
+  }
+  DerivedTypeSpec spec{std::move(name), std::list<TypeParamSpec>{}};
+  spec.derivedTypeSpec = &derived;
+  return StructureConstructor{std::move(spec), std::move(components)};
+}
+
 Substring ArrayElement::ConvertToSubstring() {
   auto iter{subscripts.begin()};
   CHECK(iter != subscripts.end());
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index f0cfd8f8269f..7d6fa5d644da 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -948,6 +948,7 @@ class ConstructVisitor : public virtual DeclarationVisitor {
   bool Pre(const parser::AcImpliedDo &);
   bool Pre(const parser::DataImpliedDo &);
   bool Pre(const parser::DataStmtObject &);
+  bool Pre(const parser::DataStmtValue &);
   bool Pre(const parser::DoConstruct &);
   void Post(const parser::DoConstruct &);
   bool Pre(const parser::ForallConstruct &);
@@ -4687,6 +4688,24 @@ bool ConstructVisitor::Pre(const parser::DataStmtObject &x) {
   return false;
 }
 
+bool ConstructVisitor::Pre(const parser::DataStmtValue &x) {
+  const auto &data{std::get<parser::DataStmtConstant>(x.t)};
+  auto &mutableData{const_cast<parser::DataStmtConstant &>(data)};
+  if (auto *elem{parser::Unwrap<parser::ArrayElement>(mutableData)}) {
+    if (const auto *name{std::get_if<parser::Name>(&elem->base.u)}) {
+      if (const Symbol * symbol{FindSymbol(*name)}) {
+        if (const Symbol * ultimate{GetAssociationRoot(*symbol)}) {
+          if (ultimate->has<DerivedTypeDetails>()) {
+            mutableData.u = elem->ConvertToStructureConstructor(
+                DerivedTypeSpec{name->source, *ultimate});
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
 bool ConstructVisitor::Pre(const parser::DoConstruct &x) {
   if (x.IsDoConcurrent()) {
     PushScope(Scope::Kind::Block, nullptr);
diff --git a/test/Semantics/data01.f90 b/test/Semantics/data01.f90
index db978331d541..87861016c6c0 100644
--- a/test/Semantics/data01.f90
+++ b/test/Semantics/data01.f90
@@ -37,12 +37,25 @@ subroutine CheckRepeat
   DATA myName%age / digits(myAge) * 35 /
 end
 
-!subroutine CheckValue
-!  use m1
-!  !C883
-!  !ERROR: Derived type 'persn' not found
-!  DATA myname / persn(2, 'Abcd Efgh') /
-!  !C884
-!  !ERROR: Structure constructor in data value must be a constant expression
-!  DATA myname / person(myAge, 'Abcd Ijkl') /
-!end
+subroutine CheckValue
+  use m1
+  !OK: constant structure constructor
+  data myname / person(1, 'Abcd Ijkl') /
+  !C883
+  !ERROR: Must have INTEGER type, but is CHARACTER(1)
+  data myname / persn(2, 'Abcd Efgh') /
+  !C884
+  !ERROR: Structure constructor in data value must be a constant expression
+  data myname / person(myAge, 'Abcd Ijkl') /
+  integer, parameter :: a(5) =(/11, 22, 33, 44, 55/)
+  integer :: b(5) =(/11, 22, 33, 44, 55/)
+  integer :: i
+  integer :: x
+  !OK: constant array element
+  data x / a(1) /
+  !C886, C887
+  !ERROR: Must be a constant value
+  data x / a(i) /
+  !ERROR: Must be a constant value
+  data x / b(1) /
+end

From 7848ab146ad32062daba9f07b032655568381a1b Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 26 Feb 2020 02:01:02 -0800
Subject: [PATCH 047/345] Fix drone CI build failure due to lack of FileCheck

Simply use the llvm build directory and save installing LLVM on the way.
---
 .drone.star | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.drone.star b/.drone.star
index 7d09fdab0977..e5859e9efc2e 100644
--- a/.drone.star
+++ b/.drone.star
@@ -11,10 +11,10 @@ def clang(arch):
                     "git clone https://github.com/llvm/llvm-project",
                     "mkdir llvm-project/build && cd llvm-project/build",
                     'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="clang;mlir" ../llvm',
-                    "ninja install",
+                    "ninja",
                     "cd ../..",
                     "mkdir build && cd build",
-                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/build/lib/cmake/llvm',
                     "ninja -j8",
                     "ctest --output-on-failure -j24",
                     "ninja check-all",
@@ -37,10 +37,10 @@ def gcc(arch):
 		        "git clone https://github.com/llvm/llvm-project",
 		        "mkdir llvm-project/build && cd llvm-project/build",
 		        'env CC=gcc CXX=g++ LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="clang;mlir" ../llvm',
-                        "ninja install",
+                        "ninja",
                         "cd ../..",
                         "mkdir build && cd build",
-                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
+                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/build/lib/cmake/llvm',
                         "ninja -j8",
                         "ctest --output-on-failure -j24",
                         "ninja check-all",

From 5eaebc800caa90b592c5ba8cf1fd6fd3987b3636 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 26 Feb 2020 06:16:22 -0800
Subject: [PATCH 048/345] Remove clang from LLVM drone builds until needed to
 fasten builds

---
 .drone.star | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.drone.star b/.drone.star
index e5859e9efc2e..5bbe018cd056 100644
--- a/.drone.star
+++ b/.drone.star
@@ -10,7 +10,7 @@ def clang(arch):
                     "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-8-dev libc++-8-dev libc++abi-8-dev libz-dev git",
                     "git clone https://github.com/llvm/llvm-project",
                     "mkdir llvm-project/build && cd llvm-project/build",
-                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="clang;mlir" ../llvm',
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="mlir" ../llvm',
                     "ninja",
                     "cd ../..",
                     "mkdir build && cd build",
@@ -36,7 +36,7 @@ def gcc(arch):
 			"apt-get update && apt-get install -y cmake ninja-build llvm-dev libz-dev git",
 		        "git clone https://github.com/llvm/llvm-project",
 		        "mkdir llvm-project/build && cd llvm-project/build",
-		        'env CC=gcc CXX=g++ LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="clang;mlir" ../llvm',
+		        'env CC=gcc CXX=g++ LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="mlir" ../llvm',
                         "ninja",
                         "cd ../..",
                         "mkdir build && cd build",

From c95c45704e7c0afeb0d2dbec965afd368e923a3a Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Mon, 24 Feb 2020 17:04:54 -0800
Subject: [PATCH 049/345] Fix layout of 128-bit IEEE-754 floating-point values

---
 include/flang/Common/real.h       |   6 +-
 include/flang/Decimal/decimal.h   |   6 +-
 include/flang/Evaluate/complex.h  |   2 +-
 include/flang/Evaluate/real.h     |   2 +-
 include/flang/Evaluate/type.h     |   2 +-
 lib/Decimal/binary-to-decimal.cpp |   4 +-
 lib/Decimal/decimal-to-binary.cpp |   2 +-
 lib/Evaluate/complex.cpp          |   2 +-
 lib/Evaluate/real.cpp             |   2 +-
 test/Evaluate/folding07.f90       | 163 +++++++++++-------------------
 test/Semantics/modfile26.f90      |  18 ++--
 11 files changed, 80 insertions(+), 129 deletions(-)

diff --git a/include/flang/Common/real.h b/include/flang/Common/real.h
index 158482e6c5c1..4688e440a82d 100644
--- a/include/flang/Common/real.h
+++ b/include/flang/Common/real.h
@@ -26,7 +26,7 @@ static constexpr int BitsForBinaryPrecision(int binaryPrecision) {
   case 53: return 64;  // IEEE double precision: 1+11+52
   case 64: return 80;  // x87 extended precision: 1+15+64
   case 106: return 128;  // "double-double": 2*(1+11+52)
-  case 112: return 128;  // IEEE quad precision: 1+16+111
+  case 113: return 128;  // IEEE quad precision: 1+15+112
   default: return -1;
   }
 }
@@ -43,7 +43,7 @@ static constexpr int MaxDecimalConversionDigits(int binaryPrecision) {
   case 53: return 751;
   case 64: return 11495;
   case 106: return 2 * 751;
-  case 112: return 22981;
+  case 113: return 11530;
   default: return -1;
   }
 }
@@ -79,7 +79,7 @@ template<int BINARY_PRECISION> class RealDetails {
 
   static_assert(binaryPrecision > 0);
   static_assert(exponentBits > 1);
-  static_assert(exponentBits <= 16);
+  static_assert(exponentBits <= 15);
 };
 
 }
diff --git a/include/flang/Decimal/decimal.h b/include/flang/Decimal/decimal.h
index 1e792d78cc1f..5f80ab6f349f 100644
--- a/include/flang/Decimal/decimal.h
+++ b/include/flang/Decimal/decimal.h
@@ -92,9 +92,9 @@ extern template ConversionToDecimalResult ConvertToDecimal<53>(char *, size_t,
 extern template ConversionToDecimalResult ConvertToDecimal<64>(char *, size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<64>);
-extern template ConversionToDecimalResult ConvertToDecimal<112>(char *, size_t,
+extern template ConversionToDecimalResult ConvertToDecimal<113>(char *, size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
-    BinaryFloatingPointNumber<112>);
+    BinaryFloatingPointNumber<113>);
 
 template<int PREC> struct ConversionToBinaryResult {
   BinaryFloatingPointNumber<PREC> binary;
@@ -115,7 +115,7 @@ extern template ConversionToBinaryResult<53> ConvertToBinary<53>(
     const char *&, enum FortranRounding = RoundNearest);
 extern template ConversionToBinaryResult<64> ConvertToBinary<64>(
     const char *&, enum FortranRounding = RoundNearest);
-extern template ConversionToBinaryResult<112> ConvertToBinary<112>(
+extern template ConversionToBinaryResult<113> ConvertToBinary<113>(
     const char *&, enum FortranRounding = RoundNearest);
 }  // namespace Fortran::decimal
 extern "C" {
diff --git a/include/flang/Evaluate/complex.h b/include/flang/Evaluate/complex.h
index 417d4cfecbbd..370bcfbb5bce 100644
--- a/include/flang/Evaluate/complex.h
+++ b/include/flang/Evaluate/complex.h
@@ -96,6 +96,6 @@ extern template class Complex<Real<Integer<16>, 8>>;
 extern template class Complex<Real<Integer<32>, 24>>;
 extern template class Complex<Real<Integer<64>, 53>>;
 extern template class Complex<Real<Integer<80>, 64>>;
-extern template class Complex<Real<Integer<128>, 112>>;
+extern template class Complex<Real<Integer<128>, 113>>;
 }
 #endif  // FORTRAN_EVALUATE_COMPLEX_H_
diff --git a/include/flang/Evaluate/real.h b/include/flang/Evaluate/real.h
index 0624abd3ee93..fbb52086f0cb 100644
--- a/include/flang/Evaluate/real.h
+++ b/include/flang/Evaluate/real.h
@@ -367,7 +367,7 @@ extern template class Real<Integer<16>, 8>;  // the "other" half format
 extern template class Real<Integer<32>, 24>;  // IEEE single
 extern template class Real<Integer<64>, 53>;  // IEEE double
 extern template class Real<Integer<80>, 64>;  // 80387 extended precision
-extern template class Real<Integer<128>, 112>;  // IEEE quad
+extern template class Real<Integer<128>, 113>;  // IEEE quad
 // N.B. No "double-double" support.
 }
 #endif  // FORTRAN_EVALUATE_REAL_H_
diff --git a/include/flang/Evaluate/type.h b/include/flang/Evaluate/type.h
index 137cf66e9cd9..97700f30e29c 100644
--- a/include/flang/Evaluate/type.h
+++ b/include/flang/Evaluate/type.h
@@ -275,7 +275,7 @@ class Type<TypeCategory::Real, 10> : public TypeBase<TypeCategory::Real, 10> {
 template<>
 class Type<TypeCategory::Real, 16> : public TypeBase<TypeCategory::Real, 16> {
 public:
-  using Scalar = value::Real<value::Integer<128>, 112>;
+  using Scalar = value::Real<value::Integer<128>, 113>;
 };
 
 // The KIND type parameter on COMPLEX is the kind of each of its components.
diff --git a/lib/Decimal/binary-to-decimal.cpp b/lib/Decimal/binary-to-decimal.cpp
index 416d85097dda..f4e57681af95 100644
--- a/lib/Decimal/binary-to-decimal.cpp
+++ b/lib/Decimal/binary-to-decimal.cpp
@@ -370,9 +370,9 @@ template ConversionToDecimalResult ConvertToDecimal<53>(char *, std::size_t,
 template ConversionToDecimalResult ConvertToDecimal<64>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<64>);
-template ConversionToDecimalResult ConvertToDecimal<112>(char *, std::size_t,
+template ConversionToDecimalResult ConvertToDecimal<113>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
-    BinaryFloatingPointNumber<112>);
+    BinaryFloatingPointNumber<113>);
 
 extern "C" {
 ConversionToDecimalResult ConvertFloatToDecimal(char *buffer, std::size_t size,
diff --git a/lib/Decimal/decimal-to-binary.cpp b/lib/Decimal/decimal-to-binary.cpp
index 7deec9f101b2..586c7f869e80 100644
--- a/lib/Decimal/decimal-to-binary.cpp
+++ b/lib/Decimal/decimal-to-binary.cpp
@@ -399,7 +399,7 @@ template ConversionToBinaryResult<53> ConvertToBinary<53>(
     const char *&, enum FortranRounding);
 template ConversionToBinaryResult<64> ConvertToBinary<64>(
     const char *&, enum FortranRounding);
-template ConversionToBinaryResult<112> ConvertToBinary<112>(
+template ConversionToBinaryResult<113> ConvertToBinary<113>(
     const char *&, enum FortranRounding);
 
 extern "C" {
diff --git a/lib/Evaluate/complex.cpp b/lib/Evaluate/complex.cpp
index 8f03304b6b05..ebb3898dee90 100644
--- a/lib/Evaluate/complex.cpp
+++ b/lib/Evaluate/complex.cpp
@@ -101,5 +101,5 @@ template class Complex<Real<Integer<16>, 8>>;
 template class Complex<Real<Integer<32>, 24>>;
 template class Complex<Real<Integer<64>, 53>>;
 template class Complex<Real<Integer<80>, 64>>;
-template class Complex<Real<Integer<128>, 112>>;
+template class Complex<Real<Integer<128>, 113>>;
 }
diff --git a/lib/Evaluate/real.cpp b/lib/Evaluate/real.cpp
index 6f9a17c6262e..fe3b5821b676 100644
--- a/lib/Evaluate/real.cpp
+++ b/lib/Evaluate/real.cpp
@@ -520,5 +520,5 @@ template class Real<Integer<16>, 8>;
 template class Real<Integer<32>, 24>;
 template class Real<Integer<64>, 53>;
 template class Real<Integer<80>, 64>;
-template class Real<Integer<128>, 112>;
+template class Real<Integer<128>, 113>;
 }
diff --git a/test/Evaluate/folding07.f90 b/test/Evaluate/folding07.f90
index b0831472149e..b7e13eb027a3 100644
--- a/test/Evaluate/folding07.f90
+++ b/test/Evaluate/folding07.f90
@@ -29,8 +29,8 @@ module m
     deps10 = 5.42101086242752217003726400434970855712890625e-20_10
   real(16), parameter :: &
     eps16 = epsilon(0._16), &
-    zeps16 = real(z'3fc78000000000000000000000000000', kind=16), &
-    deps16 = 1.925929944387235853055977942584927318538101648215388195239938795566558837890625e-34_16
+    zeps16 = real(z'3f8e0000000000000000000000000000', kind=16), &
+    deps16 = 9.629649721936179265279889712924636592690508241076940976199693977832794189453125e-35_16
   logical, parameter :: test_eps2 = eps2 == zeps2 .and. eps2 == deps2
   logical, parameter :: test_eps3 = eps3 == zeps3 .and. eps3 == deps3
   logical, parameter :: test_eps4 = eps4 == zeps4 .and. eps4 == deps4
@@ -125,106 +125,57 @@ module m
                 &5325423859110896247108853858086888377772586485641459342621210866475884892600317623459607695088491496&
                 &6244415660441955208681198977024e4932_10
   real(16), parameter :: &
-    ahuge16 = huge(0._16), zahuge16 = real(z'7fff7fffffffffffffffffffffffffff', kind=16), &
-    dahuge16 = 1.4154610310449547890015530277449513287402522312014583583863873452370673496090517844595674241105526619&
-                &5316741942296713234339847173043444610109053451307461326030568532269393756935971597477179751917262481&
-                &9352114171249119710791528826008514763128252507906157761158330471593133360520566465839598159704790361&
-                &8052216473233827726396998249642738685081537609877654130679009320149945501056683481052234280369184890&
-                &5600784088324331956396165189067350444857059625918182061259630449033723034922117505897765689572130343&
-                &6442900178897829054258075776096285494374231192475505398864394612619318718669868907615189244643178364&
-                &9604710976258237438709882933414201622978713022975908448898269286373397175572572843473932165513894328&
-                &0948775427139028319745676136738066595818634893585336670047942640579585732561265895169788288873968502&
-                &3576409450602037731566868670343358720132085137732083365284366309191514754276902232302595183222780229&
-                &0333048746295176633732590892271134921001816237945675046107354701982076491636207145766942241484852876&
-                &8086489045974168028871375519412956556734569711277377659269966781151202506367906250771838987905542729&
-                &9602633739292957854646574862022345808897851021953319762924371865024136126553409742233338383148939476&
-                &2688819583034676283720590690321437702466211493942477839239904785467381975953431360199181632139817087&
-                &1675085388306946402985966654686374017597361994515490028221221197873309065711452256943483997268156661&
-                &4251522601981091437164454815585766387477985848066653010274015762006422743531061320328958737883350699&
-                &5010107953612418870689506323691217683866631324712647102533109103896945673048537987294807465898328021&
-                &0616399905018381133672495392016893435858086953047467302012798815167555583471558849452903240275817359&
-                &7412600246880120097460997601280569422971588083755852211710169314345911644907180640214262742781303093&
-                &6362054083426905944815062311426831879988031400740033624376500891481190403873103717439643860930434152&
-                &0077820977089318080209161337954445502789934971878811641353709185004519914977577688820318078268550811&
-                &9598842219332616175613533636799875893648266143272209859623766305070288663132625316020772779359622743&
-                &6981030373132763462837652106194804931955311030759723858460597094396859076238402414307660975253097132&
-                &8698643152225068610430793799791351450546432634372714107713137332348308355668038997851202770977262560&
-                &6860655592065973411067851629502656906251604510378685022379816969935014362348544555586522272088499721&
-                &9946444206136083948321352132790842341486712676660929539344838800833207748229649079300799848460228620&
-                &9317916049805688735829248332080887463530900166033204573480074339495592738215902398384614205016081150&
-                &6669327808418122123950416238344051511059531020385411336197538432312088162779143008762730602999224040&
-                &4412462631215227731882153726267258980995290409075434047558959478172735835465203332540303097147035552&
-                &5666711990525067812075528567351636372299669796556262498468798624564731519949881412251505923493700744&
-                &6335216604198320142967929437627737857666675125232132004943938027381035739733071077389290829983249430&
-                &9929671156285733762483649064261848981602065505963476296523983015653616082982446966218901161161205188&
-                &0573600170377567179171204447290536296387610124123253094661730508794512413417917215234868180985445947&
-                &4633611169558495590616526594210716678969741229385520704603028673106854460886311076850901072143976966&
-                &6670653340074110727042938673600505240289417987265120625262935190175503280434524070893838237104432038&
-                &7277721187068571883463249210788857422002436533794328830424210014284256017507940795564055131778982162&
-                &2057329034192487819427904384064457476669697518270041324739893645003100081320531996273644177857645536&
-                &8545042222437577676482965113248928599178769221842229576106346149044548609079571934297226553085916258&
-                &7592543596965131548109725448343837961730187194350398048494910675432603696794370092723457745633520895&
-                &5119608085204333293851879810252603015301753358273689011732017729549391344820270439201073177077719806&
-                &6340808266346052755156509338328217335355010644405352755527544829502078548861021691811911472766970454&
-                &1126722373686640238868728507802237164806166737169811286535298575549796654582990432275142847727629502&
-                &1305769671663557289499368071930128517595842219011940342211409668478145343257173098710205665337736566&
-                &7695994299658695511962006986219821529127829161089064469294254157734218514131756969922934643982128786&
-                &2715171334655164118356373428019349203374943169393056179361968313211330781317671346402999475798391627&
-                &7899704387839522461273739469298912609371545163597105274885675371149316619814184131715268620939484405&
-                &4032822037910079156926925384052248020095121565015480766860393059726428647308949687836979970427915464&
-                &4264625542574505988870728965217856989288717655724378129280385306319189930760735776751678832851307548&
-                &0329607523670401065187600417105444319087401626053234839268127494935061885924159151772184284570819457&
-                &9765358561330329205363145261773965226880523298786386620674889009587176503669008414757444001413680605&
-                &1851754109107612931858580108997222201353234246355066745929992414298433627776673565501154849803765982&
-                &3801743520677023503489041175120829329692997134458297062148957929737209809196458870294106726869032085&
-                &7789703094882329377767630717523835645468121709209222839288061729452480299859659067904004155322262027&
-                &4942016841932467005817058434662245916974636886994084629484965489954062257150707733514203824510029893&
-                &0740188138973309464198336206180093073990056649880937698690357135529391353848482852684893681528382991&
-                &0410280771732290741176568547605485911343042882835702704191107389084055677618161337761939546366170150&
-                &8064781253559946842752977101984760297902666892353040900170187885831791071277065381487511702153859041&
-                &5299813558768597766083566649688989266040033065035240732139305422496656316421603624955865828341705144&
-                &3447994139174194712038660873812088215000697427262799495041365132243338960326526617370362693352900229&
-                &5839660406183978610341744635787604399627725957535437386160926670026801543280519042677441316699480894&
-                &4875931667388354376924131257775463750780942146112953413750161644209045078267855172649330717659424934&
-                &8335712735674451357884496678904100317012827438683814373992652581881866811580622571804449391481344574&
-                &8721113352345494414054446470032427805567908094831174795204261577836387511406006137595003048602258126&
-                &7574174240943346072781646716338402483610109902716905722880495175295252854374708163967596343005823957&
-                &4178083920280304911846453277681629032012659221856535496262316447548683056149679053220966081343915763&
-                &6618388485315900488605284740175857970500838688820831776374452618973739739617720957620005981443081902&
-                &4300636730721404743123197614003206963487294419744356022978269747190299245009057165700504871383191949&
-                &4899374942288264992976945103110345290533057003941954989124658125216431980606017233763887218072751504&
-                &7096960229110614316970153571571481206941090011829947032962703662183625088631507092427471435324068470&
-                &0366844465251076175358580515701393054153420428006834812855173272409462525200355138959896149898062525&
-                &2210628999335118130478060363668307275831118339581618716511127649271497546196039918772873373199382754&
-                &6560828617244201387568777027698045385338478763220413303633453325803060889236256471072252843526783119&
-                &3479871927503164671562194351641764632839321378419898279406392257259948038445867866022404201010548148&
-                &7253397872999082316105642775727365630729430694476221318450355038042498725633142324796624876140016499&
-                &3630315406642793862426329905517326187048203464559341824317026461223979145994800153463344219940539205&
-                &8817280808635659115943320567223211441185330248489643784516019287510770248820455510778539577940252666&
-                &8183267612737208040264783872625984696777713170768969342562651487622257641705902318612115711079338922&
-                &2493638262892467174711936785452484818671226836798093117387826527910160787492368254620398137406505131&
-                &8731988042354812033108407558675436962949740512319483298252234589352170375247787814835721268045446829&
-                &2317117377251138299913201780559797753723849597826002363700794792393814430199924797858736790730058164&
-                &9952115153236795221485683501836480463808149826963803445797953052814946094155785057280525607436938816&
-                &8429022866291042876643873792538883921257534909031812560345020981065950461122018135436055807910398208&
-                &1484855520256575276221518623542883183408040492631138649359729684960991172376968732880996978620285511&
-                &8920978864722624039207631304837709254566567316280789050587533720412634195873847049653211138198244266&
-                &0719308767951120142177649511668883859734091231860247534722574046015100358565612400275756547152074564&
-                &1633137898850424421600859605265441281300920250103584929436220562511251780317859133490449800210440206&
-                &3981850043050466311875810414734973403058771563153667133211228742703665404508238629870510947427656995&
-                &8638542779689576904473234941595273107383541712176187177722929884736371754403934807195232649597205636&
-                &7221673933010790346005001099664009818203015805631886046528599114745693012019712138121354212324790087&
-                &6231390929321586247720337913367593147267683928201056451758630035154869092151561740273050582062026461&
-                &9572049643976530665071930187197763438414695944410131097851490700907933723704516209591343059105381927&
-                &6905146017463471917031994260130109135398832398868757935821801928877154665144538645512469367057022196&
-                &6054756561099772143655047379026794640167482518879370689566268763892362268011507829185486417838902115&
-                &2013045682596657873774794142783874686585931915497399076756434719515907361068265152702994177444969608&
-                &9592887399294629417678853384234804422154039327343881374143794048281132753541259730778406832518482134&
-                &4637540401952767039481570552371988138457076195431968762699987960258703705461489278791473966013233379&
-                &6757285178848543455309032854535650058524208397901319574386300684931853011117241480422198239039503450&
-                &5655663330591727042233318955458942000042598046293770136501981539240756523705635887060941113869993907&
-                &1751151952076710851450505936665537567847881544310871209165764039670118474872200059013387628379850978&
-                &2307116366065133838722169400801537852265629436915335433281339392e9864_16
+    ahuge16 = huge(0._16), zahuge16 = real(z'7ffeffffffffffffffffffffffffffff', kind=16), &
+    dahuge16 = 1.1897314953572317650857593266280070161964690526416940455296988842121635797553123923249740128484620735&
+                &2590203356474912685975526543357380446267269875194526149085346195872502126284586579940540449357468156&
+                &6096686172574953791792292256220777095858112702436475442537092608935138247345677279593806773692330094&
+                &6157461197257841728898925219399207576542048645656733564522472781522888677006389355954564966995114417&
+                &5290960687851325094831139688610052683309212868397475219226638679188087369434307734815556410166997113&
+                &8512786874753496996549221727686770196551512812712488289469952298031867469924683981576664562667786719&
+                &0614996396303416570983054252372208766646300878087672561828032202122199248523759030495209113959109189&
+                &2120527349676858811903011159301878936803923201167140417584510885470696521560577711351625740481881769&
+                &5075025715299705916714352103671782759119316034498392169720631800164034124698918142227577300459309880&
+                &4547151796062998955075830758511951858579711731676769660579988993526318854177162953020146688023840758&
+                &4603622660648014297759540713505037980864913015716402406031178690879637251033587351277479527574859541&
+                &7572920936651398752709055215663939505589207804914540432978557623565645991208599669097180808881920063&
+                &7227714312184890119222096790535459636284173260024397328029395243137866685140273814343210366365711716&
+                &7042358647275956123197079396783927914728272019537706060212263845788320480934171752680963925353944773&
+                &0280863675704796054050525162959099932535265586464682793821550087166946662209865086040990507131145474&
+                &2674110428395423227629949387596131127438371928396826762575553883728144908453957471281620658715882191&
+                &0888724011665136196205080002917629993882608241754751673226993047313326125892184551681523545535431045&
+                &8114528303607394526100730578774092094736822286015459361126642549541799645333882549670764145955017051&
+                &3308000612538651401801532119293614565003435147928902055320217600618822326157365533772949809740595905&
+                &2018796145979938674151302850593441045360348019238334932111517181105100410859283099181138255290906487&
+                &3029533418691087118107895004426881765865961841419267486232005929789956207494587649901662172318722999&
+                &4845123258260870315619363836897406865052797752967893316136838227985970406516005241290251498948731531&
+                &9694209505667084746692764481259650670012944357951247923062137397808873125708979962290218382410541293&
+                &0483065603459863120371744282301377070153823878609951218937542956964157950988060608985782910656238116&
+                &1422035741047574518281708048752574462041283485138290827317223641893804935883389476643706232798207558&
+                &3164620541748839306283820178954721954319445090211369992596537690819279215212221282457887933650687528&
+                &8617303469517112245451315447164280392523574962804175375927948971096983905242318797695347043690474223&
+                &8132665056397611644388442665313646268512196339944341540985621273959361844218214442734315345078601616&
+                &1428702272098406156966033337278824103713153807737748015267058325792053556997331818811268567331899796&
+                &7497786786001251403873023920127717626858627038170562807276699687356274072773403132694104831615879354&
+                &3958115858251128378415632227616233344591881315378823557324830300859768903829697344762145934281912127&
+                &1714133304757786755221851743106484876037319629031012446614508707837714052853304868420427879959665251&
+                &4009368964527494988719996088230065668196236298805733689960371306226158464997243490564472254071897564&
+                &1441285398399860960455632647712855850663041779957201017448443871583297673755604162078008788300720724&
+                &1390865785566723954636935777578134428819598917631335685641784543423281488674422674670706697975557712&
+                &1788798468777700116472954103621810567107869855646414713502627836321256957407217461738363552424248762&
+                &4364780853518109957492932381740813319050481446127009055414257022203025376114948242287653245779337785&
+                &1981877869734028258091278067497905893806255685600107605770598216668682475603756961576049761981948205&
+                &2758118532729333127733603742149847001463931981340719681330844408263017545241644293372483217234561694&
+                &2639378557592944486629790954192274518015884259778696940266014279196551684158959230431151917518727133&
+                &4609575263460825447598815416225495259785319903964588374219923638761039583094807436598839770784963225&
+                &2080920941206268114832425403540515474312327876180802357701527842702008781378306569508588571830140611&
+                &0980426830095308627974030153554643774062498539644810004022317716657008936075218040845236685686491032&
+                &5886266629337247244143556352059546170104239050079561583450594483732665254246744436486149918427509748&
+                &5253621979537504128523848241127715641240965261646703516395599407360083455079665191393229410544185167&
+                &9990997876554244625589008743884056491694537267393122602348155432978423086460721901479480729284567258&
+                &3503954612118213364077776992584180757905173583882311275962271406750966991364528828189455892561297242&
+                &5252452248453502562347348900936766966136332741088135837550717443838484760651019872222926016920811114&
+                &6169371432077434885046020127763642567468723152059526010722289706864609324352227544963417635351891055&
+                &48847634608972381760403137363968e4932_16
   logical, parameter :: test_ahuge2 = ahuge2 == zahuge2 .and. ahuge2 == dahuge2
   logical, parameter :: test_ahuge3 = ahuge3 == zahuge3 .and. ahuge3 == dahuge3
   logical, parameter :: test_ahuge4 = ahuge4 == zahuge4 .and. ahuge4 == dahuge4
@@ -237,7 +188,7 @@ module m
   real(4), parameter :: tiny4 = tiny(0._4), ztiny4 = real(z'00800000', kind=4)
   real(8), parameter :: tiny8 = tiny(0._8), ztiny8 = real(z'0010000000000000', kind=8)
   real(10), parameter :: tiny10 = tiny(0._10), ztiny10 = real(z'00018000000000000000', kind=10)
-  real(16), parameter :: tiny16 = tiny(0._16), ztiny16 = real(z'00008000000000000000000000000000', kind=16)
+  real(16), parameter :: tiny16 = tiny(0._16), ztiny16 = real(z'00010000000000000000000000000000', kind=16)
   logical, parameter :: test_tiny2 = tiny2 == ztiny2
   logical, parameter :: test_tiny3 = tiny3 == ztiny3
   logical, parameter :: test_tiny4 = tiny4 == ztiny4
@@ -257,7 +208,7 @@ module m
   logical, parameter :: test_max4 = max4 == 127
   logical, parameter :: test_max8 = max8 == 1023
   logical, parameter :: test_max10 = max10 == 16383
-  logical, parameter :: test_max16 = max16 == 32767
+  logical, parameter :: test_max16 = max16 == 16383
 
   integer, parameter :: &
     min2 = minexponent(0._2), &
@@ -271,7 +222,7 @@ module m
   logical, parameter :: test_min4 = min4 == -126
   logical, parameter :: test_min8 = min8 == -1022
   logical, parameter :: test_min10 = min10 == -16382
-  logical, parameter :: test_min16 = min16 == -32766
+  logical, parameter :: test_min16 = min16 == -16382
 
   integer, parameter :: &
     irange1 = range(0_1), &
@@ -297,6 +248,6 @@ module m
   logical, parameter :: test_zrange4 = arange4 == 37 .and. zrange4 == 37
   logical, parameter :: test_zrange8 = arange8 == 307 .and. zrange8 == 307
   logical, parameter :: test_zrange10 = arange10 == 4931 .and. zrange10 == 4931
-  logical, parameter :: test_zrange16 = arange16 == 9863 .and. zrange16 == 9863
+  logical, parameter :: test_zrange16 = arange16 == 4931 .and. zrange16 == 4931
 
 end module
diff --git a/test/Semantics/modfile26.f90 b/test/Semantics/modfile26.f90
index 90553104b8f1..44d43c6ca788 100644
--- a/test/Semantics/modfile26.f90
+++ b/test/Semantics/modfile26.f90
@@ -36,18 +36,18 @@ module m1
   ! REAL(KIND=4)  handles  5 <= R < 38 (if no KIND=3)
   ! REAL(KIND=8)  handles 38 <= R < 308
   ! REAL(KIND=10) handles 308 <= R < 4932 (if available; ifort is KIND=16)
-  ! REAL(KIND=16) handles 4932 <= R < 9864 (except Power double/double)
+  ! REAL(KIND=16) handles 308 <= R < 4932 (except Power double/double)
   integer, parameter :: realranges(*) = &
     [range(0._2), range(0._3), range(0._4), range(0._8), range(0._10), &
      range(0._16)]
   logical, parameter :: rrangecheck = &
-    all([4, 37, 37, 307, 4931, 9863] == realranges)
+    all([4, 37, 37, 307, 4931, 4931] == realranges)
   integer, parameter :: realrvals(*) = &
-    [0, 4, 5, 37, 38, 307, 308, 4931, 4932, 9863, 9864]
+    [0, 4, 5, 37, 38, 307, 308, 4931, 4932]
   integer, parameter :: realrkinds(*) = &
     [(selected_real_kind(0,realrvals(j)),j=1,size(realrvals))]
   logical, parameter :: realrcheck = &
-    all([2, 2, 3, 3, 8, 8, 10, 10, 16, 16, -2] == realrkinds)
+    all([2, 2, 3, 3, 8, 8, 10, 10, -2] == realrkinds)
   logical, parameter :: radixcheck = &
     all([radix(0._2), radix(0._3), radix(0._4), radix(0._8), &
          radix(0._10), radix(0._16)] == 2)
@@ -59,7 +59,7 @@ module m1
     [digits(0._2), digits(0._3), digits(0._4), digits(0._8), digits(0._10), &
      digits(0._16)]
   logical, parameter :: realdigitscheck = &
-    all([11, 8, 24, 53, 64, 112] == realdigits)
+    all([11, 8, 24, 53, 64, 113] == realdigits)
 end module m1
 !Expect: m1.mod
 !module m1
@@ -74,14 +74,14 @@ end module m1
 !integer(4),parameter::realpvals(1_8:*)=[INTEGER(4)::0_4,3_4,4_4,6_4,7_4,15_4,16_4,18_4,19_4,33_4,34_4]
 !integer(4),parameter::realpkinds(1_8:*)=[INTEGER(4)::2_4,2_4,4_4,4_4,8_4,8_4,10_4,10_4,16_4,16_4,-1_4]
 !logical(4),parameter::realpcheck=.true._4
-!integer(4),parameter::realranges(1_8:*)=[INTEGER(4)::4_4,37_4,37_4,307_4,4931_4,9863_4]
+!integer(4),parameter::realranges(1_8:*)=[INTEGER(4)::4_4,37_4,37_4,307_4,4931_4,4931_4]
 !logical(4),parameter::rrangecheck=.true._4
-!integer(4),parameter::realrvals(1_8:*)=[INTEGER(4)::0_4,4_4,5_4,37_4,38_4,307_4,308_4,4931_4,4932_4,9863_4,9864_4]
-!integer(4),parameter::realrkinds(1_8:*)=[INTEGER(4)::2_4,2_4,3_4,3_4,8_4,8_4,10_4,10_4,16_4,16_4,-2_4]
+!integer(4),parameter::realrvals(1_8:*)=[INTEGER(4)::0_4,4_4,5_4,37_4,38_4,307_4,308_4,4931_4,4932_4]
+!integer(4),parameter::realrkinds(1_8:*)=[INTEGER(4)::2_4,2_4,3_4,3_4,8_4,8_4,10_4,10_4,-2_4]
 !logical(4),parameter::realrcheck=.true._4
 !logical(4),parameter::radixcheck=.true._4
 !integer(4),parameter::intdigits(1_8:*)=[INTEGER(4)::7_4,15_4,31_4,63_4,127_4]
 !logical(4),parameter::intdigitscheck=.true._4
-!integer(4),parameter::realdigits(1_8:*)=[INTEGER(4)::11_4,8_4,24_4,53_4,64_4,112_4]
+!integer(4),parameter::realdigits(1_8:*)=[INTEGER(4)::11_4,8_4,24_4,53_4,64_4,113_4]
 !logical(4),parameter::realdigitscheck=.true._4
 !end

From d9871fa9eb2304c4761a4a818187553396bb8924 Mon Sep 17 00:00:00 2001
From: Peter Waller <peter.waller@arm.com>
Date: Wed, 26 Feb 2020 19:50:43 +0000
Subject: [PATCH 050/345] Add script to flatten git history for llvm monorepo
 submission (#854)

This script, when run on a checkout of the f18 repository, takes the
current origin/master and makes a branch called "new" with a rewritten
history;

The "new" branch has a flat git history (that is, a series of commits
with only one parent). Flattening is done for merge commits by taking
the content of the commit as it is at the merge commit.
---
 flatten.cpp | 916 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 916 insertions(+)
 create mode 100644 flatten.cpp

diff --git a/flatten.cpp b/flatten.cpp
new file mode 100644
index 000000000000..302bebaa0bad
--- /dev/null
+++ b/flatten.cpp
@@ -0,0 +1,916 @@
+// Copyright (c) 2019, Arm Ltd.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Reminder: no warranty with this program. I recommend using a fresh checkout.
+
+// Compile with:
+//   clang++ -Wall -Werror -O2 flatten.cpp -lgit2
+// Run with f18 in PWD or argv[1]:
+//   time ./a.out ~/.local/src/github.com/flang-compiler/f18/
+
+// To get a rewritten history, do this:
+//
+//   sudo apt install -y libgit2-dev # or equivalent
+//   git clone https://github.com/flang-compiler/f18
+//   git remote add llvm-project https://github.com/llvm/llvm-project
+//   git fetch llvm-project
+//   clang++ -DREPLACE_REFERENCES -Wall -Werror -O2 flatten.cpp -lgit2
+//   ./a.out
+
+// Inputs:
+// * a ref called origin/master, representing f18 history
+// * (optionally) a ref called llvm-project/master, representing llvm upstream
+// * (optionally) branches called rebase-{12 digit merge sha}, representing the
+//   manual rebase of tricky cases.
+//
+// Outputs:
+// * A branch called rewritten-history-v2, with a linearized f18 history.
+// * A branch called rewritten-history-v2-llvm-project-merge, representing the
+//   renaming of the project under /flang/ and taking llvm-project/master as the
+//   new parent for the (original) root commit.
+//
+// This program is meant to be idempotent and should not write to the working
+// directory, it simply takes refs as input and produces them as output.
+
+// Key concepts:
+//
+// * The checkout that git gives you for a commit is called a "tree", which is
+//   determined by a recursive checksum of the directory structure. If two
+//   commits have the same tree ("treesame"), then they are by definition
+//   equivalent when you check them out.
+//
+// * Lineage of the "master" branch is taken by following the first parents of
+//   each commit. To see this in git log, run `git log --first-parent`. This
+//   effectively ignores the second-parent history (i.e. commits that happened
+//   on branches).
+//
+// * By construction it is arranged that the trees of the first-parent history
+//   are preserved. This means "the code on the master branch is the same before
+//   and after rewrite".
+//
+// * Preserving the non-first-parent commits is trickier, and requires a rebase.
+//
+// * If nothing changed on the master branch during a feature branch, a rebase
+//   will not change the trees of the feature branch, so trees of those commits
+//   will still be the same. It's like rewriting the merge as a fast-forward.
+//
+// * However, if something happened on the master branch during the feature
+//   branch, then a rebase *must* create new trees. This implies code which
+//   might not build. As an example, imagine a case where a class is renamed on
+//   master, and the old name is used in the feature branch (until it's fixed at
+//   some point by the time it is merged).
+//
+// * By the end of the rebase, we assert that the trees are the same as those
+//   merged into master. So code in the middle of the rebased feature branch may
+//   not build, but at least the overall result of the feature branch will be as
+//   good as master was. Thankfully this is relatively rare.
+//
+// * If a branch exists called rebase-{sha of merge commit}, that branch is
+//   substituted in place of the merge commit. This allows manually rebasing
+//   tricky merges.
+//
+// * For the non-treesame, we can take a second-order diff (diff-of-diff)
+//   comparing those commits before and after rewrite, and ensure that only line
+//   numbers and context changed. This is almost totally the case.
+
+// Using the following script, it is possible to see whether non-TREESAME
+// patches still have the same diff, modulo blank lines, by taking a
+// second-order diff.
+//
+// git log --grep=TREESAME --invert-grep  --format="%h %(trailers:key=Original-commit)" rewritten-history-v2 |
+//   sed -n 's|Original-commit: flang-compiler/f18@||p' |
+//   while read NEW ORIG
+//   do
+//     echo ORIG NEW: $ORIG $NEW
+//     git show $ORIG > a
+//     git show $NEW > b
+//     sed -r -i \
+//       -e 's/@@ .* @@/@@ Numbers @@/g' \
+//       -e '/^(commit|index) .*/d' \
+//       -e '/Original-commit.*/d' \
+//       -e '/^\s$/d' \
+//        a b
+//     git diff --color --no-index a b
+//   done |& less -SR
+
+#include <array>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <sstream>
+
+#ifndef NO_REPLACE_REFERENCES
+#include <regex>
+#endif
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <git2.h>
+#include <git2/sys/commit.h>
+
+void check(int error, const char *message, const char *extra) {
+    const git_error *err;
+    const char *msg = "", *spacer = "";
+
+    if (!error)
+        return;
+
+    if ((err = giterr_last()) != NULL && err->message != NULL) {
+        msg = err->message;
+        spacer = " - ";
+    }
+
+    if (extra)
+        fprintf(stderr, "%s '%s' [%d]%s%s\n", message, extra, error, spacer, msg);
+    else
+        fprintf(stderr, "%s [%d]%s%s\n", message, error, spacer, msg);
+
+    exit(1);
+}
+
+int n_conflicts = 0, n_discards = 0;
+
+// Copy src string to dst string, rewriting issue references.
+char *rewrite_issue_references(char *dst, const char *src) {
+#ifndef NO_REPLACE_REFERENCES
+    const char *src_end = src + strlen(src);
+    // return src_end;
+    char *new_end = std::regex_replace(
+        dst, src, src_end,
+        std::regex("(^|\\b[^a-zA-Z0-9]+)(#[0-9]+)\\b"),
+        "$1flang-compiler/f18$2");
+    *new_end = '\0';
+    return new_end;
+#else
+    return stpcpy(dst, src);
+#endif
+}
+
+// test_rewrite_issue_references runs some test cases thorugh the string
+// replacement machinery and aborts if anything is awry.
+void test_rewrite_issue_references() {
+    #ifdef NO_REPLACE_REFERENCES
+        return;
+    #endif
+    struct { const char *input, *want; } tests[] = {
+        {"foo#123", "foo#123"},
+        {"Test #123bar", "Test #123bar"},
+        // Special case.
+        // {"commit message #123", "commit message #123"},
+
+        {"#123", "flang-compiler/f18#123"},
+        {"Test #123", "Test flang-compiler/f18#123"},
+        {"Test #123", "Test flang-compiler/f18#123"},
+        {"Test (#123)", "Test (flang-compiler/f18#123)"},
+    };
+
+    bool fail = false;
+    for (const auto test : tests) {
+        char *x = (char*)malloc(1024);
+        const char *new_end = rewrite_issue_references(x, test.input);
+        if (strcmp(x, test.want)) {
+            fprintf(stderr, "Got : %s\n", x);
+            fprintf(stderr, "Want: %s\n", test.want);
+            fail = true;
+        }
+        if (new_end != x + strlen(x)) {
+            abort();
+        }
+        (void)new_end;
+        free((void*)x);
+    }
+    if (fail)
+        abort();
+}
+
+static const char mergemsg_prefix[] = "Merge pull request #";
+
+// has_merge_pr_prefix returns true if the commit message begins "Merge pull
+// request #".
+bool has_merge_pr_prefix(const char* msg) {
+    int len = sizeof(mergemsg_prefix)-1;
+    if (strlen(msg) < len)
+        len = strlen(msg);
+    return !strncmp(mergemsg_prefix, msg, len);
+}
+
+// tweak_commit_message
+// Prepend [flang-compiler/f18#PRNUM]
+// Append "Original-commit", "Reviewed-on" and "Tree-same-pre-rewrite".
+//
+// Allocates a new commit message. Return value must be freed.
+// The Reviewed-on trailer URL is determined by "Merge pull request #(number)",
+// if present.
+char *tweak_commit_message(git_commit *orig_commit, git_commit *orig_merge, const git_oid *new_tree) {
+    const char *orig_msg = git_commit_message_raw(orig_commit);
+    const char *prnum = NULL, *prnum_end = NULL;
+
+    // If the message indicates a PR, store in prnum.
+    if (orig_merge != NULL && has_merge_pr_prefix(git_commit_message(orig_merge))) {
+        const char *mergemsg = git_commit_message_raw(orig_merge);
+        prnum = mergemsg + sizeof(mergemsg_prefix) - 1;
+        prnum_end = strchr(prnum, ' ');
+    }
+
+    #ifndef NO_REPLACE_REFERENCES
+    // Match "foo bar baz (#123)", which is the convention for "Squash" commit
+    // merges on GitHub.
+    static std::regex prnum_re("^(.*\\(#)([0-9]+)\\)$");
+    std::cmatch match;
+    if (std::regex_match(git_commit_summary(orig_merge), match, prnum_re)) {
+        const char *summary = git_commit_summary(orig_merge);
+        prnum = summary + match.length(1);
+        prnum_end = prnum + match.length(2);
+    }
+    #endif
+
+    // Gratuitous space for appending things.
+    const ssize_t extra_space = 102400;
+    ssize_t size = strlen(orig_msg) + extra_space;
+    char *newmsg_start = (char*)malloc(size);
+    char *newmsg_end = newmsg_start + (size);
+    char *newmsg = newmsg_start; // Pointer tracks the current write position.
+    newmsg[0] = 0;
+
+    // Set to leave message unmodified except for Original-commit, useful for
+    // verifying second-order diffs.
+    const bool use_original_message = false;
+    if (use_original_message) {
+        // These are here to indicate if the checkouts are the same as a commit and/or a merge.
+        if (git_oid_equal(git_commit_tree_id(orig_merge), new_tree)) {
+            newmsg = stpncpy(newmsg, "[TREESAME master] ", newmsg_end - newmsg);
+        } else if (git_oid_equal(git_commit_tree_id(orig_commit), new_tree)) {
+            newmsg = stpncpy(newmsg, "[TREESAME commit] ", newmsg_end - newmsg);
+        }
+
+        newmsg = stpcpy(newmsg, orig_msg);
+
+        // From here on out, append trailer headers.
+        char buf[GIT_OID_HEXSZ+1] = {};
+        newmsg = stpncpy(newmsg, "\n\nOriginal-commit: flang-compiler/f18@", newmsg_end - newmsg);
+        git_oid_fmt(buf, git_commit_id(orig_commit));
+        newmsg = stpncpy(newmsg, buf, newmsg_end - newmsg);
+        newmsg = stpncpy(newmsg, "\n", newmsg_end - newmsg);
+        return newmsg_start;
+    }
+
+    // Prepend [Flang] tag.
+    newmsg = stpncpy(newmsg, "[Flang] ", newmsg_end - newmsg);
+
+    // Paste in the original message, rewriting references #123 => flang-compiler/f18#123
+    newmsg = rewrite_issue_references(newmsg, orig_msg);
+
+    // If there is a newline at the end, remove it; subsequent insertion of the
+    // Original-commit header will always insert it. This ensures consistent
+    // spacing before the header.
+    while (newmsg[-1] == '\n') {
+        newmsg[-1] = 0;
+        newmsg--;
+    }
+
+    // From here on out, append trailer headers.
+    char buf[GIT_OID_HEXSZ+1] = {};
+    newmsg = stpncpy(newmsg, "\n\nOriginal-commit: flang-compiler/f18@", newmsg_end - newmsg);
+    git_oid_fmt(buf, git_commit_id(orig_commit));
+    newmsg = stpncpy(newmsg, buf, newmsg_end - newmsg);
+    newmsg = stpncpy(newmsg, "\n", newmsg_end - newmsg);
+
+    if (prnum != NULL) {
+        newmsg = stpncpy(newmsg, "Reviewed-on: https://github.com/flang-compiler/f18/pull/", newmsg_end - newmsg);
+        newmsg = stpncpy(newmsg, prnum, prnum_end - prnum);
+        newmsg = stpncpy(newmsg, "\n", newmsg_end - newmsg);
+    }
+
+    if (!git_oid_equal(git_commit_tree_id(orig_merge), new_tree)) {
+        // If this is present, then the contents of the tree are identical pre-
+        // and post- merge. If it is not present, then the patch was rebased.
+        newmsg = stpncpy(newmsg, "Tree-same-pre-rewrite: false\n", newmsg_end - newmsg);
+    }
+
+    return newmsg_start;
+}
+
+// insert_flang_directory sets new_root to a newly created tree with one entry
+// in it: /flang/, which points at orig_root.
+void insert_flang_directory(git_repository *repo, git_oid *new_root, const git_oid *orig_root) {
+    git_treebuilder *tb;
+    check(git_treebuilder_new(&tb, repo, NULL), "git_treebuilder_new", NULL);
+    const git_tree_entry *te;
+    git_treebuilder_insert(&te, tb, "flang", orig_root, GIT_FILEMODE_TREE);
+    git_treebuilder_write(new_root, tb);
+    git_treebuilder_free(tb);
+}
+
+// count_branch_commits counts the number of on-branch (non-merge) commits in
+// the given merge.
+int count_branch_commits(git_commit *merge) {
+    git_revwalk *walk;
+    check(git_revwalk_new(&walk, git_commit_owner(merge)), "git_revwalk_new", NULL);
+    check(git_revwalk_hide(walk, git_commit_parent_id(merge, 0)), "git_revwalk_hide", NULL);
+    check(git_revwalk_push(walk, git_commit_parent_id(merge, 1)), "git_revwalk_push", NULL);
+
+    git_oid commit_oid;
+    int n = 0;
+    while (!git_revwalk_next(&commit_oid, walk))
+        n++;
+
+    git_revwalk_free(walk);
+    return n;
+}
+
+// tree_for_commit grabs the git_oid pointing to the tree for a given commit_id.
+git_oid tree_for_commit(git_repository *repo, const git_oid *commit_id) {
+    git_commit *c;
+    check(git_commit_lookup(&c, repo, commit_id), "git_commit_lookup", NULL);
+    git_oid tree_id;
+    git_oid_cpy(&tree_id, git_commit_tree_id(c));
+    git_commit_free(c);
+    // git_commit_
+    return tree_id;
+}
+
+// generate_authortime_to_commit_map walks the commits on the second-parent
+// history of the given `merge`, computing a mapping from the author time to the
+// original commit id. Since this is scoped to feature-branch commits, there are
+// not likely to be collisions.
+void generate_authortime_to_commit_map(std::map<git_time_t, git_oid> &authortime_to_commit, git_commit *merge) {
+    git_repository *repo = git_commit_owner(merge);
+    git_revwalk *walk;
+    check(git_revwalk_new(&walk, git_commit_owner(merge)), "git_revwalk_new", NULL);
+    check(git_revwalk_hide(walk, git_commit_parent_id(merge, 0)), "git_revwalk_hide", NULL);
+    check(git_revwalk_push(walk, git_commit_parent_id(merge, 1)), "git_revwalk_push", NULL);
+
+    // Only walk first parent history on the grounds that most of those which
+    // introduce commits not-already-on-mainline are accidental merges of
+    // rebases, duplicating patches in history. Where patches are missed, they
+    // won't have an entry in the authortime_to_commit.
+    git_revwalk_simplify_first_parent(walk);
+
+    git_oid commit_id;
+    while (!git_revwalk_next(&commit_id, walk)) {
+        git_commit *c;
+        check(git_commit_lookup(&c, repo, &commit_id), "git_commit_lookup", NULL);
+        int when = git_commit_author(c)->when.time;
+
+        if (authortime_to_commit.count(when) != 0) {
+            char buf[GIT_OID_HEXSZ+1] = {};
+            git_oid_nfmt(buf, 12, &commit_id);
+            char buf1[GIT_OID_HEXSZ+1] = {};
+            git_oid_nfmt(buf1, 12, git_commit_id(merge));
+            char buf2[GIT_OID_HEXSZ+1] = {};
+            git_oid_nfmt(buf2, 12, &authortime_to_commit[when]);
+            printf("Hit duplicate commit considering %s "
+                   "(merge %s, duplicate %s)\n", buf, buf1, buf2);
+            // Duplicate author times. Need another strategy.
+            abort();
+        }
+        authortime_to_commit[when] = commit_id;
+        git_commit_free(c);
+    }
+
+    git_revwalk_free(walk);
+}
+
+// try_rebase attempts to rebase orig_merge onto the new history.
+// It returns true if the rebase succeeds without conflicts, and false otherwise.
+// On success, new_head is set to the tip of the rebase.
+bool try_rebase(git_oid **new_head, git_commit *orig_merge) {
+    git_repository *repo = git_commit_owner(orig_merge);
+    const git_oid *p0 = git_commit_parent_id(orig_merge, 0);
+    const git_oid *p1 = git_commit_parent_id(orig_merge, 1);
+
+    git_annotated_commit *p0a, *p1a, *new_heada;
+    check(git_annotated_commit_lookup(&p0a, repo, p0), "git_annotated_commit_lookup p0", NULL);
+    check(git_annotated_commit_lookup(&p1a, repo, p1), "git_annotated_commit_lookup p1", NULL);
+    check(git_annotated_commit_lookup(&new_heada, repo, *new_head), "git_annotated_commit_lookup new_head", NULL);
+
+    char buf[] = "refs/heads/rebase-0123456789ab\0";
+    git_oid_nfmt(buf+sizeof("refs/heads/rebase-")-1, 12, git_commit_id(orig_merge));
+
+    bool using_manual_rebase = false;
+
+    // Look for a branch called rebase-[12 digit SHA]. If it exists and is
+    // tree-same to the merge, treat it as the branch we're trying to rebase.
+    git_reference *manual_rebase;
+    int err = git_reference_lookup(&manual_rebase, repo, buf);
+    switch (err) {
+    case 0: { // Reference found.
+        const git_oid manual_tree = tree_for_commit(repo, git_reference_target(manual_rebase));
+
+        if (0 == git_oid_cmp(
+                git_reference_target(manual_rebase),
+                git_commit_id(orig_merge))) {
+            printf("Skip %s because it's pointing at the merge.\n", buf);
+            goto manual_rebase_unusable;
+        }
+        if (0 != git_oid_cmp(&manual_tree, git_commit_tree_id(orig_merge))) {
+            printf("Skip %s because the tip of the rebase is not "
+                   "treesame to the merge commit\n", buf);
+            goto manual_rebase_unusable;
+        }
+        printf("Using manual rebase branch %s\n", buf);
+        using_manual_rebase = true;
+
+        // Update p1a, the commits being rebased, to point at the branch.
+        // Then rebase, and this shouldn't result in any conflicts.
+        git_annotated_commit_free(p1a);
+        git_annotated_commit_lookup(&p1a, repo, git_reference_target(manual_rebase));
+
+    manual_rebase_unusable:
+        git_reference_free(manual_rebase);
+
+        break;
+    }
+    case GIT_ENOTFOUND:
+        // printf("Rebase branch %s not found.\n", buf);
+        break;
+    default:
+        check(err, "git_reference_lookup rebase-...", NULL);
+    }
+
+    git_rebase_options rb_opts;
+    check(git_rebase_init_options(&rb_opts, GIT_REBASE_OPTIONS_VERSION), "git_rebase_init_options", NULL);
+    rb_opts.inmemory = 1;
+    rb_opts.merge_options.flags = GIT_MERGE_FIND_RENAMES;
+    rb_opts.merge_options.rename_threshold = 50;
+
+    git_rebase *rb;
+    check(git_rebase_init(&rb, repo, p1a, p0a, new_heada, &rb_opts), "git_rebase_init", NULL);
+
+    bool is_success = true; // becomes false if conflicts encountered.
+    bool committed_at_least_one_patch = false;
+    git_oid rebase_tip_id;
+    git_oid_cpy(&rebase_tip_id, *new_head);
+
+    std::map<git_time_t, git_oid> authortime_to_commit;
+    if (using_manual_rebase) {
+        generate_authortime_to_commit_map(authortime_to_commit, orig_merge);
+    }
+
+    // Loop over each patch in the rebase, committing it.
+    git_rebase_operation *op;
+    while (!git_rebase_next(&op, rb)) {
+        git_index *idx;
+        check(git_rebase_inmemory_index(&idx, rb), "git_rebase_inmemory_index", NULL);
+        if (git_index_has_conflicts(idx)) {
+            // Conflicting case. Print a useful message.
+            char buf_patch[GIT_OID_HEXSZ+1] = {};
+            char buf_merge[GIT_OID_HEXSZ+1] = {};
+            git_oid_nfmt(buf_patch, 12, &op->id);
+            git_oid_nfmt(buf_merge, 12, git_commit_id(orig_merge));
+
+            int discarded = count_branch_commits(orig_merge);
+            printf("Conflicts encountered; patch=%s merge=%s - discarding %d commits\n", buf_patch, buf_merge, discarded);
+            printf("  M=%s; git checkout -B rebase-${M} ${M}^2; git rebase ${M}^1\n", buf_merge);
+
+            n_conflicts++;
+            n_discards += discarded;
+
+            git_index_free(idx);
+            is_success = false;
+            // If conflicts are found, abort, fall back to taking the merge
+            // commit.
+            break;
+        }
+        git_index_free(idx);
+
+        git_commit *orig_commit;
+        check(git_commit_lookup(&orig_commit, repo, &op->id), "git_commit_lookup", NULL);
+
+        // Generate the new tree now (as opposed to within git_rebase_commit) so that it can be used for TREESAME
+        // diagnostics in the commit message.
+        git_oid new_tree;
+        check(git_index_write_tree_to(&new_tree, idx, repo), "git_index_write_tree_to", NULL);
+
+        if (using_manual_rebase) {
+            // If in a manual rebase, need to lookup original patch.
+            // Use the author timestamp as a heuristic for patch equality.
+            const git_time_t when = git_commit_author(orig_commit)->when.time;
+            git_oid pre_rebase_commit_id = {};
+            if (when == 1518039228) { // Wed Feb 7 13:33:48 2018 -0800
+                // Hack for a single special case, a commit which was merged.
+                check(git_oid_fromstr(&pre_rebase_commit_id, "044148ead21f18e16716d5bc30819525c79065d0"), "git_oid_fromstr", NULL);
+            } else if (authortime_to_commit.count(when) == 0) {
+                char buf[GIT_OID_HEXSZ+1] = {};
+                git_oid_nfmt(buf, 12, &op->id);
+                printf("Unable to find original commit for manual "
+                       "rebase: %s\n", buf);
+                git_oid_nfmt(buf, 12, git_commit_id(orig_merge));
+                printf("  Merge: %s\n", buf);
+                abort();
+            } else {
+                pre_rebase_commit_id = authortime_to_commit[when];
+            }
+
+            // Replace orig_commit (the rebased commit in this context) with the
+            // true original commit, so that the commit cross-reference
+            // correctly reflects a commit which exists in the f18 repository.
+            git_commit_free(orig_commit);
+            check(git_commit_lookup(&orig_commit, repo, &pre_rebase_commit_id), "git_commit_lookup", NULL);
+        }
+
+        const char *msg = tweak_commit_message(orig_commit, orig_merge, &new_tree);
+
+        int err = git_rebase_commit(
+            &rebase_tip_id,
+            rb,
+            NULL,
+            // Take the committer information from the merge commit if manually rebased.
+            using_manual_rebase ? git_commit_committer(orig_merge): git_commit_committer(orig_commit),
+            NULL,
+            msg
+        );
+        free((void*)msg);
+
+        git_commit_free(orig_commit);
+        if (err == GIT_EAPPLIED) {
+            // Applying the patch results in the same tree, so the patch is
+            // empty.
+            char buf_patch[GIT_OID_HEXSZ+1] = {};
+            char buf_merge[GIT_OID_HEXSZ+1] = {};
+            git_oid_nfmt(buf_patch, 12, &op->id);
+            git_oid_nfmt(buf_merge, 12, git_commit_id(orig_merge));
+            printf("Patch already exists in history; patch=%s merge=%s\n", buf_patch, buf_merge);
+            continue;
+        }
+        check(err, "git_rebase_commit", NULL);
+        committed_at_least_one_patch = true;
+    }
+
+    if (is_success && committed_at_least_one_patch) {
+        // Update the growing new_head to point at our new rebase tip.
+        git_oid_cpy(*new_head, &rebase_tip_id);
+    }
+
+    git_rebase_abort(rb);
+    git_rebase_free(rb);
+
+    git_annotated_commit_free(p0a);
+    git_annotated_commit_free(p1a);
+    git_annotated_commit_free(new_heada);
+
+    return is_success;
+}
+
+// merge_llvm_project_tree generates a new root tree combining the llvm project
+// tree and the given new_tree_id. new_tree_id is updated to point at the new tree.
+void merge_llvm_project_tree(
+    git_oid *new_tree_id,
+    const git_oid *orig_tree,
+    const git_tree *llvm_project_tree) {
+
+    git_repository *repo = git_tree_owner(llvm_project_tree);
+
+    git_tree *flang_tree;
+    check(git_tree_lookup(&flang_tree, repo, orig_tree), "git_tree_lookup", NULL);
+    const git_oid *flang_dir_tree_id = git_tree_entry_id(git_tree_entry_byname(flang_tree, "flang"));
+
+    // Effectively merges the flang/ directory into the llvm project tree.
+    git_treebuilder *tb;
+    check(git_treebuilder_new(&tb, repo, llvm_project_tree), "git_treebuilder_new", NULL);
+    check(git_treebuilder_insert(NULL, tb, "flang", flang_dir_tree_id, GIT_FILEMODE_TREE), "git_treebuilder_insert", NULL);
+    check(git_treebuilder_write(new_tree_id, tb), "git_treebuilder_write", NULL);
+    git_treebuilder_free(tb);
+
+    git_tree_free(flang_tree);
+}
+
+// generate_squash_message generates a commit message for merges which have been
+// squashed.
+void generate_squash_message(char **newmsg, git_commit *merge_commit) {
+    std::stringstream s;
+
+    // Start the message with the existing rewritten message.
+    s << *newmsg;
+
+    s << "\nDue to a conflicting rebase during the linearizing of "
+         "flang-compiler/f18, this commit squashes a number of "
+         "other commits:\n\n";
+
+    git_revwalk *walk;
+    check(git_revwalk_new(&walk, git_commit_owner(merge_commit)), "allocate git_revwalk", NULL);
+    git_revwalk_simplify_first_parent(walk);
+    git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE);
+    check(git_revwalk_push(walk, git_commit_parent_id(merge_commit, 1)), "git_revwalk_push", NULL);
+    check(git_revwalk_hide(walk, git_commit_parent_id(merge_commit, 0)), "git_revwalk_hide", NULL);
+
+    git_oid commit_id;
+    while (!git_revwalk_next(&commit_id, walk)) {
+        char buf[GIT_OID_HEXSZ+1] = {};
+        git_oid_fmt(buf, &commit_id);
+
+        git_commit *c;
+        check(git_commit_lookup(&c, git_commit_owner(merge_commit), &commit_id), "git_commit_lookup", NULL);
+
+        s << "flang-compiler/f18@" << buf << " " << git_commit_summary(c) << "\n";
+        git_commit_free(c);
+
+    }
+
+    git_revwalk_free(walk);
+
+    // Replace newmsg with the squashed msg.
+    auto result = s.str();
+    char *squashmsg = (char*)malloc(result.size()+1);
+    squashmsg[result.size()] = 0;
+    strncpy(squashmsg, result.c_str(), result.size());
+    free(*newmsg);
+    *newmsg = squashmsg;
+}
+
+int main(int argc, char* argv[]) {
+    test_rewrite_issue_references();
+
+    git_libgit2_init();
+
+    const char *repo_path = ".";
+    if (argc > 1)
+        repo_path = argv[1];
+
+    git_repository *repo;
+    int error = git_repository_open(&repo, repo_path);
+    if (error < 0) {
+        fprintf(stderr, "Could not open repository: %s\n", giterr_last()->message);
+        exit(1);
+    }
+
+    // Walk commits in reverse topological order starting from origin/master.
+    git_revwalk *walk;
+    check(git_revwalk_new(&walk, repo), "allocate git_revwalk", NULL);
+    git_revwalk_simplify_first_parent(walk);
+    git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE);
+
+    check(git_revwalk_push_ref(walk, "refs/remotes/origin/master"), "git_revwalk_push_head", NULL);
+    // check(git_revwalk_push_ref(walk, "refs/heads/flatten-top"), "git_revwalk_push_ref", NULL);
+    // check(git_revwalk_hide_ref(walk, "refs/heads/flatten-bottom"), "git_revwalk_hide_ref", NULL);
+
+    bool is_root = true; // First commit has no parents.
+    git_oid old_head = {};
+    git_oid *new_head = NULL;
+    git_oid new_commit_id = {};
+
+    // For each commit in the first-parent lineage of the original history:
+    //
+    //   1. Take non-merge commits as they were.
+    //   2. Attempt to rebase second-parent of merge commits onto first-parent.
+    //      2a. Otherwise, squash them.
+    //
+    // Merge commits are preserved as empty commits.
+    while (!git_revwalk_next(&old_head, walk)) {
+        git_commit *c;
+        check(git_commit_lookup(&c, repo, &old_head), "git_commit_lookup", NULL);
+
+        // Prettify the commit message - rewrite references, add trailer headers.
+        char *newmsg = tweak_commit_message(c, c, git_commit_tree_id(c));
+
+        switch (git_commit_parentcount(c)) {
+        default:
+            fprintf(stderr, "Unexpected number of parents.\n");
+            exit(5);
+
+        case 2: {
+            if (is_root) {
+                // root commit cannot be rebased. Squash instead.
+                // (only happens if using a restricted commit range)
+                break;
+            }
+            if (try_rebase(&new_head, c)) {
+                // Rebase succeeded. Now ensure that at the end of the rebase,
+                // the tree state is the same as if the merge had been done.
+                git_oid old_tree = tree_for_commit(repo, &old_head);
+                git_oid new_tree = tree_for_commit(repo, new_head);
+                if (!git_oid_equal(&old_tree, &new_tree)) {
+                    char buf_old_head[GIT_OID_HEXSZ+1] = {};
+                    char buf_new_head[GIT_OID_HEXSZ+1] = {};
+                    git_oid_nfmt(buf_old_head, 12, &old_head);
+                    git_oid_nfmt(buf_new_head, 12, new_head);
+
+                    fprintf(stderr, "commits do not have the same tree: (old, "
+                                    "new) = %s %s", buf_old_head, buf_new_head);
+                    exit(6);
+                }
+
+                // Create an empty commit for the merge.
+                check(git_commit_create_from_ids(
+                    &new_commit_id,
+                    repo,
+                    NULL,
+                    git_commit_author(c),
+                    git_commit_committer(c),
+                    git_commit_message_encoding(c),
+                    newmsg,
+                    &new_tree,
+                    is_root ? 0 : 1,
+                    (const git_oid**)(&new_head)
+                ), "git_commit_create_from_ids", NULL);
+                new_head = &new_commit_id;
+                is_root = false;
+
+                // Rebase succeeded, new_head updated. Keep going...
+                goto next_patch;
+            }
+
+            generate_squash_message(&newmsg, c);
+        }
+
+        // These are non-merge commits on the first-parent history.
+        // Take them as-is.
+        case 0: case 1: ;
+        }
+
+        // Create a new commit.
+        check(git_commit_create_from_ids(
+            &new_commit_id,
+            repo,
+            NULL,
+            git_commit_author(c),
+            git_commit_committer(c),
+            git_commit_message_encoding(c),
+            newmsg,
+            git_commit_tree_id(c),
+            is_root ? 0 : 1,
+            (const git_oid**)(&new_head)
+        ), "git_commit_create_from_ids", NULL);
+        new_head = &new_commit_id;
+        is_root = false;
+
+    next_patch:
+        free((void*)newmsg);
+        git_commit_free(c);
+    }
+
+    // First pass now done. Move the directory in a second pass, and re-parent
+    // onto llvm-project if it is available.
+
+    char buf[GIT_OID_HEXSZ+1] = {};
+    git_oid_nfmt(buf, 12, new_head);
+    printf("\nConflicts encountered: %d, discarding %d commits\n", n_conflicts, n_discards);
+    printf("Done; rewritten-history-v4 => %s\n", buf);
+
+    git_reference *ref;
+    check(git_reference_create(
+            &ref,
+            repo,
+            "refs/heads/rewritten-history-v4",
+            new_head,
+            1,
+            "flatten.cpp update"
+        ),
+        "git_reference_create", NULL);
+    git_reference_free(ref);
+
+    git_revwalk_reset(walk);
+
+    // Now rename everything under flang/.
+    printf("Inserting /flang/...\n");
+    {
+        git_oid new_commit_id;
+        bool is_root = true; // First commit has no parents.
+        git_oid *new_head_renamed = NULL;
+
+        git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE);
+        check(git_revwalk_push(walk, new_head), "git_revwalk_push_head", NULL);
+
+        // See if the upstream is available at llvm-project/master. If it is,
+        // we'll write the history into there, and use the LLVM project head as
+        // the root commit.
+        git_oid llvm_project_head = {};
+        git_tree *llvm_project_tree;
+        int err = git_reference_name_to_id(&llvm_project_head, repo, "refs/remotes/llvm-project/master");
+        bool have_llvm_project = err == 0;
+
+        if (!have_llvm_project) {
+            fprintf(stderr, "Require llvm-project/master ref to exist before proceeding. Add llvm-project as a remote and fetch it.\n");
+            exit(2);
+        }
+
+        git_oid_nfmt(buf, 12, &llvm_project_head);
+        printf("Rewriting history on top of llvm-project@%s...\n", buf);
+
+        // Disabled since the merged MLIR root commit has zero parents.
+        // Take the same approach to be consistent (= false).
+        const bool use_llvm_project_head_as_root = false;
+        if (use_llvm_project_head_as_root) {
+            new_head_renamed = &llvm_project_head;
+            is_root = false;
+        }
+
+        // Grab the llvm_project_tree.
+        git_commit *c;
+        check(git_commit_lookup(&c, repo, &llvm_project_head), "git_commit_lookup", NULL);
+        check(git_commit_tree(&llvm_project_tree, c), "git_commit_tree", NULL);
+        git_commit_free(c);
+
+        git_oid new_tree;
+
+        // For each commit, rewrite its tree.
+        while (!git_revwalk_next(&old_head, walk)) {
+            git_commit *c;
+            check(git_commit_lookup(&c, repo, &old_head), "git_commit_lookup", NULL);
+
+            insert_flang_directory(repo, &new_tree, git_commit_tree_id(c));
+
+            check(git_commit_create_from_ids(
+                &new_commit_id,
+                repo,
+                NULL,
+                git_commit_author(c),
+                git_commit_committer(c),
+                git_commit_message_encoding(c),
+                git_commit_message_raw(c),
+                &new_tree,
+                is_root ? 0 : 1,
+                (const git_oid**)(&new_head_renamed)
+            ), "git_commit_create_from_ids", NULL);
+            new_head_renamed = &new_commit_id;
+            is_root = false;
+
+            git_commit_free(c);
+        }
+
+        git_signature *merge_commit_author;
+        check(git_signature_default(&merge_commit_author, repo), "git_signature_default", NULL);
+
+        const char *merge_message =
+            "[Flang] Merge flang-compiler/f18\n"
+            "\n"
+            "This is the initial merge of flang-compiler, which is done in this way\n"
+            "principally to preserve the history and git-blame, without generating a large\n"
+            "number of commits on the first-parent history of LLVM.\n"
+            "\n"
+            "If you don't care about the flang history during a bisect remember that you can\n"
+            "supply paths to git-bisect, e.g. `git bisect start clang llvm`.\n"
+            "\n"
+            "The history of f18 was rewritten to:\n"
+            "\n"
+            "* Put the code under /flang/.\n"
+            "* Linearize the history.\n"
+            "* Rewrite commit messages so that issue and PR numbers point to the old repository.\n"
+            "\n"
+            "Updates: flang-compiler/f18#876 (submission into llvm-project)\n"
+            "Mailing-list: http://lists.llvm.org/pipermail/llvm-dev/2020-January/137989.html ([llvm-dev] Flang landing in the monorepo - next Monday!)\n"
+            "Mailing-list: http://lists.llvm.org/pipermail/llvm-dev/2019-December/137661.html ([llvm-dev] Flang landing in the monorepo)\n";
+
+        merge_llvm_project_tree(&new_tree, &new_tree, llvm_project_tree);
+
+        const git_oid *parents[2] = {};
+        parents[0] = &llvm_project_head;
+        parents[1] = &new_commit_id;
+
+        git_oid new_head_merged;
+        check(git_commit_create_from_ids(
+            &new_head_merged,
+            repo,
+            NULL,
+            merge_commit_author,
+            merge_commit_author,
+            NULL,
+            merge_message,
+            &new_tree,
+            2,
+            parents
+        ), "git_commit_create_from_ids", NULL);
+
+        git_signature_free(merge_commit_author);
+
+        git_tree_free(llvm_project_tree);
+
+        git_reference *ref;
+        check(git_reference_create(
+                &ref,
+                repo,
+                "refs/heads/rewritten-history-v4-llvm-project-merge",
+                &new_head_merged,
+                1,
+                "flatten.cpp update"
+            ),
+            "git_reference_create", NULL);
+        git_reference_free(ref);
+
+        git_oid_nfmt(buf, 12, &new_head_merged);
+        printf("Done; rewritten-history-v4-llvm-project-merge => %s\n", buf);
+    }
+    printf("  ... all done\n");
+
+    git_oid origin_master;
+    git_reference_name_to_id(&origin_master, repo, "refs/remotes/origin/master");
+    git_oid_nfmt(buf, 12, &origin_master);
+    printf("Start point was origin/master => %s\n", buf);
+
+    git_revwalk_free(walk);
+    git_repository_free(repo);
+
+    return 0;
+}

From 886ccc37fbff5df00717ac728e2aba240d0a314c Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Sat, 22 Feb 2020 11:47:04 -0800
Subject: [PATCH 051/345] Remove use of std::set::merge

Some versions of clang that we are building with don't have
std::set::merge, even though it is part of C++17. Work around
that by using std::set::insert until we can count on merge being
available everywhere.
---
 lib/Semantics/check-do-forall.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/Semantics/check-do-forall.cpp b/lib/Semantics/check-do-forall.cpp
index 615e1005e36b..6dfd51c8a823 100644
--- a/lib/Semantics/check-do-forall.cpp
+++ b/lib/Semantics/check-do-forall.cpp
@@ -763,13 +763,27 @@ class DoContext {
           common::visitors{
               [&](const evaluate::Assignment::BoundsSpec &spec) {
                 for (const auto &bound : spec) {
+// TODO: this is working around missing std::set::merge in some versions of
+// clang that we are building with
+#ifdef __clang__
+                  auto boundSymbols{evaluate::CollectSymbols(bound)};
+                  symbols.insert(boundSymbols.begin(), boundSymbols.end());
+#else
                   symbols.merge(evaluate::CollectSymbols(bound));
+#endif
                 }
               },
               [&](const evaluate::Assignment::BoundsRemapping &remapping) {
                 for (const auto &bounds : remapping) {
+#ifdef __clang__
+                  auto lbSymbols{evaluate::CollectSymbols(bounds.first)};
+                  symbols.insert(lbSymbols.begin(), lbSymbols.end());
+                  auto ubSymbols{evaluate::CollectSymbols(bounds.second)};
+                  symbols.insert(ubSymbols.begin(), ubSymbols.end());
+#else
                   symbols.merge(evaluate::CollectSymbols(bounds.first));
                   symbols.merge(evaluate::CollectSymbols(bounds.second));
+#endif
                 }
               },
               [](const auto &) {},

From 45998741e5f04bba7db6eed6a4d27c1d25209b41 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Wed, 26 Feb 2020 20:19:48 -0800
Subject: [PATCH 052/345] Semantic checks for C712 through C727

I've updated the compiler and test source with references to the contraints at
the points where they were enforced and tested.  Many of these were already
implemented and required no code change.  A few constraint checks were both
implemented and tested, and I only added references to the constraint
numbers in the compiler source and tests.  Here are the things I had to
implement:

Constraint C716 states that, in a REAL constant, if both a kind-param and an
exponent letter appear, the exponent letter must be 'E'.

Constraints C715 and C719 require that a KIND value be actually implemented.

Constraint C722 requires that functions that return assumed-length character
types are external.

Constraint C726 disallows assumed lenght charater types for dummy arguments and
return types.
---
 include/flang/Semantics/expression.h |  2 +-
 include/flang/Semantics/tools.h      |  8 ++++--
 lib/Evaluate/tools.cpp               |  2 +-
 lib/Semantics/check-declarations.cpp | 27 +++++++++++--------
 lib/Semantics/expression.cpp         | 27 +++++++++----------
 lib/Semantics/resolve-names.cpp      |  8 ++++++
 lib/Semantics/tools.cpp              | 35 ++++++++++++++++++++----
 test/Semantics/CMakeLists.txt        |  5 ++++
 test/Semantics/call05.f90            |  4 +--
 test/Semantics/complex01.f90         | 32 ++++++++++++++++++++++
 test/Semantics/kinds02.f90           | 27 +++++++++++++++++++
 test/Semantics/kinds04.f90           | 31 +++++++++++++++++++++
 test/Semantics/resolve35.f90         |  1 +
 test/Semantics/resolve37.f90         |  1 +
 test/Semantics/resolve41.f90         |  1 +
 test/Semantics/resolve73.f90         | 40 ++++++++++++++++++++++++++++
 test/Semantics/resolve74.f90         | 37 +++++++++++++++++++++++++
 test/Semantics/resolve75.f90         | 13 +++++++++
 18 files changed, 265 insertions(+), 36 deletions(-)
 create mode 100644 test/Semantics/complex01.f90
 create mode 100644 test/Semantics/kinds04.f90
 create mode 100644 test/Semantics/resolve73.f90
 create mode 100644 test/Semantics/resolve74.f90
 create mode 100644 test/Semantics/resolve75.f90

diff --git a/include/flang/Semantics/expression.h b/include/flang/Semantics/expression.h
index 2e135b0885d0..7282a96f1095 100644
--- a/include/flang/Semantics/expression.h
+++ b/include/flang/Semantics/expression.h
@@ -186,7 +186,7 @@ class ExpressionAnalyzer {
     auto result{Analyze(x.thing)};
     if (result) {
       *result = Fold(std::move(*result));
-      if (!IsConstantExpr(*result)) { //C886,C887
+      if (!IsConstantExpr(*result)) {  //  C886, C887, C713
         SayAt(x, "Must be a constant value"_err_en_US);
         ResetExpr(x);
         return std::nullopt;
diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index 69ca0e35dfe9..f73958472fdf 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -48,7 +48,7 @@ const DeclTypeSpec *FindParentTypeSpec(const DerivedTypeSpec &);
 const DeclTypeSpec *FindParentTypeSpec(const DeclTypeSpec &);
 const DeclTypeSpec *FindParentTypeSpec(const Scope &);
 const DeclTypeSpec *FindParentTypeSpec(const Symbol &);
- 
+
 // Return the Symbol of the variable of a construct association, if it exists
 const Symbol *GetAssociationRoot(const Symbol &);
 
@@ -78,6 +78,10 @@ bool DoesScopeContain(const Scope *, const Symbol &);
 bool IsUseAssociated(const Symbol &, const Scope &);
 bool IsHostAssociated(const Symbol &, const Scope &);
 bool IsDummy(const Symbol &);
+bool IsStmtFunction(const Symbol &);
+bool IsInStmtFunction(const Symbol &);
+bool IsStmtFunctionDummy(const Symbol &);
+bool IsStmtFunctionResult(const Symbol &);
 bool IsPointerDummy(const Symbol &);
 bool IsFunction(const Symbol &);
 bool IsPureProcedure(const Symbol &);
@@ -154,7 +158,7 @@ inline bool IsAssumedSizeArray(const Symbol &symbol) {
   return details && details->IsAssumedSize();
 }
 bool IsAssumedLengthCharacter(const Symbol &);
-bool IsAssumedLengthCharacterFunction(const Symbol &);
+bool IsAssumedLengthExternalCharacterFunction(const Symbol &);
 // Is the symbol modifiable in this scope
 std::optional<parser::MessageFixedText> WhyNotModifiable(
     const Symbol &, const Scope &);
diff --git a/lib/Evaluate/tools.cpp b/lib/Evaluate/tools.cpp
index cfa675c1bf81..624fb352a59e 100644
--- a/lib/Evaluate/tools.cpp
+++ b/lib/Evaluate/tools.cpp
@@ -101,7 +101,7 @@ ConvertRealOperandsResult ConvertRealOperands(
             return {AsSameKindExprs<TypeCategory::Real>(
                 ConvertTo(ry, std::move(bx)), std::move(ry))};
           },
-          [&](auto &&, auto &&) -> ConvertRealOperandsResult {
+          [&](auto &&, auto &&) -> ConvertRealOperandsResult {  // C718
             messages.Say("operands must be INTEGER or REAL"_err_en_US);
             return std::nullopt;
           },
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index 4e463319accc..1b7dd988e5b1 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -105,9 +105,11 @@ class CheckHelper {
 
 void CheckHelper::Check(const ParamValue &value, bool canBeAssumed) {
   if (value.isAssumed()) {
-    if (!canBeAssumed) {  // C795
+    if (!canBeAssumed) {  // C795, C721, C726
       messages_.Say(
-          "An assumed (*) type parameter may be used only for a dummy argument, associate name, or named constant"_err_en_US);
+          "An assumed (*) type parameter may be used only for a (non-statement"
+          " function) dummy argument, associate name, named constant, or"
+          " external function result"_err_en_US);
     }
   } else {
     CheckSpecExpr(value.GetExplicit());
@@ -186,16 +188,19 @@ void CheckHelper::Check(const Symbol &symbol) {
       }
     }
   }
-  if (type) {
+  if (type) {  // Section 7.2, paragraph 7
     bool canHaveAssumedParameter{IsNamedConstant(symbol) ||
-        IsAssumedLengthCharacterFunction(symbol) ||
+        IsAssumedLengthExternalCharacterFunction(symbol) ||  // C722
         symbol.test(Symbol::Flag::ParentComp)};
-    if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
-      canHaveAssumedParameter |= object->isDummy() ||
-          (object->isFuncResult() &&
-              type->category() == DeclTypeSpec::Character);
-    } else {
-      canHaveAssumedParameter |= symbol.has<AssocEntityDetails>();
+    if (!IsStmtFunctionDummy(symbol)) {  // C726
+      if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
+        canHaveAssumedParameter |= object->isDummy() ||
+            (object->isFuncResult() &&
+                type->category() == DeclTypeSpec::Character) ||
+            IsStmtFunctionResult(symbol);  // Avoids multiple messages
+      } else {
+        canHaveAssumedParameter |= symbol.has<AssocEntityDetails>();
+      }
     }
     Check(*type, canHaveAssumedParameter);
     if (InPure() && InFunction() && IsFunctionResult(symbol)) {
@@ -216,7 +221,7 @@ void CheckHelper::Check(const Symbol &symbol) {
       }
     }
   }
-  if (IsAssumedLengthCharacterFunction(symbol)) {  // C723
+  if (IsAssumedLengthExternalCharacterFunction(symbol)) {  // C723
     if (symbol.attrs().test(Attr::RECURSIVE)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be RECURSIVE"_err_en_US);
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index a41e754d5ade..5c1a040d1074 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -500,10 +500,10 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::RealLiteralConstant &x) {
   // Use a local message context around the real literal for better
   // provenance on any messages.
   auto restorer{GetContextualMessages().SetLocation(x.real.source)};
-  // If a kind parameter appears, it defines the kind of the literal and any
-  // letter used in an exponent part (e.g., the 'E' in "6.02214E+23")
-  // should agree.  In the absence of an explicit kind parameter, any exponent
-  // letter determines the kind.  Otherwise, defaults apply.
+  // If a kind parameter appears, it defines the kind of the literal and the
+  // letter used in an exponent part must be 'E' (e.g., the 'E' in
+  // "6.02214E+23").  In the absence of an explicit kind parameter, any
+  // exponent letter determines the kind.  Otherwise, defaults apply.
   auto &defaults{context_.defaultKinds()};
   int defaultKind{defaults.GetDefaultKind(TypeCategory::Real)};
   const char *end{x.real.source.end()};
@@ -525,14 +525,13 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::RealLiteralConstant &x) {
     defaultKind = *letterKind;
   }
   auto kind{AnalyzeKindParam(x.kind, defaultKind)};
-  if (letterKind && kind != *letterKind && expoLetter != 'e') {
-    Say("Explicit kind parameter on real constant disagrees with "
-        "exponent letter '%c'"_en_US,
-        expoLetter);
+  if (x.kind && letterKind && expoLetter != 'e') {  // C716
+    Say("Explicit kind parameter on REAL constant can only be used with"
+        " exponent letter 'E'"_err_en_US);
   }
   auto result{common::SearchTypes(
       RealTypeVisitor{kind, x.real.source, GetFoldingContext()})};
-  if (!result) {
+  if (!result) {  // C717
     Say("Unsupported REAL(KIND=%d)"_err_en_US, kind);
   }
   return AsMaybeExpr(std::move(result));
@@ -704,7 +703,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::NamedConstant &n) {
     if (IsConstantExpr(folded)) {
       return {folded};
     }
-    Say(n.v.source, "must be a constant"_err_en_US);
+    Say(n.v.source, "must be a constant"_err_en_US);  // C718
   }
   return std::nullopt;
 }
@@ -1820,8 +1819,8 @@ void ExpressionAnalyzer::CheckForBadRecursion(
       if (proc.attrs().test(semantics::Attr::NON_RECURSIVE)) {  // 15.6.2.1(3)
         msg = Say("NON_RECURSIVE procedure '%s' cannot call itself"_err_en_US,
             callSite);
-      } else if (IsAssumedLengthCharacterFunction(proc)) {  // 15.6.2.1(3)
-        msg = Say(
+      } else if (IsAssumedLengthExternalCharacterFunction(proc)) {
+        msg = Say(  // 15.6.2.1(3)
             "Assumed-length CHARACTER(*) function '%s' cannot call itself"_err_en_US,
             callSite);
       }
@@ -2422,7 +2421,7 @@ DynamicType ExpressionAnalyzer::GetDefaultKindOfType(
 
 bool ExpressionAnalyzer::CheckIntrinsicKind(
     TypeCategory category, std::int64_t kind) {
-  if (IsValidKindOfIntrinsicType(category, kind)) {
+  if (IsValidKindOfIntrinsicType(category, kind)) {  // C712, C714, C715
     return true;
   } else {
     Say("%s(KIND=%jd) is not a supported type"_err_en_US,
@@ -2471,7 +2470,7 @@ bool ExpressionAnalyzer::EnforceTypeConstraint(parser::CharBlock at,
     const MaybeExpr &result, TypeCategory category, bool defaultKind) {
   if (result) {
     if (auto type{result->GetType()}) {
-      if (type->category() != category) { // C885
+      if (type->category() != category) {  // C885
         Say(at, "Must have %s type, but is %s"_err_en_US,
             ToUpperCase(EnumToString(category)),
             ToUpperCase(type->AsFortran()));
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 7d6fa5d644da..670cec7ed970 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -2602,6 +2602,7 @@ bool SubprogramVisitor::HandleStmtFunction(const parser::StmtFunctionStmt &x) {
   if (resultType) {
     resultDetails.set_type(*resultType);
   }
+  resultDetails.set_funcResult(true);
   Symbol &result{MakeSymbol(name, std::move(resultDetails))};
   ApplyImplicitRules(result);
   details.set_result(result);
@@ -3271,6 +3272,13 @@ void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Character &) {
 }
 void DeclarationVisitor::Post(const parser::CharSelector::LengthAndKind &x) {
   charInfo_.kind = EvaluateSubscriptIntExpr(x.kind);
+  std::optional<std::int64_t> intKind{ToInt64(charInfo_.kind)};
+  if (intKind &&
+      !evaluate::IsValidKindOfIntrinsicType(
+          TypeCategory::Character, *intKind)) {  // C715, C719
+    Say(currStmtSource().value(),
+        "KIND value (%jd) not valid for CHARACTER"_err_en_US, *intKind);
+  }
   if (x.length) {
     charInfo_.length = GetParamValue(*x.length, common::TypeParamAttr::Len);
   }
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index b4a2a281ee7d..d5fc39c987b6 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -196,6 +196,29 @@ bool IsDummy(const Symbol &symbol) {
   }
 }
 
+bool IsStmtFunction(const Symbol &symbol) {
+  const auto *subprogram{symbol.detailsIf<SubprogramDetails>()};
+  if (subprogram && subprogram->stmtFunction()) {
+    return true;
+  }
+  return false;
+}
+
+bool IsInStmtFunction(const Symbol &symbol) {
+  if (const Symbol * function{symbol.owner().symbol()}) {
+    return IsStmtFunction(*function);
+  }
+  return false;
+}
+
+bool IsStmtFunctionDummy(const Symbol &symbol) {
+  return IsDummy(symbol) && IsInStmtFunction(symbol);
+}
+
+bool IsStmtFunctionResult(const Symbol &symbol) {
+  return IsFunctionResult(symbol) && IsInStmtFunction(symbol);
+}
+
 bool IsPointerDummy(const Symbol &symbol) {
   return IsPointer(symbol) && IsDummy(symbol);
 }
@@ -686,11 +709,13 @@ bool IsAssumedLengthCharacter(const Symbol &symbol) {
   }
 }
 
-bool IsAssumedLengthCharacterFunction(const Symbol &symbol) {
-  // Assumed-length character functions only appear as such in their
-  // definitions; their interfaces, pointers to them, and dummy procedures
-  // cannot be assumed-length.
-  return symbol.has<SubprogramDetails>() && IsAssumedLengthCharacter(symbol);
+// C722 and C723:  For a function to be assumed length, it must be external and
+// of CHARACTER type
+bool IsAssumedLengthExternalCharacterFunction(const Symbol &symbol) {
+  return IsAssumedLengthCharacter(symbol) &&
+      ((symbol.has<SubprogramDetails>() && symbol.owner().IsGlobal()) ||
+          (symbol.test(Symbol::Flag::Function) &&
+              symbol.attrs().test(Attr::EXTERNAL)));
 }
 
 const Symbol *IsExternalInPureContext(
diff --git a/test/Semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
index ac3e9f641c0c..51cc8e4850ff 100644
--- a/test/Semantics/CMakeLists.txt
+++ b/test/Semantics/CMakeLists.txt
@@ -31,6 +31,7 @@ set(ERROR_TESTS
   io09.f90
   io10.f90
   kinds02.f90
+  kinds04.f90
   resolve01.f90
   resolve02.f90
   resolve03.f90
@@ -103,6 +104,9 @@ set(ERROR_TESTS
   resolve70.f90
   resolve71.f90
   resolve72.f90
+  resolve73.f90
+  resolve74.f90
+  resolve75.f90
   stop01.f90
   structconst01.f90
   structconst02.f90
@@ -207,6 +211,7 @@ set(ERROR_TESTS
   critical02.f90
   critical03.f90
   block-data01.f90
+  complex01.f90
   data01.f90
 )
 
diff --git a/test/Semantics/call05.f90 b/test/Semantics/call05.f90
index 09a2c1327b19..368ec59b33b8 100644
--- a/test/Semantics/call05.f90
+++ b/test/Semantics/call05.f90
@@ -19,9 +19,9 @@ module m
   class(t2), allocatable :: pa2(:)
   class(*), pointer :: up(:)
   class(*), allocatable :: ua(:)
-  !ERROR: An assumed (*) type parameter may be used only for a dummy argument, associate name, or named constant
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
   type(pdt(*)), pointer :: amp(:)
-  !ERROR: An assumed (*) type parameter may be used only for a dummy argument, associate name, or named constant
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
   type(pdt(*)), allocatable :: ama(:)
   type(pdt(:)), pointer :: dmp(:)
   type(pdt(:)), allocatable :: dma(:)
diff --git a/test/Semantics/complex01.f90 b/test/Semantics/complex01.f90
new file mode 100644
index 000000000000..4fb46ba56b71
--- /dev/null
+++ b/test/Semantics/complex01.f90
@@ -0,0 +1,32 @@
+! C718 Each named constant in a complex literal constant shall be of type 
+! integer or real.
+subroutine s()
+  integer :: ivar = 35
+  integer, parameter :: iconst = 35
+  real :: rvar = 68.9
+  real, parameter :: rconst = 68.9
+  character :: cvar = 'hello'
+  character, parameter :: cconst = 'hello'
+  logical :: lvar = .true.
+  logical, parameter :: lconst = .true.
+  complex :: cvar1 = (1, 1)
+  complex :: cvar2 = (1.0, 1.0)
+  complex :: cvar3 = (1.0, 1)
+  complex :: cvar4 = (1, 1.0)
+  complex :: cvar5 = (iconst, 1.0)
+  complex :: cvar6 = (iconst, rconst)
+  complex :: cvar7 = (rconst, iconst)
+
+  !ERROR: must be a constant
+  complex :: cvar8 = (ivar, 1.0)
+  !ERROR: must be a constant
+  !ERROR: must be a constant
+  complex :: cvar9 = (ivar, rvar)
+  !ERROR: must be a constant
+  !ERROR: must be a constant
+  complex :: cvar10 = (rvar, ivar)
+  !ERROR: operands must be INTEGER or REAL
+  complex :: cvar11 = (cconst, 1.0)
+  !ERROR: operands must be INTEGER or REAL
+  complex :: cvar12 = (lconst, 1.0)
+end subroutine s
diff --git a/test/Semantics/kinds02.f90 b/test/Semantics/kinds02.f90
index 4ad99ad5f01b..9fb921345d85 100644
--- a/test/Semantics/kinds02.f90
+++ b/test/Semantics/kinds02.f90
@@ -1,3 +1,15 @@
+! C712 The value of scalar-int-constant-expr shall be nonnegative and 
+! shall specify a representation method that exists on the processor.
+! C714 The value of kind-param shall be nonnegative.
+! C715 The value of kind-param shall specify a representation method that 
+! exists on the processor.
+! C719 The value of scalar-int-constant-expr shall be nonnegative and shall 
+! specify a representation method that exists on the processor.
+! C725 The optional comma in a length-selector is permitted only if no 
+! double-colon separator appears in the typedeclaration- stmt.
+! C727 The value of kind-param shall specify a representation method that 
+! exists on the processor.
+!
 !ERROR: INTEGER(KIND=0) is not a supported type
 integer(kind=0) :: j0
 !ERROR: INTEGER(KIND=-1) is not a supported type
@@ -40,4 +52,19 @@
 logical(kind=3) :: l3
 !ERROR: LOGICAL(KIND=16) is not a supported type
 logical(kind=16) :: l16
+character (len=99, kind=1) :: cvar1
+character (len=99, kind=2) :: cvar2
+character *4, cvar3
+character *(5), cvar4
+!ERROR: KIND value (3) not valid for CHARACTER
+character (len=99, kind=3) :: cvar5
+!ERROR: KIND value (-1) not valid for CHARACTER
+character (len=99, kind=-1) :: cvar6
+character(len=*), parameter :: cvar7 = 1_"abcd"
+character(len=*), parameter :: cvar8 = 2_"abcd"
+!ERROR: CHARACTER(KIND=3) is not a supported type
+character(len=*), parameter :: cvar9 = 3_"abcd"
+character(len=*), parameter :: cvar10 = 4_"abcd"
+!ERROR: CHARACTER(KIND=8) is not a supported type
+character(len=*), parameter :: cvar11 = 8_"abcd"
 end program
diff --git a/test/Semantics/kinds04.f90 b/test/Semantics/kinds04.f90
new file mode 100644
index 000000000000..a44c62bae47e
--- /dev/null
+++ b/test/Semantics/kinds04.f90
@@ -0,0 +1,31 @@
+! C716 If both kind-param and exponent-letter appear, exponent-letter 
+! shall be E.
+! C717 The value of kind-param shall specify an approximation method that 
+! exists on the processor.
+subroutine s(var)
+  real :: realvar1 = 4.0E6_4
+  real :: realvar2 = 4.0D6
+  real :: realvar3 = 4.0Q6
+  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
+  real :: realvar4 = 4.0D6_8
+  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
+  real :: realvar5 = 4.0Q6_16
+  real :: realvar6 = 4.0E6_8
+  real :: realvar7 = 4.0E6_10
+  real :: realvar8 = 4.0E6_16
+  !ERROR: Unsupported REAL(KIND=32)
+  real :: realvar9 = 4.0E6_32
+
+  double precision :: doublevar1 = 4.0E6_4
+  double precision :: doublevar2 = 4.0D6
+  double precision :: doublevar3 = 4.0Q6
+  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
+  double precision :: doublevar4 = 4.0D6_8
+  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
+  double precision :: doublevar5 = 4.0Q6_16
+  double precision :: doublevar6 = 4.0E6_8
+  double precision :: doublevar7 = 4.0E6_10
+  double precision :: doublevar8 = 4.0E6_16
+  !ERROR: Unsupported REAL(KIND=32)
+  double precision :: doublevar9 = 4.0E6_32
+end subroutine s
diff --git a/test/Semantics/resolve35.f90 b/test/Semantics/resolve35.f90
index 2598d9ca82e8..6acd24f49b5e 100644
--- a/test/Semantics/resolve35.f90
+++ b/test/Semantics/resolve35.f90
@@ -66,6 +66,7 @@ subroutine s6b
   integer :: l = 4
   forall(integer(k) :: i = 1:10)
   end forall
+  ! C713 A scalar-int-constant-name shall be a named constant of type integer.
   !ERROR: Must be a constant value
   forall(integer(l) :: i = 1:10)
   end forall
diff --git a/test/Semantics/resolve37.f90 b/test/Semantics/resolve37.f90
index a33e3700a932..ccc05f3d1715 100644
--- a/test/Semantics/resolve37.f90
+++ b/test/Semantics/resolve37.f90
@@ -6,6 +6,7 @@
 !ERROR: Must be a constant value
 parameter(m=n)
 integer(k) :: x
+! C713 A scalar-int-constant-name shall be a named constant of type integer.
 !ERROR: Must have INTEGER type, but is REAL(4)
 integer(l) :: y
 !ERROR: Must be a constant value
diff --git a/test/Semantics/resolve41.f90 b/test/Semantics/resolve41.f90
index 3e5c48e9aaa6..2f618675de60 100644
--- a/test/Semantics/resolve41.f90
+++ b/test/Semantics/resolve41.f90
@@ -4,6 +4,7 @@ module m
   !ERROR: Must have INTEGER type, but is REAL(4)
   integer :: aa = 2_a
   integer :: b = 8
+  ! C713 A scalar-int-constant-name shall be a named constant of type integer.
   !ERROR: Must be a constant value
   integer :: bb = 2_b
   !TODO: should get error -- not scalar
diff --git a/test/Semantics/resolve73.f90 b/test/Semantics/resolve73.f90
new file mode 100644
index 000000000000..191be316b620
--- /dev/null
+++ b/test/Semantics/resolve73.f90
@@ -0,0 +1,40 @@
+! C721 A type-param-value of * shall be used only
+! * to declare a dummy argument,
+! * to declare a named constant,
+! * in the type-spec of an ALLOCATE statement wherein each allocate-object is 
+!   a dummy argument of type CHARACTER with an assumed character length,
+! * in the type-spec or derived-type-spec of a type guard statement (11.1.11), 
+!   or
+! * in an external function, to declare the character length parameter of the function result.
+subroutine s(arg)
+  character(len=*), pointer :: arg
+  character*(*), parameter  :: cvar1 = "abc"
+  character*4,  cvar2
+  character(len=4_4) :: cvar3
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
+  character(len=*) :: cvar4
+
+  type derived(param)
+    integer, len :: param
+    class(*), allocatable :: x
+  end type
+  type(derived(34)) :: a
+  interface
+    function fun()
+      character(len=4) :: fun
+    end function fun
+  end interface
+
+  select type (ax => a%x)
+    type is (integer)
+      print *, "hello"
+    type is (character(len=*))
+      print *, "hello"
+    class is (derived(param=*))
+      print *, "hello"
+    class default
+      print *, "hello"
+  end select
+
+  allocate (character(len=*) :: arg)
+end subroutine s
diff --git a/test/Semantics/resolve74.f90 b/test/Semantics/resolve74.f90
new file mode 100644
index 000000000000..a674b1f37ac2
--- /dev/null
+++ b/test/Semantics/resolve74.f90
@@ -0,0 +1,37 @@
+! C722 A function name shall not be declared with an asterisk type-param-value 
+! unless it is of type CHARACTER and is the name of a dummy function or the 
+! name of the result of an external function.
+subroutine s()
+
+  type derived(param)
+    integer, len :: param
+  end type
+  type(derived(34)) :: a
+
+  procedure(character(len=*)) :: externCharFunc
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
+  procedure(type(derived(param =*))) :: externDerivedFunc
+
+  interface
+    subroutine subr(dummyFunc)
+      character(len=*) :: dummyFunc
+    end subroutine subr
+  end interface
+
+  contains
+    function works()
+      type(derived(param=4)) :: works
+    end function works
+
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
+    function fails1()
+      character(len=*) :: fails1
+    end function fails1
+
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
+    function fails2()
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
+      type(derived(param=*)) :: fails2
+    end function fails2
+
+end subroutine s
diff --git a/test/Semantics/resolve75.f90 b/test/Semantics/resolve75.f90
new file mode 100644
index 000000000000..2c63a36fe523
--- /dev/null
+++ b/test/Semantics/resolve75.f90
@@ -0,0 +1,13 @@
+! C726 The length specified for a character statement function or for a 
+! statement function dummy argument of type character shall be a constant 
+! expression.
+subroutine s()
+  implicit character(len=3) (c)
+  implicit character(len=*) (d)
+  stmtFunc1 (x) = x * 32
+  cStmtFunc2 (x) = "abc"
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
+  cStmtFunc3 (dummy) = "abc"
+  !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
+  dStmtFunc3 (x) = "abc"
+end subroutine s

From e81f57fcf54ee0493044d53a6d1bf05f661e2660 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Thu, 27 Feb 2020 08:49:40 -0800
Subject: [PATCH 053/345] Responses to pull request comments

I cleaned up some code and reverted a change to semantic checking for
the exponent letter in REAL literals.
---
 lib/Semantics/expression.cpp    | 8 +++++---
 lib/Semantics/resolve-names.cpp | 3 ++-
 lib/Semantics/tools.cpp         | 5 +----
 test/Semantics/kinds04.f90      | 4 ----
 4 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index 5c1a040d1074..a09b1ac62558 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -524,10 +524,12 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::RealLiteralConstant &x) {
   if (letterKind) {
     defaultKind = *letterKind;
   }
+  // C716 requires 'E' as an exponent, but this is more useful
   auto kind{AnalyzeKindParam(x.kind, defaultKind)};
-  if (x.kind && letterKind && expoLetter != 'e') {  // C716
-    Say("Explicit kind parameter on REAL constant can only be used with"
-        " exponent letter 'E'"_err_en_US);
+  if (letterKind && kind != *letterKind && expoLetter != 'e') {
+    Say("Explicit kind parameter on real constant disagrees with "
+        "exponent letter '%c'"_en_US,
+        expoLetter);
   }
   auto result{common::SearchTypes(
       RealTypeVisitor{kind, x.real.source, GetFoldingContext()})};
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 670cec7ed970..3cb31c9484b9 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -3277,7 +3277,8 @@ void DeclarationVisitor::Post(const parser::CharSelector::LengthAndKind &x) {
       !evaluate::IsValidKindOfIntrinsicType(
           TypeCategory::Character, *intKind)) {  // C715, C719
     Say(currStmtSource().value(),
-        "KIND value (%jd) not valid for CHARACTER"_err_en_US, *intKind);
+        "KIND value (%jd) not valid for CHARACTER"_err_en_US,
+        static_cast<std::intmax_t>(*intKind));
   }
   if (x.length) {
     charInfo_.length = GetParamValue(*x.length, common::TypeParamAttr::Len);
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index d5fc39c987b6..57980dd76875 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -198,10 +198,7 @@ bool IsDummy(const Symbol &symbol) {
 
 bool IsStmtFunction(const Symbol &symbol) {
   const auto *subprogram{symbol.detailsIf<SubprogramDetails>()};
-  if (subprogram && subprogram->stmtFunction()) {
-    return true;
-  }
-  return false;
+  return subprogram && subprogram->stmtFunction();
 }
 
 bool IsInStmtFunction(const Symbol &symbol) {
diff --git a/test/Semantics/kinds04.f90 b/test/Semantics/kinds04.f90
index a44c62bae47e..ecf3a446cc3d 100644
--- a/test/Semantics/kinds04.f90
+++ b/test/Semantics/kinds04.f90
@@ -6,9 +6,7 @@ subroutine s(var)
   real :: realvar1 = 4.0E6_4
   real :: realvar2 = 4.0D6
   real :: realvar3 = 4.0Q6
-  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
   real :: realvar4 = 4.0D6_8
-  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
   real :: realvar5 = 4.0Q6_16
   real :: realvar6 = 4.0E6_8
   real :: realvar7 = 4.0E6_10
@@ -19,9 +17,7 @@ subroutine s(var)
   double precision :: doublevar1 = 4.0E6_4
   double precision :: doublevar2 = 4.0D6
   double precision :: doublevar3 = 4.0Q6
-  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
   double precision :: doublevar4 = 4.0D6_8
-  !ERROR: Explicit kind parameter on REAL constant can only be used with exponent letter 'E'
   double precision :: doublevar5 = 4.0Q6_16
   double precision :: doublevar6 = 4.0E6_8
   double precision :: doublevar7 = 4.0E6_10

From 8134fc477e843d9bf525eeb552ba1d234140e7a7 Mon Sep 17 00:00:00 2001
From: Varun Jayathirtha <vjayathirtha@nvidia.com>
Date: Tue, 25 Feb 2020 18:01:23 -0800
Subject: [PATCH 054/345] Add semantic checks C8104, C8105. Add tests for
 C8103, C8104, C8105

---
 lib/Semantics/CMakeLists.txt     |  1 +
 lib/Semantics/check-namelist.cpp | 40 ++++++++++++++++++++++++++
 lib/Semantics/check-namelist.h   | 25 ++++++++++++++++
 lib/Semantics/semantics.cpp      | 11 +++----
 test/Semantics/CMakeLists.txt    |  1 +
 test/Semantics/namelist01.f90    | 49 ++++++++++++++++++++++++++++++++
 6 files changed, 122 insertions(+), 5 deletions(-)
 create mode 100644 lib/Semantics/check-namelist.cpp
 create mode 100644 lib/Semantics/check-namelist.h
 create mode 100644 test/Semantics/namelist01.f90

diff --git a/lib/Semantics/CMakeLists.txt b/lib/Semantics/CMakeLists.txt
index 0c6b612586de..cbe9fc9b6b30 100644
--- a/lib/Semantics/CMakeLists.txt
+++ b/lib/Semantics/CMakeLists.txt
@@ -21,6 +21,7 @@ add_library(FortranSemantics
   check-do-forall.cpp
   check-if-stmt.cpp
   check-io.cpp
+  check-namelist.cpp
   check-nullify.cpp
   check-omp-structure.cpp
   check-purity.cpp
diff --git a/lib/Semantics/check-namelist.cpp b/lib/Semantics/check-namelist.cpp
new file mode 100644
index 000000000000..c720552bfe08
--- /dev/null
+++ b/lib/Semantics/check-namelist.cpp
@@ -0,0 +1,40 @@
+//===-- lib/Semantics/check-namelist.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 "check-namelist.h"
+
+namespace Fortran::semantics {
+
+void NamelistChecker::Leave(const parser::NamelistStmt &nmlStmt) {
+  for (const auto &x : nmlStmt.v) {
+    if (const auto *nml{std::get<parser::Name>(x.t).symbol}) {
+      for (const auto &nmlObjName : std::get<std::list<parser::Name>>(x.t)) {
+        const auto *nmlObjSymbol{nmlObjName.symbol};
+        if (nmlObjSymbol && nmlObjSymbol->has<ObjectEntityDetails>()) {
+          const auto *symDetails{
+              std::get_if<ObjectEntityDetails>(&nmlObjSymbol->details())};
+          if (symDetails && symDetails->IsAssumedSize()) {  // C8104
+            context_.Say(nmlObjName.source,
+                "A namelist group object '%s' must not be"
+                " assumed-size"_err_en_US,
+                nmlObjSymbol->name());
+          }
+          if (nml->attrs().test(Attr::PUBLIC) &&
+              nmlObjSymbol->attrs().test(Attr::PRIVATE)) {  // C8105
+            context_.Say(nmlObjName.source,
+                "A PRIVATE namelist group object '%s' must not be in a "
+                "PUBLIC namelist"_err_en_US,
+                nmlObjSymbol->name());
+          }
+        }
+      }
+    }
+  }
+}
+
+}
diff --git a/lib/Semantics/check-namelist.h b/lib/Semantics/check-namelist.h
new file mode 100644
index 000000000000..7989ed404bcf
--- /dev/null
+++ b/lib/Semantics/check-namelist.h
@@ -0,0 +1,25 @@
+//===-------lib/Semantics/check-namelist.h --------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_SEMANTICS_CHECK_NAMELIST_H_
+#define FORTRAN_SEMANTICS_CHECK_NAMELIST_H_
+
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/semantics.h"
+
+namespace Fortran::semantics {
+class NamelistChecker : public virtual BaseChecker {
+public:
+  NamelistChecker(SemanticsContext &context) : context_{context} {}
+  void Leave(const parser::NamelistStmt &);
+
+private:
+  SemanticsContext &context_;
+};
+}
+#endif  // FORTRAN_SEMANTICS_CHECK_NAMELIST_H_
diff --git a/lib/Semantics/semantics.cpp b/lib/Semantics/semantics.cpp
index 058bf227a40a..745143267d6d 100644
--- a/lib/Semantics/semantics.cpp
+++ b/lib/Semantics/semantics.cpp
@@ -19,6 +19,7 @@
 #include "check-do-forall.h"
 #include "check-if-stmt.h"
 #include "check-io.h"
+#include "check-namelist.h"
 #include "check-nullify.h"
 #include "check-omp-structure.h"
 #include "check-purity.h"
@@ -111,11 +112,11 @@ template<typename... C> class SemanticsVisitor : public virtual C... {
 };
 
 using StatementSemanticsPass1 = ExprChecker;
-using StatementSemanticsPass2 = SemanticsVisitor<
-    AllocateChecker, ArithmeticIfStmtChecker, AssignmentChecker, CoarrayChecker,
-    DataChecker, DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
-    NullifyChecker, OmpStructureChecker, PurityChecker, ReturnStmtChecker,
-    StopChecker>;
+using StatementSemanticsPass2 = SemanticsVisitor<AllocateChecker,
+    ArithmeticIfStmtChecker, AssignmentChecker, CoarrayChecker, DataChecker,
+    DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
+    NamelistChecker, NullifyChecker, OmpStructureChecker, PurityChecker,
+    ReturnStmtChecker, StopChecker>;
 
 static bool PerformStatementSemantics(
     SemanticsContext &context, parser::Program &program) {
diff --git a/test/Semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
index 51cc8e4850ff..e6b6ad87982d 100644
--- a/test/Semantics/CMakeLists.txt
+++ b/test/Semantics/CMakeLists.txt
@@ -213,6 +213,7 @@ set(ERROR_TESTS
   block-data01.f90
   complex01.f90
   data01.f90
+  namelist01.f90
 )
 
 # These test files have expected symbols in the source
diff --git a/test/Semantics/namelist01.f90 b/test/Semantics/namelist01.f90
new file mode 100644
index 000000000000..81acecbfc725
--- /dev/null
+++ b/test/Semantics/namelist01.f90
@@ -0,0 +1,49 @@
+! Test for checking namelist constraints, C8103-C8105
+
+module dup
+  integer dupName
+  integer uniqueName
+end module dup
+
+subroutine C8103a(x)
+  use dup, only: uniqueName, dupName
+  integer :: x
+  !ERROR: 'dupname' is already declared in this scoping unit
+  namelist /dupName/ x, x
+end subroutine C8103a
+
+subroutine C8103b(y)
+  use dup, only: uniqueName
+  integer :: y
+  namelist /dupName/ y, y
+end subroutine C8103b
+
+subroutine C8104a(ivar, jvar)
+  integer :: ivar(10,8)
+  integer :: jvar(*)
+  NAMELIST /NLIST/ ivar
+  !ERROR: A namelist group object 'jvar' must not be assumed-size
+  NAMELIST /NLIST/ jvar
+end subroutine C8104a
+
+subroutine C8104b(ivar, jvar)
+  integer, dimension(*) :: jvar
+  !ERROR: A namelist group object 'jvar' must not be assumed-size
+  NAMELIST /NLIST/ ivar, jvar
+end subroutine C8104b
+
+subroutine C8104c(jvar)
+  integer :: jvar(10, 3:*)
+  !ERROR: A namelist group object 'jvar' must not be assumed-size
+  NAMELIST /NLIST/ jvar
+end subroutine C8104c
+
+module C8105
+  integer, private :: x
+  public :: NLIST
+  !ERROR: A PRIVATE namelist group object 'x' must not be in a PUBLIC namelist
+  NAMELIST /NLIST/ x
+  !ERROR: A PRIVATE namelist group object 'x' must not be in a PUBLIC namelist
+  NAMELIST /NLIST2/ x
+  public :: NLIST2
+end module C8105

From 2260abe4c27a76e374b286df072e303aa9ea1418 Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Mon, 2 Mar 2020 13:35:24 +0000
Subject: [PATCH 055/345] Link against zlib when LLVM does.

---
 CMakeLists.txt | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2b7a823f7ec3..f293762cd2ea 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -49,6 +49,10 @@ message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}" )
 
 find_package(LLVM REQUIRED CONFIG)
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION} in ${LLVM_DIR}")
+# If LLVM links to zlib we need the imported targets so we can too.
+if(LLVM_ENABLE_ZLIB)
+  find_package(ZLIB REQUIRED)
+endif()
 
 list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
 

From 8bdaf0a521f6630ec2c369b2c41484eff4803d6e Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Mon, 2 Mar 2020 07:59:29 -0800
Subject: [PATCH 056/345] Expression analysis on DataStmtConstant

Data statements contains expressions but they are not wrapped in one of
the kinds of parse tree nodes that are analyzed, like `parser::Expr`.
So potential errors were not discovered.

Change `ExprChecker` to handle `DataStmtConstant` and analyze any
expressions that are contained in it. Note that the analyzed form of
the expression is not yet saved in the parse tree.
---
 include/flang/Semantics/expression.h |  8 ++++---
 lib/Semantics/expression.cpp         | 29 ++++++++++++++++++++++++++
 test/Semantics/CMakeLists.txt        |  1 +
 test/Semantics/data02.f90            | 31 ++++++++++++++++++++++++++++
 4 files changed, 66 insertions(+), 3 deletions(-)
 create mode 100644 test/Semantics/data02.f90

diff --git a/include/flang/Semantics/expression.h b/include/flang/Semantics/expression.h
index 7282a96f1095..bf04275d6004 100644
--- a/include/flang/Semantics/expression.h
+++ b/include/flang/Semantics/expression.h
@@ -230,6 +230,10 @@ class ExpressionAnalyzer {
     return Analyze<parser::DataRef>(dr);
   }
   MaybeExpr Analyze(const parser::StructureComponent &);
+  MaybeExpr Analyze(const parser::SignedIntLiteralConstant &);
+  MaybeExpr Analyze(const parser::SignedRealLiteralConstant &);
+  MaybeExpr Analyze(const parser::SignedComplexLiteralConstant &);
+  MaybeExpr Analyze(const parser::StructureConstructor &);
 
   void Analyze(const parser::CallStmt &);
   const Assignment *Analyze(const parser::AssignmentStmt &);
@@ -240,9 +244,7 @@ class ExpressionAnalyzer {
 
 private:
   MaybeExpr Analyze(const parser::IntLiteralConstant &);
-  MaybeExpr Analyze(const parser::SignedIntLiteralConstant &);
   MaybeExpr Analyze(const parser::RealLiteralConstant &);
-  MaybeExpr Analyze(const parser::SignedRealLiteralConstant &);
   MaybeExpr Analyze(const parser::ComplexPart &);
   MaybeExpr Analyze(const parser::ComplexLiteralConstant &);
   MaybeExpr Analyze(const parser::LogicalLiteralConstant &);
@@ -255,7 +257,6 @@ class ExpressionAnalyzer {
   MaybeExpr Analyze(const parser::CoindexedNamedObject &);
   MaybeExpr Analyze(const parser::CharLiteralConstantSubstring &);
   MaybeExpr Analyze(const parser::ArrayConstructor &);
-  MaybeExpr Analyze(const parser::StructureConstructor &);
   MaybeExpr Analyze(const parser::FunctionReference &,
       std::optional<parser::StructureConstructor> * = nullptr);
   MaybeExpr Analyze(const parser::Expr::Parentheses &);
@@ -448,6 +449,7 @@ class ExprChecker {
     AnalyzePointerAssignmentStmt(context_, x);
     return false;
   }
+  bool Pre(const parser::DataStmtConstant &);
 
   template<typename A> bool Pre(const parser::Scalar<A> &x) {
     AnalyzeExpr(context_, x);
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index a09b1ac62558..09af89f6b61a 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -454,11 +454,14 @@ MaybeExpr ExpressionAnalyzer::IntLiteralConstant(const PARSED &x) {
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::IntLiteralConstant &x) {
+  auto restorer{
+      GetContextualMessages().SetLocation(std::get<parser::CharBlock>(x.t))};
   return IntLiteralConstant(x);
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(
     const parser::SignedIntLiteralConstant &x) {
+  auto restorer{GetContextualMessages().SetLocation(x.source)};
   return IntLiteralConstant(x);
 }
 
@@ -553,6 +556,18 @@ MaybeExpr ExpressionAnalyzer::Analyze(
   return std::nullopt;
 }
 
+MaybeExpr ExpressionAnalyzer::Analyze(
+    const parser::SignedComplexLiteralConstant &x) {
+  auto result{Analyze(std::get<parser::ComplexLiteralConstant>(x.t))};
+  if (!result) {
+    return std::nullopt;
+  } else if (std::get<parser::Sign>(x.t) == parser::Sign::Negative) {
+    return AsGenericExpr(-std::move(std::get<Expr<SomeComplex>>(result->u)));
+  } else {
+    return result;
+  }
+}
+
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::ComplexPart &x) {
   return Analyze(x.u);
 }
@@ -2949,4 +2964,18 @@ bool ExprChecker::Walk(const parser::Program &program) {
   parser::Walk(program, *this);
   return !context_.AnyFatalError();
 }
+
+bool ExprChecker::Pre(const parser::DataStmtConstant &x) {
+  std::visit(
+      common::visitors{
+          [&](const parser::NullInit &) {},
+          [&](const parser::InitialDataTarget &y) {
+            AnalyzeExpr(context_, y.value());
+          },
+          [&](const auto &y) { AnalyzeExpr(context_, y); },
+      },
+      x.u);
+  return false;
+}
+
 }
diff --git a/test/Semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
index e6b6ad87982d..7144ff9cffd1 100644
--- a/test/Semantics/CMakeLists.txt
+++ b/test/Semantics/CMakeLists.txt
@@ -213,6 +213,7 @@ set(ERROR_TESTS
   block-data01.f90
   complex01.f90
   data01.f90
+  data02.f90
   namelist01.f90
 )
 
diff --git a/test/Semantics/data02.f90 b/test/Semantics/data02.f90
new file mode 100644
index 000000000000..4cd593697b23
--- /dev/null
+++ b/test/Semantics/data02.f90
@@ -0,0 +1,31 @@
+! Check that expressions are analyzed in data statements
+
+subroutine s1
+  type :: t
+    character(1) :: c
+  end type
+  type(t) :: x
+  !ERROR: Value in structure constructor of type INTEGER(4) is incompatible with component 'c' of type CHARACTER(KIND=1,LEN=1_4)
+  data x /t(1)/
+end
+
+subroutine s2
+  real :: x1, x2
+  integer :: i1, i2
+  !ERROR: Unsupported REAL(KIND=99)
+  data x1 /1.0_99/
+  !ERROR: Unsupported REAL(KIND=99)
+  data x2 /-1.0_99/
+  !ERROR: INTEGER(KIND=99) is not a supported type
+  data i1 /1_99/
+  !ERROR: INTEGER(KIND=99) is not a supported type
+  data i2 /-1_99/
+end
+
+subroutine s3
+  complex :: z1, z2
+  !ERROR: Unsupported REAL(KIND=99)
+  data z1 /(1.0, 2.0_99)/
+  !ERROR: Unsupported REAL(KIND=99)
+  data z2 /-(1.0, 2.0_99)/
+end

From e2fd5333ff1bb1e8e88cbf35028654bcf70fe9e9 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Thu, 27 Feb 2020 18:00:45 -0800
Subject: [PATCH 057/345] Improve array element errors

When something is parsed as an array element it was sometimes intended
to be a function call or structure constructor. So if the base name is
not found the errors can be confusing. This is an attempt to improve
them.

When the subscript list is empty, it was probably meant to be a function
call, so report that the name is not a function.

If the base is a scalar but there are subscripts, report that it is not
an array.
---
 lib/Semantics/expression.cpp | 27 ++++++++++++++++++++-------
 test/Semantics/data01.f90    |  2 +-
 test/Semantics/resolve59.f90 | 16 ++++++++++++----
 3 files changed, 33 insertions(+), 12 deletions(-)

diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index 09af89f6b61a..8132a6bcd409 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -238,8 +238,10 @@ MaybeExpr ExpressionAnalyzer::CompleteSubscripts(ArrayRef &&ref) {
   if (subscripts == 0) {
     // nothing to check
   } else if (subscripts != symbolRank) {
-    Say("Reference to rank-%d object '%s' has %d subscripts"_err_en_US,
-        symbolRank, symbol.name(), subscripts);
+    if (symbolRank != 0) {
+      Say("Reference to rank-%d object '%s' has %d subscripts"_err_en_US,
+          symbolRank, symbol.name(), subscripts);
+    }
     return std::nullopt;
   } else if (Component * component{ref.base().UnwrapComponent()}) {
     int baseRank{component->base().Rank()};
@@ -886,16 +888,25 @@ std::vector<Subscript> ExpressionAnalyzer::AnalyzeSectionSubscripts(
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayElement &ae) {
-  std::vector<Subscript> subscripts{AnalyzeSectionSubscripts(ae.subscripts)};
   if (MaybeExpr baseExpr{Analyze(ae.base)}) {
-    if (std::optional<DataRef> dataRef{ExtractDataRef(std::move(*baseExpr))}) {
-      if (!subscripts.empty()) {
-        return ApplySubscripts(std::move(*dataRef), std::move(subscripts));
+    if (ae.subscripts.empty()) {
+      // will be converted to function call later or error reported
+      return std::nullopt;
+    } else if (baseExpr->Rank() == 0) {
+      if (const Symbol * symbol{GetLastSymbol(*baseExpr)}) {
+        Say("'%s' is not an array"_err_en_US, symbol->name());
       }
+    } else if (std::optional<DataRef> dataRef{
+                   ExtractDataRef(std::move(*baseExpr))}) {
+      return ApplySubscripts(
+          std::move(*dataRef), AnalyzeSectionSubscripts(ae.subscripts));
     } else {
       Say("Subscripts may be applied only to an object, component, or array constant"_err_en_US);
     }
   }
+  // error was reported: analyze subscripts without reporting more errors
+  auto restorer{GetContextualMessages().DiscardMessages()};
+  AnalyzeSectionSubscripts(ae.subscripts);
   return std::nullopt;
 }
 
@@ -2296,7 +2307,9 @@ static void CheckFuncRefToArrayElementRefHasSubscripts(
       name = &std::get<parser::ProcComponentRef>(proc.u).v.thing.component;
     }
     auto &msg{context.Say(funcRef.v.source,
-        "Reference to array '%s' with empty subscript list"_err_en_US,
+        name->symbol && name->symbol->Rank() == 0
+            ? "'%s' is not a function"_err_en_US
+            : "Reference to array '%s' with empty subscript list"_err_en_US,
         name->source)};
     if (name->symbol) {
       if (semantics::IsFunctionResultWithSameNameAsFunction(*name->symbol)) {
diff --git a/test/Semantics/data01.f90 b/test/Semantics/data01.f90
index 87861016c6c0..c8af31a50d07 100644
--- a/test/Semantics/data01.f90
+++ b/test/Semantics/data01.f90
@@ -42,7 +42,7 @@ subroutine CheckValue
   !OK: constant structure constructor
   data myname / person(1, 'Abcd Ijkl') /
   !C883
-  !ERROR: Must have INTEGER type, but is CHARACTER(1)
+  !ERROR: 'persn' is not an array
   data myname / persn(2, 'Abcd Efgh') /
   !C884
   !ERROR: Structure constructor in data value must be a constant expression
diff --git a/test/Semantics/resolve59.f90 b/test/Semantics/resolve59.f90
index e2c2936d6c7b..e34fcaea01d2 100644
--- a/test/Semantics/resolve59.f90
+++ b/test/Semantics/resolve59.f90
@@ -9,7 +9,7 @@ module m_no_result
   ! testing with data object results
   function f1()
     real :: x, f1
-    !ERROR: Reference to array 'f1' with empty subscript list
+    !ERROR: 'f1' is not a function
     x = acos(f1())
     f1 = x
     x = acos(f1) !OK
@@ -17,7 +17,7 @@ function f1()
   function f2(i)
     integer i
     real :: x, f2
-    !ERROR: Reference to rank-0 object 'f2' has 1 subscripts
+    !ERROR: 'f2' is not an array
     x = acos(f2(i+1))
     f2 = x
     x = acos(f2) !OK
@@ -62,7 +62,7 @@ function f6() result(f6) !OKI (warning)
   end function
   function f7() result(f7) !OKI (warning)
     real :: x, f7
-    !ERROR: Reference to array 'f7' with empty subscript list
+    !ERROR: 'f7' is not a function
     x = acos(f7())
     f7 = x
     x = acos(f7) !OK
@@ -123,7 +123,15 @@ function f5(x) result(r)
   ! testing that calling the result is also caught
   function f6() result(r)
     real :: x, r
-    !ERROR: Reference to array 'r' with empty subscript list
+    !ERROR: 'r' is not a function
     x = r()
   end function
 end module
+
+subroutine array_rank_test()
+  real :: x(10, 10), y
+  !ERROR: Reference to rank-2 object 'x' has 1 subscripts
+  y = x(1)
+  !ERROR: Reference to rank-2 object 'x' has 3 subscripts
+  y = x(1, 2, 3)
+end

From 99ce156e49ec0847ce42a6d10f0a62664714092b Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Mon, 2 Mar 2020 16:43:01 -0800
Subject: [PATCH 058/345] Improve checking of structure constructor arguments

When a misparsed FunctionReference was converted to a StructureConstructor,
the components accessed were not checked for accessibility.

The conversion happens in expression analysis so that where the accessibity
must be checked. So move `CheckAccessibleComponent` to `tools.h` so that it
can be shared by `resolve-names.cpp` and `expression.cpp`.

Add FindModuleContaining to help implement this and use it other places.

Check that an access-spec can only appear in a module.

Remove some unnecessary "semantics::" qualifiers.
---
 include/flang/Semantics/tools.h |  4 ++
 lib/Semantics/expression.cpp    | 14 +++---
 lib/Semantics/resolve-names.cpp | 81 ++++++++++-----------------------
 lib/Semantics/symbol.cpp        | 11 +----
 lib/Semantics/tools.cpp         | 72 ++++++++++++++++++-----------
 test/Semantics/resolve10.f90    | 38 ++++++++++++++--
 test/Semantics/resolve34.f90    | 40 ++++++++++++++++
 7 files changed, 157 insertions(+), 103 deletions(-)

diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index f73958472fdf..2c201954fcb4 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -30,6 +30,7 @@ class DerivedTypeSpec;
 class Scope;
 class Symbol;
 
+const Scope *FindModuleContaining(const Scope &);
 const Symbol *FindCommonBlockContaining(const Symbol &object);
 const Scope *FindProgramUnitContaining(const Scope &);
 const Scope *FindProgramUnitContaining(const Symbol &);
@@ -167,6 +168,9 @@ std::unique_ptr<parser::Message> WhyNotModifiable(SourceName, const SomeExpr &,
 const Symbol *IsExternalInPureContext(const Symbol &, const Scope &);
 bool HasCoarray(const parser::Expr &);
 bool IsPolymorphicAllocatable(const Symbol &);
+// Return an error if component symbol is not accessible from scope (7.5.4.8(2))
+std::optional<parser::MessageFormattedText> CheckAccessibleComponent(
+    const semantics::Scope &, const Symbol &);
 
 // Analysis of image control statements
 bool IsImageControlStmt(const parser::ExecutableConstruct &);
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index a09b1ac62558..e4e6999b5815 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -1402,6 +1402,11 @@ MaybeExpr ExpressionAnalyzer::Analyze(
       }
     }
     if (symbol) {
+      if (const auto *currScope{context_.globalScope().FindScope(source)}) {
+        if (auto msg{CheckAccessibleComponent(*currScope, *symbol)}) {
+          Say(source, *msg);
+        }
+      }
       if (checkConflicts) {
         auto componentIter{
             std::find(components.begin(), components.end(), *symbol)};
@@ -1433,13 +1438,10 @@ MaybeExpr ExpressionAnalyzer::Analyze(
         } else if (symbol->has<semantics::ObjectEntityDetails>()) {
           // C1594(4)
           const auto &innermost{context_.FindScope(expr.source)};
-          if (const auto *pureProc{
-                  semantics::FindPureProcedureContaining(innermost)}) {
-            if (const Symbol *
-                pointer{semantics::FindPointerComponent(*symbol)}) {
+          if (const auto *pureProc{FindPureProcedureContaining(innermost)}) {
+            if (const Symbol * pointer{FindPointerComponent(*symbol)}) {
               if (const Symbol *
-                  object{semantics::FindExternallyVisibleObject(
-                      *value, *pureProc)}) {
+                  object{FindExternallyVisibleObject(*value, *pureProc)}) {
                 if (auto *msg{Say(expr.source,
                         "Externally visible object '%s' may not be "
                         "associated with pointer component '%s' in a "
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 3cb31c9484b9..38a9ba909135 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -230,7 +230,6 @@ class AttrsVisitor : public virtual BaseVisitor {
   bool SetPassNameOn(Symbol &);
   bool SetBindNameOn(Symbol &);
   void Post(const parser::LanguageBindingSpec &);
-  bool Pre(const parser::AccessSpec &);
   bool Pre(const parser::IntentSpec &);
   bool Pre(const parser::Pass &);
 
@@ -435,8 +434,6 @@ class ScopeHandler : public ImplicitRulesVisitor {
   Scope &currScope() { return DEREF(currScope_); }
   // The enclosing scope, skipping blocks and derived types.
   Scope &InclusiveScope();
-  // The global scope, containing program units.
-  Scope &GlobalScope();
 
   // Create a new scope and push it on the scope stack.
   void PushScope(Scope::Kind kind, Symbol *symbol);
@@ -699,6 +696,7 @@ class DeclarationVisitor : public ArraySpecVisitor,
   bool Pre(const parser::NamedConstant &);
   void Post(const parser::EnumDef &);
   bool Pre(const parser::Enumerator &);
+  bool Pre(const parser::AccessSpec &);
   bool Pre(const parser::AsynchronousStmt &);
   bool Pre(const parser::ContiguousStmt &);
   bool Pre(const parser::ExternalStmt &);
@@ -804,7 +802,6 @@ class DeclarationVisitor : public ArraySpecVisitor,
       const parser::Name &, const std::optional<parser::IntegerTypeSpec> &);
   bool CheckUseError(const parser::Name &);
   void CheckAccessibility(const SourceName &, bool, Symbol &);
-  bool CheckAccessibleComponent(const SourceName &, const Symbol &);
   void CheckCommonBlocks();
   void CheckSaveStmts();
   void CheckEquivalenceSets();
@@ -1545,10 +1542,6 @@ void AttrsVisitor::Post(const parser::LanguageBindingSpec &x) {
     bindName_ = EvaluateExpr(*x.v);
   }
 }
-bool AttrsVisitor::Pre(const parser::AccessSpec &x) {
-  attrs_->set(AccessSpecToAttr(x));
-  return false;
-}
 bool AttrsVisitor::Pre(const parser::IntentSpec &x) {
   CHECK(attrs_);
   attrs_->set(IntentSpecToAttr(x));
@@ -1907,16 +1900,9 @@ Scope &ScopeHandler::InclusiveScope() {
       return *scope;
     }
   }
-  common::die("inclusive scope not found");
-}
-Scope &ScopeHandler::GlobalScope() {
-  for (auto *scope = currScope_; scope; scope = &scope->parent()) {
-    if (scope->IsGlobal()) {
-      return *scope;
-    }
-  }
-  common::die("global scope not found");
+  DIE("inclusive scope not found");
 }
+
 void ScopeHandler::PushScope(Scope::Kind kind, Symbol *symbol) {
   PushScope(currScope().MakeScope(kind, symbol));
 }
@@ -2879,37 +2865,6 @@ void DeclarationVisitor::CheckAccessibility(
   }
 }
 
-// Check that component is accessible from current scope.
-bool DeclarationVisitor::CheckAccessibleComponent(
-    const SourceName &name, const Symbol &symbol) {
-  if (!symbol.attrs().test(Attr::PRIVATE)) {
-    return true;
-  }
-  // component must be in a module/submodule because of PRIVATE:
-  const Scope *moduleScope{&symbol.owner()};
-  CHECK(moduleScope->IsDerivedType());
-  while (
-      moduleScope->kind() != Scope::Kind::Module && !moduleScope->IsGlobal()) {
-    moduleScope = &moduleScope->parent();
-  }
-  if (moduleScope->kind() == Scope::Kind::Module) {
-    for (auto *scope{&currScope()}; !scope->IsGlobal();
-         scope = &scope->parent()) {
-      if (scope == moduleScope) {
-        return true;
-      }
-    }
-    Say(name,
-        "PRIVATE component '%s' is only accessible within module '%s'"_err_en_US,
-        name.ToString(), moduleScope->GetName().value());
-  } else {
-    Say(name,
-        "PRIVATE component '%s' is only accessible within its module"_err_en_US,
-        name.ToString());
-  }
-  return false;
-}
-
 void DeclarationVisitor::Post(const parser::TypeDeclarationStmt &) {
   if (!GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {  // C702
     if (const auto *typeSpec{GetDeclTypeSpec()}) {
@@ -3067,6 +3022,19 @@ void DeclarationVisitor::Post(const parser::EnumDef &) {
   enumerationState_ = EnumeratorState{};
 }
 
+bool DeclarationVisitor::Pre(const parser::AccessSpec &x) {
+  Attr attr{AccessSpecToAttr(x)};
+  const Scope &scope{
+      currScope().IsDerivedType() ? currScope().parent() : currScope()};
+  if (!scope.IsModule()) {  // C817
+    Say(currStmtSource().value(),
+        "%s attribute may only appear in the specification part of a module"_err_en_US,
+        EnumToString(attr));
+  }
+  attrs_->set(attr);
+  return false;
+}
+
 bool DeclarationVisitor::Pre(const parser::AsynchronousStmt &x) {
   return HandleAttributeStmt(Attr::ASYNCHRONOUS, x.v);
 }
@@ -3833,12 +3801,7 @@ bool DeclarationVisitor::Pre(const parser::StructureConstructor &x) {
     // we need to resolve its symbol in the scope of the derived type.
     Walk(std::get<parser::ComponentDataSource>(component.t));
     if (const auto &kw{std::get<std::optional<parser::Keyword>>(component.t)}) {
-      if (Symbol * symbol{FindInTypeOrParents(*typeScope, kw->v)}) {
-        if (!kw->v.symbol) {
-          kw->v.symbol = symbol;
-        }
-        CheckAccessibleComponent(kw->v.source, *symbol);
-      }
+      FindInTypeOrParents(*typeScope, kw->v);
     }
   }
   return false;
@@ -5214,9 +5177,11 @@ const parser::Name *DeclarationVisitor::FindComponent(
   } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
     if (const Scope * scope{derived->scope()}) {
       if (Resolve(component, scope->FindComponent(component.source))) {
-        if (CheckAccessibleComponent(component.source, *component.symbol)) {
-          return &component;
+        if (auto msg{
+                CheckAccessibleComponent(currScope(), *component.symbol)}) {
+          context().Say(component.source, *msg);
         }
+        return &component;
       } else {
         SayDerivedType(component.source,
             "Component '%s' not found in derived type '%s'"_err_en_US, *scope);
@@ -5517,7 +5482,7 @@ bool ResolveNamesVisitor::SetProcFlag(
 
 bool ModuleVisitor::Pre(const parser::AccessStmt &x) {
   Attr accessAttr{AccessSpecToAttr(std::get<parser::AccessSpec>(x.t))};
-  if (currScope().kind() != Scope::Kind::Module) {
+  if (!currScope().IsModule()) {  // C869
     Say(currStmtSource().value(),
         "%s statement may only appear in the specification part of a module"_err_en_US,
         EnumToString(accessAttr));
@@ -5525,7 +5490,7 @@ bool ModuleVisitor::Pre(const parser::AccessStmt &x) {
   }
   const auto &accessIds{std::get<std::list<parser::AccessId>>(x.t)};
   if (accessIds.empty()) {
-    if (prevAccessStmt_) {
+    if (prevAccessStmt_) {  // C869
       Say("The default accessibility of this module has already been declared"_err_en_US)
           .Attach(*prevAccessStmt_, "Previous declaration"_en_US);
     }
diff --git a/lib/Semantics/symbol.cpp b/lib/Semantics/symbol.cpp
index f69748ab9eb9..92e2f5fdf7af 100644
--- a/lib/Semantics/symbol.cpp
+++ b/lib/Semantics/symbol.cpp
@@ -72,16 +72,7 @@ const Scope *ModuleDetails::parent() const {
   return isSubmodule_ && scope_ ? &scope_->parent() : nullptr;
 }
 const Scope *ModuleDetails::ancestor() const {
-  if (!isSubmodule_ || !scope_) {
-    return nullptr;
-  }
-  for (auto *scope{scope_};;) {
-    auto *parent{&scope->parent()};
-    if (parent->kind() != Scope::Kind::Module) {
-      return scope;
-    }
-    scope = parent;
-  }
+  return isSubmodule_ && scope_ ? FindModuleContaining(*scope_) : nullptr;
 }
 void ModuleDetails::set_scope(const Scope *scope) {
   CHECK(!scope_);
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index 57980dd76875..922f38f44d0b 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -24,6 +24,24 @@
 
 namespace Fortran::semantics {
 
+// Find this or containing scope that matches predicate
+static const Scope *FindScopeContaining(
+    const Scope &start, std::function<bool(const Scope &)> predicate) {
+  for (const Scope *scope{&start};; scope = &scope->parent()) {
+    if (predicate(*scope)) {
+      return scope;
+    }
+    if (scope->IsGlobal()) {
+      return nullptr;
+    }
+  }
+}
+
+const Scope *FindModuleContaining(const Scope &start) {
+  return FindScopeContaining(
+      start, [](const Scope &scope) { return scope.IsModule(); });
+}
+
 const Symbol *FindCommonBlockContaining(const Symbol &object) {
   if (const auto *details{object.detailsIf<ObjectEntityDetails>()}) {
     return details->commonBlock();
@@ -33,21 +51,15 @@ const Symbol *FindCommonBlockContaining(const Symbol &object) {
 }
 
 const Scope *FindProgramUnitContaining(const Scope &start) {
-  const Scope *scope{&start};
-  while (scope) {
-    switch (scope->kind()) {
+  return FindScopeContaining(start, [](const Scope &scope) {
+    switch (scope.kind()) {
     case Scope::Kind::Module:
     case Scope::Kind::MainProgram:
     case Scope::Kind::Subprogram:
-    case Scope::Kind::BlockData: return scope;
-    case Scope::Kind::Global: return nullptr;
-    case Scope::Kind::DerivedType:
-    case Scope::Kind::Block:
-    case Scope::Kind::Forall:
-    case Scope::Kind::ImpliedDos: scope = &scope->parent();
+    case Scope::Kind::BlockData: return true;
+    default: return false;
     }
-  }
-  return nullptr;
+  });
 }
 
 const Scope *FindProgramUnitContaining(const Symbol &symbol) {
@@ -164,16 +176,9 @@ bool IsUseAssociated(const Symbol &symbol, const Scope &scope) {
 
 bool DoesScopeContain(
     const Scope *maybeAncestor, const Scope &maybeDescendent) {
-  if (maybeAncestor) {
-    const Scope *scope{&maybeDescendent};
-    while (!scope->IsGlobal()) {
-      scope = &scope->parent();
-      if (scope == maybeAncestor) {
-        return true;
-      }
-    }
-  }
-  return false;
+  return maybeAncestor && !maybeDescendent.IsGlobal() &&
+      FindScopeContaining(maybeDescendent.parent(),
+          [&](const Scope &scope) { return &scope == maybeAncestor; });
 }
 
 bool DoesScopeContain(const Scope *maybeAncestor, const Symbol &symbol) {
@@ -717,7 +722,7 @@ bool IsAssumedLengthExternalCharacterFunction(const Symbol &symbol) {
 
 const Symbol *IsExternalInPureContext(
     const Symbol &symbol, const Scope &scope) {
-  if (const auto *pureProc{semantics::FindPureProcedureContaining(scope)}) {
+  if (const auto *pureProc{FindPureProcedureContaining(scope)}) {
     if (const Symbol * root{GetAssociationRoot(symbol)}) {
       if (const Symbol *
           visible{FindExternallyVisibleObject(*root, *pureProc)}) {
@@ -956,6 +961,21 @@ bool IsPolymorphicAllocatable(const Symbol &symbol) {
   return IsAllocatable(symbol) && IsPolymorphic(symbol);
 }
 
+std::optional<parser::MessageFormattedText> CheckAccessibleComponent(
+    const Scope &scope, const Symbol &symbol) {
+  CHECK(symbol.owner().IsDerivedType());  // symbol must be a component
+  if (symbol.attrs().test(Attr::PRIVATE)) {
+    if (const Scope * moduleScope{FindModuleContaining(symbol.owner())}) {
+      if (!moduleScope->sourceRange().Contains(scope.sourceRange())) {
+        return parser::MessageFormattedText{
+            "PRIVATE component '%s' is only accessible within module '%s'"_err_en_US,
+            symbol.name(), moduleScope->GetName().value()};
+      }
+    }
+  }
+  return std::nullopt;
+}
+
 std::list<SourceName> OrderParameterNames(const Symbol &typeSymbol) {
   std::list<SourceName> result;
   if (const DerivedTypeSpec * spec{typeSymbol.GetParentTypeSpec()}) {
@@ -1227,10 +1247,10 @@ const Symbol *FindImmediateComponent(const DerivedTypeSpec &type,
 }
 
 bool IsFunctionResult(const Symbol &symbol) {
-  return (symbol.has<semantics::ObjectEntityDetails>() &&
-             symbol.get<semantics::ObjectEntityDetails>().isFuncResult()) ||
-      (symbol.has<semantics::ProcEntityDetails>() &&
-          symbol.get<semantics::ProcEntityDetails>().isFuncResult());
+  return (symbol.has<ObjectEntityDetails>() &&
+             symbol.get<ObjectEntityDetails>().isFuncResult()) ||
+      (symbol.has<ProcEntityDetails>() &&
+          symbol.get<ProcEntityDetails>().isFuncResult());
 }
 
 bool IsFunctionResultWithSameNameAsFunction(const Symbol &symbol) {
diff --git a/test/Semantics/resolve10.f90 b/test/Semantics/resolve10.f90
index 5866faafe503..75a44a4f5e57 100644
--- a/test/Semantics/resolve10.f90
+++ b/test/Semantics/resolve10.f90
@@ -1,10 +1,42 @@
 module m
   public
+  type t
+    integer, private :: i
+  end type
   !ERROR: The default accessibility of this module has already been declared
-  private
+  private  !C869
 end
 
-subroutine s
+subroutine s1
   !ERROR: PUBLIC statement may only appear in the specification part of a module
-  public
+  public  !C869
+end
+
+subroutine s2
+  !ERROR: PRIVATE attribute may only appear in the specification part of a module
+  integer, private :: i  !C817
+end
+
+subroutine s3
+  type t
+    !ERROR: PUBLIC attribute may only appear in the specification part of a module
+    integer, public :: i  !C817
+  end type
+end
+
+module m4
+  interface
+    module subroutine s()
+    end subroutine
+  end interface
+end
+submodule(m4) sm4
+  !ERROR: PUBLIC statement may only appear in the specification part of a module
+  public  !C869
+  !ERROR: PUBLIC attribute may only appear in the specification part of a module
+  real, public :: x  !C817
+  type :: t
+    !ERROR: PRIVATE attribute may only appear in the specification part of a module
+    real, private :: y  !C817
+  end type
 end
diff --git a/test/Semantics/resolve34.f90 b/test/Semantics/resolve34.f90
index 0f0c8d1d23de..c3b28bb929b8 100644
--- a/test/Semantics/resolve34.f90
+++ b/test/Semantics/resolve34.f90
@@ -91,3 +91,43 @@ subroutine s7
   !ERROR: PRIVATE component 't1' is only accessible within module 'm7'
   j = x%t1%i1
 end
+
+! 7.5.4.8(2)
+module m8
+  type  :: t
+    integer :: i1
+    integer, private :: i2
+  end type
+contains
+  subroutine s0
+    type(t) :: x
+    x = t(i1=2, i2=5)  !OK
+  end
+end
+subroutine s8
+  use m8
+  type(t) :: x
+  !ERROR: PRIVATE component 'i2' is only accessible within module 'm8'
+  x = t(2, 5)
+  !ERROR: PRIVATE component 'i2' is only accessible within module 'm8'
+  x = t(i1=2, i2=5)
+end
+
+! 7.5.4.8(2)
+module m9
+  interface
+    module subroutine s()
+    end subroutine
+  end interface
+  type  :: t
+    integer :: i1
+    integer, private :: i2
+  end type
+end
+submodule(m9) sm8
+contains
+  module subroutine s
+    type(t) :: x
+    x = t(i1=2, i2=5)  !OK
+  end
+end

From a807862ab85f2d2206f8fa77d927b0e110513620 Mon Sep 17 00:00:00 2001
From: Steve Scalpone <sscalpone@nvidia.com>
Date: Thu, 5 Mar 2020 05:40:44 -0800
Subject: [PATCH 059/345] Don't link to libm (#1038)

* Don't link to libm on windows

* Don't link to libm in Unix as well
---
 lib/Evaluate/CMakeLists.txt  | 1 -
 test/Evaluate/CMakeLists.txt | 1 -
 2 files changed, 2 deletions(-)

diff --git a/lib/Evaluate/CMakeLists.txt b/lib/Evaluate/CMakeLists.txt
index 8da75eddff69..a3391dc40394 100644
--- a/lib/Evaluate/CMakeLists.txt
+++ b/lib/Evaluate/CMakeLists.txt
@@ -38,7 +38,6 @@ target_link_libraries(FortranEvaluate
   FortranCommon
   FortranDecimal
   FortranParser
-  m
 )
 
 install (TARGETS FortranEvaluate
diff --git a/test/Evaluate/CMakeLists.txt b/test/Evaluate/CMakeLists.txt
index f1bbc1dfd7c6..b08c1431df70 100644
--- a/test/Evaluate/CMakeLists.txt
+++ b/test/Evaluate/CMakeLists.txt
@@ -98,7 +98,6 @@ target_link_libraries(real-test
   FortranEvaluate
   FortranDecimal
   FortranSemantics
-  m
 )
 
 add_executable(reshape-test

From 0e32eebf7fec8cd07ab3280565799cfbf2ca55e2 Mon Sep 17 00:00:00 2001
From: Steve Scalpone <sscalpone@nvidia.com>
Date: Thu, 5 Mar 2020 06:31:24 -0800
Subject: [PATCH 060/345] Add missing include <algorithm> for std::max (#1028)

---
 runtime/numeric-output.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/runtime/numeric-output.cpp b/runtime/numeric-output.cpp
index c0c617b8c206..fdf0cde340e1 100644
--- a/runtime/numeric-output.cpp
+++ b/runtime/numeric-output.cpp
@@ -8,6 +8,7 @@
 
 #include "numeric-output.h"
 #include "flang/Common/unsigned-const-division.h"
+#include <algorithm>
 
 namespace Fortran::runtime::io {
 

From a9a725eb9d2c39a203f4b4f55f1e03c5e17f6cf7 Mon Sep 17 00:00:00 2001
From: Steve Scalpone <sscalpone@nvidia.com>
Date: Thu, 5 Mar 2020 06:52:35 -0800
Subject: [PATCH 061/345] Use std::mutex instead of pthreads (#1006)

* Use std::mutex for portability.
---
 runtime/lock.h | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/runtime/lock.h b/runtime/lock.h
index a26c96542c88..ecf55889aaff 100644
--- a/runtime/lock.h
+++ b/runtime/lock.h
@@ -11,27 +11,23 @@
 #ifndef FORTRAN_RUNTIME_LOCK_H_
 #define FORTRAN_RUNTIME_LOCK_H_
 
-#include <pthread.h>
+#include <mutex>
 
 namespace Fortran::runtime {
 
 class Lock {
 public:
-  Lock() { pthread_mutex_init(&mutex_, nullptr); }
-  ~Lock() { pthread_mutex_destroy(&mutex_); }
-  void Take() { pthread_mutex_lock(&mutex_); }
-  bool Try() { return pthread_mutex_trylock(&mutex_) != 0; }
-  void Drop() { pthread_mutex_unlock(&mutex_); }
-
+  void Take() { mutex_.lock(); }
+  bool Try() { return mutex_.try_lock(); }
+  void Drop() { mutex_.unlock(); }
   void CheckLocked(const Terminator &terminator) {
     if (Try()) {
       Drop();
       terminator.Crash("Lock::CheckLocked() failed");
     }
   }
-
 private:
-  pthread_mutex_t mutex_;
+  std::mutex mutex_;
 };
 
 class CriticalSection {

From a8edb328f717305143ac827132c6d6f45e6e11b9 Mon Sep 17 00:00:00 2001
From: Steve Scalpone <sscalpone@nvidia.com>
Date: Thu, 5 Mar 2020 07:09:29 -0800
Subject: [PATCH 062/345] Use a file descriptor in Temp struct (#1036)

The struct Temp is used in the function call createUniqueFile
which only takes in a file descriptor instead of a file handler.
In Unix these are the same thing, but in Windows they are different.
Therefore, the type of the member of struct Temp is changed
from file handler to file descriptor and when closing the file
the file descriptor is converted to a file handler.
---
 lib/Semantics/mod-file.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/Semantics/mod-file.cpp b/lib/Semantics/mod-file.cpp
index 2810c3542446..7251e3fa285a 100644
--- a/lib/Semantics/mod-file.cpp
+++ b/lib/Semantics/mod-file.cpp
@@ -617,15 +617,16 @@ std::ostream &PutLower(std::ostream &os, const std::string &str) {
 }
 
 struct Temp {
-  Temp(llvm::sys::fs::file_t fd, std::string path) : fd{fd}, path{path} {}
+  Temp(int fd, std::string path) : fd{fd}, path{path} {}
   Temp(Temp &&t) : fd{std::exchange(t.fd, -1)}, path{std::move(t.path)} {}
   ~Temp() {
     if (fd >= 0) {
-      llvm::sys::fs::closeFile(fd);
+      llvm::sys::fs::file_t native{llvm::sys::fs::convertFDToNativeFile(fd)};
+      llvm::sys::fs::closeFile(native);
       llvm::sys::fs::remove(path.c_str());
     }
   }
-  llvm::sys::fs::file_t fd;
+  int fd;
   std::string path;
 };
 
@@ -639,7 +640,7 @@ static llvm::ErrorOr<Temp> MkTemp(const std::string &path) {
   CHECK(length > suffix.length() &&
       path.substr(length - suffix.length()) == suffix);
   auto prefix{path.substr(0, length - suffix.length())};
-  llvm::sys::fs::file_t fd;
+  int fd;
   llvm::SmallString<16> tempPath;
   if (std::error_code err{llvm::sys::fs::createUniqueFile(
           prefix + "%%%%%%" + suffix, fd, tempPath)}) {

From 3cbe344f82a0898c9e20b6718d5f80d52670838b Mon Sep 17 00:00:00 2001
From: Steve Scalpone <sscalpone@nvidia.com>
Date: Thu, 5 Mar 2020 07:12:06 -0800
Subject: [PATCH 063/345] Change README to refer to LLVM_BUILD_DIR. (#1033)

* Change README to refer to LLVM_BUILD_DIR.

LLVM_INSTALL_TOOLS doesn't to install llvm-lit. However pointing to the cmake file in the build directory works fine, and lit and FileCheck will be picked up correctly this way.
---
 README.md               | 17 +++--------------
 test-lit/CMakeLists.txt |  7 +------
 2 files changed, 4 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index d6d87c79e32c..d0887a305a14 100644
--- a/README.md
+++ b/README.md
@@ -77,21 +77,10 @@ the variable `LLVM_DIR` to find the installed components.
 To get the correct LLVM libraries included in your f18 build,
 define LLVM_DIR on the cmake command line.
 ```
-LLVM=<LLVM_INSTALLATION_DIR>/lib/cmake/llvm cmake -DLLVM_DIR=$LLVM ...
+LLVM=<LLVM_BUILD_DIR>/lib/cmake/llvm cmake -DLLVM_DIR=$LLVM ...
 ```
-where `LLVM_INSTALLATION_DIR` is
-the top-level directory
-where llvm is installed.
-
-### LLVM dependency for lit Regression tests
-
-F18 has tests that use the lit framework, these tests rely on the
-presence of llvm tools as llvm-lit, FileCheck, and others.
-These tools are installed when LLVM build set:
-```
-LLVM_INSTALL_UTILS=On
-```
-to run the regression tests on f18.
+where `LLVM_BUILD_DIR` is
+the top-level directory where LLVM was built.
 
 ### Building f18 with GCC
 
diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index 111814303b0b..965adff78976 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -14,17 +14,12 @@ set(FLANG_TEST_PARAMS
   flang_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py)
 
 set(FLANG_TEST_DEPENDS
-  flang
   f18
-  llvm-lit
-  FileCheck
-  count
-  not
 )
 add_lit_testsuite(check-all "Running the Flang regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   PARAMS ${FLANG_TEST_PARAMS}
-  DEPENDS ${FLANG_TEST_DEPENS}
+  DEPENDS ${FLANG_TEST_DEPENDS}
   )
 set_target_properties(check-all PROPERTIES FOLDER "Tests")
 

From 70fa71ff7be3024a44b8214be663b9701adc5b1f Mon Sep 17 00:00:00 2001
From: Isuru Fernando <isuruf@gmail.com>
Date: Wed, 26 Feb 2020 12:05:28 -0600
Subject: [PATCH 064/345] Fix an ambiguous overload error

---
 include/flang/Parser/dump-parse-tree.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/flang/Parser/dump-parse-tree.h b/include/flang/Parser/dump-parse-tree.h
index d132e93eeab5..818dfbd625bc 100644
--- a/include/flang/Parser/dump-parse-tree.h
+++ b/include/flang/Parser/dump-parse-tree.h
@@ -784,7 +784,7 @@ class ParseTreeDumper {
         std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t>) {
       ss << x;
     }
-    if (ss.tellp() != 0) {
+    if (ss.tellp()) {
       return ss.str();
     }
     if constexpr (std::is_same_v<T, Name> || HasSource<T>::value) {

From d971333025bb316529d233528a725fcc726f6615 Mon Sep 17 00:00:00 2001
From: Steve Scalpone <sscalpone@nvidia.com>
Date: Thu, 5 Mar 2020 08:06:58 -0800
Subject: [PATCH 065/345] Fix for 'wrong constant folding of assumed-rank
 array' (#1010)

https://github.com/flang-compiler/f18/issues/990
---
 include/flang/Semantics/tools.h |  4 ++++
 lib/Evaluate/fold-integer.cpp   | 14 +++++++++++++-
 lib/Semantics/expression.cpp    |  2 +-
 test/Semantics/assign03.f90     |  6 ++++++
 4 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index 2c201954fcb4..0dd43a281c06 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -158,6 +158,10 @@ inline bool IsAssumedSizeArray(const Symbol &symbol) {
   const auto *details{symbol.detailsIf<ObjectEntityDetails>()};
   return details && details->IsAssumedSize();
 }
+inline bool IsAssumedRankArray(const Symbol &symbol) {
+  const auto *details{symbol.detailsIf<ObjectEntityDetails>()};
+  return details && details->IsAssumedRank();
+}
 bool IsAssumedLengthCharacter(const Symbol &);
 bool IsAssumedLengthExternalCharacterFunction(const Symbol &);
 // Is the symbol modifiable in this scope
diff --git a/lib/Evaluate/fold-integer.cpp b/lib/Evaluate/fold-integer.cpp
index 1e1e06a28681..bf0eb6ca6c3e 100644
--- a/lib/Evaluate/fold-integer.cpp
+++ b/lib/Evaluate/fold-integer.cpp
@@ -509,7 +509,19 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
           cx->u)};
     }
   } else if (name == "rank") {
-    // TODO assumed-rank dummy argument
+    if (const auto *array{UnwrapExpr<Expr<SomeType>>(args[0])}) {
+      if (auto named{ExtractNamedEntity(*array)}) {
+        const Symbol &symbol{named->GetLastSymbol()};
+        if (semantics::IsAssumedRankArray(symbol)) {
+          // DescriptorInquiry can only be placed in expression of kind
+          // DescriptorInquiry::Result::kind.
+          return ConvertToType<T>(Expr<
+              Type<TypeCategory::Integer, DescriptorInquiry::Result::kind>>{
+              DescriptorInquiry{*named, DescriptorInquiry::Field::Rank}});
+        }
+      }
+      return Expr<T>{args[0].value().Rank()};
+    }
     return Expr<T>{args[0].value().Rank()};
   } else if (name == "selected_char_kind") {
     if (const auto *chCon{UnwrapExpr<Constant<TypeOf<std::string>>>(args[0])}) {
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index ef7c76429a1b..2e13b211b7fe 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -2502,7 +2502,7 @@ bool ExpressionAnalyzer::EnforceTypeConstraint(parser::CharBlock at,
     const MaybeExpr &result, TypeCategory category, bool defaultKind) {
   if (result) {
     if (auto type{result->GetType()}) {
-      if (type->category() != category) {  // C885
+      if (type->category() != category) { // C885
         Say(at, "Must have %s type, but is %s"_err_en_US,
             ToUpperCase(EnumToString(category)),
             ToUpperCase(type->AsFortran()));
diff --git a/test/Semantics/assign03.f90 b/test/Semantics/assign03.f90
index 7c4895368c52..6127de22de4f 100644
--- a/test/Semantics/assign03.f90
+++ b/test/Semantics/assign03.f90
@@ -191,5 +191,11 @@ subroutine s12
     !ERROR: Must be a constant value
     logical, parameter :: l5 = is_contiguous(y(v,1)%a(1,1))
   end
+  subroutine test3(b)
+    integer, intent(inout) :: b(..)
+    !ERROR: Must be a constant value
+    integer, parameter :: i = rank(b)
+  end subroutine
+
 
 end

From 4c6e5608adddf25a53fbdbfd5f0e1b98278cc5ec Mon Sep 17 00:00:00 2001
From: Isuru Fernando <isuruf@gmail.com>
Date: Fri, 6 Mar 2020 00:51:41 -0600
Subject: [PATCH 066/345] Rename EXTERN_C_END to FORTRAN_EXTERN_C_END

Since EXTERN_C_END is a macro defined in Windows system headers
---
 runtime/c-or-cpp.h | 4 ++--
 runtime/main.h     | 4 ++--
 runtime/stop.h     | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/runtime/c-or-cpp.h b/runtime/c-or-cpp.h
index b514838cdc6c..d9029261ae4a 100644
--- a/runtime/c-or-cpp.h
+++ b/runtime/c-or-cpp.h
@@ -20,8 +20,8 @@
 #define DEFAULT_VALUE(x)
 #endif
 
-#define EXTERN_C_BEGIN IF_CPLUSPLUS(extern "C" {)
-#define EXTERN_C_END IF_CPLUSPLUS( \
+#define FORTRAN_EXTERN_C_BEGIN IF_CPLUSPLUS(extern "C" {)
+#define FORTRAN_EXTERN_C_END IF_CPLUSPLUS( \
   })
 #define NORETURN IF_CPLUSPLUS([[noreturn]])
 #define NO_ARGUMENTS IF_NOT_CPLUSPLUS(void)
diff --git a/runtime/main.h b/runtime/main.h
index 2f2504826465..94ce3a93b70b 100644
--- a/runtime/main.h
+++ b/runtime/main.h
@@ -12,8 +12,8 @@
 #include "c-or-cpp.h"
 #include "entry-names.h"
 
-EXTERN_C_BEGIN
+FORTRAN_EXTERN_C_BEGIN
 void RTNAME(ProgramStart)(int, const char *[], const char *[]);
-EXTERN_C_END
+FORTRAN_EXTERN_C_END
 
 #endif  // FORTRAN_RUNTIME_MAIN_H_
diff --git a/runtime/stop.h b/runtime/stop.h
index 8fb1d8d4cffd..24fea0b4f7db 100644
--- a/runtime/stop.h
+++ b/runtime/stop.h
@@ -13,7 +13,7 @@
 #include "entry-names.h"
 #include <stdlib.h>
 
-EXTERN_C_BEGIN
+FORTRAN_EXTERN_C_BEGIN
 
 // Program-initiated image stop
 NORETURN void RTNAME(StopStatement)(int code DEFAULT_VALUE(EXIT_SUCCESS),
@@ -23,6 +23,6 @@ NORETURN void RTNAME(StopStatementText)(const char *,
 NORETURN void RTNAME(FailImageStatement)(NO_ARGUMENTS);
 NORETURN void RTNAME(ProgramEndStatement)(NO_ARGUMENTS);
 
-EXTERN_C_END
+FORTRAN_EXTERN_C_END
 
 #endif  // FORTRAN_RUNTIME_STOP_H_

From cede2971ff863b8dd6a2c8727f6566a444ac7a52 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Fri, 6 Mar 2020 17:05:04 -0800
Subject: [PATCH 067/345] Fix handling of DataRef when analyzing
 CoindexedNamedObject

As we loop through the Components, maintain a pointer to the current
DataRef rather than moving it. This is more efficient and the previous
behavior caused illegal memory accesses.
---
 lib/Semantics/expression.cpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index 2e13b211b7fe..dd016f9433d3 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -1023,22 +1023,23 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::StructureComponent &sc) {
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::CoindexedNamedObject &x) {
-  if (auto dataRef{ExtractDataRef(Analyze(x.base))}) {
+  if (auto maybeDataRef{ExtractDataRef(Analyze(x.base))}) {
+    DataRef *dataRef{&*maybeDataRef};
     std::vector<Subscript> subscripts;
     SymbolVector reversed;
     if (auto *aRef{std::get_if<ArrayRef>(&dataRef->u)}) {
       subscripts = std::move(aRef->subscript());
       reversed.push_back(aRef->GetLastSymbol());
       if (Component * component{aRef->base().UnwrapComponent()}) {
-        *dataRef = std::move(component->base());
+        dataRef = &component->base();
       } else {
-        dataRef.reset();
+        dataRef = nullptr;
       }
     }
     if (dataRef) {
       while (auto *component{std::get_if<Component>(&dataRef->u)}) {
         reversed.push_back(component->GetLastSymbol());
-        *dataRef = std::move(component->base());
+        dataRef = &component->base();
       }
       if (auto *baseSym{std::get_if<SymbolRef>(&dataRef->u)}) {
         reversed.push_back(*baseSym);
@@ -2502,7 +2503,7 @@ bool ExpressionAnalyzer::EnforceTypeConstraint(parser::CharBlock at,
     const MaybeExpr &result, TypeCategory category, bool defaultKind) {
   if (result) {
     if (auto type{result->GetType()}) {
-      if (type->category() != category) { // C885
+      if (type->category() != category) {  // C885
         Say(at, "Must have %s type, but is %s"_err_en_US,
             ToUpperCase(EnumToString(category)),
             ToUpperCase(type->AsFortran()));

From 864e9cfc7ee98e3646052fdc757943011d641691 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Thu, 5 Mar 2020 12:56:30 -0800
Subject: [PATCH 068/345] Change WhyNotModifiable to return optional

One overload of WhyNotModifiable returned an optional message while the
other returns a unique_ptr. Change the latter to be consistent with the
former and other message-returning functions in this file.

Also, reorder the if clauses to reduce the level of indentation.
---
 include/flang/Semantics/tools.h |  2 +-
 lib/Semantics/check-call.cpp    |  7 +++----
 lib/Semantics/tools.cpp         | 32 +++++++++++++-------------------
 3 files changed, 17 insertions(+), 24 deletions(-)

diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index 0dd43a281c06..e2179075e087 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -167,7 +167,7 @@ bool IsAssumedLengthExternalCharacterFunction(const Symbol &);
 // Is the symbol modifiable in this scope
 std::optional<parser::MessageFixedText> WhyNotModifiable(
     const Symbol &, const Scope &);
-std::unique_ptr<parser::Message> WhyNotModifiable(SourceName, const SomeExpr &,
+std::optional<parser::Message> WhyNotModifiable(SourceName, const SomeExpr &,
     const Scope &, bool vectorSubscriptIsOk = false);
 const Symbol *IsExternalInPureContext(const Symbol &, const Scope &);
 bool HasCoarray(const parser::Expr &);
diff --git a/lib/Semantics/check-call.cpp b/lib/Semantics/check-call.cpp
index bca65e9909b7..3273ed22da40 100644
--- a/lib/Semantics/check-call.cpp
+++ b/lib/Semantics/check-call.cpp
@@ -329,13 +329,12 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
   }
   if (reason && scope) {
     bool vectorSubscriptIsOk{isElemental || dummyIsValue};  // 15.5.2.4(21)
-    std::unique_ptr<parser::Message> why{
-        WhyNotModifiable(messages.at(), actual, *scope, vectorSubscriptIsOk)};
-    if (why.get()) {
+    if (auto why{WhyNotModifiable(
+            messages.at(), actual, *scope, vectorSubscriptIsOk)}) {
       if (auto *msg{messages.Say(
               "Actual argument associated with %s %s must be definable"_err_en_US,
               reason, dummyName)}) {
-        msg->Attach(std::move(why));
+        msg->Attach(*why);
       }
     }
   }
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index 922f38f44d0b..de9131d8f86b 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -789,29 +789,23 @@ std::optional<parser::MessageFixedText> WhyNotModifiable(
   }
 }
 
-std::unique_ptr<parser::Message> WhyNotModifiable(parser::CharBlock at,
+std::optional<parser::Message> WhyNotModifiable(parser::CharBlock at,
     const SomeExpr &expr, const Scope &scope, bool vectorSubscriptIsOk) {
-  if (evaluate::IsVariable(expr)) {
-    if (auto dataRef{evaluate::ExtractDataRef(expr)}) {
-      if (!vectorSubscriptIsOk && evaluate::HasVectorSubscript(expr)) {
-        return std::make_unique<parser::Message>(
-            at, "variable has a vector subscript"_en_US);
-      } else {
-        const Symbol &symbol{dataRef->GetFirstSymbol()};
-        if (auto maybeWhy{WhyNotModifiable(symbol, scope)}) {
-          return std::make_unique<parser::Message>(symbol.name(),
-              parser::MessageFormattedText{
-                  std::move(*maybeWhy), symbol.name()});
-        }
-      }
-    } else {
-      // reference to function returning POINTER
+  if (!evaluate::IsVariable(expr)) {
+    return parser::Message{at, "Expression is not a variable"_en_US};
+  } else if (auto dataRef{evaluate::ExtractDataRef(expr)}) {
+    if (!vectorSubscriptIsOk && evaluate::HasVectorSubscript(expr)) {
+      return parser::Message{at, "Variable has a vector subscript"_en_US};
+    }
+    const Symbol &symbol{dataRef->GetFirstSymbol()};
+    if (auto maybeWhy{WhyNotModifiable(symbol, scope)}) {
+      return parser::Message{symbol.name(),
+          parser::MessageFormattedText{std::move(*maybeWhy), symbol.name()}};
     }
   } else {
-    return std::make_unique<parser::Message>(
-        at, "expression is not a variable"_en_US);
+    // reference to function returning POINTER
   }
-  return {};
+  return std::nullopt;
 }
 
 class ImageControlStmtHelper {

From 305a3470e572161483b0f430514b77ba19f932ea Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Thu, 5 Mar 2020 13:05:45 -0800
Subject: [PATCH 069/345] Change CheckDefinabilityInPureScope to return bool

Have CheckDefinabilityInPureScope and CheckCopyabilityInPureScope return
false when their checks fail and report errors so that we will be able
to avoid reporting extra errors in those cases.
---
 lib/Semantics/assignment.cpp | 68 ++++++++++++++++++++----------------
 lib/Semantics/assignment.h   |  4 +--
 2 files changed, 39 insertions(+), 33 deletions(-)

diff --git a/lib/Semantics/assignment.cpp b/lib/Semantics/assignment.cpp
index dfa11e800804..b309433e68f8 100644
--- a/lib/Semantics/assignment.cpp
+++ b/lib/Semantics/assignment.cpp
@@ -43,7 +43,7 @@ class AssignmentContext {
   void Analyze(const parser::ConcurrentControl &);
 
 private:
-  void CheckForPureContext(const SomeExpr &lhs, const SomeExpr &rhs,
+  bool CheckForPureContext(const SomeExpr &lhs, const SomeExpr &rhs,
       parser::CharBlock rhsSource, bool isPointerAssignment);
   void CheckShape(parser::CharBlock, const SomeExpr *);
   template<typename... A>
@@ -110,16 +110,18 @@ static const char *WhyBaseObjectIsSuspicious(
   }
 }
 
-// Checks C1594(1,2)
-void CheckDefinabilityInPureScope(parser::ContextualMessages &messages,
+// Checks C1594(1,2); false if check fails
+bool CheckDefinabilityInPureScope(parser::ContextualMessages &messages,
     const Symbol &lhs, const Scope &context, const Scope &pure) {
   if (pure.symbol()) {
     if (const char *why{WhyBaseObjectIsSuspicious(lhs, context)}) {
       evaluate::SayWithDeclaration(messages, lhs,
           "Pure subprogram '%s' may not define '%s' because it is %s"_err_en_US,
           pure.symbol()->name(), lhs.name(), why);
+      return false;
     }
   }
+  return true;
 }
 
 static std::optional<std::string> GetPointerComponentDesignatorName(
@@ -135,21 +137,24 @@ static std::optional<std::string> GetPointerComponentDesignatorName(
   return std::nullopt;
 }
 
-// Checks C1594(5,6)
-void CheckCopyabilityInPureScope(parser::ContextualMessages &messages,
+// Checks C1594(5,6); false if check fails
+bool CheckCopyabilityInPureScope(parser::ContextualMessages &messages,
     const SomeExpr &expr, const Scope &scope) {
   if (const Symbol * base{GetFirstSymbol(expr)}) {
     if (const char *why{WhyBaseObjectIsSuspicious(*base, scope)}) {
       if (auto pointer{GetPointerComponentDesignatorName(expr)}) {
         evaluate::SayWithDeclaration(messages, *base,
-            "A pure subprogram may not copy the value of '%s' because it is %s and has the POINTER component '%s'"_err_en_US,
+            "A pure subprogram may not copy the value of '%s' because it is %s"
+            " and has the POINTER component '%s'"_err_en_US,
             base->name(), why, *pointer);
+        return false;
       }
     }
   }
+  return true;
 }
 
-void AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
+bool AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
     const SomeExpr &rhs, parser::CharBlock source, bool isPointerAssignment) {
   const Scope &scope{context_.FindScope(source)};
   if (const Scope * pure{FindPureProcedureContaining(scope)}) {
@@ -160,13 +165,12 @@ void AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
           "A pure subprogram may not define a coindexed object"_err_en_US);
     } else if (const Symbol * base{GetFirstSymbol(lhs)}) {
       if (const auto *assoc{base->detailsIf<AssocEntityDetails>()}) {
-        if (auto dataRef{ExtractDataRef(assoc->expr())}) {
-          // ASSOCIATE(a=>x) -- check x, not a, for "a=..."
-          CheckDefinabilityInPureScope(
-              messages, dataRef->GetFirstSymbol(), scope, *pure);
-        }
-      } else {
-        CheckDefinabilityInPureScope(messages, *base, scope, *pure);
+        auto dataRef{ExtractDataRef(assoc->expr())};
+        // ASSOCIATE(a=>x) -- check x, not a, for "a=..."
+        base = dataRef ? &dataRef->GetFirstSymbol() : nullptr;
+      }
+      if (!CheckDefinabilityInPureScope(messages, *base, scope, *pure)) {
+        return false;
       }
     }
     if (isPointerAssignment) {
@@ -176,29 +180,31 @@ void AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
           evaluate::SayWithDeclaration(messages, *base,
               "A pure subprogram may not use '%s' as the target of pointer assignment because it is %s"_err_en_US,
               base->name(), why);
+          return false;
         }
       }
-    } else {
-      if (auto type{evaluate::DynamicType::From(lhs)}) {
-        // C1596 checks for polymorphic deallocation in a pure subprogram
-        // due to automatic reallocation on assignment
-        if (type->IsPolymorphic()) {
-          context_.Say(
-              "Deallocation of polymorphic object is not permitted in a pure subprogram"_err_en_US);
-        }
-        if (const DerivedTypeSpec * derived{GetDerivedTypeSpec(type)}) {
-          if (auto bad{FindPolymorphicAllocatableNonCoarrayUltimateComponent(
-                  *derived)}) {
-            evaluate::SayWithDeclaration(messages, *bad,
-                "Deallocation of polymorphic non-coarray component '%s' is not permitted in a pure subprogram"_err_en_US,
-                bad.BuildResultDesignatorName());
-          } else {
-            CheckCopyabilityInPureScope(messages, rhs, scope);
-          }
+    } else if (auto type{evaluate::DynamicType::From(lhs)}) {
+      // C1596 checks for polymorphic deallocation in a pure subprogram
+      // due to automatic reallocation on assignment
+      if (type->IsPolymorphic()) {
+        context_.Say(
+            "Deallocation of polymorphic object is not permitted in a pure subprogram"_err_en_US);
+        return false;
+      }
+      if (const DerivedTypeSpec * derived{GetDerivedTypeSpec(type)}) {
+        if (auto bad{FindPolymorphicAllocatableNonCoarrayUltimateComponent(
+                *derived)}) {
+          evaluate::SayWithDeclaration(messages, *bad,
+              "Deallocation of polymorphic non-coarray component '%s' is not permitted in a pure subprogram"_err_en_US,
+              bad.BuildResultDesignatorName());
+          return false;
+        } else {
+          return CheckCopyabilityInPureScope(messages, rhs, scope);
         }
       }
     }
   }
+  return true;
 }
 
 // 10.2.3.1(2) The masks and LHS of assignments must all have the same shape
diff --git a/lib/Semantics/assignment.h b/lib/Semantics/assignment.h
index ad18577ac883..ab8b4bfca1a5 100644
--- a/lib/Semantics/assignment.h
+++ b/lib/Semantics/assignment.h
@@ -30,10 +30,10 @@ class Scope;
 class Symbol;
 
 // Applies checks from C1594(1-2) on definitions in pure subprograms
-void CheckDefinabilityInPureScope(parser::ContextualMessages &, const Symbol &,
+bool CheckDefinabilityInPureScope(parser::ContextualMessages &, const Symbol &,
     const Scope &context, const Scope &pure);
 // Applies checks from C1594(5-6) on copying pointers in pure subprograms
-void CheckCopyabilityInPureScope(parser::ContextualMessages &,
+bool CheckCopyabilityInPureScope(parser::ContextualMessages &,
     const evaluate::Expr<evaluate::SomeType> &, const Scope &);
 
 class AssignmentChecker : public virtual BaseChecker {

From f2d2657aab051b938ec4e4702926aadb436c19aa Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Thu, 5 Mar 2020 17:55:51 -0800
Subject: [PATCH 070/345] Perform definability checks on LHS of assignment

If the pure context check succeeds, call `WhyNotModifiable` to verify
the LHS can be modified.

Detect assignment to whole assumed-size array.

Change `IsVariable` to return false for a parameter or a component or
array reference whose base it a parameter.

When analyzing an assignment statement, report an error if the LHS is
a constant expression. Otherwise it might get folded and when we detect
the problem later the error will be confusing.

Handle Substring on LHS of assignment. Change ExtractDataRef and IsVariable
to work on a Substring.

Fix IsImpliedShape and IsAssumedSize predicates in ArraySpec.

Fix C709 check in check-declarations.cpp.
---
 include/flang/Evaluate/tools.h       |  11 ++-
 lib/Evaluate/tools.cpp               |  25 ++++++
 lib/Semantics/assignment.cpp         |  18 ++++-
 lib/Semantics/check-declarations.cpp |   8 +-
 lib/Semantics/expression.cpp         |  12 ++-
 lib/Semantics/type.cpp               |   8 +-
 test/Semantics/CMakeLists.txt        |   1 +
 test/Semantics/assign04.f90          | 110 +++++++++++++++++++++++++++
 test/Semantics/resolve72.f90         |   2 +-
 9 files changed, 178 insertions(+), 17 deletions(-)
 create mode 100644 test/Semantics/assign04.f90

diff --git a/include/flang/Evaluate/tools.h b/include/flang/Evaluate/tools.h
index 7f867813b2bc..2d2a46fc3eb1 100644
--- a/include/flang/Evaluate/tools.h
+++ b/include/flang/Evaluate/tools.h
@@ -64,9 +64,10 @@ struct IsVariableHelper
   IsVariableHelper() : Base{*this} {}
   using Base::operator();
   Result operator()(const StaticDataObject &) const { return false; }
-  Result operator()(const Symbol &) const { return true; }
-  Result operator()(const Component &) const { return true; }
-  Result operator()(const ArrayRef &) const { return true; }
+  Result operator()(const Symbol &) const;
+  Result operator()(const Component &) const;
+  Result operator()(const ArrayRef &) const;
+  Result operator()(const Substring &) const;
   Result operator()(const CoarrayRef &) const { return true; }
   Result operator()(const ComplexPart &) const { return true; }
   Result operator()(const ProcedureDesignator &) const;
@@ -218,6 +219,9 @@ std::optional<DataRef> ExtractDataRef(const Designator<T> &d) {
         if constexpr (common::HasMember<decltype(x), decltype(DataRef::u)>) {
           return DataRef{x};
         }
+        if constexpr (std::is_same_v<std::decay_t<decltype(x)>, Substring>) {
+          return ExtractDataRef(x);
+        }
         return std::nullopt;  // w/o "else" to dodge bogus g++ 8.1 warning
       },
       d.u);
@@ -234,6 +238,7 @@ std::optional<DataRef> ExtractDataRef(const std::optional<A> &x) {
     return std::nullopt;
   }
 }
+std::optional<DataRef> ExtractDataRef(const Substring &);
 
 // Predicate: is an expression is an array element reference?
 template<typename T> bool IsArrayElement(const Expr<T> &expr) {
diff --git a/lib/Evaluate/tools.cpp b/lib/Evaluate/tools.cpp
index 624fb352a59e..e9e2c4f0bd5c 100644
--- a/lib/Evaluate/tools.cpp
+++ b/lib/Evaluate/tools.cpp
@@ -11,6 +11,7 @@
 #include "flang/Evaluate/characteristics.h"
 #include "flang/Evaluate/traverse.h"
 #include "flang/Parser/message.h"
+#include "flang/Semantics/tools.h"
 #include <algorithm>
 #include <variant>
 
@@ -37,7 +38,31 @@ Expr<SomeType> Parenthesize(Expr<SomeType> &&expr) {
       std::move(expr.u));
 }
 
+std::optional<DataRef> ExtractDataRef(const Substring &substring) {
+  return std::visit(
+      common::visitors{
+          [&](const DataRef &x) -> std::optional<DataRef> { return x; },
+          [&](const StaticDataObject::Pointer &) -> std::optional<DataRef> {
+            return std::nullopt;
+          },
+      },
+      substring.parent());
+}
+
 // IsVariable()
+
+auto IsVariableHelper::operator()(const Symbol &symbol) const -> Result {
+  return !symbol.attrs().test(semantics::Attr::PARAMETER);
+}
+auto IsVariableHelper::operator()(const Component &x) const -> Result {
+  return (*this)(x.base());
+}
+auto IsVariableHelper::operator()(const ArrayRef &x) const -> Result {
+  return (*this)(x.base());
+}
+auto IsVariableHelper::operator()(const Substring &x) const -> Result {
+  return (*this)(x.GetBaseObject());
+}
 auto IsVariableHelper::operator()(const ProcedureDesignator &x) const
     -> Result {
   const Symbol *symbol{x.GetSymbol()};
diff --git a/lib/Semantics/assignment.cpp b/lib/Semantics/assignment.cpp
index b309433e68f8..bd8fe2cf0311 100644
--- a/lib/Semantics/assignment.cpp
+++ b/lib/Semantics/assignment.cpp
@@ -66,10 +66,23 @@ void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
     const SomeExpr &rhs{assignment->rhs};
     auto lhsLoc{std::get<parser::Variable>(stmt.t).GetSource()};
     auto rhsLoc{std::get<parser::Expr>(stmt.t).source};
+    auto shape{evaluate::GetShape(foldingContext(), lhs)};
+    if (shape && !shape->empty() && !shape->back().has_value()) {  // C1014
+      Say(lhsLoc,
+          "Left-hand side of assignment may not be a whole assumed-size array"_err_en_US);
+    }
+    if (CheckForPureContext(lhs, rhs, rhsLoc, false)) {
+      const Scope &scope{context_.FindScope(lhsLoc)};
+      if (auto whyNot{WhyNotModifiable(lhsLoc, lhs, scope)}) {
+        if (auto *msg{Say(lhsLoc,
+                "Left-hand side of assignment is not modifiable"_err_en_US)}) {
+          msg->Attach(*whyNot);
+        }
+      }
+    }
     if (whereDepth_ > 0) {
       CheckShape(lhsLoc, &lhs);
     }
-    CheckForPureContext(lhs, rhs, rhsLoc, false);
   }
 }
 
@@ -169,7 +182,8 @@ bool AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
         // ASSOCIATE(a=>x) -- check x, not a, for "a=..."
         base = dataRef ? &dataRef->GetFirstSymbol() : nullptr;
       }
-      if (!CheckDefinabilityInPureScope(messages, *base, scope, *pure)) {
+      if (base &&
+          !CheckDefinabilityInPureScope(messages, *base, scope, *pure)) {
         return false;
       }
     }
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index 1b7dd988e5b1..63d36e342cdb 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -333,10 +333,10 @@ void CheckHelper::CheckAssumedTypeEntity(  // C709
             "Assumed-type argument '%s' cannot be a coarray"_err_en_US,
             symbol.name());
       }
-      if (details.IsArray() &&
-          !(details.IsAssumedShape() || details.IsAssumedSize())) {
-        messages_.Say("Assumed-type argument '%s' must be assumed shape"
-                      " or assumed size array"_err_en_US,
+      if (details.IsArray() && details.shape().IsExplicitShape()) {
+        messages_.Say(
+            "Assumed-type array argument 'arg8' must be assumed shape,"
+            " assumed size, or assumed rank"_err_en_US,
             symbol.name());
       }
     }
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index dd016f9433d3..302ef7fdcaf8 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -2588,10 +2588,16 @@ MaybeExpr ExpressionAnalyzer::MakeFunctionRef(
 void ArgumentAnalyzer::Analyze(const parser::Variable &x) {
   source_.ExtendToCover(x.GetSource());
   if (MaybeExpr expr{context_.Analyze(x)}) {
-    actuals_.emplace_back(std::move(*expr));
-  } else {
-    fatalErrors_ = true;
+    if (!IsConstantExpr(*expr)) {
+      actuals_.emplace_back(std::move(*expr));
+      return;
+    }
+    const Symbol *symbol{GetFirstSymbol(*expr)};
+    context_.Say(x.GetSource(),
+        "Assignment to constant '%s' is not allowed"_err_en_US,
+        symbol ? symbol->name() : x.GetSource());
   }
+  fatalErrors_ = true;
 }
 
 void ArgumentAnalyzer::Analyze(
diff --git a/lib/Semantics/type.cpp b/lib/Semantics/type.cpp
index 47158c7af4ab..49bd618e3637 100644
--- a/lib/Semantics/type.cpp
+++ b/lib/Semantics/type.cpp
@@ -353,13 +353,13 @@ bool ArraySpec::IsDeferredShape() const {
   });
 }
 bool ArraySpec::IsImpliedShape() const {
-  return CheckAll([](const ShapeSpec &x) { return x.ubound().isAssumed(); });
+  return !IsAssumedRank() &&
+      CheckAll([](const ShapeSpec &x) { return x.ubound().isAssumed(); });
 }
 bool ArraySpec::IsAssumedSize() const {
-  return !empty() &&
+  return !empty() && !IsAssumedRank() && back().ubound().isAssumed() &&
       std::all_of(begin(), end() - 1,
-          [](const ShapeSpec &x) { return x.ubound().isExplicit(); }) &&
-      back().ubound().isAssumed();
+          [](const ShapeSpec &x) { return x.ubound().isExplicit(); });
 }
 bool ArraySpec::IsAssumedRank() const {
   return Rank() == 1 && front().lbound().isAssumed();
diff --git a/test/Semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
index 7144ff9cffd1..7c826d82b961 100644
--- a/test/Semantics/CMakeLists.txt
+++ b/test/Semantics/CMakeLists.txt
@@ -115,6 +115,7 @@ set(ERROR_TESTS
   assign01.f90
   assign02.f90
   assign03.f90
+  assign04.f90
   if_arith02.f90
   if_arith03.f90
   if_arith04.f90
diff --git a/test/Semantics/assign04.f90 b/test/Semantics/assign04.f90
new file mode 100644
index 000000000000..e0a02160cba5
--- /dev/null
+++ b/test/Semantics/assign04.f90
@@ -0,0 +1,110 @@
+! 9.4.5
+subroutine s1
+  type :: t(k, l)
+    integer, kind :: k
+    integer, len :: l
+  end type
+  type(t(1, 2)) :: x
+  !ERROR: Assignment to constant 'x%k' is not allowed
+  x%k = 4
+  !ERROR: Left-hand side of assignment is not modifiable
+  x%l = 3
+end
+
+! C901
+subroutine s2(x)
+  real, parameter :: x = 0.0
+  real, parameter :: a(*) = [1, 2, 3]
+  character, parameter :: c(2) = "ab"
+  integer :: i
+  !ERROR: Assignment to constant 'x' is not allowed
+  x = 2.0
+  i = 2
+  !ERROR: Left-hand side of assignment is not modifiable
+  a(i) = 3.0
+  !ERROR: Left-hand side of assignment is not modifiable
+  a(i:i+1) = [4, 5]
+  !ERROR: Left-hand side of assignment is not modifiable
+  c(i:2) = "cd"
+end
+
+! C901
+subroutine s3
+  type :: t
+    integer :: a(2)
+    integer :: b
+  end type
+  type(t) :: x
+  type(t), parameter :: y = t([1,2], 3)
+  integer :: i = 1
+  x%a(i) = 1
+  !ERROR: Left-hand side of assignment is not modifiable
+  y%a(i) = 2
+  x%b = 4
+  !ERROR: Left-hand side of assignment is not modifiable
+  y%b = 5
+end
+
+! C844
+subroutine s4
+  type :: t
+    integer :: a(2)
+  end type
+contains
+  subroutine s(x, c)
+    type(t), intent(in) :: x
+    character(10), intent(in) :: c
+    type(t) :: y
+    !ERROR: Left-hand side of assignment is not modifiable
+    x = y
+    !ERROR: Left-hand side of assignment is not modifiable
+    x%a(1) = 2
+    !ERROR: Left-hand side of assignment is not modifiable
+    c(2:3) = "ab"
+  end
+end
+
+! 8.5.15(2)
+module m5
+  real :: x
+  real, protected :: y
+  real, private :: z
+  type :: t
+    real :: a
+  end type
+  type(t), protected :: b
+end
+subroutine s5()
+  use m5
+  implicit none
+  x = 1.0
+  !ERROR: Left-hand side of assignment is not modifiable
+  y = 2.0
+  !ERROR: No explicit type declared for 'z'
+  z = 3.0
+  !ERROR: Left-hand side of assignment is not modifiable
+  b%a = 1.0
+end
+
+subroutine s6(x)
+  integer :: x(*)
+  x(1:3) = [1, 2, 3]
+  x(:3) = [1, 2, 3]
+  !ERROR: Assumed-size array 'x' must have explicit final subscript upper bound value
+  x(:) = [1, 2, 3]
+  !ERROR: Left-hand side of assignment may not be a whole assumed-size array
+  x = [1, 2, 3]
+end
+
+module m7
+  type :: t
+    integer :: i
+  end type
+contains
+  subroutine s7(x)
+    type(t) :: x(*)
+    x(:3)%i = [1, 2, 3]
+    !ERROR: Left-hand side of assignment may not be a whole assumed-size array
+    x%i = [1, 2, 3]
+  end
+end
diff --git a/test/Semantics/resolve72.f90 b/test/Semantics/resolve72.f90
index fdead88c8fe8..6ff2603b2129 100644
--- a/test/Semantics/resolve72.f90
+++ b/test/Semantics/resolve72.f90
@@ -19,7 +19,7 @@ subroutine inner1(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
         type(*), pointer :: arg6
         !ERROR: Assumed-type argument 'arg7' cannot have the VALUE attribute
         type(*), value :: arg7
-        !ERROR: Assumed-type argument 'arg8' must be assumed shape or assumed size array
+        !ERROR: Assumed-type array argument 'arg8' must be assumed shape, assumed size, or assumed rank
         type(*), dimension(3) :: arg8
       end subroutine inner1
 end subroutine s

From 111f49061e07604670614250197a1064959fd981 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Tue, 10 Mar 2020 10:28:36 -0700
Subject: [PATCH 071/345] Changes to get a clean build of f18 with latest clang

Prep for review
---
 include/flang/Common/reference.h    | 11 +++++-
 include/flang/Common/uint128.h      | 13 +++++--
 include/flang/Evaluate/common.h     |  2 +-
 include/flang/Evaluate/expression.h |  1 -
 include/flang/Evaluate/variable.h   | 28 ++------------
 lib/Evaluate/call.cpp               |  4 ++
 lib/Evaluate/expression.cpp         | 59 ++++++++++++++++++++++++++++-
 lib/Evaluate/variable.cpp           | 22 ++++++++++-
 lib/Semantics/resolve-labels.cpp    | 10 ++---
 lib/Semantics/resolve-names.cpp     |  2 +-
 10 files changed, 112 insertions(+), 40 deletions(-)

diff --git a/include/flang/Common/reference.h b/include/flang/Common/reference.h
index 37e7ab9ca523..f204b8f8b352 100644
--- a/include/flang/Common/reference.h
+++ b/include/flang/Common/reference.h
@@ -45,8 +45,15 @@ template<typename A> class Reference {
   type &get() const noexcept { return *p_; }
   type *operator->() const { return p_; }
   type &operator*() const { return *p_; }
-  bool operator==(Reference that) const { return *p_ == *that.p_; }
-  bool operator!=(Reference that) const { return *p_ != *that.p_; }
+
+  bool operator==(std::add_const_t<A> &that) const {
+    return p_ == &that || *p_ == that;
+  }
+  bool operator!=(std::add_const_t<A> &that) const { return !(*this == that); }
+  bool operator==(const Reference &that) const {
+    return p_ == that.p_ || *this == *that.p_;
+  }
+  bool operator!=(const Reference &that) const { return !(*this == that); }
 
 private:
   type *p_;  // never null
diff --git a/include/flang/Common/uint128.h b/include/flang/Common/uint128.h
index 4d4fed94a002..48e1f49e8e90 100644
--- a/include/flang/Common/uint128.h
+++ b/include/flang/Common/uint128.h
@@ -25,11 +25,18 @@ namespace Fortran::common {
 class UnsignedInt128 {
 public:
   constexpr UnsignedInt128() {}
-  constexpr UnsignedInt128(std::uint64_t n) : low_{n} {}
-  constexpr UnsignedInt128(std::int64_t n)
+  // This means of definition provides some portability for
+  // "size_t" operands.
+  constexpr UnsignedInt128(unsigned n) : low_{n} {}
+  constexpr UnsignedInt128(unsigned long n) : low_{n} {}
+  constexpr UnsignedInt128(unsigned long long n) : low_{n} {}
+  constexpr UnsignedInt128(int n)
     : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
                                                n < 0)} {}
-  constexpr UnsignedInt128(int n)
+  constexpr UnsignedInt128(long n)
+    : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
+                                               n < 0)} {}
+  constexpr UnsignedInt128(long long n)
     : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
                                                n < 0)} {}
   constexpr UnsignedInt128(const UnsignedInt128 &) = default;
diff --git a/include/flang/Evaluate/common.h b/include/flang/Evaluate/common.h
index d76126b1436b..639ff0c82e2e 100644
--- a/include/flang/Evaluate/common.h
+++ b/include/flang/Evaluate/common.h
@@ -195,7 +195,7 @@ using HostUnsignedInt =
 #define EVALUATE_UNION_CLASS_BOILERPLATE(t) \
   CLASS_BOILERPLATE(t) \
   UNION_CONSTRUCTORS(t) \
-  bool operator==(const t &that) const { return u == that.u; }
+  bool operator==(const t &) const;
 
 // Forward definition of Expr<> so that it can be indirectly used in its own
 // definition
diff --git a/include/flang/Evaluate/expression.h b/include/flang/Evaluate/expression.h
index 52c17a957b9b..e4bd57f2ae1c 100644
--- a/include/flang/Evaluate/expression.h
+++ b/include/flang/Evaluate/expression.h
@@ -780,7 +780,6 @@ using TypelessExpression = std::variant<BOZLiteralConstant, NullPointer,
 template<> class Expr<SomeType> : public ExpressionBase<SomeType> {
 public:
   using Result = SomeType;
-
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
 
   // Owning references to these generic expressions can appear in other
diff --git a/include/flang/Evaluate/variable.h b/include/flang/Evaluate/variable.h
index b39011aeab64..62effec2c636 100644
--- a/include/flang/Evaluate/variable.h
+++ b/include/flang/Evaluate/variable.h
@@ -43,27 +43,12 @@ using SymbolVector = std::vector<SymbolRef>;
 struct DataRef;
 template<typename T> struct Variable;
 
-bool AreSameSymbol(const Symbol &, const Symbol &);
-
-// Implements operator==() for a union type, using special case handling
-// for Symbol references.
-template<typename A> bool TestVariableEquality(const A &x, const A &y) {
-  const SymbolRef *xSymbol{std::get_if<SymbolRef>(&x.u)};
-  if (const SymbolRef * ySymbol{std::get_if<SymbolRef>(&y.u)}) {
-    return xSymbol && AreSameSymbol(*xSymbol, *ySymbol);
-  } else {
-    return x.u == y.u;
-  }
-}
-
 // Reference a base object in memory.  This can be a Fortran symbol,
 // static data (e.g., CHARACTER literal), or compiler-created temporary.
 struct BaseObject {
-  CLASS_BOILERPLATE(BaseObject)
-  UNION_CONSTRUCTORS(BaseObject)
+  EVALUATE_UNION_CLASS_BOILERPLATE(BaseObject)
   int Rank() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
-  bool operator==(const BaseObject &) const;
   std::ostream &AsFortran(std::ostream &) const;
   const Symbol *symbol() const {
     if (const auto *result{std::get_if<SymbolRef>(&u)}) {
@@ -296,10 +281,7 @@ class CoarrayRef {
 // a terminal substring range or complex component designator; use
 // R901 designator for that.
 struct DataRef {
-  CLASS_BOILERPLATE(DataRef)
-  UNION_CONSTRUCTORS(DataRef)
-
-  bool operator==(const DataRef &) const;
+  EVALUATE_UNION_CLASS_BOILERPLATE(DataRef)
   int Rank() const;
   const Symbol &GetFirstSymbol() const;
   const Symbol &GetLastSymbol() const;
@@ -395,15 +377,11 @@ template<typename T> class Designator {
   using Result = T;
   static_assert(
       IsSpecificIntrinsicType<Result> || std::is_same_v<Result, SomeDerived>);
-  CLASS_BOILERPLATE(Designator)
-  UNION_CONSTRUCTORS(Designator)
+  EVALUATE_UNION_CLASS_BOILERPLATE(Designator)
   Designator(const DataRef &that) : u{common::CopyVariant<Variant>(that.u)} {}
   Designator(DataRef &&that)
     : u{common::MoveVariant<Variant>(std::move(that.u))} {}
 
-  bool operator==(const Designator &that) const {
-    return TestVariableEquality(*this, that);
-  }
   std::optional<DynamicType> GetType() const;
   int Rank() const;
   BaseObject GetBaseObject() const;
diff --git a/lib/Evaluate/call.cpp b/lib/Evaluate/call.cpp
index 52c16f2e3f3b..31ee05b30873 100644
--- a/lib/Evaluate/call.cpp
+++ b/lib/Evaluate/call.cpp
@@ -79,6 +79,10 @@ bool SpecificIntrinsic::operator==(const SpecificIntrinsic &that) const {
 ProcedureDesignator::ProcedureDesignator(Component &&c)
   : u{common::CopyableIndirection<Component>::Make(std::move(c))} {}
 
+bool ProcedureDesignator::operator==(const ProcedureDesignator &that) const {
+  return u == that.u;
+}
+
 std::optional<DynamicType> ProcedureDesignator::GetType() const {
   if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&u)}) {
     if (const auto &result{intrinsic->characteristics.value().functionResult}) {
diff --git a/lib/Evaluate/expression.cpp b/lib/Evaluate/expression.cpp
index a390c9e4d1b2..11ba35dbb8ec 100644
--- a/lib/Evaluate/expression.cpp
+++ b/lib/Evaluate/expression.cpp
@@ -101,7 +101,7 @@ template<typename A> int ExpressionBase<A>::Rank() const {
       derived().u);
 }
 
-// Equality testing for classes without EVALUATE_UNION_CLASS_BOILERPLATE()
+// Equality testing
 
 bool ImpliedDoIndex::operator==(const ImpliedDoIndex &that) const {
   return name == that.name;
@@ -114,6 +114,12 @@ bool ImpliedDo<T>::operator==(const ImpliedDo<T> &that) const {
       values_ == that.values_;
 }
 
+template<typename T>
+bool ArrayConstructorValue<T>::operator==(
+    const ArrayConstructorValue<T> &that) const {
+  return u == that.u;
+}
+
 template<typename R>
 bool ArrayConstructorValues<R>::operator==(
     const ArrayConstructorValues<R> &that) const {
@@ -146,6 +152,57 @@ bool StructureConstructor::operator==(const StructureConstructor &that) const {
   return result_ == that.result_ && values_ == that.values_;
 }
 
+bool Relational<SomeType>::operator==(const Relational<SomeType> &that) const {
+  return u == that.u;
+}
+
+template<int KIND>
+bool Expr<Type<TypeCategory::Integer, KIND>>::operator==(
+    const Expr<Type<TypeCategory::Integer, KIND>> &that) const {
+  return u == that.u;
+}
+
+template<int KIND>
+bool Expr<Type<TypeCategory::Real, KIND>>::operator==(
+    const Expr<Type<TypeCategory::Real, KIND>> &that) const {
+  return u == that.u;
+}
+
+template<int KIND>
+bool Expr<Type<TypeCategory::Complex, KIND>>::operator==(
+    const Expr<Type<TypeCategory::Complex, KIND>> &that) const {
+  return u == that.u;
+}
+
+template<int KIND>
+bool Expr<Type<TypeCategory::Logical, KIND>>::operator==(
+    const Expr<Type<TypeCategory::Logical, KIND>> &that) const {
+  return u == that.u;
+}
+
+template<int KIND>
+bool Expr<Type<TypeCategory::Character, KIND>>::operator==(
+    const Expr<Type<TypeCategory::Character, KIND>> &that) const {
+  return u == that.u;
+}
+
+template<TypeCategory CAT>
+bool Expr<SomeKind<CAT>>::operator==(const Expr<SomeKind<CAT>> &that) const {
+  return u == that.u;
+}
+
+bool Expr<SomeDerived>::operator==(const Expr<SomeDerived> &that) const {
+  return u == that.u;
+}
+
+bool Expr<SomeCharacter>::operator==(const Expr<SomeCharacter> &that) const {
+  return u == that.u;
+}
+
+bool Expr<SomeType>::operator==(const Expr<SomeType> &that) const {
+  return u == that.u;
+}
+
 DynamicType StructureConstructor::GetType() const { return result_.GetType(); }
 
 const Expr<SomeType> *StructureConstructor::Find(
diff --git a/lib/Evaluate/variable.cpp b/lib/Evaluate/variable.cpp
index 2ed759057820..030f8866a42b 100644
--- a/lib/Evaluate/variable.cpp
+++ b/lib/Evaluate/variable.cpp
@@ -601,7 +601,7 @@ NamedEntity CoarrayRef::GetBase() const { return AsNamedEntity(base_); }
 // For the purposes of comparing type parameter expressions while
 // testing the compatibility of procedure characteristics, two
 // object dummy arguments with the same name are considered equal.
-bool AreSameSymbol(const Symbol &x, const Symbol &y) {
+static bool AreSameSymbol(const Symbol &x, const Symbol &y) {
   if (&x == &y) {
     return true;
   }
@@ -615,6 +615,17 @@ bool AreSameSymbol(const Symbol &x, const Symbol &y) {
   return false;
 }
 
+// Implements operator==() for a union type, using special case handling
+// for Symbol references.
+template<typename A> static bool TestVariableEquality(const A &x, const A &y) {
+  const SymbolRef *xSymbol{std::get_if<SymbolRef>(&x.u)};
+  if (const SymbolRef * ySymbol{std::get_if<SymbolRef>(&y.u)}) {
+    return xSymbol && AreSameSymbol(*xSymbol, *ySymbol);
+  } else {
+    return x.u == y.u;
+  }
+}
+
 bool BaseObject::operator==(const BaseObject &that) const {
   return TestVariableEquality(*this, that);
 }
@@ -638,6 +649,7 @@ bool Triplet::operator==(const Triplet &that) const {
   return lower_ == that.lower_ && upper_ == that.upper_ &&
       stride_ == that.stride_;
 }
+bool Subscript::operator==(const Subscript &that) const { return u == that.u; }
 bool ArrayRef::operator==(const ArrayRef &that) const {
   return base_ == that.base_ && subscript_ == that.subscript_;
 }
@@ -659,6 +671,14 @@ bool ComplexPart::operator==(const ComplexPart &that) const {
 bool ProcedureRef::operator==(const ProcedureRef &that) const {
   return proc_ == that.proc_ && arguments_ == that.arguments_;
 }
+template<typename T>
+bool Designator<T>::operator==(const Designator<T> &that) const {
+  return TestVariableEquality(*this, that);
+}
+template<typename T>
+bool Variable<T>::operator==(const Variable<T> &that) const {
+  return u == that.u;
+}
 bool DescriptorInquiry::operator==(const DescriptorInquiry &that) const {
   return field_ == that.field_ && base_ == that.base_ &&
       dimension_ == that.dimension_;
diff --git a/lib/Semantics/resolve-labels.cpp b/lib/Semantics/resolve-labels.cpp
index d17352b9a440..55d60ac1729a 100644
--- a/lib/Semantics/resolve-labels.cpp
+++ b/lib/Semantics/resolve-labels.cpp
@@ -818,7 +818,7 @@ LabeledStatementInfoTuplePOD GetLabel(
 void CheckBranchesIntoDoBody(const SourceStmtList &branches,
     const TargetStmtMap &labels, const IndexList &loopBodies,
     SemanticsContext &context) {
-  for (const auto branch : branches) {
+  for (const auto &branch : branches) {
     const auto &label{branch.parserLabel};
     auto branchTarget{GetLabel(labels, label)};
     if (HasScope(branchTarget.proxyForScope)) {
@@ -870,7 +870,7 @@ void CheckLabelDoConstraints(const SourceStmtList &dos,
     const SourceStmtList &branches, const TargetStmtMap &labels,
     const std::vector<ProxyForScope> &scopes, SemanticsContext &context) {
   IndexList loopBodies;
-  for (const auto stmt : dos) {
+  for (const auto &stmt : dos) {
     const auto &label{stmt.parserLabel};
     const auto &scope{stmt.proxyForScope};
     const auto &position{stmt.parserCharBlock};
@@ -924,7 +924,7 @@ void CheckLabelDoConstraints(const SourceStmtList &dos,
 void CheckScopeConstraints(const SourceStmtList &stmts,
     const TargetStmtMap &labels, const std::vector<ProxyForScope> &scopes,
     SemanticsContext &context) {
-  for (const auto stmt : stmts) {
+  for (const auto &stmt : stmts) {
     const auto &label{stmt.parserLabel};
     const auto &scope{stmt.proxyForScope};
     const auto &position{stmt.parserCharBlock};
@@ -943,7 +943,7 @@ void CheckScopeConstraints(const SourceStmtList &stmts,
 
 void CheckBranchTargetConstraints(const SourceStmtList &stmts,
     const TargetStmtMap &labels, SemanticsContext &context) {
-  for (const auto stmt : stmts) {
+  for (const auto &stmt : stmts) {
     const auto &label{stmt.parserLabel};
     auto branchTarget{GetLabel(labels, label)};
     if (HasScope(branchTarget.proxyForScope)) {
@@ -981,7 +981,7 @@ void CheckBranchConstraints(const SourceStmtList &branches,
 
 void CheckDataXferTargetConstraints(const SourceStmtList &stmts,
     const TargetStmtMap &labels, SemanticsContext &context) {
-  for (const auto stmt : stmts) {
+  for (const auto &stmt : stmts) {
     const auto &label{stmt.parserLabel};
     auto ioTarget{GetLabel(labels, label)};
     if (HasScope(ioTarget.proxyForScope)) {
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 38a9ba909135..a37bfd64470f 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -3618,7 +3618,7 @@ void DeclarationVisitor::Post(const parser::TypeBoundProcedurePart &) {
   // track specifics seen for the current generic to detect duplicates:
   const Symbol *currGeneric{nullptr};
   std::set<SourceName> specifics;
-  for (const auto [generic, bindingName] : genericBindings_) {
+  for (const auto &[generic, bindingName] : genericBindings_) {
     if (generic != currGeneric) {
       currGeneric = generic;
       specifics.clear();

From d787108637adad358ccf8af3d200acb3f66ce099 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 10 Mar 2020 15:31:02 -0700
Subject: [PATCH 072/345] Fix scope accessibility check

The check for whether a private component is accessible was depending on
determining whether the source range of the current scope was within the
source range of the module that the component was declared in. This
could fail if the current scope was of kind `ImpliedDos` and had no
source range.

The fix is to add `Scope::Contains` to check the relationship by
traversing the parent links. These are created when the Scope is so are
always reliable. The source range of a scope is built up over time.
---
 include/flang/Semantics/scope.h | 11 ++---------
 lib/Semantics/scope.cpp         | 22 ++++++++++++++++++++--
 lib/Semantics/tools.cpp         |  2 +-
 test/Semantics/resolve34.f90    |  7 +++++++
 4 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/include/flang/Semantics/scope.h b/include/flang/Semantics/scope.h
index 6f67ecbabf31..7c12dc14563d 100644
--- a/include/flang/Semantics/scope.h
+++ b/include/flang/Semantics/scope.h
@@ -85,15 +85,8 @@ class Scope {
 
   const Symbol *GetSymbol() const;
   const Scope *GetDerivedTypeParent() const;
-
-  std::optional<SourceName> GetName() const {
-    if (const auto *sym{GetSymbol()}) {
-      return sym->name();
-    } else {
-      return std::nullopt;
-    }
-  }
-
+  std::optional<SourceName> GetName() const;
+  bool Contains(const Scope &) const;
   /// Make a scope nested in this one
   Scope &MakeScope(Kind kind, Symbol *symbol = nullptr);
 
diff --git a/lib/Semantics/scope.cpp b/lib/Semantics/scope.cpp
index 16ee107a4612..b345c6189849 100644
--- a/lib/Semantics/scope.cpp
+++ b/lib/Semantics/scope.cpp
@@ -91,6 +91,25 @@ Symbol *Scope::FindComponent(SourceName name) const {
   }
 }
 
+std::optional<SourceName> Scope::GetName() const {
+  if (const auto *sym{GetSymbol()}) {
+    return sym->name();
+  } else {
+    return std::nullopt;
+  }
+}
+
+bool Scope::Contains(const Scope &that) const {
+  for (const Scope *scope{&that};; scope = &scope->parent()) {
+    if (*scope == *this) {
+      return true;
+    }
+    if (scope->IsGlobal()) {
+      return false;
+    }
+  }
+}
+
 const std::list<EquivalenceSet> &Scope::equivalenceSets() const {
   return equivalenceSets_;
 }
@@ -244,8 +263,7 @@ Scope *Scope::FindScope(parser::CharBlock source) {
 }
 
 void Scope::AddSourceRange(const parser::CharBlock &source) {
-  for (auto *scope = this; !scope->IsGlobal();
-       scope = &scope->parent()) {
+  for (auto *scope = this; !scope->IsGlobal(); scope = &scope->parent()) {
     scope->sourceRange_.ExtendToCover(source);
   }
 }
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index de9131d8f86b..f77a5cc8aaf1 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -960,7 +960,7 @@ std::optional<parser::MessageFormattedText> CheckAccessibleComponent(
   CHECK(symbol.owner().IsDerivedType());  // symbol must be a component
   if (symbol.attrs().test(Attr::PRIVATE)) {
     if (const Scope * moduleScope{FindModuleContaining(symbol.owner())}) {
-      if (!moduleScope->sourceRange().Contains(scope.sourceRange())) {
+      if (!moduleScope->Contains(scope)) {
         return parser::MessageFormattedText{
             "PRIVATE component '%s' is only accessible within module '%s'"_err_en_US,
             symbol.name(), moduleScope->GetName().value()};
diff --git a/test/Semantics/resolve34.f90 b/test/Semantics/resolve34.f90
index c3b28bb929b8..d9a2a233e8d4 100644
--- a/test/Semantics/resolve34.f90
+++ b/test/Semantics/resolve34.f90
@@ -98,11 +98,16 @@ module m8
     integer :: i1
     integer, private :: i2
   end type
+  type(t) :: y
+  integer :: a(1)
 contains
   subroutine s0
     type(t) :: x
     x = t(i1=2, i2=5)  !OK
   end
+  subroutine s1
+    a = [y%i2]  !OK
+  end subroutine
 end
 subroutine s8
   use m8
@@ -111,6 +116,8 @@ subroutine s8
   x = t(2, 5)
   !ERROR: PRIVATE component 'i2' is only accessible within module 'm8'
   x = t(i1=2, i2=5)
+  !ERROR: PRIVATE component 'i2' is only accessible within module 'm8'
+  a = [y%i2]
 end
 
 ! 7.5.4.8(2)

From 38aefd41f051546024ecf4555a3bb3385b99f3c7 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 10 Mar 2020 16:32:58 -0700
Subject: [PATCH 073/345] Allow for vector subscript on LHS of assignment

---
 lib/Semantics/assignment.cpp | 2 +-
 test/Semantics/assign04.f90  | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/Semantics/assignment.cpp b/lib/Semantics/assignment.cpp
index bd8fe2cf0311..18f0ffcfa29f 100644
--- a/lib/Semantics/assignment.cpp
+++ b/lib/Semantics/assignment.cpp
@@ -73,7 +73,7 @@ void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
     }
     if (CheckForPureContext(lhs, rhs, rhsLoc, false)) {
       const Scope &scope{context_.FindScope(lhsLoc)};
-      if (auto whyNot{WhyNotModifiable(lhsLoc, lhs, scope)}) {
+      if (auto whyNot{WhyNotModifiable(lhsLoc, lhs, scope, true)}) {
         if (auto *msg{Say(lhsLoc,
                 "Left-hand side of assignment is not modifiable"_err_en_US)}) {
           msg->Attach(*whyNot);
diff --git a/test/Semantics/assign04.f90 b/test/Semantics/assign04.f90
index e0a02160cba5..b4214a4766f2 100644
--- a/test/Semantics/assign04.f90
+++ b/test/Semantics/assign04.f90
@@ -108,3 +108,8 @@ subroutine s7(x)
     x%i = [1, 2, 3]
   end
 end
+
+subroutine s7
+  integer :: a(10), v(10)
+  a(v(:)) = 1  ! vector subscript is ok
+end

From a2e2593fa5457a7737faab8ee74e5f3b18cd71f7 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Tue, 10 Mar 2020 16:13:09 -0700
Subject: [PATCH 074/345] Extend shape analysis to cope with ASSOCIATE
 construct entities better

Fix incomplete copy&paste

Another review comment addressed
---
 lib/Evaluate/shape.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/Evaluate/shape.cpp b/lib/Evaluate/shape.cpp
index c523f304f84b..c0b59cff3c1f 100644
--- a/lib/Evaluate/shape.cpp
+++ b/lib/Evaluate/shape.cpp
@@ -256,6 +256,13 @@ MaybeExtentExpr GetExtent(
         }
       }
     }
+  } else if (const auto *assoc{
+                 symbol.detailsIf<semantics::AssocEntityDetails>()}) {
+    if (auto shape{GetShape(context, assoc->expr())}) {
+      if (dimension < static_cast<int>(shape->size())) {
+        return std::move(shape->at(dimension));
+      }
+    }
   }
   return std::nullopt;
 }
@@ -316,6 +323,13 @@ MaybeExtentExpr GetUpperBound(
         }
       }
     }
+  } else if (const auto *assoc{
+                 symbol.detailsIf<semantics::AssocEntityDetails>()}) {
+    if (auto shape{GetShape(context, assoc->expr())}) {
+      if (dimension < static_cast<int>(shape->size())) {
+        return std::move(shape->at(dimension));
+      }
+    }
   }
   return std::nullopt;
 }

From dc1c95277dd6161ce2d13f971ca91cce3e771e8a Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Wed, 11 Mar 2020 11:00:36 -0700
Subject: [PATCH 075/345] Repair C_LOC

---
 module/iso_c_binding.f90 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/module/iso_c_binding.f90 b/module/iso_c_binding.f90
index d1cb001c2a54..a659f2fc040c 100644
--- a/module/iso_c_binding.f90
+++ b/module/iso_c_binding.f90
@@ -91,7 +91,7 @@ end function c_associated
 
   function c_loc(x)
     type(c_ptr) :: c_loc
-    type(*), dimension(:), intent(in) :: x
+    type(*), dimension(..), intent(in) :: x
     c_loc = c_ptr(loc(x))
   end function c_loc
 

From ed2e4842d31f1329d3bec802c2f284ba62343f99 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Wed, 11 Mar 2020 13:17:03 -0700
Subject: [PATCH 076/345] Resolve known problems in shape analysis

---
 include/flang/Evaluate/shape.h |  7 ++-
 lib/Evaluate/shape.cpp         | 96 +++++++++++++++++++++++-----------
 2 files changed, 68 insertions(+), 35 deletions(-)

diff --git a/include/flang/Evaluate/shape.h b/include/flang/Evaluate/shape.h
index c7f453c90f0b..00724c259b2c 100644
--- a/include/flang/Evaluate/shape.h
+++ b/include/flang/Evaluate/shape.h
@@ -53,6 +53,8 @@ std::optional<ConstantSubscripts> AsConstantExtents(
 
 inline int GetRank(const Shape &s) { return static_cast<int>(s.size()); }
 
+template<typename A> std::optional<Shape> GetShape(FoldingContext &, const A &);
+
 // The dimension argument to these inquiries is zero-based,
 // unlike the DIM= arguments to many intrinsics.
 ExtentExpr GetLowerBound(FoldingContext &, const NamedEntity &, int dimension);
@@ -80,16 +82,13 @@ MaybeExtentExpr GetSize(Shape &&);
 // Utility predicate: does an expression reference any implied DO index?
 bool ContainsAnyImpliedDoIndex(const ExtentExpr &);
 
-// GetShape()
-template<typename A> std::optional<Shape> GetShape(FoldingContext &, const A &);
-
 class GetShapeHelper
   : public AnyTraverse<GetShapeHelper, std::optional<Shape>> {
 public:
   using Result = std::optional<Shape>;
   using Base = AnyTraverse<GetShapeHelper, Result>;
   using Base::operator();
-  GetShapeHelper(FoldingContext &c) : Base{*this}, context_{c} {}
+  explicit GetShapeHelper(FoldingContext &c) : Base{*this}, context_{c} {}
 
   Result operator()(const ImpliedDoIndex &) const { return Scalar(); }
   Result operator()(const DescriptorInquiry &) const { return Scalar(); }
diff --git a/lib/Evaluate/shape.cpp b/lib/Evaluate/shape.cpp
index c0b59cff3c1f..f27ee5814075 100644
--- a/lib/Evaluate/shape.cpp
+++ b/lib/Evaluate/shape.cpp
@@ -177,52 +177,84 @@ bool ContainsAnyImpliedDoIndex(const ExtentExpr &expr) {
   return MyVisitor{}(expr);
 }
 
-ExtentExpr GetLowerBound(
-    FoldingContext &context, const NamedEntity &base, int dimension) {
-  const Symbol &symbol{ResolveAssociations(base.GetLastSymbol())};
+// Determines lower bound on a dimension.  This can be other than 1 only
+// for a reference to a whole array object or component. (See LBOUND, 16.9.109).
+// ASSOCIATE construct entities may require tranversal of their referents.
+class GetLowerBoundHelper : public Traverse<GetLowerBoundHelper, ExtentExpr> {
+public:
+  using Result = ExtentExpr;
+  using Base = Traverse<GetLowerBoundHelper, ExtentExpr>;
+  using Base::operator();
+  GetLowerBoundHelper(FoldingContext &c, int d)
+    : Base{*this}, context_{c}, dimension_{d} {}
+  static ExtentExpr Default() { return ExtentExpr{1}; }
+  static ExtentExpr Combine(Result &&, Result &&) { return Default(); }
+  ExtentExpr operator()(const Symbol &);
+  ExtentExpr operator()(const Component &);
+
+private:
+  FoldingContext &context_;
+  int dimension_;
+};
+
+auto GetLowerBoundHelper::operator()(const Symbol &symbol0) -> Result {
+  const Symbol &symbol{symbol0.GetUltimate()};
   if (const auto *details{symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
     int j{0};
     for (const auto &shapeSpec : details->shape()) {
-      if (j++ == dimension) {
+      if (j++ == dimension_) {
         if (const auto &bound{shapeSpec.lbound().GetExplicit()}) {
-          return Fold(context, common::Clone(*bound));
+          return Fold(context_, common::Clone(*bound));
         } else if (semantics::IsDescriptor(symbol)) {
-          return ExtentExpr{DescriptorInquiry{
-              base, DescriptorInquiry::Field::LowerBound, dimension}};
+          return ExtentExpr{DescriptorInquiry{NamedEntity{symbol0},
+              DescriptorInquiry::Field::LowerBound, dimension_}};
         } else {
           break;
         }
       }
     }
+  } else if (const auto *assoc{
+                 symbol.detailsIf<semantics::AssocEntityDetails>()}) {
+    return (*this)(assoc->expr());
   }
-  // When we don't know that we don't know the lower bound at compilation
-  // time, then we do know it, and it's one.  (See LBOUND, 16.9.109).
-  return ExtentExpr{1};
+  return Default();
 }
 
-Shape GetLowerBounds(FoldingContext &context, const NamedEntity &base) {
-  const Symbol &symbol{ResolveAssociations(base.GetLastSymbol())};
-  Shape result;
-  if (const auto *details{symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
-    int dim{0};
-    for (const auto &shapeSpec : details->shape()) {
-      if (const auto &bound{shapeSpec.lbound().GetExplicit()}) {
-        result.emplace_back(Fold(context, common::Clone(*bound)));
-      } else if (semantics::IsDescriptor(symbol)) {
-        result.emplace_back(ExtentExpr{DescriptorInquiry{
-            base, DescriptorInquiry::Field::LowerBound, dim}});
-      } else {
-        result.emplace_back(std::nullopt);
+auto GetLowerBoundHelper::operator()(const Component &component) -> Result {
+  if (component.base().Rank() == 0) {
+    const Symbol &symbol{component.GetLastSymbol().GetUltimate()};
+    if (const auto *details{
+            symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
+      int j{0};
+      for (const auto &shapeSpec : details->shape()) {
+        if (j++ == dimension_) {
+          if (const auto &bound{shapeSpec.lbound().GetExplicit()}) {
+            return Fold(context_, common::Clone(*bound));
+          } else if (semantics::IsDescriptor(symbol)) {
+            return ExtentExpr{
+                DescriptorInquiry{NamedEntity{common::Clone(component)},
+                    DescriptorInquiry::Field::LowerBound, dimension_}};
+          } else {
+            break;
+          }
+        }
       }
-      ++dim;
-    }
-  } else {
-    int rank{base.Rank()};
-    for (int dim{0}; dim < rank; ++dim) {
-      result.emplace_back(ExtentExpr{1});
     }
   }
-  CHECK(GetRank(result) == symbol.Rank());
+  return Default();
+}
+
+ExtentExpr GetLowerBound(
+    FoldingContext &context, const NamedEntity &base, int dimension) {
+  return GetLowerBoundHelper{context, dimension}(base);
+}
+
+Shape GetLowerBounds(FoldingContext &context, const NamedEntity &base) {
+  Shape result;
+  int rank{base.Rank()};
+  for (int dim{0}; dim < rank; ++dim) {
+    result.emplace_back(GetLowerBound(context, base, dim));
+  }
   return result;
 }
 
@@ -327,7 +359,9 @@ MaybeExtentExpr GetUpperBound(
                  symbol.detailsIf<semantics::AssocEntityDetails>()}) {
     if (auto shape{GetShape(context, assoc->expr())}) {
       if (dimension < static_cast<int>(shape->size())) {
-        return std::move(shape->at(dimension));
+        return ComputeUpperBound(context,
+            GetLowerBound(context, base, dimension),
+            std::move(shape->at(dimension)));
       }
     }
   }

From 50406b349609efdde76e48bf2caa039d031dd1c4 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Thu, 13 Feb 2020 14:41:56 -0800
Subject: [PATCH 077/345] Use hash table for UnitMap, avoid C++ STL binary
 dependence

Scan FORMAT strings locally to avoid C++ binary runtime dependence when computing deepest parenthesis nesting

Remove a dependency on ostream from runtime

Remove remaining direct external references from runtime to C++ library binaries

Remove runtime dependences on lib/common

SetPos() and SetRec()

Instantiate templates for input

Begin input; rearrange locking, deal with CLOSE races

View()

Update error message in test to agree with compiler change

First cut at real input

More robust I/O runtime error handling

Debugging of REAL input

Add iostat.{h,cpp}

Rename runtime/numeric-* to runtime/edit-*

Move templates around, templatize integer output editing

Move LOGICAL and CHARACTER output from io-api.cpp to edit-output.cpp

Change pointer argument to reference

More list-directed input

Complex list-directed input

Use enum class Direction rather than bool for templates

Catch up with changes to master

Undo reformatting of Lower code

Use record number instead of subscripts for internal unit

Unformatted sequential backspace

Testing and debugging

Dodge bogus GCC warning

Add <cstddef> for std::size_t to fix CI build

Address review comments
---
 documentation/IORuntimeInternals.md           |   9 +-
 include/flang/Parser/char-buffer.h            |   2 +-
 include/flang/Semantics/type.h                |   4 +-
 lib/Parser/char-buffer.cpp                    |   6 +-
 lib/Parser/source.cpp                         |   2 +-
 lib/Semantics/check-call.cpp                  |   7 +-
 runtime/CMakeLists.txt                        |   6 +-
 runtime/ISO_Fortran_binding.cpp               |   5 +-
 runtime/buffer.h                              |  18 +-
 runtime/connection.cpp                        |  18 +-
 runtime/connection.h                          |  17 +-
 runtime/descriptor.cpp                        | 164 +++++--
 runtime/descriptor.h                          |  57 ++-
 runtime/edit-input.cpp                        | 428 ++++++++++++++++
 runtime/edit-input.h                          |  40 ++
 runtime/{numeric-output.h => edit-output.cpp} | 298 +++++++++---
 runtime/edit-output.h                         | 111 +++++
 runtime/file.cpp                              |  49 +-
 runtime/file.h                                |   4 -
 runtime/format-implementation.h               | 110 +++--
 runtime/format.cpp                            |  32 +-
 runtime/format.h                              |  25 +-
 runtime/internal-unit.cpp                     | 144 +++---
 runtime/internal-unit.h                       |  23 +-
 runtime/io-api.cpp                            | 456 ++++++++++++------
 runtime/io-api.h                              |  27 +-
 runtime/io-error.cpp                          |  71 ++-
 runtime/io-error.h                            |  22 +-
 runtime/io-stmt.cpp                           | 440 +++++++++++++----
 runtime/io-stmt.h                             | 204 ++++----
 runtime/iostat.cpp                            |  31 ++
 runtime/iostat.h                              |  53 ++
 runtime/lock.h                                |   3 +-
 runtime/magic-numbers.h                       |   2 +-
 runtime/main.cpp                              |   4 +-
 runtime/numeric-output.cpp                    | 153 ------
 runtime/terminator.cpp                        |  10 +
 runtime/terminator.h                          |   4 +
 runtime/tools.cpp                             |  27 +-
 runtime/tools.h                               |   8 +-
 runtime/transformational.cpp                  |  49 +-
 runtime/transformational.h                    |   7 +-
 runtime/type-code.h                           |   2 +-
 runtime/unit-map.cpp                          |  72 +++
 runtime/unit-map.h                            |  87 ++++
 runtime/unit.cpp                              | 376 ++++++++++++---
 runtime/unit.h                                |  49 +-
 test/Evaluate/reshape.cpp                     |  14 +-
 test/Runtime/CMakeLists.txt                   |  17 +
 test/Runtime/format.cpp                       |  40 +-
 test/Runtime/hello.cpp                        |  87 ++--
 test/Runtime/list-input.cpp                   |  68 +++
 test/Runtime/testing.cpp                      |  43 ++
 test/Runtime/testing.h                        |  13 +
 test/Semantics/call15.f90                     |   2 +-
 55 files changed, 2953 insertions(+), 1067 deletions(-)
 create mode 100644 runtime/edit-input.cpp
 create mode 100644 runtime/edit-input.h
 rename runtime/{numeric-output.h => edit-output.cpp} (56%)
 create mode 100644 runtime/edit-output.h
 create mode 100644 runtime/iostat.cpp
 create mode 100644 runtime/iostat.h
 delete mode 100644 runtime/numeric-output.cpp
 create mode 100644 runtime/unit-map.cpp
 create mode 100644 runtime/unit-map.h
 create mode 100644 test/Runtime/list-input.cpp
 create mode 100644 test/Runtime/testing.cpp
 create mode 100644 test/Runtime/testing.h

diff --git a/documentation/IORuntimeInternals.md b/documentation/IORuntimeInternals.md
index 70dd0941ac76..c9b1ce4078ec 100644
--- a/documentation/IORuntimeInternals.md
+++ b/documentation/IORuntimeInternals.md
@@ -273,12 +273,13 @@ A Narrative Overview Of `PRINT *, 'HELLO, WORLD'`
 =================================================
 1. When the compiled Fortran program begins execution at the `main()`
 entry point exported from its main program, it calls `ProgramStart()`
-with its arguments and environment.  `ProgramStart()` calls
-`ExternalFileUnit::InitializePredefinedUnits()` to create and
-initialize Fortran units 5 and 6 and connect them with the
-standard input and output file descriptors (respectively).
+with its arguments and environment.
 1. The generated code calls `BeginExternalListOutput()` to
 start the sequence of calls that implement the `PRINT` statement.
+Since the Fortran runtime I/O library has not yet been used in
+this process, its data structures are initialized on this
+first call, and Fortran I/O units 5 and 6 are connected with
+the stadard input and output file descriptors (respectively).
 The default unit code is converted to 6 and passed to
 `ExternalFileUnit::LookUpOrCrash()`, which returns a reference to
 unit 6's instance.
diff --git a/include/flang/Parser/char-buffer.h b/include/flang/Parser/char-buffer.h
index a62659b7c69d..0df690af3aa7 100644
--- a/include/flang/Parser/char-buffer.h
+++ b/include/flang/Parser/char-buffer.h
@@ -47,7 +47,7 @@ class CharBuffer {
     lastBlockEmpty_ = false;
   }
 
-  char *FreeSpace(std::size_t *);
+  char *FreeSpace(std::size_t &);
   void Claim(std::size_t);
 
   // The return value is the byte offset of the new data,
diff --git a/include/flang/Semantics/type.h b/include/flang/Semantics/type.h
index 935c8dbf7949..85930d334ebb 100644
--- a/include/flang/Semantics/type.h
+++ b/include/flang/Semantics/type.h
@@ -327,9 +327,7 @@ class DeclTypeSpec {
   bool IsUnlimitedPolymorphic() const {
     return category_ == TypeStar || category_ == ClassStar;
   }
-  bool IsAssumedType() const {
-    return category_ == TypeStar;
-  }
+  bool IsAssumedType() const { return category_ == TypeStar; }
   bool IsNumeric(TypeCategory) const;
   const NumericTypeSpec &numericTypeSpec() const;
   const LogicalTypeSpec &logicalTypeSpec() const;
diff --git a/lib/Parser/char-buffer.cpp b/lib/Parser/char-buffer.cpp
index 655dd3173d7f..4f72a7bdac31 100644
--- a/lib/Parser/char-buffer.cpp
+++ b/lib/Parser/char-buffer.cpp
@@ -14,7 +14,7 @@
 
 namespace Fortran::parser {
 
-char *CharBuffer::FreeSpace(std::size_t *n) {
+char *CharBuffer::FreeSpace(std::size_t &n) {
   int offset{LastBlockOffset()};
   if (blocks_.empty()) {
     blocks_.emplace_front();
@@ -24,7 +24,7 @@ char *CharBuffer::FreeSpace(std::size_t *n) {
     last_ = blocks_.emplace_after(last_);
     lastBlockEmpty_ = true;
   }
-  *n = Block::capacity - offset;
+  n = Block::capacity - offset;
   return last_->data + offset;
 }
 
@@ -38,7 +38,7 @@ void CharBuffer::Claim(std::size_t n) {
 std::size_t CharBuffer::Put(const char *data, std::size_t n) {
   std::size_t chunk;
   for (std::size_t at{0}; at < n; at += chunk) {
-    char *to{FreeSpace(&chunk)};
+    char *to{FreeSpace(chunk)};
     chunk = std::min(n - at, chunk);
     Claim(chunk);
     std::memcpy(to, data + at, chunk);
diff --git a/lib/Parser/source.cpp b/lib/Parser/source.cpp
index 0fbb8e3df1b1..e1bbfcac765c 100644
--- a/lib/Parser/source.cpp
+++ b/lib/Parser/source.cpp
@@ -200,7 +200,7 @@ bool SourceFile::ReadFile(std::string errorPath, std::stringstream *error) {
   CharBuffer buffer;
   while (true) {
     std::size_t count;
-    char *to{buffer.FreeSpace(&count)};
+    char *to{buffer.FreeSpace(count)};
     ssize_t got{read(fileDescriptor_, to, count)};
     if (got < 0) {
       *error << "could not read " << errorPath << ": " << std::strerror(errno);
diff --git a/lib/Semantics/check-call.cpp b/lib/Semantics/check-call.cpp
index 3273ed22da40..88997874bb97 100644
--- a/lib/Semantics/check-call.cpp
+++ b/lib/Semantics/check-call.cpp
@@ -613,16 +613,13 @@ static void CheckExplicitInterfaceArg(evaluate::ActualArgument &arg,
               const Symbol &assumed{DEREF(arg.GetAssumedTypeDummy())};
               if (!object.type.type().IsAssumedType()) {
                 messages.Say(
-                    "Assumed-type TYPE(*) '%s' may be associated only with an"
-                    " assumed-TYPE(*) %s"_err_en_US,
+                    "Assumed-type '%s' may be associated only with an assumed-type %s"_err_en_US,
                     assumed.name(), dummyName);
               } else if (const auto *details{
                              assumed.detailsIf<ObjectEntityDetails>()}) {
                 if (!(details->IsAssumedShape() || details->IsAssumedRank())) {
                   messages.Say(  // C711
-                      "Assumed-type TYPE(*) '%s' must be either assumed "
-                      "shape or assumed rank to be associated with TYPE(*) "
-                      "%s"_err_en_US,
+                      "Assumed-type '%s' must be either assumed shape or assumed rank to be associated with assumed-type %s"_err_en_US,
                       assumed.name(), dummyName);
                 }
               }
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index 571775ce8984..ddd77f71fdbe 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -12,25 +12,27 @@ add_library(FortranRuntime
   connection.cpp
   derived-type.cpp
   descriptor.cpp
+  edit-input.cpp
+  edit-output.cpp
   environment.cpp
   file.cpp
   format.cpp
   internal-unit.cpp
+  iostat.cpp
   io-api.cpp
   io-error.cpp
   io-stmt.cpp
   main.cpp
   memory.cpp
-  numeric-output.cpp
   stop.cpp
   terminator.cpp
   tools.cpp
   transformational.cpp
   type-code.cpp
   unit.cpp
+  unit-map.cpp
 )
 
 target_link_libraries(FortranRuntime
-  FortranCommon
   FortranDecimal
 )
diff --git a/runtime/ISO_Fortran_binding.cpp b/runtime/ISO_Fortran_binding.cpp
index bcb0d055a740..1ebaa5858349 100644
--- a/runtime/ISO_Fortran_binding.cpp
+++ b/runtime/ISO_Fortran_binding.cpp
@@ -11,6 +11,7 @@
 
 #include "../include/flang/ISO_Fortran_binding.h"
 #include "descriptor.h"
+#include <cstdlib>
 
 namespace Fortran::ISO {
 extern "C" {
@@ -75,7 +76,7 @@ int CFI_allocate(CFI_cdesc_t *descriptor, const CFI_index_t lower_bounds[],
     dim->sm = byteSize;
     byteSize *= extent;
   }
-  void *p{new char[byteSize]};
+  void *p{std::malloc(byteSize)};
   if (!p) {
     return CFI_ERROR_MEM_ALLOCATION;
   }
@@ -99,7 +100,7 @@ int CFI_deallocate(CFI_cdesc_t *descriptor) {
   if (!descriptor->base_addr) {
     return CFI_ERROR_BASE_ADDR_NULL;
   }
-  delete[] static_cast<char *>(descriptor->base_addr);
+  std::free(descriptor->base_addr);
   descriptor->base_addr = nullptr;
   return CFI_SUCCESS;
 }
diff --git a/runtime/buffer.h b/runtime/buffer.h
index a956a3bbae1d..63bbbdc26c02 100644
--- a/runtime/buffer.h
+++ b/runtime/buffer.h
@@ -43,6 +43,7 @@ template<typename STORE> class FileFrame {
   std::size_t FrameLength() const {
     return std::min<std::size_t>(length_ - frame_, size_ - (start_ + frame_));
   }
+  std::size_t BytesBufferedBeforeFrame() const { return frame_ - start_; }
 
   // Returns a short frame at a non-fatal EOF.  Can return a long frame as well.
   std::size_t ReadFrame(
@@ -52,10 +53,10 @@ template<typename STORE> class FileFrame {
     if (at < fileOffset_ || at > fileOffset_ + length_) {
       Reset(at);
     }
-    frame_ = static_cast<std::size_t>(at - fileOffset_);
-    if (start_ + frame_ + bytes > size_) {
+    frame_ = at - fileOffset_;
+    if (static_cast<std::int64_t>(start_ + frame_ + bytes) > size_) {
       DiscardLeadingBytes(frame_, handler);
-      if (start_ + bytes > size_) {
+      if (static_cast<std::int64_t>(start_ + bytes) > size_) {
         // Frame would wrap around; shift current data (if any) to force
         // contiguity.
         RUNTIME_CHECK(handler, length_ < size_);
@@ -90,7 +91,8 @@ template<typename STORE> class FileFrame {
 
   void WriteFrame(FileOffset at, std::size_t bytes, IoErrorHandler &handler) {
     if (!dirty_ || at < fileOffset_ || at > fileOffset_ + length_ ||
-        start_ + (at - fileOffset_) + bytes > size_) {
+        start_ + (at - fileOffset_) + static_cast<std::int64_t>(bytes) >
+            size_) {
       Flush(handler);
       fileOffset_ = at;
       Reallocate(bytes, handler);
@@ -120,11 +122,11 @@ template<typename STORE> class FileFrame {
 private:
   STORE &Store() { return static_cast<STORE &>(*this); }
 
-  void Reallocate(std::size_t bytes, const Terminator &terminator) {
+  void Reallocate(std::int64_t bytes, const Terminator &terminator) {
     if (bytes > size_) {
       char *old{buffer_};
       auto oldSize{size_};
-      size_ = std::max(bytes, minBuffer);
+      size_ = std::max<std::int64_t>(bytes, minBuffer);
       buffer_ =
           reinterpret_cast<char *>(AllocateMemoryOrCrash(terminator, size_));
       auto chunk{std::min<std::int64_t>(length_, oldSize - start_)};
@@ -141,7 +143,7 @@ template<typename STORE> class FileFrame {
     dirty_ = false;
   }
 
-  void DiscardLeadingBytes(std::size_t n, const Terminator &terminator) {
+  void DiscardLeadingBytes(std::int64_t n, const Terminator &terminator) {
     RUNTIME_CHECK(terminator, length_ >= n);
     length_ -= n;
     if (length_ == 0) {
@@ -163,7 +165,7 @@ template<typename STORE> class FileFrame {
   static constexpr std::size_t minBuffer{64 << 10};
 
   char *buffer_{nullptr};
-  std::size_t size_{0};  // current allocated buffer size
+  std::int64_t size_{0};  // current allocated buffer size
   FileOffset fileOffset_{0};  // file offset corresponding to buffer valid data
   std::int64_t start_{0};  // buffer_[] offset of valid data
   std::int64_t length_{0};  // valid data length (can wrap)
diff --git a/runtime/connection.cpp b/runtime/connection.cpp
index ff15a40819ab..d206b050aee4 100644
--- a/runtime/connection.cpp
+++ b/runtime/connection.cpp
@@ -12,8 +12,20 @@
 namespace Fortran::runtime::io {
 
 std::size_t ConnectionState::RemainingSpaceInRecord() const {
-  return recordLength.value_or(
-             executionEnvironment.listDirectedOutputLineLengthLimit) -
-      positionInRecord;
+  auto recl{recordLength.value_or(
+      executionEnvironment.listDirectedOutputLineLengthLimit)};
+  return positionInRecord >= recl ? 0 : recl - positionInRecord;
+}
+
+bool ConnectionState::IsAtEOF() const {
+  return endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber;
+}
+
+void ConnectionState::HandleAbsolutePosition(std::int64_t n) {
+  positionInRecord = std::max(n, std::int64_t{0}) + leftTabLimit.value_or(0);
+}
+
+void ConnectionState::HandleRelativePosition(std::int64_t n) {
+  positionInRecord = std::max(leftTabLimit.value_or(0), positionInRecord + n);
 }
 }
diff --git a/runtime/connection.h b/runtime/connection.h
index 85372dfa610d..1c0716145b47 100644
--- a/runtime/connection.h
+++ b/runtime/connection.h
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// Fortran I/O connection state (internal & external)
+// Fortran I/O connection state (abstracted over internal & external units)
 
 #ifndef FORTRAN_RUNTIME_IO_CONNECTION_H_
 #define FORTRAN_RUNTIME_IO_CONNECTION_H_
@@ -17,6 +17,7 @@
 
 namespace Fortran::runtime::io {
 
+enum class Direction { Output, Input };
 enum class Access { Sequential, Direct, Stream };
 
 inline bool IsRecordFile(Access a) { return a != Access::Stream; }
@@ -25,24 +26,30 @@ inline bool IsRecordFile(Access a) { return a != Access::Stream; }
 // established in an OPEN statement.
 struct ConnectionAttributes {
   Access access{Access::Sequential};  // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
-  std::optional<std::size_t> recordLength;  // RECL= when fixed-length
+  std::optional<std::int64_t> recordLength;  // RECL= when fixed-length
   bool isUnformatted{false};  // FORM='UNFORMATTED'
   bool isUTF8{false};  // ENCODING='UTF-8'
 };
 
 struct ConnectionState : public ConnectionAttributes {
+  bool IsAtEOF() const;  // true when read has hit EOF or endfile record
   std::size_t RemainingSpaceInRecord() const;
-  // Positions in a record file (sequential or direct, but not stream)
-  std::int64_t recordOffsetInFile{0};
+  void HandleAbsolutePosition(std::int64_t);
+  void HandleRelativePosition(std::int64_t);
+
+  // Positions in a record file (sequential or direct, not stream)
   std::int64_t currentRecordNumber{1};  // 1 is first
   std::int64_t positionInRecord{0};  // offset in current record
   std::int64_t furthestPositionInRecord{0};  // max(positionInRecord)
   bool nonAdvancing{false};  // ADVANCE='NO'
+
   // Set at end of non-advancing I/O data transfer
   std::optional<std::int64_t> leftTabLimit;  // offset in current record
+
   // currentRecordNumber value captured after ENDFILE/REWIND/BACKSPACE statement
-  // on a sequential access file
+  // or an end-of-file READ condition on a sequential access file
   std::optional<std::int64_t> endfileRecordNumber;
+
   // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
   MutableModes modes;  // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
 };
diff --git a/runtime/descriptor.cpp b/runtime/descriptor.cpp
index 9e91c1b80199..00a57cd1e216 100644
--- a/runtime/descriptor.cpp
+++ b/runtime/descriptor.cpp
@@ -7,7 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "descriptor.h"
-#include "flang/Common/idioms.h"
+#include "memory.h"
+#include "terminator.h"
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
@@ -27,11 +28,13 @@ Descriptor::~Descriptor() {
 void Descriptor::Establish(TypeCode t, std::size_t elementBytes, void *p,
     int rank, const SubscriptValue *extent, ISO::CFI_attribute_t attribute,
     bool addendum) {
-  CHECK(ISO::CFI_establish(&raw_, p, attribute, t.raw(), elementBytes, rank,
-            extent) == CFI_SUCCESS);
+  Terminator terminator{__FILE__, __LINE__};
+  RUNTIME_CHECK(terminator,
+      ISO::CFI_establish(&raw_, p, attribute, t.raw(), elementBytes, rank,
+          extent) == CFI_SUCCESS);
   raw_.f18Addendum = addendum;
   DescriptorAddendum *a{Addendum()};
-  CHECK(addendum == (a != nullptr));
+  RUNTIME_CHECK(terminator, addendum == (a != nullptr));
   if (a) {
     new (a) DescriptorAddendum{};
   }
@@ -44,11 +47,13 @@ void Descriptor::Establish(TypeCategory c, int kind, void *p, int rank,
   if (c == TypeCategory::Complex) {
     elementBytes *= 2;
   }
-  CHECK(ISO::CFI_establish(&raw_, p, attribute, TypeCode(c, kind).raw(),
-            elementBytes, rank, extent) == CFI_SUCCESS);
+  Terminator terminator{__FILE__, __LINE__};
+  RUNTIME_CHECK(terminator,
+      ISO::CFI_establish(&raw_, p, attribute, TypeCode(c, kind).raw(),
+          elementBytes, rank, extent) == CFI_SUCCESS);
   raw_.f18Addendum = addendum;
   DescriptorAddendum *a{Addendum()};
-  CHECK(addendum == (a != nullptr));
+  RUNTIME_CHECK(terminator, addendum == (a != nullptr));
   if (a) {
     new (a) DescriptorAddendum{};
   }
@@ -56,41 +61,45 @@ void Descriptor::Establish(TypeCategory c, int kind, void *p, int rank,
 
 void Descriptor::Establish(const DerivedType &dt, void *p, int rank,
     const SubscriptValue *extent, ISO::CFI_attribute_t attribute) {
-  CHECK(ISO::CFI_establish(&raw_, p, attribute, CFI_type_struct,
-            dt.SizeInBytes(), rank, extent) == CFI_SUCCESS);
+  Terminator terminator{__FILE__, __LINE__};
+  RUNTIME_CHECK(terminator,
+      ISO::CFI_establish(&raw_, p, attribute, CFI_type_struct, dt.SizeInBytes(),
+          rank, extent) == CFI_SUCCESS);
   raw_.f18Addendum = true;
   DescriptorAddendum *a{Addendum()};
-  CHECK(a);
+  RUNTIME_CHECK(terminator, a);
   new (a) DescriptorAddendum{&dt};
 }
 
-std::unique_ptr<Descriptor> Descriptor::Create(TypeCode t,
-    std::size_t elementBytes, void *p, int rank, const SubscriptValue *extent,
+OwningPtr<Descriptor> Descriptor::Create(TypeCode t, std::size_t elementBytes,
+    void *p, int rank, const SubscriptValue *extent,
     ISO::CFI_attribute_t attribute) {
   std::size_t bytes{SizeInBytes(rank, true)};
-  Descriptor *result{reinterpret_cast<Descriptor *>(new char[bytes])};
-  CHECK(result);
+  Terminator terminator{__FILE__, __LINE__};
+  Descriptor *result{
+      reinterpret_cast<Descriptor *>(AllocateMemoryOrCrash(terminator, bytes))};
   result->Establish(t, elementBytes, p, rank, extent, attribute, true);
-  return std::unique_ptr<Descriptor>{result};
+  return OwningPtr<Descriptor>{result};
 }
 
-std::unique_ptr<Descriptor> Descriptor::Create(TypeCategory c, int kind,
-    void *p, int rank, const SubscriptValue *extent,
-    ISO::CFI_attribute_t attribute) {
+OwningPtr<Descriptor> Descriptor::Create(TypeCategory c, int kind, void *p,
+    int rank, const SubscriptValue *extent, ISO::CFI_attribute_t attribute) {
   std::size_t bytes{SizeInBytes(rank, true)};
-  Descriptor *result{reinterpret_cast<Descriptor *>(new char[bytes])};
-  CHECK(result);
+  Terminator terminator{__FILE__, __LINE__};
+  Descriptor *result{
+      reinterpret_cast<Descriptor *>(AllocateMemoryOrCrash(terminator, bytes))};
   result->Establish(c, kind, p, rank, extent, attribute, true);
-  return std::unique_ptr<Descriptor>{result};
+  return OwningPtr<Descriptor>{result};
 }
 
-std::unique_ptr<Descriptor> Descriptor::Create(const DerivedType &dt, void *p,
+OwningPtr<Descriptor> Descriptor::Create(const DerivedType &dt, void *p,
     int rank, const SubscriptValue *extent, ISO::CFI_attribute_t attribute) {
   std::size_t bytes{SizeInBytes(rank, true, dt.lenParameters())};
-  Descriptor *result{reinterpret_cast<Descriptor *>(new char[bytes])};
-  CHECK(result);
+  Terminator terminator{__FILE__, __LINE__};
+  Descriptor *result{
+      reinterpret_cast<Descriptor *>(AllocateMemoryOrCrash(terminator, bytes))};
   result->Establish(dt, p, rank, extent, attribute);
-  return std::unique_ptr<Descriptor>{result};
+  return OwningPtr<Descriptor>{result};
 }
 
 std::size_t Descriptor::SizeInBytes() const {
@@ -141,42 +150,103 @@ void Descriptor::Destroy(char *data, bool finalize) const {
   }
 }
 
+bool Descriptor::IncrementSubscripts(
+    SubscriptValue *subscript, const int *permutation) const {
+  for (int j{0}; j < raw_.rank; ++j) {
+    int k{permutation ? permutation[j] : j};
+    const Dimension &dim{GetDimension(k)};
+    if (subscript[k]++ < dim.UpperBound()) {
+      return true;
+    }
+    subscript[k] = dim.LowerBound();
+  }
+  return false;
+}
+
+bool Descriptor::DecrementSubscripts(
+    SubscriptValue *subscript, const int *permutation) const {
+  for (int j{raw_.rank - 1}; j >= 0; --j) {
+    int k{permutation ? permutation[j] : j};
+    const Dimension &dim{GetDimension(k)};
+    if (--subscript[k] >= dim.LowerBound()) {
+      return true;
+    }
+    subscript[k] = dim.UpperBound();
+  }
+  return false;
+}
+
+std::size_t Descriptor::ZeroBasedElementNumber(
+    const SubscriptValue *subscript, const int *permutation) const {
+  std::size_t result{0};
+  std::size_t coefficient{1};
+  for (int j{0}; j < raw_.rank; ++j) {
+    int k{permutation ? permutation[j] : j};
+    const Dimension &dim{GetDimension(k)};
+    result += coefficient * (subscript[k] - dim.LowerBound());
+    coefficient *= dim.Extent();
+  }
+  return result;
+}
+
+bool Descriptor::SubscriptsForZeroBasedElementNumber(SubscriptValue *subscript,
+    std::size_t elementNumber, const int *permutation) const {
+  std::size_t coefficient{1};
+  std::size_t dimCoefficient[maxRank];
+  for (int j{0}; j < raw_.rank; ++j) {
+    int k{permutation ? permutation[j] : j};
+    const Dimension &dim{GetDimension(k)};
+    dimCoefficient[j] = coefficient;
+    coefficient *= dim.Extent();
+  }
+  if (elementNumber >= coefficient) {
+    return false;  // out of range
+  }
+  for (int j{raw_.rank - 1}; j >= 0; --j) {
+    int k{permutation ? permutation[j] : j};
+    const Dimension &dim{GetDimension(k)};
+    std::size_t quotient{j ? elementNumber / dimCoefficient[j] : 0};
+    subscript[k] =
+        dim.LowerBound() + elementNumber - dimCoefficient[j] * quotient;
+    elementNumber = quotient;
+  }
+  return true;
+}
+
 void Descriptor::Check() const {
   // TODO
 }
 
-std::ostream &Descriptor::Dump(std::ostream &o) const {
-  o << "Descriptor @ 0x" << std::hex << reinterpret_cast<std::intptr_t>(this)
-    << std::dec << ":\n";
-  o << "  base_addr 0x" << std::hex
-    << reinterpret_cast<std::intptr_t>(raw_.base_addr) << std::dec << '\n';
-  o << "  elem_len  " << raw_.elem_len << '\n';
-  o << "  version   " << raw_.version
-    << (raw_.version == CFI_VERSION ? "(ok)" : "BAD!") << '\n';
-  o << "  rank      " << static_cast<int>(raw_.rank) << '\n';
-  o << "  type      " << static_cast<int>(raw_.type) << '\n';
-  o << "  attribute " << static_cast<int>(raw_.attribute) << '\n';
-  o << "  addendum? " << static_cast<bool>(raw_.f18Addendum) << '\n';
+void Descriptor::Dump(FILE *f) const {
+  std::fprintf(f, "Descriptor @ %p:\n", reinterpret_cast<const void *>(this));
+  std::fprintf(f, "  base_addr %p\n", raw_.base_addr);
+  std::fprintf(f, "  elem_len  %zd\n", static_cast<std::size_t>(raw_.elem_len));
+  std::fprintf(f, "  version   %d\n", static_cast<int>(raw_.version));
+  std::fprintf(f, "  rank      %d\n", static_cast<int>(raw_.rank));
+  std::fprintf(f, "  type      %d\n", static_cast<int>(raw_.type));
+  std::fprintf(f, "  attribute %d\n", static_cast<int>(raw_.attribute));
+  std::fprintf(f, "  addendum  %d\n", static_cast<int>(raw_.f18Addendum));
   for (int j{0}; j < raw_.rank; ++j) {
-    o << "  dim[" << j << "] lower_bound " << raw_.dim[j].lower_bound << '\n';
-    o << "         extent      " << raw_.dim[j].extent << '\n';
-    o << "         sm          " << raw_.dim[j].sm << '\n';
+    std::fprintf(f, "  dim[%d] lower_bound %jd\n", j,
+        static_cast<std::intmax_t>(raw_.dim[j].lower_bound));
+    std::fprintf(f, "         extent      %jd\n",
+        static_cast<std::intmax_t>(raw_.dim[j].extent));
+    std::fprintf(f, "         sm          %jd\n",
+        static_cast<std::intmax_t>(raw_.dim[j].sm));
   }
   if (const DescriptorAddendum * addendum{Addendum()}) {
-    addendum->Dump(o);
+    addendum->Dump(f);
   }
-  return o;
 }
 
 std::size_t DescriptorAddendum::SizeInBytes() const {
   return SizeInBytes(LenParameters());
 }
 
-std::ostream &DescriptorAddendum::Dump(std::ostream &o) const {
-  o << "  derivedType @ 0x" << std::hex
-    << reinterpret_cast<std::intptr_t>(derivedType_) << std::dec << '\n';
-  o << "  flags         " << flags_ << '\n';
+void DescriptorAddendum::Dump(FILE *f) const {
+  std::fprintf(
+      f, "  derivedType @ %p\n", reinterpret_cast<const void *>(derivedType_));
+  std::fprintf(f, "  flags 0x%jx\n", static_cast<std::intmax_t>(flags_));
   // TODO: LEN parameter values
-  return o;
 }
 }
diff --git a/runtime/descriptor.h b/runtime/descriptor.h
index bb8a428c83ec..8f7a88e10731 100644
--- a/runtime/descriptor.h
+++ b/runtime/descriptor.h
@@ -19,14 +19,14 @@
 // but should never reference this internal header.
 
 #include "derived-type.h"
+#include "memory.h"
 #include "type-code.h"
 #include "flang/ISO_Fortran_binding.h"
 #include <cassert>
 #include <cinttypes>
 #include <cstddef>
+#include <cstdio>
 #include <cstring>
-#include <memory>
-#include <ostream>
 
 namespace Fortran::runtime {
 
@@ -93,7 +93,7 @@ class DescriptorAddendum {
     len_[which] = x;
   }
 
-  std::ostream &Dump(std::ostream &) const;
+  void Dump(FILE * = stdout) const;
 
 private:
   const DerivedType *derivedType_{nullptr};
@@ -141,17 +141,15 @@ class Descriptor {
       const SubscriptValue *extent = nullptr,
       ISO::CFI_attribute_t attribute = CFI_attribute_other);
 
-  static std::unique_ptr<Descriptor> Create(TypeCode t,
-      std::size_t elementBytes, void *p = nullptr, int rank = maxRank,
-      const SubscriptValue *extent = nullptr,
-      ISO::CFI_attribute_t attribute = CFI_attribute_other);
-  static std::unique_ptr<Descriptor> Create(TypeCategory, int kind,
+  static OwningPtr<Descriptor> Create(TypeCode t, std::size_t elementBytes,
       void *p = nullptr, int rank = maxRank,
       const SubscriptValue *extent = nullptr,
       ISO::CFI_attribute_t attribute = CFI_attribute_other);
-  static std::unique_ptr<Descriptor> Create(const DerivedType &dt,
-      void *p = nullptr, int rank = maxRank,
-      const SubscriptValue *extent = nullptr,
+  static OwningPtr<Descriptor> Create(TypeCategory, int kind, void *p = nullptr,
+      int rank = maxRank, const SubscriptValue *extent = nullptr,
+      ISO::CFI_attribute_t attribute = CFI_attribute_other);
+  static OwningPtr<Descriptor> Create(const DerivedType &dt, void *p = nullptr,
+      int rank = maxRank, const SubscriptValue *extent = nullptr,
       ISO::CFI_attribute_t attribute = CFI_attribute_other);
 
   ISO::CFI_cdesc_t &raw() { return raw_; }
@@ -192,33 +190,42 @@ class Descriptor {
     return offset;
   }
 
-  template<typename A> A *Element(std::size_t offset) const {
+  template<typename A> A *OffsetElement(std::size_t offset) const {
     return reinterpret_cast<A *>(
         reinterpret_cast<char *>(raw_.base_addr) + offset);
   }
 
   template<typename A> A *Element(const SubscriptValue *subscript) const {
-    return Element<A>(SubscriptsToByteOffset(subscript));
+    return OffsetElement<A>(SubscriptsToByteOffset(subscript));
   }
 
-  void GetLowerBounds(SubscriptValue *subscript) const {
-    for (int j{0}; j < raw_.rank; ++j) {
-      subscript[j] = GetDimension(j).LowerBound();
+  template<typename A> A *ZeroBasedIndexedElement(std::size_t n) const {
+    SubscriptValue at[maxRank];
+    if (SubscriptsForZeroBasedElementNumber(at, n)) {
+      return Element<A>(at);
     }
+    return nullptr;
   }
 
-  void IncrementSubscripts(
-      SubscriptValue *subscript, const int *permutation = nullptr) const {
+  void GetLowerBounds(SubscriptValue *subscript) const {
     for (int j{0}; j < raw_.rank; ++j) {
-      int k{permutation ? permutation[j] : j};
-      const Dimension &dim{GetDimension(k)};
-      if (subscript[k]++ < dim.UpperBound()) {
-        break;
-      }
-      subscript[k] = dim.LowerBound();
+      subscript[j] = GetDimension(j).LowerBound();
     }
   }
 
+  // When the passed subscript vector contains the last (or first)
+  // subscripts of the array, these wrap the subscripts around to
+  // their first (or last) values and return false.
+  bool IncrementSubscripts(
+      SubscriptValue *, const int *permutation = nullptr) const;
+  bool DecrementSubscripts(
+      SubscriptValue *, const int *permutation = nullptr) const;
+  // False when out of range.
+  bool SubscriptsForZeroBasedElementNumber(SubscriptValue *,
+      std::size_t elementNumber, const int *permutation = nullptr) const;
+  std::size_t ZeroBasedElementNumber(
+      const SubscriptValue *, const int *permutation = nullptr) const;
+
   DescriptorAddendum *Addendum() {
     if (raw_.f18Addendum != 0) {
       return reinterpret_cast<DescriptorAddendum *>(&GetDimension(rank()));
@@ -270,7 +277,7 @@ class Descriptor {
 
   // TODO: creation of array sections
 
-  std::ostream &Dump(std::ostream &) const;
+  void Dump(FILE * = stdout) const;
 
 private:
   ISO::CFI_cdesc_t raw_;
diff --git a/runtime/edit-input.cpp b/runtime/edit-input.cpp
new file mode 100644
index 000000000000..5b7884021067
--- /dev/null
+++ b/runtime/edit-input.cpp
@@ -0,0 +1,428 @@
+//===-- runtime/edit-input.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 "edit-input.h"
+#include "flang/Common/real.h"
+#include "flang/Common/uint128.h"
+
+namespace Fortran::runtime::io {
+
+static bool EditBOZInput(IoStatementState &io, const DataEdit &edit, void *n,
+    int base, int totalBitSize) {
+  std::optional<int> remaining;
+  if (edit.width) {
+    remaining = std::max(0, *edit.width);
+  }
+  io.SkipSpaces(remaining);
+  std::optional<char32_t> next{io.NextInField(remaining)};
+  common::UnsignedInt128 value{0};
+  for (; next; next = io.NextInField(remaining)) {
+    char32_t ch{*next};
+    if (ch == ' ') {
+      continue;
+    }
+    int digit{0};
+    if (ch >= '0' && ch <= '1') {
+      digit = ch - '0';
+    } else if (base >= 8 && ch >= '2' && ch <= '7') {
+      digit = ch - '0';
+    } else if (base >= 10 && ch >= '8' && ch <= '9') {
+      digit = ch - '0';
+    } else if (base == 16 && ch >= 'A' && ch <= 'Z') {
+      digit = ch + 10 - 'A';
+    } else if (base == 16 && ch >= 'a' && ch <= 'z') {
+      digit = ch + 10 - 'a';
+    } else {
+      io.GetIoErrorHandler().SignalError(
+          "Bad character '%lc' in B/O/Z input field", ch);
+      return false;
+    }
+    value *= base;
+    value += digit;
+  }
+  // TODO: check for overflow
+  std::memcpy(n, &value, totalBitSize >> 3);
+  return true;
+}
+
+// Returns false if there's a '-' sign
+static bool ScanNumericPrefix(IoStatementState &io, const DataEdit &edit,
+    std::optional<char32_t> &next, std::optional<int> &remaining) {
+  if (edit.descriptor != DataEdit::ListDirected && edit.width) {
+    remaining = std::max(0, *edit.width);
+  } else {
+    // list-directed, namelist, or (nonstandard) 0-width input editing
+    remaining.reset();
+  }
+  io.SkipSpaces(remaining);
+  next = io.NextInField(remaining);
+  bool negative{false};
+  if (next) {
+    negative = *next == '-';
+    if (negative || *next == '+') {
+      next = io.NextInField(remaining);
+    }
+  }
+  return negative;
+}
+
+bool EditIntegerInput(
+    IoStatementState &io, const DataEdit &edit, void *n, int kind) {
+  RUNTIME_CHECK(io.GetIoErrorHandler(), kind >= 1 && !(kind & (kind - 1)));
+  switch (edit.descriptor) {
+  case DataEdit::ListDirected:
+  case 'G':
+  case 'I': break;
+  case 'B': return EditBOZInput(io, edit, n, 2, kind << 3);
+  case 'O': return EditBOZInput(io, edit, n, 8, kind << 3);
+  case 'Z': return EditBOZInput(io, edit, n, 16, kind << 3);
+  default:
+    io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
+        "Data edit descriptor '%c' may not be used with an INTEGER data item",
+        edit.descriptor);
+    return false;
+  }
+  std::optional<int> remaining;
+  std::optional<char32_t> next;
+  bool negate{ScanNumericPrefix(io, edit, next, remaining)};
+  common::UnsignedInt128 value;
+  for (; next; next = io.NextInField(remaining)) {
+    char32_t ch{*next};
+    if (ch == ' ') {
+      if (edit.modes.editingFlags & blankZero) {
+        ch = '0';  // BZ mode - treat blank as if it were zero
+      } else {
+        continue;
+      }
+    }
+    int digit{0};
+    if (ch >= '0' && ch <= '9') {
+      digit = ch - '0';
+    } else {
+      io.GetIoErrorHandler().SignalError(
+          "Bad character '%lc' in INTEGER input field", ch);
+      return false;
+    }
+    value *= 10;
+    value += digit;
+  }
+  if (negate) {
+    value = -value;
+  }
+  std::memcpy(n, &value, kind);
+  return true;
+}
+
+static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
+    const DataEdit &edit, int &exponent) {
+  std::optional<int> remaining;
+  std::optional<char32_t> next;
+  int got{0};
+  std::optional<int> decimalPoint;
+  if (ScanNumericPrefix(io, edit, next, remaining) && next) {
+    if (got < bufferSize) {
+      buffer[got++] = '-';
+    }
+  }
+  if (!next) {  // empty field means zero
+    if (got < bufferSize) {
+      buffer[got++] = '0';
+    }
+    return got;
+  }
+  if (got < bufferSize) {
+    buffer[got++] = '.';  // input field is normalized to a fraction
+  }
+  char32_t decimal = edit.modes.editingFlags & decimalComma ? ',' : '.';
+  auto start{got};
+  if ((*next >= 'a' && *next <= 'z') || (*next >= 'A' && *next <= 'Z')) {
+    // NaN or infinity - convert to upper case
+    for (; next &&
+         ((*next >= 'a' && *next <= 'z') || (*next >= 'A' && *next <= 'Z'));
+         next = io.NextInField(remaining)) {
+      if (got < bufferSize) {
+        if (*next >= 'a' && *next <= 'z') {
+          buffer[got++] = *next - 'a' + 'A';
+        } else {
+          buffer[got++] = *next;
+        }
+      }
+    }
+    if (next && *next == '(') {  // NaN(...)
+      while (next && *next != ')') {
+        next = io.NextInField(remaining);
+      }
+    }
+    exponent = 0;
+  } else if (*next == decimal || (*next >= '0' && *next <= '9')) {
+    for (; next; next = io.NextInField(remaining)) {
+      char32_t ch{*next};
+      if (ch == ' ') {
+        if (edit.modes.editingFlags & blankZero) {
+          ch = '0';  // BZ mode - treat blank as if it were zero
+        } else {
+          continue;
+        }
+      }
+      if (ch == '0' && got == start) {
+        // omit leading zeroes
+      } else if (ch >= '0' && ch <= '9') {
+        if (got < bufferSize) {
+          buffer[got++] = ch;
+        }
+      } else if (ch == decimal && !decimalPoint) {
+        // the decimal point is *not* copied to the buffer
+        decimalPoint = got - start;  // # of digits before the decimal point
+      } else {
+        break;
+      }
+    }
+    if (got == start && got < bufferSize) {
+      buffer[got++] = '0';  // all digits were zeroes
+    }
+    if (next &&
+        (*next == 'e' || *next == 'E' || *next == 'd' || *next == 'D' ||
+            *next == 'q' || *next == 'Q')) {
+      io.SkipSpaces(remaining);
+      next = io.NextInField(remaining);
+    }
+    exponent = -edit.modes.scale;  // default exponent is -kP
+    if (next &&
+        (*next == '-' || *next == '+' || (*next >= '0' && *next <= '9'))) {
+      bool negExpo{*next == '-'};
+      if (negExpo || *next == '+') {
+        next = io.NextInField(remaining);
+      }
+      for (exponent = 0; next && (*next >= '0' && *next <= '9');
+           next = io.NextInField(remaining)) {
+        exponent = 10 * exponent + *next - '0';
+      }
+      if (negExpo) {
+        exponent = -exponent;
+      }
+    }
+    if (decimalPoint) {
+      exponent += *decimalPoint;
+    } else {
+      // When no decimal point (or comma) appears in the value, the 'd'
+      // part of the edit descriptor must be interpreted as the number of
+      // digits in the value to be interpreted as being to the *right* of
+      // the assumed decimal point (13.7.2.3.2)
+      exponent += got - start - edit.digits.value_or(0);
+    }
+  } else {
+    // TODO: hex FP input
+    exponent = 0;
+    return 0;
+  }
+  if (remaining) {
+    while (next && *next == ' ') {
+      next = io.NextInField(remaining);
+    }
+    if (next) {
+      return 0;  // error: unused nonblank character in fixed-width field
+    }
+  }
+  return got;
+}
+
+template<int binaryPrecision>
+bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
+  static constexpr int maxDigits{
+      common::MaxDecimalConversionDigits(binaryPrecision)};
+  static constexpr int bufferSize{maxDigits + 18};
+  char buffer[bufferSize];
+  int exponent{0};
+  int got{ScanRealInput(buffer, maxDigits + 2, io, edit, exponent)};
+  if (got >= maxDigits + 2) {
+    io.GetIoErrorHandler().Crash("EditRealInput: buffer was too small");
+    return false;
+  }
+  if (got == 0) {
+    io.GetIoErrorHandler().SignalError("Bad REAL input value");
+    return false;
+  }
+  bool hadExtra{got > maxDigits};
+  if (exponent != 0) {
+    got += std::snprintf(&buffer[got], bufferSize - got, "e%d", exponent);
+  }
+  buffer[got] = '\0';
+  const char *p{buffer};
+  decimal::ConversionToBinaryResult<binaryPrecision> converted{
+      decimal::ConvertToBinary<binaryPrecision>(p, edit.modes.round)};
+  if (hadExtra) {
+    converted.flags = static_cast<enum decimal::ConversionResultFlags>(
+        converted.flags | decimal::Inexact);
+  }
+  // TODO: raise converted.flags as exceptions?
+  *reinterpret_cast<decimal::BinaryFloatingPointNumber<binaryPrecision> *>(n) =
+      converted.binary;
+  return true;
+}
+
+template<int binaryPrecision>
+bool EditRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
+  switch (edit.descriptor) {
+  case DataEdit::ListDirected:
+  case 'F':
+  case 'E':  // incl. EN, ES, & EX
+  case 'D':
+  case 'G': return EditCommonRealInput<binaryPrecision>(io, edit, n);
+  case 'B':
+    return EditBOZInput(
+        io, edit, n, 2, common::BitsForBinaryPrecision(binaryPrecision));
+  case 'O':
+    return EditBOZInput(
+        io, edit, n, 8, common::BitsForBinaryPrecision(binaryPrecision));
+  case 'Z':
+    return EditBOZInput(
+        io, edit, n, 16, common::BitsForBinaryPrecision(binaryPrecision));
+  default:
+    io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
+        "Data edit descriptor '%c' may not be used for REAL input",
+        edit.descriptor);
+    return false;
+  }
+}
+
+// 13.7.3 in Fortran 2018
+bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
+  switch (edit.descriptor) {
+  case DataEdit::ListDirected:
+  case 'L':
+  case 'G': break;
+  default:
+    io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
+        "Data edit descriptor '%c' may not be used for LOGICAL input",
+        edit.descriptor);
+    return false;
+  }
+  std::optional<int> remaining;
+  if (edit.width) {
+    remaining = std::max(0, *edit.width);
+  }
+  io.SkipSpaces(remaining);
+  std::optional<char32_t> next{io.NextInField(remaining)};
+  if (next && *next == '.') {  // skip optional period
+    next = io.NextInField(remaining);
+  }
+  if (!next) {
+    io.GetIoErrorHandler().SignalError("Empty LOGICAL input field");
+    return false;
+  }
+  switch (*next) {
+  case 'T':
+  case 't': x = true; break;
+  case 'F':
+  case 'f': x = false; break;
+  default:
+    io.GetIoErrorHandler().SignalError(
+        "Bad character '%lc' in LOGICAL input field", *next);
+    return false;
+  }
+  if (remaining) {  // ignore the rest of the field
+    io.HandleRelativePosition(*remaining);
+  }
+  return true;
+}
+
+// See 13.10.3.1 paragraphs 7-9 in Fortran 2018
+static bool EditDelimitedCharacterInput(
+    IoStatementState &io, char *x, std::size_t length, char32_t delimiter) {
+  while (true) {
+    if (auto ch{io.GetCurrentChar()}) {
+      io.HandleRelativePosition(1);
+      if (*ch == delimiter) {
+        ch = io.GetCurrentChar();
+        if (ch && *ch == delimiter) {
+          // Repeated delimiter: use as character value.  Can't straddle a
+          // record boundary.
+          io.HandleRelativePosition(1);
+        } else {
+          std::fill_n(x, length, ' ');
+          return true;
+        }
+      }
+      if (length > 0) {
+        *x++ = *ch;
+        --length;
+      }
+    } else if (!io.AdvanceRecord()) {  // EOF
+      std::fill_n(x, length, ' ');
+      return false;
+    }
+  }
+}
+
+static bool EditListDirectedDefaultCharacterInput(
+    IoStatementState &io, char *x, std::size_t length) {
+  auto ch{io.GetCurrentChar()};
+  if (ch && (*ch == '\'' || *ch == '"')) {
+    io.HandleRelativePosition(1);
+    return EditDelimitedCharacterInput(io, x, length, *ch);
+  }
+  // Undelimited list-directed character input: stop at a value separator
+  // or the end of the current record.
+  std::optional<int> remaining{length};
+  for (std::optional<char32_t> next{io.NextInField(remaining)}; next;
+       next = io.NextInField(remaining)) {
+    switch (*next) {
+    case ' ':
+    case ',':
+    case ';':
+    case '/':
+      remaining = 0;  // value separator: stop
+      break;
+    default: *x++ = *next; --length;
+    }
+  }
+  std::fill_n(x, length, ' ');
+  return true;
+}
+
+bool EditDefaultCharacterInput(
+    IoStatementState &io, const DataEdit &edit, char *x, std::size_t length) {
+  switch (edit.descriptor) {
+  case DataEdit::ListDirected:
+    return EditListDirectedDefaultCharacterInput(io, x, length);
+  case 'A':
+  case 'G': break;
+  default:
+    io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
+        "Data edit descriptor '%c' may not be used with a CHARACTER data item",
+        edit.descriptor);
+    return false;
+  }
+  std::optional<int> remaining{length};
+  if (edit.width && *edit.width > 0) {
+    remaining = *edit.width;
+  }
+  // When the field is wider than the variable, we drop the leading
+  // characters.  When the variable is wider than the field, there's
+  // trailing padding.
+  std::int64_t skip{*remaining - static_cast<std::int64_t>(length)};
+  for (std::optional<char32_t> next{io.NextInField(remaining)}; next;
+       next = io.NextInField(remaining)) {
+    if (skip > 0) {
+      --skip;
+    } else {
+      *x++ = *next;
+      --length;
+    }
+  }
+  std::fill_n(x, length, ' ');
+  return true;
+}
+
+template bool EditRealInput<8>(IoStatementState &, const DataEdit &, void *);
+template bool EditRealInput<11>(IoStatementState &, const DataEdit &, void *);
+template bool EditRealInput<24>(IoStatementState &, const DataEdit &, void *);
+template bool EditRealInput<53>(IoStatementState &, const DataEdit &, void *);
+template bool EditRealInput<64>(IoStatementState &, const DataEdit &, void *);
+template bool EditRealInput<113>(IoStatementState &, const DataEdit &, void *);
+}
diff --git a/runtime/edit-input.h b/runtime/edit-input.h
new file mode 100644
index 000000000000..b62d81804dd6
--- /dev/null
+++ b/runtime/edit-input.h
@@ -0,0 +1,40 @@
+//===-- runtime/edit-input.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_RUNTIME_EDIT_INPUT_H_
+#define FORTRAN_RUNTIME_EDIT_INPUT_H_
+
+#include "format.h"
+#include "io-stmt.h"
+#include "flang/Decimal/decimal.h"
+
+namespace Fortran::runtime::io {
+
+bool EditIntegerInput(IoStatementState &, const DataEdit &, void *, int kind);
+
+template<int binaryPrecision>
+bool EditRealInput(IoStatementState &, const DataEdit &, void *);
+
+bool EditLogicalInput(IoStatementState &, const DataEdit &, bool &);
+bool EditDefaultCharacterInput(
+    IoStatementState &, const DataEdit &, char *, std::size_t);
+
+extern template bool EditRealInput<8>(
+    IoStatementState &, const DataEdit &, void *);
+extern template bool EditRealInput<11>(
+    IoStatementState &, const DataEdit &, void *);
+extern template bool EditRealInput<24>(
+    IoStatementState &, const DataEdit &, void *);
+extern template bool EditRealInput<53>(
+    IoStatementState &, const DataEdit &, void *);
+extern template bool EditRealInput<64>(
+    IoStatementState &, const DataEdit &, void *);
+extern template bool EditRealInput<113>(
+    IoStatementState &, const DataEdit &, void *);
+}
+#endif  // FORTRAN_RUNTIME_EDIT_INPUT_H_
diff --git a/runtime/numeric-output.h b/runtime/edit-output.cpp
similarity index 56%
rename from runtime/numeric-output.h
rename to runtime/edit-output.cpp
index c3826ffdf563..47e3b2918788 100644
--- a/runtime/numeric-output.h
+++ b/runtime/edit-output.cpp
@@ -1,4 +1,4 @@
-//===-- runtime/numeric-output.h --------------------------------*- C++ -*-===//
+//===-- runtime/edit-output.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.
@@ -6,86 +6,155 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_RUNTIME_NUMERIC_OUTPUT_H_
-#define FORTRAN_RUNTIME_NUMERIC_OUTPUT_H_
-
-// Output data editing templates implementing the FORMAT data editing
-// descriptors E, EN, ES, EX, D, F, and G for REAL data (and COMPLEX
-// components, I and G for INTEGER, and B/O/Z for both.
-// See subclauses in 13.7.2.3 of Fortran 2018 for the
-// detailed specifications of these descriptors.
-// List-directed output (13.10.4) for numeric types is also done here.
-// Drives the same fast binary-to-decimal formatting templates used
-// in the f18 front-end.
-
-#include "format.h"
-#include "io-stmt.h"
-#include "flang/Decimal/decimal.h"
+#include "edit-output.h"
+#include "flang/Common/uint128.h"
+#include "flang/Common/unsigned-const-division.h"
 
 namespace Fortran::runtime::io {
 
-class IoStatementState;
-
-// I, B, O, Z, and G output editing for INTEGER.
-// edit is const here (and elsewhere in this header) so that one
-// edit descriptor with a repeat factor may safely serve to edit
-// multiple elements of an array.
-bool EditIntegerOutput(IoStatementState &, const DataEdit &, std::int64_t);
-
-// Encapsulates the state of a REAL output conversion.
-class RealOutputEditingBase {
-protected:
-  explicit RealOutputEditingBase(IoStatementState &io) : io_{io} {}
-
-  static bool IsDecimalNumber(const char *p) {
-    if (!p) {
-      return false;
+template<typename INT, typename UINT>
+bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, INT n) {
+  char buffer[130], *end = &buffer[sizeof buffer], *p = end;
+  bool isNegative{false};
+  if constexpr (std::is_same_v<INT, UINT>) {
+    isNegative = (n >> (8 * sizeof(INT) - 1)) != 0;
+  } else {
+    isNegative = n < 0;
+  }
+  UINT un{static_cast<UINT>(isNegative ? -n : n)};
+  int signChars{0};
+  switch (edit.descriptor) {
+  case DataEdit::ListDirected:
+  case 'G':
+  case 'I':
+    if (isNegative || (edit.modes.editingFlags & signPlus)) {
+      signChars = 1;  // '-' or '+'
     }
-    if (*p == '-' || *p == '+') {
-      ++p;
+    while (un > 0) {
+      auto quotient{common::DivideUnsignedBy<UINT, 10>(un)};
+      *--p = '0' + static_cast<int>(un - UINT{10} * quotient);
+      un = quotient;
     }
-    return *p >= '0' && *p <= '9';
+    break;
+  case 'B':
+    for (; un > 0; un >>= 1) {
+      *--p = '0' + (static_cast<int>(un) & 1);
+    }
+    break;
+  case 'O':
+    for (; un > 0; un >>= 3) {
+      *--p = '0' + (static_cast<int>(un) & 7);
+    }
+    break;
+  case 'Z':
+    for (; un > 0; un >>= 4) {
+      int digit = static_cast<int>(un) & 0xf;
+      *--p = digit >= 10 ? 'A' + (digit - 10) : '0' + digit;
+    }
+    break;
+  default:
+    io.GetIoErrorHandler().Crash(
+        "Data edit descriptor '%c' may not be used with an INTEGER data item",
+        edit.descriptor);
+    return false;
   }
 
-  const char *FormatExponent(int, const DataEdit &edit, int &length);
-  bool EmitPrefix(const DataEdit &, std::size_t length, std::size_t width);
-  bool EmitSuffix(const DataEdit &);
-
-  IoStatementState &io_;
-  int trailingBlanks_{0};  // created when Gw editing maps to Fw
-  char exponent_[16];
-};
-
-template<int binaryPrecision = 53>
-class RealOutputEditing : public RealOutputEditingBase {
-public:
-  template<typename A>
-  RealOutputEditing(IoStatementState &io, A x)
-    : RealOutputEditingBase{io}, x_{x} {}
-  bool Edit(const DataEdit &);
-
-private:
-  using BinaryFloatingPoint =
-      decimal::BinaryFloatingPointNumber<binaryPrecision>;
-
-  // The DataEdit arguments here are const references or copies so that
-  // the original DataEdit can safely serve multiple array elements when
-  // it has a repeat count.
-  bool EditEorDOutput(const DataEdit &);
-  bool EditFOutput(const DataEdit &);
-  DataEdit EditForGOutput(DataEdit);  // returns an E or F edit
-  bool EditEXOutput(const DataEdit &);
-  bool EditListDirectedOutput(const DataEdit &);
+  int digits = end - p;
+  int leadingZeroes{0};
+  int editWidth{edit.width.value_or(0)};
+  if (edit.digits && digits <= *edit.digits) {  // Iw.m
+    if (*edit.digits == 0 && n == 0) {
+      // Iw.0 with zero value: output field must be blank.  For I0.0
+      // and a zero value, emit one blank character.
+      signChars = 0;  // in case of SP
+      editWidth = std::max(1, editWidth);
+    } else {
+      leadingZeroes = *edit.digits - digits;
+    }
+  } else if (n == 0) {
+    leadingZeroes = 1;
+  }
+  int total{signChars + leadingZeroes + digits};
+  if (editWidth > 0 && total > editWidth) {
+    return io.EmitRepeated('*', editWidth);
+  }
+  int leadingSpaces{std::max(0, editWidth - total)};
+  if (edit.IsListDirected()) {
+    if (static_cast<std::size_t>(total) >
+            io.GetConnectionState().RemainingSpaceInRecord() &&
+        !io.AdvanceRecord()) {
+      return false;
+    }
+    leadingSpaces = 1;
+  }
+  return io.EmitRepeated(' ', leadingSpaces) &&
+      io.Emit(n < 0 ? "-" : "+", signChars) &&
+      io.EmitRepeated('0', leadingZeroes) && io.Emit(p, digits);
+}
 
-  bool IsZero() const { return x_.IsZero(); }
+// Formats the exponent (see table 13.1 for all the cases)
+const char *RealOutputEditingBase::FormatExponent(
+    int expo, const DataEdit &edit, int &length) {
+  char *eEnd{&exponent_[sizeof exponent_]};
+  char *exponent{eEnd};
+  for (unsigned e{static_cast<unsigned>(std::abs(expo))}; e > 0;) {
+    unsigned quotient{common::DivideUnsignedBy<unsigned, 10>(e)};
+    *--exponent = '0' + e - 10 * quotient;
+    e = quotient;
+  }
+  if (edit.expoDigits) {
+    if (int ed{*edit.expoDigits}) {  // Ew.dEe with e > 0
+      while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
+        *--exponent = '0';
+      }
+    } else if (exponent == eEnd) {
+      *--exponent = '0';  // Ew.dE0 with zero-valued exponent
+    }
+  } else {  // ensure at least two exponent digits
+    while (exponent + 2 > eEnd) {
+      *--exponent = '0';
+    }
+  }
+  *--exponent = expo < 0 ? '-' : '+';
+  if (edit.expoDigits || exponent + 3 == eEnd) {
+    *--exponent = edit.descriptor == 'D' ? 'D' : 'E';  // not 'G'
+  }
+  length = eEnd - exponent;
+  return exponent;
+}
 
-  decimal::ConversionToDecimalResult Convert(
-      int significantDigits, const DataEdit &, int flags = 0);
+bool RealOutputEditingBase::EmitPrefix(
+    const DataEdit &edit, std::size_t length, std::size_t width) {
+  if (edit.IsListDirected()) {
+    int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart
+            ? 2
+            : edit.descriptor == DataEdit::ListDirectedImaginaryPart ? 0 : 1};
+    int suffixLength{edit.descriptor == DataEdit::ListDirectedRealPart ||
+                edit.descriptor == DataEdit::ListDirectedImaginaryPart
+            ? 1
+            : 0};
+    length += prefixLength + suffixLength;
+    ConnectionState &connection{io_.GetConnectionState()};
+    return (connection.positionInRecord == 0 ||
+               length <= connection.RemainingSpaceInRecord() ||
+               io_.AdvanceRecord()) &&
+        io_.Emit(" (", prefixLength);
+  } else if (width > length) {
+    return io_.EmitRepeated(' ', width - length);
+  } else {
+    return true;
+  }
+}
 
-  BinaryFloatingPoint x_;
-  char buffer_[BinaryFloatingPoint::maxDecimalConversionDigits +
-      EXTRA_DECIMAL_CONVERSION_SPACE];
-};
+bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) {
+  if (edit.descriptor == DataEdit::ListDirectedRealPart) {
+    return io_.Emit(edit.modes.editingFlags & decimalComma ? ";" : ",", 1);
+  } else if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) {
+    return io_.Emit(")", 1);
+  } else {
+    return true;
+  }
+}
 
 template<int binaryPrecision>
 decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
@@ -331,7 +400,7 @@ bool RealOutputEditing<binaryPrecision>::Edit(const DataEdit &edit) {
     if (edit.IsListDirected()) {
       return EditListDirectedOutput(edit);
     }
-    io_.GetIoErrorHandler().Crash(
+    io_.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a REAL data item",
         edit.descriptor);
     return false;
@@ -339,5 +408,88 @@ bool RealOutputEditing<binaryPrecision>::Edit(const DataEdit &edit) {
   return false;
 }
 
+bool ListDirectedLogicalOutput(IoStatementState &io,
+    ListDirectedStatementState<Direction::Output> &list, bool truth) {
+  return list.EmitLeadingSpaceOrAdvance(io, 1) && io.Emit(truth ? "T" : "F", 1);
+}
+
+bool EditLogicalOutput(IoStatementState &io, const DataEdit &edit, bool truth) {
+  switch (edit.descriptor) {
+  case 'L':
+  case 'G': return io.Emit(truth ? "T" : "F", 1);
+  default:
+    io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
+        "Data edit descriptor '%c' may not be used with a LOGICAL data item",
+        edit.descriptor);
+    return false;
+  }
+}
+
+bool ListDirectedDefaultCharacterOutput(IoStatementState &io,
+    ListDirectedStatementState<Direction::Output> &list, const char *x,
+    std::size_t length) {
+  bool ok{list.EmitLeadingSpaceOrAdvance(io, length, true)};
+  MutableModes &modes{io.mutableModes()};
+  ConnectionState &connection{io.GetConnectionState()};
+  if (modes.delim) {
+    // Value is delimited with ' or " marks, and interior
+    // instances of that character are doubled.  When split
+    // over multiple lines, delimit each lines' part.
+    ok &= io.Emit(&modes.delim, 1);
+    for (std::size_t j{0}; j < length; ++j) {
+      if (list.NeedAdvance(connection, 2)) {
+        ok &= io.Emit(&modes.delim, 1) && io.AdvanceRecord() &&
+            io.Emit(&modes.delim, 1);
+      }
+      if (x[j] == modes.delim) {
+        ok &= io.EmitRepeated(modes.delim, 2);
+      } else {
+        ok &= io.Emit(&x[j], 1);
+      }
+    }
+    ok &= io.Emit(&modes.delim, 1);
+  } else {
+    // Undelimited list-directed output
+    std::size_t put{0};
+    while (put < length) {
+      auto chunk{std::min(length - put, connection.RemainingSpaceInRecord())};
+      ok &= io.Emit(x + put, chunk);
+      put += chunk;
+      if (put < length) {
+        ok &= io.AdvanceRecord() && io.Emit(" ", 1);
+      }
+    }
+    list.lastWasUndelimitedCharacter = true;
+  }
+  return ok;
+}
+
+bool EditDefaultCharacterOutput(IoStatementState &io, const DataEdit &edit,
+    const char *x, std::size_t length) {
+  switch (edit.descriptor) {
+  case 'A':
+  case 'G': break;
+  default:
+    io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
+        "Data edit descriptor '%c' may not be used with a CHARACTER data item",
+        edit.descriptor);
+    return false;
+  }
+  int len{static_cast<int>(length)};
+  int width{edit.width.value_or(len)};
+  return io.EmitRepeated(' ', std::max(0, width - len)) &&
+      io.Emit(x, std::min(width, len));
+}
+
+template bool EditIntegerOutput<std::int64_t, std::uint64_t>(
+    IoStatementState &, const DataEdit &, std::int64_t);
+template bool EditIntegerOutput<common::uint128_t, common::uint128_t>(
+    IoStatementState &, const DataEdit &, common::uint128_t);
+
+template class RealOutputEditing<8>;
+template class RealOutputEditing<11>;
+template class RealOutputEditing<24>;
+template class RealOutputEditing<53>;
+template class RealOutputEditing<64>;
+template class RealOutputEditing<113>;
 }
-#endif  // FORTRAN_RUNTIME_NUMERIC_OUTPUT_H_
diff --git a/runtime/edit-output.h b/runtime/edit-output.h
new file mode 100644
index 000000000000..559491b584c1
--- /dev/null
+++ b/runtime/edit-output.h
@@ -0,0 +1,111 @@
+//===-- runtime/edit-output.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_RUNTIME_EDIT_OUTPUT_H_
+#define FORTRAN_RUNTIME_EDIT_OUTPUT_H_
+
+// Output data editing templates implementing the FORMAT data editing
+// descriptors E, EN, ES, EX, D, F, and G for REAL data (and COMPLEX
+// components, I and G for INTEGER, and B/O/Z for both.
+// See subclauses in 13.7.2.3 of Fortran 2018 for the
+// detailed specifications of these descriptors.
+// List-directed output (13.10.4) for numeric types is also done here.
+// Drives the same fast binary-to-decimal formatting templates used
+// in the f18 front-end.
+
+#include "format.h"
+#include "io-stmt.h"
+#include "flang/Common/uint128.h"
+#include "flang/Decimal/decimal.h"
+
+namespace Fortran::runtime::io {
+
+// I, B, O, Z, and G output editing for INTEGER.
+// The DataEdit reference is const here (and elsewhere in this header) so that
+// one edit descriptor with a repeat factor may safely serve to edit
+// multiple elements of an array.
+template<typename INT = std::int64_t, typename UINT = std::uint64_t>
+bool EditIntegerOutput(IoStatementState &, const DataEdit &, INT);
+
+// Encapsulates the state of a REAL output conversion.
+class RealOutputEditingBase {
+protected:
+  explicit RealOutputEditingBase(IoStatementState &io) : io_{io} {}
+
+  static bool IsDecimalNumber(const char *p) {
+    if (!p) {
+      return false;
+    }
+    if (*p == '-' || *p == '+') {
+      ++p;
+    }
+    return *p >= '0' && *p <= '9';
+  }
+
+  const char *FormatExponent(int, const DataEdit &edit, int &length);
+  bool EmitPrefix(const DataEdit &, std::size_t length, std::size_t width);
+  bool EmitSuffix(const DataEdit &);
+
+  IoStatementState &io_;
+  int trailingBlanks_{0};  // created when Gw editing maps to Fw
+  char exponent_[16];
+};
+
+template<int binaryPrecision = 53>
+class RealOutputEditing : public RealOutputEditingBase {
+public:
+  template<typename A>
+  RealOutputEditing(IoStatementState &io, A x)
+    : RealOutputEditingBase{io}, x_{x} {}
+  bool Edit(const DataEdit &);
+
+private:
+  using BinaryFloatingPoint =
+      decimal::BinaryFloatingPointNumber<binaryPrecision>;
+
+  // The DataEdit arguments here are const references or copies so that
+  // the original DataEdit can safely serve multiple array elements when
+  // it has a repeat count.
+  bool EditEorDOutput(const DataEdit &);
+  bool EditFOutput(const DataEdit &);
+  DataEdit EditForGOutput(DataEdit);  // returns an E or F edit
+  bool EditEXOutput(const DataEdit &);
+  bool EditListDirectedOutput(const DataEdit &);
+
+  bool IsZero() const { return x_.IsZero(); }
+
+  decimal::ConversionToDecimalResult Convert(
+      int significantDigits, const DataEdit &, int flags = 0);
+
+  BinaryFloatingPoint x_;
+  char buffer_[BinaryFloatingPoint::maxDecimalConversionDigits +
+      EXTRA_DECIMAL_CONVERSION_SPACE];
+};
+
+bool ListDirectedLogicalOutput(
+    IoStatementState &, ListDirectedStatementState<Direction::Output> &, bool);
+bool EditLogicalOutput(IoStatementState &, const DataEdit &, bool);
+bool ListDirectedDefaultCharacterOutput(IoStatementState &,
+    ListDirectedStatementState<Direction::Output> &, const char *, std::size_t);
+bool EditDefaultCharacterOutput(
+    IoStatementState &, const DataEdit &, const char *, std::size_t);
+
+extern template bool EditIntegerOutput<std::int64_t, std::uint64_t>(
+    IoStatementState &, const DataEdit &, std::int64_t);
+extern template bool EditIntegerOutput<common::uint128_t, common::uint128_t>(
+    IoStatementState &, const DataEdit &, common::uint128_t);
+
+extern template class RealOutputEditing<8>;
+extern template class RealOutputEditing<11>;
+extern template class RealOutputEditing<24>;
+extern template class RealOutputEditing<53>;
+extern template class RealOutputEditing<64>;
+extern template class RealOutputEditing<113>;
+
+}
+#endif  // FORTRAN_RUNTIME_EDIT_OUTPUT_H_
diff --git a/runtime/file.cpp b/runtime/file.cpp
index 9ee4ae3c4318..31b4246ee03d 100644
--- a/runtime/file.cpp
+++ b/runtime/file.cpp
@@ -34,7 +34,7 @@ void OpenFile::Open(
   case OpenStatus::New: flags |= O_CREAT | O_EXCL; break;
   case OpenStatus::Scratch:
     if (path_.get()) {
-      handler.Crash("FILE= must not appear with STATUS='SCRATCH'");
+      handler.SignalError("FILE= must not appear with STATUS='SCRATCH'");
       path_.reset();
     }
     {
@@ -54,7 +54,8 @@ void OpenFile::Open(
     flags |= O_CREAT;
     break;
   }
-  // If we reach this point, we're opening a new file
+  // If we reach this point, we're opening a new file.
+  // TODO: Fortran shouldn't create a new file until the first WRITE.
   if (fd_ >= 0) {
     if (fd_ <= 2) {
       // don't actually close a standard file descriptor, we might need it
@@ -63,8 +64,9 @@ void OpenFile::Open(
     }
   }
   if (!path_.get()) {
-    handler.Crash(
+    handler.SignalError(
         "FILE= is required unless STATUS='OLD' and unit is connected");
+    return;
   }
   fd_ = ::open(path_.get(), flags, 0600);
   if (fd_ < 0) {
@@ -79,7 +81,6 @@ void OpenFile::Open(
 }
 
 void OpenFile::Predefine(int fd) {
-  CriticalSection criticalSection{lock_};
   fd_ = fd;
   path_.reset();
   pathLength_ = 0;
@@ -90,7 +91,6 @@ void OpenFile::Predefine(int fd) {
 }
 
 void OpenFile::Close(CloseStatus status, IoErrorHandler &handler) {
-  CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   pending_.reset();
   knownSize_.reset();
@@ -116,7 +116,6 @@ std::size_t OpenFile::Read(FileOffset at, char *buffer, std::size_t minBytes,
   if (maxBytes == 0) {
     return 0;
   }
-  CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   if (!Seek(at, handler)) {
     return 0;
@@ -150,7 +149,6 @@ std::size_t OpenFile::Write(FileOffset at, const char *buffer,
   if (bytes == 0) {
     return 0;
   }
-  CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   if (!Seek(at, handler)) {
     return 0;
@@ -176,7 +174,6 @@ std::size_t OpenFile::Write(FileOffset at, const char *buffer,
 }
 
 void OpenFile::Truncate(FileOffset at, IoErrorHandler &handler) {
-  CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   if (!knownSize_ || *knownSize_ != at) {
     if (::ftruncate(fd_, at) != 0) {
@@ -191,7 +188,6 @@ void OpenFile::Truncate(FileOffset at, IoErrorHandler &handler) {
 // TODO: True asynchronicity
 int OpenFile::ReadAsynchronously(
     FileOffset at, char *buffer, std::size_t bytes, IoErrorHandler &handler) {
-  CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   int iostat{0};
   for (std::size_t got{0}; got < bytes;) {
@@ -221,7 +217,6 @@ int OpenFile::ReadAsynchronously(
 // TODO: True asynchronicity
 int OpenFile::WriteAsynchronously(FileOffset at, const char *buffer,
     std::size_t bytes, IoErrorHandler &handler) {
-  CriticalSection criticalSection{lock_};
   CheckOpen(handler);
   int iostat{0};
   for (std::size_t put{0}; put < bytes;) {
@@ -247,19 +242,16 @@ int OpenFile::WriteAsynchronously(FileOffset at, const char *buffer,
 
 void OpenFile::Wait(int id, IoErrorHandler &handler) {
   std::optional<int> ioStat;
-  {
-    CriticalSection criticalSection{lock_};
-    Pending *prev{nullptr};
-    for (Pending *p{pending_.get()}; p; p = (prev = p)->next.get()) {
-      if (p->id == id) {
-        ioStat = p->ioStat;
-        if (prev) {
-          prev->next.reset(p->next.release());
-        } else {
-          pending_.reset(p->next.release());
-        }
-        break;
+  Pending *prev{nullptr};
+  for (Pending *p{pending_.get()}; p; p = (prev = p)->next.get()) {
+    if (p->id == id) {
+      ioStat = p->ioStat;
+      if (prev) {
+        prev->next.reset(p->next.release());
+      } else {
+        pending_.reset(p->next.release());
       }
+      break;
     }
   }
   if (ioStat) {
@@ -270,14 +262,11 @@ void OpenFile::Wait(int id, IoErrorHandler &handler) {
 void OpenFile::WaitAll(IoErrorHandler &handler) {
   while (true) {
     int ioStat;
-    {
-      CriticalSection criticalSection{lock_};
-      if (pending_) {
-        ioStat = pending_->ioStat;
-        pending_.reset(pending_->next.release());
-      } else {
-        return;
-      }
+    if (pending_) {
+      ioStat = pending_->ioStat;
+      pending_.reset(pending_->next.release());
+    } else {
+      return;
     }
     handler.SignalError(ioStat);
   }
diff --git a/runtime/file.h b/runtime/file.h
index 9ed1c250364a..c74da330bb7d 100644
--- a/runtime/file.h
+++ b/runtime/file.h
@@ -12,7 +12,6 @@
 #define FORTRAN_RUNTIME_FILE_H_
 
 #include "io-error.h"
-#include "lock.h"
 #include "memory.h"
 #include <cinttypes>
 #include <optional>
@@ -27,7 +26,6 @@ class OpenFile {
 public:
   using FileOffset = std::int64_t;
 
-  Lock &lock() { return lock_; }
   const char *path() const { return path_.get(); }
   void set_path(OwningPtr<char> &&, std::size_t bytes);
   std::size_t pathLength() const { return pathLength_; }
@@ -76,14 +74,12 @@ class OpenFile {
     OwningPtr<Pending> next;
   };
 
-  // lock_ must be held for these
   void CheckOpen(const Terminator &);
   bool Seek(FileOffset, IoErrorHandler &);
   bool RawSeek(FileOffset);
   bool RawSeekToEnd();
   int PendingResult(const Terminator &, int);
 
-  Lock lock_;
   int fd_{-1};
   OwningPtr<char> path_;
   std::size_t pathLength_;
diff --git a/runtime/format-implementation.h b/runtime/format-implementation.h
index e066ba04debc..43efd6e1f130 100644
--- a/runtime/format-implementation.h
+++ b/runtime/format-implementation.h
@@ -25,39 +25,69 @@ FormatControl<CONTEXT>::FormatControl(const Terminator &terminator,
     const CharType *format, std::size_t formatLength, int maxHeight)
   : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
     formatLength_{static_cast<int>(formatLength)} {
-  if (maxHeight != maxHeight_) {
-    terminator.Crash("internal Fortran runtime error: maxHeight %d", maxHeight);
-  }
-  if (formatLength != static_cast<std::size_t>(formatLength_)) {
-    terminator.Crash(
-        "internal Fortran runtime error: formatLength %zd", formatLength);
-  }
+  RUNTIME_CHECK(terminator, maxHeight == maxHeight_);
+  RUNTIME_CHECK(
+      terminator, formatLength == static_cast<std::size_t>(formatLength_));
   stack_[0].start = offset_;
   stack_[0].remaining = Iteration::unlimited;  // 13.4(8)
 }
 
 template<typename CONTEXT>
 int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
-    const Terminator &terminator, const CharType *format,
-    std::size_t formatLength) {
-  using Validator = common::FormatValidator<CharType>;
-  typename Validator::Reporter reporter{
-      [&](const common::FormatMessage &message) {
-        terminator.Crash(message.text, message.arg);
-        return false;  // crashes on error above
-      }};
-  Validator validator{format, formatLength, reporter};
-  validator.Check();
-  return validator.maxNesting();
+    IoErrorHandler &handler, const CharType *format, std::size_t formatLength) {
+  int maxNesting{0};
+  int nesting{0};
+  const CharType *end{format + formatLength};
+  std::optional<CharType> quote;
+  int repeat{0};
+  for (const CharType *p{format}; p < end; ++p) {
+    if (quote) {
+      if (*p == *quote) {
+        quote.reset();
+      }
+    } else if (*p >= '0' && *p <= '9') {
+      repeat = 10 * repeat + *p - '0';
+    } else if (*p != ' ') {
+      switch (*p) {
+      case '\'':
+      case '"': quote = *p; break;
+      case 'h':
+      case 'H':  // 9HHOLLERITH
+        p += repeat;
+        if (p >= end) {
+          handler.SignalError(IostatErrorInFormat,
+              "Hollerith (%dH) too long in FORMAT", repeat);
+          return maxNesting;
+        }
+        break;
+      case ' ': break;
+      case '(':
+        ++nesting;
+        maxNesting = std::max(nesting, maxNesting);
+        break;
+      case ')': nesting = std::max(nesting - 1, 0); break;
+      }
+      repeat = 0;
+    }
+  }
+  if (quote) {
+    handler.SignalError(
+        IostatErrorInFormat, "Unbalanced quotation marks in FORMAT string");
+  } else if (nesting) {
+    handler.SignalError(
+        IostatErrorInFormat, "Unbalanced parentheses in FORMAT string");
+  }
+  return maxNesting;
 }
 
 template<typename CONTEXT>
 int FormatControl<CONTEXT>::GetIntField(
-    const Terminator &terminator, CharType firstCh) {
+    IoErrorHandler &handler, CharType firstCh) {
   CharType ch{firstCh ? firstCh : PeekNext()};
   if (ch != '-' && ch != '+' && (ch < '0' || ch > '9')) {
-    terminator.Crash(
+    handler.SignalError(IostatErrorInFormat,
         "Invalid FORMAT: integer expected at '%c'", static_cast<char>(ch));
+    return 0;
   }
   int result{0};
   bool negate{ch == '-'};
@@ -68,7 +98,9 @@ int FormatControl<CONTEXT>::GetIntField(
   while (ch >= '0' && ch <= '9') {
     if (result >
         std::numeric_limits<int>::max() / 10 - (static_cast<int>(ch) - '0')) {
-      terminator.Crash("FORMAT integer field out of range");
+      handler.SignalError(
+          IostatErrorInFormat, "FORMAT integer field out of range");
+      return result;
     }
     result = 10 * result + ch - '0';
     if (firstCh) {
@@ -79,7 +111,8 @@ int FormatControl<CONTEXT>::GetIntField(
     ch = PeekNext();
   }
   if (negate && (result *= -1) > 0) {
-    terminator.Crash("FORMAT integer field out of range");
+    handler.SignalError(
+        IostatErrorInFormat, "FORMAT integer field out of range");
   }
   return result;
 }
@@ -156,9 +189,11 @@ static void HandleControl(CONTEXT &context, char ch, char next, int n) {
   default: break;
   }
   if (next) {
-    context.Crash("Unknown '%c%c' edit descriptor in FORMAT", ch, next);
+    context.SignalError(IostatErrorInFormat,
+        "Unknown '%c%c' edit descriptor in FORMAT", ch, next);
   } else {
-    context.Crash("Unknown '%c' edit descriptor in FORMAT", ch);
+    context.SignalError(
+        IostatErrorInFormat, "Unknown '%c' edit descriptor in FORMAT", ch);
   }
 }
 
@@ -188,12 +223,16 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
       unlimited = true;
       ch = GetNextChar(context);
       if (ch != '(') {
-        context.Crash("Invalid FORMAT: '*' may appear only before '('");
+        context.SignalError(IostatErrorInFormat,
+            "Invalid FORMAT: '*' may appear only before '('");
+        return 0;
       }
     }
     if (ch == '(') {
       if (height_ >= maxHeight_) {
-        context.Crash("FORMAT stack overflow: too many nested parentheses");
+        context.SignalError(IostatErrorInFormat,
+            "FORMAT stack overflow: too many nested parentheses");
+        return 0;
       }
       stack_[height_].start = offset_ - 1;  // the '('
       if (unlimited || height_ == 0) {
@@ -209,7 +248,8 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
       }
       ++height_;
     } else if (height_ == 0) {
-      context.Crash("FORMAT lacks initial '('");
+      context.SignalError(IostatErrorInFormat, "FORMAT lacks initial '('");
+      return 0;
     } else if (ch == ')') {
       if (height_ == 1) {
         if (stop) {
@@ -220,7 +260,7 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
       if (stack_[height_ - 1].remaining == Iteration::unlimited) {
         offset_ = stack_[height_ - 1].start + 1;
         if (offset_ == unlimitedLoopCheck) {
-          context.Crash(
+          context.SignalError(IostatErrorInFormat,
               "Unlimited repetition in FORMAT lacks data edit descriptors");
         }
       } else if (stack_[height_ - 1].remaining-- > 0) {
@@ -236,7 +276,9 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
         ++offset_;
       }
       if (offset_ >= formatLength_) {
-        context.Crash("FORMAT missing closing quote on character literal");
+        context.SignalError(IostatErrorInFormat,
+            "FORMAT missing closing quote on character literal");
+        return 0;
       }
       ++offset_;
       std::size_t chars{
@@ -252,7 +294,9 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
     } else if (ch == 'H') {
       // 9HHOLLERITH
       if (!repeat || *repeat < 1 || offset_ + *repeat > formatLength_) {
-        context.Crash("Invalid width on Hollerith in FORMAT");
+        context.SignalError(
+            IostatErrorInFormat, "Invalid width on Hollerith in FORMAT");
+        return 0;
       }
       context.Emit(format_ + offset_, static_cast<std::size_t>(*repeat));
       offset_ += *repeat;
@@ -282,7 +326,9 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
     } else if (ch == '/') {
       context.AdvanceRecord(repeat && *repeat > 0 ? *repeat : 1);
     } else {
-      context.Crash("Invalid character '%c' in FORMAT", static_cast<char>(ch));
+      context.SignalError(IostatErrorInFormat,
+          "Invalid character '%c' in FORMAT", static_cast<char>(ch));
+      return 0;
     }
   }
 }
@@ -348,7 +394,7 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
 }
 
 template<typename CONTEXT>
-void FormatControl<CONTEXT>::FinishOutput(Context &context) {
+void FormatControl<CONTEXT>::Finish(Context &context) {
   CueUpNextDataEdit(context, true /* stop at colon or end of FORMAT */);
 }
 }
diff --git a/runtime/format.cpp b/runtime/format.cpp
index 91a6b6749514..6702ab97fe69 100644
--- a/runtime/format.cpp
+++ b/runtime/format.cpp
@@ -30,24 +30,34 @@ bool DefaultFormatControlCallbacks::Emit(const char32_t *, std::size_t) {
         "I/O statement");
   return {};
 }
+std::optional<char32_t> DefaultFormatControlCallbacks::GetCurrentChar() {
+  Crash("DefaultFormatControlCallbacks::GetCurrentChar() called for non-input "
+        "I/O "
+        "statement");
+  return {};
+}
 bool DefaultFormatControlCallbacks::AdvanceRecord(int) {
   Crash("DefaultFormatControlCallbacks::AdvanceRecord() called unexpectedly");
   return {};
 }
-bool DefaultFormatControlCallbacks::HandleAbsolutePosition(std::int64_t) {
+void DefaultFormatControlCallbacks::BackspaceRecord() {
+  Crash("DefaultFormatControlCallbacks::BackspaceRecord() called unexpectedly");
+}
+void DefaultFormatControlCallbacks::HandleAbsolutePosition(std::int64_t) {
   Crash("DefaultFormatControlCallbacks::HandleAbsolutePosition() called for "
-        "non-formatted "
-        "I/O statement");
-  return {};
+        "non-formatted I/O statement");
 }
-bool DefaultFormatControlCallbacks::HandleRelativePosition(std::int64_t) {
+void DefaultFormatControlCallbacks::HandleRelativePosition(std::int64_t) {
   Crash("DefaultFormatControlCallbacks::HandleRelativePosition() called for "
-        "non-formatted "
-        "I/O statement");
-  return {};
+        "non-formatted I/O statement");
 }
 
-template class FormatControl<InternalFormattedIoStatementState<false>>;
-template class FormatControl<InternalFormattedIoStatementState<true>>;
-template class FormatControl<ExternalFormattedIoStatementState<false>>;
+template class FormatControl<
+    InternalFormattedIoStatementState<Direction::Output>>;
+template class FormatControl<
+    InternalFormattedIoStatementState<Direction::Input>>;
+template class FormatControl<
+    ExternalFormattedIoStatementState<Direction::Output>>;
+template class FormatControl<
+    ExternalFormattedIoStatementState<Direction::Input>>;
 }
diff --git a/runtime/format.h b/runtime/format.h
index a4899f829ea5..4875b44f08bb 100644
--- a/runtime/format.h
+++ b/runtime/format.h
@@ -13,7 +13,6 @@
 
 #include "environment.h"
 #include "io-error.h"
-#include "terminator.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Decimal/decimal.h"
 #include <cinttypes>
@@ -41,10 +40,11 @@ struct MutableModes {
 struct DataEdit {
   char descriptor;  // capitalized: one of A, I, B, O, Z, F, E(N/S/X), D, G
 
-  // Special internal data edit descriptors to distinguish list-directed I/O
+  // Special internal data edit descriptors for list-directed I/O
   static constexpr char ListDirected{'g'};  // non-COMPLEX list-directed
   static constexpr char ListDirectedRealPart{'r'};  // emit "(r," or "(r;"
   static constexpr char ListDirectedImaginaryPart{'z'};  // emit "z)"
+  static constexpr char ListDirectedNullValue{'n'};  // see 13.10.3.2
   constexpr bool IsListDirected() const {
     return descriptor == ListDirected || descriptor == ListDirectedRealPart ||
         descriptor == ListDirectedImaginaryPart;
@@ -66,9 +66,11 @@ struct DefaultFormatControlCallbacks : public IoErrorHandler {
   bool Emit(const char *, std::size_t);
   bool Emit(const char16_t *, std::size_t);
   bool Emit(const char32_t *, std::size_t);
+  std::optional<char32_t> GetCurrentChar();
   bool AdvanceRecord(int = 1);
-  bool HandleAbsolutePosition(std::int64_t);
-  bool HandleRelativePosition(std::int64_t);
+  void BackspaceRecord();
+  void HandleAbsolutePosition(std::int64_t);
+  void HandleRelativePosition(std::int64_t);
 };
 
 // Generates a sequence of DataEdits from a FORMAT statement or
@@ -86,7 +88,7 @@ template<typename CONTEXT> class FormatControl {
   // Determines the max parenthesis nesting level by scanning and validating
   // the FORMAT string.
   static int GetMaxParenthesisNesting(
-      const Terminator &, const CharType *format, std::size_t formatLength);
+      IoErrorHandler &, const CharType *format, std::size_t formatLength);
 
   // For attempting to allocate in a user-supplied stack area
   static std::size_t GetNeededSize(int maxHeight) {
@@ -98,8 +100,9 @@ template<typename CONTEXT> class FormatControl {
   // along the way.
   DataEdit GetNextDataEdit(Context &, int maxRepeat = 1);
 
-  // Emit any remaining character literals after the last data item.
-  void FinishOutput(Context &);
+  // Emit any remaining character literals after the last data item (on output)
+  // and perform remaining record positioning actions.
+  void Finish(Context &);
 
 private:
   static constexpr std::uint8_t maxMaxHeight{100};
@@ -119,14 +122,16 @@ template<typename CONTEXT> class FormatControl {
     SkipBlanks();
     return offset_ < formatLength_ ? format_[offset_] : '\0';
   }
-  CharType GetNextChar(const Terminator &terminator) {
+  CharType GetNextChar(IoErrorHandler &handler) {
     SkipBlanks();
     if (offset_ >= formatLength_) {
-      terminator.Crash("FORMAT missing at least one ')'");
+      handler.SignalError(
+          IostatErrorInFormat, "FORMAT missing at least one ')'");
+      return '\n';
     }
     return format_[offset_++];
   }
-  int GetIntField(const Terminator &, CharType firstCh = '\0');
+  int GetIntField(IoErrorHandler &, CharType firstCh = '\0');
 
   // Advances through the FORMAT until the next data edit
   // descriptor has been found; handles control edit descriptors
diff --git a/runtime/internal-unit.cpp b/runtime/internal-unit.cpp
index 737f0856e33f..e5a71f735a12 100644
--- a/runtime/internal-unit.cpp
+++ b/runtime/internal-unit.cpp
@@ -14,8 +14,8 @@
 
 namespace Fortran::runtime::io {
 
-template<bool isInput>
-InternalDescriptorUnit<isInput>::InternalDescriptorUnit(
+template<Direction DIR>
+InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     Scalar scalar, std::size_t length) {
   recordLength = length;
   endfileRecordNumber = 2;
@@ -24,8 +24,8 @@ InternalDescriptorUnit<isInput>::InternalDescriptorUnit(
       CFI_attribute_pointer);
 }
 
-template<bool isInput>
-InternalDescriptorUnit<isInput>::InternalDescriptorUnit(
+template<Direction DIR>
+InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     const Descriptor &that, const Terminator &terminator) {
   RUNTIME_CHECK(terminator, that.type().IsCharacter());
   Descriptor &d{descriptor()};
@@ -35,95 +35,107 @@ InternalDescriptorUnit<isInput>::InternalDescriptorUnit(
   d.Check();
   recordLength = d.ElementBytes();
   endfileRecordNumber = d.Elements() + 1;
-  d.GetLowerBounds(at_);
 }
 
-template<bool isInput> void InternalDescriptorUnit<isInput>::EndIoStatement() {
-  if constexpr (!isInput) {
-    // blank fill
-    while (currentRecordNumber < endfileRecordNumber.value_or(0)) {
-      char *record{descriptor().template Element<char>(at_)};
-      std::fill_n(record + furthestPositionInRecord,
-          recordLength.value_or(0) - furthestPositionInRecord, ' ');
+template<Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
+  if constexpr (DIR == Direction::Output) {  // blank fill
+    while (char *record{CurrentRecord()}) {
+      if (furthestPositionInRecord <
+          recordLength.value_or(furthestPositionInRecord)) {
+        std::fill_n(record + furthestPositionInRecord,
+            *recordLength - furthestPositionInRecord, ' ');
+      }
       furthestPositionInRecord = 0;
       ++currentRecordNumber;
-      descriptor().IncrementSubscripts(at_);
     }
   }
 }
 
-template<bool isInput>
-bool InternalDescriptorUnit<isInput>::Emit(
+template<Direction DIR>
+bool InternalDescriptorUnit<DIR>::Emit(
     const char *data, std::size_t bytes, IoErrorHandler &handler) {
-  if constexpr (isInput) {
+  if constexpr (DIR == Direction::Input) {
+    handler.Crash("InternalDescriptorUnit<Direction::Input>::Emit() called");
+    return false && data[bytes] != 0;  // bogus compare silences GCC warning
+  } else {
+    if (bytes <= 0) {
+      return true;
+    }
+    char *record{CurrentRecord()};
+    if (!record) {
+      handler.SignalError(IostatInternalWriteOverrun);
+      return false;
+    }
+    auto furthestAfter{std::max(furthestPositionInRecord,
+        positionInRecord + static_cast<std::int64_t>(bytes))};
+    bool ok{true};
+    if (furthestAfter > static_cast<std::int64_t>(recordLength.value_or(0))) {
+      handler.SignalError(IostatRecordWriteOverrun);
+      furthestAfter = recordLength.value_or(0);
+      bytes = std::max(std::int64_t{0}, furthestAfter - positionInRecord);
+      ok = false;
+    } else if (positionInRecord > furthestPositionInRecord) {
+      std::fill_n(record + furthestPositionInRecord,
+          positionInRecord - furthestPositionInRecord, ' ');
+    }
+    std::memcpy(record + positionInRecord, data, bytes);
+    positionInRecord += bytes;
+    furthestPositionInRecord = furthestAfter;
+    return ok;
+  }
+}
+
+template<Direction DIR>
+std::optional<char32_t> InternalDescriptorUnit<DIR>::GetCurrentChar(
+    IoErrorHandler &handler) {
+  if constexpr (DIR == Direction::Output) {
     handler.Crash(
-        "InternalDescriptorUnit<true>::Emit() called for an input statement");
-    return false;
+        "InternalDescriptorUnit<Direction::Output>::GetCurrentChar() called");
+    return std::nullopt;
   }
-  if (currentRecordNumber >= endfileRecordNumber.value_or(0)) {
+  const char *record{CurrentRecord()};
+  if (!record) {
     handler.SignalEnd();
-    return false;
+    return std::nullopt;
   }
-  char *record{descriptor().template Element<char>(at_)};
-  auto furthestAfter{std::max(furthestPositionInRecord,
-      positionInRecord + static_cast<std::int64_t>(bytes))};
-  bool ok{true};
-  if (furthestAfter > static_cast<std::int64_t>(recordLength.value_or(0))) {
-    handler.SignalEor();
-    furthestAfter = recordLength.value_or(0);
-    bytes = std::max(std::int64_t{0}, furthestAfter - positionInRecord);
-    ok = false;
+  if (positionInRecord >= recordLength.value_or(positionInRecord)) {
+    return std::nullopt;
   }
-  std::memcpy(record + positionInRecord, data, bytes);
-  positionInRecord += bytes;
-  furthestPositionInRecord = furthestAfter;
-  return ok;
+  if (isUTF8) {
+    // TODO: UTF-8 decoding
+  }
+  return record[positionInRecord];
 }
 
-template<bool isInput>
-bool InternalDescriptorUnit<isInput>::AdvanceRecord(IoErrorHandler &handler) {
+template<Direction DIR>
+bool InternalDescriptorUnit<DIR>::AdvanceRecord(IoErrorHandler &handler) {
   if (currentRecordNumber >= endfileRecordNumber.value_or(0)) {
     handler.SignalEnd();
     return false;
   }
-  if (!HandleAbsolutePosition(recordLength.value_or(0), handler)) {
-    return false;
+  if constexpr (DIR == Direction::Output) {  // blank fill
+    if (furthestPositionInRecord <
+        recordLength.value_or(furthestPositionInRecord)) {
+      char *record{CurrentRecord()};
+      RUNTIME_CHECK(handler, record != nullptr);
+      std::fill_n(record + furthestPositionInRecord,
+          *recordLength - furthestPositionInRecord, ' ');
+    }
   }
   ++currentRecordNumber;
-  descriptor().IncrementSubscripts(at_);
   positionInRecord = 0;
   furthestPositionInRecord = 0;
   return true;
 }
 
-template<bool isInput>
-bool InternalDescriptorUnit<isInput>::HandleAbsolutePosition(
-    std::int64_t n, IoErrorHandler &handler) {
-  n = std::max<std::int64_t>(0, n);
-  bool ok{true};
-  if (n > static_cast<std::int64_t>(recordLength.value_or(n))) {
-    handler.SignalEor();
-    n = *recordLength;
-    ok = false;
-  }
-  if (n > furthestPositionInRecord && ok) {
-    if constexpr (!isInput) {
-      char *record{descriptor().template Element<char>(at_)};
-      std::fill_n(
-          record + furthestPositionInRecord, n - furthestPositionInRecord, ' ');
-    }
-    furthestPositionInRecord = n;
-  }
-  positionInRecord = n;
-  return ok;
-}
-
-template<bool isInput>
-bool InternalDescriptorUnit<isInput>::HandleRelativePosition(
-    std::int64_t n, IoErrorHandler &handler) {
-  return HandleAbsolutePosition(positionInRecord + n, handler);
+template<Direction DIR>
+void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
+  RUNTIME_CHECK(handler, currentRecordNumber > 1);
+  --currentRecordNumber;
+  positionInRecord = 0;
+  furthestPositionInRecord = 0;
 }
 
-template class InternalDescriptorUnit<false>;
-template class InternalDescriptorUnit<true>;
+template class InternalDescriptorUnit<Direction::Output>;
+template class InternalDescriptorUnit<Direction::Input>;
 }
diff --git a/runtime/internal-unit.h b/runtime/internal-unit.h
index 837ddc6f588f..7f4f11e976f6 100644
--- a/runtime/internal-unit.h
+++ b/runtime/internal-unit.h
@@ -22,25 +22,32 @@ class IoErrorHandler;
 
 // Points to (but does not own) a CHARACTER scalar or array for internal I/O.
 // Does not buffer.
-template<bool isInput> class InternalDescriptorUnit : public ConnectionState {
+template<Direction DIR> class InternalDescriptorUnit : public ConnectionState {
 public:
-  using Scalar = std::conditional_t<isInput, const char *, char *>;
+  using Scalar =
+      std::conditional_t<DIR == Direction::Input, const char *, char *>;
   InternalDescriptorUnit(Scalar, std::size_t);
   InternalDescriptorUnit(const Descriptor &, const Terminator &);
   void EndIoStatement();
 
-  bool Emit(const char *, std::size_t bytes, IoErrorHandler &);
+  bool Emit(const char *, std::size_t, IoErrorHandler &);
+  std::optional<char32_t> GetCurrentChar(IoErrorHandler &);
   bool AdvanceRecord(IoErrorHandler &);
-  bool HandleAbsolutePosition(std::int64_t, IoErrorHandler &);
-  bool HandleRelativePosition(std::int64_t, IoErrorHandler &);
+  void BackspaceRecord(IoErrorHandler &);
 
 private:
   Descriptor &descriptor() { return staticDescriptor_.descriptor(); }
+  const Descriptor &descriptor() const {
+    return staticDescriptor_.descriptor();
+  }
+  Scalar CurrentRecord() const {
+    return descriptor().template ZeroBasedIndexedElement<char>(
+        currentRecordNumber - 1);
+  }
   StaticDescriptor<maxRank, true /*addendum*/> staticDescriptor_;
-  SubscriptValue at_[maxRank];
 };
 
-extern template class InternalDescriptorUnit<false>;
-extern template class InternalDescriptorUnit<true>;
+extern template class InternalDescriptorUnit<Direction::Output>;
+extern template class InternalDescriptorUnit<Direction::Input>;
 }
 #endif  // FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
diff --git a/runtime/io-api.cpp b/runtime/io-api.cpp
index 969315a49fa7..cf18b8f0519b 100644
--- a/runtime/io-api.cpp
+++ b/runtime/io-api.cpp
@@ -9,11 +9,12 @@
 // Implements the I/O statement API
 
 #include "io-api.h"
+#include "edit-input.h"
+#include "edit-output.h"
 #include "environment.h"
 #include "format.h"
 #include "io-stmt.h"
 #include "memory.h"
-#include "numeric-output.h"
 #include "terminator.h"
 #include "tools.h"
 #include "unit.h"
@@ -22,116 +23,212 @@
 
 namespace Fortran::runtime::io {
 
-Cookie IONAME(BeginInternalArrayListOutput)(const Descriptor &descriptor,
+template<Direction DIR>
+Cookie BeginInternalArrayListIO(const Descriptor &descriptor,
     void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
     const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
-  return &New<InternalListIoStatementState<false>>{}(
+  return &New<InternalListIoStatementState<DIR>>{}(
       oom, descriptor, sourceFile, sourceLine)
               .ioStatementState();
 }
 
-Cookie IONAME(BeginInternalArrayFormattedOutput)(const Descriptor &descriptor,
+Cookie IONAME(BeginInternalArrayListOutput)(const Descriptor &descriptor,
+    void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
+    int sourceLine) {
+  return BeginInternalArrayListIO<Direction::Output>(
+      descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginInternalArrayListInput)(const Descriptor &descriptor,
+    void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
+    int sourceLine) {
+  return BeginInternalArrayListIO<Direction::Input>(
+      descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
+}
+
+template<Direction DIR>
+Cookie BeginInternalArrayFormattedIO(const Descriptor &descriptor,
     const char *format, std::size_t formatLength, void ** /*scratchArea*/,
     std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
-  return &New<InternalFormattedIoStatementState<false>>{}(
+  return &New<InternalFormattedIoStatementState<DIR>>{}(
       oom, descriptor, format, formatLength, sourceFile, sourceLine)
               .ioStatementState();
 }
 
-Cookie IONAME(BeginInternalListOutput)(char *internal,
-    std::size_t internalLength, void ** /*scratchArea*/,
-    std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
-  Terminator oom{sourceFile, sourceLine};
-  return &New<InternalListIoStatementState<false>>{}(
-      oom, internal, internalLength, sourceFile, sourceLine)
-              .ioStatementState();
+Cookie IONAME(BeginInternalArrayFormattedOutput)(const Descriptor &descriptor,
+    const char *format, std::size_t formatLength, void **scratchArea,
+    std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
+  return BeginInternalArrayFormattedIO<Direction::Output>(descriptor, format,
+      formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
+Cookie IONAME(BeginInternalArrayFormattedInput)(const Descriptor &descriptor,
+    const char *format, std::size_t formatLength, void **scratchArea,
+    std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
+  return BeginInternalArrayFormattedIO<Direction::Input>(descriptor, format,
+      formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
+}
+
+template<Direction DIR>
+Cookie BeginInternalFormattedIO(
+    std::conditional_t<DIR == Direction::Input, const char, char> *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
     void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
     const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
-  return &New<InternalFormattedIoStatementState<false>>{}(oom, internal,
+  return &New<InternalFormattedIoStatementState<DIR>>{}(oom, internal,
       internalLength, format, formatLength, sourceFile, sourceLine)
               .ioStatementState();
 }
 
-Cookie IONAME(BeginInternalFormattedInput)(char *internal,
+Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
-    void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
-    const char *sourceFile, int sourceLine) {
+    void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
+    int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
-  return &New<InternalFormattedIoStatementState<true>>{}(oom, internal,
-      internalLength, format, formatLength, sourceFile, sourceLine)
-              .ioStatementState();
+  return BeginInternalFormattedIO<Direction::Output>(internal, internalLength,
+      format, formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-Cookie IONAME(BeginExternalListOutput)(
+Cookie IONAME(BeginInternalFormattedInput)(const char *internal,
+    std::size_t internalLength, const char *format, std::size_t formatLength,
+    void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
+    int sourceLine) {
+  Terminator oom{sourceFile, sourceLine};
+  return BeginInternalFormattedIO<Direction::Input>(internal, internalLength,
+      format, formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
+}
+
+template<Direction DIR>
+Cookie BeginExternalListIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  int unit{unitNumber == DefaultUnit ? 6 : unitNumber};
-  ExternalFileUnit &file{ExternalFileUnit::LookUpOrCrash(unit, terminator)};
-  if (file.isUnformatted) {
-    terminator.Crash("List-directed output attempted to unformatted file");
+  if (unitNumber == DefaultUnit) {
+    unitNumber = DIR == Direction::Input ? 5 : 6;
   }
-  return &file.BeginIoStatement<ExternalListIoStatementState<false>>(
-      file, sourceFile, sourceLine);
+  ExternalFileUnit &unit{
+      ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
+  if (unit.access == Access::Direct) {
+    terminator.Crash("List-directed I/O attempted on direct access file");
+    return nullptr;
+  }
+  if (unit.isUnformatted) {
+    terminator.Crash("List-directed I/O attempted on unformatted file");
+    return nullptr;
+  }
+  IoStatementState &io{unit.BeginIoStatement<ExternalListIoStatementState<DIR>>(
+      unit, sourceFile, sourceLine)};
+  if constexpr (DIR == Direction::Input) {
+    io.AdvanceRecord();
+  }
+  return &io;
 }
 
-Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
-    std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
-    int sourceLine) {
+Cookie IONAME(BeginExternalListOutput)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  return BeginExternalListIO<Direction::Output>(
+      unitNumber, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginExternalListInput)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  return BeginExternalListIO<Direction::Input>(
+      unitNumber, sourceFile, sourceLine);
+}
+
+template<Direction DIR>
+Cookie BeginExternalFormattedIO(const char *format, std::size_t formatLength,
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  int unit{unitNumber == DefaultUnit ? 6 : unitNumber};
-  ExternalFileUnit &file{ExternalFileUnit::LookUpOrCrash(unit, terminator)};
-  if (file.isUnformatted) {
-    terminator.Crash("Formatted output attempted to unformatted file");
+  if (unitNumber == DefaultUnit) {
+    unitNumber = DIR == Direction::Input ? 5 : 6;
+  }
+  ExternalFileUnit &unit{
+      ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
+  if (unit.isUnformatted) {
+    terminator.Crash("Formatted I/O attempted on unformatted file");
+    return nullptr;
   }
   IoStatementState &io{
-      file.BeginIoStatement<ExternalFormattedIoStatementState<false>>(
-          file, format, formatLength, sourceFile, sourceLine)};
+      unit.BeginIoStatement<ExternalFormattedIoStatementState<DIR>>(
+          unit, format, formatLength, sourceFile, sourceLine)};
+  if constexpr (DIR == Direction::Input) {
+    io.AdvanceRecord();
+  }
   return &io;
 }
 
-Cookie IONAME(BeginUnformattedOutput)(
+Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
+    std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
+    int sourceLine) {
+  return BeginExternalFormattedIO<Direction::Output>(
+      format, formatLength, unitNumber, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginExternalFormattedInput)(const char *format,
+    std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
+    int sourceLine) {
+  return BeginExternalFormattedIO<Direction::Input>(
+      format, formatLength, unitNumber, sourceFile, sourceLine);
+}
+
+template<Direction DIR>
+Cookie BeginUnformattedIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   ExternalFileUnit &file{
       ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
   if (!file.isUnformatted) {
-    terminator.Crash("Unformatted output attempted to formatted file");
+    terminator.Crash("Unformatted output attempted on formatted file");
   }
-  IoStatementState &io{
-      file.BeginIoStatement<UnformattedIoStatementState<false>>(
-          file, sourceFile, sourceLine)};
-  if (file.access == Access::Sequential && !file.recordLength.has_value()) {
-    // Filled in by UnformattedIoStatementState<false>::EndIoStatement()
-    io.Emit("\0\0\0\0", 4);  // placeholder for record length header
+  IoStatementState &io{file.BeginIoStatement<UnformattedIoStatementState<DIR>>(
+      file, sourceFile, sourceLine)};
+  if constexpr (DIR == Direction::Input) {
+    io.AdvanceRecord();
+  } else {
+    if (file.access == Access::Sequential && !file.recordLength.has_value()) {
+      // Create space for (sub)record header to be completed by
+      // UnformattedIoStatementState<Direction::Output>::EndIoStatement()
+      io.Emit("\0\0\0\0", 4);  // placeholder for record length header
+    }
   }
   return &io;
 }
 
+Cookie IONAME(BeginUnformattedOutput)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  return BeginUnformattedIO<Direction::Output>(
+      unitNumber, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginUnformattedInput)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  return BeginUnformattedIO<Direction::Input>(
+      unitNumber, sourceFile, sourceLine);
+}
+
 Cookie IONAME(BeginOpenUnit)(  // OPEN(without NEWUNIT=)
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   bool wasExtant{false};
+  Terminator terminator{sourceFile, sourceLine};
   ExternalFileUnit &unit{
-      ExternalFileUnit::LookUpOrCreate(unitNumber, &wasExtant)};
+      ExternalFileUnit::LookUpOrCreate(unitNumber, terminator, &wasExtant)};
   return &unit.BeginIoStatement<OpenStatementState>(
       unit, wasExtant, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginOpenNewUnit)(  // OPEN(NEWUNIT=j)
     const char *sourceFile, int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
   return IONAME(BeginOpenUnit)(
-      ExternalFileUnit::NewUnit(), sourceFile, sourceLine);
+      ExternalFileUnit::NewUnit(terminator), sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginClose)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
+  if (ExternalFileUnit * unit{ExternalFileUnit::LookUpForClose(unitNumber)}) {
     return &unit->BeginIoStatement<CloseStatementState>(
         *unit, sourceFile, sourceLine);
   } else {
@@ -144,8 +241,8 @@ Cookie IONAME(BeginClose)(
 
 // Control list items
 
-void IONAME(EnableHandlers)(
-    Cookie cookie, bool hasIoStat, bool hasErr, bool hasEnd, bool hasEor) {
+void IONAME(EnableHandlers)(Cookie cookie, bool hasIoStat, bool hasErr,
+    bool hasEnd, bool hasEor, bool hasIoMsg) {
   IoErrorHandler &handler{cookie->GetIoErrorHandler()};
   if (hasIoStat) {
     handler.HasIoStat();
@@ -159,17 +256,20 @@ void IONAME(EnableHandlers)(
   if (hasEor) {
     handler.HasEorLabel();
   }
+  if (hasIoMsg) {
+    handler.HasIoMsg();
+  }
 }
 
 static bool YesOrNo(const char *keyword, std::size_t length, const char *what,
-    const Terminator &terminator) {
+    IoErrorHandler &handler) {
   static const char *keywords[]{"YES", "NO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0: return true;
   case 1: return false;
   default:
-    terminator.Crash(
-        "Invalid %s='%.*s'", what, static_cast<int>(length), keyword);
+    handler.SignalError(IostatErrorInKeyword, "Invalid %s='%.*s'", what,
+        static_cast<int>(length), keyword);
     return false;
   }
 }
@@ -180,6 +280,10 @@ bool IONAME(SetAdvance)(
   ConnectionState &connection{io.GetConnectionState()};
   connection.nonAdvancing =
       !YesOrNo(keyword, length, "ADVANCE", io.GetIoErrorHandler());
+  if (connection.nonAdvancing && connection.access == Access::Direct) {
+    io.GetIoErrorHandler().SignalError(
+        "Non-advancing I/O attempted on direct access file");
+  }
   return true;
 }
 
@@ -191,7 +295,7 @@ bool IONAME(SetBlank)(Cookie cookie, const char *keyword, std::size_t length) {
   case 0: connection.modes.editingFlags &= ~blankZero; return true;
   case 1: connection.modes.editingFlags |= blankZero; return true;
   default:
-    io.GetIoErrorHandler().Crash(
+    io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid BLANK='%.*s'", static_cast<int>(length), keyword);
     return false;
   }
@@ -206,7 +310,7 @@ bool IONAME(SetDecimal)(
   case 0: connection.modes.editingFlags |= decimalComma; return true;
   case 1: connection.modes.editingFlags &= ~decimalComma; return true;
   default:
-    io.GetIoErrorHandler().Crash(
+    io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid DECIMAL='%.*s'", static_cast<int>(length), keyword);
     return false;
   }
@@ -221,7 +325,7 @@ bool IONAME(SetDelim)(Cookie cookie, const char *keyword, std::size_t length) {
   case 1: connection.modes.delim = '"'; return true;
   case 2: connection.modes.delim = '\0'; return true;
   default:
-    io.GetIoErrorHandler().Crash(
+    io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid DELIM='%.*s'", static_cast<int>(length), keyword);
     return false;
   }
@@ -235,8 +339,50 @@ bool IONAME(SetPad)(Cookie cookie, const char *keyword, std::size_t length) {
   return true;
 }
 
-// TODO: SetPos (stream I/O)
-// TODO: SetRec (direct I/O)
+bool IONAME(SetPos)(Cookie cookie, std::int64_t pos) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  if (connection.access != Access::Stream) {
+    io.GetIoErrorHandler().SignalError(
+        "REC= may not appear unless ACCESS='STREAM'");
+    return false;
+  }
+  if (pos < 1) {
+    io.GetIoErrorHandler().SignalError(
+        "POS=%zd is invalid", static_cast<std::intmax_t>(pos));
+    return false;
+  }
+  if (auto *unit{io.GetExternalFileUnit()}) {
+    unit->SetPosition(pos);
+    return true;
+  }
+  io.GetIoErrorHandler().Crash("SetPos() on internal unit");
+  return false;
+}
+
+bool IONAME(SetRec)(Cookie cookie, std::int64_t rec) {
+  IoStatementState &io{*cookie};
+  ConnectionState &connection{io.GetConnectionState()};
+  if (connection.access != Access::Direct) {
+    io.GetIoErrorHandler().SignalError(
+        "REC= may not appear unless ACCESS='DIRECT'");
+    return false;
+  }
+  if (!connection.recordLength) {
+    io.GetIoErrorHandler().SignalError("RECL= was not specified");
+    return false;
+  }
+  if (rec < 1) {
+    io.GetIoErrorHandler().SignalError(
+        "REC=%zd is invalid", static_cast<std::intmax_t>(rec));
+    return false;
+  }
+  connection.currentRecordNumber = rec;
+  if (auto *unit{io.GetExternalFileUnit()}) {
+    unit->SetPosition(rec * *connection.recordLength);
+  }
+  return true;
+}
 
 bool IONAME(SetRound)(Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
@@ -253,7 +399,7 @@ bool IONAME(SetRound)(Cookie cookie, const char *keyword, std::size_t length) {
     connection.modes.round = executionEnvironment.defaultOutputRoundingMode;
     return true;
   default:
-    io.GetIoErrorHandler().Crash(
+    io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid ROUND='%.*s'", static_cast<int>(length), keyword);
     return false;
   }
@@ -270,7 +416,7 @@ bool IONAME(SetSign)(Cookie cookie, const char *keyword, std::size_t length) {
     connection.modes.editingFlags &= ~signPlus;
     return true;
   default:
-    io.GetIoErrorHandler().Crash(
+    io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid SIGN='%.*s'", static_cast<int>(length), keyword);
     return false;
   }
@@ -291,11 +437,12 @@ bool IONAME(SetAccess)(Cookie cookie, const char *keyword, std::size_t length) {
   case 1: access = Access::Direct; break;
   case 2: access = Access::Stream; break;
   default:
-    open->Crash("Invalid ACCESS='%.*s'", static_cast<int>(length), keyword);
+    open->SignalError(IostatErrorInKeyword, "Invalid ACCESS='%.*s'",
+        static_cast<int>(length), keyword);
   }
   if (access != connection.access) {
     if (open->wasExtant()) {
-      open->Crash("ACCESS= may not be changed on an open unit");
+      open->SignalError("ACCESS= may not be changed on an open unit");
     }
     connection.access = access;
   }
@@ -317,13 +464,14 @@ bool IONAME(SetAction)(Cookie cookie, const char *keyword, std::size_t length) {
   case 1: mayRead = false; break;
   case 2: break;
   default:
-    open->Crash("Invalid ACTION='%.*s'", static_cast<int>(length), keyword);
+    open->SignalError(IostatErrorInKeyword, "Invalid ACTION='%.*s'",
+        static_cast<int>(length), keyword);
     return false;
   }
   if (mayRead != open->unit().mayRead() ||
       mayWrite != open->unit().mayWrite()) {
     if (open->wasExtant()) {
-      open->Crash("ACTION= may not be changed on an open unit");
+      open->SignalError("ACTION= may not be changed on an open unit");
     }
     open->unit().set_mayRead(mayRead);
     open->unit().set_mayWrite(mayWrite);
@@ -344,8 +492,8 @@ bool IONAME(SetAsynchronous)(
   case 0: open->unit().set_mayAsynchronous(true); return true;
   case 1: open->unit().set_mayAsynchronous(false); return true;
   default:
-    open->Crash(
-        "Invalid ASYNCHRONOUS='%.*s'", static_cast<int>(length), keyword);
+    open->SignalError(IostatErrorInKeyword, "Invalid ASYNCHRONOUS='%.*s'",
+        static_cast<int>(length), keyword);
     return false;
   }
 }
@@ -364,11 +512,12 @@ bool IONAME(SetEncoding)(
   case 0: isUTF8 = true; break;
   case 1: isUTF8 = false; break;
   default:
-    open->Crash("Invalid ENCODING='%.*s'", static_cast<int>(length), keyword);
+    open->SignalError(IostatErrorInKeyword, "Invalid ENCODING='%.*s'",
+        static_cast<int>(length), keyword);
   }
   if (isUTF8 != open->unit().isUTF8) {
     if (open->wasExtant()) {
-      open->Crash("ENCODING= may not be changed on an open unit");
+      open->SignalError("ENCODING= may not be changed on an open unit");
     }
     open->unit().isUTF8 = isUTF8;
   }
@@ -388,11 +537,12 @@ bool IONAME(SetForm)(Cookie cookie, const char *keyword, std::size_t length) {
   case 0: isUnformatted = false; break;
   case 1: isUnformatted = true; break;
   default:
-    open->Crash("Invalid FORM='%.*s'", static_cast<int>(length), keyword);
+    open->SignalError(IostatErrorInKeyword, "Invalid FORM='%.*s'",
+        static_cast<int>(length), keyword);
   }
   if (isUnformatted != open->unit().isUnformatted) {
     if (open->wasExtant()) {
-      open->Crash("FORM= may not be changed on an open unit");
+      open->SignalError("FORM= may not be changed on an open unit");
     }
     open->unit().isUnformatted = isUnformatted;
   }
@@ -413,7 +563,7 @@ bool IONAME(SetPosition)(
   case 1: open->set_position(Position::Rewind); return true;
   case 2: open->set_position(Position::Append); return true;
   default:
-    io.GetIoErrorHandler().Crash(
+    io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid POSITION='%.*s'", static_cast<int>(length), keyword);
   }
   return true;
@@ -426,9 +576,12 @@ bool IONAME(SetRecl)(Cookie cookie, std::size_t n) {
     io.GetIoErrorHandler().Crash(
         "SetRecl() called when not in an OPEN statement");
   }
+  if (n <= 0) {
+    io.GetIoErrorHandler().SignalError("RECL= must be greater than zero");
+  }
   if (open->wasExtant() && open->unit().recordLength.has_value() &&
-      *open->unit().recordLength != n) {
-    open->Crash("RECL= may not be changed for an open unit");
+      *open->unit().recordLength != static_cast<std::int64_t>(n)) {
+    open->SignalError("RECL= may not be changed for an open unit");
   }
   open->unit().recordLength = n;
   return true;
@@ -446,7 +599,7 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
     case 3: open->set_status(OpenStatus::Replace); return true;
     case 4: open->set_status(OpenStatus::Unknown); return true;
     default:
-      io.GetIoErrorHandler().Crash(
+      io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
     }
     return false;
@@ -457,7 +610,7 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
     case 0: close->set_status(CloseStatus::Keep); return true;
     case 1: close->set_status(CloseStatus::Delete); return true;
     default:
-      io.GetIoErrorHandler().Crash(
+      io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
     }
     return false;
@@ -499,13 +652,12 @@ bool IONAME(GetNewUnit)(Cookie cookie, int &unit, int kind) {
         "GetNewUnit() called when not in an OPEN statement");
   }
   if (!SetInteger(unit, kind, open->unit().unitNumber())) {
-    open->Crash("GetNewUnit(): Bad INTEGER kind(%d) for result");
+    open->SignalError("GetNewUnit(): Bad INTEGER kind(%d) for result");
   }
   return true;
 }
 
 // Data transfers
-// TODO: Input
 
 bool IONAME(OutputDescriptor)(Cookie cookie, const Descriptor &) {
   IoStatementState &io{*cookie};
@@ -516,7 +668,7 @@ bool IONAME(OutputDescriptor)(Cookie cookie, const Descriptor &) {
 bool IONAME(OutputUnformattedBlock)(
     Cookie cookie, const char *x, std::size_t length) {
   IoStatementState &io{*cookie};
-  if (auto *unf{io.get_if<UnformattedIoStatementState<false>>()}) {
+  if (auto *unf{io.get_if<UnformattedIoStatementState<Direction::Output>>()}) {
     return unf->Emit(x, length);
   }
   io.GetIoErrorHandler().Crash("OutputUnformatted() called for an I/O "
@@ -531,7 +683,26 @@ bool IONAME(OutputInteger64)(Cookie cookie, std::int64_t n) {
         "OutputInteger64() called for a non-output I/O statement");
     return false;
   }
-  return EditIntegerOutput(io, io.GetNextDataEdit(), n);
+  if (auto edit{io.GetNextDataEdit()}) {
+    return EditIntegerOutput(io, *edit, n);
+  }
+  return false;
+}
+
+bool IONAME(InputInteger)(Cookie cookie, std::int64_t &n, int kind) {
+  IoStatementState &io{*cookie};
+  if (!io.get_if<InputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "InputInteger64() called for a non-input I/O statement");
+    return false;
+  }
+  if (auto edit{io.GetNextDataEdit()}) {
+    if (edit->descriptor == DataEdit::ListDirectedNullValue) {
+      return true;
+    }
+    return EditIntegerInput(io, *edit, reinterpret_cast<void *>(&n), kind);
+  }
+  return false;
 }
 
 bool IONAME(OutputReal64)(Cookie cookie, double x) {
@@ -541,12 +712,31 @@ bool IONAME(OutputReal64)(Cookie cookie, double x) {
         "OutputReal64() called for a non-output I/O statement");
     return false;
   }
-  return RealOutputEditing<53>{io, x}.Edit(io.GetNextDataEdit());
+  if (auto edit{io.GetNextDataEdit()}) {
+    return RealOutputEditing<53>{io, x}.Edit(*edit);
+  }
+  return false;
+}
+
+bool IONAME(InputReal64)(Cookie cookie, double &x) {
+  IoStatementState &io{*cookie};
+  if (!io.get_if<InputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "InputReal64() called for a non-input I/O statement");
+    return false;
+  }
+  if (auto edit{io.GetNextDataEdit()}) {
+    if (edit->descriptor == DataEdit::ListDirectedNullValue) {
+      return true;
+    }
+    return EditRealInput<53>(io, *edit, reinterpret_cast<void *>(&x));
+  }
+  return false;
 }
 
 bool IONAME(OutputComplex64)(Cookie cookie, double r, double z) {
   IoStatementState &io{*cookie};
-  if (io.get_if<ListDirectedStatementState<false>>()) {
+  if (io.get_if<ListDirectedStatementState<Direction::Output>>()) {
     DataEdit real, imaginary;
     real.descriptor = DataEdit::ListDirectedRealPart;
     imaginary.descriptor = DataEdit::ListDirectedImaginaryPart;
@@ -563,53 +753,29 @@ bool IONAME(OutputAscii)(Cookie cookie, const char *x, std::size_t length) {
         "OutputAscii() called for a non-output I/O statement");
     return false;
   }
-  bool ok{true};
-  if (auto *list{io.get_if<ListDirectedStatementState<false>>()}) {
-    // List-directed default CHARACTER output
-    ok &= list->EmitLeadingSpaceOrAdvance(io, length, true);
-    MutableModes &modes{io.mutableModes()};
-    ConnectionState &connection{io.GetConnectionState()};
-    if (modes.delim) {
-      ok &= io.Emit(&modes.delim, 1);
-      for (std::size_t j{0}; j < length; ++j) {
-        if (list->NeedAdvance(connection, 2)) {
-          ok &= io.Emit(&modes.delim, 1) && io.AdvanceRecord() &&
-              io.Emit(&modes.delim, 1);
-        }
-        if (x[j] == modes.delim) {
-          ok &= io.EmitRepeated(modes.delim, 2);
-        } else {
-          ok &= io.Emit(&x[j], 1);
-        }
-      }
-      ok &= io.Emit(&modes.delim, 1);
-    } else {
-      std::size_t put{0};
-      while (put < length) {
-        auto chunk{std::min(length - put, connection.RemainingSpaceInRecord())};
-        ok &= io.Emit(x + put, chunk);
-        put += chunk;
-        if (put < length) {
-          ok &= io.AdvanceRecord() && io.Emit(" ", 1);
-        }
-      }
-      list->lastWasUndelimitedCharacter = true;
-    }
+  if (auto *list{io.get_if<ListDirectedStatementState<Direction::Output>>()}) {
+    return ListDirectedDefaultCharacterOutput(io, *list, x, length);
+  } else if (auto edit{io.GetNextDataEdit()}) {
+    return EditDefaultCharacterOutput(io, *edit, x, length);
   } else {
-    // Formatted default CHARACTER output
-    DataEdit edit{io.GetNextDataEdit()};
-    if (edit.descriptor != 'A' && edit.descriptor != 'G') {
-      io.GetIoErrorHandler().Crash("Data edit descriptor '%c' may not be used "
-                                   "with a CHARACTER data item",
-          edit.descriptor);
-      return false;
+    return false;
+  }
+}
+
+bool IONAME(InputAscii)(Cookie cookie, char *x, std::size_t length) {
+  IoStatementState &io{*cookie};
+  if (!io.get_if<InputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "InputAscii() called for a non-input I/O statement");
+    return false;
+  }
+  if (auto edit{io.GetNextDataEdit()}) {
+    if (edit->descriptor == DataEdit::ListDirectedNullValue) {
+      return true;
     }
-    int len{static_cast<int>(length)};
-    int width{edit.width.value_or(len)};
-    ok &= io.EmitRepeated(' ', std::max(0, width - len)) &&
-        io.Emit(x, std::min(width, len));
+    return EditDefaultCharacterInput(io, *edit, x, length);
   }
-  return ok;
+  return false;
 }
 
 bool IONAME(OutputLogical)(Cookie cookie, bool truth) {
@@ -619,24 +785,36 @@ bool IONAME(OutputLogical)(Cookie cookie, bool truth) {
         "OutputLogical() called for a non-output I/O statement");
     return false;
   }
-  if (auto *unf{io.get_if<UnformattedIoStatementState<false>>()}) {
-    char x = truth;
-    return unf->Emit(&x, 1);
-  }
-  bool ok{true};
-  if (auto *list{io.get_if<ListDirectedStatementState<false>>()}) {
-    ok &= list->EmitLeadingSpaceOrAdvance(io, 1);
+  if (auto *list{io.get_if<ListDirectedStatementState<Direction::Output>>()}) {
+    return ListDirectedLogicalOutput(io, *list, truth);
+  } else if (auto edit{io.GetNextDataEdit()}) {
+    return EditLogicalOutput(io, *edit, truth);
   } else {
-    DataEdit edit{io.GetNextDataEdit()};
-    if (edit.descriptor != 'L' && edit.descriptor != 'G') {
-      io.GetIoErrorHandler().Crash(
-          "Data edit descriptor '%c' may not be used with a LOGICAL data item",
-          edit.descriptor);
-      return false;
+    return false;
+  }
+}
+
+bool IONAME(InputLogical)(Cookie cookie, bool &truth) {
+  IoStatementState &io{*cookie};
+  if (!io.get_if<InputStatementState>()) {
+    io.GetIoErrorHandler().Crash(
+        "InputLogical() called for a non-input I/O statement");
+    return false;
+  }
+  if (auto edit{io.GetNextDataEdit()}) {
+    if (edit->descriptor == DataEdit::ListDirectedNullValue) {
+      return true;
     }
-    ok &= io.EmitRepeated(' ', std::max(0, edit.width.value_or(1) - 1));
+    return EditLogicalInput(io, *edit, truth);
+  }
+  return false;
+}
+
+void IONAME(GetIoMsg)(Cookie cookie, char *msg, std::size_t length) {
+  IoErrorHandler &handler{cookie->GetIoErrorHandler()};
+  if (handler.GetIoStat()) {  // leave "msg" alone when no error
+    handler.GetIoMsg(msg, length);
   }
-  return ok && io.Emit(truth ? "T" : "F", 1);
 }
 
 enum Iostat IONAME(EndIoStatement)(Cookie cookie) {
diff --git a/runtime/io-api.h b/runtime/io-api.h
index 417c0b5a3981..0efbf6d1953f 100644
--- a/runtime/io-api.h
+++ b/runtime/io-api.h
@@ -12,7 +12,7 @@
 #define FORTRAN_RUNTIME_IO_API_H_
 
 #include "entry-names.h"
-#include "magic-numbers.h"
+#include "iostat.h"
 #include <cinttypes>
 #include <cstddef>
 
@@ -73,7 +73,7 @@ Cookie IONAME(BeginInternalListOutput)(char *internal,
     std::size_t internalLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
-Cookie IONAME(BeginInternalListInput)(char *internal,
+Cookie IONAME(BeginInternalListInput)(const char *internal,
     std::size_t internalLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
@@ -81,7 +81,7 @@ Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
     void **scratchArea = nullptr, std::size_t scratchBytes = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
-Cookie IONAME(BeginInternalFormattedInput)(char *internal,
+Cookie IONAME(BeginInternalFormattedInput)(const char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
     void **scratchArea = nullptr, std::size_t scratchBytes = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
@@ -172,7 +172,7 @@ Cookie IONAME(BeginInquireIoLength)(
 //   }
 //   if (EndIoStatement(cookie) == FORTRAN_RUTIME_IOSTAT_END) goto label666;
 void IONAME(EnableHandlers)(Cookie, bool hasIoStat = false, bool hasErr = false,
-    bool hasEnd = false, bool hasEor = false);
+    bool hasEnd = false, bool hasEor = false, bool hasIoMsg = false);
 
 // Control list options.  These return false on a error that the
 // Begin...() call has specified will be handled by the caller.
@@ -214,7 +214,7 @@ bool IONAME(InputDescriptor)(Cookie, const Descriptor &);
 bool IONAME(OutputUnformattedBlock)(Cookie, const char *, std::size_t);
 bool IONAME(InputUnformattedBlock)(Cookie, char *, std::size_t);
 bool IONAME(OutputInteger64)(Cookie, std::int64_t);
-bool IONAME(InputInteger64)(Cookie, std::int64_t &, int kind = 8);
+bool IONAME(InputInteger)(Cookie, std::int64_t &, int kind = 8);
 bool IONAME(OutputReal32)(Cookie, float);
 bool IONAME(InputReal32)(Cookie, float &);
 bool IONAME(OutputReal64)(Cookie, double);
@@ -282,23 +282,6 @@ bool IONAME(InquirePendingId)(Cookie, std::int64_t, bool &);
 bool IONAME(InquireInteger64)(
     Cookie, const char *specifier, std::int64_t &, int kind = 8);
 
-// The value of IOSTAT= is zero when no error, end-of-record,
-// or end-of-file condition has arisen; errors are positive values.
-// (See 12.11.5 in Fortran 2018 for the complete requirements;
-// these constants must match the values of their corresponding
-// named constants in the predefined module ISO_FORTRAN_ENV, so
-// they're actually defined in another magic-numbers.h header file
-// so that they can be included both here and there.)
-enum Iostat {
-  // Other errors have values >1
-  IostatInquireInternalUnit = FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT,
-  IostatOk = 0,
-  IostatEnd = FORTRAN_RUNTIME_IOSTAT_END,  // end-of-file & no error
-  IostatEor = FORTRAN_RUNTIME_IOSTAT_EOR,  // end-of-record & no error or EOF
-  IostatFlush =
-      FORTRAN_RUNTIME_IOSTAT_FLUSH,  // attempt to FLUSH an unflushable unit
-};
-
 // This function must be called to end an I/O statement, and its
 // cookie value may not be used afterwards unless it is recycled
 // by the runtime library to serve a later I/O statement.
diff --git a/runtime/io-error.cpp b/runtime/io-error.cpp
index 52fff2d10cfa..9300aa701f68 100644
--- a/runtime/io-error.cpp
+++ b/runtime/io-error.cpp
@@ -8,7 +8,9 @@
 
 #include "io-error.h"
 #include "magic-numbers.h"
+#include "tools.h"
 #include <cerrno>
+#include <cstdarg>
 #include <cstdio>
 #include <cstring>
 
@@ -17,46 +19,63 @@ namespace Fortran::runtime::io {
 void IoErrorHandler::Begin(const char *sourceFileName, int sourceLine) {
   flags_ = 0;
   ioStat_ = 0;
+  ioMsg_.reset();
   SetLocation(sourceFileName, sourceLine);
 }
 
-void IoErrorHandler::SignalError(int iostatOrErrno) {
-  if (iostatOrErrno == FORTRAN_RUNTIME_IOSTAT_END) {
-    SignalEnd();
-  } else if (iostatOrErrno == FORTRAN_RUNTIME_IOSTAT_EOR) {
-    SignalEor();
-  } else if (iostatOrErrno != 0) {
-    if (flags_ & hasIoStat) {
+void IoErrorHandler::SignalError(int iostatOrErrno, const char *msg, ...) {
+  if (iostatOrErrno == IostatEnd && (flags_ & hasEnd)) {
+    if (!ioStat_ || ioStat_ < IostatEnd) {
+      ioStat_ = IostatEnd;
+    }
+  } else if (iostatOrErrno == IostatEor && (flags_ & hasEor)) {
+    if (!ioStat_ || ioStat_ < IostatEor) {
+      ioStat_ = IostatEor;  // least priority
+    }
+  } else if (iostatOrErrno != IostatOk) {
+    if (flags_ & (hasIoStat | hasErr)) {
       if (ioStat_ <= 0) {
         ioStat_ = iostatOrErrno;  // priority over END=/EOR=
+        if (msg && (flags_ & hasIoMsg)) {
+          char buffer[256];
+          va_list ap;
+          va_start(ap, msg);
+          std::vsnprintf(buffer, sizeof buffer, msg, ap);
+          ioMsg_ = SaveDefaultCharacter(buffer, std::strlen(buffer) + 1, *this);
+        }
       }
-    } else if (iostatOrErrno == FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT) {
-      Crash("INQUIRE on internal unit");
+    } else if (msg) {
+      va_list ap;
+      va_start(ap, msg);
+      CrashArgs(msg, ap);
+    } else if (const char *errstr{IostatErrorString(iostatOrErrno)}) {
+      Crash(errstr);
     } else {
-      Crash("I/O error %d: %s", iostatOrErrno, std::strerror(iostatOrErrno));
+      Crash("I/O error (errno=%d): %s", iostatOrErrno,
+          std::strerror(iostatOrErrno));
     }
   }
 }
 
+void IoErrorHandler::SignalError(int iostatOrErrno) {
+  SignalError(iostatOrErrno, nullptr);
+}
+
 void IoErrorHandler::SignalErrno() { SignalError(errno); }
 
-void IoErrorHandler::SignalEnd() {
-  if (flags_ & hasEnd) {
-    if (!ioStat_ || ioStat_ < FORTRAN_RUNTIME_IOSTAT_END) {
-      ioStat_ = FORTRAN_RUNTIME_IOSTAT_END;
-    }
-  } else {
-    Crash("End of file");
-  }
-}
+void IoErrorHandler::SignalEnd() { SignalError(IostatEnd); }
 
-void IoErrorHandler::SignalEor() {
-  if (flags_ & hasEor) {
-    if (!ioStat_ || ioStat_ < FORTRAN_RUNTIME_IOSTAT_EOR) {
-      ioStat_ = FORTRAN_RUNTIME_IOSTAT_EOR;  // least priority
-    }
-  } else {
-    Crash("End of record");
+void IoErrorHandler::SignalEor() { SignalError(IostatEor); }
+
+bool IoErrorHandler::GetIoMsg(char *buffer, std::size_t bufferLength) {
+  const char *msg{ioMsg_.get()};
+  if (!msg) {
+    msg = IostatErrorString(ioStat_);
+  }
+  if (msg) {
+    ToFortranDefaultCharacter(buffer, bufferLength, msg);
+    return true;
   }
+  return ::strerror_r(ioStat_, buffer, bufferLength) == 0;
 }
 }
diff --git a/runtime/io-error.h b/runtime/io-error.h
index 80f5fa817910..246b12beaf3a 100644
--- a/runtime/io-error.h
+++ b/runtime/io-error.h
@@ -9,15 +9,20 @@
 // Distinguishes I/O error conditions; fatal ones lead to termination,
 // and those that the user program has chosen to handle are recorded
 // so that the highest-priority one can be returned as IOSTAT=.
+// IOSTAT error codes are raw errno values augmented with values for
+// Fortran-specific errors.
 
 #ifndef FORTRAN_RUNTIME_IO_ERROR_H_
 #define FORTRAN_RUNTIME_IO_ERROR_H_
 
+#include "iostat.h"
+#include "memory.h"
 #include "terminator.h"
 #include <cinttypes>
 
 namespace Fortran::runtime::io {
 
+// See 12.11 in Fortran 2018
 class IoErrorHandler : public Terminator {
 public:
   using Terminator::Terminator;
@@ -27,13 +32,22 @@ class IoErrorHandler : public Terminator {
   void HasErrLabel() { flags_ |= hasErr; }
   void HasEndLabel() { flags_ |= hasEnd; }
   void HasEorLabel() { flags_ |= hasEor; }
+  void HasIoMsg() { flags_ |= hasIoMsg; }
 
+  bool InError() const { return ioStat_ != 0; }
+
+  void SignalError(int iostatOrErrno, const char *msg, ...);
   void SignalError(int iostatOrErrno);
-  void SignalErrno();
-  void SignalEnd();
-  void SignalEor();
+  template<typename... X> void SignalError(const char *msg, X &&... xs) {
+    SignalError(IostatGenericError, msg, std::forward<X>(xs)...);
+  }
+
+  void SignalErrno();  // SignalError(errno)
+  void SignalEnd();  // input only; EOF on internal write is an error
+  void SignalEor();  // non-advancing input only; EOR on write is an error
 
   int GetIoStat() const { return ioStat_; }
+  bool GetIoMsg(char *, std::size_t);
 
 private:
   enum Flag : std::uint8_t {
@@ -41,9 +55,11 @@ class IoErrorHandler : public Terminator {
     hasErr = 2,  // ERR=
     hasEnd = 4,  // END=
     hasEor = 8,  // EOR=
+    hasIoMsg = 16,  // IOMSG=
   };
   std::uint8_t flags_{0};
   int ioStat_{0};
+  OwningPtr<char> ioMsg_;
 };
 
 }
diff --git a/runtime/io-stmt.cpp b/runtime/io-stmt.cpp
index adc9bae6c150..ea76226d7290 100644
--- a/runtime/io-stmt.cpp
+++ b/runtime/io-stmt.cpp
@@ -20,33 +20,43 @@ namespace Fortran::runtime::io {
 
 int IoStatementBase::EndIoStatement() { return GetIoStat(); }
 
-DataEdit IoStatementBase::GetNextDataEdit(int) {
-  Crash("IoStatementBase::GetNextDataEdit() called for non-formatted I/O "
-        "statement");
+std::optional<DataEdit> IoStatementBase::GetNextDataEdit(
+    IoStatementState &, int) {
+  return std::nullopt;
 }
 
-template<bool isInput, typename CHAR>
-InternalIoStatementState<isInput, CHAR>::InternalIoStatementState(
+template<Direction DIR, typename CHAR>
+InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
     Buffer scalar, std::size_t length, const char *sourceFile, int sourceLine)
   : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length} {}
 
-template<bool isInput, typename CHAR>
-InternalIoStatementState<isInput, CHAR>::InternalIoStatementState(
+template<Direction DIR, typename CHAR>
+InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
   : IoStatementBase{sourceFile, sourceLine}, unit_{d, *this} {}
 
-template<bool isInput, typename CHAR>
-bool InternalIoStatementState<isInput, CHAR>::Emit(
+template<Direction DIR, typename CHAR>
+bool InternalIoStatementState<DIR, CHAR>::Emit(
     const CharType *data, std::size_t chars) {
-  if constexpr (isInput) {
-    Crash("InternalIoStatementState<true>::Emit() called for input statement");
+  if constexpr (DIR == Direction::Input) {
+    Crash("InternalIoStatementState<Direction::Input>::Emit() called");
     return false;
   }
   return unit_.Emit(data, chars, *this);
 }
 
-template<bool isInput, typename CHAR>
-bool InternalIoStatementState<isInput, CHAR>::AdvanceRecord(int n) {
+template<Direction DIR, typename CHAR>
+std::optional<char32_t> InternalIoStatementState<DIR, CHAR>::GetCurrentChar() {
+  if constexpr (DIR == Direction::Output) {
+    Crash(
+        "InternalIoStatementState<Direction::Output>::GetCurrentChar() called");
+    return std::nullopt;
+  }
+  return unit_.GetCurrentChar(*this);
+}
+
+template<Direction DIR, typename CHAR>
+bool InternalIoStatementState<DIR, CHAR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit_.AdvanceRecord(*this)) {
       return false;
@@ -55,9 +65,14 @@ bool InternalIoStatementState<isInput, CHAR>::AdvanceRecord(int n) {
   return true;
 }
 
-template<bool isInput, typename CHAR>
-int InternalIoStatementState<isInput, CHAR>::EndIoStatement() {
-  if constexpr (!isInput) {
+template<Direction DIR, typename CHAR>
+void InternalIoStatementState<DIR, CHAR>::BackspaceRecord() {
+  unit_.BackspaceRecord(*this);
+}
+
+template<Direction DIR, typename CHAR>
+int InternalIoStatementState<DIR, CHAR>::EndIoStatement() {
+  if constexpr (DIR == Direction::Output) {
     unit_.EndIoStatement();  // fill
   }
   auto result{IoStatementBase::EndIoStatement()};
@@ -67,54 +82,51 @@ int InternalIoStatementState<isInput, CHAR>::EndIoStatement() {
   return result;
 }
 
-template<bool isInput, typename CHAR>
-InternalFormattedIoStatementState<isInput,
-    CHAR>::InternalFormattedIoStatementState(Buffer buffer, std::size_t length,
-    const CHAR *format, std::size_t formatLength, const char *sourceFile,
-    int sourceLine)
-  : InternalIoStatementState<isInput, CHAR>{buffer, length, sourceFile,
-        sourceLine},
-    ioStatementState_{*this}, format_{*this, format, formatLength} {}
-
-template<bool isInput, typename CHAR>
-InternalFormattedIoStatementState<isInput,
-    CHAR>::InternalFormattedIoStatementState(const Descriptor &d,
-    const CHAR *format, std::size_t formatLength, const char *sourceFile,
-    int sourceLine)
-  : InternalIoStatementState<isInput, CHAR>{d, sourceFile, sourceLine},
-    ioStatementState_{*this}, format_{*this, format, formatLength} {}
-
-template<bool isInput, typename CHAR>
-int InternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
-  if constexpr (!isInput) {
-    format_.FinishOutput(*this);
-  }
-  return InternalIoStatementState<isInput, CHAR>::EndIoStatement();
+template<Direction DIR, typename CHAR>
+void InternalIoStatementState<DIR, CHAR>::HandleAbsolutePosition(
+    std::int64_t n) {
+  return unit_.HandleAbsolutePosition(n);
 }
 
-template<bool isInput, typename CHAR>
-bool InternalFormattedIoStatementState<isInput, CHAR>::HandleAbsolutePosition(
+template<Direction DIR, typename CHAR>
+void InternalIoStatementState<DIR, CHAR>::HandleRelativePosition(
     std::int64_t n) {
-  return unit_.HandleAbsolutePosition(n, *this);
+  return unit_.HandleRelativePosition(n);
 }
 
-template<bool isInput, typename CHAR>
-bool InternalFormattedIoStatementState<isInput, CHAR>::HandleRelativePosition(
-    std::int64_t n) {
-  return unit_.HandleRelativePosition(n, *this);
+template<Direction DIR, typename CHAR>
+InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
+    Buffer buffer, std::size_t length, const CHAR *format,
+    std::size_t formatLength, const char *sourceFile, int sourceLine)
+  : InternalIoStatementState<DIR, CHAR>{buffer, length, sourceFile, sourceLine},
+    ioStatementState_{*this}, format_{*this, format, formatLength} {}
+
+template<Direction DIR, typename CHAR>
+InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
+    const Descriptor &d, const CHAR *format, std::size_t formatLength,
+    const char *sourceFile, int sourceLine)
+  : InternalIoStatementState<DIR, CHAR>{d, sourceFile, sourceLine},
+    ioStatementState_{*this}, format_{*this, format, formatLength} {}
+
+template<Direction DIR, typename CHAR>
+int InternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+  if constexpr (DIR == Direction::Output) {
+    format_.Finish(*this);  // ignore any remaining input positioning actions
+  }
+  return InternalIoStatementState<DIR, CHAR>::EndIoStatement();
 }
 
-template<bool isInput, typename CHAR>
-InternalListIoStatementState<isInput, CHAR>::InternalListIoStatementState(
+template<Direction DIR, typename CHAR>
+InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<isInput, CharType>{buffer, length, sourceFile,
+  : InternalIoStatementState<DIR, CharType>{buffer, length, sourceFile,
         sourceLine},
     ioStatementState_{*this} {}
 
-template<bool isInput, typename CHAR>
-InternalListIoStatementState<isInput, CHAR>::InternalListIoStatementState(
+template<Direction DIR, typename CHAR>
+InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<isInput, CharType>{d, sourceFile, sourceLine},
+  : InternalIoStatementState<DIR, CharType>{d, sourceFile, sourceLine},
     ioStatementState_{*this} {}
 
 ExternalIoStatementBase::ExternalIoStatementBase(
@@ -149,15 +161,17 @@ void OpenStatementState::set_path(
 
 int OpenStatementState::EndIoStatement() {
   if (wasExtant_ && status_ != OpenStatus::Old) {
-    Crash("OPEN statement for connected unit must have STATUS='OLD'");
+    SignalError("OPEN statement for connected unit must have STATUS='OLD'");
   }
   unit().OpenUnit(status_, position_, std::move(path_), pathLength_, *this);
-  return IoStatementBase::EndIoStatement();
+  return ExternalIoStatementBase::EndIoStatement();
 }
 
 int CloseStatementState::EndIoStatement() {
+  int result{ExternalIoStatementBase::EndIoStatement()};
   unit().CloseUnit(status_, *this);
-  return IoStatementBase::EndIoStatement();
+  unit().DestroyClosed();
+  return result;
 }
 
 int NoopCloseStatementState::EndIoStatement() {
@@ -166,8 +180,8 @@ int NoopCloseStatementState::EndIoStatement() {
   return result;
 }
 
-template<bool isInput> int ExternalIoStatementState<isInput>::EndIoStatement() {
-  if constexpr (!isInput) {
+template<Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
+  if constexpr (DIR == Direction::Output) {
     if (!unit().nonAdvancing) {
       unit().AdvanceRecord(*this);
     }
@@ -176,39 +190,49 @@ template<bool isInput> int ExternalIoStatementState<isInput>::EndIoStatement() {
   return ExternalIoStatementBase::EndIoStatement();
 }
 
-template<bool isInput>
-bool ExternalIoStatementState<isInput>::Emit(
-    const char *data, std::size_t chars) {
-  if (isInput) {
-    Crash("ExternalIoStatementState::Emit called for input statement");
+template<Direction DIR>
+bool ExternalIoStatementState<DIR>::Emit(const char *data, std::size_t chars) {
+  if constexpr (DIR == Direction::Input) {
+    Crash("ExternalIoStatementState::Emit(char) called for input statement");
   }
   return unit().Emit(data, chars * sizeof(*data), *this);
 }
 
-template<bool isInput>
-bool ExternalIoStatementState<isInput>::Emit(
+template<Direction DIR>
+bool ExternalIoStatementState<DIR>::Emit(
     const char16_t *data, std::size_t chars) {
-  if (isInput) {
-    Crash("ExternalIoStatementState::Emit called for input statement");
+  if constexpr (DIR == Direction::Input) {
+    Crash(
+        "ExternalIoStatementState::Emit(char16_t) called for input statement");
   }
   // TODO: UTF-8 encoding
   return unit().Emit(
       reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
 }
 
-template<bool isInput>
-bool ExternalIoStatementState<isInput>::Emit(
+template<Direction DIR>
+bool ExternalIoStatementState<DIR>::Emit(
     const char32_t *data, std::size_t chars) {
-  if (isInput) {
-    Crash("ExternalIoStatementState::Emit called for input statement");
+  if constexpr (DIR == Direction::Input) {
+    Crash(
+        "ExternalIoStatementState::Emit(char32_t) called for input statement");
   }
   // TODO: UTF-8 encoding
   return unit().Emit(
       reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
 }
 
-template<bool isInput>
-bool ExternalIoStatementState<isInput>::AdvanceRecord(int n) {
+template<Direction DIR>
+std::optional<char32_t> ExternalIoStatementState<DIR>::GetCurrentChar() {
+  if constexpr (DIR == Direction::Output) {
+    Crash(
+        "ExternalIoStatementState<Direction::Output>::GetCurrentChar() called");
+  }
+  return unit().GetCurrentChar(*this);
+}
+
+template<Direction DIR>
+bool ExternalIoStatementState<DIR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit().AdvanceRecord(*this)) {
       return false;
@@ -217,42 +241,58 @@ bool ExternalIoStatementState<isInput>::AdvanceRecord(int n) {
   return true;
 }
 
-template<bool isInput>
-bool ExternalIoStatementState<isInput>::HandleAbsolutePosition(std::int64_t n) {
-  return unit().HandleAbsolutePosition(n, *this);
+template<Direction DIR> void ExternalIoStatementState<DIR>::BackspaceRecord() {
+  unit().BackspaceRecord(*this);
+}
+
+template<Direction DIR>
+void ExternalIoStatementState<DIR>::HandleAbsolutePosition(std::int64_t n) {
+  return unit().HandleAbsolutePosition(n);
 }
 
-template<bool isInput>
-bool ExternalIoStatementState<isInput>::HandleRelativePosition(std::int64_t n) {
-  return unit().HandleRelativePosition(n, *this);
+template<Direction DIR>
+void ExternalIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
+  return unit().HandleRelativePosition(n);
 }
 
-template<bool isInput, typename CHAR>
-ExternalFormattedIoStatementState<isInput,
-    CHAR>::ExternalFormattedIoStatementState(ExternalFileUnit &unit,
-    const CHAR *format, std::size_t formatLength, const char *sourceFile,
-    int sourceLine)
-  : ExternalIoStatementState<isInput>{unit, sourceFile, sourceLine},
+template<Direction DIR, typename CHAR>
+ExternalFormattedIoStatementState<DIR, CHAR>::ExternalFormattedIoStatementState(
+    ExternalFileUnit &unit, const CHAR *format, std::size_t formatLength,
+    const char *sourceFile, int sourceLine)
+  : ExternalIoStatementState<DIR>{unit, sourceFile, sourceLine},
     mutableModes_{unit.modes}, format_{*this, format, formatLength} {}
 
-template<bool isInput, typename CHAR>
-int ExternalFormattedIoStatementState<isInput, CHAR>::EndIoStatement() {
-  format_.FinishOutput(*this);
-  return ExternalIoStatementState<isInput>::EndIoStatement();
+template<Direction DIR, typename CHAR>
+int ExternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+  format_.Finish(*this);
+  return ExternalIoStatementState<DIR>::EndIoStatement();
 }
 
-DataEdit IoStatementState::GetNextDataEdit(int n) {
-  return std::visit([&](auto &x) { return x.get().GetNextDataEdit(n); }, u_);
+std::optional<DataEdit> IoStatementState::GetNextDataEdit(int n) {
+  return std::visit(
+      [&](auto &x) { return x.get().GetNextDataEdit(*this, n); }, u_);
 }
 
 bool IoStatementState::Emit(const char *data, std::size_t n) {
   return std::visit([=](auto &x) { return x.get().Emit(data, n); }, u_);
 }
 
+std::optional<char32_t> IoStatementState::GetCurrentChar() {
+  return std::visit([&](auto &x) { return x.get().GetCurrentChar(); }, u_);
+}
+
 bool IoStatementState::AdvanceRecord(int n) {
   return std::visit([=](auto &x) { return x.get().AdvanceRecord(n); }, u_);
 }
 
+void IoStatementState::BackspaceRecord() {
+  std::visit([](auto &x) { x.get().BackspaceRecord(); }, u_);
+}
+
+void IoStatementState::HandleRelativePosition(std::int64_t n) {
+  return std::visit([=](auto &x) { x.get().HandleRelativePosition(n); }, u_);
+}
+
 int IoStatementState::EndIoStatement() {
   return std::visit([](auto &x) { return x.get().EndIoStatement(); }, u_);
 }
@@ -276,6 +316,10 @@ IoErrorHandler &IoStatementState::GetIoErrorHandler() const {
       u_);
 }
 
+ExternalFileUnit *IoStatementState::GetExternalFileUnit() const {
+  return std::visit([](auto &x) { return x.get().GetExternalFileUnit(); }, u_);
+}
+
 bool IoStatementState::EmitRepeated(char ch, std::size_t n) {
   return std::visit(
       [=](auto &x) {
@@ -302,13 +346,78 @@ bool IoStatementState::EmitField(
   }
 }
 
-bool ListDirectedStatementState<false>::NeedAdvance(
+void IoStatementState::SkipSpaces(std::optional<int> &remaining) {
+  if (!remaining || *remaining > 0) {
+    for (auto ch{GetCurrentChar()}; ch && ch == ' '; ch = GetCurrentChar()) {
+      HandleRelativePosition(1);
+      if (remaining && !--*remaining) {
+        break;
+      }
+    }
+  }
+}
+
+std::optional<char32_t> IoStatementState::NextInField(
+    std::optional<int> &remaining) {
+  if (!remaining) {  // list-directed or namelist: check for separators
+    if (auto next{GetCurrentChar()}) {
+      switch (*next) {
+      case ' ':
+      case ',':
+      case ';':
+      case '/':
+      case '(':
+      case ')':
+      case '\'':
+      case '"':
+      case '*': break;
+      default: HandleRelativePosition(1); return next;
+      }
+    }
+  } else if (*remaining > 0) {
+    if (auto next{GetCurrentChar()}) {
+      --*remaining;
+      HandleRelativePosition(1);
+      return next;
+    }
+    const ConnectionState &connection{GetConnectionState()};
+    if (!connection.IsAtEOF() && connection.recordLength &&
+        connection.positionInRecord >= *connection.recordLength) {
+      if (connection.modes.pad) {  // PAD='YES'
+        --*remaining;
+        return std::optional<char32_t>{' '};
+      }
+      IoErrorHandler &handler{GetIoErrorHandler()};
+      if (connection.nonAdvancing) {
+        handler.SignalEor();
+      } else {
+        handler.SignalError(IostatRecordReadOverrun);
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+std::optional<char32_t> IoStatementState::GetNextNonBlank() {
+  auto ch{GetCurrentChar()};
+  while (ch.value_or(' ') == ' ') {
+    if (ch) {
+      HandleRelativePosition(1);
+    } else if (!AdvanceRecord()) {
+      return std::nullopt;
+    }
+    ch = GetCurrentChar();
+  }
+  return ch;
+}
+
+bool ListDirectedStatementState<Direction::Output>::NeedAdvance(
     const ConnectionState &connection, std::size_t width) const {
   return connection.positionInRecord > 0 &&
       width > connection.RemainingSpaceInRecord();
 }
 
-bool ListDirectedStatementState<false>::EmitLeadingSpaceOrAdvance(
+bool ListDirectedStatementState<Direction::Output>::EmitLeadingSpaceOrAdvance(
     IoStatementState &io, std::size_t length, bool isCharacter) {
   if (length == 0) {
     return true;
@@ -326,9 +435,122 @@ bool ListDirectedStatementState<false>::EmitLeadingSpaceOrAdvance(
   return true;
 }
 
-template<bool isInput>
-int UnformattedIoStatementState<isInput>::EndIoStatement() {
-  auto &ext{static_cast<ExternalIoStatementState<isInput> &>(*this)};
+std::optional<DataEdit>
+ListDirectedStatementState<Direction::Output>::GetNextDataEdit(
+    IoStatementState &io, int maxRepeat) {
+  DataEdit edit;
+  edit.descriptor = DataEdit::ListDirected;
+  edit.repeat = maxRepeat;
+  edit.modes = io.mutableModes();
+  return edit;
+}
+
+std::optional<DataEdit>
+ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
+    IoStatementState &io, int maxRepeat) {
+  // N.B. list-directed transfers cannot be nonadvancing (C1221)
+  ConnectionState &connection{io.GetConnectionState()};
+  DataEdit edit;
+  edit.descriptor = DataEdit::ListDirected;
+  edit.repeat = 1;  // may be overridden below
+  edit.modes = connection.modes;
+  if (hitSlash_) {  // everything after '/' is nullified
+    edit.descriptor = DataEdit::ListDirectedNullValue;
+    return edit;
+  }
+  if (remaining_ > 0 && !realPart_) {  // "r*c" repetition in progress
+    while (connection.currentRecordNumber > initialRecordNumber_) {
+      io.BackspaceRecord();
+    }
+    connection.HandleAbsolutePosition(initialPositionInRecord_);
+    if (!imaginaryPart_) {
+      edit.repeat = std::min<int>(remaining_, maxRepeat);
+    }
+    remaining_ -= edit.repeat;
+    return edit;
+  }
+  // Skip separators, handle a "r*c" repeat count; see 13.10.2 in Fortran 2018
+  auto ch{io.GetNextNonBlank()};
+  if (imaginaryPart_) {
+    imaginaryPart_ = false;
+    if (ch && *ch == ')') {
+      io.HandleRelativePosition(1);
+      ch = io.GetNextNonBlank();
+    }
+  } else if (realPart_) {
+    realPart_ = false;
+    imaginaryPart_ = true;
+  }
+  if (!ch) {
+    return std::nullopt;
+  }
+  if (*ch == '/') {
+    hitSlash_ = true;
+    edit.descriptor = DataEdit::ListDirectedNullValue;
+    return edit;
+  }
+  char32_t comma{','};
+  if (io.mutableModes().editingFlags & decimalComma) {
+    comma = ';';
+  }
+  bool isFirstItem{isFirstItem_};
+  isFirstItem_ = false;
+  if (*ch == comma) {
+    if (isFirstItem) {
+      edit.descriptor = DataEdit::ListDirectedNullValue;
+      return edit;
+    }
+    // Consume comma & whitespace after previous item.
+    io.HandleRelativePosition(1);
+    ch = io.GetNextNonBlank();
+    if (!ch) {
+      return std::nullopt;
+    }
+    if (*ch == comma || *ch == '/') {
+      edit.descriptor = DataEdit::ListDirectedNullValue;
+      return edit;
+    }
+  }
+  if (imaginaryPart_) {  // can't repeat components
+    return edit;
+  }
+  if (*ch >= '0' && *ch <= '9') {  // look for "r*" repetition count
+    auto start{connection.positionInRecord};
+    int r{0};
+    do {
+      static auto constexpr clamp{(std::numeric_limits<int>::max() - '9') / 10};
+      if (r >= clamp) {
+        r = 0;
+        break;
+      }
+      r = 10 * r + (*ch - '0');
+      io.HandleRelativePosition(1);
+      ch = io.GetCurrentChar();
+    } while (ch && *ch >= '0' && *ch <= '9');
+    if (r > 0 && ch && *ch == '*') {  // subtle: r must be nonzero
+      io.HandleRelativePosition(1);
+      ch = io.GetCurrentChar();
+      if (!ch || *ch == ' ' || *ch == comma || *ch == '/') {  // "r*" null
+        edit.descriptor = DataEdit::ListDirectedNullValue;
+        return edit;
+      }
+      edit.repeat = std::min<int>(r, maxRepeat);
+      remaining_ = r - edit.repeat;
+      initialRecordNumber_ = connection.currentRecordNumber;
+      initialPositionInRecord_ = connection.positionInRecord;
+    } else {  // not a repetition count, just an integer value; rewind
+      connection.positionInRecord = start;
+    }
+  }
+  if (!imaginaryPart_ && ch && *ch == '(') {
+    realPart_ = true;
+    io.HandleRelativePosition(1);
+  }
+  return edit;
+}
+
+template<Direction DIR> int UnformattedIoStatementState<DIR>::EndIoStatement() {
+  auto &ext{static_cast<ExternalIoStatementState<DIR> &>(*this)};
   ExternalFileUnit &unit{ext.unit()};
   if (unit.access == Access::Sequential && !unit.recordLength.has_value()) {
     // Overwrite the first four bytes of the record with its length,
@@ -342,21 +564,27 @@ int UnformattedIoStatementState<isInput>::EndIoStatement() {
     } u;
     u.u = unit.furthestPositionInRecord - sizeof u.c;
     // TODO: Convert record length to little-endian on big-endian host?
-    if (!(ext.Emit(u.c, sizeof u.c) && ext.HandleAbsolutePosition(0) &&
-            ext.Emit(u.c, sizeof u.c) && ext.AdvanceRecord())) {
+    if (!(ext.Emit(u.c, sizeof u.c) &&
+            (ext.HandleAbsolutePosition(0), ext.Emit(u.c, sizeof u.c)) &&
+            ext.AdvanceRecord())) {
       return false;
     }
   }
   return ext.EndIoStatement();
 }
 
-template class InternalIoStatementState<false>;
-template class InternalIoStatementState<true>;
-template class InternalFormattedIoStatementState<false>;
-template class InternalFormattedIoStatementState<true>;
-template class InternalListIoStatementState<false>;
-template class ExternalIoStatementState<false>;
-template class ExternalFormattedIoStatementState<false>;
-template class ExternalListIoStatementState<false>;
-template class UnformattedIoStatementState<false>;
+template class InternalIoStatementState<Direction::Output>;
+template class InternalIoStatementState<Direction::Input>;
+template class InternalFormattedIoStatementState<Direction::Output>;
+template class InternalFormattedIoStatementState<Direction::Input>;
+template class InternalListIoStatementState<Direction::Output>;
+template class InternalListIoStatementState<Direction::Input>;
+template class ExternalIoStatementState<Direction::Output>;
+template class ExternalIoStatementState<Direction::Input>;
+template class ExternalFormattedIoStatementState<Direction::Output>;
+template class ExternalFormattedIoStatementState<Direction::Input>;
+template class ExternalListIoStatementState<Direction::Output>;
+template class ExternalListIoStatementState<Direction::Input>;
+template class UnformattedIoStatementState<Direction::Output>;
+template class UnformattedIoStatementState<Direction::Input>;
 }
diff --git a/runtime/io-stmt.h b/runtime/io-stmt.h
index 17549388b060..73b93a1f7e4b 100644
--- a/runtime/io-stmt.h
+++ b/runtime/io-stmt.h
@@ -11,6 +11,7 @@
 #ifndef FORTRAN_RUNTIME_IO_STMT_H_
 #define FORTRAN_RUNTIME_IO_STMT_H_
 
+#include "connection.h"
 #include "descriptor.h"
 #include "file.h"
 #include "format.h"
@@ -22,19 +23,19 @@
 
 namespace Fortran::runtime::io {
 
-struct ConnectionState;
 class ExternalFileUnit;
 
 class OpenStatementState;
 class CloseStatementState;
 class NoopCloseStatementState;
-template<bool isInput, typename CHAR = char>
+
+template<Direction, typename CHAR = char>
 class InternalFormattedIoStatementState;
-template<bool isInput, typename CHAR = char> class InternalListIoStatementState;
-template<bool isInput, typename CHAR = char>
+template<Direction, typename CHAR = char> class InternalListIoStatementState;
+template<Direction, typename CHAR = char>
 class ExternalFormattedIoStatementState;
-template<bool isInput> class ExternalListIoStatementState;
-template<bool isInput> class UnformattedIoStatementState;
+template<Direction> class ExternalListIoStatementState;
+template<Direction> class UnformattedIoStatementState;
 
 // The Cookie type in the I/O API is a pointer (for C) to this class.
 class IoStatementState {
@@ -42,15 +43,20 @@ class IoStatementState {
   template<typename A> explicit IoStatementState(A &x) : u_{x} {}
 
   // These member functions each project themselves into the active alternative.
-  // They're used by per-data-item routines in the I/O API(e.g., OutputReal64)
+  // They're used by per-data-item routines in the I/O API (e.g., OutputReal64)
   // to interact with the state of the I/O statement in progress.
   // This design avoids virtual member functions and function pointers,
-  // which may not have good support in some use cases.
-  DataEdit GetNextDataEdit(int = 1);
+  // which may not have good support in some runtime environments.
+  std::optional<DataEdit> GetNextDataEdit(int = 1);
   bool Emit(const char *, std::size_t);
+  std::optional<char32_t> GetCurrentChar();  // vacant after end of record
   bool AdvanceRecord(int = 1);
+  void BackspaceRecord();
+  void HandleRelativePosition(std::int64_t);
   int EndIoStatement();
   ConnectionState &GetConnectionState();
+  IoErrorHandler &GetIoErrorHandler() const;
+  ExternalFileUnit *GetExternalFileUnit() const;  // null if internal unit
   MutableModes &mutableModes();
 
   // N.B.: this also works with base classes
@@ -64,21 +70,31 @@ class IoStatementState {
         },
         u_);
   }
-  IoErrorHandler &GetIoErrorHandler() const;
 
   bool EmitRepeated(char, std::size_t);
   bool EmitField(const char *, std::size_t length, std::size_t width);
+  void SkipSpaces(std::optional<int> &remaining);
+  std::optional<char32_t> NextInField(std::optional<int> &remaining);
+  std::optional<char32_t> GetNextNonBlank();  // can advance record
 
 private:
   std::variant<std::reference_wrapper<OpenStatementState>,
       std::reference_wrapper<CloseStatementState>,
       std::reference_wrapper<NoopCloseStatementState>,
-      std::reference_wrapper<InternalFormattedIoStatementState<false>>,
-      std::reference_wrapper<InternalFormattedIoStatementState<true>>,
-      std::reference_wrapper<InternalListIoStatementState<false>>,
-      std::reference_wrapper<ExternalFormattedIoStatementState<false>>,
-      std::reference_wrapper<ExternalListIoStatementState<false>>,
-      std::reference_wrapper<UnformattedIoStatementState<false>>>
+      std::reference_wrapper<
+          InternalFormattedIoStatementState<Direction::Output>>,
+      std::reference_wrapper<
+          InternalFormattedIoStatementState<Direction::Input>>,
+      std::reference_wrapper<InternalListIoStatementState<Direction::Output>>,
+      std::reference_wrapper<InternalListIoStatementState<Direction::Input>>,
+      std::reference_wrapper<
+          ExternalFormattedIoStatementState<Direction::Output>>,
+      std::reference_wrapper<
+          ExternalFormattedIoStatementState<Direction::Input>>,
+      std::reference_wrapper<ExternalListIoStatementState<Direction::Output>>,
+      std::reference_wrapper<ExternalListIoStatementState<Direction::Input>>,
+      std::reference_wrapper<UnformattedIoStatementState<Direction::Output>>,
+      std::reference_wrapper<UnformattedIoStatementState<Direction::Input>>>
       u_;
 };
 
@@ -87,54 +103,80 @@ class IoStatementState {
 struct IoStatementBase : public DefaultFormatControlCallbacks {
   using DefaultFormatControlCallbacks::DefaultFormatControlCallbacks;
   int EndIoStatement();
-  DataEdit GetNextDataEdit(int = 1);  // crashing default
+  std::optional<DataEdit> GetNextDataEdit(IoStatementState &, int = 1);
+  ExternalFileUnit *GetExternalFileUnit() const { return nullptr; }
 };
 
 struct InputStatementState {};
 struct OutputStatementState {};
-template<bool isInput>
-using IoDirectionState =
-    std::conditional_t<isInput, InputStatementState, OutputStatementState>;
+template<Direction D>
+using IoDirectionState = std::conditional_t<D == Direction::Input,
+    InputStatementState, OutputStatementState>;
 
 struct FormattedStatementState {};
 
-template<bool isInput> struct ListDirectedStatementState {};
-template<> struct ListDirectedStatementState<false /*output*/> {
+// Common state for list-directed internal & external I/O
+template<Direction> struct ListDirectedStatementState {};
+template<> struct ListDirectedStatementState<Direction::Output> {
   static std::size_t RemainingSpaceInRecord(const ConnectionState &);
   bool NeedAdvance(const ConnectionState &, std::size_t) const;
   bool EmitLeadingSpaceOrAdvance(
       IoStatementState &, std::size_t, bool isCharacter = false);
+  std::optional<DataEdit> GetNextDataEdit(
+      IoStatementState &, int maxRepeat = 1);
   bool lastWasUndelimitedCharacter{false};
 };
+template<> class ListDirectedStatementState<Direction::Input> {
+public:
+  // Skips value separators, handles repetition and null values.
+  // Vacant when '/' appears; present with descriptor == ListDirectedNullValue
+  // when a null value appears.
+  std::optional<DataEdit> GetNextDataEdit(
+      IoStatementState &, int maxRepeat = 1);
+
+private:
+  int remaining_{0};  // for "r*" repetition
+  std::int64_t initialRecordNumber_;
+  std::int64_t initialPositionInRecord_;
+  bool isFirstItem_{true};  // leading separator implies null first item
+  bool hitSlash_{false};  // once '/' is seen, nullify further items
+  bool realPart_{false};
+  bool imaginaryPart_{false};
+};
 
-template<bool isInput, typename CHAR = char>
+template<Direction DIR, typename CHAR = char>
 class InternalIoStatementState : public IoStatementBase,
-                                 public IoDirectionState<isInput> {
+                                 public IoDirectionState<DIR> {
 public:
   using CharType = CHAR;
-  using Buffer = std::conditional_t<isInput, const CharType *, CharType *>;
+  using Buffer =
+      std::conditional_t<DIR == Direction::Input, const CharType *, CharType *>;
   InternalIoStatementState(Buffer, std::size_t,
       const char *sourceFile = nullptr, int sourceLine = 0);
   InternalIoStatementState(
       const Descriptor &, const char *sourceFile = nullptr, int sourceLine = 0);
   int EndIoStatement();
   bool Emit(const CharType *, std::size_t chars /* not bytes */);
+  std::optional<char32_t> GetCurrentChar();
   bool AdvanceRecord(int = 1);
+  void BackspaceRecord();
   ConnectionState &GetConnectionState() { return unit_; }
   MutableModes &mutableModes() { return unit_.modes; }
+  void HandleRelativePosition(std::int64_t);
+  void HandleAbsolutePosition(std::int64_t);
 
 protected:
   bool free_{true};
-  InternalDescriptorUnit<isInput> unit_;
+  InternalDescriptorUnit<DIR> unit_;
 };
 
-template<bool isInput, typename CHAR>
+template<Direction DIR, typename CHAR>
 class InternalFormattedIoStatementState
-  : public InternalIoStatementState<isInput, CHAR>,
+  : public InternalIoStatementState<DIR, CHAR>,
     public FormattedStatementState {
 public:
   using CharType = CHAR;
-  using typename InternalIoStatementState<isInput, CharType>::Buffer;
+  using typename InternalIoStatementState<DIR, CharType>::Buffer;
   InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
       const CharType *format, std::size_t formatLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
@@ -143,42 +185,34 @@ class InternalFormattedIoStatementState
       int sourceLine = 0);
   IoStatementState &ioStatementState() { return ioStatementState_; }
   int EndIoStatement();
-  DataEdit GetNextDataEdit(int maxRepeat = 1) {
+  std::optional<DataEdit> GetNextDataEdit(
+      IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
-  bool HandleRelativePosition(std::int64_t);
-  bool HandleAbsolutePosition(std::int64_t);
 
 private:
   IoStatementState ioStatementState_;  // points to *this
-  using InternalIoStatementState<isInput, CharType>::unit_;
+  using InternalIoStatementState<DIR, CharType>::unit_;
   // format_ *must* be last; it may be partial someday
   FormatControl<InternalFormattedIoStatementState> format_;
 };
 
-template<bool isInput, typename CHAR>
-class InternalListIoStatementState
-  : public InternalIoStatementState<isInput, CHAR>,
-    public ListDirectedStatementState<isInput> {
+template<Direction DIR, typename CHAR>
+class InternalListIoStatementState : public InternalIoStatementState<DIR, CHAR>,
+                                     public ListDirectedStatementState<DIR> {
 public:
   using CharType = CHAR;
-  using typename InternalIoStatementState<isInput, CharType>::Buffer;
+  using typename InternalIoStatementState<DIR, CharType>::Buffer;
   InternalListIoStatementState(Buffer internal, std::size_t internalLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
   InternalListIoStatementState(
       const Descriptor &, const char *sourceFile = nullptr, int sourceLine = 0);
   IoStatementState &ioStatementState() { return ioStatementState_; }
-  DataEdit GetNextDataEdit(int maxRepeat = 1) {
-    DataEdit edit;
-    edit.descriptor = DataEdit::ListDirected;
-    edit.repeat = maxRepeat;
-    edit.modes = InternalIoStatementState<isInput, CharType>::mutableModes();
-    return edit;
-  }
+  using ListDirectedStatementState<DIR>::GetNextDataEdit;
 
 private:
-  using InternalIoStatementState<isInput, CharType>::unit_;
   IoStatementState ioStatementState_;  // points to *this
+  using InternalIoStatementState<DIR, CharType>::unit_;
 };
 
 class ExternalIoStatementBase : public IoStatementBase {
@@ -189,29 +223,31 @@ class ExternalIoStatementBase : public IoStatementBase {
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   int EndIoStatement();
+  ExternalFileUnit *GetExternalFileUnit() { return &unit_; }
 
 private:
   ExternalFileUnit &unit_;
 };
 
-template<bool isInput>
+template<Direction DIR>
 class ExternalIoStatementState : public ExternalIoStatementBase,
-                                 public IoDirectionState<isInput> {
+                                 public IoDirectionState<DIR> {
 public:
   using ExternalIoStatementBase::ExternalIoStatementBase;
   int EndIoStatement();
   bool Emit(const char *, std::size_t chars /* not bytes */);
   bool Emit(const char16_t *, std::size_t chars /* not bytes */);
   bool Emit(const char32_t *, std::size_t chars /* not bytes */);
+  std::optional<char32_t> GetCurrentChar();
   bool AdvanceRecord(int = 1);
-  bool HandleRelativePosition(std::int64_t);
-  bool HandleAbsolutePosition(std::int64_t);
+  void BackspaceRecord();
+  void HandleRelativePosition(std::int64_t);
+  void HandleAbsolutePosition(std::int64_t);
 };
 
-template<bool isInput, typename CHAR>
-class ExternalFormattedIoStatementState
-  : public ExternalIoStatementState<isInput>,
-    public FormattedStatementState {
+template<Direction DIR, typename CHAR>
+class ExternalFormattedIoStatementState : public ExternalIoStatementState<DIR>,
+                                          public FormattedStatementState {
 public:
   using CharType = CHAR;
   ExternalFormattedIoStatementState(ExternalFileUnit &, const CharType *format,
@@ -219,7 +255,8 @@ class ExternalFormattedIoStatementState
       int sourceLine = 0);
   MutableModes &mutableModes() { return mutableModes_; }
   int EndIoStatement();
-  DataEdit GetNextDataEdit(int maxRepeat = 1) {
+  std::optional<DataEdit> GetNextDataEdit(
+      IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
 
@@ -231,25 +268,18 @@ class ExternalFormattedIoStatementState
   FormatControl<ExternalFormattedIoStatementState> format_;
 };
 
-template<bool isInput>
-class ExternalListIoStatementState
-  : public ExternalIoStatementState<isInput>,
-    public ListDirectedStatementState<isInput> {
+template<Direction DIR>
+class ExternalListIoStatementState : public ExternalIoStatementState<DIR>,
+                                     public ListDirectedStatementState<DIR> {
 public:
-  using ExternalIoStatementState<isInput>::ExternalIoStatementState;
-  DataEdit GetNextDataEdit(int maxRepeat = 1) {
-    DataEdit edit;
-    edit.descriptor = DataEdit::ListDirected;
-    edit.repeat = maxRepeat;
-    edit.modes = ExternalIoStatementState<isInput>::mutableModes();
-    return edit;
-  }
+  using ExternalIoStatementState<DIR>::ExternalIoStatementState;
+  using ListDirectedStatementState<DIR>::GetNextDataEdit;
 };
 
-template<bool isInput>
-class UnformattedIoStatementState : public ExternalIoStatementState<isInput> {
+template<Direction DIR>
+class UnformattedIoStatementState : public ExternalIoStatementState<DIR> {
 public:
-  using ExternalIoStatementState<isInput>::ExternalIoStatementState;
+  using ExternalIoStatementState<DIR>::ExternalIoStatementState;
   int EndIoStatement();
 };
 
@@ -300,18 +330,28 @@ class NoopCloseStatementState : public IoStatementBase {
   ConnectionState connection_;
 };
 
-extern template class InternalIoStatementState<false>;
-extern template class InternalIoStatementState<true>;
-extern template class InternalFormattedIoStatementState<false>;
-extern template class InternalFormattedIoStatementState<true>;
-extern template class InternalListIoStatementState<false>;
-extern template class ExternalIoStatementState<false>;
-extern template class ExternalFormattedIoStatementState<false>;
-extern template class ExternalListIoStatementState<false>;
-extern template class UnformattedIoStatementState<false>;
-extern template class FormatControl<InternalFormattedIoStatementState<false>>;
-extern template class FormatControl<InternalFormattedIoStatementState<true>>;
-extern template class FormatControl<ExternalFormattedIoStatementState<false>>;
+extern template class InternalIoStatementState<Direction::Output>;
+extern template class InternalIoStatementState<Direction::Input>;
+extern template class InternalFormattedIoStatementState<Direction::Output>;
+extern template class InternalFormattedIoStatementState<Direction::Input>;
+extern template class InternalListIoStatementState<Direction::Output>;
+extern template class InternalListIoStatementState<Direction::Input>;
+extern template class ExternalIoStatementState<Direction::Output>;
+extern template class ExternalIoStatementState<Direction::Input>;
+extern template class ExternalFormattedIoStatementState<Direction::Output>;
+extern template class ExternalFormattedIoStatementState<Direction::Input>;
+extern template class ExternalListIoStatementState<Direction::Output>;
+extern template class ExternalListIoStatementState<Direction::Input>;
+extern template class UnformattedIoStatementState<Direction::Output>;
+extern template class UnformattedIoStatementState<Direction::Input>;
+extern template class FormatControl<
+    InternalFormattedIoStatementState<Direction::Output>>;
+extern template class FormatControl<
+    InternalFormattedIoStatementState<Direction::Input>>;
+extern template class FormatControl<
+    ExternalFormattedIoStatementState<Direction::Output>>;
+extern template class FormatControl<
+    ExternalFormattedIoStatementState<Direction::Input>>;
 
 }
 #endif  // FORTRAN_RUNTIME_IO_STMT_H_
diff --git a/runtime/iostat.cpp b/runtime/iostat.cpp
new file mode 100644
index 000000000000..6e146faecdae
--- /dev/null
+++ b/runtime/iostat.cpp
@@ -0,0 +1,31 @@
+//===-- runtime/iostat.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 "iostat.h"
+
+namespace Fortran::runtime::io {
+const char *IostatErrorString(int iostat) {
+  switch (iostat) {
+  case IostatOk: return "No error";
+  case IostatEnd: return "End of file during input";
+  case IostatEor: return "End of record during non-advancing input";
+  case IostatUnflushable: return "FLUSH not possible";
+  case IostatInquireInternalUnit: return "INQUIRE on internal unit";
+  case IostatGenericError:
+    return "I/O error";  // dummy value, there's always a message
+  case IostatRecordWriteOverrun: return "Excessive output to fixed-size record";
+  case IostatRecordReadOverrun: return "Excessive input from fixed-size record";
+  case IostatInternalWriteOverrun:
+    return "Internal write overran available records";
+  case IostatErrorInFormat: return "Invalid FORMAT";
+  case IostatErrorInKeyword: return "Bad keyword argument value";
+  default: return nullptr;
+  }
+}
+
+}
diff --git a/runtime/iostat.h b/runtime/iostat.h
new file mode 100644
index 000000000000..b5b78360feb2
--- /dev/null
+++ b/runtime/iostat.h
@@ -0,0 +1,53 @@
+//===-- runtime/iostat.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 values returned by the runtime for IOSTAT= specifiers
+// on I/O statements.
+
+#ifndef FORTRAN_RUNTIME_IOSTAT_H_
+#define FORTRAN_RUNTIME_IOSTAT_H_
+#include "magic-numbers.h"
+namespace Fortran::runtime::io {
+
+// The value of IOSTAT= is zero when no error, end-of-record,
+// or end-of-file condition has arisen; errors are positive values.
+// (See 12.11.5 in Fortran 2018 for the complete requirements;
+// these constants must match the values of their corresponding
+// named constants in the predefined module ISO_FORTRAN_ENV, so
+// they're actually defined in another magic-numbers.h header file
+// so that they can be included both here and there.)
+enum Iostat {
+  IostatOk = 0,  // no error, EOF, or EOR condition
+
+  // These error codes are required by Fortran (see 12.10.2.16-17) to be
+  // negative integer values
+  IostatEnd = FORTRAN_RUNTIME_IOSTAT_END,  // end-of-file on input & no error
+  // End-of-record on non-advancing input, no EOF or error
+  IostatEor = FORTRAN_RUNTIME_IOSTAT_EOR,
+
+  // This value is also required to be negative (12.11.5 bullet 6).
+  // It signifies a FLUSH statement on an unflushable unit.
+  IostatUnflushable = FORTRAN_RUNTIME_IOSTAT_FLUSH,
+
+  // Other errors are positive.  We use "errno" values unchanged.
+  // This error is exported in ISO_Fortran_env.
+  IostatInquireInternalUnit = FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT,
+
+  // The remaining error codes are not exported.
+  IostatGenericError = 1001,  // see IOMSG= for details
+  IostatRecordWriteOverrun,
+  IostatRecordReadOverrun,
+  IostatInternalWriteOverrun,
+  IostatErrorInFormat,
+  IostatErrorInKeyword,
+};
+
+const char *IostatErrorString(int);
+
+}
+#endif  // FORTRAN_RUNTIME_IOSTAT_H_
diff --git a/runtime/lock.h b/runtime/lock.h
index ecf55889aaff..5c614801f2ae 100644
--- a/runtime/lock.h
+++ b/runtime/lock.h
@@ -6,11 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-// Wraps pthread_mutex_t (or whatever)
+// Wraps a mutex
 
 #ifndef FORTRAN_RUNTIME_LOCK_H_
 #define FORTRAN_RUNTIME_LOCK_H_
 
+#include "terminator.h"
 #include <mutex>
 
 namespace Fortran::runtime {
diff --git a/runtime/magic-numbers.h b/runtime/magic-numbers.h
index b60722894009..55790c5ee60a 100644
--- a/runtime/magic-numbers.h
+++ b/runtime/magic-numbers.h
@@ -26,7 +26,7 @@ and are used "raw" as IOSTAT values.
 #define FORTRAN_RUNTIME_IOSTAT_END (-1)
 #define FORTRAN_RUNTIME_IOSTAT_EOR (-2)
 #define FORTRAN_RUNTIME_IOSTAT_FLUSH (-3)
-#define FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT 255
+#define FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT 256
 
 #define FORTRAN_RUNTIME_STAT_FAILED_IMAGE 10
 #define FORTRAN_RUNTIME_STAT_LOCKED 11
diff --git a/runtime/main.cpp b/runtime/main.cpp
index e7f4200b2777..707e35cc99a0 100644
--- a/runtime/main.cpp
+++ b/runtime/main.cpp
@@ -9,7 +9,6 @@
 #include "main.h"
 #include "environment.h"
 #include "terminator.h"
-#include "unit.h"
 #include <cfenv>
 #include <cstdio>
 #include <cstdlib>
@@ -28,11 +27,10 @@ static void ConfigureFloatingPoint() {
 }
 
 extern "C" {
-
 void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[]) {
   std::atexit(Fortran::runtime::NotifyOtherImagesOfNormalEnd);
   Fortran::runtime::executionEnvironment.Configure(argc, argv, envp);
   ConfigureFloatingPoint();
-  Fortran::runtime::io::ExternalFileUnit::InitializePredefinedUnits();
+  // I/O is initialized on demand so that it works for non-Fortran main().
 }
 }
diff --git a/runtime/numeric-output.cpp b/runtime/numeric-output.cpp
deleted file mode 100644
index fdf0cde340e1..000000000000
--- a/runtime/numeric-output.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-//===-- runtime/numeric-output.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 "numeric-output.h"
-#include "flang/Common/unsigned-const-division.h"
-#include <algorithm>
-
-namespace Fortran::runtime::io {
-
-bool EditIntegerOutput(
-    IoStatementState &io, const DataEdit &edit, std::int64_t n) {
-  char buffer[66], *end = &buffer[sizeof buffer], *p = end;
-  std::uint64_t un{static_cast<std::uint64_t>(n < 0 ? -n : n)};
-  int signChars{0};
-  switch (edit.descriptor) {
-  case DataEdit::ListDirected:
-  case 'G':
-  case 'I':
-    if (n < 0 || (edit.modes.editingFlags & signPlus)) {
-      signChars = 1;  // '-' or '+'
-    }
-    while (un > 0) {
-      auto quotient{common::DivideUnsignedBy<std::uint64_t, 10>(un)};
-      *--p = '0' + un - 10 * quotient;
-      un = quotient;
-    }
-    break;
-  case 'B':
-    for (; un > 0; un >>= 1) {
-      *--p = '0' + (un & 1);
-    }
-    break;
-  case 'O':
-    for (; un > 0; un >>= 3) {
-      *--p = '0' + (un & 7);
-    }
-    break;
-  case 'Z':
-    for (; un > 0; un >>= 4) {
-      int digit = un & 0xf;
-      *--p = digit >= 10 ? 'A' + (digit - 10) : '0' + digit;
-    }
-    break;
-  default:
-    io.GetIoErrorHandler().Crash(
-        "Data edit descriptor '%c' may not be used with an INTEGER data item",
-        edit.descriptor);
-    return false;
-  }
-
-  int digits = end - p;
-  int leadingZeroes{0};
-  int editWidth{edit.width.value_or(0)};
-  if (edit.digits && digits <= *edit.digits) {  // Iw.m
-    if (*edit.digits == 0 && n == 0) {
-      // Iw.0 with zero value: output field must be blank.  For I0.0
-      // and a zero value, emit one blank character.
-      signChars = 0;  // in case of SP
-      editWidth = std::max(1, editWidth);
-    } else {
-      leadingZeroes = *edit.digits - digits;
-    }
-  } else if (n == 0) {
-    leadingZeroes = 1;
-  }
-  int total{signChars + leadingZeroes + digits};
-  if (editWidth > 0 && total > editWidth) {
-    return io.EmitRepeated('*', editWidth);
-  }
-  int leadingSpaces{std::max(0, editWidth - total)};
-  if (edit.IsListDirected()) {
-    if (static_cast<std::size_t>(total) >
-            io.GetConnectionState().RemainingSpaceInRecord() &&
-        !io.AdvanceRecord()) {
-      return false;
-    }
-    leadingSpaces = 1;
-  }
-  return io.EmitRepeated(' ', leadingSpaces) &&
-      io.Emit(n < 0 ? "-" : "+", signChars) &&
-      io.EmitRepeated('0', leadingZeroes) && io.Emit(p, digits);
-}
-
-// Formats the exponent (see table 13.1 for all the cases)
-const char *RealOutputEditingBase::FormatExponent(
-    int expo, const DataEdit &edit, int &length) {
-  char *eEnd{&exponent_[sizeof exponent_]};
-  char *exponent{eEnd};
-  for (unsigned e{static_cast<unsigned>(std::abs(expo))}; e > 0;) {
-    unsigned quotient{common::DivideUnsignedBy<unsigned, 10>(e)};
-    *--exponent = '0' + e - 10 * quotient;
-    e = quotient;
-  }
-  if (edit.expoDigits) {
-    if (int ed{*edit.expoDigits}) {  // Ew.dEe with e > 0
-      while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
-        *--exponent = '0';
-      }
-    } else if (exponent == eEnd) {
-      *--exponent = '0';  // Ew.dE0 with zero-valued exponent
-    }
-  } else {  // ensure at least two exponent digits
-    while (exponent + 2 > eEnd) {
-      *--exponent = '0';
-    }
-  }
-  *--exponent = expo < 0 ? '-' : '+';
-  if (edit.expoDigits || exponent + 3 == eEnd) {
-    *--exponent = edit.descriptor == 'D' ? 'D' : 'E';  // not 'G'
-  }
-  length = eEnd - exponent;
-  return exponent;
-}
-
-bool RealOutputEditingBase::EmitPrefix(
-    const DataEdit &edit, std::size_t length, std::size_t width) {
-  if (edit.IsListDirected()) {
-    int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart
-            ? 2
-            : edit.descriptor == DataEdit::ListDirectedImaginaryPart ? 0 : 1};
-    int suffixLength{edit.descriptor == DataEdit::ListDirectedRealPart ||
-                edit.descriptor == DataEdit::ListDirectedImaginaryPart
-            ? 1
-            : 0};
-    length += prefixLength + suffixLength;
-    ConnectionState &connection{io_.GetConnectionState()};
-    return (connection.positionInRecord == 0 ||
-               length <= connection.RemainingSpaceInRecord() ||
-               io_.AdvanceRecord()) &&
-        io_.Emit(" (", prefixLength);
-  } else if (width > length) {
-    return io_.EmitRepeated(' ', width - length);
-  } else {
-    return true;
-  }
-}
-
-bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) {
-  if (edit.descriptor == DataEdit::ListDirectedRealPart) {
-    return io_.Emit(edit.modes.editingFlags & decimalComma ? ";" : ",", 1);
-  } else if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) {
-    return io_.Emit(")", 1);
-  } else {
-    return true;
-  }
-}
-
-}
diff --git a/runtime/terminator.cpp b/runtime/terminator.cpp
index 74594ba65d84..cc0f4d23a439 100644
--- a/runtime/terminator.cpp
+++ b/runtime/terminator.cpp
@@ -18,8 +18,18 @@ namespace Fortran::runtime {
   CrashArgs(message, ap);
 }
 
+static void (*crashHandler)(const char *, va_list &){nullptr};
+
+void Terminator::RegisterCrashHandler(
+    void (*handler)(const char *, va_list &)) {
+  crashHandler = handler;
+}
+
 [[noreturn]] void Terminator::CrashArgs(
     const char *message, va_list &ap) const {
+  if (crashHandler) {
+    crashHandler(message, ap);
+  }
   std::fputs("\nfatal Fortran runtime error", stderr);
   if (sourceFileName_) {
     std::fprintf(stderr, "(%s", sourceFileName_);
diff --git a/runtime/terminator.h b/runtime/terminator.h
index 8cfc5cc8b123..20f5abd435c0 100644
--- a/runtime/terminator.h
+++ b/runtime/terminator.h
@@ -33,11 +33,15 @@ class Terminator {
   [[noreturn]] void CheckFailed(
       const char *predicate, const char *file, int line) const;
 
+  // For test harnessing - overrides CrashArgs().
+  static void RegisterCrashHandler(void (*)(const char *, va_list &));
+
 private:
   const char *sourceFileName_{nullptr};
   int sourceLine_{0};
 };
 
+// RUNTIME_CHECK() guarantees evaluation of its predicate.
 #define RUNTIME_CHECK(terminator, pred) \
   if (pred) \
     ; \
diff --git a/runtime/tools.cpp b/runtime/tools.cpp
index b254baf07b46..f4dffb0027f1 100644
--- a/runtime/tools.cpp
+++ b/runtime/tools.cpp
@@ -25,13 +25,22 @@ OwningPtr<char> SaveDefaultCharacter(
 
 static bool CaseInsensitiveMatch(
     const char *value, std::size_t length, const char *possibility) {
-  for (; length-- > 0; ++value, ++possibility) {
-    char ch{*value};
+  for (; length-- > 0; ++possibility) {
+    char ch{*value++};
     if (ch >= 'a' && ch <= 'z') {
       ch += 'A' - 'a';
     }
-    if (*possibility == '\0' || ch != *possibility) {
-      return false;
+    if (*possibility != ch) {
+      if (*possibility != '\0' || ch != ' ') {
+        return false;
+      }
+      // Ignore trailing blanks (12.5.6.2 p1)
+      while (length-- > 0) {
+        if (*value++ != ' ') {
+          return false;
+        }
+      }
+      return true;
     }
   }
   return *possibility == '\0';
@@ -48,4 +57,14 @@ int IdentifyValue(
   }
   return -1;
 }
+
+void ToFortranDefaultCharacter(
+    char *to, std::size_t toLength, const char *from) {
+  std::size_t len{std::strlen(from)};
+  std::memcpy(to, from, std::max(toLength, len));
+  if (len < toLength) {
+    std::memset(to + len, ' ', toLength - len);
+  }
+}
+
 }
diff --git a/runtime/tools.h b/runtime/tools.h
index 99571782dc07..ec7982c2082f 100644
--- a/runtime/tools.h
+++ b/runtime/tools.h
@@ -28,10 +28,8 @@ OwningPtr<char> SaveDefaultCharacter(
 int IdentifyValue(
     const char *value, std::size_t length, const char *possibilities[]);
 
-// A std::map<> customized to use the runtime's memory allocator
-template<typename KEY, typename VALUE>
-using MapAllocator = Allocator<std::pair<std::add_const_t<KEY>, VALUE>>;
-template<typename KEY, typename VALUE, typename COMPARE = std::less<KEY>>
-using Map = std::map<KEY, VALUE, COMPARE, MapAllocator<KEY, VALUE>>;
+// Truncates or pads as necessary
+void ToFortranDefaultCharacter(
+    char *to, std::size_t toLength, const char *from);
 }
 #endif  // FORTRAN_RUNTIME_TOOLS_H_
diff --git a/runtime/transformational.cpp b/runtime/transformational.cpp
index f2abb37c4c43..f0577c6e7dd3 100644
--- a/runtime/transformational.cpp
+++ b/runtime/transformational.cpp
@@ -7,12 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "transformational.h"
-#include "flang/Common/idioms.h"
+#include "memory.h"
+#include "terminator.h"
 #include "flang/Evaluate/integer.h"
 #include <algorithm>
-#include <bitset>
 #include <cinttypes>
-#include <memory>
 
 namespace Fortran::runtime {
 
@@ -22,18 +21,22 @@ static inline std::int64_t GetInt64(const char *p, std::size_t bytes) {
   case 2: return *reinterpret_cast<const std::int16_t *>(p);
   case 4: return *reinterpret_cast<const std::int32_t *>(p);
   case 8: return *reinterpret_cast<const std::int64_t *>(p);
-  default: CRASH_NO_CASE;
+  default:
+    Terminator terminator{__FILE__, __LINE__};
+    terminator.Crash("no case for %dz bytes", bytes);
   }
 }
 
 // F2018 16.9.163
-std::unique_ptr<Descriptor> RESHAPE(const Descriptor &source,
-    const Descriptor &shape, const Descriptor *pad, const Descriptor *order) {
+OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
+    const Descriptor *pad, const Descriptor *order) {
   // Compute and check the rank of the result.
-  CHECK(shape.rank() == 1);
-  CHECK(shape.type().IsInteger());
+  Terminator terminator{__FILE__, __LINE__};
+  RUNTIME_CHECK(terminator, shape.rank() == 1);
+  RUNTIME_CHECK(terminator, shape.type().IsInteger());
   SubscriptValue resultRank{shape.GetDimension(0).Extent()};
-  CHECK(resultRank >= 0 && resultRank <= static_cast<SubscriptValue>(maxRank));
+  RUNTIME_CHECK(terminator,
+      resultRank >= 0 && resultRank <= static_cast<SubscriptValue>(maxRank));
 
   // Extract and check the shape of the result; compute its element count.
   SubscriptValue lowerBound[maxRank];  // all 1's
@@ -45,7 +48,7 @@ std::unique_ptr<Descriptor> RESHAPE(const Descriptor &source,
     lowerBound[j] = 1;
     resultExtent[j] =
         GetInt64(shape.Element<char>(&shapeSubscript), shapeElementBytes);
-    CHECK(resultExtent[j] >= 0);
+    RUNTIME_CHECK(terminator, resultExtent[j] >= 0);
     resultElements *= resultExtent[j];
   }
 
@@ -55,23 +58,25 @@ std::unique_ptr<Descriptor> RESHAPE(const Descriptor &source,
   std::size_t sourceElements{source.Elements()};
   std::size_t padElements{pad ? pad->Elements() : 0};
   if (resultElements < sourceElements) {
-    CHECK(padElements > 0);
-    CHECK(pad->ElementBytes() == elementBytes);
+    RUNTIME_CHECK(terminator, padElements > 0);
+    RUNTIME_CHECK(terminator, pad->ElementBytes() == elementBytes);
   }
 
   // Extract and check the optional ORDER= argument, which must be a
   // permutation of [1..resultRank].
   int dimOrder[maxRank];
   if (order) {
-    CHECK(order->rank() == 1);
-    CHECK(order->type().IsInteger());
-    CHECK(order->GetDimension(0).Extent() == resultRank);
-    std::bitset<maxRank> values;
+    RUNTIME_CHECK(terminator, order->rank() == 1);
+    RUNTIME_CHECK(terminator, order->type().IsInteger());
+    RUNTIME_CHECK(terminator, order->GetDimension(0).Extent() == resultRank);
+    std::uint64_t values{0};
     SubscriptValue orderSubscript{order->GetDimension(0).LowerBound()};
     for (SubscriptValue j{0}; j < resultRank; ++j, ++orderSubscript) {
-      auto k{GetInt64(order->Element<char>(orderSubscript), shapeElementBytes)};
-      CHECK(k >= 1 && k <= resultRank && !values.test(k - 1));
-      values.set(k - 1);
+      auto k{GetInt64(
+          order->OffsetElement<char>(orderSubscript), shapeElementBytes)};
+      RUNTIME_CHECK(
+          terminator, k >= 1 && k <= resultRank && !((values >> k) & 1));
+      values |= std::uint64_t{1} << k;
       dimOrder[k - 1] = j;
     }
   } else {
@@ -84,7 +89,7 @@ std::unique_ptr<Descriptor> RESHAPE(const Descriptor &source,
   const DescriptorAddendum *sourceAddendum{source.Addendum()};
   const DerivedType *sourceDerivedType{
       sourceAddendum ? sourceAddendum->derivedType() : nullptr};
-  std::unique_ptr<Descriptor> result;
+  OwningPtr<Descriptor> result;
   if (sourceDerivedType) {
     result = Descriptor::Create(*sourceDerivedType, nullptr, resultRank,
         resultExtent, CFI_attribute_allocatable);
@@ -94,7 +99,7 @@ std::unique_ptr<Descriptor> RESHAPE(const Descriptor &source,
         CFI_attribute_allocatable);  // TODO rearrange these arguments
   }
   DescriptorAddendum *resultAddendum{result->Addendum()};
-  CHECK(resultAddendum);
+  RUNTIME_CHECK(terminator, resultAddendum);
   resultAddendum->flags() |= DescriptorAddendum::DoNotFinalize;
   if (sourceDerivedType) {
     std::size_t lenParameters{sourceDerivedType->lenParameters()};
@@ -106,7 +111,7 @@ std::unique_ptr<Descriptor> RESHAPE(const Descriptor &source,
   // Allocate storage for the result's data.
   int status{result->Allocate(lowerBound, resultExtent, elementBytes)};
   if (status != CFI_SUCCESS) {
-    common::die("RESHAPE: Allocate failed (error %d)", status);
+    terminator.Crash("RESHAPE: Allocate failed (error %d)", status);
   }
 
   // Populate the result's elements.
diff --git a/runtime/transformational.h b/runtime/transformational.h
index c57231c7951a..2785614b6937 100644
--- a/runtime/transformational.h
+++ b/runtime/transformational.h
@@ -10,12 +10,11 @@
 #define FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
 
 #include "descriptor.h"
-#include <memory>
+#include "memory.h"
 
 namespace Fortran::runtime {
 
-std::unique_ptr<Descriptor> RESHAPE(const Descriptor &source,
-    const Descriptor &shape, const Descriptor *pad = nullptr,
-    const Descriptor *order = nullptr);
+OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
+    const Descriptor *pad = nullptr, const Descriptor *order = nullptr);
 }
 #endif  // FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
diff --git a/runtime/type-code.h b/runtime/type-code.h
index 5136bb8d32ff..af09be560651 100644
--- a/runtime/type-code.h
+++ b/runtime/type-code.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_RUNTIME_TYPE_CODE_H_
 #define FORTRAN_RUNTIME_TYPE_CODE_H_
 
-#include "flang/ISO_Fortran_binding.h"
 #include "flang/Common/Fortran.h"
+#include "flang/ISO_Fortran_binding.h"
 
 namespace Fortran::runtime {
 
diff --git a/runtime/unit-map.cpp b/runtime/unit-map.cpp
new file mode 100644
index 000000000000..c505f0b0814a
--- /dev/null
+++ b/runtime/unit-map.cpp
@@ -0,0 +1,72 @@
+//===-- runtime/unit-map.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 "unit-map.h"
+
+namespace Fortran::runtime::io {
+
+ExternalFileUnit *UnitMap::LookUpForClose(int n) {
+  CriticalSection critical{lock_};
+  Chain *previous{nullptr};
+  int hash{Hash(n)};
+  for (Chain *p{bucket_[hash].get()}; p; previous = p, p = p->next.get()) {
+    if (p->unit.unitNumber() == n) {
+      if (previous) {
+        previous->next.swap(p->next);
+      } else {
+        bucket_[hash].swap(p->next);
+      }
+      // p->next.get() == p at this point; the next swap pushes p on closing_
+      closing_.swap(p->next);
+      return &p->unit;
+    }
+  }
+  return nullptr;
+}
+
+void UnitMap::DestroyClosed(ExternalFileUnit &unit) {
+  Chain *p{nullptr};
+  {
+    CriticalSection critical{lock_};
+    Chain *previous{nullptr};
+    for (p = closing_.get(); p; previous = p, p = p->next.get()) {
+      if (&p->unit == &unit) {
+        if (previous) {
+          previous->next.swap(p->next);
+        } else {
+          closing_.swap(p->next);
+        }
+        break;
+      }
+    }
+  }
+  if (p) {
+    p->unit.~ExternalFileUnit();
+    FreeMemory(p);
+  }
+}
+
+void UnitMap::CloseAll(IoErrorHandler &handler) {
+  CriticalSection critical{lock_};
+  for (int j{0}; j < buckets_; ++j) {
+    while (Chain * p{bucket_[j].get()}) {
+      bucket_[j].swap(p->next);  // pops p from head of list
+      p->unit.CloseUnit(CloseStatus::Keep, handler);
+      p->unit.~ExternalFileUnit();
+      FreeMemory(p);
+    }
+  }
+}
+
+ExternalFileUnit &UnitMap::Create(int n, const Terminator &terminator) {
+  Chain &chain{New<Chain>{}(terminator, n)};
+  chain.next.reset(&chain);
+  bucket_[Hash(n)].swap(chain.next);  // pushes new node as list head
+  return chain.unit;
+}
+}
diff --git a/runtime/unit-map.h b/runtime/unit-map.h
new file mode 100644
index 000000000000..550716fc25e8
--- /dev/null
+++ b/runtime/unit-map.h
@@ -0,0 +1,87 @@
+//===-- runtime/unit-map.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
+//
+//===----------------------------------------------------------------------===//
+
+// Maps Fortran unit numbers to their ExternalFileUnit instances.
+// A simple hash table with forward-linked chains per bucket.
+
+#ifndef FORTRAN_RUNTIME_UNIT_MAP_H_
+#define FORTRAN_RUNTIME_UNIT_MAP_H_
+
+#include "lock.h"
+#include "memory.h"
+#include "unit.h"
+
+namespace Fortran::runtime::io {
+
+class UnitMap {
+public:
+  ExternalFileUnit *LookUp(int n) {
+    CriticalSection critical{lock_};
+    return Find(n);
+  }
+
+  ExternalFileUnit &LookUpOrCreate(
+      int n, const Terminator &terminator, bool *wasExtant) {
+    CriticalSection critical{lock_};
+    auto *p{Find(n)};
+    if (wasExtant) {
+      *wasExtant = p != nullptr;
+    }
+    if (p) {
+      return *p;
+    }
+    return Create(n, terminator);
+  }
+
+  ExternalFileUnit &NewUnit(const Terminator &terminator) {
+    CriticalSection critical{lock_};
+    return Create(nextNewUnit_--, terminator);
+  }
+
+  // To prevent races, the unit is removed from the map if it exists,
+  // and put on the closing_ list until DestroyClosed() is called.
+  ExternalFileUnit *LookUpForClose(int);
+
+  void DestroyClosed(ExternalFileUnit &);
+  void CloseAll(IoErrorHandler &);
+
+private:
+  struct Chain {
+    explicit Chain(int n) : unit{n} {}
+    ExternalFileUnit unit;
+    OwningPtr<Chain> next{nullptr};
+  };
+
+  static constexpr int buckets_{1031};  // must be prime
+  int Hash(int n) { return n % buckets_; }
+
+  ExternalFileUnit *Find(int n) {
+    Chain *previous{nullptr};
+    int hash{Hash(n)};
+    for (Chain *p{bucket_[hash].get()}; p; previous = p, p = p->next.get()) {
+      if (p->unit.unitNumber() == n) {
+        if (previous) {
+          // Move found unit to front of chain for quicker lookup next time
+          previous->next.swap(p->next);  // now p->next.get() == p
+          bucket_[hash].swap(p->next);  // now bucket_[hash].get() == p
+        }
+        return &p->unit;
+      }
+    }
+    return nullptr;
+  }
+
+  ExternalFileUnit &Create(int, const Terminator &);
+
+  Lock lock_;
+  OwningPtr<Chain> bucket_[buckets_]{};  // all owned by *this
+  int nextNewUnit_{-1000};  // see 12.5.6.12 in Fortran 2018
+  OwningPtr<Chain> closing_{nullptr};  // units during CLOSE statement
+};
+}
+#endif  // FORTRAN_RUNTIME_UNIT_MAP_H_
diff --git a/runtime/unit.cpp b/runtime/unit.cpp
index 277d36b39a08..7c9801f23411 100644
--- a/runtime/unit.cpp
+++ b/runtime/unit.cpp
@@ -7,21 +7,23 @@
 //===----------------------------------------------------------------------===//
 
 #include "unit.h"
+#include "io-error.h"
 #include "lock.h"
-#include "memory.h"
-#include "tools.h"
-#include <algorithm>
-#include <type_traits>
+#include "unit-map.h"
 
 namespace Fortran::runtime::io {
 
-static Lock mapLock;
-static Terminator mapTerminator;
-static Map<int, ExternalFileUnit> unitMap{
-    MapAllocator<int, ExternalFileUnit>{mapTerminator}};
+// The per-unit data structures are created on demand so that Fortran I/O
+// should work without a Fortran main program.
+static Lock unitMapLock;
+static UnitMap *unitMap{nullptr};
 static ExternalFileUnit *defaultOutput{nullptr};
 
 void FlushOutputOnCrash(const Terminator &terminator) {
+  if (!defaultOutput) {
+    return;
+  }
+  CriticalSection critical{unitMapLock};
   if (defaultOutput) {
     IoErrorHandler handler{terminator};
     handler.HasIoStat();  // prevent nested crash if flush has error
@@ -30,14 +32,11 @@ void FlushOutputOnCrash(const Terminator &terminator) {
 }
 
 ExternalFileUnit *ExternalFileUnit::LookUp(int unit) {
-  CriticalSection criticalSection{mapLock};
-  auto iter{unitMap.find(unit)};
-  return iter == unitMap.end() ? nullptr : &iter->second;
+  return GetUnitMap().LookUp(unit);
 }
 
 ExternalFileUnit &ExternalFileUnit::LookUpOrCrash(
     int unit, const Terminator &terminator) {
-  CriticalSection criticalSection{mapLock};
   ExternalFileUnit *file{LookUp(unit)};
   if (!file) {
     terminator.Crash("Not an open I/O unit number: %d", unit);
@@ -45,25 +44,22 @@ ExternalFileUnit &ExternalFileUnit::LookUpOrCrash(
   return *file;
 }
 
-ExternalFileUnit &ExternalFileUnit::LookUpOrCreate(int unit, bool *wasExtant) {
-  CriticalSection criticalSection{mapLock};
-  auto pair{unitMap.emplace(unit, unit)};
-  if (wasExtant) {
-    *wasExtant = !pair.second;
-  }
-  return pair.first->second;
+ExternalFileUnit &ExternalFileUnit::LookUpOrCreate(
+    int unit, const Terminator &terminator, bool *wasExtant) {
+  return GetUnitMap().LookUpOrCreate(unit, terminator, wasExtant);
 }
 
-int ExternalFileUnit::NewUnit() {
-  CriticalSection criticalSection{mapLock};
-  static int nextNewUnit{-1000};  // see 12.5.6.12 in Fortran 2018
-  return --nextNewUnit;
+ExternalFileUnit *ExternalFileUnit::LookUpForClose(int unit) {
+  return GetUnitMap().LookUpForClose(unit);
+}
+
+int ExternalFileUnit::NewUnit(const Terminator &terminator) {
+  return GetUnitMap().NewUnit(terminator).unitNumber();
 }
 
 void ExternalFileUnit::OpenUnit(OpenStatus status, Position position,
     OwningPtr<char> &&newPath, std::size_t newPathLength,
     IoErrorHandler &handler) {
-  CriticalSection criticalSection{lock()};
   if (IsOpen()) {
     if (status == OpenStatus::Old &&
         (!newPath.get() ||
@@ -82,74 +78,93 @@ void ExternalFileUnit::OpenUnit(OpenStatus status, Position position,
 }
 
 void ExternalFileUnit::CloseUnit(CloseStatus status, IoErrorHandler &handler) {
-  {
-    CriticalSection criticalSection{lock()};
-    Flush(handler);
-    Close(status, handler);
-  }
-  CriticalSection criticalSection{mapLock};
-  auto iter{unitMap.find(unitNumber_)};
-  if (iter != unitMap.end()) {
-    unitMap.erase(iter);
-  }
+  Flush(handler);
+  Close(status, handler);
+}
+
+void ExternalFileUnit::DestroyClosed() {
+  GetUnitMap().DestroyClosed(*this);  // destroys *this
 }
 
-void ExternalFileUnit::InitializePredefinedUnits() {
-  ExternalFileUnit &out{ExternalFileUnit::LookUpOrCreate(6)};
+UnitMap &ExternalFileUnit::GetUnitMap() {
+  if (unitMap) {
+    return *unitMap;
+  }
+  CriticalSection critical{unitMapLock};
+  if (unitMap) {
+    return *unitMap;
+  }
+  Terminator terminator{__FILE__, __LINE__};
+  unitMap = &New<UnitMap>{}(terminator);
+  ExternalFileUnit &out{ExternalFileUnit::LookUpOrCreate(6, terminator)};
   out.Predefine(1);
   out.set_mayRead(false);
   out.set_mayWrite(true);
   out.set_mayPosition(false);
   defaultOutput = &out;
-  ExternalFileUnit &in{ExternalFileUnit::LookUpOrCreate(5)};
+  ExternalFileUnit &in{ExternalFileUnit::LookUpOrCreate(5, terminator)};
   in.Predefine(0);
   in.set_mayRead(true);
   in.set_mayWrite(false);
   in.set_mayPosition(false);
   // TODO: Set UTF-8 mode from the environment
+  return *unitMap;
 }
 
 void ExternalFileUnit::CloseAll(IoErrorHandler &handler) {
-  CriticalSection criticalSection{mapLock};
-  defaultOutput = nullptr;
-  while (!unitMap.empty()) {
-    auto &pair{*unitMap.begin()};
-    pair.second.CloseUnit(CloseStatus::Keep, handler);
+  CriticalSection critical{unitMapLock};
+  if (unitMap) {
+    unitMap->CloseAll(handler);
+    FreeMemoryAndNullify(unitMap);
   }
-}
-
-bool ExternalFileUnit::SetPositionInRecord(
-    std::int64_t n, IoErrorHandler &handler) {
-  n = std::max<std::int64_t>(0, n);
-  bool ok{true};
-  if (n > static_cast<std::int64_t>(recordLength.value_or(n))) {
-    handler.SignalEor();
-    n = *recordLength;
-    ok = false;
-  }
-  if (n > furthestPositionInRecord) {
-    if (!isReading_ && ok) {
-      WriteFrame(recordOffsetInFile, n, handler);
-      std::fill_n(Frame() + furthestPositionInRecord,
-          n - furthestPositionInRecord, ' ');
-    }
-    furthestPositionInRecord = n;
-  }
-  positionInRecord = n;
-  return ok;
+  defaultOutput = nullptr;
 }
 
 bool ExternalFileUnit::Emit(
     const char *data, std::size_t bytes, IoErrorHandler &handler) {
   auto furthestAfter{std::max(furthestPositionInRecord,
       positionInRecord + static_cast<std::int64_t>(bytes))};
-  WriteFrame(recordOffsetInFile, furthestAfter, handler);
+  if (furthestAfter > recordLength.value_or(furthestAfter)) {
+    handler.SignalError(IostatRecordWriteOverrun);
+    return false;
+  }
+  WriteFrame(frameOffsetInFile_, recordOffsetInFrame_ + furthestAfter, handler);
   std::memcpy(Frame() + positionInRecord, data, bytes);
   positionInRecord += bytes;
   furthestPositionInRecord = furthestAfter;
   return true;
 }
 
+std::optional<char32_t> ExternalFileUnit::GetCurrentChar(
+    IoErrorHandler &handler) {
+  isReading_ = true;  // TODO: manage read/write transitions
+  if (isUnformatted) {
+    handler.Crash("GetCurrentChar() called for unformatted input");
+    return std::nullopt;
+  }
+  std::size_t chunk{256};  // for stream input
+  if (recordLength.has_value()) {
+    if (positionInRecord >= *recordLength) {
+      return std::nullopt;
+    }
+    chunk = *recordLength - positionInRecord;
+  }
+  auto at{recordOffsetInFrame_ + positionInRecord};
+  std::size_t need{static_cast<std::size_t>(at + 1)};
+  std::size_t want{need + chunk};
+  auto got{ReadFrame(frameOffsetInFile_, want, handler)};
+  if (got <= need) {
+    endfileRecordNumber = currentRecordNumber;
+    handler.SignalEnd();
+    return std::nullopt;
+  }
+  const char *p{Frame() + at};
+  if (isUTF8) {
+    // TODO: UTF-8 decoding
+  }
+  return *p;
+}
+
 void ExternalFileUnit::SetLeftTabLimit() {
   leftTabLimit = furthestPositionInRecord;
   positionInRecord = furthestPositionInRecord;
@@ -157,13 +172,29 @@ void ExternalFileUnit::SetLeftTabLimit() {
 
 bool ExternalFileUnit::AdvanceRecord(IoErrorHandler &handler) {
   bool ok{true};
-  if (recordLength.has_value()) {  // fill fixed-size record
-    ok &= SetPositionInRecord(*recordLength, handler);
-  } else if (!isUnformatted && !isReading_) {
-    ok &= SetPositionInRecord(furthestPositionInRecord, handler) &&
-        Emit("\n", 1, handler);
+  if (isReading_) {
+    if (access == Access::Sequential) {
+      if (isUnformatted) {
+        NextSequentialUnformattedInputRecord(handler);
+      } else {
+        NextSequentialFormattedInputRecord(handler);
+      }
+    }
+  } else if (!isUnformatted) {
+    if (recordLength.has_value()) {
+      // fill fixed-size record
+      if (furthestPositionInRecord < *recordLength) {
+        WriteFrame(frameOffsetInFile_, *recordLength, handler);
+        std::memset(Frame() + recordOffsetInFrame_ + furthestPositionInRecord,
+            ' ', *recordLength - furthestPositionInRecord);
+      }
+    } else {
+      positionInRecord = furthestPositionInRecord + 1;
+      ok &= Emit("\n", 1, handler);  // TODO: Windows CR+LF
+      frameOffsetInFile_ += recordOffsetInFrame_ + furthestPositionInRecord;
+      recordOffsetInFrame_ = 0;
+    }
   }
-  recordOffsetInFile += furthestPositionInRecord;
   ++currentRecordNumber;
   positionInRecord = 0;
   furthestPositionInRecord = 0;
@@ -171,15 +202,23 @@ bool ExternalFileUnit::AdvanceRecord(IoErrorHandler &handler) {
   return ok;
 }
 
-bool ExternalFileUnit::HandleAbsolutePosition(
-    std::int64_t n, IoErrorHandler &handler) {
-  return SetPositionInRecord(
-      std::max(n, std::int64_t{0}) + leftTabLimit.value_or(0), handler);
-}
-
-bool ExternalFileUnit::HandleRelativePosition(
-    std::int64_t n, IoErrorHandler &handler) {
-  return HandleAbsolutePosition(positionInRecord + n, handler);
+void ExternalFileUnit::BackspaceRecord(IoErrorHandler &handler) {
+  if (!isReading_) {
+    handler.Crash("ExternalFileUnit::BackspaceRecord() called during writing");
+    // TODO: create endfile record, &c.
+  }
+  if (access == Access::Sequential) {
+    if (isUnformatted) {
+      BackspaceSequentialUnformattedRecord(handler);
+    } else {
+      BackspaceSequentialFormattedRecord(handler);
+    }
+  } else {
+    // TODO
+  }
+  positionInRecord = 0;
+  furthestPositionInRecord = 0;
+  leftTabLimit.reset();
 }
 
 void ExternalFileUnit::FlushIfTerminal(IoErrorHandler &handler) {
@@ -189,7 +228,186 @@ void ExternalFileUnit::FlushIfTerminal(IoErrorHandler &handler) {
 }
 
 void ExternalFileUnit::EndIoStatement() {
+  frameOffsetInFile_ += recordOffsetInFrame_;
+  recordOffsetInFrame_ = 0;
   io_.reset();
   u_.emplace<std::monostate>();
+  lock_.Drop();
+}
+
+void ExternalFileUnit::NextSequentialUnformattedInputRecord(
+    IoErrorHandler &handler) {
+  std::int32_t header{0}, footer{0};
+  // Retain previous footer (if any) in frame for more efficient BACKSPACE
+  std::size_t retain{sizeof header};
+  if (recordLength) {  // not first record - advance to next
+    ++currentRecordNumber;
+    if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
+      handler.SignalEnd();
+      return;
+    }
+    frameOffsetInFile_ +=
+        recordOffsetInFrame_ + *recordLength + 2 * sizeof header;
+    recordOffsetInFrame_ = 0;
+  } else {
+    retain = 0;
+  }
+  std::size_t need{retain + sizeof header};
+  std::size_t got{ReadFrame(frameOffsetInFile_ - retain, need, handler)};
+  // Try to emit informative errors to help debug corrupted files.
+  const char *error{nullptr};
+  if (got < need) {
+    if (got == retain) {
+      handler.SignalEnd();
+    } else {
+      error = "Unformatted sequential file input failed at record #%jd (file "
+              "offset %jd): truncated record header";
+    }
+  } else {
+    std::memcpy(&header, Frame() + retain, sizeof header);
+    need = retain + header + 2 * sizeof header;
+    got = ReadFrame(frameOffsetInFile_ - retain,
+        need + sizeof header /* next one */, handler);
+    if (got < need) {
+      error = "Unformatted sequential file input failed at record #%jd (file "
+              "offset %jd): hit EOF reading record with length %jd bytes";
+    } else {
+      const char *start{Frame() + retain + sizeof header};
+      std::memcpy(&footer, start + header, sizeof footer);
+      if (footer != header) {
+        error = "Unformatted sequential file input failed at record #%jd (file "
+                "offset %jd): record header has length %jd that does not match "
+                "record footer (%jd)";
+      } else {
+        recordLength = header;
+      }
+    }
+  }
+  if (error) {
+    handler.SignalError(error, static_cast<std::intmax_t>(currentRecordNumber),
+        static_cast<std::intmax_t>(frameOffsetInFile_),
+        static_cast<std::intmax_t>(header), static_cast<std::intmax_t>(footer));
+  }
+  positionInRecord = sizeof header;
+}
+
+void ExternalFileUnit::NextSequentialFormattedInputRecord(
+    IoErrorHandler &handler) {
+  static constexpr std::size_t chunk{256};
+  std::size_t length{0};
+  if (recordLength.has_value()) {
+    // not first record - advance to next
+    ++currentRecordNumber;
+    if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
+      handler.SignalEnd();
+      return;
+    }
+    if (Frame()[*recordLength] == '\r') {
+      ++*recordLength;
+    }
+    recordOffsetInFrame_ += *recordLength + 1;
+  }
+  while (true) {
+    std::size_t got{ReadFrame(
+        frameOffsetInFile_, recordOffsetInFrame_ + length + chunk, handler)};
+    if (got <= recordOffsetInFrame_ + length) {
+      handler.SignalEnd();
+      break;
+    }
+    const char *frame{Frame() + recordOffsetInFrame_};
+    if (const char *nl{reinterpret_cast<const char *>(
+            std::memchr(frame + length, '\n', chunk))}) {
+      recordLength = nl - (frame + length) + 1;
+      if (*recordLength > 0 && frame[*recordLength - 1] == '\r') {
+        --*recordLength;
+      }
+      return;
+    }
+    length += got;
+  }
+}
+
+void ExternalFileUnit::BackspaceSequentialUnformattedRecord(
+    IoErrorHandler &handler) {
+  std::int32_t header{0}, footer{0};
+  RUNTIME_CHECK(handler, currentRecordNumber > 1);
+  --currentRecordNumber;
+  int overhead{static_cast<int>(2 * sizeof header)};
+  // Error conditions here cause crashes, not file format errors, because the
+  // validity of the file structure before the current record will have been
+  // checked informatively in NextSequentialUnformattedInputRecord().
+  RUNTIME_CHECK(handler, frameOffsetInFile_ >= overhead);
+  std::size_t got{
+      ReadFrame(frameOffsetInFile_ - sizeof footer, sizeof footer, handler)};
+  RUNTIME_CHECK(handler, got >= sizeof footer);
+  std::memcpy(&footer, Frame(), sizeof footer);
+  RUNTIME_CHECK(handler, frameOffsetInFile_ >= footer + overhead);
+  frameOffsetInFile_ -= footer + 2 * sizeof footer;
+  auto extra{std::max<std::size_t>(sizeof footer, frameOffsetInFile_)};
+  std::size_t want{extra + footer + 2 * sizeof footer};
+  got = ReadFrame(frameOffsetInFile_ - extra, want, handler);
+  RUNTIME_CHECK(handler, got >= want);
+  std::memcpy(&header, Frame() + extra, sizeof header);
+  RUNTIME_CHECK(handler, header == footer);
+  positionInRecord = sizeof header;
+  recordLength = footer;
+}
+
+// There's no portable memrchr(), unfortunately, and strrchr() would
+// fail on a record with a NUL, so we have to do it the hard way.
+static const char *FindLastNewline(const char *str, std::size_t length) {
+  for (const char *p{str + length}; p-- > str;) {
+    if (*p == '\n') {
+      return p;
+    }
+  }
+  return nullptr;
+}
+
+void ExternalFileUnit::BackspaceSequentialFormattedRecord(
+    IoErrorHandler &handler) {
+  std::int64_t start{frameOffsetInFile_ + recordOffsetInFrame_};
+  --currentRecordNumber;
+  RUNTIME_CHECK(handler, currentRecordNumber > 0);
+  if (currentRecordNumber == 1) {
+    // To simplify the code below, treat a backspace to the first record
+    // as a special case;
+    RUNTIME_CHECK(handler, start > 0);
+    *recordLength = start - 1;
+    frameOffsetInFile_ = 0;
+    recordOffsetInFrame_ = 0;
+    ReadFrame(0, *recordLength + 1, handler);
+  } else {
+    RUNTIME_CHECK(handler, start > 1);
+    std::int64_t at{start - 2};  // byte before previous record's newline
+    while (true) {
+      if (const char *p{
+              FindLastNewline(Frame(), at - frameOffsetInFile_ + 1)}) {
+        // This is the newline that ends the record before the previous one.
+        recordOffsetInFrame_ = p - Frame() + 1;
+        *recordLength = start - 1 - (frameOffsetInFile_ + recordOffsetInFrame_);
+        break;
+      }
+      RUNTIME_CHECK(handler, frameOffsetInFile_ > 0);
+      at = frameOffsetInFile_ - 1;
+      if (auto bytesBefore{BytesBufferedBeforeFrame()}) {
+        frameOffsetInFile_ = FrameAt() - bytesBefore;
+      } else {
+        static constexpr int chunk{1024};
+        frameOffsetInFile_ = std::max<std::int64_t>(0, at - chunk);
+      }
+      std::size_t want{static_cast<std::size_t>(start - frameOffsetInFile_)};
+      std::size_t got{ReadFrame(frameOffsetInFile_, want, handler)};
+      RUNTIME_CHECK(handler, got >= want);
+    }
+  }
+  std::size_t want{
+      static_cast<std::size_t>(recordOffsetInFrame_ + *recordLength + 1)};
+  RUNTIME_CHECK(handler, FrameLength() >= want);
+  RUNTIME_CHECK(handler, Frame()[recordOffsetInFrame_ + *recordLength] == '\n');
+  if (*recordLength > 0 &&
+      Frame()[recordOffsetInFrame_ + *recordLength - 1] == '\r') {
+    --*recordLength;
+  }
 }
 }
diff --git a/runtime/unit.h b/runtime/unit.h
index 62f664b8f32a..b32c2cde74db 100644
--- a/runtime/unit.h
+++ b/runtime/unit.h
@@ -27,6 +27,8 @@
 
 namespace Fortran::runtime::io {
 
+class UnitMap;
+
 class ExternalFileUnit : public ConnectionState,
                          public OpenFile,
                          public FileFrame<ExternalFileUnit> {
@@ -36,19 +38,21 @@ class ExternalFileUnit : public ConnectionState,
 
   static ExternalFileUnit *LookUp(int unit);
   static ExternalFileUnit &LookUpOrCrash(int unit, const Terminator &);
-  static ExternalFileUnit &LookUpOrCreate(int unit, bool *wasExtant = nullptr);
-  static int NewUnit();
-  static void InitializePredefinedUnits();
+  static ExternalFileUnit &LookUpOrCreate(
+      int unit, const Terminator &, bool *wasExtant = nullptr);
+  static ExternalFileUnit *LookUpForClose(int unit);
+  static int NewUnit(const Terminator &);
   static void CloseAll(IoErrorHandler &);
 
   void OpenUnit(OpenStatus, Position, OwningPtr<char> &&path,
       std::size_t pathLength, IoErrorHandler &);
   void CloseUnit(CloseStatus, IoErrorHandler &);
+  void DestroyClosed();
 
   template<typename A, typename... X>
   IoStatementState &BeginIoStatement(X &&... xs) {
-    // TODO: lock().Take() here, and keep it until EndIoStatement()?
-    // Nested I/O from derived types wouldn't work, though.
+    // TODO: Child data transfer statements vs. locking
+    lock_.Take();  // dropped in EndIoStatement()
     A &state{u_.emplace<A>(std::forward<X>(xs)...)};
     if constexpr (!std::is_same_v<A, OpenStatementState>) {
       state.mutableModes() = ConnectionState::modes;
@@ -58,26 +62,47 @@ class ExternalFileUnit : public ConnectionState,
   }
 
   bool Emit(const char *, std::size_t bytes, IoErrorHandler &);
+  std::optional<char32_t> GetCurrentChar(IoErrorHandler &);
   void SetLeftTabLimit();
   bool AdvanceRecord(IoErrorHandler &);
-  bool HandleAbsolutePosition(std::int64_t, IoErrorHandler &);
-  bool HandleRelativePosition(std::int64_t, IoErrorHandler &);
-
+  void BackspaceRecord(IoErrorHandler &);
   void FlushIfTerminal(IoErrorHandler &);
   void EndIoStatement();
+  void SetPosition(std::int64_t pos) {
+    frameOffsetInFile_ = pos;
+    recordOffsetInFrame_ = 0;
+  }
 
 private:
-  bool SetPositionInRecord(std::int64_t, IoErrorHandler &);
+  static UnitMap &GetUnitMap();
+  void NextSequentialUnformattedInputRecord(IoErrorHandler &);
+  void NextSequentialFormattedInputRecord(IoErrorHandler &);
+  void BackspaceSequentialUnformattedRecord(IoErrorHandler &);
+  void BackspaceSequentialFormattedRecord(IoErrorHandler &);
 
   int unitNumber_{-1};
   bool isReading_{false};
+
+  Lock lock_;
+
   // When an I/O statement is in progress on this unit, holds its state.
   std::variant<std::monostate, OpenStatementState, CloseStatementState,
-      ExternalFormattedIoStatementState<false>,
-      ExternalListIoStatementState<false>, UnformattedIoStatementState<false>>
+      ExternalFormattedIoStatementState<Direction::Output>,
+      ExternalFormattedIoStatementState<Direction::Input>,
+      ExternalListIoStatementState<Direction::Output>,
+      ExternalListIoStatementState<Direction::Input>,
+      UnformattedIoStatementState<Direction::Output>,
+      UnformattedIoStatementState<Direction::Input>>
       u_;
-  // Points to the active alternative, if any, in u_, for use as a Cookie
+
+  // Points to the active alternative (if any) in u_ for use as a Cookie
   std::optional<IoStatementState> io_;
+
+  // Subtle: The beginning of the frame can't be allowed to advance
+  // during a single list-directed READ due to the possibility of a
+  // multi-record CHARACTER value with a "r*" repeat count.
+  std::int64_t frameOffsetInFile_{0};
+  std::int64_t recordOffsetInFrame_{0};  // of currentRecordNumber
 };
 
 }
diff --git a/test/Evaluate/reshape.cpp b/test/Evaluate/reshape.cpp
index 1680cf3644b2..db9bee325ef2 100644
--- a/test/Evaluate/reshape.cpp
+++ b/test/Evaluate/reshape.cpp
@@ -9,9 +9,8 @@ using namespace Fortran::runtime;
 int main() {
   static const SubscriptValue ones[]{1, 1, 1};
   static const SubscriptValue sourceExtent[]{2, 3, 4};
-  std::unique_ptr<Descriptor> source{
-      Descriptor::Create(TypeCategory::Integer, sizeof(std::int32_t), nullptr,
-          3, sourceExtent, CFI_attribute_allocatable)};
+  auto source{Descriptor::Create(TypeCategory::Integer, sizeof(std::int32_t),
+      nullptr, 3, sourceExtent, CFI_attribute_allocatable)};
   source->Check();
   MATCH(3, source->rank());
   MATCH(sizeof(std::int32_t), source->ElementBytes());
@@ -25,12 +24,12 @@ int main() {
   MATCH(4, source->GetDimension(2).Extent());
   MATCH(24, source->Elements());
   for (std::size_t j{0}; j < 24; ++j) {
-    *source->Element<std::int32_t>(j * sizeof(std::int32_t)) = j;
+    *source->OffsetElement<std::int32_t>(j * sizeof(std::int32_t)) = j;
   }
 
   static const std::int16_t shapeData[]{8, 4};
   static const SubscriptValue shapeExtent{2};
-  std::unique_ptr<Descriptor> shape{Descriptor::Create(TypeCategory::Integer,
+  auto shape{Descriptor::Create(TypeCategory::Integer,
       static_cast<int>(sizeof shapeData[0]),
       const_cast<void *>(reinterpret_cast<const void *>(shapeData)), 1,
       &shapeExtent, CFI_attribute_pointer)};
@@ -54,15 +53,14 @@ int main() {
   MATCH(2, pad.GetDimension(1).Extent());
   MATCH(3, pad.GetDimension(2).Extent());
 
-  std::unique_ptr<Descriptor> result{RESHAPE(*source, *shape, &pad)};
-
+  auto result{RESHAPE(*source, *shape, &pad)};
   TEST(result.get() != nullptr);
   result->Check();
   MATCH(sizeof(std::int32_t), result->ElementBytes());
   MATCH(2, result->rank());
   TEST(result->type().IsInteger());
   for (std::int32_t j{0}; j < 32; ++j) {
-    MATCH(j, *result->Element<std::int32_t>(j * sizeof(std::int32_t)));
+    MATCH(j, *result->OffsetElement<std::int32_t>(j * sizeof(std::int32_t)));
   }
   for (std::int32_t j{0}; j < 32; ++j) {
     SubscriptValue ss[2]{1 + (j % 8), 1 + (j / 8)};
diff --git a/test/Runtime/CMakeLists.txt b/test/Runtime/CMakeLists.txt
index 239c3f86f52b..905e18e0cea2 100644
--- a/test/Runtime/CMakeLists.txt
+++ b/test/Runtime/CMakeLists.txt
@@ -10,12 +10,17 @@ if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
 endif()
 
+add_library(RuntimeTesting
+  testing.cpp
+)
+
 add_executable(format-test
   format.cpp
 )
 
 target_link_libraries(format-test
   FortranRuntime
+  RuntimeTesting
 )
 
 add_test(Format format-test)
@@ -26,6 +31,7 @@ add_executable(hello-world
 
 target_link_libraries(hello-world
   FortranRuntime
+  RuntimeTesting
 )
 
 add_test(HelloWorld hello-world)
@@ -37,3 +43,14 @@ add_executable(external-hello-world
 target_link_libraries(external-hello-world
   FortranRuntime
 )
+
+add_executable(list-input-test
+  list-input.cpp
+)
+
+target_link_libraries(list-input-test
+  FortranRuntime
+  RuntimeTesting
+)
+
+add_test(ListInput list-input-test)
diff --git a/test/Runtime/format.cpp b/test/Runtime/format.cpp
index 05ec9d3e280b..b00f89c72c1f 100644
--- a/test/Runtime/format.cpp
+++ b/test/Runtime/format.cpp
@@ -1,7 +1,8 @@
 // Tests basic FORMAT string traversal
 
+#include "testing.h"
 #include "../runtime/format-implementation.h"
-#include "../runtime/terminator.h"
+#include "../runtime/io-error.h"
 #include <cstdarg>
 #include <cstring>
 #include <iostream>
@@ -12,20 +13,19 @@ using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 using namespace std::literals::string_literals;
 
-static int failures{0};
 using Results = std::vector<std::string>;
 
 // A test harness context for testing FormatControl
-class TestFormatContext : public Terminator {
+class TestFormatContext : public IoErrorHandler {
 public:
   using CharType = char;
-  TestFormatContext() : Terminator{"format.cpp", 1} {}
+  TestFormatContext() : IoErrorHandler{"format.cpp", 1} {}
   bool Emit(const char *, std::size_t);
   bool Emit(const char16_t *, std::size_t);
   bool Emit(const char32_t *, std::size_t);
   bool AdvanceRecord(int = 1);
-  bool HandleRelativePosition(std::int64_t);
-  bool HandleAbsolutePosition(std::int64_t);
+  void HandleRelativePosition(std::int64_t);
+  void HandleAbsolutePosition(std::int64_t);
   void Report(const DataEdit &);
   void Check(Results &);
   Results results;
@@ -35,17 +35,6 @@ class TestFormatContext : public Terminator {
   MutableModes mutableModes_;
 };
 
-// Override the runtime's Crash() for testing purposes
-[[noreturn]] void Fortran::runtime::Terminator::Crash(
-    const char *message, ...) const {
-  std::va_list ap;
-  va_start(ap, message);
-  char buffer[1000];
-  std::vsnprintf(buffer, sizeof buffer, message, ap);
-  va_end(ap);
-  throw std::string{buffer};
-}
-
 bool TestFormatContext::Emit(const char *s, std::size_t len) {
   std::string str{s, len};
   results.push_back("'"s + str + '\'');
@@ -67,18 +56,16 @@ bool TestFormatContext::AdvanceRecord(int n) {
   return true;
 }
 
-bool TestFormatContext::HandleAbsolutePosition(std::int64_t n) {
+void TestFormatContext::HandleAbsolutePosition(std::int64_t n) {
   results.push_back("T"s + std::to_string(n));
-  return true;
 }
 
-bool TestFormatContext::HandleRelativePosition(std::int64_t n) {
+void TestFormatContext::HandleRelativePosition(std::int64_t n) {
   if (n < 0) {
     results.push_back("TL"s + std::to_string(-n));
   } else {
     results.push_back(std::to_string(n) + 'X');
   }
-  return true;
 }
 
 void TestFormatContext::Report(const DataEdit &edit) {
@@ -104,7 +91,7 @@ void TestFormatContext::Report(const DataEdit &edit) {
 
 void TestFormatContext::Check(Results &expect) {
   if (expect != results) {
-    std::cerr << "expected:";
+    Fail() << "expected:";
     for (const std::string &s : expect) {
       std::cerr << ' ' << s;
     }
@@ -113,7 +100,6 @@ void TestFormatContext::Check(Results &expect) {
       std::cerr << ' ' << s;
     }
     std::cerr << '\n';
-    ++failures;
   }
   expect.clear();
   results.clear();
@@ -127,7 +113,10 @@ static void Test(int n, const char *format, Results &&expect, int repeat = 1) {
     for (int j{0}; j < n; ++j) {
       context.Report(control.GetNextDataEdit(context, repeat));
     }
-    control.FinishOutput(context);
+    control.Finish(context);
+    if (int iostat{context.GetIoStat()}) {
+      context.Crash("GetIoStat() == %d", iostat);
+    }
   } catch (const std::string &crash) {
     context.results.push_back("Crash:"s + crash);
   }
@@ -135,6 +124,7 @@ static void Test(int n, const char *format, Results &&expect, int repeat = 1) {
 }
 
 int main() {
+  StartTests();
   Test(1, "('PI=',F9.7)", Results{"'PI='", "F9.7"});
   Test(1, "(3HPI=F9.7)", Results{"'PI='", "F9.7"});
   Test(1, "(3HPI=/F9.7)", Results{"'PI='", "/", "F9.7"});
@@ -146,5 +136,5 @@ int main() {
   Test(2, "(*('PI=',F9.7,:),'tooFar')",
       Results{"'PI='", "F9.7", "'PI='", "F9.7"});
   Test(1, "(3F9.7)", Results{"2*F9.7"}, 2);
-  return failures > 0;
+  return EndTests();
 }
diff --git a/test/Runtime/hello.cpp b/test/Runtime/hello.cpp
index 4bb65acd565e..88628cecf1ed 100644
--- a/test/Runtime/hello.cpp
+++ b/test/Runtime/hello.cpp
@@ -1,5 +1,6 @@
 // Basic sanity tests of I/O API; exhaustive testing will be done in Fortran
 
+#include "testing.h"
 #include "../../runtime/descriptor.h"
 #include "../../runtime/io-api.h"
 #include <cstring>
@@ -8,16 +9,15 @@
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 
-static int failures{0};
-
-static void test(const char *format, const char *expect, std::string &&got) {
+static bool test(const char *format, const char *expect, std::string &&got) {
   std::string want{expect};
   want.resize(got.length(), ' ');
   if (got != want) {
-    std::cerr << '\'' << format << "' failed;\n     got '" << got
-              << "',\nexpected '" << want << "'\n";
-    ++failures;
+    Fail() << '\'' << format << "' failed;\n     got '" << got
+           << "',\nexpected '" << want << "'\n";
+    return false;
   }
+  return true;
 }
 
 static void hello() {
@@ -30,9 +30,8 @@ static void hello() {
   IONAME(OutputInteger64)(cookie, 0xfeedface);
   IONAME(OutputLogical)(cookie, true);
   if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    std::cerr << "hello: '" << format << "' failed, status "
-              << static_cast<int>(status) << '\n';
-    ++failures;
+    Fail() << "hello: '" << format << "' failed, status "
+           << static_cast<int>(status) << '\n';
   } else {
     test(format, "HELLO, WORLD  678 0xFEEDFACE T",
         std::string{buffer, sizeof buffer});
@@ -46,21 +45,18 @@ static void multiline() {
   SubscriptValue extent[]{4};
   whole.Establish(TypeCode{CFI_type_char}, sizeof buffer[0], &buffer, 1, extent,
       CFI_attribute_pointer);
-  //  whole.Dump(std::cout);
+  whole.Dump();
   whole.Check();
   Descriptor &section{staticDescriptor[1].descriptor()};
   SubscriptValue lowers[]{0}, uppers[]{3}, strides[]{1};
   section.Establish(whole.type(), whole.ElementBytes(), nullptr, 1, extent,
       CFI_attribute_pointer);
-  //  section.Dump(std::cout);
-  section.Check();
   if (auto error{
           CFI_section(&section.raw(), &whole.raw(), lowers, uppers, strides)}) {
-    std::cerr << "multiline: CFI_section failed: " << error << '\n';
-    ++failures;
+    Fail() << "multiline: CFI_section failed: " << error << '\n';
     return;
   }
-  section.Dump(std::cout);
+  section.Dump();
   section.Check();
   const char *format{"('?abcde,',T1,'>',T9,A,TL12,A,TR25,'<'//G0,25X,'done')"};
   auto cookie{IONAME(BeginInternalArrayFormattedOutput)(
@@ -69,9 +65,8 @@ static void multiline() {
   IONAME(OutputAscii)(cookie, "HELLO", 5);
   IONAME(OutputInteger64)(cookie, 789);
   if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    std::cerr << "multiline: '" << format << "' failed, status "
-              << static_cast<int>(status) << '\n';
-    ++failures;
+    Fail() << "multiline: '" << format << "' failed, status "
+           << static_cast<int>(status) << '\n';
   } else {
     test(format,
         ">HELLO, WORLD                  <"
@@ -88,15 +83,41 @@ static void realTest(const char *format, double x, const char *expect) {
       buffer, sizeof buffer, format, std::strlen(format))};
   IONAME(OutputReal64)(cookie, x);
   if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    std::cerr << '\'' << format << "' failed, status "
-              << static_cast<int>(status) << '\n';
-    ++failures;
+    Fail() << '\'' << format << "' failed, status " << static_cast<int>(status)
+           << '\n';
   } else {
     test(format, expect, std::string{buffer, sizeof buffer});
   }
 }
 
+static void realInTest(
+    const char *format, const char *data, std::uint64_t want) {
+  auto cookie{IONAME(BeginInternalFormattedInput)(
+      data, std::strlen(data), format, std::strlen(format))};
+  union {
+    double x;
+    std::uint64_t raw;
+  } u;
+  u.raw = 0;
+  IONAME(EnableHandlers)(cookie, true, true, true, true, true);
+  IONAME(InputReal64)(cookie, u.x);
+  char iomsg[65];
+  iomsg[0] = '\0';
+  iomsg[sizeof iomsg - 1] = '\0';
+  IONAME(GetIoMsg)(cookie, iomsg, sizeof iomsg - 1);
+  auto status{IONAME(EndIoStatement)(cookie)};
+  if (status) {
+    Fail() << '\'' << format << "' failed reading '" << data << "', status "
+           << static_cast<int>(status) << " iomsg '" << iomsg << "'\n";
+  } else if (u.raw != want) {
+    Fail() << '\'' << format << "' failed reading '" << data << "', want 0x"
+           << std::hex << want << ", got 0x" << u.raw << std::dec << '\n';
+  }
+}
+
 int main() {
+  StartTests();
+
   hello();
   multiline();
 
@@ -382,10 +403,22 @@ int main() {
       "4040261841248583680000+306;");
   realTest("(G0,';')", u.d, ".17976931348623157+309;");
 
-  if (failures == 0) {
-    std::cout << "PASS\n";
-  } else {
-    std::cout << "FAIL " << failures << " tests\n";
-  }
-  return failures > 0;
+  realInTest("(F18.0)", "                 0", 0x0);
+  realInTest("(F18.0)", "                  ", 0x0);
+  realInTest("(F18.0)", "                -0", 0x8000000000000000);
+  realInTest("(F18.0)", "                 1", 0x3ff0000000000000);
+  realInTest("(F18.0)", "              125.", 0x405f400000000000);
+  realInTest("(F18.0)", "              12.5", 0x4029000000000000);
+  realInTest("(F18.0)", "              1.25", 0x3ff4000000000000);
+  realInTest("(F18.0)", "              .125", 0x3fc0000000000000);
+  realInTest("(F18.0)", "               125", 0x405f400000000000);
+  realInTest("(F18.1)", "               125", 0x4029000000000000);
+  realInTest("(F18.2)", "               125", 0x3ff4000000000000);
+  realInTest("(F18.3)", "               125", 0x3fc0000000000000);
+  realInTest("(-1P,F18.0)", "               125", 0x4093880000000000);  // 1250
+  realInTest("(1P,F18.0)", "               125", 0x4029000000000000);  // 12.5
+  realInTest("(BZ,F18.0)", "              125 ", 0x4093880000000000);  // 1250
+  realInTest("(DC,F18.0)", "              12,5", 0x4029000000000000);
+
+  return EndTests();
 }
diff --git a/test/Runtime/list-input.cpp b/test/Runtime/list-input.cpp
new file mode 100644
index 000000000000..cb9021e59509
--- /dev/null
+++ b/test/Runtime/list-input.cpp
@@ -0,0 +1,68 @@
+// Basic sanity tests for list-directed input
+
+#include "testing.h"
+#include "../../runtime/descriptor.h"
+#include "../../runtime/io-api.h"
+#include "../../runtime/io-error.h"
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+
+using namespace Fortran::runtime;
+using namespace Fortran::runtime::io;
+
+int main() {
+  StartTests();
+
+  char buffer[4][32];
+  int j{0};
+  for (const char *p : {"1 2 2*3  ,", ",6,,8,123*",
+           "2*'abcdefghijklmnopqrstuvwxyzABC", "DEFGHIJKLMNOPQRSTUVWXYZ'"}) {
+    SetCharacter(buffer[j++], sizeof buffer[0], p);
+  }
+  for (; j < 4; ++j) {
+    SetCharacter(buffer[j], sizeof buffer[0], "");
+  }
+
+  StaticDescriptor<1> staticDescriptor;
+  Descriptor &whole{staticDescriptor.descriptor()};
+  SubscriptValue extent[]{4};
+  whole.Establish(TypeCode{CFI_type_char}, sizeof buffer[0], &buffer, 1, extent,
+      CFI_attribute_pointer);
+  whole.Dump();
+  whole.Check();
+
+  try {
+    auto cookie{IONAME(BeginInternalArrayListInput)(whole)};
+    std::int64_t n[9]{-1, -2, -3, -4, 5, -6, 7, -8, 9};
+    std::int64_t want[9]{1, 2, 3, 3, 5, 6, 7, 8, 9};
+    for (j = 0; j < 9; ++j) {
+      IONAME(InputInteger)(cookie, n[j]);
+    }
+    char asc[2][54]{};
+    IONAME(InputAscii)(cookie, asc[0], sizeof asc[0] - 1);
+    IONAME(InputAscii)(cookie, asc[1], sizeof asc[1] - 1);
+    if (auto status{IONAME(EndIoStatement)(cookie)}) {
+      Fail() << "list-directed input failed, status "
+             << static_cast<int>(status) << '\n';
+    } else {
+      for (j = 0; j < 9; ++j) {
+        if (n[j] != want[j]) {
+          Fail() << "wanted n[" << j << "]==" << want[j] << ", got " << n[j]
+                 << '\n';
+        }
+      }
+      for (j = 0; j < 2; ++j) {
+        if (std::strcmp(asc[j],
+                "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") != 0) {
+          Fail() << "wanted asc[" << j << "]=alphabets, got '" << asc[j]
+                 << "'\n";
+        }
+      }
+    }
+  } catch (const std::string &crash) {
+    Fail() << "crash: " << crash << '\n';
+  }
+
+  return EndTests();
+}
diff --git a/test/Runtime/testing.cpp b/test/Runtime/testing.cpp
new file mode 100644
index 000000000000..5eb86495f0cf
--- /dev/null
+++ b/test/Runtime/testing.cpp
@@ -0,0 +1,43 @@
+#include "testing.h"
+#include "../../runtime/terminator.h"
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <string>
+
+static int failures{0};
+
+// Override the Fortran runtime's Crash() for testing purposes
+[[noreturn]] static void CatchCrash(const char *message, va_list &ap) {
+  char buffer[1000];
+  std::vsnprintf(buffer, sizeof buffer, message, ap);
+  va_end(ap);
+  throw std::string{buffer};
+}
+
+void StartTests() {
+  Fortran::runtime::Terminator::RegisterCrashHandler(CatchCrash);
+}
+
+std::ostream &Fail() {
+  ++failures;
+  return std::cerr;
+}
+
+int EndTests() {
+  if (failures == 0) {
+    std::cout << "PASS\n";
+  } else {
+    std::cout << "FAIL " << failures << " tests\n";
+  }
+  return failures != 0;
+}
+
+void SetCharacter(char *to, std::size_t n, const char *from) {
+  auto len{std::strlen(from)};
+  std::memcpy(to, from, std::min(len, n));
+  if (len < n) {
+    std::memset(to + len, ' ', n - len);
+  }
+}
diff --git a/test/Runtime/testing.h b/test/Runtime/testing.h
new file mode 100644
index 000000000000..9571a34825dc
--- /dev/null
+++ b/test/Runtime/testing.h
@@ -0,0 +1,13 @@
+#ifndef FORTRAN_TEST_RUNTIME_TESTING_H_
+#define FORTRAN_TEST_RUNTIME_TESTING_H_
+
+#include <cstddef>
+#include <iosfwd>
+
+void StartTests();
+std::ostream &Fail();
+int EndTests();
+
+void SetCharacter(char *, std::size_t, const char *);
+
+#endif  // FORTRAN_TEST_RUNTIME_TESTING_H_
diff --git a/test/Semantics/call15.f90 b/test/Semantics/call15.f90
index 204a0e6c6237..ca935b91530f 100644
--- a/test/Semantics/call15.f90
+++ b/test/Semantics/call15.f90
@@ -7,7 +7,7 @@ subroutine s(arg1, arg2, arg3)
 
   call inner(arg1) ! OK, assumed rank
   call inner(arg2) ! OK, assumed shape
-  !ERROR: Assumed-type TYPE(*) 'arg3' must be either assumed shape or assumed rank to be associated with TYPE(*) dummy argument 'dummy='
+  !ERROR: Assumed-type 'arg3' must be either assumed shape or assumed rank to be associated with assumed-type dummy argument 'dummy='
   call inner(arg3)
 
     contains

From 30b428a51e140e5fb12bd53a0619f10ff510f408 Mon Sep 17 00:00:00 2001
From: jeanPerier <jeanPerier@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:47:22 -0700
Subject: [PATCH 078/345] Add Fortran IR (FIR) MLIR dialect implementation
 (#1035)

Adds FIR library that implements an MLIR dialect to which Fortran
parse-tree will be lowered to.

FIR is defined and documented inside FIROps.td added in this commit.
It is possible to generate a more readable description FIRLangRef.md
from FIROps.td following the related instructions added to the README.md
by this commit.

This patch adds FIR definition and implementation that allow parsing,
printing, and verifying FIR. FIR transformations and lowering to Standard
and LLVM dialects are not part of this patch. The FIR verifiers are verifying
the basic properties of FIR operations in order to provide a sufficient
frame for lowering. Verifiers for more advanced FIR properties can be added
as needed.

Coarrays are not covered by FIR defined in this patch.

This patch also adds tco tool that is meant to process FIR input files and
drives transformations on it. The tco tool is used for testing.
In this patch, it is only used to demonstrate parsing/verifying/
and dumping FIR with round-trip tests.

Note:
This commit does not reflect an actual work log, it is a feature-based split of the
changes done in the FIR experimental branch. The related work log can be found in the
commits between:

https://github.com/schweitzpgi/f18/commit/742edde572bd74d77cf7d447132ccf0949187fce
and
https://github.com/schweitzpgi/f18/commit/2ff55242126d86061f4fed9ef7b59d3636b5fd0b

Changes on top of these original commits were made during this patch review.
---
 .drone.star                                   |   16 +-
 CMakeLists.txt                                |    9 +
 README.md                                     |   55 +
 .../Investigating-FIR-as-an-MLIR-dialect.md   |  413 ---
 include/fir/.clang-format                     |    2 -
 include/flang/CMakeLists.txt                  |   11 +-
 include/flang/Optimizer/CMakeLists.txt        |    1 +
 .../flang/Optimizer/Dialect/CMakeLists.txt    |   22 +
 include/flang/Optimizer/Dialect/FIRAttr.h     |  166 +
 include/flang/Optimizer/Dialect/FIRDialect.h  |   92 +
 include/flang/Optimizer/Dialect/FIROps.h      |   47 +
 include/flang/Optimizer/Dialect/FIROps.td     | 2747 +++++++++++++++++
 .../flang/Optimizer/Dialect/FIROpsSupport.h   |   63 +
 include/flang/Optimizer/Dialect/FIRType.h     |  399 +++
 include/flang/Optimizer/Support/KindMapping.h |   90 +
 lib/CMakeLists.txt                            |    4 +
 lib/Fir/.clang-format                         |    2 -
 lib/Optimizer/CMakeLists.txt                  |    5 +
 lib/Optimizer/Dialect/CMakeLists.txt          |   27 +
 lib/Optimizer/Dialect/FIRAttr.cpp             |  238 ++
 lib/Optimizer/Dialect/FIRDialect.cpp          |   54 +
 lib/Optimizer/Dialect/FIROps.cpp              |  862 ++++++
 lib/Optimizer/Dialect/FIRType.cpp             | 1292 ++++++++
 lib/Optimizer/Support/CMakeLists.txt          |   10 +
 lib/Optimizer/Support/KindMapping.cpp         |  244 ++
 test-lit/CMakeLists.txt                       |    5 +
 test-lit/Fir/fir-ops.fir                      |  403 +++
 test-lit/Fir/fir-types.fir                    |   78 +
 test-lit/lit.cfg.py                           |    8 +-
 test-lit/lit.site.cfg.py.in                   |    1 +
 tools/CMakeLists.txt                          |    4 +-
 tools/tco/CMakeLists.txt                      |   24 +
 tools/tco/tco.cpp                             |  113 +
 33 files changed, 7072 insertions(+), 435 deletions(-)
 delete mode 100644 documentation/Investigating-FIR-as-an-MLIR-dialect.md
 delete mode 100644 include/fir/.clang-format
 create mode 100644 include/flang/Optimizer/CMakeLists.txt
 create mode 100644 include/flang/Optimizer/Dialect/CMakeLists.txt
 create mode 100644 include/flang/Optimizer/Dialect/FIRAttr.h
 create mode 100644 include/flang/Optimizer/Dialect/FIRDialect.h
 create mode 100644 include/flang/Optimizer/Dialect/FIROps.h
 create mode 100644 include/flang/Optimizer/Dialect/FIROps.td
 create mode 100644 include/flang/Optimizer/Dialect/FIROpsSupport.h
 create mode 100644 include/flang/Optimizer/Dialect/FIRType.h
 create mode 100644 include/flang/Optimizer/Support/KindMapping.h
 delete mode 100644 lib/Fir/.clang-format
 create mode 100644 lib/Optimizer/CMakeLists.txt
 create mode 100644 lib/Optimizer/Dialect/CMakeLists.txt
 create mode 100644 lib/Optimizer/Dialect/FIRAttr.cpp
 create mode 100644 lib/Optimizer/Dialect/FIRDialect.cpp
 create mode 100644 lib/Optimizer/Dialect/FIROps.cpp
 create mode 100644 lib/Optimizer/Dialect/FIRType.cpp
 create mode 100644 lib/Optimizer/Support/CMakeLists.txt
 create mode 100644 lib/Optimizer/Support/KindMapping.cpp
 create mode 100644 test-lit/Fir/fir-ops.fir
 create mode 100644 test-lit/Fir/fir-types.fir
 create mode 100644 tools/tco/CMakeLists.txt
 create mode 100644 tools/tco/tco.cpp

diff --git a/.drone.star b/.drone.star
index 5bbe018cd056..27ff72e911cf 100644
--- a/.drone.star
+++ b/.drone.star
@@ -8,13 +8,13 @@ def clang(arch):
                 "image": "ubuntu",
                 "commands": [
                     "apt-get update && apt-get install -y clang-8 cmake ninja-build lld-8 llvm-8-dev libc++-8-dev libc++abi-8-dev libz-dev git",
-                    "git clone https://github.com/llvm/llvm-project",
+                    "git clone --depth=1 -b f18 https://github.com/flang-compiler/f18-llvm-project.git llvm-project",
                     "mkdir llvm-project/build && cd llvm-project/build",
-                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="mlir" ../llvm',
-                    "ninja",
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_INSTALL_UTILS=On -DLLVM_ENABLE_PROJECTS="mlir" ../llvm',
+                    "ninja install",
                     "cd ../..",
                     "mkdir build && cd build",
-                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/build/lib/cmake/llvm',
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
                     "ninja -j8",
                     "ctest --output-on-failure -j24",
                     "ninja check-all",
@@ -34,13 +34,13 @@ def gcc(arch):
                     "image": "gcc",
                     "commands": [
 			"apt-get update && apt-get install -y cmake ninja-build llvm-dev libz-dev git",
-		        "git clone https://github.com/llvm/llvm-project",
+                        "git clone --depth=1 -b f18 https://github.com/flang-compiler/f18-llvm-project.git llvm-project",
 		        "mkdir llvm-project/build && cd llvm-project/build",
-		        'env CC=gcc CXX=g++ LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_ENABLE_PROJECTS="mlir" ../llvm',
-                        "ninja",
+		        'env CC=gcc CXX=g++ LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../install -DLLVM_TARGETS_TO_BUILD=host -DLLVM_INSTALL_UTILS=On -DLLVM_ENABLE_PROJECTS="mlir" ../llvm',
+                        "ninja install",
                         "cd ../..",
                         "mkdir build && cd build",
-                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/build/lib/cmake/llvm',
+                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
                         "ninja -j8",
                         "ctest --output-on-failure -j24",
                         "ninja check-all",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f293762cd2ea..97a03ee4a9a3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,6 +88,15 @@ add_definitions(${LLVM_DEFINITIONS})
 set(LLVM_EXTERNAL_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit CACHE STRING "Command used to spawn lit")
 
 if(LINK_WITH_FIR)
+  include(TableGen)
+  include(AddMLIR)
+  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
+  NO_DEFAULT_PATH)
+  # tco tool and FIR lib output directories
+  set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
+  set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
+  # Always build tco tool
+  set(LLVM_BUILD_TOOLS ON)
   message(STATUS "Linking driver with FIR and LLVM")
   llvm_map_components_to_libnames(LLVM_COMMON_LIBS support)
   message(STATUS "LLVM libraries: ${LLVM_COMMON_LIBS}")
diff --git a/README.md b/README.md
index d0887a305a14..9df131d7f325 100644
--- a/README.md
+++ b/README.md
@@ -82,6 +82,55 @@ LLVM=<LLVM_BUILD_DIR>/lib/cmake/llvm cmake -DLLVM_DIR=$LLVM ...
 where `LLVM_BUILD_DIR` is
 the top-level directory where LLVM was built.
 
+### LLVM dependency when building f18 with Fortran IR
+
+If you do not want to build Fortran IR, add `-DLINK_WITH_FIR=Off` to f18 cmake
+command and ignore the rest of this section.
+
+If you intend to build f18 with Fortran IR (`-DLINK_WITH_FIR` On by default),
+you must:
+- build LLVM with the same compiler and options as the one you are using
+to build F18.
+- pass `-DCMAKE_CXX_STANDARD=17 -DLLVM_ENABLE_PROJECTS="mlir"`
+to LLVM cmake command.
+- install LLVM somewhere with `make install` in order to get the required
+AddMLIR cmake file (it is not generated in LLVM build directory).
+
+Installing LLVM from packages is most likely not an option as it will not include
+MLIR and not be built following C++17 standard.
+
+MLIR is under active development and the most recent development version
+may be incompatible. A branch named `f18` is available inside LLVM fork in
+https://github.com/flang-compiler/f18-llvm-project. It contains a version of LLVM
+that is known be compatible to build f18 with FIR.
+
+The fastest way to get set up is to do:
+
+```
+cd where/you/want/to/build/llvm
+git clone --depth=1 -b f18 https://github.com/flang-compiler/f18-llvm-project.git
+mkdir build
+mkdir install
+cd build
+cmake ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release \
+    -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 \
+    -DLLVM_INSTALL_UTILS=On \
+    -DCMAKE_INSTALL_PREFIX=../install
+make
+make install
+```
+
+Then, `-DLLVM_DIR` would have to be set to
+ `<where/you/want/to/build/llvm>/install/lib/cmake/llvm` in f18 cmake command.
+
+To run lit tests,
+`-DLLVM_EXTERNAL_LIT=<where/you/want/to/build/llvm>/build/bin/llvm-lit` must be
+added to f18 cmake command. This is because `llvm-lit` is not part of
+LLVM installation.
+
+Note that when using some advanced options from f18 cmake file it may be
+necessary to reproduce their effects in LLVM cmake command.
+
 ### Building f18 with GCC
 
 By default,
@@ -187,3 +236,9 @@ flang_site_config and flang_config. And they can be set as shown bellow:
  --param flang_config=<path-to-f18-build>/test-lit/lit.cfg.py \
   <path-to-fortran-test>
 ```
+
+# How to Generate FIR Documentation
+
+If f18 was built with `-DLINK_WITH_FIR=On` (`On` by default), it is possible to
+generate FIR language documentation by running `make flang-doc`. This will
+create `docs/Dialect/FIRLangRef.md` in f18 build directory.
diff --git a/documentation/Investigating-FIR-as-an-MLIR-dialect.md b/documentation/Investigating-FIR-as-an-MLIR-dialect.md
deleted file mode 100644
index 79809cd4c1f0..000000000000
--- a/documentation/Investigating-FIR-as-an-MLIR-dialect.md
+++ /dev/null
@@ -1,413 +0,0 @@
-<!--===- documentation/Investigating-FIR-as-an-MLIR-dialect.md 
-  
-   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
-  
--->
-
-# Investigating FIR as an MLIR Dialect
-
-## Introduction
-
-With the availability of the extensible MLIR framework as
-open-source, we've been investigating the potential to use MLIR as
-a substrate upon which to build a FIR dialect. This document will
-explain the motivations and the shape of this subproject using MLIR
-to define and implement a high-level operational representation of
-Fortran. (See also [Design: Fortran IR](https://bit.ly/2WWRus0)
-for more information.)
-
-### What is MLIR?
-
-The MLIR project is an open-sourced project on Github.
-[MLIR](https://github.com/tensorflow/mlir) is being built as a
-common multi-level intermediate representation (IR) for the
-TensorFlow machine learning tools. It provides a common IR
-framework for building multiple layers of representation called
-dialects. These dialects can be transformed (converted) from one to
-another allowing for optimizations and successive lowering of the
-IR down to backend code generators. MLIR supports multiple backends. The
-LLVM IR dialect is a pre-defined MLIR dialect
-that can be targeted
-for final code generation using the LLVM library and/or tools.
-MLIR is explicitly intended to be extensible such that
-other projects can add their own dialects.
-
-Out of the box, MLIR supports a refined polyhedral model for
-transforming affine operations on array data. These mathematically-based
-representations will help realize F18's higher level goals of composing,
-transforming, and optimizing Fortran array operations for HPC.
-
-### What is meant by a FIR dialect?
-
-MLIR has no support for Fortran out of the box. Support for Fortran must
-be built and added through the extensibility features of MLIR. This
-process of extending MLIR is called adding a dialect. In our case, we'll
-add a FIR dialect for representation of Fortran programs.
-
-Specifically, this means that we can proceed with the plan as laid out
-in the Fortran IR design document with the advantages of not having to
-build from scratch our own
-
--    IR infrastructure    
--    LLVM IR bridge  
--    Common optimization passes (For example: CSE, DCE, loop fusion, loop
-     invariant code motion, loop tiling, loop unroll and jam, loop
-     unrolling, vectorization, etc.)
-    
-A dialect can be thought of
-as its own distinct IR, where the design and
-semantics of the IR are domain-specific for the purposes of the
-dialect. Specifically, MLIR supports a modern IR design with
-
--    A predefined set of operations with precise semantics
--    Structural/logical grouping of sets of operations
--    Explicit control flow
--    Explicit data-flow
--    Strong typing
-
--    Meta information
-
-     Informally, one can construct MLIR operations that are
-     conceptually composable containers. These containers can have
-     strongly typed metadata attached to them that can describe
-     any properties of interest. For example, one can define an
-     operation called "execute" and define it to have an attribute
-     "order", which may have a value that describes a sequential
-     execution order, a fully parallel unordered execution, or some
-     valid execution partial ordering. What meta information is
-     interesting depends on the context and is up to the MLIR user.
-
-This document describes FIR, which is a set of extensions upon the
-standard MLIR dialect. When lowering a Fortran parse tree to FIR,
-the compiler will produce a mix of operations defined in the FIR
-dialect, the MLIR __standard dialect__, and other pre-defined
-dialects, such as the [affine dialect](https://bit.ly/2XYDPNj).
-
-#### Disclaimers
-
-This document is not a tutorial on compilers, Fortran, MLIR, LLVM,
-intermediate representations, abstraction levels, semantics, nor type
-theory.
-
-## Requirements Unchanged
-
-The FIR dialect has the same requirements as spelled out in the
-Fortran IR design document. Specifically, the FIR dialect will
-capture the control flow structure of the Fortran source-level
-program. At the highest level of abstraction, Fortran computations
-will be captured as coarse-grain opaque
-operations corresponding to Fortran expressions
-(with links to `Fortran::evaluate::Expr<T>` objects from the
-front-end), where only the peripheral use-def information is
-exposed. These operations will, of course, necessarily be lowered
-to other various MLIR dialects, where they can be
-optimized.
-The compiler will continue to lower the representation
-of the input with successive transformations
-to MLIR's LLVM IR dialect, the target independent LLVM IR, machine
-IR, and eventually assembly and/or machine code.
-
-## Details
-
-Because MLIR is our adopted framework, our bridge to the FIR
-dialect of MLIR will use the concepts, libraries, coding
-conventions, etc. of the MLIR project. This means some of the class
-names will necessarily be changed from the original FIR design. For
-example, `Program` becomes `Module`, `Procedure` becomes
-`Function`, `BasicBlock` becomes `Block`, and `Statement` becomes
-`Operation`.
-
-Construction of the CFG structure reuses the original FIR pass that
-flattens and linearizes the Fortran parse tree structure prior to
-creating the FIR dialect of MLIR.
-
-`Afforestation` (a class in the original FIR code)
-of the FIR dialect tree structure has to be rewritten
-as the original framework is replaced by that of
-MLIR. Conceptually, the process and objective remains the same.
-
-### FIR Dialect Details
-
-The FIR dialect is a well-defined set of operations, types, etc. that
-captures the executable semantics and state of a correctly specified
-Fortran program. In Fortran, action statements [Fortran 2018 R515] and
-certain constructs specify the behavior of the program. Among these,
-Fortran expressions [Fortran 2018 Clause 10.1] are intrinsic to the
-computation of new values.
-
-#### FIR Operations
-
-Abstract expression operations are higher-level operations that are
-opaque computations in FIR. FIR does not know the exact computations
-involved. However, the framework requires explicit representation of how
-each operation interacts with others in terms of control flow,
-data-flow, and the types of its operands and results. These operations
-must then be lowered to sequences of operations as required by the
-standard MLIR dialect, the LLVM IR dialect, etc.
-
-##### Expression ops
-
-The following lists the FIR abstract expression operations:
-
-+    _Apply_Expr_
-
-     This operation computes a (set of) value(s) by applying an abstract
-     expression to a set of SSA input values.
-
-     As well as its input values and type, an Apply_Expr takes two
-     attributes that serve to bind the exact opaque expression from the
-     front-end. The first attribute is the expression as recovered from
-     the parse tree. The second attribute is a dictionary that maps the
-     incoming values to positions in the expression representation,
-     allowing values to bind to nodes in the expression.
-
-+    _Locate_Expr_
-
-     This operation computes a (set of) memory reference(s) by applying
-     an abstract expression to a set of SSA input values.
-
-     Exactly analogous to Apply_Expr, this operation also takes two
-     attributes to capture the expression from the front-end and to bind
-     arguments to nodes in the expression tree.
-
-+    _Alloca_Expr_
-
-     This operation allocates a temporary object of some specified
-     type. The resulting object is undefined. It must be explicitly
-     initialized with subsequent operations.
-
-+    _Undefined_
-
-     This operation yields the canonical undefined value of some
-     type. This operation lowers to the undef instruction in LLVM IR. It
-     is required for construction of register SSA form when load
-     operations load uninitialized values.
-
-+    _Load_Expr_
-
-     This operation promotes a reference to a Fortran object (for
-     example, the result of a Locate_Expr operation) to an object value
-     irrespective of type. It takes one argument, a reference to an
-     abstract storage location.
-
-     Recall that the abstract expression operations listed here operate
-     on and produce SSA values. (Specifically, they are abstract
-     operations with precise control- and data-flow constraints.)
-
-+    _Store_Expr_
-
-     This operation demotes a value to a reference to an object. It
-     takes two arguments: both a value and a reference to an abstract
-     storage location (for example, the result of a Global_Expr
-     operation) of the same type.
-
-##### Control flow ops
-
-Fortran has a number of mechanisms for specifying control flow, both
-structured (DO ... END DO) and unstructured (GOTO). Many of these can be
-directly lowered to the standard dialect's branch and conditional branch
-operations.
-
-There are a handful of multiway branch constructs to consider and these
-will be modeled as FIR (terminator) operations. The framework supports a
-generic terminator pattern operation. Specifically, a terminator is just
-an operation but it is augmented with successors (references to basic
-blocks) and successor arguments (for correct SSA form).
-
-+    _Select_
-
-     Terminator operation for switching based on the return value of,
-     for example, an I/O action.
-
-+    _Select_Case_
-
-     Terminator operation for switching on the value of an expression.
-
-+    _Select_Rank_
-
-     Terminator operation for switching on the rank attribute of an
-     object. Must be lowered to the requisite operations on the object's
-     descriptor (which shall assumably contain the rank, dimension,
-     type, etc. of the Fortran object).
-
-+    _Select_Type_
-
-     Terminator operation for switching on the type of an object. Must
-     be lowered to the requisite operations on the object's type
-     descriptor (which shall contain the encoded type of the Fortran
-     object).
-
-+    _Unreachable_
-
-     This operation is a terminator on a Block and indicates that
-     control flow cannot reach this point. This happens when lowering
-     Fortran's [ERROR] STOP statement into a runtime call. It is lowered
-     into the LLVM IR as an unreachable instruction.
-
-For now, indirect branches (such as computed GOTO statements), will be
-lowered by mapping target blocks into an indirect index value used in a
-small chain of conditional branches. This could be changed to use the
-standard dialect indirect branch op, however.
-
-The standard dialect of MLIR supports calling procedures in full
-generality -- that is, both function calls in expressions and CALL
-statements to subroutines. Both cases will be lowered explicitly into
-FIR using the standard dialect CallOp operation. The call operation is
-an abstract application of a (presumably) opaque set of computations on
-the SSA input values that produces a (set of) SSA result
-value(s). (Semantically, a CallOp is a named morphism like the anonymous
-ApplyExpr or LocateExpr.)
-
-##### Miscellaneous ops
-
-The presence of certain attributes on specific objects allow for dynamic
-allocation and deallocation of those objects. These allocations and
-deallocations can be explicit through the ALLOCATE and DEALLOCATE
-statements or can be implied via side-effect. Dynamic allocation and
-deallocation are modeled with FIR operations. It should be pointed out
-that MLIR does not, at present, have a standard way of expressing an
-object that has process lifetime (that is, "global" data like COMMON
-blocks and MODULE variables) that is not a function. This is implemented
-with the Global_Expr operation below.
-
-+    _Allocmem_
-
-     This operation allocates an object of a specified type and returns
-     a reference to it. The object's lifetime is dynamic/indefinite and
-     limited to a matching FreememOp operation that deallocates it. No
-     side-effect behaviors are implied. Initialization of the object
-     must be done explicitly in subsequent FIR operations.
-
-+    _Freemem_
-
-     This operation deallocates an object via a Fortran reference. Any
-     use of the reference in subsequent code is undefined
-     behavior. There are no implicit behaviors, so finalizers must be
-     lowered explicitly into FIR.
-
-+    _Global_Expr_
-
-     This operation is a placeholder for a reference to an object in a
-     storage location that has process lifetime (a global variable). It
-     must have a type and a symbol name for binding at link-time.
-
-+    _Extract_Value_
-
-     This operation is similar to LLVM's `extractvalue` instruction.
-     It allows the
-     extraction of a value from a composite structure, such as a
-     standard tuple.
-
-+    _Insert_Value_
-
-     The operation allows the insertion of a value into a composite
-     structure, such as a standard tuple.
-
-+    _Field_Value_
-
-     This operation computes the offset of a component of a derived type
-     for use in ExtractValue or InsertValue operations.
-
-A number of Fortran action statements/constructs are related to
-synchronization/threading. (e.g., LOCK, UNLOCK, EVENT POST, DO
-CONCURRENT, co-arrays, etc.). The current plan is not to model these
-parallel execution semantics directly in FIR, but to lower these
-synchronization and threading statements to Fortran runtime calls. The
-implicit message passing semantics of co-arrays can be lowered to
-explicit calls as well, though the exact API is TBD.
-
-#### FIR Types
-
-Some Fortran intrinsic types are familiar and map well to MLIR standard
-types. (e.g., `INTEGER*k`, `REAL*k`, and `COMPLEX*k`.)
-However, the intrinsic
-type `CHARACTER*k(LEN=n)` has no analog. Finally, the intrinsic type
-`LOGICAL*k` and derived (user-defined) types should not be prematurely
-lowered to standard MLIR types because that may inhibit optimization and
-add complexity. (e.g., one could lower a `LOGICAL*`1 type to the standard
-`i8` type, but then it would have the same type as `INTEGER*1` and,
-depending on its usage, may have better been lowered to `i1`.)
-
-In addition to types from the surface syntax of Fortran, it is
-beneficial to introduce metatypes to FIR to capture Fortran attribute
-properties that alter the underlying object in an operational
-sense. Specifically, attributes such as `DIMENSION`, `CODIMENSION`, and
-`POINTER`, alter the size, behavior, and accepted use of a variable but
-not its type (in the Fortran sense).
-
-The additional FIR types are as follows.
-
-+    __FIRCharacterType__
-
-     The Fortran intrinsic type CHARACTER with a kind value. This is
-     meant to represent the constant-sized memory reference and is
-     intentionally distinct from, for instance, an array of byte-sized
-     integers. The LEN parameter of a CHARACTER should be represented as
-     a second integer member in a FIR tuple type. Concretely, a Fortran
-     CHARACTER type is lowered into a pair:
-
-     `(FIRReferenceType<FIRCharacterType<K>>, Integer<K'>)`
-
-+    __FIRLogicalType__
-
-     The Fortran intrinsic type LOGICAL with a kind value.
-
-+    __FIRRealType__
-
-     The Fortran intrinsic type REAL with kind values (e.g., KIND=16)
-     that do not map to standard MLIR.
-
-+    __FIRReferenceType__
-
-     The Fortran concept of "reference". Actual arguments are typically
-     passed as references to objects of some type, for example. All
-     objects that reside in memory are accessible via reference types.
-
-+    __FIRSequenceType__
-
-     The Fortran concept of an object with rank > 0. Fortran does not
-     have an array type, but FIR characterizes objects with rank as
-     sequences of their base type.
-
-     In lowering a Fortran array object, the dimensions and extents of
-     the array may not be known at compile time, and therefore may need
-     to be lowered to a tuple type that describes the array's structure
-     (rank, type, dimension information, other attributes).
-
-+    __FIRTupleType__
-
-     Fortran derived types naturally map to tuples. Can be used to build
-     other type packages as well, such as Fortran's CHARACTER type with
-     its LEN parameter, array object structure descriptors, etc. Each
-     distinct tuple type has a unique name and a run-time encoding, the
-     type descriptor. (Note: any subtyping relationships between derived
-     types must be established by and lowered from the front-end.)
-
-+    __FIRTypeDesc__
-
-     The meta-type of all type descriptors. An instance of a type
-     descriptor is a constant object that encodes a Fortran (intrinsic,
-     derived) type for use by the runtime, etc. This type is
-     speculative, as it may be (more) satisfactory to encode a type
-     descriptor as a simple dope vector sequence.
-
-### Changes from Original Document
-
-Procedure calls will be unwrapped from Fortran expressions and lowered
-into FIR dialect calls to expose control flow.
-
-These computations will be presented in a memory-based SSA format, where
-memory objects will be referenced via special operation forms.
-
-There will be a pass to lower
-the memory-based SSA form to a
-register-based (proper) SSA form. There will be no
-&Phi; nodes.
-
-There will be no scope enter, scope exit pairs.
-
-There will be a pass to lower the FIR dialect to the MLIR standard
-dialect and/or LLVM IR dialect.
-
diff --git a/include/fir/.clang-format b/include/fir/.clang-format
deleted file mode 100644
index a74fda4b6734..000000000000
--- a/include/fir/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-BasedOnStyle: LLVM
-AlwaysBreakTemplateDeclarations: Yes
diff --git a/include/flang/CMakeLists.txt b/include/flang/CMakeLists.txt
index 7fae707bdc46..db5d26a83b56 100644
--- a/include/flang/CMakeLists.txt
+++ b/include/flang/CMakeLists.txt
@@ -1,8 +1,3 @@
-#===-- include/flang/CMakeLists.txt ----------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
+if(LINK_WITH_FIR)
+  add_subdirectory(Optimizer)
+endif()
diff --git a/include/flang/Optimizer/CMakeLists.txt b/include/flang/Optimizer/CMakeLists.txt
new file mode 100644
index 000000000000..0ca0f41c5af4
--- /dev/null
+++ b/include/flang/Optimizer/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(Dialect)
diff --git a/include/flang/Optimizer/Dialect/CMakeLists.txt b/include/flang/Optimizer/Dialect/CMakeLists.txt
new file mode 100644
index 000000000000..f83cb8f522a3
--- /dev/null
+++ b/include/flang/Optimizer/Dialect/CMakeLists.txt
@@ -0,0 +1,22 @@
+# This replicates part of the add_mlir_dialect cmake function from MLIR that
+# cannot be used her because it expects to be run inside MLIR directory which
+# is not the case for FIR.
+set(LLVM_TARGET_DEFINITIONS FIROps.td)
+mlir_tablegen(FIROps.h.inc -gen-op-decls)
+mlir_tablegen(FIROps.cpp.inc -gen-op-defs)
+add_public_tablegen_target(FIROpsIncGen)
+
+add_custom_target(flang-doc)
+set(dialect_doc_filename "FIRLangRef")
+
+set(LLVM_TARGET_DEFINITIONS FIROps.td)
+tablegen(MLIR ${dialect_doc_filename}.md -gen-op-doc "-I${MLIR_MAIN_SRC_DIR}" "-I${MLIR_INCLUDE_DIR}")
+set(GEN_DOC_FILE ${FLANG_BINARY_DIR}/docs/Dialect/${dialect_doc_filename}.md)
+add_custom_command(
+        OUTPUT ${GEN_DOC_FILE}
+        COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md
+                ${GEN_DOC_FILE}
+        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md)
+add_custom_target(${dialect_doc_filename}DocGen DEPENDS ${GEN_DOC_FILE})
+add_dependencies(flang-doc ${dialect_doc_filename}DocGen)
diff --git a/include/flang/Optimizer/Dialect/FIRAttr.h b/include/flang/Optimizer/Dialect/FIRAttr.h
new file mode 100644
index 000000000000..57ce5f13bf65
--- /dev/null
+++ b/include/flang/Optimizer/Dialect/FIRAttr.h
@@ -0,0 +1,166 @@
+//===-- Optimizer/Dialect/FIRAttr.h -- FIR attributes -----------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_DIALECT_FIRATTR_H
+#define OPTIMIZER_DIALECT_FIRATTR_H
+
+#include "mlir/IR/Attributes.h"
+
+namespace mlir {
+class DialectAsmParser;
+class DialectAsmPrinter;
+} // namespace mlir
+
+namespace fir {
+
+class FIROpsDialect;
+
+namespace detail {
+struct RealAttributeStorage;
+struct TypeAttributeStorage;
+} // namespace detail
+
+enum AttributeKind {
+  FIR_ATTR = mlir::Attribute::FIRST_FIR_ATTR,
+  FIR_EXACTTYPE, // instance_of, precise type relation
+  FIR_SUBCLASS,  // subsumed_by, is-a (subclass) relation
+  FIR_POINT,
+  FIR_CLOSEDCLOSED_INTERVAL,
+  FIR_OPENCLOSED_INTERVAL,
+  FIR_CLOSEDOPEN_INTERVAL,
+  FIR_REAL_ATTR,
+};
+
+class ExactTypeAttr
+    : public mlir::Attribute::AttrBase<ExactTypeAttr, mlir::Attribute,
+                                       detail::TypeAttributeStorage> {
+public:
+  using Base::Base;
+  using ValueType = mlir::Type;
+
+  static constexpr llvm::StringRef getAttrName() { return "instance"; }
+  static ExactTypeAttr get(mlir::Type value);
+
+  mlir::Type getType() const;
+
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_EXACTTYPE; }
+};
+
+class SubclassAttr
+    : public mlir::Attribute::AttrBase<SubclassAttr, mlir::Attribute,
+                                       detail::TypeAttributeStorage> {
+public:
+  using Base::Base;
+  using ValueType = mlir::Type;
+
+  static constexpr llvm::StringRef getAttrName() { return "subsumed"; }
+  static SubclassAttr get(mlir::Type value);
+
+  mlir::Type getType() const;
+
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_SUBCLASS; }
+};
+
+// Attributes for building SELECT CASE multiway branches
+
+/// A closed interval (including the bound values) is an interval with both an
+/// upper and lower bound as given as ssa-values.
+/// A case selector of `CASE (n:m)` corresponds to any value from `n` to `m` and
+/// is encoded as `#fir.interval, %n, %m`.
+class ClosedIntervalAttr
+    : public mlir::Attribute::AttrBase<ClosedIntervalAttr> {
+public:
+  using Base::Base;
+
+  static constexpr llvm::StringRef getAttrName() { return "interval"; }
+  static ClosedIntervalAttr get(mlir::MLIRContext *ctxt);
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() {
+    return AttributeKind::FIR_CLOSEDCLOSED_INTERVAL;
+  }
+};
+
+/// An upper bound is an open interval (including the bound value) as given as
+/// an ssa-value.
+/// A case selector of `CASE (:m)` corresponds to any value up to and including
+/// `m` and is encoded as `#fir.upper, %m`.
+class UpperBoundAttr : public mlir::Attribute::AttrBase<UpperBoundAttr> {
+public:
+  using Base::Base;
+
+  static constexpr llvm::StringRef getAttrName() { return "upper"; }
+  static UpperBoundAttr get(mlir::MLIRContext *ctxt);
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() {
+    return AttributeKind::FIR_OPENCLOSED_INTERVAL;
+  }
+};
+
+/// A lower bound is an open interval (including the bound value) as given as
+/// an ssa-value.
+/// A case selector of `CASE (n:)` corresponds to any value down to and
+/// including `n` and is encoded as `#fir.lower, %n`.
+class LowerBoundAttr : public mlir::Attribute::AttrBase<LowerBoundAttr> {
+public:
+  using Base::Base;
+
+  static constexpr llvm::StringRef getAttrName() { return "lower"; }
+  static LowerBoundAttr get(mlir::MLIRContext *ctxt);
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() {
+    return AttributeKind::FIR_CLOSEDOPEN_INTERVAL;
+  }
+};
+
+/// A pointer interval is a closed interval as given as an ssa-value. The
+/// interval contains exactly one value.
+/// A case selector of `CASE (p)` corresponds to exactly the value `p` and is
+/// encoded as `#fir.point, %p`.
+class PointIntervalAttr : public mlir::Attribute::AttrBase<PointIntervalAttr> {
+public:
+  using Base::Base;
+
+  static constexpr llvm::StringRef getAttrName() { return "point"; }
+  static PointIntervalAttr get(mlir::MLIRContext *ctxt);
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_POINT; }
+};
+
+/// A real attribute is used to workaround MLIR's default parsing of a real
+/// constant.
+/// `#fir.real<10, 3.14>` is used to introduce a real constant of value `3.14`
+/// with a kind of `10`.
+class RealAttr
+    : public mlir::Attribute::AttrBase<RealAttr, mlir::Attribute,
+                                       detail::RealAttributeStorage> {
+public:
+  using Base::Base;
+  using ValueType = std::pair<int, llvm::APFloat>;
+
+  static constexpr llvm::StringRef getAttrName() { return "real"; }
+  static RealAttr get(mlir::MLIRContext *ctxt, const ValueType &key);
+
+  int getFKind() const;
+  llvm::APFloat getValue() const;
+
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_REAL_ATTR; }
+};
+
+mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
+                                  mlir::DialectAsmParser &parser,
+                                  mlir::Type type);
+
+void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
+                       mlir::DialectAsmPrinter &p);
+
+} // namespace fir
+
+#endif // OPTIMIZER_DIALECT_FIRATTR_H
diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
new file mode 100644
index 000000000000..4818a7100b9c
--- /dev/null
+++ b/include/flang/Optimizer/Dialect/FIRDialect.h
@@ -0,0 +1,92 @@
+//===-- Optimizer/Dialect/FIRDialect.h -- FIR dialect -----------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_DIALECT_FIRDIALECT_H
+#define OPTIMIZER_DIALECT_FIRDIALECT_H
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/InitAllDialects.h"
+#include "mlir/InitAllPasses.h"
+
+namespace llvm {
+class raw_ostream;
+class StringRef;
+} // namespace llvm
+
+namespace mlir {
+class Attribute;
+class DialectAsmParser;
+class DialectAsmPrinter;
+class Location;
+class MLIRContext;
+class Type;
+} // namespace mlir
+
+namespace fir {
+
+/// FIR dialect
+class FIROpsDialect final : public mlir::Dialect {
+public:
+  explicit FIROpsDialect(mlir::MLIRContext *ctx);
+  virtual ~FIROpsDialect();
+
+  static llvm::StringRef getDialectNamespace() { return "fir"; }
+
+  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
+  void printType(mlir::Type ty, mlir::DialectAsmPrinter &p) const override;
+
+  mlir::Attribute parseAttribute(mlir::DialectAsmParser &parser,
+                                 mlir::Type type) const override;
+  void printAttribute(mlir::Attribute attr,
+                      mlir::DialectAsmPrinter &p) const override;
+};
+
+/// Register the dialect with MLIR
+inline void registerFIR() {
+  // we want to register exactly once
+  [[maybe_unused]] static bool init_once = [] {
+    mlir::registerDialect<mlir::AffineOpsDialect>();
+    mlir::registerDialect<mlir::LLVM::LLVMDialect>();
+    mlir::registerDialect<mlir::loop::LoopOpsDialect>();
+    mlir::registerDialect<mlir::StandardOpsDialect>();
+    mlir::registerDialect<mlir::vector::VectorOpsDialect>();
+    mlir::registerDialect<FIROpsDialect>();
+    return true;
+  }();
+}
+
+/// Register the standard passes we use. This comes from registerAllPasses(),
+/// but is a smaller set since we aren't using many of the passes found there.
+inline void registerGeneralPasses() {
+  mlir::createCanonicalizerPass();
+  mlir::createCSEPass();
+  mlir::createVectorizePass({});
+  mlir::createLoopUnrollPass();
+  mlir::createLoopUnrollAndJamPass();
+  mlir::createSimplifyAffineStructuresPass();
+  mlir::createLoopFusionPass();
+  mlir::createLoopInvariantCodeMotionPass();
+  mlir::createAffineLoopInvariantCodeMotionPass();
+  mlir::createPipelineDataTransferPass();
+  mlir::createLowerAffinePass();
+  mlir::createLoopTilingPass(0);
+  mlir::createLoopCoalescingPass();
+  mlir::createAffineDataCopyGenerationPass(0, 0);
+  mlir::createMemRefDataFlowOptPass();
+  mlir::createStripDebugInfoPass();
+  mlir::createPrintOpStatsPass();
+  mlir::createInlinerPass();
+  mlir::createSymbolDCEPass();
+  mlir::createLocationSnapshotPass({});
+}
+
+inline void registerFIRPasses() { registerGeneralPasses(); }
+
+} // namespace fir
+
+#endif // OPTIMIZER_DIALECT_FIRDIALECT_H
diff --git a/include/flang/Optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
new file mode 100644
index 000000000000..f5763693f7bb
--- /dev/null
+++ b/include/flang/Optimizer/Dialect/FIROps.h
@@ -0,0 +1,47 @@
+//===-- Optimizer/Dialect/FIROps.h - FIR operations -------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_DIALECT_FIROPS_H
+#define OPTIMIZER_DIALECT_FIROPS_H
+
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+
+using namespace mlir;
+
+namespace fir {
+
+class FirEndOp;
+class LoopOp;
+class RealAttr;
+
+void buildCmpFOp(mlir::Builder *builder, mlir::OperationState &result,
+                 mlir::CmpFPredicate predicate, mlir::Value lhs,
+                 mlir::Value rhs);
+void buildCmpCOp(mlir::Builder *builder, mlir::OperationState &result,
+                 mlir::CmpFPredicate predicate, mlir::Value lhs,
+                 mlir::Value rhs);
+unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
+                               unsigned dest);
+LoopOp getForInductionVarOwner(mlir::Value val);
+bool isReferenceLike(mlir::Type type);
+mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);
+mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result);
+mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result);
+mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result,
+                                mlir::OpAsmParser::OperandType &selector,
+                                mlir::Type &type);
+
+#define GET_OP_CLASSES
+#include "flang/Optimizer/Dialect/FIROps.h.inc"
+
+} // namespace fir
+
+#endif // OPTIMIZER_DIALECT_FIROPS_H
diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
new file mode 100644
index 000000000000..ab91c10e00fe
--- /dev/null
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -0,0 +1,2747 @@
+//===-- FIROps.td - FIR operation definitions --------------*- tablegen -*-===//
+//
+// 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
+/// Definition of the FIR dialect operations
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef FIR_DIALECT_FIR_OPS
+#define FIR_DIALECT_FIR_OPS
+
+include "mlir/Interfaces/ControlFlowInterfaces.td"
+
+def fir_Dialect : Dialect {
+  let name = "fir";
+}
+
+// Types and predicates
+
+def fir_Type : Type<CPred<"fir::isa_fir_or_std_type($_self)">,
+    "FIR dialect type">;
+
+// Fortran intrinsic types
+def fir_CharacterType : Type<CPred<"$_self.isa<fir::CharacterType>()">,
+    "FIR character type">;
+def fir_ComplexType : Type<CPred<"$_self.isa<fir::CplxType>()">,
+    "FIR complex type">;
+def fir_IntegerType : Type<CPred<"$_self.isa<fir::IntType>()">,
+    "FIR integer type">;
+def fir_LogicalType : Type<CPred<"$_self.isa<fir::LogicalType>()">,
+    "FIR logical type">;
+def fir_RealType : Type<CPred<"$_self.isa<fir::RealType>()">,
+    "FIR real type">;
+
+// Generalized FIR and standard dialect types representing intrinsic types
+def AnyIntegerLike : TypeConstraint<Or<[SignlessIntegerLike.predicate,
+    fir_IntegerType.predicate]>, "any integer">;
+def AnyLogicalLike : TypeConstraint<Or<[BoolLike.predicate,
+    fir_LogicalType.predicate]>, "any logical">;
+def AnyRealLike : TypeConstraint<Or<[FloatLike.predicate,
+    fir_RealType.predicate]>, "any real">;
+def AnyIntegerType : Type<AnyIntegerLike.predicate, "any integer">;
+
+// Fortran derived (user defined) type
+def fir_RecordType : Type<CPred<"$_self.isa<fir::RecordType>()">,
+    "FIR derived type">;
+
+// Fortran array attribute
+def fir_SequenceType : Type<CPred<"$_self.isa<fir::SequenceType>()">,
+    "array type">;
+
+// Composable types
+def AnyCompositeLike : TypeConstraint<Or<[fir_RecordType.predicate,
+    fir_SequenceType.predicate, fir_ComplexType.predicate,
+    IsTupleTypePred]>, "any composite">;
+
+// Reference to an entity type
+def fir_ReferenceType : Type<CPred<"$_self.isa<fir::ReferenceType>()">,
+    "reference type">;
+
+// Reference to an ALLOCATABLE attribute type
+def fir_HeapType : Type<CPred<"$_self.isa<fir::HeapType>()">,
+    "allocatable type">;
+
+// Reference to a POINTER attribute type
+def fir_PointerType : Type<CPred<"$_self.isa<fir::PointerType>()">,
+    "pointer type">;
+
+// Reference types
+def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
+    fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
+
+// A descriptor tuple (captures a reference to an entity and other information)
+def fir_BoxType : Type<CPred<"$_self.isa<fir::BoxType>()">, "box type">;
+
+// CHARACTER type descriptor. A pair of a data reference and a LEN value.
+def fir_BoxCharType : Type<CPred<"$_self.isa<fir::BoxCharType>()">,
+    "box character type">;
+
+// PROCEDURE POINTER descriptor. A pair that can capture a host closure.
+def fir_BoxProcType : Type<CPred<"$_self.isa<fir::BoxProcType>()">,
+    "box procedure type">;
+
+def AnyBoxLike : TypeConstraint<Or<[fir_BoxType.predicate,
+    fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
+
+def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
+    fir_HeapType.predicate, fir_PointerType.predicate, fir_BoxType.predicate]>,
+    "any reference or box">;
+
+// A vector of Fortran triple notation describing a multidimensional array
+def fir_DimsType : Type<CPred<"$_self.isa<fir::DimsType>()">, "dim type">;
+def AnyEmboxLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
+    Index.predicate, fir_IntegerType.predicate, fir_DimsType.predicate]>,
+    "any legal embox argument type">;
+def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;
+
+// A type descriptor's type
+def fir_TypeDescType : Type<CPred<"$_self.isa<fir::TypeDescType>()">,
+    "type desc type">;
+
+// A field (in a RecordType) argument's type
+def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
+
+// A LEN parameter (in a RecordType) argument's type
+def fir_LenType : Type<CPred<"$_self.isa<fir::LenType>()">,
+    "LEN parameter type">;
+
+def AnyComponentLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
+    Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate]>,
+    "any coordinate index">;
+def AnyComponentType : Type<AnyComponentLike.predicate, "coordinate type">;
+
+def AnyCoordinateLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
+    Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate,
+    fir_LenType.predicate]>, "any coordinate index">;
+def AnyCoordinateType : Type<AnyCoordinateLike.predicate, "coordinate type">;
+
+// Base class for FIR operations.
+// All operations automatically get a prefix of "fir.".
+class fir_Op<string mnemonic, list<OpTrait> traits>
+  : Op<fir_Dialect, mnemonic, traits>;
+
+// Base class for FIR operations that take a single argument
+class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
+  : fir_Op<mnemonic, traits> {
+
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
+  }];
+}
+
+// Base builder for allocate operations
+def fir_AllocateOpBuilder : OpBuilder<
+  "Builder *builder, OperationState &result, Type inType,"
+  "ValueRange lenParams = {}, ValueRange sizes = {},"
+  "ArrayRef<NamedAttribute> attributes = {}",
+  [{
+    result.addTypes(getRefTy(inType));
+    result.addAttribute("in_type", TypeAttr::get(inType));
+    result.addOperands(sizes);
+    result.addAttributes(attributes);
+  }]>;
+
+def fir_NamedAllocateOpBuilder : OpBuilder<
+  "Builder *builder, OperationState &result, Type inType, StringRef name,"
+  "ValueRange lenParams = {}, ValueRange sizes = {},"
+  "ArrayRef<NamedAttribute> attributes = {}",
+  [{
+    result.addTypes(getRefTy(inType));
+    result.addAttribute("in_type", TypeAttr::get(inType));
+    result.addAttribute("name", builder->getStringAttr(name));
+    result.addOperands(sizes);
+    result.addAttributes(attributes);
+  }]>;
+
+def fir_OneResultOpBuilder : OpBuilder<
+  "Builder *, OperationState &result, Type resultType,"
+  "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
+  [{
+    if (resultType)
+      result.addTypes(resultType);
+    result.addOperands(operands);
+    result.addAttributes(attributes);
+  }]>;
+
+// Base class of FIR operations that return 1 result
+class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
+  let builders = [fir_OneResultOpBuilder];
+}
+
+// Base class of FIR operations that have 1 argument and return 1 result
+class fir_SimpleOneResultOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_SimpleOp<mnemonic, traits> {
+  let builders = [fir_OneResultOpBuilder];
+}
+
+class fir_TwoBuilders<OpBuilder b1, OpBuilder b2> {
+  list<OpBuilder> builders = [b1, b2];
+}
+
+class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
+  let arguments = (ins
+    OptionalAttr<StrAttr>:$name,
+    OptionalAttr<BoolAttr>:$target
+  );
+}
+
+class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
+    fir_AllocatableBaseOp<mnemonic, !listconcat([NoSideEffect], traits)>,
+    fir_TwoBuilders<fir_AllocateOpBuilder, fir_NamedAllocateOpBuilder>,
+    Arguments<(ins TypeAttr:$in_type, Variadic<AnyIntegerType>:$args)> {
+
+  let parser = [{
+    mlir::Type intype;
+    if (parser.parseType(intype))
+      return mlir::failure();
+    auto &builder = parser.getBuilder();
+    result.addAttribute(inType(), mlir::TypeAttr::get(intype));
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+    llvm::SmallVector<mlir::Type, 8> typeVec;
+    bool hasOperands = false;
+    if (!parser.parseOptionalLParen()) {
+      // parse the LEN params of the derived type. (<params> : <types>)
+      if (parser.parseOperandList(operands,
+                                  mlir::OpAsmParser::Delimiter::None) ||
+          parser.parseColonTypeList(typeVec) ||
+          parser.parseRParen())
+        return mlir::failure();
+      auto lens = builder.getI32IntegerAttr(operands.size());
+      result.addAttribute(lenpName(), lens);
+      hasOperands = true;
+    }
+    if (!parser.parseOptionalComma()) {
+      // parse size to scale by, vector of n dimensions of type index
+      auto opSize = operands.size();
+      if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None))
+        return mlir::failure();
+      for (auto i = opSize, end = operands.size(); i != end; ++i)
+        typeVec.push_back(builder.getIndexType());
+      hasOperands = true;
+    }
+    if (hasOperands &&
+        parser.resolveOperands(operands, typeVec, parser.getNameLoc(),
+                               result.operands))
+      return mlir::failure();
+    mlir::Type restype = wrapResultType(intype);
+    if (!restype) {
+      parser.emitError(parser.getNameLoc(), "invalid allocate type: ")
+          << intype;
+      return mlir::failure();
+    }
+    if (parser.parseOptionalAttrDict(result.attributes) ||
+        parser.addTypeToList(restype, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr(inType());
+    if (hasLenParams()) {
+      // print the LEN parameters to a derived type in parens
+      p << '(';
+      p.printOperands(getLenParams());
+      p << " : ";
+      mlir::interleaveComma(getLenParams(), p.getStream(),
+                            [&](const auto &opnd) {
+                                p.printType(opnd.getType());
+                            });
+      p << ')';
+    }
+    // print the shape of the allocation (if any); all must be index type
+    for (auto sh : getShapeOperands()) {
+      p << ", ";
+      p.printOperand(sh);
+    }
+    p.printOptionalAttrDict(getAttrs(), {inType(), lenpName()});
+  }];
+
+  string extraAllocClassDeclaration = [{
+    static constexpr llvm::StringRef inType() { return "in_type"; }
+    static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
+    mlir::Type getAllocatedType();
+    bool hasLenParams() { return bool{getAttr(lenpName())}; }
+    unsigned numLenParams() {
+      if (auto val = getAttrOfType<mlir::IntegerAttr>(lenpName()))
+        return val.getInt();
+      return 0;
+    }
+    operand_range getLenParams() {
+      return {operand_begin(), operand_begin() + numLenParams()};
+    }
+    operand_range getShapeOperands() {
+      return {operand_begin() + numLenParams(), operand_end()};
+    }
+    static mlir::Type getRefTy(mlir::Type ty);
+
+    /// Get the input type of the allocation
+    mlir::Type getInType() {
+      return getAttrOfType<mlir::TypeAttr>(inType()).getValue();
+    }
+  }];
+
+  // Verify checks common to all allocation operations
+  string allocVerify = [{
+    llvm::SmallVector<llvm::StringRef, 8> visited;
+    if (verifyInType(getInType(), visited))
+      return emitOpError("invalid type for allocation");
+    if (verifyRecordLenParams(getInType(), numLenParams()))
+      return emitOpError("LEN params do not correspond to type");
+  }];
+}
+
+// Memory SSA operations
+
+def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
+  let summary = "allocate storage for a temporary on the stack given a type";
+  let description = [{
+    This primitive operation is used to allocate an object on the stack.  A
+    reference to the object of type `!fir.ref<T>` is returned.  The returned
+    object has an undefined/uninitialized state.  The allocation can be given
+    an optional name.  The allocation may have a dynamic repetition count
+    for allocating a sequence of locations for the specified type.
+
+    ```mlir
+      %c = ... : i64
+      %x = fir.alloca i32
+      %y = fir.alloca !fir.array<8 x i64>
+      %z = fir.alloca f32, %c
+
+      %i = ... : i16
+      %j = ... : i32
+      %w = fir.alloca !fir.type<PT(len1:i16, len2:i32)> (%i, %j : i16, i32)
+    ```
+
+    Note that in the case of `%z`, a contiguous block of memory is allocated
+    and its size is a runtime multiple of a 32-bit REAL value.
+
+    In the case of `%w`, the arguments `%i` and `%j` are LEN parameters
+    (`len1`, `len2`) to the type `PT`.
+
+    Finally, the operation is undefined if the ssa-value `%c` is negative.
+  }];
+
+  let results = (outs fir_ReferenceType);
+
+  let verifier = allocVerify#[{
+    mlir::Type outType = getType();
+    if (!outType.isa<fir::ReferenceType>())
+      return emitOpError("must be a !fir.ref type");
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = extraAllocClassDeclaration#[{
+    static mlir::Type wrapResultType(mlir::Type intype);
+  }];
+}
+
+def fir_LoadOp : fir_OneResultOp<"load", []> {
+  let summary = "load a value from a memory reference";
+  let description = [{
+    Load a value from a memory reference into an ssa-value (virtual register).
+    Produces an immutable ssa-value of the referent type. A memory reference
+    has type `!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
+
+    ```mlir
+      %a = fir.alloca i32
+      %l = fir.load %a : !fir.ref<i32>
+    ```
+
+    The ssa-value has an undefined value if the memory reference is undefined
+    or null.
+  }];
+
+  let arguments = (ins AnyReferenceLike:$memref);
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value refVal",
+    [{
+      if (!refVal) {
+        mlir::emitError(result.location, "LoadOp has null argument");
+        return;
+      }
+      auto refTy = refVal.getType().cast<fir::ReferenceType>();
+      result.addOperands(refVal);
+      result.addTypes(refTy.getEleTy());
+    }]
+  >];
+
+  let parser = [{
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType oper;
+    if (parser.parseOperand(oper) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(oper, type, result.operands))
+       return mlir::failure();
+    mlir::Type eleTy;
+    if (getElementOf(eleTy, type) ||
+        parser.addTypeToList(eleTy, result.types))
+       return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(memref());
+    p.printOptionalAttrDict(getAttrs(), {});
+    p << " : " << memref().getType();
+  }];
+
+  let extraClassDeclaration = [{
+    static mlir::ParseResult getElementOf(mlir::Type &ele, mlir::Type ref);
+  }];
+}
+
+def fir_StoreOp : fir_Op<"store", []> {
+  let summary = "store an SSA-value to a memory location";
+
+  let description = [{
+    Store an ssa-value (virtual register) to a memory reference.  The stored
+    value must be of the same type as the referent type of the memory
+    reference.
+
+    ```mlir
+      %v = ... : f64
+      %p = ... : !fir.ptr<f64>
+      fir.store %v to %p : !fir.ptr<f64>
+    ```
+
+    The above store changes the value to which the pointer is pointing and not
+    the pointer itself. The operation is undefined if the memory reference,
+    `%p`, is undefined or null.
+  }];
+
+  let arguments = (ins AnyType:$value, AnyReferenceLike:$memref);
+
+  let parser = [{
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType oper;
+    mlir::OpAsmParser::OperandType store;
+    if (parser.parseOperand(oper) ||
+        parser.parseKeyword("to") ||
+        parser.parseOperand(store) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(oper, elementType(type),
+          result.operands) ||
+        parser.resolveOperand(store, type, result.operands))
+       return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(value());
+    p << " to ";
+    p.printOperand(memref());
+    p.printOptionalAttrDict(getAttrs(), {});
+    p << " : " << memref().getType();
+  }];
+
+  let verifier = [{
+    if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
+      return emitOpError("store value type must match memory reference type");
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    static mlir::Type elementType(mlir::Type refType);
+  }];
+}
+
+def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
+  let summary = "explicit undefined value of some type";
+  let description = [{
+    Constructs an ssa-value of the specified type with an undefined value.
+    This operation is typically created internally by the mem2reg conversion
+    pass. An undefined value can be of any type except `!fir.ref<T>`.
+
+    ```mlir
+      %a = fir.undefined !fir.array<10 x !fir.type<T>>
+    ```
+
+    The example creates an array shaped ssa value. The array is rank 1, extent
+    10, and each element has type `!fir.type<T>`.
+  }];
+
+  let results = (outs AnyType:$intype);
+
+  let assemblyFormat = "type($intype) attr-dict";
+
+  let verifier = [{
+    if (auto ref = getType().dyn_cast<fir::ReferenceType>())
+      return emitOpError("undefined values of type !fir.ref not allowed");
+    return mlir::success();
+  }];
+}
+
+def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
+  let summary = "allocate storage on the heap for an object of a given type";
+
+  let description = [{
+    Creates a heap memory reference suitable for storing a value of the
+    given type, T.  The heap refernce returned has type `!fir.heap<T>`.
+    The memory object is in an undefined state.  `allocmem` operations must
+    be paired with `freemem` operations to avoid memory leaks.
+
+    ```mlir
+      %0 = fir.allocmem !fir.array<10 x f32>
+      fir.freemem %0 : !fir.heap<!fir.array<10 x f32>>
+    ```
+  }];
+
+  let results = (outs fir_HeapType);
+
+  let verifier = allocVerify#[{
+    mlir::Type outType = getType();
+    if (!outType.dyn_cast<fir::HeapType>())
+      return emitOpError("must be a !fir.heap type");
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = extraAllocClassDeclaration#[{
+    static mlir::Type wrapResultType(mlir::Type intype);
+  }];
+}
+
+def fir_FreeMemOp : fir_Op<"freemem", []> {
+  let summary = "free a heap object";
+
+  let description = [{
+    Deallocates a heap memory reference that was allocated by an `allocmem`.
+    The memory object that is deallocated is placed in an undefined state
+    after `fir.freemem`.  Optimizations may treat the loading of an object
+    in the undefined state as undefined behavior.  This includes aliasing
+    references, such as the result of an `fir.embox`.
+
+    ```mlir
+      %21 = fir.allocmem !fir.type<ZT(p:i32){field:i32}>
+      ...
+      fir.freemem %21 : !fir.heap<!fir.type<ZT>>
+    ```
+  }];
+
+  let arguments = (ins fir_HeapType:$heapref);
+
+  let assemblyFormat = "$heapref attr-dict `:` type($heapref)";
+}
+
+//===----------------------------------------------------------------------===//// Terminator operations
+//===----------------------------------------------------------------------===//
+
+class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic, !listconcat(traits, [AttrSizedOperandSegments,
+    DeclareOpInterfaceMethods<BranchOpInterface>, Terminator])> {
+
+  let arguments = (ins
+    AnyType:$selector,
+    Variadic<AnyType>:$compareArgs,
+    Variadic<AnyType>:$targetArgs
+  );
+
+  let results = (outs);
+
+  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
+
+  let builders = [OpBuilder<
+    "Builder *, OperationState &result, Value selector,"
+    "ValueRange properOperands, ArrayRef<Block *> destinations,"
+    "ArrayRef<ValueRange> operands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}",
+    [{
+      result.addOperands(selector);
+      result.addOperands(properOperands);
+      for (auto kvp : llvm::zip(destinations, operands)) {
+        result.addSuccessors(std::get<0>(kvp));
+        result.addOperands(std::get<1>(kvp));
+      }
+      result.addAttributes(attributes);
+    }]
+  >];
+
+  string extraSwitchClassDeclaration = [{
+    using Conditions = mlir::Value;
+
+    static constexpr llvm::StringRef getCasesAttr() { return "case_tags"; }
+
+    // The number of destination conditions that may be tested
+    unsigned getNumConditions() { return getNumDest(); }
+
+    // The selector is the value being tested to determine the destination
+    mlir::Value getSelector() { return selector(); }
+    mlir::Value getSelector(llvm::ArrayRef<mlir::Value> operands) {
+      return operands[0];
+    }
+
+    // The number of blocks that may be branched to
+    unsigned getNumDest() { return getOperation()->getNumSuccessors(); }
+
+    llvm::Optional<mlir::OperandRange> getCompareOperands(unsigned cond);
+    llvm::Optional<llvm::ArrayRef<mlir::Value>> getCompareOperands(
+        llvm::ArrayRef<mlir::Value> operands, unsigned cond);
+
+    llvm::Optional<llvm::ArrayRef<mlir::Value>> getSuccessorOperands(
+        llvm::ArrayRef<mlir::Value> operands, unsigned cond);
+
+    // Helper function to deal with Optional operand forms
+    void printSuccessorAtIndex(mlir::OpAsmPrinter &p, unsigned i) {
+      auto *succ = getSuccessor(i);
+      auto ops = getSuccessorOperands(i);
+      if (ops.hasValue())
+        p.printSuccessorAndUseList(succ, ops.getValue());
+      else
+        p.printSuccessor(succ);
+    }
+  }];
+}
+
+class fir_IntegralSwitchTerminatorOp<string mnemonic,
+    list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
+
+  let parser = [{
+    mlir::OpAsmParser::OperandType selector;
+    mlir::Type type;
+    if (parseSelector(parser, result, selector, type))
+      return mlir::failure();
+
+    llvm::SmallVector<mlir::Attribute, 8> ivalues;
+    llvm::SmallVector<mlir::Block *, 8> dests;
+    llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
+    while (true) {
+      mlir::Attribute ivalue; // Integer or Unit
+      mlir::Block *dest;
+      llvm::SmallVector<mlir::Value, 8> destArg;
+      llvm::SmallVector<mlir::NamedAttribute, 1> temp;
+      if (parser.parseAttribute(ivalue, "i", temp) ||
+          parser.parseComma() ||
+          parser.parseSuccessorAndUseList(dest, destArg))
+        return mlir::failure();
+      ivalues.push_back(ivalue);
+      dests.push_back(dest);
+      destArgs.push_back(destArg);
+      if (!parser.parseOptionalRSquare())
+        break;
+      if (parser.parseComma())
+        return mlir::failure();
+    }
+    auto &bld = parser.getBuilder();
+    result.addAttribute(getCasesAttr(), bld.getArrayAttr(ivalues));
+    llvm::SmallVector<int32_t, 8> argOffs;
+    int32_t sumArgs = 0;
+    const auto count = dests.size();
+    for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+      result.addSuccessors(dests[i]);
+      result.addOperands(destArgs[i]);
+      auto argSize = destArgs[i].size();
+      argOffs.push_back(argSize);
+      sumArgs += argSize;
+    }
+    result.addAttribute(getOperandSegmentSizeAttr(),
+                        bld.getI32VectorAttr({1, 0, sumArgs}));
+    result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(getSelector());
+    p << " : " << getSelector().getType() << " [";
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
+      if (i)
+        p << ", ";
+      auto &attr = cases[i];
+      if (auto intAttr = attr.dyn_cast_or_null<mlir::IntegerAttr>())
+        p << intAttr.getValue();
+      else
+        p.printAttribute(attr);
+      p << ", ";
+      printSuccessorAtIndex(p, i);
+    }
+    p << ']';
+    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
+        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
+  }];
+
+  let verifier = [{
+    if (!(getSelector().getType().isa<mlir::IntegerType>() ||
+          getSelector().getType().isa<mlir::IndexType>() ||
+          getSelector().getType().isa<fir::IntType>()))
+      return emitOpError("must be an integer");
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
+      auto &attr = cases[i];
+      if (attr.isa<mlir::IntegerAttr>() || attr.isa<mlir::UnitAttr>()) {
+        // ok
+      } else {
+        return emitOpError("invalid case alternative");
+      }
+    }
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = extraSwitchClassDeclaration;
+}
+
+def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
+  let summary = "a multiway branch";
+
+  let description = [{
+    A multiway branch terminator with similar semantics to C's `switch`
+    statement.  A selector value is matched against a list of constants
+    of the same type for a match.  When a match is found, control is
+    transferred to the corresponding basic block.  A `select` must have
+    at least one basic block with a corresponding `unit` match, and
+    that block will be selected when all other conditions fail to match.
+
+    ```mlir
+      fir.select %arg:i32 [1, ^bb1(%0 : i32),
+                           2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
+                          -3, ^bb3(%arg2,%2 : i32,i32),
+                           4, ^bb4(%1 : i32),
+                        unit, ^bb5]
+    ```
+  }];
+}
+
+def fir_SelectRankOp : fir_IntegralSwitchTerminatorOp<"select_rank"> {
+  let summary = "Fortran's SELECT RANK statement";
+
+  let description = [{
+    Similar to `select`, `select_rank` provides a way to express Fortran's
+    SELECT RANK construct.  In this case, the rank of the selector value
+    is matched against constants of integer type.  The structure is the
+    same as `select`, but `select_rank` determines the rank of the selector
+    variable at runtime to determine the best match.
+
+    ```mlir
+      fir.select_rank %arg:i32 [1, ^bb1(%0 : i32),
+                                2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
+                                3, ^bb3(%arg2,%2 : i32,i32),
+                               -1, ^bb4(%1 : i32),
+                             unit, ^bb5]
+    ```
+  }];
+}
+
+def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
+  let summary = "Fortran's SELECT CASE statement";
+
+  let description = [{
+    Similar to `select`, `select_case` provides a way to express Fortran's
+    SELECT CASE construct.  In this case, the selector value is matched
+    against variables (not just constants) and ranges.  The structure is
+    the same as `select`, but `select_case` allows for the expression of
+    more complex match conditions.
+
+    ```mlir
+      fir.select_case %arg : i32 [
+            #fir.point, %0, ^bb1(%0 : i32),
+            #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1 : i32,i32,i32,i32),
+            #fir.interval, %2, %3, ^bb3(%2,%arg2 : i32,i32),
+            #fir.upper, %arg, ^bb4(%1 : i32),
+            unit, ^bb5]
+    ```
+  }];
+
+  let parser = "return parseSelectCase(parser, result);";
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(getSelector());
+    p << " : " << getSelector().getType() << " [";
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
+      if (i)
+        p << ", ";
+      p << cases[i] << ", ";
+      if (!cases[i].isa<mlir::UnitAttr>()) {
+        auto caseArgs = *getCompareOperands(i);
+        p.printOperand(*caseArgs.begin());
+        p << ", ";
+        if (cases[i].isa<fir::ClosedIntervalAttr>()) {
+          p.printOperand(*(++caseArgs.begin()));
+          p << ", ";
+        }
+      }
+      printSuccessorAtIndex(p, i);
+    }
+    p << ']';
+    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
+        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
+  }];
+
+  let verifier = [{
+    if (!(getSelector().getType().isa<mlir::IntegerType>() ||
+          getSelector().getType().isa<mlir::IndexType>() ||
+          getSelector().getType().isa<fir::IntType>() ||
+          getSelector().getType().isa<fir::LogicalType>() ||
+          getSelector().getType().isa<fir::CharacterType>()))
+      return emitOpError("must be an integer, character, or logical");
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
+      auto &attr = cases[i];
+      if (attr.isa<fir::PointIntervalAttr>() ||
+          attr.isa<fir::LowerBoundAttr>() ||
+          attr.isa<fir::UpperBoundAttr>() ||
+          attr.isa<fir::ClosedIntervalAttr>() ||
+          attr.isa<mlir::UnitAttr>()) {
+        // ok
+      } else {
+        return emitOpError("incorrect select case attribute type");
+      }
+    }
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = extraSwitchClassDeclaration;
+}
+
+def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
+  let summary = "Fortran's SELECT TYPE statement";
+
+  let description = [{
+    Similar to `select`, `select_type` provides a way to express Fortran's
+    SELECT TYPE construct.  In this case, the type of the selector value
+    is matched against a list of type descriptors.  The structure is the
+    same as `select`, but `select_type` determines the type of the selector
+    variable at runtime to determine the best match.
+
+    ```mlir
+      fir.select_type %arg : !fir.box<()> [
+          #fir.instance<!fir.type<type1>>, ^bb1(%0 : i32),
+          #fir.instance<!fir.type<type2>>, ^bb2(%2 : i32),
+          #fir.subsumed<!fir.type<type3>>, ^bb3(%2 : i32),
+          #fir.instance<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
+          unit, ^bb5]
+    ```
+  }];
+
+  let parser = "return parseSelectType(parser, result);";
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(getSelector());
+    p << " : " << getSelector().getType() << " [";
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
+      if (i)
+        p << ", ";
+      p << cases[i] << ", ";
+      printSuccessorAtIndex(p, i);
+    }
+    p << ']';
+    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
+        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
+  }];
+
+  let verifier = [{
+    if (!(getSelector().getType().isa<fir::BoxType>()))
+      return emitOpError("must be a boxed type");
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
+      auto &attr = cases[i];
+      if (attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
+          attr.isa<mlir::UnitAttr>()) {
+        // ok
+      } else {
+        return emitOpError("invalid type-case alternative");
+      }
+    }
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = extraSwitchClassDeclaration;
+}
+
+def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
+  let summary = "the unreachable instruction";
+
+  let description = [{
+    Terminates a basic block with the assertion that the end of the block
+    will never be reached at runtime.  This instruction can be used
+    immediately after a call to the Fortran runtime to terminate the
+    program, for example.  This instruction corresponds to the LLVM IR
+    instruction `unreachable`.
+
+    ```mlir
+      fir.unreachable
+    ```
+  }];
+
+  let parser = "return mlir::success();";
+
+  let printer = "p << getOperationName();";
+}
+
+def fir_FirEndOp : fir_Op<"end", [Terminator]> {
+  let summary = "the end instruction";
+
+  let description = [{
+    The end terminator is a special terminator used inside various FIR
+    operations that have regions.  End is thus the custom invisible terminator
+    for these operations.  It is implicit and need not appear in the textual
+    representation.
+  }];
+}
+
+def fir_HasValueOp : fir_Op<"has_value", [Terminator, HasParent<"GlobalOp">]> {
+  let summary = "terminator for GlobalOp";
+  let description = [{
+    The terminator for a GlobalOp with a body.
+
+    ```mlir
+      global @variable : tuple<i32, f32> {
+        %0 = constant 45 : i32
+        %1 = constant 100.0 : f32
+        %2 = fir.undefined tuple<i32, f32>
+        %3 = constant 0 : index
+        %4 = fir.insert_value %2, %0, %3 : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
+        %5 = constant 1 : index
+        %6 = fir.insert_value %4, %1, %5 : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
+        fir.has_value %6 : tuple<i32, f32>
+      }
+    ```
+  }];
+
+  let arguments = (ins AnyType:$resval);
+
+  let assemblyFormat = "$resval attr-dict `:` type($resval)";
+}
+
+// Operations on !fir.box<T> type objects
+
+def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
+  let summary = "boxes a given reference and (optional) dimension information";
+
+  let description = [{
+    Create a boxed reference value. In Fortran, the implementation can require
+    extra information about an entity, such as its type, rank, etc.  This
+    auxilliary information is packaged and abstracted as a value with box type
+    by the calling routine. (In Fortran, these are called descriptors.)
+
+    ```mlir
+      %c1 = constant 1 : index
+      %c10 = constant 10 : index
+      %4 = fir.dims(%c1, %c10, %c1) : (index, index, index) -> !fir.dims<1>
+      %5 = ... : !fir.ref<!fir.array<10 x i32>>
+      %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10 x i32>>, !fir.dims<1>) -> !fir.box<!fir.array<10 x i32>>
+    ```
+
+    The descriptor tuple may contain additional implementation-specific
+    information through the use of additional attributes.
+  }];
+
+  let arguments = (ins AnyReferenceLike:$memref, Variadic<AnyEmboxArg>:$args);
+
+  let results = (outs fir_BoxType);
+
+  let parser = "return parseEmboxOp(parser, result);";
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(memref());
+    if (hasLenParams()) {
+      p << '(';
+      p.printOperands(getLenParams());
+      p << ')';
+    }
+    if (getNumOperands() == 2) {
+      p << ", ";
+      p.printOperands(dims());
+    } else if (auto map = getAttr(layoutName())) {
+      p << " [" << map << ']';
+    }
+    p.printOptionalAttrDict(getAttrs(), {layoutName(), lenpName()});
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+
+  let verifier = [{
+    if (hasLenParams()) {
+      auto lenParams = numLenParams();
+      auto eleTy = fir::dyn_cast_ptrEleTy(memref().getType());
+      if (!eleTy)
+        return emitOpError("must embox a memory reference type");
+      if (auto rt = eleTy.dyn_cast<fir::RecordType>()) {
+        if (lenParams != rt.getNumLenParams())
+          return emitOpError("number of LEN params does not correspond"
+                             " to the !fir.type type");
+      } else {
+        return emitOpError("LEN parameters require !fir.type type");
+      }
+      for (auto lp : getLenParams())
+        if (lp.getType().isa<fir::DimsType>())
+          return emitOpError("LEN parameters must be integral type");
+    }
+    if (dims().size() == 0) {
+      // Ok. If there is no dims and no layout map, then emboxing a scalar.
+      // TODO: Should the type be enforced? It already must agree.
+    } else if (dims().size() == 1) {
+      auto d = *dims().begin();
+      if (!d.getType().isa<fir::DimsType>())
+        return emitOpError("dimension argument must have !fir.dims type");
+    } else {
+      return emitOpError("embox can only have one !fir.dim argument");
+    }
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef layoutName() { return "layout_map"; }
+    static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
+    bool hasLenParams() { return bool{getAttr(lenpName())}; }
+    unsigned numLenParams() {
+      if (auto x = getAttrOfType<mlir::IntegerAttr>(lenpName()))
+        return x.getInt();
+      return 0;
+    }
+    operand_range getLenParams() {
+      return {operand_begin(), operand_begin() + numLenParams()};
+    }
+    operand_range dims() {
+      return {operand_begin() + numLenParams() + 1, operand_end()};
+    }
+  }];
+}
+
+def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
+  let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
+  let results = (outs fir_BoxCharType);
+
+  let summary = "boxes a given CHARACTER reference and its LEN parameter";
+
+  let description = [{
+    Create a boxed CHARACTER value. The CHARACTER type has the LEN type
+    parameter, the value of which may only be known at runtime.  Therefore,
+    a variable of type CHARACTER has both its data reference as well as a
+    LEN type parameter.
+
+    ```fortran
+      CHARACTER(LEN=10) :: var
+    ```
+    ```mlir
+      %4 = ...         : !fir.ref<!fir.array<10 x !fir.char<1>>>
+      %5 = constant 10 : i32
+      %6 = fir.emboxchar %4, %5 : (!fir.ref<!fir.array<10 x !fir.char<1>>>, i32) -> !fir.boxchar<1>
+    ```
+
+    In the above `%4` is a memory reference to a buffer of 10 CHARACTER units.
+    This buffer and its LEN value (10) are wrapped into a pair in `%6`.
+  }];
+
+  let assemblyFormat = [{
+    $memref `,` $len attr-dict `:` functional-type(operands, results)
+  }];
+
+  let verifier = [{
+    auto eleTy = elementTypeOf(memref().getType());
+    if (!eleTy.dyn_cast<CharacterType>())
+      return mlir::failure();
+    return mlir::success();
+  }];
+}
+
+def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
+
+  let summary = "boxes a given procedure and optional host context";
+
+  let description = [{
+    Creates an abstract encapsulation of a PROCEDURE POINTER along with an
+    optional pointer to a host instance context. If the pointer is not to an
+    internal procedure or the internal procedure does not need a host context
+    then the form takes only the procedure's symbol.
+
+    ```mlir
+      %0 = fir.emboxproc @f : ((i32) -> i32) -> !fir.boxproc<(i32) -> i32>
+    ```
+
+    An internal procedure requiring a host instance for correct execution uses
+    the second form. The closure of the host procedure's state is passed as a
+    reference to a tuple. It is the responsibility of the host to manage the
+    context's values accordingly, up to and including inhibiting register
+    promotion of local values.
+
+    ```mlir
+      %4 = ... : !fir.ref<tuple<i32, i32>>
+      %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) -> !fir.boxproc<(i32) -> i32>
+    ```
+  }];
+
+  let arguments = (ins SymbolRefAttr:$funcname, AnyReferenceLike:$host);
+
+  let results = (outs fir_BoxProcType);
+
+  let parser = [{
+    mlir::SymbolRefAttr procRef;
+    if (parser.parseAttribute(procRef, "funcname", result.attributes))
+      return mlir::failure();
+    bool hasTuple = false;
+    mlir::OpAsmParser::OperandType tupleRef;
+    if (!parser.parseOptionalComma()) {
+      if (parser.parseOperand(tupleRef))
+        return mlir::failure();
+      hasTuple = true;
+    }
+    mlir::FunctionType type;
+    if (parser.parseColon() ||
+        parser.parseLParen() ||
+        parser.parseType(type))
+      return mlir::failure();
+    result.addAttribute("functype", mlir::TypeAttr::get(type));
+    if (hasTuple) {
+      mlir::Type tupleType;
+      if (parser.parseComma() ||
+          parser.parseType(tupleType) ||
+          parser.resolveOperand(tupleRef, tupleType, result.operands))
+        return mlir::failure();
+    }
+    mlir::Type boxType;
+    if (parser.parseRParen() ||
+        parser.parseArrow() ||
+        parser.parseType(boxType) ||
+        parser.addTypesToList(boxType, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("funcname");
+    auto h = host();
+    if (h) {
+      p << ", ";
+      p.printOperand(h);
+    }
+    p << " : (" << getAttr("functype");
+    if (h)
+      p << ", " << h.getType();
+    p << ") -> " << getType();
+  }];
+
+  let verifier = [{
+    // host bindings (optional) must be a reference to a tuple
+    if (auto h = host()) {
+      if (auto r = h.getType().dyn_cast<ReferenceType>()) {
+        if (!r.getEleTy().dyn_cast<mlir::TupleType>())
+          return mlir::failure();
+      } else {
+        return mlir::failure();
+      }
+    }
+    return mlir::success();
+  }];
+}
+
+def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
+  let summary = "unbox the boxed value into a tuple value";
+
+  let description = [{
+    Unbox a boxed value into a result of multiple values from the box's
+    component data.  The values are, minimally, a reference to the data of the
+    entity, the byte-size of one element, the rank, the type descriptor, a set
+    of flags (packed in an integer, and an array of dimension information (of
+    size rank).
+
+    ```mlir
+      %40   = ... : !fir.box<!fir.type<T>>
+      %41:6 = fir.unbox %40 : (!fir.box<!fir.type<T>>) -> (!fir.ref<!fir.type<T>>, i32, i32, !fir.tdesc<!fir.type<T>>, i32, !fir.dims<4>)
+    ```
+  }];
+
+  let arguments = (ins fir_BoxType:$box);
+
+  let results = (outs
+    fir_ReferenceType,  // pointer to data
+    AnyIntegerLike,     // size of a data element
+    AnyIntegerLike,     // rank of data
+    fir_TypeDescType,   // abstract type descriptor
+    AnyIntegerLike,     // attribute flags (bitfields)
+    fir_DimsType        // dimension information (if any)
+  );
+}
+
+def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]> {
+  let summary = "unbox a boxchar value into a pair value";
+
+  let description = [{
+    Unboxes a value of `boxchar` type into a pair consisting of a memory
+    reference to the CHARACTER data and the LEN type parameter.
+
+    ```mlir
+      %45   = ... : !fir.boxchar<1>
+      %46:2 = fir.unboxchar %45 : (!fir.boxchar<1>) -> (!fir.ref<!fir.character<1>>, i32)
+    ```
+  }];
+
+  let arguments = (ins fir_BoxCharType:$boxchar);
+
+  let results = (outs fir_ReferenceType, AnyIntegerLike);
+}
+
+def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
+  let summary = "unbox a boxproc value into a pair value";
+
+  let description = [{
+    Unboxes a value of `boxproc` type into a pair consisting of a procedure
+    pointer and a pointer to a host context.
+
+    ```mlir
+      %47   = ... : !fir.boxproc<() -> i32>
+      %48:2 = fir.unboxproc %47 : (!fir.ref<() -> i32>, !fir.ref<tuple<f32, i32>>)
+    ```
+  }];
+
+  let verifier = [{
+    if (auto eleTy = fir::dyn_cast_ptrEleTy(refTuple().getType()))
+      if (eleTy.isa<mlir::TupleType>())
+        return mlir::success();
+    return emitOpError("second output argument has bad type");
+  }];
+
+  let arguments = (ins fir_BoxProcType:$boxproc);
+
+  let results = (outs FunctionType, fir_ReferenceType:$refTuple);
+}
+
+def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
+  let summary = "return a memory reference to the boxed value";
+
+  let description = [{
+    This operator is overloaded to work with values of type `box`,
+    `boxchar`, and `boxproc`.  The result for each of these
+    cases, respectively, is the address of the data, the address of the
+    `CHARACTER` data, and the address of the procedure.
+
+    ```mlir
+      %51 = fir.box_addr %box : (!fir.box<f64>) -> !fir.ref<f64>
+      %52 = fir.box_addr %boxchar : (!fir.boxchar<1>) -> !fir.ref<!fir.char<1>>
+      %53 = fir.box_addr %boxproc : (!fir.boxproc<!P>) -> !fir.ref<!P>
+    ```
+  }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs AnyReferenceLike);
+}
+
+def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
+  let summary = "return the LEN type parameter from a boxchar value";
+
+  let description = [{
+    Extracts the LEN type parameter from a `boxchar` value.
+
+    ```mlir
+      %45 = ... : !boxchar<1>  // CHARACTER(20)
+      %59 = fir.boxchar_len %45 : (!fir.boxchar<1>) -> i64  // len=20
+    ```
+  }];
+
+  let arguments = (ins fir_BoxCharType:$val);
+
+  let results = (outs AnyIntegerLike);
+}
+
+def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
+  let summary = "return the dynamic dimension information for the boxed value";
+
+  let description = [{
+    Returns the triple of lower bound, extent, and stride for `dim` dimension
+    of `val`, which must have a `box` type.  The dimensions are enumerated from
+    left to right from 0 to rank-1. This operation has undefined behavior if
+    `dim` is out of bounds.
+
+    ```mlir
+      %c1   = constant 0 : i32
+      %52:3 = fir.box_dims %40, %c1 : (!fir.box<!fir.array<*:f64>>, i32) -> (i32, i32, i32)
+    ```
+
+    The above is a request to return the left most row (at index 0) triple from
+    the box. The triple will be the lower bound, upper bound, and stride.
+  }];
+
+  let arguments = (ins fir_BoxType:$val, AnyIntegerLike:$dim);
+
+  let results = (outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike);
+
+  let assemblyFormat = [{
+    $val `,` $dim attr-dict `:` functional-type(operands, results)
+  }];
+
+  let extraClassDeclaration = [{
+    mlir::Type getTupleType();
+  }];
+}
+
+def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
+  let summary = "return the size of an element of the boxed value";
+
+  let description = [{
+    Returns the size of an element in an entity of `box` type.  This size may
+    not be known until runtime.
+
+    ```mlir
+      %53 = fir.box_elesize %40 : (!fir.box<f32>, i32) -> i32  // size=4
+      %54 = fir.box_elesize %40 : (!fir.box<!fir.array<*:f32>>, i32) -> i32
+    ```
+
+    In the above example, `%53` may box an array of REAL values while `%54`
+    must box an array of REAL values (with dynamic rank and extent).
+  }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs AnyIntegerLike);
+}
+
+def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]> {
+  let summary = "is the boxed value an ALLOCATABLE?";
+
+  let description = [{
+    Determine if the boxed value was from an ALLOCATABLE entity. This will
+    return true if the originating box value was from a `fir.embox` op
+    with a mem-ref value that had the type !fir.heap<T>.
+
+    ```mlir
+      %r = ... : !fir.heap<i64>
+      %b = fir.embox %r : (!fir.heap<i64>) -> !fir.box<i64>
+      %a = fir.box_isalloc %b : (!fir.box<i64>) -> i1  // true
+    ```
+
+    The canonical descriptor implementation will carry a flag to record if the
+    variable is an `ALLOCATABLE`.
+  }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs BoolLike);
+}
+
+def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]> {
+  let summary = "is the boxed value an array?";
+
+  let description = [{
+    Determine if the boxed value has a positive (> 0) rank. This will return
+    true if the originating box value was from a fir.embox with a memory
+    reference value that had the type !fir.array<T> and/or a dims argument.
+
+    ```mlir
+      %r = ... : !fir.ref<i64>
+      %d = fir.gendims(1, 100, 1) : (i32, i32, i32) -> !fir.dims<1>
+      %b = fir.embox %r, %d : (!fir.ref<i64>, !fir.dims<1>) -> !fir.box<i64>
+      %a = fir.box_isarray %b : (!fir.box<i64>) -> i1  // true
+    ```
+  }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs BoolLike);
+}
+
+def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]> {
+  let summary = "is the boxed value a POINTER?";
+
+  let description = [{
+    Determine if the boxed value was from a POINTER entity.
+
+    ```mlir
+      %p = ... : !fir.ptr<i64>
+      %b = fir.embox %p : (!fir.ptr<i64>) -> !fir.box<i64>
+      %a = fir.box_isptr %b : (!fir.box<i64>) -> i1  // true
+    ```
+  }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs BoolLike);
+}
+
+def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]> {
+  let summary = "returns the host instance pointer (or null)";
+
+  let description = [{
+    Extract the host context pointer from a boxproc value.
+
+    ```mlir
+      %8 = ... : !fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>
+      %9 = fir.boxproc_host %8 : (!fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>) -> !fir.ref<tuple<i32, i32>>
+    ```
+
+    In the example, the reference to the closure over the host procedure's
+    variables is returned. This allows an internal procedure to access the
+    host's variables. It is up to lowering to determine the contract between
+    the host and the internal procedure.
+  }];
+
+  let arguments = (ins fir_BoxProcType:$val);
+
+  let results = (outs fir_ReferenceType);
+}
+
+def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
+  let summary = "return the number of dimensions for the boxed value";
+
+  let description = [{
+    Return the rank of a value of `box` type.  If the value is scalar, the
+    rank is 0.
+
+    ```mlir
+      %57 = fir.box_rank %40 : (!fir.box<!fir.array<*:f64>>) -> i32
+      %58 = fir.box_rank %41 : (!fir.box<f64>) -> i32
+    ```
+
+    The example `%57` shows how one would determine the rank of an array that
+    has deferred rank at runtime. This rank should be at least 1. In %58, the
+    descriptor may be either an array or a scalar, so the value is nonnegative.
+  }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs AnyIntegerType);
+}
+
+def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
+  let summary = "return the type descriptor for the boxed value";
+
+  let description = [{
+    Return the opaque type descriptor of a value of `box` type. A type
+    descriptor is an implementation defined value that fully describes a type
+    to the Fortran runtime.
+
+    ```mlir
+      %7 = fir.box_tdesc %41 : (!fir.box<f64>) -> !fir.tdesc<f64>
+    ```
+  }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs fir_TypeDescType);
+}
+
+// Record and array type operations
+
+def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
+  let summary = "Finds the coordinate (location) of a value in memory";
+
+  let description = [{
+    Compute the internal coordinate address starting from a boxed value or
+    unboxed memory reference. Returns a memory reference. When computing the
+    coordinate of an array element, the rank of the array must be known and
+    the number of indexing expressions must equal the rank of the array.
+
+    This operation will apply the access map from a boxed value implicitly.
+
+    Unlike LLVM's GEP instruction, one cannot stride over the outermost
+    reference; therefore, the leading 0 index must be omitted.
+
+    ```mlir
+      %i = ... : index
+      %h = ... : !fir.heap<!fir.array<?:f32>>
+      %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
+    ```
+
+    In the example, `%p` will be a pointer to the `%i`-th f32 value in the
+    array `%h`.
+  }];
+
+  let arguments = (ins AnyRefOrBox:$ref, Variadic<AnyCoordinateType>:$coor);
+
+  let results = (outs fir_ReferenceType);
+
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
+  }];
+
+  let verifier = [{
+    // Recovering a LEN type parameter only makes sense from a boxed value
+    for (auto co : coor())
+      if (dyn_cast_or_null<LenParamIndexOp>(co.getDefiningOp())) {
+        if (getNumOperands() != 2)
+          return emitOpError("len_param_index must be last argument");
+        if (!ref().getType().dyn_cast<BoxType>())
+          return emitOpError("len_param_index must be used on box type");
+      }
+    return mlir::success();
+  }];
+}
+
+def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
+  let summary = "Extract a value from an aggregate SSA-value";
+
+  let description = [{
+    Extract a value from an entity with a type composed of tuples, arrays,
+    and/or derived types. Returns the value from entity with the type of the
+    specified component. Cannot be used on values of `!fir.box` type.
+
+    Note that the entity ssa-value must be of compile-time known size in order
+    to use this operation.
+
+    ```mlir
+      %f = fir.field_index field, !fir.type<X{field:i32}>
+      %s = ... : !fir.type<X>
+      %v = fir.extract_value %s, %f : (!fir.type<X>, !fir.field) -> i32
+    ```
+  }];
+
+  let arguments = (ins
+    AnyCompositeLike:$adt,
+    Variadic<AnyComponentType>:$coor
+  );
+
+  let assemblyFormat = [{
+    $adt `,` $coor attr-dict `:` functional-type(operands, results)
+  }];
+}
+
+def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
+  let summary = "create a field index value from a field identifier";
+
+  let description = [{
+    Generate a field (offset) value from an identifier.  Field values may be
+    lowered into exact offsets when the layout of a Fortran derived type is
+    known at compile-time. The type of a field value is `!fir.field` and
+    these values can be used with the `fir.coordinate_of`, `fir.extract_value`,
+    or `fir.insert_value` instructions to compute (abstract) addresses of
+    subobjects.
+
+    ```mlir
+      %f = fir.field_index field, !fir.type<X{field:i32}>
+    ```
+  }];
+
+  let arguments = (ins
+    StrAttr:$field_id,
+    TypeAttr:$on_type,
+    Variadic<AnyIntegerType>:$lenparams
+  );
+
+  let parser = [{
+    llvm::StringRef fieldName;
+    auto &builder = parser.getBuilder();
+    mlir::Type recty;
+    if (parser.parseOptionalKeyword(&fieldName) ||
+        parser.parseComma() ||
+        parser.parseType(recty))
+      return mlir::failure();
+    result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
+    if (!recty.dyn_cast<RecordType>())
+      return mlir::failure();
+    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(recty));
+    if (!parser.parseOptionalLParen()) {
+      llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+      llvm::SmallVector<mlir::Type, 8> types;
+      auto loc = parser.getNameLoc();
+      if (parser.parseOperandList(operands,
+                                  mlir::OpAsmParser::Delimiter::None) ||
+          parser.parseRParen() ||
+          parser.parseColonTypeList(types) ||
+          parser.resolveOperands(operands, types, loc, result.operands))
+        return mlir::failure();
+    }
+    mlir::Type fieldType = fir::FieldType::get(builder.getContext());
+    if (parser.addTypeToList(fieldType, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' '
+      << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
+      << getAttr(typeAttrName());
+    if (getNumOperands()) {
+      p << '(';
+      p.printOperands(lenparams());
+      auto sep = ") : ";
+      for (auto op : lenparams()) {
+        p << sep;
+        if (op)
+          p.printType(op.getType());
+        else
+          p << "()";
+        sep = ", ";
+      }
+    }
+  }];
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, StringRef fieldName,"
+    "Type recTy, ValueRange operands = {}",
+    [{
+      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
+      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+      result.addOperands(operands);
+    }]
+  >];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
+    static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
+  }];
+}
+
+def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
+
+  let summary = "generate a value of type `!fir.dims`";
+
+  let description = [{
+    The arguments are an ordered list of integral type values that is a
+    multiple of 3 in length.  Each such triple is defined as: the lower
+    index, the extent, and the stride for that dimension. The dimension
+    information is given in the same row-to-column order as Fortran. This
+    abstract dimension value must describe a reified object, so all dimension
+    information must be specified.  The extent must be nonnegative and the
+    stride must not be zero.
+
+    ```mlir
+      %d = fir.gendims %l, %u, %s : (index, index, index) -> !fir.dims<1>
+    ```
+  }];
+
+  let arguments = (ins Variadic<AnyIntegerType>:$triples);
+
+  let results = (outs fir_DimsType);
+
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
+  }];
+
+  let verifier = [{
+    auto size = triples().size();
+    if (size < 1 || size > 16 * 3)
+      return emitOpError("incorrect number of args");
+    if (size % 3 != 0)
+      return emitOpError("requires a multiple of 3 args");
+    return mlir::success();
+  }];
+}
+
+def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
+  let summary = "insert a new sub-value into a copy of an existing aggregate";
+
+  let description = [{
+    Insert a value from an entity with a type composed of tuples, arrays,
+    and/or derived types. Returns a new ssa value with the same type as the
+    original entity. Cannot be used on values of `!fir.box` type.
+
+    Note that the entity ssa-value must be of compile-time known size in order
+    to use this operation.
+
+    ```mlir
+      %a = ... : !fir.array<10xtuple<i32, f32>>
+      %f = ... : f32
+      %o = ... : i32
+      %c = constant 1 : i32
+      %b = fir.insert_value %a, %f, %o, %c : (!fir.array<10x20xtuple<i32, f32>>, f32, i32, i32) -> !fir.array<10x20xtuple<i32, f32>>
+    ```
+  }];
+
+  let arguments = (ins AnyCompositeLike:$adt, AnyType:$val,
+                       Variadic<AnyComponentType>:$coor);
+  let results = (outs AnyCompositeLike);
+
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
+  }];
+}
+
+def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
+  let summary =
+    "create a field index value from a LEN type parameter identifier";
+
+  let description = [{
+    Generate a LEN parameter (offset) value from an LEN parameter identifier.
+    The type of a LEN parameter value is `!fir.len` and these values can be
+    used with the `fir.coordinate_of` instructions to compute (abstract)
+    addresses of LEN parameters.
+
+    ```mlir
+      %e = fir.len_param_index len1, !fir.type<X(len1:i32)>
+      %p = ... : !fir.box<!fir.type<X>>
+      %q = fir.coordinate_of %p, %e : (!fir.box<!fir.type<X>>, !fir.len) -> !fir.ref<i32>
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$field_id, TypeAttr:$on_type);
+
+  let parser = [{
+    llvm::StringRef fieldName;
+    auto &builder = parser.getBuilder();
+    mlir::Type recty;
+    if (parser.parseOptionalKeyword(&fieldName) ||
+        parser.parseComma() ||
+        parser.parseType(recty))
+      return mlir::failure();
+    result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
+    if (!recty.dyn_cast<RecordType>())
+      return mlir::failure();
+    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(recty));
+    mlir::Type lenType = fir::LenType::get(builder.getContext());
+    if (parser.addTypeToList(lenType, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' '
+      << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
+      << getAttr(typeAttrName());
+  }];
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, StringRef fieldName, Type recTy",
+    [{
+      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
+      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+    }]
+  >];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
+    static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
+    mlir::Type getOnType() {
+      return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
+    }
+  }];
+}
+
+// Fortran loops
+
+def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
+
+def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
+  let summary = "generalized loop operation";
+  let description = [{
+    Generalized high-level looping construct. This operation is similar to
+    MLIR's `loop.for`. An ordered loop will return the final value of `%i`.
+
+    ```mlir
+      %l = constant 0 : index
+      %u = constant 9 : index
+      fir.loop %i = %l to %u unordered {
+        %x = fir.convert %i : (index) -> i32
+        %v = fir.call @compute(%x) : (i32) -> f32
+        %p = fir.coordinate_of %A, %i : (!fir.ref<f32>, index) -> !fir.ref<f32>
+        fir.store %v to %p : !fir.ref<f32>
+      }
+    ```
+
+    The above example iterates over the interval `[%l, %u]`. The unordered
+    keyword indicates that the iterations can be executed in any order.
+  }];
+
+  let arguments = (ins
+    Index:$lowerBound,
+    Index:$upperBound,
+    Variadic<Index>:$optStep,
+    OptionalAttr<I64Attr>:$constantStep,
+    OptionalAttr<UnitAttr>:$unordered
+  );
+
+  let results = (outs Variadic<Index>:$lastVal);
+
+  let regions = (region SizedRegion<1>:$region);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "mlir::Value lowerBound, mlir::Value upperBound,"
+              "ValueRange step = {}, ArrayRef<NamedAttribute> attributes = {}">
+  ];
+
+  let parser = "return parseLoopOp(parser, result);";
+
+  let printer = [{
+    p << getOperationName() << ' ' << getInductionVar() << " = "
+      << lowerBound() << " to " << upperBound();
+    auto s = optStep();
+    if (s.begin() != s.end()) {
+      p << " step ";
+      p.printOperand(*s.begin());
+    }
+    if (unordered())
+      p << " unordered";
+    p.printRegion(region(), /*printEntryBlockArgs=*/false,
+                            /*printBlockTerminators=*/false);
+    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepAttrName()});
+  }];
+
+  let verifier = [{
+    auto step = optStep();
+    if (step.begin() != step.end()) {
+      // FIXME: size of step must be 1
+      auto *s = (*step.begin()).getDefiningOp();
+      if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s))
+        if (cst.getValue() == 0)
+          return emitOpError("constant step operand must be nonzero");
+    }
+
+    // Check that the body defines as single block argument for the induction
+    // variable.
+    auto *body = getBody();
+    if (body->getNumArguments() != 1 ||
+        !body->getArgument(0).getType().isIndex())
+      return emitOpError("expected body to have a single index argument for "
+                         "the induction variable");
+    if (lastVal().size() > 1)
+      return emitOpError("can only return one final value of iterator");
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr const char *unorderedAttrName() { return "unordered"; }
+    static constexpr const char *stepAttrName() { return "step"; }
+
+    /// Is this an unordered loop?
+    bool isUnordered() { return getAttr(unorderedAttrName()).isa<UnitAttr>(); }
+
+    /// Does loop set (and return) the final value of the control variable?
+    bool hasLastValue() { return lastVal().size(); }
+
+    /// Get the body of the loop
+    mlir::Block *getBody() { return &region().front(); }
+
+    /// Get the block argument corresponding to the loop control value (PHI)
+    mlir::Value getInductionVar() { return getBody()->getArgument(0); }
+
+    /// Get a builder to insert operations into the LoopOp
+    mlir::OpBuilder getBodyBuilder() {
+      return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
+    }
+
+    void setLowerBound(mlir::Value bound) {
+      getOperation()->setOperand(0, bound);
+    }
+
+    void setUpperBound(mlir::Value bound) {
+      getOperation()->setOperand(1, bound);
+    }
+
+    void setStep(mlir::Value step) {
+      getOperation()->setOperand(2, step);
+    }
+  }];
+}
+
+def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
+  let summary = "generalized conditional operation";
+  let description = [{
+    To conditionally execute operations (typically) within the body of a
+    `fir.loop` operation. This operation is similar to `loop.if`.
+
+    ```mlir
+      %56 = ... : i1
+      %78 = ... : !fir.ref<!T>
+      fir.where %56 {
+        fir.store %76 to %78 : !fir.ref<!T>
+      } otherwise {
+        fir.store %77 to %78 : !fir.ref<!T>
+      }
+    ```
+  }];
+
+  let arguments = (ins I1:$condition);
+
+  let regions = (region SizedRegion<1>:$whereRegion, AnyRegion:$otherRegion);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"Builder *builder, OperationState &result, "
+              "Value cond, bool withOtherRegion">
+  ];
+
+  let parser = [{ return parseWhereOp(parser, result); }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << condition();
+    p.printRegion(whereRegion(), /*printEntryBlockArgs=*/false,
+        /*printBlockTerminators=*/false);
+
+    // Print the 'else' regions if it exists and has a block.
+    auto &otherReg = otherRegion();
+    if (!otherReg.empty()) {
+      p << " otherwise";
+      p.printRegion(otherReg, /*printEntryBlockArgs=*/false,
+          /*printBlockTerminators=*/false);
+    }
+    p.printOptionalAttrDict(getAttrs());
+  }];
+
+  let verifier = [{
+    for (auto &region : getOperation()->getRegions()) {
+      if (region.empty())
+        continue;
+      for (auto &b : region)
+        if (b.getNumArguments() != 0)
+          return emitOpError("requires that child entry blocks have no args");
+    }
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    mlir::OpBuilder getWhereBodyBuilder() {
+      assert(!whereRegion().empty() && "Unexpected empty 'where' region.");
+      mlir::Block &body = whereRegion().front();
+      return mlir::OpBuilder(&body, std::prev(body.end()));
+    }
+    mlir::OpBuilder getOtherBodyBuilder() {
+      assert(!otherRegion().empty() && "Unexpected empty 'other' region.");
+      mlir::Block &body = otherRegion().front();
+      return mlir::OpBuilder(&body, std::prev(body.end()));
+    }
+  }];
+}
+
+// Procedure call operations
+
+def fir_CallOp : fir_Op<"call", []> {
+  let summary = "call a procedure";
+
+  let description = [{
+    Call the specified function or function reference.
+
+    Provides a custom parser and pretty printer to allow a more readable syntax
+    in the FIR dialect, e.g. `fir.call @sub(%12)` or `fir.call %20(%22,%23)`.
+
+    ```mlir
+      %a = fir.call %funcref(%arg0) : (!fir.ref<f32>) -> f32
+      %b = fir.call @function(%arg1, %arg2) : (!fir.ref<f32>, !fir.ref<f32>) -> f32
+    ```
+  }];
+
+  let arguments = (ins
+    OptionalAttr<SymbolRefAttr>:$callee,
+    Variadic<AnyType>:$args
+  );
+
+  let results = (outs Variadic<AnyType>);
+
+  let parser = "return parseCallOp(parser, result);";
+  let printer = "printCallOp(p, *this);";
+
+  let extraClassDeclaration = [{
+    static constexpr StringRef calleeAttrName() { return "callee"; }
+  }];
+}
+
+def fir_DispatchOp : fir_Op<"dispatch", []> {
+  let summary = "call a type-bound procedure";
+
+  let description = [{
+    Perform a dynamic dispatch on the method name via the dispatch table
+    associated with the first argument.  The attribute 'pass_arg_pos' can be
+    used to select a dispatch argument other than the first one.
+
+    ```mlir
+      %r = fir.dispatch methodA(%o) : (!fir.box<none>) -> i32
+    ```
+  }];
+
+  let arguments = (ins
+    StrAttr:$method,
+    fir_BoxType:$object,
+    Variadic<AnyType>:$args
+  );
+
+  let results = (outs Variadic<AnyType>);
+
+  let parser = [{
+    mlir::FunctionType calleeType;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    auto calleeLoc = parser.getNameLoc();
+    llvm::StringRef calleeName;
+    if (failed(parser.parseOptionalKeyword(&calleeName))) {
+      mlir::StringAttr calleeAttr;
+      if (parser.parseAttribute(calleeAttr, "method", result.attributes))
+        return mlir::failure();
+    } else {
+      result.addAttribute("method",
+          parser.getBuilder().getStringAttr(calleeName));
+    }
+    if (parser.parseOperandList(operands,
+                                mlir::OpAsmParser::Delimiter::Paren) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
+        parser.parseColonType(calleeType) ||
+        parser.addTypesToList(calleeType.getResults(), result.types) ||
+        parser.resolveOperands(
+            operands, calleeType.getInputs(), calleeLoc, result.operands))
+      return mlir::failure();
+    result.addAttribute("fn_type", mlir::TypeAttr::get(calleeType));
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("method") << '(';
+    p.printOperand(object());
+    if (arg_operand_begin() != arg_operand_end()) {
+      p << ", ";
+      p.printOperands(args());
+    }
+    p << ')';
+    p.printOptionalAttrDict(getAttrs(), {"fn_type", "method"});
+    auto resTy{getResultTypes()};
+    llvm::SmallVector<mlir::Type, 8> argTy(getOperandTypes());
+    p << " : " << mlir::FunctionType::get(argTy, resTy, getContext());
+  }];
+
+  let extraClassDeclaration = [{
+    mlir::FunctionType getFunctionType();
+    operand_range getArgOperands() {
+      return {arg_operand_begin(), arg_operand_end()};
+    }
+    operand_iterator arg_operand_begin() { return operand_begin() + 1; }
+    operand_iterator arg_operand_end() { return operand_end(); }
+    llvm::StringRef passArgAttrName() { return "pass_arg_pos"; }
+    unsigned passArgPos();
+  }];
+}
+
+// Constant operations that support Fortran
+
+def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]> {
+  let summary = "create a string literal constant";
+
+  let description = [{
+    An FIR constant that represents a sequence of characters that correspond
+    to Fortran's CHARACTER type, including a LEN.  We support CHARACTER values
+    of different KINDs (different constant sizes).
+
+    ```mlir
+      %1 = fir.string_lit "Hello, World!"(13) : !fir.char<1> // ASCII
+      %2 = fir.string_lit [158, 2345](2) : !fir.char<2>      // Wide chars
+    ```
+  }];
+
+  let results = (outs fir_SequenceType);
+
+  let parser = [{
+    auto &builder = parser.getBuilder();
+    mlir::Attribute val;
+    llvm::SmallVector<mlir::NamedAttribute, 2> attrs;
+    if (parser.parseAttribute(val, "fake", attrs))
+      return mlir::failure();
+    if (auto v = val.dyn_cast<mlir::StringAttr>())
+      result.attributes.push_back(builder.getNamedAttr(value(), v));
+    else if (auto v = val.dyn_cast<mlir::ArrayAttr>())
+      result.attributes.push_back(builder.getNamedAttr(xlist(), v));
+    else
+      return mlir::failure();
+    mlir::IntegerAttr sz;
+    mlir::Type type;
+    if (parser.parseLParen() ||
+        parser.parseAttribute(sz, size(), result.attributes) ||
+        parser.parseRParen() ||
+        parser.parseColonType(type))
+      return mlir::failure();
+    type = fir::SequenceType::get({sz.getInt()}, type);
+    if (!type ||
+        parser.addTypesToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getValue() << '(';
+    p << getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
+    p.printType(getType().cast<fir::SequenceType>().getEleTy());
+  }];
+
+  let verifier = [{
+    if (getSize().cast<mlir::IntegerAttr>().getValue().isNegative())
+      return emitOpError("size must be non-negative");
+    auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
+    if (!eleTy.isa<fir::CharacterType>())
+      return emitOpError("must have !fir.char type");
+    if (auto xl = getAttr(xlist())) {
+      auto xList = xl.cast<mlir::ArrayAttr>();
+      for (auto a : xList)
+        if (!a.isa<mlir::IntegerAttr>())
+	  return emitOpError("values in list must be integers");
+    }
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr const char *size() { return "size"; }
+    static constexpr const char *value() { return "value"; }
+    static constexpr const char *xlist() { return "xlist"; }
+
+    // Get the LEN attribute of this character constant
+    mlir::Attribute getSize() { return getAttr(size()); }
+    // Get the string value of this character constant
+    mlir::Attribute getValue() {
+      if (auto attr = getAttr(value()))
+        return attr;
+      return getAttr(xlist());
+    }
+
+    /// Is this a wide character literal (1 character > 8 bits)
+    bool isWideValue();
+  }];
+}
+
+// Complex operations
+
+class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic,
+       !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
+    Results<(outs AnyType)> {
+  let parser = [{
+    return impl::parseOneResultSameOperandTypeOp(parser, result);
+  }];
+
+  let printer = [{ return printBinaryOp(this->getOperation(), p); }];
+}
+
+class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_Op<mnemonic,
+         !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
+      Results<(outs AnyType)> {
+  let parser = [{
+    return impl::parseOneResultSameOperandTypeOp(parser, result);
+  }];
+
+  let printer = [{ return printUnaryOp(this->getOperation(), p); }];
+}
+
+def FirRealAttr : Attr<CPred<"$_self.isa<fir::RealAttr>()">, "FIR real attr"> {
+  let storageType = [{ fir::RealAttr }];
+  let returnType = [{ llvm::APFloat }];
+}
+
+def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]> {
+  let summary = "create a floating point constant";
+
+  let description = [{
+    A floating-point constant. This operation is to augment MLIR to be able
+    to represent APFloat values that are not supported in the standard dialect.
+  }];
+
+  let arguments = (ins FirRealAttr:$constant);
+  
+  let results = (outs fir_RealType:$res);
+
+  let assemblyFormat = "`(` $constant `)` attr-dict `:` type($res)";
+  
+  let verifier = [{
+    if (!getType().isa<fir::RealType>())
+      return emitOpError("must be a !fir.real type");
+    return mlir::success();
+  }];
+}
+
+class RealUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_UnaryArithmeticOp<mnemonic, traits>,
+      Arguments<(ins AnyRealLike:$operand)>;
+
+def fir_NegfOp : RealUnaryArithmeticOp<"negf">;
+
+class RealArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_ArithmeticOp<mnemonic, traits>,
+      Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)>;
+
+def fir_AddfOp : RealArithmeticOp<"addf", [Commutative]>;
+def fir_SubfOp : RealArithmeticOp<"subf">;
+def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]>;
+def fir_DivfOp : RealArithmeticOp<"divf">;
+def fir_ModfOp : RealArithmeticOp<"modf">;
+// Pow is a builtin call and not a primitive
+
+def fir_CmpfOp : fir_Op<"cmpf",
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
+  let summary = "floating-point comparison operator";
+
+  let description = [{
+    Extends the standard floating-point comparison to handle the extended
+    floating-point types found in FIR.
+  }];
+
+  let arguments = (ins AnyRealLike:$lhs, AnyRealLike:$rhs);
+
+  let results = (outs AnyLogicalLike);
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, CmpFPredicate predicate,"
+    "Value lhs, Value rhs", [{
+      buildCmpFOp(builder, result, predicate, lhs, rhs);
+  }]>];
+
+  let parser = [{ return parseCmpfOp(parser, result); }];
+
+  let printer = [{ printCmpfOp(p, *this); }];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef getPredicateAttrName() {
+      return "predicate";
+    }
+    static CmpFPredicate getPredicateByName(llvm::StringRef name);
+
+    CmpFPredicate getPredicate() {
+      return (CmpFPredicate)getAttrOfType<mlir::IntegerAttr>(
+          getPredicateAttrName()).getInt();
+    }
+  }];
+}
+
+def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]>,
+    Results<(outs fir_ComplexType)> {
+  let summary = "create a complex constant";
+
+  let description = [{
+    A complex constant. Similar to the standard dialect complex type, but this
+    extension allows constants with APFloat values that are not supported in
+    the standard dialect.
+  }];
+
+  let parser = [{
+    fir::RealAttr realp;
+    fir::RealAttr imagp;
+    mlir::Type type;
+    if (parser.parseLParen() ||
+        parser.parseAttribute(realp, realAttrName(), result.attributes) ||
+        parser.parseComma() ||
+        parser.parseAttribute(imagp, imagAttrName(), result.attributes) ||
+        parser.parseRParen() ||
+        parser.parseColonType(type) ||
+        parser.addTypesToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << " (0x";
+    auto f1 = getAttr(realAttrName()).cast<mlir::FloatAttr>();
+    auto i1 = f1.getValue().bitcastToAPInt();
+    p.getStream().write_hex(i1.getZExtValue());
+    p << ", 0x";
+    auto f2 = getAttr(imagAttrName()).cast<mlir::FloatAttr>();
+    auto i2 = f2.getValue().bitcastToAPInt();
+    p.getStream().write_hex(i2.getZExtValue());
+    p << ") : ";
+    p.printType(getType());
+  }];
+
+  let verifier = [{
+    if (!getType().isa<fir::CplxType>())
+      return emitOpError("must be a !fir.complex type");
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef realAttrName() { return "real"; }
+    static constexpr llvm::StringRef imagAttrName() { return "imaginary"; }
+
+    mlir::Attribute getReal() { return getAttr(realAttrName()); }
+    mlir::Attribute getImaginary() { return getAttr(imagAttrName()); }
+  }];
+}
+
+class ComplexUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_UnaryArithmeticOp<mnemonic, traits>,
+      Arguments<(ins fir_ComplexType:$operand)>;
+
+def fir_NegcOp : ComplexUnaryArithmeticOp<"negc">;
+
+class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_ArithmeticOp<mnemonic, traits>,
+      Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)>;
+
+def fir_AddcOp : ComplexArithmeticOp<"addc", [Commutative]>;
+def fir_SubcOp : ComplexArithmeticOp<"subc">;
+def fir_MulcOp : ComplexArithmeticOp<"mulc", [Commutative]>;
+def fir_DivcOp : ComplexArithmeticOp<"divc">;
+// Pow is a builtin call and not a primitive
+
+def fir_CmpcOp : fir_Op<"cmpc",
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
+  let summary = "complex floating-point comparison operator";
+
+  let description = [{
+    A complex comparison to handle complex types found in FIR.
+  }];
+
+  let arguments = (ins fir_ComplexType:$lhs, fir_ComplexType:$rhs);
+
+  let results = (outs AnyLogicalLike);
+
+  let parser = "return parseCmpcOp(parser, result);";
+
+  let printer = "printCmpcOp(p, *this);";
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, CmpFPredicate predicate,"
+    "Value lhs, Value rhs", [{
+      buildCmpCOp(builder, result, predicate, lhs, rhs);
+  }]>];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef getPredicateAttrName() {
+      return "predicate";
+    }
+
+    CmpFPredicate getPredicate() {
+      return (CmpFPredicate)getAttrOfType<mlir::IntegerAttr>(
+          getPredicateAttrName()).getInt();
+    }
+  }];
+}
+
+// Other misc. operations
+
+def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
+  let summary = "convert a symbol to an SSA value";
+  let description = [{
+    Convert a symbol (a function or global reference) to an SSA-value to be
+    used in other Operations.
+
+    ```mlir
+      %p = fir.address_of(@symbol) : !fir.ref<f64>
+    ```
+  }];
+
+  let arguments = (ins SymbolRefAttr:$symbol);
+
+  let results = (outs fir_ReferenceType:$resTy);
+
+  let assemblyFormat = "`(` $symbol `)` attr-dict `:` type($resTy)";
+}
+
+def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
+  let summary = "encapsulates all Fortran scalar type conversions";
+  let description = [{
+    Generalized type conversion. Convert the ssa value from type T to type U.
+    Not all pairs of types have conversions. When types T and U are the same
+    type, this instruction is a NOP and may be folded away.
+
+    ```mlir
+      %v = ... : i64
+      %w = fir.convert %v : (i64) -> i32
+    ```
+
+    The example truncates the value `%v` from an i64 to an i32.
+  }];
+
+  let arguments = (ins AnyType:$value);
+
+  let assemblyFormat = [{
+    $value attr-dict `:` functional-type($value, results)
+  }];
+}
+
+def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
+    Or<[CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CharacterType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CplxType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::IntType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::LogicalType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RealType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RecordType>()">]>]>,
+    "Fortran surface type"> {
+  let storageType = [{ TypeAttr }];
+  let returnType = "Type";
+  let convertFromStorage = "$_self.getValue().cast<Type>()";
+}
+
+def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
+  let summary = "generate a type descriptor for a given type";
+  let description = [{
+    Generates a constant object that is an abstract type descriptor of the
+    specified type.  The meta-type of a type descriptor for the type `T`
+    is `!fir.tdesc<T>`.
+
+    ```mlir
+      !T = type !fir.type<T{...}>
+      %t = fir.gentypedesc !T  // returns value of !fir.tdesc<!T>
+    ```
+  }];
+
+  let arguments = (ins FortranTypeAttr:$in_type);
+
+  let parser = [{
+    mlir::Type intype;
+    if (parser.parseType(intype))
+      return mlir::failure();
+    result.addAttribute("in_type", mlir::TypeAttr::get(intype));
+    mlir::Type restype = TypeDescType::get(intype);
+    if (parser.addTypeToList(restype, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("in_type");
+    p.printOptionalAttrDict(getAttrs(), {"in_type"});
+  }];
+
+  let builders = [
+    OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty">
+  ];
+
+  let verifier = [{
+    mlir::Type resultTy = getType();
+    if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
+      if (tdesc.getOfTy() != getInType())
+        return emitOpError("wrapped type mismatched");
+    } else {
+      return emitOpError("must be !fir.tdesc type");
+    }
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    mlir::Type getInType() {
+      // get the type that the type descriptor describes
+      return getAttrOfType<mlir::TypeAttr>("in_type").getValue();
+    }
+  }];
+}
+
+def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
+    [SameOperandsAndResultType]> {
+  let summary = "synthetic op to prevent reassociation";
+  let description = [{
+    Primitive operation meant to intrusively prevent operator reassociation.
+    The operation is otherwise a nop and the value returned is the same as the
+    argument.
+
+    The presence of this operation prevents any local optimizations. In the
+    example below, this would prevent possibly replacing the multiply and add
+    operations with a single FMA operation.
+
+    ```mlir
+      %98 = mulf %96, %97 : f32
+      %99 = fir.no_reassoc %98 : f32
+      %a0 = addf %99, %95 : f32
+    ```
+  }];
+
+  let arguments = (ins AnyType:$val);
+
+  let assemblyFormat = "$val attr-dict `:` type($val)";
+}
+
+class AtMostRegion<int numBlocks> : Region<
+  CPred<"$_self.getBlocks().size() <= " # numBlocks>,
+  "region with " # numBlocks # " blocks">;
+
+def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
+  let summary = "Global data";
+  let description = [{
+    A global variable or constant with initial values.
+
+    The example creates a global variable (writable) named
+    `@_QV_Mquark_Vvarble` with some initial values. The initializer should
+    conform to the variable's type.
+
+    ```mlir
+      fir.global @_QV_Mquark_Vvarble : tuple<i32, f32> {
+        %1 = constant 1 : i32
+        %2 = constant 2.0 : f32
+        %3 = fir.undefined tuple<i32, f32>
+        %z = constant 0 : index
+        %o = constant 1 : index
+        %4 = fir.insert_value %3, %1, %z : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
+        %5 = fir.insert_value %4, %1, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
+        return %5
+      }
+    ```
+  }];
+
+  let arguments = (ins
+    StrAttr:$sym_name,
+    OptionalAttr<AnyAttr>:$initval,
+    UnitAttr:$constant,
+    TypeAttr:$type
+  );
+
+  let results = (outs fir_ReferenceType:$resultType);
+
+  let regions = (region AtMostRegion<1>:$region);
+
+  let parser = [{
+    // Parse the name as a symbol reference attribute.
+    SymbolRefAttr nameAttr;
+    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
+                              result.attributes))
+      return failure();
+
+    auto &builder = parser.getBuilder();
+    auto name = nameAttr.getRootReference();
+    result.attributes.back().second = builder.getStringAttr(name);
+
+    bool simpleInitializer = false;
+    if (!parser.parseOptionalLParen()) {
+      Attribute attr;
+      if (parser.parseAttribute(attr, initValAttrName(), result.attributes) ||
+          parser.parseRParen())
+        return failure();
+      simpleInitializer = true;
+    }
+
+    if (succeeded(parser.parseOptionalKeyword(constantAttrName()))) {
+      // if "constant" keyword then mark this as a constant, not a variable
+      result.addAttribute(constantAttrName(), builder.getUnitAttr());
+    }
+
+    mlir::Type globalType;
+    if (parser.parseColonType(globalType))
+      return failure();
+
+    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(globalType));
+
+    if (!simpleInitializer) {
+      // Parse the optional initializer body.
+      if (parser.parseRegion(*result.addRegion(), llvm::None, llvm::None))
+        return failure();
+    }
+
+    auto refTy = AllocaOp::wrapResultType(globalType);
+    if (parser.addTypeToList(refTy, result.types))
+      return failure();
+    return success();
+  }];
+
+  let printer = [{
+    auto varName = getAttrOfType<StringAttr>(
+      mlir::SymbolTable::getSymbolAttrName()).getValue();
+    p << getOperationName() << " @" << varName;
+    if (auto iv = initval().getValueOr(Attribute())) {
+      p << '(';
+      p.printAttribute(iv);
+      p << ')';
+    }
+    if (getAttr(constantAttrName()))
+      p << ' ' << constantAttrName();
+    p << " : ";
+    p.printType(getType());
+    Region &body = getOperation()->getRegion(0);
+    if (!body.empty())
+      p.printRegion(body, /*printEntryBlockArgs=*/false,
+                          /*printBlockTerminators=*/true);
+  }];
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
+    [{
+      result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
+      result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                          builder->getStringAttr(name));
+      result.addAttributes(attrs);
+    }]>
+  ];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef constantAttrName() { return "constant"; }
+    static constexpr llvm::StringRef initValAttrName() { return "initval"; }
+    static constexpr llvm::StringRef typeAttrName() { return "type"; }
+
+    mlir::Type getType() {
+      return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
+    }
+
+    /// Append the next initializer value to the `GlobalOp` to construct
+    /// the variable's initial value.
+    void appendInitialValue(mlir::Operation *op);
+
+    /// A GlobalOp has one region.
+    mlir::Region &getRegion() { return getOperation()->getRegion(0); }
+
+    /// A GlobalOp has one block.
+    mlir::Block &getBlock() { return getRegion().front(); }
+  }];
+}
+
+def fir_GlobalLenOp : fir_Op<"global_len", []> {
+  let summary = "map a LEN parameter to a global";
+  let description = [{
+    A global entity (that is not an automatic data object) can have extra LEN
+    parameter (compile-time) constants associated with the instance's type.
+    These values can be bound to the global instance used `fir.global_len`.
+
+    ```mlir
+      global @g : !fir.type<t(len1:i32)> {
+        fir.global_len len1, 10 : i32
+        %1 = fir.undefined : !fir.type<t(len1:i32)>
+        return %1 : !fir.type<t(len1:i32)>
+      }
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$lenparam, APIntAttr:$intval);
+
+  let parser = [{
+    llvm::StringRef fieldName;
+    if (failed(parser.parseOptionalKeyword(&fieldName))) {
+      mlir::StringAttr fieldAttr;
+      if (parser.parseAttribute(fieldAttr, lenParamAttrName(),
+                                result.attributes))
+        return mlir::failure();
+    } else {
+      result.addAttribute(lenParamAttrName(),
+          parser.getBuilder().getStringAttr(fieldName));
+    }
+    mlir::IntegerAttr constant;
+    if (parser.parseComma() ||
+        parser.parseAttribute(constant, intAttrName(), result.attributes))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr(lenParamAttrName()) << ", "
+      << getAttr(intAttrName());
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef lenParamAttrName() { return "lenparam"; }
+    static constexpr llvm::StringRef intAttrName() { return "intval"; }
+  }];
+}
+
+def fir_DispatchTableOp : fir_Op<"dispatch_table", [IsolatedFromAbove, Symbol,
+                                 ImplicitFirTerminator]> {
+  let summary = "Dispatch table definition";
+
+  let description = [{
+    Define a dispatch table for a derived type with type-bound procedures.
+
+    A dispatch table is an untyped symbol that contains a list of associations
+    between method identifiers and corresponding `FuncOp` symbols.
+
+    The ordering of associations in the map is determined by the front-end.
+
+    ```mlir
+      fir.dispatch_table @_QDTMquuzTfoo {
+        fir.dt_entry method1, @_QFNMquuzTfooPmethod1AfooR
+        fir.dt_entry method2, @_QFNMquuzTfooPmethod2AfooII
+      }
+    ```
+  }];
+
+  let parser = [{
+    // Parse the name as a symbol reference attribute.
+    SymbolRefAttr nameAttr;
+    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
+                              result.attributes))
+      return failure();
+
+    // Convert the parsed name attr into a string attr.
+    result.attributes.back().second =
+        parser.getBuilder().getStringAttr(nameAttr.getRootReference());
+
+    // Parse the optional table body.
+    mlir::Region *body = result.addRegion();
+    if (parser.parseOptionalRegion(*body, llvm::None, llvm::None))
+      return mlir::failure();
+
+    ensureTerminator(*body, parser.getBuilder(), result.location);
+    return mlir::success();
+  }];
+
+  let printer = [{
+    auto tableName = getAttrOfType<StringAttr>(
+      mlir::SymbolTable::getSymbolAttrName()).getValue();
+    p << getOperationName() << " @" << tableName;
+
+    Region &body = getOperation()->getRegion(0);
+    if (!body.empty())
+      p.printRegion(body, /*printEntryBlockArgs=*/false,
+                          /*printBlockTerminators=*/false);
+  }];
+
+  let verifier = [{
+    for (auto &op : getBlock())
+      if (!(isa<fir::DTEntryOp>(op) || isa<fir::FirEndOp>(op)))
+        return emitOpError("dispatch table must contain dt_entry");
+    return mlir::success();
+  }];
+
+  let regions = (region SizedRegion<1>:$region);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, OperationState *result,"
+              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
+    [{
+      result->addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                           builder->getStringAttr(name));
+      result->addAttributes(attrs);
+    }]>
+  ];
+
+  let extraClassDeclaration = [{
+    /// Append a dispatch table entry to the table.
+    void appendTableEntry(mlir::Operation *op);
+
+    mlir::Region &getRegion() {
+      return this->getOperation()->getRegion(0);
+    }
+
+    mlir::Block &getBlock() {
+      return getRegion().front();
+    }
+  }];
+}
+
+def fir_DTEntryOp : fir_Op<"dt_entry", []> {
+  let summary = "map entry in a dispatch table";
+
+  let description = [{
+    An entry in a dispatch table.  Allows a function symbol to be bound
+    to a specifier method identifier.  A dispatch operation uses the dynamic
+    type of a distinguished argument to determine an exact dispatch table
+    and uses the method identifier to select the type-bound procedure to
+    be called.
+
+    ```mlir
+      fir.dt_entry method_name, @uniquedProcedure
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$method, SymbolRefAttr:$proc);
+
+  let parser = [{
+    llvm::StringRef methodName;
+    // allow `methodName` or `"methodName"`
+    if (failed(parser.parseOptionalKeyword(&methodName))) {
+      mlir::StringAttr methodAttr;
+      if (parser.parseAttribute(methodAttr, methodAttrName(),
+                                result.attributes))
+        return mlir::failure();
+    } else {
+      result.addAttribute(methodAttrName(),
+          parser.getBuilder().getStringAttr(methodName));
+    }
+    mlir::SymbolRefAttr calleeAttr;
+    if (parser.parseComma() ||
+        parser.parseAttribute(calleeAttr, procAttrName(), result.attributes))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr(methodAttrName()) << ", "
+      << getAttr(procAttrName());
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef methodAttrName() { return "method"; }
+    static constexpr llvm::StringRef procAttrName() { return "proc"; }
+  }];
+}
+
+#endif
diff --git a/include/flang/Optimizer/Dialect/FIROpsSupport.h b/include/flang/Optimizer/Dialect/FIROpsSupport.h
new file mode 100644
index 000000000000..13e4e5ab71b2
--- /dev/null
+++ b/include/flang/Optimizer/Dialect/FIROpsSupport.h
@@ -0,0 +1,63 @@
+//===-- Optimizer/Dialect/FIROpsSupport.h -- FIR op support -----*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_DIALECT_FIROPSSUPPORT_H
+#define OPTIMIZER_DIALECT_FIROPSSUPPORT_H
+
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+
+namespace fir {
+
+/// return true iff the Operation is a non-volatile LoadOp
+inline bool nonVolatileLoad(mlir::Operation *op) {
+  if (auto load = dyn_cast<fir::LoadOp>(op))
+    return !load.getAttr("volatile");
+  return false;
+}
+
+/// return true iff the Operation is a call
+inline bool isaCall(mlir::Operation *op) {
+  return isa<fir::CallOp>(op) || isa<fir::DispatchOp>(op) ||
+         isa<mlir::CallOp>(op) || isa<mlir::CallIndirectOp>(op);
+}
+
+/// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
+/// mlir::CallOp, or mlir::CallIndirectOp and not pure
+/// NB: this is not the same as `!pureCall(op)`
+inline bool impureCall(mlir::Operation *op) {
+  // Should we also auto-detect that the called function is pure if its
+  // arguments are not references?  For now, rely on a "pure" attribute.
+  return op && isaCall(op) && !op->getAttr("pure");
+}
+
+/// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
+/// mlir::CallOp, or mlir::CallIndirectOp and is also pure.
+/// NB: this is not the same as `!impureCall(op)`
+inline bool pureCall(mlir::Operation *op) {
+  // Should we also auto-detect that the called function is pure if its
+  // arguments are not references?  For now, rely on a "pure" attribute.
+  return op && isaCall(op) && op->getAttr("pure");
+}
+
+/// Get or create a FuncOp in a module.
+///
+/// If `module` already contains FuncOp `name`, it is returned. Otherwise, a new
+/// FuncOp is created, and that new FuncOp is returned.
+mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
+                          llvm::StringRef name, mlir::FunctionType type,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+
+/// Get or create a GlobalOp in a module.
+fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
+                             llvm::StringRef name, mlir::Type type,
+                             llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+
+} // namespace fir
+
+#endif // OPTIMIZER_DIALECT_FIROPSSUPPORT_H
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
new file mode 100644
index 000000000000..73174371718a
--- /dev/null
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -0,0 +1,399 @@
+//===-- Optimizer/Dialect/FIRType.h -- FIR types ----------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_DIALECT_FIRTYPE_H
+#define OPTIMIZER_DIALECT_FIRTYPE_H
+
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/Types.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace llvm {
+class raw_ostream;
+class StringRef;
+template <typename>
+class ArrayRef;
+class hash_code;
+} // namespace llvm
+
+namespace mlir {
+class DialectAsmParser;
+class DialectAsmPrinter;
+} // namespace mlir
+
+namespace fir {
+
+class FIROpsDialect;
+
+using KindTy = int;
+
+namespace detail {
+struct BoxTypeStorage;
+struct BoxCharTypeStorage;
+struct BoxProcTypeStorage;
+struct CharacterTypeStorage;
+struct CplxTypeStorage;
+struct DimsTypeStorage;
+struct FieldTypeStorage;
+struct HeapTypeStorage;
+struct IntTypeStorage;
+struct LenTypeStorage;
+struct LogicalTypeStorage;
+struct PointerTypeStorage;
+struct RealTypeStorage;
+struct RecordTypeStorage;
+struct ReferenceTypeStorage;
+struct SequenceTypeStorage;
+struct TypeDescTypeStorage;
+} // namespace detail
+
+/// Integral identifier for all the types comprising the FIR type system
+enum TypeKind {
+  // The enum starts at the range reserved for this dialect.
+  FIR_TYPE = mlir::Type::FIRST_FIR_TYPE,
+  FIR_BOX,       // (static) descriptor
+  FIR_BOXCHAR,   // CHARACTER pointer and length
+  FIR_BOXPROC,   // procedure with host association
+  FIR_CHARACTER, // intrinsic type
+  FIR_COMPLEX,   // intrinsic type
+  FIR_DERIVED,   // derived
+  FIR_DIMS,
+  FIR_FIELD,
+  FIR_HEAP,
+  FIR_INT, // intrinsic type
+  FIR_LEN,
+  FIR_LOGICAL, // intrinsic type
+  FIR_POINTER, // POINTER attr
+  FIR_REAL,    // intrinsic type
+  FIR_REFERENCE,
+  FIR_SEQUENCE, // DIMENSION attr
+  FIR_TYPEDESC,
+};
+
+// These isa_ routines follow the precedent of llvm::isa_or_null<>
+
+/// Is `t` any of the FIR dialect types?
+bool isa_fir_type(mlir::Type t);
+
+/// Is `t` any of the Standard dialect types?
+bool isa_std_type(mlir::Type t);
+
+/// Is `t` any of the FIR dialect or Standard dialect types?
+bool isa_fir_or_std_type(mlir::Type t);
+
+/// Is `t` a FIR dialect type that implies a memory (de)reference?
+bool isa_ref_type(mlir::Type t);
+
+/// Is `t` a FIR dialect aggregate type?
+bool isa_aggregate(mlir::Type t);
+
+/// Extract the `Type` pointed to from a FIR memory reference type. If `t` is
+/// not a memory reference type, then returns a null `Type`.
+mlir::Type dyn_cast_ptrEleTy(mlir::Type t);
+
+/// Boilerplate mixin template
+template <typename A, unsigned Id>
+struct IntrinsicTypeMixin {
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return Id; }
+};
+
+// Intrinsic types
+
+/// Model of the Fortran CHARACTER intrinsic type, including the KIND type
+/// parameter. The model does not include a LEN type parameter. A CharacterType
+/// is thus the type of a single character value.
+class CharacterType
+    : public mlir::Type::TypeBase<CharacterType, mlir::Type,
+                                  detail::CharacterTypeStorage>,
+      public IntrinsicTypeMixin<CharacterType, TypeKind::FIR_CHARACTER> {
+public:
+  using Base::Base;
+  static CharacterType get(mlir::MLIRContext *ctxt, KindTy kind);
+  KindTy getFKind() const;
+};
+
+/// Model of a Fortran COMPLEX intrinsic type, including the KIND type
+/// parameter. COMPLEX is a floating point type with a real and imaginary
+/// member.
+class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
+                                             detail::CplxTypeStorage>,
+                 public IntrinsicTypeMixin<CplxType, TypeKind::FIR_COMPLEX> {
+public:
+  using Base::Base;
+  static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
+  KindTy getFKind() const;
+};
+
+/// Model of a Fortran INTEGER intrinsic type, including the KIND type
+/// parameter.
+class IntType
+    : public mlir::Type::TypeBase<IntType, mlir::Type, detail::IntTypeStorage>,
+      public IntrinsicTypeMixin<IntType, TypeKind::FIR_INT> {
+public:
+  using Base::Base;
+  static IntType get(mlir::MLIRContext *ctxt, KindTy kind);
+  KindTy getFKind() const;
+};
+
+/// Model of a Fortran LOGICAL intrinsic type, including the KIND type
+/// parameter.
+class LogicalType
+    : public mlir::Type::TypeBase<LogicalType, mlir::Type,
+                                  detail::LogicalTypeStorage>,
+      public IntrinsicTypeMixin<LogicalType, TypeKind::FIR_LOGICAL> {
+public:
+  using Base::Base;
+  static LogicalType get(mlir::MLIRContext *ctxt, KindTy kind);
+  KindTy getFKind() const;
+};
+
+/// Model of a Fortran REAL (and DOUBLE PRECISION) intrinsic type, including the
+/// KIND type parameter.
+class RealType : public mlir::Type::TypeBase<RealType, mlir::Type,
+                                             detail::RealTypeStorage>,
+                 public IntrinsicTypeMixin<RealType, TypeKind::FIR_REAL> {
+public:
+  using Base::Base;
+  static RealType get(mlir::MLIRContext *ctxt, KindTy kind);
+  KindTy getFKind() const;
+};
+
+// FIR support types
+
+/// The type of a Fortran descriptor. Descriptors are tuples of information that
+/// describe an entity being passed from a calling context. This information
+/// might include (but is not limited to) whether the entity is an array, its
+/// size, or what type it has.
+class BoxType
+    : public mlir::Type::TypeBase<BoxType, mlir::Type, detail::BoxTypeStorage> {
+public:
+  using Base::Base;
+  static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {});
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOX; }
+  mlir::Type getEleTy() const;
+  mlir::AffineMapAttr getLayoutMap() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
+                               mlir::AffineMapAttr map);
+};
+
+/// The type of a pair that describes a CHARACTER variable. Specifically, a
+/// CHARACTER consists of a reference to a buffer (the string value) and a LEN
+/// type parameter (the runtime length of the buffer).
+class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
+                                                detail::BoxCharTypeStorage> {
+public:
+  using Base::Base;
+  static BoxCharType get(mlir::MLIRContext *ctxt, KindTy kind);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXCHAR; }
+  CharacterType getEleTy() const;
+};
+
+/// The type of a pair that describes a PROCEDURE reference. Pointers to
+/// internal procedures must carry an additional reference to the host's
+/// variables that are referenced.
+class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
+                                                detail::BoxProcTypeStorage> {
+public:
+  using Base::Base;
+  static BoxProcType get(mlir::Type eleTy);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXPROC; }
+  mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
+};
+
+/// The type of a runtime vector that describes triples of array dimension
+/// information. A triple consists of a lower bound, upper bound, and
+/// stride. Each dimension of an array entity may have an associated triple that
+/// maps how elements of the array are accessed.
+class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
+                                             detail::DimsTypeStorage> {
+public:
+  using Base::Base;
+  static DimsType get(mlir::MLIRContext *ctx, unsigned rank);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_DIMS; }
+
+  /// returns -1 if the rank is unknown
+  int getRank() const;
+};
+
+/// The type of a field name. Implementations may defer the layout of a Fortran
+/// derived type until runtime. This implies that the runtime must be able to
+/// determine the offset of fields within the entity.
+class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
+                                              detail::FieldTypeStorage> {
+public:
+  using Base::Base;
+  static FieldType get(mlir::MLIRContext *ctxt);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_FIELD; }
+};
+
+/// The type of a heap pointer. Fortran entities with the ALLOCATABLE attribute
+/// may be allocated on the heap at runtime. These pointers are explicitly
+/// distinguished to disallow the composition of multiple levels of
+/// indirection. For example, an ALLOCATABLE POINTER is invalid.
+class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
+                                             detail::HeapTypeStorage> {
+public:
+  using Base::Base;
+  static HeapType get(mlir::Type elementType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_HEAP; }
+
+  mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
+};
+
+/// The type of a LEN parameter name. Implementations may defer the layout of a
+/// Fortran derived type until runtime. This implies that the runtime must be
+/// able to determine the offset of LEN type parameters related to an entity.
+class LenType
+    : public mlir::Type::TypeBase<LenType, mlir::Type, detail::LenTypeStorage> {
+public:
+  using Base::Base;
+  static LenType get(mlir::MLIRContext *ctxt);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_LEN; }
+};
+
+/// The type of entities with the POINTER attribute.  These pointers are
+/// explicitly distinguished to disallow the composition of multiple levels of
+/// indirection. For example, an ALLOCATABLE POINTER is invalid.
+class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
+                                                detail::PointerTypeStorage> {
+public:
+  using Base::Base;
+  static PointerType get(mlir::Type elementType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_POINTER; }
+
+  mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
+};
+
+/// The type of a reference to an entity in memory.
+class ReferenceType
+    : public mlir::Type::TypeBase<ReferenceType, mlir::Type,
+                                  detail::ReferenceTypeStorage> {
+public:
+  using Base::Base;
+  static ReferenceType get(mlir::Type elementType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_REFERENCE; }
+
+  mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
+};
+
+/// A sequence type is a multi-dimensional array of values. The sequence type
+/// may have an unknown number of dimensions or the extent of dimensions may be
+/// unknown. A sequence type models a Fortran array entity, giving it a type in
+/// FIR. A sequence type is assumed to be stored in a column-major order, which
+/// differs from LLVM IR and other dialects of MLIR.
+class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
+                                                 detail::SequenceTypeStorage> {
+public:
+  using Base::Base;
+  using Extent = int64_t;
+  using Shape = llvm::SmallVector<Extent, 8>;
+
+  /// Return a sequence type with the specified shape and element type
+  static SequenceType get(const Shape &shape, mlir::Type elementType,
+                          mlir::AffineMapAttr map = {});
+
+  /// The element type of this sequence
+  mlir::Type getEleTy() const;
+
+  /// The shape of the sequence. If the sequence has an unknown shape, the shape
+  /// returned will be empty.
+  Shape getShape() const;
+
+  mlir::AffineMapAttr getLayoutMap() const;
+
+  /// The number of dimensions of the sequence
+  unsigned getDimension() const { return getShape().size(); }
+
+  /// The value `-1` represents an unknown extent for a dimension
+  static constexpr Extent getUnknownExtent() { return -1; }
+
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(mlir::Location loc, const Shape &shape,
+                               mlir::Type eleTy, mlir::AffineMapAttr map);
+};
+
+bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
+llvm::hash_code hash_value(const SequenceType::Extent &);
+llvm::hash_code hash_value(const SequenceType::Shape &);
+
+/// The type of a type descriptor object. The runtime may generate type
+/// descriptor objects to determine the type of an entity at runtime, etc.
+class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
+                                                 detail::TypeDescTypeStorage> {
+public:
+  using Base::Base;
+  static TypeDescType get(mlir::Type ofType);
+  static constexpr bool kindof(unsigned kind) {
+    return kind == TypeKind::FIR_TYPEDESC;
+  }
+  mlir::Type getOfTy() const;
+
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type ofType);
+};
+
+// Derived types
+
+/// Model of Fortran's derived type, TYPE. The name of the TYPE includes any
+/// KIND type parameters. The record includes runtime slots for LEN type
+/// parameters and for data components.
+class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
+                                               detail::RecordTypeStorage> {
+public:
+  using Base::Base;
+  using TypePair = std::pair<std::string, mlir::Type>;
+  using TypeList = std::vector<TypePair>;
+
+  llvm::StringRef getName();
+  TypeList getTypeList();
+  TypeList getLenParamList();
+
+  mlir::Type getType(llvm::StringRef ident);
+  mlir::Type getType(unsigned index) {
+    assert(index < getNumFields());
+    return getTypeList()[index].second;
+  }
+  unsigned getNumFields() { return getTypeList().size(); }
+  unsigned getNumLenParams() { return getLenParamList().size(); }
+
+  static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
+  void finalize(llvm::ArrayRef<TypePair> lenPList,
+                llvm::ArrayRef<TypePair> typeList);
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return TypeKind::FIR_DERIVED; }
+
+  detail::RecordTypeStorage const *uniqueKey() const;
+
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          llvm::StringRef name);
+};
+
+mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
+
+void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);
+
+} // namespace fir
+
+#endif // OPTIMIZER_DIALECT_FIRTYPE_H
diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
new file mode 100644
index 000000000000..8c8ed1f24afd
--- /dev/null
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -0,0 +1,90 @@
+//===-- Optimizer/Support/KindMapping.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_SUPPORT_KINDMAPPING_H
+#define OPTIMIZER_SUPPORT_KINDMAPPING_H
+
+#include "mlir/IR/OpDefinition.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/IR/Type.h"
+
+namespace llvm {
+template <typename>
+class Optional;
+struct fltSemantics;
+} // namespace llvm
+
+namespace mlir {
+class MLIRContext;
+} // namespace mlir
+
+namespace fir {
+
+/// The kind mapping is an encoded string that informs FIR how the Fortran KIND
+/// values from the front-end should be converted to LLVM IR types.  This
+/// encoding allows the mapping from front-end KIND values to backend LLVM IR
+/// types to be customized by the front-end.
+///
+/// The provided string uses the following syntax.
+///
+///   intrinsic-key `:` kind-value (`,` intrinsic-key `:` kind-value)*
+///
+/// intrinsic-key is a single character for the intrinsic type.
+///   'i' : INTEGER   (size in bits)
+///   'l' : LOGICAL   (size in bits)
+///   'a' : CHARACTER (size in bits)
+///   'r' : REAL    (encoding value)
+///   'c' : COMPLEX (encoding value)
+///
+/// kind-value is either an unsigned integer (for 'i', 'l', and 'a') or one of
+/// 'Half', 'Float', 'Double', 'X86_FP80', or 'FP128' (for 'r' and 'c').
+///
+/// If LLVM adds support for new floating-point types, the final list should be
+/// extended.
+class KindMapping {
+public:
+  using KindTy = unsigned;
+  using Bitsize = unsigned;
+  using LLVMTypeID = llvm::Type::TypeID;
+  using MatchResult = mlir::ParseResult;
+
+  explicit KindMapping(mlir::MLIRContext *context);
+  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map);
+
+  /// Get the size in bits of !fir.char<kind>
+  Bitsize getCharacterBitsize(KindTy kind);
+
+  /// Get the size in bits of !fir.int<kind>
+  Bitsize getIntegerBitsize(KindTy kind);
+
+  /// Get the size in bits of !fir.logical<kind>
+  Bitsize getLogicalBitsize(KindTy kind);
+
+  /// Get the LLVM Type::TypeID of !fir.real<kind>
+  LLVMTypeID getRealTypeID(KindTy kind);
+
+  /// Get the LLVM Type::TypeID of !fir.complex<kind>
+  LLVMTypeID getComplexTypeID(KindTy kind);
+
+  mlir::MLIRContext *getContext() const { return context; }
+
+  /// Get the float semantics of !fir.real<kind>
+  const llvm::fltSemantics &getFloatSemantics(KindTy kind);
+
+private:
+  MatchResult badMapString(const llvm::Twine &ptr);
+  MatchResult parse(llvm::StringRef kindMap);
+
+  mlir::MLIRContext *context;
+  llvm::DenseMap<std::pair<char, KindTy>, Bitsize> intMap;
+  llvm::DenseMap<std::pair<char, KindTy>, LLVMTypeID> floatMap;
+};
+
+} // namespace fir
+
+#endif // OPTIMIZER_SUPPORT_KINDMAPPING_H
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index fae2eed92fa8..f2fe30dca5a1 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -12,3 +12,7 @@ add_subdirectory(Decimal)
 add_subdirectory(Lower)
 add_subdirectory(Parser)
 add_subdirectory(Semantics)
+
+if(LINK_WITH_FIR)
+  add_subdirectory(Optimizer)
+endif()
diff --git a/lib/Fir/.clang-format b/lib/Fir/.clang-format
deleted file mode 100644
index a74fda4b6734..000000000000
--- a/lib/Fir/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-BasedOnStyle: LLVM
-AlwaysBreakTemplateDeclarations: Yes
diff --git a/lib/Optimizer/CMakeLists.txt b/lib/Optimizer/CMakeLists.txt
new file mode 100644
index 000000000000..2f8cd269dd9f
--- /dev/null
+++ b/lib/Optimizer/CMakeLists.txt
@@ -0,0 +1,5 @@
+# Sources generated by tablegen have unused parameters.
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+
+add_subdirectory(Dialect)
+add_subdirectory(Support)
diff --git a/lib/Optimizer/Dialect/CMakeLists.txt b/lib/Optimizer/Dialect/CMakeLists.txt
new file mode 100644
index 000000000000..711fc64c5a2a
--- /dev/null
+++ b/lib/Optimizer/Dialect/CMakeLists.txt
@@ -0,0 +1,27 @@
+add_llvm_library(FIRDialect
+  FIRAttr.cpp
+  FIRDialect.cpp
+  FIROps.cpp
+  FIRType.cpp
+)
+
+add_dependencies(FIRDialect FIROpsIncGen)
+
+target_link_libraries(FIRDialect
+  MLIRTargetLLVMIR
+  MLIRTargetLLVMIRModuleTranslation
+  MLIREDSC
+  MLIRExecutionEngine
+  MLIRParser
+  MLIRSupport
+  MLIRStandardToLLVM
+  MLIRTransforms
+  LLVMAsmParser
+  LLVMAsmPrinter
+  LLVMRemarks
+)
+
+install (TARGETS FIRDialect
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+)
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
new file mode 100644
index 000000000000..1ba242b9484b
--- /dev/null
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -0,0 +1,238 @@
+//===-- FIRAttr.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/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "mlir/IR/AttributeSupport.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/Types.h"
+#include "mlir/Parser.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+
+using namespace fir;
+
+namespace fir {
+namespace detail {
+
+struct RealAttributeStorage : public mlir::AttributeStorage {
+  using KeyTy = std::pair<int, llvm::APFloat>;
+
+  RealAttributeStorage(int kind, const llvm::APFloat &value)
+      : kind(kind), value(value) {}
+  RealAttributeStorage(const KeyTy &key)
+      : RealAttributeStorage(key.first, key.second) {}
+
+  static unsigned hashKey(const KeyTy &key) {
+    return llvm::hash_value(key);
+  }
+
+  bool operator==(const KeyTy &key) const {
+    return key.first == kind &&
+           key.second.compare(value) == llvm::APFloatBase::cmpEqual;
+  }
+
+  static RealAttributeStorage *
+  construct(mlir::AttributeStorageAllocator &allocator, const KeyTy &key) {
+    return new (allocator.allocate<RealAttributeStorage>())
+        RealAttributeStorage(key);
+  }
+
+  int getFKind() const { return kind; }
+  llvm::APFloat getValue() const { return value; }
+
+private:
+  int kind;
+  llvm::APFloat value;
+};
+
+/// An attribute representing a reference to a type.
+struct TypeAttributeStorage : public mlir::AttributeStorage {
+  using KeyTy = mlir::Type;
+
+  TypeAttributeStorage(mlir::Type value) : value(value) {
+    assert(value && "must not be of Type null");
+  }
+
+  /// Key equality function.
+  bool operator==(const KeyTy &key) const { return key == value; }
+
+  /// Construct a new storage instance.
+  static TypeAttributeStorage *
+  construct(mlir::AttributeStorageAllocator &allocator, KeyTy key) {
+    return new (allocator.allocate<TypeAttributeStorage>())
+        TypeAttributeStorage(key);
+  }
+
+  mlir::Type getType() const { return value; }
+
+private:
+  mlir::Type value;
+};
+} // namespace detail
+
+ExactTypeAttr ExactTypeAttr::get(mlir::Type value) {
+  return Base::get(value.getContext(), FIR_EXACTTYPE, value);
+}
+
+mlir::Type ExactTypeAttr::getType() const { return getImpl()->getType(); }
+
+SubclassAttr SubclassAttr::get(mlir::Type value) {
+  return Base::get(value.getContext(), FIR_SUBCLASS, value);
+}
+
+mlir::Type SubclassAttr::getType() const { return getImpl()->getType(); }
+
+using AttributeUniquer = mlir::detail::AttributeUniquer;
+
+ClosedIntervalAttr ClosedIntervalAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<ClosedIntervalAttr>(ctxt, getId());
+}
+
+UpperBoundAttr UpperBoundAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<UpperBoundAttr>(ctxt, getId());
+}
+
+LowerBoundAttr LowerBoundAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<LowerBoundAttr>(ctxt, getId());
+}
+
+PointIntervalAttr PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<PointIntervalAttr>(ctxt, getId());
+}
+
+// RealAttr
+
+RealAttr RealAttr::get(mlir::MLIRContext *ctxt,
+                       const RealAttr::ValueType &key) {
+  return Base::get(ctxt, getId(), key);
+}
+
+int RealAttr::getFKind() const { return getImpl()->getFKind(); }
+
+llvm::APFloat RealAttr::getValue() const { return getImpl()->getValue(); }
+
+// FIR attribute parsing
+
+namespace {
+mlir::Attribute parseFirRealAttr(FIROpsDialect *dialect,
+                                 mlir::DialectAsmParser &parser,
+                                 mlir::Type type) {
+  int kind = 0;
+  if (parser.parseLess() || parser.parseInteger(kind) || parser.parseComma()) {
+    parser.emitError(parser.getNameLoc(), "expected '<' kind ','");
+    return {};
+  }
+  KindMapping kindMap(dialect->getContext());
+  llvm::APFloat value(0.);
+  if (parser.parseOptionalKeyword("i")) {
+    // `i` not present, so literal float must be present
+    double dontCare;
+    if (parser.parseFloat(dontCare) || parser.parseGreater()) {
+      parser.emitError(parser.getNameLoc(), "expected real constant '>'");
+      return {};
+    }
+    auto fltStr = parser.getFullSymbolSpec()
+                      .drop_until([](char c) { return c == ','; })
+                      .drop_front()
+                      .drop_while([](char c) { return c == ' ' || c == '\t'; })
+                      .take_until([](char c) {
+                        return c == '>' || c == ' ' || c == '\t';
+                      });
+    value = llvm::APFloat(kindMap.getFloatSemantics(kind), fltStr);
+  } else {
+    // `i` is present, so literal bitstring (hex) must be present
+    llvm::StringRef hex;
+    if (parser.parseKeyword(&hex) || parser.parseGreater()) {
+      parser.emitError(parser.getNameLoc(), "expected real constant '>'");
+      return {};
+    }
+    auto bits = llvm::APInt(kind * 8, hex.drop_front(), 16);
+    value = llvm::APFloat(kindMap.getFloatSemantics(kind), bits);
+  }
+  return RealAttr::get(dialect->getContext(), {kind, value});
+}
+} // namespace
+
+mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
+                                  mlir::DialectAsmParser &parser,
+                                  mlir::Type type) {
+  auto loc = parser.getNameLoc();
+  llvm::StringRef attrName;
+  if (parser.parseKeyword(&attrName)) {
+    parser.emitError(loc, "expected an attribute name");
+    return {};
+  }
+
+  if (attrName == ExactTypeAttr::getAttrName()) {
+    mlir::Type type;
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
+      parser.emitError(loc, "expected a type");
+      return {};
+    }
+    return ExactTypeAttr::get(type);
+  }
+  if (attrName == SubclassAttr::getAttrName()) {
+    mlir::Type type;
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
+      parser.emitError(loc, "expected a subtype");
+      return {};
+    }
+    return SubclassAttr::get(type);
+  }
+  if (attrName == PointIntervalAttr::getAttrName())
+    return PointIntervalAttr::get(dialect->getContext());
+  if (attrName == LowerBoundAttr::getAttrName())
+    return LowerBoundAttr::get(dialect->getContext());
+  if (attrName == UpperBoundAttr::getAttrName())
+    return UpperBoundAttr::get(dialect->getContext());
+  if (attrName == ClosedIntervalAttr::getAttrName())
+    return ClosedIntervalAttr::get(dialect->getContext());
+  if (attrName == RealAttr::getAttrName())
+    return parseFirRealAttr(dialect, parser, type);
+
+  parser.emitError(loc, "unknown FIR attribute: ") << attrName;
+  return {};
+}
+
+// FIR attribute pretty printer
+
+void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
+                       mlir::DialectAsmPrinter &p) {
+  auto &os = p.getStream();
+  if (auto exact = attr.dyn_cast<fir::ExactTypeAttr>()) {
+    os << fir::ExactTypeAttr::getAttrName() << '<';
+    p.printType(exact.getType());
+    os << '>';
+  } else if (auto sub = attr.dyn_cast<fir::SubclassAttr>()) {
+    os << fir::SubclassAttr::getAttrName() << '<';
+    p.printType(sub.getType());
+    os << '>';
+  } else if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
+    os << fir::PointIntervalAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+    os << fir::ClosedIntervalAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
+    os << fir::LowerBoundAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
+    os << fir::UpperBoundAttr::getAttrName();
+  } else if (auto a = attr.dyn_cast_or_null<fir::RealAttr>()) {
+    os << fir::RealAttr::getAttrName() << '<' << a.getFKind() << ", i x";
+    llvm::SmallString<40> ss;
+    a.getValue().bitcastToAPInt().toStringUnsigned(ss, 16);
+    os << ss << '>';
+  } else {
+    llvm_unreachable("attribute pretty-printer is not implemented");
+  }
+}
+
+} // namespace fir
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
new file mode 100644
index 000000000000..b6dd9edb2a2f
--- /dev/null
+++ b/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -0,0 +1,54 @@
+//===-- FIRDialect.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/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/IR/StandardTypes.h"
+
+using namespace fir;
+
+fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
+    : mlir::Dialect("fir", ctx) {
+  addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
+           FieldType, HeapType, IntType, LenType, LogicalType, PointerType,
+           RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
+  addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
+                PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
+  addOperations<
+#define GET_OP_LIST
+#include "flang/Optimizer/Dialect/FIROps.cpp.inc"
+                >();
+}
+
+// anchor the class vtable to this compilation unit
+fir::FIROpsDialect::~FIROpsDialect() {
+  // do nothing
+}
+
+mlir::Type fir::FIROpsDialect::parseType(mlir::DialectAsmParser &parser) const {
+  return parseFirType(const_cast<FIROpsDialect *>(this), parser);
+}
+
+void fir::FIROpsDialect::printType(mlir::Type ty,
+                                   mlir::DialectAsmPrinter &p) const {
+  return printFirType(const_cast<FIROpsDialect *>(this), ty, p);
+}
+
+mlir::Attribute
+fir::FIROpsDialect::parseAttribute(mlir::DialectAsmParser &parser,
+                                   mlir::Type type) const {
+  return parseFirAttribute(const_cast<FIROpsDialect *>(this), parser, type);
+}
+
+void fir::FIROpsDialect::printAttribute(mlir::Attribute attr,
+                                        mlir::DialectAsmPrinter &p) const {
+  printFirAttribute(const_cast<FIROpsDialect *>(this), attr, p);
+}
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
new file mode 100644
index 000000000000..9c46de048336
--- /dev/null
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -0,0 +1,862 @@
+//===-- FIROps.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/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "mlir/ADT/TypeSwitch.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/Function.h"
+#include "mlir/IR/Module.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/IR/SymbolTable.h"
+#include "llvm/ADT/StringSwitch.h"
+
+using namespace fir;
+
+/// return true if the sequence type is abstract or the record type is malformed
+/// or contains an abstract sequence type
+static bool verifyInType(mlir::Type inType,
+                         llvm::SmallVectorImpl<llvm::StringRef> &visited) {
+  if (auto st = inType.dyn_cast<fir::SequenceType>()) {
+    auto shape = st.getShape();
+    if (shape.size() == 0)
+      return true;
+    for (auto ext : shape)
+      if (ext < 0)
+        return true;
+  } else if (auto rt = inType.dyn_cast<fir::RecordType>()) {
+    // don't recurse if we're already visiting this one
+    if (llvm::is_contained(visited, rt.getName()))
+      return false;
+    // keep track of record types currently being visited
+    visited.push_back(rt.getName());
+    for (auto &field : rt.getTypeList())
+      if (verifyInType(field.second, visited))
+        return true;
+    visited.pop_back();
+  } else if (auto rt = inType.dyn_cast<fir::PointerType>()) {
+    return verifyInType(rt.getEleTy(), visited);
+  }
+  return false;
+}
+
+static bool verifyRecordLenParams(mlir::Type inType, unsigned numLenParams) {
+  if (numLenParams > 0) {
+    if (auto rt = inType.dyn_cast<fir::RecordType>())
+      return numLenParams != rt.getNumLenParams();
+    return true;
+  }
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// AllocaOp
+//===----------------------------------------------------------------------===//
+
+mlir::Type fir::AllocaOp::getAllocatedType() {
+  return getType().cast<ReferenceType>().getEleTy();
+}
+
+/// Create a legal memory reference as return type
+mlir::Type fir::AllocaOp::wrapResultType(mlir::Type intype) {
+  // FIR semantics: memory references to memory references are disallowed
+  if (intype.isa<ReferenceType>())
+    return {};
+  return ReferenceType::get(intype);
+}
+
+mlir::Type fir::AllocaOp::getRefTy(mlir::Type ty) {
+  return ReferenceType::get(ty);
+}
+
+//===----------------------------------------------------------------------===//
+// AllocMemOp
+//===----------------------------------------------------------------------===//
+
+mlir::Type fir::AllocMemOp::getAllocatedType() {
+  return getType().cast<HeapType>().getEleTy();
+}
+
+mlir::Type fir::AllocMemOp::getRefTy(mlir::Type ty) {
+  return HeapType::get(ty);
+}
+
+/// Create a legal heap reference as return type
+mlir::Type fir::AllocMemOp::wrapResultType(mlir::Type intype) {
+  // Fortran semantics: C852 an entity cannot be both ALLOCATABLE and POINTER
+  // 8.5.3 note 1 prohibits ALLOCATABLE procedures as well
+  // FIR semantics: one may not allocate a memory reference value
+  if (intype.isa<ReferenceType>() || intype.isa<HeapType>() ||
+      intype.isa<PointerType>() || intype.isa<FunctionType>())
+    return {};
+  return HeapType::get(intype);
+}
+
+//===----------------------------------------------------------------------===//
+// BoxDimsOp
+//===----------------------------------------------------------------------===//
+
+/// Get the result types packed in a tuple tuple
+mlir::Type fir::BoxDimsOp::getTupleType() {
+  // note: triple, but 4 is nearest power of 2
+  llvm::SmallVector<mlir::Type, 4> triple{
+      getResult(0).getType(), getResult(1).getType(), getResult(2).getType()};
+  return mlir::TupleType::get(triple, getContext());
+}
+
+//===----------------------------------------------------------------------===//
+// CallOp
+//===----------------------------------------------------------------------===//
+
+static void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
+  auto callee = op.callee();
+  bool isDirect = callee.hasValue();
+  p << op.getOperationName() << ' ';
+  if (isDirect)
+    p << callee.getValue();
+  else
+    p << op.getOperand(0);
+  p << '(' << op.getOperands().drop_front(isDirect ? 0 : 1) << ')';
+  p.printOptionalAttrDict(op.getAttrs(), {fir::CallOp::calleeAttrName()});
+  auto resultTypes{op.getResultTypes()};
+  llvm::SmallVector<Type, 8> argTypes(
+      llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
+  p << " : " << FunctionType::get(argTypes, resultTypes, op.getContext());
+}
+
+static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
+                                     mlir::OperationState &result) {
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+  if (parser.parseOperandList(operands))
+    return mlir::failure();
+
+  llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
+  mlir::SymbolRefAttr funcAttr;
+  bool isDirect = operands.empty();
+  if (isDirect)
+    if (parser.parseAttribute(funcAttr, fir::CallOp::calleeAttrName(), attrs))
+      return mlir::failure();
+
+  Type type;
+  if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
+      parser.parseOptionalAttrDict(attrs) || parser.parseColon() ||
+      parser.parseType(type))
+    return mlir::failure();
+
+  auto funcType = type.dyn_cast<mlir::FunctionType>();
+  if (!funcType)
+    return parser.emitError(parser.getNameLoc(), "expected function type");
+  if (isDirect) {
+    if (parser.resolveOperands(operands, funcType.getInputs(),
+                               parser.getNameLoc(), result.operands))
+      return mlir::failure();
+  } else {
+    auto funcArgs =
+        llvm::ArrayRef<mlir::OpAsmParser::OperandType>(operands).drop_front();
+    llvm::SmallVector<mlir::Value, 8> resultArgs(
+        result.operands.begin() + (result.operands.empty() ? 0 : 1),
+        result.operands.end());
+    if (parser.resolveOperand(operands[0], funcType, result.operands) ||
+        parser.resolveOperands(funcArgs, funcType.getInputs(),
+                               parser.getNameLoc(), resultArgs))
+      return mlir::failure();
+  }
+  result.addTypes(funcType.getResults());
+  result.attributes = attrs;
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// CmpfOp
+//===----------------------------------------------------------------------===//
+
+// Note: getCmpFPredicateNames() is inline static in StandardOps/IR/Ops.cpp
+mlir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
+  auto pred = mlir::symbolizeCmpFPredicate(name);
+  assert(pred.hasValue() && "invalid predicate name");
+  return pred.getValue();
+}
+
+void fir::buildCmpFOp(Builder *builder, OperationState &result,
+                      CmpFPredicate predicate, Value lhs, Value rhs) {
+  result.addOperands({lhs, rhs});
+  result.types.push_back(builder->getI1Type());
+  result.addAttribute(
+      CmpfOp::getPredicateAttrName(),
+      builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
+}
+
+template <typename OPTY>
+static void printCmpOp(OpAsmPrinter &p, OPTY op) {
+  p << op.getOperationName() << ' ';
+  auto predSym = mlir::symbolizeCmpFPredicate(
+      op.template getAttrOfType<mlir::IntegerAttr>(OPTY::getPredicateAttrName())
+          .getInt());
+  assert(predSym.hasValue() && "invalid symbol value for predicate");
+  p << '"' << mlir::stringifyCmpFPredicate(predSym.getValue()) << '"' << ", ";
+  p.printOperand(op.lhs());
+  p << ", ";
+  p.printOperand(op.rhs());
+  p.printOptionalAttrDict(op.getAttrs(),
+                          /*elidedAttrs=*/{OPTY::getPredicateAttrName()});
+  p << " : " << op.lhs().getType();
+}
+
+static void printCmpfOp(OpAsmPrinter &p, CmpfOp op) { printCmpOp(p, op); }
+
+template <typename OPTY>
+static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
+                                    mlir::OperationState &result) {
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> ops;
+  llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
+  mlir::Attribute predicateNameAttr;
+  mlir::Type type;
+  if (parser.parseAttribute(predicateNameAttr, OPTY::getPredicateAttrName(),
+                            attrs) ||
+      parser.parseComma() || parser.parseOperandList(ops, 2) ||
+      parser.parseOptionalAttrDict(attrs) || parser.parseColonType(type) ||
+      parser.resolveOperands(ops, type, result.operands))
+    return failure();
+
+  if (!predicateNameAttr.isa<mlir::StringAttr>())
+    return parser.emitError(parser.getNameLoc(),
+                            "expected string comparison predicate attribute");
+
+  // Rewrite string attribute to an enum value.
+  llvm::StringRef predicateName =
+      predicateNameAttr.cast<mlir::StringAttr>().getValue();
+  auto predicate = fir::CmpfOp::getPredicateByName(predicateName);
+  auto builder = parser.getBuilder();
+  mlir::Type i1Type = builder.getI1Type();
+  attrs[0].second = builder.getI64IntegerAttr(static_cast<int64_t>(predicate));
+  result.attributes = attrs;
+  result.addTypes({i1Type});
+  return success();
+}
+
+mlir::ParseResult fir::parseCmpfOp(mlir::OpAsmParser &parser,
+                                   mlir::OperationState &result) {
+  return parseCmpOp<fir::CmpfOp>(parser, result);
+}
+
+//===----------------------------------------------------------------------===//
+// CmpcOp
+//===----------------------------------------------------------------------===//
+
+void fir::buildCmpCOp(Builder *builder, OperationState &result,
+                      CmpFPredicate predicate, Value lhs, Value rhs) {
+  result.addOperands({lhs, rhs});
+  result.types.push_back(builder->getI1Type());
+  result.addAttribute(
+      fir::CmpcOp::getPredicateAttrName(),
+      builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
+}
+
+static void printCmpcOp(OpAsmPrinter &p, fir::CmpcOp op) { printCmpOp(p, op); }
+
+mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
+                                   mlir::OperationState &result) {
+  return parseCmpOp<fir::CmpcOp>(parser, result);
+}
+
+//===----------------------------------------------------------------------===//
+// DispatchOp
+//===----------------------------------------------------------------------===//
+
+mlir::FunctionType fir::DispatchOp::getFunctionType() {
+  auto attr = getAttr("fn_type").cast<mlir::TypeAttr>();
+  return attr.getValue().cast<mlir::FunctionType>();
+}
+
+//===----------------------------------------------------------------------===//
+// DispatchTableOp
+//===----------------------------------------------------------------------===//
+
+void fir::DispatchTableOp::appendTableEntry(mlir::Operation *op) {
+  assert(mlir::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
+  auto &block = getBlock();
+  block.getOperations().insert(block.end(), op);
+}
+
+//===----------------------------------------------------------------------===//
+// EmboxOp
+//===----------------------------------------------------------------------===//
+
+static mlir::ParseResult parseEmboxOp(mlir::OpAsmParser &parser,
+                                      mlir::OperationState &result) {
+  mlir::FunctionType type;
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+  mlir::OpAsmParser::OperandType memref;
+  if (parser.parseOperand(memref))
+    return mlir::failure();
+  operands.push_back(memref);
+  auto &builder = parser.getBuilder();
+  if (!parser.parseOptionalLParen()) {
+    if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseRParen())
+      return mlir::failure();
+    auto lens = builder.getI32IntegerAttr(operands.size());
+    result.addAttribute(fir::EmboxOp::lenpName(), lens);
+  }
+  if (!parser.parseOptionalComma()) {
+    mlir::OpAsmParser::OperandType dims;
+    if (parser.parseOperand(dims))
+      return mlir::failure();
+    operands.push_back(dims);
+  } else if (!parser.parseOptionalLSquare()) {
+    mlir::AffineMapAttr map;
+    if (parser.parseAttribute(map, fir::EmboxOp::layoutName(),
+                              result.attributes) ||
+        parser.parseRSquare())
+      return mlir::failure();
+  }
+  if (parser.parseOptionalAttrDict(result.attributes) ||
+      parser.parseColonType(type) ||
+      parser.resolveOperands(operands, type.getInputs(), parser.getNameLoc(),
+                             result.operands) ||
+      parser.addTypesToList(type.getResults(), result.types))
+    return mlir::failure();
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// GenTypeDescOp
+//===----------------------------------------------------------------------===//
+
+void fir::GenTypeDescOp::build(Builder *, OperationState &result,
+                               mlir::TypeAttr inty) {
+  result.addAttribute("in_type", inty);
+  result.addTypes(TypeDescType::get(inty.getValue()));
+}
+
+//===----------------------------------------------------------------------===//
+// GlobalOp
+//===----------------------------------------------------------------------===//
+
+void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
+  getBlock().getOperations().push_back(op);
+}
+
+//===----------------------------------------------------------------------===//
+// LoadOp
+//===----------------------------------------------------------------------===//
+
+/// Get the element type of a reference like type; otherwise null
+static mlir::Type elementTypeOf(mlir::Type ref) {
+  return mlir::TypeSwitch<mlir::Type, mlir::Type>(ref)
+      .Case<ReferenceType, PointerType, HeapType>(
+          [](auto type) { return type.getEleTy(); })
+      .Default([](mlir::Type) { return mlir::Type{}; });
+}
+
+mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
+  if ((ele = elementTypeOf(ref)))
+    return mlir::success();
+  return mlir::failure();
+}
+
+//===----------------------------------------------------------------------===//
+// LoopOp
+//===----------------------------------------------------------------------===//
+
+void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
+                        mlir::Value lb, mlir::Value ub, ValueRange step,
+                        ArrayRef<NamedAttribute> attributes) {
+  if (step.empty())
+    result.addOperands({lb, ub});
+  else
+    result.addOperands({lb, ub, step[0]});
+  mlir::Region *bodyRegion = result.addRegion();
+  LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
+  bodyRegion->front().addArgument(builder->getIndexType());
+  result.addAttributes(attributes);
+  NamedAttributeList attrs(attributes);
+  if (!attrs.get(unorderedAttrName()))
+    result.addTypes(builder->getIndexType());
+}
+
+static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
+                                     mlir::OperationState &result) {
+  auto &builder = parser.getBuilder();
+  OpAsmParser::OperandType inductionVariable, lb, ub, step;
+  // Parse the induction variable followed by '='.
+  if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
+    return mlir::failure();
+
+  // Parse loop bounds.
+  mlir::Type indexType = builder.getIndexType();
+  if (parser.parseOperand(lb) ||
+      parser.resolveOperand(lb, indexType, result.operands) ||
+      parser.parseKeyword("to") || parser.parseOperand(ub) ||
+      parser.resolveOperand(ub, indexType, result.operands))
+    return mlir::failure();
+
+  if (parser.parseOptionalKeyword(fir::LoopOp::stepAttrName())) {
+    result.addAttribute(fir::LoopOp::stepAttrName(),
+                        builder.getIntegerAttr(builder.getIndexType(), 1));
+  } else if (parser.parseOperand(step) ||
+             parser.resolveOperand(step, indexType, result.operands)) {
+    return mlir::failure();
+  }
+
+  // Parse the optional `unordered` keyword
+  bool isUnordered = false;
+  if (!parser.parseOptionalKeyword(LoopOp::unorderedAttrName())) {
+    result.addAttribute(LoopOp::unorderedAttrName(), builder.getUnitAttr());
+    isUnordered = true;
+  }
+
+  // Parse the body region.
+  mlir::Region *body = result.addRegion();
+  if (parser.parseRegion(*body, inductionVariable, indexType))
+    return mlir::failure();
+
+  fir::LoopOp::ensureTerminator(*body, builder, result.location);
+
+  // Parse the optional attribute list.
+  if (parser.parseOptionalAttrDict(result.attributes))
+    return mlir::failure();
+  if (!isUnordered)
+    result.addTypes(builder.getIndexType());
+  return mlir::success();
+}
+
+fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
+  auto ivArg = val.dyn_cast<mlir::BlockArgument>();
+  if (!ivArg)
+    return {};
+  assert(ivArg.getOwner() && "unlinked block argument");
+  auto *containingInst = ivArg.getOwner()->getParentOp();
+  return dyn_cast_or_null<fir::LoopOp>(containingInst);
+}
+
+//===----------------------------------------------------------------------===//
+// SelectOp
+//===----------------------------------------------------------------------===//
+
+static constexpr llvm::StringRef getCompareOffsetAttr() {
+  return "compare_operand_offsets";
+}
+
+static constexpr llvm::StringRef getTargetOffsetAttr() {
+  return "target_operand_offsets";
+}
+
+template <typename A>
+static A getSubOperands(unsigned pos, A allArgs,
+                        mlir::DenseIntElementsAttr ranges) {
+  unsigned start = 0;
+  for (unsigned i = 0; i < pos; ++i)
+    start += (*(ranges.begin() + i)).getZExtValue();
+  unsigned end = start + (*(ranges.begin() + pos)).getZExtValue();
+  return {std::next(allArgs.begin(), start), std::next(allArgs.begin(), end)};
+}
+
+llvm::Optional<mlir::OperandRange> fir::SelectOp::getCompareOperands(unsigned) {
+  return {};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
+  return {};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                    unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectOp::canEraseSuccessorOperand() { return true; }
+
+//===----------------------------------------------------------------------===//
+// SelectCaseOp
+//===----------------------------------------------------------------------===//
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectCaseOp::getCompareOperands(unsigned cond) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr());
+  return {getSubOperands(cond, compareArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectCaseOp::getCompareOperands(llvm::ArrayRef<mlir::Value> operands,
+                                      unsigned cond) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(cond, getSubOperands(1, operands, segments), a)};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectCaseOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectCaseOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                        unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectCaseOp::canEraseSuccessorOperand() { return true; }
+
+// parser for fir.select_case Op
+static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
+                                         mlir::OperationState &result) {
+  mlir::OpAsmParser::OperandType selector;
+  mlir::Type type;
+  if (parseSelector(parser, result, selector, type))
+    return mlir::failure();
+
+  llvm::SmallVector<mlir::Attribute, 8> attrs;
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> opers;
+  llvm::SmallVector<mlir::Block *, 8> dests;
+  llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
+  llvm::SmallVector<int32_t, 8> argOffs;
+  int32_t offSize = 0;
+  while (true) {
+    mlir::Attribute attr;
+    mlir::Block *dest;
+    llvm::SmallVector<mlir::Value, 8> destArg;
+    llvm::SmallVector<mlir::NamedAttribute, 1> temp;
+    if (parser.parseAttribute(attr, "a", temp) || isValidCaseAttr(attr) ||
+        parser.parseComma())
+      return mlir::failure();
+    attrs.push_back(attr);
+    if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
+      argOffs.push_back(0);
+    } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+      mlir::OpAsmParser::OperandType oper1;
+      mlir::OpAsmParser::OperandType oper2;
+      if (parser.parseOperand(oper1) || parser.parseComma() ||
+          parser.parseOperand(oper2) || parser.parseComma())
+        return mlir::failure();
+      opers.push_back(oper1);
+      opers.push_back(oper2);
+      argOffs.push_back(2);
+      offSize += 2;
+    } else {
+      mlir::OpAsmParser::OperandType oper;
+      if (parser.parseOperand(oper) || parser.parseComma())
+        return mlir::failure();
+      opers.push_back(oper);
+      argOffs.push_back(1);
+      ++offSize;
+    }
+    if (parser.parseSuccessorAndUseList(dest, destArg))
+      return mlir::failure();
+    dests.push_back(dest);
+    destArgs.push_back(destArg);
+    if (!parser.parseOptionalRSquare())
+      break;
+    if (parser.parseComma())
+      return mlir::failure();
+  }
+  result.addAttribute(fir::SelectCaseOp::getCasesAttr(),
+                      parser.getBuilder().getArrayAttr(attrs));
+  if (parser.resolveOperands(opers, type, result.operands))
+    return mlir::failure();
+  llvm::SmallVector<int32_t, 8> targOffs;
+  int32_t toffSize = 0;
+  const auto count = dests.size();
+  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+    result.addSuccessors(dests[i]);
+    result.addOperands(destArgs[i]);
+    auto argSize = destArgs[i].size();
+    targOffs.push_back(argSize);
+    toffSize += argSize;
+  }
+  auto &bld = parser.getBuilder();
+  result.addAttribute(fir::SelectCaseOp::getOperandSegmentSizeAttr(),
+                      bld.getI32VectorAttr({1, offSize, toffSize}));
+  result.addAttribute(getCompareOffsetAttr(), bld.getI32VectorAttr(argOffs));
+  result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(targOffs));
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// SelectRankOp
+//===----------------------------------------------------------------------===//
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectRankOp::getCompareOperands(unsigned) {
+  return {};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectRankOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
+  return {};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectRankOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectRankOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                        unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectRankOp::canEraseSuccessorOperand() { return true; }
+
+//===----------------------------------------------------------------------===//
+// SelectTypeOp
+//===----------------------------------------------------------------------===//
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectTypeOp::getCompareOperands(unsigned) {
+  return {};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectTypeOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
+  return {};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectTypeOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectTypeOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                        unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectTypeOp::canEraseSuccessorOperand() { return true; }
+
+static ParseResult parseSelectType(OpAsmParser &parser,
+                                   OperationState &result) {
+  mlir::OpAsmParser::OperandType selector;
+  mlir::Type type;
+  if (parseSelector(parser, result, selector, type))
+    return mlir::failure();
+
+  llvm::SmallVector<mlir::Attribute, 8> attrs;
+  llvm::SmallVector<mlir::Block *, 8> dests;
+  llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
+  while (true) {
+    mlir::Attribute attr;
+    mlir::Block *dest;
+    llvm::SmallVector<mlir::Value, 8> destArg;
+    llvm::SmallVector<mlir::NamedAttribute, 1> temp;
+    if (parser.parseAttribute(attr, "a", temp) || parser.parseComma() ||
+        parser.parseSuccessorAndUseList(dest, destArg))
+      return mlir::failure();
+    attrs.push_back(attr);
+    dests.push_back(dest);
+    destArgs.push_back(destArg);
+    if (!parser.parseOptionalRSquare())
+      break;
+    if (parser.parseComma())
+      return mlir::failure();
+  }
+  auto &bld = parser.getBuilder();
+  result.addAttribute(fir::SelectTypeOp::getCasesAttr(),
+                      bld.getArrayAttr(attrs));
+  llvm::SmallVector<int32_t, 8> argOffs;
+  int32_t offSize = 0;
+  const auto count = dests.size();
+  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+    result.addSuccessors(dests[i]);
+    result.addOperands(destArgs[i]);
+    auto argSize = destArgs[i].size();
+    argOffs.push_back(argSize);
+    offSize += argSize;
+  }
+  result.addAttribute(fir::SelectTypeOp::getOperandSegmentSizeAttr(),
+                      bld.getI32VectorAttr({1, 0, offSize}));
+  result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// StoreOp
+//===----------------------------------------------------------------------===//
+
+mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
+  if (auto ref = refType.dyn_cast<ReferenceType>())
+    return ref.getEleTy();
+  if (auto ref = refType.dyn_cast<PointerType>())
+    return ref.getEleTy();
+  if (auto ref = refType.dyn_cast<HeapType>())
+    return ref.getEleTy();
+  return {};
+}
+
+//===----------------------------------------------------------------------===//
+// StringLitOp
+//===----------------------------------------------------------------------===//
+
+bool fir::StringLitOp::isWideValue() {
+  auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
+  return eleTy.cast<fir::CharacterType>().getFKind() != 1;
+}
+
+//===----------------------------------------------------------------------===//
+// WhereOp
+//===----------------------------------------------------------------------===//
+
+void fir::WhereOp::build(mlir::Builder *builder, OperationState &result,
+                         mlir::Value cond, bool withElseRegion) {
+  result.addOperands(cond);
+  mlir::Region *thenRegion = result.addRegion();
+  mlir::Region *elseRegion = result.addRegion();
+  WhereOp::ensureTerminator(*thenRegion, *builder, result.location);
+  if (withElseRegion)
+    WhereOp::ensureTerminator(*elseRegion, *builder, result.location);
+}
+
+static mlir::ParseResult parseWhereOp(OpAsmParser &parser,
+                                      OperationState &result) {
+  result.regions.reserve(2);
+  mlir::Region *thenRegion = result.addRegion();
+  mlir::Region *elseRegion = result.addRegion();
+
+  auto &builder = parser.getBuilder();
+  OpAsmParser::OperandType cond;
+  mlir::Type i1Type = builder.getIntegerType(1);
+  if (parser.parseOperand(cond) ||
+      parser.resolveOperand(cond, i1Type, result.operands))
+    return mlir::failure();
+
+  if (parser.parseRegion(*thenRegion, {}, {}))
+    return mlir::failure();
+
+  WhereOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
+
+  if (!parser.parseOptionalKeyword("otherwise")) {
+    if (parser.parseRegion(*elseRegion, {}, {}))
+      return mlir::failure();
+    WhereOp::ensureTerminator(*elseRegion, parser.getBuilder(),
+                              result.location);
+  }
+
+  // Parse the optional attribute list.
+  if (parser.parseOptionalAttrDict(result.attributes))
+    return mlir::failure();
+
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+
+mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {
+  if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||
+      attr.dyn_cast_or_null<ClosedIntervalAttr>() ||
+      attr.dyn_cast_or_null<PointIntervalAttr>() ||
+      attr.dyn_cast_or_null<LowerBoundAttr>() ||
+      attr.dyn_cast_or_null<UpperBoundAttr>())
+    return mlir::success();
+  return mlir::failure();
+}
+
+unsigned fir::getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
+                                    unsigned dest) {
+  unsigned o = 0;
+  for (unsigned i = 0; i < dest; ++i) {
+    auto &attr = cases[i];
+    if (!attr.dyn_cast_or_null<mlir::UnitAttr>()) {
+      ++o;
+      if (attr.dyn_cast_or_null<ClosedIntervalAttr>())
+        ++o;
+    }
+  }
+  return o;
+}
+
+mlir::ParseResult fir::parseSelector(mlir::OpAsmParser &parser,
+                                     mlir::OperationState &result,
+                                     mlir::OpAsmParser::OperandType &selector,
+                                     mlir::Type &type) {
+  if (parser.parseOperand(selector) || parser.parseColonType(type) ||
+      parser.resolveOperand(selector, type, result.operands) ||
+      parser.parseLSquare())
+    return mlir::failure();
+  return mlir::success();
+}
+
+/// Generic pretty-printer of a binary operation
+static void printBinaryOp(Operation *op, OpAsmPrinter &p) {
+  assert(op->getNumOperands() == 2 && "binary op must have two operands");
+  assert(op->getNumResults() == 1 && "binary op must have one result");
+
+  p << op->getName() << ' ' << op->getOperand(0) << ", " << op->getOperand(1);
+  p.printOptionalAttrDict(op->getAttrs());
+  p << " : " << op->getResult(0).getType();
+}
+
+/// Generic pretty-printer of an unary operation
+static void printUnaryOp(Operation *op, OpAsmPrinter &p) {
+  assert(op->getNumOperands() == 1 && "unary op must have one operand");
+  assert(op->getNumResults() == 1 && "unary op must have one result");
+
+  p << op->getName() << ' ' << op->getOperand(0);
+  p.printOptionalAttrDict(op->getAttrs());
+  p << " : " << op->getResult(0).getType();
+}
+
+bool fir::isReferenceLike(mlir::Type type) {
+  return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
+         type.isa<fir::PointerType>();
+}
+
+mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
+                               StringRef name, mlir::FunctionType type,
+                               llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
+    return f;
+  mlir::OpBuilder modBuilder(module.getBodyRegion());
+  return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
+}
+
+fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
+                                  StringRef name, mlir::Type type,
+                                  llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
+    return g;
+  mlir::OpBuilder modBuilder(module.getBodyRegion());
+  return modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
+}
+
+namespace fir {
+
+// Tablegen operators
+
+#define GET_OP_CLASSES
+#include "flang/Optimizer/Dialect/FIROps.cpp.inc"
+
+} // namespace fir
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
new file mode 100644
index 000000000000..d1fccd7be317
--- /dev/null
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -0,0 +1,1292 @@
+//===-- FIRType.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/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "mlir/ADT/TypeSwitch.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/Parser.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/StringSet.h"
+
+using namespace fir;
+
+namespace {
+
+template <typename TYPE>
+TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
+  int kind = 0;
+  if (parser.parseLess() || parser.parseInteger(kind) ||
+      parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "kind value expected");
+    return {};
+  }
+  return TYPE::get(parser.getBuilder().getContext(), kind);
+}
+
+template <typename TYPE>
+TYPE parseKindSingleton(mlir::DialectAsmParser &parser) {
+  return parseIntSingleton<TYPE>(parser);
+}
+
+template <typename TYPE>
+TYPE parseRankSingleton(mlir::DialectAsmParser &parser) {
+  return parseIntSingleton<TYPE>(parser);
+}
+
+template <typename TYPE>
+TYPE parseTypeSingleton(mlir::DialectAsmParser &parser, mlir::Location) {
+  mlir::Type ty;
+  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "type expected");
+    return {};
+  }
+  return TYPE::get(ty);
+}
+
+// `box` `<` type (',' affine-map)? `>`
+BoxType parseBox(mlir::DialectAsmParser &parser, mlir::Location loc) {
+  mlir::Type ofTy;
+  if (parser.parseLess() || parser.parseType(ofTy)) {
+    parser.emitError(parser.getCurrentLocation(), "expected type parameter");
+    return {};
+  }
+
+  mlir::AffineMapAttr map;
+  if (!parser.parseOptionalComma())
+    if (parser.parseAttribute(map)) {
+      parser.emitError(parser.getCurrentLocation(), "expected affine map");
+      return {};
+    }
+  if (parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "expected '>'");
+    return {};
+  }
+  return BoxType::get(ofTy, map);
+}
+
+// `boxchar` `<` kind `>`
+BoxCharType parseBoxChar(mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<BoxCharType>(parser);
+}
+
+// `boxproc` `<` return-type `>`
+BoxProcType parseBoxProc(mlir::DialectAsmParser &parser, mlir::Location loc) {
+  return parseTypeSingleton<BoxProcType>(parser, loc);
+}
+
+// `char` `<` kind `>`
+CharacterType parseCharacter(mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<CharacterType>(parser);
+}
+
+// `complex` `<` kind `>`
+CplxType parseComplex(mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<CplxType>(parser);
+}
+
+// `dims` `<` rank `>`
+DimsType parseDims(mlir::DialectAsmParser &parser) {
+  return parseRankSingleton<DimsType>(parser);
+}
+
+// `field`
+FieldType parseField(mlir::DialectAsmParser &parser) {
+  return FieldType::get(parser.getBuilder().getContext());
+}
+
+// `heap` `<` type `>`
+HeapType parseHeap(mlir::DialectAsmParser &parser, mlir::Location loc) {
+  return parseTypeSingleton<HeapType>(parser, loc);
+}
+
+// `int` `<` kind `>`
+IntType parseInteger(mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<IntType>(parser);
+}
+
+// `len`
+LenType parseLen(mlir::DialectAsmParser &parser) {
+  return LenType::get(parser.getBuilder().getContext());
+}
+
+// `logical` `<` kind `>`
+LogicalType parseLogical(mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<LogicalType>(parser);
+}
+
+// `ptr` `<` type `>`
+PointerType parsePointer(mlir::DialectAsmParser &parser, mlir::Location loc) {
+  return parseTypeSingleton<PointerType>(parser, loc);
+}
+
+// `real` `<` kind `>`
+RealType parseReal(mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<RealType>(parser);
+}
+
+// `ref` `<` type `>`
+ReferenceType parseReference(mlir::DialectAsmParser &parser,
+                             mlir::Location loc) {
+  return parseTypeSingleton<ReferenceType>(parser, loc);
+}
+
+// `tdesc` `<` type `>`
+TypeDescType parseTypeDesc(mlir::DialectAsmParser &parser, mlir::Location loc) {
+  return parseTypeSingleton<TypeDescType>(parser, loc);
+}
+
+// `void`
+mlir::Type parseVoid(mlir::DialectAsmParser &parser) {
+  return parser.getBuilder().getNoneType();
+}
+
+// `array` `<` `*` | bounds (`x` bounds)* `:` type (',' affine-map)? `>`
+// bounds ::= `?` | int-lit
+SequenceType parseSequence(mlir::DialectAsmParser &parser, mlir::Location) {
+  if (parser.parseLess()) {
+    parser.emitError(parser.getNameLoc(), "expecting '<'");
+    return {};
+  }
+  SequenceType::Shape shape;
+  if (parser.parseOptionalStar()) {
+    if (parser.parseDimensionList(shape, true)) {
+      parser.emitError(parser.getNameLoc(), "invalid shape");
+      return {};
+    }
+  } else if (parser.parseColon()) {
+    parser.emitError(parser.getNameLoc(), "expected ':'");
+    return {};
+  }
+  mlir::Type eleTy;
+  if (parser.parseType(eleTy) || parser.parseGreater()) {
+    parser.emitError(parser.getNameLoc(), "expecting element type");
+    return {};
+  }
+  mlir::AffineMapAttr map;
+  if (!parser.parseOptionalComma())
+    if (parser.parseAttribute(map)) {
+      parser.emitError(parser.getNameLoc(), "expecting affine map");
+      return {};
+    }
+  return SequenceType::get(shape, eleTy, map);
+}
+
+bool verifyIntegerType(mlir::Type ty) {
+  return ty.isa<mlir::IntegerType>() || ty.isa<IntType>();
+}
+
+bool verifyRecordMemberType(mlir::Type ty) {
+  return !(ty.isa<BoxType>() || ty.isa<BoxCharType>() ||
+           ty.isa<BoxProcType>() || ty.isa<DimsType>() || ty.isa<FieldType>() ||
+           ty.isa<LenType>() || ty.isa<ReferenceType>() ||
+           ty.isa<TypeDescType>());
+}
+
+bool verifySameLists(llvm::ArrayRef<RecordType::TypePair> a1,
+                     llvm::ArrayRef<RecordType::TypePair> a2) {
+  // FIXME: do we need to allow for any variance here?
+  return a1 == a2;
+}
+
+RecordType verifyDerived(mlir::DialectAsmParser &parser, RecordType derivedTy,
+                         llvm::ArrayRef<RecordType::TypePair> lenPList,
+                         llvm::ArrayRef<RecordType::TypePair> typeList) {
+  auto loc = parser.getNameLoc();
+  if (!verifySameLists(derivedTy.getLenParamList(), lenPList) ||
+      !verifySameLists(derivedTy.getTypeList(), typeList)) {
+    parser.emitError(loc, "cannot redefine record type members");
+    return {};
+  }
+  for (auto &p : lenPList)
+    if (!verifyIntegerType(p.second)) {
+      parser.emitError(loc, "LEN parameter must be integral type");
+      return {};
+    }
+  for (auto &p : typeList)
+    if (!verifyRecordMemberType(p.second)) {
+      parser.emitError(loc, "field parameter has invalid type");
+      return {};
+    }
+  llvm::StringSet<> uniq;
+  for (auto &p : lenPList)
+    if (!uniq.insert(p.first).second) {
+      parser.emitError(loc, "LEN parameter cannot have duplicate name");
+      return {};
+    }
+  for (auto &p : typeList)
+    if (!uniq.insert(p.first).second) {
+      parser.emitError(loc, "field cannot have duplicate name");
+      return {};
+    }
+  return derivedTy;
+}
+
+// Fortran derived type
+// `type` `<` name
+//           (`(` id `:` type (`,` id `:` type)* `)`)?
+//           (`{` id `:` type (`,` id `:` type)* `}`)? '>'
+RecordType parseDerived(mlir::DialectAsmParser &parser, mlir::Location) {
+  llvm::StringRef name;
+  if (parser.parseLess() || parser.parseKeyword(&name)) {
+    parser.emitError(parser.getNameLoc(),
+                     "expected a identifier as name of derived type");
+    return {};
+  }
+  RecordType result = RecordType::get(parser.getBuilder().getContext(), name);
+
+  RecordType::TypeList lenParamList;
+  if (!parser.parseOptionalLParen()) {
+    while (true) {
+      llvm::StringRef lenparam;
+      mlir::Type intTy;
+      if (parser.parseKeyword(&lenparam) || parser.parseColon() ||
+          parser.parseType(intTy)) {
+        parser.emitError(parser.getNameLoc(), "expected LEN parameter list");
+        return {};
+      }
+      lenParamList.emplace_back(lenparam, intTy);
+      if (parser.parseOptionalComma())
+        break;
+    }
+    if (parser.parseRParen()) {
+      parser.emitError(parser.getNameLoc(), "expected ')'");
+      return {};
+    }
+  }
+
+  RecordType::TypeList typeList;
+  if (!parser.parseOptionalLBrace()) {
+    while (true) {
+      llvm::StringRef field;
+      mlir::Type fldTy;
+      if (parser.parseKeyword(&field) || parser.parseColon() ||
+          parser.parseType(fldTy)) {
+        parser.emitError(parser.getNameLoc(), "expected field type list");
+        return {};
+      }
+      typeList.emplace_back(field, fldTy);
+      if (parser.parseOptionalComma())
+        break;
+    }
+    if (parser.parseRBrace()) {
+      parser.emitError(parser.getNameLoc(), "expected '}'");
+      return {};
+    }
+  }
+
+  if (parser.parseGreater()) {
+    parser.emitError(parser.getNameLoc(), "expected '>' in type type");
+    return {};
+  }
+
+  if (lenParamList.empty() && typeList.empty())
+    return result;
+
+  result.finalize(lenParamList, typeList);
+  return verifyDerived(parser, result, lenParamList, typeList);
+}
+
+// !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
+// is undefined and disallowed.
+inline bool singleIndirectionLevel(mlir::Type ty) {
+  return !fir::isa_ref_type(ty);
+}
+
+} // namespace
+
+// Implementation of the thin interface from dialect to type parser
+
+mlir::Type fir::parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser) {
+  llvm::StringRef typeNameLit;
+  if (mlir::failed(parser.parseKeyword(&typeNameLit)))
+    return {};
+
+  auto loc = parser.getEncodedSourceLoc(parser.getNameLoc());
+  if (typeNameLit == "array")
+    return parseSequence(parser, loc);
+  if (typeNameLit == "box")
+    return parseBox(parser, loc);
+  if (typeNameLit == "boxchar")
+    return parseBoxChar(parser);
+  if (typeNameLit == "boxproc")
+    return parseBoxProc(parser, loc);
+  if (typeNameLit == "char")
+    return parseCharacter(parser);
+  if (typeNameLit == "complex")
+    return parseComplex(parser);
+  if (typeNameLit == "dims")
+    return parseDims(parser);
+  if (typeNameLit == "field")
+    return parseField(parser);
+  if (typeNameLit == "heap")
+    return parseHeap(parser, loc);
+  if (typeNameLit == "int")
+    return parseInteger(parser);
+  if (typeNameLit == "len")
+    return parseLen(parser);
+  if (typeNameLit == "logical")
+    return parseLogical(parser);
+  if (typeNameLit == "ptr")
+    return parsePointer(parser, loc);
+  if (typeNameLit == "real")
+    return parseReal(parser);
+  if (typeNameLit == "ref")
+    return parseReference(parser, loc);
+  if (typeNameLit == "tdesc")
+    return parseTypeDesc(parser, loc);
+  if (typeNameLit == "type")
+    return parseDerived(parser, loc);
+  if (typeNameLit == "void")
+    return parseVoid(parser);
+
+  parser.emitError(parser.getNameLoc(), "unknown FIR type " + typeNameLit);
+  return {};
+}
+
+namespace fir {
+namespace detail {
+
+// Type storage classes
+
+/// `CHARACTER` storage
+struct CharacterTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static CharacterTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                         KindTy kind) {
+    auto *storage = allocator.allocate<CharacterTypeStorage>();
+    return new (storage) CharacterTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  CharacterTypeStorage() = delete;
+  explicit CharacterTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+struct DimsTypeStorage : public mlir::TypeStorage {
+  using KeyTy = unsigned;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const {
+    return key == static_cast<unsigned>(getRank());
+  }
+
+  static DimsTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                    int rank) {
+    auto *storage = allocator.allocate<DimsTypeStorage>();
+    return new (storage) DimsTypeStorage{rank};
+  }
+
+  int getRank() const { return rank; }
+
+protected:
+  int rank;
+
+private:
+  DimsTypeStorage() = delete;
+  explicit DimsTypeStorage(int rank) : rank{rank} {}
+};
+
+/// The type of a derived type part reference
+struct FieldTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
+
+  bool operator==(const KeyTy &) const { return true; }
+
+  static FieldTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                     KindTy) {
+    auto *storage = allocator.allocate<FieldTypeStorage>();
+    return new (storage) FieldTypeStorage{0};
+  }
+
+private:
+  FieldTypeStorage() = delete;
+  explicit FieldTypeStorage(KindTy) {}
+};
+
+/// The type of a derived type LEN parameter reference
+struct LenTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
+
+  bool operator==(const KeyTy &) const { return true; }
+
+  static LenTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                   KindTy) {
+    auto *storage = allocator.allocate<LenTypeStorage>();
+    return new (storage) LenTypeStorage{0};
+  }
+
+private:
+  LenTypeStorage() = delete;
+  explicit LenTypeStorage(KindTy) {}
+};
+
+/// `LOGICAL` storage
+struct LogicalTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static LogicalTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                       KindTy kind) {
+    auto *storage = allocator.allocate<LogicalTypeStorage>();
+    return new (storage) LogicalTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  LogicalTypeStorage() = delete;
+  explicit LogicalTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// `INTEGER` storage
+struct IntTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static IntTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                   KindTy kind) {
+    auto *storage = allocator.allocate<IntTypeStorage>();
+    return new (storage) IntTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  IntTypeStorage() = delete;
+  explicit IntTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// `COMPLEX` storage
+struct CplxTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static CplxTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                    KindTy kind) {
+    auto *storage = allocator.allocate<CplxTypeStorage>();
+    return new (storage) CplxTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  CplxTypeStorage() = delete;
+  explicit CplxTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// `REAL` storage (for reals of unsupported sizes)
+struct RealTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static RealTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                    KindTy kind) {
+    auto *storage = allocator.allocate<RealTypeStorage>();
+    return new (storage) RealTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  RealTypeStorage() = delete;
+  explicit RealTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// Boxed object (a Fortran descriptor)
+struct BoxTypeStorage : public mlir::TypeStorage {
+  using KeyTy = std::tuple<mlir::Type, mlir::AffineMapAttr>;
+
+  static unsigned hashKey(const KeyTy &key) {
+    auto hashVal{llvm::hash_combine(std::get<mlir::Type>(key))};
+    return llvm::hash_combine(
+        hashVal, llvm::hash_combine(std::get<mlir::AffineMapAttr>(key)));
+  }
+
+  bool operator==(const KeyTy &key) const {
+    return std::get<mlir::Type>(key) == getElementType() &&
+           std::get<mlir::AffineMapAttr>(key) == getLayoutMap();
+  }
+
+  static BoxTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                   const KeyTy &key) {
+    auto *storage = allocator.allocate<BoxTypeStorage>();
+    return new (storage) BoxTypeStorage{std::get<mlir::Type>(key),
+                                        std::get<mlir::AffineMapAttr>(key)};
+  }
+
+  mlir::Type getElementType() const { return eleTy; }
+  mlir::AffineMapAttr getLayoutMap() const { return map; }
+
+protected:
+  mlir::Type eleTy;
+  mlir::AffineMapAttr map;
+
+private:
+  BoxTypeStorage() = delete;
+  explicit BoxTypeStorage(mlir::Type eleTy, mlir::AffineMapAttr map)
+      : eleTy{eleTy}, map{map} {}
+};
+
+/// Boxed CHARACTER object type
+struct BoxCharTypeStorage : public mlir::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static BoxCharTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                       KindTy kind) {
+    auto *storage = allocator.allocate<BoxCharTypeStorage>();
+    return new (storage) BoxCharTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+  // a !fir.boxchar<k> always wraps a !fir.char<k>
+  CharacterType getElementType(mlir::MLIRContext *ctxt) const {
+    return CharacterType::get(ctxt, getFKind());
+  }
+
+protected:
+  KindTy kind;
+
+private:
+  BoxCharTypeStorage() = delete;
+  explicit BoxCharTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// Boxed PROCEDURE POINTER object type
+struct BoxProcTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static BoxProcTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                       mlir::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<BoxProcTypeStorage>();
+    return new (storage) BoxProcTypeStorage{eleTy};
+  }
+
+  mlir::Type getElementType() const { return eleTy; }
+
+protected:
+  mlir::Type eleTy;
+
+private:
+  BoxProcTypeStorage() = delete;
+  explicit BoxProcTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Pointer-like object storage
+struct ReferenceTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static ReferenceTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                         mlir::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<ReferenceTypeStorage>();
+    return new (storage) ReferenceTypeStorage{eleTy};
+  }
+
+  mlir::Type getElementType() const { return eleTy; }
+
+protected:
+  mlir::Type eleTy;
+
+private:
+  ReferenceTypeStorage() = delete;
+  explicit ReferenceTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Pointer object storage
+struct PointerTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static PointerTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                       mlir::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<PointerTypeStorage>();
+    return new (storage) PointerTypeStorage{eleTy};
+  }
+
+  mlir::Type getElementType() const { return eleTy; }
+
+protected:
+  mlir::Type eleTy;
+
+private:
+  PointerTypeStorage() = delete;
+  explicit PointerTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Heap memory reference object storage
+struct HeapTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static HeapTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                    mlir::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<HeapTypeStorage>();
+    return new (storage) HeapTypeStorage{eleTy};
+  }
+
+  mlir::Type getElementType() const { return eleTy; }
+
+protected:
+  mlir::Type eleTy;
+
+private:
+  HeapTypeStorage() = delete;
+  explicit HeapTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Sequence-like object storage
+struct SequenceTypeStorage : public mlir::TypeStorage {
+  using KeyTy =
+      std::tuple<SequenceType::Shape, mlir::Type, mlir::AffineMapAttr>;
+
+  static unsigned hashKey(const KeyTy &key) {
+    auto shapeHash{hash_value(std::get<SequenceType::Shape>(key))};
+    shapeHash = llvm::hash_combine(shapeHash, std::get<mlir::Type>(key));
+    return llvm::hash_combine(shapeHash, std::get<mlir::AffineMapAttr>(key));
+  }
+
+  bool operator==(const KeyTy &key) const {
+    return key == KeyTy{getShape(), getElementType(), getLayoutMap()};
+  }
+
+  static SequenceTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                        const KeyTy &key) {
+    auto *storage = allocator.allocate<SequenceTypeStorage>();
+    return new (storage) SequenceTypeStorage{
+        std::get<SequenceType::Shape>(key), std::get<mlir::Type>(key),
+        std::get<mlir::AffineMapAttr>(key)};
+  }
+
+  SequenceType::Shape getShape() const { return shape; }
+  mlir::Type getElementType() const { return eleTy; }
+  mlir::AffineMapAttr getLayoutMap() const { return map; }
+
+protected:
+  SequenceType::Shape shape;
+  mlir::Type eleTy;
+  mlir::AffineMapAttr map;
+
+private:
+  SequenceTypeStorage() = delete;
+  explicit SequenceTypeStorage(const SequenceType::Shape &shape,
+                               mlir::Type eleTy, mlir::AffineMapAttr map)
+      : shape{shape}, eleTy{eleTy}, map{map} {}
+};
+
+/// Derived type storage
+struct RecordTypeStorage : public mlir::TypeStorage {
+  using KeyTy = llvm::StringRef;
+
+  static unsigned hashKey(const KeyTy &key) {
+    return llvm::hash_combine(key.str());
+  }
+
+  bool operator==(const KeyTy &key) const { return key == getName(); }
+
+  static RecordTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                      const KeyTy &key) {
+    auto *storage = allocator.allocate<RecordTypeStorage>();
+    return new (storage) RecordTypeStorage{key};
+  }
+
+  llvm::StringRef getName() const { return name; }
+
+  void setLenParamList(llvm::ArrayRef<RecordType::TypePair> list) {
+    lens = list;
+  }
+  llvm::ArrayRef<RecordType::TypePair> getLenParamList() const { return lens; }
+
+  void setTypeList(llvm::ArrayRef<RecordType::TypePair> list) { types = list; }
+  llvm::ArrayRef<RecordType::TypePair> getTypeList() const { return types; }
+
+  void finalize(llvm::ArrayRef<RecordType::TypePair> lenParamList,
+                llvm::ArrayRef<RecordType::TypePair> typeList) {
+    if (finalized)
+      return;
+    finalized = true;
+    setLenParamList(lenParamList);
+    setTypeList(typeList);
+  }
+
+protected:
+  std::string name;
+  bool finalized;
+  std::vector<RecordType::TypePair> lens;
+  std::vector<RecordType::TypePair> types;
+
+private:
+  RecordTypeStorage() = delete;
+  explicit RecordTypeStorage(llvm::StringRef name)
+      : name{name}, finalized{false} {}
+};
+
+/// Type descriptor type storage
+struct TypeDescTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getOfType(); }
+
+  static TypeDescTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                        mlir::Type ofTy) {
+    assert(ofTy && "descriptor type is null");
+    auto *storage = allocator.allocate<TypeDescTypeStorage>();
+    return new (storage) TypeDescTypeStorage{ofTy};
+  }
+
+  // The type described by this type descriptor instance
+  mlir::Type getOfType() const { return ofTy; }
+
+protected:
+  mlir::Type ofTy;
+
+private:
+  TypeDescTypeStorage() = delete;
+  explicit TypeDescTypeStorage(mlir::Type ofTy) : ofTy{ofTy} {}
+};
+
+} // namespace detail
+
+template <typename A, typename B>
+bool inbounds(A v, B lb, B ub) {
+  return v >= lb && v < ub;
+}
+
+bool isa_fir_type(mlir::Type t) {
+  return inbounds(t.getKind(), mlir::Type::FIRST_FIR_TYPE,
+                  mlir::Type::LAST_FIR_TYPE);
+}
+
+bool isa_std_type(mlir::Type t) {
+  return inbounds(t.getKind(), mlir::Type::FIRST_STANDARD_TYPE,
+                  mlir::Type::LAST_STANDARD_TYPE);
+}
+
+bool isa_fir_or_std_type(mlir::Type t) {
+  return isa_fir_type(t) || isa_std_type(t);
+}
+
+bool isa_ref_type(mlir::Type t) {
+  return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
+}
+
+bool isa_aggregate(mlir::Type t) {
+  return t.isa<SequenceType>() || t.isa<RecordType>();
+}
+
+mlir::Type dyn_cast_ptrEleTy(mlir::Type t) {
+  return mlir::TypeSwitch<mlir::Type, mlir::Type>(t)
+      .Case<fir::ReferenceType, fir::PointerType, fir::HeapType>(
+          [](auto p) { return p.getEleTy(); })
+      .Default([](mlir::Type) { return mlir::Type{}; });
+}
+
+} // namespace fir
+
+// CHARACTER
+
+CharacterType fir::CharacterType::get(mlir::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_CHARACTER, kind);
+}
+
+int fir::CharacterType::getFKind() const { return getImpl()->getFKind(); }
+
+// Dims
+
+DimsType fir::DimsType::get(mlir::MLIRContext *ctxt, unsigned rank) {
+  return Base::get(ctxt, FIR_DIMS, rank);
+}
+
+int fir::DimsType::getRank() const { return getImpl()->getRank(); }
+
+// Field
+
+FieldType fir::FieldType::get(mlir::MLIRContext *ctxt) {
+  return Base::get(ctxt, FIR_FIELD, 0);
+}
+
+// Len
+
+LenType fir::LenType::get(mlir::MLIRContext *ctxt) {
+  return Base::get(ctxt, FIR_LEN, 0);
+}
+
+// LOGICAL
+
+LogicalType fir::LogicalType::get(mlir::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_LOGICAL, kind);
+}
+
+int fir::LogicalType::getFKind() const { return getImpl()->getFKind(); }
+
+// INTEGER
+
+IntType fir::IntType::get(mlir::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_INT, kind);
+}
+
+int fir::IntType::getFKind() const { return getImpl()->getFKind(); }
+
+// COMPLEX
+
+CplxType fir::CplxType::get(mlir::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_COMPLEX, kind);
+}
+
+KindTy fir::CplxType::getFKind() const { return getImpl()->getFKind(); }
+
+// REAL
+
+RealType fir::RealType::get(mlir::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_REAL, kind);
+}
+
+int fir::RealType::getFKind() const { return getImpl()->getFKind(); }
+
+// Box<T>
+
+BoxType fir::BoxType::get(mlir::Type elementType, mlir::AffineMapAttr map) {
+  return Base::get(elementType.getContext(), FIR_BOX, elementType, map);
+}
+
+mlir::Type fir::BoxType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+mlir::AffineMapAttr fir::BoxType::getLayoutMap() const {
+  return getImpl()->getLayoutMap();
+}
+
+mlir::LogicalResult
+fir::BoxType::verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
+                                           mlir::AffineMapAttr map) {
+  // TODO
+  return mlir::success();
+}
+
+// BoxChar<C>
+
+BoxCharType fir::BoxCharType::get(mlir::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_BOXCHAR, kind);
+}
+
+CharacterType fir::BoxCharType::getEleTy() const {
+  return getImpl()->getElementType(getContext());
+}
+
+// BoxProc<T>
+
+BoxProcType fir::BoxProcType::get(mlir::Type elementType) {
+  return Base::get(elementType.getContext(), FIR_BOXPROC, elementType);
+}
+
+mlir::Type fir::BoxProcType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+mlir::LogicalResult
+fir::BoxProcType::verifyConstructionInvariants(mlir::Location loc,
+                                               mlir::Type eleTy) {
+  if (eleTy.isa<mlir::FunctionType>())
+    return mlir::success();
+  if (auto refTy = eleTy.dyn_cast<ReferenceType>())
+    if (refTy.isa<mlir::FunctionType>())
+      return mlir::success();
+  return mlir::emitError(loc, "invalid type for boxproc") << eleTy << '\n';
+}
+
+// Reference<T>
+
+ReferenceType fir::ReferenceType::get(mlir::Type elementType) {
+  return Base::get(elementType.getContext(), FIR_REFERENCE, elementType);
+}
+
+mlir::Type fir::ReferenceType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+mlir::LogicalResult
+fir::ReferenceType::verifyConstructionInvariants(mlir::Location loc,
+                                                 mlir::Type eleTy) {
+  if (eleTy.isa<DimsType>() || eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
+      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
+    return mlir::emitError(loc, "cannot build a reference to type: ")
+           << eleTy << '\n';
+  return mlir::success();
+}
+
+// Pointer<T>
+
+PointerType fir::PointerType::get(mlir::Type elementType) {
+  if (!singleIndirectionLevel(elementType)) {
+    llvm_unreachable("FIXME: invalid element type");
+    return {};
+  }
+  return Base::get(elementType.getContext(), FIR_POINTER, elementType);
+}
+
+mlir::Type fir::PointerType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+static bool canBePointerOrHeapElementType(mlir::Type eleTy) {
+  return eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+         eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+         eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
+         eleTy.isa<HeapType>() || eleTy.isa<PointerType>() ||
+         eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>();
+}
+
+mlir::LogicalResult
+fir::PointerType::verifyConstructionInvariants(mlir::Location loc,
+                                               mlir::Type eleTy) {
+  if (canBePointerOrHeapElementType(eleTy))
+    return mlir::emitError(loc, "cannot build a pointer to type: ")
+           << eleTy << '\n';
+  return mlir::success();
+}
+
+// Heap<T>
+
+HeapType fir::HeapType::get(mlir::Type elementType) {
+  if (!singleIndirectionLevel(elementType)) {
+    llvm_unreachable("FIXME: invalid element type");
+    return {};
+  }
+  return Base::get(elementType.getContext(), FIR_HEAP, elementType);
+}
+
+mlir::Type fir::HeapType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+mlir::LogicalResult
+fir::HeapType::verifyConstructionInvariants(mlir::Location loc,
+                                            mlir::Type eleTy) {
+  if (canBePointerOrHeapElementType(eleTy))
+    return mlir::emitError(loc, "cannot build a heap pointer to type: ")
+           << eleTy << '\n';
+  return mlir::success();
+}
+
+// Sequence<T>
+
+SequenceType fir::SequenceType::get(const Shape &shape, mlir::Type elementType,
+                                    mlir::AffineMapAttr map) {
+  auto *ctxt = elementType.getContext();
+  return Base::get(ctxt, FIR_SEQUENCE, shape, elementType, map);
+}
+
+mlir::Type fir::SequenceType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+mlir::AffineMapAttr fir::SequenceType::getLayoutMap() const {
+  return getImpl()->getLayoutMap();
+}
+
+SequenceType::Shape fir::SequenceType::getShape() const {
+  return getImpl()->getShape();
+}
+
+mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
+    mlir::Location loc, const SequenceType::Shape &shape, mlir::Type eleTy,
+    mlir::AffineMapAttr map) {
+  // DIMENSION attribute can only be applied to an intrinsic or record type
+  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+      eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
+      eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
+      eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>())
+    return mlir::emitError(loc, "cannot build an array of this element type: ")
+           << eleTy << '\n';
+  return mlir::success();
+}
+
+// compare if two shapes are equivalent
+bool fir::operator==(const SequenceType::Shape &sh_1,
+                     const SequenceType::Shape &sh_2) {
+  if (sh_1.size() != sh_2.size())
+    return false;
+  auto e = sh_1.size();
+  for (decltype(e) i = 0; i != e; ++i)
+    if (sh_1[i] != sh_2[i])
+      return false;
+  return true;
+}
+
+// compute the hash of a Shape
+llvm::hash_code fir::hash_value(const SequenceType::Shape &sh) {
+  if (sh.size()) {
+    return llvm::hash_combine_range(sh.begin(), sh.end());
+  }
+  return llvm::hash_combine(0);
+}
+
+/// RecordType
+///
+/// This type captures a Fortran "derived type"
+
+RecordType fir::RecordType::get(mlir::MLIRContext *ctxt, llvm::StringRef name) {
+  return Base::get(ctxt, FIR_DERIVED, name);
+}
+
+void fir::RecordType::finalize(llvm::ArrayRef<TypePair> lenPList,
+                               llvm::ArrayRef<TypePair> typeList) {
+  getImpl()->finalize(lenPList, typeList);
+}
+
+llvm::StringRef fir::RecordType::getName() { return getImpl()->getName(); }
+
+RecordType::TypeList fir::RecordType::getTypeList() {
+  return getImpl()->getTypeList();
+}
+
+RecordType::TypeList fir::RecordType::getLenParamList() {
+  return getImpl()->getLenParamList();
+}
+
+detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
+  return getImpl();
+}
+
+mlir::LogicalResult
+fir::RecordType::verifyConstructionInvariants(mlir::Location loc,
+                                              llvm::StringRef name) {
+  if (name.size() == 0)
+    return mlir::emitError(loc, "record types must have a name");
+  return mlir::success();
+}
+
+mlir::Type fir::RecordType::getType(llvm::StringRef ident) {
+  for (auto f : getTypeList())
+    if (ident == f.first)
+      return f.second;
+  llvm_unreachable("query for field not present in record");
+  return {};
+}
+
+/// Type descriptor type
+///
+/// This is the type of a type descriptor object (similar to a class instance)
+
+TypeDescType fir::TypeDescType::get(mlir::Type ofType) {
+  assert(!ofType.isa<ReferenceType>());
+  return Base::get(ofType.getContext(), FIR_TYPEDESC, ofType);
+}
+
+mlir::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
+
+mlir::LogicalResult
+fir::TypeDescType::verifyConstructionInvariants(mlir::Location loc,
+                                                mlir::Type eleTy) {
+  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+      eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
+      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
+    return mlir::emitError(loc, "cannot build a type descriptor of type: ")
+           << eleTy << '\n';
+  return mlir::success();
+}
+
+namespace {
+
+void printBounds(llvm::raw_ostream &os, const SequenceType::Shape &bounds) {
+  os << '<';
+  for (auto &b : bounds) {
+    if (b >= 0) {
+      os << b << 'x';
+    } else {
+      os << "?x";
+    }
+  }
+}
+
+llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4> recordTypeVisited;
+
+} // namespace
+
+void fir::printFirType(FIROpsDialect *, mlir::Type ty,
+                       mlir::DialectAsmPrinter &p) {
+  auto &os = p.getStream();
+  switch (ty.getKind()) {
+  case fir::FIR_BOX: {
+    auto type = ty.cast<BoxType>();
+    os << "box<";
+    p.printType(type.getEleTy());
+    if (auto map = type.getLayoutMap()) {
+      os << ", ";
+      p.printAttribute(map);
+    }
+    os << '>';
+  } break;
+  case fir::FIR_BOXCHAR: {
+    auto type = ty.cast<BoxCharType>().getEleTy();
+    os << "boxchar<" << type.cast<fir::CharacterType>().getFKind() << '>';
+  } break;
+  case fir::FIR_BOXPROC:
+    os << "boxproc<";
+    p.printType(ty.cast<BoxProcType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_CHARACTER: // intrinsic
+    os << "char<" << ty.cast<CharacterType>().getFKind() << '>';
+    break;
+  case fir::FIR_COMPLEX: // intrinsic
+    os << "complex<" << ty.cast<CplxType>().getFKind() << '>';
+    break;
+  case fir::FIR_DERIVED: { // derived
+    auto type = ty.cast<fir::RecordType>();
+    os << "type<" << type.getName();
+    if (!recordTypeVisited.count(type.uniqueKey())) {
+      recordTypeVisited.insert(type.uniqueKey());
+      if (type.getLenParamList().size()) {
+        char ch = '(';
+        for (auto p : type.getLenParamList()) {
+          os << ch << p.first << ':';
+          p.second.print(os);
+          ch = ',';
+        }
+        os << ')';
+      }
+      if (type.getTypeList().size()) {
+        char ch = '{';
+        for (auto p : type.getTypeList()) {
+          os << ch << p.first << ':';
+          p.second.print(os);
+          ch = ',';
+        }
+        os << '}';
+      }
+      recordTypeVisited.erase(type.uniqueKey());
+    }
+    os << '>';
+  } break;
+  case fir::FIR_DIMS:
+    os << "dims<" << ty.cast<DimsType>().getRank() << '>';
+    break;
+  case fir::FIR_FIELD:
+    os << "field";
+    break;
+  case fir::FIR_HEAP:
+    os << "heap<";
+    p.printType(ty.cast<HeapType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_INT: // intrinsic
+    os << "int<" << ty.cast<fir::IntType>().getFKind() << '>';
+    break;
+  case fir::FIR_LEN:
+    os << "len";
+    break;
+  case fir::FIR_LOGICAL: // intrinsic
+    os << "logical<" << ty.cast<LogicalType>().getFKind() << '>';
+    break;
+  case fir::FIR_POINTER:
+    os << "ptr<";
+    p.printType(ty.cast<PointerType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_REAL: // intrinsic
+    os << "real<" << ty.cast<fir::RealType>().getFKind() << '>';
+    break;
+  case fir::FIR_REFERENCE:
+    os << "ref<";
+    p.printType(ty.cast<ReferenceType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_SEQUENCE: {
+    os << "array";
+    auto type = ty.cast<SequenceType>();
+    auto shape = type.getShape();
+    if (shape.size()) {
+      printBounds(os, shape);
+    } else {
+      os << "<*:";
+    }
+    p.printType(ty.cast<SequenceType>().getEleTy());
+    if (auto map = type.getLayoutMap()) {
+      os << ", ";
+      map.print(os);
+    }
+    os << '>';
+  } break;
+  case fir::FIR_TYPEDESC:
+    os << "tdesc<";
+    p.printType(ty.cast<TypeDescType>().getOfTy());
+    os << '>';
+    break;
+  }
+}
diff --git a/lib/Optimizer/Support/CMakeLists.txt b/lib/Optimizer/Support/CMakeLists.txt
new file mode 100644
index 000000000000..88a1fc78a5f6
--- /dev/null
+++ b/lib/Optimizer/Support/CMakeLists.txt
@@ -0,0 +1,10 @@
+add_llvm_library(FIRSupport
+  KindMapping.cpp
+)
+
+target_link_libraries(FIRSupport FIRDialect)
+
+install (TARGETS FIRSupport
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+)
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
new file mode 100644
index 000000000000..8731c0bb087e
--- /dev/null
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -0,0 +1,244 @@
+//===-- KindMapping.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/Optimizer/Support/KindMapping.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/CommandLine.h"
+
+/// Allow the user to set the FIR intrinsic type kind value to LLVM type
+/// mappings.  Note that these are not mappings from kind values to any
+/// other MLIR dialect, only to LLVM IR. The default values follow the f18
+/// front-end kind mappings.
+
+using Bitsize = fir::KindMapping::Bitsize;
+using KindTy = fir::KindMapping::KindTy;
+using LLVMTypeID = fir::KindMapping::LLVMTypeID;
+using MatchResult = fir::KindMapping::MatchResult;
+
+static llvm::cl::opt<std::string> clKindMapping(
+    "kind-mapping", llvm::cl::desc("kind mapping string to set kind precision"),
+    llvm::cl::value_desc("kind-mapping-string"), llvm::cl::init(""));
+
+/// Integral types default to the kind value being the size of the value in
+/// bytes. The default is to scale from bytes to bits.
+static Bitsize defaultScalingKind(KindTy kind) {
+  const unsigned BITS_IN_BYTE = 8;
+  return kind * BITS_IN_BYTE;
+}
+
+/// Floating-point types default to the kind value being the size of the value
+/// in bytes. The default is to translate kinds of 2, 4, 8, 10, and 16 to a
+/// valid llvm::Type::TypeID value. Otherwise, the default is FloatTyID.
+static LLVMTypeID defaultRealKind(KindTy kind) {
+  switch (kind) {
+  case 2:
+    return LLVMTypeID::HalfTyID;
+  case 4:
+    return LLVMTypeID::FloatTyID;
+  case 8:
+    return LLVMTypeID::DoubleTyID;
+  case 10:
+    return LLVMTypeID::X86_FP80TyID;
+  case 16:
+    return LLVMTypeID::FP128TyID;
+  default:
+    return LLVMTypeID::FloatTyID;
+  }
+}
+
+// lookup the kind-value given the defaults, the mappings, and a KIND key
+template <typename RT, char KEY>
+static RT doLookup(std::function<RT(KindTy)> def,
+                   const llvm::DenseMap<std::pair<char, KindTy>, RT> &map,
+                   KindTy kind) {
+  std::pair<char, KindTy> key{KEY, kind};
+  auto iter = map.find(key);
+  if (iter != map.end())
+    return iter->second;
+  return def(kind);
+}
+
+// do a lookup for INTERGER, LOGICAL, or CHARACTER
+template <char KEY, typename MAP>
+static Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
+  return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
+}
+
+// do a lookup for REAL or COMPLEX
+template <char KEY, typename MAP>
+static LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
+  return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
+}
+
+template <char KEY, typename MAP>
+static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind,
+                                                         const MAP &map) {
+  switch (doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind)) {
+  case LLVMTypeID::HalfTyID:
+    return llvm::APFloat::IEEEhalf();
+  case LLVMTypeID::FloatTyID:
+    return llvm::APFloat::IEEEsingle();
+  case LLVMTypeID::DoubleTyID:
+    return llvm::APFloat::IEEEdouble();
+  case LLVMTypeID::X86_FP80TyID:
+    return llvm::APFloat::x87DoubleExtended();
+  case LLVMTypeID::FP128TyID:
+    return llvm::APFloat::IEEEquad();
+  case LLVMTypeID::PPC_FP128TyID:
+    return llvm::APFloat::PPCDoubleDouble();
+  default:
+    llvm_unreachable("Invalid floating type");
+  }
+}
+
+static MatchResult parseCode(char &code, const char *&ptr) {
+  if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
+    return mlir::failure();
+  code = *ptr++;
+  return mlir::success();
+}
+
+template <char ch>
+static MatchResult parseSingleChar(const char *&ptr) {
+  if (*ptr != ch)
+    return mlir::failure();
+  ++ptr;
+  return mlir::success();
+}
+
+static MatchResult parseColon(const char *&ptr) {
+  return parseSingleChar<':'>(ptr);
+}
+
+static MatchResult parseComma(const char *&ptr) {
+  return parseSingleChar<','>(ptr);
+}
+
+static MatchResult parseInt(unsigned &result, const char *&ptr) {
+  const char *beg = ptr;
+  while (*ptr >= '0' && *ptr <= '9')
+    ptr++;
+  if (beg == ptr)
+    return mlir::failure();
+  llvm::StringRef ref(beg, ptr - beg);
+  int temp;
+  if (ref.consumeInteger(10, temp))
+    return mlir::failure();
+  result = temp;
+  return mlir::success();
+}
+
+static mlir::LogicalResult matchString(const char *&ptr,
+                                       llvm::StringRef literal) {
+  llvm::StringRef s(ptr);
+  if (s.startswith(literal)) {
+    ptr += literal.size();
+    return mlir::success();
+  }
+  return mlir::failure();
+}
+
+static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
+  if (mlir::succeeded(matchString(ptr, "Half"))) {
+    result = LLVMTypeID::HalfTyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, "Float"))) {
+    result = LLVMTypeID::FloatTyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, "Double"))) {
+    result = LLVMTypeID::DoubleTyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, "X86_FP80"))) {
+    result = LLVMTypeID::X86_FP80TyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, "FP128"))) {
+    result = LLVMTypeID::FP128TyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, "PPC_FP128"))) {
+    result = LLVMTypeID::PPC_FP128TyID;
+    return mlir::success();
+  }
+  return mlir::failure();
+}
+
+fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map)
+    : context{context} {
+  if (mlir::failed(parse(map))) {
+    intMap.clear();
+    floatMap.clear();
+  }
+}
+
+fir::KindMapping::KindMapping(mlir::MLIRContext *context)
+    : KindMapping{context, clKindMapping} {}
+
+MatchResult fir::KindMapping::badMapString(const llvm::Twine &ptr) {
+  auto unknown = mlir::UnknownLoc::get(context);
+  mlir::emitError(unknown, ptr);
+  return mlir::failure();
+}
+
+MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
+  if (kindMap.empty())
+    return mlir::success();
+  const char *srcPtr = kindMap.begin();
+  while (true) {
+    char code = '\0';
+    KindTy kind = 0;
+    if (parseCode(code, srcPtr) || parseInt(kind, srcPtr))
+      return badMapString(srcPtr);
+    if (code == 'a' || code == 'i' || code == 'l') {
+      Bitsize bits = 0;
+      if (parseColon(srcPtr) || parseInt(bits, srcPtr))
+        return badMapString(srcPtr);
+      intMap[std::pair<char, KindTy>{code, kind}] = bits;
+    } else if (code == 'r' || code == 'c') {
+      LLVMTypeID id{};
+      if (parseColon(srcPtr) || parseTypeID(id, srcPtr))
+        return badMapString(srcPtr);
+      floatMap[std::pair<char, KindTy>{code, kind}] = id;
+    } else {
+      return badMapString(srcPtr);
+    }
+    if (parseComma(srcPtr))
+      break;
+  }
+  if (*srcPtr)
+    return badMapString(srcPtr);
+  return mlir::success();
+}
+
+Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) {
+  return getIntegerLikeBitsize<'a'>(kind, intMap);
+}
+
+Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) {
+  return getIntegerLikeBitsize<'i'>(kind, intMap);
+}
+
+Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) {
+  return getIntegerLikeBitsize<'l'>(kind, intMap);
+}
+
+LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) {
+  return getFloatLikeTypeID<'r'>(kind, floatMap);
+}
+
+LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) {
+  return getFloatLikeTypeID<'c'>(kind, floatMap);
+}
+
+const llvm::fltSemantics &fir::KindMapping::getFloatSemantics(KindTy kind) {
+  return getFloatSemanticsOfKind<'r'>(kind, floatMap);
+}
diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index 965adff78976..cdc5dd58d3ca 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -16,6 +16,11 @@ set(FLANG_TEST_PARAMS
 set(FLANG_TEST_DEPENDS
   f18
 )
+
+if (LINK_WITH_FIR)
+  list(APPEND FLANG_TEST_DEPENDS tco)
+endif()
+
 add_lit_testsuite(check-all "Running the Flang regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   PARAMS ${FLANG_TEST_PARAMS}
diff --git a/test-lit/Fir/fir-ops.fir b/test-lit/Fir/fir-ops.fir
new file mode 100644
index 000000000000..bdadf5cd6f58
--- /dev/null
+++ b/test-lit/Fir/fir-ops.fir
@@ -0,0 +1,403 @@
+// Test the FIR operations
+
+// RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
+// UNSUPPORTED: !fir
+
+// CHECK-LABEL: func @it1() -> !fir.int<4>
+func @it1() -> !fir.int<4>
+// CHECK-LABEL: func @box1() -> !fir.boxchar<2>
+func @box1() -> !fir.boxchar<2>
+// CHECK-LABEL: func @box2() -> !fir.boxproc<(i32, i32) -> i64>
+func @box2() -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK-LABEL: func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
+func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
+
+// Fortran SUBROUTINE and FUNCTION
+// CHECK-LABEL: func @print_index3(index, index, index)
+// CHECK-LABEL: func @user_i64(i64)
+// CHECK-LABEL: func @user_tdesc(!fir.tdesc<!fir.type<x>>)
+func @print_index3(index, index, index)
+func @user_i64(i64)
+func @user_tdesc(!fir.tdesc<!fir.type<x>>)
+
+// expect the void return to be omitted
+// CHECK-LABEL: func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>)
+func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> ()
+
+// CHECK-LABEL: func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
+// CHECK-LABEL: func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
+func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+
+// CHECK-LABEL: func @nop()
+func @nop()
+
+// CHECK-LABEL: func @get_func() -> (() -> ())
+func @get_func() -> (() -> ())
+
+// CHECK-LABEL: @instructions
+func @instructions() {
+  // CHECK: %[[A0:.*]] = fir.alloca !fir.array<10xi32>
+  %0 = fir.alloca !fir.array<10xi32>
+  // CHECK: fir.load %[[A0]] : !fir.ref<!fir.array<10xi32>>
+  %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
+  %2 = fir.alloca i32
+  %3 = constant 22 : i32
+  // CHECK: fir.store %{{.*}} to %{{.*}} : !fir.ref<i32>
+  fir.store %3 to %2 : !fir.ref<i32>
+  // CHECK: fir.undefined i32
+  %4 = fir.undefined i32
+  // CHECK: %[[A5:.*]] = fir.allocmem !fir.array<100xf32>
+  %5 = fir.allocmem !fir.array<100xf32>
+  // CHECK: %[[A6:.*]] = fir.embox %[[A5]] : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
+  %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
+  // CHECK: fir.box_addr %{{.*}} : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
+  %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
+  %c0 = constant 0 : index
+  // CHECK: %[[A8:.*]]:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
+  %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
+  // CHECK: fir.call @print_index3(%[[A8]]#0, %[[A8]]#1, %[[A8]]#2) : (index, index, index)
+  fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()
+  %8 = fir.call @it1() : () -> !fir.int<4>
+  // CHECK: fir.box_elesize %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
+  %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i64
+  // CHECK: fir.box_isalloc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+  %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  // CHECK: fir.box_isarray %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+  %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  // CHECK: fir.box_isptr %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+  %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  // CHECK: fir.box_rank %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
+  %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64
+  // CHECK: fir.box_tdesc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
+  %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
+  %15 = fir.call @box1() : () -> !fir.boxchar<2>
+  // CHECK: fir.boxchar_len %{{.*}} : (!fir.boxchar<2>) -> i32
+  %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
+  %17 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
+  // CHECK: fir.boxproc_host %{{.*}} : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
+  %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
+  %19 = constant 10 : i32
+  // CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
+  %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
+  // CHECK: fir.field_index f, !fir.type<derived{f:f32}>
+  %21 = fir.field_index f, !fir.type<derived{f:f32}>
+  // CHECK: fir.undefined !fir.type<derived{f:f32}>
+  %22 = fir.undefined !fir.type<derived{f:f32}>
+  // CHECK: fir.extract_value %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, !fir.field) -> f32
+  %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32
+  %c1 = constant 1 : i32
+  // CHECK: fir.gendims %{{.*}}, %{{.*}}, %{{.*}} : (i32, i32, i32) -> !fir.dims<1>
+  %24 = fir.gendims %c1, %19, %c1 : (i32, i32, i32) -> !fir.dims<1>
+  %cf1 = constant 1.0 : f32
+  // CHECK: fir.insert_value %{{.*}}, %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
+  %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
+  // CHECK: fir.len_param_index f, !fir.type<derived3{f:f32}>
+  %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>
+  %27 = fir.call @box3() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+  // CHECK: fir.dispatch "method"(%{{.*}}) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
+  %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
+  // CHECK: fir.convert %{{.*}} : (i32) -> i64
+  %29 = fir.convert %28 : (i32) -> i64
+  // CHECK: fir.gentypedesc !fir.type<x>
+  %30 = fir.gentypedesc !fir.type<x>
+  fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
+  // CHECK: fir.no_reassoc %{{.*}} : i64
+  %31 = fir.no_reassoc %29 : i64
+  fir.call @user_i64(%31) : (i64) -> ()
+  // CHECK: fir.freemem %{{.*}} : !fir.heap<!fir.array<100xf32>>
+  fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
+  %32 = fir.call @get_func() : () -> (() -> ())
+  fir.call %32() : () -> ()
+  // CHECK: fir.address_of(@it1) : !fir.ref<() -> !fir.int<4>>
+  %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
+  return
+}
+
+// CHECK-LABEL: @boxing_match
+func @boxing_match() {
+  %0 = fir.alloca i32
+  %d6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
+  %d3 = fir.alloca !fir.char<1>
+  %e6 = fir.alloca tuple<i32,f64>
+  %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>
+  // CHECK: fir.unbox %{{.*}} : (!fir.box<i32>) -> (!fir.ref<i32>, i32, i32, !fir.tdesc<i32>, i32, !fir.dims<0>)
+  %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.dims<0>)
+  %c8 = constant 8 : i32
+  %3 = fir.undefined !fir.char<1>
+  // CHECK: fir.emboxchar %{{.*}}, %{{.*}} : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
+  // CHECK: fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
+  %4 = fir.emboxchar %d3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
+  %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
+  %6 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
+  %z = constant 0 : i32
+  %c12 = constant 12 : i32
+  %a2 = fir.insert_value %6, %c12, %z : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+  %z1 = constant 1 : i32
+  %c42 = constant 42.13 : f64
+  %a3 = fir.insert_value %6, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+  fir.store %a3 to %d6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
+  %7 = fir.emboxproc @method_impl, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
+  %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
+  // CHECK: fir.emboxproc @method_impl, %{{.*}} : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
+  // CHECK: fir.unboxproc %{{.*}} : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
+  %9 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
+  %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)
+  %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>
+  fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()
+  return
+}
+
+// CHECK-LABEL: @loop
+func @loop() {
+  %c1 = constant 1 : index
+  %c10 = constant 10 : index
+  %ct = constant true
+  // CHECK: fir.loop %{{.*}} = %{{.*}} to %{{.*}} {
+  %i = fir.loop %i = %c1 to %c10 {
+    // CHECK: fir.where %{{.*}} {
+    fir.where %ct {
+      fir.call @nop() : () -> ()
+    // CHECK: } otherwise {
+    } otherwise {
+      fir.call @nop() : () -> ()
+    }
+  }
+  // CHECK: fir.unreachable
+  fir.unreachable
+}
+
+// CHECK-LABEL: @bar_select
+func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), -3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), 4, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2 : i32, %b3:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = addi %4, %b3 : i32
+  return %5 : i32
+^bb3(%c:i32, %c2:i32) :
+  %6 = addi %c, %c2 : i32
+  return %6 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+// CHECK-LABEL: @bar_select_rank
+func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select_rank %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), 3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), -1, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2 : i32, %b3:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = addi %4, %b3 : i32
+  return %5 : i32
+^bb3(%c:i32, %c2:i32) :
+  %6 = addi %c, %c2 : i32
+  return %6 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  %7 = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+  fir.dispatch method(%7) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
+  return %zero : i32
+}
+
+// CHECK-LABEL: @bar_select_type
+func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select_type %{{.*}} : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.instance<!fir.int<4>>, ^bb1(%{{.*}} : i32), #fir.instance<!fir.int<8>>, ^bb2(%{{.*}} : i32), #fir.subsumed<!fir.int<2>>, ^bb3(%{{.*}} : i32), #fir.instance<!fir.int<1>>, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32) :
+  return %b : i32
+^bb3(%c : i32) :
+  return %c : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+// CHECK-LABEL: @bar_select_case
+func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select_case %{{.*}} : i32 [#fir.point, %{{.*}}, ^bb1(%{{.*}} : i32), #fir.lower, %{{.*}}, ^bb2(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32, i32), #fir.interval, %{{.*}}, %{{.*}}, ^bb3(%{{.*}}, %{{.*}} : i32, i32), #fir.upper, %{{.*}}, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = muli %4, %b3 : i32
+  %6 = addi %5, %b4 : i32
+  return %6 : i32
+^bb3(%c : i32, %c2 : i32) :
+  %7 = addi %c, %c2 : i32
+  return %7 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+// CHECK-LABEL: @global_var
+fir.global @global_var : i32 {
+  %0 = constant 1 : i32
+  fir.has_value %0 : i32
+}
+
+// CHECK-LABEL: @global_constant
+fir.global @global_constant constant : i32 {
+  %0 = constant 934 : i32
+  fir.has_value %0 : i32
+}
+
+// CHECK-LABEL: @global_derived
+fir.global @global_derived : !fir.type<minez(f:i32)> {
+  // CHECK: fir.global_len "f", 1 : i32
+  fir.global_len f, 1 : i32
+  %0 = fir.undefined !fir.type<minez>
+  fir.has_value %0 : !fir.type<minez>
+}
+
+// CHECK-LABEL: @dispatch_tbl
+fir.dispatch_table @dispatch_tbl {
+  // CHECK: fir.dt_entry "method", @method_impl
+  fir.dt_entry "method", @method_impl
+}
+
+// CHECK-LABEL: @compare_real
+func @compare_real(%a : !fir.real<16>, %b : !fir.real<16>) {
+  // CHECK: fir.cmpf "false", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "oeq", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ogt", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "oge", %{{.*}}, %{{.*}} : !fir.real<16>
+  %d0 = fir.cmpf "false", %a, %b : !fir.real<16>
+  %d1 = fir.cmpf "oeq", %a, %b : !fir.real<16>
+  %d2 = fir.cmpf "ogt", %a, %b : !fir.real<16>
+  %d3 = fir.cmpf "oge", %a, %b : !fir.real<16>
+  // CHECK: fir.cmpf "olt", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ole", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "one", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ord", %{{.*}}, %{{.*}} : !fir.real<16>
+  %a0 = fir.cmpf "olt", %a, %b : !fir.real<16>
+  %a1 = fir.cmpf "ole", %a, %b : !fir.real<16>
+  %a2 = fir.cmpf "one", %a, %b : !fir.real<16>
+  %a3 = fir.cmpf "ord", %a, %b : !fir.real<16>
+  // CHECK: fir.cmpf "ueq", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ugt", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "uge", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ult", %{{.*}}, %{{.*}} : !fir.real<16>
+  %b0 = fir.cmpf "ueq", %a, %b : !fir.real<16>
+  %b1 = fir.cmpf "ugt", %a, %b : !fir.real<16>
+  %b2 = fir.cmpf "uge", %a, %b : !fir.real<16>
+  %b3 = fir.cmpf "ult", %a, %b : !fir.real<16>
+  // CHECK: fir.cmpf "ule", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "une", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "uno", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "true", %{{.*}}, %{{.*}} : !fir.real<16>
+  %c0 = fir.cmpf "ule", %a, %b : !fir.real<16>
+  %c1 = fir.cmpf "une", %a, %b : !fir.real<16>
+  %c2 = fir.cmpf "uno", %a, %b : !fir.real<16>
+  %c3 = fir.cmpf "true", %a, %b : !fir.real<16>
+  return
+}
+
+// CHECK-LABEL: @compare_complex
+func @compare_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) {
+  // CHECK: fir.cmpc "false", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "oeq", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ogt", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "oge", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %d0 = fir.cmpc "false", %a, %b : !fir.complex<16>
+  %d1 = fir.cmpc "oeq", %a, %b : !fir.complex<16>
+  %d2 = fir.cmpc "ogt", %a, %b : !fir.complex<16>
+  %d3 = fir.cmpc "oge", %a, %b : !fir.complex<16>
+  // CHECK: fir.cmpc "olt", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ole", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "one", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ord", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %a0 = fir.cmpc "olt", %a, %b : !fir.complex<16>
+  %a1 = fir.cmpc "ole", %a, %b : !fir.complex<16>
+  %a2 = fir.cmpc "one", %a, %b : !fir.complex<16>
+  %a3 = fir.cmpc "ord", %a, %b : !fir.complex<16>
+  // CHECK: fir.cmpc "ueq", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ugt", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "uge", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ult", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %b0 = fir.cmpc "ueq", %a, %b : !fir.complex<16>
+  %b1 = fir.cmpc "ugt", %a, %b : !fir.complex<16>
+  %b2 = fir.cmpc "uge", %a, %b : !fir.complex<16>
+  %b3 = fir.cmpc "ult", %a, %b : !fir.complex<16>
+  // CHECK: fir.cmpc "ule", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "une", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "uno", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "true", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %c0 = fir.cmpc "ule", %a, %b : !fir.complex<16>
+  %c1 = fir.cmpc "une", %a, %b : !fir.complex<16>
+  %c2 = fir.cmpc "uno", %a, %b : !fir.complex<16>
+  %c3 = fir.cmpc "true", %a, %b : !fir.complex<16>
+  return
+}
+
+// CHECK-LABEL: @arith_real
+func @arith_real(%a : !fir.real<16>, %b : !fir.real<16>) -> !fir.real<16> {
+  %c1 = constant 1.0 : f32
+  %0 = fir.convert %c1 : (f32) -> !fir.real<16>
+  // CHECK: %[[R1:.*]] = fir.negf %{{.*}} : !fir.real<16>
+  // CHECK: fir.addf %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: %[[R3:.*]] = fir.subf %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.mulf %[[R1]], %[[R3]] : !fir.real<16>
+  // CHECK: fir.divf %{{.*}}, %{{.*}} : !fir.real<16>
+  %1 = fir.negf %a : !fir.real<16>
+  %2 = fir.addf %0, %1 : !fir.real<16>
+  %3 = fir.subf %2, %b : !fir.real<16>
+  %4 = fir.mulf %1, %3 : !fir.real<16>
+  %5 = fir.divf %4, %a : !fir.real<16>
+  return %5 : !fir.real<16>
+}
+
+// CHECK-LABEL: @arith_complex
+func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> {
+  // CHECK: fir.negc %{{.*}} : !fir.complex<16>
+  // CHECK: fir.addc %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.subc %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.mulc %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.divc %{{.*}}, %{{.*}} : !fir.complex<16>
+  %1 = fir.negc %a : !fir.complex<16>
+  %2 = fir.addc %b, %1 : !fir.complex<16>
+  %3 = fir.subc %2, %b : !fir.complex<16>
+  %4 = fir.mulc %1, %3 : !fir.complex<16>
+  %5 = fir.divc %4, %a : !fir.complex<16>
+  return %5 : !fir.complex<16>
+}
+
+// CHECK-LABEL: @character_literal
+func @character_literal() -> !fir.array<13 x !fir.char<1>> {
+  // CHECK: fir.string_lit "Hello, World!"(13) : !fir.char<1>
+  %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1>
+  return %0 : !fir.array<13 x !fir.char<1>>
+}
diff --git a/test-lit/Fir/fir-types.fir b/test-lit/Fir/fir-types.fir
new file mode 100644
index 000000000000..19b0286f5b73
--- /dev/null
+++ b/test-lit/Fir/fir-types.fir
@@ -0,0 +1,78 @@
+// Test the FIR types
+
+// RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
+// UNSUPPORTED: !fir
+
+// Fortran Intrinsic types
+// CHECK-LABEL: func @it1() -> !fir.int<4>
+// CHECK-LABEL: func @it2() -> !fir.real<8>
+// CHECK-LABEL: func @it3() -> !fir.complex<8>
+// CHECK-LABEL: func @it4() -> !fir.logical<1>
+// CHECK-LABEL: func @it5() -> !fir.char<1>
+func @it1() -> !fir.int<4>
+func @it2() -> !fir.real<8>
+func @it3() -> !fir.complex<8>
+func @it4() -> !fir.logical<1>
+func @it5() -> !fir.char<1>
+
+// Fortran Derived types (records)
+// CHECK-LABEL: func @dvd1() -> !fir.type<derived1>
+// CHECK-LABEL: func @dvd2() -> !fir.type<derived2(p:i32)>
+// CHECK-LABEL: func @dvd3() -> !fir.type<derived3{f:f32}>
+// CHECK-LABEL: func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+// CHECK-LABEL: func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
+// CHECK-LABEL: func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
+func @dvd1() -> !fir.type<derived1>
+func @dvd2() -> !fir.type<derived2(p:i32)>
+func @dvd3() -> !fir.type<derived3{f:f32}>
+func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
+func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
+
+// FIR array types
+// CHECK-LABEL: func @arr1() -> !fir.array<10xf32>
+// CHECK-LABEL: func @arr2() -> !fir.array<10x10xf32>
+// CHECK-LABEL: func @arr3() -> !fir.array<?xf32>
+// CHECK-LABEL: func @arr4() -> !fir.array<10x?xf32>
+// CHECK-LABEL: func @arr5() -> !fir.array<?x?xf32>
+// CHECK-LABEL: func @arr6() -> !fir.array<*:f32>
+// CHECK-LABEL: func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
+func @arr1() -> !fir.array<10xf32>
+func @arr2() -> !fir.array<10x10xf32>
+func @arr3() -> !fir.array<?xf32>
+func @arr4() -> !fir.array<10x?xf32>
+func @arr5() -> !fir.array<?x?xf32>
+func @arr6() -> !fir.array<*:f32>
+func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
+
+// FIR pointer-like types
+// CHECK-LABEL: func @mem1() -> !fir.ref<i32>
+// CHECK-LABEL: func @mem2() -> !fir.ptr<i32>
+// CHECK-LABEL: func @mem3() -> !fir.heap<i32>
+// CHECK-LABEL: func @mem4() -> !fir.ref<() -> ()>
+func @mem1() -> !fir.ref<i32>
+func @mem2() -> !fir.ptr<i32>
+func @mem3() -> !fir.heap<i32>
+func @mem4() -> !fir.ref<() -> ()>
+
+// FIR box types (descriptors)
+// CHECK-LABEL: func @box1() -> !fir.box<!fir.array<?xf32>>
+// CHECK-LABEL: func @box2() -> !fir.boxchar<2>
+// CHECK-LABEL: func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK-LABEL: func @box4() -> !fir.box<none>
+// CHECK-LABEL: func @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
+func @box1() -> !fir.box<!fir.array<?xf32>>
+func @box2() -> !fir.boxchar<2>
+func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+func @box4() -> !fir.box<none>
+func @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
+
+// FIR misc. types
+// CHECK-LABEL: func @oth1() -> !fir.dims<1>
+// CHECK-LABEL: func @oth2() -> !fir.field
+// CHECK-LABEL: func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
+// CHECK-LABEL: func @oth4() -> !fir.dims<15>
+func @oth1() -> !fir.dims<1>
+func @oth2() -> !fir.field
+func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
+func @oth4() -> !fir.dims<15>
diff --git a/test-lit/lit.cfg.py b/test-lit/lit.cfg.py
index 3ca3c8ad23f7..2dce888c33fd 100644
--- a/test-lit/lit.cfg.py
+++ b/test-lit/lit.cfg.py
@@ -28,7 +28,7 @@
 # suffixes: A list of file extensions to treat as test files.
 config.suffixes = ['.f', '.F', '.ff','.FOR', '.for', '.f77', '.f90', '.F90',
                    '.ff90', '.f95', '.F95', '.ff95', '.fpp', '.FPP', '.cuf',
-                   '.CUF', '.f18', '.F18']
+                   '.CUF', '.f18', '.F18', '.fir' ]
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
@@ -56,6 +56,12 @@
 llvm_config.with_environment('PATH', config.flang_tools_dir, append_path=True)
 llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
 
+# For builds with FIR, set path for tco and enable related tests
+if config.flang_llvm_tools_dir != "" :
+  config.available_features.add('fir')
+  if config.llvm_tools_dir != config.flang_llvm_tools_dir :
+    llvm_config.with_environment('PATH', config.flang_llvm_tools_dir, append_path=True)
+
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
 # to search to ensure that we get the tools just built and not some random
diff --git a/test-lit/lit.site.cfg.py.in b/test-lit/lit.site.cfg.py.in
index d00f3856fb41..fe428f9bee06 100644
--- a/test-lit/lit.site.cfg.py.in
+++ b/test-lit/lit.site.cfg.py.in
@@ -7,6 +7,7 @@ config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
 config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
+config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 
 # Support substitution of the tools_dir with user parameters. This is
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index 41983a7b2e39..a02679436d14 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -6,5 +6,7 @@
 #
 #===------------------------------------------------------------------------===#
 
-
 add_subdirectory(f18)
+if(LINK_WITH_FIR)
+  add_subdirectory(tco)
+endif()
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
new file mode 100644
index 000000000000..33f410677705
--- /dev/null
+++ b/tools/tco/CMakeLists.txt
@@ -0,0 +1,24 @@
+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+
+set(LIBS
+  FIRDialect
+  FIRSupport
+  ${dialect_libs}
+  MLIRIR
+  MLIRLLVMIR
+  MLIRPass
+  MLIRStandardToLLVM
+  MLIRTransforms
+  MLIRAffineToStandard
+  MLIRAnalysis
+  MLIRLoopToStandard
+  MLIREDSC
+  MLIRParser
+  MLIRStandardToLLVM
+  MLIRSupport
+  MLIRVectorToLLVM
+)
+
+add_llvm_tool(tco tco.cpp)
+llvm_update_compile_flags(tco)
+target_link_libraries(tco PRIVATE ${LIBS})
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
new file mode 100644
index 000000000000..0e085fa5633f
--- /dev/null
+++ b/tools/tco/tco.cpp
@@ -0,0 +1,113 @@
+//===- tco.cpp - Tilikum Crossing Opt ---------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This is to be like LLVM's opt program, only for FIR.  Such a program is
+// required for roundtrip testing, etc.
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Module.h"
+#include "mlir/Parser.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/Passes.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+static cl::opt<std::string>
+    inputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
+
+static cl::opt<std::string> outputFilename("o",
+                                           cl::desc("Specify output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::init("-"));
+
+static cl::opt<bool> emitFir("emit-fir",
+                             cl::desc("Parse and pretty-print the input"),
+                             cl::init(false));
+
+static void printModuleBody(mlir::ModuleOp mod, raw_ostream &output) {
+  for (auto &op : mod.getBody()->without_terminator())
+    output << op << '\n';
+}
+
+// compile a .fir file
+static int compileFIR() {
+  // check that there is a file to load
+  ErrorOr<std::unique_ptr<MemoryBuffer>> fileOrErr =
+      MemoryBuffer::getFileOrSTDIN(inputFilename);
+
+  if (std::error_code EC = fileOrErr.getError()) {
+    errs() << "Could not open file: " << EC.message() << '\n';
+    return 1;
+  }
+
+  // load the file into a module
+  SourceMgr sourceMgr;
+  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), SMLoc());
+  auto context = std::make_unique<mlir::MLIRContext>();
+  auto owningRef = mlir::parseSourceFile(sourceMgr, context.get());
+
+  if (!owningRef) {
+    errs() << "Error can't load file " << inputFilename << '\n';
+    return 2;
+  }
+  if (mlir::failed(owningRef->verify())) {
+    errs() << "Error verifying FIR module\n";
+    return 4;
+  }
+
+  std::error_code ec;
+  ToolOutputFile out(outputFilename, ec, sys::fs::OF_None);
+
+  // run passes
+  mlir::PassManager pm{context.get()};
+  mlir::applyPassManagerCLOptions(pm);
+  if (emitFir) {
+    // parse the input and pretty-print it back out
+    // -emit-fir intentionally disables all the passes
+  } else {
+    // TODO: Actually add passes when added to FIR code base
+    // add all the passes
+    // the user can disable them individually
+  }
+
+  // run the pass manager
+  if (mlir::succeeded(pm.run(*owningRef))) {
+    // passes ran successfully, so keep the output
+    if (emitFir)
+      printModuleBody(*owningRef, out.os());
+    out.keep();
+    return 0;
+  }
+
+  // pass manager failed
+  printModuleBody(*owningRef, errs());
+  errs() << "\n\nFAILED: " << inputFilename << '\n';
+  return 8;
+}
+
+int main(int argc, char **argv) {
+  fir::registerFIR();
+  fir::registerFIRPasses();
+  [[maybe_unused]] InitLLVM y(argc, argv);
+  mlir::registerPassManagerCLOptions();
+  mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
+  cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Optimizer\n");
+  return compileFIR();
+}

From e5f369d0863899b601079b2d97e9144c1fd0b71e Mon Sep 17 00:00:00 2001
From: RichBarton-Arm <43278683+RichBarton-Arm@users.noreply.github.com>
Date: Thu, 12 Mar 2020 15:15:20 +0000
Subject: [PATCH 079/345] Add initial CODE_OWNERS file (#1066)

---
 CODE_OWNERS.TXT | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 CODE_OWNERS.TXT

diff --git a/CODE_OWNERS.TXT b/CODE_OWNERS.TXT
new file mode 100644
index 000000000000..a828c068d80e
--- /dev/null
+++ b/CODE_OWNERS.TXT
@@ -0,0 +1,18 @@
+This file is a list of the people responsible for ensuring that patches for a
+particular part of Flang are reviewed, either by themself or by someone else.
+They are also the gatekeepers for their part of Flang, with the final word on
+what goes in or not.
+
+The list is sorted by surname and formatted to allow easy grepping and
+beautification by scripts. The fields are: name (N), email (E), web-address
+(W), PGP key ID and fingerprint (P), description (D), snail-mail address
+(S) and (I) IRC handle. Each entry should contain at least the (N), (E) and
+(D) fields.
+
+N: Steve Scalpone
+E: sscalpone@nvidia.com
+D: Anything not covered by others
+
+N: Eric Schweitz
+E: eschweitz@nvidia.com
+D: FIR (lib/Fir), Fortran lowering (lib/Lower)

From 094f55890775362f093bb62c57c13b8d3436c82e Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Thu, 12 Mar 2020 16:38:59 +0000
Subject: [PATCH 080/345] Added documentation explaining the use of std::list
 (#988)

---
 documentation/Parsing.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/documentation/Parsing.md b/documentation/Parsing.md
index 4f584ee5aacd..b961cd630ae1 100644
--- a/documentation/Parsing.md
+++ b/documentation/Parsing.md
@@ -164,7 +164,12 @@ Parse tree entities should be viewed as values, not objects; their
 addresses should not be abused for purposes of identification.  They are
 assembled with C++ move semantics during parse tree construction.
 Their default and copy constructors are deliberately deleted in their
-declarations.
+declarations. 
+
+The std::list<> data type is used in the parse tree to reliably store pointers
+to other relevant entries in the tree. Since the tree lists are moved and
+spliced at certain points std::list<> provides the necessary guarantee of the
+stability of pointers into these lists.
 
 There is a general purpose library by means of which parse trees may
 be traversed.

From 4cdc9f75e2bd81889ccc4e30da8c40b2335f10c0 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 12 Mar 2020 10:25:22 -0700
Subject: [PATCH 081/345] fix typo (#1067)

---
 CODE_OWNERS.TXT | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CODE_OWNERS.TXT b/CODE_OWNERS.TXT
index a828c068d80e..7f84d357f9c4 100644
--- a/CODE_OWNERS.TXT
+++ b/CODE_OWNERS.TXT
@@ -15,4 +15,4 @@ D: Anything not covered by others
 
 N: Eric Schweitz
 E: eschweitz@nvidia.com
-D: FIR (lib/Fir), Fortran lowering (lib/Lower)
+D: FIR (lib/Optimizer), Fortran lowering (lib/Lower)

From d0f9ef7742132a5f9f7173b773aaac934484c7c1 Mon Sep 17 00:00:00 2001
From: Isuru Fernando <isuruf@gmail.com>
Date: Thu, 12 Mar 2020 12:52:29 -0500
Subject: [PATCH 082/345] Need <algorithm> for std::min and std::max (#1063)

---
 runtime/connection.cpp          | 1 +
 runtime/edit-input.cpp          | 1 +
 runtime/edit-output.cpp         | 1 +
 runtime/format-implementation.h | 1 +
 runtime/tools.cpp               | 1 +
 test/Runtime/testing.cpp        | 1 +
 6 files changed, 6 insertions(+)

diff --git a/runtime/connection.cpp b/runtime/connection.cpp
index d206b050aee4..e4a716560a45 100644
--- a/runtime/connection.cpp
+++ b/runtime/connection.cpp
@@ -8,6 +8,7 @@
 
 #include "connection.h"
 #include "environment.h"
+#include <algorithm>
 
 namespace Fortran::runtime::io {
 
diff --git a/runtime/edit-input.cpp b/runtime/edit-input.cpp
index 5b7884021067..dd7a804da2f8 100644
--- a/runtime/edit-input.cpp
+++ b/runtime/edit-input.cpp
@@ -9,6 +9,7 @@
 #include "edit-input.h"
 #include "flang/Common/real.h"
 #include "flang/Common/uint128.h"
+#include <algorithm>
 
 namespace Fortran::runtime::io {
 
diff --git a/runtime/edit-output.cpp b/runtime/edit-output.cpp
index 47e3b2918788..8206b418f3cd 100644
--- a/runtime/edit-output.cpp
+++ b/runtime/edit-output.cpp
@@ -9,6 +9,7 @@
 #include "edit-output.h"
 #include "flang/Common/uint128.h"
 #include "flang/Common/unsigned-const-division.h"
+#include <algorithm>
 
 namespace Fortran::runtime::io {
 
diff --git a/runtime/format-implementation.h b/runtime/format-implementation.h
index 43efd6e1f130..86168d0e823d 100644
--- a/runtime/format-implementation.h
+++ b/runtime/format-implementation.h
@@ -16,6 +16,7 @@
 #include "main.h"
 #include "flang/Common/format.h"
 #include "flang/Decimal/decimal.h"
+#include <algorithm>
 #include <limits>
 
 namespace Fortran::runtime::io {
diff --git a/runtime/tools.cpp b/runtime/tools.cpp
index f4dffb0027f1..12c792ca29cc 100644
--- a/runtime/tools.cpp
+++ b/runtime/tools.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "tools.h"
+#include <algorithm>
 #include <cstring>
 
 namespace Fortran::runtime {
diff --git a/test/Runtime/testing.cpp b/test/Runtime/testing.cpp
index 5eb86495f0cf..50ee686884cf 100644
--- a/test/Runtime/testing.cpp
+++ b/test/Runtime/testing.cpp
@@ -1,5 +1,6 @@
 #include "testing.h"
 #include "../../runtime/terminator.h"
+#include <algorithm>
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>

From 45454587c932c23430f0f1eb81df816dd75de86b Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 13 Mar 2020 04:06:31 -0700
Subject: [PATCH 083/345] Support latest LLVM head with FIR - MLIR SideEffects
 interface change

Include new .td after LLVM changes:
https://github.com/llvm/llvm-project/commit/0ddba0bd59c337f16b51a00cb205ecfda46f97fa

Tested to work with LLVM head ecd3e678bbb11cf899603037ec2c5949b8d7fa6c
from 2020-03-13 01:45 am PCT

Backwards compatible with previous known compatible heads at least back to
fde9d33f7101bac631b26990d17822474d3a34e9 from 2020-03-10, so need to
update LLVM builds if they previously work with FIR.
---
 include/flang/Optimizer/Dialect/FIROps.td | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index ab91c10e00fe..9d503928b25d 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -15,6 +15,7 @@
 #define FIR_DIALECT_FIR_OPS
 
 include "mlir/Interfaces/ControlFlowInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";

From 4de19d7ba2df892ce4361461841c3997de439532 Mon Sep 17 00:00:00 2001
From: Luke Ireland <luke.ireland@arm.com>
Date: Fri, 21 Feb 2020 12:28:58 +0000
Subject: [PATCH 084/345] Re-enable semantics/altreturn{02,03} tests

These tests were disabled due to https://github.com/flang-compiler/f18/issues/407.
Previously these tests caused F18 to crash as the feature was not fully
implemented.

The altreturn feature is now implemented, so these tests can be
re-enabled. altreturn03 tested some negative cases which F18 correctly
diagnoses. Modified that test to expect these new error messages. Also
make the later cases in the test reachable.

These tests can now be ported by the script to lit-style tests.

Change-Id: Ib336c10d55068d9a26fc2deb43ad052e74e73456
---
 test/Semantics/CMakeLists.txt  |  5 ++---
 test/Semantics/altreturn03.f90 | 15 +++++++++------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/test/Semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
index 7c826d82b961..a24108782ae7 100644
--- a/test/Semantics/CMakeLists.txt
+++ b/test/Semantics/CMakeLists.txt
@@ -131,9 +131,8 @@ set(ERROR_TESTS
   deallocate05.f90
   coarrays01.f90
   altreturn01.f90
-# Issue 407
-#  altreturn02.f90
-#  altreturn03.f90
+  altreturn02.f90
+  altreturn03.f90
   altreturn04.f90
   altreturn05.f90
   allocate01.f90
diff --git a/test/Semantics/altreturn03.f90 b/test/Semantics/altreturn03.f90
index 9873fb8357c0..15410e716752 100644
--- a/test/Semantics/altreturn03.f90
+++ b/test/Semantics/altreturn03.f90
@@ -8,11 +8,14 @@ SUBROUTINE TEST (N, *, *)
        IF ( N .EQ. 1 ) RETURN 1
        IF ( N .EQ. 2 ) RETURN 2
        IF ( N .EQ. 3 ) RETURN 3
-       IF ( N .EQ. 3 ) RETURN N
-       IF ( N .EQ. 3 ) RETURN N * N
-       IF ( N .EQ. 3 ) RETURN B(N)
-       IF ( N .EQ. 3 ) RETURN B
-       IF ( N .EQ. 3 ) RETURN R
-       IF ( N .EQ. 3 ) RETURN Z
+       IF ( N .EQ. 4 ) RETURN N
+       IF ( N .EQ. 5 ) RETURN N * N
+       IF ( N .EQ. 6 ) RETURN B(N)
+       !ERROR: Must be a scalar value, but is a rank-1 array
+       IF ( N .EQ. 7 ) RETURN B
+       !ERROR: Must have INTEGER type, but is REAL(4)
+       IF ( N .EQ. 8 ) RETURN R
+       !ERROR: Must have INTEGER type, but is COMPLEX(4)
+       IF ( N .EQ. 9 ) RETURN Z
        RETURN 2
        END

From 2bfddbe8f8898551a28c3ea07b7ae508018f8634 Mon Sep 17 00:00:00 2001
From: Luke Ireland <luke.ireland@arm.com>
Date: Wed, 19 Feb 2020 15:49:33 +0000
Subject: [PATCH 085/345] Create a separate directory for unittests

Some of the regression tests are C programs that act as test harnesses
for the compiler internals as opposed to being Fortran inputs to test
the compiler in action. The former style of tests are analog to LLVM's
unittests and will not use the lit framework.

Change-Id: I0ff10e23f66ff843e8fff4c35cfb6559b9dab762
---
 CMakeLists.txt                                |  2 +-
 {test => unittests}/CMakeLists.txt            |  1 -
 {test => unittests}/Decimal/CMakeLists.txt    |  0
 .../Decimal/quick-sanity-test.cpp             |  0
 {test => unittests}/Decimal/thorough-test.cpp |  0
 {test => unittests}/Evaluate/CMakeLists.txt   | 25 -------------------
 .../Evaluate/ISO-Fortran-binding.cpp          |  0
 .../Evaluate/bit-population-count.cpp         |  0
 {test => unittests}/Evaluate/expression.cpp   |  0
 {test => unittests}/Evaluate/folding.cpp      |  0
 {test => unittests}/Evaluate/fp-testing.cpp   |  0
 {test => unittests}/Evaluate/fp-testing.h     |  0
 {test => unittests}/Evaluate/integer.cpp      |  0
 {test => unittests}/Evaluate/intrinsics.cpp   |  0
 .../Evaluate/leading-zero-bit-count.cpp       |  0
 {test => unittests}/Evaluate/logical.cpp      |  0
 {test => unittests}/Evaluate/real.cpp         |  0
 {test => unittests}/Evaluate/reshape.cpp      |  0
 {test => unittests}/Evaluate/testing.cpp      |  0
 {test => unittests}/Evaluate/testing.h        |  0
 {test => unittests}/Evaluate/uint128.cpp      |  0
 {test => unittests}/Runtime/CMakeLists.txt    |  0
 .../Runtime/external-hello.cpp                |  0
 {test => unittests}/Runtime/format.cpp        |  0
 {test => unittests}/Runtime/hello.cpp         |  0
 {test => unittests}/Runtime/list-input.cpp    |  0
 {test => unittests}/Runtime/testing.cpp       |  0
 {test => unittests}/Runtime/testing.h         |  0
 28 files changed, 1 insertion(+), 27 deletions(-)
 rename {test => unittests}/CMakeLists.txt (94%)
 rename {test => unittests}/Decimal/CMakeLists.txt (100%)
 rename {test => unittests}/Decimal/quick-sanity-test.cpp (100%)
 rename {test => unittests}/Decimal/thorough-test.cpp (100%)
 rename {test => unittests}/Evaluate/CMakeLists.txt (85%)
 rename {test => unittests}/Evaluate/ISO-Fortran-binding.cpp (100%)
 rename {test => unittests}/Evaluate/bit-population-count.cpp (100%)
 rename {test => unittests}/Evaluate/expression.cpp (100%)
 rename {test => unittests}/Evaluate/folding.cpp (100%)
 rename {test => unittests}/Evaluate/fp-testing.cpp (100%)
 rename {test => unittests}/Evaluate/fp-testing.h (100%)
 rename {test => unittests}/Evaluate/integer.cpp (100%)
 rename {test => unittests}/Evaluate/intrinsics.cpp (100%)
 rename {test => unittests}/Evaluate/leading-zero-bit-count.cpp (100%)
 rename {test => unittests}/Evaluate/logical.cpp (100%)
 rename {test => unittests}/Evaluate/real.cpp (100%)
 rename {test => unittests}/Evaluate/reshape.cpp (100%)
 rename {test => unittests}/Evaluate/testing.cpp (100%)
 rename {test => unittests}/Evaluate/testing.h (100%)
 rename {test => unittests}/Evaluate/uint128.cpp (100%)
 rename {test => unittests}/Runtime/CMakeLists.txt (100%)
 rename {test => unittests}/Runtime/external-hello.cpp (100%)
 rename {test => unittests}/Runtime/format.cpp (100%)
 rename {test => unittests}/Runtime/hello.cpp (100%)
 rename {test => unittests}/Runtime/list-input.cpp (100%)
 rename {test => unittests}/Runtime/testing.cpp (100%)
 rename {test => unittests}/Runtime/testing.h (100%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 97a03ee4a9a3..f19259df77e1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -154,7 +154,7 @@ enable_testing()
 add_subdirectory(include/flang)
 add_subdirectory(lib)
 add_subdirectory(runtime)
-add_subdirectory(test)
+add_subdirectory(unittests)
 add_subdirectory(tools)
 add_subdirectory(test-lit)
 
diff --git a/test/CMakeLists.txt b/unittests/CMakeLists.txt
similarity index 94%
rename from test/CMakeLists.txt
rename to unittests/CMakeLists.txt
index e83f63c8e030..6d49e6c72b57 100644
--- a/test/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -9,4 +9,3 @@
 add_subdirectory(Decimal)
 add_subdirectory(Evaluate)
 add_subdirectory(Runtime)
-add_subdirectory(Semantics)
diff --git a/test/Decimal/CMakeLists.txt b/unittests/Decimal/CMakeLists.txt
similarity index 100%
rename from test/Decimal/CMakeLists.txt
rename to unittests/Decimal/CMakeLists.txt
diff --git a/test/Decimal/quick-sanity-test.cpp b/unittests/Decimal/quick-sanity-test.cpp
similarity index 100%
rename from test/Decimal/quick-sanity-test.cpp
rename to unittests/Decimal/quick-sanity-test.cpp
diff --git a/test/Decimal/thorough-test.cpp b/unittests/Decimal/thorough-test.cpp
similarity index 100%
rename from test/Decimal/thorough-test.cpp
rename to unittests/Decimal/thorough-test.cpp
diff --git a/test/Evaluate/CMakeLists.txt b/unittests/Evaluate/CMakeLists.txt
similarity index 85%
rename from test/Evaluate/CMakeLists.txt
rename to unittests/Evaluate/CMakeLists.txt
index b08c1431df70..d874fcb39dbc 100644
--- a/test/Evaluate/CMakeLists.txt
+++ b/unittests/Evaluate/CMakeLists.txt
@@ -132,18 +132,6 @@ target_link_libraries(folding-test
   FortranSemantics
 )
 
-set(FOLDING_TESTS
-  folding01.f90
-  folding02.f90
-  folding03.f90
-  folding04.f90
-  folding05.f90
-  folding06.f90
-  folding07.f90
-  folding08.f90
-  folding09.f90
-)
-
 add_test(Expression expression-test)
 add_test(Integer integer-test)
 add_test(Intrinsics intrinsics-test)
@@ -152,16 +140,3 @@ add_test(Real real-test)
 add_test(RESHAPE reshape-test)
 add_test(ISO-binding ISO-Fortran-binding-test)
 add_test(folding folding-test)
-
-set(TEST_LIBPGMATH "-pgmath=false")
-if (LIBPGMATH_DIR)
-  find_library(LIBPGMATH pgmath PATHS ${LIBPGMATH_DIR})
-  if(LIBPGMATH)
-    set(TEST_LIBPGMATH "-pgmath=true")
-  endif()
-endif()
-
-foreach(test ${FOLDING_TESTS})
-  add_test(NAME ${test} COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test_folding.sh
-    ${test} ${TEST_LIBPGMATH})
-endforeach()
diff --git a/test/Evaluate/ISO-Fortran-binding.cpp b/unittests/Evaluate/ISO-Fortran-binding.cpp
similarity index 100%
rename from test/Evaluate/ISO-Fortran-binding.cpp
rename to unittests/Evaluate/ISO-Fortran-binding.cpp
diff --git a/test/Evaluate/bit-population-count.cpp b/unittests/Evaluate/bit-population-count.cpp
similarity index 100%
rename from test/Evaluate/bit-population-count.cpp
rename to unittests/Evaluate/bit-population-count.cpp
diff --git a/test/Evaluate/expression.cpp b/unittests/Evaluate/expression.cpp
similarity index 100%
rename from test/Evaluate/expression.cpp
rename to unittests/Evaluate/expression.cpp
diff --git a/test/Evaluate/folding.cpp b/unittests/Evaluate/folding.cpp
similarity index 100%
rename from test/Evaluate/folding.cpp
rename to unittests/Evaluate/folding.cpp
diff --git a/test/Evaluate/fp-testing.cpp b/unittests/Evaluate/fp-testing.cpp
similarity index 100%
rename from test/Evaluate/fp-testing.cpp
rename to unittests/Evaluate/fp-testing.cpp
diff --git a/test/Evaluate/fp-testing.h b/unittests/Evaluate/fp-testing.h
similarity index 100%
rename from test/Evaluate/fp-testing.h
rename to unittests/Evaluate/fp-testing.h
diff --git a/test/Evaluate/integer.cpp b/unittests/Evaluate/integer.cpp
similarity index 100%
rename from test/Evaluate/integer.cpp
rename to unittests/Evaluate/integer.cpp
diff --git a/test/Evaluate/intrinsics.cpp b/unittests/Evaluate/intrinsics.cpp
similarity index 100%
rename from test/Evaluate/intrinsics.cpp
rename to unittests/Evaluate/intrinsics.cpp
diff --git a/test/Evaluate/leading-zero-bit-count.cpp b/unittests/Evaluate/leading-zero-bit-count.cpp
similarity index 100%
rename from test/Evaluate/leading-zero-bit-count.cpp
rename to unittests/Evaluate/leading-zero-bit-count.cpp
diff --git a/test/Evaluate/logical.cpp b/unittests/Evaluate/logical.cpp
similarity index 100%
rename from test/Evaluate/logical.cpp
rename to unittests/Evaluate/logical.cpp
diff --git a/test/Evaluate/real.cpp b/unittests/Evaluate/real.cpp
similarity index 100%
rename from test/Evaluate/real.cpp
rename to unittests/Evaluate/real.cpp
diff --git a/test/Evaluate/reshape.cpp b/unittests/Evaluate/reshape.cpp
similarity index 100%
rename from test/Evaluate/reshape.cpp
rename to unittests/Evaluate/reshape.cpp
diff --git a/test/Evaluate/testing.cpp b/unittests/Evaluate/testing.cpp
similarity index 100%
rename from test/Evaluate/testing.cpp
rename to unittests/Evaluate/testing.cpp
diff --git a/test/Evaluate/testing.h b/unittests/Evaluate/testing.h
similarity index 100%
rename from test/Evaluate/testing.h
rename to unittests/Evaluate/testing.h
diff --git a/test/Evaluate/uint128.cpp b/unittests/Evaluate/uint128.cpp
similarity index 100%
rename from test/Evaluate/uint128.cpp
rename to unittests/Evaluate/uint128.cpp
diff --git a/test/Runtime/CMakeLists.txt b/unittests/Runtime/CMakeLists.txt
similarity index 100%
rename from test/Runtime/CMakeLists.txt
rename to unittests/Runtime/CMakeLists.txt
diff --git a/test/Runtime/external-hello.cpp b/unittests/Runtime/external-hello.cpp
similarity index 100%
rename from test/Runtime/external-hello.cpp
rename to unittests/Runtime/external-hello.cpp
diff --git a/test/Runtime/format.cpp b/unittests/Runtime/format.cpp
similarity index 100%
rename from test/Runtime/format.cpp
rename to unittests/Runtime/format.cpp
diff --git a/test/Runtime/hello.cpp b/unittests/Runtime/hello.cpp
similarity index 100%
rename from test/Runtime/hello.cpp
rename to unittests/Runtime/hello.cpp
diff --git a/test/Runtime/list-input.cpp b/unittests/Runtime/list-input.cpp
similarity index 100%
rename from test/Runtime/list-input.cpp
rename to unittests/Runtime/list-input.cpp
diff --git a/test/Runtime/testing.cpp b/unittests/Runtime/testing.cpp
similarity index 100%
rename from test/Runtime/testing.cpp
rename to unittests/Runtime/testing.cpp
diff --git a/test/Runtime/testing.h b/unittests/Runtime/testing.h
similarity index 100%
rename from test/Runtime/testing.h
rename to unittests/Runtime/testing.h

From 63ec0af9f4c8e736a626d1cd1410f71f4e578aa9 Mon Sep 17 00:00:00 2001
From: Luke Ireland <luke.ireland@arm.com>
Date: Fri, 14 Feb 2020 14:02:29 +0000
Subject: [PATCH 086/345] Port all remaining regression tests to lit

We have re-classified a subset of the regression tests as unit tests and
now we are porting the remaining ones.

Test discovery and running is now performed by lit rather than ctest.
The tests continue to use their original scripts with minor
modifications. Most of the changes were mechanical and so scripted.
A few changes were made by hand. Details

Manual:
  * modfile09-*.f90 tests depend on being run together as some tests have
    dependencies on modules created by other tests. This will need
     separating out when porting away from test_modfile.sh, but for now,
     added modfile09-*.f90 to the Inputs directory and added a single
     tests modfile09.f90 to hold the run line.
  * getdefinition03-a.f90 includes a non-test file getdefinition03-b.f90.
    Manually edited the former to find the latter in Inputs so as to add
    only one test.
  * Same pattern for getsymbols03-{a,b}.f90

Auto:
  * Remaining tests have a lit RUN line added to them based on the type
    of test they are.
  * Failing tests also have an XFAIL line added to them.
  * Generic tests have their pre-existing RUN lines replaced with the
    word "EXEC" to avoid conflict with the added lit RUN line.
---
 {test-lit => test}/Driver/version_test.f90    |   0
 test/Evaluate/folding01.f90                   |   1 +
 test/Evaluate/folding02.f90                   |   1 +
 test/Evaluate/folding03.f90                   |   1 +
 test/Evaluate/folding04.f90                   |   1 +
 test/Evaluate/folding05.f90                   | Bin 9530 -> 9569 bytes
 test/Evaluate/folding06.f90                   |   1 +
 test/Evaluate/folding07.f90                   |   1 +
 test/Evaluate/folding08.f90                   |   1 +
 test/Evaluate/folding09.f90                   |   1 +
 {test-lit => test}/Fir/fir-ops.fir            |   0
 {test-lit => test}/Fir/fir-types.fir          |   0
 {test-lit => test}/Lower/pre-fir-tree01.f90   |   0
 {test-lit => test}/Lower/pre-fir-tree02.f90   |   0
 {test-lit => test}/Lower/pre-fir-tree03.f90   |   0
 {test-lit => test}/Lower/pre-fir-tree04.f90   |   0
 .../{ => Inputs}/getdefinition03-b.f90        |   0
 .../Semantics/{ => Inputs}/getsymbols02-a.f90 |   2 +-
 .../Semantics/{ => Inputs}/getsymbols02-b.f90 |   2 +-
 .../Semantics/{ => Inputs}/getsymbols02-c.f90 |   2 +-
 .../Semantics/{ => Inputs}/getsymbols03-b.f90 |   0
 .../Semantics/Inputs/mod-file-changed.f90     |   0
 .../Semantics/Inputs/mod-file-unchanged.f90   |   0
 test/Semantics/{ => Inputs}/modfile09-a.f90   |   0
 test/Semantics/{ => Inputs}/modfile09-b.f90   |   0
 test/Semantics/{ => Inputs}/modfile09-c.f90   |   0
 test/Semantics/{ => Inputs}/modfile09-d.f90   |   0
 test/Semantics/allocate01.f90                 |   1 +
 test/Semantics/allocate02.f90                 |   1 +
 test/Semantics/allocate03.f90                 |   1 +
 test/Semantics/allocate04.f90                 |   1 +
 test/Semantics/allocate05.f90                 |   1 +
 test/Semantics/allocate06.f90                 |   1 +
 test/Semantics/allocate07.f90                 |   1 +
 test/Semantics/allocate08.f90                 |   1 +
 test/Semantics/allocate09.f90                 |   1 +
 test/Semantics/allocate10.f90                 |   1 +
 test/Semantics/allocate11.f90                 |   1 +
 test/Semantics/allocate12.f90                 |   1 +
 test/Semantics/allocate13.f90                 |   1 +
 test/Semantics/altreturn01.f90                |   1 +
 test/Semantics/altreturn02.f90                |   1 +
 test/Semantics/altreturn03.f90                |   1 +
 test/Semantics/altreturn04.f90                |   1 +
 test/Semantics/altreturn05.f90                |   1 +
 test/Semantics/assign01.f90                   |   1 +
 test/Semantics/assign02.f90                   |   1 +
 test/Semantics/assign03.f90                   |   1 +
 test/Semantics/assign04.f90                   |   1 +
 test/Semantics/bad-forward-type.f90           |   1 +
 test/Semantics/bindings01.f90                 |   1 +
 test/Semantics/block-data01.f90               |   1 +
 test/Semantics/blockconstruct01.f90           |   1 +
 test/Semantics/blockconstruct02.f90           |   1 +
 test/Semantics/blockconstruct03.f90           |   1 +
 test/Semantics/c_f_pointer.f90                |   1 +
 test/Semantics/call01.f90                     |   1 +
 test/Semantics/call02.f90                     |   1 +
 test/Semantics/call03.f90                     |   1 +
 test/Semantics/call04.f90                     |   1 +
 test/Semantics/call05.f90                     |   1 +
 test/Semantics/call06.f90                     |   1 +
 test/Semantics/call07.f90                     |   1 +
 test/Semantics/call08.f90                     |   1 +
 test/Semantics/call09.f90                     |   1 +
 test/Semantics/call10.f90                     |   1 +
 test/Semantics/call11.f90                     |   1 +
 test/Semantics/call12.f90                     |   1 +
 test/Semantics/call13.f90                     |   1 +
 test/Semantics/call14.f90                     |   1 +
 test/Semantics/call15.f90                     |   1 +
 test/Semantics/canondo01.f90                  |   3 ++-
 test/Semantics/canondo02.f90                  |   3 ++-
 test/Semantics/canondo03.f90                  |   3 ++-
 test/Semantics/canondo04.f90                  |   3 ++-
 test/Semantics/canondo05.f90                  |   5 +++--
 test/Semantics/canondo06.f90                  |   3 ++-
 test/Semantics/canondo07.f90                  |   3 ++-
 test/Semantics/canondo08.f90                  |   3 ++-
 test/Semantics/canondo09.f90                  |   3 ++-
 test/Semantics/canondo10.f90                  |   3 ++-
 test/Semantics/canondo11.f90                  |   3 ++-
 test/Semantics/canondo12.f90                  |   3 ++-
 test/Semantics/canondo13.f90                  |   3 ++-
 test/Semantics/canondo14.f90                  |   3 ++-
 test/Semantics/canondo15.f90                  |   3 ++-
 test/Semantics/canondo16.f90                  |   3 ++-
 test/Semantics/canondo17.f90                  |   3 ++-
 test/Semantics/canondo18.f90                  |   3 ++-
 test/Semantics/canondo19.f90                  |   3 ++-
 test/Semantics/coarrays01.f90                 |   1 +
 test/Semantics/complex01.f90                  |   1 +
 test/Semantics/computed-goto01.f90            |   1 +
 test/Semantics/computed-goto02.f90            |   1 +
 test/Semantics/critical01.f90                 |   1 +
 test/Semantics/critical02.f90                 |   1 +
 test/Semantics/critical03.f90                 |   1 +
 test/Semantics/critical04.f90                 |   3 ++-
 test/Semantics/data01.f90                     |   1 +
 test/Semantics/data02.f90                     |   1 +
 test/Semantics/deallocate01.f90               |   1 +
 test/Semantics/deallocate04.f90               |   1 +
 test/Semantics/deallocate05.f90               |   1 +
 test/Semantics/doconcurrent01.f90             |   1 +
 test/Semantics/doconcurrent02.f90             |   3 ++-
 test/Semantics/doconcurrent03.f90             |   3 ++-
 test/Semantics/doconcurrent04.f90             |   3 ++-
 test/Semantics/doconcurrent05.f90             |   1 +
 test/Semantics/doconcurrent06.f90             |   1 +
 test/Semantics/doconcurrent07.f90             |   3 ++-
 test/Semantics/doconcurrent08.f90             |   1 +
 test/Semantics/dosemantics01.f90              |   1 +
 test/Semantics/dosemantics02.f90              |   1 +
 test/Semantics/dosemantics03.f90              |   1 +
 test/Semantics/dosemantics04.f90              |   1 +
 test/Semantics/dosemantics05.f90              |   1 +
 test/Semantics/dosemantics06.f90              |   1 +
 test/Semantics/dosemantics07.f90              |   1 +
 test/Semantics/dosemantics08.f90              |   1 +
 test/Semantics/dosemantics09.f90              |   1 +
 test/Semantics/dosemantics10.f90              |   1 +
 test/Semantics/dosemantics11.f90              |   1 +
 test/Semantics/dosemantics12.f90              |   1 +
 test/Semantics/equivalence01.f90              |   1 +
 test/Semantics/expr-errors01.f90              |   1 +
 test/Semantics/expr-errors02.f90              |   1 +
 test/Semantics/forall01.f90                   |   1 +
 test/Semantics/getdefinition01.f90            |  14 +++++++-------
 test/Semantics/getdefinition02.f              |  10 +++++-----
 test/Semantics/getdefinition03-a.f90          |  10 +++++-----
 test/Semantics/getdefinition04.f90            |   4 ++--
 test/Semantics/getdefinition05.f90            |   8 ++++----
 test/Semantics/getsymbols01.f90               |   4 ++--
 test/Semantics/getsymbols02.f90               |   1 +
 test/Semantics/getsymbols03-a.f90             |   6 +++---
 test/Semantics/getsymbols04.f90               |   4 ++--
 test/Semantics/getsymbols05.f90               |   4 ++--
 test/Semantics/if_arith01.f90                 |   1 +
 test/Semantics/if_arith02.f90                 |   1 +
 test/Semantics/if_arith03.f90                 |   1 +
 test/Semantics/if_arith04.f90                 |   1 +
 test/Semantics/if_construct01.f90             |   1 +
 test/Semantics/if_construct02.f90             |   1 +
 test/Semantics/if_stmt01.f90                  |   1 +
 test/Semantics/if_stmt02.f90                  |   1 +
 test/Semantics/if_stmt03.f90                  |   1 +
 test/Semantics/implicit01.f90                 |   1 +
 test/Semantics/implicit02.f90                 |   1 +
 test/Semantics/implicit03.f90                 |   1 +
 test/Semantics/implicit04.f90                 |   1 +
 test/Semantics/implicit05.f90                 |   1 +
 test/Semantics/implicit06.f90                 |   1 +
 test/Semantics/implicit07.f90                 |   1 +
 test/Semantics/implicit08.f90                 |   1 +
 test/Semantics/init01.f90                     |   1 +
 test/Semantics/int-literals.f90               |   1 +
 test/Semantics/io01.f90                       |   1 +
 test/Semantics/io02.f90                       |   1 +
 test/Semantics/io03.f90                       |   1 +
 test/Semantics/io04.f90                       |   1 +
 test/Semantics/io05.f90                       |   1 +
 test/Semantics/io06.f90                       |   1 +
 test/Semantics/io07.f90                       |   1 +
 test/Semantics/io08.f90                       |   1 +
 test/Semantics/io09.f90                       |   1 +
 test/Semantics/io10.f90                       |   1 +
 test/Semantics/kinds01.f90                    |   1 +
 test/Semantics/kinds02.f90                    |   1 +
 test/Semantics/kinds03.f90                    |   1 +
 test/Semantics/kinds04.f90                    |   1 +
 test/Semantics/label01.F90                    |   3 ++-
 test/Semantics/label02.f90                    |   3 ++-
 test/Semantics/label03.f90                    |   3 ++-
 test/Semantics/label04.f90                    |   3 ++-
 test/Semantics/label05.f90                    |   3 ++-
 test/Semantics/label06.f90                    |   3 ++-
 test/Semantics/label07.f90                    |   3 ++-
 test/Semantics/label08.f90                    |   3 ++-
 test/Semantics/label09.f90                    |   3 ++-
 test/Semantics/label10.f90                    |   3 ++-
 test/Semantics/label11.f90                    |   3 ++-
 test/Semantics/label12.f90                    |   3 ++-
 test/Semantics/label13.f90                    |   3 ++-
 test/Semantics/label14.f90                    |   3 ++-
 test/Semantics/misc-declarations.f90          |   1 +
 .../Semantics/mod-file-rewriter.f90           |   0
 test/Semantics/modfile01.f90                  |   1 +
 test/Semantics/modfile02.f90                  |   1 +
 test/Semantics/modfile03.f90                  |   1 +
 test/Semantics/modfile04.f90                  |   1 +
 test/Semantics/modfile05.f90                  |   1 +
 test/Semantics/modfile06.f90                  |   1 +
 test/Semantics/modfile07.f90                  |   1 +
 test/Semantics/modfile08.f90                  |   1 +
 test/Semantics/modfile09.f90                  |   1 +
 test/Semantics/modfile10.f90                  |   1 +
 test/Semantics/modfile11.f90                  |   1 +
 test/Semantics/modfile12.f90                  |   1 +
 test/Semantics/modfile13.f90                  |   1 +
 test/Semantics/modfile14.f90                  |   1 +
 test/Semantics/modfile15.f90                  |   1 +
 test/Semantics/modfile16.f90                  |   1 +
 test/Semantics/modfile17.f90                  |   1 +
 test/Semantics/modfile18.f90                  |   1 +
 test/Semantics/modfile19.f90                  |   1 +
 test/Semantics/modfile20.f90                  |   1 +
 test/Semantics/modfile21.f90                  |   1 +
 test/Semantics/modfile22.f90                  |   1 +
 test/Semantics/modfile23.f90                  |   1 +
 test/Semantics/modfile24.f90                  |   1 +
 test/Semantics/modfile25.f90                  |   1 +
 test/Semantics/modfile26.f90                  |   1 +
 test/Semantics/modfile27.f90                  |   1 +
 test/Semantics/modfile28.f90                  |   1 +
 test/Semantics/modfile29.f90                  |   1 +
 test/Semantics/modfile30.f90                  |   1 +
 test/Semantics/modfile31.f90                  |   1 +
 test/Semantics/modfile32.f90                  |   1 +
 test/Semantics/modfile33.f90                  |   1 +
 test/Semantics/modfile34.f90                  |   1 +
 test/Semantics/modfile35.f90                  |   1 +
 test/Semantics/namelist01.f90                 |   1 +
 test/Semantics/null01.f90                     |   1 +
 test/Semantics/nullify01.f90                  |   1 +
 test/Semantics/nullify02.f90                  |   1 +
 test/Semantics/omp-atomic.f90                 |   1 +
 test/Semantics/omp-clause-validity01.f90      |   1 +
 test/Semantics/omp-declarative-directive.f90  |   1 +
 test/Semantics/omp-device-constructs.f90      |   1 +
 test/Semantics/omp-loop-association.f90       |   1 +
 test/Semantics/omp-nested01.f90               |   2 ++
 test/Semantics/omp-resolve01.f90              |   1 +
 test/Semantics/omp-resolve02.f90              |   1 +
 test/Semantics/omp-resolve03.f90              |   1 +
 test/Semantics/omp-resolve04.f90              |   1 +
 test/Semantics/omp-resolve05.f90              |   1 +
 test/Semantics/omp-symbol01.f90               |   1 +
 test/Semantics/omp-symbol02.f90               |   1 +
 test/Semantics/omp-symbol03.f90               |   1 +
 test/Semantics/omp-symbol04.f90               |   1 +
 test/Semantics/omp-symbol05.f90               |   1 +
 test/Semantics/omp-symbol06.f90               |   1 +
 test/Semantics/omp-symbol07.f90               |   1 +
 test/Semantics/omp-symbol08.f90               |   1 +
 test/Semantics/procinterface01.f90            |   1 +
 test/Semantics/resolve01.f90                  |   1 +
 test/Semantics/resolve02.f90                  |   1 +
 test/Semantics/resolve03.f90                  |   1 +
 test/Semantics/resolve04.f90                  |   1 +
 test/Semantics/resolve05.f90                  |   1 +
 test/Semantics/resolve06.f90                  |   1 +
 test/Semantics/resolve07.f90                  |   1 +
 test/Semantics/resolve08.f90                  |   1 +
 test/Semantics/resolve09.f90                  |   1 +
 test/Semantics/resolve10.f90                  |   1 +
 test/Semantics/resolve11.f90                  |   1 +
 test/Semantics/resolve12.f90                  |   1 +
 test/Semantics/resolve13.f90                  |   1 +
 test/Semantics/resolve14.f90                  |   1 +
 test/Semantics/resolve15.f90                  |   1 +
 test/Semantics/resolve16.f90                  |   1 +
 test/Semantics/resolve17.f90                  |   1 +
 test/Semantics/resolve18.f90                  |   1 +
 test/Semantics/resolve19.f90                  |   1 +
 test/Semantics/resolve20.f90                  |   1 +
 test/Semantics/resolve21.f90                  |   1 +
 test/Semantics/resolve22.f90                  |   1 +
 test/Semantics/resolve23.f90                  |   1 +
 test/Semantics/resolve24.f90                  |   1 +
 test/Semantics/resolve25.f90                  |   1 +
 test/Semantics/resolve26.f90                  |   1 +
 test/Semantics/resolve27.f90                  |   1 +
 test/Semantics/resolve28.f90                  |   1 +
 test/Semantics/resolve29.f90                  |   1 +
 test/Semantics/resolve30.f90                  |   1 +
 test/Semantics/resolve31.f90                  |   1 +
 test/Semantics/resolve32.f90                  |   1 +
 test/Semantics/resolve33.f90                  |   1 +
 test/Semantics/resolve34.f90                  |   1 +
 test/Semantics/resolve35.f90                  |   1 +
 test/Semantics/resolve36.f90                  |   1 +
 test/Semantics/resolve37.f90                  |   1 +
 test/Semantics/resolve38.f90                  |   1 +
 test/Semantics/resolve39.f90                  |   1 +
 test/Semantics/resolve40.f90                  |   1 +
 test/Semantics/resolve41.f90                  |   1 +
 test/Semantics/resolve42.f90                  |   1 +
 test/Semantics/resolve43.f90                  |   1 +
 test/Semantics/resolve44.f90                  |   1 +
 test/Semantics/resolve45.f90                  |   1 +
 test/Semantics/resolve46.f90                  |   1 +
 test/Semantics/resolve47.f90                  |   1 +
 test/Semantics/resolve48.f90                  |   1 +
 test/Semantics/resolve49.f90                  |   1 +
 test/Semantics/resolve50.f90                  |   1 +
 test/Semantics/resolve51.f90                  |   1 +
 test/Semantics/resolve52.f90                  |   1 +
 test/Semantics/resolve53.f90                  |   1 +
 test/Semantics/resolve54.f90                  |   1 +
 test/Semantics/resolve55.f90                  |   1 +
 test/Semantics/resolve56.f90                  |   1 +
 test/Semantics/resolve57.f90                  |   1 +
 test/Semantics/resolve58.f90                  |   1 +
 test/Semantics/resolve59.f90                  |   1 +
 test/Semantics/resolve60.f90                  |   1 +
 test/Semantics/resolve61.f90                  |   1 +
 test/Semantics/resolve62.f90                  |   1 +
 test/Semantics/resolve63.f90                  |   1 +
 test/Semantics/resolve64.f90                  |   1 +
 test/Semantics/resolve65.f90                  |   1 +
 test/Semantics/resolve66.f90                  |   1 +
 test/Semantics/resolve67.f90                  |   1 +
 test/Semantics/resolve68.f90                  |   1 +
 test/Semantics/resolve69.f90                  |   1 +
 test/Semantics/resolve70.f90                  |   1 +
 test/Semantics/resolve71.f90                  |   1 +
 test/Semantics/resolve72.f90                  |   1 +
 test/Semantics/resolve73.f90                  |   1 +
 test/Semantics/resolve74.f90                  |   1 +
 test/Semantics/resolve75.f90                  |   1 +
 test/Semantics/separate-module-procs.f90      |   1 +
 test/Semantics/stop01.f90                     |   1 +
 test/Semantics/structconst01.f90              |   1 +
 test/Semantics/structconst02.f90              |   1 +
 test/Semantics/structconst03.f90              |   1 +
 test/Semantics/structconst04.f90              |   1 +
 test/Semantics/symbol01.f90                   |   1 +
 test/Semantics/symbol02.f90                   |   1 +
 test/Semantics/symbol03.f90                   |   1 +
 test/Semantics/symbol05.f90                   |   1 +
 test/Semantics/symbol06.f90                   |   1 +
 test/Semantics/symbol07.f90                   |   1 +
 test/Semantics/symbol08.f90                   |   1 +
 test/Semantics/symbol09.f90                   |   1 +
 test/Semantics/symbol10.f90                   |   1 +
 test/Semantics/symbol11.f90                   |   1 +
 test/Semantics/symbol12.f90                   |   1 +
 test/Semantics/symbol13.f90                   |   1 +
 test/Semantics/symbol14.f90                   |   1 +
 test/Semantics/symbol15.f90                   |   1 +
 test/Semantics/symbol16.f90                   |   1 +
 test/Semantics/symbol17.f90                   |   1 +
 342 files changed, 388 insertions(+), 74 deletions(-)
 rename {test-lit => test}/Driver/version_test.f90 (100%)
 rename {test-lit => test}/Fir/fir-ops.fir (100%)
 rename {test-lit => test}/Fir/fir-types.fir (100%)
 rename {test-lit => test}/Lower/pre-fir-tree01.f90 (100%)
 rename {test-lit => test}/Lower/pre-fir-tree02.f90 (100%)
 rename {test-lit => test}/Lower/pre-fir-tree03.f90 (100%)
 rename {test-lit => test}/Lower/pre-fir-tree04.f90 (100%)
 rename test/Semantics/{ => Inputs}/getdefinition03-b.f90 (100%)
 rename test/Semantics/{ => Inputs}/getsymbols02-a.f90 (83%)
 rename test/Semantics/{ => Inputs}/getsymbols02-b.f90 (86%)
 rename test/Semantics/{ => Inputs}/getsymbols02-c.f90 (70%)
 rename test/Semantics/{ => Inputs}/getsymbols03-b.f90 (100%)
 rename {test-lit => test}/Semantics/Inputs/mod-file-changed.f90 (100%)
 rename {test-lit => test}/Semantics/Inputs/mod-file-unchanged.f90 (100%)
 rename test/Semantics/{ => Inputs}/modfile09-a.f90 (100%)
 rename test/Semantics/{ => Inputs}/modfile09-b.f90 (100%)
 rename test/Semantics/{ => Inputs}/modfile09-c.f90 (100%)
 rename test/Semantics/{ => Inputs}/modfile09-d.f90 (100%)
 create mode 100644 test/Semantics/getsymbols02.f90
 rename {test-lit => test}/Semantics/mod-file-rewriter.f90 (100%)
 create mode 100644 test/Semantics/modfile09.f90

diff --git a/test-lit/Driver/version_test.f90 b/test/Driver/version_test.f90
similarity index 100%
rename from test-lit/Driver/version_test.f90
rename to test/Driver/version_test.f90
diff --git a/test/Evaluate/folding01.f90 b/test/Evaluate/folding01.f90
index 81f59c59a277..8a75a819ff81 100644
--- a/test/Evaluate/folding01.f90
+++ b/test/Evaluate/folding01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 
 ! Test intrinsic operation folding
 
diff --git a/test/Evaluate/folding02.f90 b/test/Evaluate/folding02.f90
index 47c7f6373e4f..b69ff87b5c20 100644
--- a/test/Evaluate/folding02.f90
+++ b/test/Evaluate/folding02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 ! Check intrinsic function folding with host runtime library
 
 module m
diff --git a/test/Evaluate/folding03.f90 b/test/Evaluate/folding03.f90
index 56a6adffb824..c5e26faf8327 100644
--- a/test/Evaluate/folding03.f90
+++ b/test/Evaluate/folding03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 ! Test operation folding edge case (both expected value and messages)
 ! These tests make assumptions regarding real(4) and integer(4) extrema.
 
diff --git a/test/Evaluate/folding04.f90 b/test/Evaluate/folding04.f90
index 3ced207a742c..a0e207b375b7 100644
--- a/test/Evaluate/folding04.f90
+++ b/test/Evaluate/folding04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 ! Test intrinsic function folding edge case (both expected value and messages)
 ! These tests make assumptions regarding real(4) extrema.
 
diff --git a/test/Evaluate/folding05.f90 b/test/Evaluate/folding05.f90
index 5e5e5c576976724256e3c150f56be5df2efaf023..79635e392d7717c1d1a8159c6548e7413f4712ff 100644
GIT binary patch
delta 47
zcmdnx_0UUQQ6VVQ&q_fxSidB-xFkL;KPM$KFI}%VLqWAzK{YKWF)v*~wS;Sfl_~&#
C&JS<^

delta 8
PcmaFpwaaUxx|J#b61D?p

diff --git a/test/Evaluate/folding06.f90 b/test/Evaluate/folding06.f90
index c591989488c3..42dc70d5165e 100644
--- a/test/Evaluate/folding06.f90
+++ b/test/Evaluate/folding06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 ! Test transformational intrinsic function folding
 
 module m
diff --git a/test/Evaluate/folding07.f90 b/test/Evaluate/folding07.f90
index b7e13eb027a3..9c9c0a40ed61 100644
--- a/test/Evaluate/folding07.f90
+++ b/test/Evaluate/folding07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 ! Test numeric model inquiry intrinsics
 
 module m
diff --git a/test/Evaluate/folding08.f90 b/test/Evaluate/folding08.f90
index a5546b9cf2c4..67f435a99f31 100644
--- a/test/Evaluate/folding08.f90
+++ b/test/Evaluate/folding08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 ! Test folding of LBOUND and UBOUND
 
 module m
diff --git a/test/Evaluate/folding09.f90 b/test/Evaluate/folding09.f90
index af89aecf951a..a7510604acca 100644
--- a/test/Evaluate/folding09.f90
+++ b/test/Evaluate/folding09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_folding.sh %s %flang %t
 ! Test folding of IS_CONTIGUOUS on simply contiguous items (9.5.4)
 ! When IS_CONTIGUOUS() is constant, it's .TRUE.
 
diff --git a/test-lit/Fir/fir-ops.fir b/test/Fir/fir-ops.fir
similarity index 100%
rename from test-lit/Fir/fir-ops.fir
rename to test/Fir/fir-ops.fir
diff --git a/test-lit/Fir/fir-types.fir b/test/Fir/fir-types.fir
similarity index 100%
rename from test-lit/Fir/fir-types.fir
rename to test/Fir/fir-types.fir
diff --git a/test-lit/Lower/pre-fir-tree01.f90 b/test/Lower/pre-fir-tree01.f90
similarity index 100%
rename from test-lit/Lower/pre-fir-tree01.f90
rename to test/Lower/pre-fir-tree01.f90
diff --git a/test-lit/Lower/pre-fir-tree02.f90 b/test/Lower/pre-fir-tree02.f90
similarity index 100%
rename from test-lit/Lower/pre-fir-tree02.f90
rename to test/Lower/pre-fir-tree02.f90
diff --git a/test-lit/Lower/pre-fir-tree03.f90 b/test/Lower/pre-fir-tree03.f90
similarity index 100%
rename from test-lit/Lower/pre-fir-tree03.f90
rename to test/Lower/pre-fir-tree03.f90
diff --git a/test-lit/Lower/pre-fir-tree04.f90 b/test/Lower/pre-fir-tree04.f90
similarity index 100%
rename from test-lit/Lower/pre-fir-tree04.f90
rename to test/Lower/pre-fir-tree04.f90
diff --git a/test/Semantics/getdefinition03-b.f90 b/test/Semantics/Inputs/getdefinition03-b.f90
similarity index 100%
rename from test/Semantics/getdefinition03-b.f90
rename to test/Semantics/Inputs/getdefinition03-b.f90
diff --git a/test/Semantics/getsymbols02-a.f90 b/test/Semantics/Inputs/getsymbols02-a.f90
similarity index 83%
rename from test/Semantics/getsymbols02-a.f90
rename to test/Semantics/Inputs/getsymbols02-a.f90
index b9d75fde50af..04786c0bea6d 100644
--- a/test/Semantics/getsymbols02-a.f90
+++ b/test/Semantics/Inputs/getsymbols02-a.f90
@@ -1,4 +1,4 @@
-! RUN: ${F18} -fparse-only %s
+! EXEC: ${F18} -fparse-only %s
 
 module mm2a
 implicit none
diff --git a/test/Semantics/getsymbols02-b.f90 b/test/Semantics/Inputs/getsymbols02-b.f90
similarity index 86%
rename from test/Semantics/getsymbols02-b.f90
rename to test/Semantics/Inputs/getsymbols02-b.f90
index 7ed4cbe0d894..1e6bb8b03a6c 100644
--- a/test/Semantics/getsymbols02-b.f90
+++ b/test/Semantics/Inputs/getsymbols02-b.f90
@@ -1,4 +1,4 @@
-! RUN: ${F18} -fparse-only %s
+! EXEC: ${F18} -fparse-only %s
 
 module mm2b
 use mm2a
diff --git a/test/Semantics/getsymbols02-c.f90 b/test/Semantics/Inputs/getsymbols02-c.f90
similarity index 70%
rename from test/Semantics/getsymbols02-c.f90
rename to test/Semantics/Inputs/getsymbols02-c.f90
index cb66680906bb..52a210b91699 100644
--- a/test/Semantics/getsymbols02-c.f90
+++ b/test/Semantics/Inputs/getsymbols02-c.f90
@@ -7,6 +7,6 @@ PROGRAM helloworld
     i = callget5()
 ENDPROGRAM
 
-! RUN: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
 ! CHECK:callget5: mm2b
 ! CHECK:get5: mm2a
diff --git a/test/Semantics/getsymbols03-b.f90 b/test/Semantics/Inputs/getsymbols03-b.f90
similarity index 100%
rename from test/Semantics/getsymbols03-b.f90
rename to test/Semantics/Inputs/getsymbols03-b.f90
diff --git a/test-lit/Semantics/Inputs/mod-file-changed.f90 b/test/Semantics/Inputs/mod-file-changed.f90
similarity index 100%
rename from test-lit/Semantics/Inputs/mod-file-changed.f90
rename to test/Semantics/Inputs/mod-file-changed.f90
diff --git a/test-lit/Semantics/Inputs/mod-file-unchanged.f90 b/test/Semantics/Inputs/mod-file-unchanged.f90
similarity index 100%
rename from test-lit/Semantics/Inputs/mod-file-unchanged.f90
rename to test/Semantics/Inputs/mod-file-unchanged.f90
diff --git a/test/Semantics/modfile09-a.f90 b/test/Semantics/Inputs/modfile09-a.f90
similarity index 100%
rename from test/Semantics/modfile09-a.f90
rename to test/Semantics/Inputs/modfile09-a.f90
diff --git a/test/Semantics/modfile09-b.f90 b/test/Semantics/Inputs/modfile09-b.f90
similarity index 100%
rename from test/Semantics/modfile09-b.f90
rename to test/Semantics/Inputs/modfile09-b.f90
diff --git a/test/Semantics/modfile09-c.f90 b/test/Semantics/Inputs/modfile09-c.f90
similarity index 100%
rename from test/Semantics/modfile09-c.f90
rename to test/Semantics/Inputs/modfile09-c.f90
diff --git a/test/Semantics/modfile09-d.f90 b/test/Semantics/Inputs/modfile09-d.f90
similarity index 100%
rename from test/Semantics/modfile09-d.f90
rename to test/Semantics/Inputs/modfile09-d.f90
diff --git a/test/Semantics/allocate01.f90 b/test/Semantics/allocate01.f90
index 6944e2b30090..0948230a3ea2 100644
--- a/test/Semantics/allocate01.f90
+++ b/test/Semantics/allocate01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 ! Creating a symbol that allocate should accept
diff --git a/test/Semantics/allocate02.f90 b/test/Semantics/allocate02.f90
index 7f1693849b5f..13a68e811a55 100644
--- a/test/Semantics/allocate02.f90
+++ b/test/Semantics/allocate02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 
 ! Check for semantic errors in ALLOCATE statements
 
diff --git a/test/Semantics/allocate03.f90 b/test/Semantics/allocate03.f90
index f86b44ceca2e..63598f0786df 100644
--- a/test/Semantics/allocate03.f90
+++ b/test/Semantics/allocate03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C933_a(b1, ca3, ca4, cp3, cp3mold, cp4, cp7, cp8, bsrc)
diff --git a/test/Semantics/allocate04.f90 b/test/Semantics/allocate04.f90
index 3b7ce25bf00e..40e7562938df 100644
--- a/test/Semantics/allocate04.f90
+++ b/test/Semantics/allocate04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 
diff --git a/test/Semantics/allocate05.f90 b/test/Semantics/allocate05.f90
index 5d3f2b58160f..84814b674735 100644
--- a/test/Semantics/allocate05.f90
+++ b/test/Semantics/allocate05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 
diff --git a/test/Semantics/allocate06.f90 b/test/Semantics/allocate06.f90
index 606f9cec32fe..1de258ccfb46 100644
--- a/test/Semantics/allocate06.f90
+++ b/test/Semantics/allocate06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 
diff --git a/test/Semantics/allocate07.f90 b/test/Semantics/allocate07.f90
index 3641ae62a3c6..14077a24013e 100644
--- a/test/Semantics/allocate07.f90
+++ b/test/Semantics/allocate07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C936(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
diff --git a/test/Semantics/allocate08.f90 b/test/Semantics/allocate08.f90
index 732ce270a78b..3e235fcc9cdc 100644
--- a/test/Semantics/allocate08.f90
+++ b/test/Semantics/allocate08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C945_a(srca, srcb, srcc, src_complex, src_logical, &
diff --git a/test/Semantics/allocate09.f90 b/test/Semantics/allocate09.f90
index e47cd8134b49..61046fb13ce2 100644
--- a/test/Semantics/allocate09.f90
+++ b/test/Semantics/allocate09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C946(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
diff --git a/test/Semantics/allocate10.f90 b/test/Semantics/allocate10.f90
index b3e5d77da315..c15dc57b4472 100644
--- a/test/Semantics/allocate10.f90
+++ b/test/Semantics/allocate10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 !TODO: mixing expr and source-expr?
diff --git a/test/Semantics/allocate11.f90 b/test/Semantics/allocate11.f90
index 45128ac8d69d..b883edc4980a 100644
--- a/test/Semantics/allocate11.f90
+++ b/test/Semantics/allocate11.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 ! TODO: Function Pointer in allocate and derived types!
diff --git a/test/Semantics/allocate12.f90 b/test/Semantics/allocate12.f90
index 8e46b6ddf3d0..41de8edc83ed 100644
--- a/test/Semantics/allocate12.f90
+++ b/test/Semantics/allocate12.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C941_C942b_C950(xsrc, x1, a2, b2, cx1, ca2, cb1, cb2, c1)
diff --git a/test/Semantics/allocate13.f90 b/test/Semantics/allocate13.f90
index 5e01c3853748..b7010f5b0c89 100644
--- a/test/Semantics/allocate13.f90
+++ b/test/Semantics/allocate13.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 module not_iso_fortran_env
diff --git a/test/Semantics/altreturn01.f90 b/test/Semantics/altreturn01.f90
index b227d15b4ba1..0449ff774c36 100644
--- a/test/Semantics/altreturn01.f90
+++ b/test/Semantics/altreturn01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check calls with alt returns
 
        CALL TEST (N, *100, *200 )
diff --git a/test/Semantics/altreturn02.f90 b/test/Semantics/altreturn02.f90
index ab59a3246588..74ff96933a83 100644
--- a/test/Semantics/altreturn02.f90
+++ b/test/Semantics/altreturn02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check subroutine with alt return
 
        SUBROUTINE TEST (N, *, *)
diff --git a/test/Semantics/altreturn03.f90 b/test/Semantics/altreturn03.f90
index 15410e716752..73a63860efc7 100644
--- a/test/Semantics/altreturn03.f90
+++ b/test/Semantics/altreturn03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for various alt return error conditions
 
        SUBROUTINE TEST (N, *, *)
diff --git a/test/Semantics/altreturn04.f90 b/test/Semantics/altreturn04.f90
index 5e930c781c2b..e3714fb92223 100644
--- a/test/Semantics/altreturn04.f90
+++ b/test/Semantics/altreturn04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Functions cannot use alt return
 
 REAL FUNCTION altreturn01(X)
diff --git a/test/Semantics/altreturn05.f90 b/test/Semantics/altreturn05.f90
index 6669942d00cc..cbd222cba9e7 100644
--- a/test/Semantics/altreturn05.f90
+++ b/test/Semantics/altreturn05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test extension: RETURN from main program
 
 return !ok
diff --git a/test/Semantics/assign01.f90 b/test/Semantics/assign01.f90
index b125da87ad22..bd41a5b5cc9f 100644
--- a/test/Semantics/assign01.f90
+++ b/test/Semantics/assign01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! 10.2.3.1(2) All masks and LHS of assignments in a WHERE must conform
 
 subroutine s1
diff --git a/test/Semantics/assign02.f90 b/test/Semantics/assign02.f90
index 5b3fa4f6da2b..e97be64d6aab 100644
--- a/test/Semantics/assign02.f90
+++ b/test/Semantics/assign02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Pointer assignment constraints 10.2.2.2
 
 module m1
diff --git a/test/Semantics/assign03.f90 b/test/Semantics/assign03.f90
index 6127de22de4f..5b9fe269addc 100644
--- a/test/Semantics/assign03.f90
+++ b/test/Semantics/assign03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Pointer assignment constraints 10.2.2.2 (see also assign02.f90)
 
 module m
diff --git a/test/Semantics/assign04.f90 b/test/Semantics/assign04.f90
index b4214a4766f2..f8798138c15c 100644
--- a/test/Semantics/assign04.f90
+++ b/test/Semantics/assign04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! 9.4.5
 subroutine s1
   type :: t(k, l)
diff --git a/test/Semantics/bad-forward-type.f90 b/test/Semantics/bad-forward-type.f90
index a8f7a4c64af6..62ad9d4b2b4c 100644
--- a/test/Semantics/bad-forward-type.f90
+++ b/test/Semantics/bad-forward-type.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Forward references to derived types (error cases)
 
 !ERROR: The derived type 'undef' was forward-referenced but not defined
diff --git a/test/Semantics/bindings01.f90 b/test/Semantics/bindings01.f90
index 72cab0832388..54aaacd2e9f8 100644
--- a/test/Semantics/bindings01.f90
+++ b/test/Semantics/bindings01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Confirm enforcement of constraints and restrictions in 7.5.7.3
 ! and C779-C785.
 
diff --git a/test/Semantics/block-data01.f90 b/test/Semantics/block-data01.f90
index 5abd0999c010..164709118f6f 100644
--- a/test/Semantics/block-data01.f90
+++ b/test/Semantics/block-data01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test BLOCK DATA subprogram (14.3)
 block data foo
   !ERROR: IMPORT is not allowed in a BLOCK DATA subprogram
diff --git a/test/Semantics/blockconstruct01.f90 b/test/Semantics/blockconstruct01.f90
index 727e6ab05eeb..7f7eec5b56c3 100644
--- a/test/Semantics/blockconstruct01.f90
+++ b/test/Semantics/blockconstruct01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1107 -- COMMON, EQUIVALENCE, INTENT, NAMELIST, OPTIONAL, VALUE or
 !          STATEMENT FUNCTIONS not allow in specification part
 
diff --git a/test/Semantics/blockconstruct02.f90 b/test/Semantics/blockconstruct02.f90
index eb7203052fcf..2a1a95f312bf 100644
--- a/test/Semantics/blockconstruct02.f90
+++ b/test/Semantics/blockconstruct02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1108  --  Save statement in a BLOCK construct shall not conatin a
 !            saved-entity-list that does not specify a common-block-name
 
diff --git a/test/Semantics/blockconstruct03.f90 b/test/Semantics/blockconstruct03.f90
index cb016bb8080f..df5aff7699ea 100644
--- a/test/Semantics/blockconstruct03.f90
+++ b/test/Semantics/blockconstruct03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Tests implemented for this standard:
 !            Block Construct
 ! C1109
diff --git a/test/Semantics/c_f_pointer.f90 b/test/Semantics/c_f_pointer.f90
index 2f48574717b4..1064461c509d 100644
--- a/test/Semantics/c_f_pointer.f90
+++ b/test/Semantics/c_f_pointer.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Enforce 18.2.3.3
 
 program test
diff --git a/test/Semantics/call01.f90 b/test/Semantics/call01.f90
index d38fc904cfeb..88274dd42844 100644
--- a/test/Semantics/call01.f90
+++ b/test/Semantics/call01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Confirm enforcement of constraints and restrictions in 15.6.2.1
 
 non_recursive function f01(n) result(res)
diff --git a/test/Semantics/call02.f90 b/test/Semantics/call02.f90
index f60eabfd8e1e..2d23274da1b0 100644
--- a/test/Semantics/call02.f90
+++ b/test/Semantics/call02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! 15.5.1 procedure reference constraints and restrictions
 
 subroutine s01(elem, subr)
diff --git a/test/Semantics/call03.f90 b/test/Semantics/call03.f90
index c994b9fa8519..098106aed45e 100644
--- a/test/Semantics/call03.f90
+++ b/test/Semantics/call03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.5.2.4 constraints and restrictions for non-POINTER non-ALLOCATABLE
 ! dummy arguments.
 
diff --git a/test/Semantics/call04.f90 b/test/Semantics/call04.f90
index a3e727a770c8..3064fee5decc 100644
--- a/test/Semantics/call04.f90
+++ b/test/Semantics/call04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 8.5.10 & 8.5.18 constraints on dummy argument declarations
 
 module m
diff --git a/test/Semantics/call05.f90 b/test/Semantics/call05.f90
index 368ec59b33b8..80f1874ff2d5 100644
--- a/test/Semantics/call05.f90
+++ b/test/Semantics/call05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.5.2.5 constraints and restrictions for POINTER & ALLOCATABLE
 ! arguments when both sides of the call have the same attributes.
 
diff --git a/test/Semantics/call06.f90 b/test/Semantics/call06.f90
index d9c8a0beee72..eb4bd3755f87 100644
--- a/test/Semantics/call06.f90
+++ b/test/Semantics/call06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.5.2.6 constraints and restrictions for ALLOCATABLE
 ! dummy arguments.
 
diff --git a/test/Semantics/call07.f90 b/test/Semantics/call07.f90
index bd44e43b552c..f596e3600288 100644
--- a/test/Semantics/call07.f90
+++ b/test/Semantics/call07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.5.2.7 constraints and restrictions for POINTER dummy arguments.
 
 module m
diff --git a/test/Semantics/call08.f90 b/test/Semantics/call08.f90
index 7fe42e7bd7ef..88ec7e3b4cca 100644
--- a/test/Semantics/call08.f90
+++ b/test/Semantics/call08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.5.2.8 coarray dummy arguments
 
 module m
diff --git a/test/Semantics/call09.f90 b/test/Semantics/call09.f90
index 06c304af4101..e27c78e4281f 100644
--- a/test/Semantics/call09.f90
+++ b/test/Semantics/call09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.5.2.9(2,3,5) dummy procedure requirements
 
 module m
diff --git a/test/Semantics/call10.f90 b/test/Semantics/call10.f90
index 00db9cd7319c..52983c9f18a0 100644
--- a/test/Semantics/call10.f90
+++ b/test/Semantics/call10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.7 (C1583-C1590, C1592-C1599) constraints and restrictions
 ! for pure procedures.
 ! (C1591 is tested in call11.f90; C1594 in call12.f90.)
diff --git a/test/Semantics/call11.f90 b/test/Semantics/call11.f90
index 254566fa38b8..b53b40334e93 100644
--- a/test/Semantics/call11.f90
+++ b/test/Semantics/call11.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.7 C1591 & others: contexts requiring pure subprograms
 
 module m
diff --git a/test/Semantics/call12.f90 b/test/Semantics/call12.f90
index ebcaab6fb903..3ce0812560ac 100644
--- a/test/Semantics/call12.f90
+++ b/test/Semantics/call12.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.7 C1594 - prohibited assignments in pure subprograms
 
 module used
diff --git a/test/Semantics/call13.f90 b/test/Semantics/call13.f90
index 798de8fbf2d9..952a7d0c8b1d 100644
--- a/test/Semantics/call13.f90
+++ b/test/Semantics/call13.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 15.4.2.2 constraints and restrictions for calls to implicit
 ! interfaces
 
diff --git a/test/Semantics/call14.f90 b/test/Semantics/call14.f90
index d6e94be51996..e25620b2694b 100644
--- a/test/Semantics/call14.f90
+++ b/test/Semantics/call14.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test 8.5.18 constraints on the VALUE attribute
 
 module m
diff --git a/test/Semantics/call15.f90 b/test/Semantics/call15.f90
index ca935b91530f..08886e4e7c6d 100644
--- a/test/Semantics/call15.f90
+++ b/test/Semantics/call15.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C711 An assumed-type actual argument that corresponds to an assumed-rank 
 ! dummy argument shall be assumed-shape or assumed-rank.
 subroutine s(arg1, arg2, arg3)
diff --git a/test/Semantics/canondo01.f90 b/test/Semantics/canondo01.f90
index 46c82cba9c1d..51060f8a5f1d 100644
--- a/test/Semantics/canondo01.f90
+++ b/test/Semantics/canondo01.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: end do
 
 SUBROUTINE sub00(a,b,n,m)
diff --git a/test/Semantics/canondo02.f90 b/test/Semantics/canondo02.f90
index 0389df4d52c8..62dbd4b0a024 100644
--- a/test/Semantics/canondo02.f90
+++ b/test/Semantics/canondo02.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: end do
 
 SUBROUTINE sub00(a,b,n,m)
diff --git a/test/Semantics/canondo03.f90 b/test/Semantics/canondo03.f90
index f72b1ffd0180..4be30775221e 100644
--- a/test/Semantics/canondo03.f90
+++ b/test/Semantics/canondo03.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: 10 continue
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo04.f90 b/test/Semantics/canondo04.f90
index 763d62674084..452d77d0559e 100644
--- a/test/Semantics/canondo04.f90
+++ b/test/Semantics/canondo04.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK-NOT: do [1-9]
 
 ! Figure out how to also execute this test.
diff --git a/test/Semantics/canondo05.f90 b/test/Semantics/canondo05.f90
index f676eff82219..4550e9849fc4 100644
--- a/test/Semantics/canondo05.f90
+++ b/test/Semantics/canondo05.f90
@@ -1,5 +1,6 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
-! XXXRUN: ${F18} -fopenmp -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! XXXEXEC: ${F18} -fopenmp -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK-NOT: do *[1-9]
 
 program P
diff --git a/test/Semantics/canondo06.f90 b/test/Semantics/canondo06.f90
index 1e7235b9dc47..0aea3daed4f9 100644
--- a/test/Semantics/canondo06.f90
+++ b/test/Semantics/canondo06.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -fopenmp -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -fopenmp -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK-NOT: do *[1-9]
 ! CHECK: omp simd
 
diff --git a/test/Semantics/canondo07.f90 b/test/Semantics/canondo07.f90
index 59a524275efb..f5a0feef93d0 100644
--- a/test/Semantics/canondo07.f90
+++ b/test/Semantics/canondo07.f90
@@ -1,7 +1,8 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1131
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 ! CHECK: A DO loop should terminate with an END DO or CONTINUE
 
 program endDo
diff --git a/test/Semantics/canondo08.f90 b/test/Semantics/canondo08.f90
index 7e5c158692b1..c5bfb56f1288 100644
--- a/test/Semantics/canondo08.f90
+++ b/test/Semantics/canondo08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
@@ -5,7 +6,7 @@
 ! A warning is generated with -Mstandard
 
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo09.f90 b/test/Semantics/canondo09.f90
index 98c422124c21..99956a03fe3d 100644
--- a/test/Semantics/canondo09.f90
+++ b/test/Semantics/canondo09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
@@ -5,7 +6,7 @@
 ! A warning is generated with -Mstandard
 
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo10.f90 b/test/Semantics/canondo10.f90
index 0827be6de97f..93d060dd9aaa 100644
--- a/test/Semantics/canondo10.f90
+++ b/test/Semantics/canondo10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
@@ -5,7 +6,7 @@
 ! A warning is generated with -Mstandard
 
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo11.f90 b/test/Semantics/canondo11.f90
index 9019f34ae09f..8e98a24bb87f 100644
--- a/test/Semantics/canondo11.f90
+++ b/test/Semantics/canondo11.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
@@ -5,7 +6,7 @@
 ! A warning is generated with -Mstandard
 
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo12.f90 b/test/Semantics/canondo12.f90
index 1809afaedac1..48fde32faf99 100644
--- a/test/Semantics/canondo12.f90
+++ b/test/Semantics/canondo12.f90
@@ -1,10 +1,11 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo13.f90 b/test/Semantics/canondo13.f90
index 09a3e4c13fd7..b317d7963aa3 100644
--- a/test/Semantics/canondo13.f90
+++ b/test/Semantics/canondo13.f90
@@ -1,10 +1,11 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo14.f90 b/test/Semantics/canondo14.f90
index f6d422ab7436..69bd748212be 100644
--- a/test/Semantics/canondo14.f90
+++ b/test/Semantics/canondo14.f90
@@ -1,10 +1,11 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo15.f90 b/test/Semantics/canondo15.f90
index 2726cd914aa6..f58959898345 100644
--- a/test/Semantics/canondo15.f90
+++ b/test/Semantics/canondo15.f90
@@ -1,10 +1,11 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo16.f90 b/test/Semantics/canondo16.f90
index e1819c00049e..d5c5db464930 100644
--- a/test/Semantics/canondo16.f90
+++ b/test/Semantics/canondo16.f90
@@ -1,10 +1,11 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard -I../../tools/f18/include %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard -I../../tools/f18/include %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo17.f90 b/test/Semantics/canondo17.f90
index e9194b0fd592..a687fb2fefac 100644
--- a/test/Semantics/canondo17.f90
+++ b/test/Semantics/canondo17.f90
@@ -1,10 +1,11 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo18.f90 b/test/Semantics/canondo18.f90
index 6760d20622db..3e3f18b05174 100644
--- a/test/Semantics/canondo18.f90
+++ b/test/Semantics/canondo18.f90
@@ -1,10 +1,11 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/canondo19.f90 b/test/Semantics/canondo19.f90
index 35da0076422b..82bad39e950f 100644
--- a/test/Semantics/canondo19.f90
+++ b/test/Semantics/canondo19.f90
@@ -1,7 +1,8 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Check that if there is a label or a name on an label-do-stmt,
 ! then it is not lost when rewriting it to an non-label-do-stmt.
 
-! RUN: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 ! CHECK: 2 do
diff --git a/test/Semantics/coarrays01.f90 b/test/Semantics/coarrays01.f90
index 491ebb22cbd8..3e8e1672a47b 100644
--- a/test/Semantics/coarrays01.f90
+++ b/test/Semantics/coarrays01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test selector and team-value in CHANGE TEAM statement
 
 ! OK
diff --git a/test/Semantics/complex01.f90 b/test/Semantics/complex01.f90
index 4fb46ba56b71..c70f0defad6a 100644
--- a/test/Semantics/complex01.f90
+++ b/test/Semantics/complex01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C718 Each named constant in a complex literal constant shall be of type 
 ! integer or real.
 subroutine s()
diff --git a/test/Semantics/computed-goto01.f90 b/test/Semantics/computed-goto01.f90
index f16838e9ca78..9f24996f41a0 100644
--- a/test/Semantics/computed-goto01.f90
+++ b/test/Semantics/computed-goto01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check that a basic computed goto compiles
 
 INTEGER, DIMENSION (2) :: B
diff --git a/test/Semantics/computed-goto02.f90 b/test/Semantics/computed-goto02.f90
index 7c40c65ec6b0..eea61a827052 100644
--- a/test/Semantics/computed-goto02.f90
+++ b/test/Semantics/computed-goto02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check that computed goto express must be a scalar integer expression
 ! TODO: PGI, for example, accepts a float & converts the value to int.
 
diff --git a/test/Semantics/critical01.f90 b/test/Semantics/critical01.f90
index 89d3337ba536..5ca97ade6998 100644
--- a/test/Semantics/critical01.f90
+++ b/test/Semantics/critical01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !C1117
 
 subroutine test1(a, i)
diff --git a/test/Semantics/critical02.f90 b/test/Semantics/critical02.f90
index 2c75ac2ab33e..ba5e0f4c55a7 100644
--- a/test/Semantics/critical02.f90
+++ b/test/Semantics/critical02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !C1118
 
 subroutine test1
diff --git a/test/Semantics/critical03.f90 b/test/Semantics/critical03.f90
index 6bf45531a170..2ab60e5d59a9 100644
--- a/test/Semantics/critical03.f90
+++ b/test/Semantics/critical03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !C1119
 
 subroutine test1(a, i)
diff --git a/test/Semantics/critical04.f90 b/test/Semantics/critical04.f90
index 3b5f7e8e1383..136e31baa621 100644
--- a/test/Semantics/critical04.f90
+++ b/test/Semantics/critical04.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK-NOT: Control flow escapes from CRITICAL
 
 subroutine test1(a, i)
diff --git a/test/Semantics/data01.f90 b/test/Semantics/data01.f90
index c8af31a50d07..4bdf7ea9dd4a 100644
--- a/test/Semantics/data01.f90
+++ b/test/Semantics/data01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !Test for checking data constraints, C882-C887
 module m1
   type person
diff --git a/test/Semantics/data02.f90 b/test/Semantics/data02.f90
index 4cd593697b23..ac6902622d83 100644
--- a/test/Semantics/data02.f90
+++ b/test/Semantics/data02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check that expressions are analyzed in data statements
 
 subroutine s1
diff --git a/test/Semantics/deallocate01.f90 b/test/Semantics/deallocate01.f90
index 2bb4236c3b82..8aaf14496d71 100644
--- a/test/Semantics/deallocate01.f90
+++ b/test/Semantics/deallocate01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test that DEALLOCATE works
 
 INTEGER, PARAMETER :: maxvalue=1024
diff --git a/test/Semantics/deallocate04.f90 b/test/Semantics/deallocate04.f90
index 7183e2d3ecb8..2a1ad62b9920 100644
--- a/test/Semantics/deallocate04.f90
+++ b/test/Semantics/deallocate04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for type errors in DEALLOCATE statements
 
 INTEGER, PARAMETER :: maxvalue=1024
diff --git a/test/Semantics/deallocate05.f90 b/test/Semantics/deallocate05.f90
index 765753ac0c64..fdc66004e2ce 100644
--- a/test/Semantics/deallocate05.f90
+++ b/test/Semantics/deallocate05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in DEALLOCATE statements
 
 Module share
diff --git a/test/Semantics/doconcurrent01.f90 b/test/Semantics/doconcurrent01.f90
index bba111ad25c2..a4161a5c3073 100644
--- a/test/Semantics/doconcurrent01.f90
+++ b/test/Semantics/doconcurrent01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1141
 ! A reference to the procedure IEEE_SET_HALTING_MODE ! from the intrinsic 
 ! module IEEE_EXCEPTIONS, shall not ! appear within a DO CONCURRENT construct.
diff --git a/test/Semantics/doconcurrent02.f90 b/test/Semantics/doconcurrent02.f90
index c09977d23228..db120b62bc45 100644
--- a/test/Semantics/doconcurrent02.f90
+++ b/test/Semantics/doconcurrent02.f90
@@ -1,7 +1,8 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative tests: we don't want DO CONCURRENT semantics constraints checked
 ! when the loops are not DO CONCURRENT
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK-NOT: image control statement not allowed in DO CONCURRENT
 ! CHECK-NOT: RETURN not allowed in DO CONCURRENT
 ! CHECK-NOT: call to impure procedure in DO CONCURRENT not allowed
diff --git a/test/Semantics/doconcurrent03.f90 b/test/Semantics/doconcurrent03.f90
index ffaca88b9906..cfefd92cc3b0 100644
--- a/test/Semantics/doconcurrent03.f90
+++ b/test/Semantics/doconcurrent03.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: Control flow escapes from DO CONCURRENT
 ! CHECK: branch into loop body from outside
 ! CHECK: the loop branched into
diff --git a/test/Semantics/doconcurrent04.f90 b/test/Semantics/doconcurrent04.f90
index 8182477020f0..51ec5737a154 100644
--- a/test/Semantics/doconcurrent04.f90
+++ b/test/Semantics/doconcurrent04.f90
@@ -1,5 +1,6 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! C1122 The index-name shall be a named scalar variable of type integer.
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: Must have INTEGER type, but is REAL\\(4\\)
 
 subroutine do_concurrent_test1(n)
diff --git a/test/Semantics/doconcurrent05.f90 b/test/Semantics/doconcurrent05.f90
index 8c46192e915e..d92ef6d18322 100644
--- a/test/Semantics/doconcurrent05.f90
+++ b/test/Semantics/doconcurrent05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1167 -- An exit-stmt shall not appear within a DO CONCURRENT construct if 
 ! it belongs to that construct or an outer construct.
 
diff --git a/test/Semantics/doconcurrent06.f90 b/test/Semantics/doconcurrent06.f90
index 2f181fe9de6b..f178b7a11640 100644
--- a/test/Semantics/doconcurrent06.f90
+++ b/test/Semantics/doconcurrent06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1167 -- An exit-stmt shall not appear within a DO CONCURRENT construct if 
 ! it belongs to that construct or an outer construct.
 
diff --git a/test/Semantics/doconcurrent07.f90 b/test/Semantics/doconcurrent07.f90
index 5cc70c00896a..661d51a71be5 100644
--- a/test/Semantics/doconcurrent07.f90
+++ b/test/Semantics/doconcurrent07.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK-NOT: exit from DO CONCURRENT construct
 
 subroutine do_concurrent_test1(n)
diff --git a/test/Semantics/doconcurrent08.f90 b/test/Semantics/doconcurrent08.f90
index f6773995e202..91a077fade49 100644
--- a/test/Semantics/doconcurrent08.f90
+++ b/test/Semantics/doconcurrent08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1140 -- A statement that might result in the deallocation of a polymorphic 
 ! entity shall not appear within a DO CONCURRENT construct.
 module m1
diff --git a/test/Semantics/dosemantics01.f90 b/test/Semantics/dosemantics01.f90
index 6745f1f2740e..2261f184e3cc 100644
--- a/test/Semantics/dosemantics01.f90
+++ b/test/Semantics/dosemantics01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1131 -- check valid and invalid DO loop naming
 
 PROGRAM C1131
diff --git a/test/Semantics/dosemantics02.f90 b/test/Semantics/dosemantics02.f90
index 0b3165a88270..96047f0a3678 100644
--- a/test/Semantics/dosemantics02.f90
+++ b/test/Semantics/dosemantics02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1121 -- any procedure referenced in a concurrent header must be pure
 
 ! Also, check that the step expressions are not zero.  This is prohibited by
diff --git a/test/Semantics/dosemantics03.f90 b/test/Semantics/dosemantics03.f90
index 4792ae6572de..c063a7b8c854 100644
--- a/test/Semantics/dosemantics03.f90
+++ b/test/Semantics/dosemantics03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Issue 458 -- semantic checks for a normal DO loop.  The DO variable
 ! and the initial, final, and step expressions must be INTEGER if the
 ! options for standard conformance and turning warnings into errors
diff --git a/test/Semantics/dosemantics04.f90 b/test/Semantics/dosemantics04.f90
index 7c0743517f17..35a3c9493ca2 100644
--- a/test/Semantics/dosemantics04.f90
+++ b/test/Semantics/dosemantics04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1123 -- Expressions in DO CONCURRENT header cannot reference variables
 ! declared in the same header
 PROGRAM dosemantics04
diff --git a/test/Semantics/dosemantics05.f90 b/test/Semantics/dosemantics05.f90
index c7e27d53aec4..f565f9b71679 100644
--- a/test/Semantics/dosemantics05.f90
+++ b/test/Semantics/dosemantics05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test DO loop semantics for constraint C1130 --
 ! The constraint states that "If the locality-spec DEFAULT ( NONE ) appears in a
 ! DO CONCURRENT statement; a variable that is a local or construct entity of a
diff --git a/test/Semantics/dosemantics06.f90 b/test/Semantics/dosemantics06.f90
index fd5b0a86bab8..41b9598970b5 100644
--- a/test/Semantics/dosemantics06.f90
+++ b/test/Semantics/dosemantics06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1131, C1133 -- check valid and invalid DO loop naming
 ! C1131 (R1119) If the do-stmt of a do-construct specifies a do-construct-name,
 ! the corresponding end-do shall be an end-do-stmt specifying the same
diff --git a/test/Semantics/dosemantics07.f90 b/test/Semantics/dosemantics07.f90
index 9b871fd6f3e4..f1450dda31eb 100644
--- a/test/Semantics/dosemantics07.f90
+++ b/test/Semantics/dosemantics07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !C1132
 ! If the do-stmt is a nonlabel-do-stmt, the corresponding end-do shall be an
 ! end-do-stmt.
diff --git a/test/Semantics/dosemantics08.f90 b/test/Semantics/dosemantics08.f90
index e6e313372ff8..388fb75254f8 100644
--- a/test/Semantics/dosemantics08.f90
+++ b/test/Semantics/dosemantics08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1138 -- 
 ! A branch (11.2) within a DO CONCURRENT construct shall not have a branch
 ! target that is outside the construct.
diff --git a/test/Semantics/dosemantics09.f90 b/test/Semantics/dosemantics09.f90
index 425e71e3db54..46136f29c74e 100644
--- a/test/Semantics/dosemantics09.f90
+++ b/test/Semantics/dosemantics09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !C1129 
 !A variable that is referenced by the scalar-mask-expr of a
 !concurrent-header or by any concurrent-limit or concurrent-step in that
diff --git a/test/Semantics/dosemantics10.f90 b/test/Semantics/dosemantics10.f90
index 7bd7bbbb7c85..561f9b7fb7ea 100644
--- a/test/Semantics/dosemantics10.f90
+++ b/test/Semantics/dosemantics10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1134 A CYCLE statement must be within a DO construct
 !
 ! C1166 An EXIT statement must be within a DO construct
diff --git a/test/Semantics/dosemantics11.f90 b/test/Semantics/dosemantics11.f90
index 50d69608215c..760f9f5f9b60 100644
--- a/test/Semantics/dosemantics11.f90
+++ b/test/Semantics/dosemantics11.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1135 A cycle-stmt shall not appear within a CHANGE TEAM, CRITICAL, or DO 
 ! CONCURRENT construct if it belongs to an outer construct.
 !
diff --git a/test/Semantics/dosemantics12.f90 b/test/Semantics/dosemantics12.f90
index b1ee8a02707d..48ecd14feda5 100644
--- a/test/Semantics/dosemantics12.f90
+++ b/test/Semantics/dosemantics12.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
 !
 ! Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/test/Semantics/equivalence01.f90 b/test/Semantics/equivalence01.f90
index a6e70e6ab53f..31b561e33b0d 100644
--- a/test/Semantics/equivalence01.f90
+++ b/test/Semantics/equivalence01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   integer i, j
   real r(2)
diff --git a/test/Semantics/expr-errors01.f90 b/test/Semantics/expr-errors01.f90
index 378bd2d2368e..a479e863dcaf 100644
--- a/test/Semantics/expr-errors01.f90
+++ b/test/Semantics/expr-errors01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1003 - can't parenthesize function call returning procedure pointer
 module m1
   type :: dt
diff --git a/test/Semantics/expr-errors02.f90 b/test/Semantics/expr-errors02.f90
index 2df05a2cd523..d1aac68bf008 100644
--- a/test/Semantics/expr-errors02.f90
+++ b/test/Semantics/expr-errors02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test specification expressions
 
 module m
diff --git a/test/Semantics/forall01.f90 b/test/Semantics/forall01.f90
index e90a17f62978..ecb243bc2a09 100644
--- a/test/Semantics/forall01.f90
+++ b/test/Semantics/forall01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine forall1
   real :: a(9)
   !ERROR: 'i' is already declared in this scoping unit
diff --git a/test/Semantics/getdefinition01.f90 b/test/Semantics/getdefinition01.f90
index 880e282bca9f..4a2fdd760568 100644
--- a/test/Semantics/getdefinition01.f90
+++ b/test/Semantics/getdefinition01.f90
@@ -1,5 +1,5 @@
+!RUN: %S/test_any.sh %s %flang %t
 ! Tests -fget-definition returning source position of symbol definition.
-
 module m1
  private :: f
 contains
@@ -16,12 +16,12 @@ recursive pure function f() result(x)
  end function
 end module
 
-! RUN: echo %t 1>&2;
-! RUN: ${F18} -fget-definition 7 17 18 -fparse-only %s > %t;
-! RUN: ${F18} -fget-definition 8 20 23 -fparse-only %s >> %t;
-! RUN: ${F18} -fget-definition 15 3 4 -fparse-only %s >> %t;
-! RUN: ${F18} -fget-definition -fparse-only %s >> %t 2>&1;
-! RUN: cat %t | ${FileCheck} %s
+! EXEC: echo %t 1>&2;
+! EXEC: ${F18} -fget-definition 7 17 18 -fparse-only %s > %t;
+! EXEC: ${F18} -fget-definition 8 20 23 -fparse-only %s >> %t;
+! EXEC: ${F18} -fget-definition 15 3 4 -fparse-only %s >> %t;
+! EXEC: ${F18} -fget-definition -fparse-only %s >> %t 2>&1;
+! EXEC: cat %t | ${FileCheck} %s
 ! CHECK:x:.*getdefinition01.f90, 6, 21-22
 ! CHECK:yyy:.*getdefinition01.f90, 6, 24-27
 ! CHECK:x:.*getdefinition01.f90, 14, 24-25
diff --git a/test/Semantics/getdefinition02.f b/test/Semantics/getdefinition02.f
index 3f8ac46a1380..58391a27d530 100644
--- a/test/Semantics/getdefinition02.f
+++ b/test/Semantics/getdefinition02.f
@@ -1,5 +1,5 @@
+!RUN: %S/test_any.sh %s %flang %t
 ! Tests -fget-definition with fixed form.
-
       module m2
        private :: f
       contains
@@ -17,10 +17,10 @@ recursive pure function f() result(x)
        end function
       end module
 
-! RUN: ${F18} -fget-definition 8 9 10 -fparse-only %s > %t;
-! RUN: ${F18} -fget-definition 9 26 29 -fparse-only %s >> %t;
-! RUN: ${F18} -fget-definition 16 9 10 -fparse-only %s >> %t;
-! RUN: cat %t | ${FileCheck} %s
+! EXEC: ${F18} -fget-definition 8 9 10 -fparse-only %s > %t;
+! EXEC: ${F18} -fget-definition 9 26 29 -fparse-only %s >> %t;
+! EXEC: ${F18} -fget-definition 16 9 10 -fparse-only %s >> %t;
+! EXEC: cat %t | ${FileCheck} %s
 ! CHECK:x:.*getdefinition02.f, 6, 27-28
 ! CHECK:yyy:.*getdefinition02.f, 6, 30-33
 ! CHECK:x:.*getdefinition02.f, 15, 30-31
diff --git a/test/Semantics/getdefinition03-a.f90 b/test/Semantics/getdefinition03-a.f90
index 5b287d28665c..81ad276ec29a 100644
--- a/test/Semantics/getdefinition03-a.f90
+++ b/test/Semantics/getdefinition03-a.f90
@@ -1,6 +1,6 @@
 ! Tests -fget-definition with INCLUDE
-
-INCLUDE "getdefinition03-b.f90"
+!RUN: %S/test_any.sh %s %flang %t
+INCLUDE "Inputs/getdefinition03-b.f90"
 
 program main
  use m3
@@ -8,8 +8,8 @@ program main
  x = f
 end program
 
-! RUN: ${F18} -fget-definition 8 6 7 -fparse-only %s > %t;
-! RUN: ${F18} -fget-definition 8 2 3 -fparse-only %s >> %t;
-! RUN: cat %t | ${FileCheck} %s;
+! EXEC: ${F18} -fget-definition 8 6 7 -fparse-only %s > %t;
+! EXEC: ${F18} -fget-definition 8 2 3 -fparse-only %s >> %t;
+! EXEC: cat %t | ${FileCheck} %s;
 ! CHECK:f:.*getdefinition03-b.f90, 2, 12-13
 ! CHECK:x:.*getdefinition03-a.f90, 7, 13-14
diff --git a/test/Semantics/getdefinition04.f90 b/test/Semantics/getdefinition04.f90
index 80ace6544386..aa143a161852 100644
--- a/test/Semantics/getdefinition04.f90
+++ b/test/Semantics/getdefinition04.f90
@@ -1,5 +1,5 @@
+!RUN: %S/test_any.sh %s %flang %t
 ! Tests -fget-definition with COMMON block with same name as variable.
-
 program main
   integer :: x
   integer :: y
@@ -7,5 +7,5 @@ program main
   x = y
 end program
 
-! RUN: ${F18} -fget-definition 7 3 4 -fparse-only %s | ${FileCheck} %s
+! EXEC: ${F18} -fget-definition 7 3 4 -fparse-only %s | ${FileCheck} %s
 ! CHECK:x:.*getdefinition04.f90, 4, 14-15
diff --git a/test/Semantics/getdefinition05.f90 b/test/Semantics/getdefinition05.f90
index 3ad69778ead0..e1115a245611 100644
--- a/test/Semantics/getdefinition05.f90
+++ b/test/Semantics/getdefinition05.f90
@@ -1,6 +1,6 @@
+!RUN: %S/test_any.sh %s %flang %t
 ! Tests -fget-symbols-sources with BLOCK that contains same variable name as 
 ! another in an outer scope.
-
 program main
   integer :: x
   integer :: y
@@ -13,9 +13,9 @@ program main
 end program
 
 !! Inner x
-! RUN: ${F18} -fget-definition 10 5 6 -fparse-only %s > %t;
+! EXEC: ${F18} -fget-definition 10 5 6 -fparse-only %s > %t;
 ! CHECK:x:.*getdefinition05.f90, 8, 16-17
 !! Outer y
-! RUN: ${F18} -fget-definition 12 7 8 -fparse-only %s >> %t;
+! EXEC: ${F18} -fget-definition 12 7 8 -fparse-only %s >> %t;
 ! CHECK:y:.*getdefinition05.f90, 6, 14-15
-! RUN: cat %t | ${FileCheck} %s;
+! EXEC: cat %t | ${FileCheck} %s;
diff --git a/test/Semantics/getsymbols01.f90 b/test/Semantics/getsymbols01.f90
index 9f754f9374d0..d102807ed482 100644
--- a/test/Semantics/getsymbols01.f90
+++ b/test/Semantics/getsymbols01.f90
@@ -1,5 +1,5 @@
+!RUN: %S/test_any.sh %s %flang %t
 ! Tests -fget-symbols-sources finding all symbols in file.
-
 module mm1
  private :: f
 contains
@@ -16,7 +16,7 @@ recursive pure function f() result(x)
  end function
 end module
 
-! RUN: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
 ! CHECK-ONCE:mm1:.*getsymbols01.f90, 3, 8-11
 ! CHECK-ONCE:f:.*getsymbols01.f90, 13, 26-27
 ! CHECK-ONCE:s:.*getsymbols01.f90, 6, 18-19
diff --git a/test/Semantics/getsymbols02.f90 b/test/Semantics/getsymbols02.f90
new file mode 100644
index 000000000000..4172b7418f9e
--- /dev/null
+++ b/test/Semantics/getsymbols02.f90
@@ -0,0 +1 @@
+!RUN: %S/test_any.sh '%S/Inputs/getsymbols02-*' %f18 %t
\ No newline at end of file
diff --git a/test/Semantics/getsymbols03-a.f90 b/test/Semantics/getsymbols03-a.f90
index 1d6d3b6aaba2..5616f97629ce 100644
--- a/test/Semantics/getsymbols03-a.f90
+++ b/test/Semantics/getsymbols03-a.f90
@@ -1,6 +1,6 @@
 ! Tests -fget-symbols with INCLUDE
-
-INCLUDE "getsymbols03-b.f90"
+!RUN: %S/test_any.sh %s %flang %t
+INCLUDE "Inputs/getsymbols03-b.f90"
 
 program main
  use mm3
@@ -8,7 +8,7 @@ program main
  x = f
 end program
 
-! RUN: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
 ! CHECK:mm3:.*getsymbols03-b.f90, 1, 8-11
 ! CHECK:f:.*getsymbols03-b.f90, 2, 12-13
 ! CHECK:main:.*getsymbols03-a.f90, 5, 9-13
diff --git a/test/Semantics/getsymbols04.f90 b/test/Semantics/getsymbols04.f90
index d4a83aecb5d9..06f739c71137 100644
--- a/test/Semantics/getsymbols04.f90
+++ b/test/Semantics/getsymbols04.f90
@@ -1,5 +1,5 @@
+!RUN: %S/test_any.sh %s %flang %t
 ! Tests -fget-symbols-sources with COMMON.
-
 program main
   integer :: x
   integer :: y
@@ -7,7 +7,7 @@ program main
   x = y
 end program
 
-! RUN: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
 ! CHECK:x:.*getsymbols04.f90, 4, 14-15
 ! CHECK:y:.*getsymbols04.f90, 5, 14-15
 ! CHECK:x:.*getsymbols04.f90, 6, 11-12
diff --git a/test/Semantics/getsymbols05.f90 b/test/Semantics/getsymbols05.f90
index c65a2a6f5a99..f905313675cd 100644
--- a/test/Semantics/getsymbols05.f90
+++ b/test/Semantics/getsymbols05.f90
@@ -1,5 +1,5 @@
+!RUN: %S/test_any.sh %s %flang %t
 ! Tests -fget-symbols-sources with COMMON.
-
 program main
   integer :: x
   integer :: y
@@ -10,7 +10,7 @@ program main
   x = y
 end program
 
-! RUN: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -fget-symbols-sources -fparse-only %s 2>&1 | ${FileCheck} %s
 ! CHECK:x:.*getsymbols05.f90, 4, 14-15
 ! CHECK:y:.*getsymbols05.f90, 5, 14-15
 ! CHECK:x:.*getsymbols05.f90, 7, 16-17
diff --git a/test/Semantics/if_arith01.f90 b/test/Semantics/if_arith01.f90
index 43365c64ad3a..5ec06b47485d 100644
--- a/test/Semantics/if_arith01.f90
+++ b/test/Semantics/if_arith01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check that a basic arithmetic if compiles.
 
 if ( A ) 100, 200, 300
diff --git a/test/Semantics/if_arith02.f90 b/test/Semantics/if_arith02.f90
index fc94e151cf14..f8e24b42dffa 100644
--- a/test/Semantics/if_arith02.f90
+++ b/test/Semantics/if_arith02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check that only labels are allowed in arithmetic if statements.
 ! TODO: Revisit error message "expected 'ASSIGN'" etc.
 ! TODO: Revisit error message "expected one of '0123456789'"
diff --git a/test/Semantics/if_arith03.f90 b/test/Semantics/if_arith03.f90
index fd30eb2ee954..1e5eb67d184c 100644
--- a/test/Semantics/if_arith03.f90
+++ b/test/Semantics/if_arith03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 
 
 !ERROR: label '600' was not found
diff --git a/test/Semantics/if_arith04.f90 b/test/Semantics/if_arith04.f90
index 360d596762b1..9a436cd5eb67 100644
--- a/test/Semantics/if_arith04.f90
+++ b/test/Semantics/if_arith04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Make sure arithmetic if expressions are non-complex numeric exprs.
 
 INTEGER I
diff --git a/test/Semantics/if_construct01.f90 b/test/Semantics/if_construct01.f90
index 66398def9805..c133b7d8cc9f 100644
--- a/test/Semantics/if_construct01.f90
+++ b/test/Semantics/if_construct01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Simple check that if constructs are ok.
 
 if (a < b) then
diff --git a/test/Semantics/if_construct02.f90 b/test/Semantics/if_construct02.f90
index 5177f388b493..9ba6caa45355 100644
--- a/test/Semantics/if_construct02.f90
+++ b/test/Semantics/if_construct02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check that if constructs only accept scalar logical expressions.
 ! TODO: expand the test to check this restriction for more types.
 
diff --git a/test/Semantics/if_stmt01.f90 b/test/Semantics/if_stmt01.f90
index e111f6519d26..51454a9d2116 100644
--- a/test/Semantics/if_stmt01.f90
+++ b/test/Semantics/if_stmt01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Simple check that if statements are ok.
 
 IF (A > 0.0) A = LOG (A)
diff --git a/test/Semantics/if_stmt02.f90 b/test/Semantics/if_stmt02.f90
index 483e92d2c940..71c458381ac2 100644
--- a/test/Semantics/if_stmt02.f90
+++ b/test/Semantics/if_stmt02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !ERROR: IF statement is not allowed in IF statement
 IF (A > 0.0) IF (B < 0.0) A = LOG (A)
 END
diff --git a/test/Semantics/if_stmt03.f90 b/test/Semantics/if_stmt03.f90
index dd869b2cad0a..2a2595404960 100644
--- a/test/Semantics/if_stmt03.f90
+++ b/test/Semantics/if_stmt03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check that non-logical expressions are not allowed.
 ! Check that non-scalar expressions are not allowed.
 ! TODO: Insure all non-logicals are prohibited.
diff --git a/test/Semantics/implicit01.f90 b/test/Semantics/implicit01.f90
index 318fe760322c..f0893f7ed33f 100644
--- a/test/Semantics/implicit01.f90
+++ b/test/Semantics/implicit01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   implicit none
   !ERROR: More than one IMPLICIT NONE statement
diff --git a/test/Semantics/implicit02.f90 b/test/Semantics/implicit02.f90
index d77c3f55c6e6..5d2b6e09474f 100644
--- a/test/Semantics/implicit02.f90
+++ b/test/Semantics/implicit02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   implicit none
   !ERROR: IMPLICIT statement after IMPLICIT NONE or IMPLICIT NONE(TYPE) statement
diff --git a/test/Semantics/implicit03.f90 b/test/Semantics/implicit03.f90
index 343471ad5a15..9636743233a3 100644
--- a/test/Semantics/implicit03.f90
+++ b/test/Semantics/implicit03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   implicit integer(a-z)
   !ERROR: IMPLICIT NONE statement after IMPLICIT statement
diff --git a/test/Semantics/implicit04.f90 b/test/Semantics/implicit04.f90
index 004dbe65549d..86adb95f9852 100644
--- a/test/Semantics/implicit04.f90
+++ b/test/Semantics/implicit04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s
   parameter(a=1.0)
   !ERROR: IMPLICIT NONE statement after PARAMETER statement
diff --git a/test/Semantics/implicit05.f90 b/test/Semantics/implicit05.f90
index 50039a421eaf..7649c228fa44 100644
--- a/test/Semantics/implicit05.f90
+++ b/test/Semantics/implicit05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s
   !ERROR: 'a' does not follow 'b' alphabetically
   implicit integer(b-a)
diff --git a/test/Semantics/implicit06.f90 b/test/Semantics/implicit06.f90
index 225052cd5e89..3f6672008d53 100644
--- a/test/Semantics/implicit06.f90
+++ b/test/Semantics/implicit06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   implicit integer(a-c)
   !ERROR: More than one implicit type specified for 'c'
diff --git a/test/Semantics/implicit07.f90 b/test/Semantics/implicit07.f90
index 8201c3dcb0e3..68fa37de8ce7 100644
--- a/test/Semantics/implicit07.f90
+++ b/test/Semantics/implicit07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 implicit none(external)
 external x
 call x
diff --git a/test/Semantics/implicit08.f90 b/test/Semantics/implicit08.f90
index a56382e4154c..44e96d89855e 100644
--- a/test/Semantics/implicit08.f90
+++ b/test/Semantics/implicit08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   block
     !ERROR: IMPLICIT statement is not allowed in a BLOCK construct
diff --git a/test/Semantics/init01.f90 b/test/Semantics/init01.f90
index b160a99dfc2f..1fc1ed877fa3 100644
--- a/test/Semantics/init01.f90
+++ b/test/Semantics/init01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Object pointer initializer error tests
 
 subroutine test(j)
diff --git a/test/Semantics/int-literals.f90 b/test/Semantics/int-literals.f90
index b3b966996f53..3c48b7e1b7da 100644
--- a/test/Semantics/int-literals.f90
+++ b/test/Semantics/int-literals.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Fortran syntax considers signed int literals in complex literals
 ! to be a distinct production, not an application of unary +/- to
 ! an unsigned int literal, so they're used here to test overflow
diff --git a/test/Semantics/io01.f90 b/test/Semantics/io01.f90
index c951943a4bc7..81b537d7e4c5 100644
--- a/test/Semantics/io01.f90
+++ b/test/Semantics/io01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   character(len=20) :: access = "direcT"
   character(len=20) :: access_(2) = (/"direcT", "streaM"/)
   character(len=20) :: action_(2) = (/"reaD ", "writE"/)
diff --git a/test/Semantics/io02.f90 b/test/Semantics/io02.f90
index 65e6b263bb8b..7cb901d34027 100644
--- a/test/Semantics/io02.f90
+++ b/test/Semantics/io02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   integer :: unit10 = 10
   integer :: unit11 = 11
 
diff --git a/test/Semantics/io03.f90 b/test/Semantics/io03.f90
index 71425b8869c5..a6696176b126 100644
--- a/test/Semantics/io03.f90
+++ b/test/Semantics/io03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   character(kind=1,len=50) internal_file
   character(kind=2,len=50) internal_file2
   character(kind=4,len=50) internal_file4
diff --git a/test/Semantics/io04.f90 b/test/Semantics/io04.f90
index 68b217f57a61..09776ef94ab1 100644
--- a/test/Semantics/io04.f90
+++ b/test/Semantics/io04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   character(kind=1,len=50) internal_file
   character(kind=1,len=100) msg
   character(20) sign
diff --git a/test/Semantics/io05.f90 b/test/Semantics/io05.f90
index 5b36f9ba923e..1df878197237 100644
--- a/test/Semantics/io05.f90
+++ b/test/Semantics/io05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   character*20 c(25), cv
   character(kind=1,len=59) msg
   logical*2 v(5), lv
diff --git a/test/Semantics/io06.f90 b/test/Semantics/io06.f90
index d4ea73e51154..eba437c86c86 100644
--- a/test/Semantics/io06.f90
+++ b/test/Semantics/io06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   character(kind=1,len=100) msg1
   character(kind=2,len=200) msg2
   integer(1) stat1
diff --git a/test/Semantics/io07.f90 b/test/Semantics/io07.f90
index 4677be23ec54..9462a099d67e 100644
--- a/test/Semantics/io07.f90
+++ b/test/Semantics/io07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 1001 format(A)
 
      !ERROR: Format statement must be labeled
diff --git a/test/Semantics/io08.f90 b/test/Semantics/io08.f90
index db25da188b9f..1b75e8094a9a 100644
--- a/test/Semantics/io08.f90
+++ b/test/Semantics/io08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   write(*,*)
   write(*,'()')
   write(*,'(A)')
diff --git a/test/Semantics/io09.f90 b/test/Semantics/io09.f90
index dba5ae53692a..5f50e4e0151e 100644
--- a/test/Semantics/io09.f90
+++ b/test/Semantics/io09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
   !ERROR: String edit descriptor in READ format expression
   read(*,'("abc")')
 
diff --git a/test/Semantics/io10.f90 b/test/Semantics/io10.f90
index fa38c3d38e3d..90ae8b194330 100644
--- a/test/Semantics/io10.f90
+++ b/test/Semantics/io10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !OPTIONS: -Mstandard
 
   write(*, '(B0)')
diff --git a/test/Semantics/kinds01.f90 b/test/Semantics/kinds01.f90
index 3bef1bb39762..388ca2342167 100644
--- a/test/Semantics/kinds01.f90
+++ b/test/Semantics/kinds01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
  !DEF: /MainProgram1/jk1 ObjectEntity INTEGER(1)
  integer(kind=1) jk1
  !DEF: /MainProgram1/js1 ObjectEntity INTEGER(1)
diff --git a/test/Semantics/kinds02.f90 b/test/Semantics/kinds02.f90
index 9fb921345d85..0983be564738 100644
--- a/test/Semantics/kinds02.f90
+++ b/test/Semantics/kinds02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C712 The value of scalar-int-constant-expr shall be nonnegative and 
 ! shall specify a representation method that exists on the processor.
 ! C714 The value of kind-param shall be nonnegative.
diff --git a/test/Semantics/kinds03.f90 b/test/Semantics/kinds03.f90
index 63239e08d05a..b4ba7e67bb6c 100644
--- a/test/Semantics/kinds03.f90
+++ b/test/Semantics/kinds03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
  !DEF: /MainProgram1/ipdt DerivedType
  !DEF: /MainProgram1/ipdt/k TypeParam INTEGER(4)
  type :: ipdt(k)
diff --git a/test/Semantics/kinds04.f90 b/test/Semantics/kinds04.f90
index ecf3a446cc3d..af6a8965ca65 100644
--- a/test/Semantics/kinds04.f90
+++ b/test/Semantics/kinds04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C716 If both kind-param and exponent-letter appear, exponent-letter 
 ! shall be E.
 ! C717 The value of kind-param shall specify an approximation method that 
diff --git a/test/Semantics/label01.F90 b/test/Semantics/label01.F90
index d4fd7331fb5d..e63bd547ee75 100644
--- a/test/Semantics/label01.F90
+++ b/test/Semantics/label01.F90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s -o /dev/null 2>&1 | grep -v 'procedure conflicts' | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s -o /dev/null 2>&1 | grep -v 'procedure conflicts' | ${FileCheck} %s
 ! CHECK-NOT: error:[[:space:]]
 
 ! FIXME: filter out the array/function syntax issues (procedure conflicts)
diff --git a/test/Semantics/label02.f90 b/test/Semantics/label02.f90
index f7b61953b630..6aa052d52d66 100644
--- a/test/Semantics/label02.f90
+++ b/test/Semantics/label02.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: label '0' is out of range
 ! CHECK: label '100000' is out of range
 ! CHECK: label '123456' is out of range
diff --git a/test/Semantics/label03.f90 b/test/Semantics/label03.f90
index 0ee40e95602f..a33b2f33a9b3 100644
--- a/test/Semantics/label03.f90
+++ b/test/Semantics/label03.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: DO loop doesn't properly nest
 ! CHECK: DO loop conflicts
 ! CHECK: label '30' cannot be found
diff --git a/test/Semantics/label04.f90 b/test/Semantics/label04.f90
index d9de328642cd..a3f3586763ee 100644
--- a/test/Semantics/label04.f90
+++ b/test/Semantics/label04.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: branch into loop body from outside
 ! CHECK: do 10 i = 1, m
 ! CHECK: the loop branched into
diff --git a/test/Semantics/label05.f90 b/test/Semantics/label05.f90
index 53f99df8fa6b..09bd9fa2b0f0 100644
--- a/test/Semantics/label05.f90
+++ b/test/Semantics/label05.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: label '50' was not found
 ! CHECK: label '55' is not in scope
 ! CHECK: '70' not a branch target
diff --git a/test/Semantics/label06.f90 b/test/Semantics/label06.f90
index 42f6631f59ab..4e633d3df552 100644
--- a/test/Semantics/label06.f90
+++ b/test/Semantics/label06.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: label '10' is not in scope
 ! CHECK: label '20' was not found
 ! CHECK: '30' not a branch target
diff --git a/test/Semantics/label07.f90 b/test/Semantics/label07.f90
index 0f6b57c42f5c..62755082e030 100644
--- a/test/Semantics/label07.f90
+++ b/test/Semantics/label07.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: '30' not a branch target
 ! CHECK: control flow use of '30'
 ! CHECK: label '10' is not in scope
diff --git a/test/Semantics/label08.f90 b/test/Semantics/label08.f90
index db51c6772c34..140ceb33ec68 100644
--- a/test/Semantics/label08.f90
+++ b/test/Semantics/label08.f90
@@ -1,6 +1,7 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! negative test -- invalid labels, out of range
 
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: CYCLE construct-name is not in scope
 ! CHECK: IF construct name unexpected
 ! CHECK: unnamed IF statement
diff --git a/test/Semantics/label09.f90 b/test/Semantics/label09.f90
index 0ec9efabedcb..a74263d58315 100644
--- a/test/Semantics/label09.f90
+++ b/test/Semantics/label09.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: label '60' was not found
 
 subroutine s(a)
diff --git a/test/Semantics/label10.f90 b/test/Semantics/label10.f90
index 23a0a055cb63..377108c95dd5 100644
--- a/test/Semantics/label10.f90
+++ b/test/Semantics/label10.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: '60' not a FORMAT
 ! CHECK: data transfer use of '60'
 
diff --git a/test/Semantics/label11.f90 b/test/Semantics/label11.f90
index 5b1866e4b193..924356615e3b 100644
--- a/test/Semantics/label11.f90
+++ b/test/Semantics/label11.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: BLOCK DATA subprogram name mismatch
 ! CHECK: should be
 ! CHECK: FUNCTION name mismatch
diff --git a/test/Semantics/label12.f90 b/test/Semantics/label12.f90
index bd3455d2fa90..96607bc8e8f0 100644
--- a/test/Semantics/label12.f90
+++ b/test/Semantics/label12.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: expected end of statement
 
 subroutine s
diff --git a/test/Semantics/label13.f90 b/test/Semantics/label13.f90
index b55ed6d94341..61501804d270 100644
--- a/test/Semantics/label13.f90
+++ b/test/Semantics/label13.f90
@@ -1,4 +1,5 @@
-! RUN: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
+! RUN: %S/test_any.sh %s %flang %t
+! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: branch into loop body from outside
 ! CHECK: the loop branched into
 
diff --git a/test/Semantics/label14.f90 b/test/Semantics/label14.f90
index 10a91c755b96..e6eb744f50e3 100644
--- a/test/Semantics/label14.f90
+++ b/test/Semantics/label14.f90
@@ -1,8 +1,9 @@
+! RUN: %S/test_any.sh %s %flang %t
 ! Tests implemented for this standard
 ! 11.1.4 - 4 It is permissible to branch to and end-block-stmt only withinh its
 !            Block Construct
 
-! RUN: ${F18} %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} %s 2>&1 | ${FileCheck} %s
 ! CHECK: label '20' is not in scope
 
 subroutine s1
diff --git a/test/Semantics/misc-declarations.f90 b/test/Semantics/misc-declarations.f90
index a25e5ffbfbf4..9103ad7bcf7d 100644
--- a/test/Semantics/misc-declarations.f90
+++ b/test/Semantics/misc-declarations.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Miscellaneous constraint and requirement checking on declarations:
 ! - 8.5.6.2 & 8.5.6.3 constraints on coarrays
 ! - 8.5.19 constraints on the VOLATILE attribute
diff --git a/test-lit/Semantics/mod-file-rewriter.f90 b/test/Semantics/mod-file-rewriter.f90
similarity index 100%
rename from test-lit/Semantics/mod-file-rewriter.f90
rename to test/Semantics/mod-file-rewriter.f90
diff --git a/test/Semantics/modfile01.f90 b/test/Semantics/modfile01.f90
index 79f5e570bfce..d3cd5273f853 100644
--- a/test/Semantics/modfile01.f90
+++ b/test/Semantics/modfile01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Check correct modfile generation for type with private component.
 module m
   integer :: i
diff --git a/test/Semantics/modfile02.f90 b/test/Semantics/modfile02.f90
index 0f9ba86feb4b..9f460004415d 100644
--- a/test/Semantics/modfile02.f90
+++ b/test/Semantics/modfile02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Check modfile generation for private type in public API.
 
 module m
diff --git a/test/Semantics/modfile03.f90 b/test/Semantics/modfile03.f90
index eedde939b068..9beb5308bd38 100644
--- a/test/Semantics/modfile03.f90
+++ b/test/Semantics/modfile03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Check modfile generation with use-association.
 
 module m1
diff --git a/test/Semantics/modfile04.f90 b/test/Semantics/modfile04.f90
index 0b5800387255..9dbd3adfeede 100644
--- a/test/Semantics/modfile04.f90
+++ b/test/Semantics/modfile04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! modfile with subprograms
 
 module m1
diff --git a/test/Semantics/modfile05.f90 b/test/Semantics/modfile05.f90
index e56023d191cb..49e3f47d4a68 100644
--- a/test/Semantics/modfile05.f90
+++ b/test/Semantics/modfile05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Use-association with VOLATILE or ASYNCHRONOUS
 
 module m1
diff --git a/test/Semantics/modfile06.f90 b/test/Semantics/modfile06.f90
index 94fe384dd094..5924b67c7daa 100644
--- a/test/Semantics/modfile06.f90
+++ b/test/Semantics/modfile06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Check modfile generation for external interface
 module m
   interface
diff --git a/test/Semantics/modfile07.f90 b/test/Semantics/modfile07.f90
index 58734b360c1b..b4a49d9924e3 100644
--- a/test/Semantics/modfile07.f90
+++ b/test/Semantics/modfile07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Check modfile generation for generic interfaces
 module m1
   interface foo
diff --git a/test/Semantics/modfile08.f90 b/test/Semantics/modfile08.f90
index e23078b34dcd..7a2e20195f2d 100644
--- a/test/Semantics/modfile08.f90
+++ b/test/Semantics/modfile08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Check modfile generation for external declarations
 module m
   real, external :: a
diff --git a/test/Semantics/modfile09.f90 b/test/Semantics/modfile09.f90
new file mode 100644
index 000000000000..ec5813b48e51
--- /dev/null
+++ b/test/Semantics/modfile09.f90
@@ -0,0 +1 @@
+!RUN: %S/test_modfile.sh '%S/Inputs/modfile09-*' %f18 %t
diff --git a/test/Semantics/modfile10.f90 b/test/Semantics/modfile10.f90
index 2340842b2843..dc91d8734b19 100644
--- a/test/Semantics/modfile10.f90
+++ b/test/Semantics/modfile10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test writing procedure bindings in a derived type.
 
 module m
diff --git a/test/Semantics/modfile11.f90 b/test/Semantics/modfile11.f90
index 89df7d7a068b..ec4dd2f88099 100644
--- a/test/Semantics/modfile11.f90
+++ b/test/Semantics/modfile11.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   type t1(a, b, c)
     integer, kind :: a
diff --git a/test/Semantics/modfile12.f90 b/test/Semantics/modfile12.f90
index 89f43ad350eb..ca43611984a4 100644
--- a/test/Semantics/modfile12.f90
+++ b/test/Semantics/modfile12.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   integer(8), parameter :: a = 1, b = 2_8
   parameter(n=3,l=-3,e=1.0/3.0)
diff --git a/test/Semantics/modfile13.f90 b/test/Semantics/modfile13.f90
index 9205eabf6189..c4fcfe71751b 100644
--- a/test/Semantics/modfile13.f90
+++ b/test/Semantics/modfile13.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   character(2) :: z
   character(len=3) :: y
diff --git a/test/Semantics/modfile14.f90 b/test/Semantics/modfile14.f90
index 16fbbc08b11c..1c4fa0e92076 100644
--- a/test/Semantics/modfile14.f90
+++ b/test/Semantics/modfile14.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   type t1
   contains
diff --git a/test/Semantics/modfile15.f90 b/test/Semantics/modfile15.f90
index 480ad8e77ab2..4cc8787f5d45 100644
--- a/test/Semantics/modfile15.f90
+++ b/test/Semantics/modfile15.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   type :: t
     procedure(a), pointer, pass :: c
diff --git a/test/Semantics/modfile16.f90 b/test/Semantics/modfile16.f90
index e60106148504..acc17d54a282 100644
--- a/test/Semantics/modfile16.f90
+++ b/test/Semantics/modfile16.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   character(2), parameter :: prefix = 'c_'
   integer, bind(c, name='c_a') :: a
diff --git a/test/Semantics/modfile17.f90 b/test/Semantics/modfile17.f90
index 0b91801e1081..33767a38028c 100644
--- a/test/Semantics/modfile17.f90
+++ b/test/Semantics/modfile17.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Tests parameterized derived type instantiation with KIND parameters
 
 module m
diff --git a/test/Semantics/modfile18.f90 b/test/Semantics/modfile18.f90
index 39f719e4878a..032b0491045b 100644
--- a/test/Semantics/modfile18.f90
+++ b/test/Semantics/modfile18.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Tests folding of array constructors
 
 module m
diff --git a/test/Semantics/modfile19.f90 b/test/Semantics/modfile19.f90
index 50d50ee6b1e2..fcb10b54e9d0 100644
--- a/test/Semantics/modfile19.f90
+++ b/test/Semantics/modfile19.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   implicit complex(8)(z)
   real :: x
diff --git a/test/Semantics/modfile20.f90 b/test/Semantics/modfile20.f90
index 8677e3479ad2..90188c177c44 100644
--- a/test/Semantics/modfile20.f90
+++ b/test/Semantics/modfile20.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test modfiles for entities with initialization
 module m
   integer, parameter :: k8 = 8
diff --git a/test/Semantics/modfile21.f90 b/test/Semantics/modfile21.f90
index 3618ad0ab027..03349a32682d 100644
--- a/test/Semantics/modfile21.f90
+++ b/test/Semantics/modfile21.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m
   logical b
   bind(C) :: /cb2/
diff --git a/test/Semantics/modfile22.f90 b/test/Semantics/modfile22.f90
index deb365a7606c..6279ad78678a 100644
--- a/test/Semantics/modfile22.f90
+++ b/test/Semantics/modfile22.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test character length conversions in constructors
 
 module m
diff --git a/test/Semantics/modfile23.f90 b/test/Semantics/modfile23.f90
index 8bf33b542ed7..4b5637867e1d 100644
--- a/test/Semantics/modfile23.f90
+++ b/test/Semantics/modfile23.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test that subprogram interfaces get all of the symbols that they need.
 
 module m1
diff --git a/test/Semantics/modfile24.f90 b/test/Semantics/modfile24.f90
index dc9c7d52a8df..ec446f9e8d3c 100644
--- a/test/Semantics/modfile24.f90
+++ b/test/Semantics/modfile24.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test declarations with coarray-spec
 
 ! Different ways of declaring the same coarray.
diff --git a/test/Semantics/modfile25.f90 b/test/Semantics/modfile25.f90
index 5c16ead42951..210935df2515 100644
--- a/test/Semantics/modfile25.f90
+++ b/test/Semantics/modfile25.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test compile-time analysis of shapes.
 
 module m1
diff --git a/test/Semantics/modfile26.f90 b/test/Semantics/modfile26.f90
index 44d43c6ca788..5064122a3740 100644
--- a/test/Semantics/modfile26.f90
+++ b/test/Semantics/modfile26.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Intrinsics SELECTED_INT_KIND, SELECTED_REAL_KIND, PRECISION, RANGE,
 ! RADIX, DIGITS
 
diff --git a/test/Semantics/modfile27.f90 b/test/Semantics/modfile27.f90
index ae577d84985c..2a6e23f6f464 100644
--- a/test/Semantics/modfile27.f90
+++ b/test/Semantics/modfile27.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test folding of combined array references and structure component
 ! references.
 
diff --git a/test/Semantics/modfile28.f90 b/test/Semantics/modfile28.f90
index c53ab04dfc2d..18a349de5ba1 100644
--- a/test/Semantics/modfile28.f90
+++ b/test/Semantics/modfile28.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 
 ! Test UTF-8 support in character literals
 ! Note: Module files are encoded in UTF-8.
diff --git a/test/Semantics/modfile29.f90 b/test/Semantics/modfile29.f90
index 7753e22d0f3e..7afa55120be1 100644
--- a/test/Semantics/modfile29.f90
+++ b/test/Semantics/modfile29.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Check that implicitly typed entities get a type in the module file.
 
 module m
diff --git a/test/Semantics/modfile30.f90 b/test/Semantics/modfile30.f90
index 427025b91635..ef05b9395139 100644
--- a/test/Semantics/modfile30.f90
+++ b/test/Semantics/modfile30.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Verify miscellaneous bugs
 
 ! The function result must be declared after the dummy arguments
diff --git a/test/Semantics/modfile31.f90 b/test/Semantics/modfile31.f90
index ec00f9f0ccb9..a29256fe46a2 100644
--- a/test/Semantics/modfile31.f90
+++ b/test/Semantics/modfile31.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test 7.6 enum values
 
 module m1
diff --git a/test/Semantics/modfile32.f90 b/test/Semantics/modfile32.f90
index 6db201e852c0..ea5b55a94d05 100644
--- a/test/Semantics/modfile32.f90
+++ b/test/Semantics/modfile32.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Resolution of generic names in expressions.
 ! Test by using generic function in a specification expression that needs
 ! to be written to a .mod file.
diff --git a/test/Semantics/modfile33.f90 b/test/Semantics/modfile33.f90
index 23a510bf4008..d5474c799f77 100644
--- a/test/Semantics/modfile33.f90
+++ b/test/Semantics/modfile33.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Resolution of user-defined operators in expressions.
 ! Test by using generic function in a specification expression that needs
 ! to be written to a .mod file.
diff --git a/test/Semantics/modfile34.f90 b/test/Semantics/modfile34.f90
index 16bacf7ade03..59b0fd1a447f 100644
--- a/test/Semantics/modfile34.f90
+++ b/test/Semantics/modfile34.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 ! Test resolution of type-bound generics.
 
 module m1
diff --git a/test/Semantics/modfile35.f90 b/test/Semantics/modfile35.f90
index c1d1c9541b1f..9ef35747e947 100644
--- a/test/Semantics/modfile35.f90
+++ b/test/Semantics/modfile35.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_modfile.sh %s %f18 %t
 module m1
   type :: t1
   contains
diff --git a/test/Semantics/namelist01.f90 b/test/Semantics/namelist01.f90
index 81acecbfc725..f659c998c7ef 100644
--- a/test/Semantics/namelist01.f90
+++ b/test/Semantics/namelist01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test for checking namelist constraints, C8103-C8105
 
 module dup
diff --git a/test/Semantics/null01.f90 b/test/Semantics/null01.f90
index f6f5fa79975e..09c6dce22c48 100644
--- a/test/Semantics/null01.f90
+++ b/test/Semantics/null01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! NULL() intrinsic function error tests
 
 subroutine test
diff --git a/test/Semantics/nullify01.f90 b/test/Semantics/nullify01.f90
index a8a4c7d1c2b8..9af635f8f08c 100644
--- a/test/Semantics/nullify01.f90
+++ b/test/Semantics/nullify01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test that NULLIFY works
 
 Module share
diff --git a/test/Semantics/nullify02.f90 b/test/Semantics/nullify02.f90
index 2d611f3b7859..49bcc9ef5d11 100644
--- a/test/Semantics/nullify02.f90
+++ b/test/Semantics/nullify02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Check for semantic errors in NULLIFY statements
 
 INTEGER, PARAMETER :: maxvalue=1024
diff --git a/test/Semantics/omp-atomic.f90 b/test/Semantics/omp-atomic.f90
index 9a9d027f82e3..760d1ee4f619 100644
--- a/test/Semantics/omp-atomic.f90
+++ b/test/Semantics/omp-atomic.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP 2.13.6 atomic Construct
diff --git a/test/Semantics/omp-clause-validity01.f90 b/test/Semantics/omp-clause-validity01.f90
index d624564cd20b..523b2eeb6c10 100644
--- a/test/Semantics/omp-clause-validity01.f90
+++ b/test/Semantics/omp-clause-validity01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP clause validity for the following directives:
diff --git a/test/Semantics/omp-declarative-directive.f90 b/test/Semantics/omp-declarative-directive.f90
index 3a7933d25cb7..639ed7d4d895 100644
--- a/test/Semantics/omp-declarative-directive.f90
+++ b/test/Semantics/omp-declarative-directive.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP declarative directives
diff --git a/test/Semantics/omp-device-constructs.f90 b/test/Semantics/omp-device-constructs.f90
index e87cb119dba4..7973dc2ef77f 100644
--- a/test/Semantics/omp-device-constructs.f90
+++ b/test/Semantics/omp-device-constructs.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 ! Check OpenMP clause validity for the following directives:
 !     2.10 Device constructs
diff --git a/test/Semantics/omp-loop-association.f90 b/test/Semantics/omp-loop-association.f90
index 65b79fd5b476..22e9365b2f3f 100644
--- a/test/Semantics/omp-loop-association.f90
+++ b/test/Semantics/omp-loop-association.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check the association between OpenMPLoopConstruct and DoConstruct
diff --git a/test/Semantics/omp-nested01.f90 b/test/Semantics/omp-nested01.f90
index 15b1713f6707..0e7220222217 100644
--- a/test/Semantics/omp-nested01.f90
+++ b/test/Semantics/omp-nested01.f90
@@ -1,3 +1,5 @@
+! RUN: %S/test_errors.sh %s %flang %t
+!XFAIL: *
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP 2.17 Nesting of Regions
diff --git a/test/Semantics/omp-resolve01.f90 b/test/Semantics/omp-resolve01.f90
index 003de6eae171..528915e88f8d 100644
--- a/test/Semantics/omp-resolve01.f90
+++ b/test/Semantics/omp-resolve01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.4 An array section designates a subset of the elements in an array. Although
diff --git a/test/Semantics/omp-resolve02.f90 b/test/Semantics/omp-resolve02.f90
index 3703c74cfa96..3d341662b2da 100644
--- a/test/Semantics/omp-resolve02.f90
+++ b/test/Semantics/omp-resolve02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! Test the effect to name resolution from illegal clause
diff --git a/test/Semantics/omp-resolve03.f90 b/test/Semantics/omp-resolve03.f90
index 165bfc35773b..a896ef30c9f4 100644
--- a/test/Semantics/omp-resolve03.f90
+++ b/test/Semantics/omp-resolve03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Although variables in common blocks can be accessed by use association
diff --git a/test/Semantics/omp-resolve04.f90 b/test/Semantics/omp-resolve04.f90
index d9ea847cb1b8..234013898b87 100644
--- a/test/Semantics/omp-resolve04.f90
+++ b/test/Semantics/omp-resolve04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
diff --git a/test/Semantics/omp-resolve05.f90 b/test/Semantics/omp-resolve05.f90
index 0ba4fd816d92..ebc50476b499 100644
--- a/test/Semantics/omp-resolve05.f90
+++ b/test/Semantics/omp-resolve05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
diff --git a/test/Semantics/omp-symbol01.f90 b/test/Semantics/omp-symbol01.f90
index bec8e0450dd5..70782f3adf41 100644
--- a/test/Semantics/omp-symbol01.f90
+++ b/test/Semantics/omp-symbol01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! Test clauses that accept list.
diff --git a/test/Semantics/omp-symbol02.f90 b/test/Semantics/omp-symbol02.f90
index 3419c61e13db..eddb6865e88c 100644
--- a/test/Semantics/omp-symbol02.f90
+++ b/test/Semantics/omp-symbol02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 1.4.1 Structure of the OpenMP Memory Model
diff --git a/test/Semantics/omp-symbol03.f90 b/test/Semantics/omp-symbol03.f90
index a158ee87a425..54072a1e1049 100644
--- a/test/Semantics/omp-symbol03.f90
+++ b/test/Semantics/omp-symbol03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 1.4.1 Structure of the OpenMP Memory Model
diff --git a/test/Semantics/omp-symbol04.f90 b/test/Semantics/omp-symbol04.f90
index 4824c78dc92b..052fa859cd32 100644
--- a/test/Semantics/omp-symbol04.f90
+++ b/test/Semantics/omp-symbol04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
diff --git a/test/Semantics/omp-symbol05.f90 b/test/Semantics/omp-symbol05.f90
index 7e4e691c5b96..1a4b42e1ce32 100644
--- a/test/Semantics/omp-symbol05.f90
+++ b/test/Semantics/omp-symbol05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.2 threadprivate Directive
diff --git a/test/Semantics/omp-symbol06.f90 b/test/Semantics/omp-symbol06.f90
index c1d7581db8be..b8ac0fc06115 100644
--- a/test/Semantics/omp-symbol06.f90
+++ b/test/Semantics/omp-symbol06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
diff --git a/test/Semantics/omp-symbol07.f90 b/test/Semantics/omp-symbol07.f90
index 170452959e01..c6cf500b41da 100644
--- a/test/Semantics/omp-symbol07.f90
+++ b/test/Semantics/omp-symbol07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! Generic tests
diff --git a/test/Semantics/omp-symbol08.f90 b/test/Semantics/omp-symbol08.f90
index ac09e1690677..3a11933ac023 100644
--- a/test/Semantics/omp-symbol08.f90
+++ b/test/Semantics/omp-symbol08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.1.1 Predetermined rules for associated do-loops index variable
diff --git a/test/Semantics/procinterface01.f90 b/test/Semantics/procinterface01.f90
index 5ab53d530ef3..b66206e24134 100644
--- a/test/Semantics/procinterface01.f90
+++ b/test/Semantics/procinterface01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Tests for "proc-interface" semantics.
 ! These cases are all valid.
 
diff --git a/test/Semantics/resolve01.f90 b/test/Semantics/resolve01.f90
index 0c257fe1be9f..eee8d662517f 100644
--- a/test/Semantics/resolve01.f90
+++ b/test/Semantics/resolve01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 integer :: x
 !ERROR: The type of 'x' has already been declared
 real :: x
diff --git a/test/Semantics/resolve02.f90 b/test/Semantics/resolve02.f90
index ddc419b392c3..0d8e83b0ed29 100644
--- a/test/Semantics/resolve02.f90
+++ b/test/Semantics/resolve02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s
   !ERROR: Declaration of 'x' conflicts with its use as internal procedure
   real :: x
diff --git a/test/Semantics/resolve03.f90 b/test/Semantics/resolve03.f90
index 63a88f143adc..773aaab3d453 100644
--- a/test/Semantics/resolve03.f90
+++ b/test/Semantics/resolve03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 implicit none
 integer :: x
 !ERROR: No explicit type declared for 'y'
diff --git a/test/Semantics/resolve04.f90 b/test/Semantics/resolve04.f90
index 8998acdca244..5132b9f780f6 100644
--- a/test/Semantics/resolve04.f90
+++ b/test/Semantics/resolve04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !ERROR: No explicit type declared for 'f'
 function f()
   implicit none
diff --git a/test/Semantics/resolve05.f90 b/test/Semantics/resolve05.f90
index d485a34b6532..d1960e1808b1 100644
--- a/test/Semantics/resolve05.f90
+++ b/test/Semantics/resolve05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 program p
   integer :: p ! this is ok
 end
diff --git a/test/Semantics/resolve06.f90 b/test/Semantics/resolve06.f90
index 12e0e2d4b126..276feb3b4ee4 100644
--- a/test/Semantics/resolve06.f90
+++ b/test/Semantics/resolve06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 implicit none
 allocatable :: x
 integer :: x
diff --git a/test/Semantics/resolve07.f90 b/test/Semantics/resolve07.f90
index 585bf633b2ad..f2e46f42a9d1 100644
--- a/test/Semantics/resolve07.f90
+++ b/test/Semantics/resolve07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   integer :: x(2)
   !ERROR: The dimensions of 'x' have already been declared
diff --git a/test/Semantics/resolve08.f90 b/test/Semantics/resolve08.f90
index 32274ce49df1..7252c79ef033 100644
--- a/test/Semantics/resolve08.f90
+++ b/test/Semantics/resolve08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 integer :: g(10)
 f(i) = i + 1  ! statement function
 g(i) = i + 2  ! mis-parsed array assignment
diff --git a/test/Semantics/resolve09.f90 b/test/Semantics/resolve09.f90
index f288dad1a965..5104a371a639 100644
--- a/test/Semantics/resolve09.f90
+++ b/test/Semantics/resolve09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 integer :: y
 procedure() :: a
 procedure(real) :: b
diff --git a/test/Semantics/resolve10.f90 b/test/Semantics/resolve10.f90
index 75a44a4f5e57..9990935899fa 100644
--- a/test/Semantics/resolve10.f90
+++ b/test/Semantics/resolve10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   public
   type t
diff --git a/test/Semantics/resolve11.f90 b/test/Semantics/resolve11.f90
index 1114339a1bdb..d94c0f8c87d1 100644
--- a/test/Semantics/resolve11.f90
+++ b/test/Semantics/resolve11.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   public i
   integer, private :: j
diff --git a/test/Semantics/resolve12.f90 b/test/Semantics/resolve12.f90
index 1d2e1c398642..03bad9f5616f 100644
--- a/test/Semantics/resolve12.f90
+++ b/test/Semantics/resolve12.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m1
 end
 
diff --git a/test/Semantics/resolve13.f90 b/test/Semantics/resolve13.f90
index c67c59287ac3..6fc03b1e8be0 100644
--- a/test/Semantics/resolve13.f90
+++ b/test/Semantics/resolve13.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m1
   integer :: x
   integer, private :: y
diff --git a/test/Semantics/resolve14.f90 b/test/Semantics/resolve14.f90
index d9693e3a1ffd..326fe8e94894 100644
--- a/test/Semantics/resolve14.f90
+++ b/test/Semantics/resolve14.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m1
   integer :: x
   integer :: y
diff --git a/test/Semantics/resolve15.f90 b/test/Semantics/resolve15.f90
index 6ad7b2534797..1cca8ce3dd7b 100644
--- a/test/Semantics/resolve15.f90
+++ b/test/Semantics/resolve15.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   real :: var
   interface i
diff --git a/test/Semantics/resolve16.f90 b/test/Semantics/resolve16.f90
index 798b88bd8b2d..8ce084a26fe9 100644
--- a/test/Semantics/resolve16.f90
+++ b/test/Semantics/resolve16.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   interface
     subroutine sub0
diff --git a/test/Semantics/resolve17.f90 b/test/Semantics/resolve17.f90
index 360115333235..f9c9451dcfe2 100644
--- a/test/Semantics/resolve17.f90
+++ b/test/Semantics/resolve17.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   integer :: foo
   !Note: PGI, Intel, and GNU allow this; NAG and Sun do not
diff --git a/test/Semantics/resolve18.f90 b/test/Semantics/resolve18.f90
index ed9d301106eb..dff395f4bc9b 100644
--- a/test/Semantics/resolve18.f90
+++ b/test/Semantics/resolve18.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m1
   implicit none
 contains
diff --git a/test/Semantics/resolve19.f90 b/test/Semantics/resolve19.f90
index 15f902a2ba46..f28f2b45abdf 100644
--- a/test/Semantics/resolve19.f90
+++ b/test/Semantics/resolve19.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   interface a
     subroutine s(x)
diff --git a/test/Semantics/resolve20.f90 b/test/Semantics/resolve20.f90
index 33c67dd24923..38dbd2367fe4 100644
--- a/test/Semantics/resolve20.f90
+++ b/test/Semantics/resolve20.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   abstract interface
     subroutine foo
diff --git a/test/Semantics/resolve21.f90 b/test/Semantics/resolve21.f90
index 38fc699ca018..764537a565f5 100644
--- a/test/Semantics/resolve21.f90
+++ b/test/Semantics/resolve21.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   type :: t
     integer :: i
diff --git a/test/Semantics/resolve22.f90 b/test/Semantics/resolve22.f90
index cc8c9ed75dad..3549ec76e777 100644
--- a/test/Semantics/resolve22.f90
+++ b/test/Semantics/resolve22.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   !OK: interface followed by type with same name
   interface t
diff --git a/test/Semantics/resolve23.f90 b/test/Semantics/resolve23.f90
index 504363b458e1..41644843bf1f 100644
--- a/test/Semantics/resolve23.f90
+++ b/test/Semantics/resolve23.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   type :: t
     real :: y
diff --git a/test/Semantics/resolve24.f90 b/test/Semantics/resolve24.f90
index 87917ba09fbc..c2ce595d9054 100644
--- a/test/Semantics/resolve24.f90
+++ b/test/Semantics/resolve24.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine test1
   !ERROR: Generic interface 'foo' has both a function and a subroutine
   interface foo
diff --git a/test/Semantics/resolve25.f90 b/test/Semantics/resolve25.f90
index 62e0ba6ff2d0..4d3ec8c81495 100644
--- a/test/Semantics/resolve25.f90
+++ b/test/Semantics/resolve25.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   interface foo
     subroutine s1(x)
diff --git a/test/Semantics/resolve26.f90 b/test/Semantics/resolve26.f90
index 343ee1eb9160..f39366faaef0 100644
--- a/test/Semantics/resolve26.f90
+++ b/test/Semantics/resolve26.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m1
   interface
     module subroutine s()
diff --git a/test/Semantics/resolve27.f90 b/test/Semantics/resolve27.f90
index 3f04c1aa64fa..b10105ed9e7d 100644
--- a/test/Semantics/resolve27.f90
+++ b/test/Semantics/resolve27.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   interface
     module subroutine s()
diff --git a/test/Semantics/resolve28.f90 b/test/Semantics/resolve28.f90
index 2843c2cbb071..0fd81807c97f 100644
--- a/test/Semantics/resolve28.f90
+++ b/test/Semantics/resolve28.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s
   type t
   end type
diff --git a/test/Semantics/resolve29.f90 b/test/Semantics/resolve29.f90
index f692b0c0e91d..d328eba594e7 100644
--- a/test/Semantics/resolve29.f90
+++ b/test/Semantics/resolve29.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   type t1
   end type
diff --git a/test/Semantics/resolve30.f90 b/test/Semantics/resolve30.f90
index 69121e03ec1e..98777124b134 100644
--- a/test/Semantics/resolve30.f90
+++ b/test/Semantics/resolve30.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   integer x
   block
diff --git a/test/Semantics/resolve31.f90 b/test/Semantics/resolve31.f90
index 982cb56ad564..3c61cd0bb9dc 100644
--- a/test/Semantics/resolve31.f90
+++ b/test/Semantics/resolve31.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   integer :: t0
   !ERROR: 't0' is not a derived type
diff --git a/test/Semantics/resolve32.f90 b/test/Semantics/resolve32.f90
index 6f6ed8fb0bf9..317a0ad9ed12 100644
--- a/test/Semantics/resolve32.f90
+++ b/test/Semantics/resolve32.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m2
   public s2, s4
   private s3
diff --git a/test/Semantics/resolve33.f90 b/test/Semantics/resolve33.f90
index 214a678eb567..4a37c5fb57aa 100644
--- a/test/Semantics/resolve33.f90
+++ b/test/Semantics/resolve33.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Derived type parameters
 
 module m
diff --git a/test/Semantics/resolve34.f90 b/test/Semantics/resolve34.f90
index d9a2a233e8d4..9d148ff43046 100644
--- a/test/Semantics/resolve34.f90
+++ b/test/Semantics/resolve34.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Extended derived types
 
 module m1
diff --git a/test/Semantics/resolve35.f90 b/test/Semantics/resolve35.f90
index 6acd24f49b5e..7f6a8ea9492b 100644
--- a/test/Semantics/resolve35.f90
+++ b/test/Semantics/resolve35.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Construct names
 
 subroutine s1
diff --git a/test/Semantics/resolve36.f90 b/test/Semantics/resolve36.f90
index e74d6fb62cbf..438ad1aeca92 100644
--- a/test/Semantics/resolve36.f90
+++ b/test/Semantics/resolve36.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m1
   interface
     module subroutine sub1(arg1)
diff --git a/test/Semantics/resolve37.f90 b/test/Semantics/resolve37.f90
index ccc05f3d1715..a07ebbc6625b 100644
--- a/test/Semantics/resolve37.f90
+++ b/test/Semantics/resolve37.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C701 The type-param-value for a kind type parameter shall be a constant
 ! expression.  This constraint looks like a mistake in the standard.
 integer, parameter :: k = 8
diff --git a/test/Semantics/resolve38.f90 b/test/Semantics/resolve38.f90
index ebc29b7c8ed8..53e8db813380 100644
--- a/test/Semantics/resolve38.f90
+++ b/test/Semantics/resolve38.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C772
 module m1
   type t1
diff --git a/test/Semantics/resolve39.f90 b/test/Semantics/resolve39.f90
index a5b50afe2062..d0052f16f863 100644
--- a/test/Semantics/resolve39.f90
+++ b/test/Semantics/resolve39.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   implicit none
   real(8) :: x = 2.0
diff --git a/test/Semantics/resolve40.f90 b/test/Semantics/resolve40.f90
index 1137126740af..95c2c9e8034c 100644
--- a/test/Semantics/resolve40.f90
+++ b/test/Semantics/resolve40.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   namelist /nl/x
   block
diff --git a/test/Semantics/resolve41.f90 b/test/Semantics/resolve41.f90
index 2f618675de60..e2bf877016ed 100644
--- a/test/Semantics/resolve41.f90
+++ b/test/Semantics/resolve41.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m
   implicit none
   real, parameter :: a = 8.0
diff --git a/test/Semantics/resolve42.f90 b/test/Semantics/resolve42.f90
index e71e4c881712..5b6ac9f88b2b 100644
--- a/test/Semantics/resolve42.f90
+++ b/test/Semantics/resolve42.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1
   !ERROR: Array 'z' without ALLOCATABLE or POINTER attribute must have explicit shape
   common x, y(4), z(:)
diff --git a/test/Semantics/resolve43.f90 b/test/Semantics/resolve43.f90
index ed2454a535ec..385dfedc34bd 100644
--- a/test/Semantics/resolve43.f90
+++ b/test/Semantics/resolve43.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Error tests for structure constructors.
 ! Errors caught by expression resolution are tested elsewhere; these are the
 ! errors meant to be caught by name resolution, as well as acceptable use
diff --git a/test/Semantics/resolve44.f90 b/test/Semantics/resolve44.f90
index f6e7a89ba5c3..dd082adc89df 100644
--- a/test/Semantics/resolve44.f90
+++ b/test/Semantics/resolve44.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Error tests for recursive use of derived types.
 
 program main
diff --git a/test/Semantics/resolve45.f90 b/test/Semantics/resolve45.f90
index ebc9e21b5137..e28dc33c4e72 100644
--- a/test/Semantics/resolve45.f90
+++ b/test/Semantics/resolve45.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 function f1(x, y)
   integer x
   !ERROR: SAVE attribute may not be applied to dummy argument 'x'
diff --git a/test/Semantics/resolve46.f90 b/test/Semantics/resolve46.f90
index 8a0385ae28b7..181ccfb5c280 100644
--- a/test/Semantics/resolve46.f90
+++ b/test/Semantics/resolve46.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C1030 - pointers to intrinsic procedures
 program main
   intrinsic :: cos ! a specific & generic intrinsic name
diff --git a/test/Semantics/resolve47.f90 b/test/Semantics/resolve47.f90
index 2c5f8141b967..04dab5616855 100644
--- a/test/Semantics/resolve47.f90
+++ b/test/Semantics/resolve47.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 module m1
   !ERROR: Logical constant '.true.' may not be used as a defined operator
   interface operator(.TRUE.)
diff --git a/test/Semantics/resolve48.f90 b/test/Semantics/resolve48.f90
index ba3dea3c41f1..887505d16442 100644
--- a/test/Semantics/resolve48.f90
+++ b/test/Semantics/resolve48.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test correct use-association of a derived type.
 module m1
   implicit none
diff --git a/test/Semantics/resolve49.f90 b/test/Semantics/resolve49.f90
index ac470834ff91..97d2cbdb1267 100644
--- a/test/Semantics/resolve49.f90
+++ b/test/Semantics/resolve49.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test section subscript
 program p1
   real :: a(10,10)
diff --git a/test/Semantics/resolve50.f90 b/test/Semantics/resolve50.f90
index 7d3ad7e105a3..34d6f1c1d5d5 100644
--- a/test/Semantics/resolve50.f90
+++ b/test/Semantics/resolve50.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test coarray association in CHANGE TEAM statement
 
 subroutine s1
diff --git a/test/Semantics/resolve51.f90 b/test/Semantics/resolve51.f90
index 73dafaa406b5..de763ef49911 100644
--- a/test/Semantics/resolve51.f90
+++ b/test/Semantics/resolve51.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test SELECT TYPE errors: C1157
 
 subroutine s1()
diff --git a/test/Semantics/resolve52.f90 b/test/Semantics/resolve52.f90
index 3ee41dd3503f..846b412f05ca 100644
--- a/test/Semantics/resolve52.f90
+++ b/test/Semantics/resolve52.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Tests for C760:
 ! The passed-object dummy argument shall be a scalar, nonpointer, nonallocatable
 ! dummy data object with the same declared type as the type being defined;
diff --git a/test/Semantics/resolve53.f90 b/test/Semantics/resolve53.f90
index 5cfe16410500..1aee5e79bcc9 100644
--- a/test/Semantics/resolve53.f90
+++ b/test/Semantics/resolve53.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! 15.4.3.4.5 Restrictions on generic declarations
 ! Specific procedures of generic interfaces must be distinguishable.
 
diff --git a/test/Semantics/resolve54.f90 b/test/Semantics/resolve54.f90
index aed15410ddbc..f9f895fa7f05 100644
--- a/test/Semantics/resolve54.f90
+++ b/test/Semantics/resolve54.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Tests based on examples in C.10.6
 
 ! C.10.6(10)
diff --git a/test/Semantics/resolve55.f90 b/test/Semantics/resolve55.f90
index 59f0027d9aef..98006bc0a07b 100644
--- a/test/Semantics/resolve55.f90
+++ b/test/Semantics/resolve55.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Tests for C1128:
 ! A variable-name that appears in a LOCAL or LOCAL_INIT locality-spec shall not
 ! have the ALLOCATABLE; INTENT (IN); or OPTIONAL attribute; shall not be of
diff --git a/test/Semantics/resolve56.f90 b/test/Semantics/resolve56.f90
index 65d5fa2c84b8..1efa535bd434 100644
--- a/test/Semantics/resolve56.f90
+++ b/test/Semantics/resolve56.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test that associations constructs can be correctly combined. The intrinsic
 ! functions are not what is tested here, they are only use to reveal the types
 ! of local variables.
diff --git a/test/Semantics/resolve57.f90 b/test/Semantics/resolve57.f90
index c5e8661206ad..265decd3bcde 100644
--- a/test/Semantics/resolve57.f90
+++ b/test/Semantics/resolve57.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Tests for the last sentence of C1128:
 !A variable-name that is not permitted to appear in a variable definition
 !context shall not appear in a LOCAL or LOCAL_INIT locality-spec.
diff --git a/test/Semantics/resolve58.f90 b/test/Semantics/resolve58.f90
index 00232dc9d843..db11e6779335 100644
--- a/test/Semantics/resolve58.f90
+++ b/test/Semantics/resolve58.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1(x, y)
   !ERROR: Array pointer 'x' must have deferred shape or assumed rank
   real, pointer :: x(1:)  ! C832
diff --git a/test/Semantics/resolve59.f90 b/test/Semantics/resolve59.f90
index e34fcaea01d2..0e6965a5d165 100644
--- a/test/Semantics/resolve59.f90
+++ b/test/Semantics/resolve59.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Testing 15.6.2.2 point 4 (What function-name refers to depending on the
 ! presence of RESULT).
 
diff --git a/test/Semantics/resolve60.f90 b/test/Semantics/resolve60.f90
index 843057d758c8..3232bc0fb87a 100644
--- a/test/Semantics/resolve60.f90
+++ b/test/Semantics/resolve60.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Testing 7.6 enum
 
   ! OK
diff --git a/test/Semantics/resolve61.f90 b/test/Semantics/resolve61.f90
index 727b2643ca5c..eb5ba13a07a3 100644
--- a/test/Semantics/resolve61.f90
+++ b/test/Semantics/resolve61.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 program p1
   integer(8) :: a, b, c, d
   pointer(a, b)
diff --git a/test/Semantics/resolve62.f90 b/test/Semantics/resolve62.f90
index 06c3ed1afe63..5de3a45e900f 100644
--- a/test/Semantics/resolve62.f90
+++ b/test/Semantics/resolve62.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Resolve generic based on number of arguments
 subroutine s1
   interface f
diff --git a/test/Semantics/resolve63.f90 b/test/Semantics/resolve63.f90
index 49b4e7b0d20d..07ae767d676b 100644
--- a/test/Semantics/resolve63.f90
+++ b/test/Semantics/resolve63.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Invalid operand types when user-defined operator is available
 module m1
   type :: t
diff --git a/test/Semantics/resolve64.f90 b/test/Semantics/resolve64.f90
index 360605a000ec..3be2ae14fd5d 100644
--- a/test/Semantics/resolve64.f90
+++ b/test/Semantics/resolve64.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !OPTIONS: -flogical-abbreviations -fxor-operator
 
 ! Like m4 in resolve63 but compiled with different options.
diff --git a/test/Semantics/resolve65.f90 b/test/Semantics/resolve65.f90
index 8c3264cc36f9..9e1278b66dd5 100644
--- a/test/Semantics/resolve65.f90
+++ b/test/Semantics/resolve65.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test restrictions on what subprograms can be used for defined assignment.
 
 module m1
diff --git a/test/Semantics/resolve66.f90 b/test/Semantics/resolve66.f90
index 2b82b5f0ec13..d54fd2bfe66c 100644
--- a/test/Semantics/resolve66.f90
+++ b/test/Semantics/resolve66.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test that user-defined assignment is used in the right places
 
 module m1
diff --git a/test/Semantics/resolve67.f90 b/test/Semantics/resolve67.f90
index 3f2b2572ffc0..7a8537a0a65e 100644
--- a/test/Semantics/resolve67.f90
+++ b/test/Semantics/resolve67.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test restrictions on what subprograms can be used for defined operators.
 ! See: 15.4.3.4.2
 
diff --git a/test/Semantics/resolve68.f90 b/test/Semantics/resolve68.f90
index 06cd13716d43..6accdafd5263 100644
--- a/test/Semantics/resolve68.f90
+++ b/test/Semantics/resolve68.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Test resolution of type-bound generics.
 
 module m1
diff --git a/test/Semantics/resolve69.f90 b/test/Semantics/resolve69.f90
index bf08c3a706b0..3bbc37e3f7aa 100644
--- a/test/Semantics/resolve69.f90
+++ b/test/Semantics/resolve69.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 subroutine s1()
   ! C701 (R701) The type-param-value for a kind type parameter shall be a
   ! constant expression.
diff --git a/test/Semantics/resolve70.f90 b/test/Semantics/resolve70.f90
index 8824ea4249af..31f33c345b63 100644
--- a/test/Semantics/resolve70.f90
+++ b/test/Semantics/resolve70.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C703 (R702) The derived-type-spec shall not specify an abstract type (7.5.7).
 ! This constraint refers to the derived-type-spec in a type-spec.  A type-spec
 ! can appear in an ALLOCATE statement, an ac-spec for an array constructor, and
diff --git a/test/Semantics/resolve71.f90 b/test/Semantics/resolve71.f90
index d570233d4633..8c1c56fd9b0e 100644
--- a/test/Semantics/resolve71.f90
+++ b/test/Semantics/resolve71.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C708 An entity declared with the CLASS keyword shall be a dummy argument 
 ! or have the ALLOCATABLE or POINTER attribute.
 subroutine s()
diff --git a/test/Semantics/resolve72.f90 b/test/Semantics/resolve72.f90
index 6ff2603b2129..284fb2fc2055 100644
--- a/test/Semantics/resolve72.f90
+++ b/test/Semantics/resolve72.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C709 An assumed-type entity shall be a dummy data object that does not have 
 ! the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and 
 ! is not an explicit-shape array.
diff --git a/test/Semantics/resolve73.f90 b/test/Semantics/resolve73.f90
index 191be316b620..35f8429aeacf 100644
--- a/test/Semantics/resolve73.f90
+++ b/test/Semantics/resolve73.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C721 A type-param-value of * shall be used only
 ! * to declare a dummy argument,
 ! * to declare a named constant,
diff --git a/test/Semantics/resolve74.f90 b/test/Semantics/resolve74.f90
index a674b1f37ac2..60927b198769 100644
--- a/test/Semantics/resolve74.f90
+++ b/test/Semantics/resolve74.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C722 A function name shall not be declared with an asterisk type-param-value 
 ! unless it is of type CHARACTER and is the name of a dummy function or the 
 ! name of the result of an external function.
diff --git a/test/Semantics/resolve75.f90 b/test/Semantics/resolve75.f90
index 2c63a36fe523..708ce8ffaeec 100644
--- a/test/Semantics/resolve75.f90
+++ b/test/Semantics/resolve75.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! C726 The length specified for a character statement function or for a 
 ! statement function dummy argument of type character shall be a constant 
 ! expression.
diff --git a/test/Semantics/separate-module-procs.f90 b/test/Semantics/separate-module-procs.f90
index ba3b1abcc991..33dfcd557fde 100644
--- a/test/Semantics/separate-module-procs.f90
+++ b/test/Semantics/separate-module-procs.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 !===--- separate-module-procs.f90 - Test separate module procedure ---------===
 !
 ! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
diff --git a/test/Semantics/stop01.f90 b/test/Semantics/stop01.f90
index 91112b11a801..2ae8d65a84bb 100644
--- a/test/Semantics/stop01.f90
+++ b/test/Semantics/stop01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 program main
   implicit none
   integer :: i = -1
diff --git a/test/Semantics/structconst01.f90 b/test/Semantics/structconst01.f90
index a83286c422ab..68f0261cd85d 100644
--- a/test/Semantics/structconst01.f90
+++ b/test/Semantics/structconst01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Error tests for structure constructors.
 ! Errors caught by name resolution are tested elsewhere; these are the
 ! errors meant to be caught by expression semantic analysis, as well as
diff --git a/test/Semantics/structconst02.f90 b/test/Semantics/structconst02.f90
index 923aa6071b09..22428651fa1c 100644
--- a/test/Semantics/structconst02.f90
+++ b/test/Semantics/structconst02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Error tests for structure constructors: per-component type
 ! (in)compatibility.
 
diff --git a/test/Semantics/structconst03.f90 b/test/Semantics/structconst03.f90
index e637bc08d3e3..776b4d082309 100644
--- a/test/Semantics/structconst03.f90
+++ b/test/Semantics/structconst03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Error tests for structure constructors: C1594 violations
 ! from assigning globally-visible data to POINTER components.
 ! test/Semantics/structconst04.f90 is this same test without type
diff --git a/test/Semantics/structconst04.f90 b/test/Semantics/structconst04.f90
index a2d7421945f4..07a9d69df868 100644
--- a/test/Semantics/structconst04.f90
+++ b/test/Semantics/structconst04.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_errors.sh %s %flang %t
 ! Error tests for structure constructors: C1594 violations
 ! from assigning globally-visible data to POINTER components.
 ! This test is structconst03.f90 with the type parameters removed.
diff --git a/test/Semantics/symbol01.f90 b/test/Semantics/symbol01.f90
index 7a6476dddded..9d8cacd3d6b8 100644
--- a/test/Semantics/symbol01.f90
+++ b/test/Semantics/symbol01.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Test that intent-stmt and subprogram prefix and suffix are resolved.
 
 !DEF: /m Module
diff --git a/test/Semantics/symbol02.f90 b/test/Semantics/symbol02.f90
index ba048a20ef91..8f53c50580ed 100644
--- a/test/Semantics/symbol02.f90
+++ b/test/Semantics/symbol02.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Test host association in module subroutine and internal subroutine.
 
 !DEF: /m Module
diff --git a/test/Semantics/symbol03.f90 b/test/Semantics/symbol03.f90
index 778794c1a14d..41a7cc26e694 100644
--- a/test/Semantics/symbol03.f90
+++ b/test/Semantics/symbol03.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Test host association in internal subroutine of main program.
 
 !DEF: /main MainProgram
diff --git a/test/Semantics/symbol05.f90 b/test/Semantics/symbol05.f90
index 4bc42aca6296..678b8f19f55d 100644
--- a/test/Semantics/symbol05.f90
+++ b/test/Semantics/symbol05.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Explicit and implicit entities in blocks
 
 !DEF: /s1 (Subroutine) Subprogram
diff --git a/test/Semantics/symbol06.f90 b/test/Semantics/symbol06.f90
index 804017bbdf13..b3b3e17b10da 100644
--- a/test/Semantics/symbol06.f90
+++ b/test/Semantics/symbol06.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !DEF: /main MainProgram
 program main
  !DEF: /main/t1 DerivedType
diff --git a/test/Semantics/symbol07.f90 b/test/Semantics/symbol07.f90
index 787dfc5b0ec7..b387ec6c673b 100644
--- a/test/Semantics/symbol07.f90
+++ b/test/Semantics/symbol07.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !DEF: /main MainProgram
 program main
  implicit complex(z)
diff --git a/test/Semantics/symbol08.f90 b/test/Semantics/symbol08.f90
index e0a65b84e7bb..801f7f449b20 100644
--- a/test/Semantics/symbol08.f90
+++ b/test/Semantics/symbol08.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !DEF: /main MainProgram
 program main
  !DEF: /main/x POINTER ObjectEntity REAL(4)
diff --git a/test/Semantics/symbol09.f90 b/test/Semantics/symbol09.f90
index 8dca1332a538..77d4a3416df3 100644
--- a/test/Semantics/symbol09.f90
+++ b/test/Semantics/symbol09.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !DEF: /s1 (Subroutine) Subprogram
 subroutine s1
  !DEF: /s1/a ObjectEntity REAL(4)
diff --git a/test/Semantics/symbol10.f90 b/test/Semantics/symbol10.f90
index c9cf1ce6148a..e487764fa5a2 100644
--- a/test/Semantics/symbol10.f90
+++ b/test/Semantics/symbol10.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !DEF: /m1 Module
 module m1
 contains
diff --git a/test/Semantics/symbol11.f90 b/test/Semantics/symbol11.f90
index d3312eaa293b..e759310c8dcb 100644
--- a/test/Semantics/symbol11.f90
+++ b/test/Semantics/symbol11.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 !DEF: /s1 (Subroutine) Subprogram
 subroutine s1
  implicit none
diff --git a/test/Semantics/symbol12.f90 b/test/Semantics/symbol12.f90
index e13c09542720..22350f6c25e2 100644
--- a/test/Semantics/symbol12.f90
+++ b/test/Semantics/symbol12.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Verify that SAVE attribute is propagated by EQUIVALENCE
 
 !DEF: /s1 (Subroutine) Subprogram
diff --git a/test/Semantics/symbol13.f90 b/test/Semantics/symbol13.f90
index 76235db206da..640066ed76ea 100644
--- a/test/Semantics/symbol13.f90
+++ b/test/Semantics/symbol13.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Old-style "*length" specifiers (R723)
 
 !DEF: /f1 (Function) Subprogram CHARACTER(1_8,1)
diff --git a/test/Semantics/symbol14.f90 b/test/Semantics/symbol14.f90
index c990665e8d6e..d523e8d6f480 100644
--- a/test/Semantics/symbol14.f90
+++ b/test/Semantics/symbol14.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! "Bare" uses of type parameters and components
 
  !DEF: /MainProgram1/t1 DerivedType
diff --git a/test/Semantics/symbol15.f90 b/test/Semantics/symbol15.f90
index 4ad09b395ffc..00298cfa1d84 100644
--- a/test/Semantics/symbol15.f90
+++ b/test/Semantics/symbol15.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Forward references in pointer initializers and TBP bindings.
 
 !DEF: /m Module
diff --git a/test/Semantics/symbol16.f90 b/test/Semantics/symbol16.f90
index a90ab83d2ac1..0650222e0833 100644
--- a/test/Semantics/symbol16.f90
+++ b/test/Semantics/symbol16.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Statement functions
 
 !DEF: /p1 MainProgram
diff --git a/test/Semantics/symbol17.f90 b/test/Semantics/symbol17.f90
index a861e2f6f260..a99c8245f6d7 100644
--- a/test/Semantics/symbol17.f90
+++ b/test/Semantics/symbol17.f90
@@ -1,3 +1,4 @@
+! RUN: %S/test_symbols.sh %s %flang %t
 ! Forward references to derived types (non-error cases)
 
 !DEF: /main MainProgram

From 3f99d35f3d4f57f704fd91a0d6ba8af308e900b3 Mon Sep 17 00:00:00 2001
From: Luke Ireland <luke.ireland@arm.com>
Date: Fri, 6 Mar 2020 11:21:36 +0000
Subject: [PATCH 087/345] Added CMakeLists changes, moved config and made test
 scripts compatible.

All Fortran tests are now run in lit, except Preprocessing tests #1052
Preprocessing tests are a separate kind of test, so will be sorted out
later.
---
 CMakeLists.txt                        |   2 +-
 {test-lit => test}/CMakeLists.txt     |   0
 test/Evaluate/test_folding.sh         |  21 +-
 test/Preprocessing/lit.local.cfg.py   |   7 +
 test/Semantics/CMakeLists.txt         | 346 --------------------------
 test/Semantics/common.sh              |  17 +-
 test/Semantics/test_any.sh            |   4 +-
 {test-lit => test}/lit.cfg.py         |  14 +-
 {test-lit => test}/lit.site.cfg.py.in |   2 +-
 9 files changed, 33 insertions(+), 380 deletions(-)
 rename {test-lit => test}/CMakeLists.txt (100%)
 create mode 100644 test/Preprocessing/lit.local.cfg.py
 delete mode 100644 test/Semantics/CMakeLists.txt
 rename {test-lit => test}/lit.cfg.py (91%)
 rename {test-lit => test}/lit.site.cfg.py.in (92%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f19259df77e1..8883fb7e7597 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -156,7 +156,7 @@ add_subdirectory(lib)
 add_subdirectory(runtime)
 add_subdirectory(unittests)
 add_subdirectory(tools)
-add_subdirectory(test-lit)
+add_subdirectory(test)
 
 configure_file(
   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
diff --git a/test-lit/CMakeLists.txt b/test/CMakeLists.txt
similarity index 100%
rename from test-lit/CMakeLists.txt
rename to test/CMakeLists.txt
diff --git a/test/Evaluate/test_folding.sh b/test/Evaluate/test_folding.sh
index 84b10eb23609..3834c21edad7 100755
--- a/test/Evaluate/test_folding.sh
+++ b/test/Evaluate/test_folding.sh
@@ -19,28 +19,25 @@
 #   - test_x is not folded (it is neither .true. nor .false.). This means the
 #     compiler could not fold the expression.
 
-PATH=/usr/bin:/bin
-srcdir=$(dirname $0)
-F18CC=${F18:-../../../tools/f18/bin/f18}
-CMD="$F18CC -fdebug-dump-symbols -fparse-only"
+CMD="$2 -fdebug-dump-symbols -fparse-only"
 
-if [[ $# < 1 ]]; then
-  echo "Usage: $0 <fortran-source> [-pgmath=<true/false>]"
+if [[ $# < 3 ]]; then
+  echo "Usage: $0 <fortran-source> <f18-executable> <temp test dir>"
   exit 1
 fi
 
-src=$srcdir/$1
+src=$1
 [[ ! -f $src ]] && echo "File not found: $src" && exit 1
 
-temp=temp-$1
-rm -rf $temp
-mkdir $temp
-[[ $KEEP ]] || trap "rm -rf $temp" EXIT
+temp=$3
+mkdir -p $temp
 
 # Check if tests should assume folding is using libpgmath
-if [[ $# > 1 && "$2" = "-pgmath=true" ]]; then
+if [[ $LIBPGMATH ]]; then
   CMD="$CMD -DTEST_LIBPGMATH"
   echo "Assuming libpgmath support"
+else
+  echo "Not assuming libpgmath support"
 fi
 
 src1=$temp/symbols.log
diff --git a/test/Preprocessing/lit.local.cfg.py b/test/Preprocessing/lit.local.cfg.py
new file mode 100644
index 000000000000..a7cf401d8c66
--- /dev/null
+++ b/test/Preprocessing/lit.local.cfg.py
@@ -0,0 +1,7 @@
+# -*- Python -*-
+
+from lit.llvm import llvm_config
+
+# Added this line file to prevent lit from discovering these tests
+# See Issue #1052
+config.suffixes = []
diff --git a/test/Semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
deleted file mode 100644
index a24108782ae7..000000000000
--- a/test/Semantics/CMakeLists.txt
+++ /dev/null
@@ -1,346 +0,0 @@
-#===-- test/Semantics/CMakeLists.txt ---------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
-# Run tests with test_errors.sh. It compiles the test with f18 and compares
-# actual errors produced with expected ones listed in the source.
-
-# These test files have expected errors in the source
-set(ERROR_TESTS
-  implicit01.f90
-  implicit02.f90
-  implicit03.f90
-  implicit04.f90
-  implicit05.f90
-  implicit06.f90
-  implicit07.f90
-  implicit08.f90
-  int-literals.f90
-  io01.f90
-  io02.f90
-  io03.f90
-  io04.f90
-  io05.f90
-  io06.f90
-  io07.f90
-  io08.f90
-  io09.f90
-  io10.f90
-  kinds02.f90
-  kinds04.f90
-  resolve01.f90
-  resolve02.f90
-  resolve03.f90
-  resolve04.f90
-  resolve05.f90
-  resolve06.f90
-  resolve07.f90
-  resolve08.f90
-  resolve09.f90
-  resolve10.f90
-  resolve11.f90
-  resolve12.f90
-  resolve13.f90
-  resolve14.f90
-  resolve15.f90
-  resolve16.f90
-  resolve17.f90
-  resolve18.f90
-  resolve19.f90
-  resolve20.f90
-  resolve21.f90
-  resolve22.f90
-  resolve23.f90
-  resolve24.f90
-  resolve25.f90
-  resolve26.f90
-  resolve27.f90
-  resolve28.f90
-  resolve29.f90
-  resolve30.f90
-  resolve31.f90
-  resolve32.f90
-  resolve33.f90
-  resolve34.f90
-  resolve35.f90
-  resolve36.f90
-  resolve37.f90
-  resolve38.f90
-  resolve39.f90
-  resolve40.f90
-  resolve41.f90
-  resolve42.f90
-  resolve43.f90
-  resolve44.f90
-  resolve45.f90
-  resolve46.f90
-  resolve47.f90
-  resolve48.f90
-  resolve49.f90
-  resolve50.f90
-  resolve51.f90
-  resolve52.f90
-  resolve53.f90
-  resolve54.f90
-  resolve55.f90
-  resolve56.f90
-  resolve57.f90
-  resolve58.f90
-  resolve59.f90
-  resolve60.f90
-  resolve61.f90
-  resolve62.f90
-  resolve63.f90
-  resolve64.f90
-  resolve65.f90
-  resolve66.f90
-  resolve67.f90
-  resolve68.f90
-  resolve69.f90
-  resolve70.f90
-  resolve71.f90
-  resolve72.f90
-  resolve73.f90
-  resolve74.f90
-  resolve75.f90
-  stop01.f90
-  structconst01.f90
-  structconst02.f90
-  structconst03.f90
-  structconst04.f90
-  assign01.f90
-  assign02.f90
-  assign03.f90
-  assign04.f90
-  if_arith02.f90
-  if_arith03.f90
-  if_arith04.f90
-  if_construct02.f90
-  if_stmt02.f90
-  if_stmt03.f90
-  computed-goto01.f90
-  computed-goto02.f90
-  nullify01.f90
-  nullify02.f90
-  deallocate01.f90
-  deallocate04.f90
-  deallocate05.f90
-  coarrays01.f90
-  altreturn01.f90
-  altreturn02.f90
-  altreturn03.f90
-  altreturn04.f90
-  altreturn05.f90
-  allocate01.f90
-  allocate02.f90
-  allocate03.f90
-  allocate04.f90
-  allocate05.f90
-  allocate06.f90
-  allocate07.f90
-  allocate08.f90
-  allocate09.f90
-  allocate10.f90
-  allocate11.f90
-  allocate12.f90
-  allocate13.f90
-  doconcurrent01.f90
-  doconcurrent05.f90
-  doconcurrent06.f90
-  doconcurrent08.f90
-  dosemantics01.f90
-  dosemantics02.f90
-  dosemantics03.f90
-  dosemantics04.f90
-  dosemantics05.f90
-  dosemantics06.f90
-  dosemantics07.f90
-  dosemantics08.f90
-  dosemantics09.f90
-  dosemantics10.f90
-  dosemantics11.f90
-  dosemantics12.f90
-  expr-errors01.f90
-  expr-errors02.f90
-  null01.f90
-  omp-resolve01.f90
-  omp-resolve02.f90
-  omp-resolve03.f90
-  omp-resolve04.f90
-  omp-resolve05.f90
-  omp-clause-validity01.f90
-  omp-loop-association.f90
-#  omp-nested01.f90
-  omp-declarative-directive.f90
-  omp-atomic.f90
-  omp-device-constructs.f90
-  equivalence01.f90
-  init01.f90
-  if_arith01.f90
-  if_construct01.f90
-  if_stmt01.f90
-  blockconstruct01.f90
-  blockconstruct02.f90
-  blockconstruct03.f90
-  call01.f90
-  call02.f90
-  call03.f90
-  call04.f90
-  call05.f90
-  call06.f90
-  call07.f90
-  call08.f90
-  call09.f90
-  call10.f90
-  call11.f90
-  call12.f90
-  call13.f90
-  call14.f90
-  call15.f90
-  forall01.f90
-  misc-declarations.f90
-  separate-module-procs.f90
-  bindings01.f90
-  bad-forward-type.f90
-  c_f_pointer.f90
-  critical01.f90
-  critical02.f90
-  critical03.f90
-  block-data01.f90
-  complex01.f90
-  data01.f90
-  data02.f90
-  namelist01.f90
-)
-
-# These test files have expected symbols in the source
-set(SYMBOL_TESTS
-  symbol01.f90
-  symbol02.f90
-  symbol03.f90
-  symbol05.f90
-  symbol06.f90
-  symbol07.f90
-  symbol08.f90
-  symbol09.f90
-  symbol10.f90
-  symbol11.f90
-  symbol12.f90
-  symbol13.f90
-  symbol14.f90
-  symbol15.f90
-  symbol16.f90
-  symbol17.f90
-  omp-symbol01.f90
-  omp-symbol02.f90
-  omp-symbol03.f90
-  omp-symbol04.f90
-  omp-symbol05.f90
-  omp-symbol06.f90
-  omp-symbol07.f90
-  omp-symbol08.f90
-  kinds01.f90
-  kinds03.f90
-  procinterface01.f90
-)
-
-# These test files have expected .mod file contents in the source
-set(MODFILE_TESTS
-  modfile01.f90
-  modfile02.f90
-  modfile03.f90
-  modfile04.f90
-  modfile05.f90
-  modfile06.f90
-  modfile07.f90
-  modfile08.f90
-  modfile09-*.f90
-  modfile10.f90
-  modfile11.f90
-  modfile12.f90
-  modfile13.f90
-  modfile14.f90
-  modfile15.f90
-  modfile16.f90
-  modfile17.f90
-  modfile18.f90
-  modfile19.f90
-  modfile20.f90
-  modfile21.f90
-  modfile22.f90
-  modfile23.f90
-  modfile24.f90
-  modfile25.f90
-  modfile26.f90
-  modfile27.f90
-  modfile28.f90
-  modfile29.f90
-  modfile30.f90
-  modfile31.f90
-  modfile32.f90
-  modfile33.f90
-  modfile34.f90
-  modfile35.f90
-)
-
-set(LABEL_TESTS
-  label*.[Ff]90
-)
-
-set(DOCONCURRENT_TESTS
-  doconcurrent02.f90
-  doconcurrent03.f90
-  doconcurrent04.f90
-  doconcurrent07.f90
-)
-
-set(CANONDO_TESTS
-  canondo*.[Ff]90
-)
-
-set(CRITICAL_TESTS
-  critical04.f90
-)
-
-set(GETSYMBOLS_TESTS
-  getsymbols01.f90
-  getsymbols02-*.f90
-  getsymbols03-a.f90
-  getsymbols04.f90
-  getsymbols05.f90
-)
-
-set(GETDEFINITION_TESTS
-  getdefinition01.f90
-  getdefinition02.f
-  getdefinition03-a.f90
-  getdefinition04.f90
-  getdefinition05.f90
-)
-
-set(F18 $<TARGET_FILE:f18>)
-
-foreach(test ${ERROR_TESTS})
-  add_test(NAME ${test}
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test_errors.sh ${test} ${F18})
-endforeach()
-
-foreach(test ${SYMBOL_TESTS})
-  add_test(NAME ${test}
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test_symbols.sh ${test} ${F18})
-endforeach()
-
-foreach(test ${MODFILE_TESTS})
-  add_test(NAME ${test}
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test_modfile.sh ${test} ${F18})
-endforeach()
-
-foreach(test ${LABEL_TESTS} ${CANONDO_TESTS} ${DOCONCURRENT_TESTS}
-             ${CRITICAL_TESTS} ${GETSYMBOLS_TESTS} ${GETDEFINITION_TESTS})
-  add_test(NAME ${test}
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test_any.sh ${test} ${F18})
-endforeach()
diff --git a/test/Semantics/common.sh b/test/Semantics/common.sh
index e84d9b933631..02ccb32fd5f0 100644
--- a/test/Semantics/common.sh
+++ b/test/Semantics/common.sh
@@ -10,19 +10,18 @@ function die {
   echo "$(basename $0): $*" >&2
   exit 1
 }
+if [[ $# < 3 ]]; then
+  echo "Usage: $(basename $0) <fortran-source> <f18-executable> <temp test dir>"
+  exit 1
+fi
 
-case $# in
-  (1) ;;
-  (2) F18=$2 ;;
-  (*) echo "Usage: $(basename $0) <fortran-source> [<f18-executable>]"; exit 1
-esac
-[[ -z ${F18+x} ]] && die "Path to f18 must be second argument or in F18 environment variable"
-[[ ! -f $F18 ]] && die "f18 executable not found: $F18"
 case $1 in
   (/*) src=$1 ;;
   (*) src=$(dirname $0)/$1 ;;
 esac
 USER_OPTIONS=`sed -n 's/^ *! *OPTIONS: *//p' $src`
 echo $USER_OPTIONS
-temp=`mktemp -d ./tmp.XXXXXX`
-[[ $KEEP ]] || trap "rm -rf $temp" EXIT
+F18=$2
+[[ ! -f $F18 ]] && die "f18 executable not found: $F18"
+temp=$3
+mkdir -p $temp
diff --git a/test/Semantics/test_any.sh b/test/Semantics/test_any.sh
index 71f42889911a..b0735935928f 100755
--- a/test/Semantics/test_any.sh
+++ b/test/Semantics/test_any.sh
@@ -48,9 +48,9 @@ function internal_check() {
 }
 
 gr=0
-for input in ${srcdir}/$*; do
+for input in $1; do
   [[ ! -f $input ]] && die "File not found: $input"
-  CMD=$(cat ${input} | egrep '^[[:space:]]*![[:space:]]*RUN:[[:space:]]*' | sed -e 's/^[[:space:]]*![[:space:]]*RUN:[[:space:]]*//')
+  CMD=$(cat ${input} | egrep '^[[:space:]]*![[:space:]]*EXEC:[[:space:]]*' | sed -e 's/^[[:space:]]*![[:space:]]*EXEC:[[:space:]]*//')
   CMD=$(echo ${CMD} | sed -e "s:%s:${input}:g")
   if egrep -q -e '%t' <<< ${CMD} ; then
     CMD=$(echo ${CMD} | sed -e "s:%t:$temp/t:g")
diff --git a/test-lit/lit.cfg.py b/test/lit.cfg.py
similarity index 91%
rename from test-lit/lit.cfg.py
rename to test/lit.cfg.py
index 2dce888c33fd..57dc7383d88b 100644
--- a/test-lit/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -24,19 +24,11 @@
 # the test runner updated.
 config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
 
-
 # suffixes: A list of file extensions to treat as test files.
 config.suffixes = ['.f', '.F', '.ff','.FOR', '.for', '.f77', '.f90', '.F90',
                    '.ff90', '.f95', '.F95', '.ff95', '.fpp', '.FPP', '.cuf',
                    '.CUF', '.f18', '.F18', '.fir' ]
 
-# test_source_root: The root path where tests are located.
-config.test_source_root = os.path.dirname(__file__)
-
-
-# test_exec_root: The root path where tests should be run.
-config.test_exec_root = os.path.join(config.flang_obj_root, 'test-lit')
-
 config.substitutions.append(('%PATH%', config.environment['PATH']))
 
 llvm_config.use_default_substitutions()
@@ -50,7 +42,7 @@
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
-config.test_exec_root = os.path.join(config.flang_obj_root, 'test-lit')
+config.test_exec_root = os.path.join(config.flang_obj_root, 'test')
 
 # Tweak the PATH to include the tools dir.
 llvm_config.with_environment('PATH', config.flang_tools_dir, append_path=True)
@@ -76,3 +68,7 @@
 
 llvm_config.add_tool_substitutions(tools, tool_dirs)
 
+# Enable libpgmath testing
+result = lit_config.params.get("LIBPGMATH")
+if result:
+    config.environment["LIBPGMATH"] = True
\ No newline at end of file
diff --git a/test-lit/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
similarity index 92%
rename from test-lit/lit.site.cfg.py.in
rename to test/lit.site.cfg.py.in
index fe428f9bee06..92bd926ab5ca 100644
--- a/test-lit/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -24,4 +24,4 @@ import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
-lit_config.load_config(config, "@FLANG_SOURCE_DIR@/test-lit/lit.cfg.py")
+lit_config.load_config(config, "@FLANG_SOURCE_DIR@/test/lit.cfg.py")

From 9625317ee8aed40a3827fe551cecf08aa34ee7a2 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Fri, 13 Mar 2020 09:52:15 -0700
Subject: [PATCH 088/345] Complete formatting of pointer assignments, move to
 formatting.cpp with rest of AsFortran

---
 lib/Evaluate/expression.cpp | 36 ------------------------------------
 lib/Evaluate/formatting.cpp | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/lib/Evaluate/expression.cpp b/lib/Evaluate/expression.cpp
index 11ba35dbb8ec..18646e4f19e6 100644
--- a/lib/Evaluate/expression.cpp
+++ b/lib/Evaluate/expression.cpp
@@ -222,42 +222,6 @@ StructureConstructor &StructureConstructor::Add(
 
 GenericExprWrapper::~GenericExprWrapper() {}
 
-std::ostream &Assignment::AsFortran(std::ostream &o) const {
-  std::visit(
-      common::visitors{
-          [&](const Assignment::Intrinsic &) {
-            rhs.AsFortran(lhs.AsFortran(o) << '=');
-          },
-          [&](const ProcedureRef &proc) { proc.AsFortran(o << "CALL "); },
-          [&](const BoundsSpec &bounds) {
-            lhs.AsFortran(o);
-            if (!bounds.empty()) {
-              char sep{'('};
-              for (const auto &bound : bounds) {
-                bound.AsFortran(o << sep) << ':';
-                sep = ',';
-              }
-              o << ')';
-            }
-          },
-          [&](const BoundsRemapping &bounds) {
-            lhs.AsFortran(o);
-            if (!bounds.empty()) {
-              char sep{'('};
-              for (const auto &bound : bounds) {
-                bound.first.AsFortran(o << sep) << ':';
-                bound.second.AsFortran(o);
-                sep = ',';
-              }
-              o << ')';
-            }
-            rhs.AsFortran(o << " => ");
-          },
-      },
-      u);
-  return o;
-}
-
 GenericAssignmentWrapper::~GenericAssignmentWrapper() {}
 
 template<TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
diff --git a/lib/Evaluate/formatting.cpp b/lib/Evaluate/formatting.cpp
index 0b397c92590b..560bfc532973 100644
--- a/lib/Evaluate/formatting.cpp
+++ b/lib/Evaluate/formatting.cpp
@@ -718,6 +718,43 @@ std::ostream &DescriptorInquiry::AsFortran(std::ostream &o) const {
   }
 }
 
+std::ostream &Assignment::AsFortran(std::ostream &o) const {
+  std::visit(
+      common::visitors{
+          [&](const Assignment::Intrinsic &) {
+            rhs.AsFortran(lhs.AsFortran(o) << '=');
+          },
+          [&](const ProcedureRef &proc) { proc.AsFortran(o << "CALL "); },
+          [&](const BoundsSpec &bounds) {
+            lhs.AsFortran(o);
+            if (!bounds.empty()) {
+              char sep{'('};
+              for (const auto &bound : bounds) {
+                bound.AsFortran(o << sep) << ':';
+                sep = ',';
+              }
+              o << ')';
+            }
+            rhs.AsFortran(o << " => ");
+          },
+          [&](const BoundsRemapping &bounds) {
+            lhs.AsFortran(o);
+            if (!bounds.empty()) {
+              char sep{'('};
+              for (const auto &bound : bounds) {
+                bound.first.AsFortran(o << sep) << ':';
+                bound.second.AsFortran(o);
+                sep = ',';
+              }
+              o << ')';
+            }
+            rhs.AsFortran(o << " => ");
+          },
+      },
+      u);
+  return o;
+}
+
 INSTANTIATE_CONSTANT_TEMPLATES
 INSTANTIATE_EXPRESSION_TEMPLATES
 INSTANTIATE_VARIABLE_TEMPLATES

From 688512ddc671fa1ed54224b7cfef49a1c2284c99 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Thu, 12 Mar 2020 17:07:16 -0700
Subject: [PATCH 089/345] more edits

Remove AllocateDefaultCharacter

Refinements in code review
---
 runtime/allocatable.h | 115 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 115 insertions(+)
 create mode 100644 runtime/allocatable.h

diff --git a/runtime/allocatable.h b/runtime/allocatable.h
new file mode 100644
index 000000000000..bcb70356f322
--- /dev/null
+++ b/runtime/allocatable.h
@@ -0,0 +1,115 @@
+//===-- runtime/allocatable.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 Fortran runtime library support of code generated
+// to manipulate and query allocatable variables, dummy arguments, & components.
+#ifndef FORTRAN_RUNTIME_ALLOCATABLE_H_
+#define FORTRAN_RUNTIME_ALLOCATABLE_H_
+#include "descriptor.h"
+#include "entry-names.h"
+
+namespace Fortran::runtime {
+extern "C" {
+
+// Initializes the descriptor for an allocatable of intrinsic or derived type.
+// The incoming descriptor is treated as (and can be) uninitialized garbage.
+// Must be called for each allocatable variable as its scope comes into being.
+// The storage for the allocatable's descriptor must have already been
+// allocated to a size sufficient for the rank, corank, and type.
+// A descriptor must be initialized before being used for any purpose,
+// but needs reinitialization in a deallocated state only when there is
+// a change of type, rank, or corank.
+void RTNAME(AllocatableInitIntrinsic)(
+    Descriptor &, TypeCategory, int kind, int rank = 0, int corank = 0);
+void RTNAME(AllocatableInitCharacter)(Descriptor &, SubscriptValue length,
+    int kind = 1, int rank = 0, int corank = 0);
+void RTNAME(AllocatableInitDerived)(
+    Descriptor &, const DerivedType &, int rank = 0, int corank = 0);
+
+// Checks that an allocatable is not already allocated in statements
+// with STAT=.  Use this on a value descriptor before setting bounds or
+// type parameters.  Not necessary on a freshly initialized descriptor.
+// (If there's no STAT=, the error will be caught later anyway, but
+// this API allows the error to be caught before descriptor is modified.)
+// Return 0 on success (deallocated state), else the STAT= value.
+int RTNAME(AllocatableCheckAllocated)(Descriptor &,
+    Descriptor *errMsg = nullptr, const char *sourceFile = nullptr,
+    int sourceLine = 0);
+
+// For MOLD= allocation; sets bounds, cobounds, and length type
+// parameters from another descriptor.  The destination descriptor must
+// be initialized and deallocated.
+void RTNAME(AllocatableApplyMold)(Descriptor &, const Descriptor &mold);
+
+// Explicitly sets the bounds and length type parameters of an initialized
+// deallocated allocatable.
+void RTNAME(AllocatableSetBounds)(
+    Descriptor &, int zeroBasedDim, SubscriptValue lower, SubscriptValue upper);
+
+// The upper bound is ignored for the last codimension.
+void RTNAME(AllocatableSetCoBounds)(Descriptor &, int zeroBasedCoDim,
+    SubscriptValue lower, SubscriptValue upper = 0);
+
+// Length type parameters are indexed in declaration order; i.e., 0 is the
+// first length type parameter in the deepest base type.  (Not for use
+// with CHARACTER; see above.)
+void RTNAME(AllocatableSetDerivedLength)(
+    Descriptor &, int which, SubscriptValue);
+
+// When an explicit type-spec appears in an ALLOCATE statement for an
+// allocatable with an explicit (non-deferred) length type paramater for
+// a derived type or CHARACTER value, the explicit value has to match
+// the length type parameter's value.  This API checks that requirement.
+// Returns 0 for success, or the STAT= value on failure with hasStat==true.
+int RTNAME(AllocatableCheckLengthParameter)(Descriptor &,
+    int which /* 0 for CHARACTER length */, SubscriptValue other,
+    bool hasStat = false, Descriptor *errMsg = nullptr,
+    const char *sourceFile = nullptr, int sourceLine = 0);
+
+// Allocates an allocatable.  The allocatable descriptor must have been
+// initialized and its bounds and length type parameters set and must be
+// in a deallocated state.
+// On failure, if hasStat is true, returns a nonzero error code for
+// STAT= and (if present) fills in errMsg; if hasStat is false, the
+// image is terminated.  On success, leaves errMsg alone and returns zero.
+// Successfully allocated memory is initialized if the allocatable has a
+// derived type, and is always initialized by AllocatableAllocateSource().
+// Performs all necessary coarray synchronization and validation actions.
+int RTNAME(AllocatableAllocate)(Descriptor &, bool hasStat = false,
+    Descriptor *errMsg = nullptr, const char *sourceFile = nullptr,
+    int sourceLine = 0);
+int RTNAME(AllocatableAllocateSource)(Descriptor &, const Descriptor &source,
+    bool hasStat = false, Descriptor *errMsg = nullptr,
+    const char *sourceFile = nullptr, int sourceLine = 0);
+
+// Assigns to a whole allocatable, with automatic (re)allocation when the
+// destination is unallocated or nonconforming (Fortran 2003 semantics).
+// The descriptor must be initialized.
+// Recursively assigns components with (re)allocation as necessary.
+// TODO: Consider renaming to a more general name that will work for
+// assignments to pointers, dummy arguments, and anything else with a
+// descriptor.
+void RTNAME(AllocatableAssignment)(Descriptor &to, const Descriptor &from);
+
+// Implements the intrinsic subroutine MOVE_ALLOC (16.9.137 in F'2018,
+// but note the order of first two arguments is reversed for consistency
+// with the other APIs for allocatables.)  The destination descriptor
+// must be initialized.
+int RTNAME(MoveAlloc)(Descriptor &to, const Descriptor &from,
+    bool hasStat = false, Descriptor *errMsg = nullptr,
+    const char *sourceFile = nullptr, int sourceLine = 0);
+
+// Deallocates an allocatable.  Finalizes elements &/or components as needed.
+// The allocatable is left in an initialized state suitable for reallocation
+// with the same bounds, cobounds, and length type parameters.
+int RTNAME(AllocatableDeallocate)(Descriptor &, bool hasStat = false,
+    Descriptor *errMsg = nullptr, const char *sourceFile = nullptr,
+    int sourceLine = 0);
+}
+}
+#endif  // FORTRAN_RUNTIME_ALLOCATABLE_H_

From c351181cabb234f73cb09c23e45dfe0bfc2d7219 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Mon, 16 Mar 2020 10:46:17 -0700
Subject: [PATCH 090/345] Test cleanup

Fix omp-nested01.f90 so that it is not an expected failure. The test was
never enabled but I'm guessing this is what it's supposed to do.

Fix the instructions to include "make test" as part of running tests.
---
 README.md                       | 2 +-
 test/Semantics/omp-nested01.f90 | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 9df131d7f325..d8e2cbdef63b 100644
--- a/README.md
+++ b/README.md
@@ -224,7 +224,7 @@ To run all tests:
 ```
 cd ~/f18/build
 cmake -DLLVM_DIR=$LLVM ~/f18/src
-make check-all
+make test check-all
 ```
 
 To run individual regression tests llvm-lit needs to know the lit
diff --git a/test/Semantics/omp-nested01.f90 b/test/Semantics/omp-nested01.f90
index 0e7220222217..1c0e84ab8fd9 100644
--- a/test/Semantics/omp-nested01.f90
+++ b/test/Semantics/omp-nested01.f90
@@ -1,5 +1,4 @@
 ! RUN: %S/test_errors.sh %s %flang %t
-!XFAIL: *
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP 2.17 Nesting of Regions
@@ -9,7 +8,7 @@
   do i = 1, N
      !ERROR: A worksharing region may not be closely nested inside a worksharing, explicit task, taskloop, critical, ordered, atomic, or master region
      !$omp do
-     do i = 1, N
+     do j = 1, N
         a = 3.14
      enddo
   enddo

From 4a3db55727a93805d3f047713e5d253543ee51fa Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Tue, 17 Mar 2020 12:35:31 -0700
Subject: [PATCH 091/345] Do not emit a prefix for a default-kind character
 constant in AsFortran

---
 include/flang/Evaluate/formatting.h |  2 --
 lib/Evaluate/formatting.cpp         |  4 +---
 test/Semantics/modfile16.f90        | 14 +++++++-------
 test/Semantics/modfile20.f90        |  2 +-
 test/Semantics/modfile21.f90        |  2 +-
 test/Semantics/modfile22.f90        |  4 ++--
 test/Semantics/modfile28.f90        |  2 +-
 test/Semantics/modfile30.f90        |  4 ++--
 tools/f18/f18.cpp                   |  2 --
 9 files changed, 15 insertions(+), 21 deletions(-)

diff --git a/include/flang/Evaluate/formatting.h b/include/flang/Evaluate/formatting.h
index 0a1f9517d2d0..c2e5316e39b1 100644
--- a/include/flang/Evaluate/formatting.h
+++ b/include/flang/Evaluate/formatting.h
@@ -26,8 +26,6 @@
 
 namespace Fortran::evaluate {
 
-extern bool formatForPGF90;
-
 template<typename A>
 auto operator<<(std::ostream &o, const A &x) -> decltype(x.AsFortran(o)) {
   return x.AsFortran(o);
diff --git a/lib/Evaluate/formatting.cpp b/lib/Evaluate/formatting.cpp
index 560bfc532973..4c28d66a1d66 100644
--- a/lib/Evaluate/formatting.cpp
+++ b/lib/Evaluate/formatting.cpp
@@ -18,8 +18,6 @@
 
 namespace Fortran::evaluate {
 
-bool formatForPGF90{false};
-
 static void ShapeAsFortran(std::ostream &o, const ConstantSubscripts &shape) {
   if (GetRank(shape) > 1) {
     o << ",shape=";
@@ -87,7 +85,7 @@ std::ostream &Constant<Type<TypeCategory::Character, KIND>>::AsFortran(
     if (j > 0) {
       o << ',';
     }
-    if (Result::kind != 1 || !formatForPGF90) {
+    if (Result::kind != 1) {
       o << Result::kind << '_';
     }
     o << parser::QuoteCharacterLiteral(value);
diff --git a/test/Semantics/modfile16.f90 b/test/Semantics/modfile16.f90
index acc17d54a282..48a302792878 100644
--- a/test/Semantics/modfile16.f90
+++ b/test/Semantics/modfile16.f90
@@ -22,16 +22,16 @@ subroutine sub() bind(c, name='sub')
 
 !Expect: m.mod
 !module m
-!  character(2_4,1),parameter::prefix=1_"c_"
-!  integer(4),bind(c, name=1_"c_a")::a
-!  procedure(sub),bind(c, name=1_"c_b"),pointer::b
+!  character(2_4,1),parameter::prefix="c_"
+!  integer(4),bind(c, name="c_a")::a
+!  procedure(sub),bind(c, name="c_b"),pointer::b
 !  type,bind(c)::t
 !    real(4)::c
 !  end type
-!  procedure(real(4)),bind(c, name=1_"dd")::d
-!  procedure(real(4)),bind(c, name=1_"ee")::e
-!  procedure(real(4)),bind(c, name=1_"ff")::f
+!  procedure(real(4)),bind(c, name="dd")::d
+!  procedure(real(4)),bind(c, name="ee")::e
+!  procedure(real(4)),bind(c, name="ff")::f
 !contains
-!  subroutine sub() bind(c, name=1_"sub")
+!  subroutine sub() bind(c, name="sub")
 !  end
 !end
diff --git a/test/Semantics/modfile20.f90 b/test/Semantics/modfile20.f90
index 90188c177c44..a09c4422be23 100644
--- a/test/Semantics/modfile20.f90
+++ b/test/Semantics/modfile20.f90
@@ -26,7 +26,7 @@ module m
 !  integer(8),parameter::i=2_8
 !  real(4)::r
 !  character(10_4,1)::c
-!  character(10_4,1),parameter::c2=1_"qwer      "
+!  character(10_4,1),parameter::c2="qwer      "
 !  complex(8),parameter::z=(1._8,2._8)
 !  complex(8),parameter::zn=(-1._8,2._8)
 !  type::t
diff --git a/test/Semantics/modfile21.f90 b/test/Semantics/modfile21.f90
index 03349a32682d..64dd95f868d3 100644
--- a/test/Semantics/modfile21.f90
+++ b/test/Semantics/modfile21.f90
@@ -30,6 +30,6 @@ module m
 !  bind(c)::/cb2/
 !  common//t,w,u,v
 !  common/cb/x,y,z
-!  bind(c, name=1_"CB")::/cb/
+!  bind(c, name="CB")::/cb/
 !  common/b/cb
 !end
diff --git a/test/Semantics/modfile22.f90 b/test/Semantics/modfile22.f90
index 6279ad78678a..ea2637d4b1d4 100644
--- a/test/Semantics/modfile22.f90
+++ b/test/Semantics/modfile22.f90
@@ -18,6 +18,6 @@ end module m
 !character(1_4,int(k,kind=8))::a
 !character(3_4,int(k,kind=8))::b
 !end type
-!type(t(k=1_4)),parameter::p=t(k=1_4)(a=1_"x",b=1_"xx ")
-!character(2_4,1),parameter::c2(1_8:3_8)=[CHARACTER(KIND=1,LEN=2)::1_"x ",1_"xx",1_"xx"]
+!type(t(k=1_4)),parameter::p=t(k=1_4)(a="x",b="xx ")
+!character(2_4,1),parameter::c2(1_8:3_8)=[CHARACTER(KIND=1,LEN=2)::"x ","xx","xx"]
 !end
diff --git a/test/Semantics/modfile28.f90 b/test/Semantics/modfile28.f90
index 18a349de5ba1..b06826ced22f 100644
--- a/test/Semantics/modfile28.f90
+++ b/test/Semantics/modfile28.f90
@@ -16,7 +16,7 @@ end module m
 !Expect: m.mod
 !module m
 !character(*,4),parameter::c4=4_"Hi! \344\275\240\345\245\275!"
-!character(*,1),parameter::c1=1_"Hi! \344\275\240\345\245\275!"
+!character(*,1),parameter::c1="Hi! \344\275\240\345\245\275!"
 !character(*,4),parameter::c4a(1_8:*)=[CHARACTER(KIND=4,LEN=1)::4_"\344\270\200",4_"\344\272\214",4_"\344\270\211",4_"\345\233\233",4_"\344\272\224"]
 !integer(4),parameter::lc4=7_4
 !intrinsic::len
diff --git a/test/Semantics/modfile30.f90 b/test/Semantics/modfile30.f90
index ef05b9395139..a3b42629e148 100644
--- a/test/Semantics/modfile30.f90
+++ b/test/Semantics/modfile30.f90
@@ -75,7 +75,7 @@ module m4b
 
 !Expect: m4a.mod
 !module m4a
-! character(1_4,1),parameter::a=1_"\001"
+! character(1_4,1),parameter::a="\001"
 ! intrinsic::achar
 !end
 
@@ -83,6 +83,6 @@ module m4b
 !module m4b
 ! use m4a,only:a
 ! use m4a,only:achar
-! character(1_4,1),parameter::b=1_"\001"
+! character(1_4,1),parameter::b="\001"
 !end
 
diff --git a/tools/f18/f18.cpp b/tools/f18/f18.cpp
index fe7bd8a1946f..edcd0ef66b2a 100644
--- a/tools/f18/f18.cpp
+++ b/tools/f18/f18.cpp
@@ -333,13 +333,11 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   {
     std::ofstream tmpSource;
     tmpSource.open(tmpSourcePath);
-    Fortran::evaluate::formatForPGF90 = true;
     Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/,
         options.features.IsEnabled(
             Fortran::common::LanguageFeature::BackslashEscapes),
         nullptr /* action before each statement */,
         driver.unparseTypedExprsToPGF90 ? &asFortran : nullptr);
-    Fortran::evaluate::formatForPGF90 = false;
   }
 
   if (ParentProcess()) {

From 514c0f2c9477040f830fbf0495e4d38129648615 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 17 Mar 2020 13:02:17 -0700
Subject: [PATCH 092/345] Fix location of name of Symbol for ProcEntity

When we encounter a ProcDecl and a symbol for it has already been
created, replace the CharBlock for the name with the one in the ProcDecl
as it is the "main" declaration of that name. This matches what is done
for an EntityDecl.

This moves the location of some error messages to a better source
location so update the affected tests.
---
 lib/Semantics/resolve-names.cpp | 1 +
 test/Semantics/call02.f90       | 2 +-
 test/Semantics/call09.f90       | 2 +-
 test/Semantics/call10.f90       | 2 +-
 4 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index a37bfd64470f..6f94d06c7a58 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -3603,6 +3603,7 @@ void DeclarationVisitor::Post(const parser::ProcDecl &x) {
     attrs.set(Attr::EXTERNAL);
   }
   Symbol &symbol{DeclareProcEntity(name, attrs, interface)};
+  symbol.ReplaceName(name.source);
   if (dtDetails) {
     dtDetails->add_component(symbol);
   }
diff --git a/test/Semantics/call02.f90 b/test/Semantics/call02.f90
index 2d23274da1b0..5d9bdf1cd5a2 100644
--- a/test/Semantics/call02.f90
+++ b/test/Semantics/call02.f90
@@ -9,9 +9,9 @@ elemental real function elem(x)
     subroutine subr(dummy)
       procedure(sin) :: dummy
     end subroutine
-    !ERROR: A dummy procedure may not be ELEMENTAL
     subroutine badsubr(dummy)
       import :: elem
+      !ERROR: A dummy procedure may not be ELEMENTAL
       procedure(elem) :: dummy
     end subroutine
   end interface
diff --git a/test/Semantics/call09.f90 b/test/Semantics/call09.f90
index e27c78e4281f..02224477a28f 100644
--- a/test/Semantics/call09.f90
+++ b/test/Semantics/call09.f90
@@ -28,8 +28,8 @@ real elemental function elemfunc(x)
     real, intent(in) :: x
     elemfunc = x
   end function
-  !ERROR: A dummy procedure may not be ELEMENTAL
   subroutine selemental2(p)
+    !ERROR: A dummy procedure may not be ELEMENTAL
     procedure(elemfunc) :: p
   end subroutine
 
diff --git a/test/Semantics/call10.f90 b/test/Semantics/call10.f90
index 52983c9f18a0..567d85d5d0e0 100644
--- a/test/Semantics/call10.f90
+++ b/test/Semantics/call10.f90
@@ -109,8 +109,8 @@ pure subroutine s06 ! C1589
       real, volatile :: v2
     end block
   end subroutine
-  !ERROR: A dummy procedure of a pure subprogram must be pure
   pure subroutine s07(p) ! C1590
+    !ERROR: A dummy procedure of a pure subprogram must be pure
     procedure(impure) :: p
   end subroutine
   ! C1591 is tested in call11.f90.

From 4d3c4bac843dcc6351fbe7538c6ce23bb9c1a215 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 17 Mar 2020 14:28:08 -0700
Subject: [PATCH 093/345] Create symbols for args of separate-module-subprogram

A separate-module-subprogram is declared as `module procedure ...`
and gets its characteristics from the declaration of that name as
a separate module procedure. When we encounter one, we need to create
symbols in the new subprogram scope for the dummy arguments and
function return (if any).

The failure to create these symbols led to the bug in issue #1054:
when a dummy argument was referenced, the compiler interpreted it as
an implicit declaration because there was no symbol for the argument.

Fixes #1054.
---
 include/flang/Semantics/scope.h |  2 ++
 lib/Semantics/resolve-names.cpp | 21 ++++++++++++++++++---
 lib/Semantics/scope.cpp         | 12 ++++++++++++
 test/Semantics/resolve76.f90    | 30 ++++++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 3 deletions(-)
 create mode 100644 test/Semantics/resolve76.f90

diff --git a/include/flang/Semantics/scope.h b/include/flang/Semantics/scope.h
index 7c12dc14563d..b6945e6da045 100644
--- a/include/flang/Semantics/scope.h
+++ b/include/flang/Semantics/scope.h
@@ -134,6 +134,8 @@ class Scope {
     Symbol &symbol{MakeSymbol(name, attrs, std::move(details))};
     return symbols_.emplace(name, symbol);
   }
+  // Make a copy of a symbol in this scope; nullptr if one is already there
+  Symbol *CopySymbol(const Symbol &);
 
   const std::list<EquivalenceSet> &equivalenceSets() const;
   void add_equivalenceSet(EquivalenceSet &&);
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 6f94d06c7a58..d3d3c7067a54 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -2729,10 +2729,25 @@ bool SubprogramVisitor::BeginMpSubprogram(const parser::Name &name) {
     Say(name, "'%s' was not declared a separate module procedure"_err_en_US);
     return false;
   }
-  if (symbol->owner() != currScope()) {
-    symbol = &MakeSymbol(name, SubprogramDetails{});
+  if (symbol->owner() == currScope()) {
+    PushScope(Scope::Kind::Subprogram, symbol);
+  } else {
+    Symbol &newSymbol{MakeSymbol(name, SubprogramDetails{})};
+    PushScope(Scope::Kind::Subprogram, &newSymbol);
+    const auto &details{symbol->get<SubprogramDetails>()};
+    auto &newDetails{newSymbol.get<SubprogramDetails>()};
+    for (const Symbol *dummyArg : details.dummyArgs()) {
+      if (!dummyArg) {
+        newDetails.add_alternateReturn();
+      } else if (Symbol * copy{currScope().CopySymbol(*dummyArg)}) {
+        newDetails.add_dummyArg(*copy);
+      }
+    }
+    if (details.isFunction()) {
+      currScope().erase(symbol->name());
+      newDetails.set_result(*currScope().CopySymbol(details.result()));
+    }
   }
-  PushScope(Scope::Kind::Subprogram, symbol);
   return true;
 }
 
diff --git a/lib/Semantics/scope.cpp b/lib/Semantics/scope.cpp
index b345c6189849..edb3c64382b7 100644
--- a/lib/Semantics/scope.cpp
+++ b/lib/Semantics/scope.cpp
@@ -110,6 +110,18 @@ bool Scope::Contains(const Scope &that) const {
   }
 }
 
+Symbol *Scope::CopySymbol(const Symbol &symbol) {
+  auto pair{try_emplace(symbol.name(), symbol.attrs())};
+  if (!pair.second) {
+    return nullptr;  // already exists
+  } else {
+    Symbol &result{*pair.first->second};
+    result.flags() = symbol.flags();
+    result.set_details(common::Clone(symbol.details()));
+    return &result;
+  }
+}
+
 const std::list<EquivalenceSet> &Scope::equivalenceSets() const {
   return equivalenceSets_;
 }
diff --git a/test/Semantics/resolve76.f90 b/test/Semantics/resolve76.f90
new file mode 100644
index 000000000000..e68c81f36fb2
--- /dev/null
+++ b/test/Semantics/resolve76.f90
@@ -0,0 +1,30 @@
+! RUN: %S/test_errors.sh %s %flang %t
+
+! 15.6.2.5(3)
+
+module m1
+  implicit logical(a-b)
+  interface
+    module subroutine sub1(a, b)
+      real, intent(in) :: a
+      real, intent(out) :: b
+    end
+    logical module function f()
+    end
+  end interface
+end
+submodule(m1) sm1
+contains
+  module procedure sub1
+    !ERROR: Left-hand side of assignment is not modifiable
+    a = 1.0
+    b = 2.0
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches operand types REAL(4) and LOGICAL(4)
+    b = .false.
+  end
+  module procedure f
+    f = .true.
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches operand types LOGICAL(4) and REAL(4)
+    f = 1.0
+  end
+end

From d121578af17109de3cea23617e4b8239971b5527 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Tue, 17 Mar 2020 14:48:36 -0700
Subject: [PATCH 094/345] Check module subprogram against separate module
 procedure

When a module subprogram has the MODULE prefix the following must match
with the corresponding separate module procedure interface body:
- C1549: characteristics and dummy argument names
- C1550: binding label
- C1551: NON_RECURSIVE prefix

SubprogramMatchHelper performs all of these checks.

Rename separate-module-procs.f90 to separate-mp01.f90 so we can have
separate-mp02.f90 (etc).

Make ShapesAreCompatible public in characteristics.h.

Add Scope::IsSubmodule.
---
 include/flang/Evaluate/characteristics.h      |   5 +
 include/flang/Semantics/scope.h               |   1 +
 lib/Evaluate/characteristics.cpp              |   9 +-
 lib/Semantics/check-declarations.cpp          | 263 +++++++++++++++-
 lib/Semantics/scope.cpp                       |   3 +
 lib/Semantics/symbol.cpp                      |  38 +--
 test/Semantics/resolve36.f90                  |   4 +
 ...ate-module-procs.f90 => separate-mp01.f90} |   7 -
 test/Semantics/separate-mp02.f90              | 285 ++++++++++++++++++
 9 files changed, 577 insertions(+), 38 deletions(-)
 rename test/Semantics/{separate-module-procs.f90 => separate-mp01.f90} (87%)
 create mode 100644 test/Semantics/separate-mp02.f90

diff --git a/include/flang/Evaluate/characteristics.h b/include/flang/Evaluate/characteristics.h
index 52ac7384815b..d0890465b7c1 100644
--- a/include/flang/Evaluate/characteristics.h
+++ b/include/flang/Evaluate/characteristics.h
@@ -47,6 +47,11 @@ bool Distinguishable(const Procedure &, const Procedure &);
 // Are these procedures distinguishable for a generic operator or assignment?
 bool DistinguishableOpOrAssign(const Procedure &, const Procedure &);
 
+// Shapes of function results and dummy arguments have to have
+// the same rank, the same deferred dimensions, and the same
+// values for explicit dimensions when constant.
+bool ShapesAreCompatible(const Shape &, const Shape &);
+
 class TypeAndShape {
 public:
   ENUM_CLASS(
diff --git a/include/flang/Semantics/scope.h b/include/flang/Semantics/scope.h
index b6945e6da045..6a645ad502b9 100644
--- a/include/flang/Semantics/scope.h
+++ b/include/flang/Semantics/scope.h
@@ -78,6 +78,7 @@ class Scope {
   Kind kind() const { return kind_; }
   bool IsGlobal() const { return kind_ == Kind::Global; }
   bool IsModule() const;  // only module, not submodule
+  bool IsSubmodule() const;
   bool IsDerivedType() const { return kind_ == Kind::DerivedType; }
   bool IsParameterizedDerivedType() const;
   Symbol *symbol() { return symbol_; }
diff --git a/lib/Evaluate/characteristics.cpp b/lib/Evaluate/characteristics.cpp
index dffcf3232936..d87ea198ae75 100644
--- a/lib/Evaluate/characteristics.cpp
+++ b/lib/Evaluate/characteristics.cpp
@@ -37,7 +37,7 @@ static void CopyAttrs(const semantics::Symbol &src, A &dst,
 // Shapes of function results and dummy arguments have to have
 // the same rank, the same deferred dimensions, and the same
 // values for explicit dimensions when constant.
-static bool ShapesAreCompatible(const Shape &x, const Shape &y) {
+bool ShapesAreCompatible(const Shape &x, const Shape &y) {
   if (x.size() != y.size()) {
     return false;
   }
@@ -158,10 +158,9 @@ void TypeAndShape::AcquireShape(const semantics::ObjectEntityDetails &object) {
   for (const semantics::ShapeSpec &dim : object.shape()) {
     if (dim.ubound().GetExplicit()) {
       Expr<SubscriptInteger> extent{*dim.ubound().GetExplicit()};
-      if (dim.lbound().GetExplicit()) {
-        extent = std::move(extent) +
-            common::Clone(*dim.lbound().GetExplicit()) -
-            Expr<SubscriptInteger>{1};
+      if (auto lbound{dim.lbound().GetExplicit()}) {
+        extent =
+            std::move(extent) + Expr<SubscriptInteger>{1} - std::move(*lbound);
       }
       shape_.emplace_back(std::move(extent));
     } else {
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index 63d36e342cdb..43fe3435ae07 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -23,6 +23,7 @@ namespace Fortran::semantics {
 
 using evaluate::characteristics::DummyArgument;
 using evaluate::characteristics::DummyDataObject;
+using evaluate::characteristics::DummyProcedure;
 using evaluate::characteristics::Procedure;
 
 class CheckHelper {
@@ -59,6 +60,7 @@ class CheckHelper {
   void CheckObjectEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckArraySpec(const Symbol &, const ArraySpec &);
   void CheckProcEntity(const Symbol &, const ProcEntityDetails &);
+  void CheckSubprogram(const Symbol &, const SubprogramDetails &);
   void CheckAssumedTypeEntity(const Symbol &, const ObjectEntityDetails &);
   void CheckDerivedType(const Symbol &, const DerivedTypeDetails &);
   void CheckGeneric(const Symbol &, const GenericDetails &);
@@ -88,7 +90,7 @@ class CheckHelper {
   template<typename... A>
   void SayWithDeclaration(const Symbol &symbol, A &&... x) {
     if (parser::Message * msg{messages_.Say(std::forward<A>(x)...)}) {
-      if (messages_.at() != symbol.name()) {
+      if (messages_.at().begin() != symbol.name().begin()) {
         evaluate::AttachDeclaration(*msg, symbol);
       }
     }
@@ -156,6 +158,7 @@ void CheckHelper::Check(const Symbol &symbol) {
           [&](const ProcBindingDetails &x) { CheckProcBinding(symbol, x); },
           [&](const ObjectEntityDetails &x) { CheckObjectEntity(symbol, x); },
           [&](const ProcEntityDetails &x) { CheckProcEntity(symbol, x); },
+          [&](const SubprogramDetails &x) { CheckSubprogram(symbol, x); },
           [&](const DerivedTypeDetails &x) { CheckDerivedType(symbol, x); },
           [&](const GenericDetails &x) { CheckGeneric(symbol, x); },
           [](const auto &) {},
@@ -541,6 +544,54 @@ void CheckHelper::CheckProcEntity(
   }
 }
 
+// When a module subprogram has the MODULE prefix the following must match
+// with the corresponding separate module procedure interface body:
+// - C1549: characteristics and dummy argument names
+// - C1550: binding label
+// - C1551: NON_RECURSIVE prefix
+class SubprogramMatchHelper {
+public:
+  explicit SubprogramMatchHelper(SemanticsContext &context)
+    : context{context} {}
+
+  void Check(const Symbol &, const Symbol &);
+
+private:
+  void CheckDummyArg(const Symbol &, const Symbol &, const DummyArgument &,
+      const DummyArgument &);
+  void CheckDummyDataObject(const Symbol &, const Symbol &,
+      const DummyDataObject &, const DummyDataObject &);
+  void CheckDummyProcedure(const Symbol &, const Symbol &,
+      const DummyProcedure &, const DummyProcedure &);
+  bool CheckSameIntent(
+      const Symbol &, const Symbol &, common::Intent, common::Intent);
+  template<typename... A>
+  void Say(
+      const Symbol &, const Symbol &, parser::MessageFixedText &&, A &&...);
+  template<typename ATTRS>
+  bool CheckSameAttrs(const Symbol &, const Symbol &, ATTRS, ATTRS);
+  bool ShapesAreCompatible(const DummyDataObject &, const DummyDataObject &);
+  evaluate::Shape FoldShape(const evaluate::Shape &);
+  std::string AsFortran(DummyDataObject::Attr attr) {
+    return parser::ToUpperCaseLetters(DummyDataObject::EnumToString(attr));
+  }
+  std::string AsFortran(DummyProcedure::Attr attr) {
+    return parser::ToUpperCaseLetters(DummyProcedure::EnumToString(attr));
+  }
+
+  SemanticsContext &context;
+};
+
+void CheckHelper::CheckSubprogram(
+    const Symbol &symbol, const SubprogramDetails &) {
+  const Scope &scope{symbol.owner()};
+  if (symbol.attrs().test(Attr::MODULE) && scope.IsSubmodule()) {
+    if (const Symbol * iface{scope.parent().FindSymbol(symbol.name())}) {
+      SubprogramMatchHelper{context_}.Check(symbol, *iface);
+    }
+  }
+}
+
 void CheckHelper::CheckDerivedType(
     const Symbol &symbol, const DerivedTypeDetails &details) {
   if (!symbol.scope()) {
@@ -1158,7 +1209,217 @@ void CheckHelper::CheckBlockData(const Scope &scope) {
   }
 }
 
+void SubprogramMatchHelper::Check(
+    const Symbol &symbol1, const Symbol &symbol2) {
+  const auto details1{symbol1.get<SubprogramDetails>()};
+  const auto details2{symbol2.get<SubprogramDetails>()};
+  if (details1.isFunction() != details2.isFunction()) {
+    Say(symbol1, symbol2,
+        details1.isFunction()
+            ? "Module function '%s' was declared as a subroutine in the"
+              " corresponding interface body"_err_en_US
+            : "Module subroutine '%s' was declared as a function in the"
+              " corresponding interface body"_err_en_US);
+    return;
+  }
+  const auto &args1{details1.dummyArgs()};
+  const auto &args2{details2.dummyArgs()};
+  int nargs1{static_cast<int>(args1.size())};
+  int nargs2{static_cast<int>(args2.size())};
+  if (nargs1 != nargs2) {
+    Say(symbol1, symbol2,
+        "Module subprogram '%s' has %d args but the corresponding interface"
+        " body has %d"_err_en_US,
+        nargs1, nargs2);
+    return;
+  }
+  bool nonRecursive1{symbol1.attrs().test(Attr::NON_RECURSIVE)};
+  if (nonRecursive1 != symbol2.attrs().test(Attr::NON_RECURSIVE)) {  // C1551
+    Say(symbol1, symbol2,
+        nonRecursive1
+            ? "Module subprogram '%s' has NON_RECURSIVE prefix but"
+              " the corresponding interface body does not"_err_en_US
+            : "Module subprogram '%s' does not have NON_RECURSIVE prefix but "
+              "the corresponding interface body does"_err_en_US);
+  }
+  MaybeExpr bindName1{details1.bindName()};
+  MaybeExpr bindName2{details2.bindName()};
+  if (bindName1.has_value() != bindName2.has_value()) {
+    Say(symbol1, symbol2,
+        bindName1.has_value()
+            ? "Module subprogram '%s' has a binding label but the corresponding"
+              " interface body does not"_err_en_US
+            : "Module subprogram '%s' does not have a binding label but the"
+              " corresponding interface body does"_err_en_US);
+  } else if (bindName1) {
+    std::string string1{bindName1->AsFortran()};
+    std::string string2{bindName2->AsFortran()};
+    if (string1 != string2) {
+      Say(symbol1, symbol2,
+          "Module subprogram '%s' has binding label %s but the corresponding"
+          " interface body has %s"_err_en_US,
+          string1, string2);
+    }
+  }
+  auto proc1{Procedure::Characterize(symbol1, context.intrinsics())};
+  auto proc2{Procedure::Characterize(symbol2, context.intrinsics())};
+  if (!proc1 || !proc2) {
+    return;
+  }
+  if (proc1->functionResult && proc2->functionResult &&
+      *proc1->functionResult != *proc2->functionResult) {
+    Say(symbol1, symbol2,
+        "Return type of function '%s' does not match return type of"
+        " the corresponding interface body"_err_en_US);
+  }
+  for (int i{0}; i < nargs1; ++i) {
+    const Symbol *arg1{args1[i]};
+    const Symbol *arg2{args2[i]};
+    if (arg1 && !arg2) {
+      Say(symbol1, symbol2,
+          "Dummy argument %2$d of '%1$s' is not an alternate return indicator"
+          " but the corresponding argument in the interface body is"_err_en_US,
+          i + 1);
+    } else if (!arg1 && arg2) {
+      Say(symbol1, symbol2,
+          "Dummy argument %2$d of '%1$s' is an alternate return indicator but"
+          " the corresponding argument in the interface body is not"_err_en_US,
+          i + 1);
+    } else if (arg1 && arg2) {
+      SourceName name1{arg1->name()};
+      SourceName name2{arg2->name()};
+      if (name1 != name2) {
+        Say(*arg1, *arg2,
+            "Dummy argument name '%s' does not match corresponding name '%s'"
+            " in interface body"_err_en_US,
+            name2);
+      } else {
+        CheckDummyArg(
+            *arg1, *arg2, proc1->dummyArguments[i], proc2->dummyArguments[i]);
+      }
+    }
+  }
+}
+
+void SubprogramMatchHelper::CheckDummyArg(const Symbol &symbol1,
+    const Symbol &symbol2, const DummyArgument &arg1,
+    const DummyArgument &arg2) {
+  std::visit(
+      common::visitors{
+          [&](const DummyDataObject &obj1, const DummyDataObject &obj2) {
+            CheckDummyDataObject(symbol1, symbol2, obj1, obj2);
+          },
+          [&](const DummyProcedure &proc1, const DummyProcedure &proc2) {
+            CheckDummyProcedure(symbol1, symbol2, proc1, proc2);
+          },
+          [&](const DummyDataObject &, const auto &) {
+            Say(symbol1, symbol2,
+                "Dummy argument '%s' is a data object; the corresponding"
+                " argument in the interface body is not"_err_en_US);
+          },
+          [&](const DummyProcedure &, const auto &) {
+            Say(symbol1, symbol2,
+                "Dummy argument '%s' is a procedure; the corresponding"
+                " argument in the interface body is not"_err_en_US);
+          },
+          [&](const auto &, const auto &) { DIE("can't happen"); },
+      },
+      arg1.u, arg2.u);
+}
+
+void SubprogramMatchHelper::CheckDummyDataObject(const Symbol &symbol1,
+    const Symbol &symbol2, const DummyDataObject &obj1,
+    const DummyDataObject &obj2) {
+  if (!CheckSameIntent(symbol1, symbol2, obj1.intent, obj2.intent)) {
+  } else if (!CheckSameAttrs(symbol1, symbol2, obj1.attrs, obj2.attrs)) {
+  } else if (obj1.type.type() != obj2.type.type()) {
+    Say(symbol1, symbol2,
+        "Dummy argument '%s' has type %s; the corresponding argument in the"
+        " interface body has type %s"_err_en_US,
+        obj1.type.type().AsFortran(), obj2.type.type().AsFortran());
+  } else if (!ShapesAreCompatible(obj1, obj2)) {
+    Say(symbol1, symbol2,
+        "The shape of dummy argument '%s' does not match the shape of the"
+        " corresponding argument in the interface body"_err_en_US);
+  }
+  // TODO: coshape
+}
+
+void SubprogramMatchHelper::CheckDummyProcedure(const Symbol &symbol1,
+    const Symbol &symbol2, const DummyProcedure &proc1,
+    const DummyProcedure &proc2) {
+  if (!CheckSameIntent(symbol1, symbol2, proc1.intent, proc2.intent)) {
+  } else if (!CheckSameAttrs(symbol1, symbol2, proc1.attrs, proc2.attrs)) {
+  } else if (proc1 != proc2) {
+    Say(symbol1, symbol2,
+        "Dummy procedure '%s' does not match the corresponding argument in"
+        " the interface body"_err_en_US);
+  }
+}
+
+bool SubprogramMatchHelper::CheckSameIntent(const Symbol &symbol1,
+    const Symbol &symbol2, common::Intent intent1, common::Intent intent2) {
+  if (intent1 == intent2) {
+    return true;
+  } else {
+    Say(symbol1, symbol2,
+        "The intent of dummy argument '%s' does not match the intent"
+        " of the corresponding argument in the interface body"_err_en_US);
+    return false;
+  }
+}
+
+// Report an error referring to first symbol with declaration of second symbol
+template<typename... A>
+void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
+    parser::MessageFixedText &&text, A &&... args) {
+  auto &message{context.Say(symbol1.name(), std::move(text), symbol1.name(),
+      std::forward<A>(args)...)};
+  evaluate::AttachDeclaration(message, symbol2);
+}
+
+template<typename ATTRS>
+bool SubprogramMatchHelper::CheckSameAttrs(
+    const Symbol &symbol1, const Symbol &symbol2, ATTRS attrs1, ATTRS attrs2) {
+  if (attrs1 == attrs2) {
+    return true;
+  }
+  attrs1.IterateOverMembers([&](auto attr) {
+    if (!attrs2.test(attr)) {
+      Say(symbol1, symbol2,
+          "Dummy argument '%s' has the %s attribute; the corresponding"
+          " argument in the interface body does not"_err_en_US,
+          AsFortran(attr));
+    }
+  });
+  attrs2.IterateOverMembers([&](auto attr) {
+    if (!attrs1.test(attr)) {
+      Say(symbol1, symbol2,
+          "Dummy argument '%s' does not have the %s attribute; the"
+          " corresponding argument in the interface body does"_err_en_US,
+          AsFortran(attr));
+    }
+  });
+  return false;
+}
+
+bool SubprogramMatchHelper::ShapesAreCompatible(
+    const DummyDataObject &obj1, const DummyDataObject &obj2) {
+  return evaluate::characteristics::ShapesAreCompatible(
+      FoldShape(obj1.type.shape()), FoldShape(obj2.type.shape()));
+}
+
+evaluate::Shape SubprogramMatchHelper::FoldShape(const evaluate::Shape &shape) {
+  evaluate::Shape result;
+  for (const auto &extent : shape) {
+    result.emplace_back(
+        evaluate::Fold(context.foldingContext(), common::Clone(extent)));
+  }
+  return result;
+}
+
 void CheckDeclarations(SemanticsContext &context) {
   CheckHelper{context}.Check();
 }
+
 }
diff --git a/lib/Semantics/scope.cpp b/lib/Semantics/scope.cpp
index edb3c64382b7..b63082f2c410 100644
--- a/lib/Semantics/scope.cpp
+++ b/lib/Semantics/scope.cpp
@@ -51,6 +51,9 @@ std::string EquivalenceObject::AsFortran() const {
 bool Scope::IsModule() const {
   return kind_ == Kind::Module && !symbol_->get<ModuleDetails>().isSubmodule();
 }
+bool Scope::IsSubmodule() const {
+  return kind_ == Kind::Module && symbol_->get<ModuleDetails>().isSubmodule();
+}
 
 Scope &Scope::MakeScope(Kind kind, Symbol *symbol) {
   return children_.emplace_back(*this, kind, symbol);
diff --git a/lib/Semantics/symbol.cpp b/lib/Semantics/symbol.cpp
index 92e2f5fdf7af..0017d891643b 100644
--- a/lib/Semantics/symbol.cpp
+++ b/lib/Semantics/symbol.cpp
@@ -85,20 +85,25 @@ std::ostream &operator<<(std::ostream &os, const SubprogramDetails &x) {
   DumpBool(os, "isInterface", x.isInterface_);
   DumpExpr(os, "bindName", x.bindName_);
   if (x.result_) {
-    os << " result:" << x.result_->name();
+    DumpType(os << " result:", x.result());
+    os << x.result_->name();
     if (!x.result_->attrs().empty()) {
       os << ", " << x.result_->attrs();
     }
   }
-  if (x.dummyArgs_.empty()) {
-    char sep{'('};
-    os << ' ';
-    for (const auto *arg : x.dummyArgs_) {
-      os << sep << arg->name();
-      sep = ',';
+  char sep{'('};
+  os << ' ';
+  for (const Symbol *arg : x.dummyArgs_) {
+    os << sep;
+    sep = ',';
+    if (arg) {
+      DumpType(os, *arg);
+      os << arg->name();
+    } else {
+      os << '*';
     }
-    os << (sep == '(' ? "()" : ")");
   }
+  os << (sep == '(' ? "()" : ")");
   return os;
 }
 
@@ -399,23 +404,6 @@ std::ostream &operator<<(std::ostream &os, const Details &details) {
               os << ")";
             }
           },
-          [&](const SubprogramDetails &x) {
-            os << " (";
-            int n = 0;
-            for (const auto &dummy : x.dummyArgs()) {
-              if (n++ > 0) os << ", ";
-              DumpType(os, *dummy);
-              os << dummy->name();
-            }
-            os << ')';
-            DumpExpr(os, "bindName", x.bindName());
-            if (x.isFunction()) {
-              os << " result(";
-              DumpType(os, x.result());
-              os << x.result().name() << ')';
-            }
-            DumpBool(os, "interface", x.isInterface());
-          },
           [&](const SubprogramNameDetails &x) {
             os << ' ' << EnumToString(x.kind());
           },
diff --git a/test/Semantics/resolve36.f90 b/test/Semantics/resolve36.f90
index 438ad1aeca92..7ed9391c2f9e 100644
--- a/test/Semantics/resolve36.f90
+++ b/test/Semantics/resolve36.f90
@@ -1,4 +1,8 @@
 ! RUN: %S/test_errors.sh %s %flang %t
+
+! C1568 The procedure-name shall have been declared to be a separate module
+! procedure in the containing program unit or an ancestor of that program unit.
+
 module m1
   interface
     module subroutine sub1(arg1)
diff --git a/test/Semantics/separate-module-procs.f90 b/test/Semantics/separate-mp01.f90
similarity index 87%
rename from test/Semantics/separate-module-procs.f90
rename to test/Semantics/separate-mp01.f90
index 33dfcd557fde..305c147e66c9 100644
--- a/test/Semantics/separate-module-procs.f90
+++ b/test/Semantics/separate-mp01.f90
@@ -1,11 +1,4 @@
 ! RUN: %S/test_errors.sh %s %flang %t
-!===--- separate-module-procs.f90 - Test separate module procedure ---------===
-!
-! 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
-!
-!===------------------------------------------------------------------------===
 
 ! case 1: ma_create_new_fun' was not declared a separate module procedure
 module m1
diff --git a/test/Semantics/separate-mp02.f90 b/test/Semantics/separate-mp02.f90
new file mode 100644
index 000000000000..1f514c2ccd37
--- /dev/null
+++ b/test/Semantics/separate-mp02.f90
@@ -0,0 +1,285 @@
+! RUN: %S/test_errors.sh %s %flang %t
+
+! When a module subprogram has the MODULE prefix the following must match
+! with the corresponding separate module procedure interface body:
+! - C1549: characteristics and dummy argument names
+! - C1550: binding label
+! - C1551: NON_RECURSIVE prefix
+
+module m1
+  interface
+    module subroutine s4(x)
+      real, intent(in) :: x
+    end
+    module subroutine s5(x, y)
+      real, pointer :: x
+      real, value :: y
+    end
+    module subroutine s6(x, y)
+      real :: x
+      real :: y
+    end
+    module subroutine s7(x, y, z)
+      real :: x(8)
+      real :: y(8)
+      real :: z(8)
+    end
+    module subroutine s8(x, y, z)
+      real :: x(8)
+      real :: y(*)
+      real :: z(*)
+    end
+    module subroutine s9(x, y, z, w)
+      character(len=4) :: x
+      character(len=4) :: y
+      character(len=*) :: z
+      character(len=*) :: w
+    end
+  end interface
+end
+
+submodule(m1) sm1
+contains
+  module subroutine s4(x)
+    !ERROR: The intent of dummy argument 'x' does not match the intent of the corresponding argument in the interface body
+    real, intent(out) :: x
+  end
+  module subroutine s5(x, y)
+    !ERROR: Dummy argument 'x' has the OPTIONAL attribute; the corresponding argument in the interface body does not
+    real, pointer, optional :: x
+    !ERROR: Dummy argument 'y' does not have the VALUE attribute; the corresponding argument in the interface body does
+    real :: y
+  end
+  module subroutine s6(x, y)
+    !ERROR: Dummy argument 'x' has type INTEGER(4); the corresponding argument in the interface body has type REAL(4)
+    integer :: x
+    !ERROR: Dummy argument 'y' has type REAL(8); the corresponding argument in the interface body has type REAL(4)
+    real(8) :: y
+  end
+  module subroutine s7(x, y, z)
+    integer, parameter :: n = 8
+    real :: x(n)
+    real :: y(2:n+1)
+    !ERROR: The shape of dummy argument 'z' does not match the shape of the corresponding argument in the interface body
+    real :: z(n+1)
+  end
+  module subroutine s8(x, y, z)
+    !ERROR: The shape of dummy argument 'x' does not match the shape of the corresponding argument in the interface body
+    real :: x(*)
+    real :: y(*)
+    !ERROR: The shape of dummy argument 'z' does not match the shape of the corresponding argument in the interface body
+    real :: z(8)
+  end
+  module subroutine s9(x, y, z, w)
+    character(len=4) :: x
+    !ERROR: Dummy argument 'y' has type CHARACTER(KIND=1,LEN=5_4); the corresponding argument in the interface body has type CHARACTER(KIND=1,LEN=4_4)
+    character(len=5) :: y
+    character(len=*) :: z
+    !ERROR: Dummy argument 'w' has type CHARACTER(KIND=1,LEN=4_4); the corresponding argument in the interface body has type CHARACTER(KIND=1,LEN=*)
+    character(len=4) :: w
+  end
+end
+
+module m2
+  interface
+    module subroutine s1(x, y)
+      real, intent(in) :: x
+      real, intent(out) :: y
+    end
+    module subroutine s2(x, y)
+      real, intent(in) :: x
+      real, intent(out) :: y
+    end
+    module subroutine s3(x, y)
+      real(4) :: x
+      procedure(real) :: y
+    end
+    module subroutine s4()
+    end
+    non_recursive module subroutine s5()
+    end
+  end interface
+end
+
+submodule(m2) sm2
+contains
+  !ERROR: Module subprogram 's1' has 3 args but the corresponding interface body has 2
+  module subroutine s1(x, y, z)
+    real, intent(in) :: x
+    real, intent(out) :: y
+    real :: z
+  end
+  !ERROR: Dummy argument name 'z' does not match corresponding name 'y' in interface body
+  module subroutine s2(x, z)
+    real, intent(in) :: x
+    real, intent(out) :: y
+  end
+  module subroutine s3(x, y)
+    !ERROR: Dummy argument 'x' is a procedure; the corresponding argument in the interface body is not
+    procedure(real) :: x
+    !ERROR: Dummy argument 'y' is a data object; the corresponding argument in the interface body is not
+    real :: y
+  end
+  !ERROR: Module subprogram 's4' has NON_RECURSIVE prefix but the corresponding interface body does not
+  non_recursive module subroutine s4()
+  end
+  !ERROR: Module subprogram 's5' does not have NON_RECURSIVE prefix but the corresponding interface body does
+  module subroutine s5()
+  end
+end
+
+module m2b
+  interface
+    module subroutine s1()
+    end
+    module subroutine s2() bind(c, name="s2")
+    end
+    module subroutine s3() bind(c, name="s3")
+    end
+  end interface
+end
+
+submodule(m2b) sm2b
+  character(*), parameter :: suffix = "_xxx"
+contains
+  !ERROR: Module subprogram 's1' has a binding label but the corresponding interface body does not
+  module subroutine s1() bind(c, name="s1")
+  end
+  !ERROR: Module subprogram 's2' does not have a binding label but the corresponding interface body does
+  module subroutine s2()
+  end
+  !ERROR: Module subprogram 's3' has binding label "s3_xxx" but the corresponding interface body has "s3"
+  module subroutine s3() bind(c, name="s3" // suffix)
+  end
+end
+
+
+module m3
+  interface
+    module subroutine s1(x, y, z)
+      procedure(real), intent(in) :: x
+      procedure(real), intent(out) :: y
+      procedure(real), intent(out) :: z
+    end
+    module subroutine s2(x, y)
+      procedure(real), pointer :: x
+      procedure(real) :: y
+    end
+  end interface
+end
+
+submodule(m3) sm3
+contains
+  module subroutine s1(x, y, z)
+    procedure(real), intent(in) :: x
+    !ERROR: The intent of dummy argument 'y' does not match the intent of the corresponding argument in the interface body
+    procedure(real), intent(inout) :: y
+    !ERROR: The intent of dummy argument 'z' does not match the intent of the corresponding argument in the interface body
+    procedure(real) :: z
+  end
+  module subroutine s2(x, y)
+    !ERROR: Dummy argument 'x' has the OPTIONAL attribute; the corresponding argument in the interface body does not
+    !ERROR: Dummy argument 'x' does not have the POINTER attribute; the corresponding argument in the interface body does
+    procedure(real), optional :: x
+    !ERROR: Dummy argument 'y' has the POINTER attribute; the corresponding argument in the interface body does not
+    procedure(real), pointer :: y
+  end
+end
+
+module m4
+  interface
+    subroutine s_real(x)
+      real :: x
+    end
+    subroutine s_real2(x)
+      real :: x
+    end
+    subroutine s_integer(x)
+      integer :: x
+    end
+    module subroutine s1(x)
+      procedure(s_real) :: x
+    end
+    module subroutine s2(x)
+      procedure(s_real) :: x
+    end
+  end interface
+end
+
+submodule(m4) sm4
+contains
+  module subroutine s1(x)
+    !OK
+    procedure(s_real2) :: x
+  end
+  module subroutine s2(x)
+    !ERROR: Dummy procedure 'x' does not match the corresponding argument in the interface body
+    procedure(s_integer) :: x
+  end
+end
+
+module m5
+  interface
+    module function f1()
+      real :: f1
+    end
+    module subroutine s2()
+    end
+  end interface
+end
+
+submodule(m5) sm5
+contains
+  !ERROR: Module subroutine 'f1' was declared as a function in the corresponding interface body
+  module subroutine f1()
+  end
+  !ERROR: Module function 's2' was declared as a subroutine in the corresponding interface body
+  module function s2()
+  end
+end
+
+module m6
+  interface
+    module function f1()
+      real :: f1
+    end
+    module function f2()
+      real :: f2
+    end
+    module function f3()
+      real :: f3
+    end
+  end interface
+end
+
+submodule(m6) ms6
+contains
+  !OK
+  real module function f1()
+  end
+  !ERROR: Return type of function 'f2' does not match return type of the corresponding interface body
+  integer module function f2()
+  end
+  !ERROR: Return type of function 'f3' does not match return type of the corresponding interface body
+  module function f3()
+    real :: f3
+    pointer :: f3
+  end
+end
+
+module m7
+  interface
+    module subroutine s1(x, *)
+      real :: x
+    end
+  end interface
+end
+
+submodule(m7) sm7
+contains
+  !ERROR: Dummy argument 1 of 's1' is an alternate return indicator but the corresponding argument in the interface body is not
+  !ERROR: Dummy argument 2 of 's1' is not an alternate return indicator but the corresponding argument in the interface body is
+  module subroutine s1(*, x)
+    real :: x
+  end
+end

From 234bb519cd38d0b9234fc0b4a8d11cfcb9935e6a Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Fri, 13 Mar 2020 12:19:44 -0700
Subject: [PATCH 095/345] Improve error message for procedure passed as invalid
 argument to an intrinsic

Support forward references to sibling module procedures

Add tests, handle corner cases

Rename new test
---
 include/flang/Evaluate/check-expression.h |  8 +++
 include/flang/Semantics/expression.h      |  1 +
 include/flang/Semantics/symbol.h          |  6 +-
 lib/Evaluate/check-expression.cpp         |  7 +++
 lib/Evaluate/intrinsics.cpp               | 22 +++++---
 lib/Semantics/check-declarations.cpp      | 26 +++++++--
 lib/Semantics/expression.cpp              | 66 ++++++++++++++--------
 lib/Semantics/program-tree.h              | 14 ++++-
 lib/Semantics/resolve-names.cpp           | 67 +++++++++++++++++------
 lib/Semantics/resolve-names.h             |  2 +
 lib/Semantics/tools.cpp                   |  3 +-
 test/Semantics/expr-errors02.f90          |  3 +-
 test/Semantics/resolve59.f90              | 18 +++---
 test/Semantics/resolve77.f90              | 52 ++++++++++++++++++
 14 files changed, 227 insertions(+), 68 deletions(-)
 create mode 100644 test/Semantics/resolve77.f90

diff --git a/include/flang/Evaluate/check-expression.h b/include/flang/Evaluate/check-expression.h
index afd730924baf..2285881c329a 100644
--- a/include/flang/Evaluate/check-expression.h
+++ b/include/flang/Evaluate/check-expression.h
@@ -31,6 +31,7 @@ class IntrinsicProcTable;
 template<typename A> bool IsConstantExpr(const A &);
 extern template bool IsConstantExpr(const Expr<SomeType> &);
 extern template bool IsConstantExpr(const Expr<SomeInteger> &);
+extern template bool IsConstantExpr(const Expr<SubscriptInteger> &);
 
 // Checks whether an expression is an object designator with
 // constant addressing and no vector-valued subscript.
@@ -44,6 +45,13 @@ void CheckSpecificationExpr(
     const A &, parser::ContextualMessages &, const semantics::Scope &);
 extern template void CheckSpecificationExpr(const Expr<SomeType> &x,
     parser::ContextualMessages &, const semantics::Scope &);
+extern template void CheckSpecificationExpr(const Expr<SomeInteger> &x,
+    parser::ContextualMessages &, const semantics::Scope &);
+extern template void CheckSpecificationExpr(const Expr<SubscriptInteger> &x,
+    parser::ContextualMessages &, const semantics::Scope &);
+extern template void CheckSpecificationExpr(
+    const std::optional<Expr<SomeType>> &x, parser::ContextualMessages &,
+    const semantics::Scope &);
 extern template void CheckSpecificationExpr(
     const std::optional<Expr<SomeInteger>> &x, parser::ContextualMessages &,
     const semantics::Scope &);
diff --git a/include/flang/Semantics/expression.h b/include/flang/Semantics/expression.h
index bf04275d6004..77ead117f345 100644
--- a/include/flang/Semantics/expression.h
+++ b/include/flang/Semantics/expression.h
@@ -353,6 +353,7 @@ class ExpressionAnalyzer {
       parser::CharBlock, const ProcedureDesignator &, ActualArguments &);
   using AdjustActuals =
       std::optional<std::function<bool(const Symbol &, ActualArguments &)>>;
+  bool ResolveForward(const Symbol &);
   const Symbol *ResolveGeneric(const Symbol &, const ActualArguments &,
       const AdjustActuals &, bool mightBeStructureConstructor = false);
   void EmitGenericResolutionError(const Symbol &);
diff --git a/include/flang/Semantics/symbol.h b/include/flang/Semantics/symbol.h
index 80f702a98307..b97cdf0f41e7 100644
--- a/include/flang/Semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -27,6 +27,7 @@ namespace Fortran::semantics {
 
 class Scope;
 class Symbol;
+class ProgramTree;
 
 using SymbolRef = common::Reference<const Symbol>;
 using SymbolVector = std::vector<SymbolRef>;
@@ -91,12 +92,15 @@ ENUM_CLASS(SubprogramKind, Module, Internal)
 // type information.
 class SubprogramNameDetails {
 public:
-  SubprogramNameDetails(SubprogramKind kind) : kind_{kind} {}
+  SubprogramNameDetails(SubprogramKind kind, ProgramTree &node)
+    : kind_{kind}, node_{node} {}
   SubprogramNameDetails() = delete;
   SubprogramKind kind() const { return kind_; }
+  ProgramTree &node() const { return *node_; }
 
 private:
   SubprogramKind kind_;
+  common::Reference<ProgramTree> node_;
 };
 
 // A name from an entity-decl -- could be object or function.
diff --git a/lib/Evaluate/check-expression.cpp b/lib/Evaluate/check-expression.cpp
index fede3aec6e9a..07b9065dcb29 100644
--- a/lib/Evaluate/check-expression.cpp
+++ b/lib/Evaluate/check-expression.cpp
@@ -63,6 +63,7 @@ template<typename A> bool IsConstantExpr(const A &x) {
 }
 template bool IsConstantExpr(const Expr<SomeType> &);
 template bool IsConstantExpr(const Expr<SomeInteger> &);
+template bool IsConstantExpr(const Expr<SubscriptInteger> &);
 
 // Object pointer initialization checking predicate IsInitialDataTarget().
 // This code determines whether an expression is allowable as the static
@@ -244,6 +245,12 @@ void CheckSpecificationExpr(const A &x, parser::ContextualMessages &messages,
 
 template void CheckSpecificationExpr(const Expr<SomeType> &,
     parser::ContextualMessages &, const semantics::Scope &);
+template void CheckSpecificationExpr(const Expr<SomeInteger> &,
+    parser::ContextualMessages &, const semantics::Scope &);
+template void CheckSpecificationExpr(const Expr<SubscriptInteger> &,
+    parser::ContextualMessages &, const semantics::Scope &);
+template void CheckSpecificationExpr(const std::optional<Expr<SomeType>> &,
+    parser::ContextualMessages &, const semantics::Scope &);
 template void CheckSpecificationExpr(const std::optional<Expr<SomeInteger>> &,
     parser::ContextualMessages &, const semantics::Scope &);
 template void CheckSpecificationExpr(
diff --git a/lib/Evaluate/intrinsics.cpp b/lib/Evaluate/intrinsics.cpp
index b5eacb9415ff..93dcfe28f5ae 100644
--- a/lib/Evaluate/intrinsics.cpp
+++ b/lib/Evaluate/intrinsics.cpp
@@ -42,6 +42,10 @@ class FoldingContext;
 // optionality and defaults.  The kind and rank patterns are represented
 // here with code values that are significant to the matching/validation engine.
 
+// An actual argument to an intrinsic procedure may be a procedure itself
+// only if the dummy argument is Rank::reduceOperation,
+// KindCode::addressable, or the special case of NULL(MOLD=procedurePointer).
+
 // These are small bit-sets of type category enumerators.
 // Note that typeless (BOZ literal) values don't have a distinct type category.
 // These typeless arguments are represented in the tables as if they were
@@ -1085,9 +1089,8 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
     std::optional<DynamicType> type{arg->GetType()};
     if (!type) {
       CHECK(arg->Rank() == 0);
-      const Expr<SomeType> *expr{arg->UnwrapExpr()};
-      CHECK(expr);
-      if (std::holds_alternative<BOZLiteralConstant>(expr->u)) {
+      const Expr<SomeType> &expr{DEREF(arg->UnwrapExpr())};
+      if (std::holds_alternative<BOZLiteralConstant>(expr.u)) {
         if (d.typePattern.kindCode == KindCode::typeless ||
             d.rank == Rank::elementalOrBOZ) {
           continue;
@@ -1097,11 +1100,14 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
               d.keyword);
         }
       } else {
-        // NULL(), pointer to subroutine, &c.
-        if (d.typePattern.kindCode == KindCode::addressable) {
+        // NULL(), procedure, or procedure pointer
+        CHECK(IsProcedurePointer(expr));
+        if (d.typePattern.kindCode == KindCode::addressable ||
+            d.rank == Rank::reduceOperation) {
           continue;
         } else {
-          messages.Say("Typeless item not allowed for '%s=' argument"_err_en_US,
+          messages.Say(
+              "Actual argument for '%s=' may not be a procedure"_err_en_US,
               d.keyword);
         }
       }
@@ -1249,8 +1255,8 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
         argOk = rank == 0 || rank + 1 == arrayArg->Rank();
         break;
       case Rank::reduceOperation:
-        // TODO: Confirm that the argument is a pure function
-        // of two arguments with several constraints
+        // TODO: validate the reduction operation -- it must be a pure
+        // function of two arguments with special constraints.
         CHECK(arrayArg);
         argOk = rank == 0;
         break;
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index 43fe3435ae07..c1cd33c75f33 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -43,12 +43,26 @@ class CheckHelper {
   void Check(const Scope &);
 
 private:
+  template<typename A> void CheckSpecExpr(const A &x) {
+    if (symbolBeingChecked_ && IsSaved(*symbolBeingChecked_)) {
+      if (!evaluate::IsConstantExpr(x)) {
+        messages_.Say(
+            "Specification expression must be constant in declaration of '%s' with the SAVE attribute"_err_en_US,
+            symbolBeingChecked_->name());
+      }
+    } else {
+      evaluate::CheckSpecificationExpr(x, messages_, DEREF(scope_));
+    }
+  }
+  template<typename A> void CheckSpecExpr(const std::optional<A> &x) {
+    if (x) {
+      CheckSpecExpr(*x);
+    }
+  }
   template<typename A> void CheckSpecExpr(A &x) {
     x = Fold(foldingContext_, std::move(x));
-    evaluate::CheckSpecificationExpr(x, messages_, DEREF(scope_));
-  }
-  template<typename A> void CheckSpecExpr(const A &x) {
-    evaluate::CheckSpecificationExpr(x, messages_, DEREF(scope_));
+    const A &constx{x};
+    CheckSpecExpr(constx);
   }
   void CheckValue(const Symbol &, const DerivedTypeSpec *);
   void CheckVolatile(
@@ -103,6 +117,7 @@ class CheckHelper {
   // This symbol is the one attached to the innermost enclosing scope
   // that has a symbol.
   const Symbol *innermostSymbol_{nullptr};
+  const Symbol *symbolBeingChecked_{nullptr};
 };
 
 void CheckHelper::Check(const ParamValue &value, bool canBeAssumed) {
@@ -348,10 +363,13 @@ void CheckHelper::CheckAssumedTypeEntity(  // C709
 
 void CheckHelper::CheckObjectEntity(
     const Symbol &symbol, const ObjectEntityDetails &details) {
+  CHECK(!symbolBeingChecked_);
+  symbolBeingChecked_ = &symbol;  // for specification expr checks
   CheckArraySpec(symbol, details.shape());
   Check(details.shape());
   Check(details.coshape());
   CheckAssumedTypeEntity(symbol, details);
+  symbolBeingChecked_ = nullptr;
   if (!details.coshape().empty()) {
     if (IsAllocatable(symbol)) {
       if (!details.coshape().IsDeferredShape()) {  // C827
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index 302ef7fdcaf8..84ec0a7386fe 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -9,6 +9,7 @@
 #include "flang/Semantics/expression.h"
 #include "check-call.h"
 #include "pointer-assignment.h"
+#include "resolve-names.h"
 #include "flang/Common/idioms.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/fold.h"
@@ -1718,6 +1719,41 @@ static bool CheckCompatibleArguments(
   return true;
 }
 
+// Handles a forward reference to a module function from what must
+// be a specification expression.  Return false if the symbol is
+// an invalid forward reference.
+bool ExpressionAnalyzer::ResolveForward(const Symbol &symbol) {
+  if (context_.HasError(symbol)) {
+    return false;
+  }
+  if (const auto *details{
+          symbol.detailsIf<semantics::SubprogramNameDetails>()}) {
+    if (details->kind() == semantics::SubprogramKind::Module) {
+      // If this symbol is still a SubprogramNameDetails, we must be
+      // checking a specification expression in a sibling module
+      // procedure.  Resolve its names now so that its interface
+      // is known.
+      semantics::ResolveSpecificationParts(context_, symbol);
+      if (symbol.has<semantics::SubprogramNameDetails>()) {
+        // When the symbol hasn't had its details updated, we must have
+        // already been in the process of resolving the function's
+        // specification part; but recursive function calls are not
+        // allowed in specification parts (10.1.11 para 5).
+        Say("The module function '%s' may not be referenced recursively in a specification expression"_err_en_US,
+            symbol.name());
+        context_.SetError(const_cast<Symbol &>(symbol));
+        return false;
+      }
+    } else {  // 10.1.11 para 4
+      Say("The internal function '%s' may not be referenced in a specification expression"_err_en_US,
+          symbol.name());
+      context_.SetError(const_cast<Symbol &>(symbol));
+      return false;
+    }
+  }
+  return true;
+}
+
 // Resolve a call to a generic procedure with given actual arguments.
 // adjustActuals is called on procedure bindings to handle pass arg.
 const Symbol *ExpressionAnalyzer::ResolveGeneric(const Symbol &symbol,
@@ -1726,6 +1762,9 @@ const Symbol *ExpressionAnalyzer::ResolveGeneric(const Symbol &symbol,
   const Symbol *elemental{nullptr};  // matching elemental specific proc
   const auto &details{symbol.GetUltimate().get<semantics::GenericDetails>()};
   for (const Symbol &specific : details.specificProcs()) {
+    if (!ResolveForward(specific)) {
+      continue;
+    }
     if (std::optional<characteristics::Procedure> procedure{
             characteristics::Procedure::Characterize(
                 ProcedureDesignator{specific}, context_.intrinsics())}) {
@@ -2533,6 +2572,11 @@ MaybeExpr ExpressionAnalyzer::MakeFunctionRef(parser::CharBlock callSite,
       return Expr<SomeType>{NullPointer{}};
     }
   }
+  if (const Symbol * symbol{proc.GetSymbol()}) {
+    if (!ResolveForward(*symbol)) {
+      return std::nullopt;
+    }
+  }
   if (auto chars{CheckCall(callSite, proc, arguments)}) {
     if (chars->functionResult) {
       const auto &result{*chars->functionResult};
@@ -2547,28 +2591,6 @@ MaybeExpr ExpressionAnalyzer::MakeFunctionRef(parser::CharBlock callSite,
       }
     }
   }
-  if (const Symbol * symbol{proc.GetSymbol()}) {
-    if (const auto *details{
-            symbol->detailsIf<semantics::SubprogramNameDetails>()}) {
-      // If this symbol is still a SubprogramNameDetails, we must be
-      // checking a specification expression in a sibling module or internal
-      // procedure.  Since recursion is disallowed in specification
-      // expressions, we should handle such references by processing the
-      // sibling procedure's specification part right now (recursively),
-      // but until we can do so, just complain about the forward reference.
-      // TODO: recursively process sibling's specification part.
-      if (details->kind() == semantics::SubprogramKind::Module) {
-        Say("The module function '%s' must have been previously defined "
-            "when referenced in a specification expression"_err_en_US,
-            symbol->name());
-      } else {
-        Say("The internal function '%s' cannot be referenced in "
-            "a specification expression"_err_en_US,
-            symbol->name());
-      }
-      return std::nullopt;
-    }
-  }
   return std::nullopt;
 }
 
diff --git a/lib/Semantics/program-tree.h b/lib/Semantics/program-tree.h
index 84e33ba7738d..43d986be7544 100644
--- a/lib/Semantics/program-tree.h
+++ b/lib/Semantics/program-tree.h
@@ -11,6 +11,7 @@
 
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/symbol.h"
+#include <list>
 #include <variant>
 
 // A ProgramTree represents a tree of program units and their contained
@@ -56,11 +57,17 @@ class ProgramTree {
   const parser::Name &name() const { return name_; }
   Kind GetKind() const;
   const Stmt &stmt() const { return stmt_; }
+  bool isSpecificationPartResolved() const {
+    return isSpecificationPartResolved_;
+  }
+  void set_isSpecificationPartResolved(bool yes = true) {
+    isSpecificationPartResolved_ = yes;
+  }
   const parser::ParentIdentifier &GetParentId() const;  // only for Submodule
   const parser::SpecificationPart &spec() const { return spec_; }
   const parser::ExecutionPart *exec() const { return exec_; }
-  std::vector<ProgramTree> &children() { return children_; }
-  const std::vector<ProgramTree> &children() const { return children_; }
+  std::list<ProgramTree> &children() { return children_; }
+  const std::list<ProgramTree> &children() const { return children_; }
   Symbol::Flag GetSubpFlag() const;
   bool IsModule() const;  // Module or Submodule
   bool HasModulePrefix() const;  // in function or subroutine stmt
@@ -84,9 +91,10 @@ class ProgramTree {
       static_cast<const parser::Statement<parser::ProgramStmt> *>(nullptr)};
   const parser::SpecificationPart &spec_;
   const parser::ExecutionPart *exec_{nullptr};
-  std::vector<ProgramTree> children_;
+  std::list<ProgramTree> children_;
   Scope *scope_{nullptr};
   const parser::CharBlock *endStmt_{nullptr};
+  bool isSpecificationPartResolved_{false};
 };
 
 }
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index d3d3c7067a54..42766f738e07 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -90,6 +90,9 @@ class ImplicitRules {
   friend void ShowImplicitRule(std::ostream &, const ImplicitRules &, char);
 };
 
+// scope -> implicit rules for that scope
+using ImplicitRulesMap = std::map<const Scope *, ImplicitRules>;
+
 // Track statement source locations and save messages.
 class MessageHandler {
 public:
@@ -135,8 +138,9 @@ class MessageHandler {
 class BaseVisitor {
 public:
   BaseVisitor() { DIE("BaseVisitor: default-constructed"); }
-  BaseVisitor(SemanticsContext &c, ResolveNamesVisitor &v)
-    : this_{&v}, context_{&c}, messageHandler_{c} {}
+  BaseVisitor(
+      SemanticsContext &c, ResolveNamesVisitor &v, ImplicitRulesMap &rules)
+    : implicitRulesMap_{&rules}, this_{&v}, context_{&c}, messageHandler_{c} {}
   template<typename T> void Walk(const T &);
 
   MessageHandler &messageHandler() { return messageHandler_; }
@@ -215,6 +219,9 @@ class BaseVisitor {
     return messageHandler_.Say(name.source, std::move(text), args...);
   }
 
+protected:
+  ImplicitRulesMap *implicitRulesMap_{nullptr};
+
 private:
   ResolveNamesVisitor *this_;
   SemanticsContext *context_;
@@ -377,8 +384,6 @@ class ImplicitRulesVisitor : public DeclTypeSpecVisitor {
   void SetScope(const Scope &);
 
 private:
-  // scope -> implicit rules for that scope
-  std::map<const Scope *, ImplicitRules> implicitRulesMap_;
   // implicit rules in effect for current scope
   ImplicitRules *implicitRules_{nullptr};
   std::optional<SourceName> prevImplicit_;
@@ -1330,7 +1335,8 @@ class ResolveNamesVisitor : public virtual ScopeHandler,
   using SubprogramVisitor::Post;
   using SubprogramVisitor::Pre;
 
-  ResolveNamesVisitor(SemanticsContext &context) : BaseVisitor{context, *this} {
+  ResolveNamesVisitor(SemanticsContext &context, ImplicitRulesMap &rules)
+    : BaseVisitor{context, *this, rules} {
     PushScope(context.globalScope());
   }
 
@@ -1370,6 +1376,8 @@ class ResolveNamesVisitor : public virtual ScopeHandler,
 
   void NoteExecutablePartCall(Symbol::Flag, const parser::Call &);
 
+  friend void ResolveSpecificationParts(SemanticsContext &, const Symbol &);
+
 private:
   // Kind of procedure we are expecting to see in a ProcedureDesignator
   std::optional<Symbol::Flag> expectedProcFlag_;
@@ -1384,8 +1392,8 @@ class ResolveNamesVisitor : public virtual ScopeHandler,
   void HandleProcedureName(Symbol::Flag, const parser::Name &);
   bool SetProcFlag(const parser::Name &, Symbol &, Symbol::Flag);
   void ResolveSpecificationParts(ProgramTree &);
-  void AddSubpNames(const ProgramTree &);
-  bool BeginScope(const ProgramTree &);
+  void AddSubpNames(ProgramTree &);
+  bool BeginScopeForNode(const ProgramTree &);
   void FinishSpecificationParts(const ProgramTree &);
   void FinishDerivedTypeInstantiation(Scope &);
   void ResolveExecutionParts(const ProgramTree &);
@@ -1712,7 +1720,7 @@ void ImplicitRulesVisitor::Post(const parser::ImplicitSpec &) {
 }
 
 void ImplicitRulesVisitor::SetScope(const Scope &scope) {
-  implicitRules_ = &implicitRulesMap_.at(&scope);
+  implicitRules_ = &DEREF(implicitRulesMap_).at(&scope);
   prevImplicit_ = std::nullopt;
   prevImplicitNone_ = std::nullopt;
   prevImplicitNoneType_ = std::nullopt;
@@ -1720,7 +1728,7 @@ void ImplicitRulesVisitor::SetScope(const Scope &scope) {
 }
 void ImplicitRulesVisitor::BeginScope(const Scope &scope) {
   // find or create implicit rules for this scope
-  implicitRulesMap_.try_emplace(&scope, context(), implicitRules_);
+  DEREF(implicitRulesMap_).try_emplace(&scope, context(), implicitRules_);
   SetScope(scope);
 }
 
@@ -1910,7 +1918,7 @@ void ScopeHandler::PushScope(Scope &scope) {
   currScope_ = &scope;
   auto kind{currScope_->kind()};
   if (kind != Scope::Kind::Block) {
-    ImplicitRulesVisitor::BeginScope(scope);
+    BeginScope(scope);
   }
   // The name of a module or submodule cannot be "used" in its scope,
   // as we read 19.3.1(2), so we allow the name to be used as a local
@@ -5818,7 +5826,11 @@ class ExecutionPartSkimmer {
 // Build the scope tree and resolve names in the specification parts of this
 // node and its children
 void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
-  if (!BeginScope(node)) {
+  if (node.isSpecificationPartResolved()) {
+    return;  // been here already
+  }
+  node.set_isSpecificationPartResolved();
+  if (!BeginScopeForNode(node)) {
     return;  // an error prevented scope from being created
   }
   Scope &scope{currScope()};
@@ -5861,18 +5873,18 @@ void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
   }
 }
 
-// Add SubprogramNameDetails symbols for contained subprograms
-void ResolveNamesVisitor::AddSubpNames(const ProgramTree &node) {
+// Add SubprogramNameDetails symbols for module and internal subprograms
+void ResolveNamesVisitor::AddSubpNames(ProgramTree &node) {
   auto kind{
       node.IsModule() ? SubprogramKind::Module : SubprogramKind::Internal};
-  for (const auto &child : node.children()) {
-    auto &symbol{MakeSymbol(child.name(), SubprogramNameDetails{kind})};
+  for (auto &child : node.children()) {
+    auto &symbol{MakeSymbol(child.name(), SubprogramNameDetails{kind, child})};
     symbol.set(child.GetSubpFlag());
   }
 }
 
 // Push a new scope for this node or return false on error.
-bool ResolveNamesVisitor::BeginScope(const ProgramTree &node) {
+bool ResolveNamesVisitor::BeginScopeForNode(const ProgramTree &node) {
   switch (node.GetKind()) {
     SWITCH_COVERS_ALL_CASES
   case ProgramTree::Kind::Program:
@@ -6539,8 +6551,29 @@ void ResolveNamesVisitor::Post(const parser::Program &) {
   CHECK(!GetDeclTypeSpec());
 }
 
+// A singleton instance of the scope -> IMPLICIT rules mapping is
+// shared by all instances of ResolveNamesVisitor and accessed by this
+// pointer when the visitors (other than the top-level original) are
+// constructed.
+static ImplicitRulesMap *sharedImplicitRulesMap{nullptr};
+
 bool ResolveNames(SemanticsContext &context, const parser::Program &program) {
-  ResolveNamesVisitor{context}.Walk(program);
+  ImplicitRulesMap implicitRulesMap;
+  auto restorer{common::ScopedSet(sharedImplicitRulesMap, &implicitRulesMap)};
+  ResolveNamesVisitor{context, implicitRulesMap}.Walk(program);
   return !context.AnyFatalError();
 }
+
+// Processes a module (but not internal) function when it is referenced
+// in a specification expression in a sibling procedure.
+void ResolveSpecificationParts(
+    SemanticsContext &context, const Symbol &subprogram) {
+  auto originalLocation{context.location()};
+  ResolveNamesVisitor visitor{context, DEREF(sharedImplicitRulesMap)};
+  ProgramTree &node{subprogram.get<SubprogramNameDetails>().node()};
+  const Scope &moduleScope{subprogram.owner()};
+  visitor.SetScope(const_cast<Scope &>(moduleScope));
+  visitor.ResolveSpecificationParts(node);
+  context.set_location(std::move(originalLocation));
+}
 }
diff --git a/lib/Semantics/resolve-names.h b/lib/Semantics/resolve-names.h
index 8f233adc5ec3..240f315bb715 100644
--- a/lib/Semantics/resolve-names.h
+++ b/lib/Semantics/resolve-names.h
@@ -20,8 +20,10 @@ struct Program;
 namespace Fortran::semantics {
 
 class SemanticsContext;
+class Symbol;
 
 bool ResolveNames(SemanticsContext &, const parser::Program &);
+void ResolveSpecificationParts(SemanticsContext &, const Symbol &);
 void DumpSymbols(std::ostream &);
 
 }
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index f77a5cc8aaf1..cc3b9084af34 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -607,8 +607,7 @@ bool IsOrContainsEventOrLockComponent(const Symbol &symbol) {
 
 bool IsSaved(const Symbol &symbol) {
   auto scopeKind{symbol.owner().kind()};
-  if (scopeKind == Scope::Kind::MainProgram ||
-      scopeKind == Scope::Kind::Module) {
+  if (scopeKind == Scope::Kind::Module || scopeKind == Scope::Kind::BlockData) {
     return true;
   } else if (scopeKind == Scope::Kind::DerivedType) {
     return false;  // this is a component
diff --git a/test/Semantics/expr-errors02.f90 b/test/Semantics/expr-errors02.f90
index d1aac68bf008..4b0d6d4118f3 100644
--- a/test/Semantics/expr-errors02.f90
+++ b/test/Semantics/expr-errors02.f90
@@ -29,7 +29,7 @@ subroutine test(out, optional)
     integer :: local
     !ERROR: Invalid specification expression: reference to local entity 'local'
     type(t(local)) :: x2
-    !ERROR: The internal function 'internal' cannot be referenced in a specification expression
+    !ERROR: The internal function 'internal' may not be referenced in a specification expression
     type(t(internal(0))) :: x3
     integer, intent(out) :: out
     !ERROR: Invalid specification expression: reference to INTENT(OUT) dummy argument 'out'
@@ -43,7 +43,6 @@ subroutine test(out, optional)
     type(t(coarray[1])) :: x7
     type(t(kind(foo()))) :: x101 ! ok
     type(t(modulefunc1(0))) :: x102 ! ok
-    !ERROR: The module function 'modulefunc2' must have been previously defined when referenced in a specification expression
     type(t(modulefunc2(0))) :: x103 ! ok
    contains
     pure integer function internal(n)
diff --git a/test/Semantics/resolve59.f90 b/test/Semantics/resolve59.f90
index 0e6965a5d165..fdc437030971 100644
--- a/test/Semantics/resolve59.f90
+++ b/test/Semantics/resolve59.f90
@@ -41,7 +41,7 @@ function f4()
     f4 => rf
     ! OK call to f4 pointer (rf)
     x = acos(f4())
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     x = acos(f4)
   end function
   function f5(x)
@@ -55,7 +55,7 @@ real function rfunc(x)
     f5 => rfunc
     ! OK call to f5 pointer
     x = acos(f5(x+1))
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     x = acos(f5)
   end function
   ! Sanity test: f18 handles C1560 violation by ignoring RESULT
@@ -78,21 +78,21 @@ module m_with_result
   function f1() result(r)
     real :: r
     r = acos(f1()) !OK, recursive call
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     x = acos(f1)
   end function
   function f2(i) result(r)
     integer i
     real :: r
     r = acos(f2(i+1)) ! OK, recursive call
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     r = acos(f2)
   end function
   function f3(i) result(r)
     integer i
     real :: r(1)
     r = acos(f3(i+1)) !OK recursive call
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     r = sum(acos(f3))
   end function
 
@@ -104,9 +104,9 @@ function f4() result(r)
     real :: x
     procedure(rf), pointer :: r
     r => rf
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     x = acos(f4()) ! recursive call
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     x = acos(f4)
     x = acos(r()) ! OK
   end function
@@ -114,9 +114,9 @@ function f5(x) result(r)
     real :: x
     procedure(acos), pointer :: r
     r => acos
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     x = acos(f5(x+1)) ! recursive call
-    !ERROR: Typeless item not allowed for 'x=' argument
+    !ERROR: Actual argument for 'x=' may not be a procedure
     x = acos(f5)
     x = acos(r(x+1)) ! OK
   end function
diff --git a/test/Semantics/resolve77.f90 b/test/Semantics/resolve77.f90
new file mode 100644
index 000000000000..4d34ce3b8b48
--- /dev/null
+++ b/test/Semantics/resolve77.f90
@@ -0,0 +1,52 @@
+! RUN: %S/test_errors.sh %s %flang %t
+! Tests valid and invalid usage of forward references to procedures
+! in specification expressions.
+module m
+  interface ifn2
+    module procedure if2
+  end interface
+  interface ifn3
+    module procedure if3
+  end interface
+  !ERROR: Specification expression must be constant in declaration of 'a' with the SAVE attribute
+  real :: a(if1(1))
+  !ERROR: No specific procedure of generic 'ifn2' matches the actual arguments
+  real :: b(ifn2(1))
+ contains
+  subroutine t1(n)
+    integer :: iarr(if1(n))
+  end subroutine
+  pure integer function if1(n)
+    integer, intent(in) :: n
+    if1 = n
+  end function
+  subroutine t2(n)
+    integer :: iarr(ifn3(n)) ! should resolve to if3
+  end subroutine
+  pure integer function if2(n)
+    integer, intent(in) :: n
+    if2 = n
+  end function
+  pure integer function if3(n)
+    integer, intent(in) :: n
+    if3 = n
+  end function
+end module
+
+subroutine nester
+  !ERROR: The internal function 'if1' may not be referenced in a specification expression
+  real :: a(if1(1))
+ contains
+  subroutine t1(n)
+    !ERROR: The internal function 'if2' may not be referenced in a specification expression
+    integer :: iarr(if2(n))
+  end subroutine
+  pure integer function if1(n)
+    integer, intent(in) :: n
+    if1 = n
+  end function
+  pure integer function if2(n)
+    integer, intent(in) :: n
+    if2 = n
+  end function
+end subroutine

From a3507d44b8911e6024033aa583c1dc54e0eb89fd Mon Sep 17 00:00:00 2001
From: Caroline Concatto <caroline.concatto@arm.com>
Date: Fri, 28 Feb 2020 15:11:03 +0000
Subject: [PATCH 096/345] [LLVMify F18] Replace the use std::ostream with LLVM
 streams llvm::ostream

This patch replaces the occurrence of std::ostream by llvm::raw_ostream.
In  LLVM Coding Standards[1] "All new code should use raw_ostream
instead of ostream".[1]

As a consequence, this patch also replaces the use of:
   std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream*
   std::ofstream by llvm::raw_fd_ostream
   std::endl by '\n' and flush()[2]
   std::cout by llvm::outs()   and
   std::cerr by llvm::errs()

It also replaces  std::strerro by llvm::sys::StrError** , but NOT in  Fortran
runtime libraries

*std::stringstream were replaced by llvm::raw_ostream in all methods that
used std::stringstream as a parameter. Moreover, it removes the pointers to
these streams.

[1]https://llvm.org/docs/CodingStandards.html
[2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl

Signed-off-by: Caroline Concatto <caroline.concatto@arm.com>

Running clang-format-7

Signed-off-by: Caroline Concatto <caroline.concatto@arm.com>

Removing residue of ostream library

Signed-off-by: Caroline Concatto <caroline.concatto@arm.com>
---
 documentation/ParserCombinators.md            |   2 +-
 include/flang/Common/enum-set.h               |   6 +-
 include/flang/Evaluate/call.h                 |  15 ++-
 include/flang/Evaluate/characteristics.h      |  19 +--
 include/flang/Evaluate/complex.h              |   6 +-
 include/flang/Evaluate/constant.h             |   9 +-
 include/flang/Evaluate/expression.h           |  23 ++--
 include/flang/Evaluate/formatting.h           |  14 +--
 include/flang/Evaluate/intrinsics.h           |   7 +-
 include/flang/Evaluate/real.h                 |   6 +-
 include/flang/Evaluate/static-data.h          |   7 +-
 include/flang/Evaluate/variable.h             |  33 ++---
 include/flang/Lower/PFTBuilder.h              |   5 +-
 include/flang/Parser/char-block.h             |   6 +-
 include/flang/Parser/dump-parse-tree.h        |  14 +--
 include/flang/Parser/instrumented-parser.h    |   7 +-
 include/flang/Parser/message.h                |   5 +-
 include/flang/Parser/parsing.h                |  14 +--
 include/flang/Parser/provenance.h             |  17 ++-
 include/flang/Parser/source.h                 |  11 +-
 include/flang/Parser/unparse.h                |  14 ++-
 include/flang/Parser/user-state.h             |  10 +-
 include/flang/Semantics/attr.h                |  10 +-
 include/flang/Semantics/scope.h               |   6 +-
 include/flang/Semantics/semantics.h           |  10 +-
 include/flang/Semantics/symbol.h              |  22 ++--
 include/flang/Semantics/type.h                |  20 +--
 .../flang/Semantics/unparse-with-symbols.h    |   6 +-
 lib/Evaluate/characteristics.cpp              |  18 +--
 lib/Evaluate/complex.cpp                      |   3 +-
 lib/Evaluate/expression.cpp                   |   1 +
 lib/Evaluate/formatting.cpp                   | 119 ++++++++++--------
 lib/Evaluate/host.cpp                         |  13 +-
 lib/Evaluate/intrinsics.cpp                   |  22 ++--
 lib/Evaluate/real.cpp                         |   5 +-
 lib/Evaluate/static-data.cpp                  |   2 +-
 lib/Evaluate/type.cpp                         |   1 -
 lib/Evaluate/variable.cpp                     |   1 -
 lib/Parser/CMakeLists.txt                     |   1 +
 lib/Parser/char-block.cpp                     |   4 +-
 lib/Parser/debug-parser.cpp                   |   1 -
 lib/Parser/instrumented-parser.cpp            |   4 +-
 lib/Parser/message.cpp                        |  11 +-
 lib/Parser/parse-tree.cpp                     |   3 +-
 lib/Parser/parsing.cpp                        |  24 ++--
 lib/Parser/preprocessor.cpp                   |  10 +-
 lib/Parser/prescan.cpp                        |   7 +-
 lib/Parser/provenance.cpp                     |  22 ++--
 lib/Parser/source.cpp                         |  20 +--
 lib/Parser/token-sequence.cpp                 |   5 +-
 lib/Parser/token-sequence.h                   |   9 +-
 lib/Parser/unparse.cpp                        |  11 +-
 lib/Semantics/attr.cpp                        |   6 +-
 lib/Semantics/expression.cpp                  |  11 +-
 lib/Semantics/mod-file.cpp                    |  96 +++++++-------
 lib/Semantics/mod-file.h                      |  21 +++-
 lib/Semantics/pointer-assignment.cpp          |   4 +-
 lib/Semantics/resolve-names-utils.cpp         |   1 -
 lib/Semantics/resolve-names.cpp               |  13 +-
 lib/Semantics/resolve-names.h                 |   6 +-
 lib/Semantics/scope.cpp                       |   7 +-
 lib/Semantics/semantics.cpp                   |  15 +--
 lib/Semantics/symbol.cpp                      |  48 +++----
 lib/Semantics/tools.cpp                       |   5 +-
 lib/Semantics/type.cpp                        |  31 +++--
 lib/Semantics/unparse-with-symbols.cpp        |  17 ++-
 tools/f18/dump.cpp                            |  14 +--
 tools/f18/f18-parse-demo.cpp                  |  53 ++++----
 tools/f18/f18.cpp                             | 100 ++++++++-------
 unittests/Decimal/CMakeLists.txt              |   2 +
 unittests/Decimal/quick-sanity-test.cpp       |  19 ++-
 unittests/Decimal/thorough-test.cpp           |  24 ++--
 unittests/Evaluate/CMakeLists.txt             |  11 ++
 unittests/Evaluate/ISO-Fortran-binding.cpp    |  18 ++-
 unittests/Evaluate/fp-testing.cpp             |  13 +-
 unittests/Evaluate/intrinsics.cpp             |  19 +--
 unittests/Evaluate/real.cpp                   |   9 +-
 unittests/Evaluate/testing.cpp                |  14 +--
 unittests/Evaluate/uint128.cpp                |   6 +-
 unittests/Runtime/CMakeLists.txt              |   4 +
 unittests/Runtime/format.cpp                  |  10 +-
 unittests/Runtime/hello.cpp                   |   6 +-
 unittests/Runtime/list-input.cpp              |   2 +-
 unittests/Runtime/testing.cpp                 |  10 +-
 unittests/Runtime/testing.h                   |   6 +-
 85 files changed, 722 insertions(+), 540 deletions(-)

diff --git a/documentation/ParserCombinators.md b/documentation/ParserCombinators.md
index 383367144b2b..b05d281590e9 100644
--- a/documentation/ParserCombinators.md
+++ b/documentation/ParserCombinators.md
@@ -160,5 +160,5 @@ is built.  All of the following parsers consume characters acquired from
 
 ### Debugging Parser
 Last, a string literal `"..."_debug` denotes a parser that emits the string to
-`std::cerr` and succeeds.  It is useful for tracing while debugging a parser but should
+`llvm::errs` and succeeds.  It is useful for tracing while debugging a parser but should
 obviously not be committed for production code.
diff --git a/include/flang/Common/enum-set.h b/include/flang/Common/enum-set.h
index 4b255c38cc5a..ca8bc0cbd838 100644
--- a/include/flang/Common/enum-set.h
+++ b/include/flang/Common/enum-set.h
@@ -16,11 +16,11 @@
 
 #include "constexpr-bitset.h"
 #include "idioms.h"
+#include "llvm/Support/raw_ostream.h"
 #include <bitset>
 #include <cstddef>
 #include <initializer_list>
 #include <optional>
-#include <ostream>
 #include <string>
 #include <type_traits>
 
@@ -199,8 +199,8 @@ template<typename ENUM, std::size_t BITS> class EnumSet {
     }
   }
 
-  std::ostream &Dump(
-      std::ostream &o, std::string EnumToString(enumerationType)) const {
+  llvm::raw_ostream &Dump(
+      llvm::raw_ostream &o, std::string EnumToString(enumerationType)) const {
     char sep{'{'};
     IterateOverMembers([&](auto e) {
       o << sep << EnumToString(e);
diff --git a/include/flang/Evaluate/call.h b/include/flang/Evaluate/call.h
index a792ff4188ec..e083c75708b9 100644
--- a/include/flang/Evaluate/call.h
+++ b/include/flang/Evaluate/call.h
@@ -18,9 +18,12 @@
 #include "flang/Parser/char-block.h"
 #include "flang/Semantics/attr.h"
 #include <optional>
-#include <ostream>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::semantics {
 class Symbol;
 }
@@ -60,7 +63,7 @@ class ActualArgument {
     bool operator==(const AssumedType &that) const {
       return &*symbol_ == &*that.symbol_;
     }
-    std::ostream &AsFortran(std::ostream &) const;
+    llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   private:
     SymbolRef symbol_;
@@ -101,7 +104,7 @@ class ActualArgument {
   std::optional<DynamicType> GetType() const;
   int Rank() const;
   bool operator==(const ActualArgument &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   std::optional<parser::CharBlock> keyword() const { return keyword_; }
   void set_keyword(parser::CharBlock x) { keyword_ = x; }
@@ -146,7 +149,7 @@ struct SpecificIntrinsic {
   DECLARE_CONSTRUCTORS_AND_ASSIGNMENTS(SpecificIntrinsic)
   ~SpecificIntrinsic();
   bool operator==(const SpecificIntrinsic &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   IntrinsicProcedure name;
   bool isRestrictedSpecific{false};  // if true, can only call it, not pass it
@@ -177,7 +180,7 @@ struct ProcedureDesignator {
   int Rank() const;
   bool IsElemental() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   std::variant<SpecificIntrinsic, SymbolRef,
       common::CopyableIndirection<Component>>
@@ -200,7 +203,7 @@ class ProcedureRef {
   int Rank() const;
   bool IsElemental() const { return proc_.IsElemental(); }
   bool operator==(const ProcedureRef &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 protected:
   ProcedureDesignator proc_;
diff --git a/include/flang/Evaluate/characteristics.h b/include/flang/Evaluate/characteristics.h
index d0890465b7c1..50717f04c515 100644
--- a/include/flang/Evaluate/characteristics.h
+++ b/include/flang/Evaluate/characteristics.h
@@ -24,11 +24,14 @@
 #include "flang/Parser/char-block.h"
 #include "flang/Semantics/symbol.h"
 #include <optional>
-#include <ostream>
 #include <string>
 #include <variant>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::evaluate {
 class IntrinsicProcTable;
 }
@@ -131,7 +134,7 @@ class TypeAndShape {
       const char *thisIs = "POINTER", const char *thatIs = "TARGET",
       bool isElemental = false) const;
 
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   void AcquireShape(const semantics::ObjectEntityDetails &);
@@ -160,7 +163,7 @@ struct DummyDataObject {
   }
   static std::optional<DummyDataObject> Characterize(const semantics::Symbol &);
   bool CanBePassedViaImplicitInterface() const;
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
   TypeAndShape type;
   std::vector<Expr<SubscriptInteger>> coshape;
   common::Intent intent{common::Intent::Default};
@@ -177,7 +180,7 @@ struct DummyProcedure {
   bool operator!=(const DummyProcedure &that) const { return !(*this == that); }
   static std::optional<DummyProcedure> Characterize(
       const semantics::Symbol &, const IntrinsicProcTable &);
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
   CopyableIndirection<Procedure> procedure;
   common::Intent intent{common::Intent::Default};
   Attrs attrs;
@@ -187,7 +190,7 @@ struct DummyProcedure {
 struct AlternateReturn {
   bool operator==(const AlternateReturn &) const { return true; }
   bool operator!=(const AlternateReturn &) const { return false; }
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 };
 
 // 15.3.2.1
@@ -208,7 +211,7 @@ struct DummyArgument {
   bool IsOptional() const;
   void SetOptional(bool = true);
   bool CanBePassedViaImplicitInterface() const;
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
   // name and pass are not characteristics and so does not participate in
   // operator== but are needed to determine if procedures are distinguishable
   std::string name;
@@ -247,7 +250,7 @@ struct FunctionResult {
   void SetType(DynamicType t) { std::get<TypeAndShape>(u).set_type(t); }
   bool CanBeReturnedViaImplicitInterface() const;
 
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
   Attrs attrs;
   std::variant<TypeAndShape, CopyableIndirection<Procedure>> u;
@@ -288,7 +291,7 @@ struct Procedure {
   int FindPassIndex(std::optional<parser::CharBlock>) const;
   bool CanBeCalledViaImplicitInterface() const;
   bool CanOverride(const Procedure &, std::optional<int> passIndex) const;
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
   std::optional<FunctionResult> functionResult;
   DummyArguments dummyArguments;
diff --git a/include/flang/Evaluate/complex.h b/include/flang/Evaluate/complex.h
index 370bcfbb5bce..6c404638ab4f 100644
--- a/include/flang/Evaluate/complex.h
+++ b/include/flang/Evaluate/complex.h
@@ -13,6 +13,10 @@
 #include "real.h"
 #include <string>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::evaluate::value {
 
 template<typename REAL_TYPE> class Complex {
@@ -82,7 +86,7 @@ template<typename REAL_TYPE> class Complex {
   }
 
   std::string DumpHexadecimal() const;
-  std::ostream &AsFortran(std::ostream &, int kind) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &, int kind) const;
 
   // TODO: (C)ABS once Real::HYPOT is done
   // TODO: unit testing
diff --git a/include/flang/Evaluate/constant.h b/include/flang/Evaluate/constant.h
index 2a4a8109283f..e57563a6ee8c 100644
--- a/include/flang/Evaluate/constant.h
+++ b/include/flang/Evaluate/constant.h
@@ -14,9 +14,12 @@
 #include "flang/Common/default-kinds.h"
 #include "flang/Common/reference.h"
 #include <map>
-#include <ostream>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::semantics {
 class Symbol;
 }
@@ -110,7 +113,7 @@ class ConstantBase : public ConstantBounds {
   constexpr Result result() const { return result_; }
 
   constexpr DynamicType GetType() const { return result_.GetType(); }
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 protected:
   std::vector<Element> Reshape(const ConstantSubscripts &) const;
@@ -178,7 +181,7 @@ class Constant<Type<TypeCategory::Character, KIND>> : public ConstantBounds {
   Scalar<Result> At(const ConstantSubscripts &) const;
 
   Constant Reshape(ConstantSubscripts &&) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   static constexpr DynamicType GetType() {
     return {TypeCategory::Character, KIND};
   }
diff --git a/include/flang/Evaluate/expression.h b/include/flang/Evaluate/expression.h
index e4bd57f2ae1c..b63fb1ede37b 100644
--- a/include/flang/Evaluate/expression.h
+++ b/include/flang/Evaluate/expression.h
@@ -28,11 +28,14 @@
 #include "flang/Parser/char-block.h"
 #include <algorithm>
 #include <list>
-#include <ostream>
 #include <tuple>
 #include <type_traits>
 #include <variant>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::evaluate {
 
 using common::LogicalOperator;
@@ -90,7 +93,7 @@ template<typename RESULT> class ExpressionBase {
   std::optional<DynamicType> GetType() const;
   int Rank() const;
   std::string AsFortran() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   static Derived Rewrite(FoldingContext &, Derived &&);
 };
 
@@ -185,7 +188,7 @@ class Operation {
     return operand_ == that.operand_;
   }
 
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   Container operand_;
@@ -212,7 +215,7 @@ struct Convert : public Operation<Convert<TO, FROMCAT>, TO, SomeKind<FROMCAT>> {
   using Operand = SomeKind<FROMCAT>;
   using Base = Operation<Convert, Result, Operand>;
   using Base::Base;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
 template<typename A>
@@ -446,7 +449,7 @@ class ArrayConstructor : public ArrayConstructorValues<RESULT> {
   template<typename T> explicit ArrayConstructor(const Expr<T> &) {}
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
 template<int KIND>
@@ -464,7 +467,7 @@ class ArrayConstructor<Type<TypeCategory::Character, KIND>>
   bool operator==(const ArrayConstructor &) const;
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   const Expr<SubscriptInteger> &LEN() const { return length_.value(); }
 
 private:
@@ -488,7 +491,7 @@ class ArrayConstructor<SomeDerived>
   bool operator==(const ArrayConstructor &) const;
   constexpr Result result() const { return result_; }
   constexpr DynamicType GetType() const { return result_.GetType(); }
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   Result result_;
@@ -629,7 +632,7 @@ template<> class Relational<SomeType> {
   int Rank() const {
     return std::visit([](const auto &x) { return x.Rank(); }, u);
   }
-  std::ostream &AsFortran(std::ostream &o) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &o) const;
   common::MapTemplate<Relational, DirectlyComparableTypes> u;
 };
 
@@ -715,7 +718,7 @@ class StructureConstructor {
   StructureConstructor &Add(const semantics::Symbol &, Expr<SomeType> &&);
   int Rank() const { return 0; }
   DynamicType GetType() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   Result result_;
@@ -823,7 +826,7 @@ class Assignment {
   using BoundsSpec = std::vector<Expr<SubscriptInteger>>;
   using BoundsRemapping =
       std::vector<std::pair<Expr<SubscriptInteger>, Expr<SubscriptInteger>>>;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   Expr<SomeType> lhs;
   Expr<SomeType> rhs;
diff --git a/include/flang/Evaluate/formatting.h b/include/flang/Evaluate/formatting.h
index c2e5316e39b1..b9f9c2f2e15a 100644
--- a/include/flang/Evaluate/formatting.h
+++ b/include/flang/Evaluate/formatting.h
@@ -9,10 +9,10 @@
 #ifndef FORTRAN_EVALUATE_FORMATTING_H_
 #define FORTRAN_EVALUATE_FORMATTING_H_
 
-// It is inconvenient in C++ to have std::ostream::operator<<() as a direct
+// It is inconvenient in C++ to have llvm::raw_ostream::operator<<() as a direct
 // friend function of a class template with many instantiations, so the
 // various representational class templates in lib/Evaluate format themselves
-// via AsFortran(std::ostream &) member functions, which the operator<<()
+// via AsFortran(llvm::raw_ostream &) member functions, which the operator<<()
 // overload below will call.  Others have AsFortran() member functions that
 // return strings.
 //
@@ -20,31 +20,31 @@
 // representational class templates that need it, not by external clients.
 
 #include "flang/Common/indirection.h"
+#include "llvm/Support/raw_ostream.h"
 #include <optional>
-#include <ostream>
 #include <type_traits>
 
 namespace Fortran::evaluate {
 
 template<typename A>
-auto operator<<(std::ostream &o, const A &x) -> decltype(x.AsFortran(o)) {
+auto operator<<(llvm::raw_ostream &o, const A &x) -> decltype(x.AsFortran(o)) {
   return x.AsFortran(o);
 }
 
 template<typename A>
-auto operator<<(std::ostream &o, const A &x) -> decltype(o << x.AsFortran()) {
+auto operator<<(llvm::raw_ostream &o, const A &x) -> decltype(o << x.AsFortran()) {
   return o << x.AsFortran();
 }
 
 template<typename A, bool COPYABLE>
 auto operator<<(
-    std::ostream &o, const Fortran::common::Indirection<A, COPYABLE> &x)
+    llvm::raw_ostream &o, const Fortran::common::Indirection<A, COPYABLE> &x)
     -> decltype(o << x.value()) {
   return o << x.value();
 }
 
 template<typename A>
-auto operator<<(std::ostream &o, const std::optional<A> &x)
+auto operator<<(llvm::raw_ostream &o, const std::optional<A> &x)
     -> decltype(o << *x) {
   if (x) {
     o << *x;
diff --git a/include/flang/Evaluate/intrinsics.h b/include/flang/Evaluate/intrinsics.h
index dce5162cb944..2cc523b037e7 100644
--- a/include/flang/Evaluate/intrinsics.h
+++ b/include/flang/Evaluate/intrinsics.h
@@ -16,9 +16,12 @@
 #include "flang/Parser/char-block.h"
 #include "flang/Parser/message.h"
 #include <optional>
-#include <ostream>
 #include <string>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::evaluate {
 
 class FoldingContext;
@@ -76,7 +79,7 @@ class IntrinsicProcTable {
   std::optional<SpecificIntrinsicFunctionInterface> IsSpecificIntrinsicFunction(
       const std::string &) const;
 
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   Implementation *impl_{nullptr};  // owning pointer
diff --git a/include/flang/Evaluate/real.h b/include/flang/Evaluate/real.h
index fbb52086f0cb..43b3aebbac84 100644
--- a/include/flang/Evaluate/real.h
+++ b/include/flang/Evaluate/real.h
@@ -16,13 +16,15 @@
 #include "flang/Evaluate/common.h"
 #include <cinttypes>
 #include <limits>
-#include <ostream>
 #include <string>
 
 // Some environments, viz. clang on Darwin, allow the macro HUGE
 // to leak out of <math.h> even when it is never directly included.
 #undef HUGE
 
+namespace llvm {
+class raw_ostream;
+}
 namespace Fortran::evaluate::value {
 
 // LOG10(2.)*1E12
@@ -310,7 +312,7 @@ class Real : public common::RealDetails<PREC> {
 
   // Emits a character representation for an equivalent Fortran constant
   // or parenthesized constant expression that produces this value.
-  std::ostream &AsFortran(std::ostream &, int kind, bool minimal = false) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &, int kind, bool minimal = false) const;
 
 private:
   using Significand = Integer<significandBits>;  // no implicit bit
diff --git a/include/flang/Evaluate/static-data.h b/include/flang/Evaluate/static-data.h
index 5a708aa25390..c588a77beee2 100644
--- a/include/flang/Evaluate/static-data.h
+++ b/include/flang/Evaluate/static-data.h
@@ -17,10 +17,13 @@
 #include <cinttypes>
 #include <memory>
 #include <optional>
-#include <ostream>
 #include <string>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::evaluate {
 
 class StaticDataObject {
@@ -63,7 +66,7 @@ class StaticDataObject {
   std::optional<std::string> AsString() const;
   std::optional<std::u16string> AsU16String() const;
   std::optional<std::u32string> AsU32String() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   static bool bigEndian;
 
diff --git a/include/flang/Evaluate/variable.h b/include/flang/Evaluate/variable.h
index 62effec2c636..0004b0a9c636 100644
--- a/include/flang/Evaluate/variable.h
+++ b/include/flang/Evaluate/variable.h
@@ -25,10 +25,13 @@
 #include "flang/Common/template.h"
 #include "flang/Parser/char-block.h"
 #include <optional>
-#include <ostream>
 #include <variant>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::semantics {
 class Symbol;
 }
@@ -49,7 +52,7 @@ struct BaseObject {
   EVALUATE_UNION_CLASS_BOILERPLATE(BaseObject)
   int Rank() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   const Symbol *symbol() const {
     if (const auto *result{std::get_if<SymbolRef>(&u)}) {
       return &result->get();
@@ -82,7 +85,7 @@ class Component {
   const Symbol &GetLastSymbol() const { return symbol_; }
   std::optional<Expr<SubscriptInteger>> LEN() const;
   bool operator==(const Component &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   common::CopyableIndirection<DataRef> base_;
@@ -110,7 +113,7 @@ class NamedEntity {
   int Rank() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
   bool operator==(const NamedEntity &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   std::variant<SymbolRef, Component> u_;
@@ -140,7 +143,7 @@ template<int KIND> class TypeParamInquiry {
 
   static constexpr int Rank() { return 0; }  // always scalar
   bool operator==(const TypeParamInquiry &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   std::optional<NamedEntity> base_;
@@ -168,7 +171,7 @@ class Triplet {
 
   bool operator==(const Triplet &) const;
   bool IsStrideOne() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   std::optional<IndirectSubscriptIntegerExpr> lower_, upper_;
@@ -181,7 +184,7 @@ struct Subscript {
   explicit Subscript(Expr<SubscriptInteger> &&s)
     : u{IndirectSubscriptIntegerExpr::Make(std::move(s))} {}
   int Rank() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   std::variant<IndirectSubscriptIntegerExpr, Triplet> u;
 };
 
@@ -217,7 +220,7 @@ class ArrayRef {
   const Symbol &GetLastSymbol() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
   bool operator==(const ArrayRef &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   NamedEntity base_;
@@ -265,7 +268,7 @@ class CoarrayRef {
   NamedEntity GetBase() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
   bool operator==(const CoarrayRef &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   SymbolVector base_;
@@ -286,7 +289,7 @@ struct DataRef {
   const Symbol &GetFirstSymbol() const;
   const Symbol &GetLastSymbol() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   std::variant<SymbolRef, Component, ArrayRef, CoarrayRef> u;
 };
@@ -327,7 +330,7 @@ class Substring {
   const Symbol *GetLastSymbol() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
   bool operator==(const Substring &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   std::optional<Expr<SomeCharacter>> Fold(FoldingContext &);
 
@@ -352,7 +355,7 @@ class ComplexPart {
   const Symbol &GetFirstSymbol() const { return complex_.GetFirstSymbol(); }
   const Symbol &GetLastSymbol() const { return complex_.GetLastSymbol(); }
   bool operator==(const ComplexPart &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   DataRef complex_;
@@ -387,7 +390,7 @@ template<typename T> class Designator {
   BaseObject GetBaseObject() const;
   const Symbol *GetLastSymbol() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
-  std::ostream &AsFortran(std::ostream &o) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &o) const;
 
   Variant u;
 };
@@ -405,7 +408,7 @@ template<typename T> struct Variable {
   int Rank() const {
     return std::visit([](const auto &x) { return x.Rank(); }, u);
   }
-  std::ostream &AsFortran(std::ostream &o) const {
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &o) const {
     std::visit([&](const auto &x) { x.AsFortran(o); }, u);
     return o;
   }
@@ -428,7 +431,7 @@ class DescriptorInquiry {
 
   static constexpr int Rank() { return 0; }  // always scalar
   bool operator==(const DescriptorInquiry &) const;
-  std::ostream &AsFortran(std::ostream &) const;
+  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   NamedEntity base_;
diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index bef98b519038..733027cc425d 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -11,7 +11,6 @@
 
 #include "flang/Common/template.h"
 #include "flang/Parser/parse-tree.h"
-#include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 /// Build a light-weight tree over the parse-tree to help with lowering to FIR.
@@ -26,6 +25,10 @@
 /// are either statements or constructs, where a construct contains a list of
 /// evaluations. The resulting PFT structure can then be used to create FIR.
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::lower {
 namespace pft {
 
diff --git a/include/flang/Parser/char-block.h b/include/flang/Parser/char-block.h
index 421bff9dc0d7..fd41e14821ce 100644
--- a/include/flang/Parser/char-block.h
+++ b/include/flang/Parser/char-block.h
@@ -19,6 +19,10 @@
 #include <string>
 #include <utility>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::parser {
 
 class CharBlock {
@@ -134,7 +138,7 @@ inline bool operator>(const char *left, const CharBlock &right) {
   return right < left;
 }
 
-std::ostream &operator<<(std::ostream &os, const CharBlock &x);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharBlock &x);
 
 }
 
diff --git a/include/flang/Parser/dump-parse-tree.h b/include/flang/Parser/dump-parse-tree.h
index 818dfbd625bc..ab678e76af76 100644
--- a/include/flang/Parser/dump-parse-tree.h
+++ b/include/flang/Parser/dump-parse-tree.h
@@ -15,8 +15,7 @@
 #include "unparse.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/indirection.h"
-#include <ostream>
-#include <sstream>
+#include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <type_traits>
 
@@ -37,7 +36,7 @@ struct HasSource<T, decltype((void)T::source, 0)> : std::true_type {};
 class ParseTreeDumper {
 public:
   explicit ParseTreeDumper(
-      std::ostream &out, const AnalyzedObjectsAsFortran *asFortran = nullptr)
+      llvm::raw_ostream &out, const AnalyzedObjectsAsFortran *asFortran = nullptr)
     : out_(out), asFortran_{asFortran} {}
 
   static constexpr const char *GetNodeName(const char *) { return "char *"; }
@@ -761,7 +760,8 @@ class ParseTreeDumper {
 protected:
   // Return a Fortran representation of this node to include in the dump
   template<typename T> std::string AsFortran(const T &x) {
-    std::ostringstream ss;
+    std::string buf;
+    llvm::raw_string_ostream ss{buf};
     if constexpr (std::is_same_v<T, Expr>) {
       if (asFortran_ && x.typedExpr) {
         asFortran_->expr(ss, *x.typedExpr);
@@ -784,7 +784,7 @@ class ParseTreeDumper {
         std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t>) {
       ss << x;
     }
-    if (ss.tellp()) {
+    if (ss.tell()) {
       return ss.str();
     }
     if constexpr (std::is_same_v<T, Name> || HasSource<T>::value) {
@@ -830,13 +830,13 @@ class ParseTreeDumper {
 
 private:
   int indent_{0};
-  std::ostream &out_;
+  llvm::raw_ostream &out_;
   const AnalyzedObjectsAsFortran *const asFortran_;
   bool emptyline_{false};
 };
 
 template<typename T>
-void DumpTree(std::ostream &out, const T &x,
+void DumpTree(llvm::raw_ostream &out, const T &x,
     const AnalyzedObjectsAsFortran *asFortran = nullptr) {
   ParseTreeDumper dumper{out, asFortran};
   Walk(x, dumper);
diff --git a/include/flang/Parser/instrumented-parser.h b/include/flang/Parser/instrumented-parser.h
index 0369a5f363fb..007edbf56d4e 100644
--- a/include/flang/Parser/instrumented-parser.h
+++ b/include/flang/Parser/instrumented-parser.h
@@ -15,7 +15,10 @@
 #include "flang/Parser/provenance.h"
 #include <cstddef>
 #include <map>
-#include <ostream>
+
+namespace llvm {
+class raw_ostream;
+}
 
 namespace Fortran::parser {
 
@@ -28,7 +31,7 @@ class ParsingLog {
   bool Fails(const char *at, const MessageFixedText &tag, ParseState &);
   void Note(const char *at, const MessageFixedText &tag, bool pass,
       const ParseState &);
-  void Dump(std::ostream &, const CookedSource &) const;
+  void Dump(llvm::raw_ostream &, const CookedSource &) const;
 
 private:
   struct LogForPosition {
diff --git a/include/flang/Parser/message.h b/include/flang/Parser/message.h
index 19b94bb70388..e38145a7b04b 100644
--- a/include/flang/Parser/message.h
+++ b/include/flang/Parser/message.h
@@ -22,7 +22,6 @@
 #include <cstring>
 #include <forward_list>
 #include <optional>
-#include <ostream>
 #include <string>
 #include <utility>
 #include <variant>
@@ -187,7 +186,7 @@ class Message : public common::ReferenceCounted<Message> {
   std::string ToString() const;
   std::optional<ProvenanceRange> GetProvenanceRange(const CookedSource &) const;
   void Emit(
-      std::ostream &, const CookedSource &, bool echoSourceLine = true) const;
+      llvm::raw_ostream &, const CookedSource &, bool echoSourceLine = true) const;
 
   // If this Message or any of its attachments locates itself via a CharBlock
   // within a particular CookedSource, replace its location with the
@@ -255,7 +254,7 @@ class Messages {
   void Merge(Messages &&);
   void Copy(const Messages &);
   void ResolveProvenances(const CookedSource &);
-  void Emit(std::ostream &, const CookedSource &cooked,
+  void Emit(llvm::raw_ostream &, const CookedSource &cooked,
       bool echoSourceLines = true) const;
   void AttachTo(Message &);
   bool AnyFatalError() const;
diff --git a/include/flang/Parser/parsing.h b/include/flang/Parser/parsing.h
index cff2f57b8185..0d32afee38c2 100644
--- a/include/flang/Parser/parsing.h
+++ b/include/flang/Parser/parsing.h
@@ -15,8 +15,8 @@
 #include "parse-tree.h"
 #include "provenance.h"
 #include "flang/Common/Fortran-features.h"
+#include "llvm/Support/raw_ostream.h"
 #include <optional>
-#include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -50,19 +50,19 @@ class Parsing {
   std::optional<Program> &parseTree() { return parseTree_; }
 
   const SourceFile *Prescan(const std::string &path, Options);
-  void DumpCookedChars(std::ostream &) const;
-  void DumpProvenance(std::ostream &) const;
-  void DumpParsingLog(std::ostream &) const;
-  void Parse(std::ostream *debugOutput = nullptr);
+  void DumpCookedChars(llvm::raw_ostream &) const;
+  void DumpProvenance(llvm::raw_ostream &) const;
+  void DumpParsingLog(llvm::raw_ostream &) const;
+  void Parse(llvm::raw_ostream &debugOutput);
   void ClearLog();
 
-  void EmitMessage(std::ostream &o, const char *at, const std::string &message,
+  void EmitMessage(llvm::raw_ostream &o, const char *at, const std::string &message,
       bool echoSourceLine = false) const {
     cooked_.allSources().EmitMessage(
         o, cooked_.GetProvenanceRange(CharBlock(at)), message, echoSourceLine);
   }
 
-  bool ForTesting(std::string path, std::ostream &);
+  bool ForTesting(std::string path, llvm::raw_ostream &);
 
 private:
   Options options_;
diff --git a/include/flang/Parser/provenance.h b/include/flang/Parser/provenance.h
index f1f48c07715d..2ed00d416b64 100644
--- a/include/flang/Parser/provenance.h
+++ b/include/flang/Parser/provenance.h
@@ -15,12 +15,11 @@
 #include "source.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/interval.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstddef>
 #include <map>
 #include <memory>
 #include <optional>
-#include <ostream>
-#include <sstream>
 #include <string>
 #include <utility>
 #include <variant>
@@ -91,7 +90,7 @@ class ProvenanceRangeToOffsetMappings {
   bool empty() const { return map_.empty(); }
   void Put(ProvenanceRange, std::size_t offset);
   std::optional<std::size_t> Map(ProvenanceRange) const;
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   // A comparison function object for use in std::multimap<Compare=>.
@@ -120,7 +119,7 @@ class OffsetToProvenanceMappings {
   ProvenanceRange Map(std::size_t at) const;
   void RemoveLastBytes(std::size_t);
   ProvenanceRangeToOffsetMappings Invert(const AllSources &) const;
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   struct ContiguousProvenanceMapping {
@@ -150,8 +149,8 @@ class AllSources {
 
   void PushSearchPathDirectory(std::string);
   std::string PopSearchPathDirectory();
-  const SourceFile *Open(std::string path, std::stringstream *error);
-  const SourceFile *ReadStandardInput(std::stringstream *error);
+  const SourceFile *Open(std::string path, llvm::raw_ostream &error);
+  const SourceFile *ReadStandardInput(llvm::raw_ostream &error);
 
   ProvenanceRange AddIncludedFile(
       const SourceFile &, ProvenanceRange, bool isModule = false);
@@ -163,7 +162,7 @@ class AllSources {
   bool IsValid(ProvenanceRange range) const {
     return range.size() > 0 && range_.Contains(range);
   }
-  void EmitMessage(std::ostream &, const std::optional<ProvenanceRange> &,
+  void EmitMessage(llvm::raw_ostream &, const std::optional<ProvenanceRange> &,
       const std::string &message, bool echoSourceLine = false) const;
   const SourceFile *GetSourceFile(
       Provenance, std::size_t *offset = nullptr) const;
@@ -174,7 +173,7 @@ class AllSources {
   Provenance CompilerInsertionProvenance(char ch);
   Provenance CompilerInsertionProvenance(const char *, std::size_t);
   ProvenanceRange IntersectionWithSourceFiles(ProvenanceRange) const;
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   struct Inclusion {
@@ -260,7 +259,7 @@ class CookedSource {
   void Marshal();  // marshals text into one contiguous block
   void CompileProvenanceRangeToOffsetMappings();
   std::string AcquireData() { return std::move(data_); }
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   AllSources &allSources_;
diff --git a/include/flang/Parser/source.h b/include/flang/Parser/source.h
index 08ce1514c07c..cc7dc9219a88 100644
--- a/include/flang/Parser/source.h
+++ b/include/flang/Parser/source.h
@@ -16,11 +16,14 @@
 
 #include "characters.h"
 #include <cstddef>
-#include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::parser {
 
 std::string DirectoryName(std::string path);
@@ -44,8 +47,8 @@ class SourceFile {
   std::size_t lines() const { return lineStart_.size(); }
   Encoding encoding() const { return encoding_; }
 
-  bool Open(std::string path, std::stringstream *error);
-  bool ReadStandardInput(std::stringstream *error);
+  bool Open(std::string path, llvm::raw_ostream &error);
+  bool ReadStandardInput(llvm::raw_ostream &error);
   void Close();
   SourcePosition FindOffsetLineAndColumn(std::size_t) const;
   std::size_t GetLineStartOffset(int lineNumber) const {
@@ -53,7 +56,7 @@ class SourceFile {
   }
 
 private:
-  bool ReadFile(std::string errorPath, std::stringstream *error);
+  bool ReadFile(std::string errorPath, llvm::raw_ostream &error);
   void IdentifyPayload();
   void RecordLineStarts();
 
diff --git a/include/flang/Parser/unparse.h b/include/flang/Parser/unparse.h
index d6bca8d2133c..0c7745809f39 100644
--- a/include/flang/Parser/unparse.h
+++ b/include/flang/Parser/unparse.h
@@ -14,6 +14,10 @@
 #include <functional>
 #include <iosfwd>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::evaluate {
 struct GenericExprWrapper;
 struct GenericAssignmentWrapper;
@@ -26,21 +30,21 @@ struct Program;
 
 // A function called before each Statement is unparsed.
 using preStatementType =
-    std::function<void(const CharBlock &, std::ostream &, int)>;
+    std::function<void(const CharBlock &, llvm::raw_ostream &, int)>;
 
 // Functions to handle unparsing of analyzed expressions and related
 // objects rather than their original parse trees.
 struct AnalyzedObjectsAsFortran {
-  std::function<void(std::ostream &, const evaluate::GenericExprWrapper &)>
+  std::function<void(llvm::raw_ostream &, const evaluate::GenericExprWrapper &)>
       expr;
   std::function<void(
-      std::ostream &, const evaluate::GenericAssignmentWrapper &)>
+      llvm::raw_ostream &, const evaluate::GenericAssignmentWrapper &)>
       assignment;
-  std::function<void(std::ostream &, const evaluate::ProcedureRef &)> call;
+  std::function<void(llvm::raw_ostream &, const evaluate::ProcedureRef &)> call;
 };
 
 // Converts parsed program to out as Fortran.
-void Unparse(std::ostream &out, const Program &program,
+void Unparse(llvm::raw_ostream &out, const Program &program,
     Encoding encoding = Encoding::UTF_8, bool capitalizeKeywords = true,
     bool backslashEscapes = true, preStatementType *preStatement = nullptr,
     AnalyzedObjectsAsFortran * = nullptr);
diff --git a/include/flang/Parser/user-state.h b/include/flang/Parser/user-state.h
index 60a85d1fed6b..cc5466568ecb 100644
--- a/include/flang/Parser/user-state.h
+++ b/include/flang/Parser/user-state.h
@@ -18,9 +18,9 @@
 #include "flang/Common/idioms.h"
 #include "flang/Parser/char-block.h"
 #include "flang/Parser/parse-tree.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <optional>
-#include <ostream>
 #include <set>
 #include <unordered_map>
 
@@ -40,9 +40,9 @@ class UserState {
   const CookedSource &cooked() const { return cooked_; }
   const common::LanguageFeatureControl &features() const { return features_; }
 
-  std::ostream *debugOutput() const { return debugOutput_; }
-  UserState &set_debugOutput(std::ostream *out) {
-    debugOutput_ = out;
+  llvm::raw_ostream *debugOutput() const { return debugOutput_; }
+  UserState &set_debugOutput(llvm::raw_ostream &out) {
+    debugOutput_ = &out;
     return *this;
   }
 
@@ -91,7 +91,7 @@ class UserState {
 private:
   const CookedSource &cooked_;
 
-  std::ostream *debugOutput_{nullptr};
+  llvm::raw_ostream *debugOutput_{nullptr};
 
   ParsingLog *log_{nullptr};
   bool instrumentedParse_{false};
diff --git a/include/flang/Semantics/attr.h b/include/flang/Semantics/attr.h
index 48fec0441cd3..9aa828da1f80 100644
--- a/include/flang/Semantics/attr.h
+++ b/include/flang/Semantics/attr.h
@@ -14,6 +14,10 @@
 #include <cinttypes>
 #include <string>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::semantics {
 
 // All available attributes.
@@ -38,13 +42,13 @@ class Attrs : public common::EnumSet<Attr, Attr_enumSize> {
   void CheckValid(const Attrs &allowed) const;
 
 private:
-  friend std::ostream &operator<<(std::ostream &, const Attrs &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Attrs &);
 };
 
 // Return string representation of attr that matches Fortran source.
 std::string AttrToString(Attr attr);
 
-std::ostream &operator<<(std::ostream &o, Attr attr);
-std::ostream &operator<<(std::ostream &o, const Attrs &attrs);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, Attr attr);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Attrs &attrs);
 }
 #endif  // FORTRAN_SEMANTICS_ATTR_H_
diff --git a/include/flang/Semantics/scope.h b/include/flang/Semantics/scope.h
index 6a645ad502b9..f7cef58bdcd5 100644
--- a/include/flang/Semantics/scope.h
+++ b/include/flang/Semantics/scope.h
@@ -22,6 +22,10 @@
 #include <set>
 #include <string>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::semantics {
 
 using namespace parser::literals;
@@ -234,7 +238,7 @@ class Scope {
   bool CanImport(const SourceName &) const;
   const DeclTypeSpec &MakeLengthlessType(DeclTypeSpec &&);
 
-  friend std::ostream &operator<<(std::ostream &, const Scope &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Scope &);
 };
 }
 #endif  // FORTRAN_SEMANTICS_SCOPE_H_
diff --git a/include/flang/Semantics/semantics.h b/include/flang/Semantics/semantics.h
index b88bcc4563ed..8f789e977c1d 100644
--- a/include/flang/Semantics/semantics.h
+++ b/include/flang/Semantics/semantics.h
@@ -19,6 +19,10 @@
 #include <string>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::common {
 class IntrinsicTypeDefaultKinds;
 }
@@ -209,9 +213,9 @@ class Semantics {
     return context_.FindScope(where);
   }
   bool AnyFatalError() const { return context_.AnyFatalError(); }
-  void EmitMessages(std::ostream &) const;
-  void DumpSymbols(std::ostream &);
-  void DumpSymbolsSources(std::ostream &) const;
+  void EmitMessages(llvm::raw_ostream &) const;
+  void DumpSymbols(llvm::raw_ostream &);
+  void DumpSymbolsSources(llvm::raw_ostream &) const;
 
 private:
   SemanticsContext &context_;
diff --git a/include/flang/Semantics/symbol.h b/include/flang/Semantics/symbol.h
index b97cdf0f41e7..a9f4dd6bc185 100644
--- a/include/flang/Semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -19,6 +19,10 @@
 #include <set>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::semantics {
 
 /// A Symbol consists of common information (name, owner, and attributes)
@@ -79,7 +83,7 @@ class SubprogramDetails {
   std::vector<Symbol *> dummyArgs_;  // nullptr -> alternate return indicator
   Symbol *result_{nullptr};
   MaybeExpr stmtFunction_;
-  friend std::ostream &operator<<(std::ostream &, const SubprogramDetails &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SubprogramDetails &);
 };
 
 // For SubprogramNameDetails, the kind indicates whether it is the name
@@ -121,7 +125,7 @@ class EntityDetails {
   bool isFuncResult_{false};
   const DeclTypeSpec *type_{nullptr};
   MaybeExpr bindName_;
-  friend std::ostream &operator<<(std::ostream &, const EntityDetails &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const EntityDetails &);
 };
 
 // Symbol is associated with a name or expression in a SELECT TYPE or ASSOCIATE.
@@ -176,7 +180,7 @@ class ObjectEntityDetails : public EntityDetails {
   ArraySpec shape_;
   ArraySpec coshape_;
   const Symbol *commonBlock_{nullptr};  // common block this object is in
-  friend std::ostream &operator<<(std::ostream &, const ObjectEntityDetails &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ObjectEntityDetails &);
 };
 
 // Mixin for details with passed-object dummy argument.
@@ -213,7 +217,7 @@ class ProcEntityDetails : public EntityDetails, public WithPassArg {
 private:
   ProcInterface interface_;
   std::optional<const Symbol *> init_;
-  friend std::ostream &operator<<(std::ostream &, const ProcEntityDetails &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ProcEntityDetails &);
 };
 
 // These derived type details represent the characteristics of a derived
@@ -259,7 +263,7 @@ class DerivedTypeDetails {
   std::list<SourceName> componentNames_;
   bool sequence_{false};
   bool isForwardReferenced_{false};
-  friend std::ostream &operator<<(std::ostream &, const DerivedTypeDetails &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DerivedTypeDetails &);
 };
 
 class ProcBindingDetails : public WithPassArg {
@@ -443,7 +447,7 @@ using Details = std::variant<UnknownDetails, MainProgramDetails, ModuleDetails,
     DerivedTypeDetails, UseDetails, UseErrorDetails, HostAssocDetails,
     GenericDetails, ProcBindingDetails, NamelistDetails, CommonBlockDetails,
     FinalProcDetails, TypeParamDetails, MiscDetails>;
-std::ostream &operator<<(std::ostream &, const Details &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Details &);
 std::string DetailsToString(const Details &);
 
 class Symbol {
@@ -657,8 +661,8 @@ class Symbol {
 
   Symbol() {}  // only created in class Symbols
   const std::string GetDetailsName() const;
-  friend std::ostream &operator<<(std::ostream &, const Symbol &);
-  friend std::ostream &DumpForUnparse(std::ostream &, const Symbol &, bool);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Symbol &);
+  friend llvm::raw_ostream &DumpForUnparse(llvm::raw_ostream &, const Symbol &, bool);
 
   // If a derived type's symbol refers to an extended derived type,
   // return the parent component's symbol.  The scope of the derived type
@@ -669,7 +673,7 @@ class Symbol {
   template<class, std::size_t> friend struct std::array;
 };
 
-std::ostream &operator<<(std::ostream &, Symbol::Flag);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, Symbol::Flag);
 
 // Manage memory for all symbols. BLOCK_SIZE symbols at a time are allocated.
 // Make() returns a reference to the next available one. They are never
diff --git a/include/flang/Semantics/type.h b/include/flang/Semantics/type.h
index 85930d334ebb..f18114b1f380 100644
--- a/include/flang/Semantics/type.h
+++ b/include/flang/Semantics/type.h
@@ -21,6 +21,10 @@
 #include <variant>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::parser {
 struct Keyword;
 }
@@ -71,7 +75,7 @@ class Bound {
     : category_{category}, expr_{std::move(expr)} {}
   Category category_{Category::Explicit};
   MaybeSubscriptIntExpr expr_;
-  friend std::ostream &operator<<(std::ostream &, const Bound &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Bound &);
 };
 
 // A type parameter value: integer expression or assumed or deferred.
@@ -107,7 +111,7 @@ class ParamValue {
   Category category_{Category::Explicit};
   common::TypeParamAttr attr_{common::TypeParamAttr::Kind};
   MaybeIntExpr expr_;
-  friend std::ostream &operator<<(std::ostream &, const ParamValue &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ParamValue &);
 };
 
 class IntrinsicTypeSpec {
@@ -126,7 +130,7 @@ class IntrinsicTypeSpec {
 private:
   TypeCategory category_;
   KindExpr kind_;
-  friend std::ostream &operator<<(std::ostream &os, const IntrinsicTypeSpec &x);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const IntrinsicTypeSpec &x);
 };
 
 class NumericTypeSpec : public IntrinsicTypeSpec {
@@ -153,7 +157,7 @@ class CharacterTypeSpec : public IntrinsicTypeSpec {
 
 private:
   ParamValue length_;
-  friend std::ostream &operator<<(std::ostream &os, const CharacterTypeSpec &x);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharacterTypeSpec &x);
 };
 
 class ShapeSpec {
@@ -205,7 +209,7 @@ class ShapeSpec {
   ShapeSpec(Bound &&lb, Bound &&ub) : lb_{std::move(lb)}, ub_{std::move(ub)} {}
   Bound lb_;
   Bound ub_;
-  friend std::ostream &operator<<(std::ostream &, const ShapeSpec &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ShapeSpec &);
 };
 
 struct ArraySpec : public std::vector<ShapeSpec> {
@@ -224,7 +228,7 @@ struct ArraySpec : public std::vector<ShapeSpec> {
     return !empty() && std::all_of(begin(), end(), predicate);
   }
 };
-std::ostream &operator<<(std::ostream &, const ArraySpec &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ArraySpec &);
 
 // Each DerivedTypeSpec has a typeSymbol that has DerivedTypeDetails.
 // The name may not match the symbol's name in case of a USE rename.
@@ -289,7 +293,7 @@ class DerivedTypeSpec {
   bool instantiated_{false};
   RawParameters rawParameters_;
   ParameterMapType parameters_;
-  friend std::ostream &operator<<(std::ostream &, const DerivedTypeSpec &);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DerivedTypeSpec &);
 };
 
 class DeclTypeSpec {
@@ -370,7 +374,7 @@ class DeclTypeSpec {
       CharacterTypeSpec, DerivedTypeSpec>
       typeSpec_;
 };
-std::ostream &operator<<(std::ostream &, const DeclTypeSpec &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DeclTypeSpec &);
 
 // This represents a proc-interface in the declaration of a procedure or
 // procedure component. It comprises a symbol that represents the specific
diff --git a/include/flang/Semantics/unparse-with-symbols.h b/include/flang/Semantics/unparse-with-symbols.h
index 6553b7b34de0..9bea94223e8a 100644
--- a/include/flang/Semantics/unparse-with-symbols.h
+++ b/include/flang/Semantics/unparse-with-symbols.h
@@ -12,12 +12,16 @@
 #include "flang/Parser/characters.h"
 #include <iosfwd>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::parser {
 struct Program;
 }
 
 namespace Fortran::semantics {
-void UnparseWithSymbols(std::ostream &, const parser::Program &,
+void UnparseWithSymbols(llvm::raw_ostream &, const parser::Program &,
     parser::Encoding encoding = parser::Encoding::UTF_8);
 }
 
diff --git a/lib/Evaluate/characteristics.cpp b/lib/Evaluate/characteristics.cpp
index d87ea198ae75..867b8116702f 100644
--- a/lib/Evaluate/characteristics.cpp
+++ b/lib/Evaluate/characteristics.cpp
@@ -16,8 +16,8 @@
 #include "flang/Parser/message.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/symbol.h"
+#include "llvm/Support/raw_ostream.h"
 #include <initializer_list>
-#include <ostream>
 
 using namespace Fortran::parser::literals;
 
@@ -179,7 +179,7 @@ void TypeAndShape::AcquireLEN() {
   }
 }
 
-std::ostream &TypeAndShape::Dump(std::ostream &o) const {
+llvm::raw_ostream &TypeAndShape::Dump(llvm::raw_ostream &o) const {
   o << type_.AsFortran(LEN_ ? LEN_->AsFortran() : "");
   attrs_.Dump(o, EnumToString);
   if (!shape_.empty()) {
@@ -261,7 +261,7 @@ bool DummyDataObject::CanBePassedViaImplicitInterface() const {
   }
 }
 
-std::ostream &DummyDataObject::Dump(std::ostream &o) const {
+llvm::raw_ostream &DummyDataObject::Dump(llvm::raw_ostream &o) const {
   attrs.Dump(o, EnumToString);
   if (intent != common::Intent::Default) {
     o << "INTENT(" << common::EnumToString(intent) << ')';
@@ -306,7 +306,7 @@ std::optional<DummyProcedure> DummyProcedure::Characterize(
   }
 }
 
-std::ostream &DummyProcedure::Dump(std::ostream &o) const {
+llvm::raw_ostream &DummyProcedure::Dump(llvm::raw_ostream &o) const {
   attrs.Dump(o, EnumToString);
   if (intent != common::Intent::Default) {
     o << "INTENT(" << common::EnumToString(intent) << ')';
@@ -315,7 +315,9 @@ std::ostream &DummyProcedure::Dump(std::ostream &o) const {
   return o;
 }
 
-std::ostream &AlternateReturn::Dump(std::ostream &o) const { return o << '*'; }
+llvm::raw_ostream &AlternateReturn::Dump(llvm::raw_ostream &o) const {
+  return o << '*';
+}
 
 DummyArgument::~DummyArgument() {}
 
@@ -417,7 +419,7 @@ bool DummyArgument::CanBePassedViaImplicitInterface() const {
   }
 }
 
-std::ostream &DummyArgument::Dump(std::ostream &o) const {
+llvm::raw_ostream &DummyArgument::Dump(llvm::raw_ostream &o) const {
   if (!name.empty()) {
     o << name << '=';
   }
@@ -503,7 +505,7 @@ bool FunctionResult::CanBeReturnedViaImplicitInterface() const {
   }
 }
 
-std::ostream &FunctionResult::Dump(std::ostream &o) const {
+llvm::raw_ostream &FunctionResult::Dump(llvm::raw_ostream &o) const {
   attrs.Dump(o, EnumToString);
   std::visit(
       common::visitors{
@@ -698,7 +700,7 @@ bool Procedure::CanBeCalledViaImplicitInterface() const {
   }
 }
 
-std::ostream &Procedure::Dump(std::ostream &o) const {
+llvm::raw_ostream &Procedure::Dump(llvm::raw_ostream &o) const {
   attrs.Dump(o, EnumToString);
   if (functionResult) {
     functionResult->Dump(o << "TYPE(") << ") FUNCTION";
diff --git a/lib/Evaluate/complex.cpp b/lib/Evaluate/complex.cpp
index ebb3898dee90..298c14a07540 100644
--- a/lib/Evaluate/complex.cpp
+++ b/lib/Evaluate/complex.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/Evaluate/complex.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::evaluate::value {
 
@@ -90,7 +91,7 @@ template<typename R> std::string Complex<R>::DumpHexadecimal() const {
 }
 
 template<typename R>
-std::ostream &Complex<R>::AsFortran(std::ostream &o, int kind) const {
+llvm::raw_ostream &Complex<R>::AsFortran(llvm::raw_ostream &o, int kind) const {
   re_.AsFortran(o << '(', kind);
   im_.AsFortran(o << ',', kind);
   return o << ')';
diff --git a/lib/Evaluate/expression.cpp b/lib/Evaluate/expression.cpp
index 18646e4f19e6..a3bb9280648f 100644
--- a/lib/Evaluate/expression.cpp
+++ b/lib/Evaluate/expression.cpp
@@ -13,6 +13,7 @@
 #include "flang/Evaluate/tools.h"
 #include "flang/Evaluate/variable.h"
 #include "flang/Parser/message.h"
+#include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <type_traits>
 
diff --git a/lib/Evaluate/formatting.cpp b/lib/Evaluate/formatting.cpp
index 4c28d66a1d66..adcc22865762 100644
--- a/lib/Evaluate/formatting.cpp
+++ b/lib/Evaluate/formatting.cpp
@@ -14,11 +14,12 @@
 #include "flang/Evaluate/tools.h"
 #include "flang/Parser/characters.h"
 #include "flang/Semantics/symbol.h"
-#include <sstream>
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::evaluate {
 
-static void ShapeAsFortran(std::ostream &o, const ConstantSubscripts &shape) {
+static void ShapeAsFortran(
+    llvm::raw_ostream &o, const ConstantSubscripts &shape) {
   if (GetRank(shape) > 1) {
     o << ",shape=";
     char ch{'['};
@@ -31,7 +32,8 @@ static void ShapeAsFortran(std::ostream &o, const ConstantSubscripts &shape) {
 }
 
 template<typename RESULT, typename VALUE>
-std::ostream &ConstantBase<RESULT, VALUE>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ConstantBase<RESULT, VALUE>::AsFortran(
+    llvm::raw_ostream &o) const {
   if (Rank() > 1) {
     o << "reshape(";
   }
@@ -71,8 +73,8 @@ std::ostream &ConstantBase<RESULT, VALUE>::AsFortran(std::ostream &o) const {
 }
 
 template<int KIND>
-std::ostream &Constant<Type<TypeCategory::Character, KIND>>::AsFortran(
-    std::ostream &o) const {
+llvm::raw_ostream &Constant<Type<TypeCategory::Character, KIND>>::AsFortran(
+    llvm::raw_ostream &o) const {
   if (Rank() > 1) {
     o << "reshape(";
   }
@@ -97,11 +99,12 @@ std::ostream &Constant<Type<TypeCategory::Character, KIND>>::AsFortran(
   return o;
 }
 
-std::ostream &ActualArgument::AssumedType::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ActualArgument::AssumedType::AsFortran(
+    llvm::raw_ostream &o) const {
   return o << symbol_->name().ToString();
 }
 
-std::ostream &ActualArgument::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ActualArgument::AsFortran(llvm::raw_ostream &o) const {
   if (keyword_) {
     o << keyword_->ToString() << '=';
   }
@@ -115,11 +118,11 @@ std::ostream &ActualArgument::AsFortran(std::ostream &o) const {
   }
 }
 
-std::ostream &SpecificIntrinsic::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &SpecificIntrinsic::AsFortran(llvm::raw_ostream &o) const {
   return o << name;
 }
 
-std::ostream &ProcedureRef::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ProcedureRef::AsFortran(llvm::raw_ostream &o) const {
   for (const auto &arg : arguments_) {
     if (arg && arg->isPassedObject()) {
       arg->AsFortran(o) << '%';
@@ -306,7 +309,8 @@ static OperatorSpelling SpellOperator(const Relational<T> &x) {
 }
 
 template<typename D, typename R, typename... O>
-std::ostream &Operation<D, R, O...>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Operation<D, R, O...>::AsFortran(
+    llvm::raw_ostream &o) const {
   Precedence lhsPrec{ToPrecedence(left())};
   OperatorSpelling spelling{SpellOperator(derived())};
   o << spelling.prefix;
@@ -337,7 +341,7 @@ std::ostream &Operation<D, R, O...>::AsFortran(std::ostream &o) const {
 }
 
 template<typename TO, TypeCategory FROMCAT>
-std::ostream &Convert<TO, FROMCAT>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Convert<TO, FROMCAT>::AsFortran(llvm::raw_ostream &o) const {
   static_assert(TO::category == TypeCategory::Integer ||
           TO::category == TypeCategory::Real ||
           TO::category == TypeCategory::Character ||
@@ -355,21 +359,22 @@ std::ostream &Convert<TO, FROMCAT>::AsFortran(std::ostream &o) const {
   return o << ",kind=" << TO::kind << ')';
 }
 
-std::ostream &Relational<SomeType>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Relational<SomeType>::AsFortran(llvm::raw_ostream &o) const {
   std::visit([&](const auto &rel) { rel.AsFortran(o); }, u);
   return o;
 }
 
 template<typename T>
-std::ostream &EmitArray(std::ostream &o, const Expr<T> &expr) {
+llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const Expr<T> &expr) {
   return expr.AsFortran(o);
 }
 
 template<typename T>
-std::ostream &EmitArray(std::ostream &, const ArrayConstructorValues<T> &);
+llvm::raw_ostream &EmitArray(
+    llvm::raw_ostream &, const ArrayConstructorValues<T> &);
 
 template<typename T>
-std::ostream &EmitArray(std::ostream &o, const ImpliedDo<T> &implDo) {
+llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const ImpliedDo<T> &implDo) {
   o << '(';
   EmitArray(o, implDo.values());
   o << ',' << ImpliedDoIndex::Result::AsFortran()
@@ -381,8 +386,8 @@ std::ostream &EmitArray(std::ostream &o, const ImpliedDo<T> &implDo) {
 }
 
 template<typename T>
-std::ostream &EmitArray(
-    std::ostream &o, const ArrayConstructorValues<T> &values) {
+llvm::raw_ostream &EmitArray(
+    llvm::raw_ostream &o, const ArrayConstructorValues<T> &values) {
   const char *sep{""};
   for (const auto &value : values) {
     o << sep;
@@ -393,21 +398,23 @@ std::ostream &EmitArray(
 }
 
 template<typename T>
-std::ostream &ArrayConstructor<T>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ArrayConstructor<T>::AsFortran(llvm::raw_ostream &o) const {
   o << '[' << GetType().AsFortran() << "::";
   EmitArray(o, *this);
   return o << ']';
 }
 
 template<int KIND>
-std::ostream &ArrayConstructor<Type<TypeCategory::Character, KIND>>::AsFortran(
-    std::ostream &o) const {
+llvm::raw_ostream &
+ArrayConstructor<Type<TypeCategory::Character, KIND>>::AsFortran(
+    llvm::raw_ostream &o) const {
   o << '[' << GetType().AsFortran(LEN().AsFortran()) << "::";
   EmitArray(o, *this);
   return o << ']';
 }
 
-std::ostream &ArrayConstructor<SomeDerived>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ArrayConstructor<SomeDerived>::AsFortran(
+    llvm::raw_ostream &o) const {
   o << '[' << GetType().AsFortran() << "::";
   EmitArray(o, *this);
   return o << ']';
@@ -415,13 +422,15 @@ std::ostream &ArrayConstructor<SomeDerived>::AsFortran(std::ostream &o) const {
 
 template<typename RESULT>
 std::string ExpressionBase<RESULT>::AsFortran() const {
-  std::ostringstream ss;
+  std::string buf;
+  llvm::raw_string_ostream ss{buf};
   AsFortran(ss);
   return ss.str();
 }
 
 template<typename RESULT>
-std::ostream &ExpressionBase<RESULT>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ExpressionBase<RESULT>::AsFortran(
+    llvm::raw_ostream &o) const {
   std::visit(
       common::visitors{
           [&](const BOZLiteralConstant &x) {
@@ -438,7 +447,7 @@ std::ostream &ExpressionBase<RESULT>::AsFortran(std::ostream &o) const {
   return o;
 }
 
-std::ostream &StructureConstructor::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &StructureConstructor::AsFortran(llvm::raw_ostream &o) const {
   o << DerivedTypeSpecAsFortran(result_.derivedTypeSpec());
   if (values_.empty()) {
     o << '(';
@@ -496,7 +505,8 @@ std::string SomeDerived::AsFortran() const {
 }
 
 std::string DerivedTypeSpecAsFortran(const semantics::DerivedTypeSpec &spec) {
-  std::stringstream ss;
+  std::string buf;
+  llvm::raw_string_ostream ss{buf};
   ss << spec.name().ToString();
   char ch{'('};
   for (const auto &[name, value] : spec.parameters()) {
@@ -516,33 +526,35 @@ std::string DerivedTypeSpecAsFortran(const semantics::DerivedTypeSpec &spec) {
   return ss.str();
 }
 
-std::ostream &EmitVar(std::ostream &o, const Symbol &symbol) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const Symbol &symbol) {
   return o << symbol.name().ToString();
 }
 
-std::ostream &EmitVar(std::ostream &o, const std::string &lit) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::string &lit) {
   return o << parser::QuoteCharacterLiteral(lit);
 }
 
-std::ostream &EmitVar(std::ostream &o, const std::u16string &lit) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::u16string &lit) {
   return o << parser::QuoteCharacterLiteral(lit);
 }
 
-std::ostream &EmitVar(std::ostream &o, const std::u32string &lit) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::u32string &lit) {
   return o << parser::QuoteCharacterLiteral(lit);
 }
 
-template<typename A> std::ostream &EmitVar(std::ostream &o, const A &x) {
+template<typename A>
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const A &x) {
   return x.AsFortran(o);
 }
 
 template<typename A>
-std::ostream &EmitVar(std::ostream &o, common::Reference<A> x) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, common::Reference<A> x) {
   return EmitVar(o, *x);
 }
 
 template<typename A>
-std::ostream &EmitVar(std::ostream &o, const A *p, const char *kw = nullptr) {
+llvm::raw_ostream &EmitVar(
+    llvm::raw_ostream &o, const A *p, const char *kw = nullptr) {
   if (p) {
     if (kw) {
       o << kw;
@@ -553,8 +565,8 @@ std::ostream &EmitVar(std::ostream &o, const A *p, const char *kw = nullptr) {
 }
 
 template<typename A>
-std::ostream &EmitVar(
-    std::ostream &o, const std::optional<A> &x, const char *kw = nullptr) {
+llvm::raw_ostream &EmitVar(
+    llvm::raw_ostream &o, const std::optional<A> &x, const char *kw = nullptr) {
   if (x) {
     if (kw) {
       o << kw;
@@ -565,8 +577,8 @@ std::ostream &EmitVar(
 }
 
 template<typename A, bool COPY>
-std::ostream &EmitVar(std::ostream &o, const common::Indirection<A, COPY> &p,
-    const char *kw = nullptr) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o,
+    const common::Indirection<A, COPY> &p, const char *kw = nullptr) {
   if (kw) {
     o << kw;
   }
@@ -575,35 +587,36 @@ std::ostream &EmitVar(std::ostream &o, const common::Indirection<A, COPY> &p,
 }
 
 template<typename A>
-std::ostream &EmitVar(std::ostream &o, const std::shared_ptr<A> &p) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::shared_ptr<A> &p) {
   CHECK(p);
   return EmitVar(o, *p);
 }
 
 template<typename... A>
-std::ostream &EmitVar(std::ostream &o, const std::variant<A...> &u) {
+llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::variant<A...> &u) {
   std::visit([&](const auto &x) { EmitVar(o, x); }, u);
   return o;
 }
 
-std::ostream &BaseObject::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &BaseObject::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
 template<int KIND>
-std::ostream &TypeParamInquiry<KIND>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &TypeParamInquiry<KIND>::AsFortran(
+    llvm::raw_ostream &o) const {
   if (base_) {
     return base_->AsFortran(o) << '%';
   }
   return EmitVar(o, parameter_);
 }
 
-std::ostream &Component::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Component::AsFortran(llvm::raw_ostream &o) const {
   base_.value().AsFortran(o);
   return EmitVar(o << '%', symbol_);
 }
 
-std::ostream &NamedEntity::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &NamedEntity::AsFortran(llvm::raw_ostream &o) const {
   std::visit(
       common::visitors{
           [&](SymbolRef s) { EmitVar(o, s); },
@@ -613,18 +626,18 @@ std::ostream &NamedEntity::AsFortran(std::ostream &o) const {
   return o;
 }
 
-std::ostream &Triplet::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Triplet::AsFortran(llvm::raw_ostream &o) const {
   EmitVar(o, lower_) << ':';
   EmitVar(o, upper_);
   EmitVar(o << ':', stride_.value());
   return o;
 }
 
-std::ostream &Subscript::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Subscript::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
-std::ostream &ArrayRef::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ArrayRef::AsFortran(llvm::raw_ostream &o) const {
   base_.AsFortran(o);
   char separator{'('};
   for (const Subscript &ss : subscript_) {
@@ -634,7 +647,7 @@ std::ostream &ArrayRef::AsFortran(std::ostream &o) const {
   return o << ')';
 }
 
-std::ostream &CoarrayRef::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &CoarrayRef::AsFortran(llvm::raw_ostream &o) const {
   bool first{true};
   for (const Symbol &part : base_) {
     if (first) {
@@ -668,26 +681,26 @@ std::ostream &CoarrayRef::AsFortran(std::ostream &o) const {
   return o << ']';
 }
 
-std::ostream &DataRef::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &DataRef::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
-std::ostream &Substring::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Substring::AsFortran(llvm::raw_ostream &o) const {
   EmitVar(o, parent_) << '(';
   EmitVar(o, lower_) << ':';
   return EmitVar(o, upper_) << ')';
 }
 
-std::ostream &ComplexPart::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ComplexPart::AsFortran(llvm::raw_ostream &o) const {
   return complex_.AsFortran(o) << '%' << EnumToString(part_);
 }
 
-std::ostream &ProcedureDesignator::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &ProcedureDesignator::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
 template<typename T>
-std::ostream &Designator<T>::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Designator<T>::AsFortran(llvm::raw_ostream &o) const {
   std::visit(
       common::visitors{
           [&](SymbolRef symbol) { EmitVar(o, symbol); },
@@ -697,7 +710,7 @@ std::ostream &Designator<T>::AsFortran(std::ostream &o) const {
   return o;
 }
 
-std::ostream &DescriptorInquiry::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &DescriptorInquiry::AsFortran(llvm::raw_ostream &o) const {
   switch (field_) {
   case Field::LowerBound: o << "lbound("; break;
   case Field::Extent: o << "size("; break;
@@ -716,7 +729,7 @@ std::ostream &DescriptorInquiry::AsFortran(std::ostream &o) const {
   }
 }
 
-std::ostream &Assignment::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &Assignment::AsFortran(llvm::raw_ostream &o) const {
   std::visit(
       common::visitors{
           [&](const Assignment::Intrinsic &) {
diff --git a/lib/Evaluate/host.cpp b/lib/Evaluate/host.cpp
index c9f48789e218..bc55d53fc2e3 100644
--- a/lib/Evaluate/host.cpp
+++ b/lib/Evaluate/host.cpp
@@ -9,7 +9,7 @@
 #include "host.h"
 
 #include "flang/Common/idioms.h"
-#include <cerrno>
+#include "llvm/Support/Errno.h"
 #include <cfenv>
 
 namespace Fortran::evaluate::host {
@@ -20,12 +20,12 @@ void HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment(
   errno = 0;
   if (feholdexcept(&originalFenv_) != 0) {
     common::die("Folding with host runtime: feholdexcept() failed: %s",
-        std::strerror(errno));
+        llvm::sys::StrError(errno).c_str());
     return;
   }
   if (fegetenv(&currentFenv_) != 0) {
     common::die("Folding with host runtime: fegetenv() failed: %s",
-        std::strerror(errno));
+        llvm::sys::StrError(errno).c_str());
     return;
   }
 #if __x86_64__
@@ -72,7 +72,7 @@ void HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment(
   errno = 0;
   if (fesetenv(&currentFenv_) != 0) {
     common::die("Folding with host runtime: fesetenv() failed: %s",
-        std::strerror(errno));
+        llvm::sys::StrError(errno).c_str());
     return;
   }
   switch (context.rounding().mode) {
@@ -127,10 +127,11 @@ void HostFloatingPointEnvironment::CheckAndRestoreFloatingPointEnvironment(
   }
   errno = 0;
   if (fesetenv(&originalFenv_) != 0) {
-    std::fprintf(stderr, "fesetenv() failed: %s\n", std::strerror(errno));
+    std::fprintf(
+        stderr, "fesetenv() failed: %s\n", llvm::sys::StrError(errno).c_str());
     common::die(
         "Folding with host runtime: fesetenv() failed while restoring fenv: %s",
-        std::strerror(errno));
+        llvm::sys::StrError(errno).c_str());
   }
   errno = 0;
 }
diff --git a/lib/Evaluate/intrinsics.cpp b/lib/Evaluate/intrinsics.cpp
index 93dcfe28f5ae..1936ca2cebbf 100644
--- a/lib/Evaluate/intrinsics.cpp
+++ b/lib/Evaluate/intrinsics.cpp
@@ -16,10 +16,9 @@
 #include "flang/Evaluate/shape.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Evaluate/type.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <map>
-#include <ostream>
-#include <sstream>
 #include <string>
 #include <utility>
 
@@ -90,7 +89,7 @@ ENUM_CLASS(KindCode, none, defaultIntegerKind,
 struct TypePattern {
   CategorySet categorySet;
   KindCode kindCode{KindCode::none};
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 };
 
 // Abbreviations for argument and result patterns in the intrinsic prototypes:
@@ -195,7 +194,7 @@ struct IntrinsicDummyArgument {
   TypePattern typePattern;
   Rank rank{Rank::elemental};
   Optionality optionality{Optionality::required};
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 };
 
 // constexpr abbreviations for popular arguments:
@@ -234,7 +233,7 @@ struct IntrinsicInterface {
       const common::IntrinsicTypeDefaultKinds &, ActualArguments &,
       FoldingContext &context) const;
   int CountArguments() const;
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 };
 
 int IntrinsicInterface::CountArguments() const {
@@ -1517,7 +1516,7 @@ class IntrinsicProcTable::Implementation {
   std::optional<SpecificIntrinsicFunctionInterface> IsSpecificIntrinsicFunction(
       const std::string &) const;
 
-  std::ostream &Dump(std::ostream &) const;
+  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   DynamicType GetSpecificType(const TypePattern &) const;
@@ -2000,7 +1999,7 @@ IntrinsicProcTable::IsSpecificIntrinsicFunction(const std::string &name) const {
   return DEREF(impl_).IsSpecificIntrinsicFunction(name);
 }
 
-std::ostream &TypePattern::Dump(std::ostream &o) const {
+llvm::raw_ostream &TypePattern::Dump(llvm::raw_ostream &o) const {
   if (categorySet == AnyType) {
     o << "any type";
   } else {
@@ -2016,7 +2015,7 @@ std::ostream &TypePattern::Dump(std::ostream &o) const {
   return o;
 }
 
-std::ostream &IntrinsicDummyArgument::Dump(std::ostream &o) const {
+llvm::raw_ostream &IntrinsicDummyArgument::Dump(llvm::raw_ostream &o) const {
   if (keyword) {
     o << keyword << '=';
   }
@@ -2024,7 +2023,7 @@ std::ostream &IntrinsicDummyArgument::Dump(std::ostream &o) const {
       << ' ' << EnumToString(rank) << ' ' << EnumToString(optionality);
 }
 
-std::ostream &IntrinsicInterface::Dump(std::ostream &o) const {
+llvm::raw_ostream &IntrinsicInterface::Dump(llvm::raw_ostream &o) const {
   o << name;
   char sep{'('};
   for (const auto &d : dummy) {
@@ -2040,7 +2039,8 @@ std::ostream &IntrinsicInterface::Dump(std::ostream &o) const {
   return result.Dump(o << " -> ") << ' ' << EnumToString(rank);
 }
 
-std::ostream &IntrinsicProcTable::Implementation::Dump(std::ostream &o) const {
+llvm::raw_ostream &IntrinsicProcTable::Implementation::Dump(
+    llvm::raw_ostream &o) const {
   o << "generic intrinsic functions:\n";
   for (const auto &iter : genericFuncs_) {
     iter.second->Dump(o << iter.first << ": ") << '\n';
@@ -2060,7 +2060,7 @@ std::ostream &IntrinsicProcTable::Implementation::Dump(std::ostream &o) const {
   return o;
 }
 
-std::ostream &IntrinsicProcTable::Dump(std::ostream &o) const {
+llvm::raw_ostream &IntrinsicProcTable::Dump(llvm::raw_ostream &o) const {
   return impl_->Dump(o);
 }
 }
diff --git a/lib/Evaluate/real.cpp b/lib/Evaluate/real.cpp
index fe3b5821b676..18309d9adb64 100644
--- a/lib/Evaluate/real.cpp
+++ b/lib/Evaluate/real.cpp
@@ -11,6 +11,7 @@
 #include "flang/Common/idioms.h"
 #include "flang/Decimal/decimal.h"
 #include "flang/Parser/characters.h"
+#include "llvm/Support/raw_ostream.h"
 #include <limits>
 
 namespace Fortran::evaluate::value {
@@ -478,8 +479,8 @@ template<typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
 }
 
 template<typename W, int P>
-std::ostream &Real<W, P>::AsFortran(
-    std::ostream &o, int kind, bool minimal) const {
+llvm::raw_ostream &Real<W, P>::AsFortran(
+    llvm::raw_ostream &o, int kind, bool minimal) const {
   if (IsNotANumber()) {
     o << "(0._" << kind << "/0.)";
   } else if (IsInfinite()) {
diff --git a/lib/Evaluate/static-data.cpp b/lib/Evaluate/static-data.cpp
index 8de4f3119684..bd1a729c4996 100644
--- a/lib/Evaluate/static-data.cpp
+++ b/lib/Evaluate/static-data.cpp
@@ -13,7 +13,7 @@ namespace Fortran::evaluate {
 
 bool StaticDataObject::bigEndian{false};
 
-std::ostream &StaticDataObject::AsFortran(std::ostream &o) const {
+llvm::raw_ostream &StaticDataObject::AsFortran(llvm::raw_ostream &o) const {
   if (auto string{AsString()}) {
     o << parser::QuoteCharacterLiteral(*string);
   } else if (auto string{AsU16String()}) {
diff --git a/lib/Evaluate/type.cpp b/lib/Evaluate/type.cpp
index 79f40d0481aa..d8d30264b397 100644
--- a/lib/Evaluate/type.cpp
+++ b/lib/Evaluate/type.cpp
@@ -18,7 +18,6 @@
 #include "flang/Semantics/type.h"
 #include <algorithm>
 #include <optional>
-#include <sstream>
 #include <string>
 
 // IsDescriptor() predicate
diff --git a/lib/Evaluate/variable.cpp b/lib/Evaluate/variable.cpp
index 030f8866a42b..10362c583831 100644
--- a/lib/Evaluate/variable.cpp
+++ b/lib/Evaluate/variable.cpp
@@ -14,7 +14,6 @@
 #include "flang/Parser/characters.h"
 #include "flang/Parser/message.h"
 #include "flang/Semantics/symbol.h"
-#include <ostream>
 #include <type_traits>
 
 using namespace Fortran::parser::literals;
diff --git a/lib/Parser/CMakeLists.txt b/lib/Parser/CMakeLists.txt
index 5f7ba14b0cc8..a04f37c71aec 100644
--- a/lib/Parser/CMakeLists.txt
+++ b/lib/Parser/CMakeLists.txt
@@ -34,6 +34,7 @@ add_library(FortranParser
 
 target_link_libraries(FortranParser
   FortranCommon
+  LLVMSupport
 )
 
 install (TARGETS FortranParser
diff --git a/lib/Parser/char-block.cpp b/lib/Parser/char-block.cpp
index b68be8a146ef..f74b08268c6d 100644
--- a/lib/Parser/char-block.cpp
+++ b/lib/Parser/char-block.cpp
@@ -7,11 +7,11 @@
 //----------------------------------------------------------------------------//
 
 #include "flang/Parser/char-block.h"
-#include <ostream>
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::parser {
 
-std::ostream &operator<<(std::ostream &os, const CharBlock &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharBlock &x) {
   return os << x.ToString();
 }
 
diff --git a/lib/Parser/debug-parser.cpp b/lib/Parser/debug-parser.cpp
index b0db22ff143c..75578ec51840 100644
--- a/lib/Parser/debug-parser.cpp
+++ b/lib/Parser/debug-parser.cpp
@@ -8,7 +8,6 @@
 
 #include "debug-parser.h"
 #include "flang/Parser/user-state.h"
-#include <ostream>
 #include <string>
 
 namespace Fortran::parser {
diff --git a/lib/Parser/instrumented-parser.cpp b/lib/Parser/instrumented-parser.cpp
index 47ff042b168d..7419c53874ca 100644
--- a/lib/Parser/instrumented-parser.cpp
+++ b/lib/Parser/instrumented-parser.cpp
@@ -9,8 +9,8 @@
 #include "flang/Parser/instrumented-parser.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/provenance.h"
+#include "llvm/Support/raw_ostream.h"
 #include <map>
-#include <ostream>
 
 namespace Fortran::parser {
 
@@ -63,7 +63,7 @@ void ParsingLog::Note(const char *at, const MessageFixedText &tag, bool pass,
   }
 }
 
-void ParsingLog::Dump(std::ostream &o, const CookedSource &cooked) const {
+void ParsingLog::Dump(llvm::raw_ostream &o, const CookedSource &cooked) const {
   for (const auto &posLog : perPos_) {
     const char *at{reinterpret_cast<const char *>(posLog.first)};
     for (const auto &tagLog : posLog.second.perTag) {
diff --git a/lib/Parser/message.cpp b/lib/Parser/message.cpp
index feb93a76c53e..1af00ad401b9 100644
--- a/lib/Parser/message.cpp
+++ b/lib/Parser/message.cpp
@@ -9,6 +9,7 @@
 #include "flang/Parser/message.h"
 #include "flang/Common/idioms.h"
 #include "flang/Parser/char-set.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdarg>
 #include <cstddef>
@@ -19,7 +20,7 @@
 
 namespace Fortran::parser {
 
-std::ostream &operator<<(std::ostream &o, const MessageFixedText &t) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const MessageFixedText &t) {
   std::size_t n{t.text().size()};
   for (std::size_t j{0}; j < n; ++j) {
     o << t.text()[j];
@@ -187,8 +188,8 @@ std::optional<ProvenanceRange> Message::GetProvenanceRange(
       location_);
 }
 
-void Message::Emit(
-    std::ostream &o, const CookedSource &cooked, bool echoSourceLine) const {
+void Message::Emit(llvm::raw_ostream &o, const CookedSource &cooked,
+    bool echoSourceLine) const {
   std::optional<ProvenanceRange> provenanceRange{GetProvenanceRange(cooked)};
   std::string text;
   if (IsFatal()) {
@@ -306,8 +307,8 @@ void Messages::ResolveProvenances(const CookedSource &cooked) {
   }
 }
 
-void Messages::Emit(
-    std::ostream &o, const CookedSource &cooked, bool echoSourceLines) const {
+void Messages::Emit(llvm::raw_ostream &o, const CookedSource &cooked,
+    bool echoSourceLines) const {
   std::vector<const Message *> sorted;
   for (const auto &msg : messages_) {
     sorted.push_back(&msg);
diff --git a/lib/Parser/parse-tree.cpp b/lib/Parser/parse-tree.cpp
index 181bf066c587..819e4abfc831 100644
--- a/lib/Parser/parse-tree.cpp
+++ b/lib/Parser/parse-tree.cpp
@@ -11,6 +11,7 @@
 #include "flang/Common/indirection.h"
 #include "flang/Parser/tools.h"
 #include "flang/Parser/user-state.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 // So "delete Expr;" calls an external destructor for its typedExpr.
@@ -252,7 +253,7 @@ CharBlock Variable::GetSource() const {
       u);
 }
 
-std::ostream &operator<<(std::ostream &os, const Name &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Name &x) {
   return os << x.ToString();
 }
 
diff --git a/lib/Parser/parsing.cpp b/lib/Parser/parsing.cpp
index 9b77b9f0ada5..1b8256a00a81 100644
--- a/lib/Parser/parsing.cpp
+++ b/lib/Parser/parsing.cpp
@@ -13,7 +13,7 @@
 #include "flang/Parser/message.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
-#include <sstream>
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::parser {
 
@@ -29,12 +29,13 @@ const SourceFile *Parsing::Prescan(const std::string &path, Options options) {
     }
   }
 
-  std::stringstream fileError;
+  std::string buf;
+  llvm::raw_string_ostream fileError{buf};
   const SourceFile *sourceFile;
   if (path == "-") {
-    sourceFile = allSources.ReadStandardInput(&fileError);
+    sourceFile = allSources.ReadStandardInput(fileError);
   } else {
-    sourceFile = allSources.Open(path, &fileError);
+    sourceFile = allSources.Open(path, fileError);
   }
   if (!fileError.str().empty()) {
     ProvenanceRange range{allSources.AddCompilerInsertion(path)};
@@ -85,7 +86,7 @@ const SourceFile *Parsing::Prescan(const std::string &path, Options options) {
   return sourceFile;
 }
 
-void Parsing::DumpCookedChars(std::ostream &out) const {
+void Parsing::DumpCookedChars(llvm::raw_ostream &out) const {
   UserState userState{cooked_, common::LanguageFeatureControl{}};
   ParseState parseState{cooked_};
   parseState.set_inFixedForm(options_.isFixedForm).set_userState(&userState);
@@ -94,13 +95,15 @@ void Parsing::DumpCookedChars(std::ostream &out) const {
   }
 }
 
-void Parsing::DumpProvenance(std::ostream &out) const { cooked_.Dump(out); }
+void Parsing::DumpProvenance(llvm::raw_ostream &out) const {
+  cooked_.Dump(out);
+}
 
-void Parsing::DumpParsingLog(std::ostream &out) const {
+void Parsing::DumpParsingLog(llvm::raw_ostream &out) const {
   log_.Dump(out, cooked_);
 }
 
-void Parsing::Parse(std::ostream *out) {
+void Parsing::Parse(llvm::raw_ostream &out) {
   UserState userState{cooked_, options_.features};
   userState.set_debugOutput(out)
       .set_instrumentedParse(options_.instrumentedParse)
@@ -117,14 +120,15 @@ void Parsing::Parse(std::ostream *out) {
 
 void Parsing::ClearLog() { log_.clear(); }
 
-bool Parsing::ForTesting(std::string path, std::ostream &err) {
+bool Parsing::ForTesting(std::string path, llvm::raw_ostream &err) {
+  llvm::raw_null_ostream NullStream;
   Prescan(path, Options{});
   if (messages_.AnyFatalError()) {
     messages_.Emit(err, cooked_);
     err << "could not scan " << path << '\n';
     return false;
   }
-  Parse();
+  Parse(NullStream);
   messages_.Emit(err, cooked_);
   if (!consumedWholeFile_) {
     EmitMessage(err, finalRestingPlace_, "parser FAIL; final position");
diff --git a/lib/Parser/preprocessor.cpp b/lib/Parser/preprocessor.cpp
index f825f561e32b..d2fd07268ee5 100644
--- a/lib/Parser/preprocessor.cpp
+++ b/lib/Parser/preprocessor.cpp
@@ -11,6 +11,7 @@
 #include "flang/Common/idioms.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/message.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
@@ -19,7 +20,6 @@
 #include <memory>
 #include <optional>
 #include <set>
-#include <sstream>
 #include <utility>
 
 namespace Fortran::parser {
@@ -257,7 +257,8 @@ std::optional<TokenSequence> Preprocessor::MacroReplacement(
           repl = "\""s +
               allSources_.GetPath(prescanner.GetCurrentProvenance()) + '"';
         } else if (name == "__LINE__") {
-          std::stringstream ss;
+          std::string buf;
+          llvm::raw_string_ostream ss{buf};
           ss << allSources_.GetLineNumber(prescanner.GetCurrentProvenance());
           repl = ss.str();
         }
@@ -574,8 +575,9 @@ void Preprocessor::Directive(const TokenSequence &dir, Prescanner *prescanner) {
           "#include: empty include file name"_err_en_US);
       return;
     }
-    std::stringstream error;
-    const SourceFile *included{allSources_.Open(include, &error)};
+    std::string buf;
+    llvm::raw_string_ostream error{buf};
+    const SourceFile *included{allSources_.Open(include, error)};
     if (!included) {
       prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
           "#include: %s"_err_en_US, error.str());
diff --git a/lib/Parser/prescan.cpp b/lib/Parser/prescan.cpp
index c28fc1535e38..67d5cdfbfb1d 100644
--- a/lib/Parser/prescan.cpp
+++ b/lib/Parser/prescan.cpp
@@ -13,9 +13,9 @@
 #include "flang/Parser/characters.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/source.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstddef>
 #include <cstring>
-#include <sstream>
 #include <utility>
 #include <vector>
 
@@ -736,14 +736,15 @@ void Prescanner::FortranInclude(const char *firstQuote) {
     Say(GetProvenanceRange(garbage, p),
         "excess characters after path name"_en_US);
   }
-  std::stringstream error;
+  std::string buf;
+  llvm::raw_string_ostream error{buf};
   Provenance provenance{GetProvenance(nextLine_)};
   AllSources &allSources{cooked_.allSources()};
   const SourceFile *currentFile{allSources.GetSourceFile(provenance)};
   if (currentFile) {
     allSources.PushSearchPathDirectory(DirectoryName(currentFile->path()));
   }
-  const SourceFile *included{allSources.Open(path, &error)};
+  const SourceFile *included{allSources.Open(path, error)};
   if (currentFile) {
     allSources.PopSearchPathDirectory();
   }
diff --git a/lib/Parser/provenance.cpp b/lib/Parser/provenance.cpp
index db61e4e44f2e..fb43496b53ef 100644
--- a/lib/Parser/provenance.cpp
+++ b/lib/Parser/provenance.cpp
@@ -8,6 +8,7 @@
 
 #include "flang/Parser/provenance.h"
 #include "flang/Common/idioms.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <utility>
 
@@ -166,7 +167,7 @@ std::string AllSources::PopSearchPathDirectory() {
   return directory;
 }
 
-const SourceFile *AllSources::Open(std::string path, std::stringstream *error) {
+const SourceFile *AllSources::Open(std::string path, llvm::raw_ostream &error) {
   std::unique_ptr<SourceFile> source{std::make_unique<SourceFile>(encoding_)};
   if (source->Open(LocateSourceFile(path, searchPath_), error)) {
     return ownedSourceFiles_.emplace_back(std::move(source)).get();
@@ -175,7 +176,7 @@ const SourceFile *AllSources::Open(std::string path, std::stringstream *error) {
   }
 }
 
-const SourceFile *AllSources::ReadStandardInput(std::stringstream *error) {
+const SourceFile *AllSources::ReadStandardInput(llvm::raw_ostream &error) {
   std::unique_ptr<SourceFile> source{std::make_unique<SourceFile>(encoding_)};
   if (source->ReadStandardInput(error)) {
     return ownedSourceFiles_.emplace_back(std::move(source)).get();
@@ -209,7 +210,7 @@ ProvenanceRange AllSources::AddCompilerInsertion(std::string text) {
   return covers;
 }
 
-void AllSources::EmitMessage(std::ostream &o,
+void AllSources::EmitMessage(llvm::raw_ostream &o,
     const std::optional<ProvenanceRange> &range, const std::string &message,
     bool echoSourceLine) const {
   if (!range) {
@@ -470,12 +471,13 @@ void CookedSource::CompileProvenanceRangeToOffsetMappings() {
   }
 }
 
-static void DumpRange(std::ostream &o, const ProvenanceRange &r) {
+static void DumpRange(llvm::raw_ostream &o, const ProvenanceRange &r) {
   o << "[" << r.start().offset() << ".." << r.Last().offset() << "] ("
     << r.size() << " bytes)";
 }
 
-std::ostream &ProvenanceRangeToOffsetMappings::Dump(std::ostream &o) const {
+llvm::raw_ostream &ProvenanceRangeToOffsetMappings::Dump(
+    llvm::raw_ostream &o) const {
   for (const auto &m : map_) {
     o << "provenances ";
     DumpRange(o, m.first);
@@ -485,7 +487,8 @@ std::ostream &ProvenanceRangeToOffsetMappings::Dump(std::ostream &o) const {
   return o;
 }
 
-std::ostream &OffsetToProvenanceMappings::Dump(std::ostream &o) const {
+llvm::raw_ostream &OffsetToProvenanceMappings::Dump(
+    llvm::raw_ostream &o) const {
   for (const ContiguousProvenanceMapping &m : provenanceMap_) {
     std::size_t n{m.range.size()};
     o << "offsets [" << m.start << ".." << (m.start + n - 1)
@@ -496,7 +499,7 @@ std::ostream &OffsetToProvenanceMappings::Dump(std::ostream &o) const {
   return o;
 }
 
-std::ostream &AllSources::Dump(std::ostream &o) const {
+llvm::raw_ostream &AllSources::Dump(llvm::raw_ostream &o) const {
   o << "AllSources range_ ";
   DumpRange(o, range_);
   o << '\n';
@@ -517,7 +520,8 @@ std::ostream &AllSources::Dump(std::ostream &o) const {
               o << "compiler '" << ins.text << '\'';
               if (ins.text.length() == 1) {
                 int ch = ins.text[0];
-                o << " (0x" << std::hex << (ch & 0xff) << std::dec << ")";
+                o << "(0x";
+                o.write_hex(ch & 0xff) << ")";
               }
             },
         },
@@ -531,7 +535,7 @@ std::ostream &AllSources::Dump(std::ostream &o) const {
   return o;
 }
 
-std::ostream &CookedSource::Dump(std::ostream &o) const {
+llvm::raw_ostream &CookedSource::Dump(llvm::raw_ostream &o) const {
   o << "CookedSource:\n";
   allSources_.Dump(o);
   o << "CookedSource::provenanceMap_:\n";
diff --git a/lib/Parser/source.cpp b/lib/Parser/source.cpp
index e1bbfcac765c..4f8a08aa5271 100644
--- a/lib/Parser/source.cpp
+++ b/lib/Parser/source.cpp
@@ -9,8 +9,9 @@
 #include "flang/Parser/source.h"
 #include "flang/Common/idioms.h"
 #include "flang/Parser/char-buffer.h"
+#include "llvm/Support/Errno.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cerrno>
 #include <cstddef>
 #include <cstring>
 #include <fcntl.h>
@@ -111,36 +112,38 @@ static std::size_t RemoveCarriageReturns(char *buffer, std::size_t bytes) {
   return wrote;
 }
 
-bool SourceFile::Open(std::string path, std::stringstream *error) {
+bool SourceFile::Open(std::string path, llvm::raw_ostream &error) {
   Close();
   path_ = path;
   std::string errorPath{"'"s + path + "'"};
   errno = 0;
   fileDescriptor_ = open(path.c_str(), O_RDONLY);
   if (fileDescriptor_ < 0) {
-    *error << "Could not open " << errorPath << ": " << std::strerror(errno);
+    error << "Could not open " << errorPath << ": "
+          << llvm::sys::StrError(errno);
     return false;
   }
   ++openFileDescriptors;
   return ReadFile(errorPath, error);
 }
 
-bool SourceFile::ReadStandardInput(std::stringstream *error) {
+bool SourceFile::ReadStandardInput(llvm::raw_ostream &error) {
   Close();
   path_ = "standard input";
   fileDescriptor_ = 0;
   return ReadFile(path_, error);
 }
 
-bool SourceFile::ReadFile(std::string errorPath, std::stringstream *error) {
+bool SourceFile::ReadFile(std::string errorPath, llvm::raw_ostream &error) {
   struct stat statbuf;
   if (fstat(fileDescriptor_, &statbuf) != 0) {
-    *error << "fstat failed on " << errorPath << ": " << std::strerror(errno);
+    error << "fstat failed on " << errorPath << ": "
+          << llvm::sys::StrError(errno);
     Close();
     return false;
   }
   if (S_ISDIR(statbuf.st_mode)) {
-    *error << errorPath << " is a directory";
+    error << errorPath << " is a directory";
     Close();
     return false;
   }
@@ -203,7 +206,8 @@ bool SourceFile::ReadFile(std::string errorPath, std::stringstream *error) {
     char *to{buffer.FreeSpace(count)};
     ssize_t got{read(fileDescriptor_, to, count)};
     if (got < 0) {
-      *error << "could not read " << errorPath << ": " << std::strerror(errno);
+      error << "could not read " << errorPath << ": "
+            << llvm::sys::StrError(errno);
       Close();
       return false;
     }
diff --git a/lib/Parser/token-sequence.cpp b/lib/Parser/token-sequence.cpp
index 23aa450ceb41..235a4a4d303f 100644
--- a/lib/Parser/token-sequence.cpp
+++ b/lib/Parser/token-sequence.cpp
@@ -8,6 +8,7 @@
 
 #include "token-sequence.h"
 #include "flang/Parser/characters.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::parser {
 
@@ -123,7 +124,7 @@ void TokenSequence::Put(const std::string &s, Provenance provenance) {
   Put(s.data(), s.size(), provenance);
 }
 
-void TokenSequence::Put(const std::stringstream &ss, Provenance provenance) {
+void TokenSequence::Put(llvm::raw_string_ostream &ss, Provenance provenance) {
   Put(ss.str(), provenance);
 }
 
@@ -248,7 +249,7 @@ void TokenSequence::Emit(CookedSource &cooked) const {
   cooked.PutProvenanceMappings(provenances_);
 }
 
-void TokenSequence::Dump(std::ostream &o) const {
+void TokenSequence::Dump(llvm::raw_ostream &o) const {
   o << "TokenSequence has " << char_.size() << " chars; nextStart_ "
     << nextStart_ << '\n';
   for (std::size_t j{0}; j < start_.size(); ++j) {
diff --git a/lib/Parser/token-sequence.h b/lib/Parser/token-sequence.h
index d0ef0750e2fe..b70134bd4b20 100644
--- a/lib/Parser/token-sequence.h
+++ b/lib/Parser/token-sequence.h
@@ -17,11 +17,14 @@
 #include "flang/Parser/provenance.h"
 #include <cstddef>
 #include <cstring>
-#include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::parser {
 
 // Buffers a contiguous sequence of characters that has been partitioned into
@@ -91,7 +94,7 @@ class TokenSequence {
   void Put(const char *, std::size_t, Provenance);
   void Put(const CharBlock &, Provenance);
   void Put(const std::string &, Provenance);
-  void Put(const std::stringstream &, Provenance);
+  void Put(llvm::raw_string_ostream &, Provenance);
 
   Provenance GetTokenProvenance(
       std::size_t token, std::size_t offset = 0) const;
@@ -109,7 +112,7 @@ class TokenSequence {
   TokenSequence &RemoveRedundantBlanks(std::size_t firstChar = 0);
   TokenSequence &ClipComment(bool skipFirst = false);
   void Emit(CookedSource &) const;
-  void Dump(std::ostream &) const;
+  void Dump(llvm::raw_ostream &) const;
 
 private:
   std::size_t TokenBytes(std::size_t token) const {
diff --git a/lib/Parser/unparse.cpp b/lib/Parser/unparse.cpp
index 45bb54fd58fa..5a67bac118e0 100644
--- a/lib/Parser/unparse.cpp
+++ b/lib/Parser/unparse.cpp
@@ -16,6 +16,7 @@
 #include "flang/Parser/characters.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
@@ -25,9 +26,9 @@ namespace Fortran::parser {
 
 class UnparseVisitor {
 public:
-  UnparseVisitor(std::ostream &out, int indentationAmount, Encoding encoding,
-      bool capitalize, bool backslashEscapes, preStatementType *preStatement,
-      AnalyzedObjectsAsFortran *asFortran)
+  UnparseVisitor(llvm::raw_ostream &out, int indentationAmount,
+      Encoding encoding, bool capitalize, bool backslashEscapes,
+      preStatementType *preStatement, AnalyzedObjectsAsFortran *asFortran)
     : out_{out}, indentationAmount_{indentationAmount}, encoding_{encoding},
       capitalizeKeywords_{capitalize}, backslashEscapes_{backslashEscapes},
       preStatement_{preStatement}, asFortran_{asFortran} {}
@@ -2511,7 +2512,7 @@ class UnparseVisitor {
     structureComponents_.clear();
   }
 
-  std::ostream &out_;
+  llvm::raw_ostream &out_;
   int indent_{0};
   const int indentationAmount_{1};
   int column_{1};
@@ -2593,7 +2594,7 @@ void UnparseVisitor::Word(const char *str) {
 
 void UnparseVisitor::Word(const std::string &str) { Word(str.c_str()); }
 
-void Unparse(std::ostream &out, const Program &program, Encoding encoding,
+void Unparse(llvm::raw_ostream &out, const Program &program, Encoding encoding,
     bool capitalizeKeywords, bool backslashEscapes,
     preStatementType *preStatement, AnalyzedObjectsAsFortran *asFortran) {
   UnparseVisitor visitor{out, 1, encoding, capitalizeKeywords, backslashEscapes,
diff --git a/lib/Semantics/attr.cpp b/lib/Semantics/attr.cpp
index 341fe5e67f89..e041a8f511c3 100644
--- a/lib/Semantics/attr.cpp
+++ b/lib/Semantics/attr.cpp
@@ -8,7 +8,7 @@
 
 #include "flang/Semantics/attr.h"
 #include "flang/Common/idioms.h"
-#include <ostream>
+#include "llvm/Support/raw_ostream.h"
 #include <stddef.h>
 
 namespace Fortran::semantics {
@@ -29,11 +29,11 @@ std::string AttrToString(Attr attr) {
   }
 }
 
-std::ostream &operator<<(std::ostream &o, Attr attr) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, Attr attr) {
   return o << AttrToString(attr);
 }
 
-std::ostream &operator<<(std::ostream &o, const Attrs &attrs) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Attrs &attrs) {
   std::size_t n{attrs.count()};
   std::size_t seen{0};
   for (std::size_t j{0}; seen < n; ++j) {
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index 84ec0a7386fe..fa8f96e4c79a 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -22,11 +22,11 @@
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <functional>
 #include <optional>
 #include <set>
-#include <sstream>
 
 // Typedef for optional generic expressions (ubiquitous in this file)
 using MaybeExpr =
@@ -174,7 +174,7 @@ class ArgumentAnalyzer {
   // Find and return a user-defined assignment
   std::optional<ProcedureRef> TryDefinedAssignment();
   std::optional<ProcedureRef> GetDefinedAssignmentProc();
-  void Dump(std::ostream &);
+  void Dump(llvm::raw_ostream &);
 
 private:
   MaybeExpr TryDefinedOp(
@@ -2426,7 +2426,8 @@ MaybeExpr ExpressionAnalyzer::ExprOrVariable(const PARSED &x) {
     x.typedExpr.reset(new GenericExprWrapper{std::move(result)});
     if (!x.typedExpr->v) {
       if (!context_.AnyFatalError()) {
-        std::stringstream dump;
+        std::string buf;
+        llvm::raw_string_ostream dump{buf};
         parser::DumpTree(dump, x);
         Say("Internal error: Expression analysis failed on: %s"_err_en_US,
             dump.str());
@@ -2542,7 +2543,7 @@ bool ExpressionAnalyzer::EnforceTypeConstraint(parser::CharBlock at,
     const MaybeExpr &result, TypeCategory category, bool defaultKind) {
   if (result) {
     if (auto type{result->GetType()}) {
-      if (type->category() != category) {  // C885
+      if (type->category() != category) { // C885
         Say(at, "Must have %s type, but is %s"_err_en_US,
             ToUpperCase(EnumToString(category)),
             ToUpperCase(type->AsFortran()));
@@ -2848,7 +2849,7 @@ std::optional<ProcedureRef> ArgumentAnalyzer::GetDefinedAssignmentProc() {
   }
 }
 
-void ArgumentAnalyzer::Dump(std::ostream &os) {
+void ArgumentAnalyzer::Dump(llvm::raw_ostream &os) {
   os << "source_: " << source_.ToString() << " fatalErrors_ = " << fatalErrors_
      << '\n';
   for (const auto &actual : actuals_) {
diff --git a/lib/Semantics/mod-file.cpp b/lib/Semantics/mod-file.cpp
index 7251e3fa285a..bbf62f9c372f 100644
--- a/lib/Semantics/mod-file.cpp
+++ b/lib/Semantics/mod-file.cpp
@@ -20,7 +20,6 @@
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <fstream>
-#include <ostream>
 #include <set>
 #include <string_view>
 #include <vector>
@@ -44,22 +43,23 @@ struct ModHeader {
 
 static std::optional<SourceName> GetSubmoduleParent(const parser::Program &);
 static SymbolVector CollectSymbols(const Scope &);
-static void PutEntity(std::ostream &, const Symbol &);
-static void PutObjectEntity(std::ostream &, const Symbol &);
-static void PutProcEntity(std::ostream &, const Symbol &);
-static void PutPassName(std::ostream &, const std::optional<SourceName> &);
-static void PutTypeParam(std::ostream &, const Symbol &);
+static void PutEntity(llvm::raw_ostream &, const Symbol &);
+static void PutObjectEntity(llvm::raw_ostream &, const Symbol &);
+static void PutProcEntity(llvm::raw_ostream &, const Symbol &);
+static void PutPassName(llvm::raw_ostream &, const std::optional<SourceName> &);
+static void PutTypeParam(llvm::raw_ostream &, const Symbol &);
 static void PutEntity(
-    std::ostream &, const Symbol &, std::function<void()>, Attrs);
-static void PutInit(std::ostream &, const Symbol &, const MaybeExpr &);
-static void PutInit(std::ostream &, const MaybeIntExpr &);
-static void PutBound(std::ostream &, const Bound &);
-static std::ostream &PutAttrs(std::ostream &, Attrs,
+    llvm::raw_ostream &, const Symbol &, std::function<void()>, Attrs);
+static void PutInit(llvm::raw_ostream &, const Symbol &, const MaybeExpr &);
+static void PutInit(llvm::raw_ostream &, const MaybeIntExpr &);
+static void PutBound(llvm::raw_ostream &, const Bound &);
+static llvm::raw_ostream &PutAttrs(llvm::raw_ostream &, Attrs,
     const MaybeExpr & = std::nullopt, std::string before = ","s,
     std::string after = ""s);
-static std::ostream &PutAttr(std::ostream &, Attr);
-static std::ostream &PutType(std::ostream &, const DeclTypeSpec &);
-static std::ostream &PutLower(std::ostream &, const std::string &);
+
+static llvm::raw_ostream &PutAttr(llvm::raw_ostream &, Attr);
+static llvm::raw_ostream &PutType(llvm::raw_ostream &, const DeclTypeSpec &);
+static llvm::raw_ostream &PutLower(llvm::raw_ostream &, const std::string &);
 static std::error_code WriteFile(
     const std::string &, const std::string &, bool = true);
 static bool FileContentsMatch(
@@ -143,7 +143,8 @@ void ModFileWriter::Write(const Symbol &symbol) {
 // Return the entire body of the module file
 // and clear saved uses, decls, and contains.
 std::string ModFileWriter::GetAsString(const Symbol &symbol) {
-  std::stringstream all;
+  std::string buf;
+  llvm::raw_string_ostream all{buf};
   auto &details{symbol.get<ModuleDetails>()};
   if (!details.isSubmodule()) {
     all << "module " << symbol.name();
@@ -157,13 +158,13 @@ std::string ModFileWriter::GetAsString(const Symbol &symbol) {
     all << ") " << symbol.name();
   }
   all << '\n' << uses_.str();
-  uses_.str(""s);
+  uses_.str().clear();
   all << useExtraAttrs_.str();
-  useExtraAttrs_.str(""s);
+  useExtraAttrs_.str().clear();
   all << decls_.str();
-  decls_.str(""s);
+  decls_.str().clear();
   auto str{contains_.str()};
-  contains_.str(""s);
+  contains_.str().clear();
   if (!str.empty()) {
     all << "contains\n" << str;
   }
@@ -173,7 +174,9 @@ std::string ModFileWriter::GetAsString(const Symbol &symbol) {
 
 // Put out the visible symbols from scope.
 void ModFileWriter::PutSymbols(const Scope &scope) {
-  std::stringstream typeBindings;  // stuff after CONTAINS in derived type
+  std::string buf;
+  llvm::raw_string_ostream typeBindings{
+      buf};  // stuff after CONTAINS in derived type
   for (const Symbol &symbol : CollectSymbols(scope)) {
     PutSymbol(typeBindings, symbol);
   }
@@ -186,7 +189,7 @@ void ModFileWriter::PutSymbols(const Scope &scope) {
 // Emit a symbol to decls_, except for bindings in a derived type (type-bound
 // procedures, type-bound generics, final procedures) which go to typeBindings.
 void ModFileWriter::PutSymbol(
-    std::stringstream &typeBindings, const Symbol &symbol) {
+    llvm::raw_ostream &typeBindings, const Symbol &symbol) {
   std::visit(
       common::visitors{
           [&](const ModuleDetails &) { /* should be current module */ },
@@ -301,13 +304,14 @@ void ModFileWriter::PutSubprogram(const Symbol &symbol) {
   Attrs prefixAttrs{subprogramPrefixAttrs & attrs};
   // emit any non-prefix attributes in an attribute statement
   attrs &= ~subprogramPrefixAttrs;
-  std::stringstream ss;
+  std::string ssBuf;
+  llvm::raw_string_ostream ss{ssBuf};
   PutAttrs(ss, attrs);
   if (!ss.str().empty()) {
     decls_ << ss.str().substr(1) << "::" << symbol.name() << '\n';
   }
   bool isInterface{details.isInterface()};
-  std::ostream &os{isInterface ? decls_ : contains_};
+  llvm::raw_ostream &os{isInterface ? decls_ : contains_};
   if (isInterface) {
     os << "interface\n";
   }
@@ -333,7 +337,8 @@ void ModFileWriter::PutSubprogram(const Symbol &symbol) {
 
   // walk symbols, collect ones needed
   ModFileWriter writer{context_};
-  std::stringstream typeBindings;
+  std::string typeBindingsBuf;
+  llvm::raw_string_ostream typeBindings{typeBindingsBuf};
   SubprogramSymbolCollector collector{symbol};
   collector.Collect();
   for (const Symbol &need : collector.symbols()) {
@@ -359,7 +364,8 @@ static bool IsIntrinsicOp(const Symbol &symbol) {
   }
 }
 
-static std::ostream &PutGenericName(std::ostream &os, const Symbol &symbol) {
+static llvm::raw_ostream &PutGenericName(
+    llvm::raw_ostream &os, const Symbol &symbol) {
   if (IsGenericDefinedOp(symbol)) {
     return os << "operator(" << symbol.name() << ')';
   } else {
@@ -440,7 +446,7 @@ SymbolVector CollectSymbols(const Scope &scope) {
   return sorted;
 }
 
-void PutEntity(std::ostream &os, const Symbol &symbol) {
+void PutEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   std::visit(
       common::visitors{
           [&](const ObjectEntityDetails &) { PutObjectEntity(os, symbol); },
@@ -454,7 +460,7 @@ void PutEntity(std::ostream &os, const Symbol &symbol) {
       symbol.details());
 }
 
-void PutShapeSpec(std::ostream &os, const ShapeSpec &x) {
+void PutShapeSpec(llvm::raw_ostream &os, const ShapeSpec &x) {
   if (x.lbound().isAssumed()) {
     CHECK(x.ubound().isAssumed());
     os << "..";
@@ -468,7 +474,8 @@ void PutShapeSpec(std::ostream &os, const ShapeSpec &x) {
     }
   }
 }
-void PutShape(std::ostream &os, const ArraySpec &shape, char open, char close) {
+void PutShape(
+    llvm::raw_ostream &os, const ArraySpec &shape, char open, char close) {
   if (!shape.empty()) {
     os << open;
     bool first{true};
@@ -484,7 +491,7 @@ void PutShape(std::ostream &os, const ArraySpec &shape, char open, char close) {
   }
 }
 
-void PutObjectEntity(std::ostream &os, const Symbol &symbol) {
+void PutObjectEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   auto &details{symbol.get<ObjectEntityDetails>()};
   PutEntity(os, symbol, [&]() { PutType(os, DEREF(symbol.GetType())); },
       symbol.attrs());
@@ -494,7 +501,7 @@ void PutObjectEntity(std::ostream &os, const Symbol &symbol) {
   os << '\n';
 }
 
-void PutProcEntity(std::ostream &os, const Symbol &symbol) {
+void PutProcEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   if (symbol.attrs().test(Attr::INTRINSIC)) {
     os << "intrinsic::" << symbol.name() << '\n';
     return;
@@ -520,13 +527,13 @@ void PutProcEntity(std::ostream &os, const Symbol &symbol) {
   os << '\n';
 }
 
-void PutPassName(std::ostream &os, const std::optional<SourceName> &passName) {
+void PutPassName(
+    llvm::raw_ostream &os, const std::optional<SourceName> &passName) {
   if (passName) {
     os << ",pass(" << *passName << ')';
   }
 }
-
-void PutTypeParam(std::ostream &os, const Symbol &symbol) {
+void PutTypeParam(llvm::raw_ostream &os, const Symbol &symbol) {
   auto &details{symbol.get<TypeParamDetails>()};
   PutEntity(os, symbol,
       [&]() {
@@ -538,7 +545,8 @@ void PutTypeParam(std::ostream &os, const Symbol &symbol) {
   os << '\n';
 }
 
-void PutInit(std::ostream &os, const Symbol &symbol, const MaybeExpr &init) {
+void PutInit(
+    llvm::raw_ostream &os, const Symbol &symbol, const MaybeExpr &init) {
   if (init) {
     if (symbol.attrs().test(Attr::PARAMETER) ||
         symbol.owner().IsDerivedType()) {
@@ -548,13 +556,13 @@ void PutInit(std::ostream &os, const Symbol &symbol, const MaybeExpr &init) {
   }
 }
 
-void PutInit(std::ostream &os, const MaybeIntExpr &init) {
+void PutInit(llvm::raw_ostream &os, const MaybeIntExpr &init) {
   if (init) {
     init->AsFortran(os << '=');
   }
 }
 
-void PutBound(std::ostream &os, const Bound &x) {
+void PutBound(llvm::raw_ostream &os, const Bound &x) {
   if (x.isAssumed()) {
     os << '*';
   } else if (x.isDeferred()) {
@@ -566,7 +574,7 @@ void PutBound(std::ostream &os, const Bound &x) {
 
 // Write an entity (object or procedure) declaration.
 // writeType is called to write out the type.
-void PutEntity(std::ostream &os, const Symbol &symbol,
+void PutEntity(llvm::raw_ostream &os, const Symbol &symbol,
     std::function<void()> writeType, Attrs attrs) {
   writeType();
   MaybeExpr bindName;
@@ -584,8 +592,8 @@ void PutEntity(std::ostream &os, const Symbol &symbol,
 
 // Put out each attribute to os, surrounded by `before` and `after` and
 // mapped to lower case.
-std::ostream &PutAttrs(std::ostream &os, Attrs attrs, const MaybeExpr &bindName,
-    std::string before, std::string after) {
+llvm::raw_ostream &PutAttrs(llvm::raw_ostream &os, Attrs attrs,
+    const MaybeExpr &bindName, std::string before, std::string after) {
   attrs.set(Attr::PUBLIC, false);  // no need to write PUBLIC
   attrs.set(Attr::EXTERNAL, false);  // no need to write EXTERNAL
   if (bindName) {
@@ -601,15 +609,15 @@ std::ostream &PutAttrs(std::ostream &os, Attrs attrs, const MaybeExpr &bindName,
   return os;
 }
 
-std::ostream &PutAttr(std::ostream &os, Attr attr) {
+llvm::raw_ostream &PutAttr(llvm::raw_ostream &os, Attr attr) {
   return PutLower(os, AttrToString(attr));
 }
 
-std::ostream &PutType(std::ostream &os, const DeclTypeSpec &type) {
+llvm::raw_ostream &PutType(llvm::raw_ostream &os, const DeclTypeSpec &type) {
   return PutLower(os, type.AsFortran());
 }
 
-std::ostream &PutLower(std::ostream &os, const std::string &str) {
+llvm::raw_ostream &PutLower(llvm::raw_ostream &os, const std::string &str) {
   for (char c : str) {
     os << parser::ToLowerCaseLetter(c);
   }
@@ -764,8 +772,8 @@ Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
         sourceFile->path());
     return nullptr;
   }
-
-  parsing.Parse(nullptr);
+  llvm::raw_null_ostream NullStream;
+  parsing.Parse(NullStream);
   auto &parseTree{parsing.parseTree()};
   if (!parsing.messages().empty() || !parsing.consumedWholeFile() ||
       !parseTree) {
diff --git a/lib/Semantics/mod-file.h b/lib/Semantics/mod-file.h
index 1bc356ad1bc1..d71a0f599af8 100644
--- a/lib/Semantics/mod-file.h
+++ b/lib/Semantics/mod-file.h
@@ -10,7 +10,6 @@
 #define FORTRAN_SEMANTICS_MOD_FILE_H_
 
 #include "flang/Semantics/attr.h"
-#include <sstream>
 #include <string>
 
 namespace Fortran::parser {
@@ -19,6 +18,10 @@ class Message;
 class MessageFixedText;
 }
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::semantics {
 
 using SourceName = parser::CharBlock;
@@ -33,17 +36,23 @@ class ModFileWriter {
 
 private:
   SemanticsContext &context_;
-  std::stringstream uses_;
-  std::stringstream useExtraAttrs_;  // attrs added to used entity
-  std::stringstream decls_;
-  std::stringstream contains_;
+  // Buffer to use with raw_string_ostream
+  std::string usesBuf_;
+  std::string useExtraAttrsBuf_;
+  std::string declsBuf_;
+  std::string containsBuf_;
+
+  llvm::raw_string_ostream uses_{usesBuf_};
+  llvm::raw_string_ostream useExtraAttrs_{useExtraAttrsBuf_};  // attrs added to used entity
+  llvm::raw_string_ostream decls_{declsBuf_};
+  llvm::raw_string_ostream contains_{containsBuf_};
 
   void WriteAll(const Scope &);
   void WriteOne(const Scope &);
   void Write(const Symbol &);
   std::string GetAsString(const Symbol &);
   void PutSymbols(const Scope &);
-  void PutSymbol(std::stringstream &, const Symbol &);
+  void PutSymbol(llvm::raw_ostream &, const Symbol &);
   void PutDerivedType(const Symbol &);
   void PutSubprogram(const Symbol &);
   void PutGeneric(const Symbol &);
diff --git a/lib/Semantics/pointer-assignment.cpp b/lib/Semantics/pointer-assignment.cpp
index b59dc8169aff..fdb6addc20de 100644
--- a/lib/Semantics/pointer-assignment.cpp
+++ b/lib/Semantics/pointer-assignment.cpp
@@ -19,6 +19,7 @@
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
+#include "llvm/Support/raw_ostream.h"
 #include <optional>
 #include <set>
 #include <string>
@@ -232,7 +233,8 @@ void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
   if (msg) {
     auto restorer{common::ScopedSet(lhs_, last)};
     if (auto *m{std::get_if<MessageFixedText>(&*msg)}) {
-      std::ostringstream ss;
+      std::string buf;
+      llvm::raw_string_ostream ss{buf};
       d.AsFortran(ss);
       Say(*m, description_, ss.str());
     } else {
diff --git a/lib/Semantics/resolve-names-utils.cpp b/lib/Semantics/resolve-names-utils.cpp
index afc0aac5a315..4c0e70e8caf4 100644
--- a/lib/Semantics/resolve-names-utils.cpp
+++ b/lib/Semantics/resolve-names-utils.cpp
@@ -19,7 +19,6 @@
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/tools.h"
 #include <initializer_list>
-#include <ostream>
 #include <variant>
 
 namespace Fortran::semantics {
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 42766f738e07..c696d5e4fe82 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -33,9 +33,9 @@
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
+#include "llvm/Support/raw_ostream.h"
 #include <list>
 #include <map>
-#include <ostream>
 #include <set>
 #include <stack>
 
@@ -86,8 +86,10 @@ class ImplicitRules {
   // the default Fortran mappings nor the mapping defined in parents.
   std::map<char, common::Reference<const DeclTypeSpec>> map_;
 
-  friend std::ostream &operator<<(std::ostream &, const ImplicitRules &);
-  friend void ShowImplicitRule(std::ostream &, const ImplicitRules &, char);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const ImplicitRules &);
+  friend void ShowImplicitRule(
+      llvm::raw_ostream &, const ImplicitRules &, char);
 };
 
 // scope -> implicit rules for that scope
@@ -1463,7 +1465,8 @@ char ImplicitRules::Incr(char ch) {
   }
 }
 
-std::ostream &operator<<(std::ostream &o, const ImplicitRules &implicitRules) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &o, const ImplicitRules &implicitRules) {
   o << "ImplicitRules:\n";
   for (char ch = 'a'; ch; ch = ImplicitRules::Incr(ch)) {
     ShowImplicitRule(o, implicitRules, ch);
@@ -1474,7 +1477,7 @@ std::ostream &operator<<(std::ostream &o, const ImplicitRules &implicitRules) {
   return o;
 }
 void ShowImplicitRule(
-    std::ostream &o, const ImplicitRules &implicitRules, char ch) {
+    llvm::raw_ostream &o, const ImplicitRules &implicitRules, char ch) {
   auto it{implicitRules.map_.find(ch)};
   if (it != implicitRules.map_.end()) {
     o << "  " << ch << ": " << *it->second << '\n';
diff --git a/lib/Semantics/resolve-names.h b/lib/Semantics/resolve-names.h
index 240f315bb715..218dc9c63eae 100644
--- a/lib/Semantics/resolve-names.h
+++ b/lib/Semantics/resolve-names.h
@@ -13,6 +13,10 @@
 #include <string>
 #include <vector>
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace Fortran::parser {
 struct Program;
 }
@@ -24,7 +28,7 @@ class Symbol;
 
 bool ResolveNames(SemanticsContext &, const parser::Program &);
 void ResolveSpecificationParts(SemanticsContext &, const Symbol &);
-void DumpSymbols(std::ostream &);
+void DumpSymbols(llvm::raw_ostream &);
 
 }
 
diff --git a/lib/Semantics/scope.cpp b/lib/Semantics/scope.cpp
index b63082f2c410..c25ce1114ddc 100644
--- a/lib/Semantics/scope.cpp
+++ b/lib/Semantics/scope.cpp
@@ -10,9 +10,9 @@
 #include "flang/Parser/characters.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/type.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <memory>
-#include <sstream>
 
 namespace Fortran::semantics {
 
@@ -32,7 +32,8 @@ bool EquivalenceObject::operator<(const EquivalenceObject &that) const {
 }
 
 std::string EquivalenceObject::AsFortran() const {
-  std::stringstream ss;
+  std::string buf;
+  llvm::raw_string_ostream ss{buf};
   ss << symbol.name().ToString();
   if (!subscripts.empty()) {
     char sep{'('};
@@ -283,7 +284,7 @@ void Scope::AddSourceRange(const parser::CharBlock &source) {
   }
 }
 
-std::ostream &operator<<(std::ostream &os, const Scope &scope) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Scope &scope) {
   os << Scope::EnumToString(scope.kind()) << " scope: ";
   if (auto *symbol{scope.symbol()}) {
     os << *symbol << ' ';
diff --git a/lib/Semantics/semantics.cpp b/lib/Semantics/semantics.cpp
index 745143267d6d..53be760b7741 100644
--- a/lib/Semantics/semantics.cpp
+++ b/lib/Semantics/semantics.cpp
@@ -35,12 +35,13 @@
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/symbol.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::semantics {
 
 using NameToSymbolMap = std::map<const char *, SymbolRef>;
-static void DoDumpSymbols(std::ostream &, const Scope &, int indent = 0);
-static void PutIndent(std::ostream &, int indent);
+static void DoDumpSymbols(llvm::raw_ostream &, const Scope &, int indent = 0);
+static void PutIndent(llvm::raw_ostream &, int indent);
 
 static void GetSymbolNames(const Scope &scope, NameToSymbolMap &symbols) {
   // Finds all symbol names in the scope without collecting duplicates.
@@ -282,15 +283,15 @@ bool Semantics::Perform() {
       ModFileWriter{context_}.WriteAll();
 }
 
-void Semantics::EmitMessages(std::ostream &os) const {
+void Semantics::EmitMessages(llvm::raw_ostream &os) const {
   context_.messages().Emit(os, cooked_);
 }
 
-void Semantics::DumpSymbols(std::ostream &os) {
+void Semantics::DumpSymbols(llvm::raw_ostream &os) {
   DoDumpSymbols(os, context_.globalScope());
 }
 
-void Semantics::DumpSymbolsSources(std::ostream &os) const {
+void Semantics::DumpSymbolsSources(llvm::raw_ostream &os) const {
   NameToSymbolMap symbols;
   GetSymbolNames(context_.globalScope(), symbols);
   for (const auto &pair : symbols) {
@@ -306,7 +307,7 @@ void Semantics::DumpSymbolsSources(std::ostream &os) const {
   }
 }
 
-void DoDumpSymbols(std::ostream &os, const Scope &scope, int indent) {
+void DoDumpSymbols(llvm::raw_ostream &os, const Scope &scope, int indent) {
   PutIndent(os, indent);
   os << Scope::EnumToString(scope.kind()) << " scope:";
   if (const auto *symbol{scope.symbol()}) {
@@ -357,7 +358,7 @@ void DoDumpSymbols(std::ostream &os, const Scope &scope, int indent) {
   --indent;
 }
 
-static void PutIndent(std::ostream &os, int indent) {
+static void PutIndent(llvm::raw_ostream &os, int indent) {
   for (int i = 0; i < indent; ++i) {
     os << "  ";
   }
diff --git a/lib/Semantics/symbol.cpp b/lib/Semantics/symbol.cpp
index 0017d891643b..a13f2c0d3779 100644
--- a/lib/Semantics/symbol.cpp
+++ b/lib/Semantics/symbol.cpp
@@ -12,32 +12,32 @@
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/tools.h"
-#include <ostream>
+#include "llvm/Support/raw_ostream.h"
 #include <string>
 
 namespace Fortran::semantics {
 
 template<typename T>
-static void DumpOptional(std::ostream &os, const char *label, const T &x) {
+static void DumpOptional(llvm::raw_ostream &os, const char *label, const T &x) {
   if (x) {
     os << ' ' << label << ':' << *x;
   }
 }
 template<typename T>
-static void DumpExpr(std::ostream &os, const char *label,
+static void DumpExpr(llvm::raw_ostream &os, const char *label,
     const std::optional<evaluate::Expr<T>> &x) {
   if (x) {
     x->AsFortran(os << ' ' << label << ':');
   }
 }
 
-static void DumpBool(std::ostream &os, const char *label, bool x) {
+static void DumpBool(llvm::raw_ostream &os, const char *label, bool x) {
   if (x) {
     os << ' ' << label;
   }
 }
 
-static void DumpSymbolVector(std::ostream &os, const SymbolVector &list) {
+static void DumpSymbolVector(llvm::raw_ostream &os, const SymbolVector &list) {
   char sep{' '};
   for (const Symbol &elem : list) {
     os << sep << elem.name();
@@ -45,19 +45,19 @@ static void DumpSymbolVector(std::ostream &os, const SymbolVector &list) {
   }
 }
 
-static void DumpType(std::ostream &os, const Symbol &symbol) {
+static void DumpType(llvm::raw_ostream &os, const Symbol &symbol) {
   if (const auto *type{symbol.GetType()}) {
     os << *type << ' ';
   }
 }
-static void DumpType(std::ostream &os, const DeclTypeSpec *type) {
+static void DumpType(llvm::raw_ostream &os, const DeclTypeSpec *type) {
   if (type) {
     os << ' ' << *type;
   }
 }
 
 template<typename T>
-static void DumpList(std::ostream &os, const char *label, const T &list) {
+static void DumpList(llvm::raw_ostream &os, const char *label, const T &list) {
   if (!list.empty()) {
     os << ' ' << label << ':';
     char sep{' '};
@@ -81,7 +81,8 @@ void ModuleDetails::set_scope(const Scope *scope) {
   scope_ = scope;
 }
 
-std::ostream &operator<<(std::ostream &os, const SubprogramDetails &x) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const SubprogramDetails &x) {
   DumpBool(os, "isInterface", x.isInterface_);
   DumpExpr(os, "bindName", x.bindName_);
   if (x.result_) {
@@ -334,7 +335,7 @@ bool Symbol::IsFromModFile() const {
 ObjectEntityDetails::ObjectEntityDetails(EntityDetails &&d)
   : EntityDetails(d) {}
 
-std::ostream &operator<<(std::ostream &os, const EntityDetails &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const EntityDetails &x) {
   DumpBool(os, "dummy", x.isDummy());
   DumpBool(os, "funcResult", x.isFuncResult());
   if (x.type()) {
@@ -344,7 +345,8 @@ std::ostream &operator<<(std::ostream &os, const EntityDetails &x) {
   return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const ObjectEntityDetails &x) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const ObjectEntityDetails &x) {
   os << *static_cast<const EntityDetails *>(&x);
   DumpList(os, "shape", x.shape());
   DumpList(os, "coshape", x.coshape());
@@ -352,13 +354,15 @@ std::ostream &operator<<(std::ostream &os, const ObjectEntityDetails &x) {
   return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const AssocEntityDetails &x) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const AssocEntityDetails &x) {
   os << *static_cast<const EntityDetails *>(&x);
   DumpExpr(os, "expr", x.expr());
   return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const ProcEntityDetails &x) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const ProcEntityDetails &x) {
   if (auto *symbol{x.interface_.symbol()}) {
     os << ' ' << symbol->name();
   } else {
@@ -376,13 +380,14 @@ std::ostream &operator<<(std::ostream &os, const ProcEntityDetails &x) {
   return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const DerivedTypeDetails &x) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const DerivedTypeDetails &x) {
   DumpBool(os, "sequence", x.sequence_);
   DumpList(os, "components", x.componentNames_);
   return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const Details &details) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Details &details) {
   os << DetailsToString(details);
   std::visit(
       common::visitors{
@@ -453,11 +458,12 @@ std::ostream &operator<<(std::ostream &os, const Details &details) {
   return os;
 }
 
-std::ostream &operator<<(std::ostream &o, Symbol::Flag flag) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, Symbol::Flag flag) {
   return o << Symbol::EnumToString(flag);
 }
 
-std::ostream &operator<<(std::ostream &o, const Symbol::Flags &flags) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &o, const Symbol::Flags &flags) {
   std::size_t n{flags.count()};
   std::size_t seen{0};
   for (std::size_t j{0}; seen < n; ++j) {
@@ -472,7 +478,7 @@ std::ostream &operator<<(std::ostream &o, const Symbol::Flags &flags) {
   return o;
 }
 
-std::ostream &operator<<(std::ostream &os, const Symbol &symbol) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Symbol &symbol) {
   os << symbol.name();
   if (!symbol.attrs().empty()) {
     os << ", " << symbol.attrs();
@@ -487,7 +493,7 @@ std::ostream &operator<<(std::ostream &os, const Symbol &symbol) {
 // Output a unique name for a scope by qualifying it with the names of
 // parent scopes. For scopes without corresponding symbols, use the kind
 // with an index (e.g. Block1, Block2, etc.).
-static void DumpUniqueName(std::ostream &os, const Scope &scope) {
+static void DumpUniqueName(llvm::raw_ostream &os, const Scope &scope) {
   if (!scope.IsGlobal()) {
     DumpUniqueName(os, scope.parent());
     os << '/';
@@ -511,8 +517,8 @@ static void DumpUniqueName(std::ostream &os, const Scope &scope) {
 
 // Dump a symbol for UnparseWithSymbols. This will be used for tests so the
 // format should be reasonably stable.
-std::ostream &DumpForUnparse(
-    std::ostream &os, const Symbol &symbol, bool isDef) {
+llvm::raw_ostream &DumpForUnparse(
+    llvm::raw_ostream &os, const Symbol &symbol, bool isDef) {
   DumpUniqueName(os, symbol.owner());
   os << '/' << symbol.name();
   if (isDef) {
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index cc3b9084af34..f6a4e39e511d 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -17,9 +17,9 @@
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <set>
-#include <sstream>
 #include <variant>
 
 namespace Fortran::semantics {
@@ -414,7 +414,8 @@ bool ExprTypeKindIsDefault(
 // If an analyzed expr or assignment is missing, dump the node and die.
 template<typename T> static void CheckMissingAnalysis(bool absent, const T &x) {
   if (absent) {
-    std::ostringstream ss;
+    std::string buf;
+    llvm::raw_string_ostream ss{buf};
     ss << "node has not been analyzed:\n";
     parser::DumpTree(ss, x);
     common::die(ss.str().c_str());
diff --git a/lib/Semantics/type.cpp b/lib/Semantics/type.cpp
index 49bd618e3637..cba4d3ce9b0c 100644
--- a/lib/Semantics/type.cpp
+++ b/lib/Semantics/type.cpp
@@ -12,8 +12,7 @@
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
-#include <ostream>
-#include <sstream>
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::semantics {
 
@@ -272,7 +271,8 @@ void DerivedTypeSpec::Instantiate(
 }
 
 std::string DerivedTypeSpec::AsFortran() const {
-  std::stringstream ss;
+  std::string buf;
+  llvm::raw_string_ostream ss{buf};
   ss << name_;
   if (!rawParameters_.empty()) {
     CHECK(parameters_.empty());
@@ -306,13 +306,13 @@ std::string DerivedTypeSpec::AsFortran() const {
   return ss.str();
 }
 
-std::ostream &operator<<(std::ostream &o, const DerivedTypeSpec &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const DerivedTypeSpec &x) {
   return o << x.AsFortran();
 }
 
 Bound::Bound(int bound) : expr_{bound} {}
 
-std::ostream &operator<<(std::ostream &o, const Bound &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Bound &x) {
   if (x.isAssumed()) {
     o << '*';
   } else if (x.isDeferred()) {
@@ -325,7 +325,7 @@ std::ostream &operator<<(std::ostream &o, const Bound &x) {
   return o;
 }
 
-std::ostream &operator<<(std::ostream &o, const ShapeSpec &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const ShapeSpec &x) {
   if (x.lb_.isAssumed()) {
     CHECK(x.ub_.isAssumed());
     o << "..";
@@ -365,7 +365,8 @@ bool ArraySpec::IsAssumedRank() const {
   return Rank() == 1 && front().lbound().isAssumed();
 }
 
-std::ostream &operator<<(std::ostream &os, const ArraySpec &arraySpec) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const ArraySpec &arraySpec) {
   char sep{'('};
   for (auto &shape : arraySpec) {
     os << sep << shape;
@@ -398,7 +399,8 @@ std::string ParamValue::AsFortran() const {
   case Category::Deferred: return ":";
   case Category::Explicit:
     if (expr_) {
-      std::stringstream ss;
+      std::string buf;
+      llvm::raw_string_ostream ss{buf};
       expr_->AsFortran(ss);
       return ss.str();
     } else {
@@ -407,7 +409,7 @@ std::string ParamValue::AsFortran() const {
   }
 }
 
-std::ostream &operator<<(std::ostream &o, const ParamValue &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const ParamValue &x) {
   return o << x.AsFortran();
 }
 
@@ -417,7 +419,8 @@ IntrinsicTypeSpec::IntrinsicTypeSpec(TypeCategory category, KindExpr &&kind)
 }
 
 static std::string KindAsFortran(const KindExpr &kind) {
-  std::stringstream ss;
+  std::string buf;
+  llvm::raw_string_ostream ss{buf};
   if (auto k{evaluate::ToInt64(kind)}) {
     ss << *k;  // emit unsuffixed kind code
   } else {
@@ -431,7 +434,8 @@ std::string IntrinsicTypeSpec::AsFortran() const {
       KindAsFortran(kind_) + ')';
 }
 
-std::ostream &operator<<(std::ostream &os, const IntrinsicTypeSpec &x) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const IntrinsicTypeSpec &x) {
   return os << x.AsFortran();
 }
 
@@ -439,7 +443,8 @@ std::string CharacterTypeSpec::AsFortran() const {
   return "CHARACTER(" + length_.AsFortran() + ',' + KindAsFortran(kind()) + ')';
 }
 
-std::ostream &operator<<(std::ostream &os, const CharacterTypeSpec &x) {
+llvm::raw_ostream &operator<<(
+    llvm::raw_ostream &os, const CharacterTypeSpec &x) {
   return os << x.AsFortran();
 }
 
@@ -494,7 +499,7 @@ std::string DeclTypeSpec::AsFortran() const {
   }
 }
 
-std::ostream &operator<<(std::ostream &o, const DeclTypeSpec &x) {
+llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const DeclTypeSpec &x) {
   return o << x.AsFortran();
 }
 
diff --git a/lib/Semantics/unparse-with-symbols.cpp b/lib/Semantics/unparse-with-symbols.cpp
index b4f89198b347..b8e5e8837b3d 100644
--- a/lib/Semantics/unparse-with-symbols.cpp
+++ b/lib/Semantics/unparse-with-symbols.cpp
@@ -11,8 +11,8 @@
 #include "flang/Parser/parse-tree.h"
 #include "flang/Parser/unparse.h"
 #include "flang/Semantics/symbol.h"
+#include "llvm/Support/raw_ostream.h"
 #include <map>
-#include <ostream>
 #include <set>
 
 namespace Fortran::semantics {
@@ -24,7 +24,7 @@ namespace Fortran::semantics {
 class SymbolDumpVisitor {
 public:
   // Write out symbols referenced at this statement.
-  void PrintSymbols(const parser::CharBlock &, std::ostream &, int);
+  void PrintSymbols(const parser::CharBlock &, llvm::raw_ostream &, int);
 
   template<typename T> bool Pre(const T &) { return true; }
   template<typename T> void Post(const T &) {}
@@ -51,11 +51,11 @@ class SymbolDumpVisitor {
   std::optional<SourceName> currStmt_;  // current statement we are processing
   std::multimap<const char *, const Symbol *> symbols_;  // location to symbol
   std::set<const Symbol *> symbolsDefined_;  // symbols that have been processed
-  void Indent(std::ostream &, int) const;
+  void Indent(llvm::raw_ostream &, int) const;
 };
 
 void SymbolDumpVisitor::PrintSymbols(
-    const parser::CharBlock &location, std::ostream &out, int indent) {
+    const parser::CharBlock &location, llvm::raw_ostream &out, int indent) {
   std::set<const Symbol *> done;  // prevent duplicates on this line
   auto range{symbols_.equal_range(location.begin())};
   for (auto it{range.first}; it != range.second; ++it) {
@@ -70,7 +70,7 @@ void SymbolDumpVisitor::PrintSymbols(
   }
 }
 
-void SymbolDumpVisitor::Indent(std::ostream &out, int indent) const {
+void SymbolDumpVisitor::Indent(llvm::raw_ostream &out, int indent) const {
   for (int i{0}; i < indent; ++i) {
     out << ' ';
   }
@@ -84,14 +84,13 @@ void SymbolDumpVisitor::Post(const parser::Name &name) {
   }
 }
 
-void UnparseWithSymbols(std::ostream &out, const parser::Program &program,
+void UnparseWithSymbols(llvm::raw_ostream &out, const parser::Program &program,
     parser::Encoding encoding) {
   SymbolDumpVisitor visitor;
   parser::Walk(program, visitor);
   parser::preStatementType preStatement{
-      [&](const parser::CharBlock &location, std::ostream &out, int indent) {
-        visitor.PrintSymbols(location, out, indent);
-      }};
+      [&](const parser::CharBlock &location, llvm::raw_ostream &out,
+          int indent) { visitor.PrintSymbols(location, out, indent); }};
   parser::Unparse(out, program, encoding, false, true, &preStatement);
 }
 }
diff --git a/tools/f18/dump.cpp b/tools/f18/dump.cpp
index 26f4d730f959..d04b8e094a23 100644
--- a/tools/f18/dump.cpp
+++ b/tools/f18/dump.cpp
@@ -8,26 +8,26 @@
 
 // This file defines Dump routines available for calling from the debugger.
 // Each is based on operator<< for that type. There are overloadings for
-// reference and pointer, and for dumping to a provided ostream or cerr.
+// reference and pointer, and for dumping to a provided raw_ostream or errs().
 
 #ifdef DEBUGF18
 
-#include <iostream>
+#include "llvm/Support/raw_ostream.h"
 
 #define DEFINE_DUMP(ns, name) \
   namespace ns { \
   class name; \
-  std::ostream &operator<<(std::ostream &, const name &); \
+  llvm::raw_ostream &operator<<(llvm::raw_ostream &, const name &); \
   } \
-  void Dump(std::ostream &os, const ns::name &x) { os << x << '\n'; } \
-  void Dump(std::ostream &os, const ns::name *x) { \
+  void Dump(llvm::raw_ostream &os, const ns::name &x) { os << x << '\n'; } \
+  void Dump(llvm::raw_ostream &os, const ns::name *x) { \
     if (x == nullptr) \
       os << "null\n"; \
     else \
       Dump(os, *x); \
   } \
-  void Dump(const ns::name &x) { Dump(std::cerr, x); } \
-  void Dump(const ns::name *x) { Dump(std::cerr, *x); }
+  void Dump(const ns::name &x) { Dump(llvm::errs(), x); } \
+  void Dump(const ns::name *x) { Dump(llvm::errs(), *x); }
 
 namespace Fortran {
 DEFINE_DUMP(parser, Name)
diff --git a/tools/f18/f18-parse-demo.cpp b/tools/f18/f18-parse-demo.cpp
index 67bc45eb499a..ebb35615263d 100644
--- a/tools/f18/f18-parse-demo.cpp
+++ b/tools/f18/f18-parse-demo.cpp
@@ -31,11 +31,12 @@
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/unparse.h"
-#include <cerrno>
+#include "llvm/Support/Errno.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstdio>
 #include <cstring>
 #include <fstream>
-#include <iostream>
 #include <list>
 #include <memory>
 #include <optional>
@@ -112,14 +113,14 @@ bool ParentProcess() {
 void Exec(std::vector<char *> &argv, bool verbose = false) {
   if (verbose) {
     for (size_t j{0}; j < argv.size(); ++j) {
-      std::cerr << (j > 0 ? " " : "") << argv[j];
+      llvm::errs() << (j > 0 ? " " : "") << argv[j];
     }
-    std::cerr << '\n';
+    llvm::errs() << '\n';
   }
   argv.push_back(nullptr);
   execvp(argv[0], &argv[0]);
-  std::cerr << "execvp(" << argv[0] << ") failed: " << std::strerror(errno)
-            << '\n';
+  llvm::errs() << "execvp(" << argv[0]
+               << ") failed: " << llvm::sys::StrError(errno) << '\n';
   exit(EXIT_FAILURE);
 }
 
@@ -173,52 +174,52 @@ std::string CompileFortran(
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
-    std::cerr << driver.prefix << "could not scan " << path << '\n';
-    parsing.messages().Emit(std::cerr, parsing.cooked());
+    llvm::errs() << driver.prefix << "could not scan " << path << '\n';
+    parsing.messages().Emit(llvm::errs(), parsing.cooked());
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if (driver.dumpProvenance) {
-    parsing.DumpProvenance(std::cout);
+    parsing.DumpProvenance(llvm::outs());
     return {};
   }
   if (driver.dumpCookedChars) {
-    parsing.DumpCookedChars(std::cout);
+    parsing.DumpCookedChars(llvm::outs());
     return {};
   }
-  parsing.Parse(&std::cout);
+  parsing.Parse(llvm::outs());
   auto stop{CPUseconds()};
   if (driver.timeParse) {
     if (canTime) {
-      std::cout << "parse time for " << path << ": " << (stop - start)
-                << " CPU seconds\n";
+      llvm::outs() << "parse time for " << path << ": " << (stop - start)
+                   << " CPU seconds\n";
     } else {
-      std::cout << "no timing information due to lack of clock_gettime()\n";
+      llvm::outs() << "no timing information due to lack of clock_gettime()\n";
     }
   }
 
   parsing.ClearLog();
-  parsing.messages().Emit(std::cerr, parsing.cooked());
+  parsing.messages().Emit(llvm::errs(), parsing.cooked());
   if (!parsing.consumedWholeFile()) {
-    parsing.EmitMessage(
-        std::cerr, parsing.finalRestingPlace(), "parser FAIL (final position)");
+    parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
+        "parser FAIL (final position)");
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if ((!parsing.messages().empty() &&
           (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
       !parsing.parseTree()) {
-    std::cerr << driver.prefix << "could not parse " << path << '\n';
+    llvm::errs() << driver.prefix << "could not parse " << path << '\n';
     exitStatus = EXIT_FAILURE;
     return {};
   }
   auto &parseTree{*parsing.parseTree()};
   if (driver.dumpParseTree) {
-    Fortran::parser::DumpTree(std::cout, parseTree);
+    Fortran::parser::DumpTree(llvm::outs(), parseTree);
     return {};
   }
   if (driver.dumpUnparse) {
-    Unparse(std::cout, parseTree, driver.encoding, true /*capitalize*/,
+    Unparse(llvm::outs(), parseTree, driver.encoding, true /*capitalize*/,
         options.features.IsEnabled(
             Fortran::common::LanguageFeature::BackslashEscapes));
     return {};
@@ -233,8 +234,12 @@ std::string CompileFortran(
   std::snprintf(tmpSourcePath, sizeof tmpSourcePath, "/tmp/f18-%lx.f90",
       static_cast<unsigned long>(getpid()));
   {
-    std::ofstream tmpSource;
-    tmpSource.open(tmpSourcePath);
+    std::error_code EC;
+    llvm::raw_fd_ostream tmpSource(tmpSourcePath, EC, llvm::sys::fs::F_None);
+    if (EC) {
+      llvm::errs() << EC.message();
+      std::exit(EXIT_FAILURE);
+    }
     Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/,
         options.features.IsEnabled(
             Fortran::common::LanguageFeature::BackslashEscapes));
@@ -402,7 +407,7 @@ int main(int argc, char *const argv[]) {
     } else if (arg == "-i8" || arg == "-fdefault-integer-8") {
       defaultKinds.set_defaultIntegerKind(8);
     } else if (arg == "-help" || arg == "--help" || arg == "-?") {
-      std::cerr
+      llvm::errs()
           << "f18-parse-demo options:\n"
           << "  -Mfixed | -Mfree     force the source form\n"
           << "  -Mextend             132-column fixed form\n"
@@ -425,7 +430,7 @@ int main(int argc, char *const argv[]) {
           << "Other options are passed through to the $F18_FC compiler.\n";
       return exitStatus;
     } else if (arg == "-V") {
-      std::cerr << "\nf18-parse-demo\n";
+      llvm::errs() << "\nf18-parse-demo\n";
       return exitStatus;
     } else {
       driver.fcArgs.push_back(arg);
diff --git a/tools/f18/f18.cpp b/tools/f18/f18.cpp
index edcd0ef66b2a..51d3aec3d118 100644
--- a/tools/f18/f18.cpp
+++ b/tools/f18/f18.cpp
@@ -23,12 +23,12 @@
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/unparse-with-symbols.h"
+#include "llvm/Support/Errno.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
-#include <cerrno>
 #include <cstdio>
 #include <cstring>
 #include <fstream>
-#include <iostream>
 #include <list>
 #include <memory>
 #include <optional>
@@ -58,8 +58,9 @@ struct MeasurementVisitor {
 void MeasureParseTree(const Fortran::parser::Program &program) {
   MeasurementVisitor visitor;
   Fortran::parser::Walk(program, visitor);
-  std::cout << "Parse tree comprises " << visitor.objects
-            << " objects and occupies " << visitor.bytes << " total bytes.\n";
+  llvm::outs() << "Parse tree comprises " << visitor.objects
+               << " objects and occupies " << visitor.bytes
+               << " total bytes.\n";
 }
 
 std::vector<std::string> filesToDelete;
@@ -123,14 +124,14 @@ bool ParentProcess() {
 void Exec(std::vector<char *> &argv, bool verbose = false) {
   if (verbose) {
     for (size_t j{0}; j < argv.size(); ++j) {
-      std::cerr << (j > 0 ? " " : "") << argv[j];
+      llvm::errs() << (j > 0 ? " " : "") << argv[j];
     }
-    std::cerr << '\n';
+    llvm::errs() << '\n';
   }
   argv.push_back(nullptr);
   execvp(argv[0], &argv[0]);
-  std::cerr << "execvp(" << argv[0] << ") failed: " << std::strerror(errno)
-            << '\n';
+  llvm::errs() << "execvp(" << argv[0]
+               << ") failed: " << llvm::sys::StrError(errno) << '\n';
   exit(EXIT_FAILURE);
 }
 
@@ -168,21 +169,22 @@ std::string RelocatableName(const DriverOptions &driver, std::string path) {
 int exitStatus{EXIT_SUCCESS};
 
 static Fortran::parser::AnalyzedObjectsAsFortran asFortran{
-    [](std::ostream &o, const Fortran::evaluate::GenericExprWrapper &x) {
+    [](llvm::raw_ostream &o, const Fortran::evaluate::GenericExprWrapper &x) {
       if (x.v) {
         x.v->AsFortran(o);
       } else {
         o << "(bad expression)";
       }
     },
-    [](std::ostream &o, const Fortran::evaluate::GenericAssignmentWrapper &x) {
+    [](llvm::raw_ostream &o,
+        const Fortran::evaluate::GenericAssignmentWrapper &x) {
       if (x.v) {
         x.v->AsFortran(o);
       } else {
         o << "(bad assignment)";
       }
     },
-    [](std::ostream &o, const Fortran::evaluate::ProcedureRef &x) {
+    [](llvm::raw_ostream &o, const Fortran::evaluate::ProcedureRef &x) {
       x.AsFortran(o << "CALL ");
     },
 };
@@ -211,37 +213,37 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
-    std::cerr << driver.prefix << "could not scan " << path << '\n';
-    parsing.messages().Emit(std::cerr, parsing.cooked());
+    llvm::errs() << driver.prefix << "could not scan " << path << '\n';
+    parsing.messages().Emit(llvm::errs(), parsing.cooked());
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if (driver.dumpProvenance) {
-    parsing.DumpProvenance(std::cout);
+    parsing.DumpProvenance(llvm::outs());
     return {};
   }
   if (driver.dumpCookedChars) {
-    parsing.messages().Emit(std::cerr, parsing.cooked());
-    parsing.DumpCookedChars(std::cout);
+    parsing.messages().Emit(llvm::errs(), parsing.cooked());
+    parsing.DumpCookedChars(llvm::outs());
     return {};
   }
-  parsing.Parse(&std::cout);
+  parsing.Parse(llvm::outs());
   if (options.instrumentedParse) {
-    parsing.DumpParsingLog(std::cout);
+    parsing.DumpParsingLog(llvm::outs());
     return {};
   }
   parsing.ClearLog();
-  parsing.messages().Emit(std::cerr, parsing.cooked());
+  parsing.messages().Emit(llvm::errs(), parsing.cooked());
   if (!parsing.consumedWholeFile()) {
-    parsing.EmitMessage(
-        std::cerr, parsing.finalRestingPlace(), "parser FAIL (final position)");
+    parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
+        "parser FAIL (final position)");
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if ((!parsing.messages().empty() &&
           (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
       !parsing.parseTree()) {
-    std::cerr << driver.prefix << "could not parse " << path << '\n';
+    llvm::errs() << driver.prefix << "could not parse " << path << '\n';
     exitStatus = EXIT_FAILURE;
     return {};
   }
@@ -255,25 +257,25 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
     Fortran::semantics::Semantics semantics{semanticsContext, parseTree,
         parsing.cooked(), driver.debugModuleWriter};
     semantics.Perform();
-    semantics.EmitMessages(std::cerr);
+    semantics.EmitMessages(llvm::errs());
     if (driver.dumpSymbols) {
-      semantics.DumpSymbols(std::cout);
+      semantics.DumpSymbols(llvm::outs());
     }
     if (semantics.AnyFatalError()) {
-      std::cerr << driver.prefix << "semantic errors in " << path << '\n';
+      llvm::errs() << driver.prefix << "semantic errors in " << path << '\n';
       exitStatus = EXIT_FAILURE;
       if (driver.dumpParseTree) {
-        Fortran::parser::DumpTree(std::cout, parseTree, &asFortran);
+        Fortran::parser::DumpTree(llvm::outs(), parseTree, &asFortran);
       }
       return {};
     }
     if (driver.dumpUnparseWithSymbols) {
       Fortran::semantics::UnparseWithSymbols(
-          std::cout, parseTree, driver.encoding);
+          llvm::outs(), parseTree, driver.encoding);
       return {};
     }
     if (driver.getSymbolsSources) {
-      semantics.DumpSymbolsSources(std::cout);
+      semantics.DumpSymbolsSources(llvm::outs());
       return {};
     }
     if (driver.getDefinition) {
@@ -281,32 +283,32 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
               driver.getDefinitionArgs.line,
               driver.getDefinitionArgs.startColumn,
               driver.getDefinitionArgs.endColumn)}) {
-        std::cerr << "String range: >" << cb->ToString() << "<\n";
+        llvm::errs() << "String range: >" << cb->ToString() << "<\n";
         if (auto symbol{semanticsContext.FindScope(*cb).FindSymbol(*cb)}) {
-          std::cerr << "Found symbol name: " << symbol->name().ToString()
-                    << "\n";
+          llvm::errs() << "Found symbol name: " << symbol->name().ToString()
+                       << "\n";
           if (auto sourceInfo{
                   parsing.cooked().GetSourcePositionRange(symbol->name())}) {
-            std::cout << symbol->name().ToString() << ": "
-                      << sourceInfo->first.file.path() << ", "
-                      << sourceInfo->first.line << ", "
-                      << sourceInfo->first.column << "-"
-                      << sourceInfo->second.column << "\n";
+            llvm::outs() << symbol->name().ToString() << ": "
+                         << sourceInfo->first.file.path() << ", "
+                         << sourceInfo->first.line << ", "
+                         << sourceInfo->first.column << "-"
+                         << sourceInfo->second.column << "\n";
             exitStatus = EXIT_SUCCESS;
             return {};
           }
         }
       }
-      std::cerr << "Symbol not found.\n";
+      llvm::errs() << "Symbol not found.\n";
       exitStatus = EXIT_FAILURE;
       return {};
     }
   }
   if (driver.dumpParseTree) {
-    Fortran::parser::DumpTree(std::cout, parseTree, &asFortran);
+    Fortran::parser::DumpTree(llvm::outs(), parseTree, &asFortran);
   }
   if (driver.dumpUnparse) {
-    Unparse(std::cout, parseTree, driver.encoding, true /*capitalize*/,
+    Unparse(llvm::outs(), parseTree, driver.encoding, true /*capitalize*/,
         options.features.IsEnabled(
             Fortran::common::LanguageFeature::BackslashEscapes),
         nullptr /* action before each statement */, &asFortran);
@@ -317,7 +319,7 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
       Fortran::lower::annotateControl(*ast);
       Fortran::lower::dumpPFT(llvm::outs(), *ast);
     } else {
-      std::cerr << "Pre FIR Tree is NULL.\n";
+      llvm::errs() << "Pre FIR Tree is NULL.\n";
       exitStatus = EXIT_FAILURE;
     }
   }
@@ -331,8 +333,12 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   std::snprintf(tmpSourcePath, sizeof tmpSourcePath, "/tmp/f18-%lx.f90",
       static_cast<unsigned long>(getpid()));
   {
-    std::ofstream tmpSource;
-    tmpSource.open(tmpSourcePath);
+    std::error_code EC;
+    llvm::raw_fd_ostream tmpSource(tmpSourcePath, EC, llvm::sys::fs::F_None);
+    if (EC) {
+      llvm::errs() << EC.message() << "\n";
+      std::exit(EXIT_FAILURE);
+    }
     Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/,
         options.features.IsEnabled(
             Fortran::common::LanguageFeature::BackslashEscapes),
@@ -558,13 +564,13 @@ int main(int argc, char *const argv[]) {
       int arguments[3];
       for (int i = 0; i < 3; i++) {
         if (args.empty()) {
-          std::cerr << "Must provide 3 arguments for -fget-definitions.\n";
+          llvm::errs() << "Must provide 3 arguments for -fget-definitions.\n";
           return EXIT_FAILURE;
         }
         arguments[i] = std::strtol(args.front().c_str(), &endptr, 10);
         if (*endptr != '\0') {
-          std::cerr << "Invalid argument to -fget-definitions: " << args.front()
-                    << '\n';
+          llvm::errs() << "Invalid argument to -fget-definitions: "
+                       << args.front() << '\n';
           return EXIT_FAILURE;
         }
         args.pop_front();
@@ -573,7 +579,7 @@ int main(int argc, char *const argv[]) {
     } else if (arg == "-fget-symbols-sources") {
       driver.getSymbolsSources = true;
     } else if (arg == "-help" || arg == "--help" || arg == "-?") {
-      std::cerr
+      llvm::errs()
           << "f18 options:\n"
           << "  -Mfixed | -Mfree     force the source form\n"
           << "  -Mextend             132-column fixed form\n"
@@ -608,7 +614,7 @@ int main(int argc, char *const argv[]) {
           << "Other options are passed through to the compiler.\n";
       return exitStatus;
     } else if (arg == "-V") {
-      std::cerr << "\nf18 compiler (under development)\n";
+      llvm::errs() << "\nf18 compiler (under development)\n";
       return exitStatus;
     } else {
       driver.pgf90Args.push_back(arg);
diff --git a/unittests/Decimal/CMakeLists.txt b/unittests/Decimal/CMakeLists.txt
index 46a3d1fd44bf..780c92e74475 100644
--- a/unittests/Decimal/CMakeLists.txt
+++ b/unittests/Decimal/CMakeLists.txt
@@ -12,6 +12,7 @@ add_executable(quick-sanity-test
 
 target_link_libraries(quick-sanity-test
   FortranDecimal
+  LLVMSupport
 )
 
 add_executable(thorough-test
@@ -20,6 +21,7 @@ add_executable(thorough-test
 
 target_link_libraries(thorough-test
   FortranDecimal
+  LLVMSupport
 )
 
 add_test(Sanity quick-sanity-test)
diff --git a/unittests/Decimal/quick-sanity-test.cpp b/unittests/Decimal/quick-sanity-test.cpp
index 47089499d4b5..476d2c64bafc 100644
--- a/unittests/Decimal/quick-sanity-test.cpp
+++ b/unittests/Decimal/quick-sanity-test.cpp
@@ -1,8 +1,8 @@
 #include "flang/Decimal/decimal.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
-#include <iostream>
 
 using namespace Fortran::decimal;
 
@@ -14,11 +14,12 @@ union u {
   std::uint32_t u;
 };
 
-std::ostream &failed(float x) {
+llvm::raw_ostream &failed(float x) {
   ++fails;
   union u u;
   u.x = x;
-  return std::cout << "FAIL: 0x" << std::hex << u.u << std::dec;
+  llvm::outs() << "FAIL: 0x";
+  return llvm::outs().write_hex(u.u);
 }
 
 void testDirect(float x, const char *expect, int expectExpo, int flags = 0) {
@@ -60,15 +61,13 @@ void testReadback(float x, int flags) {
     if (!(x == x)) {
       if (y == y || *p != '\0' || (rflags & Invalid)) {
         u.x = y;
-        failed(x) << " (NaN) " << flags << ": -> '" << result.str << "' -> 0x"
-                  << std::hex << u.u << std::dec << " '" << p << "' " << rflags
-                  << '\n';
+        failed(x) << " (NaN) " << flags << ": -> '" << result.str << "' -> 0x";
+        failed(x).write_hex(u.u) << " '" << p << "' " << rflags << '\n';
       }
     } else if (x != y || *p != '\0' || (rflags & Invalid)) {
       u.x = y;
-      failed(x) << ' ' << flags << ": -> '" << result.str << "' -> 0x"
-                << std::hex << u.u << std::dec << " '" << p << "' " << rflags
-                << '\n';
+      failed(x) << ' ' << flags << ": -> '" << result.str << "' -> 0x";
+      failed(x).write_hex(u.u) << " '" << p << "' " << rflags << '\n';
     }
   }
 }
@@ -138,6 +137,6 @@ int main() {
     testReadback(u.x, Minimize);
     testReadback(-u.x, Minimize);
   }
-  std::cout << tests << " tests run, " << fails << " tests failed\n";
+  llvm::outs() << tests << " tests run, " << fails << " tests failed\n";
   return fails > 0;
 }
diff --git a/unittests/Decimal/thorough-test.cpp b/unittests/Decimal/thorough-test.cpp
index f10467d1300a..e7aeed01ec8e 100644
--- a/unittests/Decimal/thorough-test.cpp
+++ b/unittests/Decimal/thorough-test.cpp
@@ -1,8 +1,8 @@
 #include "flang/Decimal/decimal.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
-#include <iostream>
 
 static constexpr int incr{1};  // steps through all values
 static constexpr bool doNegative{true};
@@ -18,11 +18,12 @@ union u {
   std::uint32_t u;
 };
 
-std::ostream &failed(float x) {
+llvm::raw_ostream &failed(float x) {
   ++fails;
   union u u;
   u.x = x;
-  return std::cout << "FAIL: 0x" << std::hex << u.u << std::dec;
+  llvm::outs() << "FAIL: 0x";
+  return llvm::outs().write_hex(u.u);
 }
 
 void testReadback(float x, int flags) {
@@ -30,9 +31,10 @@ void testReadback(float x, int flags) {
   union u u;
   u.x = x;
   if (!(tests & 0x3fffff)) {
-    std::cerr << "\n0x" << std::hex << u.u << std::dec << ' ';
+    llvm::errs() << "\n0x";
+    llvm::errs().write_hex(u.u) << ' ';
   } else if (!(tests & 0xffff)) {
-    std::cerr << '.';
+    llvm::errs() << '.';
   }
   ++tests;
   auto result{ConvertFloatToDecimal(buffer, sizeof buffer,
@@ -56,15 +58,13 @@ void testReadback(float x, int flags) {
     if (!(x == x)) {
       if (y == y || *p != '\0' || (rflags & Invalid)) {
         u.x = y;
-        failed(x) << " (NaN) " << flags << ": -> '" << result.str << "' -> 0x"
-                  << std::hex << u.u << std::dec << " '" << p << "' " << rflags
-                  << '\n';
+        failed(x) << " (NaN) " << flags << ": -> '" << result.str << "' -> 0x";
+        failed(x).write_hex(u.u) << " '" << p << "' " << rflags << '\n';
       }
     } else if (x != y || *p != '\0' || (rflags & Invalid)) {
       u.x = y;
-      failed(x) << ' ' << flags << ": -> '" << result.str << "' -> 0x"
-                << std::hex << u.u << std::dec << " '" << p << "' " << rflags
-                << '\n';
+      failed(x) << ' ' << flags << ": -> '" << result.str << "' -> 0x";
+      failed(x).write_hex(u.u) << " '" << p << "' " << rflags << '\n';
     }
   }
 }
@@ -83,6 +83,6 @@ int main() {
       }
     }
   }
-  std::cout << '\n' << tests << " tests run, " << fails << " tests failed\n";
+  llvm::outs() << '\n' << tests << " tests run, " << fails << " tests failed\n";
   return fails > 0;
 }
diff --git a/unittests/Evaluate/CMakeLists.txt b/unittests/Evaluate/CMakeLists.txt
index d874fcb39dbc..fb195ae5730a 100644
--- a/unittests/Evaluate/CMakeLists.txt
+++ b/unittests/Evaluate/CMakeLists.txt
@@ -17,6 +17,7 @@ add_executable(leading-zero-bit-count-test
 
 target_link_libraries(leading-zero-bit-count-test
   FortranEvaluateTesting
+  LLVMSupport
 )
 
 add_executable(bit-population-count-test
@@ -25,6 +26,7 @@ add_executable(bit-population-count-test
 
 target_link_libraries(bit-population-count-test
   FortranEvaluateTesting
+  LLVMSupport
 )
 
 add_executable(uint128-test
@@ -33,6 +35,7 @@ add_executable(uint128-test
 
 target_link_libraries(uint128-test
   FortranEvaluateTesting
+  LLVMSupport
 )
 
 # These routines live in lib/Common but we test them here.
@@ -49,6 +52,7 @@ target_link_libraries(expression-test
   FortranEvaluate
   FortranSemantics
   FortranParser
+  LLVMSupport
 )
 
 add_executable(integer-test
@@ -59,6 +63,7 @@ target_link_libraries(integer-test
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
+  LLVMSupport
 )
 
 add_executable(intrinsics-test
@@ -72,6 +77,7 @@ target_link_libraries(intrinsics-test
   FortranSemantics
   FortranParser
   FortranRuntime
+  LLVMSupport
 )
 
 add_executable(logical-test
@@ -82,6 +88,7 @@ target_link_libraries(logical-test
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
+  LLVMSupport
 )
 
 # GCC -fno-exceptions breaks the fenv.h interfaces needed to capture
@@ -98,6 +105,7 @@ target_link_libraries(real-test
   FortranEvaluate
   FortranDecimal
   FortranSemantics
+  LLVMSupport
 )
 
 add_executable(reshape-test
@@ -109,6 +117,7 @@ target_link_libraries(reshape-test
   FortranSemantics
   FortranEvaluate
   FortranRuntime
+  LLVMSupport
 )
 
 add_executable(ISO-Fortran-binding-test
@@ -120,6 +129,7 @@ target_link_libraries(ISO-Fortran-binding-test
   FortranEvaluate
   FortranSemantics
   FortranRuntime
+  LLVMSupport
 )
 
 add_executable(folding-test
@@ -130,6 +140,7 @@ target_link_libraries(folding-test
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
+  LLVMSupport
 )
 
 add_test(Expression expression-test)
diff --git a/unittests/Evaluate/ISO-Fortran-binding.cpp b/unittests/Evaluate/ISO-Fortran-binding.cpp
index 7b6bc458baf6..1fff9d4d1998 100644
--- a/unittests/Evaluate/ISO-Fortran-binding.cpp
+++ b/unittests/Evaluate/ISO-Fortran-binding.cpp
@@ -1,10 +1,8 @@
 #include "testing.h"
 #include "../../include/flang/ISO_Fortran_binding.h"
 #include "../../runtime/descriptor.h"
+#include "llvm/Support/raw_ostream.h"
 #include <type_traits>
-#ifdef VERBOSE
-#include <iostream>
-#endif
 
 using namespace Fortran::runtime;
 using namespace Fortran::ISO;
@@ -71,13 +69,13 @@ static void AddNoiseToCdesc(CFI_cdesc_t *dv, CFI_rank_t rank) {
 static void DumpTestWorld(const void *bAddr, CFI_attribute_t attr,
     CFI_type_t ty, std::size_t eLen, CFI_rank_t rank,
     const CFI_index_t *eAddr) {
-  std::cout << " base_addr: " << std::hex
-            << reinterpret_cast<std::intptr_t>(bAddr)
-            << " attribute: " << static_cast<int>(attr) << std::dec
-            << " type: " << static_cast<int>(ty) << " elem_len: " << eLen
-            << " rank: " << static_cast<int>(rank) << " extent: " << std::hex
-            << reinterpret_cast<std::intptr_t>(eAddr) << std::endl
-            << std::dec;
+  llvm::outs() << " base_addr: ";
+  llvm::outs().write_hex(reinterpret_cast<std::intptr_t>(bAddr))
+      << " attribute: " << static_cast<int>(attr)
+      << " type: " << static_cast<int>(ty) << " elem_len: " << eLen
+      << " rank: " << static_cast<int>(rank) << " extent: ";
+  llvm::outs().write_hex(reinterpret_cast<std::intptr_t>(eAddr)) << '\n';
+  llvm::outs().flush();
 }
 #endif
 
diff --git a/unittests/Evaluate/fp-testing.cpp b/unittests/Evaluate/fp-testing.cpp
index a1893a8df894..fe235eca7924 100644
--- a/unittests/Evaluate/fp-testing.cpp
+++ b/unittests/Evaluate/fp-testing.cpp
@@ -1,4 +1,5 @@
 #include "fp-testing.h"
+#include "llvm/Support/Errno.h"
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -15,11 +16,13 @@ ScopedHostFloatingPointEnvironment::ScopedHostFloatingPointEnvironment(
 ) {
   errno = 0;
   if (feholdexcept(&originalFenv_) != 0) {
-    std::fprintf(stderr, "feholdexcept() failed: %s\n", std::strerror(errno));
+    std::fprintf(stderr, "feholdexcept() failed: %s\n",
+        llvm::sys::StrError(errno).c_str());
     std::abort();
   }
   if (fegetenv(&currentFenv_) != 0) {
-    std::fprintf(stderr, "fegetenv() failed: %s\n", std::strerror(errno));
+    std::fprintf(
+        stderr, "fegetenv() failed: %s\n", llvm::sys::StrError(errno).c_str());
     std::abort();
   }
 #if __x86_64__
@@ -38,7 +41,8 @@ ScopedHostFloatingPointEnvironment::ScopedHostFloatingPointEnvironment(
 #endif
   errno = 0;
   if (fesetenv(&currentFenv_) != 0) {
-    std::fprintf(stderr, "fesetenv() failed: %s\n", std::strerror(errno));
+    std::fprintf(
+        stderr, "fesetenv() failed: %s\n", llvm::sys::StrError(errno).c_str());
     std::abort();
   }
 }
@@ -46,7 +50,8 @@ ScopedHostFloatingPointEnvironment::ScopedHostFloatingPointEnvironment(
 ScopedHostFloatingPointEnvironment::~ScopedHostFloatingPointEnvironment() {
   errno = 0;
   if (fesetenv(&originalFenv_) != 0) {
-    std::fprintf(stderr, "fesetenv() failed: %s\n", std::strerror(errno));
+    std::fprintf(
+        stderr, "fesetenv() failed: %s\n", llvm::sys::StrError(errno).c_str());
     std::abort();
   }
 }
diff --git a/unittests/Evaluate/intrinsics.cpp b/unittests/Evaluate/intrinsics.cpp
index 7a4ca4753b4f..e2bf1cf18cb0 100644
--- a/unittests/Evaluate/intrinsics.cpp
+++ b/unittests/Evaluate/intrinsics.cpp
@@ -4,8 +4,8 @@
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Parser/provenance.h"
+#include "llvm/Support/raw_ostream.h"
 #include <initializer_list>
-#include <iostream>
 #include <map>
 #include <string>
 
@@ -31,7 +31,7 @@ class CookedStrings {
   parser::ContextualMessages Messages(parser::Messages &buffer) {
     return parser::ContextualMessages{cooked_.data(), &buffer};
   }
-  void Emit(std::ostream &o, const parser::Messages &messages) {
+  void Emit(llvm::raw_ostream &o, const parser::Messages &messages) {
     messages.Emit(o, cooked_);
   }
 
@@ -88,17 +88,18 @@ struct TestCall {
       int rank = 0, bool isElemental = false) {
     Marshal();
     parser::CharBlock fName{strings(name)};
-    std::cout << "function: " << fName.ToString();
+    llvm::outs() << "function: " << fName.ToString();
     char sep{'('};
     for (const auto &a : args) {
-      std::cout << sep;
+      llvm::outs() << sep;
       sep = ',';
-      a->AsFortran(std::cout);
+      a->AsFortran(llvm::outs());
     }
     if (sep == '(') {
-      std::cout << '(';
+      llvm::outs() << '(';
     }
-    std::cout << ')' << std::endl;
+    llvm::outs() << ')' << '\n';
+    llvm::outs().flush();
     CallCharacteristics call{fName.ToString()};
     auto messages{strings.Messages(buffer)};
     FoldingContext context{messages, defaults, table};
@@ -126,7 +127,7 @@ struct TestCall {
       TEST((messages.messages() && messages.messages()->AnyFatalError()) ||
           name == "bad");
     }
-    strings.Emit(std::cout, buffer);
+    strings.Emit(llvm::outs(), buffer);
   }
 
   const common::IntrinsicTypeDefaultKinds &defaults;
@@ -143,7 +144,7 @@ void TestIntrinsics() {
   MATCH(4, defaults.GetDefaultKind(TypeCategory::Integer));
   MATCH(4, defaults.GetDefaultKind(TypeCategory::Real));
   IntrinsicProcTable table{IntrinsicProcTable::Configure(defaults)};
-  table.Dump(std::cout);
+  table.Dump(llvm::outs());
 
   using Int1 = Type<TypeCategory::Integer, 1>;
   using Int4 = Type<TypeCategory::Integer, 4>;
diff --git a/unittests/Evaluate/real.cpp b/unittests/Evaluate/real.cpp
index 732a2de1bec2..90f9dcf408c2 100644
--- a/unittests/Evaluate/real.cpp
+++ b/unittests/Evaluate/real.cpp
@@ -1,10 +1,10 @@
 #include "fp-testing.h"
 #include "testing.h"
 #include "flang/Evaluate/type.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
-#include <sstream>
 #include <type_traits>
 
 using namespace Fortran::evaluate;
@@ -149,7 +149,8 @@ template<typename R> void basicTests(int rm, Rounding rounding) {
       TEST(ivf.flags.empty())(ldesc);
       MATCH(x, ivf.value.ToUInt64())(ldesc);
       if (rounding.mode == RoundingMode::TiesToEven) {  // to match stold()
-        std::stringstream ss;
+        std::string buf;
+        llvm::raw_string_ostream ss{buf};
         vr.value.AsFortran(ss, kind, false /*exact*/);
         std::string decimal{ss.str()};
         const char *p{decimal.data()};
@@ -398,7 +399,9 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       ("%d IsInfinite(0x%jx)", pass, static_cast<std::intmax_t>(rj));
 
       static constexpr int kind{REAL::bits / 8};
-      std::stringstream ss, css;
+      std::string ssBuf, cssBuf;
+      llvm::raw_string_ostream ss{ssBuf};
+      llvm::raw_string_ostream css{cssBuf};
       x.AsFortran(ss, kind, false /*exact*/);
       std::string s{ss.str()};
       if (IsNaN(rj)) {
diff --git a/unittests/Evaluate/testing.cpp b/unittests/Evaluate/testing.cpp
index 75380e51c592..9be31540ec7b 100644
--- a/unittests/Evaluate/testing.cpp
+++ b/unittests/Evaluate/testing.cpp
@@ -1,8 +1,8 @@
 #include "testing.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
-#include <iostream>
 
 namespace testing {
 
@@ -103,22 +103,22 @@ FailureDetailPrinter Compare(const char *file, int line, const char *xs,
 int Complete() {
   if (failures == 0) {
     if (passes == 1) {
-      std::cout << "single test PASSES\n";
+      llvm::outs() << "single test PASSES\n";
     } else {
-      std::cout << "all " << std::dec << passes << " tests PASS\n";
+      llvm::outs() << "all " << passes << " tests PASS\n";
     }
     passes = 0;
     return EXIT_SUCCESS;
   } else {
     if (passes == 1) {
-      std::cerr << "1 test passes, ";
+      llvm::errs() << "1 test passes, ";
     } else {
-      std::cerr << std::dec << passes << " tests pass, ";
+      llvm::errs() << passes << " tests pass, ";
     }
     if (failures == 1) {
-      std::cerr << "1 test FAILS\n";
+      llvm::errs() << "1 test FAILS\n";
     } else {
-      std::cerr << std::dec << failures << " tests FAIL\n";
+      llvm::errs() << failures << " tests FAIL\n";
     }
     passes = failures = 0;
     return EXIT_FAILURE;
diff --git a/unittests/Evaluate/uint128.cpp b/unittests/Evaluate/uint128.cpp
index 07efc31c5a39..f2ddcbf557eb 100644
--- a/unittests/Evaluate/uint128.cpp
+++ b/unittests/Evaluate/uint128.cpp
@@ -1,8 +1,8 @@
 #define AVOID_NATIVE_UINT128_T 1
 #include "flang/Common/uint128.h"
 #include "testing.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
-#include <iostream>
 
 #if (defined __GNUC__ || defined __clang__) && defined __SIZEOF_INT128__
 #define HAS_NATIVE_UINT128_T 1
@@ -123,10 +123,10 @@ int main() {
     }
   }
 #if HAS_NATIVE_UINT128_T
-  std::cout << "Environment has native __uint128_t\n";
+  llvm::outs() << "Environment has native __uint128_t\n";
   TestVsNative();
 #else
-  std::cout << "Environment lacks native __uint128_t\n";
+  llvm::outs() << "Environment lacks native __uint128_t\n";
 #endif
   return testing::Complete();
 }
diff --git a/unittests/Runtime/CMakeLists.txt b/unittests/Runtime/CMakeLists.txt
index 905e18e0cea2..3f73b79132f9 100644
--- a/unittests/Runtime/CMakeLists.txt
+++ b/unittests/Runtime/CMakeLists.txt
@@ -21,6 +21,7 @@ add_executable(format-test
 target_link_libraries(format-test
   FortranRuntime
   RuntimeTesting
+  LLVMSupport
 )
 
 add_test(Format format-test)
@@ -32,6 +33,7 @@ add_executable(hello-world
 target_link_libraries(hello-world
   FortranRuntime
   RuntimeTesting
+  LLVMSupport
 )
 
 add_test(HelloWorld hello-world)
@@ -42,6 +44,7 @@ add_executable(external-hello-world
 
 target_link_libraries(external-hello-world
   FortranRuntime
+  LLVMSupport
 )
 
 add_executable(list-input-test
@@ -51,6 +54,7 @@ add_executable(list-input-test
 target_link_libraries(list-input-test
   FortranRuntime
   RuntimeTesting
+  LLVMSupport
 )
 
 add_test(ListInput list-input-test)
diff --git a/unittests/Runtime/format.cpp b/unittests/Runtime/format.cpp
index b00f89c72c1f..c855523b427e 100644
--- a/unittests/Runtime/format.cpp
+++ b/unittests/Runtime/format.cpp
@@ -3,9 +3,9 @@
 #include "testing.h"
 #include "../runtime/format-implementation.h"
 #include "../runtime/io-error.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstdarg>
 #include <cstring>
-#include <iostream>
 #include <string>
 #include <vector>
 
@@ -93,13 +93,13 @@ void TestFormatContext::Check(Results &expect) {
   if (expect != results) {
     Fail() << "expected:";
     for (const std::string &s : expect) {
-      std::cerr << ' ' << s;
+      llvm::errs() << ' ' << s;
     }
-    std::cerr << "\ngot:";
+    llvm::errs() << "\ngot:";
     for (const std::string &s : results) {
-      std::cerr << ' ' << s;
+      llvm::errs() << ' ' << s;
     }
-    std::cerr << '\n';
+    llvm::errs() << '\n';
   }
   expect.clear();
   results.clear();
diff --git a/unittests/Runtime/hello.cpp b/unittests/Runtime/hello.cpp
index 88628cecf1ed..cc2d1205a751 100644
--- a/unittests/Runtime/hello.cpp
+++ b/unittests/Runtime/hello.cpp
@@ -3,8 +3,8 @@
 #include "testing.h"
 #include "../../runtime/descriptor.h"
 #include "../../runtime/io-api.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstring>
-#include <iostream>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
@@ -110,8 +110,8 @@ static void realInTest(
     Fail() << '\'' << format << "' failed reading '" << data << "', status "
            << static_cast<int>(status) << " iomsg '" << iomsg << "'\n";
   } else if (u.raw != want) {
-    Fail() << '\'' << format << "' failed reading '" << data << "', want 0x"
-           << std::hex << want << ", got 0x" << u.raw << std::dec << '\n';
+    Fail() << '\'' << format << "' failed reading '" << data << "', want 0x";
+    Fail().write_hex(want) << ", got 0x" << u.raw << '\n';
   }
 }
 
diff --git a/unittests/Runtime/list-input.cpp b/unittests/Runtime/list-input.cpp
index cb9021e59509..9f6377656f91 100644
--- a/unittests/Runtime/list-input.cpp
+++ b/unittests/Runtime/list-input.cpp
@@ -4,9 +4,9 @@
 #include "../../runtime/descriptor.h"
 #include "../../runtime/io-api.h"
 #include "../../runtime/io-error.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
-#include <iostream>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
diff --git a/unittests/Runtime/testing.cpp b/unittests/Runtime/testing.cpp
index 50ee686884cf..8a31f23e9ef5 100644
--- a/unittests/Runtime/testing.cpp
+++ b/unittests/Runtime/testing.cpp
@@ -1,10 +1,10 @@
 #include "testing.h"
 #include "../../runtime/terminator.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
-#include <iostream>
 #include <string>
 
 static int failures{0};
@@ -21,16 +21,16 @@ void StartTests() {
   Fortran::runtime::Terminator::RegisterCrashHandler(CatchCrash);
 }
 
-std::ostream &Fail() {
+llvm::raw_ostream &Fail() {
   ++failures;
-  return std::cerr;
+  return llvm::errs();
 }
 
 int EndTests() {
   if (failures == 0) {
-    std::cout << "PASS\n";
+    llvm::outs() << "PASS\n";
   } else {
-    std::cout << "FAIL " << failures << " tests\n";
+    llvm::outs() << "FAIL " << failures << " tests\n";
   }
   return failures != 0;
 }
diff --git a/unittests/Runtime/testing.h b/unittests/Runtime/testing.h
index 9571a34825dc..4bc2b9148a0a 100644
--- a/unittests/Runtime/testing.h
+++ b/unittests/Runtime/testing.h
@@ -4,8 +4,12 @@
 #include <cstddef>
 #include <iosfwd>
 
+namespace llvm {
+ class raw_ostream;
+}
+
 void StartTests();
-std::ostream &Fail();
+llvm::raw_ostream &Fail();
 int EndTests();
 
 void SetCharacter(char *, std::size_t, const char *);

From 02531d788e7550a2455633f87d22e3f30de7a3a7 Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Wed, 18 Mar 2020 16:02:53 +0000
Subject: [PATCH 097/345] Remove non-alignment based divergences from LLVM
 formatting.

This only changs the clang-format file and adds documentation
referring to the new process for formatting code. A future commit
will perform a reformatting according to these new formatting
settings.
---
 .clang-format                         | 6 ------
 documentation/C++style.md             | 6 +++---
 documentation/PullRequestChecklist.md | 2 +-
 3 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/.clang-format b/.clang-format
index 21fb1ae51ac5..c1dfe06fdf57 100644
--- a/.clang-format
+++ b/.clang-format
@@ -3,16 +3,10 @@
 BasedOnStyle: LLVM
 AlignAfterOpenBracket: DontAlign
 AlignEscapedNewlines: DontAlign
-AllowShortCaseLabelsOnASingleLine: true
-AllowShortIfStatementsOnASingleLine: true
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 AlignOperands: false
 AlignTrailingComments: false
-ConstructorInitializerIndentWidth: 2
-SpaceAfterTemplateKeyword: false
-SpacesBeforeTrailingComments: 2
-FixNamespaceComments: false
 IncludeCategories:
   - Regex:           '^<'
     Priority:        4
diff --git a/documentation/C++style.md b/documentation/C++style.md
index f8e58968f330..ca532463ae83 100644
--- a/documentation/C++style.md
+++ b/documentation/C++style.md
@@ -88,9 +88,9 @@ well as you do and avoid distracting her by calling out usage of new
 features in comments.
 
 ### Layout
-Always run `clang-format` before committing code.  Other developers should
-be able to run `git pull`, then `clang-format`, and see only their own
-changes. Use `clang-format` from llvm 7.
+Always run `clang-format` on your changes before committing code. LLVM
+has a `git-clang-format` script to facilitate running clang-format only
+on the lines that have changed.
 
 Here's what you can expect to see `clang-format` do:
 1. Indent with two spaces.
diff --git a/documentation/PullRequestChecklist.md b/documentation/PullRequestChecklist.md
index 1097bd1f9b42..9a43fa9b46e0 100644
--- a/documentation/PullRequestChecklist.md
+++ b/documentation/PullRequestChecklist.md
@@ -31,7 +31,7 @@ can also be used when reviewing pull requests.
 ## Follow the style guide
 The following items are taken from the [C++ style guide](C++style.md).  But
 even though I've read the style guide, they regularly trip me up.
-*  Run clang-format version 7 on all .cpp and .h files.
+*  Run clang-format using the git-clang-format script from LLVM HEAD.
 *  Make sure that all source lines have 80 or fewer characters.  Note that
    clang-format will do this for most code.  But you may need to break up long
    strings.

From d34df8435127d847867e2c0bb157def9f20f4202 Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Thu, 27 Feb 2020 13:42:56 +0000
Subject: [PATCH 098/345] Replace manual mmap with llvm::MemoryBuffer

The previous code had handling for cases when too many file descriptors may be
opened; this is not necessary with MemoryBuffer as the file descriptors are
closed after the mapping occurs. MemoryBuffer also internally handles the case
where a file is small and therefore an mmap is bad for performance; such files
are simply copied to memory after being opened.

Many places elsewhere in the code assume that the buffer is not empty, and the
old file opening code handles this by replacing an empty file with a buffer
containing a single newline. That behavior is now kept in the new MemoryBuffer
based code.
---
 include/flang/Parser/source.h |  19 ++-
 lib/Parser/prescan.cpp        |   2 +-
 lib/Parser/provenance.cpp     |   2 +-
 lib/Parser/source.cpp         | 214 ++++++++--------------------------
 lib/Semantics/mod-file.cpp    |   6 +-
 test/Semantics/empty.f90      |   4 +
 6 files changed, 66 insertions(+), 181 deletions(-)
 create mode 100644 test/Semantics/empty.f90

diff --git a/include/flang/Parser/source.h b/include/flang/Parser/source.h
index cc7dc9219a88..4c5be0f62c0c 100644
--- a/include/flang/Parser/source.h
+++ b/include/flang/Parser/source.h
@@ -19,6 +19,7 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include "llvm/Support/MemoryBuffer.h"
 
 namespace llvm {
 class raw_ostream;
@@ -42,8 +43,8 @@ class SourceFile {
   explicit SourceFile(Encoding e) : encoding_{e} {}
   ~SourceFile();
   std::string path() const { return path_; }
-  const char *content() const { return content_; }
-  std::size_t bytes() const { return bytes_; }
+  llvm::ArrayRef<char> content() const { return buf_->getBuffer().slice(bom_end_, buf_end_ - bom_end_); }
+  std::size_t bytes() const { return content().size(); }
   std::size_t lines() const { return lineStart_.size(); }
   Encoding encoding() const { return encoding_; }
 
@@ -56,20 +57,16 @@ class SourceFile {
   }
 
 private:
-  bool ReadFile(std::string errorPath, llvm::raw_ostream &error);
+  void ReadFile();
   void IdentifyPayload();
   void RecordLineStarts();
 
   std::string path_;
-  int fileDescriptor_{-1};
-  bool isMemoryMapped_{false};
-  const char *address_{nullptr};  // raw content
-  std::size_t size_{0};
-  const char *content_{nullptr};  // usable content
-  std::size_t bytes_{0};
+  std::unique_ptr<llvm::WritableMemoryBuffer> buf_;
   std::vector<std::size_t> lineStart_;
-  std::string normalized_;
-  Encoding encoding_{Encoding::UTF_8};
+  std::size_t bom_end_ {0};
+  std::size_t buf_end_;
+  Encoding encoding_;
 };
 }
 #endif  // FORTRAN_PARSER_SOURCE_H_
diff --git a/lib/Parser/prescan.cpp b/lib/Parser/prescan.cpp
index 67d5cdfbfb1d..1648a0297603 100644
--- a/lib/Parser/prescan.cpp
+++ b/lib/Parser/prescan.cpp
@@ -63,7 +63,7 @@ void Prescanner::Prescan(ProvenanceRange range) {
   std::size_t offset{0};
   const SourceFile *source{allSources.GetSourceFile(startProvenance_, &offset)};
   CHECK(source);
-  start_ = source->content() + offset;
+  start_ = source->content().data() + offset;
   limit_ = start_ + range.size();
   nextLine_ = start_;
   const bool beganInFixedForm{inFixedForm_};
diff --git a/lib/Parser/provenance.cpp b/lib/Parser/provenance.cpp
index fb43496b53ef..1a2a77cd1daf 100644
--- a/lib/Parser/provenance.cpp
+++ b/lib/Parser/provenance.cpp
@@ -228,7 +228,7 @@ void AllSources::EmitMessage(llvm::raw_ostream &o,
             o << ':' << pos.line << ':' << pos.column;
             o << ": " << message << '\n';
             if (echoSourceLine) {
-              const char *text{inc.source.content() +
+              const char *text{inc.source.content().data() +
                   inc.source.GetLineStartOffset(pos.line)};
               o << "  ";
               for (const char *p{text}; *p != '\n'; ++p) {
diff --git a/lib/Parser/source.cpp b/lib/Parser/source.cpp
index 4f8a08aa5271..6b1a9df3b731 100644
--- a/lib/Parser/source.cpp
+++ b/lib/Parser/source.cpp
@@ -10,64 +10,42 @@
 #include "flang/Common/idioms.h"
 #include "flang/Parser/char-buffer.h"
 #include "llvm/Support/Errno.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cstddef>
-#include <cstring>
-#include <fcntl.h>
 #include <memory>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 #include <vector>
 
-// TODO: Port to Windows &c.
-
 namespace Fortran::parser {
 
-static constexpr bool useMMap{true};
-static constexpr int minMapFileBytes{1};  // i.e., no minimum requirement
-static constexpr int maxMapOpenFileDescriptors{100};
-static int openFileDescriptors{0};
-
 SourceFile::~SourceFile() { Close(); }
 
-static std::vector<std::size_t> FindLineStarts(
-    const char *source, std::size_t bytes) {
+static std::vector<std::size_t> FindLineStarts(llvm::StringRef source) {
   std::vector<std::size_t> result;
-  if (bytes > 0) {
-    CHECK(source[bytes - 1] == '\n' && "missing ultimate newline");
+  if (source.size() > 0) {
+    CHECK(source.back() == '\n' && "missing ultimate newline");
     std::size_t at{0};
     do {
       result.push_back(at);
-      const void *vp{static_cast<const void *>(&source[at])};
-      const void *vnl{std::memchr(vp, '\n', bytes - at)};
-      const char *nl{static_cast<const char *>(vnl)};
-      at = nl + 1 - source;
-    } while (at < bytes);
+      at = source.find('\n', at) + 1;
+    } while (at < source.size());
     result.shrink_to_fit();
   }
   return result;
 }
 
 void SourceFile::RecordLineStarts() {
-  lineStart_ = FindLineStarts(content_, bytes_);
+  lineStart_ = FindLineStarts({content().data(), bytes()});
 }
 
 // Check for a Unicode byte order mark (BOM).
 // Module files all have one; so can source files.
 void SourceFile::IdentifyPayload() {
-  content_ = address_;
-  bytes_ = size_;
-  if (content_) {
-    static constexpr int BOMBytes{3};
-    static const char UTF8_BOM[]{"\xef\xbb\xbf"};
-    if (bytes_ >= BOMBytes && std::memcmp(content_, UTF8_BOM, BOMBytes) == 0) {
-      content_ += BOMBytes;
-      bytes_ -= BOMBytes;
-      encoding_ = Encoding::UTF_8;
-    }
+  llvm::StringRef content{buf_->getBufferStart(), buf_->getBufferSize()};
+  constexpr llvm::StringLiteral UTF8_BOM{"\xef\xbb\xbf"};
+  if (content.startswith(UTF8_BOM)) {
+    bom_end_ = UTF8_BOM.size();
+    encoding_ = Encoding::UTF_8;
   }
 }
 
@@ -83,17 +61,20 @@ std::string LocateSourceFile(
   }
   for (const std::string &dir : searchPath) {
     std::string path{dir + '/' + name};
-    struct stat statbuf;
-    if (stat(path.c_str(), &statbuf) == 0 && !S_ISDIR(statbuf.st_mode)) {
+    bool isDir{false};
+    auto er = llvm::sys::fs::is_directory(path, isDir);
+    if (!er && !isDir) {
       return path;
     }
   }
   return name;
 }
 
-static std::size_t RemoveCarriageReturns(char *buffer, std::size_t bytes) {
+std::size_t RemoveCarriageReturns(llvm::MutableArrayRef<char> buf) {
   std::size_t wrote{0};
-  char *p{buffer};
+  char *buffer{buf.data()};
+  char *p{buf.data()};
+  std::size_t bytes = buf.size();
   while (bytes > 0) {
     void *vp{static_cast<void *>(p)};
     void *crvp{std::memchr(vp, '\r', bytes)};
@@ -115,154 +96,57 @@ static std::size_t RemoveCarriageReturns(char *buffer, std::size_t bytes) {
 bool SourceFile::Open(std::string path, llvm::raw_ostream &error) {
   Close();
   path_ = path;
-  std::string errorPath{"'"s + path + "'"};
-  errno = 0;
-  fileDescriptor_ = open(path.c_str(), O_RDONLY);
-  if (fileDescriptor_ < 0) {
-    error << "Could not open " << errorPath << ": "
-          << llvm::sys::StrError(errno);
+  std::string errorPath{"'"s + path_ + "'"};
+  auto bufOr{llvm::WritableMemoryBuffer::getFile(path)};
+  if (!bufOr) {
+    auto err = bufOr.getError();
+    error << "Could not open " << errorPath << ": " << err.message();
     return false;
   }
-  ++openFileDescriptors;
-  return ReadFile(errorPath, error);
+  buf_ = std::move(bufOr.get());
+  ReadFile();
+  return true;
 }
 
 bool SourceFile::ReadStandardInput(llvm::raw_ostream &error) {
   Close();
   path_ = "standard input";
-  fileDescriptor_ = 0;
-  return ReadFile(path_, error);
-}
 
-bool SourceFile::ReadFile(std::string errorPath, llvm::raw_ostream &error) {
-  struct stat statbuf;
-  if (fstat(fileDescriptor_, &statbuf) != 0) {
-    error << "fstat failed on " << errorPath << ": "
-          << llvm::sys::StrError(errno);
-    Close();
+  auto buf_or = llvm::MemoryBuffer::getSTDIN();
+  if (!buf_or) {
+    auto err = buf_or.getError();
+    error << err.message();
     return false;
   }
-  if (S_ISDIR(statbuf.st_mode)) {
-    error << errorPath << " is a directory";
-    Close();
-    return false;
-  }
-
-  // Try to map a large source file into the process' address space.
-  // Don't bother with small ones.  This also helps keep the number
-  // of open file descriptors from getting out of hand.
-  if (useMMap && S_ISREG(statbuf.st_mode)) {
-    size_ = static_cast<std::size_t>(statbuf.st_size);
-    if (size_ >= minMapFileBytes &&
-        openFileDescriptors <= maxMapOpenFileDescriptors) {
-      void *vp = mmap(0, size_, PROT_READ, MAP_SHARED, fileDescriptor_, 0);
-      if (vp != MAP_FAILED) {
-        address_ = static_cast<const char *>(const_cast<const void *>(vp));
-        IdentifyPayload();
-        if (bytes_ > 0 && content_[bytes_ - 1] == '\n' &&
-            std::memchr(static_cast<const void *>(content_), '\r', bytes_) ==
-                nullptr) {
-          isMemoryMapped_ = true;
-          RecordLineStarts();
-          return true;
-        }
-        // The file needs to have its line endings normalized to simple
-        // newlines.  Remap it for a private rewrite in place.
-        vp = mmap(
-            vp, size_, PROT_READ | PROT_WRITE, MAP_PRIVATE, fileDescriptor_, 0);
-        if (vp != MAP_FAILED) {
-          address_ = static_cast<const char *>(const_cast<const void *>(vp));
-          IdentifyPayload();
-          auto mutableContent{const_cast<char *>(content_)};
-          bytes_ = RemoveCarriageReturns(mutableContent, bytes_);
-          if (bytes_ > 0) {
-            if (mutableContent[bytes_ - 1] == '\n' ||
-                (bytes_ & 0xfff) != 0 /* don't cross into next page */) {
-              if (mutableContent[bytes_ - 1] != '\n') {
-                // Append a final newline.
-                mutableContent[bytes_++] = '\n';
-              }
-              bool isNowReadOnly{mprotect(vp, bytes_, PROT_READ) == 0};
-              CHECK(isNowReadOnly);
-              content_ = mutableContent;
-              isMemoryMapped_ = true;
-              RecordLineStarts();
-              return true;
-            }
-          }
-        }
-        munmap(vp, size_);
-        address_ = content_ = nullptr;
-        size_ = bytes_ = 0;
-      }
-    }
-  }
+  auto inbuf = std::move(buf_or.get());
+  buf_ =
+      llvm::WritableMemoryBuffer::getNewUninitMemBuffer(inbuf->getBufferSize());
+  llvm::copy(inbuf->getBuffer(), buf_->getBufferStart());
+  ReadFile();
+  return true;
+}
 
-  // Read it into an expandable buffer, then marshal its content into a single
-  // contiguous block.
-  CharBuffer buffer;
-  while (true) {
-    std::size_t count;
-    char *to{buffer.FreeSpace(count)};
-    ssize_t got{read(fileDescriptor_, to, count)};
-    if (got < 0) {
-      error << "could not read " << errorPath << ": "
-            << llvm::sys::StrError(errno);
-      Close();
-      return false;
-    }
-    if (got == 0) {
-      break;
-    }
-    buffer.Claim(got);
-  }
-  if (fileDescriptor_ > 0) {
-    close(fileDescriptor_);
-    --openFileDescriptors;
+void SourceFile::ReadFile() {
+  if (buf_->getBuffer().size() == 0) {
+    Close();
+    buf_ = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(1);
+    buf_->getBuffer()[0] = '\n';
   }
-  fileDescriptor_ = -1;
-  normalized_ = buffer.MarshalNormalized();
-  address_ = normalized_.c_str();
-  size_ = normalized_.size();
+  buf_end_ = RemoveCarriageReturns(buf_->getBuffer());
   IdentifyPayload();
   RecordLineStarts();
-  return true;
 }
 
 void SourceFile::Close() {
-  if (useMMap && isMemoryMapped_) {
-    munmap(reinterpret_cast<void *>(const_cast<char *>(address_)), size_);
-    isMemoryMapped_ = false;
-  } else if (!normalized_.empty()) {
-    normalized_.clear();
-  } else if (address_) {
-    delete[] address_;
-  }
-  address_ = content_ = nullptr;
-  size_ = bytes_ = 0;
-  if (fileDescriptor_ > 0) {
-    close(fileDescriptor_);
-    --openFileDescriptors;
-  }
-  fileDescriptor_ = -1;
   path_.clear();
+  buf_.reset();
 }
 
 SourcePosition SourceFile::FindOffsetLineAndColumn(std::size_t at) const {
-  CHECK(at < bytes_);
-  if (lineStart_.empty()) {
-    return {*this, 1, static_cast<int>(at + 1)};
-  }
-  std::size_t low{0}, count{lineStart_.size()};
-  while (count > 1) {
-    std::size_t mid{low + (count >> 1)};
-    if (lineStart_[mid] > at) {
-      count = mid - low;
-    } else {
-      count -= mid - low;
-      low = mid;
-    }
-  }
+  CHECK(at < bytes());
+
+  auto it = llvm::upper_bound(lineStart_, at);
+  auto low = std::distance(lineStart_.begin(), it - 1);
   return {*this, static_cast<int>(low + 1),
       static_cast<int>(at - lineStart_[low] + 1)};
 }
diff --git a/lib/Semantics/mod-file.cpp b/lib/Semantics/mod-file.cpp
index bbf62f9c372f..5c457321cc68 100644
--- a/lib/Semantics/mod-file.cpp
+++ b/lib/Semantics/mod-file.cpp
@@ -728,8 +728,8 @@ static std::string CheckSum(const std::string_view &contents) {
   return result;
 }
 
-static bool VerifyHeader(const char *content, std::size_t len) {
-  std::string_view sv{content, len};
+static bool VerifyHeader(llvm::ArrayRef<char> content) {
+  std::string_view sv{content.data(), content.size()};
   if (sv.substr(0, ModHeader::magicLen) != ModHeader::magic) {
     return false;
   }
@@ -767,7 +767,7 @@ Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
     return nullptr;
   }
   CHECK(sourceFile);
-  if (!VerifyHeader(sourceFile->content(), sourceFile->bytes())) {
+  if (!VerifyHeader(sourceFile->content())) {
     Say(name, ancestorName, "File has invalid checksum: %s"_en_US,
         sourceFile->path());
     return nullptr;
diff --git a/test/Semantics/empty.f90 b/test/Semantics/empty.f90
new file mode 100644
index 000000000000..e47c2e65342c
--- /dev/null
+++ b/test/Semantics/empty.f90
@@ -0,0 +1,4 @@
+! RUN: %f18 -fparse-only %s
+! RUN: rm -rf %t && mkdir %t
+! RUN: touch %t/empty.f90
+! RUN: %f18 -fparse-only %t/empty.f90

From 3f30e8a61e605b9ca6a67791469053286ae563b2 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Thu, 19 Mar 2020 20:07:01 -0700
Subject: [PATCH 099/345] Changes to enforce constraints C727 to C730 and most
 constraints related to attributes

The full list of constraints is C727, C728, C729, C730, C743, C755, C759, C778,
and C1543.

I added a function to tools.cpp to check to see if a symbol name is the name
of an intrinsic type.

The biggest change was to resolve-names.cpp to check to see if attributes were
either duplicated or in conflict with each other.  I changed all locations
where attributes were set to check for duplicates or conflicts.

I also added tests for all checks and annotated the tests and code with the
numbers of the constraints being tested/checked.
---
 include/flang/Semantics/attr.h       |   8 +-
 include/flang/Semantics/tools.h      |   1 +
 lib/Semantics/check-declarations.cpp |   4 +
 lib/Semantics/expression.cpp         |   6 +-
 lib/Semantics/resolve-names.cpp      | 115 ++++++++++++++++++++++-----
 lib/Semantics/tools.cpp              |  16 ++++
 test/Semantics/kinds02.f90           |  14 ++++
 test/Semantics/resolve78.f90         |  32 ++++++++
 test/Semantics/resolve79.f90         |  54 +++++++++++++
 test/Semantics/resolve80.f90         |  61 ++++++++++++++
 test/Semantics/resolve81.f90         |  64 +++++++++++++++
 test/Semantics/resolve82.f90         |  47 +++++++++++
 test/Semantics/resolve83.f90         |  57 +++++++++++++
 test/Semantics/resolve84.f90         |  26 ++++++
 test/Semantics/resolve85.f90         |  37 +++++++++
 15 files changed, 513 insertions(+), 29 deletions(-)
 create mode 100644 test/Semantics/resolve78.f90
 create mode 100644 test/Semantics/resolve79.f90
 create mode 100644 test/Semantics/resolve80.f90
 create mode 100644 test/Semantics/resolve81.f90
 create mode 100644 test/Semantics/resolve82.f90
 create mode 100644 test/Semantics/resolve83.f90
 create mode 100644 test/Semantics/resolve84.f90
 create mode 100644 test/Semantics/resolve85.f90

diff --git a/include/flang/Semantics/attr.h b/include/flang/Semantics/attr.h
index 9aa828da1f80..b8a8fec69aff 100644
--- a/include/flang/Semantics/attr.h
+++ b/include/flang/Semantics/attr.h
@@ -22,10 +22,10 @@ namespace Fortran::semantics {
 
 // All available attributes.
 ENUM_CLASS(Attr, ABSTRACT, ALLOCATABLE, ASYNCHRONOUS, BIND_C, CONTIGUOUS,
-    DEFERRED, ELEMENTAL, EXTERNAL, IMPURE, INTENT_IN, INTENT_INOUT, INTENT_OUT,
-    INTRINSIC, MODULE, NON_OVERRIDABLE, NON_RECURSIVE, NOPASS, OPTIONAL,
-    PARAMETER, PASS, POINTER, PRIVATE, PROTECTED, PUBLIC, PURE, RECURSIVE, SAVE,
-    TARGET, VALUE, VOLATILE)
+    DEFERRED, ELEMENTAL, EXTENDS, EXTERNAL, IMPURE, INTENT_IN, INTENT_INOUT,
+    INTENT_OUT, INTRINSIC, MODULE, NON_OVERRIDABLE, NON_RECURSIVE, NOPASS,
+    OPTIONAL, PARAMETER, PASS, POINTER, PRIVATE, PROTECTED, PUBLIC, PURE,
+    RECURSIVE, SAVE, TARGET, VALUE, VOLATILE)
 
 // Set of attributes
 class Attrs : public common::EnumSet<Attr, Attr_enumSize> {
diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index e2179075e087..43ff6286579e 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -107,6 +107,7 @@ bool IsOrContainsEventOrLockComponent(const Symbol &);
 bool IsSaved(const Symbol &);
 bool CanBeTypeBoundProc(const Symbol *);
 bool IsInitialized(const Symbol &);
+bool HasIntrinsicTypeName(const Symbol &);
 
 // Return an ultimate component of type that matches predicate, or nullptr.
 const Symbol *FindUltimateComponent(const DerivedTypeSpec &type,
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index c1cd33c75f33..ffd735e4b980 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -641,6 +641,10 @@ void CheckHelper::CheckDerivedType(
       }
     }
   }
+  if (HasIntrinsicTypeName(symbol)) {  // C729
+    messages_.Say("A derived type name cannot be the name of an intrinsic"
+                  " type"_err_en_US);
+  }
 }
 
 void CheckHelper::CheckGeneric(
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index fa8f96e4c79a..182b90bdbd1f 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -626,7 +626,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::LogicalLiteralConstant &x) {
       TypeKindVisitor<TypeCategory::Logical, Constant, bool>{
           kind, std::move(value)})};
   if (!result) {
-    Say("unsupported LOGICAL(KIND=%d)"_err_en_US, kind);
+    Say("unsupported LOGICAL(KIND=%d)"_err_en_US, kind);  // C728
   }
   return result;
 }
@@ -2494,7 +2494,7 @@ DynamicType ExpressionAnalyzer::GetDefaultKindOfType(
 
 bool ExpressionAnalyzer::CheckIntrinsicKind(
     TypeCategory category, std::int64_t kind) {
-  if (IsValidKindOfIntrinsicType(category, kind)) {  // C712, C714, C715
+  if (IsValidKindOfIntrinsicType(category, kind)) {  // C712, C714, C715, C727
     return true;
   } else {
     Say("%s(KIND=%jd) is not a supported type"_err_en_US,
@@ -2543,7 +2543,7 @@ bool ExpressionAnalyzer::EnforceTypeConstraint(parser::CharBlock at,
     const MaybeExpr &result, TypeCategory category, bool defaultKind) {
   if (result) {
     if (auto type{result->GetType()}) {
-      if (type->category() != category) { // C885
+      if (type->category() != category) {  // C885
         Say(at, "Must have %s type, but is %s"_err_en_US,
             ToUpperCase(EnumToString(category)),
             ToUpperCase(type->AsFortran()));
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index c696d5e4fe82..f41a6fb72a33 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -242,10 +242,12 @@ class AttrsVisitor : public virtual BaseVisitor {
   bool Pre(const parser::IntentSpec &);
   bool Pre(const parser::Pass &);
 
+  bool CheckAndSet(Attr);
+
 // Simple case: encountering CLASSNAME causes ATTRNAME to be set.
 #define HANDLE_ATTR_CLASS(CLASSNAME, ATTRNAME) \
   bool Pre(const parser::CLASSNAME &) { \
-    attrs_->set(Attr::ATTRNAME); \
+    CheckAndSet(Attr::ATTRNAME); \
     return false; \
   }
   HANDLE_ATTR_CLASS(PrefixSpec::Elemental, ELEMENTAL)
@@ -294,6 +296,10 @@ class AttrsVisitor : public virtual BaseVisitor {
   }
 
 private:
+  bool IsDuplicateAttr(Attr);
+  bool HaveAttrConflict(Attr, Attr, Attr);
+  bool IsConflictingAttr(Attr);
+
   MaybeExpr bindName_;  // from BIND(C, NAME="...")
   std::optional<SourceName> passName_;  // from PASS(...)
 };
@@ -607,6 +613,7 @@ class ModuleVisitor : public virtual ScopeHandler {
 class InterfaceVisitor : public virtual ScopeHandler {
 public:
   bool Pre(const parser::InterfaceStmt &);
+  void Post(const parser::InterfaceStmt &);
   void Post(const parser::EndInterfaceStmt &);
   bool Pre(const parser::GenericSpec &);
   bool Pre(const parser::ProcedureStmt &);
@@ -1548,26 +1555,69 @@ bool AttrsVisitor::SetBindNameOn(Symbol &symbol) {
 
 void AttrsVisitor::Post(const parser::LanguageBindingSpec &x) {
   CHECK(attrs_);
-  attrs_->set(Attr::BIND_C);
-  if (x.v) {
-    bindName_ = EvaluateExpr(*x.v);
+  if (CheckAndSet(Attr::BIND_C)) {
+    if (x.v) {
+      bindName_ = EvaluateExpr(*x.v);
+    }
   }
 }
 bool AttrsVisitor::Pre(const parser::IntentSpec &x) {
   CHECK(attrs_);
-  attrs_->set(IntentSpecToAttr(x));
+  CheckAndSet(IntentSpecToAttr(x));
   return false;
 }
 bool AttrsVisitor::Pre(const parser::Pass &x) {
-  if (x.v) {
-    passName_ = x.v->source;
-    MakePlaceholder(*x.v, MiscDetails::Kind::PassName);
-  } else {
-    attrs_->set(Attr::PASS);
+  if (CheckAndSet(Attr::PASS)) {
+    if (x.v) {
+      passName_ = x.v->source;
+      MakePlaceholder(*x.v, MiscDetails::Kind::PassName);
+    }
   }
   return false;
 }
 
+// C730, C743, C755, C778, C1543 say no attribute or prefix repetitions
+bool AttrsVisitor::IsDuplicateAttr(Attr attrName) {
+  if (attrs_->test(attrName)) {
+    Say(currStmtSource().value(),
+        "Attribute '%s' cannot be used more than once"_en_US,
+        AttrToString(attrName));
+    return true;
+  }
+  return false;
+}
+
+// See if attrName violates a constraint cause by a conflict.  attr1 and attr2
+// name attributes that cannot be used on the same declaration
+bool AttrsVisitor::HaveAttrConflict(Attr attrName, Attr attr1, Attr attr2) {
+  if ((attrName == attr1 && attrs_->test(attr2)) ||
+      (attrName == attr2 && attrs_->test(attr1))) {
+    Say(currStmtSource().value(),
+        "Attributes '%s' and '%s' conflict with each other"_err_en_US,
+        AttrToString(attr1), AttrToString(attr2));
+    return true;
+  }
+  return false;
+}
+// C759, C1543
+bool AttrsVisitor::IsConflictingAttr(Attr attrName) {
+  return HaveAttrConflict(attrName, Attr::INTENT_IN, Attr::INTENT_INOUT) ||
+      HaveAttrConflict(attrName, Attr::INTENT_IN, Attr::INTENT_OUT) ||
+      HaveAttrConflict(attrName, Attr::INTENT_INOUT, Attr::INTENT_OUT) ||
+      HaveAttrConflict(attrName, Attr::PASS, Attr::NOPASS) ||
+      HaveAttrConflict(attrName, Attr::PURE, Attr::IMPURE) ||
+      HaveAttrConflict(attrName, Attr::PUBLIC, Attr::PRIVATE) ||
+      HaveAttrConflict(attrName, Attr::RECURSIVE, Attr::NON_RECURSIVE);
+}
+bool AttrsVisitor::CheckAndSet(Attr attrName) {
+  CHECK(attrs_);
+  if (IsConflictingAttr(attrName) || IsDuplicateAttr(attrName)) {
+    return false;
+  }
+  attrs_->set(attrName);
+  return true;
+}
+
 // DeclTypeSpecVisitor implementation
 
 const DeclTypeSpec *DeclTypeSpecVisitor::GetDeclTypeSpec() {
@@ -1824,14 +1874,22 @@ void ArraySpecVisitor::PostAttrSpec() {
   // Save dimension/codimension from attrs so we can process array/coarray-spec
   // on the entity-decl
   if (!arraySpec_.empty()) {
-    CHECK(attrArraySpec_.empty());
-    attrArraySpec_ = arraySpec_;
-    arraySpec_.clear();
+    if (attrArraySpec_.empty()) {
+      attrArraySpec_ = arraySpec_;
+      arraySpec_.clear();
+    } else {
+      Say(currStmtSource().value(),
+          "Attribute 'DIMENSION' cannot be used more than once"_err_en_US);
+    }
   }
   if (!coarraySpec_.empty()) {
-    CHECK(attrCoarraySpec_.empty());
-    attrCoarraySpec_ = coarraySpec_;
-    coarraySpec_.clear();
+    if (attrCoarraySpec_.empty()) {
+      attrCoarraySpec_ = coarraySpec_;
+      coarraySpec_.clear();
+    } else {
+      Say(currStmtSource().value(),
+          "Attribute 'CODIMENSION' cannot be used more than once"_err_en_US);
+    }
   }
 }
 
@@ -2395,9 +2453,11 @@ void ModuleVisitor::ApplyDefaultAccess() {
 bool InterfaceVisitor::Pre(const parser::InterfaceStmt &x) {
   bool isAbstract{std::holds_alternative<parser::Abstract>(x.u)};
   genericInfo_.emplace(/*isInterface*/ true, isAbstract);
-  return true;
+  return BeginAttrs();
 }
 
+void InterfaceVisitor::Post(const parser::InterfaceStmt &) { EndAttrs(); }
+
 void InterfaceVisitor::Post(const parser::EndInterfaceStmt &) {
   genericInfo_.pop();
 }
@@ -2624,9 +2684,15 @@ bool SubprogramVisitor::Pre(const parser::Suffix &suffix) {
 bool SubprogramVisitor::Pre(const parser::PrefixSpec &x) {
   // Save this to process after UseStmt and ImplicitPart
   if (const auto *parsedType{std::get_if<parser::DeclarationTypeSpec>(&x.u)}) {
-    funcInfo_.parsedType = parsedType;
-    funcInfo_.source = currStmtSource();
-    return false;
+    if (funcInfo_.parsedType) {  // C1543
+      Say(currStmtSource().value(),
+          "FUNCTION prefix cannot specify the type more than once"_err_en_US);
+      return false;
+    } else {
+      funcInfo_.parsedType = parsedType;
+      funcInfo_.source = currStmtSource();
+      return false;
+    }
   } else {
     return true;
   }
@@ -3057,7 +3123,7 @@ bool DeclarationVisitor::Pre(const parser::AccessSpec &x) {
         "%s attribute may only appear in the specification part of a module"_err_en_US,
         EnumToString(attr));
   }
-  attrs_->set(attr);
+  CheckAndSet(attr);
   return false;
 }
 
@@ -3522,7 +3588,12 @@ void DeclarationVisitor::Post(const parser::TypeParamDefStmt &x) {
   EndDecl();
 }
 bool DeclarationVisitor::Pre(const parser::TypeAttrSpec::Extends &x) {
-  derivedTypeInfo_.extends = &x.v;
+  if (derivedTypeInfo_.extends) {
+    Say(currStmtSource().value(),
+        "Attribute 'EXTENDS' cannot be used more than once"_err_en_US);
+  } else {
+    derivedTypeInfo_.extends = &x.v;
+  }
   return false;
 }
 
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index f6a4e39e511d..9b3a0326b10e 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -674,6 +674,22 @@ bool IsInitialized(const Symbol &symbol) {
   return false;
 }
 
+bool HasIntrinsicTypeName(const Symbol &symbol) {
+  std::string name{symbol.name().ToString()};
+  if (name == "doubleprecision") {
+    return true;
+  } else if (name == "derived") {
+    return false;
+  } else {
+    for (int i{0}; i != common::TypeCategory_enumSize; ++i) {
+      if (name == parser::ToLowerCaseLetters(EnumToString(TypeCategory{i}))) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
 bool IsFinalizable(const Symbol &symbol) {
   if (const DeclTypeSpec * type{symbol.GetType()}) {
     if (const DerivedTypeSpec * derived{type->AsDerived()}) {
diff --git a/test/Semantics/kinds02.f90 b/test/Semantics/kinds02.f90
index 0983be564738..f1ff0b27caf5 100644
--- a/test/Semantics/kinds02.f90
+++ b/test/Semantics/kinds02.f90
@@ -10,6 +10,8 @@
 ! double-colon separator appears in the typedeclaration- stmt.
 ! C727 The value of kind-param shall specify a representation method that 
 ! exists on the processor.
+! C728 The value of kind-param shall specify a representation method that 
+! exists on the processor.
 !
 !ERROR: INTEGER(KIND=0) is not a supported type
 integer(kind=0) :: j0
@@ -53,6 +55,18 @@
 logical(kind=3) :: l3
 !ERROR: LOGICAL(KIND=16) is not a supported type
 logical(kind=16) :: l16
+integer, parameter :: negOne = -1
+!ERROR: unsupported LOGICAL(KIND=0)
+logical :: lvar0 = .true._0
+logical :: lvar1 = .true._1
+logical :: lvar2 = .true._2
+!ERROR: unsupported LOGICAL(KIND=3)
+logical :: lvar3 = .true._3
+logical :: lvar4 = .true._4
+!ERROR: unsupported LOGICAL(KIND=5)
+logical :: lvar5 = .true._5
+!ERROR: unsupported LOGICAL(KIND=-1)
+logical :: lvar6 = .true._negOne
 character (len=99, kind=1) :: cvar1
 character (len=99, kind=2) :: cvar2
 character *4, cvar3
diff --git a/test/Semantics/resolve78.f90 b/test/Semantics/resolve78.f90
new file mode 100644
index 000000000000..0e4efc081009
--- /dev/null
+++ b/test/Semantics/resolve78.f90
@@ -0,0 +1,32 @@
+! RUN: %S/test_errors.sh %s %flang %t
+module m
+! C743 No component-attr-spec shall appear more than once in a 
+! given component-def-stmt.
+!
+! R737 data-component-def-stmt ->
+!        declaration-type-spec [[, component-attr-spec-list] ::]
+!        component-decl-list
+!  component-attr-spec values are:
+!    PUBLIC, PRIVATE, ALLOCATABLE, CODIMENSION [*], CONTIGUOUS, DIMENSION(5), 
+!      POINTER
+
+  type :: derived
+    !WARNING: Attribute 'PUBLIC' cannot be used more than once
+    real, public, allocatable, public :: field1
+    !WARNING: Attribute 'PRIVATE' cannot be used more than once
+    real, private, allocatable, private :: field2
+    !ERROR: Attributes 'PUBLIC' and 'PRIVATE' conflict with each other
+    real, public, allocatable, private :: field3
+    !WARNING: Attribute 'ALLOCATABLE' cannot be used more than once
+    real, allocatable, public, allocatable :: field4
+    !ERROR: Attribute 'CODIMENSION' cannot be used more than once
+    real, public, codimension[:], allocatable, codimension[:] :: field5
+    !WARNING: Attribute 'CONTIGUOUS' cannot be used more than once
+    real, public, contiguous, pointer, contiguous, dimension(:) :: field6
+    !ERROR: Attribute 'DIMENSION' cannot be used more than once
+    real, dimension(5), public, dimension(5) :: field7
+    !WARNING: Attribute 'POINTER' cannot be used more than once
+    real, pointer, public, pointer :: field8
+  end type derived
+
+end module m
diff --git a/test/Semantics/resolve79.f90 b/test/Semantics/resolve79.f90
new file mode 100644
index 000000000000..5d0e2127ea10
--- /dev/null
+++ b/test/Semantics/resolve79.f90
@@ -0,0 +1,54 @@
+! RUN: %S/test_errors.sh %s %flang %t
+module m
+! C755 The same proc-component-attr-spec shall not appear more than once in a 
+! given proc-component-def-stmt.
+! C759 PASS and NOPASS shall not both appear in the same 
+! proc-component-attr-spec-list.
+!
+! R741 proc-component-def-stmt ->
+!        PROCEDURE ( [proc-interface] ) , proc-component-attr-spec-list
+!          :: proc-decl-list
+!  proc-component-attr-spec values are:
+!    PUBLIC, PRIVATE, NOPASS, PASS, POINTER
+
+  type :: procComponentType
+    !WARNING: Attribute 'PUBLIC' cannot be used more than once
+    procedure(publicProc), public, pointer, public :: publicField
+    !WARNING: Attribute 'PRIVATE' cannot be used more than once
+    procedure(privateProc), private, pointer, private :: privateField
+    !WARNING: Attribute 'NOPASS' cannot be used more than once
+    procedure(nopassProc), nopass, pointer, nopass :: noPassField
+    !WARNING: Attribute 'PASS' cannot be used more than once
+    procedure(passProc), pass, pointer, pass :: passField
+    !ERROR: Attributes 'PASS' and 'NOPASS' conflict with each other
+    procedure(passNopassProc), pass, pointer, nopass :: passNopassField
+    !WARNING: Attribute 'POINTER' cannot be used more than once
+    procedure(pointerProc), pointer, public, pointer :: pointerField
+  contains
+    procedure :: noPassProc
+    procedure :: passProc
+    procedure :: passNopassProc
+    procedure :: publicProc
+    procedure :: privateProc
+  end type procComponentType
+
+contains
+    subroutine publicProc(arg)
+      class(procComponentType) :: arg
+    end
+    subroutine privateProc(arg)
+      class(procComponentType) :: arg
+    end
+    subroutine noPassProc(arg)
+      class(procComponentType) :: arg
+    end
+    subroutine passProc(arg)
+      class(procComponentType) :: arg
+    end
+    subroutine passNopassProc(arg)
+      class(procComponentType) :: arg
+    end
+    subroutine pointerProc(arg)
+      class(procComponentType) :: arg
+    end
+end module m
diff --git a/test/Semantics/resolve80.f90 b/test/Semantics/resolve80.f90
new file mode 100644
index 000000000000..98f5c79a343b
--- /dev/null
+++ b/test/Semantics/resolve80.f90
@@ -0,0 +1,61 @@
+! RUN: %S/test_errors.sh %s %flang %t
+module m
+!C778 The same binding-attr shall not appear more than once in a given
+!binding-attr-list.
+!
+!R749 type-bound-procedure-stmt
+!  PROCEDURE [ [ ,binding-attr-list] :: ]type-bound-proc-decl-list
+!  or PROCEDURE (interface-name),binding-attr-list::binding-name-list
+!
+!
+!  binding-attr values are:
+!    PUBLIC, PRIVATE, DEFERRED, NON_OVERRIDABLE, NOPASS, PASS [ (arg-name) ]
+!
+  type, abstract :: boundProcType
+   contains
+    !WARNING: Attribute 'PUBLIC' cannot be used more than once
+    procedure(subPublic), public, deferred, public :: publicBinding
+    !WARNING: Attribute 'PRIVATE' cannot be used more than once
+    procedure(subPrivate), private, deferred, private :: privateBinding
+    !WARNING: Attribute 'DEFERRED' cannot be used more than once
+    procedure(subDeferred), deferred, public, deferred :: deferredBinding
+    !WARNING: Attribute 'NON_OVERRIDABLE' cannot be used more than once
+    procedure, non_overridable, public, non_overridable :: subNon_overridable;
+    !WARNING: Attribute 'NOPASS' cannot be used more than once
+    procedure(subNopass), nopass, deferred, nopass :: nopassBinding
+    !WARNING: Attribute 'PASS' cannot be used more than once
+    procedure(subPass), pass, deferred, pass :: passBinding
+    !ERROR: Attributes 'PASS' and 'NOPASS' conflict with each other
+    procedure(subPassNopass), pass, deferred, nopass :: passNopassBinding
+  end type boundProcType
+
+contains
+    subroutine subPublic(x)
+      class(boundProcType), intent(in) :: x
+    end subroutine subPublic
+
+    subroutine subPrivate(x)
+      class(boundProcType), intent(in) :: x
+    end subroutine subPrivate
+
+    subroutine subDeferred(x)
+      class(boundProcType), intent(in) :: x
+    end subroutine subDeferred
+
+    subroutine subNon_overridable(x)
+      class(boundProcType), intent(in) :: x
+    end subroutine subNon_overridable
+
+    subroutine subNopass(x)
+      class(boundProcType), intent(in) :: x
+    end subroutine subNopass
+
+    subroutine subPass(x)
+      class(boundProcType), intent(in) :: x
+    end subroutine subPass
+
+    subroutine subPassNopass(x)
+      class(boundProcType), intent(in) :: x
+    end subroutine subPassNopass
+
+end module m
diff --git a/test/Semantics/resolve81.f90 b/test/Semantics/resolve81.f90
new file mode 100644
index 000000000000..218d74ec6744
--- /dev/null
+++ b/test/Semantics/resolve81.f90
@@ -0,0 +1,64 @@
+! RUN: %S/test_errors.sh %s %flang %t
+! C801 The same attr-spec shall not appear more than once in a given
+! type-declaration-stmt.
+!
+! R801 type-declaration-stmt ->
+!        declaration-type-spec [[, attr-spec]... ::] entity-decl-list
+!  attr-spec values are:
+!    PUBLIC, PRIVATE, ALLOCATABLE, ASYNCHRONOUS, CODIMENSION, CONTIGUOUS, 
+!    DIMENSION (array-spec), EXTERNAL, INTENT (intent-spec), INTRINSIC, 
+!    BIND(C), OPTIONAL, PARAMETER, POINTER, PROTECTED, SAVE, TARGET, VALUE, 
+!    VOLATILE
+module m
+
+  !WARNING: Attribute 'PUBLIC' cannot be used more than once
+  real, public, allocatable, public :: publicVar
+  !WARNING: Attribute 'PRIVATE' cannot be used more than once
+  real, private, allocatable, private :: privateVar
+  !WARNING: Attribute 'ALLOCATABLE' cannot be used more than once
+  real, allocatable, allocatable :: allocVar
+  !WARNING: Attribute 'ASYNCHRONOUS' cannot be used more than once
+  real, asynchronous, public, asynchronous :: asynchVar
+  !ERROR: Attribute 'CODIMENSION' cannot be used more than once
+  real, codimension[*], codimension[*] :: codimensionVar
+  !WARNING: Attribute 'CONTIGUOUS' cannot be used more than once
+  real, contiguous, pointer, contiguous :: contigVar(:)
+  !ERROR: Attribute 'DIMENSION' cannot be used more than once
+  real, dimension(5), dimension(5) :: arrayVar
+  !WARNING: Attribute 'EXTERNAL' cannot be used more than once
+  real, external, external :: externFunc
+  !WARNING: Attribute 'INTRINSIC' cannot be used more than once
+  real, intrinsic, bind(c), intrinsic :: cos
+  !WARNING: Attribute 'BIND(C)' cannot be used more than once
+  integer, bind(c), volatile, bind(c) :: bindVar
+  !WARNING: Attribute 'PARAMETER' cannot be used more than once
+  real, parameter, parameter :: realConst = 4.3
+  !WARNING: Attribute 'POINTER' cannot be used more than once
+  real, pointer, pointer :: realPtr
+  !WARNING: Attribute 'PROTECTED' cannot be used more than once
+  real, protected, protected :: realProt
+  !WARNING: Attribute 'SAVE' cannot be used more than once
+  real, save, save :: saveVar
+  !WARNING: Attribute 'TARGET' cannot be used more than once
+  real, target, target :: targetVar
+  !WARNING: Attribute 'VOLATILE' cannot be used more than once
+  real, volatile, volatile :: volatileVar
+
+contains
+    subroutine testTypeDecl(arg1, arg2, arg3, arg4, arg5, arg6)
+      !WARNING: Attribute 'INTENT(IN)' cannot be used more than once
+      real, intent(in), intent(in) :: arg1
+      !WARNING: Attribute 'INTENT(OUT)' cannot be used more than once
+      real, intent(out), intent(out) :: arg2
+      !WARNING: Attribute 'INTENT(INOUT)' cannot be used more than once
+      real, intent(inout), intent(inout) :: arg3
+      !WARNING: Attribute 'OPTIONAL' cannot be used more than once
+      integer, optional, intent(in), optional :: arg4
+      !WARNING: Attribute 'VALUE' cannot be used more than once
+      integer, value, intent(in), value :: arg5
+      !ERROR: Attributes 'INTENT(IN)' and 'INTENT(INOUT)' conflict with each other
+      integer, intent(in), pointer, intent(inout) :: arg6
+
+      arg2 =3.5
+    end subroutine testTypeDecl
+end module m
diff --git a/test/Semantics/resolve82.f90 b/test/Semantics/resolve82.f90
new file mode 100644
index 000000000000..378e8796db45
--- /dev/null
+++ b/test/Semantics/resolve82.f90
@@ -0,0 +1,47 @@
+! RUN: %S/test_errors.sh %s %flang %t
+! C815 An entity shall not be explicitly given any attribute more than once in 
+! a scoping unit.
+!
+! R1512 procedure-declaration-stmt ->
+!         PROCEDURE ( [proc-interface] ) [[, proc-attr-spec]... ::]
+!         proc-decl-list
+!  proc-attr-spec values are:
+!    PUBLIC, PRIVATE, BIND(C), INTENT (intent-spec), OPTIONAL, POINTER, 
+!    PROTECTED, SAVE
+module m
+  abstract interface
+    real function procFunc()
+    end function procFunc
+  end interface
+
+  !WARNING: Attribute 'PUBLIC' cannot be used more than once
+  procedure(procFunc), public, pointer, public :: proc1
+  !WARNING: Attribute 'PRIVATE' cannot be used more than once
+  procedure(procFunc), private, pointer, private :: proc2
+  !WARNING: Attribute 'BIND(C)' cannot be used more than once
+  procedure(procFunc), bind(c), pointer, bind(c) :: proc3
+  !WARNING: Attribute 'PROTECTED' cannot be used more than once
+  procedure(procFunc), protected, pointer, protected :: proc4
+
+contains
+
+    subroutine testProcDecl(arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
+      !WARNING: Attribute 'INTENT(IN)' cannot be used more than once
+      procedure(procFunc), intent(in), pointer, intent(in) :: arg4
+      !WARNING: Attribute 'INTENT(OUT)' cannot be used more than once
+      procedure(procFunc), intent(out), pointer, intent(out) :: arg5
+      !WARNING: Attribute 'INTENT(INOUT)' cannot be used more than once
+      procedure(procFunc), intent(inout), pointer, intent(inout) :: arg6
+      !ERROR: Attributes 'INTENT(INOUT)' and 'INTENT(OUT)' conflict with each other
+      procedure(procFunc), intent(inout), pointer, intent(out) :: arg7
+      !ERROR: Attributes 'INTENT(INOUT)' and 'INTENT(OUT)' conflict with each other
+      procedure(procFunc), intent(out), pointer, intent(inout) :: arg8
+      !WARNING: Attribute 'OPTIONAL' cannot be used more than once
+      procedure(procFunc), optional, pointer, optional :: arg9
+      !WARNING: Attribute 'POINTER' cannot be used more than once
+      procedure(procFunc), pointer, optional, pointer :: arg10
+      !WARNING: Attribute 'SAVE' cannot be used more than once
+      procedure(procFunc), save, pointer, save :: localProc
+    end subroutine testProcDecl
+
+end module m
diff --git a/test/Semantics/resolve83.f90 b/test/Semantics/resolve83.f90
new file mode 100644
index 000000000000..cdd528a688e2
--- /dev/null
+++ b/test/Semantics/resolve83.f90
@@ -0,0 +1,57 @@
+! RUN: %S/test_errors.sh %s %flang %t
+module m
+
+  ! For C1543
+  interface intFace
+    !WARNING: Attribute 'MODULE' cannot be used more than once
+    module pure module real function moduleFunc()
+    end function moduleFunc
+  end interface
+
+contains
+
+! C1543 A prefix shall contain at most one of each prefix-spec.
+! 
+! R1535 subroutine-stmt is 
+!   [prefix] SUBROUTINE subroutine-name [ ( [dummy-arg-list] ) 
+!   [proc-language-binding-spec] ]
+! 
+! R1526  prefix is
+!   prefix-spec[prefix-spec]...
+!   
+!   prefix-spec values are:
+!      declaration-type-spec, ELEMENTAL, IMPURE, MODULE, NON_RECURSIVE, 
+!      PURE, RECURSIVE
+
+    !ERROR: FUNCTION prefix cannot specify the type more than once
+    real pure real function realFunc()
+    end function realFunc
+
+    !WARNING: Attribute 'ELEMENTAL' cannot be used more than once
+    elemental real elemental function elementalFunc()
+    end function elementalFunc
+
+    !WARNING: Attribute 'IMPURE' cannot be used more than once
+    impure real impure function impureFunc()
+    end function impureFunc
+
+    !WARNING: Attribute 'PURE' cannot be used more than once
+    pure real pure function pureFunc()
+    end function pureFunc
+
+    !ERROR: Attributes 'PURE' and 'IMPURE' conflict with each other
+    impure real pure function impurePureFunc()
+    end function impurePureFunc
+
+    !WARNING: Attribute 'RECURSIVE' cannot be used more than once
+    recursive real recursive function recursiveFunc()
+    end function recursiveFunc
+
+    !WARNING: Attribute 'NON_RECURSIVE' cannot be used more than once
+    non_recursive real non_recursive function non_recursiveFunc()
+    end function non_recursiveFunc
+
+    !ERROR: Attributes 'RECURSIVE' and 'NON_RECURSIVE' conflict with each other
+    non_recursive real recursive function non_recursiveRecursiveFunc()
+    end function non_recursiveRecursiveFunc
+end module m
diff --git a/test/Semantics/resolve84.f90 b/test/Semantics/resolve84.f90
new file mode 100644
index 000000000000..79e393f4b689
--- /dev/null
+++ b/test/Semantics/resolve84.f90
@@ -0,0 +1,26 @@
+! RUN: %S/test_errors.sh %s %flang %t
+! C729 A derived type type-name shall not be DOUBLEPRECISION or the same as 
+! the name of any intrinsic type defined in this document.
+subroutine s()
+  ! This one's OK
+  type derived
+  end type
+  !ERROR: A derived type name cannot be the name of an intrinsic type
+  type integer
+  end type
+  !ERROR: A derived type name cannot be the name of an intrinsic type
+  type real
+  end type
+  !ERROR: A derived type name cannot be the name of an intrinsic type
+  type doubleprecision
+  end type
+  !ERROR: A derived type name cannot be the name of an intrinsic type
+  type complex
+  end type
+  !ERROR: A derived type name cannot be the name of an intrinsic type
+  type character
+  end type
+  !ERROR: A derived type name cannot be the name of an intrinsic type
+  type logical
+  end type
+end subroutine s
diff --git a/test/Semantics/resolve85.f90 b/test/Semantics/resolve85.f90
new file mode 100644
index 000000000000..d228b7d03e47
--- /dev/null
+++ b/test/Semantics/resolve85.f90
@@ -0,0 +1,37 @@
+! RUN: %S/test_errors.sh %s %flang %t
+module m
+! C730 The same type-attr-spec shall not appear more than once in a given 
+! derived-type-stmt.
+!
+! R727 derived-type-stmt ->
+!        TYPE [[, type-attr-spec-list] ::] type-name [( type-param-name-list )]
+!  type-attr-spec values are:
+!    ABSTRACT, PUBLIC, PRIVATE, BIND(C), EXTENDS(parent-type-name)
+  !WARNING: Attribute 'ABSTRACT' cannot be used more than once
+  type, abstract, public, abstract :: derived1
+  end type derived1
+
+  !WARNING: Attribute 'PUBLIC' cannot be used more than once
+  type, public, abstract, public :: derived2
+  end type derived2
+
+  !WARNING: Attribute 'PRIVATE' cannot be used more than once
+  type, private, abstract, private :: derived3
+  end type derived3
+
+  !ERROR: Attributes 'PUBLIC' and 'PRIVATE' conflict with each other
+  type, public, abstract, private :: derived4
+  end type derived4
+
+  !WARNING: Attribute 'BIND(C)' cannot be used more than once
+  type, bind(c), public, bind(c) :: derived5
+  end type derived5
+
+  type, public :: derived6
+  end type derived6
+
+  !ERROR: Attribute 'EXTENDS' cannot be used more than once
+  type, extends(derived6), public, extends(derived6) :: derived7
+  end type derived7
+
+end module m

From e82cfee4325f90e3c6ed08e797fa940259948ffd Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Thu, 19 Mar 2020 16:31:10 -0700
Subject: [PATCH 100/345] Semantics for ENTRY

initial test passes

Move some checks to check-declarations

Fix bugs found in testing

Get tests all passing

Allow declaration statements for function result to follow ENTRY

Fix another bug
---
 include/flang/Semantics/symbol.h     |  26 +-
 include/flang/Semantics/tools.h      |   8 +-
 lib/Semantics/check-declarations.cpp |  81 +++-
 lib/Semantics/expression.cpp         |   5 +-
 lib/Semantics/mod-file.cpp           |  14 +-
 lib/Semantics/resolve-names.cpp      | 586 ++++++++++++++++++---------
 lib/Semantics/semantics.cpp          |  15 +-
 lib/Semantics/symbol.cpp             |  15 +-
 lib/Semantics/tools.cpp              |  33 +-
 test/Semantics/assign04.f90          |   1 +
 test/Semantics/entry01.f90           | 184 +++++++++
 11 files changed, 727 insertions(+), 241 deletions(-)
 create mode 100644 test/Semantics/entry01.f90

diff --git a/include/flang/Semantics/symbol.h b/include/flang/Semantics/symbol.h
index a9f4dd6bc185..3eaa95f08e2a 100644
--- a/include/flang/Semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -61,6 +61,9 @@ class SubprogramDetails {
   bool isFunction() const { return result_ != nullptr; }
   bool isInterface() const { return isInterface_; }
   void set_isInterface(bool value = true) { isInterface_ = value; }
+  Scope *entryScope() { return entryScope_; }
+  const Scope *entryScope() const { return entryScope_; }
+  void set_entryScope(Scope &scope) { entryScope_ = &scope; }
   MaybeExpr bindName() const { return bindName_; }
   void set_bindName(MaybeExpr &&expr) { bindName_ = std::move(expr); }
   const Symbol &result() const {
@@ -82,8 +85,10 @@ class SubprogramDetails {
   MaybeExpr bindName_;
   std::vector<Symbol *> dummyArgs_;  // nullptr -> alternate return indicator
   Symbol *result_{nullptr};
+  Scope *entryScope_{nullptr};  // if ENTRY, points to subprogram's scope
   MaybeExpr stmtFunction_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SubprogramDetails &);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const SubprogramDetails &);
 };
 
 // For SubprogramNameDetails, the kind indicates whether it is the name
@@ -115,17 +120,19 @@ class EntityDetails {
   void set_type(const DeclTypeSpec &);
   void ReplaceType(const DeclTypeSpec &);
   bool isDummy() const { return isDummy_; }
+  void set_isDummy(bool value = true) { isDummy_ = value; }
   bool isFuncResult() const { return isFuncResult_; }
   void set_funcResult(bool x) { isFuncResult_ = x; }
   MaybeExpr bindName() const { return bindName_; }
   void set_bindName(MaybeExpr &&expr) { bindName_ = std::move(expr); }
 
 private:
-  bool isDummy_;
+  bool isDummy_{false};
   bool isFuncResult_{false};
   const DeclTypeSpec *type_{nullptr};
   MaybeExpr bindName_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const EntityDetails &);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const EntityDetails &);
 };
 
 // Symbol is associated with a name or expression in a SELECT TYPE or ASSOCIATE.
@@ -180,7 +187,8 @@ class ObjectEntityDetails : public EntityDetails {
   ArraySpec shape_;
   ArraySpec coshape_;
   const Symbol *commonBlock_{nullptr};  // common block this object is in
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ObjectEntityDetails &);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const ObjectEntityDetails &);
 };
 
 // Mixin for details with passed-object dummy argument.
@@ -217,7 +225,8 @@ class ProcEntityDetails : public EntityDetails, public WithPassArg {
 private:
   ProcInterface interface_;
   std::optional<const Symbol *> init_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ProcEntityDetails &);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const ProcEntityDetails &);
 };
 
 // These derived type details represent the characteristics of a derived
@@ -263,7 +272,8 @@ class DerivedTypeDetails {
   std::list<SourceName> componentNames_;
   bool sequence_{false};
   bool isForwardReferenced_{false};
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DerivedTypeDetails &);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const DerivedTypeDetails &);
 };
 
 class ProcBindingDetails : public WithPassArg {
@@ -570,7 +580,6 @@ class Symbol {
   bool IsFuncResult() const;
   bool IsObjectArray() const;
   bool IsSubprogram() const;
-  bool IsSeparateModuleProc() const;
   bool IsFromModFile() const;
   bool HasExplicitInterface() const {
     return std::visit(
@@ -662,7 +671,8 @@ class Symbol {
   Symbol() {}  // only created in class Symbols
   const std::string GetDetailsName() const;
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Symbol &);
-  friend llvm::raw_ostream &DumpForUnparse(llvm::raw_ostream &, const Symbol &, bool);
+  friend llvm::raw_ostream &DumpForUnparse(
+      llvm::raw_ostream &, const Symbol &, bool);
 
   // If a derived type's symbol refers to an extended derived type,
   // return the parent component's symbol.  The scope of the derived type
diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index 43ff6286579e..da752d136024 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -108,6 +108,7 @@ bool IsSaved(const Symbol &);
 bool CanBeTypeBoundProc(const Symbol *);
 bool IsInitialized(const Symbol &);
 bool HasIntrinsicTypeName(const Symbol &);
+bool IsSeparateModuleProcedureInterface(const Symbol *);
 
 // Return an ultimate component of type that matches predicate, or nullptr.
 const Symbol *FindUltimateComponent(const DerivedTypeSpec &type,
@@ -164,7 +165,7 @@ inline bool IsAssumedRankArray(const Symbol &symbol) {
   return details && details->IsAssumedRank();
 }
 bool IsAssumedLengthCharacter(const Symbol &);
-bool IsAssumedLengthExternalCharacterFunction(const Symbol &);
+bool IsExternal(const Symbol &);
 // Is the symbol modifiable in this scope
 std::optional<parser::MessageFixedText> WhyNotModifiable(
     const Symbol &, const Scope &);
@@ -200,6 +201,11 @@ std::list<SourceName> OrderParameterNames(const Symbol &);
 const DeclTypeSpec &FindOrInstantiateDerivedType(Scope &, DerivedTypeSpec &&,
     SemanticsContext &, DeclTypeSpec::Category = DeclTypeSpec::TypeDerived);
 
+// When a subprogram defined in a submodule defines a separate module
+// procedure whose interface is defined in an ancestor (sub)module,
+// returns a pointer to that interface, else null.
+const Symbol *FindSeparateModuleSubprogramInterface(const Symbol *);
+
 // Determines whether an object might be visible outside a
 // pure function (C1594); returns a non-null Symbol pointer for
 // diagnostic purposes if so.
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index ffd735e4b980..cb6888610b28 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -24,6 +24,7 @@ namespace Fortran::semantics {
 using evaluate::characteristics::DummyArgument;
 using evaluate::characteristics::DummyDataObject;
 using evaluate::characteristics::DummyProcedure;
+using evaluate::characteristics::FunctionResult;
 using evaluate::characteristics::Procedure;
 
 class CheckHelper {
@@ -109,6 +110,7 @@ class CheckHelper {
       }
     }
   }
+  bool IsResultOkToDiffer(const FunctionResult &);
 
   SemanticsContext &context_;
   evaluate::FoldingContext &foldingContext_{context_.foldingContext()};
@@ -208,7 +210,8 @@ void CheckHelper::Check(const Symbol &symbol) {
   }
   if (type) {  // Section 7.2, paragraph 7
     bool canHaveAssumedParameter{IsNamedConstant(symbol) ||
-        IsAssumedLengthExternalCharacterFunction(symbol) ||  // C722
+        (IsAssumedLengthCharacter(symbol) &&  // C722
+            IsExternal(symbol)) ||
         symbol.test(Symbol::Flag::ParentComp)};
     if (!IsStmtFunctionDummy(symbol)) {  // C726
       if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
@@ -239,7 +242,7 @@ void CheckHelper::Check(const Symbol &symbol) {
       }
     }
   }
-  if (IsAssumedLengthExternalCharacterFunction(symbol)) {  // C723
+  if (IsAssumedLengthCharacter(symbol) && IsExternal(symbol)) {  // C723
     if (symbol.attrs().test(Attr::RECURSIVE)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be RECURSIVE"_err_en_US);
@@ -270,6 +273,16 @@ void CheckHelper::Check(const Symbol &symbol) {
       symbol.Rank() == 0) {  // C830
     messages_.Say("CONTIGUOUS POINTER must be an array"_err_en_US);
   }
+  if (IsDummy(symbol)) {
+    if (IsNamedConstant(symbol)) {
+      messages_.Say(
+          "A dummy argument may not also be a named constant"_err_en_US);
+    }
+    if (IsSaved(symbol)) {
+      messages_.Say(
+          "A dummy argument may not have the SAVE attribute"_err_en_US);
+    }
+  }
 }
 
 void CheckHelper::CheckValue(
@@ -600,12 +613,66 @@ class SubprogramMatchHelper {
   SemanticsContext &context;
 };
 
+// 15.6.2.6 para 3 - can the result of an ENTRY differ from its function?
+bool CheckHelper::IsResultOkToDiffer(const FunctionResult &result) {
+  if (result.attrs.test(FunctionResult::Attr::Allocatable) ||
+      result.attrs.test(FunctionResult::Attr::Pointer)) {
+    return false;
+  }
+  const auto *typeAndShape{result.GetTypeAndShape()};
+  if (!typeAndShape || typeAndShape->Rank() != 0) {
+    return false;
+  }
+  auto category{typeAndShape->type().category()};
+  if (category == TypeCategory::Character ||
+      category == TypeCategory::Derived) {
+    return false;
+  }
+  int kind{typeAndShape->type().kind()};
+  return kind == context_.GetDefaultKind(category) ||
+      (category == TypeCategory::Real &&
+          kind == context_.doublePrecisionKind());
+}
+
 void CheckHelper::CheckSubprogram(
-    const Symbol &symbol, const SubprogramDetails &) {
-  const Scope &scope{symbol.owner()};
-  if (symbol.attrs().test(Attr::MODULE) && scope.IsSubmodule()) {
-    if (const Symbol * iface{scope.parent().FindSymbol(symbol.name())}) {
-      SubprogramMatchHelper{context_}.Check(symbol, *iface);
+    const Symbol &symbol, const SubprogramDetails &details) {
+  if (const Symbol * iface{FindSeparateModuleSubprogramInterface(&symbol)}) {
+    SubprogramMatchHelper{context_}.Check(symbol, *iface);
+  }
+  if (const Scope * entryScope{details.entryScope()}) {
+    // ENTRY 15.6.2.6, esp. C1571
+    std::optional<parser::MessageFixedText> error;
+    const Symbol *subprogram{entryScope->symbol()};
+    const SubprogramDetails *subprogramDetails{nullptr};
+    if (subprogram) {
+      subprogramDetails = subprogram->detailsIf<SubprogramDetails>();
+    }
+    if (entryScope->kind() != Scope::Kind::Subprogram) {
+      error = "ENTRY may appear only in a subroutine or function"_err_en_US;
+    } else if (!(entryScope->parent().IsGlobal() ||
+                   entryScope->parent().IsModule() ||
+                   entryScope->parent().IsSubmodule())) {
+      error = "ENTRY may not appear in an internal subprogram"_err_en_US;
+    } else if (FindSeparateModuleSubprogramInterface(subprogram)) {
+      error = "ENTRY may not appear in a separate module procedure"_err_en_US;
+    } else if (subprogramDetails && details.isFunction() &&
+        subprogramDetails->isFunction()) {
+      auto result{FunctionResult::Characterize(
+          details.result(), context_.intrinsics())};
+      auto subpResult{FunctionResult::Characterize(
+          subprogramDetails->result(), context_.intrinsics())};
+      if (result && subpResult && *result != *subpResult &&
+          (!IsResultOkToDiffer(*result) || !IsResultOkToDiffer(*subpResult))) {
+        error =
+            "Result of ENTRY is not compatible with result of containing function"_err_en_US;
+      }
+    }
+    if (error) {
+      if (auto *msg{messages_.Say(symbol.name(), *error)}) {
+        if (subprogram) {
+          msg->Attach(subprogram->name(), "Containing subprogram"_en_US);
+        }
+      }
     }
   }
 }
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index 182b90bdbd1f..b8e52d9a9802 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -1889,7 +1889,7 @@ void ExpressionAnalyzer::CheckForBadRecursion(
       if (proc.attrs().test(semantics::Attr::NON_RECURSIVE)) {  // 15.6.2.1(3)
         msg = Say("NON_RECURSIVE procedure '%s' cannot call itself"_err_en_US,
             callSite);
-      } else if (IsAssumedLengthExternalCharacterFunction(proc)) {
+      } else if (IsAssumedLengthCharacter(proc) && IsExternal(proc)) {
         msg = Say(  // 15.6.2.1(3)
             "Assumed-length CHARACTER(*) function '%s' cannot call itself"_err_en_US,
             callSite);
@@ -2046,7 +2046,8 @@ static bool IsExternalCalledImplicitly(
   if (const auto *symbol{proc.GetSymbol()}) {
     return symbol->has<semantics::SubprogramDetails>() &&
         symbol->owner().IsGlobal() &&
-        !symbol->scope()->sourceRange().Contains(callSite);
+        (!symbol->scope() /*ENTRY*/ ||
+            !symbol->scope()->sourceRange().Contains(callSite));
   } else {
     return false;
   }
diff --git a/lib/Semantics/mod-file.cpp b/lib/Semantics/mod-file.cpp
index 5c457321cc68..ba1df939fd74 100644
--- a/lib/Semantics/mod-file.cpp
+++ b/lib/Semantics/mod-file.cpp
@@ -69,8 +69,8 @@ static std::string CheckSum(const std::string_view &);
 // Collect symbols needed for a subprogram interface
 class SubprogramSymbolCollector {
 public:
-  SubprogramSymbolCollector(const Symbol &symbol)
-    : symbol_{symbol}, scope_{DEREF(symbol.scope())} {}
+  SubprogramSymbolCollector(const Symbol &symbol, const Scope &scope)
+    : symbol_{symbol}, scope_{scope} {}
   const SymbolVector &symbols() const { return need_; }
   const std::set<SourceName> &imports() const { return imports_; }
   void Collect();
@@ -335,12 +335,14 @@ void ModFileWriter::PutSubprogram(const Symbol &symbol) {
   }
   os << '\n';
 
-  // walk symbols, collect ones needed
-  ModFileWriter writer{context_};
+  // walk symbols, collect ones needed for interface
+  const Scope &scope{
+      details.entryScope() ? *details.entryScope() : DEREF(symbol.scope())};
+  SubprogramSymbolCollector collector{symbol, scope};
+  collector.Collect();
   std::string typeBindingsBuf;
   llvm::raw_string_ostream typeBindings{typeBindingsBuf};
-  SubprogramSymbolCollector collector{symbol};
-  collector.Collect();
+  ModFileWriter writer{context_};
   for (const Symbol &need : collector.symbols()) {
     writer.PutSymbol(typeBindings, need);
   }
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index f41a6fb72a33..22f37a0347ec 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -43,7 +43,7 @@ namespace Fortran::semantics {
 
 using namespace parser::literals;
 
-template<typename T> using Indirection = common::Indirection<T>;
+template <typename T> using Indirection = common::Indirection<T>;
 using Message = parser::Message;
 using Messages = parser::Messages;
 using MessageFixedText = parser::MessageFixedText;
@@ -58,7 +58,7 @@ class ResolveNamesVisitor;
 class ImplicitRules {
 public:
   ImplicitRules(SemanticsContext &context, ImplicitRules *parent)
-    : parent_{parent}, context_{context} {
+      : parent_{parent}, context_{context} {
     inheritFromParent_ = parent != nullptr;
   }
   bool isImplicitNoneType() const;
@@ -78,7 +78,7 @@ class ImplicitRules {
 
   ImplicitRules *parent_;
   SemanticsContext &context_;
-  bool inheritFromParent_{false};  // look in parent if not specified here
+  bool inheritFromParent_{false}; // look in parent if not specified here
   bool isImplicitNoneType_{false};
   bool isImplicitNoneExternal_{false};
   // map_ contains the mapping between letters and types that were defined
@@ -114,7 +114,7 @@ class MessageHandler {
   // Emit a message about a SourceName
   Message &Say(const SourceName &, MessageFixedText &&);
   // Emit a formatted message associated with a source location.
-  template<typename... A>
+  template <typename... A>
   Message &Say(const SourceName &source, MessageFixedText &&msg, A &&... args) {
     return context_->Say(source, std::move(msg), std::forward<A>(args)...);
   }
@@ -142,8 +142,9 @@ class BaseVisitor {
   BaseVisitor() { DIE("BaseVisitor: default-constructed"); }
   BaseVisitor(
       SemanticsContext &c, ResolveNamesVisitor &v, ImplicitRulesMap &rules)
-    : implicitRulesMap_{&rules}, this_{&v}, context_{&c}, messageHandler_{c} {}
-  template<typename T> void Walk(const T &);
+      : implicitRulesMap_{&rules}, this_{&v}, context_{&c}, messageHandler_{c} {
+  }
+  template <typename T> void Walk(const T &);
 
   MessageHandler &messageHandler() { return messageHandler_; }
   const std::optional<SourceName> &currStmtSource() {
@@ -158,15 +159,15 @@ class BaseVisitor {
   // It is not in any scope and always has MiscDetails.
   void MakePlaceholder(const parser::Name &, MiscDetails::Kind);
 
-  template<typename T> common::IfNoLvalue<T, T> FoldExpr(T &&expr) {
+  template <typename T> common::IfNoLvalue<T, T> FoldExpr(T &&expr) {
     return evaluate::Fold(GetFoldingContext(), std::move(expr));
   }
 
-  template<typename T> MaybeExpr EvaluateExpr(const T &expr) {
+  template <typename T> MaybeExpr EvaluateExpr(const T &expr) {
     return FoldExpr(AnalyzeExpr(*context_, expr));
   }
 
-  template<typename T>
+  template <typename T>
   MaybeExpr EvaluateConvertedExpr(
       const Symbol &symbol, const T &expr, parser::CharBlock source) {
     if (context().HasError(symbol)) {
@@ -193,7 +194,7 @@ class BaseVisitor {
     return FoldExpr(std::move(*converted));
   }
 
-  template<typename T> MaybeIntExpr EvaluateIntExpr(const T &expr) {
+  template <typename T> MaybeIntExpr EvaluateIntExpr(const T &expr) {
     if (MaybeExpr maybeExpr{EvaluateExpr(expr)}) {
       if (auto *intExpr{evaluate::UnwrapExpr<SomeIntExpr>(*maybeExpr)}) {
         return std::move(*intExpr);
@@ -202,7 +203,7 @@ class BaseVisitor {
     return std::nullopt;
   }
 
-  template<typename T>
+  template <typename T>
   MaybeSubscriptIntExpr EvaluateSubscriptIntExpr(const T &expr) {
     if (MaybeIntExpr maybeIntExpr{EvaluateIntExpr(expr)}) {
       return FoldExpr(evaluate::ConvertToType<evaluate::SubscriptInteger>(
@@ -212,10 +213,10 @@ class BaseVisitor {
     }
   }
 
-  template<typename... A> Message &Say(A &&... args) {
+  template <typename... A> Message &Say(A &&... args) {
     return messageHandler_.Say(std::forward<A>(args)...);
   }
-  template<typename... A>
+  template <typename... A>
   Message &Say(
       const parser::Name &name, MessageFixedText &&text, const A &... args) {
     return messageHandler_.Say(name.source, std::move(text), args...);
@@ -233,7 +234,7 @@ class BaseVisitor {
 // Provide Post methods to collect attributes into a member variable.
 class AttrsVisitor : public virtual BaseVisitor {
 public:
-  bool BeginAttrs();  // always returns true
+  bool BeginAttrs(); // always returns true
   Attrs GetAttrs();
   Attrs EndAttrs();
   bool SetPassNameOn(Symbol &);
@@ -281,18 +282,23 @@ class AttrsVisitor : public virtual BaseVisitor {
 
   Attr AccessSpecToAttr(const parser::AccessSpec &x) {
     switch (x.v) {
-    case parser::AccessSpec::Kind::Public: return Attr::PUBLIC;
-    case parser::AccessSpec::Kind::Private: return Attr::PRIVATE;
+    case parser::AccessSpec::Kind::Public:
+      return Attr::PUBLIC;
+    case parser::AccessSpec::Kind::Private:
+      return Attr::PRIVATE;
     }
-    common::die("unreachable");  // suppress g++ warning
+    common::die("unreachable"); // suppress g++ warning
   }
   Attr IntentSpecToAttr(const parser::IntentSpec &x) {
     switch (x.v) {
-    case parser::IntentSpec::Intent::In: return Attr::INTENT_IN;
-    case parser::IntentSpec::Intent::Out: return Attr::INTENT_OUT;
-    case parser::IntentSpec::Intent::InOut: return Attr::INTENT_INOUT;
+    case parser::IntentSpec::Intent::In:
+      return Attr::INTENT_IN;
+    case parser::IntentSpec::Intent::Out:
+      return Attr::INTENT_OUT;
+    case parser::IntentSpec::Intent::InOut:
+      return Attr::INTENT_INOUT;
     }
-    common::die("unreachable");  // suppress g++ warning
+    common::die("unreachable"); // suppress g++ warning
   }
 
 private:
@@ -300,8 +306,8 @@ class AttrsVisitor : public virtual BaseVisitor {
   bool HaveAttrConflict(Attr, Attr, Attr);
   bool IsConflictingAttr(Attr);
 
-  MaybeExpr bindName_;  // from BIND(C, NAME="...")
-  std::optional<SourceName> passName_;  // from PASS(...)
+  MaybeExpr bindName_; // from BIND(C, NAME="...")
+  std::optional<SourceName> passName_; // from PASS(...)
 };
 
 // Find and create types from declaration-type-spec nodes.
@@ -319,7 +325,7 @@ class DeclTypeSpecVisitor : public AttrsVisitor {
 
 protected:
   struct State {
-    bool expectDeclTypeSpec{false};  // should see decl-type-spec only when true
+    bool expectDeclTypeSpec{false}; // should see decl-type-spec only when true
     const DeclTypeSpec *declTypeSpec{nullptr};
     struct {
       DerivedTypeSpec *type{nullptr};
@@ -336,7 +342,7 @@ class DeclTypeSpecVisitor : public AttrsVisitor {
   }
 
   // Walk the parse tree of a type spec and return the DeclTypeSpec for it.
-  template<typename T>
+  template <typename T>
   const DeclTypeSpec *ProcessTypeSpec(const T &x, bool allowForward = false) {
     auto restorer{common::ScopedSet(state_, State{})};
     set_allowForwardReferenceToDerivedType(allowForward);
@@ -446,6 +452,8 @@ class ScopeHandler : public ImplicitRulesVisitor {
 
   Scope &currScope() { return DEREF(currScope_); }
   // The enclosing scope, skipping blocks and derived types.
+  // TODO: Will return the scope of a FORALL or implied DO loop; is this ok?
+  // If not, should call FindProgramUnitContaining() instead.
   Scope &InclusiveScope();
 
   // Create a new scope and push it on the scope stack.
@@ -454,12 +462,12 @@ class ScopeHandler : public ImplicitRulesVisitor {
   void PopScope();
   void SetScope(Scope &);
 
-  template<typename T> bool Pre(const parser::Statement<T> &x) {
+  template <typename T> bool Pre(const parser::Statement<T> &x) {
     messageHandler().set_currStmtSource(x.source);
     currScope_->AddSourceRange(x.source);
     return true;
   }
-  template<typename T> void Post(const parser::Statement<T> &) {
+  template <typename T> void Post(const parser::Statement<T> &) {
     messageHandler().set_currStmtSource(std::nullopt);
   }
 
@@ -500,19 +508,19 @@ class ScopeHandler : public ImplicitRulesVisitor {
   Symbol &MakeSymbol(const SourceName &, Attrs = Attrs{});
   Symbol &MakeSymbol(const parser::Name &, Attrs = Attrs{});
 
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const parser::Name &name, D &&details) {
     return MakeSymbol(name, Attrs{}, std::move(details));
   }
 
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const parser::Name &name, const Attrs &attrs, D &&details) {
     return Resolve(name, MakeSymbol(name.source, attrs, std::move(details)));
   }
 
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const SourceName &name, const Attrs &attrs, D &&details) {
     // Note: don't use FindSymbol here. If this is a derived type scope,
@@ -633,10 +641,10 @@ class InterfaceVisitor : public virtual ScopeHandler {
   // A new GenericInfo is pushed for each interface block and generic stmt
   struct GenericInfo {
     GenericInfo(bool isInterface, bool isAbstract = false)
-      : isInterface{isInterface}, isAbstract{isAbstract} {}
-    bool isInterface;  // in interface block
-    bool isAbstract;  // in abstract interface block
-    Symbol *symbol{nullptr};  // the generic symbol being defined
+        : isInterface{isInterface}, isAbstract{isAbstract} {}
+    bool isInterface; // in interface block
+    bool isAbstract; // in abstract interface block
+    Symbol *symbol{nullptr}; // the generic symbol being defined
   };
   std::stack<GenericInfo> genericInfo_;
   const GenericInfo &GetGenericInfo() const { return genericInfo_.top(); }
@@ -658,6 +666,8 @@ class SubprogramVisitor : public virtual ScopeHandler, public InterfaceVisitor {
   void Post(const parser::SubroutineStmt &);
   bool Pre(const parser::FunctionStmt &);
   void Post(const parser::FunctionStmt &);
+  bool Pre(const parser::EntryStmt &);
+  void Post(const parser::EntryStmt &);
   bool Pre(const parser::InterfaceBody::Subroutine &);
   void Post(const parser::InterfaceBody::Subroutine &);
   bool Pre(const parser::InterfaceBody::Function &);
@@ -675,6 +685,7 @@ class SubprogramVisitor : public virtual ScopeHandler, public InterfaceVisitor {
 protected:
   // Set when we see a stmt function that is really an array element assignment
   bool badStmtFuncFound_{false};
+  bool inExecutionPart_{false};
 
 private:
   // Info about the current function: parse tree of the type in the PrefixSpec;
@@ -687,6 +698,7 @@ class SubprogramVisitor : public virtual ScopeHandler, public InterfaceVisitor {
   } funcInfo_;
 
   // Create a subprogram symbol in the current scope and push a new scope.
+  void CheckExtantExternal(const parser::Name &, Symbol::Flag);
   Symbol &PushSubprogramScope(const parser::Name &, Symbol::Flag);
   Symbol *GetSpecificFromGeneric(const parser::Name &);
   SubprogramDetails &PostSubprogramStmt(const parser::Name &);
@@ -762,7 +774,7 @@ class DeclarationVisitor : public ArraySpecVisitor,
   void Post(const parser::ComponentDecl &);
   bool Pre(const parser::ProcedureDeclarationStmt &);
   void Post(const parser::ProcedureDeclarationStmt &);
-  bool Pre(const parser::DataComponentDefStmt &);  // returns false
+  bool Pre(const parser::DataComponentDefStmt &); // returns false
   bool Pre(const parser::ProcComponentDefStmt &);
   void Post(const parser::ProcComponentDefStmt &);
   bool Pre(const parser::ProcPointerInit &);
@@ -843,25 +855,25 @@ class DeclarationVisitor : public ArraySpecVisitor,
   } charInfo_;
   // Info about current derived type while walking DerivedTypeDef
   struct {
-    const parser::Name *extends{nullptr};  // EXTENDS(name)
-    bool privateComps{false};  // components are private by default
-    bool privateBindings{false};  // bindings are private by default
-    bool sawContains{false};  // currently processing bindings
-    bool sequence{false};  // is a sequence type
-    const Symbol *type{nullptr};  // derived type being defined
+    const parser::Name *extends{nullptr}; // EXTENDS(name)
+    bool privateComps{false}; // components are private by default
+    bool privateBindings{false}; // bindings are private by default
+    bool sawContains{false}; // currently processing bindings
+    bool sequence{false}; // is a sequence type
+    const Symbol *type{nullptr}; // derived type being defined
   } derivedTypeInfo_;
   // Collect equivalence sets and process at end of specification part
   std::vector<const std::list<parser::EquivalenceObject> *> equivalenceSets_;
   // Info about common blocks in the current scope
   struct {
-    Symbol *curr{nullptr};  // common block currently being processed
-    std::set<SourceName> names;  // names in any common block of scope
+    Symbol *curr{nullptr}; // common block currently being processed
+    std::set<SourceName> names; // names in any common block of scope
   } commonBlockInfo_;
   // Info about about SAVE statements and attributes in current scope
   struct {
-    std::optional<SourceName> saveAll;  // "SAVE" without entity list
-    std::set<SourceName> entities;  // names of entities with save attr
-    std::set<SourceName> commons;  // names of common blocks with save attr
+    std::optional<SourceName> saveAll; // "SAVE" without entity list
+    std::set<SourceName> entities; // names of entities with save attr
+    std::set<SourceName> commons; // names of common blocks with save attr
   } saveInfo_;
   // In a ProcedureDeclarationStmt or ProcComponentDefStmt, this is
   // the interface name, if any.
@@ -903,7 +915,7 @@ class DeclarationVisitor : public ArraySpecVisitor,
 
   // Declare an object or procedure entity.
   // T is one of: EntityDetails, ObjectEntityDetails, ProcEntityDetails
-  template<typename T>
+  template <typename T>
   Symbol &DeclareEntity(const parser::Name &name, Attrs attrs) {
     Symbol &symbol{MakeSymbol(name, attrs)};
     if (symbol.has<T>()) {
@@ -987,7 +999,7 @@ class ConstructVisitor : public virtual DeclarationVisitor {
   bool Pre(const parser::ForallConstructStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::CriticalStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::LabelDoStmt &) {
-    return false;  // error recovery
+    return false; // error recovery
   }
   bool Pre(const parser::NonLabelDoStmt &x) { return CheckDef(x.t); }
   bool Pre(const parser::IfThenStmt &x) { return CheckDef(x.t); }
@@ -1024,7 +1036,7 @@ class ConstructVisitor : public virtual DeclarationVisitor {
   struct Selector {
     Selector() {}
     Selector(const SourceName &source, MaybeExpr &&expr)
-      : source{source}, expr{std::move(expr)} {}
+        : source{source}, expr{std::move(expr)} {}
     operator bool() const { return expr.has_value(); }
     parser::CharBlock source;
     MaybeExpr expr;
@@ -1036,10 +1048,10 @@ class ConstructVisitor : public virtual DeclarationVisitor {
   };
   std::vector<Association> associationStack_;
 
-  template<typename T> bool CheckDef(const T &t) {
+  template <typename T> bool CheckDef(const T &t) {
     return CheckDef(std::get<std::optional<parser::Name>>(t));
   }
-  template<typename T> void CheckRef(const T &t) {
+  template <typename T> void CheckRef(const T &t) {
     CheckRef(std::get<std::optional<parser::Name>>(t));
   }
   bool CheckDef(const std::optional<parser::Name> &);
@@ -1128,8 +1140,10 @@ bool OmpVisitor::NeedsScope(const parser::OpenMPBlockConstruct &x) {
   switch (beginDir.v) {
   case parser::OmpBlockDirective::Directive::TargetData:
   case parser::OmpBlockDirective::Directive::Master:
-  case parser::OmpBlockDirective::Directive::Ordered: return false;
-  default: return true;
+  case parser::OmpBlockDirective::Directive::Ordered:
+    return false;
+  default:
+    return true;
   }
 }
 
@@ -1156,12 +1170,12 @@ class OmpAttributeVisitor {
 public:
   explicit OmpAttributeVisitor(
       SemanticsContext &context, ResolveNamesVisitor &resolver)
-    : context_{context}, resolver_{resolver} {}
+      : context_{context}, resolver_{resolver} {}
 
-  template<typename A> void Walk(const A &x) { parser::Walk(x, *this); }
+  template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
 
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {}
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
 
   bool Pre(const parser::SpecificationPart &x) {
     Walk(std::get<std::list<parser::OpenMPDeclarativeConstruct>>(x.t));
@@ -1211,7 +1225,7 @@ class OmpAttributeVisitor {
 private:
   struct OmpContext {
     OmpContext(const parser::CharBlock &source, OmpDirective d, Scope &s)
-      : directiveSource{source}, directive{d}, scope{s} {}
+        : directiveSource{source}, directive{d}, scope{s} {}
     parser::CharBlock directiveSource;
     OmpDirective directive;
     Scope &scope;
@@ -1312,11 +1326,11 @@ class OmpAttributeVisitor {
   Symbol *DeclareOrMarkOtherAccessEntity(Symbol &, Symbol::Flag);
   void CheckMultipleAppearances(
       const parser::Name &, const Symbol &, Symbol::Flag);
-  SymbolSet dataSharingAttributeObjects_;  // on one directive
+  SymbolSet dataSharingAttributeObjects_; // on one directive
 
   SemanticsContext &context_;
   ResolveNamesVisitor &resolver_;
-  std::vector<OmpContext> ompContext_;  // used as a stack
+  std::vector<OmpContext> ompContext_; // used as a stack
 };
 
 // Walk the parse tree and resolve names to symbols.
@@ -1345,13 +1359,13 @@ class ResolveNamesVisitor : public virtual ScopeHandler,
   using SubprogramVisitor::Pre;
 
   ResolveNamesVisitor(SemanticsContext &context, ImplicitRulesMap &rules)
-    : BaseVisitor{context, *this, rules} {
+      : BaseVisitor{context, *this, rules} {
     PushScope(context.globalScope());
   }
 
   // Default action for a parse tree node is to visit children.
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
 
   bool Pre(const parser::SpecificationPart &);
   void Post(const parser::Program &);
@@ -1360,7 +1374,7 @@ class ResolveNamesVisitor : public virtual ScopeHandler,
   void Post(const parser::AllocateObject &);
   bool Pre(const parser::PointerAssignmentStmt &);
   void Post(const parser::Designator &);
-  template<typename A, typename B>
+  template <typename A, typename B>
   void Post(const parser::LoopBounds<A, B> &x) {
     ResolveName(*parser::Unwrap<parser::Name>(x.name));
   }
@@ -1417,7 +1431,7 @@ bool ImplicitRules::isImplicitNoneType() const {
   } else if (map_.empty() && inheritFromParent_) {
     return parent_->isImplicitNoneType();
   } else {
-    return false;  // default if not specified
+    return false; // default if not specified
   }
 }
 
@@ -1427,7 +1441,7 @@ bool ImplicitRules::isImplicitNoneExternal() const {
   } else if (inheritFromParent_) {
     return parent_->isImplicitNoneExternal();
   } else {
-    return false;  // default if not specified
+    return false; // default if not specified
   }
 }
 
@@ -1465,10 +1479,14 @@ void ImplicitRules::SetTypeMapping(const DeclTypeSpec &type,
 // Return '\0' for the char after 'z'.
 char ImplicitRules::Incr(char ch) {
   switch (ch) {
-  case 'i': return 'j';
-  case 'r': return 's';
-  case 'z': return '\0';
-  default: return ch + 1;
+  case 'i':
+    return 'j';
+  case 'r':
+    return 's';
+  case 'z':
+    return '\0';
+  default:
+    return ch + 1;
   }
 }
 
@@ -1491,7 +1509,7 @@ void ShowImplicitRule(
   }
 }
 
-template<typename T> void BaseVisitor::Walk(const T &x) {
+template <typename T> void BaseVisitor::Walk(const T &x) {
   parser::Walk(x, *this_);
 }
 
@@ -1657,14 +1675,17 @@ void DeclTypeSpecVisitor::Post(const parser::TypeSpec &typeSpec) {
     switch (spec->category()) {
     case DeclTypeSpec::Numeric:
     case DeclTypeSpec::Logical:
-    case DeclTypeSpec::Character: typeSpec.declTypeSpec = spec; break;
+    case DeclTypeSpec::Character:
+      typeSpec.declTypeSpec = spec;
+      break;
     case DeclTypeSpec::TypeDerived:
       if (const DerivedTypeSpec * derived{spec->AsDerived()}) {
-        CheckForAbstractType(derived->typeSymbol());  // C703
+        CheckForAbstractType(derived->typeSymbol()); // C703
         typeSpec.declTypeSpec = spec;
       }
       break;
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
   }
 }
@@ -2042,7 +2063,7 @@ Symbol &ScopeHandler::MakeSymbol(
     return *symbol;
   } else {
     const auto pair{scope.try_emplace(name, attrs, UnknownDetails{})};
-    CHECK(pair.second);  // name was not found, so must be able to add
+    CHECK(pair.second); // name was not found, so must be able to add
     return *pair.first->second;
   }
 }
@@ -2184,7 +2205,7 @@ const DeclTypeSpec &ScopeHandler::MakeLogicalType(
 void ScopeHandler::MakeExternal(Symbol &symbol) {
   if (!symbol.attrs().test(Attr::EXTERNAL)) {
     symbol.attrs().set(Attr::EXTERNAL);
-    if (symbol.attrs().test(Attr::INTRINSIC)) {  // C840
+    if (symbol.attrs().test(Attr::INTRINSIC)) { // C840
       Say(symbol.name(),
           "Symbol '%s' cannot have both EXTERNAL and INTRINSIC attributes"_err_en_US,
           symbol.name());
@@ -2282,7 +2303,7 @@ ModuleVisitor::SymbolRename ModuleVisitor::AddUse(
 ModuleVisitor::SymbolRename ModuleVisitor::AddUse(
     const SourceName &localName, const SourceName &useName, Symbol *useSymbol) {
   if (!useModuleScope_) {
-    return {};  // error occurred finding module
+    return {}; // error occurred finding module
   }
   if (!useSymbol) {
     Say(useName,
@@ -2400,7 +2421,7 @@ bool ModuleVisitor::BeginSubmodule(
   if (!parentScope) {
     return false;
   }
-  PushScope(*parentScope);  // submodule is hosted in parent
+  PushScope(*parentScope); // submodule is hosted in parent
   BeginModule(name, true);
   if (!ancestor->AddSubmodule(name.source, currScope())) {
     Say(name, "Module '%s' already has a submodule named '%s'"_err_en_US,
@@ -2432,7 +2453,7 @@ Scope *ModuleVisitor::FindModule(const parser::Name &name, Scope *ancestor) {
     Say(name, "'%s' is not a module"_err_en_US);
     return nullptr;
   }
-  if (DoesScopeContain(scope, currScope())) {  // 14.2.2(1)
+  if (DoesScopeContain(scope, currScope())) { // 14.2.2(1)
     Say(name, "Module '%s' cannot USE itself"_err_en_US);
   }
   Resolve(name, scope->symbol());
@@ -2519,7 +2540,7 @@ void InterfaceVisitor::AddSpecificProcs(
 // this generic interface. Resolve those names to symbols.
 void InterfaceVisitor::ResolveSpecificsInGeneric(Symbol &generic) {
   auto &details{generic.get<GenericDetails>()};
-  std::set<SourceName> namesSeen;  // to check for duplicate names
+  std::set<SourceName> namesSeen; // to check for duplicate names
   for (const Symbol &symbol : details.specificProcs()) {
     namesSeen.insert(symbol.name());
   }
@@ -2597,7 +2618,7 @@ void InterfaceVisitor::CheckGenericProcedures(Symbol &generic) {
   const Symbol &firstSpecific{specifics.front()};
   bool isFunction{firstSpecific.test(Symbol::Flag::Function)};
   for (const Symbol &specific : specifics) {
-    if (isFunction != specific.test(Symbol::Flag::Function)) {  // C1514
+    if (isFunction != specific.test(Symbol::Flag::Function)) { // C1514
       auto &msg{Say(generic.name(),
           "Generic interface '%s' has both a function and a subroutine"_err_en_US)};
       if (isFunction) {
@@ -2633,14 +2654,14 @@ bool SubprogramVisitor::HandleStmtFunction(const parser::StmtFunctionStmt &x) {
     }
     // TODO: check that attrs are compatible with stmt func
     resultType = details->type();
-    symbol->details() = UnknownDetails{};  // will be replaced below
+    symbol->details() = UnknownDetails{}; // will be replaced below
   }
   if (badStmtFuncFound_) {
     Say(name, "'%s' has not been declared as an array"_err_en_US);
     return true;
   }
   auto &symbol{PushSubprogramScope(name, Symbol::Flag::Function)};
-  EraseSymbol(symbol);  // removes symbol added by PushSubprogramScope
+  EraseSymbol(symbol); // removes symbol added by PushSubprogramScope
   auto &details{symbol.get<SubprogramDetails>()};
   for (const auto &dummyName : std::get<std::list<parser::Name>>(x.t)) {
     ObjectEntityDetails dummyDetails{true};
@@ -2684,7 +2705,7 @@ bool SubprogramVisitor::Pre(const parser::Suffix &suffix) {
 bool SubprogramVisitor::Pre(const parser::PrefixSpec &x) {
   // Save this to process after UseStmt and ImplicitPart
   if (const auto *parsedType{std::get_if<parser::DeclarationTypeSpec>(&x.u)}) {
-    if (funcInfo_.parsedType) {  // C1543
+    if (funcInfo_.parsedType) { // C1543
       Say(currStmtSource().value(),
           "FUNCTION prefix cannot specify the type more than once"_err_en_US);
       return false;
@@ -2732,6 +2753,7 @@ bool SubprogramVisitor::Pre(const parser::SubroutineStmt &) {
 bool SubprogramVisitor::Pre(const parser::FunctionStmt &) {
   return BeginAttrs();
 }
+bool SubprogramVisitor::Pre(const parser::EntryStmt &) { return BeginAttrs(); }
 
 void SubprogramVisitor::Post(const parser::SubroutineStmt &stmt) {
   const auto &name{std::get<parser::Name>(stmt.t)};
@@ -2758,7 +2780,7 @@ void SubprogramVisitor::Post(const parser::FunctionStmt &stmt) {
     // Note that RESULT is ignored if it has the same name as the function.
     funcResultName = funcInfo_.resultName;
   } else {
-    EraseSymbol(name);  // was added by PushSubprogramScope
+    EraseSymbol(name); // was added by PushSubprogramScope
     funcResultName = &name;
   }
   // add function result to function scope
@@ -2768,7 +2790,7 @@ void SubprogramVisitor::Post(const parser::FunctionStmt &stmt) {
       &MakeSymbol(*funcResultName, std::move(funcResultDetails));
   details.set_result(*funcInfo_.resultSymbol);
 
-  // C1560. TODO also enforce on entry names when entry implemented
+  // C1560.
   if (funcInfo_.resultName && funcInfo_.resultName->source == name.source) {
     Say(funcInfo_.resultName->source,
         "The function name should not appear in RESULT, references to '%s' "
@@ -2781,7 +2803,10 @@ void SubprogramVisitor::Post(const parser::FunctionStmt &stmt) {
     // should be resolved to avoid internal errors.
     Resolve(*funcInfo_.resultName, funcInfo_.resultSymbol);
   }
-  name.symbol = currScope().symbol();  // must not be function result symbol
+  name.symbol = currScope().symbol(); // must not be function result symbol
+  // Clear the RESULT() name now in case an ENTRY statement in the implicit-part
+  // has a RESULT() suffix.
+  funcInfo_.resultName = nullptr;
 }
 
 SubprogramDetails &SubprogramVisitor::PostSubprogramStmt(
@@ -2796,13 +2821,160 @@ SubprogramDetails &SubprogramVisitor::PostSubprogramStmt(
   return symbol.get<SubprogramDetails>();
 }
 
+void SubprogramVisitor::Post(const parser::EntryStmt &stmt) {
+  auto attrs{EndAttrs()}; // needs to be called even if early return
+  Scope &inclusiveScope{InclusiveScope()};
+  const Symbol *subprogram{inclusiveScope.symbol()};
+  if (!subprogram) {
+    CHECK(context().AnyFatalError());
+    return;
+  }
+  const auto &name{std::get<parser::Name>(stmt.t)};
+  const auto *parentDetails{subprogram->detailsIf<SubprogramDetails>()};
+  bool inFunction{parentDetails && parentDetails->isFunction()};
+  const parser::Name *resultName{funcInfo_.resultName};
+  if (resultName) { // RESULT(result) is present
+    funcInfo_.resultName = nullptr;
+    if (!inFunction) {
+      Say2(resultName->source,
+          "RESULT(%s) may appear only in a function"_err_en_US,
+          subprogram->name(), "Containing subprogram"_en_US);
+    } else if (resultName->source == subprogram->name()) { // C1574
+      Say2(resultName->source,
+          "RESULT(%s) may not have the same name as the function"_err_en_US,
+          subprogram->name(), "Containing function"_en_US);
+    } else if (const Symbol *
+        symbol{FindSymbol(inclusiveScope.parent(), *resultName)}) { // C1574
+      if (const auto *details{symbol->detailsIf<SubprogramDetails>()}) {
+        if (details->entryScope() == &inclusiveScope) {
+          Say2(resultName->source,
+              "RESULT(%s) may not have the same name as an ENTRY in the function"_err_en_US,
+              symbol->name(), "Conflicting ENTRY"_en_US);
+        }
+      }
+    }
+    if (Symbol * symbol{FindSymbol(name)}) { // C1570
+      // When RESULT() appears, ENTRY name can't have been already declared
+      if (inclusiveScope.Contains(symbol->owner())) {
+        Say2(name,
+            "ENTRY name '%s' may not be declared when RESULT() is present"_err_en_US,
+            *symbol, "Previous declaration of '%s'"_en_US);
+      }
+    }
+    if (resultName->source == name.source) {
+      // ignore RESULT() hereafter when it's the same name as the ENTRY
+      resultName = nullptr;
+    }
+  }
+  SubprogramDetails entryDetails;
+  entryDetails.set_entryScope(inclusiveScope);
+  if (inFunction) {
+    // Create the entity to hold the function result, if necessary.
+    Symbol *resultSymbol{nullptr};
+    auto &effectiveResultName{*(resultName ? resultName : &name)};
+    resultSymbol = FindInScope(currScope(), effectiveResultName);
+    if (resultSymbol) { // C1574
+      std::visit(
+          common::visitors{[](EntityDetails &x) { x.set_funcResult(true); },
+              [](ObjectEntityDetails &x) { x.set_funcResult(true); },
+              [](ProcEntityDetails &x) { x.set_funcResult(true); },
+              [&](const auto &) {
+                Say2(effectiveResultName.source,
+                    "'%s' was previously declared as an item that may not be used as a function result"_err_en_US,
+                    resultSymbol->name(), "Previous declaration of '%s'"_en_US);
+              }},
+          resultSymbol->details());
+    } else if (inExecutionPart_) {
+      ObjectEntityDetails entity;
+      entity.set_funcResult(true);
+      resultSymbol = &MakeSymbol(effectiveResultName, std::move(entity));
+      ApplyImplicitRules(*resultSymbol);
+    } else {
+      EntityDetails entity;
+      entity.set_funcResult(true);
+      resultSymbol = &MakeSymbol(effectiveResultName, std::move(entity));
+    }
+    if (!resultName) {
+      name.symbol = nullptr; // symbol will be used for entry point below
+    }
+    entryDetails.set_result(*resultSymbol);
+  }
+
+  for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
+    if (const auto *dummyName{std::get_if<parser::Name>(&dummyArg.u)}) {
+      Symbol *dummy{FindSymbol(*dummyName)};
+      if (dummy) {
+        std::visit(
+            common::visitors{[](EntityDetails &x) { x.set_isDummy(); },
+                [](ObjectEntityDetails &x) { x.set_isDummy(); },
+                [](ProcEntityDetails &x) { x.set_isDummy(); },
+                [&](const auto &) {
+                  Say2(dummyName->source,
+                      "ENTRY dummy argument '%s' is previously declared as an item that may not be used as a dummy argument"_err_en_US,
+                      dummy->name(), "Previous declaration of '%s'"_en_US);
+                }},
+            dummy->details());
+      } else {
+        dummy = &MakeSymbol(*dummyName, EntityDetails(true));
+      }
+      entryDetails.add_dummyArg(*dummy);
+    } else {
+      if (inFunction) { // C1573
+        Say(name,
+            "ENTRY in a function may not have an alternate return dummy argument"_err_en_US);
+        break;
+      }
+      entryDetails.add_alternateReturn();
+    }
+  }
+
+  Symbol::Flag subpFlag{
+      inFunction ? Symbol::Flag::Function : Symbol::Flag::Subroutine};
+  CheckExtantExternal(name, subpFlag);
+  Scope &outer{inclusiveScope.parent()}; // global or module scope
+  if (Symbol * extant{FindSymbol(outer, name)}) {
+    if (extant->has<ProcEntityDetails>()) {
+      if (!extant->test(subpFlag)) {
+        Say2(name,
+            subpFlag == Symbol::Flag::Function
+                ? "'%s' was previously called as a subroutine"_err_en_US
+                : "'%s' was previously called as a function"_err_en_US,
+            *extant, "Previous call of '%s'"_en_US);
+      }
+      if (extant->attrs().test(Attr::PRIVATE)) {
+        attrs.set(Attr::PRIVATE);
+      }
+      outer.erase(extant->name());
+    } else {
+      if (outer.IsGlobal()) {
+        Say2(name, "'%s' is already defined as a global identifier"_err_en_US,
+            *extant, "Previous definition of '%s'"_en_US);
+      } else {
+        SayAlreadyDeclared(name, *extant);
+      }
+      return;
+    }
+  }
+  if (outer.IsModule() && !attrs.test(Attr::PRIVATE)) {
+    attrs.set(Attr::PUBLIC);
+  }
+  Symbol &entrySymbol{MakeSymbol(outer, name.source, attrs)};
+  entrySymbol.set_details(std::move(entryDetails));
+  if (outer.IsGlobal()) {
+    MakeExternal(entrySymbol);
+  }
+  SetBindNameOn(entrySymbol);
+  entrySymbol.set(subpFlag);
+  Resolve(name, entrySymbol);
+}
+
 // A subprogram declared with MODULE PROCEDURE
 bool SubprogramVisitor::BeginMpSubprogram(const parser::Name &name) {
   auto *symbol{FindSymbol(name)};
   if (symbol && symbol->has<SubprogramNameDetails>()) {
     symbol = FindSymbol(currScope().parent(), name);
   }
-  if (!symbol || !symbol->IsSeparateModuleProc()) {
+  if (!IsSeparateModuleProcedureInterface(symbol)) {
     Say(name, "'%s' was not declared a separate module procedure"_err_en_US);
     return false;
   }
@@ -2831,12 +3003,11 @@ bool SubprogramVisitor::BeginMpSubprogram(const parser::Name &name) {
 // A subprogram declared with SUBROUTINE or FUNCTION
 bool SubprogramVisitor::BeginSubprogram(
     const parser::Name &name, Symbol::Flag subpFlag, bool hasModulePrefix) {
-  if (hasModulePrefix && !inInterfaceBlock()) {
-    auto *symbol{FindSymbol(currScope().parent(), name)};
-    if (!symbol || !symbol->IsSeparateModuleProc()) {
-      Say(name, "'%s' was not declared a separate module procedure"_err_en_US);
-      return false;
-    }
+  if (hasModulePrefix && !inInterfaceBlock() &&
+      !IsSeparateModuleProcedureInterface(
+          FindSymbol(currScope().parent(), name))) {
+    Say(name, "'%s' was not declared a separate module procedure"_err_en_US);
+    return false;
   }
   PushSubprogramScope(name, subpFlag);
   return true;
@@ -2844,24 +3015,28 @@ bool SubprogramVisitor::BeginSubprogram(
 
 void SubprogramVisitor::EndSubprogram() { PopScope(); }
 
+void SubprogramVisitor::CheckExtantExternal(
+    const parser::Name &name, Symbol::Flag subpFlag) {
+  if (auto *prev{FindSymbol(name)}) {
+    if (prev->attrs().test(Attr::EXTERNAL) && prev->has<ProcEntityDetails>()) {
+      // this subprogram was previously called, now being declared
+      if (!prev->test(subpFlag)) {
+        Say2(name,
+            subpFlag == Symbol::Flag::Function
+                ? "'%s' was previously called as a subroutine"_err_en_US
+                : "'%s' was previously called as a function"_err_en_US,
+            *prev, "Previous call of '%s'"_en_US);
+      }
+      EraseSymbol(name);
+    }
+  }
+}
+
 Symbol &SubprogramVisitor::PushSubprogramScope(
     const parser::Name &name, Symbol::Flag subpFlag) {
   auto *symbol{GetSpecificFromGeneric(name)};
   if (!symbol) {
-    if (auto *prev{FindSymbol(name)}) {
-      if (prev->attrs().test(Attr::EXTERNAL) &&
-          prev->has<ProcEntityDetails>()) {
-        // this subprogram was previously called, now being declared
-        if (!prev->test(subpFlag)) {
-          Say2(name,
-              subpFlag == Symbol::Flag::Function
-                  ? "'%s' was previously called as a subroutine"_err_en_US
-                  : "'%s' was previously called as a function"_err_en_US,
-              *prev, "Previous call of '%s'"_en_US);
-        }
-        EraseSymbol(name);
-      }
-    }
+    CheckExtantExternal(name, subpFlag);
     symbol = &MakeSymbol(name, SubprogramDetails{});
   }
   symbol->set(subpFlag);
@@ -2877,7 +3052,7 @@ Symbol &SubprogramVisitor::PushSubprogramScope(
     }
     implicitRules().set_inheritFromParent(false);
   }
-  FindSymbol(name)->set(subpFlag);  // PushScope() created symbol
+  FindSymbol(name)->set(subpFlag); // PushScope() created symbol
   return *symbol;
 }
 
@@ -2958,7 +3133,7 @@ void DeclarationVisitor::CheckAccessibility(
 }
 
 void DeclarationVisitor::Post(const parser::TypeDeclarationStmt &) {
-  if (!GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {  // C702
+  if (!GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE})) { // C702
     if (const auto *typeSpec{GetDeclTypeSpec()}) {
       if (typeSpec->category() == DeclTypeSpec::Character) {
         if (typeSpec->characterTypeSpec().length().isDeferred()) {
@@ -3006,7 +3181,7 @@ void DeclarationVisitor::Post(const parser::EntityDecl &x) {
     if (ConvertToObjectEntity(symbol)) {
       Initialization(name, *init, false);
     }
-  } else if (attrs.test(Attr::PARAMETER)) {  // C882, C883
+  } else if (attrs.test(Attr::PARAMETER)) { // C882, C883
     Say(name, "Missing initialization for parameter '%s'"_err_en_US);
   }
 }
@@ -3080,7 +3255,7 @@ bool DeclarationVisitor::Pre(const parser::Enumerator &enumerator) {
 
   if (auto &init{std::get<std::optional<parser::ScalarIntConstantExpr>>(
           enumerator.t)}) {
-    Walk(*init);  // Resolve names in expression before evaluation.
+    Walk(*init); // Resolve names in expression before evaluation.
     MaybeIntExpr expr{EvaluateIntExpr(*init)};
     if (auto value{evaluate::ToInt64(expr)}) {
       // Cast all init expressions to C_INT so that they can then be
@@ -3118,7 +3293,7 @@ bool DeclarationVisitor::Pre(const parser::AccessSpec &x) {
   Attr attr{AccessSpecToAttr(x)};
   const Scope &scope{
       currScope().IsDerivedType() ? currScope().parent() : currScope()};
-  if (!scope.IsModule()) {  // C817
+  if (!scope.IsModule()) { // C817
     Say(currStmtSource().value(),
         "%s attribute may only appear in the specification part of a module"_err_en_US,
         EnumToString(attr));
@@ -3147,7 +3322,7 @@ bool DeclarationVisitor::Pre(const parser::ExternalStmt &x) {
 bool DeclarationVisitor::Pre(const parser::IntentStmt &x) {
   auto &intentSpec{std::get<parser::IntentSpec>(x.t)};
   auto &names{std::get<std::list<parser::Name>>(x.t)};
-  return CheckNotInBlock("INTENT") &&  // C1107
+  return CheckNotInBlock("INTENT") && // C1107
       HandleAttributeStmt(IntentSpecToAttr(intentSpec), names);
 }
 bool DeclarationVisitor::Pre(const parser::IntrinsicStmt &x) {
@@ -3157,7 +3332,7 @@ bool DeclarationVisitor::Pre(const parser::IntrinsicStmt &x) {
     if (!ConvertToProcEntity(*symbol)) {
       SayWithDecl(
           name, *symbol, "INTRINSIC attribute not allowed on '%s'"_err_en_US);
-    } else if (symbol->attrs().test(Attr::EXTERNAL)) {  // C840
+    } else if (symbol->attrs().test(Attr::EXTERNAL)) { // C840
       Say(symbol->name(),
           "Symbol '%s' cannot have both EXTERNAL and INTRINSIC attributes"_err_en_US,
           symbol->name());
@@ -3166,14 +3341,14 @@ bool DeclarationVisitor::Pre(const parser::IntrinsicStmt &x) {
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::OptionalStmt &x) {
-  return CheckNotInBlock("OPTIONAL") &&  // C1107
+  return CheckNotInBlock("OPTIONAL") && // C1107
       HandleAttributeStmt(Attr::OPTIONAL, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::ProtectedStmt &x) {
   return HandleAttributeStmt(Attr::PROTECTED, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::ValueStmt &x) {
-  return CheckNotInBlock("VALUE") &&  // C1107
+  return CheckNotInBlock("VALUE") && // C1107
       HandleAttributeStmt(Attr::VALUE, x.v);
 }
 bool DeclarationVisitor::Pre(const parser::VolatileStmt &x) {
@@ -3335,7 +3510,7 @@ void DeclarationVisitor::Post(const parser::CharSelector::LengthAndKind &x) {
   std::optional<std::int64_t> intKind{ToInt64(charInfo_.kind)};
   if (intKind &&
       !evaluate::IsValidKindOfIntrinsicType(
-          TypeCategory::Character, *intKind)) {  // C715, C719
+          TypeCategory::Character, *intKind)) { // C715, C719
     Say(currStmtSource().value(),
         "KIND value (%jd) not valid for CHARACTER"_err_en_US,
         static_cast<std::intmax_t>(*intKind));
@@ -3379,7 +3554,7 @@ bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Type &) {
 void DeclarationVisitor::Post(const parser::DeclarationTypeSpec::Type &type) {
   const parser::Name &derivedName{std::get<parser::Name>(type.derived.t)};
   if (const Symbol * derivedSymbol{derivedName.symbol}) {
-    CheckForAbstractType(*derivedSymbol);  // C706
+    CheckForAbstractType(*derivedSymbol); // C706
   }
 }
 
@@ -3392,7 +3567,7 @@ void DeclarationVisitor::Post(
     const parser::DeclarationTypeSpec::Class &parsedClass) {
   const auto &typeName{std::get<parser::Name>(parsedClass.derived.t)};
   if (auto spec{ResolveDerivedType(typeName)};
-      spec && !IsExtensibleType(&*spec)) {  // C705
+      spec && !IsExtensibleType(&*spec)) { // C705
     SayWithDecl(typeName, *typeName.symbol,
         "Non-extensible derived type '%s' may not be used with CLASS"
         " keyword"_err_en_US);
@@ -3493,21 +3668,21 @@ bool DeclarationVisitor::Pre(const parser::DerivedTypeDef &x) {
     auto *symbol{FindInScope(scope, paramName)};
     if (!symbol) {
       Say(paramName,
-          "No definition found for type parameter '%s'"_err_en_US);  // C742
+          "No definition found for type parameter '%s'"_err_en_US); // C742
     } else if (!symbol->has<TypeParamDetails>()) {
       Say2(paramName, "'%s' is not defined as a type parameter"_err_en_US,
-          *symbol, "Definition of '%s'"_en_US);  // C741
+          *symbol, "Definition of '%s'"_en_US); // C741
     }
     if (!paramNames.insert(paramName.source).second) {
       Say(paramName,
-          "Duplicate type parameter name: '%s'"_err_en_US);  // C731
+          "Duplicate type parameter name: '%s'"_err_en_US); // C731
     }
   }
   for (const auto &[name, symbol] : currScope()) {
     if (symbol->has<TypeParamDetails>() && !paramNames.count(name)) {
       SayDerivedType(name,
           "'%s' is not a type parameter of this derived type"_err_en_US,
-          currScope());  // C742
+          currScope()); // C742
     }
   }
   Walk(std::get<std::list<parser::Statement<parser::PrivateOrSequence>>>(x.t));
@@ -3515,11 +3690,11 @@ bool DeclarationVisitor::Pre(const parser::DerivedTypeDef &x) {
     details.set_sequence(true);
     if (derivedTypeInfo_.extends) {
       Say(stmt.source,
-          "A sequence type may not have the EXTENDS attribute"_err_en_US);  // C735
+          "A sequence type may not have the EXTENDS attribute"_err_en_US); // C735
     }
     if (!details.paramNames().empty()) {
       Say(stmt.source,
-          "A sequence type may not have type parameters"_err_en_US);  // C740
+          "A sequence type may not have type parameters"_err_en_US); // C740
     }
   }
   Walk(std::get<std::list<parser::Statement<parser::ComponentDefStmt>>>(x.t));
@@ -3600,14 +3775,14 @@ bool DeclarationVisitor::Pre(const parser::TypeAttrSpec::Extends &x) {
 bool DeclarationVisitor::Pre(const parser::PrivateStmt &) {
   if (!currScope().parent().IsModule()) {
     Say("PRIVATE is only allowed in a derived type that is"
-        " in a module"_err_en_US);  // C766
+        " in a module"_err_en_US); // C766
   } else if (derivedTypeInfo_.sawContains) {
     derivedTypeInfo_.privateBindings = true;
   } else if (!derivedTypeInfo_.privateComps) {
     derivedTypeInfo_.privateComps = true;
   } else {
     Say("PRIVATE may not appear more than once in"
-        " derived type components"_en_US);  // C738
+        " derived type components"_en_US); // C738
   }
   return false;
 }
@@ -3625,7 +3800,7 @@ void DeclarationVisitor::Post(const parser::ComponentDecl &x) {
   if (!attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
     if (const auto *declType{GetDeclTypeSpec()}) {
       if (const auto *derived{declType->AsDerived()}) {
-        if (derivedTypeInfo_.type == &derived->typeSymbol()) {  // C737
+        if (derivedTypeInfo_.type == &derived->typeSymbol()) { // C737
           Say("Recursive use of the derived type requires "
               "POINTER or ALLOCATABLE"_err_en_US);
         }
@@ -3723,7 +3898,7 @@ void DeclarationVisitor::Post(const parser::TypeBoundProcedurePart &) {
     }
     auto [it, inserted]{specifics.insert(bindingName->source)};
     if (!inserted) {
-      Say(*bindingName,  // C773
+      Say(*bindingName, // C773
           "Binding name '%s' was already specified for generic '%s'"_err_en_US,
           bindingName->source, generic->name())
           .Attach(*it, "Previous specification of '%s'"_en_US, *it);
@@ -3731,10 +3906,10 @@ void DeclarationVisitor::Post(const parser::TypeBoundProcedurePart &) {
     }
     auto *symbol{FindInTypeOrParents(*bindingName)};
     if (!symbol) {
-      Say(*bindingName,  // C772
+      Say(*bindingName, // C772
           "Binding name '%s' not found in this derived type"_err_en_US);
     } else if (!symbol->has<ProcBindingDetails>()) {
-      SayWithDecl(*bindingName, *symbol,  // C772
+      SayWithDecl(*bindingName, *symbol, // C772
           "'%s' is not the name of a specific binding of this type"_err_en_US);
     } else {
       generic->get<GenericDetails>().AddSpecificProc(
@@ -3746,13 +3921,13 @@ void DeclarationVisitor::Post(const parser::TypeBoundProcedurePart &) {
 
 void DeclarationVisitor::Post(const parser::ContainsStmt &) {
   if (derivedTypeInfo_.sequence) {
-    Say("A sequence type may not have a CONTAINS statement"_err_en_US);  // C740
+    Say("A sequence type may not have a CONTAINS statement"_err_en_US); // C740
   }
 }
 
 void DeclarationVisitor::Post(
     const parser::TypeBoundProcedureStmt::WithoutInterface &x) {
-  if (GetAttrs().test(Attr::DEFERRED)) {  // C783
+  if (GetAttrs().test(Attr::DEFERRED)) { // C783
     Say("DEFERRED is only allowed when an interface-name is provided"_err_en_US);
   }
   for (auto &declaration : x.declarations) {
@@ -3802,7 +3977,7 @@ void DeclarationVisitor::CheckBindings(
 
 void DeclarationVisitor::Post(
     const parser::TypeBoundProcedureStmt::WithInterface &x) {
-  if (!GetAttrs().test(Attr::DEFERRED)) {  // C783
+  if (!GetAttrs().test(Attr::DEFERRED)) { // C783
     Say("DEFERRED is required when an interface-name is provided"_err_en_US);
   }
   if (Symbol * interface{NoteInterfaceName(x.interfaceName)}) {
@@ -3835,7 +4010,7 @@ bool DeclarationVisitor::Pre(const parser::TypeBoundGenericStmt &x) {
   auto *genericSymbol{info.FindInScope(context(), currScope())};
   if (genericSymbol) {
     if (!genericSymbol->has<GenericDetails>()) {
-      genericSymbol = nullptr;  // MakeTypeSymbol will report the error below
+      genericSymbol = nullptr; // MakeTypeSymbol will report the error below
     }
   } else {
     // look in parent types:
@@ -3847,11 +4022,11 @@ bool DeclarationVisitor::Pre(const parser::TypeBoundGenericStmt &x) {
       }
     }
     if (inheritedSymbol && inheritedSymbol->has<GenericDetails>()) {
-      CheckAccessibility(symbolName, isPrivate, *inheritedSymbol);  // C771
+      CheckAccessibility(symbolName, isPrivate, *inheritedSymbol); // C771
     }
   }
   if (genericSymbol) {
-    CheckAccessibility(symbolName, isPrivate, *genericSymbol);  // C771
+    CheckAccessibility(symbolName, isPrivate, *genericSymbol); // C771
   } else {
     genericSymbol = MakeTypeSymbol(symbolName, GenericDetails{});
     if (!genericSymbol) {
@@ -3978,7 +4153,7 @@ bool DeclarationVisitor::Pre(const parser::BasedPointerStmt &x) {
 }
 
 bool DeclarationVisitor::Pre(const parser::NamelistStmt::Group &x) {
-  if (!CheckNotInBlock("NAMELIST")) {  // C1107
+  if (!CheckNotInBlock("NAMELIST")) { // C1107
     return false;
   }
 
@@ -4018,7 +4193,7 @@ bool DeclarationVisitor::Pre(const parser::IoControlSpec &x) {
 }
 
 bool DeclarationVisitor::Pre(const parser::CommonStmt::Block &x) {
-  CheckNotInBlock("COMMON");  // C1107
+  CheckNotInBlock("COMMON"); // C1107
   const auto &optName{std::get<std::optional<parser::Name>>(x.t)};
   parser::Name blankCommon;
   blankCommon.source =
@@ -4046,7 +4221,7 @@ void DeclarationVisitor::Post(const parser::CommonBlockObject &x) {
   ClearCoarraySpec();
   auto *details{symbol.detailsIf<ObjectEntityDetails>()};
   if (!details) {
-    return;  // error was reported
+    return; // error was reported
   }
   commonBlockInfo_.curr->get<CommonBlockDetails>().add_object(symbol);
   auto pair{commonBlockInfo_.names.insert(name.source)};
@@ -4061,18 +4236,18 @@ void DeclarationVisitor::Post(const parser::CommonBlockObject &x) {
 
 bool DeclarationVisitor::Pre(const parser::EquivalenceStmt &x) {
   // save equivalence sets to be processed after specification part
-  CheckNotInBlock("EQUIVALENCE");  // C1107
+  CheckNotInBlock("EQUIVALENCE"); // C1107
   for (const std::list<parser::EquivalenceObject> &set : x.v) {
     equivalenceSets_.push_back(&set);
   }
-  return false;  // don't implicitly declare names yet
+  return false; // don't implicitly declare names yet
 }
 
 void DeclarationVisitor::CheckEquivalenceSets() {
   EquivalenceSets equivSets{context()};
   for (const auto *set : equivalenceSets_) {
     const auto &source{set->front().v.value().source};
-    if (set->size() <= 1) {  // R871
+    if (set->size() <= 1) { // R871
       Say(source, "Equivalence set must have more than one object"_err_en_US);
     }
     for (const parser::EquivalenceObject &object : *set) {
@@ -4136,7 +4311,7 @@ void DeclarationVisitor::CheckSaveStmts() {
           Say(name,
               "'%s' appears as a COMMON block in a SAVE statement but not in"
               " a COMMON statement"_err_en_US);
-        } else {  // C1108
+        } else { // C1108
           Say(name,
               "SAVE statement in BLOCK construct may not contain a"
               " common block name '%s'"_err_en_US);
@@ -4314,10 +4489,10 @@ bool DeclarationVisitor::HandleUnrestrictedSpecificIntrinsicFunction(
 bool DeclarationVisitor::PassesSharedLocalityChecks(
     const parser::Name &name, Symbol &symbol) {
   if (!IsVariableName(symbol)) {
-    SayLocalMustBeVariable(name, symbol);  // C1124
+    SayLocalMustBeVariable(name, symbol); // C1124
     return false;
   }
-  if (symbol.owner() == currScope()) {  // C1125 and C1126
+  if (symbol.owner() == currScope()) { // C1125 and C1126
     SayAlreadyDeclared(name, symbol);
     return false;
   }
@@ -4327,41 +4502,41 @@ bool DeclarationVisitor::PassesSharedLocalityChecks(
 // Checks for locality-specs LOCAL and LOCAL_INIT
 bool DeclarationVisitor::PassesLocalityChecks(
     const parser::Name &name, Symbol &symbol) {
-  if (IsAllocatable(symbol)) {  // C1128
+  if (IsAllocatable(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "ALLOCATABLE variable '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
-  if (IsOptional(symbol)) {  // C1128
+  if (IsOptional(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "OPTIONAL argument '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
-  if (IsIntentIn(symbol)) {  // C1128
+  if (IsIntentIn(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "INTENT IN argument '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
-  if (IsFinalizable(symbol)) {  // C1128
+  if (IsFinalizable(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "Finalizable variable '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
-  if (IsCoarray(symbol)) {  // C1128
+  if (IsCoarray(symbol)) { // C1128
     SayWithDecl(
         name, symbol, "Coarray '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (const DeclTypeSpec * type{symbol.GetType()}) {
     if (type->IsPolymorphic() && symbol.IsDummy() &&
-        !IsPointer(symbol)) {  // C1128
+        !IsPointer(symbol)) { // C1128
       SayWithDecl(name, symbol,
           "Nonpointer polymorphic argument '%s' not allowed in a "
           "locality-spec"_err_en_US);
       return false;
     }
   }
-  if (IsAssumedSizeArray(symbol)) {  // C1128
+  if (IsAssumedSizeArray(symbol)) { // C1128
     SayWithDecl(name, symbol,
         "Assumed size array '%s' not allowed in a locality-spec"_err_en_US);
     return false;
@@ -4413,7 +4588,7 @@ Symbol *DeclarationVisitor::DeclareStatementEntity(const parser::Name &name,
   }
   Symbol &symbol{DeclareEntity<ObjectEntityDetails>(name, {})};
   if (!symbol.has<ObjectEntityDetails>()) {
-    return nullptr;  // error was reported in DeclareEntity
+    return nullptr; // error was reported in DeclareEntity
   }
   if (type) {
     declTypeSpec = ProcessTypeSpec(*type);
@@ -4435,7 +4610,7 @@ void DeclarationVisitor::SetType(
     const parser::Name &name, const DeclTypeSpec &type) {
   CHECK(name.symbol);
   auto &symbol{*name.symbol};
-  if (charInfo_.length) {  // Declaration has "*length" (R723)
+  if (charInfo_.length) { // Declaration has "*length" (R723)
     auto length{std::move(*charInfo_.length)};
     charInfo_.length.reset();
     if (type.category() == DeclTypeSpec::Character) {
@@ -4477,7 +4652,7 @@ std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
       DerivedTypeDetails details;
       details.set_isForwardReferenced();
       symbol->set_details(std::move(details));
-    } else {  // C883
+    } else { // C883
       Say(name, "Derived type '%s' not found"_err_en_US);
       return std::nullopt;
     }
@@ -4603,7 +4778,7 @@ ParamValue DeclarationVisitor::GetParamValue(
     const parser::TypeParamValue &x, common::TypeParamAttr attr) {
   return std::visit(
       common::visitors{
-          [=](const parser::ScalarIntExpr &x) {  // C704
+          [=](const parser::ScalarIntExpr &x) { // C704
             return ParamValue{EvaluateIntExpr(x), attr};
           },
           [=](const parser::Star &) { return ParamValue::Assumed(attr); },
@@ -4694,7 +4869,7 @@ bool ConstructVisitor::Pre(const parser::LocalitySpec::Shared &x) {
     if (PassesSharedLocalityChecks(name, prev)) {
       auto &symbol{MakeSymbol(name, HostAssocDetails{prev})};
       symbol.set(Symbol::Flag::LocalityShared);
-      name.symbol = &symbol;  // override resolution to parent
+      name.symbol = &symbol; // override resolution to parent
     }
   }
   return false;
@@ -4833,7 +5008,7 @@ void ConstructVisitor::Post(const parser::Association &x) {
     SetTypeFromAssociation(*symbol);
     SetAttrsFromAssociation(*symbol);
   }
-  GetCurrentAssociation() = {};  // clean for further parser::Association.
+  GetCurrentAssociation() = {}; // clean for further parser::Association.
 }
 
 bool ConstructVisitor::Pre(const parser::ChangeTeamStmt &x) {
@@ -4851,7 +5026,7 @@ void ConstructVisitor::Post(const parser::CoarrayAssociation &x) {
     if (auto sel{ResolveSelector(selector)}) {
       const Symbol *whole{UnwrapWholeSymbolDataRef(sel.expr)};
       if (!whole || whole->Corank() == 0) {
-        Say(sel.source,  // C1116
+        Say(sel.source, // C1116
             "Selector in coarray association must name a coarray"_err_en_US);
       } else if (auto dynType{sel.expr->GetType()}) {
         if (!symbol->GetType()) {
@@ -4888,12 +5063,12 @@ void ConstructVisitor::Post(const parser::SelectTypeStmt &x) {
         whole{UnwrapWholeSymbolDataRef(association.selector.expr)}) {
       ConvertToObjectEntity(const_cast<Symbol &>(*whole));
       if (!IsVariableName(*whole)) {
-        Say(association.selector.source,  // C901
+        Say(association.selector.source, // C901
             "Selector is not a variable"_err_en_US);
         association = {};
       }
     } else {
-      Say(association.selector.source,  // C1157
+      Say(association.selector.source, // C1157
           "Selector is not a named variable: 'associate-name =>' is required"_err_en_US);
       association = {};
     }
@@ -4949,7 +5124,7 @@ Symbol *ConstructVisitor::MakeAssocEntity() {
   if (association.name) {
     symbol = &MakeSymbol(*association.name, UnknownDetails{});
     if (symbol->has<AssocEntityDetails>() && symbol->owner() == currScope()) {
-      Say(*association.name,  // C1104
+      Say(*association.name, // C1104
           "The associate name '%s' is already used in this associate statement"_err_en_US);
       return nullptr;
     }
@@ -5055,7 +5230,8 @@ const DeclTypeSpec &ConstructVisitor::ToDeclTypeSpec(
 
       );
     }
-  case common::TypeCategory::Character: CRASH_NO_CASE;
+  case common::TypeCategory::Character:
+    CRASH_NO_CASE;
   }
 }
 
@@ -5123,7 +5299,7 @@ bool ResolveNamesVisitor::Pre(const parser::ImportStmt &x) {
       return false;
     }
     break;
-  case Scope::Kind::BlockData:  // C1415 (in part)
+  case Scope::Kind::BlockData: // C1415 (in part)
     Say("IMPORT is not allowed in a BLOCK DATA subprogram"_err_en_US);
     return false;
   default:;
@@ -5207,7 +5383,7 @@ const parser::Name *DeclarationVisitor::ResolveVariable(
 const parser::Name *DeclarationVisitor::ResolveName(const parser::Name &name) {
   if (Symbol * symbol{FindSymbol(name)}) {
     if (CheckUseError(name)) {
-      return nullptr;  // reported an error
+      return nullptr; // reported an error
     }
     if (symbol->IsDummy() ||
         (!symbol->GetType() && FindCommonBlockContaining(*symbol))) {
@@ -5249,7 +5425,7 @@ const parser::Name *DeclarationVisitor::FindComponent(
   }
   auto *type{symbol.GetType()};
   if (!type) {
-    return nullptr;  // should have already reported error
+    return nullptr; // should have already reported error
   }
   if (const IntrinsicTypeSpec * intrinsic{type->AsIntrinsic()}) {
     auto name{component.ToString()};
@@ -5448,7 +5624,7 @@ void DeclarationVisitor::PointerInitialization(
           details.set_init(*targetName->symbol);
         }
       } else {
-        details.set_init(nullptr);  // explicit NULL()
+        details.set_init(nullptr); // explicit NULL()
       }
     } else {
       Say(name,
@@ -5505,7 +5681,7 @@ void ResolveNamesVisitor::HandleProcedureName(
     symbol = &Resolve(name, symbol)->GetUltimate();
     ConvertToProcEntity(*symbol);
     if (!SetProcFlag(name, *symbol, flag)) {
-      return;  // reported error
+      return; // reported error
     }
     if (IsProcedure(*symbol) || symbol->has<DerivedTypeDetails>() ||
         symbol->has<ObjectEntityDetails>() ||
@@ -5567,7 +5743,7 @@ bool ResolveNamesVisitor::SetProcFlag(
         name, symbol, "Cannot call subroutine '%s' like a function"_err_en_US);
     return false;
   } else if (symbol.has<ProcEntityDetails>()) {
-    symbol.set(flag);  // in case it hasn't been set yet
+    symbol.set(flag); // in case it hasn't been set yet
     if (flag == Symbol::Flag::Function) {
       ApplyImplicitRules(symbol);
     }
@@ -5580,7 +5756,7 @@ bool ResolveNamesVisitor::SetProcFlag(
 
 bool ModuleVisitor::Pre(const parser::AccessStmt &x) {
   Attr accessAttr{AccessSpecToAttr(std::get<parser::AccessSpec>(x.t))};
-  if (!currScope().IsModule()) {  // C869
+  if (!currScope().IsModule()) { // C869
     Say(currStmtSource().value(),
         "%s statement may only appear in the specification part of a module"_err_en_US,
         EnumToString(accessAttr));
@@ -5588,7 +5764,7 @@ bool ModuleVisitor::Pre(const parser::AccessStmt &x) {
   }
   const auto &accessIds{std::get<std::list<parser::AccessId>>(x.t)};
   if (accessIds.empty()) {
-    if (prevAccessStmt_) {  // C869
+    if (prevAccessStmt_) { // C869
       Say("The default accessibility of this module has already been declared"_err_en_US)
           .Attach(*prevAccessStmt_, "Previous declaration"_en_US);
     }
@@ -5705,7 +5881,7 @@ void ResolveNamesVisitor::CreateGeneric(const parser::GenericSpec &x) {
   if (Symbol * existing{info.FindInScope(context(), currScope())}) {
     if (existing->has<GenericDetails>()) {
       info.Resolve(existing);
-      return;  // already have generic, add to it
+      return; // already have generic, add to it
     }
     Symbol &ultimate{existing->GetUltimate()};
     if (auto *ultimateDetails{ultimate.detailsIf<GenericDetails>()}) {
@@ -5751,7 +5927,8 @@ void ResolveNamesVisitor::FinishSpecificationPart() {
 void ResolveNamesVisitor::CheckImports() {
   auto &scope{currScope()};
   switch (scope.GetImportKind()) {
-  case common::ImportKind::None: break;
+  case common::ImportKind::None:
+    break;
   case common::ImportKind::All:
     // C8102: all entities in host must not be hidden
     for (const auto &pair : scope.parent()) {
@@ -5782,7 +5959,7 @@ void ResolveNamesVisitor::CheckImport(
 }
 
 bool ResolveNamesVisitor::Pre(const parser::ImplicitStmt &x) {
-  return CheckNotInBlock("IMPLICIT") &&  // C1107
+  return CheckNotInBlock("IMPLICIT") && // C1107
       ImplicitRulesVisitor::Pre(x);
 }
 
@@ -5834,7 +6011,7 @@ void ResolveNamesVisitor::Post(const parser::TypeGuardStmt &x) {
   ConstructVisitor::Post(x);
 }
 bool ResolveNamesVisitor::Pre(const parser::StmtFunctionStmt &x) {
-  CheckNotInBlock("STATEMENT FUNCTION");  // C1107
+  CheckNotInBlock("STATEMENT FUNCTION"); // C1107
   if (HandleStmtFunction(x)) {
     return false;
   } else {
@@ -5866,7 +6043,9 @@ bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
   SetScope(context().globalScope());
   ResolveSpecificationParts(root);
   FinishSpecificationParts(root);
+  inExecutionPart_ = true;
   ResolveExecutionParts(root);
+  inExecutionPart_ = false;
   ResolveOmpParts(x);
   return false;
 }
@@ -5876,7 +6055,7 @@ bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
 class ExecutionPartSkimmer {
 public:
   explicit ExecutionPartSkimmer(ResolveNamesVisitor &resolver)
-    : resolver_{resolver} {}
+      : resolver_{resolver} {}
 
   void Walk(const parser::ExecutionPart *exec) {
     if (exec) {
@@ -5884,8 +6063,8 @@ class ExecutionPartSkimmer {
     }
   }
 
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {}
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
   void Post(const parser::FunctionReference &fr) {
     resolver_.NoteExecutablePartCall(Symbol::Flag::Function, fr.v);
   }
@@ -5901,11 +6080,11 @@ class ExecutionPartSkimmer {
 // node and its children
 void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
   if (node.isSpecificationPartResolved()) {
-    return;  // been here already
+    return; // been here already
   }
   node.set_isSpecificationPartResolved();
   if (!BeginScopeForNode(node)) {
-    return;  // an error prevented scope from being created
+    return; // an error prevented scope from being created
   }
   Scope &scope{currScope()};
   node.set_scope(scope);
@@ -5969,8 +6148,11 @@ bool ResolveNamesVisitor::BeginScopeForNode(const ProgramTree &node) {
   case ProgramTree::Kind::Subroutine:
     return BeginSubprogram(
         node.name(), node.GetSubpFlag(), node.HasModulePrefix());
-  case ProgramTree::Kind::MpSubprogram: return BeginMpSubprogram(node.name());
-  case ProgramTree::Kind::Module: BeginModule(node.name(), false); return true;
+  case ProgramTree::Kind::MpSubprogram:
+    return BeginMpSubprogram(node.name());
+  case ProgramTree::Kind::Module:
+    BeginModule(node.name(), false);
+    return true;
   case ProgramTree::Kind::Submodule:
     return BeginSubmodule(node.name(), node.GetParentId());
   case ProgramTree::Kind::BlockData:
@@ -5986,12 +6168,12 @@ bool ResolveNamesVisitor::BeginScopeForNode(const ProgramTree &node) {
 class DeferredCheckVisitor {
 public:
   explicit DeferredCheckVisitor(ResolveNamesVisitor &resolver)
-    : resolver_{resolver} {}
+      : resolver_{resolver} {}
 
-  template<typename A> void Walk(const A &x) { parser::Walk(x, *this); }
+  template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
 
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {}
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
 
   void Post(const parser::DerivedTypeStmt &x) {
     const auto &name{std::get<parser::Name>(x.t)};
@@ -6200,7 +6382,7 @@ void OmpAttributeVisitor::ResolveSeqLoopIndexInParallelOrTaskConstruct(
   if (auto *symbol{ResolveOmp(iv, Symbol::Flag::OmpPrivate, targetIt->scope)}) {
     targetIt++;
     symbol->set(Symbol::Flag::OmpPreDetermined);
-    iv.symbol = symbol;  // adjust the symbol within region
+    iv.symbol = symbol; // adjust the symbol within region
     for (auto it{ompContext_.rbegin()}; it != targetIt; ++it) {
       AddToContextObjectWithDSA(*symbol, Symbol::Flag::OmpPrivate, *it);
     }
@@ -6259,8 +6441,8 @@ std::size_t OmpAttributeVisitor::GetAssociatedLoopLevelFromClauses(
     return orderedLevel;
   } else if (!orderedLevel && collapseLevel) {
     return collapseLevel;
-  }  // orderedLevel < collapseLevel is an error handled in structural checks
-  return 1;  // default is outermost loop
+  } // orderedLevel < collapseLevel is an error handled in structural checks
+  return 1; // default is outermost loop
 }
 
 // 2.15.1.1 Data-sharing Attribute Rules - Predetermined
@@ -6292,7 +6474,7 @@ void OmpAttributeVisitor::PrivatizeAssociatedLoopIndex(
     const parser::Name &iv{GetLoopIndex(*loop)};
     if (auto *symbol{ResolveOmp(iv, ivDSA, currScope())}) {
       symbol->set(Symbol::Flag::OmpPreDetermined);
-      iv.symbol = symbol;  // adjust the symbol within region
+      iv.symbol = symbol; // adjust the symbol within region
       AddToContextObjectWithDSA(*symbol, ivDSA);
     }
 
@@ -6358,7 +6540,7 @@ void OmpAttributeVisitor::Post(const parser::Name &name) {
       //       determined data-sharing attributes (2.15.1.1).
       if (Symbol * found{currScope().FindSymbol(name.source)}) {
         if (symbol != found) {
-          name.symbol = found;  // adjust the symbol within region
+          name.symbol = found; // adjust the symbol within region
         } else if (GetContext().defaultDSA == Symbol::Flag::OmpNone) {
           context_.Say(name.source,
               "The DEFAULT(NONE) clause requires that '%s' must be listed in "
@@ -6367,7 +6549,7 @@ void OmpAttributeVisitor::Post(const parser::Name &name) {
         }
       }
     }
-  }  // within OpenMP construct
+  } // within OpenMP construct
 }
 
 bool OmpAttributeVisitor::HasDataSharingAttributeObject(const Symbol &object) {
@@ -6428,7 +6610,7 @@ void OmpAttributeVisitor::ResolveOmpObject(
               }
             }
           },
-          [&](const parser::Name &name) {  // common block
+          [&](const parser::Name &name) { // common block
             if (auto *symbol{ResolveOmpCommonBlockName(&name)}) {
               CheckMultipleAppearances(
                   name, *symbol, Symbol::Flag::OmpCommonBlock);
@@ -6444,7 +6626,7 @@ void OmpAttributeVisitor::ResolveOmpObject(
                 }
               }
             } else {
-              context_.Say(name.source,  // 2.15.3
+              context_.Say(name.source, // 2.15.3
                   "COMMON block must be declared in the same scoping unit "
                   "in which the OpenMP directive or clause appears"_err_en_US);
             }
@@ -6474,7 +6656,7 @@ Symbol *OmpAttributeVisitor::ResolveOmp(
 Symbol *OmpAttributeVisitor::DeclarePrivateAccessEntity(
     const parser::Name &name, Symbol::Flag ompFlag, Scope &scope) {
   if (!name.symbol) {
-    return nullptr;  // not resolved by Name Resolution step, do nothing
+    return nullptr; // not resolved by Name Resolution step, do nothing
   }
   name.symbol = DeclarePrivateAccessEntity(*name.symbol, ompFlag, scope);
   return name.symbol;
@@ -6542,7 +6724,7 @@ void OmpAttributeVisitor::CheckMultipleAppearances(
 // the specification parts but before any of the execution parts.
 void ResolveNamesVisitor::FinishSpecificationParts(const ProgramTree &node) {
   if (!node.scope()) {
-    return;  // error occurred creating scope
+    return; // error occurred creating scope
   }
   SetScope(*node.scope());
   // The initializers of pointers, pointer components, and non-deferred
@@ -6550,7 +6732,7 @@ void ResolveNamesVisitor::FinishSpecificationParts(const ProgramTree &node) {
   // We do that now, when any (formerly) forward references that appear
   // in those initializers will resolve to the right symbols.
   DeferredCheckVisitor{*this}.Walk(node.spec());
-  DeferredCheckVisitor{*this}.Walk(node.exec());  // for BLOCK
+  DeferredCheckVisitor{*this}.Walk(node.exec()); // for BLOCK
   for (Scope &childScope : currScope().children()) {
     if (childScope.IsDerivedType() && !childScope.symbol()) {
       FinishDerivedTypeInstantiation(childScope);
@@ -6595,13 +6777,13 @@ void ResolveNamesVisitor::FinishDerivedTypeInstantiation(Scope &scope) {
 // Resolve names in the execution part of this node and its children
 void ResolveNamesVisitor::ResolveExecutionParts(const ProgramTree &node) {
   if (!node.scope()) {
-    return;  // error occurred creating scope
+    return; // error occurred creating scope
   }
   SetScope(*node.scope());
   if (const auto *exec{node.exec()}) {
     Walk(*exec);
   }
-  PopScope();  // converts unclassified entities into objects
+  PopScope(); // converts unclassified entities into objects
   for (const auto &child : node.children()) {
     ResolveExecutionParts(child);
   }
@@ -6650,4 +6832,4 @@ void ResolveSpecificationParts(
   visitor.ResolveSpecificationParts(node);
   context.set_location(std::move(originalLocation));
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/semantics.cpp b/lib/Semantics/semantics.cpp
index 53be760b7741..340c0a98f7cc 100644
--- a/lib/Semantics/semantics.cpp
+++ b/lib/Semantics/semantics.cpp
@@ -112,10 +112,23 @@ template<typename... C> class SemanticsVisitor : public virtual C... {
   SemanticsContext &context_;
 };
 
+class EntryChecker : public virtual BaseChecker {
+public:
+  explicit EntryChecker(SemanticsContext &context) : context_{context} {}
+  void Leave(const parser::EntryStmt &) {
+    if (!context_.constructStack().empty()) {  // C1571
+      context_.Say("ENTRY may not appear in an executable construct"_err_en_US);
+    }
+  }
+
+private:
+  SemanticsContext &context_;
+};
+
 using StatementSemanticsPass1 = ExprChecker;
 using StatementSemanticsPass2 = SemanticsVisitor<AllocateChecker,
     ArithmeticIfStmtChecker, AssignmentChecker, CoarrayChecker, DataChecker,
-    DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
+    DeallocateChecker, DoForallChecker, EntryChecker, IfStmtChecker, IoChecker,
     NamelistChecker, NullifyChecker, OmpStructureChecker, PurityChecker,
     ReturnStmtChecker, StopChecker>;
 
diff --git a/lib/Semantics/symbol.cpp b/lib/Semantics/symbol.cpp
index a13f2c0d3779..ecda5d1f6303 100644
--- a/lib/Semantics/symbol.cpp
+++ b/lib/Semantics/symbol.cpp
@@ -92,6 +92,12 @@ llvm::raw_ostream &operator<<(
       os << ", " << x.result_->attrs();
     }
   }
+  if (x.entryScope_) {
+    os << " entry";
+    if (x.entryScope_->symbol()) {
+      os << " in " << x.entryScope_->symbol()->name();
+    }
+  }
   char sep{'('};
   os << ' ';
   for (const Symbol *arg : x.dummyArgs_) {
@@ -318,15 +324,6 @@ bool Symbol::IsSubprogram() const {
       details_);
 }
 
-bool Symbol::IsSeparateModuleProc() const {
-  if (attrs().test(Attr::MODULE)) {
-    if (auto *details{detailsIf<SubprogramDetails>()}) {
-      return details->isInterface();
-    }
-  }
-  return false;
-}
-
 bool Symbol::IsFromModFile() const {
   return test(Flag::ModFile) ||
       (!owner_->IsGlobal() && owner_->symbol()->IsFromModFile());
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index 9b3a0326b10e..ce59825167ee 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -690,6 +690,15 @@ bool HasIntrinsicTypeName(const Symbol &symbol) {
   }
 }
 
+bool IsSeparateModuleProcedureInterface(const Symbol *symbol) {
+  if (symbol && symbol->attrs().test(Attr::MODULE)) {
+    if (auto *details{symbol->detailsIf<SubprogramDetails>()}) {
+      return details->isInterface();
+    }
+  }
+  return false;
+}
+
 bool IsFinalizable(const Symbol &symbol) {
   if (const DeclTypeSpec * type{symbol.GetType()}) {
     if (const DerivedTypeSpec * derived{type->AsDerived()}) {
@@ -729,11 +738,9 @@ bool IsAssumedLengthCharacter(const Symbol &symbol) {
 
 // C722 and C723:  For a function to be assumed length, it must be external and
 // of CHARACTER type
-bool IsAssumedLengthExternalCharacterFunction(const Symbol &symbol) {
-  return IsAssumedLengthCharacter(symbol) &&
-      ((symbol.has<SubprogramDetails>() && symbol.owner().IsGlobal()) ||
-          (symbol.test(Symbol::Flag::Function) &&
-              symbol.attrs().test(Attr::EXTERNAL)));
+bool IsExternal(const Symbol &symbol) {
+  return (symbol.has<SubprogramDetails>() && symbol.owner().IsGlobal()) ||
+      symbol.attrs().test(Attr::EXTERNAL);
 }
 
 const Symbol *IsExternalInPureContext(
@@ -1022,6 +1029,22 @@ const DeclTypeSpec &FindOrInstantiateDerivedType(Scope &scope,
   return type;
 }
 
+const Symbol *FindSeparateModuleSubprogramInterface(const Symbol *proc) {
+  if (proc) {
+    if (const Symbol * submodule{proc->owner().symbol()}) {
+      if (const auto *details{submodule->detailsIf<ModuleDetails>()}) {
+        if (const Scope * ancestor{details->ancestor()}) {
+          const Symbol *iface{ancestor->FindSymbol(proc->name())};
+          if (IsSeparateModuleProcedureInterface(iface)) {
+            return iface;
+          }
+        }
+      }
+    }
+  }
+  return nullptr;
+}
+
 // ComponentIterator implementation
 
 template<ComponentKind componentKind>
diff --git a/test/Semantics/assign04.f90 b/test/Semantics/assign04.f90
index f8798138c15c..dd0159bdd0bd 100644
--- a/test/Semantics/assign04.f90
+++ b/test/Semantics/assign04.f90
@@ -14,6 +14,7 @@ subroutine s1
 
 ! C901
 subroutine s2(x)
+  !ERROR: A dummy argument may not also be a named constant
   real, parameter :: x = 0.0
   real, parameter :: a(*) = [1, 2, 3]
   character, parameter :: c(2) = "ab"
diff --git a/test/Semantics/entry01.f90 b/test/Semantics/entry01.f90
new file mode 100644
index 000000000000..ccb03a7f6083
--- /dev/null
+++ b/test/Semantics/entry01.f90
@@ -0,0 +1,184 @@
+! RUN: %S/test_errors.sh %s %flang %t
+! Tests valid and invalid ENTRY statements
+
+module m1
+  !ERROR: ENTRY may appear only in a subroutine or function
+  entry badentryinmodule
+  interface
+    module subroutine separate
+    end subroutine
+  end interface
+ contains
+  subroutine modproc
+    entry entryinmodproc ! ok
+    block
+      !ERROR: ENTRY may not appear in an executable construct
+      entry badentryinblock ! C1571
+    end block
+    if (.true.) then
+      !ERROR: ENTRY may not appear in an executable construct
+      entry ibadconstr() ! C1571
+    end if
+   contains
+    subroutine internal
+      !ERROR: ENTRY may not appear in an internal subprogram
+      entry badentryininternal ! C1571
+    end subroutine
+  end subroutine
+end module
+
+submodule(m1) m1s1
+ contains
+  module procedure separate
+    !ERROR: ENTRY may not appear in a separate module procedure
+    entry badentryinsmp ! 1571
+  end procedure
+end submodule
+
+program main
+  !ERROR: ENTRY may appear only in a subroutine or function
+  entry badentryinprogram ! C1571
+end program
+
+block data bd1
+  !ERROR: ENTRY may appear only in a subroutine or function
+  entry badentryinbd ! C1571
+end block data
+
+subroutine subr(goodarg1)
+  real, intent(in) :: goodarg1
+  real :: goodarg2
+  !ERROR: A dummy argument may not also be a named constant
+  integer, parameter :: badarg1 = 1
+  type :: badarg2
+  end type
+  common /badarg3/ x
+  namelist /badarg4/ x
+  !ERROR: A dummy argument may not have the SAVE attribute
+  integer :: badarg5 = 2
+  entry okargs(goodarg1, goodarg2)
+  !ERROR: RESULT(br1) may appear only in a function
+  entry badresult() result(br1) ! C1572
+  !ERROR: ENTRY dummy argument 'badarg2' is previously declared as an item that may not be used as a dummy argument
+  !ERROR: ENTRY dummy argument 'badarg4' is previously declared as an item that may not be used as a dummy argument
+  entry badargs(badarg1,badarg2,badarg3,badarg4,badarg5)
+end subroutine
+
+function ifunc()
+  integer :: ifunc
+  integer :: ibad1
+  type :: ibad2
+  end type
+  save :: ibad3
+  real :: weird1
+  double precision :: weird2
+  complex :: weird3
+  logical :: weird4
+  character :: weird5
+  type(ibad2) :: weird6
+  integer :: iarr(1)
+  integer, allocatable :: alloc
+  integer, pointer :: ptr
+  entry iok1()
+  !ERROR: ENTRY name 'ibad1' may not be declared when RESULT() is present
+  entry ibad1() result(ibad1res) ! C1570
+  !ERROR: 'ibad2' was previously declared as an item that may not be used as a function result
+  entry ibad2()
+  !ERROR: ENTRY in a function may not have an alternate return dummy argument
+  entry ibadalt(*) ! C1573
+  !ERROR: RESULT(ifunc) may not have the same name as the function
+  entry isameres() result(ifunc) ! C1574
+  entry iok()
+  !ERROR: RESULT(iok) may not have the same name as an ENTRY in the function
+  entry isameres2() result(iok) ! C1574
+  entry isameres3() result(iok2) ! C1574
+  entry iok2()
+  !These cases are all acceptably incompatible
+  entry iok3() result(weird1)
+  entry iok4() result(weird2)
+  entry iok5() result(weird3)
+  entry iok6() result(weird4)
+  !ERROR: Result of ENTRY is not compatible with result of containing function
+  entry ibadt1() result(weird5)
+  !ERROR: Result of ENTRY is not compatible with result of containing function
+  entry ibadt2() result(weird6)
+  !ERROR: Result of ENTRY is not compatible with result of containing function
+  entry ibadt3() result(iarr)
+  !ERROR: Result of ENTRY is not compatible with result of containing function
+  entry ibadt4() result(alloc)
+  !ERROR: Result of ENTRY is not compatible with result of containing function
+  entry ibadt5() result(ptr)
+  call isubr
+  !ERROR: 'isubr' was previously called as a subroutine
+  entry isubr()
+  continue ! force transition to execution part
+  entry implicit()
+  implicit = 666 ! ok, just ensure that it works
+end function
+
+function chfunc() result(chr)
+  character(len=1) :: chr
+  character(len=2) :: chr1
+  !ERROR: Result of ENTRY is not compatible with result of containing function
+  entry chfunc1() result(chr1)
+end function
+
+subroutine externals
+  !ERROR: 'subr' is already defined as a global identifier
+  entry subr
+  !ERROR: 'ifunc' is already defined as a global identifier
+  entry ifunc
+  !ERROR: 'm1' is already defined as a global identifier
+  entry m1
+  !ERROR: 'iok1' is already defined as a global identifier
+  entry iok1
+  integer :: ix
+  ix = iproc()
+  !ERROR: 'iproc' was previously called as a function
+  entry iproc
+end subroutine
+
+module m2
+  external m2entry2
+ contains
+  subroutine m2subr1
+    entry m2entry1 ! ok
+    entry m2entry2 ! ok
+    entry m2entry3 ! ok
+  end subroutine
+end module
+
+subroutine usem2
+  use m2
+  interface
+    subroutine simplesubr
+    end subroutine
+  end interface
+  procedure(simplesubr), pointer :: p
+  p => m2subr1 ! ok
+  p => m2entry1 ! ok
+  p => m2entry2 ! ok
+  p => m2entry3 ! ok
+end subroutine
+
+module m3
+  interface
+    module subroutine m3entry1
+    end subroutine
+  end interface
+ contains
+  subroutine m3subr1
+    !ERROR: 'm3entry1' is already declared in this scoping unit
+    entry m3entry1
+  end subroutine
+end module
+
+function inone
+  implicit none
+  integer :: inone
+  !ERROR: No explicit type declared for 'implicitbad1'
+  entry implicitbad1
+  inone = 0 ! force transition to execution part
+  !ERROR: No explicit type declared for 'implicitbad2'
+  entry implicitbad2
+end

From ff8dad10bffb70666ba3b4ff229dc4b608f9e116 Mon Sep 17 00:00:00 2001
From: David Truby <david.truby@arm.com>
Date: Thu, 19 Mar 2020 11:04:28 +0000
Subject: [PATCH 101/345] Add explicit nullptr check in initialisation of
 inDoConstruct.

This explicit check is needed as we are using braced initialisation here so
implicit narrowing conversions (such as pointer to bool) are not allowed.
---
 lib/Semantics/check-do-forall.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Semantics/check-do-forall.cpp b/lib/Semantics/check-do-forall.cpp
index 6dfd51c8a823..58b434b18a60 100644
--- a/lib/Semantics/check-do-forall.cpp
+++ b/lib/Semantics/check-do-forall.cpp
@@ -912,7 +912,7 @@ void DoForallChecker::CheckForBadLeave(
 static bool StmtMatchesConstruct(const parser::Name *stmtName,
     StmtType stmtType, const parser::Name *constructName,
     const ConstructNode &construct) {
-  bool inDoConstruct{MaybeGetDoConstruct(construct)};
+  bool inDoConstruct{MaybeGetDoConstruct(construct) != nullptr};
   if (!stmtName) {
     return inDoConstruct;  // Unlabeled statements match all DO constructs
   } else if (constructName && constructName->source == stmtName->source) {

From d1c7184159b2d3c542a8f36c58a0c817e7506845 Mon Sep 17 00:00:00 2001
From: Patrick McCormick <pat@lanl.gov>
Date: Tue, 25 Feb 2020 16:22:14 -0700
Subject: [PATCH 102/345] A rework of the cmake build components for in and out
 of tree builds.

In general all the basic functionality seems to work and removes some redundancy
and more complicated features in favor of borrowing infrastructure from LLVM
build configurations. Here's a quick summary of details and remaining issues:

  * Testing has spanned Ubuntu 18.04 & 19.10, CentOS 7, RHEL 8, and
    MacOS/darwin.  Architectures include x86_64 and Arm.  Without
    access to Window nothing has been tested there yet.

  * As we change file and directory naming schemes (i.e.,
    capitalization) some odd things can occur on MacOS systems with
    case preserving but not case senstive file system configurations.
    Can be painful and certainly something to watch out for as any
    any such changes continue.

  * Testing infrastructure still needs to be tuned up and worked on.
    Note that there do appear to be cases of some tests hanging (on
    MacOS in particular).  They appear unrelated to the build
    process.

  * Shared library configurations need testing (and probably fixing).

  * Tested both standalone and 'in-mono repo' builds.  Changes for
    supporting the mono repo builds will require LLVM-level changes that
    are straightforward when the time comes.

  * The configuration contains a work-around for LLVM's C++ standard mode
    passing down into Flang/F18 builds (i.e., LLVM CMake configuration would
    force a -std=c++11 flag to show up in command line arguments.  The
    current configuration removes that automatically and is more strict in
    following new CMake guidelines for enforcing C++17 mode across all the
    CMake files.

  * Cleaned up a lot of repetition in the command line arguments.  It
    is likely that more work is still needed to both allow for
    customization and working around CMake defailts (or those
    inherited from LLVM's configuration files). On some platforms agressive
    optimization flags (e.g. -O3) can actually break builds due to the inlining
    of templates in .cpp source files that then no longer are available for use
    cases outside those source files (shows up as link errors).   Sticking at -O2
    appears to fix this.  Currently this CMake configuration forces this in
    release mode but at the cost of stomping on any CMake, or user customized,
    settings for the release flags.

  * Made the lit tests non-source directory dependent where appropriate. This is
    done by configuring certain test shell files to refer to the correct paths
    whether an in or out of tree build is being performed. These configured
    files are output in the build directory. A %B substitution is introduced in
    lit to refer to the build directory, mirroring the %S substitution for the
    source directory, so that the tests can refer to the configured shell scripts.

Co-authored-by: David Truby <david.truby@arm.com>
---
 .gitignore                                    |   2 +
 CMakeLists.txt                                | 448 +++++++++++++-----
 README.md                                     |  25 -
 cmake/modules/AddFlang.cmake                  | 141 ++++++
 cmake/modules/CMakeLists.txt                  |  74 +++
 cmake/modules/FlangConfig.cmake.in            |  13 +
 include/CMakeLists.txt                        |   1 +
 include/flang/Version.inc.in                  |   5 +
 lib/CMakeLists.txt                            |   8 -
 lib/Common/CMakeLists.txt                     |   9 +-
 lib/Decimal/CMakeLists.txt                    |   9 +-
 lib/Evaluate/CMakeLists.txt                   |   9 +-
 lib/Parser/CMakeLists.txt                     |   9 +-
 lib/Semantics/CMakeLists.txt                  |   9 +-
 test/CMakeLists.txt                           |  16 +-
 test/Semantics/CMakeLists.txt                 |   1 +
 test/Semantics/allocate01.f90                 |   2 +-
 test/Semantics/allocate02.f90                 |   2 +-
 test/Semantics/allocate03.f90                 |   2 +-
 test/Semantics/allocate04.f90                 |   2 +-
 test/Semantics/allocate05.f90                 |   2 +-
 test/Semantics/allocate06.f90                 |   2 +-
 test/Semantics/allocate07.f90                 |   2 +-
 test/Semantics/allocate08.f90                 |   2 +-
 test/Semantics/allocate09.f90                 |   2 +-
 test/Semantics/allocate10.f90                 |   2 +-
 test/Semantics/allocate11.f90                 |   2 +-
 test/Semantics/allocate12.f90                 |   2 +-
 test/Semantics/allocate13.f90                 |   2 +-
 test/Semantics/altreturn01.f90                |   2 +-
 test/Semantics/altreturn02.f90                |   2 +-
 test/Semantics/altreturn03.f90                |   2 +-
 test/Semantics/altreturn04.f90                |   2 +-
 test/Semantics/altreturn05.f90                |   2 +-
 test/Semantics/assign01.f90                   |   2 +-
 test/Semantics/assign02.f90                   |   2 +-
 test/Semantics/assign03.f90                   |   2 +-
 test/Semantics/assign04.f90                   |   2 +-
 test/Semantics/bad-forward-type.f90           |   2 +-
 test/Semantics/bindings01.f90                 |   2 +-
 test/Semantics/block-data01.f90               |   2 +-
 test/Semantics/blockconstruct01.f90           |   2 +-
 test/Semantics/blockconstruct02.f90           |   2 +-
 test/Semantics/blockconstruct03.f90           |   2 +-
 test/Semantics/c_f_pointer.f90                |   2 +-
 test/Semantics/call01.f90                     |   2 +-
 test/Semantics/call02.f90                     |   2 +-
 test/Semantics/call03.f90                     |   2 +-
 test/Semantics/call04.f90                     |   2 +-
 test/Semantics/call05.f90                     |   2 +-
 test/Semantics/call06.f90                     |   2 +-
 test/Semantics/call07.f90                     |   2 +-
 test/Semantics/call08.f90                     |   2 +-
 test/Semantics/call09.f90                     |   2 +-
 test/Semantics/call10.f90                     |   2 +-
 test/Semantics/call11.f90                     |   2 +-
 test/Semantics/call12.f90                     |   2 +-
 test/Semantics/call13.f90                     |   2 +-
 test/Semantics/call14.f90                     |   2 +-
 test/Semantics/call15.f90                     |   2 +-
 test/Semantics/canondo16.f90                  |   4 +-
 test/Semantics/coarrays01.f90                 |   2 +-
 test/Semantics/complex01.f90                  |   2 +-
 test/Semantics/computed-goto01.f90            |   2 +-
 test/Semantics/computed-goto02.f90            |   2 +-
 test/Semantics/critical01.f90                 |   2 +-
 test/Semantics/critical02.f90                 |   2 +-
 test/Semantics/critical03.f90                 |   2 +-
 test/Semantics/data01.f90                     |   2 +-
 test/Semantics/data02.f90                     |   2 +-
 test/Semantics/deallocate01.f90               |   2 +-
 test/Semantics/deallocate04.f90               |   2 +-
 test/Semantics/deallocate05.f90               |   2 +-
 test/Semantics/doconcurrent01.f90             |   2 +-
 test/Semantics/doconcurrent05.f90             |   2 +-
 test/Semantics/doconcurrent06.f90             |   2 +-
 test/Semantics/doconcurrent08.f90             |   2 +-
 test/Semantics/dosemantics01.f90              |   2 +-
 test/Semantics/dosemantics02.f90              |   2 +-
 test/Semantics/dosemantics03.f90              |   2 +-
 test/Semantics/dosemantics04.f90              |   2 +-
 test/Semantics/dosemantics05.f90              |   2 +-
 test/Semantics/dosemantics06.f90              |   2 +-
 test/Semantics/dosemantics07.f90              |   2 +-
 test/Semantics/dosemantics08.f90              |   2 +-
 test/Semantics/dosemantics09.f90              |   2 +-
 test/Semantics/dosemantics10.f90              |   2 +-
 test/Semantics/dosemantics11.f90              |   2 +-
 test/Semantics/dosemantics12.f90              |   2 +-
 test/Semantics/entry01.f90                    |   2 +-
 test/Semantics/equivalence01.f90              |   2 +-
 test/Semantics/expr-errors01.f90              |   2 +-
 test/Semantics/expr-errors02.f90              |   2 +-
 test/Semantics/forall01.f90                   |   2 +-
 test/Semantics/if_arith01.f90                 |   2 +-
 test/Semantics/if_arith02.f90                 |   2 +-
 test/Semantics/if_arith03.f90                 |   2 +-
 test/Semantics/if_arith04.f90                 |   2 +-
 test/Semantics/if_construct01.f90             |   2 +-
 test/Semantics/if_construct02.f90             |   2 +-
 test/Semantics/if_stmt01.f90                  |   2 +-
 test/Semantics/if_stmt02.f90                  |   2 +-
 test/Semantics/if_stmt03.f90                  |   2 +-
 test/Semantics/implicit01.f90                 |   2 +-
 test/Semantics/implicit02.f90                 |   2 +-
 test/Semantics/implicit03.f90                 |   2 +-
 test/Semantics/implicit04.f90                 |   2 +-
 test/Semantics/implicit05.f90                 |   2 +-
 test/Semantics/implicit06.f90                 |   2 +-
 test/Semantics/implicit07.f90                 |   2 +-
 test/Semantics/implicit08.f90                 |   2 +-
 test/Semantics/init01.f90                     |   2 +-
 test/Semantics/int-literals.f90               |   2 +-
 test/Semantics/io01.f90                       |   2 +-
 test/Semantics/io02.f90                       |   2 +-
 test/Semantics/io03.f90                       |   2 +-
 test/Semantics/io04.f90                       |   2 +-
 test/Semantics/io05.f90                       |   2 +-
 test/Semantics/io06.f90                       |   2 +-
 test/Semantics/io07.f90                       |   2 +-
 test/Semantics/io08.f90                       |   2 +-
 test/Semantics/io09.f90                       |   2 +-
 test/Semantics/io10.f90                       |   2 +-
 test/Semantics/kinds02.f90                    |   2 +-
 test/Semantics/kinds04.f90                    |   2 +-
 test/Semantics/misc-declarations.f90          |   2 +-
 test/Semantics/namelist01.f90                 |   2 +-
 test/Semantics/null01.f90                     |   2 +-
 test/Semantics/nullify01.f90                  |   2 +-
 test/Semantics/nullify02.f90                  |   2 +-
 test/Semantics/omp-atomic.f90                 |   2 +-
 test/Semantics/omp-clause-validity01.f90      |   2 +-
 test/Semantics/omp-declarative-directive.f90  |   2 +-
 test/Semantics/omp-device-constructs.f90      |   2 +-
 test/Semantics/omp-loop-association.f90       |   2 +-
 test/Semantics/omp-nested01.f90               |   2 +-
 test/Semantics/omp-resolve01.f90              |   2 +-
 test/Semantics/omp-resolve02.f90              |   2 +-
 test/Semantics/omp-resolve03.f90              |   2 +-
 test/Semantics/omp-resolve04.f90              |   2 +-
 test/Semantics/omp-resolve05.f90              |   2 +-
 test/Semantics/resolve01.f90                  |   2 +-
 test/Semantics/resolve02.f90                  |   2 +-
 test/Semantics/resolve03.f90                  |   2 +-
 test/Semantics/resolve04.f90                  |   2 +-
 test/Semantics/resolve05.f90                  |   2 +-
 test/Semantics/resolve06.f90                  |   2 +-
 test/Semantics/resolve07.f90                  |   2 +-
 test/Semantics/resolve08.f90                  |   2 +-
 test/Semantics/resolve09.f90                  |   2 +-
 test/Semantics/resolve10.f90                  |   2 +-
 test/Semantics/resolve11.f90                  |   2 +-
 test/Semantics/resolve12.f90                  |   2 +-
 test/Semantics/resolve13.f90                  |   2 +-
 test/Semantics/resolve14.f90                  |   2 +-
 test/Semantics/resolve15.f90                  |   2 +-
 test/Semantics/resolve16.f90                  |   2 +-
 test/Semantics/resolve17.f90                  |   2 +-
 test/Semantics/resolve18.f90                  |   2 +-
 test/Semantics/resolve19.f90                  |   2 +-
 test/Semantics/resolve20.f90                  |   2 +-
 test/Semantics/resolve21.f90                  |   2 +-
 test/Semantics/resolve22.f90                  |   2 +-
 test/Semantics/resolve23.f90                  |   2 +-
 test/Semantics/resolve24.f90                  |   2 +-
 test/Semantics/resolve25.f90                  |   2 +-
 test/Semantics/resolve26.f90                  |   2 +-
 test/Semantics/resolve27.f90                  |   2 +-
 test/Semantics/resolve28.f90                  |   2 +-
 test/Semantics/resolve29.f90                  |   2 +-
 test/Semantics/resolve30.f90                  |   2 +-
 test/Semantics/resolve31.f90                  |   2 +-
 test/Semantics/resolve32.f90                  |   2 +-
 test/Semantics/resolve33.f90                  |   2 +-
 test/Semantics/resolve34.f90                  |   2 +-
 test/Semantics/resolve35.f90                  |   2 +-
 test/Semantics/resolve36.f90                  |   3 +-
 test/Semantics/resolve37.f90                  |   2 +-
 test/Semantics/resolve38.f90                  |   2 +-
 test/Semantics/resolve39.f90                  |   2 +-
 test/Semantics/resolve40.f90                  |   2 +-
 test/Semantics/resolve41.f90                  |   2 +-
 test/Semantics/resolve42.f90                  |   2 +-
 test/Semantics/resolve43.f90                  |   2 +-
 test/Semantics/resolve44.f90                  |   2 +-
 test/Semantics/resolve45.f90                  |   2 +-
 test/Semantics/resolve46.f90                  |   2 +-
 test/Semantics/resolve47.f90                  |   2 +-
 test/Semantics/resolve48.f90                  |   2 +-
 test/Semantics/resolve49.f90                  |   2 +-
 test/Semantics/resolve50.f90                  |   2 +-
 test/Semantics/resolve51.f90                  |   2 +-
 test/Semantics/resolve52.f90                  |   2 +-
 test/Semantics/resolve53.f90                  |   2 +-
 test/Semantics/resolve54.f90                  |   2 +-
 test/Semantics/resolve55.f90                  |   2 +-
 test/Semantics/resolve56.f90                  |   2 +-
 test/Semantics/resolve57.f90                  |   2 +-
 test/Semantics/resolve58.f90                  |   2 +-
 test/Semantics/resolve59.f90                  |   2 +-
 test/Semantics/resolve60.f90                  |   2 +-
 test/Semantics/resolve61.f90                  |   2 +-
 test/Semantics/resolve62.f90                  |   2 +-
 test/Semantics/resolve63.f90                  |   2 +-
 test/Semantics/resolve64.f90                  |   2 +-
 test/Semantics/resolve65.f90                  |   2 +-
 test/Semantics/resolve66.f90                  |   2 +-
 test/Semantics/resolve67.f90                  |   2 +-
 test/Semantics/resolve68.f90                  |   2 +-
 test/Semantics/resolve69.f90                  |   2 +-
 test/Semantics/resolve70.f90                  |   2 +-
 test/Semantics/resolve71.f90                  |   2 +-
 test/Semantics/resolve72.f90                  |   2 +-
 test/Semantics/resolve73.f90                  |   2 +-
 test/Semantics/resolve74.f90                  |   2 +-
 test/Semantics/resolve75.f90                  |   2 +-
 test/Semantics/resolve76.f90                  |   2 +-
 test/Semantics/resolve77.f90                  |   2 +-
 test/Semantics/resolve78.f90                  |   2 +-
 test/Semantics/resolve79.f90                  |   2 +-
 test/Semantics/resolve80.f90                  |   2 +-
 test/Semantics/resolve81.f90                  |   2 +-
 test/Semantics/resolve82.f90                  |   2 +-
 test/Semantics/resolve83.f90                  |   2 +-
 test/Semantics/resolve84.f90                  |   2 +-
 test/Semantics/resolve85.f90                  |   2 +-
 test/Semantics/separate-mp01.f90              |   2 +-
 test/Semantics/separate-mp02.f90              |   2 +-
 test/Semantics/stop01.f90                     |   2 +-
 test/Semantics/structconst01.f90              |   2 +-
 test/Semantics/structconst02.f90              |   2 +-
 test/Semantics/structconst03.f90              |   2 +-
 test/Semantics/structconst04.f90              |   2 +-
 test/Semantics/test_any.sh                    |   4 +-
 .../{test_errors.sh => test_errors.sh.in}     |   4 +-
 test/lit.cfg.py                               |   4 +-
 tools/CMakeLists.txt                          |   1 +
 tools/f18-parse-demo/CMakeLists.txt           |  13 +
 .../f18-parse-demo.cpp                        |   0
 .../{f18 => f18-parse-demo}/stub-evaluate.cpp |   0
 tools/f18/CMakeLists.txt                      |  62 +--
 tools/f18/{flang.sh => flang.sh.in}           |   2 +-
 unittests/CMakeLists.txt                      |   8 -
 unittests/Decimal/CMakeLists.txt              |  11 +-
 unittests/Evaluate/CMakeLists.txt             |   9 +-
 unittests/Runtime/CMakeLists.txt              |  19 +-
 246 files changed, 857 insertions(+), 496 deletions(-)
 create mode 100644 cmake/modules/AddFlang.cmake
 create mode 100644 cmake/modules/CMakeLists.txt
 create mode 100644 cmake/modules/FlangConfig.cmake.in
 create mode 100644 include/CMakeLists.txt
 create mode 100644 include/flang/Version.inc.in
 create mode 100644 test/Semantics/CMakeLists.txt
 rename test/Semantics/{test_errors.sh => test_errors.sh.in} (93%)
 create mode 100644 tools/f18-parse-demo/CMakeLists.txt
 rename tools/{f18 => f18-parse-demo}/f18-parse-demo.cpp (100%)
 rename tools/{f18 => f18-parse-demo}/stub-evaluate.cpp (100%)
 rename tools/f18/{flang.sh => flang.sh.in} (95%)

diff --git a/.gitignore b/.gitignore
index c45f199bbfe0..4da4ee1178ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,3 +17,5 @@ CMakeCache.txt
 */*/Makefile
 cmake_install.cmake
 formatted
+.DS_Store 
+.vs_code 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8883fb7e7597..54c5d52c45f6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,97 +1,140 @@
-#===-- CMakeLists.txt ------------------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
 cmake_minimum_required(VERSION 3.9.0)
 
-option(LINK_WITH_FIR "Link driver with FIR and LLVM" ON)
+# RPATH settings on macOS do not affect INSTALL_NAME.
+if (POLICY CMP0068)
+  cmake_policy(SET CMP0068 NEW)
+  set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
+endif()
 
-# Pass -DGCC=... to cmake to use a specific gcc installation.
-if( GCC )
-  set(CMAKE_CXX_COMPILER "${GCC}/bin/g++")
-  set(CMAKE_CC_COMPILER "${GCC}/bin/gcc")
-  set(CMAKE_BUILD_RPATH "${GCC}/lib64")
-  set(CMAKE_INSTALL_RPATH "${GCC}/lib64")
-endif()
-if(BUILD_WITH_CLANG)
-  file(TO_CMAKE_PATH "${BUILD_WITH_CLANG}" CLANG_PATH)
-  set(CMAKE_CXX_COMPILER "${CLANG_PATH}/bin/clang++")
-  set(CMAKE_CC_COMPILER "${CLANG_PATH}/bin/clang")
-  if(GCC)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
-  endif()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wstring-conversion")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcovered-switch-default")
+# Include file check macros honor CMAKE_REQUIRED_LIBRARIES.
+if(POLICY CMP0075)
+  cmake_policy(SET CMP0075 NEW)
 endif()
 
-# Set RPATH in every executable, overriding the default setting.
-# If you set this first variable back to true (the default),
-# also set the second one.
-set(CMAKE_SKIP_BUILD_RPATH false)
-set(CMAKE_BUILD_WITH_INSTALL_RPATH false)
+# option() honors normal variables.
+if (POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
+endif()
 
-set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib" "${CMAKE_INSTALL_RPATH}")
+option(LINK_WITH_FIR "Link driver with FIR and LLVM" ON)
 
-# Reminder: Setting CMAKE_CXX_COMPILER must be done before calling project()
+# Flang requires C++17.
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_EXTENSIONS OFF)
 
-project(f18 CXX)
+set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
-if( NOT CMAKE_BUILD_TYPE )
-  set( CMAKE_BUILD_TYPE Debug )
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
+  message(FATAL_ERROR "In-source builds are not allowed. \
+          Please create a directory and run cmake from there,\
+          passing the path to this source directory as the last argument.\
+          This process created the file `CMakeCache.txt' and the directory\
+          `CMakeFiles'. Please delete them.")
 endif()
 
-message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}" )
+# Add Flang-centric modules to cmake path.
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+include(AddFlang)
 
-find_package(LLVM REQUIRED CONFIG)
-message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION} in ${LLVM_DIR}")
-# If LLVM links to zlib we need the imported targets so we can too.
-if(LLVM_ENABLE_ZLIB)
-  find_package(ZLIB REQUIRED)
-endif()
+# Check for a standalone build and configure as appropriate from
+# there.
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+message("Building Flang as a standalone project.")
+project(Flang)
+
+  set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+  if (NOT MSVC_IDE)
+    set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
+      CACHE BOOL "Enable assertions")
+    # Assertions follow llvm's configuration.
+    mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
+  endif()
+
+  # We need a pre-built/installed version of LLVM.
+  find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
+  list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
 
-list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
+  # If LLVM links to zlib we need the imported targets so we can too.
+  if(LLVM_ENABLE_ZLIB)
+    find_package(ZLIB REQUIRED)
+  endif()
+
+  include(CMakeParseArguments)
+  include(AddLLVM)
+  include(HandleLLVMOptions)
+  include(VersionFromVCS)
+
+  if(LINK_WITH_FIR)
+    include(TableGen)
+    include(AddMLIR)
+    find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
+      NO_DEFAULT_PATH)
+  endif()
+
+  option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
+  option(LLVM_INSTALL_TOOLCHAIN_ONLY
+    "Only include toolchain files in the 'install' target." OFF)
+  option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
+    "Set to ON to force using an old, unsupported host toolchain." OFF)
 
-include(AddLLVM)
 
-# Get names for the LLVM libraries
-#
-# The full list of LLVM components can be obtained with
-#
-#   llvm-config --components
-#
-# Similarly, the (static) libraries corresponding to some
-# components (default is 'all') can be obtained with
-#
-#   llvm-config --libs --link-static [component ...]
-#
-# See also
-#  http://llvm.org/docs/CMake.html#embedding-llvm-in-your-project
-#  https://stackoverflow.com/questions/41924375/llvm-how-to-specify-all-link-libraries-as-input-to-llvm-map-components-to-libna
-#  https://stackoverflow.com/questions/33948633/how-do-i-link-when-building-with-llvm-libraries
+  # Add LLVM include files as if they were SYSTEM because there are complex unused
+  # parameter issues that may or may not appear depending on the environments and
+  # compilers (ifdefs are involved). This allows warnings from LLVM headers to be
+  # ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
+  # This may have to be fine-tuned if flang headers are consider part of this
+  # LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
+  # should not be suppressed).
+  include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
+  add_definitions(${LLVM_DEFINITIONS})
 
-# Add LLVM include files as if they were SYSTEM because there are complex unused
-# parameter issues that may or may not appear depending on the environments and
-# compilers (ifdefs are involved). This allows warnings from LLVM headers to be
-# ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
-# This may have to be fine-tuned if flang headers are consider part of this
-# LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
-# should not be suppressed).
-include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
-add_definitions(${LLVM_DEFINITIONS})
+  # LLVM's cmake configuration files currently sneak in a c++11 flag.
+  # We look for it here and remove it from Flang's compile flags to
+  # avoid some mixed compilation flangs (e.g. -std=c++11 ... -std=c++17).
+  if (DEFINED LLVM_CXX_STD)
+    message("LLVM configuration set a C++ standard: ${LLVM_CXX_STD}")
+    if (NOT LLVM_CXX_STD EQUAL "c++17")
+      message("Flang: Overriding LLVM's 'cxx_std' setting...")
+      message("    removing '-std=${LLVM_CXX_STD}'")
+      message("    CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
+      string(REPLACE " -std=${LLVM_CXX_STD}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+      message("    [NEW] CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
+    endif()
+  endif()
 
-# LLVM_LIT_EXTERNAL store in cache so it could be used by AddLLVM.cmake
-set(LLVM_EXTERNAL_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit CACHE STRING "Command used to spawn lit")
+  link_directories("${LLVM_LIBRARY_DIR}")
+
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
+    ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
+  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
+    ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
+
+  set(BACKEND_PACKAGE_STRING "LLVM ${LLVM_PACKAGE_VERSION}")
+  set(LLVM_EXTERNAL_LIT "${LLVM_TOOLS_BINARY_DIR}/llvm-lit" CACHE STRING "Command used to spawn lit")
+
+  option(FLANG_INCLUDE_TESTS
+         "Generate build targets for the Flang unit tests."
+         ON)
+  add_custom_target(check-all DEPENDS check-flang)
+else()
+  option(FLANG_INCLUDE_TESTS
+         "Generate build targets for the Flang unit tests."
+         ${LLVM_INCLUDE_TESTS})
+  set(FLANG_BINARY_DIR ${CMAKE_BINARY_DIR}/tools/flang)
+  set(BACKEND_PACKAGE_STRING "${PACKAGE_STRING}")
+  if (LINK_WITH_FIR)
+    set(MLIR_MAIN_SRC_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --src-root
+    set(MLIR_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --includedir
+    set(MLIR_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/mlir/include)
+    set(MLIR_TABLEGEN_EXE $<TARGET_FILE:mlir-tblgen>)
+    include_directories(SYSTEM ${MLIR_INCLUDE_DIR})
+    include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR})
+  endif()
+endif()
 
 if(LINK_WITH_FIR)
-  include(TableGen)
-  include(AddMLIR)
-  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
-  NO_DEFAULT_PATH)
   # tco tool and FIR lib output directories
   set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
   set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
@@ -102,62 +145,227 @@ if(LINK_WITH_FIR)
   message(STATUS "LLVM libraries: ${LLVM_COMMON_LIBS}")
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-      if(BUILD_WITH_CLANG_LIBRARIES)
-         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc++ -I${BUILD_WITH_CLANG_LIBRARIES}/include/c++/v1 -DCLANG_LIBRARIES")
-         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -Wl,-rpath,${BUILD_WITH_CLANG_LIBRARIES}/lib -L${BUILD_WITH_CLANG_LIBRARIES}/lib")
-      else()
-         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lstdc++")
-      endif()
-      if(GCC)
-         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
-      endif()
-   endif()
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall -Wextra -Werror")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcast-qual")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wimplicit-fallthrough")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdelete-non-virtual-dtor")
-   set(CMAKE_CXX_FLAGS_RELEASE    "-O2")
-   set(CMAKE_CXX_FLAGS_MINSIZEREL "-O2 '-DCHECK=(void)'")
-   set(CMAKE_CXX_FLAGS_DEBUG      "-g -DDEBUGF18")
-
-   # Building shared libraries is death on performance with GCC by default
-   # due to the need to preserve the right to override external entry points
-   # at dynamic link time.  -fno-semantic-interposition waives that right and
-   # recovers a little bit of that performance.
-   if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
-   endif()
+# Add Flang-centric modules to cmake path.
+include_directories(BEFORE
+  ${FLANG_BINARY_DIR}/include
+  ${FLANG_SOURCE_DIR}/include)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+
+if (NOT DEFAULT_SYSROOT)
+  set(DEFAULT_SYSROOT "" CACHE PATH
+    "The <path> to use for the system root for all compiler invocations (--sysroot=<path>).")
+endif()
+
+if (NOT ENABLE_LINKER_BUILD_ID)
+  set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
 endif()
 
+set(FLANG_DEFAULT_LINKER "" CACHE STRING
+  "Default linker to use (linker name or absolute path, empty for platform default)")
+
+set(FLANG_DEFAULT_RTLIB "" CACHE STRING
+   "Default Fortran runtime library to use (\"libFortranRuntime\"), leave empty for platform default.")
+
+if (NOT(FLANG_DEFAULT_RTLIB STREQUAL ""))
+  message(WARNING "Resetting Flang's default runtime library to use platform default.")
+  set(FLANG_DEFAULT_RTLIB "" CACHE STRING
+      "Default runtime library to use (empty for platform default)" FORCE)
+endif()
+
+
+
+set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
+# Override LLVM versioning for now...
 set(FLANG_VERSION_MAJOR      "0")
 set(FLANG_VERSION_MINOR      "1")
 set(FLANG_VERSION_PATCHLEVEL "0")
+
+
+if (NOT DEFINED FLANG_VERSION_MAJOR)
+  set(FLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
+endif()
+
+if (NOT DEFINED FLANG_VERSION_MINOR)
+  set(FLANG_VERSION_MINOR ${LLVM_VERSION_MINOR})
+endif()
+
+if (NOT DEFINED FLANG_VERSION_PATCHLEVEL)
+  set(FLANG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
+endif()
+
+# Unlike PACKAGE_VERSION, FLANG_VERSION does not include LLVM_VERSION_SUFFIX.
 set(FLANG_VERSION "${FLANG_VERSION_MAJOR}.${FLANG_VERSION_MINOR}.${FLANG_VERSION_PATCHLEVEL}")
-message(STATUS "FLANG version: ${FLANG_VERSION}")
+message(STATUS "Flang version: ${FLANG_VERSION}")
+# Flang executable version information
+set(FLANG_EXECUTABLE_VERSION
+    "${FLANG_VERSION_MAJOR}" CACHE STRING
+    "Major version number to appended to the flang executable name.")
+set(LIBFLANG_LIBRARY_VERSION
+    "${FLANG_VERSION_MAJOR}" CACHE STRING
+    "Major version number to appended to the libflang library.")
 
-set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
-set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
+mark_as_advanced(FLANG_EXECUTABLE_VERSION LIBFLANG_LIBRARY_VERSION)
 
-include_directories(BEFORE
-  ${FLANG_BINARY_DIR}/include
-  ${FLANG_SOURCE_DIR}/include
-  )
+set(FLANG_VENDOR ${PACKAGE_VENDOR} CACHE STRING
+  "Vendor-specific Flang version information.")
+set(FLANG_VENDOR_UTI "org.llvm.flang" CACHE STRING
+  "Vendor-specific uti.")
 
-enable_testing()
+if (FLANG_VENDOR)
+  add_definitions(-DFLANG_VENDOR="${FLANG_VENDOR} ")
+endif()
 
-add_subdirectory(include/flang)
-add_subdirectory(lib)
-add_subdirectory(runtime)
-add_subdirectory(unittests)
-add_subdirectory(tools)
-add_subdirectory(test)
+set(FLANG_REPOSITORY_STRING "" CACHE STRING
+  "Vendor-specific text for showing the repository the source is taken from.")
+if (FLANG_REPOSITORY_STRING)
+  add_definitions(-DFLANG_REPOSITORY_STRING="${FLANG_REPOSITORY_STRING}")
+endif()
 
+# Configure Flang's Version.inc file.
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/flang/Version.inc.in
+  ${CMAKE_CURRENT_BINARY_DIR}/include/flang/Version.inc)
+# Configure Flang's version info header file.
 configure_file(
   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
   ${FLANG_BINARY_DIR}/include/flang/Config/config.h)
+
+# Add global F18 flags.
+set(CMAKE_CXX_FLAGS "-fno-rtti -fno-exceptions -pedantic -Wall -Wextra -Werror -Wcast-qual -Wimplicit-fallthrough -Wdelete-non-virtual-dtor ${CMAKE_CXX_FLAGS}")
+
+# Builtin check_cxx_compiler_flag doesn't seem to work correctly
+macro(check_compiler_flag flag resultVar)
+  unset(${resultVar} CACHE)
+  check_cxx_compiler_flag("${flag}" ${resultVar})
+endmacro()
+
+check_compiler_flag("-Werror -Wno-deprecated-copy" CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
+if (CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy")
+endif()
+check_compiler_flag("-Wstring-conversion" CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
+if (CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
+endif()
+
+# Add appropriate flags for GCC
+if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
+
+  if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -fno-semantic-interposition")
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument -Wstring-conversion \
+          -Wcovered-switch-default")
+  endif()  # Clang.
+
+  check_cxx_compiler_flag("-Werror -Wnested-anon-types" CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
+  if (CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types")
+  endif()
+
+  # Add to or adjust build type flags.
+  #
+  # TODO: This needs some extra thought.  CMake's default for release builds
+  # is -O3, which can cause build failures on certain platforms (and compilers)
+  # with the current code base -- some templated functions are inlined and don't
+  # become available at link time when using -O3 (with Clang under MacOS/darwin).
+  # If we reset CMake's default flags we also clobber any user provided settings;
+  # make it difficult to customize a build in this regard...   The setup below
+  # has this side effect but enables successful builds across multiple platforms
+  # in release mode...
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGF18")
+  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DCHECK=\"(void)\"")  # do we need -O2 here?
+  set(CMAKE_CXX_FLAGS_RELEASE "-O2")
+
+  # Building shared libraries is bad for performance with GCC by default
+  # due to the need to preserve the right to override external entry points
+  if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+   set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
+  endif()
+
+endif()
+
+list(REMOVE_DUPLICATES CMAKE_CXX_FLAGS)
+
+# Determine HOST_LINK_VERSION on Darwin.
+set(HOST_LINK_VERSION)
+if (APPLE)
+  set(LD_V_OUTPUT)
+  execute_process(
+    COMMAND sh -c "${CMAKE_LINKER} -v 2>&1 | head -1"
+    RESULT_VARIABLE HAD_ERROR
+    OUTPUT_VARIABLE LD_V_OUTPUT)
+  if (NOT HAD_ERROR)
+    if ("${LD_V_OUTPUT}" MATCHES ".*ld64-([0-9.]+).*")
+      string(REGEX REPLACE ".*ld64-([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
+    elseif ("${LD_V_OUTPUT}" MATCHES "[^0-9]*([0-9.]+).*")
+      string(REGEX REPLACE "[^0-9]*([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
+    endif()
+  else()
+    message(FATAL_ERROR "${CMAKE_LINKER} failed with status ${HAD_ERROR}")
+  endif()
+endif()
+
+include(CMakeParseArguments)
+include(AddFlang)
+
+
+add_subdirectory(include)
+add_subdirectory(lib)
+add_subdirectory(cmake/modules)
+
+option(FLANG_BUILD_TOOLS
+  "Build the Flang tools. If OFF, just generate build targets." ON)
+if (FLANG_BUILD_TOOLS)
+  add_subdirectory(tools)
+endif()
+add_subdirectory(runtime)
+
+if (FLANG_INCLUDE_TESTS)
+  enable_testing()
+  add_subdirectory(test)
+  add_subdirectory(unittests)
+endif()
+
+# TODO: Add doxygen support.
+#option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
+#       ${LLVM_INCLUDE_DOCS})
+#if (FLANG_INCLUDE_DOCS)
+#  add_subdirectory(documentation)
+#endif()
+
+# Custom target to install Flang libraries.
+add_custom_target(flang-libraries)
+set_target_properties(flang-libraries PROPERTIES FOLDER "Misc")
+
+if (NOT LLVM_ENABLE_IDE)
+  add_llvm_install_targets(install-flang-libraries
+   DEPENDS flang-libraries
+   COMPONENT flang-libraries)
+endif()
+
+get_property(FLANG_LIBS GLOBAL PROPERTY FLANG_LIBS)
+if (FLANG_LIBS)
+  list(REMOVE_DUPLICATES FLANG_LIBS)
+  foreach(lib ${FLANG_LIBS})
+    add_dependencies(flang-libraries ${lib})
+    if (NOT LLVM_ENABLE_IDE)
+      add_dependencies(install-flang-libraries install-${lib})
+    endif()
+  endforeach()
+endif()
+
+if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+  install(DIRECTORY include/flang
+    DESTINATION include
+    COMPONENT flang-headers
+    FILES_MATCHING
+    PATTERN "*.def"
+    PATTERN "*.h"
+    PATTERN "*.inc"
+    PATTERN "*.td"
+    PATTERN "config.h" EXCLUDE
+    PATTERN ".git"     EXCLUDE
+    PATTERN "CMakeFiles" EXCLUDE)
+endif()
diff --git a/README.md b/README.md
index d8e2cbdef63b..926abc0ecf5d 100644
--- a/README.md
+++ b/README.md
@@ -150,15 +150,6 @@ or
 ```
 CXX=/opt/gcc-7.2/bin/g++-7.2 cmake ...
 ```
-There's a third option!
-The CMakeList.txt file uses the variable GCC
-as the path to the bin directory containing the C++ compiler.
-
-GCC can be defined on the cmake command line
-where `<GCC_DIRECTORY>` is the path to a GCC installation with bin, lib, etc:
-```
-cmake -DGCC=<GCC_DIRECTORY> ...
-```
 
 ### Building f18 with clang
 
@@ -166,27 +157,11 @@ To build f18 with clang,
 cmake needs to know how to find clang++
 and the GCC library and tools that were used to build clang++.
 
-The CMakeList.txt file expects either CXX or BUILD_WITH_CLANG to be set.
-
 CXX should include the full path to clang++
 or clang++ should be found on your PATH.
 ```
 export CXX=clang++
 ```
-BUILD_WITH_CLANG can be defined on the cmake command line
-where `<CLANG_DIRECTORY>`
-is the path to a clang installation with bin, lib, etc:
-```
-cmake -DBUILD_WITH_CLANG=<CLANG_DIRECTORY>
-```
-Or GCC can be defined on the f18 cmake command line
-where `<GCC_DIRECTORY>` is the path to a GCC installation with bin, lib, etc:
-```
-cmake -DGCC=<GCC_DIRECTORY> ...
-```
-To use f18 after it is built,
-the environment variables PATH and LD_LIBRARY_PATH
-must be set to use GCC and its associated libraries.
 
 ### Installation Directory
 
diff --git a/cmake/modules/AddFlang.cmake b/cmake/modules/AddFlang.cmake
new file mode 100644
index 000000000000..84610a633a04
--- /dev/null
+++ b/cmake/modules/AddFlang.cmake
@@ -0,0 +1,141 @@
+macro(set_flang_windows_version_resource_properties name)
+  if (DEFINED windows_resource_file)
+    set_windows_version_resource_properties(${name} ${windows_resource_file}
+      VERSION_MAJOR ${FLANG_VERSION_MAJOR}
+      VERSION_MINOR ${FLANG_VERSION_MINOR}
+      VERSION_PATCHLEVEL ${FLANG_VERSION_PATCHLEVEL}
+      VERSION_STRING "${FLANG_VERSION} (${BACKEND_PACKAGE_STRING})"
+      PRODUCT_NAME "flang")
+  endif()
+endmacro()
+
+macro(add_flang_subdirectory name)
+  add_llvm_subdirectory(FLANG TOOL ${name})
+endmacro()
+
+macro(add_flang_library name)
+  cmake_parse_arguments(ARG
+    "SHARED"
+    ""
+    "ADDITIONAL_HEADERS"
+    ${ARGN})
+  set(srcs)
+  if (MSVC_IDE OR XCODE)
+    # Add public headers
+    file(RELATIVE_PATH lib_path
+      ${FLANG_SOURCE_DIR}/lib/
+      ${CMAKE_CURRENT_SOURCE_DIR})
+    if(NOT lib_path MATCHES "^[.][.]")
+      file( GLOB_RECURSE headers
+        ${FLANG_SOURCE_DIR}/include/flang/${lib_path}/*.h
+        ${FLANG_SOURCE_DIR}/include/flang/${lib_path}/*.def)
+      set_source_files_properties(${headers} PROPERTIES HEADER_FILE_ONLY ON)
+
+      if (headers)
+        set(srcs ${headers})
+      endif()
+    endif()
+  endif(MSVC_IDE OR XCODE)
+
+  if (srcs OR ARG_ADDITIONAL_HEADERS)
+    set(srcs
+      ADDITIONAL_HEADERS
+      ${srcs}
+      ${ARG_ADDITIONAL_HEADERS}) # It may contain unparsed unknown args.
+      
+  endif()
+
+  if (ARG_SHARED)
+    set(LIBTYPE SHARED)
+  else()
+    # llvm_add_library ignores BUILD_SHARED_LIBS if STATIC is explicitly set,
+    # so we need to handle it here.
+    if (BUILD_SHARED_LIBS)
+      set(LIBTYPE SHARED OBJECT)
+    else()
+      set(LIBTYPE STATIC OBJECT)
+    endif()
+    set_property(GLOBAL APPEND PROPERTY FLANG_STATIC_LIBS ${name})
+  endif()
+
+  llvm_add_library(${name} ${LIBTYPE} ${ARG_UNPARSED_ARGUMENTS} ${srcs})
+
+  if (TARGET ${name})
+    target_link_libraries(${name} INTERFACE ${LLVM_COMMON_LIBS})
+
+    if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "libflang")
+      set(export_to_flangtargets)
+      if (${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
+          "flang-libraries" IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
+          NOT LLVM_DISTRIBUTION_COMPONENTS)
+        set(export_to_flangtargets EXPORT FlangTargets)
+        set_property(GLOBAL PROPERTY FLANG_HAS_EXPORTS True)
+      endif()
+
+      install(TARGETS ${name}
+        COMPONENT ${name}
+        ${export_to_flangtargets}
+        LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
+        ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
+        RUNTIME DESTINATION bin)
+
+      if (NOT LLVM_ENABLE_IDE)
+        add_llvm_install_targets(install-${name}
+                                 DEPENDS ${name}
+                                 COMPONENT ${name})
+      endif()
+
+      set_property(GLOBAL APPEND PROPERTY FLANG_LIBS ${name})
+    endif()
+    set_property(GLOBAL APPEND PROPERTY FLANG_EXPORTS ${name})
+  else()
+    # Add empty "phony" target
+    add_custom_target(${name})
+  endif()
+
+  set_target_properties(${name} PROPERTIES FOLDER "Flang libraries")
+  set_flang_windows_version_resource_properties(${name})
+endmacro(add_flang_library)
+
+macro(add_flang_executable name)
+  add_llvm_executable(${name} ${ARGN})
+  set_target_properties(${name} PROPERTIES FOLDER "Flang executables")
+  set_flang_windows_version_resource_properties(${name})
+endmacro(add_flang_executable)
+
+macro(add_flang_tool name)
+  if (NOT FLANG_BUILD_TOOLS)
+    set(EXCLUDE_FROM_ALL ON)
+  endif()
+
+  add_flang_executable(${name} ${ARGN})
+  add_dependencies(${name} flang-resource-headers)
+
+  if (FLANG_BUILD_TOOLS)
+    set(export_to_flangtargets)
+    if (${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
+        NOT LLVM_DISTRIBUTION_COMPONENTS)
+      set(export_to_flangtargets EXPORT FlangTargets)
+      set_property(GLOBAL PROPERTY FLANG_HAS_EXPORTS True)
+    endif()
+
+    install(TARGETS ${name}
+      ${export_to_flangtargets}
+      RUNTIME DESTINATION bin
+      COMPONENT ${name})
+
+    if(NOT LLVM_ENABLE_IDE)
+      add_llvm_install_targets(install-${name}
+                               DEPENDS ${name}
+                               COMPONENT ${name})
+    endif()
+    set_property(GLOBAL APPEND PROPERTY FLANG_EXPORTS ${name})
+  endif()
+endmacro()
+
+macro(add_flang_symlink name dest)
+  add_llvm_tool_symlink(${name} ${dest} ALWAYS_GENERATE)
+  # Always generate install targets
+  llvm_install_symlink(${name} ${dest} ALWAYS_GENERATE)
+endmacro()
+
diff --git a/cmake/modules/CMakeLists.txt b/cmake/modules/CMakeLists.txt
new file mode 100644
index 000000000000..4822124ca412
--- /dev/null
+++ b/cmake/modules/CMakeLists.txt
@@ -0,0 +1,74 @@
+# Generate a list of CMake library targets so that other CMake projects can
+# link against them. LLVM calls its version of this file LLVMExports.cmake, but
+# the usual CMake convention seems to be ${Project}Targets.cmake.
+set(FLANG_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/flang)
+set(flang_cmake_builddir "${CMAKE_BINARY_DIR}/${FLANG_INSTALL_PACKAGE_DIR}")
+
+# Keep this in sync with llvm/cmake/CMakeLists.txt!
+set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
+set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
+
+get_property(FLANG_EXPORTS GLOBAL PROPERTY FLANG_EXPORTS)
+export(TARGETS ${FLANG_EXPORTS} FILE ${flang_cmake_builddir}/FlangTargets.cmake)
+
+# Generate FlangConfig.cmake for the build tree.
+set(FLANG_CONFIG_CMAKE_DIR "${flang_cmake_builddir}")
+set(FLANG_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
+set(FLANG_CONFIG_EXPORTS_FILE "${flang_cmake_builddir}/FlangTargets.cmake")
+set(FLANG_CONFIG_INCLUDE_DIRS
+  "${FLANG_SOURCE_DIR}/include"
+  "${FLANG_BINARY_DIR}/include"
+  )
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/FlangConfig.cmake.in
+  ${flang_cmake_builddir}/FlangConfig.cmake
+  @ONLY)
+set(FLANG_CONFIG_CMAKE_DIR)
+set(FLANG_CONFIG_LLVM_CMAKE_DIR)
+set(FLANG_CONFIG_EXPORTS_FILE)
+
+# Generate FlangConfig.cmake for the install tree.
+set(FLANG_CONFIG_CODE "
+  # Compute the installation prefix from this LLVMConfig.cmake file location.
+  get_filename_component(FLANG_INSTALL_PREFIX \"\${CMAKE_CURRENT_LIST_FILE}\" PATH)")
+# Construct the proper number of get_filename_component(... PATH)
+# calls to compute the installation prefix.
+string(REGEX REPLACE "/" ";" _count "${FLANG_INSTALL_PACKAGE_DIR}")
+foreach(p ${_count})
+  set(FLANG_CONFIG_CODE "${FLANG_CONFIG_CODE}
+      get_filename_component(FLANG_INSTALL_PREFIX \"\${FLANG_INSTALL_PREFIX}\" PATH)")
+endforeach(p)
+
+set(FLANG_CONFIG_CMAKE_DIR "\${FLANG_INSTALL_PREFIX}/${FLANG_INSTALL_PACKAGE_DIR}")
+set(FLANG_CONFIG_LLVM_CMAKE_DIR "\${FLANG_INSTALL_PREFIX}/${LLVM_INSTALL_PACKAGE_DIR}")
+set(FLANG_CONFIG_EXPORTS_FILE "\${FLANG_CMAKE_DIR}/FlangTargets.cmake")
+set(FLANG_CONFIG_INCLUDE_DIRS "\${FLANG_INSTALL_PREFIX}/include")
+
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/FlangConfig.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/FlangConfig.cmake
+  @ONLY)
+
+set(FLANG_CONFIG_CODE)
+set(FLANG_CONFIG_CMAKE_DIR)
+set(FLANG_CONFIG_EXPORTS_FILE)
+
+if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+  get_property(flang_has_exports GLOBAL PROPERTY FLANG_HAS_EXPORTS)
+  if(flang_has_exports)
+    install(EXPORT FlangTargets DESTINATION ${FLANG_INSTALL_PACKAGE_DIR}
+            COMPONENT flang-cmake-exports)
+  endif()
+
+  install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/FlangConfig.cmake
+    DESTINATION ${FLANG_INSTALL_PACKAGE_DIR}
+    COMPONENT flang-cmake-exports)
+
+  if(NOT LLVM_ENABLE_IDE)
+    # Add a dummy target so this can be used with LLVM_DISTRIBUTION_COMPONENTS
+    add_custom_target(flang-cmake-exports)
+    add_llvm_install_targets(install-flang-cmake-exports
+                             COMPONENT flang-cmake-exports)
+  endif()
+endif()
diff --git a/cmake/modules/FlangConfig.cmake.in b/cmake/modules/FlangConfig.cmake.in
new file mode 100644
index 000000000000..3540e2df3406
--- /dev/null
+++ b/cmake/modules/FlangConfig.cmake.in
@@ -0,0 +1,13 @@
+# This file allows users to call find_package(Flang) and pick up our targets.
+
+@FLANG_CONFIG_CODE@
+
+find_package(LLVM REQUIRED CONFIG
+             HINTS "@FLANG_CONFIG_LLVM_CMAKE_DIR@")
+
+set(FLANG_EXPORTED_TARGETS "@FLANG_EXPORTS@")
+set(FLANG_CMAKE_DIR "FLANG_CONFIG_CMAKE_DIR@")
+set(FLANG_INCLUDE_DIRS "@FLANG_CONFIG_INCLUDE_DIRS@")
+
+# Provide all our library targets to users.
+include("@FLANG_CONFIG_EXPORTS_FILE@")
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
new file mode 100644
index 000000000000..e6bb9db72ff6
--- /dev/null
+++ b/include/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(flang)
diff --git a/include/flang/Version.inc.in b/include/flang/Version.inc.in
new file mode 100644
index 000000000000..a0eeab2686a9
--- /dev/null
+++ b/include/flang/Version.inc.in
@@ -0,0 +1,5 @@
+#define FLANG_VERSION @FLANG_VERSION@
+#define FLANG_VERSION_STRING "@FLANG_VERSION@"
+#define FLANG_VERSION_MAJOR @FLANG_VERSION_MAJOR@
+#define FLANG_VERSION_MINOR @FLANG_VERSION_MINOR@
+#define FLANG_VERSION_PATCHLEVEL @FLANG_VERSION_PATCHLEVEL@
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index f2fe30dca5a1..ae321b872a76 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,11 +1,3 @@
-#===-- lib/CMakeLists.txt --------------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
 add_subdirectory(Common)
 add_subdirectory(Evaluate)
 add_subdirectory(Decimal)
diff --git a/lib/Common/CMakeLists.txt b/lib/Common/CMakeLists.txt
index acbe9d125b99..f1be58f0e6d0 100644
--- a/lib/Common/CMakeLists.txt
+++ b/lib/Common/CMakeLists.txt
@@ -1,10 +1,3 @@
-#===-- lib/Common/CMakeLists.txt -------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
 
 add_library(FortranCommon
   Fortran.cpp
@@ -13,6 +6,8 @@ add_library(FortranCommon
   idioms.cpp
 )
 
+target_compile_features(FortranCommon PUBLIC cxx_std_17)
+
 install (TARGETS FortranCommon
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib
diff --git a/lib/Decimal/CMakeLists.txt b/lib/Decimal/CMakeLists.txt
index 54542187aea4..92f87621fc05 100644
--- a/lib/Decimal/CMakeLists.txt
+++ b/lib/Decimal/CMakeLists.txt
@@ -1,16 +1,11 @@
-#===-- lib/Decimal/CMakeLists.txt ------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
 
 add_library(FortranDecimal
   binary-to-decimal.cpp
   decimal-to-binary.cpp
 )
 
+target_compile_features(FortranDecimal PUBLIC cxx_std_17)
+
 install (TARGETS FortranDecimal
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib
diff --git a/lib/Evaluate/CMakeLists.txt b/lib/Evaluate/CMakeLists.txt
index a3391dc40394..2b23455165aa 100644
--- a/lib/Evaluate/CMakeLists.txt
+++ b/lib/Evaluate/CMakeLists.txt
@@ -1,10 +1,3 @@
-#===-- lib/Evaluate/CMakeLists.txt -----------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
 
 add_library(FortranEvaluate
   call.cpp
@@ -34,6 +27,8 @@ add_library(FortranEvaluate
   variable.cpp
 )
 
+target_compile_features(FortranEvaluate PUBLIC cxx_std_17)
+
 target_link_libraries(FortranEvaluate
   FortranCommon
   FortranDecimal
diff --git a/lib/Parser/CMakeLists.txt b/lib/Parser/CMakeLists.txt
index a04f37c71aec..9dc6480a2e9d 100644
--- a/lib/Parser/CMakeLists.txt
+++ b/lib/Parser/CMakeLists.txt
@@ -1,10 +1,3 @@
-#===-- lib/Parser/CMakeLists.txt -------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
 
 add_library(FortranParser
   Fortran-parsers.cpp
@@ -32,6 +25,8 @@ add_library(FortranParser
   user-state.cpp
 )
 
+target_compile_features(FortranParser PRIVATE cxx_std_17)
+
 target_link_libraries(FortranParser
   FortranCommon
   LLVMSupport
diff --git a/lib/Semantics/CMakeLists.txt b/lib/Semantics/CMakeLists.txt
index cbe9fc9b6b30..1ca03d05341f 100644
--- a/lib/Semantics/CMakeLists.txt
+++ b/lib/Semantics/CMakeLists.txt
@@ -1,10 +1,3 @@
-#===-- lib/Semantics/CMakeLists.txt ----------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
 
 add_library(FortranSemantics
   assignment.cpp
@@ -43,6 +36,8 @@ add_library(FortranSemantics
   unparse-with-symbols.cpp
 )
 
+target_compile_features(FortranSemantics PUBLIC cxx_std_17)
+
 target_link_libraries(FortranSemantics
   FortranCommon
   FortranEvaluate
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index cdc5dd58d3ca..3e22d9f18c82 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,7 +1,9 @@
 # Test runner infrastructure for Flang. This configures the Flang test trees
 # for use by Lit, and delegates to LLVM's lit test handlers.
 
-set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/tools/f18/include)
+set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/include/flang)
+
+set(FLANG_TOOLS_DIR ${FLANG_BINARY_DIR}/bin)
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
@@ -10,6 +12,8 @@ configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
 )
 
+add_subdirectory(Semantics)
+
 set(FLANG_TEST_PARAMS
   flang_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py)
 
@@ -21,10 +25,16 @@ if (LINK_WITH_FIR)
   list(APPEND FLANG_TEST_DEPENDS tco)
 endif()
 
-add_lit_testsuite(check-all "Running the Flang regression tests"
+add_custom_target(flang-test-depends DEPENDS ${FLANG_TEST_DEPENDS})
+
+add_lit_testsuite(check-flang "Running the Flang regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   PARAMS ${FLANG_TEST_PARAMS}
   DEPENDS ${FLANG_TEST_DEPENDS}
   )
-set_target_properties(check-all PROPERTIES FOLDER "Tests")
+set_target_properties(check-flang PROPERTIES FOLDER "Tests")
+
+add_lit_testsuites(FLANG ${CMAKE_CURRENT_SOURCE_DIR}
+  PARAMS ${FLANG_TEST_PARAMS}
+  DEPENDS ${FLANG_TEST_DEPENDS})
 
diff --git a/test/Semantics/CMakeLists.txt b/test/Semantics/CMakeLists.txt
new file mode 100644
index 000000000000..bdc81bbbe18c
--- /dev/null
+++ b/test/Semantics/CMakeLists.txt
@@ -0,0 +1 @@
+configure_file(test_errors.sh.in ${FLANG_BINARY_DIR}/test/Semantics/test_errors.sh @ONLY)
diff --git a/test/Semantics/allocate01.f90 b/test/Semantics/allocate01.f90
index 0948230a3ea2..4907a9d9e21f 100644
--- a/test/Semantics/allocate01.f90
+++ b/test/Semantics/allocate01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 ! Creating a symbol that allocate should accept
diff --git a/test/Semantics/allocate02.f90 b/test/Semantics/allocate02.f90
index 13a68e811a55..16895ef35001 100644
--- a/test/Semantics/allocate02.f90
+++ b/test/Semantics/allocate02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 
 ! Check for semantic errors in ALLOCATE statements
 
diff --git a/test/Semantics/allocate03.f90 b/test/Semantics/allocate03.f90
index 63598f0786df..21b093ddefe9 100644
--- a/test/Semantics/allocate03.f90
+++ b/test/Semantics/allocate03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C933_a(b1, ca3, ca4, cp3, cp3mold, cp4, cp7, cp8, bsrc)
diff --git a/test/Semantics/allocate04.f90 b/test/Semantics/allocate04.f90
index 40e7562938df..9371fcb2b1af 100644
--- a/test/Semantics/allocate04.f90
+++ b/test/Semantics/allocate04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 
diff --git a/test/Semantics/allocate05.f90 b/test/Semantics/allocate05.f90
index 84814b674735..e69ed9e5399f 100644
--- a/test/Semantics/allocate05.f90
+++ b/test/Semantics/allocate05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 
diff --git a/test/Semantics/allocate06.f90 b/test/Semantics/allocate06.f90
index 1de258ccfb46..ae9f4f60d318 100644
--- a/test/Semantics/allocate06.f90
+++ b/test/Semantics/allocate06.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 
diff --git a/test/Semantics/allocate07.f90 b/test/Semantics/allocate07.f90
index 14077a24013e..5f261f332381 100644
--- a/test/Semantics/allocate07.f90
+++ b/test/Semantics/allocate07.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C936(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
diff --git a/test/Semantics/allocate08.f90 b/test/Semantics/allocate08.f90
index 3e235fcc9cdc..7733b3a0767a 100644
--- a/test/Semantics/allocate08.f90
+++ b/test/Semantics/allocate08.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C945_a(srca, srcb, srcc, src_complex, src_logical, &
diff --git a/test/Semantics/allocate09.f90 b/test/Semantics/allocate09.f90
index 61046fb13ce2..6e20521fedd7 100644
--- a/test/Semantics/allocate09.f90
+++ b/test/Semantics/allocate09.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C946(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
diff --git a/test/Semantics/allocate10.f90 b/test/Semantics/allocate10.f90
index c15dc57b4472..2746f8e1e6dc 100644
--- a/test/Semantics/allocate10.f90
+++ b/test/Semantics/allocate10.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 !TODO: mixing expr and source-expr?
diff --git a/test/Semantics/allocate11.f90 b/test/Semantics/allocate11.f90
index b883edc4980a..594bd1ded385 100644
--- a/test/Semantics/allocate11.f90
+++ b/test/Semantics/allocate11.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 ! TODO: Function Pointer in allocate and derived types!
diff --git a/test/Semantics/allocate12.f90 b/test/Semantics/allocate12.f90
index 41de8edc83ed..52fabf888f78 100644
--- a/test/Semantics/allocate12.f90
+++ b/test/Semantics/allocate12.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C941_C942b_C950(xsrc, x1, a2, b2, cx1, ca2, cb1, cb2, c1)
diff --git a/test/Semantics/allocate13.f90 b/test/Semantics/allocate13.f90
index b7010f5b0c89..99812f9d3df6 100644
--- a/test/Semantics/allocate13.f90
+++ b/test/Semantics/allocate13.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 module not_iso_fortran_env
diff --git a/test/Semantics/altreturn01.f90 b/test/Semantics/altreturn01.f90
index 0449ff774c36..b35d0799d154 100644
--- a/test/Semantics/altreturn01.f90
+++ b/test/Semantics/altreturn01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check calls with alt returns
 
        CALL TEST (N, *100, *200 )
diff --git a/test/Semantics/altreturn02.f90 b/test/Semantics/altreturn02.f90
index 74ff96933a83..a09df81f6ada 100644
--- a/test/Semantics/altreturn02.f90
+++ b/test/Semantics/altreturn02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check subroutine with alt return
 
        SUBROUTINE TEST (N, *, *)
diff --git a/test/Semantics/altreturn03.f90 b/test/Semantics/altreturn03.f90
index 73a63860efc7..15c5ce650b96 100644
--- a/test/Semantics/altreturn03.f90
+++ b/test/Semantics/altreturn03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for various alt return error conditions
 
        SUBROUTINE TEST (N, *, *)
diff --git a/test/Semantics/altreturn04.f90 b/test/Semantics/altreturn04.f90
index e3714fb92223..4a9cf5b13ee3 100644
--- a/test/Semantics/altreturn04.f90
+++ b/test/Semantics/altreturn04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Functions cannot use alt return
 
 REAL FUNCTION altreturn01(X)
diff --git a/test/Semantics/altreturn05.f90 b/test/Semantics/altreturn05.f90
index cbd222cba9e7..baa8bcfa11ea 100644
--- a/test/Semantics/altreturn05.f90
+++ b/test/Semantics/altreturn05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test extension: RETURN from main program
 
 return !ok
diff --git a/test/Semantics/assign01.f90 b/test/Semantics/assign01.f90
index bd41a5b5cc9f..e8ec06785843 100644
--- a/test/Semantics/assign01.f90
+++ b/test/Semantics/assign01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! 10.2.3.1(2) All masks and LHS of assignments in a WHERE must conform
 
 subroutine s1
diff --git a/test/Semantics/assign02.f90 b/test/Semantics/assign02.f90
index e97be64d6aab..c504f7a8ab1f 100644
--- a/test/Semantics/assign02.f90
+++ b/test/Semantics/assign02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Pointer assignment constraints 10.2.2.2
 
 module m1
diff --git a/test/Semantics/assign03.f90 b/test/Semantics/assign03.f90
index 5b9fe269addc..62749641ea29 100644
--- a/test/Semantics/assign03.f90
+++ b/test/Semantics/assign03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Pointer assignment constraints 10.2.2.2 (see also assign02.f90)
 
 module m
diff --git a/test/Semantics/assign04.f90 b/test/Semantics/assign04.f90
index dd0159bdd0bd..c12857c66fd2 100644
--- a/test/Semantics/assign04.f90
+++ b/test/Semantics/assign04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! 9.4.5
 subroutine s1
   type :: t(k, l)
diff --git a/test/Semantics/bad-forward-type.f90 b/test/Semantics/bad-forward-type.f90
index 62ad9d4b2b4c..0c6de01ad06e 100644
--- a/test/Semantics/bad-forward-type.f90
+++ b/test/Semantics/bad-forward-type.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Forward references to derived types (error cases)
 
 !ERROR: The derived type 'undef' was forward-referenced but not defined
diff --git a/test/Semantics/bindings01.f90 b/test/Semantics/bindings01.f90
index 54aaacd2e9f8..4c517ad6c439 100644
--- a/test/Semantics/bindings01.f90
+++ b/test/Semantics/bindings01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Confirm enforcement of constraints and restrictions in 7.5.7.3
 ! and C779-C785.
 
diff --git a/test/Semantics/block-data01.f90 b/test/Semantics/block-data01.f90
index 164709118f6f..d9c6dcd0843a 100644
--- a/test/Semantics/block-data01.f90
+++ b/test/Semantics/block-data01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test BLOCK DATA subprogram (14.3)
 block data foo
   !ERROR: IMPORT is not allowed in a BLOCK DATA subprogram
diff --git a/test/Semantics/blockconstruct01.f90 b/test/Semantics/blockconstruct01.f90
index 7f7eec5b56c3..86c4ff1a77bd 100644
--- a/test/Semantics/blockconstruct01.f90
+++ b/test/Semantics/blockconstruct01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1107 -- COMMON, EQUIVALENCE, INTENT, NAMELIST, OPTIONAL, VALUE or
 !          STATEMENT FUNCTIONS not allow in specification part
 
diff --git a/test/Semantics/blockconstruct02.f90 b/test/Semantics/blockconstruct02.f90
index 2a1a95f312bf..77ce3c1a8f57 100644
--- a/test/Semantics/blockconstruct02.f90
+++ b/test/Semantics/blockconstruct02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1108  --  Save statement in a BLOCK construct shall not conatin a
 !            saved-entity-list that does not specify a common-block-name
 
diff --git a/test/Semantics/blockconstruct03.f90 b/test/Semantics/blockconstruct03.f90
index df5aff7699ea..3f1974d19408 100644
--- a/test/Semantics/blockconstruct03.f90
+++ b/test/Semantics/blockconstruct03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Tests implemented for this standard:
 !            Block Construct
 ! C1109
diff --git a/test/Semantics/c_f_pointer.f90 b/test/Semantics/c_f_pointer.f90
index 1064461c509d..ab1b479cfa7d 100644
--- a/test/Semantics/c_f_pointer.f90
+++ b/test/Semantics/c_f_pointer.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Enforce 18.2.3.3
 
 program test
diff --git a/test/Semantics/call01.f90 b/test/Semantics/call01.f90
index 88274dd42844..ed77fb81026f 100644
--- a/test/Semantics/call01.f90
+++ b/test/Semantics/call01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Confirm enforcement of constraints and restrictions in 15.6.2.1
 
 non_recursive function f01(n) result(res)
diff --git a/test/Semantics/call02.f90 b/test/Semantics/call02.f90
index 5d9bdf1cd5a2..e100a8fcc483 100644
--- a/test/Semantics/call02.f90
+++ b/test/Semantics/call02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! 15.5.1 procedure reference constraints and restrictions
 
 subroutine s01(elem, subr)
diff --git a/test/Semantics/call03.f90 b/test/Semantics/call03.f90
index 098106aed45e..13aba93a2f00 100644
--- a/test/Semantics/call03.f90
+++ b/test/Semantics/call03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.5.2.4 constraints and restrictions for non-POINTER non-ALLOCATABLE
 ! dummy arguments.
 
diff --git a/test/Semantics/call04.f90 b/test/Semantics/call04.f90
index 3064fee5decc..120cd5435a73 100644
--- a/test/Semantics/call04.f90
+++ b/test/Semantics/call04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 8.5.10 & 8.5.18 constraints on dummy argument declarations
 
 module m
diff --git a/test/Semantics/call05.f90 b/test/Semantics/call05.f90
index 80f1874ff2d5..a7cd6d9f9b78 100644
--- a/test/Semantics/call05.f90
+++ b/test/Semantics/call05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.5.2.5 constraints and restrictions for POINTER & ALLOCATABLE
 ! arguments when both sides of the call have the same attributes.
 
diff --git a/test/Semantics/call06.f90 b/test/Semantics/call06.f90
index eb4bd3755f87..77eb0c406e5e 100644
--- a/test/Semantics/call06.f90
+++ b/test/Semantics/call06.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.5.2.6 constraints and restrictions for ALLOCATABLE
 ! dummy arguments.
 
diff --git a/test/Semantics/call07.f90 b/test/Semantics/call07.f90
index f596e3600288..af9be0235435 100644
--- a/test/Semantics/call07.f90
+++ b/test/Semantics/call07.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.5.2.7 constraints and restrictions for POINTER dummy arguments.
 
 module m
diff --git a/test/Semantics/call08.f90 b/test/Semantics/call08.f90
index 88ec7e3b4cca..ae4497f316f7 100644
--- a/test/Semantics/call08.f90
+++ b/test/Semantics/call08.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.5.2.8 coarray dummy arguments
 
 module m
diff --git a/test/Semantics/call09.f90 b/test/Semantics/call09.f90
index 02224477a28f..337932d3fe0d 100644
--- a/test/Semantics/call09.f90
+++ b/test/Semantics/call09.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.5.2.9(2,3,5) dummy procedure requirements
 
 module m
diff --git a/test/Semantics/call10.f90 b/test/Semantics/call10.f90
index 567d85d5d0e0..74a0474175f6 100644
--- a/test/Semantics/call10.f90
+++ b/test/Semantics/call10.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.7 (C1583-C1590, C1592-C1599) constraints and restrictions
 ! for pure procedures.
 ! (C1591 is tested in call11.f90; C1594 in call12.f90.)
diff --git a/test/Semantics/call11.f90 b/test/Semantics/call11.f90
index b53b40334e93..d7b590427794 100644
--- a/test/Semantics/call11.f90
+++ b/test/Semantics/call11.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.7 C1591 & others: contexts requiring pure subprograms
 
 module m
diff --git a/test/Semantics/call12.f90 b/test/Semantics/call12.f90
index 3ce0812560ac..e25a2608c441 100644
--- a/test/Semantics/call12.f90
+++ b/test/Semantics/call12.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.7 C1594 - prohibited assignments in pure subprograms
 
 module used
diff --git a/test/Semantics/call13.f90 b/test/Semantics/call13.f90
index 952a7d0c8b1d..23ef745f8e1c 100644
--- a/test/Semantics/call13.f90
+++ b/test/Semantics/call13.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 15.4.2.2 constraints and restrictions for calls to implicit
 ! interfaces
 
diff --git a/test/Semantics/call14.f90 b/test/Semantics/call14.f90
index e25620b2694b..b874e6b00912 100644
--- a/test/Semantics/call14.f90
+++ b/test/Semantics/call14.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 8.5.18 constraints on the VALUE attribute
 
 module m
diff --git a/test/Semantics/call15.f90 b/test/Semantics/call15.f90
index 08886e4e7c6d..1f6646755205 100644
--- a/test/Semantics/call15.f90
+++ b/test/Semantics/call15.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C711 An assumed-type actual argument that corresponds to an assumed-rank 
 ! dummy argument shall be assumed-shape or assumed-rank.
 subroutine s(arg1, arg2, arg3)
diff --git a/test/Semantics/canondo16.f90 b/test/Semantics/canondo16.f90
index d5c5db464930..8eebde23b22f 100644
--- a/test/Semantics/canondo16.f90
+++ b/test/Semantics/canondo16.f90
@@ -1,11 +1,11 @@
-! RUN: %S/test_any.sh %s %flang %t
+! RUN: %S/test_any.sh %s %f18 %t
 ! Error test -- DO loop uses obsolete loop termination statement
 ! See R1131 and C1133
 
 ! By default, this is not an error and label do are rewritten to non-label do.
 ! A warning is generated with -Mstandard
 
-! EXEC: ${F18} -funparse-with-symbols -Mstandard -I../../tools/f18/include %s 2>&1 | ${FileCheck} %s
+! EXEC: ${F18} -funparse-with-symbols -Mstandard -I../../include/flang %s 2>&1 | ${FileCheck} %s
 
 ! CHECK: end do
 
diff --git a/test/Semantics/coarrays01.f90 b/test/Semantics/coarrays01.f90
index 3e8e1672a47b..c96e76ceebbd 100644
--- a/test/Semantics/coarrays01.f90
+++ b/test/Semantics/coarrays01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test selector and team-value in CHANGE TEAM statement
 
 ! OK
diff --git a/test/Semantics/complex01.f90 b/test/Semantics/complex01.f90
index c70f0defad6a..060760ff6e5a 100644
--- a/test/Semantics/complex01.f90
+++ b/test/Semantics/complex01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C718 Each named constant in a complex literal constant shall be of type 
 ! integer or real.
 subroutine s()
diff --git a/test/Semantics/computed-goto01.f90 b/test/Semantics/computed-goto01.f90
index 9f24996f41a0..ff38b729608c 100644
--- a/test/Semantics/computed-goto01.f90
+++ b/test/Semantics/computed-goto01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check that a basic computed goto compiles
 
 INTEGER, DIMENSION (2) :: B
diff --git a/test/Semantics/computed-goto02.f90 b/test/Semantics/computed-goto02.f90
index eea61a827052..aaca63ab3bad 100644
--- a/test/Semantics/computed-goto02.f90
+++ b/test/Semantics/computed-goto02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check that computed goto express must be a scalar integer expression
 ! TODO: PGI, for example, accepts a float & converts the value to int.
 
diff --git a/test/Semantics/critical01.f90 b/test/Semantics/critical01.f90
index 5ca97ade6998..1fa2553a5d9a 100644
--- a/test/Semantics/critical01.f90
+++ b/test/Semantics/critical01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !C1117
 
 subroutine test1(a, i)
diff --git a/test/Semantics/critical02.f90 b/test/Semantics/critical02.f90
index ba5e0f4c55a7..a339c46c3192 100644
--- a/test/Semantics/critical02.f90
+++ b/test/Semantics/critical02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !C1118
 
 subroutine test1
diff --git a/test/Semantics/critical03.f90 b/test/Semantics/critical03.f90
index 2ab60e5d59a9..2964a3b5321f 100644
--- a/test/Semantics/critical03.f90
+++ b/test/Semantics/critical03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !C1119
 
 subroutine test1(a, i)
diff --git a/test/Semantics/data01.f90 b/test/Semantics/data01.f90
index 4bdf7ea9dd4a..1c8608993868 100644
--- a/test/Semantics/data01.f90
+++ b/test/Semantics/data01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !Test for checking data constraints, C882-C887
 module m1
   type person
diff --git a/test/Semantics/data02.f90 b/test/Semantics/data02.f90
index ac6902622d83..361f3a2793a3 100644
--- a/test/Semantics/data02.f90
+++ b/test/Semantics/data02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check that expressions are analyzed in data statements
 
 subroutine s1
diff --git a/test/Semantics/deallocate01.f90 b/test/Semantics/deallocate01.f90
index 8aaf14496d71..9aa69e77876d 100644
--- a/test/Semantics/deallocate01.f90
+++ b/test/Semantics/deallocate01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test that DEALLOCATE works
 
 INTEGER, PARAMETER :: maxvalue=1024
diff --git a/test/Semantics/deallocate04.f90 b/test/Semantics/deallocate04.f90
index 2a1ad62b9920..ce9acf994684 100644
--- a/test/Semantics/deallocate04.f90
+++ b/test/Semantics/deallocate04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for type errors in DEALLOCATE statements
 
 INTEGER, PARAMETER :: maxvalue=1024
diff --git a/test/Semantics/deallocate05.f90 b/test/Semantics/deallocate05.f90
index fdc66004e2ce..862d88578b5f 100644
--- a/test/Semantics/deallocate05.f90
+++ b/test/Semantics/deallocate05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in DEALLOCATE statements
 
 Module share
diff --git a/test/Semantics/doconcurrent01.f90 b/test/Semantics/doconcurrent01.f90
index a4161a5c3073..7a3f9c078e00 100644
--- a/test/Semantics/doconcurrent01.f90
+++ b/test/Semantics/doconcurrent01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1141
 ! A reference to the procedure IEEE_SET_HALTING_MODE ! from the intrinsic 
 ! module IEEE_EXCEPTIONS, shall not ! appear within a DO CONCURRENT construct.
diff --git a/test/Semantics/doconcurrent05.f90 b/test/Semantics/doconcurrent05.f90
index d92ef6d18322..df548f23e8b5 100644
--- a/test/Semantics/doconcurrent05.f90
+++ b/test/Semantics/doconcurrent05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1167 -- An exit-stmt shall not appear within a DO CONCURRENT construct if 
 ! it belongs to that construct or an outer construct.
 
diff --git a/test/Semantics/doconcurrent06.f90 b/test/Semantics/doconcurrent06.f90
index f178b7a11640..e20a830f5d80 100644
--- a/test/Semantics/doconcurrent06.f90
+++ b/test/Semantics/doconcurrent06.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1167 -- An exit-stmt shall not appear within a DO CONCURRENT construct if 
 ! it belongs to that construct or an outer construct.
 
diff --git a/test/Semantics/doconcurrent08.f90 b/test/Semantics/doconcurrent08.f90
index 91a077fade49..826bc84b20ae 100644
--- a/test/Semantics/doconcurrent08.f90
+++ b/test/Semantics/doconcurrent08.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1140 -- A statement that might result in the deallocation of a polymorphic 
 ! entity shall not appear within a DO CONCURRENT construct.
 module m1
diff --git a/test/Semantics/dosemantics01.f90 b/test/Semantics/dosemantics01.f90
index 2261f184e3cc..55eae4582396 100644
--- a/test/Semantics/dosemantics01.f90
+++ b/test/Semantics/dosemantics01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1131 -- check valid and invalid DO loop naming
 
 PROGRAM C1131
diff --git a/test/Semantics/dosemantics02.f90 b/test/Semantics/dosemantics02.f90
index 96047f0a3678..c40d3b842dbd 100644
--- a/test/Semantics/dosemantics02.f90
+++ b/test/Semantics/dosemantics02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1121 -- any procedure referenced in a concurrent header must be pure
 
 ! Also, check that the step expressions are not zero.  This is prohibited by
diff --git a/test/Semantics/dosemantics03.f90 b/test/Semantics/dosemantics03.f90
index c063a7b8c854..f82a7e4879f7 100644
--- a/test/Semantics/dosemantics03.f90
+++ b/test/Semantics/dosemantics03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Issue 458 -- semantic checks for a normal DO loop.  The DO variable
 ! and the initial, final, and step expressions must be INTEGER if the
 ! options for standard conformance and turning warnings into errors
diff --git a/test/Semantics/dosemantics04.f90 b/test/Semantics/dosemantics04.f90
index 35a3c9493ca2..80bccf59d55e 100644
--- a/test/Semantics/dosemantics04.f90
+++ b/test/Semantics/dosemantics04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1123 -- Expressions in DO CONCURRENT header cannot reference variables
 ! declared in the same header
 PROGRAM dosemantics04
diff --git a/test/Semantics/dosemantics05.f90 b/test/Semantics/dosemantics05.f90
index f565f9b71679..4e660498e3a3 100644
--- a/test/Semantics/dosemantics05.f90
+++ b/test/Semantics/dosemantics05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test DO loop semantics for constraint C1130 --
 ! The constraint states that "If the locality-spec DEFAULT ( NONE ) appears in a
 ! DO CONCURRENT statement; a variable that is a local or construct entity of a
diff --git a/test/Semantics/dosemantics06.f90 b/test/Semantics/dosemantics06.f90
index 41b9598970b5..445eadcec6ca 100644
--- a/test/Semantics/dosemantics06.f90
+++ b/test/Semantics/dosemantics06.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1131, C1133 -- check valid and invalid DO loop naming
 ! C1131 (R1119) If the do-stmt of a do-construct specifies a do-construct-name,
 ! the corresponding end-do shall be an end-do-stmt specifying the same
diff --git a/test/Semantics/dosemantics07.f90 b/test/Semantics/dosemantics07.f90
index f1450dda31eb..95584075e2cc 100644
--- a/test/Semantics/dosemantics07.f90
+++ b/test/Semantics/dosemantics07.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !C1132
 ! If the do-stmt is a nonlabel-do-stmt, the corresponding end-do shall be an
 ! end-do-stmt.
diff --git a/test/Semantics/dosemantics08.f90 b/test/Semantics/dosemantics08.f90
index 388fb75254f8..431443a11a80 100644
--- a/test/Semantics/dosemantics08.f90
+++ b/test/Semantics/dosemantics08.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1138 -- 
 ! A branch (11.2) within a DO CONCURRENT construct shall not have a branch
 ! target that is outside the construct.
diff --git a/test/Semantics/dosemantics09.f90 b/test/Semantics/dosemantics09.f90
index 46136f29c74e..3d53e39ff3ee 100644
--- a/test/Semantics/dosemantics09.f90
+++ b/test/Semantics/dosemantics09.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !C1129 
 !A variable that is referenced by the scalar-mask-expr of a
 !concurrent-header or by any concurrent-limit or concurrent-step in that
diff --git a/test/Semantics/dosemantics10.f90 b/test/Semantics/dosemantics10.f90
index 561f9b7fb7ea..3d813184a3b4 100644
--- a/test/Semantics/dosemantics10.f90
+++ b/test/Semantics/dosemantics10.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1134 A CYCLE statement must be within a DO construct
 !
 ! C1166 An EXIT statement must be within a DO construct
diff --git a/test/Semantics/dosemantics11.f90 b/test/Semantics/dosemantics11.f90
index 760f9f5f9b60..226f0073f9a4 100644
--- a/test/Semantics/dosemantics11.f90
+++ b/test/Semantics/dosemantics11.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1135 A cycle-stmt shall not appear within a CHANGE TEAM, CRITICAL, or DO 
 ! CONCURRENT construct if it belongs to an outer construct.
 !
diff --git a/test/Semantics/dosemantics12.f90 b/test/Semantics/dosemantics12.f90
index 48ecd14feda5..4cd406e0892b 100644
--- a/test/Semantics/dosemantics12.f90
+++ b/test/Semantics/dosemantics12.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
 !
 ! Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/test/Semantics/entry01.f90 b/test/Semantics/entry01.f90
index ccb03a7f6083..f458ef515451 100644
--- a/test/Semantics/entry01.f90
+++ b/test/Semantics/entry01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Tests valid and invalid ENTRY statements
 
 module m1
diff --git a/test/Semantics/equivalence01.f90 b/test/Semantics/equivalence01.f90
index 31b561e33b0d..68b2cd4d38ef 100644
--- a/test/Semantics/equivalence01.f90
+++ b/test/Semantics/equivalence01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   integer i, j
   real r(2)
diff --git a/test/Semantics/expr-errors01.f90 b/test/Semantics/expr-errors01.f90
index a479e863dcaf..36064553684c 100644
--- a/test/Semantics/expr-errors01.f90
+++ b/test/Semantics/expr-errors01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1003 - can't parenthesize function call returning procedure pointer
 module m1
   type :: dt
diff --git a/test/Semantics/expr-errors02.f90 b/test/Semantics/expr-errors02.f90
index 4b0d6d4118f3..af51e1c3ee48 100644
--- a/test/Semantics/expr-errors02.f90
+++ b/test/Semantics/expr-errors02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test specification expressions
 
 module m
diff --git a/test/Semantics/forall01.f90 b/test/Semantics/forall01.f90
index ecb243bc2a09..f4652370bd18 100644
--- a/test/Semantics/forall01.f90
+++ b/test/Semantics/forall01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine forall1
   real :: a(9)
   !ERROR: 'i' is already declared in this scoping unit
diff --git a/test/Semantics/if_arith01.f90 b/test/Semantics/if_arith01.f90
index 5ec06b47485d..16e616fc5a0d 100644
--- a/test/Semantics/if_arith01.f90
+++ b/test/Semantics/if_arith01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check that a basic arithmetic if compiles.
 
 if ( A ) 100, 200, 300
diff --git a/test/Semantics/if_arith02.f90 b/test/Semantics/if_arith02.f90
index f8e24b42dffa..4dfe72d36a5d 100644
--- a/test/Semantics/if_arith02.f90
+++ b/test/Semantics/if_arith02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check that only labels are allowed in arithmetic if statements.
 ! TODO: Revisit error message "expected 'ASSIGN'" etc.
 ! TODO: Revisit error message "expected one of '0123456789'"
diff --git a/test/Semantics/if_arith03.f90 b/test/Semantics/if_arith03.f90
index 1e5eb67d184c..45ceec4e4e54 100644
--- a/test/Semantics/if_arith03.f90
+++ b/test/Semantics/if_arith03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 
 
 !ERROR: label '600' was not found
diff --git a/test/Semantics/if_arith04.f90 b/test/Semantics/if_arith04.f90
index 9a436cd5eb67..d947b0b1a7b0 100644
--- a/test/Semantics/if_arith04.f90
+++ b/test/Semantics/if_arith04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Make sure arithmetic if expressions are non-complex numeric exprs.
 
 INTEGER I
diff --git a/test/Semantics/if_construct01.f90 b/test/Semantics/if_construct01.f90
index c133b7d8cc9f..adac3c252cc2 100644
--- a/test/Semantics/if_construct01.f90
+++ b/test/Semantics/if_construct01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Simple check that if constructs are ok.
 
 if (a < b) then
diff --git a/test/Semantics/if_construct02.f90 b/test/Semantics/if_construct02.f90
index 9ba6caa45355..de9428649937 100644
--- a/test/Semantics/if_construct02.f90
+++ b/test/Semantics/if_construct02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check that if constructs only accept scalar logical expressions.
 ! TODO: expand the test to check this restriction for more types.
 
diff --git a/test/Semantics/if_stmt01.f90 b/test/Semantics/if_stmt01.f90
index 51454a9d2116..337d5190e329 100644
--- a/test/Semantics/if_stmt01.f90
+++ b/test/Semantics/if_stmt01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Simple check that if statements are ok.
 
 IF (A > 0.0) A = LOG (A)
diff --git a/test/Semantics/if_stmt02.f90 b/test/Semantics/if_stmt02.f90
index 71c458381ac2..5672811c4670 100644
--- a/test/Semantics/if_stmt02.f90
+++ b/test/Semantics/if_stmt02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !ERROR: IF statement is not allowed in IF statement
 IF (A > 0.0) IF (B < 0.0) A = LOG (A)
 END
diff --git a/test/Semantics/if_stmt03.f90 b/test/Semantics/if_stmt03.f90
index 2a2595404960..970b70e00889 100644
--- a/test/Semantics/if_stmt03.f90
+++ b/test/Semantics/if_stmt03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check that non-logical expressions are not allowed.
 ! Check that non-scalar expressions are not allowed.
 ! TODO: Insure all non-logicals are prohibited.
diff --git a/test/Semantics/implicit01.f90 b/test/Semantics/implicit01.f90
index f0893f7ed33f..5cc8709a4dfd 100644
--- a/test/Semantics/implicit01.f90
+++ b/test/Semantics/implicit01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   implicit none
   !ERROR: More than one IMPLICIT NONE statement
diff --git a/test/Semantics/implicit02.f90 b/test/Semantics/implicit02.f90
index 5d2b6e09474f..f30170587cf0 100644
--- a/test/Semantics/implicit02.f90
+++ b/test/Semantics/implicit02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   implicit none
   !ERROR: IMPLICIT statement after IMPLICIT NONE or IMPLICIT NONE(TYPE) statement
diff --git a/test/Semantics/implicit03.f90 b/test/Semantics/implicit03.f90
index 9636743233a3..bb6c4958da2d 100644
--- a/test/Semantics/implicit03.f90
+++ b/test/Semantics/implicit03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   implicit integer(a-z)
   !ERROR: IMPLICIT NONE statement after IMPLICIT statement
diff --git a/test/Semantics/implicit04.f90 b/test/Semantics/implicit04.f90
index 86adb95f9852..20de8c403037 100644
--- a/test/Semantics/implicit04.f90
+++ b/test/Semantics/implicit04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s
   parameter(a=1.0)
   !ERROR: IMPLICIT NONE statement after PARAMETER statement
diff --git a/test/Semantics/implicit05.f90 b/test/Semantics/implicit05.f90
index 7649c228fa44..e6dec7d61533 100644
--- a/test/Semantics/implicit05.f90
+++ b/test/Semantics/implicit05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s
   !ERROR: 'a' does not follow 'b' alphabetically
   implicit integer(b-a)
diff --git a/test/Semantics/implicit06.f90 b/test/Semantics/implicit06.f90
index 3f6672008d53..9f54282c2fd5 100644
--- a/test/Semantics/implicit06.f90
+++ b/test/Semantics/implicit06.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   implicit integer(a-c)
   !ERROR: More than one implicit type specified for 'c'
diff --git a/test/Semantics/implicit07.f90 b/test/Semantics/implicit07.f90
index 68fa37de8ce7..5ec659233f85 100644
--- a/test/Semantics/implicit07.f90
+++ b/test/Semantics/implicit07.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 implicit none(external)
 external x
 call x
diff --git a/test/Semantics/implicit08.f90 b/test/Semantics/implicit08.f90
index 44e96d89855e..a4a1c33fb233 100644
--- a/test/Semantics/implicit08.f90
+++ b/test/Semantics/implicit08.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   block
     !ERROR: IMPLICIT statement is not allowed in a BLOCK construct
diff --git a/test/Semantics/init01.f90 b/test/Semantics/init01.f90
index 1fc1ed877fa3..f8481506a809 100644
--- a/test/Semantics/init01.f90
+++ b/test/Semantics/init01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Object pointer initializer error tests
 
 subroutine test(j)
diff --git a/test/Semantics/int-literals.f90 b/test/Semantics/int-literals.f90
index 3c48b7e1b7da..01d31c5c0ca6 100644
--- a/test/Semantics/int-literals.f90
+++ b/test/Semantics/int-literals.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Fortran syntax considers signed int literals in complex literals
 ! to be a distinct production, not an application of unary +/- to
 ! an unsigned int literal, so they're used here to test overflow
diff --git a/test/Semantics/io01.f90 b/test/Semantics/io01.f90
index 81b537d7e4c5..56936b6e68fe 100644
--- a/test/Semantics/io01.f90
+++ b/test/Semantics/io01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   character(len=20) :: access = "direcT"
   character(len=20) :: access_(2) = (/"direcT", "streaM"/)
   character(len=20) :: action_(2) = (/"reaD ", "writE"/)
diff --git a/test/Semantics/io02.f90 b/test/Semantics/io02.f90
index 7cb901d34027..a405f3e91502 100644
--- a/test/Semantics/io02.f90
+++ b/test/Semantics/io02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   integer :: unit10 = 10
   integer :: unit11 = 11
 
diff --git a/test/Semantics/io03.f90 b/test/Semantics/io03.f90
index a6696176b126..6c91afc00b01 100644
--- a/test/Semantics/io03.f90
+++ b/test/Semantics/io03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   character(kind=1,len=50) internal_file
   character(kind=2,len=50) internal_file2
   character(kind=4,len=50) internal_file4
diff --git a/test/Semantics/io04.f90 b/test/Semantics/io04.f90
index 09776ef94ab1..5cda7fff8bc8 100644
--- a/test/Semantics/io04.f90
+++ b/test/Semantics/io04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   character(kind=1,len=50) internal_file
   character(kind=1,len=100) msg
   character(20) sign
diff --git a/test/Semantics/io05.f90 b/test/Semantics/io05.f90
index 1df878197237..8d10ab12416d 100644
--- a/test/Semantics/io05.f90
+++ b/test/Semantics/io05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   character*20 c(25), cv
   character(kind=1,len=59) msg
   logical*2 v(5), lv
diff --git a/test/Semantics/io06.f90 b/test/Semantics/io06.f90
index eba437c86c86..1b19fc6bc217 100644
--- a/test/Semantics/io06.f90
+++ b/test/Semantics/io06.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   character(kind=1,len=100) msg1
   character(kind=2,len=200) msg2
   integer(1) stat1
diff --git a/test/Semantics/io07.f90 b/test/Semantics/io07.f90
index 9462a099d67e..e3154689ab80 100644
--- a/test/Semantics/io07.f90
+++ b/test/Semantics/io07.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 1001 format(A)
 
      !ERROR: Format statement must be labeled
diff --git a/test/Semantics/io08.f90 b/test/Semantics/io08.f90
index 1b75e8094a9a..ca9638fb3a3f 100644
--- a/test/Semantics/io08.f90
+++ b/test/Semantics/io08.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   write(*,*)
   write(*,'()')
   write(*,'(A)')
diff --git a/test/Semantics/io09.f90 b/test/Semantics/io09.f90
index 5f50e4e0151e..7ce5e6435568 100644
--- a/test/Semantics/io09.f90
+++ b/test/Semantics/io09.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
   !ERROR: String edit descriptor in READ format expression
   read(*,'("abc")')
 
diff --git a/test/Semantics/io10.f90 b/test/Semantics/io10.f90
index 90ae8b194330..a3023861c1cf 100644
--- a/test/Semantics/io10.f90
+++ b/test/Semantics/io10.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !OPTIONS: -Mstandard
 
   write(*, '(B0)')
diff --git a/test/Semantics/kinds02.f90 b/test/Semantics/kinds02.f90
index f1ff0b27caf5..bdc998bbdfe7 100644
--- a/test/Semantics/kinds02.f90
+++ b/test/Semantics/kinds02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C712 The value of scalar-int-constant-expr shall be nonnegative and 
 ! shall specify a representation method that exists on the processor.
 ! C714 The value of kind-param shall be nonnegative.
diff --git a/test/Semantics/kinds04.f90 b/test/Semantics/kinds04.f90
index af6a8965ca65..54f953fec5ff 100644
--- a/test/Semantics/kinds04.f90
+++ b/test/Semantics/kinds04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C716 If both kind-param and exponent-letter appear, exponent-letter 
 ! shall be E.
 ! C717 The value of kind-param shall specify an approximation method that 
diff --git a/test/Semantics/misc-declarations.f90 b/test/Semantics/misc-declarations.f90
index 9103ad7bcf7d..7680eed793bc 100644
--- a/test/Semantics/misc-declarations.f90
+++ b/test/Semantics/misc-declarations.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Miscellaneous constraint and requirement checking on declarations:
 ! - 8.5.6.2 & 8.5.6.3 constraints on coarrays
 ! - 8.5.19 constraints on the VOLATILE attribute
diff --git a/test/Semantics/namelist01.f90 b/test/Semantics/namelist01.f90
index f659c998c7ef..b85357faf9ae 100644
--- a/test/Semantics/namelist01.f90
+++ b/test/Semantics/namelist01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test for checking namelist constraints, C8103-C8105
 
 module dup
diff --git a/test/Semantics/null01.f90 b/test/Semantics/null01.f90
index 09c6dce22c48..478bedbc44ed 100644
--- a/test/Semantics/null01.f90
+++ b/test/Semantics/null01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! NULL() intrinsic function error tests
 
 subroutine test
diff --git a/test/Semantics/nullify01.f90 b/test/Semantics/nullify01.f90
index 9af635f8f08c..62cde3055f77 100644
--- a/test/Semantics/nullify01.f90
+++ b/test/Semantics/nullify01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test that NULLIFY works
 
 Module share
diff --git a/test/Semantics/nullify02.f90 b/test/Semantics/nullify02.f90
index 49bcc9ef5d11..7a2408348cd4 100644
--- a/test/Semantics/nullify02.f90
+++ b/test/Semantics/nullify02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in NULLIFY statements
 
 INTEGER, PARAMETER :: maxvalue=1024
diff --git a/test/Semantics/omp-atomic.f90 b/test/Semantics/omp-atomic.f90
index 760d1ee4f619..2a27bfaf6011 100644
--- a/test/Semantics/omp-atomic.f90
+++ b/test/Semantics/omp-atomic.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP 2.13.6 atomic Construct
diff --git a/test/Semantics/omp-clause-validity01.f90 b/test/Semantics/omp-clause-validity01.f90
index 523b2eeb6c10..bcfea4c5b250 100644
--- a/test/Semantics/omp-clause-validity01.f90
+++ b/test/Semantics/omp-clause-validity01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP clause validity for the following directives:
diff --git a/test/Semantics/omp-declarative-directive.f90 b/test/Semantics/omp-declarative-directive.f90
index 639ed7d4d895..98787eea3031 100644
--- a/test/Semantics/omp-declarative-directive.f90
+++ b/test/Semantics/omp-declarative-directive.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP declarative directives
diff --git a/test/Semantics/omp-device-constructs.f90 b/test/Semantics/omp-device-constructs.f90
index 7973dc2ef77f..15daec33580a 100644
--- a/test/Semantics/omp-device-constructs.f90
+++ b/test/Semantics/omp-device-constructs.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 ! Check OpenMP clause validity for the following directives:
 !     2.10 Device constructs
diff --git a/test/Semantics/omp-loop-association.f90 b/test/Semantics/omp-loop-association.f90
index 22e9365b2f3f..036d7c3d124d 100644
--- a/test/Semantics/omp-loop-association.f90
+++ b/test/Semantics/omp-loop-association.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check the association between OpenMPLoopConstruct and DoConstruct
diff --git a/test/Semantics/omp-nested01.f90 b/test/Semantics/omp-nested01.f90
index 1c0e84ab8fd9..b13f536da27f 100644
--- a/test/Semantics/omp-nested01.f90
+++ b/test/Semantics/omp-nested01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! OPTIONS: -fopenmp
 
 ! Check OpenMP 2.17 Nesting of Regions
diff --git a/test/Semantics/omp-resolve01.f90 b/test/Semantics/omp-resolve01.f90
index 528915e88f8d..47479b4954f7 100644
--- a/test/Semantics/omp-resolve01.f90
+++ b/test/Semantics/omp-resolve01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.4 An array section designates a subset of the elements in an array. Although
diff --git a/test/Semantics/omp-resolve02.f90 b/test/Semantics/omp-resolve02.f90
index 3d341662b2da..3f28973a907b 100644
--- a/test/Semantics/omp-resolve02.f90
+++ b/test/Semantics/omp-resolve02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! Test the effect to name resolution from illegal clause
diff --git a/test/Semantics/omp-resolve03.f90 b/test/Semantics/omp-resolve03.f90
index a896ef30c9f4..8e20d23fafa6 100644
--- a/test/Semantics/omp-resolve03.f90
+++ b/test/Semantics/omp-resolve03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Although variables in common blocks can be accessed by use association
diff --git a/test/Semantics/omp-resolve04.f90 b/test/Semantics/omp-resolve04.f90
index 234013898b87..a216616eb2fd 100644
--- a/test/Semantics/omp-resolve04.f90
+++ b/test/Semantics/omp-resolve04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
diff --git a/test/Semantics/omp-resolve05.f90 b/test/Semantics/omp-resolve05.f90
index ebc50476b499..dc15b18a18db 100644
--- a/test/Semantics/omp-resolve05.f90
+++ b/test/Semantics/omp-resolve05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !OPTIONS: -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
diff --git a/test/Semantics/resolve01.f90 b/test/Semantics/resolve01.f90
index eee8d662517f..f64599ec06a0 100644
--- a/test/Semantics/resolve01.f90
+++ b/test/Semantics/resolve01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 integer :: x
 !ERROR: The type of 'x' has already been declared
 real :: x
diff --git a/test/Semantics/resolve02.f90 b/test/Semantics/resolve02.f90
index 0d8e83b0ed29..9978a95409e3 100644
--- a/test/Semantics/resolve02.f90
+++ b/test/Semantics/resolve02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s
   !ERROR: Declaration of 'x' conflicts with its use as internal procedure
   real :: x
diff --git a/test/Semantics/resolve03.f90 b/test/Semantics/resolve03.f90
index 773aaab3d453..825509da84d7 100644
--- a/test/Semantics/resolve03.f90
+++ b/test/Semantics/resolve03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 implicit none
 integer :: x
 !ERROR: No explicit type declared for 'y'
diff --git a/test/Semantics/resolve04.f90 b/test/Semantics/resolve04.f90
index 5132b9f780f6..eeb6cb686896 100644
--- a/test/Semantics/resolve04.f90
+++ b/test/Semantics/resolve04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !ERROR: No explicit type declared for 'f'
 function f()
   implicit none
diff --git a/test/Semantics/resolve05.f90 b/test/Semantics/resolve05.f90
index d1960e1808b1..89d501c664fd 100644
--- a/test/Semantics/resolve05.f90
+++ b/test/Semantics/resolve05.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 program p
   integer :: p ! this is ok
 end
diff --git a/test/Semantics/resolve06.f90 b/test/Semantics/resolve06.f90
index 276feb3b4ee4..c0fd7a1ae5d4 100644
--- a/test/Semantics/resolve06.f90
+++ b/test/Semantics/resolve06.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 implicit none
 allocatable :: x
 integer :: x
diff --git a/test/Semantics/resolve07.f90 b/test/Semantics/resolve07.f90
index f2e46f42a9d1..08156c4343f8 100644
--- a/test/Semantics/resolve07.f90
+++ b/test/Semantics/resolve07.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   integer :: x(2)
   !ERROR: The dimensions of 'x' have already been declared
diff --git a/test/Semantics/resolve08.f90 b/test/Semantics/resolve08.f90
index 7252c79ef033..db238a496133 100644
--- a/test/Semantics/resolve08.f90
+++ b/test/Semantics/resolve08.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 integer :: g(10)
 f(i) = i + 1  ! statement function
 g(i) = i + 2  ! mis-parsed array assignment
diff --git a/test/Semantics/resolve09.f90 b/test/Semantics/resolve09.f90
index 5104a371a639..cf9195992455 100644
--- a/test/Semantics/resolve09.f90
+++ b/test/Semantics/resolve09.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 integer :: y
 procedure() :: a
 procedure(real) :: b
diff --git a/test/Semantics/resolve10.f90 b/test/Semantics/resolve10.f90
index 9990935899fa..5506d3916c76 100644
--- a/test/Semantics/resolve10.f90
+++ b/test/Semantics/resolve10.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   public
   type t
diff --git a/test/Semantics/resolve11.f90 b/test/Semantics/resolve11.f90
index d94c0f8c87d1..1ff6a63ebf07 100644
--- a/test/Semantics/resolve11.f90
+++ b/test/Semantics/resolve11.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   public i
   integer, private :: j
diff --git a/test/Semantics/resolve12.f90 b/test/Semantics/resolve12.f90
index 03bad9f5616f..b68e3b76544f 100644
--- a/test/Semantics/resolve12.f90
+++ b/test/Semantics/resolve12.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m1
 end
 
diff --git a/test/Semantics/resolve13.f90 b/test/Semantics/resolve13.f90
index 6fc03b1e8be0..5ee05db5e782 100644
--- a/test/Semantics/resolve13.f90
+++ b/test/Semantics/resolve13.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m1
   integer :: x
   integer, private :: y
diff --git a/test/Semantics/resolve14.f90 b/test/Semantics/resolve14.f90
index 326fe8e94894..d24a5c621655 100644
--- a/test/Semantics/resolve14.f90
+++ b/test/Semantics/resolve14.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m1
   integer :: x
   integer :: y
diff --git a/test/Semantics/resolve15.f90 b/test/Semantics/resolve15.f90
index 1cca8ce3dd7b..d91713a2b91a 100644
--- a/test/Semantics/resolve15.f90
+++ b/test/Semantics/resolve15.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   real :: var
   interface i
diff --git a/test/Semantics/resolve16.f90 b/test/Semantics/resolve16.f90
index 8ce084a26fe9..a9d0842db7be 100644
--- a/test/Semantics/resolve16.f90
+++ b/test/Semantics/resolve16.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   interface
     subroutine sub0
diff --git a/test/Semantics/resolve17.f90 b/test/Semantics/resolve17.f90
index f9c9451dcfe2..4d1afee86b1a 100644
--- a/test/Semantics/resolve17.f90
+++ b/test/Semantics/resolve17.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   integer :: foo
   !Note: PGI, Intel, and GNU allow this; NAG and Sun do not
diff --git a/test/Semantics/resolve18.f90 b/test/Semantics/resolve18.f90
index dff395f4bc9b..50246ea01dc7 100644
--- a/test/Semantics/resolve18.f90
+++ b/test/Semantics/resolve18.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m1
   implicit none
 contains
diff --git a/test/Semantics/resolve19.f90 b/test/Semantics/resolve19.f90
index f28f2b45abdf..3234f4ccc1f2 100644
--- a/test/Semantics/resolve19.f90
+++ b/test/Semantics/resolve19.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   interface a
     subroutine s(x)
diff --git a/test/Semantics/resolve20.f90 b/test/Semantics/resolve20.f90
index 38dbd2367fe4..b38b8e35a494 100644
--- a/test/Semantics/resolve20.f90
+++ b/test/Semantics/resolve20.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   abstract interface
     subroutine foo
diff --git a/test/Semantics/resolve21.f90 b/test/Semantics/resolve21.f90
index 764537a565f5..dfd87b348591 100644
--- a/test/Semantics/resolve21.f90
+++ b/test/Semantics/resolve21.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   type :: t
     integer :: i
diff --git a/test/Semantics/resolve22.f90 b/test/Semantics/resolve22.f90
index 3549ec76e777..b9290cb9de23 100644
--- a/test/Semantics/resolve22.f90
+++ b/test/Semantics/resolve22.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   !OK: interface followed by type with same name
   interface t
diff --git a/test/Semantics/resolve23.f90 b/test/Semantics/resolve23.f90
index 41644843bf1f..ffd408f660dc 100644
--- a/test/Semantics/resolve23.f90
+++ b/test/Semantics/resolve23.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   type :: t
     real :: y
diff --git a/test/Semantics/resolve24.f90 b/test/Semantics/resolve24.f90
index c2ce595d9054..5b4a1adb11ab 100644
--- a/test/Semantics/resolve24.f90
+++ b/test/Semantics/resolve24.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine test1
   !ERROR: Generic interface 'foo' has both a function and a subroutine
   interface foo
diff --git a/test/Semantics/resolve25.f90 b/test/Semantics/resolve25.f90
index 4d3ec8c81495..780c07535bac 100644
--- a/test/Semantics/resolve25.f90
+++ b/test/Semantics/resolve25.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   interface foo
     subroutine s1(x)
diff --git a/test/Semantics/resolve26.f90 b/test/Semantics/resolve26.f90
index f39366faaef0..65cfccf0f68b 100644
--- a/test/Semantics/resolve26.f90
+++ b/test/Semantics/resolve26.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m1
   interface
     module subroutine s()
diff --git a/test/Semantics/resolve27.f90 b/test/Semantics/resolve27.f90
index b10105ed9e7d..c8e3d82b094f 100644
--- a/test/Semantics/resolve27.f90
+++ b/test/Semantics/resolve27.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   interface
     module subroutine s()
diff --git a/test/Semantics/resolve28.f90 b/test/Semantics/resolve28.f90
index 0fd81807c97f..17e603251518 100644
--- a/test/Semantics/resolve28.f90
+++ b/test/Semantics/resolve28.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s
   type t
   end type
diff --git a/test/Semantics/resolve29.f90 b/test/Semantics/resolve29.f90
index d328eba594e7..7dcd61671e5c 100644
--- a/test/Semantics/resolve29.f90
+++ b/test/Semantics/resolve29.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   type t1
   end type
diff --git a/test/Semantics/resolve30.f90 b/test/Semantics/resolve30.f90
index 98777124b134..c3abaf5fd1a6 100644
--- a/test/Semantics/resolve30.f90
+++ b/test/Semantics/resolve30.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   integer x
   block
diff --git a/test/Semantics/resolve31.f90 b/test/Semantics/resolve31.f90
index 3c61cd0bb9dc..a1fb7cea54b1 100644
--- a/test/Semantics/resolve31.f90
+++ b/test/Semantics/resolve31.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   integer :: t0
   !ERROR: 't0' is not a derived type
diff --git a/test/Semantics/resolve32.f90 b/test/Semantics/resolve32.f90
index 317a0ad9ed12..1b0140e285ed 100644
--- a/test/Semantics/resolve32.f90
+++ b/test/Semantics/resolve32.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m2
   public s2, s4
   private s3
diff --git a/test/Semantics/resolve33.f90 b/test/Semantics/resolve33.f90
index 4a37c5fb57aa..d4265cd3e2a0 100644
--- a/test/Semantics/resolve33.f90
+++ b/test/Semantics/resolve33.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Derived type parameters
 
 module m
diff --git a/test/Semantics/resolve34.f90 b/test/Semantics/resolve34.f90
index 9d148ff43046..39730cee62de 100644
--- a/test/Semantics/resolve34.f90
+++ b/test/Semantics/resolve34.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Extended derived types
 
 module m1
diff --git a/test/Semantics/resolve35.f90 b/test/Semantics/resolve35.f90
index 7f6a8ea9492b..d78c1cbd4b74 100644
--- a/test/Semantics/resolve35.f90
+++ b/test/Semantics/resolve35.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Construct names
 
 subroutine s1
diff --git a/test/Semantics/resolve36.f90 b/test/Semantics/resolve36.f90
index 7ed9391c2f9e..13f6a144db5c 100644
--- a/test/Semantics/resolve36.f90
+++ b/test/Semantics/resolve36.f90
@@ -1,8 +1,7 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 
 ! C1568 The procedure-name shall have been declared to be a separate module
 ! procedure in the containing program unit or an ancestor of that program unit.
-
 module m1
   interface
     module subroutine sub1(arg1)
diff --git a/test/Semantics/resolve37.f90 b/test/Semantics/resolve37.f90
index a07ebbc6625b..c56ac3719dd7 100644
--- a/test/Semantics/resolve37.f90
+++ b/test/Semantics/resolve37.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C701 The type-param-value for a kind type parameter shall be a constant
 ! expression.  This constraint looks like a mistake in the standard.
 integer, parameter :: k = 8
diff --git a/test/Semantics/resolve38.f90 b/test/Semantics/resolve38.f90
index 53e8db813380..98ac17f2d366 100644
--- a/test/Semantics/resolve38.f90
+++ b/test/Semantics/resolve38.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C772
 module m1
   type t1
diff --git a/test/Semantics/resolve39.f90 b/test/Semantics/resolve39.f90
index d0052f16f863..b34bbeca84f2 100644
--- a/test/Semantics/resolve39.f90
+++ b/test/Semantics/resolve39.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   implicit none
   real(8) :: x = 2.0
diff --git a/test/Semantics/resolve40.f90 b/test/Semantics/resolve40.f90
index 95c2c9e8034c..b4d8aa0d915a 100644
--- a/test/Semantics/resolve40.f90
+++ b/test/Semantics/resolve40.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   namelist /nl/x
   block
diff --git a/test/Semantics/resolve41.f90 b/test/Semantics/resolve41.f90
index e2bf877016ed..40522d8f4b7b 100644
--- a/test/Semantics/resolve41.f90
+++ b/test/Semantics/resolve41.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
   implicit none
   real, parameter :: a = 8.0
diff --git a/test/Semantics/resolve42.f90 b/test/Semantics/resolve42.f90
index 5b6ac9f88b2b..af5d6e5ee377 100644
--- a/test/Semantics/resolve42.f90
+++ b/test/Semantics/resolve42.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1
   !ERROR: Array 'z' without ALLOCATABLE or POINTER attribute must have explicit shape
   common x, y(4), z(:)
diff --git a/test/Semantics/resolve43.f90 b/test/Semantics/resolve43.f90
index 385dfedc34bd..2ef585a60021 100644
--- a/test/Semantics/resolve43.f90
+++ b/test/Semantics/resolve43.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Error tests for structure constructors.
 ! Errors caught by expression resolution are tested elsewhere; these are the
 ! errors meant to be caught by name resolution, as well as acceptable use
diff --git a/test/Semantics/resolve44.f90 b/test/Semantics/resolve44.f90
index dd082adc89df..2d8b70178753 100644
--- a/test/Semantics/resolve44.f90
+++ b/test/Semantics/resolve44.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Error tests for recursive use of derived types.
 
 program main
diff --git a/test/Semantics/resolve45.f90 b/test/Semantics/resolve45.f90
index e28dc33c4e72..bb5eaf4a5317 100644
--- a/test/Semantics/resolve45.f90
+++ b/test/Semantics/resolve45.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 function f1(x, y)
   integer x
   !ERROR: SAVE attribute may not be applied to dummy argument 'x'
diff --git a/test/Semantics/resolve46.f90 b/test/Semantics/resolve46.f90
index 181ccfb5c280..da31741163ab 100644
--- a/test/Semantics/resolve46.f90
+++ b/test/Semantics/resolve46.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C1030 - pointers to intrinsic procedures
 program main
   intrinsic :: cos ! a specific & generic intrinsic name
diff --git a/test/Semantics/resolve47.f90 b/test/Semantics/resolve47.f90
index 04dab5616855..0f27ee4b5fa2 100644
--- a/test/Semantics/resolve47.f90
+++ b/test/Semantics/resolve47.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m1
   !ERROR: Logical constant '.true.' may not be used as a defined operator
   interface operator(.TRUE.)
diff --git a/test/Semantics/resolve48.f90 b/test/Semantics/resolve48.f90
index 887505d16442..6651a72cfe84 100644
--- a/test/Semantics/resolve48.f90
+++ b/test/Semantics/resolve48.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test correct use-association of a derived type.
 module m1
   implicit none
diff --git a/test/Semantics/resolve49.f90 b/test/Semantics/resolve49.f90
index 97d2cbdb1267..583399044977 100644
--- a/test/Semantics/resolve49.f90
+++ b/test/Semantics/resolve49.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test section subscript
 program p1
   real :: a(10,10)
diff --git a/test/Semantics/resolve50.f90 b/test/Semantics/resolve50.f90
index 34d6f1c1d5d5..8158ab6bd72a 100644
--- a/test/Semantics/resolve50.f90
+++ b/test/Semantics/resolve50.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test coarray association in CHANGE TEAM statement
 
 subroutine s1
diff --git a/test/Semantics/resolve51.f90 b/test/Semantics/resolve51.f90
index de763ef49911..d2942a8f345b 100644
--- a/test/Semantics/resolve51.f90
+++ b/test/Semantics/resolve51.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test SELECT TYPE errors: C1157
 
 subroutine s1()
diff --git a/test/Semantics/resolve52.f90 b/test/Semantics/resolve52.f90
index 846b412f05ca..33eef54755af 100644
--- a/test/Semantics/resolve52.f90
+++ b/test/Semantics/resolve52.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Tests for C760:
 ! The passed-object dummy argument shall be a scalar, nonpointer, nonallocatable
 ! dummy data object with the same declared type as the type being defined;
diff --git a/test/Semantics/resolve53.f90 b/test/Semantics/resolve53.f90
index 1aee5e79bcc9..e501941f5a6f 100644
--- a/test/Semantics/resolve53.f90
+++ b/test/Semantics/resolve53.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! 15.4.3.4.5 Restrictions on generic declarations
 ! Specific procedures of generic interfaces must be distinguishable.
 
diff --git a/test/Semantics/resolve54.f90 b/test/Semantics/resolve54.f90
index f9f895fa7f05..f8b80fc126e4 100644
--- a/test/Semantics/resolve54.f90
+++ b/test/Semantics/resolve54.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Tests based on examples in C.10.6
 
 ! C.10.6(10)
diff --git a/test/Semantics/resolve55.f90 b/test/Semantics/resolve55.f90
index 98006bc0a07b..422168be90a8 100644
--- a/test/Semantics/resolve55.f90
+++ b/test/Semantics/resolve55.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Tests for C1128:
 ! A variable-name that appears in a LOCAL or LOCAL_INIT locality-spec shall not
 ! have the ALLOCATABLE; INTENT (IN); or OPTIONAL attribute; shall not be of
diff --git a/test/Semantics/resolve56.f90 b/test/Semantics/resolve56.f90
index 1efa535bd434..ef99f99ec620 100644
--- a/test/Semantics/resolve56.f90
+++ b/test/Semantics/resolve56.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test that associations constructs can be correctly combined. The intrinsic
 ! functions are not what is tested here, they are only use to reveal the types
 ! of local variables.
diff --git a/test/Semantics/resolve57.f90 b/test/Semantics/resolve57.f90
index 265decd3bcde..50843a1bbfbc 100644
--- a/test/Semantics/resolve57.f90
+++ b/test/Semantics/resolve57.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Tests for the last sentence of C1128:
 !A variable-name that is not permitted to appear in a variable definition
 !context shall not appear in a LOCAL or LOCAL_INIT locality-spec.
diff --git a/test/Semantics/resolve58.f90 b/test/Semantics/resolve58.f90
index db11e6779335..15fe4675c17d 100644
--- a/test/Semantics/resolve58.f90
+++ b/test/Semantics/resolve58.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1(x, y)
   !ERROR: Array pointer 'x' must have deferred shape or assumed rank
   real, pointer :: x(1:)  ! C832
diff --git a/test/Semantics/resolve59.f90 b/test/Semantics/resolve59.f90
index fdc437030971..49e46a9c8c7d 100644
--- a/test/Semantics/resolve59.f90
+++ b/test/Semantics/resolve59.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Testing 15.6.2.2 point 4 (What function-name refers to depending on the
 ! presence of RESULT).
 
diff --git a/test/Semantics/resolve60.f90 b/test/Semantics/resolve60.f90
index 3232bc0fb87a..811460e35975 100644
--- a/test/Semantics/resolve60.f90
+++ b/test/Semantics/resolve60.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Testing 7.6 enum
 
   ! OK
diff --git a/test/Semantics/resolve61.f90 b/test/Semantics/resolve61.f90
index eb5ba13a07a3..fe2840c74921 100644
--- a/test/Semantics/resolve61.f90
+++ b/test/Semantics/resolve61.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 program p1
   integer(8) :: a, b, c, d
   pointer(a, b)
diff --git a/test/Semantics/resolve62.f90 b/test/Semantics/resolve62.f90
index 5de3a45e900f..1ce28f3426cc 100644
--- a/test/Semantics/resolve62.f90
+++ b/test/Semantics/resolve62.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Resolve generic based on number of arguments
 subroutine s1
   interface f
diff --git a/test/Semantics/resolve63.f90 b/test/Semantics/resolve63.f90
index 07ae767d676b..59091574d5d8 100644
--- a/test/Semantics/resolve63.f90
+++ b/test/Semantics/resolve63.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Invalid operand types when user-defined operator is available
 module m1
   type :: t
diff --git a/test/Semantics/resolve64.f90 b/test/Semantics/resolve64.f90
index 3be2ae14fd5d..b0c2a608a4eb 100644
--- a/test/Semantics/resolve64.f90
+++ b/test/Semantics/resolve64.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 !OPTIONS: -flogical-abbreviations -fxor-operator
 
 ! Like m4 in resolve63 but compiled with different options.
diff --git a/test/Semantics/resolve65.f90 b/test/Semantics/resolve65.f90
index 9e1278b66dd5..f43d70bb22c7 100644
--- a/test/Semantics/resolve65.f90
+++ b/test/Semantics/resolve65.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test restrictions on what subprograms can be used for defined assignment.
 
 module m1
diff --git a/test/Semantics/resolve66.f90 b/test/Semantics/resolve66.f90
index d54fd2bfe66c..2f2e3595786c 100644
--- a/test/Semantics/resolve66.f90
+++ b/test/Semantics/resolve66.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test that user-defined assignment is used in the right places
 
 module m1
diff --git a/test/Semantics/resolve67.f90 b/test/Semantics/resolve67.f90
index 7a8537a0a65e..883909e13936 100644
--- a/test/Semantics/resolve67.f90
+++ b/test/Semantics/resolve67.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test restrictions on what subprograms can be used for defined operators.
 ! See: 15.4.3.4.2
 
diff --git a/test/Semantics/resolve68.f90 b/test/Semantics/resolve68.f90
index 6accdafd5263..caa6f2533f98 100644
--- a/test/Semantics/resolve68.f90
+++ b/test/Semantics/resolve68.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test resolution of type-bound generics.
 
 module m1
diff --git a/test/Semantics/resolve69.f90 b/test/Semantics/resolve69.f90
index 3bbc37e3f7aa..d5a35aa00306 100644
--- a/test/Semantics/resolve69.f90
+++ b/test/Semantics/resolve69.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 subroutine s1()
   ! C701 (R701) The type-param-value for a kind type parameter shall be a
   ! constant expression.
diff --git a/test/Semantics/resolve70.f90 b/test/Semantics/resolve70.f90
index 31f33c345b63..8f805b6be72d 100644
--- a/test/Semantics/resolve70.f90
+++ b/test/Semantics/resolve70.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C703 (R702) The derived-type-spec shall not specify an abstract type (7.5.7).
 ! This constraint refers to the derived-type-spec in a type-spec.  A type-spec
 ! can appear in an ALLOCATE statement, an ac-spec for an array constructor, and
diff --git a/test/Semantics/resolve71.f90 b/test/Semantics/resolve71.f90
index 8c1c56fd9b0e..b4a232ebc2fa 100644
--- a/test/Semantics/resolve71.f90
+++ b/test/Semantics/resolve71.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C708 An entity declared with the CLASS keyword shall be a dummy argument 
 ! or have the ALLOCATABLE or POINTER attribute.
 subroutine s()
diff --git a/test/Semantics/resolve72.f90 b/test/Semantics/resolve72.f90
index 284fb2fc2055..0e7dfcbfd762 100644
--- a/test/Semantics/resolve72.f90
+++ b/test/Semantics/resolve72.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C709 An assumed-type entity shall be a dummy data object that does not have 
 ! the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and 
 ! is not an explicit-shape array.
diff --git a/test/Semantics/resolve73.f90 b/test/Semantics/resolve73.f90
index 35f8429aeacf..195f7027a2a4 100644
--- a/test/Semantics/resolve73.f90
+++ b/test/Semantics/resolve73.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C721 A type-param-value of * shall be used only
 ! * to declare a dummy argument,
 ! * to declare a named constant,
diff --git a/test/Semantics/resolve74.f90 b/test/Semantics/resolve74.f90
index 60927b198769..79a1b2cec49d 100644
--- a/test/Semantics/resolve74.f90
+++ b/test/Semantics/resolve74.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C722 A function name shall not be declared with an asterisk type-param-value 
 ! unless it is of type CHARACTER and is the name of a dummy function or the 
 ! name of the result of an external function.
diff --git a/test/Semantics/resolve75.f90 b/test/Semantics/resolve75.f90
index 708ce8ffaeec..025159d78dd4 100644
--- a/test/Semantics/resolve75.f90
+++ b/test/Semantics/resolve75.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C726 The length specified for a character statement function or for a 
 ! statement function dummy argument of type character shall be a constant 
 ! expression.
diff --git a/test/Semantics/resolve76.f90 b/test/Semantics/resolve76.f90
index e68c81f36fb2..e5e22a99dd19 100644
--- a/test/Semantics/resolve76.f90
+++ b/test/Semantics/resolve76.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 
 ! 15.6.2.5(3)
 
diff --git a/test/Semantics/resolve77.f90 b/test/Semantics/resolve77.f90
index 4d34ce3b8b48..efd04d975c79 100644
--- a/test/Semantics/resolve77.f90
+++ b/test/Semantics/resolve77.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Tests valid and invalid usage of forward references to procedures
 ! in specification expressions.
 module m
diff --git a/test/Semantics/resolve78.f90 b/test/Semantics/resolve78.f90
index 0e4efc081009..280e1256dc55 100644
--- a/test/Semantics/resolve78.f90
+++ b/test/Semantics/resolve78.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
 ! C743 No component-attr-spec shall appear more than once in a 
 ! given component-def-stmt.
diff --git a/test/Semantics/resolve79.f90 b/test/Semantics/resolve79.f90
index 5d0e2127ea10..3bac3bf30583 100644
--- a/test/Semantics/resolve79.f90
+++ b/test/Semantics/resolve79.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
 ! C755 The same proc-component-attr-spec shall not appear more than once in a 
 ! given proc-component-def-stmt.
diff --git a/test/Semantics/resolve80.f90 b/test/Semantics/resolve80.f90
index 98f5c79a343b..4a196e26fc76 100644
--- a/test/Semantics/resolve80.f90
+++ b/test/Semantics/resolve80.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
 !C778 The same binding-attr shall not appear more than once in a given
 !binding-attr-list.
diff --git a/test/Semantics/resolve81.f90 b/test/Semantics/resolve81.f90
index 218d74ec6744..14f80ac9aaba 100644
--- a/test/Semantics/resolve81.f90
+++ b/test/Semantics/resolve81.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C801 The same attr-spec shall not appear more than once in a given
 ! type-declaration-stmt.
 !
diff --git a/test/Semantics/resolve82.f90 b/test/Semantics/resolve82.f90
index 378e8796db45..673abaa765ed 100644
--- a/test/Semantics/resolve82.f90
+++ b/test/Semantics/resolve82.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C815 An entity shall not be explicitly given any attribute more than once in 
 ! a scoping unit.
 !
diff --git a/test/Semantics/resolve83.f90 b/test/Semantics/resolve83.f90
index cdd528a688e2..c7a4502fd6f5 100644
--- a/test/Semantics/resolve83.f90
+++ b/test/Semantics/resolve83.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
 
   ! For C1543
diff --git a/test/Semantics/resolve84.f90 b/test/Semantics/resolve84.f90
index 79e393f4b689..06afdfc492e1 100644
--- a/test/Semantics/resolve84.f90
+++ b/test/Semantics/resolve84.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! C729 A derived type type-name shall not be DOUBLEPRECISION or the same as 
 ! the name of any intrinsic type defined in this document.
 subroutine s()
diff --git a/test/Semantics/resolve85.f90 b/test/Semantics/resolve85.f90
index d228b7d03e47..99391a364598 100644
--- a/test/Semantics/resolve85.f90
+++ b/test/Semantics/resolve85.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 module m
 ! C730 The same type-attr-spec shall not appear more than once in a given 
 ! derived-type-stmt.
diff --git a/test/Semantics/separate-mp01.f90 b/test/Semantics/separate-mp01.f90
index 305c147e66c9..b34b3500e28f 100644
--- a/test/Semantics/separate-mp01.f90
+++ b/test/Semantics/separate-mp01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 
 ! case 1: ma_create_new_fun' was not declared a separate module procedure
 module m1
diff --git a/test/Semantics/separate-mp02.f90 b/test/Semantics/separate-mp02.f90
index 1f514c2ccd37..823bfaca1413 100644
--- a/test/Semantics/separate-mp02.f90
+++ b/test/Semantics/separate-mp02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 
 ! When a module subprogram has the MODULE prefix the following must match
 ! with the corresponding separate module procedure interface body:
diff --git a/test/Semantics/stop01.f90 b/test/Semantics/stop01.f90
index 2ae8d65a84bb..69c5ad83e481 100644
--- a/test/Semantics/stop01.f90
+++ b/test/Semantics/stop01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 program main
   implicit none
   integer :: i = -1
diff --git a/test/Semantics/structconst01.f90 b/test/Semantics/structconst01.f90
index 68f0261cd85d..cdd2e77a506a 100644
--- a/test/Semantics/structconst01.f90
+++ b/test/Semantics/structconst01.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Error tests for structure constructors.
 ! Errors caught by name resolution are tested elsewhere; these are the
 ! errors meant to be caught by expression semantic analysis, as well as
diff --git a/test/Semantics/structconst02.f90 b/test/Semantics/structconst02.f90
index 22428651fa1c..a309b02e8fe0 100644
--- a/test/Semantics/structconst02.f90
+++ b/test/Semantics/structconst02.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Error tests for structure constructors: per-component type
 ! (in)compatibility.
 
diff --git a/test/Semantics/structconst03.f90 b/test/Semantics/structconst03.f90
index 776b4d082309..01d40720e771 100644
--- a/test/Semantics/structconst03.f90
+++ b/test/Semantics/structconst03.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Error tests for structure constructors: C1594 violations
 ! from assigning globally-visible data to POINTER components.
 ! test/Semantics/structconst04.f90 is this same test without type
diff --git a/test/Semantics/structconst04.f90 b/test/Semantics/structconst04.f90
index 07a9d69df868..3f0b21c6d5ec 100644
--- a/test/Semantics/structconst04.f90
+++ b/test/Semantics/structconst04.f90
@@ -1,4 +1,4 @@
-! RUN: %S/test_errors.sh %s %flang %t
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Error tests for structure constructors: C1594 violations
 ! from assigning globally-visible data to POINTER components.
 ! This test is structconst03.f90 with the type parameters removed.
diff --git a/test/Semantics/test_any.sh b/test/Semantics/test_any.sh
index b0735935928f..19fa22f1574d 100755
--- a/test/Semantics/test_any.sh
+++ b/test/Semantics/test_any.sh
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#/usr/bin/env bash
 # Compile a source file with '-funparse-with-symbols' and verify
 # we get the right symbols in the output, i.e. the output should be
 # the same as the input, except for the copyright comment.
@@ -7,7 +7,7 @@
 srcdir=$(dirname $0)
 source $srcdir/common.sh
 
-FileCheck=${FileCheck:=internal_check}
+FileCheck=internal_check
 
 function internal_check() {
   r=true
diff --git a/test/Semantics/test_errors.sh b/test/Semantics/test_errors.sh.in
similarity index 93%
rename from test/Semantics/test_errors.sh
rename to test/Semantics/test_errors.sh.in
index 9fcb06b03320..535ded3882bf 100755
--- a/test/Semantics/test_errors.sh
+++ b/test/Semantics/test_errors.sh.in
@@ -3,7 +3,7 @@
 # Change the compiler by setting the F18 environment variable.
 
 F18_OPTIONS="-fdebug-resolve-names -fparse-only"
-srcdir=$(dirname $0)
+srcdir="@CMAKE_CURRENT_SOURCE_DIR@"
 source $srcdir/common.sh
 [[ ! -f $src ]] && die "File not found: $src"
 
@@ -12,7 +12,7 @@ actual=$temp/actual
 expect=$temp/expect
 diffs=$temp/diffs
 
-include=$(dirname $(dirname $F18))/include
+include="@FLANG_INTRINSIC_MODULES_DIR@"
 cmd="$F18 $F18_OPTIONS $USER_OPTIONS -I$include $src"
 ( cd $temp; $cmd ) > $log 2>&1
 if [[ $? -ge 128 ]]; then
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index 57dc7383d88b..439f9710ef66 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -54,6 +54,8 @@
   if config.llvm_tools_dir != config.flang_llvm_tools_dir :
     llvm_config.with_environment('PATH', config.flang_llvm_tools_dir, append_path=True)
 
+config.substitutions.append(('%B', config.flang_obj_root))
+
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
 # to search to ensure that we get the tools just built and not some random
@@ -71,4 +73,4 @@
 # Enable libpgmath testing
 result = lit_config.params.get("LIBPGMATH")
 if result:
-    config.environment["LIBPGMATH"] = True
\ No newline at end of file
+    config.environment["LIBPGMATH"] = True
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index a02679436d14..b973127d3443 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -10,3 +10,4 @@ add_subdirectory(f18)
 if(LINK_WITH_FIR)
   add_subdirectory(tco)
 endif()
+add_subdirectory(f18-parse-demo)
diff --git a/tools/f18-parse-demo/CMakeLists.txt b/tools/f18-parse-demo/CMakeLists.txt
new file mode 100644
index 000000000000..fc64a3f0d904
--- /dev/null
+++ b/tools/f18-parse-demo/CMakeLists.txt
@@ -0,0 +1,13 @@
+add_llvm_tool(f18-parse-demo
+  f18-parse-demo.cpp
+  stub-evaluate.cpp
+  )
+set_property(TARGET f18-parse-demo PROPERTY CXX_STANDARD 17)
+target_compile_features(f18-parse-demo PRIVATE cxx_std_17)
+
+target_link_libraries(f18-parse-demo
+  PRIVATE
+  FortranParser
+  )
+
+#install(TARGETS f18-parse-demo DESTINATION bin)
diff --git a/tools/f18/f18-parse-demo.cpp b/tools/f18-parse-demo/f18-parse-demo.cpp
similarity index 100%
rename from tools/f18/f18-parse-demo.cpp
rename to tools/f18-parse-demo/f18-parse-demo.cpp
diff --git a/tools/f18/stub-evaluate.cpp b/tools/f18-parse-demo/stub-evaluate.cpp
similarity index 100%
rename from tools/f18/stub-evaluate.cpp
rename to tools/f18-parse-demo/stub-evaluate.cpp
diff --git a/tools/f18/CMakeLists.txt b/tools/f18/CMakeLists.txt
index b2f8e129e83a..8745f7c1caef 100644
--- a/tools/f18/CMakeLists.txt
+++ b/tools/f18/CMakeLists.txt
@@ -1,20 +1,12 @@
-#===-- tools/f18/CMakeLists.txt --------------------------------------------===#
-#
-# 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(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
-file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include")
-
-add_executable(f18
-  f18.cpp
+add_llvm_tool(f18
   dump.cpp
+  f18.cpp
 )
+set_property(TARGET f18 PROPERTY CXX_STANDARD 17)
+target_compile_features(f18 PRIVATE cxx_std_17)
 
 target_link_libraries(f18
+  PRIVATE
   FortranParser
   FortranEvaluate
   FortranSemantics
@@ -22,20 +14,6 @@ target_link_libraries(f18
   LLVMSupport
 )
 
-add_executable(f18-parse-demo
-  f18-parse-demo.cpp
-  stub-evaluate.cpp
-)
-
-target_link_libraries(f18-parse-demo
-  FortranParser
-)
-
-set_target_properties(f18 f18-parse-demo
-  PROPERTIES
-  RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
-)
-
 set(MODULES
   "ieee_arithmetic"
   "ieee_exceptions"
@@ -46,7 +24,9 @@ set(MODULES
   "__fortran_builtins"
 )
 
-set(include ${CMAKE_CURRENT_BINARY_DIR}/include)
+set(include ${FLANG_BINARY_DIR}/include/flang)
+
+set(include ${FLANG_BINARY_DIR}/include/flang)
 
 # Create module files directly from the top-level module source directory
 foreach(filename ${MODULES})
@@ -57,9 +37,9 @@ foreach(filename ${MODULES})
   endif()
   add_custom_command(OUTPUT ${include}/${filename}.mod
     COMMAND f18 -fparse-only -I${include}
-      ${PROJECT_SOURCE_DIR}/module/${filename}.f90
+      ${FLANG_SOURCE_DIR}/module/${filename}.f90
     WORKING_DIRECTORY ${include}
-    DEPENDS f18 ${PROJECT_SOURCE_DIR}/module/${filename}.f90 ${depends}
+    DEPENDS f18 ${FLANG_SOURCE_DIR}/module/${filename}.f90 ${depends}
   )
   add_custom_command(OUTPUT ${include}/${filename}.f18.mod
     DEPENDS ${include}/${filename}.mod
@@ -67,21 +47,19 @@ foreach(filename ${MODULES})
       copy ${include}/${filename}.mod ${include}/${filename}.f18.mod)
   list(APPEND MODULE_FILES ${include}/${filename}.mod)
   list(APPEND MODULE_FILES ${include}/${filename}.f18.mod)
-  install(FILES ${include}/${filename}.mod DESTINATION include)
-  install(FILES ${include}/${filename}.f18.mod DESTINATION include)
+  install(FILES ${include}/${filename}.mod DESTINATION include/flang)
+  install(FILES ${include}/${filename}.f18.mod DESTINATION include/flang)
 endforeach()
 
 add_custom_target(module_files ALL DEPENDS ${MODULE_FILES})
 
-install(TARGETS f18 f18-parse-demo DESTINATION bin)
+install(TARGETS f18 DESTINATION bin)
 
-file(COPY flang.sh
-  DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/bin"
-  FILE_PERMISSIONS
-    OWNER_READ OWNER_WRITE OWNER_EXECUTE
-    GROUP_READ GROUP_EXECUTE
-    WORLD_READ WORLD_EXECUTE
-)
-file(RENAME "${CMAKE_CURRENT_BINARY_DIR}/bin/flang.sh" "${CMAKE_CURRENT_BINARY_DIR}/bin/flang")
+set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/include/flang)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/flang.sh.in ${CMAKE_BINARY_DIR}/tools/flang/bin/flang @ONLY)
+file(COPY ${CMAKE_BINARY_DIR}/tools/flang/bin/flang DESTINATION ${CMAKE_BINARY_DIR}/bin FILE_PERMISSIONS OWNER_EXECUTE OWNER_READ OWNER_WRITE) 
+# The flang script to be installed needs a different path to the headers.
+set(FLANG_INTRINSIC_MODULES_DIR ${CMAKE_INSTALL_PREFIX}/include/flang)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/flang.sh.in ${FLANG_BINARY_DIR}/bin/flang-install.sh @ONLY)
 
-install(PROGRAMS flang.sh DESTINATION bin RENAME flang)
+install(PROGRAMS ${FLANG_BINARY_DIR}/bin/flang-install.sh DESTINATION bin RENAME flang PERMISSIONS OWNER_EXECUTE OWNER_READ OWNER_WRITE)
diff --git a/tools/f18/flang.sh b/tools/f18/flang.sh.in
similarity index 95%
rename from tools/f18/flang.sh
rename to tools/f18/flang.sh.in
index bf37e99f4d22..7f0d1335aec4 100644
--- a/tools/f18/flang.sh
+++ b/tools/f18/flang.sh.in
@@ -26,4 +26,4 @@ function abspath() {
 
 wd=`abspath $(dirname "$0")/..`
 
-${wd}/bin/f18 -module-suffix .f18.mod -intrinsic-module-directory ${wd}/include $*
+${wd}/bin/f18 -module-suffix .f18.mod -intrinsic-module-directory @FLANG_INTRINSIC_MODULES_DIR@ $*
diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt
index 6d49e6c72b57..2171927aa104 100644
--- a/unittests/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -1,11 +1,3 @@
-#===-- test/CMakeLists.txt -------------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
 add_subdirectory(Decimal)
 add_subdirectory(Evaluate)
 add_subdirectory(Runtime)
diff --git a/unittests/Decimal/CMakeLists.txt b/unittests/Decimal/CMakeLists.txt
index 780c92e74475..f26aca5d0e9b 100644
--- a/unittests/Decimal/CMakeLists.txt
+++ b/unittests/Decimal/CMakeLists.txt
@@ -1,11 +1,4 @@
-#===-- test/Decimal/CMakeLists.txt -----------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 add_executable(quick-sanity-test
   quick-sanity-test.cpp
 )
@@ -24,4 +17,4 @@ target_link_libraries(thorough-test
   LLVMSupport
 )
 
-add_test(Sanity quick-sanity-test)
+add_test(NAME Sanity COMMAND quick-sanity-test)
diff --git a/unittests/Evaluate/CMakeLists.txt b/unittests/Evaluate/CMakeLists.txt
index fb195ae5730a..54c816ef6c55 100644
--- a/unittests/Evaluate/CMakeLists.txt
+++ b/unittests/Evaluate/CMakeLists.txt
@@ -1,11 +1,4 @@
-#===-- test/Evaluate/CMakeLists.txt ----------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 add_library(FortranEvaluateTesting
   testing.cpp
   fp-testing.cpp
diff --git a/unittests/Runtime/CMakeLists.txt b/unittests/Runtime/CMakeLists.txt
index 3f73b79132f9..a5297ac67821 100644
--- a/unittests/Runtime/CMakeLists.txt
+++ b/unittests/Runtime/CMakeLists.txt
@@ -1,18 +1,11 @@
-#===-- test/Runtime/CMakeLists.txt -----------------------------------------===#
-#
-# 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
-#
-#------------------------------------------------------------------------------#
-
 if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
 endif()
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
 add_library(RuntimeTesting
   testing.cpp
-)
+  )
 
 add_executable(format-test
   format.cpp
@@ -24,7 +17,7 @@ target_link_libraries(format-test
   LLVMSupport
 )
 
-add_test(Format format-test)
+add_test(NAME Format COMMAND format-test)
 
 add_executable(hello-world
   hello.cpp
@@ -36,7 +29,7 @@ target_link_libraries(hello-world
   LLVMSupport
 )
 
-add_test(HelloWorld hello-world)
+add_test(NAME HelloWorld COMMAND hello-world)
 
 add_executable(external-hello-world
   external-hello.cpp
@@ -49,7 +42,7 @@ target_link_libraries(external-hello-world
 
 add_executable(list-input-test
   list-input.cpp
-)
+  )
 
 target_link_libraries(list-input-test
   FortranRuntime
@@ -57,4 +50,4 @@ target_link_libraries(list-input-test
   LLVMSupport
 )
 
-add_test(ListInput list-input-test)
+add_test(NAME ListInput COMMAND list-input-test)

From 116f64315f6218a7f74a8ccdc25f94d322ac6344 Mon Sep 17 00:00:00 2001
From: Steve Scalpone <sscalpone@nvidia.com>
Date: Fri, 27 Mar 2020 09:23:32 -0700
Subject: [PATCH 103/345] [mlir rebase] Add MLIR config and react to MLIR name
 changes (#1090)

[mlir rebase] Add MLIR config and react to MLIR name changes

Similar to #1085.  Now use the MLIR package to set up paths for include files and libraries.  Three MLIR names changed:
 * VectorOpsDialect to VectorDialect
 * AffineOpsDialect to AffineDialect
 * createVectorizePass to createSuperVectorizePass

Update README.md to explain how to link with MLIR. Update the example gcc to version 8.3.

Update drone.io config to define -DMLIR_DIR

Co-authored-by: Jean Perier <jperier@nvidia.com>
---
 .drone.star                                  |  4 +--
 CMakeLists.txt                               |  4 +++
 README.md                                    | 34 ++++++++++++--------
 include/flang/Optimizer/Dialect/FIRDialect.h |  6 ++--
 4 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/.drone.star b/.drone.star
index 27ff72e911cf..b03169c5014a 100644
--- a/.drone.star
+++ b/.drone.star
@@ -14,7 +14,7 @@ def clang(arch):
                     "ninja install",
                     "cd ../..",
                     "mkdir build && cd build",
-                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
+                    'env CC=clang-8 CXX=clang++-8 CXXFLAGS="-UNDEBUG -stdlib=libc++" LDFLAGS="-fuse-ld=lld" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DMLIR_DIR=/drone/src/llvm-project/install/lib/cmake/mlir -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
                     "ninja -j8",
                     "ctest --output-on-failure -j24",
                     "ninja check-all",
@@ -40,7 +40,7 @@ def gcc(arch):
                         "ninja install",
                         "cd ../..",
                         "mkdir build && cd build",
-                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
+                        'env CC=gcc CXX=g++ CXXFLAGS="-UNDEBUG" LDFLAGS="-fuse-ld=gold" cmake -GNinja -DCMAKE_BUILD_TYPE=Release .. -DLLVM_DIR=/drone/src/llvm-project/install/lib/cmake/llvm -DMLIR_DIR=/drone/src/llvm-project/install/lib/cmake/mlir -DLLVM_EXTERNAL_LIT=/drone/src/llvm-project/build/bin/llvm-lit',
                         "ninja -j8",
                         "ctest --output-on-failure -j24",
                         "ninja check-all",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 54c5d52c45f6..dceeeb16f25a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -67,6 +67,10 @@ project(Flang)
 
   if(LINK_WITH_FIR)
     include(TableGen)
+    find_package(MLIR REQUIRED CONFIG)
+    # Use SYSTEM for the same reasons as for LLVM includes
+    include_directories(SYSTEM ${MLIR_INCLUDE_DIRS})
+    list(APPEND CMAKE_MODULE_PATH ${MLIR_DIR})
     include(AddMLIR)
     find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
       NO_DEFAULT_PATH)
diff --git a/README.md b/README.md
index 926abc0ecf5d..a64bab0cb912 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,9 @@
-<!--===- README.md 
-  
+<!--===- README.md
+
    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
-  
+
 -->
 
 # F18
@@ -72,12 +72,16 @@ https://llvm.org/docs/GettingStarted.html.
 We highly recommend using the same compiler to compile both llvm and f18.
 
 The f18 CMakeList.txt file uses
-the variable `LLVM_DIR` to find the installed components.
+the variable `LLVM_DIR` to find the installed LLVM components
+and
+the variable `MLIR_DIR` to find the installed MLIR components.
 
-To get the correct LLVM libraries included in your f18 build,
-define LLVM_DIR on the cmake command line.
+To get the correct LLVM and MLIR libraries included in your f18 build,
+define LLVM_DIR and MLIR_DIR on the cmake command line.
 ```
-LLVM=<LLVM_BUILD_DIR>/lib/cmake/llvm cmake -DLLVM_DIR=$LLVM ...
+LLVM=<LLVM_BUILD_DIR>/lib/cmake/llvm \
+MLIR=<LLVM_BUILD_DIR>/lib/cmake/mlir \
+cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ...
 ```
 where `LLVM_BUILD_DIR` is
 the top-level directory where LLVM was built.
@@ -121,7 +125,11 @@ make install
 ```
 
 Then, `-DLLVM_DIR` would have to be set to
- `<where/you/want/to/build/llvm>/install/lib/cmake/llvm` in f18 cmake command.
+ `<where/you/want/to/build/llvm>/install/lib/cmake/llvm`
+and, `-DMLIR_DIR` would have to be set to
+ `<where/you/want/to/build/llvm>/install/lib/cmake/mlir`
+
+in f18 cmake command.
 
 To run lit tests,
 `-DLLVM_EXTERNAL_LIT=<where/you/want/to/build/llvm>/build/bin/llvm-lit` must be
@@ -142,13 +150,13 @@ Or,
 cmake will use the variable CXX to find the C++ compiler.
 CXX should include the full path to the compiler
 or a name that will be found on your PATH,
-e.g. g++-7.2, assuming g++-7.2 is on your PATH.
+e.g. g++-8.3, assuming g++-8.3 is on your PATH.
 ```
-export CXX=g++-7.2
+export CXX=g++-8.3
 ```
 or
 ```
-CXX=/opt/gcc-7.2/bin/g++-7.2 cmake ...
+CXX=/opt/gcc-8.3/bin/g++-8.3 cmake ...
 ```
 
 ### Building f18 with clang
@@ -189,7 +197,7 @@ Release builds execute quickly.
 ### Build F18
 ```
 cd ~/f18/build
-cmake -DLLVM_DIR=$LLVM ~/f18/src
+cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ~/f18/src
 make
 ```
 
@@ -198,7 +206,7 @@ make
 To run all tests:
 ```
 cd ~/f18/build
-cmake -DLLVM_DIR=$LLVM ~/f18/src
+cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ~/f18/src
 make test check-all
 ```
 
diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
index 4818a7100b9c..7a8fc18937fc 100644
--- a/include/flang/Optimizer/Dialect/FIRDialect.h
+++ b/include/flang/Optimizer/Dialect/FIRDialect.h
@@ -50,11 +50,11 @@ class FIROpsDialect final : public mlir::Dialect {
 inline void registerFIR() {
   // we want to register exactly once
   [[maybe_unused]] static bool init_once = [] {
-    mlir::registerDialect<mlir::AffineOpsDialect>();
+    mlir::registerDialect<mlir::AffineDialect>();
     mlir::registerDialect<mlir::LLVM::LLVMDialect>();
     mlir::registerDialect<mlir::loop::LoopOpsDialect>();
     mlir::registerDialect<mlir::StandardOpsDialect>();
-    mlir::registerDialect<mlir::vector::VectorOpsDialect>();
+    mlir::registerDialect<mlir::vector::VectorDialect>();
     mlir::registerDialect<FIROpsDialect>();
     return true;
   }();
@@ -65,7 +65,7 @@ inline void registerFIR() {
 inline void registerGeneralPasses() {
   mlir::createCanonicalizerPass();
   mlir::createCSEPass();
-  mlir::createVectorizePass({});
+  mlir::createSuperVectorizePass({});
   mlir::createLoopUnrollPass();
   mlir::createLoopUnrollAndJamPass();
   mlir::createSimplifyAffineStructuresPass();

From 12f6f30600db4cb3902677cd42764450ddeda5e0 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Thu, 26 Mar 2020 12:25:29 -0700
Subject: [PATCH 104/345] Semantics for SELECT CASE

Prep for review

Respond to review comments

Fix first line in new test
---
 include/flang/Evaluate/integer.h |  42 +++--
 include/flang/Evaluate/logical.h |  38 ++++-
 lib/Semantics/CMakeLists.txt     |   1 +
 lib/Semantics/check-case.cpp     | 253 +++++++++++++++++++++++++++++++
 lib/Semantics/check-case.h       |  30 ++++
 lib/Semantics/semantics.cpp      |  41 ++---
 test/Semantics/case01.f90        | 165 ++++++++++++++++++++
 7 files changed, 528 insertions(+), 42 deletions(-)
 create mode 100644 lib/Semantics/check-case.cpp
 create mode 100644 lib/Semantics/check-case.h
 create mode 100644 test/Semantics/case01.f90

diff --git a/include/flang/Evaluate/integer.h b/include/flang/Evaluate/integer.h
index 6f997c967e69..f519c2e64148 100644
--- a/include/flang/Evaluate/integer.h
+++ b/include/flang/Evaluate/integer.h
@@ -49,7 +49,7 @@ namespace Fortran::evaluate::value {
 // Member functions that correspond to Fortran intrinsic functions are
 // named accordingly in ALL CAPS so that they can be referenced easily in
 // the language standard.
-template<int BITS, bool IS_LITTLE_ENDIAN = isHostLittleEndian,
+template <int BITS, bool IS_LITTLE_ENDIAN = isHostLittleEndian,
     int PARTBITS = BITS <= 32 ? BITS : 32,
     typename PART = HostUnsignedInt<PARTBITS>,
     typename BIGPART = HostUnsignedInt<PARTBITS * 2>>
@@ -110,13 +110,13 @@ class Integer {
   };
 
   // Constructors and value-generating static functions
-  constexpr Integer() { Clear(); }  // default constructor: zero
+  constexpr Integer() { Clear(); } // default constructor: zero
   constexpr Integer(const Integer &) = default;
   constexpr Integer(Integer &&) = default;
 
   // C++'s integral types can all be converted to Integer
   // with silent truncation.
-  template<typename INT, typename = std::enable_if_t<std::is_integral_v<INT>>>
+  template <typename INT, typename = std::enable_if_t<std::is_integral_v<INT>>>
   constexpr Integer(INT n) {
     constexpr int nBits = CHAR_BIT * sizeof n;
     if constexpr (nBits < partBits) {
@@ -175,12 +175,24 @@ class Integer {
 
   constexpr Integer &operator=(const Integer &) = default;
 
+  constexpr bool operator<(const Integer &that) const {
+    return CompareUnsigned(that) == Ordering::Less;
+  }
+  constexpr bool operator<=(const Integer &that) const {
+    return CompareUnsigned(that) != Ordering::Greater;
+  }
   constexpr bool operator==(const Integer &that) const {
     return CompareUnsigned(that) == Ordering::Equal;
   }
   constexpr bool operator!=(const Integer &that) const {
     return !(*this == that);
   }
+  constexpr bool operator>=(const Integer &that) const {
+    return CompareUnsigned(that) != Ordering::Less;
+  }
+  constexpr bool operator>(const Integer &that) const {
+    return CompareUnsigned(that) == Ordering::Greater;
+  }
 
   // Left-justified mask (e.g., MASKL(1) has only its sign bit set)
   static constexpr Integer MASKL(int places) {
@@ -265,7 +277,7 @@ class Integer {
     return {result, overflow};
   }
 
-  template<typename FROM>
+  template <typename FROM>
   static constexpr ValueWithOverflow ConvertUnsigned(const FROM &that) {
     std::uint64_t field{that.ToUInt64()};
     ValueWithOverflow result{field, false};
@@ -286,7 +298,7 @@ class Integer {
     return result;
   }
 
-  template<typename FROM>
+  template <typename FROM>
   static constexpr ValueWithOverflow ConvertSigned(const FROM &that) {
     ValueWithOverflow result{ConvertUnsigned(that)};
     if constexpr (bits > FROM::bits) {
@@ -344,7 +356,7 @@ class Integer {
     return result;
   }
 
-  static constexpr int DIGITS{bits - 1};  // don't count the sign bit
+  static constexpr int DIGITS{bits - 1}; // don't count the sign bit
   static constexpr Integer HUGE() { return MASKR(bits - 1); }
   static constexpr int RANGE{// in the sense of SELECTED_INT_KIND
       // This magic value is LOG10(2.)*1E12.
@@ -404,9 +416,9 @@ class Integer {
   constexpr bool POPPAR() const { return POPCNT() & 1; }
 
   constexpr int TRAILZ() const {
-    auto minus1{AddUnsigned(MASKR(bits))};  // { x-1, carry = x > 0 }
+    auto minus1{AddUnsigned(MASKR(bits))}; // { x-1, carry = x > 0 }
     if (!minus1.carry) {
-      return bits;  // was zero
+      return bits; // was zero
     } else {
       // x ^ (x-1) has all bits set at and below original least-order set bit.
       return IEOR(minus1.value).POPCNT() - 1;
@@ -786,7 +798,7 @@ class Integer {
   }
 
   constexpr Product MultiplyUnsigned(const Integer &y) const {
-    Part product[2 * parts]{};  // little-endian full product
+    Part product[2 * parts]{}; // little-endian full product
     for (int j{0}; j < parts; ++j) {
       if (Part xpart{LEPart(j)}) {
         for (int k{0}; k < parts; ++k) {
@@ -842,7 +854,7 @@ class Integer {
 
   constexpr QuotientWithRemainder DivideUnsigned(const Integer &divisor) const {
     if (divisor.IsZero()) {
-      return {MASKR(bits), Integer{}, true, false};  // overflow to max value
+      return {MASKR(bits), Integer{}, true, false}; // overflow to max value
     }
     int bitsDone{LEADZ()};
     Integer top{SHIFTL(bitsDone)};
@@ -942,13 +954,13 @@ class Integer {
         result.divisionByZero = true;
         result.power = MASKR(bits - 1);
       } else if (CompareSigned(Integer{1}) == Ordering::Equal) {
-        result.power = *this;  // 1**x -> 1
+        result.power = *this; // 1**x -> 1
       } else if (CompareSigned(Integer{-1}) == Ordering::Equal) {
         if (exponent.BTEST(0)) {
-          result.power = *this;  // (-1)**x -> -1 if x is odd
+          result.power = *this; // (-1)**x -> -1 if x is odd
         }
       } else {
-        result.power.Clear();  // j**k -> 0 if |j| > 1 and k < 0
+        result.power.Clear(); // j**k -> 0 if |j| > 1 and k < 0
       }
     } else {
       Integer shifted{*this};
@@ -1016,5 +1028,5 @@ extern template class Integer<32>;
 extern template class Integer<64>;
 extern template class Integer<80>;
 extern template class Integer<128>;
-}
-#endif  // FORTRAN_EVALUATE_INTEGER_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_INTEGER_H_
diff --git a/include/flang/Evaluate/logical.h b/include/flang/Evaluate/logical.h
index a7813ecfdd70..44ba30ae6e17 100644
--- a/include/flang/Evaluate/logical.h
+++ b/include/flang/Evaluate/logical.h
@@ -14,7 +14,7 @@
 
 namespace Fortran::evaluate::value {
 
-template<int BITS, bool IS_LIKE_C = true> class Logical {
+template <int BITS, bool IS_LIKE_C = true> class Logical {
 public:
   static constexpr int bits{BITS};
 
@@ -22,19 +22,43 @@ template<int BITS, bool IS_LIKE_C = true> class Logical {
   // C's bit representation (.TRUE. -> 1, .FALSE. -> 0).
   static constexpr bool IsLikeC{BITS <= 8 || IS_LIKE_C};
 
-  constexpr Logical() {}  // .FALSE.
-  template<int B, bool C>
+  constexpr Logical() {} // .FALSE.
+  template <int B, bool C>
   constexpr Logical(Logical<B, C> x) : word_{Represent(x.IsTrue())} {}
   constexpr Logical(bool truth) : word_{Represent(truth)} {}
 
-  template<int B, bool C> constexpr Logical &operator=(Logical<B, C> x) {
+  template <int B, bool C> constexpr Logical &operator=(Logical<B, C> x) {
     word_ = Represent(x.IsTrue());
   }
 
-  template<int B, bool C>
+  // Fortran actually has only .EQV. & .NEQV. relational operations
+  // for LOGICAL, but this template class supports more so that
+  // it can be used with the STL for sorting and as a key type for
+  // std::set<> & std::map<>.
+  template <int B, bool C>
+  constexpr bool operator<(const Logical<B, C> &that) const {
+    return !IsTrue() && that.IsTrue();
+  }
+  template <int B, bool C>
+  constexpr bool operator<=(const Logical<B, C> &) const {
+    return !IsTrue();
+  }
+  template <int B, bool C>
   constexpr bool operator==(const Logical<B, C> &that) const {
     return IsTrue() == that.IsTrue();
   }
+  template <int B, bool C>
+  constexpr bool operator!=(const Logical<B, C> &that) const {
+    return IsTrue() != that.IsTrue();
+  }
+  template <int B, bool C>
+  constexpr bool operator>=(const Logical<B, C> &) const {
+    return IsTrue();
+  }
+  template <int B, bool C>
+  constexpr bool operator>(const Logical<B, C> &that) const {
+    return IsTrue() && !that.IsTrue();
+  }
 
   constexpr bool IsTrue() const {
     if constexpr (IsLikeC) {
@@ -75,5 +99,5 @@ extern template class Logical<8>;
 extern template class Logical<16>;
 extern template class Logical<32>;
 extern template class Logical<64>;
-}
-#endif  // FORTRAN_EVALUATE_LOGICAL_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_LOGICAL_H_
diff --git a/lib/Semantics/CMakeLists.txt b/lib/Semantics/CMakeLists.txt
index 1ca03d05341f..feedbab17860 100644
--- a/lib/Semantics/CMakeLists.txt
+++ b/lib/Semantics/CMakeLists.txt
@@ -7,6 +7,7 @@ add_library(FortranSemantics
   check-allocate.cpp
   check-arithmeticif.cpp
   check-call.cpp
+  check-case.cpp
   check-coarray.cpp
   check-data.cpp
   check-deallocate.cpp
diff --git a/lib/Semantics/check-case.cpp b/lib/Semantics/check-case.cpp
new file mode 100644
index 000000000000..c0f957a83728
--- /dev/null
+++ b/lib/Semantics/check-case.cpp
@@ -0,0 +1,253 @@
+//===-- lib/Semantics/check-case.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 "check-case.h"
+#include "flang/Common/idioms.h"
+#include "flang/Common/reference.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/tools.h"
+#include <tuple>
+
+namespace Fortran::semantics {
+
+template <typename T> class CaseValues {
+public:
+  CaseValues(SemanticsContext &c, const evaluate::DynamicType &t)
+      : context_{c}, caseExprType_{t} {}
+
+  void Check(const std::list<parser::CaseConstruct::Case> &cases) {
+    for (const parser::CaseConstruct::Case &c : cases) {
+      AddCase(c);
+    }
+    if (!hasErrors_) {
+      cases_.sort(Comparator{});
+      if (!AreCasesDisjoint()) { // C1149
+        ReportConflictingCases();
+      }
+    }
+  }
+
+private:
+  using Value = evaluate::Scalar<T>;
+
+  void AddCase(const parser::CaseConstruct::Case &c) {
+    const auto &stmt{std::get<parser::Statement<parser::CaseStmt>>(c.t)};
+    const parser::CaseStmt &caseStmt{stmt.statement};
+    const auto &selector{std::get<parser::CaseSelector>(caseStmt.t)};
+    std::visit(
+        common::visitors{
+            [&](const std::list<parser::CaseValueRange> &ranges) {
+              for (const auto &range : ranges) {
+                auto pair{ComputeBounds(range)};
+                if (pair.first && pair.second && *pair.first > *pair.second) {
+                  context_.Say(stmt.source,
+                      "CASE has lower bound greater than upper bound"_en_US);
+                } else {
+                  if constexpr (T::category == TypeCategory::Logical) { // C1148
+                    if ((pair.first || pair.second) &&
+                        (!pair.first || !pair.second ||
+                            *pair.first != *pair.second)) {
+                      context_.Say(stmt.source,
+                          "CASE range is not allowed for LOGICAL"_err_en_US);
+                    }
+                  }
+                  cases_.emplace_back(stmt);
+                  cases_.back().lower = std::move(pair.first);
+                  cases_.back().upper = std::move(pair.second);
+                }
+              }
+            },
+            [&](const parser::Default &) { cases_.emplace_front(stmt); },
+        },
+        selector.u);
+  }
+
+  std::optional<Value> GetValue(const parser::CaseValue &caseValue) {
+    const parser::Expr &expr{caseValue.thing.thing.value()};
+    auto *x{expr.typedExpr.get()};
+    if (x && x->v) { // C1147
+      auto type{x->v->GetType()};
+      if (type && type->category() == caseExprType_.category() &&
+          (type->category() != TypeCategory::Character ||
+              type->kind() == caseExprType_.kind())) {
+        x->v = evaluate::Fold(context_.foldingContext(),
+            evaluate::ConvertToType(T::GetType(), std::move(*x->v)));
+        if (x->v) {
+          if (auto value{evaluate::GetScalarConstantValue<T>(*x->v)}) {
+            return *value;
+          }
+        }
+        context_.Say(
+            expr.source, "CASE value must be a constant scalar"_err_en_US);
+      } else {
+        std::string typeStr{type ? type->AsFortran() : "typeless"s};
+        context_.Say(expr.source,
+            "CASE value has type '%s' which is not compatible with the SELECT CASE expression's type '%s'"_err_en_US,
+            typeStr, caseExprType_.AsFortran());
+      }
+      hasErrors_ = true;
+    }
+    return std::nullopt;
+  }
+
+  using PairOfValues = std::pair<std::optional<Value>, std::optional<Value>>;
+  PairOfValues ComputeBounds(const parser::CaseValueRange &range) {
+    return std::visit(
+        common::visitors{
+            [&](const parser::CaseValue &x) {
+              auto value{GetValue(x)};
+              return PairOfValues{value, value};
+            },
+            [&](const parser::CaseValueRange::Range &x) {
+              std::optional<Value> lo, hi;
+              if (x.lower) {
+                lo = GetValue(*x.lower);
+              }
+              if (x.upper) {
+                hi = GetValue(*x.upper);
+              }
+              if ((x.lower && !lo) || (x.upper && !hi)) {
+                return PairOfValues{}; // error case
+              }
+              return PairOfValues{std::move(lo), std::move(hi)};
+            },
+        },
+        range.u);
+  }
+
+  struct Case {
+    explicit Case(const parser::Statement<parser::CaseStmt> &s) : stmt{s} {}
+    bool IsDefault() const { return !lower && !upper; }
+    std::string AsFortran() const {
+      std::string result;
+      {
+        llvm::raw_string_ostream bs{result};
+        if (lower) {
+          evaluate::Constant<T>{*lower}.AsFortran(bs << '(');
+          if (!upper) {
+            bs << ':';
+          } else if (*lower != *upper) {
+            evaluate::Constant<T>{*upper}.AsFortran(bs << ':');
+          }
+          bs << ')';
+        } else if (upper) {
+          evaluate::Constant<T>{*upper}.AsFortran(bs << "(:") << ')';
+        } else {
+          bs << "DEFAULT";
+        }
+      }
+      return result;
+    }
+
+    const parser::Statement<parser::CaseStmt> &stmt;
+    std::optional<Value> lower, upper;
+  };
+
+  // Defines a comparator for use with std::list<>::sort().
+  // Returns true if and only if the highest value in range x is less
+  // than the least value in range y.  The DEFAULT case is arbitrarily
+  // defined to be less than all others.  When two ranges overlap,
+  // neither is less than the other.
+  struct Comparator {
+    bool operator()(const Case &x, const Case &y) const {
+      if (x.IsDefault()) {
+        return !y.IsDefault();
+      } else {
+        return x.upper && y.lower && *x.upper < *y.lower;
+      }
+    }
+  };
+
+  bool AreCasesDisjoint() const {
+    auto endIter{cases_.end()};
+    for (auto iter{cases_.begin()}; iter != endIter; ++iter) {
+      auto next{iter};
+      if (++next != endIter && !Comparator{}(*iter, *next)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // This has quadratic time, but only runs in error cases
+  void ReportConflictingCases() {
+    for (auto iter{cases_.begin()}; iter != cases_.end(); ++iter) {
+      parser::Message *msg{nullptr};
+      for (auto p{cases_.begin()}; p != cases_.end(); ++p) {
+        if (p->stmt.source.begin() < iter->stmt.source.begin() &&
+            !Comparator{}(*p, *iter) && !Comparator{}(*iter, *p)) {
+          if (!msg) {
+            msg = &context_.Say(iter->stmt.source,
+                "CASE %s conflicts with previous cases"_err_en_US,
+                iter->AsFortran());
+          }
+          msg->Attach(
+              p->stmt.source, "Conflicting CASE %s"_en_US, p->AsFortran());
+        }
+      }
+    }
+  }
+
+  SemanticsContext &context_;
+  const evaluate::DynamicType &caseExprType_;
+  std::list<Case> cases_;
+  bool hasErrors_{false};
+};
+
+void CaseChecker::Enter(const parser::CaseConstruct &construct) {
+  const auto &selectCaseStmt{
+      std::get<parser::Statement<parser::SelectCaseStmt>>(construct.t)};
+  const auto &selectCase{selectCaseStmt.statement};
+  const auto &selectExpr{
+      std::get<parser::Scalar<parser::Expr>>(selectCase.t).thing};
+  const auto *x{GetExpr(selectExpr)};
+  if (!x) {
+    return; // expression semantics failed
+  }
+  if (auto exprType{x->GetType()}) {
+    const auto &caseList{
+        std::get<std::list<parser::CaseConstruct::Case>>(construct.t)};
+    switch (exprType->category()) {
+    case TypeCategory::Integer:
+      CaseValues<evaluate::Type<TypeCategory::Integer, 16>>{context_, *exprType}
+          .Check(caseList);
+      return;
+    case TypeCategory::Logical:
+      CaseValues<evaluate::Type<TypeCategory::Logical, 1>>{context_, *exprType}
+          .Check(caseList);
+      return;
+    case TypeCategory::Character:
+      switch (exprType->kind()) {
+        SWITCH_COVERS_ALL_CASES
+      case 1:
+        CaseValues<evaluate::Type<TypeCategory::Character, 1>>{
+            context_, *exprType}
+            .Check(caseList);
+        return;
+      case 2:
+        CaseValues<evaluate::Type<TypeCategory::Character, 2>>{
+            context_, *exprType}
+            .Check(caseList);
+        return;
+      case 4:
+        CaseValues<evaluate::Type<TypeCategory::Character, 4>>{
+            context_, *exprType}
+            .Check(caseList);
+        return;
+      }
+    default:
+      break;
+    }
+  }
+  context_.Say(selectExpr.source,
+      "SELECT CASE expression must be integer, logical, or character"_err_en_US);
+}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-case.h b/lib/Semantics/check-case.h
new file mode 100644
index 000000000000..6abd6c69e2b9
--- /dev/null
+++ b/lib/Semantics/check-case.h
@@ -0,0 +1,30 @@
+//===-- lib/Semantics/check-case.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_SEMANTICS_CHECK_CASE_H_
+#define FORTRAN_SEMANTICS_CHECK_CASE_H_
+
+#include "flang/Semantics/semantics.h"
+
+namespace Fortran::parser {
+struct CaseConstruct;
+}
+
+namespace Fortran::semantics {
+
+class CaseChecker : public virtual BaseChecker {
+public:
+  explicit CaseChecker(SemanticsContext &context) : context_{context} {};
+
+  void Enter(const parser::CaseConstruct &);
+
+private:
+  SemanticsContext &context_;
+};
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_CASE_H_
diff --git a/lib/Semantics/semantics.cpp b/lib/Semantics/semantics.cpp
index 340c0a98f7cc..406396b2f776 100644
--- a/lib/Semantics/semantics.cpp
+++ b/lib/Semantics/semantics.cpp
@@ -12,6 +12,7 @@
 #include "canonicalize-omp.h"
 #include "check-allocate.h"
 #include "check-arithmeticif.h"
+#include "check-case.h"
 #include "check-coarray.h"
 #include "check-data.h"
 #include "check-deallocate.h"
@@ -61,44 +62,44 @@ static void GetSymbolNames(const Scope &scope, NameToSymbolMap &symbols) {
 // children are visited, Leave is called after. No two checkers may have the
 // same Enter or Leave function. Each checker must be constructible from
 // SemanticsContext and have BaseChecker as a virtual base class.
-template<typename... C> class SemanticsVisitor : public virtual C... {
+template <typename... C> class SemanticsVisitor : public virtual C... {
 public:
   using C::Enter...;
   using C::Leave...;
   using BaseChecker::Enter;
   using BaseChecker::Leave;
   SemanticsVisitor(SemanticsContext &context)
-    : C{context}..., context_{context} {}
+      : C{context}..., context_{context} {}
 
-  template<typename N> bool Pre(const N &node) {
+  template <typename N> bool Pre(const N &node) {
     if constexpr (common::HasMember<const N *, ConstructNode>) {
       context_.PushConstruct(node);
     }
     Enter(node);
     return true;
   }
-  template<typename N> void Post(const N &node) {
+  template <typename N> void Post(const N &node) {
     Leave(node);
     if constexpr (common::HasMember<const N *, ConstructNode>) {
       context_.PopConstruct();
     }
   }
 
-  template<typename T> bool Pre(const parser::Statement<T> &node) {
+  template <typename T> bool Pre(const parser::Statement<T> &node) {
     context_.set_location(node.source);
     Enter(node);
     return true;
   }
-  template<typename T> bool Pre(const parser::UnlabeledStatement<T> &node) {
+  template <typename T> bool Pre(const parser::UnlabeledStatement<T> &node) {
     context_.set_location(node.source);
     Enter(node);
     return true;
   }
-  template<typename T> void Post(const parser::Statement<T> &node) {
+  template <typename T> void Post(const parser::Statement<T> &node) {
     Leave(node);
     context_.set_location(std::nullopt);
   }
-  template<typename T> void Post(const parser::UnlabeledStatement<T> &node) {
+  template <typename T> void Post(const parser::UnlabeledStatement<T> &node) {
     Leave(node);
     context_.set_location(std::nullopt);
   }
@@ -116,7 +117,7 @@ class EntryChecker : public virtual BaseChecker {
 public:
   explicit EntryChecker(SemanticsContext &context) : context_{context} {}
   void Leave(const parser::EntryStmt &) {
-    if (!context_.constructStack().empty()) {  // C1571
+    if (!context_.constructStack().empty()) { // C1571
       context_.Say("ENTRY may not appear in an executable construct"_err_en_US);
     }
   }
@@ -127,10 +128,10 @@ class EntryChecker : public virtual BaseChecker {
 
 using StatementSemanticsPass1 = ExprChecker;
 using StatementSemanticsPass2 = SemanticsVisitor<AllocateChecker,
-    ArithmeticIfStmtChecker, AssignmentChecker, CoarrayChecker, DataChecker,
-    DeallocateChecker, DoForallChecker, EntryChecker, IfStmtChecker, IoChecker,
-    NamelistChecker, NullifyChecker, OmpStructureChecker, PurityChecker,
-    ReturnStmtChecker, StopChecker>;
+    ArithmeticIfStmtChecker, AssignmentChecker, CaseChecker, CoarrayChecker,
+    DataChecker, DeallocateChecker, DoForallChecker, EntryChecker,
+    IfStmtChecker, IoChecker, NamelistChecker, NullifyChecker,
+    OmpStructureChecker, PurityChecker, ReturnStmtChecker, StopChecker>;
 
 static bool PerformStatementSemantics(
     SemanticsContext &context, parser::Program &program) {
@@ -146,11 +147,11 @@ SemanticsContext::SemanticsContext(
     const common::IntrinsicTypeDefaultKinds &defaultKinds,
     const common::LanguageFeatureControl &languageFeatures,
     parser::AllSources &allSources)
-  : defaultKinds_{defaultKinds}, languageFeatures_{languageFeatures},
-    allSources_{allSources},
-    intrinsics_{evaluate::IntrinsicProcTable::Configure(defaultKinds_)},
-    foldingContext_{
-        parser::ContextualMessages{&messages_}, defaultKinds_, intrinsics_} {}
+    : defaultKinds_{defaultKinds}, languageFeatures_{languageFeatures},
+      allSources_{allSources},
+      intrinsics_{evaluate::IntrinsicProcTable::Configure(defaultKinds_)},
+      foldingContext_{
+          parser::ContextualMessages{&messages_}, defaultKinds_, intrinsics_} {}
 
 SemanticsContext::~SemanticsContext() {}
 
@@ -290,7 +291,7 @@ SymbolVector SemanticsContext::GetIndexVars(IndexVarKind kind) {
 
 bool Semantics::Perform() {
   return ValidateLabels(context_, program_) &&
-      parser::CanonicalizeDo(program_) &&  // force line break
+      parser::CanonicalizeDo(program_) && // force line break
       CanonicalizeOmp(context_.messages(), program_) &&
       PerformStatementSemantics(context_, program_) &&
       ModFileWriter{context_}.WriteAll();
@@ -376,4 +377,4 @@ static void PutIndent(llvm::raw_ostream &os, int indent) {
     os << "  ";
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/test/Semantics/case01.f90 b/test/Semantics/case01.f90
new file mode 100644
index 000000000000..7e5efc6a45a8
--- /dev/null
+++ b/test/Semantics/case01.f90
@@ -0,0 +1,165 @@
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! Test SELECT CASE Constraints: C1145, C1146, C1147, C1148, C1149
+program selectCaseProg
+   implicit none
+   ! local variable declaration
+   character :: grade1 = 'B'
+   integer :: grade2 = 3
+   logical :: grade3 = .false.
+   real :: grade4 = 2.0
+   character (len = 10) :: name = 'test'
+   logical, parameter :: grade5 = .false.
+   CHARACTER(KIND=1), parameter :: ASCII_parm1 = 'a', ASCII_parm2='b'
+   CHARACTER(KIND=2), parameter :: UCS16_parm = 'c'
+   CHARACTER(KIND=4), parameter :: UCS32_parm ='d'
+   type scores
+     integer :: val
+   end type
+   type (scores) :: score = scores(25)
+   type (scores), parameter :: score_val = scores(50)
+
+  ! Valid Cases
+   select case (grade1)
+      case ('A')
+      case ('B')
+      case ('C')
+      case default
+   end select
+
+   select case (grade2)
+      case (1)
+      case (2)
+      case (3)
+      case default
+   end select
+
+   select case (grade3)
+      case (.true.)
+      case (.false.)
+   end select
+
+   select case (name)
+      case default
+      case ('now')
+      case ('test')
+   end select
+
+  ! C1145
+  !ERROR: SELECT CASE expression must be integer, logical, or character
+  select case (grade4)
+     case (1.0)
+     case (2.0)
+     case (3.0)
+     case default
+  end select
+
+  !ERROR: SELECT CASE expression must be integer, logical, or character
+  select case (score)
+     case (score_val)
+     case (scores(100))
+  end select
+
+  ! C1146
+  select case (grade3)
+     case default
+     case (.true.)
+     !ERROR: CASE DEFAULT conflicts with previous cases
+     case default
+  end select
+
+  ! C1147
+  select case (grade2)
+     !ERROR: CASE value has type 'CHARACTER(1)' which is not compatible with the SELECT CASE expression's type 'INTEGER(4)'
+     case (:'Z')
+     case default
+   end select
+
+  select case (grade1)
+     !ERROR: CASE value has type 'INTEGER(4)' which is not compatible with the SELECT CASE expression's type 'CHARACTER(KIND=1,LEN=1_8)'
+     case (:1)
+     case default
+   end select
+
+  select case (grade3)
+     case default
+     case (.true.)
+     !ERROR: CASE value has type 'INTEGER(4)' which is not compatible with the SELECT CASE expression's type 'LOGICAL(4)'
+     case (3)
+  end select
+
+  select case (grade2)
+     case default
+     case (2 :)
+     !ERROR: CASE value has type 'LOGICAL(4)' which is not compatible with the SELECT CASE expression's type 'INTEGER(4)'
+     case (.true. :)
+     !ERROR: CASE value has type 'REAL(4)' which is not compatible with the SELECT CASE expression's type 'INTEGER(4)'
+     case (1.0)
+     !ERROR: CASE value has type 'CHARACTER(1)' which is not compatible with the SELECT CASE expression's type 'INTEGER(4)'
+     case ('wow')
+  end select
+
+  select case (ASCII_parm1)
+     case (ASCII_parm2)
+     !ERROR: CASE value has type 'CHARACTER(4)' which is not compatible with the SELECT CASE expression's type 'CHARACTER(1)'
+     case (UCS32_parm)
+     !ERROR: CASE value has type 'CHARACTER(2)' which is not compatible with the SELECT CASE expression's type 'CHARACTER(1)'
+     case (UCS16_parm)
+     !ERROR: CASE value has type 'CHARACTER(4)' which is not compatible with the SELECT CASE expression's type 'CHARACTER(1)'
+     case (4_"ucs-32")
+     !ERROR: CASE value has type 'CHARACTER(2)' which is not compatible with the SELECT CASE expression's type 'CHARACTER(1)'
+     case (2_"ucs-16")
+     case default
+   end select
+
+  ! C1148
+  select case (grade3)
+     case default
+     !ERROR: CASE range is not allowed for LOGICAL
+     case (.true. :)
+  end select
+
+  ! C1149
+  select case (grade3)
+    case (.true.)
+    case (.false.)
+     !ERROR: CASE (.true._1) conflicts with previous cases
+     case (.true.)
+    !ERROR: CASE (.false._1) conflicts with previous cases
+     case (grade5)
+  end select
+
+  select case (grade2)
+     case (51:50) ! warning
+     case (100:)
+     case (:30)
+     case (40)
+     case (90)
+     case (91:99)
+     !ERROR: CASE (81_16:90_16) conflicts with previous cases
+     case (81:90)
+     !ERROR: CASE (:80_16) conflicts with previous cases
+     case (:80)
+     !ERROR: CASE (200_16) conflicts with previous cases
+     case (200)
+     case default
+  end select
+
+  select case (name)
+     case ('hello')
+     case ('hey')
+     !ERROR: CASE (:"hh") conflicts with previous cases
+     case (:'hh')
+     !ERROR: CASE (:"hd") conflicts with previous cases
+     case (:'hd')
+     case ( 'hu':)
+     case ('hi':'ho')
+     !ERROR: CASE ("hj") conflicts with previous cases
+     case ('hj')
+     !ERROR: CASE ("ha") conflicts with previous cases
+     case ('ha')
+     !ERROR: CASE ("hz") conflicts with previous cases
+     case ('hz')
+     case default
+   end select
+
+end program

From 3b0c150b2e4d194cb5a46b40f41b3be59ef5fa51 Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Fri, 27 Mar 2020 14:17:25 -0700
Subject: [PATCH 105/345] Fix missing substring bounds (bug #1091)

---
 include/flang/Evaluate/tools.h | 203 ++++++++++++++++++---------------
 lib/Evaluate/tools.cpp         |  40 +++----
 lib/Semantics/assignment.cpp   |  18 +--
 lib/Semantics/expression.cpp   | 138 ++++++++++++----------
 lib/Semantics/tools.cpp        |  49 ++++----
 5 files changed, 241 insertions(+), 207 deletions(-)

diff --git a/include/flang/Evaluate/tools.h b/include/flang/Evaluate/tools.h
index 2d2a46fc3eb1..d14827377b22 100644
--- a/include/flang/Evaluate/tools.h
+++ b/include/flang/Evaluate/tools.h
@@ -31,7 +31,7 @@ namespace Fortran::evaluate {
 // When an Expr holds something that is a Variable (i.e., a Designator
 // or pointer-valued FunctionRef), return a copy of its contents in
 // a Variable.
-template<typename A>
+template <typename A>
 std::optional<Variable<A>> AsVariable(const Expr<A> &expr) {
   using Variant = decltype(Variable<A>::u);
   return std::visit(
@@ -44,7 +44,7 @@ std::optional<Variable<A>> AsVariable(const Expr<A> &expr) {
       expr.u);
 }
 
-template<typename A>
+template <typename A>
 std::optional<Variable<A>> AsVariable(const std::optional<Expr<A>> &expr) {
   if (expr) {
     return AsVariable(*expr);
@@ -58,8 +58,8 @@ std::optional<Variable<A>> AsVariable(const std::optional<Expr<A>> &expr) {
 // pointer is a "variable" in Fortran (it can be the left-hand side of
 // an assignment).
 struct IsVariableHelper
-  : public AnyTraverse<IsVariableHelper, std::optional<bool>> {
-  using Result = std::optional<bool>;  // effectively tri-state
+    : public AnyTraverse<IsVariableHelper, std::optional<bool>> {
+  using Result = std::optional<bool>; // effectively tri-state
   using Base = AnyTraverse<IsVariableHelper, Result>;
   IsVariableHelper() : Base{*this} {}
   using Base::operator();
@@ -71,7 +71,7 @@ struct IsVariableHelper
   Result operator()(const CoarrayRef &) const { return true; }
   Result operator()(const ComplexPart &) const { return true; }
   Result operator()(const ProcedureDesignator &) const;
-  template<typename T> Result operator()(const Expr<T> &x) const {
+  template <typename T> Result operator()(const Expr<T> &x) const {
     if constexpr (common::HasMember<T, AllIntrinsicTypes> ||
         std::is_same_v<T, SomeDerived>) {
       // Expression with a specific type
@@ -88,7 +88,7 @@ struct IsVariableHelper
   }
 };
 
-template<typename A> bool IsVariable(const A &x) {
+template <typename A> bool IsVariable(const A &x) {
   if (auto known{IsVariableHelper{}(x)}) {
     return *known;
   } else {
@@ -99,39 +99,39 @@ template<typename A> bool IsVariable(const A &x) {
 // Predicate: true when an expression is assumed-rank
 bool IsAssumedRank(const Symbol &);
 bool IsAssumedRank(const ActualArgument &);
-template<typename A> bool IsAssumedRank(const A &) { return false; }
-template<typename A> bool IsAssumedRank(const Designator<A> &designator) {
+template <typename A> bool IsAssumedRank(const A &) { return false; }
+template <typename A> bool IsAssumedRank(const Designator<A> &designator) {
   if (const auto *symbol{std::get_if<SymbolRef>(&designator.u)}) {
     return IsAssumedRank(symbol->get());
   } else {
     return false;
   }
 }
-template<typename T> bool IsAssumedRank(const Expr<T> &expr) {
+template <typename T> bool IsAssumedRank(const Expr<T> &expr) {
   return std::visit([](const auto &x) { return IsAssumedRank(x); }, expr.u);
 }
-template<typename A> bool IsAssumedRank(const std::optional<A> &x) {
+template <typename A> bool IsAssumedRank(const std::optional<A> &x) {
   return x && IsAssumedRank(*x);
 }
 
 // Generalizing packagers: these take operations and expressions of more
 // specific types and wrap them in Expr<> containers of more abstract types.
 
-template<typename A> common::IfNoLvalue<Expr<ResultType<A>>, A> AsExpr(A &&x) {
+template <typename A> common::IfNoLvalue<Expr<ResultType<A>>, A> AsExpr(A &&x) {
   return Expr<ResultType<A>>{std::move(x)};
 }
 
-template<typename T> Expr<T> AsExpr(Expr<T> &&x) {
+template <typename T> Expr<T> AsExpr(Expr<T> &&x) {
   static_assert(IsSpecificIntrinsicType<T>);
   return std::move(x);
 }
 
-template<TypeCategory CATEGORY>
+template <TypeCategory CATEGORY>
 Expr<SomeKind<CATEGORY>> AsCategoryExpr(Expr<SomeKind<CATEGORY>> &&x) {
   return std::move(x);
 }
 
-template<typename A>
+template <typename A>
 common::IfNoLvalue<Expr<SomeType>, A> AsGenericExpr(A &&x) {
   if constexpr (common::HasMember<A, TypelessExpression>) {
     return Expr<SomeType>{std::move(x)};
@@ -140,7 +140,7 @@ common::IfNoLvalue<Expr<SomeType>, A> AsGenericExpr(A &&x) {
   }
 }
 
-template<typename A>
+template <typename A>
 common::IfNoLvalue<Expr<SomeKind<ResultType<A>::category>>, A> AsCategoryExpr(
     A &&x) {
   return Expr<SomeKind<ResultType<A>::category>>{AsExpr(std::move(x))};
@@ -153,13 +153,13 @@ Expr<SomeType> Parenthesize(Expr<SomeType> &&);
 Expr<SomeReal> GetComplexPart(
     const Expr<SomeComplex> &, bool isImaginary = false);
 
-template<int KIND>
+template <int KIND>
 Expr<SomeComplex> MakeComplex(Expr<Type<TypeCategory::Real, KIND>> &&re,
     Expr<Type<TypeCategory::Real, KIND>> &&im) {
   return AsCategoryExpr(ComplexConstructor<KIND>{std::move(re), std::move(im)});
 }
 
-template<typename A> constexpr bool IsNumericCategoryExpr() {
+template <typename A> constexpr bool IsNumericCategoryExpr() {
   if constexpr (common::HasMember<A, TypelessExpression>) {
     return false;
   } else {
@@ -170,7 +170,7 @@ template<typename A> constexpr bool IsNumericCategoryExpr() {
 // Specializing extractor.  If an Expr wraps some type of object, perhaps
 // in several layers, return a pointer to it; otherwise null.  Also works
 // with expressions contained in ActualArgument.
-template<typename A, typename B>
+template <typename A, typename B>
 auto UnwrapExpr(B &x) -> common::Constify<A, B> * {
   using Ty = std::decay_t<B>;
   if constexpr (std::is_same_v<A, Ty>) {
@@ -190,7 +190,7 @@ auto UnwrapExpr(B &x) -> common::Constify<A, B> * {
   return nullptr;
 }
 
-template<typename A, typename B>
+template <typename A, typename B>
 const A *UnwrapExpr(const std::optional<B> &x) {
   if (x) {
     return UnwrapExpr<A>(*x);
@@ -199,7 +199,7 @@ const A *UnwrapExpr(const std::optional<B> &x) {
   }
 }
 
-template<typename A, typename B> A *UnwrapExpr(std::optional<B> &x) {
+template <typename A, typename B> A *UnwrapExpr(std::optional<B> &x) {
   if (x) {
     return UnwrapExpr<A>(*x);
   } else {
@@ -208,41 +208,52 @@ template<typename A, typename B> A *UnwrapExpr(std::optional<B> &x) {
 }
 
 // If an expression simply wraps a DataRef, extract and return it.
-template<typename A>
-common::IfNoLvalue<std::optional<DataRef>, A> ExtractDataRef(const A &) {
-  return std::nullopt;  // default base case
-}
-template<typename T>
-std::optional<DataRef> ExtractDataRef(const Designator<T> &d) {
+// The Boolean argument controls the handling of Substring
+// references: when true (not default), it extracts the base DataRef
+// of a substring, if it has one.
+template <typename A>
+common::IfNoLvalue<std::optional<DataRef>, A> ExtractDataRef(
+    const A &, bool intoSubstring) {
+  return std::nullopt; // default base case
+}
+template <typename T>
+std::optional<DataRef> ExtractDataRef(
+    const Designator<T> &d, bool intoSubstring = false) {
   return std::visit(
-      [](const auto &x) -> std::optional<DataRef> {
+      [=](const auto &x) -> std::optional<DataRef> {
         if constexpr (common::HasMember<decltype(x), decltype(DataRef::u)>) {
           return DataRef{x};
         }
         if constexpr (std::is_same_v<std::decay_t<decltype(x)>, Substring>) {
-          return ExtractDataRef(x);
+          if (intoSubstring) {
+            return ExtractSubstringBase(x);
+          }
         }
-        return std::nullopt;  // w/o "else" to dodge bogus g++ 8.1 warning
+        return std::nullopt; // w/o "else" to dodge bogus g++ 8.1 warning
       },
       d.u);
 }
-template<typename T>
-std::optional<DataRef> ExtractDataRef(const Expr<T> &expr) {
-  return std::visit([](const auto &x) { return ExtractDataRef(x); }, expr.u);
+template <typename T>
+std::optional<DataRef> ExtractDataRef(
+    const Expr<T> &expr, bool intoSubstring = false) {
+  return std::visit(
+      [=](const auto &x) { return ExtractDataRef(x, intoSubstring); }, expr.u);
 }
-template<typename A>
-std::optional<DataRef> ExtractDataRef(const std::optional<A> &x) {
+template <typename A>
+std::optional<DataRef> ExtractDataRef(
+    const std::optional<A> &x, bool intoSubstring = false) {
   if (x) {
-    return ExtractDataRef(*x);
+    return ExtractDataRef(*x, intoSubstring);
   } else {
     return std::nullopt;
   }
 }
-std::optional<DataRef> ExtractDataRef(const Substring &);
+std::optional<DataRef> ExtractSubstringBase(const Substring &);
 
 // Predicate: is an expression is an array element reference?
-template<typename T> bool IsArrayElement(const Expr<T> &expr) {
-  if (auto dataRef{ExtractDataRef(expr)}) {
+template <typename T>
+bool IsArrayElement(const Expr<T> &expr, bool intoSubstring = false) {
+  if (auto dataRef{ExtractDataRef(expr, intoSubstring)}) {
     const DataRef *ref{&*dataRef};
     while (const Component * component{std::get_if<Component>(&ref->u)}) {
       ref = &component->base();
@@ -253,8 +264,9 @@ template<typename T> bool IsArrayElement(const Expr<T> &expr) {
   }
 }
 
-template<typename A> std::optional<NamedEntity> ExtractNamedEntity(const A &x) {
-  if (auto dataRef{ExtractDataRef(x)}) {
+template <typename A>
+std::optional<NamedEntity> ExtractNamedEntity(const A &x) {
+  if (auto dataRef{ExtractDataRef(x, true)}) {
     return std::visit(
         common::visitors{
             [](SymbolRef &&symbol) -> std::optional<NamedEntity> {
@@ -275,11 +287,11 @@ template<typename A> std::optional<NamedEntity> ExtractNamedEntity(const A &x) {
 }
 
 struct ExtractCoindexedObjectHelper {
-  template<typename A> std::optional<CoarrayRef> operator()(const A &) const {
+  template <typename A> std::optional<CoarrayRef> operator()(const A &) const {
     return std::nullopt;
   }
   std::optional<CoarrayRef> operator()(const CoarrayRef &x) const { return x; }
-  template<typename A>
+  template <typename A>
   std::optional<CoarrayRef> operator()(const Expr<A> &expr) const {
     return std::visit(*this, expr.u);
   }
@@ -309,8 +321,8 @@ struct ExtractCoindexedObjectHelper {
   }
 };
 
-template<typename A> std::optional<CoarrayRef> ExtractCoarrayRef(const A &x) {
-  if (auto dataRef{ExtractDataRef(x)}) {
+template <typename A> std::optional<CoarrayRef> ExtractCoarrayRef(const A &x) {
+  if (auto dataRef{ExtractDataRef(x, true)}) {
     return ExtractCoindexedObjectHelper{}(*dataRef);
   } else {
     return ExtractCoindexedObjectHelper{}(x);
@@ -319,7 +331,7 @@ template<typename A> std::optional<CoarrayRef> ExtractCoarrayRef(const A &x) {
 
 // If an expression is simply a whole symbol data designator,
 // extract and return that symbol, else null.
-template<typename A> const Symbol *UnwrapWholeSymbolDataRef(const A &x) {
+template <typename A> const Symbol *UnwrapWholeSymbolDataRef(const A &x) {
   if (auto dataRef{ExtractDataRef(x)}) {
     if (const SymbolRef * p{std::get_if<SymbolRef>(&dataRef->u)}) {
       return &p->get();
@@ -329,8 +341,8 @@ template<typename A> const Symbol *UnwrapWholeSymbolDataRef(const A &x) {
 }
 
 // GetFirstSymbol(A%B%C[I]%D) -> A
-template<typename A> const Symbol *GetFirstSymbol(const A &x) {
-  if (auto dataRef{ExtractDataRef(x)}) {
+template <typename A> const Symbol *GetFirstSymbol(const A &x) {
+  if (auto dataRef{ExtractDataRef(x, true)}) {
     return &dataRef->GetFirstSymbol();
   } else {
     return nullptr;
@@ -341,7 +353,7 @@ template<typename A> const Symbol *GetFirstSymbol(const A &x) {
 // specific intrinsic type with ConvertToType<T>(x) or by converting
 // one arbitrary expression to the type of another with ConvertTo(to, from).
 
-template<typename TO, TypeCategory FROMCAT>
+template <typename TO, TypeCategory FROMCAT>
 Expr<TO> ConvertToType(Expr<SomeKind<FROMCAT>> &&x) {
   static_assert(IsSpecificIntrinsicType<TO>);
   if constexpr (FROMCAT != TO::category) {
@@ -390,12 +402,12 @@ Expr<TO> ConvertToType(Expr<SomeKind<FROMCAT>> &&x) {
   }
 }
 
-template<typename TO, TypeCategory FROMCAT, int FROMKIND>
+template <typename TO, TypeCategory FROMCAT, int FROMKIND>
 Expr<TO> ConvertToType(Expr<Type<FROMCAT, FROMKIND>> &&x) {
   return ConvertToType<TO, FROMCAT>(Expr<SomeKind<FROMCAT>>{std::move(x)});
 }
 
-template<typename TO> Expr<TO> ConvertToType(BOZLiteralConstant &&x) {
+template <typename TO> Expr<TO> ConvertToType(BOZLiteralConstant &&x) {
   static_assert(IsSpecificIntrinsicType<TO>);
   if constexpr (TO::category == TypeCategory::Integer) {
     return Expr<TO>{
@@ -418,13 +430,13 @@ std::optional<Expr<SomeType>> ConvertToType(
     const Symbol &, std::optional<Expr<SomeType>> &&);
 
 // Conversions to the type of another expression
-template<TypeCategory TC, int TK, typename FROM>
+template <TypeCategory TC, int TK, typename FROM>
 common::IfNoLvalue<Expr<Type<TC, TK>>, FROM> ConvertTo(
     const Expr<Type<TC, TK>> &, FROM &&x) {
   return ConvertToType<Type<TC, TK>>(std::move(x));
 }
 
-template<TypeCategory TC, typename FROM>
+template <TypeCategory TC, typename FROM>
 common::IfNoLvalue<Expr<SomeKind<TC>>, FROM> ConvertTo(
     const Expr<SomeKind<TC>> &to, FROM &&from) {
   return std::visit(
@@ -436,7 +448,7 @@ common::IfNoLvalue<Expr<SomeKind<TC>>, FROM> ConvertTo(
       to.u);
 }
 
-template<typename FROM>
+template <typename FROM>
 common::IfNoLvalue<Expr<SomeType>, FROM> ConvertTo(
     const Expr<SomeType> &to, FROM &&from) {
   return std::visit(
@@ -448,11 +460,11 @@ common::IfNoLvalue<Expr<SomeType>, FROM> ConvertTo(
 
 // Convert an expression of some known category to a dynamically chosen
 // kind of some category (usually but not necessarily distinct).
-template<TypeCategory TOCAT, typename VALUE> struct ConvertToKindHelper {
+template <TypeCategory TOCAT, typename VALUE> struct ConvertToKindHelper {
   using Result = std::optional<Expr<SomeKind<TOCAT>>>;
   using Types = CategoryTypes<TOCAT>;
   ConvertToKindHelper(int k, VALUE &&x) : kind{k}, value{std::move(x)} {}
-  template<typename T> Result Test() {
+  template <typename T> Result Test() {
     if (kind == T::kind) {
       return std::make_optional(
           AsCategoryExpr(ConvertToType<T>(std::move(value))));
@@ -463,7 +475,7 @@ template<TypeCategory TOCAT, typename VALUE> struct ConvertToKindHelper {
   VALUE value;
 };
 
-template<TypeCategory TOCAT, typename VALUE>
+template <TypeCategory TOCAT, typename VALUE>
 common::IfNoLvalue<Expr<SomeKind<TOCAT>>, VALUE> ConvertToKind(
     int kind, VALUE &&x) {
   return common::SearchTypes(
@@ -474,11 +486,11 @@ common::IfNoLvalue<Expr<SomeKind<TOCAT>>, VALUE> ConvertToKind(
 // Given a type category CAT, SameKindExprs<CAT, N> is a variant that
 // holds an arrays of expressions of the same supported kind in that
 // category.
-template<typename A, int N = 2> using SameExprs = std::array<Expr<A>, N>;
-template<int N = 2> struct SameKindExprsHelper {
-  template<typename A> using SameExprs = std::array<Expr<A>, N>;
+template <typename A, int N = 2> using SameExprs = std::array<Expr<A>, N>;
+template <int N = 2> struct SameKindExprsHelper {
+  template <typename A> using SameExprs = std::array<Expr<A>, N>;
 };
-template<TypeCategory CAT, int N = 2>
+template <TypeCategory CAT, int N = 2>
 using SameKindExprs =
     common::MapTemplate<SameKindExprsHelper<N>::template SameExprs,
         CategoryTypes<CAT>>;
@@ -486,7 +498,7 @@ using SameKindExprs =
 // Given references to two expressions of arbitrary kind in the same type
 // category, convert one to the kind of the other when it has the smaller kind,
 // then return them in a type-safe package.
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 SameKindExprs<CAT, 2> AsSameKindExprs(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return std::visit(
@@ -528,7 +540,7 @@ std::optional<Expr<SomeComplex>> ConstructComplex(parser::ContextualMessages &,
     std::optional<Expr<SomeType>> &&, std::optional<Expr<SomeType>> &&,
     int defaultRealKind);
 
-template<typename A> Expr<TypeOf<A>> ScalarConstantToExpr(const A &x) {
+template <typename A> Expr<TypeOf<A>> ScalarConstantToExpr(const A &x) {
   using Ty = TypeOf<A>;
   static_assert(
       std::is_same_v<Scalar<Ty>, std::decay_t<A>>, "TypeOf<> is broken");
@@ -538,7 +550,7 @@ template<typename A> Expr<TypeOf<A>> ScalarConstantToExpr(const A &x) {
 // Combine two expressions of the same specific numeric type with an operation
 // to produce a new expression.  Implements piecewise addition and subtraction
 // for COMPLEX.
-template<template<typename> class OPR, typename SPECIFIC>
+template <template <typename> class OPR, typename SPECIFIC>
 Expr<SPECIFIC> Combine(Expr<SPECIFIC> &&x, Expr<SPECIFIC> &&y) {
   static_assert(IsSpecificIntrinsicType<SPECIFIC>);
   if constexpr (SPECIFIC::category == TypeCategory::Complex &&
@@ -560,7 +572,7 @@ Expr<SPECIFIC> Combine(Expr<SPECIFIC> &&x, Expr<SPECIFIC> &&y) {
 // category, convert one of them if necessary to the larger kind of the
 // other, then combine the resulting homogenized operands with a given
 // operation, returning a new expression in the same type category.
-template<template<typename> class OPR, TypeCategory CAT>
+template <template <typename> class OPR, TypeCategory CAT>
 Expr<SomeKind<CAT>> PromoteAndCombine(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return std::visit(
@@ -577,7 +589,7 @@ Expr<SomeKind<CAT>> PromoteAndCombine(
 // one of the operands to the type of the other.  Handles special cases with
 // typeless literal operands and with REAL/COMPLEX exponentiation to INTEGER
 // powers.
-template<template<typename> class OPR>
+template <template <typename> class OPR>
 std::optional<Expr<SomeType>> NumericOperation(parser::ContextualMessages &,
     Expr<SomeType> &&, Expr<SomeType> &&, int defaultRealKind);
 
@@ -605,7 +617,7 @@ std::optional<Expr<SomeType>> Negation(
 std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &,
     RelationalOperator, Expr<SomeType> &&, Expr<SomeType> &&);
 
-template<int K>
+template <int K>
 Expr<Type<TypeCategory::Logical, K>> LogicalNegation(
     Expr<Type<TypeCategory::Logical, K>> &&x) {
   return AsExpr(Not<K>{std::move(x)});
@@ -613,7 +625,7 @@ Expr<Type<TypeCategory::Logical, K>> LogicalNegation(
 
 Expr<SomeLogical> LogicalNegation(Expr<SomeLogical> &&);
 
-template<int K>
+template <int K>
 Expr<Type<TypeCategory::Logical, K>> BinaryLogicalOperation(LogicalOperator opr,
     Expr<Type<TypeCategory::Logical, K>> &&x,
     Expr<Type<TypeCategory::Logical, K>> &&y) {
@@ -628,12 +640,12 @@ Expr<SomeLogical> BinaryLogicalOperation(
 // emit any message.  Use the more general templates (above) in other
 // situations.
 
-template<TypeCategory C, int K>
+template <TypeCategory C, int K>
 Expr<Type<C, K>> operator-(Expr<Type<C, K>> &&x) {
   return AsExpr(Negate<Type<C, K>>{std::move(x)});
 }
 
-template<int K>
+template <int K>
 Expr<Type<TypeCategory::Complex, K>> operator-(
     Expr<Type<TypeCategory::Complex, K>> &&x) {
   using Part = Type<TypeCategory::Real, K>;
@@ -642,50 +654,50 @@ Expr<Type<TypeCategory::Complex, K>> operator-(
       AsExpr(Negate<Part>{AsExpr(ComplexComponent<K>{true, x})})});
 }
 
-template<TypeCategory C, int K>
+template <TypeCategory C, int K>
 Expr<Type<C, K>> operator+(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
   return AsExpr(Combine<Add, Type<C, K>>(std::move(x), std::move(y)));
 }
 
-template<TypeCategory C, int K>
+template <TypeCategory C, int K>
 Expr<Type<C, K>> operator-(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
   return AsExpr(Combine<Subtract, Type<C, K>>(std::move(x), std::move(y)));
 }
 
-template<TypeCategory C, int K>
+template <TypeCategory C, int K>
 Expr<Type<C, K>> operator*(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
   return AsExpr(Combine<Multiply, Type<C, K>>(std::move(x), std::move(y)));
 }
 
-template<TypeCategory C, int K>
+template <TypeCategory C, int K>
 Expr<Type<C, K>> operator/(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
   return AsExpr(Combine<Divide, Type<C, K>>(std::move(x), std::move(y)));
 }
 
-template<TypeCategory C> Expr<SomeKind<C>> operator-(Expr<SomeKind<C>> &&x) {
+template <TypeCategory C> Expr<SomeKind<C>> operator-(Expr<SomeKind<C>> &&x) {
   return std::visit(
       [](auto &xk) { return Expr<SomeKind<C>>{-std::move(xk)}; }, x.u);
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator+(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Add, CAT>(std::move(x), std::move(y));
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator-(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Subtract, CAT>(std::move(x), std::move(y));
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator*(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Multiply, CAT>(std::move(x), std::move(y));
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 Expr<SomeKind<CAT>> operator/(
     Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return PromoteAndCombine<Divide, CAT>(std::move(x), std::move(y));
@@ -694,7 +706,7 @@ Expr<SomeKind<CAT>> operator/(
 // A utility for use with common::SearchTypes to create generic expressions
 // when an intrinsic type category for (say) a variable is known
 // but the kind parameter value is not.
-template<TypeCategory CAT, template<typename> class TEMPLATE, typename VALUE>
+template <TypeCategory CAT, template <typename> class TEMPLATE, typename VALUE>
 struct TypeKindVisitor {
   using Result = std::optional<Expr<SomeType>>;
   using Types = CategoryTypes<CAT>;
@@ -702,7 +714,7 @@ struct TypeKindVisitor {
   TypeKindVisitor(int k, VALUE &&x) : kind{k}, value{std::move(x)} {}
   TypeKindVisitor(int k, const VALUE &x) : kind{k}, value{x} {}
 
-  template<typename T> Result Test() {
+  template <typename T> Result Test() {
     if (kind == T::kind) {
       return AsGenericExpr(TEMPLATE<T>{std::move(value)});
     }
@@ -717,7 +729,7 @@ struct TypeKindVisitor {
 // designator (which has perhaps been wrapped in an Expr<>), or a null pointer
 // when none is found.
 struct GetLastSymbolHelper
-  : public AnyTraverse<GetLastSymbolHelper, std::optional<const Symbol *>> {
+    : public AnyTraverse<GetLastSymbolHelper, std::optional<const Symbol *>> {
   using Result = std::optional<const Symbol *>;
   using Base = AnyTraverse<GetLastSymbolHelper, Result>;
   GetLastSymbolHelper() : Base{*this} {}
@@ -728,7 +740,7 @@ struct GetLastSymbolHelper
   Result operator()(const ProcedureDesignator &x) const {
     return x.GetSymbol();
   }
-  template<typename T> Result operator()(const Expr<T> &x) const {
+  template <typename T> Result operator()(const Expr<T> &x) const {
     if constexpr (common::HasMember<T, AllIntrinsicTypes> ||
         std::is_same_v<T, SomeDerived>) {
       if (const auto *designator{std::get_if<Designator<T>>(&x.u)}) {
@@ -743,7 +755,7 @@ struct GetLastSymbolHelper
   }
 };
 
-template<typename A> const Symbol *GetLastSymbol(const A &x) {
+template <typename A> const Symbol *GetLastSymbol(const A &x) {
   if (auto known{GetLastSymbolHelper{}(x)}) {
     return *known;
   } else {
@@ -753,7 +765,7 @@ template<typename A> const Symbol *GetLastSymbol(const A &x) {
 
 // Convenience: If GetLastSymbol() succeeds on the argument, return its
 // set of attributes, otherwise the empty set.
-template<typename A> semantics::Attrs GetAttrs(const A &x) {
+template <typename A> semantics::Attrs GetAttrs(const A &x) {
   if (const Symbol * symbol{GetLastSymbol(x)}) {
     return symbol->attrs();
   } else {
@@ -762,17 +774,18 @@ template<typename A> semantics::Attrs GetAttrs(const A &x) {
 }
 
 // GetBaseObject()
-template<typename A> std::optional<BaseObject> GetBaseObject(const A &) {
+template <typename A> std::optional<BaseObject> GetBaseObject(const A &) {
   return std::nullopt;
 }
-template<typename T>
+template <typename T>
 std::optional<BaseObject> GetBaseObject(const Designator<T> &x) {
   return x.GetBaseObject();
 }
-template<typename T> std::optional<BaseObject> GetBaseObject(const Expr<T> &x) {
+template <typename T>
+std::optional<BaseObject> GetBaseObject(const Expr<T> &x) {
   return std::visit([](const auto &y) { return GetBaseObject(y); }, x.u);
 }
-template<typename A>
+template <typename A>
 std::optional<BaseObject> GetBaseObject(const std::optional<A> &x) {
   if (x) {
     return GetBaseObject(*x);
@@ -782,7 +795,7 @@ std::optional<BaseObject> GetBaseObject(const std::optional<A> &x) {
 }
 
 // Predicate: IsAllocatableOrPointer()
-template<typename A> bool IsAllocatableOrPointer(const A &x) {
+template <typename A> bool IsAllocatableOrPointer(const A &x) {
   return GetAttrs(x).HasAny(
       semantics::Attrs{semantics::Attr::POINTER, semantics::Attr::ALLOCATABLE});
 }
@@ -796,7 +809,7 @@ bool IsNullPointer(const Expr<SomeType> &);
 // wrapped in an Expr<>, removing all of the (co)subscripts.  The
 // base object will be the first symbol in the result vector.
 struct GetSymbolVectorHelper
-  : public Traverse<GetSymbolVectorHelper, SymbolVector> {
+    : public Traverse<GetSymbolVectorHelper, SymbolVector> {
   using Result = SymbolVector;
   using Base = Traverse<GetSymbolVectorHelper, Result>;
   using Base::operator();
@@ -811,7 +824,7 @@ struct GetSymbolVectorHelper
   Result operator()(const ArrayRef &) const;
   Result operator()(const CoarrayRef &) const;
 };
-template<typename A> SymbolVector GetSymbolVector(const A &x) {
+template <typename A> SymbolVector GetSymbolVector(const A &x) {
   return GetSymbolVectorHelper{}(x);
 }
 
@@ -824,7 +837,7 @@ const Symbol *GetLastTarget(const SymbolVector &);
 const Symbol &ResolveAssociations(const Symbol &);
 
 // Collects all of the Symbols in an expression
-template<typename A> semantics::SymbolSet CollectSymbols(const A &);
+template <typename A> semantics::SymbolSet CollectSymbols(const A &);
 extern template semantics::SymbolSet CollectSymbols(const Expr<SomeType> &);
 extern template semantics::SymbolSet CollectSymbols(const Expr<SomeInteger> &);
 extern template semantics::SymbolSet CollectSymbols(
@@ -838,7 +851,7 @@ bool HasVectorSubscript(const Expr<SomeType> &);
 // the case of USE association gracefully.
 parser::Message *AttachDeclaration(parser::Message &, const Symbol &);
 parser::Message *AttachDeclaration(parser::Message *, const Symbol &);
-template<typename MESSAGES, typename... A>
+template <typename MESSAGES, typename... A>
 parser::Message *SayWithDeclaration(
     MESSAGES &messages, const Symbol &symbol, A &&... x) {
   return AttachDeclaration(messages.Say(std::forward<A>(x)...), symbol);
@@ -851,5 +864,5 @@ std::optional<std::string> FindImpureCall(
 std::optional<std::string> FindImpureCall(
     const IntrinsicProcTable &, const ProcedureRef &);
 
-}
-#endif  // FORTRAN_EVALUATE_TOOLS_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_TOOLS_H_
diff --git a/lib/Evaluate/tools.cpp b/lib/Evaluate/tools.cpp
index e9e2c4f0bd5c..c3a30aad8ce6 100644
--- a/lib/Evaluate/tools.cpp
+++ b/lib/Evaluate/tools.cpp
@@ -25,7 +25,7 @@ Expr<SomeType> Parenthesize(Expr<SomeType> &&expr) {
         using T = std::decay_t<decltype(x)>;
         if constexpr (common::HasMember<T, TypelessExpression> ||
             std::is_same_v<T, Expr<SomeDerived>>) {
-          return expr;  // no parentheses around typeless or derived type
+          return expr; // no parentheses around typeless or derived type
         } else {
           return std::visit(
               [](auto &&y) {
@@ -38,7 +38,7 @@ Expr<SomeType> Parenthesize(Expr<SomeType> &&expr) {
       std::move(expr.u));
 }
 
-std::optional<DataRef> ExtractDataRef(const Substring &substring) {
+std::optional<DataRef> ExtractSubstringBase(const Substring &substring) {
   return std::visit(
       common::visitors{
           [&](const DataRef &x) -> std::optional<DataRef> { return x; },
@@ -126,7 +126,7 @@ ConvertRealOperandsResult ConvertRealOperands(
             return {AsSameKindExprs<TypeCategory::Real>(
                 ConvertTo(ry, std::move(bx)), std::move(ry))};
           },
-          [&](auto &&, auto &&) -> ConvertRealOperandsResult {  // C718
+          [&](auto &&, auto &&) -> ConvertRealOperandsResult { // C718
             messages.Say("operands must be INTEGER or REAL"_err_en_US);
             return std::nullopt;
           },
@@ -137,11 +137,11 @@ ConvertRealOperandsResult ConvertRealOperands(
 // Helpers for NumericOperation and its subroutines below.
 static std::optional<Expr<SomeType>> NoExpr() { return std::nullopt; }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 std::optional<Expr<SomeType>> Package(Expr<SomeKind<CAT>> &&catExpr) {
   return {AsGenericExpr(std::move(catExpr))};
 }
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 std::optional<Expr<SomeType>> Package(
     std::optional<Expr<SomeKind<CAT>>> &&catExpr) {
   if (catExpr) {
@@ -152,7 +152,7 @@ std::optional<Expr<SomeType>> Package(
 
 // Mixed REAL+INTEGER operations.  REAL**INTEGER is a special case that
 // does not require conversion of the exponent expression.
-template<template<typename> class OPR>
+template <template <typename> class OPR>
 std::optional<Expr<SomeType>> MixedRealLeft(
     Expr<SomeReal> &&rx, Expr<SomeInteger> &&iy) {
   return Package(std::visit(
@@ -220,7 +220,7 @@ Expr<SomeComplex> PromoteRealToComplex(Expr<SomeReal> &&someX) {
 // Handle mixed COMPLEX+REAL (or INTEGER) operations in a better way
 // than just converting the second operand to COMPLEX and performing the
 // corresponding COMPLEX+COMPLEX operation.
-template<template<typename> class OPR, TypeCategory RCAT>
+template <template <typename> class OPR, TypeCategory RCAT>
 std::optional<Expr<SomeType>> MixedComplexLeft(
     parser::ContextualMessages &messages, Expr<SomeComplex> &&zx,
     Expr<SomeKind<RCAT>> &&iry, int defaultRealKind) {
@@ -261,7 +261,7 @@ std::optional<Expr<SomeType>> MixedComplexLeft(
               AsExpr(RealToIntPower<Ty>{std::move(zxk), std::move(iry)}));
         },
         std::move(zx.u)));
-  } else if (defaultRealKind != 666) {  // dodge unused parameter warning
+  } else if (defaultRealKind != 666) { // dodge unused parameter warning
     // (a,b) ** x -> (a,b) ** (x,0)
     if constexpr (RCAT == TypeCategory::Integer) {
       Expr<SomeComplex> zy{ConvertTo(zx, std::move(iry))};
@@ -279,7 +279,7 @@ std::optional<Expr<SomeType>> MixedComplexLeft(
 //  x - (a,b) -> (x-a, -b)
 //  x * (a,b) -> (x*a, x*b)
 //  x / (a,b) -> (x,0) / (a,b)   (and **)
-template<template<typename> class OPR, TypeCategory LCAT>
+template <template <typename> class OPR, TypeCategory LCAT>
 std::optional<Expr<SomeType>> MixedComplexRight(
     parser::ContextualMessages &messages, Expr<SomeKind<LCAT>> &&irx,
     Expr<SomeComplex> &&zy, int defaultRealKind) {
@@ -300,7 +300,7 @@ std::optional<Expr<SomeType>> MixedComplexRight(
       return Package(ConstructComplex(messages, std::move(*rr),
           AsGenericExpr(-std::move(zi)), defaultRealKind));
     }
-  } else if (defaultRealKind != 666) {  // dodge unused parameter warning
+  } else if (defaultRealKind != 666) { // dodge unused parameter warning
     // x / (a,b) -> (x,0) / (a,b)
     if constexpr (LCAT == TypeCategory::Integer) {
       Expr<SomeComplex> zx{ConvertTo(zy, std::move(irx))};
@@ -316,7 +316,7 @@ std::optional<Expr<SomeType>> MixedComplexRight(
 // N.B. When a "typeless" BOZ literal constant appears as one (not both!) of
 // the operands to a dyadic operation where one is permitted, it assumes the
 // type and kind of the other operand.
-template<template<typename> class OPR>
+template <template <typename> class OPR>
 std::optional<Expr<SomeType>> NumericOperation(
     parser::ContextualMessages &messages, Expr<SomeType> &&x,
     Expr<SomeType> &&y, int defaultRealKind) {
@@ -458,7 +458,7 @@ Expr<SomeLogical> LogicalNegation(Expr<SomeLogical> &&x) {
       std::move(x.u));
 }
 
-template<typename T>
+template <typename T>
 Expr<LogicalResult> PackageRelation(
     RelationalOperator opr, Expr<T> &&x, Expr<T> &&y) {
   static_assert(IsSpecificIntrinsicType<T>);
@@ -466,7 +466,7 @@ Expr<LogicalResult> PackageRelation(
       Relational<SomeType>{Relational<T>{opr, std::move(x), std::move(y)}}};
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 Expr<LogicalResult> PromoteAndRelate(
     RelationalOperator opr, Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return std::visit(
@@ -576,7 +576,7 @@ Expr<SomeLogical> BinaryLogicalOperation(
       AsSameKindExprs(std::move(x), std::move(y)));
 }
 
-template<TypeCategory TO>
+template <TypeCategory TO>
 std::optional<Expr<SomeType>> ConvertToNumeric(int kind, Expr<SomeType> &&x) {
   static_assert(common::IsNumericTypeCategory(TO));
   return std::visit(
@@ -772,7 +772,7 @@ const Symbol &ResolveAssociations(const Symbol &symbol) {
 }
 
 struct CollectSymbolsHelper
-  : public SetTraverse<CollectSymbolsHelper, semantics::SymbolSet> {
+    : public SetTraverse<CollectSymbolsHelper, semantics::SymbolSet> {
   using Base = SetTraverse<CollectSymbolsHelper, semantics::SymbolSet>;
   CollectSymbolsHelper() : Base{*this} {}
   using Base::operator();
@@ -780,7 +780,7 @@ struct CollectSymbolsHelper
     return {symbol};
   }
 };
-template<typename A> semantics::SymbolSet CollectSymbols(const A &x) {
+template <typename A> semantics::SymbolSet CollectSymbols(const A &x) {
   return CollectSymbolsHelper{}(x);
 }
 template semantics::SymbolSet CollectSymbols(const Expr<SomeType> &);
@@ -796,7 +796,7 @@ struct HasVectorSubscriptHelper : public AnyTraverse<HasVectorSubscriptHelper> {
     return !std::holds_alternative<Triplet>(ss.u) && ss.Rank() > 0;
   }
   bool operator()(const ProcedureRef &) const {
-    return false;  // don't descend into function call arguments
+    return false; // don't descend into function call arguments
   }
 };
 
@@ -841,13 +841,13 @@ parser::Message *AttachDeclaration(
 }
 
 class FindImpureCallHelper
-  : public AnyTraverse<FindImpureCallHelper, std::optional<std::string>> {
+    : public AnyTraverse<FindImpureCallHelper, std::optional<std::string>> {
   using Result = std::optional<std::string>;
   using Base = AnyTraverse<FindImpureCallHelper, Result>;
 
 public:
   explicit FindImpureCallHelper(const IntrinsicProcTable &intrinsics)
-    : Base{*this}, intrinsics_{intrinsics} {}
+      : Base{*this}, intrinsics_{intrinsics} {}
   using Base::operator();
   Result operator()(const ProcedureRef &call) const {
     if (auto chars{characteristics::Procedure::Characterize(
@@ -872,4 +872,4 @@ std::optional<std::string> FindImpureCall(
   return FindImpureCallHelper{intrinsics}(proc);
 }
 
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Semantics/assignment.cpp b/lib/Semantics/assignment.cpp
index 18f0ffcfa29f..3e74f86b23e9 100644
--- a/lib/Semantics/assignment.cpp
+++ b/lib/Semantics/assignment.cpp
@@ -36,7 +36,7 @@ class AssignmentContext {
   AssignmentContext(const AssignmentContext &) = delete;
   bool operator==(const AssignmentContext &x) const { return this == &x; }
 
-  template<typename A> void PushWhereContext(const A &);
+  template <typename A> void PushWhereContext(const A &);
   void PopWhereContext();
   void Analyze(const parser::AssignmentStmt &);
   void Analyze(const parser::PointerAssignmentStmt &);
@@ -46,7 +46,7 @@ class AssignmentContext {
   bool CheckForPureContext(const SomeExpr &lhs, const SomeExpr &rhs,
       parser::CharBlock rhsSource, bool isPointerAssignment);
   void CheckShape(parser::CharBlock, const SomeExpr *);
-  template<typename... A>
+  template <typename... A>
   parser::Message *Say(parser::CharBlock at, A &&... args) {
     return &context_.Say(at, std::forward<A>(args)...);
   }
@@ -55,7 +55,7 @@ class AssignmentContext {
   }
 
   SemanticsContext &context_;
-  int whereDepth_{0};  // number of WHEREs currently nested in
+  int whereDepth_{0}; // number of WHEREs currently nested in
   // shape of masks in LHS of assignments in current WHERE:
   std::vector<std::optional<std::int64_t>> whereExtents_;
 };
@@ -67,7 +67,7 @@ void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
     auto lhsLoc{std::get<parser::Variable>(stmt.t).GetSource()};
     auto rhsLoc{std::get<parser::Expr>(stmt.t).source};
     auto shape{evaluate::GetShape(foldingContext(), lhs)};
-    if (shape && !shape->empty() && !shape->back().has_value()) {  // C1014
+    if (shape && !shape->empty() && !shape->back().has_value()) { // C1014
       Say(lhsLoc,
           "Left-hand side of assignment may not be a whole assumed-size array"_err_en_US);
     }
@@ -178,7 +178,7 @@ bool AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
           "A pure subprogram may not define a coindexed object"_err_en_US);
     } else if (const Symbol * base{GetFirstSymbol(lhs)}) {
       if (const auto *assoc{base->detailsIf<AssocEntityDetails>()}) {
-        auto dataRef{ExtractDataRef(assoc->expr())};
+        auto dataRef{ExtractDataRef(assoc->expr(), true)};
         // ASSOCIATE(a=>x) -- check x, not a, for "a=..."
         base = dataRef ? &dataRef->GetFirstSymbol() : nullptr;
       }
@@ -190,7 +190,7 @@ bool AssignmentContext::CheckForPureContext(const SomeExpr &lhs,
     if (isPointerAssignment) {
       if (const Symbol * base{GetFirstSymbol(rhs)}) {
         if (const char *why{
-                WhyBaseObjectIsSuspicious(*base, scope)}) {  // C1594(3)
+                WhyBaseObjectIsSuspicious(*base, scope)}) { // C1594(3)
           evaluate::SayWithDeclaration(messages, *base,
               "A pure subprogram may not use '%s' as the target of pointer assignment because it is %s"_err_en_US,
               base->name(), why);
@@ -249,7 +249,7 @@ void AssignmentContext::CheckShape(parser::CharBlock at, const SomeExpr *expr) {
   }
 }
 
-template<typename A> void AssignmentContext::PushWhereContext(const A &x) {
+template <typename A> void AssignmentContext::PushWhereContext(const A &x) {
   const auto &expr{std::get<parser::LogicalExpr>(x.t)};
   CheckShape(expr.thing.value().source, GetExpr(expr));
   ++whereDepth_;
@@ -265,7 +265,7 @@ void AssignmentContext::PopWhereContext() {
 AssignmentChecker::~AssignmentChecker() {}
 
 AssignmentChecker::AssignmentChecker(SemanticsContext &context)
-  : context_{new AssignmentContext{context}} {}
+    : context_{new AssignmentContext{context}} {}
 void AssignmentChecker::Enter(const parser::AssignmentStmt &x) {
   context_.value().Analyze(x);
 }
@@ -291,6 +291,6 @@ void AssignmentChecker::Leave(const parser::MaskedElsewhereStmt &) {
   context_.value().PopWhereContext();
 }
 
-}
+} // namespace Fortran::semantics
 template class Fortran::common::Indirection<
     Fortran::semantics::AssignmentContext>;
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index b8e52d9a9802..717266af9733 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -60,7 +60,7 @@ std::optional<Expr<SubscriptInteger>> DynamicTypeWithLength::LEN() const {
       return ConvertToType<SubscriptInteger>(common::Clone(*len));
     }
   }
-  return std::nullopt;  // assumed or deferred length
+  return std::nullopt; // assumed or deferred length
 }
 
 static std::optional<DynamicTypeWithLength> AnalyzeTypeSpec(
@@ -97,14 +97,14 @@ static std::optional<DynamicTypeWithLength> AnalyzeTypeSpec(
 
 // Wraps a object in an explicitly typed representation (e.g., Designator<>
 // or FunctionRef<>) that has been instantiated on a dynamically chosen type.
-template<TypeCategory CATEGORY, template<typename> typename WRAPPER,
+template <TypeCategory CATEGORY, template <typename> typename WRAPPER,
     typename WRAPPED>
 common::IfNoLvalue<MaybeExpr, WRAPPED> WrapperHelper(int kind, WRAPPED &&x) {
   return common::SearchTypes(
       TypeKindVisitor<CATEGORY, WRAPPER, WRAPPED>{kind, std::move(x)});
 }
 
-template<template<typename> typename WRAPPER, typename WRAPPED>
+template <template <typename> typename WRAPPER, typename WRAPPED>
 common::IfNoLvalue<MaybeExpr, WRAPPED> TypedWrapper(
     const DynamicType &dyType, WRAPPED &&x) {
   switch (dyType.category()) {
@@ -132,10 +132,11 @@ common::IfNoLvalue<MaybeExpr, WRAPPED> TypedWrapper(
 class ArgumentAnalyzer {
 public:
   explicit ArgumentAnalyzer(ExpressionAnalyzer &context)
-    : context_{context}, allowAssumedType_{false} {}
+      : context_{context}, allowAssumedType_{false} {}
   ArgumentAnalyzer(ExpressionAnalyzer &context, parser::CharBlock source,
       bool allowAssumedType = false)
-    : context_{context}, source_{source}, allowAssumedType_{allowAssumedType} {}
+      : context_{context}, source_{source}, allowAssumedType_{
+                                                allowAssumedType} {}
   bool fatalErrors() const { return fatalErrors_; }
   ActualArguments &&GetActuals() {
     CHECK(!fatalErrors_);
@@ -166,7 +167,7 @@ class ArgumentAnalyzer {
   // The provided message is used if there is no such operator.
   MaybeExpr TryDefinedOp(
       const char *, parser::MessageFixedText &&, bool isUserOp = false);
-  template<typename E>
+  template <typename E>
   MaybeExpr TryDefinedOp(E opr, parser::MessageFixedText &&msg) {
     return TryDefinedOp(
         context_.context().languageFeatures().GetNames(opr), std::move(msg));
@@ -355,6 +356,8 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::Designator &d) {
   FixMisparsedSubstring(d);
   // These checks have to be deferred to these "top level" data-refs where
   // we can be sure that there are no following subscripts (yet).
+  // Substrings have already been run through TopLevelChecks() and
+  // won't be returned by ExtractDataRef().
   if (MaybeExpr result{Analyze(d.u)}) {
     if (std::optional<DataRef> dataRef{ExtractDataRef(std::move(result))}) {
       return TopLevelChecks(std::move(*dataRef));
@@ -366,10 +369,10 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::Designator &d) {
 
 // A utility subroutine to repackage optional expressions of various levels
 // of type specificity as fully general MaybeExpr values.
-template<typename A> common::IfNoLvalue<MaybeExpr, A> AsMaybeExpr(A &&x) {
+template <typename A> common::IfNoLvalue<MaybeExpr, A> AsMaybeExpr(A &&x) {
   return std::make_optional(AsGenericExpr(std::move(x)));
 }
-template<typename A> MaybeExpr AsMaybeExpr(std::optional<A> &&x) {
+template <typename A> MaybeExpr AsMaybeExpr(std::optional<A> &&x) {
   if (x) {
     return AsMaybeExpr(std::move(*x));
   }
@@ -405,7 +408,7 @@ int ExpressionAnalyzer::AnalyzeKindParam(
 struct IntTypeVisitor {
   using Result = MaybeExpr;
   using Types = IntegerTypes;
-  template<typename T> Result Test() {
+  template <typename T> Result Test() {
     if (T::kind >= kind) {
       const char *p{digits.begin()};
       auto value{T::Scalar::Read(p, 10, true /*signed*/)};
@@ -434,7 +437,7 @@ struct IntTypeVisitor {
   bool isDefaultKind;
 };
 
-template<typename PARSED>
+template <typename PARSED>
 MaybeExpr ExpressionAnalyzer::IntLiteralConstant(const PARSED &x) {
   const auto &kindParam{std::get<std::optional<parser::KindParam>>(x.t)};
   bool isDefaultKind{!kindParam};
@@ -468,7 +471,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(
   return IntLiteralConstant(x);
 }
 
-template<typename TYPE>
+template <typename TYPE>
 Constant<TYPE> ReadRealLiteral(
     parser::CharBlock source, FoldingContext &context) {
   const char *p{source.begin()};
@@ -487,9 +490,9 @@ struct RealTypeVisitor {
   using Types = RealTypes;
 
   RealTypeVisitor(int k, parser::CharBlock lit, FoldingContext &ctx)
-    : kind{k}, literal{lit}, context{ctx} {}
+      : kind{k}, literal{lit}, context{ctx} {}
 
-  template<typename T> Result Test() {
+  template <typename T> Result Test() {
     if (kind == T::kind) {
       return {AsCategoryExpr(ReadRealLiteral<T>(literal, context))};
     }
@@ -519,10 +522,17 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::RealLiteralConstant &x) {
     if (parser::IsLetter(*p)) {
       expoLetter = *p;
       switch (expoLetter) {
-      case 'e': letterKind = defaults.GetDefaultKind(TypeCategory::Real); break;
-      case 'd': letterKind = defaults.doublePrecisionKind(); break;
-      case 'q': letterKind = defaults.quadPrecisionKind(); break;
-      default: Say("Unknown exponent letter '%c'"_err_en_US, expoLetter);
+      case 'e':
+        letterKind = defaults.GetDefaultKind(TypeCategory::Real);
+        break;
+      case 'd':
+        letterKind = defaults.doublePrecisionKind();
+        break;
+      case 'q':
+        letterKind = defaults.quadPrecisionKind();
+        break;
+      default:
+        Say("Unknown exponent letter '%c'"_err_en_US, expoLetter);
       }
       break;
     }
@@ -539,7 +549,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::RealLiteralConstant &x) {
   }
   auto result{common::SearchTypes(
       RealTypeVisitor{kind, x.real.source, GetFoldingContext()})};
-  if (!result) {  // C717
+  if (!result) { // C717
     Say("Unsupported REAL(KIND=%d)"_err_en_US, kind);
   }
   return AsMaybeExpr(std::move(result));
@@ -599,7 +609,8 @@ MaybeExpr ExpressionAnalyzer::AnalyzeString(std::string &&string, int kind) {
     return AsGenericExpr(Constant<Type<TypeCategory::Character, 4>>{
         parser::DecodeString<std::u32string, parser::Encoding::UTF_8>(
             string, true)});
-  default: CRASH_NO_CASE;
+  default:
+    CRASH_NO_CASE;
   }
 }
 
@@ -626,7 +637,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::LogicalLiteralConstant &x) {
       TypeKindVisitor<TypeCategory::Logical, Constant, bool>{
           kind, std::move(value)})};
   if (!result) {
-    Say("unsupported LOGICAL(KIND=%d)"_err_en_US, kind);  // C728
+    Say("unsupported LOGICAL(KIND=%d)"_err_en_US, kind); // C728
   }
   return result;
 }
@@ -636,11 +647,18 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::BOZLiteralConstant &x) {
   const char *p{x.v.c_str()};
   std::uint64_t base{16};
   switch (*p++) {
-  case 'b': base = 2; break;
-  case 'o': base = 8; break;
-  case 'z': break;
-  case 'x': break;
-  default: CRASH_NO_CASE;
+  case 'b':
+    base = 2;
+    break;
+  case 'o':
+    base = 8;
+    break;
+  case 'z':
+    break;
+  case 'x':
+    break;
+  default:
+    CRASH_NO_CASE;
   }
   CHECK(*p == '"');
   ++p;
@@ -662,10 +680,10 @@ struct TypeParamInquiryVisitor {
   using Result = std::optional<Expr<SomeInteger>>;
   using Types = IntegerTypes;
   TypeParamInquiryVisitor(int k, NamedEntity &&b, const Symbol &param)
-    : kind{k}, base{std::move(b)}, parameter{param} {}
+      : kind{k}, base{std::move(b)}, parameter{param} {}
   TypeParamInquiryVisitor(int k, const Symbol &param)
-    : kind{k}, parameter{param} {}
-  template<typename T> Result Test() {
+      : kind{k}, parameter{param} {}
+  template <typename T> Result Test() {
     if (kind == T::kind) {
       return Expr<SomeInteger>{
           Expr<T>{TypeParamInquiry<T::kind>{std::move(base), parameter}}};
@@ -723,7 +741,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::NamedConstant &n) {
     if (IsConstantExpr(folded)) {
       return {folded};
     }
-    Say(n.v.source, "must be a constant"_err_en_US);  // C718
+    Say(n.v.source, "must be a constant"_err_en_US); // C718
   }
   return std::nullopt;
 }
@@ -1093,7 +1111,7 @@ int ExpressionAnalyzer::IntegerTypeSpecKind(
 
 // Inverts a collection of generic ArrayConstructorValues<SomeType> that
 // all happen to have the same actual type T into one ArrayConstructor<T>.
-template<typename T>
+template <typename T>
 ArrayConstructorValues<T> MakeSpecific(
     ArrayConstructorValues<SomeType> &&from) {
   ArrayConstructorValues<T> to;
@@ -1120,7 +1138,7 @@ class ArrayConstructorContext {
 public:
   ArrayConstructorContext(
       ExpressionAnalyzer &c, std::optional<DynamicTypeWithLength> &&t)
-    : exprAnalyzer_{c}, type_{std::move(t)} {}
+      : exprAnalyzer_{c}, type_{std::move(t)} {}
 
   void Add(const parser::AcValue &);
   MaybeExpr ToExpr();
@@ -1130,7 +1148,7 @@ class ArrayConstructorContext {
   // expression in ToExpr().
   using Result = MaybeExpr;
   using Types = AllTypes;
-  template<typename T> Result Test() {
+  template <typename T> Result Test() {
     if (type_ && type_->category() == T::category) {
       if constexpr (T::category == TypeCategory::Derived) {
         return AsMaybeExpr(ArrayConstructor<T>{
@@ -1153,7 +1171,7 @@ class ArrayConstructorContext {
 private:
   void Push(MaybeExpr &&);
 
-  template<int KIND, typename A>
+  template <int KIND, typename A>
   std::optional<Expr<Type<TypeCategory::Integer, KIND>>> GetSpecificIntExpr(
       const A &x) {
     if (MaybeExpr y{exprAnalyzer_.Analyze(x)}) {
@@ -1338,12 +1356,12 @@ MaybeExpr ExpressionAnalyzer::Analyze(
   const auto &spec{*parsedType.derivedTypeSpec};
   const Symbol &typeSymbol{spec.typeSymbol()};
   if (!spec.scope() || !typeSymbol.has<semantics::DerivedTypeDetails>()) {
-    return std::nullopt;  // error recovery
+    return std::nullopt; // error recovery
   }
   const auto &typeDetails{typeSymbol.get<semantics::DerivedTypeDetails>()};
   const Symbol *parentComponent{typeDetails.GetParentComponent(*spec.scope())};
 
-  if (typeSymbol.attrs().test(semantics::Attr::ABSTRACT)) {  // C796
+  if (typeSymbol.attrs().test(semantics::Attr::ABSTRACT)) { // C796
     AttachDeclaration(Say(typeName,
                           "ABSTRACT derived type '%s' may not be used in a "
                           "structure constructor"_err_en_US,
@@ -1365,7 +1383,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(
   std::set<parser::CharBlock> unavailable;
   bool anyKeyword{false};
   StructureConstructor result{spec};
-  bool checkConflicts{true};  // until we hit one
+  bool checkConflicts{true}; // until we hit one
 
   for (const auto &component :
       std::get<std::list<parser::ComponentSpec>>(structure.t)) {
@@ -1388,16 +1406,16 @@ MaybeExpr ExpressionAnalyzer::Analyze(
           symbol = &*componentIter;
         }
       }
-      if (!symbol) {  // C7101
+      if (!symbol) { // C7101
         Say(source,
             "Keyword '%s=' does not name a component of derived type '%s'"_err_en_US,
             source, typeName);
       }
     } else {
-      if (anyKeyword) {  // C7100
+      if (anyKeyword) { // C7100
         Say(source,
             "Value in structure constructor lacks a component name"_err_en_US);
-        checkConflicts = false;  // stem cascade
+        checkConflicts = false; // stem cascade
       }
       // Here's a regrettably common extension of the standard: anonymous
       // initialization of parent components, e.g., T(PT(1)) rather than
@@ -1496,7 +1514,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(
         }
         if (IsPointer(*symbol)) {
           semantics::CheckPointerAssignment(
-              GetFoldingContext(), *symbol, *value);  // C7104, C7105
+              GetFoldingContext(), *symbol, *value); // C7104, C7105
           result.Add(*symbol, Fold(std::move(*value)));
         } else if (MaybeExpr converted{
                        ConvertToType(*symbol, std::move(*value))}) {
@@ -1535,7 +1553,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(
               symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
         if (details->init()) {
           result.Add(symbol, common::Clone(*details->init()));
-        } else {  // C799
+        } else { // C799
           AttachDeclaration(Say(typeName,
                                 "Structure constructor lacks a value for "
                                 "component '%s'"_err_en_US,
@@ -1568,7 +1586,7 @@ static int GetPassIndex(const Symbol &proc) {
   std::optional<parser::CharBlock> passName{GetPassName(proc)};
   const auto *interface{semantics::FindInterface(proc)};
   if (!passName || !interface) {
-    return 0;  // first argument is passed-object
+    return 0; // first argument is passed-object
   }
   const auto &subp{interface->get<semantics::SubprogramDetails>()};
   int index{0};
@@ -1744,7 +1762,7 @@ bool ExpressionAnalyzer::ResolveForward(const Symbol &symbol) {
         context_.SetError(const_cast<Symbol &>(symbol));
         return false;
       }
-    } else {  // 10.1.11 para 4
+    } else { // 10.1.11 para 4
       Say("The internal function '%s' may not be referenced in a specification expression"_err_en_US,
           symbol.name());
       context_.SetError(const_cast<Symbol &>(symbol));
@@ -1759,7 +1777,7 @@ bool ExpressionAnalyzer::ResolveForward(const Symbol &symbol) {
 const Symbol *ExpressionAnalyzer::ResolveGeneric(const Symbol &symbol,
     const ActualArguments &actuals, const AdjustActuals &adjustActuals,
     bool mightBeStructureConstructor) {
-  const Symbol *elemental{nullptr};  // matching elemental specific proc
+  const Symbol *elemental{nullptr}; // matching elemental specific proc
   const auto &details{symbol.GetUltimate().get<semantics::GenericDetails>()};
   for (const Symbol &specific : details.specificProcs()) {
     if (!ResolveForward(specific)) {
@@ -1778,7 +1796,7 @@ const Symbol *ExpressionAnalyzer::ResolveGeneric(const Symbol &symbol,
               *procedure, localActuals, GetFoldingContext())) {
         if (CheckCompatibleArguments(*procedure, localActuals)) {
           if (!procedure->IsElemental()) {
-            return &specific;  // takes priority over elemental match
+            return &specific; // takes priority over elemental match
           }
           elemental = &specific;
         }
@@ -1837,7 +1855,7 @@ auto ExpressionAnalyzer::GetCalleeAndArguments(const parser::Name &name,
     bool mightBeStructureConstructor) -> std::optional<CalleeAndArguments> {
   const Symbol *symbol{name.symbol};
   if (context_.HasError(symbol)) {
-    return std::nullopt;  // also handles null symbol
+    return std::nullopt; // also handles null symbol
   }
   const Symbol &ultimate{DEREF(symbol).GetUltimate()};
   if (ultimate.attrs().test(semantics::Attr::INTRINSIC)) {
@@ -1886,11 +1904,11 @@ void ExpressionAnalyzer::CheckForBadRecursion(
   if (const auto *scope{proc.scope()}) {
     if (scope->sourceRange().Contains(callSite)) {
       parser::Message *msg{nullptr};
-      if (proc.attrs().test(semantics::Attr::NON_RECURSIVE)) {  // 15.6.2.1(3)
+      if (proc.attrs().test(semantics::Attr::NON_RECURSIVE)) { // 15.6.2.1(3)
         msg = Say("NON_RECURSIVE procedure '%s' cannot call itself"_err_en_US,
             callSite);
       } else if (IsAssumedLengthCharacter(proc) && IsExternal(proc)) {
-        msg = Say(  // 15.6.2.1(3)
+        msg = Say( // 15.6.2.1(3)
             "Assumed-length CHARACTER(*) function '%s' cannot call itself"_err_en_US,
             callSite);
       }
@@ -1899,7 +1917,7 @@ void ExpressionAnalyzer::CheckForBadRecursion(
   }
 }
 
-template<typename A> static const Symbol *AssumedTypeDummy(const A &x) {
+template <typename A> static const Symbol *AssumedTypeDummy(const A &x) {
   if (const auto *designator{
           std::get_if<common::Indirection<parser::Designator>>(&x.u)}) {
     if (const auto *dataRef{
@@ -2088,7 +2106,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Parentheses &x) {
       if (const semantics::Symbol * result{FindFunctionResult(*symbol)}) {
         if (semantics::IsProcedurePointer(*result)) {
           Say("A function reference that returns a procedure "
-              "pointer may not be parenthesized"_err_en_US);  // C1003
+              "pointer may not be parenthesized"_err_en_US); // C1003
         }
       }
     }
@@ -2166,7 +2184,7 @@ MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::DefinedUnary &x) {
 
 // Binary (dyadic) operations
 
-template<template<typename> class OPR>
+template <template <typename> class OPR>
 MaybeExpr NumericBinaryHelper(ExpressionAnalyzer &context, NumericOperator opr,
     const parser::Expr::IntrinsicBinary &x) {
   ArgumentAnalyzer analyzer{context};
@@ -2370,7 +2388,7 @@ static void CheckFuncRefToArrayElementRefHasSubscripts(
 // A(1) as a function reference into an array reference.
 // Misparse structure constructors are detected elsewhere after generic
 // function call resolution fails.
-template<typename... A>
+template <typename... A>
 static void FixMisparsedFunctionReference(
     semantics::SemanticsContext &context, const std::variant<A...> &constU) {
   // The parse tree is updated in situ when resolving an ambiguous parse.
@@ -2407,12 +2425,12 @@ static void FixMisparsedFunctionReference(
 }
 
 // Common handling of parser::Expr and parser::Variable
-template<typename PARSED>
+template <typename PARSED>
 MaybeExpr ExpressionAnalyzer::ExprOrVariable(const PARSED &x) {
   if (!x.typedExpr) {
     FixMisparsedFunctionReference(context_, x.u);
     MaybeExpr result;
-    if (AssumedTypeDummy(x)) {  // C710
+    if (AssumedTypeDummy(x)) { // C710
       Say("TYPE(*) dummy argument may only be used as an actual argument"_err_en_US);
     } else {
       if constexpr (std::is_same_v<PARSED, parser::Expr>) {
@@ -2495,7 +2513,7 @@ DynamicType ExpressionAnalyzer::GetDefaultKindOfType(
 
 bool ExpressionAnalyzer::CheckIntrinsicKind(
     TypeCategory category, std::int64_t kind) {
-  if (IsValidKindOfIntrinsicType(category, kind)) {  // C712, C714, C715, C727
+  if (IsValidKindOfIntrinsicType(category, kind)) { // C712, C714, C715, C727
     return true;
   } else {
     Say("%s(KIND=%jd) is not a supported type"_err_en_US,
@@ -2544,7 +2562,7 @@ bool ExpressionAnalyzer::EnforceTypeConstraint(parser::CharBlock at,
     const MaybeExpr &result, TypeCategory category, bool defaultKind) {
   if (result) {
     if (auto type{result->GetType()}) {
-      if (type->category() != category) {  // C885
+      if (type->category() != category) { // C885
         Say(at, "Must have %s type, but is %s"_err_en_US,
             ToUpperCase(EnumToString(category)),
             ToUpperCase(type->AsFortran()));
@@ -2683,7 +2701,7 @@ bool ArgumentAnalyzer::IsIntrinsicNumeric(NumericOperator opr) const {
     if (IsBOZLiteral(0) && type1) {
       auto cat1{type1->category()};
       return cat1 == TypeCategory::Integer || cat1 == TypeCategory::Real;
-    } else if (IsBOZLiteral(1) && type0) {  // Integer/Real opr BOZ
+    } else if (IsBOZLiteral(1) && type0) { // Integer/Real opr BOZ
       auto cat0{type0->category()};
       return cat0 == TypeCategory::Integer || cat0 == TypeCategory::Real;
     } else {
@@ -2782,7 +2800,7 @@ std::optional<ProcedureRef> ArgumentAnalyzer::TryDefinedAssignment() {
   Tristate isDefined{
       semantics::IsDefinedAssignment(lhsType, lhsRank, rhsType, rhsRank)};
   if (isDefined == Tristate::No) {
-    return std::nullopt;  // user-defined assignment not allowed for these args
+    return std::nullopt; // user-defined assignment not allowed for these args
   }
   auto restorer{context_.GetContextualMessages().SetLocation(source_)};
   if (std::optional<ProcedureRef> procRef{GetDefinedAssignmentProc()}) {
@@ -2979,7 +2997,7 @@ bool ArgumentAnalyzer::AnyUntypedOperand() {
   return false;
 }
 
-}  // namespace Fortran::evaluate
+} // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 evaluate::Expr<evaluate::SubscriptInteger> AnalyzeKindSelector(
@@ -3024,4 +3042,4 @@ bool ExprChecker::Pre(const parser::DataStmtConstant &x) {
   return false;
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index ce59825167ee..249dcb27b65a 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -56,8 +56,10 @@ const Scope *FindProgramUnitContaining(const Scope &start) {
     case Scope::Kind::Module:
     case Scope::Kind::MainProgram:
     case Scope::Kind::Subprogram:
-    case Scope::Kind::BlockData: return true;
-    default: return false;
+    case Scope::Kind::BlockData:
+      return true;
+    default:
+      return false;
     }
   });
 }
@@ -82,7 +84,7 @@ Tristate IsDefinedAssignment(
     const std::optional<evaluate::DynamicType> &lhsType, int lhsRank,
     const std::optional<evaluate::DynamicType> &rhsType, int rhsRank) {
   if (!lhsType || !rhsType) {
-    return Tristate::No;  // error or rhs is untyped
+    return Tristate::No; // error or rhs is untyped
   }
   TypeCategory lhsCat{lhsType->category()};
   TypeCategory rhsCat{rhsType->category()};
@@ -95,8 +97,8 @@ Tristate IsDefinedAssignment(
     const auto *lhsDerived{evaluate::GetDerivedTypeSpec(lhsType)};
     const auto *rhsDerived{evaluate::GetDerivedTypeSpec(rhsType)};
     if (lhsDerived && rhsDerived && *lhsDerived == *rhsDerived) {
-      return Tristate::Maybe;  // TYPE(t) = TYPE(t) can be defined or
-                               // intrinsic
+      return Tristate::Maybe; // TYPE(t) = TYPE(t) can be defined or
+                              // intrinsic
     } else {
       return Tristate::Yes;
     }
@@ -412,7 +414,8 @@ bool ExprTypeKindIsDefault(
 }
 
 // If an analyzed expr or assignment is missing, dump the node and die.
-template<typename T> static void CheckMissingAnalysis(bool absent, const T &x) {
+template <typename T>
+static void CheckMissingAnalysis(bool absent, const T &x) {
   if (absent) {
     std::string buf;
     llvm::raw_string_ostream ss{buf};
@@ -611,7 +614,7 @@ bool IsSaved(const Symbol &symbol) {
   if (scopeKind == Scope::Kind::Module || scopeKind == Scope::Kind::BlockData) {
     return true;
   } else if (scopeKind == Scope::Kind::DerivedType) {
-    return false;  // this is a component
+    return false; // this is a component
   } else if (IsNamedConstant(symbol)) {
     return false;
   } else if (symbol.attrs().test(Attr::SAVE)) {
@@ -816,7 +819,7 @@ std::optional<parser::Message> WhyNotModifiable(parser::CharBlock at,
     const SomeExpr &expr, const Scope &scope, bool vectorSubscriptIsOk) {
   if (!evaluate::IsVariable(expr)) {
     return parser::Message{at, "Expression is not a variable"_en_US};
-  } else if (auto dataRef{evaluate::ExtractDataRef(expr)}) {
+  } else if (auto dataRef{evaluate::ExtractDataRef(expr, true)}) {
     if (!vectorSubscriptIsOk && evaluate::HasVectorSubscript(expr)) {
       return parser::Message{at, "Variable has a vector subscript"_en_US};
     }
@@ -839,10 +842,10 @@ class ImageControlStmtHelper {
       parser::SyncTeamStmt, parser::UnlockStmt>;
 
 public:
-  template<typename T> bool operator()(const T &) {
+  template <typename T> bool operator()(const T &) {
     return common::HasMember<T, ImageControlStmts>;
   }
-  template<typename T> bool operator()(const common::Indirection<T> &x) {
+  template <typename T> bool operator()(const common::Indirection<T> &x) {
     return (*this)(x.value());
   }
   bool operator()(const parser::AllocateStmt &stmt) {
@@ -980,7 +983,7 @@ bool IsPolymorphicAllocatable(const Symbol &symbol) {
 
 std::optional<parser::MessageFormattedText> CheckAccessibleComponent(
     const Scope &scope, const Symbol &symbol) {
-  CHECK(symbol.owner().IsDerivedType());  // symbol must be a component
+  CHECK(symbol.owner().IsDerivedType()); // symbol must be a component
   if (symbol.attrs().test(Attr::PRIVATE)) {
     if (const Scope * moduleScope{FindModuleContaining(symbol.owner())}) {
       if (!moduleScope->Contains(scope)) {
@@ -1047,17 +1050,17 @@ const Symbol *FindSeparateModuleSubprogramInterface(const Symbol *proc) {
 
 // ComponentIterator implementation
 
-template<ComponentKind componentKind>
+template <ComponentKind componentKind>
 typename ComponentIterator<componentKind>::const_iterator
 ComponentIterator<componentKind>::const_iterator::Create(
     const DerivedTypeSpec &derived) {
   const_iterator it{};
   it.componentPath_.emplace_back(derived);
-  it.Increment();  // cue up first relevant component, if any
+  it.Increment(); // cue up first relevant component, if any
   return it;
 }
 
-template<ComponentKind componentKind>
+template <ComponentKind componentKind>
 const DerivedTypeSpec *
 ComponentIterator<componentKind>::const_iterator::PlanComponentTraversal(
     const Symbol &component) const {
@@ -1091,12 +1094,12 @@ ComponentIterator<componentKind>::const_iterator::PlanComponentTraversal(
           return derived;
         }
       }
-    }  // intrinsic & unlimited polymorphic not traversable
+    } // intrinsic & unlimited polymorphic not traversable
   }
   return nullptr;
 }
 
-template<ComponentKind componentKind>
+template <ComponentKind componentKind>
 static bool StopAtComponentPre(const Symbol &component) {
   if constexpr (componentKind == ComponentKind::Ordered) {
     // Parent components need to be iterated upon after their
@@ -1114,13 +1117,13 @@ static bool StopAtComponentPre(const Symbol &component) {
   }
 }
 
-template<ComponentKind componentKind>
+template <ComponentKind componentKind>
 static bool StopAtComponentPost(const Symbol &component) {
   return componentKind == ComponentKind::Ordered &&
       component.test(Symbol::Flag::ParentComp);
 }
 
-template<ComponentKind componentKind>
+template <ComponentKind componentKind>
 void ComponentIterator<componentKind>::const_iterator::Increment() {
   while (!componentPath_.empty()) {
     ComponentPathNode &deepest{componentPath_.back()};
@@ -1134,7 +1137,7 @@ void ComponentIterator<componentKind>::const_iterator::Increment() {
         }
       } else if (!deepest.visited()) {
         deepest.set_visited(true);
-        return;  // this is the next component to visit, after descending
+        return; // this is the next component to visit, after descending
       }
     }
     auto &nameIterator{deepest.nameIterator()};
@@ -1144,7 +1147,7 @@ void ComponentIterator<componentKind>::const_iterator::Increment() {
       deepest.set_component(*nameIterator++->second);
       deepest.set_descended(false);
       deepest.set_visited(true);
-      return;  // this is the next component to visit, before descending
+      return; // this is the next component to visit, before descending
     } else {
       const Scope &scope{deepest.GetScope()};
       auto scopeIter{scope.find(*nameIterator++)};
@@ -1154,7 +1157,7 @@ void ComponentIterator<componentKind>::const_iterator::Increment() {
         deepest.set_descended(false);
         if (StopAtComponentPre<componentKind>(component)) {
           deepest.set_visited(true);
-          return;  // this is the next component to visit, before descending
+          return; // this is the next component to visit, before descending
         } else {
           deepest.set_visited(!StopAtComponentPost<componentKind>(component));
         }
@@ -1163,7 +1166,7 @@ void ComponentIterator<componentKind>::const_iterator::Increment() {
   }
 }
 
-template<ComponentKind componentKind>
+template <ComponentKind componentKind>
 std::string
 ComponentIterator<componentKind>::const_iterator::BuildResultDesignatorName()
     const {
@@ -1353,4 +1356,4 @@ void LabelEnforce::SayWithConstruct(SemanticsContext &context,
   context.Say(stmtLocation, message)
       .Attach(constructLocation, GetEnclosingConstructMsg());
 }
-}
+} // namespace Fortran::semantics

From 7b7e30845df14886342d0d3b7020d34d52256bd8 Mon Sep 17 00:00:00 2001
From: Isuru Fernando <isuruf@gmail.com>
Date: Thu, 12 Mar 2020 15:48:00 -0500
Subject: [PATCH 106/345] Support windows where mkstemp and ftruncate doesn't
 exist

---
 runtime/file.cpp | 53 ++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 44 insertions(+), 9 deletions(-)

diff --git a/runtime/file.cpp b/runtime/file.cpp
index 31b4246ee03d..233217c70096 100644
--- a/runtime/file.cpp
+++ b/runtime/file.cpp
@@ -13,7 +13,12 @@
 #include <cstring>
 #include <fcntl.h>
 #include <stdlib.h>
+#ifdef _WIN32
+#include <io.h>
+#include <windows.h>
+#else
 #include <unistd.h>
+#endif
 
 namespace Fortran::runtime::io {
 
@@ -22,6 +27,35 @@ void OpenFile::set_path(OwningPtr<char> &&path, std::size_t bytes) {
   pathLength_ = bytes;
 }
 
+static int openfile_mkstemp(IoErrorHandler &handler) {
+#ifdef _WIN32
+  const unsigned int uUnique{0};
+  // GetTempFileNameA needs a directory name < MAX_PATH-14 characters in length.
+  // https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-gettempfilenamea
+  char tempDirName[MAX_PATH - 14];
+  char tempFileName[MAX_PATH];
+  unsigned long nBufferLength{sizeof(tempDirName)};
+  nBufferLength = ::GetTempPathA(nBufferLength, tempDirName);
+  if (nBufferLength > sizeof(tempDirName) || nBufferLength == 0) {
+    return -1;
+  }
+  if (::GetTempFileNameA(tempDirName, "Fortran", uUnique, tempFileName) == 0) {
+    return -1;
+  }
+  int fd{::_open(tempFileName, _O_CREAT | _O_TEMPORARY, _S_IREAD | _S_IWRITE)};
+#else
+  char path[]{"/tmp/Fortran-Scratch-XXXXXX"};
+  int fd{::mkstemp(path)};
+#endif
+  if (fd < 0) {
+    handler.SignalErrno();
+  }
+#ifndef _WIN32
+  ::unlink(path);
+#endif
+  return fd;
+}
+
 void OpenFile::Open(
     OpenStatus status, Position position, IoErrorHandler &handler) {
   int flags{mayRead_ ? mayWrite_ ? O_RDWR : O_RDONLY : O_WRONLY};
@@ -37,14 +71,7 @@ void OpenFile::Open(
       handler.SignalError("FILE= must not appear with STATUS='SCRATCH'");
       path_.reset();
     }
-    {
-      char path[]{"/tmp/Fortran-Scratch-XXXXXX"};
-      fd_ = ::mkstemp(path);
-      if (fd_ < 0) {
-        handler.SignalErrno();
-      }
-      ::unlink(path);
-    }
+    fd_ = openfile_mkstemp(handler);
     return;
   case OpenStatus::Replace: flags |= O_CREAT | O_TRUNC; break;
   case OpenStatus::Unknown:
@@ -173,10 +200,18 @@ std::size_t OpenFile::Write(FileOffset at, const char *buffer,
   return put;
 }
 
+inline static int openfile_ftruncate(int fd, OpenFile::FileOffset at) {
+#ifdef _WIN32
+  return !::_chsize(fd, at);
+#else
+  return ::ftruncate(fd, at);
+#endif
+}
+
 void OpenFile::Truncate(FileOffset at, IoErrorHandler &handler) {
   CheckOpen(handler);
   if (!knownSize_ || *knownSize_ != at) {
-    if (::ftruncate(fd_, at) != 0) {
+    if (openfile_ftruncate(fd_, at) != 0) {
       handler.SignalErrno();
     }
     knownSize_ = at;

From 0575b54cc79110ae03f73b136e704f6313e2d63f Mon Sep 17 00:00:00 2001
From: Isuru Fernando <isuruf@gmail.com>
Date: Thu, 12 Mar 2020 15:28:35 -0500
Subject: [PATCH 107/345] Support platforms without strerror_r

---
 runtime/CMakeLists.txt | 24 ++++++++++++++++++++++++
 runtime/config.h.cmake | 11 +++++++++++
 runtime/io-error.cpp   | 27 +++++++++++++++++++++++++++
 3 files changed, 62 insertions(+)
 create mode 100644 runtime/config.h.cmake

diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index ddd77f71fdbe..066cb7d12459 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -6,6 +6,26 @@
 #
 #===------------------------------------------------------------------------===#
 
+include(CheckCXXSymbolExists)
+include(CheckCXXSourceCompiles)
+check_cxx_symbol_exists(strerror string.h HAVE_STRERROR)
+check_cxx_symbol_exists(strerror_r string.h HAVE_STRERROR_R)
+# Can't use symbol exists here as the function is overloaded in C++
+check_cxx_source_compiles(
+  "#include <string.h>
+   int main() {
+     char buf[4096];
+     return strerror_s(buf, 4096, 0);
+   }
+  "
+  HAVE_DECL_STRERROR_S)
+
+if (NOT (HAVE_STRERROR OR HAVE_STRERROR_R OR HAVE_DECL_STRERROR_S))
+  message(FATAL_ERROR "None of strerror, strerror_r, strerror_s found.")
+endif()
+
+configure_file(config.h.cmake config.h)
+
 add_library(FortranRuntime
   ISO_Fortran_binding.cpp
   buffer.cpp
@@ -33,6 +53,10 @@ add_library(FortranRuntime
   unit-map.cpp
 )
 
+target_include_directories(FortranRuntime
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+)
+
 target_link_libraries(FortranRuntime
   FortranDecimal
 )
diff --git a/runtime/config.h.cmake b/runtime/config.h.cmake
new file mode 100644
index 000000000000..0a1d1394b9bc
--- /dev/null
+++ b/runtime/config.h.cmake
@@ -0,0 +1,11 @@
+#ifndef FORTRAN_RUNTIME_CONFIG_H
+#define FORTRAN_RUNTIME_CONFIG_H
+
+/* Define to 1 if you have the `strerror_r' function. */
+#cmakedefine01 HAVE_STRERROR_R
+
+/* Define to 1 if you have the declaration of `strerror_s', and to 0 if you
+   don't. */
+#cmakedefine01 HAVE_DECL_STRERROR_S
+
+#endif
diff --git a/runtime/io-error.cpp b/runtime/io-error.cpp
index 9300aa701f68..721ecf31fecc 100644
--- a/runtime/io-error.cpp
+++ b/runtime/io-error.cpp
@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "config.h"
 #include "io-error.h"
 #include "magic-numbers.h"
 #include "tools.h"
@@ -76,6 +77,32 @@ bool IoErrorHandler::GetIoMsg(char *buffer, std::size_t bufferLength) {
     ToFortranDefaultCharacter(buffer, bufferLength, msg);
     return true;
   }
+
+  char *newBuf;
+  // Following code is taken from llvm/lib/Support/Errno.cpp
+  // in LLVM v9.0.1
+#if HAVE_STRERROR_R
+  // strerror_r is thread-safe.
+#if defined(__GLIBC__) && defined(_GNU_SOURCE)
+  // glibc defines its own incompatible version of strerror_r
+  // which may not use the buffer supplied.
+  newBuf = ::strerror_r(ioStat_, buffer, bufferLength);
+#else
   return ::strerror_r(ioStat_, buffer, bufferLength) == 0;
+#endif
+#elif HAVE_DECL_STRERROR_S // "Windows Secure API"
+  return ::strerror_s(buffer, bufferLength, ioStat_) == 0;
+#elif HAVE_STRERROR
+  // Copy the thread un-safe result of strerror into
+  // the buffer as fast as possible to minimize impact
+  // of collision of strerror in multiple threads.
+  newBuf = strerror(ioStat_);
+#else
+  // Strange that this system doesn't even have strerror
+  return false;
+#endif
+  ::strncpy(buffer, newBuf, bufferLength - 1);
+  buffer[bufferLength-1] = '\n';
+  return true;
 }
 }

From 9fe84f45d7fd685051004678d6b5775dcc4c6f8f Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Sat, 28 Mar 2020 21:00:16 -0700
Subject: [PATCH 108/345] Reformat with latest clang-format and .clang-format

---
 include/flang/Common/Fortran-features.h       |    4 +-
 include/flang/Common/Fortran.h                |   18 +-
 include/flang/Common/bit-population-count.h   |   10 +-
 include/flang/Common/constexpr-bitset.h       |    6 +-
 include/flang/Common/default-kinds.h          |    6 +-
 include/flang/Common/enum-set.h               |   10 +-
 include/flang/Common/format.h                 |  296 ++--
 include/flang/Common/idioms.h                 |   34 +-
 include/flang/Common/indirection.h            |   18 +-
 include/flang/Common/interval.h               |    8 +-
 include/flang/Common/leading-zero-bit-count.h |   12 +-
 include/flang/Common/real.h                   |   54 +-
 include/flang/Common/reference-counted.h      |    8 +-
 include/flang/Common/reference.h              |   12 +-
 include/flang/Common/restorer.h               |   10 +-
 include/flang/Common/template.h               |   96 +-
 include/flang/Common/uint128.h                |   22 +-
 .../flang/Common/unsigned-const-division.h    |    8 +-
 include/flang/Common/unwrap.h                 |   32 +-
 include/flang/Decimal/binary-floating-point.h |   10 +-
 include/flang/Decimal/decimal.h               |   10 +-
 include/flang/Evaluate/call.h                 |   22 +-
 include/flang/Evaluate/characteristics.h      |   14 +-
 include/flang/Evaluate/check-expression.h     |    8 +-
 include/flang/Evaluate/common.h               |   65 +-
 include/flang/Evaluate/complex.h              |   10 +-
 include/flang/Evaluate/constant.h             |   24 +-
 include/flang/Evaluate/expression.h           |  187 +--
 include/flang/Evaluate/fold.h                 |   16 +-
 include/flang/Evaluate/formatting.h           |   15 +-
 include/flang/Evaluate/intrinsics-library.h   |   20 +-
 include/flang/Evaluate/intrinsics.h           |   12 +-
 include/flang/Evaluate/real.h                 |   51 +-
 include/flang/Evaluate/rounding-bits.h        |   31 +-
 include/flang/Evaluate/shape.h                |   23 +-
 include/flang/Evaluate/static-data.h          |    4 +-
 include/flang/Evaluate/traverse.h             |   56 +-
 include/flang/Evaluate/type.h                 |  112 +-
 include/flang/Evaluate/variable.h             |   48 +-
 include/flang/ISO_Fortran_binding.h           |   18 +-
 include/flang/Parser/char-block.h             |   10 +-
 include/flang/Parser/char-buffer.h            |    8 +-
 include/flang/Parser/char-set.h               |    4 +-
 include/flang/Parser/characters.h             |   82 +-
 include/flang/Parser/dump-parse-tree.h        |   64 +-
 include/flang/Parser/format-specification.h   |   32 +-
 include/flang/Parser/instrumented-parser.h    |   10 +-
 include/flang/Parser/message.h                |   58 +-
 include/flang/Parser/parse-state.h            |   45 +-
 include/flang/Parser/parse-tree-visitor.h     |  240 +--
 include/flang/Parser/parse-tree.h             |  365 +++--
 include/flang/Parser/parsing.h                |    8 +-
 include/flang/Parser/provenance.h             |   14 +-
 include/flang/Parser/source.h                 |   12 +-
 include/flang/Parser/tools.h                  |   18 +-
 include/flang/Parser/unparse.h                |    4 +-
 include/flang/Parser/user-state.h             |    8 +-
 include/flang/Semantics/attr.h                |    4 +-
 include/flang/Semantics/expression.h          |   80 +-
 include/flang/Semantics/scope.h               |   25 +-
 include/flang/Semantics/semantics.h           |   18 +-
 include/flang/Semantics/symbol.h              |  108 +-
 include/flang/Semantics/tools.h               |   46 +-
 include/flang/Semantics/type.h                |   47 +-
 .../flang/Semantics/unparse-with-symbols.h    |    2 +-
 lib/Common/Fortran-features.cpp               |   32 +-
 lib/Common/Fortran.cpp                        |   50 +-
 lib/Common/default-kinds.cpp                  |   18 +-
 lib/Common/idioms.cpp                         |    2 +-
 lib/Decimal/big-radix-floating-point.h        |   38 +-
 lib/Decimal/binary-to-decimal.cpp             |   50 +-
 lib/Decimal/decimal-to-binary.cpp             |   52 +-
 lib/Evaluate/call.cpp                         |   27 +-
 lib/Evaluate/character.h                      |    6 +-
 lib/Evaluate/characteristics.cpp              |   90 +-
 lib/Evaluate/check-expression.cpp             |   66 +-
 lib/Evaluate/common.cpp                       |    2 +-
 lib/Evaluate/complex.cpp                      |   16 +-
 lib/Evaluate/constant.cpp                     |   63 +-
 lib/Evaluate/expression.cpp                   |   40 +-
 lib/Evaluate/fold-character.cpp               |   12 +-
 lib/Evaluate/fold-complex.cpp                 |    6 +-
 lib/Evaluate/fold-implementation.h            |  142 +-
 lib/Evaluate/fold-integer.cpp                 |   30 +-
 lib/Evaluate/fold-logical.cpp                 |   35 +-
 lib/Evaluate/fold-real.cpp                    |    8 +-
 lib/Evaluate/fold.cpp                         |   35 +-
 lib/Evaluate/formatting.cpp                   |  197 +--
 lib/Evaluate/host.cpp                         |   34 +-
 lib/Evaluate/host.h                           |   78 +-
 lib/Evaluate/int-power.h                      |    8 +-
 lib/Evaluate/integer.cpp                      |    2 +-
 lib/Evaluate/intrinsics-library-templates.h   |   56 +-
 lib/Evaluate/intrinsics-library.cpp           |  138 +-
 lib/Evaluate/intrinsics.cpp                   |  136 +-
 lib/Evaluate/logical.cpp                      |    2 +-
 lib/Evaluate/real.cpp                         |   97 +-
 lib/Evaluate/shape.cpp                        |   16 +-
 lib/Evaluate/static-data.cpp                  |    2 +-
 lib/Evaluate/tools.cpp                        |   13 +-
 lib/Evaluate/type.cpp                         |   48 +-
 lib/Evaluate/variable.cpp                     |  189 ++-
 lib/Optimizer/Dialect/FIRAttr.cpp             |    4 +-
 lib/Optimizer/Dialect/FIRDialect.cpp          |    2 +-
 lib/Parser/Fortran-parsers.cpp                |    6 +-
 lib/Parser/basic-parsers.h                    |  144 +-
 lib/Parser/char-block.cpp                     |    2 +-
 lib/Parser/char-buffer.cpp                    |    2 +-
 lib/Parser/char-set.cpp                       |    2 +-
 lib/Parser/characters.cpp                     |   32 +-
 lib/Parser/debug-parser.cpp                   |    2 +-
 lib/Parser/debug-parser.h                     |    6 +-
 lib/Parser/executable-parsers.cpp             |    6 +-
 lib/Parser/expr-parsers.cpp                   |    8 +-
 lib/Parser/expr-parsers.h                     |   24 +-
 lib/Parser/instrumented-parser.cpp            |    4 +-
 lib/Parser/io-parsers.cpp                     |    8 +-
 lib/Parser/message.cpp                        |   17 +-
 lib/Parser/misc-parsers.h                     |   14 +-
 lib/Parser/openmp-parsers.cpp                 |    4 +-
 lib/Parser/parse-tree.cpp                     |   12 +-
 lib/Parser/parsing.cpp                        |    4 +-
 lib/Parser/preprocessor.cpp                   |  117 +-
 lib/Parser/preprocessor.h                     |    4 +-
 lib/Parser/prescan.cpp                        |   52 +-
 lib/Parser/prescan.h                          |   32 +-
 lib/Parser/program-parsers.cpp                |    6 +-
 lib/Parser/provenance.cpp                     |   80 +-
 lib/Parser/source.cpp                         |    2 +-
 lib/Parser/stmt-parser.h                      |   13 +-
 lib/Parser/token-parsers.h                    |   41 +-
 lib/Parser/token-sequence.cpp                 |    4 +-
 lib/Parser/token-sequence.h                   |   10 +-
 lib/Parser/tools.cpp                          |    2 +-
 lib/Parser/type-parser-implementation.h       |    2 +-
 lib/Parser/type-parsers.h                     |  184 +--
 lib/Parser/unparse.cpp                        | 1393 +++++++++--------
 lib/Parser/user-state.cpp                     |    2 +-
 lib/Semantics/assignment.h                    |    6 +-
 lib/Semantics/attr.cpp                        |   17 +-
 lib/Semantics/canonicalize-do.cpp             |   60 +-
 lib/Semantics/canonicalize-do.h               |    4 +-
 lib/Semantics/canonicalize-omp.cpp            |   12 +-
 lib/Semantics/canonicalize-omp.h              |    4 +-
 lib/Semantics/check-allocate.cpp              |   48 +-
 lib/Semantics/check-allocate.h                |    4 +-
 lib/Semantics/check-arithmeticif.cpp          |    2 +-
 lib/Semantics/check-arithmeticif.h            |    4 +-
 lib/Semantics/check-call.cpp                  |   36 +-
 lib/Semantics/check-call.h                    |    4 +-
 lib/Semantics/check-case.cpp                  |   39 +-
 lib/Semantics/check-coarray.cpp               |   20 +-
 lib/Semantics/check-coarray.h                 |    6 +-
 lib/Semantics/check-data.cpp                  |    6 +-
 lib/Semantics/check-data.h                    |    4 +-
 lib/Semantics/check-deallocate.cpp            |    6 +-
 lib/Semantics/check-deallocate.h              |    4 +-
 lib/Semantics/check-declarations.cpp          |  200 ++-
 lib/Semantics/check-declarations.h            |    2 +-
 lib/Semantics/check-do-forall.cpp             |  136 +-
 lib/Semantics/check-do-forall.h               |    4 +-
 lib/Semantics/check-if-stmt.cpp               |    2 +-
 lib/Semantics/check-if-stmt.h                 |    4 +-
 lib/Semantics/check-io.cpp                    |  350 +++--
 lib/Semantics/check-io.h                      |    6 +-
 lib/Semantics/check-namelist.cpp              |    6 +-
 lib/Semantics/check-namelist.h                |    4 +-
 lib/Semantics/check-nullify.cpp               |    6 +-
 lib/Semantics/check-nullify.h                 |    4 +-
 lib/Semantics/check-omp-structure.cpp         |    9 +-
 lib/Semantics/check-omp-structure.h           |   10 +-
 lib/Semantics/check-purity.cpp                |    2 +-
 lib/Semantics/check-purity.h                  |    4 +-
 lib/Semantics/check-return.cpp                |    2 +-
 lib/Semantics/check-return.h                  |    4 +-
 lib/Semantics/check-stop.cpp                  |    2 +-
 lib/Semantics/check-stop.h                    |    4 +-
 lib/Semantics/expression.cpp                  |  148 +-
 lib/Semantics/mod-file.cpp                    |  241 +--
 lib/Semantics/mod-file.h                      |    7 +-
 lib/Semantics/pointer-assignment.cpp          |   50 +-
 lib/Semantics/pointer-assignment.h            |    4 +-
 lib/Semantics/program-tree.cpp                |   28 +-
 lib/Semantics/program-tree.h                  |   21 +-
 lib/Semantics/resolve-labels.cpp              |   50 +-
 lib/Semantics/resolve-labels.h                |    4 +-
 lib/Semantics/resolve-names-utils.cpp         |  134 +-
 lib/Semantics/resolve-names-utils.h           |   12 +-
 lib/Semantics/resolve-names.cpp               |  208 ++-
 lib/Semantics/resolve-names.h                 |    4 +-
 lib/Semantics/rewrite-parse-tree.cpp          |   14 +-
 lib/Semantics/rewrite-parse-tree.h            |    4 +-
 lib/Semantics/scope.cpp                       |   15 +-
 lib/Semantics/symbol.cpp                      |   40 +-
 lib/Semantics/type.cpp                        |   57 +-
 lib/Semantics/unparse-with-symbols.cpp        |   18 +-
 runtime/ISO_Fortran_binding.cpp               |  120 +-
 runtime/allocatable.h                         |    4 +-
 runtime/buffer.cpp                            |    8 +-
 runtime/buffer.h                              |   24 +-
 runtime/c-or-cpp.h                            |    2 +-
 runtime/connection.cpp                        |    2 +-
 runtime/connection.h                          |   26 +-
 runtime/derived-type.cpp                      |    4 +-
 runtime/derived-type.h                        |   32 +-
 runtime/descriptor.cpp                        |    4 +-
 runtime/descriptor.h                          |   24 +-
 runtime/edit-input.cpp                        |   67 +-
 runtime/edit-input.h                          |    6 +-
 runtime/edit-output.cpp                       |  105 +-
 runtime/edit-output.h                         |   16 +-
 runtime/environment.cpp                       |    6 +-
 runtime/environment.h                         |    4 +-
 runtime/file.cpp                              |   13 +-
 runtime/file.h                                |    4 +-
 runtime/format-implementation.h               |   89 +-
 runtime/format.cpp                            |    2 +-
 runtime/format.h                              |   46 +-
 runtime/internal-unit.cpp                     |   22 +-
 runtime/internal-unit.h                       |    6 +-
 runtime/io-api.cpp                            |  193 ++-
 runtime/io-api.h                              |   12 +-
 runtime/io-error.cpp                          |   10 +-
 runtime/io-error.h                            |   22 +-
 runtime/io-stmt.cpp                           |  121 +-
 runtime/io-stmt.h                             |   76 +-
 runtime/iostat.cpp                            |   34 +-
 runtime/iostat.h                              |   10 +-
 runtime/lock.h                                |    5 +-
 runtime/main.cpp                              |    2 +-
 runtime/main.h                                |    2 +-
 runtime/memory.cpp                            |    2 +-
 runtime/memory.h                              |   24 +-
 runtime/stop.cpp                              |    2 +-
 runtime/stop.h                                |    2 +-
 runtime/terminator.cpp                        |    2 +-
 runtime/terminator.h                          |    6 +-
 runtime/tools.cpp                             |    2 +-
 runtime/tools.h                               |    4 +-
 runtime/transformational.cpp                  |   18 +-
 runtime/transformational.h                    |    2 +-
 runtime/type-code.cpp                         |   66 +-
 runtime/type-code.h                           |    4 +-
 runtime/unit-map.cpp                          |    6 +-
 runtime/unit-map.h                            |   16 +-
 runtime/unit.cpp                              |   16 +-
 runtime/unit.h                                |   10 +-
 tools/f18-parse-demo/f18-parse-demo.cpp       |   18 +-
 tools/f18-parse-demo/stub-evaluate.cpp        |    2 +-
 tools/f18/dump.cpp                            |    2 +-
 tools/f18/f18.cpp                             |   26 +-
 unittests/Decimal/thorough-test.cpp           |    2 +-
 unittests/Evaluate/ISO-Fortran-binding.cpp    |   24 +-
 unittests/Evaluate/folding.cpp                |   18 +-
 unittests/Evaluate/fp-testing.cpp             |   16 +-
 unittests/Evaluate/fp-testing.h               |    2 +-
 unittests/Evaluate/integer.cpp                |    2 +-
 unittests/Evaluate/intrinsics.cpp             |   24 +-
 unittests/Evaluate/logical.cpp                |    2 +-
 unittests/Evaluate/real.cpp                   |   34 +-
 unittests/Evaluate/testing.cpp                |    4 +-
 unittests/Evaluate/testing.h                  |    4 +-
 unittests/Evaluate/uint128.cpp                |    2 +-
 unittests/Runtime/hello.cpp                   |   32 +-
 unittests/Runtime/testing.h                   |    4 +-
 265 files changed, 5587 insertions(+), 4857 deletions(-)

diff --git a/include/flang/Common/Fortran-features.h b/include/flang/Common/Fortran-features.h
index dfce05c99cd5..823fa85ad12e 100644
--- a/include/flang/Common/Fortran-features.h
+++ b/include/flang/Common/Fortran-features.h
@@ -61,5 +61,5 @@ class LanguageFeatureControl {
   LanguageFeatures warn_;
   bool warnAll_{false};
 };
-}
-#endif  // FORTRAN_COMMON_FORTRAN_FEATURES_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_FORTRAN_FEATURES_H_
diff --git a/include/flang/Common/Fortran.h b/include/flang/Common/Fortran.h
index 20a507aed415..df6b27c8ce3b 100644
--- a/include/flang/Common/Fortran.h
+++ b/include/flang/Common/Fortran.h
@@ -52,21 +52,21 @@ ENUM_CLASS(IoSpecKind, Access, Action, Advance, Asynchronous, Blank, Decimal,
     Id, Iomsg, Iostat, Name, Named, Newunit, Nextrec, Nml, Number, Opened, Pad,
     Pending, Pos, Position, Read, Readwrite, Rec, Recl, Round, Sequential, Sign,
     Size, Status, Stream, Unformatted, Unit, Write,
-    Convert,  // nonstandard
-    Dispose,  // nonstandard
+    Convert, // nonstandard
+    Dispose, // nonstandard
 )
 
 // Floating-point rounding modes; these are packed into a byte to save
 // room in the runtime's format processing context structure.
 enum class RoundingMode : std::uint8_t {
-  TiesToEven,  // ROUND=NEAREST, RN - default IEEE rounding
-  ToZero,  // ROUND=ZERO, RZ - truncation
-  Down,  // ROUND=DOWN, RD
-  Up,  // ROUND=UP, RU
-  TiesAwayFromZero,  // ROUND=COMPATIBLE, RC - ties round away from zero
+  TiesToEven, // ROUND=NEAREST, RN - default IEEE rounding
+  ToZero, // ROUND=ZERO, RZ - truncation
+  Down, // ROUND=DOWN, RD
+  Up, // ROUND=UP, RU
+  TiesAwayFromZero, // ROUND=COMPATIBLE, RC - ties round away from zero
 };
 
 // Fortran arrays may have up to 15 dimensions (See Fortran 2018 section 5.4.6).
 static constexpr int maxRank{15};
-}
-#endif  // FORTRAN_COMMON_FORTRAN_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_FORTRAN_H_
diff --git a/include/flang/Common/bit-population-count.h b/include/flang/Common/bit-population-count.h
index af3a1f22fd30..83d767ce0eee 100644
--- a/include/flang/Common/bit-population-count.h
+++ b/include/flang/Common/bit-population-count.h
@@ -70,18 +70,18 @@ inline constexpr int BitPopulationCount(std::uint8_t x) {
   return (x & 0xf) + (x >> 4);
 }
 
-template<typename UINT> inline constexpr bool Parity(UINT x) {
+template <typename UINT> inline constexpr bool Parity(UINT x) {
   return BitPopulationCount(x) & 1;
 }
 
 // "Parity is for farmers." -- Seymour R. Cray
 
-template<typename UINT> inline constexpr int TrailingZeroBitCount(UINT x) {
+template <typename UINT> inline constexpr int TrailingZeroBitCount(UINT x) {
   if ((x & 1) != 0) {
-    return 0;  // fast path for odd values
+    return 0; // fast path for odd values
   } else {
     return BitPopulationCount(static_cast<UINT>(x ^ (x - 1))) - !!x;
   }
 }
-}
-#endif  // FORTRAN_COMMON_BIT_POPULATION_COUNT_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_BIT_POPULATION_COUNT_H_
diff --git a/include/flang/Common/constexpr-bitset.h b/include/flang/Common/constexpr-bitset.h
index eae11f57d1e1..f1f468268909 100644
--- a/include/flang/Common/constexpr-bitset.h
+++ b/include/flang/Common/constexpr-bitset.h
@@ -21,7 +21,7 @@
 
 namespace Fortran::common {
 
-template<int BITS> class BitSet {
+template <int BITS> class BitSet {
   static_assert(BITS > 0 && BITS <= 64);
   static constexpr bool partialWord{BITS != 32 && BITS != 64};
   using Word = std::conditional_t<(BITS > 32), std::uint64_t, std::uint32_t>;
@@ -143,5 +143,5 @@ template<int BITS> class BitSet {
 private:
   Word bits_{0};
 };
-}
-#endif  // FORTRAN_COMMON_CONSTEXPR_BITSET_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_CONSTEXPR_BITSET_H_
diff --git a/include/flang/Common/default-kinds.h b/include/flang/Common/default-kinds.h
index c3610b23745f..6c66b98e98a0 100644
--- a/include/flang/Common/default-kinds.h
+++ b/include/flang/Common/default-kinds.h
@@ -50,12 +50,12 @@ class IntrinsicTypeDefaultKinds {
   // comprise two default REAL components.
   int defaultIntegerKind_{4};
   int subscriptIntegerKind_{8};
-  int sizeIntegerKind_{4};  // SIZE(), UBOUND(), &c. default KIND=
+  int sizeIntegerKind_{4}; // SIZE(), UBOUND(), &c. default KIND=
   int defaultRealKind_{defaultIntegerKind_};
   int doublePrecisionKind_{2 * defaultRealKind_};
   int quadPrecisionKind_{2 * doublePrecisionKind_};
   int defaultCharacterKind_{1};
   int defaultLogicalKind_{defaultIntegerKind_};
 };
-}
-#endif  // FORTRAN_COMMON_DEFAULT_KINDS_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_DEFAULT_KINDS_H_
diff --git a/include/flang/Common/enum-set.h b/include/flang/Common/enum-set.h
index ca8bc0cbd838..185c48825621 100644
--- a/include/flang/Common/enum-set.h
+++ b/include/flang/Common/enum-set.h
@@ -26,7 +26,7 @@
 
 namespace Fortran::common {
 
-template<typename ENUM, std::size_t BITS> class EnumSet {
+template <typename ENUM, std::size_t BITS> class EnumSet {
   static_assert(BITS > 0);
 
 public:
@@ -191,7 +191,7 @@ template<typename ENUM, std::size_t BITS> class EnumSet {
     }
   }
 
-  template<typename FUNC> void IterateOverMembers(const FUNC &f) const {
+  template <typename FUNC> void IterateOverMembers(const FUNC &f) const {
     EnumSet copy{*this};
     while (auto least{copy.LeastElement()}) {
       f(*least);
@@ -212,13 +212,13 @@ template<typename ENUM, std::size_t BITS> class EnumSet {
 private:
   bitsetType bitset_{};
 };
-}
+} // namespace Fortran::common
 
-template<typename ENUM, std::size_t values>
+template <typename ENUM, std::size_t values>
 struct std::hash<Fortran::common::EnumSet<ENUM, values>> {
   std::size_t operator()(
       const Fortran::common::EnumSet<ENUM, values> &x) const {
     return std::hash(x.bitset());
   }
 };
-#endif  // FORTRAN_COMMON_ENUM_SET_H_
+#endif // FORTRAN_COMMON_ENUM_SET_H_
diff --git a/include/flang/Common/format.h b/include/flang/Common/format.h
index 4cb274c81cd5..99b8cbe41d7c 100644
--- a/include/flang/Common/format.h
+++ b/include/flang/Common/format.h
@@ -29,30 +29,30 @@
 namespace Fortran::common {
 
 struct FormatMessage {
-  const char *text;  // message text; may have one %s argument
-  const char *arg;  // optional %s argument value
-  int offset;  // offset to message marker
-  int length;  // length of message marker
-  bool isError;  // vs. warning
+  const char *text; // message text; may have one %s argument
+  const char *arg; // optional %s argument value
+  int offset; // offset to message marker
+  int length; // length of message marker
+  bool isError; // vs. warning
 };
 
 // This declaration is logically private to class FormatValidator.
 // It is placed here to work around a clang compilation problem.
 ENUM_CLASS(TokenKind, None, A, B, BN, BZ, D, DC, DP, DT, E, EN, ES, EX, F, G, I,
     L, O, P, RC, RD, RN, RP, RU, RZ, S, SP, SS, T, TL, TR, X, Z, Colon, Slash,
-    Backslash,  // nonstandard: inhibit newline on output
-    Dollar,  // nonstandard: inhibit newline on output on terminals
+    Backslash, // nonstandard: inhibit newline on output
+    Dollar, // nonstandard: inhibit newline on output on terminals
     Star, LParen, RParen, Comma, Point, Sign,
-    UnsignedInteger,  // value in integerValue_
-    String)  // char-literal-constant or Hollerith constant
+    UnsignedInteger, // value in integerValue_
+    String) // char-literal-constant or Hollerith constant
 
-template<typename CHAR = char> class FormatValidator {
+template <typename CHAR = char> class FormatValidator {
 public:
   using Reporter = std::function<bool(const FormatMessage &)>;
   FormatValidator(const CHAR *format, size_t length, Reporter reporter,
       IoStmtKind stmt = IoStmtKind::None)
-    : format_{format}, end_{format + length}, reporter_{reporter}, stmt_{stmt},
-      cursor_{format - 1} {
+      : format_{format}, end_{format + length}, reporter_{reporter},
+        stmt_{stmt}, cursor_{format - 1} {
     CHECK(format);
   }
 
@@ -128,54 +128,54 @@ template<typename CHAR = char> class FormatValidator {
   bool check_d();
   void check_e();
 
-  const CHAR *const format_;  // format text
-  const CHAR *const end_;  // one-past-last of format_ text
+  const CHAR *const format_; // format text
+  const CHAR *const end_; // one-past-last of format_ text
   Reporter reporter_;
   IoStmtKind stmt_;
 
-  const CHAR *cursor_{};  // current location in format_
-  const CHAR *laCursor_{};  // lookahead cursor
-  Token token_{};  // current token
-  int64_t integerValue_{-1};  // value of UnsignedInteger token
-  Token knrToken_{};  // k, n, or r UnsignedInteger token
-  int64_t knrValue_{-1};  // -1 ==> not present
+  const CHAR *cursor_{}; // current location in format_
+  const CHAR *laCursor_{}; // lookahead cursor
+  Token token_{}; // current token
+  int64_t integerValue_{-1}; // value of UnsignedInteger token
+  Token knrToken_{}; // k, n, or r UnsignedInteger token
+  int64_t knrValue_{-1}; // -1 ==> not present
   int64_t wValue_{-1};
   bool previousTokenWasInt_{false};
-  char argString_[3]{};  // 1-2 character msg arg; usually edit descriptor name
+  char argString_[3]{}; // 1-2 character msg arg; usually edit descriptor name
   bool formatHasErrors_{false};
   bool unterminatedFormatError_{false};
   bool suppressMessageCascade_{false};
   bool reporterExit_{false};
-  int maxNesting_{0};  // max level of nested parentheses
+  int maxNesting_{0}; // max level of nested parentheses
 };
 
-template<typename CHAR> CHAR FormatValidator<CHAR>::NextChar() {
+template <typename CHAR> CHAR FormatValidator<CHAR>::NextChar() {
   for (++cursor_; cursor_ < end_; ++cursor_) {
     if (*cursor_ != ' ') {
       return toupper(*cursor_);
     }
   }
-  cursor_ = end_;  // don't allow cursor_ > end_
+  cursor_ = end_; // don't allow cursor_ > end_
   return ' ';
 }
 
-template<typename CHAR> CHAR FormatValidator<CHAR>::LookAheadChar() {
+template <typename CHAR> CHAR FormatValidator<CHAR>::LookAheadChar() {
   for (laCursor_ = cursor_ + 1; laCursor_ < end_; ++laCursor_) {
     if (*laCursor_ != ' ') {
       return toupper(*laCursor_);
     }
   }
-  laCursor_ = end_;  // don't allow laCursor_ > end_
+  laCursor_ = end_; // don't allow laCursor_ > end_
   return ' ';
 }
 
 // After a call to LookAheadChar, set token kind and advance cursor to laCursor.
-template<typename CHAR> void FormatValidator<CHAR>::Advance(TokenKind tk) {
+template <typename CHAR> void FormatValidator<CHAR>::Advance(TokenKind tk) {
   cursor_ = laCursor_;
   token_.set_kind(tk);
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
+template <typename CHAR> void FormatValidator<CHAR>::NextToken() {
   // At entry, cursor_ points before the start of the next token.
   // At exit, cursor_ points to last CHAR of token_.
 
@@ -184,7 +184,7 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
   token_.set_kind(TokenKind::None);
   token_.set_offset(cursor_ - format_);
   token_.set_length(1);
-  if (c == '_' && integerValue_ >= 0) {  // C1305, C1309, C1310, C1312, C1313
+  if (c == '_' && integerValue_ >= 0) { // C1305, C1309, C1310, C1312, C1313
     ReportError("Kind parameter '_' character in format expression");
   }
   integerValue_ = -1;
@@ -232,7 +232,7 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
       cursor_ = end_;
     }
     SetLength();
-    if (stmt_ == IoStmtKind::Read) {  // 13.3.2p6
+    if (stmt_ == IoStmtKind::Read) { // 13.3.2p6
       ReportError("'H' edit descriptor in READ format expression");
     } else if (token_.kind() == TokenKind::None) {
       ReportError("Unterminated 'H' edit descriptor");
@@ -241,72 +241,154 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
     }
     break;
   }
-  case 'A': token_.set_kind(TokenKind::A); break;
+  case 'A':
+    token_.set_kind(TokenKind::A);
+    break;
   case 'B':
     switch (LookAheadChar()) {
-    case 'N': Advance(TokenKind::BN); break;
-    case 'Z': Advance(TokenKind::BZ); break;
-    default: token_.set_kind(TokenKind::B); break;
+    case 'N':
+      Advance(TokenKind::BN);
+      break;
+    case 'Z':
+      Advance(TokenKind::BZ);
+      break;
+    default:
+      token_.set_kind(TokenKind::B);
+      break;
     }
     break;
   case 'D':
     switch (LookAheadChar()) {
-    case 'C': Advance(TokenKind::DC); break;
-    case 'P': Advance(TokenKind::DP); break;
-    case 'T': Advance(TokenKind::DT); break;
-    default: token_.set_kind(TokenKind::D); break;
+    case 'C':
+      Advance(TokenKind::DC);
+      break;
+    case 'P':
+      Advance(TokenKind::DP);
+      break;
+    case 'T':
+      Advance(TokenKind::DT);
+      break;
+    default:
+      token_.set_kind(TokenKind::D);
+      break;
     }
     break;
   case 'E':
     switch (LookAheadChar()) {
-    case 'N': Advance(TokenKind::EN); break;
-    case 'S': Advance(TokenKind::ES); break;
-    case 'X': Advance(TokenKind::EX); break;
-    default: token_.set_kind(TokenKind::E); break;
+    case 'N':
+      Advance(TokenKind::EN);
+      break;
+    case 'S':
+      Advance(TokenKind::ES);
+      break;
+    case 'X':
+      Advance(TokenKind::EX);
+      break;
+    default:
+      token_.set_kind(TokenKind::E);
+      break;
     }
     break;
-  case 'F': token_.set_kind(TokenKind::F); break;
-  case 'G': token_.set_kind(TokenKind::G); break;
-  case 'I': token_.set_kind(TokenKind::I); break;
-  case 'L': token_.set_kind(TokenKind::L); break;
-  case 'O': token_.set_kind(TokenKind::O); break;
-  case 'P': token_.set_kind(TokenKind::P); break;
+  case 'F':
+    token_.set_kind(TokenKind::F);
+    break;
+  case 'G':
+    token_.set_kind(TokenKind::G);
+    break;
+  case 'I':
+    token_.set_kind(TokenKind::I);
+    break;
+  case 'L':
+    token_.set_kind(TokenKind::L);
+    break;
+  case 'O':
+    token_.set_kind(TokenKind::O);
+    break;
+  case 'P':
+    token_.set_kind(TokenKind::P);
+    break;
   case 'R':
     switch (LookAheadChar()) {
-    case 'C': Advance(TokenKind::RC); break;
-    case 'D': Advance(TokenKind::RD); break;
-    case 'N': Advance(TokenKind::RN); break;
-    case 'P': Advance(TokenKind::RP); break;
-    case 'U': Advance(TokenKind::RU); break;
-    case 'Z': Advance(TokenKind::RZ); break;
-    default: token_.set_kind(TokenKind::None); break;
+    case 'C':
+      Advance(TokenKind::RC);
+      break;
+    case 'D':
+      Advance(TokenKind::RD);
+      break;
+    case 'N':
+      Advance(TokenKind::RN);
+      break;
+    case 'P':
+      Advance(TokenKind::RP);
+      break;
+    case 'U':
+      Advance(TokenKind::RU);
+      break;
+    case 'Z':
+      Advance(TokenKind::RZ);
+      break;
+    default:
+      token_.set_kind(TokenKind::None);
+      break;
     }
     break;
   case 'S':
     switch (LookAheadChar()) {
-    case 'P': Advance(TokenKind::SP); break;
-    case 'S': Advance(TokenKind::SS); break;
-    default: token_.set_kind(TokenKind::S); break;
+    case 'P':
+      Advance(TokenKind::SP);
+      break;
+    case 'S':
+      Advance(TokenKind::SS);
+      break;
+    default:
+      token_.set_kind(TokenKind::S);
+      break;
     }
     break;
   case 'T':
     switch (LookAheadChar()) {
-    case 'L': Advance(TokenKind::TL); break;
-    case 'R': Advance(TokenKind::TR); break;
-    default: token_.set_kind(TokenKind::T); break;
+    case 'L':
+      Advance(TokenKind::TL);
+      break;
+    case 'R':
+      Advance(TokenKind::TR);
+      break;
+    default:
+      token_.set_kind(TokenKind::T);
+      break;
     }
     break;
-  case 'X': token_.set_kind(TokenKind::X); break;
-  case 'Z': token_.set_kind(TokenKind::Z); break;
+  case 'X':
+    token_.set_kind(TokenKind::X);
+    break;
+  case 'Z':
+    token_.set_kind(TokenKind::Z);
+    break;
   case '-':
-  case '+': token_.set_kind(TokenKind::Sign); break;
-  case '/': token_.set_kind(TokenKind::Slash); break;
-  case '(': token_.set_kind(TokenKind::LParen); break;
-  case ')': token_.set_kind(TokenKind::RParen); break;
-  case '.': token_.set_kind(TokenKind::Point); break;
-  case ':': token_.set_kind(TokenKind::Colon); break;
-  case '\\': token_.set_kind(TokenKind::Backslash); break;
-  case '$': token_.set_kind(TokenKind::Dollar); break;
+  case '+':
+    token_.set_kind(TokenKind::Sign);
+    break;
+  case '/':
+    token_.set_kind(TokenKind::Slash);
+    break;
+  case '(':
+    token_.set_kind(TokenKind::LParen);
+    break;
+  case ')':
+    token_.set_kind(TokenKind::RParen);
+    break;
+  case '.':
+    token_.set_kind(TokenKind::Point);
+    break;
+  case ':':
+    token_.set_kind(TokenKind::Colon);
+    break;
+  case '\\':
+    token_.set_kind(TokenKind::Backslash);
+    break;
+  case '$':
+    token_.set_kind(TokenKind::Dollar);
+    break;
   case '*':
     token_.set_kind(LookAheadChar() == '(' ? TokenKind::Star : TokenKind::None);
     break;
@@ -334,7 +416,7 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
       }
     }
     SetLength();
-    if (stmt_ == IoStmtKind::Read) {  // 13.3.2p6
+    if (stmt_ == IoStmtKind::Read) { // 13.3.2p6
       ReportError("String edit descriptor in READ format expression");
     } else if (token_.kind() != TokenKind::String) {
       ReportError("Unterminated string");
@@ -353,34 +435,34 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
   SetLength();
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::check_r(bool allowed) {
+template <typename CHAR> void FormatValidator<CHAR>::check_r(bool allowed) {
   if (!allowed && knrValue_ >= 0) {
     ReportError("Repeat specifier before '%s' edit descriptor", knrToken_);
   } else if (knrValue_ == 0) {
     ReportError("'%s' edit descriptor repeat specifier must be positive",
-        knrToken_);  // C1304
+        knrToken_); // C1304
   }
 }
 
 // Return the predicate "w value is present" to control further processing.
-template<typename CHAR> bool FormatValidator<CHAR>::check_w() {
+template <typename CHAR> bool FormatValidator<CHAR>::check_w() {
   if (token_.kind() == TokenKind::UnsignedInteger) {
     wValue_ = integerValue_;
     if (wValue_ == 0 &&
         (*argString_ == 'A' || *argString_ == 'L' ||
-            stmt_ == IoStmtKind::Read)) {  // C1306, 13.7.2.1p6
+            stmt_ == IoStmtKind::Read)) { // C1306, 13.7.2.1p6
       ReportError("'%s' edit descriptor 'w' value must be positive");
     }
     NextToken();
     return true;
   }
   if (*argString_ != 'A') {
-    ReportWarning("Expected '%s' edit descriptor 'w' value");  // C1306
+    ReportWarning("Expected '%s' edit descriptor 'w' value"); // C1306
   }
   return false;
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::check_m() {
+template <typename CHAR> void FormatValidator<CHAR>::check_m() {
   if (token_.kind() != TokenKind::Point) {
     return;
   }
@@ -390,14 +472,14 @@ template<typename CHAR> void FormatValidator<CHAR>::check_m() {
     return;
   }
   if ((stmt_ == IoStmtKind::Print || stmt_ == IoStmtKind::Write) &&
-      wValue_ > 0 && integerValue_ > wValue_) {  // 13.7.2.2p5, 13.7.2.4p6
+      wValue_ > 0 && integerValue_ > wValue_) { // 13.7.2.2p5, 13.7.2.4p6
     ReportError("'%s' edit descriptor 'm' value is greater than 'w' value");
   }
   NextToken();
 }
 
 // Return the predicate "d value is present" to control further processing.
-template<typename CHAR> bool FormatValidator<CHAR>::check_d() {
+template <typename CHAR> bool FormatValidator<CHAR>::check_d() {
   if (token_.kind() != TokenKind::Point) {
     ReportError("Expected '%s' edit descriptor '.d' value");
     return false;
@@ -411,7 +493,7 @@ template<typename CHAR> bool FormatValidator<CHAR>::check_d() {
   return true;
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::check_e() {
+template <typename CHAR> void FormatValidator<CHAR>::check_e() {
   if (token_.kind() != TokenKind::E) {
     return;
   }
@@ -423,7 +505,7 @@ template<typename CHAR> void FormatValidator<CHAR>::check_e() {
   NextToken();
 }
 
-template<typename CHAR> bool FormatValidator<CHAR>::Check() {
+template <typename CHAR> bool FormatValidator<CHAR>::Check() {
   if (!*format_) {
     ReportError("Empty format expression");
     return formatHasErrors_;
@@ -435,8 +517,8 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
   }
   NextToken();
 
-  int nestLevel{0};  // Outer level ()s are at level 0.
-  Token starToken{};  // unlimited format token
+  int nestLevel{0}; // Outer level ()s are at level 0.
+  Token starToken{}; // unlimited format token
   bool hasDataEditDesc{false};
 
   // Subject to error recovery exceptions, a loop iteration processes one
@@ -446,7 +528,7 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
   //  - the error reporter requests termination (error threshold reached)
   while (!reporterExit_) {
     Token signToken{};
-    knrValue_ = -1;  // -1 ==> not present
+    knrValue_ = -1; // -1 ==> not present
     wValue_ = -1;
     bool commaRequired{true};
 
@@ -519,12 +601,12 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       NextToken();
       if (check_w()) {
         if (wValue_ > 0) {
-          if (check_d()) {  // C1307
+          if (check_d()) { // C1307
             check_e();
           }
         } else if (token_.kind() == TokenKind::Point && check_d() &&
             token_.kind() == TokenKind::E) {
-          ReportError("Unexpected 'e' in 'G0' edit descriptor");  // C1308
+          ReportError("Unexpected 'e' in 'G0' edit descriptor"); // C1308
           NextToken();
           if (token_.kind() == TokenKind::UnsignedInteger) {
             NextToken();
@@ -616,7 +698,9 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       case TokenKind::ES:
       case TokenKind::EX:
       case TokenKind::F:
-      case TokenKind::G: commaRequired = false; break;
+      case TokenKind::G:
+        commaRequired = false;
+        break;
       default:;
       }
       cursor_ = saveCursor;
@@ -629,14 +713,14 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       // R1315 position-edit-desc -> T n | TL n | TR n
       check_r(false);
       NextToken();
-      if (integerValue_ <= 0) {  // C1311
+      if (integerValue_ <= 0) { // C1311
         ReportError("'%s' edit descriptor must have a positive position value");
       }
       NextToken();
       break;
     case TokenKind::X:
       // R1315 position-edit-desc -> n X
-      if (knrValue_ == 0) {  // C1311
+      if (knrValue_ == 0) { // C1311
         ReportError("'X' edit descriptor must have a positive position value",
             knrToken_);
       } else if (knrValue_ < 0) {
@@ -695,11 +779,11 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       do {
         if (nestLevel == 0) {
           // Any characters after level-0 ) are ignored.
-          return formatHasErrors_;  // normal exit (may have messages)
+          return formatHasErrors_; // normal exit (may have messages)
         }
         if (nestLevel == 1 && starToken.IsSet() && !hasDataEditDesc) {
           SetLength(starToken);
-          ReportError(  // C1303
+          ReportError( // C1303
               "Unlimited format item list must contain a data edit descriptor",
               starToken);
         }
@@ -718,31 +802,33 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
         break;
       }
       [[fallthrough]];
-    default: ReportError("Unexpected '%s' in format expression"); NextToken();
+    default:
+      ReportError("Unexpected '%s' in format expression");
+      NextToken();
     }
 
     // Process comma separator and exit an incomplete format.
     switch (token_.kind()) {
-    case TokenKind::Colon:  // Comma not required; token not yet processed.
-    case TokenKind::Slash:  // Comma not required; token not yet processed.
-    case TokenKind::RParen:  // Comma not allowed; token not yet processed.
+    case TokenKind::Colon: // Comma not required; token not yet processed.
+    case TokenKind::Slash: // Comma not required; token not yet processed.
+    case TokenKind::RParen: // Comma not allowed; token not yet processed.
       suppressMessageCascade_ = false;
       break;
-    case TokenKind::LParen:  // Comma not allowed; token already processed.
-    case TokenKind::Comma:  // Normal comma case; move past token.
+    case TokenKind::LParen: // Comma not allowed; token already processed.
+    case TokenKind::Comma: // Normal comma case; move past token.
       suppressMessageCascade_ = false;
       NextToken();
       break;
-    case TokenKind::Sign:  // Error; main switch has a better message.
-    case TokenKind::None:  // Error; token not yet processed.
+    case TokenKind::Sign: // Error; main switch has a better message.
+    case TokenKind::None: // Error; token not yet processed.
       if (cursor_ >= end_) {
-        return formatHasErrors_;  // incomplete format error exit
+        return formatHasErrors_; // incomplete format error exit
       }
       break;
     default:
       // Possible first token of the next format item; token not yet processed.
       if (commaRequired) {
-        const char *s{"Expected ',' or ')' in format expression"};  // C1302
+        const char *s{"Expected ',' or ')' in format expression"}; // C1302
         if (previousTokenWasInt_ && itemsWithLeadingInts_.test(token_.kind())) {
           ReportError(s);
         } else {
@@ -752,8 +838,8 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
     }
   }
 
-  return formatHasErrors_;  // error reporter (message threshold) exit
+  return formatHasErrors_; // error reporter (message threshold) exit
 }
 
-}
-#endif  // FORTRAN_COMMON_FORMAT_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_FORMAT_H_
diff --git a/include/flang/Common/idioms.h b/include/flang/Common/idioms.h
index 84862f4976da..3f4f8f2eec6b 100644
--- a/include/flang/Common/idioms.h
+++ b/include/flang/Common/idioms.h
@@ -34,11 +34,11 @@
 #if __GNUC__ == 7
 // Avoid a deduction bug in GNU 7.x headers by forcing the answer.
 namespace std {
-template<typename A>
+template <typename A>
 struct is_trivially_copy_constructible<list<A>> : false_type {};
-template<typename A>
+template <typename A>
 struct is_trivially_copy_constructible<optional<list<A>>> : false_type {};
-}
+} // namespace std
 #endif
 
 // enable "this is a std::string"s with the 's' suffix
@@ -54,11 +54,11 @@ namespace Fortran::common {
 //         ...
 //         [&](const auto &catchAll) { ... }}, variantObject);
 
-template<typename... LAMBDAS> struct visitors : LAMBDAS... {
+template <typename... LAMBDAS> struct visitors : LAMBDAS... {
   using LAMBDAS::operator()...;
 };
 
-template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
+template <typename... LAMBDAS> visitors(LAMBDAS... x) -> visitors<LAMBDAS...>;
 
 // Calls std::fprintf(stderr, ...), then abort().
 [[noreturn]] void die(const char *, ...);
@@ -93,11 +93,11 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
 // in template specialization definitions.
 #define CLASS_TRAIT(T) \
   namespace class_trait_ns_##T { \
-    template<typename A> std::true_type test(typename A::T *); \
-    template<typename A> std::false_type test(...); \
-    template<typename A> \
+    template <typename A> std::true_type test(typename A::T *); \
+    template <typename A> std::false_type test(...); \
+    template <typename A> \
     constexpr bool has_trait{decltype(test<A>(nullptr))::value}; \
-    template<typename A> constexpr bool trait_value() { \
+    template <typename A> constexpr bool trait_value() { \
       if constexpr (has_trait<A>) { \
         using U = typename A::T; \
         return U::value; \
@@ -106,7 +106,7 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
       } \
     } \
   } \
-  template<typename A> constexpr bool T{class_trait_ns_##T::trait_value<A>()};
+  template <typename A> constexpr bool T{class_trait_ns_##T::trait_value<A>()};
 
 #if !defined ATTRIBUTE_UNUSED && (__clang__ || __GNUC__)
 #define ATTRIBUTE_UNUSED __attribute__((unused))
@@ -119,7 +119,7 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
 
 std::string EnumIndexToString(int index, const char *names);
 
-template<typename A> struct ListItemCount {
+template <typename A> struct ListItemCount {
   constexpr ListItemCount(std::initializer_list<A> list) : value{list.size()} {}
   const std::size_t value;
 };
@@ -138,7 +138,7 @@ template<typename A> struct ListItemCount {
 // Check that a pointer is non-null and dereference it
 #define DEREF(p) Fortran::common::Deref(p, __FILE__, __LINE__)
 
-template<typename T> constexpr T &Deref(T *p, const char *file, int line) {
+template <typename T> constexpr T &Deref(T *p, const char *file, int line) {
   if (!p) {
     Fortran::common::die("nullptr dereference at %s(%d)", file, line);
   }
@@ -146,7 +146,7 @@ template<typename T> constexpr T &Deref(T *p, const char *file, int line) {
 }
 
 // Given a const reference to a value, return a copy of the value.
-template<typename A> A Clone(const A &x) { return x; }
+template <typename A> A Clone(const A &x) { return x; }
 
 // C++ does a weird and dangerous thing when deducing template type parameters
 // from function arguments: lvalue references are allowed to match rvalue
@@ -159,8 +159,8 @@ template<typename A> A Clone(const A &x) { return x; }
 // or, for constructors,
 //   template<typename A, typename = common::NoLvalue<A>> int foo(A &&);
 // This works with parameter packs too.
-template<typename A, typename... B>
+template <typename A, typename... B>
 using IfNoLvalue = std::enable_if_t<(... && !std::is_lvalue_reference_v<B>), A>;
-template<typename... RVREF> using NoLvalue = IfNoLvalue<void, RVREF...>;
-}
-#endif  // FORTRAN_COMMON_IDIOMS_H_
+template <typename... RVREF> using NoLvalue = IfNoLvalue<void, RVREF...>;
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_IDIOMS_H_
diff --git a/include/flang/Common/indirection.h b/include/flang/Common/indirection.h
index a79fc19a388f..f34d561ae049 100644
--- a/include/flang/Common/indirection.h
+++ b/include/flang/Common/indirection.h
@@ -28,7 +28,7 @@
 namespace Fortran::common {
 
 // The default case does not support (deep) copy construction or assignment.
-template<typename A, bool COPY = false> class Indirection {
+template <typename A, bool COPY = false> class Indirection {
 public:
   using element_type = A;
   Indirection() = delete;
@@ -59,7 +59,7 @@ template<typename A, bool COPY = false> class Indirection {
   bool operator==(const A &that) const { return *p_ == that; }
   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
-  template<typename... ARGS>
+  template <typename... ARGS>
   static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
     return {new A(std::move(args)...)};
   }
@@ -69,7 +69,7 @@ template<typename A, bool COPY = false> class Indirection {
 };
 
 // Variant with copy construction and assignment
-template<typename A> class Indirection<A, true> {
+template <typename A> class Indirection<A, true> {
 public:
   using element_type = A;
 
@@ -111,7 +111,7 @@ template<typename A> class Indirection<A, true> {
   bool operator==(const A &that) const { return *p_ == that; }
   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
-  template<typename... ARGS>
+  template <typename... ARGS>
   static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
     return {new A(std::move(args)...)};
   }
@@ -120,7 +120,7 @@ template<typename A> class Indirection<A, true> {
   A *p_{nullptr};
 };
 
-template<typename A> using CopyableIndirection = Indirection<A, true>;
+template <typename A> using CopyableIndirection = Indirection<A, true>;
 
 // For use with std::unique_ptr<> when declaring owning pointers to
 // forward-referenced types, here's a minimal custom deleter that avoids
@@ -129,13 +129,13 @@ template<typename A> using CopyableIndirection = Indirection<A, true>;
 // type is visible.  Be advised, std::unique_ptr<> does not have copy
 // semantics; if you need ownership, copy semantics, and nullability,
 // std::optional<CopyableIndirection<>> works.
-template<typename A> class Deleter {
+template <typename A> class Deleter {
 public:
   void operator()(A *) const;
 };
-}
+} // namespace Fortran::common
 #define DEFINE_DELETER(A) \
-  template<> void Fortran::common::Deleter<A>::operator()(A *p) const { \
+  template <> void Fortran::common::Deleter<A>::operator()(A *p) const { \
     delete p; \
   }
-#endif  // FORTRAN_COMMON_INDIRECTION_H_
+#endif // FORTRAN_COMMON_INDIRECTION_H_
diff --git a/include/flang/Common/interval.h b/include/flang/Common/interval.h
index c1d1cfb890c8..baaa35b9efc5 100644
--- a/include/flang/Common/interval.h
+++ b/include/flang/Common/interval.h
@@ -19,13 +19,13 @@
 
 namespace Fortran::common {
 
-template<typename A> class Interval {
+template <typename A> class Interval {
 public:
   using type = A;
   constexpr Interval() {}
   constexpr Interval(const A &s, std::size_t n = 1) : start_{s}, size_{n} {}
   constexpr Interval(A &&s, std::size_t n = 1)
-    : start_{std::move(s)}, size_{n} {}
+      : start_{std::move(s)}, size_{n} {}
   constexpr Interval(const Interval &) = default;
   constexpr Interval(Interval &&) = default;
   constexpr Interval &operator=(const Interval &) = default;
@@ -111,5 +111,5 @@ template<typename A> class Interval {
   A start_;
   std::size_t size_{0};
 };
-}
-#endif  // FORTRAN_COMMON_INTERVAL_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_INTERVAL_H_
diff --git a/include/flang/Common/leading-zero-bit-count.h b/include/flang/Common/leading-zero-bit-count.h
index 48fc3f129059..a296e0b44691 100644
--- a/include/flang/Common/leading-zero-bit-count.h
+++ b/include/flang/Common/leading-zero-bit-count.h
@@ -40,7 +40,7 @@ static constexpr std::uint8_t mapping[64]{63, 0, 58, 1, 59, 47, 53, 2, 60, 39,
     48, 27, 54, 33, 42, 3, 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43,
     14, 22, 4, 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
     56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5};
-}
+} // namespace
 
 inline constexpr int LeadingZeroBitCount(std::uint64_t x) {
   if (x == 0) {
@@ -53,13 +53,13 @@ inline constexpr int LeadingZeroBitCount(std::uint64_t x) {
     x |= x >> 16;
     x |= x >> 32;
     // All of the bits below the uppermost set bit are now also set.
-    x -= x >> 1;  // All of the bits below the uppermost are now clear.
+    x -= x >> 1; // All of the bits below the uppermost are now clear.
     // x now has exactly one bit set, so it is a power of two, so
     // multiplication by x is equivalent to a left shift by its
     // base-2 logarithm.  We calculate that unknown base-2 logarithm
     // by shifting the deBruijn sequence and mapping the framed value.
     int base2Log{mapping[(x * deBruijn) >> 58]};
-    return 63 - base2Log;  // convert to leading zero count
+    return 63 - base2Log; // convert to leading zero count
   }
 }
 
@@ -89,8 +89,8 @@ inline constexpr int LeadingZeroBitCount(std::uint8_t x) {
   return eightBitLeadingZeroBitCount[x];
 }
 
-template<typename A> inline constexpr int BitsNeededFor(A x) {
+template <typename A> inline constexpr int BitsNeededFor(A x) {
   return 8 * sizeof x - LeadingZeroBitCount(x);
 }
-}
-#endif  // FORTRAN_COMMON_LEADING_ZERO_BIT_COUNT_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_LEADING_ZERO_BIT_COUNT_H_
diff --git a/include/flang/Common/real.h b/include/flang/Common/real.h
index 4688e440a82d..eec29f1ca7b3 100644
--- a/include/flang/Common/real.h
+++ b/include/flang/Common/real.h
@@ -20,14 +20,22 @@ namespace Fortran::common {
 // Total representation size in bits for each type
 static constexpr int BitsForBinaryPrecision(int binaryPrecision) {
   switch (binaryPrecision) {
-  case 8: return 16;  // IEEE single (truncated): 1+8+7
-  case 11: return 16;  // IEEE half precision: 1+5+10
-  case 24: return 32;  // IEEE single precision: 1+8+23
-  case 53: return 64;  // IEEE double precision: 1+11+52
-  case 64: return 80;  // x87 extended precision: 1+15+64
-  case 106: return 128;  // "double-double": 2*(1+11+52)
-  case 113: return 128;  // IEEE quad precision: 1+15+112
-  default: return -1;
+  case 8:
+    return 16; // IEEE single (truncated): 1+8+7
+  case 11:
+    return 16; // IEEE half precision: 1+5+10
+  case 24:
+    return 32; // IEEE single precision: 1+8+23
+  case 53:
+    return 64; // IEEE double precision: 1+11+52
+  case 64:
+    return 80; // x87 extended precision: 1+15+64
+  case 106:
+    return 128; // "double-double": 2*(1+11+52)
+  case 113:
+    return 128; // IEEE quad precision: 1+15+112
+  default:
+    return -1;
   }
 }
 
@@ -37,18 +45,26 @@ static constexpr int BitsForBinaryPrecision(int binaryPrecision) {
 // exactly with FORMAT(E0.22981).
 static constexpr int MaxDecimalConversionDigits(int binaryPrecision) {
   switch (binaryPrecision) {
-  case 8: return 93;
-  case 11: return 17;
-  case 24: return 105;
-  case 53: return 751;
-  case 64: return 11495;
-  case 106: return 2 * 751;
-  case 113: return 11530;
-  default: return -1;
+  case 8:
+    return 93;
+  case 11:
+    return 17;
+  case 24:
+    return 105;
+  case 53:
+    return 751;
+  case 64:
+    return 11495;
+  case 106:
+    return 2 * 751;
+  case 113:
+    return 11530;
+  default:
+    return -1;
   }
 }
 
-template<int BINARY_PRECISION> class RealDetails {
+template <int BINARY_PRECISION> class RealDetails {
 private:
   // Converts bit widths to whole decimal digits
   static constexpr int LogBaseTwoToLogBaseTen(int logb2) {
@@ -82,5 +98,5 @@ template<int BINARY_PRECISION> class RealDetails {
   static_assert(exponentBits <= 15);
 };
 
-}
-#endif  // FORTRAN_COMMON_REAL_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_REAL_H_
diff --git a/include/flang/Common/reference-counted.h b/include/flang/Common/reference-counted.h
index 2a96741bb8f7..6aae6cface46 100644
--- a/include/flang/Common/reference-counted.h
+++ b/include/flang/Common/reference-counted.h
@@ -16,7 +16,7 @@
 namespace Fortran::common {
 
 // A base class for reference-counted objects.  Must be public.
-template<typename A> class ReferenceCounted {
+template <typename A> class ReferenceCounted {
 public:
   ReferenceCounted() {}
   void TakeReference() { ++references_; }
@@ -31,7 +31,7 @@ template<typename A> class ReferenceCounted {
 };
 
 // A reference to a reference-counted object.
-template<typename A> class CountedReference {
+template <typename A> class CountedReference {
 public:
   using type = A;
   CountedReference() {}
@@ -72,5 +72,5 @@ template<typename A> class CountedReference {
 
   type *p_{nullptr};
 };
-}
-#endif  // FORTRAN_COMMON_REFERENCE_COUNTED_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_REFERENCE_COUNTED_H_
diff --git a/include/flang/Common/reference.h b/include/flang/Common/reference.h
index f204b8f8b352..0c579de44bd7 100644
--- a/include/flang/Common/reference.h
+++ b/include/flang/Common/reference.h
@@ -15,7 +15,7 @@
 #define FORTRAN_COMMON_REFERENCE_H_
 #include <type_traits>
 namespace Fortran::common {
-template<typename A> class Reference {
+template <typename A> class Reference {
 public:
   using type = A;
   Reference(type &x) : p_{&x} {}
@@ -35,8 +35,8 @@ template<typename A> class Reference {
   // creation of a temporary copy in cases like:
   //   Reference<type> ref;
   //   const Type &x{ref};  // creates ref to temp copy!
-  operator std::conditional_t<std::is_const_v<type>, type &, void>() const
-      noexcept {
+  operator std::conditional_t<std::is_const_v<type>, type &, void>()
+      const noexcept {
     if constexpr (std::is_const_v<type>) {
       return *p_;
     }
@@ -56,8 +56,8 @@ template<typename A> class Reference {
   bool operator!=(const Reference &that) const { return !(*this == that); }
 
 private:
-  type *p_;  // never null
+  type *p_; // never null
 };
-template<typename A> Reference(A &)->Reference<A>;
-}
+template <typename A> Reference(A &) -> Reference<A>;
+} // namespace Fortran::common
 #endif
diff --git a/include/flang/Common/restorer.h b/include/flang/Common/restorer.h
index 26ddcfca0820..47e54237fe43 100644
--- a/include/flang/Common/restorer.h
+++ b/include/flang/Common/restorer.h
@@ -20,7 +20,7 @@
 #define FORTRAN_COMMON_RESTORER_H_
 #include "idioms.h"
 namespace Fortran::common {
-template<typename A> class Restorer {
+template <typename A> class Restorer {
 public:
   explicit Restorer(A &p) : p_{p}, original_{std::move(p)} {}
   ~Restorer() { p_ = std::move(original_); }
@@ -30,17 +30,17 @@ template<typename A> class Restorer {
   A original_;
 };
 
-template<typename A, typename B>
+template <typename A, typename B>
 common::IfNoLvalue<Restorer<A>, B> ScopedSet(A &to, B &&from) {
   Restorer<A> result{to};
   to = std::move(from);
   return result;
 }
-template<typename A, typename B>
+template <typename A, typename B>
 common::IfNoLvalue<Restorer<A>, B> ScopedSet(A &to, const B &from) {
   Restorer<A> result{to};
   to = from;
   return result;
 }
-}
-#endif  // FORTRAN_COMMON_RESTORER_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_RESTORER_H_
diff --git a/include/flang/Common/template.h b/include/flang/Common/template.h
index 2f726fe6cc39..866292cfcf48 100644
--- a/include/flang/Common/template.h
+++ b/include/flang/Common/template.h
@@ -26,7 +26,7 @@ namespace Fortran::common {
 // index of the first type T in the list for which PREDICATE<T>::value() is
 // true is returned, or -1 if the predicate is false for every type in the list.
 // This is a compile-time operation; see SearchTypes below for a run-time form.
-template<int N, template<typename> class PREDICATE, typename TUPLE>
+template <int N, template <typename> class PREDICATE, typename TUPLE>
 struct SearchTypeListHelper {
   static constexpr int value() {
     if constexpr (N >= std::tuple_size_v<TUPLE>) {
@@ -39,41 +39,41 @@ struct SearchTypeListHelper {
   }
 };
 
-template<template<typename> class PREDICATE, typename... TYPES>
+template <template <typename> class PREDICATE, typename... TYPES>
 constexpr int SearchTypeList{
     SearchTypeListHelper<0, PREDICATE, std::tuple<TYPES...>>::value()};
 
 // TypeIndex<A, TYPES...> scans a list of types for simple type equality.
 // The zero-based index of A in the list is returned, or -1 if A is not present.
-template<typename A> struct MatchType {
-  template<typename B> struct Match {
+template <typename A> struct MatchType {
+  template <typename B> struct Match {
     static constexpr bool value() {
       return std::is_same_v<std::decay_t<A>, std::decay_t<B>>;
     }
   };
 };
 
-template<typename A, typename... TYPES>
+template <typename A, typename... TYPES>
 constexpr int TypeIndex{SearchTypeList<MatchType<A>::template Match, TYPES...>};
 
 // IsTypeInList<A, TYPES...> is a simple presence predicate.
-template<typename A, typename... TYPES>
+template <typename A, typename... TYPES>
 constexpr bool IsTypeInList{TypeIndex<A, TYPES...> >= 0};
 
 // OverMembers extracts the list of types that constitute the alternatives
 // of a std::variant or elements of a std::tuple and passes that list as
 // parameter types to a given variadic template.
-template<template<typename...> class, typename> struct OverMembersHelper;
-template<template<typename...> class T, typename... Ts>
+template <template <typename...> class, typename> struct OverMembersHelper;
+template <template <typename...> class T, typename... Ts>
 struct OverMembersHelper<T, std::variant<Ts...>> {
   using type = T<Ts...>;
 };
-template<template<typename...> class T, typename... Ts>
+template <template <typename...> class T, typename... Ts>
 struct OverMembersHelper<T, std::tuple<Ts...>> {
   using type = T<Ts...>;
 };
 
-template<template<typename...> class T, typename TUPLEorVARIANT>
+template <template <typename...> class T, typename TUPLEorVARIANT>
 using OverMembers =
     typename OverMembersHelper<T, std::decay_t<TUPLEorVARIANT>>::type;
 
@@ -82,23 +82,23 @@ using OverMembers =
 // The zero-based index of the first type T among the alternatives for which
 // PREDICATE<T>::value() is true is returned, or -1 when the predicate is false
 // for every type in the set.
-template<template<typename> class PREDICATE> struct SearchMembersHelper {
-  template<typename... Ts> struct Scanner {
+template <template <typename> class PREDICATE> struct SearchMembersHelper {
+  template <typename... Ts> struct Scanner {
     static constexpr int value() { return SearchTypeList<PREDICATE, Ts...>; }
   };
 };
 
-template<template<typename> class PREDICATE, typename TUPLEorVARIANT>
+template <template <typename> class PREDICATE, typename TUPLEorVARIANT>
 constexpr int SearchMembers{
     OverMembers<SearchMembersHelper<PREDICATE>::template Scanner,
         TUPLEorVARIANT>::value()};
 
-template<typename A, typename TUPLEorVARIANT>
+template <typename A, typename TUPLEorVARIANT>
 constexpr bool HasMember{
     SearchMembers<MatchType<A>::template Match, TUPLEorVARIANT> >= 0};
 
 // std::optional<std::optional<A>> -> std::optional<A>
-template<typename A>
+template <typename A>
 std::optional<A> JoinOptional(std::optional<std::optional<A>> &&x) {
   if (x) {
     return std::move(*x);
@@ -107,7 +107,7 @@ std::optional<A> JoinOptional(std::optional<std::optional<A>> &&x) {
 }
 
 // Convert an std::optional to an ordinary pointer
-template<typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
+template <typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
   if (x) {
     return &*x;
   } else {
@@ -117,13 +117,13 @@ template<typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
 
 // Copy a value from one variant type to another.  The types allowed in the
 // source variant must all be allowed in the destination variant type.
-template<typename TOV, typename FROMV> TOV CopyVariant(const FROMV &u) {
+template <typename TOV, typename FROMV> TOV CopyVariant(const FROMV &u) {
   return std::visit([](const auto &x) -> TOV { return {x}; }, u);
 }
 
 // Move a value from one variant type to another.  The types allowed in the
 // source variant must all be allowed in the destination variant type.
-template<typename TOV, typename FROMV>
+template <typename TOV, typename FROMV>
 common::IfNoLvalue<TOV, FROMV> MoveVariant(FROMV &&u) {
   return std::visit(
       [](auto &&x) -> TOV { return {std::move(x)}; }, std::move(u));
@@ -134,26 +134,26 @@ common::IfNoLvalue<TOV, FROMV> MoveVariant(FROMV &&u) {
 // types.  E.g.,
 //   CombineTuples<std::tuple<char, int>, std::tuple<float, double>>
 // is std::tuple<char, int, float, double>.
-template<typename... TUPLES> struct CombineTuplesHelper {
+template <typename... TUPLES> struct CombineTuplesHelper {
   static decltype(auto) f(TUPLES *... a) {
     return std::tuple_cat(std::move(*a)...);
   }
   using type = decltype(f(static_cast<TUPLES *>(nullptr)...));
 };
-template<typename... TUPLES>
+template <typename... TUPLES>
 using CombineTuples = typename CombineTuplesHelper<TUPLES...>::type;
 
 // CombineVariants takes a list of std::variant<> instantiations and constructs
 // a new instantiation that holds all of their alternatives, which must be
 // pairwise distinct.
-template<typename> struct VariantToTupleHelper;
-template<typename... Ts> struct VariantToTupleHelper<std::variant<Ts...>> {
+template <typename> struct VariantToTupleHelper;
+template <typename... Ts> struct VariantToTupleHelper<std::variant<Ts...>> {
   using type = std::tuple<Ts...>;
 };
-template<typename VARIANT>
+template <typename VARIANT>
 using VariantToTuple = typename VariantToTupleHelper<VARIANT>::type;
 
-template<typename A, typename... REST> struct AreTypesDistinctHelper {
+template <typename A, typename... REST> struct AreTypesDistinctHelper {
   static constexpr bool value() {
     if constexpr (sizeof...(REST) > 0) {
       // extra () for clang-format
@@ -163,10 +163,10 @@ template<typename A, typename... REST> struct AreTypesDistinctHelper {
     return true;
   }
 };
-template<typename... Ts>
+template <typename... Ts>
 constexpr bool AreTypesDistinct{AreTypesDistinctHelper<Ts...>::value()};
 
-template<typename A, typename... Ts> struct AreSameTypeHelper {
+template <typename A, typename... Ts> struct AreSameTypeHelper {
   using type = A;
   static constexpr bool value() {
     if constexpr (sizeof...(Ts) == 0) {
@@ -178,53 +178,53 @@ template<typename A, typename... Ts> struct AreSameTypeHelper {
   }
 };
 
-template<typename... Ts>
+template <typename... Ts>
 constexpr bool AreSameType{AreSameTypeHelper<Ts...>::value()};
 
-template<typename> struct TupleToVariantHelper;
-template<typename... Ts> struct TupleToVariantHelper<std::tuple<Ts...>> {
+template <typename> struct TupleToVariantHelper;
+template <typename... Ts> struct TupleToVariantHelper<std::tuple<Ts...>> {
   static_assert(AreTypesDistinct<Ts...>,
       "TupleToVariant: types are not pairwise distinct");
   using type = std::variant<Ts...>;
 };
-template<typename TUPLE>
+template <typename TUPLE>
 using TupleToVariant = typename TupleToVariantHelper<TUPLE>::type;
 
-template<typename... VARIANTS> struct CombineVariantsHelper {
+template <typename... VARIANTS> struct CombineVariantsHelper {
   using type = TupleToVariant<CombineTuples<VariantToTuple<VARIANTS>...>>;
 };
-template<typename... VARIANTS>
+template <typename... VARIANTS>
 using CombineVariants = typename CombineVariantsHelper<VARIANTS...>::type;
 
 // SquashVariantOfVariants: given a std::variant whose alternatives are
 // all std::variant instantiations, form a new union over their alternatives.
-template<typename VARIANT>
+template <typename VARIANT>
 using SquashVariantOfVariants = OverMembers<CombineVariants, VARIANT>;
 
 // Given a type function, MapTemplate applies it to each of the types
 // in a tuple or variant, and collect the results in a given variadic
 // template (typically a std::variant).
-template<template<typename> class, template<typename...> class, typename...>
+template <template <typename> class, template <typename...> class, typename...>
 struct MapTemplateHelper;
-template<template<typename> class F, template<typename...> class PACKAGE,
+template <template <typename> class F, template <typename...> class PACKAGE,
     typename... Ts>
 struct MapTemplateHelper<F, PACKAGE, std::tuple<Ts...>> {
   using type = PACKAGE<F<Ts>...>;
 };
-template<template<typename> class F, template<typename...> class PACKAGE,
+template <template <typename> class F, template <typename...> class PACKAGE,
     typename... Ts>
 struct MapTemplateHelper<F, PACKAGE, std::variant<Ts...>> {
   using type = PACKAGE<F<Ts>...>;
 };
-template<template<typename> class F, typename TUPLEorVARIANT,
-    template<typename...> class PACKAGE = std::variant>
+template <template <typename> class F, typename TUPLEorVARIANT,
+    template <typename...> class PACKAGE = std::variant>
 using MapTemplate =
     typename MapTemplateHelper<F, PACKAGE, TUPLEorVARIANT>::type;
 
 // std::tuple<std::optional<>...> -> std::optional<std::tuple<...>>
 // i.e., inverts a tuple of optional values into an optional tuple that has
 // a value only if all of the original elements were present.
-template<typename... A, std::size_t... J>
+template <typename... A, std::size_t... J>
 std::optional<std::tuple<A...>> AllElementsPresentHelper(
     std::tuple<std::optional<A>...> &&t, std::index_sequence<J...>) {
   bool present[]{std::get<J>(t).has_value()...};
@@ -236,7 +236,7 @@ std::optional<std::tuple<A...>> AllElementsPresentHelper(
   return {std::make_tuple(*std::get<J>(t)...)};
 }
 
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<A...>> AllElementsPresent(
     std::tuple<std::optional<A>...> &&t) {
   return AllElementsPresentHelper(
@@ -246,7 +246,7 @@ std::optional<std::tuple<A...>> AllElementsPresent(
 // std::vector<std::optional<A>> -> std::optional<std::vector<A>>
 // i.e., inverts a vector of optional values into an optional vector that
 // will have a value only when all of the original elements are present.
-template<typename A>
+template <typename A>
 std::optional<std::vector<A>> AllElementsPresent(
     std::vector<std::optional<A>> &&v) {
   for (const auto &maybeA : v) {
@@ -264,7 +264,7 @@ std::optional<std::vector<A>> AllElementsPresent(
 // (std::optional<>...) -> std::optional<std::tuple<...>>
 // i.e., given some number of optional values, return a optional tuple of
 // those values that is present only of all of the values were so.
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&... x) {
   return AllElementsPresent(std::make_tuple(std::move(x)...));
 }
@@ -274,7 +274,7 @@ std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&... x) {
 // N.B. If the function returns std::optional, MapOptional will return
 // std::optional<std::optional<...>> and you will probably want to
 // run it through JoinOptional to "squash" it.
-template<typename R, typename... A>
+template <typename R, typename... A>
 std::optional<R> MapOptional(
     std::function<R(A &&...)> &&f, std::optional<A> &&... x) {
   if (auto args{AllPresent(std::move(x)...)}) {
@@ -282,7 +282,7 @@ std::optional<R> MapOptional(
   }
   return std::nullopt;
 }
-template<typename R, typename... A>
+template <typename R, typename... A>
 std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&... x) {
   return MapOptional(std::function<R(A && ...)>{f}, std::move(x)...);
 }
@@ -297,7 +297,7 @@ std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&... x) {
 // and invoke VISITOR::Test<T>() on each until it returns a value that
 // casts to true.  If no invocation of Test succeeds, SearchTypes will
 // return a default value.
-template<std::size_t J, typename VISITOR>
+template <std::size_t J, typename VISITOR>
 common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypesHelper(
     VISITOR &&visitor, typename VISITOR::Result &&defaultResult) {
   using Tuple = typename VISITOR::Types;
@@ -312,12 +312,12 @@ common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypesHelper(
   }
 }
 
-template<typename VISITOR>
+template <typename VISITOR>
 common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypes(
     VISITOR &&visitor,
     typename VISITOR::Result defaultResult = typename VISITOR::Result{}) {
   return SearchTypesHelper<0, VISITOR>(
       std::move(visitor), std::move(defaultResult));
 }
-}
-#endif  // FORTRAN_COMMON_TEMPLATE_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_TEMPLATE_H_
diff --git a/include/flang/Common/uint128.h b/include/flang/Common/uint128.h
index 48e1f49e8e90..996b13778322 100644
--- a/include/flang/Common/uint128.h
+++ b/include/flang/Common/uint128.h
@@ -13,7 +13,7 @@
 #define FORTRAN_COMMON_UINT128_H_
 
 #ifndef AVOID_NATIVE_UINT128_T
-#define AVOID_NATIVE_UINT128_T 1  // always use this code for now for testing
+#define AVOID_NATIVE_UINT128_T 1 // always use this code for now for testing
 #endif
 
 #include "leading-zero-bit-count.h"
@@ -31,14 +31,14 @@ class UnsignedInt128 {
   constexpr UnsignedInt128(unsigned long n) : low_{n} {}
   constexpr UnsignedInt128(unsigned long long n) : low_{n} {}
   constexpr UnsignedInt128(int n)
-    : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                               n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
+                                                 n < 0)} {}
   constexpr UnsignedInt128(long n)
-    : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                               n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
+                                                 n < 0)} {}
   constexpr UnsignedInt128(long long n)
-    : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                               n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
+                                                 n < 0)} {}
   constexpr UnsignedInt128(const UnsignedInt128 &) = default;
   constexpr UnsignedInt128(UnsignedInt128 &&) = default;
   constexpr UnsignedInt128 &operator=(const UnsignedInt128 &) = default;
@@ -241,7 +241,7 @@ class UnsignedInt128 {
 
 private:
   constexpr UnsignedInt128(std::uint64_t hi, std::uint64_t lo)
-    : low_{lo}, high_{hi} {}
+      : low_{lo}, high_{hi} {}
   constexpr int LeadingZeroes() const {
     if (high_ == 0) {
       return 64 + LeadingZeroBitCount(low_);
@@ -261,14 +261,14 @@ using uint128_t = __uint128_t;
 using uint128_t = UnsignedInt128;
 #endif
 
-template<int BITS> struct HostUnsignedIntTypeHelper {
+template <int BITS> struct HostUnsignedIntTypeHelper {
   using type = std::conditional_t<(BITS <= 8), std::uint8_t,
       std::conditional_t<(BITS <= 16), std::uint16_t,
           std::conditional_t<(BITS <= 32), std::uint32_t,
               std::conditional_t<(BITS <= 64), std::uint64_t, uint128_t>>>>;
 };
-template<int BITS>
+template <int BITS>
 using HostUnsignedIntType = typename HostUnsignedIntTypeHelper<BITS>::type;
 
-}
+} // namespace Fortran::common
 #endif
diff --git a/include/flang/Common/unsigned-const-division.h b/include/flang/Common/unsigned-const-division.h
index 752bbd94e7fa..0799edbe0ef9 100644
--- a/include/flang/Common/unsigned-const-division.h
+++ b/include/flang/Common/unsigned-const-division.h
@@ -22,7 +22,7 @@
 
 namespace Fortran::common {
 
-template<typename UINT> class FixedPointReciprocal {
+template <typename UINT> class FixedPointReciprocal {
 public:
   using type = UINT;
 
@@ -36,7 +36,7 @@ template<typename UINT> class FixedPointReciprocal {
   static constexpr FixedPointReciprocal For(type n) {
     if (n == 0) {
       return {0, 0};
-    } else if ((n & (n - 1)) == 0) {  // n is a power of two
+    } else if ((n & (n - 1)) == 0) { // n is a power of two
       return {TrailingZeroBitCount(n), 1};
     } else {
       int shift{bits - 1 + BitsNeededFor(n)};
@@ -60,7 +60,7 @@ static_assert(FixedPointReciprocal<std::uint32_t>::For(5).Divide(2000000000u) ==
 static_assert(FixedPointReciprocal<std::uint64_t>::For(10).Divide(
                   10000000000000000u) == 1000000000000000u);
 
-template<typename UINT, std::uint64_t DENOM>
+template <typename UINT, std::uint64_t DENOM>
 inline constexpr UINT DivideUnsignedBy(UINT n) {
   if constexpr (std::is_same_v<UINT, uint128_t>) {
     return n / static_cast<UINT>(DENOM);
@@ -73,5 +73,5 @@ inline constexpr UINT DivideUnsignedBy(UINT n) {
     return recip.Divide(n);
   }
 }
-}
+} // namespace Fortran::common
 #endif
diff --git a/include/flang/Common/unwrap.h b/include/flang/Common/unwrap.h
index 8a14bf68fb27..339b6a77edc0 100644
--- a/include/flang/Common/unwrap.h
+++ b/include/flang/Common/unwrap.h
@@ -37,7 +37,7 @@
 namespace Fortran::common {
 
 // Utility: Produces "const A" if B is const and A is not already so.
-template<typename A, typename B>
+template <typename A, typename B>
 using Constify = std::conditional_t<std::is_const_v<B> && !std::is_const_v<A>,
     std::add_const_t<A>, A>;
 
@@ -46,7 +46,7 @@ using Constify = std::conditional_t<std::is_const_v<B> && !std::is_const_v<A>,
 struct UnwrapperHelper {
 
   // Base case
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(B &x) -> Constify<A, B> * {
     if constexpr (std::is_same_v<std::decay_t<A>, std::decay_t<B>>) {
       return &x;
@@ -56,7 +56,7 @@ struct UnwrapperHelper {
   }
 
   // Implementations of specializations
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(B *p) -> Constify<A, B> * {
     if (p) {
       return Unwrap<A>(*p);
@@ -65,7 +65,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const std::unique_ptr<B> &p) -> Constify<A, B> * {
     if (p.get()) {
       return Unwrap<A>(*p);
@@ -74,7 +74,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const std::shared_ptr<B> &p) -> Constify<A, B> * {
     if (p.get()) {
       return Unwrap<A>(*p);
@@ -83,7 +83,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(std::optional<B> &x) -> Constify<A, B> * {
     if (x) {
       return Unwrap<A>(*x);
@@ -92,7 +92,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const std::optional<B> &x) -> Constify<A, B> * {
     if (x) {
       return Unwrap<A>(*x);
@@ -101,7 +101,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   static A *Unwrap(std::variant<Bs...> &u) {
     return std::visit(
         [](auto &x) -> A * {
@@ -115,23 +115,23 @@ struct UnwrapperHelper {
         u);
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   static auto Unwrap(const std::variant<Bs...> &u) -> std::add_const_t<A> * {
     return std::visit(
         [](const auto &x) -> std::add_const_t<A> * { return Unwrap<A>(x); }, u);
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const Reference<B> &ref) -> Constify<A, B> * {
     return Unwrap<A>(*ref);
   }
 
-  template<typename A, typename B, bool COPY>
+  template <typename A, typename B, bool COPY>
   static auto Unwrap(const Indirection<B, COPY> &p) -> Constify<A, B> * {
     return Unwrap<A>(*p);
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const CountedReference<B> &p) -> Constify<A, B> * {
     if (p.get()) {
       return Unwrap<A>(*p);
@@ -141,17 +141,17 @@ struct UnwrapperHelper {
   }
 };
 
-template<typename A, typename B> auto Unwrap(B &x) -> Constify<A, B> * {
+template <typename A, typename B> auto Unwrap(B &x) -> Constify<A, B> * {
   return UnwrapperHelper::Unwrap<A>(x);
 }
 
 // Returns a copy of a wrapped value, if present, otherwise a vacant optional.
-template<typename A, typename B> std::optional<A> UnwrapCopy(const B &x) {
+template <typename A, typename B> std::optional<A> UnwrapCopy(const B &x) {
   if (const A * p{Unwrap<A>(x)}) {
     return std::make_optional<A>(*p);
   } else {
     return std::nullopt;
   }
 }
-}
-#endif  // FORTRAN_COMMON_UNWRAP_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_UNWRAP_H_
diff --git a/include/flang/Decimal/binary-floating-point.h b/include/flang/Decimal/binary-floating-point.h
index ad3eb3e47ad1..7cc8384861fb 100644
--- a/include/flang/Decimal/binary-floating-point.h
+++ b/include/flang/Decimal/binary-floating-point.h
@@ -21,9 +21,9 @@
 
 namespace Fortran::decimal {
 
-template<int BINARY_PRECISION>
+template <int BINARY_PRECISION>
 struct BinaryFloatingPointNumber
-  : public common::RealDetails<BINARY_PRECISION> {
+    : public common::RealDetails<BINARY_PRECISION> {
 
   using Details = common::RealDetails<BINARY_PRECISION>;
   using Details::bits;
@@ -40,7 +40,7 @@ struct BinaryFloatingPointNumber
   static_assert(CHAR_BIT * sizeof(RawType) >= bits);
   static constexpr RawType significandMask{(RawType{1} << significandBits) - 1};
 
-  constexpr BinaryFloatingPointNumber() {}  // zero
+  constexpr BinaryFloatingPointNumber() {} // zero
   constexpr BinaryFloatingPointNumber(
       const BinaryFloatingPointNumber &that) = default;
   constexpr BinaryFloatingPointNumber(
@@ -50,7 +50,7 @@ struct BinaryFloatingPointNumber
   constexpr BinaryFloatingPointNumber &operator=(
       BinaryFloatingPointNumber &&that) = default;
 
-  template<typename A> explicit constexpr BinaryFloatingPointNumber(A x) {
+  template <typename A> explicit constexpr BinaryFloatingPointNumber(A x) {
     static_assert(sizeof raw <= sizeof x);
     std::memcpy(reinterpret_cast<void *>(&raw),
         reinterpret_cast<const void *>(&x), sizeof raw);
@@ -92,5 +92,5 @@ struct BinaryFloatingPointNumber
 
   RawType raw{0};
 };
-}
+} // namespace Fortran::decimal
 #endif
diff --git a/include/flang/Decimal/decimal.h b/include/flang/Decimal/decimal.h
index 5f80ab6f349f..0bc9deb08f4c 100644
--- a/include/flang/Decimal/decimal.h
+++ b/include/flang/Decimal/decimal.h
@@ -72,7 +72,7 @@ enum DecimalConversionFlags {
 #define EXTRA_DECIMAL_CONVERSION_SPACE (1 + 1 + 16 - 1)
 
 #ifdef __cplusplus
-template<int PREC>
+template <int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *, size_t,
     DecimalConversionFlags, int digits, enum FortranRounding rounding,
     BinaryFloatingPointNumber<PREC> x);
@@ -96,12 +96,12 @@ extern template ConversionToDecimalResult ConvertToDecimal<113>(char *, size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<113>);
 
-template<int PREC> struct ConversionToBinaryResult {
+template <int PREC> struct ConversionToBinaryResult {
   BinaryFloatingPointNumber<PREC> binary;
   enum ConversionResultFlags flags { Exact };
 };
 
-template<int PREC>
+template <int PREC>
 ConversionToBinaryResult<PREC> ConvertToBinary(
     const char *&, enum FortranRounding = RoundNearest);
 
@@ -117,7 +117,7 @@ extern template ConversionToBinaryResult<64> ConvertToBinary<64>(
     const char *&, enum FortranRounding = RoundNearest);
 extern template ConversionToBinaryResult<113> ConvertToBinary<113>(
     const char *&, enum FortranRounding = RoundNearest);
-}  // namespace Fortran::decimal
+} // namespace Fortran::decimal
 extern "C" {
 #define NS(x) Fortran::decimal::x
 #else /* C++ */
@@ -146,6 +146,6 @@ enum NS(ConversionResultFlags) ConvertDecimalToLongDouble(
 #endif
 #undef NS
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 #endif
diff --git a/include/flang/Evaluate/call.h b/include/flang/Evaluate/call.h
index e083c75708b9..15fe5b879dc4 100644
--- a/include/flang/Evaluate/call.h
+++ b/include/flang/Evaluate/call.h
@@ -33,11 +33,11 @@ class Symbol;
 namespace Fortran::evaluate {
 class Component;
 class IntrinsicProcTable;
-}
+} // namespace Fortran::evaluate
 namespace Fortran::evaluate::characteristics {
 struct DummyArgument;
 struct Procedure;
-}
+} // namespace Fortran::evaluate::characteristics
 
 extern template class Fortran::common::Indirection<Fortran::evaluate::Component,
     true>;
@@ -133,7 +133,7 @@ class ActualArgument {
   // in the parse tree.
   std::variant<common::CopyableIndirection<Expr<SomeType>>, AssumedType> u_;
   std::optional<parser::CharBlock> keyword_;
-  bool isAlternateReturn_{false};  // whether expr is a "*label" number
+  bool isAlternateReturn_{false}; // whether expr is a "*label" number
   bool isPassedObject_{false};
   common::Intent dummyIntent_{common::Intent::Default};
 };
@@ -152,7 +152,7 @@ struct SpecificIntrinsic {
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   IntrinsicProcedure name;
-  bool isRestrictedSpecific{false};  // if true, can only call it, not pass it
+  bool isRestrictedSpecific{false}; // if true, can only call it, not pass it
   common::CopyableIndirection<characteristics::Procedure> characteristics;
 };
 
@@ -164,7 +164,7 @@ struct ProcedureDesignator {
 
   // Exactly one of these will return a non-null pointer.
   const SpecificIntrinsic *GetSpecificIntrinsic() const;
-  const Symbol *GetSymbol() const;  // symbol or component symbol
+  const Symbol *GetSymbol() const; // symbol or component symbol
 
   // For references to NOPASS components and bindings only.
   // References to PASS components and bindings are represented
@@ -191,7 +191,7 @@ class ProcedureRef {
 public:
   CLASS_BOILERPLATE(ProcedureRef)
   ProcedureRef(ProcedureDesignator &&p, ActualArguments &&a)
-    : proc_{std::move(p)}, arguments_(std::move(a)) {}
+      : proc_{std::move(p)}, arguments_(std::move(a)) {}
   ~ProcedureRef();
 
   ProcedureDesignator &proc() { return proc_; }
@@ -210,18 +210,18 @@ class ProcedureRef {
   ActualArguments arguments_;
 };
 
-template<typename A> class FunctionRef : public ProcedureRef {
+template <typename A> class FunctionRef : public ProcedureRef {
 public:
   using Result = A;
   CLASS_BOILERPLATE(FunctionRef)
   explicit FunctionRef(ProcedureRef &&pr) : ProcedureRef{std::move(pr)} {}
   FunctionRef(ProcedureDesignator &&p, ActualArguments &&a)
-    : ProcedureRef{std::move(p), std::move(a)} {}
+      : ProcedureRef{std::move(p), std::move(a)} {}
 
   std::optional<DynamicType> GetType() const { return proc_.GetType(); }
-  std::optional<Constant<Result>> Fold(FoldingContext &);  // for intrinsics
+  std::optional<Constant<Result>> Fold(FoldingContext &); // for intrinsics
 };
 
 FOR_EACH_SPECIFIC_TYPE(extern template class FunctionRef, )
-}
-#endif  // FORTRAN_EVALUATE_CALL_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_CALL_H_
diff --git a/include/flang/Evaluate/characteristics.h b/include/flang/Evaluate/characteristics.h
index 50717f04c515..5233c5785d95 100644
--- a/include/flang/Evaluate/characteristics.h
+++ b/include/flang/Evaluate/characteristics.h
@@ -91,7 +91,7 @@ class TypeAndShape {
   static std::optional<TypeAndShape> Characterize(
       const semantics::DeclTypeSpec &);
 
-  template<typename A>
+  template <typename A>
   static std::optional<TypeAndShape> Characterize(
       const A &x, FoldingContext &context) {
     if (const auto *symbol{UnwrapWholeSymbolDataRef(x)}) {
@@ -197,9 +197,9 @@ struct AlternateReturn {
 struct DummyArgument {
   DECLARE_CONSTRUCTORS_AND_ASSIGNMENTS(DummyArgument)
   DummyArgument(std::string &&name, DummyDataObject &&x)
-    : name{std::move(name)}, u{std::move(x)} {}
+      : name{std::move(name)}, u{std::move(x)} {}
   DummyArgument(std::string &&name, DummyProcedure &&x)
-    : name{std::move(name)}, u{std::move(x)} {}
+      : name{std::move(name)}, u{std::move(x)} {}
   explicit DummyArgument(AlternateReturn &&x) : u{std::move(x)} {}
   ~DummyArgument();
   bool operator==(const DummyArgument &) const;
@@ -215,7 +215,7 @@ struct DummyArgument {
   // name and pass are not characteristics and so does not participate in
   // operator== but are needed to determine if procedures are distinguishable
   std::string name;
-  bool pass{false};  // is this the PASS argument of its procedure
+  bool pass{false}; // is this the PASS argument of its procedure
   std::variant<DummyDataObject, DummyProcedure, AlternateReturn> u;
 };
 
@@ -262,7 +262,7 @@ struct Procedure {
       Attr, Pure, Elemental, BindC, ImplicitInterface, NullPointer, Subroutine)
   using Attrs = common::EnumSet<Attr, Attr_enumSize>;
   Procedure(FunctionResult &&, DummyArguments &&, Attrs);
-  Procedure(DummyArguments &&, Attrs);  // for subroutines and NULL()
+  Procedure(DummyArguments &&, Attrs); // for subroutines and NULL()
   DECLARE_CONSTRUCTORS_AND_ASSIGNMENTS(Procedure)
   ~Procedure();
   bool operator==(const Procedure &) const;
@@ -301,5 +301,5 @@ struct Procedure {
   Procedure() {}
 };
 
-}
-#endif  // FORTRAN_EVALUATE_CHARACTERISTICS_H_
+} // namespace Fortran::evaluate::characteristics
+#endif // FORTRAN_EVALUATE_CHARACTERISTICS_H_
diff --git a/include/flang/Evaluate/check-expression.h b/include/flang/Evaluate/check-expression.h
index 2285881c329a..4e93b2ab4f32 100644
--- a/include/flang/Evaluate/check-expression.h
+++ b/include/flang/Evaluate/check-expression.h
@@ -28,7 +28,7 @@ class IntrinsicProcTable;
 // Predicate: true when an expression is a constant expression (in the
 // strict sense of the Fortran standard); it may not (yet) be a hard
 // constant value.
-template<typename A> bool IsConstantExpr(const A &);
+template <typename A> bool IsConstantExpr(const A &);
 extern template bool IsConstantExpr(const Expr<SomeType> &);
 extern template bool IsConstantExpr(const Expr<SomeInteger> &);
 extern template bool IsConstantExpr(const Expr<SubscriptInteger> &);
@@ -40,7 +40,7 @@ bool IsInitialDataTarget(const Expr<SomeType> &, parser::ContextualMessages &);
 // Check whether an expression is a specification expression
 // (10.1.11(2), C1010).  Constant expressions are always valid
 // specification expressions.
-template<typename A>
+template <typename A>
 void CheckSpecificationExpr(
     const A &, parser::ContextualMessages &, const semantics::Scope &);
 extern template void CheckSpecificationExpr(const Expr<SomeType> &x,
@@ -60,10 +60,10 @@ extern template void CheckSpecificationExpr(
     parser::ContextualMessages &, const semantics::Scope &);
 
 // Simple contiguity (9.5.4)
-template<typename A>
+template <typename A>
 bool IsSimplyContiguous(const A &, const IntrinsicProcTable &);
 extern template bool IsSimplyContiguous(
     const Expr<SomeType> &, const IntrinsicProcTable &);
 
-}
+} // namespace Fortran::evaluate
 #endif
diff --git a/include/flang/Evaluate/common.h b/include/flang/Evaluate/common.h
index 639ff0c82e2e..7065977ca577 100644
--- a/include/flang/Evaluate/common.h
+++ b/include/flang/Evaluate/common.h
@@ -35,7 +35,8 @@ using common::RelationalOperator;
 ENUM_CLASS(Ordering, Less, Equal, Greater)
 ENUM_CLASS(Relation, Less, Equal, Greater, Unordered)
 
-template<typename A> static constexpr Ordering Compare(const A &x, const A &y) {
+template <typename A>
+static constexpr Ordering Compare(const A &x, const A &y) {
   if (x < y) {
     return Ordering::Less;
   } else if (x > y) {
@@ -87,17 +88,21 @@ static constexpr bool Satisfies(RelationalOperator op, Ordering order) {
     return op == RelationalOperator::NE || op == RelationalOperator::GE ||
         op == RelationalOperator::GT;
   }
-  return false;  // silence g++ warning
+  return false; // silence g++ warning
 }
 
 static constexpr bool Satisfies(RelationalOperator op, Relation relation) {
   switch (relation) {
-  case Relation::Less: return Satisfies(op, Ordering::Less);
-  case Relation::Equal: return Satisfies(op, Ordering::Equal);
-  case Relation::Greater: return Satisfies(op, Ordering::Greater);
-  case Relation::Unordered: return false;
+  case Relation::Less:
+    return Satisfies(op, Ordering::Less);
+  case Relation::Equal:
+    return Satisfies(op, Ordering::Equal);
+  case Relation::Greater:
+    return Satisfies(op, Ordering::Greater);
+  case Relation::Unordered:
+    return false;
   }
-  return false;  // silence g++ warning
+  return false; // silence g++ warning
 }
 
 ENUM_CLASS(
@@ -105,7 +110,7 @@ ENUM_CLASS(
 
 using RealFlags = common::EnumSet<RealFlag, RealFlag_enumSize>;
 
-template<typename A> struct ValueWithRealFlags {
+template <typename A> struct ValueWithRealFlags {
   A AccumulateFlags(RealFlags &f) {
     f |= flags;
     return value;
@@ -139,20 +144,20 @@ constexpr bool isHostLittleEndian{true};
 
 // HostUnsignedInt<BITS> finds the smallest native unsigned integer type
 // whose size is >= BITS.
-template<bool LE8, bool LE16, bool LE32, bool LE64> struct SmallestUInt {};
-template<> struct SmallestUInt<true, true, true, true> {
+template <bool LE8, bool LE16, bool LE32, bool LE64> struct SmallestUInt {};
+template <> struct SmallestUInt<true, true, true, true> {
   using type = std::uint8_t;
 };
-template<> struct SmallestUInt<false, true, true, true> {
+template <> struct SmallestUInt<false, true, true, true> {
   using type = std::uint16_t;
 };
-template<> struct SmallestUInt<false, false, true, true> {
+template <> struct SmallestUInt<false, false, true, true> {
   using type = std::uint32_t;
 };
-template<> struct SmallestUInt<false, false, false, true> {
+template <> struct SmallestUInt<false, false, false, true> {
   using type = std::uint64_t;
 };
-template<int BITS>
+template <int BITS>
 using HostUnsignedInt =
     typename SmallestUInt<BITS <= 8, BITS <= 16, BITS <= 32, BITS <= 64>::type;
 
@@ -188,8 +193,8 @@ using HostUnsignedInt =
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(t)
 
 #define UNION_CONSTRUCTORS(t) \
-  template<typename _A> explicit t(const _A &x) : u{x} {} \
-  template<typename _A, typename = common::NoLvalue<_A>> \
+  template <typename _A> explicit t(const _A &x) : u{x} {} \
+  template <typename _A, typename = common::NoLvalue<_A>> \
   explicit t(_A &&x) : u(std::move(x)) {}
 
 #define EVALUATE_UNION_CLASS_BOILERPLATE(t) \
@@ -199,29 +204,29 @@ using HostUnsignedInt =
 
 // Forward definition of Expr<> so that it can be indirectly used in its own
 // definition
-template<typename A> class Expr;
+template <typename A> class Expr;
 
 class FoldingContext {
 public:
   FoldingContext(
       const common::IntrinsicTypeDefaultKinds &d, const IntrinsicProcTable &t)
-    : defaults_{d}, intrinsics_{t} {}
+      : defaults_{d}, intrinsics_{t} {}
   FoldingContext(const parser::ContextualMessages &m,
       const common::IntrinsicTypeDefaultKinds &d, const IntrinsicProcTable &t,
       Rounding round = defaultRounding, bool flush = false)
-    : messages_{m}, defaults_{d}, intrinsics_{t}, rounding_{round},
-      flushSubnormalsToZero_{flush} {}
+      : messages_{m}, defaults_{d}, intrinsics_{t}, rounding_{round},
+        flushSubnormalsToZero_{flush} {}
   FoldingContext(const FoldingContext &that)
-    : messages_{that.messages_}, defaults_{that.defaults_},
-      intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
-      flushSubnormalsToZero_{that.flushSubnormalsToZero_},
-      pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
+      : messages_{that.messages_}, defaults_{that.defaults_},
+        intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
+        flushSubnormalsToZero_{that.flushSubnormalsToZero_},
+        pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
   FoldingContext(
       const FoldingContext &that, const parser::ContextualMessages &m)
-    : messages_{m}, defaults_{that.defaults_},
-      intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
-      flushSubnormalsToZero_{that.flushSubnormalsToZero_},
-      pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
+      : messages_{m}, defaults_{that.defaults_},
+        intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
+        flushSubnormalsToZero_{that.flushSubnormalsToZero_},
+        pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
 
   parser::ContextualMessages &messages() { return messages_; }
   const parser::ContextualMessages &messages() const { return messages_; }
@@ -263,5 +268,5 @@ class FoldingContext {
 };
 
 void RealFlagWarnings(FoldingContext &, const RealFlags &, const char *op);
-}
-#endif  // FORTRAN_EVALUATE_COMMON_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_COMMON_H_
diff --git a/include/flang/Evaluate/complex.h b/include/flang/Evaluate/complex.h
index 6c404638ab4f..5b8861caf4bf 100644
--- a/include/flang/Evaluate/complex.h
+++ b/include/flang/Evaluate/complex.h
@@ -19,12 +19,12 @@ class raw_ostream;
 
 namespace Fortran::evaluate::value {
 
-template<typename REAL_TYPE> class Complex {
+template <typename REAL_TYPE> class Complex {
 public:
   using Part = REAL_TYPE;
   static constexpr int bits{2 * Part::bits};
 
-  constexpr Complex() {}  // (+0.0, +0.0)
+  constexpr Complex() {} // (+0.0, +0.0)
   constexpr Complex(const Complex &) = default;
   constexpr Complex(const Part &r, const Part &i) : re_{r}, im_{i} {}
   explicit constexpr Complex(const Part &r) : re_{r} {}
@@ -59,7 +59,7 @@ template<typename REAL_TYPE> class Complex {
     return re_.IsSignalingNaN() || im_.IsSignalingNaN();
   }
 
-  template<typename INT>
+  template <typename INT>
   static ValueWithRealFlags<Complex> FromInteger(
       const INT &n, Rounding rounding = defaultRounding) {
     ValueWithRealFlags<Complex> result;
@@ -101,5 +101,5 @@ extern template class Complex<Real<Integer<32>, 24>>;
 extern template class Complex<Real<Integer<64>, 53>>;
 extern template class Complex<Real<Integer<80>, 64>>;
 extern template class Complex<Real<Integer<128>, 113>>;
-}
-#endif  // FORTRAN_EVALUATE_COMPLEX_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_COMPLEX_H_
diff --git a/include/flang/Evaluate/constant.h b/include/flang/Evaluate/constant.h
index e57563a6ee8c..04ebc991d215 100644
--- a/include/flang/Evaluate/constant.h
+++ b/include/flang/Evaluate/constant.h
@@ -37,7 +37,7 @@ using SymbolRef = common::Reference<const Symbol>;
 // constants, use a generic expression like Expr<SomeInteger> &
 // Expr<SomeType>) to wrap the appropriate instantiation of Constant<>.
 
-template<typename> class Constant;
+template <typename> class Constant;
 
 // When describing shapes of constants or specifying 1-based subscript
 // values as indices into constants, use a vector of integers.
@@ -87,7 +87,7 @@ class ConstantBounds {
 // Constant<> is specialized for Character kinds and SomeDerived.
 // The non-Character intrinsic types, and SomeDerived, share enough
 // common behavior that they use this common base class.
-template<typename RESULT, typename ELEMENT = Scalar<RESULT>>
+template <typename RESULT, typename ELEMENT = Scalar<RESULT>>
 class ConstantBase : public ConstantBounds {
   static_assert(RESULT::category != TypeCategory::Character);
 
@@ -95,11 +95,11 @@ class ConstantBase : public ConstantBounds {
   using Result = RESULT;
   using Element = ELEMENT;
 
-  template<typename A>
+  template <typename A>
   ConstantBase(const A &x, Result res = Result{}) : result_{res}, values_{x} {}
-  template<typename A, typename = common::NoLvalue<A>>
+  template <typename A, typename = common::NoLvalue<A>>
   ConstantBase(A &&x, Result res = Result{})
-    : result_{res}, values_{std::move(x)} {}
+      : result_{res}, values_{std::move(x)} {}
   ConstantBase(
       std::vector<Element> &&, ConstantSubscripts &&, Result = Result{});
 
@@ -124,7 +124,7 @@ class ConstantBase : public ConstantBounds {
   std::vector<Element> values_;
 };
 
-template<typename T> class Constant : public ConstantBase<T> {
+template <typename T> class Constant : public ConstantBase<T> {
 public:
   using Result = T;
   using Base = ConstantBase<T>;
@@ -149,7 +149,7 @@ template<typename T> class Constant : public ConstantBase<T> {
       ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder);
 };
 
-template<int KIND>
+template <int KIND>
 class Constant<Type<TypeCategory::Character, KIND>> : public ConstantBounds {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
@@ -189,7 +189,7 @@ class Constant<Type<TypeCategory::Character, KIND>> : public ConstantBounds {
       ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder);
 
 private:
-  Scalar<Result> values_;  // one contiguous string
+  Scalar<Result> values_; // one contiguous string
   ConstantSubscript length_;
   ConstantSubscripts shape_;
   ConstantSubscripts lbounds_;
@@ -199,9 +199,9 @@ class StructureConstructor;
 using StructureConstructorValues =
     std::map<SymbolRef, common::CopyableIndirection<Expr<SomeType>>>;
 
-template<>
+template <>
 class Constant<SomeDerived>
-  : public ConstantBase<SomeDerived, StructureConstructorValues> {
+    : public ConstantBase<SomeDerived, StructureConstructorValues> {
 public:
   using Result = SomeDerived;
   using Element = StructureConstructorValues;
@@ -231,5 +231,5 @@ FOR_EACH_INTRINSIC_KIND(extern template class Constant, )
   FOR_EACH_LENGTHLESS_INTRINSIC_KIND(template class ConstantBase, ) \
   template class ConstantBase<SomeDerived, StructureConstructorValues>; \
   FOR_EACH_INTRINSIC_KIND(template class Constant, )
-}
-#endif  // FORTRAN_EVALUATE_CONSTANT_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_CONSTANT_H_
diff --git a/include/flang/Evaluate/expression.h b/include/flang/Evaluate/expression.h
index b63fb1ede37b..ebeb78f558d1 100644
--- a/include/flang/Evaluate/expression.h
+++ b/include/flang/Evaluate/expression.h
@@ -60,10 +60,10 @@ using common::RelationalOperator;
 // represented with an instance of some class containing a Result typedef that
 // maps to some instantiation of Type<CATEGORY, KIND>, SomeKind<CATEGORY>,
 // or SomeType.  (Exception: BOZ literal constants in generic Expr<SomeType>.)
-template<typename A> using ResultType = typename std::decay_t<A>::Result;
+template <typename A> using ResultType = typename std::decay_t<A>::Result;
 
 // Common Expr<> behaviors: every Expr<T> derives from ExpressionBase<T>.
-template<typename RESULT> class ExpressionBase {
+template <typename RESULT> class ExpressionBase {
 public:
   using Result = RESULT;
 
@@ -78,13 +78,13 @@ template<typename RESULT> class ExpressionBase {
 #endif
 
 public:
-  template<typename A> Derived &operator=(const A &x) {
+  template <typename A> Derived &operator=(const A &x) {
     Derived &d{derived()};
     d.u = x;
     return d;
   }
 
-  template<typename A> common::IfNoLvalue<Derived &, A> operator=(A &&x) {
+  template <typename A> common::IfNoLvalue<Derived &, A> operator=(A &&x) {
     Derived &d{derived()};
     d.u = std::move(x);
     return d;
@@ -106,7 +106,7 @@ template<typename RESULT> class ExpressionBase {
 // struct Add : public Operation<Add, ...>.  Uses of instances of Operation<>,
 // including its own member functions, can access each specific class derived
 // from it via its derived() member function with compile-time type safety.
-template<typename DERIVED, typename RESULT, typename... OPERANDS>
+template <typename DERIVED, typename RESULT, typename... OPERANDS>
 class Operation {
   // The extra final member is a dummy that allows a safe unused reference
   // to element 1 to arise indirectly in the definition of "right()" below
@@ -118,7 +118,7 @@ class Operation {
   using Result = RESULT;
   static_assert(IsSpecificIntrinsicType<Result>);
   static constexpr std::size_t operands{sizeof...(OPERANDS)};
-  template<int J> using Operand = std::tuple_element_t<J, OperandTypes>;
+  template <int J> using Operand = std::tuple_element_t<J, OperandTypes>;
 
   // Unary operations wrap a single Expr with a CopyableIndirection.
   // Binary operations wrap a tuple of CopyableIndirections to Exprs.
@@ -140,7 +140,7 @@ class Operation {
   // which must be spelled like "this->template operand<0>()" when
   // inherited in a derived class template.  There are convenience aliases
   // left() and right() that are not templates.
-  template<int J> Expr<Operand<J>> &operand() {
+  template <int J> Expr<Operand<J>> &operand() {
     if constexpr (operands == 1) {
       static_assert(J == 0);
       return operand_.value();
@@ -148,7 +148,7 @@ class Operation {
       return std::get<J>(operand_).value();
     }
   }
-  template<int J> const Expr<Operand<J>> &operand() const {
+  template <int J> const Expr<Operand<J>> &operand() const {
     if constexpr (operands == 1) {
       static_assert(J == 0);
       return operand_.value();
@@ -198,7 +198,7 @@ class Operation {
 
 // Conversions to specific types from expressions of known category and
 // dynamic kind.
-template<typename TO, TypeCategory FROMCAT = TO::category>
+template <typename TO, TypeCategory FROMCAT = TO::category>
 struct Convert : public Operation<Convert<TO, FROMCAT>, TO, SomeKind<FROMCAT>> {
   // Fortran doesn't have conversions between kinds of CHARACTER apart from
   // assignments, and in those the data must be convertible to/from 7-bit ASCII.
@@ -218,7 +218,7 @@ struct Convert : public Operation<Convert<TO, FROMCAT>, TO, SomeKind<FROMCAT>> {
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
-template<typename A>
+template <typename A>
 struct Parentheses : public Operation<Parentheses<A>, A, A> {
   using Result = A;
   using Operand = A;
@@ -226,30 +226,30 @@ struct Parentheses : public Operation<Parentheses<A>, A, A> {
   using Base::Base;
 };
 
-template<typename A> struct Negate : public Operation<Negate<A>, A, A> {
+template <typename A> struct Negate : public Operation<Negate<A>, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Negate, A, A>;
   using Base::Base;
 };
 
-template<int KIND>
+template <int KIND>
 struct ComplexComponent
-  : public Operation<ComplexComponent<KIND>, Type<TypeCategory::Real, KIND>,
-        Type<TypeCategory::Complex, KIND>> {
+    : public Operation<ComplexComponent<KIND>, Type<TypeCategory::Real, KIND>,
+          Type<TypeCategory::Complex, KIND>> {
   using Result = Type<TypeCategory::Real, KIND>;
   using Operand = Type<TypeCategory::Complex, KIND>;
   using Base = Operation<ComplexComponent, Result, Operand>;
   CLASS_BOILERPLATE(ComplexComponent)
   ComplexComponent(bool isImaginary, const Expr<Operand> &x)
-    : Base{x}, isImaginaryPart{isImaginary} {}
+      : Base{x}, isImaginaryPart{isImaginary} {}
   ComplexComponent(bool isImaginary, Expr<Operand> &&x)
-    : Base{std::move(x)}, isImaginaryPart{isImaginary} {}
+      : Base{std::move(x)}, isImaginaryPart{isImaginary} {}
 
   bool isImaginaryPart{true};
 };
 
-template<int KIND>
+template <int KIND>
 struct Not : public Operation<Not<KIND>, Type<TypeCategory::Logical, KIND>,
                  Type<TypeCategory::Logical, KIND>> {
   using Result = Type<TypeCategory::Logical, KIND>;
@@ -262,10 +262,10 @@ struct Not : public Operation<Not<KIND>, Type<TypeCategory::Logical, KIND>,
 // have explicit syntax for changing them.  Expressions represent
 // changes of length (e.g., for assignments and structure constructors)
 // with this operation.
-template<int KIND>
+template <int KIND>
 struct SetLength
-  : public Operation<SetLength<KIND>, Type<TypeCategory::Character, KIND>,
-        Type<TypeCategory::Character, KIND>, SubscriptInteger> {
+    : public Operation<SetLength<KIND>, Type<TypeCategory::Character, KIND>,
+          Type<TypeCategory::Character, KIND>, SubscriptInteger> {
   using Result = Type<TypeCategory::Character, KIND>;
   using CharacterOperand = Result;
   using LengthOperand = SubscriptInteger;
@@ -275,42 +275,42 @@ struct SetLength
 
 // Binary operations
 
-template<typename A> struct Add : public Operation<Add<A>, A, A, A> {
+template <typename A> struct Add : public Operation<Add<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Add, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Subtract : public Operation<Subtract<A>, A, A, A> {
+template <typename A> struct Subtract : public Operation<Subtract<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Subtract, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Multiply : public Operation<Multiply<A>, A, A, A> {
+template <typename A> struct Multiply : public Operation<Multiply<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Multiply, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Divide : public Operation<Divide<A>, A, A, A> {
+template <typename A> struct Divide : public Operation<Divide<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Divide, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Power : public Operation<Power<A>, A, A, A> {
+template <typename A> struct Power : public Operation<Power<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Power, A, A, A>;
   using Base::Base;
 };
 
-template<typename A>
+template <typename A>
 struct RealToIntPower : public Operation<RealToIntPower<A>, A, A, SomeInteger> {
   using Base = Operation<RealToIntPower, A, A, SomeInteger>;
   using Result = A;
@@ -319,74 +319,75 @@ struct RealToIntPower : public Operation<RealToIntPower<A>, A, A, SomeInteger> {
   using Base::Base;
 };
 
-template<typename A> struct Extremum : public Operation<Extremum<A>, A, A, A> {
+template <typename A> struct Extremum : public Operation<Extremum<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Extremum, A, A, A>;
   CLASS_BOILERPLATE(Extremum)
   Extremum(Ordering ord, const Expr<Operand> &x, const Expr<Operand> &y)
-    : Base{x, y}, ordering{ord} {}
+      : Base{x, y}, ordering{ord} {}
   Extremum(Ordering ord, Expr<Operand> &&x, Expr<Operand> &&y)
-    : Base{std::move(x), std::move(y)}, ordering{ord} {}
+      : Base{std::move(x), std::move(y)}, ordering{ord} {}
   Ordering ordering{Ordering::Greater};
 };
 
-template<int KIND>
+template <int KIND>
 struct ComplexConstructor
-  : public Operation<ComplexConstructor<KIND>,
-        Type<TypeCategory::Complex, KIND>, Type<TypeCategory::Real, KIND>,
-        Type<TypeCategory::Real, KIND>> {
+    : public Operation<ComplexConstructor<KIND>,
+          Type<TypeCategory::Complex, KIND>, Type<TypeCategory::Real, KIND>,
+          Type<TypeCategory::Real, KIND>> {
   using Result = Type<TypeCategory::Complex, KIND>;
   using Operand = Type<TypeCategory::Real, KIND>;
   using Base = Operation<ComplexConstructor, Result, Operand, Operand>;
   using Base::Base;
 };
 
-template<int KIND>
+template <int KIND>
 struct Concat
-  : public Operation<Concat<KIND>, Type<TypeCategory::Character, KIND>,
-        Type<TypeCategory::Character, KIND>,
-        Type<TypeCategory::Character, KIND>> {
+    : public Operation<Concat<KIND>, Type<TypeCategory::Character, KIND>,
+          Type<TypeCategory::Character, KIND>,
+          Type<TypeCategory::Character, KIND>> {
   using Result = Type<TypeCategory::Character, KIND>;
   using Operand = Result;
   using Base = Operation<Concat, Result, Operand, Operand>;
   using Base::Base;
 };
 
-template<int KIND>
+template <int KIND>
 struct LogicalOperation
-  : public Operation<LogicalOperation<KIND>, Type<TypeCategory::Logical, KIND>,
-        Type<TypeCategory::Logical, KIND>, Type<TypeCategory::Logical, KIND>> {
+    : public Operation<LogicalOperation<KIND>,
+          Type<TypeCategory::Logical, KIND>, Type<TypeCategory::Logical, KIND>,
+          Type<TypeCategory::Logical, KIND>> {
   using Result = Type<TypeCategory::Logical, KIND>;
   using Operand = Result;
   using Base = Operation<LogicalOperation, Result, Operand, Operand>;
   CLASS_BOILERPLATE(LogicalOperation)
   LogicalOperation(
       LogicalOperator opr, const Expr<Operand> &x, const Expr<Operand> &y)
-    : Base{x, y}, logicalOperator{opr} {}
+      : Base{x, y}, logicalOperator{opr} {}
   LogicalOperation(LogicalOperator opr, Expr<Operand> &&x, Expr<Operand> &&y)
-    : Base{std::move(x), std::move(y)}, logicalOperator{opr} {}
+      : Base{std::move(x), std::move(y)}, logicalOperator{opr} {}
   LogicalOperator logicalOperator;
 };
 
 // Array constructors
-template<typename RESULT> class ArrayConstructorValues;
+template <typename RESULT> class ArrayConstructorValues;
 
 struct ImpliedDoIndex {
   using Result = SubscriptInteger;
   bool operator==(const ImpliedDoIndex &) const;
   static constexpr int Rank() { return 0; }
-  parser::CharBlock name;  // nested implied DOs must use distinct names
+  parser::CharBlock name; // nested implied DOs must use distinct names
 };
 
-template<typename RESULT> class ImpliedDo {
+template <typename RESULT> class ImpliedDo {
 public:
   using Result = RESULT;
   using Index = ResultType<ImpliedDoIndex>;
   ImpliedDo(parser::CharBlock name, Expr<Index> &&lower, Expr<Index> &&upper,
       Expr<Index> &&stride, ArrayConstructorValues<Result> &&values)
-    : name_{name}, lower_{std::move(lower)}, upper_{std::move(upper)},
-      stride_{std::move(stride)}, values_{std::move(values)} {}
+      : name_{name}, lower_{std::move(lower)}, upper_{std::move(upper)},
+        stride_{std::move(stride)}, values_{std::move(values)} {}
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ImpliedDo)
   bool operator==(const ImpliedDo &) const;
   parser::CharBlock name() const { return name_; }
@@ -407,13 +408,13 @@ template<typename RESULT> class ImpliedDo {
   common::CopyableIndirection<ArrayConstructorValues<Result>> values_;
 };
 
-template<typename RESULT> struct ArrayConstructorValue {
+template <typename RESULT> struct ArrayConstructorValue {
   using Result = RESULT;
   EVALUATE_UNION_CLASS_BOILERPLATE(ArrayConstructorValue)
   std::variant<Expr<Result>, ImpliedDo<Result>> u;
 };
 
-template<typename RESULT> class ArrayConstructorValues {
+template <typename RESULT> class ArrayConstructorValues {
 public:
   using Result = RESULT;
   using Values = std::vector<ArrayConstructorValue<Result>>;
@@ -422,7 +423,7 @@ template<typename RESULT> class ArrayConstructorValues {
 
   bool operator==(const ArrayConstructorValues &) const;
   static constexpr int Rank() { return 1; }
-  template<typename A> common::NoLvalue<A> Push(A &&x) {
+  template <typename A> common::NoLvalue<A> Push(A &&x) {
     values_.emplace_back(std::move(x));
   }
 
@@ -439,31 +440,31 @@ template<typename RESULT> class ArrayConstructorValues {
 // and derived types, since they must carry additional type information,
 // but that an empty ArrayConstructor can be constructed for any type
 // given an expression from which such type information may be gleaned.
-template<typename RESULT>
+template <typename RESULT>
 class ArrayConstructor : public ArrayConstructorValues<RESULT> {
 public:
   using Result = RESULT;
   using Base = ArrayConstructorValues<Result>;
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ArrayConstructor)
   explicit ArrayConstructor(Base &&values) : Base{std::move(values)} {}
-  template<typename T> explicit ArrayConstructor(const Expr<T> &) {}
+  template <typename T> explicit ArrayConstructor(const Expr<T> &) {}
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
-template<int KIND>
+template <int KIND>
 class ArrayConstructor<Type<TypeCategory::Character, KIND>>
-  : public ArrayConstructorValues<Type<TypeCategory::Character, KIND>> {
+    : public ArrayConstructorValues<Type<TypeCategory::Character, KIND>> {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
   using Base = ArrayConstructorValues<Result>;
   CLASS_BOILERPLATE(ArrayConstructor)
   ArrayConstructor(Expr<SubscriptInteger> &&len, Base &&v)
-    : Base{std::move(v)}, length_{std::move(len)} {}
-  template<typename A>
+      : Base{std::move(v)}, length_{std::move(len)} {}
+  template <typename A>
   explicit ArrayConstructor(const A &prototype)
-    : length_{prototype.LEN().value()} {}
+      : length_{prototype.LEN().value()} {}
   bool operator==(const ArrayConstructor &) const;
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
@@ -474,19 +475,19 @@ class ArrayConstructor<Type<TypeCategory::Character, KIND>>
   common::CopyableIndirection<Expr<SubscriptInteger>> length_;
 };
 
-template<>
+template <>
 class ArrayConstructor<SomeDerived>
-  : public ArrayConstructorValues<SomeDerived> {
+    : public ArrayConstructorValues<SomeDerived> {
 public:
   using Result = SomeDerived;
   using Base = ArrayConstructorValues<Result>;
   CLASS_BOILERPLATE(ArrayConstructor)
 
   ArrayConstructor(const semantics::DerivedTypeSpec &spec, Base &&v)
-    : Base{std::move(v)}, result_{spec} {}
-  template<typename A>
+      : Base{std::move(v)}, result_{spec} {}
+  template <typename A>
   explicit ArrayConstructor(const A &prototype)
-    : result_{prototype.GetType().value().GetDerivedTypeSpec()} {}
+      : result_{prototype.GetType().value().GetDerivedTypeSpec()} {}
 
   bool operator==(const ArrayConstructor &) const;
   constexpr Result result() const { return result_; }
@@ -499,9 +500,9 @@ class ArrayConstructor<SomeDerived>
 
 // Expression representations for each type category.
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Integer, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Integer, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Integer, KIND>> {
 public:
   using Result = Type<TypeCategory::Integer, KIND>;
 
@@ -527,9 +528,9 @@ class Expr<Type<TypeCategory::Integer, KIND>>
       u;
 };
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Real, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Real, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Real, KIND>> {
 public:
   using Result = Type<TypeCategory::Real, KIND>;
 
@@ -552,9 +553,9 @@ class Expr<Type<TypeCategory::Real, KIND>>
   common::CombineVariants<Operations, Conversions, Others> u;
 };
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Complex, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Complex, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Complex, KIND>> {
 public:
   using Result = Type<TypeCategory::Complex, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -576,9 +577,9 @@ FOR_EACH_INTEGER_KIND(extern template class Expr, )
 FOR_EACH_REAL_KIND(extern template class Expr, )
 FOR_EACH_COMPLEX_KIND(extern template class Expr, )
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Character, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Character, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Character, KIND>> {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -603,7 +604,7 @@ FOR_EACH_CHARACTER_KIND(extern template class Expr, )
 // addition operator.  Character relations must have the same kind.
 // There are no relations between LOGICAL values.
 
-template<typename T>
+template <typename T>
 struct Relational : public Operation<Relational<T>, LogicalResult, T, T> {
   using Result = LogicalResult;
   using Base = Operation<Relational, LogicalResult, T, T>;
@@ -614,13 +615,13 @@ struct Relational : public Operation<Relational<T>, LogicalResult, T, T> {
   CLASS_BOILERPLATE(Relational)
   Relational(
       RelationalOperator r, const Expr<Operand> &a, const Expr<Operand> &b)
-    : Base{a, b}, opr{r} {}
+      : Base{a, b}, opr{r} {}
   Relational(RelationalOperator r, Expr<Operand> &&a, Expr<Operand> &&b)
-    : Base{std::move(a), std::move(b)}, opr{r} {}
+      : Base{std::move(a), std::move(b)}, opr{r} {}
   RelationalOperator opr;
 };
 
-template<> class Relational<SomeType> {
+template <> class Relational<SomeType> {
   // COMPLEX data are compared piecewise.
   using DirectlyComparableTypes =
       common::CombineTuples<IntegerTypes, RealTypes, CharacterTypes>;
@@ -645,9 +646,9 @@ extern template struct Relational<SomeType>;
 // do not include Relational<> operations as possibilities,
 // since the results of Relationals are always LogicalResult
 // (kind=1).
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Logical, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Logical, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Logical, KIND>> {
 public:
   using Result = Type<TypeCategory::Logical, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -688,7 +689,7 @@ class StructureConstructor {
   using Result = SomeDerived;
 
   explicit StructureConstructor(const semantics::DerivedTypeSpec &spec)
-    : result_{spec} {}
+      : result_{spec} {}
   StructureConstructor(
       const semantics::DerivedTypeSpec &, const StructureConstructorValues &);
   StructureConstructor(
@@ -713,7 +714,7 @@ class StructureConstructor {
     return values_.end();
   }
 
-  const Expr<SomeType> *Find(const Symbol &) const;  // can return null
+  const Expr<SomeType> *Find(const Symbol &) const; // can return null
 
   StructureConstructor &Add(const semantics::Symbol &, Expr<SomeType> &&);
   int Rank() const { return 0; }
@@ -726,7 +727,7 @@ class StructureConstructor {
 };
 
 // An expression whose result has a derived type.
-template<> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
+template <> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
 public:
   using Result = SomeDerived;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -738,7 +739,7 @@ template<> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
 // A polymorphic expression of known intrinsic type category, but dynamic
 // kind, represented as a discriminated union over Expr<Type<CAT, K>>
 // for each supported kind K in the category.
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 class Expr<SomeKind<CAT>> : public ExpressionBase<SomeKind<CAT>> {
 public:
   using Result = SomeKind<CAT>;
@@ -747,7 +748,7 @@ class Expr<SomeKind<CAT>> : public ExpressionBase<SomeKind<CAT>> {
   common::MapTemplate<Expr, CategoryTypes<CAT>> u;
 };
 
-template<> class Expr<SomeCharacter> : public ExpressionBase<SomeCharacter> {
+template <> class Expr<SomeCharacter> : public ExpressionBase<SomeCharacter> {
 public:
   using Result = SomeCharacter;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -780,7 +781,7 @@ using TypelessExpression = std::variant<BOZLiteralConstant, NullPointer,
 
 // A completely generic expression, polymorphic across all of the intrinsic type
 // categories and each of their kinds.
-template<> class Expr<SomeType> : public ExpressionBase<SomeType> {
+template <> class Expr<SomeType> : public ExpressionBase<SomeType> {
 public:
   using Result = SomeType;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -790,20 +791,20 @@ template<> class Expr<SomeType> : public ExpressionBase<SomeType> {
   // its destructor is externalized to reduce redundant default instances.
   ~Expr();
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   explicit Expr(const Expr<Type<CAT, KIND>> &x) : u{Expr<SomeKind<CAT>>{x}} {}
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   explicit Expr(Expr<Type<CAT, KIND>> &&x)
-    : u{Expr<SomeKind<CAT>>{std::move(x)}} {}
+      : u{Expr<SomeKind<CAT>>{std::move(x)}} {}
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   Expr &operator=(const Expr<Type<CAT, KIND>> &x) {
     u = Expr<SomeKind<CAT>>{x};
     return *this;
   }
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   Expr &operator=(Expr<Type<CAT, KIND>> &&x) {
     u = Expr<SomeKind<CAT>>{std::move(x)};
     return *this;
@@ -820,7 +821,7 @@ template<> class Expr<SomeType> : public ExpressionBase<SomeType> {
 class Assignment {
 public:
   Assignment(Expr<SomeType> &&lhs, Expr<SomeType> &&rhs)
-    : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
+      : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
 
   struct Intrinsic {};
   using BoundsSpec = std::vector<Expr<SubscriptInteger>>;
@@ -838,9 +839,9 @@ class Assignment {
 struct GenericExprWrapper {
   GenericExprWrapper() {}
   explicit GenericExprWrapper(std::optional<Expr<SomeType>> &&x)
-    : v{std::move(x)} {}
+      : v{std::move(x)} {}
   ~GenericExprWrapper();
-  std::optional<Expr<SomeType>> v;  // vacant if error
+  std::optional<Expr<SomeType>> v; // vacant if error
 };
 
 // Like GenericExprWrapper but for analyzed assignments
@@ -848,7 +849,7 @@ struct GenericAssignmentWrapper {
   GenericAssignmentWrapper() {}
   explicit GenericAssignmentWrapper(Assignment &&x) : v{std::move(x)} {}
   ~GenericAssignmentWrapper();
-  std::optional<Assignment> v;  // vacant if error
+  std::optional<Assignment> v; // vacant if error
 };
 
 FOR_EACH_CATEGORY_TYPE(extern template class Expr, )
@@ -867,5 +868,5 @@ FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructor, )
   FOR_EACH_TYPE_AND_KIND(template class ExpressionBase, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructorValues, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructor, )
-}
-#endif  // FORTRAN_EVALUATE_EXPRESSION_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_EXPRESSION_H_
diff --git a/include/flang/Evaluate/fold.h b/include/flang/Evaluate/fold.h
index 85e497464508..ae06a9f138e0 100644
--- a/include/flang/Evaluate/fold.h
+++ b/include/flang/Evaluate/fold.h
@@ -28,11 +28,11 @@ using namespace Fortran::parser::literals;
 // be able to extract it.
 // Note the rvalue reference argument: the rewrites are performed in place
 // for efficiency.
-template<typename T> Expr<T> Fold(FoldingContext &context, Expr<T> &&expr) {
+template <typename T> Expr<T> Fold(FoldingContext &context, Expr<T> &&expr) {
   return Expr<T>::Rewrite(context, std::move(expr));
 }
 
-template<typename T>
+template <typename T>
 std::optional<Expr<T>> Fold(
     FoldingContext &context, std::optional<Expr<T>> &&expr) {
   if (expr) {
@@ -46,7 +46,7 @@ std::optional<Expr<T>> Fold(
 // an expression, if it has one.  It returns a pointer, which is
 // const-qualified when the expression is so.  The value can be
 // parenthesized.
-template<typename T, typename EXPR>
+template <typename T, typename EXPR>
 auto UnwrapConstantValue(EXPR &expr) -> common::Constify<Constant<T>, EXPR> * {
   if (auto *c{UnwrapExpr<Constant<T>>(expr)}) {
     return c;
@@ -62,7 +62,7 @@ auto UnwrapConstantValue(EXPR &expr) -> common::Constify<Constant<T>, EXPR> * {
 
 // GetScalarConstantValue() extracts the known scalar constant value of
 // an expression, if it has one.  The value can be parenthesized.
-template<typename T, typename EXPR>
+template <typename T, typename EXPR>
 auto GetScalarConstantValue(const EXPR &expr) -> std::optional<Scalar<T>> {
   if (const Constant<T> *constant{UnwrapConstantValue<T>(expr)}) {
     return constant->GetScalarValue();
@@ -74,7 +74,7 @@ auto GetScalarConstantValue(const EXPR &expr) -> std::optional<Scalar<T>> {
 // When an expression is a constant integer, ToInt64() extracts its value.
 // Ensure that the expression has been folded beforehand when folding might
 // be required.
-template<int KIND>
+template <int KIND>
 std::optional<std::int64_t> ToInt64(
     const Expr<Type<TypeCategory::Integer, KIND>> &expr) {
   if (auto scalar{
@@ -88,7 +88,7 @@ std::optional<std::int64_t> ToInt64(
 std::optional<std::int64_t> ToInt64(const Expr<SomeInteger> &);
 std::optional<std::int64_t> ToInt64(const Expr<SomeType> &);
 
-template<typename A>
+template <typename A>
 std::optional<std::int64_t> ToInt64(const std::optional<A> &x) {
   if (x) {
     return ToInt64(*x);
@@ -96,5 +96,5 @@ std::optional<std::int64_t> ToInt64(const std::optional<A> &x) {
     return std::nullopt;
   }
 }
-}
-#endif  // FORTRAN_EVALUATE_FOLD_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_FOLD_H_
diff --git a/include/flang/Evaluate/formatting.h b/include/flang/Evaluate/formatting.h
index b9f9c2f2e15a..aa82f56107fd 100644
--- a/include/flang/Evaluate/formatting.h
+++ b/include/flang/Evaluate/formatting.h
@@ -26,24 +26,25 @@
 
 namespace Fortran::evaluate {
 
-template<typename A>
+template <typename A>
 auto operator<<(llvm::raw_ostream &o, const A &x) -> decltype(x.AsFortran(o)) {
   return x.AsFortran(o);
 }
 
-template<typename A>
-auto operator<<(llvm::raw_ostream &o, const A &x) -> decltype(o << x.AsFortran()) {
+template <typename A>
+auto operator<<(llvm::raw_ostream &o, const A &x)
+    -> decltype(o << x.AsFortran()) {
   return o << x.AsFortran();
 }
 
-template<typename A, bool COPYABLE>
+template <typename A, bool COPYABLE>
 auto operator<<(
     llvm::raw_ostream &o, const Fortran::common::Indirection<A, COPYABLE> &x)
     -> decltype(o << x.value()) {
   return o << x.value();
 }
 
-template<typename A>
+template <typename A>
 auto operator<<(llvm::raw_ostream &o, const std::optional<A> &x)
     -> decltype(o << *x) {
   if (x) {
@@ -53,5 +54,5 @@ auto operator<<(llvm::raw_ostream &o, const std::optional<A> &x)
   }
   return o;
 }
-}
-#endif  // FORTRAN_EVALUATE_FORMATTING_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_FORMATTING_H_
diff --git a/include/flang/Evaluate/intrinsics-library.h b/include/flang/Evaluate/intrinsics-library.h
index 3e1bf5471c2c..9853bee1ca87 100644
--- a/include/flang/Evaluate/intrinsics-library.h
+++ b/include/flang/Evaluate/intrinsics-library.h
@@ -28,17 +28,17 @@ class FoldingContext;
 
 using TypeCode = unsigned char;
 
-template<typename TR, typename... TA> using FuncPointer = TR (*)(TA...);
+template <typename TR, typename... TA> using FuncPointer = TR (*)(TA...);
 // This specific type signature prevents GCC complaining about function casts.
 using GenericFunctionPointer = void (*)(void);
 
 enum class PassBy { Ref, Val };
-template<typename TA, PassBy Pass = PassBy::Ref> struct ArgumentInfo {
+template <typename TA, PassBy Pass = PassBy::Ref> struct ArgumentInfo {
   using Type = TA;
   static constexpr PassBy pass{Pass};
 };
 
-template<typename TR, typename... ArgInfo> struct Signature {
+template <typename TR, typename... ArgInfo> struct Signature {
   // Note valid template argument are of form
   //<TR, ArgumentInfo<TA, PassBy>...> where TA and TR belong to RuntimeTypes.
   // RuntimeTypes is a type union defined in intrinsics-library-templates.h to
@@ -55,7 +55,7 @@ struct IntrinsicProcedureRuntimeDescription {
   const bool isElemental;
   const GenericFunctionPointer callable;
   // Construct from description using host independent types (RuntimeTypes)
-  template<typename TR, typename... ArgInfo>
+  template <typename TR, typename... ArgInfo>
   IntrinsicProcedureRuntimeDescription(
       const Signature<TR, ArgInfo...> &signature, bool isElemental = false);
 };
@@ -64,19 +64,19 @@ struct IntrinsicProcedureRuntimeDescription {
 // constant folding.
 struct HostRuntimeIntrinsicProcedure : IntrinsicProcedureRuntimeDescription {
   // Construct from runtime pointer with host types (float, double....)
-  template<typename HostTR, typename... HostTA>
+  template <typename HostTR, typename... HostTA>
   HostRuntimeIntrinsicProcedure(const std::string &name,
       FuncPointer<HostTR, HostTA...> func, bool isElemental = false);
   HostRuntimeIntrinsicProcedure(
       const IntrinsicProcedureRuntimeDescription &rteProc,
       GenericFunctionPointer handle)
-    : IntrinsicProcedureRuntimeDescription{rteProc}, handle{handle} {}
+      : IntrinsicProcedureRuntimeDescription{rteProc}, handle{handle} {}
   GenericFunctionPointer handle;
 };
 
 // Defines a wrapper type that indirects calls to host runtime functions.
 // Valid ConstantContainer are Scalar (only for elementals) and Constant.
-template<template<typename> typename ConstantContainer, typename TR,
+template <template <typename> typename ConstantContainer, typename TR,
     typename... TA>
 using HostProcedureWrapper = std::function<ConstantContainer<TR>(
     FoldingContext &, ConstantContainer<TA>...)>;
@@ -95,7 +95,7 @@ class HostIntrinsicProceduresLibrary {
   }
   bool HasEquivalentProcedure(
       const IntrinsicProcedureRuntimeDescription &sym) const;
-  template<template<typename> typename ConstantContainer, typename TR,
+  template <template <typename> typename ConstantContainer, typename TR,
       typename... TA>
   std::optional<HostProcedureWrapper<ConstantContainer, TR, TA...>>
   GetHostProcedureWrapper(const std::string &name) const;
@@ -104,5 +104,5 @@ class HostIntrinsicProceduresLibrary {
   std::multimap<std::string, const HostRuntimeIntrinsicProcedure> procedures_;
 };
 
-}
-#endif  // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_H_
diff --git a/include/flang/Evaluate/intrinsics.h b/include/flang/Evaluate/intrinsics.h
index 2cc523b037e7..fc7963818919 100644
--- a/include/flang/Evaluate/intrinsics.h
+++ b/include/flang/Evaluate/intrinsics.h
@@ -39,7 +39,7 @@ struct CallCharacteristics {
 
 struct SpecificCall {
   SpecificCall(SpecificIntrinsic &&si, ActualArguments &&as)
-    : specificIntrinsic{std::move(si)}, arguments{std::move(as)} {}
+      : specificIntrinsic{std::move(si)}, arguments{std::move(as)} {}
   SpecificIntrinsic specificIntrinsic;
   ActualArguments arguments;
 };
@@ -47,8 +47,8 @@ struct SpecificCall {
 struct SpecificIntrinsicFunctionInterface : public characteristics::Procedure {
   SpecificIntrinsicFunctionInterface(
       characteristics::Procedure &&p, std::string n, bool isRestrictedSpecific)
-    : characteristics::Procedure{std::move(p)}, genericName{n},
-      isRestrictedSpecific{isRestrictedSpecific} {}
+      : characteristics::Procedure{std::move(p)}, genericName{n},
+        isRestrictedSpecific{isRestrictedSpecific} {}
   std::string genericName;
   bool isRestrictedSpecific;
   // N.B. If there are multiple arguments, they all have the same type.
@@ -82,7 +82,7 @@ class IntrinsicProcTable {
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
-  Implementation *impl_{nullptr};  // owning pointer
+  Implementation *impl_{nullptr}; // owning pointer
 };
-}
-#endif  // FORTRAN_EVALUATE_INTRINSICS_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INTRINSICS_H_
diff --git a/include/flang/Evaluate/real.h b/include/flang/Evaluate/real.h
index 43b3aebbac84..3af11d2058fd 100644
--- a/include/flang/Evaluate/real.h
+++ b/include/flang/Evaluate/real.h
@@ -35,7 +35,7 @@ static constexpr std::int64_t ScaledLogBaseTenOfTwo{301029995664};
 // class template must be (or look like) an instance of Integer<>;
 // the second specifies the number of effective bits (binary precision)
 // in the fraction.
-template<typename WORD, int PREC>
+template <typename WORD, int PREC>
 class Real : public common::RealDetails<PREC> {
 public:
   using Word = WORD;
@@ -49,11 +49,11 @@ class Real : public common::RealDetails<PREC> {
 
   static constexpr int bits{Word::bits};
   static_assert(bits >= Details::bits);
-  using Fraction = Integer<binaryPrecision>;  // all bits made explicit
+  using Fraction = Integer<binaryPrecision>; // all bits made explicit
 
-  template<typename W, int P> friend class Real;
+  template <typename W, int P> friend class Real;
 
-  constexpr Real() {}  // +0.0
+  constexpr Real() {} // +0.0
   constexpr Real(const Real &) = default;
   constexpr Real(const Word &bits) : word_{bits} {}
   constexpr Real &operator=(const Real &) = default;
@@ -91,10 +91,10 @@ class Real : public common::RealDetails<PREC> {
     return Exponent() == 0 && !GetSignificand().IsZero();
   }
 
-  constexpr Real ABS() const {  // non-arithmetic, no flags returned
+  constexpr Real ABS() const { // non-arithmetic, no flags returned
     return {word_.IBCLR(bits - 1)};
   }
-  constexpr Real SetSign(bool toNegative) const {  // non-arithmetic
+  constexpr Real SetSign(bool toNegative) const { // non-arithmetic
     if (toNegative) {
       return {word_.IBSET(bits - 1)};
     } else {
@@ -122,7 +122,7 @@ class Real : public common::RealDetails<PREC> {
   ValueWithRealFlags<Real> HYPOT(
       const Real &, Rounding rounding = defaultRounding) const;
 
-  template<typename INT> constexpr INT EXPONENT() const {
+  template <typename INT> constexpr INT EXPONENT() const {
     if (Exponent() == maxExponent) {
       return INT::HUGE();
     } else {
@@ -143,7 +143,7 @@ class Real : public common::RealDetails<PREC> {
   }
   static constexpr Real TINY() {
     Real tiny;
-    tiny.Normalize(false, 1, Fraction::MASKL(1));  // minimum *normal* number
+    tiny.Normalize(false, 1, Fraction::MASKL(1)); // minimum *normal* number
     return tiny;
   }
 
@@ -177,17 +177,17 @@ class Real : public common::RealDetails<PREC> {
     return {infinity};
   }
 
-  template<typename INT>
+  template <typename INT>
   static ValueWithRealFlags<Real> FromInteger(
       const INT &n, Rounding rounding = defaultRounding) {
     bool isNegative{n.IsNegative()};
     INT absN{n};
     if (isNegative) {
-      absN = n.Negate().value;  // overflow is safe to ignore
+      absN = n.Negate().value; // overflow is safe to ignore
     }
     int leadz{absN.LEADZ()};
     if (leadz >= absN.bits) {
-      return {};  // all bits zero -> +0.0
+      return {}; // all bits zero -> +0.0
     }
     ValueWithRealFlags<Real> result;
     int exponent{exponentBias + absN.bits - leadz - 1};
@@ -211,7 +211,7 @@ class Real : public common::RealDetails<PREC> {
       common::RoundingMode = common::RoundingMode::ToZero) const;
 
   // Conversion to an integer (INT(), NINT(), FLOOR(), CEILING())
-  template<typename INT>
+  template <typename INT>
   constexpr ValueWithRealFlags<INT> ToInteger(
       common::RoundingMode mode = common::RoundingMode::ToZero) const {
     ValueWithRealFlags<INT> result;
@@ -226,7 +226,7 @@ class Real : public common::RealDetails<PREC> {
         RealFlag::Overflow, exponent >= exponentBias + result.value.bits);
     result.flags |= intPart.flags;
     int shift{
-        exponent - exponentBias - binaryPrecision + 1};  // positive -> left
+        exponent - exponentBias - binaryPrecision + 1}; // positive -> left
     result.value =
         result.value.ConvertUnsigned(intPart.value.GetFraction().SHIFTR(-shift))
             .value.SHIFTL(shift);
@@ -244,7 +244,7 @@ class Real : public common::RealDetails<PREC> {
     return result;
   }
 
-  template<typename A>
+  template <typename A>
   static ValueWithRealFlags<Real> Convert(
       const A &x, Rounding rounding = defaultRounding) {
     bool isNegative{x.IsNegative()};
@@ -312,10 +312,11 @@ class Real : public common::RealDetails<PREC> {
 
   // Emits a character representation for an equivalent Fortran constant
   // or parenthesized constant expression that produces this value.
-  llvm::raw_ostream &AsFortran(llvm::raw_ostream &, int kind, bool minimal = false) const;
+  llvm::raw_ostream &AsFortran(
+      llvm::raw_ostream &, int kind, bool minimal = false) const;
 
 private:
-  using Significand = Integer<significandBits>;  // no implicit bit
+  using Significand = Integer<significandBits>; // no implicit bit
 
   constexpr Significand GetSignificand() const {
     return Significand::ConvertUnsigned(word_).value;
@@ -361,15 +362,15 @@ class Real : public common::RealDetails<PREC> {
       bool isNegative, int exponent, const Fraction &, Rounding, RoundingBits,
       bool multiply = false);
 
-  Word word_{};  // an Integer<>
+  Word word_{}; // an Integer<>
 };
 
-extern template class Real<Integer<16>, 11>;  // IEEE half format
-extern template class Real<Integer<16>, 8>;  // the "other" half format
-extern template class Real<Integer<32>, 24>;  // IEEE single
-extern template class Real<Integer<64>, 53>;  // IEEE double
-extern template class Real<Integer<80>, 64>;  // 80387 extended precision
-extern template class Real<Integer<128>, 113>;  // IEEE quad
+extern template class Real<Integer<16>, 11>; // IEEE half format
+extern template class Real<Integer<16>, 8>; // the "other" half format
+extern template class Real<Integer<32>, 24>; // IEEE single
+extern template class Real<Integer<64>, 53>; // IEEE double
+extern template class Real<Integer<80>, 64>; // 80387 extended precision
+extern template class Real<Integer<128>, 113>; // IEEE quad
 // N.B. No "double-double" support.
-}
-#endif  // FORTRAN_EVALUATE_REAL_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_REAL_H_
diff --git a/include/flang/Evaluate/rounding-bits.h b/include/flang/Evaluate/rounding-bits.h
index 271d780b923f..7fddaa0fce73 100644
--- a/include/flang/Evaluate/rounding-bits.h
+++ b/include/flang/Evaluate/rounding-bits.h
@@ -19,9 +19,9 @@ class RoundingBits {
 public:
   constexpr RoundingBits(
       bool guard = false, bool round = false, bool sticky = false)
-    : guard_{guard}, round_{round}, sticky_{sticky} {}
+      : guard_{guard}, round_{round}, sticky_{sticky} {}
 
-  template<typename FRACTION>
+  template <typename FRACTION>
   constexpr RoundingBits(const FRACTION &fraction, int rshift) {
     if (rshift > 0 && rshift < fraction.bits + 1) {
       guard_ = fraction.BTEST(rshift - 1);
@@ -76,23 +76,30 @@ class RoundingBits {
   // fraction, given a rounding mode and a summary of the lost bits.
   constexpr bool MustRound(
       Rounding rounding, bool isNegative, bool isOdd) const {
-    bool round{false};  // to dodge bogus g++ warning about missing return
+    bool round{false}; // to dodge bogus g++ warning about missing return
     switch (rounding.mode) {
     case common::RoundingMode::TiesToEven:
       round = guard_ && (round_ | sticky_ | isOdd);
       break;
-    case common::RoundingMode::ToZero: break;
-    case common::RoundingMode::Down: round = isNegative && !empty(); break;
-    case common::RoundingMode::Up: round = !isNegative && !empty(); break;
-    case common::RoundingMode::TiesAwayFromZero: round = guard_; break;
+    case common::RoundingMode::ToZero:
+      break;
+    case common::RoundingMode::Down:
+      round = isNegative && !empty();
+      break;
+    case common::RoundingMode::Up:
+      round = !isNegative && !empty();
+      break;
+    case common::RoundingMode::TiesAwayFromZero:
+      round = guard_;
+      break;
     }
     return round;
   }
 
 private:
-  bool guard_{false};  // 0.5 * ulp (unit in lowest place)
-  bool round_{false};  // 0.25 * ulp
-  bool sticky_{false};  // true if any lesser-valued bit would be set
+  bool guard_{false}; // 0.5 * ulp (unit in lowest place)
+  bool round_{false}; // 0.25 * ulp
+  bool sticky_{false}; // true if any lesser-valued bit would be set
 };
-}
-#endif  // FORTRAN_EVALUATE_ROUNDING_BITS_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_ROUNDING_BITS_H_
diff --git a/include/flang/Evaluate/shape.h b/include/flang/Evaluate/shape.h
index 00724c259b2c..4c46d89e3406 100644
--- a/include/flang/Evaluate/shape.h
+++ b/include/flang/Evaluate/shape.h
@@ -53,7 +53,8 @@ std::optional<ConstantSubscripts> AsConstantExtents(
 
 inline int GetRank(const Shape &s) { return static_cast<int>(s.size()); }
 
-template<typename A> std::optional<Shape> GetShape(FoldingContext &, const A &);
+template <typename A>
+std::optional<Shape> GetShape(FoldingContext &, const A &);
 
 // The dimension argument to these inquiries is zero-based,
 // unlike the DIM= arguments to many intrinsics.
@@ -83,7 +84,7 @@ MaybeExtentExpr GetSize(Shape &&);
 bool ContainsAnyImpliedDoIndex(const ExtentExpr &);
 
 class GetShapeHelper
-  : public AnyTraverse<GetShapeHelper, std::optional<Shape>> {
+    : public AnyTraverse<GetShapeHelper, std::optional<Shape>> {
 public:
   using Result = std::optional<Shape>;
   using Base = AnyTraverse<GetShapeHelper, Result>;
@@ -92,7 +93,7 @@ class GetShapeHelper
 
   Result operator()(const ImpliedDoIndex &) const { return Scalar(); }
   Result operator()(const DescriptorInquiry &) const { return Scalar(); }
-  template<int KIND> Result operator()(const TypeParamInquiry<KIND> &) const {
+  template <int KIND> Result operator()(const TypeParamInquiry<KIND> &) const {
     return Scalar();
   }
   Result operator()(const BOZLiteralConstant &) const { return Scalar(); }
@@ -101,7 +102,7 @@ class GetShapeHelper
   }
   Result operator()(const StructureConstructor &) const { return Scalar(); }
 
-  template<typename T> Result operator()(const Constant<T> &c) const {
+  template <typename T> Result operator()(const Constant<T> &c) const {
     return AsShape(c.SHAPE());
   }
 
@@ -112,11 +113,11 @@ class GetShapeHelper
   Result operator()(const Substring &) const;
   Result operator()(const ProcedureRef &) const;
 
-  template<typename T>
+  template <typename T>
   Result operator()(const ArrayConstructor<T> &aconst) const {
     return Shape{GetArrayConstructorExtent(aconst)};
   }
-  template<typename D, typename R, typename LO, typename RO>
+  template <typename D, typename R, typename LO, typename RO>
   Result operator()(const Operation<D, R, LO, RO> &operation) const {
     if (operation.right().Rank() > 0) {
       return (*this)(operation.right());
@@ -128,7 +129,7 @@ class GetShapeHelper
 private:
   static Result Scalar() { return Shape{}; }
 
-  template<typename T>
+  template <typename T>
   MaybeExtentExpr GetArrayConstructorValueExtent(
       const ArrayConstructorValue<T> &value) const {
     return std::visit(
@@ -159,7 +160,7 @@ class GetShapeHelper
         value.u);
   }
 
-  template<typename T>
+  template <typename T>
   MaybeExtentExpr GetArrayConstructorExtent(
       const ArrayConstructorValues<T> &values) const {
     ExtentExpr result{0};
@@ -176,7 +177,7 @@ class GetShapeHelper
   FoldingContext &context_;
 };
 
-template<typename A>
+template <typename A>
 std::optional<Shape> GetShape(FoldingContext &context, const A &x) {
   return GetShapeHelper{context}(x);
 }
@@ -187,5 +188,5 @@ bool CheckConformance(parser::ContextualMessages &, const Shape &left,
     const Shape &right, const char *leftIs = "left operand",
     const char *rightIs = "right operand");
 
-}
-#endif  // FORTRAN_EVALUATE_SHAPE_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_SHAPE_H_
diff --git a/include/flang/Evaluate/static-data.h b/include/flang/Evaluate/static-data.h
index c588a77beee2..8a12c9893e61 100644
--- a/include/flang/Evaluate/static-data.h
+++ b/include/flang/Evaluate/static-data.h
@@ -78,5 +78,5 @@ class StaticDataObject {
   int itemBytes_{1};
   std::vector<std::uint8_t> data_;
 };
-}
-#endif  // FORTRAN_EVALUATE_STATIC_DATA_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_STATIC_DATA_H_
diff --git a/include/flang/Evaluate/traverse.h b/include/flang/Evaluate/traverse.h
index 23b3d4cf682c..8d70c39513ef 100644
--- a/include/flang/Evaluate/traverse.h
+++ b/include/flang/Evaluate/traverse.h
@@ -41,42 +41,43 @@
 #include <type_traits>
 
 namespace Fortran::evaluate {
-template<typename Visitor, typename Result> class Traverse {
+template <typename Visitor, typename Result> class Traverse {
 public:
   explicit Traverse(Visitor &v) : visitor_{v} {}
 
   // Packaging
-  template<typename A, bool C>
+  template <typename A, bool C>
   Result operator()(const common::Indirection<A, C> &x) const {
     return visitor_(x.value());
   }
-  template<typename A> Result operator()(SymbolRef x) const {
+  template <typename A> Result operator()(SymbolRef x) const {
     return visitor_(*x);
   }
-  template<typename A> Result operator()(const std::unique_ptr<A> &x) const {
+  template <typename A> Result operator()(const std::unique_ptr<A> &x) const {
     return visitor_(x.get());
   }
-  template<typename A> Result operator()(const std::shared_ptr<A> &x) const {
+  template <typename A> Result operator()(const std::shared_ptr<A> &x) const {
     return visitor_(x.get());
   }
-  template<typename A> Result operator()(const A *x) const {
+  template <typename A> Result operator()(const A *x) const {
     if (x) {
       return visitor_(*x);
     } else {
       return visitor_.Default();
     }
   }
-  template<typename A> Result operator()(const std::optional<A> &x) const {
+  template <typename A> Result operator()(const std::optional<A> &x) const {
     if (x) {
       return visitor_(*x);
     } else {
       return visitor_.Default();
     }
   }
-  template<typename... A> Result operator()(const std::variant<A...> &u) const {
+  template <typename... A>
+  Result operator()(const std::variant<A...> &u) const {
     return std::visit(visitor_, u);
   }
-  template<typename A> Result operator()(const std::vector<A> &x) const {
+  template <typename A> Result operator()(const std::vector<A> &x) const {
     return CombineContents(x);
   }
 
@@ -85,7 +86,7 @@ template<typename Visitor, typename Result> class Traverse {
     return visitor_.Default();
   }
   Result operator()(const NullPointer &) const { return visitor_.Default(); }
-  template<typename T> Result operator()(const Constant<T> &x) const {
+  template <typename T> Result operator()(const Constant<T> &x) const {
     if constexpr (T::category == TypeCategory::Derived) {
       std::optional<Result> result;
       for (const StructureConstructorValues &map : x.values()) {
@@ -119,7 +120,7 @@ template<typename Visitor, typename Result> class Traverse {
       return visitor_(x.GetFirstSymbol());
     }
   }
-  template<int KIND> Result operator()(const TypeParamInquiry<KIND> &x) const {
+  template <int KIND> Result operator()(const TypeParamInquiry<KIND> &x) const {
     return visitor_(x.base());
   }
   Result operator()(const Triplet &x) const {
@@ -140,10 +141,10 @@ template<typename Visitor, typename Result> class Traverse {
   Result operator()(const ComplexPart &x) const {
     return visitor_(x.complex());
   }
-  template<typename T> Result operator()(const Designator<T> &x) const {
+  template <typename T> Result operator()(const Designator<T> &x) const {
     return visitor_(x.u);
   }
-  template<typename T> Result operator()(const Variable<T> &x) const {
+  template <typename T> Result operator()(const Variable<T> &x) const {
     return visitor_(x.u);
   }
   Result operator()(const DescriptorInquiry &x) const {
@@ -173,20 +174,20 @@ template<typename Visitor, typename Result> class Traverse {
   Result operator()(const ProcedureRef &x) const {
     return Combine(x.proc(), x.arguments());
   }
-  template<typename T> Result operator()(const FunctionRef<T> &x) const {
+  template <typename T> Result operator()(const FunctionRef<T> &x) const {
     return visitor_(static_cast<const ProcedureRef &>(x));
   }
 
   // Other primaries
-  template<typename T>
+  template <typename T>
   Result operator()(const ArrayConstructorValue<T> &x) const {
     return visitor_(x.u);
   }
-  template<typename T>
+  template <typename T>
   Result operator()(const ArrayConstructorValues<T> &x) const {
     return CombineContents(x);
   }
-  template<typename T> Result operator()(const ImpliedDo<T> &x) const {
+  template <typename T> Result operator()(const ImpliedDo<T> &x) const {
     return Combine(x.lower(), x.upper(), x.stride(), x.values());
   }
   Result operator()(const semantics::ParamValue &x) const {
@@ -207,23 +208,23 @@ template<typename Visitor, typename Result> class Traverse {
   }
 
   // Operations and wrappers
-  template<typename D, typename R, typename O>
+  template <typename D, typename R, typename O>
   Result operator()(const Operation<D, R, O> &op) const {
     return visitor_(op.left());
   }
-  template<typename D, typename R, typename LO, typename RO>
+  template <typename D, typename R, typename LO, typename RO>
   Result operator()(const Operation<D, R, LO, RO> &op) const {
     return Combine(op.left(), op.right());
   }
   Result operator()(const Relational<SomeType> &x) const {
     return visitor_(x.u);
   }
-  template<typename T> Result operator()(const Expr<T> &x) const {
+  template <typename T> Result operator()(const Expr<T> &x) const {
     return visitor_(x.u);
   }
 
 private:
-  template<typename ITER> Result CombineRange(ITER iter, ITER end) const {
+  template <typename ITER> Result CombineRange(ITER iter, ITER end) const {
     if (iter == end) {
       return visitor_.Default();
     } else {
@@ -235,11 +236,11 @@ template<typename Visitor, typename Result> class Traverse {
     }
   }
 
-  template<typename A> Result CombineContents(const A &x) const {
+  template <typename A> Result CombineContents(const A &x) const {
     return CombineRange(x.begin(), x.end());
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   Result Combine(const A &x, const Bs &... ys) const {
     if constexpr (sizeof...(Bs) == 0) {
       return visitor_(x);
@@ -253,7 +254,7 @@ template<typename Visitor, typename Result> class Traverse {
 
 // For validity checks across an expression: if any operator() result is
 // false, so is the overall result.
-template<typename Visitor, bool DefaultValue,
+template <typename Visitor, bool DefaultValue,
     typename Base = Traverse<Visitor, bool>>
 struct AllTraverse : public Base {
   AllTraverse(Visitor &v) : Base{v} {}
@@ -265,7 +266,7 @@ struct AllTraverse : public Base {
 // For searches over an expression: the first operator() result that
 // is truthful is the final result.  Works for Booleans, pointers,
 // and std::optional<>.
-template<typename Visitor, typename Result = bool,
+template <typename Visitor, typename Result = bool,
     typename Base = Traverse<Visitor, Result>>
 struct AnyTraverse : public Base {
   AnyTraverse(Visitor &v) : Base{v} {}
@@ -280,7 +281,8 @@ struct AnyTraverse : public Base {
   }
 };
 
-template<typename Visitor, typename Set, typename Base = Traverse<Visitor, Set>>
+template <typename Visitor, typename Set,
+    typename Base = Traverse<Visitor, Set>>
 struct SetTraverse : public Base {
   SetTraverse(Visitor &v) : Base{v} {}
   using Base::operator();
@@ -298,5 +300,5 @@ struct SetTraverse : public Base {
   }
 };
 
-}
+} // namespace Fortran::evaluate
 #endif
diff --git a/include/flang/Evaluate/type.h b/include/flang/Evaluate/type.h
index 97700f30e29c..93de6242aa30 100644
--- a/include/flang/Evaluate/type.h
+++ b/include/flang/Evaluate/type.h
@@ -37,7 +37,7 @@ class DerivedTypeSpec;
 class ParamValue;
 class Symbol;
 bool IsDescriptor(const Symbol &);
-}
+} // namespace Fortran::semantics
 
 namespace Fortran::evaluate {
 
@@ -45,7 +45,7 @@ using common::TypeCategory;
 
 // Specific intrinsic types are represented by specializations of
 // this class template Type<CATEGORY, KIND>.
-template<TypeCategory CATEGORY, int KIND = 0> class Type;
+template <TypeCategory CATEGORY, int KIND = 0> class Type;
 
 using SubscriptInteger = Type<TypeCategory::Integer, 8>;
 using CInteger = Type<TypeCategory::Integer, 4>;
@@ -65,10 +65,12 @@ static constexpr bool IsValidKindOfIntrinsicType(
   case TypeCategory::Complex:
     return kind == 2 || kind == 3 || kind == 4 || kind == 8 || kind == 10 ||
         kind == 16;
-  case TypeCategory::Character: return kind == 1 || kind == 2 || kind == 4;
+  case TypeCategory::Character:
+    return kind == 1 || kind == 2 || kind == 4;
   case TypeCategory::Logical:
     return kind == 1 || kind == 2 || kind == 4 || kind == 8;
-  default: return false;
+  default:
+    return false;
   }
 }
 
@@ -86,12 +88,12 @@ class DynamicType {
     CHECK(IsValidKindOfIntrinsicType(category_, kind_));
   }
   constexpr DynamicType(int k, const semantics::ParamValue &pv)
-    : category_{TypeCategory::Character}, kind_{k}, charLength_{&pv} {
+      : category_{TypeCategory::Character}, kind_{k}, charLength_{&pv} {
     CHECK(IsValidKindOfIntrinsicType(category_, kind_));
   }
   explicit constexpr DynamicType(
       const semantics::DerivedTypeSpec &dt, bool poly = false)
-    : category_{TypeCategory::Derived}, derived_{&dt} {
+      : category_{TypeCategory::Derived}, derived_{&dt} {
     if (poly) {
       kind_ = ClassKind;
     }
@@ -113,7 +115,7 @@ class DynamicType {
     result.category_ = TypeCategory::Derived;
     result.kind_ = ClassKind;
     result.derived_ = nullptr;
-    return result;  // CLASS(*)
+    return result; // CLASS(*)
   }
 
   static constexpr DynamicType AssumedType() {
@@ -121,7 +123,7 @@ class DynamicType {
     result.category_ = TypeCategory::Derived;
     result.kind_ = AssumedTypeKind;
     result.derived_ = nullptr;
-    return result;  // TYPE(*)
+    return result; // TYPE(*)
   }
 
   // Comparison is deep -- type parameters are compared independently.
@@ -145,13 +147,13 @@ class DynamicType {
   bool IsAssumedLengthCharacter() const;
   bool IsUnknownLengthCharacter() const;
   bool IsTypelessIntrinsicArgument() const;
-  constexpr bool IsAssumedType() const {  // TYPE(*)
+  constexpr bool IsAssumedType() const { // TYPE(*)
     return kind_ == AssumedTypeKind;
   }
-  constexpr bool IsPolymorphic() const {  // TYPE(*) or CLASS()
+  constexpr bool IsPolymorphic() const { // TYPE(*) or CLASS()
     return kind_ == ClassKind || IsAssumedType();
   }
-  constexpr bool IsUnlimitedPolymorphic() const {  // TYPE(*) or CLASS(*)
+  constexpr bool IsUnlimitedPolymorphic() const { // TYPE(*) or CLASS(*)
     return IsPolymorphic() && !derived_;
   }
   constexpr const semantics::DerivedTypeSpec &GetDerivedTypeSpec() const {
@@ -174,17 +176,17 @@ class DynamicType {
   static std::optional<DynamicType> From(const semantics::DeclTypeSpec &);
   static std::optional<DynamicType> From(const semantics::Symbol &);
 
-  template<typename A> static std::optional<DynamicType> From(const A &x) {
+  template <typename A> static std::optional<DynamicType> From(const A &x) {
     return x.GetType();
   }
-  template<typename A> static std::optional<DynamicType> From(const A *p) {
+  template <typename A> static std::optional<DynamicType> From(const A *p) {
     if (!p) {
       return std::nullopt;
     } else {
       return From(*p);
     }
   }
-  template<typename A>
+  template <typename A>
   static std::optional<DynamicType> From(const std::optional<A> &x) {
     if (x) {
       return From(*x);
@@ -196,17 +198,17 @@ class DynamicType {
 private:
   // Special kind codes are used to distinguish the following Fortran types.
   enum SpecialKind {
-    TypelessKind = -1,  // BOZ actual argument to intrinsic function
-    ClassKind = -2,  // CLASS(T) or CLASS(*)
-    AssumedTypeKind = -3,  // TYPE(*)
+    TypelessKind = -1, // BOZ actual argument to intrinsic function
+    ClassKind = -2, // CLASS(T) or CLASS(*)
+    AssumedTypeKind = -3, // TYPE(*)
   };
 
   constexpr DynamicType() {}
 
-  TypeCategory category_{TypeCategory::Derived};  // overridable default
+  TypeCategory category_{TypeCategory::Derived}; // overridable default
   int kind_{0};
   const semantics::ParamValue *charLength_{nullptr};
-  const semantics::DerivedTypeSpec *derived_{nullptr};  // TYPE(T), CLASS(T)
+  const semantics::DerivedTypeSpec *derived_{nullptr}; // TYPE(T), CLASS(T)
 };
 
 // Return the DerivedTypeSpec of a DynamicType if it has one.
@@ -216,7 +218,7 @@ const semantics::DerivedTypeSpec *GetDerivedTypeSpec(
 
 std::string DerivedTypeSpecAsFortran(const semantics::DerivedTypeSpec &);
 
-template<TypeCategory CATEGORY, int KIND = 0> struct TypeBase {
+template <TypeCategory CATEGORY, int KIND = 0> struct TypeBase {
   static constexpr TypeCategory category{CATEGORY};
   static constexpr int kind{KIND};
   constexpr bool operator==(const TypeBase &) const { return true; }
@@ -224,15 +226,15 @@ template<TypeCategory CATEGORY, int KIND = 0> struct TypeBase {
   static std::string AsFortran() { return GetType().AsFortran(); }
 };
 
-template<int KIND>
+template <int KIND>
 class Type<TypeCategory::Integer, KIND>
-  : public TypeBase<TypeCategory::Integer, KIND> {
+    : public TypeBase<TypeCategory::Integer, KIND> {
 public:
   using Scalar = value::Integer<8 * KIND>;
 };
 
 // REAL(KIND=2) is IEEE half-precision (16 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 2> : public TypeBase<TypeCategory::Real, 2> {
 public:
   using Scalar =
@@ -241,7 +243,7 @@ class Type<TypeCategory::Real, 2> : public TypeBase<TypeCategory::Real, 2> {
 
 // REAL(KIND=3) identifies the "other" half-precision format, which is
 // basically REAL(4) without its least-order 16 fraction bits.
-template<>
+template <>
 class Type<TypeCategory::Real, 3> : public TypeBase<TypeCategory::Real, 3> {
 public:
   using Scalar =
@@ -249,7 +251,7 @@ class Type<TypeCategory::Real, 3> : public TypeBase<TypeCategory::Real, 3> {
 };
 
 // REAL(KIND=4) is IEEE-754 single precision (32 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 4> : public TypeBase<TypeCategory::Real, 4> {
 public:
   using Scalar =
@@ -257,7 +259,7 @@ class Type<TypeCategory::Real, 4> : public TypeBase<TypeCategory::Real, 4> {
 };
 
 // REAL(KIND=8) is IEEE double precision (64 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 8> : public TypeBase<TypeCategory::Real, 8> {
 public:
   using Scalar =
@@ -265,52 +267,52 @@ class Type<TypeCategory::Real, 8> : public TypeBase<TypeCategory::Real, 8> {
 };
 
 // REAL(KIND=10) is x87 FPU extended precision (80 bits, all explicit)
-template<>
+template <>
 class Type<TypeCategory::Real, 10> : public TypeBase<TypeCategory::Real, 10> {
 public:
   using Scalar = value::Real<value::Integer<80>, 64>;
 };
 
 // REAL(KIND=16) is IEEE quad precision (128 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 16> : public TypeBase<TypeCategory::Real, 16> {
 public:
   using Scalar = value::Real<value::Integer<128>, 113>;
 };
 
 // The KIND type parameter on COMPLEX is the kind of each of its components.
-template<int KIND>
+template <int KIND>
 class Type<TypeCategory::Complex, KIND>
-  : public TypeBase<TypeCategory::Complex, KIND> {
+    : public TypeBase<TypeCategory::Complex, KIND> {
 public:
   using Part = Type<TypeCategory::Real, KIND>;
   using Scalar = value::Complex<typename Part::Scalar>;
 };
 
-template<>
+template <>
 class Type<TypeCategory::Character, 1>
-  : public TypeBase<TypeCategory::Character, 1> {
+    : public TypeBase<TypeCategory::Character, 1> {
 public:
   using Scalar = std::string;
 };
 
-template<>
+template <>
 class Type<TypeCategory::Character, 2>
-  : public TypeBase<TypeCategory::Character, 2> {
+    : public TypeBase<TypeCategory::Character, 2> {
 public:
   using Scalar = std::u16string;
 };
 
-template<>
+template <>
 class Type<TypeCategory::Character, 4>
-  : public TypeBase<TypeCategory::Character, 4> {
+    : public TypeBase<TypeCategory::Character, 4> {
 public:
   using Scalar = std::u32string;
 };
 
-template<int KIND>
+template <int KIND>
 class Type<TypeCategory::Logical, KIND>
-  : public TypeBase<TypeCategory::Logical, KIND> {
+    : public TypeBase<TypeCategory::Logical, KIND> {
 public:
   using Scalar = value::Logical<8 * KIND>;
 };
@@ -318,7 +320,7 @@ class Type<TypeCategory::Logical, KIND>
 // Type functions
 
 // Given a specific type, find the type of the same kind in another category.
-template<TypeCategory CATEGORY, typename T>
+template <TypeCategory CATEGORY, typename T>
 using SameKind = Type<CATEGORY, std::decay_t<T>::kind>;
 
 // Many expressions, including subscripts, CHARACTER lengths, array bounds,
@@ -329,16 +331,16 @@ using IndirectSubscriptIntegerExpr =
 // For each intrinsic type category CAT, CategoryTypes<CAT> is an instantiation
 // of std::tuple<Type<CAT, K>> that comprises every kind value K in that
 // category that could possibly be supported on any target.
-template<TypeCategory CATEGORY, int KIND>
+template <TypeCategory CATEGORY, int KIND>
 using CategoryKindTuple =
     std::conditional_t<IsValidKindOfIntrinsicType(CATEGORY, KIND),
         std::tuple<Type<CATEGORY, KIND>>, std::tuple<>>;
 
-template<TypeCategory CATEGORY, int... KINDS>
+template <TypeCategory CATEGORY, int... KINDS>
 using CategoryTypesHelper =
     common::CombineTuples<CategoryKindTuple<CATEGORY, KINDS>...>;
 
-template<TypeCategory CATEGORY>
+template <TypeCategory CATEGORY>
 using CategoryTypes = CategoryTypesHelper<CATEGORY, 1, 2, 3, 4, 8, 10, 16, 32>;
 
 using IntegerTypes = CategoryTypes<TypeCategory::Integer>;
@@ -355,18 +357,18 @@ using LengthlessIntrinsicTypes =
     common::CombineTuples<NumericTypes, LogicalTypes>;
 
 // Predicates: does a type represent a specific intrinsic type?
-template<typename T>
+template <typename T>
 constexpr bool IsSpecificIntrinsicType{common::HasMember<T, AllIntrinsicTypes>};
 
 // Predicate: is a type an intrinsic type that is completely characterized
 // by its category and kind parameter value, or might it have a derived type
 // &/or a length type parameter?
-template<typename T>
+template <typename T>
 constexpr bool IsLengthlessIntrinsicType{
     common::HasMember<T, LengthlessIntrinsicTypes>};
 
 // Represents a type of any supported kind within a particular category.
-template<TypeCategory CATEGORY> struct SomeKind {
+template <TypeCategory CATEGORY> struct SomeKind {
   static constexpr TypeCategory category{CATEGORY};
   constexpr bool operator==(const SomeKind &) const { return true; }
 };
@@ -384,16 +386,16 @@ struct SomeType {};
 class StructureConstructor;
 
 // Represents any derived type, polymorphic or not, as well as CLASS(*).
-template<> class SomeKind<TypeCategory::Derived> {
+template <> class SomeKind<TypeCategory::Derived> {
 public:
   static constexpr TypeCategory category{TypeCategory::Derived};
   using Scalar = StructureConstructor;
 
-  constexpr SomeKind() {}  // CLASS(*)
+  constexpr SomeKind() {} // CLASS(*)
   constexpr explicit SomeKind(const semantics::DerivedTypeSpec &dts)
-    : derivedTypeSpec_{&dts} {}
+      : derivedTypeSpec_{&dts} {}
   constexpr explicit SomeKind(const DynamicType &dt)
-    : SomeKind(dt.GetDerivedTypeSpec()) {}
+      : SomeKind(dt.GetDerivedTypeSpec()) {}
   CONSTEXPR_CONSTRUCTORS_AND_ASSIGNMENTS(SomeKind)
 
   bool IsUnlimitedPolymorphic() const { return !derivedTypeSpec_; }
@@ -427,13 +429,13 @@ using SomeCategory = std::tuple<SomeInteger, SomeReal, SomeComplex,
 using AllTypes =
     common::CombineTuples<AllIntrinsicTypes, std::tuple<SomeDerived>>;
 
-template<typename T> using Scalar = typename std::decay_t<T>::Scalar;
+template <typename T> using Scalar = typename std::decay_t<T>::Scalar;
 
 // When Scalar<T> is S, then TypeOf<S> is T.
 // TypeOf is implemented by scanning all supported types for a match
 // with Type<T>::Scalar.
-template<typename CONST> struct TypeOfHelper {
-  template<typename T> struct Predicate {
+template <typename CONST> struct TypeOfHelper {
+  template <typename T> struct Predicate {
     static constexpr bool value() {
       return std::is_same_v<std::decay_t<CONST>,
           std::decay_t<typename T::Scalar>>;
@@ -445,7 +447,7 @@ template<typename CONST> struct TypeOfHelper {
       std::tuple_element_t<index, AllIntrinsicTypes>, void>;
 };
 
-template<typename CONST> using TypeOf = typename TypeOfHelper<CONST>::type;
+template <typename CONST> using TypeOf = typename TypeOfHelper<CONST>::type;
 
 int SelectedCharKind(const std::string &, int defaultKind);
 int SelectedIntKind(std::int64_t precision = 0);
@@ -511,5 +513,5 @@ bool IsKindTypeParameter(const semantics::Symbol &);
 #define FOR_EACH_TYPE_AND_KIND(PREFIX, SUFFIX) \
   FOR_EACH_INTRINSIC_KIND(PREFIX, SUFFIX) \
   FOR_EACH_CATEGORY_TYPE(PREFIX, SUFFIX)
-}
-#endif  // FORTRAN_EVALUATE_TYPE_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_TYPE_H_
diff --git a/include/flang/Evaluate/variable.h b/include/flang/Evaluate/variable.h
index 0004b0a9c636..d9345fbb9111 100644
--- a/include/flang/Evaluate/variable.h
+++ b/include/flang/Evaluate/variable.h
@@ -44,7 +44,7 @@ using SymbolVector = std::vector<SymbolRef>;
 
 // Forward declarations
 struct DataRef;
-template<typename T> struct Variable;
+template <typename T> struct Variable;
 
 // Reference a base object in memory.  This can be a Fortran symbol,
 // static data (e.g., CHARACTER literal), or compiler-created temporary.
@@ -76,7 +76,7 @@ class Component {
   Component(const DataRef &b, const Symbol &c) : base_{b}, symbol_{c} {}
   Component(DataRef &&b, const Symbol &c) : base_{std::move(b)}, symbol_{c} {}
   Component(common::CopyableIndirection<DataRef> &&b, const Symbol &c)
-    : base_{std::move(b)}, symbol_{c} {}
+      : base_{std::move(b)}, symbol_{c} {}
 
   const DataRef &base() const { return base_.value(); }
   DataRef &base() { return base_.value(); }
@@ -107,7 +107,7 @@ class NamedEntity {
   const Symbol &GetLastSymbol() const;
   const Component &GetComponent() const { return std::get<Component>(u_); }
   Component &GetComponent() { return std::get<Component>(u_); }
-  const Component *UnwrapComponent() const;  // null if just a Symbol
+  const Component *UnwrapComponent() const; // null if just a Symbol
   Component *UnwrapComponent();
 
   int Rank() const;
@@ -128,20 +128,20 @@ class NamedEntity {
 // KIND(x), which is then folded to a constant value.
 // "Bare" type parameter references within a derived type definition do
 // not have base objects.
-template<int KIND> class TypeParamInquiry {
+template <int KIND> class TypeParamInquiry {
 public:
   using Result = Type<TypeCategory::Integer, KIND>;
   CLASS_BOILERPLATE(TypeParamInquiry)
   TypeParamInquiry(NamedEntity &&x, const Symbol &param)
-    : base_{std::move(x)}, parameter_{param} {}
+      : base_{std::move(x)}, parameter_{param} {}
   TypeParamInquiry(std::optional<NamedEntity> &&x, const Symbol &param)
-    : base_{std::move(x)}, parameter_{param} {}
+      : base_{std::move(x)}, parameter_{param} {}
 
   const std::optional<NamedEntity> &base() const { return base_; }
   std::optional<NamedEntity> &base() { return base_; }
   const Symbol &parameter() const { return parameter_; }
 
-  static constexpr int Rank() { return 0; }  // always scalar
+  static constexpr int Rank() { return 0; } // always scalar
   bool operator==(const TypeParamInquiry &) const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
@@ -166,7 +166,7 @@ class Triplet {
   Triplet &set_lower(Expr<SubscriptInteger> &&);
   std::optional<Expr<SubscriptInteger>> upper() const;
   Triplet &set_upper(Expr<SubscriptInteger> &&);
-  Expr<SubscriptInteger> stride() const;  // N.B. result is not optional<>
+  Expr<SubscriptInteger> stride() const; // N.B. result is not optional<>
   Triplet &set_stride(Expr<SubscriptInteger> &&);
 
   bool operator==(const Triplet &) const;
@@ -182,7 +182,7 @@ class Triplet {
 struct Subscript {
   EVALUATE_UNION_CLASS_BOILERPLATE(Subscript)
   explicit Subscript(Expr<SubscriptInteger> &&s)
-    : u{IndirectSubscriptIntegerExpr::Make(std::move(s))} {}
+      : u{IndirectSubscriptIntegerExpr::Make(std::move(s))} {}
   int Rank() const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   std::variant<IndirectSubscriptIntegerExpr, Triplet> u;
@@ -197,11 +197,11 @@ class ArrayRef {
 public:
   CLASS_BOILERPLATE(ArrayRef)
   ArrayRef(const Symbol &symbol, std::vector<Subscript> &&ss)
-    : base_{symbol}, subscript_(std::move(ss)) {}
+      : base_{symbol}, subscript_(std::move(ss)) {}
   ArrayRef(Component &&c, std::vector<Subscript> &&ss)
-    : base_{std::move(c)}, subscript_(std::move(ss)) {}
+      : base_{std::move(c)}, subscript_(std::move(ss)) {}
   ArrayRef(NamedEntity &&base, std::vector<Subscript> &&ss)
-    : base_{std::move(base)}, subscript_(std::move(ss)) {}
+      : base_{std::move(base)}, subscript_(std::move(ss)) {}
 
   NamedEntity &base() { return base_; }
   const NamedEntity &base() const { return base_; }
@@ -211,7 +211,7 @@ class ArrayRef {
   int size() const { return static_cast<int>(subscript_.size()); }
   Subscript &at(int n) { return subscript_.at(n); }
   const Subscript &at(int n) const { return subscript_.at(n); }
-  template<typename A> common::IfNoLvalue<Subscript &, A> emplace_back(A &&x) {
+  template <typename A> common::IfNoLvalue<Subscript &, A> emplace_back(A &&x) {
     return subscript_.emplace_back(std::move(x));
   }
 
@@ -275,7 +275,7 @@ class CoarrayRef {
   std::vector<Subscript> subscript_;
   std::vector<Expr<SubscriptInteger>> cosubscript_;
   std::optional<common::CopyableIndirection<Expr<SomeInteger>>> stat_, team_;
-  bool teamIsTeamNumber_{false};  // false: TEAM=, true: TEAM_NUMBER=
+  bool teamIsTeamNumber_{false}; // false: TEAM=, true: TEAM_NUMBER=
 };
 
 // R911 data-ref is defined syntactically as a series of part-refs, which
@@ -305,13 +305,13 @@ class Substring {
   CLASS_BOILERPLATE(Substring)
   Substring(DataRef &&parent, std::optional<Expr<SubscriptInteger>> &&lower,
       std::optional<Expr<SubscriptInteger>> &&upper)
-    : parent_{std::move(parent)} {
+      : parent_{std::move(parent)} {
     SetBounds(lower, upper);
   }
   Substring(StaticDataObject::Pointer &&parent,
       std::optional<Expr<SubscriptInteger>> &&lower,
       std::optional<Expr<SubscriptInteger>> &&upper)
-    : parent_{std::move(parent)} {
+      : parent_{std::move(parent)} {
     SetBounds(lower, upper);
   }
 
@@ -323,7 +323,7 @@ class Substring {
   Parent &parent() { return parent_; }
 
   int Rank() const;
-  template<typename A> const A *GetParentIf() const {
+  template <typename A> const A *GetParentIf() const {
     return std::get_if<A>(&parent_);
   }
   BaseObject GetBaseObject() const;
@@ -366,7 +366,7 @@ class ComplexPart {
 // calls to pointer-valued functions.  Its variant holds everything that
 // a DataRef can, and possibly also a substring reference or a
 // complex component (%RE/%IM) reference.
-template<typename T> class Designator {
+template <typename T> class Designator {
   using DataRefs = std::decay_t<decltype(DataRef::u)>;
   using MaybeSubstring =
       std::conditional_t<T::category == TypeCategory::Character,
@@ -383,7 +383,7 @@ template<typename T> class Designator {
   EVALUATE_UNION_CLASS_BOILERPLATE(Designator)
   Designator(const DataRef &that) : u{common::CopyVariant<Variant>(that.u)} {}
   Designator(DataRef &&that)
-    : u{common::MoveVariant<Variant>(std::move(that.u))} {}
+      : u{common::MoveVariant<Variant>(std::move(that.u))} {}
 
   std::optional<DynamicType> GetType() const;
   int Rank() const;
@@ -397,7 +397,7 @@ template<typename T> class Designator {
 
 FOR_EACH_CHARACTER_KIND(extern template class Designator, )
 
-template<typename T> struct Variable {
+template <typename T> struct Variable {
   using Result = T;
   static_assert(IsSpecificIntrinsicType<Result> ||
       std::is_same_v<Result, SomeKind<TypeCategory::Derived>>);
@@ -429,19 +429,19 @@ class DescriptorInquiry {
   Field field() const { return field_; }
   int dimension() const { return dimension_; }
 
-  static constexpr int Rank() { return 0; }  // always scalar
+  static constexpr int Rank() { return 0; } // always scalar
   bool operator==(const DescriptorInquiry &) const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   NamedEntity base_;
   Field field_;
-  int dimension_{0};  // zero-based
+  int dimension_{0}; // zero-based
 };
 
 #define INSTANTIATE_VARIABLE_TEMPLATES \
   EXPAND_FOR_EACH_INTEGER_KIND( \
       TEMPLATE_INSTANTIATION, template class TypeParamInquiry, ) \
   FOR_EACH_SPECIFIC_TYPE(template class Designator, )
-}
-#endif  // FORTRAN_EVALUATE_VARIABLE_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_VARIABLE_H_
diff --git a/include/flang/ISO_Fortran_binding.h b/include/flang/ISO_Fortran_binding.h
index b54f778fdec8..dca063fe5cf5 100644
--- a/include/flang/ISO_Fortran_binding.h
+++ b/include/flang/ISO_Fortran_binding.h
@@ -80,7 +80,7 @@ typedef signed char CFI_type_t;
 #define CFI_type_char 32
 #define CFI_type_cptr 33
 #define CFI_type_struct 34
-#define CFI_type_other (-1)  // must be negative
+#define CFI_type_other (-1) // must be negative
 
 /* Error code macros */
 #define CFI_SUCCESS 0 /* must be zero */
@@ -108,13 +108,13 @@ namespace cfi_internal {
 // The below structure emulates a flexible array. This structure does not take
 // care of getting the memory storage. Note that it already contains one element
 // because a struct cannot be empty.
-template<typename T> struct FlexibleArray : T {
+template <typename T> struct FlexibleArray : T {
   T &operator[](int index) { return *(this + index); }
   const T &operator[](int index) const { return *(this + index); }
   operator T *() { return this; }
   operator const T *() const { return this; }
 };
-}
+} // namespace cfi_internal
 #endif
 
 /* 18.5.3 generic data descriptor */
@@ -139,13 +139,13 @@ typedef struct CFI_cdesc_t {
 // The struct below take care of getting the memory storage for C++ CFI_cdesc_t
 // that contain an emulated flexible array.
 namespace cfi_internal {
-template<int r> struct CdescStorage : public CFI_cdesc_t {
+template <int r> struct CdescStorage : public CFI_cdesc_t {
   static_assert((r > 1 && r <= CFI_MAX_RANK), "CFI_INVALID_RANK");
   CFI_dim_t dim[r - 1];
 };
-template<> struct CdescStorage<1> : public CFI_cdesc_t {};
-template<> struct CdescStorage<0> : public CFI_cdesc_t {};
-}
+template <> struct CdescStorage<1> : public CFI_cdesc_t {};
+template <> struct CdescStorage<0> : public CFI_cdesc_t {};
+} // namespace cfi_internal
 #define CFI_CDESC_T(rank) cfi_internal::CdescStorage<rank>
 #else
 #define CFI_CDESC_T(rank) \
@@ -174,8 +174,8 @@ int CFI_select_part(CFI_cdesc_t *, const CFI_cdesc_t *source,
 int CFI_setpointer(
     CFI_cdesc_t *, const CFI_cdesc_t *source, const CFI_index_t lower_bounds[]);
 #ifdef __cplusplus
-}  // extern "C"
-}  // inline namespace Fortran_2018
+} // extern "C"
+} // inline namespace Fortran_2018
 }
 }
 #endif
diff --git a/include/flang/Parser/char-block.h b/include/flang/Parser/char-block.h
index fd41e14821ce..7c29c9aa41a0 100644
--- a/include/flang/Parser/char-block.h
+++ b/include/flang/Parser/char-block.h
@@ -30,7 +30,7 @@ class CharBlock {
   constexpr CharBlock() {}
   constexpr CharBlock(const char *x, std::size_t n = 1) : interval_{x, n} {}
   constexpr CharBlock(const char *b, const char *ep1)
-    : interval_{b, static_cast<std::size_t>(ep1 - b)} {}
+      : interval_{b, static_cast<std::size_t>(ep1 - b)} {}
   CharBlock(const std::string &s) : interval_{s.data(), s.size()} {}
   constexpr CharBlock(const CharBlock &) = default;
   constexpr CharBlock(CharBlock &&) = default;
@@ -61,7 +61,7 @@ class CharBlock {
         return ch;
       }
     }
-    return ' ';  // non no-blank character
+    return ' '; // non no-blank character
   }
 
   bool IsBlank() const { return FirstNonBlank() == ' '; }
@@ -140,10 +140,10 @@ inline bool operator>(const char *left, const CharBlock &right) {
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharBlock &x);
 
-}
+} // namespace Fortran::parser
 
 // Specializations to enable std::unordered_map<CharBlock, ...> &c.
-template<> struct std::hash<Fortran::parser::CharBlock> {
+template <> struct std::hash<Fortran::parser::CharBlock> {
   std::size_t operator()(const Fortran::parser::CharBlock &x) const {
     std::size_t hash{0}, bytes{x.size()};
     for (std::size_t j{0}; j < bytes; ++j) {
@@ -152,4 +152,4 @@ template<> struct std::hash<Fortran::parser::CharBlock> {
     return hash;
   }
 };
-#endif  // FORTRAN_PARSER_CHAR_BLOCK_H_
+#endif // FORTRAN_PARSER_CHAR_BLOCK_H_
diff --git a/include/flang/Parser/char-buffer.h b/include/flang/Parser/char-buffer.h
index 0df690af3aa7..e61a3fe3427e 100644
--- a/include/flang/Parser/char-buffer.h
+++ b/include/flang/Parser/char-buffer.h
@@ -24,8 +24,8 @@ class CharBuffer {
 public:
   CharBuffer() {}
   CharBuffer(CharBuffer &&that)
-    : blocks_(std::move(that.blocks_)), last_{that.last_}, bytes_{that.bytes_},
-      lastBlockEmpty_{that.lastBlockEmpty_} {
+      : blocks_(std::move(that.blocks_)), last_{that.last_},
+        bytes_{that.bytes_}, lastBlockEmpty_{that.lastBlockEmpty_} {
     that.clear();
   }
   CharBuffer &operator=(CharBuffer &&that) {
@@ -73,5 +73,5 @@ class CharBuffer {
   std::size_t bytes_{0};
   bool lastBlockEmpty_{false};
 };
-}
-#endif  // FORTRAN_PARSER_CHAR_BUFFER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_CHAR_BUFFER_H_
diff --git a/include/flang/Parser/char-set.h b/include/flang/Parser/char-set.h
index 64ff6692b1d1..8fa7be5f2c07 100644
--- a/include/flang/Parser/char-set.h
+++ b/include/flang/Parser/char-set.h
@@ -75,5 +75,5 @@ struct SetOfChars {
   constexpr SetOfChars(std::uint64_t b) : bits_{b} {}
   std::uint64_t bits_{0};
 };
-}
-#endif  // FORTRAN_PARSER_CHAR_SET_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_CHAR_SET_H_
diff --git a/include/flang/Parser/characters.h b/include/flang/Parser/characters.h
index 02b92ba6f047..c18140780956 100644
--- a/include/flang/Parser/characters.h
+++ b/include/flang/Parser/characters.h
@@ -103,33 +103,51 @@ inline constexpr char HexadecimalDigitValue(char ch) {
 
 inline constexpr std::optional<char> BackslashEscapeValue(char ch) {
   switch (ch) {
-  case 'a': return std::nullopt;  // '\a';  PGF90 doesn't know \a
-  case 'b': return '\b';
-  case 'f': return '\f';
-  case 'n': return '\n';
-  case 'r': return '\r';
-  case 't': return '\t';
-  case 'v': return '\v';
+  case 'a':
+    return std::nullopt; // '\a';  PGF90 doesn't know \a
+  case 'b':
+    return '\b';
+  case 'f':
+    return '\f';
+  case 'n':
+    return '\n';
+  case 'r':
+    return '\r';
+  case 't':
+    return '\t';
+  case 'v':
+    return '\v';
   case '"':
   case '\'':
-  case '\\': return ch;
-  default: return std::nullopt;
+  case '\\':
+    return ch;
+  default:
+    return std::nullopt;
   }
 }
 
 inline constexpr std::optional<char> BackslashEscapeChar(char ch) {
   switch (ch) {
-  case '\a': return std::nullopt;  // 'a';  PGF90 doesn't know \a
-  case '\b': return 'b';
-  case '\f': return 'f';
-  case '\n': return 'n';
-  case '\r': return 'r';
-  case '\t': return 't';
-  case '\v': return 'v';
+  case '\a':
+    return std::nullopt; // 'a';  PGF90 doesn't know \a
+  case '\b':
+    return 'b';
+  case '\f':
+    return 'f';
+  case '\n':
+    return 'n';
+  case '\r':
+    return 'r';
+  case '\t':
+    return 't';
+  case '\v':
+    return 'v';
   case '"':
   case '\'':
-  case '\\': return ch;
-  default: return std::nullopt;
+  case '\\':
+    return ch;
+  default:
+    return std::nullopt;
   }
 }
 
@@ -139,13 +157,13 @@ struct EncodedCharacter {
   int bytes{0};
 };
 
-template<Encoding ENCODING> EncodedCharacter EncodeCharacter(char32_t ucs);
-template<> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t);
-template<> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t);
+template <Encoding ENCODING> EncodedCharacter EncodeCharacter(char32_t ucs);
+template <> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t);
+template <> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t);
 
 EncodedCharacter EncodeCharacter(Encoding, char32_t ucs);
 
-template<Encoding ENCODING, typename STRING>
+template <Encoding ENCODING, typename STRING>
 std::string EncodeString(const STRING &);
 extern template std::string EncodeString<Encoding::LATIN_1, std::string>(
     const std::string &);
@@ -154,7 +172,7 @@ extern template std::string EncodeString<Encoding::UTF_8, std::u32string>(
 
 // EmitQuotedChar drives callbacks "emit" and "insert" to output the
 // bytes of an encoding for a codepoint.
-template<typename NORMAL, typename INSERTED>
+template <typename NORMAL, typename INSERTED>
 void EmitQuotedChar(char32_t ch, const NORMAL &emit, const INSERTED &insert,
     bool backslashEscapes = true, Encoding encoding = Encoding::UTF_8) {
   auto emitOneByte{[&](std::uint8_t ch) {
@@ -175,7 +193,7 @@ void EmitQuotedChar(char32_t ch, const NORMAL &emit, const INSERTED &insert,
         insert('0' + ((ch >> 3) & 7));
         insert('0' + (ch & 7));
       }
-    } else if (ch == '\n') {  // always escape newlines
+    } else if (ch == '\n') { // always escape newlines
       insert('\\');
       insert('n');
     } else {
@@ -203,20 +221,20 @@ int UTF_8CharacterBytes(const char *);
 
 struct DecodedCharacter {
   char32_t codepoint{0};
-  int bytes{0};  // signifying failure
+  int bytes{0}; // signifying failure
 };
 
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 DecodedCharacter DecodeRawCharacter(const char *, std::size_t);
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::LATIN_1>(
     const char *, std::size_t);
 
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::UTF_8>(const char *, std::size_t);
 
 // DecodeCharacter optionally handles backslash escape sequences, too.
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 DecodedCharacter DecodeCharacter(
     const char *, std::size_t, bool backslashEscapes);
 extern template DecodedCharacter DecodeCharacter<Encoding::LATIN_1>(
@@ -227,7 +245,7 @@ extern template DecodedCharacter DecodeCharacter<Encoding::UTF_8>(
 DecodedCharacter DecodeCharacter(
     Encoding, const char *, std::size_t, bool backslashEscapes);
 
-template<typename RESULT, Encoding ENCODING>
+template <typename RESULT, Encoding ENCODING>
 RESULT DecodeString(const std::string &, bool backslashEscapes);
 extern template std::string DecodeString<std::string, Encoding::LATIN_1>(
     const std::string &, bool);
@@ -235,5 +253,5 @@ extern template std::u16string DecodeString<std::u16string, Encoding::UTF_8>(
     const std::string &, bool);
 extern template std::u32string DecodeString<std::u32string, Encoding::UTF_8>(
     const std::string &, bool);
-}
-#endif  // FORTRAN_PARSER_CHARACTERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_CHARACTERS_H_
diff --git a/include/flang/Parser/dump-parse-tree.h b/include/flang/Parser/dump-parse-tree.h
index ab678e76af76..774af899de6d 100644
--- a/include/flang/Parser/dump-parse-tree.h
+++ b/include/flang/Parser/dump-parse-tree.h
@@ -23,9 +23,9 @@ namespace Fortran::parser {
 
 // When SHOW_ALL_SOURCE_MEMBERS is defined, HasSource<T>::value is true if T has
 // a member named source
-template<typename T, typename = int> struct HasSource : std::false_type {};
+template <typename T, typename = int> struct HasSource : std::false_type {};
 #ifdef SHOW_ALL_SOURCE_MEMBERS
-template<typename T>
+template <typename T>
 struct HasSource<T, decltype((void)T::source, 0)> : std::true_type {};
 #endif
 
@@ -35,9 +35,9 @@ struct HasSource<T, decltype((void)T::source, 0)> : std::true_type {};
 
 class ParseTreeDumper {
 public:
-  explicit ParseTreeDumper(
-      llvm::raw_ostream &out, const AnalyzedObjectsAsFortran *asFortran = nullptr)
-    : out_(out), asFortran_{asFortran} {}
+  explicit ParseTreeDumper(llvm::raw_ostream &out,
+      const AnalyzedObjectsAsFortran *asFortran = nullptr)
+      : out_(out), asFortran_{asFortran} {}
 
   static constexpr const char *GetNodeName(const char *) { return "char *"; }
 #define NODE_NAME(T, N) \
@@ -682,7 +682,7 @@ class ParseTreeDumper {
 #undef NODE
 #undef NODE_NAME
 
-  template<typename T> bool Pre(const T &x) {
+  template <typename T> bool Pre(const T &x) {
     std::string fortran{AsFortran<T>(x)};
     if (fortran.empty() && (UnionTrait<T> || WrapperTrait<T>)) {
       Prefix(GetNodeName(x));
@@ -698,7 +698,7 @@ class ParseTreeDumper {
     return true;
   }
 
-  template<typename T> void Post(const T &x) {
+  template <typename T> void Post(const T &x) {
     if (AsFortran<T>(x).empty() && (UnionTrait<T> || WrapperTrait<T>)) {
       EndLineIfNonempty();
     } else {
@@ -711,55 +711,57 @@ class ParseTreeDumper {
   bool Pre(const CharBlock &) { return true; }
   void Post(const CharBlock &) {}
 
-  template<typename T> bool Pre(const Statement<T> &) { return true; }
-  template<typename T> void Post(const Statement<T> &) {}
-  template<typename T> bool Pre(const UnlabeledStatement<T> &) { return true; }
-  template<typename T> void Post(const UnlabeledStatement<T> &) {}
+  template <typename T> bool Pre(const Statement<T> &) { return true; }
+  template <typename T> void Post(const Statement<T> &) {}
+  template <typename T> bool Pre(const UnlabeledStatement<T> &) { return true; }
+  template <typename T> void Post(const UnlabeledStatement<T> &) {}
 
-  template<typename T> bool Pre(const common::Indirection<T> &) { return true; }
-  template<typename T> void Post(const common::Indirection<T> &) {}
+  template <typename T> bool Pre(const common::Indirection<T> &) {
+    return true;
+  }
+  template <typename T> void Post(const common::Indirection<T> &) {}
 
-  template<typename A> bool Pre(const Scalar<A> &) {
+  template <typename A> bool Pre(const Scalar<A> &) {
     Prefix("Scalar");
     return true;
   }
-  template<typename A> void Post(const Scalar<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Scalar<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const Constant<A> &) {
+  template <typename A> bool Pre(const Constant<A> &) {
     Prefix("Constant");
     return true;
   }
-  template<typename A> void Post(const Constant<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Constant<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const Integer<A> &) {
+  template <typename A> bool Pre(const Integer<A> &) {
     Prefix("Integer");
     return true;
   }
-  template<typename A> void Post(const Integer<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Integer<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const Logical<A> &) {
+  template <typename A> bool Pre(const Logical<A> &) {
     Prefix("Logical");
     return true;
   }
-  template<typename A> void Post(const Logical<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Logical<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const DefaultChar<A> &) {
+  template <typename A> bool Pre(const DefaultChar<A> &) {
     Prefix("DefaultChar");
     return true;
   }
-  template<typename A> void Post(const DefaultChar<A> &) {
+  template <typename A> void Post(const DefaultChar<A> &) {
     EndLineIfNonempty();
   }
 
-  template<typename... A> bool Pre(const std::tuple<A...> &) { return true; }
-  template<typename... A> void Post(const std::tuple<A...> &) {}
+  template <typename... A> bool Pre(const std::tuple<A...> &) { return true; }
+  template <typename... A> void Post(const std::tuple<A...> &) {}
 
-  template<typename... A> bool Pre(const std::variant<A...> &) { return true; }
-  template<typename... A> void Post(const std::variant<A...> &) {}
+  template <typename... A> bool Pre(const std::variant<A...> &) { return true; }
+  template <typename... A> void Post(const std::variant<A...> &) {}
 
 protected:
   // Return a Fortran representation of this node to include in the dump
-  template<typename T> std::string AsFortran(const T &x) {
+  template <typename T> std::string AsFortran(const T &x) {
     std::string buf;
     llvm::raw_string_ostream ss{buf};
     if constexpr (std::is_same_v<T, Expr>) {
@@ -835,12 +837,12 @@ class ParseTreeDumper {
   bool emptyline_{false};
 };
 
-template<typename T>
+template <typename T>
 void DumpTree(llvm::raw_ostream &out, const T &x,
     const AnalyzedObjectsAsFortran *asFortran = nullptr) {
   ParseTreeDumper dumper{out, asFortran};
   Walk(x, dumper);
 }
 
-}
-#endif  // FORTRAN_PARSER_DUMP_PARSE_TREE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_DUMP_PARSE_TREE_H_
diff --git a/include/flang/Parser/format-specification.h b/include/flang/Parser/format-specification.h
index 872d025b5e61..a34e68af2832 100644
--- a/include/flang/Parser/format-specification.h
+++ b/include/flang/Parser/format-specification.h
@@ -41,12 +41,12 @@ struct IntrinsicTypeDataEditDesc {
   IntrinsicTypeDataEditDesc &operator=(IntrinsicTypeDataEditDesc &&) = default;
   IntrinsicTypeDataEditDesc(Kind &&k, std::optional<int> &&w,
       std::optional<int> &&d, std::optional<int> &&e)
-    : kind{k}, width{std::move(w)}, digits{std::move(d)}, exponentWidth{
-                                                              std::move(e)} {}
+      : kind{k}, width{std::move(w)}, digits{std::move(d)}, exponentWidth{
+                                                                std::move(e)} {}
   Kind kind;
-  std::optional<int> width;  // w
-  std::optional<int> digits;  // m or d
-  std::optional<int> exponentWidth;  // e
+  std::optional<int> width; // w
+  std::optional<int> digits; // m or d
+  std::optional<int> exponentWidth; // e
 };
 
 // R1307 data-edit-desc (part 2 of 2) ->
@@ -57,7 +57,7 @@ struct DerivedTypeDataEditDesc {
   DerivedTypeDataEditDesc(DerivedTypeDataEditDesc &&) = default;
   DerivedTypeDataEditDesc &operator=(DerivedTypeDataEditDesc &&) = default;
   DerivedTypeDataEditDesc(std::string &&t, std::list<std::int64_t> &&p)
-    : type{std::move(t)}, parameters{std::move(p)} {}
+      : type{std::move(t)}, parameters{std::move(p)} {}
   std::string type;
   std::list<std::int64_t> parameters;
 };
@@ -94,8 +94,8 @@ struct ControlEditDesc {
     RP,
     DC,
     DP,
-    Dollar,  // extension: inhibit newline on output
-    Backslash,  // ditto, but only on terminals
+    Dollar, // extension: inhibit newline on output
+    Backslash, // ditto, but only on terminals
   };
   ControlEditDesc() = delete;
   ControlEditDesc(ControlEditDesc &&) = default;
@@ -104,7 +104,7 @@ struct ControlEditDesc {
   ControlEditDesc(Kind k, std::int64_t ct) : kind{k}, count{ct} {}
   ControlEditDesc(std::int64_t ct, Kind k) : kind{k}, count{ct} {}
   Kind kind;
-  std::int64_t count{1};  // r, k, or n
+  std::int64_t count{1}; // r, k, or n
 };
 
 // R1304 format-item ->
@@ -116,10 +116,10 @@ struct FormatItem {
   FormatItem() = delete;
   FormatItem(FormatItem &&) = default;
   FormatItem &operator=(FormatItem &&) = default;
-  template<typename A, typename = common::NoLvalue<A>>
+  template <typename A, typename = common::NoLvalue<A>>
   FormatItem(std::optional<std::uint64_t> &&r, A &&x)
-    : repeatCount{std::move(r)}, u{std::move(x)} {}
-  template<typename A, typename = common::NoLvalue<A>>
+      : repeatCount{std::move(r)}, u{std::move(x)} {}
+  template <typename A, typename = common::NoLvalue<A>>
   explicit FormatItem(A &&x) : u{std::move(x)} {}
   std::optional<std::uint64_t> repeatCount;
   std::variant<IntrinsicTypeDataEditDesc, DerivedTypeDataEditDesc,
@@ -136,10 +136,10 @@ struct FormatSpecification {
   FormatSpecification(FormatSpecification &&) = default;
   FormatSpecification &operator=(FormatSpecification &&) = default;
   explicit FormatSpecification(std::list<FormatItem> &&is)
-    : items(std::move(is)) {}
+      : items(std::move(is)) {}
   FormatSpecification(std::list<FormatItem> &&is, std::list<FormatItem> &&us)
-    : items(std::move(is)), unlimitedItems(std::move(us)) {}
+      : items(std::move(is)), unlimitedItems(std::move(us)) {}
   std::list<FormatItem> items, unlimitedItems;
 };
-}
-#endif  // FORTRAN_PARSER_FORMAT_SPECIFICATION_H_
+} // namespace Fortran::format
+#endif // FORTRAN_PARSER_FORMAT_SPECIFICATION_H_
diff --git a/include/flang/Parser/instrumented-parser.h b/include/flang/Parser/instrumented-parser.h
index 007edbf56d4e..51dbd5f03c17 100644
--- a/include/flang/Parser/instrumented-parser.h
+++ b/include/flang/Parser/instrumented-parser.h
@@ -47,12 +47,12 @@ class ParsingLog {
   std::map<std::size_t, LogForPosition> perPos_;
 };
 
-template<typename PA> class InstrumentedParser {
+template <typename PA> class InstrumentedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr InstrumentedParser(const InstrumentedParser &) = default;
   constexpr InstrumentedParser(const MessageFixedText &tag, const PA &parser)
-    : tag_{tag}, parser_{parser} {}
+      : tag_{tag}, parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if (UserState * ustate{state.userState()}) {
       if (ParsingLog * log{ustate->log()}) {
@@ -75,10 +75,10 @@ template<typename PA> class InstrumentedParser {
   const PA parser_;
 };
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto instrumented(
     const MessageFixedText &tag, const PA &parser) {
   return InstrumentedParser{tag, parser};
 }
-}
-#endif  // FORTRAN_PARSER_INSTRUMENTED_PARSER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_INSTRUMENTED_PARSER_H_
diff --git a/include/flang/Parser/message.h b/include/flang/Parser/message.h
index e38145a7b04b..bc2eed0dedc7 100644
--- a/include/flang/Parser/message.h
+++ b/include/flang/Parser/message.h
@@ -34,7 +34,7 @@ class MessageFixedText {
 public:
   constexpr MessageFixedText(
       const char str[], std::size_t n, bool isFatal = false)
-    : text_{str, n}, isFatal_{isFatal} {}
+      : text_{str, n}, isFatal_{isFatal} {}
   constexpr MessageFixedText(const MessageFixedText &) = default;
   constexpr MessageFixedText(MessageFixedText &&) = default;
   constexpr MessageFixedText &operator=(const MessageFixedText &) = default;
@@ -57,7 +57,7 @@ constexpr MessageFixedText operator""_err_en_US(
     const char str[], std::size_t n) {
   return MessageFixedText{str, n, true /* fatal */};
 }
-}
+} // namespace literals
 
 // The construction of a MessageFormattedText uses a MessageFixedText
 // as a vsnprintf() formatting string that is applied to the
@@ -66,9 +66,9 @@ constexpr MessageFixedText operator""_err_en_US(
 // char pointers that are suitable for '%s' formatting.
 class MessageFormattedText {
 public:
-  template<typename... A>
+  template <typename... A>
   MessageFormattedText(const MessageFixedText &text, A &&... x)
-    : isFatal_{text.isFatal()} {
+      : isFatal_{text.isFatal()} {
     Format(&text, Convert(std::forward<A>(x))...);
   }
   MessageFormattedText(const MessageFormattedText &) = default;
@@ -82,15 +82,15 @@ class MessageFormattedText {
 private:
   void Format(const MessageFixedText *, ...);
 
-  template<typename A> A Convert(const A &x) {
+  template <typename A> A Convert(const A &x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return x;
   }
-  template<typename A> A Convert(A &x) {
+  template <typename A> A Convert(A &x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return x;
   }
-  template<typename A> common::IfNoLvalue<A, A> Convert(A &&x) {
+  template <typename A> common::IfNoLvalue<A, A> Convert(A &&x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return std::move(x);
   }
@@ -103,7 +103,7 @@ class MessageFormattedText {
 
   bool isFatal_{false};
   std::string string_;
-  std::forward_list<std::string> conversions_;  // preserves created strings
+  std::forward_list<std::string> conversions_; // preserves created strings
 };
 
 // Represents a formatted rendition of "expected '%s'"_err_en_US
@@ -146,27 +146,27 @@ class Message : public common::ReferenceCounted<Message> {
   Message &operator=(Message &&) = default;
 
   Message(ProvenanceRange pr, const MessageFixedText &t)
-    : location_{pr}, text_{t} {}
+      : location_{pr}, text_{t} {}
   Message(ProvenanceRange pr, const MessageFormattedText &s)
-    : location_{pr}, text_{s} {}
+      : location_{pr}, text_{s} {}
   Message(ProvenanceRange pr, MessageFormattedText &&s)
-    : location_{pr}, text_{std::move(s)} {}
+      : location_{pr}, text_{std::move(s)} {}
   Message(ProvenanceRange pr, const MessageExpectedText &t)
-    : location_{pr}, text_{t} {}
+      : location_{pr}, text_{t} {}
 
   Message(CharBlock csr, const MessageFixedText &t)
-    : location_{csr}, text_{t} {}
+      : location_{csr}, text_{t} {}
   Message(CharBlock csr, const MessageFormattedText &s)
-    : location_{csr}, text_{s} {}
+      : location_{csr}, text_{s} {}
   Message(CharBlock csr, MessageFormattedText &&s)
-    : location_{csr}, text_{std::move(s)} {}
+      : location_{csr}, text_{std::move(s)} {}
   Message(CharBlock csr, const MessageExpectedText &t)
-    : location_{csr}, text_{t} {}
+      : location_{csr}, text_{t} {}
 
-  template<typename RANGE, typename A, typename... As>
+  template <typename RANGE, typename A, typename... As>
   Message(RANGE r, const MessageFixedText &t, A &&x, As &&... xs)
-    : location_{r}, text_{MessageFormattedText{
-                        t, std::forward<A>(x), std::forward<As>(xs)...}} {}
+      : location_{r}, text_{MessageFormattedText{
+                          t, std::forward<A>(x), std::forward<As>(xs)...}} {}
 
   bool attachmentIsContext() const { return attachmentIsContext_; }
   Reference attachment() const { return attachment_; }
@@ -177,16 +177,16 @@ class Message : public common::ReferenceCounted<Message> {
   }
   Message &Attach(Message *);
   Message &Attach(std::unique_ptr<Message> &&);
-  template<typename... A> Message &Attach(A &&... args) {
-    return Attach(new Message{std::forward<A>(args)...});  // reference-counted
+  template <typename... A> Message &Attach(A &&... args) {
+    return Attach(new Message{std::forward<A>(args)...}); // reference-counted
   }
 
   bool SortBefore(const Message &that) const;
   bool IsFatal() const;
   std::string ToString() const;
   std::optional<ProvenanceRange> GetProvenanceRange(const CookedSource &) const;
-  void Emit(
-      llvm::raw_ostream &, const CookedSource &, bool echoSourceLine = true) const;
+  void Emit(llvm::raw_ostream &, const CookedSource &,
+      bool echoSourceLine = true) const;
 
   // If this Message or any of its attachments locates itself via a CharBlock
   // within a particular CookedSource, replace its location with the
@@ -232,7 +232,7 @@ class Messages {
   bool empty() const { return messages_.empty(); }
   void clear();
 
-  template<typename... A> Message &Say(A &&... args) {
+  template <typename... A> Message &Say(A &&... args) {
     last_ = messages_.emplace_after(last_, std::forward<A>(args)...);
     return *last_;
   }
@@ -272,7 +272,7 @@ class ContextualMessages {
   ContextualMessages(CharBlock at, Messages *m) : at_{at}, messages_{m} {}
   explicit ContextualMessages(Messages *m) : messages_{m} {}
   ContextualMessages(const ContextualMessages &that)
-    : at_{that.at_}, messages_{that.messages_} {}
+      : at_{that.at_}, messages_{that.messages_} {}
 
   CharBlock at() const { return at_; }
   Messages *messages() const { return messages_; }
@@ -296,7 +296,7 @@ class ContextualMessages {
     return common::ScopedSet(messages_, nullptr);
   }
 
-  template<typename... A> Message *Say(CharBlock at, A &&... args) {
+  template <typename... A> Message *Say(CharBlock at, A &&... args) {
     if (messages_ != nullptr) {
       return &messages_->Say(at, std::forward<A>(args)...);
     } else {
@@ -304,7 +304,7 @@ class ContextualMessages {
     }
   }
 
-  template<typename... A> Message *Say(A &&... args) {
+  template <typename... A> Message *Say(A &&... args) {
     return Say(at_, std::forward<A>(args)...);
   }
 
@@ -312,5 +312,5 @@ class ContextualMessages {
   CharBlock at_;
   Messages *messages_{nullptr};
 };
-}
-#endif  // FORTRAN_PARSER_MESSAGE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_MESSAGE_H_
diff --git a/include/flang/Parser/parse-state.h b/include/flang/Parser/parse-state.h
index d0b304f3c73b..c704d6a9ad1b 100644
--- a/include/flang/Parser/parse-state.h
+++ b/include/flang/Parser/parse-state.h
@@ -36,24 +36,24 @@ class ParseState {
 public:
   // TODO: Add a constructor for parsing a normalized module file.
   ParseState(const CookedSource &cooked)
-    : p_{&cooked.data().front()}, limit_{&cooked.data().back() + 1} {}
+      : p_{&cooked.data().front()}, limit_{&cooked.data().back() + 1} {}
   ParseState(const ParseState &that)
-    : p_{that.p_}, limit_{that.limit_}, context_{that.context_},
-      userState_{that.userState_}, inFixedForm_{that.inFixedForm_},
-      anyErrorRecovery_{that.anyErrorRecovery_},
-      anyConformanceViolation_{that.anyConformanceViolation_},
-      deferMessages_{that.deferMessages_},
-      anyDeferredMessages_{that.anyDeferredMessages_},
-      anyTokenMatched_{that.anyTokenMatched_} {}
+      : p_{that.p_}, limit_{that.limit_}, context_{that.context_},
+        userState_{that.userState_}, inFixedForm_{that.inFixedForm_},
+        anyErrorRecovery_{that.anyErrorRecovery_},
+        anyConformanceViolation_{that.anyConformanceViolation_},
+        deferMessages_{that.deferMessages_},
+        anyDeferredMessages_{that.anyDeferredMessages_},
+        anyTokenMatched_{that.anyTokenMatched_} {}
   ParseState(ParseState &&that)
-    : p_{that.p_}, limit_{that.limit_}, messages_{std::move(that.messages_)},
-      context_{std::move(that.context_)}, userState_{that.userState_},
-      inFixedForm_{that.inFixedForm_},
-      anyErrorRecovery_{that.anyErrorRecovery_},
-      anyConformanceViolation_{that.anyConformanceViolation_},
-      deferMessages_{that.deferMessages_},
-      anyDeferredMessages_{that.anyDeferredMessages_},
-      anyTokenMatched_{that.anyTokenMatched_} {}
+      : p_{that.p_}, limit_{that.limit_}, messages_{std::move(that.messages_)},
+        context_{std::move(that.context_)}, userState_{that.userState_},
+        inFixedForm_{that.inFixedForm_},
+        anyErrorRecovery_{that.anyErrorRecovery_},
+        anyConformanceViolation_{that.anyConformanceViolation_},
+        deferMessages_{that.deferMessages_},
+        anyDeferredMessages_{that.anyDeferredMessages_},
+        anyTokenMatched_{that.anyTokenMatched_} {}
   ParseState &operator=(const ParseState &that) {
     p_ = that.p_, limit_ = that.limit_, context_ = that.context_;
     userState_ = that.userState_, inFixedForm_ = that.inFixedForm_;
@@ -121,7 +121,7 @@ class ParseState {
   const char *GetLocation() const { return p_; }
 
   void PushContext(MessageFixedText text) {
-    auto m{new Message{p_, text}};  // reference-counted
+    auto m{new Message{p_, text}}; // reference-counted
     m->SetContext(context_.get());
     context_ = Message::Reference{m};
   }
@@ -131,17 +131,18 @@ class ParseState {
     context_ = context_->attachment();
   }
 
-  template<typename... A> void Say(CharBlock range, A &&... args) {
+  template <typename... A> void Say(CharBlock range, A &&... args) {
     if (deferMessages_) {
       anyDeferredMessages_ = true;
     } else {
       messages_.Say(range, std::forward<A>(args)...).SetContext(context_.get());
     }
   }
-  template<typename... A> void Say(const MessageFixedText &text, A &&... args) {
+  template <typename... A>
+  void Say(const MessageFixedText &text, A &&... args) {
     Say(p_, text, std::forward<A>(args)...);
   }
-  template<typename... A>
+  template <typename... A>
   void Say(const MessageExpectedText &text, A &&... args) {
     Say(p_, text, std::forward<A>(args)...);
   }
@@ -228,5 +229,5 @@ class ParseState {
   // reflected in the copy and move constructors defined at the top of this
   // class definition!
 };
-}
-#endif  // FORTRAN_PARSER_PARSE_STATE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSE_STATE_H_
diff --git a/include/flang/Parser/parse-tree-visitor.h b/include/flang/Parser/parse-tree-visitor.h
index de8e36ba7fd6..179d9c263378 100644
--- a/include/flang/Parser/parse-tree-visitor.h
+++ b/include/flang/Parser/parse-tree-visitor.h
@@ -29,7 +29,7 @@ namespace Fortran::parser {
 
 // Default case for visitation of non-class data members, strings, and
 // any other non-decomposable values.
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A> ||
     std::is_same_v<CharBlock, A>>
 Walk(const A &x, V &visitor) {
@@ -37,7 +37,7 @@ Walk(const A &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A> ||
     std::is_same_v<CharBlock, A>>
 Walk(A &x, M &mutator) {
@@ -46,25 +46,25 @@ Walk(A &x, M &mutator) {
   }
 }
 
-template<typename V> void Walk(const format::ControlEditDesc &, V &);
-template<typename M> void Walk(format::ControlEditDesc &, M &);
-template<typename V> void Walk(const format::DerivedTypeDataEditDesc &, V &);
-template<typename M> void Walk(format::DerivedTypeDataEditDesc &, M &);
-template<typename V> void Walk(const format::FormatItem &, V &);
-template<typename M> void Walk(format::FormatItem &, M &);
-template<typename V> void Walk(const format::FormatSpecification &, V &);
-template<typename M> void Walk(format::FormatSpecification &, M &);
-template<typename V> void Walk(const format::IntrinsicTypeDataEditDesc &, V &);
-template<typename M> void Walk(format::IntrinsicTypeDataEditDesc &, M &);
+template <typename V> void Walk(const format::ControlEditDesc &, V &);
+template <typename M> void Walk(format::ControlEditDesc &, M &);
+template <typename V> void Walk(const format::DerivedTypeDataEditDesc &, V &);
+template <typename M> void Walk(format::DerivedTypeDataEditDesc &, M &);
+template <typename V> void Walk(const format::FormatItem &, V &);
+template <typename M> void Walk(format::FormatItem &, M &);
+template <typename V> void Walk(const format::FormatSpecification &, V &);
+template <typename M> void Walk(format::FormatSpecification &, M &);
+template <typename V> void Walk(const format::IntrinsicTypeDataEditDesc &, V &);
+template <typename M> void Walk(format::IntrinsicTypeDataEditDesc &, M &);
 
 // Traversal of needed STL template classes (optional, list, tuple, variant)
-template<typename T, typename V>
+template <typename T, typename V>
 void Walk(const std::optional<T> &x, V &visitor) {
   if (x) {
     Walk(*x, visitor);
   }
 }
-template<typename T, typename M> void Walk(std::optional<T> &x, M &mutator) {
+template <typename T, typename M> void Walk(std::optional<T> &x, M &mutator) {
   if (x) {
     Walk(*x, mutator);
   }
@@ -72,17 +72,17 @@ template<typename T, typename M> void Walk(std::optional<T> &x, M &mutator) {
 // For most lists, just traverse the elements; but when a list constitutes
 // a Block (i.e., std::list<ExecutionPartConstruct>), also invoke the
 // visitor/mutator on the list itself.
-template<typename T, typename V> void Walk(const std::list<T> &x, V &visitor) {
+template <typename T, typename V> void Walk(const std::list<T> &x, V &visitor) {
   for (const auto &elem : x) {
     Walk(elem, visitor);
   }
 }
-template<typename T, typename M> void Walk(std::list<T> &x, M &mutator) {
+template <typename T, typename M> void Walk(std::list<T> &x, M &mutator) {
   for (auto &elem : x) {
     Walk(elem, mutator);
   }
 }
-template<typename V> void Walk(const Block &x, V &visitor) {
+template <typename V> void Walk(const Block &x, V &visitor) {
   if (visitor.Pre(x)) {
     for (const auto &elem : x) {
       Walk(elem, visitor);
@@ -90,7 +90,7 @@ template<typename V> void Walk(const Block &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Block &x, M &mutator) {
+template <typename M> void Walk(Block &x, M &mutator) {
   if (mutator.Pre(x)) {
     for (auto &elem : x) {
       Walk(elem, mutator);
@@ -98,14 +98,14 @@ template<typename M> void Walk(Block &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<std::size_t I = 0, typename Func, typename T>
+template <std::size_t I = 0, typename Func, typename T>
 void ForEachInTuple(const T &tuple, Func func) {
   func(std::get<I>(tuple));
   if constexpr (I + 1 < std::tuple_size_v<T>) {
     ForEachInTuple<I + 1>(tuple, func);
   }
 }
-template<typename V, typename... A>
+template <typename V, typename... A>
 void Walk(const std::tuple<A...> &x, V &visitor) {
   if (sizeof...(A) > 0) {
     if (visitor.Pre(x)) {
@@ -114,14 +114,15 @@ void Walk(const std::tuple<A...> &x, V &visitor) {
     }
   }
 }
-template<std::size_t I = 0, typename Func, typename T>
+template <std::size_t I = 0, typename Func, typename T>
 void ForEachInTuple(T &tuple, Func func) {
   func(std::get<I>(tuple));
   if constexpr (I + 1 < std::tuple_size_v<T>) {
     ForEachInTuple<I + 1>(tuple, func);
   }
 }
-template<typename M, typename... A> void Walk(std::tuple<A...> &x, M &mutator) {
+template <typename M, typename... A>
+void Walk(std::tuple<A...> &x, M &mutator) {
   if (sizeof...(A) > 0) {
     if (mutator.Pre(x)) {
       ForEachInTuple(x, [&](auto &y) { Walk(y, mutator); });
@@ -129,28 +130,28 @@ template<typename M, typename... A> void Walk(std::tuple<A...> &x, M &mutator) {
     }
   }
 }
-template<typename V, typename... A>
+template <typename V, typename... A>
 void Walk(const std::variant<A...> &x, V &visitor) {
   if (visitor.Pre(x)) {
     std::visit([&](const auto &y) { Walk(y, visitor); }, x);
     visitor.Post(x);
   }
 }
-template<typename M, typename... A>
+template <typename M, typename... A>
 void Walk(std::variant<A...> &x, M &mutator) {
   if (mutator.Pre(x)) {
     std::visit([&](auto &y) { Walk(y, mutator); }, x);
     mutator.Post(x);
   }
 }
-template<typename A, typename B, typename V>
+template <typename A, typename B, typename V>
 void Walk(const std::pair<A, B> &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.first, visitor);
     Walk(x.second, visitor);
   }
 }
-template<typename A, typename B, typename M>
+template <typename A, typename B, typename M>
 void Walk(std::pair<A, B> &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.first, mutator);
@@ -160,27 +161,27 @@ void Walk(std::pair<A, B> &x, M &mutator) {
 
 // Trait-determined traversal of empty, tuple, union, wrapper,
 // and constraint-checking classes.
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<EmptyTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<EmptyTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     mutator.Post(x);
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<TupleTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.t, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<TupleTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.t, mutator);
@@ -188,14 +189,14 @@ std::enable_if_t<TupleTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<UnionTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<UnionTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.u, mutator);
@@ -203,14 +204,14 @@ std::enable_if_t<UnionTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<WrapperTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.v, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<WrapperTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.v, mutator);
@@ -218,14 +219,14 @@ std::enable_if_t<WrapperTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<ConstraintTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.thing, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<ConstraintTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.thing, mutator);
@@ -233,16 +234,16 @@ std::enable_if_t<ConstraintTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename T, typename V>
+template <typename T, typename V>
 void Walk(const common::Indirection<T> &x, V &visitor) {
   Walk(x.value(), visitor);
 }
-template<typename T, typename M>
+template <typename T, typename M>
 void Walk(common::Indirection<T> &x, M &mutator) {
   Walk(x.value(), mutator);
 }
 
-template<typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
+template <typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
   if (visitor.Pre(x)) {
     // N.B. The label, if any, is not visited.
     Walk(x.source, visitor);
@@ -250,7 +251,7 @@ template<typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename T, typename M> void Walk(Statement<T> &x, M &mutator) {
+template <typename T, typename M> void Walk(Statement<T> &x, M &mutator) {
   if (mutator.Pre(x)) {
     // N.B. The label, if any, is not visited.
     Walk(x.source, mutator);
@@ -259,7 +260,7 @@ template<typename T, typename M> void Walk(Statement<T> &x, M &mutator) {
   }
 }
 
-template<typename T, typename V>
+template <typename T, typename V>
 void Walk(const UnlabeledStatement<T> &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
@@ -267,7 +268,7 @@ void Walk(const UnlabeledStatement<T> &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename T, typename M>
+template <typename T, typename M>
 void Walk(UnlabeledStatement<T> &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
@@ -276,48 +277,48 @@ void Walk(UnlabeledStatement<T> &x, M &mutator) {
   }
 }
 
-template<typename V> void Walk(const Name &x, V &visitor) {
+template <typename V> void Walk(const Name &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Name &x, M &mutator) {
+template <typename M> void Walk(Name &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     mutator.Post(x);
   }
 }
 
-template<typename V> void Walk(const AcSpec &x, V &visitor) {
+template <typename V> void Walk(const AcSpec &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.type, visitor);
     Walk(x.values, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(AcSpec &x, M &mutator) {
+template <typename M> void Walk(AcSpec &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.type, mutator);
     Walk(x.values, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const ArrayElement &x, V &visitor) {
+template <typename V> void Walk(const ArrayElement &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.base, visitor);
     Walk(x.subscripts, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(ArrayElement &x, M &mutator) {
+template <typename M> void Walk(ArrayElement &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.base, mutator);
     Walk(x.subscripts, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const CharSelector::LengthAndKind &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.length, visitor);
@@ -325,130 +326,131 @@ void Walk(const CharSelector::LengthAndKind &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CharSelector::LengthAndKind &x, M &mutator) {
+template <typename M> void Walk(CharSelector::LengthAndKind &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.length, mutator);
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CaseValueRange::Range &x, V &visitor) {
+template <typename V> void Walk(const CaseValueRange::Range &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.lower, visitor);
     Walk(x.upper, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CaseValueRange::Range &x, M &mutator) {
+template <typename M> void Walk(CaseValueRange::Range &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.lower, mutator);
     Walk(x.upper, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CoindexedNamedObject &x, V &visitor) {
+template <typename V> void Walk(const CoindexedNamedObject &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.base, visitor);
     Walk(x.imageSelector, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CoindexedNamedObject &x, M &mutator) {
+template <typename M> void Walk(CoindexedNamedObject &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.base, mutator);
     Walk(x.imageSelector, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const DeclarationTypeSpec::Class &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.derived, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(DeclarationTypeSpec::Class &x, M &mutator) {
+template <typename M> void Walk(DeclarationTypeSpec::Class &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.derived, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const DeclarationTypeSpec::Type &x, V &visitor) {
+template <typename V>
+void Walk(const DeclarationTypeSpec::Type &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.derived, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(DeclarationTypeSpec::Type &x, M &mutator) {
+template <typename M> void Walk(DeclarationTypeSpec::Type &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.derived, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const ImportStmt &x, V &visitor) {
+template <typename V> void Walk(const ImportStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.names, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(ImportStmt &x, M &mutator) {
+template <typename M> void Walk(ImportStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.names, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const IntrinsicTypeSpec::Character &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.selector, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Character &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Character &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.selector, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const IntrinsicTypeSpec::Complex &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Complex &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Complex &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const IntrinsicTypeSpec::Logical &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Logical &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Logical &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const IntrinsicTypeSpec::Real &x, V &visitor) {
+template <typename V> void Walk(const IntrinsicTypeSpec::Real &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Real &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Real &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename A, typename B, typename V>
+template <typename A, typename B, typename V>
 void Walk(const LoopBounds<A, B> &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.name, visitor);
@@ -458,7 +460,7 @@ void Walk(const LoopBounds<A, B> &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename A, typename B, typename M>
+template <typename A, typename B, typename M>
 void Walk(LoopBounds<A, B> &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.name, mutator);
@@ -468,61 +470,61 @@ void Walk(LoopBounds<A, B> &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CommonStmt &x, V &visitor) {
+template <typename V> void Walk(const CommonStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.blocks, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CommonStmt &x, M &mutator) {
+template <typename M> void Walk(CommonStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.blocks, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Expr &x, V &visitor) {
+template <typename V> void Walk(const Expr &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Expr &x, M &mutator) {
+template <typename M> void Walk(Expr &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Designator &x, V &visitor) {
+template <typename V> void Walk(const Designator &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Designator &x, M &mutator) {
+template <typename M> void Walk(Designator &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Call &x, V &visitor) {
+template <typename V> void Walk(const Call &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.t, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Call &x, M &mutator) {
+template <typename M> void Walk(Call &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.t, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const PartRef &x, V &visitor) {
+template <typename V> void Walk(const PartRef &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.name, visitor);
     Walk(x.subscripts, visitor);
@@ -530,7 +532,7 @@ template<typename V> void Walk(const PartRef &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(PartRef &x, M &mutator) {
+template <typename M> void Walk(PartRef &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.name, mutator);
     Walk(x.subscripts, mutator);
@@ -538,7 +540,7 @@ template<typename M> void Walk(PartRef &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const ReadStmt &x, V &visitor) {
+template <typename V> void Walk(const ReadStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.iounit, visitor);
     Walk(x.format, visitor);
@@ -547,7 +549,7 @@ template<typename V> void Walk(const ReadStmt &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(ReadStmt &x, M &mutator) {
+template <typename M> void Walk(ReadStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.iounit, mutator);
     Walk(x.format, mutator);
@@ -556,75 +558,76 @@ template<typename M> void Walk(ReadStmt &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const SignedIntLiteralConstant &x, V &visitor) {
+template <typename V> void Walk(const SignedIntLiteralConstant &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.t, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(SignedIntLiteralConstant &x, M &mutator) {
+template <typename M> void Walk(SignedIntLiteralConstant &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.t, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const RealLiteralConstant &x, V &visitor) {
+template <typename V> void Walk(const RealLiteralConstant &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.real, visitor);
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(RealLiteralConstant &x, M &mutator) {
+template <typename M> void Walk(RealLiteralConstant &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.real, mutator);
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const RealLiteralConstant::Real &x, V &visitor) {
+template <typename V>
+void Walk(const RealLiteralConstant::Real &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(RealLiteralConstant::Real &x, M &mutator) {
+template <typename M> void Walk(RealLiteralConstant::Real &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const StructureComponent &x, V &visitor) {
+template <typename V> void Walk(const StructureComponent &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.base, visitor);
     Walk(x.component, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(StructureComponent &x, M &mutator) {
+template <typename M> void Walk(StructureComponent &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.base, mutator);
     Walk(x.component, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Suffix &x, V &visitor) {
+template <typename V> void Walk(const Suffix &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.binding, visitor);
     Walk(x.resultName, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Suffix &x, M &mutator) {
+template <typename M> void Walk(Suffix &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.binding, mutator);
     Walk(x.resultName, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const TypeBoundProcedureStmt::WithInterface &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.interfaceName, visitor);
@@ -633,7 +636,7 @@ void Walk(const TypeBoundProcedureStmt::WithInterface &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(TypeBoundProcedureStmt::WithInterface &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.interfaceName, mutator);
@@ -642,7 +645,7 @@ void Walk(TypeBoundProcedureStmt::WithInterface &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.attributes, visitor);
@@ -650,7 +653,7 @@ void Walk(const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(TypeBoundProcedureStmt::WithoutInterface &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.attributes, mutator);
@@ -658,7 +661,7 @@ void Walk(TypeBoundProcedureStmt::WithoutInterface &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const UseStmt &x, V &visitor) {
+template <typename V> void Walk(const UseStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.nature, visitor);
     Walk(x.moduleName, visitor);
@@ -666,7 +669,7 @@ template<typename V> void Walk(const UseStmt &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(UseStmt &x, M &mutator) {
+template <typename M> void Walk(UseStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.nature, mutator);
     Walk(x.moduleName, mutator);
@@ -674,7 +677,7 @@ template<typename M> void Walk(UseStmt &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const WriteStmt &x, V &visitor) {
+template <typename V> void Walk(const WriteStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.iounit, visitor);
     Walk(x.format, visitor);
@@ -683,7 +686,7 @@ template<typename V> void Walk(const WriteStmt &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(WriteStmt &x, M &mutator) {
+template <typename M> void Walk(WriteStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.iounit, mutator);
     Walk(x.format, mutator);
@@ -692,19 +695,19 @@ template<typename M> void Walk(WriteStmt &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const format::ControlEditDesc &x, V &visitor) {
+template <typename V> void Walk(const format::ControlEditDesc &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::ControlEditDesc &x, M &mutator) {
+template <typename M> void Walk(format::ControlEditDesc &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const format::DerivedTypeDataEditDesc &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.type, visitor);
@@ -712,28 +715,29 @@ void Walk(const format::DerivedTypeDataEditDesc &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::DerivedTypeDataEditDesc &x, M &mutator) {
+template <typename M>
+void Walk(format::DerivedTypeDataEditDesc &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.type, mutator);
     Walk(x.parameters, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const format::FormatItem &x, V &visitor) {
+template <typename V> void Walk(const format::FormatItem &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.repeatCount, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::FormatItem &x, M &mutator) {
+template <typename M> void Walk(format::FormatItem &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.repeatCount, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const format::FormatSpecification &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.items, visitor);
@@ -741,14 +745,14 @@ void Walk(const format::FormatSpecification &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::FormatSpecification &x, M &mutator) {
+template <typename M> void Walk(format::FormatSpecification &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.items, mutator);
     Walk(x.unlimitedItems, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const format::IntrinsicTypeDataEditDesc &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
@@ -758,7 +762,7 @@ void Walk(const format::IntrinsicTypeDataEditDesc &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(format::IntrinsicTypeDataEditDesc &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
@@ -768,21 +772,21 @@ void Walk(format::IntrinsicTypeDataEditDesc &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CompilerDirective &x, V &visitor) {
+template <typename V> void Walk(const CompilerDirective &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CompilerDirective &x, M &mutator) {
+template <typename M> void Walk(CompilerDirective &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const OmpLinearClause::WithModifier &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.modifier, visitor);
@@ -791,7 +795,7 @@ void Walk(const OmpLinearClause::WithModifier &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(OmpLinearClause::WithModifier &x, M &mutator) {
+template <typename M> void Walk(OmpLinearClause::WithModifier &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.modifier, mutator);
     Walk(x.names, mutator);
@@ -799,7 +803,7 @@ template<typename M> void Walk(OmpLinearClause::WithModifier &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const OmpLinearClause::WithoutModifier &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.names, visitor);
@@ -807,7 +811,7 @@ void Walk(const OmpLinearClause::WithoutModifier &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(OmpLinearClause::WithoutModifier &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.names, mutator);
@@ -815,5 +819,5 @@ void Walk(OmpLinearClause::WithoutModifier &x, M &mutator) {
     mutator.Post(x);
   }
 }
-}
-#endif  // FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
diff --git a/include/flang/Parser/parse-tree.h b/include/flang/Parser/parse-tree.h
index 1d93c13cada6..f5f7a18652fc 100644
--- a/include/flang/Parser/parse-tree.h
+++ b/include/flang/Parser/parse-tree.h
@@ -58,15 +58,15 @@ namespace Fortran::semantics {
 class Symbol;
 class DeclTypeSpec;
 class DerivedTypeSpec;
-}
+} // namespace Fortran::semantics
 
 // Expressions in the parse tree have owning pointers that can be set to
 // type-checked generic expression representations by semantic analysis.
 namespace Fortran::evaluate {
-struct GenericExprWrapper;  // forward definition, wraps Expr<SomeType>
-struct GenericAssignmentWrapper;  // forward definition, represent assignment
-class ProcedureRef;  // forward definition, represents a CALL statement
-}
+struct GenericExprWrapper; // forward definition, wraps Expr<SomeType>
+struct GenericAssignmentWrapper; // forward definition, represent assignment
+class ProcedureRef; // forward definition, represents a CALL statement
+} // namespace Fortran::evaluate
 
 // Most non-template classes in this file use these default definitions
 // for their move constructor and move assignment operator=, and disable
@@ -97,7 +97,7 @@ class ProcedureRef;  // forward definition, represents a CALL statement
 // Many classes below simply wrap a std::variant<> discriminated union,
 // which is conventionally named "u".
 #define UNION_CLASS_BOILERPLATE(classname) \
-  template<typename A, typename = common::NoLvalue<A>> \
+  template <typename A, typename = common::NoLvalue<A>> \
   classname(A &&x) : u(std::move(x)) {} \
   using UnionTrait = std::true_type; \
   BOILERPLATE(classname)
@@ -105,7 +105,7 @@ class ProcedureRef;  // forward definition, represents a CALL statement
 // Many other classes below simply wrap a std::tuple<> structure, which
 // is conventionally named "t".
 #define TUPLE_CLASS_BOILERPLATE(classname) \
-  template<typename... Ts, typename = common::NoLvalue<Ts...>> \
+  template <typename... Ts, typename = common::NoLvalue<Ts...>> \
   classname(Ts &&... args) : t(std::move(args)...) {} \
   using TupleTrait = std::true_type; \
   BOILERPLATE(classname)
@@ -129,123 +129,123 @@ namespace Fortran::parser {
 // Some references to the representations of their parses require
 // indirection.  The Indirect<> pointer wrapper class is used to
 // enforce ownership semantics and non-nullability.
-struct SpecificationPart;  // R504
-struct ExecutableConstruct;  // R514
-struct ActionStmt;  // R515
-struct AcImpliedDo;  // R774
-struct DataImpliedDo;  // R840
-struct Designator;  // R901
-struct Variable;  // R902
-struct Expr;  // R1001
-struct WhereConstruct;  // R1042
-struct ForallConstruct;  // R1050
-struct InputImpliedDo;  // R1218
-struct OutputImpliedDo;  // R1218
-struct FunctionReference;  // R1520
-struct FunctionSubprogram;  // R1529
-struct SubroutineSubprogram;  // R1534
+struct SpecificationPart; // R504
+struct ExecutableConstruct; // R514
+struct ActionStmt; // R515
+struct AcImpliedDo; // R774
+struct DataImpliedDo; // R840
+struct Designator; // R901
+struct Variable; // R902
+struct Expr; // R1001
+struct WhereConstruct; // R1042
+struct ForallConstruct; // R1050
+struct InputImpliedDo; // R1218
+struct OutputImpliedDo; // R1218
+struct FunctionReference; // R1520
+struct FunctionSubprogram; // R1529
+struct SubroutineSubprogram; // R1534
 
 // These additional forward references are declared so that the order of
 // class definitions in this header file can remain reasonably consistent
 // with order of the the requirement productions in the grammar.
-struct DerivedTypeDef;  // R726
-struct EnumDef;  // R759
-struct TypeDeclarationStmt;  // R801
-struct AccessStmt;  // R827
-struct AllocatableStmt;  // R829
-struct AsynchronousStmt;  // R831
-struct BindStmt;  // R832
-struct CodimensionStmt;  // R834
-struct ContiguousStmt;  // R836
-struct DataStmt;  // R837
-struct DataStmtValue;  // R843
-struct DimensionStmt;  // R848
-struct IntentStmt;  // R849
-struct OptionalStmt;  // R850
-struct ParameterStmt;  // R851
+struct DerivedTypeDef; // R726
+struct EnumDef; // R759
+struct TypeDeclarationStmt; // R801
+struct AccessStmt; // R827
+struct AllocatableStmt; // R829
+struct AsynchronousStmt; // R831
+struct BindStmt; // R832
+struct CodimensionStmt; // R834
+struct ContiguousStmt; // R836
+struct DataStmt; // R837
+struct DataStmtValue; // R843
+struct DimensionStmt; // R848
+struct IntentStmt; // R849
+struct OptionalStmt; // R850
+struct ParameterStmt; // R851
 struct OldParameterStmt;
-struct PointerStmt;  // R853
-struct ProtectedStmt;  // R855
-struct SaveStmt;  // R856
-struct TargetStmt;  // R859
-struct ValueStmt;  // R861
-struct VolatileStmt;  // R862
-struct ImplicitStmt;  // R863
-struct ImportStmt;  // R867
-struct NamelistStmt;  // R868
-struct EquivalenceStmt;  // R870
-struct CommonStmt;  // R873
-struct Substring;  // R908
+struct PointerStmt; // R853
+struct ProtectedStmt; // R855
+struct SaveStmt; // R856
+struct TargetStmt; // R859
+struct ValueStmt; // R861
+struct VolatileStmt; // R862
+struct ImplicitStmt; // R863
+struct ImportStmt; // R867
+struct NamelistStmt; // R868
+struct EquivalenceStmt; // R870
+struct CommonStmt; // R873
+struct Substring; // R908
 struct CharLiteralConstantSubstring;
-struct DataRef;  // R911
-struct StructureComponent;  // R913
-struct CoindexedNamedObject;  // R914
-struct ArrayElement;  // R917
-struct AllocateStmt;  // R927
-struct NullifyStmt;  // R939
-struct DeallocateStmt;  // R941
-struct AssignmentStmt;  // R1032
-struct PointerAssignmentStmt;  // R1033
-struct WhereStmt;  // R1041, R1045, R1046
-struct ForallStmt;  // R1055
-struct AssociateConstruct;  // R1102
-struct BlockConstruct;  // R1107
-struct ChangeTeamConstruct;  // R1111
-struct CriticalConstruct;  // R1116
-struct DoConstruct;  // R1119
-struct LabelDoStmt;  // R1121
-struct ConcurrentHeader;  // R1125
-struct EndDoStmt;  // R1132
-struct CycleStmt;  // R1133
-struct IfConstruct;  // R1134
-struct IfStmt;  // R1139
-struct CaseConstruct;  // R1140
-struct SelectRankConstruct;  // R1148
-struct SelectTypeConstruct;  // R1152
-struct ExitStmt;  // R1156
-struct GotoStmt;  // R1157
-struct ComputedGotoStmt;  // R1158
-struct StopStmt;  // R1160, R1161
-struct SyncAllStmt;  // R1164
-struct SyncImagesStmt;  // R1166
-struct SyncMemoryStmt;  // R1168
-struct SyncTeamStmt;  // R1169
-struct EventPostStmt;  // R1170, R1171
-struct EventWaitStmt;  // R1172, R1173, R1174
-struct FormTeamStmt;  // R1175, R1176, R1177
-struct LockStmt;  // R1178
-struct UnlockStmt;  // R1180
-struct OpenStmt;  // R1204
-struct CloseStmt;  // R1208
-struct ReadStmt;  // R1210
-struct WriteStmt;  // R1211
-struct PrintStmt;  // R1212
-struct WaitStmt;  // R1222
-struct BackspaceStmt;  // R1224
-struct EndfileStmt;  // R1225
-struct RewindStmt;  // R1226
-struct FlushStmt;  // R1228
-struct InquireStmt;  // R1230
-struct FormatStmt;  // R1301
-struct MainProgram;  // R1401
-struct Module;  // R1404
-struct UseStmt;  // R1409
-struct Submodule;  // R1416
-struct BlockData;  // R1420
-struct InterfaceBlock;  // R1501
-struct GenericSpec;  // R1508
-struct GenericStmt;  // R1510
-struct ExternalStmt;  // R1511
-struct ProcedureDeclarationStmt;  // R1512
-struct IntrinsicStmt;  // R1519
-struct Call;  // R1520 & R1521
-struct CallStmt;  // R1521
-struct ProcedureDesignator;  // R1522
-struct ActualArg;  // R1524
-struct SeparateModuleSubprogram;  // R1538
-struct EntryStmt;  // R1541
-struct ReturnStmt;  // R1542
-struct StmtFunctionStmt;  // R1544
+struct DataRef; // R911
+struct StructureComponent; // R913
+struct CoindexedNamedObject; // R914
+struct ArrayElement; // R917
+struct AllocateStmt; // R927
+struct NullifyStmt; // R939
+struct DeallocateStmt; // R941
+struct AssignmentStmt; // R1032
+struct PointerAssignmentStmt; // R1033
+struct WhereStmt; // R1041, R1045, R1046
+struct ForallStmt; // R1055
+struct AssociateConstruct; // R1102
+struct BlockConstruct; // R1107
+struct ChangeTeamConstruct; // R1111
+struct CriticalConstruct; // R1116
+struct DoConstruct; // R1119
+struct LabelDoStmt; // R1121
+struct ConcurrentHeader; // R1125
+struct EndDoStmt; // R1132
+struct CycleStmt; // R1133
+struct IfConstruct; // R1134
+struct IfStmt; // R1139
+struct CaseConstruct; // R1140
+struct SelectRankConstruct; // R1148
+struct SelectTypeConstruct; // R1152
+struct ExitStmt; // R1156
+struct GotoStmt; // R1157
+struct ComputedGotoStmt; // R1158
+struct StopStmt; // R1160, R1161
+struct SyncAllStmt; // R1164
+struct SyncImagesStmt; // R1166
+struct SyncMemoryStmt; // R1168
+struct SyncTeamStmt; // R1169
+struct EventPostStmt; // R1170, R1171
+struct EventWaitStmt; // R1172, R1173, R1174
+struct FormTeamStmt; // R1175, R1176, R1177
+struct LockStmt; // R1178
+struct UnlockStmt; // R1180
+struct OpenStmt; // R1204
+struct CloseStmt; // R1208
+struct ReadStmt; // R1210
+struct WriteStmt; // R1211
+struct PrintStmt; // R1212
+struct WaitStmt; // R1222
+struct BackspaceStmt; // R1224
+struct EndfileStmt; // R1225
+struct RewindStmt; // R1226
+struct FlushStmt; // R1228
+struct InquireStmt; // R1230
+struct FormatStmt; // R1301
+struct MainProgram; // R1401
+struct Module; // R1404
+struct UseStmt; // R1409
+struct Submodule; // R1416
+struct BlockData; // R1420
+struct InterfaceBlock; // R1501
+struct GenericSpec; // R1508
+struct GenericStmt; // R1510
+struct ExternalStmt; // R1511
+struct ProcedureDeclarationStmt; // R1512
+struct IntrinsicStmt; // R1519
+struct Call; // R1520 & R1521
+struct CallStmt; // R1521
+struct ProcedureDesignator; // R1522
+struct ActualArg; // R1524
+struct SeparateModuleSubprogram; // R1538
+struct EntryStmt; // R1541
+struct ReturnStmt; // R1542
+struct StmtFunctionStmt; // R1544
 
 // Directives, extensions, and deprecated statements
 struct CompilerDirective;
@@ -274,7 +274,7 @@ struct Verbatim {
 // R403 scalar-xyz -> xyz
 // These template class wrappers correspond to the Standard's modifiers
 // scalar-xyz, constant-xzy, int-xzy, default-char-xyz, & logical-xyz.
-template<typename A> struct Scalar {
+template <typename A> struct Scalar {
   using ConstraintTrait = std::true_type;
   Scalar(Scalar &&that) = default;
   Scalar(A &&that) : thing(std::move(that)) {}
@@ -282,7 +282,7 @@ template<typename A> struct Scalar {
   A thing;
 };
 
-template<typename A> struct Constant {
+template <typename A> struct Constant {
   using ConstraintTrait = std::true_type;
   Constant(Constant &&that) = default;
   Constant(A &&that) : thing(std::move(that)) {}
@@ -290,7 +290,7 @@ template<typename A> struct Constant {
   A thing;
 };
 
-template<typename A> struct Integer {
+template <typename A> struct Integer {
   using ConstraintTrait = std::true_type;
   Integer(Integer &&that) = default;
   Integer(A &&that) : thing(std::move(that)) {}
@@ -298,7 +298,7 @@ template<typename A> struct Integer {
   A thing;
 };
 
-template<typename A> struct Logical {
+template <typename A> struct Logical {
   using ConstraintTrait = std::true_type;
   Logical(Logical &&that) = default;
   Logical(A &&that) : thing(std::move(that)) {}
@@ -306,7 +306,7 @@ template<typename A> struct Logical {
   A thing;
 };
 
-template<typename A> struct DefaultChar {
+template <typename A> struct DefaultChar {
   using ConstraintTrait = std::true_type;
   DefaultChar(DefaultChar &&that) = default;
   DefaultChar(A &&that) : thing(std::move(that)) {}
@@ -314,11 +314,11 @@ template<typename A> struct DefaultChar {
   A thing;
 };
 
-using LogicalExpr = Logical<common::Indirection<Expr>>;  // R1024
-using DefaultCharExpr = DefaultChar<common::Indirection<Expr>>;  // R1025
-using IntExpr = Integer<common::Indirection<Expr>>;  // R1026
-using ConstantExpr = Constant<common::Indirection<Expr>>;  // R1029
-using IntConstantExpr = Integer<ConstantExpr>;  // R1031
+using LogicalExpr = Logical<common::Indirection<Expr>>; // R1024
+using DefaultCharExpr = DefaultChar<common::Indirection<Expr>>; // R1025
+using IntExpr = Integer<common::Indirection<Expr>>; // R1026
+using ConstantExpr = Constant<common::Indirection<Expr>>; // R1029
+using IntConstantExpr = Integer<ConstantExpr>; // R1031
 using ScalarLogicalExpr = Scalar<LogicalExpr>;
 using ScalarIntExpr = Scalar<IntExpr>;
 using ScalarIntConstantExpr = Scalar<IntConstantExpr>;
@@ -328,18 +328,18 @@ using ScalarDefaultCharExpr = Scalar<DefaultCharExpr>;
 using ScalarDefaultCharConstantExpr = Scalar<DefaultChar<ConstantExpr>>;
 
 // R611 label -> digit [digit]...
-using Label = std::uint64_t;  // validated later, must be in [1..99999]
+using Label = std::uint64_t; // validated later, must be in [1..99999]
 
 // A wrapper for xzy-stmt productions that are statements, so that
 // source provenances and labels have a uniform representation.
-template<typename A> struct UnlabeledStatement {
+template <typename A> struct UnlabeledStatement {
   explicit UnlabeledStatement(A &&s) : statement(std::move(s)) {}
   CharBlock source;
   A statement;
 };
-template<typename A> struct Statement : public UnlabeledStatement<A> {
+template <typename A> struct Statement : public UnlabeledStatement<A> {
   Statement(std::optional<long> &&lab, A &&s)
-    : UnlabeledStatement<A>{std::move(s)}, label(std::move(lab)) {}
+      : UnlabeledStatement<A>{std::move(s)}, label(std::move(lab)) {}
   std::optional<Label> label;
 };
 
@@ -548,7 +548,7 @@ WRAPPER_CLASS(Program, std::list<ProgramUnit>);
 struct Name {
   std::string ToString() const { return source.ToString(); }
   CharBlock source;
-  mutable semantics::Symbol *symbol{nullptr};  // filled in during semantics
+  mutable semantics::Symbol *symbol{nullptr}; // filled in during semantics
 };
 
 // R516 keyword -> name
@@ -609,7 +609,7 @@ EMPTY_CLASS(Star);
 
 struct TypeParamValue {
   UNION_CLASS_BOILERPLATE(TypeParamValue);
-  EMPTY_CLASS(Deferred);  // :
+  EMPTY_CLASS(Deferred); // :
   std::variant<ScalarIntExpr, Star, Deferred> u;
 };
 
@@ -647,14 +647,14 @@ struct CharSelector {
   struct LengthAndKind {
     BOILERPLATE(LengthAndKind);
     LengthAndKind(std::optional<TypeParamValue> &&l, ScalarIntConstantExpr &&k)
-      : length(std::move(l)), kind(std::move(k)) {}
+        : length(std::move(l)), kind(std::move(k)) {}
     std::optional<TypeParamValue> length;
     ScalarIntConstantExpr kind;
   };
   CharSelector(TypeParamValue &&l, ScalarIntConstantExpr &&k)
-    : u{LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
+      : u{LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
   CharSelector(ScalarIntConstantExpr &&k, std::optional<TypeParamValue> &&l)
-    : u{LengthAndKind{std::move(l), std::move(k)}} {}
+      : u{LengthAndKind{std::move(l), std::move(k)}} {}
   std::variant<LengthSelector, LengthAndKind> u;
 };
 
@@ -770,7 +770,7 @@ struct RealLiteralConstant {
     CharBlock source;
   };
   RealLiteralConstant(Real &&r, std::optional<KindParam> &&k)
-    : real{std::move(r)}, kind{std::move(k)} {}
+      : real{std::move(r)}, kind{std::move(k)} {}
   Real real;
   std::optional<KindParam> kind;
 };
@@ -797,7 +797,7 @@ struct ComplexPart {
 // R718 complex-literal-constant -> ( real-part , imag-part )
 struct ComplexLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(ComplexLiteralConstant);
-  std::tuple<ComplexPart, ComplexPart> t;  // real, imaginary
+  std::tuple<ComplexPart, ComplexPart> t; // real, imaginary
 };
 
 // Extension: signed COMPLEX constant
@@ -1077,15 +1077,15 @@ struct TypeBoundProcedureStmt {
     BOILERPLATE(WithoutInterface);
     WithoutInterface(
         std::list<BindAttr> &&as, std::list<TypeBoundProcDecl> &&ds)
-      : attributes(std::move(as)), declarations(std::move(ds)) {}
+        : attributes(std::move(as)), declarations(std::move(ds)) {}
     std::list<BindAttr> attributes;
     std::list<TypeBoundProcDecl> declarations;
   };
   struct WithInterface {
     BOILERPLATE(WithInterface);
     WithInterface(Name &&n, std::list<BindAttr> &&as, std::list<Name> &&bs)
-      : interfaceName(std::move(n)), attributes(std::move(as)),
-        bindingNames(std::move(bs)) {}
+        : interfaceName(std::move(n)), attributes(std::move(as)),
+          bindingNames(std::move(bs)) {}
     Name interfaceName;
     std::list<BindAttr> attributes;
     std::list<Name> bindingNames;
@@ -1184,7 +1184,7 @@ struct EnumDef {
 
 // R773 ac-value -> expr | ac-implied-do
 struct AcValue {
-  struct Triplet {  // PGI/Intel extension
+  struct Triplet { // PGI/Intel extension
     TUPLE_CLASS_BOILERPLATE(Triplet);
     std::tuple<ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>> t;
   };
@@ -1198,7 +1198,7 @@ struct AcValue {
 struct AcSpec {
   BOILERPLATE(AcSpec);
   AcSpec(std::optional<TypeSpec> &&ts, std::list<AcValue> &&xs)
-    : type(std::move(ts)), values(std::move(xs)) {}
+      : type(std::move(ts)), values(std::move(xs)) {}
   explicit AcSpec(TypeSpec &&ts) : type{std::move(ts)} {}
   std::optional<TypeSpec> type;
   std::list<AcValue> values;
@@ -1210,12 +1210,12 @@ WRAPPER_CLASS(ArrayConstructor, AcSpec);
 // R1124 do-variable -> scalar-int-variable-name
 using DoVariable = Scalar<Integer<Name>>;
 
-template<typename VAR, typename BOUND> struct LoopBounds {
+template <typename VAR, typename BOUND> struct LoopBounds {
   LoopBounds(LoopBounds &&that) = default;
   LoopBounds(
       VAR &&name, BOUND &&lower, BOUND &&upper, std::optional<BOUND> &&step)
-    : name{std::move(name)}, lower{std::move(lower)}, upper{std::move(upper)},
-      step{std::move(step)} {}
+      : name{std::move(name)}, lower{std::move(lower)}, upper{std::move(upper)},
+        step{std::move(step)} {}
   LoopBounds &operator=(LoopBounds &&) = default;
   VAR name;
   BOUND lower, upper;
@@ -1528,7 +1528,7 @@ struct ImplicitSpec {
 // R866 implicit-name-spec -> EXTERNAL | TYPE
 struct ImplicitStmt {
   UNION_CLASS_BOILERPLATE(ImplicitStmt);
-  ENUM_CLASS(ImplicitNoneNameSpec, External, Type)  // R866
+  ENUM_CLASS(ImplicitNoneNameSpec, External, Type) // R866
   std::variant<std::list<ImplicitSpec>, std::list<ImplicitNoneNameSpec>> u;
 };
 
@@ -1624,8 +1624,7 @@ struct Expr {
     using IntrinsicUnary::IntrinsicUnary;
   };
 
-  WRAPPER_CLASS(
-      PercentLoc, common::Indirection<Variable>);  // %LOC(v) extension
+  WRAPPER_CLASS(PercentLoc, common::Indirection<Variable>); // %LOC(v) extension
 
   struct DefinedUnary {
     TUPLE_CLASS_BOILERPLATE(DefinedUnary);
@@ -1721,8 +1720,8 @@ struct PartRef {
   BOILERPLATE(PartRef);
   PartRef(Name &&n, std::list<SectionSubscript> &&ss,
       std::optional<ImageSelector> &&is)
-    : name{std::move(n)},
-      subscripts(std::move(ss)), imageSelector{std::move(is)} {}
+      : name{std::move(n)},
+        subscripts(std::move(ss)), imageSelector{std::move(is)} {}
   Name name;
   std::list<SectionSubscript> subscripts;
   std::optional<ImageSelector> imageSelector;
@@ -1792,7 +1791,7 @@ using ScalarIntVariable = Scalar<Integer<Variable>>;
 struct StructureComponent {
   BOILERPLATE(StructureComponent);
   StructureComponent(DataRef &&dr, Name &&n)
-    : base{std::move(dr)}, component(std::move(n)) {}
+      : base{std::move(dr)}, component(std::move(n)) {}
   DataRef base;
   Name component;
 };
@@ -1807,7 +1806,7 @@ struct ProcComponentRef {
 struct CoindexedNamedObject {
   BOILERPLATE(CoindexedNamedObject);
   CoindexedNamedObject(DataRef &&dr, ImageSelector &&is)
-    : base{std::move(dr)}, imageSelector{std::move(is)} {}
+      : base{std::move(dr)}, imageSelector{std::move(is)} {}
   DataRef base;
   ImageSelector imageSelector;
 };
@@ -1816,7 +1815,7 @@ struct CoindexedNamedObject {
 struct ArrayElement {
   BOILERPLATE(ArrayElement);
   ArrayElement(DataRef &&dr, std::list<SectionSubscript> &&ss)
-    : base{std::move(dr)}, subscripts(std::move(ss)) {}
+      : base{std::move(dr)}, subscripts(std::move(ss)) {}
   Substring ConvertToSubstring();
   StructureConstructor ConvertToStructureConstructor(
       const semantics::DerivedTypeSpec &);
@@ -2287,8 +2286,8 @@ struct CaseValueRange {
   struct Range {
     BOILERPLATE(Range);
     Range(std::optional<CaseValue> &&l, std::optional<CaseValue> &&u)
-      : lower{std::move(l)}, upper{std::move(u)} {}
-    std::optional<CaseValue> lower, upper;  // not both missing
+        : lower{std::move(l)}, upper{std::move(u)} {}
+    std::optional<CaseValue> lower, upper; // not both missing
   };
   std::variant<CaseValue, Range> u;
 };
@@ -2625,13 +2624,13 @@ struct ReadStmt {
   BOILERPLATE(ReadStmt);
   ReadStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
       std::list<IoControlSpec> &&cs, std::list<InputItem> &&its)
-    : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
-      items(std::move(its)) {}
-  std::optional<IoUnit> iounit;  // if first in controls without UNIT= &/or
-                                 // followed by untagged format/namelist
-  std::optional<Format> format;  // if second in controls without FMT=/NML=, or
-                                 // no (io-control-spec-list); might be
-                                 // an untagged namelist group name
+      : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
+        items(std::move(its)) {}
+  std::optional<IoUnit> iounit; // if first in controls without UNIT= &/or
+                                // followed by untagged format/namelist
+  std::optional<Format> format; // if second in controls without FMT=/NML=, or
+                                // no (io-control-spec-list); might be
+                                // an untagged namelist group name
   std::list<IoControlSpec> controls;
   std::list<InputItem> items;
 };
@@ -2647,12 +2646,12 @@ struct WriteStmt {
   BOILERPLATE(WriteStmt);
   WriteStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
       std::list<IoControlSpec> &&cs, std::list<OutputItem> &&its)
-    : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
-      items(std::move(its)) {}
-  std::optional<IoUnit> iounit;  // if first in controls without UNIT= &/or
-                                 // followed by untagged format/namelist
-  std::optional<Format> format;  // if second in controls without FMT=/NML=;
-                                 // might be an untagged namelist group, too
+      : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
+        items(std::move(its)) {}
+  std::optional<IoUnit> iounit; // if first in controls without UNIT= &/or
+                                // followed by untagged format/namelist
+  std::optional<Format> format; // if second in controls without FMT=/NML=;
+                                // might be an untagged namelist group, too
   std::list<IoControlSpec> controls;
   std::list<OutputItem> items;
 };
@@ -2947,10 +2946,10 @@ struct Only {
 // R1410 module-nature -> INTRINSIC | NON_INTRINSIC
 struct UseStmt {
   BOILERPLATE(UseStmt);
-  ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic)  // R1410
-  template<typename A>
+  ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic) // R1410
+  template <typename A>
   UseStmt(std::optional<ModuleNature> &&nat, Name &&n, std::list<A> &&x)
-    : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
+      : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
   std::optional<ModuleNature> nature;
   Name moduleName;
   std::variant<std::list<Rename>, std::list<Only>> u;
@@ -2998,9 +2997,9 @@ struct PrefixSpec {
 struct Suffix {
   BOILERPLATE(Suffix);
   Suffix(LanguageBindingSpec &&lbs, std::optional<Name> &&rn)
-    : binding(std::move(lbs)), resultName(std::move(rn)) {}
+      : binding(std::move(lbs)), resultName(std::move(rn)) {}
   Suffix(Name &&rn, std::optional<LanguageBindingSpec> &&lbs)
-    : binding(std::move(lbs)), resultName(std::move(rn)) {}
+      : binding(std::move(lbs)), resultName(std::move(rn)) {}
   std::optional<LanguageBindingSpec> binding;
   std::optional<Name> resultName;
 };
@@ -3103,8 +3102,8 @@ WRAPPER_CLASS(AltReturnSpec, Label);
 //         expr | variable | procedure-name | proc-component-ref |
 //         alt-return-spec
 struct ActualArg {
-  WRAPPER_CLASS(PercentRef, Variable);  // %REF(v) extension
-  WRAPPER_CLASS(PercentVal, Expr);  // %VAL(x) extension
+  WRAPPER_CLASS(PercentRef, Variable); // %REF(v) extension
+  WRAPPER_CLASS(PercentVal, Expr); // %VAL(x) extension
   UNION_CLASS_BOILERPLATE(ActualArg);
   ActualArg(Expr &&x) : u{common::Indirection<Expr>(std::move(x))} {}
   std::variant<common::Indirection<Expr>, AltReturnSpec, PercentRef, PercentVal>
@@ -3136,7 +3135,7 @@ struct CallStmt {
   WRAPPER_CLASS_BOILERPLATE(CallStmt, Call);
   mutable std::unique_ptr<evaluate::ProcedureRef,
       common::Deleter<evaluate::ProcedureRef>>
-      typedCall;  // filled by semantics
+      typedCall; // filled by semantics
 };
 
 // R1529 function-subprogram ->
@@ -3371,7 +3370,7 @@ struct OmpLinearClause {
     BOILERPLATE(WithModifier);
     WithModifier(OmpLinearModifier &&m, std::list<Name> &&n,
         std::optional<ScalarIntConstantExpr> &&s)
-      : modifier(std::move(m)), names(std::move(n)), step(std::move(s)) {}
+        : modifier(std::move(m)), names(std::move(n)), step(std::move(s)) {}
     OmpLinearModifier modifier;
     std::list<Name> names;
     std::optional<ScalarIntConstantExpr> step;
@@ -3380,7 +3379,7 @@ struct OmpLinearClause {
     BOILERPLATE(WithoutModifier);
     WithoutModifier(
         std::list<Name> &&n, std::optional<ScalarIntConstantExpr> &&s)
-      : names(std::move(n)), step(std::move(s)) {}
+        : names(std::move(n)), step(std::move(s)) {}
     std::list<Name> names;
     std::optional<ScalarIntConstantExpr> step;
   };
@@ -3774,7 +3773,7 @@ struct OpenMPBlockConstruct {
 struct OpenMPLoopConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPLoopConstruct);
   OpenMPLoopConstruct(OmpBeginLoopDirective &&a)
-    : t({std::move(a), std::nullopt, std::nullopt}) {}
+      : t({std::move(a), std::nullopt, std::nullopt}) {}
   std::tuple<OmpBeginLoopDirective, std::optional<DoConstruct>,
       std::optional<OmpEndLoopDirective>>
       t;
@@ -3787,5 +3786,5 @@ struct OpenMPConstruct {
       OpenMPCriticalConstruct>
       u;
 };
-}
-#endif  // FORTRAN_PARSER_PARSE_TREE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSE_TREE_H_
diff --git a/include/flang/Parser/parsing.h b/include/flang/Parser/parsing.h
index 0d32afee38c2..9b84705d8151 100644
--- a/include/flang/Parser/parsing.h
+++ b/include/flang/Parser/parsing.h
@@ -56,8 +56,8 @@ class Parsing {
   void Parse(llvm::raw_ostream &debugOutput);
   void ClearLog();
 
-  void EmitMessage(llvm::raw_ostream &o, const char *at, const std::string &message,
-      bool echoSourceLine = false) const {
+  void EmitMessage(llvm::raw_ostream &o, const char *at,
+      const std::string &message, bool echoSourceLine = false) const {
     cooked_.allSources().EmitMessage(
         o, cooked_.GetProvenanceRange(CharBlock(at)), message, echoSourceLine);
   }
@@ -73,5 +73,5 @@ class Parsing {
   std::optional<Program> parseTree_;
   ParsingLog log_;
 };
-}
-#endif  // FORTRAN_PARSER_PARSING_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSING_H_
diff --git a/include/flang/Parser/provenance.h b/include/flang/Parser/provenance.h
index 2ed00d416b64..b543cd7d7b4e 100644
--- a/include/flang/Parser/provenance.h
+++ b/include/flang/Parser/provenance.h
@@ -168,8 +168,8 @@ class AllSources {
       Provenance, std::size_t *offset = nullptr) const;
   std::optional<SourcePosition> GetSourcePosition(Provenance) const;
   std::optional<ProvenanceRange> GetFirstFileProvenance() const;
-  std::string GetPath(Provenance) const;  // __FILE__
-  int GetLineNumber(Provenance) const;  // __LINE__
+  std::string GetPath(Provenance) const; // __FILE__
+  int GetLineNumber(Provenance) const; // __LINE__
   Provenance CompilerInsertionProvenance(char ch);
   Provenance CompilerInsertionProvenance(const char *, std::size_t);
   ProvenanceRange IntersectionWithSourceFiles(ProvenanceRange) const;
@@ -256,17 +256,17 @@ class CookedSource {
   }
 
   std::size_t BufferedBytes() const;
-  void Marshal();  // marshals text into one contiguous block
+  void Marshal(); // marshals text into one contiguous block
   void CompileProvenanceRangeToOffsetMappings();
   std::string AcquireData() { return std::move(data_); }
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   AllSources &allSources_;
-  CharBuffer buffer_;  // before Marshal()
-  std::string data_;  // all of it, prescanned and preprocessed
+  CharBuffer buffer_; // before Marshal()
+  std::string data_; // all of it, prescanned and preprocessed
   OffsetToProvenanceMappings provenanceMap_;
   ProvenanceRangeToOffsetMappings invertedMap_;
 };
-}
-#endif  // FORTRAN_PARSER_PROVENANCE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PROVENANCE_H_
diff --git a/include/flang/Parser/source.h b/include/flang/Parser/source.h
index 4c5be0f62c0c..e0d1a5308fdf 100644
--- a/include/flang/Parser/source.h
+++ b/include/flang/Parser/source.h
@@ -15,11 +15,11 @@
 //  - A Unicode byte order mark is recognized if present.
 
 #include "characters.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <cstddef>
 #include <string>
 #include <utility>
 #include <vector>
-#include "llvm/Support/MemoryBuffer.h"
 
 namespace llvm {
 class raw_ostream;
@@ -43,7 +43,9 @@ class SourceFile {
   explicit SourceFile(Encoding e) : encoding_{e} {}
   ~SourceFile();
   std::string path() const { return path_; }
-  llvm::ArrayRef<char> content() const { return buf_->getBuffer().slice(bom_end_, buf_end_ - bom_end_); }
+  llvm::ArrayRef<char> content() const {
+    return buf_->getBuffer().slice(bom_end_, buf_end_ - bom_end_);
+  }
   std::size_t bytes() const { return content().size(); }
   std::size_t lines() const { return lineStart_.size(); }
   Encoding encoding() const { return encoding_; }
@@ -64,9 +66,9 @@ class SourceFile {
   std::string path_;
   std::unique_ptr<llvm::WritableMemoryBuffer> buf_;
   std::vector<std::size_t> lineStart_;
-  std::size_t bom_end_ {0};
+  std::size_t bom_end_{0};
   std::size_t buf_end_;
   Encoding encoding_;
 };
-}
-#endif  // FORTRAN_PARSER_SOURCE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_SOURCE_H_
diff --git a/include/flang/Parser/tools.h b/include/flang/Parser/tools.h
index 9112cc4a4886..426222b7f7dc 100644
--- a/include/flang/Parser/tools.h
+++ b/include/flang/Parser/tools.h
@@ -34,7 +34,7 @@ const Name &GetLastName(const AllocateObject &);
 // wrapped in a struct to avoid prototypes.
 struct UnwrapperHelper {
 
-  template<typename A, typename B> static const A *Unwrap(B *p) {
+  template <typename A, typename B> static const A *Unwrap(B *p) {
     if (p) {
       return Unwrap<A>(*p);
     } else {
@@ -42,17 +42,17 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B, bool COPY>
+  template <typename A, typename B, bool COPY>
   static const A *Unwrap(const common::Indirection<B, COPY> &x) {
     return Unwrap<A>(x.value());
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   static const A *Unwrap(const std::variant<Bs...> &x) {
     return std::visit([](const auto &y) { return Unwrap<A>(y); }, x);
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static const A *Unwrap(const std::optional<B> &o) {
     if (o) {
       return Unwrap<A>(*o);
@@ -61,7 +61,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B> static const A *Unwrap(B &x) {
+  template <typename A, typename B> static const A *Unwrap(B &x) {
     if constexpr (std::is_same_v<std::decay_t<A>, std::decay_t<B>>) {
       return &x;
     } else if constexpr (ConstraintTrait<B>) {
@@ -76,10 +76,10 @@ struct UnwrapperHelper {
   }
 };
 
-template<typename A, typename B> const A *Unwrap(const B &x) {
+template <typename A, typename B> const A *Unwrap(const B &x) {
   return UnwrapperHelper::Unwrap<A>(x);
 }
-template<typename A, typename B> A *Unwrap(B &x) {
+template <typename A, typename B> A *Unwrap(B &x) {
   return const_cast<A *>(Unwrap<A, B>(const_cast<const B &>(x)));
 }
 
@@ -87,5 +87,5 @@ template<typename A, typename B> A *Unwrap(B &x) {
 const CoindexedNamedObject *GetCoindexedNamedObject(const AllocateObject &);
 const CoindexedNamedObject *GetCoindexedNamedObject(const DataRef &);
 
-}
-#endif  // FORTRAN_PARSER_TOOLS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TOOLS_H_
diff --git a/include/flang/Parser/unparse.h b/include/flang/Parser/unparse.h
index 0c7745809f39..cc79294b909d 100644
--- a/include/flang/Parser/unparse.h
+++ b/include/flang/Parser/unparse.h
@@ -22,7 +22,7 @@ namespace Fortran::evaluate {
 struct GenericExprWrapper;
 struct GenericAssignmentWrapper;
 class ProcedureRef;
-}
+} // namespace Fortran::evaluate
 
 namespace Fortran::parser {
 
@@ -48,6 +48,6 @@ void Unparse(llvm::raw_ostream &out, const Program &program,
     Encoding encoding = Encoding::UTF_8, bool capitalizeKeywords = true,
     bool backslashEscapes = true, preStatementType *preStatement = nullptr,
     AnalyzedObjectsAsFortran * = nullptr);
-}
+} // namespace Fortran::parser
 
 #endif
diff --git a/include/flang/Parser/user-state.h b/include/flang/Parser/user-state.h
index cc5466568ecb..75757d2f305a 100644
--- a/include/flang/Parser/user-state.h
+++ b/include/flang/Parser/user-state.h
@@ -30,12 +30,12 @@ class CookedSource;
 class ParsingLog;
 class ParseState;
 
-class Success {};  // for when one must return something that's present
+class Success {}; // for when one must return something that's present
 
 class UserState {
 public:
   UserState(const CookedSource &cooked, common::LanguageFeatureControl features)
-    : cooked_{cooked}, features_{features} {}
+      : cooked_{cooked}, features_{features} {}
 
   const CookedSource &cooked() const { return cooked_; }
   const common::LanguageFeatureControl &features() const { return features_; }
@@ -139,5 +139,5 @@ struct StructureComponents {
   using resultType = DataComponentDefStmt;
   static std::optional<DataComponentDefStmt> Parse(ParseState &);
 };
-}
-#endif  // FORTRAN_PARSER_USER_STATE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_USER_STATE_H_
diff --git a/include/flang/Semantics/attr.h b/include/flang/Semantics/attr.h
index b8a8fec69aff..76fab5e0c904 100644
--- a/include/flang/Semantics/attr.h
+++ b/include/flang/Semantics/attr.h
@@ -50,5 +50,5 @@ std::string AttrToString(Attr attr);
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, Attr attr);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Attrs &attrs);
-}
-#endif  // FORTRAN_SEMANTICS_ATTR_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_ATTR_H_
diff --git a/include/flang/Semantics/expression.h b/include/flang/Semantics/expression.h
index 77ead117f345..3e5c053756b8 100644
--- a/include/flang/Semantics/expression.h
+++ b/include/flang/Semantics/expression.h
@@ -29,8 +29,8 @@ using namespace Fortran::parser::literals;
 
 namespace Fortran::parser {
 struct SourceLocationFindingVisitor {
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {}
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
   bool Pre(const Expr &x) {
     source = x.source;
     return false;
@@ -51,7 +51,7 @@ struct SourceLocationFindingVisitor {
     source = x.source;
     return false;
   }
-  template<typename A> bool Pre(const UnlabeledStatement<A> &stmt) {
+  template <typename A> bool Pre(const UnlabeledStatement<A> &stmt) {
     source = stmt.source;
     return false;
   }
@@ -60,12 +60,12 @@ struct SourceLocationFindingVisitor {
   CharBlock source;
 };
 
-template<typename A> CharBlock FindSourceLocation(const A &x) {
+template <typename A> CharBlock FindSourceLocation(const A &x) {
   SourceLocationFindingVisitor visitor;
   Walk(x, visitor);
   return visitor.source;
 }
-}
+} // namespace Fortran::parser
 
 using namespace Fortran::parser::literals;
 
@@ -89,10 +89,10 @@ struct SetExprHelper {
   }
   void Set(const parser::Expr &x) { Set(x.typedExpr); }
   void Set(const parser::Variable &x) { Set(x.typedExpr); }
-  template<typename T> void Set(const common::Indirection<T> &x) {
+  template <typename T> void Set(const common::Indirection<T> &x) {
     Set(x.value());
   }
-  template<typename T> void Set(const T &x) {
+  template <typename T> void Set(const T &x) {
     if constexpr (ConstraintTrait<T>) {
       Set(x.thing);
     } else if constexpr (WrapperTrait<T>) {
@@ -103,11 +103,11 @@ struct SetExprHelper {
   GenericExprWrapper expr_;
 };
 
-template<typename T> void ResetExpr(const T &x) {
+template <typename T> void ResetExpr(const T &x) {
   SetExprHelper{GenericExprWrapper{/* error indicator */}}.Set(x);
 }
 
-template<typename T> void SetExpr(const T &x, Expr<SomeType> &&expr) {
+template <typename T> void SetExpr(const T &x, Expr<SomeType> &&expr) {
   SetExprHelper{GenericExprWrapper{std::move(expr)}}.Set(x);
 }
 
@@ -117,7 +117,7 @@ class ExpressionAnalyzer {
 
   explicit ExpressionAnalyzer(semantics::SemanticsContext &sc) : context_{sc} {}
   ExpressionAnalyzer(semantics::SemanticsContext &sc, FoldingContext &fc)
-    : context_{sc}, foldingContext_{fc} {}
+      : context_{sc}, foldingContext_{fc} {}
   ExpressionAnalyzer(ExpressionAnalyzer &) = default;
 
   semantics::SemanticsContext &context() const { return context_; }
@@ -128,11 +128,11 @@ class ExpressionAnalyzer {
     return foldingContext_.messages();
   }
 
-  template<typename... A> parser::Message *Say(A &&... args) {
+  template <typename... A> parser::Message *Say(A &&... args) {
     return GetContextualMessages().Say(std::forward<A>(args)...);
   }
 
-  template<typename T, typename... A>
+  template <typename T, typename... A>
   parser::Message *SayAt(const T &parsed, A &&... args) {
     return Say(parser::FindSourceLocation(parsed), std::forward<A>(args)...);
   }
@@ -156,10 +156,10 @@ class ExpressionAnalyzer {
   MaybeExpr Analyze(const parser::Variable &);
   MaybeExpr Analyze(const parser::Designator &);
 
-  template<typename A> MaybeExpr Analyze(const common::Indirection<A> &x) {
+  template <typename A> MaybeExpr Analyze(const common::Indirection<A> &x) {
     return Analyze(x.value());
   }
-  template<typename A> MaybeExpr Analyze(const std::optional<A> &x) {
+  template <typename A> MaybeExpr Analyze(const std::optional<A> &x) {
     if (x) {
       return Analyze(*x);
     } else {
@@ -168,7 +168,7 @@ class ExpressionAnalyzer {
   }
 
   // Implement constraint-checking wrappers from the Fortran grammar.
-  template<typename A> MaybeExpr Analyze(const parser::Scalar<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Scalar<A> &x) {
     auto result{Analyze(x.thing)};
     if (result) {
       if (int rank{result->Rank()}; rank != 0) {
@@ -180,13 +180,13 @@ class ExpressionAnalyzer {
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::Constant<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Constant<A> &x) {
     auto restorer{
         GetFoldingContext().messages().SetLocation(FindSourceLocation(x))};
     auto result{Analyze(x.thing)};
     if (result) {
       *result = Fold(std::move(*result));
-      if (!IsConstantExpr(*result)) {  //  C886, C887, C713
+      if (!IsConstantExpr(*result)) { //  C886, C887, C713
         SayAt(x, "Must be a constant value"_err_en_US);
         ResetExpr(x);
         return std::nullopt;
@@ -197,7 +197,7 @@ class ExpressionAnalyzer {
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::Integer<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Integer<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(
             parser::FindSourceLocation(x), result, TypeCategory::Integer)) {
@@ -206,7 +206,7 @@ class ExpressionAnalyzer {
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::Logical<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Logical<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(
             parser::FindSourceLocation(x), result, TypeCategory::Logical)) {
@@ -215,7 +215,7 @@ class ExpressionAnalyzer {
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::DefaultChar<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::DefaultChar<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(parser::FindSourceLocation(x), result,
             TypeCategory::Character, true /* default kind */)) {
@@ -283,10 +283,10 @@ class ExpressionAnalyzer {
   MaybeExpr Analyze(const parser::Expr::EQV &);
   MaybeExpr Analyze(const parser::Expr::NEQV &);
   MaybeExpr Analyze(const parser::Expr::DefinedBinary &);
-  template<typename A> MaybeExpr Analyze(const A &x) {
-    return Analyze(x.u);  // default case
+  template <typename A> MaybeExpr Analyze(const A &x) {
+    return Analyze(x.u); // default case
   }
-  template<typename... As> MaybeExpr Analyze(const std::variant<As...> &u) {
+  template <typename... As> MaybeExpr Analyze(const std::variant<As...> &u) {
     return std::visit(
         [&](const auto &x) {
           using Ty = std::decay_t<decltype(x)>;
@@ -321,8 +321,8 @@ class ExpressionAnalyzer {
   // Analysis subroutines
   int AnalyzeKindParam(
       const std::optional<parser::KindParam> &, int defaultKind);
-  template<typename PARSED> MaybeExpr ExprOrVariable(const PARSED &);
-  template<typename PARSED> MaybeExpr IntLiteralConstant(const PARSED &);
+  template <typename PARSED> MaybeExpr ExprOrVariable(const PARSED &);
+  template <typename PARSED> MaybeExpr IntLiteralConstant(const PARSED &);
   MaybeExpr AnalyzeString(std::string &&, int kind);
   std::optional<Expr<SubscriptInteger>> AsSubscript(MaybeExpr &&);
   std::optional<Expr<SubscriptInteger>> TripletPart(
@@ -370,13 +370,13 @@ class ExpressionAnalyzer {
   MaybeExpr MakeFunctionRef(
       parser::CharBlock, ProcedureDesignator &&, ActualArguments &&);
   MaybeExpr MakeFunctionRef(parser::CharBlock intrinsic, ActualArguments &&);
-  template<typename T> T Fold(T &&expr) {
+  template <typename T> T Fold(T &&expr) {
     return evaluate::Fold(foldingContext_, std::move(expr));
   }
 
   semantics::SemanticsContext &context_;
   FoldingContext &foldingContext_{context_.foldingContext()};
-  std::map<parser::CharBlock, int> acImpliedDos_;  // values are INTEGER kinds
+  std::map<parser::CharBlock, int> acImpliedDos_; // values are INTEGER kinds
   bool fatalErrors_{false};
   friend class ArgumentAnalyzer;
 };
@@ -385,12 +385,12 @@ inline bool AreConformable(int leftRank, int rightRank) {
   return leftRank == 0 || rightRank == 0 || leftRank == rightRank;
 }
 
-template<typename L, typename R>
+template <typename L, typename R>
 bool AreConformable(const L &left, const R &right) {
   return AreConformable(left.Rank(), right.Rank());
 }
 
-template<typename L, typename R>
+template <typename L, typename R>
 void ConformabilityCheck(
     parser::ContextualMessages &context, const L &left, const R &right) {
   if (!AreConformable(left, right)) {
@@ -398,12 +398,12 @@ void ConformabilityCheck(
         left.Rank(), right.Rank());
   }
 }
-}  // namespace Fortran::evaluate
+} // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 
 // Semantic analysis of one expression, variable, or designator.
-template<typename A>
+template <typename A>
 std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
     SemanticsContext &context, const A &expr) {
   return evaluate::ExpressionAnalyzer{context}.Analyze(expr);
@@ -426,8 +426,8 @@ class ExprChecker {
 public:
   explicit ExprChecker(SemanticsContext &);
 
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {}
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
   bool Walk(const parser::Program &);
 
   bool Pre(const parser::Expr &x) {
@@ -452,23 +452,23 @@ class ExprChecker {
   }
   bool Pre(const parser::DataStmtConstant &);
 
-  template<typename A> bool Pre(const parser::Scalar<A> &x) {
+  template <typename A> bool Pre(const parser::Scalar<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::Constant<A> &x) {
+  template <typename A> bool Pre(const parser::Constant<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::Integer<A> &x) {
+  template <typename A> bool Pre(const parser::Integer<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::Logical<A> &x) {
+  template <typename A> bool Pre(const parser::Logical<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::DefaultChar<A> &x) {
+  template <typename A> bool Pre(const parser::DefaultChar<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
@@ -476,5 +476,5 @@ class ExprChecker {
 private:
   SemanticsContext &context_;
 };
-}  // namespace Fortran::semantics
-#endif  // FORTRAN_SEMANTICS_EXPRESSION_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_EXPRESSION_H_
diff --git a/include/flang/Semantics/scope.h b/include/flang/Semantics/scope.h
index f7cef58bdcd5..b55cf509c78d 100644
--- a/include/flang/Semantics/scope.h
+++ b/include/flang/Semantics/scope.h
@@ -39,13 +39,14 @@ class SemanticsContext;
 struct EquivalenceObject {
   EquivalenceObject(Symbol &symbol, std::vector<ConstantSubscript> subscripts,
       std::optional<ConstantSubscript> substringStart)
-    : symbol{symbol}, subscripts{subscripts}, substringStart{substringStart} {}
+      : symbol{symbol}, subscripts{subscripts}, substringStart{substringStart} {
+  }
   bool operator==(const EquivalenceObject &) const;
   bool operator<(const EquivalenceObject &) const;
   std::string AsFortran() const;
 
   Symbol &symbol;
-  std::vector<ConstantSubscript> subscripts;  // for array elem
+  std::vector<ConstantSubscript> subscripts; // for array elem
   std::optional<ConstantSubscript> substringStart;
 };
 using EquivalenceSet = std::vector<EquivalenceObject>;
@@ -61,7 +62,7 @@ class Scope {
   // Create the Global scope -- the root of the scope tree
   Scope() : Scope{*this, Kind::Global, nullptr} {}
   Scope(Scope &parent, Kind kind, Symbol *symbol)
-    : parent_{parent}, kind_{kind}, symbol_{symbol} {
+      : parent_{parent}, kind_{kind}, symbol_{symbol} {
     if (symbol) {
       symbol->set_scope(this);
     }
@@ -81,7 +82,7 @@ class Scope {
   }
   Kind kind() const { return kind_; }
   bool IsGlobal() const { return kind_ == Kind::Global; }
-  bool IsModule() const;  // only module, not submodule
+  bool IsModule() const; // only module, not submodule
   bool IsSubmodule() const;
   bool IsDerivedType() const { return kind_ == Kind::DerivedType; }
   bool IsParameterizedDerivedType() const;
@@ -127,13 +128,13 @@ class Scope {
     return try_emplace(name, attrs, UnknownDetails());
   }
   /// Make a Symbol with provided details.
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<std::pair<iterator, bool>, D> try_emplace(
       const SourceName &name, D &&details) {
     return try_emplace(name, Attrs(), std::move(details));
   }
   /// Make a Symbol with attrs and details
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<std::pair<iterator, bool>, D> try_emplace(
       const SourceName &name, Attrs attrs, D &&details) {
     Symbol &symbol{MakeSymbol(name, attrs, std::move(details))};
@@ -153,7 +154,7 @@ class Scope {
   Symbol *FindCommonBlock(const SourceName &);
 
   /// Make a Symbol but don't add it to the scope.
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const SourceName &name, Attrs attrs, D &&details) {
     return allSymbols.Make(*this, name, attrs, std::move(details));
@@ -213,10 +214,10 @@ class Scope {
   void InstantiateDerivedTypes(SemanticsContext &);
 
 private:
-  Scope &parent_;  // this is enclosing scope, not extended derived type base
+  Scope &parent_; // this is enclosing scope, not extended derived type base
   const Kind kind_;
   parser::CharBlock sourceRange_;
-  Symbol *const symbol_;  // if not null, symbol_->scope() == this
+  Symbol *const symbol_; // if not null, symbol_->scope() == this
   std::list<Scope> children_;
   mapType symbols_;
   mapType commonBlocks_;
@@ -227,7 +228,7 @@ class Scope {
   std::string chars_;
   std::optional<ImportKind> importKind_;
   std::set<SourceName> importNames_;
-  DerivedTypeSpec *derivedTypeSpec_{nullptr};  // dTS->scope() == this
+  DerivedTypeSpec *derivedTypeSpec_{nullptr}; // dTS->scope() == this
   // When additional data members are added to Scope, remember to
   // copy them, if appropriate, in InstantiateDerivedType().
 
@@ -240,5 +241,5 @@ class Scope {
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Scope &);
 };
-}
-#endif  // FORTRAN_SEMANTICS_SCOPE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_SCOPE_H_
diff --git a/include/flang/Semantics/semantics.h b/include/flang/Semantics/semantics.h
index 8f789e977c1d..0c60a98cd562 100644
--- a/include/flang/Semantics/semantics.h
+++ b/include/flang/Semantics/semantics.h
@@ -43,7 +43,7 @@ struct SelectRankConstruct;
 struct SelectTypeConstruct;
 struct Variable;
 struct WhereConstruct;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -133,18 +133,18 @@ class SemanticsContext {
   bool HasError(const parser::Name &);
   void SetError(Symbol &, bool = true);
 
-  template<typename... A> parser::Message &Say(A &&... args) {
+  template <typename... A> parser::Message &Say(A &&... args) {
     CHECK(location_);
     return messages_.Say(*location_, std::forward<A>(args)...);
   }
-  template<typename... A>
+  template <typename... A>
   parser::Message &Say(parser::CharBlock at, A &&... args) {
     return messages_.Say(at, std::forward<A>(args)...);
   }
   parser::Message &Say(parser::Message &&msg) {
     return messages_.Say(std::move(msg));
   }
-  template<typename... A>
+  template <typename... A>
   void SayWithDecl(const Symbol &symbol, const parser::CharBlock &at,
       parser::MessageFixedText &&msg, A &&... args) {
     auto &message{Say(at, std::move(msg), args...)};
@@ -155,7 +155,7 @@ class SemanticsContext {
   Scope &FindScope(parser::CharBlock);
 
   const ConstructStack &constructStack() const { return constructStack_; }
-  template<typename N> void PushConstruct(const N &node) {
+  template <typename N> void PushConstruct(const N &node) {
     constructStack_.emplace_back(&node);
   }
   void PopConstruct();
@@ -202,7 +202,7 @@ class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
       parser::CookedSource &cooked, bool debugModuleWriter = false)
-    : context_{context}, program_{program}, cooked_{cooked} {
+      : context_{context}, program_{program}, cooked_{cooked} {
     context.set_debugModuleWriter(debugModuleWriter);
     context.globalScope().AddSourceRange(parser::CharBlock{cooked.data()});
   }
@@ -225,8 +225,8 @@ class Semantics {
 
 // Base class for semantics checkers.
 struct BaseChecker {
-  template<typename N> void Enter(const N &) {}
-  template<typename N> void Leave(const N &) {}
+  template <typename N> void Enter(const N &) {}
+  template <typename N> void Leave(const N &) {}
 };
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/include/flang/Semantics/symbol.h b/include/flang/Semantics/symbol.h
index 3eaa95f08e2a..947535c59a7e 100644
--- a/include/flang/Semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -42,8 +42,8 @@ class ModuleDetails {
   ModuleDetails(bool isSubmodule = false) : isSubmodule_{isSubmodule} {}
   bool isSubmodule() const { return isSubmodule_; }
   const Scope *scope() const { return scope_; }
-  const Scope *ancestor() const;  // for submodule; nullptr for module
-  const Scope *parent() const;  // for submodule; nullptr for module
+  const Scope *ancestor() const; // for submodule; nullptr for module
+  const Scope *parent() const; // for submodule; nullptr for module
   void set_scope(const Scope *);
 
 private:
@@ -81,11 +81,11 @@ class SubprogramDetails {
   void set_stmtFunction(SomeExpr &&expr) { stmtFunction_ = std::move(expr); }
 
 private:
-  bool isInterface_{false};  // true if this represents an interface-body
+  bool isInterface_{false}; // true if this represents an interface-body
   MaybeExpr bindName_;
-  std::vector<Symbol *> dummyArgs_;  // nullptr -> alternate return indicator
+  std::vector<Symbol *> dummyArgs_; // nullptr -> alternate return indicator
   Symbol *result_{nullptr};
-  Scope *entryScope_{nullptr};  // if ENTRY, points to subprogram's scope
+  Scope *entryScope_{nullptr}; // if ENTRY, points to subprogram's scope
   MaybeExpr stmtFunction_;
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const SubprogramDetails &);
@@ -102,7 +102,7 @@ ENUM_CLASS(SubprogramKind, Module, Internal)
 class SubprogramNameDetails {
 public:
   SubprogramNameDetails(SubprogramKind kind, ProgramTree &node)
-    : kind_{kind}, node_{node} {}
+      : kind_{kind}, node_{node} {}
   SubprogramNameDetails() = delete;
   SubprogramKind kind() const { return kind_; }
   ProgramTree &node() const { return *node_; }
@@ -186,7 +186,7 @@ class ObjectEntityDetails : public EntityDetails {
   bool initWasValidated_{false};
   ArraySpec shape_;
   ArraySpec coshape_;
-  const Symbol *commonBlock_{nullptr};  // common block this object is in
+  const Symbol *commonBlock_{nullptr}; // common block this object is in
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const ObjectEntityDetails &);
 };
@@ -282,7 +282,7 @@ class ProcBindingDetails : public WithPassArg {
   const Symbol &symbol() const { return symbol_; }
 
 private:
-  SymbolRef symbol_;  // procedure bound to; may be forward
+  SymbolRef symbol_; // procedure bound to; may be forward
 };
 
 class NamelistDetails {
@@ -309,7 +309,7 @@ class CommonBlockDetails {
   MaybeExpr bindName_;
 };
 
-class FinalProcDetails {};  // TODO
+class FinalProcDetails {}; // TODO
 
 class MiscDetails {
 public:
@@ -346,7 +346,7 @@ class TypeParamDetails {
 class UseDetails {
 public:
   UseDetails(const SourceName &location, const Symbol &symbol)
-    : location_{location}, symbol_{symbol} {}
+      : location_{location}, symbol_{symbol} {}
   const SourceName &location() const { return location_; }
   const Symbol &symbol() const { return symbol_; }
   const Symbol &module() const;
@@ -383,10 +383,10 @@ class HostAssocDetails {
 // defined assignment, intrinsic operator, or defined I/O.
 struct GenericKind {
   ENUM_CLASS(OtherKind, Name, DefinedOp, Assignment, Concat)
-  ENUM_CLASS(DefinedIo,  // defined io
+  ENUM_CLASS(DefinedIo, // defined io
       ReadFormatted, ReadUnformatted, WriteFormatted, WriteUnformatted)
   GenericKind() : u{OtherKind::Name} {}
-  template<typename T> GenericKind(const T &x) { u = x; }
+  template <typename T> GenericKind(const T &x) { u = x; }
   bool IsName() const { return Is(OtherKind::Name); }
   bool IsAssignment() const { return Is(OtherKind::Assignment); }
   bool IsDefinedOperator() const { return Is(OtherKind::DefinedOp); }
@@ -398,7 +398,9 @@ struct GenericKind {
       u;
 
 private:
-  template<typename T> bool Has() const { return std::holds_alternative<T>(u); }
+  template <typename T> bool Has() const {
+    return std::holds_alternative<T>(u);
+  }
   bool Is(OtherKind) const;
 };
 
@@ -463,17 +465,17 @@ std::string DetailsToString(const Details &);
 class Symbol {
 public:
   ENUM_CLASS(Flag,
-      Error,  // an error has been reported on this symbol
-      Function,  // symbol is a function
-      Subroutine,  // symbol is a subroutine
-      Implicit,  // symbol is implicitly typed
-      ModFile,  // symbol came from .mod file
-      ParentComp,  // symbol is the "parent component" of an extended type
+      Error, // an error has been reported on this symbol
+      Function, // symbol is a function
+      Subroutine, // symbol is a subroutine
+      Implicit, // symbol is implicitly typed
+      ModFile, // symbol came from .mod file
+      ParentComp, // symbol is the "parent component" of an extended type
       CrayPointer, CrayPointee,
-      LocalityLocal,  // named in LOCAL locality-spec
-      LocalityLocalInit,  // named in LOCAL_INIT locality-spec
-      LocalityShared,  // named in SHARED locality-spec
-      InDataStmt,  // initialized in a DATA statement
+      LocalityLocal, // named in LOCAL locality-spec
+      LocalityLocalInit, // named in LOCAL_INIT locality-spec
+      LocalityShared, // named in SHARED locality-spec
+      InDataStmt, // initialized in a DATA statement
 
       // OpenMP data-sharing attribute
       OmpShared, OmpPrivate, OmpLinear, OmpFirstPrivate, OmpLastPrivate,
@@ -501,21 +503,21 @@ class Symbol {
   void ReplaceName(const SourceName &);
 
   // Does symbol have this type of details?
-  template<typename D> bool has() const {
+  template <typename D> bool has() const {
     return std::holds_alternative<D>(details_);
   }
 
   // Return a non-owning pointer to details if it is type D, else nullptr.
-  template<typename D> D *detailsIf() { return std::get_if<D>(&details_); }
-  template<typename D> const D *detailsIf() const {
+  template <typename D> D *detailsIf() { return std::get_if<D>(&details_); }
+  template <typename D> const D *detailsIf() const {
     return std::get_if<D>(&details_);
   }
 
   // Return a reference to the details which must be of type D.
-  template<typename D> D &get() {
+  template <typename D> D &get() {
     return const_cast<D &>(const_cast<const Symbol *>(this)->get<D>());
   }
-  template<typename D> const D &get() const {
+  template <typename D> const D &get() const {
     const auto *p{detailsIf<D>()};
     CHECK(p);
     return *p;
@@ -582,24 +584,24 @@ class Symbol {
   bool IsSubprogram() const;
   bool IsFromModFile() const;
   bool HasExplicitInterface() const {
-    return std::visit(
-        common::visitors{
-            [](const SubprogramDetails &) { return true; },
-            [](const SubprogramNameDetails &) { return true; },
-            [&](const ProcEntityDetails &x) {
-              return attrs_.test(Attr::INTRINSIC) || x.HasExplicitInterface();
-            },
-            [](const ProcBindingDetails &x) {
-              return x.symbol().HasExplicitInterface();
-            },
-            [](const UseDetails &x) {
-              return x.symbol().HasExplicitInterface();
-            },
-            [](const HostAssocDetails &x) {
-              return x.symbol().HasExplicitInterface();
-            },
-            [](const auto &) { return false; },
-        },
+    return std::visit(common::visitors{
+                          [](const SubprogramDetails &) { return true; },
+                          [](const SubprogramNameDetails &) { return true; },
+                          [&](const ProcEntityDetails &x) {
+                            return attrs_.test(Attr::INTRINSIC) ||
+                                x.HasExplicitInterface();
+                          },
+                          [](const ProcBindingDetails &x) {
+                            return x.symbol().HasExplicitInterface();
+                          },
+                          [](const UseDetails &x) {
+                            return x.symbol().HasExplicitInterface();
+                          },
+                          [](const HostAssocDetails &x) {
+                            return x.symbol().HasExplicitInterface();
+                          },
+                          [](const auto &) { return false; },
+                      },
         details_);
   }
 
@@ -668,7 +670,7 @@ class Symbol {
   Scope *scope_{nullptr};
   Details details_;
 
-  Symbol() {}  // only created in class Symbols
+  Symbol() {} // only created in class Symbols
   const std::string GetDetailsName() const;
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Symbol &);
   friend llvm::raw_ostream &DumpForUnparse(
@@ -679,8 +681,8 @@ class Symbol {
   // can be overridden.
   const Symbol *GetParentComponent(const Scope * = nullptr) const;
 
-  template<std::size_t> friend class Symbols;
-  template<class, std::size_t> friend struct std::array;
+  template <std::size_t> friend class Symbols;
+  template <class, std::size_t> friend struct std::array;
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, Symbol::Flag);
@@ -688,7 +690,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &, Symbol::Flag);
 // Manage memory for all symbols. BLOCK_SIZE symbols at a time are allocated.
 // Make() returns a reference to the next available one. They are never
 // deleted.
-template<std::size_t BLOCK_SIZE> class Symbols {
+template <std::size_t BLOCK_SIZE> class Symbols {
 public:
   Symbol &Make(const Scope &owner, const SourceName &name, const Attrs &attrs,
       Details &&details) {
@@ -713,7 +715,7 @@ template<std::size_t BLOCK_SIZE> class Symbols {
     }
     Symbol &result = (*currBlock_)[nextIndex_];
     if (++nextIndex_ >= BLOCK_SIZE) {
-      nextIndex_ = 0;  // allocate a new block next time
+      nextIndex_ = 0; // allocate a new block next time
     }
     return result;
   }
@@ -733,5 +735,5 @@ inline bool ProcEntityDetails::HasExplicitInterface() const {
 inline bool operator<(SymbolRef x, SymbolRef y) { return *x < *y; }
 using SymbolSet = std::set<SymbolRef>;
 
-}
-#endif  // FORTRAN_SEMANTICS_SYMBOL_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_SYMBOL_H_
diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index da752d136024..e6a3a2eb53f1 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -90,8 +90,8 @@ bool IsPureProcedure(const Scope &);
 bool IsBindCProcedure(const Symbol &);
 bool IsBindCProcedure(const Scope &);
 bool IsProcedure(const Symbol &);
-bool IsProcName(const Symbol &symbol);  // proc-name
-bool IsVariableName(const Symbol &symbol);  // variable-name
+bool IsProcName(const Symbol &symbol); // proc-name
+bool IsVariableName(const Symbol &symbol); // variable-name
 bool IsProcedurePointer(const Symbol &);
 bool IsFunctionResult(const Symbol &);
 bool IsFunctionResultWithSameNameAsFunction(const Symbol &);
@@ -211,12 +211,12 @@ const Symbol *FindSeparateModuleSubprogramInterface(const Symbol *);
 // diagnostic purposes if so.
 const Symbol *FindExternallyVisibleObject(const Symbol &, const Scope &);
 
-template<typename A>
+template <typename A>
 const Symbol *FindExternallyVisibleObject(const A &, const Scope &) {
-  return nullptr;  // default base case
+  return nullptr; // default base case
 }
 
-template<typename T>
+template <typename T>
 const Symbol *FindExternallyVisibleObject(
     const evaluate::Designator<T> &designator, const Scope &scope) {
   if (const Symbol * symbol{designator.GetBaseObject().symbol()}) {
@@ -229,7 +229,7 @@ const Symbol *FindExternallyVisibleObject(
   }
 }
 
-template<typename T>
+template <typename T>
 const Symbol *FindExternallyVisibleObject(
     const evaluate::Expr<T> &expr, const Scope &scope) {
   return std::visit(
@@ -247,13 +247,13 @@ bool ExprTypeKindIsDefault(
 struct GetExprHelper {
   const SomeExpr *Get(const parser::Expr &);
   const SomeExpr *Get(const parser::Variable &);
-  template<typename T> const SomeExpr *Get(const common::Indirection<T> &x) {
+  template <typename T> const SomeExpr *Get(const common::Indirection<T> &x) {
     return Get(x.value());
   }
-  template<typename T> const SomeExpr *Get(const std::optional<T> &x) {
+  template <typename T> const SomeExpr *Get(const std::optional<T> &x) {
     return x ? Get(*x) : nullptr;
   }
-  template<typename T> const SomeExpr *Get(const T &x) {
+  template <typename T> const SomeExpr *Get(const T &x) {
     if constexpr (ConstraintTrait<T>) {
       return Get(x.thing);
     } else if constexpr (WrapperTrait<T>) {
@@ -264,7 +264,7 @@ struct GetExprHelper {
   }
 };
 
-template<typename T> const SomeExpr *GetExpr(const T &x) {
+template <typename T> const SomeExpr *GetExpr(const T &x) {
   return GetExprHelper{}.Get(x);
 }
 
@@ -272,7 +272,7 @@ const evaluate::Assignment *GetAssignment(const parser::AssignmentStmt &);
 const evaluate::Assignment *GetAssignment(
     const parser::PointerAssignmentStmt &);
 
-template<typename T> std::optional<std::int64_t> GetIntValue(const T &x) {
+template <typename T> std::optional<std::int64_t> GetIntValue(const T &x) {
   if (const auto *expr{GetExpr(x)}) {
     return evaluate::ToInt64(*expr);
   } else {
@@ -280,7 +280,7 @@ template<typename T> std::optional<std::int64_t> GetIntValue(const T &x) {
   }
 }
 
-template<typename T> bool IsZero(const T &expr) {
+template <typename T> bool IsZero(const T &expr) {
   auto value{GetIntValue(expr)};
   return value && *value == 0;
 }
@@ -347,7 +347,7 @@ template<typename T> bool IsZero(const T &expr) {
 
 ENUM_CLASS(ComponentKind, Ordered, Direct, Ultimate, Potential, Scope)
 
-template<ComponentKind componentKind> class ComponentIterator {
+template <ComponentKind componentKind> class ComponentIterator {
 public:
   ComponentIterator(const DerivedTypeSpec &derived) : derived_{derived} {}
   class const_iterator {
@@ -404,7 +404,7 @@ template<ComponentKind componentKind> class ComponentIterator {
     class ComponentPathNode {
     public:
       explicit ComponentPathNode(const DerivedTypeSpec &derived)
-        : derived_{derived} {
+          : derived_{derived} {
         if constexpr (componentKind == ComponentKind::Scope) {
           const Scope &scope{DEREF(derived.scope())};
           nameIterator_ = scope.cbegin();
@@ -436,7 +436,7 @@ template<ComponentKind componentKind> class ComponentIterator {
       common::Reference<const DerivedTypeSpec> derived_;
       name_iterator nameEnd_;
       name_iterator nameIterator_;
-      const Symbol *component_{nullptr};  // until Increment()
+      const Symbol *component_{nullptr}; // until Increment()
       bool visited_{false};
       bool descended_{false};
     };
@@ -495,16 +495,16 @@ class LabelEnforce {
 public:
   LabelEnforce(SemanticsContext &context, std::set<parser::Label> &&labels,
       parser::CharBlock constructSourcePosition, const char *construct)
-    : context_{context}, labels_{labels},
-      constructSourcePosition_{constructSourcePosition}, construct_{construct} {
-  }
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> bool Pre(const parser::Statement<T> &statement) {
+      : context_{context}, labels_{labels},
+        constructSourcePosition_{constructSourcePosition}, construct_{
+                                                               construct} {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     return true;
   }
 
-  template<typename T> void Post(const T &) {}
+  template <typename T> void Post(const T &) {}
 
   void Post(const parser::GotoStmt &gotoStmt);
   void Post(const parser::ComputedGotoStmt &computedGotoStmt);
@@ -529,5 +529,5 @@ class LabelEnforce {
       parser::CharBlock stmtLocation, parser::MessageFormattedText &&message,
       parser::CharBlock constructLocation);
 };
-}
-#endif  // FORTRAN_SEMANTICS_TOOLS_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_TOOLS_H_
diff --git a/include/flang/Semantics/type.h b/include/flang/Semantics/type.h
index f18114b1f380..00f38e2157f4 100644
--- a/include/flang/Semantics/type.h
+++ b/include/flang/Semantics/type.h
@@ -72,7 +72,7 @@ class Bound {
   enum class Category { Explicit, Deferred, Assumed };
   Bound(Category category) : category_{category} {}
   Bound(Category category, MaybeSubscriptIntExpr &&expr)
-    : category_{category}, expr_{std::move(expr)} {}
+      : category_{category}, expr_{std::move(expr)} {}
   Category category_{Category::Explicit};
   MaybeSubscriptIntExpr expr_;
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Bound &);
@@ -107,7 +107,7 @@ class ParamValue {
 private:
   enum class Category { Explicit, Deferred, Assumed };
   ParamValue(Category category, common::TypeParamAttr attr)
-    : category_{category}, attr_{attr} {}
+      : category_{category}, attr_{attr} {}
   Category category_{Category::Explicit};
   common::TypeParamAttr attr_{common::TypeParamAttr::Kind};
   MaybeIntExpr expr_;
@@ -130,13 +130,14 @@ class IntrinsicTypeSpec {
 private:
   TypeCategory category_;
   KindExpr kind_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const IntrinsicTypeSpec &x);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &os, const IntrinsicTypeSpec &x);
 };
 
 class NumericTypeSpec : public IntrinsicTypeSpec {
 public:
   NumericTypeSpec(TypeCategory category, KindExpr &&kind)
-    : IntrinsicTypeSpec(category, std::move(kind)) {
+      : IntrinsicTypeSpec(category, std::move(kind)) {
     CHECK(common::IsNumericTypeCategory(category));
   }
 };
@@ -144,20 +145,21 @@ class NumericTypeSpec : public IntrinsicTypeSpec {
 class LogicalTypeSpec : public IntrinsicTypeSpec {
 public:
   explicit LogicalTypeSpec(KindExpr &&kind)
-    : IntrinsicTypeSpec(TypeCategory::Logical, std::move(kind)) {}
+      : IntrinsicTypeSpec(TypeCategory::Logical, std::move(kind)) {}
 };
 
 class CharacterTypeSpec : public IntrinsicTypeSpec {
 public:
   CharacterTypeSpec(ParamValue &&length, KindExpr &&kind)
-    : IntrinsicTypeSpec(TypeCategory::Character, std::move(kind)),
-      length_{std::move(length)} {}
+      : IntrinsicTypeSpec(TypeCategory::Character, std::move(kind)),
+        length_{std::move(length)} {}
   const ParamValue &length() const { return length_; }
   std::string AsFortran() const;
 
 private:
   ParamValue length_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharacterTypeSpec &x);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &os, const CharacterTypeSpec &x);
 };
 
 class ShapeSpec {
@@ -224,7 +226,7 @@ struct ArraySpec : public std::vector<ShapeSpec> {
 
 private:
   // Check non-empty and predicate is true for each element.
-  template<typename P> bool CheckAll(P predicate) const {
+  template <typename P> bool CheckAll(P predicate) const {
     return !empty() && std::all_of(begin(), end(), predicate);
   }
 };
@@ -287,13 +289,14 @@ class DerivedTypeSpec {
 private:
   SourceName name_;
   const Symbol &typeSymbol_;
-  const Scope *scope_{nullptr};  // same as typeSymbol_.scope() unless PDT
+  const Scope *scope_{nullptr}; // same as typeSymbol_.scope() unless PDT
   bool cooked_{false};
   bool evaluated_{false};
   bool instantiated_{false};
   RawParameters rawParameters_;
   ParameterMapType parameters_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DerivedTypeSpec &);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const DerivedTypeSpec &);
 };
 
 class DeclTypeSpec {
@@ -351,18 +354,24 @@ class DeclTypeSpec {
   IntrinsicTypeSpec *AsIntrinsic();
   const IntrinsicTypeSpec *AsIntrinsic() const {
     switch (category_) {
-    case Numeric: return &std::get<NumericTypeSpec>(typeSpec_);
-    case Logical: return &std::get<LogicalTypeSpec>(typeSpec_);
-    case Character: return &std::get<CharacterTypeSpec>(typeSpec_);
-    default: return nullptr;
+    case Numeric:
+      return &std::get<NumericTypeSpec>(typeSpec_);
+    case Logical:
+      return &std::get<LogicalTypeSpec>(typeSpec_);
+    case Character:
+      return &std::get<CharacterTypeSpec>(typeSpec_);
+    default:
+      return nullptr;
     }
   }
 
   const DerivedTypeSpec *AsDerived() const {
     switch (category_) {
     case TypeDerived:
-    case ClassDerived: return &std::get<DerivedTypeSpec>(typeSpec_);
-    default: return nullptr;
+    case ClassDerived:
+      return &std::get<DerivedTypeSpec>(typeSpec_);
+    default:
+      return nullptr;
     }
   }
 
@@ -390,5 +399,5 @@ class ProcInterface {
   const Symbol *symbol_{nullptr};
   const DeclTypeSpec *type_{nullptr};
 };
-}
-#endif  // FORTRAN_SEMANTICS_TYPE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_TYPE_H_
diff --git a/include/flang/Semantics/unparse-with-symbols.h b/include/flang/Semantics/unparse-with-symbols.h
index 9bea94223e8a..d70110245e2b 100644
--- a/include/flang/Semantics/unparse-with-symbols.h
+++ b/include/flang/Semantics/unparse-with-symbols.h
@@ -25,4 +25,4 @@ void UnparseWithSymbols(llvm::raw_ostream &, const parser::Program &,
     parser::Encoding encoding = parser::Encoding::UTF_8);
 }
 
-#endif  // FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
+#endif // FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
diff --git a/lib/Common/Fortran-features.cpp b/lib/Common/Fortran-features.cpp
index a9e03395cab2..25a948818e65 100644
--- a/lib/Common/Fortran-features.cpp
+++ b/lib/Common/Fortran-features.cpp
@@ -22,15 +22,22 @@ std::vector<const char *> LanguageFeatureControl::GetNames(
   if (IsEnabled(LanguageFeature::LogicalAbbreviations)) {
     switch (opr) {
       SWITCH_COVERS_ALL_CASES
-    case LogicalOperator::And: result.push_back(".a."); break;
-    case LogicalOperator::Or: result.push_back(".o."); break;
-    case LogicalOperator::Not: result.push_back(".n."); break;
+    case LogicalOperator::And:
+      result.push_back(".a.");
+      break;
+    case LogicalOperator::Or:
+      result.push_back(".o.");
+      break;
+    case LogicalOperator::Not:
+      result.push_back(".n.");
+      break;
     case LogicalOperator::Neqv:
       if (IsEnabled(LanguageFeature::XOROperator)) {
         result.push_back(".x.");
       }
       break;
-    case LogicalOperator::Eqv: break;
+    case LogicalOperator::Eqv:
+      break;
     }
   }
   return result;
@@ -40,11 +47,16 @@ std::vector<const char *> LanguageFeatureControl::GetNames(
     RelationalOperator opr) const {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case RelationalOperator::LT: return {".lt.", "<"};
-  case RelationalOperator::LE: return {".le.", "<="};
-  case RelationalOperator::EQ: return {".eq.", "=="};
-  case RelationalOperator::GE: return {".ge.", ">="};
-  case RelationalOperator::GT: return {".gt.", ">"};
+  case RelationalOperator::LT:
+    return {".lt.", "<"};
+  case RelationalOperator::LE:
+    return {".le.", "<="};
+  case RelationalOperator::EQ:
+    return {".eq.", "=="};
+  case RelationalOperator::GE:
+    return {".ge.", ">="};
+  case RelationalOperator::GT:
+    return {".gt.", ">"};
   case RelationalOperator::NE:
     if (IsEnabled(LanguageFeature::AlternativeNE)) {
       return {".ne.", "/=", "<>"};
@@ -54,4 +66,4 @@ std::vector<const char *> LanguageFeatureControl::GetNames(
   }
 }
 
-}
+} // namespace Fortran::common
diff --git a/lib/Common/Fortran.cpp b/lib/Common/Fortran.cpp
index d65a17e6a7b7..45a061451168 100644
--- a/lib/Common/Fortran.cpp
+++ b/lib/Common/Fortran.cpp
@@ -13,35 +13,51 @@ namespace Fortran::common {
 const char *AsFortran(NumericOperator opr) {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case NumericOperator::Power: return "**";
-  case NumericOperator::Multiply: return "*";
-  case NumericOperator::Divide: return "/";
-  case NumericOperator::Add: return "+";
-  case NumericOperator::Subtract: return "-";
+  case NumericOperator::Power:
+    return "**";
+  case NumericOperator::Multiply:
+    return "*";
+  case NumericOperator::Divide:
+    return "/";
+  case NumericOperator::Add:
+    return "+";
+  case NumericOperator::Subtract:
+    return "-";
   }
 }
 
 const char *AsFortran(LogicalOperator opr) {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case LogicalOperator::And: return ".and.";
-  case LogicalOperator::Or: return ".or.";
-  case LogicalOperator::Eqv: return ".eqv.";
-  case LogicalOperator::Neqv: return ".neqv.";
-  case LogicalOperator::Not: return ".not.";
+  case LogicalOperator::And:
+    return ".and.";
+  case LogicalOperator::Or:
+    return ".or.";
+  case LogicalOperator::Eqv:
+    return ".eqv.";
+  case LogicalOperator::Neqv:
+    return ".neqv.";
+  case LogicalOperator::Not:
+    return ".not.";
   }
 }
 
 const char *AsFortran(RelationalOperator opr) {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case RelationalOperator::LT: return "<";
-  case RelationalOperator::LE: return "<=";
-  case RelationalOperator::EQ: return "==";
-  case RelationalOperator::NE: return "/=";
-  case RelationalOperator::GE: return ">=";
-  case RelationalOperator::GT: return ">";
+  case RelationalOperator::LT:
+    return "<";
+  case RelationalOperator::LE:
+    return "<=";
+  case RelationalOperator::EQ:
+    return "==";
+  case RelationalOperator::NE:
+    return "/=";
+  case RelationalOperator::GE:
+    return ">=";
+  case RelationalOperator::GT:
+    return ">";
   }
 }
 
-}
+} // namespace Fortran::common
diff --git a/lib/Common/default-kinds.cpp b/lib/Common/default-kinds.cpp
index 8470cfc6d137..0c708fcd6050 100644
--- a/lib/Common/default-kinds.cpp
+++ b/lib/Common/default-kinds.cpp
@@ -67,12 +67,18 @@ IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_defaultLogicalKind(
 
 int IntrinsicTypeDefaultKinds::GetDefaultKind(TypeCategory category) const {
   switch (category) {
-  case TypeCategory::Integer: return defaultIntegerKind_;
+  case TypeCategory::Integer:
+    return defaultIntegerKind_;
   case TypeCategory::Real:
-  case TypeCategory::Complex: return defaultRealKind_;
-  case TypeCategory::Character: return defaultCharacterKind_;
-  case TypeCategory::Logical: return defaultLogicalKind_;
-  default: CRASH_NO_CASE; return 0;
+  case TypeCategory::Complex:
+    return defaultRealKind_;
+  case TypeCategory::Character:
+    return defaultCharacterKind_;
+  case TypeCategory::Logical:
+    return defaultLogicalKind_;
+  default:
+    CRASH_NO_CASE;
+    return 0;
   }
 }
-}
+} // namespace Fortran::common
diff --git a/lib/Common/idioms.cpp b/lib/Common/idioms.cpp
index 229e1c062d8c..cf6ff87b1bb1 100644
--- a/lib/Common/idioms.cpp
+++ b/lib/Common/idioms.cpp
@@ -40,4 +40,4 @@ std::string EnumIndexToString(int index, const char *enumNames) {
   }
   return std::string(p, q - p);
 }
-}
+} // namespace Fortran::common
diff --git a/lib/Decimal/big-radix-floating-point.h b/lib/Decimal/big-radix-floating-point.h
index 4af217a52b42..9c940fe7d6d8 100644
--- a/lib/Decimal/big-radix-floating-point.h
+++ b/lib/Decimal/big-radix-floating-point.h
@@ -40,7 +40,7 @@ static constexpr std::uint64_t TenToThe(int power) {
 // 10**(LOG10RADIX + 3) must be < 2**wordbits, and LOG10RADIX must be
 // even, so that pairs of decimal digits do not straddle Digits.
 // So LOG10RADIX must be 16 or 6.
-template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
+template <int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 public:
   using Real = BinaryFloatingPointNumber<PREC>;
   static constexpr int log10Radix{LOG10RADIX};
@@ -67,7 +67,7 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 public:
   explicit BigRadixFloatingPointNumber(
       enum FortranRounding rounding = RoundDefault)
-    : rounding_{rounding} {}
+      : rounding_{rounding} {}
 
   // Converts a binary floating point value.
   explicit BigRadixFloatingPointNumber(
@@ -113,8 +113,8 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 
 private:
   BigRadixFloatingPointNumber(const BigRadixFloatingPointNumber &that)
-    : digits_{that.digits_}, exponent_{that.exponent_},
-      isNegative_{that.isNegative_}, rounding_{that.rounding_} {
+      : digits_{that.digits_}, exponent_{that.exponent_},
+        isNegative_{that.isNegative_}, rounding_{that.rounding_} {
     for (int j{0}; j < digits_; ++j) {
       digit_[j] = that.digit_[j];
     }
@@ -140,7 +140,7 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 
   // Sets *this to an unsigned integer value.
   // Returns any remainder.
-  template<typename UINT> UINT SetTo(UINT n) {
+  template <typename UINT> UINT SetTo(UINT n) {
     static_assert(
         std::is_same_v<UINT, common::uint128_t> || std::is_unsigned_v<UINT>);
     SetToZero();
@@ -198,12 +198,12 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 
   // This limited divisibility test only works for even divisors of the radix,
   // which is fine since it's only ever used with 2 and 5.
-  template<int N> bool IsDivisibleBy() const {
+  template <int N> bool IsDivisibleBy() const {
     static_assert(N > 1 && radix % N == 0, "bad modulus");
     return digits_ == 0 || (digit_[0] % N) == 0;
   }
 
-  template<unsigned DIVISOR> int DivideBy() {
+  template <unsigned DIVISOR> int DivideBy() {
     Digit remainder{0};
     for (int j{digits_ - 1}; j >= 0; --j) {
       Digit q{common::DivideUnsignedBy<Digit, DIVISOR>(digit_[j])};
@@ -214,7 +214,7 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
     return remainder;
   }
 
-  int DivideByPowerOfTwo(int twoPow) {  // twoPow <= LOG10RADIX
+  int DivideByPowerOfTwo(int twoPow) { // twoPow <= LOG10RADIX
     int remainder{0};
     for (int j{digits_ - 1}; j >= 0; --j) {
       Digit q{digit_[j] >> twoPow};
@@ -253,16 +253,16 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
     }
   }
 
-  template<int N> int MultiplyByHelper(int carry = 0) {
+  template <int N> int MultiplyByHelper(int carry = 0) {
     for (int j{0}; j < digits_; ++j) {
       auto v{N * digit_[j] + carry};
       carry = common::DivideUnsignedBy<Digit, radix>(v);
-      digit_[j] = v - carry * radix;  // i.e., v % radix
+      digit_[j] = v - carry * radix; // i.e., v % radix
     }
     return carry;
   }
 
-  template<int N> int MultiplyBy(int carry = 0) {
+  template <int N> int MultiplyBy(int carry = 0) {
     if (int newCarry{MultiplyByHelper<N>(carry)}) {
       return AddCarry(digits_, newCarry);
     } else {
@@ -270,7 +270,7 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
     }
   }
 
-  template<int N> int MultiplyWithoutNormalization() {
+  template <int N> int MultiplyWithoutNormalization() {
     if (int carry{MultiplyByHelper<N>(0)}) {
       if (digits_ < digitLimit_) {
         digit_[digits_++] = carry;
@@ -283,7 +283,7 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
     }
   }
 
-  template<int N> void MultiplyByRounded() {
+  template <int N> void MultiplyByRounded() {
     if (int carry{MultiplyBy<N>()}) {
       LoseLeastSignificantDigit();
       digit_[digits_ - 1] += carry;
@@ -291,7 +291,7 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
     }
   }
 
-  void LoseLeastSignificantDigit();  // with rounding
+  void LoseLeastSignificantDigit(); // with rounding
 
   void PushCarry(int carry) {
     if (digits_ == maxDigits && RemoveLeastOrderZeroDigits() == 0) {
@@ -319,12 +319,12 @@ template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
         (Raw{1} << (Real::significandBits - 2));
   }
 
-  Digit digit_[maxDigits];  // in little-endian order: digit_[0] is LSD
-  int digits_{0};  // # of elements in digit_[] array; zero when zero
-  int digitLimit_{maxDigits};  // precision clamp
-  int exponent_{0};  // signed power of ten
+  Digit digit_[maxDigits]; // in little-endian order: digit_[0] is LSD
+  int digits_{0}; // # of elements in digit_[] array; zero when zero
+  int digitLimit_{maxDigits}; // precision clamp
+  int exponent_{0}; // signed power of ten
   bool isNegative_{false};
   enum FortranRounding rounding_ { RoundDefault };
 };
-}
+} // namespace Fortran::decimal
 #endif
diff --git a/lib/Decimal/binary-to-decimal.cpp b/lib/Decimal/binary-to-decimal.cpp
index f4e57681af95..a7af4036f0d6 100644
--- a/lib/Decimal/binary-to-decimal.cpp
+++ b/lib/Decimal/binary-to-decimal.cpp
@@ -11,10 +11,10 @@
 
 namespace Fortran::decimal {
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::BigRadixFloatingPointNumber(
     BinaryFloatingPointNumber<PREC> x, enum FortranRounding rounding)
-  : rounding_{rounding} {
+    : rounding_{rounding} {
   bool negative{x.IsNegative()};
   if (x.IsZero()) {
     isNegative_ = negative;
@@ -104,7 +104,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::BigRadixFloatingPointNumber(
   Normalize();
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 ConversionToDecimalResult
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
     std::size_t n, enum DecimalConversionFlags flags, int maxDigits) const {
@@ -176,10 +176,17 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
       incr = *end > '5' ||
           (*end == '5' && (p > end + 1 || ((end[-1] - '0') & 1) != 0));
       break;
-    case RoundUp: incr = !isNegative_; break;
-    case RoundDown: incr = isNegative_; break;
-    case RoundToZero: break;
-    case RoundCompatible: incr = *end >= '5'; break;
+    case RoundUp:
+      incr = !isNegative_;
+      break;
+    case RoundDown:
+      incr = isNegative_;
+      break;
+    case RoundToZero:
+      break;
+    case RoundCompatible:
+      incr = *end >= '5';
+      break;
     }
     p = end;
     if (incr) {
@@ -199,7 +206,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
   }
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Mean(
     const BigRadixFloatingPointNumber &that) {
   while (digits_ < that.digits_) {
@@ -222,7 +229,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Mean(
   return DivideBy<2>() != 0;
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 void BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Minimize(
     BigRadixFloatingPointNumber &&less, BigRadixFloatingPointNumber &&more) {
   int leastExponent{exponent_};
@@ -245,10 +252,10 @@ void BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Minimize(
     more.MultiplyBy<10>();
   }
   if (less.Mean(*this)) {
-    less.AddCarry();  // round up
+    less.AddCarry(); // round up
   }
   if (!more.Mean(*this)) {
-    more.Decrement();  // round down
+    more.Decrement(); // round down
   }
   while (less.digits_ < more.digits_) {
     less.digit_[less.digits_++] = 0;
@@ -292,7 +299,7 @@ void BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Minimize(
   Normalize();
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 void BigRadixFloatingPointNumber<PREC,
     LOG10RADIX>::LoseLeastSignificantDigit() {
   Digit LSD{digit_[0]};
@@ -306,17 +313,24 @@ void BigRadixFloatingPointNumber<PREC,
   case RoundDefault:
     incr = LSD > radix / 2 || (LSD == radix / 2 && digit_[0] % 2 != 0);
     break;
-  case RoundUp: incr = LSD > 0 && !isNegative_; break;
-  case RoundDown: incr = LSD > 0 && isNegative_; break;
-  case RoundToZero: break;
-  case RoundCompatible: incr = LSD >= radix / 2; break;
+  case RoundUp:
+    incr = LSD > 0 && !isNegative_;
+    break;
+  case RoundDown:
+    incr = LSD > 0 && isNegative_;
+    break;
+  case RoundToZero:
+    break;
+  case RoundCompatible:
+    incr = LSD >= radix / 2;
+    break;
   }
   for (int j{0}; (digit_[j] += incr) == radix; ++j) {
     digit_[j] = 0;
   }
 }
 
-template<int PREC>
+template <int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *buffer, std::size_t size,
     enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, BinaryFloatingPointNumber<PREC> x) {
@@ -398,4 +412,4 @@ ConversionToDecimalResult ConvertLongDoubleToDecimal(char *buffer,
 }
 #endif
 }
-}
+} // namespace Fortran::decimal
diff --git a/lib/Decimal/decimal-to-binary.cpp b/lib/Decimal/decimal-to-binary.cpp
index 586c7f869e80..f7efb230faf2 100644
--- a/lib/Decimal/decimal-to-binary.cpp
+++ b/lib/Decimal/decimal-to-binary.cpp
@@ -17,7 +17,7 @@
 
 namespace Fortran::decimal {
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
     const char *&p, bool &inexact) {
   SetToZero();
@@ -43,7 +43,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
     }
   }
   if (q == start || (q == start + 1 && *start == '.')) {
-    return false;  // require at least one digit
+    return false; // require at least one digit
   }
   // There's a valid number here; set the reference argument to point to
   // the first character afterward.
@@ -81,7 +81,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
     exponent_ -= static_cast<int>(q - point - 1);
   }
   if (q == first) {
-    exponent_ = 0;  // all zeros
+    exponent_ = 0; // all zeros
   }
   // Rack the decimal digits up into big Digits.
   for (auto times{radix}; q-- > first;) {
@@ -125,7 +125,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
         expo = 10 * Real::decimalRange;
         exponent_ = 0;
       }
-      p = q;  // exponent was valid
+      p = q; // exponent was valid
       if (negExpo) {
         exponent_ -= expo;
       } else {
@@ -133,7 +133,8 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
       }
     }
   } break;
-  default: break;
+  default:
+    break;
   }
   return true;
 }
@@ -142,7 +143,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
 // binary floating-point value with an unbiased (i.e., signed)
 // binary exponent, an integer value (not a fraction) with an implied
 // binary point to its *right*, and some guard bits for rounding.
-template<int PREC> class IntermediateFloat {
+template <int PREC> class IntermediateFloat {
 public:
   static constexpr int precision{PREC};
   using IntType = common::HostUnsignedIntType<precision>;
@@ -154,7 +155,7 @@ template<int PREC> class IntermediateFloat {
 
   // Assumes that exponent_ is valid on entry, and may increment it.
   // Returns the number of guard_ bits that have been determined.
-  template<typename UINT> bool SetTo(UINT n) {
+  template <typename UINT> bool SetTo(UINT n) {
     static constexpr int nBits{CHAR_BIT * sizeof n};
     if constexpr (precision >= nBits) {
       value_ = n;
@@ -187,7 +188,7 @@ template<int PREC> class IntermediateFloat {
       bool isNegative, FortranRounding) const;
 
 private:
-  static constexpr int guardBits{3};  // guard, round, sticky
+  static constexpr int guardBits{3}; // guard, round, sticky
   using GuardType = int;
   static constexpr GuardType oneHalf{GuardType{1} << (guardBits - 1)};
 
@@ -196,7 +197,7 @@ template<int PREC> class IntermediateFloat {
   int exponent_{0};
 };
 
-template<int PREC>
+template <int PREC>
 ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
     bool isNegative, FortranRounding rounding) const {
   using Binary = BinaryFloatingPointNumber<PREC>;
@@ -231,10 +232,17 @@ ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
   case RoundDefault:
     incr = guard > oneHalf || (guard == oneHalf && (fraction & 1));
     break;
-  case RoundUp: incr = guard != 0 && !isNegative; break;
-  case RoundDown: incr = guard != 0 && isNegative; break;
-  case RoundToZero: break;
-  case RoundCompatible: incr = guard >= oneHalf; break;
+  case RoundUp:
+    incr = guard != 0 && !isNegative;
+    break;
+  case RoundDown:
+    incr = guard != 0 && isNegative;
+    break;
+  case RoundToZero:
+    break;
+  case RoundCompatible:
+    incr = guard >= oneHalf;
+    break;
   }
   if (incr) {
     if (fraction == mask) {
@@ -246,10 +254,10 @@ ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
     }
   }
   if (expo == 1 && fraction < topBit) {
-    expo = 0;  // subnormal
+    expo = 0; // subnormal
   }
   if (expo >= Binary::maxExponent) {
-    expo = Binary::maxExponent;  // Inf
+    expo = Binary::maxExponent; // Inf
     flags |= Overflow;
     fraction = 0;
   }
@@ -263,14 +271,14 @@ ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
   return {Binary(raw), static_cast<enum ConversionResultFlags>(flags)};
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 ConversionToBinaryResult<PREC>
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   // On entry, *this holds a multi-precision integer value in a radix of a
   // large power of ten.  Its radix point is defined to be to the right of its
   // digits, and "exponent_" is the power of ten by which it is to be scaled.
   Normalize();
-  if (digits_ == 0) {  // zero value
+  if (digits_ == 0) { // zero value
     return {Real{SignBit()}};
   }
   // The value is not zero:  x = D. * 10.**E
@@ -279,9 +287,9 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   exponent_ += digits_ * log10Radix;
   // Sanity checks for ridiculous exponents
   static constexpr int crazy{2 * Real::decimalRange + log10Radix};
-  if (exponent_ < -crazy) {  // underflow to +/-0.
+  if (exponent_ < -crazy) { // underflow to +/-0.
     return {Real{SignBit()}, Inexact};
-  } else if (exponent_ > crazy) {  // overflow to +/-Inf.
+  } else if (exponent_ > crazy) { // overflow to +/-Inf.
     return {Real{Infinity()}, Overflow};
   }
   // Apply any negative decimal exponent by multiplication
@@ -346,7 +354,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   return f.ToBinary(isNegative_, rounding_);
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 ConversionToBinaryResult<PREC>
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary(const char *&p) {
   bool inexact{false};
@@ -383,7 +391,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary(const char *&p) {
   }
 }
 
-template<int PREC>
+template <int PREC>
 ConversionToBinaryResult<PREC> ConvertToBinary(
     const char *&p, enum FortranRounding rounding) {
   return BigRadixFloatingPointNumber<PREC>{rounding}.ConvertToBinary(p);
@@ -427,4 +435,4 @@ enum ConversionResultFlags ConvertDecimalToLongDouble(
 }
 #endif
 }
-}
+} // namespace Fortran::decimal
diff --git a/lib/Evaluate/call.cpp b/lib/Evaluate/call.cpp
index 31ee05b30873..ae1786c9290d 100644
--- a/lib/Evaluate/call.cpp
+++ b/lib/Evaluate/call.cpp
@@ -18,12 +18,12 @@ namespace Fortran::evaluate {
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ActualArgument)
 ActualArgument::ActualArgument(Expr<SomeType> &&x) : u_{std::move(x)} {}
 ActualArgument::ActualArgument(common::CopyableIndirection<Expr<SomeType>> &&v)
-  : u_{std::move(v)} {}
+    : u_{std::move(v)} {}
 ActualArgument::ActualArgument(AssumedType x) : u_{x} {}
 ActualArgument::~ActualArgument() {}
 
 ActualArgument::AssumedType::AssumedType(const Symbol &symbol)
-  : symbol_{symbol} {
+    : symbol_{symbol} {
   const semantics::DeclTypeSpec *type{symbol.GetType()};
   CHECK(type && type->category() == semantics::DeclTypeSpec::TypeStar);
 }
@@ -65,8 +65,8 @@ void ActualArgument::Parenthesize() {
 
 SpecificIntrinsic::SpecificIntrinsic(
     IntrinsicProcedure n, characteristics::Procedure &&chars)
-  : name{n}, characteristics{new characteristics::Procedure{std::move(chars)}} {
-}
+    : name{n}, characteristics{
+                   new characteristics::Procedure{std::move(chars)}} {}
 
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(SpecificIntrinsic)
 
@@ -77,7 +77,7 @@ bool SpecificIntrinsic::operator==(const SpecificIntrinsic &that) const {
 }
 
 ProcedureDesignator::ProcedureDesignator(Component &&c)
-  : u{common::CopyableIndirection<Component>::Make(std::move(c))} {}
+    : u{common::CopyableIndirection<Component>::Make(std::move(c))} {}
 
 bool ProcedureDesignator::operator==(const ProcedureDesignator &that) const {
   return u == that.u;
@@ -150,14 +150,13 @@ const Component *ProcedureDesignator::GetComponent() const {
 }
 
 const Symbol *ProcedureDesignator::GetSymbol() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return &*symbol; },
-          [](const common::CopyableIndirection<Component> &c) {
-            return &c.value().GetLastSymbol();
-          },
-          [](const auto &) -> const Symbol * { return nullptr; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return &*symbol; },
+                        [](const common::CopyableIndirection<Component> &c) {
+                          return &c.value().GetLastSymbol();
+                        },
+                        [](const auto &) -> const Symbol * { return nullptr; },
+                    },
       u);
 }
 
@@ -213,5 +212,5 @@ int ProcedureRef::Rank() const {
 ProcedureRef::~ProcedureRef() {}
 
 FOR_EACH_SPECIFIC_TYPE(template class FunctionRef, )
-}
+} // namespace Fortran::evaluate
 DEFINE_DELETER(Fortran::evaluate::ProcedureRef)
diff --git a/lib/Evaluate/character.h b/lib/Evaluate/character.h
index ef43a2b3afbb..f5464c733445 100644
--- a/lib/Evaluate/character.h
+++ b/lib/Evaluate/character.h
@@ -19,7 +19,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND> class CharacterUtils {
+template <int KIND> class CharacterUtils {
   using Character = Scalar<Type<TypeCategory::Character, KIND>>;
   using CharT = typename Character::value_type;
 
@@ -117,6 +117,6 @@ template<int KIND> class CharacterUtils {
   static constexpr CharT NewLine() { return 0x0a; }
 };
 
-}
+} // namespace Fortran::evaluate
 
-#endif  // FORTRAN_EVALUATE_CHARACTER_H_
+#endif // FORTRAN_EVALUATE_CHARACTER_H_
diff --git a/lib/Evaluate/characteristics.cpp b/lib/Evaluate/characteristics.cpp
index 867b8116702f..6c4ec1446774 100644
--- a/lib/Evaluate/characteristics.cpp
+++ b/lib/Evaluate/characteristics.cpp
@@ -24,7 +24,7 @@ using namespace Fortran::parser::literals;
 namespace Fortran::evaluate::characteristics {
 
 // Copy attributes from a symbol to dst based on the mapping in pairs.
-template<typename A, typename B>
+template <typename A, typename B>
 static void CopyAttrs(const semantics::Symbol &src, A &dst,
     const std::initializer_list<std::pair<semantics::Attr, B>> &pairs) {
   for (const auto &pair : pairs) {
@@ -245,17 +245,17 @@ bool DummyDataObject::CanBePassedViaImplicitInterface() const {
           Attrs{Attr::Allocatable, Attr::Asynchronous, Attr::Optional,
               Attr::Pointer, Attr::Target, Attr::Value, Attr::Volatile})
           .any()) {
-    return false;  // 15.4.2.2(3)(a)
+    return false; // 15.4.2.2(3)(a)
   } else if ((type.attrs() &
                  TypeAndShape::Attrs{TypeAndShape::Attr::AssumedShape,
                      TypeAndShape::Attr::AssumedRank,
                      TypeAndShape::Attr::Coarray})
                  .any()) {
-    return false;  // 15.4.2.2(3)(b-d)
+    return false; // 15.4.2.2(3)(b-d)
   } else if (type.type().IsPolymorphic()) {
-    return false;  // 15.4.2.2(3)(f)
+    return false; // 15.4.2.2(3)(f)
   } else if (const auto *derived{GetDerivedTypeSpec(type.type())}) {
-    return derived->parameters().empty();  // 15.4.2.2(3)(e)
+    return derived->parameters().empty(); // 15.4.2.2(3)(e)
   } else {
     return true;
   }
@@ -278,7 +278,7 @@ llvm::raw_ostream &DummyDataObject::Dump(llvm::raw_ostream &o) const {
 }
 
 DummyProcedure::DummyProcedure(Procedure &&p)
-  : procedure{new Procedure{std::move(p)}} {}
+    : procedure{new Procedure{std::move(p)}} {}
 
 bool DummyProcedure::operator==(const DummyProcedure &that) const {
   return attrs == that.attrs && intent == that.intent &&
@@ -322,7 +322,7 @@ llvm::raw_ostream &AlternateReturn::Dump(llvm::raw_ostream &o) const {
 DummyArgument::~DummyArgument() {}
 
 bool DummyArgument::operator==(const DummyArgument &that) const {
-  return u == that.u;  // name and passed-object usage are not characteristics
+  return u == that.u; // name and passed-object usage are not characteristics
 }
 
 std::optional<DummyArgument> DummyArgument::Characterize(
@@ -398,16 +398,15 @@ bool DummyArgument::IsOptional() const {
 }
 
 void DummyArgument::SetOptional(bool value) {
-  std::visit(
-      common::visitors{
-          [value](DummyDataObject &data) {
-            data.attrs.set(DummyDataObject::Attr::Optional, value);
-          },
-          [value](DummyProcedure &proc) {
-            proc.attrs.set(DummyProcedure::Attr::Optional, value);
-          },
-          [](AlternateReturn &) { DIE("cannot set optional"); },
-      },
+  std::visit(common::visitors{
+                 [value](DummyDataObject &data) {
+                   data.attrs.set(DummyDataObject::Attr::Optional, value);
+                 },
+                 [value](DummyProcedure &proc) {
+                   proc.attrs.set(DummyProcedure::Attr::Optional, value);
+                 },
+                 [](AlternateReturn &) { DIE("cannot set optional"); },
+             },
       u);
 }
 
@@ -470,17 +469,17 @@ bool FunctionResult::IsAssumedLengthCharacter() const {
 
 bool FunctionResult::CanBeReturnedViaImplicitInterface() const {
   if (attrs.test(Attr::Pointer) || attrs.test(Attr::Allocatable)) {
-    return false;  // 15.4.2.2(4)(b)
+    return false; // 15.4.2.2(4)(b)
   } else if (const auto *typeAndShape{GetTypeAndShape()}) {
     if (typeAndShape->Rank() > 0) {
-      return false;  // 15.4.2.2(4)(a)
+      return false; // 15.4.2.2(4)(a)
     } else {
       const DynamicType &type{typeAndShape->type()};
       switch (type.category()) {
       case TypeCategory::Character:
         if (const auto *param{type.charLength()}) {
           if (const auto &expr{param->GetExplicit()}) {
-            return IsConstantExpr(*expr);  // 15.4.2.2(4)(c)
+            return IsConstantExpr(*expr); // 15.4.2.2(4)(c)
           }
         }
         return false;
@@ -490,38 +489,39 @@ bool FunctionResult::CanBeReturnedViaImplicitInterface() const {
           for (const auto &pair : spec.parameters()) {
             if (const auto &expr{pair.second.GetExplicit()}) {
               if (!IsConstantExpr(*expr)) {
-                return false;  // 15.4.2.2(4)(c)
+                return false; // 15.4.2.2(4)(c)
               }
             }
           }
           return true;
         }
         return false;
-      default: return true;
+      default:
+        return true;
       }
     }
   } else {
-    return false;  // 15.4.2.2(4)(b) - procedure pointer
+    return false; // 15.4.2.2(4)(b) - procedure pointer
   }
 }
 
 llvm::raw_ostream &FunctionResult::Dump(llvm::raw_ostream &o) const {
   attrs.Dump(o, EnumToString);
-  std::visit(
-      common::visitors{
-          [&](const TypeAndShape &ts) { ts.Dump(o); },
-          [&](const CopyableIndirection<Procedure> &p) {
-            p.value().Dump(o << " procedure(") << ')';
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const TypeAndShape &ts) { ts.Dump(o); },
+                 [&](const CopyableIndirection<Procedure> &p) {
+                   p.value().Dump(o << " procedure(") << ')';
+                 },
+             },
       u);
   return o;
 }
 
 Procedure::Procedure(FunctionResult &&fr, DummyArguments &&args, Attrs a)
-  : functionResult{std::move(fr)}, dummyArguments{std::move(args)}, attrs{a} {}
+    : functionResult{std::move(fr)}, dummyArguments{std::move(args)}, attrs{a} {
+}
 Procedure::Procedure(DummyArguments &&args, Attrs a)
-  : dummyArguments{std::move(args)}, attrs{a} {}
+    : dummyArguments{std::move(args)}, attrs{a} {}
 Procedure::~Procedure() {}
 
 bool Procedure::operator==(const Procedure &that) const {
@@ -573,7 +573,7 @@ std::optional<Procedure> Procedure::Characterize(
       });
   if (result.attrs.test(Attr::Elemental) &&
       !symbol.attrs().test(semantics::Attr::IMPURE)) {
-    result.attrs.set(Attr::Pure);  // explicitly flag pure procedures
+    result.attrs.set(Attr::Pure); // explicitly flag pure procedures
   }
   return std::visit(
       common::visitors{
@@ -686,7 +686,7 @@ std::optional<Procedure> Procedure::Characterize(
 
 bool Procedure::CanBeCalledViaImplicitInterface() const {
   if (attrs.test(Attr::Elemental) || attrs.test(Attr::BindC)) {
-    return false;  // 15.4.2.2(5,6)
+    return false; // 15.4.2.2(5,6)
   } else if (IsFunction() &&
       !functionResult->CanBeReturnedViaImplicitInterface()) {
     return false;
@@ -765,11 +765,11 @@ bool DistinguishUtils::DistinguishableOpOrAssign(
   auto &args1{proc1.dummyArguments};
   auto &args2{proc2.dummyArguments};
   if (args1.size() != args2.size()) {
-    return true;  // C1511: distinguishable based on number of arguments
+    return true; // C1511: distinguishable based on number of arguments
   }
   for (std::size_t i{0}; i < args1.size(); ++i) {
     if (Distinguishable(args1[i], args2[i])) {
-      return true;  // C1511, C1512: distinguishable based on this arg
+      return true; // C1511, C1512: distinguishable based on this arg
     }
   }
   return false;
@@ -782,23 +782,23 @@ bool DistinguishUtils::Distinguishable(
   auto count1{CountDummyProcedures(args1)};
   auto count2{CountDummyProcedures(args2)};
   if (count1.notOptional > count2.total || count2.notOptional > count1.total) {
-    return true;  // distinguishable based on C1514 rule 2
+    return true; // distinguishable based on C1514 rule 2
   }
   if (Rule3Distinguishable(proc1, proc2)) {
-    return true;  // distinguishable based on C1514 rule 3
+    return true; // distinguishable based on C1514 rule 3
   }
   if (Rule1DistinguishingArg(args1, args2)) {
-    return true;  // distinguishable based on C1514 rule 1
+    return true; // distinguishable based on C1514 rule 1
   }
   int pos1{FindFirstToDistinguishByPosition(args1, args2)};
   int name1{FindLastToDistinguishByName(args1, args2)};
   if (pos1 >= 0 && pos1 <= name1) {
-    return true;  // distinguishable based on C1514 rule 4
+    return true; // distinguishable based on C1514 rule 4
   }
   int pos2{FindFirstToDistinguishByPosition(args2, args1)};
   int name2{FindLastToDistinguishByName(args2, args1)};
   if (pos2 >= 0 && pos2 <= name2) {
-    return true;  // distinguishable based on C1514 rule 4
+    return true; // distinguishable based on C1514 rule 4
   }
   return false;
 }
@@ -843,7 +843,7 @@ const DummyArgument *DistinguishUtils::Rule1DistinguishingArg(
 // - the dummy argument at that position is distinguishable from it
 int DistinguishUtils::FindFirstToDistinguishByPosition(
     const DummyArguments &args1, const DummyArguments &args2) {
-  int effective{0};  // position of arg1 in list, ignoring passed arg
+  int effective{0}; // position of arg1 in list, ignoring passed arg
   for (std::size_t i{0}; i < args1.size(); ++i) {
     const DummyArgument &arg1{args1.at(i)};
     if (!arg1.pass && !arg1.IsOptional()) {
@@ -901,7 +901,7 @@ int DistinguishUtils::CountNotDistinguishableFrom(
 bool DistinguishUtils::Distinguishable(
     const DummyArgument &x, const DummyArgument &y) {
   if (x.u.index() != y.u.index()) {
-    return true;  // different kind: data/proc/alt-return
+    return true; // different kind: data/proc/alt-return
   }
   return std::visit(
       common::visitors{
@@ -949,7 +949,7 @@ bool DistinguishUtils::Distinguishable(
 bool DistinguishUtils::Distinguishable(
     const FunctionResult &x, const FunctionResult &y) {
   if (x.u.index() != y.u.index()) {
-    return true;  // one is data object, one is procedure
+    return true; // one is data object, one is procedure
   }
   return std::visit(
       common::visitors{
@@ -1020,7 +1020,7 @@ DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(DummyArgument)
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(DummyProcedure)
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(FunctionResult)
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(Procedure)
-}
+} // namespace Fortran::evaluate::characteristics
 
 template class Fortran::common::Indirection<
     Fortran::evaluate::characteristics::Procedure, true>;
diff --git a/lib/Evaluate/check-expression.cpp b/lib/Evaluate/check-expression.cpp
index 07b9065dcb29..4ac73131f54a 100644
--- a/lib/Evaluate/check-expression.cpp
+++ b/lib/Evaluate/check-expression.cpp
@@ -26,7 +26,7 @@ class IsConstantExprHelper : public AllTraverse<IsConstantExprHelper, true> {
   IsConstantExprHelper() : Base{*this} {}
   using Base::operator();
 
-  template<int KIND> bool operator()(const TypeParamInquiry<KIND> &inq) const {
+  template <int KIND> bool operator()(const TypeParamInquiry<KIND> &inq) const {
     return IsKindTypeParameter(inq.parameter());
   }
   bool operator()(const semantics::Symbol &symbol) const {
@@ -36,7 +36,7 @@ class IsConstantExprHelper : public AllTraverse<IsConstantExprHelper, true> {
   bool operator()(const semantics::ParamValue &param) const {
     return param.isExplicit() && (*this)(param.GetExplicit());
   }
-  template<typename T> bool operator()(const FunctionRef<T> &call) const {
+  template <typename T> bool operator()(const FunctionRef<T> &call) const {
     if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&call.proc().u)}) {
       return intrinsic->name == "kind";
       // TODO: other inquiry intrinsics
@@ -46,7 +46,7 @@ class IsConstantExprHelper : public AllTraverse<IsConstantExprHelper, true> {
   }
 
   // Forbid integer division by zero in constants.
-  template<int KIND>
+  template <int KIND>
   bool operator()(
       const Divide<Type<TypeCategory::Integer, KIND>> &division) const {
     using T = Type<TypeCategory::Integer, KIND>;
@@ -58,7 +58,7 @@ class IsConstantExprHelper : public AllTraverse<IsConstantExprHelper, true> {
   }
 };
 
-template<typename A> bool IsConstantExpr(const A &x) {
+template <typename A> bool IsConstantExpr(const A &x) {
   return IsConstantExprHelper{}(x);
 }
 template bool IsConstantExpr(const Expr<SomeType> &);
@@ -69,15 +69,15 @@ template bool IsConstantExpr(const Expr<SubscriptInteger> &);
 // This code determines whether an expression is allowable as the static
 // data address used to initialize a pointer with "=> x".  See C765.
 struct IsInitialDataTargetHelper
-  : public AllTraverse<IsInitialDataTargetHelper, true> {
+    : public AllTraverse<IsInitialDataTargetHelper, true> {
   using Base = AllTraverse<IsInitialDataTargetHelper, true>;
   using Base::operator();
   explicit IsInitialDataTargetHelper(parser::ContextualMessages &m)
-    : Base{*this}, messages_{m} {}
+      : Base{*this}, messages_{m} {}
 
   bool operator()(const BOZLiteralConstant &) const { return false; }
   bool operator()(const NullPointer &) const { return true; }
-  template<typename T> bool operator()(const Constant<T> &) const {
+  template <typename T> bool operator()(const Constant<T> &) const {
     return false;
   }
   bool operator()(const semantics::Symbol &symbol) const {
@@ -102,7 +102,7 @@ struct IsInitialDataTargetHelper
     return true;
   }
   bool operator()(const StaticDataObject &) const { return false; }
-  template<int KIND> bool operator()(const TypeParamInquiry<KIND> &) const {
+  template <int KIND> bool operator()(const TypeParamInquiry<KIND> &) const {
     return false;
   }
   bool operator()(const Triplet &x) const {
@@ -110,13 +110,13 @@ struct IsInitialDataTargetHelper
         IsConstantExpr(x.stride());
   }
   bool operator()(const Subscript &x) const {
-    return std::visit(
-        common::visitors{
-            [&](const Triplet &t) { return (*this)(t); },
-            [&](const auto &y) {
-              return y.value().Rank() == 0 && IsConstantExpr(y.value());
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const Triplet &t) { return (*this)(t); },
+                          [&](const auto &y) {
+                            return y.value().Rank() == 0 &&
+                                IsConstantExpr(y.value());
+                          },
+                      },
         x.u);
   }
   bool operator()(const CoarrayRef &) const { return false; }
@@ -125,16 +125,18 @@ struct IsInitialDataTargetHelper
         (*this)(x.parent());
   }
   bool operator()(const DescriptorInquiry &) const { return false; }
-  template<typename T> bool operator()(const ArrayConstructor<T> &) const {
+  template <typename T> bool operator()(const ArrayConstructor<T> &) const {
     return false;
   }
   bool operator()(const StructureConstructor &) const { return false; }
-  template<typename T> bool operator()(const FunctionRef<T> &) { return false; }
-  template<typename D, typename R, typename... O>
+  template <typename T> bool operator()(const FunctionRef<T> &) {
+    return false;
+  }
+  template <typename D, typename R, typename... O>
   bool operator()(const Operation<D, R, O...> &) const {
     return false;
   }
-  template<typename T> bool operator()(const Parentheses<T> &x) const {
+  template <typename T> bool operator()(const Parentheses<T> &x) const {
     return (*this)(x.left());
   }
   bool operator()(const Relational<SomeType> &) const { return false; }
@@ -150,13 +152,13 @@ bool IsInitialDataTarget(
 
 // Specification expression validation (10.1.11(2), C1010)
 class CheckSpecificationExprHelper
-  : public AnyTraverse<CheckSpecificationExprHelper,
-        std::optional<std::string>> {
+    : public AnyTraverse<CheckSpecificationExprHelper,
+          std::optional<std::string>> {
 public:
   using Result = std::optional<std::string>;
   using Base = AnyTraverse<CheckSpecificationExprHelper, Result>;
   explicit CheckSpecificationExprHelper(const semantics::Scope &s)
-    : Base{*this}, scope_{s} {}
+      : Base{*this}, scope_{s} {}
   using Base::operator();
 
   Result operator()(const ProcedureDesignator &) const {
@@ -211,7 +213,7 @@ class CheckSpecificationExprHelper
     return std::nullopt;
   }
 
-  template<typename T> Result operator()(const FunctionRef<T> &x) const {
+  template <typename T> Result operator()(const FunctionRef<T> &x) const {
     if (const auto *symbol{x.proc().GetSymbol()}) {
       if (!semantics::IsPureProcedure(*symbol)) {
         return "reference to impure function '"s + symbol->name().ToString() +
@@ -221,7 +223,7 @@ class CheckSpecificationExprHelper
     } else {
       const SpecificIntrinsic &intrin{DEREF(x.proc().GetSpecificIntrinsic())};
       if (intrin.name == "present") {
-        return std::nullopt;  // no need to check argument(s)
+        return std::nullopt; // no need to check argument(s)
       }
       if (IsConstantExpr(x)) {
         // inquiry functions may not need to check argument(s)
@@ -235,7 +237,7 @@ class CheckSpecificationExprHelper
   const semantics::Scope &scope_;
 };
 
-template<typename A>
+template <typename A>
 void CheckSpecificationExpr(const A &x, parser::ContextualMessages &messages,
     const semantics::Scope &scope) {
   if (auto why{CheckSpecificationExprHelper{scope}(x)}) {
@@ -259,12 +261,12 @@ template void CheckSpecificationExpr(
 
 // IsSimplyContiguous() -- 9.5.4
 class IsSimplyContiguousHelper
-  : public AnyTraverse<IsSimplyContiguousHelper, std::optional<bool>> {
+    : public AnyTraverse<IsSimplyContiguousHelper, std::optional<bool>> {
 public:
-  using Result = std::optional<bool>;  // tri-state
+  using Result = std::optional<bool>; // tri-state
   using Base = AnyTraverse<IsSimplyContiguousHelper, Result>;
   explicit IsSimplyContiguousHelper(const IntrinsicProcTable &t)
-    : Base{*this}, table_{t} {}
+      : Base{*this}, table_{t} {}
   using Base::operator();
 
   Result operator()(const semantics::Symbol &symbol) const {
@@ -303,7 +305,7 @@ class IsSimplyContiguousHelper
   Result operator()(const ComplexPart &) const { return false; }
   Result operator()(const Substring &) const { return false; }
 
-  template<typename T> Result operator()(const FunctionRef<T> &x) const {
+  template <typename T> Result operator()(const FunctionRef<T> &x) const {
     if (auto chars{
             characteristics::Procedure::Characterize(x.proc(), table_)}) {
       if (chars->functionResult) {
@@ -347,17 +349,17 @@ class IsSimplyContiguousHelper
   const IntrinsicProcTable &table_;
 };
 
-template<typename A>
+template <typename A>
 bool IsSimplyContiguous(const A &x, const IntrinsicProcTable &table) {
   if (IsVariable(x)) {
     auto known{IsSimplyContiguousHelper{table}(x)};
     return known && *known;
   } else {
-    return true;  // not a variable
+    return true; // not a variable
   }
 }
 
 template bool IsSimplyContiguous(
     const Expr<SomeType> &, const IntrinsicProcTable &);
 
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/common.cpp b/lib/Evaluate/common.cpp
index 92f7403918ee..cdfa9989ba76 100644
--- a/lib/Evaluate/common.cpp
+++ b/lib/Evaluate/common.cpp
@@ -51,4 +51,4 @@ void FoldingContext::EndImpliedDo(parser::CharBlock name) {
     impliedDos_.erase(iter);
   }
 }
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/complex.cpp b/lib/Evaluate/complex.cpp
index 298c14a07540..73ed5b3ca950 100644
--- a/lib/Evaluate/complex.cpp
+++ b/lib/Evaluate/complex.cpp
@@ -11,7 +11,7 @@
 
 namespace Fortran::evaluate::value {
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Add(
     const Complex &that, Rounding rounding) const {
   RealFlags flags;
@@ -20,7 +20,7 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Add(
   return {Complex{reSum, imSum}, flags};
 }
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Subtract(
     const Complex &that, Rounding rounding) const {
   RealFlags flags;
@@ -29,7 +29,7 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Subtract(
   return {Complex{reDiff, imDiff}, flags};
 }
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Multiply(
     const Complex &that, Rounding rounding) const {
   // (a + ib)*(c + id) -> ac - bd + i(ad + bc)
@@ -43,14 +43,14 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Multiply(
   return {Complex{acbd, adbc}, flags};
 }
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Divide(
     const Complex &that, Rounding rounding) const {
   // (a + ib)/(c + id) -> [(a+ib)*(c-id)] / [(c+id)*(c-id)]
   //   -> [ac+bd+i(bc-ad)] / (cc+dd)
   //   -> ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
   // but to avoid overflows, scale by d/c if c>=d, else c/d
-  Part scale;  // <= 1.0
+  Part scale; // <= 1.0
   RealFlags flags;
   bool cGEd{that.re_.ABS().Compare(that.im_.ABS()) != Relation::Less};
   if (cGEd) {
@@ -81,7 +81,7 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Divide(
   return {Complex{re, im}, flags};
 }
 
-template<typename R> std::string Complex<R>::DumpHexadecimal() const {
+template <typename R> std::string Complex<R>::DumpHexadecimal() const {
   std::string result{'('};
   result += re_.DumpHexadecimal();
   result += ',';
@@ -90,7 +90,7 @@ template<typename R> std::string Complex<R>::DumpHexadecimal() const {
   return result;
 }
 
-template<typename R>
+template <typename R>
 llvm::raw_ostream &Complex<R>::AsFortran(llvm::raw_ostream &o, int kind) const {
   re_.AsFortran(o << '(', kind);
   im_.AsFortran(o << ',', kind);
@@ -103,4 +103,4 @@ template class Complex<Real<Integer<32>, 24>>;
 template class Complex<Real<Integer<64>, 53>>;
 template class Complex<Real<Integer<80>, 64>>;
 template class Complex<Real<Integer<128>, 113>>;
-}
+} // namespace Fortran::evaluate::value
diff --git a/lib/Evaluate/constant.cpp b/lib/Evaluate/constant.cpp
index 0d6a780b9879..ecdcc0ab8e3e 100644
--- a/lib/Evaluate/constant.cpp
+++ b/lib/Evaluate/constant.cpp
@@ -24,10 +24,10 @@ std::size_t TotalElementCount(const ConstantSubscripts &shape) {
 }
 
 ConstantBounds::ConstantBounds(const ConstantSubscripts &shape)
-  : shape_(shape), lbounds_(shape_.size(), 1) {}
+    : shape_(shape), lbounds_(shape_.size(), 1) {}
 
 ConstantBounds::ConstantBounds(ConstantSubscripts &&shape)
-  : shape_(std::move(shape)), lbounds_(shape_.size(), 1) {}
+    : shape_(std::move(shape)), lbounds_(shape_.size(), 1) {}
 
 ConstantBounds::~ConstantBounds() = default;
 
@@ -71,7 +71,7 @@ bool ConstantBounds::IncrementSubscripts(
       indices[k] = lb;
     }
   }
-  return false;  // all done
+  return false; // all done
 }
 
 std::optional<std::vector<int>> ValidateDimensionOrder(
@@ -102,22 +102,22 @@ bool IsValidShape(const ConstantSubscripts &shape) {
   return shape.size() <= common::maxRank;
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 ConstantBase<RESULT, ELEMENT>::ConstantBase(
     std::vector<Element> &&x, ConstantSubscripts &&sh, Result res)
-  : ConstantBounds(std::move(sh)), result_{res}, values_(std::move(x)) {
+    : ConstantBounds(std::move(sh)), result_{res}, values_(std::move(x)) {
   CHECK(size() == TotalElementCount(shape()));
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 ConstantBase<RESULT, ELEMENT>::~ConstantBase() {}
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 bool ConstantBase<RESULT, ELEMENT>::operator==(const ConstantBase &that) const {
   return shape() == that.shape() && values_ == that.values_;
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 auto ConstantBase<RESULT, ELEMENT>::Reshape(
     const ConstantSubscripts &dims) const -> std::vector<Element> {
   std::size_t n{TotalElementCount(dims)};
@@ -133,7 +133,7 @@ auto ConstantBase<RESULT, ELEMENT>::Reshape(
   return elements;
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 std::size_t ConstantBase<RESULT, ELEMENT>::CopyFrom(
     const ConstantBase<RESULT, ELEMENT> &source, std::size_t count,
     ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder) {
@@ -149,37 +149,37 @@ std::size_t ConstantBase<RESULT, ELEMENT>::CopyFrom(
   return copied;
 }
 
-template<typename T>
+template <typename T>
 auto Constant<T>::At(const ConstantSubscripts &index) const -> Element {
   return Base::values_.at(Base::SubscriptsToOffset(index));
 }
 
-template<typename T>
+template <typename T>
 auto Constant<T>::Reshape(ConstantSubscripts &&dims) const -> Constant {
   return {Base::Reshape(dims), std::move(dims)};
 }
 
-template<typename T>
+template <typename T>
 std::size_t Constant<T>::CopyFrom(const Constant<T> &source, std::size_t count,
     ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder) {
   return Base::CopyFrom(source, count, resultSubscripts, dimOrder);
 }
 
 // Constant<Type<TypeCategory::Character, KIND> specializations
-template<int KIND>
+template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(
     const Scalar<Result> &str)
-  : values_{str}, length_{static_cast<ConstantSubscript>(values_.size())} {}
+    : values_{str}, length_{static_cast<ConstantSubscript>(values_.size())} {}
 
-template<int KIND>
+template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(Scalar<Result> &&str)
-  : values_{std::move(str)}, length_{static_cast<ConstantSubscript>(
-                                 values_.size())} {}
+    : values_{std::move(str)}, length_{static_cast<ConstantSubscript>(
+                                   values_.size())} {}
 
-template<int KIND>
+template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(ConstantSubscript len,
     std::vector<Scalar<Result>> &&strings, ConstantSubscripts &&sh)
-  : ConstantBounds(std::move(sh)), length_{len} {
+    : ConstantBounds(std::move(sh)), length_{len} {
   CHECK(strings.size() == TotalElementCount(shape()));
   values_.assign(strings.size() * length_,
       static_cast<typename Scalar<Result>::value_type>(' '));
@@ -196,14 +196,15 @@ Constant<Type<TypeCategory::Character, KIND>>::Constant(ConstantSubscript len,
   CHECK(at == static_cast<ConstantSubscript>(values_.size()));
 }
 
-template<int KIND> Constant<Type<TypeCategory::Character, KIND>>::~Constant() {}
+template <int KIND>
+Constant<Type<TypeCategory::Character, KIND>>::~Constant() {}
 
-template<int KIND>
+template <int KIND>
 bool Constant<Type<TypeCategory::Character, KIND>>::empty() const {
   return size() == 0;
 }
 
-template<int KIND>
+template <int KIND>
 std::size_t Constant<Type<TypeCategory::Character, KIND>>::size() const {
   if (length_ == 0) {
     return TotalElementCount(shape());
@@ -212,14 +213,14 @@ std::size_t Constant<Type<TypeCategory::Character, KIND>>::size() const {
   }
 }
 
-template<int KIND>
+template <int KIND>
 auto Constant<Type<TypeCategory::Character, KIND>>::At(
     const ConstantSubscripts &index) const -> Scalar<Result> {
   auto offset{SubscriptsToOffset(index)};
   return values_.substr(offset * length_, length_);
 }
 
-template<int KIND>
+template <int KIND>
 auto Constant<Type<TypeCategory::Character, KIND>>::Reshape(
     ConstantSubscripts &&dims) const -> Constant<Result> {
   std::size_t n{TotalElementCount(dims)};
@@ -230,14 +231,14 @@ auto Constant<Type<TypeCategory::Character, KIND>>::Reshape(
   while (n-- > 0) {
     elements.push_back(values_.substr(at, length_));
     at += length_;
-    if (at == limit) {  // subtle: at > limit somehow? substr() will catch it
+    if (at == limit) { // subtle: at > limit somehow? substr() will catch it
       at = 0;
     }
   }
   return {length_, std::move(elements), std::move(dims)};
 }
 
-template<int KIND>
+template <int KIND>
 std::size_t Constant<Type<TypeCategory::Character, KIND>>::CopyFrom(
     const Constant<Type<TypeCategory::Character, KIND>> &source,
     std::size_t count, ConstantSubscripts &resultSubscripts,
@@ -260,14 +261,14 @@ std::size_t Constant<Type<TypeCategory::Character, KIND>>::CopyFrom(
 
 // Constant<SomeDerived> specialization
 Constant<SomeDerived>::Constant(const StructureConstructor &x)
-  : Base{x.values(), Result{x.derivedTypeSpec()}} {}
+    : Base{x.values(), Result{x.derivedTypeSpec()}} {}
 
 Constant<SomeDerived>::Constant(StructureConstructor &&x)
-  : Base{std::move(x.values()), Result{x.derivedTypeSpec()}} {}
+    : Base{std::move(x.values()), Result{x.derivedTypeSpec()}} {}
 
 Constant<SomeDerived>::Constant(const semantics::DerivedTypeSpec &spec,
     std::vector<StructureConstructorValues> &&x, ConstantSubscripts &&s)
-  : Base{std::move(x), std::move(s), Result{spec}} {}
+    : Base{std::move(x), std::move(s), Result{spec}} {}
 
 static std::vector<StructureConstructorValues> AcquireValues(
     std::vector<StructureConstructor> &&x) {
@@ -280,7 +281,7 @@ static std::vector<StructureConstructorValues> AcquireValues(
 
 Constant<SomeDerived>::Constant(const semantics::DerivedTypeSpec &spec,
     std::vector<StructureConstructor> &&x, ConstantSubscripts &&shape)
-  : Base{AcquireValues(std::move(x)), std::move(shape), Result{spec}} {}
+    : Base{AcquireValues(std::move(x)), std::move(shape), Result{spec}} {}
 
 std::optional<StructureConstructor>
 Constant<SomeDerived>::GetScalarValue() const {
@@ -308,4 +309,4 @@ std::size_t Constant<SomeDerived>::CopyFrom(const Constant<SomeDerived> &source,
 }
 
 INSTANTIATE_CONSTANT_TEMPLATES
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/expression.cpp b/lib/Evaluate/expression.cpp
index a3bb9280648f..604e4ff41ce2 100644
--- a/lib/Evaluate/expression.cpp
+++ b/lib/Evaluate/expression.cpp
@@ -21,7 +21,7 @@ using namespace Fortran::parser::literals;
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 std::optional<Expr<SubscriptInteger>>
 Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
   using T = std::optional<Expr<SubscriptInteger>>;
@@ -63,18 +63,18 @@ Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
 Expr<SomeType>::~Expr() = default;
 
 #if defined(__APPLE__) && defined(__GNUC__)
-template<typename A>
+template <typename A>
 typename ExpressionBase<A>::Derived &ExpressionBase<A>::derived() {
   return *static_cast<Derived *>(this);
 }
 
-template<typename A>
+template <typename A>
 const typename ExpressionBase<A>::Derived &ExpressionBase<A>::derived() const {
   return *static_cast<const Derived *>(this);
 }
 #endif
 
-template<typename A>
+template <typename A>
 std::optional<DynamicType> ExpressionBase<A>::GetType() const {
   if constexpr (IsLengthlessIntrinsicType<Result>) {
     return Result::GetType();
@@ -84,13 +84,13 @@ std::optional<DynamicType> ExpressionBase<A>::GetType() const {
           if constexpr (!common::HasMember<decltype(x), TypelessExpression>) {
             return x.GetType();
           }
-          return std::nullopt;  // w/o "else" to dodge bogus g++ 8.1 warning
+          return std::nullopt; // w/o "else" to dodge bogus g++ 8.1 warning
         },
         derived().u);
   }
 }
 
-template<typename A> int ExpressionBase<A>::Rank() const {
+template <typename A> int ExpressionBase<A>::Rank() const {
   return std::visit(
       [](const auto &x) {
         if constexpr (common::HasMember<decltype(x), TypelessExpression>) {
@@ -108,26 +108,26 @@ bool ImpliedDoIndex::operator==(const ImpliedDoIndex &that) const {
   return name == that.name;
 }
 
-template<typename T>
+template <typename T>
 bool ImpliedDo<T>::operator==(const ImpliedDo<T> &that) const {
   return name_ == that.name_ && lower_ == that.lower_ &&
       upper_ == that.upper_ && stride_ == that.stride_ &&
       values_ == that.values_;
 }
 
-template<typename T>
+template <typename T>
 bool ArrayConstructorValue<T>::operator==(
     const ArrayConstructorValue<T> &that) const {
   return u == that.u;
 }
 
-template<typename R>
+template <typename R>
 bool ArrayConstructorValues<R>::operator==(
     const ArrayConstructorValues<R> &that) const {
   return values_ == that.values_;
 }
 
-template<int KIND>
+template <int KIND>
 bool ArrayConstructor<Type<TypeCategory::Character, KIND>>::operator==(
     const ArrayConstructor &that) const {
   return length_ == that.length_ &&
@@ -144,10 +144,10 @@ bool ArrayConstructor<SomeDerived>::operator==(
 StructureConstructor::StructureConstructor(
     const semantics::DerivedTypeSpec &spec,
     const StructureConstructorValues &values)
-  : result_{spec}, values_{values} {}
+    : result_{spec}, values_{values} {}
 StructureConstructor::StructureConstructor(
     const semantics::DerivedTypeSpec &spec, StructureConstructorValues &&values)
-  : result_{spec}, values_{std::move(values)} {}
+    : result_{spec}, values_{std::move(values)} {}
 
 bool StructureConstructor::operator==(const StructureConstructor &that) const {
   return result_ == that.result_ && values_ == that.values_;
@@ -157,37 +157,37 @@ bool Relational<SomeType>::operator==(const Relational<SomeType> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Integer, KIND>>::operator==(
     const Expr<Type<TypeCategory::Integer, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Real, KIND>>::operator==(
     const Expr<Type<TypeCategory::Real, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Complex, KIND>>::operator==(
     const Expr<Type<TypeCategory::Complex, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Logical, KIND>>::operator==(
     const Expr<Type<TypeCategory::Logical, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Character, KIND>>::operator==(
     const Expr<Type<TypeCategory::Character, KIND>> &that) const {
   return u == that.u;
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 bool Expr<SomeKind<CAT>>::operator==(const Expr<SomeKind<CAT>> &that) const {
   return u == that.u;
 }
@@ -225,7 +225,7 @@ GenericExprWrapper::~GenericExprWrapper() {}
 
 GenericAssignmentWrapper::~GenericAssignmentWrapper() {}
 
-template<TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
+template <TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
   return std::visit(
       [](const auto &kx) { return std::decay_t<decltype(kx)>::Result::kind; },
       u);
@@ -242,6 +242,6 @@ std::optional<Expr<SubscriptInteger>> Expr<SomeCharacter>::LEN() const {
 }
 
 INSTANTIATE_EXPRESSION_TEMPLATES
-}
+} // namespace Fortran::evaluate
 DEFINE_DELETER(Fortran::evaluate::GenericExprWrapper)
 DEFINE_DELETER(Fortran::evaluate::GenericAssignmentWrapper)
diff --git a/lib/Evaluate/fold-character.cpp b/lib/Evaluate/fold-character.cpp
index 7398a1b56d0f..1eac58213f20 100644
--- a/lib/Evaluate/fold-character.cpp
+++ b/lib/Evaluate/fold-character.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Character, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Character, KIND>> &&funcRef) {
@@ -38,14 +38,14 @@ Expr<Type<TypeCategory::Character, KIND>> FoldIntrinsicFunction(
     return FoldMINorMAX(context, std::move(funcRef), Ordering::Less);
   } else if (name == "new_line") {
     return Expr<T>{Constant<T>{CharacterUtils<KIND>::NEW_LINE()}};
-  } else if (name == "repeat") {  // not elemental
+  } else if (name == "repeat") { // not elemental
     if (auto scalars{GetScalarConstantArguments<T, SubscriptInteger>(
             context, funcRef.arguments())}) {
       return Expr<T>{Constant<T>{
           CharacterUtils<KIND>::REPEAT(std::get<Scalar<T>>(*scalars),
               std::get<Scalar<SubscriptInteger>>(*scalars).ToInt64())}};
     }
-  } else if (name == "trim") {  // not elemental
+  } else if (name == "trim") { // not elemental
     if (auto scalar{
             GetScalarConstantArguments<T>(context, funcRef.arguments())}) {
       return Expr<T>{Constant<T>{
@@ -57,7 +57,7 @@ Expr<Type<TypeCategory::Character, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
     FoldingContext &context, Concat<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -70,7 +70,7 @@ Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
   return Expr<Result>{std::move(x)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
     FoldingContext &context, SetLength<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -93,4 +93,4 @@ Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
 
 FOR_EACH_CHARACTER_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeCharacter>;
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/fold-complex.cpp b/lib/Evaluate/fold-complex.cpp
index f2006daf3b56..ea96f045aa3e 100644
--- a/lib/Evaluate/fold-complex.cpp
+++ b/lib/Evaluate/fold-complex.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Complex, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Complex, KIND>> &&funcRef) {
@@ -61,7 +61,7 @@ Expr<Type<TypeCategory::Complex, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Complex, KIND>> FoldOperation(
     FoldingContext &context, ComplexConstructor<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -77,4 +77,4 @@ Expr<Type<TypeCategory::Complex, KIND>> FoldOperation(
 
 FOR_EACH_COMPLEX_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeComplex>;
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/fold-implementation.h b/lib/Evaluate/fold-implementation.h
index 67e541e1204a..44f0093a3bdb 100644
--- a/lib/Evaluate/fold-implementation.h
+++ b/lib/Evaluate/fold-implementation.h
@@ -45,7 +45,7 @@
 namespace Fortran::evaluate {
 
 // Utilities
-template<typename T> class Folder {
+template <typename T> class Folder {
 public:
   explicit Folder(FoldingContext &c) : context_{c} {}
   std::optional<Expr<T>> GetNamedConstantValue(const Symbol &);
@@ -76,7 +76,7 @@ std::optional<Constant<SubscriptInteger>> GetConstantSubscript(
 // specific type.
 
 // no-op base case
-template<typename A>
+template <typename A>
 common::IfNoLvalue<Expr<ResultType<A>>, A> FoldOperation(
     FoldingContext &, A &&x) {
   static_assert(!std::is_same_v<A, Expr<ResultType<A>>>,
@@ -94,36 +94,36 @@ DataRef FoldOperation(FoldingContext &, DataRef &&);
 Substring FoldOperation(FoldingContext &, Substring &&);
 ComplexPart FoldOperation(FoldingContext &, ComplexPart &&);
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, FunctionRef<T> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Integer, KIND>> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Real, KIND>> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Complex, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Complex, KIND>> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Logical, KIND>> &&);
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Designator<T> &&designator) {
   return Folder<T>{context}.Folding(std::move(designator));
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldOperation(
     FoldingContext &, TypeParamInquiry<KIND> &&);
 Expr<ImpliedDoIndex::Result> FoldOperation(
     FoldingContext &context, ImpliedDoIndex &&);
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &, ArrayConstructor<T> &&);
 Expr<SomeDerived> FoldOperation(FoldingContext &, StructureConstructor &&);
 
-template<typename T>
+template <typename T>
 std::optional<Expr<T>> Folder<T>::GetNamedConstantValue(const Symbol &symbol0) {
   const Symbol &symbol{ResolveAssociations(symbol0)};
   if (IsNamedConstant(symbol)) {
@@ -200,7 +200,7 @@ std::optional<Expr<T>> Folder<T>::GetNamedConstantValue(const Symbol &symbol0) {
   return std::nullopt;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::GetFoldedNamedConstantValue(
     const Symbol &symbol) {
   if (auto value{GetNamedConstantValue(symbol)}) {
@@ -212,7 +212,7 @@ std::optional<Constant<T>> Folder<T>::GetFoldedNamedConstantValue(
   return std::nullopt;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::Folding(ArrayRef &aRef) {
   std::vector<Constant<SubscriptInteger>> subscripts;
   int dim{0};
@@ -233,7 +233,7 @@ std::optional<Constant<T>> Folder<T>::Folding(ArrayRef &aRef) {
   }
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::ApplySubscripts(const Constant<T> &array,
     const std::vector<Constant<SubscriptInteger>> &subscripts) {
   const auto &shape{array.shape()};
@@ -293,7 +293,7 @@ std::optional<Constant<T>> Folder<T>::ApplySubscripts(const Constant<T> &array,
   }
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::ApplyComponent(
     Constant<SomeDerived> &&structures, const Symbol &component,
     const std::vector<Constant<SubscriptInteger>> *subscripts) {
@@ -351,7 +351,7 @@ std::optional<Constant<T>> Folder<T>::ApplyComponent(
   return std::nullopt;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::GetConstantComponent(Component &component,
     const std::vector<Constant<SubscriptInteger>> *subscripts) {
   if (std::optional<Constant<SomeDerived>> structures{std::visit(
@@ -378,7 +378,7 @@ std::optional<Constant<T>> Folder<T>::GetConstantComponent(Component &component,
   }
 }
 
-template<typename T> Expr<T> Folder<T>::Folding(Designator<T> &&designator) {
+template <typename T> Expr<T> Folder<T>::Folding(Designator<T> &&designator) {
   if constexpr (T::category == TypeCategory::Character) {
     if (auto *substring{common::Unwrap<Substring>(designator.u)}) {
       if (std::optional<Expr<SomeCharacter>> folded{
@@ -428,7 +428,7 @@ template<typename T> Expr<T> Folder<T>::Folding(Designator<T> &&designator) {
 
 // Apply type conversion and re-folding if necessary.
 // This is where BOZ arguments are converted.
-template<typename T>
+template <typename T>
 Constant<T> *Folder<T>::Folding(std::optional<ActualArgument> &arg) {
   if (auto *expr{UnwrapExpr<Expr<SomeType>>(arg)}) {
     if (!UnwrapExpr<Expr<T>>(*expr)) {
@@ -441,12 +441,12 @@ Constant<T> *Folder<T>::Folding(std::optional<ActualArgument> &arg) {
   return nullptr;
 }
 
-template<typename... A, std::size_t... I>
+template <typename... A, std::size_t... I>
 std::optional<std::tuple<const Constant<A> *...>> GetConstantArgumentsHelper(
     FoldingContext &context, ActualArguments &arguments,
     std::index_sequence<I...>) {
   static_assert(
-      (... && IsSpecificIntrinsicType<A>));  // TODO derived types for MERGE?
+      (... && IsSpecificIntrinsicType<A>)); // TODO derived types for MERGE?
   static_assert(sizeof...(A) > 0);
   std::tuple<const Constant<A> *...> args{
       Folder<A>{context}.Folding(arguments.at(I))...};
@@ -457,14 +457,14 @@ std::optional<std::tuple<const Constant<A> *...>> GetConstantArgumentsHelper(
   }
 }
 
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<const Constant<A> *...>> GetConstantArguments(
     FoldingContext &context, ActualArguments &args) {
   return GetConstantArgumentsHelper<A...>(
       context, args, std::index_sequence_for<A...>{});
 }
 
-template<typename... A, std::size_t... I>
+template <typename... A, std::size_t... I>
 std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArgumentsHelper(
     FoldingContext &context, ActualArguments &args, std::index_sequence<I...>) {
   if (auto constArgs{GetConstantArguments<A...>(context, args)}) {
@@ -475,7 +475,7 @@ std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArgumentsHelper(
   }
 }
 
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArguments(
     FoldingContext &context, ActualArguments &args) {
   return GetScalarConstantArgumentsHelper<A...>(
@@ -486,13 +486,13 @@ std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArguments(
 // Define callable types used in a common utility that
 // takes care of array and cast/conversion aspects for elemental intrinsics
 
-template<typename TR, typename... TArgs>
+template <typename TR, typename... TArgs>
 using ScalarFunc = std::function<Scalar<TR>(const Scalar<TArgs> &...)>;
-template<typename TR, typename... TArgs>
+template <typename TR, typename... TArgs>
 using ScalarFuncWithContext =
     std::function<Scalar<TR>(FoldingContext &, const Scalar<TArgs> &...)>;
 
-template<template<typename, typename...> typename WrapperType, typename TR,
+template <template <typename, typename...> typename WrapperType, typename TR,
     typename... TA, std::size_t... I>
 Expr<TR> FoldElementalIntrinsicHelper(FoldingContext &context,
     FunctionRef<TR> &&funcRef, WrapperType<TR, TA...> func,
@@ -556,13 +556,13 @@ Expr<TR> FoldElementalIntrinsicHelper(FoldingContext &context,
   return Expr<TR>{std::move(funcRef)};
 }
 
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 Expr<TR> FoldElementalIntrinsic(FoldingContext &context,
     FunctionRef<TR> &&funcRef, ScalarFunc<TR, TA...> func) {
   return FoldElementalIntrinsicHelper<ScalarFunc, TR, TA...>(
       context, std::move(funcRef), func, std::index_sequence_for<TA...>{});
 }
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 Expr<TR> FoldElementalIntrinsic(FoldingContext &context,
     FunctionRef<TR> &&funcRef, ScalarFuncWithContext<TR, TA...> func) {
   return FoldElementalIntrinsicHelper<ScalarFuncWithContext, TR, TA...>(
@@ -573,7 +573,7 @@ std::optional<std::int64_t> GetInt64Arg(const std::optional<ActualArgument> &);
 std::optional<std::int64_t> GetInt64ArgOr(
     const std::optional<ActualArgument> &, std::int64_t defaultValue);
 
-template<typename A, typename B>
+template <typename A, typename B>
 std::optional<std::vector<A>> GetIntegerVector(const B &x) {
   static_assert(std::is_integral_v<A>);
   if (const auto *someInteger{UnwrapExpr<Expr<SomeInteger>>(x)}) {
@@ -600,14 +600,14 @@ std::optional<std::vector<A>> GetIntegerVector(const B &x) {
 // into an intrinsic with the same characteristic but the "invalid" name.
 // This to prevent generating warnings over and over if the expression
 // gets re-folded.
-template<typename T> Expr<T> MakeInvalidIntrinsic(FunctionRef<T> &&funcRef) {
+template <typename T> Expr<T> MakeInvalidIntrinsic(FunctionRef<T> &&funcRef) {
   SpecificIntrinsic invalid{std::get<SpecificIntrinsic>(funcRef.proc().u)};
   invalid.name = "(invalid intrinsic function call)";
   return Expr<T>{FunctionRef<T>{ProcedureDesignator{std::move(invalid)},
       ActualArguments{ActualArgument{AsGenericExpr(std::move(funcRef))}}}};
 }
 
-template<typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
+template <typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
   auto args{funcRef.arguments()};
   CHECK(args.size() == 4);
   const auto *source{UnwrapConstantValue<T>(args[0])};
@@ -616,7 +616,7 @@ template<typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
       GetIntegerVector<ConstantSubscript>(args[1])};
   std::optional<std::vector<int>> order{GetIntegerVector<int>(args[3])};
   if (!source || !shape || (args[2] && !pad) || (args[3] && !order)) {
-    return Expr<T>{std::move(funcRef)};  // Non-constant arguments
+    return Expr<T>{std::move(funcRef)}; // Non-constant arguments
   } else if (!IsValidShape(shape.value())) {
     context_.messages().Say("Invalid SHAPE in RESHAPE"_en_US);
   } else {
@@ -652,7 +652,7 @@ template<typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
   return MakeInvalidIntrinsic(std::move(funcRef));
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldMINorMAX(
     FoldingContext &context, FunctionRef<T> &&funcRef, Ordering order) {
   std::vector<Constant<T> *> constantArgs;
@@ -672,7 +672,7 @@ Expr<T> FoldMINorMAX(
   return result;
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, FunctionRef<T> &&funcRef) {
   ActualArguments &args{funcRef.arguments()};
   for (std::optional<ActualArgument> &arg : args) {
@@ -693,7 +693,7 @@ Expr<T> FoldOperation(FoldingContext &context, FunctionRef<T> &&funcRef) {
   return Expr<T>{std::move(funcRef)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldMerge(FoldingContext &context, FunctionRef<T> &&funcRef) {
   return FoldElementalIntrinsic<T, T, T, LogicalResult>(context,
       std::move(funcRef),
@@ -707,7 +707,7 @@ Expr<T> FoldMerge(FoldingContext &context, FunctionRef<T> &&funcRef) {
 Expr<ImpliedDoIndex::Result> FoldOperation(FoldingContext &, ImpliedDoIndex &&);
 
 // Array constructor folding
-template<typename T> class ArrayConstructorFolder {
+template <typename T> class ArrayConstructorFolder {
 public:
   explicit ArrayConstructorFolder(const FoldingContext &c) : context_{c} {}
 
@@ -797,7 +797,7 @@ template<typename T> class ArrayConstructorFolder {
   std::vector<Scalar<T>> elements_;
 };
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, ArrayConstructor<T> &&array) {
   return ArrayConstructorFolder<T>{context}.FoldArray(std::move(array));
 }
@@ -810,7 +810,7 @@ Expr<T> FoldOperation(FoldingContext &context, ArrayConstructor<T> &&array) {
 
 // If possible, restructures an array expression into an array constructor
 // that comprises a "flat" ArrayConstructorValues with no implied DO loops.
-template<typename T>
+template <typename T>
 bool ArrayConstructorIsFlat(const ArrayConstructorValues<T> &values) {
   for (const ArrayConstructorValue<T> &x : values) {
     if (!std::holds_alternative<Expr<T>>(x.u)) {
@@ -820,7 +820,7 @@ bool ArrayConstructorIsFlat(const ArrayConstructorValues<T> &values) {
   return true;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Expr<T>> AsFlatArrayConstructor(const Expr<T> &expr) {
   if (const auto *c{UnwrapConstantValue<T>(expr)}) {
     ArrayConstructor<T> result{expr};
@@ -841,7 +841,7 @@ std::optional<Expr<T>> AsFlatArrayConstructor(const Expr<T> &expr) {
   return std::nullopt;
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 std::enable_if_t<CAT != TypeCategory::Derived,
     std::optional<Expr<SomeKind<CAT>>>>
 AsFlatArrayConstructor(const Expr<SomeKind<CAT>> &expr) {
@@ -860,7 +860,7 @@ AsFlatArrayConstructor(const Expr<SomeKind<CAT>> &expr) {
 // Given a flat ArrayConstructor<T> and a shape, it wraps the array
 // into an Expr<T>, folds it, and returns the resulting wrapped
 // array constructor or constant array value.
-template<typename T>
+template <typename T>
 Expr<T> FromArrayConstructor(FoldingContext &context,
     ArrayConstructor<T> &&values, std::optional<ConstantSubscripts> &&shape) {
   Expr<T> result{Fold(context, Expr<T>{std::move(values)})};
@@ -880,7 +880,7 @@ Expr<T> FromArrayConstructor(FoldingContext &context,
 // Preserves shape.
 
 // Unary case
-template<typename RESULT, typename OPERAND>
+template <typename RESULT, typename OPERAND>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<OPERAND> &&)> &&f, const Shape &shape,
     Expr<OPERAND> &&values) {
@@ -908,7 +908,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 }
 
 // array * array case
-template<typename RESULT, typename LEFT, typename RIGHT>
+template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, Expr<LEFT> &&leftValues, Expr<RIGHT> &&rightValues) {
@@ -948,7 +948,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 }
 
 // array * scalar case
-template<typename RESULT, typename LEFT, typename RIGHT>
+template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, Expr<LEFT> &&leftValues,
@@ -965,7 +965,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 }
 
 // scalar * array case
-template<typename RESULT, typename LEFT, typename RIGHT>
+template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, const Expr<LEFT> &leftScalar,
@@ -1000,7 +1000,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 // operation, then attempts to apply the operation to the (corresponding)
 // scalar element(s) of those operands.  Returns std::nullopt for scalars
 // or unlinearizable operands.
-template<typename DERIVED, typename RESULT, typename OPERAND>
+template <typename DERIVED, typename RESULT, typename OPERAND>
 auto ApplyElementwise(FoldingContext &context,
     Operation<DERIVED, RESULT, OPERAND> &operation,
     std::function<Expr<RESULT>(Expr<OPERAND> &&)> &&f)
@@ -1017,7 +1017,7 @@ auto ApplyElementwise(FoldingContext &context,
   return std::nullopt;
 }
 
-template<typename DERIVED, typename RESULT, typename OPERAND>
+template <typename DERIVED, typename RESULT, typename OPERAND>
 auto ApplyElementwise(
     FoldingContext &context, Operation<DERIVED, RESULT, OPERAND> &operation)
     -> std::optional<Expr<RESULT>> {
@@ -1032,19 +1032,19 @@ auto ApplyElementwise(
 // in the flattening of an array expression?
 // TODO: capture such scalar expansions in temporaries, flatten everything
 struct UnexpandabilityFindingVisitor
-  : public AnyTraverse<UnexpandabilityFindingVisitor> {
+    : public AnyTraverse<UnexpandabilityFindingVisitor> {
   using Base = AnyTraverse<UnexpandabilityFindingVisitor>;
   using Base::operator();
   UnexpandabilityFindingVisitor() : Base{*this} {}
-  template<typename T> bool operator()(const FunctionRef<T> &) { return true; }
+  template <typename T> bool operator()(const FunctionRef<T> &) { return true; }
   bool operator()(const CoarrayRef &) { return true; }
 };
 
-template<typename T> bool IsExpandableScalar(const Expr<T> &expr) {
+template <typename T> bool IsExpandableScalar(const Expr<T> &expr) {
   return !UnexpandabilityFindingVisitor{}(expr);
 }
 
-template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
+template <typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
 auto ApplyElementwise(FoldingContext &context,
     Operation<DERIVED, RESULT, LEFT, RIGHT> &operation,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f)
@@ -1081,7 +1081,7 @@ auto ApplyElementwise(FoldingContext &context,
   return std::nullopt;
 }
 
-template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
+template <typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
 auto ApplyElementwise(
     FoldingContext &context, Operation<DERIVED, RESULT, LEFT, RIGHT> &operation)
     -> std::optional<Expr<RESULT>> {
@@ -1094,7 +1094,7 @@ auto ApplyElementwise(
 
 // Unary operations
 
-template<typename TO, typename FROM>
+template <typename TO, typename FROM>
 common::IfNoLvalue<std::optional<TO>, FROM> ConvertString(FROM &&s) {
   if constexpr (std::is_same_v<TO, FROM>) {
     return std::make_optional<TO>(std::move(s));
@@ -1112,7 +1112,7 @@ common::IfNoLvalue<std::optional<TO>, FROM> ConvertString(FROM &&s) {
   }
 }
 
-template<typename TO, TypeCategory FROMCAT>
+template <typename TO, TypeCategory FROMCAT>
 Expr<TO> FoldOperation(
     FoldingContext &context, Convert<TO, FROMCAT> &&convert) {
   if (auto array{ApplyElementwise(context, convert)}) {
@@ -1178,14 +1178,14 @@ Expr<TO> FoldOperation(
           }
         } else if constexpr (std::is_same_v<Operand, TO> &&
             FROMCAT != TypeCategory::Character) {
-          return std::move(kindExpr);  // remove needless conversion
+          return std::move(kindExpr); // remove needless conversion
         }
         return Expr<TO>{std::move(convert)};
       },
       convert.left().u);
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Parentheses<T> &&x) {
   auto &operand{x.left()};
   operand = Fold(context, std::move(operand));
@@ -1200,7 +1200,7 @@ Expr<T> FoldOperation(FoldingContext &context, Parentheses<T> &&x) {
   }
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Negate<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1224,7 +1224,7 @@ Expr<T> FoldOperation(FoldingContext &context, Negate<T> &&x) {
 
 // Binary (dyadic) operations
 
-template<typename LEFT, typename RIGHT>
+template <typename LEFT, typename RIGHT>
 std::optional<std::pair<Scalar<LEFT>, Scalar<RIGHT>>> OperandsAreConstants(
     const Expr<LEFT> &x, const Expr<RIGHT> &y) {
   if (auto xvalue{GetScalarConstantValue<LEFT>(x)}) {
@@ -1235,13 +1235,13 @@ std::optional<std::pair<Scalar<LEFT>, Scalar<RIGHT>>> OperandsAreConstants(
   return std::nullopt;
 }
 
-template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
+template <typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
 std::optional<std::pair<Scalar<LEFT>, Scalar<RIGHT>>> OperandsAreConstants(
     const Operation<DERIVED, RESULT, LEFT, RIGHT> &operation) {
   return OperandsAreConstants(operation.left(), operation.right());
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Add<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1266,7 +1266,7 @@ Expr<T> FoldOperation(FoldingContext &context, Add<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Subtract<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1292,7 +1292,7 @@ Expr<T> FoldOperation(FoldingContext &context, Subtract<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Multiply<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1317,7 +1317,7 @@ Expr<T> FoldOperation(FoldingContext &context, Multiply<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Divide<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1346,7 +1346,7 @@ Expr<T> FoldOperation(FoldingContext &context, Divide<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Power<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1378,7 +1378,7 @@ Expr<T> FoldOperation(FoldingContext &context, Power<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, RealToIntPower<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1399,7 +1399,7 @@ Expr<T> FoldOperation(FoldingContext &context, RealToIntPower<T> &&x) {
       x.right().u);
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Extremum<T> &&x) {
   if (auto array{ApplyElementwise(context, x,
           std::function<Expr<T>(Expr<T> &&, Expr<T> &&)>{[=](Expr<T> &&l,
@@ -1436,7 +1436,7 @@ Expr<T> FoldOperation(FoldingContext &context, Extremum<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> ToReal(
     FoldingContext &context, Expr<SomeType> &&expr) {
   using Result = Type<TypeCategory::Real, KIND>;
@@ -1452,7 +1452,7 @@ Expr<Type<TypeCategory::Real, KIND>> ToReal(
           CHECK(constant);
           Scalar<Result> real{constant->GetScalarValue().value()};
           From converted{From::ConvertUnsigned(real.RawBits()).value};
-          if (original != converted) {  // C1601
+          if (original != converted) { // C1601
             context.messages().Say(
                 "Nonzero bits truncated from BOZ literal constant in REAL intrinsic"_en_US);
           }
@@ -1466,7 +1466,7 @@ Expr<Type<TypeCategory::Real, KIND>> ToReal(
   return result.value();
 }
 
-template<typename T>
+template <typename T>
 Expr<T> ExpressionBase<T>::Rewrite(FoldingContext &context, Expr<T> &&expr) {
   return std::visit(
       [&](auto &&x) -> Expr<T> {
@@ -1486,5 +1486,5 @@ Expr<T> ExpressionBase<T>::Rewrite(FoldingContext &context, Expr<T> &&expr) {
 
 FOR_EACH_TYPE_AND_KIND(extern template class ExpressionBase, )
 
-}
-#endif  // FORTRAN_EVALUATE_FOLD_IMPLEMENTATION_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_FOLD_IMPLEMENTATION_H_
diff --git a/lib/Evaluate/fold-integer.cpp b/lib/Evaluate/fold-integer.cpp
index bf0eb6ca6c3e..6d159eda93e3 100644
--- a/lib/Evaluate/fold-integer.cpp
+++ b/lib/Evaluate/fold-integer.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
     FunctionRef<Type<TypeCategory::Integer, KIND>> &&funcRef) {
   using T = Type<TypeCategory::Integer, KIND>;
@@ -27,7 +27,7 @@ Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
                 static_cast<std::intmax_t>(*dim64), rank);
             return MakeInvalidIntrinsic<T>(std::move(funcRef));
           } else {
-            dim = *dim64 - 1;  // 1-based to 0-based
+            dim = *dim64 - 1; // 1-based to 0-based
           }
         } else {
           // DIM= is present but not constant
@@ -48,7 +48,7 @@ Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
                 ConvertToType<T>(Expr<ExtentType>{std::move(*extents)}));
           }
         } else {
-          lowerBoundsAreOne = symbol.Rank() == 0;  // LBOUND(array%component)
+          lowerBoundsAreOne = symbol.Rank() == 0; // LBOUND(array%component)
         }
       }
       if (lowerBoundsAreOne) {
@@ -65,7 +65,7 @@ Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
     FunctionRef<Type<TypeCategory::Integer, KIND>> &&funcRef) {
   using T = Type<TypeCategory::Integer, KIND>;
@@ -82,7 +82,7 @@ Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
                 static_cast<std::intmax_t>(*dim64), rank);
             return MakeInvalidIntrinsic<T>(std::move(funcRef));
           } else {
-            dim = *dim64 - 1;  // 1-based to 0-based
+            dim = *dim64 - 1; // 1-based to 0-based
           }
         } else {
           // DIM= is present but not constant
@@ -112,7 +112,7 @@ Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
             }
           }
         } else {
-          takeBoundsFromShape = symbol.Rank() == 0;  // UBOUND(array%component)
+          takeBoundsFromShape = symbol.Rank() == 0; // UBOUND(array%component)
         }
       }
       if (takeBoundsFromShape) {
@@ -132,7 +132,7 @@ Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Integer, KIND>> &&funcRef) {
@@ -177,7 +177,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
           cx->u);
     }
   } else if (name == "count") {
-    if (!args[1]) {  // TODO: COUNT(x,DIM=d)
+    if (!args[1]) { // TODO: COUNT(x,DIM=d)
       if (const auto *constant{UnwrapConstantValue<LogicalResult>(args[0])}) {
         std::int64_t result{0};
         for (const auto &element : constant->values()) {
@@ -260,7 +260,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     }
   } else if (name == "iand" || name == "ior" || name == "ieor") {
     auto fptr{&Scalar<T>::IAND};
-    if (name == "iand") {  // done in fptr declaration
+    if (name == "iand") { // done in fptr declaration
     } else if (name == "ior") {
       fptr = &Scalar<T>::IOR;
     } else if (name == "ieor") {
@@ -275,7 +275,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     // Second argument can be of any kind. However, it must be smaller or
     // equal than BIT_SIZE. It can be converted to Int4 to simplify.
     auto fptr{&Scalar<T>::IBCLR};
-    if (name == "ibclr") {  // done in fprt definition
+    if (name == "ibclr") { // done in fprt definition
     } else if (name == "ibset") {
       fptr = &Scalar<T>::IBSET;
     } else if (name == "ishft") {
@@ -299,7 +299,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
       return std::visit(
           [&](const auto &kch) -> Expr<T> {
             using TC = typename std::decay_t<decltype(kch)>::Result;
-            if (UnwrapExpr<Expr<SomeLogical>>(args[2])) {  // BACK=
+            if (UnwrapExpr<Expr<SomeLogical>>(args[2])) { // BACK=
               return FoldElementalIntrinsic<T, TC, TC, LogicalResult>(context,
                   std::move(funcRef),
                   ScalarFunc<T, TC, TC, LogicalResult>{
@@ -367,7 +367,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
                   }));
             }
             auto fptr{&Scalar<TI>::LEADZ};
-            if (name == "leadz") {  // done in fptr definition
+            if (name == "leadz") { // done in fptr definition
             } else if (name == "trailz") {
               fptr = &Scalar<TI>::TRAILZ;
             } else if (name == "popcnt") {
@@ -562,7 +562,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
             }));
   } else if (name == "size") {
     if (auto shape{GetShape(context, args[0])}) {
-      if (auto &dimArg{args[1]}) {  // DIM= is present, get one extent
+      if (auto &dimArg{args[1]}) { // DIM= is present, get one extent
         if (auto dim{GetInt64Arg(args[1])}) {
           int rank{GetRank(*shape)};
           if (*dim >= 1 && *dim <= rank) {
@@ -597,7 +597,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
 }
 
 // Substitute a bare type parameter reference with its value if it has one now
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldOperation(
     FoldingContext &context, TypeParamInquiry<KIND> &&inquiry) {
   using IntKIND = Type<TypeCategory::Integer, KIND>;
@@ -644,4 +644,4 @@ std::optional<std::int64_t> ToInt64(const Expr<SomeType> &expr) {
 
 FOR_EACH_INTEGER_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeInteger>;
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/fold-logical.cpp b/lib/Evaluate/fold-logical.cpp
index ebffbb20c6f3..99b95a962443 100644
--- a/lib/Evaluate/fold-logical.cpp
+++ b/lib/Evaluate/fold-logical.cpp
@@ -11,7 +11,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Logical, KIND>> &&funcRef) {
@@ -21,7 +21,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
   CHECK(intrinsic);
   std::string name{intrinsic->name};
   if (name == "all") {
-    if (!args[1]) {  // TODO: ALL(x,DIM=d)
+    if (!args[1]) { // TODO: ALL(x,DIM=d)
       if (const auto *constant{UnwrapConstantValue<T>(args[0])}) {
         bool result{true};
         for (const auto &element : constant->values()) {
@@ -34,7 +34,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
       }
     }
   } else if (name == "any") {
-    if (!args[1]) {  // TODO: ANY(x,DIM=d)
+    if (!args[1]) { // TODO: ANY(x,DIM=d)
       if (const auto *constant{UnwrapConstantValue<T>(args[0])}) {
         bool result{false};
         for (const auto &element : constant->values()) {
@@ -61,7 +61,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
       }
     }
     auto fptr{&Scalar<LargestInt>::BGE};
-    if (name == "bge") {  // done in fptr declaration
+    if (name == "bge") { // done in fptr declaration
     } else if (name == "bgt") {
       fptr = &Scalar<LargestInt>::BGT;
     } else if (name == "ble") {
@@ -95,7 +95,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<typename T>
+template <typename T>
 Expr<LogicalResult> FoldOperation(
     FoldingContext &context, Relational<T> &&relation) {
   if (auto array{ApplyElementwise(context, relation,
@@ -133,7 +133,7 @@ Expr<LogicalResult> FoldOperation(
       std::move(relation.u));
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
     FoldingContext &context, Not<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -147,7 +147,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
   return Expr<Ty>{x};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
     FoldingContext &context, LogicalOperation<KIND> &&operation) {
   using LOGICAL = Type<TypeCategory::Logical, KIND>;
@@ -162,11 +162,20 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
   if (auto folded{OperandsAreConstants(operation)}) {
     bool xt{folded->first.IsTrue()}, yt{folded->second.IsTrue()}, result{};
     switch (operation.logicalOperator) {
-    case LogicalOperator::And: result = xt && yt; break;
-    case LogicalOperator::Or: result = xt || yt; break;
-    case LogicalOperator::Eqv: result = xt == yt; break;
-    case LogicalOperator::Neqv: result = xt != yt; break;
-    case LogicalOperator::Not: DIE("not a binary operator");
+    case LogicalOperator::And:
+      result = xt && yt;
+      break;
+    case LogicalOperator::Or:
+      result = xt || yt;
+      break;
+    case LogicalOperator::Eqv:
+      result = xt == yt;
+      break;
+    case LogicalOperator::Neqv:
+      result = xt != yt;
+      break;
+    case LogicalOperator::Not:
+      DIE("not a binary operator");
     }
     return Expr<LOGICAL>{Constant<LOGICAL>{result}};
   }
@@ -175,4 +184,4 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
 
 FOR_EACH_LOGICAL_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeLogical>;
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/fold-real.cpp b/lib/Evaluate/fold-real.cpp
index 1a0d1d2cfd45..ee2ff5937462 100644
--- a/lib/Evaluate/fold-real.cpp
+++ b/lib/Evaluate/fold-real.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Real, KIND>> &&funcRef) {
@@ -52,7 +52,7 @@ Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
           name, KIND, KIND);
     }
   } else if (name == "bessel_jn" || name == "bessel_yn") {
-    if (args.size() == 2) {  // elemental
+    if (args.size() == 2) { // elemental
       // runtime functions use int arg
       using Int4 = Type<TypeCategory::Integer, 4>;
       if (auto callable{
@@ -135,7 +135,7 @@ Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> FoldOperation(
     FoldingContext &context, ComplexComponent<KIND> &&x) {
   using Operand = Type<TypeCategory::Complex, KIND>;
@@ -162,4 +162,4 @@ Expr<Type<TypeCategory::Real, KIND>> FoldOperation(
 
 FOR_EACH_REAL_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeReal>;
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/fold.cpp b/lib/Evaluate/fold.cpp
index 3ec4a2ed213d..b878bb351c42 100644
--- a/lib/Evaluate/fold.cpp
+++ b/lib/Evaluate/fold.cpp
@@ -85,16 +85,16 @@ Triplet FoldOperation(FoldingContext &context, Triplet &&triplet) {
 }
 
 Subscript FoldOperation(FoldingContext &context, Subscript &&subscript) {
-  return std::visit(
-      common::visitors{
-          [&](IndirectSubscriptIntegerExpr &&expr) {
-            expr.value() = Fold(context, std::move(expr.value()));
-            return Subscript(std::move(expr));
-          },
-          [&](Triplet &&triplet) {
-            return Subscript(FoldOperation(context, std::move(triplet)));
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](IndirectSubscriptIntegerExpr &&expr) {
+                          expr.value() = Fold(context, std::move(expr.value()));
+                          return Subscript(std::move(expr));
+                        },
+                        [&](Triplet &&triplet) {
+                          return Subscript(
+                              FoldOperation(context, std::move(triplet)));
+                        },
+                    },
       std::move(subscript.u));
 }
 
@@ -128,13 +128,12 @@ CoarrayRef FoldOperation(FoldingContext &context, CoarrayRef &&coarrayRef) {
 }
 
 DataRef FoldOperation(FoldingContext &context, DataRef &&dataRef) {
-  return std::visit(
-      common::visitors{
-          [&](SymbolRef symbol) { return DataRef{*symbol}; },
-          [&](auto &&x) {
-            return DataRef{FoldOperation(context, std::move(x))};
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](SymbolRef symbol) { return DataRef{*symbol}; },
+                        [&](auto &&x) {
+                          return DataRef{FoldOperation(context, std::move(x))};
+                        },
+                    },
       std::move(dataRef.u));
 }
 
@@ -188,4 +187,4 @@ Expr<ImpliedDoIndex::Result> FoldOperation(
 template class ExpressionBase<SomeDerived>;
 template class ExpressionBase<SomeType>;
 
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/formatting.cpp b/lib/Evaluate/formatting.cpp
index adcc22865762..c2cbe4521d45 100644
--- a/lib/Evaluate/formatting.cpp
+++ b/lib/Evaluate/formatting.cpp
@@ -31,7 +31,7 @@ static void ShapeAsFortran(
   }
 }
 
-template<typename RESULT, typename VALUE>
+template <typename RESULT, typename VALUE>
 llvm::raw_ostream &ConstantBase<RESULT, VALUE>::AsFortran(
     llvm::raw_ostream &o) const {
   if (Rank() > 1) {
@@ -72,7 +72,7 @@ llvm::raw_ostream &ConstantBase<RESULT, VALUE>::AsFortran(
   return o;
 }
 
-template<int KIND>
+template <int KIND>
 llvm::raw_ostream &Constant<Type<TypeCategory::Character, KIND>>::AsFortran(
     llvm::raw_ostream &o) const {
   if (Rank() > 1) {
@@ -146,67 +146,71 @@ llvm::raw_ostream &ProcedureRef::AsFortran(llvm::raw_ostream &o) const {
 // Operator precedence formatting; insert parentheses around operands
 // only when necessary.
 
-enum class Precedence {  // in increasing order for sane comparisons
+enum class Precedence { // in increasing order for sane comparisons
   DefinedBinary,
   Or,
   And,
-  Equivalence,  // .EQV., .NEQV.
-  Not,  // which binds *less* tightly in Fortran than relations
+  Equivalence, // .EQV., .NEQV.
+  Not, // which binds *less* tightly in Fortran than relations
   Relational,
-  Additive,  // +, -, and (arbitrarily) //
-  Negate,  // which binds *less* tightly than *, /, **
-  Multiplicative,  // *, /
-  Power,  // **, which is right-associative unlike the other dyadic operators
+  Additive, // +, -, and (arbitrarily) //
+  Negate, // which binds *less* tightly than *, /, **
+  Multiplicative, // *, /
+  Power, // **, which is right-associative unlike the other dyadic operators
   DefinedUnary,
   Top,
 };
 
-template<typename A> constexpr Precedence ToPrecedence(const A &) {
+template <typename A> constexpr Precedence ToPrecedence(const A &) {
   return Precedence::Top;
 }
-template<int KIND>
+template <int KIND>
 static Precedence ToPrecedence(const LogicalOperation<KIND> &x) {
   switch (x.logicalOperator) {
     SWITCH_COVERS_ALL_CASES
-  case LogicalOperator::And: return Precedence::And;
-  case LogicalOperator::Or: return Precedence::Or;
-  case LogicalOperator::Not: return Precedence::Not;
+  case LogicalOperator::And:
+    return Precedence::And;
+  case LogicalOperator::Or:
+    return Precedence::Or;
+  case LogicalOperator::Not:
+    return Precedence::Not;
   case LogicalOperator::Eqv:
-  case LogicalOperator::Neqv: return Precedence::Equivalence;
+  case LogicalOperator::Neqv:
+    return Precedence::Equivalence;
   }
 }
-template<int KIND> constexpr Precedence ToPrecedence(const Not<KIND> &) {
+template <int KIND> constexpr Precedence ToPrecedence(const Not<KIND> &) {
   return Precedence::Not;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Relational<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Relational<T> &) {
   return Precedence::Relational;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Add<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Add<T> &) {
   return Precedence::Additive;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Subtract<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Subtract<T> &) {
   return Precedence::Additive;
 }
-template<int KIND> constexpr Precedence ToPrecedence(const Concat<KIND> &) {
+template <int KIND> constexpr Precedence ToPrecedence(const Concat<KIND> &) {
   return Precedence::Additive;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Negate<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Negate<T> &) {
   return Precedence::Negate;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Multiply<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Multiply<T> &) {
   return Precedence::Multiplicative;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Divide<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Divide<T> &) {
   return Precedence::Multiplicative;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Power<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Power<T> &) {
   return Precedence::Power;
 }
-template<typename T>
+template <typename T>
 constexpr Precedence ToPrecedence(const RealToIntPower<T> &) {
   return Precedence::Power;
 }
-template<typename T> static Precedence ToPrecedence(const Constant<T> &x) {
+template <typename T> static Precedence ToPrecedence(const Constant<T> &x) {
   static constexpr TypeCategory cat{T::category};
   if constexpr (cat == TypeCategory::Integer || cat == TypeCategory::Real) {
     if (auto n{GetScalarConstantValue<T>(x)}) {
@@ -217,11 +221,11 @@ template<typename T> static Precedence ToPrecedence(const Constant<T> &x) {
   }
   return Precedence::Top;
 }
-template<typename T> static Precedence ToPrecedence(const Expr<T> &expr) {
+template <typename T> static Precedence ToPrecedence(const Expr<T> &expr) {
   return std::visit([](const auto &x) { return ToPrecedence(x); }, expr.u);
 }
 
-template<typename T> static bool IsNegatedScalarConstant(const Expr<T> &expr) {
+template <typename T> static bool IsNegatedScalarConstant(const Expr<T> &expr) {
   static constexpr TypeCategory cat{T::category};
   if constexpr (cat == TypeCategory::Integer || cat == TypeCategory::Real) {
     if (auto n{GetScalarConstantValue<T>(expr)}) {
@@ -231,7 +235,7 @@ template<typename T> static bool IsNegatedScalarConstant(const Expr<T> &expr) {
   return false;
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 static bool IsNegatedScalarConstant(const Expr<SomeKind<CAT>> &expr) {
   return std::visit(
       [](const auto &x) { return IsNegatedScalarConstant(x); }, expr.u);
@@ -241,74 +245,75 @@ struct OperatorSpelling {
   const char *prefix{""}, *infix{","}, *suffix{""};
 };
 
-template<typename A> constexpr OperatorSpelling SpellOperator(const A &) {
+template <typename A> constexpr OperatorSpelling SpellOperator(const A &) {
   return OperatorSpelling{};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Negate<A> &) {
   return OperatorSpelling{"-", "", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Parentheses<A> &) {
   return OperatorSpelling{"(", "", ")"};
 }
-template<int KIND>
+template <int KIND>
 static OperatorSpelling SpellOperator(const ComplexComponent<KIND> &x) {
   return {x.isImaginaryPart ? "aimag(" : "real(", "", ")"};
 }
-template<int KIND> constexpr OperatorSpelling SpellOperator(const Not<KIND> &) {
+template <int KIND>
+constexpr OperatorSpelling SpellOperator(const Not<KIND> &) {
   return OperatorSpelling{".NOT.", "", ""};
 }
-template<int KIND>
+template <int KIND>
 constexpr OperatorSpelling SpellOperator(const SetLength<KIND> &) {
   return OperatorSpelling{"%SET_LENGTH(", ",", ")"};
 }
-template<int KIND>
+template <int KIND>
 constexpr OperatorSpelling SpellOperator(const ComplexConstructor<KIND> &) {
   return OperatorSpelling{"(", ",", ")"};
 }
-template<typename A> constexpr OperatorSpelling SpellOperator(const Add<A> &) {
+template <typename A> constexpr OperatorSpelling SpellOperator(const Add<A> &) {
   return OperatorSpelling{"", "+", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Subtract<A> &) {
   return OperatorSpelling{"", "-", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Multiply<A> &) {
   return OperatorSpelling{"", "*", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Divide<A> &) {
   return OperatorSpelling{"", "/", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Power<A> &) {
   return OperatorSpelling{"", "**", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const RealToIntPower<A> &) {
   return OperatorSpelling{"", "**", ""};
 }
-template<typename A>
+template <typename A>
 static OperatorSpelling SpellOperator(const Extremum<A> &x) {
   return OperatorSpelling{
       x.ordering == Ordering::Less ? "min(" : "max(", ",", ")"};
 }
-template<int KIND>
+template <int KIND>
 constexpr OperatorSpelling SpellOperator(const Concat<KIND> &) {
   return OperatorSpelling{"", "//", ""};
 }
-template<int KIND>
+template <int KIND>
 static OperatorSpelling SpellOperator(const LogicalOperation<KIND> &x) {
   return OperatorSpelling{"", AsFortran(x.logicalOperator), ""};
 }
-template<typename T>
+template <typename T>
 static OperatorSpelling SpellOperator(const Relational<T> &x) {
   return OperatorSpelling{"", AsFortran(x.opr), ""};
 }
 
-template<typename D, typename R, typename... O>
+template <typename D, typename R, typename... O>
 llvm::raw_ostream &Operation<D, R, O...>::AsFortran(
     llvm::raw_ostream &o) const {
   Precedence lhsPrec{ToPrecedence(left())};
@@ -340,7 +345,7 @@ llvm::raw_ostream &Operation<D, R, O...>::AsFortran(
   return o << spelling.suffix;
 }
 
-template<typename TO, TypeCategory FROMCAT>
+template <typename TO, TypeCategory FROMCAT>
 llvm::raw_ostream &Convert<TO, FROMCAT>::AsFortran(llvm::raw_ostream &o) const {
   static_assert(TO::category == TypeCategory::Integer ||
           TO::category == TypeCategory::Real ||
@@ -364,16 +369,16 @@ llvm::raw_ostream &Relational<SomeType>::AsFortran(llvm::raw_ostream &o) const {
   return o;
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const Expr<T> &expr) {
   return expr.AsFortran(o);
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(
     llvm::raw_ostream &, const ArrayConstructorValues<T> &);
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const ImpliedDo<T> &implDo) {
   o << '(';
   EmitArray(o, implDo.values());
@@ -385,7 +390,7 @@ llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const ImpliedDo<T> &implDo) {
   return o;
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(
     llvm::raw_ostream &o, const ArrayConstructorValues<T> &values) {
   const char *sep{""};
@@ -397,14 +402,14 @@ llvm::raw_ostream &EmitArray(
   return o;
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &ArrayConstructor<T>::AsFortran(llvm::raw_ostream &o) const {
   o << '[' << GetType().AsFortran() << "::";
   EmitArray(o, *this);
   return o << ']';
 }
 
-template<int KIND>
+template <int KIND>
 llvm::raw_ostream &
 ArrayConstructor<Type<TypeCategory::Character, KIND>>::AsFortran(
     llvm::raw_ostream &o) const {
@@ -420,7 +425,7 @@ llvm::raw_ostream &ArrayConstructor<SomeDerived>::AsFortran(
   return o << ']';
 }
 
-template<typename RESULT>
+template <typename RESULT>
 std::string ExpressionBase<RESULT>::AsFortran() const {
   std::string buf;
   llvm::raw_string_ostream ss{buf};
@@ -428,21 +433,20 @@ std::string ExpressionBase<RESULT>::AsFortran() const {
   return ss.str();
 }
 
-template<typename RESULT>
+template <typename RESULT>
 llvm::raw_ostream &ExpressionBase<RESULT>::AsFortran(
     llvm::raw_ostream &o) const {
-  std::visit(
-      common::visitors{
-          [&](const BOZLiteralConstant &x) {
-            o << "z'" << x.Hexadecimal() << "'";
-          },
-          [&](const NullPointer &) { o << "NULL()"; },
-          [&](const common::CopyableIndirection<Substring> &s) {
-            s.value().AsFortran(o);
-          },
-          [&](const ImpliedDoIndex &i) { o << i.name.ToString(); },
-          [&](const auto &x) { x.AsFortran(o); },
-      },
+  std::visit(common::visitors{
+                 [&](const BOZLiteralConstant &x) {
+                   o << "z'" << x.Hexadecimal() << "'";
+                 },
+                 [&](const NullPointer &) { o << "NULL()"; },
+                 [&](const common::CopyableIndirection<Substring> &s) {
+                   s.value().AsFortran(o);
+                 },
+                 [&](const ImpliedDoIndex &i) { o << i.name.ToString(); },
+                 [&](const auto &x) { x.AsFortran(o); },
+             },
       derived().u);
   return o;
 }
@@ -542,17 +546,17 @@ llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::u32string &lit) {
   return o << parser::QuoteCharacterLiteral(lit);
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const A &x) {
   return x.AsFortran(o);
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, common::Reference<A> x) {
   return EmitVar(o, *x);
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(
     llvm::raw_ostream &o, const A *p, const char *kw = nullptr) {
   if (p) {
@@ -564,7 +568,7 @@ llvm::raw_ostream &EmitVar(
   return o;
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(
     llvm::raw_ostream &o, const std::optional<A> &x, const char *kw = nullptr) {
   if (x) {
@@ -576,7 +580,7 @@ llvm::raw_ostream &EmitVar(
   return o;
 }
 
-template<typename A, bool COPY>
+template <typename A, bool COPY>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o,
     const common::Indirection<A, COPY> &p, const char *kw = nullptr) {
   if (kw) {
@@ -586,13 +590,13 @@ llvm::raw_ostream &EmitVar(llvm::raw_ostream &o,
   return o;
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::shared_ptr<A> &p) {
   CHECK(p);
   return EmitVar(o, *p);
 }
 
-template<typename... A>
+template <typename... A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::variant<A...> &u) {
   std::visit([&](const auto &x) { EmitVar(o, x); }, u);
   return o;
@@ -602,7 +606,7 @@ llvm::raw_ostream &BaseObject::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
-template<int KIND>
+template <int KIND>
 llvm::raw_ostream &TypeParamInquiry<KIND>::AsFortran(
     llvm::raw_ostream &o) const {
   if (base_) {
@@ -617,11 +621,10 @@ llvm::raw_ostream &Component::AsFortran(llvm::raw_ostream &o) const {
 }
 
 llvm::raw_ostream &NamedEntity::AsFortran(llvm::raw_ostream &o) const {
-  std::visit(
-      common::visitors{
-          [&](SymbolRef s) { EmitVar(o, s); },
-          [&](const Component &c) { c.AsFortran(o); },
-      },
+  std::visit(common::visitors{
+                 [&](SymbolRef s) { EmitVar(o, s); },
+                 [&](const Component &c) { c.AsFortran(o); },
+             },
       u_);
   return o;
 }
@@ -699,24 +702,32 @@ llvm::raw_ostream &ProcedureDesignator::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &Designator<T>::AsFortran(llvm::raw_ostream &o) const {
-  std::visit(
-      common::visitors{
-          [&](SymbolRef symbol) { EmitVar(o, symbol); },
-          [&](const auto &x) { x.AsFortran(o); },
-      },
+  std::visit(common::visitors{
+                 [&](SymbolRef symbol) { EmitVar(o, symbol); },
+                 [&](const auto &x) { x.AsFortran(o); },
+             },
       u);
   return o;
 }
 
 llvm::raw_ostream &DescriptorInquiry::AsFortran(llvm::raw_ostream &o) const {
   switch (field_) {
-  case Field::LowerBound: o << "lbound("; break;
-  case Field::Extent: o << "size("; break;
-  case Field::Stride: o << "%STRIDE("; break;
-  case Field::Rank: o << "rank("; break;
-  case Field::Len: break;
+  case Field::LowerBound:
+    o << "lbound(";
+    break;
+  case Field::Extent:
+    o << "size(";
+    break;
+  case Field::Stride:
+    o << "%STRIDE(";
+    break;
+  case Field::Rank:
+    o << "rank(";
+    break;
+  case Field::Len:
+    break;
   }
   base_.AsFortran(o);
   if (field_ == Field::Len) {
@@ -769,4 +780,4 @@ llvm::raw_ostream &Assignment::AsFortran(llvm::raw_ostream &o) const {
 INSTANTIATE_CONSTANT_TEMPLATES
 INSTANTIATE_EXPRESSION_TEMPLATES
 INSTANTIATE_VARIABLE_TEMPLATES
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/host.cpp b/lib/Evaluate/host.cpp
index bc55d53fc2e3..ea831274b942 100644
--- a/lib/Evaluate/host.cpp
+++ b/lib/Evaluate/host.cpp
@@ -31,26 +31,26 @@ void HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment(
 #if __x86_64__
   hasSubnormalFlushingHardwareControl_ = true;
   if (context.flushSubnormalsToZero()) {
-    currentFenv_.__mxcsr |= 0x8000;  // result
-    currentFenv_.__mxcsr |= 0x0040;  // operands
+    currentFenv_.__mxcsr |= 0x8000; // result
+    currentFenv_.__mxcsr |= 0x0040; // operands
   } else {
-    currentFenv_.__mxcsr &= ~0x8000;  // result
-    currentFenv_.__mxcsr &= ~0x0040;  // operands
+    currentFenv_.__mxcsr &= ~0x8000; // result
+    currentFenv_.__mxcsr &= ~0x0040; // operands
   }
 #elif defined(__aarch64__)
 #if defined(__GNU_LIBRARY__)
   hasSubnormalFlushingHardwareControl_ = true;
   if (context.flushSubnormalsToZero()) {
-    currentFenv_.__fpcr |= (1U << 24);  // control register
+    currentFenv_.__fpcr |= (1U << 24); // control register
   } else {
-    currentFenv_.__fpcr &= ~(1U << 24);  // control register
+    currentFenv_.__fpcr &= ~(1U << 24); // control register
   }
 #elif defined(__BIONIC__)
   hasSubnormalFlushingHardwareControl_ = true;
   if (context.flushSubnormalsToZero()) {
-    currentFenv_.__control |= (1U << 24);  // control register
+    currentFenv_.__control |= (1U << 24); // control register
   } else {
-    currentFenv_.__control &= ~(1U << 24);  // control register
+    currentFenv_.__control &= ~(1U << 24); // control register
   }
 #else
   // If F18 is built with other C libraries on AArch64, software flushing will
@@ -76,10 +76,18 @@ void HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment(
     return;
   }
   switch (context.rounding().mode) {
-  case common::RoundingMode::TiesToEven: fesetround(FE_TONEAREST); break;
-  case common::RoundingMode::ToZero: fesetround(FE_TOWARDZERO); break;
-  case common::RoundingMode::Up: fesetround(FE_UPWARD); break;
-  case common::RoundingMode::Down: fesetround(FE_DOWNWARD); break;
+  case common::RoundingMode::TiesToEven:
+    fesetround(FE_TONEAREST);
+    break;
+  case common::RoundingMode::ToZero:
+    fesetround(FE_TOWARDZERO);
+    break;
+  case common::RoundingMode::Up:
+    fesetround(FE_UPWARD);
+    break;
+  case common::RoundingMode::Down:
+    fesetround(FE_DOWNWARD);
+    break;
   case common::RoundingMode::TiesAwayFromZero:
     fesetround(FE_TONEAREST);
     context.messages().Say(
@@ -135,4 +143,4 @@ void HostFloatingPointEnvironment::CheckAndRestoreFloatingPointEnvironment(
   }
   errno = 0;
 }
-}
+} // namespace Fortran::evaluate::host
diff --git a/lib/Evaluate/host.h b/lib/Evaluate/host.h
index cb7d5806f0cf..20355ae3147a 100644
--- a/lib/Evaluate/host.h
+++ b/lib/Evaluate/host.h
@@ -48,14 +48,14 @@ class HostFloatingPointEnvironment {
 };
 
 // Type mapping from F18 types to host types
-struct UnsupportedType {};  // There is no host type for the F18 type
+struct UnsupportedType {}; // There is no host type for the F18 type
 
-template<typename FTN_T> struct HostTypeHelper {
+template <typename FTN_T> struct HostTypeHelper {
   using Type = UnsupportedType;
 };
-template<typename FTN_T> using HostType = typename HostTypeHelper<FTN_T>::Type;
+template <typename FTN_T> using HostType = typename HostTypeHelper<FTN_T>::Type;
 
-template<typename... T> constexpr inline bool HostTypeExists() {
+template <typename... T> constexpr inline bool HostTypeExists() {
   return (... && (!std::is_same_v<HostType<T>, UnsupportedType>));
 }
 
@@ -64,7 +64,7 @@ template<typename... T> constexpr inline bool HostTypeExists() {
 // duplication.
 
 // Scalar conversion utilities from host scalars to F18 scalars
-template<typename FTN_T>
+template <typename FTN_T>
 inline constexpr Scalar<FTN_T> CastHostToFortran(const HostType<FTN_T> &x) {
   static_assert(HostTypeExists<FTN_T>());
   if constexpr (FTN_T::category == TypeCategory::Complex &&
@@ -79,7 +79,7 @@ inline constexpr Scalar<FTN_T> CastHostToFortran(const HostType<FTN_T> &x) {
 }
 
 // Scalar conversion utilities from  F18 scalars to host scalars
-template<typename FTN_T>
+template <typename FTN_T>
 inline constexpr HostType<FTN_T> CastFortranToHost(const Scalar<FTN_T> &x) {
   static_assert(HostTypeExists<FTN_T>());
   if constexpr (FTN_T::category == TypeCategory::Complex &&
@@ -93,40 +93,40 @@ inline constexpr HostType<FTN_T> CastFortranToHost(const Scalar<FTN_T> &x) {
   }
 }
 
-template<typename T> struct BiggerOrSameHostTypeHelper {
+template <typename T> struct BiggerOrSameHostTypeHelper {
   using Type =
       std::conditional_t<HostTypeExists<T>(), HostType<T>, UnsupportedType>;
   using FortranType = T;
 };
 
-template<typename FTN_T>
+template <typename FTN_T>
 using BiggerOrSameHostType = typename BiggerOrSameHostTypeHelper<FTN_T>::Type;
-template<typename FTN_T>
+template <typename FTN_T>
 using BiggerOrSameFortranTypeSupportedOnHost =
     typename BiggerOrSameHostTypeHelper<FTN_T>::FortranType;
 
-template<typename... T> constexpr inline bool BiggerOrSameHostTypeExists() {
+template <typename... T> constexpr inline bool BiggerOrSameHostTypeExists() {
   return (... && (!std::is_same_v<BiggerOrSameHostType<T>, UnsupportedType>));
 }
 
 // Defining the actual mapping
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 1>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 1>> {
   using Type = std::int8_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 2>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 2>> {
   using Type = std::int16_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 4>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 4>> {
   using Type = std::int32_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 8>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 8>> {
   using Type = std::int64_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 16>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 16>> {
 #if (defined(__GNUC__) || defined(__clang__)) && defined(__SIZEOF_INT128__)
   using Type = __int128_t;
 #else
@@ -137,21 +137,21 @@ template<> struct HostTypeHelper<Type<TypeCategory::Integer, 16>> {
 // TODO no mapping to host types are defined currently for 16bits float
 // It should be defined when gcc/clang have a better support for it.
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 4>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 4>> {
   // IEE 754 64bits
   using Type = std::conditional_t<sizeof(float) == 4 &&
           std::numeric_limits<float>::is_iec559,
       float, UnsupportedType>;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 8>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 8>> {
   // IEE 754 64bits
   using Type = std::conditional_t<sizeof(double) == 8 &&
           std::numeric_limits<double>::is_iec559,
       double, UnsupportedType>;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 10>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 10>> {
   // X87 80bits
   using Type = std::conditional_t<sizeof(long double) >= 10 &&
           std::numeric_limits<long double>::digits == 64 &&
@@ -159,7 +159,7 @@ template<> struct HostTypeHelper<Type<TypeCategory::Real, 10>> {
       long double, UnsupportedType>;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
   // IEE 754 128bits
   using Type = std::conditional_t<sizeof(long double) == 16 &&
           std::numeric_limits<long double>::digits == 113 &&
@@ -167,30 +167,30 @@ template<> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
       long double, UnsupportedType>;
 };
 
-template<int KIND> struct HostTypeHelper<Type<TypeCategory::Complex, KIND>> {
+template <int KIND> struct HostTypeHelper<Type<TypeCategory::Complex, KIND>> {
   using RealT = Fortran::evaluate::Type<TypeCategory::Real, KIND>;
   using Type = std::conditional_t<HostTypeExists<RealT>(),
       std::complex<HostType<RealT>>, UnsupportedType>;
 };
 
-template<int KIND> struct HostTypeHelper<Type<TypeCategory::Logical, KIND>> {
+template <int KIND> struct HostTypeHelper<Type<TypeCategory::Logical, KIND>> {
   using Type = std::conditional_t<KIND <= 8, std::uint8_t, UnsupportedType>;
 };
 
-template<int KIND> struct HostTypeHelper<Type<TypeCategory::Character, KIND>> {
+template <int KIND> struct HostTypeHelper<Type<TypeCategory::Character, KIND>> {
   using Type =
       Scalar<typename Fortran::evaluate::Type<TypeCategory::Character, KIND>>;
 };
 
 // Type mapping from host types to F18 types. This need to be placed after all
 // HostTypeHelper specializations.
-template<typename T, typename... TT> struct IndexInTupleHelper {};
-template<typename T, typename... TT>
+template <typename T, typename... TT> struct IndexInTupleHelper {};
+template <typename T, typename... TT>
 struct IndexInTupleHelper<T, std::tuple<TT...>> {
   static constexpr int value{common::TypeIndex<T, TT...>};
 };
-struct UnknownType {};  // the host type does not match any F18 types
-template<typename HOST_T> struct FortranTypeHelper {
+struct UnknownType {}; // the host type does not match any F18 types
+template <typename HOST_T> struct FortranTypeHelper {
   using HostTypeMapping =
       common::MapTemplate<HostType, AllIntrinsicTypes, std::tuple>;
   static constexpr int index{
@@ -202,38 +202,38 @@ template<typename HOST_T> struct FortranTypeHelper {
       UnknownType>;
 };
 
-template<typename HOST_T>
+template <typename HOST_T>
 using FortranType = typename FortranTypeHelper<HOST_T>::Type;
 
-template<typename... HT> constexpr inline bool FortranTypeExists() {
+template <typename... HT> constexpr inline bool FortranTypeExists() {
   return (... && (!std::is_same_v<FortranType<HT>, UnknownType>));
 }
 
 // Utility to find "bigger" types that exist on host. By bigger, it is meant
 // that the bigger type can represent all the values of the smaller types
 // without information loss.
-template<TypeCategory cat, int KIND> struct NextBiggerReal {
+template <TypeCategory cat, int KIND> struct NextBiggerReal {
   using Type = void;
 };
-template<TypeCategory cat> struct NextBiggerReal<cat, 2> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 2> {
   using Type = Fortran::evaluate::Type<cat, 4>;
 };
-template<TypeCategory cat> struct NextBiggerReal<cat, 3> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 3> {
   using Type = Fortran::evaluate::Type<cat, 4>;
 };
-template<TypeCategory cat> struct NextBiggerReal<cat, 4> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 4> {
   using Type = Fortran::evaluate::Type<cat, 8>;
 };
 
-template<TypeCategory cat> struct NextBiggerReal<cat, 8> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 8> {
   using Type = Fortran::evaluate::Type<cat, 10>;
 };
 
-template<TypeCategory cat> struct NextBiggerReal<cat, 10> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 10> {
   using Type = Fortran::evaluate::Type<cat, 16>;
 };
 
-template<int KIND>
+template <int KIND>
 struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Real, KIND>> {
   using T = Fortran::evaluate::Type<TypeCategory::Real, KIND>;
   using NextT = typename NextBiggerReal<TypeCategory::Real, KIND>::Type;
@@ -243,7 +243,7 @@ struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Real, KIND>> {
       typename BiggerOrSameHostTypeHelper<NextT>::FortranType>;
 };
 
-template<int KIND>
+template <int KIND>
 struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Complex, KIND>> {
   using T = Fortran::evaluate::Type<TypeCategory::Complex, KIND>;
   using NextT = typename NextBiggerReal<TypeCategory::Complex, KIND>::Type;
@@ -252,7 +252,7 @@ struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Complex, KIND>> {
   using FortranType = std::conditional_t<HostTypeExists<T>(), T,
       typename BiggerOrSameHostTypeHelper<NextT>::FortranType>;
 };
-}
-}
+} // namespace host
+} // namespace Fortran::evaluate
 
-#endif  // FORTRAN_EVALUATE_HOST_H_
+#endif // FORTRAN_EVALUATE_HOST_H_
diff --git a/lib/Evaluate/int-power.h b/lib/Evaluate/int-power.h
index 5ab16cd6d209..e700cacd380f 100644
--- a/lib/Evaluate/int-power.h
+++ b/lib/Evaluate/int-power.h
@@ -15,7 +15,7 @@
 
 namespace Fortran::evaluate {
 
-template<typename REAL, typename INT>
+template <typename REAL, typename INT>
 ValueWithRealFlags<REAL> TimesIntPowerOf(const REAL &factor, const REAL &base,
     const INT &power, Rounding rounding = defaultRounding) {
   ValueWithRealFlags<REAL> result{factor};
@@ -48,11 +48,11 @@ ValueWithRealFlags<REAL> TimesIntPowerOf(const REAL &factor, const REAL &base,
   return result;
 }
 
-template<typename REAL, typename INT>
+template <typename REAL, typename INT>
 ValueWithRealFlags<REAL> IntPower(
     const REAL &base, const INT &power, Rounding rounding = defaultRounding) {
   REAL one{REAL::FromInteger(INT{1}).value};
   return TimesIntPowerOf(one, base, power, rounding);
 }
-}
-#endif  // FORTRAN_EVALUATE_INT_POWER_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INT_POWER_H_
diff --git a/lib/Evaluate/integer.cpp b/lib/Evaluate/integer.cpp
index 074bee7b9fb8..e8173b44e873 100644
--- a/lib/Evaluate/integer.cpp
+++ b/lib/Evaluate/integer.cpp
@@ -28,4 +28,4 @@ static_assert(Integer<64>::partBits == 32);
 static_assert(std::is_same_v<typename Integer<64>::Part, std::uint32_t>);
 static_assert(Integer<128>::partBits == 32);
 static_assert(std::is_same_v<typename Integer<128>::Part, std::uint32_t>);
-}
+} // namespace Fortran::evaluate::value
diff --git a/lib/Evaluate/intrinsics-library-templates.h b/lib/Evaluate/intrinsics-library-templates.h
index 268a50718992..8accd2bbbd28 100644
--- a/lib/Evaluate/intrinsics-library-templates.h
+++ b/lib/Evaluate/intrinsics-library-templates.h
@@ -29,8 +29,8 @@ namespace Fortran::evaluate {
 // Define meaningful types for the runtime
 using RuntimeTypes = evaluate::AllIntrinsicTypes;
 
-template<typename T, typename... TT> struct IndexInTupleHelper {};
-template<typename T, typename... TT>
+template <typename T, typename... TT> struct IndexInTupleHelper {};
+template <typename T, typename... TT>
 struct IndexInTupleHelper<T, std::tuple<TT...>> {
   static constexpr TypeCode value{common::TypeIndex<T, TT...>};
 };
@@ -38,36 +38,36 @@ struct IndexInTupleHelper<T, std::tuple<TT...>> {
 static_assert(
     std::tuple_size_v<RuntimeTypes> < std::numeric_limits<TypeCode>::max(),
     "TypeCode is too small");
-template<typename T>
+template <typename T>
 inline constexpr TypeCode typeCodeOf{
     IndexInTupleHelper<T, RuntimeTypes>::value};
 
-template<TypeCode n>
+template <TypeCode n>
 using RuntimeTypeOf = typename std::tuple_element_t<n, RuntimeTypes>;
 
-template<typename TA, PassBy Pass>
+template <typename TA, PassBy Pass>
 using HostArgType = std::conditional_t<Pass == PassBy::Ref,
     std::add_lvalue_reference_t<std::add_const_t<host::HostType<TA>>>,
     host::HostType<TA>>;
 
-template<typename TR, typename... ArgInfo>
+template <typename TR, typename... ArgInfo>
 using HostFuncPointer = FuncPointer<host::HostType<TR>,
     HostArgType<typename ArgInfo::Type, ArgInfo::pass>...>;
 
 // Software Subnormal Flushing helper.
-template<typename T> struct Flusher {
+template <typename T> struct Flusher {
   // Only flush floating-points. Forward other scalars untouched.
   static constexpr inline const Scalar<T> &FlushSubnormals(const Scalar<T> &x) {
     return x;
   }
 };
-template<int Kind> struct Flusher<Type<TypeCategory::Real, Kind>> {
+template <int Kind> struct Flusher<Type<TypeCategory::Real, Kind>> {
   using T = Type<TypeCategory::Real, Kind>;
   static constexpr inline Scalar<T> FlushSubnormals(const Scalar<T> &x) {
     return x.FlushSubnormalToZero();
   }
 };
-template<int Kind> struct Flusher<Type<TypeCategory::Complex, Kind>> {
+template <int Kind> struct Flusher<Type<TypeCategory::Complex, Kind>> {
   using T = Type<TypeCategory::Complex, Kind>;
   static constexpr inline Scalar<T> FlushSubnormals(const Scalar<T> &x) {
     return x.FlushSubnormalToZero();
@@ -75,7 +75,7 @@ template<int Kind> struct Flusher<Type<TypeCategory::Complex, Kind>> {
 };
 
 // Callable factory
-template<typename TR, typename... ArgInfo> struct CallableHostWrapper {
+template <typename TR, typename... ArgInfo> struct CallableHostWrapper {
   static Scalar<TR> scalarCallable(FoldingContext &context,
       HostFuncPointer<TR, ArgInfo...> func,
       const Scalar<typename ArgInfo::Type> &... x) {
@@ -120,28 +120,28 @@ template<typename TR, typename... ArgInfo> struct CallableHostWrapper {
   }
 };
 
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 inline GenericFunctionPointer ToGenericFunctionPointer(
     FuncPointer<TR, TA...> f) {
   return reinterpret_cast<GenericFunctionPointer>(f);
 }
 
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 inline FuncPointer<TR, TA...> FromGenericFunctionPointer(
     GenericFunctionPointer g) {
   return reinterpret_cast<FuncPointer<TR, TA...>>(g);
 }
 
-template<typename TR, typename... ArgInfo>
+template <typename TR, typename... ArgInfo>
 IntrinsicProcedureRuntimeDescription::IntrinsicProcedureRuntimeDescription(
     const Signature<TR, ArgInfo...> &signature, bool isElemental)
-  : name{signature.name}, returnType{typeCodeOf<TR>},
-    argumentsType{typeCodeOf<typename ArgInfo::Type>...},
-    argumentsPassedBy{ArgInfo::pass...}, isElemental{isElemental},
-    callable{ToGenericFunctionPointer(
-        CallableHostWrapper<TR, ArgInfo...>::MakeScalarCallable())} {}
+    : name{signature.name}, returnType{typeCodeOf<TR>},
+      argumentsType{typeCodeOf<typename ArgInfo::Type>...},
+      argumentsPassedBy{ArgInfo::pass...}, isElemental{isElemental},
+      callable{ToGenericFunctionPointer(
+          CallableHostWrapper<TR, ArgInfo...>::MakeScalarCallable())} {}
 
-template<typename HostTA> static constexpr inline PassBy PassByMethod() {
+template <typename HostTA> static constexpr inline PassBy PassByMethod() {
   if constexpr (std::is_pointer_v<std::decay_t<HostTA>> ||
       std::is_lvalue_reference_v<HostTA>) {
     return PassBy::Ref;
@@ -149,24 +149,24 @@ template<typename HostTA> static constexpr inline PassBy PassByMethod() {
   return PassBy::Val;
 }
 
-template<typename HostTA>
+template <typename HostTA>
 using ArgInfoFromHostType =
     ArgumentInfo<host::FortranType<std::remove_pointer_t<std::decay_t<HostTA>>>,
         PassByMethod<HostTA>()>;
 
-template<typename HostTR, typename... HostTA>
+template <typename HostTR, typename... HostTA>
 using SignatureFromHostFuncPointer =
     Signature<host::FortranType<HostTR>, ArgInfoFromHostType<HostTA>...>;
 
-template<typename HostTR, typename... HostTA>
+template <typename HostTR, typename... HostTA>
 HostRuntimeIntrinsicProcedure::HostRuntimeIntrinsicProcedure(
     const std::string &name, FuncPointer<HostTR, HostTA...> func,
     bool isElemental)
-  : IntrinsicProcedureRuntimeDescription(
-        SignatureFromHostFuncPointer<HostTR, HostTA...>{name}, isElemental),
-    handle{ToGenericFunctionPointer(func)} {}
+    : IntrinsicProcedureRuntimeDescription(
+          SignatureFromHostFuncPointer<HostTR, HostTA...>{name}, isElemental),
+      handle{ToGenericFunctionPointer(func)} {}
 
-template<template<typename> typename ConstantContainer, typename TR,
+template <template <typename> typename ConstantContainer, typename TR,
     typename... TA>
 std::optional<HostProcedureWrapper<ConstantContainer, TR, TA...>>
 HostIntrinsicProceduresLibrary::GetHostProcedureWrapper(
@@ -205,5 +205,5 @@ HostIntrinsicProceduresLibrary::GetHostProcedureWrapper(
   return std::nullopt;
 }
 
-}
-#endif  // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_
diff --git a/lib/Evaluate/intrinsics-library.cpp b/lib/Evaluate/intrinsics-library.cpp
index 9636179d01e4..84c71e145bb6 100644
--- a/lib/Evaluate/intrinsics-library.cpp
+++ b/lib/Evaluate/intrinsics-library.cpp
@@ -46,7 +46,7 @@ bool HostIntrinsicProceduresLibrary::HasEquivalentProcedure(
 
 // Define which host runtime functions will be used for folding
 
-template<typename HostT>
+template <typename HostT>
 static void AddLibmRealHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   using F = FuncPointer<HostT, HostT>;
@@ -96,7 +96,7 @@ static void AddLibmRealHostProcedures(
   }
 }
 
-template<typename HostT>
+template <typename HostT>
 static void AddLibmComplexHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   using F = FuncPointer<std::complex<HostT>, const std::complex<HostT> &>;
@@ -207,21 +207,21 @@ enum class I {
 enum class L { F, R, P };
 
 struct NoSuchRuntimeSymbol {};
-template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
+template <L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 
 // Macros to declare fast/relaxed/precise libpgmath variants.
 #define DECLARE_PGMATH_FAST_REAL(func) \
   extern "C" float __fs_##func##_1(float); \
   extern "C" double __fd_##func##_1(double); \
-  template<> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
-  template<> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
+  template <> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
+  template <> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
 
 #define DECLARE_PGMATH_FAST_COMPLEX(func) \
   extern "C" float _Complex __fc_##func##_1(float _Complex); \
   extern "C" double _Complex __fz_##func##_1(double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<float>>{__fc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<double>>{__fz_##func##_1};
 
 #define DECLARE_PGMATH_FAST_ALL_FP(func) \
@@ -231,15 +231,15 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_PRECISE_REAL(func) \
   extern "C" float __ps_##func##_1(float); \
   extern "C" double __pd_##func##_1(double); \
-  template<> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
-  template<> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
+  template <> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
+  template <> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_COMPLEX(func) \
   extern "C" float _Complex __pc_##func##_1(float _Complex); \
   extern "C" double _Complex __pz_##func##_1(double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<float>>{__pc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<double>>{__pz_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_ALL_FP(func) \
@@ -249,15 +249,15 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_RELAXED_REAL(func) \
   extern "C" float __rs_##func##_1(float); \
   extern "C" double __rd_##func##_1(double); \
-  template<> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
-  template<> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
+  template <> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
+  template <> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_COMPLEX(func) \
   extern "C" float _Complex __rc_##func##_1(float _Complex); \
   extern "C" double _Complex __rz_##func##_1(double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<float>>{__rc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<double>>{__rz_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_ALL_FP(func) \
@@ -282,16 +282,16 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_FAST_REAL2(func) \
   extern "C" float __fs_##func##_1(float, float); \
   extern "C" double __fd_##func##_1(double, double); \
-  template<> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
-  template<> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
+  template <> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
+  template <> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
 
 #define DECLARE_PGMATH_FAST_COMPLEX2(func) \
   extern "C" float _Complex __fc_##func##_1(float _Complex, float _Complex); \
   extern "C" double _Complex __fz_##func##_1( \
       double _Complex, double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<float>>{__fc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<double>>{__fz_##func##_1};
 
 #define DECLARE_PGMATH_FAST_ALL_FP2(func) \
@@ -301,16 +301,16 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_PRECISE_REAL2(func) \
   extern "C" float __ps_##func##_1(float, float); \
   extern "C" double __pd_##func##_1(double, double); \
-  template<> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
-  template<> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
+  template <> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
+  template <> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_COMPLEX2(func) \
   extern "C" float _Complex __pc_##func##_1(float _Complex, float _Complex); \
   extern "C" double _Complex __pz_##func##_1( \
       double _Complex, double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<float>>{__pc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<double>>{__pz_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_ALL_FP2(func) \
@@ -320,16 +320,16 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_RELAXED_REAL2(func) \
   extern "C" float __rs_##func##_1(float, float); \
   extern "C" double __rd_##func##_1(double, double); \
-  template<> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
-  template<> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
+  template <> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
+  template <> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_COMPLEX2(func) \
   extern "C" float _Complex __rc_##func##_1(float _Complex, float _Complex); \
   extern "C" double _Complex __rz_##func##_1( \
       double _Complex, double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<float>>{__rc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<double>>{__rz_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_ALL_FP2(func) \
@@ -354,12 +354,12 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_MTH_VERSION_REAL(func) \
   extern "C" float __mth_i_##func(float); \
   extern "C" double __mth_i_d##func(double); \
-  template<> constexpr auto Sym<L::F, I::func, float>{__mth_i_##func}; \
-  template<> constexpr auto Sym<L::F, I::func, double>{__mth_i_d##func}; \
-  template<> constexpr auto Sym<L::P, I::func, float>{__mth_i_##func}; \
-  template<> constexpr auto Sym<L::P, I::func, double>{__mth_i_d##func}; \
-  template<> constexpr auto Sym<L::R, I::func, float>{__mth_i_##func}; \
-  template<> constexpr auto Sym<L::R, I::func, double>{__mth_i_d##func};
+  template <> constexpr auto Sym<L::F, I::func, float>{__mth_i_##func}; \
+  template <> constexpr auto Sym<L::F, I::func, double>{__mth_i_d##func}; \
+  template <> constexpr auto Sym<L::P, I::func, float>{__mth_i_##func}; \
+  template <> constexpr auto Sym<L::P, I::func, double>{__mth_i_d##func}; \
+  template <> constexpr auto Sym<L::R, I::func, float>{__mth_i_##func}; \
+  template <> constexpr auto Sym<L::R, I::func, double>{__mth_i_d##func};
 
 // Actual libpgmath declarations
 DECLARE_PGMATH_ALL(acos)
@@ -376,20 +376,20 @@ DECLARE_PGMATH_MTH_VERSION_REAL(bessel_y1)
 // bessel_jn and bessel_yn takes an int as first arg
 extern "C" float __mth_i_bessel_jn(int, float);
 extern "C" double __mth_i_dbessel_jn(int, double);
-template<> constexpr auto Sym<L::F, I::bessel_jn, float>{__mth_i_bessel_jn};
-template<> constexpr auto Sym<L::F, I::bessel_jn, double>{__mth_i_dbessel_jn};
-template<> constexpr auto Sym<L::P, I::bessel_jn, float>{__mth_i_bessel_jn};
-template<> constexpr auto Sym<L::P, I::bessel_jn, double>{__mth_i_dbessel_jn};
-template<> constexpr auto Sym<L::R, I::bessel_jn, float>{__mth_i_bessel_jn};
-template<> constexpr auto Sym<L::R, I::bessel_jn, double>{__mth_i_dbessel_jn};
+template <> constexpr auto Sym<L::F, I::bessel_jn, float>{__mth_i_bessel_jn};
+template <> constexpr auto Sym<L::F, I::bessel_jn, double>{__mth_i_dbessel_jn};
+template <> constexpr auto Sym<L::P, I::bessel_jn, float>{__mth_i_bessel_jn};
+template <> constexpr auto Sym<L::P, I::bessel_jn, double>{__mth_i_dbessel_jn};
+template <> constexpr auto Sym<L::R, I::bessel_jn, float>{__mth_i_bessel_jn};
+template <> constexpr auto Sym<L::R, I::bessel_jn, double>{__mth_i_dbessel_jn};
 extern "C" float __mth_i_bessel_yn(int, float);
 extern "C" double __mth_i_dbessel_yn(int, double);
-template<> constexpr auto Sym<L::F, I::bessel_yn, float>{__mth_i_bessel_yn};
-template<> constexpr auto Sym<L::F, I::bessel_yn, double>{__mth_i_dbessel_yn};
-template<> constexpr auto Sym<L::P, I::bessel_yn, float>{__mth_i_bessel_yn};
-template<> constexpr auto Sym<L::P, I::bessel_yn, double>{__mth_i_dbessel_yn};
-template<> constexpr auto Sym<L::R, I::bessel_yn, float>{__mth_i_bessel_yn};
-template<> constexpr auto Sym<L::R, I::bessel_yn, double>{__mth_i_dbessel_yn};
+template <> constexpr auto Sym<L::F, I::bessel_yn, float>{__mth_i_bessel_yn};
+template <> constexpr auto Sym<L::F, I::bessel_yn, double>{__mth_i_dbessel_yn};
+template <> constexpr auto Sym<L::P, I::bessel_yn, float>{__mth_i_bessel_yn};
+template <> constexpr auto Sym<L::P, I::bessel_yn, double>{__mth_i_dbessel_yn};
+template <> constexpr auto Sym<L::R, I::bessel_yn, float>{__mth_i_bessel_yn};
+template <> constexpr auto Sym<L::R, I::bessel_yn, double>{__mth_i_dbessel_yn};
 DECLARE_PGMATH_ALL(cos)
 DECLARE_PGMATH_ALL(cosh)
 DECLARE_PGMATH_MTH_VERSION_REAL(erf)
@@ -399,34 +399,34 @@ DECLARE_PGMATH_ALL(exp)
 DECLARE_PGMATH_MTH_VERSION_REAL(gamma)
 extern "C" float __mth_i_hypot(float, float);
 extern "C" double __mth_i_dhypot(double, double);
-template<> constexpr auto Sym<L::F, I::hypot, float>{__mth_i_hypot};
-template<> constexpr auto Sym<L::F, I::hypot, double>{__mth_i_dhypot};
-template<> constexpr auto Sym<L::P, I::hypot, float>{__mth_i_hypot};
-template<> constexpr auto Sym<L::P, I::hypot, double>{__mth_i_dhypot};
-template<> constexpr auto Sym<L::R, I::hypot, float>{__mth_i_hypot};
-template<> constexpr auto Sym<L::R, I::hypot, double>{__mth_i_dhypot};
+template <> constexpr auto Sym<L::F, I::hypot, float>{__mth_i_hypot};
+template <> constexpr auto Sym<L::F, I::hypot, double>{__mth_i_dhypot};
+template <> constexpr auto Sym<L::P, I::hypot, float>{__mth_i_hypot};
+template <> constexpr auto Sym<L::P, I::hypot, double>{__mth_i_dhypot};
+template <> constexpr auto Sym<L::R, I::hypot, float>{__mth_i_hypot};
+template <> constexpr auto Sym<L::R, I::hypot, double>{__mth_i_dhypot};
 DECLARE_PGMATH_ALL(log)
 DECLARE_PGMATH_REAL(log10)
 DECLARE_PGMATH_MTH_VERSION_REAL(log_gamma)
 // no function for modulo in libpgmath
 extern "C" float __fs_mod_1(float, float);
 extern "C" double __fd_mod_1(double, double);
-template<> constexpr auto Sym<L::F, I::mod, float>{__fs_mod_1};
-template<> constexpr auto Sym<L::F, I::mod, double>{__fd_mod_1};
-template<> constexpr auto Sym<L::P, I::mod, float>{__fs_mod_1};
-template<> constexpr auto Sym<L::P, I::mod, double>{__fd_mod_1};
-template<> constexpr auto Sym<L::R, I::mod, float>{__fs_mod_1};
-template<> constexpr auto Sym<L::R, I::mod, double>{__fd_mod_1};
+template <> constexpr auto Sym<L::F, I::mod, float>{__fs_mod_1};
+template <> constexpr auto Sym<L::F, I::mod, double>{__fd_mod_1};
+template <> constexpr auto Sym<L::P, I::mod, float>{__fs_mod_1};
+template <> constexpr auto Sym<L::P, I::mod, double>{__fd_mod_1};
+template <> constexpr auto Sym<L::R, I::mod, float>{__fs_mod_1};
+template <> constexpr auto Sym<L::R, I::mod, double>{__fd_mod_1};
 DECLARE_PGMATH_ALL2(pow)
 DECLARE_PGMATH_ALL(sin)
 DECLARE_PGMATH_ALL(sinh)
 DECLARE_PGMATH_MTH_VERSION_REAL(sqrt)
-DECLARE_PGMATH_COMPLEX(sqrt)  // real versions are __mth_i...
+DECLARE_PGMATH_COMPLEX(sqrt) // real versions are __mth_i...
 DECLARE_PGMATH_ALL(tan)
 DECLARE_PGMATH_ALL(tanh)
 
 // Fill the function map used for folding with libpgmath symbols
-template<L Lib, typename HostT>
+template <L Lib, typename HostT>
 static void AddLibpgmathRealHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   static_assert(std::is_same_v<HostT, float> || std::is_same_v<HostT, double>);
@@ -437,7 +437,7 @@ static void AddLibpgmathRealHostProcedures(
       {"asinh", Sym<Lib, I::asinh, HostT>, true},
       {"atan", Sym<Lib, I::atan, HostT>, true},
       {"atan", Sym<Lib, I::atan2, HostT>,
-          true},  // atan is also the generic name for atan2
+          true}, // atan is also the generic name for atan2
       {"atanh", Sym<Lib, I::atanh, HostT>, true},
       {"bessel_j0", Sym<Lib, I::bessel_j0, HostT>, true},
       {"bessel_j1", Sym<Lib, I::bessel_j1, HostT>, true},
@@ -475,19 +475,19 @@ static void AddLibpgmathRealHostProcedures(
 // by a pair of register but std::complex<float> is returned by structure
 // address. To fix the issue, wrapper around C _Complex functions are defined
 // below.
-template<FuncPointer<float _Complex, float _Complex> func>
+template <FuncPointer<float _Complex, float _Complex> func>
 static std::complex<float> ComplexCFuncWrapper(std::complex<float> &arg) {
   float _Complex res{func(*reinterpret_cast<float _Complex *>(&arg))};
   return *reinterpret_cast<std::complex<float> *>(&res);
 }
 
-template<FuncPointer<double _Complex, double _Complex> func>
+template <FuncPointer<double _Complex, double _Complex> func>
 static std::complex<double> ComplexCFuncWrapper(std::complex<double> &arg) {
   double _Complex res{func(*reinterpret_cast<double _Complex *>(&arg))};
   return *reinterpret_cast<std::complex<double> *>(&res);
 }
 
-template<FuncPointer<float _Complex, float _Complex, float _Complex> func>
+template <FuncPointer<float _Complex, float _Complex, float _Complex> func>
 static std::complex<float> ComplexCFuncWrapper(
     std::complex<float> &arg1, std::complex<float> &arg2) {
   float _Complex res{func(*reinterpret_cast<float _Complex *>(&arg1),
@@ -495,7 +495,7 @@ static std::complex<float> ComplexCFuncWrapper(
   return *reinterpret_cast<std::complex<float> *>(&res);
 }
 
-template<FuncPointer<double _Complex, double _Complex, double _Complex> func>
+template <FuncPointer<double _Complex, double _Complex, double _Complex> func>
 static std::complex<double> ComplexCFuncWrapper(
     std::complex<double> &arg1, std::complex<double> &arg2) {
   double _Complex res{func(*reinterpret_cast<double _Complex *>(&arg1),
@@ -503,7 +503,7 @@ static std::complex<double> ComplexCFuncWrapper(
   return *reinterpret_cast<std::complex<double> *>(&res);
 }
 
-template<L Lib, typename HostT>
+template <L Lib, typename HostT>
 static void AddLibpgmathComplexHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   static_assert(std::is_same_v<HostT, float> || std::is_same_v<HostT, double>);
@@ -535,7 +535,7 @@ static void AddLibpgmathComplexHostProcedures(
   }
 }
 
-template<L Lib>
+template <L Lib>
 static void InitHostIntrinsicLibraryWithLibpgmath(
     HostIntrinsicProceduresLibrary &lib) {
   if constexpr (host::FortranTypeExists<float>()) {
@@ -558,8 +558,8 @@ static void InitHostIntrinsicLibraryWithLibpgmath(
     AddLibmComplexHostProcedures<long double>(lib);
   }
 }
-}
-#endif  // LINK_WITH_LIBPGMATH
+} // namespace pgmath
+#endif // LINK_WITH_LIBPGMATH
 
 // Define which host runtime functions will be used for folding
 HostIntrinsicProceduresLibrary::HostIntrinsicProceduresLibrary() {
@@ -581,4 +581,4 @@ HostIntrinsicProceduresLibrary::HostIntrinsicProceduresLibrary() {
   InitHostIntrinsicLibraryWithLibm(*this);
 #endif
 }
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/intrinsics.cpp b/lib/Evaluate/intrinsics.cpp
index 1936ca2cebbf..cbf082bd8ac5 100644
--- a/lib/Evaluate/intrinsics.cpp
+++ b/lib/Evaluate/intrinsics.cpp
@@ -70,20 +70,20 @@ static constexpr CategorySet IntrinsicType{
 static constexpr CategorySet AnyType{IntrinsicType | DerivedType};
 
 ENUM_CLASS(KindCode, none, defaultIntegerKind,
-    defaultRealKind,  // is also the default COMPLEX kind
+    defaultRealKind, // is also the default COMPLEX kind
     doublePrecision, defaultCharKind, defaultLogicalKind,
-    any,  // matches any kind value; each instance is independent
-    same,  // match any kind, but all "same" kinds must be equal
-    operand,  // match any kind, with promotion (non-standard)
-    typeless,  // BOZ literals are INTEGER with this kind
-    teamType,  // TEAM_TYPE from module ISO_FORTRAN_ENV (for coarrays)
-    kindArg,  // this argument is KIND=
-    effectiveKind,  // for function results: "kindArg" value, possibly defaulted
-    dimArg,  // this argument is DIM=
-    likeMultiply,  // for DOT_PRODUCT and MATMUL
-    subscript,  // address-sized integer
-    size,  // default KIND= for SIZE(), UBOUND, &c.
-    addressable,  // for PRESENT(), &c.; anything (incl. procedure) but BOZ
+    any, // matches any kind value; each instance is independent
+    same, // match any kind, but all "same" kinds must be equal
+    operand, // match any kind, with promotion (non-standard)
+    typeless, // BOZ literals are INTEGER with this kind
+    teamType, // TEAM_TYPE from module ISO_FORTRAN_ENV (for coarrays)
+    kindArg, // this argument is KIND=
+    effectiveKind, // for function results: "kindArg" value, possibly defaulted
+    dimArg, // this argument is DIM=
+    likeMultiply, // for DOT_PRODUCT and MATMUL
+    subscript, // address-sized integer
+    size, // default KIND= for SIZE(), UBOUND, &c.
+    addressable, // for PRESENT(), &c.; anything (incl. procedure) but BOZ
 )
 
 struct TypePattern {
@@ -166,27 +166,27 @@ static constexpr TypePattern KINDLogical{LogicalType, KindCode::effectiveKind};
 // The default rank pattern for dummy arguments and function results is
 // "elemental".
 ENUM_CLASS(Rank,
-    elemental,  // scalar, or array that conforms with other array arguments
-    elementalOrBOZ,  // elemental, or typeless BOZ literal scalar
+    elemental, // scalar, or array that conforms with other array arguments
+    elementalOrBOZ, // elemental, or typeless BOZ literal scalar
     scalar, vector,
-    shape,  // INTEGER vector of known length and no negative element
+    shape, // INTEGER vector of known length and no negative element
     matrix,
-    array,  // not scalar, rank is known and greater than zero
-    known,  // rank is known and can be scalar
-    anyOrAssumedRank,  // rank can be unknown; assumed-type TYPE(*) allowed
-    conformable,  // scalar, or array of same rank & shape as "array" argument
-    reduceOperation,  // a pure function with constraints for REDUCE
-    dimReduced,  // scalar if no DIM= argument, else rank(array)-1
-    dimRemoved,  // scalar, or rank(array)-1
-    rankPlus1,  // rank(known)+1
-    shaped,  // rank is length of SHAPE vector
+    array, // not scalar, rank is known and greater than zero
+    known, // rank is known and can be scalar
+    anyOrAssumedRank, // rank can be unknown; assumed-type TYPE(*) allowed
+    conformable, // scalar, or array of same rank & shape as "array" argument
+    reduceOperation, // a pure function with constraints for REDUCE
+    dimReduced, // scalar if no DIM= argument, else rank(array)-1
+    dimRemoved, // scalar, or rank(array)-1
+    rankPlus1, // rank(known)+1
+    shaped, // rank is length of SHAPE vector
 )
 
 ENUM_CLASS(Optionality, required, optional,
-    defaultsToSameKind,  // for MatchingDefaultKIND
-    defaultsToDefaultForResult,  // for DefaultingKIND
-    defaultsToSizeKind,  // for SizeDefaultKIND
-    repeats,  // for MAX/MIN and their several variants
+    defaultsToSameKind, // for MatchingDefaultKIND
+    defaultsToDefaultForResult, // for DefaultingKIND
+    defaultsToSizeKind, // for SizeDefaultKIND
+    repeats, // for MAX/MIN and their several variants
 )
 
 struct IntrinsicDummyArgument {
@@ -224,7 +224,7 @@ static constexpr IntrinsicDummyArgument OptionalMASK{
     "mask", AnyLogical, Rank::conformable, Optionality::optional};
 
 struct IntrinsicInterface {
-  static constexpr int maxArguments{7};  // if not a MAX/MIN(...)
+  static constexpr int maxArguments{7}; // if not a MAX/MIN(...)
   const char *name{nullptr};
   IntrinsicDummyArgument dummy[maxArguments];
   TypePattern result;
@@ -350,7 +350,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
     {"dot_product",
         {{"vector_a", AnyComplex, Rank::vector},
             {"vector_b", AnyNumeric, Rank::vector}},
-        ResultNumeric, Rank::scalar},  // conjugates vector_a
+        ResultNumeric, Rank::scalar}, // conjugates vector_a
     {"dot_product",
         {{"vector_a", AnyIntOrReal, Rank::vector},
             {"vector_b", AnyNumeric, Rank::vector}},
@@ -600,7 +600,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
     {"rank", {{"a", AnyData, Rank::anyOrAssumedRank}}, DefaultInt,
         Rank::scalar},
     {"real", {{"a", SameComplex, Rank::elemental}},
-        SameReal},  // 16.9.160(4)(ii)
+        SameReal}, // 16.9.160(4)(ii)
     {"real", {{"a", AnyNumeric, Rank::elementalOrBOZ}, DefaultingKIND},
         KINDReal},
     {"reduce",
@@ -943,7 +943,7 @@ static const IntrinsicInterface intrinsicSubroutine[]{
     {"mvbits",
         {{"from", SameInt}, {"frompos", AnyInt}, {"len", AnyInt},
             {"to", SameInt}, {"topos", AnyInt}},
-        {}},  // elemental
+        {}}, // elemental
     {"random_init",
         {{"repeatable", AnyLogical, Rank::scalar},
             {"image_distinct", AnyLogical, Rank::scalar}},
@@ -953,7 +953,7 @@ static const IntrinsicInterface intrinsicSubroutine[]{
         {{"size", DefaultInt, Rank::scalar, Optionality::optional},
             {"put", DefaultInt, Rank::vector, Optionality::optional},
             {"get", DefaultInt, Rank::vector, Optionality::optional}},
-        {}},  // TODO: at most one argument can be present
+        {}}, // TODO: at most one argument can be present
     {"system_clock",
         {{"count", AnyInt, Rank::scalar, Optionality::optional},
             {"count_rate", AnyIntOrReal, Rank::scalar, Optionality::optional},
@@ -1066,7 +1066,7 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
     if (!arg) {
       if (d.optionality == Optionality::required) {
         messages.Say("missing mandatory '%s=' argument"_err_en_US, d.keyword);
-        return std::nullopt;  // missing non-OPTIONAL argument
+        return std::nullopt; // missing non-OPTIONAL argument
       } else {
         continue;
       }
@@ -1114,13 +1114,13 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
     } else if (!d.typePattern.categorySet.test(type->category())) {
       messages.Say("Actual argument for '%s=' has bad type '%s'"_err_en_US,
           d.keyword, type->AsFortran());
-      return std::nullopt;  // argument has invalid type category
+      return std::nullopt; // argument has invalid type category
     }
     bool argOk{false};
     switch (d.typePattern.kindCode) {
     case KindCode::none:
     case KindCode::typeless:
-    case KindCode::teamType:  // TODO: TEAM_TYPE
+    case KindCode::teamType: // TODO: TEAM_TYPE
       argOk = false;
       break;
     case KindCode::defaultIntegerKind:
@@ -1138,7 +1138,9 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
     case KindCode::defaultLogicalKind:
       argOk = type->kind() == defaults.GetDefaultKind(TypeCategory::Logical);
       break;
-    case KindCode::any: argOk = true; break;
+    case KindCode::any:
+      argOk = true;
+      break;
     case KindCode::kindArg:
       CHECK(type->category() == TypeCategory::Integer);
       CHECK(!kindArg);
@@ -1175,8 +1177,11 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
                   "for intrinsic '%s'",
           d.keyword, name);
       break;
-    case KindCode::addressable: argOk = true; break;
-    default: CRASH_NO_CASE;
+    case KindCode::addressable:
+      argOk = true;
+      break;
+    default:
+      CRASH_NO_CASE;
     }
     if (!argOk) {
       messages.Say(
@@ -1210,8 +1215,12 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
         }
         argOk = rank == 0 || rank == elementalRank;
         break;
-      case Rank::scalar: argOk = rank == 0; break;
-      case Rank::vector: argOk = rank == 1; break;
+      case Rank::scalar:
+        argOk = rank == 0;
+        break;
+      case Rank::vector:
+        argOk = rank == 1;
+        break;
       case Rank::shape:
         CHECK(!shapeArgSize);
         if (rank == 1) {
@@ -1229,7 +1238,9 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
           return std::nullopt;
         }
         break;
-      case Rank::matrix: argOk = rank == 2; break;
+      case Rank::matrix:
+        argOk = rank == 2;
+        break;
       case Rank::array:
         argOk = rank > 0;
         if (!arrayArg) {
@@ -1244,7 +1255,9 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
         }
         argOk = rank == knownArg->Rank();
         break;
-      case Rank::anyOrAssumedRank: argOk = true; break;
+      case Rank::anyOrAssumedRank:
+        argOk = true;
+        break;
       case Rank::conformable:
         CHECK(arrayArg);
         argOk = rank == 0 || rank == arrayArg->Rank();
@@ -1383,7 +1396,8 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
       common::die(
           "INTERNAL: bad KindCode appears on intrinsic '%s' result", name);
       break;
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
   } else {
     if (!call.isSubroutineCall) {
@@ -1396,10 +1410,18 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
   // Determine the rank of the function result.
   int resultRank{0};
   switch (rank) {
-  case Rank::elemental: resultRank = elementalRank; break;
-  case Rank::scalar: resultRank = 0; break;
-  case Rank::vector: resultRank = 1; break;
-  case Rank::matrix: resultRank = 2; break;
+  case Rank::elemental:
+    resultRank = elementalRank;
+    break;
+  case Rank::scalar:
+    resultRank = 0;
+    break;
+  case Rank::vector:
+    resultRank = 1;
+    break;
+  case Rank::matrix:
+    resultRank = 2;
+    break;
   case Rank::conformable:
     CHECK(arrayArg);
     resultRank = arrayArg->Rank();
@@ -1496,7 +1518,7 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
 class IntrinsicProcTable::Implementation {
 public:
   explicit Implementation(const common::IntrinsicTypeDefaultKinds &dfts)
-    : defaults_{dfts} {
+      : defaults_{dfts} {
     for (const IntrinsicInterface &f : genericIntrinsicFunction) {
       genericFuncs_.insert(std::make_pair(std::string{f.name}, &f));
     }
@@ -1798,10 +1820,14 @@ static DynamicType GetReturnType(const SpecificIntrinsicInterface &interface,
     const common::IntrinsicTypeDefaultKinds &defaults) {
   TypeCategory category{TypeCategory::Integer};
   switch (interface.result.kindCode) {
-  case KindCode::defaultIntegerKind: break;
+  case KindCode::defaultIntegerKind:
+    break;
   case KindCode::doublePrecision:
-  case KindCode::defaultRealKind: category = TypeCategory::Real; break;
-  default: CRASH_NO_CASE;
+  case KindCode::defaultRealKind:
+    category = TypeCategory::Real;
+    break;
+  default:
+    CRASH_NO_CASE;
   }
   int kind{interface.result.kindCode == KindCode::doublePrecision
           ? defaults.doublePrecisionKind()
@@ -1836,7 +1862,7 @@ std::optional<SpecificCall> IntrinsicProcTable::Implementation::Probe(
         return specificCall;
       }
     }
-    return std::nullopt;  // TODO
+    return std::nullopt; // TODO
   }
 
   // Helper to avoid emitting errors before it is sure there is no match
@@ -2063,4 +2089,4 @@ llvm::raw_ostream &IntrinsicProcTable::Implementation::Dump(
 llvm::raw_ostream &IntrinsicProcTable::Dump(llvm::raw_ostream &o) const {
   return impl_->Dump(o);
 }
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/logical.cpp b/lib/Evaluate/logical.cpp
index c29ed1df33d3..520d11fb967f 100644
--- a/lib/Evaluate/logical.cpp
+++ b/lib/Evaluate/logical.cpp
@@ -14,4 +14,4 @@ template class Logical<8>;
 template class Logical<16>;
 template class Logical<32>;
 template class Logical<64>;
-}
+} // namespace Fortran::evaluate::value
diff --git a/lib/Evaluate/real.cpp b/lib/Evaluate/real.cpp
index 18309d9adb64..58aa833dd6dd 100644
--- a/lib/Evaluate/real.cpp
+++ b/lib/Evaluate/real.cpp
@@ -16,26 +16,26 @@
 
 namespace Fortran::evaluate::value {
 
-template<typename W, int P> Relation Real<W, P>::Compare(const Real &y) const {
-  if (IsNotANumber() || y.IsNotANumber()) {  // NaN vs x, x vs NaN
+template <typename W, int P> Relation Real<W, P>::Compare(const Real &y) const {
+  if (IsNotANumber() || y.IsNotANumber()) { // NaN vs x, x vs NaN
     return Relation::Unordered;
   } else if (IsInfinite()) {
     if (y.IsInfinite()) {
-      if (IsNegative()) {  // -Inf vs +/-Inf
+      if (IsNegative()) { // -Inf vs +/-Inf
         return y.IsNegative() ? Relation::Equal : Relation::Less;
-      } else {  // +Inf vs +/-Inf
+      } else { // +Inf vs +/-Inf
         return y.IsNegative() ? Relation::Greater : Relation::Equal;
       }
-    } else {  // +/-Inf vs finite
+    } else { // +/-Inf vs finite
       return IsNegative() ? Relation::Less : Relation::Greater;
     }
-  } else if (y.IsInfinite()) {  // finite vs +/-Inf
+  } else if (y.IsInfinite()) { // finite vs +/-Inf
     return y.IsNegative() ? Relation::Greater : Relation::Less;
-  } else {  // two finite numbers
+  } else { // two finite numbers
     bool isNegative{IsNegative()};
     if (isNegative != y.IsNegative()) {
       if (word_.IOR(y.word_).IBCLR(bits - 1).IsZero()) {
-        return Relation::Equal;  // +/-0.0 == -/+0.0
+        return Relation::Equal; // +/-0.0 == -/+0.0
       } else {
         return isNegative ? Relation::Less : Relation::Greater;
       }
@@ -53,12 +53,12 @@ template<typename W, int P> Relation Real<W, P>::Compare(const Real &y) const {
   }
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
-    result.value = NotANumber();  // NaN + x -> NaN
+    result.value = NotANumber(); // NaN + x -> NaN
     if (IsSignalingNaN() || y.IsSignalingNaN()) {
       result.flags.set(RealFlag::InvalidArgument);
     }
@@ -69,18 +69,18 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
   if (IsInfinite()) {
     if (y.IsInfinite()) {
       if (isNegative == yIsNegative) {
-        result.value = *this;  // +/-Inf + +/-Inf -> +/-Inf
+        result.value = *this; // +/-Inf + +/-Inf -> +/-Inf
       } else {
-        result.value = NotANumber();  // +/-Inf + -/+Inf -> NaN
+        result.value = NotANumber(); // +/-Inf + -/+Inf -> NaN
         result.flags.set(RealFlag::InvalidArgument);
       }
     } else {
-      result.value = *this;  // +/-Inf + x -> +/-Inf
+      result.value = *this; // +/-Inf + x -> +/-Inf
     }
     return result;
   }
   if (y.IsInfinite()) {
-    result.value = y;  // x + +/-Inf -> +/-Inf
+    result.value = y; // x + +/-Inf -> +/-Inf
     return result;
   }
   int exponent{Exponent()};
@@ -98,7 +98,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
     if (order == Ordering::Equal) {
       // x + (-x) -> +0.0 unless rounding is directed downwards
       if (rounding.mode == common::RoundingMode::Down) {
-        result.value.word_ = result.value.word_.IBSET(bits - 1);  // -0.0
+        result.value.word_ = result.value.word_.IBSET(bits - 1); // -0.0
       }
       return result;
     }
@@ -110,7 +110,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
   Fraction yFraction{y.GetFraction()};
   int rshift = exponent - yExponent;
   if (exponent > 0 && yExponent == 0) {
-    --rshift;  // correct overshift when only y is subnormal
+    --rshift; // correct overshift when only y is subnormal
   }
   RoundingBits roundingBits{yFraction, rshift};
   yFraction = yFraction.SHIFTR(rshift);
@@ -133,12 +133,12 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Multiply(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
-    result.value = NotANumber();  // NaN * x -> NaN
+    result.value = NotANumber(); // NaN * x -> NaN
     if (IsSignalingNaN() || y.IsSignalingNaN()) {
       result.flags.set(RealFlag::InvalidArgument);
     }
@@ -146,7 +146,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Multiply(
     bool isNegative{IsNegative() != y.IsNegative()};
     if (IsInfinite() || y.IsInfinite()) {
       if (IsZero() || y.IsZero()) {
-        result.value = NotANumber();  // 0 * Inf -> NaN
+        result.value = NotANumber(); // 0 * Inf -> NaN
         result.flags.set(RealFlag::InvalidArgument);
       } else {
         result.value = Infinity(isNegative);
@@ -193,12 +193,12 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Multiply(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Divide(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
-    result.value = NotANumber();  // NaN / x -> NaN, x / NaN -> NaN
+    result.value = NotANumber(); // NaN / x -> NaN, x / NaN -> NaN
     if (IsSignalingNaN() || y.IsSignalingNaN()) {
       result.flags.set(RealFlag::InvalidArgument);
     }
@@ -206,20 +206,20 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Divide(
     bool isNegative{IsNegative() != y.IsNegative()};
     if (IsInfinite()) {
       if (y.IsInfinite()) {
-        result.value = NotANumber();  // Inf/Inf -> NaN
+        result.value = NotANumber(); // Inf/Inf -> NaN
         result.flags.set(RealFlag::InvalidArgument);
-      } else {  // Inf/x -> Inf,  Inf/0 -> Inf
+      } else { // Inf/x -> Inf,  Inf/0 -> Inf
         result.value = Infinity(isNegative);
       }
     } else if (y.IsZero()) {
-      if (IsZero()) {  // 0/0 -> NaN
+      if (IsZero()) { // 0/0 -> NaN
         result.value = NotANumber();
         result.flags.set(RealFlag::InvalidArgument);
-      } else {  // x/0 -> Inf, Inf/0 -> Inf
+      } else { // x/0 -> Inf, Inf/0 -> Inf
         result.value = Infinity(isNegative);
         result.flags.set(RealFlag::DivideByZero);
       }
-    } else if (IsZero() || y.IsInfinite()) {  // 0/x, x/Inf -> 0
+    } else if (IsZero() || y.IsInfinite()) { // 0/x, x/Inf -> 0
       if (isNegative) {
         result.value.word_ = result.value.word_.IBSET(bits - 1);
       }
@@ -261,7 +261,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Divide(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::ToWholeNumber(
     common::RoundingMode mode) const {
   ValueWithRealFlags<Real> result{*this};
@@ -273,11 +273,11 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::ToWholeNumber(
   } else {
     constexpr int noClipExponent{exponentBias + binaryPrecision - 1};
     if (Exponent() < noClipExponent) {
-      Real adjust;  // ABS(EPSILON(adjust)) == 0.5
+      Real adjust; // ABS(EPSILON(adjust)) == 0.5
       adjust.Normalize(IsSignBitSet(), noClipExponent, Fraction::MASKL(1));
       // Compute ival=(*this + adjust), losing any fractional bits; keep flags
       result = Add(adjust, Rounding{mode});
-      result.flags.reset(RealFlag::Inexact);  // result *is* exact
+      result.flags.reset(RealFlag::Inexact); // result *is* exact
       // Return (ival-adjust) with original sign in case we've generated a zero.
       result.value =
           result.value.Subtract(adjust, Rounding{common::RoundingMode::ToZero})
@@ -287,7 +287,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::ToWholeNumber(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 RealFlags Real<W, P>::Normalize(bool negative, int exponent,
     const Fraction &fraction, Rounding rounding, RoundingBits *roundingBits) {
   int lshift{fraction.LEADZ()};
@@ -311,7 +311,7 @@ RealFlags Real<W, P>::Normalize(bool negative, int exponent,
         rounding.mode == common::RoundingMode::TiesAwayFromZero ||
         (rounding.mode == common::RoundingMode::Up && !negative) ||
         (rounding.mode == common::RoundingMode::Down && negative)) {
-      word_ = Word{maxExponent}.SHIFTL(significandBits);  // Inf
+      word_ = Word{maxExponent}.SHIFTL(significandBits); // Inf
     } else {
       // directed rounding: round to largest finite value rather than infinity
       // (x86 does this, not sure whether it's standard behavior)
@@ -347,7 +347,7 @@ RealFlags Real<W, P>::Normalize(bool negative, int exponent,
   return {};
 }
 
-template<typename W, int P>
+template <typename W, int P>
 RealFlags Real<W, P>::Round(
     Rounding rounding, const RoundingBits &bits, bool multiply) {
   int origExponent{Exponent()};
@@ -365,7 +365,7 @@ RealFlags Real<W, P>::Round(
       // The fraction was all ones before rounding; sum.value is now zero
       sum.value = sum.value.IBSET(binaryPrecision - 1);
       if (++newExponent >= maxExponent) {
-        flags.set(RealFlag::Overflow);  // rounded away to an infinity
+        flags.set(RealFlag::Overflow); // rounded away to an infinity
       }
     }
     flags |= Normalize(IsNegative(), newExponent, sum.value);
@@ -388,7 +388,7 @@ RealFlags Real<W, P>::Round(
   return flags;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 void Real<W, P>::NormalizeAndRound(ValueWithRealFlags<Real> &result,
     bool isNegative, int exponent, const Fraction &fraction, Rounding rounding,
     RoundingBits roundingBits, bool multiply) {
@@ -400,13 +400,18 @@ void Real<W, P>::NormalizeAndRound(ValueWithRealFlags<Real> &result,
 inline enum decimal::FortranRounding MapRoundingMode(
     common::RoundingMode rounding) {
   switch (rounding) {
-  case common::RoundingMode::TiesToEven: break;
-  case common::RoundingMode::ToZero: return decimal::RoundToZero;
-  case common::RoundingMode::Down: return decimal::RoundDown;
-  case common::RoundingMode::Up: return decimal::RoundUp;
-  case common::RoundingMode::TiesAwayFromZero: return decimal::RoundCompatible;
+  case common::RoundingMode::TiesToEven:
+    break;
+  case common::RoundingMode::ToZero:
+    return decimal::RoundToZero;
+  case common::RoundingMode::Down:
+    return decimal::RoundDown;
+  case common::RoundingMode::Up:
+    return decimal::RoundUp;
+  case common::RoundingMode::TiesAwayFromZero:
+    return decimal::RoundCompatible;
   }
-  return decimal::RoundNearest;  // dodge gcc warning about lack of result
+  return decimal::RoundNearest; // dodge gcc warning about lack of result
 }
 
 inline RealFlags MapFlags(decimal::ConversionResultFlags flags) {
@@ -423,7 +428,7 @@ inline RealFlags MapFlags(decimal::ConversionResultFlags flags) {
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Read(
     const char *&p, Rounding rounding) {
   auto converted{
@@ -432,7 +437,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Read(
   return {*value, MapFlags(converted.flags)};
 }
 
-template<typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
+template <typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
   if (IsNotANumber()) {
     return "NaN 0x"s + word_.Hexadecimal();
   } else if (IsNegative()) {
@@ -478,7 +483,7 @@ template<typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
   }
 }
 
-template<typename W, int P>
+template <typename W, int P>
 llvm::raw_ostream &Real<W, P>::AsFortran(
     llvm::raw_ostream &o, int kind, bool minimal) const {
   if (IsNotANumber()) {
@@ -492,8 +497,8 @@ llvm::raw_ostream &Real<W, P>::AsFortran(
   } else {
     using B = decimal::BinaryFloatingPointNumber<P>;
     const auto *value{reinterpret_cast<const B *>(this)};
-    char buffer[24000];  // accommodate real*16
-    decimal::DecimalConversionFlags flags{};  // default: exact representation
+    char buffer[24000]; // accommodate real*16
+    decimal::DecimalConversionFlags flags{}; // default: exact representation
     if (minimal) {
       flags = decimal::Minimize;
     }
@@ -522,4 +527,4 @@ template class Real<Integer<32>, 24>;
 template class Real<Integer<64>, 53>;
 template class Real<Integer<80>, 64>;
 template class Real<Integer<128>, 113>;
-}
+} // namespace Fortran::evaluate::value
diff --git a/lib/Evaluate/shape.cpp b/lib/Evaluate/shape.cpp
index f27ee5814075..7d33a8b0594c 100644
--- a/lib/Evaluate/shape.cpp
+++ b/lib/Evaluate/shape.cpp
@@ -18,7 +18,7 @@
 #include "flang/Semantics/symbol.h"
 #include <functional>
 
-using namespace std::placeholders;  // _1, _2, &c. for std::bind()
+using namespace std::placeholders; // _1, _2, &c. for std::bind()
 
 namespace Fortran::evaluate {
 
@@ -36,7 +36,7 @@ bool IsExplicitShape(const Symbol &symbol0) {
   const Symbol &symbol{ResolveAssociations(symbol0)};
   if (const auto *details{symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
     const auto &shape{details->shape()};
-    return shape.Rank() == 0 || shape.IsExplicitShape();  // even if scalar
+    return shape.Rank() == 0 || shape.IsExplicitShape(); // even if scalar
   } else {
     return false;
   }
@@ -186,7 +186,7 @@ class GetLowerBoundHelper : public Traverse<GetLowerBoundHelper, ExtentExpr> {
   using Base = Traverse<GetLowerBoundHelper, ExtentExpr>;
   using Base::operator();
   GetLowerBoundHelper(FoldingContext &c, int d)
-    : Base{*this}, context_{c}, dimension_{d} {}
+      : Base{*this}, context_{c}, dimension_{d} {}
   static ExtentExpr Default() { return ExtentExpr{1}; }
   static ExtentExpr Combine(Result &&, Result &&) { return Default(); }
   ExtentExpr operator()(const Symbol &);
@@ -318,7 +318,7 @@ MaybeExtentExpr GetExtent(FoldingContext &context, const Subscript &subscript,
           [&](const IndirectSubscriptIntegerExpr &subs) -> MaybeExtentExpr {
             if (auto shape{GetShape(context, subs.value())}) {
               if (GetRank(*shape) > 0) {
-                CHECK(GetRank(*shape) == 1);  // vector-valued subscript
+                CHECK(GetRank(*shape) == 1); // vector-valued subscript
                 return std::move(shape->at(0));
               }
             }
@@ -378,7 +378,7 @@ Shape GetUpperBounds(FoldingContext &context, const NamedEntity &base) {
         result.emplace_back(Fold(context, common::Clone(*bound)));
       } else if (details->IsAssumedSize()) {
         CHECK(dim + 1 == base.Rank());
-        result.emplace_back(std::nullopt);  // UBOUND folding replaces with -1
+        result.emplace_back(std::nullopt); // UBOUND folding replaces with -1
       } else {
         result.emplace_back(ComputeUpperBound(context,
             GetLowerBound(context, base, dim), GetExtent(context, base, dim)));
@@ -409,7 +409,7 @@ auto GetShapeHelper::operator()(const Symbol &symbol) const -> Result {
             }
           },
           [](const semantics::EntityDetails &) {
-            return Scalar();  // no dimensions seen
+            return Scalar(); // no dimensions seen
           },
           [&](const semantics::ProcEntityDetails &proc) {
             if (const Symbol * interface{proc.interface().symbol()}) {
@@ -617,7 +617,7 @@ auto GetShapeHelper::operator()(const ProcedureRef &call) const -> Result {
         }
       }
     } else if (intrinsic->characteristics.value().attrs.test(characteristics::
-                       Procedure::Attr::NullPointer)) {  // NULL(MOLD=)
+                       Procedure::Attr::NullPointer)) { // NULL(MOLD=)
       return (*this)(call.arguments());
     } else {
       // TODO: shapes of other non-elemental intrinsic results
@@ -653,4 +653,4 @@ bool CheckConformance(parser::ContextualMessages &messages, const Shape &left,
   }
   return true;
 }
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/static-data.cpp b/lib/Evaluate/static-data.cpp
index bd1a729c4996..a288b08ebfab 100644
--- a/lib/Evaluate/static-data.cpp
+++ b/lib/Evaluate/static-data.cpp
@@ -93,4 +93,4 @@ std::optional<std::u32string> StaticDataObject::AsU32String() const {
   }
   return std::nullopt;
 }
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/tools.cpp b/lib/Evaluate/tools.cpp
index c3a30aad8ce6..693d25bd31fa 100644
--- a/lib/Evaluate/tools.cpp
+++ b/lib/Evaluate/tools.cpp
@@ -705,13 +705,12 @@ bool IsProcedure(const Expr<SomeType> &expr) {
 }
 
 bool IsProcedurePointer(const Expr<SomeType> &expr) {
-  return std::visit(
-      common::visitors{
-          [](const NullPointer &) { return true; },
-          [](const ProcedureDesignator &) { return true; },
-          [](const ProcedureRef &) { return true; },
-          [](const auto &) { return false; },
-      },
+  return std::visit(common::visitors{
+                        [](const NullPointer &) { return true; },
+                        [](const ProcedureDesignator &) { return true; },
+                        [](const ProcedureRef &) { return true; },
+                        [](const auto &) { return false; },
+                    },
       expr.u);
 }
 
diff --git a/lib/Evaluate/type.cpp b/lib/Evaluate/type.cpp
index d8d30264b397..d1fb80f6a781 100644
--- a/lib/Evaluate/type.cpp
+++ b/lib/Evaluate/type.cpp
@@ -80,11 +80,11 @@ bool IsDescriptor(const Symbol &symbol) {
       },
       symbol.details());
 }
-}
+} // namespace Fortran::semantics
 
 namespace Fortran::evaluate {
 
-template<typename A> inline bool PointeeComparison(const A *x, const A *y) {
+template <typename A> inline bool PointeeComparison(const A *x, const A *y) {
   return x == y || (x && y && *x == *y);
 }
 
@@ -198,7 +198,7 @@ static bool AreSameDerivedType(const semantics::DerivedTypeSpec &x,
   }
   auto thisQuery{std::make_pair(&x, &y)};
   if (inProgress.find(thisQuery) != inProgress.end()) {
-    return true;  // recursive use of types in components
+    return true; // recursive use of types in components
   }
   inProgress.insert(thisQuery);
   const auto &xDetails{xSymbol.get<semantics::DerivedTypeDetails>()};
@@ -243,7 +243,7 @@ static bool AreSameComponent(const semantics::Symbol &x,
   if (x.attrs().test(semantics::Attr::PRIVATE)) {
     return false;
   }
-#if 0  // TODO
+#if 0 // TODO
   if (const auto *xObject{x.detailsIf<semantics::ObjectEntityDetails>()}) {
     if (const auto *yObject{y.detailsIf<semantics::ObjectEntityDetails>()}) {
 #else
@@ -256,7 +256,7 @@ static bool AreSameComponent(const semantics::Symbol &x,
 else {
   return false;
 }
-}
+} // namespace Fortran::evaluate
 else {
   // TODO: non-object components
   return true;
@@ -343,7 +343,7 @@ bool DynamicType::IsTkCompatibleWith(const DynamicType &that) const {
     return false;
   } else if (!derived_ || !that.derived_ ||
       !IsKindCompatible(*derived_, *that.derived_)) {
-    return false;  // kind params don't match
+    return false; // kind params don't match
   } else {
     return AreCompatibleDerivedTypes(derived_, that.derived_, IsPolymorphic());
   }
@@ -377,7 +377,7 @@ std::optional<DynamicType> DynamicType::From(
 }
 
 std::optional<DynamicType> DynamicType::From(const semantics::Symbol &symbol) {
-  return From(symbol.GetType());  // Symbol -> DeclTypeSpec -> DynamicType
+  return From(symbol.GetType()); // Symbol -> DeclTypeSpec -> DynamicType
 }
 
 DynamicType DynamicType::ResultTypeForMultiply(const DynamicType &that) const {
@@ -387,37 +387,45 @@ DynamicType DynamicType::ResultTypeForMultiply(const DynamicType &that) const {
     case TypeCategory::Integer:
       return DynamicType{TypeCategory::Integer, std::max(kind_, that.kind_)};
     case TypeCategory::Real:
-    case TypeCategory::Complex: return that;
-    default: CRASH_NO_CASE;
+    case TypeCategory::Complex:
+      return that;
+    default:
+      CRASH_NO_CASE;
     }
     break;
   case TypeCategory::Real:
     switch (that.category_) {
-    case TypeCategory::Integer: return *this;
+    case TypeCategory::Integer:
+      return *this;
     case TypeCategory::Real:
       return DynamicType{TypeCategory::Real, std::max(kind_, that.kind_)};
     case TypeCategory::Complex:
       return DynamicType{TypeCategory::Complex, std::max(kind_, that.kind_)};
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
     break;
   case TypeCategory::Complex:
     switch (that.category_) {
-    case TypeCategory::Integer: return *this;
+    case TypeCategory::Integer:
+      return *this;
     case TypeCategory::Real:
     case TypeCategory::Complex:
       return DynamicType{TypeCategory::Complex, std::max(kind_, that.kind_)};
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
     break;
   case TypeCategory::Logical:
     switch (that.category_) {
     case TypeCategory::Logical:
       return DynamicType{TypeCategory::Logical, std::max(kind_, that.kind_)};
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
     break;
-  default: CRASH_NO_CASE;
+  default:
+    CRASH_NO_CASE;
   }
   return *this;
 }
@@ -463,7 +471,7 @@ bool SomeKind<TypeCategory::Derived>::operator==(
   return PointeeComparison(derivedTypeSpec_, that.derivedTypeSpec_);
 }
 
-int SelectedCharKind(const std::string &s, int defaultKind) {  // 16.9.168
+int SelectedCharKind(const std::string &s, int defaultKind) { // 16.9.168
   auto lower{parser::ToLowerCaseLetters(s)};
   auto n{lower.size()};
   while (n > 0 && lower[0] == ' ') {
@@ -491,7 +499,7 @@ class SelectedIntKindVisitor {
   explicit SelectedIntKindVisitor(std::int64_t p) : precision_{p} {}
   using Result = std::optional<int>;
   using Types = IntegerTypes;
-  template<typename T> Result Test() const {
+  template <typename T> Result Test() const {
     if (Scalar<T>::RANGE >= precision_) {
       return T::kind;
     } else {
@@ -514,10 +522,10 @@ int SelectedIntKind(std::int64_t precision) {
 class SelectedRealKindVisitor {
 public:
   explicit SelectedRealKindVisitor(std::int64_t p, std::int64_t r)
-    : precision_{p}, range_{r} {}
+      : precision_{p}, range_{r} {}
   using Result = std::optional<int>;
   using Types = RealTypes;
-  template<typename T> Result Test() const {
+  template <typename T> Result Test() const {
     if (Scalar<T>::PRECISION >= precision_ && Scalar<T>::RANGE >= range_) {
       return {T::kind};
     } else {
@@ -557,4 +565,4 @@ int SelectedRealKind(
     }
   }
 }
-}
+} // namespace Fortran::evaluate
diff --git a/lib/Evaluate/variable.cpp b/lib/Evaluate/variable.cpp
index 10362c583831..3ebd68a4543b 100644
--- a/lib/Evaluate/variable.cpp
+++ b/lib/Evaluate/variable.cpp
@@ -27,7 +27,7 @@ Triplet::Triplet() : stride_{Expr<SubscriptInteger>{1}} {}
 Triplet::Triplet(std::optional<Expr<SubscriptInteger>> &&l,
     std::optional<Expr<SubscriptInteger>> &&u,
     std::optional<Expr<SubscriptInteger>> &&s)
-  : stride_{s ? std::move(*s) : Expr<SubscriptInteger>{1}} {
+    : stride_{s ? std::move(*s) : Expr<SubscriptInteger>{1}} {
   if (l) {
     lower_.emplace(std::move(*l));
   }
@@ -77,8 +77,8 @@ bool Triplet::IsStrideOne() const {
 
 CoarrayRef::CoarrayRef(SymbolVector &&base, std::vector<Subscript> &&ss,
     std::vector<Expr<SubscriptInteger>> &&css)
-  : base_{std::move(base)}, subscript_(std::move(ss)),
-    cosubscript_(std::move(css)) {
+    : base_{std::move(base)}, subscript_(std::move(ss)),
+      cosubscript_(std::move(css)) {
   CHECK(!base_.empty());
   CHECK(!cosubscript_.empty());
 }
@@ -230,7 +230,8 @@ std::optional<Expr<SomeCharacter>> Substring::Fold(FoldingContext &context) {
       case 4:
         return {AsCategoryExpr(Constant<Type<TypeCategory::Character, 4>>{
             *newStaticData->AsU32String()})};
-      default: CRASH_NO_CASE;
+      default:
+        CRASH_NO_CASE;
       }
     }
   }
@@ -239,7 +240,7 @@ std::optional<Expr<SomeCharacter>> Substring::Fold(FoldingContext &context) {
 
 DescriptorInquiry::DescriptorInquiry(
     const NamedEntity &base, Field field, int dim)
-  : base_{base}, field_{field}, dimension_{dim} {
+    : base_{base}, field_{field}, dimension_{dim} {
   const Symbol &last{base_.GetLastSymbol()};
   CHECK(IsDescriptor(last));
   CHECK((field == Field::Len && dim == 0) ||
@@ -247,7 +248,7 @@ DescriptorInquiry::DescriptorInquiry(
 }
 
 DescriptorInquiry::DescriptorInquiry(NamedEntity &&base, Field field, int dim)
-  : base_{std::move(base)}, field_{field}, dimension_{dim} {
+    : base_{std::move(base)}, field_{field}, dimension_{dim} {
   const Symbol &last{base_.GetLastSymbol()};
   CHECK(IsDescriptor(last));
   CHECK((field == Field::Len && dim == 0) ||
@@ -298,11 +299,10 @@ std::optional<Expr<SubscriptInteger>> CoarrayRef::LEN() const {
 }
 
 std::optional<Expr<SubscriptInteger>> DataRef::LEN() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return SymbolLEN(symbol); },
-          [](const auto &x) { return x.LEN(); },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return SymbolLEN(symbol); },
+                        [](const auto &x) { return x.LEN(); },
+                    },
       u);
 }
 
@@ -316,14 +316,13 @@ std::optional<Expr<SubscriptInteger>> Substring::LEN() const {
   }
 }
 
-template<typename T>
+template <typename T>
 std::optional<Expr<SubscriptInteger>> Designator<T>::LEN() const {
   if constexpr (T::category == TypeCategory::Character) {
-    return std::visit(
-        common::visitors{
-            [](SymbolRef symbol) { return SymbolLEN(symbol); },
-            [](const auto &x) { return x.LEN(); },
-        },
+    return std::visit(common::visitors{
+                          [](SymbolRef symbol) { return SymbolLEN(symbol); },
+                          [](const auto &x) { return x.LEN(); },
+                      },
         u);
   } else {
     common::die("Designator<non-char>::LEN() called");
@@ -354,11 +353,10 @@ std::optional<Expr<SubscriptInteger>> ProcedureDesignator::LEN() const {
 
 // Rank()
 int BaseObject::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return symbol->Rank(); },
-          [](const StaticDataObject::Pointer &) { return 0; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return symbol->Rank(); },
+                        [](const StaticDataObject::Pointer &) { return 0; },
+                    },
       u);
 }
 
@@ -370,22 +368,20 @@ int Component::Rank() const {
 }
 
 int NamedEntity::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](const SymbolRef s) { return s->Rank(); },
-          [](const Component &c) { return c.Rank(); },
-      },
+  return std::visit(common::visitors{
+                        [](const SymbolRef s) { return s->Rank(); },
+                        [](const Component &c) { return c.Rank(); },
+                    },
       u_);
 }
 
 int Subscript::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](const IndirectSubscriptIntegerExpr &x) {
-            return x.value().Rank();
-          },
-          [](const Triplet &) { return 1; },
-      },
+  return std::visit(common::visitors{
+                        [](const IndirectSubscriptIntegerExpr &x) {
+                          return x.value().Rank();
+                        },
+                        [](const Triplet &) { return 1; },
+                    },
       u);
 }
 
@@ -416,31 +412,28 @@ int CoarrayRef::Rank() const {
 }
 
 int DataRef::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return symbol->Rank(); },
-          [](const auto &x) { return x.Rank(); },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return symbol->Rank(); },
+                        [](const auto &x) { return x.Rank(); },
+                    },
       u);
 }
 
 int Substring::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](const DataRef &dataRef) { return dataRef.Rank(); },
-          [](const StaticDataObject::Pointer &) { return 0; },
-      },
+  return std::visit(common::visitors{
+                        [](const DataRef &dataRef) { return dataRef.Rank(); },
+                        [](const StaticDataObject::Pointer &) { return 0; },
+                    },
       parent_);
 }
 
 int ComplexPart::Rank() const { return complex_.Rank(); }
 
-template<typename T> int Designator<T>::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return symbol->Rank(); },
-          [](const auto &x) { return x.Rank(); },
-      },
+template <typename T> int Designator<T>::Rank() const {
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return symbol->Rank(); },
+                        [](const auto &x) { return x.Rank(); },
+                    },
       u);
 }
 
@@ -450,42 +443,38 @@ const Symbol &Component::GetFirstSymbol() const {
 }
 
 const Symbol &NamedEntity::GetFirstSymbol() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef s) -> const Symbol & { return s; },
-          [](const Component &c) -> const Symbol & {
-            return c.GetFirstSymbol();
-          },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef s) -> const Symbol & { return s; },
+                        [](const Component &c) -> const Symbol & {
+                          return c.GetFirstSymbol();
+                        },
+                    },
       u_);
 }
 
 const Symbol &NamedEntity::GetLastSymbol() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef s) -> const Symbol & { return s; },
-          [](const Component &c) -> const Symbol & {
-            return c.GetLastSymbol();
-          },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef s) -> const Symbol & { return s; },
+                        [](const Component &c) -> const Symbol & {
+                          return c.GetLastSymbol();
+                        },
+                    },
       u_);
 }
 
 const Component *NamedEntity::UnwrapComponent() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef) -> const Component * { return nullptr; },
-          [](const Component &c) { return &c; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef) -> const Component * { return nullptr; },
+                        [](const Component &c) { return &c; },
+                    },
       u_);
 }
 
 Component *NamedEntity::UnwrapComponent() {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef &) -> Component * { return nullptr; },
-          [](Component &c) { return &c; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef &) -> Component * { return nullptr; },
+                        [](Component &c) { return &c; },
+                    },
       u_);
 }
 
@@ -496,33 +485,30 @@ const Symbol &ArrayRef::GetFirstSymbol() const {
 const Symbol &ArrayRef::GetLastSymbol() const { return base_.GetLastSymbol(); }
 
 const Symbol &DataRef::GetFirstSymbol() const {
-  return *std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return &*symbol; },
-          [](const auto &x) { return &x.GetFirstSymbol(); },
-      },
+  return *std::visit(common::visitors{
+                         [](SymbolRef symbol) { return &*symbol; },
+                         [](const auto &x) { return &x.GetFirstSymbol(); },
+                     },
       u);
 }
 
 const Symbol &DataRef::GetLastSymbol() const {
-  return *std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return &*symbol; },
-          [](const auto &x) { return &x.GetLastSymbol(); },
-      },
+  return *std::visit(common::visitors{
+                         [](SymbolRef symbol) { return &*symbol; },
+                         [](const auto &x) { return &x.GetLastSymbol(); },
+                     },
       u);
 }
 
 BaseObject Substring::GetBaseObject() const {
-  return std::visit(
-      common::visitors{
-          [](const DataRef &dataRef) {
-            return BaseObject{dataRef.GetFirstSymbol()};
-          },
-          [](StaticDataObject::Pointer pointer) {
-            return BaseObject{std::move(pointer)};
-          },
-      },
+  return std::visit(common::visitors{
+                        [](const DataRef &dataRef) {
+                          return BaseObject{dataRef.GetFirstSymbol()};
+                        },
+                        [](StaticDataObject::Pointer pointer) {
+                          return BaseObject{std::move(pointer)};
+                        },
+                    },
       parent_);
 }
 
@@ -535,7 +521,7 @@ const Symbol *Substring::GetLastSymbol() const {
       parent_);
 }
 
-template<typename T> BaseObject Designator<T>::GetBaseObject() const {
+template <typename T> BaseObject Designator<T>::GetBaseObject() const {
   return std::visit(
       common::visitors{
           [](SymbolRef symbol) { return BaseObject{symbol}; },
@@ -553,7 +539,7 @@ template<typename T> BaseObject Designator<T>::GetBaseObject() const {
       u);
 }
 
-template<typename T> const Symbol *Designator<T>::GetLastSymbol() const {
+template <typename T> const Symbol *Designator<T>::GetLastSymbol() const {
   return std::visit(
       common::visitors{
           [](SymbolRef symbol) { return &*symbol; },
@@ -571,7 +557,8 @@ template<typename T> const Symbol *Designator<T>::GetLastSymbol() const {
       u);
 }
 
-template<typename T> std::optional<DynamicType> Designator<T>::GetType() const {
+template <typename T>
+std::optional<DynamicType> Designator<T>::GetType() const {
   if constexpr (IsLengthlessIntrinsicType<Result>) {
     return {Result::GetType()};
   } else {
@@ -616,7 +603,7 @@ static bool AreSameSymbol(const Symbol &x, const Symbol &y) {
 
 // Implements operator==() for a union type, using special case handling
 // for Symbol references.
-template<typename A> static bool TestVariableEquality(const A &x, const A &y) {
+template <typename A> static bool TestVariableEquality(const A &x, const A &y) {
   const SymbolRef *xSymbol{std::get_if<SymbolRef>(&x.u)};
   if (const SymbolRef * ySymbol{std::get_if<SymbolRef>(&y.u)}) {
     return xSymbol && AreSameSymbol(*xSymbol, *ySymbol);
@@ -639,7 +626,7 @@ bool NamedEntity::operator==(const NamedEntity &that) const {
     return !that.IsSymbol() && GetComponent() == that.GetComponent();
   }
 }
-template<int KIND>
+template <int KIND>
 bool TypeParamInquiry<KIND>::operator==(
     const TypeParamInquiry<KIND> &that) const {
   return &*parameter_ == &*that.parameter_ && base_ == that.base_;
@@ -670,11 +657,11 @@ bool ComplexPart::operator==(const ComplexPart &that) const {
 bool ProcedureRef::operator==(const ProcedureRef &that) const {
   return proc_ == that.proc_ && arguments_ == that.arguments_;
 }
-template<typename T>
+template <typename T>
 bool Designator<T>::operator==(const Designator<T> &that) const {
   return TestVariableEquality(*this, that);
 }
-template<typename T>
+template <typename T>
 bool Variable<T>::operator==(const Variable<T> &that) const {
   return u == that.u;
 }
@@ -684,6 +671,6 @@ bool DescriptorInquiry::operator==(const DescriptorInquiry &that) const {
 }
 
 INSTANTIATE_VARIABLE_TEMPLATES
-}
+} // namespace Fortran::evaluate
 
 template class Fortran::common::Indirection<Fortran::evaluate::Component, true>;
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index 1ba242b9484b..76cccbfb06d3 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -32,9 +32,7 @@ struct RealAttributeStorage : public mlir::AttributeStorage {
   RealAttributeStorage(const KeyTy &key)
       : RealAttributeStorage(key.first, key.second) {}
 
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_value(key);
-  }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_value(key); }
 
   bool operator==(const KeyTy &key) const {
     return key.first == kind &&
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
index b6dd9edb2a2f..9a56c6bc403e 100644
--- a/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -25,7 +25,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
   addOperations<
 #define GET_OP_LIST
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
-                >();
+      >();
 }
 
 // anchor the class vtable to this compilation unit
diff --git a/lib/Parser/Fortran-parsers.cpp b/lib/Parser/Fortran-parsers.cpp
index 1bf5393b9b42..fb6ab347979d 100644
--- a/lib/Parser/Fortran-parsers.cpp
+++ b/lib/Parser/Fortran-parsers.cpp
@@ -594,7 +594,7 @@ TYPE_PARSER(recovery("END ENUM"_tok, "END" >> SkipPast<'\n'>{}) >>
 //        declaration-type-spec [[, attr-spec]... ::] entity-decl-list
 constexpr auto entityDeclWithoutEqInit{construct<EntityDecl>(name,
     maybe(arraySpec), maybe(coarraySpec), maybe("*" >> charLength),
-    !"="_tok >> maybe(initialization))};  // old-style REAL A/0/ still works
+    !"="_tok >> maybe(initialization))}; // old-style REAL A/0/ still works
 TYPE_PARSER(
     construct<TypeDeclarationStmt>(declarationTypeSpec,
         defaulted("," >> nonemptyList(Parser<AttrSpec>{})) / "::",
@@ -738,7 +738,7 @@ TYPE_PARSER(construct<AccessStmt>(accessSpec,
 
 // R828 access-id -> access-name | generic-spec
 TYPE_PARSER(construct<AccessId>(indirect(genericSpec)) ||
-    construct<AccessId>(name))  // initially ambiguous with genericSpec
+    construct<AccessId>(name)) // initially ambiguous with genericSpec
 
 // R829 allocatable-stmt -> ALLOCATABLE [::] allocatable-decl-list
 TYPE_PARSER(construct<AllocatableStmt>("ALLOCATABLE" >> maybe("::"_tok) >>
@@ -1254,4 +1254,4 @@ TYPE_CONTEXT_PARSER("PAUSE statement"_en_US,
 //     is not used because parsing is not sensitive to rank
 //   R1030 default-char-constant-expr -> default-char-expr
 //     is only used via scalar-default-char-constant-expr
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/basic-parsers.h b/lib/Parser/basic-parsers.h
index 10df4a71bcf9..b05a68da7922 100644
--- a/lib/Parser/basic-parsers.h
+++ b/lib/Parser/basic-parsers.h
@@ -46,7 +46,7 @@ namespace Fortran::parser {
 // error message at the current position.  The result type is unused,
 // but might have to be specified at the point of call to satisfy
 // the type checker.  The state remains valid.
-template<typename A> class FailParser {
+template <typename A> class FailParser {
 public:
   using resultType = A;
   constexpr FailParser(const FailParser &) = default;
@@ -60,13 +60,13 @@ template<typename A> class FailParser {
   const MessageFixedText text_;
 };
 
-template<typename A = Success> inline constexpr auto fail(MessageFixedText t) {
+template <typename A = Success> inline constexpr auto fail(MessageFixedText t) {
   return FailParser<A>{t};
 }
 
 // pure(x) returns a parser that always succeeds, does not advance the
 // parse, and returns a captured value whose type must be copy-constructible.
-template<typename A> class PureParser {
+template <typename A> class PureParser {
 public:
   using resultType = A;
   constexpr PureParser(const PureParser &) = default;
@@ -77,13 +77,13 @@ template<typename A> class PureParser {
   const A value_;
 };
 
-template<typename A> inline constexpr auto pure(A x) {
+template <typename A> inline constexpr auto pure(A x) {
   return PureParser<A>(std::move(x));
 }
 
 // If a is a parser, attempt(a) is the same parser, but on failure
 // the ParseState is guaranteed to have been restored to its initial value.
-template<typename A> class BacktrackingParser {
+template <typename A> class BacktrackingParser {
 public:
   using resultType = typename A::resultType;
   constexpr BacktrackingParser(const BacktrackingParser &) = default;
@@ -105,13 +105,13 @@ template<typename A> class BacktrackingParser {
   const A parser_;
 };
 
-template<typename A> inline constexpr auto attempt(const A &parser) {
+template <typename A> inline constexpr auto attempt(const A &parser) {
   return BacktrackingParser<A>{parser};
 }
 
 // For any parser x, the parser returned by !x is one that succeeds when
 // x fails, returning a useless (but present) result.  !x fails when x succeeds.
-template<typename PA> class NegatedParser {
+template <typename PA> class NegatedParser {
 public:
   using resultType = Success;
   constexpr NegatedParser(const NegatedParser &) = default;
@@ -129,14 +129,14 @@ template<typename PA> class NegatedParser {
   const PA parser_;
 };
 
-template<typename PA, typename = typename PA::resultType>
+template <typename PA, typename = typename PA::resultType>
 constexpr auto operator!(PA p) {
   return NegatedParser<PA>(p);
 }
 
 // For any parser x, the parser returned by lookAhead(x) is one that succeeds
 // or fails if x does, but the state is not modified.
-template<typename PA> class LookAheadParser {
+template <typename PA> class LookAheadParser {
 public:
   using resultType = Success;
   constexpr LookAheadParser(const LookAheadParser &) = default;
@@ -154,18 +154,18 @@ template<typename PA> class LookAheadParser {
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto lookAhead(PA p) {
+template <typename PA> inline constexpr auto lookAhead(PA p) {
   return LookAheadParser<PA>{p};
 }
 
 // If a is a parser, inContext("..."_en_US, a) runs it in a nested message
 // context.
-template<typename PA> class MessageContextParser {
+template <typename PA> class MessageContextParser {
 public:
   using resultType = typename PA::resultType;
   constexpr MessageContextParser(const MessageContextParser &) = default;
   constexpr MessageContextParser(MessageFixedText t, PA p)
-    : text_{t}, parser_{p} {}
+      : text_{t}, parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     state.PushContext(text_);
     std::optional<resultType> result{parser_.Parse(state)};
@@ -178,7 +178,7 @@ template<typename PA> class MessageContextParser {
   const PA parser_;
 };
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto inContext(MessageFixedText context, PA parser) {
   return MessageContextParser{context, parser};
 }
@@ -186,12 +186,12 @@ inline constexpr auto inContext(MessageFixedText context, PA parser) {
 // If a is a parser, withMessage("..."_en_US, a) runs it unchanged if it
 // succeeds, and overrides its messages with a specific one if it fails and
 // has matched no tokens.
-template<typename PA> class WithMessageParser {
+template <typename PA> class WithMessageParser {
 public:
   using resultType = typename PA::resultType;
   constexpr WithMessageParser(const WithMessageParser &) = default;
   constexpr WithMessageParser(MessageFixedText t, PA p)
-    : text_{t}, parser_{p} {}
+      : text_{t}, parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     Messages messages{std::move(state.messages())};
     ParseState backtrack{state};
@@ -226,7 +226,7 @@ template<typename PA> class WithMessageParser {
   const PA parser_;
 };
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto withMessage(MessageFixedText msg, PA parser) {
   return WithMessageParser{msg, parser};
 }
@@ -235,7 +235,7 @@ inline constexpr auto withMessage(MessageFixedText msg, PA parser) {
 // b succeeds after a does so, but fails when either a or b does.  The
 // result is taken from b.  Similarly, a / b also succeeds if both a and b
 // do so, but the result is that returned by a.
-template<typename PA, typename PB> class SequenceParser {
+template <typename PA, typename PB> class SequenceParser {
 public:
   using resultType = typename PB::resultType;
   constexpr SequenceParser(const SequenceParser &) = default;
@@ -253,12 +253,12 @@ template<typename PA, typename PB> class SequenceParser {
   const PB pb_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto operator>>(PA pa, PB pb) {
   return SequenceParser<PA, PB>{pa, pb};
 }
 
-template<typename PA, typename PB> class FollowParser {
+template <typename PA, typename PB> class FollowParser {
 public:
   using resultType = typename PA::resultType;
   constexpr FollowParser(const FollowParser &) = default;
@@ -277,12 +277,12 @@ template<typename PA, typename PB> class FollowParser {
   const PB pb_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto operator/(PA pa, PB pb) {
   return FollowParser<PA, PB>{pa, pb};
 }
 
-template<typename PA, typename... Ps> class AlternativesParser {
+template <typename PA, typename... Ps> class AlternativesParser {
 public:
   using resultType = typename PA::resultType;
   constexpr AlternativesParser(PA pa, Ps... ps) : ps_{pa, ps...} {}
@@ -301,7 +301,7 @@ template<typename PA, typename... Ps> class AlternativesParser {
   }
 
 private:
-  template<int J>
+  template <int J>
   void ParseRest(std::optional<resultType> &result, ParseState &state,
       ParseState &backtrack) const {
     ParseState prevState{std::move(state)};
@@ -318,11 +318,11 @@ template<typename PA, typename... Ps> class AlternativesParser {
   const std::tuple<PA, Ps...> ps_;
 };
 
-template<typename... Ps> inline constexpr auto first(Ps... ps) {
+template <typename... Ps> inline constexpr auto first(Ps... ps) {
   return AlternativesParser<Ps...>{ps...};
 }
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto operator||(PA pa, PB pb) {
   return AlternativesParser<PA, PB>{pa, pb};
 }
@@ -331,7 +331,7 @@ inline constexpr auto operator||(PA pa, PB pb) {
 // a does so, or if a fails and b succeeds.  If a succeeds, b is not attempted.
 // All messages from the first parse are retained.
 // The two parsers must return values of the same type.
-template<typename PA, typename PB> class RecoveryParser {
+template <typename PA, typename PB> class RecoveryParser {
 public:
   using resultType = typename PA::resultType;
   static_assert(std::is_same_v<resultType, typename PB::resultType>);
@@ -386,7 +386,7 @@ template<typename PA, typename PB> class RecoveryParser {
   const PB pb_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto recovery(PA pa, PB pb) {
   return RecoveryParser<PA, PB>{pa, pb};
 }
@@ -394,7 +394,7 @@ inline constexpr auto recovery(PA pa, PB pb) {
 // If x is a parser, then many(x) returns a parser that always succeeds
 // and whose value is a list, possibly empty, of the values returned from
 // repeated application of x until it fails or does not advance the parse.
-template<typename PA> class ManyParser {
+template <typename PA> class ManyParser {
   using paType = typename PA::resultType;
 
 public:
@@ -407,7 +407,7 @@ template<typename PA> class ManyParser {
     while (std::optional<paType> x{parser_.Parse(state)}) {
       result.emplace_back(std::move(*x));
       if (state.GetLocation() <= at) {
-        break;  // no forward progress, don't loop
+        break; // no forward progress, don't loop
       }
       at = state.GetLocation();
     }
@@ -418,7 +418,7 @@ template<typename PA> class ManyParser {
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto many(PA parser) {
+template <typename PA> inline constexpr auto many(PA parser) {
   return ManyParser<PA>{parser};
 }
 
@@ -426,7 +426,7 @@ template<typename PA> inline constexpr auto many(PA parser) {
 // and whose value is a nonempty list of the values returned from repeated
 // application of x until it fails or does not advance the parse.  In other
 // words, some(x) is a variant of many(x) that has to succeed at least once.
-template<typename PA> class SomeParser {
+template <typename PA> class SomeParser {
   using paType = typename PA::resultType;
 
 public:
@@ -450,12 +450,12 @@ template<typename PA> class SomeParser {
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto some(PA parser) {
+template <typename PA> inline constexpr auto some(PA parser) {
   return SomeParser<PA>{parser};
 }
 
 // If x is a parser, skipMany(x) is equivalent to many(x) but with no result.
-template<typename PA> class SkipManyParser {
+template <typename PA> class SkipManyParser {
 public:
   using resultType = Success;
   constexpr SkipManyParser(const SkipManyParser &) = default;
@@ -472,14 +472,14 @@ template<typename PA> class SkipManyParser {
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto skipMany(PA parser) {
+template <typename PA> inline constexpr auto skipMany(PA parser) {
   return SkipManyParser<PA>{parser};
 }
 
 // If x is a parser, skipManyFast(x) is equivalent to skipMany(x).
 // The parser x must always advance on success and never invalidate the
 // state on failure.
-template<typename PA> class SkipManyFastParser {
+template <typename PA> class SkipManyFastParser {
 public:
   using resultType = Success;
   constexpr SkipManyFastParser(const SkipManyFastParser &) = default;
@@ -494,13 +494,13 @@ template<typename PA> class SkipManyFastParser {
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto skipManyFast(PA parser) {
+template <typename PA> inline constexpr auto skipManyFast(PA parser) {
   return SkipManyFastParser<PA>{parser};
 }
 
 // If x is a parser returning some type A, then maybe(x) returns a
 // parser that returns std::optional<A>, always succeeding.
-template<typename PA> class MaybeParser {
+template <typename PA> class MaybeParser {
   using paType = typename PA::resultType;
 
 public:
@@ -519,21 +519,21 @@ template<typename PA> class MaybeParser {
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto maybe(PA parser) {
+template <typename PA> inline constexpr auto maybe(PA parser) {
   return MaybeParser<PA>{parser};
 }
 
 // If x is a parser, then defaulted(x) returns a parser that always
 // succeeds.  When x succeeds, its result is that of x; otherwise, its
 // result is a default-constructed value of x's result type.
-template<typename PA> class DefaultedParser {
+template <typename PA> class DefaultedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr DefaultedParser(const DefaultedParser &) = default;
   constexpr DefaultedParser(PA p) : parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     std::optional<std::optional<resultType>> ax{maybe(parser_).Parse(state)};
-    if (ax.value()) {  // maybe() always succeeds
+    if (ax.value()) { // maybe() always succeeds
       return std::move(*ax);
     }
     return resultType{};
@@ -543,7 +543,7 @@ template<typename PA> class DefaultedParser {
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto defaulted(PA p) {
+template <typename PA> inline constexpr auto defaulted(PA p) {
   return DefaultedParser<PA>(p);
 }
 
@@ -568,10 +568,10 @@ template<typename PA> inline constexpr auto defaulted(PA p) {
 
 // Runs a sequence of parsers until one fails or all have succeeded.
 // Collects their results in a std::tuple<std::optional<>...>.
-template<typename... PARSER>
+template <typename... PARSER>
 using ApplyArgs = std::tuple<std::optional<typename PARSER::resultType>...>;
 
-template<typename... PARSER, std::size_t... J>
+template <typename... PARSER, std::size_t... J>
 inline bool ApplyHelperArgs(const std::tuple<PARSER...> &parsers,
     ApplyArgs<PARSER...> &args, ParseState &state, std::index_sequence<J...>) {
   return (... &&
@@ -580,20 +580,20 @@ inline bool ApplyHelperArgs(const std::tuple<PARSER...> &parsers,
 }
 
 // Applies a function to the arguments collected by ApplyHelperArgs.
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 using ApplicableFunctionPointer = RESULT (*)(typename PARSER::resultType &&...);
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 using ApplicableFunctionObject =
     const std::function<RESULT(typename PARSER::resultType &&...)> &;
 
-template<template<typename...> class FUNCTION, typename RESULT,
+template <template <typename...> class FUNCTION, typename RESULT,
     typename... PARSER, std::size_t... J>
 inline RESULT ApplyHelperFunction(FUNCTION<RESULT, PARSER...> f,
     ApplyArgs<PARSER...> &&args, std::index_sequence<J...>) {
   return f(std::move(*std::get<J>(args))...);
 }
 
-template<template<typename...> class FUNCTION, typename RESULT,
+template <template <typename...> class FUNCTION, typename RESULT,
     typename... PARSER>
 class ApplyFunction {
   using funcType = FUNCTION<RESULT, PARSER...>;
@@ -602,7 +602,7 @@ class ApplyFunction {
   using resultType = RESULT;
   constexpr ApplyFunction(const ApplyFunction &) = default;
   constexpr ApplyFunction(funcType f, PARSER... p)
-    : function_{f}, parsers_{p...} {}
+      : function_{f}, parsers_{p...} {}
   std::optional<resultType> Parse(ParseState &state) const {
     ApplyArgs<PARSER...> results;
     using Sequence = std::index_sequence_for<PARSER...>;
@@ -619,14 +619,14 @@ class ApplyFunction {
   const std::tuple<PARSER...> parsers_;
 };
 
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 inline constexpr auto applyFunction(
     ApplicableFunctionPointer<RESULT, PARSER...> f, const PARSER &... parser) {
   return ApplyFunction<ApplicableFunctionPointer, RESULT, PARSER...>{
       f, parser...};
 }
 
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 inline /* not constexpr */ auto applyLambda(
     ApplicableFunctionObject<RESULT, PARSER...> f, const PARSER &... parser) {
   return ApplyFunction<ApplicableFunctionObject, RESULT, PARSER...>{
@@ -634,17 +634,17 @@ inline /* not constexpr */ auto applyLambda(
 }
 
 // Member function application
-template<typename OBJPARSER, typename... PARSER> class AMFPHelper {
+template <typename OBJPARSER, typename... PARSER> class AMFPHelper {
   using resultType = typename OBJPARSER::resultType;
 
 public:
   using type = void (resultType::*)(typename PARSER::resultType &&...);
 };
-template<typename OBJPARSER, typename... PARSER>
+template <typename OBJPARSER, typename... PARSER>
 using ApplicableMemberFunctionPointer =
     typename AMFPHelper<OBJPARSER, PARSER...>::type;
 
-template<typename OBJPARSER, typename... PARSER, std::size_t... J>
+template <typename OBJPARSER, typename... PARSER, std::size_t... J>
 inline auto ApplyHelperMember(
     ApplicableMemberFunctionPointer<OBJPARSER, PARSER...> mfp,
     ApplyArgs<OBJPARSER, PARSER...> &&args, std::index_sequence<J...>) ->
@@ -653,14 +653,14 @@ inline auto ApplyHelperMember(
   return std::get<0>(std::move(args));
 }
 
-template<typename OBJPARSER, typename... PARSER> class ApplyMemberFunction {
+template <typename OBJPARSER, typename... PARSER> class ApplyMemberFunction {
   using funcType = ApplicableMemberFunctionPointer<OBJPARSER, PARSER...>;
 
 public:
   using resultType = typename OBJPARSER::resultType;
   constexpr ApplyMemberFunction(const ApplyMemberFunction &) = default;
   constexpr ApplyMemberFunction(funcType f, OBJPARSER o, PARSER... p)
-    : function_{f}, parsers_{o, p...} {}
+      : function_{f}, parsers_{o, p...} {}
   std::optional<resultType> Parse(ParseState &state) const {
     ApplyArgs<OBJPARSER, PARSER...> results;
     using Sequence1 = std::index_sequence_for<OBJPARSER, PARSER...>;
@@ -678,7 +678,7 @@ template<typename OBJPARSER, typename... PARSER> class ApplyMemberFunction {
   const std::tuple<OBJPARSER, PARSER...> parsers_;
 };
 
-template<typename OBJPARSER, typename... PARSER>
+template <typename OBJPARSER, typename... PARSER>
 inline constexpr auto applyMem(
     ApplicableMemberFunctionPointer<OBJPARSER, PARSER...> mfp,
     const OBJPARSER &objParser, PARSER... parser) {
@@ -698,13 +698,13 @@ inline constexpr auto applyMem(
 // the opportunity to make construct<> capture source provenance all of the
 // time, and the first form will then lead to better error positioning.)
 
-template<typename RESULT, typename... PARSER, std::size_t... J>
+template <typename RESULT, typename... PARSER, std::size_t... J>
 inline RESULT ApplyHelperConstructor(
     ApplyArgs<PARSER...> &&args, std::index_sequence<J...>) {
   return RESULT{std::move(*std::get<J>(args))...};
 }
 
-template<typename RESULT, typename... PARSER> class ApplyConstructor {
+template <typename RESULT, typename... PARSER> class ApplyConstructor {
 public:
   using resultType = RESULT;
   constexpr ApplyConstructor(const ApplyConstructor &) = default;
@@ -737,14 +737,14 @@ template<typename RESULT, typename... PARSER> class ApplyConstructor {
   const std::tuple<PARSER...> parsers_;
 };
 
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 inline constexpr auto construct(PARSER... p) {
   return ApplyConstructor<RESULT, PARSER...>{p...};
 }
 
 // For a parser p, indirect(p) returns a parser that builds an indirect
 // reference to p's return type.
-template<typename PA> inline constexpr auto indirect(PA p) {
+template <typename PA> inline constexpr auto indirect(PA p) {
   return construct<common::Indirection<typename PA::resultType>>(p);
 }
 
@@ -752,13 +752,13 @@ template<typename PA> inline constexpr auto indirect(PA p) {
 // that succeeds if a does.  If a succeeds, it then applies many(b >> a).
 // The result is the list of the values returned from all of the applications
 // of a.
-template<typename T>
+template <typename T>
 common::IfNoLvalue<std::list<T>, T> prepend(T &&head, std::list<T> &&rest) {
   rest.push_front(std::move(head));
   return std::move(rest);
 }
 
-template<typename PA, typename PB> class NonemptySeparated {
+template <typename PA, typename PB> class NonemptySeparated {
 private:
   using paType = typename PA::resultType;
 
@@ -776,7 +776,7 @@ template<typename PA, typename PB> class NonemptySeparated {
   const PB separator_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto nonemptySeparated(PA p, PB sep) {
   return NonemptySeparated<PA, PB>{p, sep};
 }
@@ -791,7 +791,7 @@ inline constexpr auto nonemptySeparated(PA p, PB sep) {
 // which is essentially what "pure(T{})" would be able to do for x's
 // result type T, but without requiring that T have a default constructor
 // or a non-trivial destructor.  The state is preserved.
-template<bool pass> struct FixedParser {
+template <bool pass> struct FixedParser {
   using resultType = Success;
   constexpr FixedParser() {}
   static constexpr std::optional<Success> Parse(ParseState &) {
@@ -807,7 +807,7 @@ constexpr FixedParser<true> ok;
 constexpr FixedParser<false> cut;
 
 // A variant of recovery() above for convenience.
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto localRecovery(MessageFixedText msg, PA pa, PB pb) {
   return recovery(withMessage(msg, pa), pb >> defaulted(cut >> pa));
 }
@@ -832,7 +832,7 @@ constexpr NextCh nextCh;
 // If a is a parser for some nonstandard language feature LF, extension<LF>(a)
 // is a parser that optionally enabled, sets a strict conformance violation
 // flag, and may emit a warning message, if those are enabled.
-template<LanguageFeature LF, typename PA> class NonstandardParser {
+template <LanguageFeature LF, typename PA> class NonstandardParser {
 public:
   using resultType = typename PA::resultType;
   constexpr NonstandardParser(const NonstandardParser &) = default;
@@ -856,7 +856,7 @@ template<LanguageFeature LF, typename PA> class NonstandardParser {
   const PA parser_;
 };
 
-template<LanguageFeature LF, typename PA>
+template <LanguageFeature LF, typename PA>
 inline constexpr auto extension(PA parser) {
   return NonstandardParser<LF, PA>(parser);
 }
@@ -864,7 +864,7 @@ inline constexpr auto extension(PA parser) {
 // If a is a parser for some deprecated or deleted language feature LF,
 // deprecated<LF>(a) is a parser that is optionally enabled, sets a strict
 // conformance violation flag, and may emit a warning message, if enabled.
-template<LanguageFeature LF, typename PA> class DeprecatedParser {
+template <LanguageFeature LF, typename PA> class DeprecatedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr DeprecatedParser(const DeprecatedParser &) = default;
@@ -888,13 +888,13 @@ template<LanguageFeature LF, typename PA> class DeprecatedParser {
   const PA parser_;
 };
 
-template<LanguageFeature LF, typename PA>
+template <LanguageFeature LF, typename PA>
 inline constexpr auto deprecated(PA parser) {
   return DeprecatedParser<LF, PA>(parser);
 }
 
 // Parsing objects with "source" members.
-template<typename PA> class SourcedParser {
+template <typename PA> class SourcedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr SourcedParser(const SourcedParser &) = default;
@@ -917,8 +917,8 @@ template<typename PA> class SourcedParser {
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto sourced(PA parser) {
+template <typename PA> inline constexpr auto sourced(PA parser) {
   return SourcedParser<PA>{parser};
 }
-}
-#endif  // FORTRAN_PARSER_BASIC_PARSERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_BASIC_PARSERS_H_
diff --git a/lib/Parser/char-block.cpp b/lib/Parser/char-block.cpp
index f74b08268c6d..5228464fd7b7 100644
--- a/lib/Parser/char-block.cpp
+++ b/lib/Parser/char-block.cpp
@@ -15,4 +15,4 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharBlock &x) {
   return os << x.ToString();
 }
 
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/char-buffer.cpp b/lib/Parser/char-buffer.cpp
index 4f72a7bdac31..e0fc7335424b 100644
--- a/lib/Parser/char-buffer.cpp
+++ b/lib/Parser/char-buffer.cpp
@@ -87,4 +87,4 @@ std::string CharBuffer::MarshalNormalized() const {
   result.shrink_to_fit();
   return result;
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/char-set.cpp b/lib/Parser/char-set.cpp
index 382cc4f430d5..439e9fbff3a8 100644
--- a/lib/Parser/char-set.cpp
+++ b/lib/Parser/char-set.cpp
@@ -21,4 +21,4 @@ std::string SetOfChars::ToString() const {
   }
   return result;
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/characters.cpp b/lib/Parser/characters.cpp
index 62df4013332c..dce20a4e5fe4 100644
--- a/lib/Parser/characters.cpp
+++ b/lib/Parser/characters.cpp
@@ -33,7 +33,7 @@ int UTF_8CharacterBytes(const char *p) {
   }
 }
 
-template<typename STRING>
+template <typename STRING>
 std::string QuoteCharacterLiteralHelper(
     const STRING &str, bool backslashEscapes, Encoding encoding) {
   std::string result{'"'};
@@ -42,7 +42,7 @@ std::string QuoteCharacterLiteralHelper(
     using CharT = std::decay_t<decltype(ch)>;
     char32_t ch32{static_cast<std::make_unsigned_t<CharT>>(ch)};
     if (ch32 == static_cast<unsigned char>('"')) {
-      emit('"');  // double the " when it appears in the text
+      emit('"'); // double the " when it appears in the text
     }
     EmitQuotedChar(ch32, emit, emit, backslashEscapes, encoding);
   }
@@ -65,7 +65,7 @@ std::string QuoteCharacterLiteral(
   return QuoteCharacterLiteralHelper(str, backslashEscapes, encoding);
 }
 
-template<> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t ucs) {
+template <> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t ucs) {
   CHECK(ucs <= 0xff);
   EncodedCharacter result;
   result.buffer[0] = ucs;
@@ -73,7 +73,7 @@ template<> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t ucs) {
   return result;
 }
 
-template<> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t ucs) {
+template <> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t ucs) {
   // N.B. char32_t is unsigned
   EncodedCharacter result;
   if (ucs <= 0x7f) {
@@ -118,12 +118,14 @@ template<> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t ucs) {
 EncodedCharacter EncodeCharacter(Encoding encoding, char32_t ucs) {
   switch (encoding) {
     SWITCH_COVERS_ALL_CASES
-  case Encoding::LATIN_1: return EncodeCharacter<Encoding::LATIN_1>(ucs);
-  case Encoding::UTF_8: return EncodeCharacter<Encoding::UTF_8>(ucs);
+  case Encoding::LATIN_1:
+    return EncodeCharacter<Encoding::LATIN_1>(ucs);
+  case Encoding::UTF_8:
+    return EncodeCharacter<Encoding::UTF_8>(ucs);
   }
 }
 
-template<Encoding ENCODING, typename STRING>
+template <Encoding ENCODING, typename STRING>
 std::string EncodeString(const STRING &str) {
   std::string result;
   for (auto ch : str) {
@@ -141,7 +143,7 @@ template std::string EncodeString<Encoding::UTF_8, std::u16string>(
 template std::string EncodeString<Encoding::UTF_8, std::u32string>(
     const std::u32string &);
 
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::LATIN_1>(
     const char *cp, std::size_t bytes) {
   if (bytes >= 1) {
@@ -151,7 +153,7 @@ DecodedCharacter DecodeRawCharacter<Encoding::LATIN_1>(
   }
 }
 
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::UTF_8>(
     const char *cp, std::size_t bytes) {
   auto p{reinterpret_cast<const std::uint8_t *>(cp)};
@@ -174,7 +176,7 @@ DecodedCharacter DecodeRawCharacter<Encoding::UTF_8>(
     ch = ((ch & 0x1f) << 6) | (p[1] & 0x3f);
     return {ch, 2};
   } else {
-    return {};  // not valid UTF-8
+    return {}; // not valid UTF-8
   }
 }
 
@@ -186,7 +188,7 @@ static DecodedCharacter DecodeEscapedCharacter(
     } else if (IsOctalDigit(cp[1])) {
       std::size_t maxLen{std::min(std::size_t{4}, bytes)};
       char32_t code{static_cast<char32_t>(DecimalDigitValue(cp[1]))};
-      std::size_t len{2};  // so far
+      std::size_t len{2}; // so far
       for (; code <= 037 && len < maxLen && IsOctalDigit(cp[len]); ++len) {
         code = 8 * code + DecimalDigitValue(cp[len]);
       }
@@ -207,7 +209,7 @@ static DecodedCharacter DecodeEscapedCharacter(
   return {static_cast<unsigned char>(cp[0]), 1};
 }
 
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 static DecodedCharacter DecodeEscapedCharacters(
     const char *cp, std::size_t bytes) {
   char buffer[EncodedCharacter::maxEncodingBytes];
@@ -229,7 +231,7 @@ static DecodedCharacter DecodeEscapedCharacters(
   return code;
 }
 
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 DecodedCharacter DecodeCharacter(
     const char *cp, std::size_t bytes, bool backslashEscapes) {
   if (backslashEscapes && bytes >= 2 && *cp == '\\') {
@@ -255,7 +257,7 @@ DecodedCharacter DecodeCharacter(Encoding encoding, const char *cp,
   }
 }
 
-template<typename RESULT, Encoding ENCODING>
+template <typename RESULT, Encoding ENCODING>
 RESULT DecodeString(const std::string &s, bool backslashEscapes) {
   RESULT result;
   const char *p{s.c_str()};
@@ -283,4 +285,4 @@ template std::u16string DecodeString<std::u16string, Encoding::UTF_8>(
     const std::string &, bool);
 template std::u32string DecodeString<std::u32string, Encoding::UTF_8>(
     const std::string &, bool);
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/debug-parser.cpp b/lib/Parser/debug-parser.cpp
index 75578ec51840..dbcc64f14bb1 100644
--- a/lib/Parser/debug-parser.cpp
+++ b/lib/Parser/debug-parser.cpp
@@ -23,4 +23,4 @@ std::optional<Success> DebugParser::Parse(ParseState &state) const {
   }
   return {Success{}};
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/debug-parser.h b/lib/Parser/debug-parser.h
index fb9f208cd2fd..3c0079bf623c 100644
--- a/lib/Parser/debug-parser.h
+++ b/lib/Parser/debug-parser.h
@@ -25,7 +25,7 @@ class DebugParser {
   using resultType = Success;
   constexpr DebugParser(const DebugParser &) = default;
   constexpr DebugParser(const char *str, std::size_t n)
-    : str_{str}, length_{n} {}
+      : str_{str}, length_{n} {}
   std::optional<Success> Parse(ParseState &) const;
 
 private:
@@ -36,5 +36,5 @@ class DebugParser {
 constexpr DebugParser operator""_debug(const char str[], std::size_t n) {
   return DebugParser{str, n};
 }
-}
-#endif  // FORTRAN_PARSER_DEBUG_PARSER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_DEBUG_PARSER_H_
diff --git a/lib/Parser/executable-parsers.cpp b/lib/Parser/executable-parsers.cpp
index df1e7ba59d44..160b2dc376a4 100644
--- a/lib/Parser/executable-parsers.cpp
+++ b/lib/Parser/executable-parsers.cpp
@@ -121,7 +121,7 @@ TYPE_PARSER(first(construct<ActionStmt>(indirect(Parser<AllocateStmt>{})),
     construct<ActionStmt>(indirect(Parser<ReadStmt>{})),
     construct<ActionStmt>(indirect(Parser<ReturnStmt>{})),
     construct<ActionStmt>(indirect(Parser<RewindStmt>{})),
-    construct<ActionStmt>(indirect(Parser<StopStmt>{})),  // & error-stop-stmt
+    construct<ActionStmt>(indirect(Parser<StopStmt>{})), // & error-stop-stmt
     construct<ActionStmt>(indirect(Parser<SyncAllStmt>{})),
     construct<ActionStmt>(indirect(Parser<SyncImagesStmt>{})),
     construct<ActionStmt>(indirect(Parser<SyncMemoryStmt>{})),
@@ -163,7 +163,7 @@ TYPE_PARSER(construct<EndAssociateStmt>(
 //         block-stmt [block-specification-part] block end-block-stmt
 TYPE_CONTEXT_PARSER("BLOCK construct"_en_US,
     construct<BlockConstruct>(statement(Parser<BlockStmt>{}),
-        Parser<BlockSpecificationPart>{},  // can be empty
+        Parser<BlockSpecificationPart>{}, // can be empty
         block, statement(Parser<EndBlockStmt>{})))
 
 // R1108 block-stmt -> [block-construct-name :] BLOCK
@@ -522,4 +522,4 @@ TYPE_CONTEXT_PARSER("UNLOCK statement"_en_US,
     construct<UnlockStmt>("UNLOCK (" >> lockVariable,
         defaulted("," >> nonemptyList(statOrErrmsg)) / ")"))
 
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/expr-parsers.cpp b/lib/Parser/expr-parsers.cpp
index 79370881759c..a7ae7c32f9f6 100644
--- a/lib/Parser/expr-parsers.cpp
+++ b/lib/Parser/expr-parsers.cpp
@@ -84,7 +84,7 @@ constexpr auto primary{instrumented("primary"_en_US,
 // R1002 level-1-expr -> [defined-unary-op] primary
 // TODO: Reasonable extension: permit multiple defined-unary-ops
 constexpr auto level1Expr{sourced(
-    first(primary,  // must come before define op to resolve .TRUE._8 ambiguity
+    first(primary, // must come before define op to resolve .TRUE._8 ambiguity
         construct<Expr>(construct<Expr::DefinedUnary>(definedOpName, primary)),
         extension<LanguageFeature::SignedPrimary>(
             construct<Expr>(construct<Expr::UnaryPlus>("+" >> primary))),
@@ -110,7 +110,7 @@ inline std::optional<Expr> MultOperand::Parse(ParseState &state) {
       std::function<Expr(Expr &&)> power{[&result](Expr &&right) {
         return Expr{Expr::Power(std::move(result).value(), std::move(right))};
       }};
-      return applyLambda(power, multOperand).Parse(state);  // right-recursive
+      return applyLambda(power, multOperand).Parse(state); // right-recursive
     }
   }
   return result;
@@ -362,7 +362,7 @@ constexpr struct Level5Expr {
 
 // R1022 expr -> [expr defined-binary-op] level-5-expr
 // Defined binary operators associate leftwards.
-template<> std::optional<Expr> Parser<Expr>::Parse(ParseState &state) {
+template <> std::optional<Expr> Parser<Expr>::Parse(ParseState &state) {
   std::optional<Expr> result{level5Expr.Parse(state)};
   if (result) {
     auto source{result->source};
@@ -513,4 +513,4 @@ TYPE_CONTEXT_PARSER("END FORALL statement"_en_US,
 TYPE_CONTEXT_PARSER("FORALL statement"_en_US,
     construct<ForallStmt>("FORALL" >> indirect(concurrentHeader),
         unlabeledStatement(forallAssignmentStmt)))
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/expr-parsers.h b/lib/Parser/expr-parsers.h
index 7106352943f9..1a93344fffb7 100644
--- a/lib/Parser/expr-parsers.h
+++ b/lib/Parser/expr-parsers.h
@@ -18,24 +18,24 @@ namespace Fortran::parser {
 
 // R403 scalar-xyz -> xyz
 // Also define constant-xyz, int-xyz, default-char-xyz.
-template<typename PA> inline constexpr auto scalar(const PA &p) {
-  return construct<Scalar<typename PA::resultType>>(p);  // scalar-p
+template <typename PA> inline constexpr auto scalar(const PA &p) {
+  return construct<Scalar<typename PA::resultType>>(p); // scalar-p
 }
 
-template<typename PA> inline constexpr auto constant(const PA &p) {
-  return construct<Constant<typename PA::resultType>>(p);  // constant-p
+template <typename PA> inline constexpr auto constant(const PA &p) {
+  return construct<Constant<typename PA::resultType>>(p); // constant-p
 }
 
-template<typename PA> inline constexpr auto integer(const PA &p) {
-  return construct<Integer<typename PA::resultType>>(p);  // int-p
+template <typename PA> inline constexpr auto integer(const PA &p) {
+  return construct<Integer<typename PA::resultType>>(p); // int-p
 }
 
-template<typename PA> inline constexpr auto logical(const PA &p) {
-  return construct<Logical<typename PA::resultType>>(p);  // logical-p
+template <typename PA> inline constexpr auto logical(const PA &p) {
+  return construct<Logical<typename PA::resultType>>(p); // logical-p
 }
 
-template<typename PA> inline constexpr auto defaultChar(const PA &p) {
-  return construct<DefaultChar<typename PA::resultType>>(p);  // default-char-p
+template <typename PA> inline constexpr auto defaultChar(const PA &p) {
+  return construct<DefaultChar<typename PA::resultType>>(p); // default-char-p
 }
 
 // N.B. charLiteralConstantWithoutKind does not skip preceding space.
@@ -97,9 +97,9 @@ inline constexpr auto loopBounds(decltype(scalarExpr) &p) {
   return construct<LoopBounds<ScalarName, ScalarExpr>>(
       scalar(name) / "=", p / ",", p, maybe("," >> p));
 }
-template<typename PA> inline constexpr auto loopBounds(const PA &p) {
+template <typename PA> inline constexpr auto loopBounds(const PA &p) {
   return construct<LoopBounds<DoVariable, typename PA::resultType>>(
       doVariable / "=", p / ",", p, maybe("," >> p));
 }
-}
+} // namespace Fortran::parser
 #endif
diff --git a/lib/Parser/instrumented-parser.cpp b/lib/Parser/instrumented-parser.cpp
index 7419c53874ca..765d29219395 100644
--- a/lib/Parser/instrumented-parser.cpp
+++ b/lib/Parser/instrumented-parser.cpp
@@ -35,7 +35,7 @@ bool ParsingLog::Fails(
   }
   auto &entry{tagIter->second};
   if (entry.deferred && !state.deferMessages()) {
-    return false;  // don't fail fast, we want to generate messages
+    return false; // don't fail fast, we want to generate messages
   }
   ++entry.count;
   if (!state.deferMessages()) {
@@ -74,4 +74,4 @@ void ParsingLog::Dump(llvm::raw_ostream &o, const CookedSource &cooked) const {
     }
   }
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/io-parsers.cpp b/lib/Parser/io-parsers.cpp
index 48b383bfd80a..9eab72172b7b 100644
--- a/lib/Parser/io-parsers.cpp
+++ b/lib/Parser/io-parsers.cpp
@@ -136,7 +136,7 @@ TYPE_CONTEXT_PARSER("CLOSE statement"_en_US,
 //         READ format [, input-item-list]
 constexpr auto inputItemList{
     extension<LanguageFeature::IOListLeadingComma>(
-        some("," >> inputItem)) ||  // legacy extension: leading comma
+        some("," >> inputItem)) || // legacy extension: leading comma
     optionalList(inputItem)};
 
 TYPE_CONTEXT_PARSER("READ statement"_en_US,
@@ -217,7 +217,7 @@ TYPE_PARSER(first(construct<IoControlSpec>("UNIT =" >> ioUnit),
 // R1211 write-stmt -> WRITE ( io-control-spec-list ) [output-item-list]
 constexpr auto outputItemList{
     extension<LanguageFeature::IOListLeadingComma>(
-        some("," >> outputItem)) ||  // legacy: allow leading comma
+        some("," >> outputItem)) || // legacy: allow leading comma
     optionalList(outputItem)};
 
 TYPE_CONTEXT_PARSER("WRITE statement"_en_US,
@@ -285,7 +285,7 @@ TYPE_PARSER(first(construct<WaitSpec>(maybe("UNIT ="_tok) >> fileUnitNumber),
     construct<WaitSpec>("IOMSG =" >> msgVariable),
     construct<WaitSpec>("IOSTAT =" >> statVariable)))
 
-template<typename A> common::IfNoLvalue<std::list<A>, A> singletonList(A &&x) {
+template <typename A> common::IfNoLvalue<std::list<A>, A> singletonList(A &&x) {
   std::list<A> result;
   result.push_front(std::move(x));
   return result;
@@ -661,4 +661,4 @@ TYPE_PARSER(construct<format::ControlEditDesc>(
                    pure(format::ControlEditDesc::Kind::Dollar)) ||
         "\\" >> construct<format::ControlEditDesc>(
                     pure(format::ControlEditDesc::Kind::Backslash))))
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/message.cpp b/lib/Parser/message.cpp
index 1af00ad401b9..87594d64a8c1 100644
--- a/lib/Parser/message.cpp
+++ b/lib/Parser/message.cpp
@@ -112,14 +112,13 @@ std::string MessageExpectedText::ToString() const {
 }
 
 bool MessageExpectedText::Merge(const MessageExpectedText &that) {
-  return std::visit(
-      common::visitors{
-          [](SetOfChars &s1, const SetOfChars &s2) {
-            s1 = s1.Union(s2);
-            return true;
-          },
-          [](const auto &, const auto &) { return false; },
-      },
+  return std::visit(common::visitors{
+                        [](SetOfChars &s1, const SetOfChars &s2) {
+                          s1 = s1.Union(s2);
+                          return true;
+                        },
+                        [](const auto &, const auto &) { return false; },
+                    },
       u_, that.u_);
 }
 
@@ -335,4 +334,4 @@ bool Messages::AnyFatalError() const {
   }
   return false;
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/misc-parsers.h b/lib/Parser/misc-parsers.h
index ca98e691ad82..b9d6ca541802 100644
--- a/lib/Parser/misc-parsers.h
+++ b/lib/Parser/misc-parsers.h
@@ -21,17 +21,17 @@
 namespace Fortran::parser {
 
 // R401 xzy-list -> xzy [, xzy]...
-template<typename PA> inline constexpr auto nonemptyList(const PA &p) {
-  return nonemptySeparated(p, ","_tok);  // p-list
+template <typename PA> inline constexpr auto nonemptyList(const PA &p) {
+  return nonemptySeparated(p, ","_tok); // p-list
 }
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto nonemptyList(MessageFixedText error, const PA &p) {
-  return withMessage(error, nonemptySeparated(p, ","_tok));  // p-list
+  return withMessage(error, nonemptySeparated(p, ","_tok)); // p-list
 }
 
-template<typename PA> inline constexpr auto optionalList(const PA &p) {
-  return defaulted(nonemptySeparated(p, ","_tok));  // [p-list]
+template <typename PA> inline constexpr auto optionalList(const PA &p) {
+  return defaulted(nonemptySeparated(p, ","_tok)); // [p-list]
 }
 
 // R402 xzy-name -> name
@@ -52,5 +52,5 @@ constexpr auto pointer{construct<Pointer>("POINTER"_tok)};
 constexpr auto protectedAttr{construct<Protected>("PROTECTED"_tok)};
 constexpr auto save{construct<Save>("SAVE"_tok)};
 
-}
+} // namespace Fortran::parser
 #endif
diff --git a/lib/Parser/openmp-parsers.cpp b/lib/Parser/openmp-parsers.cpp
index 407b5125e2b5..2d81f5a8197b 100644
--- a/lib/Parser/openmp-parsers.cpp
+++ b/lib/Parser/openmp-parsers.cpp
@@ -23,7 +23,7 @@ namespace Fortran::parser {
 constexpr auto startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok;
 constexpr auto endOmpLine = space >> endOfLine;
 
-template<typename A> constexpr decltype(auto) verbatim(A x) {
+template <typename A> constexpr decltype(auto) verbatim(A x) {
   return sourced(construct<Verbatim>(x));
 }
 
@@ -524,4 +524,4 @@ TYPE_PARSER(
 
 TYPE_PARSER(construct<OpenMPLoopConstruct>(
     Parser<OmpBeginLoopDirective>{} / endOmpLine))
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/parse-tree.cpp b/lib/Parser/parse-tree.cpp
index 819e4abfc831..650635ec97bc 100644
--- a/lib/Parser/parse-tree.cpp
+++ b/lib/Parser/parse-tree.cpp
@@ -22,13 +22,13 @@ struct GenericExprWrapper {
 struct GenericAssignmentWrapper {
   ~GenericAssignmentWrapper();
 };
-}
+} // namespace Fortran::evaluate
 
 namespace Fortran::parser {
 
 // R867
 ImportStmt::ImportStmt(common::ImportKind &&k, std::list<Name> &&n)
-  : kind{k}, names(std::move(n)) {
+    : kind{k}, names(std::move(n)) {
   CHECK(kind == common::ImportKind::Default ||
       kind == common::ImportKind::Only || names.empty());
 }
@@ -75,9 +75,9 @@ DataRef::DataRef(std::list<PartRef> &&prl) : u{std::move(prl.front().name)} {
 
 // R1001 - R1022 expression
 Expr::Expr(Designator &&x)
-  : u{common::Indirection<Designator>::Make(std::move(x))} {}
+    : u{common::Indirection<Designator>::Make(std::move(x))} {}
 Expr::Expr(FunctionReference &&x)
-  : u{common::Indirection<FunctionReference>::Make(std::move(x))} {}
+    : u{common::Indirection<FunctionReference>::Make(std::move(x))} {}
 
 const std::optional<LoopControl> &DoConstruct::GetLoopControl() const {
   const NonLabelDoStmt &doStmt{
@@ -124,7 +124,7 @@ static Designator MakeArrayElementRef(
 }
 
 // Set source in any type of node that has it.
-template<typename T> T WithSource(CharBlock source, T &&x) {
+template <typename T> T WithSource(CharBlock source, T &&x) {
   x.source = source;
   return std::move(x);
 }
@@ -257,7 +257,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Name &x) {
   return os << x.ToString();
 }
 
-}
+} // namespace Fortran::parser
 
 template class std::unique_ptr<Fortran::evaluate::GenericExprWrapper>;
 template class std::unique_ptr<Fortran::evaluate::GenericAssignmentWrapper>;
diff --git a/lib/Parser/parsing.cpp b/lib/Parser/parsing.cpp
index 1b8256a00a81..5e12b5545f0a 100644
--- a/lib/Parser/parsing.cpp
+++ b/lib/Parser/parsing.cpp
@@ -69,7 +69,7 @@ const SourceFile *Parsing::Prescan(const std::string &path, Options options) {
       .AddCompilerDirectiveSentinel("dir$");
   if (options.features.IsEnabled(LanguageFeature::OpenMP)) {
     prescanner.AddCompilerDirectiveSentinel("$omp");
-    prescanner.AddCompilerDirectiveSentinel("$");  // OMP conditional line
+    prescanner.AddCompilerDirectiveSentinel("$"); // OMP conditional line
   }
   ProvenanceRange range{allSources.AddIncludedFile(
       *sourceFile, ProvenanceRange{}, options.isModuleFile)};
@@ -140,4 +140,4 @@ bool Parsing::ForTesting(std::string path, llvm::raw_ostream &err) {
   }
   return true;
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/preprocessor.cpp b/lib/Parser/preprocessor.cpp
index d2fd07268ee5..3b09597ddeb7 100644
--- a/lib/Parser/preprocessor.cpp
+++ b/lib/Parser/preprocessor.cpp
@@ -26,19 +26,19 @@ namespace Fortran::parser {
 
 Definition::Definition(
     const TokenSequence &repl, std::size_t firstToken, std::size_t tokens)
-  : replacement_{Tokenize({}, repl, firstToken, tokens)} {}
+    : replacement_{Tokenize({}, repl, firstToken, tokens)} {}
 
 Definition::Definition(const std::vector<std::string> &argNames,
     const TokenSequence &repl, std::size_t firstToken, std::size_t tokens,
     bool isVariadic)
-  : isFunctionLike_{true},
-    argumentCount_(argNames.size()), isVariadic_{isVariadic},
-    replacement_{Tokenize(argNames, repl, firstToken, tokens)} {}
+    : isFunctionLike_{true},
+      argumentCount_(argNames.size()), isVariadic_{isVariadic},
+      replacement_{Tokenize(argNames, repl, firstToken, tokens)} {}
 
 Definition::Definition(const std::string &predefined, AllSources &sources)
-  : isPredefined_{true}, replacement_{predefined,
-                             sources.AddCompilerInsertion(predefined).start()} {
-}
+    : isPredefined_{true},
+      replacement_{
+          predefined, sources.AddCompilerInsertion(predefined).start()} {}
 
 bool Definition::set_isDisabled(bool disable) {
   bool was{isDisabled_};
@@ -200,9 +200,9 @@ Preprocessor::Preprocessor(AllSources &allSources) : allSources_{allSources} {
   // of __DATE__ or __TIME__ change during compilation.
   std::time_t now;
   std::time(&now);
-  definitions_.emplace(SaveTokenAsName("__DATE__"s),  // e.g., "Jun 16 1904"
+  definitions_.emplace(SaveTokenAsName("__DATE__"s), // e.g., "Jun 16 1904"
       Definition{FormatTime(now, "\"%h %e %Y\""), allSources});
-  definitions_.emplace(SaveTokenAsName("__TIME__"s),  // e.g., "23:59:60"
+  definitions_.emplace(SaveTokenAsName("__TIME__"s), // e.g., "23:59:60"
       Definition{FormatTime(now, "\"%T\""), allSources});
   // The values of these predefined macros depend on their invocation sites.
   definitions_.emplace(
@@ -230,7 +230,7 @@ std::optional<TokenSequence> Preprocessor::MacroReplacement(
     }
   }
   if (j == tokens) {
-    return std::nullopt;  // input contains nothing that would be replaced
+    return std::nullopt; // input contains nothing that would be replaced
   }
   TokenSequence result{input, 0, j};
   for (; j < tokens; ++j) {
@@ -342,7 +342,7 @@ std::optional<TokenSequence> Preprocessor::MacroReplacement(
           allSources_.AddMacroCall(from, use, replaced.ToString())};
       result.Put(replaced, newRange);
     }
-    j = k;  // advance to the terminal ')'
+    j = k; // advance to the terminal ')'
   }
   return result;
 }
@@ -373,7 +373,7 @@ void Preprocessor::Directive(const TokenSequence &dir, Prescanner *prescanner) {
     return;
   }
   if (IsDecimalDigit(dir.TokenAt(j)[0]) || dir.TokenAt(j)[0] == '"') {
-    return;  // treat like #line, ignore it
+    return; // treat like #line, ignore it
   }
   std::size_t dirOffset{j};
   std::string dirName{ToLowerCaseLetters(dir.TokenAt(dirOffset).ToString())};
@@ -677,8 +677,8 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
   enum Operator {
     PARENS,
     CONST,
-    NOTZERO,  // !
-    COMPLEMENT,  // ~
+    NOTZERO, // !
+    COMPLEMENT, // ~
     UPLUS,
     UMINUS,
     POWER,
@@ -707,13 +707,13 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
     COMMA
   };
   static const int precedence[]{
-      15, 15, 15, 15,  // (), 6, !, ~
-      14, 14,  // unary +, -
-      13, 12, 12, 12, 11, 11, 10, 10,  // **, *, /, %, +, -, <<, >>
-      9, 8, 7,  // &, ^, |
-      6, 6, 6, 6, 6, 6,  // relations .LT. to .GT.
-      5, 4, 3, 2, 2,  // .NOT., .AND., .OR., .EQV., .NEQV.
-      1, 0  // ?: and ,
+      15, 15, 15, 15, // (), 6, !, ~
+      14, 14, // unary +, -
+      13, 12, 12, 12, 11, 11, 10, 10, // **, *, /, %, +, -, <<, >>
+      9, 8, 7, // &, ^, |
+      6, 6, 6, 6, 6, 6, // relations .LT. to .GT.
+      5, 4, 3, 2, 2, // .NOT., .AND., .OR., .EQV., .NEQV.
+      1, 0 // ?: and ,
   };
   static const int operandPrecedence[]{0, -1, 15, 15, 15, 15, 13, 12, 12, 12,
       11, 11, 11, 11, 9, 8, 7, 7, 7, 7, 7, 7, 7, 6, 4, 3, 3, 3, 1, 0};
@@ -821,12 +821,22 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
             token.GetTokenProvenanceRange(*atToken), "expected ')'"_err_en_US};
       }
       return 0;
-    case NOTZERO: left = !left; break;
-    case COMPLEMENT: left = ~left; break;
-    case UPLUS: break;
-    case UMINUS: left = -left; break;
-    case NOT: left = -!left; break;
-    default: CRASH_NO_CASE;
+    case NOTZERO:
+      left = !left;
+      break;
+    case COMPLEMENT:
+      left = ~left;
+      break;
+    case UPLUS:
+      break;
+    case UMINUS:
+      left = -left;
+      break;
+    case NOT:
+      left = -!left;
+      break;
+    default:
+      CRASH_NO_CASE;
     }
   }
 
@@ -934,18 +944,40 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
       left = right >= 64 ? 0 : left >> right;
       break;
     case BITAND:
-    case AND: left = left & right; break;
-    case BITXOR: left = left ^ right; break;
+    case AND:
+      left = left & right;
+      break;
+    case BITXOR:
+      left = left ^ right;
+      break;
     case BITOR:
-    case OR: left = left | right; break;
-    case LT: left = -(left < right); break;
-    case LE: left = -(left <= right); break;
-    case EQ: left = -(left == right); break;
-    case NE: left = -(left != right); break;
-    case GE: left = -(left >= right); break;
-    case GT: left = -(left > right); break;
-    case EQV: left = -(!left == !right); break;
-    case NEQV: left = -(!left != !right); break;
+    case OR:
+      left = left | right;
+      break;
+    case LT:
+      left = -(left < right);
+      break;
+    case LE:
+      left = -(left <= right);
+      break;
+    case EQ:
+      left = -(left == right);
+      break;
+    case NE:
+      left = -(left != right);
+      break;
+    case GE:
+      left = -(left >= right);
+      break;
+    case GT:
+      left = -(left > right);
+      break;
+    case EQV:
+      left = -(!left == !right);
+      break;
+    case NEQV:
+      left = -(!left != !right);
+      break;
     case SELECT:
       if (*atToken >= tokens || token.TokenAt(*atToken).ToString() != ":") {
         *error = Message{token.GetTokenProvenanceRange(opAt),
@@ -958,8 +990,11 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
         left = left != 0 ? right : third;
       }
       break;
-    case COMMA: left = right; break;
-    default: CRASH_NO_CASE;
+    case COMMA:
+      left = right;
+      break;
+    default:
+      CRASH_NO_CASE;
     }
   }
   return left;
@@ -1014,4 +1049,4 @@ bool Preprocessor::IsIfPredicateTrue(const TokenSequence &expr,
   }
   return result;
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/preprocessor.h b/lib/Parser/preprocessor.h
index 9b1b019b8c29..977d480c2482 100644
--- a/lib/Parser/preprocessor.h
+++ b/lib/Parser/preprocessor.h
@@ -91,5 +91,5 @@ class Preprocessor {
   std::unordered_map<CharBlock, Definition> definitions_;
   std::stack<CanDeadElseAppear> ifStack_;
 };
-}
-#endif  // FORTRAN_PARSER_PREPROCESSOR_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PREPROCESSOR_H_
diff --git a/lib/Parser/prescan.cpp b/lib/Parser/prescan.cpp
index 1648a0297603..90b71925b389 100644
--- a/lib/Parser/prescan.cpp
+++ b/lib/Parser/prescan.cpp
@@ -27,18 +27,19 @@ static constexpr int maxPrescannerNesting{100};
 
 Prescanner::Prescanner(Messages &messages, CookedSource &cooked,
     Preprocessor &preprocessor, common::LanguageFeatureControl lfc)
-  : messages_{messages}, cooked_{cooked}, preprocessor_{preprocessor},
-    features_{lfc}, encoding_{cooked.allSources().encoding()} {}
+    : messages_{messages}, cooked_{cooked}, preprocessor_{preprocessor},
+      features_{lfc}, encoding_{cooked.allSources().encoding()} {}
 
 Prescanner::Prescanner(const Prescanner &that)
-  : messages_{that.messages_}, cooked_{that.cooked_},
-    preprocessor_{that.preprocessor_}, features_{that.features_},
-    inFixedForm_{that.inFixedForm_},
-    fixedFormColumnLimit_{that.fixedFormColumnLimit_},
-    encoding_{that.encoding_}, prescannerNesting_{that.prescannerNesting_ + 1},
-    skipLeadingAmpersand_{that.skipLeadingAmpersand_},
-    compilerDirectiveBloomFilter_{that.compilerDirectiveBloomFilter_},
-    compilerDirectiveSentinels_{that.compilerDirectiveSentinels_} {}
+    : messages_{that.messages_}, cooked_{that.cooked_},
+      preprocessor_{that.preprocessor_}, features_{that.features_},
+      inFixedForm_{that.inFixedForm_},
+      fixedFormColumnLimit_{that.fixedFormColumnLimit_},
+      encoding_{that.encoding_}, prescannerNesting_{that.prescannerNesting_ +
+                                     1},
+      skipLeadingAmpersand_{that.skipLeadingAmpersand_},
+      compilerDirectiveBloomFilter_{that.compilerDirectiveBloomFilter_},
+      compilerDirectiveSentinels_{that.compilerDirectiveSentinels_} {}
 
 static inline constexpr bool IsFixedFormCommentChar(char ch) {
   return ch == '!' || ch == '*' || ch == 'C' || ch == 'c';
@@ -93,7 +94,7 @@ void Prescanner::Statement() {
   LineClassification line{ClassifyLine(nextLine_)};
   switch (line.kind) {
   case LineClassification::Kind::Comment:
-    nextLine_ += line.payloadOffset;  // advance to '!' or newline
+    nextLine_ += line.payloadOffset; // advance to '!' or newline
     NextLine();
     return;
   case LineClassification::Kind::IncludeLine:
@@ -170,9 +171,10 @@ void Prescanner::Statement() {
     preprocessed->CloseToken();
     const char *ppd{preprocessed->ToCharBlock().begin()};
     LineClassification ppl{ClassifyLine(ppd)};
-    preprocessed->RemoveLastToken();  // remove the newline
+    preprocessed->RemoveLastToken(); // remove the newline
     switch (ppl.kind) {
-    case LineClassification::Kind::Comment: break;
+    case LineClassification::Kind::Comment:
+      break;
     case LineClassification::Kind::IncludeLine:
       FortranInclude(ppd + ppl.payloadOffset);
       break;
@@ -251,7 +253,7 @@ void Prescanner::LabelField(TokenSequence &token, int outCol) {
       break;
     }
     if (*at_ != ' ' &&
-        !(*at_ == '0' && column_ == 6)) {  // '0' in column 6 becomes space
+        !(*at_ == '0' && column_ == 6)) { // '0' in column 6 becomes space
       EmitChar(token, *at_);
       ++outCol;
     }
@@ -280,9 +282,9 @@ void Prescanner::SkipToEndOfLine() {
 
 bool Prescanner::MustSkipToEndOfLine() const {
   if (inFixedForm_ && column_ > fixedFormColumnLimit_ && !tabInCurrentLine_) {
-    return true;  // skip over ignored columns in right margin (73:80)
+    return true; // skip over ignored columns in right margin (73:80)
   } else if (*at_ == '!' && !inCharLiteral_) {
-    return true;  // inline comment goes to end of source line
+    return true; // inline comment goes to end of source line
   } else {
     return false;
   }
@@ -376,7 +378,7 @@ const char *Prescanner::SkipCComment(const char *p) const {
   p += 2;
   while (star != '*' || slash != '/') {
     if (p >= limit_) {
-      return nullptr;  // signifies an unterminated comment
+      return nullptr; // signifies an unterminated comment
     }
     star = slash;
     slash = *p++;
@@ -476,7 +478,7 @@ bool Prescanner::NextToken(TokenSequence &tokens) {
       }
       ExponentAndKind(tokens);
     } else if (nch == '.' && EmitCharAndAdvance(tokens, '.') == '.') {
-      EmitCharAndAdvance(tokens, '.');  // variadic macro definition ellipsis
+      EmitCharAndAdvance(tokens, '.'); // variadic macro definition ellipsis
     }
     preventHollerith_ = false;
   } else if (IsLegalInIdentifier(*at_)) {
@@ -582,7 +584,7 @@ void Prescanner::QuotedCharacterLiteral(
       // quote character in the literal (later).  There can be spaces between
       // the quotes in fixed form source.
       EmitChar(tokens, quote);
-      inCharLiteral_ = false;  // for cases like print *, '...'!comment
+      inCharLiteral_ = false; // for cases like print *, '...'!comment
       NextChar();
       if (InFixedFormSource()) {
         SkipSpaces();
@@ -649,7 +651,7 @@ bool Prescanner::PadOutCharacterLiteral(TokenSequence &tokens) {
       return false;
     }
     CHECK(column_ == 7);
-    --at_;  // point to column 6 of continuation line
+    --at_; // point to column 6 of continuation line
     column_ = 6;
   }
   return false;
@@ -657,7 +659,7 @@ bool Prescanner::PadOutCharacterLiteral(TokenSequence &tokens) {
 
 bool Prescanner::IsFixedFormCommentLine(const char *start) const {
   const char *p{start};
-  if (IsFixedFormCommentChar(*p) || *p == '%' ||  // VAX %list, %eject, &c.
+  if (IsFixedFormCommentChar(*p) || *p == '%' || // VAX %list, %eject, &c.
       ((*p == 'D' || *p == 'd') &&
           !features_.IsEnabled(LanguageFeature::OldDebugLines))) {
     return true;
@@ -670,7 +672,7 @@ bool Prescanner::IsFixedFormCommentLine(const char *start) const {
       anyTabs = true;
       ++p;
     } else if (*p == '0' && !anyTabs && p == start + 5) {
-      ++p;  // 0 in column 6 must treated as a space
+      ++p; // 0 in column 6 must treated as a space
     } else {
       break;
     }
@@ -867,7 +869,7 @@ const char *Prescanner::FixedFormContinuationLine(bool mightNeedSpace) {
     }
     if (col1 == '\t' && nextLine_[1] >= '1' && nextLine_[1] <= '9') {
       tabInCurrentLine_ = true;
-      return nextLine_ + 2;  // VAX extension
+      return nextLine_ + 2; // VAX extension
     }
     if (col1 == ' ' && nextLine_[1] == ' ' && nextLine_[2] == ' ' &&
         nextLine_[3] == ' ' && nextLine_[4] == ' ') {
@@ -882,7 +884,7 @@ const char *Prescanner::FixedFormContinuationLine(bool mightNeedSpace) {
       }
     }
   }
-  return nullptr;  // not a continuation line
+  return nullptr; // not a continuation line
 }
 
 const char *Prescanner::FreeFormContinuationLine(bool ampersand) {
@@ -1127,4 +1129,4 @@ void Prescanner::SourceFormChange(std::string &&dir) {
     inFixedForm_ = true;
   }
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/prescan.h b/lib/Parser/prescan.h
index 94098048f23e..f2840c3bf771 100644
--- a/lib/Parser/prescan.h
+++ b/lib/Parser/prescan.h
@@ -64,7 +64,7 @@ class Prescanner {
   TokenSequence TokenizePreprocessorDirective();
   Provenance GetCurrentProvenance() const { return GetProvenance(at_); }
 
-  template<typename... A> Message &Say(A &&... a) {
+  template <typename... A> Message &Say(A &&... a) {
     Message &m{messages_.Say(std::forward<A>(a)...)};
     std::optional<ProvenanceRange> range{m.GetProvenanceRange(cooked_)};
     CHECK(!range || cooked_.IsValid(*range));
@@ -76,19 +76,19 @@ class Prescanner {
     enum class Kind {
       Comment,
       ConditionalCompilationDirective,
-      IncludeDirective,  // #include
-      DefinitionDirective,  // #define & #undef
+      IncludeDirective, // #include
+      DefinitionDirective, // #define & #undef
       PreprocessorDirective,
-      IncludeLine,  // Fortran INCLUDE
+      IncludeLine, // Fortran INCLUDE
       CompilerDirective,
       Source
     };
     LineClassification(Kind k, std::size_t po = 0, const char *s = nullptr)
-      : kind{k}, payloadOffset{po}, sentinel{s} {}
+        : kind{k}, payloadOffset{po}, sentinel{s} {}
     LineClassification(LineClassification &&) = default;
     Kind kind;
-    std::size_t payloadOffset;  // byte offset of content
-    const char *sentinel;  // if it's a compiler directive
+    std::size_t payloadOffset; // byte offset of content
+    const char *sentinel; // if it's a compiler directive
   };
 
   void BeginSourceLine(const char *at) {
@@ -187,15 +187,15 @@ class Prescanner {
   int prescannerNesting_{0};
 
   Provenance startProvenance_;
-  const char *start_{nullptr};  // beginning of current source file content
-  const char *limit_{nullptr};  // first address after end of current source
-  const char *nextLine_{nullptr};  // next line to process; <= limit_
-  const char *directiveSentinel_{nullptr};  // current compiler directive
+  const char *start_{nullptr}; // beginning of current source file content
+  const char *limit_{nullptr}; // first address after end of current source
+  const char *nextLine_{nullptr}; // next line to process; <= limit_
+  const char *directiveSentinel_{nullptr}; // current compiler directive
 
   // This data members are state for processing the source line containing
   // "at_", which goes to up to the newline character before "nextLine_".
-  const char *at_{nullptr};  // next character to process; < nextLine_
-  int column_{1};  // card image column position of next character
+  const char *at_{nullptr}; // next character to process; < nextLine_
+  int column_{1}; // card image column position of next character
   bool tabInCurrentLine_{false};
   bool slashInCurrentLine_{false};
   bool preventHollerith_{false};
@@ -225,8 +225,8 @@ class Prescanner {
   // To avoid probing the set of active compiler directive sentinel strings
   // on every comment line, they're checked first with a cheap Bloom filter.
   static const int prime1{1019}, prime2{1021};
-  std::bitset<prime2> compilerDirectiveBloomFilter_;  // 128 bytes
+  std::bitset<prime2> compilerDirectiveBloomFilter_; // 128 bytes
   std::unordered_set<std::string> compilerDirectiveSentinels_;
 };
-}
-#endif  // FORTRAN_PARSER_PRESCAN_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PRESCAN_H_
diff --git a/lib/Parser/program-parsers.cpp b/lib/Parser/program-parsers.cpp
index 36a9d39d4512..e394e25631d3 100644
--- a/lib/Parser/program-parsers.cpp
+++ b/lib/Parser/program-parsers.cpp
@@ -263,7 +263,7 @@ TYPE_PARSER(construct<Rename>("OPERATOR (" >>
 // R1413 only-use-name -> use-name
 TYPE_PARSER(construct<Only>(Parser<Rename>{}) ||
     construct<Only>(indirect(genericSpec)) ||
-    construct<Only>(name))  // TODO: ambiguous, accepted by genericSpec
+    construct<Only>(name)) // TODO: ambiguous, accepted by genericSpec
 
 // R1416 submodule ->
 //         submodule-stmt [specification-part] [module-subprogram-part]
@@ -477,7 +477,7 @@ TYPE_CONTEXT_PARSER("FUNCTION statement"_en_US,
     construct<FunctionStmt>(many(prefixSpec), "FUNCTION" >> name,
         parenthesized(optionalList(name)), maybe(suffix)) ||
         extension<LanguageFeature::OmitFunctionDummies>(
-            construct<FunctionStmt>(  // PGI & Intel accept "FUNCTION F"
+            construct<FunctionStmt>( // PGI & Intel accept "FUNCTION F"
                 many(prefixSpec), "FUNCTION" >> name,
                 construct<std::list<Name>>(),
                 construct<std::optional<Suffix>>())))
@@ -556,4 +556,4 @@ TYPE_PARSER(construct<ContainsStmt>("CONTAINS"_tok))
 TYPE_CONTEXT_PARSER("statement function definition"_en_US,
     construct<StmtFunctionStmt>(
         name, parenthesized(optionalList(name)), "=" >> scalar(expr)))
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/provenance.cpp b/lib/Parser/provenance.cpp
index 1a2a77cd1daf..73e0f7154b6b 100644
--- a/lib/Parser/provenance.cpp
+++ b/lib/Parser/provenance.cpp
@@ -281,24 +281,23 @@ void AllSources::EmitMessage(llvm::raw_ostream &o,
 const SourceFile *AllSources::GetSourceFile(
     Provenance at, std::size_t *offset) const {
   const Origin &origin{MapToOrigin(at)};
-  return std::visit(
-      common::visitors{
-          [&](const Inclusion &inc) {
-            if (offset) {
-              *offset = origin.covers.MemberOffset(at);
-            }
-            return &inc.source;
-          },
-          [&](const Macro &) {
-            return GetSourceFile(origin.replaces.start(), offset);
-          },
-          [offset](const CompilerInsertion &) {
-            if (offset) {
-              *offset = 0;
-            }
-            return static_cast<const SourceFile *>(nullptr);
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](const Inclusion &inc) {
+                          if (offset) {
+                            *offset = origin.covers.MemberOffset(at);
+                          }
+                          return &inc.source;
+                        },
+                        [&](const Macro &) {
+                          return GetSourceFile(origin.replaces.start(), offset);
+                        },
+                        [offset](const CompilerInsertion &) {
+                          if (offset) {
+                            *offset = 0;
+                          }
+                          return static_cast<const SourceFile *>(nullptr);
+                        },
+                    },
       origin.u);
 }
 
@@ -361,15 +360,15 @@ ProvenanceRange AllSources::IntersectionWithSourceFiles(
 }
 
 AllSources::Origin::Origin(ProvenanceRange r, const SourceFile &source)
-  : u{Inclusion{source}}, covers{r} {}
+    : u{Inclusion{source}}, covers{r} {}
 AllSources::Origin::Origin(ProvenanceRange r, const SourceFile &included,
     ProvenanceRange from, bool isModule)
-  : u{Inclusion{included, isModule}}, covers{r}, replaces{from} {}
+    : u{Inclusion{included, isModule}}, covers{r}, replaces{from} {}
 AllSources::Origin::Origin(ProvenanceRange r, ProvenanceRange def,
     ProvenanceRange use, const std::string &expansion)
-  : u{Macro{def, expansion}}, covers{r}, replaces{use} {}
+    : u{Macro{def, expansion}}, covers{r}, replaces{use} {}
 AllSources::Origin::Origin(ProvenanceRange r, const std::string &text)
-  : u{CompilerInsertion{text}}, covers{r} {}
+    : u{CompilerInsertion{text}}, covers{r} {}
 
 const char &AllSources::Origin::operator[](std::size_t n) const {
   return std::visit(
@@ -507,24 +506,23 @@ llvm::raw_ostream &AllSources::Dump(llvm::raw_ostream &o) const {
     o << "   ";
     DumpRange(o, m.covers);
     o << " -> ";
-    std::visit(
-        common::visitors{
-            [&](const Inclusion &inc) {
-              if (inc.isModule) {
-                o << "module ";
-              }
-              o << "file " << inc.source.path();
-            },
-            [&](const Macro &mac) { o << "macro " << mac.expansion; },
-            [&](const CompilerInsertion &ins) {
-              o << "compiler '" << ins.text << '\'';
-              if (ins.text.length() == 1) {
-                int ch = ins.text[0];
-                o << "(0x";
-                o.write_hex(ch & 0xff) << ")";
-              }
-            },
-        },
+    std::visit(common::visitors{
+                   [&](const Inclusion &inc) {
+                     if (inc.isModule) {
+                       o << "module ";
+                     }
+                     o << "file " << inc.source.path();
+                   },
+                   [&](const Macro &mac) { o << "macro " << mac.expansion; },
+                   [&](const CompilerInsertion &ins) {
+                     o << "compiler '" << ins.text << '\'';
+                     if (ins.text.length() == 1) {
+                       int ch = ins.text[0];
+                       o << "(0x";
+                       o.write_hex(ch & 0xff) << ")";
+                     }
+                   },
+               },
         m.u);
     if (IsValid(m.replaces)) {
       o << " replaces ";
@@ -544,4 +542,4 @@ llvm::raw_ostream &CookedSource::Dump(llvm::raw_ostream &o) const {
   invertedMap_.Dump(o);
   return o;
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/source.cpp b/lib/Parser/source.cpp
index 6b1a9df3b731..376786e3923e 100644
--- a/lib/Parser/source.cpp
+++ b/lib/Parser/source.cpp
@@ -150,4 +150,4 @@ SourcePosition SourceFile::FindOffsetLineAndColumn(std::size_t at) const {
   return {*this, static_cast<int>(low + 1),
       static_cast<int>(at - lineStart_[low] + 1)};
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/stmt-parser.h b/lib/Parser/stmt-parser.h
index ee26e50db119..058a3b6cc215 100644
--- a/lib/Parser/stmt-parser.h
+++ b/lib/Parser/stmt-parser.h
@@ -23,7 +23,8 @@ namespace Fortran::parser {
 // R611 label -> digit [digit]...
 constexpr auto label{space >> digitString64 / spaceCheck};
 
-template<typename PA> inline constexpr auto unterminatedStatement(const PA &p) {
+template <typename PA>
+inline constexpr auto unterminatedStatement(const PA &p) {
   return skipStuffBeforeStatement >>
       sourced(construct<Statement<typename PA::resultType>>(
           maybe(label), space >> p));
@@ -38,13 +39,13 @@ constexpr auto endOfStmt{
                  semicolons || endOfLine)};
 constexpr auto forceEndOfStmt{recovery(endOfStmt, SkipPast<'\n'>{})};
 
-template<typename PA> inline constexpr auto statement(const PA &p) {
+template <typename PA> inline constexpr auto statement(const PA &p) {
   return unterminatedStatement(p) / endOfStmt;
 }
 
 // unlabeledStatement() is basically statement() for those few situations
 // in Fortran where a statement cannot have a label.
-template<typename PA> inline constexpr auto unlabeledStatement(const PA &p) {
+template <typename PA> inline constexpr auto unlabeledStatement(const PA &p) {
   return space >>
       sourced(construct<UnlabeledStatement<typename PA::resultType>>(p));
 }
@@ -55,7 +56,7 @@ template<typename PA> inline constexpr auto unlabeledStatement(const PA &p) {
 // question could also be a legal prefix of some other statement that might
 // be valid at that point.  It only makes sense to use this within "some()"
 // or "many()" so as to not end the list of statements.
-template<typename PA> inline constexpr auto unambiguousStatement(const PA &p) {
+template <typename PA> inline constexpr auto unambiguousStatement(const PA &p) {
   return unterminatedStatement(p) / forceEndOfStmt;
 }
 
@@ -95,5 +96,5 @@ constexpr auto progUnitEndStmtErrorRecovery{
     (many(!"END"_tok >> SkipPast<'\n'>{}) >>
         ("END"_tok >> SkipTo<'\n'>{} || consumedAllInput)) >>
     missingOptionalName};
-}
-#endif  // FORTRAN_PARSER_STMT_PARSER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_STMT_PARSER_H_
diff --git a/lib/Parser/token-parsers.h b/lib/Parser/token-parsers.h
index c34b9785b3fd..fdb0a3a09899 100644
--- a/lib/Parser/token-parsers.h
+++ b/lib/Parser/token-parsers.h
@@ -114,24 +114,24 @@ constexpr struct SpaceCheck {
 // when a string literal appears before the sequencing operator >> or
 // after the sequencing operator /.  The literal "..."_id parses a
 // token that cannot be a prefix of a longer identifier.
-template<bool MandatoryFreeFormSpace = false, bool MustBeComplete = false>
+template <bool MandatoryFreeFormSpace = false, bool MustBeComplete = false>
 class TokenStringMatch {
 public:
   using resultType = Success;
   constexpr TokenStringMatch(const TokenStringMatch &) = default;
   constexpr TokenStringMatch(const char *str, std::size_t n)
-    : str_{str}, bytes_{n} {}
+      : str_{str}, bytes_{n} {}
   explicit constexpr TokenStringMatch(const char *str) : str_{str} {}
   std::optional<Success> Parse(ParseState &state) const {
     space.Parse(state);
     const char *start{state.GetLocation()};
     const char *p{str_};
-    std::optional<const char *> at;  // initially empty
+    std::optional<const char *> at; // initially empty
     for (std::size_t j{0}; j < bytes_ && *p != '\0'; ++j, ++p) {
       bool spaceSkipping{*p == ' '};
       if (spaceSkipping) {
         if (j + 1 == bytes_ || p[1] == ' ' || p[1] == '\0') {
-          continue;  // redundant; ignore
+          continue; // redundant; ignore
         }
       }
       if (!at) {
@@ -192,25 +192,25 @@ constexpr TokenStringMatch<false, true> operator""_id(
   return {str, n};
 }
 
-template<class PA>
+template <class PA>
 inline constexpr std::enable_if_t<std::is_class_v<PA>,
     SequenceParser<TokenStringMatch<>, PA>>
 operator>>(const char *str, const PA &p) {
   return SequenceParser<TokenStringMatch<>, PA>{TokenStringMatch<>{str}, p};
 }
 
-template<class PA>
+template <class PA>
 inline constexpr std::enable_if_t<std::is_class_v<PA>,
     FollowParser<PA, TokenStringMatch<>>>
 operator/(const PA &p, const char *str) {
   return FollowParser<PA, TokenStringMatch<>>{p, TokenStringMatch<>{str}};
 }
 
-template<class PA> inline constexpr auto parenthesized(const PA &p) {
+template <class PA> inline constexpr auto parenthesized(const PA &p) {
   return "(" >> p / ")";
 }
 
-template<class PA> inline constexpr auto bracketed(const PA &p) {
+template <class PA> inline constexpr auto bracketed(const PA &p) {
   return "[" >> p / "]";
 }
 
@@ -243,7 +243,7 @@ struct CharLiteralChar {
   }
 };
 
-template<char quote> struct CharLiteral {
+template <char quote> struct CharLiteral {
   using resultType = std::string;
   static std::optional<std::string> Parse(ParseState &state) {
     std::string str;
@@ -274,9 +274,14 @@ struct BOZLiteral {
       switch (ch) {
       case 'b':
       case 'o':
-      case 'z': base = ch; return true;
-      case 'x': base = 'z'; return true;
-      default: return false;
+      case 'z':
+        base = ch;
+        return true;
+      case 'x':
+        base = 'z';
+        return true;
+      default:
+        return false;
       }
     }};
 
@@ -543,7 +548,7 @@ constexpr struct ConsumedAllInputParser {
   }
 } consumedAllInput;
 
-template<char goal> struct SkipPast {
+template <char goal> struct SkipPast {
   using resultType = Success;
   constexpr SkipPast() {}
   constexpr SkipPast(const SkipPast &) {}
@@ -557,7 +562,7 @@ template<char goal> struct SkipPast {
   }
 };
 
-template<char goal> struct SkipTo {
+template <char goal> struct SkipTo {
   using resultType = Success;
   constexpr SkipTo() {}
   constexpr SkipTo(const SkipTo &) {}
@@ -578,11 +583,11 @@ template<char goal> struct SkipTo {
 // not appear, and the doubled colons are optional.
 //   [[, xyz] ::]     is  optionalBeforeColons(xyz)
 //   [[, xyz]... ::]  is  optionalBeforeColons(nonemptyList(xyz))
-template<typename PA> inline constexpr auto optionalBeforeColons(const PA &p) {
+template <typename PA> inline constexpr auto optionalBeforeColons(const PA &p) {
   return "," >> construct<std::optional<typename PA::resultType>>(p) / "::" ||
       ("::"_tok || !","_tok) >> defaulted(cut >> maybe(p));
 }
-template<typename PA>
+template <typename PA>
 inline constexpr auto optionalListBeforeColons(const PA &p) {
   return "," >> nonemptyList(p) / "::" ||
       ("::"_tok || !","_tok) >> defaulted(cut >> nonemptyList(p));
@@ -657,5 +662,5 @@ constexpr auto logicalFALSE{
 constexpr auto rawHollerithLiteral{
     deprecated<LanguageFeature::Hollerith>(HollerithLiteral{})};
 
-}
-#endif  // FORTRAN_PARSER_TOKEN_PARSERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TOKEN_PARSERS_H_
diff --git a/lib/Parser/token-sequence.cpp b/lib/Parser/token-sequence.cpp
index 235a4a4d303f..ce94f2623501 100644
--- a/lib/Parser/token-sequence.cpp
+++ b/lib/Parser/token-sequence.cpp
@@ -53,7 +53,7 @@ std::size_t TokenSequence::SkipBlanks(std::size_t at) const {
       return at;
     }
   }
-  return tokens;  // even if at > tokens
+  return tokens; // even if at > tokens
 }
 
 void TokenSequence::RemoveLastToken() {
@@ -285,4 +285,4 @@ ProvenanceRange TokenSequence::GetIntervalProvenanceRange(
 ProvenanceRange TokenSequence::GetProvenanceRange() const {
   return GetIntervalProvenanceRange(0, start_.size());
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/token-sequence.h b/lib/Parser/token-sequence.h
index b70134bd4b20..d73b3c20be6f 100644
--- a/lib/Parser/token-sequence.h
+++ b/lib/Parser/token-sequence.h
@@ -38,9 +38,9 @@ class TokenSequence {
     Put(that, at, count);
   }
   TokenSequence(TokenSequence &&that)
-    : start_{std::move(that.start_)}, nextStart_{that.nextStart_},
-      char_{std::move(that.char_)}, provenances_{std::move(that.provenances_)} {
-  }
+      : start_{std::move(that.start_)}, nextStart_{that.nextStart_},
+        char_{std::move(that.char_)}, provenances_{
+                                          std::move(that.provenances_)} {}
   TokenSequence(const std::string &s, Provenance p) { Put(s, p); }
 
   TokenSequence &operator=(const TokenSequence &that) {
@@ -125,5 +125,5 @@ class TokenSequence {
   std::vector<char> char_;
   OffsetToProvenanceMappings provenances_;
 };
-}
-#endif  // FORTRAN_PARSER_TOKEN_SEQUENCE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TOKEN_SEQUENCE_H_
diff --git a/lib/Parser/tools.cpp b/lib/Parser/tools.cpp
index 7fb73791b32a..98aa6897c6cd 100644
--- a/lib/Parser/tools.cpp
+++ b/lib/Parser/tools.cpp
@@ -91,4 +91,4 @@ const CoindexedNamedObject *GetCoindexedNamedObject(
       },
       allocateObject.u);
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/type-parser-implementation.h b/lib/Parser/type-parser-implementation.h
index 1bea618f81b0..266b78dc2f1e 100644
--- a/lib/Parser/type-parser-implementation.h
+++ b/lib/Parser/type-parser-implementation.h
@@ -21,7 +21,7 @@
 // causes it to crash on "decltype(pexpr)" when pexpr's top-level
 // operator is an overridden || of parsing alternatives.
 #define TYPE_PARSER(pexpr) \
-  template<> \
+  template <> \
   auto Parser<typename decltype(attempt(pexpr))::resultType>::Parse( \
       ParseState &state) \
       ->std::optional<resultType> { \
diff --git a/lib/Parser/type-parsers.h b/lib/Parser/type-parsers.h
index 40e36a8c5a0c..c7a1bce781ff 100644
--- a/lib/Parser/type-parsers.h
+++ b/lib/Parser/type-parsers.h
@@ -20,7 +20,7 @@ namespace Fortran::parser {
 // This usage requires that their Parse() member functions be defined
 // separately, typically with a parsing expression wrapped up in an
 // TYPE_PARSER() macro call.
-template<typename A> struct Parser {
+template <typename A> struct Parser {
   using resultType = A;
   constexpr Parser() {}
   constexpr Parser(const Parser &) = default;
@@ -39,99 +39,99 @@ template<typename A> struct Parser {
 // of some special importance, so we instantiate them once here and
 // give them names rather than referencing them as anonymous Parser<T>{}
 // objects in the right-hand sides of productions.
-constexpr Parser<Program> program;  //  R501 - the "top level" production
-constexpr Parser<SpecificationPart> specificationPart;  //  R504
-constexpr Parser<ImplicitPart> implicitPart;  //  R505
-constexpr Parser<DeclarationConstruct> declarationConstruct;  //  R507
-constexpr Parser<SpecificationConstruct> specificationConstruct;  //  R508
-constexpr Parser<ExecutionPart> executionPart;  //  R509
-constexpr Parser<ExecutionPartConstruct> executionPartConstruct;  //  R510
-constexpr Parser<InternalSubprogramPart> internalSubprogramPart;  //  R511
-constexpr Parser<ActionStmt> actionStmt;  // R515
-constexpr Parser<Name> name;  // R603
-constexpr Parser<LiteralConstant> literalConstant;  // R605
-constexpr Parser<NamedConstant> namedConstant;  // R606
-constexpr Parser<TypeParamValue> typeParamValue;  // R701
-constexpr Parser<TypeSpec> typeSpec;  // R702
-constexpr Parser<DeclarationTypeSpec> declarationTypeSpec;  // R703
-constexpr Parser<IntrinsicTypeSpec> intrinsicTypeSpec;  // R704
-constexpr Parser<IntegerTypeSpec> integerTypeSpec;  // R705
-constexpr Parser<KindSelector> kindSelector;  // R706
-constexpr Parser<SignedIntLiteralConstant> signedIntLiteralConstant;  // R707
-constexpr Parser<IntLiteralConstant> intLiteralConstant;  // R708
-constexpr Parser<KindParam> kindParam;  // R709
-constexpr Parser<RealLiteralConstant> realLiteralConstant;  // R714
-constexpr Parser<CharLength> charLength;  // R723
-constexpr Parser<CharLiteralConstant> charLiteralConstant;  // R724
-constexpr Parser<Initialization> initialization;  // R743 & R805
-constexpr Parser<DerivedTypeSpec> derivedTypeSpec;  // R754
-constexpr Parser<TypeDeclarationStmt> typeDeclarationStmt;  // R801
-constexpr Parser<NullInit> nullInit;  // R806
-constexpr Parser<AccessSpec> accessSpec;  // R807
-constexpr Parser<LanguageBindingSpec> languageBindingSpec;  // R808, R1528
-constexpr Parser<EntityDecl> entityDecl;  // R803
-constexpr Parser<CoarraySpec> coarraySpec;  // R809
-constexpr Parser<ArraySpec> arraySpec;  // R815
-constexpr Parser<ExplicitShapeSpec> explicitShapeSpec;  // R816
-constexpr Parser<DeferredShapeSpecList> deferredShapeSpecList;  // R820
-constexpr Parser<AssumedImpliedSpec> assumedImpliedSpec;  // R821
-constexpr Parser<IntentSpec> intentSpec;  // R826
-constexpr Parser<DataStmt> dataStmt;  // R837
-constexpr Parser<DataImpliedDo> dataImpliedDo;  // R840
-constexpr Parser<ParameterStmt> parameterStmt;  // R851
+constexpr Parser<Program> program; //  R501 - the "top level" production
+constexpr Parser<SpecificationPart> specificationPart; //  R504
+constexpr Parser<ImplicitPart> implicitPart; //  R505
+constexpr Parser<DeclarationConstruct> declarationConstruct; //  R507
+constexpr Parser<SpecificationConstruct> specificationConstruct; //  R508
+constexpr Parser<ExecutionPart> executionPart; //  R509
+constexpr Parser<ExecutionPartConstruct> executionPartConstruct; //  R510
+constexpr Parser<InternalSubprogramPart> internalSubprogramPart; //  R511
+constexpr Parser<ActionStmt> actionStmt; // R515
+constexpr Parser<Name> name; // R603
+constexpr Parser<LiteralConstant> literalConstant; // R605
+constexpr Parser<NamedConstant> namedConstant; // R606
+constexpr Parser<TypeParamValue> typeParamValue; // R701
+constexpr Parser<TypeSpec> typeSpec; // R702
+constexpr Parser<DeclarationTypeSpec> declarationTypeSpec; // R703
+constexpr Parser<IntrinsicTypeSpec> intrinsicTypeSpec; // R704
+constexpr Parser<IntegerTypeSpec> integerTypeSpec; // R705
+constexpr Parser<KindSelector> kindSelector; // R706
+constexpr Parser<SignedIntLiteralConstant> signedIntLiteralConstant; // R707
+constexpr Parser<IntLiteralConstant> intLiteralConstant; // R708
+constexpr Parser<KindParam> kindParam; // R709
+constexpr Parser<RealLiteralConstant> realLiteralConstant; // R714
+constexpr Parser<CharLength> charLength; // R723
+constexpr Parser<CharLiteralConstant> charLiteralConstant; // R724
+constexpr Parser<Initialization> initialization; // R743 & R805
+constexpr Parser<DerivedTypeSpec> derivedTypeSpec; // R754
+constexpr Parser<TypeDeclarationStmt> typeDeclarationStmt; // R801
+constexpr Parser<NullInit> nullInit; // R806
+constexpr Parser<AccessSpec> accessSpec; // R807
+constexpr Parser<LanguageBindingSpec> languageBindingSpec; // R808, R1528
+constexpr Parser<EntityDecl> entityDecl; // R803
+constexpr Parser<CoarraySpec> coarraySpec; // R809
+constexpr Parser<ArraySpec> arraySpec; // R815
+constexpr Parser<ExplicitShapeSpec> explicitShapeSpec; // R816
+constexpr Parser<DeferredShapeSpecList> deferredShapeSpecList; // R820
+constexpr Parser<AssumedImpliedSpec> assumedImpliedSpec; // R821
+constexpr Parser<IntentSpec> intentSpec; // R826
+constexpr Parser<DataStmt> dataStmt; // R837
+constexpr Parser<DataImpliedDo> dataImpliedDo; // R840
+constexpr Parser<ParameterStmt> parameterStmt; // R851
 constexpr Parser<OldParameterStmt> oldParameterStmt;
-constexpr Parser<Designator> designator;  // R901
-constexpr Parser<Variable> variable;  // R902
-constexpr Parser<Substring> substring;  // R908
-constexpr Parser<DataRef> dataRef;  // R911, R914, R917
-constexpr Parser<StructureComponent> structureComponent;  // R913
-constexpr Parser<StatVariable> statVariable;  // R929
-constexpr Parser<StatOrErrmsg> statOrErrmsg;  // R942 & R1165
-constexpr Parser<DefinedOpName> definedOpName;  // R1003, R1023, R1414, & R1415
-constexpr Parser<Expr> expr;  // R1022
-constexpr Parser<SpecificationExpr> specificationExpr;  // R1028
-constexpr Parser<AssignmentStmt> assignmentStmt;  // R1032
-constexpr Parser<PointerAssignmentStmt> pointerAssignmentStmt;  // R1033
-constexpr Parser<WhereStmt> whereStmt;  // R1041, R1045, R1046
-constexpr Parser<WhereConstruct> whereConstruct;  // R1042
-constexpr Parser<WhereBodyConstruct> whereBodyConstruct;  // R1044
-constexpr Parser<ForallConstruct> forallConstruct;  // R1050
-constexpr Parser<ForallAssignmentStmt> forallAssignmentStmt;  // R1053
-constexpr Parser<ForallStmt> forallStmt;  // R1055
-constexpr Parser<Selector> selector;  // R1105
-constexpr Parser<EndSelectStmt> endSelectStmt;  // R1143 & R1151 & R1155
-constexpr Parser<LoopControl> loopControl;  // R1123
-constexpr Parser<ConcurrentHeader> concurrentHeader;  // R1125
-constexpr Parser<IoUnit> ioUnit;  // R1201, R1203
-constexpr Parser<FileUnitNumber> fileUnitNumber;  // R1202
-constexpr Parser<IoControlSpec> ioControlSpec;  // R1213, R1214
-constexpr Parser<Format> format;  // R1215
-constexpr Parser<InputItem> inputItem;  // R1216
-constexpr Parser<OutputItem> outputItem;  // R1217
-constexpr Parser<InputImpliedDo> inputImpliedDo;  // R1218, R1219
-constexpr Parser<OutputImpliedDo> outputImpliedDo;  // R1218, R1219
-constexpr Parser<PositionOrFlushSpec> positionOrFlushSpec;  // R1227 & R1229
-constexpr Parser<FormatStmt> formatStmt;  // R1301
-constexpr Parser<InterfaceBlock> interfaceBlock;  // R1501
-constexpr Parser<GenericSpec> genericSpec;  // R1508
-constexpr Parser<ProcInterface> procInterface;  // R1513
-constexpr Parser<ProcDecl> procDecl;  // R1515
-constexpr Parser<FunctionReference> functionReference;  // R1520
-constexpr Parser<ActualArgSpec> actualArgSpec;  // R1523
-constexpr Parser<PrefixSpec> prefixSpec;  // R1527
-constexpr Parser<FunctionSubprogram> functionSubprogram;  // R1529
-constexpr Parser<FunctionStmt> functionStmt;  // R1530
-constexpr Parser<Suffix> suffix;  // R1532
-constexpr Parser<EndFunctionStmt> endFunctionStmt;  // R1533
-constexpr Parser<SubroutineSubprogram> subroutineSubprogram;  // R1534
-constexpr Parser<SubroutineStmt> subroutineStmt;  // R1535
-constexpr Parser<DummyArg> dummyArg;  // R1536
-constexpr Parser<EndSubroutineStmt> endSubroutineStmt;  // R1537
-constexpr Parser<EntryStmt> entryStmt;  // R1541
-constexpr Parser<ContainsStmt> containsStmt;  // R1543
+constexpr Parser<Designator> designator; // R901
+constexpr Parser<Variable> variable; // R902
+constexpr Parser<Substring> substring; // R908
+constexpr Parser<DataRef> dataRef; // R911, R914, R917
+constexpr Parser<StructureComponent> structureComponent; // R913
+constexpr Parser<StatVariable> statVariable; // R929
+constexpr Parser<StatOrErrmsg> statOrErrmsg; // R942 & R1165
+constexpr Parser<DefinedOpName> definedOpName; // R1003, R1023, R1414, & R1415
+constexpr Parser<Expr> expr; // R1022
+constexpr Parser<SpecificationExpr> specificationExpr; // R1028
+constexpr Parser<AssignmentStmt> assignmentStmt; // R1032
+constexpr Parser<PointerAssignmentStmt> pointerAssignmentStmt; // R1033
+constexpr Parser<WhereStmt> whereStmt; // R1041, R1045, R1046
+constexpr Parser<WhereConstruct> whereConstruct; // R1042
+constexpr Parser<WhereBodyConstruct> whereBodyConstruct; // R1044
+constexpr Parser<ForallConstruct> forallConstruct; // R1050
+constexpr Parser<ForallAssignmentStmt> forallAssignmentStmt; // R1053
+constexpr Parser<ForallStmt> forallStmt; // R1055
+constexpr Parser<Selector> selector; // R1105
+constexpr Parser<EndSelectStmt> endSelectStmt; // R1143 & R1151 & R1155
+constexpr Parser<LoopControl> loopControl; // R1123
+constexpr Parser<ConcurrentHeader> concurrentHeader; // R1125
+constexpr Parser<IoUnit> ioUnit; // R1201, R1203
+constexpr Parser<FileUnitNumber> fileUnitNumber; // R1202
+constexpr Parser<IoControlSpec> ioControlSpec; // R1213, R1214
+constexpr Parser<Format> format; // R1215
+constexpr Parser<InputItem> inputItem; // R1216
+constexpr Parser<OutputItem> outputItem; // R1217
+constexpr Parser<InputImpliedDo> inputImpliedDo; // R1218, R1219
+constexpr Parser<OutputImpliedDo> outputImpliedDo; // R1218, R1219
+constexpr Parser<PositionOrFlushSpec> positionOrFlushSpec; // R1227 & R1229
+constexpr Parser<FormatStmt> formatStmt; // R1301
+constexpr Parser<InterfaceBlock> interfaceBlock; // R1501
+constexpr Parser<GenericSpec> genericSpec; // R1508
+constexpr Parser<ProcInterface> procInterface; // R1513
+constexpr Parser<ProcDecl> procDecl; // R1515
+constexpr Parser<FunctionReference> functionReference; // R1520
+constexpr Parser<ActualArgSpec> actualArgSpec; // R1523
+constexpr Parser<PrefixSpec> prefixSpec; // R1527
+constexpr Parser<FunctionSubprogram> functionSubprogram; // R1529
+constexpr Parser<FunctionStmt> functionStmt; // R1530
+constexpr Parser<Suffix> suffix; // R1532
+constexpr Parser<EndFunctionStmt> endFunctionStmt; // R1533
+constexpr Parser<SubroutineSubprogram> subroutineSubprogram; // R1534
+constexpr Parser<SubroutineStmt> subroutineStmt; // R1535
+constexpr Parser<DummyArg> dummyArg; // R1536
+constexpr Parser<EndSubroutineStmt> endSubroutineStmt; // R1537
+constexpr Parser<EntryStmt> entryStmt; // R1541
+constexpr Parser<ContainsStmt> containsStmt; // R1543
 constexpr Parser<CompilerDirective> compilerDirective;
 constexpr Parser<OpenMPConstruct> openmpConstruct;
 constexpr Parser<OpenMPDeclarativeConstruct> openmpDeclarativeConstruct;
 constexpr Parser<OmpEndLoopDirective> ompEndLoopDirective;
-}
-#endif  // FORTRAN_PARSER_TYPE_PARSERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TYPE_PARSERS_H_
diff --git a/lib/Parser/unparse.cpp b/lib/Parser/unparse.cpp
index 5a67bac118e0..c2b5c28767da 100644
--- a/lib/Parser/unparse.cpp
+++ b/lib/Parser/unparse.cpp
@@ -29,31 +29,31 @@ class UnparseVisitor {
   UnparseVisitor(llvm::raw_ostream &out, int indentationAmount,
       Encoding encoding, bool capitalize, bool backslashEscapes,
       preStatementType *preStatement, AnalyzedObjectsAsFortran *asFortran)
-    : out_{out}, indentationAmount_{indentationAmount}, encoding_{encoding},
-      capitalizeKeywords_{capitalize}, backslashEscapes_{backslashEscapes},
-      preStatement_{preStatement}, asFortran_{asFortran} {}
+      : out_{out}, indentationAmount_{indentationAmount}, encoding_{encoding},
+        capitalizeKeywords_{capitalize}, backslashEscapes_{backslashEscapes},
+        preStatement_{preStatement}, asFortran_{asFortran} {}
 
   // In nearly all cases, this code avoids defining Boolean-valued Pre()
   // callbacks for the parse tree walking framework in favor of two void
   // functions, Before() and Unparse(), which imply true and false return
   // values for Pre() respectively.
-  template<typename T> void Before(const T &) {}
-  template<typename T> double Unparse(const T &);  // not void, never used
+  template <typename T> void Before(const T &) {}
+  template <typename T> double Unparse(const T &); // not void, never used
 
-  template<typename T> bool Pre(const T &x) {
+  template <typename T> bool Pre(const T &x) {
     if constexpr (std::is_void_v<decltype(Unparse(x))>) {
       // There is a local definition of Unparse() for this type.  It
       // overrides the parse tree walker's default Walk() over the descendents.
       Before(x);
       Unparse(x);
       Post(x);
-      return false;  // Walk() does not visit descendents
+      return false; // Walk() does not visit descendents
     } else {
       Before(x);
-      return true;  // there's no Unparse() defined here, Walk() the descendents
+      return true; // there's no Unparse() defined here, Walk() the descendents
     }
   }
-  template<typename T> void Post(const T &) {}
+  template <typename T> void Post(const T &) {}
 
   // Emit simple types as-is.
   void Unparse(const std::string &x) { Put(x); }
@@ -66,45 +66,70 @@ class UnparseVisitor {
   void Unparse(char x) { Put(x); }
 
   // Statement labels and ends of lines
-  template<typename T> void Before(const Statement<T> &x) {
+  template <typename T> void Before(const Statement<T> &x) {
     if (preStatement_) {
       (*preStatement_)(x.source, out_, indent_);
     }
     Walk(x.label, " ");
   }
-  template<typename T> void Post(const Statement<T> &) { Put('\n'); }
+  template <typename T> void Post(const Statement<T> &) { Put('\n'); }
 
   // The special-case formatting functions for these productions are
   // ordered to correspond roughly to their order of appearance in
   // the Fortran 2018 standard (and parse-tree.h).
 
-  void Unparse(const Program &x) {  // R501
-    Walk("", x.v, "\n");  // put blank lines between ProgramUnits
+  void Unparse(const Program &x) { // R501
+    Walk("", x.v, "\n"); // put blank lines between ProgramUnits
   }
 
-  void Unparse(const Name &x) {  // R603
+  void Unparse(const Name &x) { // R603
     Put(x.ToString());
   }
-  void Unparse(const DefinedOperator::IntrinsicOperator &x) {  // R608
+  void Unparse(const DefinedOperator::IntrinsicOperator &x) { // R608
     switch (x) {
-    case DefinedOperator::IntrinsicOperator::Power: Put("**"); break;
-    case DefinedOperator::IntrinsicOperator::Multiply: Put('*'); break;
-    case DefinedOperator::IntrinsicOperator::Divide: Put('/'); break;
-    case DefinedOperator::IntrinsicOperator::Add: Put('+'); break;
-    case DefinedOperator::IntrinsicOperator::Subtract: Put('-'); break;
-    case DefinedOperator::IntrinsicOperator::Concat: Put("//"); break;
-    case DefinedOperator::IntrinsicOperator::LT: Put('<'); break;
-    case DefinedOperator::IntrinsicOperator::LE: Put("<="); break;
-    case DefinedOperator::IntrinsicOperator::EQ: Put("=="); break;
-    case DefinedOperator::IntrinsicOperator::NE: Put("/="); break;
-    case DefinedOperator::IntrinsicOperator::GE: Put(">="); break;
-    case DefinedOperator::IntrinsicOperator::GT: Put('>'); break;
-    default: Put('.'), Word(DefinedOperator::EnumToString(x)), Put('.');
+    case DefinedOperator::IntrinsicOperator::Power:
+      Put("**");
+      break;
+    case DefinedOperator::IntrinsicOperator::Multiply:
+      Put('*');
+      break;
+    case DefinedOperator::IntrinsicOperator::Divide:
+      Put('/');
+      break;
+    case DefinedOperator::IntrinsicOperator::Add:
+      Put('+');
+      break;
+    case DefinedOperator::IntrinsicOperator::Subtract:
+      Put('-');
+      break;
+    case DefinedOperator::IntrinsicOperator::Concat:
+      Put("//");
+      break;
+    case DefinedOperator::IntrinsicOperator::LT:
+      Put('<');
+      break;
+    case DefinedOperator::IntrinsicOperator::LE:
+      Put("<=");
+      break;
+    case DefinedOperator::IntrinsicOperator::EQ:
+      Put("==");
+      break;
+    case DefinedOperator::IntrinsicOperator::NE:
+      Put("/=");
+      break;
+    case DefinedOperator::IntrinsicOperator::GE:
+      Put(">=");
+      break;
+    case DefinedOperator::IntrinsicOperator::GT:
+      Put('>');
+      break;
+    default:
+      Put('.'), Word(DefinedOperator::EnumToString(x)), Put('.');
     }
   }
-  void Post(const Star &) { Put('*'); }  // R701 &c.
-  void Post(const TypeParamValue::Deferred &) { Put(':'); }  // R701
-  void Unparse(const DeclarationTypeSpec::Type &x) {  // R703
+  void Post(const Star &) { Put('*'); } // R701 &c.
+  void Post(const TypeParamValue::Deferred &) { Put(':'); } // R701
+  void Unparse(const DeclarationTypeSpec::Type &x) { // R703
     Word("TYPE("), Walk(x.derived), Put(')');
   }
   void Unparse(const DeclarationTypeSpec::Class &x) {
@@ -115,7 +140,7 @@ class UnparseVisitor {
   void Unparse(const DeclarationTypeSpec::Record &x) {
     Word("RECORD/"), Walk(x.v), Put('/');
   }
-  void Before(const IntrinsicTypeSpec::Real &) {  // R704
+  void Before(const IntrinsicTypeSpec::Real &) { // R704
     Word("REAL");
   }
   void Before(const IntrinsicTypeSpec::Complex &) { Word("COMPLEX"); }
@@ -127,10 +152,10 @@ class UnparseVisitor {
   void Post(const IntrinsicTypeSpec::DoubleComplex &) {
     Word("DOUBLE COMPLEX");
   }
-  void Before(const IntegerTypeSpec &) {  // R705
+  void Before(const IntegerTypeSpec &) { // R705
     Word("INTEGER");
   }
-  void Unparse(const KindSelector &x) {  // R706
+  void Unparse(const KindSelector &x) { // R706
     std::visit(
         common::visitors{
             [&](const ScalarIntConstantExpr &y) {
@@ -140,38 +165,37 @@ class UnparseVisitor {
         },
         x.u);
   }
-  void Unparse(const SignedIntLiteralConstant &x) {  // R707
+  void Unparse(const SignedIntLiteralConstant &x) { // R707
     Put(std::get<CharBlock>(x.t).ToString());
     Walk("_", std::get<std::optional<KindParam>>(x.t));
   }
-  void Unparse(const IntLiteralConstant &x) {  // R708
+  void Unparse(const IntLiteralConstant &x) { // R708
     Put(std::get<CharBlock>(x.t).ToString());
     Walk("_", std::get<std::optional<KindParam>>(x.t));
   }
-  void Unparse(const Sign &x) {  // R712
+  void Unparse(const Sign &x) { // R712
     Put(x == Sign::Negative ? '-' : '+');
   }
-  void Unparse(const RealLiteralConstant &x) {  // R714, R715
+  void Unparse(const RealLiteralConstant &x) { // R714, R715
     Put(x.real.source.ToString()), Walk("_", x.kind);
   }
-  void Unparse(const ComplexLiteralConstant &x) {  // R718 - R720
+  void Unparse(const ComplexLiteralConstant &x) { // R718 - R720
     Put('('), Walk(x.t, ","), Put(')');
   }
-  void Unparse(const CharSelector::LengthAndKind &x) {  // R721
+  void Unparse(const CharSelector::LengthAndKind &x) { // R721
     Put('('), Word("KIND="), Walk(x.kind);
     Walk(", LEN=", x.length), Put(')');
   }
-  void Unparse(const LengthSelector &x) {  // R722
-    std::visit(
-        common::visitors{
-            [&](const TypeParamValue &y) {
-              Put('('), Word("LEN="), Walk(y), Put(')');
-            },
-            [&](const CharLength &y) { Put('*'), Walk(y); },
-        },
+  void Unparse(const LengthSelector &x) { // R722
+    std::visit(common::visitors{
+                   [&](const TypeParamValue &y) {
+                     Put('('), Word("LEN="), Walk(y), Put(')');
+                   },
+                   [&](const CharLength &y) { Put('*'), Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const CharLength &x) {  // R723
+  void Unparse(const CharLength &x) { // R723
     std::visit(
         common::visitors{
             [&](const TypeParamValue &y) { Put('('), Walk(y), Put(')'); },
@@ -179,7 +203,7 @@ class UnparseVisitor {
         },
         x.u);
   }
-  void Unparse(const CharLiteralConstant &x) {  // R724
+  void Unparse(const CharLiteralConstant &x) { // R724
     const auto &str{std::get<std::string>(x.t)};
     if (const auto &k{std::get<std::optional<KindParam>>(x.t)}) {
       Walk(*k), Put('_');
@@ -197,39 +221,39 @@ class UnparseVisitor {
       }
     }
   }
-  void Unparse(const LogicalLiteralConstant &x) {  // R725
+  void Unparse(const LogicalLiteralConstant &x) { // R725
     Put(std::get<bool>(x.t) ? ".TRUE." : ".FALSE.");
     Walk("_", std::get<std::optional<KindParam>>(x.t));
   }
-  void Unparse(const DerivedTypeStmt &x) {  // R727
+  void Unparse(const DerivedTypeStmt &x) { // R727
     Word("TYPE"), Walk(", ", std::get<std::list<TypeAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::list<Name>>(x.t), ", ", ")");
     Indent();
   }
-  void Unparse(const Abstract &) {  // R728, &c.
+  void Unparse(const Abstract &) { // R728, &c.
     Word("ABSTRACT");
   }
   void Post(const TypeAttrSpec::BindC &) { Word("BIND(C)"); }
   void Unparse(const TypeAttrSpec::Extends &x) {
     Word("EXTENDS("), Walk(x.v), Put(')');
   }
-  void Unparse(const EndTypeStmt &x) {  // R730
+  void Unparse(const EndTypeStmt &x) { // R730
     Outdent(), Word("END TYPE"), Walk(" ", x.v);
   }
-  void Unparse(const SequenceStmt &) {  // R731
+  void Unparse(const SequenceStmt &) { // R731
     Word("SEQUENCE");
   }
-  void Unparse(const TypeParamDefStmt &x) {  // R732
+  void Unparse(const TypeParamDefStmt &x) { // R732
     Walk(std::get<IntegerTypeSpec>(x.t));
     Put(", "), Walk(std::get<common::TypeParamAttr>(x.t));
     Put(" :: "), Walk(std::get<std::list<TypeParamDecl>>(x.t), ", ");
   }
-  void Unparse(const TypeParamDecl &x) {  // R733
+  void Unparse(const TypeParamDecl &x) { // R733
     Walk(std::get<Name>(x.t));
     Walk("=", std::get<std::optional<ScalarIntConstantExpr>>(x.t));
   }
-  void Unparse(const DataComponentDefStmt &x) {  // R737
+  void Unparse(const DataComponentDefStmt &x) { // R737
     const auto &dts{std::get<DeclarationTypeSpec>(x.t)};
     const auto &attrs{std::get<std::list<ComponentAttrSpec>>(x.t)};
     const auto &decls{std::get<std::list<ComponentDecl>>(x.t)};
@@ -249,70 +273,66 @@ class UnparseVisitor {
     }
     Put(' '), Walk(decls, ", ");
   }
-  void Unparse(const Allocatable &) {  // R738
+  void Unparse(const Allocatable &) { // R738
     Word("ALLOCATABLE");
   }
   void Unparse(const Pointer &) { Word("POINTER"); }
   void Unparse(const Contiguous &) { Word("CONTIGUOUS"); }
   void Before(const ComponentAttrSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Word("CODIMENSION["); },
-            [&](const ComponentArraySpec &) { Word("DIMENSION("); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Word("CODIMENSION["); },
+                   [&](const ComponentArraySpec &) { Word("DIMENSION("); },
+                   [](const auto &) {},
+               },
         x.u);
   }
   void Post(const ComponentAttrSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Put(']'); },
-            [&](const ComponentArraySpec &) { Put(')'); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Put(']'); },
+                   [&](const ComponentArraySpec &) { Put(')'); },
+                   [](const auto &) {},
+               },
         x.u);
   }
-  void Unparse(const ComponentDecl &x) {  // R739
+  void Unparse(const ComponentDecl &x) { // R739
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ComponentArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
     Walk("*", std::get<std::optional<CharLength>>(x.t));
     Walk(std::get<std::optional<Initialization>>(x.t));
   }
-  void Unparse(const ComponentArraySpec &x) {  // R740
-    std::visit(
-        common::visitors{
-            [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
-            [&](const DeferredShapeSpecList &y) { Walk(y); },
-        },
+  void Unparse(const ComponentArraySpec &x) { // R740
+    std::visit(common::visitors{
+                   [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
+                   [&](const DeferredShapeSpecList &y) { Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const ProcComponentDefStmt &x) {  // R741
+  void Unparse(const ProcComponentDefStmt &x) { // R741
     Word("PROCEDURE(");
     Walk(std::get<std::optional<ProcInterface>>(x.t)), Put(')');
     Walk(", ", std::get<std::list<ProcComponentAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<std::list<ProcDecl>>(x.t), ", ");
   }
-  void Unparse(const NoPass &) {  // R742
+  void Unparse(const NoPass &) { // R742
     Word("NOPASS");
   }
   void Unparse(const Pass &x) { Word("PASS"), Walk("(", x.v, ")"); }
-  void Unparse(const Initialization &x) {  // R743 & R805
-    std::visit(
-        common::visitors{
-            [&](const ConstantExpr &y) { Put(" = "), Walk(y); },
-            [&](const NullInit &y) { Put(" => "), Walk(y); },
-            [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
-            [&](const std::list<common::Indirection<DataStmtValue>> &y) {
-              Walk("/", y, ", ", "/");
-            },
-        },
+  void Unparse(const Initialization &x) { // R743 & R805
+    std::visit(common::visitors{
+                   [&](const ConstantExpr &y) { Put(" = "), Walk(y); },
+                   [&](const NullInit &y) { Put(" => "), Walk(y); },
+                   [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
+                   [&](const std::list<common::Indirection<DataStmtValue>> &y) {
+                     Walk("/", y, ", ", "/");
+                   },
+               },
         x.u);
   }
-  void Unparse(const PrivateStmt &) {  // R745
+  void Unparse(const PrivateStmt &) { // R745
     Word("PRIVATE");
   }
-  void Unparse(const TypeBoundProcedureStmt::WithoutInterface &x) {  // R749
+  void Unparse(const TypeBoundProcedureStmt::WithoutInterface &x) { // R749
     Word("PROCEDURE"), Walk(", ", x.attributes, ", ");
     Put(" :: "), Walk(x.declarations, ", ");
   }
@@ -321,76 +341,76 @@ class UnparseVisitor {
     Walk(x.attributes);
     Put(" :: "), Walk(x.bindingNames, ", ");
   }
-  void Unparse(const TypeBoundProcDecl &x) {  // R750
+  void Unparse(const TypeBoundProcDecl &x) { // R750
     Walk(std::get<Name>(x.t));
     Walk(" => ", std::get<std::optional<Name>>(x.t));
   }
-  void Unparse(const TypeBoundGenericStmt &x) {  // R751
+  void Unparse(const TypeBoundGenericStmt &x) { // R751
     Word("GENERIC"), Walk(", ", std::get<std::optional<AccessSpec>>(x.t));
     Put(" :: "), Walk(std::get<common::Indirection<GenericSpec>>(x.t));
     Put(" => "), Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Post(const BindAttr::Deferred &) { Word("DEFERRED"); }  // R752
+  void Post(const BindAttr::Deferred &) { Word("DEFERRED"); } // R752
   void Post(const BindAttr::Non_Overridable &) { Word("NON_OVERRIDABLE"); }
-  void Unparse(const FinalProcedureStmt &x) {  // R753
+  void Unparse(const FinalProcedureStmt &x) { // R753
     Word("FINAL :: "), Walk(x.v, ", ");
   }
-  void Unparse(const DerivedTypeSpec &x) {  // R754
+  void Unparse(const DerivedTypeSpec &x) { // R754
     Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::list<TypeParamSpec>>(x.t), ",", ")");
   }
-  void Unparse(const TypeParamSpec &x) {  // R755
+  void Unparse(const TypeParamSpec &x) { // R755
     Walk(std::get<std::optional<Keyword>>(x.t), "=");
     Walk(std::get<TypeParamValue>(x.t));
   }
-  void Unparse(const StructureConstructor &x) {  // R756
+  void Unparse(const StructureConstructor &x) { // R756
     Walk(std::get<DerivedTypeSpec>(x.t));
     Put('('), Walk(std::get<std::list<ComponentSpec>>(x.t), ", "), Put(')');
   }
-  void Unparse(const ComponentSpec &x) {  // R757
+  void Unparse(const ComponentSpec &x) { // R757
     Walk(std::get<std::optional<Keyword>>(x.t), "=");
     Walk(std::get<ComponentDataSource>(x.t));
   }
-  void Unparse(const EnumDefStmt &) {  // R760
+  void Unparse(const EnumDefStmt &) { // R760
     Word("ENUM, BIND(C)"), Indent();
   }
-  void Unparse(const EnumeratorDefStmt &x) {  // R761
+  void Unparse(const EnumeratorDefStmt &x) { // R761
     Word("ENUMERATOR :: "), Walk(x.v, ", ");
   }
-  void Unparse(const Enumerator &x) {  // R762
+  void Unparse(const Enumerator &x) { // R762
     Walk(std::get<NamedConstant>(x.t));
     Walk(" = ", std::get<std::optional<ScalarIntConstantExpr>>(x.t));
   }
-  void Post(const EndEnumStmt &) {  // R763
+  void Post(const EndEnumStmt &) { // R763
     Outdent(), Word("END ENUM");
   }
-  void Unparse(const BOZLiteralConstant &x) {  // R764 - R767
+  void Unparse(const BOZLiteralConstant &x) { // R764 - R767
     Put(x.v);
   }
-  void Unparse(const AcValue::Triplet &x) {  // R773
+  void Unparse(const AcValue::Triplet &x) { // R773
     Walk(std::get<0>(x.t)), Put(':'), Walk(std::get<1>(x.t));
     Walk(":", std::get<std::optional<ScalarIntExpr>>(x.t));
   }
-  void Unparse(const ArrayConstructor &x) {  // R769
+  void Unparse(const ArrayConstructor &x) { // R769
     Put('['), Walk(x.v), Put(']');
   }
-  void Unparse(const AcSpec &x) {  // R770
+  void Unparse(const AcSpec &x) { // R770
     Walk(x.type, "::"), Walk(x.values, ", ");
   }
-  template<typename A, typename B> void Unparse(const LoopBounds<A, B> &x) {
+  template <typename A, typename B> void Unparse(const LoopBounds<A, B> &x) {
     Walk(x.name), Put('='), Walk(x.lower), Put(','), Walk(x.upper);
     Walk(",", x.step);
   }
-  void Unparse(const AcImpliedDo &x) {  // R774
+  void Unparse(const AcImpliedDo &x) { // R774
     Put('('), Walk(std::get<std::list<AcValue>>(x.t), ", ");
     Put(", "), Walk(std::get<AcImpliedDoControl>(x.t)), Put(')');
   }
-  void Unparse(const AcImpliedDoControl &x) {  // R775
+  void Unparse(const AcImpliedDoControl &x) { // R775
     Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
     Walk(std::get<AcImpliedDoControl::Bounds>(x.t));
   }
 
-  void Unparse(const TypeDeclarationStmt &x) {  // R801
+  void Unparse(const TypeDeclarationStmt &x) { // R801
     const auto &dts{std::get<DeclarationTypeSpec>(x.t)};
     const auto &attrs{std::get<std::list<AttrSpec>>(x.t)};
     const auto &decls{std::get<std::list<EntityDecl>>(x.t)};
@@ -445,46 +465,43 @@ class UnparseVisitor {
     }
     Put(' '), Walk(std::get<std::list<EntityDecl>>(x.t), ", ");
   }
-  void Before(const AttrSpec &x) {  // R802
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Word("CODIMENSION["); },
-            [&](const ArraySpec &) { Word("DIMENSION("); },
-            [](const auto &) {},
-        },
+  void Before(const AttrSpec &x) { // R802
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Word("CODIMENSION["); },
+                   [&](const ArraySpec &) { Word("DIMENSION("); },
+                   [](const auto &) {},
+               },
         x.u);
   }
   void Post(const AttrSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Put(']'); },
-            [&](const ArraySpec &) { Put(')'); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Put(']'); },
+                   [&](const ArraySpec &) { Put(')'); },
+                   [](const auto &) {},
+               },
         x.u);
   }
-  void Unparse(const EntityDecl &x) {  // R803
+  void Unparse(const EntityDecl &x) { // R803
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
     Walk("*", std::get<std::optional<CharLength>>(x.t));
     Walk(std::get<std::optional<Initialization>>(x.t));
   }
-  void Unparse(const NullInit &) {  // R806
+  void Unparse(const NullInit &) { // R806
     Word("NULL()");
   }
-  void Unparse(const LanguageBindingSpec &x) {  // R808 & R1528
+  void Unparse(const LanguageBindingSpec &x) { // R808 & R1528
     Word("BIND(C"), Walk(", NAME=", x.v), Put(')');
   }
-  void Unparse(const CoarraySpec &x) {  // R809
-    std::visit(
-        common::visitors{
-            [&](const DeferredCoshapeSpecList &y) { Walk(y); },
-            [&](const ExplicitCoshapeSpec &y) { Walk(y); },
-        },
+  void Unparse(const CoarraySpec &x) { // R809
+    std::visit(common::visitors{
+                   [&](const DeferredCoshapeSpecList &y) { Walk(y); },
+                   [&](const ExplicitCoshapeSpec &y) { Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const DeferredCoshapeSpecList &x) {  // R810
+  void Unparse(const DeferredCoshapeSpecList &x) { // R810
     for (auto j{x.v}; j > 0; --j) {
       Put(':');
       if (j > 1) {
@@ -492,28 +509,27 @@ class UnparseVisitor {
       }
     }
   }
-  void Unparse(const ExplicitCoshapeSpec &x) {  // R811
+  void Unparse(const ExplicitCoshapeSpec &x) { // R811
     Walk(std::get<std::list<ExplicitShapeSpec>>(x.t), ",", ",");
     Walk(std::get<std::optional<SpecificationExpr>>(x.t), ":"), Put('*');
   }
-  void Unparse(const ExplicitShapeSpec &x) {  // R812 - R813 & R816 - R818
+  void Unparse(const ExplicitShapeSpec &x) { // R812 - R813 & R816 - R818
     Walk(std::get<std::optional<SpecificationExpr>>(x.t), ":");
     Walk(std::get<SpecificationExpr>(x.t));
   }
-  void Unparse(const ArraySpec &x) {  // R815
-    std::visit(
-        common::visitors{
-            [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
-            [&](const std::list<AssumedShapeSpec> &y) { Walk(y, ","); },
-            [&](const DeferredShapeSpecList &y) { Walk(y); },
-            [&](const AssumedSizeSpec &y) { Walk(y); },
-            [&](const ImpliedShapeSpec &y) { Walk(y); },
-            [&](const AssumedRankSpec &y) { Walk(y); },
-        },
+  void Unparse(const ArraySpec &x) { // R815
+    std::visit(common::visitors{
+                   [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
+                   [&](const std::list<AssumedShapeSpec> &y) { Walk(y, ","); },
+                   [&](const DeferredShapeSpecList &y) { Walk(y); },
+                   [&](const AssumedSizeSpec &y) { Walk(y); },
+                   [&](const ImpliedShapeSpec &y) { Walk(y); },
+                   [&](const AssumedRankSpec &y) { Walk(y); },
+               },
         x.u);
   }
-  void Post(const AssumedShapeSpec &) { Put(':'); }  // R819
-  void Unparse(const DeferredShapeSpecList &x) {  // R820
+  void Post(const AssumedShapeSpec &) { Put(':'); } // R819
+  void Unparse(const DeferredShapeSpecList &x) { // R820
     for (auto j{x.v}; j > 0; --j) {
       Put(':');
       if (j > 1) {
@@ -521,18 +537,18 @@ class UnparseVisitor {
       }
     }
   }
-  void Unparse(const AssumedImpliedSpec &x) {  // R821
+  void Unparse(const AssumedImpliedSpec &x) { // R821
     Walk(x.v, ":");
     Put('*');
   }
-  void Unparse(const AssumedSizeSpec &x) {  // R822
+  void Unparse(const AssumedSizeSpec &x) { // R822
     Walk(std::get<std::list<ExplicitShapeSpec>>(x.t), ",", ",");
     Walk(std::get<AssumedImpliedSpec>(x.t));
   }
-  void Unparse(const ImpliedShapeSpec &x) {  // R823
+  void Unparse(const ImpliedShapeSpec &x) { // R823
     Walk(x.v, ",");
   }
-  void Post(const AssumedRankSpec &) { Put(".."); }  // R825
+  void Post(const AssumedRankSpec &) { Put(".."); } // R825
   void Post(const Asynchronous &) { Word("ASYNCHRONOUS"); }
   void Post(const External &) { Word("EXTERNAL"); }
   void Post(const Intrinsic &) { Word("INTRINSIC"); }
@@ -543,147 +559,152 @@ class UnparseVisitor {
   void Post(const Target &) { Word("TARGET"); }
   void Post(const Value &) { Word("VALUE"); }
   void Post(const Volatile &) { Word("VOLATILE"); }
-  void Unparse(const IntentSpec &x) {  // R826
+  void Unparse(const IntentSpec &x) { // R826
     Word("INTENT("), Walk(x.v), Put(")");
   }
-  void Unparse(const AccessStmt &x) {  // R827
+  void Unparse(const AccessStmt &x) { // R827
     Walk(std::get<AccessSpec>(x.t));
     Walk(" :: ", std::get<std::list<AccessId>>(x.t), ", ");
   }
-  void Unparse(const AllocatableStmt &x) {  // R829
+  void Unparse(const AllocatableStmt &x) { // R829
     Word("ALLOCATABLE :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ObjectDecl &x) {  // R830 & R860
+  void Unparse(const ObjectDecl &x) { // R830 & R860
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
   }
-  void Unparse(const AsynchronousStmt &x) {  // R831
+  void Unparse(const AsynchronousStmt &x) { // R831
     Word("ASYNCHRONOUS :: "), Walk(x.v, ", ");
   }
-  void Unparse(const BindStmt &x) {  // R832
+  void Unparse(const BindStmt &x) { // R832
     Walk(x.t, " :: ");
   }
-  void Unparse(const BindEntity &x) {  // R833
+  void Unparse(const BindEntity &x) { // R833
     bool isCommon{std::get<BindEntity::Kind>(x.t) == BindEntity::Kind::Common};
     const char *slash{isCommon ? "/" : ""};
     Put(slash), Walk(std::get<Name>(x.t)), Put(slash);
   }
-  void Unparse(const CodimensionStmt &x) {  // R834
+  void Unparse(const CodimensionStmt &x) { // R834
     Word("CODIMENSION :: "), Walk(x.v, ", ");
   }
-  void Unparse(const CodimensionDecl &x) {  // R835
+  void Unparse(const CodimensionDecl &x) { // R835
     Walk(std::get<Name>(x.t));
     Put('['), Walk(std::get<CoarraySpec>(x.t)), Put(']');
   }
-  void Unparse(const ContiguousStmt &x) {  // R836
+  void Unparse(const ContiguousStmt &x) { // R836
     Word("CONTIGUOUS :: "), Walk(x.v, ", ");
   }
-  void Unparse(const DataStmt &x) {  // R837
+  void Unparse(const DataStmt &x) { // R837
     Word("DATA "), Walk(x.v, ", ");
   }
-  void Unparse(const DataStmtSet &x) {  // R838
+  void Unparse(const DataStmtSet &x) { // R838
     Walk(std::get<std::list<DataStmtObject>>(x.t), ", ");
     Put('/'), Walk(std::get<std::list<DataStmtValue>>(x.t), ", "), Put('/');
   }
-  void Unparse(const DataImpliedDo &x) {  // R840, R842
+  void Unparse(const DataImpliedDo &x) { // R840, R842
     Put('('), Walk(std::get<std::list<DataIDoObject>>(x.t), ", "), Put(',');
     Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
     Walk(std::get<DataImpliedDo::Bounds>(x.t)), Put(')');
   }
-  void Unparse(const DataStmtValue &x) {  // R843
+  void Unparse(const DataStmtValue &x) { // R843
     Walk(std::get<std::optional<DataStmtRepeat>>(x.t), "*");
     Walk(std::get<DataStmtConstant>(x.t));
   }
-  void Unparse(const DimensionStmt &x) {  // R848
+  void Unparse(const DimensionStmt &x) { // R848
     Word("DIMENSION :: "), Walk(x.v, ", ");
   }
   void Unparse(const DimensionStmt::Declaration &x) {
     Walk(std::get<Name>(x.t));
     Put('('), Walk(std::get<ArraySpec>(x.t)), Put(')');
   }
-  void Unparse(const IntentStmt &x) {  // R849
+  void Unparse(const IntentStmt &x) { // R849
     Walk(x.t, " :: ");
   }
-  void Unparse(const OptionalStmt &x) {  // R850
+  void Unparse(const OptionalStmt &x) { // R850
     Word("OPTIONAL :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ParameterStmt &x) {  // R851
+  void Unparse(const ParameterStmt &x) { // R851
     Word("PARAMETER("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const NamedConstantDef &x) {  // R852
+  void Unparse(const NamedConstantDef &x) { // R852
     Walk(x.t, "=");
   }
-  void Unparse(const PointerStmt &x) {  // R853
+  void Unparse(const PointerStmt &x) { // R853
     Word("POINTER :: "), Walk(x.v, ", ");
   }
-  void Unparse(const PointerDecl &x) {  // R854
+  void Unparse(const PointerDecl &x) { // R854
     Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::optional<DeferredShapeSpecList>>(x.t), ")");
   }
-  void Unparse(const ProtectedStmt &x) {  // R855
+  void Unparse(const ProtectedStmt &x) { // R855
     Word("PROTECTED :: "), Walk(x.v, ", ");
   }
-  void Unparse(const SaveStmt &x) {  // R856
+  void Unparse(const SaveStmt &x) { // R856
     Word("SAVE"), Walk(" :: ", x.v, ", ");
   }
-  void Unparse(const SavedEntity &x) {  // R857, R858
+  void Unparse(const SavedEntity &x) { // R857, R858
     bool isCommon{
         std::get<SavedEntity::Kind>(x.t) == SavedEntity::Kind::Common};
     const char *slash{isCommon ? "/" : ""};
     Put(slash), Walk(std::get<Name>(x.t)), Put(slash);
   }
-  void Unparse(const TargetStmt &x) {  // R859
+  void Unparse(const TargetStmt &x) { // R859
     Word("TARGET :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ValueStmt &x) {  // R861
+  void Unparse(const ValueStmt &x) { // R861
     Word("VALUE :: "), Walk(x.v, ", ");
   }
-  void Unparse(const VolatileStmt &x) {  // R862
+  void Unparse(const VolatileStmt &x) { // R862
     Word("VOLATILE :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ImplicitStmt &x) {  // R863
+  void Unparse(const ImplicitStmt &x) { // R863
     Word("IMPLICIT ");
-    std::visit(
-        common::visitors{
-            [&](const std::list<ImplicitSpec> &y) { Walk(y, ", "); },
-            [&](const std::list<ImplicitStmt::ImplicitNoneNameSpec> &y) {
-              Word("NONE"), Walk(" (", y, ", ", ")");
-            },
-        },
+    std::visit(common::visitors{
+                   [&](const std::list<ImplicitSpec> &y) { Walk(y, ", "); },
+                   [&](const std::list<ImplicitStmt::ImplicitNoneNameSpec> &y) {
+                     Word("NONE"), Walk(" (", y, ", ", ")");
+                   },
+               },
         x.u);
   }
-  void Unparse(const ImplicitSpec &x) {  // R864
+  void Unparse(const ImplicitSpec &x) { // R864
     Walk(std::get<DeclarationTypeSpec>(x.t));
     Put('('), Walk(std::get<std::list<LetterSpec>>(x.t), ", "), Put(')');
   }
-  void Unparse(const LetterSpec &x) {  // R865
+  void Unparse(const LetterSpec &x) { // R865
     Put(*std::get<const char *>(x.t));
     auto second{std::get<std::optional<const char *>>(x.t)};
     if (second) {
       Put('-'), Put(**second);
     }
   }
-  void Unparse(const ImportStmt &x) {  // R867
+  void Unparse(const ImportStmt &x) { // R867
     Word("IMPORT");
     switch (x.kind) {
-    case common::ImportKind::Default: Walk(" :: ", x.names, ", "); break;
+    case common::ImportKind::Default:
+      Walk(" :: ", x.names, ", ");
+      break;
     case common::ImportKind::Only:
       Put(", "), Word("ONLY: ");
       Walk(x.names, ", ");
       break;
-    case common::ImportKind::None: Word(", NONE"); break;
-    case common::ImportKind::All: Word(", ALL"); break;
+    case common::ImportKind::None:
+      Word(", NONE");
+      break;
+    case common::ImportKind::All:
+      Word(", ALL");
+      break;
     }
   }
-  void Unparse(const NamelistStmt &x) {  // R868
+  void Unparse(const NamelistStmt &x) { // R868
     Word("NAMELIST"), Walk(x.v, ", ");
   }
   void Unparse(const NamelistStmt::Group &x) {
     Put('/'), Walk(std::get<Name>(x.t)), Put('/');
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Unparse(const EquivalenceStmt &x) {  // R870, R871
+  void Unparse(const EquivalenceStmt &x) { // R870, R871
     Word("EQUIVALENCE");
     const char *separator{" "};
     for (const std::list<EquivalenceObject> &y : x.v) {
@@ -691,11 +712,11 @@ class UnparseVisitor {
       separator = ", ";
     }
   }
-  void Unparse(const CommonStmt &x) {  // R873
+  void Unparse(const CommonStmt &x) { // R873
     Word("COMMON ");
     Walk(x.blocks);
   }
-  void Unparse(const CommonBlockObject &x) {  // R874
+  void Unparse(const CommonBlockObject &x) { // R874
     Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::optional<ArraySpec>>(x.t), ")");
   }
@@ -704,7 +725,7 @@ class UnparseVisitor {
     Walk(std::get<std::list<CommonBlockObject>>(x.t));
   }
 
-  void Unparse(const Substring &x) {  // R908, R909
+  void Unparse(const Substring &x) { // R908, R909
     Walk(std::get<DataRef>(x.t));
     Put('('), Walk(std::get<SubstringRange>(x.t)), Put(')');
   }
@@ -712,15 +733,15 @@ class UnparseVisitor {
     Walk(std::get<CharLiteralConstant>(x.t));
     Put('('), Walk(std::get<SubstringRange>(x.t)), Put(')');
   }
-  void Unparse(const SubstringRange &x) {  // R910
+  void Unparse(const SubstringRange &x) { // R910
     Walk(x.t, ":");
   }
-  void Unparse(const PartRef &x) {  // R912
+  void Unparse(const PartRef &x) { // R912
     Walk(x.name);
     Walk("(", x.subscripts, ",", ")");
     Walk(x.imageSelector);
   }
-  void Unparse(const StructureComponent &x) {  // R913
+  void Unparse(const StructureComponent &x) { // R913
     Walk(x.base);
     if (structureComponents_.find(x.component.source) !=
         structureComponents_.end()) {
@@ -730,19 +751,19 @@ class UnparseVisitor {
     }
     Walk(x.component);
   }
-  void Unparse(const ArrayElement &x) {  // R917
+  void Unparse(const ArrayElement &x) { // R917
     Walk(x.base);
     Put('('), Walk(x.subscripts, ","), Put(')');
   }
-  void Unparse(const SubscriptTriplet &x) {  // R921
+  void Unparse(const SubscriptTriplet &x) { // R921
     Walk(std::get<0>(x.t)), Put(':'), Walk(std::get<1>(x.t));
     Walk(":", std::get<2>(x.t));
   }
-  void Unparse(const ImageSelector &x) {  // R924
+  void Unparse(const ImageSelector &x) { // R924
     Put('['), Walk(std::get<std::list<Cosubscript>>(x.t), ",");
     Walk(",", std::get<std::list<ImageSelectorSpec>>(x.t), ","), Put(']');
   }
-  void Before(const ImageSelectorSpec::Stat &) {  // R926
+  void Before(const ImageSelectorSpec::Stat &) { // R926
     Word("STAT=");
   }
   void Before(const ImageSelectorSpec::Team_Number &) { Word("TEAM_NUMBER="); }
@@ -751,48 +772,46 @@ class UnparseVisitor {
       Word("TEAM=");
     }
   }
-  void Unparse(const AllocateStmt &x) {  // R927
+  void Unparse(const AllocateStmt &x) { // R927
     Word("ALLOCATE(");
     Walk(std::get<std::optional<TypeSpec>>(x.t), "::");
     Walk(std::get<std::list<Allocation>>(x.t), ", ");
     Walk(", ", std::get<std::list<AllocOpt>>(x.t), ", "), Put(')');
   }
-  void Before(const AllocOpt &x) {  // R928, R931
-    std::visit(
-        common::visitors{
-            [&](const AllocOpt::Mold &) { Word("MOLD="); },
-            [&](const AllocOpt::Source &) { Word("SOURCE="); },
-            [](const StatOrErrmsg &) {},
-        },
+  void Before(const AllocOpt &x) { // R928, R931
+    std::visit(common::visitors{
+                   [&](const AllocOpt::Mold &) { Word("MOLD="); },
+                   [&](const AllocOpt::Source &) { Word("SOURCE="); },
+                   [](const StatOrErrmsg &) {},
+               },
         x.u);
   }
-  void Unparse(const Allocation &x) {  // R932
+  void Unparse(const Allocation &x) { // R932
     Walk(std::get<AllocateObject>(x.t));
     Walk("(", std::get<std::list<AllocateShapeSpec>>(x.t), ",", ")");
     Walk("[", std::get<std::optional<AllocateCoarraySpec>>(x.t), "]");
   }
-  void Unparse(const AllocateShapeSpec &x) {  // R934 & R938
+  void Unparse(const AllocateShapeSpec &x) { // R934 & R938
     Walk(std::get<std::optional<BoundExpr>>(x.t), ":");
     Walk(std::get<BoundExpr>(x.t));
   }
-  void Unparse(const AllocateCoarraySpec &x) {  // R937
+  void Unparse(const AllocateCoarraySpec &x) { // R937
     Walk(std::get<std::list<AllocateCoshapeSpec>>(x.t), ",", ",");
     Walk(std::get<std::optional<BoundExpr>>(x.t), ":"), Put('*');
   }
-  void Unparse(const NullifyStmt &x) {  // R939
+  void Unparse(const NullifyStmt &x) { // R939
     Word("NULLIFY("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const DeallocateStmt &x) {  // R941
+  void Unparse(const DeallocateStmt &x) { // R941
     Word("DEALLOCATE(");
     Walk(std::get<std::list<AllocateObject>>(x.t), ", ");
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Before(const StatOrErrmsg &x) {  // R942 & R1165
-    std::visit(
-        common::visitors{
-            [&](const StatVariable &) { Word("STAT="); },
-            [&](const MsgVariable &) { Word("ERRMSG="); },
-        },
+  void Before(const StatOrErrmsg &x) { // R942 & R1165
+    std::visit(common::visitors{
+                   [&](const StatVariable &) { Word("STAT="); },
+                   [&](const MsgVariable &) { Word("ERRMSG="); },
+               },
         x.u);
   }
 
@@ -833,14 +852,14 @@ class UnparseVisitor {
     Put('('), Walk(x.t, ","), Put(')');
   }
   void Unparse(const Expr::DefinedBinary &x) {
-    Walk(std::get<1>(x.t));  // left
+    Walk(std::get<1>(x.t)); // left
     Walk(std::get<DefinedOpName>(x.t));
-    Walk(std::get<2>(x.t));  // right
+    Walk(std::get<2>(x.t)); // right
   }
-  void Unparse(const DefinedOpName &x) {  // R1003, R1023, R1414, & R1415
+  void Unparse(const DefinedOpName &x) { // R1003, R1023, R1414, & R1415
     Walk(x.v);
   }
-  void Unparse(const AssignmentStmt &x) {  // R1032
+  void Unparse(const AssignmentStmt &x) { // R1032
     if (asFortran_ && x.typedAssignment.get()) {
       Put(' ');
       asFortran_->assignment(out_, *x.typedAssignment);
@@ -849,7 +868,7 @@ class UnparseVisitor {
       Walk(x.t, " = ");
     }
   }
-  void Unparse(const PointerAssignmentStmt &x) {  // R1033, R1034, R1038
+  void Unparse(const PointerAssignmentStmt &x) { // R1033, R1034, R1038
     if (asFortran_ && x.typedAssignment.get()) {
       Put(' ');
       asFortran_->assignment(out_, *x.typedAssignment);
@@ -867,119 +886,118 @@ class UnparseVisitor {
       Put(" => "), Walk(std::get<Expr>(x.t));
     }
   }
-  void Post(const BoundsSpec &) {  // R1035
+  void Post(const BoundsSpec &) { // R1035
     Put(':');
   }
-  void Unparse(const BoundsRemapping &x) {  // R1036
+  void Unparse(const BoundsRemapping &x) { // R1036
     Walk(x.t, ":");
   }
-  void Unparse(const WhereStmt &x) {  // R1041, R1045, R1046
+  void Unparse(const WhereStmt &x) { // R1041, R1045, R1046
     Word("WHERE ("), Walk(x.t, ") ");
   }
-  void Unparse(const WhereConstructStmt &x) {  // R1043
+  void Unparse(const WhereConstructStmt &x) { // R1043
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("WHERE ("), Walk(std::get<LogicalExpr>(x.t)), Put(')');
     Indent();
   }
-  void Unparse(const MaskedElsewhereStmt &x) {  // R1047
+  void Unparse(const MaskedElsewhereStmt &x) { // R1047
     Outdent();
     Word("ELSEWHERE ("), Walk(std::get<LogicalExpr>(x.t)), Put(')');
     Walk(" ", std::get<std::optional<Name>>(x.t));
     Indent();
   }
-  void Unparse(const ElsewhereStmt &x) {  // R1048
+  void Unparse(const ElsewhereStmt &x) { // R1048
     Outdent(), Word("ELSEWHERE"), Walk(" ", x.v), Indent();
   }
-  void Unparse(const EndWhereStmt &x) {  // R1049
+  void Unparse(const EndWhereStmt &x) { // R1049
     Outdent(), Word("END WHERE"), Walk(" ", x.v);
   }
-  void Unparse(const ForallConstructStmt &x) {  // R1051
+  void Unparse(const ForallConstructStmt &x) { // R1051
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("FORALL"), Walk(std::get<common::Indirection<ConcurrentHeader>>(x.t));
     Indent();
   }
-  void Unparse(const EndForallStmt &x) {  // R1054
+  void Unparse(const EndForallStmt &x) { // R1054
     Outdent(), Word("END FORALL"), Walk(" ", x.v);
   }
-  void Before(const ForallStmt &) {  // R1055
+  void Before(const ForallStmt &) { // R1055
     Word("FORALL");
   }
 
-  void Unparse(const AssociateStmt &x) {  // R1103
+  void Unparse(const AssociateStmt &x) { // R1103
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("ASSOCIATE (");
     Walk(std::get<std::list<Association>>(x.t), ", "), Put(')'), Indent();
   }
-  void Unparse(const Association &x) {  // R1104
+  void Unparse(const Association &x) { // R1104
     Walk(x.t, " => ");
   }
-  void Unparse(const EndAssociateStmt &x) {  // R1106
+  void Unparse(const EndAssociateStmt &x) { // R1106
     Outdent(), Word("END ASSOCIATE"), Walk(" ", x.v);
   }
-  void Unparse(const BlockStmt &x) {  // R1108
+  void Unparse(const BlockStmt &x) { // R1108
     Walk(x.v, ": "), Word("BLOCK"), Indent();
   }
-  void Unparse(const EndBlockStmt &x) {  // R1110
+  void Unparse(const EndBlockStmt &x) { // R1110
     Outdent(), Word("END BLOCK"), Walk(" ", x.v);
   }
-  void Unparse(const ChangeTeamStmt &x) {  // R1112
+  void Unparse(const ChangeTeamStmt &x) { // R1112
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("CHANGE TEAM ("), Walk(std::get<TeamValue>(x.t));
     Walk(", ", std::get<std::list<CoarrayAssociation>>(x.t), ", ");
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
     Indent();
   }
-  void Unparse(const CoarrayAssociation &x) {  // R1113
+  void Unparse(const CoarrayAssociation &x) { // R1113
     Walk(x.t, " => ");
   }
-  void Unparse(const EndChangeTeamStmt &x) {  // R1114
+  void Unparse(const EndChangeTeamStmt &x) { // R1114
     Outdent(), Word("END TEAM (");
     Walk(std::get<std::list<StatOrErrmsg>>(x.t), ", ");
     Put(')'), Walk(" ", std::get<std::optional<Name>>(x.t));
   }
-  void Unparse(const CriticalStmt &x) {  // R1117
+  void Unparse(const CriticalStmt &x) { // R1117
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("CRITICAL ("), Walk(std::get<std::list<StatOrErrmsg>>(x.t), ", ");
     Put(')'), Indent();
   }
-  void Unparse(const EndCriticalStmt &x) {  // R1118
+  void Unparse(const EndCriticalStmt &x) { // R1118
     Outdent(), Word("END CRITICAL"), Walk(" ", x.v);
   }
-  void Unparse(const DoConstruct &x) {  // R1119, R1120
+  void Unparse(const DoConstruct &x) { // R1119, R1120
     Walk(std::get<Statement<NonLabelDoStmt>>(x.t));
     Indent(), Walk(std::get<Block>(x.t), ""), Outdent();
     Walk(std::get<Statement<EndDoStmt>>(x.t));
   }
-  void Unparse(const LabelDoStmt &x) {  // R1121
+  void Unparse(const LabelDoStmt &x) { // R1121
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("DO "), Walk(std::get<Label>(x.t));
     Walk(" ", std::get<std::optional<LoopControl>>(x.t));
   }
-  void Unparse(const NonLabelDoStmt &x) {  // R1122
+  void Unparse(const NonLabelDoStmt &x) { // R1122
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("DO "), Walk(std::get<std::optional<LoopControl>>(x.t));
   }
-  void Unparse(const LoopControl &x) {  // R1123
-    std::visit(
-        common::visitors{
-            [&](const ScalarLogicalExpr &y) {
-              Word("WHILE ("), Walk(y), Put(')');
-            },
-            [&](const auto &y) { Walk(y); },
-        },
+  void Unparse(const LoopControl &x) { // R1123
+    std::visit(common::visitors{
+                   [&](const ScalarLogicalExpr &y) {
+                     Word("WHILE ("), Walk(y), Put(')');
+                   },
+                   [&](const auto &y) { Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const ConcurrentHeader &x) {  // R1125
+  void Unparse(const ConcurrentHeader &x) { // R1125
     Put('('), Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
     Walk(std::get<std::list<ConcurrentControl>>(x.t), ", ");
     Walk(", ", std::get<std::optional<ScalarLogicalExpr>>(x.t)), Put(')');
   }
-  void Unparse(const ConcurrentControl &x) {  // R1126 - R1128
+  void Unparse(const ConcurrentControl &x) { // R1126 - R1128
     Walk(std::get<Name>(x.t)), Put('='), Walk(std::get<1>(x.t));
     Put(':'), Walk(std::get<2>(x.t));
     Walk(":", std::get<std::optional<ScalarIntExpr>>(x.t));
   }
-  void Before(const LoopControl::Concurrent &) {  // R1129
+  void Before(const LoopControl::Concurrent &) { // R1129
     Word("CONCURRENT");
   }
   void Unparse(const LocalitySpec::Local &x) {
@@ -992,80 +1010,78 @@ class UnparseVisitor {
     Word("SHARED("), Walk(x.v, ", "), Put(')');
   }
   void Post(const LocalitySpec::DefaultNone &) { Word("DEFAULT(NONE)"); }
-  void Unparse(const EndDoStmt &x) {  // R1132
+  void Unparse(const EndDoStmt &x) { // R1132
     Word("END DO"), Walk(" ", x.v);
   }
-  void Unparse(const CycleStmt &x) {  // R1133
+  void Unparse(const CycleStmt &x) { // R1133
     Word("CYCLE"), Walk(" ", x.v);
   }
-  void Unparse(const IfThenStmt &x) {  // R1135
+  void Unparse(const IfThenStmt &x) { // R1135
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("IF ("), Walk(std::get<ScalarLogicalExpr>(x.t));
     Put(") "), Word("THEN"), Indent();
   }
-  void Unparse(const ElseIfStmt &x) {  // R1136
+  void Unparse(const ElseIfStmt &x) { // R1136
     Outdent(), Word("ELSE IF (");
     Walk(std::get<ScalarLogicalExpr>(x.t)), Put(") "), Word("THEN");
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
-  void Unparse(const ElseStmt &x) {  // R1137
+  void Unparse(const ElseStmt &x) { // R1137
     Outdent(), Word("ELSE"), Walk(" ", x.v), Indent();
   }
-  void Unparse(const EndIfStmt &x) {  // R1138
+  void Unparse(const EndIfStmt &x) { // R1138
     Outdent(), Word("END IF"), Walk(" ", x.v);
   }
-  void Unparse(const IfStmt &x) {  // R1139
+  void Unparse(const IfStmt &x) { // R1139
     Word("IF ("), Walk(x.t, ") ");
   }
-  void Unparse(const SelectCaseStmt &x) {  // R1141, R1144
+  void Unparse(const SelectCaseStmt &x) { // R1141, R1144
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("SELECT CASE (");
     Walk(std::get<Scalar<Expr>>(x.t)), Put(')'), Indent();
   }
-  void Unparse(const CaseStmt &x) {  // R1142
+  void Unparse(const CaseStmt &x) { // R1142
     Outdent(), Word("CASE "), Walk(std::get<CaseSelector>(x.t));
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
-  void Unparse(const EndSelectStmt &x) {  // R1143 & R1151 & R1155
+  void Unparse(const EndSelectStmt &x) { // R1143 & R1151 & R1155
     Outdent(), Word("END SELECT"), Walk(" ", x.v);
   }
-  void Unparse(const CaseSelector &x) {  // R1145
-    std::visit(
-        common::visitors{
-            [&](const std::list<CaseValueRange> &y) {
-              Put('('), Walk(y), Put(')');
-            },
-            [&](const Default &) { Word("DEFAULT"); },
-        },
+  void Unparse(const CaseSelector &x) { // R1145
+    std::visit(common::visitors{
+                   [&](const std::list<CaseValueRange> &y) {
+                     Put('('), Walk(y), Put(')');
+                   },
+                   [&](const Default &) { Word("DEFAULT"); },
+               },
         x.u);
   }
-  void Unparse(const CaseValueRange::Range &x) {  // R1146
+  void Unparse(const CaseValueRange::Range &x) { // R1146
     Walk(x.lower), Put(':'), Walk(x.upper);
   }
-  void Unparse(const SelectRankStmt &x) {  // R1149
+  void Unparse(const SelectRankStmt &x) { // R1149
     Walk(std::get<0>(x.t), ": ");
     Word("SELECT RANK ("), Walk(std::get<1>(x.t), " => ");
     Walk(std::get<Selector>(x.t)), Put(')'), Indent();
   }
-  void Unparse(const SelectRankCaseStmt &x) {  // R1150
+  void Unparse(const SelectRankCaseStmt &x) { // R1150
     Outdent(), Word("RANK ");
-    std::visit(
-        common::visitors{
-            [&](const ScalarIntConstantExpr &y) {
-              Put('('), Walk(y), Put(')');
-            },
-            [&](const Star &) { Put("(*)"); },
-            [&](const Default &) { Word("DEFAULT"); },
-        },
+    std::visit(common::visitors{
+                   [&](const ScalarIntConstantExpr &y) {
+                     Put('('), Walk(y), Put(')');
+                   },
+                   [&](const Star &) { Put("(*)"); },
+                   [&](const Default &) { Word("DEFAULT"); },
+               },
         std::get<SelectRankCaseStmt::Rank>(x.t).u);
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
-  void Unparse(const SelectTypeStmt &x) {  // R1153
+  void Unparse(const SelectTypeStmt &x) { // R1153
     Walk(std::get<0>(x.t), ": ");
     Word("SELECT TYPE ("), Walk(std::get<1>(x.t), " => ");
     Walk(std::get<Selector>(x.t)), Put(')'), Indent();
   }
-  void Unparse(const TypeGuardStmt &x) {  // R1154
+  void Unparse(const TypeGuardStmt &x) { // R1154
     Outdent(), Walk(std::get<TypeGuardStmt::Guard>(x.t));
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
@@ -1080,80 +1096,78 @@ class UnparseVisitor {
         },
         x.u);
   }
-  void Unparse(const ExitStmt &x) {  // R1156
+  void Unparse(const ExitStmt &x) { // R1156
     Word("EXIT"), Walk(" ", x.v);
   }
-  void Before(const GotoStmt &) {  // R1157
+  void Before(const GotoStmt &) { // R1157
     Word("GO TO ");
   }
-  void Unparse(const ComputedGotoStmt &x) {  // R1158
+  void Unparse(const ComputedGotoStmt &x) { // R1158
     Word("GO TO ("), Walk(x.t, "), ");
   }
-  void Unparse(const ContinueStmt &) {  // R1159
+  void Unparse(const ContinueStmt &) { // R1159
     Word("CONTINUE");
   }
-  void Unparse(const StopStmt &x) {  // R1160, R1161
+  void Unparse(const StopStmt &x) { // R1160, R1161
     if (std::get<StopStmt::Kind>(x.t) == StopStmt::Kind::ErrorStop) {
       Word("ERROR ");
     }
     Word("STOP"), Walk(" ", std::get<std::optional<StopCode>>(x.t));
     Walk(", QUIET=", std::get<std::optional<ScalarLogicalExpr>>(x.t));
   }
-  void Unparse(const FailImageStmt &) {  // R1163
+  void Unparse(const FailImageStmt &) { // R1163
     Word("FAIL IMAGE");
   }
-  void Unparse(const SyncAllStmt &x) {  // R1164
+  void Unparse(const SyncAllStmt &x) { // R1164
     Word("SYNC ALL ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const SyncImagesStmt &x) {  // R1166
+  void Unparse(const SyncImagesStmt &x) { // R1166
     Word("SYNC IMAGES (");
     Walk(std::get<SyncImagesStmt::ImageSet>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Unparse(const SyncMemoryStmt &x) {  // R1168
+  void Unparse(const SyncMemoryStmt &x) { // R1168
     Word("SYNC MEMORY ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const SyncTeamStmt &x) {  // R1169
+  void Unparse(const SyncTeamStmt &x) { // R1169
     Word("SYNC TEAM ("), Walk(std::get<TeamValue>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Unparse(const EventPostStmt &x) {  // R1170
+  void Unparse(const EventPostStmt &x) { // R1170
     Word("EVENT POST ("), Walk(std::get<EventVariable>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Before(const EventWaitStmt::EventWaitSpec &x) {  // R1173, R1174
-    std::visit(
-        common::visitors{
-            [&](const ScalarIntExpr &) { Word("UNTIL_COUNT="); },
-            [](const StatOrErrmsg &) {},
-        },
+  void Before(const EventWaitStmt::EventWaitSpec &x) { // R1173, R1174
+    std::visit(common::visitors{
+                   [&](const ScalarIntExpr &) { Word("UNTIL_COUNT="); },
+                   [](const StatOrErrmsg &) {},
+               },
         x.u);
   }
-  void Unparse(const EventWaitStmt &x) {  // R1170
+  void Unparse(const EventWaitStmt &x) { // R1170
     Word("EVENT WAIT ("), Walk(std::get<EventVariable>(x.t));
     Walk(", ", std::get<std::list<EventWaitStmt::EventWaitSpec>>(x.t), ", ");
     Put(')');
   }
-  void Unparse(const FormTeamStmt &x) {  // R1175, R1177
+  void Unparse(const FormTeamStmt &x) { // R1175, R1177
     Word("FORM TEAM ("), Walk(std::get<ScalarIntExpr>(x.t));
     Put(','), Walk(std::get<TeamVariable>(x.t));
     Walk(", ", std::get<std::list<FormTeamStmt::FormTeamSpec>>(x.t), ", ");
     Put(')');
   }
-  void Before(const FormTeamStmt::FormTeamSpec &x) {  // R1176, R1178
-    std::visit(
-        common::visitors{
-            [&](const ScalarIntExpr &) { Word("NEW_INDEX="); },
-            [](const StatOrErrmsg &) {},
-        },
+  void Before(const FormTeamStmt::FormTeamSpec &x) { // R1176, R1178
+    std::visit(common::visitors{
+                   [&](const ScalarIntExpr &) { Word("NEW_INDEX="); },
+                   [](const StatOrErrmsg &) {},
+               },
         x.u);
   }
-  void Unparse(const LockStmt &x) {  // R1179
+  void Unparse(const LockStmt &x) { // R1179
     Word("LOCK ("), Walk(std::get<LockVariable>(x.t));
     Walk(", ", std::get<std::list<LockStmt::LockStat>>(x.t), ", ");
     Put(')');
   }
-  void Before(const LockStmt::LockStat &x) {  // R1180
+  void Before(const LockStmt::LockStat &x) { // R1180
     std::visit(
         common::visitors{
             [&](const ScalarLogicalVariable &) { Word("ACQUIRED_LOCK="); },
@@ -1161,72 +1175,70 @@ class UnparseVisitor {
         },
         x.u);
   }
-  void Unparse(const UnlockStmt &x) {  // R1181
+  void Unparse(const UnlockStmt &x) { // R1181
     Word("UNLOCK ("), Walk(std::get<LockVariable>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", ");
     Put(')');
   }
 
-  void Unparse(const OpenStmt &x) {  // R1204
+  void Unparse(const OpenStmt &x) { // R1204
     Word("OPEN ("), Walk(x.v, ", "), Put(')');
   }
-  bool Pre(const ConnectSpec &x) {  // R1205
-    return std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) {
-              Word("UNIT=");
-              return true;
-            },
-            [&](const FileNameExpr &) {
-              Word("FILE=");
-              return true;
-            },
-            [&](const ConnectSpec::CharExpr &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const MsgVariable &) {
-              Word("IOMSG=");
-              return true;
-            },
-            [&](const StatVariable &) {
-              Word("IOSTAT=");
-              return true;
-            },
-            [&](const ConnectSpec::Recl &) {
-              Word("RECL=");
-              return true;
-            },
-            [&](const ConnectSpec::Newunit &) {
-              Word("NEWUNIT=");
-              return true;
-            },
-            [&](const ErrLabel &) {
-              Word("ERR=");
-              return true;
-            },
-            [&](const StatusExpr &) {
-              Word("STATUS=");
-              return true;
-            },
-        },
+  bool Pre(const ConnectSpec &x) { // R1205
+    return std::visit(common::visitors{
+                          [&](const FileUnitNumber &) {
+                            Word("UNIT=");
+                            return true;
+                          },
+                          [&](const FileNameExpr &) {
+                            Word("FILE=");
+                            return true;
+                          },
+                          [&](const ConnectSpec::CharExpr &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const MsgVariable &) {
+                            Word("IOMSG=");
+                            return true;
+                          },
+                          [&](const StatVariable &) {
+                            Word("IOSTAT=");
+                            return true;
+                          },
+                          [&](const ConnectSpec::Recl &) {
+                            Word("RECL=");
+                            return true;
+                          },
+                          [&](const ConnectSpec::Newunit &) {
+                            Word("NEWUNIT=");
+                            return true;
+                          },
+                          [&](const ErrLabel &) {
+                            Word("ERR=");
+                            return true;
+                          },
+                          [&](const StatusExpr &) {
+                            Word("STATUS=");
+                            return true;
+                          },
+                      },
         x.u);
   }
-  void Unparse(const CloseStmt &x) {  // R1208
+  void Unparse(const CloseStmt &x) { // R1208
     Word("CLOSE ("), Walk(x.v, ", "), Put(')');
   }
-  void Before(const CloseStmt::CloseSpec &x) {  // R1209
-    std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) { Word("UNIT="); },
-            [&](const StatVariable &) { Word("IOSTAT="); },
-            [&](const MsgVariable &) { Word("IOMSG="); },
-            [&](const ErrLabel &) { Word("ERR="); },
-            [&](const StatusExpr &) { Word("STATUS="); },
-        },
+  void Before(const CloseStmt::CloseSpec &x) { // R1209
+    std::visit(common::visitors{
+                   [&](const FileUnitNumber &) { Word("UNIT="); },
+                   [&](const StatVariable &) { Word("IOSTAT="); },
+                   [&](const MsgVariable &) { Word("IOMSG="); },
+                   [&](const ErrLabel &) { Word("ERR="); },
+                   [&](const StatusExpr &) { Word("STATUS="); },
+               },
         x.u);
   }
-  void Unparse(const ReadStmt &x) {  // R1210
+  void Unparse(const ReadStmt &x) { // R1210
     Word("READ ");
     if (x.iounit) {
       Put('('), Walk(x.iounit);
@@ -1245,7 +1257,7 @@ class UnparseVisitor {
     }
     Walk(" ", x.items, ", ");
   }
-  void Unparse(const WriteStmt &x) {  // R1211
+  void Unparse(const WriteStmt &x) { // R1211
     Word("WRITE (");
     if (x.iounit) {
       Walk(x.iounit);
@@ -1258,119 +1270,116 @@ class UnparseVisitor {
     }
     Put(')'), Walk(" ", x.items, ", ");
   }
-  void Unparse(const PrintStmt &x) {  // R1212
+  void Unparse(const PrintStmt &x) { // R1212
     Word("PRINT "), Walk(std::get<Format>(x.t));
     Walk(", ", std::get<std::list<OutputItem>>(x.t), ", ");
   }
-  bool Pre(const IoControlSpec &x) {  // R1213
-    return std::visit(
-        common::visitors{
-            [&](const IoUnit &) {
-              Word("UNIT=");
-              return true;
-            },
-            [&](const Format &) {
-              Word("FMT=");
-              return true;
-            },
-            [&](const Name &) {
-              Word("NML=");
-              return true;
-            },
-            [&](const IoControlSpec::CharExpr &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const IoControlSpec::Asynchronous &) {
-              Word("ASYNCHRONOUS=");
-              return true;
-            },
-            [&](const EndLabel &) {
-              Word("END=");
-              return true;
-            },
-            [&](const EorLabel &) {
-              Word("EOR=");
-              return true;
-            },
-            [&](const ErrLabel &) {
-              Word("ERR=");
-              return true;
-            },
-            [&](const IdVariable &) {
-              Word("ID=");
-              return true;
-            },
-            [&](const MsgVariable &) {
-              Word("IOMSG=");
-              return true;
-            },
-            [&](const StatVariable &) {
-              Word("IOSTAT=");
-              return true;
-            },
-            [&](const IoControlSpec::Pos &) {
-              Word("POS=");
-              return true;
-            },
-            [&](const IoControlSpec::Rec &) {
-              Word("REC=");
-              return true;
-            },
-            [&](const IoControlSpec::Size &) {
-              Word("SIZE=");
-              return true;
-            },
-        },
+  bool Pre(const IoControlSpec &x) { // R1213
+    return std::visit(common::visitors{
+                          [&](const IoUnit &) {
+                            Word("UNIT=");
+                            return true;
+                          },
+                          [&](const Format &) {
+                            Word("FMT=");
+                            return true;
+                          },
+                          [&](const Name &) {
+                            Word("NML=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::CharExpr &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const IoControlSpec::Asynchronous &) {
+                            Word("ASYNCHRONOUS=");
+                            return true;
+                          },
+                          [&](const EndLabel &) {
+                            Word("END=");
+                            return true;
+                          },
+                          [&](const EorLabel &) {
+                            Word("EOR=");
+                            return true;
+                          },
+                          [&](const ErrLabel &) {
+                            Word("ERR=");
+                            return true;
+                          },
+                          [&](const IdVariable &) {
+                            Word("ID=");
+                            return true;
+                          },
+                          [&](const MsgVariable &) {
+                            Word("IOMSG=");
+                            return true;
+                          },
+                          [&](const StatVariable &) {
+                            Word("IOSTAT=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::Pos &) {
+                            Word("POS=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::Rec &) {
+                            Word("REC=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::Size &) {
+                            Word("SIZE=");
+                            return true;
+                          },
+                      },
         x.u);
   }
-  void Unparse(const InputImpliedDo &x) {  // R1218
+  void Unparse(const InputImpliedDo &x) { // R1218
     Put('('), Walk(std::get<std::list<InputItem>>(x.t), ", "), Put(", ");
     Walk(std::get<IoImpliedDoControl>(x.t)), Put(')');
   }
-  void Unparse(const OutputImpliedDo &x) {  // R1219
+  void Unparse(const OutputImpliedDo &x) { // R1219
     Put('('), Walk(std::get<std::list<OutputItem>>(x.t), ", "), Put(", ");
     Walk(std::get<IoImpliedDoControl>(x.t)), Put(')');
   }
-  void Unparse(const WaitStmt &x) {  // R1222
+  void Unparse(const WaitStmt &x) { // R1222
     Word("WAIT ("), Walk(x.v, ", "), Put(')');
   }
-  void Before(const WaitSpec &x) {  // R1223
-    std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) { Word("UNIT="); },
-            [&](const EndLabel &) { Word("END="); },
-            [&](const EorLabel &) { Word("EOR="); },
-            [&](const ErrLabel &) { Word("ERR="); },
-            [&](const IdExpr &) { Word("ID="); },
-            [&](const MsgVariable &) { Word("IOMSG="); },
-            [&](const StatVariable &) { Word("IOSTAT="); },
-        },
+  void Before(const WaitSpec &x) { // R1223
+    std::visit(common::visitors{
+                   [&](const FileUnitNumber &) { Word("UNIT="); },
+                   [&](const EndLabel &) { Word("END="); },
+                   [&](const EorLabel &) { Word("EOR="); },
+                   [&](const ErrLabel &) { Word("ERR="); },
+                   [&](const IdExpr &) { Word("ID="); },
+                   [&](const MsgVariable &) { Word("IOMSG="); },
+                   [&](const StatVariable &) { Word("IOSTAT="); },
+               },
         x.u);
   }
-  void Unparse(const BackspaceStmt &x) {  // R1224
+  void Unparse(const BackspaceStmt &x) { // R1224
     Word("BACKSPACE ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const EndfileStmt &x) {  // R1225
+  void Unparse(const EndfileStmt &x) { // R1225
     Word("ENDFILE ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const RewindStmt &x) {  // R1226
+  void Unparse(const RewindStmt &x) { // R1226
     Word("REWIND ("), Walk(x.v, ", "), Put(')');
   }
-  void Before(const PositionOrFlushSpec &x) {  // R1227 & R1229
-    std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) { Word("UNIT="); },
-            [&](const MsgVariable &) { Word("IOMSG="); },
-            [&](const StatVariable &) { Word("IOSTAT="); },
-            [&](const ErrLabel &) { Word("ERR="); },
-        },
+  void Before(const PositionOrFlushSpec &x) { // R1227 & R1229
+    std::visit(common::visitors{
+                   [&](const FileUnitNumber &) { Word("UNIT="); },
+                   [&](const MsgVariable &) { Word("IOMSG="); },
+                   [&](const StatVariable &) { Word("IOSTAT="); },
+                   [&](const ErrLabel &) { Word("ERR="); },
+               },
         x.u);
   }
-  void Unparse(const FlushStmt &x) {  // R1228
+  void Unparse(const FlushStmt &x) { // R1228
     Word("FLUSH ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const InquireStmt &x) {  // R1230
+  void Unparse(const InquireStmt &x) { // R1230
     Word("INQUIRE (");
     std::visit(
         common::visitors{
@@ -1381,67 +1390,67 @@ class UnparseVisitor {
         },
         x.u);
   }
-  bool Pre(const InquireSpec &x) {  // R1231
-    return std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) {
-              Word("UNIT=");
-              return true;
-            },
-            [&](const FileNameExpr &) {
-              Word("FILE=");
-              return true;
-            },
-            [&](const InquireSpec::CharVar &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const InquireSpec::IntVar &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const InquireSpec::LogVar &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const IdExpr &) {
-              Word("ID=");
-              return true;
-            },
-            [&](const ErrLabel &) {
-              Word("ERR=");
-              return true;
-            },
-        },
+  bool Pre(const InquireSpec &x) { // R1231
+    return std::visit(common::visitors{
+                          [&](const FileUnitNumber &) {
+                            Word("UNIT=");
+                            return true;
+                          },
+                          [&](const FileNameExpr &) {
+                            Word("FILE=");
+                            return true;
+                          },
+                          [&](const InquireSpec::CharVar &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const InquireSpec::IntVar &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const InquireSpec::LogVar &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const IdExpr &) {
+                            Word("ID=");
+                            return true;
+                          },
+                          [&](const ErrLabel &) {
+                            Word("ERR=");
+                            return true;
+                          },
+                      },
         x.u);
   }
 
-  void Before(const FormatStmt &) {  // R1301
+  void Before(const FormatStmt &) { // R1301
     Word("FORMAT");
   }
-  void Unparse(const format::FormatSpecification &x) {  // R1302, R1303, R1305
+  void Unparse(const format::FormatSpecification &x) { // R1302, R1303, R1305
     Put('('), Walk("", x.items, ",", x.unlimitedItems.empty() ? "" : ",");
     Walk("*(", x.unlimitedItems, ",", ")"), Put(')');
   }
-  void Unparse(const format::FormatItem &x) {  // R1304, R1306, R1321
+  void Unparse(const format::FormatItem &x) { // R1304, R1306, R1321
     if (x.repeatCount) {
       Walk(*x.repeatCount);
     }
-    std::visit(
-        common::visitors{
-            [&](const std::string &y) { PutNormalized(y); },
-            [&](const std::list<format::FormatItem> &y) {
-              Walk("(", y, ",", ")");
-            },
-            [&](const auto &y) { Walk(y); },
-        },
+    std::visit(common::visitors{
+                   [&](const std::string &y) { PutNormalized(y); },
+                   [&](const std::list<format::FormatItem> &y) {
+                     Walk("(", y, ",", ")");
+                   },
+                   [&](const auto &y) { Walk(y); },
+               },
         x.u);
   }
   void Unparse(
-      const format::IntrinsicTypeDataEditDesc &x) {  // R1307(1/2) - R1311
+      const format::IntrinsicTypeDataEditDesc &x) { // R1307(1/2) - R1311
     switch (x.kind) {
 #define FMT(x) \
-  case format::IntrinsicTypeDataEditDesc::Kind::x: Put(#x); break
+  case format::IntrinsicTypeDataEditDesc::Kind::x: \
+    Put(#x); \
+    break
       FMT(I);
       FMT(B);
       FMT(O);
@@ -1459,14 +1468,14 @@ class UnparseVisitor {
     }
     Walk(x.width), Walk(".", x.digits), Walk("E", x.exponentWidth);
   }
-  void Unparse(const format::DerivedTypeDataEditDesc &x) {  // R1307(2/2), R1312
+  void Unparse(const format::DerivedTypeDataEditDesc &x) { // R1307(2/2), R1312
     Word("DT");
     if (!x.type.empty()) {
       Put('"'), Put(x.type), Put('"');
     }
     Walk("(", x.parameters, ",", ")");
   }
-  void Unparse(const format::ControlEditDesc &x) {  // R1313, R1315-R1320
+  void Unparse(const format::ControlEditDesc &x) { // R1313, R1315-R1320
     switch (x.kind) {
     case format::ControlEditDesc::Kind::T:
       Word("T");
@@ -1492,13 +1501,17 @@ class UnparseVisitor {
       }
       Put('/');
       break;
-    case format::ControlEditDesc::Kind::Colon: Put(':'); break;
+    case format::ControlEditDesc::Kind::Colon:
+      Put(':');
+      break;
     case format::ControlEditDesc::Kind::P:
       Walk(x.count);
       Word("P");
       break;
 #define FMT(x) \
-  case format::ControlEditDesc::Kind::x: Put(#x); break
+  case format::ControlEditDesc::Kind::x: \
+    Put(#x); \
+    break
       FMT(SS);
       FMT(SP);
       FMT(S);
@@ -1513,78 +1526,79 @@ class UnparseVisitor {
       FMT(DC);
       FMT(DP);
 #undef FMT
-    case format::ControlEditDesc::Kind::Dollar: Put('$'); break;
-    case format::ControlEditDesc::Kind::Backslash: Put('\\'); break;
+    case format::ControlEditDesc::Kind::Dollar:
+      Put('$');
+      break;
+    case format::ControlEditDesc::Kind::Backslash:
+      Put('\\');
+      break;
     }
   }
 
-  void Before(const MainProgram &x) {  // R1401
+  void Before(const MainProgram &x) { // R1401
     if (!std::get<std::optional<Statement<ProgramStmt>>>(x.t)) {
       Indent();
     }
   }
-  void Before(const ProgramStmt &) {  // R1402
+  void Before(const ProgramStmt &) { // R1402
     Word("PROGRAM "), Indent();
   }
-  void Unparse(const EndProgramStmt &x) {  // R1403
+  void Unparse(const EndProgramStmt &x) { // R1403
     EndSubprogram("PROGRAM", x.v);
   }
-  void Before(const ModuleStmt &) {  // R1405
+  void Before(const ModuleStmt &) { // R1405
     Word("MODULE "), Indent();
   }
-  void Unparse(const EndModuleStmt &x) {  // R1406
+  void Unparse(const EndModuleStmt &x) { // R1406
     EndSubprogram("MODULE", x.v);
   }
-  void Unparse(const UseStmt &x) {  // R1409
+  void Unparse(const UseStmt &x) { // R1409
     Word("USE"), Walk(", ", x.nature), Put(" :: "), Walk(x.moduleName);
-    std::visit(
-        common::visitors{
-            [&](const std::list<Rename> &y) { Walk(", ", y, ", "); },
-            [&](const std::list<Only> &y) { Walk(", ONLY: ", y, ", "); },
-        },
+    std::visit(common::visitors{
+                   [&](const std::list<Rename> &y) { Walk(", ", y, ", "); },
+                   [&](const std::list<Only> &y) { Walk(", ONLY: ", y, ", "); },
+               },
         x.u);
   }
-  void Unparse(const Rename &x) {  // R1411
-    std::visit(
-        common::visitors{
-            [&](const Rename::Names &y) { Walk(y.t, " => "); },
-            [&](const Rename::Operators &y) {
-              Word("OPERATOR("), Walk(y.t, ") => OPERATOR("), Put(")");
-            },
-        },
+  void Unparse(const Rename &x) { // R1411
+    std::visit(common::visitors{
+                   [&](const Rename::Names &y) { Walk(y.t, " => "); },
+                   [&](const Rename::Operators &y) {
+                     Word("OPERATOR("), Walk(y.t, ") => OPERATOR("), Put(")");
+                   },
+               },
         x.u);
   }
-  void Unparse(const SubmoduleStmt &x) {  // R1417
+  void Unparse(const SubmoduleStmt &x) { // R1417
     Word("SUBMODULE ("), WalkTupleElements(x.t, ")"), Indent();
   }
-  void Unparse(const ParentIdentifier &x) {  // R1418
+  void Unparse(const ParentIdentifier &x) { // R1418
     Walk(std::get<Name>(x.t)), Walk(":", std::get<std::optional<Name>>(x.t));
   }
-  void Unparse(const EndSubmoduleStmt &x) {  // R1419
+  void Unparse(const EndSubmoduleStmt &x) { // R1419
     EndSubprogram("SUBMODULE", x.v);
   }
-  void Unparse(const BlockDataStmt &x) {  // R1421
+  void Unparse(const BlockDataStmt &x) { // R1421
     Word("BLOCK DATA"), Walk(" ", x.v), Indent();
   }
-  void Unparse(const EndBlockDataStmt &x) {  // R1422
+  void Unparse(const EndBlockDataStmt &x) { // R1422
     EndSubprogram("BLOCK DATA", x.v);
   }
 
-  void Unparse(const InterfaceStmt &x) {  // R1503
-    std::visit(
-        common::visitors{
-            [&](const std::optional<GenericSpec> &y) {
-              Word("INTERFACE"), Walk(" ", y);
-            },
-            [&](const Abstract &) { Word("ABSTRACT INTERFACE"); },
-        },
+  void Unparse(const InterfaceStmt &x) { // R1503
+    std::visit(common::visitors{
+                   [&](const std::optional<GenericSpec> &y) {
+                     Word("INTERFACE"), Walk(" ", y);
+                   },
+                   [&](const Abstract &) { Word("ABSTRACT INTERFACE"); },
+               },
         x.u);
     Indent();
   }
-  void Unparse(const EndInterfaceStmt &x) {  // R1504
+  void Unparse(const EndInterfaceStmt &x) { // R1504
     Outdent(), Word("END INTERFACE"), Walk(" ", x.v);
   }
-  void Unparse(const ProcedureStmt &x) {  // R1506
+  void Unparse(const ProcedureStmt &x) { // R1506
     if (std::get<ProcedureStmt::Kind>(x.t) ==
         ProcedureStmt::Kind::ModuleProcedure) {
       Word("MODULE ");
@@ -1592,7 +1606,7 @@ class UnparseVisitor {
     Word("PROCEDURE :: ");
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Before(const GenericSpec &x) {  // R1508, R1509
+  void Before(const GenericSpec &x) { // R1508, R1509
     std::visit(
         common::visitors{
             [&](const DefinedOperator &) { Word("OPERATOR("); },
@@ -1614,38 +1628,37 @@ class UnparseVisitor {
         x.u);
   }
   void Post(const GenericSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const DefinedOperator &) { Put(')'); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const DefinedOperator &) { Put(')'); },
+                   [](const auto &) {},
+               },
         x.u);
   }
-  void Unparse(const GenericStmt &x) {  // R1510
+  void Unparse(const GenericStmt &x) { // R1510
     Word("GENERIC"), Walk(", ", std::get<std::optional<AccessSpec>>(x.t));
     Put(" :: "), Walk(std::get<GenericSpec>(x.t)), Put(" => ");
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Unparse(const ExternalStmt &x) {  // R1511
+  void Unparse(const ExternalStmt &x) { // R1511
     Word("EXTERNAL :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ProcedureDeclarationStmt &x) {  // R1512
+  void Unparse(const ProcedureDeclarationStmt &x) { // R1512
     Word("PROCEDURE("), Walk(std::get<std::optional<ProcInterface>>(x.t));
     Put(')'), Walk(", ", std::get<std::list<ProcAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<std::list<ProcDecl>>(x.t), ", ");
   }
-  void Unparse(const ProcDecl &x) {  // R1515
+  void Unparse(const ProcDecl &x) { // R1515
     Walk(std::get<Name>(x.t));
     Walk(" => ", std::get<std::optional<ProcPointerInit>>(x.t));
   }
-  void Unparse(const IntrinsicStmt &x) {  // R1519
+  void Unparse(const IntrinsicStmt &x) { // R1519
     Word("INTRINSIC :: "), Walk(x.v, ", ");
   }
-  void Unparse(const FunctionReference &x) {  // R1520
+  void Unparse(const FunctionReference &x) { // R1520
     Walk(std::get<ProcedureDesignator>(x.v.t));
     Put('('), Walk(std::get<std::list<ActualArgSpec>>(x.v.t), ", "), Put(')');
   }
-  void Unparse(const CallStmt &x) {  // R1521
+  void Unparse(const CallStmt &x) { // R1521
     if (asFortran_ && x.typedCall.get()) {
       Put(' ');
       asFortran_->call(out_, *x.typedCall);
@@ -1656,39 +1669,39 @@ class UnparseVisitor {
       Word("CALL "), Walk(pd);
       if (args.empty()) {
         if (std::holds_alternative<ProcComponentRef>(pd.u)) {
-          Put("()");  // pgf90 crashes on CALL to tbp without parentheses
+          Put("()"); // pgf90 crashes on CALL to tbp without parentheses
         }
       } else {
         Walk("(", args, ", ", ")");
       }
     }
   }
-  void Unparse(const ActualArgSpec &x) {  // R1523
+  void Unparse(const ActualArgSpec &x) { // R1523
     Walk(std::get<std::optional<Keyword>>(x.t), "=");
     Walk(std::get<ActualArg>(x.t));
   }
-  void Unparse(const ActualArg::PercentRef &x) {  // R1524
+  void Unparse(const ActualArg::PercentRef &x) { // R1524
     Word("%REF("), Walk(x.v), Put(')');
   }
   void Unparse(const ActualArg::PercentVal &x) {
     Word("%VAL("), Walk(x.v), Put(')');
   }
-  void Before(const AltReturnSpec &) {  // R1525
+  void Before(const AltReturnSpec &) { // R1525
     Put('*');
   }
-  void Post(const PrefixSpec::Elemental) { Word("ELEMENTAL"); }  // R1527
+  void Post(const PrefixSpec::Elemental) { Word("ELEMENTAL"); } // R1527
   void Post(const PrefixSpec::Impure) { Word("IMPURE"); }
   void Post(const PrefixSpec::Module) { Word("MODULE"); }
   void Post(const PrefixSpec::Non_Recursive) { Word("NON_RECURSIVE"); }
   void Post(const PrefixSpec::Pure) { Word("PURE"); }
   void Post(const PrefixSpec::Recursive) { Word("RECURSIVE"); }
-  void Unparse(const FunctionStmt &x) {  // R1530
+  void Unparse(const FunctionStmt &x) { // R1530
     Walk("", std::get<std::list<PrefixSpec>>(x.t), " ", " ");
     Word("FUNCTION "), Walk(std::get<Name>(x.t)), Put("(");
     Walk(std::get<std::list<Name>>(x.t), ", "), Put(')');
     Walk(" ", std::get<std::optional<Suffix>>(x.t)), Indent();
   }
-  void Unparse(const Suffix &x) {  // R1532
+  void Unparse(const Suffix &x) { // R1532
     if (x.resultName) {
       Word("RESULT("), Walk(x.resultName), Put(')');
       Walk(" ", x.binding);
@@ -1696,10 +1709,10 @@ class UnparseVisitor {
       Walk(x.binding);
     }
   }
-  void Unparse(const EndFunctionStmt &x) {  // R1533
+  void Unparse(const EndFunctionStmt &x) { // R1533
     EndSubprogram("FUNCTION", x.v);
   }
-  void Unparse(const SubroutineStmt &x) {  // R1535
+  void Unparse(const SubroutineStmt &x) { // R1535
     Walk("", std::get<std::list<PrefixSpec>>(x.t), " ", " ");
     Word("SUBROUTINE "), Walk(std::get<Name>(x.t));
     const auto &args{std::get<std::list<DummyArg>>(x.t)};
@@ -1712,29 +1725,29 @@ class UnparseVisitor {
     }
     Indent();
   }
-  void Unparse(const EndSubroutineStmt &x) {  // R1537
+  void Unparse(const EndSubroutineStmt &x) { // R1537
     EndSubprogram("SUBROUTINE", x.v);
   }
-  void Before(const MpSubprogramStmt &) {  // R1539
+  void Before(const MpSubprogramStmt &) { // R1539
     Word("MODULE PROCEDURE "), Indent();
   }
-  void Unparse(const EndMpSubprogramStmt &x) {  // R1540
+  void Unparse(const EndMpSubprogramStmt &x) { // R1540
     EndSubprogram("PROCEDURE", x.v);
   }
-  void Unparse(const EntryStmt &x) {  // R1541
+  void Unparse(const EntryStmt &x) { // R1541
     Word("ENTRY "), Walk(std::get<Name>(x.t)), Put("(");
     Walk(std::get<std::list<DummyArg>>(x.t), ", "), Put(")");
     Walk(" ", std::get<std::optional<Suffix>>(x.t));
   }
-  void Unparse(const ReturnStmt &x) {  // R1542
+  void Unparse(const ReturnStmt &x) { // R1542
     Word("RETURN"), Walk(" ", x.v);
   }
-  void Unparse(const ContainsStmt &) {  // R1543
+  void Unparse(const ContainsStmt &) { // R1543
     Outdent();
     Word("CONTAINS");
     Indent();
   }
-  void Unparse(const StmtFunctionStmt &x) {  // R1544
+  void Unparse(const StmtFunctionStmt &x) { // R1544
     Walk(std::get<Name>(x.t)), Put('(');
     Walk(std::get<std::list<Name>>(x.t), ", "), Put(") = ");
     Walk(std::get<Scalar<Expr>>(x.t));
@@ -1745,7 +1758,7 @@ class UnparseVisitor {
     std::visit(
         common::visitors{
             [&](const std::list<CompilerDirective::IgnoreTKR> &tkr) {
-              Word("!DIR$ IGNORE_TKR");  // emitted even if tkr list is empty
+              Word("!DIR$ IGNORE_TKR"); // emitted even if tkr list is empty
               Walk(" ", tkr, ", ");
             },
             [&](const std::list<Name> &names) { Walk("!DIR$ ", names, " "); },
@@ -1766,11 +1779,10 @@ class UnparseVisitor {
   }
   // OpenMP Clauses & Directives
   void Unparse(const OmpObject &x) {
-    std::visit(
-        common::visitors{
-            [&](const Designator &y) { Walk(y); },
-            [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
-        },
+    std::visit(common::visitors{
+                   [&](const Designator &y) { Walk(y); },
+                   [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
+               },
         x.u);
   }
   void Unparse(const OmpMapType::Always &) { Word("ALWAYS,"); }
@@ -1836,23 +1848,22 @@ class UnparseVisitor {
     Put(")");
   }
   bool Pre(const OmpDependClause &x) {
-    return std::visit(
-        common::visitors{
-            [&](const OmpDependClause::Source &) {
-              Word("DEPEND(SOURCE)");
-              return false;
-            },
-            [&](const OmpDependClause::Sink &y) {
-              Word("DEPEND(SINK:");
-              Walk(y.v);
-              Put(")");
-              return false;
-            },
-            [&](const OmpDependClause::InOut &) {
-              Word("DEPEND");
-              return true;
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const OmpDependClause::Source &) {
+                            Word("DEPEND(SOURCE)");
+                            return false;
+                          },
+                          [&](const OmpDependClause::Sink &y) {
+                            Word("DEPEND(SINK:");
+                            Walk(y.v);
+                            Put(")");
+                            return false;
+                          },
+                          [&](const OmpDependClause::InOut &) {
+                            Word("DEPEND");
+                            return true;
+                          },
+                      },
         x.u);
   }
   bool Pre(const OmpDefaultClause &) {
@@ -2006,7 +2017,9 @@ class UnparseVisitor {
   }
   void Unparse(const OmpLoopDirective &x) {
     switch (x.v) {
-    case OmpLoopDirective::Directive::Distribute: Word("DISTRIBUTE "); break;
+    case OmpLoopDirective::Directive::Distribute:
+      Word("DISTRIBUTE ");
+      break;
     case OmpLoopDirective::Directive::DistributeParallelDo:
       Word("DISTRIBUTE PARALLEL DO ");
       break;
@@ -2016,13 +2029,21 @@ class UnparseVisitor {
     case OmpLoopDirective::Directive::DistributeSimd:
       Word("DISTRIBUTE SIMD ");
       break;
-    case OmpLoopDirective::Directive::Do: Word("DO "); break;
-    case OmpLoopDirective::Directive::DoSimd: Word("Do SIMD "); break;
-    case OmpLoopDirective::Directive::ParallelDo: Word("PARALLEL DO "); break;
+    case OmpLoopDirective::Directive::Do:
+      Word("DO ");
+      break;
+    case OmpLoopDirective::Directive::DoSimd:
+      Word("Do SIMD ");
+      break;
+    case OmpLoopDirective::Directive::ParallelDo:
+      Word("PARALLEL DO ");
+      break;
     case OmpLoopDirective::Directive::ParallelDoSimd:
       Word("PARALLEL DO SIMD ");
       break;
-    case OmpLoopDirective::Directive::Simd: Word("SIMD "); break;
+    case OmpLoopDirective::Directive::Simd:
+      Word("SIMD ");
+      break;
     case OmpLoopDirective::Directive::TargetParallelDo:
       Word("TARGET PARALLEL DO ");
       break;
@@ -2041,8 +2062,12 @@ class UnparseVisitor {
     case OmpLoopDirective::Directive::TargetTeamsDistributeSimd:
       Word("TARGET TEAMS DISTRIBUTE SIMD ");
       break;
-    case OmpLoopDirective::Directive::TargetSimd: Word("TARGET SIMD "); break;
-    case OmpLoopDirective::Directive::Taskloop: Word("TASKLOOP "); break;
+    case OmpLoopDirective::Directive::TargetSimd:
+      Word("TARGET SIMD ");
+      break;
+    case OmpLoopDirective::Directive::Taskloop:
+      Word("TASKLOOP ");
+      break;
     case OmpLoopDirective::Directive::TaskloopSimd:
       Word("TASKLOOP SIMD ");
       break;
@@ -2088,30 +2113,52 @@ class UnparseVisitor {
   }
   void Unparse(const OmpBlockDirective &x) {
     switch (x.v) {
-    case OmpBlockDirective::Directive::Master: Word("MASTER"); break;
-    case OmpBlockDirective::Directive::Ordered: Word("ORDERED "); break;
+    case OmpBlockDirective::Directive::Master:
+      Word("MASTER");
+      break;
+    case OmpBlockDirective::Directive::Ordered:
+      Word("ORDERED ");
+      break;
     case OmpBlockDirective::Directive::ParallelWorkshare:
       Word("PARALLEL WORKSHARE ");
       break;
-    case OmpBlockDirective::Directive::Parallel: Word("PARALLEL "); break;
-    case OmpBlockDirective::Directive::Single: Word("SINGLE "); break;
-    case OmpBlockDirective::Directive::TargetData: Word("TARGET DATA "); break;
+    case OmpBlockDirective::Directive::Parallel:
+      Word("PARALLEL ");
+      break;
+    case OmpBlockDirective::Directive::Single:
+      Word("SINGLE ");
+      break;
+    case OmpBlockDirective::Directive::TargetData:
+      Word("TARGET DATA ");
+      break;
     case OmpBlockDirective::Directive::TargetParallel:
       Word("TARGET PARALLEL ");
       break;
     case OmpBlockDirective::Directive::TargetTeams:
       Word("TARGET TEAMS ");
       break;
-    case OmpBlockDirective::Directive::Target: Word("TARGET "); break;
-    case OmpBlockDirective::Directive::Taskgroup: Word("TASKGROUP "); break;
-    case OmpBlockDirective::Directive::Task: Word("TASK "); break;
-    case OmpBlockDirective::Directive::Teams: Word("TEAMS "); break;
-    case OmpBlockDirective::Directive::Workshare: Word("WORKSHARE "); break;
+    case OmpBlockDirective::Directive::Target:
+      Word("TARGET ");
+      break;
+    case OmpBlockDirective::Directive::Taskgroup:
+      Word("TASKGROUP ");
+      break;
+    case OmpBlockDirective::Directive::Task:
+      Word("TASK ");
+      break;
+    case OmpBlockDirective::Directive::Teams:
+      Word("TEAMS ");
+      break;
+    case OmpBlockDirective::Directive::Workshare:
+      Word("WORKSHARE ");
+      break;
     }
   }
   void Unparse(const OmpMemoryClause &x) {
     switch (x.v) {
-    case OmpMemoryClause::MemoryOrder::SeqCst: Word("SEQ_CST"); break;
+    case OmpMemoryClause::MemoryOrder::SeqCst:
+      Word("SEQ_CST");
+      break;
     }
   }
   void Unparse(const OmpMemoryClauseList &x) { Walk(" ", x.v, " "); }
@@ -2233,29 +2280,28 @@ class UnparseVisitor {
   bool Pre(const OpenMPDeclarativeConstruct &x) {
     BeginOpenMP();
     Word("!$OMP ");
-    return std::visit(
-        common::visitors{
-            [&](const OpenMPDeclareReductionConstruct &) {
-              Word("DECLARE REDUCTION ");
-              return true;
-            },
-            [&](const OpenMPDeclareSimdConstruct &y) {
-              Word("DECLARE SIMD ");
-              Walk("(", std::get<std::optional<Name>>(y.t), ")");
-              Walk(std::get<OmpClauseList>(y.t));
-              Put("\n");
-              EndOpenMP();
-              return false;
-            },
-            [&](const OpenMPDeclareTargetConstruct &) {
-              Word("DECLARE TARGET ");
-              return true;
-            },
-            [&](const OpenMPThreadprivate &) {
-              Word("THREADPRIVATE (");
-              return true;
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const OpenMPDeclareReductionConstruct &) {
+                            Word("DECLARE REDUCTION ");
+                            return true;
+                          },
+                          [&](const OpenMPDeclareSimdConstruct &y) {
+                            Word("DECLARE SIMD ");
+                            Walk("(", std::get<std::optional<Name>>(y.t), ")");
+                            Walk(std::get<OmpClauseList>(y.t));
+                            Put("\n");
+                            EndOpenMP();
+                            return false;
+                          },
+                          [&](const OpenMPDeclareTargetConstruct &) {
+                            Word("DECLARE TARGET ");
+                            return true;
+                          },
+                          [&](const OpenMPThreadprivate &) {
+                            Word("THREADPRIVATE (");
+                            return true;
+                          },
+                      },
         x.u);
   }
   void Post(const OpenMPDeclarativeConstruct &) {
@@ -2268,7 +2314,9 @@ class UnparseVisitor {
   }
   void Unparse(const OmpSectionsDirective &x) {
     switch (x.v) {
-    case OmpSectionsDirective::Directive::Sections: Word("SECTIONS "); break;
+    case OmpSectionsDirective::Directive::Sections:
+      Word("SECTIONS ");
+      break;
     case OmpSectionsDirective::Directive::ParallelSections:
       Word("PARALLEL SECTIONS ");
       break;
@@ -2280,7 +2328,7 @@ class UnparseVisitor {
       Word("!$OMP SECTION");
       Put("\n");
       EndOpenMP();
-      Walk(y, "");  // y is Block
+      Walk(y, ""); // y is Block
     }
   }
   void Unparse(const OpenMPSectionsConstruct &x) {
@@ -2372,7 +2420,7 @@ class UnparseVisitor {
   }
   void Unparse(const StructureStmt &x) {
     Word("STRUCTURE ");
-    if (std::get<bool>(x.t)) {  // slashes around name
+    if (std::get<bool>(x.t)) { // slashes around name
       Put('/'), Walk(std::get<Name>(x.t)), Put('/');
       Walk(" ", std::get<std::list<EntityDecl>>(x.t), ", ");
     } else {
@@ -2409,29 +2457,28 @@ class UnparseVisitor {
 
 #define WALK_NESTED_ENUM(CLASS, ENUM) \
   void Unparse(const CLASS::ENUM &x) { Word(CLASS::EnumToString(x)); }
-  WALK_NESTED_ENUM(AccessSpec, Kind)  // R807
-  WALK_NESTED_ENUM(common, TypeParamAttr)  // R734
-  WALK_NESTED_ENUM(IntentSpec, Intent)  // R826
-  WALK_NESTED_ENUM(ImplicitStmt, ImplicitNoneNameSpec)  // R866
-  WALK_NESTED_ENUM(ConnectSpec::CharExpr, Kind)  // R1205
+  WALK_NESTED_ENUM(AccessSpec, Kind) // R807
+  WALK_NESTED_ENUM(common, TypeParamAttr) // R734
+  WALK_NESTED_ENUM(IntentSpec, Intent) // R826
+  WALK_NESTED_ENUM(ImplicitStmt, ImplicitNoneNameSpec) // R866
+  WALK_NESTED_ENUM(ConnectSpec::CharExpr, Kind) // R1205
   WALK_NESTED_ENUM(IoControlSpec::CharExpr, Kind)
   WALK_NESTED_ENUM(InquireSpec::CharVar, Kind)
   WALK_NESTED_ENUM(InquireSpec::IntVar, Kind)
   WALK_NESTED_ENUM(InquireSpec::LogVar, Kind)
-  WALK_NESTED_ENUM(ProcedureStmt, Kind)  // R1506
-  WALK_NESTED_ENUM(UseStmt, ModuleNature)  // R1410
-  WALK_NESTED_ENUM(OmpProcBindClause, Type)  // OMP PROC_BIND
-  WALK_NESTED_ENUM(OmpDefaultClause, Type)  // OMP DEFAULT
-  WALK_NESTED_ENUM(OmpDefaultmapClause, ImplicitBehavior)  // OMP DEFAULTMAP
-  WALK_NESTED_ENUM(OmpDefaultmapClause, VariableCategory)  // OMP DEFAULTMAP
-  WALK_NESTED_ENUM(OmpScheduleModifierType, ModType)  // OMP schedule-modifier
-  WALK_NESTED_ENUM(OmpLinearModifier, Type)  // OMP linear-modifier
-  WALK_NESTED_ENUM(OmpDependenceType, Type)  // OMP dependence-type
-  WALK_NESTED_ENUM(OmpMapType, Type)  // OMP map-type
-  WALK_NESTED_ENUM(OmpScheduleClause, ScheduleType)  // OMP schedule-type
-  WALK_NESTED_ENUM(
-      OmpIfClause, DirectiveNameModifier)  // OMP directive-modifier
-  WALK_NESTED_ENUM(OmpCancelType, Type)  // OMP cancel-type
+  WALK_NESTED_ENUM(ProcedureStmt, Kind) // R1506
+  WALK_NESTED_ENUM(UseStmt, ModuleNature) // R1410
+  WALK_NESTED_ENUM(OmpProcBindClause, Type) // OMP PROC_BIND
+  WALK_NESTED_ENUM(OmpDefaultClause, Type) // OMP DEFAULT
+  WALK_NESTED_ENUM(OmpDefaultmapClause, ImplicitBehavior) // OMP DEFAULTMAP
+  WALK_NESTED_ENUM(OmpDefaultmapClause, VariableCategory) // OMP DEFAULTMAP
+  WALK_NESTED_ENUM(OmpScheduleModifierType, ModType) // OMP schedule-modifier
+  WALK_NESTED_ENUM(OmpLinearModifier, Type) // OMP linear-modifier
+  WALK_NESTED_ENUM(OmpDependenceType, Type) // OMP dependence-type
+  WALK_NESTED_ENUM(OmpMapType, Type) // OMP map-type
+  WALK_NESTED_ENUM(OmpScheduleClause, ScheduleType) // OMP schedule-type
+  WALK_NESTED_ENUM(OmpIfClause, DirectiveNameModifier) // OMP directive-modifier
+  WALK_NESTED_ENUM(OmpCancelType, Type) // OMP cancel-type
 #undef WALK_NESTED_ENUM
 
   void Done() const { CHECK(indent_ == 0); }
@@ -2453,27 +2500,27 @@ class UnparseVisitor {
   void EndOpenMP() { openmpDirective_ = false; }
 
   // Call back to the traversal framework.
-  template<typename T> void Walk(const T &x) {
+  template <typename T> void Walk(const T &x) {
     Fortran::parser::Walk(x, *this);
   }
 
   // Traverse a std::optional<> value.  Emit a prefix and/or a suffix string
   // only when it contains a value.
-  template<typename A>
+  template <typename A>
   void Walk(
       const char *prefix, const std::optional<A> &x, const char *suffix = "") {
     if (x) {
       Word(prefix), Walk(*x), Word(suffix);
     }
   }
-  template<typename A>
+  template <typename A>
   void Walk(const std::optional<A> &x, const char *suffix = "") {
     return Walk("", x, suffix);
   }
 
   // Traverse a std::list<>.  Separate the elements with an optional string.
   // Emit a prefix and/or a suffix string only when the list is not empty.
-  template<typename A>
+  template <typename A>
   void Walk(const char *prefix, const std::list<A> &list,
       const char *comma = ", ", const char *suffix = "") {
     if (!list.empty()) {
@@ -2485,24 +2532,24 @@ class UnparseVisitor {
       Word(suffix);
     }
   }
-  template<typename A>
+  template <typename A>
   void Walk(const std::list<A> &list, const char *comma = ", ",
       const char *suffix = "") {
     return Walk("", list, comma, suffix);
   }
 
   // Traverse a std::tuple<>, with an optional separator.
-  template<std::size_t J = 0, typename T>
+  template <std::size_t J = 0, typename T>
   void WalkTupleElements(const T &tuple, const char *separator) {
     if (J > 0 && J < std::tuple_size_v<T>) {
-      Word(separator);  // this usage dodges "unused parameter" warning
+      Word(separator); // this usage dodges "unused parameter" warning
     }
     if constexpr (J < std::tuple_size_v<T>) {
       Walk(std::get<J>(tuple));
       WalkTupleElements<J + 1>(tuple, separator);
     }
   }
-  template<typename... A>
+  template <typename... A>
   void Walk(const std::tuple<A...> &tuple, const char *separator = "") {
     WalkTupleElements(tuple, separator);
   }
@@ -2602,4 +2649,4 @@ void Unparse(llvm::raw_ostream &out, const Program &program, Encoding encoding,
   Walk(program, visitor);
   visitor.Done();
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Parser/user-state.cpp b/lib/Parser/user-state.cpp
index 1140d40214eb..f0bc36cb6bdc 100644
--- a/lib/Parser/user-state.cpp
+++ b/lib/Parser/user-state.cpp
@@ -87,4 +87,4 @@ std::optional<DataComponentDefStmt> StructureComponents::Parse(
   }
   return defs;
 }
-}
+} // namespace Fortran::parser
diff --git a/lib/Semantics/assignment.h b/lib/Semantics/assignment.h
index ab8b4bfca1a5..65345ab7912a 100644
--- a/lib/Semantics/assignment.h
+++ b/lib/Semantics/assignment.h
@@ -21,7 +21,7 @@ struct MaskedElsewhereStmt;
 struct PointerAssignmentStmt;
 struct WhereConstructStmt;
 struct WhereStmt;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -53,8 +53,8 @@ class AssignmentChecker : public virtual BaseChecker {
   common::Indirection<AssignmentContext> context_;
 };
 
-}
+} // namespace Fortran::semantics
 
 extern template class Fortran::common::Indirection<
     Fortran::semantics::AssignmentContext>;
-#endif  // FORTRAN_SEMANTICS_ASSIGNMENT_H_
+#endif // FORTRAN_SEMANTICS_ASSIGNMENT_H_
diff --git a/lib/Semantics/attr.cpp b/lib/Semantics/attr.cpp
index e041a8f511c3..b9b0f327352d 100644
--- a/lib/Semantics/attr.cpp
+++ b/lib/Semantics/attr.cpp
@@ -21,11 +21,16 @@ void Attrs::CheckValid(const Attrs &allowed) const {
 
 std::string AttrToString(Attr attr) {
   switch (attr) {
-  case Attr::BIND_C: return "BIND(C)";
-  case Attr::INTENT_IN: return "INTENT(IN)";
-  case Attr::INTENT_INOUT: return "INTENT(INOUT)";
-  case Attr::INTENT_OUT: return "INTENT(OUT)";
-  default: return EnumToString(attr);
+  case Attr::BIND_C:
+    return "BIND(C)";
+  case Attr::INTENT_IN:
+    return "INTENT(IN)";
+  case Attr::INTENT_INOUT:
+    return "INTENT(INOUT)";
+  case Attr::INTENT_OUT:
+    return "INTENT(OUT)";
+  default:
+    return EnumToString(attr);
   }
 }
 
@@ -48,4 +53,4 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Attrs &attrs) {
   }
   return o;
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/canonicalize-do.cpp b/lib/Semantics/canonicalize-do.cpp
index b50c0ff974af..8d27d6344423 100644
--- a/lib/Semantics/canonicalize-do.cpp
+++ b/lib/Semantics/canonicalize-do.cpp
@@ -18,8 +18,8 @@ class CanonicalizationOfDoLoops {
   };
 
 public:
-  template<typename T> bool Pre(T &) { return true; }
-  template<typename T> void Post(T &) {}
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
   void Post(Block &block) {
     std::vector<LabelInfo> stack;
     for (auto i{block.begin()}, end{block.end()}; i != end; ++i) {
@@ -30,62 +30,58 @@ class CanonicalizationOfDoLoops {
                 // Labels on end-stmt of constructs are accepted by f18 as an
                 // extension.
                 [&](common::Indirection<AssociateConstruct> &associate) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndAssociateStmt>>(
-                          associate.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndAssociateStmt>>(associate.value().t));
                 },
                 [&](common::Indirection<BlockConstruct> &blockConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndBlockStmt>>(
-                          blockConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndBlockStmt>>(blockConstruct.value().t));
                 },
                 [&](common::Indirection<ChangeTeamConstruct> &changeTeam) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndChangeTeamStmt>>(
-                          changeTeam.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndChangeTeamStmt>>(changeTeam.value().t));
                 },
                 [&](common::Indirection<CriticalConstruct> &critical) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndCriticalStmt>>(critical.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndCriticalStmt>>(critical.value().t));
                 },
                 [&](common::Indirection<DoConstruct> &doConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndDoStmt>>(doConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndDoStmt>>(doConstruct.value().t));
                 },
                 [&](common::Indirection<IfConstruct> &ifConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndIfStmt>>(ifConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndIfStmt>>(ifConstruct.value().t));
                 },
                 [&](common::Indirection<CaseConstruct> &caseConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndSelectStmt>>(
-                          caseConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndSelectStmt>>(caseConstruct.value().t));
                 },
                 [&](common::Indirection<SelectRankConstruct> &selectRank) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndSelectStmt>>(selectRank.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndSelectStmt>>(selectRank.value().t));
                 },
                 [&](common::Indirection<SelectTypeConstruct> &selectType) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndSelectStmt>>(selectType.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndSelectStmt>>(selectType.value().t));
                 },
                 [&](common::Indirection<ForallConstruct> &forall) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndForallStmt>>(forall.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndForallStmt>>(forall.value().t));
                 },
                 [&](common::Indirection<WhereConstruct> &where) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndWhereStmt>>(where.value().t));
                 },
                 [&](Statement<common::Indirection<LabelDoStmt>> &labelDoStmt) {
-                  auto &label{std::get<Label>(labelDoStmt.statement.value().t)};
-                  stack.push_back(LabelInfo{i, label});
+          auto &label{std::get<Label>(labelDoStmt.statement.value().t)};
+          stack.push_back(LabelInfo{i, label});
                 },
                 [&](Statement<common::Indirection<EndDoStmt>> &endDoStmt) {
-                  CanonicalizeIfMatch(block, stack, i, endDoStmt);
+          CanonicalizeIfMatch(block, stack, i, endDoStmt);
                 },
                 [&](Statement<ActionStmt> &actionStmt) {
-                  CanonicalizeIfMatch(block, stack, i, actionStmt);
+          CanonicalizeIfMatch(block, stack, i, actionStmt);
                 },
             },
             executableConstruct->u);
@@ -94,7 +90,7 @@ class CanonicalizationOfDoLoops {
   }
 
 private:
-  template<typename T>
+  template <typename T>
   void CanonicalizeIfMatch(Block &originalBlock, std::vector<LabelInfo> &stack,
       Block::iterator &i, Statement<T> &statement) {
     if (!stack.empty() && statement.label &&
@@ -140,4 +136,4 @@ bool CanonicalizeDo(Program &program) {
   return true;
 }
 
-}
+} // namespace Fortran::parser
diff --git a/lib/Semantics/canonicalize-do.h b/lib/Semantics/canonicalize-do.h
index 9de5b52c5ed8..bbdad8cedc23 100644
--- a/lib/Semantics/canonicalize-do.h
+++ b/lib/Semantics/canonicalize-do.h
@@ -14,6 +14,6 @@
 namespace Fortran::parser {
 struct Program;
 bool CanonicalizeDo(Program &program);
-}
+} // namespace Fortran::parser
 
-#endif  // FORTRAN_SEMANTICS_CANONICALIZE_DO_H_
+#endif // FORTRAN_SEMANTICS_CANONICALIZE_DO_H_
diff --git a/lib/Semantics/canonicalize-omp.cpp b/lib/Semantics/canonicalize-omp.cpp
index 9588b037aef0..dc8a2a4d93af 100644
--- a/lib/Semantics/canonicalize-omp.cpp
+++ b/lib/Semantics/canonicalize-omp.cpp
@@ -22,8 +22,8 @@ using namespace parser::literals;
 
 class CanonicalizationOfOmp {
 public:
-  template<typename T> bool Pre(T &) { return true; }
-  template<typename T> void Post(T &) {}
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
   CanonicalizationOfOmp(parser::Messages &messages) : messages_{messages} {}
 
   void Post(parser::Block &block) {
@@ -43,11 +43,11 @@ class CanonicalizationOfOmp {
             "loop construct"_err_en_US,
             parser::ToUpperCaseLetters(dir.source.ToString()));
       }
-    }  // Block list
+    } // Block list
   }
 
 private:
-  template<typename T> T *GetConstructIf(parser::ExecutionPartConstruct &x) {
+  template <typename T> T *GetConstructIf(parser::ExecutionPartConstruct &x) {
     if (auto *y{std::get_if<parser::ExecutableConstruct>(&x.u)}) {
       if (auto *z{std::get_if<common::Indirection<T>>(&y->u)}) {
         return &z->value();
@@ -98,7 +98,7 @@ class CanonicalizationOfOmp {
               "DO loop after the %s directive must have loop control"_err_en_US,
               parser::ToUpperCaseLetters(dir.source.ToString()));
         }
-        return;  // found do-loop
+        return; // found do-loop
       }
     }
     messages_.Say(dir.source,
@@ -114,4 +114,4 @@ bool CanonicalizeOmp(parser::Messages &messages, parser::Program &program) {
   Walk(program, omp);
   return !messages.AnyFatalError();
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/canonicalize-omp.h b/lib/Semantics/canonicalize-omp.h
index 6531851a6675..c45d6bbbf906 100644
--- a/lib/Semantics/canonicalize-omp.h
+++ b/lib/Semantics/canonicalize-omp.h
@@ -12,10 +12,10 @@
 namespace Fortran::parser {
 struct Program;
 class Messages;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 bool CanonicalizeOmp(parser::Messages &messages, parser::Program &program);
 }
 
-#endif  // FORTRAN_SEMANTICS_CANONICALIZE_OMP_H_
+#endif // FORTRAN_SEMANTICS_CANONICALIZE_OMP_H_
diff --git a/lib/Semantics/check-allocate.cpp b/lib/Semantics/check-allocate.cpp
index fdba6151d343..456d5949a3a2 100644
--- a/lib/Semantics/check-allocate.cpp
+++ b/lib/Semantics/check-allocate.cpp
@@ -24,7 +24,7 @@ struct AllocateCheckerInfo {
   std::optional<evaluate::DynamicType> sourceExprType;
   std::optional<parser::CharBlock> sourceExprLoc;
   std::optional<parser::CharBlock> typeSpecLoc;
-  int sourceExprRank{0};  // only valid if gotMold || gotSource
+  int sourceExprRank{0}; // only valid if gotMold || gotSource
   bool gotStat{false};
   bool gotMsg{false};
   bool gotTypeSpec{false};
@@ -36,16 +36,16 @@ class AllocationCheckerHelper {
 public:
   AllocationCheckerHelper(
       const parser::Allocation &alloc, AllocateCheckerInfo &info)
-    : allocateInfo_{info}, allocateObject_{std::get<parser::AllocateObject>(
-                               alloc.t)},
-      name_{parser::GetLastName(allocateObject_)},
-      symbol_{name_.symbol ? &name_.symbol->GetUltimate() : nullptr},
-      type_{symbol_ ? symbol_->GetType() : nullptr},
-      allocateShapeSpecRank_{ShapeSpecRank(alloc)}, rank_{symbol_
-                                                            ? symbol_->Rank()
-                                                            : 0},
-      allocateCoarraySpecRank_{CoarraySpecRank(alloc)},
-      corank_{symbol_ ? symbol_->Corank() : 0} {}
+      : allocateInfo_{info}, allocateObject_{std::get<parser::AllocateObject>(
+                                 alloc.t)},
+        name_{parser::GetLastName(allocateObject_)},
+        symbol_{name_.symbol ? &name_.symbol->GetUltimate() : nullptr},
+        type_{symbol_ ? symbol_->GetType() : nullptr},
+        allocateShapeSpecRank_{ShapeSpecRank(alloc)}, rank_{symbol_
+                                                              ? symbol_->Rank()
+                                                              : 0},
+        allocateCoarraySpecRank_{CoarraySpecRank(alloc)},
+        corank_{symbol_ ? symbol_->Corank() : 0} {}
 
   bool RunChecks(SemanticsContext &context);
 
@@ -102,7 +102,7 @@ class AllocationCheckerHelper {
 static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
     const parser::AllocateStmt &allocateStmt, SemanticsContext &context) {
   AllocateCheckerInfo info;
-  bool stopCheckingAllocate{false};  // for errors that would lead to ambiguity
+  bool stopCheckingAllocate{false}; // for errors that would lead to ambiguity
   if (const auto &typeSpec{
           std::get<std::optional<parser::TypeSpec>>(allocateStmt.t)}) {
     info.typeSpec = typeSpec->declTypeSpec;
@@ -134,14 +134,14 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
               std::visit(
                   common::visitors{
                       [&](const parser::StatVariable &) {
-                        if (info.gotStat) {  // C943
+                        if (info.gotStat) { // C943
                           context.Say(
                               "STAT may not be duplicated in a ALLOCATE statement"_err_en_US);
                         }
                         info.gotStat = true;
                       },
                       [&](const parser::MsgVariable &) {
-                        if (info.gotMsg) {  // C943
+                        if (info.gotMsg) { // C943
                           context.Say(
                               "ERRMSG may not be duplicated in a ALLOCATE statement"_err_en_US);
                         }
@@ -151,12 +151,12 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
                   statOrErr.u);
             },
             [&](const parser::AllocOpt::Source &source) {
-              if (info.gotSource) {  // C943
+              if (info.gotSource) { // C943
                 context.Say(
                     "SOURCE may not be duplicated in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
               }
-              if (info.gotMold || info.gotTypeSpec) {  // C944
+              if (info.gotMold || info.gotTypeSpec) { // C944
                 context.Say(
                     "At most one of source-expr and type-spec may appear in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
@@ -165,12 +165,12 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
               info.gotSource = true;
             },
             [&](const parser::AllocOpt::Mold &mold) {
-              if (info.gotMold) {  // C943
+              if (info.gotMold) { // C943
                 context.Say(
                     "MOLD may not be duplicated in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
               }
-              if (info.gotSource || info.gotTypeSpec) {  // C944
+              if (info.gotSource || info.gotTypeSpec) { // C944
                 context.Say(
                     "At most one of source-expr and type-spec may appear in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
@@ -227,7 +227,7 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
           }
         }
       }
-      if (info.gotSource) {  // C1594(6) - SOURCE= restrictions when pure
+      if (info.gotSource) { // C1594(6) - SOURCE= restrictions when pure
         const Scope &scope{context.FindScope(at)};
         if (FindPureProcedureContaining(scope)) {
           parser::ContextualMessages messages{at, &context.messages()};
@@ -341,7 +341,7 @@ static bool HaveSameAssumedTypeParameters(
     // type1 or do not exist in type1
     return type1AssumedParametersCount == type2AssumedParametersCount;
   }
-  return true;  // other intrinsic types have no length type parameters
+  return true; // other intrinsic types have no length type parameters
 }
 
 static std::optional<std::int64_t> GetTypeParameterInt64Value(
@@ -409,7 +409,7 @@ bool AllocationCheckerHelper::RunChecks(SemanticsContext &context) {
     CHECK(context.AnyFatalError());
     return false;
   }
-  if (!IsVariableName(*symbol_)) {  // C932 pre-requisite
+  if (!IsVariableName(*symbol_)) { // C932 pre-requisite
     context.Say(name_.source,
         "Name in ALLOCATE statement must be a variable name"_err_en_US);
     return false;
@@ -422,7 +422,7 @@ bool AllocationCheckerHelper::RunChecks(SemanticsContext &context) {
     return false;
   }
   GatherAllocationBasicInfo();
-  if (!IsAllocatableOrPointer(*symbol_)) {  // C932
+  if (!IsAllocatableOrPointer(*symbol_)) { // C932
     context.Say(name_.source,
         "Entity in ALLOCATE statement must have the ALLOCATABLE or POINTER attribute"_err_en_US);
     return false;
@@ -596,7 +596,7 @@ bool AllocationCheckerHelper::RunCoarrayRelatedChecks(
         return false;
       }
     }
-  } else {  // Not a coarray
+  } else { // Not a coarray
     if (hasAllocateCoarraySpec()) {
       // C941
       context.Say(name_.source,
@@ -622,4 +622,4 @@ void AllocateChecker::Leave(const parser::AllocateStmt &allocateStmt) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-allocate.h b/lib/Semantics/check-allocate.h
index 2d7405d3e21d..e3f7f07bca5b 100644
--- a/lib/Semantics/check-allocate.h
+++ b/lib/Semantics/check-allocate.h
@@ -24,5 +24,5 @@ class AllocateChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
diff --git a/lib/Semantics/check-arithmeticif.cpp b/lib/Semantics/check-arithmeticif.cpp
index efa711319333..e8ce6aab60c9 100644
--- a/lib/Semantics/check-arithmeticif.cpp
+++ b/lib/Semantics/check-arithmeticif.cpp
@@ -42,4 +42,4 @@ void ArithmeticIfStmtChecker::Leave(
   // statements and in the same inclusive scope.
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-arithmeticif.h b/lib/Semantics/check-arithmeticif.h
index f1b50e10d7d4..1d156763e551 100644
--- a/lib/Semantics/check-arithmeticif.h
+++ b/lib/Semantics/check-arithmeticif.h
@@ -24,5 +24,5 @@ class ArithmeticIfStmtChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
diff --git a/lib/Semantics/check-call.cpp b/lib/Semantics/check-call.cpp
index 88997874bb97..163944533eac 100644
--- a/lib/Semantics/check-call.cpp
+++ b/lib/Semantics/check-call.cpp
@@ -182,13 +182,13 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       dummy.attrs.test(characteristics::DummyDataObject::Attr::Value)};
 
   if (actualIsPolymorphic && dummyIsPolymorphic &&
-      actualIsCoindexed) {  // 15.5.2.4(2)
+      actualIsCoindexed) { // 15.5.2.4(2)
     messages.Say(
         "Coindexed polymorphic object may not be associated with a polymorphic %s"_err_en_US,
         dummyName);
   }
   if (actualIsPolymorphic && !dummyIsPolymorphic &&
-      actualIsAssumedSize) {  // 15.5.2.4(2)
+      actualIsAssumedSize) { // 15.5.2.4(2)
     messages.Say(
         "Assumed-size polymorphic array may not be associated with a monomorphic %s"_err_en_US,
         dummyName);
@@ -202,7 +202,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       actualFirstSymbol && actualFirstSymbol->attrs().test(Attr::VOLATILE)};
   if (const auto *derived{evaluate::GetDerivedTypeSpec(actualType.type())}) {
     if (dummy.type.type().IsAssumedType()) {
-      if (!derived->parameters().empty()) {  // 15.5.2.4(2)
+      if (!derived->parameters().empty()) { // 15.5.2.4(2)
         messages.Say(
             "Actual argument associated with TYPE(*) %s may not have a parameterized derived type"_err_en_US,
             dummyName);
@@ -210,7 +210,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       if (const Symbol *
           tbp{FindImmediateComponent(*derived, [](const Symbol &symbol) {
             return symbol.has<ProcBindingDetails>();
-          })}) {  // 15.5.2.4(2)
+          })}) { // 15.5.2.4(2)
         evaluate::SayWithDeclaration(messages, *tbp,
             "Actual argument associated with TYPE(*) %s may not have type-bound procedure '%s'"_err_en_US,
             dummyName, tbp->name());
@@ -218,7 +218,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       if (const Symbol *
           finalizer{FindImmediateComponent(*derived, [](const Symbol &symbol) {
             return symbol.has<FinalProcDetails>();
-          })}) {  // 15.5.2.4(2)
+          })}) { // 15.5.2.4(2)
         evaluate::SayWithDeclaration(messages, *finalizer,
             "Actual argument associated with TYPE(*) %s may not have FINAL subroutine '%s'"_err_en_US,
             dummyName, finalizer->name());
@@ -227,13 +227,13 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
     if (actualIsCoindexed) {
       if (dummy.intent != common::Intent::In && !dummyIsValue) {
         if (auto bad{
-                FindAllocatableUltimateComponent(*derived)}) {  // 15.5.2.4(6)
+                FindAllocatableUltimateComponent(*derived)}) { // 15.5.2.4(6)
           evaluate::SayWithDeclaration(messages, *bad,
               "Coindexed actual argument with ALLOCATABLE ultimate component '%s' must be associated with a %s with VALUE or INTENT(IN) attributes"_err_en_US,
               bad.BuildResultDesignatorName(), dummyName);
         }
       }
-      if (auto coarrayRef{evaluate::ExtractCoarrayRef(actual)}) {  // C1537
+      if (auto coarrayRef{evaluate::ExtractCoarrayRef(actual)}) { // C1537
         const Symbol &coarray{coarrayRef->GetLastSymbol()};
         if (const DeclTypeSpec * type{coarray.GetType()}) {
           if (const DerivedTypeSpec * derived{type->AsDerived()}) {
@@ -246,7 +246,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
         }
       }
     }
-    if (actualIsVolatile != dummyIsVolatile) {  // 15.5.2.4(22)
+    if (actualIsVolatile != dummyIsVolatile) { // 15.5.2.4(22)
       if (auto bad{semantics::FindCoarrayUltimateComponent(*derived)}) {
         evaluate::SayWithDeclaration(messages, *bad,
             "VOLATILE attribute must match for %s when actual argument has a coarray ultimate component '%s'"_err_en_US,
@@ -310,7 +310,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
   }
   if (actualLastObject && actualLastObject->IsCoarray() &&
       IsAllocatable(*actualLastSymbol) &&
-      dummy.intent == common::Intent::Out) {  // C846
+      dummy.intent == common::Intent::Out) { // C846
     messages.Say(
         "ALLOCATABLE coarray '%s' may not be associated with INTENT(OUT) %s"_err_en_US,
         actualLastSymbol->name(), dummyName);
@@ -328,7 +328,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
     reason = "VOLATILE";
   }
   if (reason && scope) {
-    bool vectorSubscriptIsOk{isElemental || dummyIsValue};  // 15.5.2.4(21)
+    bool vectorSubscriptIsOk{isElemental || dummyIsValue}; // 15.5.2.4(21)
     if (auto why{WhyNotModifiable(
             messages.at(), actual, *scope, vectorSubscriptIsOk)}) {
       if (auto *msg{messages.Say(
@@ -351,7 +351,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       characteristics::TypeAndShape::Attr::AssumedShape)};
   if ((actualIsAsynchronous || actualIsVolatile) &&
       (dummyIsAsynchronous || dummyIsVolatile) && !dummyIsValue) {
-    if (actualIsCoindexed) {  // C1538
+    if (actualIsCoindexed) { // C1538
       messages.Say(
           "Coindexed ASYNCHRONOUS or VOLATILE actual argument may not be associated with %s with ASYNCHRONOUS or VOLATILE attributes unless VALUE"_err_en_US,
           dummyName);
@@ -359,7 +359,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
     if (actualRank > 0 && !actualIsContiguous) {
       if (dummyIsContiguous ||
           !(dummyIsAssumedShape || dummyIsAssumedRank ||
-              (actualIsPointer && dummyIsPointer))) {  // C1539 & C1540
+              (actualIsPointer && dummyIsPointer))) { // C1539 & C1540
         messages.Say(
             "ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous %s"_err_en_US,
             dummyName);
@@ -509,11 +509,11 @@ static void CheckProcedureArg(evaluate::ActualArgument &arg,
           argInterface.attrs.reset(characteristics::Procedure::Attr::Elemental);
         } else if (argInterface.attrs.test(
                        characteristics::Procedure::Attr::Elemental)) {
-          if (argProcSymbol) {  // C1533
+          if (argProcSymbol) { // C1533
             evaluate::SayWithDeclaration(messages, *argProcSymbol,
                 "Non-intrinsic ELEMENTAL procedure '%s' may not be passed as an actual argument"_err_en_US,
                 argProcSymbol->name());
-            return;  // avoid piling on with checks below
+            return; // avoid piling on with checks below
           } else {
             argInterface.attrs.reset(
                 characteristics::Procedure::Attr::NullPointer);
@@ -529,7 +529,7 @@ static void CheckProcedureArg(evaluate::ActualArgument &arg,
                 "Actual argument procedure has interface incompatible with %s"_err_en_US,
                 dummyName);
           }
-        } else {  // 15.5.2.9(2,3)
+        } else { // 15.5.2.9(2,3)
           if (interface.IsSubroutine() && argInterface.IsFunction()) {
             messages.Say(
                 "Actual argument associated with procedure %s is a function but must be a subroutine"_err_en_US,
@@ -567,7 +567,7 @@ static void CheckProcedureArg(evaluate::ActualArgument &arg,
               "Actual argument associated with procedure pointer %s must be a POINTER unless INTENT(IN)"_err_en_US,
               dummyName);
         }
-      } else {  // 15.5.2.9(4) -- dummy procedure is not POINTER
+      } else { // 15.5.2.9(4) -- dummy procedure is not POINTER
         if (!argProcDesignator) {
           messages.Say(
               "Actual argument associated with non-POINTER procedure %s must be a procedure (and not a procedure pointer)"_err_en_US,
@@ -618,7 +618,7 @@ static void CheckExplicitInterfaceArg(evaluate::ActualArgument &arg,
               } else if (const auto *details{
                              assumed.detailsIf<ObjectEntityDetails>()}) {
                 if (!(details->IsAssumedShape() || details->IsAssumedRank())) {
-                  messages.Say(  // C711
+                  messages.Say( // C711
                       "Assumed-type '%s' must be either assumed shape or assumed rank to be associated with assumed-type %s"_err_en_US,
                       assumed.name(), dummyName);
                 }
@@ -753,4 +753,4 @@ void CheckArguments(const characteristics::Procedure &proc,
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-call.h b/lib/Semantics/check-call.h
index 08bed15cb7ec..be503e49e5cc 100644
--- a/lib/Semantics/check-call.h
+++ b/lib/Semantics/check-call.h
@@ -16,7 +16,7 @@
 namespace Fortran::parser {
 class Messages;
 class ContextualMessages;
-}
+} // namespace Fortran::parser
 namespace Fortran::evaluate::characteristics {
 struct Procedure;
 }
@@ -44,5 +44,5 @@ parser::Messages CheckExplicitInterface(
 // Checks actual arguments for the purpose of resolving a generic interface.
 bool CheckInterfaceForGeneric(const evaluate::characteristics::Procedure &,
     evaluate::ActualArguments &, const evaluate::FoldingContext &);
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/lib/Semantics/check-case.cpp b/lib/Semantics/check-case.cpp
index c0f957a83728..3f1586dfd8fd 100644
--- a/lib/Semantics/check-case.cpp
+++ b/lib/Semantics/check-case.cpp
@@ -100,26 +100,25 @@ template <typename T> class CaseValues {
 
   using PairOfValues = std::pair<std::optional<Value>, std::optional<Value>>;
   PairOfValues ComputeBounds(const parser::CaseValueRange &range) {
-    return std::visit(
-        common::visitors{
-            [&](const parser::CaseValue &x) {
-              auto value{GetValue(x)};
-              return PairOfValues{value, value};
-            },
-            [&](const parser::CaseValueRange::Range &x) {
-              std::optional<Value> lo, hi;
-              if (x.lower) {
-                lo = GetValue(*x.lower);
-              }
-              if (x.upper) {
-                hi = GetValue(*x.upper);
-              }
-              if ((x.lower && !lo) || (x.upper && !hi)) {
-                return PairOfValues{}; // error case
-              }
-              return PairOfValues{std::move(lo), std::move(hi)};
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const parser::CaseValue &x) {
+                            auto value{GetValue(x)};
+                            return PairOfValues{value, value};
+                          },
+                          [&](const parser::CaseValueRange::Range &x) {
+                            std::optional<Value> lo, hi;
+                            if (x.lower) {
+                              lo = GetValue(*x.lower);
+                            }
+                            if (x.upper) {
+                              hi = GetValue(*x.upper);
+                            }
+                            if ((x.lower && !lo) || (x.upper && !hi)) {
+                              return PairOfValues{}; // error case
+                            }
+                            return PairOfValues{std::move(lo), std::move(hi)};
+                          },
+                      },
         range.u);
   }
 
diff --git a/lib/Semantics/check-coarray.cpp b/lib/Semantics/check-coarray.cpp
index f070ebc61695..a9d649ffff47 100644
--- a/lib/Semantics/check-coarray.cpp
+++ b/lib/Semantics/check-coarray.cpp
@@ -21,12 +21,12 @@ class CriticalBodyEnforce {
 public:
   CriticalBodyEnforce(
       SemanticsContext &context, parser::CharBlock criticalSourcePosition)
-    : context_{context}, criticalSourcePosition_{criticalSourcePosition} {}
+      : context_{context}, criticalSourcePosition_{criticalSourcePosition} {}
   std::set<parser::Label> labels() { return labels_; }
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
 
-  template<typename T> bool Pre(const parser::Statement<T> &statement) {
+  template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     if (statement.label.has_value()) {
       labels_.insert(*statement.label);
@@ -62,11 +62,11 @@ class CriticalBodyEnforce {
   parser::CharBlock criticalSourcePosition_;
 };
 
-template<typename T>
+template <typename T>
 static void CheckTeamType(SemanticsContext &context, const T &x) {
   if (const auto *expr{GetExpr(x)}) {
     if (!IsTeamType(evaluate::GetDerivedTypeSpec(expr->GetType()))) {
-      context.Say(parser::FindSourceLocation(x),  // C1114
+      context.Say(parser::FindSourceLocation(x), // C1114
           "Team value must be of type TEAM_TYPE from module ISO_FORTRAN_ENV"_err_en_US);
     }
   }
@@ -118,10 +118,10 @@ void CoarrayChecker::CheckNamesAreDistinct(
     const auto &selector{std::get<parser::Selector>(assoc.t)};
     const auto &declName{std::get<parser::Name>(decl.t)};
     if (context_.HasError(declName)) {
-      continue;  // already reported an error about this name
+      continue; // already reported an error about this name
     }
     if (auto *prev{getPreviousUse(declName)}) {
-      Say2(declName.source,  // C1113
+      Say2(declName.source, // C1113
           "Coarray '%s' was already used as a selector or coarray in this statement"_err_en_US,
           *prev, "Previous use of '%s'"_en_US);
     }
@@ -129,7 +129,7 @@ void CoarrayChecker::CheckNamesAreDistinct(
     const parser::Name *name{parser::Unwrap<parser::Name>(selector)};
     if (name) {
       if (auto *prev{getPreviousUse(*name)}) {
-        Say2(name->source,  // C1113, C1115
+        Say2(name->source, // C1113, C1115
             "Selector '%s' was already used as a selector or coarray in this statement"_err_en_US,
             *prev, "Previous use of '%s'"_en_US);
       }
@@ -143,4 +143,4 @@ void CoarrayChecker::Say2(const parser::CharBlock &name1,
   context_.Say(name1, std::move(msg1), name1)
       .Attach(name2, std::move(msg2), name2);
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-coarray.h b/lib/Semantics/check-coarray.h
index dd34f0ae3641..2e91c7b259d6 100644
--- a/lib/Semantics/check-coarray.h
+++ b/lib/Semantics/check-coarray.h
@@ -21,7 +21,7 @@ struct FormTeamStmt;
 struct ImageSelectorSpec;
 struct SyncTeamStmt;
 struct TeamValue;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -42,5 +42,5 @@ class CoarrayChecker : public virtual BaseChecker {
   void Say2(const parser::CharBlock &, parser::MessageFixedText &&,
       const parser::CharBlock &, parser::MessageFixedText &&);
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_COARRAY_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_COARRAY_H_
diff --git a/lib/Semantics/check-data.cpp b/lib/Semantics/check-data.cpp
index e7d599eeebe5..6178eb7360ca 100644
--- a/lib/Semantics/check-data.cpp
+++ b/lib/Semantics/check-data.cpp
@@ -18,7 +18,7 @@ void DataChecker::Leave(const parser::DataStmtConstant &dataConst) {
       const parser::Expr &parsedExpr{
           std::get<parser::ComponentDataSource>(component.t).v.value()};
       if (const auto *expr{GetExpr(parsedExpr)}) {
-        if (!evaluate::IsConstantExpr(*expr)) {  // C884
+        if (!evaluate::IsConstantExpr(*expr)) { // C884
           context_.Say(parsedExpr.source,
               "Structure constructor in data value must be a constant expression"_err_en_US);
         }
@@ -38,7 +38,7 @@ void DataChecker::Leave(const parser::DataStmtRepeat &dataRepeat) {
         auto expr{
             evaluate::Fold(context_.foldingContext(), std::move(checked))};
         if (auto i64{ToInt64(expr)}) {
-          if (*i64 < 0) {  // C882
+          if (*i64 < 0) { // C882
             context_.Say(designator->source,
                 "Repeat count for data value must not be negative"_err_en_US);
           }
@@ -47,4 +47,4 @@ void DataChecker::Leave(const parser::DataStmtRepeat &dataRepeat) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-data.h b/lib/Semantics/check-data.h
index 80b8edc7f713..5d66c8e74e55 100644
--- a/lib/Semantics/check-data.h
+++ b/lib/Semantics/check-data.h
@@ -24,5 +24,5 @@ class DataChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_DATA_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_DATA_H_
diff --git a/lib/Semantics/check-deallocate.cpp b/lib/Semantics/check-deallocate.cpp
index 646251427db8..92e197bbb322 100644
--- a/lib/Semantics/check-deallocate.cpp
+++ b/lib/Semantics/check-deallocate.cpp
@@ -26,7 +26,7 @@ void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
               } else if (!IsVariableName(*symbol)) {
                 context_.Say(name.source,
                     "name in DEALLOCATE statement must be a variable name"_err_en_US);
-              } else if (!IsAllocatableOrPointer(*symbol)) {  // C932
+              } else if (!IsAllocatableOrPointer(*symbol)) { // C932
                 context_.Say(name.source,
                     "name in DEALLOCATE statement must have the ALLOCATABLE or POINTER attribute"_err_en_US);
               } else {
@@ -37,7 +37,7 @@ void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
               evaluate::ExpressionAnalyzer analyzer{context_};
               if (MaybeExpr checked{analyzer.Analyze(structureComponent)}) {
                 if (!IsAllocatableOrPointer(
-                        *structureComponent.component.symbol)) {  // C932
+                        *structureComponent.component.symbol)) { // C932
                   context_.Say(structureComponent.component.source,
                       "component in DEALLOCATE statement must have the ALLOCATABLE or POINTER attribute"_err_en_US);
                 }
@@ -69,4 +69,4 @@ void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
         deallocOpt.u);
   }
 }
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-deallocate.h b/lib/Semantics/check-deallocate.h
index f47283a22c29..6aafb87a7479 100644
--- a/lib/Semantics/check-deallocate.h
+++ b/lib/Semantics/check-deallocate.h
@@ -24,5 +24,5 @@ class DeallocateChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index cb6888610b28..15dd78270e5d 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -44,7 +44,7 @@ class CheckHelper {
   void Check(const Scope &);
 
 private:
-  template<typename A> void CheckSpecExpr(const A &x) {
+  template <typename A> void CheckSpecExpr(const A &x) {
     if (symbolBeingChecked_ && IsSaved(*symbolBeingChecked_)) {
       if (!evaluate::IsConstantExpr(x)) {
         messages_.Say(
@@ -55,12 +55,12 @@ class CheckHelper {
       evaluate::CheckSpecificationExpr(x, messages_, DEREF(scope_));
     }
   }
-  template<typename A> void CheckSpecExpr(const std::optional<A> &x) {
+  template <typename A> void CheckSpecExpr(const std::optional<A> &x) {
     if (x) {
       CheckSpecExpr(*x);
     }
   }
-  template<typename A> void CheckSpecExpr(A &x) {
+  template <typename A> void CheckSpecExpr(A &x) {
     x = Fold(foldingContext_, std::move(x));
     const A &constx{x};
     CheckSpecExpr(constx);
@@ -102,7 +102,7 @@ class CheckHelper {
   bool InFunction() const {
     return innermostSymbol_ && IsFunction(*innermostSymbol_);
   }
-  template<typename... A>
+  template <typename... A>
   void SayWithDeclaration(const Symbol &symbol, A &&... x) {
     if (parser::Message * msg{messages_.Say(std::forward<A>(x)...)}) {
       if (messages_.at().begin() != symbol.name().begin()) {
@@ -124,7 +124,7 @@ class CheckHelper {
 
 void CheckHelper::Check(const ParamValue &value, bool canBeAssumed) {
   if (value.isAssumed()) {
-    if (!canBeAssumed) {  // C795, C721, C726
+    if (!canBeAssumed) { // C795, C721, C726
       messages_.Say(
           "An assumed (*) type parameter may be used only for a (non-statement"
           " function) dummy argument, associate name, named constant, or"
@@ -165,7 +165,7 @@ void CheckHelper::Check(const Symbol &symbol) {
     CheckVolatile(symbol, isAssociated, derived);
   }
   if (isAssociated) {
-    return;  // only care about checking VOLATILE on associated symbols
+    return; // only care about checking VOLATILE on associated symbols
   }
   if (IsPointer(symbol)) {
     CheckPointer(symbol);
@@ -208,28 +208,28 @@ void CheckHelper::Check(const Symbol &symbol) {
       }
     }
   }
-  if (type) {  // Section 7.2, paragraph 7
+  if (type) { // Section 7.2, paragraph 7
     bool canHaveAssumedParameter{IsNamedConstant(symbol) ||
-        (IsAssumedLengthCharacter(symbol) &&  // C722
+        (IsAssumedLengthCharacter(symbol) && // C722
             IsExternal(symbol)) ||
         symbol.test(Symbol::Flag::ParentComp)};
-    if (!IsStmtFunctionDummy(symbol)) {  // C726
+    if (!IsStmtFunctionDummy(symbol)) { // C726
       if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
         canHaveAssumedParameter |= object->isDummy() ||
             (object->isFuncResult() &&
                 type->category() == DeclTypeSpec::Character) ||
-            IsStmtFunctionResult(symbol);  // Avoids multiple messages
+            IsStmtFunctionResult(symbol); // Avoids multiple messages
       } else {
         canHaveAssumedParameter |= symbol.has<AssocEntityDetails>();
       }
     }
     Check(*type, canHaveAssumedParameter);
     if (InPure() && InFunction() && IsFunctionResult(symbol)) {
-      if (derived && HasImpureFinal(*derived)) {  // C1584
+      if (derived && HasImpureFinal(*derived)) { // C1584
         messages_.Say(
             "Result of pure function may not have an impure FINAL subroutine"_err_en_US);
       }
-      if (type->IsPolymorphic() && IsAllocatable(symbol)) {  // C1585
+      if (type->IsPolymorphic() && IsAllocatable(symbol)) { // C1585
         messages_.Say(
             "Result of pure function may not be both polymorphic and ALLOCATABLE"_err_en_US);
       }
@@ -242,7 +242,7 @@ void CheckHelper::Check(const Symbol &symbol) {
       }
     }
   }
-  if (IsAssumedLengthCharacter(symbol) && IsExternal(symbol)) {  // C723
+  if (IsAssumedLengthCharacter(symbol) && IsExternal(symbol)) { // C723
     if (symbol.attrs().test(Attr::RECURSIVE)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be RECURSIVE"_err_en_US);
@@ -270,7 +270,7 @@ void CheckHelper::Check(const Symbol &symbol) {
     CheckValue(symbol, derived);
   }
   if (symbol.attrs().test(Attr::CONTIGUOUS) && IsPointer(symbol) &&
-      symbol.Rank() == 0) {  // C830
+      symbol.Rank() == 0) { // C830
     messages_.Say("CONTIGUOUS POINTER must be an array"_err_en_US);
   }
   if (IsDummy(symbol)) {
@@ -286,7 +286,7 @@ void CheckHelper::Check(const Symbol &symbol) {
 }
 
 void CheckHelper::CheckValue(
-    const Symbol &symbol, const DerivedTypeSpec *derived) {  // C863 - C865
+    const Symbol &symbol, const DerivedTypeSpec *derived) { // C863 - C865
   if (!IsDummy(symbol)) {
     messages_.Say(
         "VALUE attribute may apply only to a dummy argument"_err_en_US);
@@ -330,7 +330,7 @@ void CheckHelper::CheckValue(
   }
 }
 
-void CheckHelper::CheckAssumedTypeEntity(  // C709
+void CheckHelper::CheckAssumedTypeEntity( // C709
     const Symbol &symbol, const ObjectEntityDetails &details) {
   if (const DeclTypeSpec * type{symbol.GetType()};
       type && type->category() == DeclTypeSpec::TypeStar) {
@@ -377,7 +377,7 @@ void CheckHelper::CheckAssumedTypeEntity(  // C709
 void CheckHelper::CheckObjectEntity(
     const Symbol &symbol, const ObjectEntityDetails &details) {
   CHECK(!symbolBeingChecked_);
-  symbolBeingChecked_ = &symbol;  // for specification expr checks
+  symbolBeingChecked_ = &symbol; // for specification expr checks
   CheckArraySpec(symbol, details.shape());
   Check(details.shape());
   Check(details.coshape());
@@ -385,12 +385,12 @@ void CheckHelper::CheckObjectEntity(
   symbolBeingChecked_ = nullptr;
   if (!details.coshape().empty()) {
     if (IsAllocatable(symbol)) {
-      if (!details.coshape().IsDeferredShape()) {  // C827
+      if (!details.coshape().IsDeferredShape()) { // C827
         messages_.Say(
             "ALLOCATABLE coarray must have a deferred coshape"_err_en_US);
       }
     } else {
-      if (!details.coshape().IsAssumedSize()) {  // C828
+      if (!details.coshape().IsAssumedSize()) { // C828
         messages_.Say(
             "Non-ALLOCATABLE coarray must have an explicit coshape"_err_en_US);
       }
@@ -400,40 +400,40 @@ void CheckHelper::CheckObjectEntity(
     if (symbol.attrs().test(Attr::INTENT_OUT)) {
       if (FindUltimateComponent(symbol, [](const Symbol &x) {
             return IsCoarray(x) && IsAllocatable(x);
-          })) {  // C846
+          })) { // C846
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, an ALLOCATABLE coarray"_err_en_US);
       }
-      if (IsOrContainsEventOrLockComponent(symbol)) {  // C847
+      if (IsOrContainsEventOrLockComponent(symbol)) { // C847
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, EVENT_TYPE or LOCK_TYPE"_err_en_US);
       }
     }
     if (InPure() && !IsPointer(symbol) && !IsIntentIn(symbol) &&
         !symbol.attrs().test(Attr::VALUE)) {
-      if (InFunction()) {  // C1583
+      if (InFunction()) { // C1583
         messages_.Say(
             "non-POINTER dummy argument of pure function must be INTENT(IN) or VALUE"_err_en_US);
       } else if (IsIntentOut(symbol)) {
         if (const DeclTypeSpec * type{details.type()}) {
-          if (type && type->IsPolymorphic()) {  // C1588
+          if (type && type->IsPolymorphic()) { // C1588
             messages_.Say(
                 "An INTENT(OUT) dummy argument of a pure subroutine may not be polymorphic"_err_en_US);
           } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
             if (FindUltimateComponent(*derived, [](const Symbol &x) {
                   const DeclTypeSpec *type{x.GetType()};
                   return type && type->IsPolymorphic();
-                })) {  // C1588
+                })) { // C1588
               messages_.Say(
                   "An INTENT(OUT) dummy argument of a pure subroutine may not have a polymorphic ultimate component"_err_en_US);
             }
-            if (HasImpureFinal(*derived)) {  // C1587
+            if (HasImpureFinal(*derived)) { // C1587
               messages_.Say(
                   "An INTENT(OUT) dummy argument of a pure subroutine may not have an impure FINAL subroutine"_err_en_US);
             }
           }
         }
-      } else if (!IsIntentInOut(symbol)) {  // C1586
+      } else if (!IsIntentInOut(symbol)) { // C1586
         messages_.Say(
             "non-POINTER dummy argument of pure subroutine must have INTENT() or VALUE attribute"_err_en_US);
       }
@@ -456,7 +456,7 @@ void CheckHelper::CheckObjectEntity(
       }
     }
   }
-  if (const DeclTypeSpec * type{details.type()}) {  // C708
+  if (const DeclTypeSpec * type{details.type()}) { // C708
     if (type->IsPolymorphic() &&
         !(type->IsAssumedType() || IsAllocatableOrPointer(symbol) ||
             symbol.IsDummy())) {
@@ -496,7 +496,7 @@ void CheckHelper::CheckArraySpec(
     msg = "Cray pointee '%s' must have must have explicit shape or"
           " assumed size"_err_en_US;
   } else if (IsAllocatableOrPointer(symbol) && !isDeferred && !isAssumedRank) {
-    if (symbol.owner().IsDerivedType()) {  // C745
+    if (symbol.owner().IsDerivedType()) { // C745
       if (IsAllocatable(symbol)) {
         msg = "Allocatable array component '%s' must have"
               " deferred shape"_err_en_US;
@@ -504,7 +504,7 @@ void CheckHelper::CheckArraySpec(
         msg = "Array pointer component '%s' must have deferred shape"_err_en_US;
       }
     } else {
-      if (IsAllocatable(symbol)) {  // C832
+      if (IsAllocatable(symbol)) { // C832
         msg = "Allocatable array '%s' must have deferred shape or"
               " assumed rank"_err_en_US;
       } else {
@@ -513,17 +513,17 @@ void CheckHelper::CheckArraySpec(
       }
     }
   } else if (symbol.IsDummy()) {
-    if (isImplied && !isAssumedSize) {  // C836
+    if (isImplied && !isAssumedSize) { // C836
       msg = "Dummy array argument '%s' may not have implied shape"_err_en_US;
     }
   } else if (isAssumedShape && !isDeferred) {
     msg = "Assumed-shape array '%s' must be a dummy argument"_err_en_US;
-  } else if (isAssumedSize && !isImplied) {  // C833
+  } else if (isAssumedSize && !isImplied) { // C833
     msg = "Assumed-size array '%s' must be a dummy argument"_err_en_US;
-  } else if (isAssumedRank) {  // C837
+  } else if (isAssumedRank) { // C837
     msg = "Assumed-rank array '%s' must be a dummy argument"_err_en_US;
   } else if (isImplied) {
-    if (!IsNamedConstant(symbol)) {  // C836
+    if (!IsNamedConstant(symbol)) { // C836
       msg = "Implied-shape array '%s' must be a named constant"_err_en_US;
     }
   } else if (IsNamedConstant(symbol)) {
@@ -532,10 +532,10 @@ void CheckHelper::CheckArraySpec(
             " implied shape"_err_en_US;
     }
   } else if (!IsAllocatableOrPointer(symbol) && !isExplicit) {
-    if (symbol.owner().IsDerivedType()) {  // C749
+    if (symbol.owner().IsDerivedType()) { // C749
       msg = "Component array '%s' without ALLOCATABLE or POINTER attribute must"
             " have explicit shape"_err_en_US;
-    } else {  // C816
+    } else { // C816
       msg = "Array '%s' without ALLOCATABLE or POINTER attribute must have"
             " explicit shape"_err_en_US;
     }
@@ -569,7 +569,7 @@ void CheckHelper::CheckProcEntity(
       if (interface->attrs().test(Attr::ELEMENTAL) &&
           !interface->attrs().test(Attr::INTRINSIC)) {
         messages_.Say("Procedure pointer '%s' may not be ELEMENTAL"_err_en_US,
-            symbol.name());  // C1517
+            symbol.name()); // C1517
       }
     }
   }
@@ -583,7 +583,7 @@ void CheckHelper::CheckProcEntity(
 class SubprogramMatchHelper {
 public:
   explicit SubprogramMatchHelper(SemanticsContext &context)
-    : context{context} {}
+      : context{context} {}
 
   void Check(const Symbol &, const Symbol &);
 
@@ -596,10 +596,10 @@ class SubprogramMatchHelper {
       const DummyProcedure &, const DummyProcedure &);
   bool CheckSameIntent(
       const Symbol &, const Symbol &, common::Intent, common::Intent);
-  template<typename... A>
+  template <typename... A>
   void Say(
       const Symbol &, const Symbol &, parser::MessageFixedText &&, A &&...);
-  template<typename ATTRS>
+  template <typename ATTRS>
   bool CheckSameAttrs(const Symbol &, const Symbol &, ATTRS, ATTRS);
   bool ShapesAreCompatible(const DummyDataObject &, const DummyDataObject &);
   evaluate::Shape FoldShape(const evaluate::Shape &);
@@ -691,7 +691,7 @@ void CheckHelper::CheckDerivedType(
   }
   if (const DeclTypeSpec * parent{FindParentTypeSpec(symbol)}) {
     const DerivedTypeSpec *parentDerived{parent->AsDerived()};
-    if (!IsExtensibleType(parentDerived)) {  // C705
+    if (!IsExtensibleType(parentDerived)) { // C705
       messages_.Say("The parent type is not extensible"_err_en_US);
     }
     if (!symbol.attrs().test(Attr::ABSTRACT) && parentDerived &&
@@ -708,7 +708,7 @@ void CheckHelper::CheckDerivedType(
       }
     }
   }
-  if (HasIntrinsicTypeName(symbol)) {  // C729
+  if (HasIntrinsicTypeName(symbol)) { // C729
     messages_.Say("A derived type name cannot be the name of an intrinsic"
                   " type"_err_en_US);
   }
@@ -789,7 +789,7 @@ static bool ConflictsWithIntrinsicOperator(
     const GenericKind &kind, const Procedure &proc) {
   auto arg0{std::get<DummyDataObject>(proc.dummyArguments[0].u).type};
   auto type0{arg0.type()};
-  if (proc.dummyArguments.size() == 1) {  // unary
+  if (proc.dummyArguments.size() == 1) { // unary
     return std::visit(
         common::visitors{
             [&](common::NumericOperator) { return IsIntrinsicNumeric(type0); },
@@ -797,7 +797,7 @@ static bool ConflictsWithIntrinsicOperator(
             [](const auto &) -> bool { DIE("bad generic kind"); },
         },
         kind.u);
-  } else {  // binary
+  } else { // binary
     int rank0{arg0.Rank()};
     auto arg1{std::get<DummyDataObject>(proc.dummyArguments[1].u).type};
     auto type1{arg1.type()};
@@ -827,7 +827,7 @@ static bool ConflictsWithIntrinsicOperator(
 bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
     const GenericKind &kind, const Symbol &specific, const Procedure &proc) {
   std::optional<parser::MessageFixedText> msg;
-  if (specific.attrs().test(Attr::NOPASS)) {  // C774
+  if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "%s procedure '%s' may not have NOPASS attribute"_err_en_US;
   } else if (!proc.functionResult.has_value()) {
     msg = "%s procedure '%s' must be a function"_err_en_US;
@@ -838,11 +838,11 @@ bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
     msg = std::move(m);
   } else if (!CheckDefinedOperatorArg(opName, specific, proc, 0) |
       !CheckDefinedOperatorArg(opName, specific, proc, 1)) {
-    return false;  // error was reported
+    return false; // error was reported
   } else if (ConflictsWithIntrinsicOperator(kind, proc)) {
     msg = "%s function '%s' conflicts with intrinsic operator"_err_en_US;
   } else {
-    return true;  // OK
+    return true; // OK
   }
   SayWithDeclaration(specific, std::move(msg.value()),
       parser::ToUpperCaseLetters(opName.ToString()), specific.name());
@@ -853,29 +853,28 @@ bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
 // false and return the error message in msg.
 std::optional<parser::MessageFixedText> CheckHelper::CheckNumberOfArgs(
     const GenericKind &kind, std::size_t nargs) {
-  std::size_t min{2}, max{2};  // allowed number of args; default is binary
-  std::visit(
-      common::visitors{
-          [&](const common::NumericOperator &x) {
-            if (x == common::NumericOperator::Add ||
-                x == common::NumericOperator::Subtract) {
-              min = 1;  // + and - are unary or binary
-            }
-          },
-          [&](const common::LogicalOperator &x) {
-            if (x == common::LogicalOperator::Not) {
-              min = 1;  // .NOT. is unary
-              max = 1;
-            }
-          },
-          [](const common::RelationalOperator &) {
-            // all are binary
-          },
-          [](const GenericKind::OtherKind &x) {
-            CHECK(x == GenericKind::OtherKind::Concat);
-          },
-          [](const auto &) { DIE("expected intrinsic operator"); },
-      },
+  std::size_t min{2}, max{2}; // allowed number of args; default is binary
+  std::visit(common::visitors{
+                 [&](const common::NumericOperator &x) {
+                   if (x == common::NumericOperator::Add ||
+                       x == common::NumericOperator::Subtract) {
+                     min = 1; // + and - are unary or binary
+                   }
+                 },
+                 [&](const common::LogicalOperator &x) {
+                   if (x == common::LogicalOperator::Not) {
+                     min = 1; // .NOT. is unary
+                     max = 1;
+                   }
+                 },
+                 [](const common::RelationalOperator &) {
+                   // all are binary
+                 },
+                 [](const GenericKind::OtherKind &x) {
+                   CHECK(x == GenericKind::OtherKind::Concat);
+                 },
+                 [](const auto &) { DIE("expected intrinsic operator"); },
+             },
       kind.u);
   if (nargs >= min && nargs <= max) {
     return std::nullopt;
@@ -919,7 +918,7 @@ bool CheckHelper::CheckDefinedOperatorArg(const SourceName &opName,
 bool CheckHelper::CheckDefinedAssignment(
     const Symbol &specific, const Procedure &proc) {
   std::optional<parser::MessageFixedText> msg;
-  if (specific.attrs().test(Attr::NOPASS)) {  // C774
+  if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "Defined assignment procedure '%s' may not have"
           " NOPASS attribute"_err_en_US;
   } else if (!proc.IsSubroutine()) {
@@ -929,12 +928,12 @@ bool CheckHelper::CheckDefinedAssignment(
           " two dummy arguments"_err_en_US;
   } else if (!CheckDefinedAssignmentArg(specific, proc.dummyArguments[0], 0) |
       !CheckDefinedAssignmentArg(specific, proc.dummyArguments[1], 1)) {
-    return false;  // error was reported
+    return false; // error was reported
   } else if (ConflictsWithIntrinsicAssignment(proc)) {
     msg = "Defined assignment subroutine '%s' conflicts with"
           " intrinsic assignment"_err_en_US;
   } else {
-    return true;  // OK
+    return true; // OK
   }
   SayWithDeclaration(specific, std::move(msg.value()), specific.name());
   return false;
@@ -999,7 +998,7 @@ std::optional<std::vector<Procedure>> CheckHelper::Characterize(
 }
 
 void CheckHelper::CheckVolatile(const Symbol &symbol, bool isAssociated,
-    const DerivedTypeSpec *derived) {  // C866 - C868
+    const DerivedTypeSpec *derived) { // C866 - C868
   if (IsIntentIn(symbol)) {
     messages_.Say(
         "VOLATILE attribute may not apply to an INTENT(IN) argument"_err_en_US);
@@ -1022,7 +1021,7 @@ void CheckHelper::CheckVolatile(const Symbol &symbol, bool isAssociated,
   }
 }
 
-void CheckHelper::CheckPointer(const Symbol &symbol) {  // C852
+void CheckHelper::CheckPointer(const Symbol &symbol) { // C852
   CheckConflicting(symbol, Attr::POINTER, Attr::TARGET);
   CheckConflicting(symbol, Attr::POINTER, Attr::ALLOCATABLE);
   CheckConflicting(symbol, Attr::POINTER, Attr::INTRINSIC);
@@ -1105,7 +1104,7 @@ void CheckHelper::CheckPassArg(
   }
   const DeclTypeSpec *type{passArg.GetType()};
   if (!type) {
-    return;  // an error already occurred
+    return; // an error already occurred
   }
   const Symbol &typeSymbol{*proc.owner().GetSymbol()};
   const DerivedTypeSpec *derived{type->AsDerived()};
@@ -1224,7 +1223,7 @@ void CheckHelper::Check(const Scope &scope) {
   if (const Symbol * symbol{scope.symbol()}) {
     innermostSymbol_ = symbol;
   } else if (scope.IsDerivedType()) {
-    return;  // PDT instantiations have null symbol()
+    return; // PDT instantiations have null symbol()
   }
   for (const auto &set : scope.equivalenceSets()) {
     CheckEquivalenceSet(set);
@@ -1251,7 +1250,7 @@ void CheckHelper::CheckEquivalenceSet(const EquivalenceSet &set) {
       if (&object != &*iter) {
         if (auto *details{object.symbol.detailsIf<ObjectEntityDetails>()}) {
           if (details->commonBlock()) {
-            if (details->commonBlock() != &commonBlock) {  // 8.10.3 paragraph 1
+            if (details->commonBlock() != &commonBlock) { // 8.10.3 paragraph 1
               if (auto *msg{messages_.Say(object.symbol.name(),
                       "Two objects in the same EQUIVALENCE set may not be members of distinct COMMON blocks"_err_en_US)}) {
                 msg->Attach(iter->symbol.name(),
@@ -1323,7 +1322,7 @@ void SubprogramMatchHelper::Check(
     return;
   }
   bool nonRecursive1{symbol1.attrs().test(Attr::NON_RECURSIVE)};
-  if (nonRecursive1 != symbol2.attrs().test(Attr::NON_RECURSIVE)) {  // C1551
+  if (nonRecursive1 != symbol2.attrs().test(Attr::NON_RECURSIVE)) { // C1551
     Say(symbol1, symbol2,
         nonRecursive1
             ? "Module subprogram '%s' has NON_RECURSIVE prefix but"
@@ -1393,26 +1392,25 @@ void SubprogramMatchHelper::Check(
 void SubprogramMatchHelper::CheckDummyArg(const Symbol &symbol1,
     const Symbol &symbol2, const DummyArgument &arg1,
     const DummyArgument &arg2) {
-  std::visit(
-      common::visitors{
-          [&](const DummyDataObject &obj1, const DummyDataObject &obj2) {
-            CheckDummyDataObject(symbol1, symbol2, obj1, obj2);
-          },
-          [&](const DummyProcedure &proc1, const DummyProcedure &proc2) {
-            CheckDummyProcedure(symbol1, symbol2, proc1, proc2);
-          },
-          [&](const DummyDataObject &, const auto &) {
-            Say(symbol1, symbol2,
-                "Dummy argument '%s' is a data object; the corresponding"
-                " argument in the interface body is not"_err_en_US);
-          },
-          [&](const DummyProcedure &, const auto &) {
-            Say(symbol1, symbol2,
-                "Dummy argument '%s' is a procedure; the corresponding"
-                " argument in the interface body is not"_err_en_US);
-          },
-          [&](const auto &, const auto &) { DIE("can't happen"); },
-      },
+  std::visit(common::visitors{
+                 [&](const DummyDataObject &obj1, const DummyDataObject &obj2) {
+                   CheckDummyDataObject(symbol1, symbol2, obj1, obj2);
+                 },
+                 [&](const DummyProcedure &proc1, const DummyProcedure &proc2) {
+                   CheckDummyProcedure(symbol1, symbol2, proc1, proc2);
+                 },
+                 [&](const DummyDataObject &, const auto &) {
+                   Say(symbol1, symbol2,
+                       "Dummy argument '%s' is a data object; the corresponding"
+                       " argument in the interface body is not"_err_en_US);
+                 },
+                 [&](const DummyProcedure &, const auto &) {
+                   Say(symbol1, symbol2,
+                       "Dummy argument '%s' is a procedure; the corresponding"
+                       " argument in the interface body is not"_err_en_US);
+                 },
+                 [&](const auto &, const auto &) { DIE("can't happen"); },
+             },
       arg1.u, arg2.u);
 }
 
@@ -1459,7 +1457,7 @@ bool SubprogramMatchHelper::CheckSameIntent(const Symbol &symbol1,
 }
 
 // Report an error referring to first symbol with declaration of second symbol
-template<typename... A>
+template <typename... A>
 void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
     parser::MessageFixedText &&text, A &&... args) {
   auto &message{context.Say(symbol1.name(), std::move(text), symbol1.name(),
@@ -1467,7 +1465,7 @@ void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
   evaluate::AttachDeclaration(message, symbol2);
 }
 
-template<typename ATTRS>
+template <typename ATTRS>
 bool SubprogramMatchHelper::CheckSameAttrs(
     const Symbol &symbol1, const Symbol &symbol2, ATTRS attrs1, ATTRS attrs2) {
   if (attrs1 == attrs2) {
@@ -1511,4 +1509,4 @@ void CheckDeclarations(SemanticsContext &context) {
   CheckHelper{context}.Check();
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-declarations.h b/lib/Semantics/check-declarations.h
index 98cea3249d4a..3b50bac4f5e7 100644
--- a/lib/Semantics/check-declarations.h
+++ b/lib/Semantics/check-declarations.h
@@ -13,5 +13,5 @@
 namespace Fortran::semantics {
 class SemanticsContext;
 void CheckDeclarations(SemanticsContext &);
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/lib/Semantics/check-do-forall.cpp b/lib/Semantics/check-do-forall.cpp
index 58b434b18a60..503a28412102 100644
--- a/lib/Semantics/check-do-forall.cpp
+++ b/lib/Semantics/check-do-forall.cpp
@@ -27,7 +27,7 @@ using ActualArgumentRef = common::Reference<const ActualArgument>;
 inline bool operator<(ActualArgumentRef x, ActualArgumentRef y) {
   return &*x < &*y;
 }
-}
+} // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 
@@ -55,7 +55,7 @@ static const parser::ConcurrentHeader &GetConcurrentHeader(
   return std::get<common::Indirection<parser::ConcurrentHeader>>(stmt.t)
       .value();
 }
-template<typename T>
+template <typename T>
 static const std::list<parser::ConcurrentControl> &GetControls(const T &x) {
   return std::get<std::list<parser::ConcurrentControl>>(
       GetConcurrentHeader(x).t);
@@ -73,7 +73,7 @@ static const parser::Name &GetDoVariable(
 }
 
 // Return the (possibly null)  name of the construct
-template<typename A>
+template <typename A>
 static const parser::Name *MaybeGetConstructName(const A &a) {
   return common::GetPtrFromOptional(std::get<0>(std::get<0>(a.t).statement.t));
 }
@@ -99,13 +99,13 @@ class DoConcurrentBodyEnforce {
 public:
   DoConcurrentBodyEnforce(
       SemanticsContext &context, parser::CharBlock doConcurrentSourcePosition)
-    : context_{context}, doConcurrentSourcePosition_{
-                             doConcurrentSourcePosition} {}
+      : context_{context}, doConcurrentSourcePosition_{
+                               doConcurrentSourcePosition} {}
   std::set<parser::Label> labels() { return labels_; }
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
 
-  template<typename T> bool Pre(const parser::Statement<T> &statement) {
+  template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     if (statement.label.has_value()) {
       labels_.insert(*statement.label);
@@ -113,7 +113,7 @@ class DoConcurrentBodyEnforce {
     return true;
   }
 
-  template<typename T> bool Pre(const parser::UnlabeledStatement<T> &stmt) {
+  template <typename T> bool Pre(const parser::UnlabeledStatement<T> &stmt) {
     currentStatementSourcePosition_ = stmt.source;
     return true;
   }
@@ -246,7 +246,7 @@ class DoConcurrentBodyEnforce {
       if (name.symbol) {
         const Symbol &entity{*name.symbol};
         const DeclTypeSpec *entityType{entity.GetType()};
-        if ((entityType && entityType->IsPolymorphic()) ||  // POINTER case
+        if ((entityType && entityType->IsPolymorphic()) || // POINTER case
             MightDeallocatePolymorphic(entity, DeallocateAll)) {
           SayDeallocateOfPolymorph(
               currentStatementSourcePosition_, entity, reason);
@@ -330,7 +330,8 @@ class DoConcurrentBodyEnforce {
 
 private:
   // Return the (possibly null) name of the statement
-  template<typename A> static const parser::Name *MaybeGetStmtName(const A &a) {
+  template <typename A>
+  static const parser::Name *MaybeGetStmtName(const A &a) {
     return common::GetPtrFromOptional(std::get<0>(a.t));
   }
 
@@ -347,7 +348,7 @@ class DoConcurrentBodyEnforce {
   parser::CharBlock currentStatementSourcePosition_;
   SemanticsContext &context_;
   parser::CharBlock doConcurrentSourcePosition_;
-};  // class DoConcurrentBodyEnforce
+}; // class DoConcurrentBodyEnforce
 
 // Class for enforcing C1130 -- in a DO CONCURRENT with DEFAULT(NONE),
 // variables from enclosing scopes must have their locality specified
@@ -355,12 +356,12 @@ class DoConcurrentVariableEnforce {
 public:
   DoConcurrentVariableEnforce(
       SemanticsContext &context, parser::CharBlock doConcurrentSourcePosition)
-    : context_{context},
-      doConcurrentSourcePosition_{doConcurrentSourcePosition},
-      blockScope_{context.FindScope(doConcurrentSourcePosition_)} {}
+      : context_{context},
+        doConcurrentSourcePosition_{doConcurrentSourcePosition},
+        blockScope_{context.FindScope(doConcurrentSourcePosition_)} {}
 
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
 
   // Check to see if the name is a variable from an enclosing scope
   void Post(const parser::Name &name) {
@@ -382,13 +383,13 @@ class DoConcurrentVariableEnforce {
   SemanticsContext &context_;
   parser::CharBlock doConcurrentSourcePosition_;
   const Scope &blockScope_;
-};  // class DoConcurrentVariableEnforce
+}; // class DoConcurrentVariableEnforce
 
 // Find a DO or FORALL and enforce semantics checks on its body
 class DoContext {
 public:
   DoContext(SemanticsContext &context, IndexVarKind kind)
-    : context_{context}, kind_{kind} {}
+      : context_{context}, kind_{kind} {}
 
   // Mark this DO construct as a point of definition for the DO variables
   // or index-names it contains.  If they're already defined, emit an error
@@ -459,24 +460,23 @@ class DoContext {
               std::get_if<evaluate::ProcedureRef>(&assignment->u)}) {
         CheckForImpureCall(*proc);
       }
-      std::visit(
-          common::visitors{
-              [](const evaluate::Assignment::Intrinsic &) {},
-              [&](const evaluate::ProcedureRef &proc) {
-                CheckForImpureCall(proc);
-              },
-              [&](const evaluate::Assignment::BoundsSpec &bounds) {
-                for (const auto &bound : bounds) {
-                  CheckForImpureCall(SomeExpr{bound});
-                }
-              },
-              [&](const evaluate::Assignment::BoundsRemapping &bounds) {
-                for (const auto &bound : bounds) {
-                  CheckForImpureCall(SomeExpr{bound.first});
-                  CheckForImpureCall(SomeExpr{bound.second});
-                }
-              },
-          },
+      std::visit(common::visitors{
+                     [](const evaluate::Assignment::Intrinsic &) {},
+                     [&](const evaluate::ProcedureRef &proc) {
+                       CheckForImpureCall(proc);
+                     },
+                     [&](const evaluate::Assignment::BoundsSpec &bounds) {
+                       for (const auto &bound : bounds) {
+                         CheckForImpureCall(SomeExpr{bound});
+                       }
+                     },
+                     [&](const evaluate::Assignment::BoundsRemapping &bounds) {
+                       for (const auto &bound : bounds) {
+                         CheckForImpureCall(SomeExpr{bound.first});
+                         CheckForImpureCall(SomeExpr{bound.second});
+                       }
+                     },
+                 },
           assignment->u);
     }
   }
@@ -514,7 +514,7 @@ class DoContext {
                 sourceLocation, symType->IsNumeric(TypeCategory::Real));
           }
         }
-      }  // No messages for INTEGER
+      } // No messages for INTEGER
     }
   }
 
@@ -745,7 +745,7 @@ class DoContext {
     CheckConcurrentHeader(std::get<parser::ConcurrentHeader>(concurrent.t));
   }
 
-  template<typename T> void CheckForImpureCall(const T &x) {
+  template <typename T> void CheckForImpureCall(const T &x) {
     const auto &intrinsics{context_.foldingContext().intrinsics()};
     if (auto bad{FindImpureCall(intrinsics, x)}) {
       context_.Say(
@@ -808,7 +808,7 @@ class DoContext {
   SemanticsContext &context_;
   const IndexVarKind kind_;
   parser::CharBlock currentStatementSourcePosition_;
-};  // class DoContext
+}; // class DoContext
 
 void DoForallChecker::Enter(const parser::DoConstruct &doConstruct) {
   DoContext doContext{context_, IndexVarKind::DO};
@@ -851,7 +851,8 @@ static const parser::Name *MaybeGetNodeName(const ConstructNode &construct) {
       [&](const auto &x) { return MaybeGetConstructName(*x); }, construct);
 }
 
-template<typename A> static parser::CharBlock GetConstructPosition(const A &a) {
+template <typename A>
+static parser::CharBlock GetConstructPosition(const A &a) {
   return std::get<0>(a.t).source;
 }
 
@@ -887,25 +888,24 @@ static bool ConstructIsDoConcurrent(const ConstructNode &construct) {
 // leave DO CONCURRENT, CRITICAL, or CHANGE TEAM constructs.
 void DoForallChecker::CheckForBadLeave(
     StmtType stmtType, const ConstructNode &construct) const {
-  std::visit(
-      common::visitors{
-          [&](const parser::DoConstruct *doConstructPtr) {
-            if (doConstructPtr->IsDoConcurrent()) {
-              // C1135 and C1167 -- CYCLE and EXIT statements can't leave a
-              // DO CONCURRENT
-              SayBadLeave(stmtType, "DO CONCURRENT", construct);
-            }
-          },
-          [&](const parser::CriticalConstruct *) {
-            // C1135 and C1168 -- similarly, for CRITICAL
-            SayBadLeave(stmtType, "CRITICAL", construct);
-          },
-          [&](const parser::ChangeTeamConstruct *) {
-            // C1135 and C1168 -- similarly, for CHANGE TEAM
-            SayBadLeave(stmtType, "CHANGE TEAM", construct);
-          },
-          [](const auto *) {},
-      },
+  std::visit(common::visitors{
+                 [&](const parser::DoConstruct *doConstructPtr) {
+                   if (doConstructPtr->IsDoConcurrent()) {
+                     // C1135 and C1167 -- CYCLE and EXIT statements can't leave
+                     // a DO CONCURRENT
+                     SayBadLeave(stmtType, "DO CONCURRENT", construct);
+                   }
+                 },
+                 [&](const parser::CriticalConstruct *) {
+                   // C1135 and C1168 -- similarly, for CRITICAL
+                   SayBadLeave(stmtType, "CRITICAL", construct);
+                 },
+                 [&](const parser::ChangeTeamConstruct *) {
+                   // C1135 and C1168 -- similarly, for CHANGE TEAM
+                   SayBadLeave(stmtType, "CHANGE TEAM", construct);
+                 },
+                 [](const auto *) {},
+             },
       construct);
 }
 
@@ -914,7 +914,7 @@ static bool StmtMatchesConstruct(const parser::Name *stmtName,
     const ConstructNode &construct) {
   bool inDoConstruct{MaybeGetDoConstruct(construct) != nullptr};
   if (!stmtName) {
-    return inDoConstruct;  // Unlabeled statements match all DO constructs
+    return inDoConstruct; // Unlabeled statements match all DO constructs
   } else if (constructName && constructName->source == stmtName->source) {
     return stmtType == StmtType::EXIT || inDoConstruct;
   } else {
@@ -942,7 +942,7 @@ void DoForallChecker::CheckNesting(
     const parser::Name *constructName{MaybeGetNodeName(construct)};
     if (StmtMatchesConstruct(stmtName, stmtType, constructName, construct)) {
       CheckDoConcurrentExit(stmtType, construct);
-      return;  // We got a match, so we're finished checking
+      return; // We got a match, so we're finished checking
     }
     CheckForBadLeave(stmtType, construct);
   }
@@ -979,7 +979,7 @@ static void CheckIfArgIsDoVar(const evaluate::ActualArgument &arg,
         if (intent == common::Intent::Out) {
           context.CheckIndexVarRedefine(location, *var);
         } else {
-          context.WarnIndexVarRedefine(location, *var);  // INTENT(INOUT)
+          context.WarnIndexVarRedefine(location, *var); // INTENT(INOUT)
         }
       }
     }
@@ -1002,7 +1002,7 @@ void DoForallChecker::Leave(const parser::CallStmt &callStmt) {
     const evaluate::ActualArguments &checkedArgs{typedCall->arguments()};
     for (const auto &checkedOptionalArg : checkedArgs) {
       if (parsedArgIter == parsedArgs.end()) {
-        break;  // No more parsed arguments, we're done.
+        break; // No more parsed arguments, we're done.
       }
       const auto &parsedArg{std::get<parser::ActualArg>(parsedArgIter->t)};
       ++parsedArgIter;
@@ -1028,8 +1028,8 @@ void DoForallChecker::Leave(const parser::ConnectSpec &connectSpec) {
 using ActualArgumentSet = std::set<evaluate::ActualArgumentRef>;
 
 struct CollectActualArgumentsHelper
-  : public evaluate::SetTraverse<CollectActualArgumentsHelper,
-        ActualArgumentSet> {
+    : public evaluate::SetTraverse<CollectActualArgumentsHelper,
+          ActualArgumentSet> {
   using Base = SetTraverse<CollectActualArgumentsHelper, ActualArgumentSet>;
   CollectActualArgumentsHelper() : Base{*this} {}
   using Base::operator();
@@ -1038,7 +1038,7 @@ struct CollectActualArgumentsHelper
   }
 };
 
-template<typename A> ActualArgumentSet CollectActualArguments(const A &x) {
+template <typename A> ActualArgumentSet CollectActualArguments(const A &x) {
   return CollectActualArgumentsHelper{}(x);
 }
 
@@ -1078,4 +1078,4 @@ void DoForallChecker::Leave(const parser::StatVariable &statVariable) {
   context_.CheckIndexVarRedefine(statVariable.v.thing.thing);
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-do-forall.h b/lib/Semantics/check-do-forall.h
index f820926d9199..8f0cdc75ac97 100644
--- a/lib/Semantics/check-do-forall.h
+++ b/lib/Semantics/check-do-forall.h
@@ -27,7 +27,7 @@ struct InquireSpec;
 struct IoControlSpec;
 struct OutputImpliedDo;
 struct StatVariable;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -65,5 +65,5 @@ class DoForallChecker : public virtual BaseChecker {
   void CheckForBadLeave(StmtType, const ConstructNode &) const;
   void CheckNesting(StmtType, const parser::Name *) const;
 };
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/lib/Semantics/check-if-stmt.cpp b/lib/Semantics/check-if-stmt.cpp
index b9693389f5d9..6aca57c99207 100644
--- a/lib/Semantics/check-if-stmt.cpp
+++ b/lib/Semantics/check-if-stmt.cpp
@@ -24,4 +24,4 @@ void IfStmtChecker::Leave(const parser::IfStmt &ifStmt) {
   }
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-if-stmt.h b/lib/Semantics/check-if-stmt.h
index 21ae269d2049..ea4a5c22bd31 100644
--- a/lib/Semantics/check-if-stmt.h
+++ b/lib/Semantics/check-if-stmt.h
@@ -24,5 +24,5 @@ class IfStmtChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
diff --git a/lib/Semantics/check-io.cpp b/lib/Semantics/check-io.cpp
index a3de44ef8dd0..d670c792eb81 100644
--- a/lib/Semantics/check-io.cpp
+++ b/lib/Semantics/check-io.cpp
@@ -21,15 +21,15 @@ class FormatErrorReporter {
 public:
   FormatErrorReporter(SemanticsContext &context,
       const parser::CharBlock &formatCharBlock, int errorAllowance = 3)
-    : context_{context}, formatCharBlock_{formatCharBlock},
-      errorAllowance_{errorAllowance} {}
+      : context_{context}, formatCharBlock_{formatCharBlock},
+        errorAllowance_{errorAllowance} {}
 
   bool Say(const common::FormatMessage &);
 
 private:
   SemanticsContext &context_;
   const parser::CharBlock &formatCharBlock_;
-  int errorAllowance_;  // initialized to maximum number of errors to report
+  int errorAllowance_; // initialized to maximum number of errors to report
 };
 
 bool FormatErrorReporter::Say(const common::FormatMessage &msg) {
@@ -56,7 +56,7 @@ bool FormatErrorReporter::Say(const common::FormatMessage &msg) {
 void IoChecker::Enter(
     const parser::Statement<common::Indirection<parser::FormatStmt>> &stmt) {
   if (!stmt.label) {
-    context_.Say("Format statement must be labeled"_err_en_US);  // C1301
+    context_.Say("Format statement must be labeled"_err_en_US); // C1301
   }
   const char *formatStart{static_cast<const char *>(
       std::memchr(stmt.source.begin(), '(', stmt.source.size()))};
@@ -71,19 +71,20 @@ void IoChecker::Enter(
     validator.Check();
     break;
   }
-  case 2: {  // TODO: Get this to work.
+  case 2: { // TODO: Get this to work.
     common::FormatValidator<char16_t> validator{
         /*???*/ nullptr, /*???*/ 0, reporterWrapper};
     validator.Check();
     break;
   }
-  case 4: {  // TODO: Get this to work.
+  case 4: { // TODO: Get this to work.
     common::FormatValidator<char32_t> validator{
         /*???*/ nullptr, /*???*/ 0, reporterWrapper};
     validator.Check();
     break;
   }
-  default: CRASH_NO_CASE;
+  default:
+    CRASH_NO_CASE;
   }
 }
 
@@ -98,20 +99,48 @@ void IoChecker::Enter(const parser::ConnectSpec::CharExpr &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::ConnectSpec::CharExpr::Kind;
   switch (std::get<ParseKind>(spec.t)) {
-  case ParseKind::Access: specKind = IoSpecKind::Access; break;
-  case ParseKind::Action: specKind = IoSpecKind::Action; break;
-  case ParseKind::Asynchronous: specKind = IoSpecKind::Asynchronous; break;
-  case ParseKind::Blank: specKind = IoSpecKind::Blank; break;
-  case ParseKind::Decimal: specKind = IoSpecKind::Decimal; break;
-  case ParseKind::Delim: specKind = IoSpecKind::Delim; break;
-  case ParseKind::Encoding: specKind = IoSpecKind::Encoding; break;
-  case ParseKind::Form: specKind = IoSpecKind::Form; break;
-  case ParseKind::Pad: specKind = IoSpecKind::Pad; break;
-  case ParseKind::Position: specKind = IoSpecKind::Position; break;
-  case ParseKind::Round: specKind = IoSpecKind::Round; break;
-  case ParseKind::Sign: specKind = IoSpecKind::Sign; break;
-  case ParseKind::Convert: specKind = IoSpecKind::Convert; break;
-  case ParseKind::Dispose: specKind = IoSpecKind::Dispose; break;
+  case ParseKind::Access:
+    specKind = IoSpecKind::Access;
+    break;
+  case ParseKind::Action:
+    specKind = IoSpecKind::Action;
+    break;
+  case ParseKind::Asynchronous:
+    specKind = IoSpecKind::Asynchronous;
+    break;
+  case ParseKind::Blank:
+    specKind = IoSpecKind::Blank;
+    break;
+  case ParseKind::Decimal:
+    specKind = IoSpecKind::Decimal;
+    break;
+  case ParseKind::Delim:
+    specKind = IoSpecKind::Delim;
+    break;
+  case ParseKind::Encoding:
+    specKind = IoSpecKind::Encoding;
+    break;
+  case ParseKind::Form:
+    specKind = IoSpecKind::Form;
+    break;
+  case ParseKind::Pad:
+    specKind = IoSpecKind::Pad;
+    break;
+  case ParseKind::Position:
+    specKind = IoSpecKind::Position;
+    break;
+  case ParseKind::Round:
+    specKind = IoSpecKind::Round;
+    break;
+  case ParseKind::Sign:
+    specKind = IoSpecKind::Sign;
+    break;
+  case ParseKind::Convert:
+    specKind = IoSpecKind::Convert;
+    break;
+  case ParseKind::Dispose:
+    specKind = IoSpecKind::Dispose;
+    break;
   }
   SetSpecifier(specKind);
   if (const std::optional<std::string> charConst{GetConstExpr<std::string>(
@@ -137,7 +166,7 @@ void IoChecker::Enter(const parser::ConnectSpec::Recl &spec) {
     if (*recl <= 0) {
       context_.Say(parser::FindSourceLocation(spec),
           "RECL value (%jd) must be positive"_err_en_US,
-          std::move(static_cast<std::intmax_t>(*recl)));  // 12.5.6.15
+          std::move(static_cast<std::intmax_t>(*recl))); // 12.5.6.15
     }
   }
 }
@@ -204,7 +233,8 @@ void IoChecker::Enter(const parser::Format &spec) {
               validator.Check();
               break;
             }
-            default: CRASH_NO_CASE;
+            default:
+              CRASH_NO_CASE;
             }
           },
       },
@@ -224,7 +254,7 @@ void IoChecker::Enter(const parser::IdVariable &spec) {
   if (kind < defaultKind) {
     context_.Say(
         "ID kind (%d) is smaller than default INTEGER kind (%d)"_err_en_US,
-        std::move(kind), std::move(defaultKind));  // C1229
+        std::move(kind), std::move(defaultKind)); // C1229
   }
 }
 
@@ -240,7 +270,7 @@ void IoChecker::Enter(const parser::InputItem &spec) {
         // This check may be superseded by C928 or C1002.
         context_.Say(name.source,
             "'%s' must not be a whole assumed size array"_err_en_US,
-            name.source);  // C1231
+            name.source); // C1231
       }
     }
   }
@@ -257,31 +287,81 @@ void IoChecker::Enter(const parser::InquireSpec::CharVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::CharVar::Kind;
   switch (std::get<ParseKind>(spec.t)) {
-  case ParseKind::Access: specKind = IoSpecKind::Access; break;
-  case ParseKind::Action: specKind = IoSpecKind::Action; break;
-  case ParseKind::Asynchronous: specKind = IoSpecKind::Asynchronous; break;
-  case ParseKind::Blank: specKind = IoSpecKind::Blank; break;
-  case ParseKind::Decimal: specKind = IoSpecKind::Decimal; break;
-  case ParseKind::Delim: specKind = IoSpecKind::Delim; break;
-  case ParseKind::Direct: specKind = IoSpecKind::Direct; break;
-  case ParseKind::Encoding: specKind = IoSpecKind::Encoding; break;
-  case ParseKind::Form: specKind = IoSpecKind::Form; break;
-  case ParseKind::Formatted: specKind = IoSpecKind::Formatted; break;
-  case ParseKind::Iomsg: specKind = IoSpecKind::Iomsg; break;
-  case ParseKind::Name: specKind = IoSpecKind::Name; break;
-  case ParseKind::Pad: specKind = IoSpecKind::Pad; break;
-  case ParseKind::Position: specKind = IoSpecKind::Position; break;
-  case ParseKind::Read: specKind = IoSpecKind::Read; break;
-  case ParseKind::Readwrite: specKind = IoSpecKind::Readwrite; break;
-  case ParseKind::Round: specKind = IoSpecKind::Round; break;
-  case ParseKind::Sequential: specKind = IoSpecKind::Sequential; break;
-  case ParseKind::Sign: specKind = IoSpecKind::Sign; break;
-  case ParseKind::Status: specKind = IoSpecKind::Status; break;
-  case ParseKind::Stream: specKind = IoSpecKind::Stream; break;
-  case ParseKind::Unformatted: specKind = IoSpecKind::Unformatted; break;
-  case ParseKind::Write: specKind = IoSpecKind::Write; break;
-  case ParseKind::Convert: specKind = IoSpecKind::Convert; break;
-  case ParseKind::Dispose: specKind = IoSpecKind::Dispose; break;
+  case ParseKind::Access:
+    specKind = IoSpecKind::Access;
+    break;
+  case ParseKind::Action:
+    specKind = IoSpecKind::Action;
+    break;
+  case ParseKind::Asynchronous:
+    specKind = IoSpecKind::Asynchronous;
+    break;
+  case ParseKind::Blank:
+    specKind = IoSpecKind::Blank;
+    break;
+  case ParseKind::Decimal:
+    specKind = IoSpecKind::Decimal;
+    break;
+  case ParseKind::Delim:
+    specKind = IoSpecKind::Delim;
+    break;
+  case ParseKind::Direct:
+    specKind = IoSpecKind::Direct;
+    break;
+  case ParseKind::Encoding:
+    specKind = IoSpecKind::Encoding;
+    break;
+  case ParseKind::Form:
+    specKind = IoSpecKind::Form;
+    break;
+  case ParseKind::Formatted:
+    specKind = IoSpecKind::Formatted;
+    break;
+  case ParseKind::Iomsg:
+    specKind = IoSpecKind::Iomsg;
+    break;
+  case ParseKind::Name:
+    specKind = IoSpecKind::Name;
+    break;
+  case ParseKind::Pad:
+    specKind = IoSpecKind::Pad;
+    break;
+  case ParseKind::Position:
+    specKind = IoSpecKind::Position;
+    break;
+  case ParseKind::Read:
+    specKind = IoSpecKind::Read;
+    break;
+  case ParseKind::Readwrite:
+    specKind = IoSpecKind::Readwrite;
+    break;
+  case ParseKind::Round:
+    specKind = IoSpecKind::Round;
+    break;
+  case ParseKind::Sequential:
+    specKind = IoSpecKind::Sequential;
+    break;
+  case ParseKind::Sign:
+    specKind = IoSpecKind::Sign;
+    break;
+  case ParseKind::Status:
+    specKind = IoSpecKind::Status;
+    break;
+  case ParseKind::Stream:
+    specKind = IoSpecKind::Stream;
+    break;
+  case ParseKind::Unformatted:
+    specKind = IoSpecKind::Unformatted;
+    break;
+  case ParseKind::Write:
+    specKind = IoSpecKind::Write;
+    break;
+  case ParseKind::Convert:
+    specKind = IoSpecKind::Convert;
+    break;
+  case ParseKind::Dispose:
+    specKind = IoSpecKind::Dispose;
+    break;
   }
   SetSpecifier(specKind);
 }
@@ -290,12 +370,24 @@ void IoChecker::Enter(const parser::InquireSpec::IntVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::IntVar::Kind;
   switch (std::get<parser::InquireSpec::IntVar::Kind>(spec.t)) {
-  case ParseKind::Iostat: specKind = IoSpecKind::Iostat; break;
-  case ParseKind::Nextrec: specKind = IoSpecKind::Nextrec; break;
-  case ParseKind::Number: specKind = IoSpecKind::Number; break;
-  case ParseKind::Pos: specKind = IoSpecKind::Pos; break;
-  case ParseKind::Recl: specKind = IoSpecKind::Recl; break;
-  case ParseKind::Size: specKind = IoSpecKind::Size; break;
+  case ParseKind::Iostat:
+    specKind = IoSpecKind::Iostat;
+    break;
+  case ParseKind::Nextrec:
+    specKind = IoSpecKind::Nextrec;
+    break;
+  case ParseKind::Number:
+    specKind = IoSpecKind::Number;
+    break;
+  case ParseKind::Pos:
+    specKind = IoSpecKind::Pos;
+    break;
+  case ParseKind::Recl:
+    specKind = IoSpecKind::Recl;
+    break;
+  case ParseKind::Size:
+    specKind = IoSpecKind::Size;
+    break;
   }
   SetSpecifier(specKind);
 }
@@ -304,10 +396,18 @@ void IoChecker::Enter(const parser::InquireSpec::LogVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::LogVar::Kind;
   switch (std::get<parser::InquireSpec::LogVar::Kind>(spec.t)) {
-  case ParseKind::Exist: specKind = IoSpecKind::Exist; break;
-  case ParseKind::Named: specKind = IoSpecKind::Named; break;
-  case ParseKind::Opened: specKind = IoSpecKind::Opened; break;
-  case ParseKind::Pending: specKind = IoSpecKind::Pending; break;
+  case ParseKind::Exist:
+    specKind = IoSpecKind::Exist;
+    break;
+  case ParseKind::Named:
+    specKind = IoSpecKind::Named;
+    break;
+  case ParseKind::Opened:
+    specKind = IoSpecKind::Opened;
+    break;
+  case ParseKind::Pending:
+    specKind = IoSpecKind::Pending;
+    break;
   }
   SetSpecifier(specKind);
 }
@@ -328,7 +428,7 @@ void IoChecker::Enter(const parser::IoControlSpec::Asynchronous &spec) {
     flags_.set(
         Flag::AsynchronousYes, parser::ToUpperCaseLetters(*charConst) == "YES");
     CheckStringValue(IoSpecKind::Asynchronous, *charConst,
-        parser::FindSourceLocation(spec));  // C1223
+        parser::FindSourceLocation(spec)); // C1223
   }
 }
 
@@ -336,13 +436,27 @@ void IoChecker::Enter(const parser::IoControlSpec::CharExpr &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::IoControlSpec::CharExpr::Kind;
   switch (std::get<ParseKind>(spec.t)) {
-  case ParseKind::Advance: specKind = IoSpecKind::Advance; break;
-  case ParseKind::Blank: specKind = IoSpecKind::Blank; break;
-  case ParseKind::Decimal: specKind = IoSpecKind::Decimal; break;
-  case ParseKind::Delim: specKind = IoSpecKind::Delim; break;
-  case ParseKind::Pad: specKind = IoSpecKind::Pad; break;
-  case ParseKind::Round: specKind = IoSpecKind::Round; break;
-  case ParseKind::Sign: specKind = IoSpecKind::Sign; break;
+  case ParseKind::Advance:
+    specKind = IoSpecKind::Advance;
+    break;
+  case ParseKind::Blank:
+    specKind = IoSpecKind::Blank;
+    break;
+  case ParseKind::Decimal:
+    specKind = IoSpecKind::Decimal;
+    break;
+  case ParseKind::Delim:
+    specKind = IoSpecKind::Delim;
+    break;
+  case ParseKind::Pad:
+    specKind = IoSpecKind::Pad;
+    break;
+  case ParseKind::Round:
+    specKind = IoSpecKind::Round;
+    break;
+  case ParseKind::Sign:
+    specKind = IoSpecKind::Sign;
+    break;
   }
   SetSpecifier(specKind);
   if (const std::optional<std::string> charConst{GetConstExpr<std::string>(
@@ -373,7 +487,7 @@ void IoChecker::Enter(const parser::IoUnit &spec) {
     if (auto expr{GetExpr(*var)}) {
       if (!ExprTypeKindIsDefault(*expr, context_)) {
         // This may be too restrictive; other kinds may be valid.
-        context_.Say(  // C1202
+        context_.Say( // C1202
             "Invalid character kind for an internal file variable"_err_en_US);
       }
     }
@@ -429,28 +543,28 @@ void IoChecker::Enter(const parser::StatVariable &) {
 void IoChecker::Leave(const parser::BackspaceStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1240
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1240
   Done();
 }
 
 void IoChecker::Leave(const parser::CloseStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1208
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1208
   Done();
 }
 
 void IoChecker::Leave(const parser::EndfileStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1240
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1240
   Done();
 }
 
 void IoChecker::Leave(const parser::FlushStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1243
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1243
   Done();
 }
 
@@ -460,9 +574,9 @@ void IoChecker::Leave(const parser::InquireStmt &stmt) {
     // Inquire by unit or by file (vs. by output list).
     CheckForRequiredSpecifier(
         flags_.test(Flag::NumberUnit) || specifierSet_.test(IoSpecKind::File),
-        "UNIT number or FILE");  // C1246
-    CheckForProhibitedSpecifier(IoSpecKind::File, IoSpecKind::Unit);  // C1246
-    CheckForRequiredSpecifier(IoSpecKind::Id, IoSpecKind::Pending);  // C1248
+        "UNIT number or FILE"); // C1246
+    CheckForProhibitedSpecifier(IoSpecKind::File, IoSpecKind::Unit); // C1246
+    CheckForRequiredSpecifier(IoSpecKind::Id, IoSpecKind::Pending); // C1248
   }
   Done();
 }
@@ -471,31 +585,31 @@ void IoChecker::Leave(const parser::OpenStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(specifierSet_.test(IoSpecKind::Unit) ||
           specifierSet_.test(IoSpecKind::Newunit),
-      "UNIT or NEWUNIT");  // C1204, C1205
+      "UNIT or NEWUNIT"); // C1204, C1205
   CheckForProhibitedSpecifier(
-      IoSpecKind::Newunit, IoSpecKind::Unit);  // C1204, C1205
+      IoSpecKind::Newunit, IoSpecKind::Unit); // C1204, C1205
   CheckForRequiredSpecifier(flags_.test(Flag::StatusNew), "STATUS='NEW'",
-      IoSpecKind::File);  // 12.5.6.10
+      IoSpecKind::File); // 12.5.6.10
   CheckForRequiredSpecifier(flags_.test(Flag::StatusReplace),
-      "STATUS='REPLACE'", IoSpecKind::File);  // 12.5.6.10
+      "STATUS='REPLACE'", IoSpecKind::File); // 12.5.6.10
   CheckForProhibitedSpecifier(flags_.test(Flag::StatusScratch),
-      "STATUS='SCRATCH'", IoSpecKind::File);  // 12.5.6.10
+      "STATUS='SCRATCH'", IoSpecKind::File); // 12.5.6.10
   if (flags_.test(Flag::KnownStatus)) {
     CheckForRequiredSpecifier(IoSpecKind::Newunit,
         specifierSet_.test(IoSpecKind::File) ||
             flags_.test(Flag::StatusScratch),
-        "FILE or STATUS='SCRATCH'");  // 12.5.6.12
+        "FILE or STATUS='SCRATCH'"); // 12.5.6.12
   } else {
     CheckForRequiredSpecifier(IoSpecKind::Newunit,
         specifierSet_.test(IoSpecKind::File) ||
             specifierSet_.test(IoSpecKind::Status),
-        "FILE or STATUS");  // 12.5.6.12
+        "FILE or STATUS"); // 12.5.6.12
   }
   if (flags_.test(Flag::KnownAccess)) {
     CheckForRequiredSpecifier(flags_.test(Flag::AccessDirect),
-        "ACCESS='DIRECT'", IoSpecKind::Recl);  // 12.5.6.15
+        "ACCESS='DIRECT'", IoSpecKind::Recl); // 12.5.6.15
     CheckForProhibitedSpecifier(flags_.test(Flag::AccessStream),
-        "STATUS='STREAM'", IoSpecKind::Recl);  // 12.5.6.15
+        "STATUS='STREAM'", IoSpecKind::Recl); // 12.5.6.15
   }
   Done();
 }
@@ -547,29 +661,29 @@ void IoChecker::Leave(const parser::ReadStmt &readStmt) {
     return;
   }
   LeaveReadWrite();
-  CheckForProhibitedSpecifier(IoSpecKind::Delim);  // C1212
-  CheckForProhibitedSpecifier(IoSpecKind::Sign);  // C1212
-  CheckForProhibitedSpecifier(IoSpecKind::Rec, IoSpecKind::End);  // C1220
+  CheckForProhibitedSpecifier(IoSpecKind::Delim); // C1212
+  CheckForProhibitedSpecifier(IoSpecKind::Sign); // C1212
+  CheckForProhibitedSpecifier(IoSpecKind::Rec, IoSpecKind::End); // C1220
   CheckForRequiredSpecifier(IoSpecKind::Eor,
       specifierSet_.test(IoSpecKind::Advance) && !flags_.test(Flag::AdvanceYes),
-      "ADVANCE with value 'NO'");  // C1222 + 12.6.2.1p2
+      "ADVANCE with value 'NO'"); // C1222 + 12.6.2.1p2
   CheckForRequiredSpecifier(IoSpecKind::Blank, flags_.test(Flag::FmtOrNml),
-      "FMT or NML");  // C1227
+      "FMT or NML"); // C1227
   CheckForRequiredSpecifier(
-      IoSpecKind::Pad, flags_.test(Flag::FmtOrNml), "FMT or NML");  // C1227
+      IoSpecKind::Pad, flags_.test(Flag::FmtOrNml), "FMT or NML"); // C1227
   Done();
 }
 
 void IoChecker::Leave(const parser::RewindStmt &) {
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1240
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1240
   CheckForPureSubprogram();
   Done();
 }
 
 void IoChecker::Leave(const parser::WaitStmt &) {
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1237
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1237
   CheckForPureSubprogram();
   Done();
 }
@@ -579,50 +693,50 @@ void IoChecker::Leave(const parser::WriteStmt &) {
     CheckForPureSubprogram();
   }
   LeaveReadWrite();
-  CheckForProhibitedSpecifier(IoSpecKind::Blank);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::End);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::Eor);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::Pad);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::Size);  // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Blank); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::End); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Eor); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Pad); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Size); // C1213
   CheckForRequiredSpecifier(
-      IoSpecKind::Sign, flags_.test(Flag::FmtOrNml), "FMT or NML");  // C1227
+      IoSpecKind::Sign, flags_.test(Flag::FmtOrNml), "FMT or NML"); // C1227
   CheckForRequiredSpecifier(IoSpecKind::Delim,
       flags_.test(Flag::StarFmt) || specifierSet_.test(IoSpecKind::Nml),
-      "FMT=* or NML");  // C1228
+      "FMT=* or NML"); // C1228
   Done();
 }
 
 void IoChecker::LeaveReadWrite() const {
-  CheckForRequiredSpecifier(IoSpecKind::Unit);  // C1211
-  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Rec);  // C1216
-  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Fmt);  // C1216
+  CheckForRequiredSpecifier(IoSpecKind::Unit); // C1211
+  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Rec); // C1216
+  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Fmt); // C1216
   CheckForProhibitedSpecifier(
-      IoSpecKind::Nml, flags_.test(Flag::DataList), "a data list");  // C1216
+      IoSpecKind::Nml, flags_.test(Flag::DataList), "a data list"); // C1216
   CheckForProhibitedSpecifier(flags_.test(Flag::InternalUnit),
-      "UNIT=internal-file", IoSpecKind::Pos);  // C1219
+      "UNIT=internal-file", IoSpecKind::Pos); // C1219
   CheckForProhibitedSpecifier(flags_.test(Flag::InternalUnit),
-      "UNIT=internal-file", IoSpecKind::Rec);  // C1219
+      "UNIT=internal-file", IoSpecKind::Rec); // C1219
   CheckForProhibitedSpecifier(
-      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Pos);  // C1219
+      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Pos); // C1219
   CheckForProhibitedSpecifier(
-      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Rec);  // C1219
+      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Rec); // C1219
   CheckForProhibitedSpecifier(
-      IoSpecKind::Rec, flags_.test(Flag::StarFmt), "FMT=*");  // C1220
+      IoSpecKind::Rec, flags_.test(Flag::StarFmt), "FMT=*"); // C1220
   CheckForRequiredSpecifier(IoSpecKind::Advance,
       flags_.test(Flag::CharFmt) || flags_.test(Flag::LabelFmt),
-      "an explicit format");  // C1221
+      "an explicit format"); // C1221
   CheckForProhibitedSpecifier(IoSpecKind::Advance,
-      flags_.test(Flag::InternalUnit), "UNIT=internal-file");  // C1221
+      flags_.test(Flag::InternalUnit), "UNIT=internal-file"); // C1221
   CheckForRequiredSpecifier(flags_.test(Flag::AsynchronousYes),
       "ASYNCHRONOUS='YES'", flags_.test(Flag::NumberUnit),
-      "UNIT=number");  // C1224
+      "UNIT=number"); // C1224
   CheckForRequiredSpecifier(IoSpecKind::Id, flags_.test(Flag::AsynchronousYes),
-      "ASYNCHRONOUS='YES'");  // C1225
-  CheckForProhibitedSpecifier(IoSpecKind::Pos, IoSpecKind::Rec);  // C1226
+      "ASYNCHRONOUS='YES'"); // C1225
+  CheckForProhibitedSpecifier(IoSpecKind::Pos, IoSpecKind::Rec); // C1226
   CheckForRequiredSpecifier(IoSpecKind::Decimal, flags_.test(Flag::FmtOrNml),
-      "FMT or NML");  // C1227
+      "FMT or NML"); // C1227
   CheckForRequiredSpecifier(IoSpecKind::Round, flags_.test(Flag::FmtOrNml),
-      "FMT or NML");  // C1227
+      "FMT or NML"); // C1227
 }
 
 void IoChecker::SetSpecifier(IoSpecKind specKind) {
@@ -755,11 +869,11 @@ void IoChecker::CheckForProhibitedSpecifier(
   }
 }
 
-void IoChecker::CheckForPureSubprogram() const {  // C1597
+void IoChecker::CheckForPureSubprogram() const { // C1597
   CHECK(context_.location());
   if (FindPureProcedureContaining(context_.FindScope(*context_.location()))) {
     context_.Say("External I/O is not allowed in a pure subprogram"_err_en_US);
   }
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-io.h b/lib/Semantics/check-io.h
index c43f62b1ae03..6763657e623b 100644
--- a/lib/Semantics/check-io.h
+++ b/lib/Semantics/check-io.h
@@ -85,7 +85,7 @@ class IoChecker : public virtual BaseChecker {
       AdvanceYes, AsynchronousYes, KnownStatus, StatusNew, StatusReplace,
       StatusScratch, DataList)
 
-  template<typename R, typename T> std::optional<R> GetConstExpr(const T &x) {
+  template <typename R, typename T> std::optional<R> GetConstExpr(const T &x) {
     using DefaultCharConstantType =
         evaluate::Type<common::TypeCategory::Character, 1>;
     if (const SomeExpr * expr{GetExpr(x)}) {
@@ -138,5 +138,5 @@ class IoChecker : public virtual BaseChecker {
   common::EnumSet<Flag, Flag_enumSize> flags_;
 };
 
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_IO_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_IO_H_
diff --git a/lib/Semantics/check-namelist.cpp b/lib/Semantics/check-namelist.cpp
index c720552bfe08..630840ab5d92 100644
--- a/lib/Semantics/check-namelist.cpp
+++ b/lib/Semantics/check-namelist.cpp
@@ -18,14 +18,14 @@ void NamelistChecker::Leave(const parser::NamelistStmt &nmlStmt) {
         if (nmlObjSymbol && nmlObjSymbol->has<ObjectEntityDetails>()) {
           const auto *symDetails{
               std::get_if<ObjectEntityDetails>(&nmlObjSymbol->details())};
-          if (symDetails && symDetails->IsAssumedSize()) {  // C8104
+          if (symDetails && symDetails->IsAssumedSize()) { // C8104
             context_.Say(nmlObjName.source,
                 "A namelist group object '%s' must not be"
                 " assumed-size"_err_en_US,
                 nmlObjSymbol->name());
           }
           if (nml->attrs().test(Attr::PUBLIC) &&
-              nmlObjSymbol->attrs().test(Attr::PRIVATE)) {  // C8105
+              nmlObjSymbol->attrs().test(Attr::PRIVATE)) { // C8105
             context_.Say(nmlObjName.source,
                 "A PRIVATE namelist group object '%s' must not be in a "
                 "PUBLIC namelist"_err_en_US,
@@ -37,4 +37,4 @@ void NamelistChecker::Leave(const parser::NamelistStmt &nmlStmt) {
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-namelist.h b/lib/Semantics/check-namelist.h
index 7989ed404bcf..a23b7d717b02 100644
--- a/lib/Semantics/check-namelist.h
+++ b/lib/Semantics/check-namelist.h
@@ -21,5 +21,5 @@ class NamelistChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_NAMELIST_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_NAMELIST_H_
diff --git a/lib/Semantics/check-nullify.cpp b/lib/Semantics/check-nullify.cpp
index c7595f476d39..5c3396e8128d 100644
--- a/lib/Semantics/check-nullify.cpp
+++ b/lib/Semantics/check-nullify.cpp
@@ -32,7 +32,7 @@ void NullifyChecker::Leave(const parser::NullifyStmt &nullifyStmt) {
               } else if (!IsVariableName(symbol) && !IsProcName(symbol)) {
                 messages.Say(name.source,
                     "name in NULLIFY statement must be a variable or procedure pointer name"_err_en_US);
-              } else if (!IsPointer(symbol)) {  // C951
+              } else if (!IsPointer(symbol)) { // C951
                 messages.Say(name.source,
                     "name in NULLIFY statement must have the POINTER attribute"_err_en_US);
               } else if (pure) {
@@ -42,7 +42,7 @@ void NullifyChecker::Leave(const parser::NullifyStmt &nullifyStmt) {
             [&](const parser::StructureComponent &structureComponent) {
               evaluate::ExpressionAnalyzer analyzer{context_};
               if (MaybeExpr checked{analyzer.Analyze(structureComponent)}) {
-                if (!IsPointer(*structureComponent.component.symbol)) {  // C951
+                if (!IsPointer(*structureComponent.component.symbol)) { // C951
                   messages.Say(structureComponent.component.source,
                       "component in NULLIFY statement must have the POINTER attribute"_err_en_US);
                 } else if (pure) {
@@ -64,4 +64,4 @@ void NullifyChecker::Leave(const parser::NullifyStmt &nullifyStmt) {
   // Some dependencies can be found compile time or at
   // runtime, but for now we choose to skip such checks.
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-nullify.h b/lib/Semantics/check-nullify.h
index 508631a9649b..7b9191508e3b 100644
--- a/lib/Semantics/check-nullify.h
+++ b/lib/Semantics/check-nullify.h
@@ -24,5 +24,5 @@ class NullifyChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
diff --git a/lib/Semantics/check-omp-structure.cpp b/lib/Semantics/check-omp-structure.cpp
index 0e122856985f..b1864fbda62a 100644
--- a/lib/Semantics/check-omp-structure.cpp
+++ b/lib/Semantics/check-omp-structure.cpp
@@ -668,7 +668,7 @@ void OmpStructureChecker::Leave(const parser::OmpClauseList &) {
 
       // TODO: ordered region binding check (requires nesting implementation)
     }
-  }  // doSet
+  } // doSet
 
   // 2.8.1 Simd Construct Restriction
   if (simdSet.test(GetContext().directive)) {
@@ -692,7 +692,7 @@ void OmpStructureChecker::Leave(const parser::OmpClauseList &) {
     }
 
     // TODO: A list-item cannot appear in more than one aligned clause
-  }  // SIMD
+  } // SIMD
 
   // 2.7.3 Single Construct Restriction
   if (GetContext().directive == OmpDirective::END_SINGLE) {
@@ -938,7 +938,8 @@ void OmpStructureChecker::Enter(const parser::OmpMapClause &x) {
             ContextDirectiveAsFortran());
       }
     } break;
-    default: break;
+    default:
+      break;
     }
   }
 }
@@ -995,4 +996,4 @@ void OmpStructureChecker::Enter(const parser::OmpScheduleClause &x) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-omp-structure.h b/lib/Semantics/check-omp-structure.h
index 67709e38b5a8..e952b3531f84 100644
--- a/lib/Semantics/check-omp-structure.h
+++ b/lib/Semantics/check-omp-structure.h
@@ -170,7 +170,7 @@ class OmpStructureChecker : public virtual BaseChecker {
 private:
   struct OmpContext {
     OmpContext(parser::CharBlock source, OmpDirective d)
-      : directiveSource{source}, directive{d} {}
+        : directiveSource{source}, directive{d} {}
     parser::CharBlock directiveSource{nullptr};
     parser::CharBlock clauseSource{nullptr};
     OmpDirective directive;
@@ -246,7 +246,7 @@ class OmpStructureChecker : public virtual BaseChecker {
   void CheckRequired(OmpClause);
   std::string ContextDirectiveAsFortran();
   void SayNotMatching(const parser::CharBlock &, const parser::CharBlock &);
-  template<typename A, typename B, typename C>
+  template <typename A, typename B, typename C>
   const A &CheckMatching(const B &beginDir, const C &endDir) {
     const A &begin{std::get<A>(beginDir.t)};
     const A &end{std::get<A>(endDir.t)};
@@ -261,7 +261,7 @@ class OmpStructureChecker : public virtual BaseChecker {
       const parser::OmpScheduleModifierType::ModType &);
 
   SemanticsContext &context_;
-  std::vector<OmpContext> ompContext_;  // used as a stack
+  std::vector<OmpContext> ompContext_; // used as a stack
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
diff --git a/lib/Semantics/check-purity.cpp b/lib/Semantics/check-purity.cpp
index 9ca56fc04fa1..5176390f366b 100644
--- a/lib/Semantics/check-purity.cpp
+++ b/lib/Semantics/check-purity.cpp
@@ -70,4 +70,4 @@ void PurityChecker::Left() {
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-purity.h b/lib/Semantics/check-purity.h
index b4c8272de634..a6551162325f 100644
--- a/lib/Semantics/check-purity.h
+++ b/lib/Semantics/check-purity.h
@@ -15,7 +15,7 @@ struct ExecutableConstruct;
 struct SubroutineSubprogram;
 struct FunctionSubprogram;
 struct PrefixSpec;
-}
+} // namespace Fortran::parser
 namespace Fortran::semantics {
 class PurityChecker : public virtual BaseChecker {
 public:
@@ -35,5 +35,5 @@ class PurityChecker : public virtual BaseChecker {
   int depth_{0};
   int pureDepth_{-1};
 };
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/lib/Semantics/check-return.cpp b/lib/Semantics/check-return.cpp
index 0e0dd2c3e66f..602ecc8a22f7 100644
--- a/lib/Semantics/check-return.cpp
+++ b/lib/Semantics/check-return.cpp
@@ -43,4 +43,4 @@ void ReturnStmtChecker::Leave(const parser::ReturnStmt &returnStmt) {
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-return.h b/lib/Semantics/check-return.h
index edaf90b4f641..d49c747717ec 100644
--- a/lib/Semantics/check-return.h
+++ b/lib/Semantics/check-return.h
@@ -24,5 +24,5 @@ class ReturnStmtChecker : public virtual BaseChecker {
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_RETURN_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_RETURN_H_
diff --git a/lib/Semantics/check-stop.cpp b/lib/Semantics/check-stop.cpp
index 08487a5c07af..ce3482a072bb 100644
--- a/lib/Semantics/check-stop.cpp
+++ b/lib/Semantics/check-stop.cpp
@@ -39,4 +39,4 @@ void StopChecker::Enter(const parser::StopStmt &stmt) {
   }
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/check-stop.h b/lib/Semantics/check-stop.h
index ed50830edc4a..b9a22bf9df80 100644
--- a/lib/Semantics/check-stop.h
+++ b/lib/Semantics/check-stop.h
@@ -28,6 +28,6 @@ class StopChecker : public virtual BaseChecker {
   SemanticsContext &context_;
 };
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
 
-#endif  // FORTRAN_SEMANTICS_CHECK_STOP_H_
+#endif // FORTRAN_SEMANTICS_CHECK_STOP_H_
diff --git a/lib/Semantics/expression.cpp b/lib/Semantics/expression.cpp
index 717266af9733..d36bd6f8e1e0 100644
--- a/lib/Semantics/expression.cpp
+++ b/lib/Semantics/expression.cpp
@@ -873,21 +873,21 @@ std::optional<Expr<SubscriptInteger>> ExpressionAnalyzer::TripletPart(
 
 std::optional<Subscript> ExpressionAnalyzer::AnalyzeSectionSubscript(
     const parser::SectionSubscript &ss) {
-  return std::visit(
-      common::visitors{
-          [&](const parser::SubscriptTriplet &t) {
-            return std::make_optional<Subscript>(Triplet{
-                TripletPart(std::get<0>(t.t)), TripletPart(std::get<1>(t.t)),
-                TripletPart(std::get<2>(t.t))});
-          },
-          [&](const auto &s) -> std::optional<Subscript> {
-            if (auto subscriptExpr{AsSubscript(Analyze(s))}) {
-              return Subscript{std::move(*subscriptExpr)};
-            } else {
-              return std::nullopt;
-            }
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](const parser::SubscriptTriplet &t) {
+                          return std::make_optional<Subscript>(
+                              Triplet{TripletPart(std::get<0>(t.t)),
+                                  TripletPart(std::get<1>(t.t)),
+                                  TripletPart(std::get<2>(t.t))});
+                        },
+                        [&](const auto &s) -> std::optional<Subscript> {
+                          if (auto subscriptExpr{AsSubscript(Analyze(s))}) {
+                            return Subscript{std::move(*subscriptExpr)};
+                          } else {
+                            return std::nullopt;
+                          }
+                        },
+                    },
       ss.u);
 }
 
@@ -2027,30 +2027,29 @@ const Assignment *ExpressionAnalyzer::Analyze(
       x.typedAssignment.reset(new GenericAssignmentWrapper{});
     } else {
       Assignment assignment{std::move(*lhs), std::move(*rhs)};
-      std::visit(
-          common::visitors{
-              [&](const std::list<parser::BoundsRemapping> &list) {
-                Assignment::BoundsRemapping bounds;
-                for (const auto &elem : list) {
-                  auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
-                  auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
-                  if (lower && upper) {
-                    bounds.emplace_back(
-                        Fold(std::move(*lower)), Fold(std::move(*upper)));
-                  }
-                }
-                assignment.u = std::move(bounds);
-              },
-              [&](const std::list<parser::BoundsSpec> &list) {
-                Assignment::BoundsSpec bounds;
-                for (const auto &bound : list) {
-                  if (auto lower{AsSubscript(Analyze(bound.v))}) {
-                    bounds.emplace_back(Fold(std::move(*lower)));
-                  }
-                }
-                assignment.u = std::move(bounds);
-              },
-          },
+      std::visit(common::visitors{
+                     [&](const std::list<parser::BoundsRemapping> &list) {
+                       Assignment::BoundsRemapping bounds;
+                       for (const auto &elem : list) {
+                         auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
+                         auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
+                         if (lower && upper) {
+                           bounds.emplace_back(Fold(std::move(*lower)),
+                               Fold(std::move(*upper)));
+                         }
+                       }
+                       assignment.u = std::move(bounds);
+                     },
+                     [&](const std::list<parser::BoundsSpec> &list) {
+                       Assignment::BoundsSpec bounds;
+                       for (const auto &bound : list) {
+                         if (auto lower{AsSubscript(Analyze(bound.v))}) {
+                           bounds.emplace_back(Fold(std::move(*lower)));
+                         }
+                       }
+                       assignment.u = std::move(bounds);
+                     },
+                 },
           std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
       x.typedAssignment.reset(
           new GenericAssignmentWrapper{std::move(assignment)});
@@ -2399,14 +2398,14 @@ static void FixMisparsedFunctionReference(
     parser::FunctionReference &funcRef{func->value()};
     auto &proc{std::get<parser::ProcedureDesignator>(funcRef.v.t)};
     if (Symbol *
-        origSymbol{std::visit(
-            common::visitors{
-                [&](parser::Name &name) { return name.symbol; },
-                [&](parser::ProcComponentRef &pcr) {
-                  return pcr.v.thing.component.symbol;
-                },
-            },
-            proc.u)}) {
+        origSymbol{
+            std::visit(common::visitors{
+                           [&](parser::Name &name) { return name.symbol; },
+                           [&](parser::ProcComponentRef &pcr) {
+                             return pcr.v.thing.component.symbol;
+                           },
+                       },
+                proc.u)}) {
       Symbol &symbol{origSymbol->GetUltimate()};
       if (symbol.has<semantics::ObjectEntityDetails>() ||
           symbol.has<semantics::AssocEntityDetails>()) {
@@ -2651,26 +2650,26 @@ void ArgumentAnalyzer::Analyze(
   // be detected and represented (they're not expressions).
   // TODO: C1534: Don't allow a "restricted" specific intrinsic to be passed.
   std::optional<ActualArgument> actual;
-  std::visit(
-      common::visitors{
-          [&](const common::Indirection<parser::Expr> &x) {
-            // TODO: Distinguish & handle procedure name and
-            // proc-component-ref
-            actual = AnalyzeExpr(x.value());
-          },
-          [&](const parser::AltReturnSpec &) {
-            if (!isSubroutine) {
-              context_.Say("alternate return specification may not appear on"
-                           " function reference"_err_en_US);
-            }
-          },
-          [&](const parser::ActualArg::PercentRef &) {
-            context_.Say("TODO: %REF() argument"_err_en_US);
-          },
-          [&](const parser::ActualArg::PercentVal &) {
-            context_.Say("TODO: %VAL() argument"_err_en_US);
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const common::Indirection<parser::Expr> &x) {
+                   // TODO: Distinguish & handle procedure name and
+                   // proc-component-ref
+                   actual = AnalyzeExpr(x.value());
+                 },
+                 [&](const parser::AltReturnSpec &) {
+                   if (!isSubroutine) {
+                     context_.Say(
+                         "alternate return specification may not appear on"
+                         " function reference"_err_en_US);
+                   }
+                 },
+                 [&](const parser::ActualArg::PercentRef &) {
+                   context_.Say("TODO: %REF() argument"_err_en_US);
+                 },
+                 [&](const parser::ActualArg::PercentVal &) {
+                   context_.Say("TODO: %VAL() argument"_err_en_US);
+                 },
+             },
       std::get<parser::ActualArg>(arg.t).u);
   if (actual) {
     if (const auto &argKW{std::get<std::optional<parser::Keyword>>(arg.t)}) {
@@ -3030,14 +3029,13 @@ bool ExprChecker::Walk(const parser::Program &program) {
 }
 
 bool ExprChecker::Pre(const parser::DataStmtConstant &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::NullInit &) {},
-          [&](const parser::InitialDataTarget &y) {
-            AnalyzeExpr(context_, y.value());
-          },
-          [&](const auto &y) { AnalyzeExpr(context_, y); },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::NullInit &) {},
+                 [&](const parser::InitialDataTarget &y) {
+                   AnalyzeExpr(context_, y.value());
+                 },
+                 [&](const auto &y) { AnalyzeExpr(context_, y); },
+             },
       x.u);
   return false;
 }
diff --git a/lib/Semantics/mod-file.cpp b/lib/Semantics/mod-file.cpp
index ba1df939fd74..5dcc19881363 100644
--- a/lib/Semantics/mod-file.cpp
+++ b/lib/Semantics/mod-file.cpp
@@ -70,7 +70,7 @@ static std::string CheckSum(const std::string_view &);
 class SubprogramSymbolCollector {
 public:
   SubprogramSymbolCollector(const Symbol &symbol, const Scope &scope)
-    : symbol_{symbol}, scope_{scope} {}
+      : symbol_{symbol}, scope_{scope} {}
   const SymbolVector &symbols() const { return need_; }
   const std::set<SourceName> &imports() const { return imports_; }
   void Collect();
@@ -79,10 +79,10 @@ class SubprogramSymbolCollector {
   const Symbol &symbol_;
   const Scope &scope_;
   bool isInterface_{false};
-  SymbolVector need_;  // symbols that are needed
-  SymbolSet needSet_;  // symbols already in need_
-  SymbolSet useSet_;  // use-associations that might be needed
-  std::set<SourceName> imports_;  // imports from host that are needed
+  SymbolVector need_; // symbols that are needed
+  SymbolSet needSet_; // symbols already in need_
+  SymbolSet useSet_; // use-associations that might be needed
+  std::set<SourceName> imports_; // imports from host that are needed
 
   void DoSymbol(const Symbol &);
   void DoSymbol(const SourceName &, const Symbol &);
@@ -91,7 +91,7 @@ class SubprogramSymbolCollector {
   void DoParamValue(const ParamValue &);
   bool NeedImport(const SourceName &, const Symbol &);
 
-  template<typename T> void DoExpr(evaluate::Expr<T> expr) {
+  template <typename T> void DoExpr(evaluate::Expr<T> expr) {
     for (const Symbol &symbol : evaluate::CollectSymbols(expr)) {
       DoSymbol(symbol);
     }
@@ -115,7 +115,7 @@ void ModFileWriter::WriteOne(const Scope &scope) {
     if (!symbol->test(Symbol::Flag::ModFile)) {
       Write(*symbol);
     }
-    WriteAll(scope);  // write out submodules
+    WriteAll(scope); // write out submodules
   }
 }
 
@@ -176,7 +176,7 @@ std::string ModFileWriter::GetAsString(const Symbol &symbol) {
 void ModFileWriter::PutSymbols(const Scope &scope) {
   std::string buf;
   llvm::raw_string_ostream typeBindings{
-      buf};  // stuff after CONTAINS in derived type
+      buf}; // stuff after CONTAINS in derived type
   for (const Symbol &symbol : CollectSymbols(scope)) {
     PutSymbol(typeBindings, symbol);
   }
@@ -190,77 +190,76 @@ void ModFileWriter::PutSymbols(const Scope &scope) {
 // procedures, type-bound generics, final procedures) which go to typeBindings.
 void ModFileWriter::PutSymbol(
     llvm::raw_ostream &typeBindings, const Symbol &symbol) {
-  std::visit(
-      common::visitors{
-          [&](const ModuleDetails &) { /* should be current module */ },
-          [&](const DerivedTypeDetails &) { PutDerivedType(symbol); },
-          [&](const SubprogramDetails &) { PutSubprogram(symbol); },
-          [&](const GenericDetails &x) {
-            if (symbol.owner().IsDerivedType()) {
-              // generic binding
-              for (const Symbol &proc : x.specificProcs()) {
-                typeBindings << "generic::" << symbol.name() << "=>"
-                             << proc.name() << '\n';
-              }
-            } else {
-              PutGeneric(symbol);
-              if (x.specific()) {
-                PutSymbol(typeBindings, *x.specific());
-              }
-              if (x.derivedType()) {
-                PutSymbol(typeBindings, *x.derivedType());
-              }
-            }
-          },
-          [&](const UseDetails &) { PutUse(symbol); },
-          [](const UseErrorDetails &) {},
-          [&](const ProcBindingDetails &x) {
-            bool deferred{symbol.attrs().test(Attr::DEFERRED)};
-            typeBindings << "procedure";
-            if (deferred) {
-              typeBindings << '(' << x.symbol().name() << ')';
-            }
-            PutPassName(typeBindings, x.passName());
-            auto attrs{symbol.attrs()};
-            if (x.passName()) {
-              attrs.reset(Attr::PASS);
-            }
-            PutAttrs(typeBindings, attrs);
-            typeBindings << "::" << symbol.name();
-            if (!deferred && x.symbol().name() != symbol.name()) {
-              typeBindings << "=>" << x.symbol().name();
-            }
-            typeBindings << '\n';
-          },
-          [&](const NamelistDetails &x) {
-            decls_ << "namelist/" << symbol.name();
-            char sep{'/'};
-            for (const Symbol &object : x.objects()) {
-              decls_ << sep << object.name();
-              sep = ',';
-            }
-            decls_ << '\n';
-          },
-          [&](const CommonBlockDetails &x) {
-            decls_ << "common/" << symbol.name();
-            char sep = '/';
-            for (const Symbol &object : x.objects()) {
-              decls_ << sep << object.name();
-              sep = ',';
-            }
-            decls_ << '\n';
-            if (symbol.attrs().test(Attr::BIND_C)) {
-              PutAttrs(decls_, symbol.attrs(), x.bindName(), ""s);
-              decls_ << "::/" << symbol.name() << "/\n";
-            }
-          },
-          [&](const FinalProcDetails &) {
-            typeBindings << "final::" << symbol.name() << '\n';
-          },
-          [](const HostAssocDetails &) {},
-          [](const MiscDetails &) {},
-          [&](const auto &) { PutEntity(decls_, symbol); },
-      },
+  std::visit(common::visitors{
+                 [&](const ModuleDetails &) { /* should be current module */ },
+                 [&](const DerivedTypeDetails &) { PutDerivedType(symbol); },
+                 [&](const SubprogramDetails &) { PutSubprogram(symbol); },
+                 [&](const GenericDetails &x) {
+                   if (symbol.owner().IsDerivedType()) {
+                     // generic binding
+                     for (const Symbol &proc : x.specificProcs()) {
+                       typeBindings << "generic::" << symbol.name() << "=>"
+                                    << proc.name() << '\n';
+                     }
+                   } else {
+                     PutGeneric(symbol);
+                     if (x.specific()) {
+                       PutSymbol(typeBindings, *x.specific());
+                     }
+                     if (x.derivedType()) {
+                       PutSymbol(typeBindings, *x.derivedType());
+                     }
+                   }
+                 },
+                 [&](const UseDetails &) { PutUse(symbol); },
+                 [](const UseErrorDetails &) {},
+                 [&](const ProcBindingDetails &x) {
+                   bool deferred{symbol.attrs().test(Attr::DEFERRED)};
+                   typeBindings << "procedure";
+                   if (deferred) {
+                     typeBindings << '(' << x.symbol().name() << ')';
+                   }
+                   PutPassName(typeBindings, x.passName());
+                   auto attrs{symbol.attrs()};
+                   if (x.passName()) {
+                     attrs.reset(Attr::PASS);
+                   }
+                   PutAttrs(typeBindings, attrs);
+                   typeBindings << "::" << symbol.name();
+                   if (!deferred && x.symbol().name() != symbol.name()) {
+                     typeBindings << "=>" << x.symbol().name();
+                   }
+                   typeBindings << '\n';
+                 },
+                 [&](const NamelistDetails &x) {
+                   decls_ << "namelist/" << symbol.name();
+                   char sep{'/'};
+                   for (const Symbol &object : x.objects()) {
+                     decls_ << sep << object.name();
+                     sep = ',';
+                   }
+                   decls_ << '\n';
+                 },
+                 [&](const CommonBlockDetails &x) {
+                   decls_ << "common/" << symbol.name();
+                   char sep = '/';
+                   for (const Symbol &object : x.objects()) {
+                     decls_ << sep << object.name();
+                     sep = ',';
+                   }
+                   decls_ << '\n';
+                   if (symbol.attrs().test(Attr::BIND_C)) {
+                     PutAttrs(decls_, symbol.attrs(), x.bindName(), ""s);
+                     decls_ << "::/" << symbol.name() << "/\n";
+                   }
+                 },
+                 [&](const FinalProcDetails &) {
+                   typeBindings << "final::" << symbol.name() << '\n';
+                 },
+                 [](const HostAssocDetails &) {},
+                 [](const MiscDetails &) {},
+                 [&](const auto &) { PutEntity(decls_, symbol); },
+             },
       symbol.details());
 }
 
@@ -415,7 +414,7 @@ void ModFileWriter::PutUseExtraAttr(
 // Collect the symbols of this scope sorted by their original order, not name.
 // Namelists are an exception: they are sorted after other symbols.
 SymbolVector CollectSymbols(const Scope &scope) {
-  SymbolSet symbols;  // to prevent duplicates
+  SymbolSet symbols; // to prevent duplicates
   SymbolVector sorted;
   SymbolVector namelist;
   SymbolVector common;
@@ -495,7 +494,8 @@ void PutShape(
 
 void PutObjectEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   auto &details{symbol.get<ObjectEntityDetails>()};
-  PutEntity(os, symbol, [&]() { PutType(os, DEREF(symbol.GetType())); },
+  PutEntity(
+      os, symbol, [&]() { PutType(os, DEREF(symbol.GetType())); },
       symbol.attrs());
   PutShape(os, details.shape(), '(', ')');
   PutShape(os, details.coshape(), '[', ']');
@@ -514,7 +514,8 @@ void PutProcEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   if (details.passName()) {
     attrs.reset(Attr::PASS);
   }
-  PutEntity(os, symbol,
+  PutEntity(
+      os, symbol,
       [&]() {
         os << "procedure(";
         if (interface.symbol()) {
@@ -537,7 +538,8 @@ void PutPassName(
 }
 void PutTypeParam(llvm::raw_ostream &os, const Symbol &symbol) {
   auto &details{symbol.get<TypeParamDetails>()};
-  PutEntity(os, symbol,
+  PutEntity(
+      os, symbol,
       [&]() {
         PutType(os, DEREF(symbol.GetType()));
         PutLower(os << ',', common::EnumToString(details.attr()));
@@ -580,13 +582,12 @@ void PutEntity(llvm::raw_ostream &os, const Symbol &symbol,
     std::function<void()> writeType, Attrs attrs) {
   writeType();
   MaybeExpr bindName;
-  std::visit(
-      common::visitors{
-          [&](const SubprogramDetails &x) { bindName = x.bindName(); },
-          [&](const ObjectEntityDetails &x) { bindName = x.bindName(); },
-          [&](const ProcEntityDetails &x) { bindName = x.bindName(); },
-          [&](const auto &) {},
-      },
+  std::visit(common::visitors{
+                 [&](const SubprogramDetails &x) { bindName = x.bindName(); },
+                 [&](const ObjectEntityDetails &x) { bindName = x.bindName(); },
+                 [&](const ProcEntityDetails &x) { bindName = x.bindName(); },
+                 [&](const auto &) {},
+             },
       symbol.details());
   PutAttrs(os, attrs, bindName);
   os << "::" << symbol.name();
@@ -596,8 +597,8 @@ void PutEntity(llvm::raw_ostream &os, const Symbol &symbol,
 // mapped to lower case.
 llvm::raw_ostream &PutAttrs(llvm::raw_ostream &os, Attrs attrs,
     const MaybeExpr &bindName, std::string before, std::string after) {
-  attrs.set(Attr::PUBLIC, false);  // no need to write PUBLIC
-  attrs.set(Attr::EXTERNAL, false);  // no need to write EXTERNAL
+  attrs.set(Attr::PUBLIC, false); // no need to write PUBLIC
+  attrs.set(Attr::EXTERNAL, false); // no need to write EXTERNAL
   if (bindName) {
     bindName->AsFortran(os << before << "bind(c, name=") << ')' << after;
     attrs.set(Attr::BIND_C, false);
@@ -741,7 +742,7 @@ static bool VerifyHeader(llvm::ArrayRef<char> content) {
 }
 
 Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
-  std::string ancestorName;  // empty for module
+  std::string ancestorName; // empty for module
   if (ancestor) {
     if (auto *scope{ancestor->FindSubmodule(name)}) {
       return scope;
@@ -783,7 +784,7 @@ Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
         sourceFile->path());
     return nullptr;
   }
-  Scope *parentScope;  // the scope this module/submodule goes into
+  Scope *parentScope; // the scope this module/submodule goes into
   if (!ancestor) {
     parentScope = &context_.globalScope();
   } else if (std::optional<SourceName> parent{GetSubmoduleParent(*parseTree)}) {
@@ -868,30 +869,29 @@ void SubprogramSymbolCollector::DoSymbol(
     return;
   }
   if (!needSet_.insert(symbol).second) {
-    return;  // already done
-  }
-  std::visit(
-      common::visitors{
-          [this](const ObjectEntityDetails &details) {
-            for (const ShapeSpec &spec : details.shape()) {
-              DoBound(spec.lbound());
-              DoBound(spec.ubound());
-            }
-            for (const ShapeSpec &spec : details.coshape()) {
-              DoBound(spec.lbound());
-              DoBound(spec.ubound());
-            }
-            if (const Symbol * commonBlock{details.commonBlock()}) {
-              DoSymbol(*commonBlock);
-            }
-          },
-          [this](const CommonBlockDetails &details) {
-            for (const Symbol &object : details.objects()) {
-              DoSymbol(object);
-            }
-          },
-          [](const auto &) {},
-      },
+    return; // already done
+  }
+  std::visit(common::visitors{
+                 [this](const ObjectEntityDetails &details) {
+                   for (const ShapeSpec &spec : details.shape()) {
+                     DoBound(spec.lbound());
+                     DoBound(spec.ubound());
+                   }
+                   for (const ShapeSpec &spec : details.coshape()) {
+                     DoBound(spec.lbound());
+                     DoBound(spec.ubound());
+                   }
+                   if (const Symbol * commonBlock{details.commonBlock()}) {
+                     DoSymbol(*commonBlock);
+                   }
+                 },
+                 [this](const CommonBlockDetails &details) {
+                   for (const Symbol &object : details.objects()) {
+                     DoSymbol(object);
+                   }
+                 },
+                 [](const auto &) {},
+             },
       symbol.details());
   if (!symbol.has<UseDetails>()) {
     DoType(symbol.GetType());
@@ -907,7 +907,8 @@ void SubprogramSymbolCollector::DoType(const DeclTypeSpec *type) {
   }
   switch (type->category()) {
   case DeclTypeSpec::Numeric:
-  case DeclTypeSpec::Logical: break;  // nothing to do
+  case DeclTypeSpec::Logical:
+    break; // nothing to do
   case DeclTypeSpec::Character:
     DoParamValue(type->characterTypeSpec().length());
     break;
@@ -956,4 +957,4 @@ bool SubprogramSymbolCollector::NeedImport(
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/mod-file.h b/lib/Semantics/mod-file.h
index d71a0f599af8..2800f315054e 100644
--- a/lib/Semantics/mod-file.h
+++ b/lib/Semantics/mod-file.h
@@ -16,7 +16,7 @@ namespace Fortran::parser {
 class CharBlock;
 class Message;
 class MessageFixedText;
-}
+} // namespace Fortran::parser
 
 namespace llvm {
 class raw_ostream;
@@ -43,7 +43,8 @@ class ModFileWriter {
   std::string containsBuf_;
 
   llvm::raw_string_ostream uses_{usesBuf_};
-  llvm::raw_string_ostream useExtraAttrs_{useExtraAttrsBuf_};  // attrs added to used entity
+  llvm::raw_string_ostream useExtraAttrs_{
+      useExtraAttrsBuf_}; // attrs added to used entity
   llvm::raw_string_ostream decls_{declsBuf_};
   llvm::raw_string_ostream contains_{containsBuf_};
 
@@ -76,5 +77,5 @@ class ModFileReader {
       parser::MessageFixedText &&, const std::string &);
 };
 
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/lib/Semantics/pointer-assignment.cpp b/lib/Semantics/pointer-assignment.cpp
index fdb6addc20de..cb6fcaa933af 100644
--- a/lib/Semantics/pointer-assignment.cpp
+++ b/lib/Semantics/pointer-assignment.cpp
@@ -41,11 +41,11 @@ class PointerAssignmentChecker {
 public:
   PointerAssignmentChecker(evaluate::FoldingContext &context,
       parser::CharBlock source, const std::string &description)
-    : context_{context}, source_{source}, description_{description} {}
+      : context_{context}, source_{source}, description_{description} {}
   PointerAssignmentChecker(evaluate::FoldingContext &context, const Symbol &lhs)
-    : context_{context}, source_{lhs.name()},
-      description_{"pointer '"s + lhs.name().ToString() + '\''}, lhs_{&lhs},
-      procedure_{Procedure::Characterize(lhs, context.intrinsics())} {
+      : context_{context}, source_{lhs.name()},
+        description_{"pointer '"s + lhs.name().ToString() + '\''}, lhs_{&lhs},
+        procedure_{Procedure::Characterize(lhs, context.intrinsics())} {
     set_lhsType(TypeAndShape::Characterize(lhs, context));
     set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS));
     set_isVolatile(lhs.attrs().test(Attr::VOLATILE));
@@ -57,10 +57,10 @@ class PointerAssignmentChecker {
   void Check(const SomeExpr &);
 
 private:
-  template<typename T> void Check(const T &);
-  template<typename T> void Check(const evaluate::Expr<T> &);
-  template<typename T> void Check(const evaluate::FunctionRef<T> &);
-  template<typename T> void Check(const evaluate::Designator<T> &);
+  template <typename T> void Check(const T &);
+  template <typename T> void Check(const evaluate::Expr<T> &);
+  template <typename T> void Check(const evaluate::FunctionRef<T> &);
+  template <typename T> void Check(const evaluate::Designator<T> &);
   void Check(const evaluate::NullPointer &);
   void Check(const evaluate::ProcedureDesignator &);
   void Check(const evaluate::ProcedureRef &);
@@ -68,7 +68,7 @@ class PointerAssignmentChecker {
   void Check(
       parser::CharBlock rhsName, bool isCall, const Procedure * = nullptr);
   bool LhsOkForUnlimitedPoly() const;
-  template<typename... A> parser::Message *Say(A &&...);
+  template <typename... A> parser::Message *Say(A &&...);
 
   evaluate::FoldingContext &context_;
   const parser::CharBlock source_;
@@ -105,22 +105,22 @@ PointerAssignmentChecker &PointerAssignmentChecker::set_isBoundsRemapping(
   return *this;
 }
 
-template<typename T> void PointerAssignmentChecker::Check(const T &) {
+template <typename T> void PointerAssignmentChecker::Check(const T &) {
   // Catch-all case for really bad target expression
   Say("Target associated with %s must be a designator or a call to a"
       " pointer-valued function"_err_en_US,
       description_);
 }
 
-template<typename T>
+template <typename T>
 void PointerAssignmentChecker::Check(const evaluate::Expr<T> &x) {
   std::visit([&](const auto &x) { Check(x); }, x.u);
 }
 
 void PointerAssignmentChecker::Check(const SomeExpr &rhs) {
-  if (HasVectorSubscript(rhs)) {  // C1025
+  if (HasVectorSubscript(rhs)) { // C1025
     Say("An array section with a vector subscript may not be a pointer target"_err_en_US);
-  } else if (ExtractCoarrayRef(rhs)) {  // C1026
+  } else if (ExtractCoarrayRef(rhs)) { // C1026
     Say("A coindexed object may not be a pointer target"_err_en_US);
   } else {
     std::visit([&](const auto &x) { Check(x); }, rhs.u);
@@ -131,7 +131,7 @@ void PointerAssignmentChecker::Check(const evaluate::NullPointer &) {
   // P => NULL() without MOLD=; always OK
 }
 
-template<typename T>
+template <typename T>
 void PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
   std::string funcName;
   const auto *symbol{f.proc().GetSymbol()};
@@ -145,7 +145,7 @@ void PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
     return;
   }
   std::optional<MessageFixedText> msg;
-  const auto &funcResult{proc->functionResult};  // C1025
+  const auto &funcResult{proc->functionResult}; // C1025
   if (!funcResult) {
     msg = "%s is associated with the non-existent result of reference to"
           " procedure"_err_en_US;
@@ -177,7 +177,7 @@ void PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
   }
 }
 
-template<typename T>
+template <typename T>
 void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
   const Symbol *last{d.GetLastSymbol()};
   const Symbol *base{d.GetBaseObject().symbol()};
@@ -191,7 +191,7 @@ void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
     // Shouldn't be here in this function unless lhs is an object pointer.
     msg = "In assignment to procedure %s, the target is not a procedure or"
           " procedure pointer"_err_en_US;
-  } else if (!evaluate::GetLastTarget(GetSymbolVector(d))) {  // C1025
+  } else if (!evaluate::GetLastTarget(GetSymbolVector(d))) { // C1025
     msg = "In assignment to object %s, the target '%s' is not an object with"
           " POINTER or TARGET attributes"_err_en_US;
   } else if (auto rhsType{TypeAndShape::Characterize(d, context_)}) {
@@ -199,7 +199,7 @@ void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
       msg = "%s associated with object '%s' with incompatible type or"
             " shape"_err_en_US;
     } else if (rhsType->corank() > 0 &&
-        (isVolatile_ != last->attrs().test(Attr::VOLATILE))) {  // C1020
+        (isVolatile_ != last->attrs().test(Attr::VOLATILE))) { // C1020
       // TODO: what if A is VOLATILE in A%B%C?  need a better test here
       if (isVolatile_) {
         msg = "Pointer may not be VOLATILE when target is a"
@@ -335,7 +335,7 @@ bool PointerAssignmentChecker::LhsOkForUnlimitedPoly() const {
   }
 }
 
-template<typename... A>
+template <typename... A>
 parser::Message *PointerAssignmentChecker::Say(A &&... x) {
   auto *msg{context_.messages().Say(std::forward<A>(x)...)};
   if (lhs_) {
@@ -377,7 +377,7 @@ static bool CheckPointerBounds(
                     messages.Say(
                         "Pointer bounds require %d elements but target has"
                         " only %d"_err_en_US,
-                        *lhsSize, *rhsSize);  // 10.2.2.3(9)
+                        *lhsSize, *rhsSize); // 10.2.2.3(9)
                   }
                 }
               }
@@ -393,13 +393,13 @@ static bool CheckPointerBounds(
     if (lhs.Rank() != static_cast<int>(numBounds)) {
       messages.Say("Pointer '%s' has rank %d but the number of bounds specified"
                    " is %d"_err_en_US,
-          lhs.AsFortran(), lhs.Rank(), numBounds);  // C1018
+          lhs.AsFortran(), lhs.Rank(), numBounds); // C1018
     }
   }
   if (isBoundsRemapping && rhs.Rank() != 1 &&
       !evaluate::IsSimplyContiguous(rhs, context.intrinsics())) {
     messages.Say("Pointer bounds remapping target must have rank 1 or be"
-                 " simply contiguous"_err_en_US);  // 10.2.2.3(9)
+                 " simply contiguous"_err_en_US); // 10.2.2.3(9)
   }
   return isBoundsRemapping;
 }
@@ -410,7 +410,7 @@ void CheckPointerAssignment(
   const SomeExpr &rhs{assignment.rhs};
   const Symbol *pointer{GetLastSymbol(lhs)};
   if (!pointer) {
-    return;  // error was reported
+    return; // error was reported
   }
   if (!IsPointer(*pointer)) {
     evaluate::SayWithDeclaration(context.messages(), *pointer,
@@ -418,7 +418,7 @@ void CheckPointerAssignment(
     return;
   }
   if (pointer->has<ProcEntityDetails>() && evaluate::ExtractCoarrayRef(lhs)) {
-    context.messages().Say(  // C1027
+    context.messages().Say( // C1027
         "Procedure pointer may not be a coindexed object"_err_en_US);
     return;
   }
@@ -444,4 +444,4 @@ void CheckPointerAssignment(evaluate::FoldingContext &context,
       .Check(rhs);
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/pointer-assignment.h b/lib/Semantics/pointer-assignment.h
index 31131a356e4a..fc64fb7e1656 100644
--- a/lib/Semantics/pointer-assignment.h
+++ b/lib/Semantics/pointer-assignment.h
@@ -34,6 +34,6 @@ void CheckPointerAssignment(evaluate::FoldingContext &,
     parser::CharBlock source, const std::string &description,
     const evaluate::characteristics::DummyDataObject &, const SomeExpr &rhs);
 
-}
+} // namespace Fortran::semantics
 
-#endif  // FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
+#endif // FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
diff --git a/lib/Semantics/program-tree.cpp b/lib/Semantics/program-tree.cpp
index 9325079655d2..e6dfd9b2f51c 100644
--- a/lib/Semantics/program-tree.cpp
+++ b/lib/Semantics/program-tree.cpp
@@ -13,7 +13,7 @@
 
 namespace Fortran::semantics {
 
-template<typename T>
+template <typename T>
 static ProgramTree BuildSubprogramTree(const parser::Name &name, const T &x) {
   const auto &spec{std::get<parser::SpecificationPart>(x.t)};
   const auto &exec{std::get<parser::ExecutionPart>(x.t)};
@@ -37,7 +37,7 @@ static ProgramTree BuildSubprogramTree(
   return ProgramTree{name, spec, nullptr};
 }
 
-template<typename T>
+template <typename T>
 static ProgramTree BuildModuleTree(const parser::Name &name, const T &x) {
   const auto &spec{std::get<parser::SpecificationPart>(x.t)};
   const auto &subps{std::get<std::optional<parser::ModuleSubprogramPart>>(x.t)};
@@ -130,17 +130,17 @@ Symbol::Flag ProgramTree::GetSubpFlag() const {
 
 bool ProgramTree::HasModulePrefix() const {
   using ListType = std::list<parser::PrefixSpec>;
-  const auto *prefixes{std::visit(
-      common::visitors{
-          [](const parser::Statement<parser::FunctionStmt> *x) {
-            return &std::get<ListType>(x->statement.t);
-          },
-          [](const parser::Statement<parser::SubroutineStmt> *x) {
-            return &std::get<ListType>(x->statement.t);
-          },
-          [](const auto *) -> const ListType * { return nullptr; },
-      },
-      stmt_)};
+  const auto *prefixes{
+      std::visit(common::visitors{
+                     [](const parser::Statement<parser::FunctionStmt> *x) {
+                       return &std::get<ListType>(x->statement.t);
+                     },
+                     [](const parser::Statement<parser::SubroutineStmt> *x) {
+                       return &std::get<ListType>(x->statement.t);
+                     },
+                     [](const auto *) -> const ListType * { return nullptr; },
+                 },
+          stmt_)};
   if (prefixes) {
     for (const auto &prefix : *prefixes) {
       if (std::holds_alternative<parser::PrefixSpec::Module>(prefix.u)) {
@@ -189,4 +189,4 @@ void ProgramTree::AddChild(ProgramTree &&child) {
   children_.emplace_back(std::move(child));
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/program-tree.h b/lib/Semantics/program-tree.h
index 43d986be7544..69c133bfbde7 100644
--- a/lib/Semantics/program-tree.h
+++ b/lib/Semantics/program-tree.h
@@ -39,9 +39,9 @@ class ProgramTree {
   static ProgramTree Build(const parser::Submodule &);
   static ProgramTree Build(const parser::BlockData &);
 
-  ENUM_CLASS(Kind,  // kind of node
+  ENUM_CLASS(Kind, // kind of node
       Program, Function, Subroutine, MpSubprogram, Module, Submodule, BlockData)
-  using Stmt = std::variant<  // the statement that introduces the program unit
+  using Stmt = std::variant< // the statement that introduces the program unit
       const parser::Statement<parser::ProgramStmt> *,
       const parser::Statement<parser::FunctionStmt> *,
       const parser::Statement<parser::SubroutineStmt> *,
@@ -52,7 +52,7 @@ class ProgramTree {
 
   ProgramTree(const parser::Name &name, const parser::SpecificationPart &spec,
       const parser::ExecutionPart *exec = nullptr)
-    : name_{name}, spec_{spec}, exec_{exec} {}
+      : name_{name}, spec_{spec}, exec_{exec} {}
 
   const parser::Name &name() const { return name_; }
   Kind GetKind() const;
@@ -63,23 +63,24 @@ class ProgramTree {
   void set_isSpecificationPartResolved(bool yes = true) {
     isSpecificationPartResolved_ = yes;
   }
-  const parser::ParentIdentifier &GetParentId() const;  // only for Submodule
+  const parser::ParentIdentifier &GetParentId() const; // only for Submodule
   const parser::SpecificationPart &spec() const { return spec_; }
   const parser::ExecutionPart *exec() const { return exec_; }
   std::list<ProgramTree> &children() { return children_; }
   const std::list<ProgramTree> &children() const { return children_; }
   Symbol::Flag GetSubpFlag() const;
-  bool IsModule() const;  // Module or Submodule
-  bool HasModulePrefix() const;  // in function or subroutine stmt
+  bool IsModule() const; // Module or Submodule
+  bool HasModulePrefix() const; // in function or subroutine stmt
   Scope *scope() const { return scope_; }
   void set_scope(Scope &);
   void AddChild(ProgramTree &&);
 
-  template<typename T> ProgramTree &set_stmt(const parser::Statement<T> &stmt) {
+  template <typename T>
+  ProgramTree &set_stmt(const parser::Statement<T> &stmt) {
     stmt_ = &stmt;
     return *this;
   }
-  template<typename T>
+  template <typename T>
   ProgramTree &set_endStmt(const parser::Statement<T> &stmt) {
     endStmt_ = &stmt.source;
     return *this;
@@ -97,5 +98,5 @@ class ProgramTree {
   bool isSpecificationPartResolved_{false};
 };
 
-}
-#endif  // FORTRAN_SEMANTICS_PROGRAM_TREE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_PROGRAM_TREE_H_
diff --git a/lib/Semantics/resolve-labels.cpp b/lib/Semantics/resolve-labels.cpp
index 55d60ac1729a..66f86c6c4e51 100644
--- a/lib/Semantics/resolve-labels.cpp
+++ b/lib/Semantics/resolve-labels.cpp
@@ -39,8 +39,8 @@ struct SourceStatementInfoTuplePOD {
   SourceStatementInfoTuplePOD(const parser::Label &parserLabel,
       const ProxyForScope &proxyForScope,
       const parser::CharBlock &parserCharBlock)
-    : parserLabel{parserLabel}, proxyForScope{proxyForScope},
-      parserCharBlock{parserCharBlock} {}
+      : parserLabel{parserLabel}, proxyForScope{proxyForScope},
+        parserCharBlock{parserCharBlock} {}
   parser::Label parserLabel;
   ProxyForScope proxyForScope;
   parser::CharBlock parserCharBlock;
@@ -51,7 +51,7 @@ enum class Legality { never, always, formerly };
 bool HasScope(ProxyForScope scope) { return scope != ProxyForScope{0u}; }
 
 // F18:R1131
-template<typename A>
+template <typename A>
 constexpr Legality IsLegalDoTerm(const parser::Statement<A> &) {
   if (std::is_same_v<A, common::Indirection<parser::EndDoStmt>> ||
       std::is_same_v<A, parser::EndDoStmt>) {
@@ -92,11 +92,11 @@ constexpr Legality IsLegalDoTerm(
   }
 }
 
-template<typename A> constexpr bool IsFormat(const parser::Statement<A> &) {
+template <typename A> constexpr bool IsFormat(const parser::Statement<A> &) {
   return std::is_same_v<A, common::Indirection<parser::FormatStmt>>;
 }
 
-template<typename A>
+template <typename A>
 constexpr Legality IsLegalBranchTarget(const parser::Statement<A> &) {
   if (std::is_same_v<A, parser::ActionStmt> ||
       std::is_same_v<A, parser::AssociateStmt> ||
@@ -128,7 +128,7 @@ constexpr Legality IsLegalBranchTarget(const parser::Statement<A> &) {
   }
 }
 
-template<typename A>
+template <typename A>
 constexpr LabeledStmtClassificationSet ConstructBranchTargetFlags(
     const parser::Statement<A> &statement) {
   LabeledStmtClassificationSet labeledStmtClassificationSet{};
@@ -155,11 +155,11 @@ static unsigned SayLabel(parser::Label label) {
 struct UnitAnalysis {
   UnitAnalysis() { scopeModel.push_back(0); }
   UnitAnalysis(UnitAnalysis &&that)
-    : doStmtSources{std::move(that.doStmtSources)},
-      formatStmtSources{std::move(that.formatStmtSources)},
-      otherStmtSources{std::move(that.otherStmtSources)},
-      targetStmts{std::move(that.targetStmts)}, scopeModel{std::move(
-                                                    that.scopeModel)} {}
+      : doStmtSources{std::move(that.doStmtSources)},
+        formatStmtSources{std::move(that.formatStmtSources)},
+        otherStmtSources{std::move(that.otherStmtSources)},
+        targetStmts{std::move(that.targetStmts)}, scopeModel{std::move(
+                                                      that.scopeModel)} {}
 
   SourceStmtList doStmtSources;
   SourceStmtList formatStmtSources;
@@ -171,7 +171,7 @@ struct UnitAnalysis {
 // Some parse tree record for statements simply wrap construct names;
 // others include them as tuple components.  Given a statement,
 // return a pointer to its name if it has one.
-template<typename A>
+template <typename A>
 const parser::CharBlock *GetStmtName(const parser::Statement<A> &stmt) {
   const std::optional<parser::Name> *name{nullptr};
   if constexpr (WrapperTrait<A>) {
@@ -199,7 +199,7 @@ using ExecutableConstructEndStmts = std::tuple<parser::EndIfStmt,
     parser::EndDoStmt, parser::EndSelectStmt, parser::EndChangeTeamStmt,
     parser::EndBlockStmt, parser::EndCriticalStmt, parser::EndAssociateStmt>;
 
-template<typename A>
+template <typename A>
 static constexpr bool IsExecutableConstructEndStmt{
     common::HasMember<A, ExecutableConstructEndStmts>};
 
@@ -208,10 +208,10 @@ class ParseTreeAnalyzer {
   ParseTreeAnalyzer(ParseTreeAnalyzer &&that) = default;
   ParseTreeAnalyzer(SemanticsContext &context) : context_{context} {}
 
-  template<typename A> constexpr bool Pre(const A &) { return true; }
-  template<typename A> constexpr void Post(const A &) {}
+  template <typename A> constexpr bool Pre(const A &) { return true; }
+  template <typename A> constexpr void Post(const A &) {}
 
-  template<typename A> bool Pre(const parser::Statement<A> &statement) {
+  template <typename A> bool Pre(const parser::Statement<A> &statement) {
     currentPosition_ = statement.source;
     if (statement.label) {
       auto label{statement.label.value()};
@@ -331,7 +331,7 @@ class ParseTreeAnalyzer {
   // and their intermediate or terminal statements that allow optional
   // construct names(e.g., ELSE).  When an optional construct name is present,
   // the construct as a whole must have a name that matches.
-  template<typename FIRST, typename CONSTRUCT, typename STMT>
+  template <typename FIRST, typename CONSTRUCT, typename STMT>
   void CheckOptionalName(const char *constructTag, const CONSTRUCT &a,
       const parser::Statement<STMT> &stmt) {
     if (const parser::CharBlock * name{GetStmtName(stmt)}) {
@@ -520,7 +520,7 @@ class ParseTreeAnalyzer {
     return PushSubscope();
   }
 
-  template<typename A> bool PushConstructName(const A &a) {
+  template <typename A> bool PushConstructName(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.emplace_back(optionalName->ToString());
@@ -536,7 +536,7 @@ class ParseTreeAnalyzer {
     }
     return PushSubscope();
   }
-  template<typename A> bool PushConstructNameWithoutBlock(const A &a) {
+  template <typename A> bool PushConstructNameWithoutBlock(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.emplace_back(optionalName->ToString());
@@ -544,11 +544,11 @@ class ParseTreeAnalyzer {
     return true;
   }
 
-  template<typename A> void PopConstructNameWithoutBlock(const A &a) {
+  template <typename A> void PopConstructNameWithoutBlock(const A &a) {
     CheckName(a);
     PopConstructNameIfPresent(a);
   }
-  template<typename A> void PopConstructNameIfPresent(const A &a) {
+  template <typename A> void PopConstructNameIfPresent(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.pop_back();
@@ -563,13 +563,13 @@ class ParseTreeAnalyzer {
     }
   }
 
-  template<typename A> void PopConstructName(const A &a) {
+  template <typename A> void PopConstructName(const A &a) {
     CheckName(a);
     PopScope();
     PopConstructNameIfPresent(a);
   }
 
-  template<typename FIRST, typename CASEBLOCK, typename CASE,
+  template <typename FIRST, typename CASEBLOCK, typename CASE,
       typename CONSTRUCT>
   void CheckSelectNames(const char *tag, const CONSTRUCT &construct) {
     CheckEndName<FIRST, parser::EndSelectStmt>(tag, construct);
@@ -609,7 +609,7 @@ class ParseTreeAnalyzer {
 
   // Checks for missing or mismatching names on various constructs (e.g., BLOCK)
   // and their END statements.  Both names must be present if either one is.
-  template<typename FIRST, typename END, typename CONSTRUCT>
+  template <typename FIRST, typename END, typename CONSTRUCT>
   void CheckEndName(const char *constructTag, const CONSTRUCT &a) {
     const auto &constructStmt{std::get<parser::Statement<FIRST>>(a.t)};
     const auto &endStmt{std::get<parser::Statement<END>>(a.t)};
@@ -1024,4 +1024,4 @@ bool CheckConstraints(ParseTreeAnalyzer &&parseTreeAnalysis) {
 bool ValidateLabels(SemanticsContext &context, const parser::Program &program) {
   return CheckConstraints(LabelAnalysis(context, program));
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/resolve-labels.h b/lib/Semantics/resolve-labels.h
index 6538a00cf18d..296a90305a41 100644
--- a/lib/Semantics/resolve-labels.h
+++ b/lib/Semantics/resolve-labels.h
@@ -21,5 +21,5 @@ class SemanticsContext;
 /// \param program    the parse tree of the program
 /// \return true, iff the program's labels pass semantics checks
 bool ValidateLabels(SemanticsContext &context, const parser::Program &program);
-}
-#endif  // FORTRAN_SEMANTICS_RESOLVE_LABELS_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_RESOLVE_LABELS_H_
diff --git a/lib/Semantics/resolve-names-utils.cpp b/lib/Semantics/resolve-names-utils.cpp
index 4c0e70e8caf4..5d1014aacec5 100644
--- a/lib/Semantics/resolve-names-utils.cpp
+++ b/lib/Semantics/resolve-names-utils.cpp
@@ -172,23 +172,40 @@ void GenericSpecInfo::Analyze(const parser::GenericSpec &x) {
 static GenericKind MapIntrinsicOperator(IntrinsicOperator op) {
   switch (op) {
     SWITCH_COVERS_ALL_CASES
-  case IntrinsicOperator::Concat: return GenericKind::OtherKind::Concat;
-  case IntrinsicOperator::Power: return NumericOperator::Power;
-  case IntrinsicOperator::Multiply: return NumericOperator::Multiply;
-  case IntrinsicOperator::Divide: return NumericOperator::Divide;
-  case IntrinsicOperator::Add: return NumericOperator::Add;
-  case IntrinsicOperator::Subtract: return NumericOperator::Subtract;
-  case IntrinsicOperator::AND: return LogicalOperator::And;
-  case IntrinsicOperator::OR: return LogicalOperator::Or;
-  case IntrinsicOperator::EQV: return LogicalOperator::Eqv;
-  case IntrinsicOperator::NEQV: return LogicalOperator::Neqv;
-  case IntrinsicOperator::NOT: return LogicalOperator::Not;
-  case IntrinsicOperator::LT: return RelationalOperator::LT;
-  case IntrinsicOperator::LE: return RelationalOperator::LE;
-  case IntrinsicOperator::EQ: return RelationalOperator::EQ;
-  case IntrinsicOperator::NE: return RelationalOperator::NE;
-  case IntrinsicOperator::GE: return RelationalOperator::GE;
-  case IntrinsicOperator::GT: return RelationalOperator::GT;
+  case IntrinsicOperator::Concat:
+    return GenericKind::OtherKind::Concat;
+  case IntrinsicOperator::Power:
+    return NumericOperator::Power;
+  case IntrinsicOperator::Multiply:
+    return NumericOperator::Multiply;
+  case IntrinsicOperator::Divide:
+    return NumericOperator::Divide;
+  case IntrinsicOperator::Add:
+    return NumericOperator::Add;
+  case IntrinsicOperator::Subtract:
+    return NumericOperator::Subtract;
+  case IntrinsicOperator::AND:
+    return LogicalOperator::And;
+  case IntrinsicOperator::OR:
+    return LogicalOperator::Or;
+  case IntrinsicOperator::EQV:
+    return LogicalOperator::Eqv;
+  case IntrinsicOperator::NEQV:
+    return LogicalOperator::Neqv;
+  case IntrinsicOperator::NOT:
+    return LogicalOperator::Not;
+  case IntrinsicOperator::LT:
+    return RelationalOperator::LT;
+  case IntrinsicOperator::LE:
+    return RelationalOperator::LE;
+  case IntrinsicOperator::EQ:
+    return RelationalOperator::EQ;
+  case IntrinsicOperator::NE:
+    return RelationalOperator::NE;
+  case IntrinsicOperator::GE:
+    return RelationalOperator::GE;
+  case IntrinsicOperator::GT:
+    return RelationalOperator::GT;
   }
 }
 
@@ -203,7 +220,7 @@ class ArraySpecAnalyzer {
   SemanticsContext &context_;
   ArraySpec arraySpec_;
 
-  template<typename T> void Analyze(const std::list<T> &list) {
+  template <typename T> void Analyze(const std::list<T> &list) {
     for (const auto &elem : list) {
       Analyze(elem);
     }
@@ -240,15 +257,14 @@ ArraySpec ArraySpecAnalyzer::Analyze(const parser::ComponentArraySpec &x) {
   return arraySpec_;
 }
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::ArraySpec &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::AssumedSizeSpec &y) {
-            Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
-            Analyze(std::get<parser::AssumedImpliedSpec>(y.t));
-          },
-          [&](const parser::ImpliedShapeSpec &y) { Analyze(y.v); },
-          [&](const auto &y) { Analyze(y); },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::AssumedSizeSpec &y) {
+                   Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
+                   Analyze(std::get<parser::AssumedImpliedSpec>(y.t));
+                 },
+                 [&](const parser::ImpliedShapeSpec &y) { Analyze(y.v); },
+                 [&](const auto &y) { Analyze(y); },
+             },
       x.u);
   CHECK(!arraySpec_.empty());
   return arraySpec_;
@@ -356,15 +372,15 @@ void EquivalenceSets::AddToSet(const parser::Designator &designator) {
 }
 
 void EquivalenceSets::FinishSet(const parser::CharBlock &source) {
-  std::set<std::size_t> existing;  // indices of sets intersecting this one
+  std::set<std::size_t> existing; // indices of sets intersecting this one
   for (auto &obj : currSet_) {
     auto it{objectToSet_.find(obj)};
     if (it != objectToSet_.end()) {
-      existing.insert(it->second);  // symbol already in this set
+      existing.insert(it->second); // symbol already in this set
     }
   }
   if (existing.empty()) {
-    sets_.push_back({});  // create a new equivalence set
+    sets_.push_back({}); // create a new equivalence set
     MergeInto(source, currSet_, sets_.size() - 1);
   } else {
     auto it{existing.begin()};
@@ -388,7 +404,7 @@ bool EquivalenceSets::CheckCanEquivalence(
   bool isChar1{IsCharacterSequenceType(type1)};
   bool isChar2{IsCharacterSequenceType(type2)};
   if (sym1.attrs().test(Attr::PROTECTED) &&
-      !sym2.attrs().test(Attr::PROTECTED)) {  // C8114
+      !sym2.attrs().test(Attr::PROTECTED)) { // C8114
     msg = "Equivalence set cannot contain '%s'"
           " with PROTECTED attribute and '%s' without"_err_en_US;
   } else if (isNum1) {
@@ -398,7 +414,7 @@ bool EquivalenceSets::CheckCanEquivalence(
         msg = "Equivalence set contains '%s' that is numeric sequence "
               "type and '%s' that is character"_en_US;
       }
-    } else if (!isNum2) {  // C8110
+    } else if (!isNum2) { // C8110
       msg = "Equivalence set cannot contain '%s'"
             " that is numeric sequence type and '%s' that is not"_err_en_US;
     }
@@ -409,11 +425,11 @@ bool EquivalenceSets::CheckCanEquivalence(
         msg = "Equivalence set contains '%s' that is character sequence "
               "type and '%s' that is numeric"_en_US;
       }
-    } else if (!isChar2) {  // C8111
+    } else if (!isChar2) { // C8111
       msg = "Equivalence set cannot contain '%s'"
             " that is character sequence type and '%s' that is not"_err_en_US;
     }
-  } else if (!isNum2 && !isChar2 && *type1 != *type2) {  // C8112, C8113
+  } else if (!isNum2 && !isChar2 && *type1 != *type2) { // C8112, C8113
     msg = "Equivalence set cannot contain '%s' and '%s' with different types"
           " that are neither numeric nor character sequence types"_err_en_US;
   }
@@ -432,7 +448,7 @@ void EquivalenceSets::MergeInto(const parser::CharBlock &source,
   for (const auto &obj : src) {
     if (const auto *obj2{Find(dst, obj.symbol)}) {
       if (obj == *obj2) {
-        continue;  // already there
+        continue; // already there
       }
       context_.Say(source,
           "'%s' and '%s' cannot have the same first storage unit"_err_en_US,
@@ -487,7 +503,7 @@ bool EquivalenceSets::CheckDataRef(
       common::visitors{
           [&](const parser::Name &name) { return CheckObject(name); },
           [&](const common::Indirection<parser::StructureComponent> &) {
-            context_.Say(source,  // C8107
+            context_.Say(source, // C8107
                 "Derived type component '%s' is not allowed in an equivalence set"_err_en_US,
                 source);
             return false;
@@ -498,7 +514,7 @@ bool EquivalenceSets::CheckDataRef(
               ok &= std::visit(
                   common::visitors{
                       [&](const parser::SubscriptTriplet &) {
-                        context_.Say(source,  // C924, R872
+                        context_.Say(source, // C924, R872
                             "Array section '%s' is not allowed in an equivalence set"_err_en_US,
                             source);
                         return false;
@@ -512,7 +528,7 @@ bool EquivalenceSets::CheckDataRef(
             return ok;
           },
           [&](const common::Indirection<parser::CoindexedNamedObject> &) {
-            context_.Say(source,  // C924 (R872)
+            context_.Say(source, // C924 (R872)
                 "Coindexed object '%s' is not allowed in an equivalence set"_err_en_US,
                 source);
             return false;
@@ -533,43 +549,43 @@ static bool InCommonWithBind(const Symbol &symbol) {
 // If symbol can't be in equivalence set report error and return false;
 bool EquivalenceSets::CheckObject(const parser::Name &name) {
   if (!name.symbol) {
-    return false;  // an error has already occurred
+    return false; // an error has already occurred
   }
   currObject_.symbol = name.symbol;
   parser::MessageFixedText msg{"", 0};
   const Symbol &symbol{*name.symbol};
-  if (symbol.owner().IsDerivedType()) {  // C8107
+  if (symbol.owner().IsDerivedType()) { // C8107
     msg = "Derived type component '%s'"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.IsDummy()) {  // C8106
+  } else if (symbol.IsDummy()) { // C8106
     msg = "Dummy argument '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.IsFuncResult()) {  // C8106
+  } else if (symbol.IsFuncResult()) { // C8106
     msg = "Function result '%s' is not allow in an equivalence set"_err_en_US;
-  } else if (IsPointer(symbol)) {  // C8106
+  } else if (IsPointer(symbol)) { // C8106
     msg = "Pointer '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (IsAllocatable(symbol)) {  // C8106
+  } else if (IsAllocatable(symbol)) { // C8106
     msg = "Allocatable variable '%s'"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.Corank() > 0) {  // C8106
+  } else if (symbol.Corank() > 0) { // C8106
     msg = "Coarray '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.has<UseDetails>()) {  // C8115
+  } else if (symbol.has<UseDetails>()) { // C8115
     msg = "Use-associated variable '%s'"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.attrs().test(Attr::BIND_C)) {  // C8106
+  } else if (symbol.attrs().test(Attr::BIND_C)) { // C8106
     msg = "Variable '%s' with BIND attribute"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.attrs().test(Attr::TARGET)) {  // C8108
+  } else if (symbol.attrs().test(Attr::TARGET)) { // C8108
     msg = "Variable '%s' with TARGET attribute"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (IsNamedConstant(symbol)) {  // C8106
+  } else if (IsNamedConstant(symbol)) { // C8106
     msg = "Named constant '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (InCommonWithBind(symbol)) {  // C8106
+  } else if (InCommonWithBind(symbol)) { // C8106
     msg = "Variable '%s' in common block with BIND attribute"
           " is not allowed in an equivalence set"_err_en_US;
   } else if (const auto *type{symbol.GetType()}) {
     if (const auto *derived{type->AsDerived()}) {
       if (const auto *comp{FindUltimateComponent(
-              *derived, IsAllocatableOrPointer)}) {  // C8106
+              *derived, IsAllocatableOrPointer)}) { // C8106
         msg = IsPointer(*comp)
             ? "Derived type object '%s' with pointer ultimate component"
               " is not allowed in an equivalence set"_err_en_US
@@ -605,14 +621,14 @@ bool EquivalenceSets::CheckArrayBound(const parser::Expr &bound) {
     return false;
   }
   if (expr->Rank() > 0) {
-    context_.Say(bound.source,  // C924, R872
+    context_.Say(bound.source, // C924, R872
         "Array with vector subscript '%s' is not allowed in an equivalence set"_err_en_US,
         bound.source);
     return false;
   }
   auto subscript{evaluate::ToInt64(*expr)};
   if (!subscript) {
-    context_.Say(bound.source,  // C8109
+    context_.Say(bound.source, // C8109
         "Array with nonconstant subscript '%s' is not allowed in an equivalence set"_err_en_US,
         bound.source);
     return false;
@@ -630,7 +646,7 @@ bool EquivalenceSets::CheckSubstringBound(
   }
   auto subscript{evaluate::ToInt64(*expr)};
   if (!subscript) {
-    context_.Say(bound.source,  // C8109
+    context_.Say(bound.source, // C8109
         "Substring with nonconstant bound '%s' is not allowed in an equivalence set"_err_en_US,
         bound.source);
     return false;
@@ -638,7 +654,7 @@ bool EquivalenceSets::CheckSubstringBound(
   if (!isStart) {
     auto start{currObject_.substringStart};
     if (*subscript < (start ? *start : 1)) {
-      context_.Say(bound.source,  // C8116
+      context_.Say(bound.source, // C8116
           "Substring with zero length is not allowed in an equivalence set"_err_en_US);
       return false;
     }
@@ -663,11 +679,13 @@ bool EquivalenceSets::IsDefaultKindNumericType(const IntrinsicTypeSpec &type) {
     auto defaultKind{context_.GetDefaultKind(category)};
     switch (category) {
     case TypeCategory::Integer:
-    case TypeCategory::Logical: return *kind == defaultKind;
+    case TypeCategory::Logical:
+      return *kind == defaultKind;
     case TypeCategory::Real:
     case TypeCategory::Complex:
       return *kind == defaultKind || *kind == context_.doublePrecisionKind();
-    default: return false;
+    default:
+      return false;
     }
   }
   return false;
@@ -701,4 +719,4 @@ bool EquivalenceSets::IsSequenceType(const DeclTypeSpec *type,
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/resolve-names-utils.h b/lib/Semantics/resolve-names-utils.h
index 055e47db1253..e04f58f1cc57 100644
--- a/lib/Semantics/resolve-names-utils.h
+++ b/lib/Semantics/resolve-names-utils.h
@@ -28,7 +28,7 @@ struct Designator;
 struct Expr;
 struct GenericSpec;
 struct Name;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -108,16 +108,16 @@ class EquivalenceSets {
       const DeclTypeSpec *, std::function<bool(const IntrinsicTypeSpec &)>);
 
   SemanticsContext &context_;
-  std::vector<EquivalenceSet> sets_;  // all equivalence sets in this scope
+  std::vector<EquivalenceSet> sets_; // all equivalence sets in this scope
   // Map object to index of set it is in
   std::map<EquivalenceObject, std::size_t> objectToSet_;
-  EquivalenceSet currSet_;  // equivalence set currently being constructed
+  EquivalenceSet currSet_; // equivalence set currently being constructed
   struct {
     Symbol *symbol{nullptr};
     std::vector<ConstantSubscript> subscripts;
     std::optional<ConstantSubscript> substringStart;
-  } currObject_;  // equivalence object currently being constructed
+  } currObject_; // equivalence object currently being constructed
 };
 
-}
-#endif  // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 22f37a0347ec..805a9c7a9979 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -1544,12 +1544,11 @@ bool AttrsVisitor::SetPassNameOn(Symbol &symbol) {
   if (!passName_) {
     return false;
   }
-  std::visit(
-      common::visitors{
-          [&](ProcEntityDetails &x) { x.set_passName(*passName_); },
-          [&](ProcBindingDetails &x) { x.set_passName(*passName_); },
-          [](auto &) { common::die("unexpected pass name"); },
-      },
+  std::visit(common::visitors{
+                 [&](ProcEntityDetails &x) { x.set_passName(*passName_); },
+                 [&](ProcBindingDetails &x) { x.set_passName(*passName_); },
+                 [](auto &) { common::die("unexpected pass name"); },
+             },
       symbol.details());
   return true;
 }
@@ -1747,23 +1746,23 @@ void ImplicitRulesVisitor::Post(const parser::ParameterStmt &) {
 }
 
 bool ImplicitRulesVisitor::Pre(const parser::ImplicitStmt &x) {
-  bool result{std::visit(
-      common::visitors{
-          [&](const std::list<ImplicitNoneNameSpec> &y) {
-            return HandleImplicitNone(y);
-          },
-          [&](const std::list<parser::ImplicitSpec> &) {
-            if (prevImplicitNoneType_) {
-              Say("IMPLICIT statement after IMPLICIT NONE or "
-                  "IMPLICIT NONE(TYPE) statement"_err_en_US);
-              return false;
-            } else {
-              implicitRules().set_isImplicitNoneType(false);
-            }
-            return true;
-          },
-      },
-      x.u)};
+  bool result{
+      std::visit(common::visitors{
+                     [&](const std::list<ImplicitNoneNameSpec> &y) {
+                       return HandleImplicitNone(y);
+                     },
+                     [&](const std::list<parser::ImplicitSpec> &) {
+                       if (prevImplicitNoneType_) {
+                         Say("IMPLICIT statement after IMPLICIT NONE or "
+                             "IMPLICIT NONE(TYPE) statement"_err_en_US);
+                         return false;
+                       } else {
+                         implicitRules().set_isImplicitNoneType(false);
+                       }
+                       return true;
+                     },
+                 },
+          x.u)};
   prevImplicit_ = currStmtSource();
   return result;
 }
@@ -2107,18 +2106,17 @@ void ScopeHandler::EraseSymbol(const parser::Name &name) {
 
 static bool NeedsType(const Symbol &symbol) {
   return !symbol.GetType() &&
-      std::visit(
-          common::visitors{
-              [](const EntityDetails &) { return true; },
-              [](const ObjectEntityDetails &) { return true; },
-              [](const AssocEntityDetails &) { return true; },
-              [&](const ProcEntityDetails &p) {
-                return symbol.test(Symbol::Flag::Function) &&
-                    !symbol.attrs().test(Attr::INTRINSIC) &&
-                    !p.interface().type() && !p.interface().symbol();
-              },
-              [](const auto &) { return false; },
-          },
+      std::visit(common::visitors{
+                     [](const EntityDetails &) { return true; },
+                     [](const ObjectEntityDetails &) { return true; },
+                     [](const AssocEntityDetails &) { return true; },
+                     [&](const ProcEntityDetails &p) {
+                       return symbol.test(Symbol::Flag::Function) &&
+                           !symbol.attrs().test(Attr::INTRINSIC) &&
+                           !p.interface().type() && !p.interface().symbol();
+                     },
+                     [](const auto &) { return false; },
+                 },
           symbol.details());
 }
 void ScopeHandler::ApplyImplicitRules(Symbol &symbol) {
@@ -2216,16 +2214,15 @@ void ScopeHandler::MakeExternal(Symbol &symbol) {
 // ModuleVisitor implementation
 
 bool ModuleVisitor::Pre(const parser::Only &x) {
-  std::visit(
-      common::visitors{
-          [&](const Indirection<parser::GenericSpec> &generic) {
-            AddUse(GenericSpecInfo{generic.value()});
-          },
-          [&](const parser::Name &name) {
-            Resolve(name, AddUse(name.source, name.source).use);
-          },
-          [&](const parser::Rename &rename) { Walk(rename); },
-      },
+  std::visit(common::visitors{
+                 [&](const Indirection<parser::GenericSpec> &generic) {
+                   AddUse(GenericSpecInfo{generic.value()});
+                 },
+                 [&](const parser::Name &name) {
+                   Resolve(name, AddUse(name.source, name.source).use);
+                 },
+                 [&](const parser::Rename &rename) { Walk(rename); },
+             },
       x.u);
   return false;
 }
@@ -2268,15 +2265,14 @@ void ModuleVisitor::Post(const parser::UseStmt &x) {
     // then add a use for each public name that was not renamed.
     std::set<SourceName> useNames;
     for (const auto &rename : *list) {
-      std::visit(
-          common::visitors{
-              [&](const parser::Rename::Names &names) {
-                useNames.insert(std::get<1>(names.t).source);
-              },
-              [&](const parser::Rename::Operators &ops) {
-                useNames.insert(std::get<1>(ops.t).v.source);
-              },
-          },
+      std::visit(common::visitors{
+                     [&](const parser::Rename::Names &names) {
+                       useNames.insert(std::get<1>(names.t).source);
+                     },
+                     [&](const parser::Rename::Operators &ops) {
+                       useNames.insert(std::get<1>(ops.t).v.source);
+                     },
+                 },
           rename.u);
     }
     for (const auto &[name, symbol] : *useModuleScope_) {
@@ -4905,30 +4901,30 @@ bool ConstructVisitor::Pre(const parser::DataImpliedDo &x) {
 }
 
 bool ConstructVisitor::Pre(const parser::DataStmtObject &x) {
-  std::visit(
-      common::visitors{
-          [&](const Indirection<parser::Variable> &y) {
-            Walk(y.value());
-            if (const auto *designator{
-                    std::get_if<Indirection<parser::Designator>>(
-                        &y.value().u)}) {
-              if (const parser::Name *
-                  name{ResolveDesignator(designator->value())}) {
-                if (name->symbol) {
-                  name->symbol->set(Symbol::Flag::InDataStmt);
-                }
-              }
-              // TODO check C874 - C881
-            } else {
-              // TODO report C875 error: variable is not a designator here?
-            }
-          },
-          [&](const parser::DataImpliedDo &y) {
-            PushScope(Scope::Kind::ImpliedDos, nullptr);
-            Walk(y);
-            PopScope();
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const Indirection<parser::Variable> &y) {
+                   Walk(y.value());
+                   if (const auto *designator{
+                           std::get_if<Indirection<parser::Designator>>(
+                               &y.value().u)}) {
+                     if (const parser::Name *
+                         name{ResolveDesignator(designator->value())}) {
+                       if (name->symbol) {
+                         name->symbol->set(Symbol::Flag::InDataStmt);
+                       }
+                     }
+                     // TODO check C874 - C881
+                   } else {
+                     // TODO report C875 error: variable is not a designator
+                     // here?
+                   }
+                 },
+                 [&](const parser::DataImpliedDo &y) {
+                   PushScope(Scope::Kind::ImpliedDos, nullptr);
+                   Walk(y);
+                   PopScope();
+                 },
+             },
       x.u);
   return false;
 }
@@ -5181,15 +5177,14 @@ void ConstructVisitor::SetAttrsFromAssociation(Symbol &symbol) {
 
 ConstructVisitor::Selector ConstructVisitor::ResolveSelector(
     const parser::Selector &x) {
-  return std::visit(
-      common::visitors{
-          [&](const parser::Expr &expr) {
-            return Selector{expr.source, EvaluateExpr(expr)};
-          },
-          [&](const parser::Variable &var) {
-            return Selector{var.GetSource(), EvaluateExpr(var)};
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](const parser::Expr &expr) {
+                          return Selector{expr.source, EvaluateExpr(expr)};
+                        },
+                        [&](const parser::Variable &var) {
+                          return Selector{var.GetSource(), EvaluateExpr(var)};
+                        },
+                    },
       x.u);
 }
 
@@ -5365,13 +5360,12 @@ const parser::Name *DeclarationVisitor::ResolveVariable(
           [&](const Indirection<parser::FunctionReference> &y) {
             const auto &proc{
                 std::get<parser::ProcedureDesignator>(y.value().v.t)};
-            return std::visit(
-                common::visitors{
-                    [&](const parser::Name &z) { return &z; },
-                    [&](const parser::ProcComponentRef &z) {
-                      return ResolveStructureComponent(z.v.thing);
-                    },
-                },
+            return std::visit(common::visitors{
+                                  [&](const parser::Name &z) { return &z; },
+                                  [&](const parser::ProcComponentRef &z) {
+                                    return ResolveStructureComponent(z.v.thing);
+                                  },
+                              },
                 proc.u);
           },
       },
@@ -5964,23 +5958,21 @@ bool ResolveNamesVisitor::Pre(const parser::ImplicitStmt &x) {
 }
 
 void ResolveNamesVisitor::Post(const parser::PointerObject &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::Name &x) { ResolveName(x); },
-          [&](const parser::StructureComponent &x) {
-            ResolveStructureComponent(x);
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::Name &x) { ResolveName(x); },
+                 [&](const parser::StructureComponent &x) {
+                   ResolveStructureComponent(x);
+                 },
+             },
       x.u);
 }
 void ResolveNamesVisitor::Post(const parser::AllocateObject &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::Name &x) { ResolveName(x); },
-          [&](const parser::StructureComponent &x) {
-            ResolveStructureComponent(x);
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::Name &x) { ResolveName(x); },
+                 [&](const parser::StructureComponent &x) {
+                   ResolveStructureComponent(x);
+                 },
+             },
       x.u);
 }
 
diff --git a/lib/Semantics/resolve-names.h b/lib/Semantics/resolve-names.h
index 218dc9c63eae..1a16f0936c66 100644
--- a/lib/Semantics/resolve-names.h
+++ b/lib/Semantics/resolve-names.h
@@ -30,6 +30,6 @@ bool ResolveNames(SemanticsContext &, const parser::Program &);
 void ResolveSpecificationParts(SemanticsContext &, const Symbol &);
 void DumpSymbols(llvm::raw_ostream &);
 
-}
+} // namespace Fortran::semantics
 
-#endif  // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
+#endif // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
diff --git a/lib/Semantics/rewrite-parse-tree.cpp b/lib/Semantics/rewrite-parse-tree.cpp
index 761621cf58f0..046c61e33b36 100644
--- a/lib/Semantics/rewrite-parse-tree.cpp
+++ b/lib/Semantics/rewrite-parse-tree.cpp
@@ -28,12 +28,12 @@ using namespace parser::literals;
 class RewriteMutator {
 public:
   RewriteMutator(SemanticsContext &context)
-    : errorOnUnresolvedName_{!context.AnyFatalError()},
-      messages_{context.messages()} {}
+      : errorOnUnresolvedName_{!context.AnyFatalError()},
+        messages_{context.messages()} {}
 
   // Default action for a parse tree node is to visit children.
-  template<typename T> bool Pre(T &) { return true; }
-  template<typename T> void Post(T &) {}
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
 
   void Post(parser::Name &);
   void Post(parser::SpecificationPart &);
@@ -94,7 +94,7 @@ void RewriteMutator::Post(parser::SpecificationPart &x) {
 
 // Insert converted assignments at start of ExecutionPart.
 bool RewriteMutator::Pre(parser::ExecutionPart &x) {
-  auto origFirst{x.v.begin()};  // insert each elem before origFirst
+  auto origFirst{x.v.begin()}; // insert each elem before origFirst
   for (stmtFuncType &sf : stmtFuncsToConvert_) {
     auto stmt{sf.statement.value().ConvertToAssignment()};
     stmt.source = sf.source;
@@ -129,7 +129,7 @@ void RewriteMutator::Post(parser::IoUnit &x) {
 // statement in such a way that it can be misparsed as a format expression,
 // rewrite the I/O statement's parse tree node as if the namelist group
 // name had appeared with NML=.
-template<typename READ_OR_WRITE>
+template <typename READ_OR_WRITE>
 void FixMisparsedUntaggedNamelistName(READ_OR_WRITE &x) {
   if (x.iounit && x.format &&
       std::holds_alternative<parser::DefaultCharExpr>(x.format->u)) {
@@ -156,4 +156,4 @@ bool RewriteParseTree(SemanticsContext &context, parser::Program &program) {
   return !context.AnyFatalError();
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/rewrite-parse-tree.h b/lib/Semantics/rewrite-parse-tree.h
index 7978fd60edda..313276db481d 100644
--- a/lib/Semantics/rewrite-parse-tree.h
+++ b/lib/Semantics/rewrite-parse-tree.h
@@ -12,7 +12,7 @@
 namespace Fortran::parser {
 class Messages;
 struct Program;
-}
+} // namespace Fortran::parser
 namespace Fortran::semantics {
 class SemanticsContext;
 }
@@ -21,4 +21,4 @@ namespace Fortran::semantics {
 bool RewriteParseTree(SemanticsContext &, parser::Program &);
 }
 
-#endif  // FORTRAN_SEMANTICS_REWRITE_PARSE_TREE_H_
+#endif // FORTRAN_SEMANTICS_REWRITE_PARSE_TREE_H_
diff --git a/lib/Semantics/scope.cpp b/lib/Semantics/scope.cpp
index c25ce1114ddc..dc934a51190d 100644
--- a/lib/Semantics/scope.cpp
+++ b/lib/Semantics/scope.cpp
@@ -117,7 +117,7 @@ bool Scope::Contains(const Scope &that) const {
 Symbol *Scope::CopySymbol(const Symbol &symbol) {
   auto pair{try_emplace(symbol.name(), symbol.attrs())};
   if (!pair.second) {
-    return nullptr;  // already exists
+    return nullptr; // already exists
   } else {
     Symbol &result{*pair.first->second};
     result.flags() = symbol.flags();
@@ -216,7 +216,7 @@ Scope::ImportKind Scope::GetImportKind() const {
   if (symbol_ && !symbol_->attrs().test(Attr::MODULE)) {
     if (auto *details{symbol_->detailsIf<SubprogramDetails>()}) {
       if (details->isInterface()) {
-        return ImportKind::None;  // default for non-mod-proc interface body
+        return ImportKind::None; // default for non-mod-proc interface body
       }
     }
   }
@@ -254,10 +254,13 @@ bool Scope::CanImport(const SourceName &name) const {
   }
   switch (GetImportKind()) {
     SWITCH_COVERS_ALL_CASES
-  case ImportKind::None: return false;
+  case ImportKind::None:
+    return false;
   case ImportKind::All:
-  case ImportKind::Default: return true;
-  case ImportKind::Only: return importNames_.count(name) > 0;
+  case ImportKind::Default:
+    return true;
+  case ImportKind::Only:
+    return importNames_.count(name) > 0;
   }
 }
 
@@ -367,4 +370,4 @@ void Scope::InstantiateDerivedTypes(SemanticsContext &context) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/symbol.cpp b/lib/Semantics/symbol.cpp
index ecda5d1f6303..e48b7b950a6d 100644
--- a/lib/Semantics/symbol.cpp
+++ b/lib/Semantics/symbol.cpp
@@ -17,13 +17,13 @@
 
 namespace Fortran::semantics {
 
-template<typename T>
+template <typename T>
 static void DumpOptional(llvm::raw_ostream &os, const char *label, const T &x) {
   if (x) {
     os << ' ' << label << ':' << *x;
   }
 }
-template<typename T>
+template <typename T>
 static void DumpExpr(llvm::raw_ostream &os, const char *label,
     const std::optional<evaluate::Expr<T>> &x) {
   if (x) {
@@ -56,7 +56,7 @@ static void DumpType(llvm::raw_ostream &os, const DeclTypeSpec *type) {
   }
 }
 
-template<typename T>
+template <typename T>
 static void DumpList(llvm::raw_ostream &os, const char *label, const T &list) {
   if (!list.empty()) {
     os << ' ' << label << ':';
@@ -155,7 +155,7 @@ UseErrorDetails &UseErrorDetails::add_occurrence(
 }
 
 GenericDetails::GenericDetails(const SymbolVector &specificProcs)
-  : specificProcs_{specificProcs} {}
+    : specificProcs_{specificProcs} {}
 
 void GenericDetails::AddSpecificProc(
     const Symbol &proc, SourceName bindingName) {
@@ -247,7 +247,7 @@ void Symbol::set_details(Details &&details) {
 
 bool Symbol::CanReplaceDetails(const Details &details) const {
   if (has<UnknownDetails>()) {
-    return true;  // can always replace UnknownDetails
+    return true; // can always replace UnknownDetails
   } else {
     return std::visit(
         common::visitors{
@@ -275,15 +275,14 @@ void Symbol::ReplaceName(const SourceName &name) {
 }
 
 void Symbol::SetType(const DeclTypeSpec &type) {
-  std::visit(
-      common::visitors{
-          [&](EntityDetails &x) { x.set_type(type); },
-          [&](ObjectEntityDetails &x) { x.set_type(type); },
-          [&](AssocEntityDetails &x) { x.set_type(type); },
-          [&](ProcEntityDetails &x) { x.interface().set_type(type); },
-          [&](TypeParamDetails &x) { x.set_type(type); },
-          [](auto &) {},
-      },
+  std::visit(common::visitors{
+                 [&](EntityDetails &x) { x.set_type(type); },
+                 [&](ObjectEntityDetails &x) { x.set_type(type); },
+                 [&](AssocEntityDetails &x) { x.set_type(type); },
+                 [&](ProcEntityDetails &x) { x.interface().set_type(type); },
+                 [&](TypeParamDetails &x) { x.set_type(type); },
+                 [](auto &) {},
+             },
       details_);
 }
 
@@ -330,7 +329,7 @@ bool Symbol::IsFromModFile() const {
 }
 
 ObjectEntityDetails::ObjectEntityDetails(EntityDetails &&d)
-  : EntityDetails(d) {}
+    : EntityDetails(d) {}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const EntityDetails &x) {
   DumpBool(os, "dummy", x.isDummy());
@@ -557,7 +556,7 @@ static const DeclTypeSpec &InstantiateIntrinsicType(Scope &scope,
     const DeclTypeSpec &spec, SemanticsContext &semanticsContext) {
   const IntrinsicTypeSpec &intrinsic{DEREF(spec.AsIntrinsic())};
   if (evaluate::ToInt64(intrinsic.kind())) {
-    return spec;  // KIND is already a known constant
+    return spec; // KIND is already a known constant
   }
   // The expression was not originally constant, but now it must be so
   // in the context of a parameterized derived type instantiation.
@@ -580,12 +579,13 @@ static const DeclTypeSpec &InstantiateIntrinsicType(Scope &scope,
   switch (spec.category()) {
   case DeclTypeSpec::Numeric:
     return scope.MakeNumericType(intrinsic.category(), KindExpr{kind});
-  case DeclTypeSpec::Logical:  //
+  case DeclTypeSpec::Logical: //
     return scope.MakeLogicalType(KindExpr{kind});
   case DeclTypeSpec::Character:
     return scope.MakeCharacterType(
         ParamValue{spec.characterTypeSpec().length()}, KindExpr{kind});
-  default: CRASH_NO_CASE;
+  default:
+    CRASH_NO_CASE;
   }
 }
 
@@ -607,7 +607,7 @@ Symbol &Symbol::InstantiateComponent(
     if (DeclTypeSpec * origType{result.GetType()}) {
       if (const DerivedTypeSpec * derived{origType->AsDerived()}) {
         DerivedTypeSpec newSpec{*derived};
-        newSpec.CookParameters(foldingContext);  // enables AddParamValue()
+        newSpec.CookParameters(foldingContext); // enables AddParamValue()
         if (test(Symbol::Flag::ParentComp)) {
           // Forward any explicit type parameter values from the
           // derived type spec under instantiation that define type parameters
@@ -728,4 +728,4 @@ bool GenericKind::Is(GenericKind::OtherKind x) const {
   return y && *y == x;
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/type.cpp b/lib/Semantics/type.cpp
index cba4d3ce9b0c..108d04a1c403 100644
--- a/lib/Semantics/type.cpp
+++ b/lib/Semantics/type.cpp
@@ -17,7 +17,7 @@
 namespace Fortran::semantics {
 
 DerivedTypeSpec::DerivedTypeSpec(SourceName name, const Symbol &typeSymbol)
-  : name_{name}, typeSymbol_{typeSymbol} {
+    : name_{name}, typeSymbol_{typeSymbol} {
   CHECK(typeSymbol.has<DerivedTypeDetails>());
 }
 DerivedTypeSpec::DerivedTypeSpec(const DerivedTypeSpec &that) = default;
@@ -157,7 +157,7 @@ void DerivedTypeSpec::EvaluateParameters(
 void DerivedTypeSpec::AddParamValue(SourceName name, ParamValue &&value) {
   CHECK(cooked_);
   auto pair{parameters_.insert(std::make_pair(name, std::move(value)))};
-  CHECK(pair.second);  // name was not already present
+  CHECK(pair.second); // name was not already present
 }
 
 bool DerivedTypeSpec::MightBeParameterized() const {
@@ -379,13 +379,13 @@ llvm::raw_ostream &operator<<(
 }
 
 ParamValue::ParamValue(MaybeIntExpr &&expr, common::TypeParamAttr attr)
-  : attr_{attr}, expr_{std::move(expr)} {}
+    : attr_{attr}, expr_{std::move(expr)} {}
 ParamValue::ParamValue(SomeIntExpr &&expr, common::TypeParamAttr attr)
-  : attr_{attr}, expr_{std::move(expr)} {}
+    : attr_{attr}, expr_{std::move(expr)} {}
 ParamValue::ParamValue(
     common::ConstantSubscript value, common::TypeParamAttr attr)
-  : ParamValue(
-        SomeIntExpr{evaluate::Expr<evaluate::SubscriptInteger>{value}}, attr) {}
+    : ParamValue(SomeIntExpr{evaluate::Expr<evaluate::SubscriptInteger>{value}},
+          attr) {}
 
 void ParamValue::SetExplicit(SomeIntExpr &&x) {
   category_ = Category::Explicit;
@@ -395,8 +395,10 @@ void ParamValue::SetExplicit(SomeIntExpr &&x) {
 std::string ParamValue::AsFortran() const {
   switch (category_) {
     SWITCH_COVERS_ALL_CASES
-  case Category::Assumed: return "*";
-  case Category::Deferred: return ":";
+  case Category::Assumed:
+    return "*";
+  case Category::Deferred:
+    return ":";
   case Category::Explicit:
     if (expr_) {
       std::string buf;
@@ -414,7 +416,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const ParamValue &x) {
 }
 
 IntrinsicTypeSpec::IntrinsicTypeSpec(TypeCategory category, KindExpr &&kind)
-  : category_{category}, kind_{std::move(kind)} {
+    : category_{category}, kind_{std::move(kind)} {
   CHECK(category != TypeCategory::Derived);
 }
 
@@ -422,7 +424,7 @@ static std::string KindAsFortran(const KindExpr &kind) {
   std::string buf;
   llvm::raw_string_ostream ss{buf};
   if (auto k{evaluate::ToInt64(kind)}) {
-    ss << *k;  // emit unsuffixed kind code
+    ss << *k; // emit unsuffixed kind code
   } else {
     kind.AsFortran(ss);
   }
@@ -449,19 +451,19 @@ llvm::raw_ostream &operator<<(
 }
 
 DeclTypeSpec::DeclTypeSpec(NumericTypeSpec &&typeSpec)
-  : category_{Numeric}, typeSpec_{std::move(typeSpec)} {}
+    : category_{Numeric}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(LogicalTypeSpec &&typeSpec)
-  : category_{Logical}, typeSpec_{std::move(typeSpec)} {}
+    : category_{Logical}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(const CharacterTypeSpec &typeSpec)
-  : category_{Character}, typeSpec_{typeSpec} {}
+    : category_{Character}, typeSpec_{typeSpec} {}
 DeclTypeSpec::DeclTypeSpec(CharacterTypeSpec &&typeSpec)
-  : category_{Character}, typeSpec_{std::move(typeSpec)} {}
+    : category_{Character}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(Category category, const DerivedTypeSpec &typeSpec)
-  : category_{category}, typeSpec_{typeSpec} {
+    : category_{category}, typeSpec_{typeSpec} {
   CHECK(category == TypeDerived || category == ClassDerived);
 }
 DeclTypeSpec::DeclTypeSpec(Category category, DerivedTypeSpec &&typeSpec)
-  : category_{category}, typeSpec_{std::move(typeSpec)} {
+    : category_{category}, typeSpec_{std::move(typeSpec)} {
   CHECK(category == TypeDerived || category == ClassDerived);
 }
 DeclTypeSpec::DeclTypeSpec(Category category) : category_{category} {
@@ -489,13 +491,20 @@ bool DeclTypeSpec::operator==(const DeclTypeSpec &that) const {
 std::string DeclTypeSpec::AsFortran() const {
   switch (category_) {
     SWITCH_COVERS_ALL_CASES
-  case Numeric: return numericTypeSpec().AsFortran();
-  case Logical: return logicalTypeSpec().AsFortran();
-  case Character: return characterTypeSpec().AsFortran();
-  case TypeDerived: return "TYPE(" + derivedTypeSpec().AsFortran() + ')';
-  case ClassDerived: return "CLASS(" + derivedTypeSpec().AsFortran() + ')';
-  case TypeStar: return "TYPE(*)";
-  case ClassStar: return "CLASS(*)";
+  case Numeric:
+    return numericTypeSpec().AsFortran();
+  case Logical:
+    return logicalTypeSpec().AsFortran();
+  case Character:
+    return characterTypeSpec().AsFortran();
+  case TypeDerived:
+    return "TYPE(" + derivedTypeSpec().AsFortran() + ')';
+  case ClassDerived:
+    return "CLASS(" + derivedTypeSpec().AsFortran() + ')';
+  case TypeStar:
+    return "TYPE(*)";
+  case ClassStar:
+    return "CLASS(*)";
   }
 }
 
@@ -511,4 +520,4 @@ void ProcInterface::set_type(const DeclTypeSpec &type) {
   CHECK(!symbol_);
   type_ = &type;
 }
-}
+} // namespace Fortran::semantics
diff --git a/lib/Semantics/unparse-with-symbols.cpp b/lib/Semantics/unparse-with-symbols.cpp
index b8e5e8837b3d..44ceb9fe08bb 100644
--- a/lib/Semantics/unparse-with-symbols.cpp
+++ b/lib/Semantics/unparse-with-symbols.cpp
@@ -26,13 +26,13 @@ class SymbolDumpVisitor {
   // Write out symbols referenced at this statement.
   void PrintSymbols(const parser::CharBlock &, llvm::raw_ostream &, int);
 
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
-  template<typename T> bool Pre(const parser::Statement<T> &stmt) {
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const parser::Statement<T> &stmt) {
     currStmt_ = stmt.source;
     return true;
   }
-  template<typename T> void Post(const parser::Statement<T> &) {
+  template <typename T> void Post(const parser::Statement<T> &) {
     currStmt_ = std::nullopt;
   }
   bool Pre(const parser::OmpClause &clause) {
@@ -48,15 +48,15 @@ class SymbolDumpVisitor {
   void Post(const parser::Name &name);
 
 private:
-  std::optional<SourceName> currStmt_;  // current statement we are processing
-  std::multimap<const char *, const Symbol *> symbols_;  // location to symbol
-  std::set<const Symbol *> symbolsDefined_;  // symbols that have been processed
+  std::optional<SourceName> currStmt_; // current statement we are processing
+  std::multimap<const char *, const Symbol *> symbols_; // location to symbol
+  std::set<const Symbol *> symbolsDefined_; // symbols that have been processed
   void Indent(llvm::raw_ostream &, int) const;
 };
 
 void SymbolDumpVisitor::PrintSymbols(
     const parser::CharBlock &location, llvm::raw_ostream &out, int indent) {
-  std::set<const Symbol *> done;  // prevent duplicates on this line
+  std::set<const Symbol *> done; // prevent duplicates on this line
   auto range{symbols_.equal_range(location.begin())};
   for (auto it{range.first}; it != range.second; ++it) {
     const auto *symbol{it->second};
@@ -93,4 +93,4 @@ void UnparseWithSymbols(llvm::raw_ostream &out, const parser::Program &program,
           int indent) { visitor.PrintSymbols(location, out, indent); }};
   parser::Unparse(out, program, encoding, false, true, &preStatement);
 }
-}
+} // namespace Fortran::semantics
diff --git a/runtime/ISO_Fortran_binding.cpp b/runtime/ISO_Fortran_binding.cpp
index 1ebaa5858349..853d1f7b6f58 100644
--- a/runtime/ISO_Fortran_binding.cpp
+++ b/runtime/ISO_Fortran_binding.cpp
@@ -108,41 +108,99 @@ int CFI_deallocate(CFI_cdesc_t *descriptor) {
 static constexpr std::size_t MinElemLen(CFI_type_t type) {
   std::size_t minElemLen{0};
   switch (type) {
-  case CFI_type_signed_char: minElemLen = sizeof(signed char); break;
-  case CFI_type_short: minElemLen = sizeof(short); break;
-  case CFI_type_int: minElemLen = sizeof(int); break;
-  case CFI_type_long: minElemLen = sizeof(long); break;
-  case CFI_type_long_long: minElemLen = sizeof(long long); break;
-  case CFI_type_size_t: minElemLen = sizeof(std::size_t); break;
-  case CFI_type_int8_t: minElemLen = sizeof(std::int8_t); break;
-  case CFI_type_int16_t: minElemLen = sizeof(std::int16_t); break;
-  case CFI_type_int32_t: minElemLen = sizeof(std::int32_t); break;
-  case CFI_type_int64_t: minElemLen = sizeof(std::int64_t); break;
-  case CFI_type_int128_t: minElemLen = 2 * sizeof(std::int64_t); break;
-  case CFI_type_int_least8_t: minElemLen = sizeof(std::int_least8_t); break;
-  case CFI_type_int_least16_t: minElemLen = sizeof(std::int_least16_t); break;
-  case CFI_type_int_least32_t: minElemLen = sizeof(std::int_least32_t); break;
-  case CFI_type_int_least64_t: minElemLen = sizeof(std::int_least64_t); break;
+  case CFI_type_signed_char:
+    minElemLen = sizeof(signed char);
+    break;
+  case CFI_type_short:
+    minElemLen = sizeof(short);
+    break;
+  case CFI_type_int:
+    minElemLen = sizeof(int);
+    break;
+  case CFI_type_long:
+    minElemLen = sizeof(long);
+    break;
+  case CFI_type_long_long:
+    minElemLen = sizeof(long long);
+    break;
+  case CFI_type_size_t:
+    minElemLen = sizeof(std::size_t);
+    break;
+  case CFI_type_int8_t:
+    minElemLen = sizeof(std::int8_t);
+    break;
+  case CFI_type_int16_t:
+    minElemLen = sizeof(std::int16_t);
+    break;
+  case CFI_type_int32_t:
+    minElemLen = sizeof(std::int32_t);
+    break;
+  case CFI_type_int64_t:
+    minElemLen = sizeof(std::int64_t);
+    break;
+  case CFI_type_int128_t:
+    minElemLen = 2 * sizeof(std::int64_t);
+    break;
+  case CFI_type_int_least8_t:
+    minElemLen = sizeof(std::int_least8_t);
+    break;
+  case CFI_type_int_least16_t:
+    minElemLen = sizeof(std::int_least16_t);
+    break;
+  case CFI_type_int_least32_t:
+    minElemLen = sizeof(std::int_least32_t);
+    break;
+  case CFI_type_int_least64_t:
+    minElemLen = sizeof(std::int_least64_t);
+    break;
   case CFI_type_int_least128_t:
     minElemLen = 2 * sizeof(std::int_least64_t);
     break;
-  case CFI_type_int_fast8_t: minElemLen = sizeof(std::int_fast8_t); break;
-  case CFI_type_int_fast16_t: minElemLen = sizeof(std::int_fast16_t); break;
-  case CFI_type_int_fast32_t: minElemLen = sizeof(std::int_fast32_t); break;
-  case CFI_type_int_fast64_t: minElemLen = sizeof(std::int_fast64_t); break;
-  case CFI_type_intmax_t: minElemLen = sizeof(std::intmax_t); break;
-  case CFI_type_intptr_t: minElemLen = sizeof(std::intptr_t); break;
-  case CFI_type_ptrdiff_t: minElemLen = sizeof(std::ptrdiff_t); break;
-  case CFI_type_float: minElemLen = sizeof(float); break;
-  case CFI_type_double: minElemLen = sizeof(double); break;
-  case CFI_type_long_double: minElemLen = sizeof(long double); break;
-  case CFI_type_float_Complex: minElemLen = 2 * sizeof(float); break;
-  case CFI_type_double_Complex: minElemLen = 2 * sizeof(double); break;
+  case CFI_type_int_fast8_t:
+    minElemLen = sizeof(std::int_fast8_t);
+    break;
+  case CFI_type_int_fast16_t:
+    minElemLen = sizeof(std::int_fast16_t);
+    break;
+  case CFI_type_int_fast32_t:
+    minElemLen = sizeof(std::int_fast32_t);
+    break;
+  case CFI_type_int_fast64_t:
+    minElemLen = sizeof(std::int_fast64_t);
+    break;
+  case CFI_type_intmax_t:
+    minElemLen = sizeof(std::intmax_t);
+    break;
+  case CFI_type_intptr_t:
+    minElemLen = sizeof(std::intptr_t);
+    break;
+  case CFI_type_ptrdiff_t:
+    minElemLen = sizeof(std::ptrdiff_t);
+    break;
+  case CFI_type_float:
+    minElemLen = sizeof(float);
+    break;
+  case CFI_type_double:
+    minElemLen = sizeof(double);
+    break;
+  case CFI_type_long_double:
+    minElemLen = sizeof(long double);
+    break;
+  case CFI_type_float_Complex:
+    minElemLen = 2 * sizeof(float);
+    break;
+  case CFI_type_double_Complex:
+    minElemLen = 2 * sizeof(double);
+    break;
   case CFI_type_long_double_Complex:
     minElemLen = 2 * sizeof(long double);
     break;
-  case CFI_type_Bool: minElemLen = 1; break;
-  case CFI_type_cptr: minElemLen = sizeof(void *); break;
+  case CFI_type_Bool:
+    minElemLen = 1;
+    break;
+  case CFI_type_cptr:
+    minElemLen = sizeof(void *);
+    break;
   }
   return minElemLen;
 }
@@ -353,5 +411,5 @@ int CFI_setpointer(CFI_cdesc_t *result, const CFI_cdesc_t *source,
   }
   return CFI_SUCCESS;
 }
-}  // extern "C"
-}
+} // extern "C"
+} // namespace Fortran::ISO
diff --git a/runtime/allocatable.h b/runtime/allocatable.h
index bcb70356f322..d63bd2c482af 100644
--- a/runtime/allocatable.h
+++ b/runtime/allocatable.h
@@ -111,5 +111,5 @@ int RTNAME(AllocatableDeallocate)(Descriptor &, bool hasStat = false,
     Descriptor *errMsg = nullptr, const char *sourceFile = nullptr,
     int sourceLine = 0);
 }
-}
-#endif  // FORTRAN_RUNTIME_ALLOCATABLE_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_ALLOCATABLE_H_
diff --git a/runtime/buffer.cpp b/runtime/buffer.cpp
index 607bbfcc9ec2..d5081ee7a182 100644
--- a/runtime/buffer.cpp
+++ b/runtime/buffer.cpp
@@ -16,8 +16,8 @@ namespace Fortran::runtime::io {
 void LeftShiftBufferCircularly(
     char *buffer, std::size_t bytes, std::size_t shift) {
   // Assume that we start with "efgabcd" and the left shift is 3.
-  std::reverse(buffer, buffer + shift);  // "gfeabcd"
-  std::reverse(buffer, buffer + bytes);  // "dcbaefg"
-  std::reverse(buffer, buffer + bytes - shift);  // "abcdefg"
-}
+  std::reverse(buffer, buffer + shift); // "gfeabcd"
+  std::reverse(buffer, buffer + bytes); // "dcbaefg"
+  std::reverse(buffer, buffer + bytes - shift); // "abcdefg"
 }
+} // namespace Fortran::runtime::io
diff --git a/runtime/buffer.h b/runtime/buffer.h
index 63bbbdc26c02..27e0ac31579d 100644
--- a/runtime/buffer.h
+++ b/runtime/buffer.h
@@ -27,7 +27,7 @@ void LeftShiftBufferCircularly(char *, std::size_t bytes, std::size_t shift);
 // preserve read data that may be reused by means of Tn/TLn edit descriptors
 // without needing to position the file (which may not always be possible,
 // e.g. a socket) and a general desire to reduce system call counts.
-template<typename STORE> class FileFrame {
+template <typename STORE> class FileFrame {
 public:
   using FileOffset = std::int64_t;
 
@@ -65,10 +65,10 @@ template<typename STORE> class FileFrame {
           std::memmove(buffer_, buffer_ + start_, length_);
         } else {
           // [cde........ab] -> [abcde........]
-          auto n{start_ + length_ - size_};  // 3 for cde
+          auto n{start_ + length_ - size_}; // 3 for cde
           RUNTIME_CHECK(handler, length_ >= n);
-          std::memmove(buffer_ + n, buffer_ + start_, length_ - n);  // cdeab
-          LeftShiftBufferCircularly(buffer_, length_, n);  // abcde
+          std::memmove(buffer_ + n, buffer_ + start_, length_ - n); // cdeab
+          LeftShiftBufferCircularly(buffer_, length_, n); // abcde
         }
         start_ = 0;
       }
@@ -83,7 +83,7 @@ template<typename STORE> class FileFrame {
       length_ += got;
       RUNTIME_CHECK(handler, length_ < size_);
       if (got < minBytes) {
-        break;  // error or EOF & program can handle it
+        break; // error or EOF & program can handle it
       }
     }
     return FrameLength();
@@ -165,12 +165,12 @@ template<typename STORE> class FileFrame {
   static constexpr std::size_t minBuffer{64 << 10};
 
   char *buffer_{nullptr};
-  std::int64_t size_{0};  // current allocated buffer size
-  FileOffset fileOffset_{0};  // file offset corresponding to buffer valid data
-  std::int64_t start_{0};  // buffer_[] offset of valid data
-  std::int64_t length_{0};  // valid data length (can wrap)
-  std::int64_t frame_{0};  // offset of current frame in valid data
+  std::int64_t size_{0}; // current allocated buffer size
+  FileOffset fileOffset_{0}; // file offset corresponding to buffer valid data
+  std::int64_t start_{0}; // buffer_[] offset of valid data
+  std::int64_t length_{0}; // valid data length (can wrap)
+  std::int64_t frame_{0}; // offset of current frame in valid data
   bool dirty_{false};
 };
-}
-#endif  // FORTRAN_RUNTIME_BUFFER_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_BUFFER_H_
diff --git a/runtime/c-or-cpp.h b/runtime/c-or-cpp.h
index d9029261ae4a..016bce07956d 100644
--- a/runtime/c-or-cpp.h
+++ b/runtime/c-or-cpp.h
@@ -26,4 +26,4 @@
 #define NORETURN IF_CPLUSPLUS([[noreturn]])
 #define NO_ARGUMENTS IF_NOT_CPLUSPLUS(void)
 
-#endif  // FORTRAN_RUNTIME_C_OR_CPP_H_
+#endif // FORTRAN_RUNTIME_C_OR_CPP_H_
diff --git a/runtime/connection.cpp b/runtime/connection.cpp
index e4a716560a45..d61f4ce5e08d 100644
--- a/runtime/connection.cpp
+++ b/runtime/connection.cpp
@@ -29,4 +29,4 @@ void ConnectionState::HandleAbsolutePosition(std::int64_t n) {
 void ConnectionState::HandleRelativePosition(std::int64_t n) {
   positionInRecord = std::max(leftTabLimit.value_or(0), positionInRecord + n);
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/connection.h b/runtime/connection.h
index 1c0716145b47..67d4d77fd4fb 100644
--- a/runtime/connection.h
+++ b/runtime/connection.h
@@ -25,33 +25,33 @@ inline bool IsRecordFile(Access a) { return a != Access::Stream; }
 // These characteristics of a connection are immutable after being
 // established in an OPEN statement.
 struct ConnectionAttributes {
-  Access access{Access::Sequential};  // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
-  std::optional<std::int64_t> recordLength;  // RECL= when fixed-length
-  bool isUnformatted{false};  // FORM='UNFORMATTED'
-  bool isUTF8{false};  // ENCODING='UTF-8'
+  Access access{Access::Sequential}; // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
+  std::optional<std::int64_t> recordLength; // RECL= when fixed-length
+  bool isUnformatted{false}; // FORM='UNFORMATTED'
+  bool isUTF8{false}; // ENCODING='UTF-8'
 };
 
 struct ConnectionState : public ConnectionAttributes {
-  bool IsAtEOF() const;  // true when read has hit EOF or endfile record
+  bool IsAtEOF() const; // true when read has hit EOF or endfile record
   std::size_t RemainingSpaceInRecord() const;
   void HandleAbsolutePosition(std::int64_t);
   void HandleRelativePosition(std::int64_t);
 
   // Positions in a record file (sequential or direct, not stream)
-  std::int64_t currentRecordNumber{1};  // 1 is first
-  std::int64_t positionInRecord{0};  // offset in current record
-  std::int64_t furthestPositionInRecord{0};  // max(positionInRecord)
-  bool nonAdvancing{false};  // ADVANCE='NO'
+  std::int64_t currentRecordNumber{1}; // 1 is first
+  std::int64_t positionInRecord{0}; // offset in current record
+  std::int64_t furthestPositionInRecord{0}; // max(positionInRecord)
+  bool nonAdvancing{false}; // ADVANCE='NO'
 
   // Set at end of non-advancing I/O data transfer
-  std::optional<std::int64_t> leftTabLimit;  // offset in current record
+  std::optional<std::int64_t> leftTabLimit; // offset in current record
 
   // currentRecordNumber value captured after ENDFILE/REWIND/BACKSPACE statement
   // or an end-of-file READ condition on a sequential access file
   std::optional<std::int64_t> endfileRecordNumber;
 
   // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
-  MutableModes modes;  // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
+  MutableModes modes; // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
 };
-}
-#endif  // FORTRAN_RUNTIME_IO_CONNECTION_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_CONNECTION_H_
diff --git a/runtime/derived-type.cpp b/runtime/derived-type.cpp
index fb0e5a88277d..e04488b66fab 100644
--- a/runtime/derived-type.cpp
+++ b/runtime/derived-type.cpp
@@ -48,7 +48,7 @@ void DerivedType::Initialize(char *instance) const {
       f(instance);
     }
   }
-#if 0  // TODO
+#if 0 // TODO
   for (std::size_t j{0}; j < components_; ++j) {
     if (const Descriptor * descriptor{component_[j].GetDescriptor(instance)}) {
       // invoke initialization TBP
@@ -74,4 +74,4 @@ void DerivedType::Destroy(char *instance, bool finalize) const {
     }
   }
 }
-}
+} // namespace Fortran::runtime
diff --git a/runtime/derived-type.h b/runtime/derived-type.h
index 1d0e8502745e..1cb5ba96c00e 100644
--- a/runtime/derived-type.h
+++ b/runtime/derived-type.h
@@ -40,9 +40,9 @@ class TypeParameter {
 
 private:
   const char *name_;
-  TypeCode typeCode_;  // INTEGER, but not necessarily default kind
-  int which_{-1};  // index into DescriptorAddendum LEN type parameter values
-  TypeParameterValue value_;  // default in the case of LEN type parameter
+  TypeCode typeCode_; // INTEGER, but not necessarily default kind
+  int which_{-1}; // index into DescriptorAddendum LEN type parameter values
+  TypeParameterValue value_; // default in the case of LEN type parameter
 };
 
 // Components that have any need for a descriptor will either reference
@@ -64,10 +64,10 @@ class Component {
   bool IsPrivate() const { return (flags_ & PRIVATE) != 0; }
   bool IsDescriptor() const { return (flags_ & IS_DESCRIPTOR) != 0; }
 
-  template<typename A> A *Locate(char *dtInstance) const {
+  template <typename A> A *Locate(char *dtInstance) const {
     return reinterpret_cast<A *>(dtInstance + offset_);
   }
-  template<typename A> const A *Locate(const char *dtInstance) const {
+  template <typename A> const A *Locate(const char *dtInstance) const {
     return reinterpret_cast<const A *>(dtInstance + offset_);
   }
 
@@ -95,7 +95,7 @@ class Component {
   std::uint32_t flags_{0};
   TypeCode typeCode_{CFI_type_other};
   const Descriptor *staticDescriptor_{nullptr};
-  std::size_t offset_{0};  // byte offset in derived type instance
+  std::size_t offset_{0}; // byte offset in derived type instance
 };
 
 struct ExecutableCode {
@@ -121,9 +121,9 @@ class DerivedType {
   DerivedType(const char *n, std::size_t kps, std::size_t lps,
       const TypeParameter *tp, std::size_t cs, const Component *ca,
       std::size_t tbps, const TypeBoundProcedure *tbp, std::size_t sz)
-    : name_{n}, kindParameters_{kps}, lenParameters_{lps}, typeParameter_{tp},
-      components_{cs}, component_{ca}, typeBoundProcedures_{tbps},
-      typeBoundProcedure_{tbp}, bytes_{sz} {
+      : name_{n}, kindParameters_{kps}, lenParameters_{lps}, typeParameter_{tp},
+        components_{cs}, component_{ca}, typeBoundProcedures_{tbps},
+        typeBoundProcedure_{tbp}, bytes_{sz} {
     if (IsNontrivialAnalysis()) {
       flags_ |= NONTRIVIAL;
     }
@@ -175,16 +175,16 @@ class DerivedType {
   // LEN type parameters.  Conservative.
   bool IsNontrivialAnalysis() const;
 
-  const char *name_{""};  // NUL-terminated constant text
+  const char *name_{""}; // NUL-terminated constant text
   std::size_t kindParameters_{0};
   std::size_t lenParameters_{0};
-  const TypeParameter *typeParameter_{nullptr};  // array
-  std::size_t components_{0};  // *not* including type parameters
-  const Component *component_{nullptr};  // array
+  const TypeParameter *typeParameter_{nullptr}; // array
+  std::size_t components_{0}; // *not* including type parameters
+  const Component *component_{nullptr}; // array
   std::size_t typeBoundProcedures_{0};
-  const TypeBoundProcedure *typeBoundProcedure_{nullptr};  // array
+  const TypeBoundProcedure *typeBoundProcedure_{nullptr}; // array
   std::uint64_t flags_{0};
   std::size_t bytes_{0};
 };
-}
-#endif  // FORTRAN_RUNTIME_DERIVED_TYPE_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_DERIVED_TYPE_H_
diff --git a/runtime/descriptor.cpp b/runtime/descriptor.cpp
index 00a57cd1e216..9b3555a4723f 100644
--- a/runtime/descriptor.cpp
+++ b/runtime/descriptor.cpp
@@ -200,7 +200,7 @@ bool Descriptor::SubscriptsForZeroBasedElementNumber(SubscriptValue *subscript,
     coefficient *= dim.Extent();
   }
   if (elementNumber >= coefficient) {
-    return false;  // out of range
+    return false; // out of range
   }
   for (int j{raw_.rank - 1}; j >= 0; --j) {
     int k{permutation ? permutation[j] : j};
@@ -249,4 +249,4 @@ void DescriptorAddendum::Dump(FILE *f) const {
   std::fprintf(f, "  flags 0x%jx\n", static_cast<std::intmax_t>(flags_));
   // TODO: LEN parameter values
 }
-}
+} // namespace Fortran::runtime
diff --git a/runtime/descriptor.h b/runtime/descriptor.h
index 8f7a88e10731..d45cbe893951 100644
--- a/runtime/descriptor.h
+++ b/runtime/descriptor.h
@@ -58,14 +58,14 @@ class DescriptorAddendum {
 public:
   enum Flags {
     StaticDescriptor = 0x001,
-    ImplicitAllocatable = 0x002,  // compiler-created allocatable
-    DoNotFinalize = 0x004,  // compiler temporary
-    Target = 0x008,  // TARGET attribute
+    ImplicitAllocatable = 0x002, // compiler-created allocatable
+    DoNotFinalize = 0x004, // compiler temporary
+    Target = 0x008, // TARGET attribute
   };
 
   explicit DescriptorAddendum(
       const DerivedType *dt = nullptr, std::uint64_t flags = 0)
-    : derivedType_{dt}, flags_{flags} {}
+      : derivedType_{dt}, flags_{flags} {}
 
   const DerivedType *derivedType() const { return derivedType_; }
   DescriptorAddendum &set_derivedType(const DerivedType *dt) {
@@ -98,7 +98,7 @@ class DescriptorAddendum {
 private:
   const DerivedType *derivedType_{nullptr};
   std::uint64_t flags_{0};
-  TypeParameterValue len_[1];  // must be the last component
+  TypeParameterValue len_[1]; // must be the last component
   // The LEN type parameter values can also include captured values of
   // specification expressions that were used for bounds and for LEN type
   // parameters of components.  The values have been truncated to the LEN
@@ -190,16 +190,16 @@ class Descriptor {
     return offset;
   }
 
-  template<typename A> A *OffsetElement(std::size_t offset) const {
+  template <typename A> A *OffsetElement(std::size_t offset) const {
     return reinterpret_cast<A *>(
         reinterpret_cast<char *>(raw_.base_addr) + offset);
   }
 
-  template<typename A> A *Element(const SubscriptValue *subscript) const {
+  template <typename A> A *Element(const SubscriptValue *subscript) const {
     return OffsetElement<A>(SubscriptsToByteOffset(subscript));
   }
 
-  template<typename A> A *ZeroBasedIndexedElement(std::size_t n) const {
+  template <typename A> A *ZeroBasedIndexedElement(std::size_t n) const {
     SubscriptValue at[maxRank];
     if (SubscriptsForZeroBasedElementNumber(at, n)) {
       return Element<A>(at);
@@ -257,7 +257,7 @@ class Descriptor {
   std::size_t Elements() const;
 
   int Allocate(const SubscriptValue lb[], const SubscriptValue ub[],
-      std::size_t charLen = 0);  // TODO: SOURCE= and MOLD=
+      std::size_t charLen = 0); // TODO: SOURCE= and MOLD=
   int Deallocate(bool finalize = true);
   void Destroy(char *data, bool finalize = true) const;
 
@@ -293,7 +293,7 @@ static_assert(sizeof(Descriptor) == sizeof(ISO::CFI_cdesc_t));
 //   StaticDescriptor<R,A,LP> statDesc;
 //   Descriptor &descriptor{statDesc.descriptor()};
 //   descriptor.Establish( ... );
-template<int MAX_RANK = maxRank, bool ADDENDUM = false, int MAX_LEN_PARMS = 0>
+template <int MAX_RANK = maxRank, bool ADDENDUM = false, int MAX_LEN_PARMS = 0>
 class alignas(Descriptor) StaticDescriptor {
 public:
   static constexpr int maxRank{MAX_RANK};
@@ -331,5 +331,5 @@ class alignas(Descriptor) StaticDescriptor {
 private:
   char storage_[byteSize];
 };
-}
-#endif  // FORTRAN_RUNTIME_DESCRIPTOR_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_DESCRIPTOR_H_
diff --git a/runtime/edit-input.cpp b/runtime/edit-input.cpp
index dd7a804da2f8..77bf100d2e21 100644
--- a/runtime/edit-input.cpp
+++ b/runtime/edit-input.cpp
@@ -78,10 +78,14 @@ bool EditIntegerInput(
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
   case 'G':
-  case 'I': break;
-  case 'B': return EditBOZInput(io, edit, n, 2, kind << 3);
-  case 'O': return EditBOZInput(io, edit, n, 8, kind << 3);
-  case 'Z': return EditBOZInput(io, edit, n, 16, kind << 3);
+  case 'I':
+    break;
+  case 'B':
+    return EditBOZInput(io, edit, n, 2, kind << 3);
+  case 'O':
+    return EditBOZInput(io, edit, n, 8, kind << 3);
+  case 'Z':
+    return EditBOZInput(io, edit, n, 16, kind << 3);
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with an INTEGER data item",
@@ -96,7 +100,7 @@ bool EditIntegerInput(
     char32_t ch{*next};
     if (ch == ' ') {
       if (edit.modes.editingFlags & blankZero) {
-        ch = '0';  // BZ mode - treat blank as if it were zero
+        ch = '0'; // BZ mode - treat blank as if it were zero
       } else {
         continue;
       }
@@ -130,14 +134,14 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       buffer[got++] = '-';
     }
   }
-  if (!next) {  // empty field means zero
+  if (!next) { // empty field means zero
     if (got < bufferSize) {
       buffer[got++] = '0';
     }
     return got;
   }
   if (got < bufferSize) {
-    buffer[got++] = '.';  // input field is normalized to a fraction
+    buffer[got++] = '.'; // input field is normalized to a fraction
   }
   char32_t decimal = edit.modes.editingFlags & decimalComma ? ',' : '.';
   auto start{got};
@@ -154,7 +158,7 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
         }
       }
     }
-    if (next && *next == '(') {  // NaN(...)
+    if (next && *next == '(') { // NaN(...)
       while (next && *next != ')') {
         next = io.NextInField(remaining);
       }
@@ -165,7 +169,7 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       char32_t ch{*next};
       if (ch == ' ') {
         if (edit.modes.editingFlags & blankZero) {
-          ch = '0';  // BZ mode - treat blank as if it were zero
+          ch = '0'; // BZ mode - treat blank as if it were zero
         } else {
           continue;
         }
@@ -178,13 +182,13 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
         }
       } else if (ch == decimal && !decimalPoint) {
         // the decimal point is *not* copied to the buffer
-        decimalPoint = got - start;  // # of digits before the decimal point
+        decimalPoint = got - start; // # of digits before the decimal point
       } else {
         break;
       }
     }
     if (got == start && got < bufferSize) {
-      buffer[got++] = '0';  // all digits were zeroes
+      buffer[got++] = '0'; // all digits were zeroes
     }
     if (next &&
         (*next == 'e' || *next == 'E' || *next == 'd' || *next == 'D' ||
@@ -192,7 +196,7 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       io.SkipSpaces(remaining);
       next = io.NextInField(remaining);
     }
-    exponent = -edit.modes.scale;  // default exponent is -kP
+    exponent = -edit.modes.scale; // default exponent is -kP
     if (next &&
         (*next == '-' || *next == '+' || (*next >= '0' && *next <= '9'))) {
       bool negExpo{*next == '-'};
@@ -226,13 +230,13 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       next = io.NextInField(remaining);
     }
     if (next) {
-      return 0;  // error: unused nonblank character in fixed-width field
+      return 0; // error: unused nonblank character in fixed-width field
     }
   }
   return got;
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   static constexpr int maxDigits{
       common::MaxDecimalConversionDigits(binaryPrecision)};
@@ -266,14 +270,15 @@ bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   return true;
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool EditRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
   case 'F':
-  case 'E':  // incl. EN, ES, & EX
+  case 'E': // incl. EN, ES, & EX
   case 'D':
-  case 'G': return EditCommonRealInput<binaryPrecision>(io, edit, n);
+  case 'G':
+    return EditCommonRealInput<binaryPrecision>(io, edit, n);
   case 'B':
     return EditBOZInput(
         io, edit, n, 2, common::BitsForBinaryPrecision(binaryPrecision));
@@ -296,7 +301,8 @@ bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
   case 'L':
-  case 'G': break;
+  case 'G':
+    break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used for LOGICAL input",
@@ -309,7 +315,7 @@ bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   }
   io.SkipSpaces(remaining);
   std::optional<char32_t> next{io.NextInField(remaining)};
-  if (next && *next == '.') {  // skip optional period
+  if (next && *next == '.') { // skip optional period
     next = io.NextInField(remaining);
   }
   if (!next) {
@@ -318,15 +324,19 @@ bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   }
   switch (*next) {
   case 'T':
-  case 't': x = true; break;
+  case 't':
+    x = true;
+    break;
   case 'F':
-  case 'f': x = false; break;
+  case 'f':
+    x = false;
+    break;
   default:
     io.GetIoErrorHandler().SignalError(
         "Bad character '%lc' in LOGICAL input field", *next);
     return false;
   }
-  if (remaining) {  // ignore the rest of the field
+  if (remaining) { // ignore the rest of the field
     io.HandleRelativePosition(*remaining);
   }
   return true;
@@ -353,7 +363,7 @@ static bool EditDelimitedCharacterInput(
         *x++ = *ch;
         --length;
       }
-    } else if (!io.AdvanceRecord()) {  // EOF
+    } else if (!io.AdvanceRecord()) { // EOF
       std::fill_n(x, length, ' ');
       return false;
     }
@@ -377,9 +387,11 @@ static bool EditListDirectedDefaultCharacterInput(
     case ',':
     case ';':
     case '/':
-      remaining = 0;  // value separator: stop
+      remaining = 0; // value separator: stop
       break;
-    default: *x++ = *next; --length;
+    default:
+      *x++ = *next;
+      --length;
     }
   }
   std::fill_n(x, length, ' ');
@@ -392,7 +404,8 @@ bool EditDefaultCharacterInput(
   case DataEdit::ListDirected:
     return EditListDirectedDefaultCharacterInput(io, x, length);
   case 'A':
-  case 'G': break;
+  case 'G':
+    break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a CHARACTER data item",
@@ -426,4 +439,4 @@ template bool EditRealInput<24>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<53>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<64>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<113>(IoStatementState &, const DataEdit &, void *);
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/edit-input.h b/runtime/edit-input.h
index b62d81804dd6..c628b9c7e673 100644
--- a/runtime/edit-input.h
+++ b/runtime/edit-input.h
@@ -17,7 +17,7 @@ namespace Fortran::runtime::io {
 
 bool EditIntegerInput(IoStatementState &, const DataEdit &, void *, int kind);
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool EditRealInput(IoStatementState &, const DataEdit &, void *);
 
 bool EditLogicalInput(IoStatementState &, const DataEdit &, bool &);
@@ -36,5 +36,5 @@ extern template bool EditRealInput<64>(
     IoStatementState &, const DataEdit &, void *);
 extern template bool EditRealInput<113>(
     IoStatementState &, const DataEdit &, void *);
-}
-#endif  // FORTRAN_RUNTIME_EDIT_INPUT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_EDIT_INPUT_H_
diff --git a/runtime/edit-output.cpp b/runtime/edit-output.cpp
index 8206b418f3cd..d505e170c437 100644
--- a/runtime/edit-output.cpp
+++ b/runtime/edit-output.cpp
@@ -13,7 +13,7 @@
 
 namespace Fortran::runtime::io {
 
-template<typename INT, typename UINT>
+template <typename INT, typename UINT>
 bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, INT n) {
   char buffer[130], *end = &buffer[sizeof buffer], *p = end;
   bool isNegative{false};
@@ -29,7 +29,7 @@ bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, INT n) {
   case 'G':
   case 'I':
     if (isNegative || (edit.modes.editingFlags & signPlus)) {
-      signChars = 1;  // '-' or '+'
+      signChars = 1; // '-' or '+'
     }
     while (un > 0) {
       auto quotient{common::DivideUnsignedBy<UINT, 10>(un)};
@@ -63,11 +63,11 @@ bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, INT n) {
   int digits = end - p;
   int leadingZeroes{0};
   int editWidth{edit.width.value_or(0)};
-  if (edit.digits && digits <= *edit.digits) {  // Iw.m
+  if (edit.digits && digits <= *edit.digits) { // Iw.m
     if (*edit.digits == 0 && n == 0) {
       // Iw.0 with zero value: output field must be blank.  For I0.0
       // and a zero value, emit one blank character.
-      signChars = 0;  // in case of SP
+      signChars = 0; // in case of SP
       editWidth = std::max(1, editWidth);
     } else {
       leadingZeroes = *edit.digits - digits;
@@ -104,21 +104,21 @@ const char *RealOutputEditingBase::FormatExponent(
     e = quotient;
   }
   if (edit.expoDigits) {
-    if (int ed{*edit.expoDigits}) {  // Ew.dEe with e > 0
+    if (int ed{*edit.expoDigits}) { // Ew.dEe with e > 0
       while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
         *--exponent = '0';
       }
     } else if (exponent == eEnd) {
-      *--exponent = '0';  // Ew.dE0 with zero-valued exponent
+      *--exponent = '0'; // Ew.dE0 with zero-valued exponent
     }
-  } else {  // ensure at least two exponent digits
+  } else { // ensure at least two exponent digits
     while (exponent + 2 > eEnd) {
       *--exponent = '0';
     }
   }
   *--exponent = expo < 0 ? '-' : '+';
   if (edit.expoDigits || exponent + 3 == eEnd) {
-    *--exponent = edit.descriptor == 'D' ? 'D' : 'E';  // not 'G'
+    *--exponent = edit.descriptor == 'D' ? 'D' : 'E'; // not 'G'
   }
   length = eEnd - exponent;
   return exponent;
@@ -157,7 +157,7 @@ bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) {
   }
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
     int significantDigits, const DataEdit &edit, int flags) {
   if (edit.modes.editingFlags & signPlus) {
@@ -166,7 +166,7 @@ decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
   auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_,
       sizeof buffer_, static_cast<enum decimal::DecimalConversionFlags>(flags),
       significantDigits, edit.modes.round, x_)};
-  if (!converted.str) {  // overflow
+  if (!converted.str) { // overflow
     io_.GetIoErrorHandler().Crash(
         "RealOutputEditing::Convert : buffer size %zd was insufficient",
         sizeof buffer_);
@@ -175,24 +175,24 @@ decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
 }
 
 // 13.7.2.3.3 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
-  int editDigits{edit.digits.value_or(0)};  // 'd' field
-  int editWidth{edit.width.value_or(0)};  // 'w' field
+  int editDigits{edit.digits.value_or(0)}; // 'd' field
+  int editWidth{edit.width.value_or(0)}; // 'w' field
   int significantDigits{editDigits};
   int flags{0};
-  if (editWidth == 0) {  // "the processor selects the field width"
-    if (edit.digits.has_value()) {  // E0.d
-      editWidth = editDigits + 6;  // -.666E+ee
-    } else {  // E0
+  if (editWidth == 0) { // "the processor selects the field width"
+    if (edit.digits.has_value()) { // E0.d
+      editWidth = editDigits + 6; // -.666E+ee
+    } else { // E0
       flags |= decimal::Minimize;
       significantDigits =
-          sizeof buffer_ - 5;  // sign, NUL, + 3 extra for EN scaling
+          sizeof buffer_ - 5; // sign, NUL, + 3 extra for EN scaling
     }
   }
   bool isEN{edit.variation == 'N'};
   bool isES{edit.variation == 'S'};
-  int scale{isEN || isES ? 1 : edit.modes.scale};  // 'kP' value
+  int scale{isEN || isES ? 1 : edit.modes.scale}; // 'kP' value
   int zeroesAfterPoint{0};
   if (scale < 0) {
     zeroesAfterPoint = -scale;
@@ -205,7 +205,7 @@ bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(significantDigits, edit, flags)};
-    if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
+    if (converted.length > 0 && !IsDecimalNumber(converted.str)) { // Inf, NaN
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
@@ -257,16 +257,16 @@ bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
 }
 
 // 13.7.2.3.2 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
-  int fracDigits{edit.digits.value_or(0)};  // 'd' field
+  int fracDigits{edit.digits.value_or(0)}; // 'd' field
   int extraDigits{0};
-  int editWidth{edit.width.value_or(0)};  // 'w' field
+  int editWidth{edit.width.value_or(0)}; // 'w' field
   int flags{0};
-  if (editWidth == 0) {  // "the processor selects the field width"
-    if (!edit.digits.has_value()) {  // F0
+  if (editWidth == 0) { // "the processor selects the field width"
+    if (!edit.digits.has_value()) { // F0
       flags |= decimal::Minimize;
-      fracDigits = sizeof buffer_ - 2;  // sign & NUL
+      fracDigits = sizeof buffer_ - 2; // sign & NUL
     }
   }
   // Multiple conversions may be needed to get the right number of
@@ -274,7 +274,7 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(extraDigits + fracDigits, edit, flags)};
-    if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
+    if (converted.length > 0 && !IsDecimalNumber(converted.str)) { // Inf, NaN
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
@@ -283,9 +283,9 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
     if (expo > extraDigits) {
       extraDigits = expo;
       if (flags & decimal::Minimize) {
-        fracDigits = sizeof buffer_ - extraDigits - 2;  // sign & NUL
+        fracDigits = sizeof buffer_ - extraDigits - 2; // sign & NUL
       }
-      continue;  // try again
+      continue; // try again
     }
     int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
     int convertedDigits{static_cast<int>(converted.length) - signLength};
@@ -299,7 +299,7 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
     if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
             digitsAfterPoint + trailingZeroes ==
         0) {
-      ++zeroesBeforePoint;  // "." -> "0."
+      ++zeroesBeforePoint; // "." -> "0."
     }
     int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
         1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes};
@@ -324,30 +324,30 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
 }
 
 // 13.7.5.2.3 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   edit.descriptor = 'E';
   if (!edit.width.has_value() ||
       (*edit.width > 0 && edit.digits.value_or(-1) == 0)) {
-    return edit;  // Gw.0 -> Ew.0 for w > 0
+    return edit; // Gw.0 -> Ew.0 for w > 0
   }
   decimal::ConversionToDecimalResult converted{Convert(1, edit)};
-  if (!IsDecimalNumber(converted.str)) {  // Inf, NaN
+  if (!IsDecimalNumber(converted.str)) { // Inf, NaN
     return edit;
   }
-  int expo{IsZero() ? 1 : converted.decimalExponent};  // 's'
+  int expo{IsZero() ? 1 : converted.decimalExponent}; // 's'
   int significantDigits{
-      edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)};  // 'd'
+      edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)}; // 'd'
   if (expo < 0 || expo > significantDigits) {
-    return edit;  // Ew.d
+    return edit; // Ew.d
   }
   edit.descriptor = 'F';
-  edit.modes.scale = 0;  // kP is ignored for G when no exponent field
+  edit.modes.scale = 0; // kP is ignored for G when no exponent field
   trailingBlanks_ = 0;
   int editWidth{edit.width.value_or(0)};
   if (editWidth > 0) {
     int expoDigits{edit.expoDigits.value_or(0)};
-    trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4;  // 'n'
+    trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4; // 'n'
     *edit.width = std::max(0, editWidth - trailingBlanks_);
   }
   if (edit.digits.has_value()) {
@@ -357,46 +357,49 @@ DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
 }
 
 // 13.10.4 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
     const DataEdit &edit) {
   decimal::ConversionToDecimalResult converted{Convert(1, edit)};
-  if (!IsDecimalNumber(converted.str)) {  // Inf, NaN
+  if (!IsDecimalNumber(converted.str)) { // Inf, NaN
     return EditEorDOutput(edit);
   }
   int expo{converted.decimalExponent};
   if (expo < 0 || expo > BinaryFloatingPoint::decimalPrecision) {
     DataEdit copy{edit};
-    copy.modes.scale = 1;  // 1P
+    copy.modes.scale = 1; // 1P
     return EditEorDOutput(copy);
   }
   return EditFOutput(edit);
 }
 
 // 13.7.5.2.6 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditEXOutput(const DataEdit &) {
   io_.GetIoErrorHandler().Crash(
-      "EX output editing is not yet implemented");  // TODO
+      "EX output editing is not yet implemented"); // TODO
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::Edit(const DataEdit &edit) {
   switch (edit.descriptor) {
-  case 'D': return EditEorDOutput(edit);
+  case 'D':
+    return EditEorDOutput(edit);
   case 'E':
     if (edit.variation == 'X') {
       return EditEXOutput(edit);
     } else {
       return EditEorDOutput(edit);
     }
-  case 'F': return EditFOutput(edit);
+  case 'F':
+    return EditFOutput(edit);
   case 'B':
   case 'O':
   case 'Z':
     return EditIntegerOutput(
         io_, edit, decimal::BinaryFloatingPointNumber<binaryPrecision>{x_}.raw);
-  case 'G': return Edit(EditForGOutput(edit));
+  case 'G':
+    return Edit(EditForGOutput(edit));
   default:
     if (edit.IsListDirected()) {
       return EditListDirectedOutput(edit);
@@ -417,7 +420,8 @@ bool ListDirectedLogicalOutput(IoStatementState &io,
 bool EditLogicalOutput(IoStatementState &io, const DataEdit &edit, bool truth) {
   switch (edit.descriptor) {
   case 'L':
-  case 'G': return io.Emit(truth ? "T" : "F", 1);
+  case 'G':
+    return io.Emit(truth ? "T" : "F", 1);
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a LOGICAL data item",
@@ -469,7 +473,8 @@ bool EditDefaultCharacterOutput(IoStatementState &io, const DataEdit &edit,
     const char *x, std::size_t length) {
   switch (edit.descriptor) {
   case 'A':
-  case 'G': break;
+  case 'G':
+    break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a CHARACTER data item",
@@ -493,4 +498,4 @@ template class RealOutputEditing<24>;
 template class RealOutputEditing<53>;
 template class RealOutputEditing<64>;
 template class RealOutputEditing<113>;
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/edit-output.h b/runtime/edit-output.h
index 559491b584c1..aa324c3ca0d2 100644
--- a/runtime/edit-output.h
+++ b/runtime/edit-output.h
@@ -29,7 +29,7 @@ namespace Fortran::runtime::io {
 // The DataEdit reference is const here (and elsewhere in this header) so that
 // one edit descriptor with a repeat factor may safely serve to edit
 // multiple elements of an array.
-template<typename INT = std::int64_t, typename UINT = std::uint64_t>
+template <typename INT = std::int64_t, typename UINT = std::uint64_t>
 bool EditIntegerOutput(IoStatementState &, const DataEdit &, INT);
 
 // Encapsulates the state of a REAL output conversion.
@@ -52,16 +52,16 @@ class RealOutputEditingBase {
   bool EmitSuffix(const DataEdit &);
 
   IoStatementState &io_;
-  int trailingBlanks_{0};  // created when Gw editing maps to Fw
+  int trailingBlanks_{0}; // created when Gw editing maps to Fw
   char exponent_[16];
 };
 
-template<int binaryPrecision = 53>
+template <int binaryPrecision = 53>
 class RealOutputEditing : public RealOutputEditingBase {
 public:
-  template<typename A>
+  template <typename A>
   RealOutputEditing(IoStatementState &io, A x)
-    : RealOutputEditingBase{io}, x_{x} {}
+      : RealOutputEditingBase{io}, x_{x} {}
   bool Edit(const DataEdit &);
 
 private:
@@ -73,7 +73,7 @@ class RealOutputEditing : public RealOutputEditingBase {
   // it has a repeat count.
   bool EditEorDOutput(const DataEdit &);
   bool EditFOutput(const DataEdit &);
-  DataEdit EditForGOutput(DataEdit);  // returns an E or F edit
+  DataEdit EditForGOutput(DataEdit); // returns an E or F edit
   bool EditEXOutput(const DataEdit &);
   bool EditListDirectedOutput(const DataEdit &);
 
@@ -107,5 +107,5 @@ extern template class RealOutputEditing<53>;
 extern template class RealOutputEditing<64>;
 extern template class RealOutputEditing<113>;
 
-}
-#endif  // FORTRAN_RUNTIME_EDIT_OUTPUT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_EDIT_OUTPUT_H_
diff --git a/runtime/environment.cpp b/runtime/environment.cpp
index 735312b9f57c..e05baa3323cd 100644
--- a/runtime/environment.cpp
+++ b/runtime/environment.cpp
@@ -19,9 +19,9 @@ void ExecutionEnvironment::Configure(
   argc = ac;
   argv = av;
   envp = env;
-  listDirectedOutputLineLengthLimit = 79;  // PGI default
+  listDirectedOutputLineLengthLimit = 79; // PGI default
   defaultOutputRoundingMode =
-      decimal::FortranRounding::RoundNearest;  // RP(==RN)
+      decimal::FortranRounding::RoundNearest; // RP(==RN)
 
   if (auto *x{std::getenv("FORT_FMT_RECL")}) {
     char *end;
@@ -36,4 +36,4 @@ void ExecutionEnvironment::Configure(
 
   // TODO: Set RP/ROUND='PROCESSOR_DEFINED' from environment
 }
-}
+} // namespace Fortran::runtime
diff --git a/runtime/environment.h b/runtime/environment.h
index 93730c180673..0d9d318915cd 100644
--- a/runtime/environment.h
+++ b/runtime/environment.h
@@ -22,6 +22,6 @@ struct ExecutionEnvironment {
   enum decimal::FortranRounding defaultOutputRoundingMode;
 };
 extern ExecutionEnvironment executionEnvironment;
-}
+} // namespace Fortran::runtime
 
-#endif  // FORTRAN_RUNTIME_ENVIRONMENT_H_
+#endif // FORTRAN_RUNTIME_ENVIRONMENT_H_
diff --git a/runtime/file.cpp b/runtime/file.cpp
index 233217c70096..677b9675f47a 100644
--- a/runtime/file.cpp
+++ b/runtime/file.cpp
@@ -65,7 +65,9 @@ void OpenFile::Open(
       return;
     }
     break;
-  case OpenStatus::New: flags |= O_CREAT | O_EXCL; break;
+  case OpenStatus::New:
+    flags |= O_CREAT | O_EXCL;
+    break;
   case OpenStatus::Scratch:
     if (path_.get()) {
       handler.SignalError("FILE= must not appear with STATUS='SCRATCH'");
@@ -73,7 +75,9 @@ void OpenFile::Open(
     }
     fd_ = openfile_mkstemp(handler);
     return;
-  case OpenStatus::Replace: flags |= O_CREAT | O_TRUNC; break;
+  case OpenStatus::Replace:
+    flags |= O_CREAT | O_TRUNC;
+    break;
   case OpenStatus::Unknown:
     if (fd_ >= 0) {
       return;
@@ -122,7 +126,8 @@ void OpenFile::Close(CloseStatus status, IoErrorHandler &handler) {
   pending_.reset();
   knownSize_.reset();
   switch (status) {
-  case CloseStatus::Keep: break;
+  case CloseStatus::Keep:
+    break;
   case CloseStatus::Delete:
     if (path_.get()) {
       ::unlink(path_.get());
@@ -350,4 +355,4 @@ int OpenFile::PendingResult(const Terminator &terminator, int iostat) {
   pending_.reset(&New<Pending>{}(terminator, id, iostat, std::move(pending_)));
   return id;
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/file.h b/runtime/file.h
index c74da330bb7d..741a0bcffa3e 100644
--- a/runtime/file.h
+++ b/runtime/file.h
@@ -94,5 +94,5 @@ class OpenFile {
   int nextId_;
   OwningPtr<Pending> pending_;
 };
-}
-#endif  // FORTRAN_RUNTIME_FILE_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_FILE_H_
diff --git a/runtime/format-implementation.h b/runtime/format-implementation.h
index 86168d0e823d..21cb41c26266 100644
--- a/runtime/format-implementation.h
+++ b/runtime/format-implementation.h
@@ -21,19 +21,19 @@
 
 namespace Fortran::runtime::io {
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 FormatControl<CONTEXT>::FormatControl(const Terminator &terminator,
     const CharType *format, std::size_t formatLength, int maxHeight)
-  : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
-    formatLength_{static_cast<int>(formatLength)} {
+    : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
+      formatLength_{static_cast<int>(formatLength)} {
   RUNTIME_CHECK(terminator, maxHeight == maxHeight_);
   RUNTIME_CHECK(
       terminator, formatLength == static_cast<std::size_t>(formatLength_));
   stack_[0].start = offset_;
-  stack_[0].remaining = Iteration::unlimited;  // 13.4(8)
+  stack_[0].remaining = Iteration::unlimited; // 13.4(8)
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
     IoErrorHandler &handler, const CharType *format, std::size_t formatLength) {
   int maxNesting{0};
@@ -51,9 +51,11 @@ int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
     } else if (*p != ' ') {
       switch (*p) {
       case '\'':
-      case '"': quote = *p; break;
+      case '"':
+        quote = *p;
+        break;
       case 'h':
-      case 'H':  // 9HHOLLERITH
+      case 'H': // 9HHOLLERITH
         p += repeat;
         if (p >= end) {
           handler.SignalError(IostatErrorInFormat,
@@ -61,12 +63,15 @@ int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
           return maxNesting;
         }
         break;
-      case ' ': break;
+      case ' ':
+        break;
       case '(':
         ++nesting;
         maxNesting = std::max(nesting, maxNesting);
         break;
-      case ')': nesting = std::max(nesting - 1, 0); break;
+      case ')':
+        nesting = std::max(nesting - 1, 0);
+        break;
       }
       repeat = 0;
     }
@@ -81,7 +86,7 @@ int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
   return maxNesting;
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 int FormatControl<CONTEXT>::GetIntField(
     IoErrorHandler &handler, CharType firstCh) {
   CharType ch{firstCh ? firstCh : PeekNext()};
@@ -118,7 +123,7 @@ int FormatControl<CONTEXT>::GetIntField(
   return result;
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 static void HandleControl(CONTEXT &context, char ch, char next, int n) {
   MutableModes &modes{context.mutableModes()};
   switch (ch) {
@@ -144,21 +149,32 @@ static void HandleControl(CONTEXT &context, char ch, char next, int n) {
     break;
   case 'P':
     if (!next) {
-      modes.scale = n;  // kP - decimal scaling by 10**k
+      modes.scale = n; // kP - decimal scaling by 10**k
       return;
     }
     break;
   case 'R':
     switch (next) {
-    case 'N': modes.round = decimal::RoundNearest; return;
-    case 'Z': modes.round = decimal::RoundToZero; return;
-    case 'U': modes.round = decimal::RoundUp; return;
-    case 'D': modes.round = decimal::RoundDown; return;
-    case 'C': modes.round = decimal::RoundCompatible; return;
+    case 'N':
+      modes.round = decimal::RoundNearest;
+      return;
+    case 'Z':
+      modes.round = decimal::RoundToZero;
+      return;
+    case 'U':
+      modes.round = decimal::RoundUp;
+      return;
+    case 'D':
+      modes.round = decimal::RoundDown;
+      return;
+    case 'C':
+      modes.round = decimal::RoundCompatible;
+      return;
     case 'P':
       modes.round = executionEnvironment.defaultOutputRoundingMode;
       return;
-    default: break;
+    default:
+      break;
     }
     break;
   case 'X':
@@ -178,16 +194,17 @@ static void HandleControl(CONTEXT &context, char ch, char next, int n) {
     }
     break;
   case 'T': {
-    if (!next) {  // Tn
-      context.HandleAbsolutePosition(n - 1);  // convert 1-based to 0-based
+    if (!next) { // Tn
+      context.HandleAbsolutePosition(n - 1); // convert 1-based to 0-based
       return;
     }
-    if (next == 'L' || next == 'R') {  // TLn & TRn
+    if (next == 'L' || next == 'R') { // TLn & TRn
       context.HandleRelativePosition(next == 'L' ? -n : n);
       return;
     }
   } break;
-  default: break;
+  default:
+    break;
   }
   if (next) {
     context.SignalError(IostatErrorInFormat,
@@ -202,7 +219,7 @@ static void HandleControl(CONTEXT &context, char ch, char next, int n) {
 // Handles all repetition counts and control edit descriptors.
 // Generally assumes that the format string has survived the common
 // format validator gauntlet.
-template<typename CONTEXT>
+template <typename CONTEXT>
 int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
   int unlimitedLoopCheck{-1};
   while (true) {
@@ -235,13 +252,13 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
             "FORMAT stack overflow: too many nested parentheses");
         return 0;
       }
-      stack_[height_].start = offset_ - 1;  // the '('
+      stack_[height_].start = offset_ - 1; // the '('
       if (unlimited || height_ == 0) {
         stack_[height_].remaining = Iteration::unlimited;
         unlimitedLoopCheck = offset_ - 1;
       } else if (repeat) {
         if (*repeat <= 0) {
-          *repeat = 1;  // error recovery
+          *repeat = 1; // error recovery
         }
         stack_[height_].remaining = *repeat - 1;
       } else {
@@ -254,9 +271,9 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
     } else if (ch == ')') {
       if (height_ == 1) {
         if (stop) {
-          return 0;  // end of FORMAT and no data items remain
+          return 0; // end of FORMAT and no data items remain
         }
-        context.AdvanceRecord();  // implied / before rightmost )
+        context.AdvanceRecord(); // implied / before rightmost )
       }
       if (stack_[height_ - 1].remaining == Iteration::unlimited) {
         offset_ = stack_[height_ - 1].start + 1;
@@ -318,7 +335,7 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
         return repeat && *repeat > 0 ? *repeat : 1;
       } else {
         // Control edit descriptor
-        if (ch == 'T') {  // Tn, TLn, TRn
+        if (ch == 'T') { // Tn, TLn, TRn
           repeat = GetIntField(context);
         }
         HandleControl(context, static_cast<char>(ch), static_cast<char>(next),
@@ -334,7 +351,7 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
   }
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
     Context &context, int maxRepeat) {
 
@@ -352,7 +369,7 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
     }
   }
 
-  if (edit.descriptor == 'A') {  // width is optional for A[w]
+  if (edit.descriptor == 'A') { // width is optional for A[w]
     auto ch{PeekNext()};
     if (ch >= '0' && ch <= '9') {
       edit.width = GetIntField(context);
@@ -373,8 +390,8 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
 
   // Handle repeated nonparenthesized edit descriptors
   if (repeat > 1) {
-    stack_[height_].start = start;  // after repeat count
-    stack_[height_].remaining = repeat;  // full count
+    stack_[height_].start = start; // after repeat count
+    stack_[height_].remaining = repeat; // full count
     ++height_;
   }
   edit.repeat = 1;
@@ -384,7 +401,7 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
       if (stack_[height_ - 1].remaining > maxRepeat) {
         edit.repeat = maxRepeat;
         stack_[height_ - 1].remaining -= maxRepeat;
-        offset_ = start;  // repeat same edit descriptor next time
+        offset_ = start; // repeat same edit descriptor next time
       } else {
         edit.repeat = stack_[height_ - 1].remaining;
         --height_;
@@ -394,9 +411,9 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
   return edit;
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 void FormatControl<CONTEXT>::Finish(Context &context) {
   CueUpNextDataEdit(context, true /* stop at colon or end of FORMAT */);
 }
-}
-#endif  // FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
diff --git a/runtime/format.cpp b/runtime/format.cpp
index 6702ab97fe69..2c259b1f7b83 100644
--- a/runtime/format.cpp
+++ b/runtime/format.cpp
@@ -60,4 +60,4 @@ template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Output>>;
 template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Input>>;
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/format.h b/runtime/format.h
index 4875b44f08bb..07eff97a7048 100644
--- a/runtime/format.h
+++ b/runtime/format.h
@@ -21,39 +21,39 @@
 namespace Fortran::runtime::io {
 
 enum EditingFlags {
-  blankZero = 1,  // BLANK=ZERO or BZ edit
-  decimalComma = 2,  // DECIMAL=COMMA or DC edit
-  signPlus = 4,  // SIGN=PLUS or SP edit
+  blankZero = 1, // BLANK=ZERO or BZ edit
+  decimalComma = 2, // DECIMAL=COMMA or DC edit
+  signPlus = 4, // SIGN=PLUS or SP edit
 };
 
 struct MutableModes {
-  std::uint8_t editingFlags{0};  // BN, DP, SS
+  std::uint8_t editingFlags{0}; // BN, DP, SS
   enum decimal::FortranRounding round{
       executionEnvironment
-          .defaultOutputRoundingMode};  // RP/ROUND='PROCESSOR_DEFAULT'
-  bool pad{false};  // PAD= mode on READ
-  char delim{'\0'};  // DELIM=
-  short scale{0};  // kP
+          .defaultOutputRoundingMode}; // RP/ROUND='PROCESSOR_DEFAULT'
+  bool pad{false}; // PAD= mode on READ
+  char delim{'\0'}; // DELIM=
+  short scale{0}; // kP
 };
 
 // A single edit descriptor extracted from a FORMAT
 struct DataEdit {
-  char descriptor;  // capitalized: one of A, I, B, O, Z, F, E(N/S/X), D, G
+  char descriptor; // capitalized: one of A, I, B, O, Z, F, E(N/S/X), D, G
 
   // Special internal data edit descriptors for list-directed I/O
-  static constexpr char ListDirected{'g'};  // non-COMPLEX list-directed
-  static constexpr char ListDirectedRealPart{'r'};  // emit "(r," or "(r;"
-  static constexpr char ListDirectedImaginaryPart{'z'};  // emit "z)"
-  static constexpr char ListDirectedNullValue{'n'};  // see 13.10.3.2
+  static constexpr char ListDirected{'g'}; // non-COMPLEX list-directed
+  static constexpr char ListDirectedRealPart{'r'}; // emit "(r," or "(r;"
+  static constexpr char ListDirectedImaginaryPart{'z'}; // emit "z)"
+  static constexpr char ListDirectedNullValue{'n'}; // see 13.10.3.2
   constexpr bool IsListDirected() const {
     return descriptor == ListDirected || descriptor == ListDirectedRealPart ||
         descriptor == ListDirectedImaginaryPart;
   }
 
-  char variation{'\0'};  // N, S, or X for EN, ES, EX
-  std::optional<int> width;  // the 'w' field; optional for A
-  std::optional<int> digits;  // the 'm' or 'd' field
-  std::optional<int> expoDigits;  // 'Ee' field
+  char variation{'\0'}; // N, S, or X for EN, ES, EX
+  std::optional<int> width; // the 'w' field; optional for A
+  std::optional<int> digits; // the 'm' or 'd' field
+  std::optional<int> expoDigits; // 'Ee' field
   MutableModes modes;
   int repeat{1};
 };
@@ -76,7 +76,7 @@ struct DefaultFormatControlCallbacks : public IoErrorHandler {
 // Generates a sequence of DataEdits from a FORMAT statement or
 // default-CHARACTER string.  Driven by I/O item list processing.
 // Errors are fatal.  See clause 13.4 in Fortran 2018 for background.
-template<typename CONTEXT> class FormatControl {
+template <typename CONTEXT> class FormatControl {
 public:
   using Context = CONTEXT;
   using CharType = typename Context::CharType;
@@ -109,8 +109,8 @@ template<typename CONTEXT> class FormatControl {
 
   struct Iteration {
     static constexpr int unlimited{-1};
-    int start{0};  // offset in format_ of '(' or a repeated edit descriptor
-    int remaining{0};  // while >0, decrement and iterate
+    int start{0}; // offset in format_ of '(' or a repeated edit descriptor
+    int remaining{0}; // while >0, decrement and iterate
   };
 
   void SkipBlanks() {
@@ -151,10 +151,10 @@ template<typename CONTEXT> class FormatControl {
   std::uint8_t height_{0};
   const CharType *format_{nullptr};
   int formatLength_{0};
-  int offset_{0};  // next item is at format_[offset_]
+  int offset_{0}; // next item is at format_[offset_]
 
   // must be last, may be incomplete
   Iteration stack_[maxMaxHeight];
 };
-}
-#endif  // FORTRAN_RUNTIME_FORMAT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_FORMAT_H_
diff --git a/runtime/internal-unit.cpp b/runtime/internal-unit.cpp
index e5a71f735a12..c051100b9a18 100644
--- a/runtime/internal-unit.cpp
+++ b/runtime/internal-unit.cpp
@@ -14,7 +14,7 @@
 
 namespace Fortran::runtime::io {
 
-template<Direction DIR>
+template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     Scalar scalar, std::size_t length) {
   recordLength = length;
@@ -24,7 +24,7 @@ InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
       CFI_attribute_pointer);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     const Descriptor &that, const Terminator &terminator) {
   RUNTIME_CHECK(terminator, that.type().IsCharacter());
@@ -37,8 +37,8 @@ InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
   endfileRecordNumber = d.Elements() + 1;
 }
 
-template<Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
-  if constexpr (DIR == Direction::Output) {  // blank fill
+template <Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
+  if constexpr (DIR == Direction::Output) { // blank fill
     while (char *record{CurrentRecord()}) {
       if (furthestPositionInRecord <
           recordLength.value_or(furthestPositionInRecord)) {
@@ -51,12 +51,12 @@ template<Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
   }
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool InternalDescriptorUnit<DIR>::Emit(
     const char *data, std::size_t bytes, IoErrorHandler &handler) {
   if constexpr (DIR == Direction::Input) {
     handler.Crash("InternalDescriptorUnit<Direction::Input>::Emit() called");
-    return false && data[bytes] != 0;  // bogus compare silences GCC warning
+    return false && data[bytes] != 0; // bogus compare silences GCC warning
   } else {
     if (bytes <= 0) {
       return true;
@@ -85,7 +85,7 @@ bool InternalDescriptorUnit<DIR>::Emit(
   }
 }
 
-template<Direction DIR>
+template <Direction DIR>
 std::optional<char32_t> InternalDescriptorUnit<DIR>::GetCurrentChar(
     IoErrorHandler &handler) {
   if constexpr (DIR == Direction::Output) {
@@ -107,13 +107,13 @@ std::optional<char32_t> InternalDescriptorUnit<DIR>::GetCurrentChar(
   return record[positionInRecord];
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool InternalDescriptorUnit<DIR>::AdvanceRecord(IoErrorHandler &handler) {
   if (currentRecordNumber >= endfileRecordNumber.value_or(0)) {
     handler.SignalEnd();
     return false;
   }
-  if constexpr (DIR == Direction::Output) {  // blank fill
+  if constexpr (DIR == Direction::Output) { // blank fill
     if (furthestPositionInRecord <
         recordLength.value_or(furthestPositionInRecord)) {
       char *record{CurrentRecord()};
@@ -128,7 +128,7 @@ bool InternalDescriptorUnit<DIR>::AdvanceRecord(IoErrorHandler &handler) {
   return true;
 }
 
-template<Direction DIR>
+template <Direction DIR>
 void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
   RUNTIME_CHECK(handler, currentRecordNumber > 1);
   --currentRecordNumber;
@@ -138,4 +138,4 @@ void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
 
 template class InternalDescriptorUnit<Direction::Output>;
 template class InternalDescriptorUnit<Direction::Input>;
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/internal-unit.h b/runtime/internal-unit.h
index 7f4f11e976f6..e5137ebfe1ad 100644
--- a/runtime/internal-unit.h
+++ b/runtime/internal-unit.h
@@ -22,7 +22,7 @@ class IoErrorHandler;
 
 // Points to (but does not own) a CHARACTER scalar or array for internal I/O.
 // Does not buffer.
-template<Direction DIR> class InternalDescriptorUnit : public ConnectionState {
+template <Direction DIR> class InternalDescriptorUnit : public ConnectionState {
 public:
   using Scalar =
       std::conditional_t<DIR == Direction::Input, const char *, char *>;
@@ -49,5 +49,5 @@ template<Direction DIR> class InternalDescriptorUnit : public ConnectionState {
 
 extern template class InternalDescriptorUnit<Direction::Output>;
 extern template class InternalDescriptorUnit<Direction::Input>;
-}
-#endif  // FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
diff --git a/runtime/io-api.cpp b/runtime/io-api.cpp
index cf18b8f0519b..db228e5bbf21 100644
--- a/runtime/io-api.cpp
+++ b/runtime/io-api.cpp
@@ -23,7 +23,7 @@
 
 namespace Fortran::runtime::io {
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginInternalArrayListIO(const Descriptor &descriptor,
     void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
     const char *sourceFile, int sourceLine) {
@@ -47,7 +47,7 @@ Cookie IONAME(BeginInternalArrayListInput)(const Descriptor &descriptor,
       descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginInternalArrayFormattedIO(const Descriptor &descriptor,
     const char *format, std::size_t formatLength, void ** /*scratchArea*/,
     std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
@@ -71,7 +71,7 @@ Cookie IONAME(BeginInternalArrayFormattedInput)(const Descriptor &descriptor,
       formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginInternalFormattedIO(
     std::conditional_t<DIR == Direction::Input, const char, char> *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
@@ -101,7 +101,7 @@ Cookie IONAME(BeginInternalFormattedInput)(const char *internal,
       format, formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginExternalListIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
@@ -138,7 +138,7 @@ Cookie IONAME(BeginExternalListInput)(
       unitNumber, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginExternalFormattedIO(const char *format, std::size_t formatLength,
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
@@ -174,7 +174,7 @@ Cookie IONAME(BeginExternalFormattedInput)(const char *format,
       format, formatLength, unitNumber, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginUnformattedIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
@@ -191,7 +191,7 @@ Cookie BeginUnformattedIO(
     if (file.access == Access::Sequential && !file.recordLength.has_value()) {
       // Create space for (sub)record header to be completed by
       // UnformattedIoStatementState<Direction::Output>::EndIoStatement()
-      io.Emit("\0\0\0\0", 4);  // placeholder for record length header
+      io.Emit("\0\0\0\0", 4); // placeholder for record length header
     }
   }
   return &io;
@@ -209,7 +209,7 @@ Cookie IONAME(BeginUnformattedInput)(
       unitNumber, sourceFile, sourceLine);
 }
 
-Cookie IONAME(BeginOpenUnit)(  // OPEN(without NEWUNIT=)
+Cookie IONAME(BeginOpenUnit)( // OPEN(without NEWUNIT=)
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   bool wasExtant{false};
   Terminator terminator{sourceFile, sourceLine};
@@ -219,7 +219,7 @@ Cookie IONAME(BeginOpenUnit)(  // OPEN(without NEWUNIT=)
       unit, wasExtant, sourceFile, sourceLine);
 }
 
-Cookie IONAME(BeginOpenNewUnit)(  // OPEN(NEWUNIT=j)
+Cookie IONAME(BeginOpenNewUnit)( // OPEN(NEWUNIT=j)
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   return IONAME(BeginOpenUnit)(
@@ -265,8 +265,10 @@ static bool YesOrNo(const char *keyword, std::size_t length, const char *what,
     IoErrorHandler &handler) {
   static const char *keywords[]{"YES", "NO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: return true;
-  case 1: return false;
+  case 0:
+    return true;
+  case 1:
+    return false;
   default:
     handler.SignalError(IostatErrorInKeyword, "Invalid %s='%.*s'", what,
         static_cast<int>(length), keyword);
@@ -292,8 +294,12 @@ bool IONAME(SetBlank)(Cookie cookie, const char *keyword, std::size_t length) {
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"NULL", "ZERO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.editingFlags &= ~blankZero; return true;
-  case 1: connection.modes.editingFlags |= blankZero; return true;
+  case 0:
+    connection.modes.editingFlags &= ~blankZero;
+    return true;
+  case 1:
+    connection.modes.editingFlags |= blankZero;
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid BLANK='%.*s'", static_cast<int>(length), keyword);
@@ -307,8 +313,12 @@ bool IONAME(SetDecimal)(
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"COMMA", "POINT", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.editingFlags |= decimalComma; return true;
-  case 1: connection.modes.editingFlags &= ~decimalComma; return true;
+  case 0:
+    connection.modes.editingFlags |= decimalComma;
+    return true;
+  case 1:
+    connection.modes.editingFlags &= ~decimalComma;
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid DECIMAL='%.*s'", static_cast<int>(length), keyword);
@@ -321,9 +331,15 @@ bool IONAME(SetDelim)(Cookie cookie, const char *keyword, std::size_t length) {
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"APOSTROPHE", "QUOTE", "NONE", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.delim = '\''; return true;
-  case 1: connection.modes.delim = '"'; return true;
-  case 2: connection.modes.delim = '\0'; return true;
+  case 0:
+    connection.modes.delim = '\'';
+    return true;
+  case 1:
+    connection.modes.delim = '"';
+    return true;
+  case 2:
+    connection.modes.delim = '\0';
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid DELIM='%.*s'", static_cast<int>(length), keyword);
@@ -390,11 +406,21 @@ bool IONAME(SetRound)(Cookie cookie, const char *keyword, std::size_t length) {
   static const char *keywords[]{"UP", "DOWN", "ZERO", "NEAREST", "COMPATIBLE",
       "PROCESSOR_DEFINED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.round = decimal::RoundUp; return true;
-  case 1: connection.modes.round = decimal::RoundDown; return true;
-  case 2: connection.modes.round = decimal::RoundToZero; return true;
-  case 3: connection.modes.round = decimal::RoundNearest; return true;
-  case 4: connection.modes.round = decimal::RoundCompatible; return true;
+  case 0:
+    connection.modes.round = decimal::RoundUp;
+    return true;
+  case 1:
+    connection.modes.round = decimal::RoundDown;
+    return true;
+  case 2:
+    connection.modes.round = decimal::RoundToZero;
+    return true;
+  case 3:
+    connection.modes.round = decimal::RoundNearest;
+    return true;
+  case 4:
+    connection.modes.round = decimal::RoundCompatible;
+    return true;
   case 5:
     connection.modes.round = executionEnvironment.defaultOutputRoundingMode;
     return true;
@@ -410,9 +436,11 @@ bool IONAME(SetSign)(Cookie cookie, const char *keyword, std::size_t length) {
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"PLUS", "YES", "PROCESSOR_DEFINED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.editingFlags |= signPlus; return true;
+  case 0:
+    connection.modes.editingFlags |= signPlus;
+    return true;
   case 1:
-  case 2:  // processor default is SS
+  case 2: // processor default is SS
     connection.modes.editingFlags &= ~signPlus;
     return true;
   default:
@@ -433,9 +461,15 @@ bool IONAME(SetAccess)(Cookie cookie, const char *keyword, std::size_t length) {
   Access access{connection.access};
   static const char *keywords[]{"SEQUENTIAL", "DIRECT", "STREAM", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: access = Access::Sequential; break;
-  case 1: access = Access::Direct; break;
-  case 2: access = Access::Stream; break;
+  case 0:
+    access = Access::Sequential;
+    break;
+  case 1:
+    access = Access::Direct;
+    break;
+  case 2:
+    access = Access::Stream;
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ACCESS='%.*s'",
         static_cast<int>(length), keyword);
@@ -460,9 +494,14 @@ bool IONAME(SetAction)(Cookie cookie, const char *keyword, std::size_t length) {
   bool mayWrite{true};
   static const char *keywords[]{"READ", "WRITE", "READWRITE", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: mayWrite = false; break;
-  case 1: mayRead = false; break;
-  case 2: break;
+  case 0:
+    mayWrite = false;
+    break;
+  case 1:
+    mayRead = false;
+    break;
+  case 2:
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ACTION='%.*s'",
         static_cast<int>(length), keyword);
@@ -489,8 +528,12 @@ bool IONAME(SetAsynchronous)(
   }
   static const char *keywords[]{"YES", "NO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: open->unit().set_mayAsynchronous(true); return true;
-  case 1: open->unit().set_mayAsynchronous(false); return true;
+  case 0:
+    open->unit().set_mayAsynchronous(true);
+    return true;
+  case 1:
+    open->unit().set_mayAsynchronous(false);
+    return true;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ASYNCHRONOUS='%.*s'",
         static_cast<int>(length), keyword);
@@ -509,8 +552,12 @@ bool IONAME(SetEncoding)(
   bool isUTF8{false};
   static const char *keywords[]{"UTF-8", "DEFAULT", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: isUTF8 = true; break;
-  case 1: isUTF8 = false; break;
+  case 0:
+    isUTF8 = true;
+    break;
+  case 1:
+    isUTF8 = false;
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ENCODING='%.*s'",
         static_cast<int>(length), keyword);
@@ -534,8 +581,12 @@ bool IONAME(SetForm)(Cookie cookie, const char *keyword, std::size_t length) {
   bool isUnformatted{false};
   static const char *keywords[]{"FORMATTED", "UNFORMATTED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: isUnformatted = false; break;
-  case 1: isUnformatted = true; break;
+  case 0:
+    isUnformatted = false;
+    break;
+  case 1:
+    isUnformatted = true;
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid FORM='%.*s'",
         static_cast<int>(length), keyword);
@@ -559,9 +610,15 @@ bool IONAME(SetPosition)(
   }
   static const char *positions[]{"ASIS", "REWIND", "APPEND", nullptr};
   switch (IdentifyValue(keyword, length, positions)) {
-  case 0: open->set_position(Position::AsIs); return true;
-  case 1: open->set_position(Position::Rewind); return true;
-  case 2: open->set_position(Position::Append); return true;
+  case 0:
+    open->set_position(Position::AsIs);
+    return true;
+  case 1:
+    open->set_position(Position::Rewind);
+    return true;
+  case 2:
+    open->set_position(Position::Append);
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid POSITION='%.*s'", static_cast<int>(length), keyword);
@@ -593,11 +650,21 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
     static const char *statuses[]{
         "OLD", "NEW", "SCRATCH", "REPLACE", "UNKNOWN", nullptr};
     switch (IdentifyValue(keyword, length, statuses)) {
-    case 0: open->set_status(OpenStatus::Old); return true;
-    case 1: open->set_status(OpenStatus::New); return true;
-    case 2: open->set_status(OpenStatus::Scratch); return true;
-    case 3: open->set_status(OpenStatus::Replace); return true;
-    case 4: open->set_status(OpenStatus::Unknown); return true;
+    case 0:
+      open->set_status(OpenStatus::Old);
+      return true;
+    case 1:
+      open->set_status(OpenStatus::New);
+      return true;
+    case 2:
+      open->set_status(OpenStatus::Scratch);
+      return true;
+    case 3:
+      open->set_status(OpenStatus::Replace);
+      return true;
+    case 4:
+      open->set_status(OpenStatus::Unknown);
+      return true;
     default:
       io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
@@ -607,8 +674,12 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
   if (auto *close{io.get_if<CloseStatementState>()}) {
     static const char *statuses[]{"KEEP", "DELETE", nullptr};
     switch (IdentifyValue(keyword, length, statuses)) {
-    case 0: close->set_status(CloseStatus::Keep); return true;
-    case 1: close->set_status(CloseStatus::Delete); return true;
+    case 0:
+      close->set_status(CloseStatus::Keep);
+      return true;
+    case 1:
+      close->set_status(CloseStatus::Delete);
+      return true;
     default:
       io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
@@ -616,7 +687,7 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
     return false;
   }
   if (io.get_if<NoopCloseStatementState>()) {
-    return true;  // don't bother validating STATUS= in a no-op CLOSE
+    return true; // don't bother validating STATUS= in a no-op CLOSE
   }
   io.GetIoErrorHandler().Crash(
       "SetStatus() called when not in an OPEN or CLOSE statement");
@@ -636,11 +707,20 @@ bool IONAME(SetFile)(
 
 static bool SetInteger(int &x, int kind, int value) {
   switch (kind) {
-  case 1: reinterpret_cast<std::int8_t &>(x) = value; return true;
-  case 2: reinterpret_cast<std::int16_t &>(x) = value; return true;
-  case 4: x = value; return true;
-  case 8: reinterpret_cast<std::int64_t &>(x) = value; return true;
-  default: return false;
+  case 1:
+    reinterpret_cast<std::int8_t &>(x) = value;
+    return true;
+  case 2:
+    reinterpret_cast<std::int16_t &>(x) = value;
+    return true;
+  case 4:
+    x = value;
+    return true;
+  case 8:
+    reinterpret_cast<std::int64_t &>(x) = value;
+    return true;
+  default:
+    return false;
   }
 }
 
@@ -661,8 +741,7 @@ bool IONAME(GetNewUnit)(Cookie cookie, int &unit, int kind) {
 
 bool IONAME(OutputDescriptor)(Cookie cookie, const Descriptor &) {
   IoStatementState &io{*cookie};
-  io.GetIoErrorHandler().Crash(
-      "OutputDescriptor: not yet implemented");  // TODO
+  io.GetIoErrorHandler().Crash("OutputDescriptor: not yet implemented"); // TODO
 }
 
 bool IONAME(OutputUnformattedBlock)(
@@ -812,7 +891,7 @@ bool IONAME(InputLogical)(Cookie cookie, bool &truth) {
 
 void IONAME(GetIoMsg)(Cookie cookie, char *msg, std::size_t length) {
   IoErrorHandler &handler{cookie->GetIoErrorHandler()};
-  if (handler.GetIoStat()) {  // leave "msg" alone when no error
+  if (handler.GetIoStat()) { // leave "msg" alone when no error
     handler.GetIoMsg(msg, length);
   }
 }
@@ -821,4 +900,4 @@ enum Iostat IONAME(EndIoStatement)(Cookie cookie) {
   IoStatementState &io{*cookie};
   return static_cast<enum Iostat>(io.EndIoStatement());
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/io-api.h b/runtime/io-api.h
index 0efbf6d1953f..6b394dbdec02 100644
--- a/runtime/io-api.h
+++ b/runtime/io-api.h
@@ -19,7 +19,7 @@
 namespace Fortran::runtime {
 class Descriptor;
 class NamelistGroup;
-}
+} // namespace Fortran::runtime
 
 namespace Fortran::runtime::io {
 
@@ -27,7 +27,7 @@ class IoStatementState;
 using Cookie = IoStatementState *;
 using ExternalUnit = int;
 using AsynchronousId = int;
-static constexpr ExternalUnit DefaultUnit{-1};  // READ(*), WRITE(*), PRINT
+static constexpr ExternalUnit DefaultUnit{-1}; // READ(*), WRITE(*), PRINT
 
 extern "C" {
 
@@ -242,7 +242,7 @@ bool IONAME(SetEncoding)(Cookie, const char *, std::size_t);
 bool IONAME(SetForm)(Cookie, const char *, std::size_t);
 // POSITION=ASIS, REWIND, APPEND
 bool IONAME(SetPosition)(Cookie, const char *, std::size_t);
-bool IONAME(SetRecl)(Cookie, std::size_t);  // RECL=
+bool IONAME(SetRecl)(Cookie, std::size_t); // RECL=
 
 // STATUS can be set during an OPEN or CLOSE statement.
 // For OPEN: STATUS=OLD, NEW, SCRATCH, REPLACE, UNKNOWN
@@ -265,7 +265,7 @@ bool IONAME(GetIoLength)(Cookie, std::int64_t, int kind = 8);
 
 // GetIoMsg() does not modify its argument unless an error or
 // end-of-record/file condition is present.
-void IONAME(GetIoMsg)(Cookie, char *, std::size_t);  // IOMSG=
+void IONAME(GetIoMsg)(Cookie, char *, std::size_t); // IOMSG=
 
 // INQUIRE() specifiers are mostly identified by their NUL-terminated
 // case-insensitive names.
@@ -293,6 +293,6 @@ bool IONAME(InquireInteger64)(
 // rather than by terminating the image.
 enum Iostat IONAME(EndIoStatement)(Cookie);
 
-}  // extern "C"
-}
+} // extern "C"
+} // namespace Fortran::runtime::io
 #endif
diff --git a/runtime/io-error.cpp b/runtime/io-error.cpp
index 721ecf31fecc..58696728c48a 100644
--- a/runtime/io-error.cpp
+++ b/runtime/io-error.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "config.h"
 #include "io-error.h"
+#include "config.h"
 #include "magic-numbers.h"
 #include "tools.h"
 #include <cerrno>
@@ -31,12 +31,12 @@ void IoErrorHandler::SignalError(int iostatOrErrno, const char *msg, ...) {
     }
   } else if (iostatOrErrno == IostatEor && (flags_ & hasEor)) {
     if (!ioStat_ || ioStat_ < IostatEor) {
-      ioStat_ = IostatEor;  // least priority
+      ioStat_ = IostatEor; // least priority
     }
   } else if (iostatOrErrno != IostatOk) {
     if (flags_ & (hasIoStat | hasErr)) {
       if (ioStat_ <= 0) {
-        ioStat_ = iostatOrErrno;  // priority over END=/EOR=
+        ioStat_ = iostatOrErrno; // priority over END=/EOR=
         if (msg && (flags_ & hasIoMsg)) {
           char buffer[256];
           va_list ap;
@@ -102,7 +102,7 @@ bool IoErrorHandler::GetIoMsg(char *buffer, std::size_t bufferLength) {
   return false;
 #endif
   ::strncpy(buffer, newBuf, bufferLength - 1);
-  buffer[bufferLength-1] = '\n';
+  buffer[bufferLength - 1] = '\n';
   return true;
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/io-error.h b/runtime/io-error.h
index 246b12beaf3a..8d43c40ef103 100644
--- a/runtime/io-error.h
+++ b/runtime/io-error.h
@@ -38,29 +38,29 @@ class IoErrorHandler : public Terminator {
 
   void SignalError(int iostatOrErrno, const char *msg, ...);
   void SignalError(int iostatOrErrno);
-  template<typename... X> void SignalError(const char *msg, X &&... xs) {
+  template <typename... X> void SignalError(const char *msg, X &&... xs) {
     SignalError(IostatGenericError, msg, std::forward<X>(xs)...);
   }
 
-  void SignalErrno();  // SignalError(errno)
-  void SignalEnd();  // input only; EOF on internal write is an error
-  void SignalEor();  // non-advancing input only; EOR on write is an error
+  void SignalErrno(); // SignalError(errno)
+  void SignalEnd(); // input only; EOF on internal write is an error
+  void SignalEor(); // non-advancing input only; EOR on write is an error
 
   int GetIoStat() const { return ioStat_; }
   bool GetIoMsg(char *, std::size_t);
 
 private:
   enum Flag : std::uint8_t {
-    hasIoStat = 1,  // IOSTAT=
-    hasErr = 2,  // ERR=
-    hasEnd = 4,  // END=
-    hasEor = 8,  // EOR=
-    hasIoMsg = 16,  // IOMSG=
+    hasIoStat = 1, // IOSTAT=
+    hasErr = 2, // ERR=
+    hasEnd = 4, // END=
+    hasEor = 8, // EOR=
+    hasIoMsg = 16, // IOMSG=
   };
   std::uint8_t flags_{0};
   int ioStat_{0};
   OwningPtr<char> ioMsg_;
 };
 
-}
-#endif  // FORTRAN_RUNTIME_IO_ERROR_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_ERROR_H_
diff --git a/runtime/io-stmt.cpp b/runtime/io-stmt.cpp
index ea76226d7290..1e2e5f5ec5c8 100644
--- a/runtime/io-stmt.cpp
+++ b/runtime/io-stmt.cpp
@@ -25,17 +25,17 @@ std::optional<DataEdit> IoStatementBase::GetNextDataEdit(
   return std::nullopt;
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
     Buffer scalar, std::size_t length, const char *sourceFile, int sourceLine)
-  : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length} {}
+    : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
-  : IoStatementBase{sourceFile, sourceLine}, unit_{d, *this} {}
+    : IoStatementBase{sourceFile, sourceLine}, unit_{d, *this} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 bool InternalIoStatementState<DIR, CHAR>::Emit(
     const CharType *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
@@ -45,7 +45,7 @@ bool InternalIoStatementState<DIR, CHAR>::Emit(
   return unit_.Emit(data, chars, *this);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 std::optional<char32_t> InternalIoStatementState<DIR, CHAR>::GetCurrentChar() {
   if constexpr (DIR == Direction::Output) {
     Crash(
@@ -55,7 +55,7 @@ std::optional<char32_t> InternalIoStatementState<DIR, CHAR>::GetCurrentChar() {
   return unit_.GetCurrentChar(*this);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 bool InternalIoStatementState<DIR, CHAR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit_.AdvanceRecord(*this)) {
@@ -65,15 +65,15 @@ bool InternalIoStatementState<DIR, CHAR>::AdvanceRecord(int n) {
   return true;
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 void InternalIoStatementState<DIR, CHAR>::BackspaceRecord() {
   unit_.BackspaceRecord(*this);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 int InternalIoStatementState<DIR, CHAR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
-    unit_.EndIoStatement();  // fill
+    unit_.EndIoStatement(); // fill
   }
   auto result{IoStatementBase::EndIoStatement()};
   if (free_) {
@@ -82,56 +82,57 @@ int InternalIoStatementState<DIR, CHAR>::EndIoStatement() {
   return result;
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 void InternalIoStatementState<DIR, CHAR>::HandleAbsolutePosition(
     std::int64_t n) {
   return unit_.HandleAbsolutePosition(n);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 void InternalIoStatementState<DIR, CHAR>::HandleRelativePosition(
     std::int64_t n) {
   return unit_.HandleRelativePosition(n);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     Buffer buffer, std::size_t length, const CHAR *format,
     std::size_t formatLength, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CHAR>{buffer, length, sourceFile, sourceLine},
-    ioStatementState_{*this}, format_{*this, format, formatLength} {}
+    : InternalIoStatementState<DIR, CHAR>{buffer, length, sourceFile,
+          sourceLine},
+      ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     const Descriptor &d, const CHAR *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CHAR>{d, sourceFile, sourceLine},
-    ioStatementState_{*this}, format_{*this, format, formatLength} {}
+    : InternalIoStatementState<DIR, CHAR>{d, sourceFile, sourceLine},
+      ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 int InternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
-    format_.Finish(*this);  // ignore any remaining input positioning actions
+    format_.Finish(*this); // ignore any remaining input positioning actions
   }
   return InternalIoStatementState<DIR, CHAR>::EndIoStatement();
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CharType>{buffer, length, sourceFile,
-        sourceLine},
-    ioStatementState_{*this} {}
+    : InternalIoStatementState<DIR, CharType>{buffer, length, sourceFile,
+          sourceLine},
+      ioStatementState_{*this} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CharType>{d, sourceFile, sourceLine},
-    ioStatementState_{*this} {}
+    : InternalIoStatementState<DIR, CharType>{d, sourceFile, sourceLine},
+      ioStatementState_{*this} {}
 
 ExternalIoStatementBase::ExternalIoStatementBase(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
-  : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
+    : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
 
 MutableModes &ExternalIoStatementBase::mutableModes() { return unit_.modes; }
 
@@ -145,16 +146,16 @@ int ExternalIoStatementBase::EndIoStatement() {
     unit_.leftTabLimit.reset();
   }
   auto result{IoStatementBase::EndIoStatement()};
-  unit_.EndIoStatement();  // annihilates *this in unit_.u_
+  unit_.EndIoStatement(); // annihilates *this in unit_.u_
   return result;
 }
 
 void OpenStatementState::set_path(
     const char *path, std::size_t length, int kind) {
-  if (kind != 1) {  // TODO
+  if (kind != 1) { // TODO
     Crash("OPEN: FILE= with unimplemented: CHARACTER(KIND=%d)", kind);
   }
-  std::size_t bytes{length * kind};  // TODO: UTF-8 encoding of Unicode path
+  std::size_t bytes{length * kind}; // TODO: UTF-8 encoding of Unicode path
   path_ = SaveDefaultCharacter(path, bytes, *this);
   pathLength_ = length;
 }
@@ -180,7 +181,7 @@ int NoopCloseStatementState::EndIoStatement() {
   return result;
 }
 
-template<Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
+template <Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
     if (!unit().nonAdvancing) {
       unit().AdvanceRecord(*this);
@@ -190,7 +191,7 @@ template<Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
   return ExternalIoStatementBase::EndIoStatement();
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(const char *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
     Crash("ExternalIoStatementState::Emit(char) called for input statement");
@@ -198,7 +199,7 @@ bool ExternalIoStatementState<DIR>::Emit(const char *data, std::size_t chars) {
   return unit().Emit(data, chars * sizeof(*data), *this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(
     const char16_t *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
@@ -210,7 +211,7 @@ bool ExternalIoStatementState<DIR>::Emit(
       reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(
     const char32_t *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
@@ -222,7 +223,7 @@ bool ExternalIoStatementState<DIR>::Emit(
       reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 std::optional<char32_t> ExternalIoStatementState<DIR>::GetCurrentChar() {
   if constexpr (DIR == Direction::Output) {
     Crash(
@@ -231,7 +232,7 @@ std::optional<char32_t> ExternalIoStatementState<DIR>::GetCurrentChar() {
   return unit().GetCurrentChar(*this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit().AdvanceRecord(*this)) {
@@ -241,28 +242,28 @@ bool ExternalIoStatementState<DIR>::AdvanceRecord(int n) {
   return true;
 }
 
-template<Direction DIR> void ExternalIoStatementState<DIR>::BackspaceRecord() {
+template <Direction DIR> void ExternalIoStatementState<DIR>::BackspaceRecord() {
   unit().BackspaceRecord(*this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 void ExternalIoStatementState<DIR>::HandleAbsolutePosition(std::int64_t n) {
   return unit().HandleAbsolutePosition(n);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 void ExternalIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
   return unit().HandleRelativePosition(n);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 ExternalFormattedIoStatementState<DIR, CHAR>::ExternalFormattedIoStatementState(
     ExternalFileUnit &unit, const CHAR *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
-  : ExternalIoStatementState<DIR>{unit, sourceFile, sourceLine},
-    mutableModes_{unit.modes}, format_{*this, format, formatLength} {}
+    : ExternalIoStatementState<DIR>{unit, sourceFile, sourceLine},
+      mutableModes_{unit.modes}, format_{*this, format, formatLength} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 int ExternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
   format_.Finish(*this);
   return ExternalIoStatementState<DIR>::EndIoStatement();
@@ -359,7 +360,7 @@ void IoStatementState::SkipSpaces(std::optional<int> &remaining) {
 
 std::optional<char32_t> IoStatementState::NextInField(
     std::optional<int> &remaining) {
-  if (!remaining) {  // list-directed or namelist: check for separators
+  if (!remaining) { // list-directed or namelist: check for separators
     if (auto next{GetCurrentChar()}) {
       switch (*next) {
       case ' ':
@@ -370,8 +371,11 @@ std::optional<char32_t> IoStatementState::NextInField(
       case ')':
       case '\'':
       case '"':
-      case '*': break;
-      default: HandleRelativePosition(1); return next;
+      case '*':
+        break;
+      default:
+        HandleRelativePosition(1);
+        return next;
       }
     }
   } else if (*remaining > 0) {
@@ -383,7 +387,7 @@ std::optional<char32_t> IoStatementState::NextInField(
     const ConnectionState &connection{GetConnectionState()};
     if (!connection.IsAtEOF() && connection.recordLength &&
         connection.positionInRecord >= *connection.recordLength) {
-      if (connection.modes.pad) {  // PAD='YES'
+      if (connection.modes.pad) { // PAD='YES'
         --*remaining;
         return std::optional<char32_t>{' '};
       }
@@ -452,13 +456,13 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
   ConnectionState &connection{io.GetConnectionState()};
   DataEdit edit;
   edit.descriptor = DataEdit::ListDirected;
-  edit.repeat = 1;  // may be overridden below
+  edit.repeat = 1; // may be overridden below
   edit.modes = connection.modes;
-  if (hitSlash_) {  // everything after '/' is nullified
+  if (hitSlash_) { // everything after '/' is nullified
     edit.descriptor = DataEdit::ListDirectedNullValue;
     return edit;
   }
-  if (remaining_ > 0 && !realPart_) {  // "r*c" repetition in progress
+  if (remaining_ > 0 && !realPart_) { // "r*c" repetition in progress
     while (connection.currentRecordNumber > initialRecordNumber_) {
       io.BackspaceRecord();
     }
@@ -511,10 +515,10 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
       return edit;
     }
   }
-  if (imaginaryPart_) {  // can't repeat components
+  if (imaginaryPart_) { // can't repeat components
     return edit;
   }
-  if (*ch >= '0' && *ch <= '9') {  // look for "r*" repetition count
+  if (*ch >= '0' && *ch <= '9') { // look for "r*" repetition count
     auto start{connection.positionInRecord};
     int r{0};
     do {
@@ -527,10 +531,10 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
       io.HandleRelativePosition(1);
       ch = io.GetCurrentChar();
     } while (ch && *ch >= '0' && *ch <= '9');
-    if (r > 0 && ch && *ch == '*') {  // subtle: r must be nonzero
+    if (r > 0 && ch && *ch == '*') { // subtle: r must be nonzero
       io.HandleRelativePosition(1);
       ch = io.GetCurrentChar();
-      if (!ch || *ch == ' ' || *ch == comma || *ch == '/') {  // "r*" null
+      if (!ch || *ch == ' ' || *ch == comma || *ch == '/') { // "r*" null
         edit.descriptor = DataEdit::ListDirectedNullValue;
         return edit;
       }
@@ -538,7 +542,7 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
       remaining_ = r - edit.repeat;
       initialRecordNumber_ = connection.currentRecordNumber;
       initialPositionInRecord_ = connection.positionInRecord;
-    } else {  // not a repetition count, just an integer value; rewind
+    } else { // not a repetition count, just an integer value; rewind
       connection.positionInRecord = start;
     }
   }
@@ -549,7 +553,8 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
   return edit;
 }
 
-template<Direction DIR> int UnformattedIoStatementState<DIR>::EndIoStatement() {
+template <Direction DIR>
+int UnformattedIoStatementState<DIR>::EndIoStatement() {
   auto &ext{static_cast<ExternalIoStatementState<DIR> &>(*this)};
   ExternalFileUnit &unit{ext.unit()};
   if (unit.access == Access::Sequential && !unit.recordLength.has_value()) {
@@ -587,4 +592,4 @@ template class ExternalListIoStatementState<Direction::Output>;
 template class ExternalListIoStatementState<Direction::Input>;
 template class UnformattedIoStatementState<Direction::Output>;
 template class UnformattedIoStatementState<Direction::Input>;
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/io-stmt.h b/runtime/io-stmt.h
index 73b93a1f7e4b..b8145d79a96a 100644
--- a/runtime/io-stmt.h
+++ b/runtime/io-stmt.h
@@ -29,18 +29,18 @@ class OpenStatementState;
 class CloseStatementState;
 class NoopCloseStatementState;
 
-template<Direction, typename CHAR = char>
+template <Direction, typename CHAR = char>
 class InternalFormattedIoStatementState;
-template<Direction, typename CHAR = char> class InternalListIoStatementState;
-template<Direction, typename CHAR = char>
+template <Direction, typename CHAR = char> class InternalListIoStatementState;
+template <Direction, typename CHAR = char>
 class ExternalFormattedIoStatementState;
-template<Direction> class ExternalListIoStatementState;
-template<Direction> class UnformattedIoStatementState;
+template <Direction> class ExternalListIoStatementState;
+template <Direction> class UnformattedIoStatementState;
 
 // The Cookie type in the I/O API is a pointer (for C) to this class.
 class IoStatementState {
 public:
-  template<typename A> explicit IoStatementState(A &x) : u_{x} {}
+  template <typename A> explicit IoStatementState(A &x) : u_{x} {}
 
   // These member functions each project themselves into the active alternative.
   // They're used by per-data-item routines in the I/O API (e.g., OutputReal64)
@@ -49,18 +49,18 @@ class IoStatementState {
   // which may not have good support in some runtime environments.
   std::optional<DataEdit> GetNextDataEdit(int = 1);
   bool Emit(const char *, std::size_t);
-  std::optional<char32_t> GetCurrentChar();  // vacant after end of record
+  std::optional<char32_t> GetCurrentChar(); // vacant after end of record
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
   void HandleRelativePosition(std::int64_t);
   int EndIoStatement();
   ConnectionState &GetConnectionState();
   IoErrorHandler &GetIoErrorHandler() const;
-  ExternalFileUnit *GetExternalFileUnit() const;  // null if internal unit
+  ExternalFileUnit *GetExternalFileUnit() const; // null if internal unit
   MutableModes &mutableModes();
 
   // N.B.: this also works with base classes
-  template<typename A> A *get_if() const {
+  template <typename A> A *get_if() const {
     return std::visit(
         [](auto &x) -> A * {
           if constexpr (std::is_convertible_v<decltype(x.get()), A &>) {
@@ -75,7 +75,7 @@ class IoStatementState {
   bool EmitField(const char *, std::size_t length, std::size_t width);
   void SkipSpaces(std::optional<int> &remaining);
   std::optional<char32_t> NextInField(std::optional<int> &remaining);
-  std::optional<char32_t> GetNextNonBlank();  // can advance record
+  std::optional<char32_t> GetNextNonBlank(); // can advance record
 
 private:
   std::variant<std::reference_wrapper<OpenStatementState>,
@@ -109,15 +109,15 @@ struct IoStatementBase : public DefaultFormatControlCallbacks {
 
 struct InputStatementState {};
 struct OutputStatementState {};
-template<Direction D>
+template <Direction D>
 using IoDirectionState = std::conditional_t<D == Direction::Input,
     InputStatementState, OutputStatementState>;
 
 struct FormattedStatementState {};
 
 // Common state for list-directed internal & external I/O
-template<Direction> struct ListDirectedStatementState {};
-template<> struct ListDirectedStatementState<Direction::Output> {
+template <Direction> struct ListDirectedStatementState {};
+template <> struct ListDirectedStatementState<Direction::Output> {
   static std::size_t RemainingSpaceInRecord(const ConnectionState &);
   bool NeedAdvance(const ConnectionState &, std::size_t) const;
   bool EmitLeadingSpaceOrAdvance(
@@ -126,7 +126,7 @@ template<> struct ListDirectedStatementState<Direction::Output> {
       IoStatementState &, int maxRepeat = 1);
   bool lastWasUndelimitedCharacter{false};
 };
-template<> class ListDirectedStatementState<Direction::Input> {
+template <> class ListDirectedStatementState<Direction::Input> {
 public:
   // Skips value separators, handles repetition and null values.
   // Vacant when '/' appears; present with descriptor == ListDirectedNullValue
@@ -135,16 +135,16 @@ template<> class ListDirectedStatementState<Direction::Input> {
       IoStatementState &, int maxRepeat = 1);
 
 private:
-  int remaining_{0};  // for "r*" repetition
+  int remaining_{0}; // for "r*" repetition
   std::int64_t initialRecordNumber_;
   std::int64_t initialPositionInRecord_;
-  bool isFirstItem_{true};  // leading separator implies null first item
-  bool hitSlash_{false};  // once '/' is seen, nullify further items
+  bool isFirstItem_{true}; // leading separator implies null first item
+  bool hitSlash_{false}; // once '/' is seen, nullify further items
   bool realPart_{false};
   bool imaginaryPart_{false};
 };
 
-template<Direction DIR, typename CHAR = char>
+template <Direction DIR, typename CHAR = char>
 class InternalIoStatementState : public IoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
@@ -170,10 +170,10 @@ class InternalIoStatementState : public IoStatementBase,
   InternalDescriptorUnit<DIR> unit_;
 };
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 class InternalFormattedIoStatementState
-  : public InternalIoStatementState<DIR, CHAR>,
-    public FormattedStatementState {
+    : public InternalIoStatementState<DIR, CHAR>,
+      public FormattedStatementState {
 public:
   using CharType = CHAR;
   using typename InternalIoStatementState<DIR, CharType>::Buffer;
@@ -191,13 +191,13 @@ class InternalFormattedIoStatementState
   }
 
 private:
-  IoStatementState ioStatementState_;  // points to *this
+  IoStatementState ioStatementState_; // points to *this
   using InternalIoStatementState<DIR, CharType>::unit_;
   // format_ *must* be last; it may be partial someday
   FormatControl<InternalFormattedIoStatementState> format_;
 };
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 class InternalListIoStatementState : public InternalIoStatementState<DIR, CHAR>,
                                      public ListDirectedStatementState<DIR> {
 public:
@@ -211,7 +211,7 @@ class InternalListIoStatementState : public InternalIoStatementState<DIR, CHAR>,
   using ListDirectedStatementState<DIR>::GetNextDataEdit;
 
 private:
-  IoStatementState ioStatementState_;  // points to *this
+  IoStatementState ioStatementState_; // points to *this
   using InternalIoStatementState<DIR, CharType>::unit_;
 };
 
@@ -229,7 +229,7 @@ class ExternalIoStatementBase : public IoStatementBase {
   ExternalFileUnit &unit_;
 };
 
-template<Direction DIR>
+template <Direction DIR>
 class ExternalIoStatementState : public ExternalIoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
@@ -245,7 +245,7 @@ class ExternalIoStatementState : public ExternalIoStatementBase,
   void HandleAbsolutePosition(std::int64_t);
 };
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 class ExternalFormattedIoStatementState : public ExternalIoStatementState<DIR>,
                                           public FormattedStatementState {
 public:
@@ -268,7 +268,7 @@ class ExternalFormattedIoStatementState : public ExternalIoStatementState<DIR>,
   FormatControl<ExternalFormattedIoStatementState> format_;
 };
 
-template<Direction DIR>
+template <Direction DIR>
 class ExternalListIoStatementState : public ExternalIoStatementState<DIR>,
                                      public ListDirectedStatementState<DIR> {
 public:
@@ -276,7 +276,7 @@ class ExternalListIoStatementState : public ExternalIoStatementState<DIR>,
   using ListDirectedStatementState<DIR>::GetNextDataEdit;
 };
 
-template<Direction DIR>
+template <Direction DIR>
 class UnformattedIoStatementState : public ExternalIoStatementState<DIR> {
 public:
   using ExternalIoStatementState<DIR>::ExternalIoStatementState;
@@ -287,12 +287,12 @@ class OpenStatementState : public ExternalIoStatementBase {
 public:
   OpenStatementState(ExternalFileUnit &unit, bool wasExtant,
       const char *sourceFile = nullptr, int sourceLine = 0)
-    : ExternalIoStatementBase{unit, sourceFile, sourceLine}, wasExtant_{
-                                                                 wasExtant} {}
+      : ExternalIoStatementBase{unit, sourceFile, sourceLine}, wasExtant_{
+                                                                   wasExtant} {}
   bool wasExtant() const { return wasExtant_; }
   void set_status(OpenStatus status) { status_ = status; }
-  void set_path(const char *, std::size_t, int kind);  // FILE=
-  void set_position(Position position) { position_ = position; }  // POSITION=
+  void set_path(const char *, std::size_t, int kind); // FILE=
+  void set_position(Position position) { position_ = position; } // POSITION=
   int EndIoStatement();
 
 private:
@@ -307,7 +307,7 @@ class CloseStatementState : public ExternalIoStatementBase {
 public:
   CloseStatementState(ExternalFileUnit &unit, const char *sourceFile = nullptr,
       int sourceLine = 0)
-    : ExternalIoStatementBase{unit, sourceFile, sourceLine} {}
+      : ExternalIoStatementBase{unit, sourceFile, sourceLine} {}
   void set_status(CloseStatus status) { status_ = status; }
   int EndIoStatement();
 
@@ -318,15 +318,15 @@ class CloseStatementState : public ExternalIoStatementBase {
 class NoopCloseStatementState : public IoStatementBase {
 public:
   NoopCloseStatementState(const char *sourceFile, int sourceLine)
-    : IoStatementBase{sourceFile, sourceLine}, ioStatementState_{*this} {}
+      : IoStatementBase{sourceFile, sourceLine}, ioStatementState_{*this} {}
   IoStatementState &ioStatementState() { return ioStatementState_; }
-  void set_status(CloseStatus) {}  // discards
+  void set_status(CloseStatus) {} // discards
   MutableModes &mutableModes() { return connection_.modes; }
   ConnectionState &GetConnectionState() { return connection_; }
   int EndIoStatement();
 
 private:
-  IoStatementState ioStatementState_;  // points to *this
+  IoStatementState ioStatementState_; // points to *this
   ConnectionState connection_;
 };
 
@@ -353,5 +353,5 @@ extern template class FormatControl<
 extern template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Input>>;
 
-}
-#endif  // FORTRAN_RUNTIME_IO_STMT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_STMT_H_
diff --git a/runtime/iostat.cpp b/runtime/iostat.cpp
index 6e146faecdae..c86619d384f9 100644
--- a/runtime/iostat.cpp
+++ b/runtime/iostat.cpp
@@ -11,21 +11,31 @@
 namespace Fortran::runtime::io {
 const char *IostatErrorString(int iostat) {
   switch (iostat) {
-  case IostatOk: return "No error";
-  case IostatEnd: return "End of file during input";
-  case IostatEor: return "End of record during non-advancing input";
-  case IostatUnflushable: return "FLUSH not possible";
-  case IostatInquireInternalUnit: return "INQUIRE on internal unit";
+  case IostatOk:
+    return "No error";
+  case IostatEnd:
+    return "End of file during input";
+  case IostatEor:
+    return "End of record during non-advancing input";
+  case IostatUnflushable:
+    return "FLUSH not possible";
+  case IostatInquireInternalUnit:
+    return "INQUIRE on internal unit";
   case IostatGenericError:
-    return "I/O error";  // dummy value, there's always a message
-  case IostatRecordWriteOverrun: return "Excessive output to fixed-size record";
-  case IostatRecordReadOverrun: return "Excessive input from fixed-size record";
+    return "I/O error"; // dummy value, there's always a message
+  case IostatRecordWriteOverrun:
+    return "Excessive output to fixed-size record";
+  case IostatRecordReadOverrun:
+    return "Excessive input from fixed-size record";
   case IostatInternalWriteOverrun:
     return "Internal write overran available records";
-  case IostatErrorInFormat: return "Invalid FORMAT";
-  case IostatErrorInKeyword: return "Bad keyword argument value";
-  default: return nullptr;
+  case IostatErrorInFormat:
+    return "Invalid FORMAT";
+  case IostatErrorInKeyword:
+    return "Bad keyword argument value";
+  default:
+    return nullptr;
   }
 }
 
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/iostat.h b/runtime/iostat.h
index b5b78360feb2..2ab5ac8232d2 100644
--- a/runtime/iostat.h
+++ b/runtime/iostat.h
@@ -22,11 +22,11 @@ namespace Fortran::runtime::io {
 // they're actually defined in another magic-numbers.h header file
 // so that they can be included both here and there.)
 enum Iostat {
-  IostatOk = 0,  // no error, EOF, or EOR condition
+  IostatOk = 0, // no error, EOF, or EOR condition
 
   // These error codes are required by Fortran (see 12.10.2.16-17) to be
   // negative integer values
-  IostatEnd = FORTRAN_RUNTIME_IOSTAT_END,  // end-of-file on input & no error
+  IostatEnd = FORTRAN_RUNTIME_IOSTAT_END, // end-of-file on input & no error
   // End-of-record on non-advancing input, no EOF or error
   IostatEor = FORTRAN_RUNTIME_IOSTAT_EOR,
 
@@ -39,7 +39,7 @@ enum Iostat {
   IostatInquireInternalUnit = FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT,
 
   // The remaining error codes are not exported.
-  IostatGenericError = 1001,  // see IOMSG= for details
+  IostatGenericError = 1001, // see IOMSG= for details
   IostatRecordWriteOverrun,
   IostatRecordReadOverrun,
   IostatInternalWriteOverrun,
@@ -49,5 +49,5 @@ enum Iostat {
 
 const char *IostatErrorString(int);
 
-}
-#endif  // FORTRAN_RUNTIME_IOSTAT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IOSTAT_H_
diff --git a/runtime/lock.h b/runtime/lock.h
index 5c614801f2ae..714b1d595b18 100644
--- a/runtime/lock.h
+++ b/runtime/lock.h
@@ -27,6 +27,7 @@ class Lock {
       terminator.Crash("Lock::CheckLocked() failed");
     }
   }
+
 private:
   std::mutex mutex_;
 };
@@ -39,6 +40,6 @@ class CriticalSection {
 private:
   Lock &lock_;
 };
-}
+} // namespace Fortran::runtime
 
-#endif  // FORTRAN_RUNTIME_LOCK_H_
+#endif // FORTRAN_RUNTIME_LOCK_H_
diff --git a/runtime/main.cpp b/runtime/main.cpp
index 707e35cc99a0..5de2e6434abb 100644
--- a/runtime/main.cpp
+++ b/runtime/main.cpp
@@ -14,7 +14,7 @@
 #include <cstdlib>
 
 static void ConfigureFloatingPoint() {
-#ifdef feclearexcept  // a macro in some environments; omit std::
+#ifdef feclearexcept // a macro in some environments; omit std::
   feclearexcept(FE_ALL_EXCEPT);
 #else
   std::feclearexcept(FE_ALL_EXCEPT);
diff --git a/runtime/main.h b/runtime/main.h
index 94ce3a93b70b..31ef8f8f4446 100644
--- a/runtime/main.h
+++ b/runtime/main.h
@@ -16,4 +16,4 @@ FORTRAN_EXTERN_C_BEGIN
 void RTNAME(ProgramStart)(int, const char *[], const char *[]);
 FORTRAN_EXTERN_C_END
 
-#endif  // FORTRAN_RUNTIME_MAIN_H_
+#endif // FORTRAN_RUNTIME_MAIN_H_
diff --git a/runtime/memory.cpp b/runtime/memory.cpp
index 84fd35da48ef..21cd210308a2 100644
--- a/runtime/memory.cpp
+++ b/runtime/memory.cpp
@@ -25,4 +25,4 @@ void *AllocateMemoryOrCrash(const Terminator &terminator, std::size_t bytes) {
 }
 
 void FreeMemory(void *p) { std::free(p); }
-}
+} // namespace Fortran::runtime
diff --git a/runtime/memory.h b/runtime/memory.h
index 1bd5bca1b78a..f26213f954a4 100644
--- a/runtime/memory.h
+++ b/runtime/memory.h
@@ -20,38 +20,38 @@ class Terminator;
 
 [[nodiscard]] void *AllocateMemoryOrCrash(
     const Terminator &, std::size_t bytes);
-template<typename A>[[nodiscard]] A &AllocateOrCrash(const Terminator &t) {
+template <typename A>[[nodiscard]] A &AllocateOrCrash(const Terminator &t) {
   return *reinterpret_cast<A *>(AllocateMemoryOrCrash(t, sizeof(A)));
 }
 void FreeMemory(void *);
-template<typename A> void FreeMemory(A *p) {
+template <typename A> void FreeMemory(A *p) {
   FreeMemory(reinterpret_cast<void *>(p));
 }
-template<typename A> void FreeMemoryAndNullify(A *&p) {
+template <typename A> void FreeMemoryAndNullify(A *&p) {
   FreeMemory(p);
   p = nullptr;
 }
 
-template<typename A> struct New {
-  template<typename... X>
+template <typename A> struct New {
+  template <typename... X>
   [[nodiscard]] A &operator()(const Terminator &terminator, X &&... x) {
     return *new (AllocateMemoryOrCrash(terminator, sizeof(A)))
         A{std::forward<X>(x)...};
   }
 };
 
-template<typename A> struct OwningPtrDeleter {
+template <typename A> struct OwningPtrDeleter {
   void operator()(A *p) { FreeMemory(p); }
 };
 
-template<typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
+template <typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
 
-template<typename A> struct Allocator {
+template <typename A> struct Allocator {
   using value_type = A;
   explicit Allocator(const Terminator &t) : terminator{t} {}
-  template<typename B>
+  template <typename B>
   explicit constexpr Allocator(const Allocator<B> &that) noexcept
-    : terminator{that.terminator} {}
+      : terminator{that.terminator} {}
   Allocator(const Allocator &) = default;
   Allocator(Allocator &&) = default;
   [[nodiscard]] constexpr A *allocate(std::size_t n) {
@@ -61,6 +61,6 @@ template<typename A> struct Allocator {
   constexpr void deallocate(A *p, std::size_t) { FreeMemory(p); }
   const Terminator &terminator;
 };
-}
+} // namespace Fortran::runtime
 
-#endif  // FORTRAN_RUNTIME_MEMORY_H_
+#endif // FORTRAN_RUNTIME_MEMORY_H_
diff --git a/runtime/stop.cpp b/runtime/stop.cpp
index 46ad558dfe4c..321b060d8b91 100644
--- a/runtime/stop.cpp
+++ b/runtime/stop.cpp
@@ -17,7 +17,7 @@
 extern "C" {
 
 static void DescribeIEEESignaledExceptions() {
-#ifdef fetestexcept  // a macro in some environments; omit std::
+#ifdef fetestexcept // a macro in some environments; omit std::
   auto excepts{fetestexcept(FE_ALL_EXCEPT)};
 #else
   auto excepts{std::fetestexcept(FE_ALL_EXCEPT)};
diff --git a/runtime/stop.h b/runtime/stop.h
index 24fea0b4f7db..249e71e0b1f0 100644
--- a/runtime/stop.h
+++ b/runtime/stop.h
@@ -25,4 +25,4 @@ NORETURN void RTNAME(ProgramEndStatement)(NO_ARGUMENTS);
 
 FORTRAN_EXTERN_C_END
 
-#endif  // FORTRAN_RUNTIME_STOP_H_
+#endif // FORTRAN_RUNTIME_STOP_H_
diff --git a/runtime/terminator.cpp b/runtime/terminator.cpp
index cc0f4d23a439..cea1a8673eeb 100644
--- a/runtime/terminator.cpp
+++ b/runtime/terminator.cpp
@@ -57,4 +57,4 @@ void Terminator::RegisterCrashHandler(
 void NotifyOtherImagesOfNormalEnd() {}
 void NotifyOtherImagesOfFailImageStatement() {}
 void NotifyOtherImagesOfErrorTermination() {}
-}
+} // namespace Fortran::runtime
diff --git a/runtime/terminator.h b/runtime/terminator.h
index 20f5abd435c0..66bc92ae4e25 100644
--- a/runtime/terminator.h
+++ b/runtime/terminator.h
@@ -23,7 +23,7 @@ class Terminator {
   Terminator() {}
   Terminator(const Terminator &) = default;
   explicit Terminator(const char *sourceFileName, int sourceLine = 0)
-    : sourceFileName_{sourceFileName}, sourceLine_{sourceLine} {}
+      : sourceFileName_{sourceFileName}, sourceLine_{sourceLine} {}
   void SetLocation(const char *sourceFileName = nullptr, int sourceLine = 0) {
     sourceFileName_ = sourceFileName;
     sourceLine_ = sourceLine;
@@ -51,10 +51,10 @@ class Terminator {
 void NotifyOtherImagesOfNormalEnd();
 void NotifyOtherImagesOfFailImageStatement();
 void NotifyOtherImagesOfErrorTermination();
-}
+} // namespace Fortran::runtime
 
 namespace Fortran::runtime::io {
 void FlushOutputOnCrash(const Terminator &);
 }
 
-#endif  // FORTRAN_RUNTIME_TERMINATOR_H_
+#endif // FORTRAN_RUNTIME_TERMINATOR_H_
diff --git a/runtime/tools.cpp b/runtime/tools.cpp
index 12c792ca29cc..ea9ad9063344 100644
--- a/runtime/tools.cpp
+++ b/runtime/tools.cpp
@@ -68,4 +68,4 @@ void ToFortranDefaultCharacter(
   }
 }
 
-}
+} // namespace Fortran::runtime
diff --git a/runtime/tools.h b/runtime/tools.h
index ec7982c2082f..fad19f607c68 100644
--- a/runtime/tools.h
+++ b/runtime/tools.h
@@ -31,5 +31,5 @@ int IdentifyValue(
 // Truncates or pads as necessary
 void ToFortranDefaultCharacter(
     char *to, std::size_t toLength, const char *from);
-}
-#endif  // FORTRAN_RUNTIME_TOOLS_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_TOOLS_H_
diff --git a/runtime/transformational.cpp b/runtime/transformational.cpp
index f0577c6e7dd3..1964a536f7df 100644
--- a/runtime/transformational.cpp
+++ b/runtime/transformational.cpp
@@ -17,10 +17,14 @@ namespace Fortran::runtime {
 
 static inline std::int64_t GetInt64(const char *p, std::size_t bytes) {
   switch (bytes) {
-  case 1: return *reinterpret_cast<const std::int8_t *>(p);
-  case 2: return *reinterpret_cast<const std::int16_t *>(p);
-  case 4: return *reinterpret_cast<const std::int32_t *>(p);
-  case 8: return *reinterpret_cast<const std::int64_t *>(p);
+  case 1:
+    return *reinterpret_cast<const std::int8_t *>(p);
+  case 2:
+    return *reinterpret_cast<const std::int16_t *>(p);
+  case 4:
+    return *reinterpret_cast<const std::int32_t *>(p);
+  case 8:
+    return *reinterpret_cast<const std::int64_t *>(p);
   default:
     Terminator terminator{__FILE__, __LINE__};
     terminator.Crash("no case for %dz bytes", bytes);
@@ -39,7 +43,7 @@ OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
       resultRank >= 0 && resultRank <= static_cast<SubscriptValue>(maxRank));
 
   // Extract and check the shape of the result; compute its element count.
-  SubscriptValue lowerBound[maxRank];  // all 1's
+  SubscriptValue lowerBound[maxRank]; // all 1's
   SubscriptValue resultExtent[maxRank];
   std::size_t shapeElementBytes{shape.ElementBytes()};
   std::size_t resultElements{1};
@@ -96,7 +100,7 @@ OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
   } else {
     result = Descriptor::Create(source.type(), elementBytes, nullptr,
         resultRank, resultExtent,
-        CFI_attribute_allocatable);  // TODO rearrange these arguments
+        CFI_attribute_allocatable); // TODO rearrange these arguments
   }
   DescriptorAddendum *resultAddendum{result->Addendum()};
   RUNTIME_CHECK(terminator, resultAddendum);
@@ -141,4 +145,4 @@ OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
 
   return result;
 }
-}
+} // namespace Fortran::runtime
diff --git a/runtime/transformational.h b/runtime/transformational.h
index 2785614b6937..bf271fa23291 100644
--- a/runtime/transformational.h
+++ b/runtime/transformational.h
@@ -17,4 +17,4 @@ namespace Fortran::runtime {
 OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
     const Descriptor *pad = nullptr, const Descriptor *order = nullptr);
 }
-#endif  // FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
+#endif // FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
diff --git a/runtime/type-code.cpp b/runtime/type-code.cpp
index 8b57cdb4e5a7..54b2b23089f7 100644
--- a/runtime/type-code.cpp
+++ b/runtime/type-code.cpp
@@ -14,27 +14,49 @@ TypeCode::TypeCode(TypeCategory f, int kind) {
   switch (f) {
   case TypeCategory::Integer:
     switch (kind) {
-    case 1: raw_ = CFI_type_int8_t; break;
-    case 2: raw_ = CFI_type_int16_t; break;
-    case 4: raw_ = CFI_type_int32_t; break;
-    case 8: raw_ = CFI_type_int64_t; break;
-    case 16: raw_ = CFI_type_int128_t; break;
+    case 1:
+      raw_ = CFI_type_int8_t;
+      break;
+    case 2:
+      raw_ = CFI_type_int16_t;
+      break;
+    case 4:
+      raw_ = CFI_type_int32_t;
+      break;
+    case 8:
+      raw_ = CFI_type_int64_t;
+      break;
+    case 16:
+      raw_ = CFI_type_int128_t;
+      break;
     }
     break;
   case TypeCategory::Real:
     switch (kind) {
-    case 4: raw_ = CFI_type_float; break;
-    case 8: raw_ = CFI_type_double; break;
+    case 4:
+      raw_ = CFI_type_float;
+      break;
+    case 8:
+      raw_ = CFI_type_double;
+      break;
     case 10:
-    case 16: raw_ = CFI_type_long_double; break;
+    case 16:
+      raw_ = CFI_type_long_double;
+      break;
     }
     break;
   case TypeCategory::Complex:
     switch (kind) {
-    case 4: raw_ = CFI_type_float_Complex; break;
-    case 8: raw_ = CFI_type_double_Complex; break;
+    case 4:
+      raw_ = CFI_type_float_Complex;
+      break;
+    case 8:
+      raw_ = CFI_type_double_Complex;
+      break;
     case 10:
-    case 16: raw_ = CFI_type_long_double_Complex; break;
+    case 16:
+      raw_ = CFI_type_long_double_Complex;
+      break;
     }
     break;
   case TypeCategory::Character:
@@ -44,13 +66,23 @@ TypeCode::TypeCode(TypeCategory f, int kind) {
     break;
   case TypeCategory::Logical:
     switch (kind) {
-    case 1: raw_ = CFI_type_Bool; break;
-    case 2: raw_ = CFI_type_int16_t; break;
-    case 4: raw_ = CFI_type_int32_t; break;
-    case 8: raw_ = CFI_type_int64_t; break;
+    case 1:
+      raw_ = CFI_type_Bool;
+      break;
+    case 2:
+      raw_ = CFI_type_int16_t;
+      break;
+    case 4:
+      raw_ = CFI_type_int32_t;
+      break;
+    case 8:
+      raw_ = CFI_type_int64_t;
+      break;
     }
     break;
-  case TypeCategory::Derived: raw_ = CFI_type_struct; break;
+  case TypeCategory::Derived:
+    raw_ = CFI_type_struct;
+    break;
   }
 }
-}
+} // namespace Fortran::runtime
diff --git a/runtime/type-code.h b/runtime/type-code.h
index af09be560651..104944b1a7ed 100644
--- a/runtime/type-code.h
+++ b/runtime/type-code.h
@@ -65,5 +65,5 @@ class TypeCode {
 private:
   ISO::CFI_type_t raw_{CFI_type_other};
 };
-}
-#endif  // FORTRAN_RUNTIME_TYPE_CODE_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_TYPE_CODE_H_
diff --git a/runtime/unit-map.cpp b/runtime/unit-map.cpp
index c505f0b0814a..4e58cf590c2a 100644
--- a/runtime/unit-map.cpp
+++ b/runtime/unit-map.cpp
@@ -55,7 +55,7 @@ void UnitMap::CloseAll(IoErrorHandler &handler) {
   CriticalSection critical{lock_};
   for (int j{0}; j < buckets_; ++j) {
     while (Chain * p{bucket_[j].get()}) {
-      bucket_[j].swap(p->next);  // pops p from head of list
+      bucket_[j].swap(p->next); // pops p from head of list
       p->unit.CloseUnit(CloseStatus::Keep, handler);
       p->unit.~ExternalFileUnit();
       FreeMemory(p);
@@ -66,7 +66,7 @@ void UnitMap::CloseAll(IoErrorHandler &handler) {
 ExternalFileUnit &UnitMap::Create(int n, const Terminator &terminator) {
   Chain &chain{New<Chain>{}(terminator, n)};
   chain.next.reset(&chain);
-  bucket_[Hash(n)].swap(chain.next);  // pushes new node as list head
+  bucket_[Hash(n)].swap(chain.next); // pushes new node as list head
   return chain.unit;
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/unit-map.h b/runtime/unit-map.h
index 550716fc25e8..8b8afb3b4638 100644
--- a/runtime/unit-map.h
+++ b/runtime/unit-map.h
@@ -57,7 +57,7 @@ class UnitMap {
     OwningPtr<Chain> next{nullptr};
   };
 
-  static constexpr int buckets_{1031};  // must be prime
+  static constexpr int buckets_{1031}; // must be prime
   int Hash(int n) { return n % buckets_; }
 
   ExternalFileUnit *Find(int n) {
@@ -67,8 +67,8 @@ class UnitMap {
       if (p->unit.unitNumber() == n) {
         if (previous) {
           // Move found unit to front of chain for quicker lookup next time
-          previous->next.swap(p->next);  // now p->next.get() == p
-          bucket_[hash].swap(p->next);  // now bucket_[hash].get() == p
+          previous->next.swap(p->next); // now p->next.get() == p
+          bucket_[hash].swap(p->next); // now bucket_[hash].get() == p
         }
         return &p->unit;
       }
@@ -79,9 +79,9 @@ class UnitMap {
   ExternalFileUnit &Create(int, const Terminator &);
 
   Lock lock_;
-  OwningPtr<Chain> bucket_[buckets_]{};  // all owned by *this
-  int nextNewUnit_{-1000};  // see 12.5.6.12 in Fortran 2018
-  OwningPtr<Chain> closing_{nullptr};  // units during CLOSE statement
+  OwningPtr<Chain> bucket_[buckets_]{}; // all owned by *this
+  int nextNewUnit_{-1000}; // see 12.5.6.12 in Fortran 2018
+  OwningPtr<Chain> closing_{nullptr}; // units during CLOSE statement
 };
-}
-#endif  // FORTRAN_RUNTIME_UNIT_MAP_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_UNIT_MAP_H_
diff --git a/runtime/unit.cpp b/runtime/unit.cpp
index 7c9801f23411..0661d55134f4 100644
--- a/runtime/unit.cpp
+++ b/runtime/unit.cpp
@@ -26,7 +26,7 @@ void FlushOutputOnCrash(const Terminator &terminator) {
   CriticalSection critical{unitMapLock};
   if (defaultOutput) {
     IoErrorHandler handler{terminator};
-    handler.HasIoStat();  // prevent nested crash if flush has error
+    handler.HasIoStat(); // prevent nested crash if flush has error
     defaultOutput->Flush(handler);
   }
 }
@@ -83,7 +83,7 @@ void ExternalFileUnit::CloseUnit(CloseStatus status, IoErrorHandler &handler) {
 }
 
 void ExternalFileUnit::DestroyClosed() {
-  GetUnitMap().DestroyClosed(*this);  // destroys *this
+  GetUnitMap().DestroyClosed(*this); // destroys *this
 }
 
 UnitMap &ExternalFileUnit::GetUnitMap() {
@@ -137,12 +137,12 @@ bool ExternalFileUnit::Emit(
 
 std::optional<char32_t> ExternalFileUnit::GetCurrentChar(
     IoErrorHandler &handler) {
-  isReading_ = true;  // TODO: manage read/write transitions
+  isReading_ = true; // TODO: manage read/write transitions
   if (isUnformatted) {
     handler.Crash("GetCurrentChar() called for unformatted input");
     return std::nullopt;
   }
-  std::size_t chunk{256};  // for stream input
+  std::size_t chunk{256}; // for stream input
   if (recordLength.has_value()) {
     if (positionInRecord >= *recordLength) {
       return std::nullopt;
@@ -190,7 +190,7 @@ bool ExternalFileUnit::AdvanceRecord(IoErrorHandler &handler) {
       }
     } else {
       positionInRecord = furthestPositionInRecord + 1;
-      ok &= Emit("\n", 1, handler);  // TODO: Windows CR+LF
+      ok &= Emit("\n", 1, handler); // TODO: Windows CR+LF
       frameOffsetInFile_ += recordOffsetInFrame_ + furthestPositionInRecord;
       recordOffsetInFrame_ = 0;
     }
@@ -240,7 +240,7 @@ void ExternalFileUnit::NextSequentialUnformattedInputRecord(
   std::int32_t header{0}, footer{0};
   // Retain previous footer (if any) in frame for more efficient BACKSPACE
   std::size_t retain{sizeof header};
-  if (recordLength) {  // not first record - advance to next
+  if (recordLength) { // not first record - advance to next
     ++currentRecordNumber;
     if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
       handler.SignalEnd();
@@ -379,7 +379,7 @@ void ExternalFileUnit::BackspaceSequentialFormattedRecord(
     ReadFrame(0, *recordLength + 1, handler);
   } else {
     RUNTIME_CHECK(handler, start > 1);
-    std::int64_t at{start - 2};  // byte before previous record's newline
+    std::int64_t at{start - 2}; // byte before previous record's newline
     while (true) {
       if (const char *p{
               FindLastNewline(Frame(), at - frameOffsetInFile_ + 1)}) {
@@ -410,4 +410,4 @@ void ExternalFileUnit::BackspaceSequentialFormattedRecord(
     --*recordLength;
   }
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/runtime/unit.h b/runtime/unit.h
index b32c2cde74db..cb40ddebacc5 100644
--- a/runtime/unit.h
+++ b/runtime/unit.h
@@ -49,10 +49,10 @@ class ExternalFileUnit : public ConnectionState,
   void CloseUnit(CloseStatus, IoErrorHandler &);
   void DestroyClosed();
 
-  template<typename A, typename... X>
+  template <typename A, typename... X>
   IoStatementState &BeginIoStatement(X &&... xs) {
     // TODO: Child data transfer statements vs. locking
-    lock_.Take();  // dropped in EndIoStatement()
+    lock_.Take(); // dropped in EndIoStatement()
     A &state{u_.emplace<A>(std::forward<X>(xs)...)};
     if constexpr (!std::is_same_v<A, OpenStatementState>) {
       state.mutableModes() = ConnectionState::modes;
@@ -102,8 +102,8 @@ class ExternalFileUnit : public ConnectionState,
   // during a single list-directed READ due to the possibility of a
   // multi-record CHARACTER value with a "r*" repeat count.
   std::int64_t frameOffsetInFile_{0};
-  std::int64_t recordOffsetInFrame_{0};  // of currentRecordNumber
+  std::int64_t recordOffsetInFrame_{0}; // of currentRecordNumber
 };
 
-}
-#endif  // FORTRAN_RUNTIME_IO_UNIT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_UNIT_H_
diff --git a/tools/f18-parse-demo/f18-parse-demo.cpp b/tools/f18-parse-demo/f18-parse-demo.cpp
index ebb35615263d..fd577e2fd350 100644
--- a/tools/f18-parse-demo/f18-parse-demo.cpp
+++ b/tools/f18-parse-demo/f18-parse-demo.cpp
@@ -80,13 +80,13 @@ double CPUseconds() { return 0; }
 
 struct DriverOptions {
   DriverOptions() {}
-  bool verbose{false};  // -v
-  bool compileOnly{false};  // -c
-  std::string outputPath;  // -o path
-  std::vector<std::string> searchDirectories{"."s};  // -I dir
-  bool forcedForm{false};  // -Mfixed or -Mfree appeared
-  bool warnOnNonstandardUsage{false};  // -Mstandard
-  bool warningsAreErrors{false};  // -Werror
+  bool verbose{false}; // -v
+  bool compileOnly{false}; // -c
+  std::string outputPath; // -o path
+  std::vector<std::string> searchDirectories{"."s}; // -I dir
+  bool forcedForm{false}; // -Mfixed or -Mfree appeared
+  bool warnOnNonstandardUsage{false}; // -Mstandard
+  bool warningsAreErrors{false}; // -Werror
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::LATIN_1};
   bool parseOnly{false};
   bool dumpProvenance{false};
@@ -100,7 +100,7 @@ struct DriverOptions {
 
 bool ParentProcess() {
   if (fork() == 0) {
-    return false;  // in child process
+    return false; // in child process
   }
   int childStat{0};
   wait(&childStat);
@@ -451,7 +451,7 @@ int main(int argc, char *const argv[]) {
   }
   if (!options.features.IsEnabled(
           Fortran::common::LanguageFeature::BackslashEscapes)) {
-    driver.fcArgs.push_back("-fno-backslash");  // PGI "-Mbackslash"
+    driver.fcArgs.push_back("-fno-backslash"); // PGI "-Mbackslash"
   }
 
   if (!anyFiles) {
diff --git a/tools/f18-parse-demo/stub-evaluate.cpp b/tools/f18-parse-demo/stub-evaluate.cpp
index dbaa13a338d9..d673eca5fa50 100644
--- a/tools/f18-parse-demo/stub-evaluate.cpp
+++ b/tools/f18-parse-demo/stub-evaluate.cpp
@@ -26,7 +26,7 @@ struct ProcedureRef {
   ~ProcedureRef();
 };
 ProcedureRef::~ProcedureRef() {}
-}
+} // namespace Fortran::evaluate
 
 DEFINE_DELETER(Fortran::evaluate::GenericExprWrapper)
 DEFINE_DELETER(Fortran::evaluate::GenericAssignmentWrapper)
diff --git a/tools/f18/dump.cpp b/tools/f18/dump.cpp
index d04b8e094a23..f11b5aedf4c6 100644
--- a/tools/f18/dump.cpp
+++ b/tools/f18/dump.cpp
@@ -37,6 +37,6 @@ DEFINE_DUMP(semantics, Scope)
 DEFINE_DUMP(semantics, IntrinsicTypeSpec)
 DEFINE_DUMP(semantics, DerivedTypeSpec)
 DEFINE_DUMP(semantics, DeclTypeSpec)
-}
+} // namespace Fortran
 
 #endif
diff --git a/tools/f18/f18.cpp b/tools/f18/f18.cpp
index 51d3aec3d118..5538c9fc3e9a 100644
--- a/tools/f18/f18.cpp
+++ b/tools/f18/f18.cpp
@@ -47,8 +47,8 @@ static std::list<std::string> argList(int argc, char *const argv[]) {
 }
 
 struct MeasurementVisitor {
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {
     ++objects;
     bytes += sizeof(A);
   }
@@ -79,15 +79,15 @@ struct GetDefinitionArgs {
 
 struct DriverOptions {
   DriverOptions() {}
-  bool verbose{false};  // -v
-  bool compileOnly{false};  // -c
-  std::string outputPath;  // -o path
-  std::vector<std::string> searchDirectories{"."s};  // -I dir
-  std::string moduleDirectory{"."s};  // -module dir
-  std::string moduleFileSuffix{".mod"};  // -moduleSuffix suff
-  bool forcedForm{false};  // -Mfixed or -Mfree appeared
-  bool warnOnNonstandardUsage{false};  // -Mstandard
-  bool warningsAreErrors{false};  // -Werror
+  bool verbose{false}; // -v
+  bool compileOnly{false}; // -c
+  std::string outputPath; // -o path
+  std::vector<std::string> searchDirectories{"."s}; // -I dir
+  std::string moduleDirectory{"."s}; // -module dir
+  std::string moduleFileSuffix{".mod"}; // -moduleSuffix suff
+  bool forcedForm{false}; // -Mfixed or -Mfree appeared
+  bool warnOnNonstandardUsage{false}; // -Mstandard
+  bool warningsAreErrors{false}; // -Werror
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
   bool parseOnly{false};
   bool dumpProvenance{false};
@@ -111,7 +111,7 @@ struct DriverOptions {
 
 bool ParentProcess() {
   if (fork() == 0) {
-    return false;  // in child process
+    return false; // in child process
   }
   int childStat{0};
   wait(&childStat);
@@ -640,7 +640,7 @@ int main(int argc, char *const argv[]) {
     if (!options.features.IsEnabled(
             Fortran::common::LanguageFeature::BackslashEscapes)) {
       driver.pgf90Args.push_back(
-          "-Mbackslash");  // yes, this *disables* them in pgf90
+          "-Mbackslash"); // yes, this *disables* them in pgf90
     }
     Fortran::parser::useHexadecimalEscapeSequences = false;
   } else {
diff --git a/unittests/Decimal/thorough-test.cpp b/unittests/Decimal/thorough-test.cpp
index e7aeed01ec8e..f8416bffa719 100644
--- a/unittests/Decimal/thorough-test.cpp
+++ b/unittests/Decimal/thorough-test.cpp
@@ -4,7 +4,7 @@
 #include <cstdio>
 #include <cstring>
 
-static constexpr int incr{1};  // steps through all values
+static constexpr int incr{1}; // steps through all values
 static constexpr bool doNegative{true};
 static constexpr bool doMinimize{true};
 
diff --git a/unittests/Evaluate/ISO-Fortran-binding.cpp b/unittests/Evaluate/ISO-Fortran-binding.cpp
index 1fff9d4d1998..da9ea3521388 100644
--- a/unittests/Evaluate/ISO-Fortran-binding.cpp
+++ b/unittests/Evaluate/ISO-Fortran-binding.cpp
@@ -8,7 +8,7 @@ using namespace Fortran::runtime;
 using namespace Fortran::ISO;
 
 // CFI_CDESC_T test helpers
-template<int rank> class Test_CFI_CDESC_T {
+template <int rank> class Test_CFI_CDESC_T {
 public:
   Test_CFI_CDESC_T() {}
   ~Test_CFI_CDESC_T() {}
@@ -22,7 +22,7 @@ template<int rank> class Test_CFI_CDESC_T {
     // suitable in size
     if (rank > 0) {
       MATCH(sizeof(dvStorage_), Descriptor::SizeInBytes(rank_, false));
-    } else {  // C++ implementation over-allocates for rank=0 by 24bytes.
+    } else { // C++ implementation over-allocates for rank=0 by 24bytes.
       MATCH(true, sizeof(dvStorage_) >= Descriptor::SizeInBytes(rank_, false));
     }
     // suitable in alignment
@@ -36,14 +36,14 @@ template<int rank> class Test_CFI_CDESC_T {
   CFI_CDESC_T(rank) dvStorage_;
 };
 
-template<int rank> static void TestCdescMacroForAllRanksSmallerThan() {
+template <int rank> static void TestCdescMacroForAllRanksSmallerThan() {
   static_assert(rank > 0, "rank<0!");
   Test_CFI_CDESC_T<rank> obj;
   obj.Check();
   TestCdescMacroForAllRanksSmallerThan<rank - 1>();
 }
 
-template<> void TestCdescMacroForAllRanksSmallerThan<0>() {
+template <> void TestCdescMacroForAllRanksSmallerThan<0>() {
   Test_CFI_CDESC_T<0> obj;
   obj.Check();
 }
@@ -191,11 +191,11 @@ static void run_CFI_establish_tests() {
   const int rank3d{3};
   CFI_CDESC_T(rank3d) dv3darrayStorage;
   CFI_cdesc_t *dv_3darray{&dv3darrayStorage};
-  AddNoiseToCdesc(dv_3darray, rank3d);  // => dv_3darray->dim[2].extent = -42
+  AddNoiseToCdesc(dv_3darray, rank3d); // => dv_3darray->dim[2].extent = -42
   check_CFI_establish(dv_3darray, nullptr, CFI_attribute_other, CFI_type_int, 4,
       rank3d, extents);
   MATCH(false,
-      dv_3darray->dim[2].extent == 2 + 66);  // extents was read
+      dv_3darray->dim[2].extent == 2 + 66); // extents was read
 }
 
 static void check_CFI_address(
@@ -412,13 +412,13 @@ static void run_CFI_section_tests() {
   bool testPreConditions{true};
   constexpr CFI_index_t m{5}, n{6}, o{7};
   constexpr CFI_rank_t rank{3};
-  long long array[o][n][m];  // Fortran A(m,n,o)
+  long long array[o][n][m]; // Fortran A(m,n,o)
   long long counter{1};
 
   for (CFI_index_t k{0}; k < o; ++k) {
     for (CFI_index_t j{0}; j < n; ++j) {
       for (CFI_index_t i{0}; i < m; ++i) {
-        array[k][j][i] = counter++;  // Fortran A(i,j,k)
+        array[k][j][i] = counter++; // Fortran A(i,j,k)
       }
     }
   }
@@ -446,7 +446,7 @@ static void run_CFI_section_tests() {
   }
 
   retCode = CFI_section(
-      result, source, lb, ub, strides);  // Fortran B = A(2:4:2, 5:5:0, 4:6:2)
+      result, source, lb, ub, strides); // Fortran B = A(2:4:2, 5:5:0, 4:6:2)
   MATCH(true, retCode == CFI_SUCCESS);
 
   const CFI_index_t lbs0{source->dim[0].lower_bound};
@@ -477,7 +477,7 @@ static void run_CFI_section_tests() {
   lb[0] = 4;
   ub[0] = 2;
   retCode = CFI_section(
-      result, source, lb, ub, strides);  // Fortran B = A(4:2:-1, 5:5:0, 4:6:2)
+      result, source, lb, ub, strides); // Fortran B = A(4:2:-1, 5:5:0, 4:6:2)
   MATCH(true, retCode == CFI_SUCCESS);
 
   resJ = result->dim[1].lower_bound;
@@ -540,7 +540,7 @@ static void run_CFI_select_part_tests() {
   }
 
   std::size_t displacement{offsetof(Galaxy, stars)};
-  std::size_t elem_len{0};  // ignored
+  std::size_t elem_len{0}; // ignored
   retCode = CFI_select_part(result, source, displacement, elem_len);
   MATCH(CFI_SUCCESS, retCode);
 
@@ -572,7 +572,7 @@ static void run_CFI_select_part_tests() {
   }
 
   displacement = offsetof(Galaxy, name) + 2;
-  elem_len = 2;  // not ignored this time
+  elem_len = 2; // not ignored this time
   retCode = CFI_select_part(result, source, displacement, elem_len);
   MATCH(CFI_SUCCESS, retCode);
 
diff --git a/unittests/Evaluate/folding.cpp b/unittests/Evaluate/folding.cpp
index 450f87ac2622..ec98c9846786 100644
--- a/unittests/Evaluate/folding.cpp
+++ b/unittests/Evaluate/folding.cpp
@@ -11,15 +11,15 @@
 using namespace Fortran::evaluate;
 
 // helper to call functions on all types from tuple
-template<typename... T> struct RunOnTypes {};
-template<typename Test, typename... T>
+template <typename... T> struct RunOnTypes {};
+template <typename Test, typename... T>
 struct RunOnTypes<Test, std::tuple<T...>> {
   static void Run() { (..., Test::template Run<T>()); }
 };
 
 // test for fold.h GetScalarConstantValue function
 struct TestGetScalarConstantValue {
-  template<typename T> static void Run() {
+  template <typename T> static void Run() {
     Expr<T> exprFullyTyped{Constant<T>{Scalar<T>{}}};
     Expr<SomeKind<T::category>> exprSomeKind{exprFullyTyped};
     Expr<SomeType> exprSomeType{exprSomeKind};
@@ -29,7 +29,7 @@ struct TestGetScalarConstantValue {
   }
 };
 
-template<typename T>
+template <typename T>
 static FunctionRef<T> CreateIntrinsicElementalCall(
     const std::string &name, const Expr<T> &arg) {
   Fortran::semantics::Attrs attrs;
@@ -45,12 +45,12 @@ static FunctionRef<T> CreateIntrinsicElementalCall(
 // HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment
 
 // Dummy host runtime functions where subnormal flushing matters
-float SubnormalFlusher1(float f) {  // given f is subnormal
-  return 2.3 * f;  // returns 0 if subnormal arguments are flushed to zero
+float SubnormalFlusher1(float f) { // given f is subnormal
+  return 2.3 * f; // returns 0 if subnormal arguments are flushed to zero
 }
 
-float SubnormalFlusher2(float f) {  // given f/2 is subnormal
-  return f / 2.3;  // returns 0 if subnormal
+float SubnormalFlusher2(float f) { // given f/2 is subnormal
+  return f / 2.3; // returns 0 if subnormal
 }
 
 void TestHostRuntimeSubnormalFlushing() {
@@ -98,7 +98,7 @@ void TestHostRuntimeSubnormalFlushing() {
       TEST(false);
     }
   } else {
-    TEST(false);  // Cannot run this test on the host
+    TEST(false); // Cannot run this test on the host
   }
 }
 
diff --git a/unittests/Evaluate/fp-testing.cpp b/unittests/Evaluate/fp-testing.cpp
index fe235eca7924..66ab7b274a82 100644
--- a/unittests/Evaluate/fp-testing.cpp
+++ b/unittests/Evaluate/fp-testing.cpp
@@ -83,10 +83,18 @@ RealFlags ScopedHostFloatingPointEnvironment::CurrentFlags() {
 
 void ScopedHostFloatingPointEnvironment::SetRounding(Rounding rounding) {
   switch (rounding.mode) {
-  case RoundingMode::TiesToEven: fesetround(FE_TONEAREST); break;
-  case RoundingMode::ToZero: fesetround(FE_TOWARDZERO); break;
-  case RoundingMode::Up: fesetround(FE_UPWARD); break;
-  case RoundingMode::Down: fesetround(FE_DOWNWARD); break;
+  case RoundingMode::TiesToEven:
+    fesetround(FE_TONEAREST);
+    break;
+  case RoundingMode::ToZero:
+    fesetround(FE_TOWARDZERO);
+    break;
+  case RoundingMode::Up:
+    fesetround(FE_UPWARD);
+    break;
+  case RoundingMode::Down:
+    fesetround(FE_DOWNWARD);
+    break;
   case RoundingMode::TiesAwayFromZero:
     std::fprintf(stderr, "SetRounding: TiesAwayFromZero not available");
     std::abort();
diff --git a/unittests/Evaluate/fp-testing.h b/unittests/Evaluate/fp-testing.h
index 9e10561fd9e4..760e976c4c96 100644
--- a/unittests/Evaluate/fp-testing.h
+++ b/unittests/Evaluate/fp-testing.h
@@ -22,4 +22,4 @@ class ScopedHostFloatingPointEnvironment {
   fenv_t currentFenv_;
 };
 
-#endif  // FORTRAN_TEST_EVALUATE_FP_TESTING_H_
+#endif // FORTRAN_TEST_EVALUATE_FP_TESTING_H_
diff --git a/unittests/Evaluate/integer.cpp b/unittests/Evaluate/integer.cpp
index a6111848ab9b..3eabb2434cce 100644
--- a/unittests/Evaluate/integer.cpp
+++ b/unittests/Evaluate/integer.cpp
@@ -6,7 +6,7 @@
 using Fortran::evaluate::Ordering;
 using Fortran::evaluate::value::Integer;
 
-template<int BITS, typename INT = Integer<BITS>> void exhaustiveTesting() {
+template <int BITS, typename INT = Integer<BITS>> void exhaustiveTesting() {
   std::uint64_t maxUnsignedValue{(std::uint64_t{1} << BITS) - 1};
   std::int64_t maxPositiveSignedValue{(std::int64_t{1} << (BITS - 1)) - 1};
   std::int64_t mostNegativeSignedValue{-(std::int64_t{1} << (BITS - 1))};
diff --git a/unittests/Evaluate/intrinsics.cpp b/unittests/Evaluate/intrinsics.cpp
index e2bf1cf18cb0..7123ef63b63d 100644
--- a/unittests/Evaluate/intrinsics.cpp
+++ b/unittests/Evaluate/intrinsics.cpp
@@ -41,35 +41,35 @@ class CookedStrings {
   std::map<std::string, std::size_t> offsets_;
 };
 
-template<typename A> auto Const(A &&x) -> Constant<TypeOf<A>> {
+template <typename A> auto Const(A &&x) -> Constant<TypeOf<A>> {
   return Constant<TypeOf<A>>{std::move(x)};
 }
 
-template<typename A> struct NamedArg {
+template <typename A> struct NamedArg {
   std::string keyword;
   A value;
 };
 
-template<typename A> static NamedArg<A> Named(std::string kw, A &&x) {
+template <typename A> static NamedArg<A> Named(std::string kw, A &&x) {
   return {kw, std::move(x)};
 }
 
 struct TestCall {
   TestCall(const common::IntrinsicTypeDefaultKinds &d,
       const IntrinsicProcTable &t, std::string n)
-    : defaults{d}, table{t}, name{n} {}
-  template<typename A> TestCall &Push(A &&x) {
+      : defaults{d}, table{t}, name{n} {}
+  template <typename A> TestCall &Push(A &&x) {
     args.emplace_back(AsGenericExpr(std::move(x)));
     keywords.push_back("");
     return *this;
   }
-  template<typename A> TestCall &Push(NamedArg<A> &&x) {
+  template <typename A> TestCall &Push(NamedArg<A> &&x) {
     args.emplace_back(AsGenericExpr(std::move(x.value)));
     keywords.push_back(x.keyword);
     strings.Save(x.keyword);
     return *this;
   }
-  template<typename A, typename... As> TestCall &Push(A &&x, As &&... xs) {
+  template <typename A, typename... As> TestCall &Push(A &&x, As &&... xs) {
     Push(std::move(x));
     return Push(std::move(xs)...);
   }
@@ -158,7 +158,7 @@ void TestIntrinsics() {
 
   TestCall{defaults, table, "bad"}
       .Push(Const(Scalar<Int4>{}))
-      .DoCall();  // bad intrinsic name
+      .DoCall(); // bad intrinsic name
   TestCall{defaults, table, "abs"}
       .Push(Named("a", Const(Scalar<Int4>{})))
       .DoCall(Int4::GetType());
@@ -167,12 +167,12 @@ void TestIntrinsics() {
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Named("bad", Const(Scalar<Int4>{})))
-      .DoCall();  // bad keyword
-  TestCall{defaults, table, "abs"}.DoCall();  // insufficient args
+      .DoCall(); // bad keyword
+  TestCall{defaults, table, "abs"}.DoCall(); // insufficient args
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .Push(Const(Scalar<Int4>{}))
-      .DoCall();  // too many args
+      .DoCall(); // too many args
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .Push(Named("a", Const(Scalar<Int4>{})))
@@ -259,7 +259,7 @@ void TestIntrinsics() {
       .DoCall(Int4::GetType());
   // TODO: test other intrinsics
 }
-}
+} // namespace Fortran::evaluate
 
 int main() {
   Fortran::evaluate::TestIntrinsics();
diff --git a/unittests/Evaluate/logical.cpp b/unittests/Evaluate/logical.cpp
index f2d171718093..d79aff844871 100644
--- a/unittests/Evaluate/logical.cpp
+++ b/unittests/Evaluate/logical.cpp
@@ -2,7 +2,7 @@
 #include "flang/Evaluate/type.h"
 #include <cstdio>
 
-template<int KIND> void testKind() {
+template <int KIND> void testKind() {
   using Type =
       Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, KIND>;
   TEST(Fortran::evaluate::IsSpecificIntrinsicType<Type>);
diff --git a/unittests/Evaluate/real.cpp b/unittests/Evaluate/real.cpp
index 90f9dcf408c2..d4c7ce5fb1aa 100644
--- a/unittests/Evaluate/real.cpp
+++ b/unittests/Evaluate/real.cpp
@@ -45,7 +45,7 @@ void dumpTest() {
   }
 }
 
-template<typename R> void basicTests(int rm, Rounding rounding) {
+template <typename R> void basicTests(int rm, Rounding rounding) {
   static constexpr int kind{R::bits / 8};
   char desc[64];
   using Word = typename R::Word;
@@ -148,7 +148,7 @@ template<typename R> void basicTests(int rm, Rounding rounding) {
       TEST(!vr.value.IsInfinite())(ldesc);
       TEST(ivf.flags.empty())(ldesc);
       MATCH(x, ivf.value.ToUInt64())(ldesc);
-      if (rounding.mode == RoundingMode::TiesToEven) {  // to match stold()
+      if (rounding.mode == RoundingMode::TiesToEven) { // to match stold()
         std::string buf;
         llvm::raw_string_ostream ss{buf};
         vr.value.AsFortran(ss, kind, false /*exact*/);
@@ -284,9 +284,9 @@ inline std::uint32_t FlagsToBits(const RealFlags &flags) {
   }
   return bits;
 }
-#endif  // __clang__
+#endif // __clang__
 
-template<typename UINT = std::uint32_t, typename FLT = float, typename REAL>
+template <typename UINT = std::uint32_t, typename FLT = float, typename REAL>
 void inttest(std::int64_t x, int pass, Rounding rounding) {
   union {
     UINT ui;
@@ -296,10 +296,10 @@ void inttest(std::int64_t x, int pass, Rounding rounding) {
   Integer8 ix{x};
   ValueWithRealFlags<REAL> real;
   real = real.value.FromInteger(ix, rounding);
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
   fpenv.ClearFlags();
 #endif
-  FLT fcheck = x;  // TODO unsigned too
+  FLT fcheck = x; // TODO unsigned too
   auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
   u.f = fcheck;
   UINT rcheck{NormalizeNaN(u.ui)};
@@ -308,7 +308,7 @@ void inttest(std::int64_t x, int pass, Rounding rounding) {
   MATCH(actualFlags, FlagsToBits(real.flags))("%d 0x%llx", pass, x);
 }
 
-template<typename FLT = float> FLT ToIntPower(FLT x, int power) {
+template <typename FLT = float> FLT ToIntPower(FLT x, int power) {
   if (power == 0) {
     return x / x;
   }
@@ -330,7 +330,7 @@ template<typename FLT = float> FLT ToIntPower(FLT x, int power) {
   return result;
 }
 
-template<typename FLT, int decimalDigits>
+template <typename FLT, int decimalDigits>
 FLT TimesIntPowerOfTen(FLT x, int power) {
   if (power > decimalDigits || power < -decimalDigits) {
     auto maxExactPowerOfTen{
@@ -343,7 +343,7 @@ FLT TimesIntPowerOfTen(FLT x, int power) {
   return x * ToIntPower<FLT>(10.0, power);
 }
 
-template<typename UINT = std::uint32_t, typename FLT = float,
+template <typename UINT = std::uint32_t, typename FLT = float,
     typename REAL = Real4>
 void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
   for (int j{0}; j < 63; ++j) {
@@ -372,16 +372,16 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
     // unary operations
     {
       ValueWithRealFlags<REAL> aint{x.ToWholeNumber()};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
       fpenv.ClearFlags();
 #endif
       FLT fcheck{std::trunc(fj)};
       auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
-      actualFlags &= ~Inexact;  // x86 std::trunc can set Inexact; AINT ain't
+      actualFlags &= ~Inexact; // x86 std::trunc can set Inexact; AINT ain't
       u.f = fcheck;
 #ifndef __clang__
       if (IsNaN(u.ui)) {
-        actualFlags |= InvalidArgument;  // x86 std::trunc(NaN) workaround
+        actualFlags |= InvalidArgument; // x86 std::trunc(NaN) workaround
       }
 #endif
       UINT rcheck{NormalizeNaN(u.ui)};
@@ -440,7 +440,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       REAL y{typename REAL::Word{std::uint64_t{rk}}};
       {
         ValueWithRealFlags<REAL> sum{x.Add(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj + fk};
@@ -457,7 +457,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       }
       {
         ValueWithRealFlags<REAL> diff{x.Subtract(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj - fk};
@@ -474,7 +474,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       }
       {
         ValueWithRealFlags<REAL> prod{x.Multiply(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj * fk};
@@ -491,7 +491,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       }
       {
         ValueWithRealFlags<REAL> quot{x.Divide(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj / fk};
@@ -524,7 +524,7 @@ void roundTest(int rm, Rounding rounding, std::uint32_t opds) {
 
 int main() {
   dumpTest();
-  std::uint32_t opds{512};  // for quick testing by default
+  std::uint32_t opds{512}; // for quick testing by default
   if (const char *p{std::getenv("REAL_TEST_OPERANDS")}) {
     // Use 8192 or 16384 for more exhaustive testing.
     opds = std::atol(p);
diff --git a/unittests/Evaluate/testing.cpp b/unittests/Evaluate/testing.cpp
index 9be31540ec7b..b2f73bf1b265 100644
--- a/unittests/Evaluate/testing.cpp
+++ b/unittests/Evaluate/testing.cpp
@@ -9,7 +9,7 @@ namespace testing {
 namespace {
 int passes{0};
 int failures{0};
-}
+} // namespace
 
 static void BitBucket(const char *, ...) {}
 
@@ -124,4 +124,4 @@ int Complete() {
     return EXIT_FAILURE;
   }
 }
-}
+} // namespace testing
diff --git a/unittests/Evaluate/testing.h b/unittests/Evaluate/testing.h
index 639a698d72d5..422e2853c05b 100644
--- a/unittests/Evaluate/testing.h
+++ b/unittests/Evaluate/testing.h
@@ -32,5 +32,5 @@ FailureDetailPrinter Match(const char *file, int line, const std::string &want,
     const char *gots, const std::string &got);
 FailureDetailPrinter Compare(const char *file, int line, const char *xs,
     const char *rel, const char *ys, std::uint64_t x, std::uint64_t y);
-}
-#endif  // FORTRAN_EVALUATE_TESTING_H_
+} // namespace testing
+#endif // FORTRAN_EVALUATE_TESTING_H_
diff --git a/unittests/Evaluate/uint128.cpp b/unittests/Evaluate/uint128.cpp
index f2ddcbf557eb..f05c1c96a7e8 100644
--- a/unittests/Evaluate/uint128.cpp
+++ b/unittests/Evaluate/uint128.cpp
@@ -106,7 +106,7 @@ static void TestVsNative() {
       TestVsNative(m ^ ~n, m ^ n);
       TestVsNative(m ^ n, ~m ^ n);
       TestVsNative(m ^ ~n, ~m ^ n);
-      Test(m, 10000000000000000);  // important case for decimal conversion
+      Test(m, 10000000000000000); // important case for decimal conversion
       Test(~m, 10000000000000000);
     }
   }
diff --git a/unittests/Runtime/hello.cpp b/unittests/Runtime/hello.cpp
index cc2d1205a751..64ed2cbaba72 100644
--- a/unittests/Runtime/hello.cpp
+++ b/unittests/Runtime/hello.cpp
@@ -175,13 +175,13 @@ int main() {
     double d;
     std::uint64_t n;
   } u;
-  u.n = 0x8000000000000000;  // -0
+  u.n = 0x8000000000000000; // -0
   realTest("(E9.1,';')", u.d, " -0.0E+00;");
   realTest("(F4.0,';')", u.d, " -0.;");
   realTest("(G8.0,';')", u.d, "-0.0E+00;");
   realTest("(G8.1,';')", u.d, " -0.    ;");
   realTest("(G0,';')", u.d, "-0.;");
-  u.n = 0x7ff0000000000000;  // +Inf
+  u.n = 0x7ff0000000000000; // +Inf
   realTest("(E9.1,';')", u.d, "      Inf;");
   realTest("(F9.1,';')", u.d, "      Inf;");
   realTest("(G9.1,';')", u.d, "      Inf;");
@@ -189,17 +189,17 @@ int main() {
   realTest("(SP,F9.1,';')", u.d, "     +Inf;");
   realTest("(SP,G9.1,';')", u.d, "     +Inf;");
   realTest("(G0,';')", u.d, "Inf;");
-  u.n = 0xfff0000000000000;  // -Inf
+  u.n = 0xfff0000000000000; // -Inf
   realTest("(E9.1,';')", u.d, "     -Inf;");
   realTest("(F9.1,';')", u.d, "     -Inf;");
   realTest("(G9.1,';')", u.d, "     -Inf;");
   realTest("(G0,';')", u.d, "-Inf;");
-  u.n = 0x7ff0000000000001;  // NaN
+  u.n = 0x7ff0000000000001; // NaN
   realTest("(E9.1,';')", u.d, "      NaN;");
   realTest("(F9.1,';')", u.d, "      NaN;");
   realTest("(G9.1,';')", u.d, "      NaN;");
   realTest("(G0,';')", u.d, "NaN;");
-  u.n = 0xfff0000000000001;  // NaN (sign irrelevant)
+  u.n = 0xfff0000000000001; // NaN (sign irrelevant)
   realTest("(E9.1,';')", u.d, "      NaN;");
   realTest("(F9.1,';')", u.d, "      NaN;");
   realTest("(G9.1,';')", u.d, "      NaN;");
@@ -208,7 +208,7 @@ int main() {
   realTest("(SP,G9.1,';')", u.d, "      NaN;");
   realTest("(G0,';')", u.d, "NaN;");
 
-  u.n = 0x3fb999999999999a;  // 0.1 rounded
+  u.n = 0x3fb999999999999a; // 0.1 rounded
   realTest("(E62.55,';')", u.d,
       " 0.1000000000000000055511151231257827021181583404541015625E+00;");
   realTest("(E0.0,';')", u.d, "0.E+00;");
@@ -228,7 +228,7 @@ int main() {
       ".1000000000000000055511151231257827021181583404541015625;");
   realTest("(G0,';')", u.d, ".1;");
 
-  u.n = 0x3ff8000000000000;  // 1.5
+  u.n = 0x3ff8000000000000; // 1.5
   realTest("(E9.2,';')", u.d, " 0.15E+01;");
   realTest("(F4.1,';')", u.d, " 1.5;");
   realTest("(G7.1,';')", u.d, " 2.    ;");
@@ -254,7 +254,7 @@ int main() {
 
   // TODO continue F and G editing tests on these data
 
-  u.n = 0xbff8000000000000;  // -1.5
+  u.n = 0xbff8000000000000; // -1.5
   realTest("(E9.2,';')", u.d, "-0.15E+01;");
   realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
   realTest("(RD,E8.1,';')", u.d, "-0.2E+01;");
@@ -262,7 +262,7 @@ int main() {
   realTest("(RZ,E8.1,';')", u.d, "-0.1E+01;");
   realTest("(RC,E8.1,';')", u.d, "-0.2E+01;");
 
-  u.n = 0x4004000000000000;  // 2.5
+  u.n = 0x4004000000000000; // 2.5
   realTest("(E9.2,';')", u.d, " 0.25E+01;");
   realTest("(RN,E8.1,';')", u.d, " 0.2E+01;");
   realTest("(RD,E8.1,';')", u.d, " 0.2E+01;");
@@ -270,7 +270,7 @@ int main() {
   realTest("(RZ,E8.1,';')", u.d, " 0.2E+01;");
   realTest("(RC,E8.1,';')", u.d, " 0.3E+01;");
 
-  u.n = 0xc004000000000000;  // -2.5
+  u.n = 0xc004000000000000; // -2.5
   realTest("(E9.2,';')", u.d, "-0.25E+01;");
   realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
   realTest("(RD,E8.1,';')", u.d, "-0.3E+01;");
@@ -278,7 +278,7 @@ int main() {
   realTest("(RZ,E8.1,';')", u.d, "-0.2E+01;");
   realTest("(RC,E8.1,';')", u.d, "-0.3E+01;");
 
-  u.n = 1;  // least positive nonzero subnormal
+  u.n = 1; // least positive nonzero subnormal
   realTest("(E32.17,';')", u.d, "         0.49406564584124654-323;");
   realTest("(ES32.17,';')", u.d, "         4.94065645841246544-324;");
   realTest("(EN32.17,';')", u.d, "         4.94065645841246544-324;");
@@ -362,7 +362,7 @@ int main() {
       "273816725095583738973359899366480994116420570263709027924276754456522908"
       "753868250641971826553344726563-323;");
 
-  u.n = 0x10000000000000;  // least positive nonzero normal
+  u.n = 0x10000000000000; // least positive nonzero normal
   realTest("(E723.716,';')", u.d,
       " 0."
       "222507385850720138309023271733240406421921598046233183055332741688720443"
@@ -378,7 +378,7 @@ int main() {
       "307;");
   realTest("(G0,';')", u.d, ".22250738585072014-307;");
 
-  u.n = 0x7fefffffffffffffuLL;  // greatest finite
+  u.n = 0x7fefffffffffffffuLL; // greatest finite
   realTest("(E32.17,';')", u.d, "         0.17976931348623157+309;");
   realTest("(E317.310,';')", u.d,
       " 0."
@@ -415,9 +415,9 @@ int main() {
   realInTest("(F18.1)", "               125", 0x4029000000000000);
   realInTest("(F18.2)", "               125", 0x3ff4000000000000);
   realInTest("(F18.3)", "               125", 0x3fc0000000000000);
-  realInTest("(-1P,F18.0)", "               125", 0x4093880000000000);  // 1250
-  realInTest("(1P,F18.0)", "               125", 0x4029000000000000);  // 12.5
-  realInTest("(BZ,F18.0)", "              125 ", 0x4093880000000000);  // 1250
+  realInTest("(-1P,F18.0)", "               125", 0x4093880000000000); // 1250
+  realInTest("(1P,F18.0)", "               125", 0x4029000000000000); // 12.5
+  realInTest("(BZ,F18.0)", "              125 ", 0x4093880000000000); // 1250
   realInTest("(DC,F18.0)", "              12,5", 0x4029000000000000);
 
   return EndTests();
diff --git a/unittests/Runtime/testing.h b/unittests/Runtime/testing.h
index 4bc2b9148a0a..943b6fd8d915 100644
--- a/unittests/Runtime/testing.h
+++ b/unittests/Runtime/testing.h
@@ -5,7 +5,7 @@
 #include <iosfwd>
 
 namespace llvm {
- class raw_ostream;
+class raw_ostream;
 }
 
 void StartTests();
@@ -14,4 +14,4 @@ int EndTests();
 
 void SetCharacter(char *, std::size_t, const char *);
 
-#endif  // FORTRAN_TEST_RUNTIME_TESTING_H_
+#endif // FORTRAN_TEST_RUNTIME_TESTING_H_

From 098f01bc474798ae03bd4dc7de6c929deec6f244 Mon Sep 17 00:00:00 2001
From: Pete Steinfeld <psteinfeld@nvidia.com>
Date: Mon, 30 Mar 2020 17:42:50 -0700
Subject: [PATCH 109/345] Checks for constraints C731 through C740

In most cases, I just added the contraint names to the code and tests.

I implemented the following checks:
  - C736 A child type with a coarray ultimate component must have a parent with
    a coarray ultimate component.
  - C737 A child type with and EVENT_TYPE or LOCK_TYPE component must have a
    parent either which is EVENT_TYPE or LOCK_TYPE or a type with an EVENT_TYPE
    or LOCK_TYPE component.
  - C740 Sequence types must contain at least on component
  - C740 Data components of sequence types must either be of an intrinsic type
    or a sequenced derived type.

After implementing these checks, some tests had new errors unrelated to their
original purpose, so I fixed them.
---
 include/flang/Semantics/scope.h      |  1 +
 include/flang/Semantics/type.h       |  1 +
 lib/Semantics/check-declarations.cpp | 33 ++++++++--
 lib/Semantics/resolve-names.cpp      | 40 ++++++++++---
 lib/Semantics/scope.cpp              |  9 +++
 lib/Semantics/type.cpp               |  8 +++
 test/Semantics/assign02.f90          |  1 +
 test/Semantics/bad-forward-type.f90  |  2 +
 test/Semantics/bindings01.f90        |  4 +-
 test/Semantics/label11.f90           |  2 +
 test/Semantics/modfile33.f90         |  8 +++
 test/Semantics/resolve31.f90         | 37 ++++++++++++
 test/Semantics/resolve33.f90         |  2 +
 test/Semantics/resolve86.f90         | 44 ++++++++++++++
 test/Semantics/resolve87.f90         | 90 ++++++++++++++++++++++++++++
 15 files changed, 268 insertions(+), 14 deletions(-)
 create mode 100644 test/Semantics/resolve86.f90
 create mode 100644 test/Semantics/resolve87.f90

diff --git a/include/flang/Semantics/scope.h b/include/flang/Semantics/scope.h
index b55cf509c78d..38b884e9eb0a 100644
--- a/include/flang/Semantics/scope.h
+++ b/include/flang/Semantics/scope.h
@@ -91,6 +91,7 @@ class Scope {
 
   const Symbol *GetSymbol() const;
   const Scope *GetDerivedTypeParent() const;
+  const Scope &GetDerivedTypeBase() const;
   std::optional<SourceName> GetName() const;
   bool Contains(const Scope &) const;
   /// Make a scope nested in this one
diff --git a/include/flang/Semantics/type.h b/include/flang/Semantics/type.h
index 00f38e2157f4..cc203181a8f5 100644
--- a/include/flang/Semantics/type.h
+++ b/include/flang/Semantics/type.h
@@ -336,6 +336,7 @@ class DeclTypeSpec {
   }
   bool IsAssumedType() const { return category_ == TypeStar; }
   bool IsNumeric(TypeCategory) const;
+  bool IsSequenceType() const;
   const NumericTypeSpec &numericTypeSpec() const;
   const LogicalTypeSpec &logicalTypeSpec() const;
   const CharacterTypeSpec &characterTypeSpec() const {
diff --git a/lib/Semantics/check-declarations.cpp b/lib/Semantics/check-declarations.cpp
index 15dd78270e5d..da02b4fbe47f 100644
--- a/lib/Semantics/check-declarations.cpp
+++ b/lib/Semantics/check-declarations.cpp
@@ -679,13 +679,14 @@ void CheckHelper::CheckSubprogram(
 
 void CheckHelper::CheckDerivedType(
     const Symbol &symbol, const DerivedTypeDetails &details) {
-  if (!symbol.scope()) {
+  const Scope *scope{symbol.scope()};
+  if (!scope) {
     CHECK(details.isForwardReferenced());
     return;
   }
-  CHECK(symbol.scope()->symbol() == &symbol);
-  CHECK(symbol.scope()->IsDerivedType());
-  if (symbol.attrs().test(Attr::ABSTRACT) &&
+  CHECK(scope->symbol() == &symbol);
+  CHECK(scope->IsDerivedType());
+  if (symbol.attrs().test(Attr::ABSTRACT) && // C734
       (symbol.attrs().test(Attr::BIND_C) || details.sequence())) {
     messages_.Say("An ABSTRACT derived type must be extensible"_err_en_US);
   }
@@ -699,7 +700,7 @@ void CheckHelper::CheckDerivedType(
       ScopeComponentIterator components{*parentDerived};
       for (const Symbol &component : components) {
         if (component.attrs().test(Attr::DEFERRED)) {
-          if (symbol.scope()->FindComponent(component.name()) == &component) {
+          if (scope->FindComponent(component.name()) == &component) {
             SayWithDeclaration(component,
                 "Non-ABSTRACT extension of ABSTRACT derived type '%s' lacks a binding for DEFERRED procedure '%s'"_err_en_US,
                 parentDerived->typeSymbol().name(), component.name());
@@ -707,6 +708,26 @@ void CheckHelper::CheckDerivedType(
         }
       }
     }
+    DerivedTypeSpec derived{symbol.name(), symbol};
+    derived.set_scope(*scope);
+    if (FindCoarrayUltimateComponent(derived) && // C736
+        !(parentDerived && FindCoarrayUltimateComponent(*parentDerived))) {
+      messages_.Say(
+          "Type '%s' has a coarray ultimate component so the type at the base "
+          "of its type extension chain ('%s') must be a type that has a "
+          "coarray ultimate component"_err_en_US,
+          symbol.name(), scope->GetDerivedTypeBase().GetSymbol()->name());
+    }
+    if (FindEventOrLockPotentialComponent(derived) && // C737
+        !(FindEventOrLockPotentialComponent(*parentDerived) ||
+            IsEventTypeOrLockType(parentDerived))) {
+      messages_.Say(
+          "Type '%s' has an EVENT_TYPE or LOCK_TYPE component, so the type "
+          "at the base of its type extension chain ('%s') must either have an "
+          "EVENT_TYPE or LOCK_TYPE component, or be EVENT_TYPE or "
+          "LOCK_TYPE"_err_en_US,
+          symbol.name(), scope->GetDerivedTypeBase().GetSymbol()->name());
+    }
   }
   if (HasIntrinsicTypeName(symbol)) { // C729
     messages_.Say("A derived type name cannot be the name of an intrinsic"
@@ -1141,7 +1162,7 @@ void CheckHelper::CheckProcBinding(
   CHECK(dtScope.kind() == Scope::Kind::DerivedType);
   if (const Symbol * dtSymbol{dtScope.symbol()}) {
     if (symbol.attrs().test(Attr::DEFERRED)) {
-      if (!dtSymbol->attrs().test(Attr::ABSTRACT)) {
+      if (!dtSymbol->attrs().test(Attr::ABSTRACT)) { // C733
         SayWithDeclaration(*dtSymbol,
             "Procedure bound to non-ABSTRACT derived type '%s' may not be DEFERRED"_err_en_US,
             dtSymbol->name());
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index 805a9c7a9979..ee2db0394f16 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -3682,18 +3682,40 @@ bool DeclarationVisitor::Pre(const parser::DerivedTypeDef &x) {
     }
   }
   Walk(std::get<std::list<parser::Statement<parser::PrivateOrSequence>>>(x.t));
+  const auto &componentDefs{
+      std::get<std::list<parser::Statement<parser::ComponentDefStmt>>>(x.t)};
+  Walk(componentDefs);
   if (derivedTypeInfo_.sequence) {
     details.set_sequence(true);
-    if (derivedTypeInfo_.extends) {
+    if (componentDefs.empty()) { // C740
       Say(stmt.source,
-          "A sequence type may not have the EXTENDS attribute"_err_en_US); // C735
+          "A sequence type must have at least one component"_err_en_US);
     }
-    if (!details.paramNames().empty()) {
+    if (!details.paramNames().empty()) { // C740
       Say(stmt.source,
-          "A sequence type may not have type parameters"_err_en_US); // C740
+          "A sequence type may not have type parameters"_err_en_US);
+    }
+    if (derivedTypeInfo_.extends) { // C735
+      Say(stmt.source,
+          "A sequence type may not have the EXTENDS attribute"_err_en_US);
+    } else {
+      for (const auto &componentName : details.componentNames()) {
+        const Symbol *componentSymbol{scope.FindComponent(componentName)};
+        if (componentSymbol && componentSymbol->has<ObjectEntityDetails>()) {
+          const auto &componentDetails{
+              componentSymbol->get<ObjectEntityDetails>()};
+          const DeclTypeSpec *componentType{componentDetails.type()};
+          if (componentType && // C740
+              !componentType->AsIntrinsic() &&
+              !componentType->IsSequenceType()) {
+            Say(componentSymbol->name(),
+                "A sequence type data component must either be of an"
+                " intrinsic type or a derived sequence type"_err_en_US);
+          }
+        }
+      }
     }
   }
-  Walk(std::get<std::list<parser::Statement<parser::ComponentDefStmt>>>(x.t));
   Walk(std::get<std::optional<parser::TypeBoundProcedurePart>>(x.t));
   Walk(std::get<parser::Statement<parser::EndTypeStmt>>(x.t));
   derivedTypeInfo_ = {};
@@ -3783,6 +3805,10 @@ bool DeclarationVisitor::Pre(const parser::PrivateStmt &) {
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::SequenceStmt &) {
+  if (derivedTypeInfo_.sequence) {
+    Say("SEQUENCE may not appear more than once in"
+        " derived type components"_en_US); // C738
+  }
   derivedTypeInfo_.sequence = true;
   return false;
 }
@@ -3796,7 +3822,7 @@ void DeclarationVisitor::Post(const parser::ComponentDecl &x) {
   if (!attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
     if (const auto *declType{GetDeclTypeSpec()}) {
       if (const auto *derived{declType->AsDerived()}) {
-        if (derivedTypeInfo_.type == &derived->typeSymbol()) { // C737
+        if (derivedTypeInfo_.type == &derived->typeSymbol()) { // C744
           Say("Recursive use of the derived type requires "
               "POINTER or ALLOCATABLE"_err_en_US);
         }
@@ -4648,7 +4674,7 @@ std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
       DerivedTypeDetails details;
       details.set_isForwardReferenced();
       symbol->set_details(std::move(details));
-    } else { // C883
+    } else { // C732
       Say(name, "Derived type '%s' not found"_err_en_US);
       return std::nullopt;
     }
diff --git a/lib/Semantics/scope.cpp b/lib/Semantics/scope.cpp
index dc934a51190d..85307c276d84 100644
--- a/lib/Semantics/scope.cpp
+++ b/lib/Semantics/scope.cpp
@@ -362,6 +362,15 @@ const Scope *Scope::GetDerivedTypeParent() const {
   return nullptr;
 }
 
+const Scope &Scope::GetDerivedTypeBase() const {
+  const Scope *child{this};
+  for (const Scope *parent{GetDerivedTypeParent()}; parent != nullptr;
+       parent = child->GetDerivedTypeParent()) {
+    child = parent;
+  }
+  return *child;
+}
+
 void Scope::InstantiateDerivedTypes(SemanticsContext &context) {
   for (DeclTypeSpec &type : declTypeSpecs_) {
     if (type.category() == DeclTypeSpec::TypeDerived ||
diff --git a/lib/Semantics/type.cpp b/lib/Semantics/type.cpp
index 108d04a1c403..f4fc7cbc2bed 100644
--- a/lib/Semantics/type.cpp
+++ b/lib/Semantics/type.cpp
@@ -472,6 +472,14 @@ DeclTypeSpec::DeclTypeSpec(Category category) : category_{category} {
 bool DeclTypeSpec::IsNumeric(TypeCategory tc) const {
   return category_ == Numeric && numericTypeSpec().category() == tc;
 }
+bool DeclTypeSpec::IsSequenceType() const {
+  if (const DerivedTypeSpec * derivedType{AsDerived()}) {
+    const auto *typeDetails{
+        derivedType->typeSymbol().detailsIf<DerivedTypeDetails>()};
+    return typeDetails && typeDetails->sequence();
+  }
+  return false;
+}
 IntrinsicTypeSpec *DeclTypeSpec::AsIntrinsic() {
   return const_cast<IntrinsicTypeSpec *>(
       const_cast<const DeclTypeSpec *>(this)->AsIntrinsic());
diff --git a/test/Semantics/assign02.f90 b/test/Semantics/assign02.f90
index c504f7a8ab1f..91bb845b3343 100644
--- a/test/Semantics/assign02.f90
+++ b/test/Semantics/assign02.f90
@@ -7,6 +7,7 @@ module m1
   end type
   type t2
     sequence
+    real :: t2Field
   end type
 contains
 
diff --git a/test/Semantics/bad-forward-type.f90 b/test/Semantics/bad-forward-type.f90
index 0c6de01ad06e..0fda08f3718c 100644
--- a/test/Semantics/bad-forward-type.f90
+++ b/test/Semantics/bad-forward-type.f90
@@ -1,5 +1,7 @@
 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Forward references to derived types (error cases)
+! C732 A parent-type-name shall be the name of a previously defined
+! extensible type (7.5.7).
 
 !ERROR: The derived type 'undef' was forward-referenced but not defined
 type(undef) function f1()
diff --git a/test/Semantics/bindings01.f90 b/test/Semantics/bindings01.f90
index 4c517ad6c439..9d155158ae05 100644
--- a/test/Semantics/bindings01.f90
+++ b/test/Semantics/bindings01.f90
@@ -1,6 +1,6 @@
 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Confirm enforcement of constraints and restrictions in 7.5.7.3
-! and C779-C785.
+! and C733, C734 and C779, C780, C781, C782, C783, C784, and C785.
 
 module m
   !ERROR: An ABSTRACT derived type must be extensible
@@ -9,6 +9,7 @@ module m
   !ERROR: An ABSTRACT derived type must be extensible
   type, abstract :: badAbstract2
     sequence
+    real :: badAbstract2Field
   end type
   type, abstract :: abstract
    contains
@@ -50,6 +51,7 @@ module m
   end type
   type :: inextensible2
     sequence
+    real :: inextensible2Field
   end type
   !ERROR: The parent type is not extensible
   type, extends(inextensible2) :: badExtends2
diff --git a/test/Semantics/label11.f90 b/test/Semantics/label11.f90
index 924356615e3b..71c40cf066d3 100644
--- a/test/Semantics/label11.f90
+++ b/test/Semantics/label11.f90
@@ -11,6 +11,8 @@
 ! CHECK: derived type definition name mismatch
 ! CHECK: MODULE PROCEDURE name mismatch
 ! CHECK: MODULE name mismatch
+! C739 If END TYPE is followed by a type-name, the type-name shall be the
+! same as that in the corresponding derived-type-stmt.
 
 block data t1
 end block data t2
diff --git a/test/Semantics/modfile33.f90 b/test/Semantics/modfile33.f90
index d5474c799f77..361542acbc33 100644
--- a/test/Semantics/modfile33.f90
+++ b/test/Semantics/modfile33.f90
@@ -9,6 +9,7 @@
 module m1
   type :: t
     sequence
+    logical :: x
   end type
   interface operator(+)
     pure integer(8) function add_ll(x, y)
@@ -61,6 +62,7 @@ subroutine s4(x, y, z)
 !module m1
 ! type :: t
 !  sequence
+!  logical(4) :: x
 ! end type
 ! interface operator(+)
 !  procedure :: add_ll
@@ -136,6 +138,7 @@ subroutine s4(x, y, z)
 module m2
   type :: t
     sequence
+    logical :: x
   end type
   interface operator(.And.)
     pure integer(8) function and_ti(x, y)
@@ -195,6 +198,7 @@ subroutine s5(x, y, z)
 !module m2
 ! type :: t
 !  sequence
+!  logical(4) :: x
 ! end type
 ! interface operator( .and.)
 !  procedure :: and_ti
@@ -275,6 +279,7 @@ subroutine s5(x, y, z)
 module m3
   type :: t
     sequence
+    logical :: x
   end type
   interface operator(<>)
     pure integer(8) function ne_it(x, y)
@@ -317,6 +322,7 @@ subroutine s3(x, y, z)
 !module m3
 ! type :: t
 !  sequence
+!  logical(4) :: x
 ! end type
 ! interface operator(<>)
 !  procedure :: ne_it
@@ -368,6 +374,7 @@ subroutine s3(x, y, z)
 module m4
   type :: t
     sequence
+    logical :: x
   end type
   interface operator(//)
     pure integer(8) function concat_12(x, y)
@@ -395,6 +402,7 @@ subroutine s2(x, y, z)
 !module m4
 ! type :: t
 !  sequence
+!  logical(4) :: x
 ! end type
 ! interface operator(//)
 !  procedure :: concat_12
diff --git a/test/Semantics/resolve31.f90 b/test/Semantics/resolve31.f90
index a1fb7cea54b1..14a7bc9c8a36 100644
--- a/test/Semantics/resolve31.f90
+++ b/test/Semantics/resolve31.f90
@@ -1,4 +1,13 @@
 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! C735 If EXTENDS appears, SEQUENCE shall not appear.
+! C738 The same private-or-sequence shall not appear more than once in a
+! given derived-type-def .
+!
+! C740 If SEQUENCE appears,
+!  the type shall have at least one component,
+!  each data component shall be declared to be of an intrinsic type or of a sequence type,
+!  the derived type shall not have any type parameter,
+!  and a type-bound-procedure-part shall not appear.
 subroutine s1
   integer :: t0
   !ERROR: 't0' is not a derived type
@@ -41,6 +50,8 @@ module m4
     private
     sequence
     private  ! not a fatal error
+    sequence ! not a fatal error
+    real :: t1Field
   end type
   type :: t1a
   end type
@@ -55,6 +66,32 @@ module m4
   !ERROR: A sequence type may not have a CONTAINS statement
   contains
   end type
+  !ERROR: A sequence type must have at least one component
+  type :: emptyType
+    sequence
+  end type emptyType
+  type :: plainType
+    real :: plainField
+  end type plainType
+  type :: sequenceType
+    sequence
+    real :: sequenceField
+  end type sequenceType
+  type :: testType
+    sequence
+    !ERROR: A sequence type data component must either be of an intrinsic type or a derived sequence type
+    class(*), allocatable :: typeStarField
+    !ERROR: A sequence type data component must either be of an intrinsic type or a derived sequence type
+    type(plainType) :: testField1
+    type(sequenceType) :: testField2
+    procedure(real), nopass :: procField
+  end type testType
+  !ERROR: A sequence type may not have type parameters
+  type :: paramType(param)
+    integer, kind :: param
+    sequence
+    real :: paramField
+  end type paramType
 contains
   subroutine s3
     type :: t1
diff --git a/test/Semantics/resolve33.f90 b/test/Semantics/resolve33.f90
index d4265cd3e2a0..176404b9db63 100644
--- a/test/Semantics/resolve33.f90
+++ b/test/Semantics/resolve33.f90
@@ -1,5 +1,7 @@
 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Derived type parameters
+! C731 The same type-param-name shall not appear more than once in a given
+! derived-type-stmt.
 
 module m
   !ERROR: Duplicate type parameter name: 'a'
diff --git a/test/Semantics/resolve86.f90 b/test/Semantics/resolve86.f90
new file mode 100644
index 000000000000..0c42bcea0a42
--- /dev/null
+++ b/test/Semantics/resolve86.f90
@@ -0,0 +1,44 @@
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! C736 If EXTENDS appears and the type being defined has a coarray ultimate 
+! component, its parent type shall have a coarray ultimate component.
+!
+subroutine s()
+  type coarrayParent
+    real,allocatable, codimension[:] :: parentField
+  end type coarrayParent
+
+  type, extends(coarrayParent) :: goodChildType
+    real, allocatable, codimension[:] :: childField
+  end type goodChildType
+
+  type, extends(coarrayParent) :: brotherType
+    real :: brotherField
+  end type brotherType
+
+  type, extends(brotherType) :: grandChildType
+    real, allocatable, codimension[:] :: grandChildField
+  end type grandChildType
+
+  type plainParent
+  end type plainParent
+
+  !ERROR: Type 'badchildtype' has a coarray ultimate component so the type at the base of its type extension chain ('plainparent') must be a type that has a coarray ultimate component
+  type, extends(plainParent) :: badChildType
+    real, allocatable, codimension[:] :: childField
+  end type badChildType
+
+  type, extends(plainParent) :: plainChild
+    real :: realField
+  end type plainChild
+
+  !ERROR: Type 'badchildtype2' has a coarray ultimate component so the type at the base of its type extension chain ('plainparent') must be a type that has a coarray ultimate component
+  type, extends(plainChild) :: badChildType2
+    real, allocatable, codimension[:] :: childField
+  end type badChildType2
+
+  !ERROR: Type 'badchildtype3' has a coarray ultimate component so the type at the base of its type extension chain ('plainparent') must be a type that has a coarray ultimate component
+  type, extends(plainParent) :: badChildType3
+    type(coarrayParent) :: childField
+  end type badChildType3
+
+end subroutine s
diff --git a/test/Semantics/resolve87.f90 b/test/Semantics/resolve87.f90
new file mode 100644
index 000000000000..ad09d8155ec6
--- /dev/null
+++ b/test/Semantics/resolve87.f90
@@ -0,0 +1,90 @@
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! C737 If EXTENDS appears and the type being defined has a potential 
+! subobject component of type EVENT_TYPE or LOCK_TYPE from the intrinsic 
+! module ISO_FORTRAN_ENV, its parent type shall be EVENT_TYPE or LOCK_TYPE 
+! or have a potential subobject component of type EVENT_TYPE or LOCK_TYPE.
+module not_iso_fortran_env
+  type event_type
+  end type
+
+  type lock_type
+  end type
+end module
+
+subroutine C737_a()
+  use iso_fortran_env
+
+  type lockGrandParentType
+    type(lock_type) :: grandParentField
+  end type lockGrandParentType
+
+  type, extends(lockGrandParentType) :: lockParentType
+    real :: parentField
+  end type lockParentType
+
+  type eventParentType
+    type(event_type) :: parentField
+  end type eventParentType
+
+  type noLockParentType
+  end type noLockParentType
+
+  type, extends(lockParentType) :: goodChildType1
+    type(lock_type) :: childField
+  end type goodChildType1
+
+  type, extends(lockParentType) :: goodChildType2
+    type(event_type) :: childField
+  end type goodChildType2
+
+  type, extends(lock_type) :: goodChildType3
+    type(event_type) :: childField
+  end type goodChildType3
+
+  type, extends(event_type) :: goodChildType4
+    type(lock_type) :: childField
+  end type goodChildType4
+
+  !ERROR: Type 'badchildtype1' has an EVENT_TYPE or LOCK_TYPE component, so the type at the base of its type extension chain ('nolockparenttype') must either have an EVENT_TYPE or LOCK_TYPE component, or be EVENT_TYPE or LOCK_TYPE
+  type, extends(noLockParentType) :: badChildType1
+    type(lock_type) :: childField
+  end type badChildType1
+
+  !ERROR: Type 'badchildtype2' has an EVENT_TYPE or LOCK_TYPE component, so the type at the base of its type extension chain ('nolockparenttype') must either have an EVENT_TYPE or LOCK_TYPE component, or be EVENT_TYPE or LOCK_TYPE
+  type, extends(noLockParentType) :: badChildType2
+    type(event_type) :: childField
+  end type badChildType2
+
+  !ERROR: Type 'badchildtype3' has an EVENT_TYPE or LOCK_TYPE component, so the type at the base of its type extension chain ('nolockparenttype') must either have an EVENT_TYPE or LOCK_TYPE component, or be EVENT_TYPE or LOCK_TYPE
+  type, extends(noLockParentType) :: badChildType3
+    type(lockParentType) :: childField
+  end type badChildType3
+
+  !ERROR: Type 'badchildtype4' has an EVENT_TYPE or LOCK_TYPE component, so the type at the base of its type extension chain ('nolockparenttype') must either have an EVENT_TYPE or LOCK_TYPE component, or be EVENT_TYPE or LOCK_TYPE
+  type, extends(noLockParentType) :: badChildType4
+    type(eventParentType) :: childField
+  end type badChildType4
+
+end subroutine C737_a
+
+subroutine C737_b()
+  use not_iso_fortran_env
+
+  type lockParentType
+    type(lock_type) :: parentField
+  end type lockParentType
+
+  type noLockParentType
+  end type noLockParentType
+
+  ! actually OK since this is not the predefined lock_type
+  type, extends(noLockParentType) :: notBadChildType1
+    type(lock_type) :: childField
+  end type notBadChildType1
+
+  ! actually OK since this is not the predefined event_type
+  type, extends(noLockParentType) :: notBadChildType2
+    type(event_type) :: childField
+  end type notBadChildType2
+
+end subroutine C737_b

From 1d287d9d59eaee357db604dd9986c74c298a7b4d Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Mon, 30 Mar 2020 16:37:30 -0700
Subject: [PATCH 110/345] Define CHARACTER runtime API, establish placeholder
 implementations

formatting
---
 documentation/Calls.md     |   7 +-
 documentation/Character.md | 147 +++++++++++++++++++++++++++++++++++++
 runtime/CMakeLists.txt     |   2 +
 runtime/allocatable.cpp    |  45 ++++++++++++
 runtime/allocatable.h      |   4 +-
 runtime/character.cpp      |  48 ++++++++++++
 runtime/character.h        |  53 +++++++++++++
 7 files changed, 301 insertions(+), 5 deletions(-)
 create mode 100644 documentation/Character.md
 create mode 100644 runtime/allocatable.cpp
 create mode 100644 runtime/character.cpp
 create mode 100644 runtime/character.h

diff --git a/documentation/Calls.md b/documentation/Calls.md
index bd57deeb3780..79f0d972bc73 100644
--- a/documentation/Calls.md
+++ b/documentation/Calls.md
@@ -1,9 +1,9 @@
-<!--===- documentation/Calls.md 
-  
+<!--===- documentation/Calls.md
+
    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
-  
+
 -->
 
 ## Procedure reference implementation protocol
@@ -182,6 +182,7 @@ some design alternatives that are explored further below.
    discretionary `VALUE` arguments) into registers.
 1. Marshal `CHARACTER` argument lengths in additional value arguments for
    `CHARACTER` effective arguments not passed via descriptors.
+   These lengths must be 64-bit integers.
 1. Marshal an extra argument for the length of a `CHARACTER` function
    result if the function is F77ish.
 1. Marshal an extra argument for the function result's descriptor,
diff --git a/documentation/Character.md b/documentation/Character.md
new file mode 100644
index 000000000000..d1c7ca479a17
--- /dev/null
+++ b/documentation/Character.md
@@ -0,0 +1,147 @@
+<!--===- documentation/Character.md
+
+   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
+
+-->
+
+## Implementation of `CHARACTER` types in f18
+
+### Kinds and Character Sets
+
+The f18 compiler and runtime support three kinds of the intrinsic
+`CHARACTER` type of Fortran 2018.
+The default (`CHARACTER(KIND=1)`) holds 8-bit character codes;
+`CHARACTER(KIND=2)` holds 16-bit character codes;
+and `CHARACTER(KIND=4)` holds 32-bit character codes.
+
+We assume that code values 0 through 127 correspond to
+the 7-bit ASCII character set (ISO-646) in every kind of `CHARACTER`.
+This is a valid assumption for Unicode (UCS == ISO/IEC-10646),
+ISO-8859, and many legacy character sets and interchange formats.
+
+`CHARACTER` data in memory and unformatted files are not in an
+interchange representation (like UTF-8, Shift-JIS, EUC-JP, or a JIS X).
+Each character's code in memory occupies a 1-, 2-, or 4- byte
+word and substrings can be indexed with simple arithmetic.
+In formatted I/O, however, `CHARACTER` data may be assumed to use
+the UTF-8 variable-length encoding when it is selected with
+`OPEN(ENCODING='UTF-8')`.
+
+`CHARACTER(KIND=1)` literal constants in Fortran source files,
+Hollerith constants, and formatted I/O with `ENCODING='DEFAULT'`
+are not translated.
+
+For the purposes of non-default-kind `CHARACTER` constants in Fortran
+source files, formatted I/O with `ENCODING='UTF-8'` or non-default-kind
+`CHARACTER` value, and conversions between kinds of `CHARACTER`,
+by default:
+* `CHARACTER(KIND=1)` is assumed to be ISO-8859-1 (Latin-1),
+* `CHARACTER(KIND=2)` is assumed to be UCS-2 (16-bit Unicode), and
+* `CHARACTER(KIND=4)` is assumed to be UCS-4 (full Unicode in a 32-bit word).
+
+In particular, conversions between kinds are assumed to be
+simple zero-extensions or truncation, not table look-ups.
+
+We might want to support one or more environment variables to change these
+assumptions, especially for `KIND=1` users of ISO-8859 character sets
+besides Latin-1.
+
+### Lengths
+
+Allocatable `CHARACTER` objects in Fortran may defer the specification
+of their lengths until the time of their allocation or whole (non-substring)
+assignment.
+Non-allocatable objects (and non-deferred-length allocatables) have
+lengths that are fixed or assumed from an actual argument, or,
+in the case of assumed-length `CHARACTER` functions, their local
+declaration in the calling scope.
+
+The elements of `CHARACTER` arrays have the same length.
+
+Assignments to targets that are not deferred-length allocatables will
+truncate or pad the assigned value to the length of the left-hand side
+of the assignment.
+
+Lengths and offsets that are used by or exposed to Fortran programs via
+declarations, substring bounds, and the `LEN()` intrinsic function are always
+represented in units of characters, not bytes.
+In generated code, assumed-length arguments, the runtime support library,
+and in the `elem_len` field of the interoperable descriptor `cdesc_t`,
+lengths are always in units of bytes.
+The distinction matters only for kinds other than the default.
+
+Fortran substrings are rather like subscript triplets into a hidden
+"zero" dimension of a scalar `CHARACTER` value, but they cannot have
+strides.
+
+### Concatenation
+
+Fortran has one `CHARACTER`-valued intrinsic operator, `//`, which
+concatenates its operands (10.1.5.3).
+The operands must have the same kind type parameter.
+One or both of the operands may be arrays; if both are arrays, their
+shapes must be identical.
+The effective length of the result is the sum of the lengths of the
+operands.
+Parentheses may be ignored, so any `CHARACTER`-valued expression
+may be "flattened" into a single sequence of concatenations.
+
+The result of `//` may be used
+* as an operand to another concatenation,
+* as an operand of a `CHARACTER` relation,
+* as an actual argument,
+* as the right-hand side of an assignment,
+* as the `SOURCE=` or `MOLD=` of an `ALLOCATE` statemnt,
+* as the selector or case-expr of an `ASSOCIATE` or `SELECT` construct,
+* as a component of a structure or array constructor,
+* as the value of a named constant or initializer,
+* as the `NAME=` of a `BIND(C)` attribute,
+* as the stop-code of a `STOP` statement,
+* as the value of a specifier of an I/O statement,
+* or as the value of a statement function.
+
+The f18 compiler has a general (but slow) means of implementing concatenation
+and a specialized (fast) option to optimize the most common case.
+
+#### General concatenation
+
+In the most general case, the f18 compiler's generated code and
+runtime support library represent the result as a deferred-length allocatable
+`CHARACTER` temporary scalar or array variable that is initialized
+as a zero-length array by `AllocatableInitCharacter()`
+and then progressively augmented in place by the values of each of the
+operands of the concatenation sequence in turn with calls to
+`CharacterConcatenate()`.
+Conformability errors are fatal -- Fortran has no means by which a program
+may recover from them.
+The result is then used as any other deferred-length allocatable
+array or scalar would be, and finally deallocated like any other
+allocatable.
+
+The runtime routine `CharacterAssign()` takes care of
+truncating, padding, or replicating the value(s) assigned to the left-hand
+side, as well as reallocating an nonconforming or deferred-length allocatable
+left-hand side.  It takes the descriptors of the left- and right-hand sides of
+a `CHARACTER` assignemnt as its arguments.
+
+When the left-hand side of a `CHARACTER` assignment is a deferred-length
+allocatable and the right-hand side is a temporary, use of the runtime's
+`MoveAlloc()` subroutine instead can save an allocation and a copy.
+
+#### Optimized concatenation
+
+Scalar `CHARACTER(KIND=1)` expressions evaluated as the right-hand sides of
+assignments to independent substrings or whole variables that are not
+deferred-length allocatables can be optimized into a sequence of
+calls to the runtime support library that do not allocate temporary
+memory.
+
+The routine `CharacterAppend()` copies data from the right-hand side value
+to the remaining space, if any, in the left-hand side object, and returns
+the new offset of the reduced remaining space.
+It is essentially `memcpy(lhs + offset, rhs, min(lhsLength - offset, rhsLength))`.
+It does nothing when `offset > lhsLength`.
+
+`void CharacterPad()`adds any necessary trailing blank characters.
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index 066cb7d12459..9232d8095fc1 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -28,7 +28,9 @@ configure_file(config.h.cmake config.h)
 
 add_library(FortranRuntime
   ISO_Fortran_binding.cpp
+  allocatable.cpp
   buffer.cpp
+  character.cpp
   connection.cpp
   derived-type.cpp
   descriptor.cpp
diff --git a/runtime/allocatable.cpp b/runtime/allocatable.cpp
new file mode 100644
index 000000000000..b47a40e5759a
--- /dev/null
+++ b/runtime/allocatable.cpp
@@ -0,0 +1,45 @@
+//===-- runtime/allocatable.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 "allocatable.h"
+#include "terminator.h"
+
+namespace Fortran::runtime {
+extern "C" {
+
+void RTNAME(AllocatableInitIntrinsic)(
+    Descriptor &, TypeCategory, int /*kind*/, int /*rank*/, int /*corank*/) {
+  // TODO
+}
+
+void RTNAME(AllocatableInitCharacter)(Descriptor &, SubscriptValue /*length*/,
+    int /*kind*/, int /*rank*/, int /*corank*/) {
+  // TODO
+}
+
+void RTNAME(AllocatableInitDerived)(
+    Descriptor &, const DerivedType &, int /*rank*/, int /*corank*/) {
+  // TODO
+}
+
+void RTNAME(AllocatableAssign)(Descriptor &to, const Descriptor & /*from*/) {}
+
+int RTNAME(MoveAlloc)(Descriptor &to, const Descriptor & /*from*/,
+    bool /*hasStat*/, Descriptor * /*errMsg*/, const char * /*sourceFile*/,
+    int /*sourceLine*/) {
+  // TODO
+  return 0;
+}
+
+int RTNAME(AllocatableDeallocate)(Descriptor &, bool /*hasStat*/,
+    Descriptor * /*errMsg*/, const char * /*sourceFile*/, int /*sourceLine*/) {
+  // TODO
+  return 0;
+}
+}
+} // namespace Fortran::runtime
diff --git a/runtime/allocatable.h b/runtime/allocatable.h
index d63bd2c482af..c65ede2da65e 100644
--- a/runtime/allocatable.h
+++ b/runtime/allocatable.h
@@ -26,7 +26,7 @@ extern "C" {
 // a change of type, rank, or corank.
 void RTNAME(AllocatableInitIntrinsic)(
     Descriptor &, TypeCategory, int kind, int rank = 0, int corank = 0);
-void RTNAME(AllocatableInitCharacter)(Descriptor &, SubscriptValue length,
+void RTNAME(AllocatableInitCharacter)(Descriptor &, SubscriptValue length = 0,
     int kind = 1, int rank = 0, int corank = 0);
 void RTNAME(AllocatableInitDerived)(
     Descriptor &, const DerivedType &, int rank = 0, int corank = 0);
@@ -94,7 +94,7 @@ int RTNAME(AllocatableAllocateSource)(Descriptor &, const Descriptor &source,
 // TODO: Consider renaming to a more general name that will work for
 // assignments to pointers, dummy arguments, and anything else with a
 // descriptor.
-void RTNAME(AllocatableAssignment)(Descriptor &to, const Descriptor &from);
+void RTNAME(AllocatableAssign)(Descriptor &to, const Descriptor &from);
 
 // Implements the intrinsic subroutine MOVE_ALLOC (16.9.137 in F'2018,
 // but note the order of first two arguments is reversed for consistency
diff --git a/runtime/character.cpp b/runtime/character.cpp
new file mode 100644
index 000000000000..b6a804dfa03f
--- /dev/null
+++ b/runtime/character.cpp
@@ -0,0 +1,48 @@
+//===-- runtime/character.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 "character.h"
+#include "terminator.h"
+#include <algorithm>
+#include <cstring>
+
+namespace Fortran::runtime {
+extern "C" {
+
+void RTNAME(CharacterConcatenate)(Descriptor & /*temp*/,
+    const Descriptor & /*operand*/, const char * /*sourceFile*/,
+    int /*sourceLine*/) {
+  // TODO
+}
+
+void RTNAME(CharacterConcatenateScalar)(
+    Descriptor & /*temp*/, const char * /*from*/, std::size_t /*byteLength*/) {
+  // TODO
+}
+
+void RTNAME(CharacterAssign)(Descriptor & /*lhs*/, const Descriptor & /*rhs*/,
+    const char * /*sourceFile*/, int /*sourceLine*/) {
+  // TODO
+}
+
+std::size_t RTNAME(CharacterAppend)(char *lhs, std::size_t lhsLength,
+    std::size_t offset, const char *rhs, std::size_t rhsLength) {
+  if (auto n{std::min(lhsLength - offset, rhsLength)}) {
+    std::memcpy(lhs + offset, rhs, n);
+    offset += n;
+  }
+  return offset;
+}
+
+void RTNAME(CharacterPad)(char *lhs, std::size_t length, std::size_t offset) {
+  if (length > offset) {
+    std::memset(lhs + offset, ' ', length - offset);
+  }
+}
+}
+} // namespace Fortran::runtime
diff --git a/runtime/character.h b/runtime/character.h
new file mode 100644
index 000000000000..ff182dec5445
--- /dev/null
+++ b/runtime/character.h
@@ -0,0 +1,53 @@
+//===-- runtime/character.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 API between compiled code and the CHARACTER
+// support functions in the runtime library.
+
+#ifndef FORTRAN_RUNTIME_CHARACTER_H_
+#define FORTRAN_RUNTIME_CHARACTER_H_
+#include "descriptor.h"
+#include "entry-names.h"
+#include <cstddef>
+
+namespace Fortran::runtime {
+extern "C" {
+
+// Appends the corresponding (or expanded) characters of 'operand'
+// to the (elements of) a (re)allocation of 'temp', which must be an
+// initialized CHARACTER allocatable scalar or array descriptor -- use
+// AllocatableInitCharacter() to set one up.  Crashes when not
+// conforming.  Assumes independence of data.
+void RTNAME(CharacterConcatenate)(Descriptor &temp, const Descriptor &operand,
+    const char *sourceFile = nullptr, int sourceLine = 0);
+
+// Convenience specialization for character scalars.
+void RTNAME(CharacterConcatenateScalar)(
+    Descriptor &temp, const char *, std::size_t byteLength);
+
+// Assigns the value(s) of 'rhs' to 'lhs'.  Handles reallocation,
+// truncation, or padding ss necessary.  Crashes when not conforming.
+// Assumes independence of data.
+// Call MoveAlloc() instead as an optimization when a temporary value is
+// being assigned to a deferred-length allocatable.
+void RTNAME(CharacterAssign)(Descriptor &lhs, const Descriptor &rhs,
+    const char *sourceFile = nullptr, int sourceLine = 0);
+
+// Special-case support for optimized scalar CHARACTER concatenation
+// expressions.
+
+// Copies data from 'rhs' to the remaining space (lhsLength - offset)
+// in 'lhs', if any.  Returns the new offset.  Assumes independence.
+std::size_t RTNAME(CharacterAppend)(char *lhs, std::size_t lhsLength,
+    std::size_t offset, const char *rhs, std::size_t rhsLength);
+
+// Appends any necessary spaces to a CHARACTER(KIND=1) scalar.
+void RTNAME(CharacterPad)(char *lhs, std::size_t length, std::size_t offset);
+}
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_CHARACTER_H_

From 361a151508b4a1940fc0669dead180be67964d8d Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Fri, 3 Apr 2020 12:05:03 -0700
Subject: [PATCH 111/345] Process names in ASSIGN and assigned GOTO

Allow ASSIGNed integer variables as formats

Address review comment
---
 include/flang/Parser/parse-tree.h    |  3 +-
 lib/Parser/io-parsers.cpp            |  3 +-
 lib/Semantics/check-io.cpp           | 34 ++++++++++---
 lib/Semantics/check-io.h             |  6 +--
 lib/Semantics/resolve-labels.cpp     | 74 ++++++++++++++++++++--------
 lib/Semantics/resolve-names.cpp      | 13 +++++
 lib/Semantics/rewrite-parse-tree.cpp |  2 +-
 lib/Semantics/semantics.cpp          | 34 +++++++++++--
 test/Semantics/assign06.f90          | 47 ++++++++++++++++++
 test/Semantics/assign07.f90          | 35 +++++++++++++
 test/Semantics/if_arith03.f90        |  6 +--
 test/Semantics/label02.f90           | 10 ++--
 test/Semantics/label03.f90           |  6 +--
 test/Semantics/label05.f90           |  8 +--
 test/Semantics/label06.f90           | 12 ++---
 test/Semantics/label07.f90           | 10 ++--
 test/Semantics/label09.f90           |  2 +-
 test/Semantics/label14.f90           |  2 +-
 18 files changed, 242 insertions(+), 65 deletions(-)
 create mode 100644 test/Semantics/assign06.f90
 create mode 100644 test/Semantics/assign07.f90

diff --git a/include/flang/Parser/parse-tree.h b/include/flang/Parser/parse-tree.h
index f5f7a18652fc..2e5227c5f1b4 100644
--- a/include/flang/Parser/parse-tree.h
+++ b/include/flang/Parser/parse-tree.h
@@ -2573,9 +2573,10 @@ struct CloseStmt {
 };
 
 // R1215 format -> default-char-expr | label | *
+// deprecated(ASSIGN): | scalar-int-name
 struct Format {
   UNION_CLASS_BOILERPLATE(Format);
-  std::variant<DefaultCharExpr, Label, Star> u;
+  std::variant<Expr, Label, Star> u;
 };
 
 // R1214 id-variable -> scalar-int-variable
diff --git a/lib/Parser/io-parsers.cpp b/lib/Parser/io-parsers.cpp
index 9eab72172b7b..30f6db172c74 100644
--- a/lib/Parser/io-parsers.cpp
+++ b/lib/Parser/io-parsers.cpp
@@ -240,8 +240,9 @@ TYPE_CONTEXT_PARSER("PRINT statement"_en_US,
         "PRINT" >> format, defaulted("," >> nonemptyList(outputItem))))
 
 // R1215 format -> default-char-expr | label | *
+// deprecated(ASSIGN): | scalar-int-name
 TYPE_PARSER(construct<Format>(label / !"_."_ch) ||
-    construct<Format>(defaultCharExpr / !"="_tok) || construct<Format>(star))
+    construct<Format>(expr / !"="_tok) || construct<Format>(star))
 
 // R1216 input-item -> variable | io-implied-do
 TYPE_PARSER(construct<InputItem>(variable) ||
diff --git a/lib/Semantics/check-io.cpp b/lib/Semantics/check-io.cpp
index d670c792eb81..0e447bc398ee 100644
--- a/lib/Semantics/check-io.cpp
+++ b/lib/Semantics/check-io.cpp
@@ -195,7 +195,29 @@ void IoChecker::Enter(const parser::Format &spec) {
       common::visitors{
           [&](const parser::Label &) { flags_.set(Flag::LabelFmt); },
           [&](const parser::Star &) { flags_.set(Flag::StarFmt); },
-          [&](const parser::DefaultCharExpr &format) {
+          [&](const parser::Expr &format) {
+            const SomeExpr *expr{GetExpr(format)};
+            if (!expr) {
+              return;
+            }
+            auto type{expr->GetType()};
+            if (!type ||
+                (type->category() != TypeCategory::Integer &&
+                    type->category() != TypeCategory::Character) ||
+                type->kind() !=
+                    context_.defaultKinds().GetDefaultKind(type->category())) {
+              context_.Say(format.source,
+                  "Format expression must be default character or integer"_err_en_US);
+              return;
+            }
+            if (type->category() == TypeCategory::Integer) {
+              flags_.set(Flag::AssignFmt);
+              if (expr->Rank() != 0 || !IsVariable(*expr)) {
+                context_.Say(format.source,
+                    "Assigned format label must be a scalar variable"_err_en_US);
+              }
+              return;
+            }
             flags_.set(Flag::CharFmt);
             const std::optional<std::string> constantFormat{
                 GetConstExpr<std::string>(format)};
@@ -203,11 +225,10 @@ void IoChecker::Enter(const parser::Format &spec) {
               return;
             }
             // validate constant format -- 12.6.2.2
-            bool isFolded{constantFormat->size() !=
-                format.thing.value().source.size() - 2};
+            bool isFolded{constantFormat->size() != format.source.size() - 2};
             parser::CharBlock reporterCharBlock{isFolded
-                    ? parser::CharBlock{format.thing.value().source}
-                    : parser::CharBlock{format.thing.value().source.begin() + 1,
+                    ? parser::CharBlock{format.source}
+                    : parser::CharBlock{format.source.begin() + 1,
                           static_cast<std::size_t>(0)}};
             FormatErrorReporter reporter{context_, reporterCharBlock};
             auto reporterWrapper{
@@ -723,7 +744,8 @@ void IoChecker::LeaveReadWrite() const {
   CheckForProhibitedSpecifier(
       IoSpecKind::Rec, flags_.test(Flag::StarFmt), "FMT=*"); // C1220
   CheckForRequiredSpecifier(IoSpecKind::Advance,
-      flags_.test(Flag::CharFmt) || flags_.test(Flag::LabelFmt),
+      flags_.test(Flag::CharFmt) || flags_.test(Flag::LabelFmt) ||
+          flags_.test(Flag::AssignFmt),
       "an explicit format"); // C1221
   CheckForProhibitedSpecifier(IoSpecKind::Advance,
       flags_.test(Flag::InternalUnit), "UNIT=internal-file"); // C1221
diff --git a/lib/Semantics/check-io.h b/lib/Semantics/check-io.h
index 6763657e623b..b5e8f12b5ee6 100644
--- a/lib/Semantics/check-io.h
+++ b/lib/Semantics/check-io.h
@@ -81,9 +81,9 @@ class IoChecker : public virtual BaseChecker {
 private:
   // Presence flag values.
   ENUM_CLASS(Flag, IoControlList, InternalUnit, NumberUnit, StarUnit, CharFmt,
-      LabelFmt, StarFmt, FmtOrNml, KnownAccess, AccessDirect, AccessStream,
-      AdvanceYes, AsynchronousYes, KnownStatus, StatusNew, StatusReplace,
-      StatusScratch, DataList)
+      LabelFmt, StarFmt, AssignFmt, FmtOrNml, KnownAccess, AccessDirect,
+      AccessStream, AdvanceYes, AsynchronousYes, KnownStatus, StatusNew,
+      StatusReplace, StatusScratch, DataList)
 
   template <typename R, typename T> std::optional<R> GetConstExpr(const T &x) {
     using DefaultCharConstantType =
diff --git a/lib/Semantics/resolve-labels.cpp b/lib/Semantics/resolve-labels.cpp
index 66f86c6c4e51..0c67a079d483 100644
--- a/lib/Semantics/resolve-labels.cpp
+++ b/lib/Semantics/resolve-labels.cpp
@@ -154,16 +154,11 @@ static unsigned SayLabel(parser::Label label) {
 
 struct UnitAnalysis {
   UnitAnalysis() { scopeModel.push_back(0); }
-  UnitAnalysis(UnitAnalysis &&that)
-      : doStmtSources{std::move(that.doStmtSources)},
-        formatStmtSources{std::move(that.formatStmtSources)},
-        otherStmtSources{std::move(that.otherStmtSources)},
-        targetStmts{std::move(that.targetStmts)}, scopeModel{std::move(
-                                                      that.scopeModel)} {}
 
   SourceStmtList doStmtSources;
   SourceStmtList formatStmtSources;
   SourceStmtList otherStmtSources;
+  SourceStmtList assignStmtSources;
   TargetStmtMap targetStmts;
   std::vector<ProxyForScope> scopeModel;
 };
@@ -465,7 +460,7 @@ class ParseTreeAnalyzer {
     AddLabelReference(std::get<3>(arithmeticIfStmt.t));
   }
   void Post(const parser::AssignStmt &assignStmt) {
-    AddLabelReference(std::get<parser::Label>(assignStmt.t));
+    AddLabelReferenceFromAssignStmt(std::get<parser::Label>(assignStmt.t));
   }
   void Post(const parser::AssignedGotoStmt &assignedGotoStmt) {
     AddLabelReference(std::get<std::list<parser::Label>>(assignedGotoStmt.t));
@@ -726,7 +721,7 @@ class ParseTreeAnalyzer {
     if (label < 1 || label > 99999) {
       context_.Say(currentPosition_,
           parser::MessageFormattedText{
-              "label '%u' is out of range"_err_en_US, SayLabel(label)});
+              "Label '%u' is out of range"_err_en_US, SayLabel(label)});
     }
   }
 
@@ -742,7 +737,7 @@ class ParseTreeAnalyzer {
     if (!pair.second) {
       context_.Say(currentPosition_,
           parser::MessageFormattedText{
-              "label '%u' is not distinct"_err_en_US, SayLabel(label)});
+              "Label '%u' is not distinct"_err_en_US, SayLabel(label)});
     }
   }
 
@@ -758,6 +753,12 @@ class ParseTreeAnalyzer {
         label, currentScope_, currentPosition_);
   }
 
+  void AddLabelReferenceFromAssignStmt(parser::Label label) {
+    CheckLabelInRange(label);
+    programUnits_.back().assignStmtSources.emplace_back(
+        label, currentScope_, currentPosition_);
+  }
+
   void AddLabelReference(parser::Label label) {
     CheckLabelInRange(label);
     programUnits_.back().otherStmtSources.emplace_back(
@@ -879,12 +880,12 @@ void CheckLabelDoConstraints(const SourceStmtList &dos,
       // C1133
       context.Say(position,
           parser::MessageFormattedText{
-              "label '%u' cannot be found"_err_en_US, SayLabel(label)});
+              "Label '%u' cannot be found"_err_en_US, SayLabel(label)});
     } else if (doTarget.parserCharBlock.begin() < position.begin()) {
       // R1119
       context.Say(position,
           parser::MessageFormattedText{
-              "label '%u' doesn't lexically follow DO stmt"_err_en_US,
+              "Label '%u' doesn't lexically follow DO stmt"_err_en_US,
               SayLabel(label)});
 
     } else if ((InInclusiveScope(scopes, scope, doTarget.proxyForScope) &&
@@ -905,7 +906,7 @@ void CheckLabelDoConstraints(const SourceStmtList &dos,
     } else if (!InInclusiveScope(scopes, scope, doTarget.proxyForScope)) {
       context.Say(position,
           parser::MessageFormattedText{
-              "label '%u' is not in DO loop scope"_err_en_US, SayLabel(label)});
+              "Label '%u' is not in DO loop scope"_err_en_US, SayLabel(label)});
     } else if (!doTarget.labeledStmtClassificationSet.test(
                    TargetStatementEnum::Do)) {
       context.Say(doTarget.parserCharBlock,
@@ -932,11 +933,11 @@ void CheckScopeConstraints(const SourceStmtList &stmts,
     if (!HasScope(target.proxyForScope)) {
       context.Say(position,
           parser::MessageFormattedText{
-              "label '%u' was not found"_err_en_US, SayLabel(label)});
+              "Label '%u' was not found"_err_en_US, SayLabel(label)});
     } else if (!InInclusiveScope(scopes, scope, target.proxyForScope)) {
       context.Say(position,
           parser::MessageFormattedText{
-              "label '%u' is not in scope"_en_US, SayLabel(label)});
+              "Label '%u' is not in scope"_en_US, SayLabel(label)});
     }
   }
 }
@@ -950,23 +951,24 @@ void CheckBranchTargetConstraints(const SourceStmtList &stmts,
       if (!branchTarget.labeledStmtClassificationSet.test(
               TargetStatementEnum::Branch) &&
           !branchTarget.labeledStmtClassificationSet.test(
-              TargetStatementEnum::CompatibleBranch)) {
+              TargetStatementEnum::CompatibleBranch)) { // error
         context
             .Say(branchTarget.parserCharBlock,
                 parser::MessageFormattedText{
-                    "'%u' not a branch target"_err_en_US, SayLabel(label)})
+                    "Label '%u' is not a branch target"_err_en_US,
+                    SayLabel(label)})
             .Attach(stmt.parserCharBlock,
                 parser::MessageFormattedText{
-                    "control flow use of '%u'"_en_US, SayLabel(label)});
+                    "Control flow use of '%u'"_en_US, SayLabel(label)});
       } else if (!branchTarget.labeledStmtClassificationSet.test(
-                     TargetStatementEnum::Branch)) {
+                     TargetStatementEnum::Branch)) { // warning
         context
             .Say(branchTarget.parserCharBlock,
                 parser::MessageFormattedText{
-                    "'%u' not a branch target"_en_US, SayLabel(label)})
+                    "Label '%u' is not a branch target"_en_US, SayLabel(label)})
             .Attach(stmt.parserCharBlock,
                 parser::MessageFormattedText{
-                    "control flow use of '%u'"_en_US, SayLabel(label)});
+                    "Control flow use of '%u'"_en_US, SayLabel(label)});
       }
     }
   }
@@ -1006,6 +1008,36 @@ void CheckDataTransferConstraints(const SourceStmtList &dataTransfers,
   CheckDataXferTargetConstraints(dataTransfers, labels, context);
 }
 
+void CheckAssignTargetConstraints(const SourceStmtList &stmts,
+    const TargetStmtMap &labels, SemanticsContext &context) {
+  for (const auto &stmt : stmts) {
+    const auto &label{stmt.parserLabel};
+    auto target{GetLabel(labels, label)};
+    if (HasScope(target.proxyForScope) &&
+        !target.labeledStmtClassificationSet.test(
+            TargetStatementEnum::Branch) &&
+        !target.labeledStmtClassificationSet.test(
+            TargetStatementEnum::Format)) {
+      context
+          .Say(target.parserCharBlock,
+              target.labeledStmtClassificationSet.test(
+                  TargetStatementEnum::CompatibleBranch)
+                  ? "Label '%u' is not a branch target or FORMAT"_en_US
+                  : "Label '%u' is not a branch target or FORMAT"_err_en_US,
+              SayLabel(label))
+          .Attach(stmt.parserCharBlock, "ASSIGN statement use of '%u'"_en_US,
+              SayLabel(label));
+    }
+  }
+}
+
+void CheckAssignConstraints(const SourceStmtList &assigns,
+    const TargetStmtMap &labels, const std::vector<ProxyForScope> &scopes,
+    SemanticsContext &context) {
+  CheckScopeConstraints(assigns, labels, scopes, context);
+  CheckAssignTargetConstraints(assigns, labels, context);
+}
+
 bool CheckConstraints(ParseTreeAnalyzer &&parseTreeAnalysis) {
   auto &context{parseTreeAnalysis.ErrorHandler()};
   for (const auto &programUnit : parseTreeAnalysis.ProgramUnits()) {
@@ -1017,6 +1049,8 @@ bool CheckConstraints(ParseTreeAnalyzer &&parseTreeAnalysis) {
     CheckBranchConstraints(branches, labels, scopes, context);
     const auto &dataTransfers{programUnit.formatStmtSources};
     CheckDataTransferConstraints(dataTransfers, labels, scopes, context);
+    const auto &assigns{programUnit.assignStmtSources};
+    CheckAssignConstraints(assigns, labels, scopes, context);
   }
   return !context.AnyFatalError();
 }
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index ee2db0394f16..7828d6906cf6 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -1387,6 +1387,8 @@ class ResolveNamesVisitor : public virtual ScopeHandler,
   bool Pre(const parser::StmtFunctionStmt &);
   bool Pre(const parser::DefinedOpName &);
   bool Pre(const parser::ProgramUnit &);
+  void Post(const parser::AssignStmt &);
+  void Post(const parser::AssignedGotoStmt &);
 
   // These nodes should never be reached: they are handled in ProgramUnit
   bool Pre(const parser::MainProgram &) { DIE("unreachable"); }
@@ -6056,6 +6058,17 @@ bool ResolveNamesVisitor::Pre(const parser::DefinedOpName &x) {
   return false;
 }
 
+void ResolveNamesVisitor::Post(const parser::AssignStmt &x) {
+  if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
+    ConvertToObjectEntity(DEREF(name->symbol));
+  }
+}
+void ResolveNamesVisitor::Post(const parser::AssignedGotoStmt &x) {
+  if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
+    ConvertToObjectEntity(DEREF(name->symbol));
+  }
+}
+
 bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
   auto root{ProgramTree::Build(x)};
   SetScope(context().globalScope());
diff --git a/lib/Semantics/rewrite-parse-tree.cpp b/lib/Semantics/rewrite-parse-tree.cpp
index 046c61e33b36..435bafc73849 100644
--- a/lib/Semantics/rewrite-parse-tree.cpp
+++ b/lib/Semantics/rewrite-parse-tree.cpp
@@ -132,7 +132,7 @@ void RewriteMutator::Post(parser::IoUnit &x) {
 template <typename READ_OR_WRITE>
 void FixMisparsedUntaggedNamelistName(READ_OR_WRITE &x) {
   if (x.iounit && x.format &&
-      std::holds_alternative<parser::DefaultCharExpr>(x.format->u)) {
+      std::holds_alternative<parser::Expr>(x.format->u)) {
     if (const parser::Name * name{parser::Unwrap<parser::Name>(x.format)}) {
       if (name->symbol && name->symbol->GetUltimate().has<NamelistDetails>()) {
         x.controls.emplace_front(parser::IoControlSpec{std::move(*name)});
diff --git a/lib/Semantics/semantics.cpp b/lib/Semantics/semantics.cpp
index 406396b2f776..cfc16149733e 100644
--- a/lib/Semantics/semantics.cpp
+++ b/lib/Semantics/semantics.cpp
@@ -113,25 +113,49 @@ template <typename... C> class SemanticsVisitor : public virtual C... {
   SemanticsContext &context_;
 };
 
-class EntryChecker : public virtual BaseChecker {
+class MiscChecker : public virtual BaseChecker {
 public:
-  explicit EntryChecker(SemanticsContext &context) : context_{context} {}
+  explicit MiscChecker(SemanticsContext &context) : context_{context} {}
   void Leave(const parser::EntryStmt &) {
     if (!context_.constructStack().empty()) { // C1571
       context_.Say("ENTRY may not appear in an executable construct"_err_en_US);
     }
   }
+  void Leave(const parser::AssignStmt &stmt) {
+    CheckAssignGotoName(std::get<parser::Name>(stmt.t));
+  }
+  void Leave(const parser::AssignedGotoStmt &stmt) {
+    CheckAssignGotoName(std::get<parser::Name>(stmt.t));
+  }
 
 private:
+  void CheckAssignGotoName(const parser::Name &name) {
+    if (context_.HasError(name.symbol)) {
+      return;
+    }
+    const Symbol &symbol{DEREF(name.symbol)};
+    auto type{evaluate::DynamicType::From(symbol)};
+    if (!IsVariableName(symbol) || symbol.Rank() != 0 || !type ||
+        type->category() != TypeCategory::Integer ||
+        type->kind() !=
+            context_.defaultKinds().GetDefaultKind(TypeCategory::Integer)) {
+      context_
+          .Say(name.source,
+              "'%s' must be a default integer scalar variable"_err_en_US,
+              name.source)
+          .Attach(symbol.name(), "Declaration of '%s'"_en_US, symbol.name());
+    }
+  }
+
   SemanticsContext &context_;
 };
 
 using StatementSemanticsPass1 = ExprChecker;
 using StatementSemanticsPass2 = SemanticsVisitor<AllocateChecker,
     ArithmeticIfStmtChecker, AssignmentChecker, CaseChecker, CoarrayChecker,
-    DataChecker, DeallocateChecker, DoForallChecker, EntryChecker,
-    IfStmtChecker, IoChecker, NamelistChecker, NullifyChecker,
-    OmpStructureChecker, PurityChecker, ReturnStmtChecker, StopChecker>;
+    DataChecker, DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
+    MiscChecker, NamelistChecker, NullifyChecker, OmpStructureChecker,
+    PurityChecker, ReturnStmtChecker, StopChecker>;
 
 static bool PerformStatementSemantics(
     SemanticsContext &context, parser::Program &program) {
diff --git a/test/Semantics/assign06.f90 b/test/Semantics/assign06.f90
new file mode 100644
index 000000000000..33b7f703b08d
--- /dev/null
+++ b/test/Semantics/assign06.f90
@@ -0,0 +1,47 @@
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! Test ASSIGN statement, assigned GOTO, and assigned format labels
+! (see subclause 8.2.4 in Fortran 90 (*not* 2018!)
+
+program main
+  call test(0)
+ contains
+  subroutine test(n)
+    integer, intent(in) :: n
+    integer :: lab
+    integer(kind=1) :: badlab1
+    real :: badlab2
+    integer :: badlab3(1)
+    assign 1 to lab ! ok
+    assign 1 to implicitlab1 ! ok
+    !ERROR: 'badlab1' must be a default integer scalar variable
+    assign 1 to badlab1
+    !ERROR: 'badlab2' must be a default integer scalar variable
+    assign 1 to badlab2
+    !ERROR: 'badlab3' must be a default integer scalar variable
+    assign 1 to badlab3
+    !ERROR: 'test' must be a default integer scalar variable
+    assign 1 to test
+    if (n==1) goto lab ! ok
+    if (n==1) goto implicitlab2 ! ok
+    !ERROR: 'badlab1' must be a default integer scalar variable
+    if (n==1) goto badlab1
+    !ERROR: 'badlab2' must be a default integer scalar variable
+    if (n==1) goto badlab2
+    !ERROR: 'badlab3' must be a default integer scalar variable
+    if (n==1) goto badlab3
+    if (n==1) goto lab(1) ! ok
+    if (n==1) goto lab,(1) ! ok
+    if (n==1) goto lab(1,1) ! ok
+    assign 3 to lab ! ok
+    write(*,fmt=lab) ! ok
+    write(*,fmt=implicitlab3) ! ok
+    !ERROR: Format expression must be default character or integer
+    write(*,fmt=badlab1)
+    !ERROR: Format expression must be default character or integer
+    write(*,fmt=badlab2)
+    !ERROR: Format expression must be default character or integer
+    write(*,fmt=badlab2)
+1   continue
+3   format('yes')
+  end subroutine test
+end program
diff --git a/test/Semantics/assign07.f90 b/test/Semantics/assign07.f90
new file mode 100644
index 000000000000..9d62da5df1b1
--- /dev/null
+++ b/test/Semantics/assign07.f90
@@ -0,0 +1,35 @@
+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! Test ASSIGN statement, assigned GOTO, and assigned format labels
+! (see subclause 8.2.4 in Fortran 90 (*not* 2018!)
+
+program main
+  call test(0)
+2 format('no')
+ contains
+  subroutine test(n)
+    !ERROR: Label '4' is not a branch target or FORMAT
+4   integer, intent(in) :: n
+    integer :: lab
+    assign 1 to lab ! ok
+    assign 1 to implicitlab1 ! ok
+    !ERROR: Label '666' was not found
+    assign 666 to lab
+    !ERROR: Label '2' was not found
+    assign 2 to lab
+    assign 4 to lab
+    if (n==1) goto lab ! ok
+    if (n==1) goto implicitlab2 ! ok
+    if (n==1) goto lab(1) ! ok
+    if (n==1) goto lab,(1) ! ok
+    if (n==1) goto lab(1,1) ! ok
+    !ERROR: Label '666' was not found
+    if (n==1) goto lab(1,666)
+    !ERROR: Label '2' was not found
+    if (n==1) goto lab(1,2)
+    assign 3 to lab
+    write(*,fmt=lab) ! ok
+    write(*,fmt=implicitlab3) ! ok
+1   continue
+3   format('yes')
+  end subroutine test
+end program
diff --git a/test/Semantics/if_arith03.f90 b/test/Semantics/if_arith03.f90
index 45ceec4e4e54..a9a3e5010b02 100644
--- a/test/Semantics/if_arith03.f90
+++ b/test/Semantics/if_arith03.f90
@@ -1,19 +1,19 @@
 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 
 
-!ERROR: label '600' was not found
+!ERROR: Label '600' was not found
 if ( A ) 100, 200, 600
 100 CONTINUE
 200 CONTINUE
 300 CONTINUE
 
-!ERROR: label '601' was not found
+!ERROR: Label '601' was not found
 if ( A ) 101, 601, 301
 101 CONTINUE
 201 CONTINUE
 301 CONTINUE
 
-!ERROR: label '602' was not found
+!ERROR: Label '602' was not found
 if ( A ) 602, 202, 302
 102 CONTINUE
 202 CONTINUE
diff --git a/test/Semantics/label02.f90 b/test/Semantics/label02.f90
index 6aa052d52d66..e98868106f1d 100644
--- a/test/Semantics/label02.f90
+++ b/test/Semantics/label02.f90
@@ -2,11 +2,11 @@
 ! negative test -- invalid labels, out of range
 
 ! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
-! CHECK: label '0' is out of range
-! CHECK: label '100000' is out of range
-! CHECK: label '123456' is out of range
-! CHECK: label '123456' was not found
-! CHECK: label '1000' is not distinct
+! CHECK: Label '0' is out of range
+! CHECK: Label '100000' is out of range
+! CHECK: Label '123456' is out of range
+! CHECK: Label '123456' was not found
+! CHECK: Label '1000' is not distinct
 
 subroutine sub00(a,b,n,m)
   real a(n)
diff --git a/test/Semantics/label03.f90 b/test/Semantics/label03.f90
index a33b2f33a9b3..557bb00054b3 100644
--- a/test/Semantics/label03.f90
+++ b/test/Semantics/label03.f90
@@ -4,9 +4,9 @@
 ! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
 ! CHECK: DO loop doesn't properly nest
 ! CHECK: DO loop conflicts
-! CHECK: label '30' cannot be found
-! CHECK: label '40' cannot be found
-! CHECK: label '50' doesn't lexically follow DO stmt
+! CHECK: Label '30' cannot be found
+! CHECK: Label '40' cannot be found
+! CHECK: Label '50' doesn't lexically follow DO stmt
 
 subroutine sub00(a,b,n,m)
   real a(n,m)
diff --git a/test/Semantics/label05.f90 b/test/Semantics/label05.f90
index 09bd9fa2b0f0..94765fbee0e5 100644
--- a/test/Semantics/label05.f90
+++ b/test/Semantics/label05.f90
@@ -2,10 +2,10 @@
 ! negative test -- invalid labels, out of range
 
 ! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
-! CHECK: label '50' was not found
-! CHECK: label '55' is not in scope
-! CHECK: '70' not a branch target
-! CHECK: control flow use of '70'
+! CHECK: Label '50' was not found
+! CHECK: Label '55' is not in scope
+! CHECK: Label '70' is not a branch target
+! CHECK: Control flow use of '70'
 
 subroutine sub00(a,b,n,m)
   real a(n,m)
diff --git a/test/Semantics/label06.f90 b/test/Semantics/label06.f90
index 4e633d3df552..34dc4362941c 100644
--- a/test/Semantics/label06.f90
+++ b/test/Semantics/label06.f90
@@ -2,12 +2,12 @@
 ! negative test -- invalid labels, out of range
 
 ! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
-! CHECK: label '10' is not in scope
-! CHECK: label '20' was not found
-! CHECK: '30' not a branch target
-! CHECK: control flow use of '30'
-! CHECK: label '40' is not in scope
-! CHECK: label '50' is not in scope
+! CHECK: Label '10' is not in scope
+! CHECK: Label '20' was not found
+! CHECK: Label '30' is not a branch target
+! CHECK: Control flow use of '30'
+! CHECK: Label '40' is not in scope
+! CHECK: Label '50' is not in scope
 
 subroutine sub00(n)
   GOTO (10,20,30) n
diff --git a/test/Semantics/label07.f90 b/test/Semantics/label07.f90
index 62755082e030..f1d440a045ea 100644
--- a/test/Semantics/label07.f90
+++ b/test/Semantics/label07.f90
@@ -2,11 +2,11 @@
 ! negative test -- invalid labels, out of range
 
 ! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
-! CHECK: '30' not a branch target
-! CHECK: control flow use of '30'
-! CHECK: label '10' is not in scope
-! CHECK: label '20' was not found
-! CHECK: label '60' was not found
+! CHECK: Label '30' is not a branch target
+! CHECK: Control flow use of '30'
+! CHECK: Label '10' is not in scope
+! CHECK: Label '20' was not found
+! CHECK: Label '60' was not found
 
 subroutine sub00(n,m)
 30 format (i6,f6.2)
diff --git a/test/Semantics/label09.f90 b/test/Semantics/label09.f90
index a74263d58315..d7e5ae304fce 100644
--- a/test/Semantics/label09.f90
+++ b/test/Semantics/label09.f90
@@ -1,6 +1,6 @@
 ! RUN: %S/test_any.sh %s %flang %t
 ! EXEC: ${F18} -funparse-with-symbols %s 2>&1 | ${FileCheck} %s
-! CHECK: label '60' was not found
+! CHECK: Label '60' was not found
 
 subroutine s(a)
   real a(10)
diff --git a/test/Semantics/label14.f90 b/test/Semantics/label14.f90
index e6eb744f50e3..b16366819d8e 100644
--- a/test/Semantics/label14.f90
+++ b/test/Semantics/label14.f90
@@ -4,7 +4,7 @@
 !            Block Construct
 
 ! EXEC: ${F18} %s 2>&1 | ${FileCheck} %s
-! CHECK: label '20' is not in scope
+! CHECK: Label '20' is not in scope
 
 subroutine s1
   block

From 8a2343dfffc9ccb04bdfe4c16ca47128255d47bd Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Fri, 3 Apr 2020 17:28:23 -0700
Subject: [PATCH 112/345] Add message formatting for std::int64_t

There is no printf formatting string for std::int64_t. Instead we have
to cast to std::intmax_t and use `%jd`. This change simplifies that by
automatically converting std::int64_t to std::intmax_t when formatting
messages.
---
 include/flang/Parser/message.h     | 1 +
 lib/Evaluate/fold-implementation.h | 2 +-
 lib/Evaluate/fold-integer.cpp      | 6 +++---
 lib/Evaluate/shape.cpp             | 3 +--
 lib/Evaluate/variable.cpp          | 6 ++----
 lib/Semantics/assignment.cpp       | 2 +-
 lib/Semantics/check-io.cpp         | 2 +-
 lib/Semantics/resolve-names.cpp    | 3 +--
 lib/Semantics/symbol.cpp           | 2 +-
 9 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/include/flang/Parser/message.h b/include/flang/Parser/message.h
index bc2eed0dedc7..784989ebdd83 100644
--- a/include/flang/Parser/message.h
+++ b/include/flang/Parser/message.h
@@ -100,6 +100,7 @@ class MessageFormattedText {
   const char *Convert(std::string &);
   const char *Convert(std::string &&);
   const char *Convert(CharBlock);
+  std::intmax_t Convert(std::int64_t x) { return x; }
 
   bool isFatal_{false};
   std::string string_;
diff --git a/lib/Evaluate/fold-implementation.h b/lib/Evaluate/fold-implementation.h
index 44f0093a3bdb..3b1a314eb288 100644
--- a/lib/Evaluate/fold-implementation.h
+++ b/lib/Evaluate/fold-implementation.h
@@ -275,7 +275,7 @@ std::optional<Constant<T>> Folder<T>::ApplySubscripts(const Constant<T> &array,
       if (at[j] < lbounds[j] || at[j] >= lbounds[j] + shape[j]) {
         context_.messages().Say(
             "Subscript value (%jd) is out of range on dimension %d in reference to a constant array value"_err_en_US,
-            static_cast<std::intmax_t>(at[j]), j + 1);
+            at[j], j + 1);
         return std::nullopt;
       }
     }
diff --git a/lib/Evaluate/fold-integer.cpp b/lib/Evaluate/fold-integer.cpp
index 6d159eda93e3..fa4c8b08218a 100644
--- a/lib/Evaluate/fold-integer.cpp
+++ b/lib/Evaluate/fold-integer.cpp
@@ -24,7 +24,7 @@ Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
           if (*dim64 < 1 || *dim64 > rank) {
             context.messages().Say("DIM=%jd dimension is out of range for "
                                    "rank-%d array"_en_US,
-                static_cast<std::intmax_t>(*dim64), rank);
+                *dim64, rank);
             return MakeInvalidIntrinsic<T>(std::move(funcRef));
           } else {
             dim = *dim64 - 1; // 1-based to 0-based
@@ -79,7 +79,7 @@ Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
           if (*dim64 < 1 || *dim64 > rank) {
             context.messages().Say("DIM=%jd dimension is out of range for "
                                    "rank-%d array"_en_US,
-                static_cast<std::intmax_t>(*dim64), rank);
+                *dim64, rank);
             return MakeInvalidIntrinsic<T>(std::move(funcRef));
           } else {
             dim = *dim64 - 1; // 1-based to 0-based
@@ -572,7 +572,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
           } else {
             context.messages().Say(
                 "size(array,dim=%jd) dimension is out of range for rank-%d array"_en_US,
-                static_cast<std::intmax_t>(*dim), static_cast<int>(rank));
+                *dim, rank);
           }
         }
       } else if (auto extents{common::AllElementsPresent(std::move(*shape))}) {
diff --git a/lib/Evaluate/shape.cpp b/lib/Evaluate/shape.cpp
index 7d33a8b0594c..9cf684b699a1 100644
--- a/lib/Evaluate/shape.cpp
+++ b/lib/Evaluate/shape.cpp
@@ -642,8 +642,7 @@ bool CheckConformance(parser::ContextualMessages &messages, const Shape &left,
             if (*leftDim != *rightDim) {
               messages.Say("Dimension %1$d of %2$s has extent %3$jd, "
                            "but %4$s has extent %5$jd"_err_en_US,
-                  j + 1, leftIs, static_cast<std::intmax_t>(*leftDim), rightIs,
-                  static_cast<std::intmax_t>(*rightDim));
+                  j + 1, leftIs, *leftDim, rightIs, *rightDim);
               return false;
             }
           }
diff --git a/lib/Evaluate/variable.cpp b/lib/Evaluate/variable.cpp
index 3ebd68a4543b..36bfee2c1f91 100644
--- a/lib/Evaluate/variable.cpp
+++ b/lib/Evaluate/variable.cpp
@@ -168,8 +168,7 @@ std::optional<Expr<SomeCharacter>> Substring::Fold(FoldingContext &context) {
   std::optional<ConstantSubscript> lbi{ToInt64(lower_.value().value())};
   if (lbi && *lbi < 1) {
     context.messages().Say(
-        "Lower bound (%jd) on substring is less than one"_en_US,
-        static_cast<std::intmax_t>(*lbi));
+        "Lower bound (%jd) on substring is less than one"_en_US, *lbi);
     *lbi = 1;
     lower_ = AsExpr(Constant<SubscriptInteger>{1});
   }
@@ -200,8 +199,7 @@ std::optional<Expr<SomeCharacter>> Substring::Fold(FoldingContext &context) {
     } else if (length && *ubi > *length) {
       context.messages().Say("Upper bound (%jd) on substring is greater "
                              "than character length (%jd)"_en_US,
-          static_cast<std::intmax_t>(*ubi),
-          static_cast<std::intmax_t>(*length));
+          *ubi, *length);
       *ubi = *length;
     }
     if (lbi && literal) {
diff --git a/lib/Semantics/assignment.cpp b/lib/Semantics/assignment.cpp
index 3e74f86b23e9..657e618c1d7e 100644
--- a/lib/Semantics/assignment.cpp
+++ b/lib/Semantics/assignment.cpp
@@ -242,7 +242,7 @@ void AssignmentContext::CheckShape(parser::CharBlock at, const SomeExpr *expr) {
           Say(at,
               "Dimension %d must have extent %jd to match prior mask or"
               " assignment of WHERE construct"_err_en_US,
-              i + 1, static_cast<std::intmax_t>(*whereExtents_[i]));
+              i + 1, *whereExtents_[i]);
         }
       }
     }
diff --git a/lib/Semantics/check-io.cpp b/lib/Semantics/check-io.cpp
index d670c792eb81..a2a76584b914 100644
--- a/lib/Semantics/check-io.cpp
+++ b/lib/Semantics/check-io.cpp
@@ -166,7 +166,7 @@ void IoChecker::Enter(const parser::ConnectSpec::Recl &spec) {
     if (*recl <= 0) {
       context_.Say(parser::FindSourceLocation(spec),
           "RECL value (%jd) must be positive"_err_en_US,
-          std::move(static_cast<std::intmax_t>(*recl))); // 12.5.6.15
+          *recl); // 12.5.6.15
     }
   }
 }
diff --git a/lib/Semantics/resolve-names.cpp b/lib/Semantics/resolve-names.cpp
index ee2db0394f16..be5ed2e46700 100644
--- a/lib/Semantics/resolve-names.cpp
+++ b/lib/Semantics/resolve-names.cpp
@@ -3508,8 +3508,7 @@ void DeclarationVisitor::Post(const parser::CharSelector::LengthAndKind &x) {
       !evaluate::IsValidKindOfIntrinsicType(
           TypeCategory::Character, *intKind)) { // C715, C719
     Say(currStmtSource().value(),
-        "KIND value (%jd) not valid for CHARACTER"_err_en_US,
-        static_cast<std::intmax_t>(*intKind));
+        "KIND value (%jd) not valid for CHARACTER"_err_en_US, *intKind);
   }
   if (x.length) {
     charInfo_.length = GetParamValue(*x.length, common::TypeParamAttr::Len);
diff --git a/lib/Semantics/symbol.cpp b/lib/Semantics/symbol.cpp
index e48b7b950a6d..c80b669d8ec6 100644
--- a/lib/Semantics/symbol.cpp
+++ b/lib/Semantics/symbol.cpp
@@ -571,7 +571,7 @@ static const DeclTypeSpec &InstantiateIntrinsicType(Scope &scope,
       foldingContext.messages().Say(
           "KIND parameter value (%jd) of intrinsic type %s "
           "did not resolve to a supported value"_err_en_US,
-          static_cast<std::intmax_t>(*value),
+          *value,
           parser::ToUpperCaseLetters(
               common::EnumToString(intrinsic.category())));
     }

From 3749b463dc6d4e2847c272bf2f6b575478391a2a Mon Sep 17 00:00:00 2001
From: Caroline Concatto <caroline.concatto@arm.com>
Date: Tue, 24 Mar 2020 09:09:06 +0000
Subject: [PATCH 113/345] Adjust supported compilers statement in F18 readme

This patch is an update of the readme according to compilations done and
also information given in flang dev mailing list.
[F18] Which compilers configurations f18 have being tested/built?

Signed-off-by: Caroline Concatto <caroline.concatto@arm.com>
---
 README.md | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index d8e2cbdef63b..321c9d63fa5b 100644
--- a/README.md
+++ b/README.md
@@ -53,15 +53,23 @@ git clone https://github.com/flang-compiler/f18.git
 
 ### Supported C++ compilers
 
-F18 is written in C++17.
+F18 is written in C++17 and it has LLVM libraries dependency.
 
 The code has been compiled and tested with
-GCC versions 7.2.0, 7.3.0, 8.1.0, and 8.2.0.
+GCC versions from 7.2.0 to 9.3.0.
 
 The code has been compiled and tested with
-clang version 7.0 and 8.0
+clang version 7.0, 8.0, 9.0 and 10.0
 using either GNU's libstdc++ or LLVM's libc++.
 
+The code has been compiled on
+AArch64, x86_64 and ppc64le servers
+with CentOS7, Ubuntu18.04, Rhel, MacOs, Mojave, XCode and
+Apple LLVM version 10.0.1.
+
+The code does not compile with Windows and
+a compiler that does not have support for C++17.
+
 ### LLVM dependency
 
 F18 uses components from LLVM.

From 92a1ef6810f02b65b5fafcde2130b1482d373995 Mon Sep 17 00:00:00 2001
From: Tim Keith <tkeith@nvidia.com>
Date: Mon, 6 Apr 2020 10:06:34 -0700
Subject: [PATCH 114/345] Convert std::uint64_t to std::uintmax_t as well

---
 include/flang/Parser/message.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/flang/Parser/message.h b/include/flang/Parser/message.h
index 784989ebdd83..84106dbc3bfc 100644
--- a/include/flang/Parser/message.h
+++ b/include/flang/Parser/message.h
@@ -101,6 +101,7 @@ class MessageFormattedText {
   const char *Convert(std::string &&);
   const char *Convert(CharBlock);
   std::intmax_t Convert(std::int64_t x) { return x; }
+  std::uintmax_t Convert(std::uint64_t x) { return x; }
 
   bool isFatal_{false};
   std::string string_;

From 7f447526a81cf83512da2b7376a3b840669a91b0 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Thu, 2 Apr 2020 18:44:35 -0700
Subject: [PATCH 115/345] [shim] applied anti-patches to CMakeLists.txt and
 README.md files to ease the rebasing of mono. CMakeLists.txt is almost
 unrecognizable and we'll have to figure out how to drop it on mono on the tip
 of the branch.

---
 CMakeLists.txt | 452 +++++++++++++------------------------------------
 README.md      |  25 +++
 2 files changed, 145 insertions(+), 332 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index dceeeb16f25a..8883fb7e7597 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,144 +1,97 @@
-cmake_minimum_required(VERSION 3.9.0)
-
-# RPATH settings on macOS do not affect INSTALL_NAME.
-if (POLICY CMP0068)
-  cmake_policy(SET CMP0068 NEW)
-  set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
-endif()
+#===-- CMakeLists.txt ------------------------------------------------------===#
+#
+# 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 file check macros honor CMAKE_REQUIRED_LIBRARIES.
-if(POLICY CMP0075)
-  cmake_policy(SET CMP0075 NEW)
-endif()
-
-# option() honors normal variables.
-if (POLICY CMP0077)
-  cmake_policy(SET CMP0077 NEW)
-endif()
+cmake_minimum_required(VERSION 3.9.0)
 
 option(LINK_WITH_FIR "Link driver with FIR and LLVM" ON)
 
-# Flang requires C++17.
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-
-if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
-  message(FATAL_ERROR "In-source builds are not allowed. \
-          Please create a directory and run cmake from there,\
-          passing the path to this source directory as the last argument.\
-          This process created the file `CMakeCache.txt' and the directory\
-          `CMakeFiles'. Please delete them.")
-endif()
-
-# Add Flang-centric modules to cmake path.
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
-include(AddFlang)
-
-# Check for a standalone build and configure as appropriate from
-# there.
-if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-message("Building Flang as a standalone project.")
-project(Flang)
-
-  set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
-  if (NOT MSVC_IDE)
-    set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
-      CACHE BOOL "Enable assertions")
-    # Assertions follow llvm's configuration.
-    mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
+# Pass -DGCC=... to cmake to use a specific gcc installation.
+if( GCC )
+  set(CMAKE_CXX_COMPILER "${GCC}/bin/g++")
+  set(CMAKE_CC_COMPILER "${GCC}/bin/gcc")
+  set(CMAKE_BUILD_RPATH "${GCC}/lib64")
+  set(CMAKE_INSTALL_RPATH "${GCC}/lib64")
+endif()
+if(BUILD_WITH_CLANG)
+  file(TO_CMAKE_PATH "${BUILD_WITH_CLANG}" CLANG_PATH)
+  set(CMAKE_CXX_COMPILER "${CLANG_PATH}/bin/clang++")
+  set(CMAKE_CC_COMPILER "${CLANG_PATH}/bin/clang")
+  if(GCC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
   endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wstring-conversion")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcovered-switch-default")
+endif()
 
-  # We need a pre-built/installed version of LLVM.
-  find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
-  list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
+# Set RPATH in every executable, overriding the default setting.
+# If you set this first variable back to true (the default),
+# also set the second one.
+set(CMAKE_SKIP_BUILD_RPATH false)
+set(CMAKE_BUILD_WITH_INSTALL_RPATH false)
 
-  # If LLVM links to zlib we need the imported targets so we can too.
-  if(LLVM_ENABLE_ZLIB)
-    find_package(ZLIB REQUIRED)
-  endif()
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib" "${CMAKE_INSTALL_RPATH}")
 
-  include(CMakeParseArguments)
-  include(AddLLVM)
-  include(HandleLLVMOptions)
-  include(VersionFromVCS)
+# Reminder: Setting CMAKE_CXX_COMPILER must be done before calling project()
 
-  if(LINK_WITH_FIR)
-    include(TableGen)
-    find_package(MLIR REQUIRED CONFIG)
-    # Use SYSTEM for the same reasons as for LLVM includes
-    include_directories(SYSTEM ${MLIR_INCLUDE_DIRS})
-    list(APPEND CMAKE_MODULE_PATH ${MLIR_DIR})
-    include(AddMLIR)
-    find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
-      NO_DEFAULT_PATH)
-  endif()
+project(f18 CXX)
 
-  option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
-  option(LLVM_INSTALL_TOOLCHAIN_ONLY
-    "Only include toolchain files in the 'install' target." OFF)
-  option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
-    "Set to ON to force using an old, unsupported host toolchain." OFF)
+if( NOT CMAKE_BUILD_TYPE )
+  set( CMAKE_BUILD_TYPE Debug )
+endif()
 
+message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}" )
 
-  # Add LLVM include files as if they were SYSTEM because there are complex unused
-  # parameter issues that may or may not appear depending on the environments and
-  # compilers (ifdefs are involved). This allows warnings from LLVM headers to be
-  # ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
-  # This may have to be fine-tuned if flang headers are consider part of this
-  # LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
-  # should not be suppressed).
-  include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
-  add_definitions(${LLVM_DEFINITIONS})
+find_package(LLVM REQUIRED CONFIG)
+message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION} in ${LLVM_DIR}")
+# If LLVM links to zlib we need the imported targets so we can too.
+if(LLVM_ENABLE_ZLIB)
+  find_package(ZLIB REQUIRED)
+endif()
 
-  # LLVM's cmake configuration files currently sneak in a c++11 flag.
-  # We look for it here and remove it from Flang's compile flags to
-  # avoid some mixed compilation flangs (e.g. -std=c++11 ... -std=c++17).
-  if (DEFINED LLVM_CXX_STD)
-    message("LLVM configuration set a C++ standard: ${LLVM_CXX_STD}")
-    if (NOT LLVM_CXX_STD EQUAL "c++17")
-      message("Flang: Overriding LLVM's 'cxx_std' setting...")
-      message("    removing '-std=${LLVM_CXX_STD}'")
-      message("    CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
-      string(REPLACE " -std=${LLVM_CXX_STD}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-      message("    [NEW] CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
-    endif()
-  endif()
+list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
 
-  link_directories("${LLVM_LIBRARY_DIR}")
+include(AddLLVM)
 
-  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
-    ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
-  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
-    ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
+# Get names for the LLVM libraries
+#
+# The full list of LLVM components can be obtained with
+#
+#   llvm-config --components
+#
+# Similarly, the (static) libraries corresponding to some
+# components (default is 'all') can be obtained with
+#
+#   llvm-config --libs --link-static [component ...]
+#
+# See also
+#  http://llvm.org/docs/CMake.html#embedding-llvm-in-your-project
+#  https://stackoverflow.com/questions/41924375/llvm-how-to-specify-all-link-libraries-as-input-to-llvm-map-components-to-libna
+#  https://stackoverflow.com/questions/33948633/how-do-i-link-when-building-with-llvm-libraries
 
-  set(BACKEND_PACKAGE_STRING "LLVM ${LLVM_PACKAGE_VERSION}")
-  set(LLVM_EXTERNAL_LIT "${LLVM_TOOLS_BINARY_DIR}/llvm-lit" CACHE STRING "Command used to spawn lit")
+# Add LLVM include files as if they were SYSTEM because there are complex unused
+# parameter issues that may or may not appear depending on the environments and
+# compilers (ifdefs are involved). This allows warnings from LLVM headers to be
+# ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
+# This may have to be fine-tuned if flang headers are consider part of this
+# LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
+# should not be suppressed).
+include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
+add_definitions(${LLVM_DEFINITIONS})
 
-  option(FLANG_INCLUDE_TESTS
-         "Generate build targets for the Flang unit tests."
-         ON)
-  add_custom_target(check-all DEPENDS check-flang)
-else()
-  option(FLANG_INCLUDE_TESTS
-         "Generate build targets for the Flang unit tests."
-         ${LLVM_INCLUDE_TESTS})
-  set(FLANG_BINARY_DIR ${CMAKE_BINARY_DIR}/tools/flang)
-  set(BACKEND_PACKAGE_STRING "${PACKAGE_STRING}")
-  if (LINK_WITH_FIR)
-    set(MLIR_MAIN_SRC_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --src-root
-    set(MLIR_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --includedir
-    set(MLIR_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/mlir/include)
-    set(MLIR_TABLEGEN_EXE $<TARGET_FILE:mlir-tblgen>)
-    include_directories(SYSTEM ${MLIR_INCLUDE_DIR})
-    include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR})
-  endif()
-endif()
+# LLVM_LIT_EXTERNAL store in cache so it could be used by AddLLVM.cmake
+set(LLVM_EXTERNAL_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit CACHE STRING "Command used to spawn lit")
 
 if(LINK_WITH_FIR)
+  include(TableGen)
+  include(AddMLIR)
+  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
+  NO_DEFAULT_PATH)
   # tco tool and FIR lib output directories
   set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
   set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
@@ -149,227 +102,62 @@ if(LINK_WITH_FIR)
   message(STATUS "LLVM libraries: ${LLVM_COMMON_LIBS}")
 endif()
 
-# Add Flang-centric modules to cmake path.
-include_directories(BEFORE
-  ${FLANG_BINARY_DIR}/include
-  ${FLANG_SOURCE_DIR}/include)
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
-
-if (NOT DEFAULT_SYSROOT)
-  set(DEFAULT_SYSROOT "" CACHE PATH
-    "The <path> to use for the system root for all compiler invocations (--sysroot=<path>).")
-endif()
-
-if (NOT ENABLE_LINKER_BUILD_ID)
-  set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
+if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+      if(BUILD_WITH_CLANG_LIBRARIES)
+         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc++ -I${BUILD_WITH_CLANG_LIBRARIES}/include/c++/v1 -DCLANG_LIBRARIES")
+         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -Wl,-rpath,${BUILD_WITH_CLANG_LIBRARIES}/lib -L${BUILD_WITH_CLANG_LIBRARIES}/lib")
+      else()
+         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lstdc++")
+      endif()
+      if(GCC)
+         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
+      endif()
+   endif()
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall -Wextra -Werror")
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcast-qual")
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wimplicit-fallthrough")
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdelete-non-virtual-dtor")
+   set(CMAKE_CXX_FLAGS_RELEASE    "-O2")
+   set(CMAKE_CXX_FLAGS_MINSIZEREL "-O2 '-DCHECK=(void)'")
+   set(CMAKE_CXX_FLAGS_DEBUG      "-g -DDEBUGF18")
+
+   # Building shared libraries is death on performance with GCC by default
+   # due to the need to preserve the right to override external entry points
+   # at dynamic link time.  -fno-semantic-interposition waives that right and
+   # recovers a little bit of that performance.
+   if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
+   endif()
 endif()
 
-set(FLANG_DEFAULT_LINKER "" CACHE STRING
-  "Default linker to use (linker name or absolute path, empty for platform default)")
-
-set(FLANG_DEFAULT_RTLIB "" CACHE STRING
-   "Default Fortran runtime library to use (\"libFortranRuntime\"), leave empty for platform default.")
-
-if (NOT(FLANG_DEFAULT_RTLIB STREQUAL ""))
-  message(WARNING "Resetting Flang's default runtime library to use platform default.")
-  set(FLANG_DEFAULT_RTLIB "" CACHE STRING
-      "Default runtime library to use (empty for platform default)" FORCE)
-endif()
-
-
-
-set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
-# Override LLVM versioning for now...
 set(FLANG_VERSION_MAJOR      "0")
 set(FLANG_VERSION_MINOR      "1")
 set(FLANG_VERSION_PATCHLEVEL "0")
-
-
-if (NOT DEFINED FLANG_VERSION_MAJOR)
-  set(FLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
-endif()
-
-if (NOT DEFINED FLANG_VERSION_MINOR)
-  set(FLANG_VERSION_MINOR ${LLVM_VERSION_MINOR})
-endif()
-
-if (NOT DEFINED FLANG_VERSION_PATCHLEVEL)
-  set(FLANG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
-endif()
-
-# Unlike PACKAGE_VERSION, FLANG_VERSION does not include LLVM_VERSION_SUFFIX.
 set(FLANG_VERSION "${FLANG_VERSION_MAJOR}.${FLANG_VERSION_MINOR}.${FLANG_VERSION_PATCHLEVEL}")
-message(STATUS "Flang version: ${FLANG_VERSION}")
-# Flang executable version information
-set(FLANG_EXECUTABLE_VERSION
-    "${FLANG_VERSION_MAJOR}" CACHE STRING
-    "Major version number to appended to the flang executable name.")
-set(LIBFLANG_LIBRARY_VERSION
-    "${FLANG_VERSION_MAJOR}" CACHE STRING
-    "Major version number to appended to the libflang library.")
+message(STATUS "FLANG version: ${FLANG_VERSION}")
 
-mark_as_advanced(FLANG_EXECUTABLE_VERSION LIBFLANG_LIBRARY_VERSION)
+set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
 
-set(FLANG_VENDOR ${PACKAGE_VENDOR} CACHE STRING
-  "Vendor-specific Flang version information.")
-set(FLANG_VENDOR_UTI "org.llvm.flang" CACHE STRING
-  "Vendor-specific uti.")
+include_directories(BEFORE
+  ${FLANG_BINARY_DIR}/include
+  ${FLANG_SOURCE_DIR}/include
+  )
 
-if (FLANG_VENDOR)
-  add_definitions(-DFLANG_VENDOR="${FLANG_VENDOR} ")
-endif()
+enable_testing()
 
-set(FLANG_REPOSITORY_STRING "" CACHE STRING
-  "Vendor-specific text for showing the repository the source is taken from.")
-if (FLANG_REPOSITORY_STRING)
-  add_definitions(-DFLANG_REPOSITORY_STRING="${FLANG_REPOSITORY_STRING}")
-endif()
+add_subdirectory(include/flang)
+add_subdirectory(lib)
+add_subdirectory(runtime)
+add_subdirectory(unittests)
+add_subdirectory(tools)
+add_subdirectory(test)
 
-# Configure Flang's Version.inc file.
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/include/flang/Version.inc.in
-  ${CMAKE_CURRENT_BINARY_DIR}/include/flang/Version.inc)
-# Configure Flang's version info header file.
 configure_file(
   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
   ${FLANG_BINARY_DIR}/include/flang/Config/config.h)
-
-# Add global F18 flags.
-set(CMAKE_CXX_FLAGS "-fno-rtti -fno-exceptions -pedantic -Wall -Wextra -Werror -Wcast-qual -Wimplicit-fallthrough -Wdelete-non-virtual-dtor ${CMAKE_CXX_FLAGS}")
-
-# Builtin check_cxx_compiler_flag doesn't seem to work correctly
-macro(check_compiler_flag flag resultVar)
-  unset(${resultVar} CACHE)
-  check_cxx_compiler_flag("${flag}" ${resultVar})
-endmacro()
-
-check_compiler_flag("-Werror -Wno-deprecated-copy" CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
-if (CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy")
-endif()
-check_compiler_flag("-Wstring-conversion" CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
-if (CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
-endif()
-
-# Add appropriate flags for GCC
-if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
-
-  if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -fno-semantic-interposition")
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument -Wstring-conversion \
-          -Wcovered-switch-default")
-  endif()  # Clang.
-
-  check_cxx_compiler_flag("-Werror -Wnested-anon-types" CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
-  if (CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types")
-  endif()
-
-  # Add to or adjust build type flags.
-  #
-  # TODO: This needs some extra thought.  CMake's default for release builds
-  # is -O3, which can cause build failures on certain platforms (and compilers)
-  # with the current code base -- some templated functions are inlined and don't
-  # become available at link time when using -O3 (with Clang under MacOS/darwin).
-  # If we reset CMake's default flags we also clobber any user provided settings;
-  # make it difficult to customize a build in this regard...   The setup below
-  # has this side effect but enables successful builds across multiple platforms
-  # in release mode...
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGF18")
-  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DCHECK=\"(void)\"")  # do we need -O2 here?
-  set(CMAKE_CXX_FLAGS_RELEASE "-O2")
-
-  # Building shared libraries is bad for performance with GCC by default
-  # due to the need to preserve the right to override external entry points
-  if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-   set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
-  endif()
-
-endif()
-
-list(REMOVE_DUPLICATES CMAKE_CXX_FLAGS)
-
-# Determine HOST_LINK_VERSION on Darwin.
-set(HOST_LINK_VERSION)
-if (APPLE)
-  set(LD_V_OUTPUT)
-  execute_process(
-    COMMAND sh -c "${CMAKE_LINKER} -v 2>&1 | head -1"
-    RESULT_VARIABLE HAD_ERROR
-    OUTPUT_VARIABLE LD_V_OUTPUT)
-  if (NOT HAD_ERROR)
-    if ("${LD_V_OUTPUT}" MATCHES ".*ld64-([0-9.]+).*")
-      string(REGEX REPLACE ".*ld64-([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
-    elseif ("${LD_V_OUTPUT}" MATCHES "[^0-9]*([0-9.]+).*")
-      string(REGEX REPLACE "[^0-9]*([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
-    endif()
-  else()
-    message(FATAL_ERROR "${CMAKE_LINKER} failed with status ${HAD_ERROR}")
-  endif()
-endif()
-
-include(CMakeParseArguments)
-include(AddFlang)
-
-
-add_subdirectory(include)
-add_subdirectory(lib)
-add_subdirectory(cmake/modules)
-
-option(FLANG_BUILD_TOOLS
-  "Build the Flang tools. If OFF, just generate build targets." ON)
-if (FLANG_BUILD_TOOLS)
-  add_subdirectory(tools)
-endif()
-add_subdirectory(runtime)
-
-if (FLANG_INCLUDE_TESTS)
-  enable_testing()
-  add_subdirectory(test)
-  add_subdirectory(unittests)
-endif()
-
-# TODO: Add doxygen support.
-#option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
-#       ${LLVM_INCLUDE_DOCS})
-#if (FLANG_INCLUDE_DOCS)
-#  add_subdirectory(documentation)
-#endif()
-
-# Custom target to install Flang libraries.
-add_custom_target(flang-libraries)
-set_target_properties(flang-libraries PROPERTIES FOLDER "Misc")
-
-if (NOT LLVM_ENABLE_IDE)
-  add_llvm_install_targets(install-flang-libraries
-   DEPENDS flang-libraries
-   COMPONENT flang-libraries)
-endif()
-
-get_property(FLANG_LIBS GLOBAL PROPERTY FLANG_LIBS)
-if (FLANG_LIBS)
-  list(REMOVE_DUPLICATES FLANG_LIBS)
-  foreach(lib ${FLANG_LIBS})
-    add_dependencies(flang-libraries ${lib})
-    if (NOT LLVM_ENABLE_IDE)
-      add_dependencies(install-flang-libraries install-${lib})
-    endif()
-  endforeach()
-endif()
-
-if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-  install(DIRECTORY include/flang
-    DESTINATION include
-    COMPONENT flang-headers
-    FILES_MATCHING
-    PATTERN "*.def"
-    PATTERN "*.h"
-    PATTERN "*.inc"
-    PATTERN "*.td"
-    PATTERN "config.h" EXCLUDE
-    PATTERN ".git"     EXCLUDE
-    PATTERN "CMakeFiles" EXCLUDE)
-endif()
diff --git a/README.md b/README.md
index 8da65c3828e7..7855d5482128 100644
--- a/README.md
+++ b/README.md
@@ -166,6 +166,15 @@ or
 ```
 CXX=/opt/gcc-8.3/bin/g++-8.3 cmake ...
 ```
+There's a third option!
+The CMakeList.txt file uses the variable GCC
+as the path to the bin directory containing the C++ compiler.
+
+GCC can be defined on the cmake command line
+where `<GCC_DIRECTORY>` is the path to a GCC installation with bin, lib, etc:
+```
+cmake -DGCC=<GCC_DIRECTORY> ...
+```
 
 ### Building f18 with clang
 
@@ -173,11 +182,27 @@ To build f18 with clang,
 cmake needs to know how to find clang++
 and the GCC library and tools that were used to build clang++.
 
+The CMakeList.txt file expects either CXX or BUILD_WITH_CLANG to be set.
+
 CXX should include the full path to clang++
 or clang++ should be found on your PATH.
 ```
 export CXX=clang++
 ```
+BUILD_WITH_CLANG can be defined on the cmake command line
+where `<CLANG_DIRECTORY>`
+is the path to a clang installation with bin, lib, etc:
+```
+cmake -DBUILD_WITH_CLANG=<CLANG_DIRECTORY>
+```
+Or GCC can be defined on the f18 cmake command line
+where `<GCC_DIRECTORY>` is the path to a GCC installation with bin, lib, etc:
+```
+cmake -DGCC=<GCC_DIRECTORY> ...
+```
+To use f18 after it is built,
+the environment variables PATH and LD_LIBRARY_PATH
+must be set to use GCC and its associated libraries.
 
 ### Installation Directory
 

From b1473ad91e5a68617a462bd1a2d27b3a3987ff12 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 16 Dec 2019 09:39:58 -0800
Subject: [PATCH 116/345] [shim] add back removed files

Conflicts:
	lib/CMakeLists.txt
---
 .../fir/Analysis/IteratedDominanceFrontier.h  |   97 +
 include/fir/Attribute.h                       |  123 ++
 include/fir/CMakeLists.txt                    |    4 +
 include/fir/Dialect.h                         |   54 +
 include/fir/FIROps.h                          |  107 +
 include/fir/FIROps.td                         | 1768 +++++++++++++++++
 include/fir/Transforms/MemToReg.h             |   39 +
 include/fir/Type.h                            |  277 +++
 lib/CMakeLists.txt                            |    5 +-
 lib/burnside/CMakeLists.txt                   |   25 +
 lib/burnside/builder.h                        |   78 +
 lib/burnside/flattened.cc                     |  695 +++++++
 lib/burnside/flattened.h                      |  237 +++
 lib/burnside/mixin.h                          |   72 +
 14 files changed, 3577 insertions(+), 4 deletions(-)
 create mode 100644 include/fir/Analysis/IteratedDominanceFrontier.h
 create mode 100644 include/fir/Attribute.h
 create mode 100644 include/fir/CMakeLists.txt
 create mode 100644 include/fir/Dialect.h
 create mode 100644 include/fir/FIROps.h
 create mode 100644 include/fir/FIROps.td
 create mode 100644 include/fir/Transforms/MemToReg.h
 create mode 100644 include/fir/Type.h
 create mode 100644 lib/burnside/CMakeLists.txt
 create mode 100644 lib/burnside/builder.h
 create mode 100644 lib/burnside/flattened.cc
 create mode 100644 lib/burnside/flattened.h
 create mode 100644 lib/burnside/mixin.h

diff --git a/include/fir/Analysis/IteratedDominanceFrontier.h b/include/fir/Analysis/IteratedDominanceFrontier.h
new file mode 100644
index 000000000000..c8858d0a8f70
--- /dev/null
+++ b/include/fir/Analysis/IteratedDominanceFrontier.h
@@ -0,0 +1,97 @@
+//===- IteratedDominanceFrontier.h - Calculate IDF --------------*- 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
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// Compute iterated dominance frontiers using a linear time algorithm.
+///
+/// The algorithm used here is based on:
+///
+///   Sreedhar and Gao. A linear time algorithm for placing phi-nodes.
+///   In Proceedings of the 22nd ACM SIGPLAN-SIGACT Symposium on Principles of
+///   Programming Languages
+///   POPL '95. ACM, New York, NY, 62-73.
+///
+/// It has been modified to not explicitly use the DJ graph data structure and
+/// to directly compute pruned SSA using per-variable liveness information.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FIR_ANALYSIS_IDF_H
+#define FIR_ANALYSIS_IDF_H
+
+#include "mlir/Analysis/Dominance.h"
+#include "mlir/IR/Block.h"
+#include "mlir/Support/LLVM.h"
+
+namespace mlir {
+class Block;
+class DominanceInfo;
+} // namespace mlir
+
+namespace fir {
+
+/// Determine the iterated dominance frontier, given a set of defining
+/// blocks, and optionally, a set of live-in blocks.
+///
+/// In turn, the results can be used to place phi nodes.
+///
+/// This algorithm is a linear time computation of Iterated Dominance Frontiers,
+/// pruned using the live-in set.
+/// By default, liveness is not used to prune the IDF computation.
+/// The template parameters should be either BasicBlock* or Inverse<BasicBlock
+/// *>, depending on if you want the forward or reverse IDF.
+template <class NodeTy, bool IsPostDom>
+class IDFCalculator {
+public:
+  IDFCalculator(mlir::DominanceInfo &DT) : DT(DT), useLiveIn(false) {}
+
+  /// Give the IDF calculator the set of blocks in which the value is
+  /// defined.  This is equivalent to the set of starting blocks it should be
+  /// calculating the IDF for (though later gets pruned based on liveness).
+  ///
+  /// Note: This set *must* live for the entire lifetime of the IDF calculator.
+  void setDefiningBlocks(const llvm::SmallPtrSetImpl<NodeTy *> &Blocks) {
+    DefBlocks = &Blocks;
+  }
+
+  /// Give the IDF calculator the set of blocks in which the value is
+  /// live on entry to the block.   This is used to prune the IDF calculation to
+  /// not include blocks where any phi insertion would be dead.
+  ///
+  /// Note: This set *must* live for the entire lifetime of the IDF calculator.
+
+  void setLiveInBlocks(const llvm::SmallPtrSetImpl<NodeTy *> &Blocks) {
+    LiveInBlocks = &Blocks;
+    useLiveIn = true;
+  }
+
+  /// Reset the live-in block set to be empty, and tell the IDF
+  /// calculator to not use liveness anymore.
+  void resetLiveInBlocks() {
+    LiveInBlocks = nullptr;
+    useLiveIn = false;
+  }
+
+  /// Calculate iterated dominance frontiers
+  ///
+  /// This uses the linear-time phi algorithm based on DJ-graphs mentioned in
+  /// the file-level comment.  It performs DF->IDF pruning using the live-in
+  /// set, to avoid computing the IDF for blocks where an inserted PHI node
+  /// would be dead.
+  void calculate(llvm::SmallVectorImpl<NodeTy *> &IDFBlocks);
+
+private:
+  mlir::DominanceInfo &DT;
+  bool useLiveIn;
+  const llvm::SmallPtrSetImpl<NodeTy *> *LiveInBlocks;
+  const llvm::SmallPtrSetImpl<NodeTy *> *DefBlocks;
+};
+
+typedef IDFCalculator<mlir::Block, false> ForwardIDFCalculator;
+
+} // namespace fir
+#endif
diff --git a/include/fir/Attribute.h b/include/fir/Attribute.h
new file mode 100644
index 000000000000..c71a8862c4d6
--- /dev/null
+++ b/include/fir/Attribute.h
@@ -0,0 +1,123 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_ATTRIBUTE_H
+#define FIR_ATTRIBUTE_H
+
+#include "mlir/IR/Attributes.h"
+
+namespace fir {
+
+class FIROpsDialect;
+
+namespace detail {
+struct TypeAttributeStorage;
+}
+
+enum AttributeKind {
+  FIR_ATTR = mlir::Attribute::FIRST_FIR_ATTR,
+  FIR_EXACTTYPE, // instance_of, precise type relation
+  FIR_SUBCLASS,  // subsumed_by, is-a (subclass) relation
+  FIR_POINT,
+  FIR_CLOSEDCLOSED_INTERVAL,
+  FIR_OPENCLOSED_INTERVAL,
+  FIR_CLOSEDOPEN_INTERVAL,
+};
+
+class ExactTypeAttr
+    : public mlir::Attribute::AttrBase<ExactTypeAttr, mlir::Attribute,
+                                       detail::TypeAttributeStorage> {
+public:
+  using Base::Base;
+  using ValueType = mlir::Type;
+
+  static llvm::StringRef getAttrName() { return "instance"; }
+  static ExactTypeAttr get(mlir::Type value);
+
+  mlir::Type getType() const;
+
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() { return AttributeKind::FIR_EXACTTYPE; }
+};
+
+class SubclassAttr
+    : public mlir::Attribute::AttrBase<SubclassAttr, mlir::Attribute,
+                                       detail::TypeAttributeStorage> {
+public:
+  using Base::Base;
+  using ValueType = mlir::Type;
+
+  static llvm::StringRef getAttrName() { return "subsumed"; }
+  static SubclassAttr get(mlir::Type value);
+
+  mlir::Type getType() const;
+
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() { return AttributeKind::FIR_SUBCLASS; }
+};
+
+class ClosedIntervalAttr
+    : public mlir::Attribute::AttrBase<ClosedIntervalAttr> {
+public:
+  using Base::Base;
+
+  static llvm::StringRef getAttrName() { return "interval"; }
+  static ClosedIntervalAttr get(mlir::MLIRContext *ctxt);
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() {
+    return AttributeKind::FIR_CLOSEDCLOSED_INTERVAL;
+  }
+};
+
+class UpperBoundAttr : public mlir::Attribute::AttrBase<UpperBoundAttr> {
+public:
+  using Base::Base;
+
+  static llvm::StringRef getAttrName() { return "upper"; }
+  static UpperBoundAttr get(mlir::MLIRContext *ctxt);
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() {
+    return AttributeKind::FIR_OPENCLOSED_INTERVAL;
+  }
+};
+
+class LowerBoundAttr : public mlir::Attribute::AttrBase<LowerBoundAttr> {
+public:
+  using Base::Base;
+
+  static llvm::StringRef getAttrName() { return "lower"; }
+  static LowerBoundAttr get(mlir::MLIRContext *ctxt);
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() {
+    return AttributeKind::FIR_CLOSEDOPEN_INTERVAL;
+  }
+};
+
+class PointIntervalAttr : public mlir::Attribute::AttrBase<PointIntervalAttr> {
+public:
+  using Base::Base;
+
+  static llvm::StringRef getAttrName() { return "point"; }
+  static PointIntervalAttr get(mlir::MLIRContext *ctxt);
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() { return AttributeKind::FIR_POINT; }
+};
+
+mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
+                                  llvm::StringRef rawText, mlir::Type type,
+                                  mlir::Location loc);
+
+} // namespace fir
+
+#endif // FIR_ATTRIBUTE_H
diff --git a/include/fir/CMakeLists.txt b/include/fir/CMakeLists.txt
new file mode 100644
index 000000000000..9528b1abffb0
--- /dev/null
+++ b/include/fir/CMakeLists.txt
@@ -0,0 +1,4 @@
+set(LLVM_TARGET_DEFINITIONS FIROps.td)
+mlir_tablegen(FIROps.h.inc -gen-op-decls)
+mlir_tablegen(FIROps.cpp.inc -gen-op-defs)
+add_public_tablegen_target(FIROpsIncGen)
diff --git a/include/fir/Dialect.h b/include/fir/Dialect.h
new file mode 100644
index 000000000000..d4a180cecce9
--- /dev/null
+++ b/include/fir/Dialect.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_DIALECT_H
+#define FIR_DIALECT_H
+
+#include "mlir/IR/Dialect.h"
+
+namespace llvm {
+class raw_ostream;
+class StringRef;
+} // namespace llvm
+
+namespace mlir {
+class Attribute;
+class Location;
+class MLIRContext;
+class Type;
+} // namespace mlir
+
+namespace fir {
+
+/// FIR dialect
+class FIROpsDialect final : public mlir::Dialect {
+public:
+  explicit FIROpsDialect(mlir::MLIRContext *ctx);
+  virtual ~FIROpsDialect();
+
+  static llvm::StringRef getDialectNamespace() { return "fir"; }
+
+  mlir::Type parseType(llvm::StringRef rawData,
+                       mlir::Location loc) const override;
+  void printType(mlir::Type ty, llvm::raw_ostream &os) const override;
+
+  mlir::Attribute parseAttribute(llvm::StringRef rawText, mlir::Type type,
+                                 mlir::Location loc) const override;
+  void printAttribute(mlir::Attribute attr,
+                      llvm::raw_ostream &os) const override;
+};
+
+} // namespace fir
+
+#endif // FIR_DIALECT_H
diff --git a/include/fir/FIROps.h b/include/fir/FIROps.h
new file mode 100644
index 000000000000..3a9bbf99af04
--- /dev/null
+++ b/include/fir/FIROps.h
@@ -0,0 +1,107 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_FIROPS_H
+#define FIR_FIROPS_H
+
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/OpImplementation.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+using namespace mlir;
+using llvm::ArrayRef;
+using llvm::StringRef;
+
+namespace fir {
+
+class FirEndOp;
+
+/// `fir.global` is a typed symbol with an optional list of initializers.
+class GlobalOp
+    : public mlir::Op<
+          GlobalOp, mlir::OpTrait::ZeroOperands, mlir::OpTrait::ZeroResult,
+          mlir::OpTrait::IsIsolatedFromAbove,
+          mlir::OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
+public:
+  using Op::Op;
+  using Op::print;
+
+  static llvm::StringRef getOperationName() { return "fir.global"; }
+  static llvm::StringRef getTypeAttrName() { return "type"; }
+
+  static void build(mlir::Builder *builder, mlir::OperationState *result,
+                    llvm::StringRef name, mlir::Type type,
+                    llvm::ArrayRef<mlir::NamedAttribute> attrs);
+
+  /// Operation hooks.
+  static mlir::ParseResult parse(mlir::OpAsmParser &parser,
+                                 mlir::OperationState &result);
+  void print(mlir::OpAsmPrinter &p);
+  mlir::LogicalResult verify();
+
+  mlir::Type getType() {
+    return getAttrOfType<TypeAttr>(getTypeAttrName()).getValue();
+  }
+
+  void appendInitialValue(mlir::Operation *op);
+
+private:
+  mlir::Region &front();
+};
+
+/// `fir.dispatch_table` is an untyped symbol that is a list of associations
+/// between method identifiers and a FuncOp symbol.
+class DispatchTableOp
+    : public mlir::Op<
+          DispatchTableOp, mlir::OpTrait::ZeroOperands,
+          mlir::OpTrait::ZeroResult, mlir::OpTrait::IsIsolatedFromAbove,
+          mlir::OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
+public:
+  using Op::Op;
+
+  static llvm::StringRef getOperationName() { return "fir.dispatch_table"; }
+
+  static void build(mlir::Builder *builder, mlir::OperationState *result,
+                    llvm::StringRef name, mlir::Type type,
+                    llvm::ArrayRef<mlir::NamedAttribute> attrs);
+
+  /// Operation hooks.
+  static mlir::ParseResult parse(mlir::OpAsmParser &parser,
+                                 mlir::OperationState &result);
+  void print(mlir::OpAsmPrinter &p);
+  mlir::LogicalResult verify();
+
+  void appendTableEntry(mlir::Operation *op);
+
+private:
+  mlir::Region &front();
+};
+
+mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);
+unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
+                               unsigned dest);
+mlir::ParseResult parseSelector(mlir::OpAsmParser *parser,
+                                mlir::OperationState *result,
+                                mlir::OpAsmParser::OperandType &selector,
+                                mlir::Type &type);
+
+#define GET_OP_CLASSES
+#include "fir/FIROps.h.inc"
+
+LoopOp getForInductionVarOwner(mlir::Value *val);
+
+} // namespace fir
+
+#endif // FIR_FIROPS_H
diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
new file mode 100644
index 000000000000..7e4b24afb703
--- /dev/null
+++ b/include/fir/FIROps.td
@@ -0,0 +1,1768 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//
+// Definition of the FIR dialect operations
+//
+
+#ifdef FIR_DIALECT_FIR_OPS
+#else
+#define FIR_DIALECT_FIR_OPS
+
+#ifdef OP_BASE
+#else
+include "mlir/IR/OpBase.td"
+#endif
+
+def fir_Dialect : Dialect {
+  let name = "fir";
+}
+
+def fir_Type : Type<CPred<"fir::isa_fir_or_std_type($_self)">,
+    "FIR dialect type">;
+
+def fir_CharacterType : Type<CPred<"$_self.isa<fir::CharacterType>()">,
+    "FIR character type">;
+def fir_ComplexType : Type<CPred<"$_self.isa<fir::CplxType>()">,
+    "FIR complex type">;
+def fir_IntegerType : Type<CPred<"$_self.isa<fir::IntType>()">,
+    "FIR integer type">;
+def fir_LogicalType : Type<CPred<"$_self.isa<fir::LogicalType>()">,
+    "FIR logical type">;
+def fir_RealType : Type<CPred<"$_self.isa<fir::RealType>()">,
+    "FIR real type">;
+
+def AnyIntegerLike : TypeConstraint<Or<[IntegerLike.predicate,
+    fir_IntegerType.predicate]>, "any integer">;
+def AnyLogicalLike : TypeConstraint<Or<[BoolLike.predicate,
+    fir_LogicalType.predicate]>, "any logical">;
+def AnyRealLike : TypeConstraint<Or<[FloatLike.predicate,
+    fir_RealType.predicate]>, "any real">;
+def AnyIntegerType : Type<AnyIntegerLike.predicate, "any integer">;
+
+def fir_RecordType : Type<CPred<"$_self.isa<fir::RecordType>()">,
+    "FIR derived type">;
+def fir_SequenceType : Type<CPred<"$_self.isa<fir::SequenceType>()">,
+    "array type">;
+
+def AnyCompositeLike : TypeConstraint<Or<[fir_RecordType.predicate,
+    fir_SequenceType.predicate, IsTupleTypePred]>, "any composite">;
+
+def fir_ReferenceType : Type<CPred<"$_self.isa<fir::ReferenceType>()">,
+    "reference type">;
+def fir_HeapType : Type<CPred<"$_self.isa<fir::HeapType>()">,
+    "allocatable type">;
+def fir_PointerType : Type<CPred<"$_self.isa<fir::PointerType>()">,
+    "pointer type">;
+
+def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
+    fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
+
+def fir_BoxType : Type<CPred<"$_self.isa<fir::BoxType>()">, "box type">;
+def fir_BoxCharType : Type<CPred<"$_self.isa<fir::BoxCharType>()">,
+    "box character type">;
+def fir_BoxProcType : Type<CPred<"$_self.isa<fir::BoxProcType>()">,
+    "box procedure type">;
+
+def AnyBoxLike : TypeConstraint<Or<[fir_BoxType.predicate,
+    fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
+
+def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
+    fir_HeapType.predicate, fir_PointerType.predicate, fir_BoxType.predicate]>,
+    "any reference or box">;
+
+def fir_DimsType : Type<CPred<"$_self.isa<fir::DimsType>()">, "dim type">;
+def fir_TypeDescType : Type<CPred<"$_self.isa<fir::TypeDescType>()">,
+    "type desc type">;
+def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
+
+def AnyCoordinateLike : TypeConstraint<Or<[AnyInteger.predicate,
+    Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate]>,
+    "any coordinate index">;
+def AnyCoordinateType : Type<AnyCoordinateLike.predicate, "coordinate type">;
+
+class fir_Op<string mnemonic, list<OpTrait> traits>
+  : Op<fir_Dialect, mnemonic, traits>;
+
+def SimplePrettyParserPrinter {
+}
+
+class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
+  : fir_Op<mnemonic, traits> {
+  let parser = [{
+    M::FunctionType type;
+    M::OpAsmParser::OperandType opnd;
+    if (parser.parseOperand(opnd) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(opnd, type.getInput(0), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return M::failure();
+    return M::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(*getODSOperands(0).begin());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_AllocateOpBuilder : OpBuilder<
+  "Builder *, OperationState &result, Type resultType,"
+  "ArrayRef<Value *> size = {}, ArrayRef<NamedAttribute> attributes = {}",
+  [{
+    result.addTypes(resultType);
+    result.addOperands(size);
+    for (auto namedAttr : attributes)
+      result.addAttribute(namedAttr.first, namedAttr.second);
+  }]>;
+
+def fir_NamedAllocateOpBuilder : OpBuilder<
+  "Builder *builder, OperationState &result, Type resultType,"
+  "StringRef name, ArrayRef<Value *> size = {},"
+  "ArrayRef<NamedAttribute> attributes = {}",
+  [{
+    result.addAttribute("name", builder->getStringAttr(name));
+    result.addTypes(resultType);
+    result.addOperands(size);
+    for (auto namedAttr : attributes)
+      result.addAttribute(namedAttr.first, namedAttr.second);
+  }]>;
+
+def fir_OneResultOpBuilder : OpBuilder<
+  "Builder *, OperationState &result, Type resultType, "
+  "ArrayRef<Value *> operands, ArrayRef<NamedAttribute> attributes = {}",
+  [{
+    if (resultType)
+      result.addTypes(resultType);
+    result.addOperands(operands);
+    for (auto namedAttr : attributes) {
+      result.addAttribute(namedAttr.first, namedAttr.second);
+    }
+  }]>;
+
+class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
+  let builders = [fir_OneResultOpBuilder];
+}
+
+class fir_SimpleOneResultOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_SimpleOp<mnemonic, traits>, Results<(outs fir_Type:$res)> {
+  let builders = [fir_OneResultOpBuilder];
+}
+
+class fir_TwoBuilders<OpBuilder b1, OpBuilder b2> {
+  list<OpBuilder> builders = [b1, b2];
+}
+
+class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
+  let arguments = (ins
+    OptionalAttr<StrAttr>:$name,
+    OptionalAttr<BoolAttr>:$target
+  );
+}
+
+class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
+    fir_AllocatableBaseOp<mnemonic, !listconcat([NoSideEffect], traits)>,
+    fir_TwoBuilders<fir_AllocateOpBuilder, fir_NamedAllocateOpBuilder>,
+    Arguments<(ins Variadic<Index>:$shape)> {
+}
+
+// Memory SSA operations
+
+def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
+  let summary = "allocate storage for a temporary on the stack given a type";
+
+  let description = [{
+    This primitive operation is used to allocate an object on the stack.  A
+    reference to the object of type `!fir.ref<T>` is returned.  The returned
+    object has an undefined state.  The allocation can be given an optional
+    name.  The allocation may have a dynamic repetition count for allocating
+    a sequence of locations for the specified type.
+  }];
+
+  let parser = [{
+    M::Type intype;
+    if (parser.parseType(intype))
+      return M::failure();
+    auto &builder = parser.getBuilder();
+    result.addAttribute("in_type", builder.getTypeAttr(intype));
+    if (!parser.parseOptionalComma()) {
+      llvm::SmallVector<M::Type, 4> typeVec;
+      llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+      if (parser.parseOperandList(operands,
+              M::OpAsmParser::Delimiter::None) ||
+          parser.resolveOperands(operands, builder.getIndexType(),
+              parser.getNameLoc(), result.operands))
+        return M::failure();
+    }
+    M::Type restype;
+    if (parser.parseColonType(restype) ||
+        parser.addTypeToList(restype, result.types))
+      return M::failure();
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("in_type");
+    for (auto sh : getShapeOperands()) {
+      p << ", ";
+      p.printOperand(sh);
+    }
+    p << " : " << getType();
+    p.printOptionalAttrDict(getAttrs(), {"in_type"});
+  }];
+  let verifier = [{
+    M::Type inType = getAttrOfType<M::TypeAttr>("in_type").getValue();
+    M::Type outType = getType();
+    if (auto ref = outType.dyn_cast<fir::ReferenceType>()) {
+      if (inType != ref.getEleTy())
+        return emitOpError("input type and !fir.ref element type mismatch");
+    } else {
+      return emitOpError("must be a !fir.ref type");
+    }
+    return M::success();
+  }];
+
+  let extraClassDeclaration = [{
+    mlir::Type getAllocatedType();
+    operand_range getShapeOperands() {
+      return {operand_begin(), operand_end()};
+    }
+  }];
+}
+
+def fir_LoadOp : fir_OneResultOp<"load", [NoSideEffect]>,
+    Arguments<(ins AnyReferenceLike:$memref)> {
+  let summary = "load a value from a memory reference";
+
+  let description = [{
+    Load a value from a memory reference into a virtual register.  Produces
+    an immutable ssa-value of the referent type.
+  }];
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value *refVal",
+    [{
+      fir::ReferenceType refTy =
+        refVal->getType().cast<fir::ReferenceType>();
+      result.addOperands(refVal);
+      result.addTypes(refTy.getEleTy());
+    }]
+  >];
+
+  let parser = [{
+    M::Type type;
+    M::OpAsmParser::OperandType oper;
+    if (parser.parseOperand(oper) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(oper, type, result.operands))
+       return M::failure();
+    M::Type eleTy;
+    if (getElementOf(eleTy, type) ||
+        parser.addTypeToList(eleTy, result.types))
+       return M::failure();
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(memref());
+    p << " : " << memref()->getType();
+    p.printOptionalAttrDict(getAttrs(), {});
+  }];
+
+  let extraClassDeclaration = [{
+    static mlir::ParseResult getElementOf(mlir::Type &ele, mlir::Type ref);
+  }];
+}
+
+def fir_StoreOp : fir_Op<"store", []>,
+    Arguments<(ins AnyType:$value, AnyReferenceLike:$memref)> {
+  let summary = "store an SSA-value to a memory location";
+
+  let description = [{
+    Store an ssa-value (virtual register) to a memory reference.  The stored
+    value must be of the same type as the referent type of the memory
+    reference.
+  }];
+
+  let parser = [{
+    M::Type type;
+    M::OpAsmParser::OperandType oper;
+    M::OpAsmParser::OperandType store;
+    if (parser.parseOperand(oper) ||
+        parser.parseKeyword("to") ||
+        parser.parseOperand(store) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(oper, elementType(type),
+          result.operands) ||
+        parser.resolveOperand(store, type, result.operands))
+       return M::failure();
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(value());
+    p << " to ";
+    p.printOperand(memref());
+    p << " : " << memref()->getType();
+    p.printOptionalAttrDict(getAttrs(), {});
+  }];
+
+  let extraClassDeclaration = [{
+    static mlir::Type elementType(mlir::Type refType);
+  }];
+}
+
+def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
+  let summary = "explicit undefined value of some type";
+
+  let description = [{
+    Constructs an ssa-value of the specified type with an undefined value.
+    This operation is typically created internally by the mem2reg conversion
+    pass.
+  }];
+
+  let parser = [{
+    M::Type intype;
+    if (parser.parseType(intype) ||
+        parser.addTypeToList(intype, result.types))
+      return M::failure();
+    auto &builder = parser.getBuilder();
+    result.addAttribute("in_type", builder.getTypeAttr(intype));
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("in_type");
+  }];
+  let verifier = [{
+    if (auto ref = getType().dyn_cast<fir::ReferenceType>())
+      return emitOpError("undefined values of type !fir.ref not allowed");
+    return M::success();
+  }];
+}
+
+def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
+  let summary = "allocate storage on the heap for an object of a given type";
+
+  let description = [{
+    Creates a heap memory reference suitable for storing a value of the
+    given type, T.  The heap refernce returned has type `!fir.heap<T>`.
+    The memory object is in an undefined state.  `allocmem` operations must
+    be paired with `freemem` operations to avoid memory leaks.
+  }];
+
+  let parser = [{
+    M::Type intype;
+    if (parser.parseType(intype))
+      return M::failure();
+    auto &builder = parser.getBuilder();
+    result.addAttribute("in_type", builder.getTypeAttr(intype));
+    if (!parser.parseOptionalComma()) {
+      llvm::SmallVector<M::Type, 4> typeVec;
+      llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+      if (parser.parseOperandList(operands,
+              M::OpAsmParser::Delimiter::None) ||
+          parser.resolveOperands(operands, builder.getIndexType(),
+              parser.getNameLoc(), result.operands))
+        return M::failure();
+    }
+    M::Type restype;
+    if (parser.parseColonType(restype) ||
+        parser.addTypeToList(restype, result.types))
+      return M::failure();
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("in_type");
+    for (auto sh : getShapeOperands()) {
+      p << ", ";
+      p.printOperand(sh);
+    }
+    p << " : " << getType();
+    p.printOptionalAttrDict(getAttrs(), {"in_type"});
+  }];
+  let verifier = [{
+    M::Type inType = getAttrOfType<M::TypeAttr>("in_type").getValue();
+    M::Type outType = getType();
+    if (auto ref = outType.dyn_cast<fir::HeapType>()) {
+      if (inType != ref.getEleTy())
+        return emitOpError("input type and !fir.heap element type mismatch");
+    } else {
+      return emitOpError("must be a !fir.heap type");
+    }
+    return M::success();
+  }];
+
+  let extraClassDeclaration = [{
+    mlir::Type getAllocatedType();
+    operand_range getShapeOperands() {
+      return {operand_begin(), operand_end()};
+    }
+  }];
+}
+
+def fir_FreeMemOp : fir_Op<"freemem", []>,
+    Arguments<(ins fir_HeapType:$heapref)> {
+  let summary = "free a heap object";
+
+  let description = [{
+    Deallocates a heap memory reference that was allocated by an `allocmem`.
+    The memory object that is deallocated is placed in an undefined state
+    after `fir.freemem`.  Optimizations may treat the loading of an object
+    in the undefined state as undefined behavior.
+  }];
+
+  let parser = [{
+    M::Type type;
+    M::OpAsmParser::OperandType oper;
+    if (parser.parseOperand(oper) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(oper, type, result.operands))
+      return M::failure();
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(heapref());
+    p << " : " << getOperand()->getType();
+    p.printOptionalAttrDict(getAttrs(), {});
+  }];
+}
+
+// Terminator operations
+
+class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic, !listconcat(traits, [Terminator])>,
+    Arguments<(ins Variadic<AnyType>:$args)>, Results<(outs)> {
+  let builders = [OpBuilder<
+    "Builder *, OperationState &result, Value *selector,"
+    "ArrayRef<Value *> properOperands, ArrayRef<Block *> destinations,"
+    "ArrayRef<ArrayRef<Value *>> operands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}",
+    [{
+      result.addOperands(selector);
+      result.addOperands(properOperands);
+      for (auto kvp : llvm::zip(destinations, operands)) {
+        result.addSuccessor(std::get<0>(kvp), std::get<1>(kvp));
+      }
+      for (auto namedAttr : attributes) {
+        result.addAttribute(namedAttr.first, namedAttr.second);
+      }
+    }]
+  >];
+
+  string extraSwitchClassDeclaration = [{
+    using Conditions = mlir::Value *;
+    constexpr static auto AttrName = "cases";
+
+    // The number of destination conditions that may be tested
+    unsigned getNumConditions() { return getNumDest(); }
+
+    // The selector is the value being tested to determine the destination
+    mlir::Value *getSelector() { return getOperand(0); }
+
+    // The number of blocks that may be branched to
+    unsigned getNumDest() { return getOperation()->getNumSuccessors(); }
+  }];
+}
+
+class fir_IntegralSwitchTerminatorOp<string mnemonic,
+    list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
+  let parser = [{
+    M::OpAsmParser::OperandType selector;
+    M::Type type;
+    if (parseSelector(parser, result, selector, type))
+      return M::failure();
+
+    llvm::SmallVector<M::Attribute, 4> ivalues;
+    llvm::SmallVector<M::Block *, 4> dests;
+    llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
+    while (true) {
+      M::Attribute ivalue;
+      M::Block *dest;
+      llvm::SmallVector<M::Value *, 4> destArg;
+      llvm::SmallVector<M::NamedAttribute, 1> temp;
+      if (parser.parseAttribute(ivalue, "i", temp) ||
+          parser.parseComma() ||
+          parser.parseSuccessorAndUseList(dest, destArg))
+        return M::failure();
+      ivalues.push_back(ivalue);
+      dests.push_back(dest);
+      destArgs.push_back(destArg);
+      if (!parser.parseOptionalRSquare())
+        break;
+      if (parser.parseComma())
+        return M::failure();
+    }
+    result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(ivalues));
+    for (unsigned i = 0, count = dests.size(); i != count; ++i)
+      result.addSuccessor(dests[i], destArgs[i]);
+    return M::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(getSelector());
+    p << " : " << getSelector()->getType() << " [";
+    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+      if (i)
+        p << ", ";
+      auto &attr = cases[i];
+      if (auto intAttr = attr.dyn_cast_or_null<M::IntegerAttr>())
+        p << intAttr.getValue();
+      else
+        p.printAttribute(attr);
+      p << ", ";
+      p.printSuccessorAndUseList(getOperation(), i);
+    }
+    p << ']';
+    p.printOptionalAttrDict(getAttrs(), {AttrName});
+  }];
+
+  let verifier = [{
+    if (!(getSelector()->getType().isa<M::IntegerType>() ||
+          getSelector()->getType().isa<M::IndexType>() ||
+          getSelector()->getType().isa<fir::IntType>()))
+      return emitOpError("must be an integer");
+    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+      auto &attr = cases[i];
+      if (attr.dyn_cast_or_null<M::IntegerAttr>()) {
+        // ok
+      } else if (attr.dyn_cast_or_null<M::UnitAttr>()) {
+        // ok
+      } else {
+        return emitOpError("invalid case alternative");
+      }
+    }
+    return M::success();
+  }];
+
+  let extraClassDeclaration = extraSwitchClassDeclaration;
+}
+
+def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
+  let summary = "a multiway branch";
+
+  let description = [{
+    A multiway branch terminator with similar semantics to C's `switch`
+    statement.  A selector value is matched against a list of constants
+    of the same type for a match.  When a match is found, control is
+    transferred to the corresponding basic block.  A `select` must have
+    at least one basic block with a corresponding `unit` match, and
+    that block will be selected when all other conditions fail to match.
+  }];
+}
+
+def fir_SelectRankOp : fir_IntegralSwitchTerminatorOp<"select_rank"> {
+  let summary = "Fortran's SELECT RANK statement";
+
+  let description = [{
+    Similar to `select`, `select_rank` provides a way to express Fortran's
+    SELECT RANK construct.  In this case, the rank of the selector value
+    is matched against constants of integer type.  The structure is the
+    same as `select`, but `select_rank` determines the rank of the selector
+    variable at runtime to determine the best match.
+  }];
+}
+
+def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
+  let summary = "Fortran's SELECT CASE statement";
+
+  let description = [{
+    Similar to `select`, `select_case` provides a way to express Fortran's
+    SELECT CASE construct.  In this case, the selector value is matched
+    against variables (not just constants) and ranges.  The structure is
+    the same as `select`, but `select_case` allows for the expression of
+    more complex match conditions.
+  }];
+
+  let parser = [{
+    M::OpAsmParser::OperandType selector;
+    M::Type type;
+    if (parseSelector(parser, result, selector, type))
+      return M::failure();
+
+    llvm::SmallVector<M::Attribute, 4> attrs;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 4> opers;
+    llvm::SmallVector<M::Block *, 4> dests;
+    llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
+    while (true) {
+      M::Attribute attr;
+      M::Block *dest;
+      llvm::SmallVector<M::Value *, 4> destArg;
+      llvm::SmallVector<M::NamedAttribute, 1> temp;
+      if (parser.parseAttribute(attr, "a", temp) ||
+          isValidCaseAttr(attr) ||
+          parser.parseComma())
+        return M::failure();
+      attrs.push_back(attr);
+      if (attr.dyn_cast_or_null<M::UnitAttr>()) {
+      } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+        M::OpAsmParser::OperandType oper1;
+        M::OpAsmParser::OperandType oper2;
+        if (parser.parseOperand(oper1) ||
+            parser.parseComma() ||
+            parser.parseOperand(oper2) ||
+            parser.parseComma())
+          return M::failure();
+        opers.push_back(oper1);
+        opers.push_back(oper2);
+      } else {
+        M::OpAsmParser::OperandType oper;
+        if (parser.parseOperand(oper) ||
+            parser.parseComma())
+          return M::failure();
+        opers.push_back(oper);
+      }
+      if (parser.parseSuccessorAndUseList(dest, destArg))
+        return M::failure();
+      dests.push_back(dest);
+      destArgs.push_back(destArg);
+      if (!parser.parseOptionalRSquare())
+        break;
+      if (parser.parseComma())
+        return M::failure();
+    }
+    result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(attrs));
+    if (parser.resolveOperands(opers, type, result.operands))
+      return M::failure();
+    for (unsigned i = 0, count = dests.size(); i != count; ++i)
+      result.addSuccessor(dests[i], destArgs[i]);
+    return M::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(getSelector());
+    p << " : " << getSelector()->getType() << " [";
+    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+      if (i)
+        p << ", ";
+      p << cases[i] << ", ";
+      if (!cases[i].dyn_cast_or_null<M::UnitAttr>()) {
+        p.printOperand(getCaseArg(i, 0));
+        p << ", ";
+        if (cases[i].dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+          p.printOperand(getCaseArg(i, 1));
+          p << ", ";
+        }
+      }
+      p.printSuccessorAndUseList(getOperation(), i);
+    }
+    p << ']';
+    p.printOptionalAttrDict(getAttrs(), {AttrName});
+  }];
+
+  let verifier = [{
+    if (!(getSelector()->getType().isa<M::IntegerType>() ||
+          getSelector()->getType().isa<M::IndexType>() ||
+          getSelector()->getType().isa<fir::IntType>() ||
+          getSelector()->getType().isa<fir::LogicalType>() ||
+          getSelector()->getType().isa<fir::CharacterType>()))
+      return emitOpError("must be an integer, character, or logical");
+    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+    }
+    return M::success();
+  }];
+
+  let extraClassDeclaration = extraSwitchClassDeclaration#[{
+
+    mlir::Value* getCaseArg(unsigned dest, unsigned ele) {
+      assert(ele < 2);
+      assert(dest < getNumConditions());
+      auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
+      assert(cases.size() == getNumConditions());
+      unsigned o = getCaseArgumentOffset(cases, dest);
+      return getOperand(o + 1 + ele);
+    }
+  }];
+}
+
+def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
+  let summary = "Fortran's SELECT TYPE statement";
+
+  let description = [{
+    Similar to `select`, `select_type` provides a way to express Fortran's
+    SELECT TYPE construct.  In this case, the type of the selector value
+    is matched against a list of type descriptors.  The structure is the
+    same as `select`, but `select_type` determines the type of the selector
+    variable at runtime to determine the best match.
+  }];
+
+  let parser = [{
+    M::OpAsmParser::OperandType selector;
+    M::Type type;
+    if (parseSelector(parser, result, selector, type))
+      return M::failure();
+
+    llvm::SmallVector<M::Attribute, 4> attrs;
+    llvm::SmallVector<M::Block *, 4> dests;
+    llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
+    while (true) {
+      M::Attribute attr;
+      M::Block *dest;
+      llvm::SmallVector<M::Value *, 4> destArg;
+      llvm::SmallVector<M::NamedAttribute, 1> temp;
+      if (parser.parseAttribute(attr, "a", temp) ||
+          parser.parseComma() ||
+          parser.parseSuccessorAndUseList(dest, destArg))
+        return M::failure();
+      attrs.push_back(attr);
+      dests.push_back(dest);
+      destArgs.push_back(destArg);
+      if (!parser.parseOptionalRSquare())
+        break;
+      if (parser.parseComma())
+        return M::failure();
+    }
+    result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(attrs));
+    for (unsigned i = 0, count = dests.size(); i != count; ++i)
+      result.addSuccessor(dests[i], destArgs[i]);
+    return M::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(getSelector());
+    p << " : " << getSelector()->getType() << " [";
+    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+      if (i)
+        p << ", ";
+      p << cases[i] << ", ";
+      p.printSuccessorAndUseList(getOperation(), i);
+    }
+    p << ']';
+    p.printOptionalAttrDict(getAttrs(), {AttrName});
+  }];
+
+  let verifier = [{
+    if (!(getSelector()->getType().isa<fir::BoxType>()))
+      return emitOpError("must be a boxed type");
+    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+      auto &attr = cases[i];
+      if (attr.dyn_cast_or_null<fir::ExactTypeAttr>()) {
+        // ok
+      } else if (attr.dyn_cast_or_null<fir::SubclassAttr>()) {
+        // ok
+      } else if (attr.dyn_cast_or_null<M::UnitAttr>()) {
+        // ok
+      } else {
+        return emitOpError("invalid type-case alternative");
+      }
+    }
+    return M::success();
+  }];
+  let extraClassDeclaration = extraSwitchClassDeclaration;
+}
+
+def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
+  let summary = "the unreachable instruction";
+
+  let description = [{
+    Terminates a basic block with the assertion that the end of the block
+    will never be reached at runtime.  This instruction can be used
+    immediately after a call to the Fortran runtime to terminate the
+    program, for example.
+  }];
+
+  let parser = [{
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName();
+  }];
+}
+
+def fir_FirEndOp : fir_Op<"end", [Terminator]> {
+  let summary = "the end instruction";
+
+  let description = [{
+    The end terminator is a special terminator used inside various FIR
+    operations that have regions.  End is thus the custom (and only) terminator
+    for these operations.  It is implicit and need not appear in the textual
+    representation.
+  }];
+}
+
+// Operations on !fir.box<T> type objects
+
+def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
+    Arguments<(ins AnyReferenceLike:$memref, Variadic<fir_DimsType>:$dims)> {
+  let summary = "boxes a given reference and (optional) dimension information";
+
+  let description = [{
+    Create a boxed reference value. In Fortran, the implementation can require
+    extra information about an entity, such as its type, rank, etc.  This
+    auxilliary information is packaged and abstracted as a value with box type.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
+    mlir::OpAsmParser::OperandType memref;
+    if (parser.parseOperand(memref))
+      return mlir::failure();
+    operands.push_back(memref);
+    if (!parser.parseOptionalComma()) {
+      mlir::OpAsmParser::OperandType dims;
+      if (parser.parseOperand(dims))
+        return mlir::failure();
+      operands.push_back(dims);
+    }
+    if (parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(memref());
+    if (getNumOperands() == 2) {
+      p << ", ";
+      p.printOperands(dims());
+    }
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
+    Results<(outs fir_BoxCharType)>,
+    Arguments<(ins fir_CharacterType:$memref, AnyIntegerLike:$len)> {
+  let summary = "boxes a given CHARACTER reference and its LEN parameter";
+
+  let description = [{
+    Create a boxed CHARACTER value. The CHARACTER type has the LEN type
+    parameter, the value of which may only be known at runtime.  Therefore,
+    a variable of type CHARACTER has both its data reference as well as a
+    LEN type parameter.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
+    if (parser.parseOperandList(operands, 2,
+            mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(memref());
+    p << ", ";
+    p.printOperand(len());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
+    Results<(outs fir_BoxProcType)>,
+    Arguments<(ins SymbolRefAttr:$funcname, AnyReferenceLike:$host)> {
+  let summary = "boxes a given procedure and optional host context";
+
+  let description = [{
+    Creates an abstract encapsulation of a PROCEDURE POINTER
+    along with an optional pointer to a host instance context. An internal
+    procedure may require a host instance for execution.
+  }];
+
+  let parser = [{
+    M::FunctionType type;
+    M::SymbolRefAttr procref;
+    M::OpAsmParser::OperandType tupleref;
+    if (parser.parseAttribute(procref, "funcname", result.attributes))
+      return M::failure();
+    bool hasTuple = false;
+    if (!parser.parseOptionalComma()) {
+      if (parser.parseOperand(tupleref))
+        return M::failure();
+      hasTuple = true;
+    }
+    if (parser.parseColonType(type))
+      return M::failure();
+    if (hasTuple) {
+      auto input = type.getInputs()[1];
+      if (parser.resolveOperand(tupleref, input, result.operands))
+        return M::failure();
+    }
+    if (parser.addTypesToList(type.getResults(), result.types))
+      return M::failure();
+    return M::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("funcname");
+    auto *h = host();
+    if (h) {
+      p << ", ";
+      p.printOperand(h);
+    }
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]>,
+    Results<(outs fir_ReferenceType, AnyInteger, AnyInteger, fir_TypeDescType,
+             AnyInteger, fir_DimsType)>,
+    Arguments<(ins fir_BoxType:$box)> {
+  let summary = "unbox the boxed value into a tuple value";
+
+  let description = [{
+    Unboxes a value of `box` type into a tuple of information abstracted in
+    that boxed value.
+  }];
+}
+
+def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]>,
+    Results<(outs fir_ReferenceType, AnyInteger)>,
+    Arguments<(ins fir_BoxCharType:$boxchar)> {
+  let summary = "unbox a boxchar value into a pair value";
+
+  let description = [{
+    Unboxes a value of `boxchar` type into a pair consisting of a memory
+    reference to the CHARACTER data and the LEN type parameter.
+  }];
+}
+
+def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]>,
+    Results<(outs FunctionType, fir_ReferenceType)>,
+    Arguments<(ins fir_BoxProcType:$boxproc)> {
+  let summary = "unbox a boxproc value into a pair value";
+
+  let description = [{
+    Unboxes a value of `boxproc` type into a pair consisting of a procedure
+    pointer and a pointer to a host context.
+  }];
+}
+
+def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]>,
+    Arguments<(ins fir_BoxType:$val)> {
+  let summary = "return a memory reference to the boxed value";
+
+  let description = [{
+    This operator is overloaded to work with values of type `box`,
+    `boxchar`, and `boxproc`.  The result for each of these
+    cases, respectively, is the address of the data, the address of the
+    CHARACTER data, and the address of the procedure.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    mlir::OpAsmParser::OperandType opnd;
+    if (parser.parseOperand(opnd) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(opnd, type.getInput(0), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(val());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]>,
+    Results<(outs AnyInteger)>, Arguments<(ins fir_BoxCharType:$val)> {
+  let summary = "return the LEN type parameter from a boxchar value";
+
+  let description = [{
+    Extracts the LEN type parameter from a `boxchar` value.
+  }];
+}
+
+def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
+    Results<(outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike)>,
+    Arguments<(ins fir_BoxType:$val, AnyIntegerLike:$dim)> {
+  let summary = "return the dynamic dimension information for the boxed value";
+
+  let description = [{
+    Returns the triple of lower bound, extent, and stride for `dim` dimension
+    of `val`, which must have a `box` type.  The dimensions are enumerated from
+    left to right from 0 to rank-1. This operation has undefined behavior if
+    `dim` is out of bounds.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
+    if (parser.parseOperandList(operands, 2,
+            mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(val());
+    p << ", ";
+    p.printOperand(dim());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]>,
+    Arguments<(ins fir_BoxType:$val)> {
+  let summary = "return the size of an element of the boxed value";
+
+  let description = [{
+    Returns the size of an element in an entity of `box` type.  This size may
+    not be known until runtime.
+  }];
+}
+
+def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]>,
+    Results<(outs BoolLike)>, Arguments<(ins fir_BoxType:$val)> {
+  let summary = "is the boxed value an ALLOCATABLE?";
+
+  let description = [{
+    Determine if the boxed value was from an ALLOCATABLE entity.
+
+      %ref = ... : !fir.heap<i64>
+      %box = fir.embox %ref : !fir.box<i64>
+      %isheap = fir.box_isalloc %box : i1
+  }];
+}
+
+def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]>,
+    Results<(outs BoolLike)>, Arguments<(ins fir_BoxType:$val)> {
+  let summary = "is the boxed value an array?";
+
+  let description = [{
+    Determine if the boxed value has a positive (> 0) rank.
+
+      %ref = ... : !fir.ref<i64>
+      %dims = fir.gendims(1, 100, 1) : !fir.dims<1>
+      %box = fir.embox %ref, %dims : !fir.box<i64>
+      %isarr = fir.box_isarray %box : i1
+  }];
+}
+
+def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]>,
+    Results<(outs BoolLike)>, Arguments<(ins fir_BoxType:$val)> {
+  let summary = "is the boxed value a POINTER?";
+
+  let description = [{
+    Determine if the boxed value was from a POINTER entity.
+
+      %ptr = ... : !fir.ptr<i64>
+      %box = fir.embox %ptr : !fir.box<i64>
+      %isptr = fir.box_isptr %box : i1
+  }];
+}
+
+def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]>,
+    Results<(outs fir_ReferenceType)>, Arguments<(ins fir_BoxProcType:$val)> {
+  let summary = "returns the host instance pointer (or null)";
+
+  let description = [{
+    Extract the host context pointer from a `boxproc` value.
+  }];
+}
+
+def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]>,
+    Arguments<(ins fir_BoxType:$val)> {
+  let summary = "return the number of dimensions for the boxed value";
+
+  let description = [{
+    Return the rank of a value of `box` type.  If the value is scalar, the
+    rank is 0.
+  }];
+}
+
+def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]>,
+    Arguments<(ins fir_BoxType:$val)> {
+  let summary = "return the type descriptor for the boxed value";
+
+  let description = [{
+    Return the opaque type descriptor of a value of `box` type.
+  }];
+}
+
+// Record and array type operations
+
+def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
+    Results<(outs fir_ReferenceType)>, Arguments<(ins AnyRefOrBox:$ref,
+    Variadic<AnyCoordinateType>:$coor)> {
+  let summary = "Finds the coordinate (location) of a value in memory";
+
+  let description = [{
+    Determine a memory reference given a memory reference of composite type
+    and a list of index values.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    if (parser.parseOperandList(operands,
+            mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(ref());
+    p << ", ";
+    p.printOperands(coor());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]>,
+    Arguments<(ins AnyCompositeLike:$adt, Variadic<AnyCoordinateType>:$coor)> {
+  let summary = "Extract a value from an aggregate SSA-value";
+
+  let description = [{
+    Extract a subobject value given a value of composite type and a list of
+    index values.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    if (parser.parseOperandList(operands,
+            mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(adt());
+    p << ", ";
+    p.printOperands(coor());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
+  let summary = "create a field index value from a field identifier";
+
+  let description = [{
+    Generate a field (offset) value from an identifier.  Field values may be
+    lowered into exact offsets when the layout of a Fortran derived type is
+    known at compile-time. The type of a field value is `!fir.field` and
+    these values can be used with the `fir.coordinate_of`, `fir.extract_value`,
+    or `fir.insert_value` instructions to compute (abstract) addresses of 
+    subobjects.
+  }];
+
+  let arguments = (ins StrAttr:$field_id);
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, StringRef fieldName",
+    [{
+      result.addAttribute("name", builder->getStringAttr(fieldName));
+    }]
+  >];
+
+  let parser = [{
+    mlir::StringAttr attr;
+    mlir::Type type;
+    if (parser.parseLParen() ||
+        parser.parseAttribute(attr, "field_id", result.attributes) ||
+        parser.parseRParen() ||
+        parser.parseColonType(type) ||
+        parser.addTypeToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << " (" << getAttr("field_id") << ") : "
+      << getType();
+  }];
+}
+
+def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>, 
+    Arguments<(ins Variadic<AnyInteger>:$triples)> {
+  let summary = "generate a value of type `!fir.dims`";
+
+  let description = [{
+    The arguments are an ordered list of integral type values that is a
+    multiple of 3 in length.  Each such triple is defined as: the lower
+    index, the extent, and the stride for that dimension. The dimension
+    information is given in the same row-to-column order as Fortran. This
+    abstract dimension value must describe a reified object, so all dimension
+    information must be specified.  The extent must be non-negative and the
+    stride must not be zero.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 6> operands;
+    if (parser.parseOperandList(operands,
+            mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperands(triples());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]>,
+    Arguments<(ins AnyCompositeLike:$adt, AnyType:$val,
+    Variadic<AnyCoordinateType>:$coor)> {
+  let summary = "insert a new sub-value into a copy of an existing aggregate";
+
+  let description = [{
+    Insert a value into a composite value.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    if (parser.parseOperandList(operands,
+            mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(adt());
+    p << ", ";
+    p.printOperands(coor());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
+  let summary =
+    "create a field index value from a LEN type parameter identifier";
+
+  let description = [{
+    Generate a field (offset) value from an LEN parameter identifier.  Field
+    values may be lowered into exact offsets when the layout of a Fortran
+    derived type is known at compile-time. The type of a field value is
+    `!fir.field` and these values can be used with the `fir.coordinate_of`,
+    `fir.extract_value`, or `fir.insert_value` instructions to compute
+    (abstract) addresses of subobjects.
+  }];
+
+  let arguments = (ins StrAttr:$field_id);
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, StringRef fieldName",
+    [{
+      result.addAttribute("name", builder->getStringAttr(fieldName));
+    }]
+  >];
+
+  let parser = [{
+    mlir::StringAttr attr;
+    mlir::Type type;
+    if (parser.parseLParen() ||
+        parser.parseAttribute(attr, "field_id", result.attributes) ||
+        parser.parseRParen() ||
+        parser.parseColonType(type) ||
+        parser.addTypeToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << " (" << getAttr("field_id") << ") : "
+      << getType();
+  }];
+}
+
+// Fortran loops
+
+def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
+
+def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
+  let summary = "generalized loop operation";
+  let description = [{
+    A generalized Fortran loop construct.
+  }];
+  let arguments = (ins Index:$lowerBound, Index:$upperBound,
+                   Variadic<Index>:$optstep, OptionalAttr<I32Attr>:$constep,
+                   OptionalAttr<BoolAttr>:$unordered);
+  let regions = (region SizedRegion<1>:$region);
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
+              "int64_t lowerBound, int64_t upperBound, int64_t step = 1">,
+    OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
+              "mlir::Value *lowerBound, mlir::Value *upperBound,"
+              "llvm::ArrayRef<mlir::Value*> step">
+  ];
+
+  let printer = [{
+    p << getOperationName() << ' ' << *getInductionVar() << " = "
+      << *lowerBound() << " to " << *upperBound();
+    auto s = optstep();
+    if (s.begin() != s.end()) {
+      p << " step ";
+      p.printOperands(s.begin(), s.end());
+    }
+    if (unordered())
+      p << " unordered";
+    p.printRegion(region(), /*printEntryBlockArgs=*/false,
+        /*printBlockTerminators=*/false);
+    p.printOptionalAttrDict(getAttrs(), {"unordered", "step"});
+  }];
+  let verifier = [{
+    auto step = optstep();
+    if (step.begin() != step.end()) {
+      auto *s = (*step.begin())->getDefiningOp();
+      if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s)) {
+        if (cst.getValue() == 0)
+          return emitOpError("constant step operand must be nonzero");
+      }
+    }
+
+    // Check that the body defines as single block argument for the induction
+    // variable.
+    auto *body = getBody();
+    if (body->getNumArguments() != 1 ||
+        !body->getArgument(0)->getType().isIndex())
+      return emitOpError("expected body to have a single index argument for "
+                       "the induction variable");
+    return mlir::success();
+  }];
+  let parser = [{ return parseLoopOp(parser, result); }];
+
+  let extraClassDeclaration = [{
+    mlir::Block *getBody() { return &region().front(); }
+    mlir::Value *getInductionVar() { return getBody()->getArgument(0); }
+    mlir::OpBuilder getBodyBuilder() {
+      return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
+    }
+    void setLowerBound(mlir::Value *bound) {
+      getOperation()->setOperand(0, bound);
+    }
+    void setUpperBound(mlir::Value *bound) {
+      getOperation()->setOperand(1, bound);
+     }
+    void setStep(mlir::Value *step) {
+      getOperation()->setOperand(2, step);
+    }
+    static char const* getStepKeyword() {
+      return "step";
+    }
+  }];
+}
+
+def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
+  let summary = "generalized conditional operation";
+  let description = [{
+    This is a generalized conditional construct.
+  }];
+  let arguments = (ins I1:$condition);
+  let regions = (region SizedRegion<1>:$whereRegion, AnyRegion:$otherRegion);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"Builder *builder, OperationState &result, "
+              "Value *cond, bool withOtherRegion">
+  ];
+
+  let printer = [{
+    p << getOperationName() << ' ' << *condition();
+    p.printRegion(whereRegion(), /*printEntryBlockArgs=*/false,
+        /*printBlockTerminators=*/false);
+
+    // Print the 'else' regions if it exists and has a block.
+    auto &otherReg = otherRegion();
+    if (!otherReg.empty()) {
+      p << " otherwise";
+      p.printRegion(otherReg, /*printEntryBlockArgs=*/false,
+          /*printBlockTerminators=*/false);
+    }
+    p.printOptionalAttrDict(getAttrs());
+  }];
+  let verifier = [{
+    for (auto &region : getOperation()->getRegions()) {
+      if (region.empty())
+        continue;
+      for (auto &b : region)
+        if (b.getNumArguments() != 0)
+          return emitOpError("requires that child entry blocks have no args");
+    }
+    return mlir::success();
+  }];
+  let parser = [{ return parseWhereOp(parser, result); }];
+
+  let extraClassDeclaration = [{
+    mlir::OpBuilder getWhereBodyBuilder() {
+      assert(!whereRegion().empty() && "Unexpected empty 'where' region.");
+      mlir::Block &body = whereRegion().front();
+      return mlir::OpBuilder(&body, std::prev(body.end()));
+    }
+    mlir::OpBuilder getOtherBodyBuilder() {
+      assert(!otherRegion().empty() && "Unexpected empty 'other' region.");
+      mlir::Block &body = otherRegion().front();
+      return mlir::OpBuilder(&body, std::prev(body.end()));
+    }
+  }];
+}
+
+// Procedure call operations
+
+def fir_CallOp : fir_Op<"call", []>,
+    Results<(outs Variadic<AnyType>)>,
+    Arguments<(ins SymbolRefAttr:$proc, Variadic<AnyType>:$args)> {
+  let summary = "call a procedure directly";
+
+  let description = [{
+    Provides a custom parser and pretty printer to allow for a slightly more
+    readable syntax in the FIR dialect, e.g. `fir.call @sub(%12)`.
+  }];
+
+  let parser = [{
+    M::FunctionType calleeType;
+    M::StringAttr proc;
+    L::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    if (parser.parseAttribute(proc, "proc", result.attributes) ||
+        parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseColonType(calleeType) ||
+        parser.resolveOperands(operands, calleeType.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(calleeType.getResults(), result.types))
+      return M::failure();
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("proc") << '(';
+    p.printOperands(args());
+    p << ')';
+    p.printOptionalAttrDict(getAttrs(), {"proc"});
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_ICallOp : fir_Op<"icall", []>,
+    Results<(outs Variadic<AnyType>)>,
+    Arguments<(ins FunctionType:$proc, Variadic<AnyType>:$args)> {
+  let summary = "call a procedure indirectly";
+
+  let description = [{
+    Provides a custom parser and pretty printer to allow for a slightly more
+    readable syntax in the FIR dialect, e.g. `fir.icall %fun(%12)`.
+  }];
+
+  let parser = [{ 
+    M::FunctionType calleeType;
+    L::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    M::OpAsmParser::OperandType callee;
+    if (parser.parseOperand(callee))
+      return M::failure();
+    operands.push_back(callee);
+    auto calleeLoc = parser.getNameLoc();
+    if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseColonType(calleeType) ||
+        parser.addTypesToList(calleeType.getResults(), result.types))
+      return M::failure();
+    L::SmallVector<M::Type, 8> types;
+    types.push_back(calleeType);
+    auto input = calleeType.getInputs();
+    types.insert(types.end(), input.begin(), input.end());
+    if (parser.resolveOperands(operands, types, calleeLoc, result.operands))
+      return M::failure();
+    return M::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(proc());
+    p << '(';
+    p.printOperands(args());
+    p << ')';
+    p.printOptionalAttrDict(getAttrs(), {"proc"});
+    p << " : " << getCallee()->getType();
+  }];
+  let extraClassDeclaration = [{
+    Value *getCallee() { return getOperand(0); }
+
+    operand_range getArgOperands() {
+      return {arg_operand_begin(), arg_operand_end()};
+    }
+
+    operand_iterator arg_operand_begin() { return ++operand_begin(); }
+    operand_iterator arg_operand_end() { return operand_end(); }
+  }];
+}
+
+def fir_DispatchOp : fir_Op<"dispatch", []>,
+    Results<(outs Variadic<AnyType>)>,
+    Arguments<(ins StrAttr:$method, fir_BoxType:$object,
+               Variadic<AnyType>:$args)> {
+  let summary = "call a type-bound procedure";
+
+  let description = [{
+    Dynamic dispatch to the specified method.
+  }];
+
+  let parser = [{
+    M::FunctionType calleeType;
+    L::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    auto calleeLoc = parser.getNameLoc();
+    M::StringAttr calleeAttr;
+    if (parser.parseAttribute(calleeAttr, "method", result.attributes) ||
+        parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseColonType(calleeType) ||
+        parser.addTypesToList(calleeType.getResults(), result.types) ||
+        parser.resolveOperands(
+            operands, calleeType.getInputs(), calleeLoc, result.operands))
+      return M::failure();
+    return M::success();
+  }];
+  let printer = [{ 
+    p << getAttr("method") << '(';
+    p.printOperand(object());
+    if (arg_operand_begin() != arg_operand_end()) {
+      p << ", ";
+      p.printOperands(args());
+    }
+    p << ')';
+    p.printOptionalAttrDict(getAttrs(), {"method"});
+    llvm::SmallVector<mlir::Type, 2> resTy(getResultTypes());
+    llvm::SmallVector<mlir::Type, 8> argTy(getOperandTypes());
+    p << " : " << M::FunctionType::get(argTy, resTy, getContext());
+  }];
+  let extraClassDeclaration = [{
+    operand_range getArgOperands() {
+      return {arg_operand_begin(), arg_operand_end()};
+    }
+    operand_iterator arg_operand_begin() { return operand_begin() + 1; }
+    operand_iterator arg_operand_end() { return operand_end(); }
+  }];
+}
+
+// Other misc. operations
+
+def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
+  let summary = "convert a symbol to an SSA value";
+
+  let description = [{
+    Convert a symbol (a function or global reference) to an SSA-value to be
+    used in other Operations.
+  }];
+
+  let arguments = (ins SymbolRefAttr:$symbol);
+
+  let parser = [{
+    mlir::SymbolRefAttr attr;
+    mlir::Type type;
+    if (parser.parseLParen() ||
+        parser.parseAttribute(attr, "symbol", result.attributes) ||
+        parser.parseRParen() ||
+        parser.parseColonType(type) ||
+        parser.addTypeToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << " (" << getAttr("symbol") << ") : "
+      << getType();
+  }];
+}
+
+def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]>,
+    Arguments<(ins AnyType:$value)> {
+  let summary = "encapsulates all Fortran scalar type conversions";
+
+  let description = [{
+    Generalized type conversion. Not all pairs of types have conversions.
+  }];
+
+  let parser = [{
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 1> operands;
+    if (parser.parseOperandList(operands, 1,
+            mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperands(operands, type.getInputs(),
+            parser.getNameLoc(), result.operands) ||
+        parser.addTypesToList(type.getResults(), result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(value());
+    p << " : ";
+    p.printFunctionalType(getOperation());
+  }];
+}
+
+def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
+  let summary = "generate a type descriptor for a given type";
+
+  let description = [{
+    Generates a constant object that is an abstract type descriptor of the
+    specified type.  The meta-type of a type descriptor for the type `T`
+    is `!fir.tdesc<T>`.
+  }];
+
+  let parser = [{
+    mlir::Type intype;
+    if (parser.parseType(intype))
+      return mlir::failure();
+    auto &builder = parser.getBuilder();
+    result.addAttribute("in_type", builder.getTypeAttr(intype));
+    mlir::Type restype;
+    if (parser.parseColonType(restype) ||
+        parser.addTypeToList(restype, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr("in_type");
+    p << " : " << getType();
+    p.printOptionalAttrDict(getAttrs(), {"in_type"});
+  }];
+}
+
+def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
+    [SameOperandsAndResultType]>, Arguments<(ins fir_Type:$val)> {
+  let summary = "synthetic op to prevent reassociation";
+
+  let description = [{
+    The operation is to make sure that the Fortran optimizer does not
+    reassociate operations when they are syntactically surrounded by
+    parenthesis.
+  }];
+
+  let parser = [{
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType opnd;
+    if (parser.parseOperand(opnd) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(opnd, type, result.operands) ||
+        parser.addTypeToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+  let printer = [{
+    p << getOperationName() << ' ';
+    p.printOperand(val());
+    p << " : " << getType();
+  }];
+}
+
+def fir_GlobalEntryOp : fir_Op<"global_entry", []>,
+    Arguments<(ins StrAttr:$field, AnyType:$constant)> {
+  let summary = "map entry in a global";
+
+  let description = [{
+    An entry in a global.  Allows a constant to be bound to a specific
+    field in a record even though the layout of the record has not yet
+    been reified.
+  }];
+
+  let parser = [{
+    M::Type type;
+    M::StringAttr fieldAttr;
+    M::OpAsmParser::OperandType constant;
+    if (parser.parseAttribute(fieldAttr, "field", result.attributes) ||
+        parser.parseComma() ||
+        parser.parseOperand(constant) ||
+        parser.parseColonType(type) ||
+        parser.resolveOperand(constant, type, result.operands))
+      return M::failure();
+    result.addAttribute("in_type", parser.getBuilder().getTypeAttr(type));
+    return M::success();
+  }];
+  let printer = [{ 
+    p << getOperationName() << ' ' << getAttr("field") << ", ";
+    p.printOperand(constant());
+    p << " : " << getAttr("in_type");
+  }];
+}
+
+def fir_DTEntryOp : fir_Op<"dt_entry", []>,
+    Arguments<(ins StrAttr:$method, SymbolRefAttr:$proc)> {
+  let summary = "map entry in a dispatch table";
+
+  let description = [{
+    An entry in a dispatch table.  Allows a function symbol to be bound
+    to a specifier method identifier.  A dispatch operation uses the dynamic
+    type of a distinguished argument to determine an exact dispatch table
+    and uses the method identifier to select the type-bound procedure to
+    be called.
+  }];
+
+  let parser = [{
+    M::SymbolRefAttr calleeAttr;
+    M::StringAttr methodAttr;
+    if (parser.parseAttribute(methodAttr, "method", result.attributes) ||
+        parser.parseComma() ||
+        parser.parseAttribute(calleeAttr, "proc", result.attributes))
+      return M::failure();
+    return M::success();
+  }];
+  let printer = [{ 
+    p << getOperationName() << ' ' << getAttr("method") << ", "
+      << getAttr("proc");
+  }];
+}
+
+#endif
diff --git a/include/fir/Transforms/MemToReg.h b/include/fir/Transforms/MemToReg.h
new file mode 100644
index 000000000000..67e060ac0bfd
--- /dev/null
+++ b/include/fir/Transforms/MemToReg.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_TRANSFORMS_MEMTOREG_H
+#define FIR_TRANSFORMS_MEMTOREG_H
+
+/// A pass to convert the FIR dialect from "Mem-SSA" form to "Reg-SSA"
+/// form. This pass is a port of LLVM's mem2reg pass, but modified for the FIR
+/// dialect as well as the restructuring of MLIR's representation to present PHI
+/// nodes as block arguments.
+
+#include <memory>
+
+namespace mlir {
+template <typename>
+class OpPassBase;
+class FuncOp;
+using FunctionPassBase = OpPassBase<FuncOp>;
+} // namespace mlir
+
+namespace fir {
+
+/// Creates a pass to convert FIR into a reg SSA form
+std::unique_ptr<mlir::FunctionPassBase> createMemToRegPass();
+
+} // namespace fir
+
+#endif // FIR_TRANSFORMS_MEMTOREG_H
diff --git a/include/fir/Type.h b/include/fir/Type.h
new file mode 100644
index 000000000000..0f423f4dbaf5
--- /dev/null
+++ b/include/fir/Type.h
@@ -0,0 +1,277 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_TYPE_H
+#define FIR_TYPE_H
+
+#include "mlir/IR/Types.h"
+
+namespace llvm {
+class StringRef;
+template <typename>
+class ArrayRef;
+class hash_code;
+} // namespace llvm
+
+namespace fir {
+
+class FIROpsDialect;
+
+using KindTy = int;
+
+namespace detail {
+struct BoxTypeStorage;
+struct BoxCharTypeStorage;
+struct BoxProcTypeStorage;
+struct CharacterTypeStorage;
+struct CplxTypeStorage;
+struct DimsTypeStorage;
+struct FieldTypeStorage;
+struct HeapTypeStorage;
+struct IntTypeStorage;
+struct LogicalTypeStorage;
+struct PointerTypeStorage;
+struct RealTypeStorage;
+struct RecordTypeStorage;
+struct ReferenceTypeStorage;
+struct SequenceTypeStorage;
+struct TypeDescTypeStorage;
+} // namespace detail
+
+enum TypeKind {
+  // The enum starts at the range reserved for this dialect.
+  FIR_TYPE = mlir::Type::FIRST_FIR_TYPE,
+  FIR_BOX,
+  FIR_BOXCHAR,
+  FIR_BOXPROC,
+  FIR_CHARACTER, // intrinsic
+  FIR_COMPLEX,   // intrinsic
+  FIR_DERIVED,   // derived
+  FIR_DIMS,
+  FIR_FIELD,
+  FIR_HEAP,
+  FIR_INT,     // intrinsic
+  FIR_LOGICAL, // intrinsic
+  FIR_POINTER,
+  FIR_REAL, // intrinsic
+  FIR_REFERENCE,
+  FIR_SEQUENCE,
+  FIR_TYPEDESC,
+};
+
+bool isa_fir_type(mlir::Type);
+bool isa_std_type(mlir::Type t);
+bool isa_fir_or_std_type(mlir::Type t);
+
+template <typename A, unsigned Id>
+struct IntrinsicTypeMixin {
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() { return Id; }
+};
+
+class CharacterType
+    : public mlir::Type::TypeBase<CharacterType, mlir::Type,
+                                  detail::CharacterTypeStorage>,
+      public IntrinsicTypeMixin<CharacterType, TypeKind::FIR_CHARACTER> {
+public:
+  using Base::Base;
+  static CharacterType get(mlir::MLIRContext *ctxt, KindTy kind);
+  int getSizeInBits() const;
+  KindTy getFKind() const { return getSizeInBits() / 8; }
+};
+
+class IntType
+    : public mlir::Type::TypeBase<IntType, mlir::Type, detail::IntTypeStorage>,
+      public IntrinsicTypeMixin<IntType, TypeKind::FIR_INT> {
+public:
+  using Base::Base;
+  static IntType get(mlir::MLIRContext *ctxt, KindTy kind);
+  int getSizeInBits() const;
+  KindTy getFKind() const { return getSizeInBits() / 8; }
+};
+
+class LogicalType
+    : public mlir::Type::TypeBase<LogicalType, mlir::Type,
+                                  detail::LogicalTypeStorage>,
+      public IntrinsicTypeMixin<LogicalType, TypeKind::FIR_LOGICAL> {
+public:
+  using Base::Base;
+  static LogicalType get(mlir::MLIRContext *ctxt, KindTy kind);
+  int getSizeInBits() const;
+  KindTy getFKind() const { return getSizeInBits() / 8; }
+};
+
+class RealType : public mlir::Type::TypeBase<RealType, mlir::Type,
+                                             detail::RealTypeStorage>,
+                 public IntrinsicTypeMixin<RealType, TypeKind::FIR_REAL> {
+public:
+  using Base::Base;
+  static RealType get(mlir::MLIRContext *ctxt, KindTy kind);
+  int getSizeInBits() const;
+  KindTy getFKind() const { return getSizeInBits() / 8; }
+};
+
+class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
+                                             detail::CplxTypeStorage>,
+                 public IntrinsicTypeMixin<CplxType, TypeKind::FIR_COMPLEX> {
+public:
+  using Base::Base;
+  static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
+  int getSizeInBits() const;
+  KindTy getFKind() const;
+};
+
+// FIR support types
+
+class BoxType
+    : public mlir::Type::TypeBase<BoxType, mlir::Type, detail::BoxTypeStorage> {
+public:
+  using Base::Base;
+  static BoxType get(mlir::Type eleTy);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOX; }
+  mlir::Type getEleTy() const;
+};
+
+class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
+                                                detail::BoxCharTypeStorage> {
+public:
+  using Base::Base;
+  static BoxCharType get(mlir::MLIRContext *ctxt, KindTy kind);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXCHAR; }
+  CharacterType getEleTy() const;
+};
+
+class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
+                                                detail::BoxProcTypeStorage> {
+public:
+  using Base::Base;
+  static BoxProcType get(mlir::Type eleTy);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXPROC; }
+  mlir::Type getEleTy() const;
+};
+
+class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
+                                             detail::DimsTypeStorage> {
+public:
+  using Base::Base;
+  static DimsType get(mlir::MLIRContext *ctx, unsigned rank);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_DIMS; }
+
+  /// returns -1 if the rank is unknown
+  int getRank() const;
+};
+
+class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
+                                              detail::FieldTypeStorage> {
+public:
+  using Base::Base;
+  static FieldType get(mlir::MLIRContext *ctxt, KindTy _ = 0);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_FIELD; }
+};
+
+class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
+                                             detail::HeapTypeStorage> {
+public:
+  using Base::Base;
+  static HeapType get(mlir::Type elementType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_HEAP; }
+
+  mlir::Type getEleTy() const;
+};
+
+class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
+                                                detail::PointerTypeStorage> {
+public:
+  using Base::Base;
+  static PointerType get(mlir::Type elementType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_POINTER; }
+
+  mlir::Type getEleTy() const;
+};
+
+class ReferenceType
+    : public mlir::Type::TypeBase<ReferenceType, mlir::Type,
+                                  detail::ReferenceTypeStorage> {
+public:
+  using Base::Base;
+  static ReferenceType get(mlir::Type elementType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_REFERENCE; }
+
+  mlir::Type getEleTy() const;
+};
+
+class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
+                                                 detail::SequenceTypeStorage> {
+public:
+  using Base::Base;
+  using BoundInfo = int64_t;
+  struct Extent {
+    bool known;
+    BoundInfo bound;
+    explicit Extent(bool k, BoundInfo b) : known(k), bound(b) {}
+  };
+  using Bounds = std::vector<Extent>;
+  struct Shape {
+    bool known;
+    Bounds bounds;
+    Shape() : known(false) {}
+    Shape(const Bounds &b) : known(true), bounds(b) {}
+  };
+
+  mlir::Type getEleTy() const;
+  Shape getShape() const;
+
+  static SequenceType get(const Shape &shape, mlir::Type elementType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
+};
+
+bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
+llvm::hash_code hash_value(const SequenceType::Extent &);
+llvm::hash_code hash_value(const SequenceType::Shape &);
+
+class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
+                                                 detail::TypeDescTypeStorage> {
+public:
+  using Base::Base;
+  static TypeDescType get(mlir::Type ofType);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_TYPEDESC; }
+  mlir::Type getOfTy() const;
+};
+
+// Derived types
+
+class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
+                                               detail::RecordTypeStorage> {
+public:
+  using Base::Base;
+  using TypePair = std::pair<std::string, mlir::Type>;
+  using TypeList = std::vector<TypePair>;
+
+  llvm::StringRef getName();
+  TypeList getTypeList();
+  TypeList getLenParamList();
+
+  static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name,
+                        llvm::ArrayRef<TypePair> lenPList = {},
+                        llvm::ArrayRef<TypePair> typeList = {});
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() { return TypeKind::FIR_DERIVED; }
+};
+
+mlir::Type parseFirType(FIROpsDialect *dialect, llvm::StringRef rawData,
+                        mlir::Location loc);
+
+} // namespace fir
+
+#endif // FIR_TYPE_H
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index ae321b872a76..cf1b80fd565a 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -3,8 +3,5 @@ add_subdirectory(Evaluate)
 add_subdirectory(Decimal)
 add_subdirectory(Lower)
 add_subdirectory(Parser)
+add_subdirectory(Optimizer)
 add_subdirectory(Semantics)
-
-if(LINK_WITH_FIR)
-  add_subdirectory(Optimizer)
-endif()
diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
new file mode 100644
index 000000000000..c9c99ae0315b
--- /dev/null
+++ b/lib/burnside/CMakeLists.txt
@@ -0,0 +1,25 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+
+add_library(FortranBurnside
+  flattened.cc
+)
+
+install (TARGETS FortranBurnside
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+  RUNTIME DESTINATION bin
+)
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
new file mode 100644
index 000000000000..2e13a0f76153
--- /dev/null
+++ b/lib/burnside/builder.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_BUILDER_H_
+#define FORTRAN_BURNSIDE_BUILDER_H_
+
+#include "../semantics/symbol.h"
+#include "llvm/ADT/DenseMap.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Function.h"
+#include "mlir/IR/Module.h"
+#include <string>
+
+namespace llvm {
+class StringRef;
+}
+
+namespace Fortran::burnside {
+
+/// Miscellaneous helper routines for building MLIR
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+class SymMap {
+  llvm::DenseMap<const semantics::Symbol *, mlir::Value *> symbolMap;
+
+public:
+  void addSymbol(const semantics::Symbol *symbol, mlir::Value *value);
+
+  mlir::Value *lookupSymbol(const semantics::Symbol *symbol);
+};
+
+std::string applyNameMangling(llvm::StringRef parserName);
+
+/// Get the current Module
+inline mlir::ModuleOp getModule(mlir::OpBuilder *bldr) {
+  return bldr->getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
+}
+
+/// Get the current Function
+inline mlir::FuncOp getFunction(mlir::OpBuilder *bldr) {
+  return bldr->getBlock()->getParent()->getParentOfType<mlir::FuncOp>();
+}
+
+/// Get the entry block of the current Function
+inline mlir::Block *getEntryBlock(mlir::OpBuilder *bldr) {
+  return &getFunction(bldr).front();
+}
+
+/// Create a new basic block
+inline mlir::Block *createBlock(mlir::OpBuilder *bldr, mlir::Region *region) {
+  return bldr->createBlock(region, region->end());
+}
+
+inline mlir::Block *createBlock(mlir::OpBuilder *bldr) {
+  return createBlock(bldr, bldr->getBlock()->getParent());
+}
+
+/// Get a function by name (or null)
+mlir::FuncOp getNamedFunction(llvm::StringRef name);
+
+/// Create a new Function
+mlir::FuncOp createFunction(
+    mlir::ModuleOp module, llvm::StringRef name, mlir::FunctionType funcTy);
+
+}  // Fortran::burnside
+
+#endif  // FORTRAN_BURNSIDE_BUILDER_H_
diff --git a/lib/burnside/flattened.cc b/lib/burnside/flattened.cc
new file mode 100644
index 000000000000..387cf3f377d4
--- /dev/null
+++ b/lib/burnside/flattened.cc
@@ -0,0 +1,695 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "flattened.h"
+#include "../parser/parse-tree-visitor.h"
+#include "../semantics/symbol.h"
+
+namespace Fortran::burnside {
+namespace flat {
+
+// Labels are numbered [0 .. `n`] consecutively. They are unsigned. Not all
+// labels are numbered. The unnumbered ones are given the value UINT_MAX. `n`
+// should never approach UINT_MAX.
+LabelBuilder::LabelBuilder() : referenced(32), counter{0u} {}
+
+LabelRef LabelBuilder::getNext() {
+  LabelRef next{counter++};
+  auto cap{referenced.size()};
+  if (cap < counter) {
+    referenced.resize(2 * cap);
+  }
+  referenced.reset(next);
+  return next;
+}
+
+void LabelBuilder::setReferenced(LabelRef label) {
+  CHECK(label < referenced.getBitCapacity());
+  referenced.set(label);
+}
+
+bool LabelBuilder::isReferenced(LabelRef label) const {
+  CHECK(label < referenced.getBitCapacity());
+  return referenced.test(label);
+}
+
+LabelOp::LabelOp(LabelBuilder &builder)
+  : builder{builder}, label{builder.getNext()} {}
+
+LabelOp::LabelOp(const LabelOp &that)
+  : builder{that.builder}, label{that.label} {}
+
+LabelOp &LabelOp::operator=(const LabelOp &that) {
+  CHECK(&builder == &that.builder);
+  label = that.label;
+  return *this;
+}
+
+void LabelOp::setReferenced() const { builder.setReferenced(label); }
+
+bool LabelOp::isReferenced() const { return builder.isReferenced(label); }
+
+static void AddAssign(AnalysisData &ad, const semantics::Symbol *symbol,
+    const parser::Label &label) {
+  ad.assignMap[symbol].insert(label);
+}
+
+std::vector<LabelRef> GetAssign(
+    AnalysisData &ad, const semantics::Symbol *symbol) {
+  std::vector<LabelRef> result;
+  for (auto lab : ad.assignMap[symbol]) {
+    result.emplace_back(lab);
+  }
+  return result;
+}
+
+static std::tuple<const parser::Name *, LabelRef, LabelRef> FindStack(
+    const std::vector<std::tuple<const parser::Name *, LabelRef, LabelRef>>
+        &stack,
+    const parser::Name *key) {
+  for (auto iter{stack.rbegin()}, iend{stack.rend()}; iter != iend; ++iter) {
+    if (std::get<0>(*iter) == key) {
+      return *iter;
+    }
+  }
+  assert(false && "construct name not on stack");
+  return {};
+}
+
+LabelOp FetchLabel(AnalysisData &ad, const parser::Label &label) {
+  auto iter{ad.labelMap.find(label)};
+  if (iter == ad.labelMap.end()) {
+    LabelOp ll{ad.labelBuilder};
+    ll.setReferenced();
+    ad.labelMap.insert({label, ll});
+    return ll;
+  }
+  return iter->second;
+}
+
+static LabelOp BuildNewLabel(AnalysisData &ad) {
+  return LabelOp{ad.labelBuilder};
+}
+
+template<typename A> parser::Label GetErr(const A &stmt) {
+  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
+      std::is_same_v<A, parser::WriteStmt>) {
+    for (const auto &control : stmt.controls) {
+      if (std::holds_alternative<parser::ErrLabel>(control.u)) {
+        return std::get<parser::ErrLabel>(control.u).v;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, parser::WaitStmt> ||
+      std::is_same_v<A, parser::OpenStmt> ||
+      std::is_same_v<A, parser::CloseStmt> ||
+      std::is_same_v<A, parser::BackspaceStmt> ||
+      std::is_same_v<A, parser::EndfileStmt> ||
+      std::is_same_v<A, parser::RewindStmt> ||
+      std::is_same_v<A, parser::FlushStmt>) {
+    for (const auto &spec : stmt.v) {
+      if (std::holds_alternative<parser::ErrLabel>(spec.u)) {
+        return std::get<parser::ErrLabel>(spec.u).v;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, parser::InquireStmt>) {
+    for (const auto &spec : std::get<std::list<parser::InquireSpec>>(stmt.u)) {
+      if (std::holds_alternative<parser::ErrLabel>(spec.u)) {
+        return std::get<parser::ErrLabel>(spec.u).v;
+      }
+    }
+  }
+  return 0;
+}
+
+template<typename A> parser::Label GetEor(const A &stmt) {
+  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
+      std::is_same_v<A, parser::WriteStmt>) {
+    for (const auto &control : stmt.controls) {
+      if (std::holds_alternative<parser::EorLabel>(control.u)) {
+        return std::get<parser::EorLabel>(control.u).v;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, parser::WaitStmt>) {
+    for (const auto &waitSpec : stmt.v) {
+      if (std::holds_alternative<parser::EorLabel>(waitSpec.u)) {
+        return std::get<parser::EorLabel>(waitSpec.u).v;
+      }
+    }
+  }
+  return 0;
+}
+
+template<typename A> parser::Label GetEnd(const A &stmt) {
+  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
+      std::is_same_v<A, parser::WriteStmt>) {
+    for (const auto &control : stmt.controls) {
+      if (std::holds_alternative<parser::EndLabel>(control.u)) {
+        return std::get<parser::EndLabel>(control.u).v;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, parser::WaitStmt>) {
+    for (const auto &waitSpec : stmt.v) {
+      if (std::holds_alternative<parser::EndLabel>(waitSpec.u)) {
+        return std::get<parser::EndLabel>(waitSpec.u).v;
+      }
+    }
+  }
+  return 0;
+}
+
+template<typename A>
+void errLabelSpec(const A &s, std::list<Op> &ops,
+    const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
+  if (auto errLab{GetErr(s)}) {
+    std::optional<LabelRef> errRef{FetchLabel(ad, errLab).get()};
+    LabelOp next{BuildNewLabel(ad)};
+    ops.emplace_back(SwitchIOOp{s, next, ec.source, errRef});
+    ops.emplace_back(next);
+  } else {
+    ops.emplace_back(ActionOp{ec});
+  }
+}
+
+template<typename A>
+void threeLabelSpec(const A &s, std::list<Op> &ops,
+    const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
+  auto errLab{GetErr(s)};
+  auto eorLab{GetEor(s)};
+  auto endLab{GetEnd(s)};
+  if (errLab || eorLab || endLab) {
+    std::optional<LabelRef> errRef;
+    if (errLab) {
+      errRef = FetchLabel(ad, errLab).get();
+    }
+    std::optional<LabelRef> eorRef;
+    if (eorLab) {
+      eorRef = FetchLabel(ad, eorLab).get();
+    }
+    std::optional<LabelRef> endRef;
+    if (endLab) {
+      endRef = FetchLabel(ad, endLab).get();
+    }
+    auto next{BuildNewLabel(ad)};
+    ops.emplace_back(SwitchIOOp{s, next, ec.source, errRef, eorRef, endRef});
+    ops.emplace_back(next);
+  } else {
+    ops.emplace_back(ActionOp{ec});
+  }
+}
+
+template<typename A>
+std::vector<LabelRef> toLabelRef(AnalysisData &ad, const A &labels) {
+  std::vector<LabelRef> result;
+  for (auto label : labels) {
+    result.emplace_back(FetchLabel(ad, label).get());
+  }
+  CHECK(result.size() == labels.size());
+  return result;
+}
+
+template<typename A>
+std::vector<LabelRef> toLabelRef(
+    const LabelOp &next, AnalysisData &ad, const A &labels) {
+  std::vector<LabelRef> result;
+  result.emplace_back(next);
+  auto refs{toLabelRef(ad, labels)};
+  result.insert(result.end(), refs.begin(), refs.end());
+  CHECK(result.size() == labels.size() + 1);
+  return result;
+}
+
+static bool hasAltReturns(const parser::CallStmt &callStmt) {
+  const auto &args{std::get<std::list<parser::ActualArgSpec>>(callStmt.v.t)};
+  for (const auto &arg : args) {
+    const auto &actual{std::get<parser::ActualArg>(arg.t)};
+    if (std::holds_alternative<parser::AltReturnSpec>(actual.u)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static std::list<parser::Label> getAltReturnLabels(const parser::Call &call) {
+  std::list<parser::Label> result;
+  const auto &args{std::get<std::list<parser::ActualArgSpec>>(call.t)};
+  for (const auto &arg : args) {
+    const auto &actual{std::get<parser::ActualArg>(arg.t)};
+    if (const auto *p{std::get_if<parser::AltReturnSpec>(&actual.u)}) {
+      result.push_back(p->v);
+    }
+  }
+  return result;
+}
+
+static LabelRef NearestEnclosingDoConstruct(AnalysisData &ad) {
+  for (auto iterator{ad.constructContextStack.rbegin()},
+       endIterator{ad.constructContextStack.rend()};
+       iterator != endIterator; ++iterator) {
+    auto labelReference{std::get<2>(*iterator)};
+    if (labelReference != UnspecifiedLabel) {
+      return labelReference;
+    }
+  }
+  assert(false && "CYCLE|EXIT not in loop");
+  return UnspecifiedLabel;
+}
+
+template<typename A> std::string GetSource(const A *s) {
+  return s->source.ToString();
+}
+
+template<typename A, typename B> std::string GetSource(const B *s) {
+  return GetSource(&std::get<parser::Statement<A>>(s->t));
+}
+
+void Op::Build(std::list<Op> &ops,
+    const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
+  std::visit(
+      common::visitors{
+          [&](const auto &) { ops.emplace_back(ActionOp{ec}); },
+          [&](const common::Indirection<parser::CallStmt> &s) {
+            if (hasAltReturns(s.value())) {
+              auto next{BuildNewLabel(ad)};
+              auto alts{getAltReturnLabels(s.value().v)};
+              auto labels{toLabelRef(next, ad, alts)};
+              ops.emplace_back(
+                  SwitchOp{s.value(), std::move(labels), ec.source});
+              ops.emplace_back(next);
+            } else {
+              ops.emplace_back(ActionOp{ec});
+            }
+          },
+          [&](const common::Indirection<parser::AssignStmt> &s) {
+            AddAssign(ad, std::get<parser::Name>(s.value().t).symbol,
+                std::get<parser::Label>(s.value().t));
+            ops.emplace_back(ActionOp{ec});
+          },
+          [&](const common::Indirection<parser::CycleStmt> &s) {
+            ops.emplace_back(GotoOp{s.value(),
+                s.value().v ? std::get<2>(FindStack(ad.constructContextStack,
+                                  &s.value().v.value()))
+                            : NearestEnclosingDoConstruct(ad),
+                ec.source});
+          },
+          [&](const common::Indirection<parser::ExitStmt> &s) {
+            ops.emplace_back(GotoOp{s.value(),
+                s.value().v ? std::get<1>(FindStack(ad.constructContextStack,
+                                  &s.value().v.value()))
+                            : NearestEnclosingDoConstruct(ad),
+                ec.source});
+          },
+          [&](const common::Indirection<parser::GotoStmt> &s) {
+            ops.emplace_back(GotoOp{
+                s.value(), FetchLabel(ad, s.value().v).get(), ec.source});
+          },
+          [&](const parser::FailImageStmt &s) {
+            ops.emplace_back(ReturnOp{s, ec.source});
+          },
+          [&](const common::Indirection<parser::ReturnStmt> &s) {
+            ops.emplace_back(ReturnOp{s.value(), ec.source});
+          },
+          [&](const common::Indirection<parser::StopStmt> &s) {
+            ops.emplace_back(ActionOp{ec});
+            ops.emplace_back(ReturnOp{s.value(), ec.source});
+          },
+          [&](const common::Indirection<const parser::ReadStmt> &s) {
+            threeLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::WriteStmt> &s) {
+            threeLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::WaitStmt> &s) {
+            threeLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::OpenStmt> &s) {
+            errLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::CloseStmt> &s) {
+            errLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::BackspaceStmt> &s) {
+            errLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::EndfileStmt> &s) {
+            errLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::RewindStmt> &s) {
+            errLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::FlushStmt> &s) {
+            errLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<const parser::InquireStmt> &s) {
+            errLabelSpec(s.value(), ops, ec, ad);
+          },
+          [&](const common::Indirection<parser::ComputedGotoStmt> &s) {
+            auto next{BuildNewLabel(ad)};
+            auto labels{toLabelRef(
+                next, ad, std::get<std::list<parser::Label>>(s.value().t))};
+            ops.emplace_back(SwitchOp{s.value(), std::move(labels), ec.source});
+            ops.emplace_back(next);
+          },
+          [&](const common::Indirection<parser::ArithmeticIfStmt> &s) {
+            ops.emplace_back(SwitchOp{s.value(),
+                toLabelRef(ad,
+                    std::list{std::get<1>(s.value().t),
+                        std::get<2>(s.value().t), std::get<3>(s.value().t)}),
+                ec.source});
+          },
+          [&](const common::Indirection<parser::AssignedGotoStmt> &s) {
+            ops.emplace_back(
+                IndirectGotoOp{std::get<parser::Name>(s.value().t).symbol,
+                    toLabelRef(
+                        ad, std::get<std::list<parser::Label>>(s.value().t))});
+          },
+          [&](const common::Indirection<parser::IfStmt> &s) {
+            auto then{BuildNewLabel(ad)};
+            auto endif{BuildNewLabel(ad)};
+            ops.emplace_back(ConditionalGotoOp{s.value(), then, endif});
+            ops.emplace_back(then);
+            ops.emplace_back(ActionOp{ec});
+            ops.emplace_back(endif);
+          },
+      },
+      ec.statement.u);
+}
+
+template<typename> struct ElementMap;
+template<> struct ElementMap<parser::CaseConstruct> {
+  using type = parser::CaseConstruct::Case;
+};
+template<> struct ElementMap<parser::SelectRankConstruct> {
+  using type = parser::SelectRankConstruct::RankCase;
+};
+template<> struct ElementMap<parser::SelectTypeConstruct> {
+  using type = parser::SelectTypeConstruct::TypeCase;
+};
+
+struct ControlFlowAnalyzer {
+  explicit ControlFlowAnalyzer(std::list<Op> &ops, AnalysisData &ad)
+    : linearOps{ops}, ad{ad} {}
+
+  LabelOp buildNewLabel() { return BuildNewLabel(ad); }
+
+  Op findLabel(const parser::Label &lab) {
+    auto iter{ad.labelMap.find(lab)};
+    if (iter == ad.labelMap.end()) {
+      LabelOp ll{ad.labelBuilder};
+      ad.labelMap.insert({lab, ll});
+      return {ll};
+    }
+    return {iter->second};
+  }
+
+  template<typename A> constexpr bool Pre(const A &) { return true; }
+  template<typename A> constexpr void Post(const A &) {}
+
+  template<typename A> bool Pre(const parser::Statement<A> &stmt) {
+    if (stmt.label) {
+      linearOps.emplace_back(findLabel(*stmt.label));
+    }
+    if constexpr (std::is_same_v<A, parser::ActionStmt>) {
+      Op::Build(linearOps, stmt, ad);
+    }
+    return true;
+  }
+  template<typename A>
+  void appendIfLabeled(const parser::Statement<A> &stmt, std::list<Op> &ops) {
+    if (stmt.label) {
+      ops.emplace_back(findLabel(*stmt.label));
+    }
+  }
+
+  // named constructs
+  template<typename A> bool linearConstruct(const A &construct) {
+    std::list<Op> ops;
+    LabelOp label{buildNewLabel()};
+    const parser::Name *name{getName(construct)};
+    ad.constructContextStack.emplace_back(
+        name, GetLabelRef(label), UnspecifiedLabel);
+    appendIfLabeled(std::get<0>(construct.t), ops);
+    ops.emplace_back(BeginOp{construct});
+    ControlFlowAnalyzer cfa{ops, ad};
+    Walk(std::get<parser::Block>(construct.t), cfa);
+    ops.emplace_back(label);
+    appendIfLabeled(std::get<2>(construct.t), ops);
+    ops.emplace_back(EndOp{construct});
+    linearOps.splice(linearOps.end(), ops);
+    ad.constructContextStack.pop_back();
+    return false;
+  }
+
+  bool Pre(const parser::AssociateConstruct &c) { return linearConstruct(c); }
+  bool Pre(const parser::ChangeTeamConstruct &c) { return linearConstruct(c); }
+  bool Pre(const parser::CriticalConstruct &c) { return linearConstruct(c); }
+
+  bool Pre(const parser::BlockConstruct &construct) {
+    std::list<Op> ops;
+    LabelOp label{buildNewLabel()};
+    const auto &optName{
+        std::get<parser::Statement<parser::BlockStmt>>(construct.t)
+            .statement.v};
+    const parser::Name *name{optName ? &*optName : nullptr};
+    ad.constructContextStack.emplace_back(
+        name, GetLabelRef(label), UnspecifiedLabel);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::BlockStmt>>(construct.t), ops);
+    ops.emplace_back(BeginOp{construct});
+    ControlFlowAnalyzer cfa{ops, ad};
+    Walk(std::get<parser::Block>(construct.t), cfa);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::EndBlockStmt>>(construct.t), ops);
+    ops.emplace_back(EndOp{construct});
+    ops.emplace_back(label);
+    linearOps.splice(linearOps.end(), ops);
+    ad.constructContextStack.pop_back();
+    return false;
+  }
+
+  /// `DO` constructs can be lowered to `fir.loop` if they meet some
+  /// constraints, otherwise they are lowered to a CFG.
+  bool Pre(const parser::DoConstruct &construct) {
+    std::list<Op> ops;
+    LabelOp backedgeLab{buildNewLabel()};
+    LabelOp incrementLab{buildNewLabel()};
+    LabelOp entryLab{buildNewLabel()};
+    LabelOp exitLab{buildNewLabel()};
+    const parser::Name *name{getName(construct)};
+    LabelRef exitOpRef{GetLabelRef(exitLab)};
+    ad.constructContextStack.emplace_back(
+        name, exitOpRef, GetLabelRef(incrementLab));
+    appendIfLabeled(
+        std::get<parser::Statement<parser::NonLabelDoStmt>>(construct.t), ops);
+    ops.emplace_back(BeginOp{construct});
+    ops.emplace_back(GotoOp{GetLabelRef(backedgeLab)});
+    ops.emplace_back(incrementLab);
+    ops.emplace_back(DoIncrementOp{construct});
+    ops.emplace_back(backedgeLab);
+    ops.emplace_back(DoCompareOp{construct});
+    ops.emplace_back(ConditionalGotoOp{
+        std::get<parser::Statement<parser::NonLabelDoStmt>>(construct.t),
+        GetLabelRef(entryLab), exitOpRef});
+    ops.push_back(entryLab);
+    ControlFlowAnalyzer cfa{ops, ad};
+    Walk(std::get<parser::Block>(construct.t), cfa);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::EndDoStmt>>(construct.t), ops);
+    ops.emplace_back(GotoOp{GetLabelRef(incrementLab)});
+    ops.emplace_back(EndOp{construct});
+    ops.emplace_back(exitLab);
+    linearOps.splice(linearOps.end(), ops);
+    ad.constructContextStack.pop_back();
+    return false;
+  }
+
+  /// `IF` constructs can be lowered to `fir.where` if they meet some
+  /// constraints, otherwise they are lowered to a CFG.
+  bool Pre(const parser::IfConstruct &construct) {
+    std::list<Op> ops;
+    LabelOp thenLab{buildNewLabel()};
+    LabelOp elseLab{buildNewLabel()};
+    LabelOp exitLab{buildNewLabel()};
+    const parser::Name *name{getName(construct)};
+    ad.constructContextStack.emplace_back(
+        name, GetLabelRef(exitLab), UnspecifiedLabel);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::IfThenStmt>>(construct.t), ops);
+    ops.emplace_back(BeginOp{construct});
+    ops.emplace_back(ConditionalGotoOp{
+        std::get<parser::Statement<parser::IfThenStmt>>(construct.t),
+        GetLabelRef(thenLab), GetLabelRef(elseLab)});
+    ops.emplace_back(thenLab);
+    ControlFlowAnalyzer cfa{ops, ad};
+    Walk(std::get<parser::Block>(construct.t), cfa);
+    LabelRef exitOpRef{GetLabelRef(exitLab)};
+    ops.emplace_back(GotoOp{exitOpRef});
+    for (const auto &elseIfBlock :
+        std::get<std::list<parser::IfConstruct::ElseIfBlock>>(construct.t)) {
+      appendIfLabeled(
+          std::get<parser::Statement<parser::ElseIfStmt>>(elseIfBlock.t), ops);
+      ops.emplace_back(elseLab);
+      LabelOp newThenLab{buildNewLabel()};
+      LabelOp newElseLab{buildNewLabel()};
+      ops.emplace_back(ConditionalGotoOp{
+          std::get<parser::Statement<parser::ElseIfStmt>>(elseIfBlock.t),
+          GetLabelRef(newThenLab), GetLabelRef(newElseLab)});
+      ops.emplace_back(newThenLab);
+      Walk(std::get<parser::Block>(elseIfBlock.t), cfa);
+      ops.emplace_back(GotoOp{exitOpRef});
+      elseLab = newElseLab;
+    }
+    ops.emplace_back(elseLab);
+    if (const auto &optElseBlock{
+            std::get<std::optional<parser::IfConstruct::ElseBlock>>(
+                construct.t)}) {
+      appendIfLabeled(
+          std::get<parser::Statement<parser::ElseStmt>>(optElseBlock->t), ops);
+      Walk(std::get<parser::Block>(optElseBlock->t), cfa);
+    }
+    ops.emplace_back(GotoOp{exitOpRef});
+    ops.emplace_back(exitLab);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::EndIfStmt>>(construct.t), ops);
+    ops.emplace_back(EndOp{construct});
+    linearOps.splice(linearOps.end(), ops);
+    ad.constructContextStack.pop_back();
+    return false;
+  }
+
+  template<typename A> bool Multiway(const A &construct) {
+    using B = typename ElementMap<A>::type;
+    std::list<Op> ops;
+    LabelOp exitLab{buildNewLabel()};
+    const parser::Name *name{getName(construct)};
+    ad.constructContextStack.emplace_back(
+        name, GetLabelRef(exitLab), UnspecifiedLabel);
+    appendIfLabeled(std::get<0>(construct.t), ops);
+    ops.emplace_back(BeginOp{construct});
+    const auto N{std::get<std::list<B>>(construct.t).size()};
+    LabelRef exitOpRef{GetLabelRef(exitLab)};
+    if (N > 0) {
+      typename std::list<B>::size_type i;
+      std::vector<LabelOp> toLabels;
+      for (i = 0; i != N; ++i) {
+        toLabels.emplace_back(buildNewLabel());
+      }
+      std::vector<LabelRef> targets;
+      for (i = 0; i != N; ++i) {
+        targets.emplace_back(GetLabelRef(toLabels[i]));
+      }
+      ops.emplace_back(
+          SwitchOp{construct, targets, std::get<0>(construct.t).source});
+      ControlFlowAnalyzer cfa{ops, ad};
+      i = 0;
+      for (const auto &caseBlock : std::get<std::list<B>>(construct.t)) {
+        ops.emplace_back(toLabels[i++]);
+        appendIfLabeled(std::get<0>(caseBlock.t), ops);
+        Walk(std::get<parser::Block>(caseBlock.t), cfa);
+        ops.emplace_back(GotoOp{exitOpRef});
+      }
+    }
+    ops.emplace_back(exitLab);
+    appendIfLabeled(std::get<2>(construct.t), ops);
+    ops.emplace_back(EndOp{construct});
+    linearOps.splice(linearOps.end(), ops);
+    ad.constructContextStack.pop_back();
+    return false;
+  }
+
+  bool Pre(const parser::CaseConstruct &c) { return Multiway(c); }
+  bool Pre(const parser::SelectRankConstruct &c) { return Multiway(c); }
+  bool Pre(const parser::SelectTypeConstruct &c) { return Multiway(c); }
+
+  bool Pre(const parser::WhereConstruct &c) {
+    std::list<Op> ops;
+    LabelOp label{buildNewLabel()};
+    const parser::Name *name{getName(c)};
+    ad.constructContextStack.emplace_back(
+        name, GetLabelRef(label), UnspecifiedLabel);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::WhereConstructStmt>>(c.t), ops);
+    ops.emplace_back(BeginOp{c});
+    ControlFlowAnalyzer cfa{ops, ad};
+    Walk(std::get<std::list<parser::WhereBodyConstruct>>(c.t), cfa);
+    Walk(
+        std::get<std::list<parser::WhereConstruct::MaskedElsewhere>>(c.t), cfa);
+    Walk(std::get<std::optional<parser::WhereConstruct::Elsewhere>>(c.t), cfa);
+    ops.emplace_back(label);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::EndWhereStmt>>(c.t), ops);
+    ops.emplace_back(EndOp{c});
+    linearOps.splice(linearOps.end(), ops);
+    ad.constructContextStack.pop_back();
+    return false;
+  }
+
+  bool Pre(const parser::ForallConstruct &construct) {
+    std::list<Op> ops;
+    LabelOp label{buildNewLabel()};
+    const parser::Name *name{getName(construct)};
+    ad.constructContextStack.emplace_back(
+        name, GetLabelRef(label), UnspecifiedLabel);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::ForallConstructStmt>>(construct.t),
+        ops);
+    ops.emplace_back(BeginOp{construct});
+    ControlFlowAnalyzer cfa{ops, ad};
+    Walk(std::get<std::list<parser::ForallBodyConstruct>>(construct.t), cfa);
+    ops.emplace_back(label);
+    appendIfLabeled(
+        std::get<parser::Statement<parser::EndForallStmt>>(construct.t), ops);
+    ops.emplace_back(EndOp{construct});
+    linearOps.splice(linearOps.end(), ops);
+    ad.constructContextStack.pop_back();
+    return false;
+  }
+
+  template<typename A> const parser::Name *getName(const A &a) {
+    const auto &optName{std::get<0>(std::get<0>(a.t).statement.t)};
+    return optName ? &*optName : nullptr;
+  }
+
+  LabelRef GetLabelRef(const LabelOp &label) {
+    label.setReferenced();
+    return label;
+  }
+
+  LabelRef GetLabelRef(const parser::Label &label) {
+    return FetchLabel(ad, label);
+  }
+
+  std::list<Op> &linearOps;
+  AnalysisData &ad;
+};
+
+}  // namespace flat
+
+template<typename A>
+void CreateFlatIR(const A &ptree, std::list<flat::Op> &ops, AnalysisData &ad) {
+  flat::ControlFlowAnalyzer linearize{ops, ad};
+  Walk(ptree, linearize);
+}
+
+#define INSTANTIATE_EXPLICITLY(T) \
+  template void CreateFlatIR<parser::T>( \
+      const parser::T &, std::list<flat::Op> &, AnalysisData &)
+INSTANTIATE_EXPLICITLY(MainProgram);
+INSTANTIATE_EXPLICITLY(FunctionSubprogram);
+INSTANTIATE_EXPLICITLY(SubroutineSubprogram);
+
+}  // namespace burnside
diff --git a/lib/burnside/flattened.h b/lib/burnside/flattened.h
new file mode 100644
index 000000000000..7d07d477968f
--- /dev/null
+++ b/lib/burnside/flattened.h
@@ -0,0 +1,237 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_FLATTENED_H_
+#define FORTRAN_BURNSIDE_FLATTENED_H_
+
+#include "mixin.h"
+#include "../parser/parse-tree.h"
+#include "llvm/ADT/BitVector.h"
+#include <cstdint>
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
+
+namespace Fortran::burnside {
+
+struct AnalysisData;
+
+namespace flat {
+
+/// This is a flattened, linearized representation of the parse
+/// tree. It captures the executable specification of the input
+/// program. The flattened IR can be used to construct FIR.
+///
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+using LabelRef = unsigned;
+constexpr LabelRef UnspecifiedLabel{UINT_MAX};
+
+using Location = parser::CharBlock;
+struct LabelBuilder;
+
+// target for a control-flow edge
+struct LabelOp {
+  explicit LabelOp(LabelBuilder &builder);
+  LabelOp(const LabelOp &that);
+  LabelOp &operator=(const LabelOp &that);
+  void setReferenced() const;
+  bool isReferenced() const;
+  LabelRef get() const { return label; }
+  operator LabelRef() const { return get(); }
+
+private:
+  LabelBuilder &builder;
+  LabelRef label;
+};
+
+struct ArtificialJump {};
+
+// a source of an absolute control flow edge
+struct GotoOp
+  : public SumTypeCopyMixin<const parser::CycleStmt *, const parser::ExitStmt *,
+        const parser::GotoStmt *, ArtificialJump> {
+  template<typename A>
+  explicit GotoOp(const A &stmt, LabelRef dest, const Location &source)
+    : SumTypeCopyMixin{&stmt}, target{dest}, source{source} {}
+  explicit GotoOp(LabelRef dest)
+    : SumTypeCopyMixin{ArtificialJump{}}, target{dest} {}
+
+  LabelRef target;
+  Location source;
+};
+
+// control exits the procedure
+struct ReturnOp : public SumTypeCopyMixin<const parser::FailImageStmt *,
+                      const parser::ReturnStmt *, const parser::StopStmt *> {
+  template<typename A>
+  explicit ReturnOp(const A &stmt, const Location &source)
+    : SumTypeCopyMixin{&stmt}, source{source} {}
+
+  Location source;
+};
+
+// two-way branch based on a condition
+struct ConditionalGotoOp
+  : public SumTypeCopyMixin<const parser::Statement<parser::IfThenStmt> *,
+        const parser::Statement<parser::ElseIfStmt> *, const parser::IfStmt *,
+        const parser::Statement<parser::NonLabelDoStmt> *> {
+  template<typename A>
+  explicit ConditionalGotoOp(const A &cond, LabelRef tb, LabelRef fb)
+    : SumTypeCopyMixin{&cond}, trueLabel{tb}, falseLabel{fb} {}
+
+  LabelRef trueLabel;
+  LabelRef falseLabel;
+};
+
+// multi-way branch based on a target-value of a variable
+struct IndirectGotoOp {
+  explicit IndirectGotoOp(
+      const semantics::Symbol *symbol, std::vector<LabelRef> &&labelRefs)
+      : labelRefs{labelRefs}, symbol{symbol} {}
+
+  std::vector<LabelRef> labelRefs;
+  const semantics::Symbol *symbol;
+};
+
+// intrinsic IO operations can return with an implied multi-way branch
+struct SwitchIOOp
+  : public SumTypeCopyMixin<const parser::ReadStmt *, const parser::WriteStmt *,
+        const parser::WaitStmt *, const parser::OpenStmt *,
+        const parser::CloseStmt *, const parser::BackspaceStmt *,
+        const parser::EndfileStmt *, const parser::RewindStmt *,
+        const parser::FlushStmt *, const parser::InquireStmt *> {
+  template<typename A>
+  explicit SwitchIOOp(const A &io, LabelRef next, const Location &source,
+      std::optional<LabelRef> errLab,
+      std::optional<LabelRef> eorLab = std::nullopt,
+      std::optional<LabelRef> endLab = std::nullopt)
+    : SumTypeCopyMixin{&io}, next{next}, source{source}, errLabel{errLab},
+      eorLabel{eorLab}, endLabel{endLab} {}
+  LabelRef next;
+  Location source;
+  std::optional<LabelRef> errLabel;
+  std::optional<LabelRef> eorLabel;
+  std::optional<LabelRef> endLabel;
+};
+
+// multi-way branch based on conditions
+struct SwitchOp
+  : public SumTypeCopyMixin<const parser::CallStmt *,
+        const parser::ComputedGotoStmt *, const parser::ArithmeticIfStmt *,
+        const parser::CaseConstruct *, const parser::SelectRankConstruct *,
+        const parser::SelectTypeConstruct *> {
+  template<typename A>
+  explicit SwitchOp(
+      const A &sw, const std::vector<LabelRef> &refs, const Location &source)
+    : SumTypeCopyMixin{&sw}, refs{refs}, source{source} {}
+
+  const std::vector<LabelRef> refs;
+  Location source;
+};
+
+// a compute step
+struct ActionOp {
+  explicit ActionOp(const parser::Statement<parser::ActionStmt> &stmt)
+    : v{&stmt} {}
+
+  const parser::Statement<parser::ActionStmt> *v;
+};
+
+#define CONSTRUCT_TYPES \
+  const parser::AssociateConstruct *, const parser::BlockConstruct *, \
+      const parser::CaseConstruct *, const parser::ChangeTeamConstruct *, \
+      const parser::CriticalConstruct *, const parser::DoConstruct *, \
+      const parser::IfConstruct *, const parser::SelectRankConstruct *, \
+      const parser::SelectTypeConstruct *, const parser::WhereConstruct *, \
+      const parser::ForallConstruct *, const parser::CompilerDirective *, \
+      const parser::OpenMPConstruct *, const parser::OmpEndLoopDirective *
+
+// entry into a Fortran construct
+struct BeginOp : public SumTypeCopyMixin<CONSTRUCT_TYPES> {
+  SUM_TYPE_COPY_MIXIN(BeginOp)
+
+  template<typename A> explicit BeginOp(const A &c) : SumTypeCopyMixin{&c} {}
+};
+
+// exit from a Fortran construct
+struct EndOp : public SumTypeCopyMixin<CONSTRUCT_TYPES> {
+  SUM_TYPE_COPY_MIXIN(EndOp)
+
+  template<typename A> explicit EndOp(const A &c) : SumTypeCopyMixin{&c} {}
+};
+
+struct DoIncrementOp {
+  explicit DoIncrementOp(const parser::DoConstruct &stmt) : v{&stmt} {}
+
+  const parser::DoConstruct *v;
+};
+
+struct DoCompareOp {
+  DoCompareOp(const parser::DoConstruct &stmt) : v{&stmt} {}
+
+  const parser::DoConstruct *v;
+};
+
+// the flat structure is a list of Ops, where an Op is any of ...
+struct Op : public SumTypeMixin<LabelOp, GotoOp, ReturnOp, ConditionalGotoOp,
+                SwitchIOOp, SwitchOp, ActionOp, BeginOp, EndOp, IndirectGotoOp,
+                DoIncrementOp, DoCompareOp> {
+  template<typename A> Op(const A &thing) : SumTypeMixin{thing} {}
+
+  static void Build(std::list<Op> &ops,
+      const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad);
+};
+
+// helper to build unique labels
+struct LabelBuilder {
+  LabelBuilder();
+  LabelRef getNext();
+  void setReferenced(LabelRef label);
+  bool isReferenced(LabelRef label) const;
+  llvm::BitVector referenced;
+  unsigned counter;
+};
+
+LabelOp FetchLabel(AnalysisData &ad, const parser::Label &label);
+
+std::vector<LabelRef> GetAssign(
+    AnalysisData &ad, const semantics::Symbol *symbol);
+
+}  // namespace flat
+
+// Collection of data maintained internally by the flattening algorithm
+struct AnalysisData {
+  std::map<parser::Label, flat::LabelOp> labelMap;
+  std::vector<std::tuple<const parser::Name *, flat::LabelRef, flat::LabelRef>>
+      constructContextStack;
+  flat::LabelBuilder labelBuilder;
+  std::map<const semantics::Symbol *, std::set<parser::Label>> assignMap;
+};
+
+// entry-point into building the flat IR
+template<typename A>
+void CreateFlatIR(const A &ptree, std::list<flat::Op> &ops, AnalysisData &ad);
+
+#define EXPLICIT_INSTANTIATION(T) \
+  extern template void CreateFlatIR<parser::T>( \
+      const parser::T &, std::list<flat::Op> &, AnalysisData &)
+EXPLICIT_INSTANTIATION(MainProgram);
+EXPLICIT_INSTANTIATION(FunctionSubprogram);
+EXPLICIT_INSTANTIATION(SubroutineSubprogram);
+
+}  // namespace burnside
+
+#endif  // FORTRAN_BURNSIDE_FLATTENED_H_
diff --git a/lib/burnside/mixin.h b/lib/burnside/mixin.h
new file mode 100644
index 000000000000..f24ccc2b1b08
--- /dev/null
+++ b/lib/burnside/mixin.h
@@ -0,0 +1,72 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_MIXIN_H_
+#define FORTRAN_BURNSIDE_MIXIN_H_
+
+// Mixin classes are "partial" classes (not used standalone) that can be used to
+// add a repetitive (ad hoc) interface (and implementation) to a class.  It's
+// better to think of these as "included in" a class, rather than as an
+// "inherited from" base class.
+
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+#include "llvm/ADT/ilist.h"
+#include <optional>
+#include <tuple>
+#include <type_traits>
+#include <variant>
+
+namespace Fortran::burnside {
+
+// implementation of a (moveable) sum type (variant)
+template<typename... Ts> struct SumTypeMixin {
+  using SumTypeTrait = std::true_type;
+  template<typename A> SumTypeMixin(const A &x) : u{x} {}
+  template<typename A> SumTypeMixin(A &&x) : u{std::forward<A>(x)} {}
+  SumTypeMixin(SumTypeMixin &&) = default;
+  SumTypeMixin &operator=(SumTypeMixin &&) = default;
+  SumTypeMixin(const SumTypeMixin &) = delete;
+  SumTypeMixin &operator=(const SumTypeMixin &) = delete;
+  SumTypeMixin() = delete;
+  std::variant<Ts...> u;
+};
+
+// implementation of a copyable sum type
+template<typename... Ts> struct SumTypeCopyMixin {
+  using CopyableSumTypeTrait = std::true_type;
+  template<typename A> SumTypeCopyMixin(const A &x) : u{x} {}
+  template<typename A> SumTypeCopyMixin(A &&x) : u{std::forward<A>(x)} {}
+  SumTypeCopyMixin(SumTypeCopyMixin &&) = default;
+  SumTypeCopyMixin &operator=(SumTypeCopyMixin &&) = default;
+  SumTypeCopyMixin(const SumTypeCopyMixin &) = default;
+  SumTypeCopyMixin &operator=(const SumTypeCopyMixin &) = default;
+  SumTypeCopyMixin() = delete;
+  std::variant<Ts...> u;
+};
+#define SUM_TYPE_COPY_MIXIN(DT) \
+  DT(const DT &derived) : SumTypeCopyMixin(derived.u) {} \
+  DT(DT &&derived) : SumTypeCopyMixin(std::move(derived.u)) {} \
+  DT &operator=(const DT &derived) { \
+    SumTypeCopyMixin::operator=(derived.u); \
+    return *this; \
+  } \
+  DT &operator=(DT &&derived) { \
+    SumTypeCopyMixin::operator=(std::move(derived.u)); \
+    return *this; \
+  }
+
+} // namespace burnside
+
+#endif  // FORTRAN_BURNSIDE_MIXIN_H_

From 17eb0112b604e161759906ab670a82dcb1b77b35 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 18 Mar 2020 11:42:01 -0700
Subject: [PATCH 117/345] [shim] revert come changes made on master to ease
 rebasing of mono branch

---
 CMakeLists.txt       | 11 +-------
 README.md            | 63 ++------------------------------------------
 tools/CMakeLists.txt | 12 +--------
 3 files changed, 4 insertions(+), 82 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8883fb7e7597..dedcdc21f142 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,15 +88,6 @@ add_definitions(${LLVM_DEFINITIONS})
 set(LLVM_EXTERNAL_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit CACHE STRING "Command used to spawn lit")
 
 if(LINK_WITH_FIR)
-  include(TableGen)
-  include(AddMLIR)
-  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
-  NO_DEFAULT_PATH)
-  # tco tool and FIR lib output directories
-  set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
-  set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
-  # Always build tco tool
-  set(LLVM_BUILD_TOOLS ON)
   message(STATUS "Linking driver with FIR and LLVM")
   llvm_map_components_to_libnames(LLVM_COMMON_LIBS support)
   message(STATUS "LLVM libraries: ${LLVM_COMMON_LIBS}")
@@ -156,7 +147,7 @@ add_subdirectory(lib)
 add_subdirectory(runtime)
 add_subdirectory(unittests)
 add_subdirectory(tools)
-add_subdirectory(test)
+add_subdirectory(test-lit)
 
 configure_file(
   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
diff --git a/README.md b/README.md
index 7855d5482128..ed3775c0d588 100644
--- a/README.md
+++ b/README.md
@@ -94,59 +94,6 @@ cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ...
 where `LLVM_BUILD_DIR` is
 the top-level directory where LLVM was built.
 
-### LLVM dependency when building f18 with Fortran IR
-
-If you do not want to build Fortran IR, add `-DLINK_WITH_FIR=Off` to f18 cmake
-command and ignore the rest of this section.
-
-If you intend to build f18 with Fortran IR (`-DLINK_WITH_FIR` On by default),
-you must:
-- build LLVM with the same compiler and options as the one you are using
-to build F18.
-- pass `-DCMAKE_CXX_STANDARD=17 -DLLVM_ENABLE_PROJECTS="mlir"`
-to LLVM cmake command.
-- install LLVM somewhere with `make install` in order to get the required
-AddMLIR cmake file (it is not generated in LLVM build directory).
-
-Installing LLVM from packages is most likely not an option as it will not include
-MLIR and not be built following C++17 standard.
-
-MLIR is under active development and the most recent development version
-may be incompatible. A branch named `f18` is available inside LLVM fork in
-https://github.com/flang-compiler/f18-llvm-project. It contains a version of LLVM
-that is known be compatible to build f18 with FIR.
-
-The fastest way to get set up is to do:
-
-```
-cd where/you/want/to/build/llvm
-git clone --depth=1 -b f18 https://github.com/flang-compiler/f18-llvm-project.git
-mkdir build
-mkdir install
-cd build
-cmake ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release \
-    -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 \
-    -DLLVM_INSTALL_UTILS=On \
-    -DCMAKE_INSTALL_PREFIX=../install
-make
-make install
-```
-
-Then, `-DLLVM_DIR` would have to be set to
- `<where/you/want/to/build/llvm>/install/lib/cmake/llvm`
-and, `-DMLIR_DIR` would have to be set to
- `<where/you/want/to/build/llvm>/install/lib/cmake/mlir`
-
-in f18 cmake command.
-
-To run lit tests,
-`-DLLVM_EXTERNAL_LIT=<where/you/want/to/build/llvm>/build/bin/llvm-lit` must be
-added to f18 cmake command. This is because `llvm-lit` is not part of
-LLVM installation.
-
-Note that when using some advanced options from f18 cmake file it may be
-necessary to reproduce their effects in LLVM cmake command.
-
 ### Building f18 with GCC
 
 By default,
@@ -239,8 +186,8 @@ make
 To run all tests:
 ```
 cd ~/f18/build
-cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ~/f18/src
-make test check-all
+cmake -DLLVM_DIR=$LLVM ~/f18/src
+make check-flang
 ```
 
 To run individual regression tests llvm-lit needs to know the lit
@@ -252,9 +199,3 @@ flang_site_config and flang_config. And they can be set as shown bellow:
  --param flang_config=<path-to-f18-build>/test-lit/lit.cfg.py \
   <path-to-fortran-test>
 ```
-
-# How to Generate FIR Documentation
-
-If f18 was built with `-DLINK_WITH_FIR=On` (`On` by default), it is possible to
-generate FIR language documentation by running `make flang-doc`. This will
-create `docs/Dialect/FIRLangRef.md` in f18 build directory.
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index b973127d3443..e1dc5d702475 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -1,13 +1,3 @@
-#===-- tools/CMakeLists.txt ------------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
 add_subdirectory(f18)
-if(LINK_WITH_FIR)
-  add_subdirectory(tco)
-endif()
 add_subdirectory(f18-parse-demo)
+add_subdirectory(tco)

From 4a683c7b84e874ccc4f59a679012ef8b4dd99db3 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 1 Apr 2019 11:09:03 -0700
Subject: [PATCH 118/345] Burnside bridge implementation

adding types - expand sequence type to support Fortran descriptor information
add code to lower function type signatures to LLVM types
add support and lowering for an if-then-else construct
add support and lowering for SELECT X operations
add address arithmetic to canonicalize
changes to start adding new concepts to FIR
start adding top-level special forms
convert the build system to work as an in-tree build
finish draft of pretty parsers and printers
finish the pretty printer/parser
add "How To Lower" doc
changes to put optional attributes in and position them before the type
allow unquoted identifiers
turn off warnings on Mac
implement recursive record type (round trips)
Add a small framework to lower intrinsic calls to runtime calls.
refine type checking, add some sketches of tests, etc.
convert MemToReg to template form
add converter stubs for all FIR ops
move the bridge from FIR to standard to be a transformation pass
work on tilikum bridge, lowering types
add complex primitives; start lowering some FIR to LLVM IR
add code to allow cleanup on attribute dicts
add FirEndOp converter
add code to lower addc and subc ops
add lowering for mulc and divc
add code to support FP128 and X86_FP80
add real primitives to FIR to support extended precision types
add float primitives for !fir.real types that are not supported in std dialect
add option for user control of KIND mappings
Refactor intrinsic function lowering facility
add more interface to allow source positions to be tracked for functions
identified structs; box ops; add complex changes from 8c33745
fix type passed to InsertValueOp and ExtractValueOp builder
sync to latest MLIR and get rid of the `fir.icall` operation
Change the readme to explain how to build FIR.
Update FIR language document.
fix bug with overly exuberate merging
create Transforms folder
clone the MLIR CSE pass for modification
implementation of basic CSE
---
 .clang-format                                 |    2 +-
 CMakeLists.txt                                |  562 +++-
 README.md                                     |  210 +-
 docs/CMakeLists.txt                           |   92 +
 docs/doxygen.cfg.in                           | 2293 +++++++++++++++++
 documentation/BurnsideToFIR.md                |  823 ++++++
 documentation/FIRLangRef.md                   | 1023 ++++++++
 include/CMakeLists.txt                        |    1 +
 include/fir/FIROps.h                          |   20 +
 include/fir/FIROps.td                         |  518 ++--
 include/fir/KindMapping.h                     |   68 +
 include/fir/Tilikum/Tilikum.h                 |   34 +
 .../fir/Transforms/{MemToReg.h => Passes.h}   |   24 +-
 include/fir/Transforms/StdConverter.h         |   31 +
 include/fir/Type.h                            |  102 +-
 include/flang/Version.h                       |   61 +
 lib/CMakeLists.txt                            |    6 +
 lib/burnside/CMakeLists.txt                   |   13 +
 lib/burnside/bridge.cc                        | 1014 ++++++++
 lib/burnside/bridge.h                         |   96 +
 lib/burnside/builder.cc                       |   55 +
 lib/burnside/builder.h                        |   21 +-
 lib/burnside/convert-expr.cc                  |  691 +++++
 lib/burnside/convert-expr.h                   |   64 +
 lib/burnside/fe-helper.cc                     |  384 +++
 lib/burnside/fe-helper.h                      |  109 +
 lib/burnside/flattened.cc                     |  108 +-
 lib/burnside/flattened.h                      |   61 +-
 lib/burnside/intrinsics.cc                    |  505 ++++
 lib/burnside/intrinsics.h                     |   74 +
 lib/burnside/runtime.cc                       |  106 +
 lib/burnside/runtime.def                      |   42 +
 lib/burnside/runtime.h                        |   48 +
 lib/fir/Attribute.cpp                         |  181 ++
 lib/fir/CMakeLists.txt                        |   47 +
 lib/fir/Dialect.cpp                           |   99 +
 lib/fir/FIROps.cpp                            |  430 ++++
 lib/fir/IteratedDominanceFrontier.cpp         |  107 +
 lib/fir/KindMapping.cpp                       |  221 ++
 lib/fir/StdConverter.cpp                      |  180 ++
 lib/fir/Tilikum.cpp                           | 1478 +++++++++++
 lib/fir/Transforms/CMakeLists.txt             |   29 +
 lib/fir/Transforms/CSE.cpp                    |  319 +++
 lib/fir/Transforms/MemToReg.cpp               |  740 ++++++
 lib/fir/Type.cpp                              | 1652 ++++++++++++
 test/fir/addrof.1.fir                         |    7 +
 test/fir/character.fir                        |   12 +
 test/fir/commute.fir                          |   21 +
 test/fir/complex.fir                          |    7 +
 test/fir/complex.mlir                         |    6 +
 test/fir/embox.fir                            |    6 +
 test/fir/fir-dt.fir                           |    5 +
 test/fir/fir-ops.fir                          |  237 ++
 test/fir/fir-types.fir                        |   38 +
 test/fir/float.fir                            |   27 +
 test/fir/recursive-type.fir                   |    5 +
 tools/f18/CMakeLists.txt                      |    6 +-
 tools/fml/CMakeLists.txt                      |   39 +
 tools/fml/fml.cc                              |  638 +++++
 59 files changed, 15158 insertions(+), 640 deletions(-)
 create mode 100644 docs/CMakeLists.txt
 create mode 100644 docs/doxygen.cfg.in
 create mode 100644 documentation/BurnsideToFIR.md
 create mode 100644 documentation/FIRLangRef.md
 create mode 100644 include/fir/KindMapping.h
 create mode 100644 include/fir/Tilikum/Tilikum.h
 rename include/fir/Transforms/{MemToReg.h => Passes.h} (79%)
 create mode 100644 include/fir/Transforms/StdConverter.h
 create mode 100644 include/flang/Version.h
 create mode 100644 lib/burnside/bridge.cc
 create mode 100644 lib/burnside/bridge.h
 create mode 100644 lib/burnside/builder.cc
 create mode 100644 lib/burnside/convert-expr.cc
 create mode 100644 lib/burnside/convert-expr.h
 create mode 100644 lib/burnside/fe-helper.cc
 create mode 100644 lib/burnside/fe-helper.h
 create mode 100644 lib/burnside/intrinsics.cc
 create mode 100644 lib/burnside/intrinsics.h
 create mode 100644 lib/burnside/runtime.cc
 create mode 100644 lib/burnside/runtime.def
 create mode 100644 lib/burnside/runtime.h
 create mode 100644 lib/fir/Attribute.cpp
 create mode 100644 lib/fir/CMakeLists.txt
 create mode 100644 lib/fir/Dialect.cpp
 create mode 100644 lib/fir/FIROps.cpp
 create mode 100644 lib/fir/IteratedDominanceFrontier.cpp
 create mode 100644 lib/fir/KindMapping.cpp
 create mode 100644 lib/fir/StdConverter.cpp
 create mode 100644 lib/fir/Tilikum.cpp
 create mode 100644 lib/fir/Transforms/CMakeLists.txt
 create mode 100644 lib/fir/Transforms/CSE.cpp
 create mode 100644 lib/fir/Transforms/MemToReg.cpp
 create mode 100644 lib/fir/Type.cpp
 create mode 100644 test/fir/addrof.1.fir
 create mode 100644 test/fir/character.fir
 create mode 100644 test/fir/commute.fir
 create mode 100644 test/fir/complex.fir
 create mode 100644 test/fir/complex.mlir
 create mode 100644 test/fir/embox.fir
 create mode 100644 test/fir/fir-dt.fir
 create mode 100644 test/fir/fir-ops.fir
 create mode 100644 test/fir/fir-types.fir
 create mode 100644 test/fir/float.fir
 create mode 100644 test/fir/recursive-type.fir
 create mode 100644 tools/fml/CMakeLists.txt
 create mode 100644 tools/fml/fml.cc

diff --git a/.clang-format b/.clang-format
index c1dfe06fdf57..064f60c2fb90 100644
--- a/.clang-format
+++ b/.clang-format
@@ -10,7 +10,7 @@ AlignTrailingComments: false
 IncludeCategories:
   - Regex:           '^<'
     Priority:        4
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c|mlir|mlir-c)/'
     Priority:        3
   - Regex:           '^"(flang|\.\.)/'
     Priority:        2
diff --git a/CMakeLists.txt b/CMakeLists.txt
index dedcdc21f142..06381ef5da19 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,113 +8,388 @@
 
 cmake_minimum_required(VERSION 3.9.0)
 
-option(LINK_WITH_FIR "Link driver with FIR and LLVM" ON)
-
-# Pass -DGCC=... to cmake to use a specific gcc installation.
-if( GCC )
-  set(CMAKE_CXX_COMPILER "${GCC}/bin/g++")
-  set(CMAKE_CC_COMPILER "${GCC}/bin/gcc")
-  set(CMAKE_BUILD_RPATH "${GCC}/lib64")
-  set(CMAKE_INSTALL_RPATH "${GCC}/lib64")
-endif()
-if(BUILD_WITH_CLANG)
-  file(TO_CMAKE_PATH "${BUILD_WITH_CLANG}" CLANG_PATH)
-  set(CMAKE_CXX_COMPILER "${CLANG_PATH}/bin/clang++")
-  set(CMAKE_CC_COMPILER "${CLANG_PATH}/bin/clang")
-  if(GCC)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
-  endif()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wstring-conversion")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcovered-switch-default")
+if (POLICY CMP0068)
+  cmake_policy(SET CMP0068 NEW)
+  set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
+endif()
+
+if(POLICY CMP0075)
+  cmake_policy(SET CMP0075 NEW)
 endif()
 
-# Set RPATH in every executable, overriding the default setting.
-# If you set this first variable back to true (the default),
-# also set the second one.
-set(CMAKE_SKIP_BUILD_RPATH false)
-set(CMAKE_BUILD_WITH_INSTALL_RPATH false)
+if (POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
+endif()
 
-set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib" "${CMAKE_INSTALL_RPATH}")
+# If we are not building as part of LLVM (e.g., within the mono-repo),
+# build Flang as a standalone project.  This assumes the use of an
+# existing LLVM install w/ external libraries.
+if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
+  project(Flang)
 
-# Reminder: Setting CMAKE_CXX_COMPILER must be done before calling project()
+  # Rely on llvm-config.
+  set(CONFIG_OUTPUT)
+  if(LLVM_CONFIG)
+    set (LLVM_CONFIG_FOUND 1)
+    message(STATUS "Found LLVM_CONFIG as ${LLVM_CONFIG}")
+    message(DEPRECATION "Using llvm-config is deprecated.  Use the \
+                         LLVM installed CMake files instead. \
+ 		         This should allow CMake to automatically find \
+			 find your install.  You can also use LLVM_DIR \
+			 to specify the path to LLVMConfig.cmake.")
+    set(CONFIG_COMMAND ${LLVM_CONFIG}
+      "--assertion-mode"
+      "--bindir"
+      "--libdir"
+      "--includedir"
+      "--prefix"
+      "--src-root"
+      "--cmakedir")
+    execute_process(
+      COMMAND ${CONFIG_COMMAND}
+      RESULT_VARIABLE HAD_ERROR
+      OUTPUT_VARIABLE CONFIG_OUTPUT
+    )
+    if(NOT HAD_ERROR)
+      string(REGEX REPLACE
+        "[ \t]*[\r\n]+[ \t]*" ";"
+        CONFIG_OUTPUT ${CONFIG_OUTPUT})
+    else()
+      string(REPLACE ";" " " CONFIG_COMMAND_STR "${CONFIG_COMMAND}")
+      message(STATUS "${CONFIG_COMMAND_STR}")
+      message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")
+    endif()
 
-project(f18 CXX)
+    list(GET CONFIG_OUTPUT 0 ENABLE_ASSERTIONS)
+    list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR)
+    list(GET CONFIG_OUTPUT 2 LIBRARY_DIR)
+    list(GET CONFIG_OUTPUT 3 INCLUDE_DIR)
+    list(GET CONFIG_OUTPUT 4 LLVM_OBJ_ROOT)
+    list(GET CONFIG_OUTPUT 5 MAIN_SRC_DIR)
+    list(GET CONFIG_OUTPUT 6 LLVM_CONFIG_CMAKE_PATH)
 
-if( NOT CMAKE_BUILD_TYPE )
-  set( CMAKE_BUILD_TYPE Debug )
-endif()
+    # Normalize LLVM_CMAKE_PATH. --cmakedir might contain backslashes.
+    # CMake assumes slashes as PATH.
+    file(TO_CMAKE_PATH ${LLVM_CONFIG_CMAKE_PATH} LLVM_CMAKE_PATH)
+  endif()
+
+  if(NOT MSVC_IDE)
+    set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
+      CACHE BOOL "Enable assertions")
+    # Assertions should follow llvm-config's.
+    mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
+  endif()
+
+  find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
+  list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
+
+  # We can't check LLVM_CONFIG here, because find_package(LLVM ...) also sets
+  # LLVM_CONFIG.
+  if (NOT LLVM_CONFIG_FOUND)
+    # Pull values from LLVMConfig.cmake.  We can drop this once the llvm-config
+    # path is removed.
+    set(TOOLS_BINARY_DIR ${LLVM_TOOLS_BINARY_DIR})
+    set(LIBRARY_DIR ${LLVM_LIBRARY_DIR})
+    set(INCLUDE_DIR ${LLVM_INCLUDE_DIR})
+    set(LLVM_OBJ_DIR ${LLVM_BINARY_DIR})
+    # The LLVM_CMAKE_PATH variable is set when doing non-standalone builds and
+    # used in this project, so we need to make sure we set this value.
+    # FIXME: LLVM_CMAKE_DIR comes from LLVMConfig.cmake.  We should rename
+    # LLVM_CMAKE_PATH to LLVM_CMAKE_DIR throughout the project.
+    set(LLVM_CMAKE_PATH ${LLVM_CMAKE_DIR})
+  endif()
+
+  set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
+  set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib")
+  set(LLVM_MAIN_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Path to llvm/include")
+  set(LLVM_BINARY_DIR ${LLVM_OBJ_ROOT} CACHE PATH "Path to LLVM build tree")
+  set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")
+
+  find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" ${LLVM_TOOLS_BINARY_DIR}
+    NO_DEFAULT_PATH)
+  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
+    NO_DEFAULT_PATH)
+
+  # They are used as destination of target generators.
+  set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
+  set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
+  if(WIN32 OR CYGWIN)
+    # DLL platform -- put DLLs into bin.
+    set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
+  else()
+    set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
+  endif()
 
-message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}" )
+  option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
+  option(LLVM_INSTALL_TOOLCHAIN_ONLY
+    "Only include toolchain files in the 'install' target." OFF)
+
+  option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
+    "Set to ON to force using an old, unsupported host toolchain." OFF)
+  option(CLANG_ENABLE_BOOTSTRAP "Generate the clang bootstrap target" OFF)
+  option(LLVM_ENABLE_LIBXML2 "Use libxml2 if available." ON)
+
+  include(AddLLVM)
+  include(TableGen)
+  include(HandleLLVMOptions)
+  include(VersionFromVCS)
+  include(AddMLIR)
+
+  set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
+
+  if (NOT DEFINED LLVM_INCLUDE_TESTS)
+    set(LLVM_INCLUDE_TESTS ON)
+  endif()
+
+  include_directories("${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}")
+  link_directories("${LLVM_LIBRARY_DIR}")
+  set(MLIR_BINARY_DIR ${LLVM_BINARY_DIR})
+
+  set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
+  set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
+  set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
+
+  if(LLVM_INCLUDE_TESTS)
+    include(FindPythonInterp)
+    if(NOT PYTHONINTERP_FOUND)
+      message(FATAL_ERROR
+"Unable to find Python interpreter, required for builds and testing.
+
+Please install Python or specify the PYTHON_EXECUTABLE CMake variable.")
+    endif()
+
+    if( ${PYTHON_VERSION_STRING} VERSION_LESS 2.7 )
+      message(FATAL_ERROR "Python 2.7 or newer is required")
+    endif()
+
+    # Check prebuilt llvm/utils.
+    if(EXISTS ${LLVM_TOOLS_BINARY_DIR}/FileCheck${CMAKE_EXECUTABLE_SUFFIX}
+        AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/count${CMAKE_EXECUTABLE_SUFFIX}
+        AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/not${CMAKE_EXECUTABLE_SUFFIX})
+      set(LLVM_UTILS_PROVIDED ON)
+    endif()
+
+    if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
+      # Note: path not really used, except for checking if lit was found
+      set(LLVM_LIT ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
+      if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/llvm-lit)
+        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit utils/llvm-lit)
+      endif()
+      if(NOT LLVM_UTILS_PROVIDED)
+        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/FileCheck utils/FileCheck)
+        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/count utils/count)
+        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/not utils/not)
+        set(LLVM_UTILS_PROVIDED ON)
+        set(FLANG_TEST_DEPS FileCheck count not)
+      endif()
+      set(UNITTEST_DIR ${LLVM_MAIN_SRC_DIR}/utils/unittest)
+      if(EXISTS ${UNITTEST_DIR}/googletest/include/gtest/gtest.h
+          AND NOT EXISTS ${LLVM_LIBRARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX}
+          AND EXISTS ${UNITTEST_DIR}/CMakeLists.txt)
+        add_subdirectory(${UNITTEST_DIR} utils/unittest)
+      endif()
+    else()
+      # Seek installed Lit.
+      find_program(LLVM_LIT
+                   NAMES llvm-lit lit.py lit
+                   PATHS "${LLVM_MAIN_SRC_DIR}/utils/lit"
+                   DOC "Path to lit.py")
+    endif()
+
+    if(LLVM_LIT)
+      # Define the default arguments to use with 'lit', and an option for the user
+      # to override.
+      set(LIT_ARGS_DEFAULT "-sv")
+      if (MSVC OR XCODE)
+        set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
+      endif()
+      set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
+
+      # On Win32 hosts, provide an option to specify the path to the GnuWin32 tools.
+      if( WIN32 AND NOT CYGWIN )
+        set(LLVM_LIT_TOOLS_DIR "" CACHE PATH "Path to GnuWin32 tools")
+      endif()
+    else()
+      set(LLVM_INCLUDE_TESTS OFF)
+    endif()
+  endif()
+
+  set(FLANG_BUILT_STANDALONE 1)
+  set(BACKEND_PACKAGE_STRING "LLVM ${LLVM_PACKAGE_VERSION}")
+else()
+  set(BACKEND_PACKAGE_STRING "${PACKAGE_STRING}")
+  set(MLIR_BINARY_DIR ${LLVM_BINARY_DIR}/tools/mlir)
+  set(MLIR_SOURCE_DIR ${LLVM_SOURCE_DIR}/../mlir)
+endif()
 
-find_package(LLVM REQUIRED CONFIG)
-message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION} in ${LLVM_DIR}")
 # If LLVM links to zlib we need the imported targets so we can too.
 if(LLVM_ENABLE_ZLIB)
   find_package(ZLIB REQUIRED)
 endif()
 
-list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
+# Make sure that our source directory is on the current cmake module path so that
+# we can include cmake files from this directory.
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
-include(AddLLVM)
+if(LLVM_ENABLE_LIBXML2)
+  # Don't look for libxml if we're using MSan, since uninstrumented third party
+  # code may call MSan interceptors like strlen, leading to false positives.
+  if(NOT LLVM_USE_SANITIZER MATCHES "Memory.*")
+    set (LIBXML2_FOUND 0)
+    find_package(LibXml2 2.5.3 QUIET)
+    if (LIBXML2_FOUND)
+      set(FLANG_HAVE_LIBXML 1)
+    endif()
+  endif()
+endif()
 
-# Get names for the LLVM libraries
-#
-# The full list of LLVM components can be obtained with
-#
-#   llvm-config --components
-#
-# Similarly, the (static) libraries corresponding to some
-# components (default is 'all') can be obtained with
-#
-#   llvm-config --libs --link-static [component ...]
-#
-# See also
-#  http://llvm.org/docs/CMake.html#embedding-llvm-in-your-project
-#  https://stackoverflow.com/questions/41924375/llvm-how-to-specify-all-link-libraries-as-input-to-llvm-map-components-to-libna
-#  https://stackoverflow.com/questions/33948633/how-do-i-link-when-building-with-llvm-libraries
-
-# Add LLVM include files as if they were SYSTEM because there are complex unused
-# parameter issues that may or may not appear depending on the environments and
-# compilers (ifdefs are involved). This allows warnings from LLVM headers to be
-# ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
-# This may have to be fine-tuned if flang headers are consider part of this
-# LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
-# should not be suppressed).
-include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
-add_definitions(${LLVM_DEFINITIONS})
-
-# LLVM_LIT_EXTERNAL store in cache so it could be used by AddLLVM.cmake
-set(LLVM_EXTERNAL_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit CACHE STRING "Command used to spawn lit")
-
-if(LINK_WITH_FIR)
+option(FLANG_LINK_WITH_FIR "Link Flang driver with FIR and LLVM" ON)
+if (LINK_WITH_FIR)
   message(STATUS "Linking driver with FIR and LLVM")
   llvm_map_components_to_libnames(LLVM_COMMON_LIBS support)
   message(STATUS "LLVM libraries: ${LLVM_COMMON_LIBS}")
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-      if(BUILD_WITH_CLANG_LIBRARIES)
-         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc++ -I${BUILD_WITH_CLANG_LIBRARIES}/include/c++/v1 -DCLANG_LIBRARIES")
-         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -Wl,-rpath,${BUILD_WITH_CLANG_LIBRARIES}/lib -L${BUILD_WITH_CLANG_LIBRARIES}/lib")
-      else()
-         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lstdc++")
-      endif()
-      if(GCC)
-         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
-      endif()
-   endif()
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall -Wextra -Werror")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcast-qual")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wimplicit-fallthrough")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdelete-non-virtual-dtor")
-   set(CMAKE_CXX_FLAGS_RELEASE    "-O2")
-   set(CMAKE_CXX_FLAGS_MINSIZEREL "-O2 '-DCHECK=(void)'")
-   set(CMAKE_CXX_FLAGS_DEBUG      "-g -DDEBUGF18")
+set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+if(MLIR_SOURCE_DIR)
+  include_directories(BEFORE
+    ${FLANG_BINARY_DIR}/include
+    ${FLANG_SOURCE_DIR}/include
+    ${MLIR_BINARY_DIR}/include
+    ${MLIR_SOURCE_DIR}/include
+    )
+  set(MLIR_MAIN_SRC_DIR ${MLIR_SOURCE_DIR})
+  set(MLIR_INCLUDE_DIR ${MLIR_SOURCE_DIR}/include)
+else()
+  include_directories(BEFORE
+    ${FLANG_BINARY_DIR}/include
+    ${FLANG_SOURCE_DIR}/include
+    ${MLIR_BINARY_DIR}/include
+    )
+  set(MLIR_MAIN_SRC_DIR ${MLIR_BINARY_DIR})
+  set(MLIR_INCLUDE_DIR ${MLIR_BINARY_DIR}/include)
+endif()
+
+set(MLIR_TABLEGEN_EXE mlir-tblgen)
+
+set(FLANG_C_INCLUDE_DIRS "" CACHE STRING
+  "Colon separated list of directories flang will search for headers.")
+
+set(GCC_INSTALL_PREFIX "" CACHE PATH "Directory where gcc is installed.")
+set(DEFAULT_SYSROOT "" CACHE PATH
+  "Default <path> to all compiler invocations for --sysroot=<path>.")
+
+set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
+
+set(FLANG_DEFAULT_LINKER "" CACHE STRING
+  "Default linker to use (linker name or absolute path, empty for platform default)")
+
+set(FLANG_DEFAULT_RTLIB "" CACHE STRING "Default Fortran runtime library to use (\"libFortranRuntime\", empty for platform default)")
+if (NOT(FLANG_DEFAULT_RTLIB STREQUAL ""))
+  message(WARNING "Resetting Flang's default runtime library to use platform default")
+  set(FLANG_DEFAULT_RTLIB "" CACHE STRING
+      "Default runtime library to use (\"libgcc\" or \"compiler-rt\", empty for platform default)" FORCE)
+endif()
+
+set(FLANG_VENDOR ${PACKAGE_VENDOR} CACHE STRING
+  "Vendor-specific text for showing with version information.")
+
+
+if (FLANG_VENDOR)
+  add_definitions(-DFLANG_VENDOR="${FLANG_VENDOR} ")
+endif()
+
+set(FLANG_REPOSITORY_STRING "" CACHE STRING
+  "Vendor-specific text for showing the repository the source is taken from.")
+
+if (FLANG_REPOSITORY_STRING)
+  add_definitions(-DFLANG_REPOSITORY_STRING="${FLANG_REPOSITORY_STRING}")
+endif()
+
+set(FLANG_VENDOR_UTI "org.llvm.flang" CACHE STRING
+  "Vendor-specific uti.")
+
+# The libdir suffix must exactly match whatever LLVM's configuration used.
+set(FLANG_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}")
+
+set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
+  message(FATAL_ERROR "In-source builds are not allowed. "
+"Please create a directory and run cmake "
+"from there, passing the path to this source directory as the last argument. "
+"This process created the file `CMakeCache.txt' and the directory "
+"`CMakeFiles'. Please delete them.")
+endif()
+
+# Override version information to reflect early stages of flang vs.
+# following LLVM's versioning info...
+set(FLANG_VERSION_MAJOR      "0")
+set(FLANG_VERSION_MINOR      "1")
+set(FLANG_VERSION_PATCHLEVEL "0")
+
+# If FLANG_VERSION_* is specified, use it, if not use LLVM_VERSION_*.
+if (NOT DEFINED FLANG_VERSION_MAJOR)
+  set(FLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
+endif()
+if (NOT DEFINED FLANG_VERSION_MINOR)
+  set(FLANG_VERSION_MINOR ${LLVM_VERSION_MINOR})
+endif()
+if (NOT DEFINED FLANG_VERSION_PATCHLEVEL)
+  set(FLANG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
+endif()
+# Unlike PACKAGE_VERSION, FLANG_VERSION does not include LLVM_VERSION_SUFFIX.
+set(FLANG_VERSION "${FLANG_VERSION_MAJOR}.${FLANG_VERSION_MINOR}.${FLANG_VERSION_PATCHLEVEL}")
+message(STATUS "Flang version: ${FLANG_VERSION}")
+
+# Configure the Version.inc file.
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/flang/Version.inc.in
+  ${CMAKE_CURRENT_BINARY_DIR}/include/flang/Version.inc)
+
+if (FLANG_LINK_WITH_FIR)
+  message(STATUS "Linking Flang driver with FIR and LLVM")
+  llvm_map_components_to_libnames(LLVM_COMMON_LIBS support)
+  message(STATUS "Flang using LLVM libraries: ${LLVM_COMMON_LIBS}")
+endif()
+
+# Add appropriate flags for GCC
+if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -fno-rtti -fno-exceptions -Wall -Wextra -Werror -Wcast-qual -Wimplicit-fallthrough -Wdelete-non-virtual-dtor")
+  if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -fno-semantic-interposition")
+  else ()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument -Wstring-conversion -Wcovered-switch-default")
+    # The following works around warnings in the f18 sources
+    check_cxx_compiler_flag("-Werror -Wdeprecated-copy" CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
+    if (CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy")
+    endif()
+    check_cxx_compiler_flag("-Werror -Wstring-conversion" CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
+    if (CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
+    endif()
+  endif ()
+
+  # Enable -pedantic for Flang even if it's not enabled for LLVM.
+  if (NOT LLVM_ENABLE_PEDANTIC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
+  endif ()
+
+  check_cxx_compiler_flag("-Werror -Wnested-anon-types" CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
+  if (CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types")
+  endif()
+
+  if (GCC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
+  endif ()
+
+  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DCHECK=(void)")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGF18")
 
    # Building shared libraries is death on performance with GCC by default
    # due to the need to preserve the right to override external entry points
@@ -123,32 +398,111 @@ if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
    if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
    endif()
+  
+endif ()
+
+# Determine HOST_LINK_VERSION on Darwin.
+set(HOST_LINK_VERSION)
+if (APPLE)
+  set(LD_V_OUTPUT)
+  execute_process(
+    COMMAND sh -c "${CMAKE_LINKER} -v 2>&1 | head -1"
+    RESULT_VARIABLE HAD_ERROR
+    OUTPUT_VARIABLE LD_V_OUTPUT
+  )
+  if (NOT HAD_ERROR)
+    if ("${LD_V_OUTPUT}" MATCHES ".*ld64-([0-9.]+).*")
+      string(REGEX REPLACE ".*ld64-([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
+    elseif ("${LD_V_OUTPUT}" MATCHES "[^0-9]*([0-9.]+).*")
+      string(REGEX REPLACE "[^0-9]*([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
+    endif()
+  else()
+    message(FATAL_ERROR "${CMAKE_LINKER} failed with status ${HAD_ERROR}")
+  endif()
 endif()
 
-set(FLANG_VERSION_MAJOR      "0")
-set(FLANG_VERSION_MINOR      "1")
-set(FLANG_VERSION_PATCHLEVEL "0")
-set(FLANG_VERSION "${FLANG_VERSION_MAJOR}.${FLANG_VERSION_MINOR}.${FLANG_VERSION_PATCHLEVEL}")
-message(STATUS "FLANG version: ${FLANG_VERSION}")
+include(CMakeParseArguments)
+include(AddFlang)
 
-set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
-set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
+if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+  install(DIRECTORY include/flang
+    DESTINATION include
+    COMPONENT flang-headers
+    FILES_MATCHING
+    PATTERN "*.def"
+    PATTERN "*.h"
+    PATTERN "config.h" EXCLUDE
+    PATTERN ".svn" EXCLUDE
+    )
 
-include_directories(BEFORE
-  ${FLANG_BINARY_DIR}/include
-  ${FLANG_SOURCE_DIR}/include
-  )
+  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/flang
+    DESTINATION include
+    COMPONENT flang-headers
+    FILES_MATCHING
+    PATTERN "CMakeFiles" EXCLUDE
+    PATTERN "*.inc"
+    PATTERN "*.h"
+    )
+
+endif()
+
+add_definitions(-D_GNU_SOURCE)
+
+option(FLANG_BUILD_TOOLS
+  "Build the Flang tools. If OFF, just generate build targets." ON)
+
+# Flang version information
+set(FLANG_EXECUTABLE_VERSION
+    "${FLANG_VERSION_MAJOR}" CACHE STRING
+    "Major version number that will be appended to the flang executable name")
+
+set(LIBFLANG_LIBRARY_VERSION
+    "${FLANG_VERSION_MAJOR}" CACHE STRING
+    "Major version number that will be appended to the libflang library")
 
-enable_testing()
+mark_as_advanced(FLANG_EXECUTABLE_VERSION LIBFLANG_LIBRARY_VERSION)
 
-add_subdirectory(include/flang)
+option(FLANG_INCLUDE_TESTS
+       "Generate build targets for the Flang unit tests."
+       ${LLVM_INCLUDE_TESTS})
+
+add_subdirectory(include)
 add_subdirectory(lib)
-add_subdirectory(runtime)
-add_subdirectory(unittests)
 add_subdirectory(tools)
-add_subdirectory(test-lit)
+add_subdirectory(runtime)
+
+option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
+  ${LLVM_INCLUDE_DOCS})
+
+if (FLANG_INCLUDE_DOCS)
+  add_subdirectory(docs)
+endif()
+
+# Custom target to install Flang libraries.
+add_custom_target(flang-libraries)
+set_target_properties(flang-libraries PROPERTIES FOLDER "Misc")
+
+if (NOT LLVM_ENABLE_IDE)
+  add_llvm_install_targets(install-flang-libraries
+                           DEPENDS flang-libraries
+			   COMPONENT flang-libraries)
+endif()
+
+get_property(FLANG_LIBS GLOBAL PROPERTY FLANG_LIBS)
+if (FLANG_LIBS)
+  list(REMOVE_DUPLICATES FLANG_LIBS)
+  foreach(lib ${FLANG_LIBS})
+    add_dependencies(flang-libraries ${lib})
+    if (NOT LLVM_ENABLE_IDE)
+      add_dependencies(install-flang-libraries install-${lib})
+    endif()
+  endforeach()
+endif()
+
+add_subdirectory(cmake/modules)
 
 configure_file(
   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
   ${FLANG_BINARY_DIR}/include/flang/Config/config.h)
+
+add_subdirectory(test-lit)
diff --git a/README.md b/README.md
index ed3775c0d588..3ee6a3ea590d 100644
--- a/README.md
+++ b/README.md
@@ -6,196 +6,102 @@
 
 -->
 
-# F18
+# FIR
 
-F18 is a ground-up implementation of a Fortran front end written in modern C++.
-F18, when combined with LLVM, is intended to replace the Flang compiler.
+Working branch for FIR development.
 
-Flang is a Fortran compiler targeting LLVM.
-Visit the [Flang wiki](https://github.com/flang-compiler/flang/wiki)
-for more information about Flang.
+## Monorepo now contains MLIR
 
-## Getting Started
+### In-tree build
 
-Read more about f18 in the [documentation directory](documentation).
-Start with the [compiler overview](documentation/Overview.md).
+This is quite similar to the old way, but with a few subtle differences.
 
-To better understand Fortran as a language
-and the specific grammar accepted by f18,
-read [Fortran For C Programmers](documentation/FortranForCProgrammers.md)
-and
-f18's specifications of the [Fortran grammar](documentation/f2018-grammar.txt)
-and
-the [OpenMP grammar](documentation/OpenMP-4.5-grammar.txt).
+1. Get the stuff.
 
-Treatment of language extensions is covered
-in [this document](documentation/Extensions.md).
-
-To understand the compilers handling of intrinsics,
-see the [discussion of intrinsics](documentation/Intrinsics.md).
-
-To understand how an f18 program communicates with libraries at runtime,
-see the discussion of [runtime descriptors](documentation/RuntimeDescriptor.md).
-
-If you're interested in contributing to the compiler,
-read the [style guide](documentation/C++style.md)
-and
-also review [how f18 uses modern C++ features](documentation/C++17.md).
-
-## Building F18
+```
+  git clone git@github.com:flang-compiler/f18-llvm-project.git
+  git clone git@github.com:schweitzpgi/f18.git 
+```
 
-### Get the Source Code
+2. Get "on" the right branches.
 
 ```
-cd where/you/want/the/source
-git clone https://github.com/flang-compiler/f18.git
+  (cd f18-llvm-project ; git checkout mono)
+  (cd f18 ; git checkout mono)
+```
+             
+3. Setup the LLVM space for in-tree builds.
+   
+``` 
+  (cd f18-llvm-project ; ln -s ../f18 flang)
 ```
 
-### Supported C++ compilers
+4. Create a build space for cmake and make (or ninja)
 
-F18 is written in C++17 and it has LLVM libraries dependency.
+```
+  mkdir build
+  cd build
+  cmake ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS="flang;mlir" -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DLLVM_INSTALL_UTILS=On <other-arguments>
+```
 
-The code has been compiled and tested with
-GCC versions from 7.2.0 to 9.3.0.
+5. Build everything
 
-The code has been compiled and tested with
-clang version 7.0, 8.0, 9.0 and 10.0
-using either GNU's libstdc++ or LLVM's libc++.
+One can, for example, do this with make as follows.
 
-The code has been compiled on
-AArch64, x86_64 and ppc64le servers
-with CentOS7, Ubuntu18.04, Rhel, MacOs, Mojave, XCode and
-Apple LLVM version 10.0.1.
+```
+  make <make-arguments>
+```
 
-The code does not compile with Windows and
-a compiler that does not have support for C++17.
+Or, of course, use their favorite build tool (such as ninja).
 
-### LLVM dependency
+### Out-of-tree build
 
-F18 uses components from LLVM.
+1. Get the stuff is the same as above. Get the code from the same repos.
 
-The instructions to build LLVM can be found at
-https://llvm.org/docs/GettingStarted.html.
+2. Get on the right branches. Again, same as above.
 
-We highly recommend using the same compiler to compile both llvm and f18.
+3. SKIP step 3 above. We're not going to build `flang` yet.
 
-The f18 CMakeList.txt file uses
-the variable `LLVM_DIR` to find the installed LLVM components
-and
-the variable `MLIR_DIR` to find the installed MLIR components.
+4. Create a build space for cmake and make (or ninja)
 
-To get the correct LLVM and MLIR libraries included in your f18 build,
-define LLVM_DIR and MLIR_DIR on the cmake command line.
 ```
-LLVM=<LLVM_BUILD_DIR>/lib/cmake/llvm \
-MLIR=<LLVM_BUILD_DIR>/lib/cmake/mlir \
-cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ...
+  mkdir build
+  cd build
+  export CC=<my-favorite-C-compiler>
+  export CXX=<my-favorite-C++-compiler>
+  cmake -GNinja ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DCMAKE_INSTALL_PREFIX=<install-llvm-here> <other-arguments>
 ```
-where `LLVM_BUILD_DIR` is
-the top-level directory where LLVM was built.
-
-### Building f18 with GCC
 
-By default,
-cmake will search for g++ on your PATH.
-The g++ version must be one of the supported versions
-in order to build f18.
-
-Or,
-cmake will use the variable CXX to find the C++ compiler.
-CXX should include the full path to the compiler
-or a name that will be found on your PATH,
-e.g. g++-8.3, assuming g++-8.3 is on your PATH.
-```
-export CXX=g++-8.3
-```
-or
-```
-CXX=/opt/gcc-8.3/bin/g++-8.3 cmake ...
-```
-There's a third option!
-The CMakeList.txt file uses the variable GCC
-as the path to the bin directory containing the C++ compiler.
+5. Build and install
 
-GCC can be defined on the cmake command line
-where `<GCC_DIRECTORY>` is the path to a GCC installation with bin, lib, etc:
 ```
-cmake -DGCC=<GCC_DIRECTORY> ...
+  ninja
+  ninja install
 ```
 
-### Building f18 with clang
-
-To build f18 with clang,
-cmake needs to know how to find clang++
-and the GCC library and tools that were used to build clang++.
-
-The CMakeList.txt file expects either CXX or BUILD_WITH_CLANG to be set.
+6. Add the new installation to your PATH
 
-CXX should include the full path to clang++
-or clang++ should be found on your PATH.
-```
-export CXX=clang++
-```
-BUILD_WITH_CLANG can be defined on the cmake command line
-where `<CLANG_DIRECTORY>`
-is the path to a clang installation with bin, lib, etc:
-```
-cmake -DBUILD_WITH_CLANG=<CLANG_DIRECTORY>
-```
-Or GCC can be defined on the f18 cmake command line
-where `<GCC_DIRECTORY>` is the path to a GCC installation with bin, lib, etc:
 ```
-cmake -DGCC=<GCC_DIRECTORY> ...
+  PATH=<install-llvm-here>/bin:$PATH
 ```
-To use f18 after it is built,
-the environment variables PATH and LD_LIBRARY_PATH
-must be set to use GCC and its associated libraries.
 
-### Installation Directory
+7. Create a build space for another round of cmake and make (or ninja)
 
-To specify a custom install location,
-add
-`-DCMAKE_INSTALL_PREFIX=<INSTALL_PREFIX>`
-to the cmake command
-where `<INSTALL_PREFIX>`
-is the path where f18 should be installed.
-
-### Build Types
-
-To create a debug build,
-add
-`-DCMAKE_BUILD_TYPE=Debug`
-to the cmake command.
-Debug builds execute slowly.
-
-To create a release build,
-add
-`-DCMAKE_BUILD_TYPE=Release`
-to the cmake command.
-Release builds execute quickly.
-
-### Build F18
 ```
-cd ~/f18/build
-cmake -DLLVM_DIR=$LLVM -DMLIR_DIR=$MLIR ~/f18/src
-make
+  mkdir build-flang
+  cd build-flang
+  cmake -GNinja ../f18 -DLLVM_DIR=<install-llvm-here> -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86 -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DCMAKE_INSTALL_PREFIX=<install-flang-here> <other-arguments>
 ```
 
-### How to Run the Regression Tests
+8. Build and install
 
-To run all tests:
 ```
-cd ~/f18/build
-cmake -DLLVM_DIR=$LLVM ~/f18/src
-make check-flang
+  ninja
+  ninja check-flang
+  ninja install
 ```
 
-To run individual regression tests llvm-lit needs to know the lit
-configuration for f18. The parameters in charge of this are:
-flang_site_config and flang_config. And they can be set as shown bellow:
-```
-<path-to-llvm-lit>/llvm-lit \
- --param flang_site_config=<path-to-f18-build>/test-lit/lit.site.cfg.py \
- --param flang_config=<path-to-f18-build>/test-lit/lit.cfg.py \
-  <path-to-fortran-test>
-```
+### Problems
+
+Despite best efforts, there may be situations where the above repos will
+get out of sync, and the build will fail.
diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
new file mode 100644
index 000000000000..d4915e101ea6
--- /dev/null
+++ b/docs/CMakeLists.txt
@@ -0,0 +1,92 @@
+if (DOXYGEN_FOUND)
+if (LLVM_ENABLE_DOXYGEN)
+  set(abs_srcdir ${CMAKE_CURRENT_SOURCE_DIR})
+  set(abs_builddir ${CMAKE_CURRENT_BINARY_DIR})
+
+  if (HAVE_DOT)
+    set(DOT ${LLVM_PATH_DOT})
+  endif()
+
+  if (LLVM_DOXYGEN_EXTERNAL_SEARCH)
+    set(enable_searchengine "YES")
+    set(searchengine_url "${LLVM_DOXYGEN_SEARCHENGINE_URL}")
+    set(enable_server_based_search "YES")
+    set(enable_external_search "YES")
+    set(extra_search_mappings "${LLVM_DOXYGEN_SEARCH_MAPPINGS}")
+  else()
+    set(enable_searchengine "NO")
+    set(searchengine_url "")
+    set(enable_server_based_search "NO")
+    set(enable_external_search "NO")
+    set(extra_search_mappings "")
+  endif()
+
+  # If asked, configure doxygen for the creation of a Qt Compressed Help file.
+  if (LLVM_ENABLE_DOXYGEN_QT_HELP)
+    set(FLANG_DOXYGEN_QCH_FILENAME "org.llvm.flang.qch" CACHE STRING
+      "Filename of the Qt Compressed help file")
+    set(FLANG_DOXYGEN_QHP_NAMESPACE "org.llvm.flang" CACHE STRING
+      "Namespace under which the intermediate Qt Help Project file lives")
+    set(FLANG_DOXYGEN_QHP_CUST_FILTER_NAME "Flang ${FLANG_VERSION}" CACHE STRING
+      "See http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-filters")
+    set(FLANG_DOXYGEN_QHP_CUST_FILTER_ATTRS "Flang,${FLANG_VERSION}" CACHE STRING
+      "See http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes")
+    set(flang_doxygen_generate_qhp "YES")
+    set(flang_doxygen_qch_filename "${FLANG_DOXYGEN_QCH_FILENAME}")
+    set(flang_doxygen_qhp_namespace "${FLANG_DOXYGEN_QHP_NAMESPACE}")
+    set(flang_doxygen_qhelpgenerator_path "${LLVM_DOXYGEN_QHELPGENERATOR_PATH}")
+    set(flang_doxygen_qhp_cust_filter_name "${FLANG_DOXYGEN_QHP_CUST_FILTER_NAME}")
+    set(flang_doxygen_qhp_cust_filter_attrs "${FLANG_DOXYGEN_QHP_CUST_FILTER_ATTRS}")
+  else()
+    set(flang_doxygen_generate_qhp "NO")
+    set(flang_doxygen_qch_filename "")
+    set(flang_doxygen_qhp_namespace "")
+    set(flang_doxygen_qhelpgenerator_path "")
+    set(flang_doxygen_qhp_cust_filter_name "")
+    set(flang_doxygen_qhp_cust_filter_attrs "")
+  endif()
+
+  option(LLVM_DOXYGEN_SVG
+    "Use svg instead of png files for doxygen graphs." OFF)
+  if (LLVM_DOXYGEN_SVG)
+    set(DOT_IMAGE_FORMAT "svg")
+  else()
+    set(DOT_IMAGE_FORMAT "png")
+  endif()
+
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doxygen.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg @ONLY)
+
+  set(abs_top_srcdir)
+  set(abs_top_builddir)
+  set(DOT)
+  set(enable_searchengine)
+  set(searchengine_url)
+  set(enable_server_based_search)
+  set(enable_external_search)
+  set(extra_search_mappings)
+  set(flang_doxygen_generate_qhp)
+  set(flang_doxygen_qch_filename)
+  set(flang_doxygen_qhp_namespace)
+  set(flang_doxygen_qhelpgenerator_path)
+  set(flang_doxygen_qhp_cust_filter_name)
+  set(flang_doxygen_qhp_cust_filter_attrs)
+  set(DOT_IMAGE_FORMAT)
+
+  add_custom_target(doxygen-flang
+    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMENT "Generating flang doxygen documentation." VERBATIM)
+
+  if (LLVM_BUILD_DOCS)
+    add_dependencies(doxygen doxygen-flang)
+  endif()
+
+  if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doxygen/html
+      DESTINATION docs/html)
+  endif()
+endif()
+endif()
+
+# FIXME: skipping sphinx for now...
diff --git a/docs/doxygen.cfg.in b/docs/doxygen.cfg.in
new file mode 100644
index 000000000000..cf49203c0f91
--- /dev/null
+++ b/docs/doxygen.cfg.in
@@ -0,0 +1,2293 @@
+# Doxyfile 1.8.6
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all text
+# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
+# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
+# for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = flang
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         = @PACKAGE_VERSION@
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          =
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
+# the documentation. The maximum height of the logo should not exceed 55 pixels
+# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
+# to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = @abs_builddir@/doxygen
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       =
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        = @abs_srcdir@/..
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    = @abs_srcdir@/../include
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = YES
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
+# new page for each member. If set to NO, the documentation of a member will be
+# part of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 2
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines.
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. For instance to make
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
+# (default is Fortran), use: inc=Fortran f=C.
+#
+# Note For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word
+# or globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 3
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO these classes will be included in the various overviews. This option has
+# no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) declarations. If set to NO these declarations will be
+# included in the documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = YES
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
+# todo list. This list is created by putting \todo commands in the
+# documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
+# test list. This list is created by putting \test commands in the
+# documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES the list
+# will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. Do not use file names with spaces, bibtex cannot handle them. See
+# also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = NO
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = NO
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO doxygen will only warn about wrong or incomplete parameter
+# documentation, but not about the absence of documentation.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces.
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = @abs_srcdir@/../include \
+                         @abs_srcdir@/../lib \
+                         @abs_srcdir@/doxygen-mainpage.dox
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: http://www.gnu.org/software/libiconv) for the list of
+# possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank the
+# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
+# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
+# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
+# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
+# *.qsf, *.as and *.js.
+
+FILE_PATTERNS          =
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           = @abs_srcdir@/../examples
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       =
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = YES
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             = @abs_srcdir@/img
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER ) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = NO
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# function all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = YES
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see http://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 4
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          = flang::
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user-
+# defined cascading style sheet that is included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet file to the output directory. For an example
+# see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the stylesheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: http://developer.apple.com/tools/xcode/), introduced with
+# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler ( hhc.exe). If non-empty
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated (
+# YES) or that it should be included in the master .chm file ( NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated (
+# YES) or a normal table of contents ( NO) in the .chm file.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = @flang_doxygen_generate_qhp@
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               = @flang_doxygen_qch_filename@
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = @flang_doxygen_qhp_namespace@
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   = @flang_doxygen_qhp_cust_filter_name@
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  = @flang_doxygen_qhp_cust_filter_attrs@
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           = @flang_doxygen_qhelpgenerator_path@
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using prerendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = @enable_searchengine@
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavours of web server based searching depending on the
+# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
+# searching and an index file used by the script. When EXTERNAL_SEARCH is
+# enabled the indexing and searching needs to be provided by external tools. See
+# the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = @enable_server_based_search@
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = @enable_external_search@
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       = @searchengine_url@
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     = flang
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  = @extra_search_mappings@
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. To get the times font for
+# instance you can specify
+# EXTRA_PACKAGES=times
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber. Doxygen will
+# replace them by respectively the title of the page, the current date and time,
+# only the current date, the version number of doxygen, the project name (see
+# PROJECT_NAME), or the project number (see PROJECT_NUMBER).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the LATEX_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's config
+# file, i.e. a series of assignments. You only have to provide replacements,
+# missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's config file. A template extensions file can be generated
+# using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
+# Definitions (see http://autogen.sf.net) file that captures the structure of
+# the code including all documentation. Note that this feature is still
+# experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
+# in the source code. If set to NO only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = YES
+
+# If the SEARCH_INCLUDES tag is set to YES the includes files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           = ../include
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             = LLVM_ALIGNAS(x)=
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have an
+# all uppercase name, and do not end with a semicolon. Such function macros are
+# typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have an unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
+# class index. If set to NO only the inherited external classes will be listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = YES
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
+# the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES, the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = NO
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: NO.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font n the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = YES
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot.
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, jpg, gif and svg.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = @DOT_IMAGE_FORMAT@
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               = @DOT@
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = YES
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = YES
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/documentation/BurnsideToFIR.md b/documentation/BurnsideToFIR.md
new file mode 100644
index 000000000000..de4d1ff44dd9
--- /dev/null
+++ b/documentation/BurnsideToFIR.md
@@ -0,0 +1,823 @@
+## Burnside: The Bridge from the Fortran front-end to FIR
+
+This document sketches the translation of various Fortran snippets from
+their syntactic level to how they ought to be represented in FIR.  These
+translations are representative and written in pseudo-code.
+
+This document shows examples of how Fortran fragments might be lowered into
+FIR fragments.  The style used throughout the document is to first show the
+Fortran code fragment above a line and the FIR code fragment below the
+line.
+
+### Program Units (PROGRAM, MODULE, and SUBMODULE)
+
+FIR has one flat global namespace.  The global namespace can be populated
+by Ops that represent code (functions), data (variables, constants), and
+auxiliary structures (dispatch tables).
+
+Name collisions and scoping will be handled by a name mangling scheme. This
+scheme ought to be a bijection from the tree of Fortran syntactic symbols
+to and from the set of mangled names.
+
+A `PROGRAM` will necessarily have its executable definition wrapped in a
+FIR `func` like a `SUBROUTINE`.  Again, it is assumed the name mangling
+scheme will provide a mapping to a distinct name.
+
+### Procedures (FUNCTION and SUBROUTINE)
+
+```fortran
+    FUNCTION foo (arg1, arg2) RESULT retval
+
+    SUBROUTINE bar (arg1, arg2)
+```
+----
+```mlir
+    func @foo(!fir.ref<!T1>, !fir.ref<!T2>) -> !TR
+    func @bar(!fir.ref<!T1>, !fir.ref<!T2>)
+```
+
+MLIR is strongly typed, so the types of the arguments and return value(s),
+if any, must be explicitly specified.  (Here, `arg1`, `arg2`, and `retval`
+have the types `!T1`, `!T2`, and `!TR`, resp.)  Also reflected is the
+default calling convention: Fortran passes arguments by reference.
+
+#### Internal subprograms
+
+These will be lowered as any other `SUBROUTINE`. The difference will be
+that they may take an extra `tuple` reference argument to refer to
+variables in the host context.  Host associated variables must be bundled
+and passed explicitly on the FIR side. An example will be detailed below.
+
+#### Statement functions
+
+These are very simple internal subroutines, in a sense. They will be
+lowered in the same way.
+
+### Non-executable statements
+
+#### Data
+
+Some non-executable statements may create constant (`PARAMETER`) or
+variable data.  This information should be lowered.
+
+##### Constants
+
+```fortran
+    INTEGER, PARAMETER :: x = 1
+    CHARACTER (LEN = 10), PARAMETER :: DIGITS = "0123456789"
+```
+----
+```mlir
+    %0 = constant 1 : i32
+
+    fir.global @_QG_digits constant : !fir.array<10:!fir.char<1>> {
+      constant '0' : !fir.char<1>
+      ...
+      constant '9' : !fir.char<1>
+    }
+```
+
+##### Local Variable
+
+```fortran
+    CHARACTER (LEN = 1) :: digit
+    INTEGER :: i
+```
+----
+```mlir
+    %len = constant 1 : i32
+    %digit = fir.alloca !fir.char<1>, %len : !fir.ref<!fir.char<1>>
+    %i = fir.alloca i32 : !fir.ref<i32>
+```
+
+Note that in MLIR, the `%` sigil denotes an ssa-value, the `@` sigil
+denotes a global symbol, and the `!` sigil denotes a type.
+
+##### Process lifetime variable
+
+```fortran
+    COMMON /X/ A(10),B(10)
+
+    MODULE mymod
+      INTEGER a
+
+    SUBROUTINE subr()
+      REAL, SAVE :: s
+      DATA s/12.0/
+```
+----
+```mlir
+    fir.global @common_x : tuple<!fir.array<10 : f32>, !fir.array<10 : f32>> {}
+
+    fir.global @mymod_a : i32 {}
+
+    fir.global @subr_s : f32 {
+      constant 12.0 : f32
+    }
+```
+
+The empty initializer region could mean these variables are placed in the
+`.bss` section.
+
+#### Other non-executable statements
+
+These statements will define other properties of how the Fortran gets
+lowered.  For example, a variable in a `COMMON` block needs to reside in a
+`fir.global`, or the structure of a derived type (user-defined record),
+which would be reflected in a `!fir.type`.
+
+#### A note on TYPEs
+
+A FIR type is an synthesis of the Fortran concepts of type, attributes, and
+type parameters.
+
+##### Intrinsic types
+
+For Fortran intrinsic types, there is a direct translation to a FIR type.
+
+```fortran
+    REAL(4) a
+    COMPLEX(8) b
+    CHARACTER(1,LEN=4) c
+    LOGICAL(1) d
+    INTEGER(4) e
+
+    CHARACTER(1,LEN=*) f
+```
+----
+```mlir
+    %a = ... : !fir.real<4>
+    %b = ... : !fir.complex<8>
+    %c = ... : !fir.array<4:!fir.char<1>>
+    %d = ... : !fir.logical<1>
+    %e = ... : !fir.int<4>
+
+    %f_data = ... : !fir.ref<!fir.array<?:!fir.char<1>>>
+    %f_len = ... : i32
+    %f = fir.emboxchar %f_data, %f_len : !fir.boxchar<1>
+```
+
+The bridge will have a mapping of what the front-end kind value must map to
+in the internal representation.  For example, the f18 front-end maps kind
+values for integers to the size in bytes of the integer representation.
+Such mappings must be provided for all intrinsic type kind values.
+
+The Fortran `CHARACTER` variable, `f`, is a bit more complicated as there
+is both a reference to a buffer (that contains the characters) and an
+extra, assumed length, `LEN` type parameter to keep track of the length of
+the buffer.  The buffer is a sequence of `!fir.char<1>` values in memory.
+The pair, `(buffer, len)`, may be boxed in a `!fir.boxchar<1>` type
+object.
+
+##### Derived types
+
+Fortran also has derived types and these are supported with a more
+elaborate record syntax.
+
+```fortran
+    TYPE :: person
+      CHARACTER(LEN=20) :: name
+      INTEGER :: age
+    END TYPE
+
+    TYPE(person) :: george
+```
+----
+```mlir
+    %george = ... : !fir.type<person {name : !fir.array<20:!fir.char<1>>, age : i32}>
+```
+
+Fortran allows the compiler to reorder the fields in the derived type.
+`SEQUENCE` can be used to disable reordering. (Name mangling can provide a
+compile-time distinction, as needed.)
+
+Fortran allows a derived type to have type parameters. There are `KIND`
+type parameters and `LEN` type parameters. A `KIND` type parameter is a
+compile-time known constant. As such, it is possible for the compiler
+implementation to create a distinct type for each set of `KIND` type
+parameters (by name mangling, for instance).
+
+The `LEN` type parameters are runtime constant and not necessarily known at
+compile-time. These values must be provided when constructing a value of
+derived type in FIR, just as regular fields must be provided. (That does
+not preclude an optimizer from eliminating unused `LEN` parameters.)
+
+Because of Fortran's `LEN` type parameters, an implementation is allowed to
+defer the size and layout of an entity of derived type until runtime.
+
+Lowering may also exploit ad hoc product types created as needed. This can
+be done using the standard dialect `tuple` type.
+
+##### Arrays
+
+An entity with type _T_ and a `DIMENSION` attribute is an array with
+elements of type _T_ in Fortran.
+
+```fortran
+    INTEGER arr
+    DIMENSION arr(10,20)
+```
+----
+```mlir
+    %arr = ... : !fir.array<10x20 : i32>
+```
+
+A FIR array is laid out in column-major order exactly like a Fortran array.
+
+##### Pointer and reference types
+
+The attribute `POINTER` can be used similarly to create a pointer entity.
+The `ALLOCATABLE` attribute is another Fortran attribute that can be used
+to indicate an entity's storage is to be allocated at runtime. As mentiond
+previosuly, Fortran uses pass-by-reference calling semantics too.
+
+```fortran
+    INTEGER, POINTER :: ptr
+    REAL, ALLOCATABLE, DIMENSION(1000) :: al
+
+    INTERFACE
+      SUBROUTINE fun(ptr, al)
+        INTEGER, POINTER :: p
+        REAL, ALLOCATABLE :: a
+      END SUBROUTINE
+    END INTERFACE
+```
+----
+```mlir
+    %ptr = ... : !fir.ptr<i32>
+    %al = ... : !fir.heap<!fir.array<1000 : f32>>
+
+    func @fun(!fir.ref<!fir.ptr<i32>>, !fir.ref<!fir.heap<f32>>)
+```
+
+Note that references to pointers and heap allocatables are
+allowed. However, a pointer/heap cannot point directly to a pointer/heap.
+
+```mlir
+    %err1 = ... : !fir.ptr<!fir.ptr<i32>>   // Invalid type
+    %err2 = ... : !fir.heap<!fir.ptr<i32>>  // Invalid type
+```
+
+Note that a value of function type is also considered a reference.
+
+```mlir
+    %fun = ... : (i32, f64) -> i1   // %fun is a reference to a func object
+```
+
+##### Boxed types
+
+Boxed types are reference types. A boxed entity is implicitly located in
+memory.  The only way to construct a boxed value is by providing a memory
+reference type, discussed above. Any reference can be emboxed.
+
+There are additionally, two special-purpose box types. A `!fir.boxchar`
+value is a `CHARACTER` variable (in memory) including both a pointer to the
+buffer and the `LEN` type parameter. `boxchar` was discussed above.
+
+The second special case is the `!fir.boxproc` type. A Fortran internal
+procedure can reference variables in its host's scope. Fortran also allows
+pointers to procedures. A value of type `!fir.boxproc` then is a pair of
+references, one for the procedure pointer and the other a pointer to a
+tuple of host associated values.
+
+```fortran
+    SUBROUTINE host
+      REAL X
+      PROCEDURE(), POINTER :: procptr
+      ...
+      procptr => intern
+      ...
+      CALL procptr
+    CONTAINS
+      SUBROUTINE intern
+        X = ...
+```
+----
+```mlir
+    func @host() {
+      %x = ... : !fir.ref<f32>
+      ...
+      %bag_val = fir.insert_value %b, %x, %0 : ... -> tuple<!fir.ref<f32>, ...>
+      %bag = ... : !fir.ref<tuple<!fir.ref<f32>, ...>>
+      fir.store %bag_val to %bag : !fir.ref<tuple<!fir.ref<f32>, ...>>
+      %procptr = fir.emboxproc @intern, %bag : ... -> !fir.boxproc<() -> ()>
+      ...
+      fir.call %procptr() : () -> ()
+```
+
+Here, the call to the boxed procedure implicitly passes the extra argument, the
+reference to `%bag`, which contains the value of the variable `x`.
+
+##### Miscellaneous types
+
+Fortran uses triple notation to describe array sections, strided views of
+multidimensional arrays.  These sections can be captured using the
+`fir.gendims` instruction which produces a value of type `!fir.dims<n>`.
+
+```fortran
+    DIMENSION (10,10) a
+    ... a(2:6:2,1:7:4) ...
+```
+----
+```mlir
+    // the following line is pseudocode
+    %1 = fir.gendims 2,6,2, 1,7,4 : !fir.dims<2>
+```
+
+Fortran also allows the implementation to reorder fields in a derived
+type. Furthermore, the sizes of these fields and the layout may be left up
+to the runtime. This could mean that the backend needs to generate runtime
+calls to determine the offsets and sizes of fields.
+
+```fortran
+    TYPE ding(k)
+      ...
+      TYPE(T(k)) :: field_name
+```
+----
+```mlir
+    %2 = fir.field("field_name") : !fir.field
+```
+
+When lowering a boxed value, the compiler may need to test what the exact
+type of the value is at runtime. (For example, when generating code for
+`SELECT TYPE`.)
+
+```fortran
+    CLASS(*) :: x
+    SELECT TYPE (x)
+      ...
+```
+----
+```mlir
+    %1 = fir.box_tdesc %x : (!fir.box<none>) -> !fir.tdesc<none>
+```
+
+The `none` type is used when the entity has unlimited polymorphic type. See
+below for a larger example of `SELECT TYPE`.
+
+### Executable statements
+
+The main purpose of lowering is to lower all the executable statements from
+Fortran into FIR in a semantics preserving way.
+
+#### Substrings
+
+```fortran
+    ID(4:9)
+```
+----
+```mlir
+    %id = ... : !fir.ref<!fir.array<20 : !fir.char<1>>>
+    %1 = fir.coordinate_of %id, %c3 : ... -> !fir.ref<!fir.char<1>>
+    %2 = fir.emboxchar %1, %c5 : ... -> !fir.boxchar<1>
+```
+
+#### Structure components
+
+```fortran
+    scalar_parent%scalar_field
+```
+----
+```mlir
+    %sf = fir.field("scalar_field") : !fir.field
+    %1 = fir.coordinate_of %scalar_parent, %sf : ... -> !fir.ref<f32>
+```
+
+#### Type parameters
+
+```fortran
+    TYPE ding(dim)
+      INTEGER, LEN :: dim
+      REAL :: values(dim)
+    END TYPE ding
+
+    ding(x) :: a_ding
+    ... a_ding%dim ... 
+```
+----
+```mlir
+    %1 = fir.len_param_index("dim") : !fir.field
+    %2 = fir.coordinate_of %a_ding, %1 : ... -> !fir.ref<i32>
+    %3 = fir.load %2 : !fir.ref<i32>
+```
+
+#### Arrays
+
+```fortran
+    ... A ...         ! whole array
+    ... B(4) ...      ! array element
+    ... C(1:10) ...   ! array section
+    ... D(1:10:2) ... ! array section with stride
+    INTEGER, DIMENSION :: V(4)
+    ... E(V) ...      ! array section with vector subscript
+```
+----
+```mlir
+    %1 = fir.load %a : !fir.ref<!fir.array<*:f32>>
+
+    %2 = fir.extract_element %b, %c4 : (!fir.array<?:f32>, i32) -> f32
+
+    %3 = fir.coordinate_of %c, %c1 : (!fir.ref<!fir.array<?:f32>>, i32) -> !fir.ref<f32>
+    %4 = fir.convert %3 : (!fir.ref<f32>) -> !fir.ref<!fir.array<10:f32>>
+    %5 = fir.load %4 : (!fir.ref<!fir.array<10:f32>>) -> !fir.array<10:f32>
+
+    %6 = fir.gendims %c1, %c10, %c2 : (i32, i32, i32) -> !fir.dims<1>
+    %7 = fir.embox %d, %6 : (!fir.ref<!fir.array<40:f32>>, !fir.dims<1>) -> !fir.embox<!fir.array<10:f32>>
+
+    // create a temporary to hold E(V)
+    %v = ... : !fir.array<4:i32>
+    %8 = fir.alloca !fir.array<4:f32> : !fir.ref<!fir.array<4:f32>>
+    fir.loop %i = %c1 to %c4 unordered {
+      %9 = fir.extract_value %v, %i : (!fir.array<4:i32>, index) -> i32
+      %10 = fir.extract_value %e, %9 : (!fir.array<?:f32>, i32) -> f32
+      %11 = fir.coordinate_of %8, %i : (!fir.ref<!fir.array<4:f32>>, index) -> !fir.ref<f32>
+      fir.store %10 to %11 : !fir.ref<f32>
+    }
+```
+
+In the fourth case, lowering could also create a temporary and copy the
+values from the section `D(1:10:2)` into it, but the preference should be
+to defer copying data until it is necessary (as in the fifth non-affine
+case, `E(V)`).
+
+#### Image selector
+
+```fortran
+    REAL :: A(10)[5,*]
+
+    ... A(:)[1,4] ...    ! selects image 16 (if available)
+```
+----
+```mlir
+    %1 = fir.call @runtime_fetch_array(%a, %c_1, %c_4, ...) : (!fir.box<!fir.array<10:f32>>, i32, i32, ...) -> !fir.ref<!fir.array<10:f32>>
+```
+
+#### Dynamic association
+
+```fortran
+    ALLOCATE (x(n), b(-3:m, 0:9))
+
+    NULLIFY (p)
+
+    DEALLOCATE (x, b)
+```
+----
+```mlir
+    %x = fir.allocmem f32, %n : !fir.heap<!fir.array<?:f32>>
+
+    %c4 = constant 4 : i32
+    %1 = addi %m, %c4 : i32
+    %2 = constant 10 : i32
+    %b = fir.allocmem f32, %1, %2 : !fir.heap<!fir.array<?x10:f32>>
+
+    %zero = constant 0 : i64
+    %null = fir.convert %zero : (i64) -> !fir.ptr<none>
+    fir.store %null to %p : !fir.ref<!fir.ptr<none>>
+
+    fir.freemem %x : !fir.heap<!fir.array<?:f32>>
+    fir.freemem %b : !fir.heap<!fir.array<?x10:f32>>
+```
+
+#### Basic operators
+
+Operators like `**`, `*`, `/`, etc. will be lowered into standard dialect
+operations or runtime calls as needed.
+
+```fortran
+    a * b
+    c .LE. d
+```
+----
+```mlir
+    %0 = mulf %a, %b : f32
+    %1 = cmp "le" %c, %d : (f32, f32) -> i1
+```
+
+#### Calls
+
+```fortran
+    CALL foo(v1)
+    ... func(v2, v3) ...
+
+    pp => bar
+    CALL pp(v4)
+
+    CALL object%method(arg)
+```
+----
+```mlir
+    fir.call @foo(%v1) : (!fir.ref<!T1>) -> ()
+    %1 = fir.call @func(%v2, %v3) : (!fir.ref<!T2, !T3>) -> i64
+
+    %pp = fir.address_of(@bar) : ((!fir.ref<i64>) -> ()) -> !fir.ref<(!fir.ref<i64>) -> ()>
+    fir.icall %pp(%v4) : (!fir.ref<i64>) -> ()
+
+    fir.dispatch "method"(%object, %arg) : (!fir.box<!fir.type<mytype{f1:i64, f2:f64}>>, !fir.ref<i64>) -> ()
+```
+
+There are two modes of argument passing in Fortran: calls that are "Fortran
+77" style and use an implicit interface, and calls that require an
+interface. In FIR, this translates to passing a simple reference to an
+entity's data versus passing a boxed reference value. The following calls
+illustrate this distinction.
+
+```fortran
+    SUBROUTINE sub1(a)
+      INTEGER :: a(10,10)  ! F77 style
+      ...
+    INTERFACE
+      SUBROUTINE sub2(a)
+        INTEGER :: a(:,:)    ! assumed shape
+      ...
+    PROGRAM p
+      INTEGER :: a(10,10)
+      CALL sub1(a)
+      CALL sub2(a)
+```
+----
+```mlir
+    func @sub1(!fir.ref<!fir.array<10x10:i32>>) -> ()
+    func @sub1(!fir.box<!fir.array<?x?:i32>>) -> ()
+
+    func @_QP_p() {
+      %c1 = constant 1 : i32
+      %c10 = constant 10 : i32
+      %a1 = fir.alloca !fir.array<10x10:i32> : !fir.ref<!fir.array<10x10:i32>>
+      fir.call @sub1(%a1) : (!fir.ref<!fir.array<10x10:i32>>) -> ()
+      %1 = fir.gendims %c1, %c10, %c1, %c1, %c10, %c1 : (i32,i32,i32,i32,i32,i32) -> !fir.dims<2>
+      %a2 = fir.embox %a1, %1 : (!fir.ref<!fir.array<10x10:i32>>, !fir.dims<2>) -> !fir.box<!fir.array<?x?:i32>>
+      fir.call @sub2(%a2) : (!fir.box<!fir.array<?x?:i32>>) -> ()
+```
+
+When lowering into FIR, the bridge must explicitly perform any allocation,
+copying, deallocation, and finalization on temporary entities as required
+by the Fortran standard, preserving the copy-in copy-out calling
+convention.
+
+#### Parentheses (10.1.8)
+
+```fortran
+    (a + b) + (a + c)  ! cannot rewrite as (2 * a) + b + c
+```
+----
+```mlir
+    %1 = addf %a, %b : f32
+    %2 = fir.no_reassoc %1 : f32  // to prevent reassociation
+    %3 = addf %a, %c : f32
+    %4 = fir.no_reassoc %3 : f32
+    %5 = addf %2, %4 : f32
+```
+
+One must also specify to LLVM that these operations will not be reassociated.
+
+#### Assignment
+
+```fortran
+    scalar = e1   ! intrinsic scalar assignment
+    array = e2    ! intrinsic array assignment
+    object = e3   ! defined assignment
+    pntr => e4    ! pointer assignment
+    pproc => func ! procedure pointer assignment
+```
+----
+```mlir
+    %e1 = ... : f32
+    fir.store %e1 to %scalar : !fir.ref<f32>
+    
+    %e2 = ... : !fir.array<10x10 : i32>
+    fir.store %e2 to %array : !fir.ref<!fir.array<10x10 : i32>>
+
+    %e3 = ... !fir.ref<!T>
+    %object = ... !fir.ref<!U>
+    fir.call @defd_assn(%object, %e3) : ... -> ()
+
+    %e4 = ... : !fir.ptr<!V>
+    %pntr = ... : !fir.ref<!fir.ptr<!V>>
+    fir.store %e4 to %pntr : !fir.ref<!fir.ptr<!V>>
+
+    @func(i32, i32) -> i32
+    %fn = fir.address_of(@func) : ((i32, i32) -> i32) -> !fir.ptr<(i32, i32) -> i32>
+    %pproc = ... : !fir.ref<!fir.ptr<(i32, i32) -> i32>>
+    fir.store %fn to %pproc : !fir.ref<!fir.ptr<(i32, i32) -> i32>>
+```
+
+#### Masked assignment
+
+```fortran
+    WHERE (arr < threshold)
+      arr = arr + increment
+    ELSEWHERE
+      arr = threshold
+    END WHILE
+```
+----
+```mlir
+    %arr = ... : !fir.array<?:!T>
+    %threshold = ... : !fir.array<?:!T>
+    fir.loop %i = %c1 to %size {
+      %arr_i = fir.extract_value %arr, %i : ... -> !T
+      %threshold_i = fir.extract_value %threshold, %i : ... -> !T
+      %1 = cmp "lt" %arr_i, %threshold_i : ... -> i1
+      fir.where %1 {
+        %2 = addf %arr_i, %increment : !T
+	%3 = fir.coordinate_of %arr, %i : ... -> !fir.ref<!T>
+	fir.store %2 to %3 : !fir.ref<!T>
+      } otherwise {
+	%4 = fir.coordinate_of %arr, %i : ... -> !fir.ref<!T>
+        fir.store %threshold_i to %4
+      }
+    }
+```
+
+#### FORALL
+
+```fortran
+    FORALL (i = 1:100)
+      a(i) = b(i) / c(i)
+    END FORALL
+```
+----
+```mlir
+    fir.loop %i = %c1 to %c100 unordered {
+      %1 = fir.extract_value %b, %i : (!fir.array<?:f32>, index) -> f32
+      %2 = fir.extract_value %c, %i : (!fir.array<?:f32>, index) -> f32
+      %3 = divf %1, %2 : f32
+      %4 = fir.coordinate_of %a, %i : (!fir.ref<!fir.array<?:f32>>, index) -> !fir.ref<f32>
+      fir.store %3 to %4 : !fir.ref<f32>
+    }
+```
+
+#### ASSOCIATE construct
+
+```fortran
+    ASSOCIATE (z => EXP(-(x**2+y**2)) * COS(theta))
+      CALL foo(z)
+    END ASSOCIATE
+```
+----
+```mlir
+    %1 = ... : f32
+    %2 = fir.call @exp(%1) : (f32) -> f32
+    %3 = fir.load %theta : !fir.ref<f32>
+    %4 = fir.call @cos(%3) : (f32) -> f32
+    %5 = mulf %2, %4 : f32
+    fir.store %5 to %z : !fir.ref<f32>
+    fir.call @foo(%z) : (!fir.ref<f32>) -> ()
+```
+
+#### DO construct
+
+```fortran
+    DIMENSION a(10,10,10), b(10,10,10)
+
+    DO i = 1, m
+      DO j = 1, n
+        c(i,j) = dot_prod(a(i,j,:), b(:,i,j))
+      END DO
+    END DO
+```
+----
+```mlir
+    %c1 = constant 1 : index
+    %c10 = constant 10 : index
+    %c100 = constant 100 : index
+    %c1000 = constant 1000 : index
+    %1 = fir.gendims %c1, %c1000, %c100 : !fir.dims<1>
+    %2 = fir.gendims %c1, %c10, %c1 : !fir.dims<1>
+
+    fir.loop %i = %c1 to %m {
+      fir.loop %i = %c1 to %n {
+        %13 = fir.coordinate_of %a, %i, %j : !fir.ref<!fir.array<?:f32>>
+        %14 = fir.embox %13, %1 : (!fir.ref<!fir.array<?:f32>>, !fir.dims<1>) -> !fir.box<!fir.array<?:f32>>
+        %15 = fir.coordinate_of %b, %c1, %i, %j : !fir.ref<f32>
+        %16 = fir.convert %15 : (!fir.ref<f32>) -> !fir.ref<!fir.array<?:f32>>
+        %17 = fir.embox %16, %2 : (!fir.ref<!fir.array<?:f32>>, !fir.dims<1>) -> !fir.box<!fir.array<?:f32>>
+        %18 = fir.call @dot_prod(%14, %17) : (!fir.box<!fir.array<?:f32>>, !fir.box<!fir.array<?:f32>>) -> f32
+        %19 = fir.coordinate_of %c, %i, %j : (!fir.box<!fir.array<?:?:f32>>, index, index) -> !fir.ref<f32>
+	fir.store %18 to %19 : !fir.ref<f32>
+      }
+    }
+```
+
+In this lowering, the array sections from the arrays `a` and `b` are _not_
+copied to a temporary memory buffer, but are instead captured in boxed
+values (`%14` and `%17`).
+
+#### IF construct
+
+```fortran
+    IF (a > 0) THEN
+      ...
+    ELSE
+      ...
+    END IF
+```
+----
+```mlir
+    %1 = ... : i1
+    cond_br %1, ^bb1(%2:i32), ^bb2(%3:i32)
+```
+
+#### SELECT CASE construct
+
+```fortran
+    SELECT CASE (p)
+    CASE (1, 3:5)
+      ...
+    CASE (:-1)
+      ...
+    CASE (10:)
+      ...
+    CASE DEFAULT
+      ...
+    END SELECT CASE
+```
+----
+```mlir
+    fir.select_case %p : i32 [#fir.point,%c1,^bb1, #fir.interval,%c3,%c5,^bb1, #fir.upper,%cn1,^bb2, #fir.lower,%c10,^bb3, unit,^bb4]
+```
+
+#### SELECT RANK construct
+
+```fortran
+    SELECT RANK (p)
+    RANK (2)
+      ...
+    RANK (*)
+      ...
+    RANK DEFAULT
+      ...
+    END SELECT RANK
+```
+----
+```mlir
+    fir.select_rank %p : i32 [2,^bb1(%1:f32), -1,^bb2, unit,^bb3(%2:f32,%3:i32)]
+```
+
+#### SELECT TYPE construct
+
+```fortran
+    SELECT TYPE (p)
+    TYPE IS (type_a)
+      ...
+    CLASS IS (super_b)
+      ...
+    CLASS DEFAULT
+      ...
+    END SELECT TYPE
+```
+----
+```mlir
+    fir.select_type %p : !fir.box<none> [#fir.instance<!fir.type<type_a ...>>,^bb_1(%1:i32,%2:i64), #fir.subsumed<!fir.type<super_b ...>>,^bb_2(%3:f32,%4:f64,%5:i32), unit,^bb_3]
+```
+----
+```mlir
+     %type_a_desc = fir.gentypedesc !fir.type<type_a ...> : !fir.tdesc<!fir.type<type_a ...>>
+     %super_b_desc = fir.gentypedesc !fir.type<super_b ...> : !fir.tdesc<!fir.type<super_b ...>>
+     %11 = fir.box_tdesc %p : (!fir.box<none>) -> !fir.tdesc<none>
+     %12 = cmp "eq" %11, %type_a_desc : (!fir.tdesc<none>, !fir.tdesc<!fir.type<type_a ...>>) -> i1
+     cond_br %2, ^bb1(%1:i32,%2:i64), ^bb1b(%3:f32,%4:f64,%5:i32)
+    ^bb1(%a1,%a2 : i32,i64):
+     ...
+    ^bb1b(%b1,%b2,%b3 : f32,f64,i32):
+     %13 = fir.call @is_subtype_of(%11, %super_b_desc) : ... -> i1
+     cond_br %13, ^bb2(%b1,%b2,%b3), ^bb3 
+    ^bb2(%b1,%b2,%b3 : f32,f64,i32):
+     ...
+    ^bb3:
+     ...
+```
+
+#### Jumping statements
+
+```fortran
+    STOP
+    ERROR STOP
+    FAIL IMAGE
+    CONTINUE loop
+    EXIT a_construct
+    GOTO label1
+    GOTO (label2,label3,label4), i
+```
+----
+```mlir
+    fir.call @stop()
+    fir.unreachable
+
+    fir.call @error_stop()
+    fir.unreachable
+
+    fir.call @fail_image()
+    fir.unreachable
+
+    br ^bb_continue
+
+    br ^bb_exit
+
+    br ^bb_label1
+
+    fir.select %i : i32 [1,^bb_label2(%1:i32), 2,^bb_label3, 3,^bb_label4, unit,^fallthru]
+    ^fallthru:
+```
+
diff --git a/documentation/FIRLangRef.md b/documentation/FIRLangRef.md
new file mode 100644
index 000000000000..7d8216dd5e7d
--- /dev/null
+++ b/documentation/FIRLangRef.md
@@ -0,0 +1,1023 @@
+# FIR Language Reference
+
+This document describes the FIR dialect, an extension of the MLIR extensible
+IR. FIR (Fortran IR) is a higher-level compiler intermediate representation for
+Fortran compilation units used by the Flang compiler.
+
+Some familiarity with [MLIR](https://github.com/tensorflow/mlir/blob/master/g3doc/LangRef.md) and [LLVM IR](https://llvm.org/docs/LangRef.html) is encouraged.  The [LLVM tutorial](https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/index.html) may help as well.
+
+# Type System
+
+This section defines the _FIR type system_, which is related to but certainly
+not the same as Fortran's concept and definition of a type. FIR is a strongly
+typed language. FIR types subsume Fortran types and attributes that, when taken
+together, describe the operational properties applicable to a Fortran entity.
+
+Standard dialect MLIR types are available in FIR. FIR adds its own types as
+well, and this section documents the FIR dialect type system.
+
+In the most general case, the reified FIR type of a Fortran entity may not be
+known at compile-time. Specifically, the size, rank, shape, index ranges,
+strides, aggregate layout, data member sizes, and parameters of that type
+instance may all be deferred until runtime.
+
+In FIR, it is necessary to be able to abstract away much of the Fortran syntax
+and runtime specialization of an entity's properties, while maintaining the
+advantages of a strong type system. For one optimization, it may suffice to
+know that a Fortran entity has a rank. For another, it may be desirable (or
+required) for the operand entities to have a more precise reified FIR type for
+efficiency and performance.
+
+For example, for a Fortran variable with a declared type of `TYPE(*)`, it is
+possible to express this variable in FIR as the most general sort of entity
+with an unlimited polymorphic type. However, the compiler will be able to
+produce better performing (and smaller) code if it can prove and rewrite this
+value as having a FIR type of `i32`, which might be kept in a machine register,
+for example.
+
+The point here is that the FIR type system needs to allow transformations on a
+Fortran entity that express both an unlimited polymorphic type and, say like in
+the last example, a reified type as a 32-bit signed integer depending on the
+context.
+
+#### Notation
+
+* _abc-list_ is a possibly empty comma separated list of _abc_.
+* _abc-xlist_ is a non-empty 'x'-character separated list of _abc._
+* _abc-type_ is a type.
+
+## Fortran Intrinsic Types
+
+<pre><code><b>!fir.int&lt;</b><em>kind</em><b>&gt;<br>
+!fir.real&lt;</b><em>kind</em><b>&gt;<br>
+!fir.complex&lt;</b><em>kind</em><b>&gt;<br>
+!fir.logical&lt;</b><em>kind</em><b>&gt;<br>
+!fir.character&lt;</b><em>kind</em><b>&gt;</b><br>
+&nbsp;&nbsp;&nbsp; where <em>kind</em> := <em>integer-constant</em><br>
+</code></pre>
+
+Some of these types may be directly rewritten to standard dialect types. The
+intrinsic types are meant to correspond one-to-one with the front-end's
+intrinsic types. What a particular kind-value means in terms of bit-width is
+not relevant to these FIR types. However, the semantics of kind-values are
+absolutely relevant when these types are converted to a lower-level
+dialect. For example, assuming the f18 front-end definition then `!fir.int<2>`
+can be trivially rewritten to `i16`.
+
+## Fortran Derived Types
+
+<pre><code><b>!fir.type&lt;</b><em>derived-type-name [</em> <b>(</b><em>len-param-list</em><b>)</b> <em>] [</em> <b>{</b><em>field-id-list</em><b>}</b> <em>]</em> <b>&gt;</b><br>
+&nbsp;&nbsp;&nbsp; where <em>len-param</em> := <em>len-param-name</em> <b>:</b> <em>integer-type</em><br>
+&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>field-id</em> := <em>field-name</em> <b>:</b> <em>type</em><br>
+</code></pre>
+
+This is the type of a Fortran derived type. Each derived type is given a unique
+name. The data parts of the derived type are elaborated in the field list. The
+degenerate form is allowed to be able to construct recursive references. As
+these elaborated record types can become rather verbose, the intention will be
+to exploit MLIR's type alias feature to create shorter nicknames.
+
+## Modeled Types
+
+These types are not Fortran types. These modeled types capture the semantic
+properties of attributes on Fortran data entities by converting those
+attributes into the constraints of FIR's static type system.
+
+### Function Type
+
+<pre><code><b>(</b><em>argument-type-list</em><b>) -&gt; </b><em>result-type</em><br>
+</code></pre>
+
+This is the type of a Fortran procedure (function or subroutine) and is the
+same as the standard dialect. The void type is simply `()`.
+
+### Sequence Type
+
+<pre><code><b>!fir.array&lt;</b><em>extent-xlist</em> <b>:</b> <em>element-type</em><b>&gt;</b><br>
+&nbsp;&nbsp;&nbsp; where <em>extent</em> := <em>integer-constant |</em> <b>?</b> <em>|</em> <b>*</b><br>
+</code></pre>
+
+This is used to declare that the value is an array.  It may additionally
+capture the shape of the array. It maps to a Fortran column-major layout. An
+array with explicit shape can be represented with an xlist of rank length of
+integers. An unknown extent in one of the dimensions can be specified with the
+`?` character. The `*` character is used (by itself) when the shape of the
+array is not known.
+
+Examples:
+
+```mlir
+    !fir.array<10x10:i32>	; array of rank 2 and shape [10, 10]
+    !fir.array<5x?:f32>	; array of rank 2 and shape [5, unknown]
+    !fir.array<*:f64>	; array of unknown rank and shape
+```
+
+### Pointer-like Types
+
+<pre><code><b>!fir.ref&lt;</b><em>ref-to-type</em><b>&gt;</b><br>
+</code></pre>
+
+This is the type of a memory reference. This is needed in a number of
+situations. For one example, dummy arguments (variables) in Fortran can refer
+to the actual argument passed from the calling procedure. Assignments to the
+dummy variable will change the value of the actual variable. This semantics can
+be reified by passing a memory reference to the actual variable to the called
+procedure. _ref-to-type_ cannot be `!fir.ref`.
+
+<pre><code><b>!fir.ptr&lt;</b><em>ptr-to-type</em><b>&gt;</b><br>
+</code></pre>
+
+This is also a memory reference type, but it is limited to Fortran's POINTER
+attribute. A variable with a POINTER attribute has a runtime defined reference
+value. This introduces aliasing (which may be important to the optimizer), and
+having a separate type allows for some refinement in alias
+analysis. _ptr-to-type_ cannot be `!fir.ptr`, `!fir.heap`, or `!fir.ref`.
+
+<pre><code><b>!fir.heap&lt;</b><em>heap-to-type</em><b>&gt;</b><br>
+</code></pre>
+
+This is the third memory reference type, and this one is limited to Fortran's
+ALLOCATABLE attribute. The allocation of ALLOCATABLE variables will return a
+reference of `!fir.heap` type. _heap-to-type_ cannot be `!fir.ptr`,
+`!fir.heap`, or `!fir.ref`.
+
+By having different pointer-like types, the language constraint prohibiting
+first-class pointers-to-pointers can be trivially enforced. For example, C852
+prohibits having both a POINTER and ALLOCATABLE attribute on entity. This can
+be enforced in the type system by disallowing the construction of
+`!fir.ptr<!fir.heap<T>>` and `!fir.heap<!fir.ptr<T>>` types.
+
+### Descriptor Types
+
+<pre><code><b>!fir.box&lt;</b><em>of-type</em><b>&gt;</b><br>
+</code></pre>
+
+The type of the most general object in Fortran. A boxed value can be a scalar
+or an array. A boxed value has a memory reference (to the value's data), a
+reified type value, optional type parameters, and optional array dimension
+information (if it's an array box). A value of box type can return dynamic
+values such as the rank of the object, the size of an element, or the size of
+the object.
+
+<pre><code><b>!fir.boxchar&lt;</b><em>kind</em><b>&gt;</b><br>
+</code></pre>
+
+A Fortran CHARACTER type can be a pair of values, the buffer of characters
+along with a runtime LEN value. This is the abstract type of the pair that
+describes a CHARACTER value.
+
+<pre><code><b>!fir.boxproc&lt;</b><em>function-type</em><b>&gt;</b><br>
+</code></pre>
+
+A Fortran procedure POINTER may be to an internal procedure. An internal
+procedure may require a runtime host instance value. This is the abstract type
+of a procedure pointer, including a procedure pointer with a host instance
+value.
+
+### Other Types
+
+<pre><code><b>!fir.dims&lt;</b><em>rank</em><b>&gt;</b><br>
+</code></pre>
+
+This is the type of a vector of array dimension triples. A boxed array object
+takes a vector of dimension triples to properly instantiate the box value.
+
+<pre><code><b>!fir.field</b><br>
+</code></pre>
+
+This is the type of a part reference via a field name. A field value can be
+constructed to provide an abstract value to refer to members of a value of type
+`!fir.type`. In the most general case, the layout of a parametric derived type
+may not be known until runtime and the offset of a particular field must be
+computed.
+
+<pre><code><b>!fir.tdesc&lt;</b><em>of-type</em><b>&gt;</b><br>
+</code></pre>
+
+A Fortran type has a meta-type known as a type descriptor. This is the type of
+these meta-types. A boxed value carries a `!fir.tdesc` value to identify the
+type of that instance.
+
+
+# Modules, Functions, and Basic Blocks
+
+For organizing a Fortran compilation unit, FIR uses the MLIR infrastructure for
+modules, functions, regions, and basic blocks.  These concepts are explained in
+the MLIR Language Reference.
+
+
+# Operations
+
+This section defines the _FIR operations_.  MLIR operations are a generalized
+abstraction meant to allow a dialect, like FIR, to add its own constructs with
+their own semantics.  FIR operations are meant to capture the operations and
+structures from the Fortran language for presentation to optimization passes.
+
+Some FIR operations capture execution semantics and are intended to be placed
+in Blocks. Other operations are Module level abstractions and intended to be
+referenced by name.
+
+## Executable Operations
+
+### SSA Memory Related Ops
+
+#### `fir.alloca`
+
+Syntax:	<code><b>fir.alloca</b> <em>T [</em> <b>,</b> <em>size-list ]</em> <b>: !fir.ref&lt;</b><em>T</em><b>&gt;</b></code>
+
+Allocate uninitialized space on the stack for a variable of type _T_.  If
+allocating an array of _T_, then a size-list of ssa-values sufficient rank must
+be provided to compute the array's shape.
+
+Example:
+
+```mlir
+    %11 = fir.alloca i32 : !fir.ref<i32>
+    %12 = fir.alloca !fir.array<8:i64> : !fir.ref<!fir.array<8:i64>>
+    %13 = fir.alloca f32, %5 : !fir.ref<f32>
+```
+
+Note that in the case of `%13`, a contiguous block of memory is allocated and
+its size is some runtime multiple of a 32-bit REAL value. Furthermore, the
+operation is undefined if the ssa-value `%5` is nonpositive.
+
+
+#### `fir.load`
+
+Syntax:	<code><b>fir.load</b> <em>memory-reference</em> <b>:</b> <em>reference-type</em></code>
+
+Loads a value from a memory reference. A memory reference has type
+`!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
+
+Example:
+
+```mlir
+    %14 = fir.alloca i32 : !fir.ref<i32>
+    %15 = fir.load %14 : !fir.ref<i32>
+```
+
+#### `fir.store`
+
+Syntax:	<code><b>fir.store</b> <em>ssa-value</em> <b>to</b> <em>memory-reference</em> <b>:</b> <em>reference-type</em></code>
+
+Store a value to a memory reference.
+
+Example:
+
+```mlir
+    %16 = fir.call @foo() : f64
+    %17 = fir.call @bar() : !fir.ptr<f64>
+    fir.store %16 to %17 : !fir.ptr<f64>
+```
+
+The above store changes the value to which the pointer is pointing and not
+the pointer itself.
+
+
+#### `fir.undefined`
+
+Syntax:	<code><b>fir.undefined</b> <em>T</em></code>
+
+An undefined value. This is a constant that can be used to represent an
+undefined _ssa-value_ of any type except
+<code>!fir.ref&lt;<em>U</em>&gt;</code>.
+
+Example:
+
+```mlir
+    %18 = fir.undefined !fir.array<10:!fir.type<T{...}>>
+```
+
+### Heap Memory Ops
+
+#### `fir.allocmem`
+
+Syntax:	<code><b>fir.allocmem</b> <em>T [</em> <b>,</b> <em>size-list ]</em> <b>: !fir.heap&lt;</b><em>T</em><b>&gt;</b></code>
+
+Allocate contiguous memory on the heap. It is expected that a properly
+constructed FIR program properly pairs `fir.allocmem` and `fir.freemem`
+operations.
+
+
+Example:
+
+```mlir
+    %20 = fir.allocmem !fir.type<Z(p:i32){field:i32}> : !fir.heap<!fir.type<Z(p:i32){field:i32}>>
+```
+
+#### `fir.freemem`
+
+
+Syntax:	<code><b>fir.freemem</b> <em>heap-value</em> <b>: !fir.heap&lt;</b><em>T</em><b>&gt;</b></code>
+
+Deallocate a previously allocated block of memory returned from
+`fir.allocmem`.
+
+Example:
+
+```mlir
+    %21 = fir.allocmem !fir.type<Z(p:i32){field:i32}> : !fir.heap<!fir.type<"Z"(p:i32){field:i32}>>
+    ...
+    fir.freemem %21 : !fir.heap<!fir.type<"Z"(p:i32){field:i32}>>
+```
+
+
+### Terminators
+
+#### `fir.select`
+
+
+Syntax:
+<pre><code><b>fir.select</b> <em>selector</em> <b>:</b> <em>selector-type</em> <b>[</b> <em>value-target-list</em> <b>]</b><br>
+&nbsp;&nbsp;&nbsp; where <em>value-target</em> := <em>select-const</em> <b>,</b> <em>block block-arg-list</em><br>
+&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>select-const</em> := <em>integer-const |</em> <b>unit</b><br>
+&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>block-arg-list</em> := <em>[</em> <b>(</b> <em>value-type-list</em> <b>)</b> <em>]</em>
+</code></pre>
+
+A terminator for a simple switch like control flow.
+
+Example:
+
+    fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
+
+
+#### `fir.select_case`
+
+Syntax:
+<pre><code><b>fir.select_case</b> <em>selector</em> <b>:</b> <em>selector-type</em> <b>[</b> <em>case-target-list</em> <b>]</b><br>
+&nbsp;&nbsp;&nbsp; where <em>case-target-list</em> := <em>case-attr</em> <b>,</b> <em>case-attr-values</em> <b>,</b> <em>block block-arg-list</em><br>
+&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>case-attr</em> := <b>unit</b> <em>|</em> <b>#fir.point</b> <em>|</em> <b>#fir.interval</b> <em>|</em> <b>#fir.lower</b> <em>|</em> <b>#fir.upper</b><br>
+&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>case-attr-values</em> := <em>[ ssa-value [</em> <b>,</b> <em>ssa-value ] ]</em>
+</code></pre>
+
+A terminator for the SELECT CASE construct.
+
+Example:
+
+    fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
+
+#### `fir.select_rank`
+
+Syntax:	<code><b>fir.select_rank</b> <em>selector</em> <b>:</b> <em>selector-type</em> <b>[</b> <em>value-target-list</em> <b>]</b></code>
+
+A terminator for the SELECT RANK construct.
+
+Example:
+
+    fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
+
+
+#### `fir.select_type`
+
+Syntax:
+<pre><code><b>fir.select_type</b> <em>selector</em> <b>[</b> <em>type-target-list</em> <b>]</b></code><br>
+&nbsp;&nbsp;&nbsp; where <em>type-target-list</em> := <em>type-attr</em> <b>,</b> <em>block block-arg-list</em>
+&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>case-attr</em> := <b>unit</b> <em>|</em> <b>#fir.instance&lt;</b><em>type</em><b>&gt;</b> <em>|</em> <b>#fir.subsumed&lt;</b><em>type</em><b>&gt;</b>
+</code></pre>
+
+A terminator for the SELECT TYPE construct.
+
+Example:
+
+    fir.select_type %arg : !fir.box<()> [ #fir.instance<!fir.type<type1{f1:i32,f2:i64,f3:i1}>>,^bb1(%0:i32), #fir.instance<!fir.type<type2{...}>>,^bb2(%2:i32), #fir.subsumed<!fir.type<type3{...}>>,^bb3(%2:i32), #fir.instance<!fir.type<type4{...}>>,^bb4(%1:i32), unit,^bb5 ]
+
+#### `fir.unreachable`
+
+Syntax:	`fir.unreachable`
+
+A terminator that should never be reached by the executing program.  This
+terminator is translated to LLVM's `unreachable` instruction.
+
+
+### Ops for Boxed Values
+
+
+#### Packing Boxed Values
+
+
+#### `fir.embox`
+
+
+Syntax:
+<pre><code><b>fir.embox</b> <em>mem-ref [</em> <b>,</b> <em>access-map ]</em> <b>: (</b> <em>arg-type-list</em> <b>) -&gt; !fir.box&lt;</b><em>T</em><b>&gt;</b><br>
+&nbsp;&nbsp;&nbsp; where <em>access-map</em> := <em>dims | affine-map</em>
+</code></pre>
+
+Creation of a boxed value.  A boxed value is a memory reference value that
+is wrapped with a Fortran descriptor.  References to scalars, arrays,
+pointers, allocatables, etc. can be boxed.
+
+Example:
+
+```mlir
+    %34 = fir.dims(%c1, %c10, %c1) : (i32, i32, i32) -> !fir.dims<1>
+    %35 = fir.call @foo() : () -> !fir.ref<!fir.array<10:i32>>
+    %36 = fir.embox %35, %34 : (!fir.ref<!fir.array<10:i32>>, !fir.dims<1>) -> !fir.box<!fir.array<10:i32>>
+```
+
+#### `fir.emboxchar`
+
+Syntax:	<code><b>fir.emboxchar</b> <em>buffer-ref</em> <b>,</b> <em>len-value</em> <b>: (</b> <em>arg-type-list</em> <b>) -&gt; !fir.boxchar&lt;</b><em>kind</em><b>&gt;</b></code>
+
+Creation of a boxed CHARACTER pair.  A variable of type CHARACTER has a
+dependent LEN type parameter that is the size of the buffer holding the
+CHARACTER value.
+
+Example:
+
+```mlir
+    %c20 = constant 20 : i32
+    %37 = fir.call @foo() : !fir.ref<!fir.character<1>>
+    %38 = fir.emboxchar %37, %c20 : !fir.boxchar<1>
+```
+
+#### `fir.emboxproc`
+
+
+Syntax:	<code><b>fir.emboxproc</b> <em>callee [</em> <b>,</b> <em>context ]</em> <b>: (</b> <em>arg-type-list</em> <b>) -&gt; !fir.boxproc&lt;(</b><em>T</em><b>) -&gt;</b> <em>U</em><b>&gt;</b></code>
+
+Creation of a boxed procedure reference.
+
+Example:
+
+```mlir
+    %39 = fir.emboxproc @proc_xyz
+```
+
+#### Unpacking Boxed Values
+
+
+#### `fir.unbox`
+
+
+Syntax:	<code><b>fir.unbox</b> <em>box-value</em> <b>: (</b> <em>arg-type</em> <b>) -&gt; (</b>!fir.ref&lt;<em>Tx</em><b>&gt;, i</b><em>v</em><b>, i</b><em>w</em><b>, !fir.tdesc&lt;</b><em>Tx</em><b>&gt;, i</b><em>y</em><b>, !fir.dims&lt;</b><em>z</em><b>&gt;)</b></code>
+
+Unbox a boxed value into a result of multiple values from the box's
+component data.  The values are, minimally, a reference to the data of the
+entity, the byte-size of one element, the rank, the type descriptor, a set
+of flags (packed in an integer, and an array of dimension information (of
+size rank).
+
+Example:
+
+```mlir
+    %40 = fir.call @foo() : !fir.box<!fir.type<"T"{field:i32}>>
+    %41 = fir.unbox %40 : (!fir.box<!fir.type<"T"{field:i32}>>) -> (!fir.ref<!fir.type<"T"{field:i32}>>, i32, i32, !fir.tdesc<!fir.type<"T"{field:i32}>>, i32, !fir.dims<4>)
+```
+
+Note: the exact type and content of the returned multiple value is still to
+be determined and may change.
+
+#### `fir.unboxchar`
+
+Syntax:	<code><b>fir.unboxchar</b> <em>boxchar-value</em> <b>: (</b> <em>boxchar-type</em> <b>) -&gt; (</b> <em>reference</em> <b>,</b> <em>len</em> <b>)</b></code>
+
+Unbox a boxed CHARACTER pair.
+
+Example:
+
+```mlir
+    %45 = fir.call @foo() : !fir.boxchar<1>
+    %46 = fir.unboxchar %45 : (!fir.boxchar<1>) -> (!fir.ref<!fir.character<1>>, i32)
+```
+
+#### `fir.unboxproc`
+
+
+Syntax:	<code><b>fir.unboxproc</b> <em>boxproc-value</em> <b>: (</b> <em>boxproc-type</em> <b>) -> (</b> <em>callee</em> <b>,</b> <em>context</em> <b>)</b></code>
+
+Unbox a boxed procedure reference.
+
+
+Example:
+
+```mlir
+    %47 = fir.call @foo() : () -> !fir.boxproc<() -> i32>
+    %48 = fir.unboxproc %47 : (!fir.ref<() -> i32>, !fir.ref<(f32, i32)>)
+```
+
+#### Queries on Boxed Values
+
+#### `fir.box_addr`
+
+
+Syntax:	<code><b>fir.box_addr</b> <em>boxable</em> <b>: (</b> <em>box-type</em> <b>) -&gt; !fir.ref&lt;</b><em>T</em><b>&gt;</b></code>
+
+
+Return the referenced entity from the boxed value. The boxable value must
+have a type of <code>!fir.box&lt;<em>T</em>&gt;</code>,
+<code>!fir.boxchar&lt;<em>C</em>&gt;</code>, or
+<code>!fir.boxproc&lt;<em>FT</em>&gt;</code>.
+
+
+Example:
+
+```mlir
+    %51 = fir.box_addr %boxvec : (!fir.box<!fir.array<?:f64>>) -> !fir.ref<!fir.array<?:f64>>
+```
+
+#### `fir.box_dims`
+
+
+Syntax:	<code><b>fir.box_dims</b> <em>box-value</em> <b>,</b> <em>dim</em> <b>: (</b> <em>box-type</em> <b>) -&gt; (i</b><em>n</em><b>, i</b><em>n</em><b>, i</b><em>n</em><b>)</b></code>
+
+
+Return the dimension vector for the boxed value, _box-value_, at dimension,
+_dim_. The returned value is the triple of lower bound, extent, and stride,
+respectively.  If _dim_ is larger than the rank of the boxed value, this
+operation has undefined behavior.
+
+
+Example:
+
+```mlir
+    %c1 = constant 1 : i32
+    %52 = fir.box_dims %40, %c1 : (!fir.box<!fir.array<*:f64>>, i32) -> (i32, i32, i32)
+```
+
+#### `fir.box_elesize`
+
+
+Syntax:	<code><b>fir.box_elesize</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i</b><em>n</em></code>
+
+
+Return the size of an element for the boxed value. The returned value may
+not be constant and only known at runtime.
+
+
+Example:
+
+```mlir
+    %53 = fir.box_elesize %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i32
+```
+
+#### `fir.box_isalloc`
+
+
+Syntax:	<code><b>fir.box_isalloc</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i1</b></code>
+
+
+Return true if the boxed value is an ALLOCATABLE. This will return true if
+the originating _box-value_ was from a `fir.embox` with a _mem-ref_ value
+that had the type <code>!fir.ref&lt;!fir.heap&lt;<em>T</em>&gt;&gt;</code>.
+
+
+Example:
+
+```mlir
+    %54 = fir.box_isalloc %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i1
+```
+
+#### `fir.box_isarray`
+
+Syntax:	<code><b>fir.box_isarray</b> <em>box-value</em> <b>:  (</b> <em>box-type</em> <b>) -&gt; i1</b></code>
+
+
+Return true if the boxed value has a rank greater than 0. This will return
+true if the originating _box-value_ was from a `fir.embox` with a _mem-ref_
+value that had the type <code>!fir.ref<!fir.array<<em>T</em>>></code> and a
+<em>dims</em> argument.
+
+
+Example:
+
+```mlir
+    %55 = fir.box_isarray %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i1
+```
+
+#### `fir.box_isptr`
+
+
+Syntax:	<code><b>fir.box_isptr</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i1</b></code>
+
+Return true if the boxed value is a POINTER. This will return true if the
+originating _box-value_ was from a `fir.embox` with a _mem-ref_ value that
+had the type <code>!fir.ref&lt;!fir.ptr&lt;<em>T</em>&gt;&gt;</code>.
+
+Example:
+
+```mlir
+    %56 = fir.box_isptr %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i1
+```
+
+#### `fir.box_rank`
+
+Syntax:	<code><b>fir.box_rank</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i</b><em>n</em></code>
+
+Return the rank of the boxed value. The rank of a scalar is 0.
+
+Example:
+
+```mlir
+    %57 = fir.box_rank %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i32
+```
+
+#### `fir.box_tdesc`
+
+Syntax:	<code><b>fir.box_tdesc</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; !fir.tdesc&lt;</b> <em>ele-type</em> <b>&gt;</b></code>
+
+Return the type descriptor of the boxed value.
+
+Example:
+
+```mlir
+    %58 = fir.box_tdesc %40 : (!fir.box<!fir.array<*:f64>>) -> !fir.tdesc<!fir.array<*:f64>>
+```
+
+#### `fir.boxchar_len`
+
+Syntax:	<code><b>fir.boxchar_len</b> <em>boxchar-value</em> <b>: (!fir.boxchar&lt;1&gt;) -&gt; i</b><em>n</em></code>
+
+Return the LEN type parameter of a boxchar value.
+
+Example:
+
+```mlir
+    %59 = fir.boxchar_len %45 : (!fir.boxchar<1>) -> i32
+```
+
+#### `fir.boxproc_host`
+
+
+Syntax:	<code><b>fir.boxproc_host</b> <em>boxproc-value</em> <b>: (</b> <em>boxproc-type</em> <b>) -&gt; </b><em>host-context</em></code>
+
+
+Return the host context of a boxproc value, if any.
+
+
+Example:
+
+```mlir
+    %60 = fir.boxproc_host %47 : (!fir.boxproc<() -> none>) -> (() -> none, !fir.ref<(f32, i64)>)
+```
+
+The content and type of _host-context_ is to be determined.
+
+
+### Ops for Derived Types and Arrays
+
+#### `fir.coordinate_of`
+
+Syntax:	<code><b>fir.coordinate_of</b> <em>box-or-ref-value</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>reference-like-type</em> <b>) -&gt; !fir.ref&lt;</b><em>T</em><b>&gt;</b></code>
+
+Compute the internal coordinate address starting from a boxed value or
+unboxed memory reference. Returns a memory reference.
+
+Example:
+
+```mlir
+    %57 = fir.call @foo() : () -> !fir.heap<!fir.array<?:f32>>
+    %58 = fir.coordinate_of %57, %56 : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
+```
+
+#### `fir.extract_value`
+
+Syntax:	<code><b>fir.extract_value</b> <em>entity</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>entity-type</em> <b>,</b> <em>index-type</em> <b>) -&gt;</b> <em>subobject-type</em></code>
+
+Extract a value from an entity with a type composed of arrays and/or
+derived types. Returns the value from _entity_ with the type of the
+specified component.
+
+Example:
+
+```mlir
+    %59 = fir.field_index("field") : !fir.field
+    %60 = fir.call @foo3() : () -> !fir.type<X{field:i32}>
+    %61 = fir.extract_value %60, %59 : (!fir.type<X{field:i32}>, !fir.field) -> i32
+```
+
+#### `fir.field_index`
+
+Syntax:	<code><b>fir.field_index ("</b><em>field-name</em><b>") : !fir.field</b></code>
+
+Compute the field offset of a particular named field in a derived
+type. Note: it is possible in Fortran to write code that can only determine
+the exact offset of a particular field in a parameterized derived type at
+runtime.
+
+Example:
+
+```mlir
+    %62 = fir.field_index ("member_1") : !fir.field
+```
+
+#### `fir.gendims`
+
+Syntax:	<code><b>fir.gendims</b> <em>triple-list</em> <b>: (</b> <em>type-list</em> <b>) -&gt; !fir.dims&lt;</b><em>R</em><b>&gt;</b></code>
+
+
+Generate dimension information. This is needed to embox array entities.
+
+
+Example:
+
+```mlir
+    %c1 = constant 1 : i32
+    %c10 = constant 10 : i32
+    %63 = fir.gendims %c1,%c10,%c1 : (i32,i32,i32) -> !fir.dims<1>
+```
+
+#### `fir.insert_value`
+
+Syntax:	<code><b>fir.insert_value</b> <em>entity</em> <b>,</b> <em>value</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>entity-type</em> <b>,</b> <em>value-type</em> <b>,</b> <em>index-field-type-list</em> <b>) -&gt;</b> <em>entity-type</em></code>
+
+Insert a value into an entity with a type composed arrays and/or derived
+types. Returns a new value of the same type as _entity_.
+
+Example:
+
+```mlir
+    %64 = fir.field_index("field") : !fir.field
+    %65 = fir.call @foo2() : () -> i32
+    %66 = fir.call @foo3() : () -> !fir.type<X{field:i32}>
+    %67 = fir.insert_value(%66, %65, %64) : (!fir.type<X{field:i32}>, i32, !fir.field) -> !fir.type<X{field:i32}>
+```
+
+The above is a possible translation of the following Fortran code sequence.
+
+```Fortran
+    temp1 = foo2()
+    temp2 = foo3()
+    temp2%field = temp1
+```
+
+
+#### `fir.len_param_index`
+
+Syntax:	<code><b>fir.len_param_index ("</b><em>len-param-name</em><b>") : !fir.field</b></code>
+
+Compute the LEN type parameter offset of a particular named parameter in a
+derived type.
+
+Example:
+
+```mlir
+    %62 = fir.len_param_index("param_1") : !fir.field
+```
+
+### Generalized Control Flow Ops
+
+
+#### `fir.loop`
+
+Syntax:
+<pre><code><b>fir.loop</b> <em>ssa-id</em> <b>=</b> <em>lower-bound</em> <b>to</b> <em>upper-bound [</em> <b>step</b> <em>step-value ] [</em> <b>unordered</b> <em>]</em> <b>{</b><br>
+&nbsp;&nbsp;&nbsp; <em>op-list</em><br>
+<b>}</b>
+</code></pre>
+
+Generalized high-level looping construct. This operation is similar to
+MLIR's affine.for but does not have the restriction that the loop be
+affine.
+
+Example:
+
+```mlir
+    %72 = fir.load %A : !fir.ref<!fir.type<"R"{fld:!fir.array<?:f32>}>>
+    fir.loop %i = 1 to 10 unordered {
+      %73 = fir.extract_element %72, %field, %i : (!fir.ref<!fir.type<"R"{fld:!fir.array<?:f32>}>>, !fir.field, i32) -> f32
+      %74 = fir.call @compute(%73) : (f32) -> i32
+      %75 = fir.coordinate_of %B, %74 : (!fir.ref<!fir.array<?:f32>>, i32) -> !fir.ref<f32>
+      fir.store %73 to %75 : !fir.ref<f32>
+    }
+```
+
+The above fir.loop is a possible translation for the following Fortran DO
+CONCURRENT loop.
+
+
+```Fortran
+    DO CONCURRENT (i = 1:10) LOCAL(x)
+       x = A%fld(i)
+       B(compute(x)) = x
+    END DO
+```
+
+
+#### `fir.where`
+
+Syntax:
+<pre><code><b>fir.where</b> <em>condition</em> <b>{</b><br>
+&nbsp;&nbsp;&nbsp; <em>op-list</em><br>
+<b>}</b> <em>[</em> <b>otherwise {</b><br>
+&nbsp;&nbsp;&nbsp; <em>op-list</em><br>
+<b>}</b> <em>]</em>
+</code></pre>
+
+To conditionally execute operations (typically) within the body of a
+`fir.loop` operation. This operation is similar to `affine.if`, but it is
+generalized and not restricted to affine loop nests.
+
+Example:
+
+```mlir
+    %78 = fir.call %75(%74) : !fir.ref<!T>
+    fir.where %56 {
+      fir.store %76 to %78 : !fir.ref<!T>
+    } otherwise {
+      fir.store %77 to %78 : !fir.ref<!T>
+    }
+```
+
+#### `fir.call`
+
+Syntax:	<code><b>fir.call</b> <em>callee</em> <b>(</b> <em>arg-list</em> <b>) :</b> <em>func-type</em></code>
+
+Call the specified function or function reference.
+
+Example:
+
+```mlir
+    %89 = fir.call %funcref(%arg0) : (!fir.ref<f32>) -> f32
+    %90 = fir.call @function(%arg1, %arg2) : (!fir.ref<f32>, !fir.ref<f32>) -> f32
+```
+
+#### `fir.dispatch`
+
+Syntax:	<code><b>fir.dispatch</b> <em>method-id</em> <b>(</b> <em>arg-list</em> <b>) :</b> <em>func-type</em></code>
+
+Perform a dynamic dispatch on the method name via the dispatch table
+associated with the first argument.  The attribute 'pass_arg_pos' can be
+used to select a dispatch argument other than the first one.
+
+Example:
+
+```mlir
+    %91 = fir.dispatch "methodA"(%89, %90) : (!fir.box<!fir.type<T>>, !fir.ref<f32>) -> i32
+```
+
+### Complex Ops
+
+The standard dialect does not have primitive operations for complex types.
+We've added these primitives in the FIR dialect.
+
+#### `fir.addc`
+
+Syntax: <code><b>fir.addc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
+
+Perform addition of two complex values. The result and arguments must be
+the same type.
+
+#### `fir.subc`
+
+Syntax: <code><b>fir.subc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
+
+Perform subtraction on complex values. The result and arguments must be the
+same type.
+
+#### `fir.mulc`
+
+Syntax: <code><b>fir.mulc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
+
+Perform multiplication on complex values. The result and arguments must be
+the same type.
+
+#### `fir.divc`
+
+Syntax: <code><b>fir.divc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
+
+Perform division on complex values. The result and arguments must be the
+same type.
+
+### Other Ops
+
+#### `fir.address_of`
+
+Syntax:	<code><b>fir.address_of (@</b><em>symbol</em><b>) :</b> <em>T</em></code>
+
+Converts a symbol to an SSA-value.
+
+Example:
+
+```mlir
+    %func = fir.address_of(@func) : !fir.ref<(!fir.ref<i32>) -> ()>
+```
+
+#### `fir.convert`
+
+Syntax:	<code><b>fir.convert</b> <em>ssa-value</em> <b> : (</b> <em>T</em> <b>) -&gt;</b> <em>U</em></code>
+
+
+Generalized type conversion. Convert the _ssa-value_ from type _T_ to type
+_U_.  Conversions between some types may not be defined.  When _T_ and _U_
+are the same type, this instruction is a NOP.
+
+
+Example:
+
+```mlir
+    %92 = fir.call @foo() : () -> i64
+    %93 = fir.convert %92 : (i64) -> i32
+```
+
+The above conversion truncates a 64-bit integer value to 32-bits.
+
+
+#### `fir.gentypedesc`
+
+Syntax:	<code><b>fir.gentypedesc</b> <em>T</em> <b>: !fir.tdesc&lt;</b><em>T</em><b>&gt;</b></code>
+
+Generate a type descriptor for the type _T_.  This may be useful for
+generating type discriminating code. A type descriptor is an opaque
+singleton constant value in FIR. (It is assumed to be COMDAT.)
+
+
+Example:
+
+```mlir
+    !T = type !fir.type<T{...}>
+    %97 = fir.gentypedesc !T : !fir.tdesc<!T>
+```
+
+#### `fir.no_reassoc`
+
+Syntax:	<code><b>fir.no_reassoc</b> <em>ssa-value</em> <b>:</b> <em>T</em></code>
+
+Primitive operation meant to intrusively prevent operator reassociation.
+The operation is otherwise a nop and the value returned is the same as the
+argument.
+
+
+Example:
+
+```mlir
+    %98 = mulf %96,%97 : f32
+    %99 = fir.no_reassoc %98 : f32
+    %100 = addf %99,%95 : f32
+```
+
+The presence of this operation prevents any local optimizations. In the
+above example, this would prevent replacing the multiply and add with an
+FMA operation.
+
+## Module Abstractions
+
+#### `fir.global`
+
+Syntax:
+<pre><code><b>fir.global @</b><em>global-name [</em> <b>constant</b> <em>]</em> <b>:</b> <em>type</em> <b>{</b><br>
+&nbsp;&nbsp;&nbsp; <em>initializer-list</em><br>
+<b>}</b>
+</code></pre>
+
+A global variable or constant with initial values.
+
+Example:
+
+```mlir
+    fir.global @_QV_Mquark_Vvarble : !VarType {
+      constant 1 : i32
+      constant @some_func : (i32) -> !fir.logical<1>
+    }
+```
+
+The example creates a global variable (writable) named
+`@_QV_Mquark_Vvarble` with some initial values. The initializer should
+conform to the variable's type.
+
+#### `fir.global_entry`
+
+Syntax:	<code><b>fir.global_entry</b> <em>field-id</em> <b>,</b> <em>constant</em></code>
+
+A global entry is a mapping in a global variable that binds a field-id to a
+constant value.  This allows one to specify the values composed in a
+product type and simultaneously defer layout decisions.
+
+Example:
+
+    To do.
+
+#### `fir.dispatch_table`
+
+
+Syntax:
+<pre><code><b>fir.dispatch_table @</b><em>table-name</em> <b>{</b><br>
+&nbsp;&nbsp;&nbsp; <em>dt-entry-list</em><br>
+<b>}</b>
+</code></pre>
+
+A dispatch lookup table used implicitly by a fir.dispatch operation.
+
+Example:
+
+    See below.
+
+
+#### `fir.dt_entry`
+
+Syntax:	<code><b>fir.dt_entry</b> "<em>method-id</em>" <b>,</b> <em>callee</em></code>
+
+
+A dispatch table entry is a mapping in a dispatch table that binds a
+method-id to a callee-reference.
+
+
+Example:
+
+```mlir
+    fir.dispatch_table @_QDTMquuzTfoo {
+      fir.dt_entry "method1", @_QFNMquuzTfooPmethod1AfooR
+      fir.dt_entry "method2", @_QFNMquuzTfooPmethod2AfooII
+    }
+```
+
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index e6bb9db72ff6..bd3543028a2c 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1 +1,2 @@
+add_subdirectory(fir)
 add_subdirectory(flang)
diff --git a/include/fir/FIROps.h b/include/fir/FIROps.h
index 3a9bbf99af04..ef6532c9126f 100644
--- a/include/fir/FIROps.h
+++ b/include/fir/FIROps.h
@@ -102,6 +102,26 @@ mlir::ParseResult parseSelector(mlir::OpAsmParser *parser,
 
 LoopOp getForInductionVarOwner(mlir::Value *val);
 
+/// return true iff the Operation is a non-volatile LoadOp
+inline bool nonVolatileLoad(mlir::Operation *op) {
+  if (auto load = dyn_cast<fir::LoadOp>(op))
+    if (!load.getAttr("volatile"))
+      return true;
+  return false;
+}
+
+/// return true iff the Operation is a CallOp or DispatchOp and not pure
+inline bool impureCall(mlir::Operation *op) {
+  if (auto call = dyn_cast<fir::CallOp>(op)) {
+    if (!call.getAttr("pure"))
+      return true;
+  } else if (auto dispatch = dyn_cast<fir::DispatchOp>(op)) {
+    if (!dispatch.getAttr("pure"))
+      return true;
+  }
+  return false;
+}
+
 } // namespace fir
 
 #endif // FIR_FIROPS_H
diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
index 7e4b24afb703..9d7bbcc9ac5d 100644
--- a/include/fir/FIROps.td
+++ b/include/fir/FIROps.td
@@ -57,7 +57,8 @@ def fir_SequenceType : Type<CPred<"$_self.isa<fir::SequenceType>()">,
     "array type">;
 
 def AnyCompositeLike : TypeConstraint<Or<[fir_RecordType.predicate,
-    fir_SequenceType.predicate, IsTupleTypePred]>, "any composite">;
+    fir_SequenceType.predicate, fir_ComplexType.predicate,
+    IsTupleTypePred]>, "any composite">;
 
 def fir_ReferenceType : Type<CPred<"$_self.isa<fir::ReferenceType>()">,
     "reference type">;
@@ -120,37 +121,37 @@ class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
 }
 
 def fir_AllocateOpBuilder : OpBuilder<
-  "Builder *, OperationState &result, Type resultType,"
-  "ArrayRef<Value *> size = {}, ArrayRef<NamedAttribute> attributes = {}",
+  "Builder *builder, OperationState &result, Type inType,"
+  "ArrayRef<Value *> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
   [{
-    result.addTypes(resultType);
-    result.addOperands(size);
+    result.addTypes(getRefTy(inType));
+    result.addAttribute("in_type", M::TypeAttr::get(inType));
+    result.addOperands(sizes);
     for (auto namedAttr : attributes)
       result.addAttribute(namedAttr.first, namedAttr.second);
   }]>;
 
 def fir_NamedAllocateOpBuilder : OpBuilder<
-  "Builder *builder, OperationState &result, Type resultType,"
-  "StringRef name, ArrayRef<Value *> size = {},"
-  "ArrayRef<NamedAttribute> attributes = {}",
+  "Builder *builder, OperationState &result, Type inType, StringRef name,"
+  "ArrayRef<Value *> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
   [{
+    result.addTypes(getRefTy(inType));
+    result.addAttribute("in_type", M::TypeAttr::get(inType));
     result.addAttribute("name", builder->getStringAttr(name));
-    result.addTypes(resultType);
-    result.addOperands(size);
+    result.addOperands(sizes);
     for (auto namedAttr : attributes)
       result.addAttribute(namedAttr.first, namedAttr.second);
   }]>;
 
 def fir_OneResultOpBuilder : OpBuilder<
-  "Builder *, OperationState &result, Type resultType, "
+  "Builder *, OperationState &result, Type resultType,"
   "ArrayRef<Value *> operands, ArrayRef<NamedAttribute> attributes = {}",
   [{
     if (resultType)
       result.addTypes(resultType);
     result.addOperands(operands);
-    for (auto namedAttr : attributes) {
+    for (auto namedAttr : attributes)
       result.addAttribute(namedAttr.first, namedAttr.second);
-    }
   }]>;
 
 class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
@@ -178,52 +179,53 @@ class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
 class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
     fir_AllocatableBaseOp<mnemonic, !listconcat([NoSideEffect], traits)>,
     fir_TwoBuilders<fir_AllocateOpBuilder, fir_NamedAllocateOpBuilder>,
-    Arguments<(ins Variadic<Index>:$shape)> {
-}
-
-// Memory SSA operations
-
-def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
-  let summary = "allocate storage for a temporary on the stack given a type";
-
-  let description = [{
-    This primitive operation is used to allocate an object on the stack.  A
-    reference to the object of type `!fir.ref<T>` is returned.  The returned
-    object has an undefined state.  The allocation can be given an optional
-    name.  The allocation may have a dynamic repetition count for allocating
-    a sequence of locations for the specified type.
-  }];
-
+    Arguments<(ins TypeAttr:$in_type, Variadic<Index>:$shape)> {
   let parser = [{
     M::Type intype;
     if (parser.parseType(intype))
       return M::failure();
     auto &builder = parser.getBuilder();
-    result.addAttribute("in_type", builder.getTypeAttr(intype));
+    result.addAttribute("in_type", M::TypeAttr::get(intype));
     if (!parser.parseOptionalComma()) {
       llvm::SmallVector<M::Type, 4> typeVec;
       llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
-      if (parser.parseOperandList(operands,
-              M::OpAsmParser::Delimiter::None) ||
+      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None) ||
           parser.resolveOperands(operands, builder.getIndexType(),
               parser.getNameLoc(), result.operands))
         return M::failure();
     }
     M::Type restype;
-    if (parser.parseColonType(restype) ||
+    if (parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseColonType(restype) ||
         parser.addTypeToList(restype, result.types))
       return M::failure();
     return M::success();
   }];
+
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
     for (auto sh : getShapeOperands()) {
       p << ", ";
       p.printOperand(sh);
     }
-    p << " : " << getType();
     p.printOptionalAttrDict(getAttrs(), {"in_type"});
+    p << " : " << getType();
   }];
+}
+
+// Memory SSA operations
+
+def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
+  let summary = "allocate storage for a temporary on the stack given a type";
+
+  let description = [{
+    This primitive operation is used to allocate an object on the stack.  A
+    reference to the object of type `!fir.ref<T>` is returned.  The returned
+    object has an undefined state.  The allocation can be given an optional
+    name.  The allocation may have a dynamic repetition count for allocating
+    a sequence of locations for the specified type.
+  }];
+
   let verifier = [{
     M::Type inType = getAttrOfType<M::TypeAttr>("in_type").getValue();
     M::Type outType = getType();
@@ -241,10 +243,11 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
     operand_range getShapeOperands() {
       return {operand_begin(), operand_end()};
     }
+    static mlir::Type getRefTy(mlir::Type ty);
   }];
 }
 
-def fir_LoadOp : fir_OneResultOp<"load", [NoSideEffect]>,
+def fir_LoadOp : fir_OneResultOp<"load", []>,
     Arguments<(ins AnyReferenceLike:$memref)> {
   let summary = "load a value from a memory reference";
 
@@ -267,6 +270,7 @@ def fir_LoadOp : fir_OneResultOp<"load", [NoSideEffect]>,
     M::Type type;
     M::OpAsmParser::OperandType oper;
     if (parser.parseOperand(oper) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, type, result.operands))
        return M::failure();
@@ -276,11 +280,12 @@ def fir_LoadOp : fir_OneResultOp<"load", [NoSideEffect]>,
        return M::failure();
     return M::success();
   }];
+
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(memref());
-    p << " : " << memref()->getType();
     p.printOptionalAttrDict(getAttrs(), {});
+    p << " : " << memref()->getType();
   }];
 
   let extraClassDeclaration = [{
@@ -305,6 +310,7 @@ def fir_StoreOp : fir_Op<"store", []>,
     if (parser.parseOperand(oper) ||
         parser.parseKeyword("to") ||
         parser.parseOperand(store) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, elementType(type),
           result.operands) ||
@@ -312,13 +318,14 @@ def fir_StoreOp : fir_Op<"store", []>,
        return M::failure();
     return M::success();
   }];
+
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(value());
     p << " to ";
     p.printOperand(memref());
-    p << " : " << memref()->getType();
     p.printOptionalAttrDict(getAttrs(), {});
+    p << " : " << memref()->getType();
   }];
 
   let extraClassDeclaration = [{
@@ -340,13 +347,11 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
     if (parser.parseType(intype) ||
         parser.addTypeToList(intype, result.types))
       return M::failure();
-    auto &builder = parser.getBuilder();
-    result.addAttribute("in_type", builder.getTypeAttr(intype));
     return M::success();
   }];
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr("in_type");
-  }];
+
+  let printer = [{ p << getOperationName() << ' ' << getType(); }];
+
   let verifier = [{
     if (auto ref = getType().dyn_cast<fir::ReferenceType>())
       return emitOpError("undefined values of type !fir.ref not allowed");
@@ -364,36 +369,6 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
     be paired with `freemem` operations to avoid memory leaks.
   }];
 
-  let parser = [{
-    M::Type intype;
-    if (parser.parseType(intype))
-      return M::failure();
-    auto &builder = parser.getBuilder();
-    result.addAttribute("in_type", builder.getTypeAttr(intype));
-    if (!parser.parseOptionalComma()) {
-      llvm::SmallVector<M::Type, 4> typeVec;
-      llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
-      if (parser.parseOperandList(operands,
-              M::OpAsmParser::Delimiter::None) ||
-          parser.resolveOperands(operands, builder.getIndexType(),
-              parser.getNameLoc(), result.operands))
-        return M::failure();
-    }
-    M::Type restype;
-    if (parser.parseColonType(restype) ||
-        parser.addTypeToList(restype, result.types))
-      return M::failure();
-    return M::success();
-  }];
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr("in_type");
-    for (auto sh : getShapeOperands()) {
-      p << ", ";
-      p.printOperand(sh);
-    }
-    p << " : " << getType();
-    p.printOptionalAttrDict(getAttrs(), {"in_type"});
-  }];
   let verifier = [{
     M::Type inType = getAttrOfType<M::TypeAttr>("in_type").getValue();
     M::Type outType = getType();
@@ -411,6 +386,7 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
     operand_range getShapeOperands() {
       return {operand_begin(), operand_end()};
     }
+    static mlir::Type getRefTy(mlir::Type ty);
   }];
 }
 
@@ -429,16 +405,18 @@ def fir_FreeMemOp : fir_Op<"freemem", []>,
     M::Type type;
     M::OpAsmParser::OperandType oper;
     if (parser.parseOperand(oper) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, type, result.operands))
       return M::failure();
     return M::success();
   }];
+
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(heapref());
-    p << " : " << getOperand()->getType();
     p.printOptionalAttrDict(getAttrs(), {});
+    p << " : " << getOperand()->getType();    
   }];
 }
 
@@ -491,7 +469,7 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
     llvm::SmallVector<M::Block *, 4> dests;
     llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
     while (true) {
-      M::Attribute ivalue;
+      M::IntegerAttr ivalue;
       M::Block *dest;
       llvm::SmallVector<M::Value *, 4> destArg;
       llvm::SmallVector<M::NamedAttribute, 1> temp;
@@ -612,6 +590,7 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
         return M::failure();
       attrs.push_back(attr);
       if (attr.dyn_cast_or_null<M::UnitAttr>()) {
+        // do nothing
       } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
         M::OpAsmParser::OperandType oper1;
         M::OpAsmParser::OperandType oper2;
@@ -815,24 +794,29 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-    mlir::OpAsmParser::OperandType memref;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 2> operands;
+    M::OpAsmParser::OperandType memref;
     if (parser.parseOperand(memref))
-      return mlir::failure();
+      return M::failure();
     operands.push_back(memref);
     if (!parser.parseOptionalComma()) {
-      mlir::OpAsmParser::OperandType dims;
+      M::OpAsmParser::OperandType dims;
       if (parser.parseOperand(dims))
-        return mlir::failure();
+        return M::failure();
       operands.push_back(dims);
+    } else if (!parser.parseOptionalLSquare()) {
+      M::AffineMapAttr map;
+      if (parser.parseAttribute(map, "layout_map", result.attributes) ||
+          parser.parseRSquare())
+        return M::failure();
     }
     if (parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -841,6 +825,8 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
     if (getNumOperands() == 2) {
       p << ", ";
       p.printOperands(dims());
+    } else if (auto map = getAttr("layout_map")) {
+      p << " [" << map << ']';
     }
     p << " : ";
     p.printFunctionalType(getOperation());
@@ -849,7 +835,7 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
 
 def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
     Results<(outs fir_BoxCharType)>,
-    Arguments<(ins fir_CharacterType:$memref, AnyIntegerLike:$len)> {
+    Arguments<(ins AnyReferenceLike:$memref, AnyIntegerLike:$len)> {
   let summary = "boxes a given CHARACTER reference and its LEN parameter";
 
   let description = [{
@@ -860,16 +846,16 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 2> operands;
     if (parser.parseOperandList(operands, 2,
-            mlir::OpAsmParser::Delimiter::None) ||
+            M::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -880,6 +866,13 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
     p << " : ";
     p.printFunctionalType(getOperation());
   }];
+
+  let verifier = [{
+    auto eleTy = elementTypeOf(memref()->getType());
+    if (!eleTy.dyn_cast<CharacterType>())
+      return M::failure();
+    return M::success();
+  }];
 }
 
 def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
@@ -975,14 +968,14 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    mlir::OpAsmParser::OperandType opnd;
+    M::FunctionType type;
+    M::OpAsmParser::OperandType opnd;
     if (parser.parseOperand(opnd) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(opnd, type.getInput(0), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1015,16 +1008,16 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 2> operands;
     if (parser.parseOperandList(operands, 2,
-            mlir::OpAsmParser::Delimiter::None) ||
+            M::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1124,20 +1117,20 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
 
   let description = [{
     Determine a memory reference given a memory reference of composite type
-    and a list of index values.
+    and a list of index values. (This returns the address of a value.)
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
     if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
+            M::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1160,16 +1153,16 @@ def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
     if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
+            M::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1199,20 +1192,28 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, StringRef fieldName",
     [{
-      result.addAttribute("name", builder->getStringAttr(fieldName));
+      result.addAttribute("field_id", builder->getStringAttr(fieldName));
     }]
   >];
 
   let parser = [{
-    mlir::StringAttr attr;
-    mlir::Type type;
-    if (parser.parseLParen() ||
-        parser.parseAttribute(attr, "field_id", result.attributes) ||
-        parser.parseRParen() ||
+    if (parser.parseLParen())
+      return M::failure();
+    llvm::StringRef fieldName;
+    if (parser.parseOptionalKeyword(&fieldName)) {
+      M::StringAttr attr;
+      if (parser.parseAttribute(attr, "field_id", result.attributes))
+        return M::failure();
+    } else {
+      result.addAttribute("field_id",
+          parser.getBuilder().getStringAttr(fieldName));
+    }
+    M::Type type;
+    if (parser.parseRParen() ||
         parser.parseColonType(type) ||
         parser.addTypeToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1236,16 +1237,16 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 6> operands;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 6> operands;
     if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
+            M::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1266,16 +1267,16 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
     if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
+            M::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1306,20 +1307,28 @@ def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, StringRef fieldName",
     [{
-      result.addAttribute("name", builder->getStringAttr(fieldName));
+      result.addAttribute("field_id", builder->getStringAttr(fieldName));
     }]
   >];
 
   let parser = [{
-    mlir::StringAttr attr;
-    mlir::Type type;
-    if (parser.parseLParen() ||
-        parser.parseAttribute(attr, "field_id", result.attributes) ||
-        parser.parseRParen() ||
+    if (parser.parseLParen())
+      return M::failure();
+    llvm::StringRef fieldName;
+    if (parser.parseOptionalKeyword(&fieldName)) {
+      M::StringAttr attr;
+      if (parser.parseAttribute(attr, "field_id", result.attributes))
+        return M::failure();
+    } else {
+      result.addAttribute("field_id",
+          parser.getBuilder().getStringAttr(fieldName));
+    }
+    M::Type type;
+    if (parser.parseRParen() ||
         parser.parseColonType(type) ||
         parser.addTypeToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
@@ -1349,6 +1358,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
               "mlir::Value *lowerBound, mlir::Value *upperBound,"
               "llvm::ArrayRef<mlir::Value*> step">
   ];
+  let parser = [{ return parseLoopOp(parser, result); }];
 
   let printer = [{
     p << getOperationName() << ' ' << *getInductionVar() << " = "
@@ -1364,11 +1374,12 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
         /*printBlockTerminators=*/false);
     p.printOptionalAttrDict(getAttrs(), {"unordered", "step"});
   }];
+
   let verifier = [{
     auto step = optstep();
     if (step.begin() != step.end()) {
       auto *s = (*step.begin())->getDefiningOp();
-      if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s)) {
+      if (auto cst = dyn_cast_or_null<M::ConstantIndexOp>(s)) {
         if (cst.getValue() == 0)
           return emitOpError("constant step operand must be nonzero");
       }
@@ -1380,10 +1391,9 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     if (body->getNumArguments() != 1 ||
         !body->getArgument(0)->getType().isIndex())
       return emitOpError("expected body to have a single index argument for "
-                       "the induction variable");
-    return mlir::success();
+                         "the induction variable");
+    return M::success();
   }];
-  let parser = [{ return parseLoopOp(parser, result); }];
 
   let extraClassDeclaration = [{
     mlir::Block *getBody() { return &region().front(); }
@@ -1419,6 +1429,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
     OpBuilder<"Builder *builder, OperationState &result, "
               "Value *cond, bool withOtherRegion">
   ];
+  let parser = [{ return parseWhereOp(parser, result); }];
 
   let printer = [{
     p << getOperationName() << ' ' << *condition();
@@ -1442,9 +1453,8 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
         if (b.getNumArguments() != 0)
           return emitOpError("requires that child entry blocks have no args");
     }
-    return mlir::success();
+    return M::success();
   }];
-  let parser = [{ return parseWhereOp(parser, result); }];
 
   let extraClassDeclaration = [{
     mlir::OpBuilder getWhereBodyBuilder() {
@@ -1462,90 +1472,18 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
 
 // Procedure call operations
 
-def fir_CallOp : fir_Op<"call", []>,
-    Results<(outs Variadic<AnyType>)>,
-    Arguments<(ins SymbolRefAttr:$proc, Variadic<AnyType>:$args)> {
-  let summary = "call a procedure directly";
-
-  let description = [{
-    Provides a custom parser and pretty printer to allow for a slightly more
-    readable syntax in the FIR dialect, e.g. `fir.call @sub(%12)`.
-  }];
-
-  let parser = [{
-    M::FunctionType calleeType;
-    M::StringAttr proc;
-    L::SmallVector<M::OpAsmParser::OperandType, 4> operands;
-    if (parser.parseAttribute(proc, "proc", result.attributes) ||
-        parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
-        parser.parseColonType(calleeType) ||
-        parser.resolveOperands(operands, calleeType.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(calleeType.getResults(), result.types))
-      return M::failure();
-    return M::success();
-  }];
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr("proc") << '(';
-    p.printOperands(args());
-    p << ')';
-    p.printOptionalAttrDict(getAttrs(), {"proc"});
-    p << " : ";
-    p.printFunctionalType(getOperation());
-  }];
-}
-
-def fir_ICallOp : fir_Op<"icall", []>,
-    Results<(outs Variadic<AnyType>)>,
-    Arguments<(ins FunctionType:$proc, Variadic<AnyType>:$args)> {
-  let summary = "call a procedure indirectly";
+def fir_CallOp : fir_Op<"call", []>, Results<(outs Variadic<AnyType>)>,
+    Arguments<(ins OptionalAttr<SymbolRefAttr>:$callee,
+               Variadic<AnyType>:$args)> {
+  let summary = "call a procedure";
 
   let description = [{
-    Provides a custom parser and pretty printer to allow for a slightly more
-    readable syntax in the FIR dialect, e.g. `fir.icall %fun(%12)`.
-  }];
-
-  let parser = [{ 
-    M::FunctionType calleeType;
-    L::SmallVector<M::OpAsmParser::OperandType, 4> operands;
-    M::OpAsmParser::OperandType callee;
-    if (parser.parseOperand(callee))
-      return M::failure();
-    operands.push_back(callee);
-    auto calleeLoc = parser.getNameLoc();
-    if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
-        parser.parseColonType(calleeType) ||
-        parser.addTypesToList(calleeType.getResults(), result.types))
-      return M::failure();
-    L::SmallVector<M::Type, 8> types;
-    types.push_back(calleeType);
-    auto input = calleeType.getInputs();
-    types.insert(types.end(), input.begin(), input.end());
-    if (parser.resolveOperands(operands, types, calleeLoc, result.operands))
-      return M::failure();
-    return M::success();
-  }];
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(proc());
-    p << '(';
-    p.printOperands(args());
-    p << ')';
-    p.printOptionalAttrDict(getAttrs(), {"proc"});
-    p << " : " << getCallee()->getType();
+    Provides a custom parser and pretty printer to allow a more readable syntax
+    in the FIR dialect, e.g. `fir.call @sub(%12)` or `fir.call %20(%22,%23)`.
   }];
-  let extraClassDeclaration = [{
-    Value *getCallee() { return getOperand(0); }
-
-    operand_range getArgOperands() {
-      return {arg_operand_begin(), arg_operand_end()};
-    }
 
-    operand_iterator arg_operand_begin() { return ++operand_begin(); }
-    operand_iterator arg_operand_end() { return operand_end(); }
-  }];
+  let parser = [{ return parseCallOp(parser, result); }];
+  let printer = [{ printCallOp(p, *this); }];
 }
 
 def fir_DispatchOp : fir_Op<"dispatch", []>,
@@ -1562,39 +1500,88 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
     M::FunctionType calleeType;
     L::SmallVector<M::OpAsmParser::OperandType, 4> operands;
     auto calleeLoc = parser.getNameLoc();
-    M::StringAttr calleeAttr;
-    if (parser.parseAttribute(calleeAttr, "method", result.attributes) ||
-        parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
+    llvm::StringRef calleeName;
+    if (parser.parseOptionalKeyword(&calleeName)) {
+      M::StringAttr calleeAttr;
+      if (parser.parseAttribute(calleeAttr, "method", result.attributes))
+        return M::failure();
+    } else {
+      result.addAttribute("method",
+          parser.getBuilder().getStringAttr(calleeName));
+    }
+    if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
         parser.parseOptionalAttributeDict(result.attributes) ||
         parser.parseColonType(calleeType) ||
         parser.addTypesToList(calleeType.getResults(), result.types) ||
         parser.resolveOperands(
             operands, calleeType.getInputs(), calleeLoc, result.operands))
       return M::failure();
+    result.addAttribute("fn_type", M::TypeAttr::get(calleeType));
     return M::success();
   }];
+
   let printer = [{ 
-    p << getAttr("method") << '(';
+    p << getOperationName() << ' ' << getAttr("method") << '(';
     p.printOperand(object());
     if (arg_operand_begin() != arg_operand_end()) {
       p << ", ";
       p.printOperands(args());
     }
     p << ')';
-    p.printOptionalAttrDict(getAttrs(), {"method"});
-    llvm::SmallVector<mlir::Type, 2> resTy(getResultTypes());
-    llvm::SmallVector<mlir::Type, 8> argTy(getOperandTypes());
+    p.printOptionalAttrDict(getAttrs(), {"fn_type", "method"});
+    llvm::SmallVector<M::Type, 2> resTy(getResultTypes());
+    llvm::SmallVector<M::Type, 8> argTy(getOperandTypes());
     p << " : " << M::FunctionType::get(argTy, resTy, getContext());
   }];
+
   let extraClassDeclaration = [{
+    mlir::FunctionType getFunctionType();
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
     operand_iterator arg_operand_begin() { return operand_begin() + 1; }
     operand_iterator arg_operand_end() { return operand_end(); }
+    llvm::StringRef passArgAttrName() { return "pass_arg_pos"; }
+    unsigned passArgPos();
+  }];
+}
+
+// Complex operations
+
+class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic,
+       !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])> {
+
+  let results = (outs AnyType);
+
+  let parser = [{
+    return impl::parseOneResultSameOperandTypeOp(parser, result);
+  }];
+
+  let printer = [{
+    return fir::printComplexBinaryOp(this->getOperation(), p);
   }];
 }
 
+class RealArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_ArithmeticOp<mnemonic, traits>,
+      Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)>;
+
+def fir_AddfOp : RealArithmeticOp<"addf", [Commutative]>;
+def fir_SubfOp : RealArithmeticOp<"subf">;
+def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]>;
+def fir_DivfOp : RealArithmeticOp<"divf">;
+def fir_ModfOp : RealArithmeticOp<"modf">;
+
+class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_ArithmeticOp<mnemonic, traits>,
+      Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)>;
+
+def fir_AddcOp : ComplexArithmeticOp<"addc", [Commutative]>;
+def fir_SubcOp : ComplexArithmeticOp<"subc">;
+def fir_MulcOp : ComplexArithmeticOp<"mulc", [Commutative]>;
+def fir_DivcOp : ComplexArithmeticOp<"divc">;
+
 // Other misc. operations
 
 def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
@@ -1608,20 +1595,22 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
   let arguments = (ins SymbolRefAttr:$symbol);
 
   let parser = [{
-    mlir::SymbolRefAttr attr;
-    mlir::Type type;
+    M::SymbolRefAttr attr;
+    M::Type type;
     if (parser.parseLParen() ||
         parser.parseAttribute(attr, "symbol", result.attributes) ||
         parser.parseRParen() ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.addTypeToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
 
   let printer = [{
-    p << getOperationName() << " (" << getAttr("symbol") << ") : "
-      << getType();
+    p << getOperationName() << " (" << getAttr("symbol") << ')';
+    p.printOptionalAttrDict(getAttrs(), {"symbol"});
+    p << " : " << getType();
   }];
 }
 
@@ -1634,20 +1623,22 @@ def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 1> operands;
+    M::FunctionType type;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 1> operands;
     if (parser.parseOperandList(operands, 1,
-            mlir::OpAsmParser::Delimiter::None) ||
+            M::OpAsmParser::Delimiter::None) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(value());
+    p.printOptionalAttrDict(getAttrs(), {});
     p << " : ";
     p.printFunctionalType(getOperation());
   }];
@@ -1663,16 +1654,15 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
   }];
 
   let parser = [{
-    mlir::Type intype;
+    M::Type intype;
     if (parser.parseType(intype))
-      return mlir::failure();
-    auto &builder = parser.getBuilder();
-    result.addAttribute("in_type", builder.getTypeAttr(intype));
-    mlir::Type restype;
+      return M::failure();
+    result.addAttribute("in_type", M::TypeAttr::get(intype));
+    M::Type restype;
     if (parser.parseColonType(restype) ||
         parser.addTypeToList(restype, result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
@@ -1692,14 +1682,14 @@ def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
   }];
 
   let parser = [{
-    mlir::Type type;
-    mlir::OpAsmParser::OperandType opnd;
+    M::Type type;
+    M::OpAsmParser::OperandType opnd;
     if (parser.parseOperand(opnd) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(opnd, type, result.operands) ||
         parser.addTypeToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
+      return M::failure();
+    return M::success();
   }];
   let printer = [{
     p << getOperationName() << ' ';
@@ -1720,20 +1710,29 @@ def fir_GlobalEntryOp : fir_Op<"global_entry", []>,
 
   let parser = [{
     M::Type type;
-    M::StringAttr fieldAttr;
     M::OpAsmParser::OperandType constant;
-    if (parser.parseAttribute(fieldAttr, "field", result.attributes) ||
-        parser.parseComma() ||
+    llvm::StringRef fieldName;
+    if (parser.parseOptionalKeyword(&fieldName)) {
+      M::StringAttr fieldAttr;
+      if (parser.parseAttribute(fieldAttr, "field", result.attributes))
+        return M::failure();
+    } else {
+      result.addAttribute("field",
+          parser.getBuilder().getStringAttr(fieldName));
+    }
+    if (parser.parseComma() ||
         parser.parseOperand(constant) ||
+        parser.parseOptionalAttributeDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(constant, type, result.operands))
       return M::failure();
-    result.addAttribute("in_type", parser.getBuilder().getTypeAttr(type));
+    result.addAttribute("in_type", M::TypeAttr::get(type));
     return M::success();
   }];
   let printer = [{ 
     p << getOperationName() << ' ' << getAttr("field") << ", ";
     p.printOperand(constant());
+    p.printOptionalAttrDict(getAttrs(), {"in_type", "field"});
     p << " : " << getAttr("in_type");
   }];
 }
@@ -1752,9 +1751,16 @@ def fir_DTEntryOp : fir_Op<"dt_entry", []>,
 
   let parser = [{
     M::SymbolRefAttr calleeAttr;
-    M::StringAttr methodAttr;
-    if (parser.parseAttribute(methodAttr, "method", result.attributes) ||
-        parser.parseComma() ||
+    llvm::StringRef methodName;
+    if (parser.parseOptionalKeyword(&methodName)) {
+      M::StringAttr methodAttr;
+      if (parser.parseAttribute(methodAttr, "method", result.attributes))
+        return M::failure();
+    } else {
+      result.addAttribute("method",
+          parser.getBuilder().getStringAttr(methodName));
+    }
+    if (parser.parseComma() ||
         parser.parseAttribute(calleeAttr, "proc", result.attributes))
       return M::failure();
     return M::success();
diff --git a/include/fir/KindMapping.h b/include/fir/KindMapping.h
new file mode 100644
index 000000000000..f5e3ca7cc504
--- /dev/null
+++ b/include/fir/KindMapping.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_KINDMAPPING_H
+#define FIR_KINDMAPPING_H
+
+#include "llvm/IR/Type.h"
+#include <map>
+
+namespace llvm {
+template <typename>
+class Optional;
+} // namespace llvm
+
+namespace mlir {
+class MLIRContext;
+} // namespace mlir
+
+namespace fir {
+
+class KindMapping {
+public:
+  using KindTy = unsigned;
+  using Bitsize = unsigned;
+  using LLVMTypeID = llvm::Type::TypeID;
+  using MatchResult = llvm::Optional<bool>;
+
+  explicit KindMapping(mlir::MLIRContext *context);
+  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map);
+
+  /// Get the size in bits of !fir.char<kind>
+  Bitsize getCharacterBitsize(KindTy kind);
+
+  /// Get the size in bits of !fir.int<kind>
+  Bitsize getIntegerBitsize(KindTy kind);
+
+  /// Get the size in bits of !fir.logical<kind>
+  Bitsize getLogicalBitsize(KindTy kind);
+
+  /// Get the LLVM Type::TypeID of !fir.real<kind>
+  LLVMTypeID getRealTypeID(KindTy kind);
+
+  /// Get the LLVM Type::TypeID of !fir.complex<kind>
+  LLVMTypeID getComplexTypeID(KindTy kind);
+
+private:
+  MatchResult badMapString(llvm::Twine const &ptr);
+  MatchResult parse(llvm::StringRef kindMap);
+
+  mlir::MLIRContext *context;
+  std::map<char, std::map<KindTy, Bitsize>> intMap;
+  std::map<char, std::map<KindTy, LLVMTypeID>> floatMap;
+};
+
+} // namespace fir
+
+#endif // FIR_KINDMAPPING_H
diff --git a/include/fir/Tilikum/Tilikum.h b/include/fir/Tilikum/Tilikum.h
new file mode 100644
index 000000000000..d08737ea80ba
--- /dev/null
+++ b/include/fir/Tilikum/Tilikum.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_TILIKUM_TILIKUM_H
+#define FIR_TILIKUM_TILIKUM_H
+
+#include <memory>
+
+namespace mlir {
+class Pass;
+}
+
+namespace fir {
+
+/// Convert FIR to the LLVM IR dialect
+std::unique_ptr<mlir::Pass> createFIRToLLVMPass();
+
+/// Convert the LLVM IR dialect to LLVM-IR proper
+std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass();
+
+} // namespace fir
+
+#endif // FIR_TILIKUM_TILIKUM_H
diff --git a/include/fir/Transforms/MemToReg.h b/include/fir/Transforms/Passes.h
similarity index 79%
rename from include/fir/Transforms/MemToReg.h
rename to include/fir/Transforms/Passes.h
index 67e060ac0bfd..64fd3bebefaf 100644
--- a/include/fir/Transforms/MemToReg.h
+++ b/include/fir/Transforms/Passes.h
@@ -12,28 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_TRANSFORMS_MEMTOREG_H
-#define FIR_TRANSFORMS_MEMTOREG_H
-
-/// A pass to convert the FIR dialect from "Mem-SSA" form to "Reg-SSA"
-/// form. This pass is a port of LLVM's mem2reg pass, but modified for the FIR
-/// dialect as well as the restructuring of MLIR's representation to present PHI
-/// nodes as block arguments.
+#ifndef FIR_TRANSFORMS_PASSES_H
+#define FIR_TRANSFORMS_PASSES_H
 
 #include <memory>
 
 namespace mlir {
+class FuncOp;
 template <typename>
 class OpPassBase;
-class FuncOp;
-using FunctionPassBase = OpPassBase<FuncOp>;
 } // namespace mlir
 
 namespace fir {
 
-/// Creates a pass to convert FIR into a reg SSA form
-std::unique_ptr<mlir::FunctionPassBase> createMemToRegPass();
+/// Effects aware CSE pass
+std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createCSEPass();
+
+/// A pass to convert the FIR dialect from "Mem-SSA" form to "Reg-SSA"
+/// form. This pass is a port of LLVM's mem2reg pass, but modified for the FIR
+/// dialect as well as the restructuring of MLIR's representation to present PHI
+/// nodes as block arguments.
+std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createMemToRegPass();
 
 } // namespace fir
 
-#endif // FIR_TRANSFORMS_MEMTOREG_H
+#endif // FIR_TRANSFORMS_PASSES_H
diff --git a/include/fir/Transforms/StdConverter.h b/include/fir/Transforms/StdConverter.h
new file mode 100644
index 000000000000..80ef0aca2615
--- /dev/null
+++ b/include/fir/Transforms/StdConverter.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_STD_CONVERTER_H
+#define FIR_STD_CONVERTER_H
+
+#include <memory>
+
+namespace mlir {
+class Pass;
+}
+
+namespace fir {
+
+/// Convert FIR to the standard dialect
+std::unique_ptr<mlir::Pass> createFIRToStdPass();
+
+} // namespace fir
+
+#endif // FIR_STD_CONVERSION_H
diff --git a/include/fir/Type.h b/include/fir/Type.h
index 0f423f4dbaf5..8a469c4d35b8 100644
--- a/include/fir/Type.h
+++ b/include/fir/Type.h
@@ -15,9 +15,12 @@
 #ifndef FIR_TYPE_H
 #define FIR_TYPE_H
 
+#include "mlir/IR/Attributes.h"
 #include "mlir/IR/Types.h"
+#include "llvm/ADT/Optional.h"
 
 namespace llvm {
+class raw_ostream;
 class StringRef;
 template <typename>
 class ArrayRef;
@@ -87,8 +90,16 @@ class CharacterType
 public:
   using Base::Base;
   static CharacterType get(mlir::MLIRContext *ctxt, KindTy kind);
-  int getSizeInBits() const;
-  KindTy getFKind() const { return getSizeInBits() / 8; }
+  KindTy getFKind() const;
+};
+
+class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
+                                             detail::CplxTypeStorage>,
+                 public IntrinsicTypeMixin<CplxType, TypeKind::FIR_COMPLEX> {
+public:
+  using Base::Base;
+  static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
+  KindTy getFKind() const;
 };
 
 class IntType
@@ -97,8 +108,7 @@ class IntType
 public:
   using Base::Base;
   static IntType get(mlir::MLIRContext *ctxt, KindTy kind);
-  int getSizeInBits() const;
-  KindTy getFKind() const { return getSizeInBits() / 8; }
+  KindTy getFKind() const;
 };
 
 class LogicalType
@@ -108,8 +118,7 @@ class LogicalType
 public:
   using Base::Base;
   static LogicalType get(mlir::MLIRContext *ctxt, KindTy kind);
-  int getSizeInBits() const;
-  KindTy getFKind() const { return getSizeInBits() / 8; }
+  KindTy getFKind() const;
 };
 
 class RealType : public mlir::Type::TypeBase<RealType, mlir::Type,
@@ -118,17 +127,6 @@ class RealType : public mlir::Type::TypeBase<RealType, mlir::Type,
 public:
   using Base::Base;
   static RealType get(mlir::MLIRContext *ctxt, KindTy kind);
-  int getSizeInBits() const;
-  KindTy getFKind() const { return getSizeInBits() / 8; }
-};
-
-class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
-                                             detail::CplxTypeStorage>,
-                 public IntrinsicTypeMixin<CplxType, TypeKind::FIR_COMPLEX> {
-public:
-  using Base::Base;
-  static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
-  int getSizeInBits() const;
   KindTy getFKind() const;
 };
 
@@ -138,9 +136,15 @@ class BoxType
     : public mlir::Type::TypeBase<BoxType, mlir::Type, detail::BoxTypeStorage> {
 public:
   using Base::Base;
-  static BoxType get(mlir::Type eleTy);
+  static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {});
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOX; }
   mlir::Type getEleTy() const;
+  mlir::AffineMapAttr getLayoutMap() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location>,
+                               mlir::MLIRContext *ctx, mlir::Type eleTy,
+                               mlir::AffineMapAttr map);
 };
 
 class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
@@ -159,6 +163,10 @@ class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
   static BoxProcType get(mlir::Type eleTy);
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXPROC; }
   mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                               mlir::MLIRContext *context, mlir::Type eleTy);
 };
 
 class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
@@ -188,6 +196,10 @@ class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_HEAP; }
 
   mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                               mlir::MLIRContext *context, mlir::Type eleTy);
 };
 
 class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
@@ -198,6 +210,10 @@ class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_POINTER; }
 
   mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                               mlir::MLIRContext *context, mlir::Type eleTy);
 };
 
 class ReferenceType
@@ -209,6 +225,10 @@ class ReferenceType
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_REFERENCE; }
 
   mlir::Type getEleTy() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                               mlir::MLIRContext *context, mlir::Type eleTy);
 };
 
 class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
@@ -216,24 +236,21 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
 public:
   using Base::Base;
   using BoundInfo = int64_t;
-  struct Extent {
-    bool known;
-    BoundInfo bound;
-    explicit Extent(bool k, BoundInfo b) : known(k), bound(b) {}
-  };
+  using Extent = llvm::Optional<BoundInfo>;
   using Bounds = std::vector<Extent>;
-  struct Shape {
-    bool known;
-    Bounds bounds;
-    Shape() : known(false) {}
-    Shape(const Bounds &b) : known(true), bounds(b) {}
-  };
+  using Shape = llvm::Optional<Bounds>;
 
   mlir::Type getEleTy() const;
   Shape getShape() const;
+  mlir::AffineMapAttr getLayoutMap() const;
 
-  static SequenceType get(const Shape &shape, mlir::Type elementType);
+  static SequenceType get(const Shape &shape, mlir::Type elementType,
+                          mlir::AffineMapAttr map = {});
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                               mlir::MLIRContext *context, const Shape &shape,
+                               mlir::Type eleTy, mlir::AffineMapAttr map);
 };
 
 bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
@@ -247,6 +264,10 @@ class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
   static TypeDescType get(mlir::Type ofType);
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_TYPEDESC; }
   mlir::Type getOfTy() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                               mlir::MLIRContext *context, mlir::Type ofType);
 };
 
 // Derived types
@@ -262,16 +283,31 @@ class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
   TypeList getTypeList();
   TypeList getLenParamList();
 
-  static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name,
-                        llvm::ArrayRef<TypePair> lenPList = {},
-                        llvm::ArrayRef<TypePair> typeList = {});
+  static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
+  void finalize(llvm::ArrayRef<TypePair> lenPList,
+                llvm::ArrayRef<TypePair> typeList);
   constexpr static bool kindof(unsigned kind) { return kind == getId(); }
   constexpr static unsigned getId() { return TypeKind::FIR_DERIVED; }
+
+  detail::RecordTypeStorage const *uniqueKey() const;
+
+  static mlir::LogicalResult
+  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                               mlir::MLIRContext *context,
+                               llvm::StringRef name);
 };
 
 mlir::Type parseFirType(FIROpsDialect *dialect, llvm::StringRef rawData,
                         mlir::Location loc);
 
+void printFirType(FIROpsDialect *dialect, mlir::Type ty, llvm::raw_ostream &os);
+
 } // namespace fir
 
+namespace llvm {
+inline llvm::hash_code hash_value(const Optional<int64_t> &ext) {
+  return fir::hash_value(ext);
+}
+} // namespace llvm
+
 #endif // FIR_TYPE_H
diff --git a/include/flang/Version.h b/include/flang/Version.h
new file mode 100644
index 000000000000..79da179cfaac
--- /dev/null
+++ b/include/flang/Version.h
@@ -0,0 +1,61 @@
+//===- Version.h - Flang Version Number -------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Defines version macros and version-related utility functions
+/// for Clang.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLANG_VERSION_H
+#define LLVM_FLANG_VERSION_H
+
+#include "flang/Version.inc"
+#include "llvm/ADT/StringRef.h"
+
+namespace flang {
+  /// Retrieves the repository path (e.g., Subversion path) that
+  /// identifies the particular Clang branch, tag, or trunk from which this
+  /// Clang was built.
+  std::string getFlangRepositoryPath();
+
+  /// Retrieves the repository path from which LLVM was built.
+  ///
+  /// This supports LLVM residing in a separate repository from clang.
+  std::string getLLVMRepositoryPath();
+
+  /// Retrieves the repository revision number (or identifier) from which
+  /// this Clang was built.
+  std::string getFlangRevision();
+
+  /// Retrieves the repository revision number (or identifier) from which
+  /// LLVM was built.
+  ///
+  /// If Clang and LLVM are in the same repository, this returns the same
+  /// string as getClangRevision.
+  std::string getLLVMRevision();
+
+  /// Retrieves the full repository version that is an amalgamation of
+  /// the information in getClangRepositoryPath() and getClangRevision().
+  std::string getFlangFullRepositoryVersion();
+
+  /// Retrieves a string representing the complete clang version,
+  /// which includes the clang version number, the repository version,
+  /// and the vendor tag.
+  std::string getFlangFullVersion();
+
+  /// Like getClangFullVersion(), but with a custom tool name.
+  std::string getFlangToolFullVersion(llvm::StringRef ToolName);
+
+  /// Retrieves a string representing the complete clang version suitable
+  /// for use in the CPP __VERSION__ macro, which includes the clang version
+  /// number, the repository version, and the vendor tag.
+  std::string getFlangFullCPPVersion();
+}
+
+#endif // LLVM_FLANG_VERSION_H
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index cf1b80fd565a..22ecde7b8844 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,3 +1,9 @@
+if ((CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+  if (APPLE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion -Wno-covered-switch-default")
+  endif()
+endif()
+
 add_subdirectory(Common)
 add_subdirectory(Evaluate)
 add_subdirectory(Decimal)
diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
index c9c99ae0315b..5a29de117ecb 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/burnside/CMakeLists.txt
@@ -15,7 +15,20 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
 
 add_library(FortranBurnside
+  bridge.cc
+  builder.cc
+  convert-expr.cc
+  fe-helper.cc
   flattened.cc
+  intrinsics.cc
+  runtime.cc
+)
+
+target_link_libraries(FortranBurnside
+  FIR
+  MLIRAffineOps
+  MLIRLLVMIR
+  MLIRStandardOps
 )
 
 install (TARGETS FortranBurnside
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
new file mode 100644
index 000000000000..c68970f49551
--- /dev/null
+++ b/lib/burnside/bridge.cc
@@ -0,0 +1,1014 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "bridge.h"
+#include "builder.h"
+#include "convert-expr.h"
+#include "fe-helper.h"
+#include "fir/Dialect.h"
+#include "fir/FIROps.h"
+#include "fir/Type.h"
+#include "flattened.h"
+#include "intrinsics.h"
+#include "runtime.h"
+#include "../parser/parse-tree-visitor.h"
+#include "../semantics/tools.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/Parser.h"
+#include "mlir/Target/LLVMIR.h"
+
+#undef TODO
+#define TODO() assert(false && "not yet implemented")
+
+namespace Br = Fortran::burnside;
+namespace Co = Fortran::common;
+namespace Ev = Fortran::evaluate;
+namespace Fl = Fortran::burnside::flat;
+namespace M = mlir;
+namespace Pa = Fortran::parser;
+namespace Se = Fortran::semantics;
+
+using namespace Fortran;
+using namespace Fortran::burnside;
+
+namespace {
+
+using SomeExpr = Ev::Expr<Ev::SomeType>;
+
+std::unique_ptr<BurnsideBridge> bridgeInstance;
+
+constexpr bool isStopStmt(Pa::StopStmt::Kind kind) {
+  return kind == Pa::StopStmt::Kind::Stop;
+}
+
+constexpr bool firLoopOp{false};
+
+/// Converter from Fortran to FIR
+class FIRConverter {
+  using LabelMapType = std::map<Fl::LabelMention, M::Block *>;
+  using Closure = std::function<void(const LabelMapType &)>;
+
+  struct DoBoundsInfo {
+    M::Value *doVar;
+
+    M::Value *counter;
+    M::Value *stepExpr;
+    M::Operation *condition;
+  };
+
+  M::MLIRContext &mlirContext;
+  const Pa::CookedSource *cooked;
+  M::ModuleOp &module;
+  Co::IntrinsicTypeDefaultKinds const &defaults;
+  std::unique_ptr<M::OpBuilder> builder;
+  LabelMapType blockMap;  // map from flattened labels to MLIR blocks
+  std::list<Closure> edgeQ;
+  std::map<const Pa::NonLabelDoStmt *, DoBoundsInfo> doMap;
+  SymMap symbolMap;
+  IntrinsicLibrary intrinsics;
+  Pa::CharBlock lastKnownPos;
+  bool noInsPt{false};
+
+  inline M::OpBuilder &build() { return *builder.get(); }
+  inline M::ModuleOp &getMod() { return module; }
+  inline LabelMapType &blkMap() { return blockMap; }
+  void setCurrentPos(const Pa::CharBlock &pos) { lastKnownPos = pos; }
+
+  /// Convert a parser CharBlock to a Location
+  M::Location toLocation(const Pa::CharBlock &cb) {
+    return parserPosToLoc(mlirContext, cooked, cb);
+  }
+  M::Location toLocation() { return toLocation(lastKnownPos); }
+
+  /// Construct the type of an Expr<A> expression
+  M::Type exprType(const SomeExpr *expr) {
+    return translateSomeExprToFIRType(&mlirContext, defaults, expr);
+  }
+  M::Type refExprType(const SomeExpr *expr) {
+    auto type{translateSomeExprToFIRType(&mlirContext, defaults, expr)};
+    return fir::ReferenceType::get(type);
+  }
+
+  M::Type getDefaultIntegerType() {
+    return getFIRType(&mlirContext, defaults, IntegerCat);
+  }
+  M::Type getDefaultLogicalType() {
+    return getFIRType(&mlirContext, defaults, LogicalCat);
+  }
+
+  M::Value *createFIRAddr(M::Location loc, const SomeExpr *expr) {
+    return createSomeAddress(
+        loc, build(), *expr, symbolMap, defaults, intrinsics);
+  }
+  M::Value *createFIRExpr(M::Location loc, const SomeExpr *expr) {
+    return createSomeExpression(
+        loc, build(), *expr, symbolMap, defaults, intrinsics);
+  }
+  M::Value *createTemp(M::Type type, Se::Symbol *symbol = nullptr) {
+    return createTemporary(toLocation(), build(), symbolMap, type, symbol);
+  }
+
+  M::FuncOp genFunctionFIR(llvm::StringRef callee, M::FunctionType funcTy) {
+    if (auto func{getNamedFunction(getMod(), callee)}) {
+      return func;
+    }
+    return createFunction(getMod(), callee, funcTy);
+  }
+
+  M::FuncOp genRuntimeFunction(RuntimeEntryCode rec, int kind) {
+    return genFunctionFIR(
+        getRuntimeEntryName(rec), getRuntimeEntryType(rec, mlirContext, kind));
+  }
+
+  template<typename T> DoBoundsInfo *getBoundsInfo(const T &linearOp) {
+    auto &st{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(linearOp.v->t)};
+    setCurrentPos(st.source);
+    auto *s{&st.statement};
+    auto iter{doMap.find(s)};
+    if (iter != doMap.end()) {
+      return &iter->second;
+    }
+    assert(false && "DO context not present");
+    return nullptr;
+  }
+
+  // Simple scalar expression builders
+  // TODO: handle REAL and COMPLEX (iff needed)
+  template<M::CmpIPredicate ICMPOPC>
+  M::Value *genCompare(M::Value *lhs, M::Value *rhs) {
+    auto lty{lhs->getType()};
+    assert(lty == rhs->getType());
+    if (lty.isIntOrIndex()) {
+      return build().create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
+    }
+    if (fir::LogicalType::kindof(lty.getKind())) {
+      return build().create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
+    }
+    if (fir::CharacterType::kindof(lty.getKind())) {
+      // return build().create<M::CallOp>(lhs->getLoc(), );
+      return {};
+    }
+    assert(false && "cannot generate operation on this type");
+    return {};
+  }
+  M::Value *genGE(M::Value *lhs, M::Value *rhs) {
+    return genCompare<M::CmpIPredicate::SGE>(lhs, rhs);
+  }
+  M::Value *genLE(M::Value *lhs, M::Value *rhs) {
+    return genCompare<M::CmpIPredicate::SLE>(lhs, rhs);
+  }
+  M::Value *genEQ(M::Value *lhs, M::Value *rhs) {
+    return genCompare<M::CmpIPredicate::EQ>(lhs, rhs);
+  }
+  M::Value *genAND(M::Value *lhs, M::Value *rhs) {
+    return build().create<M::AndOp>(lhs->getLoc(), lhs, rhs);
+  }
+
+  void genFIR(AnalysisData &ad, std::list<Fl::Op> &operations);
+
+  // Control flow destination
+  void genFIR(bool lastWasLabel, const Fl::LabelOp &op) {
+    if (lastWasLabel) {
+      blkMap().insert({op.get(), build().getInsertionBlock()});
+    } else {
+      auto *currBlock{build().getInsertionBlock()};
+      auto *newBlock{createBlock(&build())};
+      blkMap().insert({op.get(), newBlock});
+      if (!noInsPt) {
+        build().setInsertionPointToEnd(currBlock);
+        build().create<M::BranchOp>(toLocation(), newBlock);
+      }
+      build().setInsertionPointToStart(newBlock);
+    }
+  }
+
+  // Goto statements
+  void genFIR(const Fl::GotoOp &op) {
+    auto iter{blkMap().find(op.target)};
+    if (iter != blkMap().end()) {
+      build().create<M::BranchOp>(toLocation(), iter->second);
+    } else {
+      using namespace std::placeholders;
+      edgeQ.emplace_back(std::bind(
+          [](M::OpBuilder *builder, M::Block *block, Fl::LabelMention dest,
+              M::Location location, const LabelMapType &map) {
+            builder->setInsertionPointToEnd(block);
+            assert(map.find(dest) != map.end() && "no destination");
+            builder->create<M::BranchOp>(location, map.find(dest)->second);
+          },
+          &build(), build().getInsertionBlock(), op.target, toLocation(), _1));
+    }
+    noInsPt = true;
+  }
+  void genFIR(const Fl::ReturnOp &op) {
+    std::visit([&](const auto *stmt) { genFIR(*stmt); }, op.u);
+    noInsPt = true;
+  }
+  void genFIR(const Fl::ConditionalGotoOp &op) {
+    std::visit(
+        [&](const auto *stmt) { genFIR(*stmt, op.trueLabel, op.falseLabel); },
+        op.u);
+    noInsPt = true;
+  }
+
+  // IO statement with END, ERR, EOR labels
+  void genFIR(const Fl::SwitchIOOp &op) {
+    auto loc{toLocation(op.source)};
+    (void)loc;
+    TODO();
+  }
+
+  // CALL with alt-return value returned
+  void genFIR(const Fl::SwitchOp &op, const Pa::CallStmt &stmt) {
+    auto loc{toLocation(op.source)};
+    (void)loc;
+    TODO();
+  }
+  void genFIR(const Fl::SwitchOp &op, const Pa::ComputedGotoStmt &stmt) {
+    auto loc{toLocation(op.source)};
+    auto *exp{Se::GetExpr(std::get<Pa::ScalarIntExpr>(stmt.t))};
+    auto *e1{createFIRExpr(loc, exp)};
+    (void)e1;
+    TODO();
+  }
+  void genFIR(const Fl::SwitchOp &op, const Pa::ArithmeticIfStmt &stmt) {
+    auto loc{toLocation(op.source)};
+    auto *exp{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
+    auto *e1{createFIRExpr(loc, exp)};
+    (void)e1;
+    TODO();
+  }
+  M::Value *fromCaseValue(const M::Location &locs, const Pa::CaseValue &val) {
+    return createFIRExpr(locs, Se::GetExpr(val));
+  }
+  void genFIR(const Fl::SwitchOp &op, const Pa::CaseConstruct &stmt);
+  void genFIR(const Fl::SwitchOp &op, const Pa::SelectRankConstruct &stmt);
+  void genFIR(const Fl::SwitchOp &op, const Pa::SelectTypeConstruct &stmt);
+  void genFIR(const Fl::SwitchOp &op) {
+    std::visit([&](auto *construct) { genFIR(op, *construct); }, op.u);
+    noInsPt = true;
+  }
+
+  void genFIR(AnalysisData &ad, const Fl::ActionOp &op);
+
+  void pushDoContext(const Pa::NonLabelDoStmt *doStmt,
+      M::Value *doVar = nullptr, M::Value *counter = nullptr,
+      M::Value *stepExpr = nullptr) {
+    doMap.emplace(doStmt, DoBoundsInfo{doVar, counter, stepExpr, 0});
+  }
+
+  void genLoopEnterFIR(const Pa::LoopControl::Bounds &bounds,
+      const Pa::NonLabelDoStmt *stmt, const Pa::CharBlock &source) {
+    auto loc{toLocation(source)};
+    // evaluate e1, e2 [, e3] ...
+    auto *e1{createFIRExpr(loc, Se::GetExpr(bounds.lower))};
+    auto *e2{createFIRExpr(loc, Se::GetExpr(bounds.upper))};
+    if (firLoopOp) {
+      std::vector<M::Value *> step;
+      if (bounds.step.has_value())
+        step.push_back(createFIRExpr(loc, Se::GetExpr(bounds.step)));
+      auto loopOp{build().create<fir::LoopOp>(loc, e1, e2, step)};
+      auto *block = createBlock(&build(), &loopOp.getOperation()->getRegion(0));
+      block->addArgument(M::IndexType::get(build().getContext()));
+      return;
+    }
+    auto *nameExpr{bounds.name.thing.symbol};
+    auto *name{createTemp(getDefaultIntegerType(), nameExpr)};
+    M::Value *e3;
+    if (bounds.step.has_value()) {
+      auto *stepExpr{Se::GetExpr(bounds.step)};
+      e3 = createFIRExpr(loc, stepExpr);
+    } else {
+      auto attr{build().getIntegerAttr(e2->getType(), 1)};
+      e3 = build().create<M::ConstantOp>(loc, attr);
+    }
+    // name <- e1
+    build().create<fir::StoreOp>(loc, e1, name);
+    auto tripCounter{createTemp(getDefaultIntegerType())};
+    // See 11.1.7.4.1, para. 1, item (3)
+    // totalTrips ::= iteration count = a
+    //   where a = (e2 - e1 + e3) / e3 if a > 0 and 0 otherwise
+    auto c1{build().create<M::SubIOp>(loc, e2, e1)};
+    auto c2{build().create<M::AddIOp>(loc, c1.getResult(), e3)};
+    auto c3{build().create<M::DivISOp>(loc, c2.getResult(), e3)};
+    auto *totalTrips{c3.getResult()};
+    build().create<fir::StoreOp>(loc, totalTrips, tripCounter);
+    pushDoContext(stmt, name, tripCounter, e3);
+  }
+
+  void genLoopEnterFIR(const Pa::ScalarLogicalExpr &logicalExpr,
+      const Pa::NonLabelDoStmt *stmt, const Pa::CharBlock &source) {
+    // See 11.1.7.4.1, para. 2
+    // See BuildLoopHeaderExpression()
+    pushDoContext(stmt);
+  }
+
+  void genLoopEnterFIR(const Pa::LoopControl::Concurrent &concurrent,
+      const Pa::NonLabelDoStmt *stmt, const Pa::CharBlock &source) {
+    // See 11.1.7.4.2
+    TODO();
+  }
+
+  void genEnterFIR(const Pa::DoConstruct &construct) {
+    auto &stmt{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(construct.t)};
+    setCurrentPos(stmt.source);
+    const Pa::NonLabelDoStmt &ss{stmt.statement};
+    auto &ctrl{std::get<std::optional<Pa::LoopControl>>(ss.t)};
+    if (ctrl.has_value()) {
+      std::visit([&](const auto &x) { genLoopEnterFIR(x, &ss, stmt.source); },
+          ctrl->u);
+    } else {
+      // loop forever (See 11.1.7.4.1, para. 2)
+      pushDoContext(&ss);
+    }
+  }
+  template<typename A> void genEnterFIR(const A &construct) {
+    // FIXME: add other genEnterFIR() members and delete this stub
+    TODO();
+  }
+  void genFIR(const Fl::BeginOp &op) {
+    std::visit([&](auto *construct) { genEnterFIR(*construct); }, op.u);
+  }
+
+  void genExitFIR(const Pa::DoConstruct &construct) {
+    if (firLoopOp) {
+      build().setInsertionPointAfter(
+          build().getBlock()->getParent()->getParentOp());
+      return;
+    }
+    auto &stmt{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(construct.t)};
+    setCurrentPos(stmt.source);
+    const Pa::NonLabelDoStmt &ss{stmt.statement};
+    auto &ctrl{std::get<std::optional<parser::LoopControl>>(ss.t)};
+    if (ctrl.has_value() &&
+        std::holds_alternative<parser::LoopControl::Bounds>(ctrl->u)) {
+      doMap.erase(&ss);
+    }
+    noInsPt = true;  // backedge already processed
+  }
+
+  void genFIR(const Fl::EndOp &op) {
+    if (auto *construct{std::get_if<const Pa::DoConstruct *>(&op.u)})
+      genExitFIR(**construct);
+  }
+
+  void genFIR(AnalysisData &ad, const Fl::IndirectGotoOp &op);
+
+  void genFIR(const Fl::DoIncrementOp &op) {
+    if (firLoopOp) {
+      return;
+    }
+    auto *info{getBoundsInfo(op)};
+    if (info->doVar && info->stepExpr) {
+      // add: do_var = do_var + e3
+      auto load{
+          build().create<fir::LoadOp>(info->doVar->getLoc(), info->doVar)};
+      auto incremented{build().create<M::AddIOp>(
+          load.getLoc(), load.getResult(), info->stepExpr)};
+      build().create<fir::StoreOp>(load.getLoc(), incremented, info->doVar);
+      // add: counter--
+      auto loadCtr{
+          build().create<fir::LoadOp>(info->counter->getLoc(), info->counter)};
+      auto one{build().create<M::ConstantOp>(
+          loadCtr.getLoc(), build().getIntegerAttr(loadCtr.getType(), 1))};
+      auto decremented{build().create<M::SubIOp>(
+          loadCtr.getLoc(), loadCtr.getResult(), one)};
+      build().create<fir::StoreOp>(
+          loadCtr.getLoc(), decremented, info->counter);
+    }
+  }
+
+  void genFIR(const Fl::DoCompareOp &op) {
+    if (firLoopOp) {
+      return;
+    }
+    auto *info{getBoundsInfo(op)};
+    if (info->doVar && info->stepExpr) {
+      // add: cond = counter > 0 (signed)
+      auto load{
+          build().create<fir::LoadOp>(info->counter->getLoc(), info->counter)};
+      auto zero{build().create<M::ConstantOp>(
+          load.getLoc(), build().getIntegerAttr(load.getType(), 0))};
+      auto cond{build().create<M::CmpIOp>(
+          load.getLoc(), M::CmpIPredicate::SGT, load, zero)};
+      info->condition = cond;
+    }
+  }
+
+  void genFIR(const Pa::FailImageStmt &stmt) {
+    auto callee{genRuntimeFunction(FIRT_FAIL_IMAGE, 0)};
+    llvm::SmallVector<M::Value *, 1> operands;  // FAIL IMAGE has no args
+    build().create<M::CallOp>(toLocation(), callee, operands);
+    build().create<fir::UnreachableOp>(toLocation());
+  }
+  void genFIR(const Pa::ReturnStmt &stmt) {
+    build().create<M::ReturnOp>(toLocation());  // FIXME: argument(s)?
+  }
+  void genFIR(const Pa::StopStmt &stmt) {
+    auto callee{genRuntimeFunction(
+        isStopStmt(std::get<Pa::StopStmt::Kind>(stmt.t)) ? FIRT_STOP
+                                                         : FIRT_ERROR_STOP,
+        defaults.GetDefaultKind(IntegerCat))};
+    // 2 args: stop-code-opt, quiet-opt
+    llvm::SmallVector<M::Value *, 8> operands;
+    build().create<M::CallOp>(toLocation(), callee, operands);
+    build().create<fir::UnreachableOp>(toLocation());
+  }
+
+  // Conditional branch-like statements
+  template<typename A>
+  void genFIR(
+      const A &tuple, Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
+    auto *exprRef{Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(tuple))};
+    assert(exprRef && "condition expression missing");
+    auto *cond{createFIRExpr(toLocation(), exprRef)};
+    genCondBranch(cond, trueLabel, falseLabel);
+  }
+  void genFIR(const Pa::Statement<Pa::IfThenStmt> &stmt,
+      Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
+    setCurrentPos(stmt.source);
+    genFIR(stmt.statement.t, trueLabel, falseLabel);
+  }
+  void genFIR(const Pa::Statement<Pa::ElseIfStmt> &stmt,
+      Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
+    setCurrentPos(stmt.source);
+    genFIR(stmt.statement.t, trueLabel, falseLabel);
+  }
+  void genFIR(const Pa::IfStmt &stmt, Fl::LabelMention trueLabel,
+      Fl::LabelMention falseLabel) {
+    genFIR(stmt.t, trueLabel, falseLabel);
+  }
+
+  M::Value *getTrueConstant() {
+    auto attr{build().getBoolAttr(true)};
+    return build().create<M::ConstantOp>(toLocation(), attr).getResult();
+  }
+
+  // Conditional branch to enter loop body or exit
+  void genFIR(const Pa::Statement<Pa::NonLabelDoStmt> &stmt,
+      Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
+    setCurrentPos(stmt.source);
+    auto &loopCtrl{std::get<std::optional<Pa::LoopControl>>(stmt.statement.t)};
+    M::Value *condition{nullptr};
+    bool exitNow{false};
+    if (loopCtrl.has_value()) {
+      exitNow = std::visit(
+          Co::visitors{
+              [&](const parser::LoopControl::Bounds &) {
+                if (firLoopOp) {
+                  return true;
+                }
+                auto iter{doMap.find(&stmt.statement)};
+                assert(iter != doMap.end());
+                condition = iter->second.condition->getResult(0);
+                return false;
+              },
+              [&](const parser::ScalarLogicalExpr &logical) {
+                auto loc{toLocation(stmt.source)};
+                auto *exp{Se::GetExpr(logical)};
+                condition = createFIRExpr(loc, exp);
+                return false;
+              },
+              [&](const parser::LoopControl::Concurrent &concurrent) {
+                // FIXME: incorrectly lowering DO CONCURRENT
+                condition = getTrueConstant();
+                return false;
+              },
+          },
+          loopCtrl->u);
+      if (firLoopOp && exitNow) {
+        return;
+      }
+    } else {
+      condition = getTrueConstant();
+    }
+    assert(condition && "condition must be a Value");
+    genCondBranch(condition, trueLabel, falseLabel);
+  }
+
+  // Action statements
+  void genFIR(const Pa::AllocateStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::AssignmentStmt &stmt) {
+    auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
+    auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
+    auto loc{toLocation()};
+    build().create<fir::StoreOp>(
+        loc, createFIRExpr(loc, rhs), createFIRAddr(loc, lhs));
+  }
+  void genFIR(const Pa::BackspaceStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::CallStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::CloseStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::DeallocateStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::EndfileStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::EventPostStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::EventWaitStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::FlushStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::FormTeamStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::InquireStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::LockStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::NullifyStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::OpenStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::PointerAssignmentStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::PrintStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::ReadStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::RewindStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::SyncAllStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::SyncImagesStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::SyncMemoryStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::SyncTeamStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::UnlockStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::WaitStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::WhereStmt &stmt){
+    TODO();
+  }
+  void genFIR(const Pa::WriteStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::ForallStmt &stmt) {
+    TODO();
+  }
+  void genFIR(AnalysisData &ad, const Pa::AssignStmt &stmt) {
+    TODO();
+  }
+  void genFIR(const Pa::PauseStmt &stmt) {
+    TODO();
+  }
+
+  template<typename A>
+  void translateRoutine(
+      const A &routine, llvm::StringRef name, const Se::Symbol *funcSym);
+
+  void genCondBranch(
+      M::Value *cond, Fl::LabelMention trueBlock, Fl::LabelMention falseBlock) {
+    auto trueIter{blkMap().find(trueBlock)};
+    auto falseIter{blkMap().find(falseBlock)};
+    if (trueIter != blkMap().end() && falseIter != blkMap().end()) {
+      llvm::SmallVector<M::Value *, 2> blanks;
+      build().create<M::CondBranchOp>(toLocation(), cond, trueIter->second,
+          blanks, falseIter->second, blanks);
+    } else {
+      using namespace std::placeholders;
+      edgeQ.emplace_back(std::bind(
+          [](M::OpBuilder *builder, M::Block *block, M::Value *cnd,
+              Fl::LabelMention trueDest, Fl::LabelMention falseDest,
+              M::Location location, const LabelMapType &map) {
+            llvm::SmallVector<M::Value *, 2> blk;
+            builder->setInsertionPointToEnd(block);
+            auto tdp{map.find(trueDest)};
+            auto fdp{map.find(falseDest)};
+            assert(tdp != map.end() && fdp != map.end());
+            builder->create<M::CondBranchOp>(
+                location, cnd, tdp->second, blk, fdp->second, blk);
+          },
+          &build(), build().getInsertionBlock(), cond, trueBlock, falseBlock,
+          toLocation(), _1));
+    }
+  }
+
+  template<typename A>
+  void genSwitchBranch(const M::Location &loc, M::Value *selector,
+      std::list<typename A::Conditions> &&conditions,
+      const std::vector<Fl::LabelMention> &labels) {
+    assert(conditions.size() == labels.size());
+    bool haveAllLabels{true};
+    std::size_t u{0};
+    // do we already have all the targets?
+    for (auto last{labels.size()}; u != last; ++u) {
+      haveAllLabels = blkMap().find(labels[u]) != blkMap().end();
+      if (!haveAllLabels) break;
+    }
+    if (haveAllLabels) {
+      // yes, so generate the FIR operation now
+      u = 0;
+      std::vector<M::Value *> conds;
+      std::vector<M::Block *> blocks;
+      std::vector<llvm::ArrayRef<M::Value *>> blockArgs;
+      llvm::SmallVector<M::Value *, 2> blanks;
+      for (auto cond : conditions) {
+        conds.emplace_back(cond);
+        blocks.emplace_back(blkMap().find(labels[u++])->second);
+        blockArgs.emplace_back(blanks);
+      }
+      build().create<A>(loc, selector, conds, blocks, blockArgs);
+    } else {
+      // no, so queue the FIR operation for later
+      using namespace std::placeholders;
+      edgeQ.emplace_back(std::bind(
+          [](M::OpBuilder *builder, M::Block *block, M::Value *sel,
+              const std::list<typename A::Conditions> &conditions,
+              const std::vector<Fl::LabelMention> &labels, M::Location location,
+              const LabelMapType &map) {
+            std::size_t u{0};
+            std::vector<M::Value *> conds;
+            std::vector<M::Block *> blocks;
+            std::vector<llvm::ArrayRef<M::Value *>> blockArgs;
+            llvm::SmallVector<M::Value *, 2> blanks;
+            for (auto &cond : conditions) {
+              auto iter{map.find(labels[u++])};
+              assert(iter != map.end());
+              conds.emplace_back(cond);
+              blocks.emplace_back(iter->second);
+              blockArgs.emplace_back(blanks);
+            }
+            builder->setInsertionPointToEnd(block);
+            builder->create<A>(location, sel, conds, blocks, blockArgs);
+          },
+          &build(), build().getInsertionBlock(), selector, conditions, labels,
+          loc, _1));
+    }
+  }
+
+  void finalizeQueued() {
+    for (auto &edgeFunc : edgeQ) {
+      edgeFunc(blkMap());
+    }
+  }
+
+public:
+  FIRConverter(BurnsideBridge &bridge)
+    : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
+      module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
+      intrinsics{IntrinsicLibrary::create(
+          IntrinsicLibrary::Version::LLVM, mlirContext)} {}
+  FIRConverter() = delete;
+
+  template<typename A> constexpr bool Pre(const A &) { return true; }
+  template<typename A> constexpr void Post(const A &) {
+    // FIXME: make sure we lower all of the parse tree
+  }
+
+  /// Translate the various routines from the parse tree
+  void Post(const Pa::MainProgram &mainp) {
+    std::string mainName{"_MAIN"s};
+    if (auto &ps{
+            std::get<std::optional<Pa::Statement<Pa::ProgramStmt>>>(mainp.t)}) {
+      mainName = ps->statement.v.ToString();
+      setCurrentPos(ps->source);
+    }
+    translateRoutine(mainp, mainName, nullptr);
+  }
+  void Post(const Pa::FunctionSubprogram &subp) {
+    auto &stmt{std::get<Pa::Statement<Pa::FunctionStmt>>(subp.t)};
+    setCurrentPos(stmt.source);
+    auto &name{std::get<Pa::Name>(stmt.statement.t)};
+    translateRoutine(subp, name.ToString(), name.symbol);
+  }
+  void Post(const Pa::SubroutineSubprogram &subp) {
+    auto &stmt{std::get<Pa::Statement<Pa::SubroutineStmt>>(subp.t)};
+    setCurrentPos(stmt.source);
+    auto &name{std::get<Pa::Name>(stmt.statement.t)};
+    translateRoutine(subp, name.ToString(), name.symbol);
+  }
+};
+
+/// SELECT CASE
+/// Build a switch-like structure for a SELECT CASE
+void FIRConverter::genFIR(
+    const Fl::SwitchOp &op, const Pa::CaseConstruct &stmt) {
+  auto loc{toLocation(op.source)};
+  auto &cstm{std::get<Pa::Statement<Pa::SelectCaseStmt>>(stmt.t)};
+  auto *exp{Se::GetExpr(std::get<Pa::Scalar<Pa::Expr>>(cstm.statement.t))};
+  auto *e1{createFIRExpr(loc, exp)};
+  auto &cases{std::get<std::list<Pa::CaseConstruct::Case>>(stmt.t)};
+  std::list<fir::SelectCaseOp::Conditions> conds;
+  // Per C1145, we know each `case-expr` must have type INTEGER, CHARACTER, or
+  // LOGICAL
+  for (auto &sel : cases) {
+    auto &cs{std::get<Pa::Statement<Pa::CaseStmt>>(sel.t)};
+    auto locs{toLocation(cs.source)};
+    auto &csel{std::get<Pa::CaseSelector>(cs.statement.t)};
+    std::visit(
+        Co::visitors{
+            [&](const std::list<Pa::CaseValueRange> &ranges) {
+              for (auto &r : ranges) {
+                std::visit(Co::visitors{
+                               [&](const Pa::CaseValue &val) {
+                                 auto *term{fromCaseValue(locs, val)};
+                                 conds.emplace_back(genEQ(e1, term));
+                               },
+                               [&](const Pa::CaseValueRange::Range &rng) {
+                                 fir::SelectCaseOp::Conditions rangeComparison =
+                                     nullptr;
+                                 if (rng.lower.has_value()) {
+                                   auto *term{fromCaseValue(locs, *rng.lower)};
+                                   // rc = e1 >= lower.term
+                                   rangeComparison = genGE(e1, term);
+                                 }
+                                 if (rng.upper.has_value()) {
+                                   auto *term{fromCaseValue(locs, *rng.upper)};
+                                   // c = e1 <= upper.term
+                                   auto *comparison{genLE(e1, term)};
+                                   // rc = if rc then (rc && c) else c
+                                   if (rangeComparison) {
+                                     rangeComparison =
+                                         genAND(rangeComparison, comparison);
+                                   } else {
+                                     rangeComparison = comparison;
+                                   }
+                                 }
+                                 conds.emplace_back(rangeComparison);
+                               },
+                           },
+                    r.u);
+              }
+            },
+            [&](const Pa::Default &) { conds.emplace_back(getTrueConstant()); },
+        },
+        csel.u);
+  }
+  genSwitchBranch<fir::SelectCaseOp>(loc, e1, std::move(conds), op.refs);
+}
+
+/// SELECT RANK
+/// Build a switch-like structure for a SELECT RANK
+void FIRConverter::genFIR(
+    const Fl::SwitchOp &op, const Pa::SelectRankConstruct &stmt) {
+  auto loc{toLocation(op.source)};
+  auto &rstm{std::get<Pa::Statement<Pa::SelectRankStmt>>(stmt.t)};
+  auto *exp{std::visit([](auto &x) { return Se::GetExpr(x); },
+      std::get<Pa::Selector>(rstm.statement.t).u)};
+  auto *e1{createFIRExpr(loc, exp)};
+  auto &ranks{std::get<std::list<Pa::SelectRankConstruct::RankCase>>(stmt.t)};
+  std::list<fir::SelectRankOp::Conditions> conds;
+  for (auto &r : ranks) {
+    auto &rs{std::get<Pa::Statement<Pa::SelectRankCaseStmt>>(r.t)};
+    auto &rank{std::get<Pa::SelectRankCaseStmt::Rank>(rs.statement.t)};
+    std::visit(
+        Co::visitors{
+            [&](const Pa::ScalarIntConstantExpr &ex) {
+              auto *ie{createFIRExpr(loc, Se::GetExpr(ex))};
+              conds.emplace_back(ie);
+            },
+            [&](const Pa::Star &) {
+              // FIXME: using a bogon for now.  Special value per
+              // whatever the runtime returns.
+              auto attr{build().getIntegerAttr(e1->getType(), -1)};
+              conds.emplace_back(build().create<M::ConstantOp>(loc, attr));
+            },
+            [&](const Pa::Default &) { conds.emplace_back(getTrueConstant()); },
+        },
+        rank.u);
+  }
+  // FIXME: fix the type of the function
+  auto callee{genRuntimeFunction(FIRT_GET_RANK, 0)};
+  llvm::SmallVector<M::Value *, 1> operands{e1};
+  auto e3{build().create<M::CallOp>(loc, callee, operands)};
+  genSwitchBranch<fir::SelectRankOp>(
+      loc, e3.getResult(0), std::move(conds), op.refs);
+}
+
+/// SELECT TYPE
+/// Build a switch-like structure for a SELECT TYPE
+void FIRConverter::genFIR(
+    const Fl::SwitchOp &op, const Pa::SelectTypeConstruct &stmt) {
+  auto loc{toLocation(op.source)};
+  auto &tstm{std::get<Pa::Statement<Pa::SelectTypeStmt>>(stmt.t)};
+  auto *exp{std::visit([](auto &x) { return Se::GetExpr(x); },
+      std::get<Pa::Selector>(tstm.statement.t).u)};
+  auto *e1{createFIRExpr(loc, exp)};
+  auto &types{std::get<std::list<Pa::SelectTypeConstruct::TypeCase>>(stmt.t)};
+  std::list<fir::SelectTypeOp::Conditions> conds;
+  for (auto &t : types) {
+    auto &ts{std::get<Pa::Statement<Pa::TypeGuardStmt>>(t.t)};
+    auto &ty{std::get<Pa::TypeGuardStmt::Guard>(ts.statement.t)};
+    std::visit(
+        Co::visitors{
+            [&](const Pa::TypeSpec &) {
+              // FIXME: add arguments
+              auto func{genRuntimeFunction(FIRT_ISA_TYPE, 0)};
+              llvm::SmallVector<M::Value *, 2> operands;
+              auto call{build().create<M::CallOp>(loc, func, operands)};
+              conds.emplace_back(call.getResult(0));
+            },
+            [&](const Pa::DerivedTypeSpec &) {
+              // FIXME: add arguments
+              auto func{genRuntimeFunction(FIRT_ISA_SUBTYPE, 0)};
+              llvm::SmallVector<M::Value *, 2> operands;
+              auto call{build().create<M::CallOp>(loc, func, operands)};
+              conds.emplace_back(call.getResult(0));
+            },
+            [&](const Pa::Default &) { conds.emplace_back(getTrueConstant()); },
+        },
+        ty.u);
+  }
+  auto callee{genRuntimeFunction(FIRT_GET_ELETYPE, 0)};
+  llvm::SmallVector<M::Value *, 1> operands{e1};
+  auto e3{build().create<M::CallOp>(loc, callee, operands)};
+  genSwitchBranch<fir::SelectTypeOp>(
+      loc, e3.getResult(0), std::move(conds), op.refs);
+}
+
+/// translate action statements
+void FIRConverter::genFIR(AnalysisData &ad, const Fl::ActionOp &op) {
+  setCurrentPos(op.v->source);
+  std::visit(Co::visitors{
+                 [](const Pa::ContinueStmt &) { TODO(); },
+                 [](const Pa::FailImageStmt &) { TODO(); },
+                 [](const Co::Indirection<Pa::ArithmeticIfStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::AssignedGotoStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::ComputedGotoStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::CycleStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::ExitStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::GotoStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::IfStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::ReturnStmt> &) { TODO(); },
+                 [](const Co::Indirection<Pa::StopStmt> &) { TODO(); },
+                 [&](const Co::Indirection<Pa::AssignStmt> &assign) {
+                   genFIR(ad, assign.value());
+                 },
+                 [&](const auto &stmt) { genFIR(stmt.value()); },
+             },
+      op.v->statement.u);
+}
+
+void FIRConverter::genFIR(AnalysisData &ad, const Fl::IndirectGotoOp &op) {
+  // add or queue an igoto
+  TODO();
+}
+
+void FIRConverter::genFIR(AnalysisData &ad, std::list<Fl::Op> &operations) {
+  bool lastWasLabel{false};
+  for (auto &op : operations) {
+    std::visit(Co::visitors{
+                   [&](const Fl::IndirectGotoOp &oper) {
+                     genFIR(ad, oper);
+                     lastWasLabel = false;
+                   },
+                   [&](const Fl::ActionOp &oper) {
+                     noInsPt = false;
+                     genFIR(ad, oper);
+                     lastWasLabel = false;
+                   },
+                   [&](const Fl::LabelOp &oper) {
+                     genFIR(lastWasLabel, oper);
+                     lastWasLabel = true;
+                   },
+                   [&](const Fl::BeginOp &oper) {
+                     noInsPt = false;
+                     genFIR(oper);
+                     lastWasLabel = true;
+                   },
+                   [&](const auto &oper) {
+                     noInsPt = false;
+                     genFIR(oper);
+                     lastWasLabel = false;
+                   },
+               },
+        op.u);
+  }
+  if (build().getInsertionBlock()) {
+    // FIXME: assuming type of '() -> ()'
+    build().create<M::ReturnOp>(toLocation());
+  }
+}
+
+/// Translate the routine to MLIR
+template<typename A>
+void FIRConverter::translateRoutine(
+    const A &routine, llvm::StringRef name, const Se::Symbol *funcSym) {
+  M::FuncOp func{getNamedFunction(getMod(), name)};
+  if (!func) {
+    // get arguments and return type if any, otherwise just use empty vectors
+    llvm::SmallVector<M::Type, 8> args;
+    llvm::SmallVector<M::Type, 2> results;
+    if (funcSym) {
+      if (auto *details{funcSym->detailsIf<Se::SubprogramDetails>()}) {
+        for (auto a : details->dummyArgs()) {
+          auto type{translateSymbolToFIRType(&mlirContext, defaults, a)};
+          args.push_back(fir::ReferenceType::get(type));
+        }
+        if (details->isFunction()) {
+          // FIXME: handle subroutines that return magic values
+          auto *result{&details->result()};
+          results.push_back(
+              translateSymbolToFIRType(&mlirContext, defaults, result));
+        }
+      } else {
+        llvm::errs() << "Symbol: " << funcSym->name().ToString() << " @ "
+                     << funcSym->details().index() << '\n';
+        assert(false && "symbol misidentified by front-end");
+      }
+    }
+    auto funcTy{M::FunctionType::get(args, results, &mlirContext)};
+    func = createFunction(getMod(), name, funcTy);
+  }
+  func.addEntryBlock();
+  builder = std::make_unique<M::OpBuilder>(func);
+  build().setInsertionPointToStart(&func.front());
+  if (funcSym) {
+    auto *entryBlock{&func.front()};
+    if (auto *details{funcSym->detailsIf<Se::SubprogramDetails>()}) {
+      for (const auto &v :
+          llvm::zip(details->dummyArgs(), entryBlock->getArguments())) {
+        symbolMap.addSymbol(std::get<0>(v), std::get<1>(v));
+      }
+    } else {
+      llvm::errs() << "Symbol: " << funcSym->name().ToString() << " @ "
+                   << funcSym->details().index() << '\n';
+      assert(false && "symbol misidentified by front-end");
+    }
+  }
+  AnalysisData ad;
+  std::list<Fl::Op> operations;
+  CreateFlatIR(routine, operations, ad);
+  genFIR(ad, operations);
+  finalizeQueued();
+}
+
+M::DialectRegistration<fir::FIROpsDialect> FIROps;
+
+}  // namespace
+
+void Br::crossBurnsideBridge(BurnsideBridge &bridge, const Pa::Program &prg) {
+  FIRConverter converter{bridge};
+  Walk(prg, converter);
+}
+
+std::unique_ptr<llvm::Module> Br::LLVMBridge(M::ModuleOp &module) {
+  return M::translateModuleToLLVMIR(module);
+}
+
+void Br::BurnsideBridge::parseSourceFile(llvm::SourceMgr &srcMgr) {
+  auto owningRef = M::parseSourceFile(srcMgr, context.get());
+  module.reset(new M::ModuleOp(owningRef.get().getOperation()));
+  owningRef.release();
+}
+
+Br::BurnsideBridge::BurnsideBridge(
+    const Co::IntrinsicTypeDefaultKinds &defaultKinds,
+    const Pa::CookedSource *cooked)
+  : defaultKinds{defaultKinds}, cooked{cooked} {
+  context = std::make_unique<M::MLIRContext>();
+  module = std::make_unique<M::ModuleOp>(
+      M::ModuleOp::create(M::UnknownLoc::get(context.get())));
+}
+
+void Br::instantiateBurnsideBridge(
+    const Co::IntrinsicTypeDefaultKinds &defaultKinds,
+    const Pa::CookedSource *cooked) {
+  auto p{BurnsideBridge::create(defaultKinds, cooked)};
+  bridgeInstance.swap(p);
+}
+
+BurnsideBridge &Br::getBridge() { return *bridgeInstance.get(); }
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
new file mode 100644
index 000000000000..b4614a050099
--- /dev/null
+++ b/lib/burnside/bridge.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_BRIDGE_H_
+#define FORTRAN_BURNSIDE_BRIDGE_H_
+
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Module.h"
+#include <memory>
+
+/// Implement the burnside bridge from Fortran to
+/// [MLIR](https://github.com/tensorflow/mlir).
+///
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+namespace Fortran::common {
+class IntrinsicTypeDefaultKinds;
+}
+
+namespace Fortran::parser {
+class CookedSource;
+struct Program;
+}
+
+namespace llvm {
+class Module;
+class SourceMgr;
+}
+
+namespace Fortran::burnside {
+
+/// An instance of BurnsideBridge is a singleton that owns the state of the
+/// bridge
+class BurnsideBridge {
+public:
+  static std::unique_ptr<BurnsideBridge> create(
+      const common::IntrinsicTypeDefaultKinds &defaultKinds,
+      const parser::CookedSource *cooked) {
+    BurnsideBridge *p = new BurnsideBridge{defaultKinds, cooked};
+    return std::unique_ptr<BurnsideBridge>{p};
+  }
+
+  mlir::MLIRContext &getMLIRContext() { return *context.get(); }
+  mlir::ModuleOp &getModule() { return *module.get(); }
+
+  void parseSourceFile(llvm::SourceMgr &);
+
+  common::IntrinsicTypeDefaultKinds const &getDefaultKinds() {
+    return defaultKinds;
+  }
+
+  bool validModule() { return getModule(); }
+
+  const parser::CookedSource *getCookedSource() const { return cooked; }
+
+private:
+  explicit BurnsideBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
+      const parser::CookedSource *cooked);
+  BurnsideBridge() = delete;
+  BurnsideBridge(const BurnsideBridge &) = delete;
+
+  const common::IntrinsicTypeDefaultKinds &defaultKinds;
+  const parser::CookedSource *cooked;
+  std::unique_ptr<mlir::MLIRContext> context;
+  std::unique_ptr<mlir::ModuleOp> module;
+};
+
+/// Cross the bridge from the Fortran parse-tree, etc. to FIR+OpenMP+MLIR
+void crossBurnsideBridge(
+    BurnsideBridge &bridge, const parser::Program &program);
+
+/// Bridge from MLIR to LLVM-IR
+std::unique_ptr<llvm::Module> LLVMBridge(mlir::ModuleOp &module);
+
+/// instantiate the BURNSIDE bridge singleton
+void instantiateBurnsideBridge(
+    const common::IntrinsicTypeDefaultKinds &defaultKinds,
+    const parser::CookedSource *cooked = nullptr);
+
+/// get the burnside bridge singleton
+BurnsideBridge &getBridge();
+
+}  // Fortran::burnside
+
+#endif  // FORTRAN_BURNSIDE_BRIDGE_H_
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
new file mode 100644
index 000000000000..650f80c21790
--- /dev/null
+++ b/lib/burnside/builder.cc
@@ -0,0 +1,55 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "builder.h"
+#include "bridge.h"
+#include "fe-helper.h"
+#include "llvm/ADT/StringRef.h"
+#include "mlir/IR/Module.h"
+#include "mlir/IR/Value.h"
+
+namespace B = Fortran::burnside;
+
+using namespace Fortran;
+using namespace B;
+
+// This will need to be extended to consider the type of what is being mangled
+std::string B::applyNameMangling(llvm::StringRef parserName) {
+  // FIXME: this is fake for now, add type info, etc.
+  return "_Qp_"s + parserName.str();
+}
+
+mlir::FuncOp B::createFunction(mlir::ModuleOp module, llvm::StringRef name,
+    mlir::FunctionType funcTy, parser::CookedSource const *cooked,
+    parser::CharBlock const *cb) {
+  mlir::MLIRContext *ctxt{module.getContext()};
+  mlir::Location loc{
+      (cooked && cb) ? parserPosToLoc(*ctxt, cooked, *cb) : dummyLoc(*ctxt)};
+  auto func{mlir::FuncOp::create(loc, name, funcTy)};
+  module.push_back(func);
+  return func;
+}
+
+mlir::FuncOp B::getNamedFunction(mlir::ModuleOp module, llvm::StringRef name) {
+  return module.lookupSymbol<mlir::FuncOp>(name);
+}
+
+void B::SymMap::addSymbol(const semantics::Symbol *symbol, mlir::Value *value) {
+  symbolMap.try_emplace(symbol, value);
+}
+
+mlir::Value *B::SymMap::lookupSymbol(const semantics::Symbol *symbol) {
+  auto iter{symbolMap.find(symbol)};
+  return (iter == symbolMap.end()) ? nullptr : iter->second;
+}
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index 2e13a0f76153..a2bce6b79faa 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -26,7 +26,12 @@ namespace llvm {
 class StringRef;
 }
 
-namespace Fortran::burnside {
+namespace Fortran {
+namespace parser {
+class CookedSource;
+}
+
+namespace burnside {
 
 /// Miscellaneous helper routines for building MLIR
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
@@ -67,12 +72,16 @@ inline mlir::Block *createBlock(mlir::OpBuilder *bldr) {
 }
 
 /// Get a function by name (or null)
-mlir::FuncOp getNamedFunction(llvm::StringRef name);
+mlir::FuncOp getNamedFunction(mlir::ModuleOp, llvm::StringRef name);
 
 /// Create a new Function
-mlir::FuncOp createFunction(
-    mlir::ModuleOp module, llvm::StringRef name, mlir::FunctionType funcTy);
-
-}  // Fortran::burnside
+/// Both the `CookedSource` and `CharBlock` position should be provided to
+/// properly track source position information.
+mlir::FuncOp createFunction(mlir::ModuleOp module, llvm::StringRef name,
+    mlir::FunctionType funcTy, parser::CookedSource const *cooked = nullptr,
+    parser::CharBlock const *cb = nullptr);
+
+}  // burnside
+}  // Fortran
 
 #endif  // FORTRAN_BURNSIDE_BUILDER_H_
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
new file mode 100644
index 000000000000..3827a0a37477
--- /dev/null
+++ b/lib/burnside/convert-expr.cc
@@ -0,0 +1,691 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "convert-expr.h"
+#include "builder.h"
+#include "fe-helper.h"
+#include "fir/Dialect.h"
+#include "fir/FIROps.h"
+#include "fir/Type.h"
+#include "intrinsics.h"
+#include "runtime.h"
+#include "../common/default-kinds.h"
+#include "../common/unwrap.h"
+#include "../evaluate/fold.h"
+#include "../evaluate/real.h"
+#include "../semantics/expression.h"
+#include "../semantics/symbol.h"
+#include "../semantics/type.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Support/raw_ostream.h"
+#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Module.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/IR/Value.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "mlir/Transforms/Passes.h"
+
+namespace Br = Fortran::burnside;
+namespace Co = Fortran::common;
+namespace Ev = Fortran::evaluate;
+namespace L = llvm;
+namespace M = mlir;
+namespace Pa = Fortran::parser;
+namespace Se = Fortran::semantics;
+
+using namespace Fortran;
+using namespace Fortran::burnside;
+
+namespace {
+
+#define TODO() \
+  assert(false); \
+  return {}
+
+/// Lowering of Fortran::evaluate::Expr<T> expressions
+class ExprLowering {
+  M::Location location;
+  M::OpBuilder &builder;
+  SomeExpr const &expr;
+  SymMap &symMap;
+  Co::IntrinsicTypeDefaultKinds const &defaults;
+  IntrinsicLibrary const &intrinsics;
+
+  M::Location getLoc() { return location; }
+
+  /// Convert parser's INTEGER relational operators to MLIR.  TODO: using
+  /// unordered, but we may want to cons ordered in certain situation.
+  static M::CmpIPredicate translateRelational(Co::RelationalOperator rop) {
+    switch (rop) {
+    case Co::RelationalOperator::LT: return M::CmpIPredicate::SLT;
+    case Co::RelationalOperator::LE: return M::CmpIPredicate::SLE;
+    case Co::RelationalOperator::EQ: return M::CmpIPredicate::EQ;
+    case Co::RelationalOperator::NE: return M::CmpIPredicate::NE;
+    case Co::RelationalOperator::GT: return M::CmpIPredicate::SGT;
+    case Co::RelationalOperator::GE: return M::CmpIPredicate::SGE;
+    }
+    assert(false && "unhandled INTEGER relational operator");
+    return {};
+  }
+
+  /// Convert parser's REAL relational operators to MLIR.  TODO: using
+  /// unordered, but we may want to cons ordered in certain situation.
+  static M::CmpFPredicate translateFloatRelational(Co::RelationalOperator rop) {
+    switch (rop) {
+    case Co::RelationalOperator::LT: return M::CmpFPredicate::ULT;
+    case Co::RelationalOperator::LE: return M::CmpFPredicate::ULE;
+    case Co::RelationalOperator::EQ: return M::CmpFPredicate::UEQ;
+    case Co::RelationalOperator::NE: return M::CmpFPredicate::UNE;
+    case Co::RelationalOperator::GT: return M::CmpFPredicate::UGT;
+    case Co::RelationalOperator::GE: return M::CmpFPredicate::UGE;
+    }
+    assert(false && "unhandled REAL relational operator");
+    return {};
+  }
+
+  /// Generate an integral constant of `value`
+  template<int KIND>
+  M::Value *genIntegerConstant(M::MLIRContext *context, std::int64_t value) {
+    M::Type type{getFIRType(context, defaults, IntegerCat, 8)};
+    auto attr{builder.getIntegerAttr(type, value)};
+    auto res{builder.create<M::ConstantOp>(getLoc(), type, attr)};
+    return res.getResult();
+  }
+
+  /// Generate a logical/boolean constant of `value`
+  template<int KIND>
+  M::Value *genLogicalConstant(M::MLIRContext *context, bool value) {
+    auto attr{builder.getBoolAttr(value)};
+    M::Type logTy{getFIRType(context, defaults, LogicalCat, KIND)};
+    auto res{builder.create<M::ConstantOp>(getLoc(), logTy, attr)};
+    return res.getResult();
+  }
+
+  template<int KIND>
+  M::Value *genRealConstant(M::MLIRContext *context, L::APFloat const &value) {
+    M::Type fltTy{convertReal(context, KIND)};
+    auto attr{builder.getFloatAttr(fltTy, value)};
+    auto res{builder.create<M::ConstantOp>(getLoc(), fltTy, attr)};
+    return res.getResult();
+  }
+
+  M::Type getSomeKindInteger() {
+    return M::IndexType::get(builder.getContext());
+  }
+
+  template<typename OpTy, typename A>
+  M::Value *createBinaryOp(A const &ex, M::Value *lhs, M::Value *rhs) {
+    assert(lhs && rhs && "argument did not lower");
+    auto x = builder.create<OpTy>(getLoc(), lhs, rhs);
+    return x.getResult();
+  }
+  template<typename OpTy, typename A>
+  M::Value *createBinaryOp(A const &ex, M::Value *rhs) {
+    return createBinaryOp<OpTy>(ex, genval(ex.left()), rhs);
+  }
+  template<typename OpTy, typename A> M::Value *createBinaryOp(A const &ex) {
+    return createBinaryOp<OpTy>(ex, genval(ex.left()), genval(ex.right()));
+  }
+
+  M::FuncOp getFunction(L::StringRef name, M::FunctionType funTy) {
+    auto module{getModule(&builder)};
+    if (M::FuncOp func{getNamedFunction(module, name)}) {
+      return func;
+    }
+    return createFunction(module, name, funTy);
+  }
+
+  M::FuncOp getRuntimeFunction(RuntimeEntryCode callee, M::FunctionType funTy) {
+    auto name{getRuntimeEntryName(callee)};
+    return getFunction(name, funTy);
+  }
+
+  // FIXME binary operation :: ('a, 'a) -> 'a
+  template<Co::TypeCategory TC, int KIND> M::FunctionType createFunctionType() {
+    if constexpr (TC == IntegerCat) {
+      M::Type output{
+          getFIRType(builder.getContext(), defaults, IntegerCat, KIND)};
+      L::SmallVector<M::Type, 2> inputs;
+      inputs.push_back(output);
+      inputs.push_back(output);
+      return M::FunctionType::get(inputs, output, builder.getContext());
+    } else if constexpr (TC == RealCat) {
+      M::Type output{convertReal(builder.getContext(), KIND)};
+      L::SmallVector<M::Type, 2> inputs;
+      inputs.push_back(output);
+      inputs.push_back(output);
+      return M::FunctionType::get(inputs, output, builder.getContext());
+    } else {
+      assert(false);
+      return {};
+    }
+  }
+
+  /// Create a call to a Fortran runtime entry point
+  template<Co::TypeCategory TC, int KIND, typename A>
+  M::Value *createBinaryFIRTCall(A const &ex, RuntimeEntryCode callee) {
+    L::SmallVector<M::Value *, 2> operands;
+    operands.push_back(genval(ex.left()));
+    operands.push_back(genval(ex.right()));
+    M::FunctionType funTy = createFunctionType<TC, KIND>();
+    auto func{getRuntimeFunction(callee, funTy)};
+    auto x{builder.create<M::CallOp>(getLoc(), func, operands)};
+    return x.getResult(0);  // FIXME
+  }
+
+  template<typename OpTy, typename A>
+  M::Value *createCompareOp(
+      A const &ex, M::CmpIPredicate pred, M::Value *lhs, M::Value *rhs) {
+    assert(lhs && rhs && "argument did not lower");
+    auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
+    return x.getResult();
+  }
+  template<typename OpTy, typename A>
+  M::Value *createCompareOp(A const &ex, M::CmpIPredicate pred) {
+    return createCompareOp<OpTy>(
+        ex, pred, genval(ex.left()), genval(ex.right()));
+  }
+  template<typename OpTy, typename A>
+  M::Value *createFltCmpOp(
+      A const &ex, M::CmpFPredicate pred, M::Value *lhs, M::Value *rhs) {
+    assert(lhs && rhs && "argument did not lower");
+    auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
+    return x.getResult();
+  }
+  template<typename OpTy, typename A>
+  M::Value *createFltCmpOp(A const &ex, M::CmpFPredicate pred) {
+    return createFltCmpOp<OpTy>(
+        ex, pred, genval(ex.left()), genval(ex.right()));
+  }
+
+  M::Value *gen(Se::Symbol const *sym) {
+    // FIXME: not all symbols are local
+    return createTemporary(getLoc(), builder, symMap,
+        translateSymbolToFIRType(builder.getContext(), defaults, sym), sym);
+  }
+  M::Value *gendef(Se::Symbol const *sym) { return gen(sym); }
+  M::Value *genval(Se::Symbol const *sym) {
+    return builder.create<fir::LoadOp>(getLoc(), gen(sym));
+  }
+
+  M::Value *genval(Ev::BOZLiteralConstant const &) { TODO(); }
+  M::Value *genval(Ev::ProcedureRef const &) { TODO(); }
+  M::Value *genval(Ev::ProcedureDesignator const &) { TODO(); }
+  M::Value *genval(Ev::NullPointer const &) { TODO(); }
+  M::Value *genval(Ev::StructureConstructor const &) { TODO(); }
+  M::Value *genval(Ev::ImpliedDoIndex const &) { TODO(); }
+  M::Value *genval(Ev::DescriptorInquiry const &) { TODO(); }
+  template<int KIND> M::Value *genval(Ev::TypeParamInquiry<KIND> const &) {
+    TODO();
+  }
+  template<int KIND> M::Value *genval(Ev::ComplexComponent<KIND> const &part) {
+    auto *ctxt = builder.getContext();
+    auto realTy{getFIRType(ctxt, defaults, RealCat, KIND)};
+    auto index = genIntegerConstant<4>(ctxt, part.isImaginaryPart ? 1 : 0);
+    return builder.create<fir::ExtractValueOp>(
+        getLoc(), realTy, genval(part.left()), index);
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Negate<Ev::Type<TC, KIND>> const &) {
+    TODO();
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Add<Ev::Type<TC, KIND>> const &op) {
+    if constexpr (TC == IntegerCat) {
+      return createBinaryOp<M::AddIOp>(op);
+    } else if constexpr (TC == RealCat) {
+      return createBinaryOp<M::AddFOp>(op);
+    } else {
+      static_assert(TC == ComplexCat, "Expected numeric type");
+      return createBinaryOp<fir::AddcOp>(op);
+    }
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Subtract<Ev::Type<TC, KIND>> const &op) {
+    if constexpr (TC == IntegerCat) {
+      return createBinaryOp<M::SubIOp>(op);
+    } else if constexpr (TC == RealCat) {
+      return createBinaryOp<M::SubFOp>(op);
+    } else {
+      static_assert(TC == ComplexCat, "Expected numeric type");
+      return createBinaryOp<fir::SubcOp>(op);
+    }
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Multiply<Ev::Type<TC, KIND>> const &op) {
+    if constexpr (TC == IntegerCat) {
+      return createBinaryOp<M::MulIOp>(op);
+    } else if constexpr (TC == RealCat) {
+      return createBinaryOp<M::MulFOp>(op);
+    } else {
+      static_assert(TC == ComplexCat, "Expected numeric type");
+      return createBinaryOp<fir::MulcOp>(op);
+    }
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Divide<Ev::Type<TC, KIND>> const &op) {
+    if constexpr (TC == IntegerCat) {
+      return createBinaryOp<M::DivISOp>(op);
+    } else if constexpr (TC == RealCat) {
+      return createBinaryOp<M::DivFOp>(op);
+    } else {
+      static_assert(TC == ComplexCat, "Expected numeric type");
+      return createBinaryOp<fir::DivcOp>(op);
+    }
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Power<Ev::Type<TC, KIND>> const &op) {
+    llvm::SmallVector<mlir::Value *, 2> operands{
+        genval(op.left()), genval(op.right())};
+    M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
+    return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::RealToIntPower<Ev::Type<TC, KIND>> const &op) {
+    // TODO: runtime as limited integer kind support. Look if the conversions
+    // are ok
+    llvm::SmallVector<mlir::Value *, 2> operands{
+        genval(op.left()), genval(op.right())};
+    M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
+    return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
+  }
+  template<int KIND> M::Value *genval(Ev::ComplexConstructor<KIND> const &op) {
+    auto *ctxt = builder.getContext();
+    auto complexTy{fir::CplxType::get(ctxt, KIND)};
+    auto loc{getLoc()};
+    auto und = builder.create<fir::UndefOp>(loc, complexTy);
+    auto *lf = genval(op.left());
+    auto *realIdx = genIntegerConstant<4>(ctxt, 0);
+    auto rp =
+        builder.create<fir::InsertValueOp>(loc, complexTy, und, lf, realIdx);
+    auto *rt = genval(op.right());
+    auto *imagIdx = genIntegerConstant<4>(ctxt, 1);
+    return builder.create<fir::InsertValueOp>(loc, complexTy, rp, rt, imagIdx);
+  }
+  template<int KIND> M::Value *genval(Ev::Concat<KIND> const &op) {
+    // TODO this is a bogus call
+    return createBinaryFIRTCall<CharacterCat, KIND>(op, FIRT_CONCAT);
+  }
+
+  /// MIN and MAX operations
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Extremum<Ev::Type<TC, KIND>> const &op) {
+    if constexpr (TC == IntegerCat) {
+      return createBinaryFIRTCall<TC, KIND>(
+          op, op.ordering == Ev::Ordering::Greater ? FIRT_MAX : FIRT_MIN);
+    } else {
+      TODO();
+    }
+  }
+
+  template<int KIND> M::Value *genval(Ev::SetLength<KIND> const &) { TODO(); }
+
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Relational<Ev::Type<TC, KIND>> const &op) {
+    if constexpr (TC == IntegerCat) {
+      return createCompareOp<M::CmpIOp>(op, translateRelational(op.opr));
+    } else if constexpr (TC == RealCat) {
+      return createFltCmpOp<M::CmpFOp>(op, translateFloatRelational(op.opr));
+    } else {
+      TODO();
+    }
+  }
+  M::Value *genval(Ev::Relational<Ev::SomeType> const &op) {
+    return std::visit([&](const auto &x) { return genval(x); }, op.u);
+  }
+
+  template<Co::TypeCategory TC1, int KIND, Co::TypeCategory TC2>
+  M::Value *genval(Ev::Convert<Ev::Type<TC1, KIND>, TC2> const &convert) {
+    auto ty{getFIRType(builder.getContext(), defaults, TC1, KIND)};
+    return builder.create<fir::ConvertOp>(getLoc(), ty, genval(convert.left()));
+  }
+  template<typename A> M::Value *genval(Ev::Parentheses<A> const &) { TODO(); }
+  template<int KIND> M::Value *genval(const Ev::Not<KIND> &op) {
+    auto *context{builder.getContext()};
+    return createBinaryOp<M::XOrOp>(op, genLogicalConstant<KIND>(context, 1));
+  }
+
+  template<int KIND> M::Value *genval(Ev::LogicalOperation<KIND> const &op) {
+    switch (op.logicalOperator) {
+    case Ev::LogicalOperator::And: return createBinaryOp<M::AndOp>(op);
+    case Ev::LogicalOperator::Or: return createBinaryOp<M::OrOp>(op);
+    case Ev::LogicalOperator::Eqv:
+      return createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::EQ);
+    case Ev::LogicalOperator::Neqv:
+      return createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::NE);
+    }
+    assert(false && "unhandled logical operation");
+    return {};
+  }
+
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(Ev::Constant<Ev::Type<TC, KIND>> const &con) {
+    // TODO:
+    // - character type constant
+    // - array constant not handled
+    // - derived type constant
+    if constexpr (TC == IntegerCat) {
+      auto opt{con.GetScalarValue()};
+      if (opt.has_value())
+        return genIntegerConstant<KIND>(builder.getContext(), opt->ToInt64());
+      assert(false && "integer constant has no value");
+      return {};
+    } else if constexpr (TC == LogicalCat) {
+      auto opt{con.GetScalarValue()};
+      if (opt.has_value())
+        return genLogicalConstant<KIND>(builder.getContext(), opt->IsTrue());
+      assert(false && "logical constant has no value");
+      return {};
+    } else if constexpr (TC == RealCat) {
+      auto opt{con.GetScalarValue()};
+      if (opt.has_value()) {
+        std::string str{opt.value().DumpHexadecimal()};
+        if constexpr (KIND == 2) {
+          L::APFloat floatVal{L::APFloatBase::IEEEhalf(), str};
+          return genRealConstant<KIND>(builder.getContext(), floatVal);
+        } else if constexpr (KIND == 4) {
+          L::APFloat floatVal{L::APFloatBase::IEEEsingle(), str};
+          return genRealConstant<KIND>(builder.getContext(), floatVal);
+        } else if constexpr (KIND == 10) {
+          L::APFloat floatVal{L::APFloatBase::x87DoubleExtended(), str};
+          return genRealConstant<KIND>(builder.getContext(), floatVal);
+        } else if constexpr (KIND == 16) {
+          L::APFloat floatVal{L::APFloatBase::IEEEquad(), str};
+          return genRealConstant<KIND>(builder.getContext(), floatVal);
+        } else {
+          // convert everything else to double
+          L::APFloat floatVal{L::APFloatBase::IEEEdouble(), str};
+          return genRealConstant<KIND>(builder.getContext(), floatVal);
+        }
+      }
+      assert(false && "real constant has no value");
+      return {};
+    } else if constexpr (TC == ComplexCat) {
+      auto opt{con.GetScalarValue()};
+      if (opt.has_value()) {
+        using TR = Ev::Type<RealCat, KIND>;
+        return genval(Ev::ComplexConstructor<KIND>{
+            Ev::Expr<TR>{Ev::Constant<TR>{opt->REAL()}},
+            Ev::Expr<TR>{Ev::Constant<TR>{opt->AIMAG()}}});
+      }
+      assert(false && "array of complex unhandled");
+      return {};
+    } else {
+      assert(false && "unhandled constant");
+      return {};
+    }
+  }
+
+  template<Co::TypeCategory TC>
+  M::Value *genval(Ev::Constant<Ev::SomeKind<TC>> const &con) {
+    if constexpr (TC == IntegerCat) {
+      auto opt = (*con).ToInt64();
+      M::Type type{getSomeKindInteger()};
+      auto attr{builder.getIntegerAttr(type, opt)};
+      auto res{builder.create<M::ConstantOp>(getLoc(), type, attr)};
+      return res.getResult();
+    } else {
+      assert(false && "unhandled constant of unknown kind");
+      return {};
+    }
+  }
+
+  template<typename A> M::Value *genval(Ev::ArrayConstructor<A> const &) {
+    TODO();
+  }
+  M::Value *gen(Ev::ComplexPart const &) { TODO(); }
+  M::Value *gendef(Ev::ComplexPart const &cp) { return gen(cp); }
+  M::Value *genval(Ev::ComplexPart const &) { TODO(); }
+  M::Value *gen(const Ev::Substring &) { TODO(); }
+  M::Value *gendef(const Ev::Substring &ss) { return gen(ss); }
+  M::Value *genval(const Ev::Substring &) { TODO(); }
+  M::Value *genval(const Ev::Triplet &trip) { TODO(); }
+
+  M::Value *genval(const Ev::Subscript &subs) {
+    return std::visit(Co::visitors{
+                          [&](const Ev::IndirectSubscriptIntegerExpr &x) {
+                            return genval(x.value());
+                          },
+                          [&](const Ev::Triplet &x) { return genval(x); },
+                      },
+        subs.u);
+  }
+
+  M::Value *gen(const Ev::DataRef &dref) {
+    return std::visit([&](const auto &x) { return gen(x); }, dref.u);
+  }
+  M::Value *gendef(Ev::DataRef const &dref) { return gen(dref); }
+  M::Value *genval(Ev::DataRef const &dref) {
+    return std::visit([&](const auto &x) { return genval(x); }, dref.u);
+  }
+
+  // Helper function to turn the left-recursive Component structure into a list.
+  // Returns the object used as the base coordinate for the component chain.
+  static Ev::DataRef const *reverseComponents(
+      Ev::Component const &cmpt, std::list<Ev::Component const *> &list) {
+    list.push_front(&cmpt);
+    return std::visit(
+        Co::visitors{
+            [&](Ev::Component const &x) { return reverseComponents(x, list); },
+            [&](auto &) { return &cmpt.base(); },
+        },
+        cmpt.base().u);
+  }
+
+  // Return the coordinate of the component reference
+  M::Value *gen(const Ev::Component &cmpt) {
+    std::list<const Ev::Component *> list;
+    auto *base{reverseComponents(cmpt, list)};
+    L::SmallVector<M::Value *, 2> coorArgs;
+    auto obj{gen(*base)};
+    const Se::Symbol *sym{nullptr};
+    for (auto *field : list) {
+      sym = &field->GetLastSymbol();
+      auto name{sym->name().ToString()};
+      coorArgs.push_back(builder.create<fir::FieldIndexOp>(getLoc(), name));
+    }
+    assert(sym && "no component(s)?");
+    M::Type ty{translateSymbolToFIRType(builder.getContext(), defaults, sym)};
+    ty = fir::ReferenceType::get(ty);
+    return builder.create<fir::CoordinateOp>(getLoc(), ty, obj, coorArgs);
+  }
+  M::Value *gendef(const Ev::Component &cmpt) { return gen(cmpt); }
+  M::Value *genval(const Ev::Component &cmpt) {
+    return builder.create<fir::LoadOp>(getLoc(), gen(cmpt));
+  }
+
+  // Determine the result type after removing `dims` dimensions from the array
+  // type `arrTy`
+  M::Type genSubType(M::Type arrTy, unsigned dims) {
+    if (auto memRef{arrTy.dyn_cast<M::MemRefType>()}) {
+      if (dims < memRef.getRank()) {
+        auto shape{memRef.getShape()};
+        llvm::SmallVector<int64_t, 4> newShape;
+        // TODO: should we really remove rows here?
+        for (unsigned i = dims, e = memRef.getRank(); i < e; ++i) {
+          newShape.push_back(shape[i]);
+        }
+        return M::MemRefType::get(newShape, memRef.getElementType());
+      }
+      return memRef.getElementType();
+    }
+    auto unwrapTy{arrTy.cast<fir::ReferenceType>().getEleTy()};
+    auto seqTy{unwrapTy.cast<fir::SequenceType>()};
+    auto shape = seqTy.getShape();
+    if (shape.hasValue()) {
+      if (dims < shape->size()) {
+        fir::SequenceType::Bounds newBnds;
+        // follow Fortran semantics and remove columns
+        for (unsigned i = 0; i < dims; ++i) {
+          newBnds.push_back((*shape)[i]);
+        }
+        return fir::SequenceType::get({newBnds}, seqTy.getEleTy());
+      }
+    }
+    return seqTy.getEleTy();
+  }
+
+  // Return the coordinate of the array reference
+  M::Value *gen(Ev::ArrayRef const &aref) {
+    M::Value *base;
+    if (aref.base().IsSymbol())
+      base = gen(const_cast<Se::Symbol *>(&aref.base().GetFirstSymbol()));
+    else
+      base = gen(aref.base().GetComponent());
+    llvm::SmallVector<M::Value *, 8> args;
+    for (auto &subsc : aref.subscript()) {
+      args.push_back(genval(subsc));
+    }
+    auto ty{genSubType(base->getType(), args.size() - 1)};
+    ty = fir::ReferenceType::get(ty);
+    return builder.create<fir::CoordinateOp>(getLoc(), ty, base, args);
+  }
+  M::Value *gendef(const Ev::ArrayRef &aref) { return gen(aref); }
+  M::Value *genval(const Ev::ArrayRef &aref) {
+    return builder.create<fir::LoadOp>(getLoc(), gen(aref));
+  }
+
+  // Return a coordinate of the coarray reference. This is necessary as a
+  // Component may have a CoarrayRef as its base coordinate.
+  M::Value *gen(Ev::CoarrayRef const &coref) {
+    // FIXME: need to visit the cosubscripts...
+    // return gen(coref.base());
+    TODO();
+  }
+  M::Value *gendef(const Ev::CoarrayRef &coref) { return gen(coref); }
+  M::Value *genval(const Ev::CoarrayRef &coref) {
+    return builder.create<fir::LoadOp>(getLoc(), gen(coref));
+  }
+
+  template<typename A> M::Value *gen(Ev::Designator<A> const &des) {
+    return std::visit([&](const auto &x) { return gen(x); }, des.u);
+  }
+  template<typename A> M::Value *gendef(Ev::Designator<A> const &des) {
+    return gen(des);
+  }
+  template<typename A> M::Value *genval(Ev::Designator<A> const &des) {
+    return std::visit([&](const auto &x) { return genval(x); }, des.u);
+  }
+
+  // call a function
+  template<typename A> M::Value *gen(const Ev::FunctionRef<A> &funRef) {
+    TODO();
+  }
+  template<typename A> M::Value *gendef(const Ev::FunctionRef<A> &funRef) {
+    return gen(funRef);
+  }
+  template<typename A> M::Value *genval(const Ev::FunctionRef<A> &funRef) {
+    TODO();  // Derived type functions (user + intrinsics)
+  }
+  template<Co::TypeCategory TC, int KIND>
+  M::Value *genval(const Ev::FunctionRef<Ev::Type<TC, KIND>> &funRef) {
+    if (const auto &intrinsic{funRef.proc().GetSpecificIntrinsic()}) {
+      M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
+      L::SmallVector<M::Value *, 2> operands;
+      // Lower arguments
+      for (const auto &arg : funRef.arguments()) {
+        if (auto *expr{Ev::UnwrapExpr<Ev::Expr<Ev::SomeType>>(arg)}) {
+          operands.push_back(genval(*expr));
+        } else {
+          operands.push_back(nullptr);  // optional
+        }
+      }
+      // Let the intrinsic library lower the intrinsic function call
+      L::StringRef name{intrinsic->name};
+      return intrinsics.genval(getLoc(), builder, name, ty, operands);
+    } else {
+      TODO();  // User defined function.
+    }
+  }
+
+  template<typename A> M::Value *gen(const Ev::Expr<A> &exp) {
+    // must be a designator or function-reference (R902)
+    return std::visit([&](const auto &e) { return gendef(e); }, exp.u);
+  }
+  template<typename A> M::Value *gendef(Ev::Expr<A> const &exp) {
+    return gen(exp);
+  }
+  template<typename A> M::Value *genval(Ev::Expr<A> const &exp) {
+    return std::visit([&](const auto &e) { return genval(e); }, exp.u);
+  }
+
+  template<typename A> M::Value *gendef(const A &) {
+    assert(false && "expression error");
+    return {};
+  }
+
+public:
+  explicit ExprLowering(M::Location loc, M::OpBuilder &bldr,
+      SomeExpr const &vop, SymMap &map,
+      Co::IntrinsicTypeDefaultKinds const &defaults,
+      IntrinsicLibrary const &intr)
+    : location{loc}, builder{bldr}, expr{vop}, symMap{map}, defaults{defaults},
+      intrinsics{intr} {}
+
+  /// Lower the expression `expr` into MLIR standard dialect
+  M::Value *gen() { return gen(expr); }
+  M::Value *genval() { return genval(expr); }
+};
+
+}  // namespace
+
+M::Value *Br::createSomeExpression(M::Location loc, M::OpBuilder &builder,
+    Ev::Expr<Ev::SomeType> const &expr, SymMap &symMap,
+    Co::IntrinsicTypeDefaultKinds const &defaults,
+    IntrinsicLibrary const &intrinsics) {
+  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics}
+      .genval();
+}
+
+M::Value *Br::createSomeAddress(M::Location loc, M::OpBuilder &builder,
+    Ev::Expr<Ev::SomeType> const &expr, SymMap &symMap,
+    Co::IntrinsicTypeDefaultKinds const &defaults,
+    IntrinsicLibrary const &intrinsics) {
+  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics}.gen();
+}
+
+/// Create a temporary variable
+/// `symbol` will be nullptr for an anonymous temporary
+M::Value *Br::createTemporary(M::Location loc, M::OpBuilder &builder,
+    SymMap &symMap, M::Type type, Se::Symbol const *symbol) {
+  if (symbol)
+    if (auto *val{symMap.lookupSymbol(symbol)}) {
+      if (auto *op{val->getDefiningOp()}) {
+        return op->getResult(0);
+      }
+      return val;
+    }
+  auto insPt(builder.saveInsertionPoint());
+  builder.setInsertionPointToStart(getEntryBlock(&builder));
+  fir::AllocaOp ae;
+  assert(!type.dyn_cast<fir::ReferenceType>() && "cannot be a reference");
+  if (symbol) {
+    ae = builder.create<fir::AllocaOp>(loc, type, symbol->name().ToString());
+    symMap.addSymbol(symbol, ae);
+  } else {
+    ae = builder.create<fir::AllocaOp>(loc, type);
+  }
+  builder.restoreInsertionPoint(insPt);
+  return ae;
+}
diff --git a/lib/burnside/convert-expr.h b/lib/burnside/convert-expr.h
new file mode 100644
index 000000000000..5334fe72cb03
--- /dev/null
+++ b/lib/burnside/convert-expr.h
@@ -0,0 +1,64 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_CONVERT_EXPR_H_
+#define FORTRAN_BURNSIDE_CONVERT_EXPR_H_
+
+#include "intrinsics.h"
+
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+namespace mlir {
+class Location;
+class OpBuilder;
+class Type;
+class Value;
+}  // mlir
+
+namespace fir {
+class AllocaExpr;
+}  // fir
+
+namespace Fortran {
+namespace common {
+class IntrinsicTypeDefaultKinds;
+}  //  common
+namespace evaluate {
+template<typename> class Expr;
+class SomeType;
+}  // evaluate
+namespace semantics {
+class Symbol;
+}  // semantics
+
+namespace burnside {
+
+class SymMap;
+
+mlir::Value *createSomeExpression(mlir::Location loc, mlir::OpBuilder &builder,
+    evaluate::Expr<evaluate::SomeType> const &expr, SymMap &symMap,
+    common::IntrinsicTypeDefaultKinds const &defaults,
+    IntrinsicLibrary const &intrinsics);
+mlir::Value *createSomeAddress(mlir::Location loc, mlir::OpBuilder &builder,
+    evaluate::Expr<evaluate::SomeType> const &expr, SymMap &symMap,
+    common::IntrinsicTypeDefaultKinds const &defaults,
+    IntrinsicLibrary const &intrinsics);
+
+mlir::Value *createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
+    SymMap &symMap, mlir::Type type, const semantics::Symbol *symbol);
+
+}  // burnside
+}  // Fortran
+
+#endif  // FORTRAN_BURNSIDE_CONVERT_EXPR_H_
diff --git a/lib/burnside/fe-helper.cc b/lib/burnside/fe-helper.cc
new file mode 100644
index 000000000000..72265d6b66fe
--- /dev/null
+++ b/lib/burnside/fe-helper.cc
@@ -0,0 +1,384 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fe-helper.h"
+#include "bridge.h"
+#include "fir/Type.h"
+#include "../semantics/expression.h"
+#include "../semantics/tools.h"
+#include "../semantics/type.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Location.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/StandardTypes.h"
+
+namespace Br = Fortran::burnside;
+namespace Co = Fortran::common;
+namespace Ev = Fortran::evaluate;
+namespace M = mlir;
+namespace Pa = Fortran::parser;
+namespace Se = Fortran::semantics;
+
+using namespace Fortran;
+using namespace Fortran::burnside;
+
+namespace {
+
+template<typename A> bool isConstant(const Ev::Expr<A> &e) {
+  return Ev::IsConstantExpr(SomeExpr{e});
+}
+
+template<typename A> int64_t toConstant(const Ev::Expr<A> &e) {
+  auto opt = Ev::ToInt64(e);
+  assert(opt.has_value() && "expression didn't resolve to a constant");
+  return opt.value();
+}
+
+#undef TODO
+#define TODO() assert(false); return {}
+
+// one argument template, must be specialized
+template<Co::TypeCategory TC>
+M::Type genFIRType(M::MLIRContext *context, int kind) {
+  return {};
+}
+
+// two argument template
+template<Co::TypeCategory TC, int KIND>
+M::Type genFIRType(M::MLIRContext *context) {
+  if constexpr (TC == IntegerCat) {
+    auto bits{Ev::Type<IntegerCat, KIND>::Scalar::bits};
+    return M::IntegerType::get(bits, context);
+  } else if constexpr (TC == LogicalCat || TC == CharacterCat ||
+      TC == ComplexCat) {
+    return genFIRType<TC>(context, KIND);
+  } else {
+    return {};
+  }
+}
+
+template<> M::Type genFIRType<RealCat, 2>(M::MLIRContext *context) {
+  return M::FloatType::getF16(context);
+}
+
+template<> M::Type genFIRType<RealCat, 3>(M::MLIRContext *context) {
+  return M::FloatType::getBF16(context);
+}
+
+template<> M::Type genFIRType<RealCat, 4>(M::MLIRContext *context) {
+  return M::FloatType::getF32(context);
+}
+
+template<> M::Type genFIRType<RealCat, 8>(M::MLIRContext *context) {
+  return M::FloatType::getF64(context);
+}
+
+template<> M::Type genFIRType<RealCat, 10>(M::MLIRContext *context) {
+  return fir::RealType::get(context, 10);
+}
+
+template<> M::Type genFIRType<RealCat, 16>(M::MLIRContext *context) {
+  return fir::RealType::get(context, 16);
+}
+
+template<> M::Type genFIRType<RealCat>(M::MLIRContext *context, int kind) {
+  if (Ev::IsValidKindOfIntrinsicType(RealCat, kind)) {
+    switch (kind) {
+    case 2: return genFIRType<RealCat, 2>(context);
+    case 3: return genFIRType<RealCat, 3>(context);
+    case 4: return genFIRType<RealCat, 4>(context);
+    case 8: return genFIRType<RealCat, 8>(context);
+    case 10: return genFIRType<RealCat, 10>(context);
+    case 16: return genFIRType<RealCat, 16>(context);
+    }
+    assert(false && "type translation not implemented");
+  }
+  return {};
+}
+
+template<> M::Type genFIRType<IntegerCat>(M::MLIRContext *context, int kind) {
+  if (Ev::IsValidKindOfIntrinsicType(IntegerCat, kind)) {
+    switch (kind) {
+    case 1: return genFIRType<IntegerCat, 1>(context);
+    case 2: return genFIRType<IntegerCat, 2>(context);
+    case 4: return genFIRType<IntegerCat, 4>(context);
+    case 8: return genFIRType<IntegerCat, 8>(context);
+    case 16: return genFIRType<IntegerCat, 16>(context);
+    }
+    assert(false && "type translation not implemented");
+  }
+  return {};
+}
+
+template<> M::Type genFIRType<LogicalCat>(M::MLIRContext *context, int KIND) {
+  if (Ev::IsValidKindOfIntrinsicType(LogicalCat, KIND))
+    return fir::LogicalType::get(context, KIND);
+  return {};
+}
+
+template<> M::Type genFIRType<CharacterCat>(M::MLIRContext *context, int KIND) {
+  if (Ev::IsValidKindOfIntrinsicType(CharacterCat, KIND))
+    return fir::CharacterType::get(context, KIND);
+  return {};
+}
+
+template<> M::Type genFIRType<ComplexCat>(M::MLIRContext *context, int KIND) {
+  if (Ev::IsValidKindOfIntrinsicType(ComplexCat, KIND))
+    return fir::CplxType::get(context, KIND);
+  return {};
+}
+
+/// Recover the type of an evaluate::Expr<T> and convert it to an
+/// mlir::Type. The type returned can be a MLIR standard or FIR type.
+class TypeBuilder {
+  M::MLIRContext *context;
+  Co::IntrinsicTypeDefaultKinds const &defaults;
+
+  template<Co::TypeCategory TC> int defaultKind() { return defaultKind(TC); }
+  int defaultKind(Co::TypeCategory TC) { return defaults.GetDefaultKind(TC); }
+
+public:
+  explicit TypeBuilder(
+      M::MLIRContext *context, Co::IntrinsicTypeDefaultKinds const &defaults)
+    : context{context}, defaults{defaults} {}
+
+  // non-template, arguments are runtime values
+  M::Type genFIRTy(Co::TypeCategory tc, int kind) {
+    switch (tc) {
+    case RealCat: return genFIRType<RealCat>(context, kind);
+    case IntegerCat: return genFIRType<IntegerCat>(context, kind);
+    case ComplexCat: return genFIRType<ComplexCat>(context, kind);
+    case LogicalCat: return genFIRType<LogicalCat>(context, kind);
+    case CharacterCat: return genFIRType<CharacterCat>(context, kind);
+    default: break;
+    }
+    assert(false && "unhandled type category");
+    return {};
+  }
+
+  // non-template, category is runtime values, kind is defaulted
+  M::Type genFIRTy(Co::TypeCategory tc) {
+    return genFIRTy(tc, defaultKind(tc));
+  }
+
+  M::Type gen(const Ev::ImpliedDoIndex &) {
+    return genFIRType<IntegerCat>(context, defaultKind<IntegerCat>());
+  }
+
+  template<template<typename> typename A, Co::TypeCategory TC>
+  M::Type gen(const A<Ev::SomeKind<TC>> &) {
+    return genFIRType<TC>(context, defaultKind<TC>());
+  }
+
+  template<int KIND> M::Type gen(const Ev::TypeParamInquiry<KIND> &) {
+    return genFIRType<IntegerCat, KIND>(context);
+  }
+
+  template<typename A> M::Type gen(const Ev::Relational<A> &) {
+    return genFIRType<LogicalCat, 1>(context);
+  }
+
+  template<template<typename> typename A, Co::TypeCategory TC, int KIND>
+  M::Type gen(const A<Ev::Type<TC, KIND>> &) {
+    return genFIRType<TC, KIND>(context);
+  }
+
+  // breaks the conflict between A<Type<TC,KIND>> and Expr<B> deduction
+  template<Co::TypeCategory TC, int KIND>
+  M::Type gen(const Ev::Expr<Ev::Type<TC, KIND>> &) {
+    return genFIRType<TC, KIND>(context);
+  }
+
+  template<typename A> M::Type genVariant(const A &variant) {
+    return std::visit([&](const auto &x) { return gen(x); }, variant.u);
+  }
+
+  // breaks the conflict between A<SomeKind<TC>> and Expr<B> deduction
+  template<Co::TypeCategory TC>
+  M::Type gen(const Ev::Expr<Ev::SomeKind<TC>> &expr) {
+    return genVariant(expr);
+  }
+
+  template<typename A> M::Type gen(const Ev::Expr<A> &expr) {
+    return genVariant(expr);
+  }
+
+  M::Type gen(const Ev::DataRef &dref) { return genVariant(dref); }
+
+  M::Type mkVoid() { return M::TupleType::get(context); }
+
+  fir::SequenceType::Shape genSeqShape(const Se::Symbol *symbol) {
+    assert(symbol->IsObjectArray());
+    fir::SequenceType::Bounds bounds;
+    auto &details = symbol->get<Se::ObjectEntityDetails>();
+    const auto size = details.shape().size();
+    for (auto &ss : details.shape()) {
+      auto lb = ss.lbound();
+      auto ub = ss.ubound();
+      if (lb.isAssumed() && ub.isAssumed() && size == 1) {
+        return {};
+      }
+      if (lb.isExplicit() && ub.isExplicit()) {
+        auto &lbv = lb.GetExplicit();
+        auto &ubv = ub.GetExplicit();
+        if (lbv.has_value() && ubv.has_value() && isConstant(lbv.value()) &&
+            isConstant(ubv.value())) {
+          bounds.emplace_back(
+              toConstant(ubv.value()) - toConstant(lbv.value()) + 1);
+        } else {
+          bounds.emplace_back(0);
+        }
+      } else {
+        bounds.emplace_back(0);
+      }
+    }
+    return {bounds};
+  }
+
+  /// Type consing from a symbol. A symbol's type must be created from the type
+  /// discovered by the front-end at runtime.
+  M::Type gen(const Se::Symbol *symbol) {
+    if (auto *proc = symbol->detailsIf<Se::SubprogramDetails>()) {
+      M::Type returnTy{mkVoid()};
+      if (proc->isFunction()) {
+        returnTy = gen(&proc->result());
+      }
+      // FIXME: handle alt-return
+      llvm::SmallVector<M::Type, 4> inputTys;
+      for (auto *arg : proc->dummyArgs()) {
+        // FIXME: not all args are pass by ref
+        inputTys.emplace_back(fir::ReferenceType::get(gen(arg)));
+      }
+      return M::FunctionType::get(inputTys, returnTy, context);
+    }
+    M::Type returnTy{};
+    if (auto *type{symbol->GetType()}) {
+      if (auto *tySpec{type->AsIntrinsic()}) {
+        int kind = toConstant(tySpec->kind());
+        switch (tySpec->category()) {
+        case IntegerCat:
+          returnTy = genFIRType<IntegerCat>(context, kind);
+          break;
+        case RealCat: returnTy = genFIRType<RealCat>(context, kind); break;
+        case ComplexCat:
+          returnTy = genFIRType<ComplexCat>(context, kind);
+          break;
+        case CharacterCat:
+          returnTy = genFIRType<CharacterCat>(context, kind);
+          break;
+        case LogicalCat:
+          returnTy = genFIRType<LogicalCat>(context, kind);
+          break;
+        case DerivedCat: TODO(); break;
+        }
+      } else if (auto *tySpec{type->AsDerived()}) {
+        TODO();
+      } else {
+        assert(false && "type spec not found");
+      }
+    } else {
+      assert(false && "symbol has no type");
+    }
+    if (symbol->IsObjectArray()) {
+      // FIXME: add bounds info
+      returnTy = fir::SequenceType::get(genSeqShape(symbol), returnTy);
+    } else if (Se::IsPointer(*symbol)) {
+      // FIXME: what about allocatable?
+      returnTy = fir::ReferenceType::get(returnTy);
+    }
+    return returnTy;
+  }
+
+  fir::SequenceType::Shape trivialShape(int size) {
+    fir::SequenceType::Bounds bounds;
+    bounds.emplace_back(size);
+    return {bounds};
+  }
+
+  // some sequence of `n` bytes
+  M::Type gen(const Ev::StaticDataObject::Pointer &ptr) {
+    M::Type byteTy{M::IntegerType::get(8, context)};
+    return fir::SequenceType::get(trivialShape(ptr->itemBytes()), byteTy);
+  }
+
+  M::Type gen(const Ev::Substring &ss) {
+    return genVariant(ss.GetBaseObject());
+  }
+
+  M::Type genTypelessPtr() { return fir::ReferenceType::get(mkVoid()); }
+  M::Type gen(const Ev::NullPointer &) { return genTypelessPtr(); }
+  M::Type gen(const Ev::ProcedureRef &) { return genTypelessPtr(); }
+  M::Type gen(const Ev::ProcedureDesignator &) { return genTypelessPtr(); }
+  M::Type gen(const Ev::BOZLiteralConstant &) { return genTypelessPtr(); }
+
+  M::Type gen(const Ev::ArrayRef &) { TODO(); }
+  M::Type gen(const Ev::CoarrayRef &) { TODO(); }
+  M::Type gen(const Ev::Component &) { TODO(); }
+  M::Type gen(const Ev::ComplexPart &) { TODO(); }
+  M::Type gen(const Ev::DescriptorInquiry &) { TODO(); }
+  M::Type gen(const Ev::StructureConstructor &) { TODO(); }
+};
+
+}  // namespace
+
+M::Location Br::dummyLoc(M::MLIRContext &context) {
+  return M::UnknownLoc::get(&context);
+}
+
+M::Location Br::parserPosToLoc(M::MLIRContext &context,
+    const Pa::CookedSource *cooked, const Pa::CharBlock &position) {
+  if (cooked) {
+    auto loc{cooked->GetSourcePositionRange(position)};
+    if (loc.has_value()) {
+      // loc is a pair (begin, end); use the beginning position
+      auto &filePos{loc->first};
+      return M::FileLineColLoc::get(
+          filePos.file.path(), filePos.line, filePos.column, &context);
+    }
+  }
+  return dummyLoc(context);
+}
+
+M::Type Br::getFIRType(M::MLIRContext *context,
+    Co::IntrinsicTypeDefaultKinds const &defaults, Co::TypeCategory tc,
+    int kind) {
+  return TypeBuilder{context, defaults}.genFIRTy(tc, kind);
+}
+
+M::Type Br::getFIRType(M::MLIRContext *context,
+    Co::IntrinsicTypeDefaultKinds const &defaults, Co::TypeCategory tc) {
+  return TypeBuilder{context, defaults}.genFIRTy(tc);
+}
+
+M::Type Br::translateDataRefToFIRType(M::MLIRContext *context,
+    Co::IntrinsicTypeDefaultKinds const &defaults, const Ev::DataRef &dataRef) {
+  return TypeBuilder{context, defaults}.gen(dataRef);
+}
+
+// Builds the FIR type from an instance of SomeExpr
+M::Type Br::translateSomeExprToFIRType(M::MLIRContext *context,
+    Co::IntrinsicTypeDefaultKinds const &defaults, const SomeExpr *expr) {
+  return TypeBuilder{context, defaults}.gen(*expr);
+}
+
+// This entry point avoids gratuitously wrapping the Symbol instance in layers
+// of Expr<T> that will then be immediately peeled back off and discarded.
+M::Type Br::translateSymbolToFIRType(M::MLIRContext *context,
+    Co::IntrinsicTypeDefaultKinds const &defaults, const Se::Symbol *symbol) {
+  return TypeBuilder{context, defaults}.gen(symbol);
+}
+
+M::Type Br::convertReal(M::MLIRContext *context, int kind) {
+  return genFIRType<RealCat>(context, kind);
+}
diff --git a/lib/burnside/fe-helper.h b/lib/burnside/fe-helper.h
new file mode 100644
index 000000000000..3eb90d83d9c2
--- /dev/null
+++ b/lib/burnside/fe-helper.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_FE_HELPER_H_
+#define FORTRAN_BURNSIDE_FE_HELPER_H_
+
+/// Traversal and conversion of Fortran type data structures into the FIR
+/// dialect of MLIR.
+///
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+#include "../common/Fortran.h"
+#include "mlir/IR/Types.h"
+
+namespace mlir {
+class Location;
+class MLIRContext;
+class Type;
+}
+
+namespace Fortran {
+namespace common {
+class IntrinsicTypeDefaultKinds;
+}  // common
+
+namespace evaluate {
+struct DataRef;
+template<typename> class Designator;
+template<typename> class Expr;
+template<common::TypeCategory> struct SomeKind;
+struct SomeType;
+template<common::TypeCategory, int> class Type;
+}  // evaluate
+
+namespace parser {
+class CharBlock;
+class CookedSource;
+}  // parser
+
+namespace semantics {
+class Symbol;
+}  // semantics
+
+namespace burnside {
+
+using SomeExpr = evaluate::Expr<evaluate::SomeType>;
+
+constexpr common::TypeCategory IntegerCat{common::TypeCategory::Integer};
+constexpr common::TypeCategory RealCat{common::TypeCategory::Real};
+constexpr common::TypeCategory ComplexCat{common::TypeCategory::Complex};
+constexpr common::TypeCategory CharacterCat{common::TypeCategory::Character};
+constexpr common::TypeCategory LogicalCat{common::TypeCategory::Logical};
+constexpr common::TypeCategory DerivedCat{common::TypeCategory::Derived};
+
+/// Generate a dummy location when there is no origin
+mlir::Location dummyLoc(mlir::MLIRContext &context);
+
+/// Convert a `CharBlock` front-end position pointer into the `(file, line,
+/// column)` triple for use in MLIR, LLVM, and ultimately DWARF.
+mlir::Location parserPosToLoc(mlir::MLIRContext &context,
+    parser::CookedSource const *cooked, parser::CharBlock const &position);
+
+mlir::Type getFIRType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults, common::TypeCategory tc,
+    int kind);
+mlir::Type getFIRType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults, common::TypeCategory tc);
+
+mlir::Type translateDataRefToFIRType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults,
+    const evaluate::DataRef &dataRef);
+
+template<common::TypeCategory TC, int KIND>
+inline mlir::Type translateDesignatorToFIRType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults,
+    const evaluate::Designator<evaluate::Type<TC, KIND>> &) {
+  return getFIRType(ctxt, defaults, TC, KIND);
+}
+
+template<common::TypeCategory TC>
+inline mlir::Type translateDesignatorToFIRType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults,
+    const evaluate::Designator<evaluate::SomeKind<TC>> &) {
+  return getFIRType(ctxt, defaults, TC);
+}
+
+mlir::Type translateSomeExprToFIRType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults, const SomeExpr *expr);
+
+mlir::Type translateSymbolToFIRType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults,
+    const semantics::Symbol *symbol);
+
+mlir::Type convertReal(mlir::MLIRContext *context, int KIND);
+
+}  // burnside
+}  // Fortran
+#endif  // FORTRAN_BURNSIDE_FE_HELPER_H_
diff --git a/lib/burnside/flattened.cc b/lib/burnside/flattened.cc
index 387cf3f377d4..3d7989dcda9e 100644
--- a/lib/burnside/flattened.cc
+++ b/lib/burnside/flattened.cc
@@ -24,8 +24,8 @@ namespace flat {
 // should never approach UINT_MAX.
 LabelBuilder::LabelBuilder() : referenced(32), counter{0u} {}
 
-LabelRef LabelBuilder::getNext() {
-  LabelRef next{counter++};
+LabelMention LabelBuilder::getNext() {
+  LabelMention next{counter++};
   auto cap{referenced.size()};
   if (cap < counter) {
     referenced.resize(2 * cap);
@@ -34,12 +34,12 @@ LabelRef LabelBuilder::getNext() {
   return next;
 }
 
-void LabelBuilder::setReferenced(LabelRef label) {
+void LabelBuilder::setReferenced(LabelMention label) {
   CHECK(label < referenced.getBitCapacity());
   referenced.set(label);
 }
 
-bool LabelBuilder::isReferenced(LabelRef label) const {
+bool LabelBuilder::isReferenced(LabelMention label) const {
   CHECK(label < referenced.getBitCapacity());
   return referenced.test(label);
 }
@@ -65,17 +65,17 @@ static void AddAssign(AnalysisData &ad, const semantics::Symbol *symbol,
   ad.assignMap[symbol].insert(label);
 }
 
-std::vector<LabelRef> GetAssign(
+std::vector<LabelMention> GetAssign(
     AnalysisData &ad, const semantics::Symbol *symbol) {
-  std::vector<LabelRef> result;
+  std::vector<LabelMention> result;
   for (auto lab : ad.assignMap[symbol]) {
     result.emplace_back(lab);
   }
   return result;
 }
 
-static std::tuple<const parser::Name *, LabelRef, LabelRef> FindStack(
-    const std::vector<std::tuple<const parser::Name *, LabelRef, LabelRef>>
+static std::tuple<const parser::Name *, LabelMention, LabelMention> FindStack(
+    const std::vector<std::tuple<const parser::Name *, LabelMention, LabelMention>>
         &stack,
     const parser::Name *key) {
   for (auto iter{stack.rbegin()}, iend{stack.rend()}; iter != iend; ++iter) {
@@ -176,7 +176,7 @@ template<typename A>
 void errLabelSpec(const A &s, std::list<Op> &ops,
     const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
   if (auto errLab{GetErr(s)}) {
-    std::optional<LabelRef> errRef{FetchLabel(ad, errLab).get()};
+    std::optional<LabelMention> errRef{FetchLabel(ad, errLab).get()};
     LabelOp next{BuildNewLabel(ad)};
     ops.emplace_back(SwitchIOOp{s, next, ec.source, errRef});
     ops.emplace_back(next);
@@ -192,15 +192,15 @@ void threeLabelSpec(const A &s, std::list<Op> &ops,
   auto eorLab{GetEor(s)};
   auto endLab{GetEnd(s)};
   if (errLab || eorLab || endLab) {
-    std::optional<LabelRef> errRef;
+    std::optional<LabelMention> errRef;
     if (errLab) {
       errRef = FetchLabel(ad, errLab).get();
     }
-    std::optional<LabelRef> eorRef;
+    std::optional<LabelMention> eorRef;
     if (eorLab) {
       eorRef = FetchLabel(ad, eorLab).get();
     }
-    std::optional<LabelRef> endRef;
+    std::optional<LabelMention> endRef;
     if (endLab) {
       endRef = FetchLabel(ad, endLab).get();
     }
@@ -213,8 +213,8 @@ void threeLabelSpec(const A &s, std::list<Op> &ops,
 }
 
 template<typename A>
-std::vector<LabelRef> toLabelRef(AnalysisData &ad, const A &labels) {
-  std::vector<LabelRef> result;
+std::vector<LabelMention> toLabelMention(AnalysisData &ad, const A &labels) {
+  std::vector<LabelMention> result;
   for (auto label : labels) {
     result.emplace_back(FetchLabel(ad, label).get());
   }
@@ -223,11 +223,11 @@ std::vector<LabelRef> toLabelRef(AnalysisData &ad, const A &labels) {
 }
 
 template<typename A>
-std::vector<LabelRef> toLabelRef(
+std::vector<LabelMention> toLabelMention(
     const LabelOp &next, AnalysisData &ad, const A &labels) {
-  std::vector<LabelRef> result;
+  std::vector<LabelMention> result;
   result.emplace_back(next);
-  auto refs{toLabelRef(ad, labels)};
+  auto refs{toLabelMention(ad, labels)};
   result.insert(result.end(), refs.begin(), refs.end());
   CHECK(result.size() == labels.size() + 1);
   return result;
@@ -256,7 +256,7 @@ static std::list<parser::Label> getAltReturnLabels(const parser::Call &call) {
   return result;
 }
 
-static LabelRef NearestEnclosingDoConstruct(AnalysisData &ad) {
+static LabelMention NearestEnclosingDoConstruct(AnalysisData &ad) {
   for (auto iterator{ad.constructContextStack.rbegin()},
        endIterator{ad.constructContextStack.rend()};
        iterator != endIterator; ++iterator) {
@@ -277,6 +277,26 @@ template<typename A, typename B> std::string GetSource(const B *s) {
   return GetSource(&std::get<parser::Statement<A>>(s->t));
 }
 
+static bool meetsBlockConstraints(const parser::Block &block) { return false; }
+
+static bool meetsLoopConstraints(const parser::DoConstruct &loop) {
+  return meetsBlockConstraints(std::get<parser::Block>(loop.t));
+}
+
+static bool meetsWhereConstraints(const parser::IfConstruct &w) {
+  // we can do better, but for now don't allow ELSE IF constructs
+  if (std::get<std::list<parser::IfConstruct::ElseIfBlock>>(w.t).empty()) {
+    const auto &optElse{
+        std::get<std::optional<parser::IfConstruct::ElseBlock>>(w.t)};
+    if (optElse.has_value() &&
+        !meetsBlockConstraints(std::get<parser::Block>(optElse->t))) {
+      return false;
+    }
+    return meetsBlockConstraints(std::get<parser::Block>(w.t));
+  }
+  return false;
+}
+
 void Op::Build(std::list<Op> &ops,
     const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
   std::visit(
@@ -286,7 +306,7 @@ void Op::Build(std::list<Op> &ops,
             if (hasAltReturns(s.value())) {
               auto next{BuildNewLabel(ad)};
               auto alts{getAltReturnLabels(s.value().v)};
-              auto labels{toLabelRef(next, ad, alts)};
+              auto labels{toLabelMention(next, ad, alts)};
               ops.emplace_back(
                   SwitchOp{s.value(), std::move(labels), ec.source});
               ops.emplace_back(next);
@@ -359,14 +379,14 @@ void Op::Build(std::list<Op> &ops,
           },
           [&](const common::Indirection<parser::ComputedGotoStmt> &s) {
             auto next{BuildNewLabel(ad)};
-            auto labels{toLabelRef(
+            auto labels{toLabelMention(
                 next, ad, std::get<std::list<parser::Label>>(s.value().t))};
             ops.emplace_back(SwitchOp{s.value(), std::move(labels), ec.source});
             ops.emplace_back(next);
           },
           [&](const common::Indirection<parser::ArithmeticIfStmt> &s) {
             ops.emplace_back(SwitchOp{s.value(),
-                toLabelRef(ad,
+                toLabelMention(ad,
                     std::list{std::get<1>(s.value().t),
                         std::get<2>(s.value().t), std::get<3>(s.value().t)}),
                 ec.source});
@@ -374,7 +394,7 @@ void Op::Build(std::list<Op> &ops,
           [&](const common::Indirection<parser::AssignedGotoStmt> &s) {
             ops.emplace_back(
                 IndirectGotoOp{std::get<parser::Name>(s.value().t).symbol,
-                    toLabelRef(
+                    toLabelMention(
                         ad, std::get<std::list<parser::Label>>(s.value().t))});
           },
           [&](const common::Indirection<parser::IfStmt> &s) {
@@ -441,7 +461,7 @@ struct ControlFlowAnalyzer {
     LabelOp label{buildNewLabel()};
     const parser::Name *name{getName(construct)};
     ad.constructContextStack.emplace_back(
-        name, GetLabelRef(label), UnspecifiedLabel);
+        name, GetLabelMention(label), UnspecifiedLabel);
     appendIfLabeled(std::get<0>(construct.t), ops);
     ops.emplace_back(BeginOp{construct});
     ControlFlowAnalyzer cfa{ops, ad};
@@ -466,7 +486,7 @@ struct ControlFlowAnalyzer {
             .statement.v};
     const parser::Name *name{optName ? &*optName : nullptr};
     ad.constructContextStack.emplace_back(
-        name, GetLabelRef(label), UnspecifiedLabel);
+        name, GetLabelMention(label), UnspecifiedLabel);
     appendIfLabeled(
         std::get<parser::Statement<parser::BlockStmt>>(construct.t), ops);
     ops.emplace_back(BeginOp{construct});
@@ -484,32 +504,35 @@ struct ControlFlowAnalyzer {
   /// `DO` constructs can be lowered to `fir.loop` if they meet some
   /// constraints, otherwise they are lowered to a CFG.
   bool Pre(const parser::DoConstruct &construct) {
+    if (meetsLoopConstraints(construct)) {
+      // use `fir.loop`
+    }
     std::list<Op> ops;
     LabelOp backedgeLab{buildNewLabel()};
     LabelOp incrementLab{buildNewLabel()};
     LabelOp entryLab{buildNewLabel()};
     LabelOp exitLab{buildNewLabel()};
     const parser::Name *name{getName(construct)};
-    LabelRef exitOpRef{GetLabelRef(exitLab)};
+    LabelMention exitOpRef{GetLabelMention(exitLab)};
     ad.constructContextStack.emplace_back(
-        name, exitOpRef, GetLabelRef(incrementLab));
+        name, exitOpRef, GetLabelMention(incrementLab));
     appendIfLabeled(
         std::get<parser::Statement<parser::NonLabelDoStmt>>(construct.t), ops);
     ops.emplace_back(BeginOp{construct});
-    ops.emplace_back(GotoOp{GetLabelRef(backedgeLab)});
+    ops.emplace_back(GotoOp{GetLabelMention(backedgeLab)});
     ops.emplace_back(incrementLab);
     ops.emplace_back(DoIncrementOp{construct});
     ops.emplace_back(backedgeLab);
     ops.emplace_back(DoCompareOp{construct});
     ops.emplace_back(ConditionalGotoOp{
         std::get<parser::Statement<parser::NonLabelDoStmt>>(construct.t),
-        GetLabelRef(entryLab), exitOpRef});
+        GetLabelMention(entryLab), exitOpRef});
     ops.push_back(entryLab);
     ControlFlowAnalyzer cfa{ops, ad};
     Walk(std::get<parser::Block>(construct.t), cfa);
     appendIfLabeled(
         std::get<parser::Statement<parser::EndDoStmt>>(construct.t), ops);
-    ops.emplace_back(GotoOp{GetLabelRef(incrementLab)});
+    ops.emplace_back(GotoOp{GetLabelMention(incrementLab)});
     ops.emplace_back(EndOp{construct});
     ops.emplace_back(exitLab);
     linearOps.splice(linearOps.end(), ops);
@@ -520,23 +543,26 @@ struct ControlFlowAnalyzer {
   /// `IF` constructs can be lowered to `fir.where` if they meet some
   /// constraints, otherwise they are lowered to a CFG.
   bool Pre(const parser::IfConstruct &construct) {
+    if (meetsWhereConstraints(construct)) {
+      // use `fir.where`
+    }
     std::list<Op> ops;
     LabelOp thenLab{buildNewLabel()};
     LabelOp elseLab{buildNewLabel()};
     LabelOp exitLab{buildNewLabel()};
     const parser::Name *name{getName(construct)};
     ad.constructContextStack.emplace_back(
-        name, GetLabelRef(exitLab), UnspecifiedLabel);
+        name, GetLabelMention(exitLab), UnspecifiedLabel);
     appendIfLabeled(
         std::get<parser::Statement<parser::IfThenStmt>>(construct.t), ops);
     ops.emplace_back(BeginOp{construct});
     ops.emplace_back(ConditionalGotoOp{
         std::get<parser::Statement<parser::IfThenStmt>>(construct.t),
-        GetLabelRef(thenLab), GetLabelRef(elseLab)});
+        GetLabelMention(thenLab), GetLabelMention(elseLab)});
     ops.emplace_back(thenLab);
     ControlFlowAnalyzer cfa{ops, ad};
     Walk(std::get<parser::Block>(construct.t), cfa);
-    LabelRef exitOpRef{GetLabelRef(exitLab)};
+    LabelMention exitOpRef{GetLabelMention(exitLab)};
     ops.emplace_back(GotoOp{exitOpRef});
     for (const auto &elseIfBlock :
         std::get<std::list<parser::IfConstruct::ElseIfBlock>>(construct.t)) {
@@ -547,7 +573,7 @@ struct ControlFlowAnalyzer {
       LabelOp newElseLab{buildNewLabel()};
       ops.emplace_back(ConditionalGotoOp{
           std::get<parser::Statement<parser::ElseIfStmt>>(elseIfBlock.t),
-          GetLabelRef(newThenLab), GetLabelRef(newElseLab)});
+          GetLabelMention(newThenLab), GetLabelMention(newElseLab)});
       ops.emplace_back(newThenLab);
       Walk(std::get<parser::Block>(elseIfBlock.t), cfa);
       ops.emplace_back(GotoOp{exitOpRef});
@@ -577,20 +603,20 @@ struct ControlFlowAnalyzer {
     LabelOp exitLab{buildNewLabel()};
     const parser::Name *name{getName(construct)};
     ad.constructContextStack.emplace_back(
-        name, GetLabelRef(exitLab), UnspecifiedLabel);
+        name, GetLabelMention(exitLab), UnspecifiedLabel);
     appendIfLabeled(std::get<0>(construct.t), ops);
     ops.emplace_back(BeginOp{construct});
     const auto N{std::get<std::list<B>>(construct.t).size()};
-    LabelRef exitOpRef{GetLabelRef(exitLab)};
+    LabelMention exitOpRef{GetLabelMention(exitLab)};
     if (N > 0) {
       typename std::list<B>::size_type i;
       std::vector<LabelOp> toLabels;
       for (i = 0; i != N; ++i) {
         toLabels.emplace_back(buildNewLabel());
       }
-      std::vector<LabelRef> targets;
+      std::vector<LabelMention> targets;
       for (i = 0; i != N; ++i) {
-        targets.emplace_back(GetLabelRef(toLabels[i]));
+        targets.emplace_back(GetLabelMention(toLabels[i]));
       }
       ops.emplace_back(
           SwitchOp{construct, targets, std::get<0>(construct.t).source});
@@ -620,7 +646,7 @@ struct ControlFlowAnalyzer {
     LabelOp label{buildNewLabel()};
     const parser::Name *name{getName(c)};
     ad.constructContextStack.emplace_back(
-        name, GetLabelRef(label), UnspecifiedLabel);
+        name, GetLabelMention(label), UnspecifiedLabel);
     appendIfLabeled(
         std::get<parser::Statement<parser::WhereConstructStmt>>(c.t), ops);
     ops.emplace_back(BeginOp{c});
@@ -643,7 +669,7 @@ struct ControlFlowAnalyzer {
     LabelOp label{buildNewLabel()};
     const parser::Name *name{getName(construct)};
     ad.constructContextStack.emplace_back(
-        name, GetLabelRef(label), UnspecifiedLabel);
+        name, GetLabelMention(label), UnspecifiedLabel);
     appendIfLabeled(
         std::get<parser::Statement<parser::ForallConstructStmt>>(construct.t),
         ops);
@@ -664,12 +690,12 @@ struct ControlFlowAnalyzer {
     return optName ? &*optName : nullptr;
   }
 
-  LabelRef GetLabelRef(const LabelOp &label) {
+  LabelMention GetLabelMention(const LabelOp &label) {
     label.setReferenced();
     return label;
   }
 
-  LabelRef GetLabelRef(const parser::Label &label) {
+  LabelMention GetLabelMention(const parser::Label &label) {
     return FetchLabel(ad, label);
   }
 
diff --git a/lib/burnside/flattened.h b/lib/burnside/flattened.h
index 7d07d477968f..f5c795c04eaa 100644
--- a/lib/burnside/flattened.h
+++ b/lib/burnside/flattened.h
@@ -36,8 +36,8 @@ namespace flat {
 ///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-using LabelRef = unsigned;
-constexpr LabelRef UnspecifiedLabel{UINT_MAX};
+using LabelMention = unsigned;
+constexpr LabelMention UnspecifiedLabel{UINT_MAX};
 
 using Location = parser::CharBlock;
 struct LabelBuilder;
@@ -49,12 +49,12 @@ struct LabelOp {
   LabelOp &operator=(const LabelOp &that);
   void setReferenced() const;
   bool isReferenced() const;
-  LabelRef get() const { return label; }
-  operator LabelRef() const { return get(); }
+  LabelMention get() const { return label; }
+  operator LabelMention() const { return get(); }
 
 private:
   LabelBuilder &builder;
-  LabelRef label;
+  LabelMention label;
 };
 
 struct ArtificialJump {};
@@ -64,12 +64,12 @@ struct GotoOp
   : public SumTypeCopyMixin<const parser::CycleStmt *, const parser::ExitStmt *,
         const parser::GotoStmt *, ArtificialJump> {
   template<typename A>
-  explicit GotoOp(const A &stmt, LabelRef dest, const Location &source)
+  explicit GotoOp(const A &stmt, LabelMention dest, const Location &source)
     : SumTypeCopyMixin{&stmt}, target{dest}, source{source} {}
-  explicit GotoOp(LabelRef dest)
+  explicit GotoOp(LabelMention dest)
     : SumTypeCopyMixin{ArtificialJump{}}, target{dest} {}
 
-  LabelRef target;
+  LabelMention target;
   Location source;
 };
 
@@ -89,20 +89,20 @@ struct ConditionalGotoOp
         const parser::Statement<parser::ElseIfStmt> *, const parser::IfStmt *,
         const parser::Statement<parser::NonLabelDoStmt> *> {
   template<typename A>
-  explicit ConditionalGotoOp(const A &cond, LabelRef tb, LabelRef fb)
+  explicit ConditionalGotoOp(const A &cond, LabelMention tb, LabelMention fb)
     : SumTypeCopyMixin{&cond}, trueLabel{tb}, falseLabel{fb} {}
 
-  LabelRef trueLabel;
-  LabelRef falseLabel;
+  LabelMention trueLabel;
+  LabelMention falseLabel;
 };
 
 // multi-way branch based on a target-value of a variable
 struct IndirectGotoOp {
   explicit IndirectGotoOp(
-      const semantics::Symbol *symbol, std::vector<LabelRef> &&labelRefs)
-      : labelRefs{labelRefs}, symbol{symbol} {}
+      const semantics::Symbol *symbol, std::vector<LabelMention> &&labelRefs)
+    : labelRefs{labelRefs}, symbol{symbol} {}
 
-  std::vector<LabelRef> labelRefs;
+  std::vector<LabelMention> labelRefs;
   const semantics::Symbol *symbol;
 };
 
@@ -114,17 +114,17 @@ struct SwitchIOOp
         const parser::EndfileStmt *, const parser::RewindStmt *,
         const parser::FlushStmt *, const parser::InquireStmt *> {
   template<typename A>
-  explicit SwitchIOOp(const A &io, LabelRef next, const Location &source,
-      std::optional<LabelRef> errLab,
-      std::optional<LabelRef> eorLab = std::nullopt,
-      std::optional<LabelRef> endLab = std::nullopt)
+  explicit SwitchIOOp(const A &io, LabelMention next, const Location &source,
+      std::optional<LabelMention> errLab,
+      std::optional<LabelMention> eorLab = std::nullopt,
+      std::optional<LabelMention> endLab = std::nullopt)
     : SumTypeCopyMixin{&io}, next{next}, source{source}, errLabel{errLab},
       eorLabel{eorLab}, endLabel{endLab} {}
-  LabelRef next;
+  LabelMention next;
   Location source;
-  std::optional<LabelRef> errLabel;
-  std::optional<LabelRef> eorLabel;
-  std::optional<LabelRef> endLabel;
+  std::optional<LabelMention> errLabel;
+  std::optional<LabelMention> eorLabel;
+  std::optional<LabelMention> endLabel;
 };
 
 // multi-way branch based on conditions
@@ -134,11 +134,11 @@ struct SwitchOp
         const parser::CaseConstruct *, const parser::SelectRankConstruct *,
         const parser::SelectTypeConstruct *> {
   template<typename A>
-  explicit SwitchOp(
-      const A &sw, const std::vector<LabelRef> &refs, const Location &source)
+  explicit SwitchOp(const A &sw, const std::vector<LabelMention> &refs,
+      const Location &source)
     : SumTypeCopyMixin{&sw}, refs{refs}, source{source} {}
 
-  const std::vector<LabelRef> refs;
+  const std::vector<LabelMention> refs;
   Location source;
 };
 
@@ -198,16 +198,16 @@ struct Op : public SumTypeMixin<LabelOp, GotoOp, ReturnOp, ConditionalGotoOp,
 // helper to build unique labels
 struct LabelBuilder {
   LabelBuilder();
-  LabelRef getNext();
-  void setReferenced(LabelRef label);
-  bool isReferenced(LabelRef label) const;
+  LabelMention getNext();
+  void setReferenced(LabelMention label);
+  bool isReferenced(LabelMention label) const;
   llvm::BitVector referenced;
   unsigned counter;
 };
 
 LabelOp FetchLabel(AnalysisData &ad, const parser::Label &label);
 
-std::vector<LabelRef> GetAssign(
+std::vector<LabelMention> GetAssign(
     AnalysisData &ad, const semantics::Symbol *symbol);
 
 }  // namespace flat
@@ -215,7 +215,8 @@ std::vector<LabelRef> GetAssign(
 // Collection of data maintained internally by the flattening algorithm
 struct AnalysisData {
   std::map<parser::Label, flat::LabelOp> labelMap;
-  std::vector<std::tuple<const parser::Name *, flat::LabelRef, flat::LabelRef>>
+  std::vector<
+      std::tuple<const parser::Name *, flat::LabelMention, flat::LabelMention>>
       constructContextStack;
   flat::LabelBuilder labelBuilder;
   std::map<const semantics::Symbol *, std::set<parser::Label>> assignMap;
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
new file mode 100644
index 000000000000..ec351b710b55
--- /dev/null
+++ b/lib/burnside/intrinsics.cc
@@ -0,0 +1,505 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "intrinsics.h"
+#include "builder.h"
+#include "fe-helper.h"
+#include "fir/FIROps.h"
+#include "fir/Type.h"
+#include "llvm/ADT/Optional.h"
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+namespace Fortran::burnside {
+
+/// MathRuntimeLibrary maps Fortran generic intrinsic names to runtime function
+/// signatures. There is no guarantee that that runtime functions are available
+/// for all intrinsic functions and possible types.
+/// To be easy and fast to use, this class holds a map and uses
+/// mlir::FunctionType to represent the runtime function type. This imply that
+/// MathRuntimeLibrary cannot be constexpr built and requires an
+/// mlir::MLIRContext to be built. Its constructor uses a constexpr table
+/// description of the runtime. The runtime functions are not declared into the
+/// mlir::module until there is a query that needs them. This is to avoid
+/// polluting the FIR/LLVM IR dumps with unused functions.
+class MathRuntimeLibrary {
+public:
+  /// The map key are Fortran generic intrinsic names.
+  using Key = llvm::StringRef;
+  struct Hash {  // Need custom hash for this kind of key
+    size_t operator()(const Key &k) const { return llvm::hash_value(k); }
+  };
+  /// Runtime function description that is sufficient to build an
+  /// mlir::FuncOp and to compare function types.
+  struct RuntimeFunction {
+    RuntimeFunction(llvm::StringRef n, mlir::FunctionType t)
+      : symbol{n}, type{t} {};
+    llvm::StringRef symbol;
+    mlir::FunctionType type;
+  };
+  using Map = std::unordered_multimap<Key, RuntimeFunction, Hash>;
+
+  MathRuntimeLibrary(IntrinsicLibrary::Version, mlir::MLIRContext &);
+
+  /// Probe the intrinsic library for a certain intrinsic and get/build the
+  /// related mlir::FuncOp if a runtime description is found.
+  /// Also add a unit attribute "fir.runtime" to the function so that later
+  /// it is possible to quickly know what function are intrinsics vs users.
+  llvm::Optional<mlir::FuncOp> getFunction(
+      mlir::OpBuilder &, llvm::StringRef, mlir::FunctionType) const;
+
+private:
+  mlir::FuncOp getFuncOp(
+      mlir::OpBuilder &builder, const RuntimeFunction &runtime) const;
+  Map library;
+};
+
+/// The implementation of IntrinsicLibrary is based on a map that associates
+/// Fortran intrinsics generic names to the related FIR generator functions.
+/// All generator functions are member functions of the Implementation class
+/// and they all take the same context argument that contains the name and
+/// arguments of the Fortran intrinsics call to lower among other things.
+/// A same FIR generator function may be able to generate the FIR for several
+/// intrinsics. For instance generateRuntimeCall tries to find a runtime
+/// functions that matches the Fortran intrinsic call and generate the
+/// operations to call this functions if it was found.
+/// IntrinsicLibrary holds a constant MathRuntimeLibrary that it uses to
+/// find and place call to math runtime functions. This library is built
+/// when the Implementation is built. Because of this, Implementation is
+/// not cheap to build and it should be kept as long as possible.
+
+// TODO it is unclear how optional argument are handled
+// TODO error handling -> return a code or directly emit messages ?
+class IntrinsicLibrary::Implementation {
+public:
+  Implementation(Version v, mlir::MLIRContext &c) : runtime{v, c} {}
+  inline mlir::Value *genval(mlir::Location loc, mlir::OpBuilder &builder,
+      llvm::StringRef name, mlir::Type resultType,
+      llvm::ArrayRef<mlir::Value *> args) const;
+
+private:
+  // Info needed by Generators is passed in Context struct to keep Generator
+  // signatures modification easy.
+  struct Context {
+    mlir::Location loc;
+    mlir::OpBuilder *builder{nullptr};
+    llvm::StringRef name;
+    llvm::ArrayRef<mlir::Value *> arguments;
+    mlir::FunctionType funcType;
+    mlir::MLIRContext *getMLIRContext() {
+      return getModule(builder).getContext();
+    }
+    mlir::Type getResultType() {
+      assert(funcType.getNumResults() == 1);
+      return funcType.getResult(0);
+    }
+  };
+
+  /// Define the different FIR generators that can be mapped to intrinsic to
+  /// generate the related code.
+  using Generator = mlir::Value *(Implementation::*)(Context &) const;
+  /// Search a runtime function that is associated to the generic intrinsic name
+  /// and whose signature matches the intrinsic arguments and result types.
+  /// If no such runtime function is found but a runtime function associated
+  /// with the Fortran generic exists and has the same number of arguments,
+  /// conversions will be inserted before and/or after the call. This is to
+  /// mainly to allow 16 bits float support even-though little or no math
+  /// runtime is currently available for it.
+  mlir::Value *generateRuntimeCall(Context &) const;
+  /// All generators can be combined with generateWrapperCall that will build a
+  /// function named "fir."+ <generic name> + "." + <result type code> and
+  /// generate the intrinsic implementation inside instead of at the intrinsic
+  /// call sites. This can be used to keep the FIR more readable.
+  template<Generator g> mlir::Value *generateWrapperCall(Context &c) const {
+    return outlineInWrapper(g, c);
+  }
+  /// The defaultGenerator is always attempted if no mapping was found for the
+  /// generic name provided.
+  mlir::Value *defaultGenerator(Context &c) const {
+    return generateWrapperCall<&I::generateRuntimeCall>(c);
+  }
+  mlir::Value *conjgGenerator(Context &) const;
+
+  struct IntrinsicHanlder {
+    const char *name;
+    Generator generator{&I::defaultGenerator};
+  };
+  using I = Implementation;
+  /// Table that drives the fir generation depending on the intrinsic.
+  /// one to one mapping with Fortran arguments. If no mapping is
+  /// defined here for a generic intrinsic, the defaultGenerator will
+  /// be attempted.
+  static constexpr IntrinsicHanlder handlers[]{
+      {"conjg", &I::conjgGenerator},
+  };
+
+  // helpers
+  static std::string getWrapperName(Context &);
+  mlir::Value *outlineInWrapper(Generator, Context &) const;
+  static mlir::FunctionType getFunctionType(mlir::Type resultType,
+      llvm::ArrayRef<mlir::Value *> arguments, mlir::OpBuilder &);
+
+  MathRuntimeLibrary runtime;
+};
+
+/// Define a simple static runtime description that will be transformed into
+/// RuntimeFunction when building the IntrinsicLibrary.
+/// It is constexpr constructible so that static tables of such descriptions can
+/// be safely stored as global variables without requiring global constructors.
+class RuntimeStaticDescription {
+public:
+  /// Define possible runtime function argument/return type used in signature
+  /// descriptions. They follow mlir standard types naming. MLIR types cannot
+  /// directly be used because they can only be dynamically built.
+  enum class TypeCode { i32, i64, f32, f64, c32, c64 };
+  /// C++ does not provide variable size constexpr container yet. TypeVector
+  /// implements one for Type elements. It works because Type is an enumeration.
+  struct TypeCodeVector {
+    template<TypeCode... v> struct Storage {
+      static constexpr TypeCode values[]{v...};
+    };
+    template<TypeCode... v> static constexpr TypeCodeVector create() {
+      const TypeCode *start{&Storage<v...>::values[0]};
+      return TypeCodeVector{start, start + sizeof...(v)};
+    }
+    const TypeCode *start{nullptr};
+    const TypeCode *end{nullptr};
+  };
+  constexpr RuntimeStaticDescription(
+      const char *n, const char *s, TypeCode r, TypeCodeVector a)
+    : name{n}, symbol{s}, resultTypeCode{r}, argumentTypeCodes{a} {}
+  llvm::StringRef getSymbol() const { return symbol; }
+  llvm::StringRef getName() const { return name; }
+  /// Conversion between types of the static representation and MLIR types.
+  mlir::FunctionType getMLIRFunctionType(mlir::MLIRContext &) const;
+
+private:
+  static mlir::Type getMLIRType(TypeCode, mlir::MLIRContext &);
+
+  const char *name{nullptr};
+  const char *symbol{nullptr};
+  TypeCode resultTypeCode;
+  TypeCodeVector argumentTypeCodes;
+};
+
+/// Description of the runtime functions available on the target.
+using RType = typename RuntimeStaticDescription::TypeCode;
+using Args = typename RuntimeStaticDescription::TypeCodeVector;
+static constexpr RuntimeStaticDescription llvmRuntime[] = {
+    {"abs", "llvm.fabs.f32", RType::f32, Args::create<RType::f32>()},
+    {"abs", "llvm.fabs.f64", RType::f64, Args::create<RType::f64>()},
+    {"acos", "acosf", RType::f32, Args::create<RType::f32>()},
+    {"acos", "acos", RType::f64, Args::create<RType::f64>()},
+    {"atan", "atan2f", RType::f32, Args::create<RType::f32, RType::f32>()},
+    {"atan", "atan2", RType::f64, Args::create<RType::f64, RType::f64>()},
+    {"sqrt", "llvm.sqrt.f32", RType::f32, Args::create<RType::f32>()},
+    {"sqrt", "llvm.sqrt.f64", RType::f64, Args::create<RType::f64>()},
+    {"cos", "llvm.cos.f32", RType::f32, Args::create<RType::f32>()},
+    {"cos", "llvm.cos.f64", RType::f64, Args::create<RType::f64>()},
+    {"sin", "llvm.sin.f32", RType::f32, Args::create<RType::f32>()},
+    {"sin", "llvm.sin.f64", RType::f64, Args::create<RType::f64>()},
+};
+
+static constexpr RuntimeStaticDescription pgmathPreciseRuntime[] = {
+    {"acos", "__pc_acos_1", RType::c32, Args::create<RType::c32>()},
+    {"acos", "__pz_acos_1", RType::c64, Args::create<RType::c64>()},
+    {"pow", "__pc_pow_1", RType::c32, Args::create<RType::c32, RType::c32>()},
+    {"pow", "__pc_powi_1", RType::c32, Args::create<RType::c32, RType::i32>()},
+    {"pow", "__pc_powk_1", RType::c32, Args::create<RType::c32, RType::i64>()},
+    {"pow", "__pd_pow_1", RType::f64, Args::create<RType::f64, RType::f64>()},
+    {"pow", "__pd_powi_1", RType::f64, Args::create<RType::f64, RType::i32>()},
+    {"pow", "__pd_powk_1", RType::f64, Args::create<RType::f64, RType::i64>()},
+    {"pow", "__ps_pow_1", RType::f32, Args::create<RType::f32, RType::f32>()},
+    {"pow", "__ps_powi_1", RType::f32, Args::create<RType::f32, RType::i32>()},
+    {"pow", "__ps_powk_1", RType::f32, Args::create<RType::f32, RType::i64>()},
+    {"pow", "__pz_pow_1", RType::c64, Args::create<RType::c64, RType::c64>()},
+    {"pow", "__pz_powi_1", RType::c64, Args::create<RType::c64, RType::i32>()},
+    {"pow", "__pz_powk_1", RType::c64, Args::create<RType::c64, RType::i64>()},
+    {"pow", "__mth_i_ipowi", RType::i32,
+        Args::create<RType::i32, RType::i32>()},
+    {"pow", "__mth_i_kpowi", RType::i64,
+        Args::create<RType::i64, RType::i32>()},
+    {"pow", "__mth_i_kpowk", RType::i64,
+        Args::create<RType::i64, RType::i64>()},
+};
+
+// TODO : Tables above should be generated in a clever ways and probably shared
+// with lib/evaluate intrinsic folding.
+
+// Implementations
+
+// IntrinsicLibrary implementation
+
+IntrinsicLibrary IntrinsicLibrary::create(
+    IntrinsicLibrary::Version v, mlir::MLIRContext &context) {
+  IntrinsicLibrary lib{};
+  lib.impl = new Implementation(v, context);
+  return lib;
+}
+
+IntrinsicLibrary::~IntrinsicLibrary() { delete impl; }
+
+mlir::Value *IntrinsicLibrary::genval(mlir::Location loc,
+    mlir::OpBuilder &builder, llvm::StringRef name, mlir::Type resultType,
+    llvm::ArrayRef<mlir::Value *> args) const {
+  assert(impl);
+  return impl->genval(loc, builder, name, resultType, args);
+}
+
+// MathRuntimeLibrary implementation
+
+// Create the runtime description for the targeted library version.
+// So far ignore the version an only load the dummy llvm lib and pgmath precise
+MathRuntimeLibrary::MathRuntimeLibrary(
+    IntrinsicLibrary::Version, mlir::MLIRContext &context) {
+  for (const RuntimeStaticDescription &func : llvmRuntime) {
+    RuntimeFunction impl{func.getSymbol(), func.getMLIRFunctionType(context)};
+    library.insert({Key{func.getName()}, impl});
+  }
+  for (const RuntimeStaticDescription &func : pgmathPreciseRuntime) {
+    RuntimeFunction impl{func.getSymbol(), func.getMLIRFunctionType(context)};
+    library.insert({Key{func.getName()}, impl});
+  }
+}
+
+mlir::FuncOp MathRuntimeLibrary::getFuncOp(
+    mlir::OpBuilder &builder, const RuntimeFunction &runtime) const {
+  auto module{getModule(&builder)};
+  mlir::FuncOp function{getNamedFunction(module, runtime.symbol)};
+  if (!function) {
+    function = createFunction(module, runtime.symbol, runtime.type);
+    function.setAttr("fir.runtime", builder.getUnitAttr());
+  }
+  return function;
+}
+
+llvm::Optional<mlir::FuncOp> MathRuntimeLibrary::getFunction(
+    mlir::OpBuilder &builder, llvm::StringRef name,
+    mlir::FunctionType funcType) const {
+  auto range{library.equal_range(name)};
+  const RuntimeFunction *bestNearMatch{nullptr};
+  for (auto iter{range.first}; iter != range.second; ++iter) {
+    const RuntimeFunction &impl{iter->second};
+    if (funcType == impl.type) {
+      return getFuncOp(builder, impl);  // exact match
+    } else {
+      if (!bestNearMatch &&
+          impl.type.getNumResults() == funcType.getNumResults() &&
+          impl.type.getNumInputs() == funcType.getNumInputs()) {
+        bestNearMatch = &impl;
+      } else {
+        // TODO the best near match should not be the first hit.
+        // It should apply rules:
+        //  -> Non narrowing argument conversion are better
+        //  -> The "nearest" conversions are better
+      }
+    }
+  }
+  if (bestNearMatch != nullptr) {
+    return getFuncOp(builder, *bestNearMatch);
+  } else {
+    return {};
+  }
+}
+
+// IntrinsicLibrary::Implementation implementation
+
+mlir::Value *IntrinsicLibrary::Implementation::genval(mlir::Location loc,
+    mlir::OpBuilder &builder, llvm::StringRef name, mlir::Type resultType,
+    llvm::ArrayRef<mlir::Value *> args) const {
+  Context context{
+      loc, &builder, name, args, getFunctionType(resultType, args, builder)};
+  for (const IntrinsicHanlder &handler : handlers) {
+    if (name == handler.name) {
+      assert(handler.generator != nullptr);
+      return (this->*handler.generator)(context);
+    }
+  }
+  // Try the default generator if no special handler was defined for the
+  // intrinsic being called.
+  return this->defaultGenerator(context);
+}
+
+mlir::FunctionType IntrinsicLibrary::Implementation::getFunctionType(
+    mlir::Type resultType, llvm::ArrayRef<mlir::Value *> arguments,
+    mlir::OpBuilder &builder) {
+  llvm::SmallVector<mlir::Type, 2> argumentTypes;
+  for (const auto &arg : arguments) {
+    assert(arg != nullptr);  // TODO think about optionals
+    argumentTypes.push_back(arg->getType());
+  }
+  return mlir::FunctionType::get(
+      argumentTypes, resultType, getModule(&builder).getContext());
+}
+
+std::string IntrinsicLibrary::Implementation::getWrapperName(Context &c) {
+  // TODO find nicer type to string infra
+  llvm::StringRef prefix{"fir."};
+  assert(c.funcType.getNumResults() == 1);
+  mlir::Type resultType{c.funcType.getResult(0)};
+  if (auto f{resultType.dyn_cast<mlir::FloatType>()}) {
+    return prefix.str() + c.name.str() + ".f" + std::to_string(f.getWidth());
+  } else if (auto i{resultType.dyn_cast<mlir::IntegerType>()}) {
+    return prefix.str() + c.name.str() + ".i" + std::to_string(i.getWidth());
+  } else if (auto cplx{resultType.dyn_cast<fir::CplxType>()}) {
+    // TODO using kind here is weird, but I do not want to hard coded mapping
+    return prefix.str() + c.name.str() + ".c" + std::to_string(cplx.getFKind());
+  } else {
+    assert(false);
+    return "fir." + c.name.str() + ".unknown";
+  }
+}
+
+mlir::Value *IntrinsicLibrary::Implementation::outlineInWrapper(
+    Generator generator, Context &context) const {
+  mlir::ModuleOp module{getModule(context.builder)};
+  mlir::MLIRContext *mlirContext{module.getContext()};
+  std::string wrapperName{getWrapperName(context)};
+  mlir::FuncOp function{getNamedFunction(module, wrapperName)};
+  if (!function) {
+    // First time this wrapper is needed, build it.
+    function = createFunction(module, wrapperName, context.funcType);
+    function.setAttr("fir.intrinsic", context.builder->getUnitAttr());
+    function.addEntryBlock();
+
+    // Create local context to emit code into the newly created function
+    // This new function is not linked to a source file location, only
+    // its calls will be.
+    Context localContext{context};
+    auto localBuilder{std::make_unique<mlir::OpBuilder>(function)};
+    localBuilder->setInsertionPointToStart(&function.front());
+    localContext.builder = &(*localBuilder);
+    llvm::SmallVector<mlir::Value *, 2> localArguments;
+    for (mlir::BlockArgument *bArg : function.front().getArguments()) {
+      localArguments.push_back(bArg);
+    }
+    localContext.arguments = localArguments;
+    localContext.loc = mlir::UnknownLoc::get(mlirContext);
+
+    mlir::Value *result{(this->*generator)(localContext)};
+    localBuilder->create<mlir::ReturnOp>(localContext.loc, result);
+  } else {
+    // Wrapper was already built, ensure it has the sought type
+    assert(function.getType() == context.funcType);
+  }
+  auto call{context.builder->create<mlir::CallOp>(
+      context.loc, function, context.arguments)};
+  return call.getResult(0);
+}
+
+mlir::Value *IntrinsicLibrary::Implementation::generateRuntimeCall(
+    Context &context) const {
+  // Look up runtime
+  mlir::FunctionType soughtFuncType{context.funcType};
+  if (auto funcOp{runtime.getFunction(
+          *context.builder, context.name, soughtFuncType)}) {
+    mlir::FunctionType actualFuncType{funcOp->getType()};
+    if (actualFuncType.getNumResults() != soughtFuncType.getNumResults() ||
+        actualFuncType.getNumInputs() != soughtFuncType.getNumInputs() ||
+        actualFuncType.getNumInputs() != context.arguments.size() ||
+        actualFuncType.getNumResults() != 1) {
+      assert(false);  // TODO better error handling
+      return nullptr;
+    }
+    llvm::SmallVector<mlir::Value *, 2> convertedArguments;
+    int i{0};
+    for (mlir::Value *arg : context.arguments) {
+      mlir::Type actualType{actualFuncType.getInput(i)};
+      if (soughtFuncType.getInput(i) != actualType) {
+        auto castedArg{context.builder->create<fir::ConvertOp>(
+            context.loc, actualType, arg)};
+        convertedArguments.push_back(castedArg.getResult());
+      } else {
+        convertedArguments.push_back(arg);
+      }
+      ++i;
+    }
+    auto call{context.builder->create<mlir::CallOp>(
+        context.loc, *funcOp, convertedArguments)};
+    mlir::Type soughtType{soughtFuncType.getResult(0)};
+    mlir::Value *res{call.getResult(0)};
+    if (actualFuncType.getResult(0) != soughtType) {
+      auto castedRes{context.builder->create<fir::ConvertOp>(
+          context.loc, soughtType, res)};
+      return castedRes.getResult();
+    } else {
+      return res;
+    }
+  } else {
+    // could not find runtime function
+    assert(false);  // TODO: better error handling.
+    return nullptr;
+  }
+}
+
+// CONJG
+mlir::Value *IntrinsicLibrary::Implementation::conjgGenerator(
+    Context &genCtxt) const {
+  assert(genCtxt.arguments.size() == 1);
+  mlir::Type resType{genCtxt.getResultType()};
+  assert(resType == genCtxt.arguments[0]->getType());
+
+  // FIXME make fir.complex<f32>.. instead of fir.complex<4> to avoid
+  // constantly having to translate to fe types ? Or get actual mapping
+  auto complexType{resType.cast<fir::CplxType>()};
+  mlir::Type realType{
+      burnside::convertReal(genCtxt.getMLIRContext(), complexType.getFKind())};
+  auto ity{mlir::IndexType::get(genCtxt.getMLIRContext())};
+  auto oneAttr{genCtxt.builder->getIntegerAttr(ity, 1)};
+  auto *imagIdx{
+      genCtxt.builder->create<mlir::ConstantOp>(genCtxt.loc, ity, oneAttr)
+          .getResult()};
+  auto parts{genCtxt.builder->create<fir::ExtractValueOp>(
+      genCtxt.loc, realType, genCtxt.arguments[0], imagIdx)};
+  // TODO a negation unary would be better than a sub to zero ?
+  auto zeroAttr{genCtxt.builder->getFloatAttr(realType, llvm::APFloat{0.})};
+  auto zero{genCtxt.builder->create<mlir::ConstantOp>(
+      genCtxt.loc, realType, zeroAttr)};
+  auto negImag{genCtxt.builder->create<mlir::SubFOp>(genCtxt.loc, zero, parts)};
+  return genCtxt.builder->create<fir::InsertValueOp>(
+      genCtxt.loc, resType, genCtxt.arguments[0], negImag, imagIdx);
+}
+
+// RuntimeStaticDescription implementation
+
+mlir::Type RuntimeStaticDescription::getMLIRType(
+    TypeCode t, mlir::MLIRContext &context) {
+  switch (t) {
+  case TypeCode::i32: return mlir::IntegerType::get(32, &context);
+  case TypeCode::i64: return mlir::IntegerType::get(64, &context);
+  case TypeCode::f32: return mlir::FloatType::getF32(&context);
+  case TypeCode::f64: return mlir::FloatType::getF64(&context);
+  // TODO need to access mapping between fe/target
+  case TypeCode::c32: return fir::CplxType::get(&context, 4);
+  case TypeCode::c64: return fir::CplxType::get(&context, 8);
+  }
+  assert(false && "bug");
+  return {};
+}
+
+mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
+    mlir::MLIRContext &context) const {
+  llvm::SmallVector<mlir::Type, 2> argMLIRTypes;
+  for (const TypeCode *t{argumentTypeCodes.start};
+       t != nullptr && t != argumentTypeCodes.end; ++t) {
+    argMLIRTypes.push_back(getMLIRType(*t, context));
+  }
+  mlir::Type resMLIRType{getMLIRType(resultTypeCode, context)};
+  return mlir::FunctionType::get(argMLIRTypes, resMLIRType, &context);
+}
+
+}
diff --git a/lib/burnside/intrinsics.h b/lib/burnside/intrinsics.h
new file mode 100644
index 000000000000..d2534b71d1e3
--- /dev/null
+++ b/lib/burnside/intrinsics.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_INTRINSICS_H_
+#define FORTRAN_BURNSIDE_INTRINSICS_H_
+
+#include "llvm/ADT/StringRef.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include <optional>
+
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+namespace Fortran::burnside {
+
+/// IntrinsicLibrary generates FIR+MLIR operations that implement Fortran
+/// generic intrinsic function calls. It operates purely on FIR+MLIR types so
+/// that it can be used at different lowering level if needed.
+/// IntrinsicLibrary is not in charge of generating code for the argument
+/// expressions/symbols. These must be generated before and the resulting
+/// mlir::Values* are inputs for the IntrinsicLibrary operation generation.
+///
+/// The operations generated can be as simple as a single runtime library call
+/// or they may fully implement the intrinsic without runtime help. This
+/// depends on the IntrinsicLibrary::Implementation.
+///
+/// IntrinsicLibrary should not be assumed cheap to build since they may need
+/// to build a representation of the target runtime before they can be used.
+/// Once built, they are stateless and cannot be modified.
+///
+
+class IntrinsicLibrary {
+public:
+  /// Available runtime library versions.
+  enum class Version { PgmathFast, PgmathRelaxed, PgmathPrecise, LLVM };
+
+  ~IntrinsicLibrary();
+  /// Generate the FIR+MLIR operations for the generic intrinsic "name".
+  /// On failure, returns a nullptr, else the returned mlir::Value* is
+  /// the returned Fortran intrinsic value.
+  mlir::Value *genval(mlir::Location loc, mlir::OpBuilder &builder,
+      llvm::StringRef name, mlir::Type resultType,
+      llvm::ArrayRef<mlir::Value *> args) const;
+
+  // TODO: Expose interface to get specific intrinsic function address.
+  // TODO: Handle intrinsic subroutine.
+  // TODO: Intrinsics that do not require their arguments to be defined
+  //   (e.g shape inquiries) might not fit in the current interface that
+  //   requires mlir::Value* to be provided.
+  // TODO: Error handling interface ?
+  // TODO: Implementation is incomplete. Many intrinsics to tbd.
+
+  /// Create an IntrinsicLibrary targeting the desired runtime library version.
+  static IntrinsicLibrary create(Version, mlir::MLIRContext &);
+
+private:
+  /// Actual implementation is hidden.
+  class Implementation;
+  Implementation *impl{nullptr};  // owning pointer
+};
+
+}
+
+#endif  // FORTRAN_BURNSIDE_INTRINSICS_H_
diff --git a/lib/burnside/runtime.cc b/lib/burnside/runtime.cc
new file mode 100644
index 000000000000..dc14ce642918
--- /dev/null
+++ b/lib/burnside/runtime.cc
@@ -0,0 +1,106 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "runtime.h"
+#include "fir/Type.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/IR/Types.h"
+#include <cassert>
+
+namespace Br = Fortran::burnside;
+
+using namespace Fortran;
+using namespace Fortran::burnside;
+
+namespace {
+
+using FuncPointer = llvm::SmallVector<mlir::Type, 4> (*)(
+    mlir::MLIRContext *, int kind);
+
+// FIXME: these are wrong and just serving as temporary placeholders
+using Cplx = mlir::IntegerType;
+using Intopt = mlir::IntegerType;
+using TypeDesc = mlir::IntegerType;
+
+template<typename A, typename... B>
+void consType(
+    llvm::SmallVector<mlir::Type, 4> &types, mlir::MLIRContext *ctx, int kind) {
+  if constexpr (std::is_same_v<A, mlir::IntegerType>) {
+    types.emplace_back(A::get(kind, ctx));
+  } else if constexpr (std::is_same_v<A, mlir::ComplexType>) {
+    // FIXME: this is wrong
+    assert(false);
+    types.emplace_back(mlir::IntegerType::get(kind, ctx));
+  } else {
+    types.emplace_back(A::get(ctx, kind));
+  }
+  if constexpr (sizeof...(B) > 0) {
+    consType<B...>(types, ctx, kind);
+  }
+}
+
+template<typename... A>
+llvm::SmallVector<mlir::Type, 4> consType(mlir::MLIRContext *ctx, int kind) {
+  llvm::SmallVector<mlir::Type, 4> types;
+  if constexpr (sizeof...(A) > 0) {
+    consType<A...>(types, ctx, kind);
+  } else {
+    (void)ctx;
+    (void)kind;
+  }
+  return types;
+}
+
+#define DEFINE_RUNTIME_ENTRY(A, B, C, D) "Fortran_" B,
+char const *const RuntimeEntryNames[FIRT_LAST_ENTRY_CODE] = {
+#include "runtime.def"
+};
+
+#define UNPACK_TYPES(...) __VA_ARGS__
+#define DEFINE_RUNTIME_ENTRY(A, B, C, D) consType<UNPACK_TYPES C>,
+FuncPointer RuntimeEntryInputType[FIRT_LAST_ENTRY_CODE] = {
+#include "runtime.def"
+};
+
+#define DEFINE_RUNTIME_ENTRY(A, B, C, D) consType<UNPACK_TYPES D>,
+FuncPointer RuntimeEntryResultType[FIRT_LAST_ENTRY_CODE] = {
+#include "runtime.def"
+};
+#undef UNPACK_TYPES
+
+}  // namespace
+
+llvm::StringRef Br::getRuntimeEntryName(RuntimeEntryCode code) {
+  assert(code < FIRT_LAST_ENTRY_CODE);
+  return {RuntimeEntryNames[code]};
+}
+
+mlir::FunctionType Br::getRuntimeEntryType(
+    RuntimeEntryCode code, mlir::MLIRContext &mlirContext, int kind) {
+  assert(code < FIRT_LAST_ENTRY_CODE);
+  return mlir::FunctionType::get(
+      RuntimeEntryInputType[code](&mlirContext, kind),
+      RuntimeEntryResultType[code](&mlirContext, kind), &mlirContext);
+}
+
+mlir::FunctionType Br::getRuntimeEntryType(RuntimeEntryCode code,
+    mlir::MLIRContext &mlirContext, int inpKind, int resKind) {
+  assert(code < FIRT_LAST_ENTRY_CODE);
+  return mlir::FunctionType::get(
+      RuntimeEntryInputType[code](&mlirContext, inpKind),
+      RuntimeEntryResultType[code](&mlirContext, resKind), &mlirContext);
+}
diff --git a/lib/burnside/runtime.def b/lib/burnside/runtime.def
new file mode 100644
index 000000000000..9121321fc80a
--- /dev/null
+++ b/lib/burnside/runtime.def
@@ -0,0 +1,42 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Define the various runtime entry points. At this point, these are entirely
+// bogons as we don't have a runtime library nor even a definition for one.
+
+// Fortran execution control primitive ops
+DEFINE_RUNTIME_ENTRY(STOP, "stop", (Intopt, Intopt), ())
+DEFINE_RUNTIME_ENTRY(ERROR_STOP, "error_stop", (Intopt, Intopt), ())
+DEFINE_RUNTIME_ENTRY(FAIL_IMAGE, "fail_image", (), ())
+
+// INTEGER ops
+DEFINE_RUNTIME_ENTRY(MAX, "int_max", (mlir::IntegerType, mlir::IntegerType), (mlir::IntegerType))
+DEFINE_RUNTIME_ENTRY(MIN, "int_min", (mlir::IntegerType, mlir::IntegerType), (mlir::IntegerType))
+DEFINE_RUNTIME_ENTRY(POW, "int_pow", (mlir::IntegerType, mlir::IntegerType), (mlir::IntegerType))
+
+// COMPLEX ops
+DEFINE_RUNTIME_ENTRY(CDIV, "complex_div", (Cplx, Cplx), (Cplx))
+
+// CHARACTER ops
+DEFINE_RUNTIME_ENTRY(CONCAT, "char_concat", (fir::CharacterType, fir::CharacterType), (fir::CharacterType))
+
+// TYPE descriptor queries
+DEFINE_RUNTIME_ENTRY(ISA_TYPE, "isa_type", (TypeDesc), (mlir::IntegerType))
+DEFINE_RUNTIME_ENTRY(ISA_SUBTYPE, "isa_subtype", (TypeDesc), (mlir::IntegerType))
+
+// ARRAY descriptor queries
+DEFINE_RUNTIME_ENTRY(GET_RANK, "get_rank", (TypeDesc), (mlir::IntegerType))
+DEFINE_RUNTIME_ENTRY(GET_ELETYPE, "get_element_type", (TypeDesc), (mlir::IntegerType))
+
+#undef DEFINE_RUNTIME_ENTRY
diff --git a/lib/burnside/runtime.h b/lib/burnside/runtime.h
new file mode 100644
index 000000000000..48096775bc25
--- /dev/null
+++ b/lib/burnside/runtime.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_RUNTIME_H_
+#define FORTRAN_BURNSIDE_RUNTIME_H_
+
+#include <string>
+
+namespace llvm {
+class StringRef;
+}
+namespace mlir {
+class FunctionType;
+class MLIRContext;
+}
+
+namespace Fortran::burnside {
+
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+#define DEFINE_RUNTIME_ENTRY(A, B, C, D) FIRT_##A,
+enum RuntimeEntryCode {
+#include "runtime.def"
+  FIRT_LAST_ENTRY_CODE
+};
+
+llvm::StringRef getRuntimeEntryName(RuntimeEntryCode code);
+
+mlir::FunctionType getRuntimeEntryType(
+    RuntimeEntryCode code, mlir::MLIRContext &mlirContext, int kind);
+
+mlir::FunctionType getRuntimeEntryType(RuntimeEntryCode code,
+    mlir::MLIRContext &mlirContext, int inpKind, int resKind);
+
+}  // Fortran::burnside
+
+#endif  // FORTRAN_BURNSIDE_RUNTIME_H_
diff --git a/lib/fir/Attribute.cpp b/lib/fir/Attribute.cpp
new file mode 100644
index 000000000000..7c7bdd05f46c
--- /dev/null
+++ b/lib/fir/Attribute.cpp
@@ -0,0 +1,181 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/Attribute.h"
+#include "fir/Dialect.h"
+#include "fir/Type.h"
+#include "mlir/IR/AttributeSupport.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/Types.h"
+#include "mlir/Parser.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+
+namespace L = llvm;
+namespace M = mlir;
+
+using namespace fir;
+
+namespace {
+
+// Our very stripped down parser for Attributes.
+// TODO: clean this up
+class AttributeParser {
+public:
+  AttributeParser(L::StringRef rawText)
+      : srcBuff{rawText}, srcPtr{rawText.begin()} {}
+
+  M::Attribute parseAttribute(FIROpsDialect *dialect, M::Location loc) {
+    skipWhitespace();
+    L::StringRef keyword{lexKeyword()};
+    skipWhitespace();
+    auto data{srcBuff.drop_front(srcPtr - srcBuff.begin())};
+    if (keyword == ExactTypeAttr::getAttrName()) {
+      data = consumeAngles(loc, data);
+      M::Type type{M::parseType(data, dialect->getContext())};
+      return ExactTypeAttr::get(type);
+    }
+    if (keyword == SubclassAttr::getAttrName()) {
+      data = consumeAngles(loc, data);
+      M::Type type{M::parseType(data, dialect->getContext())};
+      return SubclassAttr::get(type);
+    }
+    if (keyword == PointIntervalAttr::getAttrName()) {
+      return PointIntervalAttr::get(dialect->getContext());
+    }
+    if (keyword == LowerBoundAttr::getAttrName()) {
+      return LowerBoundAttr::get(dialect->getContext());
+    }
+    if (keyword == UpperBoundAttr::getAttrName()) {
+      return UpperBoundAttr::get(dialect->getContext());
+    }
+    if (keyword == ClosedIntervalAttr::getAttrName()) {
+      return ClosedIntervalAttr::get(dialect->getContext());
+    }
+    L::Twine msg{"unknown FIR attribute: "};
+    M::emitError(loc, msg.concat(srcBuff));
+    return {};
+  }
+
+private:
+  bool atEnd() const { return srcPtr == srcBuff.end(); }
+
+  L::StringRef lexKeyword() {
+    const char *tokStart = srcPtr;
+    while (!atEnd() && (std::isalnum(*srcPtr) || *srcPtr == '_')) {
+      ++srcPtr;
+    }
+    return {tokStart, static_cast<std::size_t>(srcPtr - tokStart)};
+  }
+
+  void skipWhitespace() {
+    while (!atEnd()) {
+      switch (*srcPtr) {
+      case ' ':
+      case '\f':
+      case '\n':
+      case '\r':
+      case '\t':
+      case '\v':
+        ++srcPtr;
+        continue;
+      default:
+        break;
+      }
+      break;
+    }
+  }
+
+  L::StringRef consumeAngles(M::Location loc, L::StringRef data) {
+    data = data.ltrim().rtrim();
+    if (data.size() <= 2) {
+      M::emitError(loc, "expecting '<' type '>' in attribute");
+      return {};
+    }
+    if (data.front() != '<') {
+      M::emitError(loc, "expecting '<' in attribute");
+      return {};
+    }
+    data = data.drop_front(1);
+    if (data.back() != '>') {
+      M::emitError(loc, "expecting '>' in attribute");
+      return {};
+    }
+    data = data.drop_back(1);
+    return data;
+  }
+
+  L::StringRef srcBuff;
+  const char *srcPtr;
+};
+
+} // namespace
+
+namespace fir {
+namespace detail {
+
+/// An attribute representing a reference to a type.
+struct TypeAttributeStorage : public M::AttributeStorage {
+  using KeyTy = M::Type;
+
+  TypeAttributeStorage(M::Type value) : value(value) {}
+
+  /// Key equality function.
+  bool operator==(const KeyTy &key) const { return key == value; }
+
+  /// Construct a new storage instance.
+  static TypeAttributeStorage *
+  construct(M::AttributeStorageAllocator &allocator, KeyTy key) {
+    return new (allocator.allocate<TypeAttributeStorage>())
+        TypeAttributeStorage(key);
+  }
+
+  M::Type value;
+};
+} // namespace detail
+
+ExactTypeAttr ExactTypeAttr::get(M::Type value) {
+  return Base::get(value.getContext(), FIR_EXACTTYPE, value);
+}
+
+M::Type ExactTypeAttr::getType() const { return getImpl()->value; }
+
+SubclassAttr SubclassAttr::get(M::Type value) {
+  return Base::get(value.getContext(), FIR_SUBCLASS, value);
+}
+
+M::Type SubclassAttr::getType() const { return getImpl()->value; }
+
+using AttributeUniquer = mlir::detail::AttributeUniquer;
+
+ClosedIntervalAttr ClosedIntervalAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<ClosedIntervalAttr>(ctxt, getId());
+}
+UpperBoundAttr UpperBoundAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<UpperBoundAttr>(ctxt, getId());
+}
+LowerBoundAttr LowerBoundAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<LowerBoundAttr>(ctxt, getId());
+}
+PointIntervalAttr PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
+  return AttributeUniquer::get<PointIntervalAttr>(ctxt, getId());
+}
+
+M::Attribute parseFirAttribute(FIROpsDialect *dialect, L::StringRef rawText,
+                               M::Type type, M::Location loc) {
+  AttributeParser parser{rawText};
+  return parser.parseAttribute(dialect, loc);
+}
+
+} // namespace fir
diff --git a/lib/fir/CMakeLists.txt b/lib/fir/CMakeLists.txt
new file mode 100644
index 000000000000..f10d851171b8
--- /dev/null
+++ b/lib/fir/CMakeLists.txt
@@ -0,0 +1,47 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_subdirectory(Transforms)
+
+add_llvm_library(FIR
+  Attribute.cpp
+  Dialect.cpp
+  FIROps.cpp
+  IteratedDominanceFrontier.cpp
+  KindMapping.cpp
+  StdConverter.cpp
+  Tilikum.cpp
+  Type.cpp
+)
+
+add_dependencies(FIR FIROpsIncGen)
+
+target_link_libraries(FIR
+  MLIRTargetLLVMIR
+  MLIRTargetLLVMIRModuleTranslation
+  MLIREDSC
+  MLIRExecutionEngine
+  MLIRParser
+  MLIRSupport
+  MLIRStandardToLLVM
+  MLIRTransforms
+  LLVMAsmParser
+  LLVMAsmPrinter
+  LLVMRemarks
+)
+
+install (TARGETS FIR
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+)
diff --git a/lib/fir/Dialect.cpp b/lib/fir/Dialect.cpp
new file mode 100644
index 000000000000..432686041ced
--- /dev/null
+++ b/lib/fir/Dialect.cpp
@@ -0,0 +1,99 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/Dialect.h"
+#include "fir/Attribute.h"
+#include "fir/FIROps.h"
+#include "fir/Type.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/Transforms/SideEffectsInterface.h"
+
+namespace M = mlir;
+
+using namespace fir;
+
+namespace {
+
+template <typename A>
+void selectBuild(M::OpBuilder *builder, M::OperationState *result,
+                 M::Value *condition,
+                 llvm::ArrayRef<typename A::BranchTuple> tuples) {
+  result->addOperands(condition);
+  for (auto &tup : tuples) {
+    auto *cond{std::get<typename A::Conditions>(tup)};
+    result->addOperands(cond);
+  }
+  // Note: succs must be added *after* operands
+  for (auto &tup : tuples) {
+    auto *block{std::get<M::Block *>(tup)};
+    assert(block);
+    auto blkArgs{std::get<llvm::ArrayRef<M::Value *>>(tup)};
+    result->addSuccessor(block, blkArgs);
+  }
+}
+} // namespace
+
+fir::FIROpsDialect::FIROpsDialect(M::MLIRContext *ctx)
+    : M::Dialect("fir", ctx) {
+  addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
+           FieldType, HeapType, IntType, LogicalType, PointerType, RealType,
+           RecordType, ReferenceType, SequenceType, TypeDescType>();
+  addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
+                PointIntervalAttr, SubclassAttr, UpperBoundAttr>();
+  addOperations<GlobalOp, DispatchTableOp,
+#define GET_OP_LIST
+#include "fir/FIROps.cpp.inc"
+                >();
+}
+
+// anchor the class vtable to this compilation unit
+fir::FIROpsDialect::~FIROpsDialect() {
+  // do nothing
+}
+
+M::Type fir::FIROpsDialect::parseType(llvm::StringRef rawData,
+                                      M::Location loc) const {
+  return parseFirType(const_cast<FIROpsDialect *>(this), rawData, loc);
+}
+
+void fir::FIROpsDialect::printType(M::Type ty, llvm::raw_ostream &os) const {
+  return printFirType(const_cast<FIROpsDialect *>(this), ty, os);
+}
+
+M::Attribute fir::FIROpsDialect::parseAttribute(llvm::StringRef rawText,
+                                                M::Type type,
+                                                M::Location loc) const {
+  return parseFirAttribute(const_cast<FIROpsDialect *>(this), rawText, type,
+                           loc);
+}
+
+void fir::FIROpsDialect::printAttribute(M::Attribute attr,
+                                        llvm::raw_ostream &os) const {
+  if (auto exact = attr.dyn_cast<fir::ExactTypeAttr>()) {
+    os << fir::ExactTypeAttr::getAttrName() << '<' << exact.getType() << '>';
+  } else if (auto sub = attr.dyn_cast<fir::SubclassAttr>()) {
+    os << fir::SubclassAttr::getAttrName() << '<' << sub.getType() << '>';
+  } else if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
+    os << fir::PointIntervalAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+    os << fir::ClosedIntervalAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
+    os << fir::LowerBoundAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
+    os << fir::UpperBoundAttr::getAttrName();
+  } else {
+    assert(false && "attribute pretty-printer is not implemented");
+  }
+}
diff --git a/lib/fir/FIROps.cpp b/lib/fir/FIROps.cpp
new file mode 100644
index 000000000000..25a99b0656c0
--- /dev/null
+++ b/lib/fir/FIROps.cpp
@@ -0,0 +1,430 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/FIROps.h"
+#include "fir/Attribute.h"
+#include "fir/Type.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/IR/SymbolTable.h"
+
+namespace L = llvm;
+namespace M = mlir;
+
+namespace fir {
+
+// AllocaOp
+
+M::Type AllocaOp::getAllocatedType() {
+  // return getAttrOfType<M::TypeAttr>("in_type").getType();
+  return getType().cast<ReferenceType>().getEleTy();
+}
+
+M::Type AllocaOp::getRefTy(M::Type ty) { return ReferenceType::get(ty); }
+
+// AllocMemOp
+
+M::Type AllocMemOp::getAllocatedType() {
+  // return getAttrOfType<M::TypeAttr>("in_type").getType();
+  return getType().cast<HeapType>().getEleTy();
+}
+
+M::Type AllocMemOp::getRefTy(M::Type ty) { return HeapType::get(ty); }
+
+// CallOp
+
+void printCallOp(M::OpAsmPrinter &p, fir::CallOp &op) {
+  auto callee = op.callee();
+  bool isDirect = callee.hasValue();
+  p << op.getOperationName() << ' ';
+  if (isDirect)
+    p.printSymbolName(callee.getValue());
+  else
+    p << *op.getOperand(0);
+  p << '(';
+  p.printOperands(L::drop_begin(op.getOperands(), isDirect ? 0 : 1));
+  p << ')';
+  p.printOptionalAttrDict(op.getAttrs(), {"callee"});
+  L::SmallVector<Type, 1> resultTypes(op.getResultTypes());
+  L::SmallVector<Type, 8> argTypes(
+      L::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
+  p << " : " << FunctionType::get(argTypes, resultTypes, op.getContext());
+}
+
+M::ParseResult parseCallOp(M::OpAsmParser &parser, M::OperationState &result) {
+  L::SmallVector<M::OpAsmParser::OperandType, 8> operands;
+
+  if (parser.parseOperandList(operands))
+    return M::failure();
+  bool isDirect = operands.empty();
+  SmallVector<NamedAttribute, 4> attrs;
+  SymbolRefAttr funcAttr;
+
+  if (isDirect)
+    if (parser.parseAttribute(funcAttr, "callee", attrs))
+      return M::failure();
+  Type type;
+
+  if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
+      parser.parseOptionalAttributeDict(attrs) || parser.parseColon() ||
+      parser.parseType(type))
+    return M::failure();
+
+  auto funcType = type.dyn_cast<M::FunctionType>();
+  if (!funcType)
+    return parser.emitError(parser.getNameLoc(), "expected function type");
+  if (isDirect) {
+    if (parser.resolveOperands(operands, funcType.getInputs(),
+                               parser.getNameLoc(), result.operands))
+      return M::failure();
+  } else {
+    auto funcArgs =
+        L::ArrayRef<M::OpAsmParser::OperandType>(operands).drop_front();
+    L::SmallVector<M::Value *, 8> resultArgs(
+        result.operands.begin() + (result.operands.empty() ? 0 : 1),
+        result.operands.end());
+    if (parser.resolveOperand(operands[0], funcType, result.operands) ||
+        parser.resolveOperands(funcArgs, funcType.getInputs(),
+                               parser.getNameLoc(), resultArgs))
+      return M::failure();
+  }
+  result.addTypes(funcType.getResults());
+  result.attributes = attrs;
+  return M::success();
+}
+
+// DispatchOp
+
+M::FunctionType DispatchOp::getFunctionType() {
+  auto attr = getAttr("fn_type").cast<M::TypeAttr>();
+  return attr.getValue().cast<M::FunctionType>();
+}
+
+// DispatchTableOp
+
+void DispatchTableOp::build(M::Builder *builder, M::OperationState *result,
+                            L::StringRef name, M::Type type,
+                            L::ArrayRef<M::NamedAttribute> attrs) {
+  result->addAttribute("method", builder->getStringAttr(name));
+  for (const auto &pair : attrs) {
+    result->addAttribute(pair.first, pair.second);
+  }
+}
+
+M::ParseResult DispatchTableOp::parse(M::OpAsmParser &parser,
+                                      M::OperationState &result) {
+  // Parse the name as a symbol reference attribute.
+  SymbolRefAttr nameAttr;
+  if (parser.parseAttribute(nameAttr, "method", result.attributes))
+    return failure();
+
+  // Convert the parsed name attr into a string attr.
+  result.attributes.back().second =
+      parser.getBuilder().getStringAttr(nameAttr.getValue());
+
+  // Parse the optional table body.
+  M::Region *body = result.addRegion();
+  if (parser.parseOptionalRegion(*body,
+                                 L::ArrayRef<M::OpAsmParser::OperandType>{},
+                                 L::ArrayRef<M::Type>{}))
+    return M::failure();
+
+  ensureTerminator(*body, parser.getBuilder(), result.location);
+  return M::success();
+}
+
+void DispatchTableOp::print(M::OpAsmPrinter &p) {
+  auto tableName = getAttrOfType<StringAttr>("method").getValue();
+  p << getOperationName() << " @" << tableName;
+
+  Region &body = getOperation()->getRegion(0);
+  if (!body.empty())
+    p.printRegion(body, /*printEntryBlockArgs=*/false,
+                  /*printBlockTerminators=*/false);
+}
+
+M::LogicalResult DispatchTableOp::verify() { return M::success(); }
+
+M::Region &DispatchTableOp::front() {
+  return this->getOperation()->getRegion(0);
+}
+
+void DispatchTableOp::appendTableEntry(M::Operation *op) {
+  assert(M::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
+  front().front().push_back(op);
+}
+
+// GlobalOp
+
+void GlobalOp::build(M::Builder *builder, M::OperationState *result,
+                     L::StringRef name, M::Type type,
+                     L::ArrayRef<M::NamedAttribute> attrs) {
+  result->addAttribute(getTypeAttrName(), M::TypeAttr::get(type));
+  result->addAttribute(M::SymbolTable::getSymbolAttrName(),
+                       builder->getStringAttr(name));
+  for (const auto &pair : attrs) {
+    result->addAttribute(pair.first, pair.second);
+  }
+}
+
+M::ParseResult GlobalOp::parse(M::OpAsmParser &parser,
+                               M::OperationState &result) {
+  // Parse the name as a symbol reference attribute.
+  SymbolRefAttr nameAttr;
+  if (parser.parseAttribute(nameAttr, M::SymbolTable::getSymbolAttrName(),
+                            result.attributes))
+    return failure();
+
+  auto &builder = parser.getBuilder();
+  result.attributes.back().second = builder.getStringAttr(nameAttr.getValue());
+
+  if (parser.parseOptionalKeyword("constant")) {
+    result.addAttribute("constant", builder.getBoolAttr(false));
+  } else {
+    // if "constant" keyword then mark this as a constant, not a variable
+    result.addAttribute("constant", builder.getBoolAttr(true));
+  }
+
+  M::Type globalType;
+  if (parser.parseColonType(globalType)) {
+    return M::failure();
+  }
+  result.addAttribute(getTypeAttrName(), M::TypeAttr::get(globalType));
+
+  // Parse the optional initializer body.
+  M::Region *body = result.addRegion();
+  if (parser.parseOptionalRegion(*body,
+                                 L::ArrayRef<M::OpAsmParser::OperandType>{},
+                                 L::ArrayRef<M::Type>{}))
+    return M::failure();
+
+  ensureTerminator(*body, builder, result.location);
+  return M::success();
+}
+
+void GlobalOp::print(M::OpAsmPrinter &p) {
+  auto varName =
+      getAttrOfType<StringAttr>(M::SymbolTable::getSymbolAttrName()).getValue();
+  p << getOperationName() << " @" << varName;
+  if (getAttr("constant").cast<M::BoolAttr>().getValue())
+    p << " constant";
+  p << " : ";
+  p.printType(getType());
+  Region &body = getOperation()->getRegion(0);
+  if (!body.empty())
+    p.printRegion(body, /*printEntryBlockArgs=*/false,
+                  /*printBlockTerminators=*/false);
+}
+
+M::LogicalResult GlobalOp::verify() { return M::success(); }
+
+void GlobalOp::appendInitialValue(M::Operation *op) {
+  front().front().push_back(op);
+}
+
+M::Region &GlobalOp::front() { return this->getOperation()->getRegion(0); }
+
+// LoadOp
+
+/// Get the element type of a reference like type; otherwise null
+M::Type elementTypeOf(M::Type ref) {
+  if (auto r = ref.dyn_cast_or_null<ReferenceType>())
+    return r.getEleTy();
+  if (auto r = ref.dyn_cast_or_null<PointerType>())
+    return r.getEleTy();
+  if (auto r = ref.dyn_cast_or_null<HeapType>())
+    return r.getEleTy();
+  return {};
+}
+
+M::ParseResult LoadOp::getElementOf(M::Type &ele, M::Type ref) {
+  if (M::Type r = elementTypeOf(ref)) {
+    ele = r;
+    return M::success();
+  }
+  return M::failure();
+}
+
+// LoopOp
+
+void LoopOp::build(M::Builder *builder, M::OperationState &result, M::Value *lb,
+                   M::Value *ub, L::ArrayRef<M::Value *> step) {
+  if (step.empty())
+    result.addOperands({lb, ub});
+  else
+    result.addOperands({lb, ub, step[0]});
+  M::Region *bodyRegion = result.addRegion();
+  LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
+  bodyRegion->front().addArgument(builder->getIndexType());
+}
+
+M::ParseResult parseLoopOp(M::OpAsmParser &parser, M::OperationState &result) {
+  auto &builder = parser.getBuilder();
+  M::OpAsmParser::OperandType inductionVariable, lb, ub, step;
+  // Parse the induction variable followed by '='.
+  if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
+    return M::failure();
+
+  // Parse loop bounds.
+  M::Type indexType = builder.getIndexType();
+  if (parser.parseOperand(lb) ||
+      parser.resolveOperand(lb, indexType, result.operands) ||
+      parser.parseKeyword("to") || parser.parseOperand(ub) ||
+      parser.resolveOperand(ub, indexType, result.operands))
+    return M::failure();
+  if (parser.parseOptionalKeyword(LoopOp::getStepKeyword())) {
+    result.addAttribute(LoopOp::getStepKeyword(),
+                        builder.getIntegerAttr(builder.getIndexType(), 1));
+  } else if (parser.parseOperand(step) ||
+             parser.resolveOperand(step, indexType, result.operands)) {
+    return M::failure();
+  }
+
+  if (parser.parseOptionalKeyword("unordered")) {
+    // ok
+  } else {
+    result.addAttribute("unordered", builder.getBoolAttr(true));
+  }
+
+  // Parse the body region.
+  M::Region *body = result.addRegion();
+  if (parser.parseRegion(*body, inductionVariable, indexType))
+    return M::failure();
+
+  fir::LoopOp::ensureTerminator(*body, builder, result.location);
+
+  // Parse the optional attribute list.
+  if (parser.parseOptionalAttributeDict(result.attributes)) {
+    return M::failure();
+  }
+  return M::success();
+}
+
+fir::LoopOp getForInductionVarOwner(M::Value *val) {
+  auto *ivArg = dyn_cast<M::BlockArgument>(val);
+  if (!ivArg) {
+    return fir::LoopOp();
+  }
+  assert(ivArg->getOwner() && "unlinked block argument");
+  auto *containingInst = ivArg->getOwner()->getParentOp();
+  return dyn_cast_or_null<fir::LoopOp>(containingInst);
+}
+
+// StoreOp
+
+M::Type StoreOp::elementType(M::Type refType) {
+  if (auto ref = refType.dyn_cast<ReferenceType>())
+    return ref.getEleTy();
+  if (auto ref = refType.dyn_cast<PointerType>())
+    return ref.getEleTy();
+  if (auto ref = refType.dyn_cast<HeapType>())
+    return ref.getEleTy();
+  return {};
+}
+
+// WhereOp
+
+void WhereOp::build(M::Builder *builder, M::OperationState &result,
+                    M::Value *cond, bool withElseRegion) {
+  result.addOperands(cond);
+  M::Region *thenRegion = result.addRegion();
+  M::Region *elseRegion = result.addRegion();
+  WhereOp::ensureTerminator(*thenRegion, *builder, result.location);
+  if (withElseRegion)
+    WhereOp::ensureTerminator(*elseRegion, *builder, result.location);
+}
+
+M::ParseResult parseWhereOp(M::OpAsmParser &parser, M::OperationState &result) {
+  // Create the regions for 'then'.
+  result.regions.reserve(2);
+  M::Region *thenRegion = result.addRegion();
+  M::Region *elseRegion = result.addRegion();
+
+  auto &builder = parser.getBuilder();
+  M::OpAsmParser::OperandType cond;
+  M::Type i1Type = builder.getIntegerType(1);
+  if (parser.parseOperand(cond) ||
+      parser.resolveOperand(cond, i1Type, result.operands))
+    return M::failure();
+
+  if (parser.parseRegion(*thenRegion, {}, {})) {
+    return M::failure();
+  }
+  WhereOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
+
+  if (!parser.parseOptionalKeyword("otherwise")) {
+    if (parser.parseRegion(*elseRegion, {}, {})) {
+      return M::failure();
+    }
+    WhereOp::ensureTerminator(*elseRegion, parser.getBuilder(),
+                              result.location);
+  }
+
+  // Parse the optional attribute list.
+  if (parser.parseOptionalAttributeDict(result.attributes)) {
+    return M::failure();
+  }
+
+  return M::success();
+}
+
+M::ParseResult isValidCaseAttr(M::Attribute attr) {
+  if (attr.dyn_cast_or_null<M::UnitAttr>() ||
+      attr.dyn_cast_or_null<ClosedIntervalAttr>() ||
+      attr.dyn_cast_or_null<PointIntervalAttr>() ||
+      attr.dyn_cast_or_null<LowerBoundAttr>() ||
+      attr.dyn_cast_or_null<UpperBoundAttr>())
+    return M::success();
+  return M::failure();
+}
+
+unsigned getCaseArgumentOffset(L::ArrayRef<M::Attribute> cases, unsigned dest) {
+  unsigned o = 0;
+  for (unsigned i = 0; i < dest; ++i) {
+    auto &attr = cases[i];
+    if (!attr.dyn_cast_or_null<M::UnitAttr>()) {
+      ++o;
+      if (attr.dyn_cast_or_null<ClosedIntervalAttr>()) {
+        ++o;
+      }
+    }
+  }
+  return o;
+}
+
+M::ParseResult parseSelector(M::OpAsmParser &parser, M::OperationState &result,
+                             M::OpAsmParser::OperandType &selector,
+                             M::Type &type) {
+  if (parser.parseOperand(selector) || parser.parseColonType(type) ||
+      parser.resolveOperand(selector, type, result.operands) ||
+      parser.parseLSquare())
+    return M::failure();
+  return M::success();
+}
+
+void printComplexBinaryOp(Operation *op, OpAsmPrinter &p) {
+  assert(op->getNumOperands() == 2 && "binary op should have two operands");
+  assert(op->getNumResults() == 1 && "binary op should have one result");
+
+  p << op->getName() << ' ' << *op->getOperand(0) << ", " << *op->getOperand(1);
+  p.printOptionalAttrDict(op->getAttrs());
+  p << " : " << op->getResult(0)->getType();
+}
+
+// Tablegen operators
+
+#define GET_OP_CLASSES
+#include "fir/FIROps.cpp.inc"
+
+} // namespace fir
diff --git a/lib/fir/IteratedDominanceFrontier.cpp b/lib/fir/IteratedDominanceFrontier.cpp
new file mode 100644
index 000000000000..d35ce321bc7a
--- /dev/null
+++ b/lib/fir/IteratedDominanceFrontier.cpp
@@ -0,0 +1,107 @@
+//===- IteratedDominanceFrontier.cpp - Compute IDF ------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Compute iterated dominance frontiers using a linear time algorithm.
+//
+//===----------------------------------------------------------------------===//
+
+#include "fir/Analysis/IteratedDominanceFrontier.h"
+#include "mlir/Analysis/Dominance.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/Dominators.h"
+#include <queue>
+#include <utility>
+
+namespace fir {
+
+template <class NodeTy, bool IsPostDom>
+void IDFCalculator<NodeTy, IsPostDom>::calculate(
+    llvm::SmallVectorImpl<NodeTy *> &PHIBlocks) {
+  // Use a priority queue keyed on dominator tree level so that inserted nodes
+  // are handled from the bottom of the dominator tree upwards. We also augment
+  // the level with a DFS number to ensure that the blocks are ordered in a
+  // deterministic way.
+  using UnsignedPair = std::pair<unsigned, unsigned>;
+  using DomTreeNode = llvm::DomTreeNodeBase<NodeTy>;
+  using DomTreeNodePair = std::pair<DomTreeNode *, UnsignedPair>;
+  using IDFPriorityQueue =
+      std::priority_queue<DomTreeNodePair,
+                          llvm::SmallVector<DomTreeNodePair, 32>,
+                          llvm::less_second>;
+  IDFPriorityQueue PQ;
+
+  if (DefBlocks->empty())
+    return;
+
+  DT.updateDFSNumbers();
+
+  for (NodeTy *BB : *DefBlocks) {
+    if (DomTreeNode *Node = DT.getNode(BB))
+      PQ.push({Node, std::make_pair(Node->getLevel(), Node->getDFSNumIn())});
+  }
+
+  llvm::SmallVector<DomTreeNode *, 32> Worklist;
+  llvm::SmallPtrSet<DomTreeNode *, 32> VisitedPQ;
+  llvm::SmallPtrSet<DomTreeNode *, 32> VisitedWorklist;
+
+  while (!PQ.empty()) {
+    DomTreeNodePair RootPair = PQ.top();
+    PQ.pop();
+    DomTreeNode *Root = RootPair.first;
+    unsigned RootLevel = RootPair.second.first;
+
+    // Walk all dominator tree children of Root, inspecting their CFG edges with
+    // targets elsewhere on the dominator tree. Only targets whose level is at
+    // most Root's level are added to the iterated dominance frontier of the
+    // definition set.
+
+    Worklist.clear();
+    Worklist.push_back(Root);
+    VisitedWorklist.insert(Root);
+
+    while (!Worklist.empty()) {
+      DomTreeNode *Node = Worklist.pop_back_val();
+      NodeTy *BB = Node->getBlock();
+      // Succ is the successor in the direction we are calculating IDF, so it is
+      // successor for IDF, and predecessor for Reverse IDF.
+      auto DoWork = [&](NodeTy *Succ) {
+        DomTreeNode *SuccNode = DT.getNode(Succ);
+
+        const unsigned SuccLevel = SuccNode->getLevel();
+        if (SuccLevel > RootLevel)
+          return;
+
+        if (!VisitedPQ.insert(SuccNode).second)
+          return;
+
+        NodeTy *SuccBB = SuccNode->getBlock();
+        if (useLiveIn && !LiveInBlocks->count(SuccBB))
+          return;
+
+        PHIBlocks.emplace_back(SuccBB);
+        if (!DefBlocks->count(SuccBB))
+          PQ.push(std::make_pair(
+              SuccNode, std::make_pair(SuccLevel, SuccNode->getDFSNumIn())));
+      };
+
+      for (auto *Succ : BB->getSuccessors())
+        DoWork(Succ);
+
+      for (auto DomChild : *Node) {
+        if (VisitedWorklist.insert(DomChild).second)
+          Worklist.push_back(DomChild);
+      }
+    }
+  }
+}
+
+template class IDFCalculator<mlir::Block, false>;
+
+} // namespace fir
diff --git a/lib/fir/KindMapping.cpp b/lib/fir/KindMapping.cpp
new file mode 100644
index 000000000000..f762e75cc0e7
--- /dev/null
+++ b/lib/fir/KindMapping.cpp
@@ -0,0 +1,221 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/KindMapping.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/CommandLine.h"
+
+/// Allow the user to set the FIR intrinsic type kind value to LLVM type
+/// mappings.  Note that these are not mappings from kind values to any
+/// other MLIR dialect, only to LLVM IR. The default values follow the f18
+/// front-end kind mappings.
+
+namespace M = mlir;
+
+using namespace fir;
+using namespace llvm;
+
+using Bitsize = KindMapping::Bitsize;
+using KindTy = KindMapping::KindTy;
+using LLVMTypeID = KindMapping::LLVMTypeID;
+using MatchResult = KindMapping::MatchResult;
+
+static cl::opt<std::string>
+    ClKindMapping("kind-mapping",
+                  cl::desc("kind mapping string to set kind precision"),
+                  cl::value_desc("kind-mapping-string"), cl::init(""));
+
+namespace {
+
+/// Integral types default to the kind value being the size of the value in
+/// bytes. The default is to scale from bytes to bits.
+Bitsize defaultScalingKind(KindTy kind) {
+  const unsigned BITS_IN_BYTE = 8;
+  return kind * BITS_IN_BYTE;
+}
+
+/// Floating-point types default to the kind value being the size of the value
+/// in bytes. The default is to translate kinds of 2, 4, 8, 10, and 16 to a
+/// valid llvm::Type::TypeID value. Otherwise, the default is FloatTyID.
+LLVMTypeID defaultRealKind(KindTy kind) {
+  switch (kind) {
+  case 2:
+    return LLVMTypeID::HalfTyID;
+  case 4:
+    return LLVMTypeID::FloatTyID;
+  case 8:
+    return LLVMTypeID::DoubleTyID;
+  case 10:
+    return LLVMTypeID::X86_FP80TyID;
+  case 16:
+    return LLVMTypeID::FP128TyID;
+  default:
+    return LLVMTypeID::FloatTyID;
+  }
+}
+
+template <typename RT, char KEY>
+RT doLookup(std::function<RT(KindTy)> def,
+            std::map<char, std::map<KindTy, RT>> const &map, KindTy kind) {
+  auto iter = map.find(KEY);
+  if (iter != map.end()) {
+    auto iter2 = iter->second.find(kind);
+    if (iter2 != iter->second.end())
+      return iter2->second;
+  }
+  return def(kind);
+}
+
+template <char KEY, typename MAP>
+Bitsize getIntegerLikeBitsize(KindTy kind, MAP const &map) {
+  return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
+}
+
+template <char KEY, typename MAP>
+LLVMTypeID getFloatLikeTypeID(KindTy kind, MAP const &map) {
+  return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
+}
+
+MatchResult parseCode(char &code, char const *&ptr) {
+  if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
+    return {};
+  code = *ptr++;
+  return {true};
+}
+
+template <char ch>
+MatchResult parseSingleChar(char const *&ptr) {
+  if (*ptr != ch)
+    return {};
+  ++ptr;
+  return {true};
+}
+
+MatchResult parseColon(char const *&ptr) { return parseSingleChar<':'>(ptr); }
+
+MatchResult parseComma(char const *&ptr) { return parseSingleChar<','>(ptr); }
+
+MatchResult parseInt(unsigned &result, char const *&ptr) {
+  char const *beg = ptr;
+  while (*ptr >= '0' && *ptr <= '9')
+    ptr++;
+  if (beg == ptr)
+    return {};
+  StringRef ref(beg, ptr - beg);
+  int temp;
+  if (ref.consumeInteger(10, temp))
+    return {};
+  result = temp;
+  return {true};
+}
+
+bool matchString(char const *&ptr, StringRef literal) {
+  StringRef s(ptr);
+  if (s.startswith(literal)) {
+    ptr += literal.size();
+    return true;
+  }
+  return false;
+}
+
+MatchResult parseTypeID(LLVMTypeID &result, char const *&ptr) {
+  if (matchString(ptr, "Half")) {
+    result = LLVMTypeID::HalfTyID;
+    return {true};
+  }
+  if (matchString(ptr, "Float")) {
+    result = LLVMTypeID::FloatTyID;
+    return {true};
+  }
+  if (matchString(ptr, "Double")) {
+    result = LLVMTypeID::DoubleTyID;
+    return {true};
+  }
+  if (matchString(ptr, "X86_FP80")) {
+    result = LLVMTypeID::X86_FP80TyID;
+    return {true};
+  }
+  if (matchString(ptr, "FP128")) {
+    result = LLVMTypeID::FP128TyID;
+    return {true};
+  }
+  return {};
+}
+
+} // namespace
+
+fir::KindMapping::KindMapping(mlir::MLIRContext *context, StringRef map)
+    : context{context} {
+  parse(map);
+}
+
+fir::KindMapping::KindMapping(mlir::MLIRContext *context)
+    : KindMapping{context, ClKindMapping} {}
+
+MatchResult fir::KindMapping::badMapString(Twine const &ptr) {
+  auto unknown = mlir::UnknownLoc::get(context);
+  mlir::emitError(unknown, ptr);
+  return {};
+}
+
+MatchResult fir::KindMapping::parse(StringRef kindMap) {
+  if (kindMap.empty())
+    return {true};
+  char const *srcPtr = kindMap.begin();
+  while (true) {
+    char code;
+    KindTy kind;
+    if (parseCode(code, srcPtr) || parseInt(kind, srcPtr))
+      return badMapString(srcPtr);
+    if (code == 'a' || code == 'i' || code == 'l') {
+      Bitsize bits;
+      if (parseColon(srcPtr) || parseInt(bits, srcPtr))
+        return badMapString(srcPtr);
+      intMap[code][kind] = bits;
+    } else if (code == 'r' || code == 'c') {
+      LLVMTypeID id;
+      if (parseColon(srcPtr) || parseTypeID(id, srcPtr))
+        return badMapString(srcPtr);
+      floatMap[code][kind] = id;
+    } else {
+      return badMapString(srcPtr);
+    }
+    if (parseComma(srcPtr))
+      break;
+  }
+  if (*srcPtr)
+    return badMapString(srcPtr);
+  return {true};
+}
+
+Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) {
+  return getIntegerLikeBitsize<'a'>(kind, intMap);
+}
+
+Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) {
+  return getIntegerLikeBitsize<'i'>(kind, intMap);
+}
+
+Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) {
+  return getIntegerLikeBitsize<'l'>(kind, intMap);
+}
+
+LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) {
+  return getFloatLikeTypeID<'r'>(kind, floatMap);
+}
+
+LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) {
+  return getFloatLikeTypeID<'c'>(kind, floatMap);
+}
diff --git a/lib/fir/StdConverter.cpp b/lib/fir/StdConverter.cpp
new file mode 100644
index 000000000000..9736b8b94fc0
--- /dev/null
+++ b/lib/fir/StdConverter.cpp
@@ -0,0 +1,180 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/Transforms/StdConverter.h"
+#include "fir/Dialect.h"
+#include "fir/FIROps.h"
+#include "fir/Type.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
+#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Target/LLVMIR.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "mlir/Transforms/LowerAffine.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Config/abi-breaking.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/raw_ostream.h"
+
+// This module performs the conversion of FIR operations to MLIR standard and/or
+// LLVM-IR dialects.
+
+namespace L = llvm;
+namespace M = mlir;
+
+using namespace fir;
+
+namespace {
+
+using SmallVecResult = L::SmallVector<M::Value *, 4>;
+using OperandTy = L::ArrayRef<M::Value *>;
+using AttributeTy = L::ArrayRef<M::NamedAttribute>;
+
+/// FIR to standard type converter
+/// This converts a subset of FIR types to standard types
+class FIRToStdTypeConverter : public M::TypeConverter {
+public:
+  using TypeConverter::TypeConverter;
+
+  // convert a front-end kind value to either a std dialect type
+  static M::Type kindToRealType(M::MLIRContext *ctx, KindTy kind) {
+    switch (kind) {
+    case 2:
+      return M::FloatType::getF16(ctx);
+    case 3:
+      return M::FloatType::getBF16(ctx);
+    case 4:
+      return M::FloatType::getF32(ctx);
+    case 8:
+      return M::FloatType::getF64(ctx);
+    }
+    return fir::RealType::get(ctx, kind);
+  }
+
+  /// Convert FIR types to MLIR standard dialect types
+  M::Type convertType(M::Type t) override {
+    if (auto cplx = t.dyn_cast<CplxType>()) {
+      return M::ComplexType::get(
+          kindToRealType(cplx.getContext(), cplx.getFKind()));
+    }
+    if (auto integer = t.dyn_cast<IntType>()) {
+      return M::IntegerType::get(integer.getFKind() * 8, integer.getContext());
+    }
+    if (auto real = t.dyn_cast<RealType>()) {
+      return kindToRealType(real.getContext(), real.getFKind());
+    }
+    return t;
+  }
+};
+
+// Lower a SELECT operation into a cascade of conditional branches. The last
+// case must be the `true` condition.
+inline void rewriteSelectConstruct(M::Operation *op, OperandTy operands,
+                                   L::ArrayRef<M::Block *> dests,
+                                   L::ArrayRef<OperandTy> destOperands,
+                                   M::OpBuilder &rewriter) {
+  L::SmallVector<M::Value *, 1> noargs;
+  L::SmallVector<M::Block *, 8> blocks;
+  auto loc{op->getLoc()};
+  blocks.push_back(rewriter.getInsertionBlock());
+  for (std::size_t i = 1; i < dests.size(); ++i)
+    blocks.push_back(rewriter.createBlock(dests[0]));
+  rewriter.setInsertionPointToEnd(blocks[0]);
+  if (dests.size() == 1) {
+    rewriter.create<M::BranchOp>(loc, dests[0], destOperands[0]);
+    return;
+  }
+  rewriter.create<M::CondBranchOp>(loc, operands[1], dests[0], destOperands[0],
+                                   blocks[1], noargs);
+  for (std::size_t i = 1; i < dests.size() - 1; ++i) {
+    rewriter.setInsertionPointToEnd(blocks[i]);
+    rewriter.create<M::CondBranchOp>(loc, operands[i + 1], dests[i],
+                                     destOperands[i], blocks[i + 1], noargs);
+  }
+  std::size_t last{dests.size() - 1};
+  rewriter.setInsertionPointToEnd(blocks[last]);
+  rewriter.create<M::BranchOp>(loc, dests[last], destOperands[last]);
+}
+
+/// Convert FIR dialect to standard dialect
+class FIRToStdLoweringPass : public M::ModulePass<FIRToStdLoweringPass> {
+  M::OpBuilder *builder;
+
+  void lowerSelect(M::Operation *op) {
+    if (M::dyn_cast<SelectCaseOp>(op) || M::dyn_cast<SelectRankOp>(op) ||
+        M::dyn_cast<SelectTypeOp>(op)) {
+      // build the lists of operands and successors
+      L::SmallVector<M::Value *, 4> operands{op->operand_begin(),
+                                             op->operand_end()};
+      L::SmallVector<M::Block *, 2> destinations;
+      destinations.reserve(op->getNumSuccessors());
+      L::SmallVector<OperandTy, 2> destOperands;
+      unsigned firstSuccOpd = op->getSuccessorOperandIndex(0);
+      for (unsigned i = 0, seen = 0, e = op->getNumSuccessors(); i < e; ++i) {
+        destinations.push_back(op->getSuccessor(i));
+        unsigned n = op->getNumSuccessorOperands(i);
+        destOperands.push_back(
+            L::makeArrayRef(operands.data() + firstSuccOpd + seen, n));
+        seen += n;
+      }
+      // do the rewrite
+      rewriteSelectConstruct(
+          op, L::makeArrayRef(operands.data(), operands.data() + firstSuccOpd),
+          destinations, destOperands, *builder);
+    }
+  }
+
+public:
+  void runOnModule() override {
+    return;
+
+    for (auto fn : getModule().getOps<M::FuncOp>()) {
+      M::OpBuilder rewriter{&fn.getBody()};
+      builder = &rewriter;
+      fn.walk([&](M::Operation *op) { lowerSelect(op); });
+    }
+    auto &context{getContext()};
+    FIRToStdTypeConverter typeConverter;
+    M::OwningRewritePatternList patterns;
+    // patterns.insert<>(&context, typeConverter);
+    M::populateAffineToStdConversionPatterns(patterns, &context);
+    M::populateFuncOpTypeConversionPattern(patterns, &context, typeConverter);
+    M::ConversionTarget target{context};
+    target.addLegalDialect<M::StandardOpsDialect, fir::FIROpsDialect>();
+    target.addDynamicallyLegalOp<M::FuncOp>([&](M::FuncOp op) {
+      return typeConverter.isSignatureLegal(op.getType());
+    });
+    target.addDynamicallyLegalOp<M::ModuleOp>(
+        [&](M::ModuleOp op) { return true; });
+    if (M::failed(M::applyPartialConversion(
+            getModule(), target, std::move(patterns), &typeConverter))) {
+      M::emitError(M::UnknownLoc::get(&context),
+                   "error in converting to standard dialect\n");
+      signalPassFailure();
+    }
+  }
+};
+
+} // namespace
+
+std::unique_ptr<M::Pass> fir::createFIRToStdPass() {
+  return std::make_unique<FIRToStdLoweringPass>();
+}
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
new file mode 100644
index 000000000000..1ba031a454a4
--- /dev/null
+++ b/lib/fir/Tilikum.cpp
@@ -0,0 +1,1478 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/Tilikum/Tilikum.h"
+#include "fir/Dialect.h"
+#include "fir/FIROps.h"
+#include "fir/KindMapping.h"
+#include "fir/Type.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
+#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Target/LLVMIR.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Config/abi-breaking.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/raw_ostream.h"
+
+/// The bridge that performs the conversion of FIR and standard dialect
+/// operations to the LLVM-IR dialect.
+
+#undef TODO
+#define TODO(X)                                                                \
+  (void)X;                                                                     \
+  assert(false && "not yet implemented")
+
+namespace L = llvm;
+namespace M = mlir;
+
+using namespace fir;
+
+namespace {
+
+using SmallVecResult = L::SmallVector<M::Value *, 4>;
+using OperandTy = L::ArrayRef<M::Value *>;
+using AttributeTy = L::ArrayRef<M::NamedAttribute>;
+
+/// FIR type converter
+/// This converts FIR types to LLVM types (for now)
+class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
+  KindMapping kindMapping;
+  static L::StringMap<M::LLVM::LLVMType> identStructCache;
+
+public:
+  FIRToLLVMTypeConverter(M::MLIRContext *context)
+      : LLVMTypeConverter(context), kindMapping(context) {}
+
+  // fir.dims<r>  -->  llvm<"[r x [3 x i64]]">
+  // FIXME
+  M::LLVM::LLVMType dimsType() {
+    auto i64Ty{M::LLVM::LLVMType::getInt64Ty(llvmDialect)};
+    return M::LLVM::LLVMType::getArrayTy(i64Ty, 3);
+  }
+
+  // i32 is used here because LLVM wants i32 constants when indexing into struct
+  // types. Indexing into other aggregate types is more flexible. TODO: See if
+  // we can't use i64 anyway; the restiction may not longer hold.
+  M::LLVM::LLVMType indexType() {
+    return M::LLVM::LLVMType::getInt32Ty(llvmDialect);
+  }
+
+  // This corresponds to the descriptor as defined ISO_Fortran_binding.h and the
+  // addendum defined in descriptor.h.
+  // FIXME: This code should be generated and follow SPOT
+  M::LLVM::LLVMType convertBoxType(BoxType box) {
+    // (buffer*, ele-size, rank, type-descriptor, attribute, [dims])
+    L::SmallVector<M::LLVM::LLVMType, 6> parts;
+    M::Type ele = box.getEleTy();
+    // auto *ctx = box.getContext();
+    auto eleTy = unwrap(convertType(ele));
+    // buffer*
+    parts.push_back(eleTy.getPointerTo());
+    // ele-size
+    parts.push_back(M::LLVM::LLVMType::getInt64Ty(llvmDialect));
+    // version
+    parts.push_back(M::LLVM::LLVMType::getInt32Ty(llvmDialect));
+    // rank
+    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    // type (code)
+    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    // attribute
+    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    // addendum
+    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    // opt-dims: [0..15 x [int,int,int]]  (see fir.dims)
+    // opt-type-ptr: i8* (see fir.tdesc)
+    // opt-flags: i64
+    // opt-len-params: [? x i64]
+    return M::LLVM::LLVMType::getStructTy(llvmDialect, parts).getPointerTo();
+  }
+
+  // fir.boxchar<n>  -->  llvm<"{ ix*, i64 }">   where ix is kind mapping
+  M::LLVM::LLVMType convertBoxCharType(BoxCharType boxchar) {
+    auto ptrTy = convertCharType(boxchar.getEleTy()).getPointerTo();
+    auto i64Ty = M::LLVM::LLVMType::getInt64Ty(llvmDialect);
+    L::SmallVector<M::LLVM::LLVMType, 2> tuple = {ptrTy, i64Ty};
+    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+  }
+
+  // fir.boxproc<any>  -->  llvm<"{ any*, i8* }">
+  M::LLVM::LLVMType convertBoxProcType(BoxProcType boxproc) {
+    auto funcTy = convertType(boxproc.getEleTy());
+    auto ptrTy = unwrap(funcTy).getPointerTo();
+    auto i8Ty = M::LLVM::LLVMType::getInt8Ty(llvmDialect);
+    L::SmallVector<M::LLVM::LLVMType, 2> tuple{ptrTy, i8Ty};
+    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+  }
+
+  // fir.char<n>  -->  llvm<"ix*">   where ix is scaled by kind mapping
+  M::LLVM::LLVMType convertCharType(CharacterType charTy) {
+    return M::LLVM::LLVMType::getIntNTy(
+        llvmDialect, kindMapping.getCharacterBitsize(charTy.getFKind()));
+  }
+
+  // fir.complex<n>  -->  llvm<"{ anyfloat, anyfloat }">
+  M::LLVM::LLVMType convertComplexType(KindTy kind) {
+    auto realID = kindMapping.getComplexTypeID(kind);
+    auto realTy = fromRealTypeID(realID, kind);
+    L::SmallVector<M::LLVM::LLVMType, 2> tuple{realTy, realTy};
+    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+  }
+
+  LLVM::LLVMType getDefaultInt() {
+    // FIXME: this should be tied to the front-end default
+    return M::LLVM::LLVMType::getInt64Ty(llvmDialect);
+  }
+
+  // fir.int<n>  -->  llvm.ix   where ix is a kind mapping
+  M::LLVM::LLVMType convertIntegerType(IntType intTy) {
+    return M::LLVM::LLVMType::getIntNTy(
+        llvmDialect, kindMapping.getIntegerBitsize(intTy.getFKind()));
+  }
+
+  // fir.logical<n>  -->  llvm.ix  where ix is a kind mapping
+  M::LLVM::LLVMType convertLogicalType(LogicalType boolTy) {
+    return M::LLVM::LLVMType::getIntNTy(
+        llvmDialect, kindMapping.getLogicalBitsize(boolTy.getFKind()));
+  }
+
+  template <typename A>
+  M::LLVM::LLVMType convertPointerLike(A &ty) {
+    return unwrap(convertType(ty.getEleTy())).getPointerTo();
+  }
+
+  // convert a front-end kind value to either a std or LLVM IR dialect type
+  // fir.real<n>  -->  llvm.anyfloat  where anyfloat is a kind mapping
+  M::LLVM::LLVMType convertRealType(KindTy kind) {
+    return fromRealTypeID(kindMapping.getRealTypeID(kind), kind);
+  }
+
+  // The cache is needed to keep a unique mapping from name -> StructType
+  M::LLVM::LLVMType convertRecordType(RecordType derived) {
+    auto name{derived.getName()};
+    auto iter{identStructCache.find(name)};
+    if (iter != identStructCache.end())
+      return iter->second;
+    auto st{M::LLVM::LLVMType::createStructTy(llvmDialect, name)};
+    identStructCache[name] = st;
+    L::SmallVector<M::LLVM::LLVMType, 8> members;
+    for (auto mem : derived.getTypeList())
+      members.push_back(convertType(mem.second).cast<M::LLVM::LLVMType>());
+    M::LLVM::LLVMType::setStructTyBody(st, members);
+    return st;
+  }
+
+  // fir.array<c ... :any>  -->  llvm<"[...[c x any]]">
+  M::LLVM::LLVMType convertSequenceType(SequenceType seq) {
+    auto baseTy = unwrap(convertType(seq.getEleTy()));
+    if (auto shape = seq.getShape()) {
+      for (auto e : shape.getValue())
+        if (e.hasValue())
+          baseTy = M::LLVM::LLVMType::getArrayTy(baseTy, e.getValue());
+        else
+          return baseTy.getPointerTo();
+      return baseTy;
+    }
+    return baseTy.getPointerTo();
+  }
+
+  // fir.tdesc<any>  -->  llvm<"i8*">
+  // FIXME: for now use a void*, however pointer identity is not sufficient for
+  // the f18 object v. class distinction
+  M::LLVM::LLVMType convertTypeDescType(M::MLIRContext *ctx) {
+    return M::LLVM::LLVMType::getInt8PtrTy(llvmDialect);
+  }
+
+  /// Convert FIR types to LLVM IR dialect types
+  M::Type convertType(M::Type t) override {
+    if (auto box = t.dyn_cast<BoxType>())
+      return convertBoxType(box);
+    if (auto boxchar = t.dyn_cast<BoxCharType>())
+      return convertBoxCharType(boxchar);
+    if (auto boxproc = t.dyn_cast<BoxProcType>())
+      return convertBoxProcType(boxproc);
+    if (auto charTy = t.dyn_cast<CharacterType>())
+      return convertCharType(charTy);
+    if (auto cplx = t.dyn_cast<CplxType>())
+      return convertComplexType(cplx.getFKind());
+    if (auto derived = t.dyn_cast<RecordType>())
+      return convertRecordType(derived);
+    if (auto dims = t.dyn_cast<DimsType>())
+      return M::LLVM::LLVMType::getArrayTy(dimsType(), dims.getRank());
+    if (auto field = t.dyn_cast<FieldType>())
+      return M::LLVM::LLVMType::getInt64Ty(llvmDialect);
+    if (auto heap = t.dyn_cast<HeapType>())
+      return convertPointerLike(heap);
+    if (auto integer = t.dyn_cast<IntType>())
+      return convertIntegerType(integer);
+    if (auto logical = t.dyn_cast<LogicalType>())
+      return convertLogicalType(logical);
+    if (auto pointer = t.dyn_cast<PointerType>())
+      return convertPointerLike(pointer);
+    if (auto real = t.dyn_cast<RealType>())
+      return convertRealType(real.getFKind());
+    if (auto ref = t.dyn_cast<ReferenceType>())
+      return convertPointerLike(ref);
+    if (auto sequence = t.dyn_cast<SequenceType>())
+      return convertSequenceType(sequence);
+    if (auto tdesc = t.dyn_cast<TypeDescType>())
+      return convertTypeDescType(tdesc.getContext());
+    return LLVMTypeConverter::convertType(t);
+  }
+
+  /// Convert llvm::Type::TypeID to mlir::LLVM::LLVMType
+  M::LLVM::LLVMType fromRealTypeID(L::Type::TypeID typeID, KindTy kind) {
+    switch (typeID) {
+    case L::Type::TypeID::HalfTyID:
+      return M::LLVM::LLVMType::getHalfTy(llvmDialect);
+    case L::Type::TypeID::FloatTyID:
+      return M::LLVM::LLVMType::getFloatTy(llvmDialect);
+    case L::Type::TypeID::DoubleTyID:
+      return M::LLVM::LLVMType::getDoubleTy(llvmDialect);
+    case L::Type::TypeID::X86_FP80TyID:
+      return M::LLVM::LLVMType::getX86_FP80Ty(llvmDialect);
+    case L::Type::TypeID::FP128TyID:
+      return M::LLVM::LLVMType::getFP128Ty(llvmDialect);
+    default:
+      emitError(UnknownLoc::get(llvmDialect->getContext()))
+          << "unsupported type: !fir.real<" << kind << ">";
+      return {};
+    }
+  }
+
+  /// HACK: cloned from LLVMTypeConverter since this is private there
+  LLVM::LLVMType unwrap(Type type) {
+    if (!type)
+      return nullptr;
+    auto *mlirContext = type.getContext();
+    auto wrappedLLVMType = type.dyn_cast<LLVM::LLVMType>();
+    if (!wrappedLLVMType)
+      emitError(UnknownLoc::get(mlirContext),
+                "conversion resulted in a non-LLVM type");
+    return wrappedLLVMType;
+  }
+};
+
+// instantiate static data member
+L::StringMap<M::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
+
+L::SmallVector<M::NamedAttribute, 4>
+pruneNamedAttrDict(L::ArrayRef<M::NamedAttribute> attrs,
+                   L::ArrayRef<L::StringRef> omitNames) {
+  L::SmallVector<M::NamedAttribute, 4> result;
+  for (auto x : attrs) {
+    bool omit = false;
+    for (auto o : omitNames)
+      if (x.first.strref() == o) {
+        omit = true;
+        break;
+      }
+    if (!omit)
+      result.push_back(x);
+  }
+  return result;
+}
+
+/// FIR conversion pattern template
+template <typename FromOp>
+class FIROpConversion : public M::ConversionPattern {
+public:
+  explicit FIROpConversion(M::MLIRContext *ctx,
+                           FIRToLLVMTypeConverter &lowering)
+      : ConversionPattern(FromOp::getOperationName(), 1, ctx),
+        lowering(lowering) {}
+
+protected:
+  L::LLVMContext &getLLVMContext() const { return lowering.getLLVMContext(); }
+  M::LLVM::LLVMDialect *getDialect() const { return lowering.getDialect(); }
+
+  FIRToLLVMTypeConverter &lowering;
+};
+
+struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto addr = M::cast<fir::AddrOfOp>(op);
+    auto ty = lowering.unwrap(lowering.convertType(addr.getType()));
+    auto attrs = pruneNamedAttrDict(addr.getAttrs(), {"symbol"});
+    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(addr, ty, addr.symbol(),
+                                                      attrs);
+    return matchSuccess();
+  }
+};
+
+// convert to LLVM IR dialect `alloca`
+struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto alloc = M::cast<fir::AllocaOp>(op);
+    auto loc = alloc.getLoc();
+    auto ty = lowering.convertType(alloc.getType());
+    auto ity = lowering.indexType();
+    auto c1attr = rewriter.getI32IntegerAttr(1);
+    auto c1 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
+    rewriter.replaceOpWithNewOp<M::LLVM::AllocaOp>(alloc, ty, c1.getResult(),
+                                                   alloc.getAttrs());
+    return matchSuccess();
+  }
+};
+
+M::LLVM::LLVMFuncOp getMalloc(AllocMemOp op,
+                              M::ConversionPatternRewriter &rewriter,
+                              M::LLVM::LLVMDialect *dialect) {
+  auto module = op.getParentOfType<M::ModuleOp>();
+  auto mallocFunc = module.lookupSymbol<M::LLVM::LLVMFuncOp>("malloc");
+  if (!mallocFunc) {
+    M::OpBuilder moduleBuilder(
+        op.getParentOfType<M::ModuleOp>().getBodyRegion());
+    auto voidPtrType = M::LLVM::LLVMType::getInt8PtrTy(dialect);
+    auto indexType = M::LLVM::LLVMType::getInt64Ty(dialect);
+    mallocFunc = moduleBuilder.create<M::LLVM::LLVMFuncOp>(
+        rewriter.getUnknownLoc(), "malloc",
+        M::LLVM::LLVMType::getFunctionTy(voidPtrType, indexType,
+                                         /*isVarArg=*/false));
+  }
+  return mallocFunc;
+}
+
+// convert to `call` to the runtime to `malloc` memory
+struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto heap = M::cast<AllocMemOp>(op);
+    auto ty = lowering.convertType(heap.getType());
+    // FIXME: should be a call to malloc
+    auto loc = heap.getLoc();
+    auto ity = lowering.indexType();
+    auto c1attr = rewriter.getI32IntegerAttr(1);
+    auto c1 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
+    rewriter.replaceOpWithNewOp<M::LLVM::AllocaOp>(heap, ty, c1.getResult(),
+                                                   heap.getAttrs());
+    return matchSuccess();
+  }
+};
+
+struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxaddr = M::cast<BoxAddrOp>(op);
+    auto a = operands[0];
+    auto loc = boxaddr.getLoc();
+    auto ty = lowering.convertType(boxaddr.getType());
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    if (auto argty = boxaddr.val()->getType().dyn_cast<BoxType>()) {
+      auto ity = lowering.indexType();
+      auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+      L::SmallVector<M::Value *, 4> args({a, c0, c0});
+      auto pty = lowering.unwrap(ty).getPointerTo();
+      auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
+      rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxaddr, ty, p);
+    } else {
+      auto c0 = M::ArrayAttr::get(c0attr, boxaddr.getContext());
+      rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxaddr, ty, a, c0);
+    }
+    return matchSuccess();
+  }
+};
+
+struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxchar = M::cast<BoxCharLenOp>(op);
+    auto a = operands[0];
+    auto ty = lowering.convertType(boxchar.getType());
+    auto ctx = boxchar.getContext();
+    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxchar, ty, a, c1);
+    return matchSuccess();
+  }
+};
+
+struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxdims = M::cast<BoxDimsOp>(op);
+    auto a = operands[0];
+    auto dim = operands[1];
+    auto loc = boxdims.getLoc();
+    auto ity = lowering.indexType();
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+    auto c7attr = rewriter.getI32IntegerAttr(7);
+    auto c7 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c7attr);
+    auto ty = lowering.convertType(boxdims.getResult(0)->getType());
+    L::SmallVector<M::Value *, 4> args({a, c0, c7, dim});
+    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxdims, ty, p);
+    return matchSuccess();
+  }
+};
+
+struct BoxEleSizeOpConversion : public FIROpConversion<BoxEleSizeOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxelesz = M::cast<BoxEleSizeOp>(op);
+    auto a = operands[0];
+    auto loc = boxelesz.getLoc();
+    auto ty = lowering.convertType(boxelesz.getType());
+    auto ity = lowering.indexType();
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+    auto c1attr = rewriter.getI32IntegerAttr(1);
+    auto c1 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
+    L::SmallVector<M::Value *, 4> args({a, c0, c1});
+    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxelesz, ty, p);
+    return matchSuccess();
+  }
+};
+
+struct BoxIsAllocOpConversion : public FIROpConversion<BoxIsAllocOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxisalloc = M::cast<BoxIsAllocOp>(op);
+    auto a = operands[0];
+    auto loc = boxisalloc.getLoc();
+    auto ty = lowering.convertType(boxisalloc.getType());
+    auto ity = lowering.indexType();
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+    auto c5attr = rewriter.getI32IntegerAttr(5);
+    auto c5 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c5attr);
+    L::SmallVector<M::Value *, 4> args({a, c0, c5});
+    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+    auto c2attr = rewriter.getI32IntegerAttr(2);
+    auto ab = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c2attr);
+    auto bit = rewriter.create<M::LLVM::AndOp>(loc, ity, ld, ab);
+    rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
+        boxisalloc, M::LLVM::ICmpPredicate::ne, bit, c0);
+    return matchSuccess();
+  }
+};
+
+struct BoxIsArrayOpConversion : public FIROpConversion<BoxIsArrayOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxisarray = M::cast<BoxIsArrayOp>(op);
+    auto a = operands[0];
+    auto loc = boxisarray.getLoc();
+    auto ty = lowering.convertType(boxisarray.getType());
+    auto ity = lowering.indexType();
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+    auto c3attr = rewriter.getI32IntegerAttr(3);
+    auto c3 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c3attr);
+    L::SmallVector<M::Value *, 4> args({a, c0, c3});
+    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+    rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
+        boxisarray, M::LLVM::ICmpPredicate::ne, ld, c0);
+    return matchSuccess();
+  }
+};
+
+struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxisptr = M::cast<BoxIsPtrOp>(op);
+    auto a = operands[0];
+    auto loc = boxisptr.getLoc();
+    auto ty = lowering.convertType(boxisptr.getType());
+    auto ity = lowering.indexType();
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+    auto c5attr = rewriter.getI32IntegerAttr(5);
+    auto c5 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c5attr);
+    L::SmallVector<M::Value *, 4> args({a, c0, c5});
+    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+    auto c1attr = rewriter.getI32IntegerAttr(1);
+    auto ab = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
+    auto bit = rewriter.create<M::LLVM::AndOp>(loc, ity, ld, ab);
+    rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
+        boxisptr, M::LLVM::ICmpPredicate::ne, bit, c0);
+    return matchSuccess();
+  }
+};
+
+struct BoxProcHostOpConversion : public FIROpConversion<BoxProcHostOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxprochost = M::cast<BoxProcHostOp>(op);
+    auto a = operands[0];
+    auto ty = lowering.convertType(boxprochost.getType());
+    auto ctx = boxprochost.getContext();
+    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxprochost, ty, a,
+                                                         c1);
+    return matchSuccess();
+  }
+};
+
+struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxrank = M::cast<BoxRankOp>(op);
+    auto a = operands[0];
+    auto loc = boxrank.getLoc();
+    auto ty = lowering.convertType(boxrank.getType());
+    auto ity = lowering.indexType();
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+    auto c3attr = rewriter.getI32IntegerAttr(3);
+    auto c3 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c3attr);
+    L::SmallVector<M::Value *, 4> args({a, c0, c3});
+    auto pty = lowering.unwrap(ty).getPointerTo();
+    auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
+    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxrank, ty, p);
+    return matchSuccess();
+  }
+};
+
+struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto boxtypedesc = M::cast<BoxTypeDescOp>(op);
+    auto a = operands[0];
+    auto loc = boxtypedesc.getLoc();
+    auto ty = lowering.convertType(boxtypedesc.getType());
+    auto ity = lowering.indexType();
+    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
+    auto c4attr = rewriter.getI32IntegerAttr(4);
+    auto c4 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c4attr);
+    L::SmallVector<M::Value *, 4> args({a, c0, c4});
+    auto pty = lowering.unwrap(ty).getPointerTo();
+    auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
+    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+    auto i8ptr = M::LLVM::LLVMType::getInt8PtrTy(getDialect());
+    rewriter.replaceOpWithNewOp<M::LLVM::IntToPtrOp>(boxtypedesc, i8ptr, ld);
+    return matchSuccess();
+  }
+};
+
+// direct call LLVM function
+struct CallOpConversion : public FIROpConversion<fir::CallOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto call = M::cast<fir::CallOp>(op);
+    L::SmallVector<M::Type, 4> resultTys;
+    for (auto r : call.getResults())
+      resultTys.push_back(lowering.convertType(r->getType()));
+    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(call, resultTys, operands,
+                                                 call.getAttrs());
+    return matchSuccess();
+  }
+};
+
+// convert value of from-type to value of to-type
+struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto convert = M::cast<ConvertOp>(op);
+    auto fromTy_ = lowering.convertType(convert.value()->getType());
+    auto fromTy = lowering.unwrap(fromTy_);
+    auto toTy_ = lowering.convertType(convert.res()->getType());
+    auto toTy = lowering.unwrap(toTy_);
+    auto *fromLLVMTy = fromTy.getUnderlyingType();
+    auto *toLLVMTy = toTy.getUnderlyingType();
+    auto *op0 = operands[0];
+    if (fromLLVMTy == toLLVMTy) {
+      rewriter.replaceOp(convert, op0);
+      return matchSuccess();
+    }
+    auto loc = convert.getLoc();
+    M::Value *v = {};
+    if (fromLLVMTy->isFloatingPointTy()) {
+      if (toLLVMTy->isFloatingPointTy()) {
+        unsigned fromBits = fromLLVMTy->getPrimitiveSizeInBits();
+        unsigned toBits = toLLVMTy->getPrimitiveSizeInBits();
+        // TODO: what if different reps (F16, BF16) are the same size?
+        assert(fromBits != toBits);
+        if (fromBits > toBits)
+          v = rewriter.create<M::LLVM::FPTruncOp>(loc, toTy, op0);
+        else
+          v = rewriter.create<M::LLVM::FPExtOp>(loc, toTy, op0);
+      } else if (toLLVMTy->isIntegerTy()) {
+        v = rewriter.create<M::LLVM::FPToSIOp>(loc, toTy, op0);
+      }
+    } else if (fromLLVMTy->isIntegerTy()) {
+      if (toLLVMTy->isIntegerTy()) {
+        unsigned fromBits = fromLLVMTy->getIntegerBitWidth();
+        unsigned toBits = toLLVMTy->getIntegerBitWidth();
+        assert(fromBits != toBits);
+        if (fromBits > toBits)
+          v = rewriter.create<M::LLVM::TruncOp>(loc, toTy, op0);
+        else
+          v = rewriter.create<M::LLVM::SExtOp>(loc, toTy, op0);
+      } else if (toLLVMTy->isFloatingPointTy()) {
+        v = rewriter.create<M::LLVM::SIToFPOp>(loc, toTy, op0);
+      } else if (toLLVMTy->isPointerTy()) {
+        v = rewriter.create<M::LLVM::IntToPtrOp>(loc, toTy, op0);
+      }
+    } else if (fromLLVMTy->isPointerTy()) {
+      if (toLLVMTy->isIntegerTy()) {
+        v = rewriter.create<M::LLVM::PtrToIntOp>(loc, toTy, op0);
+      } else if (toLLVMTy->isPointerTy()) {
+        v = rewriter.create<M::LLVM::BitcastOp>(loc, toTy, op0);
+      }
+    }
+    if (v)
+      rewriter.replaceOp(op, v);
+    else
+      emitError(loc) << "cannot convert " << fromTy_ << " to " << toTy_;
+    return matchSuccess();
+  }
+};
+
+// convert to reference to a reference to a subobject
+struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto coor = M::cast<CoordinateOp>(op);
+    auto baseOp = coor.ref()->getDefiningOp();
+    auto loc = coor.getLoc();
+    if (auto box = M::dyn_cast<EmboxOp>(baseOp)) {
+      // FIXME: for now assume this is always an array
+      M::Value *v = rewriter.create<M::LLVM::GEPOp>(
+          loc, lowering.convertType(coor.getType()), box.memref(), operands);
+      rewriter.replaceOp(op, v);
+      return matchSuccess();
+    }
+    TODO(coor);
+    return matchSuccess();
+  }
+};
+
+// virtual call to a method in a dispatch table
+struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto dispatch = M::cast<DispatchOp>(op);
+    auto ty = lowering.convertType(dispatch.getFunctionType());
+    // get the table, lookup the method, fetch the func-ptr
+    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(dispatch, ty, operands);
+    TODO(dispatch);
+    return matchSuccess();
+  }
+};
+
+// dispatch table for a Fortran derived type
+struct DispatchTableOpConversion : public FIROpConversion<DispatchTableOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto disptable = M::cast<DispatchTableOp>(op);
+    TODO(disptable);
+    return matchSuccess();
+  }
+};
+
+// entry in a dispatch table; binds a method-name to a function
+struct DTEntryOpConversion : public FIROpConversion<DTEntryOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto dtentry = M::cast<DTEntryOp>(op);
+    TODO(dtentry);
+    return matchSuccess();
+  }
+};
+
+// create a CHARACTER box
+struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto emboxchar = M::cast<EmboxCharOp>(op);
+    auto a = operands[0];
+    auto b = operands[1];
+    auto loc = emboxchar.getLoc();
+    auto ctx = emboxchar.getContext();
+    auto ty = lowering.convertType(emboxchar.getType());
+    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto un = rewriter.create<M::LLVM::UndefOp>(loc, ty);
+    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, un, a, c0);
+    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(emboxchar, ty, r, b,
+                                                        c1);
+    return matchSuccess();
+  }
+};
+
+// create a generic box on a memory reference
+struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto embox = M::cast<EmboxOp>(op);
+    TODO(embox);
+    return matchSuccess();
+  }
+};
+
+// create a procedure pointer box
+struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto emboxproc = M::cast<EmboxProcOp>(op);
+    auto a = operands[0];
+    auto b = operands[1];
+    auto loc = emboxproc.getLoc();
+    auto ctx = emboxproc.getContext();
+    auto ty = lowering.convertType(emboxproc.getType());
+    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto un = rewriter.create<M::LLVM::UndefOp>(loc, ty);
+    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, un, a, c0);
+    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(emboxproc, ty, r, b,
+                                                        c1);
+    return matchSuccess();
+  }
+};
+
+// extract a subobject value from an ssa-value of aggregate type
+struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto extractVal = M::cast<ExtractValueOp>(op);
+    TODO(extractVal);
+    return matchSuccess();
+  }
+};
+
+// Compute the offset of a field in a variable of derived type. A value of type
+// field can only be used as an argument to a coordinate_of, extract_value, or
+// insert_value operation. It derives it's meaning from the context of where it
+// is used.
+struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto fieldindex = M::cast<FieldIndexOp>(op);
+    rewriter.replaceOp(fieldindex, {});
+    return matchSuccess();
+  }
+};
+
+// Replace the fir-end op with a null
+struct FirEndOpConversion : public FIROpConversion<FirEndOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    rewriter.replaceOp(op, {});
+    return matchSuccess();
+  }
+};
+
+// call free function
+struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::LLVM::LLVMType getVoidPtrType() const {
+    return M::LLVM::LLVMType::getInt8PtrTy(getDialect());
+  }
+
+  M::FuncOp genFreeFunc(M::Operation *op,
+                        M::ConversionPatternRewriter &rewriter) const {
+    M::FuncOp freeFunc =
+        op->getParentOfType<M::ModuleOp>().lookupSymbol<M::FuncOp>("free");
+    if (!freeFunc) {
+      auto freeType = rewriter.getFunctionType(getVoidPtrType(), {});
+      freeFunc = M::FuncOp::create(rewriter.getUnknownLoc(), "free", freeType);
+      op->getParentOfType<M::ModuleOp>().push_back(freeFunc);
+    }
+    return freeFunc;
+  }
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto freemem = M::cast<fir::FreeMemOp>(op);
+    auto freeFunc = genFreeFunc(freemem, rewriter);
+    M::Value *casted = rewriter.create<M::LLVM::BitcastOp>(
+        freemem.getLoc(), getVoidPtrType(), operands[0]);
+    auto sym = rewriter.getSymbolRefAttr(freeFunc);
+    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(
+        freemem, llvm::ArrayRef<M::Type>(), sym, casted);
+    return matchSuccess();
+  }
+};
+
+struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
+  using FIROpConversion::FIROpConversion;
+
+  // gendims(args:index, ...) ==> %v = ... : [size x <3 x index>]
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto gendims = M::cast<GenDimsOp>(op);
+    TODO(gendims);
+    return matchSuccess();
+  }
+};
+
+struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto gentypedesc = M::cast<GenTypeDescOp>(op);
+    TODO(gentypedesc);
+    return matchSuccess();
+  }
+};
+
+struct GlobalEntryOpConversion : public FIROpConversion<GlobalEntryOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto globalentry = M::cast<GlobalEntryOp>(op);
+    TODO(globalentry);
+    return matchSuccess();
+  }
+};
+
+struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto global = M::cast<fir::GlobalOp>(op);
+    auto tyAttr = M::TypeAttr::get(lowering.convertType(global.getType()));
+    M::UnitAttr isConst;
+    if (global.getAttrOfType<M::BoolAttr>("constant").getValue())
+      isConst = M::UnitAttr::get(global.getContext());
+    auto name = M::StringAttr::get(
+        global.getAttrOfType<M::StringAttr>(M::SymbolTable::getSymbolAttrName())
+            .getValue(),
+        global.getContext());
+    M::Attribute value;
+    auto addrSpace = /* FIXME: hard-coded i32 here; is that ok? */
+        rewriter.getI32IntegerAttr(0);
+    rewriter.replaceOpWithNewOp<M::LLVM::GlobalOp>(global, tyAttr, isConst,
+                                                   name, value, addrSpace);
+    return matchSuccess();
+  }
+};
+
+// InsertValue is the generalized instruction for the composition of new
+// aggregate type values.
+struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto insertVal = cast<InsertValueOp>(op);
+    TODO(insertVal);
+    // rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(insertVal, ...);
+    return matchSuccess();
+  }
+};
+
+// Compute the index of the LEN param in the descriptor addendum.  A value of
+// type field can only be used as an argument to a coordinate_of, extract_value,
+// or insert_value operation. It derives it's meaning from the context of where
+// it is used.  A LEN parameter cannot be an aggregate itself and thus a
+// LenParamIndexOp can appear only once and must be last in the argument list.
+struct LenParamIndexOpConversion
+    : public FIROpConversion<fir::LenParamIndexOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto lenparam = M::cast<LenParamIndexOp>(op);
+    rewriter.replaceOp(lenparam, {});
+    return matchSuccess();
+  }
+};
+
+// convert to LLVM IR dialect `load`
+struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto load = M::cast<fir::LoadOp>(op);
+    auto ty = lowering.convertType(load.getType());
+    auto at = load.getAttrs();
+    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(op, ty, operands, at);
+    return matchSuccess();
+  }
+};
+
+// abstract loop construct
+struct LoopOpConversion : public FIROpConversion<fir::LoopOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto loop = M::cast<fir::LoopOp>(op);
+    TODO(loop);
+    return matchSuccess();
+  }
+};
+
+// TODO: how do we want to enforce this in LLVM-IR?
+struct NoReassocOpConversion : public FIROpConversion<NoReassocOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto noreassoc = M::cast<NoReassocOp>(op);
+    noreassoc.replaceAllUsesWith(operands[0]);
+    rewriter.replaceOp(noreassoc, {});
+    return matchSuccess();
+  }
+};
+
+struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  L::ArrayRef<M::Block *> destinations,
+                  L::ArrayRef<OperandTy> destOperands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto selectcase = M::cast<SelectCaseOp>(op);
+    TODO(selectcase);
+    return matchSuccess();
+  }
+};
+
+// conversion of fir::SelectOp
+struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  L::ArrayRef<M::Block *> destinations,
+                  L::ArrayRef<OperandTy> destOperands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto select = M::cast<fir::SelectOp>(op);
+    TODO(select);
+    return matchSuccess();
+  }
+};
+
+struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  L::ArrayRef<M::Block *> destinations,
+                  L::ArrayRef<OperandTy> destOperands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto selectrank = M::cast<SelectRankOp>(op);
+    TODO(selectrank);
+    return matchSuccess();
+  }
+};
+
+// SelectTypeOp should have already been lowered
+struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  L::ArrayRef<M::Block *> destinations,
+                  L::ArrayRef<OperandTy> destOperands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto selecttype = M::cast<SelectRankOp>(op);
+    TODO(selecttype);
+    return matchSuccess();
+  }
+};
+
+// convert to LLVM IR dialect `store`
+struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto store = M::cast<fir::StoreOp>(op);
+    rewriter.replaceOpWithNewOp<M::LLVM::StoreOp>(store, operands[0],
+                                                  operands[1]);
+    return matchSuccess();
+  }
+};
+
+// unbox a CHARACTER box value, yielding its components
+struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto unboxchar = M::cast<UnboxCharOp>(op);
+    unboxchar.replaceAllUsesWith(operands);
+    rewriter.replaceOp(unboxchar, {});
+    return matchSuccess();
+  }
+};
+
+// unbox a generic box value, yielding its components
+struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto unbox = M::cast<UnboxOp>(op);
+    unbox.replaceAllUsesWith(operands);
+    rewriter.replaceOp(unbox, {});
+    return matchSuccess();
+  }
+};
+
+// unbox a procedure box value, yielding its components
+struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto unboxproc = M::cast<UnboxProcOp>(op);
+    unboxproc.replaceAllUsesWith(operands);
+    rewriter.replaceOp(unboxproc, {});
+    return matchSuccess();
+  }
+};
+
+// convert to LLVM IR dialect `undef`
+struct UndefOpConversion : public FIROpConversion<UndefOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto undef = M::cast<UndefOp>(op);
+    rewriter.replaceOpWithNewOp<M::LLVM::UndefOp>(
+        undef, lowering.convertType(undef.getType()));
+    return matchSuccess();
+  }
+};
+
+// convert to LLVM IR dialect `unreachable`
+struct UnreachableOpConversion : public FIROpConversion<UnreachableOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto unreach = M::cast<UnreachableOp>(op);
+    L::SmallVector<M::Block *, 1> destinations; // none
+    L::SmallVector<OperandTy, 1> destOperands;  // none
+    rewriter.replaceOpWithNewOp<M::LLVM::UnreachableOp>(
+        unreach, operands, destinations, destOperands, unreach.getAttrs());
+    return matchSuccess();
+  }
+};
+
+// abstract conditional construct
+struct WhereOpConversion : public FIROpConversion<fir::WhereOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto where = M::cast<fir::WhereOp>(op);
+    TODO(where);
+    return matchSuccess();
+  }
+};
+
+// Generate code for complex addition/subtraction
+template <typename LLVMOP, typename OPTY>
+M::LLVM::InsertValueOp complexSum(OPTY sumop, OperandTy opnds,
+                                  M::ConversionPatternRewriter &rewriter,
+                                  FIRToLLVMTypeConverter &lowering) {
+  auto a = opnds[0];
+  auto b = opnds[1];
+  auto loc = sumop.getLoc();
+  auto ctx = sumop.getContext();
+  auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+  auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+  auto ty = lowering.convertType(sumop.getType());
+  auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
+  auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
+  auto rx = rewriter.create<LLVMOP>(loc, ty, x, x_);
+  auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
+  auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
+  auto ry = rewriter.create<LLVMOP>(loc, ty, y, y_);
+  auto r = rewriter.create<M::LLVM::UndefOp>(loc, ty);
+  auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r, rx, c0);
+  return rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ry, c1);
+}
+
+template <typename BINOP, typename LLVMOP>
+void lowerRealBinaryOp(M::Operation *op, OperandTy operands,
+                       M::ConversionPatternRewriter &rewriter,
+                       FIRToLLVMTypeConverter &lowering) {
+  auto binop = cast<BINOP>(op);
+  auto ty = lowering.convertType(binop.getType());
+  rewriter.replaceOpWithNewOp<LLVMOP>(binop, ty, operands);
+}
+
+struct AddfOpConversion : public FIROpConversion<fir::AddfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::AddfOp, M::LLVM::FAddOp>(op, operands, rewriter,
+                                                    lowering);
+    return matchSuccess();
+  }
+};
+struct SubfOpConversion : public FIROpConversion<fir::SubfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::SubfOp, M::LLVM::FSubOp>(op, operands, rewriter,
+                                                    lowering);
+    return matchSuccess();
+  }
+};
+struct MulfOpConversion : public FIROpConversion<fir::MulfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::MulfOp, M::LLVM::FMulOp>(op, operands, rewriter,
+                                                    lowering);
+    return matchSuccess();
+  }
+};
+struct DivfOpConversion : public FIROpConversion<fir::DivfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::DivfOp, M::LLVM::FDivOp>(op, operands, rewriter,
+                                                    lowering);
+    return matchSuccess();
+  }
+};
+struct ModfOpConversion : public FIROpConversion<fir::ModfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::ModfOp, M::LLVM::FRemOp>(op, operands, rewriter,
+                                                    lowering);
+    return matchSuccess();
+  }
+};
+
+struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    // result: (x + x') + i(y + y')
+    auto addc = cast<fir::AddcOp>(op);
+    auto r = complexSum<M::LLVM::FAddOp>(addc, operands, rewriter, lowering);
+    addc.replaceAllUsesWith(r.getResult());
+    rewriter.replaceOp(addc, r.getResult());
+    return matchSuccess();
+  }
+};
+
+struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    // result: (x - x') + i(y - y')
+    auto subc = M::cast<fir::SubcOp>(op);
+    auto r = complexSum<M::LLVM::FSubOp>(subc, operands, rewriter, lowering);
+    subc.replaceAllUsesWith(r.getResult());
+    rewriter.replaceOp(subc, r.getResult());
+    return matchSuccess();
+  }
+};
+
+struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto mulc = M::cast<fir::MulcOp>(op);
+    // TODO: should this just call __muldc3 ?
+    // result: (xx'-yy')+i(xy'+yx')
+    auto a = operands[0];
+    auto b = operands[1];
+    auto loc = mulc.getLoc();
+    auto ctx = mulc.getContext();
+    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto ty = lowering.convertType(mulc.getType());
+    auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
+    auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
+    auto xx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, x_);
+    auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
+    auto yx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, x_);
+    auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
+    auto xy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, y_);
+    auto ri = rewriter.create<M::LLVM::FAddOp>(loc, ty, xy_, yx_);
+    auto yy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, y_);
+    auto rr = rewriter.create<M::LLVM::FSubOp>(loc, ty, xx_, yy_);
+    auto ra = rewriter.create<M::LLVM::UndefOp>(loc, ty);
+    auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
+    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
+    mulc.replaceAllUsesWith(r.getResult());
+    rewriter.replaceOp(mulc, r.getResult());
+    return matchSuccess();
+  }
+};
+
+struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto divc = M::cast<fir::DivcOp>(op);
+    // TODO: should this just call __divdc3 ?
+    // result: ((xx'+yy')/d) + i((yx'-xy')/d) where d = x'x' + y'y'
+    auto a = operands[0];
+    auto b = operands[1];
+    auto loc = divc.getLoc();
+    auto ctx = divc.getContext();
+    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto ty = lowering.convertType(divc.getType());
+    auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
+    auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
+    auto xx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, x_);
+    auto x_x_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x_, x_);
+    auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
+    auto yx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, x_);
+    auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
+    auto xy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, y_);
+    auto yy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, y_);
+    auto y_y_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y_, y_);
+    auto d = rewriter.create<M::LLVM::FAddOp>(loc, ty, x_x_, y_y_);
+    auto rrn = rewriter.create<M::LLVM::FAddOp>(loc, ty, xx_, yy_);
+    auto rin = rewriter.create<M::LLVM::FSubOp>(loc, ty, yx_, xy_);
+    auto rr = rewriter.create<M::LLVM::FDivOp>(loc, ty, rrn, d);
+    auto ri = rewriter.create<M::LLVM::FDivOp>(loc, ty, rin, d);
+    auto ra = rewriter.create<M::LLVM::UndefOp>(loc, ty);
+    auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
+    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
+    divc.replaceAllUsesWith(r.getResult());
+    rewriter.replaceOp(divc, r.getResult());
+    return matchSuccess();
+  }
+};
+
+// Lower a SELECT operation into a cascade of conditional branches. The last
+// case must be the `true` condition.
+inline void rewriteSelectConstruct(M::Operation *op, OperandTy operands,
+                                   L::ArrayRef<M::Block *> dests,
+                                   L::ArrayRef<OperandTy> destOperands,
+                                   M::OpBuilder &rewriter) {
+  L::SmallVector<M::Value *, 1> noargs;
+  L::SmallVector<M::Block *, 8> blocks;
+  auto loc{op->getLoc()};
+  blocks.push_back(rewriter.getInsertionBlock());
+  for (std::size_t i = 1; i < dests.size(); ++i)
+    blocks.push_back(rewriter.createBlock(dests[0]));
+  rewriter.setInsertionPointToEnd(blocks[0]);
+  if (dests.size() == 1) {
+    rewriter.create<M::BranchOp>(loc, dests[0], destOperands[0]);
+    return;
+  }
+  rewriter.create<M::CondBranchOp>(loc, operands[1], dests[0], destOperands[0],
+                                   blocks[1], noargs);
+  for (std::size_t i = 1; i < dests.size() - 1; ++i) {
+    rewriter.setInsertionPointToEnd(blocks[i]);
+    rewriter.create<M::CondBranchOp>(loc, operands[i + 1], dests[i],
+                                     destOperands[i], blocks[i + 1], noargs);
+  }
+  std::size_t last{dests.size() - 1};
+  rewriter.setInsertionPointToEnd(blocks[last]);
+  rewriter.create<M::BranchOp>(loc, dests[last], destOperands[last]);
+}
+
+/// Convert FIR dialect to LLVM dialect
+///
+/// This pass lowers all FIR dialect operations to LLVM IR dialect.  An
+/// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
+struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
+  void runOnModule() override {
+    auto &context{getContext()};
+    FIRToLLVMTypeConverter typeConverter{&context};
+    M::OwningRewritePatternList patterns;
+    patterns.insert<
+        AddcOpConversion, AddfOpConversion, AddrOfOpConversion,
+        AllocaOpConversion, AllocMemOpConversion, BoxAddrOpConversion,
+        BoxCharLenOpConversion, BoxDimsOpConversion, BoxEleSizeOpConversion,
+        BoxIsAllocOpConversion, BoxIsArrayOpConversion, BoxIsPtrOpConversion,
+        BoxProcHostOpConversion, BoxRankOpConversion, BoxTypeDescOpConversion,
+        CallOpConversion, ConvertOpConversion, CoordinateOpConversion,
+        DispatchOpConversion, DispatchTableOpConversion, DivcOpConversion,
+        DivfOpConversion, DTEntryOpConversion, EmboxCharOpConversion,
+        EmboxOpConversion, EmboxProcOpConversion, FirEndOpConversion,
+        ExtractValueOpConversion, FieldIndexOpConversion, FreeMemOpConversion,
+        GenDimsOpConversion, GenTypeDescOpConversion, GlobalEntryOpConversion,
+        GlobalOpConversion, InsertValueOpConversion, LenParamIndexOpConversion,
+        LoadOpConversion, LoopOpConversion, ModfOpConversion, MulcOpConversion,
+        MulfOpConversion, NoReassocOpConversion, SelectCaseOpConversion,
+        SelectOpConversion, SelectRankOpConversion, SelectTypeOpConversion,
+        StoreOpConversion, SubcOpConversion, SubfOpConversion,
+        UnboxCharOpConversion, UnboxOpConversion, UnboxProcOpConversion,
+        UndefOpConversion, UnreachableOpConversion, WhereOpConversion>(
+        &context, typeConverter);
+    M::populateStdToLLVMConversionPatterns(typeConverter, patterns);
+    M::ConversionTarget target{context};
+    target.addLegalDialect<M::LLVM::LLVMDialect>();
+
+    // required NOP stubs for applying a full conversion
+    target.addDynamicallyLegalOp<M::ModuleOp>(
+        [&](M::ModuleOp op) { return true; });
+    target.addDynamicallyLegalOp<M::ModuleTerminatorOp>(
+        [&](M::ModuleTerminatorOp op) { return true; });
+
+    // apply the patterns
+    if (M::failed(M::applyFullConversion(
+            getModule(), target, std::move(patterns), &typeConverter))) {
+      M::emitError(M::UnknownLoc::get(&context),
+                   "error in converting to LLVM-IR dialect\n");
+      signalPassFailure();
+    }
+  }
+};
+
+/// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
+struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
+  void runOnModule() override {
+    if (auto llvmModule{M::translateModuleToLLVMIR(getModule())}) {
+      std::error_code ec;
+      L::raw_fd_ostream stream("a.ll", ec, L::sys::fs::F_None);
+      stream << *llvmModule << '\n';
+    } else {
+      auto ctxt{getModule().getContext()};
+      M::emitError(M::UnknownLoc::get(ctxt), "could not emit LLVM-IR\n");
+      signalPassFailure();
+    }
+  }
+};
+
+} // namespace
+
+std::unique_ptr<M::Pass> fir::createFIRToLLVMPass() {
+  return std::make_unique<FIRToLLVMLoweringPass>();
+}
+
+std::unique_ptr<M::Pass> fir::createLLVMDialectToLLVMPass() {
+  return std::make_unique<LLVMIRLoweringPass>();
+}
diff --git a/lib/fir/Transforms/CMakeLists.txt b/lib/fir/Transforms/CMakeLists.txt
new file mode 100644
index 000000000000..a8ddb6d71ba9
--- /dev/null
+++ b/lib/fir/Transforms/CMakeLists.txt
@@ -0,0 +1,29 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_llvm_library(FIRTransforms
+  CSE.cpp
+  MemToReg.cpp
+)
+
+add_dependencies(FIRTransforms FIROpsIncGen)
+
+target_link_libraries(FIRTransforms
+  FIR
+)
+
+install (TARGETS FIRTransforms
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+)
diff --git a/lib/fir/Transforms/CSE.cpp b/lib/fir/Transforms/CSE.cpp
new file mode 100644
index 000000000000..45dff9d123c2
--- /dev/null
+++ b/lib/fir/Transforms/CSE.cpp
@@ -0,0 +1,319 @@
+//===- CSE.cpp - Common Sub-expression Elimination ------------------------===//
+//
+// Copyright 2019 The MLIR Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// =============================================================================
+//
+// This transformation pass performs a simple common sub-expression elimination
+// algorithm on operations within a function.
+//
+//===----------------------------------------------------------------------===//
+
+#include "fir/FIROps.h"
+#include "fir/Transforms/Passes.h"
+#include "mlir/Analysis/Dominance.h"
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Function.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Support/Functional.h"
+#include "mlir/Transforms/Passes.h"
+#include "mlir/Transforms/Utils.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/ScopedHashTable.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/RecyclingAllocator.h"
+#include <deque>
+
+using namespace mlir;
+
+static llvm::cl::opt<bool>
+    ClLeaveEffects("keep-effects",
+                   llvm::cl::desc("disable cleaning up effects attributes"),
+                   llvm::cl::init(false), llvm::cl::Hidden);
+
+namespace {
+
+struct SimpleOperationInfo : public llvm::DenseMapInfo<Operation *> {
+  static unsigned getHashValue(const Operation *opC) {
+    auto *op = const_cast<Operation *>(opC);
+    // Hash the operations based upon their:
+    //   - Operation Name
+    //   - Attributes
+    //   - Result Types
+    //   - Operands
+    unsigned hashOps;
+    if (op->isCommutative()) {
+      std::vector<void *> vec(op->operand_begin(), op->operand_end());
+      llvm::sort(vec.begin(), vec.end());
+      hashOps = llvm::hash_combine_range(vec.begin(), vec.end());
+    } else {
+      hashOps = hash_combine_range(op->operand_begin(), op->operand_end());
+    }
+    return hash_combine(
+        op->getName(), op->getAttrs(),
+        hash_combine_range(op->result_type_begin(), op->result_type_end()),
+        hashOps);
+  }
+
+  static bool isEqual(const Operation *lhsC, const Operation *rhsC) {
+    auto *lhs = const_cast<Operation *>(lhsC);
+    auto *rhs = const_cast<Operation *>(rhsC);
+    if (lhs == rhs)
+      return true;
+    if (lhs == getTombstoneKey() || lhs == getEmptyKey() ||
+        rhs == getTombstoneKey() || rhs == getEmptyKey())
+      return false;
+
+    // Compare the operation name.
+    if (lhs->getName() != rhs->getName())
+      return false;
+    // Check operand and result type counts.
+    if (lhs->getNumOperands() != rhs->getNumOperands() ||
+        lhs->getNumResults() != rhs->getNumResults())
+      return false;
+    // Compare attributes.
+    if (lhs->getAttrs() != rhs->getAttrs())
+      return false;
+    // Compare operands.
+    if (lhs->isCommutative()) {
+      SmallVector<Value *, 8> lops(lhs->operand_begin(), lhs->operand_end());
+      llvm::sort(lops.begin(), lops.end());
+      SmallVector<Value *, 8> rops(rhs->operand_begin(), rhs->operand_end());
+      llvm::sort(rops.begin(), rops.end());
+      if (!std::equal(lops.begin(), lops.end(), rops.begin()))
+        return false;
+    } else {
+      if (!std::equal(lhs->operand_begin(), lhs->operand_end(),
+                      rhs->operand_begin()))
+        return false;
+    }
+    // Compare result types.
+    return std::equal(lhs->result_type_begin(), lhs->result_type_end(),
+                      rhs->result_type_begin());
+  }
+};
+
+/// Basic common sub-expression elimination.
+struct BasicCSE : public FunctionPass<BasicCSE> {
+  BasicCSE() = default;
+  BasicCSE(const BasicCSE &) {}
+
+  /// Shared implementation of operation elimination and scoped map definitions.
+  using AllocatorTy = llvm::RecyclingAllocator<
+      llvm::BumpPtrAllocator,
+      llvm::ScopedHashTableVal<Operation *, Operation *>>;
+  using ScopedMapTy = llvm::ScopedHashTable<Operation *, Operation *,
+                                            SimpleOperationInfo, AllocatorTy>;
+
+  /// Represents a single entry in the depth first traversal of a CFG.
+  struct CFGStackNode {
+    CFGStackNode(ScopedMapTy &knownValues, DominanceInfoNode *node)
+        : scope(knownValues), node(node), childIterator(node->begin()),
+          processed(false) {}
+
+    /// Scope for the known values.
+    ScopedMapTy::ScopeTy scope;
+
+    DominanceInfoNode *node;
+    DominanceInfoNode::iterator childIterator;
+
+    /// If this node has been fully processed yet or not.
+    bool processed;
+  };
+
+  /// Attempt to eliminate a redundant operation. Returns success if the
+  /// operation was marked for removal, failure otherwise.
+  LogicalResult simplifyOperation(ScopedMapTy &knownValues, Operation *op);
+
+  void simplifyBlock(ScopedMapTy &knownValues, DominanceInfo &domInfo,
+                     Block *bb);
+  void simplifyRegion(ScopedMapTy &knownValues, DominanceInfo &domInfo,
+                      Region &region);
+  
+  void cleanupBlock(Block *bb) {
+    for (auto &inst : *bb) {
+      if (fir::nonVolatileLoad(&inst)) {
+        inst.removeAttr(Identifier::get("effects_token", inst.getContext()));
+      } else if (inst.getNumRegions()) {
+        for (auto &region : inst.getRegions())
+          cleanupRegion(region);
+      }
+    }
+  }
+  void cleanupRegion(Region &region) {
+    for (auto &block : region)
+      cleanupBlock(&block);
+  }
+
+  void runOnFunction() override;
+
+private:
+  /// Operations marked as dead and to be erased.
+  std::vector<Operation *> opsToErase;
+};
+
+/// Attempt to eliminate a redundant operation.
+LogicalResult BasicCSE::simplifyOperation(ScopedMapTy &knownValues,
+                                          Operation *op) {
+  // Don't simplify operations with nested blocks. We don't currently model
+  // equality comparisons correctly among other things. It is also unclear
+  // whether we would want to CSE such operations.
+  if (op->getNumRegions() != 0)
+    return failure();
+
+  if (!op->hasNoSideEffect() && !fir::nonVolatileLoad(op))
+    return failure();
+
+  // If the operation is already trivially dead just add it to the erase list.
+  if (op->use_empty()) {
+    opsToErase.push_back(op);
+    return success();
+  }
+
+  // Look for an existing definition for the operation.
+  if (auto *existing = knownValues.lookup(op)) {
+    // If we find one then replace all uses of the current operation with the
+    // existing one and mark it for deletion.
+    op->replaceAllUsesWith(existing);
+    opsToErase.push_back(op);
+
+    // If the existing operation has an unknown location and the current
+    // operation doesn't, then set the existing op's location to that of the
+    // current op.
+    if (existing->getLoc().isa<UnknownLoc>() &&
+        !op->getLoc().isa<UnknownLoc>()) {
+      existing->setLoc(op->getLoc());
+    }
+    return success();
+  }
+
+  // Otherwise, we add this operation to the known values map.
+  knownValues.insert(op, op);
+  return failure();
+}
+
+void BasicCSE::simplifyBlock(ScopedMapTy &knownValues, DominanceInfo &domInfo,
+                             Block *bb) {
+  std::intptr_t token = reinterpret_cast<std::intptr_t>(bb);
+  for (auto &inst : *bb) {
+    if (fir::nonVolatileLoad(&inst))
+      inst.setAttr("effects_token",
+                   IntegerAttr::get(IndexType::get(inst.getContext()), token));
+    if (dyn_cast<fir::StoreOp>(&inst) || fir::impureCall(&inst))
+      token = reinterpret_cast<std::intptr_t>(&inst);
+  }
+  for (auto &inst : *bb) {
+    // If the operation is simplified, we don't process any held regions.
+    if (succeeded(simplifyOperation(knownValues, &inst)))
+      continue;
+
+    // If this operation is isolated above, we can't process nested regions with
+    // the given 'knownValues' map. This would cause the insertion of implicit
+    // captures in explicit capture only regions.
+    if (!inst.isRegistered() || inst.isKnownIsolatedFromAbove()) {
+      ScopedMapTy nestedKnownValues;
+      for (auto &region : inst.getRegions())
+        simplifyRegion(nestedKnownValues, domInfo, region);
+      continue;
+    }
+
+    // Otherwise, process nested regions normally.
+    for (auto &region : inst.getRegions())
+      simplifyRegion(knownValues, domInfo, region);
+  }
+}
+
+void BasicCSE::simplifyRegion(ScopedMapTy &knownValues, DominanceInfo &domInfo,
+                              Region &region) {
+  // If the region is empty there is nothing to do.
+  if (region.empty())
+    return;
+
+  // If the region only contains one block, then simplify it directly.
+  if (std::next(region.begin()) == region.end()) {
+    ScopedMapTy::ScopeTy scope(knownValues);
+    simplifyBlock(knownValues, domInfo, &region.front());
+    return;
+  }
+
+  // Note, deque is being used here because there was significant performance
+  // gains over vector when the container becomes very large due to the
+  // specific access patterns. If/when these performance issues are no
+  // longer a problem we can change this to vector. For more information see
+  // the llvm mailing list discussion on this:
+  // http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20120116/135228.html
+  std::deque<std::unique_ptr<CFGStackNode>> stack;
+
+  // Process the nodes of the dom tree for this region.
+  stack.emplace_back(std::make_unique<CFGStackNode>(
+      knownValues, domInfo.getRootNode(&region)));
+
+  while (!stack.empty()) {
+    auto &currentNode = stack.back();
+
+    // Check to see if we need to process this node.
+    if (!currentNode->processed) {
+      currentNode->processed = true;
+      simplifyBlock(knownValues, domInfo, currentNode->node->getBlock());
+    }
+
+    // Otherwise, check to see if we need to process a child node.
+    if (currentNode->childIterator != currentNode->node->end()) {
+      auto *childNode = *(currentNode->childIterator++);
+      stack.emplace_back(
+          std::make_unique<CFGStackNode>(knownValues, childNode));
+    } else {
+      // Finally, if the node and all of its children have been processed
+      // then we delete the node.
+      stack.pop_back();
+    }
+  }
+}
+
+void BasicCSE::runOnFunction() {
+  /// A scoped hash table of defining operations within a function.
+  {
+    ScopedMapTy knownValues;
+    simplifyRegion(knownValues, getAnalysis<DominanceInfo>(),
+                   getFunction().getBody());
+  }
+  if (!ClLeaveEffects) {
+    cleanupRegion(getFunction().getBody());
+  }
+
+  // If no operations were erased, then we mark all analyses as preserved.
+  if (opsToErase.empty())
+    return markAllAnalysesPreserved();
+
+  /// Erase any operations that were marked as dead during simplification.
+  for (auto *op : opsToErase)
+    op->erase();
+  opsToErase.clear();
+
+  // We currently don't remove region operations, so mark dominance as
+  // preserved.
+  markAnalysesPreserved<DominanceInfo, PostDominanceInfo>();
+}
+
+} // end anonymous namespace
+
+std::unique_ptr<OpPassBase<FuncOp>> fir::createCSEPass() {
+  return std::make_unique<BasicCSE>();
+}
+
+static PassRegistration<BasicCSE>
+    pass("basiccse", "Eliminate common sub-expressions in functions");
diff --git a/lib/fir/Transforms/MemToReg.cpp b/lib/fir/Transforms/MemToReg.cpp
new file mode 100644
index 000000000000..2104f8ddf97c
--- /dev/null
+++ b/lib/fir/Transforms/MemToReg.cpp
@@ -0,0 +1,740 @@
+//===- MemToReg.cpp - Generalized mem to reg pass for MLIR dialects     ---===//
+//
+// 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 "fir/Analysis/IteratedDominanceFrontier.h"
+#include "fir/Dialect.h"
+#include "fir/FIROps.h"
+#include "fir/Transforms/Passes.h"
+#include "mlir/Analysis/Dominance.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Pass/Pass.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include <utility>
+#include <vector>
+
+namespace M = mlir;
+
+using namespace fir;
+
+using DominatorTree = M::DominanceInfo;
+
+/// A generalized version of a mem-to-reg pass suitable for use with an MLIR
+/// dialect. This code was ported from the LLVM project. MLIR differs with its
+/// use of block arguments rather than PHI nodes, etc.
+
+namespace {
+
+template <typename LOAD, typename STORE, typename ALLOCA>
+bool isAllocaPromotable(ALLOCA &ae) {
+  for (auto &use : ae.getResult()->getUses()) {
+    auto *op = use.getOwner();
+    if (auto load = M::dyn_cast<LOAD>(op)) {
+      // do nothing
+    } else if (auto stor = M::dyn_cast<STORE>(op)) {
+      if (stor.getOperand(0)->getDefiningOp() == op) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <typename LOAD, typename STORE, typename ALLOCA>
+struct AllocaInfo {
+  llvm::SmallVector<M::Block *, 32> definingBlocks;
+  llvm::SmallVector<M::Block *, 32> usingBlocks;
+
+  M::Operation *onlyStore;
+  M::Block *onlyBlock;
+  bool onlyUsedInOneBlock;
+
+  void clear() {
+    definingBlocks.clear();
+    usingBlocks.clear();
+    onlyStore = nullptr;
+    onlyBlock = nullptr;
+    onlyUsedInOneBlock = true;
+  }
+
+  /// Scan the uses of the specified alloca, filling in the AllocaInfo used
+  /// by the rest of the pass to reason about the uses of this alloca.
+  void analyzeAlloca(ALLOCA &AI) {
+    clear();
+
+    // As we scan the uses of the alloca instruction, keep track of stores,
+    // and decide whether all of the loads and stores to the alloca are within
+    // the same basic block.
+    for (auto UI = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+         UI != E;) {
+      auto *User = UI->getOwner();
+      UI++;
+
+      if (auto SI = M::dyn_cast<STORE>(User)) {
+        // Remember the basic blocks which define new values for the alloca
+        definingBlocks.push_back(SI.getOperation()->getBlock());
+        onlyStore = SI.getOperation();
+      } else {
+        auto LI = M::cast<LOAD>(User);
+        // Otherwise it must be a load instruction, keep track of variable
+        // reads.
+        usingBlocks.push_back(LI.getOperation()->getBlock());
+      }
+
+      if (onlyUsedInOneBlock) {
+        if (!onlyBlock)
+          onlyBlock = User->getBlock();
+        else if (onlyBlock != User->getBlock())
+          onlyUsedInOneBlock = false;
+      }
+    }
+  }
+};
+
+struct RenamePassData {
+  using ValVector = std::vector<M::Value *>;
+
+  RenamePassData(M::Block *b, M::Block *p, const ValVector &v)
+      : BB(b), Pred(p), Values(v) {}
+  RenamePassData(const RenamePassData &) = delete;
+  RenamePassData &operator=(const RenamePassData &) = delete;
+  RenamePassData(RenamePassData &&) = default;
+  ~RenamePassData() = default;
+
+  M::Block *BB;
+  M::Block *Pred;
+  ValVector Values;
+};
+
+template <typename LOAD, typename STORE, typename ALLOCA>
+struct LargeBlockInfo {
+  using INMap = llvm::DenseMap<M::Operation *, unsigned>;
+  INMap instNumbers;
+
+  static bool isInterestingInstruction(M::Operation &I) {
+    if (M::isa<LOAD>(I)) {
+      if (auto *op = I.getOperand(0)->getDefiningOp())
+        return M::isa<ALLOCA>(op);
+    } else if (M::isa<STORE>(I)) {
+      if (auto *op = I.getOperand(1)->getDefiningOp())
+        return M::isa<ALLOCA>(op);
+    }
+    return false;
+  }
+
+  template <typename A>
+  unsigned getInstructionIndex(A &op) {
+    auto *oper = op.getOperation();
+
+    // has it already been numbered?
+    INMap::iterator it = instNumbers.find(oper);
+    if (it != instNumbers.end())
+      return it->second;
+
+    // No. search for the oper
+    auto *block = oper->getBlock();
+    unsigned num = 0u;
+    for (auto &o : block->getOperations())
+      if (isInterestingInstruction(o))
+        instNumbers[&o] = num++;
+
+    it = instNumbers.find(oper);
+    assert(it != instNumbers.end() && "operation not in block?");
+    return it->second;
+  }
+
+  template <typename A>
+  void deleteValue(A &op) {
+    auto *oper = op.getOperation();
+    instNumbers.erase(oper);
+  }
+
+  void clear() { instNumbers.clear(); }
+};
+
+template <typename LOAD, typename STORE, typename ALLOCA, typename UNDEF>
+struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
+  explicit MemToReg() {}
+
+  std::vector<ALLOCA> allocas;
+  DominatorTree *domTree = nullptr;
+  M::OpBuilder *builder = nullptr;
+
+  /// Contains a stable numbering of basic blocks to avoid non-determinstic
+  /// behavior.
+  llvm::DenseMap<M::Block *, unsigned> BBNumbers;
+
+  /// Reverse mapping of Allocas.
+  llvm::DenseMap<M::Operation *, unsigned> allocaLookup;
+
+  /// The set of basic blocks the renamer has already visited.
+  llvm::SmallPtrSet<M::Block *, 16> Visited;
+
+  llvm::DenseMap<std::pair<M::Block *, M::Operation *>, unsigned> BlockArgs;
+  llvm::DenseMap<std::pair<M::Block *, unsigned>, unsigned> argToAllocaMap;
+
+  bool rewriteSingleStoreAlloca(ALLOCA &AI,
+                                AllocaInfo<LOAD, STORE, ALLOCA> &Info,
+                                LargeBlockInfo<LOAD, STORE, ALLOCA> &LBI) {
+    STORE onlyStore(M::cast<STORE>(Info.onlyStore));
+    M::Block *StoreBB = Info.onlyStore->getBlock();
+    int StoreIndex = -1;
+
+    // Clear out usingBlocks.  We will reconstruct it here if needed.
+    Info.usingBlocks.clear();
+
+    for (auto UI = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+         UI != E;) {
+      auto *UserInst = UI->getOwner();
+      UI++;
+
+      if (M::dyn_cast<STORE>(UserInst))
+        continue;
+
+      auto LI = M::cast<LOAD>(UserInst);
+
+      // Okay, if we have a load from the alloca, we want to replace it with the
+      // only value stored to the alloca.  We can do this if the value is
+      // dominated by the store.  If not, we use the rest of the MemToReg
+      // machinery to insert the phi nodes as needed.
+      if (LI.getOperation()->getBlock() == StoreBB) {
+        // If we have a use that is in the same block as the store, compare
+        // the indices of the two instructions to see which one came first. If
+        // the load came before the store, we can't handle it.
+        if (StoreIndex == -1)
+          StoreIndex = LBI.getInstructionIndex(onlyStore);
+
+        if (unsigned(StoreIndex) > LBI.getInstructionIndex(LI)) {
+          // Can't handle this load, bail out.
+          Info.usingBlocks.push_back(StoreBB);
+          continue;
+        }
+      } else if (!domTree->dominates(StoreBB, LI.getOperation()->getBlock())) {
+        // If the load and store are in different blocks, use BB dominance to
+        // check their relationships.  If the store doesn't dom the use, bail
+        // out.
+        Info.usingBlocks.push_back(LI.getOperation()->getBlock());
+        continue;
+      }
+
+      // Otherwise, we *can* safely rewrite this load.
+      M::Value *ReplVal = onlyStore.getOperand(0);
+      // If the replacement value is the load, this must occur in unreachable
+      // code.
+      if (ReplVal == LI.getResult())
+        ReplVal = builder->create<UNDEF>(LI.getLoc(), LI.getType());
+
+      LI.replaceAllUsesWith(ReplVal);
+      LI.erase();
+      LBI.deleteValue(LI);
+    }
+
+    // Finally, after the scan, check to see if the store is all that is left.
+    if (!Info.usingBlocks.empty())
+      return false; // If not, we'll have to fall back for the remainder.
+
+    // Remove the (now dead) store and alloca.
+    Info.onlyStore->erase();
+
+    AI.erase();
+    return true;
+  }
+
+  bool promoteSingleBlockAlloca(ALLOCA &AI,
+                                AllocaInfo<LOAD, STORE, ALLOCA> &Info,
+                                LargeBlockInfo<LOAD, STORE, ALLOCA> &LBI) {
+    // Walk the use-def list of the alloca, getting the locations of all stores.
+    using StoresByIndexTy = llvm::SmallVector<std::pair<unsigned, STORE *>, 64>;
+    StoresByIndexTy StoresByIndex;
+
+    for (auto U = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+         U != E; U++)
+      if (STORE SI = M::dyn_cast<STORE>(U->getOwner()))
+        StoresByIndex.emplace_back(LBI.getInstructionIndex(SI), &SI);
+
+    // Sort the stores by their index, making it efficient to do a lookup with a
+    // binary search.
+    llvm::sort(StoresByIndex, llvm::less_first());
+
+    // Walk all of the loads from this alloca, replacing them with the nearest
+    // store above them, if any.
+    for (auto UI = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+         UI != E;) {
+      auto LI = M::dyn_cast<LOAD>(UI->getOwner());
+      UI++;
+      if (!LI)
+        continue;
+
+      unsigned LoadIdx = LBI.getInstructionIndex(LI);
+
+      // Find the nearest store that has a lower index than this load.
+      typename StoresByIndexTy::iterator I = llvm::lower_bound(
+          StoresByIndex, std::make_pair(LoadIdx, static_cast<STORE *>(nullptr)),
+          llvm::less_first());
+      if (I == StoresByIndex.begin()) {
+        if (StoresByIndex.empty()) {
+          // If there are no stores, the load takes the undef value.
+          auto undef = builder->create<UNDEF>(LI.getLoc(), LI.getType());
+          LI.replaceAllUsesWith(undef.getResult());
+        } else {
+          // There is no store before this load, bail out (load may be affected
+          // by the following stores - see main comment).
+          return false;
+        }
+      } else {
+        // Otherwise, there was a store before this load, the load takes its
+        // value. Note, if the load was marked as nonnull we don't want to lose
+        // that information when we erase it. So we preserve it with an assume.
+        M::Value *ReplVal = std::prev(I)->second->getOperand(0);
+
+        // If the replacement value is the load, this must occur in unreachable
+        // code.
+        if (ReplVal == LI)
+          ReplVal = builder->create<UNDEF>(LI.getLoc(), LI.getType());
+
+        LI.replaceAllUsesWith(ReplVal);
+      }
+
+      LI.erase();
+      LBI.deleteValue(LI);
+    }
+
+    // Remove the (now dead) stores and alloca.
+    while (!AI.use_empty()) {
+      auto *ae = AI.getResult();
+      for (auto ai = ae->user_begin(), E = ae->user_end(); ai != E; ai++)
+        if (STORE SI = M::dyn_cast<STORE>(*ai)) {
+          SI.erase();
+          LBI.deleteValue(SI);
+        }
+    }
+
+    AI.erase();
+    return true;
+  }
+
+  void computeLiveInBlocks(ALLOCA &ae, AllocaInfo<LOAD, STORE, ALLOCA> &Info,
+                           const llvm::SmallPtrSetImpl<M::Block *> &DefBlocks,
+                           llvm::SmallPtrSetImpl<M::Block *> &liveInBlks) {
+    auto *AI = ae.getOperation();
+    // To determine liveness, we must iterate through the predecessors of blocks
+    // where the def is live.  Blocks are added to the worklist if we need to
+    // check their predecessors.  Start with all the using blocks.
+    llvm::SmallVector<M::Block *, 64> LiveInBlockWorklist(
+        Info.usingBlocks.begin(), Info.usingBlocks.end());
+
+    // If any of the using blocks is also a definition block, check to see if
+    // the definition occurs before or after the use.  If it happens before the
+    // use, the value isn't really live-in.
+    for (unsigned i = 0, e = LiveInBlockWorklist.size(); i != e; ++i) {
+      M::Block *BB = LiveInBlockWorklist[i];
+      if (!DefBlocks.count(BB))
+        continue;
+
+      // Okay, this is a block that both uses and defines the value.  If the
+      // first reference to the alloca is a def (store), then we know it isn't
+      // live-in.
+      for (M::Block::iterator I = BB->begin();; ++I) {
+        if (STORE SI = M::dyn_cast<STORE>(I)) {
+          if (SI.getOperand(1)->getDefiningOp() != AI)
+            continue;
+
+          // We found a store to the alloca before a load.  The alloca is not
+          // actually live-in here.
+          LiveInBlockWorklist[i] = LiveInBlockWorklist.back();
+          LiveInBlockWorklist.pop_back();
+          --i;
+          --e;
+          break;
+        }
+
+        if (auto LI = M::dyn_cast<LOAD>(I))
+          // Okay, we found a load before a store to the alloca.  It is actually
+          // live into this block.
+          if (LI.getOperand()->getDefiningOp() == AI)
+            break;
+      }
+    }
+
+    // Now that we have a set of blocks where the phi is live-in, recursively
+    // add their predecessors until we find the full region the value is live.
+    while (!LiveInBlockWorklist.empty()) {
+      M::Block *BB = LiveInBlockWorklist.pop_back_val();
+
+      // The block really is live in here, insert it into the set.  If already
+      // in the set, then it has already been processed.
+      if (!liveInBlks.insert(BB).second)
+        continue;
+
+      // Since the value is live into BB, it is either defined in a predecessor
+      // or live into it to.  Add the preds to the worklist unless they are a
+      // defining block.
+      for (M::Block *P : BB->getPredecessors()) {
+        // The value is not live into a predecessor if it defines the value.
+        if (DefBlocks.count(P))
+          continue;
+
+        // Otherwise it is, add to the worklist.
+        LiveInBlockWorklist.push_back(P);
+      }
+    }
+  }
+
+  bool addBlockArgument(M::Block *BB, ALLOCA &Alloca, unsigned allocaNum) {
+    auto *ae = Alloca.getOperation();
+    auto key = std::make_pair(BB, ae);
+    auto argNoIter = BlockArgs.find(key);
+    if (argNoIter != BlockArgs.end())
+      return false;
+    auto argNo = BB->getNumArguments();
+    BB->addArgument(Alloca.getAllocatedType());
+    BlockArgs[key] = argNo;
+    argToAllocaMap[std::make_pair(BB, argNo)] = allocaNum;
+    return true;
+  }
+
+  template <typename A>
+  void initOperands(std::vector<M::Value *> &opers, M::Location &&loc,
+                    M::Block *dest, unsigned size, unsigned ai, M::Value *val,
+                    A &&oldOpers) {
+    unsigned i = 0;
+    for (auto v : oldOpers)
+      opers[i++] = v;
+
+    // we must fill additional args with temporary undef values
+    for (; i < size; ++i) {
+      if (i == ai)
+        continue;
+      auto opTy = dest->getArgument(i)->getType();
+      auto typedUndef = builder->create<UNDEF>(loc, opTy);
+      opers[i] = typedUndef;
+    }
+    opers[ai] = val;
+  }
+
+  static void eraseIfNoUse(M::Value *val) {
+    if (val->use_begin() == val->use_end()) {
+      val->getDefiningOp()->erase();
+    }
+  }
+
+  /// Set the incoming value on the branch side for the `ai`th block argument
+  void setParam(M::Block *blk, unsigned ai, M::Value *val, M::Block *target,
+                unsigned size) {
+    auto *term = blk->getTerminator();
+    if (auto br = M::dyn_cast<M::BranchOp>(term)) {
+      if (br.getNumOperands() <= ai) {
+        // construct a new BranchOp to replace term
+        std::vector<M::Value *> opers(size);
+        auto *dest = br.getDest();
+        builder->setInsertionPoint(term);
+        initOperands(opers, br.getLoc(), dest, size, ai, val, br.getOperands());
+        builder->create<M::BranchOp>(br.getLoc(), dest, opers);
+        br.erase();
+      } else {
+        auto *oldParam = br.getOperand(ai);
+        br.setOperand(ai, val);
+        eraseIfNoUse(oldParam);
+      }
+    } else if (auto cond = M::dyn_cast<M::CondBranchOp>(term)) {
+      if (target == cond.getTrueDest()) {
+        if (cond.getNumTrueOperands() <= ai) {
+          // construct a new CondBranchOp to replace term
+          std::vector<M::Value *> opers(size);
+          auto *dest = cond.getTrueDest();
+          builder->setInsertionPoint(term);
+          initOperands(opers, cond.getLoc(), dest, size, ai, val,
+                       cond.getTrueOperands());
+          auto *c = cond.getCondition();
+          auto *othDest = cond.getFalseDest();
+          std::vector<M::Value *> othOpers(cond.false_operand_begin(),
+                                           cond.false_operand_end());
+          builder->create<M::CondBranchOp>(cond.getLoc(), c, dest, opers,
+                                           othDest, othOpers);
+          cond.erase();
+        } else {
+          auto *oldParam = cond.getTrueOperand(ai);
+          cond.setTrueOperand(ai, val);
+          eraseIfNoUse(oldParam);
+        }
+      } else {
+        if (cond.getNumFalseOperands() <= ai) {
+          // construct a new CondBranchOp to replace term
+          std::vector<M::Value *> opers(size);
+          auto *dest = cond.getFalseDest();
+          builder->setInsertionPoint(term);
+          initOperands(opers, cond.getLoc(), dest, size, ai, val,
+                       cond.getFalseOperands());
+          auto *c = cond.getCondition();
+          auto *othDest = cond.getTrueDest();
+          std::vector<M::Value *> othOpers(cond.true_operand_begin(),
+                                           cond.true_operand_end());
+          builder->create<M::CondBranchOp>(cond.getLoc(), c, othDest, othOpers,
+                                           dest, opers);
+          cond.erase();
+        } else {
+          auto *oldParam = cond.getFalseOperand(ai);
+          cond.setFalseOperand(ai, val);
+          eraseIfNoUse(oldParam);
+        }
+      }
+    } else {
+      assert(false && "unhandled terminator");
+    }
+  }
+
+  inline static void addValue(RenamePassData::ValVector &vector,
+                              RenamePassData::ValVector::size_type size,
+                              M::Value *value) {
+    if (vector.size() < size + 1)
+      vector.resize(size + 1);
+    vector[size] = value;
+  }
+
+  /// Recursively traverse the CFG of the function, renaming loads and
+  /// stores to the allocas which we are promoting.
+  ///
+  /// IncomingVals indicates what value each Alloca contains on exit from the
+  /// predecessor block Pred.
+  void renamePass(M::Block *BB, M::Block *Pred,
+                  RenamePassData::ValVector &IncomingVals,
+                  std::vector<RenamePassData> &Worklist) {
+  NextIteration:
+    // Does this block take arguments?
+    if ((!BB->hasNoPredecessors()) && (BB->getNumArguments() > 0)) {
+      // add the values from block `Pred` to the argument list in the proper
+      // positions
+      for (unsigned ai = 0, AI = BB->getNumArguments(); ai != AI; ++ai) {
+        auto allocaNo = argToAllocaMap[std::make_pair(BB, ai)];
+        setParam(Pred, ai, IncomingVals[allocaNo], BB, AI);
+        // use the block argument, not the live def in the pred block
+        addValue(IncomingVals, allocaNo, BB->getArgument(ai));
+      }
+    }
+
+    // Don't revisit blocks.
+    if (!Visited.insert(BB).second)
+      return;
+
+    M::Block::iterator II = BB->begin();
+    while (true) {
+      if (II == BB->end())
+        break;
+      M::Operation &opn = *II;
+      II++;
+
+      if (auto LI = M::dyn_cast<LOAD>(opn)) {
+        auto *srcOpn = LI.getOperand()->getDefiningOp();
+        if (!srcOpn)
+          continue;
+
+        auto Src = M::dyn_cast<ALLOCA>(srcOpn);
+        if (!Src)
+          continue;
+
+        llvm::DenseMap<M::Operation *, unsigned>::iterator AI =
+            allocaLookup.find(srcOpn);
+        if (AI == allocaLookup.end())
+          continue;
+
+        M::Value *V = IncomingVals[AI->second];
+
+        // Anything using the load now uses the current value.
+        LI.replaceAllUsesWith(V);
+        LI.erase();
+      } else if (auto SI = M::dyn_cast<STORE>(opn)) {
+        auto *dstOpn = SI.getOperand(1)->getDefiningOp();
+        if (!dstOpn)
+          continue;
+
+        // Delete this instruction and mark the name as the current holder of
+        // the value
+        auto Dest = M::dyn_cast<ALLOCA>(dstOpn);
+        if (!Dest)
+          continue;
+
+        llvm::DenseMap<M::Operation *, unsigned>::iterator ai =
+            allocaLookup.find(dstOpn);
+        if (ai == allocaLookup.end())
+          continue;
+
+        // what value were we writing?
+        unsigned AllocaNo = ai->second;
+        addValue(IncomingVals, AllocaNo, SI.getOperand(0));
+        SI.erase();
+      }
+    }
+
+    // 'Recurse' to our successors.
+    auto I = BB->succ_begin();
+    auto E = BB->succ_end();
+    if (I == E)
+      return;
+
+    // Keep track of the successors so we don't visit the same successor twice
+    llvm::SmallPtrSet<M::Block *, 8> VisitedSuccs;
+
+    // Handle the first successor without using the worklist.
+    VisitedSuccs.insert(*I);
+    Pred = BB;
+    BB = *I;
+    ++I;
+
+    for (; I != E; ++I)
+      if (VisitedSuccs.insert(*I).second)
+        Worklist.emplace_back(*I, Pred, IncomingVals);
+    goto NextIteration;
+  }
+
+  void doPromotion() {
+    auto F = this->getFunction();
+    std::vector<ALLOCA> aes;
+    AllocaInfo<LOAD, STORE, ALLOCA> info;
+    LargeBlockInfo<LOAD, STORE, ALLOCA> lbi;
+    ForwardIDFCalculator IDF(*domTree);
+
+    assert(!allocas.empty());
+
+    for (unsigned allocaNum = 0, End = allocas.size(); allocaNum != End;
+         ++allocaNum) {
+      auto ae = allocas[allocaNum];
+      assert(ae.template getParentOfType<M::FuncOp>() == F);
+      if (ae.use_empty()) {
+        ae.erase();
+        continue;
+      }
+      info.analyzeAlloca(ae);
+      builder->setInsertionPointToStart(&F.front());
+      if (info.definingBlocks.size() == 1)
+        if (rewriteSingleStoreAlloca(ae, info, lbi))
+          continue;
+      if (info.onlyUsedInOneBlock)
+        if (promoteSingleBlockAlloca(ae, info, lbi))
+          continue;
+
+      // If we haven't computed a numbering for the BB's in the function, do
+      // so now.
+      if (BBNumbers.empty()) {
+        unsigned ID = 0;
+        for (auto &BB : F)
+          BBNumbers[&BB] = ID++;
+      }
+
+      // Keep the reverse mapping of the 'Allocas' array for the rename pass.
+      allocaLookup[allocas[allocaNum].getOperation()] = allocaNum;
+
+      // At this point, we're committed to promoting the alloca using IDF's,
+      // and the standard SSA construction algorithm.  Determine which blocks
+      // need PHI nodes and see if we can optimize out some work by avoiding
+      // insertion of dead phi nodes.
+
+      // Unique the set of defining blocks for efficient lookup.
+      llvm::SmallPtrSet<M::Block *, 32> DefBlocks(info.definingBlocks.begin(),
+                                                  info.definingBlocks.end());
+
+      // Determine which blocks the value is live in.  These are blocks which
+      // lead to uses.
+      llvm::SmallPtrSet<M::Block *, 32> liveInBlks;
+      computeLiveInBlocks(ae, info, DefBlocks, liveInBlks);
+
+      // At this point, we're committed to promoting the alloca using IDF's,
+      // and the standard SSA construction algorithm.  Determine which blocks
+      // need phi nodes and see if we can optimize out some work by avoiding
+      // insertion of dead phi nodes.
+      IDF.setLiveInBlocks(liveInBlks);
+      IDF.setDefiningBlocks(DefBlocks);
+      llvm::SmallVector<M::Block *, 32> PHIBlocks;
+      IDF.calculate(PHIBlocks);
+      llvm::sort(PHIBlocks, [this](M::Block *A, M::Block *B) {
+        return BBNumbers.find(A)->second < BBNumbers.find(B)->second;
+      });
+
+      for (M::Block *BB : PHIBlocks)
+        addBlockArgument(BB, ae, allocaNum);
+
+      aes.push_back(ae);
+    }
+
+    std::swap(allocas, aes);
+    if (allocas.empty())
+      return;
+
+    lbi.clear();
+
+    // Set the incoming values for the basic block to be null values for all
+    // of the alloca's.  We do this in case there is a load of a value that
+    // has not been stored yet.  In this case, it will get this null value.
+    RenamePassData::ValVector Values(allocas.size());
+    for (unsigned i = 0, e = allocas.size(); i != e; ++i)
+      Values[i] = builder->create<UNDEF>(allocas[i].getLoc(),
+                                         allocas[i].getAllocatedType());
+
+    // Walks all basic blocks in the function performing the SSA rename
+    // algorithm and inserting the phi nodes we marked as necessary
+    std::vector<RenamePassData> renameWorklist;
+    renameWorklist.emplace_back(&F.front(), nullptr, Values);
+    do {
+      RenamePassData RPD(std::move(renameWorklist.back()));
+      renameWorklist.pop_back();
+      // renamePass may add new worklist entries.
+      renamePass(RPD.BB, RPD.Pred, RPD.Values, renameWorklist);
+    } while (!renameWorklist.empty());
+
+    // The renamer uses the Visited set to avoid infinite loops.  Clear it
+    // now.
+    Visited.clear();
+
+    // Remove the allocas themselves from the function.
+    for (auto aa : allocas) {
+      M::Operation *A = aa.getOperation();
+      // If there are any uses of the alloca instructions left, they must be
+      // in unreachable basic blocks that were not processed by walking the
+      // dominator tree. Just delete the users now.
+      if (!A->use_empty()) {
+        auto undef = builder->create<UNDEF>(aa.getLoc(), aa.getType());
+        aa.replaceAllUsesWith(undef.getResult());
+      }
+      aa.erase();
+    }
+  }
+
+  /// run the MemToReg pass on the FIR dialect
+  void runOnFunction() override {
+    auto f = this->getFunction();
+    auto &entry = f.front();
+    auto bldr = M::OpBuilder(f.getBody());
+
+    domTree = &this->template getAnalysis<DominatorTree>();
+    builder = &bldr;
+
+    while (true) {
+      allocas.clear();
+
+      for (auto &op : entry)
+        if (ALLOCA ae = M::dyn_cast<ALLOCA>(op))
+          if (isAllocaPromotable<LOAD, STORE>(ae))
+            allocas.push_back(ae);
+
+      if (allocas.empty())
+        break;
+
+      doPromotion();
+    }
+
+    domTree = nullptr;
+    builder = nullptr;
+  }
+};
+
+} // namespace
+
+std::unique_ptr<M::OpPassBase<M::FuncOp>> fir::createMemToRegPass() {
+  return std::make_unique<MemToReg<LoadOp, StoreOp, AllocaOp, UndefOp>>();
+}
diff --git a/lib/fir/Type.cpp b/lib/fir/Type.cpp
new file mode 100644
index 000000000000..57b36a1620d4
--- /dev/null
+++ b/lib/fir/Type.cpp
@@ -0,0 +1,1652 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/Type.h"
+#include "fir/Dialect.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/Parser.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace L = llvm;
+namespace M = mlir;
+
+using namespace fir;
+
+namespace {
+
+// Tokens
+
+enum class TokenKind {
+  error,
+  eof,
+  leftang,
+  rightang,
+  leftparen,
+  rightparen,
+  leftbrace,
+  rightbrace,
+  leftbracket,
+  rightbracket,
+  colon,
+  comma,
+  period,
+  eroteme,
+  ecphoneme,
+  star,
+  arrow,
+  ident,
+  string,
+  intlit,
+};
+
+struct Token {
+  TokenKind kind;
+  L::StringRef text;
+};
+
+// Lexer
+
+class Lexer {
+public:
+  Lexer(L::StringRef source) : srcBuff{source}, srcPtr{source.begin()} {}
+
+  // consume and return next token from the input. input is advanced to after
+  // the token.
+  Token lexToken();
+
+  int nextNonWSChar() {
+    skipWhitespace();
+    if (atEnd())
+      return -1;
+    return *srcPtr++;
+  }
+
+  // peek ahead to the next non-whitespace character, leaving it on the input
+  // stream
+  char nextChar() {
+    skipWhitespace();
+    if (atEnd())
+      return '\0';
+    return *srcPtr;
+  }
+
+  // advance the input stream `count` characters
+  void advance(unsigned count = 1) {
+    while (count--) {
+      if (atEnd())
+        break;
+      ++srcPtr;
+    }
+  }
+
+  const char *getMarker() { return srcPtr; }
+
+  L::StringRef getNextType() {
+    char const *const marker = srcPtr;
+    L::SmallVector<char, 8> nestedPunc;
+    for (bool scanning = true; scanning && !atEnd(); ++srcPtr) {
+      char c = *srcPtr;
+      switch (c) {
+      case '<':
+      case '[':
+      case '(':
+      case '{':
+        nestedPunc.push_back(c);
+        break;
+      case '>':
+        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '<') {
+          goto done;
+        }
+        continue;
+      case ']':
+        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '[') {
+          goto done;
+        }
+        continue;
+      case ')':
+        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '(') {
+          goto done;
+        }
+        continue;
+      case '}':
+        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '{') {
+          goto done;
+        }
+        continue;
+      case ',':
+        if (nestedPunc.empty()) {
+          goto done;
+        }
+        continue;
+      case '-':
+        if ((srcPtr + 1 != srcBuff.end()) && *(srcPtr + 1) == '>') {
+          ++srcPtr;
+        }
+        continue;
+      done:
+        --srcPtr;
+        [[fallthrough]];
+      case '\0': {
+        scanning = false;
+      } break;
+      default:
+        break;
+      }
+    }
+    std::size_t count = srcPtr - marker;
+    return {marker, count};
+  }
+
+private:
+  void skipWhitespace() {
+    while (!atEnd()) {
+      switch (*srcPtr) {
+      case ' ':
+      case '\f':
+      case '\n':
+      case '\r':
+      case '\t':
+      case '\v':
+        ++srcPtr;
+        continue;
+      default:
+        break;
+      }
+      break;
+    }
+  }
+
+  Token formToken(TokenKind kind, const char *tokStart) {
+    return Token{kind, L::StringRef(tokStart, srcPtr - tokStart)};
+  }
+
+  Token emitError(const char *loc, const L::Twine &message) {
+    return formToken(TokenKind::error, loc);
+  }
+
+  bool atEnd() const { return srcPtr == srcBuff.end(); }
+
+  Token lexIdent(const char *tokStart);
+  Token lexNumber(const char *tokStart);
+  Token lexString(const char *tokStart);
+
+  L::StringRef srcBuff;
+  const char *srcPtr;
+};
+
+Token Lexer::lexToken() {
+  skipWhitespace();
+  if (atEnd()) {
+    return formToken(TokenKind::eof, "");
+  }
+
+  const char *tokStart = srcPtr;
+  switch (*srcPtr++) {
+  case '<':
+    return formToken(TokenKind::leftang, tokStart);
+  case '>':
+    return formToken(TokenKind::rightang, tokStart);
+  case '{':
+    return formToken(TokenKind::leftbrace, tokStart);
+  case '}':
+    return formToken(TokenKind::rightbrace, tokStart);
+  case '[':
+    return formToken(TokenKind::leftbracket, tokStart);
+  case ']':
+    return formToken(TokenKind::rightbracket, tokStart);
+  case '(':
+    return formToken(TokenKind::leftparen, tokStart);
+  case ')':
+    return formToken(TokenKind::rightparen, tokStart);
+  case ':':
+    return formToken(TokenKind::colon, tokStart);
+  case ',':
+    return formToken(TokenKind::comma, tokStart);
+  case '"':
+    return lexString(tokStart + 1);
+  case '-':
+    if (*srcPtr == '>') {
+      srcPtr++;
+      return formToken(TokenKind::arrow, tokStart);
+    }
+    return lexNumber(tokStart);
+  case '+':
+    return lexNumber(tokStart + 1);
+  case '!':
+    return formToken(TokenKind::ecphoneme, tokStart);
+  case '?':
+    return formToken(TokenKind::eroteme, tokStart);
+  case '*':
+    return formToken(TokenKind::star, tokStart);
+  case '.':
+    return formToken(TokenKind::period, tokStart);
+  default:
+    if (std::isalpha(*tokStart)) {
+      return lexIdent(tokStart);
+    }
+    if (std::isdigit(*tokStart)) {
+      return lexNumber(tokStart);
+    }
+    return emitError(tokStart, "unexpected character");
+  }
+}
+
+Token Lexer::lexString(const char *tokStart) {
+  while (!atEnd() && *srcPtr != '"') {
+    ++srcPtr;
+  }
+  Token token{formToken(TokenKind::string, tokStart)};
+  ++srcPtr;
+  return token;
+}
+
+Token Lexer::lexIdent(const char *tokStart) {
+  while (!atEnd() && (std::isalnum(*srcPtr) || *srcPtr == '_')) {
+    ++srcPtr;
+  }
+  return formToken(TokenKind::ident, tokStart);
+}
+
+Token Lexer::lexNumber(const char *tokStart) {
+  while (!atEnd() && std::isdigit(*srcPtr)) {
+    ++srcPtr;
+  }
+  return formToken(TokenKind::intlit, tokStart);
+}
+
+class auto_counter {
+public:
+  explicit auto_counter(int &ref) : counter(ref) { ++counter; }
+  ~auto_counter() { --counter; }
+
+private:
+  auto_counter() = delete;
+  auto_counter(const auto_counter &) = delete;
+  int &counter;
+};
+
+/// A FIROpsDialect instance uses a FIRTypeParser object to parse and
+/// instantiate all FIR types from .fir files.
+class FIRTypeParser {
+public:
+  FIRTypeParser(FIROpsDialect *dialect, L::StringRef rawData, M::Location loc)
+      : context{dialect->getContext()}, lexer{rawData}, loc{loc} {}
+
+  M::Type parseType();
+
+protected:
+  inline void emitError(M::Location loc, const L::Twine &msg) {
+    M::emitError(loc, msg);
+  }
+
+  bool consumeToken(TokenKind tk, const L::Twine &msg) {
+    auto token = lexer.lexToken();
+    if (token.kind != tk) {
+      emitError(loc, msg);
+      return true; // error!
+    }
+    return false;
+  }
+
+  bool consumeChar(char ch, const L::Twine &msg) {
+    auto lexCh = lexer.nextChar();
+    if (lexCh != ch) {
+      emitError(loc, msg);
+      return true; // error!
+    }
+    lexer.advance();
+    return false;
+  }
+
+  template <typename A>
+  A parseIntLitSingleton(const char *msg) {
+    if (consumeToken(TokenKind::leftang, "expected '<' in type")) {
+      return {};
+    }
+    auto token{lexer.lexToken()};
+    if (token.kind != TokenKind::intlit) {
+      emitError(loc, msg);
+      return {};
+    }
+    KindTy kind;
+    if (token.text.getAsInteger(0, kind)) {
+      emitError(loc, "expected integer constant");
+      return {};
+    }
+    if (consumeToken(TokenKind::rightang, "expected '>' in type")) {
+      return {};
+    }
+    if (checkAtEnd())
+      return {};
+    return A::get(getContext(), kind);
+  }
+
+  // `<` kind `>`
+  template <typename A>
+  A parseKindSingleton() {
+    return parseIntLitSingleton<A>("expected kind parameter");
+  }
+
+  // `<` rank `>`
+  template <typename A>
+  A parseRankSingleton() {
+    return parseIntLitSingleton<A>("expected rank parameter");
+  }
+
+  // '<' type '>'
+  template <typename A>
+  A parseTypeSingleton() {
+    if (consumeToken(TokenKind::leftang, "expected '<' in type")) {
+      return {};
+    }
+    auto ofTy = parseNextType();
+    if (!ofTy) {
+      emitError(loc, "expected type parameter");
+      return {};
+    }
+    if (consumeToken(TokenKind::rightang, "expected '>' in type")) {
+      return {};
+    }
+    if (checkAtEnd())
+      return {};
+    return A::get(ofTy);
+  }
+
+  M::Type parseNextType();
+
+  bool checkAtEnd() {
+    if (!recursiveCall) {
+      auto token = lexer.lexToken();
+      if (token.kind != TokenKind::eof) {
+        emitError(loc, "unexpected extra characters");
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // `box` `<` type (',' affine-map)? `>`
+  BoxType parseBox() {
+    if (consumeToken(TokenKind::leftang, "expected '<' in type")) {
+      return {};
+    }
+    auto ofTy = parseNextType();
+    if (!ofTy) {
+      emitError(loc, "expected type parameter");
+      return {};
+    }
+    auto token = lexer.lexToken();
+    M::AffineMapAttr map;
+    if (token.kind == TokenKind::comma) {
+      map = parseAffineMapAttr();
+      token = lexer.lexToken();
+    }
+    if (token.kind != TokenKind::rightang) {
+      emitError(loc, "expected '>' in type");
+      return {};
+    }
+    if (checkAtEnd())
+      return {};
+    return BoxType::get(ofTy, map);
+  }
+
+  // `boxchar` `<` kind `>`
+  BoxCharType parseBoxChar() { return parseKindSingleton<BoxCharType>(); }
+
+  // `boxproc` `<` return-type `>`
+  BoxProcType parseBoxProc() { return parseTypeSingleton<BoxProcType>(); }
+
+  // `char` `<` kind `>`
+  CharacterType parseCharacter() { return parseKindSingleton<CharacterType>(); }
+
+  // `dims` `<` rank `>`
+  DimsType parseDims() { return parseRankSingleton<DimsType>(); }
+
+  // `field`
+  FieldType parseField() {
+    if (checkAtEnd())
+      return {};
+    return FieldType::get(getContext());
+  }
+
+  // `logical` `<` kind `>`
+  LogicalType parseLogical() { return parseKindSingleton<LogicalType>(); }
+
+  // `int` `<` kind `>`
+  IntType parseInteger() { return parseKindSingleton<IntType>(); }
+
+  // `complex` `<` kind `>`
+  CplxType parseComplex() { return parseKindSingleton<CplxType>(); }
+
+  // `real` `<` kind `>`
+  RealType parseReal() { return parseKindSingleton<RealType>(); }
+
+  // `ref` `<` type `>`
+  ReferenceType parseReference() { return parseTypeSingleton<ReferenceType>(); }
+
+  // `ptr` `<` type `>`
+  PointerType parsePointer() { return parseTypeSingleton<PointerType>(); }
+
+  // `heap` `<` type `>`
+  HeapType parseHeap() { return parseTypeSingleton<HeapType>(); }
+
+  SequenceType::Shape parseShape();
+  SequenceType parseSequence();
+
+  RecordType::TypeList parseTypeList();
+  RecordType::TypeList parseLenParamList();
+  RecordType parseDerived();
+  RecordType verifyDerived(RecordType derivedTy,
+                           llvm::ArrayRef<RecordType::TypePair> lenPList,
+                           llvm::ArrayRef<RecordType::TypePair> typeList);
+
+  // `tdesc` `<` type `>`
+  TypeDescType parseTypeDesc() { return parseTypeSingleton<TypeDescType>(); }
+
+  // `void`
+  M::Type parseVoid() {
+    if (checkAtEnd())
+      return {};
+    return M::TupleType::get(getContext());
+  }
+
+  M::MLIRContext *getContext() const { return context; }
+
+  M::AffineMapAttr parseAffineMapAttr();
+
+private:
+  M::MLIRContext *context;
+  Lexer lexer;
+  M::Location loc;
+  int recursiveCall{-1};
+};
+
+// If this is a `!fir.x` type then recursively parse it now, otherwise figure
+// out its extent and call into the standard type parser.
+M::Type FIRTypeParser::parseNextType() {
+  return M::parseType(lexer.getNextType(), getContext());
+}
+
+// Parses either `*` `:`
+//            or (int | `?`) (`x` (int | `?`))* `:`
+SequenceType::Shape FIRTypeParser::parseShape() {
+  SequenceType::Bounds bounds;
+  int extent;
+  int nextChar;
+  Token token = lexer.lexToken();
+  if (token.kind == TokenKind::star) {
+    token = lexer.lexToken();
+    if (token.kind != TokenKind::colon) {
+      emitError(loc, "expected '*' to be followed by ':'");
+      return {};
+    }
+    return SequenceType::Shape();
+  }
+  while (true) {
+    if (token.kind != TokenKind::eroteme) {
+      goto shape_spec;
+    }
+    bounds.emplace_back(SequenceType::Extent());
+    goto check_xchar;
+  shape_spec:
+    if (token.kind != TokenKind::intlit) {
+      emitError(loc, "expected an integer or '?' in shape specification");
+      return {};
+    }
+    token.text.getAsInteger(10, extent);
+    bounds.emplace_back(extent);
+  check_xchar:
+    nextChar = lexer.nextNonWSChar();
+    if (nextChar == ':') {
+      return SequenceType::Shape(bounds);
+    }
+    if (nextChar != 'x') {
+      emitError(loc, "expected an 'x' or ':' after integer");
+      return {};
+    }
+    token = lexer.lexToken();
+  }
+}
+
+// affine-map ::= `#` ident
+M::AffineMapAttr FIRTypeParser::parseAffineMapAttr() {
+  return {}; // FIXME opParser->parseAttr();
+}
+
+// bounds ::= lo extent stride | `?`
+// `array` `<` bounds (`,` bounds)* `:` type (',' affine-map)? `>`
+SequenceType FIRTypeParser::parseSequence() {
+  if (consumeToken(TokenKind::leftang, "expected '<' in array type")) {
+    return {};
+  }
+  auto shape = parseShape();
+  M::Type eleTy = parseNextType();
+  if (!eleTy) {
+    emitError(loc, "invalid element type");
+    return {};
+  }
+  auto token = lexer.lexToken();
+  M::AffineMapAttr map;
+  if (token.kind == TokenKind::comma) {
+    map = parseAffineMapAttr();
+    token = lexer.lexToken();
+  }
+  if (token.kind != TokenKind::rightang) {
+    emitError(loc, "expected '>' in array type");
+    return {};
+  }
+  if (checkAtEnd()) {
+    return {};
+  }
+  return SequenceType::get(shape, eleTy, map);
+}
+
+// Parses: string `:` type (',' string `:` type)* '}'
+RecordType::TypeList FIRTypeParser::parseTypeList() {
+  RecordType::TypeList result;
+  while (true) {
+    auto name{lexer.lexToken()};
+    if (name.kind != TokenKind::ident) {
+      emitError(loc, "expected identifier");
+      return {};
+    }
+    if (consumeToken(TokenKind::colon, "expected colon")) {
+      return {};
+    }
+    auto memTy{parseNextType()};
+    result.emplace_back(name.text, memTy);
+    auto token{lexer.lexToken()};
+    if (token.kind == TokenKind::rightbrace) {
+      return result;
+    }
+    if (token.kind != TokenKind::comma) {
+      emitError(loc, "expected ','");
+      return {};
+    }
+  }
+}
+
+// Parses: string `:` int-type (',' string `:` int-type)* ')'
+RecordType::TypeList FIRTypeParser::parseLenParamList() {
+  RecordType::TypeList result;
+  while (true) {
+    auto name{lexer.lexToken()};
+    if (name.kind != TokenKind::ident) {
+      emitError(loc, "expected identifier");
+      return {};
+    }
+    if (consumeToken(TokenKind::colon, "expected colon")) {
+      return {};
+    }
+    auto memTy{parseNextType()};
+    result.emplace_back(name.text, memTy);
+    auto token{lexer.lexToken()};
+    if (token.kind == TokenKind::rightparen) {
+      return result;
+    }
+    if (token.kind != TokenKind::comma) {
+      emitError(loc, "expected ','");
+      return {};
+    }
+  }
+}
+
+bool verifyIntegerType(M::Type ty) {
+  return ty.dyn_cast<M::IntegerType>() || ty.dyn_cast<IntType>();
+}
+
+bool verifyRecordMemberType(M::Type ty) {
+  return !(ty.dyn_cast<BoxType>() || ty.dyn_cast<BoxCharType>() ||
+           ty.dyn_cast<BoxProcType>() || ty.dyn_cast<DimsType>() ||
+           ty.dyn_cast<FieldType>() || ty.dyn_cast<ReferenceType>() ||
+           ty.dyn_cast<TypeDescType>());
+}
+
+bool verifySameLists(L::ArrayRef<RecordType::TypePair> a1,
+                     L::ArrayRef<RecordType::TypePair> a2) {
+  if (a1.size() != a2.size())
+    return false;
+  auto iter = a1.begin();
+  for (auto lp : a2) {
+    if (!((iter->first == lp.first) && (iter->second == lp.second)))
+      return false;
+    ++iter;
+  }
+  return true;
+}
+
+RecordType
+FIRTypeParser::verifyDerived(RecordType derivedTy,
+                             L::ArrayRef<RecordType::TypePair> lenPList,
+                             L::ArrayRef<RecordType::TypePair> typeList) {
+  if (!verifySameLists(derivedTy.getLenParamList(), lenPList) ||
+      !verifySameLists(derivedTy.getTypeList(), typeList)) {
+    emitError(loc, "cannot redefine record type members");
+    return {};
+  }
+  for (auto &p : lenPList)
+    if (!verifyIntegerType(p.second)) {
+      emitError(loc, "LEN parameter must be integral type");
+      return {};
+    }
+  for (auto &p : typeList)
+    if (!verifyRecordMemberType(p.second)) {
+      emitError(loc, "field parameter has invalid type");
+      return {};
+    }
+  llvm::StringSet<> uniq;
+  for (auto &p : lenPList)
+    if (!uniq.insert(p.first).second) {
+      emitError(loc, "LEN parameter cannot have duplicate name");
+      return {};
+    }
+  for (auto &p : typeList)
+    if (!uniq.insert(p.first).second) {
+      emitError(loc, "field cannot have duplicate name");
+      return {};
+    }
+  return derivedTy;
+}
+
+// Fortran derived type
+// `type` `<` name
+//           (`(` id `:` type (`,` id `:` type)* `)`)?
+//           (`{` id `:` type (`,` id `:` type)* `}`)? '>'
+RecordType FIRTypeParser::parseDerived() {
+  if (consumeToken(TokenKind::leftang, "expected '<' in type type")) {
+    return {};
+  }
+  auto name{lexer.lexToken()};
+  if (name.kind != TokenKind::ident) {
+    emitError(loc, "expected a identifier as name of derived type");
+    return {};
+  }
+  RecordType result = RecordType::get(getContext(), name.text);
+  auto token = lexer.lexToken();
+  RecordType::TypeList lenParamList;
+  RecordType::TypeList typeList;
+  if (token.kind == TokenKind::leftbrace) {
+    goto parse_fields;
+  } else if (token.kind != TokenKind::leftparen) {
+    // degenerate case?
+    goto check_close;
+  }
+  lenParamList = parseLenParamList();
+  token = lexer.lexToken();
+  if (token.kind != TokenKind::leftbrace) {
+    // no fields?
+    goto check_close;
+  }
+parse_fields:
+  typeList = parseTypeList();
+  token = lexer.lexToken();
+check_close:
+  if (token.kind != TokenKind::rightang) {
+    emitError(loc, "expected '>' in type type");
+    return {};
+  }
+  if (checkAtEnd()) {
+    return {};
+  }
+  if (lenParamList.empty() && typeList.empty())
+    return result;
+  result.finalize(lenParamList, typeList);
+  return verifyDerived(result, lenParamList, typeList);
+}
+
+M::Type FIRTypeParser::parseType() {
+  auto_counter c{recursiveCall};
+  auto token = lexer.lexToken();
+  if (token.kind == TokenKind::ident) {
+    if (token.text == "ref")
+      return parseReference();
+    if (token.text == "array")
+      return parseSequence();
+    if (token.text == "char")
+      return parseCharacter();
+    if (token.text == "logical")
+      return parseLogical();
+    if (token.text == "real")
+      return parseReal();
+    if (token.text == "type")
+      return parseDerived();
+    if (token.text == "box")
+      return parseBox();
+    if (token.text == "boxchar")
+      return parseBoxChar();
+    if (token.text == "boxproc")
+      return parseBoxProc();
+    if (token.text == "ptr")
+      return parsePointer();
+    if (token.text == "heap")
+      return parseHeap();
+    if (token.text == "dims")
+      return parseDims();
+    if (token.text == "tdesc")
+      return parseTypeDesc();
+    if (token.text == "field")
+      return parseField();
+    if (token.text == "int")
+      return parseInteger();
+    if (token.text == "complex")
+      return parseComplex();
+    if (token.text == "void")
+      return parseVoid();
+    emitError(loc, "not a known fir type");
+    return {};
+  }
+  emitError(loc, "invalid token");
+  return {};
+}
+
+// !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
+// is undefined and disallowed.
+bool singleIndirectionLevel(M::Type ty) {
+  return !(ty.dyn_cast<ReferenceType>() || ty.dyn_cast<PointerType>() ||
+           ty.dyn_cast<HeapType>());
+}
+
+} // namespace
+
+namespace fir {
+namespace detail {
+
+// Type storage classes
+
+/// `CHARACTER` storage
+struct CharacterTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static CharacterTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                         KindTy kind) {
+    auto *storage = allocator.allocate<CharacterTypeStorage>();
+    return new (storage) CharacterTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  CharacterTypeStorage() = delete;
+  explicit CharacterTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+struct DimsTypeStorage : public M::TypeStorage {
+  using KeyTy = unsigned;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const {
+    return key == static_cast<unsigned>(getRank());
+  }
+
+  static DimsTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                    int rank) {
+    auto *storage = allocator.allocate<DimsTypeStorage>();
+    return new (storage) DimsTypeStorage{rank};
+  }
+
+  int getRank() const { return rank; }
+
+protected:
+  int rank;
+
+private:
+  DimsTypeStorage() = delete;
+  explicit DimsTypeStorage(int rank) : rank{rank} {}
+};
+
+/// The type of a derived type part reference
+struct FieldTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &) { return L::hash_combine(0); }
+
+  bool operator==(const KeyTy &) const { return true; }
+
+  static FieldTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                     KindTy) {
+    auto *storage = allocator.allocate<FieldTypeStorage>();
+    return new (storage) FieldTypeStorage{0};
+  }
+
+private:
+  FieldTypeStorage() = delete;
+  explicit FieldTypeStorage(KindTy) {}
+};
+
+/// `LOGICAL` storage
+struct LogicalTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static LogicalTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                       KindTy kind) {
+    auto *storage = allocator.allocate<LogicalTypeStorage>();
+    return new (storage) LogicalTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  LogicalTypeStorage() = delete;
+  explicit LogicalTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// `INTEGER` storage
+struct IntTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static IntTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                   KindTy kind) {
+    auto *storage = allocator.allocate<IntTypeStorage>();
+    return new (storage) IntTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  IntTypeStorage() = delete;
+  explicit IntTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// `COMPLEX` storage
+struct CplxTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static CplxTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                    KindTy kind) {
+    auto *storage = allocator.allocate<CplxTypeStorage>();
+    return new (storage) CplxTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  CplxTypeStorage() = delete;
+  explicit CplxTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// `REAL` storage (for reals of unsupported sizes)
+struct RealTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static RealTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                    KindTy kind) {
+    auto *storage = allocator.allocate<RealTypeStorage>();
+    return new (storage) RealTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+protected:
+  KindTy kind;
+
+private:
+  RealTypeStorage() = delete;
+  explicit RealTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// Boxed object (a Fortran descriptor)
+struct BoxTypeStorage : public M::TypeStorage {
+  using KeyTy = std::tuple<M::Type, M::AffineMapAttr>;
+
+  static unsigned hashKey(const KeyTy &key) {
+    auto hashVal{L::hash_combine(std::get<M::Type>(key))};
+    return L::hash_combine(hashVal,
+                           L::hash_combine(std::get<M::AffineMapAttr>(key)));
+  }
+
+  bool operator==(const KeyTy &key) const {
+    return std::get<M::Type>(key) == getElementType() &&
+           std::get<M::AffineMapAttr>(key) == getLayoutMap();
+  }
+
+  static BoxTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                   const KeyTy &key) {
+    auto *storage = allocator.allocate<BoxTypeStorage>();
+    return new (storage)
+        BoxTypeStorage{std::get<M::Type>(key), std::get<M::AffineMapAttr>(key)};
+  }
+
+  M::Type getElementType() const { return eleTy; }
+  M::AffineMapAttr getLayoutMap() const { return map; }
+
+protected:
+  M::Type eleTy;
+  M::AffineMapAttr map;
+
+private:
+  BoxTypeStorage() = delete;
+  explicit BoxTypeStorage(M::Type eleTy, M::AffineMapAttr map)
+      : eleTy{eleTy}, map{map} {}
+};
+
+/// Boxed CHARACTER object type
+struct BoxCharTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getFKind(); }
+
+  static BoxCharTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                       KindTy kind) {
+    auto *storage = allocator.allocate<BoxCharTypeStorage>();
+    return new (storage) BoxCharTypeStorage{kind};
+  }
+
+  KindTy getFKind() const { return kind; }
+
+  // a !fir.boxchar<k> always wraps a !fir.char<k>
+  CharacterType getElementType(M::MLIRContext *ctxt) const {
+    return CharacterType::get(ctxt, getFKind());
+  }
+
+protected:
+  KindTy kind;
+
+private:
+  BoxCharTypeStorage() = delete;
+  explicit BoxCharTypeStorage(KindTy kind) : kind{kind} {}
+};
+
+/// Boxed PROCEDURE POINTER object type
+struct BoxProcTypeStorage : public M::TypeStorage {
+  using KeyTy = M::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static BoxProcTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                       M::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<BoxProcTypeStorage>();
+    return new (storage) BoxProcTypeStorage{eleTy};
+  }
+
+  M::Type getElementType() const { return eleTy; }
+
+protected:
+  M::Type eleTy;
+
+private:
+  BoxProcTypeStorage() = delete;
+  explicit BoxProcTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Pointer-like object storage
+struct ReferenceTypeStorage : public M::TypeStorage {
+  using KeyTy = M::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static ReferenceTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                         M::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<ReferenceTypeStorage>();
+    return new (storage) ReferenceTypeStorage{eleTy};
+  }
+
+  M::Type getElementType() const { return eleTy; }
+
+protected:
+  M::Type eleTy;
+
+private:
+  ReferenceTypeStorage() = delete;
+  explicit ReferenceTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Pointer object storage
+struct PointerTypeStorage : public M::TypeStorage {
+  using KeyTy = M::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static PointerTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                       M::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<PointerTypeStorage>();
+    return new (storage) PointerTypeStorage{eleTy};
+  }
+
+  M::Type getElementType() const { return eleTy; }
+
+protected:
+  M::Type eleTy;
+
+private:
+  PointerTypeStorage() = delete;
+  explicit PointerTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Heap memory reference object storage
+struct HeapTypeStorage : public M::TypeStorage {
+  using KeyTy = M::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getElementType(); }
+
+  static HeapTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                    M::Type eleTy) {
+    assert(eleTy && "element type is null");
+    auto *storage = allocator.allocate<HeapTypeStorage>();
+    return new (storage) HeapTypeStorage{eleTy};
+  }
+
+  M::Type getElementType() const { return eleTy; }
+
+protected:
+  M::Type eleTy;
+
+private:
+  HeapTypeStorage() = delete;
+  explicit HeapTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+};
+
+/// Sequence-like object storage
+struct SequenceTypeStorage : public M::TypeStorage {
+  using KeyTy = std::tuple<SequenceType::Shape, M::Type, M::AffineMapAttr>;
+
+  static unsigned hashKey(const KeyTy &key) {
+    auto shapeHash{hash_value(std::get<SequenceType::Shape>(key))};
+    shapeHash = L::hash_combine(shapeHash, std::get<M::Type>(key));
+    return L::hash_combine(shapeHash, std::get<M::AffineMapAttr>(key));
+  }
+
+  bool operator==(const KeyTy &key) const {
+    return key == KeyTy{getShape(), getElementType(), getLayoutMap()};
+  }
+
+  static SequenceTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                        const KeyTy &key) {
+    auto *storage = allocator.allocate<SequenceTypeStorage>();
+    return new (storage) SequenceTypeStorage{std::get<SequenceType::Shape>(key),
+                                             std::get<M::Type>(key),
+                                             std::get<M::AffineMapAttr>(key)};
+  }
+
+  SequenceType::Shape getShape() const { return shape; }
+  M::Type getElementType() const { return eleTy; }
+  M::AffineMapAttr getLayoutMap() const { return map; }
+
+protected:
+  SequenceType::Shape shape;
+  M::Type eleTy;
+  M::AffineMapAttr map;
+
+private:
+  SequenceTypeStorage() = delete;
+  explicit SequenceTypeStorage(const SequenceType::Shape &shape, M::Type eleTy,
+                               M::AffineMapAttr map)
+      : shape{shape}, eleTy{eleTy}, map{map} {}
+};
+
+/// Derived type storage
+struct RecordTypeStorage : public M::TypeStorage {
+  using KeyTy = L::StringRef;
+
+  static unsigned hashKey(const KeyTy &key) {
+    return L::hash_combine(key.str());
+  }
+
+  bool operator==(const KeyTy &key) const { return key == getName(); }
+
+  static RecordTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                      const KeyTy &key) {
+    auto *storage = allocator.allocate<RecordTypeStorage>();
+    return new (storage) RecordTypeStorage{key};
+  }
+
+  L::StringRef getName() const { return name; }
+
+  void setLenParamList(L::ArrayRef<RecordType::TypePair> list) { lens = list; }
+  L::ArrayRef<RecordType::TypePair> getLenParamList() const { return lens; }
+
+  void setTypeList(L::ArrayRef<RecordType::TypePair> list) { types = list; }
+  L::ArrayRef<RecordType::TypePair> getTypeList() const { return types; }
+
+  void finalize(L::ArrayRef<RecordType::TypePair> lenParamList,
+                L::ArrayRef<RecordType::TypePair> typeList) {
+    if (finalized)
+      return;
+    finalized = true;
+    setLenParamList(lenParamList);
+    setTypeList(typeList);
+  }
+
+protected:
+  std::string name;
+  bool finalized;
+  std::vector<RecordType::TypePair> lens;
+  std::vector<RecordType::TypePair> types;
+
+private:
+  RecordTypeStorage() = delete;
+  explicit RecordTypeStorage(L::StringRef name)
+      : name{name}, finalized{false} {}
+};
+
+/// Type descriptor type storage
+struct TypeDescTypeStorage : public M::TypeStorage {
+  using KeyTy = M::Type;
+
+  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+
+  bool operator==(const KeyTy &key) const { return key == getOfType(); }
+
+  static TypeDescTypeStorage *construct(M::TypeStorageAllocator &allocator,
+                                        M::Type ofTy) {
+    assert(ofTy && "descriptor type is null");
+    auto *storage = allocator.allocate<TypeDescTypeStorage>();
+    return new (storage) TypeDescTypeStorage{ofTy};
+  }
+
+  // The type described by this type descriptor instance
+  M::Type getOfType() const { return ofTy; }
+
+protected:
+  M::Type ofTy;
+
+private:
+  TypeDescTypeStorage() = delete;
+  explicit TypeDescTypeStorage(M::Type ofTy) : ofTy{ofTy} {}
+};
+
+} // namespace detail
+} // namespace fir
+
+template <typename A, typename B>
+bool inbounds(A v, B lb, B ub) {
+  return v >= lb && v < ub;
+}
+
+bool fir::isa_fir_type(mlir::Type t) {
+  return inbounds(t.getKind(), M::Type::FIRST_FIR_TYPE, M::Type::LAST_FIR_TYPE);
+}
+
+bool fir::isa_std_type(mlir::Type t) {
+  return inbounds(t.getKind(), M::Type::FIRST_STANDARD_TYPE,
+                  M::Type::LAST_STANDARD_TYPE);
+}
+
+bool fir::isa_fir_or_std_type(mlir::Type t) {
+  return isa_fir_type(t) || isa_std_type(t);
+}
+
+// CHARACTER
+
+CharacterType fir::CharacterType::get(M::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_CHARACTER, kind);
+}
+
+int fir::CharacterType::getFKind() const { return getImpl()->getFKind(); }
+
+// Dims
+
+DimsType fir::DimsType::get(M::MLIRContext *ctxt, unsigned rank) {
+  return Base::get(ctxt, FIR_DIMS, rank);
+}
+
+int fir::DimsType::getRank() const { return getImpl()->getRank(); }
+
+// Field
+
+FieldType fir::FieldType::get(M::MLIRContext *ctxt, KindTy) {
+  return Base::get(ctxt, FIR_FIELD, 0);
+}
+
+// LOGICAL
+
+LogicalType fir::LogicalType::get(M::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_LOGICAL, kind);
+}
+
+int fir::LogicalType::getFKind() const { return getImpl()->getFKind(); }
+
+// INTEGER
+
+IntType fir::IntType::get(M::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_INT, kind);
+}
+
+int fir::IntType::getFKind() const { return getImpl()->getFKind(); }
+
+// COMPLEX
+
+CplxType fir::CplxType::get(M::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_COMPLEX, kind);
+}
+
+KindTy fir::CplxType::getFKind() const { return getImpl()->getFKind(); }
+
+// REAL
+
+RealType fir::RealType::get(M::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_REAL, kind);
+}
+
+int fir::RealType::getFKind() const { return getImpl()->getFKind(); }
+
+// Box<T>
+
+BoxType fir::BoxType::get(M::Type elementType, M::AffineMapAttr map) {
+  return Base::get(elementType.getContext(), FIR_BOX, elementType, map);
+}
+
+M::Type fir::BoxType::getEleTy() const { return getImpl()->getElementType(); }
+
+M::AffineMapAttr fir::BoxType::getLayoutMap() const {
+  return getImpl()->getLayoutMap();
+}
+
+M::LogicalResult
+fir::BoxType::verifyConstructionInvariants(L::Optional<M::Location>,
+                                           M::MLIRContext *ctx, M::Type eleTy,
+                                           mlir::AffineMapAttr map) {
+  // TODO
+  return M::success();
+}
+
+// BoxChar<C>
+
+BoxCharType fir::BoxCharType::get(M::MLIRContext *ctxt, KindTy kind) {
+  return Base::get(ctxt, FIR_BOXCHAR, kind);
+}
+
+CharacterType fir::BoxCharType::getEleTy() const {
+  return getImpl()->getElementType(getContext());
+}
+
+// BoxProc<T>
+
+BoxProcType fir::BoxProcType::get(M::Type elementType) {
+  return Base::get(elementType.getContext(), FIR_BOXPROC, elementType);
+}
+
+M::Type fir::BoxProcType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+M::LogicalResult fir::BoxProcType::verifyConstructionInvariants(
+    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+  if (eleTy.dyn_cast<M::FunctionType>() || eleTy.dyn_cast<ReferenceType>())
+    return M::success();
+  return M::failure();
+}
+
+// Reference<T>
+
+ReferenceType fir::ReferenceType::get(M::Type elementType) {
+  return Base::get(elementType.getContext(), FIR_REFERENCE, elementType);
+}
+
+M::Type fir::ReferenceType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+M::LogicalResult fir::ReferenceType::verifyConstructionInvariants(
+    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+  if (eleTy.dyn_cast<DimsType>() || eleTy.dyn_cast<FieldType>() ||
+      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
+    return M::failure();
+  return M::success();
+}
+
+// Pointer<T>
+
+PointerType fir::PointerType::get(M::Type elementType) {
+  if (!singleIndirectionLevel(elementType)) {
+    assert(false && "FIXME: invalid element type");
+    return {};
+  }
+  return Base::get(elementType.getContext(), FIR_POINTER, elementType);
+}
+
+M::Type fir::PointerType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+M::LogicalResult fir::PointerType::verifyConstructionInvariants(
+    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
+      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<HeapType>() ||
+      eleTy.dyn_cast<PointerType>() || eleTy.dyn_cast<ReferenceType>() ||
+      eleTy.dyn_cast<TypeDescType>())
+    return M::failure();
+  return M::success();
+}
+
+// Heap<T>
+
+HeapType fir::HeapType::get(M::Type elementType) {
+  if (!singleIndirectionLevel(elementType)) {
+    assert(false && "FIXME: invalid element type");
+    return {};
+  }
+  return Base::get(elementType.getContext(), FIR_HEAP, elementType);
+}
+
+M::Type fir::HeapType::getEleTy() const { return getImpl()->getElementType(); }
+
+M::LogicalResult fir::HeapType::verifyConstructionInvariants(
+    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
+      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<HeapType>() ||
+      eleTy.dyn_cast<PointerType>() || eleTy.dyn_cast<ReferenceType>() ||
+      eleTy.dyn_cast<TypeDescType>())
+    return M::failure();
+  return M::success();
+}
+
+// Sequence<T>
+
+SequenceType fir::SequenceType::get(const Shape &shape, M::Type elementType,
+                                    M::AffineMapAttr map) {
+  auto *ctxt = elementType.getContext();
+  return Base::get(ctxt, FIR_SEQUENCE, shape, elementType, map);
+}
+
+M::Type fir::SequenceType::getEleTy() const {
+  return getImpl()->getElementType();
+}
+
+M::AffineMapAttr fir::SequenceType::getLayoutMap() const {
+  return getImpl()->getLayoutMap();
+}
+
+SequenceType::Shape fir::SequenceType::getShape() const {
+  return getImpl()->getShape();
+}
+
+M::LogicalResult fir::SequenceType::verifyConstructionInvariants(
+    L::Optional<mlir::Location> loc, M::MLIRContext *context,
+    const SequenceType::Shape &shape, M::Type eleTy, M::AffineMapAttr map) {
+  // DIMENSION attribute can only be applied to an intrinsic or record type
+  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
+      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<HeapType>() ||
+      eleTy.dyn_cast<PointerType>() || eleTy.dyn_cast<ReferenceType>() ||
+      eleTy.dyn_cast<TypeDescType>() || eleTy.dyn_cast<SequenceType>())
+    return M::failure();
+  return M::success();
+}
+
+// compare if two shapes are equivalent
+bool fir::operator==(const SequenceType::Shape &sh_1,
+                     const SequenceType::Shape &sh_2) {
+  if (sh_1.hasValue() != sh_2.hasValue()) {
+    return false;
+  }
+  if (!sh_1.hasValue()) {
+    return true;
+  }
+  auto &bnd_1 = *sh_1;
+  auto &bnd_2 = *sh_2;
+  if (bnd_1.size() != bnd_2.size()) {
+    return false;
+  }
+  for (std::size_t i = 0, end = bnd_1.size(); i != end; ++i) {
+    if (bnd_1[i].hasValue() != bnd_2[i].hasValue()) {
+      return false;
+    }
+    if (bnd_1[i].hasValue() && *bnd_1[i] != *bnd_2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// compute the hash of an Extent
+L::hash_code fir::hash_value(const SequenceType::Extent &ext) {
+  return L::hash_combine(ext.hasValue() ? *ext : 0);
+}
+
+// compute the hash of a Shape
+L::hash_code fir::hash_value(const SequenceType::Shape &sh) {
+  if (sh.hasValue()) {
+    return L::hash_combine_range(sh->begin(), sh->end());
+  }
+  return L::hash_combine(0);
+}
+
+/// RecordType
+///
+/// This type captures a Fortran "derived type"
+
+RecordType fir::RecordType::get(M::MLIRContext *ctxt, L::StringRef name) {
+  return Base::get(ctxt, FIR_DERIVED, name);
+}
+
+void fir::RecordType::finalize(L::ArrayRef<TypePair> lenPList,
+                               L::ArrayRef<TypePair> typeList) {
+  getImpl()->finalize(lenPList, typeList);
+}
+
+L::StringRef fir::RecordType::getName() { return getImpl()->getName(); }
+
+RecordType::TypeList fir::RecordType::getTypeList() {
+  return getImpl()->getTypeList();
+}
+
+RecordType::TypeList fir::RecordType::getLenParamList() {
+  return getImpl()->getLenParamList();
+}
+
+detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
+  return getImpl();
+}
+
+M::LogicalResult fir::RecordType::verifyConstructionInvariants(
+    L::Optional<mlir::Location>, M::MLIRContext *context, L::StringRef name) {
+  if (name.size() == 0)
+    return M::failure();
+  return M::success();
+}
+
+/// Type descriptor type
+///
+/// This is the type of a type descriptor object (similar to a class instance)
+
+TypeDescType fir::TypeDescType::get(M::Type ofType) {
+  assert(!ofType.dyn_cast<ReferenceType>());
+  return Base::get(ofType.getContext(), FIR_TYPEDESC, ofType);
+}
+
+M::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
+
+M::LogicalResult fir::TypeDescType::verifyConstructionInvariants(
+    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
+      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<ReferenceType>() ||
+      eleTy.dyn_cast<TypeDescType>())
+    return M::failure();
+  return M::success();
+}
+
+// Implementation of the thin interface from dialect to type parser
+
+M::Type fir::parseFirType(FIROpsDialect *dialect, L::StringRef rawData,
+                          M::Location loc) {
+  FIRTypeParser parser{dialect, rawData, loc};
+  return parser.parseType();
+}
+
+namespace {
+class TypePrinter {
+public:
+  void print(FIROpsDialect *dialect, M::Type ty, llvm::raw_ostream &os) {
+    if (auto type = ty.dyn_cast<fir::ReferenceType>()) {
+      os << "ref<";
+      type.getEleTy().print(os);
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::LogicalType>()) {
+      os << "logical<" << type.getFKind() << '>';
+    } else if (auto type = ty.dyn_cast<fir::RealType>()) {
+      os << "real<" << type.getFKind() << '>';
+    } else if (auto type = ty.dyn_cast<fir::CharacterType>()) {
+      os << "char<" << type.getFKind() << '>';
+    } else if (auto type = ty.dyn_cast<fir::TypeDescType>()) {
+      os << "tdesc<";
+      type.getOfTy().print(os);
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::FieldType>()) {
+      os << "field";
+    } else if (auto type = ty.dyn_cast<fir::BoxType>()) {
+      os << "box<";
+      type.getEleTy().print(os);
+      if (auto map = type.getLayoutMap()) {
+        os << ", ";
+        map.print(os);
+      }
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::BoxCharType>()) {
+      auto eleTy = type.getEleTy().cast<fir::CharacterType>();
+      os << "boxchar<" << eleTy.getFKind() << '>';
+    } else if (auto type = ty.dyn_cast<fir::BoxProcType>()) {
+      os << "boxproc<";
+      type.getEleTy().print(os);
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::DimsType>()) {
+      os << "dims<" << type.getRank() << '>';
+    } else if (auto type = ty.dyn_cast<fir::SequenceType>()) {
+      os << "array";
+      auto shape = type.getShape();
+      if (shape.hasValue()) {
+        printBounds(os, *shape);
+      } else {
+        os << "<*";
+      }
+      os << ':';
+      type.getEleTy().print(os);
+      if (auto map = type.getLayoutMap()) {
+        os << ", ";
+        map.print(os);
+      }
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::HeapType>()) {
+      os << "heap<";
+      type.getEleTy().print(os);
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::PointerType>()) {
+      os << "ptr<";
+      type.getEleTy().print(os);
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::RecordType>()) {
+      os << "type<" << type.getName();
+      if (!recordTypeVisited.count(type.uniqueKey())) {
+        recordTypeVisited.insert(type.uniqueKey());
+        if (type.getLenParamList().size()) {
+          char ch = '(';
+          for (auto p : type.getLenParamList()) {
+            os << ch << p.first << ':';
+            p.second.print(os);
+            ch = ',';
+          }
+          os << ')';
+        }
+        if (type.getTypeList().size()) {
+          char ch = '{';
+          for (auto p : type.getTypeList()) {
+            os << ch << p.first << ':';
+            p.second.print(os);
+            ch = ',';
+          }
+          os << '}';
+        }
+        recordTypeVisited.erase(type.uniqueKey());
+      }
+      os << '>';
+    } else if (auto type = ty.dyn_cast<fir::IntType>()) {
+      os << "int<" << type.getFKind() << '>';
+    } else if (auto type = ty.dyn_cast<fir::CplxType>()) {
+      os << "complex<" << type.getFKind() << '>';
+    } else {
+      assert(false);
+    }
+  }
+
+private:
+  void printBounds(llvm::raw_ostream &os, const SequenceType::Bounds &bounds) {
+    char ch = '<';
+    for (auto &b : bounds) {
+      if (b.hasValue()) {
+        os << ch << *b;
+      } else {
+        os << ch << '?';
+      }
+      ch = 'x';
+    }
+  }
+
+  // must be in a global context because the printer must be able to track
+  // context through multiple recursive invocations of the mlir type printer
+  static llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4>
+      recordTypeVisited;
+};
+
+llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4>
+    TypePrinter::recordTypeVisited; // instantiate
+} // namespace
+
+void fir::printFirType(FIROpsDialect *dialect, M::Type ty,
+                       llvm::raw_ostream &os) {
+  TypePrinter().print(dialect, ty, os);
+}
diff --git a/test/fir/addrof.1.fir b/test/fir/addrof.1.fir
new file mode 100644
index 000000000000..75cc12a55eb1
--- /dev/null
+++ b/test/fir/addrof.1.fir
@@ -0,0 +1,7 @@
+fir.global @var_x : !fir.int<4> {}
+
+func @getAddressOfX() -> !fir.ref<!fir.int<4>> {
+  %1 = fir.address_of(@var_x) : !fir.ref<!fir.int<4>>
+  return %1 : !fir.ref<!fir.int<4>>
+}
+
diff --git a/test/fir/character.fir b/test/fir/character.fir
new file mode 100644
index 000000000000..c4a11a607d7a
--- /dev/null
+++ b/test/fir/character.fir
@@ -0,0 +1,12 @@
+
+fir.global @name constant : !fir.char<1> {
+  constant "Your name"
+  //constant 1
+}
+
+func @get_name() -> !fir.boxchar<1> {
+  %j1 = fir.address_of (@name_constant) : !fir.ref<!fir.char<1>>
+  %j2 = constant 9 : i64
+  %j3 = fir.emboxchar %j1, %j2 : (!fir.ref<!fir.char<1>>, i64) -> !fir.boxchar<1>
+  return %j3 : !fir.boxchar<1>
+}
diff --git a/test/fir/commute.fir b/test/fir/commute.fir
new file mode 100644
index 000000000000..6e55bb0e36be
--- /dev/null
+++ b/test/fir/commute.fir
@@ -0,0 +1,21 @@
+func @f1(%a : i32, %b : i32) -> i32 {
+  %1 = addi %a, %b : i32
+  %2 = addi %b, %a : i32
+  %3 = muli %1, %2 : i32
+  return %3 : i32
+}
+
+func @f2(%a : !fir.ref<i32>) -> i32 {
+  %1 = fir.load %a : !fir.ref<i32>
+  %2 = fir.load %a : !fir.ref<i32>
+  %3 = addi %1, %2 : i32
+  %4 = fir.load %a : !fir.ref<i32>
+  %5 = addi %3, %4 : i32
+  %6 = fir.load %a : !fir.ref<i32>
+  %7 = addi %5, %6 : i32
+  %8 = fir.load %a : !fir.ref<i32>
+  %9 = addi %7, %8 : i32
+  %10 = fir.load %a : !fir.ref<i32>
+  %11 = addi %10, %9 : i32
+  return %11 : i32
+}
diff --git a/test/fir/complex.fir b/test/fir/complex.fir
new file mode 100644
index 000000000000..9f69e41bbd2b
--- /dev/null
+++ b/test/fir/complex.fir
@@ -0,0 +1,7 @@
+func @foo(%a : !fir.complex<4>, %b : !fir.complex<4>, %c : !fir.complex<4>, %d : !fir.complex<4>, %e : !fir.complex<4>) -> !fir.complex<4> {
+  %1 = fir.addc %a, %b : !fir.complex<4>
+  %2 = fir.mulc %1, %c : !fir.complex<4>
+  %3 = fir.subc %2, %d : !fir.complex<4>
+  %4 = fir.divc %3, %e : !fir.complex<4>
+  return %4 : !fir.complex<4>
+}
diff --git a/test/fir/complex.mlir b/test/fir/complex.mlir
new file mode 100644
index 000000000000..5a36992c9567
--- /dev/null
+++ b/test/fir/complex.mlir
@@ -0,0 +1,6 @@
+func @add(%a : complex<f32>, %b : complex<f32>) -> complex<f32>
+
+func @foo(%a : complex<f32>, %b : complex<f32>) -> complex<f32> {
+  %1 = call @add(%a, %b) : (complex<f32>, complex<f32>) -> complex<f32>
+  return %1 : complex<f32>
+}
diff --git a/test/fir/embox.fir b/test/fir/embox.fir
new file mode 100644
index 000000000000..e3750a3c8b55
--- /dev/null
+++ b/test/fir/embox.fir
@@ -0,0 +1,6 @@
+#x0 = (d0, d1) -> (d1, d0)
+
+func @f(%arg : !fir.ref<!fir.array<?:f64>>) {
+  %1 = fir.embox %arg [#x0] : (!fir.ref<!fir.array<?:f64>>) -> !fir.box<!fir.array<?:f64>, >
+  return
+}
diff --git a/test/fir/fir-dt.fir b/test/fir/fir-dt.fir
new file mode 100644
index 000000000000..7dbd6bd13187
--- /dev/null
+++ b/test/fir/fir-dt.fir
@@ -0,0 +1,5 @@
+func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+
+fir.dispatch_table @dispatch_tbl {
+  fir.dt_entry method, @method_impl
+}
diff --git a/test/fir/fir-ops.fir b/test/fir/fir-ops.fir
new file mode 100644
index 000000000000..6d025b2cf24b
--- /dev/null
+++ b/test/fir/fir-ops.fir
@@ -0,0 +1,237 @@
+func @it1() -> !fir.int<4>
+func @it2() -> !fir.real<8>
+func @it3() -> !fir.complex<8>
+func @it4() -> !fir.logical<1>
+func @it5() -> !fir.char<1>
+
+func @dvd1() -> !fir.type<derived1>
+func @dvd2() -> !fir.type<derived2(p:i32)>
+func @dvd3() -> !fir.type<derived3{f:f32}>
+func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+
+func @arr1() -> !fir.array<10:f32>
+func @arr2() -> !fir.array<10x10:f32>
+func @arr3() -> !fir.array<?:f32>
+func @arr4() -> !fir.array<10x?:f32>
+func @arr5() -> !fir.array<?x?:f32>
+func @arr6() -> !fir.array<*:f32>
+
+func @mem1() -> !fir.ref<i32>
+func @mem2() -> !fir.ptr<i32>
+func @mem3() -> !fir.heap<i32>
+func @mem4() -> !fir.ref<() -> ()>
+
+func @box1() -> !fir.box<!fir.array<?:f32>>
+func @box2() -> !fir.boxchar<2>
+func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+func @box4() -> !fir.box<!fir.type<derived3{f:f32}>>
+
+func @oth1() -> !fir.dims<1>
+func @oth2() -> !fir.field
+func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
+
+func @print_index3(index, index, index)
+func @user_i64(i64)
+func @user_tdesc(!fir.tdesc<!fir.type<x>>)
+func @store_tuple(!fir.type<qq1{f1:i32}>) -> ()
+
+func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
+func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+
+func @nop()
+
+func @get_func() -> (() -> ())
+
+func @instructions() {
+  %0 = fir.alloca !fir.array<10:i32> : !fir.ref<!fir.array<10:i32>>
+  %1 = fir.load %0 : !fir.ref<!fir.array<10:i32>>
+  %2 = fir.alloca i32 : !fir.ref<i32>
+  %3 = constant 22 : i32
+  fir.store %3 to %2 : !fir.ref<i32>
+  %4 = fir.undefined i32
+  %5 = fir.allocmem !fir.array<100:f32> : !fir.heap<!fir.array<100:f32>>
+  %6 = fir.embox %5 : (!fir.heap<!fir.array<100:f32>>) -> !fir.box<!fir.array<100:f32>>
+  %7 = fir.box_addr %6 : (!fir.box<!fir.array<100:f32>>) -> !fir.ref<!fir.array<100:f32>>
+  %c0 = constant 0 : index
+  %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100:f32>>, index) -> (index, index, index)
+  fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()
+  %8 = fir.call @it1() : () -> !fir.int<4>
+  %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100:f32>>) -> i64
+  %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100:f32>>) -> i1
+  %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100:f32>>) -> i1
+  %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100:f32>>) -> i1
+  %13 = fir.box_rank %6 : (!fir.box<!fir.array<100:f32>>) -> i64
+  %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100:f32>>) -> !fir.tdesc<!fir.array<100:f32>>
+  %15 = fir.call @box2() : () -> !fir.boxchar<2>
+  %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
+  %17 = fir.call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
+  %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
+  %19 = constant 10 : i32
+  %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100:f32>>, i32) -> !fir.ref<f32>
+  %21 = fir.field_index("f") : !fir.field
+  %22 = fir.undefined !fir.type<derived{f:f32}>
+  %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32
+  %c1 = constant 1 : i32
+  %24 = fir.gendims %c1, %19, %c1 : (i32, i32, i32) -> !fir.dims<1>
+  %cf1 = constant 1.0 : f32
+  %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
+  %26 = fir.len_param_index("f") : !fir.field
+  %27 = fir.call @box4() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+  %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
+  %29 = fir.convert %28 : (i32) -> i64
+  %30 = fir.gentypedesc !fir.type<x> : !fir.tdesc<!fir.type<x>>
+  fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
+  %31 = fir.no_reassoc %29 : i64
+  fir.call @user_i64(%31) : (i64) -> ()
+  fir.freemem %5 : !fir.heap<!fir.array<100:f32>>
+  %32 = fir.call @get_func() : () -> (() -> ())
+  fir.call %32() : () -> ()
+  %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
+  return
+}
+
+func @boxing_match() {
+  %0 = fir.alloca i32 : !fir.ref<i32>
+  %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>
+  %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.dims<0>)
+  %c8 = constant 8 : i32
+  %3 = fir.alloca !fir.char<1> : !fir.ref<!fir.char<1>>
+  %b3 = fir.undefined !fir.char<1>
+  %4 = fir.emboxchar %3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
+  %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
+  %6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}> : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
+  %a1 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
+  %z = constant 0 : i32
+  %c12 = constant 12 : i32
+  %a2 = fir.insert_value %a1, %c12, %z : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+  %z1 = constant 1 : i32
+  %c42 = constant 42.13 : f64
+  %a3 = fir.insert_value %a1, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+  fir.store %a3 to %6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
+  %7 = fir.emboxproc @method_impl, %6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
+  %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>)
+  %9 = call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
+  %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<!fir.type<qq1{f1:i32}>>)
+  %11 = fir.load %10#1 : !fir.ref<!fir.type<qq1{f1:i32}>>
+  fir.call @store_tuple(%11) : (!fir.type<qq1{f1:i32}>) -> ()
+  return
+}
+
+func @loop() {
+  %c1 = constant 1 : index
+  %c10 = constant 10 : index
+  %ct = constant true
+  fir.loop %i = %c1 to %c10 {
+    fir.where %ct {
+      fir.call @nop() : () -> ()
+    } otherwise {
+      fir.call @nop() : () -> ()
+    }
+  }
+  fir.unreachable
+}
+
+func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2 : i32, %b3:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = addi %4, %b3 : i32
+  return %5 : i32
+^bb3(%c:i32, %c2:i32) :
+  %6 = addi %c, %c2 : i32
+  return %6 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2 : i32, %b3:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = addi %4, %b3 : i32
+  return %5 : i32
+^bb3(%c:i32, %c2:i32) :
+  %6 = addi %c, %c2 : i32
+  return %6 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  %7 = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+  fir.dispatch method(%7) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
+  return %zero : i32
+}
+
+func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<i32>,^bb1(%0:i32), #fir.instance<i64>,^bb2(%2:i32), #fir.subsumed<i16>,^bb3(%2:i32), #fir.instance<i8>,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32) :
+  return %b : i32
+^bb3(%c : i32) :
+  return %c : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = muli %4, %b3 : i32
+  %6 = addi %5, %b4 : i32
+  return %6 : i32
+^bb3(%c : i32, %c2 : i32) :
+  %7 = addi %c, %c2 : i32
+  return %7 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+fir.global @global_var : i32 {
+  %0 = constant 1 : i32
+}
+
+fir.global @global_constant constant : i32 {
+  %0 = constant 934 : i32
+}
+
+fir.global @global_derived : !fir.type<mine{f:i32}> {
+  %0 = constant 1 : i32
+  fir.global_entry "f", %0 : i32
+}
+
+fir.dispatch_table @dispatch_tbl {
+  fir.dt_entry "method", @method_impl
+}
diff --git a/test/fir/fir-types.fir b/test/fir/fir-types.fir
new file mode 100644
index 000000000000..c61b7d98bde3
--- /dev/null
+++ b/test/fir/fir-types.fir
@@ -0,0 +1,38 @@
+// Test the FIR operations
+
+func @it1() -> !fir.int<4>
+func @it2() -> !fir.real<8>
+func @it3() -> !fir.complex<8>
+func @it4() -> !fir.logical<1>
+func @it5() -> !fir.char<1>
+
+func @dvd1() -> !fir.type<derived1>
+func @dvd2() -> !fir.type<derived2(p:i32)>
+func @dvd3() -> !fir.type<derived3{f:f32}>
+func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
+func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
+
+func @arr1() -> !fir.array<10:f32>
+func @arr2() -> !fir.array<10x10:f32>
+func @arr3() -> !fir.array<?:f32>
+func @arr4() -> !fir.array<10x?:f32>
+func @arr5() -> !fir.array<?x?:f32>
+func @arr6() -> !fir.array<*:f32>
+func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9:f32>
+
+func @mem1() -> !fir.ref<i32>
+func @mem2() -> !fir.ptr<i32>
+func @mem3() -> !fir.heap<i32>
+func @mem4() -> !fir.ref<() -> ()>
+
+func @box1() -> !fir.box<!fir.array<?:f32>>
+func @box2() -> !fir.boxchar<2>
+func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+func @box4() -> !fir.box<none>
+//func @box5() -> !fir.box<()>
+
+func @oth1() -> !fir.dims<1>
+func @oth2() -> !fir.field
+func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
+func @oth4() -> !fir.dims<15>
diff --git a/test/fir/float.fir b/test/fir/float.fir
new file mode 100644
index 000000000000..f12b1383d6ab
--- /dev/null
+++ b/test/fir/float.fir
@@ -0,0 +1,27 @@
+func @bar(%a : !fir.real<2>, %b : !fir.real<4>, %c : !fir.real<8>, %d : !fir.real<10>, %e : !fir.real<16>) -> !fir.real<10> {
+  %1 = fir.convert %a : (!fir.real<2>) -> !fir.real<10>
+  %2 = fir.convert %b : (!fir.real<4>) -> !fir.real<10>
+  %3 = fir.convert %c : (!fir.real<8>) -> !fir.real<10>
+  %4 = fir.convert %d : (!fir.real<10>) -> !fir.real<10>
+  %5 = fir.convert %e : (!fir.real<16>) -> !fir.real<10>
+  %6 = call @foo2(%1, %2, %3, %4, %5) : (!fir.real<10>, !fir.real<10>, !fir.real<10>, !fir.real<10>, !fir.real<10>) -> !fir.real<10>
+  return %6 : !fir.real<10>
+}
+
+func @foo(%a : !fir.real<16>, %b : !fir.real<16>, %c : !fir.real<16>, %d : !fir.real<16>, %e : !fir.real<16>) -> !fir.real<16> {
+  %1 = fir.addf %a, %b : !fir.real<16>
+  %2 = fir.mulf %1, %c : !fir.real<16>
+  %3 = fir.subf %2, %d : !fir.real<16>
+  %4 = fir.divf %3, %e : !fir.real<16>
+  %5 = fir.modf %4, %a : !fir.real<16>
+  return %5 : !fir.real<16>
+}
+
+func @foo2(%a : !fir.real<10>, %b : !fir.real<10>, %c : !fir.real<10>, %d : !fir.real<10>, %e : !fir.real<10>) -> !fir.real<10> {
+  %1 = fir.addf %a, %b : !fir.real<10>
+  %2 = fir.mulf %1, %c : !fir.real<10>
+  %3 = fir.subf %2, %d : !fir.real<10>
+  %4 = fir.divf %3, %e : !fir.real<10>
+  %5 = fir.modf %4, %a : !fir.real<10>
+  return %5 : !fir.real<10>
+}
diff --git a/test/fir/recursive-type.fir b/test/fir/recursive-type.fir
new file mode 100644
index 000000000000..26f76c3d4ddf
--- /dev/null
+++ b/test/fir/recursive-type.fir
@@ -0,0 +1,5 @@
+!t = type !fir.type<t {p : !fir.ptr<!fir.type<t>>}>
+
+func @a(%a : !t) {
+  return
+}
diff --git a/tools/f18/CMakeLists.txt b/tools/f18/CMakeLists.txt
index 8745f7c1caef..553ec78a0c7b 100644
--- a/tools/f18/CMakeLists.txt
+++ b/tools/f18/CMakeLists.txt
@@ -36,15 +36,11 @@ foreach(filename ${MODULES})
     set(depends ${include}/__fortran_builtins.mod)
   endif()
   add_custom_command(OUTPUT ${include}/${filename}.mod
-    COMMAND f18 -fparse-only -I${include}
+    COMMAND f18 -fparse-only -fdebug-semantics -I${include}
       ${FLANG_SOURCE_DIR}/module/${filename}.f90
     WORKING_DIRECTORY ${include}
     DEPENDS f18 ${FLANG_SOURCE_DIR}/module/${filename}.f90 ${depends}
   )
-  add_custom_command(OUTPUT ${include}/${filename}.f18.mod
-    DEPENDS ${include}/${filename}.mod
-    COMMAND ${CMAKE_COMMAND} -E
-      copy ${include}/${filename}.mod ${include}/${filename}.f18.mod)
   list(APPEND MODULE_FILES ${include}/${filename}.mod)
   list(APPEND MODULE_FILES ${include}/${filename}.f18.mod)
   install(FILES ${include}/${filename}.mod DESTINATION include/flang)
diff --git a/tools/fml/CMakeLists.txt b/tools/fml/CMakeLists.txt
new file mode 100644
index 000000000000..1f79d37d0233
--- /dev/null
+++ b/tools/fml/CMakeLists.txt
@@ -0,0 +1,39 @@
+# Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
+
+add_executable(fml
+  fml.cc
+)
+
+set(LIBS
+  MLIRAffineOps
+  MLIRLLVMIR
+  MLIRLoopOps
+  MLIRStandardOps
+)
+
+whole_archive_link(fml ${LIBS})
+target_link_libraries(fml
+  FortranCommon
+  FortranParser
+  FortranEvaluate
+  FortranSemantics
+  FortranBurnside
+  FIRTransforms
+  ${LIBS}
+)
+
+install(TARGETS fml DESTINATION bin)
diff --git a/tools/fml/fml.cc b/tools/fml/fml.cc
new file mode 100644
index 000000000000..a09a5629f4b9
--- /dev/null
+++ b/tools/fml/fml.cc
@@ -0,0 +1,638 @@
+// Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Temporary Fortran front end driver main program for development scaffolding.
+
+#include "fir/Dialect.h"
+#include "fir/Tilikum/Tilikum.h"
+#include "fir/Transforms/Passes.h"
+#include "fir/Transforms/StdConverter.h"
+#include "../../lib/burnside/bridge.h"
+#include "../../lib/burnside/convert-expr.h"
+#include "../../lib/common/default-kinds.h"
+#include "../../lib/parser/characters.h"
+#include "../../lib/parser/dump-parse-tree.h"
+#include "../../lib/parser/flang-features.h"
+#include "../../lib/parser/message.h"
+#include "../../lib/parser/parse-tree-visitor.h"
+#include "../../lib/parser/parse-tree.h"
+#include "../../lib/parser/parsing.h"
+#include "../../lib/parser/provenance.h"
+#include "../../lib/parser/unparse.h"
+#include "../../lib/semantics/expression.h"
+#include "../../lib/semantics/semantics.h"
+#include "../../lib/semantics/unparse-with-symbols.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Module.h"
+#include "mlir/Parser.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/Passes.h"
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <list>
+#include <memory>
+#include <optional>
+#include <stdlib.h>
+#include <string>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <vector>
+
+namespace Br = Fortran::burnside;
+
+static std::list<std::string> argList(int argc, char *const argv[]) {
+  std::list<std::string> result;
+  for (int j = 0; j < argc; ++j) {
+    result.emplace_back(argv[j]);
+  }
+  return result;
+}
+
+struct MeasurementVisitor {
+  template<typename A> bool Pre(const A &) { return true; }
+  template<typename A> void Post(const A &) {
+    ++objects;
+    bytes += sizeof(A);
+  }
+  size_t objects{0}, bytes{0};
+};
+
+void MeasureParseTree(const Fortran::parser::Program &program) {
+  MeasurementVisitor visitor;
+  Fortran::parser::Walk(program, visitor);
+  std::cout << "Parse tree comprises " << visitor.objects
+            << " objects and occupies " << visitor.bytes << " total bytes.\n";
+}
+
+std::vector<std::string> filesToDelete;
+
+void CleanUpAtExit() {
+  for (const auto &path : filesToDelete) {
+    if (!path.empty()) {
+      unlink(path.data());
+    }
+  }
+}
+
+struct DriverOptions {
+  DriverOptions() {}
+  bool verbose{false};  // -v
+  bool compileOnly{false};  // -c
+  std::string outputPath;  // -o path
+  std::vector<std::string> searchDirectories{"."s};  // -I dir
+  std::string moduleDirectory{"."s};  // -module dir
+  std::string moduleFileSuffix{".mod"};  // -moduleSuffix suff
+  bool forcedForm{false};  // -Mfixed or -Mfree appeared
+  bool warnOnNonstandardUsage{false};  // -Mstandard
+  bool warningsAreErrors{false};  // -Werror
+  Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
+  bool parseOnly{false};
+  bool dumpProvenance{false};
+  bool dumpCookedChars{false};
+  bool dumpUnparse{false};
+  bool dumpUnparseWithSymbols{false};
+  bool dumpParseTree{false};
+  bool dumpSymbols{false};
+  bool debugLinearFIR{false};
+  bool debugResolveNames{false};
+  bool debugSemantics{false};
+  bool measureTree{false};
+  bool runBackend{true};
+  bool dumpHLFIR{true};
+  bool dumpFIR{true};
+  bool lowerToStd{true};
+  bool lowerToLLVM{true};
+  bool lowerToLLVMIR{true};
+  bool isFirInput{false};
+  std::vector<std::string> pgf90Args;
+  const char *prefix{nullptr};
+};
+
+bool ParentProcess() {
+  if (fork() == 0) {
+    return false;  // in child process
+  }
+  int childStat{0};
+  wait(&childStat);
+  if (!WIFEXITED(childStat) || WEXITSTATUS(childStat) != 0) {
+    exit(EXIT_FAILURE);
+  }
+  return true;
+}
+
+void Exec(std::vector<char *> &argv, bool verbose = false) {
+  if (verbose) {
+    for (size_t j{0}; j < argv.size(); ++j) {
+      std::cerr << (j > 0 ? " " : "") << argv[j];
+    }
+    std::cerr << '\n';
+  }
+  argv.push_back(nullptr);
+  execvp(argv[0], &argv[0]);
+  std::cerr << "execvp(" << argv[0] << ") failed: " << std::strerror(errno)
+            << '\n';
+  exit(EXIT_FAILURE);
+}
+
+void RunOtherCompiler(DriverOptions &driver, char *source, char *relo) {
+  std::vector<char *> argv;
+  for (size_t j{0}; j < driver.pgf90Args.size(); ++j) {
+    argv.push_back(driver.pgf90Args[j].data());
+  }
+  char dashC[3] = "-c", dashO[3] = "-o";
+  argv.push_back(dashC);
+  argv.push_back(dashO);
+  argv.push_back(relo);
+  argv.push_back(source);
+  Exec(argv, driver.verbose);
+}
+
+std::string RelocatableName(const DriverOptions &driver, std::string path) {
+  if (driver.compileOnly && !driver.outputPath.empty()) {
+    return driver.outputPath;
+  }
+  std::string base{path};
+  auto slash{base.rfind("/")};
+  if (slash != std::string::npos) {
+    base = base.substr(slash + 1);
+  }
+  std::string relo{base};
+  auto dot{base.rfind(".")};
+  if (dot != std::string::npos) {
+    relo = base.substr(0, dot);
+  }
+  relo += ".o";
+  return relo;
+}
+
+int exitStatus{EXIT_SUCCESS};
+
+std::string CompileFortran(std::string path, Fortran::parser::Options options,
+    DriverOptions &driver,
+    Fortran::semantics::SemanticsContext &semanticsContext) {
+  if (!driver.forcedForm) {
+    auto dot{path.rfind(".")};
+    if (dot != std::string::npos) {
+      std::string suffix{path.substr(dot + 1)};
+      options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
+    }
+  }
+  options.searchDirectories = driver.searchDirectories;
+  Fortran::parser::Parsing parsing{semanticsContext.allSources()};
+  parsing.Prescan(path, options);
+  if (!parsing.messages().empty() &&
+      (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
+    std::cerr << driver.prefix << "could not scan " << path << '\n';
+    parsing.messages().Emit(std::cerr, parsing.cooked());
+    exitStatus = EXIT_FAILURE;
+    return {};
+  }
+  if (driver.dumpProvenance) {
+    parsing.DumpProvenance(std::cout);
+    return {};
+  }
+  if (driver.dumpCookedChars) {
+    parsing.messages().Emit(std::cerr, parsing.cooked());
+    parsing.DumpCookedChars(std::cout);
+    return {};
+  }
+  parsing.Parse(&std::cout);
+  if (options.instrumentedParse) {
+    parsing.DumpParsingLog(std::cout);
+    return {};
+  }
+  parsing.ClearLog();
+  parsing.messages().Emit(std::cerr, parsing.cooked());
+  if (!parsing.consumedWholeFile()) {
+    parsing.EmitMessage(
+        std::cerr, parsing.finalRestingPlace(), "parser FAIL (final position)");
+    exitStatus = EXIT_FAILURE;
+    return {};
+  }
+  if ((!parsing.messages().empty() &&
+          (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
+      !parsing.parseTree().has_value()) {
+    std::cerr << driver.prefix << "could not parse " << path << '\n';
+    exitStatus = EXIT_FAILURE;
+    return {};
+  }
+  auto &parseTree{*parsing.parseTree()};
+  if (driver.measureTree) {
+    MeasureParseTree(parseTree);
+  }
+  // TODO: Change this predicate to just "if (!driver.debugNoSemantics)"
+  if (driver.debugSemantics || driver.debugResolveNames || driver.dumpSymbols ||
+      driver.dumpUnparseWithSymbols || driver.debugLinearFIR ||
+      driver.runBackend) {
+    Fortran::semantics::Semantics semantics{
+        semanticsContext, parseTree, parsing.cooked()};
+    semantics.Perform();
+    semantics.EmitMessages(std::cerr);
+    if (driver.dumpSymbols) {
+      semantics.DumpSymbols(std::cout);
+    }
+    if (semantics.AnyFatalError()) {
+      std::cerr << driver.prefix << "semantic errors in " << path << '\n';
+      exitStatus = EXIT_FAILURE;
+      if (driver.dumpParseTree) {
+        Fortran::parser::DumpTree(std::cout, parseTree);
+      }
+      return {};
+    }
+    if (driver.dumpUnparseWithSymbols) {
+      Fortran::semantics::UnparseWithSymbols(
+          std::cout, parseTree, driver.encoding);
+      return {};
+    }
+  }
+
+  // MLIR+FIR
+  Br::instantiateBurnsideBridge(
+      semanticsContext.defaultKinds(), &parsing.cooked());
+  Br::crossBurnsideBridge(Br::getBridge(), parseTree);
+  mlir::ModuleOp mlirModule{Br::getBridge().getModule()};
+  mlir::PassManager pm{mlirModule.getContext()};
+  if (driver.dumpHLFIR) {
+    llvm::errs() << ";== 1 ==\n";
+    mlirModule.dump();
+  }
+  // Run FIR mem2reg and CSE as a pair
+  pm.addPass(fir::createMemToRegPass());
+  pm.addPass(fir::createCSEPass());
+  if (driver.lowerToStd) {
+    pm.addPass(fir::createFIRToStdPass());
+  }
+  if (driver.lowerToLLVM) {
+    pm.addPass(fir::createFIRToLLVMPass());
+  }
+  if (driver.lowerToLLVMIR) {
+    pm.addPass(fir::createLLVMDialectToLLVMPass());
+  }
+  auto result{pm.run(mlirModule)};
+  if (driver.dumpFIR) {
+    llvm::errs() << ";== 2 ==\n";
+    mlirModule.dump();
+  }
+  return {};
+}
+
+// For handling .fir files (MLIR+FIR)
+std::string CompileFir(std::string path, Fortran::parser::Options options,
+    DriverOptions &driver,
+    Fortran::semantics::SemanticsContext &semanticsContext) {
+  Br::instantiateBurnsideBridge(semanticsContext.defaultKinds());
+
+  // check that there is a file to load
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
+      llvm::MemoryBuffer::getFileOrSTDIN(path);
+  if (std::error_code EC = fileOrErr.getError()) {
+    llvm::errs() << "Could not open file: " << EC.message() << '\n';
+    std::exit(-1);
+  }
+
+  // load the file into a module
+  llvm::SourceMgr sourceMgr;
+  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
+  Br::getBridge().parseSourceFile(sourceMgr);
+  auto mlirModule = Br::getBridge().getModule();
+  if (!Br::getBridge().validModule()) {
+    llvm::errs() << "Error can't load file " << path << '\n';
+    std::exit(3);
+  }
+  if (mlir::failed(mlirModule.verify())) {
+    llvm::errs() << "Error verifying FIR module\n";
+    std::exit(4);
+  }
+
+  llvm::errs() << ";== 3 ==\n";
+  mlirModule.dump();
+
+  // run passes
+  mlir::PassManager pm{mlirModule.getContext()};
+  pm.addPass(fir::createMemToRegPass());
+  pm.addPass(fir::createCSEPass());
+  if (driver.lowerToStd) {
+    pm.addPass(fir::createFIRToStdPass());
+  }
+  if (driver.lowerToLLVM) {
+    pm.addPass(fir::createFIRToLLVMPass());
+  }
+  if (driver.lowerToLLVMIR) {
+    pm.addPass(fir::createLLVMDialectToLLVMPass());
+  }
+  auto result{pm.run(mlirModule)};
+  llvm::errs() << ";== 4 ==\n";
+  mlirModule.dump();
+  if (mlir::succeeded(result)) {
+    llvm::errs() << "a.ll written\n";
+  } else {
+    llvm::errs() << "FAILED\n";
+    std::exit(5);
+  }
+  return {};
+}
+
+std::string CompileOtherLanguage(std::string path, DriverOptions &driver) {
+  std::string relo{RelocatableName(driver, path)};
+  if (ParentProcess()) {
+    if (!driver.compileOnly && driver.outputPath.empty()) {
+      filesToDelete.push_back(relo);
+    }
+    return relo;
+  }
+  RunOtherCompiler(driver, path.data(), relo.data());
+  return {};
+}
+
+void Link(std::vector<std::string> &relocatables, DriverOptions &driver) {
+  if (!ParentProcess()) {
+    std::vector<char *> argv;
+    for (size_t j{0}; j < driver.pgf90Args.size(); ++j) {
+      argv.push_back(driver.pgf90Args[j].data());
+    }
+    for (auto &relo : relocatables) {
+      argv.push_back(relo.data());
+    }
+    if (!driver.outputPath.empty()) {
+      char dashO[3] = "-o";
+      argv.push_back(dashO);
+      argv.push_back(driver.outputPath.data());
+    }
+    Exec(argv, driver.verbose);
+  }
+}
+
+int main(int argc, char *const argv[]) {
+
+  atexit(CleanUpAtExit);
+
+  DriverOptions driver;
+  const char *pgf90{getenv("F18_FC")};
+  driver.pgf90Args.push_back(pgf90 ? pgf90 : "pgf90");
+
+  std::list<std::string> args{argList(argc, argv)};
+  std::string prefix{args.front()};
+  args.pop_front();
+  prefix += ": ";
+  driver.prefix = prefix.data();
+
+  Fortran::parser::Options options;
+  options.predefinitions.emplace_back("__F18", "1");
+  options.predefinitions.emplace_back("__F18_MAJOR__", "1");
+  options.predefinitions.emplace_back("__F18_MINOR__", "1");
+  options.predefinitions.emplace_back("__F18_PATCHLEVEL__", "1");
+#if __x86_64__
+  options.predefinitions.emplace_back("__x86_64__", "1");
+#endif
+
+  Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
+
+  std::vector<std::string> fortranSources, firSources, otherSources,
+      relocatables;
+  bool anyFiles{false};
+
+  while (!args.empty()) {
+    std::string arg{std::move(args.front())};
+    args.pop_front();
+    if (arg.empty()) {
+    } else if (arg.at(0) != '-') {
+      anyFiles = true;
+      auto dot{arg.rfind(".")};
+      if (dot == std::string::npos) {
+        driver.pgf90Args.push_back(arg);
+      } else {
+        std::string suffix{arg.substr(dot + 1)};
+        if (suffix == "f" || suffix == "F" || suffix == "ff" ||
+            suffix == "f90" || suffix == "F90" || suffix == "ff90" ||
+            suffix == "f95" || suffix == "F95" || suffix == "ff95" ||
+            suffix == "cuf" || suffix == "CUF" || suffix == "f18" ||
+            suffix == "F18" || suffix == "ff18") {
+          fortranSources.push_back(arg);
+        } else if (suffix == "fir" || suffix == "ir" || suffix == "mlir") {
+          firSources.push_back(arg);
+        } else if (suffix == "o" || suffix == "a") {
+          relocatables.push_back(arg);
+        } else {
+          otherSources.push_back(arg);
+        }
+      }
+    } else if (arg == "-") {
+      fortranSources.push_back("-");
+    } else if (arg == "--") {
+      while (!args.empty()) {
+        fortranSources.emplace_back(std::move(args.front()));
+        args.pop_front();
+      }
+      break;
+    } else if (arg == "-Mfixed") {
+      driver.forcedForm = true;
+      options.isFixedForm = true;
+    } else if (arg == "-Mfree") {
+      driver.forcedForm = true;
+      options.isFixedForm = false;
+    } else if (arg == "-Mextend") {
+      options.fixedFormColumns = 132;
+    } else if (arg == "-Mbackslash") {
+      options.features.Enable(
+          Fortran::parser::LanguageFeature::BackslashEscapes, false);
+    } else if (arg == "-Mnobackslash") {
+      options.features.Enable(
+          Fortran::parser::LanguageFeature::BackslashEscapes);
+    } else if (arg == "-Mstandard") {
+      driver.warnOnNonstandardUsage = true;
+    } else if (arg == "-fopenmp") {
+      options.features.Enable(Fortran::parser::LanguageFeature::OpenMP);
+      options.predefinitions.emplace_back("_OPENMP", "201511");
+    } else if (arg == "-Werror") {
+      driver.warningsAreErrors = true;
+    } else if (arg == "-ed") {
+      options.features.Enable(Fortran::parser::LanguageFeature::OldDebugLines);
+    } else if (arg == "-E") {
+      driver.dumpCookedChars = true;
+    } else if (arg == "-fbackslash") {
+      options.features.Enable(
+          Fortran::parser::LanguageFeature::BackslashEscapes);
+    } else if (arg == "-fno-backslash") {
+      options.features.Enable(
+          Fortran::parser::LanguageFeature::BackslashEscapes, false);
+    } else if (arg == "-fdebug-dump-provenance") {
+      driver.dumpProvenance = true;
+    } else if (arg == "-fdebug-dump-parse-tree") {
+      driver.dumpParseTree = true;
+    } else if (arg == "-fdebug-dump-symbols") {
+      driver.dumpSymbols = true;
+    } else if (arg == "-fdebug-resolve-names") {
+      driver.debugResolveNames = true;
+    } else if (arg == "-fdebug-measure-parse-tree") {
+      driver.measureTree = true;
+    } else if (arg == "-fdebug-instrumented-parse") {
+      options.instrumentedParse = true;
+    } else if (arg == "-fdebug-semantics") {
+      // TODO: Enable by default once basic tests pass
+      driver.debugSemantics = true;
+    } else if (arg == "-funparse") {
+      driver.dumpUnparse = true;
+    } else if (arg == "-funparse-with-symbols") {
+      driver.dumpUnparseWithSymbols = true;
+    } else if (arg == "-fdebug-dump-linear-ir") {
+      driver.debugLinearFIR = true;
+    } else if (arg == "-fno-dump-hl-fir") {
+      driver.dumpHLFIR = false;
+    } else if (arg == "-fno-dump-fir") {
+      driver.dumpFIR = false;
+    } else if (arg == "-fno-lower-to-llvm") {
+      driver.lowerToLLVMIR = false;
+    } else if (arg == "-fno-lower-to-llvm-dialect") {
+      driver.lowerToLLVM = false;
+      driver.lowerToLLVMIR = false;
+    } else if (arg == "-fno-lower-to-std") {
+      driver.lowerToStd = false;
+      driver.lowerToLLVM = false;
+      driver.lowerToLLVMIR = false;
+    } else if (arg == "-fparse-only") {
+      driver.parseOnly = true;
+    } else if (arg == "-c") {
+      driver.compileOnly = true;
+    } else if (arg == "-o") {
+      driver.outputPath = args.front();
+      args.pop_front();
+    } else if (arg.substr(0, 2) == "-D") {
+      auto eq{arg.find('=')};
+      if (eq == std::string::npos) {
+        options.predefinitions.emplace_back(arg.substr(2), "1");
+      } else {
+        options.predefinitions.emplace_back(
+            arg.substr(2, eq - 2), arg.substr(eq + 1));
+      }
+    } else if (arg.substr(0, 2) == "-U") {
+      options.predefinitions.emplace_back(
+          arg.substr(2), std::optional<std::string>{});
+    } else if (arg == "-r8" || arg == "-fdefault-real-8") {
+      defaultKinds.set_defaultRealKind(8);
+    } else if (arg == "-i8" || arg == "-fdefault-integer-8") {
+      defaultKinds.set_defaultIntegerKind(8);
+    } else if (arg == "-module") {
+      driver.moduleDirectory = args.front();
+      args.pop_front();
+    } else if (arg == "-module-suffix") {
+      driver.moduleFileSuffix = args.front();
+      args.pop_front();
+    } else if (arg == "-help" || arg == "--help" || arg == "-?") {
+      std::cerr
+          << "f18 options:\n"
+          << "  -Mfixed | -Mfree     force the source form\n"
+          << "  -Mextend             132-column fixed form\n"
+          << "  -f[no-]backslash     enable[disable] \\escapes in literals\n"
+          << "  -M[no]backslash      disable[enable] \\escapes in literals\n"
+          << "  -Mstandard           enable conformance warnings\n"
+          << "  -r8 | -fdefault-real-8 | -i8 | -fdefault-integer-8  "
+             "change default kinds of intrinsic types\n"
+          << "  -Werror              treat warnings as errors\n"
+          << "  -ed                  enable fixed form D lines\n"
+          << "  -E                   prescan & preprocess only\n"
+          << "  -module dir          module output directory (default .)\n"
+          << "  -fparse-only         parse only, no output except messages\n"
+          << "  -funparse            parse & reformat only, no code "
+             "generation\n"
+          << "  -funparse-with-symbols  parse, resolve symbols, and unparse\n"
+          << "  -fdebug-measure-parse-tree\n"
+          << "  -fdebug-dump-provenance\n"
+          << "  -fdebug-dump-parse-tree\n"
+          << "  -fdebug-dump-symbols\n"
+          << "  -fdebug-resolve-names\n"
+          << "  -fdebug-instrumented-parse\n"
+          << "  -fdebug-semantics    perform semantic checks\n"
+          << "  -fdotty              print FIR as a dotty graph\n"
+          << "  -fdebug-dump-linear-ir dump the flat linear FIR for debug\n"
+          << "  -v -c -o -I -D -U    have their usual meanings\n"
+          << "  -help                print this again\n"
+          << "Other options are passed through to the compiler.\n";
+      return exitStatus;
+    } else if (arg == "-V") {
+      std::cerr << "\nf18 compiler (under development)\n";
+      return exitStatus;
+    } else {
+      driver.pgf90Args.push_back(arg);
+      if (arg == "-v") {
+        driver.verbose = true;
+      } else if (arg == "-I") {
+        driver.pgf90Args.push_back(args.front());
+        driver.searchDirectories.push_back(args.front());
+        args.pop_front();
+      } else if (arg.substr(0, 2) == "-I") {
+        driver.searchDirectories.push_back(arg.substr(2));
+      }
+    }
+  }
+
+  if (driver.warnOnNonstandardUsage) {
+    options.features.WarnOnAllNonstandard();
+  }
+  if (!options.features.IsEnabled(
+          Fortran::parser::LanguageFeature::BackslashEscapes)) {
+    driver.pgf90Args.push_back("-Mbackslash");
+  }
+  if (options.features.IsEnabled(Fortran::parser::LanguageFeature::OpenMP)) {
+    driver.pgf90Args.push_back("-mp");
+  }
+
+  Fortran::parser::AllSources allSources;
+  Fortran::semantics::SemanticsContext semanticsContext{
+      defaultKinds, options.features, allSources};
+  semanticsContext.set_moduleDirectory(driver.moduleDirectory)
+      .set_moduleFileSuffix(driver.moduleFileSuffix)
+      .set_searchDirectories(driver.searchDirectories)
+      .set_warnOnNonstandardUsage(driver.warnOnNonstandardUsage)
+      .set_warningsAreErrors(driver.warningsAreErrors);
+  
+  //llvm::cl::ParseCommandLineOptions(argc, argv, "Fortran/FIR/MLIR compiler\n");
+
+  if (!anyFiles) {
+    driver.measureTree = true;
+    driver.dumpUnparse = true;
+    CompileFortran("-", options, driver, semanticsContext);
+    return exitStatus;
+  }
+  for (const auto &path : fortranSources) {
+    std::string relo{CompileFortran(path, options, driver, semanticsContext)};
+    if (!driver.compileOnly && !relo.empty()) {
+      relocatables.push_back(relo);
+    }
+  }
+  for (const auto &path : firSources) {
+    std::string relo{CompileFir(path, options, driver, semanticsContext)};
+    if (!driver.compileOnly && !relo.empty()) {
+      relocatables.push_back(relo);
+    }
+  }
+  for (const auto &path : otherSources) {
+    std::string relo{CompileOtherLanguage(path, driver)};
+    if (!driver.compileOnly && !relo.empty()) {
+      relocatables.push_back(relo);
+    }
+  }
+  if (!relocatables.empty()) {
+    Link(relocatables, driver);
+  }
+  return exitStatus;
+}

From ce0fcd1956adc1aa3fd2978b59f9346fd3817775 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Sun, 27 Oct 2019 09:51:18 -0700
Subject: [PATCH 119/345] fix option parsing

Expand genEnterFIR, FORALL construct, etc.

add support for standard calls
---
 include/fir/FIROps.h        |  20 -----
 include/fir/FIROpsSupport.h |  54 ++++++++++++
 lib/burnside/bridge.cc      | 166 +++++++++++++++++-------------------
 lib/fir/Transforms/CSE.cpp  |   4 +-
 tools/fml/fml.cc            |  19 +++--
 5 files changed, 143 insertions(+), 120 deletions(-)
 create mode 100644 include/fir/FIROpsSupport.h

diff --git a/include/fir/FIROps.h b/include/fir/FIROps.h
index ef6532c9126f..3a9bbf99af04 100644
--- a/include/fir/FIROps.h
+++ b/include/fir/FIROps.h
@@ -102,26 +102,6 @@ mlir::ParseResult parseSelector(mlir::OpAsmParser *parser,
 
 LoopOp getForInductionVarOwner(mlir::Value *val);
 
-/// return true iff the Operation is a non-volatile LoadOp
-inline bool nonVolatileLoad(mlir::Operation *op) {
-  if (auto load = dyn_cast<fir::LoadOp>(op))
-    if (!load.getAttr("volatile"))
-      return true;
-  return false;
-}
-
-/// return true iff the Operation is a CallOp or DispatchOp and not pure
-inline bool impureCall(mlir::Operation *op) {
-  if (auto call = dyn_cast<fir::CallOp>(op)) {
-    if (!call.getAttr("pure"))
-      return true;
-  } else if (auto dispatch = dyn_cast<fir::DispatchOp>(op)) {
-    if (!dispatch.getAttr("pure"))
-      return true;
-  }
-  return false;
-}
-
 } // namespace fir
 
 #endif // FIR_FIROPS_H
diff --git a/include/fir/FIROpsSupport.h b/include/fir/FIROpsSupport.h
new file mode 100644
index 000000000000..ee7c6b4cb85b
--- /dev/null
+++ b/include/fir/FIROpsSupport.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_FIROPSSUPPORT_H
+#define FIR_FIROPSSUPPORT_H
+
+#include "fir/FIROps.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+
+namespace fir {
+
+/// return true iff the Operation is a non-volatile LoadOp
+inline bool nonVolatileLoad(mlir::Operation *op) {
+  if (auto load = dyn_cast<fir::LoadOp>(op))
+    if (!load.getAttr("volatile"))
+      return true;
+  return false;
+}
+
+/// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
+/// mlir::CallOp, or mlir::CallIndirectOp and not pure
+inline bool impureCall(mlir::Operation *op) {
+  // Should we also auto-detect that the called function is pure if its
+  // arguments are not references?  For now, rely on a "pure" attribute.
+  if (auto call = dyn_cast<fir::CallOp>(op)) {
+    if (!call.getAttr("pure"))
+      return true;
+  } else if (auto dispatch = dyn_cast<fir::DispatchOp>(op)) {
+    if (!dispatch.getAttr("pure"))
+      return true;
+  } else if (auto call = dyn_cast<mlir::CallOp>(op)) {
+    if (!call.getAttr("pure"))
+      return true;
+  } else if (auto icall = dyn_cast<mlir::CallIndirectOp>(op)) {
+    if (!icall.getAttr("pure"))
+      return true;
+  }
+  return false;
+}
+
+} // namespace fir
+
+#endif // FIR_FIROPSSUPPORT_H
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index c68970f49551..22527ae4e055 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -177,6 +177,22 @@ class FIRConverter {
     return build().create<M::AndOp>(lhs->getLoc(), lhs, rhs);
   }
 
+  template<typename A> void genFIR(const Co::Indirection<A> &indirection) {
+    genFIR(indirection.value());
+  }
+  template<typename A> void genFIR(const Pa::Statement<A> &stmt) {
+    setCurrentPos(stmt.source);
+    genFIR(stmt.statement);
+  }
+  template<typename A> void genFIR(const std::list<A> &list) {
+    for (auto &a : list) {
+      genFIR(a);
+    }
+  }
+  template<typename A> void genFIROnVariant(const A &variant) {
+    std::visit([&](auto &s) { genFIR(s); }, variant.u);
+  }
+
   void genFIR(AnalysisData &ad, std::list<Fl::Op> &operations);
 
   // Control flow destination
@@ -335,14 +351,42 @@ class FIRConverter {
       pushDoContext(&ss);
     }
   }
-  template<typename A> void genEnterFIR(const A &construct) {
-    // FIXME: add other genEnterFIR() members and delete this stub
+
+  /// Lower FORALL construct (See 10.2.4)
+  void genEnterFIR(const Pa::ForallConstruct &forall) {
+    auto &stmt{std::get<Pa::Statement<Pa::ForallConstructStmt>>(forall.t)};
+    setCurrentPos(stmt.source);
+    auto &fas{stmt.statement};
+    auto &ctrl{std::get<Co::Indirection<Pa::ConcurrentHeader>>(fas.t).value()};
+    auto &bld{build()};
+    // bld.create<fir::LoopOp>();
+    for (auto &s : std::get<std::list<Pa::ForallBodyConstruct>>(forall.t)) {
+      genFIROnVariant(s);
+    }
     TODO();
   }
+  void genFIR(const Pa::ForallConstruct &forall) { genEnterFIR(forall); }
+  void genFIR(const Pa::ForallAssignmentStmt &s) { genFIROnVariant(s); }
+
+  void genEnterFIR(const Pa::WhereConstruct &where) { TODO(); }
+  void genFIR(const Pa::WhereConstruct &where) { genEnterFIR(where); }
+
   void genFIR(const Fl::BeginOp &op) {
     std::visit([&](auto *construct) { genEnterFIR(*construct); }, op.u);
   }
 
+  void genEnterFIR(const Pa::AssociateConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::BlockConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::CaseConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::ChangeTeamConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::CriticalConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::IfConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::CompilerDirective &) { TODO(); }
+  void genEnterFIR(const Pa::OpenMPConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::OmpEndLoopDirective &) { TODO(); }
+  void genEnterFIR(const Pa::SelectRankConstruct &) { TODO(); }
+  void genEnterFIR(const Pa::SelectTypeConstruct &) { TODO(); }
+  
   void genExitFIR(const Pa::DoConstruct &construct) {
     if (firLoopOp) {
       build().setInsertionPointAfter(
@@ -500,9 +544,7 @@ class FIRConverter {
   }
 
   // Action statements
-  void genFIR(const Pa::AllocateStmt &stmt) {
-    TODO();
-  }
+  void genFIR(const Pa::AllocateStmt &stmt) { TODO(); }
   void genFIR(const Pa::AssignmentStmt &stmt) {
     auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
     auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
@@ -510,90 +552,34 @@ class FIRConverter {
     build().create<fir::StoreOp>(
         loc, createFIRExpr(loc, rhs), createFIRAddr(loc, lhs));
   }
-  void genFIR(const Pa::BackspaceStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::CallStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::CloseStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::DeallocateStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::EndfileStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::EventPostStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::EventWaitStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::FlushStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::FormTeamStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::InquireStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::LockStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::NullifyStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::OpenStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::PointerAssignmentStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::PrintStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::ReadStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::RewindStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::SyncAllStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::SyncImagesStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::SyncMemoryStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::SyncTeamStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::UnlockStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::WaitStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::WhereStmt &stmt){
-    TODO();
-  }
-  void genFIR(const Pa::WriteStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::ForallStmt &stmt) {
-    TODO();
-  }
-  void genFIR(AnalysisData &ad, const Pa::AssignStmt &stmt) {
-    TODO();
-  }
-  void genFIR(const Pa::PauseStmt &stmt) {
-    TODO();
-  }
+  void genFIR(const Pa::BackspaceStmt &stmt) { TODO(); }
+  void genFIR(const Pa::CallStmt &stmt) { TODO(); }
+  void genFIR(const Pa::CloseStmt &stmt) { TODO(); }
+  void genFIR(const Pa::DeallocateStmt &stmt) { TODO(); }
+  void genFIR(const Pa::EndfileStmt &stmt) { TODO(); }
+  void genFIR(const Pa::EventPostStmt &stmt) { TODO(); }
+  void genFIR(const Pa::EventWaitStmt &stmt) { TODO(); }
+  void genFIR(const Pa::FlushStmt &stmt) { TODO(); }
+  void genFIR(const Pa::FormTeamStmt &stmt) { TODO(); }
+  void genFIR(const Pa::InquireStmt &stmt) { TODO(); }
+  void genFIR(const Pa::LockStmt &stmt) { TODO(); }
+  void genFIR(const Pa::NullifyStmt &stmt) { TODO(); }
+  void genFIR(const Pa::OpenStmt &stmt) { TODO(); }
+  void genFIR(const Pa::PointerAssignmentStmt &stmt) { TODO(); }
+  void genFIR(const Pa::PrintStmt &stmt) { TODO(); }
+  void genFIR(const Pa::ReadStmt &stmt) { TODO(); }
+  void genFIR(const Pa::RewindStmt &stmt) { TODO(); }
+  void genFIR(const Pa::SyncAllStmt &stmt) { TODO(); }
+  void genFIR(const Pa::SyncImagesStmt &stmt) { TODO(); }
+  void genFIR(const Pa::SyncMemoryStmt &stmt) { TODO(); }
+  void genFIR(const Pa::SyncTeamStmt &stmt) { TODO(); }
+  void genFIR(const Pa::UnlockStmt &stmt) { TODO(); }
+  void genFIR(const Pa::WaitStmt &stmt) { TODO(); }
+  void genFIR(const Pa::WhereStmt &stmt) { TODO(); }
+  void genFIR(const Pa::WriteStmt &stmt) { TODO(); }
+  void genFIR(const Pa::ForallStmt &stmt) { TODO(); }
+  void genFIR(AnalysisData &ad, const Pa::AssignStmt &stmt) { TODO(); }
+  void genFIR(const Pa::PauseStmt &stmt) { TODO(); }
 
   template<typename A>
   void translateRoutine(
@@ -877,7 +863,7 @@ void FIRConverter::genFIR(AnalysisData &ad, const Fl::ActionOp &op) {
                  [&](const Co::Indirection<Pa::AssignStmt> &assign) {
                    genFIR(ad, assign.value());
                  },
-                 [&](const auto &stmt) { genFIR(stmt.value()); },
+                 [&](const auto &stmt) { genFIR(stmt); },
              },
       op.v->statement.u);
 }
diff --git a/lib/fir/Transforms/CSE.cpp b/lib/fir/Transforms/CSE.cpp
index 45dff9d123c2..3092f6a61eca 100644
--- a/lib/fir/Transforms/CSE.cpp
+++ b/lib/fir/Transforms/CSE.cpp
@@ -20,7 +20,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/FIROps.h"
+#include "fir/FIROpsSupport.h"
 #include "fir/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/IR/Attributes.h"
@@ -143,7 +143,7 @@ struct BasicCSE : public FunctionPass<BasicCSE> {
                      Block *bb);
   void simplifyRegion(ScopedMapTy &knownValues, DominanceInfo &domInfo,
                       Region &region);
-  
+
   void cleanupBlock(Block *bb) {
     for (auto &inst : *bb) {
       if (fir::nonVolatileLoad(&inst)) {
diff --git a/tools/fml/fml.cc b/tools/fml/fml.cc
index a09a5629f4b9..05293d6f54c1 100644
--- a/tools/fml/fml.cc
+++ b/tools/fml/fml.cc
@@ -588,12 +588,17 @@ int main(int argc, char *const argv[]) {
   if (driver.warnOnNonstandardUsage) {
     options.features.WarnOnAllNonstandard();
   }
-  if (!options.features.IsEnabled(
-          Fortran::parser::LanguageFeature::BackslashEscapes)) {
-    driver.pgf90Args.push_back("-Mbackslash");
-  }
-  if (options.features.IsEnabled(Fortran::parser::LanguageFeature::OpenMP)) {
-    driver.pgf90Args.push_back("-mp");
+
+  if (driver.pgf90Args.size() > 0) {
+    // marshal the arguments for cl parsing
+    int argc_cp = driver.pgf90Args.size();
+    const char **argv_cp = new const char *[argc_cp + 1];
+    for (int i = 0; i < argc_cp; ++i)
+      argv_cp[i] = driver.pgf90Args[i].c_str();
+    argv_cp[argc_cp] = nullptr;
+    llvm::cl::ParseCommandLineOptions(
+        argc_cp, argv_cp, "Fortran/FIR/MLIR compiler\n");
+    delete[] argv_cp;
   }
 
   Fortran::parser::AllSources allSources;
@@ -604,8 +609,6 @@ int main(int argc, char *const argv[]) {
       .set_searchDirectories(driver.searchDirectories)
       .set_warnOnNonstandardUsage(driver.warnOnNonstandardUsage)
       .set_warningsAreErrors(driver.warningsAreErrors);
-  
-  //llvm::cl::ParseCommandLineOptions(argc, argv, "Fortran/FIR/MLIR compiler\n");
 
   if (!anyFiles) {
     driver.measureTree = true;

From 661e9565bfca24e5dfec56b0a5affbdf369cc243 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 24 Oct 2019 07:27:58 -0700
Subject: [PATCH 120/345] More Complex expresison lowering:   * Provide a class
 to help generating fir to     manipulate complex in fir. It hides
 InsertValueOp and     ExtractValueOp details.   * Implement complex compare  
 * Replace all mlir float basic ops (e.g. mlir::AddFOp) by their     FIR
 equivalent. This is because mlir::AddFOp and such do not     support fir real
 types operands and we cannot ensure all real     types are lowered to mlir
 real types (e.g. fir.real<16> currently).     Fir real ops support both fir
 and mlir real operands.   * Prevent re-loading of a same symbol while
 lowering a same symbol.     This especially important for complex because the
 expression     analysis may have already re-written some complex ops as real 
    ops piece-wise. This increase the occurance of symbols.     Fortran gives
 us the guarantee we should not have to reload a var     while evaluating an
 expression (see F2018 section 10.1.4).

Handle function result in ReturnStmt lowering
Return statement were not returning any value for
functions. The function generating return opertion was lacking knowledge
about the result symbol to return a value. This commit solves this by:
  + Adding a pointer to the root of the parse tree being lowered in
    AnalysisData.
  + Restructuring the functions handling flat::ReturnOp to handle
    main, subroutine and functions differently and proagate
    the information needed to emit the related return ops
  + For functions, get the symbol result form FunctionSubprogram parse tree
    node, load its value and return the value.

The knowledege of the parse tree root that can be flattened is now contained in
a variant in AnalysisData so there is no need to pass the tree node in
`CreateFlatFIR`. The template and its explicit instantiations can be removed
and replaced by a `std::visit` inside the single `CreateFlatFIR` entry point.

Conflicts:
	lib/burnside/bridge.cc

Generate FIR for funciton calls in expressions.
  + This is a primitive implementation that only works with
    implicit interface and when the arguments are variables (i.e. symbols).

Reorganize Maths Runtime description to prepare for other runtimes

+ Strip out the part that are not specific to maths runtime into
 runtime.cc and runtime.h so that they can be used by future other
 runtime description. (RuntimeStaticDescription and TypeCode)
+ Provide a new StaticMultimapView that can provide constexpr
  multimap search functions over a static constexpr tables.
  This is to provide a way to handle runtime description without
  needing to dynamicaaly instanciate a map and hold it somewhere.
  For now, it is not used on the math runtime so that we can compare
  both strategies.

Add IO runtime description framework

It uses what was made generic from the maths intrinsic runtime.
The main differences is that it use an enum based key
to sort the functions instead of math function names and also that
it use the newly created constexpr multimap to avoid having to
create a dynamic map to handle it.
The runtime described so far is experimental.

Conflicts:
	lib/burnside/bridge.cc
---
 lib/burnside/CMakeLists.txt  |   1 +
 lib/burnside/bridge.cc       |  75 +++++++++++++++++---
 lib/burnside/complex.h       | 109 +++++++++++++++++++++++++++++
 lib/burnside/convert-expr.cc |  85 ++++++++++++++++-------
 lib/burnside/flattened.cc    |  17 ++---
 lib/burnside/flattened.h     |  17 ++---
 lib/burnside/intrinsics.cc   | 120 +++++++++-----------------------
 lib/burnside/io.cc           | 130 +++++++++++++++++++++++++++++++++++
 lib/burnside/io.h            |  38 ++++++++++
 lib/burnside/runtime.cc      |  53 +++++++++++++-
 lib/burnside/runtime.h       | 130 ++++++++++++++++++++++++++++++++++-
 11 files changed, 629 insertions(+), 146 deletions(-)
 create mode 100644 lib/burnside/complex.h
 create mode 100644 lib/burnside/io.cc
 create mode 100644 lib/burnside/io.h

diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
index 5a29de117ecb..c4b1c3e9b6ca 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/burnside/CMakeLists.txt
@@ -22,6 +22,7 @@ add_library(FortranBurnside
   flattened.cc
   intrinsics.cc
   runtime.cc
+  io.cc
 )
 
 target_link_libraries(FortranBurnside
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 22527ae4e055..0897ea911cf1 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -21,6 +21,7 @@
 #include "fir/Type.h"
 #include "flattened.h"
 #include "intrinsics.h"
+#include "io.h"
 #include "runtime.h"
 #include "../parser/parse-tree-visitor.h"
 #include "../semantics/tools.h"
@@ -229,8 +230,12 @@ class FIRConverter {
     }
     noInsPt = true;
   }
-  void genFIR(const Fl::ReturnOp &op) {
-    std::visit([&](const auto *stmt) { genFIR(*stmt); }, op.u);
+  void genFIR(AnalysisData &ad, const Fl::ReturnOp &op) {
+    std::visit(Co::visitors{
+                   [&](const Pa::ReturnStmt *stmt) { genReturnStmt(ad, stmt); },
+                   [&](const auto *stmt) { genFIR(*stmt); },
+               },
+        op.u);
     noInsPt = true;
   }
   void genFIR(const Fl::ConditionalGotoOp &op) {
@@ -386,7 +391,7 @@ class FIRConverter {
   void genEnterFIR(const Pa::OmpEndLoopDirective &) { TODO(); }
   void genEnterFIR(const Pa::SelectRankConstruct &) { TODO(); }
   void genEnterFIR(const Pa::SelectTypeConstruct &) { TODO(); }
-  
+
   void genExitFIR(const Pa::DoConstruct &construct) {
     if (firLoopOp) {
       build().setInsertionPointAfter(
@@ -458,9 +463,39 @@ class FIRConverter {
     build().create<M::CallOp>(toLocation(), callee, operands);
     build().create<fir::UnreachableOp>(toLocation());
   }
-  void genFIR(const Pa::ReturnStmt &stmt) {
-    build().create<M::ReturnOp>(toLocation());  // FIXME: argument(s)?
+  void genReturnStmt(AnalysisData &, const Pa::FunctionSubprogram &func) {
+    auto &stmt{std::get<Pa::Statement<Pa::FunctionStmt>>(func.t)};
+    auto &name{std::get<Pa::Name>(stmt.statement.t)};
+    assert(name.symbol);
+    const auto &details{name.symbol->get<Se::SubprogramDetails>()};
+    const Se::Symbol *result{&details.result()};
+    M::Value *resultRef{symbolMap.lookupSymbol(result)};
+    assert(resultRef);  // FIXME might die if result
+    // was never referenced before and temp not created.
+    M::Value *resultVal{build().create<fir::LoadOp>(toLocation(), resultRef)};
+    build().create<M::ReturnOp>(toLocation(), resultVal);
+  }
+  void genReturnStmt(const Pa::MainProgram &) {
+    build().create<M::ReturnOp>(toLocation());
+  }
+  void genReturnStmt(
+      const Pa::SubroutineSubprogram &, const Pa::ReturnStmt * = nullptr) {
+    // TODO use Pa::ReturnStmt for alternate return
+    build().create<M::ReturnOp>(toLocation());
+  }
+  void genReturnStmt(AnalysisData &ad, const Pa::ReturnStmt *stmt = nullptr) {
+    std::visit(Co::visitors{
+                   [&](const Pa::SubroutineSubprogram *sub) {
+                     genReturnStmt(*sub, stmt);
+                   },
+                   [&](const Pa::FunctionSubprogram *func) {
+                     genReturnStmt(ad, *func);
+                   },
+                   [&](const Pa::MainProgram *main) { genReturnStmt(*main); },
+               },
+        ad.parseTreeRoot);
   }
+
   void genFIR(const Pa::StopStmt &stmt) {
     auto callee{genRuntimeFunction(
         isStopStmt(std::get<Pa::StopStmt::Kind>(stmt.t)) ? FIRT_STOP
@@ -566,7 +601,19 @@ class FIRConverter {
   void genFIR(const Pa::NullifyStmt &stmt) { TODO(); }
   void genFIR(const Pa::OpenStmt &stmt) { TODO(); }
   void genFIR(const Pa::PointerAssignmentStmt &stmt) { TODO(); }
-  void genFIR(const Pa::PrintStmt &stmt) { TODO(); }
+  void genFIR(const Pa::PrintStmt &stmt) {
+    llvm::SmallVector<mlir::Value *, 4> args;
+    for (const Pa::OutputItem &item :
+        std::get<std::list<Pa::OutputItem>>(stmt.t)) {
+      if (const Pa::Expr * parserExpr{std::get_if<Pa::Expr>(&item.u)}) {
+        mlir::Location loc{toLocation(parserExpr->source)};
+        args.push_back(createFIRExpr(loc, Se::GetExpr(*parserExpr)));
+      } else {
+        assert(false);  // implied do TODO
+      }
+    }
+    genPrintStatement(build(), toLocation(lastKnownPos), args);
+  }
   void genFIR(const Pa::ReadStmt &stmt) { TODO(); }
   void genFIR(const Pa::RewindStmt &stmt) { TODO(); }
   void genFIR(const Pa::SyncAllStmt &stmt) { TODO(); }
@@ -858,11 +905,13 @@ void FIRConverter::genFIR(AnalysisData &ad, const Fl::ActionOp &op) {
                  [](const Co::Indirection<Pa::ExitStmt> &) { TODO(); },
                  [](const Co::Indirection<Pa::GotoStmt> &) { TODO(); },
                  [](const Co::Indirection<Pa::IfStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::ReturnStmt> &) { TODO(); },
                  [](const Co::Indirection<Pa::StopStmt> &) { TODO(); },
                  [&](const Co::Indirection<Pa::AssignStmt> &assign) {
                    genFIR(ad, assign.value());
                  },
+                 [](const Co::Indirection<Pa::ReturnStmt> &) {
+                   assert(false && "should be a ReturnOp");
+                 },
                  [&](const auto &stmt) { genFIR(stmt); },
              },
       op.v->statement.u);
@@ -895,6 +944,11 @@ void FIRConverter::genFIR(AnalysisData &ad, std::list<Fl::Op> &operations) {
                      genFIR(oper);
                      lastWasLabel = true;
                    },
+                   [&](const Fl::ReturnOp &oper) {
+                     noInsPt = false;
+                     genFIR(ad, oper);
+                     lastWasLabel = true;
+                   },
                    [&](const auto &oper) {
                      noInsPt = false;
                      genFIR(oper);
@@ -904,8 +958,7 @@ void FIRConverter::genFIR(AnalysisData &ad, std::list<Fl::Op> &operations) {
         op.u);
   }
   if (build().getInsertionBlock()) {
-    // FIXME: assuming type of '() -> ()'
-    build().create<M::ReturnOp>(toLocation());
+    genReturnStmt(ad);
   }
 }
 
@@ -955,9 +1008,9 @@ void FIRConverter::translateRoutine(
       assert(false && "symbol misidentified by front-end");
     }
   }
-  AnalysisData ad;
+  AnalysisData ad{routine};
   std::list<Fl::Op> operations;
-  CreateFlatIR(routine, operations, ad);
+  CreateFlatIR(operations, ad);
   genFIR(ad, operations);
   finalizeQueued();
 }
diff --git a/lib/burnside/complex.h b/lib/burnside/complex.h
new file mode 100644
index 000000000000..bdf874d6fbca
--- /dev/null
+++ b/lib/burnside/complex.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_COMPLEX_H_
+#define FORTRAN_BURNSIDE_COMPLEX_H_
+
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+
+#include "fe-helper.h"
+#include "fir/FIROps.h"
+#include "fir/Type.h"
+
+namespace Fortran::burnside {
+/// Provide helpers to generate Complex manipulations in FIR.
+
+class ComplexHandler {
+public:
+  ComplexHandler(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
+  mlir::Type getComplexPartType(fir::KindTy complexKind) {
+    return convertReal(builder.getContext(), complexKind);
+  }
+
+  mlir::Type getComplexPartType(mlir::Type complexType) {
+    return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
+  }
+
+  mlir::Type getComplexPartType(mlir::Value *cplx) {
+    assert(cplx != nullptr);
+    return getComplexPartType(cplx->getType());
+  }
+
+  mlir::Value *createComplexPart(mlir::Value *cplx, bool isImaginaryPart) {
+    return builder.create<fir::ExtractValueOp>(
+        loc, getComplexPartType(cplx), cplx, getPartId(isImaginaryPart));
+  }
+
+  mlir::Value *createComplexRealPart(mlir::Value *cplx) {
+    return createComplexPart(cplx, false);
+  }
+
+  mlir::Value *createComplexImagPart(mlir::Value *cplx) {
+    return createComplexPart(cplx, true);
+  }
+
+  mlir::Value *setComplexPart(
+      mlir::Value *cplx, mlir::Value *part, bool isImaginaryPart) {
+    assert(cplx != nullptr);
+    return builder.create<fir::InsertValueOp>(
+        loc, cplx->getType(), cplx, part, getPartId(isImaginaryPart));
+  }
+  mlir::Value *setRealPart(mlir::Value *cplx, mlir::Value *part) {
+    return setComplexPart(cplx, part, false);
+  }
+  mlir::Value *setImagPart(mlir::Value *cplx, mlir::Value *part) {
+    return setComplexPart(cplx, part, true);
+  }
+
+  mlir::Value *createComplex(
+      fir::KindTy kind, mlir::Value *real, mlir::Value *imag) {
+    mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
+    mlir::Value *und{builder.create<fir::UndefOp>(loc, complexTy)};
+    return setImagPart(setRealPart(und, real), imag);
+  }
+
+  mlir::Value *createComplexCompare(
+      mlir::Value *cplx1, mlir::Value *cplx2, bool eq) {
+    mlir::Value *real1{createComplexRealPart(cplx1)};
+    mlir::Value *real2{createComplexRealPart(cplx2)};
+    mlir::Value *imag1{createComplexImagPart(cplx1)};
+    mlir::Value *imag2{createComplexImagPart(cplx2)};
+
+    mlir::CmpFPredicate predicate{
+        eq ? mlir::CmpFPredicate::UEQ : mlir::CmpFPredicate::UNE};
+    mlir::Value *realCmp{
+        builder.create<mlir::CmpFOp>(loc, predicate, real1, real2).getResult()};
+    mlir::Value *imagCmp{
+        builder.create<mlir::CmpFOp>(loc, predicate, imag1, imag2).getResult()};
+
+    if (eq) {
+      return builder.create<mlir::AndOp>(loc, realCmp, imagCmp).getResult();
+    } else {
+      return builder.create<mlir::OrOp>(loc, realCmp, imagCmp).getResult();
+    }
+  }
+
+private:
+  inline mlir::Value *getPartId(bool isImaginaryPart) {
+    auto type{mlir::IntegerType::get(32, builder.getContext())};
+    auto attr{builder.getIntegerAttr(type, isImaginaryPart ? 1 : 0)};
+    return builder.create<mlir::ConstantOp>(loc, type, attr).getResult();
+  }
+
+  mlir::OpBuilder &builder;
+  mlir::Location loc;
+};
+
+}
+#endif  // FORTRAN_BURNSIDE_COMPLEX_H_
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 3827a0a37477..d5528844ed1d 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -14,6 +14,7 @@
 
 #include "convert-expr.h"
 #include "builder.h"
+#include "complex.h"
 #include "fe-helper.h"
 #include "fir/Dialect.h"
 #include "fir/FIROps.h"
@@ -69,6 +70,7 @@ class ExprLowering {
   M::OpBuilder &builder;
   SomeExpr const &expr;
   SymMap &symMap;
+  SymMap loadedSymbols{};
   Co::IntrinsicTypeDefaultKinds const &defaults;
   IntrinsicLibrary const &intrinsics;
 
@@ -107,7 +109,7 @@ class ExprLowering {
   /// Generate an integral constant of `value`
   template<int KIND>
   M::Value *genIntegerConstant(M::MLIRContext *context, std::int64_t value) {
-    M::Type type{getFIRType(context, defaults, IntegerCat, 8)};
+    M::Type type{getFIRType(context, defaults, IntegerCat, KIND)};
     auto attr{builder.getIntegerAttr(type, value)};
     auto res{builder.create<M::ConstantOp>(getLoc(), type, attr)};
     return res.getResult();
@@ -151,6 +153,8 @@ class ExprLowering {
   M::FuncOp getFunction(L::StringRef name, M::FunctionType funTy) {
     auto module{getModule(&builder)};
     if (M::FuncOp func{getNamedFunction(module, name)}) {
+      assert(func.getType() == funTy &&
+          "function already declared with a different type");
       return func;
     }
     return createFunction(module, name, funTy);
@@ -226,7 +230,16 @@ class ExprLowering {
   }
   M::Value *gendef(Se::Symbol const *sym) { return gen(sym); }
   M::Value *genval(Se::Symbol const *sym) {
-    return builder.create<fir::LoadOp>(getLoc(), gen(sym));
+    // Do not load the same symbols several time in one expression.
+    // Fortran guarantees variable value must be the same wherever it
+    // appears in one expression.
+    if (mlir::Value * loaded{loadedSymbols.lookupSymbol(sym)}) {
+      return loaded;
+    } else {
+      mlir::Value *load{builder.create<fir::LoadOp>(getLoc(), gen(sym))};
+      loadedSymbols.addSymbol(sym, load);
+      return load;
+    }
   }
 
   M::Value *genval(Ev::BOZLiteralConstant const &) { TODO(); }
@@ -239,23 +252,23 @@ class ExprLowering {
   template<int KIND> M::Value *genval(Ev::TypeParamInquiry<KIND> const &) {
     TODO();
   }
+
   template<int KIND> M::Value *genval(Ev::ComplexComponent<KIND> const &part) {
-    auto *ctxt = builder.getContext();
-    auto realTy{getFIRType(ctxt, defaults, RealCat, KIND)};
-    auto index = genIntegerConstant<4>(ctxt, part.isImaginaryPart ? 1 : 0);
-    return builder.create<fir::ExtractValueOp>(
-        getLoc(), realTy, genval(part.left()), index);
+    return ComplexHandler{builder, getLoc()}.createComplexPart(
+        genval(part.left()), part.isImaginaryPart);
   }
+
   template<Co::TypeCategory TC, int KIND>
   M::Value *genval(Ev::Negate<Ev::Type<TC, KIND>> const &) {
     TODO();
   }
+
   template<Co::TypeCategory TC, int KIND>
   M::Value *genval(Ev::Add<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::AddIOp>(op);
     } else if constexpr (TC == RealCat) {
-      return createBinaryOp<M::AddFOp>(op);
+      return createBinaryOp<fir::AddfOp>(op);
     } else {
       static_assert(TC == ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::AddcOp>(op);
@@ -266,7 +279,7 @@ class ExprLowering {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::SubIOp>(op);
     } else if constexpr (TC == RealCat) {
-      return createBinaryOp<M::SubFOp>(op);
+      return createBinaryOp<fir::SubfOp>(op);
     } else {
       static_assert(TC == ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::SubcOp>(op);
@@ -277,7 +290,7 @@ class ExprLowering {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::MulIOp>(op);
     } else if constexpr (TC == RealCat) {
-      return createBinaryOp<M::MulFOp>(op);
+      return createBinaryOp<fir::MulfOp>(op);
     } else {
       static_assert(TC == ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::MulcOp>(op);
@@ -288,7 +301,7 @@ class ExprLowering {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::DivISOp>(op);
     } else if constexpr (TC == RealCat) {
-      return createBinaryOp<M::DivFOp>(op);
+      return createBinaryOp<fir::DivfOp>(op);
     } else {
       static_assert(TC == ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::DivcOp>(op);
@@ -310,18 +323,10 @@ class ExprLowering {
     M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
+
   template<int KIND> M::Value *genval(Ev::ComplexConstructor<KIND> const &op) {
-    auto *ctxt = builder.getContext();
-    auto complexTy{fir::CplxType::get(ctxt, KIND)};
-    auto loc{getLoc()};
-    auto und = builder.create<fir::UndefOp>(loc, complexTy);
-    auto *lf = genval(op.left());
-    auto *realIdx = genIntegerConstant<4>(ctxt, 0);
-    auto rp =
-        builder.create<fir::InsertValueOp>(loc, complexTy, und, lf, realIdx);
-    auto *rt = genval(op.right());
-    auto *imagIdx = genIntegerConstant<4>(ctxt, 1);
-    return builder.create<fir::InsertValueOp>(loc, complexTy, rp, rt, imagIdx);
+    return ComplexHandler{builder, getLoc()}.createComplex(
+        KIND, genval(op.left()), genval(op.right()));
   }
   template<int KIND> M::Value *genval(Ev::Concat<KIND> const &op) {
     // TODO this is a bogus call
@@ -347,10 +352,20 @@ class ExprLowering {
       return createCompareOp<M::CmpIOp>(op, translateRelational(op.opr));
     } else if constexpr (TC == RealCat) {
       return createFltCmpOp<M::CmpFOp>(op, translateFloatRelational(op.opr));
+    } else if constexpr (TC == ComplexCat) {
+      bool eq{op.opr == Co::RelationalOperator::EQ};
+      assert(eq ||
+          op.opr == Co::RelationalOperator::NE &&
+              "relation undefined for complex");
+      return ComplexHandler{builder, getLoc()}.createComplexCompare(
+          genval(op.left()), genval(op.right()), eq);
     } else {
+      static_assert(TC == CharacterCat);
       TODO();
     }
   }
+
+  // TODO JP: the thing below should not be required.
   M::Value *genval(Ev::Relational<Ev::SomeType> const &op) {
     return std::visit([&](const auto &x) { return genval(x); }, op.u);
   }
@@ -615,7 +630,31 @@ class ExprLowering {
       L::StringRef name{intrinsic->name};
       return intrinsics.genval(getLoc(), builder, name, ty, operands);
     } else {
-      TODO();  // User defined function.
+      // implicit interface implementation only
+      // TODO: explicit interface
+      L::SmallVector<M::Type, 2> argTypes;
+      L::SmallVector<M::Value *, 2> operands;
+      for (const auto &arg : funRef.arguments()) {
+        assert(
+            arg.has_value() && "optional argument requires explicit interface");
+        const auto *expr{arg->UnwrapExpr()};
+        assert(expr && "assumed type argument requires explicit interface");
+        if (const Se::Symbol * sym{Ev::UnwrapWholeSymbolDataRef(*expr)}) {
+          M::Value *argRef{symMap.lookupSymbol(sym)};
+          assert(argRef && "could not get symbol reference");
+          argTypes.push_back(argRef->getType());
+          operands.push_back(argRef);
+        } else {
+          // TODO create temps for expressions
+          TODO();
+        }
+      }
+      M::Type resultType{getFIRType(builder.getContext(), defaults, TC, KIND)};
+      M::FunctionType funTy{
+          M::FunctionType::get(argTypes, resultType, builder.getContext())};
+      M::FuncOp func{getFunction(funRef.proc().GetName(), funTy)};
+      M::CallOp call{builder.create<M::CallOp>(getLoc(), func, operands)};
+      return call.getResult(0);
     }
   }
 
diff --git a/lib/burnside/flattened.cc b/lib/burnside/flattened.cc
index 3d7989dcda9e..0a5f6c91e9b2 100644
--- a/lib/burnside/flattened.cc
+++ b/lib/burnside/flattened.cc
@@ -75,8 +75,8 @@ std::vector<LabelMention> GetAssign(
 }
 
 static std::tuple<const parser::Name *, LabelMention, LabelMention> FindStack(
-    const std::vector<std::tuple<const parser::Name *, LabelMention, LabelMention>>
-        &stack,
+    const std::vector<
+        std::tuple<const parser::Name *, LabelMention, LabelMention>> &stack,
     const parser::Name *key) {
   for (auto iter{stack.rbegin()}, iend{stack.rend()}; iter != iend; ++iter) {
     if (std::get<0>(*iter) == key) {
@@ -705,17 +705,10 @@ struct ControlFlowAnalyzer {
 
 }  // namespace flat
 
-template<typename A>
-void CreateFlatIR(const A &ptree, std::list<flat::Op> &ops, AnalysisData &ad) {
+void CreateFlatIR(std::list<flat::Op> &ops, AnalysisData &ad) {
   flat::ControlFlowAnalyzer linearize{ops, ad};
-  Walk(ptree, linearize);
+  std::visit(
+      [&](const auto *ptree) { Walk(*ptree, linearize); }, ad.parseTreeRoot);
 }
 
-#define INSTANTIATE_EXPLICITLY(T) \
-  template void CreateFlatIR<parser::T>( \
-      const parser::T &, std::list<flat::Op> &, AnalysisData &)
-INSTANTIATE_EXPLICITLY(MainProgram);
-INSTANTIATE_EXPLICITLY(FunctionSubprogram);
-INSTANTIATE_EXPLICITLY(SubroutineSubprogram);
-
 }  // namespace burnside
diff --git a/lib/burnside/flattened.h b/lib/burnside/flattened.h
index f5c795c04eaa..36c32c3c98d0 100644
--- a/lib/burnside/flattened.h
+++ b/lib/burnside/flattened.h
@@ -214,24 +214,21 @@ std::vector<LabelMention> GetAssign(
 
 // Collection of data maintained internally by the flattening algorithm
 struct AnalysisData {
+  template<typename Node>
+  AnalysisData(const Node &node) : parseTreeRoot{&node} {}
+
   std::map<parser::Label, flat::LabelOp> labelMap;
   std::vector<
       std::tuple<const parser::Name *, flat::LabelMention, flat::LabelMention>>
       constructContextStack;
   flat::LabelBuilder labelBuilder;
   std::map<const semantics::Symbol *, std::set<parser::Label>> assignMap;
+  const std::variant<const parser::MainProgram *,
+      const parser::FunctionSubprogram *, const parser::SubroutineSubprogram *>
+      parseTreeRoot;
 };
 
-// entry-point into building the flat IR
-template<typename A>
-void CreateFlatIR(const A &ptree, std::list<flat::Op> &ops, AnalysisData &ad);
-
-#define EXPLICIT_INSTANTIATION(T) \
-  extern template void CreateFlatIR<parser::T>( \
-      const parser::T &, std::list<flat::Op> &, AnalysisData &)
-EXPLICIT_INSTANTIATION(MainProgram);
-EXPLICIT_INSTANTIATION(FunctionSubprogram);
-EXPLICIT_INSTANTIATION(SubroutineSubprogram);
+void CreateFlatIR(std::list<flat::Op> &, AnalysisData &);
 
 }  // namespace burnside
 
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index ec351b710b55..4e514e6ee5d1 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -14,9 +14,11 @@
 
 #include "intrinsics.h"
 #include "builder.h"
+#include "complex.h"
 #include "fe-helper.h"
 #include "fir/FIROps.h"
 #include "fir/Type.h"
+#include "runtime.h"
 #include "llvm/ADT/Optional.h"
 #include <string>
 #include <unordered_map>
@@ -111,7 +113,7 @@ class IntrinsicLibrary::Implementation {
 
   /// Define the different FIR generators that can be mapped to intrinsic to
   /// generate the related code.
-  using Generator = mlir::Value *(Implementation::*)(Context &) const;
+  using Generator = mlir::Value *(Implementation::*)(Context &)const;
   /// Search a runtime function that is associated to the generic intrinsic name
   /// and whose signature matches the intrinsic arguments and result types.
   /// If no such runtime function is found but a runtime function associated
@@ -132,7 +134,7 @@ class IntrinsicLibrary::Implementation {
   mlir::Value *defaultGenerator(Context &c) const {
     return generateWrapperCall<&I::generateRuntimeCall>(c);
   }
-  mlir::Value *conjgGenerator(Context &) const;
+  mlir::Value *generateConjg(Context &) const;
 
   struct IntrinsicHanlder {
     const char *name;
@@ -144,7 +146,7 @@ class IntrinsicLibrary::Implementation {
   /// defined here for a generic intrinsic, the defaultGenerator will
   /// be attempted.
   static constexpr IntrinsicHanlder handlers[]{
-      {"conjg", &I::conjgGenerator},
+      {"conjg", &I::generateConjg},
   };
 
   // helpers
@@ -158,48 +160,22 @@ class IntrinsicLibrary::Implementation {
 
 /// Define a simple static runtime description that will be transformed into
 /// RuntimeFunction when building the IntrinsicLibrary.
-/// It is constexpr constructible so that static tables of such descriptions can
-/// be safely stored as global variables without requiring global constructors.
-class RuntimeStaticDescription {
+class MathsRuntimeStaticDescription : public RuntimeStaticDescription {
 public:
-  /// Define possible runtime function argument/return type used in signature
-  /// descriptions. They follow mlir standard types naming. MLIR types cannot
-  /// directly be used because they can only be dynamically built.
-  enum class TypeCode { i32, i64, f32, f64, c32, c64 };
-  /// C++ does not provide variable size constexpr container yet. TypeVector
-  /// implements one for Type elements. It works because Type is an enumeration.
-  struct TypeCodeVector {
-    template<TypeCode... v> struct Storage {
-      static constexpr TypeCode values[]{v...};
-    };
-    template<TypeCode... v> static constexpr TypeCodeVector create() {
-      const TypeCode *start{&Storage<v...>::values[0]};
-      return TypeCodeVector{start, start + sizeof...(v)};
-    }
-    const TypeCode *start{nullptr};
-    const TypeCode *end{nullptr};
-  };
-  constexpr RuntimeStaticDescription(
-      const char *n, const char *s, TypeCode r, TypeCodeVector a)
-    : name{n}, symbol{s}, resultTypeCode{r}, argumentTypeCodes{a} {}
-  llvm::StringRef getSymbol() const { return symbol; }
+  constexpr MathsRuntimeStaticDescription(
+      const char *n, const char *s, MaybeTypeCode r, TypeCodeVector a)
+    : RuntimeStaticDescription{s, r, a}, name{n} {}
   llvm::StringRef getName() const { return name; }
-  /// Conversion between types of the static representation and MLIR types.
-  mlir::FunctionType getMLIRFunctionType(mlir::MLIRContext &) const;
 
 private:
-  static mlir::Type getMLIRType(TypeCode, mlir::MLIRContext &);
-
+  // Generic math function name
   const char *name{nullptr};
-  const char *symbol{nullptr};
-  TypeCode resultTypeCode;
-  TypeCodeVector argumentTypeCodes;
 };
 
 /// Description of the runtime functions available on the target.
 using RType = typename RuntimeStaticDescription::TypeCode;
 using Args = typename RuntimeStaticDescription::TypeCodeVector;
-static constexpr RuntimeStaticDescription llvmRuntime[] = {
+static constexpr MathsRuntimeStaticDescription llvmRuntime[] = {
     {"abs", "llvm.fabs.f32", RType::f32, Args::create<RType::f32>()},
     {"abs", "llvm.fabs.f64", RType::f64, Args::create<RType::f64>()},
     {"acos", "acosf", RType::f32, Args::create<RType::f32>()},
@@ -214,7 +190,7 @@ static constexpr RuntimeStaticDescription llvmRuntime[] = {
     {"sin", "llvm.sin.f64", RType::f64, Args::create<RType::f64>()},
 };
 
-static constexpr RuntimeStaticDescription pgmathPreciseRuntime[] = {
+static constexpr MathsRuntimeStaticDescription pgmathPreciseRuntime[] = {
     {"acos", "__pc_acos_1", RType::c32, Args::create<RType::c32>()},
     {"acos", "__pz_acos_1", RType::c64, Args::create<RType::c64>()},
     {"pow", "__pc_pow_1", RType::c32, Args::create<RType::c32, RType::c32>()},
@@ -265,13 +241,15 @@ mlir::Value *IntrinsicLibrary::genval(mlir::Location loc,
 // Create the runtime description for the targeted library version.
 // So far ignore the version an only load the dummy llvm lib and pgmath precise
 MathRuntimeLibrary::MathRuntimeLibrary(
-    IntrinsicLibrary::Version, mlir::MLIRContext &context) {
-  for (const RuntimeStaticDescription &func : llvmRuntime) {
-    RuntimeFunction impl{func.getSymbol(), func.getMLIRFunctionType(context)};
+    IntrinsicLibrary::Version, mlir::MLIRContext &mlirContext) {
+  for (const MathsRuntimeStaticDescription &func : llvmRuntime) {
+    RuntimeFunction impl{
+        func.getSymbol(), func.getMLIRFunctionType(&mlirContext)};
     library.insert({Key{func.getName()}, impl});
   }
-  for (const RuntimeStaticDescription &func : pgmathPreciseRuntime) {
-    RuntimeFunction impl{func.getSymbol(), func.getMLIRFunctionType(context)};
+  for (const MathsRuntimeStaticDescription &func : pgmathPreciseRuntime) {
+    RuntimeFunction impl{
+        func.getSymbol(), func.getMLIRFunctionType(&mlirContext)};
     library.insert({Key{func.getName()}, impl});
   }
 }
@@ -358,6 +336,8 @@ std::string IntrinsicLibrary::Implementation::getWrapperName(Context &c) {
   } else if (auto cplx{resultType.dyn_cast<fir::CplxType>()}) {
     // TODO using kind here is weird, but I do not want to hard coded mapping
     return prefix.str() + c.name.str() + ".c" + std::to_string(cplx.getFKind());
+  } else if (auto firf{resultType.dyn_cast<fir::RealType>()}) {
+    return prefix.str() + c.name.str() + ".f" + std::to_string(firf.getFKind());
   } else {
     assert(false);
     return "fir." + c.name.str() + ".unknown";
@@ -447,59 +427,23 @@ mlir::Value *IntrinsicLibrary::Implementation::generateRuntimeCall(
 }
 
 // CONJG
-mlir::Value *IntrinsicLibrary::Implementation::conjgGenerator(
+mlir::Value *IntrinsicLibrary::Implementation::generateConjg(
     Context &genCtxt) const {
   assert(genCtxt.arguments.size() == 1);
   mlir::Type resType{genCtxt.getResultType()};
   assert(resType == genCtxt.arguments[0]->getType());
+  mlir::OpBuilder &builder{*genCtxt.builder};
+  ComplexHandler cplxHandler{builder, genCtxt.loc};
 
-  // FIXME make fir.complex<f32>.. instead of fir.complex<4> to avoid
-  // constantly having to translate to fe types ? Or get actual mapping
-  auto complexType{resType.cast<fir::CplxType>()};
-  mlir::Type realType{
-      burnside::convertReal(genCtxt.getMLIRContext(), complexType.getFKind())};
-  auto ity{mlir::IndexType::get(genCtxt.getMLIRContext())};
-  auto oneAttr{genCtxt.builder->getIntegerAttr(ity, 1)};
-  auto *imagIdx{
-      genCtxt.builder->create<mlir::ConstantOp>(genCtxt.loc, ity, oneAttr)
-          .getResult()};
-  auto parts{genCtxt.builder->create<fir::ExtractValueOp>(
-      genCtxt.loc, realType, genCtxt.arguments[0], imagIdx)};
   // TODO a negation unary would be better than a sub to zero ?
-  auto zeroAttr{genCtxt.builder->getFloatAttr(realType, llvm::APFloat{0.})};
-  auto zero{genCtxt.builder->create<mlir::ConstantOp>(
-      genCtxt.loc, realType, zeroAttr)};
-  auto negImag{genCtxt.builder->create<mlir::SubFOp>(genCtxt.loc, zero, parts)};
-  return genCtxt.builder->create<fir::InsertValueOp>(
-      genCtxt.loc, resType, genCtxt.arguments[0], negImag, imagIdx);
-}
-
-// RuntimeStaticDescription implementation
-
-mlir::Type RuntimeStaticDescription::getMLIRType(
-    TypeCode t, mlir::MLIRContext &context) {
-  switch (t) {
-  case TypeCode::i32: return mlir::IntegerType::get(32, &context);
-  case TypeCode::i64: return mlir::IntegerType::get(64, &context);
-  case TypeCode::f32: return mlir::FloatType::getF32(&context);
-  case TypeCode::f64: return mlir::FloatType::getF64(&context);
-  // TODO need to access mapping between fe/target
-  case TypeCode::c32: return fir::CplxType::get(&context, 4);
-  case TypeCode::c64: return fir::CplxType::get(&context, 8);
-  }
-  assert(false && "bug");
-  return {};
-}
-
-mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
-    mlir::MLIRContext &context) const {
-  llvm::SmallVector<mlir::Type, 2> argMLIRTypes;
-  for (const TypeCode *t{argumentTypeCodes.start};
-       t != nullptr && t != argumentTypeCodes.end; ++t) {
-    argMLIRTypes.push_back(getMLIRType(*t, context));
-  }
-  mlir::Type resMLIRType{getMLIRType(resultTypeCode, context)};
-  return mlir::FunctionType::get(argMLIRTypes, resMLIRType, &context);
+  mlir::Value *cplx{genCtxt.arguments[0]};
+  mlir::Type realType{cplxHandler.getComplexPartType(cplx)};
+  mlir::Value *zero{builder.create<mlir::ConstantOp>(
+      genCtxt.loc, realType, builder.getZeroAttr(realType))};
+  mlir::Value *imag{cplxHandler.createComplexImagPart(cplx)};
+  mlir::Value *negImag{
+      genCtxt.builder->create<mlir::SubFOp>(genCtxt.loc, zero, imag)};
+  return cplxHandler.setImagPart(cplx, negImag);
 }
 
 }
diff --git a/lib/burnside/io.cc b/lib/burnside/io.cc
new file mode 100644
index 000000000000..038e022fa625
--- /dev/null
+++ b/lib/burnside/io.cc
@@ -0,0 +1,130 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "io.h"
+#include "builder.h"
+#include "runtime.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/IR/Builders.h"
+
+namespace Fortran::burnside {
+
+/// Define actions to sort runtime functions. One actions
+/// may be associated to one or more runtime function.
+/// Actions are the keys in the StaticMultimapView used to
+/// hold the io runtime description in a static constexpr way.
+enum class IOAction { BeginExternalList, Output, EndIO };
+
+class IORuntimeDescription : public RuntimeStaticDescription {
+public:
+  using Key = IOAction;
+  constexpr IORuntimeDescription(
+      IOAction act, const char *s, MaybeTypeCode r, TypeCodeVector a)
+    : RuntimeStaticDescription{s, r, a}, key{act} {}
+  static mlir::Type getIOCookieType(mlir::MLIRContext *context) {
+    return getMLIRType(TypeCode::IOCookie, context);
+  }
+  IOAction key;
+};
+
+using IORuntimeMap = StaticMultimapView<IORuntimeDescription>;
+
+using RT = RuntimeStaticDescription;
+using RType = typename RT::TypeCode;
+using Args = typename RT::TypeCodeVector;
+using IOA = IOAction;
+
+/// This is were the IO runtime are to be described.
+/// The array need to be sorted on the Actions.
+/// Experimental runtime for now.
+static constexpr IORuntimeDescription ioRuntimeTable[]{
+    {IOA::BeginExternalList, "__F18IOa_BeginExternalListOutput",
+        RType::IOCookie, Args::create<RType::i32>()},
+    {IOA::Output, "__F18IOa_OutputInteger64", RT::voidTy,
+        Args::create<RType::IOCookie, RType::i64>()},
+    {IOA::Output, "__F18IOa_OutputReal64", RT::voidTy,
+        Args::create<RType::IOCookie, RType::f64>()},
+    {IOA::EndIO, "__F18IOa_EndIOStatement", RT::voidTy,
+        Args::create<RType::IOCookie>()},
+};
+
+static constexpr IORuntimeMap ioRuntimeMap{ioRuntimeTable};
+
+/// This helper can be used to access io runtime functions that
+/// are mapped to an IOAction that must be mapped to one and
+/// exactly one runtime function. This constraint is enforced
+/// at compile time. This search is resolved at compile time.
+template<IORuntimeDescription::Key key>
+static mlir::FuncOp getIORuntimeFunction(mlir::OpBuilder &builder) {
+  static constexpr auto runtimeDescription{ioRuntimeMap.find(key)};
+  static_assert(runtimeDescription != ioRuntimeMap.end());
+  return runtimeDescription->getFuncOp(builder);
+}
+
+/// This helper can be used to access io runtime functions that
+/// are mapped to Output IOAction that must be mapped to at least one
+/// runtime function but can be mapped to more functions.
+/// This helper returns the function that has the same
+/// mlir::FunctionType as the one seeked. It may therefore dynamically fail
+/// if no function mapped to the Action has the seeked mlir::FunctionType.
+static mlir::FuncOp getOutputRuntimeFunction(
+    mlir::OpBuilder &builder, mlir::Type type) {
+  static constexpr auto descriptionRange{ioRuntimeMap.getRange(IOA::Output)};
+  static_assert(!descriptionRange.empty());
+
+  mlir::MLIRContext *context{getModule(&builder).getContext()};
+  llvm::SmallVector<mlir::Type, 2> argTypes{
+      IORuntimeDescription::getIOCookieType(context), type};
+
+  mlir::FunctionType seekedType{mlir::FunctionType::get(argTypes, {}, context)};
+  for (const auto &description : descriptionRange) {
+    if (description.getMLIRFunctionType(context) == seekedType) {
+      return description.getFuncOp(builder);
+    }
+  }
+  assert(false && "IO output runtime function not defined for this type");
+  return {};
+}
+
+/// Lower print statement assuming a dummy runtime interface for now.
+void genPrintStatement(mlir::OpBuilder &builder, mlir::Location loc,
+    llvm::ArrayRef<mlir::Value *> args) {
+  mlir::ModuleOp module{getModule(&builder)};
+  mlir::MLIRContext *mlirContext{module.getContext()};
+
+  mlir::FuncOp beginFunc{
+      getIORuntimeFunction<IOAction::BeginExternalList>(builder)};
+
+  // Initiate io
+  mlir::Type externalUnitType{mlir::IntegerType::get(32, mlirContext)};
+  mlir::Value *defaultUnit{builder.create<mlir::ConstantOp>(
+      loc, builder.getIntegerAttr(externalUnitType, 1))};
+  llvm::SmallVector<mlir::Value *, 1> beginArgs{defaultUnit};
+  mlir::Value *cookie{
+      builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0)};
+
+  // Call data transfer runtime function
+  for (mlir::Value *arg : args) {
+    llvm::SmallVector<mlir::Value *, 1> operands{cookie, arg};
+    mlir::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg->getType())};
+    builder.create<mlir::CallOp>(loc, outputFunc, operands);
+  }
+
+  // Terminate IO
+  mlir::FuncOp endIOFunc{getIORuntimeFunction<IOAction::EndIO>(builder)};
+  llvm::SmallVector<mlir::Value *, 1> endArgs{cookie};
+  builder.create<mlir::CallOp>(loc, endIOFunc, endArgs);
+}
+
+}
diff --git a/lib/burnside/io.h b/lib/burnside/io.h
new file mode 100644
index 000000000000..bae368609d9b
--- /dev/null
+++ b/lib/burnside/io.h
@@ -0,0 +1,38 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_IO_H_
+#define FORTRAN_BURNSIDE_IO_H_
+
+namespace mlir {
+class OpBuilder;
+class Location;
+class Value;
+}
+namespace llvm {
+template<typename T> class ArrayRef;
+}
+
+/// Experimental IO lowering to FIR + runtime. The Runtime design is under
+/// design.
+/// FIXME This interface is also not final. Should it be based on parser::..
+/// nodes and lower expressions as needed or should it get every expression
+/// already lowered as mlir::Value* ? (currently second options, not sure it
+/// will provide enough information for complex IO statements).
+namespace Fortran::burnside {
+void genPrintStatement(
+    mlir::OpBuilder &, mlir::Location loc, llvm::ArrayRef<mlir::Value *>);
+}
+
+#endif  // FORTRAN_BURNSIDE_IO_H_
diff --git a/lib/burnside/runtime.cc b/lib/burnside/runtime.cc
index dc14ce642918..453dbb9faf64 100644
--- a/lib/burnside/runtime.cc
+++ b/lib/burnside/runtime.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "runtime.h"
+#include "builder.h"
 #include "fir/Type.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
@@ -21,8 +22,58 @@
 #include "mlir/IR/Types.h"
 #include <cassert>
 
-namespace Br = Fortran::burnside;
+namespace Fortran::burnside {
+mlir::Type RuntimeStaticDescription::getMLIRType(
+    TypeCode t, mlir::MLIRContext *context) {
+  switch (t) {
+  case TypeCode::i32: return mlir::IntegerType::get(32, context);
+  case TypeCode::i64: return mlir::IntegerType::get(64, context);
+  case TypeCode::f32: return mlir::FloatType::getF32(context);
+  case TypeCode::f64: return mlir::FloatType::getF64(context);
+  // TODO need to access mapping between fe/target
+  case TypeCode::c32: return fir::CplxType::get(context, 4);
+  case TypeCode::c64: return fir::CplxType::get(context, 8);
+  // ! IOCookie is experimental only so far
+  case TypeCode::IOCookie:
+    return fir::ReferenceType::get(mlir::IntegerType::get(64, context));
+  }
+  assert(false && "bug");
+  return {};
+}
+
+mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
+    mlir::MLIRContext *context) const {
+  llvm::SmallVector<mlir::Type, 2> argMLIRTypes;
+  for (const TypeCode *t{argumentTypeCodes.start};
+       t != nullptr && t != argumentTypeCodes.end; ++t) {
+    argMLIRTypes.push_back(getMLIRType(*t, context));
+  }
+  if (resultTypeCode.has_value()) {
+    mlir::Type resMLIRType{getMLIRType(*resultTypeCode, context)};
+    return mlir::FunctionType::get(argMLIRTypes, resMLIRType, context);
+  } else {
+    return mlir::FunctionType::get(argMLIRTypes, {}, context);
+  }
+}
 
+mlir::FuncOp RuntimeStaticDescription::getFuncOp(
+    mlir::OpBuilder &builder) const {
+  mlir::ModuleOp module{getModule(&builder)};
+  mlir::FunctionType funTy{getMLIRFunctionType(module.getContext())};
+  auto function{getNamedFunction(module, symbol)};
+  if (!function) {
+    function = createFunction(module, symbol, funTy);
+    function.setAttr("fir.runtime", builder.getUnitAttr());
+  } else {
+    assert(funTy == function.getType() && "conflicting runtime declaration");
+  }
+  return function;
+}
+}
+
+// TODO remove dependencies to stub rt below
+
+namespace Br = Fortran::burnside;
 using namespace Fortran;
 using namespace Fortran::burnside;
 
diff --git a/lib/burnside/runtime.h b/lib/burnside/runtime.h
index 48096775bc25..86f3c208f35b 100644
--- a/lib/burnside/runtime.h
+++ b/lib/burnside/runtime.h
@@ -15,20 +15,148 @@
 #ifndef FORTRAN_BURNSIDE_RUNTIME_H_
 #define FORTRAN_BURNSIDE_RUNTIME_H_
 
-#include <string>
+#include <optional>
 
 namespace llvm {
 class StringRef;
 }
 namespace mlir {
+class Type;
 class FunctionType;
 class MLIRContext;
+class OpBuilder;
+class FuncOp;
 }
 
 namespace Fortran::burnside {
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
+/// Define a simple static runtime description that different runtime can
+/// derived from (e.g io, maths ...).
+/// This base class only define enough to generate the functuion declarations,
+// it is up to the actual runtime descriptions to define a way to organize these
+// descriptions in a meaningful way.
+/// It is constexpr constructible so that static tables of such descriptions can
+/// be safely stored as global variables without requiring global constructors.
+class RuntimeStaticDescription {
+public:
+  /// Define possible runtime function argument/return type used in signature
+  /// descriptions. They follow mlir standard types naming. MLIR types cannot
+  /// directly be used because they can only be dynamically built.
+  enum TypeCode { i32, i64, f32, f64, c32, c64, IOCookie };
+  using MaybeTypeCode = std::optional<TypeCode>;  // for results
+  static constexpr MaybeTypeCode voidTy{MaybeTypeCode{std::nullopt}};
+
+  /// C++ does not provide variable size constexpr container yet. TypeVector
+  /// implements one for Type elements. It works because Type is an enumeration.
+  struct TypeCodeVector {
+    template<TypeCode... v> struct Storage {
+      static constexpr TypeCode values[]{v...};
+    };
+    template<TypeCode... v> static constexpr TypeCodeVector create() {
+      const TypeCode *start{&Storage<v...>::values[0]};
+      return TypeCodeVector{start, start + sizeof...(v)};
+    }
+    template<> constexpr TypeCodeVector create<>() { return TypeCodeVector{}; }
+    const TypeCode *start{nullptr};
+    const TypeCode *end{nullptr};
+  };
+  constexpr RuntimeStaticDescription(
+      const char *s, MaybeTypeCode r, TypeCodeVector a)
+    : symbol{s}, resultTypeCode{r}, argumentTypeCodes{a} {}
+  const char *getSymbol() const { return symbol; }
+  /// Conversion between types of the static representation and MLIR types.
+  mlir::FunctionType getMLIRFunctionType(mlir::MLIRContext *) const;
+  mlir::FuncOp getFuncOp(mlir::OpBuilder &) const;
+  static mlir::Type getMLIRType(TypeCode, mlir::MLIRContext *);
+
+private:
+  const char *symbol{nullptr};
+  MaybeTypeCode resultTypeCode;
+  TypeCodeVector argumentTypeCodes;
+};
+
+/// StaticMultimapView is a constexpr friendly multimap
+/// implementation over sorted constexpr arrays.
+/// As the View name suggests, it does not duplicate the
+/// sorted array but only brings range and search concepts
+/// over it. It provides compile time search and can also
+/// provide dynamic search (currently linear, can be improved to
+/// log(n) due to the sorted array property).
+
+// TODO: Find a better place for this if this is retained.
+// This is currently here because this was designed to provide
+// maps over runtime description without the burden of having to
+// instantiate these maps dynamically and to keep they somewhere.
+template<typename Value> class StaticMultimapView {
+public:
+  using Key = typename Value::Key;
+  struct Range {
+    using const_iterator = const Value *;
+    constexpr const_iterator begin() const { return startPtr; }
+    constexpr const_iterator end() const { return endPtr; }
+    constexpr bool empty() const {
+      return startPtr == nullptr || endPtr == nullptr || endPtr <= startPtr;
+    }
+    constexpr std::size_t size() const {
+      return empty() ? 0 : static_cast<std::size_t>(endPtr - startPtr);
+    }
+    const Value *startPtr{nullptr};
+    const Value *endPtr{nullptr};
+  };
+  using const_iterator = typename Range::const_iterator;
+
+  template<std::size_t N>
+  constexpr StaticMultimapView(const Value (&array)[N])
+    : range{&array[0], &array[0] + N} {}
+  template<typename Key> constexpr bool verify() {
+    // TODO: sorted
+    // non empty increasing pointer direction
+    return !range.empty();
+  };
+  constexpr const_iterator begin() const { return range.begin(); }
+  constexpr const_iterator end() const { return range.end(); }
+
+  // Assume array is sorted.
+  // TODO make it a log(n) search based on sorted property
+  // std::equal_range will be constexpr in C++20 only.
+  constexpr Range getRange(const Key &key) const {
+    bool matched{false};
+    const Value *start{nullptr}, *end{nullptr};
+    for (const auto &desc : range) {
+      if (desc.key == key) {
+        if (!matched) {
+          start = &desc;
+          matched = true;
+        }
+      } else if (matched) {
+        end = &desc;
+        matched = false;
+      }
+    }
+    if (matched) {
+      end = range.end();
+    }
+    return Range{start, end};
+  }
+
+  constexpr std::pair<const_iterator, const_iterator> equal_range(
+      const Key &key) const {
+    Range range{getRange(key)};
+    return {range.begin(), range.end()};
+  }
+
+  constexpr typename Range::const_iterator find(Key key) const {
+    const Range subRange{getRange(key)};
+    return subRange.size() == 1 ? subRange.begin() : end();
+  }
+
+private:
+  Range range{nullptr, nullptr};
+};
+// TODO get rid of fake runtime below
+
 #define DEFINE_RUNTIME_ENTRY(A, B, C, D) FIRT_##A,
 enum RuntimeEntryCode {
 #include "runtime.def"

From 484e2756aad95396ce8e3a15399e4dd47e7f61cf Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 18 Mar 2020 12:23:20 -0700
Subject: [PATCH 121/345] [shim] remove files to avoid conflicts

---
 tools/tco/CMakeLists.txt |  24 ---------
 tools/tco/tco.cpp        | 113 ---------------------------------------
 2 files changed, 137 deletions(-)
 delete mode 100644 tools/tco/CMakeLists.txt
 delete mode 100644 tools/tco/tco.cpp

diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
deleted file mode 100644
index 33f410677705..000000000000
--- a/tools/tco/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
-
-set(LIBS
-  FIRDialect
-  FIRSupport
-  ${dialect_libs}
-  MLIRIR
-  MLIRLLVMIR
-  MLIRPass
-  MLIRStandardToLLVM
-  MLIRTransforms
-  MLIRAffineToStandard
-  MLIRAnalysis
-  MLIRLoopToStandard
-  MLIREDSC
-  MLIRParser
-  MLIRStandardToLLVM
-  MLIRSupport
-  MLIRVectorToLLVM
-)
-
-add_llvm_tool(tco tco.cpp)
-llvm_update_compile_flags(tco)
-target_link_libraries(tco PRIVATE ${LIBS})
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
deleted file mode 100644
index 0e085fa5633f..000000000000
--- a/tools/tco/tco.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//===- tco.cpp - Tilikum Crossing Opt ---------------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This is to be like LLVM's opt program, only for FIR.  Such a program is
-// required for roundtrip testing, etc.
-//
-//===----------------------------------------------------------------------===//
-
-#include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Support/KindMapping.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/IR/Module.h"
-#include "mlir/Parser.h"
-#include "mlir/Pass/Pass.h"
-#include "mlir/Pass/PassManager.h"
-#include "mlir/Transforms/Passes.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/InitLLVM.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/ToolOutputFile.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace llvm;
-
-static cl::opt<std::string>
-    inputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
-
-static cl::opt<std::string> outputFilename("o",
-                                           cl::desc("Specify output filename"),
-                                           cl::value_desc("filename"),
-                                           cl::init("-"));
-
-static cl::opt<bool> emitFir("emit-fir",
-                             cl::desc("Parse and pretty-print the input"),
-                             cl::init(false));
-
-static void printModuleBody(mlir::ModuleOp mod, raw_ostream &output) {
-  for (auto &op : mod.getBody()->without_terminator())
-    output << op << '\n';
-}
-
-// compile a .fir file
-static int compileFIR() {
-  // check that there is a file to load
-  ErrorOr<std::unique_ptr<MemoryBuffer>> fileOrErr =
-      MemoryBuffer::getFileOrSTDIN(inputFilename);
-
-  if (std::error_code EC = fileOrErr.getError()) {
-    errs() << "Could not open file: " << EC.message() << '\n';
-    return 1;
-  }
-
-  // load the file into a module
-  SourceMgr sourceMgr;
-  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), SMLoc());
-  auto context = std::make_unique<mlir::MLIRContext>();
-  auto owningRef = mlir::parseSourceFile(sourceMgr, context.get());
-
-  if (!owningRef) {
-    errs() << "Error can't load file " << inputFilename << '\n';
-    return 2;
-  }
-  if (mlir::failed(owningRef->verify())) {
-    errs() << "Error verifying FIR module\n";
-    return 4;
-  }
-
-  std::error_code ec;
-  ToolOutputFile out(outputFilename, ec, sys::fs::OF_None);
-
-  // run passes
-  mlir::PassManager pm{context.get()};
-  mlir::applyPassManagerCLOptions(pm);
-  if (emitFir) {
-    // parse the input and pretty-print it back out
-    // -emit-fir intentionally disables all the passes
-  } else {
-    // TODO: Actually add passes when added to FIR code base
-    // add all the passes
-    // the user can disable them individually
-  }
-
-  // run the pass manager
-  if (mlir::succeeded(pm.run(*owningRef))) {
-    // passes ran successfully, so keep the output
-    if (emitFir)
-      printModuleBody(*owningRef, out.os());
-    out.keep();
-    return 0;
-  }
-
-  // pass manager failed
-  printModuleBody(*owningRef, errs());
-  errs() << "\n\nFAILED: " << inputFilename << '\n';
-  return 8;
-}
-
-int main(int argc, char **argv) {
-  fir::registerFIR();
-  fir::registerFIRPasses();
-  [[maybe_unused]] InitLLVM y(argc, argv);
-  mlir::registerPassManagerCLOptions();
-  mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
-  cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Optimizer\n");
-  return compileFIR();
-}

From 2d1208051290db0b2e46de4c069663ce74a463a6 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 28 Oct 2019 09:42:58 -0700
Subject: [PATCH 122/345] work on extract_value and insert_value add primitives
 for REAL and COMPLEX comparison and unary negation Fix TypeCodeVector GCC
 compile issues.  GCC has trouble with template specialization in classes.
 lowering of select and select-rank ops Implement MAX and MIN lowering Lower
 to MERGE + comparisons to avoid introducing branches. add primitives for REAL
 and COMPLEX comparison and unary negation lowering of select and select-rank
 ops Use SymbolRef in Burnside bridge add pure calls to CSE fix caching bug in
 mem2reg select case on ints remove fir processing from bbc; finish adding
 fir.len type Add a rough draft of a name mangling scheme.  This is unofficial
 and a mere starting point. Rework fir.field_index and fie.len_param_index
 operations; fix bbc link issue work on coordinate lowering; add internal name
 generator add fir.constant

---
 .../BijectiveInternalNameMangling.md          |  115 ++
 documentation/FIRLangRef.md                   |   99 +-
 include/fir/Attribute.h                       |   29 +-
 include/fir/{Dialect.h => FIRDialect.h}       |   19 +-
 include/fir/FIROps.h                          |   37 +
 include/fir/FIROps.td                         |  424 ++++--
 include/fir/FIROpsSupport.h                   |   48 +-
 include/fir/{Type.h => FIRType.h}             |   50 +-
 include/fir/InternalNames.h                   |   89 ++
 include/fir/Tilikum/Tilikum.h                 |    5 +-
 include/fir/Transforms/Passes.h               |    5 +
 lib/burnside/bridge.cc                        |   39 +-
 lib/burnside/builder.cc                       |    8 +-
 lib/burnside/builder.h                        |    4 +-
 lib/burnside/{complex.h => complex-handler.h} |   67 +-
 lib/burnside/convert-expr.cc                  |  104 +-
 lib/burnside/fe-helper.cc                     |   20 +-
 lib/burnside/fe-helper.h                      |    4 +-
 lib/burnside/intrinsics.cc                    |  142 +-
 lib/burnside/runtime.cc                       |    7 +-
 lib/burnside/runtime.h                        |   67 +-
 lib/fir/Attribute.cpp                         |  170 +--
 lib/fir/CMakeLists.txt                        |    5 +-
 lib/fir/{Dialect.cpp => FIRDialect.cpp}       |   46 +-
 lib/fir/FIROps.cpp                            |  223 +++-
 lib/fir/{Type.cpp => FIRType.cpp}             | 1175 ++++++-----------
 lib/fir/InternalNames.cpp                     |  141 ++
 lib/fir/StdConverter.cpp                      |   17 +-
 lib/fir/Tilikum.cpp                           | 1147 +++++++++++-----
 lib/fir/Transforms/CSE.cpp                    |   13 +-
 lib/fir/Transforms/MemToReg.cpp               |  140 +-
 test/fir/aggregate.fir                        |   11 +
 test/fir/alloc.fir                            |   21 +
 test/fir/bugs/bug0001.fir                     |   41 +
 test/fir/bugs/bug0002.fir                     |   12 +
 test/fir/compare.fir                          |   29 +
 test/fir/complex.fir                          |   15 +
 test/fir/constant.fir                         |   19 +
 test/fir/dynlayout.fir                        |   38 +
 test/fir/embox.fir                            |    4 +-
 test/fir/fir-ops.fir                          |   44 +-
 test/fir/fir-types.fir                        |   16 +-
 test/fir/loads.fir                            |   35 +
 test/fir/select.fir                           |   45 +
 tools/CMakeLists.txt                          |    1 +
 tools/{fml => bbc}/CMakeLists.txt             |   12 +-
 tools/{fml/fml.cc => bbc/bbc.cc}              |   82 +-
 tools/tco/CMakeLists.txt                      |   46 +
 tools/tco/tco.cpp                             |   87 ++
 49 files changed, 3236 insertions(+), 1781 deletions(-)
 create mode 100644 documentation/BijectiveInternalNameMangling.md
 rename include/fir/{Dialect.h => FIRDialect.h} (70%)
 rename include/fir/{Type.h => FIRType.h} (90%)
 create mode 100644 include/fir/InternalNames.h
 rename lib/burnside/{complex.h => complex-handler.h} (65%)
 rename lib/fir/{Dialect.cpp => FIRDialect.cpp} (54%)
 rename lib/fir/{Type.cpp => FIRType.cpp} (53%)
 create mode 100644 lib/fir/InternalNames.cpp
 create mode 100644 test/fir/aggregate.fir
 create mode 100644 test/fir/alloc.fir
 create mode 100644 test/fir/bugs/bug0001.fir
 create mode 100644 test/fir/bugs/bug0002.fir
 create mode 100644 test/fir/compare.fir
 create mode 100644 test/fir/constant.fir
 create mode 100644 test/fir/dynlayout.fir
 create mode 100644 test/fir/loads.fir
 create mode 100644 test/fir/select.fir
 rename tools/{fml => bbc}/CMakeLists.txt (85%)
 rename tools/{fml/fml.cc => bbc/bbc.cc} (89%)
 create mode 100644 tools/tco/CMakeLists.txt
 create mode 100644 tools/tco/tco.cpp

diff --git a/documentation/BijectiveInternalNameMangling.md b/documentation/BijectiveInternalNameMangling.md
new file mode 100644
index 000000000000..51801d328232
--- /dev/null
+++ b/documentation/BijectiveInternalNameMangling.md
@@ -0,0 +1,115 @@
+## A Bijective Internal Name Mangling Proposal
+
+FIR has a flat namespace.  No two objects may have the same name.  This
+necessitates that we deploy some sort of name mangling scheme to unique
+symbols from the front-end into FIR.
+
+We also want to be able to reverse-mangle these names back to rederive
+their Fortran names.
+
+Fortran is case insensitive, which allows the compiler to convert the
+user's identifiers to all lower case.  Such a universal conversion implies
+that all upper case letters are available for use in mangling.
+
+### Prefix `_Q`
+
+All mangled names have the prefix sequence `_Q` to indicate the name has
+been mangled.  (Q is chosen because it is a
+[low frequency letter](http://pi.math.cornell.edu/~mec/2003-2004/cryptography/subs/frequencies.html)
+in English.)
+
+### Scope Building
+
+Symbols can be scoped by the module, submodule, or procedure that contains
+that symbol.  After the `_Q` sigil, names are constructed from outermost to
+innermost scope as
+
+   * Module name prefixed with `M`
+   * Submodule name prefixed with `S`
+   * Procedure name prefixed with `F`
+
+Given:
+```
+    submodule (mod:s1mod) s2mod
+      ...
+      subroutine sub
+        ...
+      contains
+        function fun
+```
+
+The mangled name of `fun` becomes:
+```
+    _QMmodSs1modSs2modFsubPfun
+```
+
+### Common blocks
+
+   * A common block name will be prefixed with `B`
+
+### Module scope global data
+
+   * A global data entity is prefixed with `E`
+   * A global entity that is constant will be prefixed with `EC`
+
+### Procedures
+
+   * A procedure is prefixed with `P`
+
+Given:
+```
+    subroutine sub
+```
+The mangled name of `sub` becomes:
+```
+    _QPsub
+```
+
+### Derived types and related
+
+   * A derived type is prefixed with `T`
+   * If a derived type has KIND parameters, they are listed in a consistent
+     canonical order where each takes the form `Ki` and where _i_ is the
+     compile-time constant value. (All type parameters are integer.)  If _i_
+     is a negative value, the prefix `KN` will be used and _i_ will reflect
+     the magnitude of the value.
+
+Given:
+```
+    module mymodule
+      type mytype
+        integer :: member
+      end type
+      ...
+```
+The mangled name of `mytype` becomes:
+```
+    _QMmymoduleTmytype
+```
+
+Given:
+```
+    type yourtype(k1,k2)
+      integer, kind :: k1, k2
+      real :: mem1
+      complex :: mem2
+    end type
+```
+
+The mangled name of `yourtype` where `k1=4` and `k2=-6` (at compile-time):
+```
+    _QTyourtypeK4KN6
+```
+
+   * A derived type dispatch table is prefixed with `D`.  The dispatch table
+     for `type t` would be `_QDTt`
+   * A type descriptor instance is prefixed with `C`.  Intrinsic types can
+     be encoded with their names and kinds.  The type descriptor for the
+     type `yourtype` above would be `_QCTyourtypeK4KN6`.  The type
+     descriptor for `REAL(4)` would be `_QCrealK4`.
+
+### Compiler generated names
+
+Compiler generated names do not have to be mapped back to Fortran.  These
+names will be prefixed with `_QQ` and followed by a unique compiler
+generated identifier.
diff --git a/documentation/FIRLangRef.md b/documentation/FIRLangRef.md
index 7d8216dd5e7d..759fd772b629 100644
--- a/documentation/FIRLangRef.md
+++ b/documentation/FIRLangRef.md
@@ -112,6 +112,11 @@ Examples:
     !fir.array<*:f64>	; array of unknown rank and shape
 ```
 
+Unlike Fortran, FIR arrays have a starting index of 0 (always). This must be
+accounted for when lowering Fortran arrays. See `fir.coordinate_of` and
+`fir.embox` on how access maps can be used. (A starting index of 0 makes FIR
+array offset computation consistent with tuples, record types, etc.)
+
 ### Pointer-like Types
 
 <pre><code><b>!fir.ref&lt;</b><em>ref-to-type</em><b>&gt;</b><br>
@@ -133,6 +138,8 @@ value. This introduces aliasing (which may be important to the optimizer), and
 having a separate type allows for some refinement in alias
 analysis. _ptr-to-type_ cannot be `!fir.ptr`, `!fir.heap`, or `!fir.ref`.
 
+A value of type `!fir.ptr` can introduce aliasing (unlike `!fir.ref`).
+
 <pre><code><b>!fir.heap&lt;</b><em>heap-to-type</em><b>&gt;</b><br>
 </code></pre>
 
@@ -660,8 +667,15 @@ The content and type of _host-context_ is to be determined.
 
 Syntax:	<code><b>fir.coordinate_of</b> <em>box-or-ref-value</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>reference-like-type</em> <b>) -&gt; !fir.ref&lt;</b><em>T</em><b>&gt;</b></code>
 
-Compute the internal coordinate address starting from a boxed value or
-unboxed memory reference. Returns a memory reference.
+Compute the internal coordinate address starting from a boxed value or unboxed
+memory reference. Returns a memory reference. When computing the coordinate of
+an array element, the rank of the array must be known and the number of
+indexing expressions must equal the rank of the array.
+
+This operation will apply the access map from a boxed value implicitly.
+
+Unlike LLVM's GEP instruction, one cannot stride over the outermost reference;
+therefore, the leading 0 index must be omitted.
 
 Example:
 
@@ -674,9 +688,12 @@ Example:
 
 Syntax:	<code><b>fir.extract_value</b> <em>entity</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>entity-type</em> <b>,</b> <em>index-type</em> <b>) -&gt;</b> <em>subobject-type</em></code>
 
-Extract a value from an entity with a type composed of arrays and/or
+Extract a value from an entity with a type composed of tuples, arrays, and/or
 derived types. Returns the value from _entity_ with the type of the
-specified component.
+specified component. Cannot be used on values of `!fir.box` type.
+
+Note that the <em>entity</em> ssa-value must be of compile-time known size
+in order to use this operation.
 
 Example:
 
@@ -686,73 +703,81 @@ Example:
     %61 = fir.extract_value %60, %59 : (!fir.type<X{field:i32}>, !fir.field) -> i32
 ```
 
-#### `fir.field_index`
+#### `fir.insert_value`
 
-Syntax:	<code><b>fir.field_index ("</b><em>field-name</em><b>") : !fir.field</b></code>
+Syntax:	<code><b>fir.insert_value</b> <em>entity</em> <b>,</b> <em>value</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>entity-type</em> <b>,</b> <em>value-type</em> <b>,</b> <em>index-field-type-list</em> <b>) -&gt;</b> <em>entity-type</em></code>
 
-Compute the field offset of a particular named field in a derived
-type. Note: it is possible in Fortran to write code that can only determine
-the exact offset of a particular field in a parameterized derived type at
-runtime.
+Insert a value into an entity with a type composed of tuples, arrays, and/or
+derived types. Returns a new value of the same type as _entity_.  It cannot be
+used on values of `!fir.box` type.
+
+Note that the <em>entity</em> ssa-value must be of compile-time known size
+in order to use this operation.
 
 Example:
 
 ```mlir
-    %62 = fir.field_index ("member_1") : !fir.field
+    %64 = fir.field_index("field") : !fir.field
+    %65 = fir.call @foo2() : () -> i32
+    %66 = fir.call @foo3() : () -> !fir.type<X{field:i32}>
+    %67 = fir.insert_value(%66, %65, %64) : (!fir.type<X{field:i32}>, i32, !fir.field) -> !fir.type<X{field:i32}>
 ```
 
-#### `fir.gendims`
+The above is one possible translation of the following Fortran code sequence.
 
-Syntax:	<code><b>fir.gendims</b> <em>triple-list</em> <b>: (</b> <em>type-list</em> <b>) -&gt; !fir.dims&lt;</b><em>R</em><b>&gt;</b></code>
+```Fortran
+    temp1 = foo2()
+    temp2 = foo3()
+    temp2%field = temp1
+```
 
 
-Generate dimension information. This is needed to embox array entities.
+#### `fir.field_index`
+
+Syntax:	<code><b>fir.field_index ("</b><em>field-name</em><b>") : !fir.field</b></code>
 
+Compute the field offset of a particular named field in a derived
+type. Note: it is possible in Fortran to write code that can only determine
+the exact offset of a particular field in a parameterized derived type at
+runtime.
 
 Example:
 
 ```mlir
-    %c1 = constant 1 : i32
-    %c10 = constant 10 : i32
-    %63 = fir.gendims %c1,%c10,%c1 : (i32,i32,i32) -> !fir.dims<1>
+    %62 = fir.field_index ("member_1") : !fir.field
 ```
 
-#### `fir.insert_value`
+#### `fir.len_param_index`
 
-Syntax:	<code><b>fir.insert_value</b> <em>entity</em> <b>,</b> <em>value</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>entity-type</em> <b>,</b> <em>value-type</em> <b>,</b> <em>index-field-type-list</em> <b>) -&gt;</b> <em>entity-type</em></code>
+Syntax:	<code><b>fir.len_param_index ("</b><em>len-param-name</em><b>") : !fir.field</b></code>
 
-Insert a value into an entity with a type composed arrays and/or derived
-types. Returns a new value of the same type as _entity_.
+Compute the LEN type parameter offset of a particular named parameter in a
+derived type.
 
 Example:
 
 ```mlir
-    %64 = fir.field_index("field") : !fir.field
-    %65 = fir.call @foo2() : () -> i32
-    %66 = fir.call @foo3() : () -> !fir.type<X{field:i32}>
-    %67 = fir.insert_value(%66, %65, %64) : (!fir.type<X{field:i32}>, i32, !fir.field) -> !fir.type<X{field:i32}>
+    %62 = fir.len_param_index("param_1") : !fir.field
 ```
 
-The above is a possible translation of the following Fortran code sequence.
-
-```Fortran
-    temp1 = foo2()
-    temp2 = foo3()
-    temp2%field = temp1
-```
+#### `fir.gendims`
 
+Syntax:	<code><b>fir.gendims</b> <em>triple-list</em> <b>: (</b> <em>type-list</em> <b>) -&gt; !fir.dims&lt;</b><em>R</em><b>&gt;</b></code>
 
-#### `fir.len_param_index`
 
-Syntax:	<code><b>fir.len_param_index ("</b><em>len-param-name</em><b>") : !fir.field</b></code>
+Generate dimension information. This is needed to embox array entities. A
+triple corresponds to the definition of Fortran's array slice operator.
+Specifically, the components are `(first, last, stride)`.
 
-Compute the LEN type parameter offset of a particular named parameter in a
-derived type.
+(These values will be lowered appropriately for the target runtime, which may
+encode the triple as a `CFI_dim_t`, for example.)
 
 Example:
 
 ```mlir
-    %62 = fir.len_param_index("param_1") : !fir.field
+    %c1 = constant 1 : i32
+    %c10 = constant 10 : i32
+    %63 = fir.gendims %c1,%c10,%c1 : (i32,i32,i32) -> !fir.dims<1>
 ```
 
 ### Generalized Control Flow Ops
diff --git a/include/fir/Attribute.h b/include/fir/Attribute.h
index c71a8862c4d6..9299774dd102 100644
--- a/include/fir/Attribute.h
+++ b/include/fir/Attribute.h
@@ -12,11 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_ATTRIBUTE_H
-#define FIR_ATTRIBUTE_H
+#ifndef DIALECT_FIR_FIRATTRIBUTE_H
+#define DIALECT_FIR_FIRATTRIBUTE_H
 
 #include "mlir/IR/Attributes.h"
 
+namespace mlir {
+class DialectAsmParser;
+class DialectAsmPrinter;
+} // namespace mlir
+
 namespace fir {
 
 class FIROpsDialect;
@@ -33,6 +38,7 @@ enum AttributeKind {
   FIR_CLOSEDCLOSED_INTERVAL,
   FIR_OPENCLOSED_INTERVAL,
   FIR_CLOSEDOPEN_INTERVAL,
+  FIR_REAL_ATTR,
 };
 
 class ExactTypeAttr
@@ -114,10 +120,23 @@ class PointIntervalAttr : public mlir::Attribute::AttrBase<PointIntervalAttr> {
   constexpr static unsigned getId() { return AttributeKind::FIR_POINT; }
 };
 
+class RealAttr : public mlir::Attribute::AttrBase<RealAttr, mlir::Attribute> {
+public:
+  using Base::Base;
+
+  static llvm::StringRef getAttrName() { return "real"; }
+  static RealAttr get(mlir::MLIRContext *ctxt, const llvm::APFloat &flt);
+  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
+  constexpr static unsigned getId() { return AttributeKind::FIR_REAL_ATTR; }
+};
+
 mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
-                                  llvm::StringRef rawText, mlir::Type type,
-                                  mlir::Location loc);
+                                  mlir::DialectAsmParser &parser,
+                                  mlir::Type type);
+
+void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
+                       mlir::DialectAsmPrinter &p);
 
 } // namespace fir
 
-#endif // FIR_ATTRIBUTE_H
+#endif // DIALECT_FIR_FIRATTRIBUTE_H
diff --git a/include/fir/Dialect.h b/include/fir/FIRDialect.h
similarity index 70%
rename from include/fir/Dialect.h
rename to include/fir/FIRDialect.h
index d4a180cecce9..708b81bdadc9 100644
--- a/include/fir/Dialect.h
+++ b/include/fir/FIRDialect.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_DIALECT_H
-#define FIR_DIALECT_H
+#ifndef DIALECT_FIR_FIRDIALECT_H
+#define DIALECT_FIR_FIRDIALECT_H
 
 #include "mlir/IR/Dialect.h"
 
@@ -24,6 +24,8 @@ class StringRef;
 
 namespace mlir {
 class Attribute;
+class DialectAsmParser;
+class DialectAsmPrinter;
 class Location;
 class MLIRContext;
 class Type;
@@ -39,16 +41,15 @@ class FIROpsDialect final : public mlir::Dialect {
 
   static llvm::StringRef getDialectNamespace() { return "fir"; }
 
-  mlir::Type parseType(llvm::StringRef rawData,
-                       mlir::Location loc) const override;
-  void printType(mlir::Type ty, llvm::raw_ostream &os) const override;
+  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
+  void printType(mlir::Type ty, mlir::DialectAsmPrinter &p) const override;
 
-  mlir::Attribute parseAttribute(llvm::StringRef rawText, mlir::Type type,
-                                 mlir::Location loc) const override;
+  mlir::Attribute parseAttribute(mlir::DialectAsmParser &parser,
+                                 mlir::Type type) const override;
   void printAttribute(mlir::Attribute attr,
-                      llvm::raw_ostream &os) const override;
+                      mlir::DialectAsmPrinter &p) const override;
 };
 
 } // namespace fir
 
-#endif // FIR_DIALECT_H
+#endif // DIALECT_FIR_FIRDIALECT_H
diff --git a/include/fir/FIROps.h b/include/fir/FIROps.h
index 3a9bbf99af04..37938137567c 100644
--- a/include/fir/FIROps.h
+++ b/include/fir/FIROps.h
@@ -28,6 +28,34 @@ namespace fir {
 
 class FirEndOp;
 
+enum class CmpFPredicate {
+  FirstValidValue,
+  // Always false
+  AlwaysFalse = FirstValidValue,
+  // Ordered comparisons
+  OEQ,
+  OGT,
+  OGE,
+  OLT,
+  OLE,
+  ONE,
+  // Both ordered
+  ORD,
+  // Unordered comparisons
+  UEQ,
+  UGT,
+  UGE,
+  ULT,
+  ULE,
+  UNE,
+  // Any unordered
+  UNO,
+  // Always true
+  AlwaysTrue,
+  // Number of predicates.
+  NumPredicates
+};
+
 /// `fir.global` is a typed symbol with an optional list of initializers.
 class GlobalOp
     : public mlir::Op<
@@ -97,6 +125,15 @@ mlir::ParseResult parseSelector(mlir::OpAsmParser *parser,
                                 mlir::OpAsmParser::OperandType &selector,
                                 mlir::Type &type);
 
+void buildCmpFOp(Builder *builder, OperationState &result,
+                 CmpFPredicate predicate, Value *lhs, Value *rhs);
+void buildCmpCOp(Builder *builder, OperationState &result,
+                 CmpFPredicate predicate, Value *lhs, Value *rhs);
+mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result);
+mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result);
+
 #define GET_OP_CLASSES
 #include "fir/FIROps.h.inc"
 
diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
index 9d7bbcc9ac5d..f13d626baae1 100644
--- a/include/fir/FIROps.td
+++ b/include/fir/FIROps.td
@@ -87,18 +87,22 @@ def fir_DimsType : Type<CPred<"$_self.isa<fir::DimsType>()">, "dim type">;
 def fir_TypeDescType : Type<CPred<"$_self.isa<fir::TypeDescType>()">,
     "type desc type">;
 def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
+def fir_LenType : Type<CPred<"$_self.isa<fir::LenType>()">,
+    "LEN parameter type">;
 
-def AnyCoordinateLike : TypeConstraint<Or<[AnyInteger.predicate,
+def AnyComponentLike : TypeConstraint<Or<[AnyInteger.predicate,
     Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate]>,
     "any coordinate index">;
+def AnyComponentType : Type<AnyComponentLike.predicate, "coordinate type">;
+
+def AnyCoordinateLike : TypeConstraint<Or<[AnyInteger.predicate,
+    Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate,
+    fir_LenType.predicate]>, "any coordinate index">;
 def AnyCoordinateType : Type<AnyCoordinateLike.predicate, "coordinate type">;
 
 class fir_Op<string mnemonic, list<OpTrait> traits>
   : Op<fir_Dialect, mnemonic, traits>;
 
-def SimplePrettyParserPrinter {
-}
-
 class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   : fir_Op<mnemonic, traits> {
   let parser = [{
@@ -179,23 +183,36 @@ class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
 class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
     fir_AllocatableBaseOp<mnemonic, !listconcat([NoSideEffect], traits)>,
     fir_TwoBuilders<fir_AllocateOpBuilder, fir_NamedAllocateOpBuilder>,
-    Arguments<(ins TypeAttr:$in_type, Variadic<Index>:$shape)> {
+    Arguments<(ins TypeAttr:$in_type, Variadic<AnyIntegerType>:$args)> {
+
   let parser = [{
     M::Type intype;
     if (parser.parseType(intype))
       return M::failure();
     auto &builder = parser.getBuilder();
     result.addAttribute("in_type", M::TypeAttr::get(intype));
-    if (!parser.parseOptionalComma()) {
-      llvm::SmallVector<M::Type, 4> typeVec;
-      llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    L::SmallVector<M::OpAsmParser::OperandType, 8> operands;
+    L::SmallVector<M::Type, 8> typeVec;
+    bool hasOperands = false;
+    if (!parser.parseOptionalLParen()) {
       if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None) ||
-          parser.resolveOperands(operands, builder.getIndexType(),
-              parser.getNameLoc(), result.operands))
+          parser.parseRParen())
+        return M::failure();
+      auto lens = builder.getI32IntegerAttr(operands.size());
+      result.addAttribute(lenpName(), lens);
+      hasOperands = true;
+    }
+    if (!parser.parseOptionalComma()) {
+      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None))
         return M::failure();
+      hasOperands = true;
     }
+    if (hasOperands &&
+        parser.resolveOperands(operands, builder.getIndexType(),
+            parser.getNameLoc(), result.operands))
+      return M::failure();
     M::Type restype;
-    if (parser.parseOptionalAttributeDict(result.attributes) ||
+    if (parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(restype) ||
         parser.addTypeToList(restype, result.types))
       return M::failure();
@@ -204,13 +221,36 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
 
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
+    if (hasLenParams()) {
+      p << '(';
+      p.printOperands(getLenParams());
+      p << ')';
+    }
     for (auto sh : getShapeOperands()) {
       p << ", ";
       p.printOperand(sh);
     }
-    p.printOptionalAttrDict(getAttrs(), {"in_type"});
+    p.printOptionalAttrDict(getAttrs(), {"in_type", lenpName()});
     p << " : " << getType();
   }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef lenpName() { return "len_param_count"; }
+    mlir::Type getAllocatedType();
+    bool hasLenParams() { return bool{getAttr(lenpName())}; }
+    unsigned numLenParams() {
+      if (auto val = getAttrOfType<mlir::IntegerAttr>(lenpName()))
+        return val.getInt();
+      return 0;
+    }
+    operand_range getLenParams() {
+      return {operand_begin(), operand_begin() + numLenParams()};
+    }
+    operand_range getShapeOperands() {
+      return {operand_begin() + numLenParams(), operand_end()};
+    }
+    static mlir::Type getRefTy(mlir::Type ty);
+  }];
 }
 
 // Memory SSA operations
@@ -237,14 +277,6 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
     }
     return M::success();
   }];
-
-  let extraClassDeclaration = [{
-    mlir::Type getAllocatedType();
-    operand_range getShapeOperands() {
-      return {operand_begin(), operand_end()};
-    }
-    static mlir::Type getRefTy(mlir::Type ty);
-  }];
 }
 
 def fir_LoadOp : fir_OneResultOp<"load", []>,
@@ -270,7 +302,7 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
     M::Type type;
     M::OpAsmParser::OperandType oper;
     if (parser.parseOperand(oper) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, type, result.operands))
        return M::failure();
@@ -310,7 +342,7 @@ def fir_StoreOp : fir_Op<"store", []>,
     if (parser.parseOperand(oper) ||
         parser.parseKeyword("to") ||
         parser.parseOperand(store) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, elementType(type),
           result.operands) ||
@@ -380,14 +412,6 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
     }
     return M::success();
   }];
-
-  let extraClassDeclaration = [{
-    mlir::Type getAllocatedType();
-    operand_range getShapeOperands() {
-      return {operand_begin(), operand_end()};
-    }
-    static mlir::Type getRefTy(mlir::Type ty);
-  }];
 }
 
 def fir_FreeMemOp : fir_Op<"freemem", []>,
@@ -405,7 +429,7 @@ def fir_FreeMemOp : fir_Op<"freemem", []>,
     M::Type type;
     M::OpAsmParser::OperandType oper;
     if (parser.parseOperand(oper) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, type, result.operands))
       return M::failure();
@@ -784,7 +808,7 @@ def fir_FirEndOp : fir_Op<"end", [Terminator]> {
 // Operations on !fir.box<T> type objects
 
 def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
-    Arguments<(ins AnyReferenceLike:$memref, Variadic<fir_DimsType>:$dims)> {
+    Arguments<(ins AnyReferenceLike:$memref, Variadic<AnyIntegerType>:$args)> {
   let summary = "boxes a given reference and (optional) dimension information";
 
   let description = [{
@@ -795,11 +819,19 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
 
   let parser = [{
     M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 2> operands;
+    llvm::SmallVector<M::OpAsmParser::OperandType, 8> operands;
     M::OpAsmParser::OperandType memref;
     if (parser.parseOperand(memref))
       return M::failure();
     operands.push_back(memref);
+    auto &builder = parser.getBuilder();
+    if (!parser.parseOptionalLParen()) {
+      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None) ||
+          parser.parseRParen())
+        return M::failure();
+      auto lens = builder.getI32IntegerAttr(operands.size());
+      result.addAttribute(lenpName(), lens);
+    }
     if (!parser.parseOptionalComma()) {
       M::OpAsmParser::OperandType dims;
       if (parser.parseOperand(dims))
@@ -822,6 +854,11 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(memref());
+    if (hasLenParams()) {
+      p << '(';
+      p.printOperands(getLenParams());
+      p << ')';
+    }
     if (getNumOperands() == 2) {
       p << ", ";
       p.printOperands(dims());
@@ -831,6 +868,22 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
     p << " : ";
     p.printFunctionalType(getOperation());
   }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef lenpName() { return "len_param_count"; }
+    bool hasLenParams() { return bool{getAttr(lenpName())}; }
+    unsigned numLenParams() {
+      if (auto x = getAttrOfType<mlir::IntegerAttr>(lenpName()))
+        return x.getInt();
+      return 0;
+    }
+    operand_range getLenParams() {
+      return {operand_begin(), operand_begin() + numLenParams()};
+    }
+    operand_range dims() {
+      return {operand_begin() + numLenParams(), operand_end()};
+    }
+  }];
 }
 
 def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
@@ -923,8 +976,8 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
 }
 
 def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]>,
-    Results<(outs fir_ReferenceType, AnyInteger, AnyInteger, fir_TypeDescType,
-             AnyInteger, fir_DimsType)>,
+    Results<(outs fir_ReferenceType, AnyIntegerLike, AnyIntegerLike,
+             fir_TypeDescType, AnyIntegerLike, fir_DimsType)>,
     Arguments<(ins fir_BoxType:$box)> {
   let summary = "unbox the boxed value into a tuple value";
 
@@ -935,7 +988,7 @@ def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]>,
 }
 
 def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]>,
-    Results<(outs fir_ReferenceType, AnyInteger)>,
+    Results<(outs fir_ReferenceType, AnyIntegerLike)>,
     Arguments<(ins fir_BoxCharType:$boxchar)> {
   let summary = "unbox a boxchar value into a pair value";
 
@@ -987,7 +1040,7 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]>,
 }
 
 def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]>,
-    Results<(outs AnyInteger)>, Arguments<(ins fir_BoxCharType:$val)> {
+    Results<(outs AnyIntegerLike)>, Arguments<(ins fir_BoxCharType:$val)> {
   let summary = "return the LEN type parameter from a boxchar value";
 
   let description = [{
@@ -1028,6 +1081,10 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
     p << " : ";
     p.printFunctionalType(getOperation());
   }];
+
+  let extraClassDeclaration = [{
+    mlir::Type getTupleType();
+  }];
 }
 
 def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]>,
@@ -1141,10 +1198,23 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
     p << " : ";
     p.printFunctionalType(getOperation());
   }];
+
+  let verifier = [{
+    // Recovering a LEN type parameter only makes sense from a boxed value
+    for (auto *co : coor())
+      if (auto *s = co->getDefiningOp())
+        if (dyn_cast_or_null<LenParamIndexOp>(s)) {
+          if (getNumOperands() != 2)
+            return emitOpError("len_param_index must be last argument");
+          if (!ref()->getType().dyn_cast<BoxType>())
+            return emitOpError("len_param_index must be used on box type");
+        }
+    return M::success();
+  }];
 }
 
 def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]>,
-    Arguments<(ins AnyCompositeLike:$adt, Variadic<AnyCoordinateType>:$coor)> {
+    Arguments<(ins AnyCompositeLike:$adt, Variadic<AnyComponentType>:$coor)> {
   let summary = "Extract a value from an aggregate SSA-value";
 
   let description = [{
@@ -1175,7 +1245,9 @@ def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]>,
   }];
 }
 
-def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
+def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
+    Arguments<(ins StrAttr:$field_id, TypeAttr:$on_type,
+               Variadic<AnyIntegerType>:$lenparams)> {
   let summary = "create a field index value from a field identifier";
 
   let description = [{
@@ -1187,43 +1259,71 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
     subobjects.
   }];
 
-  let arguments = (ins StrAttr:$field_id);
-
   let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, StringRef fieldName",
+    "Builder *builder, OperationState &result, StringRef fieldName,"
+    "Type recTy, ArrayRef<Value*> operands = {}",
     [{
-      result.addAttribute("field_id", builder->getStringAttr(fieldName));
+      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
+      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+      result.addOperands(operands);
     }]
   >];
 
   let parser = [{
-    if (parser.parseLParen())
-      return M::failure();
     llvm::StringRef fieldName;
-    if (parser.parseOptionalKeyword(&fieldName)) {
-      M::StringAttr attr;
-      if (parser.parseAttribute(attr, "field_id", result.attributes))
+    auto &builder = parser.getBuilder();
+    M::Type recty;
+    if (parser.parseOptionalKeyword(&fieldName) ||
+        parser.parseComma() ||
+        parser.parseType(recty))
+      return M::failure();
+    result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
+    if (!recty.dyn_cast<RecordType>())
+      return M::failure();
+    result.addAttribute(typeAttrName(), M::TypeAttr::get(recty));
+    if (!parser.parseLParen()) {
+      L::SmallVector<M::OpAsmParser::OperandType, 8> operands;
+      L::SmallVector<M::Type, 8> types;
+      auto loc = parser.getNameLoc();
+      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None) ||
+          parser.parseRParen() ||
+          parser.parseColonTypeList(types) ||
+          parser.resolveOperands(operands, types, loc, result.operands))
         return M::failure();
-    } else {
-      result.addAttribute("field_id",
-          parser.getBuilder().getStringAttr(fieldName));
     }
-    M::Type type;
-    if (parser.parseRParen() ||
-        parser.parseColonType(type) ||
-        parser.addTypeToList(type, result.types))
+    M::Type fieldType = fir::FieldType::get(builder.getContext());
+    if (parser.addTypeToList(fieldType, result.types))
       return M::failure();
     return M::success();
   }];
 
   let printer = [{
-    p << getOperationName() << " (" << getAttr("field_id") << ") : "
-      << getType();
+    p << getOperationName() << ' '
+      << getAttrOfType<M::StringAttr>(fieldAttrName()).getValue() << ", "
+      << getAttr(typeAttrName());
+    if (getNumOperands()) {
+      p << '(';
+      p.printOperands(lenparams());
+      auto sep = ") : ";
+      for (auto *op : lenparams()) {
+        p << sep;
+        if (op)
+          p.printType(op->getType());
+        else
+          p << "()";
+        sep = ", ";
+      }
+    }
+  }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef fieldAttrName() { return "field_id"; }
+    constexpr static llvm::StringRef typeAttrName() { return "on_type"; }
   }];
 }
 
 def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>, 
-    Arguments<(ins Variadic<AnyInteger>:$triples)> {
+    Arguments<(ins Variadic<AnyIntegerType>:$triples)> {
   let summary = "generate a value of type `!fir.dims`";
 
   let description = [{
@@ -1259,7 +1359,7 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>,
 
 def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]>,
     Arguments<(ins AnyCompositeLike:$adt, AnyType:$val,
-    Variadic<AnyCoordinateType>:$coor)> {
+    Variadic<AnyComponentType>:$coor)> {
   let summary = "insert a new sub-value into a copy of an existing aggregate";
 
   let description = [{
@@ -1289,51 +1389,56 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]>,
   }];
 }
 
-def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
+def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]>,
+    Arguments<(ins StrAttr:$field_id, TypeAttr:$on_type)> {
   let summary =
     "create a field index value from a LEN type parameter identifier";
 
   let description = [{
-    Generate a field (offset) value from an LEN parameter identifier.  Field
-    values may be lowered into exact offsets when the layout of a Fortran
-    derived type is known at compile-time. The type of a field value is
-    `!fir.field` and these values can be used with the `fir.coordinate_of`,
-    `fir.extract_value`, or `fir.insert_value` instructions to compute
-    (abstract) addresses of subobjects.
+    Generate a LEN parameter (offset) value from an LEN parameter identifier.
+    The type of a LEN parameter value is `!fir.len` and these values can be
+    used with the `fir.coordinate_of` instructions to compute (abstract)
+    addresses of LEN parameters.
   }];
 
-  let arguments = (ins StrAttr:$field_id);
-
   let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, StringRef fieldName",
+    "Builder *builder, OperationState &result, StringRef fieldName, Type recTy",
     [{
-      result.addAttribute("field_id", builder->getStringAttr(fieldName));
+      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
+      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
     }]
   >];
 
   let parser = [{
-    if (parser.parseLParen())
-      return M::failure();
     llvm::StringRef fieldName;
-    if (parser.parseOptionalKeyword(&fieldName)) {
-      M::StringAttr attr;
-      if (parser.parseAttribute(attr, "field_id", result.attributes))
-        return M::failure();
-    } else {
-      result.addAttribute("field_id",
-          parser.getBuilder().getStringAttr(fieldName));
-    }
-    M::Type type;
-    if (parser.parseRParen() ||
-        parser.parseColonType(type) ||
-        parser.addTypeToList(type, result.types))
+    auto &builder = parser.getBuilder();
+    M::Type recty;
+    if (parser.parseOptionalKeyword(&fieldName) ||
+        parser.parseComma() ||
+        parser.parseType(recty))
+      return M::failure();
+    result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
+    if (!recty.dyn_cast<RecordType>())
+      return M::failure();
+    result.addAttribute(typeAttrName(), M::TypeAttr::get(recty));
+    M::Type lenType = fir::LenType::get(builder.getContext());
+    if (parser.addTypeToList(lenType, result.types))
       return M::failure();
     return M::success();
   }];
 
   let printer = [{
-    p << getOperationName() << " (" << getAttr("field_id") << ") : "
-      << getType();
+    p << getOperationName() << ' '
+      << getAttrOfType<M::StringAttr>(fieldAttrName()).getValue() << ", "
+      << getAttr(typeAttrName());
+  }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef fieldAttrName() { return "field_id"; }
+    constexpr static llvm::StringRef typeAttrName() { return "on_type"; }
+    mlir::Type getOnType() {
+      return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
+    }
   }];
 }
 
@@ -1348,7 +1453,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   }];
   let arguments = (ins Index:$lowerBound, Index:$upperBound,
                    Variadic<Index>:$optstep, OptionalAttr<I32Attr>:$constep,
-                   OptionalAttr<BoolAttr>:$unordered);
+                   OptionalAttr<UnitAttr>:$unordered);
   let regions = (region SizedRegion<1>:$region);
   let skipDefaultBuilders = 1;
   let builders = [
@@ -1379,10 +1484,9 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     auto step = optstep();
     if (step.begin() != step.end()) {
       auto *s = (*step.begin())->getDefiningOp();
-      if (auto cst = dyn_cast_or_null<M::ConstantIndexOp>(s)) {
+      if (auto cst = dyn_cast_or_null<M::ConstantIndexOp>(s))
         if (cst.getValue() == 0)
           return emitOpError("constant step operand must be nonzero");
-      }
     }
 
     // Check that the body defines as single block argument for the induction
@@ -1510,7 +1614,7 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
           parser.getBuilder().getStringAttr(calleeName));
     }
     if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(calleeType) ||
         parser.addTypesToList(calleeType.getResults(), result.types) ||
         parser.resolveOperands(
@@ -1546,23 +1650,68 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
   }];
 }
 
+// Constant operations that support Fortran
+
+def fir_ConstantOp : fir_Op<"constant", [NoSideEffect]>,
+    Results<(outs AnyType)> {
+  let summary = "create a constant of FIR type";
+
+  let description = [{
+    An FIR constant
+  }];
+
+  let parser = [{
+    M::StringAttr attr;
+    if (parser.parseAttribute(attr, value(), result.attributes) ||
+        parser.addTypesToList(attr.getType(), result.types))
+      return M::failure();
+    return M::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr(value());
+  }];
+
+  //let verifier = [{
+  // FIXME!
+  //}];
+
+  let extraClassDeclaration = [{
+    constexpr static char const *value() { return "value"; }
+    mlir::Attribute getValue() { return getAttr(value()); }
+  }];
+}
+
 // Complex operations
 
 class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic,
-       !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])> {
+       !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
+    Results<(outs AnyType)> {
+  let parser = [{
+    return impl::parseOneResultSameOperandTypeOp(parser, result);
+  }];
 
-  let results = (outs AnyType);
+  let printer = [{ return fir::printBinaryOp(this->getOperation(), p); }];
+}
 
+class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_Op<mnemonic,
+         !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
+      Results<(outs AnyType)> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 
-  let printer = [{
-    return fir::printComplexBinaryOp(this->getOperation(), p);
-  }];
+  let printer = [{ return fir::printUnaryOp(this->getOperation(), p); }];
 }
 
+class RealUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_UnaryArithmeticOp<mnemonic, traits>,
+      Arguments<(ins AnyRealLike:$operand)>;
+
+def fir_NegfOp : RealUnaryArithmeticOp<"negf">;
+
 class RealArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_ArithmeticOp<mnemonic, traits>,
       Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)>;
@@ -1572,6 +1721,46 @@ def fir_SubfOp : RealArithmeticOp<"subf">;
 def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]>;
 def fir_DivfOp : RealArithmeticOp<"divf">;
 def fir_ModfOp : RealArithmeticOp<"modf">;
+// Pow is a builtin call and not a primitive
+
+def fir_CmpfOp : fir_Op<"cmpf",
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]>,
+    Results<(outs AnyLogicalLike)>,
+    Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)> {
+  let summary = "floating-point comparison operator";
+
+  let description = [{
+    Extends the standard floating-point comparison to handle the extended
+    floating-point types found in FIR.
+  }];
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, CmpFPredicate predicate,"
+    "Value *lhs, Value *rhs", [{
+      fir::buildCmpFOp(builder, result, predicate, lhs, rhs);
+  }]>];
+
+  let parser = [{ return fir::parseCmpfOp(parser, result); }];
+  let printer = [{ fir::printCmpfOp(p, *this); }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef getPredicateAttrName() {
+      return "predicate";
+    }
+    static CmpFPredicate getPredicateByName(llvm::StringRef name);
+
+    CmpFPredicate getPredicate() {
+      return (CmpFPredicate)getAttrOfType<mlir::IntegerAttr>(
+          getPredicateAttrName()).getInt();
+    }
+  }];
+}
+
+class ComplexUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+      fir_UnaryArithmeticOp<mnemonic, traits>,
+      Arguments<(ins fir_ComplexType:$operand)>;
+
+def fir_NegcOp : ComplexUnaryArithmeticOp<"negc">;
 
 class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_ArithmeticOp<mnemonic, traits>,
@@ -1581,6 +1770,38 @@ def fir_AddcOp : ComplexArithmeticOp<"addc", [Commutative]>;
 def fir_SubcOp : ComplexArithmeticOp<"subc">;
 def fir_MulcOp : ComplexArithmeticOp<"mulc", [Commutative]>;
 def fir_DivcOp : ComplexArithmeticOp<"divc">;
+// Pow is a builtin call and not a primitive
+
+def fir_CmpcOp : fir_Op<"cmpc",
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]>,
+    Results<(outs AnyLogicalLike)>,
+    Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)> {
+  let summary = "complex floating-point comparison operator";
+
+  let description = [{
+    A complex comparison to handle complex types found in FIR.
+  }];
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, CmpFPredicate predicate,"
+    "Value *lhs, Value *rhs", [{
+      fir::buildCmpCOp(builder, result, predicate, lhs, rhs);
+  }]>];
+
+  let parser = [{ return fir::parseCmpcOp(parser, result); }];
+  let printer = [{ fir::printCmpcOp(p, *this); }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef getPredicateAttrName() {
+      return "predicate";
+    }
+
+    CmpFPredicate getPredicate() {
+      return (CmpFPredicate)getAttrOfType<mlir::IntegerAttr>(
+          getPredicateAttrName()).getInt();
+    }
+  }];
+}
 
 // Other misc. operations
 
@@ -1600,7 +1821,7 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
     if (parser.parseLParen() ||
         parser.parseAttribute(attr, "symbol", result.attributes) ||
         parser.parseRParen() ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.addTypeToList(type, result.types))
       return M::failure();
@@ -1627,7 +1848,7 @@ def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]>,
     llvm::SmallVector<M::OpAsmParser::OperandType, 1> operands;
     if (parser.parseOperandList(operands, 1,
             M::OpAsmParser::Delimiter::None) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
@@ -1664,11 +1885,18 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
       return M::failure();
     return M::success();
   }];
+
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
     p << " : " << getType();
     p.printOptionalAttrDict(getAttrs(), {"in_type"});
   }];
+
+  let extraClassDeclaration = [{
+    mlir::Type getInType() {
+      return getAttrOfType<mlir::TypeAttr>("in_type").getType();
+    }
+  }];
 }
 
 def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
@@ -1722,7 +1950,7 @@ def fir_GlobalEntryOp : fir_Op<"global_entry", []>,
     }
     if (parser.parseComma() ||
         parser.parseOperand(constant) ||
-        parser.parseOptionalAttributeDict(result.attributes) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(constant, type, result.operands))
       return M::failure();
diff --git a/include/fir/FIROpsSupport.h b/include/fir/FIROpsSupport.h
index ee7c6b4cb85b..a0f48de4c69e 100644
--- a/include/fir/FIROpsSupport.h
+++ b/include/fir/FIROpsSupport.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_FIROPSSUPPORT_H
-#define FIR_FIROPSSUPPORT_H
+#ifndef FIR_FIROPS_SUPPORT_H
+#define FIR_FIROPS_SUPPORT_H
 
 #include "fir/FIROps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
@@ -23,32 +23,44 @@ namespace fir {
 /// return true iff the Operation is a non-volatile LoadOp
 inline bool nonVolatileLoad(mlir::Operation *op) {
   if (auto load = dyn_cast<fir::LoadOp>(op))
-    if (!load.getAttr("volatile"))
-      return true;
+    return !load.getAttr("volatile");
   return false;
 }
 
 /// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
 /// mlir::CallOp, or mlir::CallIndirectOp and not pure
+/// NB: this is not the same as `!pureCall(op)`
 inline bool impureCall(mlir::Operation *op) {
   // Should we also auto-detect that the called function is pure if its
   // arguments are not references?  For now, rely on a "pure" attribute.
-  if (auto call = dyn_cast<fir::CallOp>(op)) {
-    if (!call.getAttr("pure"))
-      return true;
-  } else if (auto dispatch = dyn_cast<fir::DispatchOp>(op)) {
-    if (!dispatch.getAttr("pure"))
-      return true;
-  } else if (auto call = dyn_cast<mlir::CallOp>(op)) {
-    if (!call.getAttr("pure"))
-      return true;
-  } else if (auto icall = dyn_cast<mlir::CallIndirectOp>(op)) {
-    if (!icall.getAttr("pure"))
-      return true;
-  }
+  if (auto call = dyn_cast<fir::CallOp>(op))
+    return !call.getAttr("pure");
+  if (auto dispatch = dyn_cast<fir::DispatchOp>(op))
+    return !dispatch.getAttr("pure");
+  if (auto call = dyn_cast<mlir::CallOp>(op))
+    return !call.getAttr("pure");
+  if (auto icall = dyn_cast<mlir::CallIndirectOp>(op))
+    return !icall.getAttr("pure");
+  return false;
+}
+
+/// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
+/// mlir::CallOp, or mlir::CallIndirectOp and is also pure.
+/// NB: this is not the same as `!impureCall(op)`
+inline bool pureCall(mlir::Operation *op) {
+  // Should we also auto-detect that the called function is pure if its
+  // arguments are not references?  For now, rely on a "pure" attribute.
+  if (auto call = dyn_cast<fir::CallOp>(op))
+    return bool(call.getAttr("pure"));
+  if (auto dispatch = dyn_cast<fir::DispatchOp>(op))
+    return bool(dispatch.getAttr("pure"));
+  if (auto call = dyn_cast<mlir::CallOp>(op))
+    return bool(call.getAttr("pure"));
+  if (auto icall = dyn_cast<mlir::CallIndirectOp>(op))
+    return bool(icall.getAttr("pure"));
   return false;
 }
 
 } // namespace fir
 
-#endif // FIR_FIROPSSUPPORT_H
+#endif // FIR_FIROPS_SUPPORT_H
diff --git a/include/fir/Type.h b/include/fir/FIRType.h
similarity index 90%
rename from include/fir/Type.h
rename to include/fir/FIRType.h
index 8a469c4d35b8..a5161c3afa03 100644
--- a/include/fir/Type.h
+++ b/include/fir/FIRType.h
@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_TYPE_H
-#define FIR_TYPE_H
+#ifndef DIALECT_FIR_FIRTYPE_H
+#define DIALECT_FIR_FIRTYPE_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Types.h"
-#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 class raw_ostream;
@@ -27,6 +27,11 @@ class ArrayRef;
 class hash_code;
 } // namespace llvm
 
+namespace mlir {
+class DialectAsmParser;
+class DialectAsmPrinter;
+} // namespace mlir
+
 namespace fir {
 
 class FIROpsDialect;
@@ -43,6 +48,7 @@ struct DimsTypeStorage;
 struct FieldTypeStorage;
 struct HeapTypeStorage;
 struct IntTypeStorage;
+struct LenTypeStorage;
 struct LogicalTypeStorage;
 struct PointerTypeStorage;
 struct RealTypeStorage;
@@ -64,7 +70,8 @@ enum TypeKind {
   FIR_DIMS,
   FIR_FIELD,
   FIR_HEAP,
-  FIR_INT,     // intrinsic
+  FIR_INT, // intrinsic
+  FIR_LEN,
   FIR_LOGICAL, // intrinsic
   FIR_POINTER,
   FIR_REAL, // intrinsic
@@ -202,6 +209,14 @@ class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
                                mlir::MLIRContext *context, mlir::Type eleTy);
 };
 
+class LenType
+    : public mlir::Type::TypeBase<LenType, mlir::Type, detail::LenTypeStorage> {
+public:
+  using Base::Base;
+  static LenType get(mlir::MLIRContext *ctxt, KindTy _ = 0);
+  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_LEN; }
+};
+
 class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
                                                 detail::PointerTypeStorage> {
 public:
@@ -235,14 +250,13 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
                                                  detail::SequenceTypeStorage> {
 public:
   using Base::Base;
-  using BoundInfo = int64_t;
-  using Extent = llvm::Optional<BoundInfo>;
-  using Bounds = std::vector<Extent>;
-  using Shape = llvm::Optional<Bounds>;
+  using Extent = int64_t;
+  using Shape = llvm::SmallVector<Extent, 8>;
 
   mlir::Type getEleTy() const;
   Shape getShape() const;
   mlir::AffineMapAttr getLayoutMap() const;
+  unsigned getDimension() const { return getShape().size(); }
 
   static SequenceType get(const Shape &shape, mlir::Type elementType,
                           mlir::AffineMapAttr map = {});
@@ -283,6 +297,13 @@ class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
   TypeList getTypeList();
   TypeList getLenParamList();
 
+  mlir::Type getType(llvm::StringRef ident);
+  mlir::Type getType(unsigned index) {
+    assert(index < getNumFields());
+    return getTypeList()[index].second;
+  }
+  unsigned getNumFields() { return getTypeList().size(); }
+
   static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
   void finalize(llvm::ArrayRef<TypePair> lenPList,
                 llvm::ArrayRef<TypePair> typeList);
@@ -297,17 +318,10 @@ class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
                                llvm::StringRef name);
 };
 
-mlir::Type parseFirType(FIROpsDialect *dialect, llvm::StringRef rawData,
-                        mlir::Location loc);
+mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
 
-void printFirType(FIROpsDialect *dialect, mlir::Type ty, llvm::raw_ostream &os);
+void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);
 
 } // namespace fir
 
-namespace llvm {
-inline llvm::hash_code hash_value(const Optional<int64_t> &ext) {
-  return fir::hash_value(ext);
-}
-} // namespace llvm
-
-#endif // FIR_TYPE_H
+#endif // DIALECT_FIR_FIRTYPE_H
diff --git a/include/fir/InternalNames.h b/include/fir/InternalNames.h
new file mode 100644
index 000000000000..9f00d150cd53
--- /dev/null
+++ b/include/fir/InternalNames.h
@@ -0,0 +1,89 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIR_INTERNAL_NAMES_H
+#define FIR_INTERNAL_NAMES_H
+
+#include "llvm/ADT/StringSet.h"
+#include <cstdint>
+
+namespace llvm {
+template <typename>
+class ArrayRef;
+template <typename>
+class Optional;
+class Twine;
+} // namespace llvm
+
+namespace fir {
+
+/// Internal name mangling of identifiers
+struct NameMangler {
+  enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };
+
+  NameMangler();
+
+  /// Mangle a common block name
+  llvm::Twine doCommonBlock(llvm::StringRef name);
+
+  /// Mangle a (global) constant name
+  llvm::Twine doConstant(llvm::ArrayRef<llvm::StringRef> modules,
+                         llvm::StringRef name);
+
+  /// Mangle a dispatch table name
+  llvm::Twine doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
+                              llvm::Optional<llvm::StringRef> host,
+                              llvm::StringRef name,
+                              llvm::ArrayRef<std::int64_t> kinds);
+
+  /// Mangle a compiler generated name
+  llvm::Twine doGenerated(llvm::StringRef name);
+
+  /// Mangle an intrinsic type descriptor
+  llvm::Twine doIntrinsicTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+                                        llvm::Optional<llvm::StringRef> host,
+                                        IntrinsicType type, std::int64_t kind);
+
+  /// Mangle a procedure name
+  llvm::Twine doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
+                          llvm::Optional<llvm::StringRef> host,
+                          llvm::StringRef name);
+
+  /// Mangle a derived type name
+  llvm::Twine doType(llvm::ArrayRef<llvm::StringRef> modules,
+                     llvm::Optional<llvm::StringRef> host, llvm::StringRef name,
+                     llvm::ArrayRef<std::int64_t> kinds);
+
+  /// Mangle a (derived) type descriptor name
+  llvm::Twine doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+                               llvm::Optional<llvm::StringRef> host,
+                               llvm::StringRef name,
+                               llvm::ArrayRef<std::int64_t> kinds);
+
+  /// Mangle a (global) variable name
+  llvm::Twine doVariable(llvm::ArrayRef<llvm::StringRef> modules,
+                         llvm::StringRef name);
+
+private:
+  llvm::Twine addAsString(std::int64_t i);
+  llvm::Twine doKind(std::int64_t kind);
+  llvm::Twine doKinds(llvm::ArrayRef<std::int64_t> kinds);
+  llvm::Twine toLower(llvm::StringRef name);
+
+  llvm::StringSet<> cache;
+};
+
+} // namespace fir
+
+#endif // FIR_INTERNAL_NAMES_H
diff --git a/include/fir/Tilikum/Tilikum.h b/include/fir/Tilikum/Tilikum.h
index d08737ea80ba..dca126e0491e 100644
--- a/include/fir/Tilikum/Tilikum.h
+++ b/include/fir/Tilikum/Tilikum.h
@@ -17,6 +17,9 @@
 
 #include <memory>
 
+namespace llvm {
+class StringRef;
+}
 namespace mlir {
 class Pass;
 }
@@ -27,7 +30,7 @@ namespace fir {
 std::unique_ptr<mlir::Pass> createFIRToLLVMPass();
 
 /// Convert the LLVM IR dialect to LLVM-IR proper
-std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass();
+std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass(llvm::StringRef output);
 
 } // namespace fir
 
diff --git a/include/fir/Transforms/Passes.h b/include/fir/Transforms/Passes.h
index 64fd3bebefaf..faafc64608ed 100644
--- a/include/fir/Transforms/Passes.h
+++ b/include/fir/Transforms/Passes.h
@@ -28,6 +28,11 @@ namespace fir {
 /// Effects aware CSE pass
 std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createCSEPass();
 
+/// Convert `fir.loop` and `fir.where` to `loop.for` and `loop.if`.  This
+/// conversion enables the `createLowerToCFGPass` to transform these to CFG
+/// form.
+std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createFirToLoopPass();
+
 /// A pass to convert the FIR dialect from "Mem-SSA" form to "Reg-SSA"
 /// form. This pass is a port of LLVM's mem2reg pass, but modified for the FIR
 /// dialect as well as the restructuring of MLIR's representation to present PHI
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 0897ea911cf1..87922bfeba47 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -16,9 +16,9 @@
 #include "builder.h"
 #include "convert-expr.h"
 #include "fe-helper.h"
-#include "fir/Dialect.h"
+#include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 #include "flattened.h"
 #include "intrinsics.h"
 #include "io.h"
@@ -166,13 +166,13 @@ class FIRConverter {
     return {};
   }
   M::Value *genGE(M::Value *lhs, M::Value *rhs) {
-    return genCompare<M::CmpIPredicate::SGE>(lhs, rhs);
+    return genCompare<M::CmpIPredicate::sge>(lhs, rhs);
   }
   M::Value *genLE(M::Value *lhs, M::Value *rhs) {
-    return genCompare<M::CmpIPredicate::SLE>(lhs, rhs);
+    return genCompare<M::CmpIPredicate::sle>(lhs, rhs);
   }
   M::Value *genEQ(M::Value *lhs, M::Value *rhs) {
-    return genCompare<M::CmpIPredicate::EQ>(lhs, rhs);
+    return genCompare<M::CmpIPredicate::eq>(lhs, rhs);
   }
   M::Value *genAND(M::Value *lhs, M::Value *rhs) {
     return build().create<M::AndOp>(lhs->getLoc(), lhs, rhs);
@@ -364,6 +364,8 @@ class FIRConverter {
     auto &fas{stmt.statement};
     auto &ctrl{std::get<Co::Indirection<Pa::ConcurrentHeader>>(fas.t).value()};
     auto &bld{build()};
+    (void)ctrl;
+    (void)bld;  // FIXME
     // bld.create<fir::LoopOp>();
     for (auto &s : std::get<std::list<Pa::ForallBodyConstruct>>(forall.t)) {
       genFIROnVariant(s);
@@ -452,7 +454,7 @@ class FIRConverter {
       auto zero{build().create<M::ConstantOp>(
           load.getLoc(), build().getIntegerAttr(load.getType(), 0))};
       auto cond{build().create<M::CmpIOp>(
-          load.getLoc(), M::CmpIPredicate::SGT, load, zero)};
+          load.getLoc(), M::CmpIPredicate::sgt, load, zero)};
       info->condition = cond;
     }
   }
@@ -463,21 +465,23 @@ class FIRConverter {
     build().create<M::CallOp>(toLocation(), callee, operands);
     build().create<fir::UnreachableOp>(toLocation());
   }
+
   void genReturnStmt(AnalysisData &, const Pa::FunctionSubprogram &func) {
     auto &stmt{std::get<Pa::Statement<Pa::FunctionStmt>>(func.t)};
     auto &name{std::get<Pa::Name>(stmt.statement.t)};
     assert(name.symbol);
     const auto &details{name.symbol->get<Se::SubprogramDetails>()};
-    const Se::Symbol *result{&details.result()};
-    M::Value *resultRef{symbolMap.lookupSymbol(result)};
+    M::Value *resultRef{symbolMap.lookupSymbol(details.result())};
     assert(resultRef);  // FIXME might die if result
     // was never referenced before and temp not created.
     M::Value *resultVal{build().create<fir::LoadOp>(toLocation(), resultRef)};
     build().create<M::ReturnOp>(toLocation(), resultVal);
   }
+
   void genReturnStmt(const Pa::MainProgram &) {
     build().create<M::ReturnOp>(toLocation());
   }
+
   void genReturnStmt(
       const Pa::SubroutineSubprogram &, const Pa::ReturnStmt * = nullptr) {
     // TODO use Pa::ReturnStmt for alternate return
@@ -973,13 +977,15 @@ void FIRConverter::translateRoutine(
     llvm::SmallVector<M::Type, 2> results;
     if (funcSym) {
       if (auto *details{funcSym->detailsIf<Se::SubprogramDetails>()}) {
-        for (auto a : details->dummyArgs()) {
-          auto type{translateSymbolToFIRType(&mlirContext, defaults, a)};
-          args.push_back(fir::ReferenceType::get(type));
+        for (auto *a : details->dummyArgs()) {
+          if (a) {  // nullptr indicates alternate return argument
+            auto type{translateSymbolToFIRType(&mlirContext, defaults, *a)};
+            args.push_back(fir::ReferenceType::get(type));
+          }
         }
         if (details->isFunction()) {
           // FIXME: handle subroutines that return magic values
-          auto *result{&details->result()};
+          auto result{details->result()};
           results.push_back(
               translateSymbolToFIRType(&mlirContext, defaults, result));
         }
@@ -998,9 +1004,14 @@ void FIRConverter::translateRoutine(
   if (funcSym) {
     auto *entryBlock{&func.front()};
     if (auto *details{funcSym->detailsIf<Se::SubprogramDetails>()}) {
+      // TODO zipping might be an issue in case of alternate returns
       for (const auto &v :
           llvm::zip(details->dummyArgs(), entryBlock->getArguments())) {
-        symbolMap.addSymbol(std::get<0>(v), std::get<1>(v));
+        if (std::get<0>(v)) {
+          symbolMap.addSymbol(*std::get<0>(v), std::get<1>(v));
+        } else {
+          TODO();  // handle alternate return, maybe nothing todo here though
+        }
       }
     } else {
       llvm::errs() << "Symbol: " << funcSym->name().ToString() << " @ "
@@ -1015,8 +1026,6 @@ void FIRConverter::translateRoutine(
   finalizeQueued();
 }
 
-M::DialectRegistration<fir::FIROpsDialect> FIROps;
-
 }  // namespace
 
 void Br::crossBurnsideBridge(BurnsideBridge &bridge, const Pa::Program &prg) {
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index 650f80c21790..409203483f2b 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -45,11 +45,11 @@ mlir::FuncOp B::getNamedFunction(mlir::ModuleOp module, llvm::StringRef name) {
   return module.lookupSymbol<mlir::FuncOp>(name);
 }
 
-void B::SymMap::addSymbol(const semantics::Symbol *symbol, mlir::Value *value) {
-  symbolMap.try_emplace(symbol, value);
+void B::SymMap::addSymbol(semantics::SymbolRef symbol, mlir::Value *value) {
+  symbolMap.try_emplace(&*symbol, value);
 }
 
-mlir::Value *B::SymMap::lookupSymbol(const semantics::Symbol *symbol) {
-  auto iter{symbolMap.find(symbol)};
+mlir::Value *B::SymMap::lookupSymbol(semantics::SymbolRef symbol) {
+  auto iter{symbolMap.find(&*symbol)};
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index a2bce6b79faa..563a13e0db6f 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -40,9 +40,9 @@ class SymMap {
   llvm::DenseMap<const semantics::Symbol *, mlir::Value *> symbolMap;
 
 public:
-  void addSymbol(const semantics::Symbol *symbol, mlir::Value *value);
+  void addSymbol(semantics::SymbolRef symbol, mlir::Value *value);
 
-  mlir::Value *lookupSymbol(const semantics::Symbol *symbol);
+  mlir::Value *lookupSymbol(semantics::SymbolRef symbol);
 };
 
 std::string applyNameMangling(llvm::StringRef parserName);
diff --git a/lib/burnside/complex.h b/lib/burnside/complex-handler.h
similarity index 65%
rename from lib/burnside/complex.h
rename to lib/burnside/complex-handler.h
index bdf874d6fbca..6c408c0e9879 100644
--- a/lib/burnside/complex.h
+++ b/lib/burnside/complex-handler.h
@@ -19,66 +19,66 @@
 
 #include "fe-helper.h"
 #include "fir/FIROps.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 
 namespace Fortran::burnside {
 /// Provide helpers to generate Complex manipulations in FIR.
 
 class ComplexHandler {
 public:
+  // The values of part enum members are meaningful for
+  // InsertValueOp and ExtractValueOp so they are explicit.
+  enum class Part { Real = 0, Imag = 1 };
+
   ComplexHandler(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
   mlir::Type getComplexPartType(fir::KindTy complexKind) {
     return convertReal(builder.getContext(), complexKind);
   }
 
+  mlir::Value *createComplex(
+      fir::KindTy kind, mlir::Value *real, mlir::Value *imag) {
+    mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
+    mlir::Value *und{builder.create<fir::UndefOp>(loc, complexTy)};
+    return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
+  }
+
+  // Complex part manipulation helpers
   mlir::Type getComplexPartType(mlir::Type complexType) {
     return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
   }
-
   mlir::Type getComplexPartType(mlir::Value *cplx) {
     assert(cplx != nullptr);
     return getComplexPartType(cplx->getType());
   }
 
-  mlir::Value *createComplexPart(mlir::Value *cplx, bool isImaginaryPart) {
+  template<Part partId> mlir::Value *extract(mlir::Value *cplx) {
     return builder.create<fir::ExtractValueOp>(
-        loc, getComplexPartType(cplx), cplx, getPartId(isImaginaryPart));
-  }
-
-  mlir::Value *createComplexRealPart(mlir::Value *cplx) {
-    return createComplexPart(cplx, false);
+        loc, getComplexPartType(cplx), cplx, getPartId<partId>());
   }
-
-  mlir::Value *createComplexImagPart(mlir::Value *cplx) {
-    return createComplexPart(cplx, true);
-  }
-
-  mlir::Value *setComplexPart(
-      mlir::Value *cplx, mlir::Value *part, bool isImaginaryPart) {
+  template<Part partId>
+  mlir::Value *insert(mlir::Value *cplx, mlir::Value *part) {
     assert(cplx != nullptr);
     return builder.create<fir::InsertValueOp>(
-        loc, cplx->getType(), cplx, part, getPartId(isImaginaryPart));
-  }
-  mlir::Value *setRealPart(mlir::Value *cplx, mlir::Value *part) {
-    return setComplexPart(cplx, part, false);
-  }
-  mlir::Value *setImagPart(mlir::Value *cplx, mlir::Value *part) {
-    return setComplexPart(cplx, part, true);
+        loc, cplx->getType(), cplx, part, getPartId<partId>());
   }
 
-  mlir::Value *createComplex(
-      fir::KindTy kind, mlir::Value *real, mlir::Value *imag) {
-    mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
-    mlir::Value *und{builder.create<fir::UndefOp>(loc, complexTy)};
-    return setImagPart(setRealPart(und, real), imag);
+  /// Complex part access helper dynamic versions
+  mlir::Value *extractComplexPart(mlir::Value *cplx, bool isImagPart) {
+    return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
+  }
+  mlir::Value *insertComplexPart(
+      mlir::Value *cplx, mlir::Value *part, bool isImagPart) {
+    return isImagPart ? insert<Part::Imag>(cplx, part)
+                      : insert<Part::Real>(cplx, part);
   }
 
+  // Complex operation helpers
   mlir::Value *createComplexCompare(
       mlir::Value *cplx1, mlir::Value *cplx2, bool eq) {
-    mlir::Value *real1{createComplexRealPart(cplx1)};
-    mlir::Value *real2{createComplexRealPart(cplx2)};
-    mlir::Value *imag1{createComplexImagPart(cplx1)};
-    mlir::Value *imag2{createComplexImagPart(cplx2)};
+    mlir::Value *real1{extract<Part::Real>(cplx1)};
+    mlir::Value *real2{extract<Part::Real>(cplx2)};
+    mlir::Value *imag1{extract<Part::Imag>(cplx1)};
+    mlir::Value *imag2{extract<Part::Imag>(cplx2)};
 
     mlir::CmpFPredicate predicate{
         eq ? mlir::CmpFPredicate::UEQ : mlir::CmpFPredicate::UNE};
@@ -95,9 +95,10 @@ class ComplexHandler {
   }
 
 private:
-  inline mlir::Value *getPartId(bool isImaginaryPart) {
+  // Make mlir ConstantOp from template part id.
+  template<Part partId> inline mlir::Value *getPartId() {
     auto type{mlir::IntegerType::get(32, builder.getContext())};
-    auto attr{builder.getIntegerAttr(type, isImaginaryPart ? 1 : 0)};
+    auto attr{builder.getIntegerAttr(type, static_cast<int>(partId))};
     return builder.create<mlir::ConstantOp>(loc, type, attr).getResult();
   }
 
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index d5528844ed1d..62a47c794f3e 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -14,11 +14,11 @@
 
 #include "convert-expr.h"
 #include "builder.h"
-#include "complex.h"
+#include "complex-handler.h"
 #include "fe-helper.h"
-#include "fir/Dialect.h"
+#include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 #include "intrinsics.h"
 #include "runtime.h"
 #include "../common/default-kinds.h"
@@ -80,12 +80,12 @@ class ExprLowering {
   /// unordered, but we may want to cons ordered in certain situation.
   static M::CmpIPredicate translateRelational(Co::RelationalOperator rop) {
     switch (rop) {
-    case Co::RelationalOperator::LT: return M::CmpIPredicate::SLT;
-    case Co::RelationalOperator::LE: return M::CmpIPredicate::SLE;
-    case Co::RelationalOperator::EQ: return M::CmpIPredicate::EQ;
-    case Co::RelationalOperator::NE: return M::CmpIPredicate::NE;
-    case Co::RelationalOperator::GT: return M::CmpIPredicate::SGT;
-    case Co::RelationalOperator::GE: return M::CmpIPredicate::SGE;
+    case Co::RelationalOperator::LT: return M::CmpIPredicate::slt;
+    case Co::RelationalOperator::LE: return M::CmpIPredicate::sle;
+    case Co::RelationalOperator::EQ: return M::CmpIPredicate::eq;
+    case Co::RelationalOperator::NE: return M::CmpIPredicate::ne;
+    case Co::RelationalOperator::GT: return M::CmpIPredicate::sgt;
+    case Co::RelationalOperator::GE: return M::CmpIPredicate::sge;
     }
     assert(false && "unhandled INTEGER relational operator");
     return {};
@@ -93,14 +93,15 @@ class ExprLowering {
 
   /// Convert parser's REAL relational operators to MLIR.  TODO: using
   /// unordered, but we may want to cons ordered in certain situation.
-  static M::CmpFPredicate translateFloatRelational(Co::RelationalOperator rop) {
+  static fir::CmpFPredicate translateFloatRelational(
+      Co::RelationalOperator rop) {
     switch (rop) {
-    case Co::RelationalOperator::LT: return M::CmpFPredicate::ULT;
-    case Co::RelationalOperator::LE: return M::CmpFPredicate::ULE;
-    case Co::RelationalOperator::EQ: return M::CmpFPredicate::UEQ;
-    case Co::RelationalOperator::NE: return M::CmpFPredicate::UNE;
-    case Co::RelationalOperator::GT: return M::CmpFPredicate::UGT;
-    case Co::RelationalOperator::GE: return M::CmpFPredicate::UGE;
+    case Co::RelationalOperator::LT: return fir::CmpFPredicate::ULT;
+    case Co::RelationalOperator::LE: return fir::CmpFPredicate::ULE;
+    case Co::RelationalOperator::EQ: return fir::CmpFPredicate::UEQ;
+    case Co::RelationalOperator::NE: return fir::CmpFPredicate::UNE;
+    case Co::RelationalOperator::GT: return fir::CmpFPredicate::UGT;
+    case Co::RelationalOperator::GE: return fir::CmpFPredicate::UGE;
     }
     assert(false && "unhandled REAL relational operator");
     return {};
@@ -149,6 +150,19 @@ class ExprLowering {
   template<typename OpTy, typename A> M::Value *createBinaryOp(A const &ex) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), genval(ex.right()));
   }
+  template<typename OpTy, typename A> M::Value *createLogicalOp(A const &ex) {
+    auto mlirTy{M::IntegerType::get(1, builder.getContext())};
+    auto *lhs{genval(ex.left())};
+    auto *rhs{genval(ex.right())};
+    // mlir logical ops do not work with fir.logical<k>, so the operation
+    // is wrapped in conversions
+    auto lhsConv{builder.create<fir::ConvertOp>(getLoc(), mlirTy, lhs)};
+    auto rhsConv{builder.create<fir::ConvertOp>(getLoc(), mlirTy, rhs)};
+    auto op{createBinaryOp<OpTy>(ex, lhsConv, rhsConv)};
+    assert(lhs);
+    auto resType{lhs->getType()};
+    return builder.create<fir::ConvertOp>(getLoc(), resType, op);
+  }
 
   M::FuncOp getFunction(L::StringRef name, M::FunctionType funTy) {
     auto module{getModule(&builder)};
@@ -212,24 +226,24 @@ class ExprLowering {
   }
   template<typename OpTy, typename A>
   M::Value *createFltCmpOp(
-      A const &ex, M::CmpFPredicate pred, M::Value *lhs, M::Value *rhs) {
+      A const &ex, fir::CmpFPredicate pred, M::Value *lhs, M::Value *rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
   template<typename OpTy, typename A>
-  M::Value *createFltCmpOp(A const &ex, M::CmpFPredicate pred) {
+  M::Value *createFltCmpOp(A const &ex, fir::CmpFPredicate pred) {
     return createFltCmpOp<OpTy>(
         ex, pred, genval(ex.left()), genval(ex.right()));
   }
 
-  M::Value *gen(Se::Symbol const *sym) {
+  M::Value *gen(Se::SymbolRef sym) {
     // FIXME: not all symbols are local
     return createTemporary(getLoc(), builder, symMap,
-        translateSymbolToFIRType(builder.getContext(), defaults, sym), sym);
+        translateSymbolToFIRType(builder.getContext(), defaults, sym), &*sym);
   }
-  M::Value *gendef(Se::Symbol const *sym) { return gen(sym); }
-  M::Value *genval(Se::Symbol const *sym) {
+  M::Value *gendef(Se::SymbolRef sym) { return gen(sym); }
+  M::Value *genval(Se::SymbolRef sym) {
     // Do not load the same symbols several time in one expression.
     // Fortran guarantees variable value must be the same wherever it
     // appears in one expression.
@@ -254,7 +268,7 @@ class ExprLowering {
   }
 
   template<int KIND> M::Value *genval(Ev::ComplexComponent<KIND> const &part) {
-    return ComplexHandler{builder, getLoc()}.createComplexPart(
+    return ComplexHandler{builder, getLoc()}.extractComplexPart(
         genval(part.left()), part.isImaginaryPart);
   }
 
@@ -348,21 +362,25 @@ class ExprLowering {
 
   template<Co::TypeCategory TC, int KIND>
   M::Value *genval(Ev::Relational<Ev::Type<TC, KIND>> const &op) {
+    mlir::Value *result{nullptr};
     if constexpr (TC == IntegerCat) {
-      return createCompareOp<M::CmpIOp>(op, translateRelational(op.opr));
+      result = createCompareOp<M::CmpIOp>(op, translateRelational(op.opr));
     } else if constexpr (TC == RealCat) {
-      return createFltCmpOp<M::CmpFOp>(op, translateFloatRelational(op.opr));
+      result =
+          createFltCmpOp<fir::CmpfOp>(op, translateFloatRelational(op.opr));
     } else if constexpr (TC == ComplexCat) {
       bool eq{op.opr == Co::RelationalOperator::EQ};
       assert(eq ||
           op.opr == Co::RelationalOperator::NE &&
               "relation undefined for complex");
-      return ComplexHandler{builder, getLoc()}.createComplexCompare(
+      result = ComplexHandler{builder, getLoc()}.createComplexCompare(
           genval(op.left()), genval(op.right()), eq);
     } else {
       static_assert(TC == CharacterCat);
       TODO();
     }
+    auto logicalTy{getFIRType(builder.getContext(), defaults, LogicalCat)};
+    return builder.create<fir::ConvertOp>(getLoc(), logicalTy, result);
   }
 
   // TODO JP: the thing below should not be required.
@@ -382,16 +400,24 @@ class ExprLowering {
   }
 
   template<int KIND> M::Value *genval(Ev::LogicalOperation<KIND> const &op) {
+    mlir::Value *result{nullptr};
     switch (op.logicalOperator) {
-    case Ev::LogicalOperator::And: return createBinaryOp<M::AndOp>(op);
-    case Ev::LogicalOperator::Or: return createBinaryOp<M::OrOp>(op);
+    case Ev::LogicalOperator::And:
+      result = createLogicalOp<M::AndOp>(op);
+      break;
+    case Ev::LogicalOperator::Or: result = createLogicalOp<M::OrOp>(op); break;
     case Ev::LogicalOperator::Eqv:
-      return createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::EQ);
+      result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::eq);
+      break;
     case Ev::LogicalOperator::Neqv:
-      return createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::NE);
+      result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::ne);
+      break;
     }
-    assert(false && "unhandled logical operation");
-    return {};
+    if (!result) {
+      assert(false && "unhandled logical operation");
+    }
+    auto logicalTy{getFIRType(builder.getContext(), defaults, LogicalCat)};
+    return builder.create<fir::ConvertOp>(getLoc(), logicalTy, result);
   }
 
   template<Co::TypeCategory TC, int KIND>
@@ -515,13 +541,15 @@ class ExprLowering {
     L::SmallVector<M::Value *, 2> coorArgs;
     auto obj{gen(*base)};
     const Se::Symbol *sym{nullptr};
+    M::Type ty{translateSymbolToFIRType(builder.getContext(), defaults, *sym)};
     for (auto *field : list) {
       sym = &field->GetLastSymbol();
       auto name{sym->name().ToString()};
-      coorArgs.push_back(builder.create<fir::FieldIndexOp>(getLoc(), name));
+      // FIXME: as we're walking the chain of field names, we need to update the
+      // subtype as we drill down
+      coorArgs.push_back(builder.create<fir::FieldIndexOp>(getLoc(), name, ty));
     }
     assert(sym && "no component(s)?");
-    M::Type ty{translateSymbolToFIRType(builder.getContext(), defaults, sym)};
     ty = fir::ReferenceType::get(ty);
     return builder.create<fir::CoordinateOp>(getLoc(), ty, obj, coorArgs);
   }
@@ -565,7 +593,7 @@ class ExprLowering {
   M::Value *gen(Ev::ArrayRef const &aref) {
     M::Value *base;
     if (aref.base().IsSymbol())
-      base = gen(const_cast<Se::Symbol *>(&aref.base().GetFirstSymbol()));
+      base = gen(aref.base().GetFirstSymbol());
     else
       base = gen(aref.base().GetComponent());
     llvm::SmallVector<M::Value *, 8> args;
@@ -640,7 +668,7 @@ class ExprLowering {
         const auto *expr{arg->UnwrapExpr()};
         assert(expr && "assumed type argument requires explicit interface");
         if (const Se::Symbol * sym{Ev::UnwrapWholeSymbolDataRef(*expr)}) {
-          M::Value *argRef{symMap.lookupSymbol(sym)};
+          M::Value *argRef{symMap.lookupSymbol(*sym)};
           assert(argRef && "could not get symbol reference");
           argTypes.push_back(argRef->getType());
           operands.push_back(argRef);
@@ -709,7 +737,7 @@ M::Value *Br::createSomeAddress(M::Location loc, M::OpBuilder &builder,
 M::Value *Br::createTemporary(M::Location loc, M::OpBuilder &builder,
     SymMap &symMap, M::Type type, Se::Symbol const *symbol) {
   if (symbol)
-    if (auto *val{symMap.lookupSymbol(symbol)}) {
+    if (auto *val{symMap.lookupSymbol(*symbol)}) {
       if (auto *op{val->getDefiningOp()}) {
         return op->getResult(0);
       }
@@ -721,7 +749,7 @@ M::Value *Br::createTemporary(M::Location loc, M::OpBuilder &builder,
   assert(!type.dyn_cast<fir::ReferenceType>() && "cannot be a reference");
   if (symbol) {
     ae = builder.create<fir::AllocaOp>(loc, type, symbol->name().ToString());
-    symMap.addSymbol(symbol, ae);
+    symMap.addSymbol(*symbol, ae);
   } else {
     ae = builder.create<fir::AllocaOp>(loc, type);
   }
diff --git a/lib/burnside/fe-helper.cc b/lib/burnside/fe-helper.cc
index 72265d6b66fe..eaa649afed19 100644
--- a/lib/burnside/fe-helper.cc
+++ b/lib/burnside/fe-helper.cc
@@ -14,7 +14,7 @@
 
 #include "fe-helper.h"
 #include "bridge.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 #include "../semantics/expression.h"
 #include "../semantics/tools.h"
 #include "../semantics/type.h"
@@ -46,7 +46,9 @@ template<typename A> int64_t toConstant(const Ev::Expr<A> &e) {
 }
 
 #undef TODO
-#define TODO() assert(false); return {}
+#define TODO() \
+  assert(false && "not yet implemented"); \
+  return {}
 
 // one argument template, must be specialized
 template<Co::TypeCategory TC>
@@ -218,7 +220,7 @@ class TypeBuilder {
 
   M::Type mkVoid() { return M::TupleType::get(context); }
 
-  fir::SequenceType::Shape genSeqShape(const Se::Symbol *symbol) {
+  fir::SequenceType::Shape genSeqShape(Se::SymbolRef symbol) {
     assert(symbol->IsObjectArray());
     fir::SequenceType::Bounds bounds;
     auto &details = symbol->get<Se::ObjectEntityDetails>();
@@ -248,17 +250,20 @@ class TypeBuilder {
 
   /// Type consing from a symbol. A symbol's type must be created from the type
   /// discovered by the front-end at runtime.
-  M::Type gen(const Se::Symbol *symbol) {
+  M::Type gen(Se::SymbolRef symbol) {
     if (auto *proc = symbol->detailsIf<Se::SubprogramDetails>()) {
       M::Type returnTy{mkVoid()};
       if (proc->isFunction()) {
-        returnTy = gen(&proc->result());
+        returnTy = gen(proc->result());
       }
       // FIXME: handle alt-return
       llvm::SmallVector<M::Type, 4> inputTys;
       for (auto *arg : proc->dummyArgs()) {
         // FIXME: not all args are pass by ref
-        inputTys.emplace_back(fir::ReferenceType::get(gen(arg)));
+        // Nullptr args are alternate returns indicators
+        if (arg) {
+          inputTys.emplace_back(fir::ReferenceType::get(gen(*arg)));
+        }
       }
       return M::FunctionType::get(inputTys, returnTy, context);
     }
@@ -283,6 +288,7 @@ class TypeBuilder {
         case DerivedCat: TODO(); break;
         }
       } else if (auto *tySpec{type->AsDerived()}) {
+        (void)tySpec; // FIXME
         TODO();
       } else {
         assert(false && "type spec not found");
@@ -375,7 +381,7 @@ M::Type Br::translateSomeExprToFIRType(M::MLIRContext *context,
 // This entry point avoids gratuitously wrapping the Symbol instance in layers
 // of Expr<T> that will then be immediately peeled back off and discarded.
 M::Type Br::translateSymbolToFIRType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, const Se::Symbol *symbol) {
+    Co::IntrinsicTypeDefaultKinds const &defaults, Se::SymbolRef symbol) {
   return TypeBuilder{context, defaults}.gen(symbol);
 }
 
diff --git a/lib/burnside/fe-helper.h b/lib/burnside/fe-helper.h
index 3eb90d83d9c2..bc7352339212 100644
--- a/lib/burnside/fe-helper.h
+++ b/lib/burnside/fe-helper.h
@@ -32,6 +32,7 @@ class Type;
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
+template<typename T> class Reference;
 }  // common
 
 namespace evaluate {
@@ -50,6 +51,7 @@ class CookedSource;
 
 namespace semantics {
 class Symbol;
+using SymbolRef = common::Reference<const Symbol>;
 }  // semantics
 
 namespace burnside {
@@ -100,7 +102,7 @@ mlir::Type translateSomeExprToFIRType(mlir::MLIRContext *ctxt,
 
 mlir::Type translateSymbolToFIRType(mlir::MLIRContext *ctxt,
     common::IntrinsicTypeDefaultKinds const &defaults,
-    const semantics::Symbol *symbol);
+    const semantics::SymbolRef symbol);
 
 mlir::Type convertReal(mlir::MLIRContext *context, int KIND);
 
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index 4e514e6ee5d1..a80471fa4a12 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -14,12 +14,13 @@
 
 #include "intrinsics.h"
 #include "builder.h"
-#include "complex.h"
+#include "complex-handler.h"
 #include "fe-helper.h"
 #include "fir/FIROps.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 #include "runtime.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/Twine.h"
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -70,13 +71,16 @@ class MathRuntimeLibrary {
   Map library;
 };
 
+/// enum used to templatized code gen for intrinsics that are alike.
+enum class Extremum { Min, Max };
+
 /// The implementation of IntrinsicLibrary is based on a map that associates
 /// Fortran intrinsics generic names to the related FIR generator functions.
 /// All generator functions are member functions of the Implementation class
 /// and they all take the same context argument that contains the name and
 /// arguments of the Fortran intrinsics call to lower among other things.
 /// A same FIR generator function may be able to generate the FIR for several
-/// intrinsics. For instance generateRuntimeCall tries to find a runtime
+/// intrinsics. For instance genRuntimeCall tries to find a runtime
 /// functions that matches the Fortran intrinsic call and generate the
 /// operations to call this functions if it was found.
 /// IntrinsicLibrary holds a constant MathRuntimeLibrary that it uses to
@@ -102,6 +106,7 @@ class IntrinsicLibrary::Implementation {
     llvm::StringRef name;
     llvm::ArrayRef<mlir::Value *> arguments;
     mlir::FunctionType funcType;
+    mlir::ModuleOp getModuleOp() { return getModule(builder); }
     mlir::MLIRContext *getMLIRContext() {
       return getModule(builder).getContext();
     }
@@ -113,7 +118,7 @@ class IntrinsicLibrary::Implementation {
 
   /// Define the different FIR generators that can be mapped to intrinsic to
   /// generate the related code.
-  using Generator = mlir::Value *(Implementation::*)(Context &)const;
+  using Generator = mlir::Value *(Implementation::*)(Context &) const;
   /// Search a runtime function that is associated to the generic intrinsic name
   /// and whose signature matches the intrinsic arguments and result types.
   /// If no such runtime function is found but a runtime function associated
@@ -121,20 +126,21 @@ class IntrinsicLibrary::Implementation {
   /// conversions will be inserted before and/or after the call. This is to
   /// mainly to allow 16 bits float support even-though little or no math
   /// runtime is currently available for it.
-  mlir::Value *generateRuntimeCall(Context &) const;
-  /// All generators can be combined with generateWrapperCall that will build a
+  mlir::Value *genRuntimeCall(Context &) const;
+  /// All generators can be combined with genWrapperCall that will build a
   /// function named "fir."+ <generic name> + "." + <result type code> and
   /// generate the intrinsic implementation inside instead of at the intrinsic
   /// call sites. This can be used to keep the FIR more readable.
-  template<Generator g> mlir::Value *generateWrapperCall(Context &c) const {
+  template<Generator g> mlir::Value *genWrapperCall(Context &c) const {
     return outlineInWrapper(g, c);
   }
   /// The defaultGenerator is always attempted if no mapping was found for the
   /// generic name provided.
   mlir::Value *defaultGenerator(Context &c) const {
-    return generateWrapperCall<&I::generateRuntimeCall>(c);
+    return genWrapperCall<&I::genRuntimeCall>(c);
   }
-  mlir::Value *generateConjg(Context &) const;
+  mlir::Value *genConjg(Context &) const;
+  template<Extremum extremum> mlir::Value *genExtremum(Context &) const;
 
   struct IntrinsicHanlder {
     const char *name;
@@ -146,18 +152,23 @@ class IntrinsicLibrary::Implementation {
   /// defined here for a generic intrinsic, the defaultGenerator will
   /// be attempted.
   static constexpr IntrinsicHanlder handlers[]{
-      {"conjg", &I::generateConjg},
+      {"conjg", &I::genConjg},
+      {"max", &I::genExtremum<Extremum::Max>},
+      {"min", &I::genExtremum<Extremum::Min>},
   };
 
   // helpers
-  static std::string getWrapperName(Context &);
   mlir::Value *outlineInWrapper(Generator, Context &) const;
-  static mlir::FunctionType getFunctionType(mlir::Type resultType,
-      llvm::ArrayRef<mlir::Value *> arguments, mlir::OpBuilder &);
 
   MathRuntimeLibrary runtime;
 };
 
+// helpers
+static std::string getIntrinsicWrapperName(
+    const llvm::StringRef &intrinsic, mlir::FunctionType funTy);
+static mlir::FunctionType getFunctionType(mlir::Type resultType,
+    llvm::ArrayRef<mlir::Value *> arguments, mlir::OpBuilder &);
+
 /// Define a simple static runtime description that will be transformed into
 /// RuntimeFunction when building the IntrinsicLibrary.
 class MathsRuntimeStaticDescription : public RuntimeStaticDescription {
@@ -312,9 +323,8 @@ mlir::Value *IntrinsicLibrary::Implementation::genval(mlir::Location loc,
   return this->defaultGenerator(context);
 }
 
-mlir::FunctionType IntrinsicLibrary::Implementation::getFunctionType(
-    mlir::Type resultType, llvm::ArrayRef<mlir::Value *> arguments,
-    mlir::OpBuilder &builder) {
+static mlir::FunctionType getFunctionType(mlir::Type resultType,
+    llvm::ArrayRef<mlir::Value *> arguments, mlir::OpBuilder &builder) {
   llvm::SmallVector<mlir::Type, 2> argumentTypes;
   for (const auto &arg : arguments) {
     assert(arg != nullptr);  // TODO think about optionals
@@ -324,23 +334,25 @@ mlir::FunctionType IntrinsicLibrary::Implementation::getFunctionType(
       argumentTypes, resultType, getModule(&builder).getContext());
 }
 
-std::string IntrinsicLibrary::Implementation::getWrapperName(Context &c) {
-  // TODO find nicer type to string infra
-  llvm::StringRef prefix{"fir."};
-  assert(c.funcType.getNumResults() == 1);
-  mlir::Type resultType{c.funcType.getResult(0)};
+static std::string getIntrinsicWrapperName(
+    const llvm::StringRef &intrinsic, mlir::FunctionType funTy) {
+  // TODO find nicer type to string infra or move this in a mangling utility
+  auto addSuffix{[&](const llvm::Twine &suffix) -> std::string {
+    return ("fir." + intrinsic + suffix).str();
+  }};
+  assert(funTy.getNumResults() == 1 && "only function mangling supported");
+  mlir::Type resultType{funTy.getResult(0)};
   if (auto f{resultType.dyn_cast<mlir::FloatType>()}) {
-    return prefix.str() + c.name.str() + ".f" + std::to_string(f.getWidth());
+    return addSuffix(".f" + llvm::Twine(f.getWidth()));
   } else if (auto i{resultType.dyn_cast<mlir::IntegerType>()}) {
-    return prefix.str() + c.name.str() + ".i" + std::to_string(i.getWidth());
+    return addSuffix(".i" + llvm::Twine(i.getWidth()));
   } else if (auto cplx{resultType.dyn_cast<fir::CplxType>()}) {
-    // TODO using kind here is weird, but I do not want to hard coded mapping
-    return prefix.str() + c.name.str() + ".c" + std::to_string(cplx.getFKind());
-  } else if (auto firf{resultType.dyn_cast<fir::RealType>()}) {
-    return prefix.str() + c.name.str() + ".f" + std::to_string(firf.getFKind());
+    return addSuffix(".c" + llvm::Twine(cplx.getFKind()));
+  } else if (auto real{resultType.dyn_cast<fir::RealType>()}) {
+    return addSuffix(".r" + llvm::Twine(real.getFKind()));
   } else {
     assert(false);
-    return "fir." + c.name.str() + ".unknown";
+    return addSuffix(".unknown");
   }
 }
 
@@ -348,7 +360,8 @@ mlir::Value *IntrinsicLibrary::Implementation::outlineInWrapper(
     Generator generator, Context &context) const {
   mlir::ModuleOp module{getModule(context.builder)};
   mlir::MLIRContext *mlirContext{module.getContext()};
-  std::string wrapperName{getWrapperName(context)};
+  std::string wrapperName{
+      getIntrinsicWrapperName(context.name, context.funcType)};
   mlir::FuncOp function{getNamedFunction(module, wrapperName)};
   if (!function) {
     // First time this wrapper is needed, build it.
@@ -381,7 +394,7 @@ mlir::Value *IntrinsicLibrary::Implementation::outlineInWrapper(
   return call.getResult(0);
 }
 
-mlir::Value *IntrinsicLibrary::Implementation::generateRuntimeCall(
+mlir::Value *IntrinsicLibrary::Implementation::genRuntimeCall(
     Context &context) const {
   // Look up runtime
   mlir::FunctionType soughtFuncType{context.funcType};
@@ -421,13 +434,14 @@ mlir::Value *IntrinsicLibrary::Implementation::generateRuntimeCall(
     }
   } else {
     // could not find runtime function
-    assert(false);  // TODO: better error handling.
-    return nullptr;
+    assert(false && "no runtime found for this intrinsics");
+    // TODO: better error handling ?
+    //  - Try to have compile time check of runtime compltness ?
   }
 }
 
 // CONJG
-mlir::Value *IntrinsicLibrary::Implementation::generateConjg(
+mlir::Value *IntrinsicLibrary::Implementation::genConjg(
     Context &genCtxt) const {
   assert(genCtxt.arguments.size() == 1);
   mlir::Type resType{genCtxt.getResultType()};
@@ -440,10 +454,68 @@ mlir::Value *IntrinsicLibrary::Implementation::generateConjg(
   mlir::Type realType{cplxHandler.getComplexPartType(cplx)};
   mlir::Value *zero{builder.create<mlir::ConstantOp>(
       genCtxt.loc, realType, builder.getZeroAttr(realType))};
-  mlir::Value *imag{cplxHandler.createComplexImagPart(cplx)};
+  mlir::Value *imag{cplxHandler.extract<ComplexHandler::Part::Imag>(cplx)};
   mlir::Value *negImag{
       genCtxt.builder->create<mlir::SubFOp>(genCtxt.loc, zero, imag)};
-  return cplxHandler.setImagPart(cplx, negImag);
+  return cplxHandler.insert<ComplexHandler::Part::Imag>(cplx, negImag);
+}
+
+static mlir::FuncOp getMergeFunc(mlir::Type type, mlir::ModuleOp module) {
+  llvm::SmallVector<mlir::Type, 3> argTypes{
+      type, type, fir::LogicalType::get(module.getContext(), 4)};
+  auto mergeType{
+      mlir::FunctionType::get(argTypes, {type}, module.getContext())};
+  auto mergeName{getIntrinsicWrapperName("merge", mergeType)};
+  return createFunction(module, mergeName, mergeType);
+}
+
+template<Extremum extremum>
+static mlir::Value *createCompare(mlir::Location loc, mlir::OpBuilder &builder,
+    mlir::Value *left, mlir::Value *right) {
+  static constexpr auto integerPredicate{extremum == Extremum::Max
+          ? mlir::CmpIPredicate::sgt
+          : mlir::CmpIPredicate::slt};
+  static constexpr auto realPredicate{extremum == Extremum::Max
+          ? fir::CmpFPredicate::UGT
+          : fir::CmpFPredicate::ULT};
+  auto type{left->getType()};
+  mlir::Value *result{nullptr};
+  if (type.isa<mlir::FloatType>() || type.isa<fir::RealType>()) {
+    // TODO: The type we get from CmpfOp is a bit weird (it is the operands
+    // types, and not a boolean).
+    result = builder.create<fir::CmpfOp>(loc, realPredicate, left, right);
+  } else if (type.isa<mlir::IntegerType>()) {
+    result = builder.create<mlir::CmpIOp>(loc, integerPredicate, left, right);
+  } else if (type.isa<fir::CharacterType>()) {
+    // TODO: ! character min and max is tricky because the result
+    // length is the length of the longest argument!
+    // So we may need a temp.
+  }
+  assert(result);
+  // TODO which logical type should comparisons return ?
+  // This is also currently not observed in convert-expr
+  auto resTy{fir::LogicalType::get(getModule(&builder).getContext(), 4)};
+  return builder.create<fir::ConvertOp>(loc, resTy, result);
 }
 
+// MIN and MAX
+// Extremum intrinsic are lowered using the MERGE intrinsic
+// to avoid introducing branches.
+template<Extremum extremum>
+mlir::Value *IntrinsicLibrary::Implementation::genExtremum(
+    Context &genCtxt) const {
+  auto &builder{*genCtxt.builder};
+  auto loc{genCtxt.loc};
+  assert(genCtxt.arguments.size() >= 2);
+  auto *result{genCtxt.arguments[0]};
+  auto mergeFunc{getMergeFunc(result->getType(), genCtxt.getModuleOp())};
+  for (auto *arg : genCtxt.arguments.drop_front()) {
+    auto mask{createCompare<extremum>(loc, builder, result, arg)};
+    llvm::SmallVector<mlir::Value *, 3> mergeArgs{result, arg, mask};
+    result =
+        builder.create<mlir::CallOp>(loc, mergeFunc, mergeArgs).getResult(0);
+  }
+  return result;
 }
+
+}  // namespace Fortran::burnside
diff --git a/lib/burnside/runtime.cc b/lib/burnside/runtime.cc
index 453dbb9faf64..fcf7f9d1d722 100644
--- a/lib/burnside/runtime.cc
+++ b/lib/burnside/runtime.cc
@@ -14,7 +14,7 @@
 
 #include "runtime.h"
 #include "builder.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -44,9 +44,8 @@ mlir::Type RuntimeStaticDescription::getMLIRType(
 mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
     mlir::MLIRContext *context) const {
   llvm::SmallVector<mlir::Type, 2> argMLIRTypes;
-  for (const TypeCode *t{argumentTypeCodes.start};
-       t != nullptr && t != argumentTypeCodes.end; ++t) {
-    argMLIRTypes.push_back(getMLIRType(*t, context));
+  for (const TypeCode &t : argumentTypeCodes) {
+    argMLIRTypes.push_back(getMLIRType(t, context));
   }
   if (resultTypeCode.has_value()) {
     mlir::Type resMLIRType{getMLIRType(*resultTypeCode, context)};
diff --git a/lib/burnside/runtime.h b/lib/burnside/runtime.h
index 86f3c208f35b..c8d77126fb27 100644
--- a/lib/burnside/runtime.h
+++ b/lib/burnside/runtime.h
@@ -32,13 +32,57 @@ namespace Fortran::burnside {
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
+/// C++ does not provide variable size constexpr container yet.
+/// StaticVector is a class that can be used to hold constexpr data as if it was
+/// a vector (i.e, the number of element is not reflected in the
+/// container type). This is useful to use in classes that need to be constexpr
+/// and where leaking the size as a template type would make it harder to
+/// manipulate. It can hold whatever data that can appear as non-type templates
+/// (integers, enums, pointer to objects, function pointers...).
+/// Example usage:
+///
+///  enum class Enum {A, B};
+///  constexpr StaticVector<Enum> vec{StaticVector::create<Enum::A, Enum::B>()};
+///  for (const Enum& code : vec) { /*...*/ }
+///
+
+/// This is the class where the constexpr data is "allocated". In fact
+/// the data is stored "in" the type. Objects of this type are not meant to
+/// be ever constructed.
+template<typename T, T... v> struct StaticVectorStorage {
+  static constexpr T values[]{v...};
+  static constexpr const T *start{&values[0]};
+  static constexpr const T *end{start + sizeof...(v)};
+};
+template<typename T> struct StaticVectorStorage<T> {
+  static constexpr const T *start{nullptr}, *end{nullptr};
+};
+
+/// StaticVector cannot be directly constructed, instead its
+/// `create` static method has to be used to create StaticVector objects.
+/// StaticVector are views over the StaticVectorStorage type that was built
+/// while instantiating the create method. They do not duplicate the values from
+/// these read-only storages.
+template<typename T> struct StaticVector {
+  template<T... v> static constexpr StaticVector create() {
+    using storage = StaticVectorStorage<T, v...>;
+    return StaticVector{storage::start, storage::end};
+  }
+  using const_iterator = const T *;
+  constexpr const_iterator begin() const { return startPtr; }
+  constexpr const_iterator end() const { return endPtr; }
+  const T *startPtr{nullptr};
+  const T *endPtr{nullptr};
+};
+
 /// Define a simple static runtime description that different runtime can
 /// derived from (e.g io, maths ...).
 /// This base class only define enough to generate the functuion declarations,
-// it is up to the actual runtime descriptions to define a way to organize these
-// descriptions in a meaningful way.
+/// it is up to the actual runtime descriptions to define a way to organize
+/// these descriptions in a meaningful way.
 /// It is constexpr constructible so that static tables of such descriptions can
 /// be safely stored as global variables without requiring global constructors.
+
 class RuntimeStaticDescription {
 public:
   /// Define possible runtime function argument/return type used in signature
@@ -46,22 +90,9 @@ class RuntimeStaticDescription {
   /// directly be used because they can only be dynamically built.
   enum TypeCode { i32, i64, f32, f64, c32, c64, IOCookie };
   using MaybeTypeCode = std::optional<TypeCode>;  // for results
+  using TypeCodeVector = StaticVector<TypeCode>;  // for arguments
   static constexpr MaybeTypeCode voidTy{MaybeTypeCode{std::nullopt}};
 
-  /// C++ does not provide variable size constexpr container yet. TypeVector
-  /// implements one for Type elements. It works because Type is an enumeration.
-  struct TypeCodeVector {
-    template<TypeCode... v> struct Storage {
-      static constexpr TypeCode values[]{v...};
-    };
-    template<TypeCode... v> static constexpr TypeCodeVector create() {
-      const TypeCode *start{&Storage<v...>::values[0]};
-      return TypeCodeVector{start, start + sizeof...(v)};
-    }
-    template<> constexpr TypeCodeVector create<>() { return TypeCodeVector{}; }
-    const TypeCode *start{nullptr};
-    const TypeCode *end{nullptr};
-  };
   constexpr RuntimeStaticDescription(
       const char *s, MaybeTypeCode r, TypeCodeVector a)
     : symbol{s}, resultTypeCode{r}, argumentTypeCodes{a} {}
@@ -88,7 +119,7 @@ class RuntimeStaticDescription {
 // TODO: Find a better place for this if this is retained.
 // This is currently here because this was designed to provide
 // maps over runtime description without the burden of having to
-// instantiate these maps dynamically and to keep they somewhere.
+// instantiate these maps dynamically and to keep them somewhere.
 template<typename Value> class StaticMultimapView {
 public:
   using Key = typename Value::Key;
@@ -114,7 +145,7 @@ template<typename Value> class StaticMultimapView {
     // TODO: sorted
     // non empty increasing pointer direction
     return !range.empty();
-  };
+  }
   constexpr const_iterator begin() const { return range.begin(); }
   constexpr const_iterator end() const { return range.end(); }
 
diff --git a/lib/fir/Attribute.cpp b/lib/fir/Attribute.cpp
index 7c7bdd05f46c..62338be35e3c 100644
--- a/lib/fir/Attribute.cpp
+++ b/lib/fir/Attribute.cpp
@@ -13,10 +13,11 @@
 // limitations under the License.
 
 #include "fir/Attribute.h"
-#include "fir/Dialect.h"
-#include "fir/Type.h"
+#include "fir/FIRDialect.h"
+#include "fir/FIRType.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
 #include "llvm/ADT/StringRef.h"
@@ -27,101 +28,6 @@ namespace M = mlir;
 
 using namespace fir;
 
-namespace {
-
-// Our very stripped down parser for Attributes.
-// TODO: clean this up
-class AttributeParser {
-public:
-  AttributeParser(L::StringRef rawText)
-      : srcBuff{rawText}, srcPtr{rawText.begin()} {}
-
-  M::Attribute parseAttribute(FIROpsDialect *dialect, M::Location loc) {
-    skipWhitespace();
-    L::StringRef keyword{lexKeyword()};
-    skipWhitespace();
-    auto data{srcBuff.drop_front(srcPtr - srcBuff.begin())};
-    if (keyword == ExactTypeAttr::getAttrName()) {
-      data = consumeAngles(loc, data);
-      M::Type type{M::parseType(data, dialect->getContext())};
-      return ExactTypeAttr::get(type);
-    }
-    if (keyword == SubclassAttr::getAttrName()) {
-      data = consumeAngles(loc, data);
-      M::Type type{M::parseType(data, dialect->getContext())};
-      return SubclassAttr::get(type);
-    }
-    if (keyword == PointIntervalAttr::getAttrName()) {
-      return PointIntervalAttr::get(dialect->getContext());
-    }
-    if (keyword == LowerBoundAttr::getAttrName()) {
-      return LowerBoundAttr::get(dialect->getContext());
-    }
-    if (keyword == UpperBoundAttr::getAttrName()) {
-      return UpperBoundAttr::get(dialect->getContext());
-    }
-    if (keyword == ClosedIntervalAttr::getAttrName()) {
-      return ClosedIntervalAttr::get(dialect->getContext());
-    }
-    L::Twine msg{"unknown FIR attribute: "};
-    M::emitError(loc, msg.concat(srcBuff));
-    return {};
-  }
-
-private:
-  bool atEnd() const { return srcPtr == srcBuff.end(); }
-
-  L::StringRef lexKeyword() {
-    const char *tokStart = srcPtr;
-    while (!atEnd() && (std::isalnum(*srcPtr) || *srcPtr == '_')) {
-      ++srcPtr;
-    }
-    return {tokStart, static_cast<std::size_t>(srcPtr - tokStart)};
-  }
-
-  void skipWhitespace() {
-    while (!atEnd()) {
-      switch (*srcPtr) {
-      case ' ':
-      case '\f':
-      case '\n':
-      case '\r':
-      case '\t':
-      case '\v':
-        ++srcPtr;
-        continue;
-      default:
-        break;
-      }
-      break;
-    }
-  }
-
-  L::StringRef consumeAngles(M::Location loc, L::StringRef data) {
-    data = data.ltrim().rtrim();
-    if (data.size() <= 2) {
-      M::emitError(loc, "expecting '<' type '>' in attribute");
-      return {};
-    }
-    if (data.front() != '<') {
-      M::emitError(loc, "expecting '<' in attribute");
-      return {};
-    }
-    data = data.drop_front(1);
-    if (data.back() != '>') {
-      M::emitError(loc, "expecting '>' in attribute");
-      return {};
-    }
-    data = data.drop_back(1);
-    return data;
-  }
-
-  L::StringRef srcBuff;
-  const char *srcPtr;
-};
-
-} // namespace
-
 namespace fir {
 namespace detail {
 
@@ -162,20 +68,82 @@ using AttributeUniquer = mlir::detail::AttributeUniquer;
 ClosedIntervalAttr ClosedIntervalAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<ClosedIntervalAttr>(ctxt, getId());
 }
+
 UpperBoundAttr UpperBoundAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<UpperBoundAttr>(ctxt, getId());
 }
+
 LowerBoundAttr LowerBoundAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<LowerBoundAttr>(ctxt, getId());
 }
+
 PointIntervalAttr PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<PointIntervalAttr>(ctxt, getId());
 }
 
-M::Attribute parseFirAttribute(FIROpsDialect *dialect, L::StringRef rawText,
-                               M::Type type, M::Location loc) {
-  AttributeParser parser{rawText};
-  return parser.parseAttribute(dialect, loc);
+M::Attribute parseFirAttribute(FIROpsDialect *dialect,
+                               M::DialectAsmParser &parser, M::Type type) {
+  auto loc = parser.getNameLoc();
+  L::StringRef attrName;
+  if (parser.parseKeyword(&attrName)) {
+    parser.emitError(loc, "expected an attribute name");
+    return {};
+  }
+
+  if (attrName == ExactTypeAttr::getAttrName()) {
+    M::Type type;
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
+      parser.emitError(loc, "expected a type");
+    }
+    return ExactTypeAttr::get(type);
+  }
+  if (attrName == SubclassAttr::getAttrName()) {
+    M::Type type;
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
+      parser.emitError(loc, "expected a subtype");
+    }
+    return SubclassAttr::get(type);
+  }
+  if (attrName == PointIntervalAttr::getAttrName()) {
+    return PointIntervalAttr::get(dialect->getContext());
+  }
+  if (attrName == LowerBoundAttr::getAttrName()) {
+    return LowerBoundAttr::get(dialect->getContext());
+  }
+  if (attrName == UpperBoundAttr::getAttrName()) {
+    return UpperBoundAttr::get(dialect->getContext());
+  }
+  if (attrName == ClosedIntervalAttr::getAttrName()) {
+    return ClosedIntervalAttr::get(dialect->getContext());
+  }
+
+  L::Twine msg{"unknown FIR attribute: "};
+  parser.emitError(loc, msg.concat(attrName));
+  return {};
+}
+
+void printFirAttribute(FIROpsDialect *dialect, M::Attribute attr,
+                       M::DialectAsmPrinter &p) {
+  auto &os = p.getStream();
+  if (auto exact = attr.dyn_cast<fir::ExactTypeAttr>()) {
+    os << fir::ExactTypeAttr::getAttrName() << '<';
+    p.printType(exact.getType());
+    os << '>';
+  } else if (auto sub = attr.dyn_cast<fir::SubclassAttr>()) {
+    os << fir::SubclassAttr::getAttrName() << '<';
+    p.printType(sub.getType());
+    os << '>';
+  } else if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
+    os << fir::PointIntervalAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+    os << fir::ClosedIntervalAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
+    os << fir::LowerBoundAttr::getAttrName();
+  } else if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
+    os << fir::UpperBoundAttr::getAttrName();
+  } else {
+    assert(false && "attribute pretty-printer is not implemented");
+  }
 }
 
 } // namespace fir
diff --git a/lib/fir/CMakeLists.txt b/lib/fir/CMakeLists.txt
index f10d851171b8..54587daaf7f1 100644
--- a/lib/fir/CMakeLists.txt
+++ b/lib/fir/CMakeLists.txt
@@ -16,13 +16,14 @@ add_subdirectory(Transforms)
 
 add_llvm_library(FIR
   Attribute.cpp
-  Dialect.cpp
+  FIRDialect.cpp
   FIROps.cpp
+  FIRType.cpp
+  InternalNames.cpp
   IteratedDominanceFrontier.cpp
   KindMapping.cpp
   StdConverter.cpp
   Tilikum.cpp
-  Type.cpp
 )
 
 add_dependencies(FIR FIROpsIncGen)
diff --git a/lib/fir/Dialect.cpp b/lib/fir/FIRDialect.cpp
similarity index 54%
rename from lib/fir/Dialect.cpp
rename to lib/fir/FIRDialect.cpp
index 432686041ced..a8b869202ba2 100644
--- a/lib/fir/Dialect.cpp
+++ b/lib/fir/FIRDialect.cpp
@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fir/Dialect.h"
+#include "fir/FIRDialect.h"
 #include "fir/Attribute.h"
 #include "fir/FIROps.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Transforms/SideEffectsInterface.h"
@@ -43,13 +43,16 @@ void selectBuild(M::OpBuilder *builder, M::OperationState *result,
     result->addSuccessor(block, blkArgs);
   }
 }
+
+M::DialectRegistration<fir::FIROpsDialect> FIROps;
+
 } // namespace
 
 fir::FIROpsDialect::FIROpsDialect(M::MLIRContext *ctx)
     : M::Dialect("fir", ctx) {
   addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
-           FieldType, HeapType, IntType, LogicalType, PointerType, RealType,
-           RecordType, ReferenceType, SequenceType, TypeDescType>();
+           FieldType, HeapType, IntType, LenType, LogicalType, PointerType,
+           RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
   addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
                 PointIntervalAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<GlobalOp, DispatchTableOp,
@@ -63,37 +66,20 @@ fir::FIROpsDialect::~FIROpsDialect() {
   // do nothing
 }
 
-M::Type fir::FIROpsDialect::parseType(llvm::StringRef rawData,
-                                      M::Location loc) const {
-  return parseFirType(const_cast<FIROpsDialect *>(this), rawData, loc);
+M::Type fir::FIROpsDialect::parseType(M::DialectAsmParser &parser) const {
+  return parseFirType(const_cast<FIROpsDialect *>(this), parser);
 }
 
-void fir::FIROpsDialect::printType(M::Type ty, llvm::raw_ostream &os) const {
-  return printFirType(const_cast<FIROpsDialect *>(this), ty, os);
+void fir::FIROpsDialect::printType(M::Type ty, M::DialectAsmPrinter &p) const {
+  return printFirType(const_cast<FIROpsDialect *>(this), ty, p);
 }
 
-M::Attribute fir::FIROpsDialect::parseAttribute(llvm::StringRef rawText,
-                                                M::Type type,
-                                                M::Location loc) const {
-  return parseFirAttribute(const_cast<FIROpsDialect *>(this), rawText, type,
-                           loc);
+M::Attribute fir::FIROpsDialect::parseAttribute(M::DialectAsmParser &parser,
+                                                M::Type type) const {
+  return parseFirAttribute(const_cast<FIROpsDialect *>(this), parser, type);
 }
 
 void fir::FIROpsDialect::printAttribute(M::Attribute attr,
-                                        llvm::raw_ostream &os) const {
-  if (auto exact = attr.dyn_cast<fir::ExactTypeAttr>()) {
-    os << fir::ExactTypeAttr::getAttrName() << '<' << exact.getType() << '>';
-  } else if (auto sub = attr.dyn_cast<fir::SubclassAttr>()) {
-    os << fir::SubclassAttr::getAttrName() << '<' << sub.getType() << '>';
-  } else if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
-    os << fir::PointIntervalAttr::getAttrName();
-  } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
-    os << fir::ClosedIntervalAttr::getAttrName();
-  } else if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
-    os << fir::LowerBoundAttr::getAttrName();
-  } else if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
-    os << fir::UpperBoundAttr::getAttrName();
-  } else {
-    assert(false && "attribute pretty-printer is not implemented");
-  }
+                                        M::DialectAsmPrinter &p) const {
+  printFirAttribute(const_cast<FIROpsDialect *>(this), attr, p);
 }
diff --git a/lib/fir/FIROps.cpp b/lib/fir/FIROps.cpp
index 25a99b0656c0..bdff4e57f8df 100644
--- a/lib/fir/FIROps.cpp
+++ b/lib/fir/FIROps.cpp
@@ -14,10 +14,12 @@
 
 #include "fir/FIROps.h"
 #include "fir/Attribute.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
+#include "llvm/ADT/StringSwitch.h"
 
 namespace L = llvm;
 namespace M = mlir;
@@ -42,6 +44,16 @@ M::Type AllocMemOp::getAllocatedType() {
 
 M::Type AllocMemOp::getRefTy(M::Type ty) { return HeapType::get(ty); }
 
+// BoxDimsOp
+
+/// Get the result types packed in a tuple tuple
+M::Type BoxDimsOp::getTupleType() {
+  L::SmallVector<M::Type, 3> triple{getResult(0)->getType(),
+                                    getResult(1)->getType(),
+                                    getResult(2)->getType()};
+  return mlir::TupleType::get(triple, getContext());
+}
+
 // CallOp
 
 void printCallOp(M::OpAsmPrinter &p, fir::CallOp &op) {
@@ -49,7 +61,7 @@ void printCallOp(M::OpAsmPrinter &p, fir::CallOp &op) {
   bool isDirect = callee.hasValue();
   p << op.getOperationName() << ' ';
   if (isDirect)
-    p.printSymbolName(callee.getValue());
+    p << callee.getValue();
   else
     p << *op.getOperand(0);
   p << '(';
@@ -77,7 +89,7 @@ M::ParseResult parseCallOp(M::OpAsmParser &parser, M::OperationState &result) {
   Type type;
 
   if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
-      parser.parseOptionalAttributeDict(attrs) || parser.parseColon() ||
+      parser.parseOptionalAttrDict(attrs) || parser.parseColon() ||
       parser.parseType(type))
     return M::failure();
 
@@ -104,6 +116,137 @@ M::ParseResult parseCallOp(M::OpAsmParser &parser, M::OperationState &result) {
   return M::success();
 }
 
+// CmpfOp
+
+fir::CmpFPredicate CmpfOp::getPredicateByName(llvm::StringRef name) {
+  return llvm::StringSwitch<fir::CmpFPredicate>(name)
+      .Case("false", CmpFPredicate::AlwaysFalse)
+      .Case("oeq", CmpFPredicate::OEQ)
+      .Case("ogt", CmpFPredicate::OGT)
+      .Case("oge", CmpFPredicate::OGE)
+      .Case("olt", CmpFPredicate::OLT)
+      .Case("ole", CmpFPredicate::OLE)
+      .Case("one", CmpFPredicate::ONE)
+      .Case("ord", CmpFPredicate::ORD)
+      .Case("ueq", CmpFPredicate::UEQ)
+      .Case("ugt", CmpFPredicate::UGT)
+      .Case("uge", CmpFPredicate::UGE)
+      .Case("ult", CmpFPredicate::ULT)
+      .Case("ule", CmpFPredicate::ULE)
+      .Case("une", CmpFPredicate::UNE)
+      .Case("uno", CmpFPredicate::UNO)
+      .Case("true", CmpFPredicate::AlwaysTrue)
+      .Default(CmpFPredicate::NumPredicates);
+}
+
+void buildCmpFOp(Builder *builder, OperationState &result,
+                 CmpFPredicate predicate, Value *lhs, Value *rhs) {
+  result.addOperands({lhs, rhs});
+  result.types.push_back(builder->getI1Type());
+  result.addAttribute(
+      CmpfOp::getPredicateAttrName(),
+      builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
+}
+
+template <typename OPTY>
+void printCmpOp(OpAsmPrinter &p, OPTY op) {
+  static const char *predicateNames[] = {
+      /*AlwaysFalse*/ "false",
+      /*OEQ*/ "oeq",
+      /*OGT*/ "ogt",
+      /*OGE*/ "oge",
+      /*OLT*/ "olt",
+      /*OLE*/ "ole",
+      /*ONE*/ "one",
+      /*ORD*/ "ord",
+      /*UEQ*/ "ueq",
+      /*UGT*/ "ugt",
+      /*UGE*/ "uge",
+      /*ULT*/ "ult",
+      /*ULE*/ "ule",
+      /*UNE*/ "une",
+      /*UNO*/ "uno",
+      /*AlwaysTrue*/ "true",
+  };
+  static_assert(std::extent<decltype(predicateNames)>::value ==
+                    (size_t)fir::CmpFPredicate::NumPredicates,
+                "wrong number of predicate names");
+  p << op.getOperationName() << ' ';
+  auto predicateValue =
+      op.template getAttrOfType<M::IntegerAttr>(OPTY::getPredicateAttrName())
+          .getInt();
+  assert(predicateValue >= static_cast<int>(CmpFPredicate::FirstValidValue) &&
+         predicateValue < static_cast<int>(CmpFPredicate::NumPredicates) &&
+         "unknown predicate index");
+  Builder b(op.getContext());
+  auto predicateStringAttr = b.getStringAttr(predicateNames[predicateValue]);
+  p.printAttribute(predicateStringAttr);
+  p << ", ";
+  p.printOperand(op.lhs());
+  p << ", ";
+  p.printOperand(op.rhs());
+  p.printOptionalAttrDict(op.getAttrs(),
+                          /*elidedAttrs=*/{OPTY::getPredicateAttrName()});
+  p << " : " << op.lhs()->getType();
+}
+
+void printCmpfOp(OpAsmPrinter &p, CmpfOp op) { printCmpOp(p, op); }
+
+template <typename OPTY>
+M::ParseResult parseCmpOp(M::OpAsmParser &parser, M::OperationState &result) {
+  L::SmallVector<M::OpAsmParser::OperandType, 2> ops;
+  L::SmallVector<M::NamedAttribute, 4> attrs;
+  M::Attribute predicateNameAttr;
+  M::Type type;
+  if (parser.parseAttribute(predicateNameAttr, OPTY::getPredicateAttrName(),
+                            attrs) ||
+      parser.parseComma() || parser.parseOperandList(ops, 2) ||
+      parser.parseOptionalAttrDict(attrs) || parser.parseColonType(type) ||
+      parser.resolveOperands(ops, type, result.operands))
+    return failure();
+
+  if (!predicateNameAttr.isa<M::StringAttr>())
+    return parser.emitError(parser.getNameLoc(),
+                            "expected string comparison predicate attribute");
+
+  // Rewrite string attribute to an enum value.
+  L::StringRef predicateName =
+      predicateNameAttr.cast<M::StringAttr>().getValue();
+  auto predicate = CmpfOp::getPredicateByName(predicateName);
+  if (predicate == CmpFPredicate::NumPredicates)
+    return parser.emitError(parser.getNameLoc(),
+                            "unknown comparison predicate \"" + predicateName +
+                                "\"");
+
+  auto builder = parser.getBuilder();
+  M::Type i1Type = builder.getI1Type();
+  attrs[0].second = builder.getI64IntegerAttr(static_cast<int64_t>(predicate));
+  result.attributes = attrs;
+  result.addTypes({i1Type});
+  return success();
+}
+
+M::ParseResult parseCmpfOp(M::OpAsmParser &parser, M::OperationState &result) {
+  return parseCmpOp<fir::CmpfOp>(parser, result);
+}
+
+// CmpcOp
+
+void buildCmpCOp(Builder *builder, OperationState &result,
+                 CmpFPredicate predicate, Value *lhs, Value *rhs) {
+  result.addOperands({lhs, rhs});
+  result.types.push_back(builder->getI1Type());
+  result.addAttribute(
+      CmpcOp::getPredicateAttrName(),
+      builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
+}
+
+void printCmpcOp(OpAsmPrinter &p, CmpcOp op) { printCmpOp(p, op); }
+
+M::ParseResult parseCmpcOp(M::OpAsmParser &parser, M::OperationState &result) {
+  return parseCmpOp<fir::CmpcOp>(parser, result);
+}
+
 // DispatchOp
 
 M::FunctionType DispatchOp::getFunctionType() {
@@ -117,9 +260,8 @@ void DispatchTableOp::build(M::Builder *builder, M::OperationState *result,
                             L::StringRef name, M::Type type,
                             L::ArrayRef<M::NamedAttribute> attrs) {
   result->addAttribute("method", builder->getStringAttr(name));
-  for (const auto &pair : attrs) {
+  for (const auto &pair : attrs)
     result->addAttribute(pair.first, pair.second);
-  }
 }
 
 M::ParseResult DispatchTableOp::parse(M::OpAsmParser &parser,
@@ -131,7 +273,7 @@ M::ParseResult DispatchTableOp::parse(M::OpAsmParser &parser,
 
   // Convert the parsed name attr into a string attr.
   result.attributes.back().second =
-      parser.getBuilder().getStringAttr(nameAttr.getValue());
+      parser.getBuilder().getStringAttr(nameAttr.getRootReference());
 
   // Parse the optional table body.
   M::Region *body = result.addRegion();
@@ -173,9 +315,8 @@ void GlobalOp::build(M::Builder *builder, M::OperationState *result,
   result->addAttribute(getTypeAttrName(), M::TypeAttr::get(type));
   result->addAttribute(M::SymbolTable::getSymbolAttrName(),
                        builder->getStringAttr(name));
-  for (const auto &pair : attrs) {
+  for (const auto &pair : attrs)
     result->addAttribute(pair.first, pair.second);
-  }
 }
 
 M::ParseResult GlobalOp::parse(M::OpAsmParser &parser,
@@ -187,19 +328,18 @@ M::ParseResult GlobalOp::parse(M::OpAsmParser &parser,
     return failure();
 
   auto &builder = parser.getBuilder();
-  result.attributes.back().second = builder.getStringAttr(nameAttr.getValue());
+  auto name = nameAttr.getRootReference();
+  result.attributes.back().second = builder.getStringAttr(name);
 
-  if (parser.parseOptionalKeyword("constant")) {
-    result.addAttribute("constant", builder.getBoolAttr(false));
-  } else {
+  if (!parser.parseOptionalKeyword("constant")) {
     // if "constant" keyword then mark this as a constant, not a variable
-    result.addAttribute("constant", builder.getBoolAttr(true));
+    result.addAttribute("constant", builder.getUnitAttr());
   }
 
   M::Type globalType;
-  if (parser.parseColonType(globalType)) {
+  if (parser.parseColonType(globalType))
     return M::failure();
-  }
+
   result.addAttribute(getTypeAttrName(), M::TypeAttr::get(globalType));
 
   // Parse the optional initializer body.
@@ -217,7 +357,7 @@ void GlobalOp::print(M::OpAsmPrinter &p) {
   auto varName =
       getAttrOfType<StringAttr>(M::SymbolTable::getSymbolAttrName()).getValue();
   p << getOperationName() << " @" << varName;
-  if (getAttr("constant").cast<M::BoolAttr>().getValue())
+  if (getAttr("constant"))
     p << " constant";
   p << " : ";
   p.printType(getType());
@@ -283,19 +423,16 @@ M::ParseResult parseLoopOp(M::OpAsmParser &parser, M::OperationState &result) {
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands))
     return M::failure();
-  if (parser.parseOptionalKeyword(LoopOp::getStepKeyword())) {
+
+  if (parser.parseOptionalKeyword(LoopOp::getStepKeyword()))
     result.addAttribute(LoopOp::getStepKeyword(),
                         builder.getIntegerAttr(builder.getIndexType(), 1));
-  } else if (parser.parseOperand(step) ||
-             parser.resolveOperand(step, indexType, result.operands)) {
+  else if (parser.parseOperand(step) ||
+           parser.resolveOperand(step, indexType, result.operands))
     return M::failure();
-  }
 
-  if (parser.parseOptionalKeyword("unordered")) {
-    // ok
-  } else {
-    result.addAttribute("unordered", builder.getBoolAttr(true));
-  }
+  if (!parser.parseOptionalKeyword("unordered"))
+    result.addAttribute("unordered", builder.getUnitAttr());
 
   // Parse the body region.
   M::Region *body = result.addRegion();
@@ -305,17 +442,15 @@ M::ParseResult parseLoopOp(M::OpAsmParser &parser, M::OperationState &result) {
   fir::LoopOp::ensureTerminator(*body, builder, result.location);
 
   // Parse the optional attribute list.
-  if (parser.parseOptionalAttributeDict(result.attributes)) {
+  if (parser.parseOptionalAttrDict(result.attributes))
     return M::failure();
-  }
   return M::success();
 }
 
 fir::LoopOp getForInductionVarOwner(M::Value *val) {
   auto *ivArg = dyn_cast<M::BlockArgument>(val);
-  if (!ivArg) {
+  if (!ivArg)
     return fir::LoopOp();
-  }
   assert(ivArg->getOwner() && "unlinked block argument");
   auto *containingInst = ivArg->getOwner()->getParentOp();
   return dyn_cast_or_null<fir::LoopOp>(containingInst);
@@ -358,23 +493,21 @@ M::ParseResult parseWhereOp(M::OpAsmParser &parser, M::OperationState &result) {
       parser.resolveOperand(cond, i1Type, result.operands))
     return M::failure();
 
-  if (parser.parseRegion(*thenRegion, {}, {})) {
+  if (parser.parseRegion(*thenRegion, {}, {}))
     return M::failure();
-  }
+
   WhereOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
 
   if (!parser.parseOptionalKeyword("otherwise")) {
-    if (parser.parseRegion(*elseRegion, {}, {})) {
+    if (parser.parseRegion(*elseRegion, {}, {}))
       return M::failure();
-    }
     WhereOp::ensureTerminator(*elseRegion, parser.getBuilder(),
                               result.location);
   }
 
   // Parse the optional attribute list.
-  if (parser.parseOptionalAttributeDict(result.attributes)) {
+  if (parser.parseOptionalAttrDict(result.attributes))
     return M::failure();
-  }
 
   return M::success();
 }
@@ -395,9 +528,8 @@ unsigned getCaseArgumentOffset(L::ArrayRef<M::Attribute> cases, unsigned dest) {
     auto &attr = cases[i];
     if (!attr.dyn_cast_or_null<M::UnitAttr>()) {
       ++o;
-      if (attr.dyn_cast_or_null<ClosedIntervalAttr>()) {
+      if (attr.dyn_cast_or_null<ClosedIntervalAttr>())
         ++o;
-      }
     }
   }
   return o;
@@ -413,15 +545,26 @@ M::ParseResult parseSelector(M::OpAsmParser &parser, M::OperationState &result,
   return M::success();
 }
 
-void printComplexBinaryOp(Operation *op, OpAsmPrinter &p) {
-  assert(op->getNumOperands() == 2 && "binary op should have two operands");
-  assert(op->getNumResults() == 1 && "binary op should have one result");
+/// Generic pretty-printer of a binary operation
+void printBinaryOp(Operation *op, OpAsmPrinter &p) {
+  assert(op->getNumOperands() == 2 && "binary op must have two operands");
+  assert(op->getNumResults() == 1 && "binary op must have one result");
 
   p << op->getName() << ' ' << *op->getOperand(0) << ", " << *op->getOperand(1);
   p.printOptionalAttrDict(op->getAttrs());
   p << " : " << op->getResult(0)->getType();
 }
 
+/// Generic pretty-printer of an unary operation
+void printUnaryOp(Operation *op, OpAsmPrinter &p) {
+  assert(op->getNumOperands() == 1 && "unary op must have one operand");
+  assert(op->getNumResults() == 1 && "unary op must have one result");
+
+  p << op->getName() << ' ' << *op->getOperand(0);
+  p.printOptionalAttrDict(op->getAttrs());
+  p << " : " << op->getResult(0)->getType();
+}
+
 // Tablegen operators
 
 #define GET_OP_CLASSES
diff --git a/lib/fir/Type.cpp b/lib/fir/FIRType.cpp
similarity index 53%
rename from lib/fir/Type.cpp
rename to lib/fir/FIRType.cpp
index 57b36a1620d4..8b020f6e88d7 100644
--- a/lib/fir/Type.cpp
+++ b/lib/fir/FIRType.cpp
@@ -12,17 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fir/Type.h"
-#include "fir/Dialect.h"
+#include "fir/FIRType.h"
+#include "fir/FIRDialect.h"
+#include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Parser.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace L = llvm;
 namespace M = mlir;
@@ -31,581 +30,162 @@ using namespace fir;
 
 namespace {
 
-// Tokens
-
-enum class TokenKind {
-  error,
-  eof,
-  leftang,
-  rightang,
-  leftparen,
-  rightparen,
-  leftbrace,
-  rightbrace,
-  leftbracket,
-  rightbracket,
-  colon,
-  comma,
-  period,
-  eroteme,
-  ecphoneme,
-  star,
-  arrow,
-  ident,
-  string,
-  intlit,
-};
-
-struct Token {
-  TokenKind kind;
-  L::StringRef text;
-};
-
-// Lexer
-
-class Lexer {
-public:
-  Lexer(L::StringRef source) : srcBuff{source}, srcPtr{source.begin()} {}
-
-  // consume and return next token from the input. input is advanced to after
-  // the token.
-  Token lexToken();
-
-  int nextNonWSChar() {
-    skipWhitespace();
-    if (atEnd())
-      return -1;
-    return *srcPtr++;
-  }
-
-  // peek ahead to the next non-whitespace character, leaving it on the input
-  // stream
-  char nextChar() {
-    skipWhitespace();
-    if (atEnd())
-      return '\0';
-    return *srcPtr;
-  }
-
-  // advance the input stream `count` characters
-  void advance(unsigned count = 1) {
-    while (count--) {
-      if (atEnd())
-        break;
-      ++srcPtr;
-    }
-  }
-
-  const char *getMarker() { return srcPtr; }
-
-  L::StringRef getNextType() {
-    char const *const marker = srcPtr;
-    L::SmallVector<char, 8> nestedPunc;
-    for (bool scanning = true; scanning && !atEnd(); ++srcPtr) {
-      char c = *srcPtr;
-      switch (c) {
-      case '<':
-      case '[':
-      case '(':
-      case '{':
-        nestedPunc.push_back(c);
-        break;
-      case '>':
-        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '<') {
-          goto done;
-        }
-        continue;
-      case ']':
-        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '[') {
-          goto done;
-        }
-        continue;
-      case ')':
-        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '(') {
-          goto done;
-        }
-        continue;
-      case '}':
-        if (nestedPunc.empty() || nestedPunc.pop_back_val() != '{') {
-          goto done;
-        }
-        continue;
-      case ',':
-        if (nestedPunc.empty()) {
-          goto done;
-        }
-        continue;
-      case '-':
-        if ((srcPtr + 1 != srcBuff.end()) && *(srcPtr + 1) == '>') {
-          ++srcPtr;
-        }
-        continue;
-      done:
-        --srcPtr;
-        [[fallthrough]];
-      case '\0': {
-        scanning = false;
-      } break;
-      default:
-        break;
-      }
-    }
-    std::size_t count = srcPtr - marker;
-    return {marker, count};
-  }
-
-private:
-  void skipWhitespace() {
-    while (!atEnd()) {
-      switch (*srcPtr) {
-      case ' ':
-      case '\f':
-      case '\n':
-      case '\r':
-      case '\t':
-      case '\v':
-        ++srcPtr;
-        continue;
-      default:
-        break;
-      }
-      break;
-    }
-  }
-
-  Token formToken(TokenKind kind, const char *tokStart) {
-    return Token{kind, L::StringRef(tokStart, srcPtr - tokStart)};
-  }
-
-  Token emitError(const char *loc, const L::Twine &message) {
-    return formToken(TokenKind::error, loc);
-  }
-
-  bool atEnd() const { return srcPtr == srcBuff.end(); }
-
-  Token lexIdent(const char *tokStart);
-  Token lexNumber(const char *tokStart);
-  Token lexString(const char *tokStart);
-
-  L::StringRef srcBuff;
-  const char *srcPtr;
-};
-
-Token Lexer::lexToken() {
-  skipWhitespace();
-  if (atEnd()) {
-    return formToken(TokenKind::eof, "");
-  }
-
-  const char *tokStart = srcPtr;
-  switch (*srcPtr++) {
-  case '<':
-    return formToken(TokenKind::leftang, tokStart);
-  case '>':
-    return formToken(TokenKind::rightang, tokStart);
-  case '{':
-    return formToken(TokenKind::leftbrace, tokStart);
-  case '}':
-    return formToken(TokenKind::rightbrace, tokStart);
-  case '[':
-    return formToken(TokenKind::leftbracket, tokStart);
-  case ']':
-    return formToken(TokenKind::rightbracket, tokStart);
-  case '(':
-    return formToken(TokenKind::leftparen, tokStart);
-  case ')':
-    return formToken(TokenKind::rightparen, tokStart);
-  case ':':
-    return formToken(TokenKind::colon, tokStart);
-  case ',':
-    return formToken(TokenKind::comma, tokStart);
-  case '"':
-    return lexString(tokStart + 1);
-  case '-':
-    if (*srcPtr == '>') {
-      srcPtr++;
-      return formToken(TokenKind::arrow, tokStart);
-    }
-    return lexNumber(tokStart);
-  case '+':
-    return lexNumber(tokStart + 1);
-  case '!':
-    return formToken(TokenKind::ecphoneme, tokStart);
-  case '?':
-    return formToken(TokenKind::eroteme, tokStart);
-  case '*':
-    return formToken(TokenKind::star, tokStart);
-  case '.':
-    return formToken(TokenKind::period, tokStart);
-  default:
-    if (std::isalpha(*tokStart)) {
-      return lexIdent(tokStart);
-    }
-    if (std::isdigit(*tokStart)) {
-      return lexNumber(tokStart);
-    }
-    return emitError(tokStart, "unexpected character");
+template <typename TYPE>
+TYPE parseIntSingleton(M::DialectAsmParser &parser) {
+  int kind = 0;
+  if (parser.parseLess() || parser.parseInteger(kind) ||
+      parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "kind value expected");
+    return {};
   }
+  return TYPE::get(parser.getBuilder().getContext(), kind);
 }
 
-Token Lexer::lexString(const char *tokStart) {
-  while (!atEnd() && *srcPtr != '"') {
-    ++srcPtr;
-  }
-  Token token{formToken(TokenKind::string, tokStart)};
-  ++srcPtr;
-  return token;
+template <typename TYPE>
+TYPE parseKindSingleton(M::DialectAsmParser &parser) {
+  return parseIntSingleton<TYPE>(parser);
 }
 
-Token Lexer::lexIdent(const char *tokStart) {
-  while (!atEnd() && (std::isalnum(*srcPtr) || *srcPtr == '_')) {
-    ++srcPtr;
-  }
-  return formToken(TokenKind::ident, tokStart);
+template <typename TYPE>
+TYPE parseRankSingleton(M::DialectAsmParser &parser) {
+  return parseIntSingleton<TYPE>(parser);
 }
 
-Token Lexer::lexNumber(const char *tokStart) {
-  while (!atEnd() && std::isdigit(*srcPtr)) {
-    ++srcPtr;
+template <typename TYPE>
+TYPE parseTypeSingleton(M::DialectAsmParser &parser, M::Location) {
+  M::Type ty;
+  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "type expected");
+    return {};
   }
-  return formToken(TokenKind::intlit, tokStart);
+  return TYPE::get(ty);
 }
 
-class auto_counter {
-public:
-  explicit auto_counter(int &ref) : counter(ref) { ++counter; }
-  ~auto_counter() { --counter; }
-
-private:
-  auto_counter() = delete;
-  auto_counter(const auto_counter &) = delete;
-  int &counter;
-};
-
-/// A FIROpsDialect instance uses a FIRTypeParser object to parse and
-/// instantiate all FIR types from .fir files.
-class FIRTypeParser {
-public:
-  FIRTypeParser(FIROpsDialect *dialect, L::StringRef rawData, M::Location loc)
-      : context{dialect->getContext()}, lexer{rawData}, loc{loc} {}
-
-  M::Type parseType();
-
-protected:
-  inline void emitError(M::Location loc, const L::Twine &msg) {
-    M::emitError(loc, msg);
-  }
-
-  bool consumeToken(TokenKind tk, const L::Twine &msg) {
-    auto token = lexer.lexToken();
-    if (token.kind != tk) {
-      emitError(loc, msg);
-      return true; // error!
-    }
-    return false;
-  }
-
-  bool consumeChar(char ch, const L::Twine &msg) {
-    auto lexCh = lexer.nextChar();
-    if (lexCh != ch) {
-      emitError(loc, msg);
-      return true; // error!
-    }
-    lexer.advance();
-    return false;
-  }
-
-  template <typename A>
-  A parseIntLitSingleton(const char *msg) {
-    if (consumeToken(TokenKind::leftang, "expected '<' in type")) {
-      return {};
-    }
-    auto token{lexer.lexToken()};
-    if (token.kind != TokenKind::intlit) {
-      emitError(loc, msg);
-      return {};
-    }
-    KindTy kind;
-    if (token.text.getAsInteger(0, kind)) {
-      emitError(loc, "expected integer constant");
-      return {};
-    }
-    if (consumeToken(TokenKind::rightang, "expected '>' in type")) {
-      return {};
-    }
-    if (checkAtEnd())
-      return {};
-    return A::get(getContext(), kind);
-  }
-
-  // `<` kind `>`
-  template <typename A>
-  A parseKindSingleton() {
-    return parseIntLitSingleton<A>("expected kind parameter");
-  }
-
-  // `<` rank `>`
-  template <typename A>
-  A parseRankSingleton() {
-    return parseIntLitSingleton<A>("expected rank parameter");
-  }
-
-  // '<' type '>'
-  template <typename A>
-  A parseTypeSingleton() {
-    if (consumeToken(TokenKind::leftang, "expected '<' in type")) {
-      return {};
-    }
-    auto ofTy = parseNextType();
-    if (!ofTy) {
-      emitError(loc, "expected type parameter");
-      return {};
-    }
-    if (consumeToken(TokenKind::rightang, "expected '>' in type")) {
-      return {};
-    }
-    if (checkAtEnd())
-      return {};
-    return A::get(ofTy);
-  }
-
-  M::Type parseNextType();
-
-  bool checkAtEnd() {
-    if (!recursiveCall) {
-      auto token = lexer.lexToken();
-      if (token.kind != TokenKind::eof) {
-        emitError(loc, "unexpected extra characters");
-        return true;
-      }
-    }
-    return false;
+// `box` `<` type (',' affine-map)? `>`
+BoxType parseBox(M::DialectAsmParser &parser, M::Location loc) {
+  M::Type ofTy;
+  if (parser.parseLess() || parser.parseType(ofTy)) {
+    parser.emitError(parser.getCurrentLocation(), "expected type parameter");
+    return {};
   }
 
-  // `box` `<` type (',' affine-map)? `>`
-  BoxType parseBox() {
-    if (consumeToken(TokenKind::leftang, "expected '<' in type")) {
-      return {};
-    }
-    auto ofTy = parseNextType();
-    if (!ofTy) {
-      emitError(loc, "expected type parameter");
-      return {};
-    }
-    auto token = lexer.lexToken();
-    M::AffineMapAttr map;
-    if (token.kind == TokenKind::comma) {
-      map = parseAffineMapAttr();
-      token = lexer.lexToken();
-    }
-    if (token.kind != TokenKind::rightang) {
-      emitError(loc, "expected '>' in type");
+  M::AffineMapAttr map;
+  if (!parser.parseOptionalComma())
+    if (parser.parseAttribute(map)) {
+      parser.emitError(parser.getCurrentLocation(), "expected affine map");
       return {};
     }
-    if (checkAtEnd())
-      return {};
-    return BoxType::get(ofTy, map);
-  }
-
-  // `boxchar` `<` kind `>`
-  BoxCharType parseBoxChar() { return parseKindSingleton<BoxCharType>(); }
-
-  // `boxproc` `<` return-type `>`
-  BoxProcType parseBoxProc() { return parseTypeSingleton<BoxProcType>(); }
-
-  // `char` `<` kind `>`
-  CharacterType parseCharacter() { return parseKindSingleton<CharacterType>(); }
-
-  // `dims` `<` rank `>`
-  DimsType parseDims() { return parseRankSingleton<DimsType>(); }
-
-  // `field`
-  FieldType parseField() {
-    if (checkAtEnd())
-      return {};
-    return FieldType::get(getContext());
+  if (parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "expected '>'");
+    return {};
   }
+  return BoxType::get(ofTy, map);
+}
 
-  // `logical` `<` kind `>`
-  LogicalType parseLogical() { return parseKindSingleton<LogicalType>(); }
-
-  // `int` `<` kind `>`
-  IntType parseInteger() { return parseKindSingleton<IntType>(); }
+// `boxchar` `<` kind `>`
+BoxCharType parseBoxChar(M::DialectAsmParser &parser) {
+  return parseKindSingleton<BoxCharType>(parser);
+}
 
-  // `complex` `<` kind `>`
-  CplxType parseComplex() { return parseKindSingleton<CplxType>(); }
+// `boxproc` `<` return-type `>`
+BoxProcType parseBoxProc(M::DialectAsmParser &parser, M::Location loc) {
+  return parseTypeSingleton<BoxProcType>(parser, loc);
+}
 
-  // `real` `<` kind `>`
-  RealType parseReal() { return parseKindSingleton<RealType>(); }
+// `char` `<` kind `>`
+CharacterType parseCharacter(M::DialectAsmParser &parser) {
+  return parseKindSingleton<CharacterType>(parser);
+}
 
-  // `ref` `<` type `>`
-  ReferenceType parseReference() { return parseTypeSingleton<ReferenceType>(); }
+// `complex` `<` kind `>`
+CplxType parseComplex(M::DialectAsmParser &parser) {
+  return parseKindSingleton<CplxType>(parser);
+}
 
-  // `ptr` `<` type `>`
-  PointerType parsePointer() { return parseTypeSingleton<PointerType>(); }
+// `dims` `<` rank `>`
+DimsType parseDims(M::DialectAsmParser &parser) {
+  return parseRankSingleton<DimsType>(parser);
+}
 
-  // `heap` `<` type `>`
-  HeapType parseHeap() { return parseTypeSingleton<HeapType>(); }
+// `field`
+FieldType parseField(M::DialectAsmParser &parser) {
+  return FieldType::get(parser.getBuilder().getContext());
+}
 
-  SequenceType::Shape parseShape();
-  SequenceType parseSequence();
+// `heap` `<` type `>`
+HeapType parseHeap(M::DialectAsmParser &parser, M::Location loc) {
+  return parseTypeSingleton<HeapType>(parser, loc);
+}
 
-  RecordType::TypeList parseTypeList();
-  RecordType::TypeList parseLenParamList();
-  RecordType parseDerived();
-  RecordType verifyDerived(RecordType derivedTy,
-                           llvm::ArrayRef<RecordType::TypePair> lenPList,
-                           llvm::ArrayRef<RecordType::TypePair> typeList);
+// `int` `<` kind `>`
+IntType parseInteger(M::DialectAsmParser &parser) {
+  return parseKindSingleton<IntType>(parser);
+}
 
-  // `tdesc` `<` type `>`
-  TypeDescType parseTypeDesc() { return parseTypeSingleton<TypeDescType>(); }
+// `len`
+LenType parseLen(M::DialectAsmParser &parser) {
+  return LenType::get(parser.getBuilder().getContext());
+}
 
-  // `void`
-  M::Type parseVoid() {
-    if (checkAtEnd())
-      return {};
-    return M::TupleType::get(getContext());
-  }
+// `logical` `<` kind `>`
+LogicalType parseLogical(M::DialectAsmParser &parser) {
+  return parseKindSingleton<LogicalType>(parser);
+}
 
-  M::MLIRContext *getContext() const { return context; }
+// `ptr` `<` type `>`
+PointerType parsePointer(M::DialectAsmParser &parser, M::Location loc) {
+  return parseTypeSingleton<PointerType>(parser, loc);
+}
 
-  M::AffineMapAttr parseAffineMapAttr();
+// `real` `<` kind `>`
+RealType parseReal(M::DialectAsmParser &parser) {
+  return parseKindSingleton<RealType>(parser);
+}
 
-private:
-  M::MLIRContext *context;
-  Lexer lexer;
-  M::Location loc;
-  int recursiveCall{-1};
-};
+// `ref` `<` type `>`
+ReferenceType parseReference(M::DialectAsmParser &parser, M::Location loc) {
+  return parseTypeSingleton<ReferenceType>(parser, loc);
+}
 
-// If this is a `!fir.x` type then recursively parse it now, otherwise figure
-// out its extent and call into the standard type parser.
-M::Type FIRTypeParser::parseNextType() {
-  return M::parseType(lexer.getNextType(), getContext());
-}
-
-// Parses either `*` `:`
-//            or (int | `?`) (`x` (int | `?`))* `:`
-SequenceType::Shape FIRTypeParser::parseShape() {
-  SequenceType::Bounds bounds;
-  int extent;
-  int nextChar;
-  Token token = lexer.lexToken();
-  if (token.kind == TokenKind::star) {
-    token = lexer.lexToken();
-    if (token.kind != TokenKind::colon) {
-      emitError(loc, "expected '*' to be followed by ':'");
-      return {};
-    }
-    return SequenceType::Shape();
-  }
-  while (true) {
-    if (token.kind != TokenKind::eroteme) {
-      goto shape_spec;
-    }
-    bounds.emplace_back(SequenceType::Extent());
-    goto check_xchar;
-  shape_spec:
-    if (token.kind != TokenKind::intlit) {
-      emitError(loc, "expected an integer or '?' in shape specification");
-      return {};
-    }
-    token.text.getAsInteger(10, extent);
-    bounds.emplace_back(extent);
-  check_xchar:
-    nextChar = lexer.nextNonWSChar();
-    if (nextChar == ':') {
-      return SequenceType::Shape(bounds);
-    }
-    if (nextChar != 'x') {
-      emitError(loc, "expected an 'x' or ':' after integer");
-      return {};
-    }
-    token = lexer.lexToken();
-  }
+// `tdesc` `<` type `>`
+TypeDescType parseTypeDesc(M::DialectAsmParser &parser, M::Location loc) {
+  return parseTypeSingleton<TypeDescType>(parser, loc);
 }
 
-// affine-map ::= `#` ident
-M::AffineMapAttr FIRTypeParser::parseAffineMapAttr() {
-  return {}; // FIXME opParser->parseAttr();
+// `void`
+M::Type parseVoid(M::DialectAsmParser &parser) {
+  return parser.getBuilder().getNoneType();
 }
 
-// bounds ::= lo extent stride | `?`
-// `array` `<` bounds (`,` bounds)* `:` type (',' affine-map)? `>`
-SequenceType FIRTypeParser::parseSequence() {
-  if (consumeToken(TokenKind::leftang, "expected '<' in array type")) {
-    return {};
-  }
-  auto shape = parseShape();
-  M::Type eleTy = parseNextType();
-  if (!eleTy) {
-    emitError(loc, "invalid element type");
+// `array` `<` `*` | bounds (`x` bounds)* `:` type (',' affine-map)? `>`
+// bounds ::= `?` | int-lit
+SequenceType parseSequence(M::DialectAsmParser &parser, M::Location) {
+  if (parser.parseLess()) {
+    parser.emitError(parser.getNameLoc(), "expecting '<'");
     return {};
   }
-  auto token = lexer.lexToken();
-  M::AffineMapAttr map;
-  if (token.kind == TokenKind::comma) {
-    map = parseAffineMapAttr();
-    token = lexer.lexToken();
-  }
-  if (token.kind != TokenKind::rightang) {
-    emitError(loc, "expected '>' in array type");
+  SequenceType::Shape shape;
+  if (parser.parseOptionalStar()) {
+    if (parser.parseDimensionList(shape, true)) {
+      parser.emitError(parser.getNameLoc(), "invalid shape");
+      return {};
+    }
+  } else if (parser.parseColon()) {
+    parser.emitError(parser.getNameLoc(), "expected ':'");
     return {};
   }
-  if (checkAtEnd()) {
+  M::Type eleTy;
+  if (parser.parseType(eleTy) || parser.parseGreater()) {
+    parser.emitError(parser.getNameLoc(), "expecting element type");
     return {};
   }
-  return SequenceType::get(shape, eleTy, map);
-}
-
-// Parses: string `:` type (',' string `:` type)* '}'
-RecordType::TypeList FIRTypeParser::parseTypeList() {
-  RecordType::TypeList result;
-  while (true) {
-    auto name{lexer.lexToken()};
-    if (name.kind != TokenKind::ident) {
-      emitError(loc, "expected identifier");
-      return {};
-    }
-    if (consumeToken(TokenKind::colon, "expected colon")) {
-      return {};
-    }
-    auto memTy{parseNextType()};
-    result.emplace_back(name.text, memTy);
-    auto token{lexer.lexToken()};
-    if (token.kind == TokenKind::rightbrace) {
-      return result;
-    }
-    if (token.kind != TokenKind::comma) {
-      emitError(loc, "expected ','");
-      return {};
-    }
-  }
-}
-
-// Parses: string `:` int-type (',' string `:` int-type)* ')'
-RecordType::TypeList FIRTypeParser::parseLenParamList() {
-  RecordType::TypeList result;
-  while (true) {
-    auto name{lexer.lexToken()};
-    if (name.kind != TokenKind::ident) {
-      emitError(loc, "expected identifier");
-      return {};
-    }
-    if (consumeToken(TokenKind::colon, "expected colon")) {
-      return {};
-    }
-    auto memTy{parseNextType()};
-    result.emplace_back(name.text, memTy);
-    auto token{lexer.lexToken()};
-    if (token.kind == TokenKind::rightparen) {
-      return result;
-    }
-    if (token.kind != TokenKind::comma) {
-      emitError(loc, "expected ','");
+  M::AffineMapAttr map;
+  if (!parser.parseOptionalComma())
+    if (parser.parseAttribute(map)) {
+      parser.emitError(parser.getNameLoc(), "expecting affine map");
       return {};
     }
-  }
+  return SequenceType::get(shape, eleTy, map);
 }
 
 bool verifyIntegerType(M::Type ty) {
@@ -615,8 +195,8 @@ bool verifyIntegerType(M::Type ty) {
 bool verifyRecordMemberType(M::Type ty) {
   return !(ty.dyn_cast<BoxType>() || ty.dyn_cast<BoxCharType>() ||
            ty.dyn_cast<BoxProcType>() || ty.dyn_cast<DimsType>() ||
-           ty.dyn_cast<FieldType>() || ty.dyn_cast<ReferenceType>() ||
-           ty.dyn_cast<TypeDescType>());
+           ty.dyn_cast<FieldType>() || ty.dyn_cast<LenType>() ||
+           ty.dyn_cast<ReferenceType>() || ty.dyn_cast<TypeDescType>());
 }
 
 bool verifySameLists(L::ArrayRef<RecordType::TypePair> a1,
@@ -632,34 +212,34 @@ bool verifySameLists(L::ArrayRef<RecordType::TypePair> a1,
   return true;
 }
 
-RecordType
-FIRTypeParser::verifyDerived(RecordType derivedTy,
-                             L::ArrayRef<RecordType::TypePair> lenPList,
-                             L::ArrayRef<RecordType::TypePair> typeList) {
+RecordType verifyDerived(M::DialectAsmParser &parser, RecordType derivedTy,
+                         L::ArrayRef<RecordType::TypePair> lenPList,
+                         L::ArrayRef<RecordType::TypePair> typeList) {
+  auto loc = parser.getNameLoc();
   if (!verifySameLists(derivedTy.getLenParamList(), lenPList) ||
       !verifySameLists(derivedTy.getTypeList(), typeList)) {
-    emitError(loc, "cannot redefine record type members");
+    parser.emitError(loc, "cannot redefine record type members");
     return {};
   }
   for (auto &p : lenPList)
     if (!verifyIntegerType(p.second)) {
-      emitError(loc, "LEN parameter must be integral type");
+      parser.emitError(loc, "LEN parameter must be integral type");
       return {};
     }
   for (auto &p : typeList)
     if (!verifyRecordMemberType(p.second)) {
-      emitError(loc, "field parameter has invalid type");
+      parser.emitError(loc, "field parameter has invalid type");
       return {};
     }
   llvm::StringSet<> uniq;
   for (auto &p : lenPList)
     if (!uniq.insert(p.first).second) {
-      emitError(loc, "LEN parameter cannot have duplicate name");
+      parser.emitError(loc, "LEN parameter cannot have duplicate name");
       return {};
     }
   for (auto &p : typeList)
     if (!uniq.insert(p.first).second) {
-      emitError(loc, "field cannot have duplicate name");
+      parser.emitError(loc, "field cannot have duplicate name");
       return {};
     }
   return derivedTy;
@@ -669,91 +249,65 @@ FIRTypeParser::verifyDerived(RecordType derivedTy,
 // `type` `<` name
 //           (`(` id `:` type (`,` id `:` type)* `)`)?
 //           (`{` id `:` type (`,` id `:` type)* `}`)? '>'
-RecordType FIRTypeParser::parseDerived() {
-  if (consumeToken(TokenKind::leftang, "expected '<' in type type")) {
-    return {};
-  }
-  auto name{lexer.lexToken()};
-  if (name.kind != TokenKind::ident) {
-    emitError(loc, "expected a identifier as name of derived type");
+RecordType parseDerived(M::DialectAsmParser &parser, M::Location) {
+  L::StringRef name;
+  if (parser.parseLess() || parser.parseKeyword(&name)) {
+    parser.emitError(parser.getNameLoc(),
+                     "expected a identifier as name of derived type");
     return {};
   }
-  RecordType result = RecordType::get(getContext(), name.text);
-  auto token = lexer.lexToken();
+  RecordType result = RecordType::get(parser.getBuilder().getContext(), name);
+
   RecordType::TypeList lenParamList;
-  RecordType::TypeList typeList;
-  if (token.kind == TokenKind::leftbrace) {
-    goto parse_fields;
-  } else if (token.kind != TokenKind::leftparen) {
-    // degenerate case?
-    goto check_close;
-  }
-  lenParamList = parseLenParamList();
-  token = lexer.lexToken();
-  if (token.kind != TokenKind::leftbrace) {
-    // no fields?
-    goto check_close;
+  if (!parser.parseOptionalLParen()) {
+    while (true) {
+      L::StringRef lenparam;
+      M::Type intTy;
+      if (parser.parseKeyword(&lenparam) || parser.parseColon() ||
+          parser.parseType(intTy)) {
+        parser.emitError(parser.getNameLoc(), "expected LEN parameter list");
+        return {};
+      }
+      lenParamList.emplace_back(lenparam, intTy);
+      if (parser.parseOptionalComma())
+        break;
+    }
+    if (parser.parseRParen()) {
+      parser.emitError(parser.getNameLoc(), "expected ')'");
+      return {};
+    }
   }
-parse_fields:
-  typeList = parseTypeList();
-  token = lexer.lexToken();
-check_close:
-  if (token.kind != TokenKind::rightang) {
-    emitError(loc, "expected '>' in type type");
-    return {};
+
+  RecordType::TypeList typeList;
+  if (!parser.parseOptionalLBrace()) {
+    while (true) {
+      L::StringRef field;
+      M::Type fldTy;
+      if (parser.parseKeyword(&field) || parser.parseColon() ||
+          parser.parseType(fldTy)) {
+        parser.emitError(parser.getNameLoc(), "expected field type list");
+        return {};
+      }
+      typeList.emplace_back(field, fldTy);
+      if (parser.parseOptionalComma())
+        break;
+    }
+    if (parser.parseRBrace()) {
+      parser.emitError(parser.getNameLoc(), "expected '}'");
+      return {};
+    }
   }
-  if (checkAtEnd()) {
+
+  if (parser.parseGreater()) {
+    parser.emitError(parser.getNameLoc(), "expected '>' in type type");
     return {};
   }
+
   if (lenParamList.empty() && typeList.empty())
     return result;
+
   result.finalize(lenParamList, typeList);
-  return verifyDerived(result, lenParamList, typeList);
-}
-
-M::Type FIRTypeParser::parseType() {
-  auto_counter c{recursiveCall};
-  auto token = lexer.lexToken();
-  if (token.kind == TokenKind::ident) {
-    if (token.text == "ref")
-      return parseReference();
-    if (token.text == "array")
-      return parseSequence();
-    if (token.text == "char")
-      return parseCharacter();
-    if (token.text == "logical")
-      return parseLogical();
-    if (token.text == "real")
-      return parseReal();
-    if (token.text == "type")
-      return parseDerived();
-    if (token.text == "box")
-      return parseBox();
-    if (token.text == "boxchar")
-      return parseBoxChar();
-    if (token.text == "boxproc")
-      return parseBoxProc();
-    if (token.text == "ptr")
-      return parsePointer();
-    if (token.text == "heap")
-      return parseHeap();
-    if (token.text == "dims")
-      return parseDims();
-    if (token.text == "tdesc")
-      return parseTypeDesc();
-    if (token.text == "field")
-      return parseField();
-    if (token.text == "int")
-      return parseInteger();
-    if (token.text == "complex")
-      return parseComplex();
-    if (token.text == "void")
-      return parseVoid();
-    emitError(loc, "not a known fir type");
-    return {};
-  }
-  emitError(loc, "invalid token");
-  return {};
+  return verifyDerived(parser, result, lenParamList, typeList);
 }
 
 // !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
@@ -765,6 +319,55 @@ bool singleIndirectionLevel(M::Type ty) {
 
 } // namespace
 
+// Implementation of the thin interface from dialect to type parser
+
+M::Type fir::parseFirType(FIROpsDialect *, M::DialectAsmParser &parser) {
+  L::StringRef typeNameLit;
+  if (M::failed(parser.parseKeyword(&typeNameLit)))
+    return {};
+
+  auto loc = parser.getEncodedSourceLoc(parser.getNameLoc());
+  if (typeNameLit == "array")
+    return parseSequence(parser, loc);
+  if (typeNameLit == "box")
+    return parseBox(parser, loc);
+  if (typeNameLit == "boxchar")
+    return parseBoxChar(parser);
+  if (typeNameLit == "boxproc")
+    return parseBoxProc(parser, loc);
+  if (typeNameLit == "char")
+    return parseCharacter(parser);
+  if (typeNameLit == "complex")
+    return parseComplex(parser);
+  if (typeNameLit == "dims")
+    return parseDims(parser);
+  if (typeNameLit == "field")
+    return parseField(parser);
+  if (typeNameLit == "heap")
+    return parseHeap(parser, loc);
+  if (typeNameLit == "int")
+    return parseInteger(parser);
+  if (typeNameLit == "len")
+    return parseLen(parser);
+  if (typeNameLit == "logical")
+    return parseLogical(parser);
+  if (typeNameLit == "ptr")
+    return parsePointer(parser, loc);
+  if (typeNameLit == "real")
+    return parseReal(parser);
+  if (typeNameLit == "ref")
+    return parseReference(parser, loc);
+  if (typeNameLit == "tdesc")
+    return parseTypeDesc(parser, loc);
+  if (typeNameLit == "type")
+    return parseDerived(parser, loc);
+  if (typeNameLit == "void")
+    return parseVoid(parser);
+
+  parser.emitError(parser.getNameLoc(), "unknown FIR type " + typeNameLit);
+  return {};
+}
+
 namespace fir {
 namespace detail {
 
@@ -838,6 +441,24 @@ struct FieldTypeStorage : public M::TypeStorage {
   explicit FieldTypeStorage(KindTy) {}
 };
 
+/// The type of a derived type LEN parameter reference
+struct LenTypeStorage : public M::TypeStorage {
+  using KeyTy = KindTy;
+
+  static unsigned hashKey(const KeyTy &) { return L::hash_combine(0); }
+
+  bool operator==(const KeyTy &) const { return true; }
+
+  static LenTypeStorage *construct(M::TypeStorageAllocator &allocator, KindTy) {
+    auto *storage = allocator.allocate<LenTypeStorage>();
+    return new (storage) LenTypeStorage{0};
+  }
+
+private:
+  LenTypeStorage() = delete;
+  explicit LenTypeStorage(KindTy) {}
+};
+
 /// `LOGICAL` storage
 struct LogicalTypeStorage : public M::TypeStorage {
   using KeyTy = KindTy;
@@ -1250,6 +871,12 @@ FieldType fir::FieldType::get(M::MLIRContext *ctxt, KindTy) {
   return Base::get(ctxt, FIR_FIELD, 0);
 }
 
+// Len
+
+LenType fir::LenType::get(M::MLIRContext *ctxt, KindTy) {
+  return Base::get(ctxt, FIR_LEN, 0);
+}
+
 // LOGICAL
 
 LogicalType fir::LogicalType::get(M::MLIRContext *ctxt, KindTy kind) {
@@ -1342,7 +969,8 @@ M::Type fir::ReferenceType::getEleTy() const {
 M::LogicalResult fir::ReferenceType::verifyConstructionInvariants(
     L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
   if (eleTy.dyn_cast<DimsType>() || eleTy.dyn_cast<FieldType>() ||
-      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
+      eleTy.dyn_cast<LenType>() || eleTy.dyn_cast<ReferenceType>() ||
+      eleTy.dyn_cast<TypeDescType>())
     return M::failure();
   return M::success();
 }
@@ -1365,9 +993,9 @@ M::LogicalResult fir::PointerType::verifyConstructionInvariants(
     L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<HeapType>() ||
-      eleTy.dyn_cast<PointerType>() || eleTy.dyn_cast<ReferenceType>() ||
-      eleTy.dyn_cast<TypeDescType>())
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
+      eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
+      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
     return M::failure();
   return M::success();
 }
@@ -1388,9 +1016,9 @@ M::LogicalResult fir::HeapType::verifyConstructionInvariants(
     L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<HeapType>() ||
-      eleTy.dyn_cast<PointerType>() || eleTy.dyn_cast<ReferenceType>() ||
-      eleTy.dyn_cast<TypeDescType>())
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
+      eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
+      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
     return M::failure();
   return M::success();
 }
@@ -1421,9 +1049,10 @@ M::LogicalResult fir::SequenceType::verifyConstructionInvariants(
   // DIMENSION attribute can only be applied to an intrinsic or record type
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<HeapType>() ||
-      eleTy.dyn_cast<PointerType>() || eleTy.dyn_cast<ReferenceType>() ||
-      eleTy.dyn_cast<TypeDescType>() || eleTy.dyn_cast<SequenceType>())
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
+      eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
+      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>() ||
+      eleTy.dyn_cast<SequenceType>())
     return M::failure();
   return M::success();
 }
@@ -1431,37 +1060,18 @@ M::LogicalResult fir::SequenceType::verifyConstructionInvariants(
 // compare if two shapes are equivalent
 bool fir::operator==(const SequenceType::Shape &sh_1,
                      const SequenceType::Shape &sh_2) {
-  if (sh_1.hasValue() != sh_2.hasValue()) {
-    return false;
-  }
-  if (!sh_1.hasValue()) {
-    return true;
-  }
-  auto &bnd_1 = *sh_1;
-  auto &bnd_2 = *sh_2;
-  if (bnd_1.size() != bnd_2.size()) {
+  if (sh_1.size() != sh_2.size())
     return false;
-  }
-  for (std::size_t i = 0, end = bnd_1.size(); i != end; ++i) {
-    if (bnd_1[i].hasValue() != bnd_2[i].hasValue()) {
-      return false;
-    }
-    if (bnd_1[i].hasValue() && *bnd_1[i] != *bnd_2[i]) {
+  for (std::size_t i = 0, e = sh_1.size(); i != e; ++i)
+    if (sh_1[i] != sh_2[i])
       return false;
-    }
-  }
   return true;
 }
 
-// compute the hash of an Extent
-L::hash_code fir::hash_value(const SequenceType::Extent &ext) {
-  return L::hash_combine(ext.hasValue() ? *ext : 0);
-}
-
 // compute the hash of a Shape
 L::hash_code fir::hash_value(const SequenceType::Shape &sh) {
-  if (sh.hasValue()) {
-    return L::hash_combine_range(sh->begin(), sh->end());
+  if (sh.size()) {
+    return L::hash_combine_range(sh.begin(), sh.end());
   }
   return L::hash_combine(0);
 }
@@ -1500,6 +1110,14 @@ M::LogicalResult fir::RecordType::verifyConstructionInvariants(
   return M::success();
 }
 
+M::Type fir::RecordType::getType(L::StringRef ident) {
+  for (auto f : getTypeList())
+    if (ident == f.first)
+      return f.second;
+  assert(false && "query for field not present in record");
+  return {};
+}
+
 /// Type descriptor type
 ///
 /// This is the type of a type descriptor object (similar to a class instance)
@@ -1515,138 +1133,137 @@ M::LogicalResult fir::TypeDescType::verifyConstructionInvariants(
     L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<ReferenceType>() ||
-      eleTy.dyn_cast<TypeDescType>())
+      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
+      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
     return M::failure();
   return M::success();
 }
 
-// Implementation of the thin interface from dialect to type parser
+namespace {
 
-M::Type fir::parseFirType(FIROpsDialect *dialect, L::StringRef rawData,
-                          M::Location loc) {
-  FIRTypeParser parser{dialect, rawData, loc};
-  return parser.parseType();
+void printBounds(llvm::raw_ostream &os, const SequenceType::Shape &bounds) {
+  os << '<';
+  for (auto &b : bounds) {
+    if (b >= 0) {
+      os << b << 'x';
+    } else {
+      os << "?x";
+    }
+  }
 }
 
-namespace {
-class TypePrinter {
-public:
-  void print(FIROpsDialect *dialect, M::Type ty, llvm::raw_ostream &os) {
-    if (auto type = ty.dyn_cast<fir::ReferenceType>()) {
-      os << "ref<";
-      type.getEleTy().print(os);
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::LogicalType>()) {
-      os << "logical<" << type.getFKind() << '>';
-    } else if (auto type = ty.dyn_cast<fir::RealType>()) {
-      os << "real<" << type.getFKind() << '>';
-    } else if (auto type = ty.dyn_cast<fir::CharacterType>()) {
-      os << "char<" << type.getFKind() << '>';
-    } else if (auto type = ty.dyn_cast<fir::TypeDescType>()) {
-      os << "tdesc<";
-      type.getOfTy().print(os);
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::FieldType>()) {
-      os << "field";
-    } else if (auto type = ty.dyn_cast<fir::BoxType>()) {
-      os << "box<";
-      type.getEleTy().print(os);
-      if (auto map = type.getLayoutMap()) {
-        os << ", ";
-        map.print(os);
-      }
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::BoxCharType>()) {
-      auto eleTy = type.getEleTy().cast<fir::CharacterType>();
-      os << "boxchar<" << eleTy.getFKind() << '>';
-    } else if (auto type = ty.dyn_cast<fir::BoxProcType>()) {
-      os << "boxproc<";
-      type.getEleTy().print(os);
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::DimsType>()) {
-      os << "dims<" << type.getRank() << '>';
-    } else if (auto type = ty.dyn_cast<fir::SequenceType>()) {
-      os << "array";
-      auto shape = type.getShape();
-      if (shape.hasValue()) {
-        printBounds(os, *shape);
-      } else {
-        os << "<*";
-      }
-      os << ':';
-      type.getEleTy().print(os);
-      if (auto map = type.getLayoutMap()) {
-        os << ", ";
-        map.print(os);
-      }
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::HeapType>()) {
-      os << "heap<";
-      type.getEleTy().print(os);
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::PointerType>()) {
-      os << "ptr<";
-      type.getEleTy().print(os);
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::RecordType>()) {
-      os << "type<" << type.getName();
-      if (!recordTypeVisited.count(type.uniqueKey())) {
-        recordTypeVisited.insert(type.uniqueKey());
-        if (type.getLenParamList().size()) {
-          char ch = '(';
-          for (auto p : type.getLenParamList()) {
-            os << ch << p.first << ':';
-            p.second.print(os);
-            ch = ',';
-          }
-          os << ')';
+llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4> recordTypeVisited;
+
+} // namespace
+
+void fir::printFirType(FIROpsDialect *, M::Type ty, M::DialectAsmPrinter &p) {
+  auto &os = p.getStream();
+  switch (ty.getKind()) {
+  case fir::FIR_BOX: {
+    auto type = ty.cast<BoxType>();
+    os << "box<";
+    p.printType(type.getEleTy());
+    if (auto map = type.getLayoutMap()) {
+      os << ", ";
+      p.printAttribute(map);
+    }
+    os << '>';
+  } break;
+  case fir::FIR_BOXCHAR: {
+    auto type = ty.cast<BoxCharType>().getEleTy();
+    os << "boxchar<" << type.cast<fir::CharacterType>().getFKind() << '>';
+  } break;
+  case fir::FIR_BOXPROC:
+    os << "boxproc<";
+    p.printType(ty.cast<BoxProcType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_CHARACTER: // intrinsic
+    os << "char<" << ty.cast<CharacterType>().getFKind() << '>';
+    break;
+  case fir::FIR_COMPLEX: // intrinsic
+    os << "complex<" << ty.cast<CplxType>().getFKind() << '>';
+    break;
+  case fir::FIR_DERIVED: { // derived
+    auto type = ty.cast<fir::RecordType>();
+    os << "type<" << type.getName();
+    if (!recordTypeVisited.count(type.uniqueKey())) {
+      recordTypeVisited.insert(type.uniqueKey());
+      if (type.getLenParamList().size()) {
+        char ch = '(';
+        for (auto p : type.getLenParamList()) {
+          os << ch << p.first << ':';
+          p.second.print(os);
+          ch = ',';
         }
-        if (type.getTypeList().size()) {
-          char ch = '{';
-          for (auto p : type.getTypeList()) {
-            os << ch << p.first << ':';
-            p.second.print(os);
-            ch = ',';
-          }
-          os << '}';
+        os << ')';
+      }
+      if (type.getTypeList().size()) {
+        char ch = '{';
+        for (auto p : type.getTypeList()) {
+          os << ch << p.first << ':';
+          p.second.print(os);
+          ch = ',';
         }
-        recordTypeVisited.erase(type.uniqueKey());
+        os << '}';
       }
-      os << '>';
-    } else if (auto type = ty.dyn_cast<fir::IntType>()) {
-      os << "int<" << type.getFKind() << '>';
-    } else if (auto type = ty.dyn_cast<fir::CplxType>()) {
-      os << "complex<" << type.getFKind() << '>';
+      recordTypeVisited.erase(type.uniqueKey());
+    }
+    os << '>';
+  } break;
+  case fir::FIR_DIMS:
+    os << "dims<" << ty.cast<DimsType>().getRank() << '>';
+    break;
+  case fir::FIR_FIELD:
+    os << "field";
+    break;
+  case fir::FIR_HEAP:
+    os << "heap<";
+    p.printType(ty.cast<HeapType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_INT: // intrinsic
+    os << "int<" << ty.cast<fir::IntType>().getFKind() << '>';
+    break;
+  case fir::FIR_LEN:
+    os << "len";
+    break;
+  case fir::FIR_LOGICAL: // intrinsic
+    os << "logical<" << ty.cast<LogicalType>().getFKind() << '>';
+    break;
+  case fir::FIR_POINTER:
+    os << "ptr<";
+    p.printType(ty.cast<PointerType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_REAL: // intrinsic
+    os << "real<" << ty.cast<fir::RealType>().getFKind() << '>';
+    break;
+  case fir::FIR_REFERENCE:
+    os << "ref<";
+    p.printType(ty.cast<ReferenceType>().getEleTy());
+    os << '>';
+    break;
+  case fir::FIR_SEQUENCE: {
+    os << "array";
+    auto type = ty.cast<SequenceType>();
+    auto shape = type.getShape();
+    if (shape.size()) {
+      printBounds(os, shape);
     } else {
-      assert(false);
+      os << "<*:";
     }
-  }
-
-private:
-  void printBounds(llvm::raw_ostream &os, const SequenceType::Bounds &bounds) {
-    char ch = '<';
-    for (auto &b : bounds) {
-      if (b.hasValue()) {
-        os << ch << *b;
-      } else {
-        os << ch << '?';
-      }
-      ch = 'x';
+    p.printType(ty.cast<SequenceType>().getEleTy());
+    if (auto map = type.getLayoutMap()) {
+      os << ", ";
+      map.print(os);
     }
+    os << '>';
+  } break;
+  case fir::FIR_TYPEDESC:
+    os << "tdesc<";
+    p.printType(ty.cast<TypeDescType>().getOfTy());
+    os << '>';
+    break;
   }
-
-  // must be in a global context because the printer must be able to track
-  // context through multiple recursive invocations of the mlir type printer
-  static llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4>
-      recordTypeVisited;
-};
-
-llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4>
-    TypePrinter::recordTypeVisited; // instantiate
-} // namespace
-
-void fir::printFirType(FIROpsDialect *dialect, M::Type ty,
-                       llvm::raw_ostream &os) {
-  TypePrinter().print(dialect, ty, os);
 }
diff --git a/lib/fir/InternalNames.cpp b/lib/fir/InternalNames.cpp
new file mode 100644
index 000000000000..3f7657a462ba
--- /dev/null
+++ b/lib/fir/InternalNames.cpp
@@ -0,0 +1,141 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/InternalNames.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+
+namespace L = llvm;
+
+namespace {
+
+inline L::Twine prefix() { return "_Q"; }
+
+L::Twine doModules(L::ArrayRef<L::StringRef> mods) {
+  L::Twine result;
+  auto *token = "M";
+  for (auto mod : mods) {
+    result.concat(token).concat(mod);
+    token = "S";
+  }
+  return result;
+}
+
+L::Twine doModulesHost(L::ArrayRef<L::StringRef> mods,
+                       L::Optional<L::StringRef> host) {
+  L::Twine result = doModules(mods);
+  if (host.hasValue())
+    result.concat("F").concat(*host);
+  return result;
+}
+
+} // namespace
+
+L::Twine fir::NameMangler::toLower(L::StringRef name) {
+  auto lo = name.lower();
+  if (name.equals(lo))
+    return name;
+  return cache.insert(lo).first->getKey();
+}
+
+L::Twine fir::NameMangler::addAsString(std::int64_t i) {
+  return cache.insert(std::to_string(i)).first->getKey();
+}
+
+L::Twine fir::NameMangler::doKind(std::int64_t kind) {
+  if (kind < 0)
+    return "KN" + addAsString(-kind);
+  return "K" + addAsString(kind);
+}
+
+L::Twine fir::NameMangler::doKinds(L::ArrayRef<std::int64_t> kinds) {
+  L::Twine result;
+  for (auto i : kinds)
+    result.concat(doKind(i));
+  return result;
+}
+
+L::Twine fir::NameMangler::doCommonBlock(L::StringRef name) {
+  return prefix() + "B" + toLower(name);
+}
+
+L::Twine fir::NameMangler::doConstant(L::ArrayRef<L::StringRef> modules,
+                                      L::StringRef name) {
+  return prefix() + doModules(modules) + "EC" + toLower(name);
+}
+
+L::Twine fir::NameMangler::doDispatchTable(L::ArrayRef<L::StringRef> modules,
+                                           L::Optional<L::StringRef> host,
+                                           L::StringRef name,
+                                           L::ArrayRef<std::int64_t> kinds) {
+  return prefix() + doModulesHost(modules, host) + "DT" + toLower(name) +
+         doKinds(kinds);
+}
+
+L::Twine fir::NameMangler::doGenerated(L::StringRef name) {
+  return prefix() + "Q" + toLower(name);
+}
+
+L::Twine fir::NameMangler::doIntrinsicTypeDescriptor(
+    L::ArrayRef<L::StringRef> modules, L::Optional<L::StringRef> host,
+    IntrinsicType type, std::int64_t kind) {
+  char const *name;
+  switch (type) {
+  case IntrinsicType::CHARACTER:
+    name = "character";
+    break;
+  case IntrinsicType::COMPLEX:
+    name = "complex";
+    break;
+  case IntrinsicType::INTEGER:
+    name = "integer";
+    break;
+  case IntrinsicType::LOGICAL:
+    name = "logical";
+    break;
+  case IntrinsicType::REAL:
+    name = "real";
+    break;
+  }
+  return prefix() + doModulesHost(modules, host) + "C" + name + doKind(kind);
+}
+
+L::Twine fir::NameMangler::doProcedure(L::ArrayRef<L::StringRef> modules,
+                                       L::Optional<L::StringRef> host,
+                                       L::StringRef name) {
+  return prefix() + doModulesHost(modules, host) + "P" + toLower(name);
+}
+
+L::Twine fir::NameMangler::doType(L::ArrayRef<L::StringRef> modules,
+                                  L::Optional<L::StringRef> host,
+                                  L::StringRef name,
+                                  L::ArrayRef<std::int64_t> kinds) {
+  return prefix() + doModulesHost(modules, host) + "T" + toLower(name) +
+         doKinds(kinds);
+}
+
+L::Twine fir::NameMangler::doTypeDescriptor(L::ArrayRef<L::StringRef> modules,
+                                            L::Optional<L::StringRef> host,
+                                            L::StringRef name,
+                                            L::ArrayRef<std::int64_t> kinds) {
+  return prefix() + doModulesHost(modules, host) + "CT" + toLower(name) +
+         doKinds(kinds);
+}
+
+L::Twine fir::NameMangler::doVariable(L::ArrayRef<L::StringRef> modules,
+                                      L::StringRef name) {
+  return prefix() + doModules(modules) + "E" + toLower(name);
+}
diff --git a/lib/fir/StdConverter.cpp b/lib/fir/StdConverter.cpp
index 9736b8b94fc0..e25fbda94baa 100644
--- a/lib/fir/StdConverter.cpp
+++ b/lib/fir/StdConverter.cpp
@@ -13,9 +13,10 @@
 // limitations under the License.
 
 #include "fir/Transforms/StdConverter.h"
-#include "fir/Dialect.h"
+#include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
-#include "fir/Type.h"
+#include "fir/FIRType.h"
+#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
@@ -24,8 +25,6 @@
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Target/LLVMIR.h"
-#include "mlir/Transforms/DialectConversion.h"
-#include "mlir/Transforms/LowerAffine.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Config/abi-breaking.h"
 #include "llvm/IR/IRBuilder.h"
@@ -42,6 +41,11 @@ namespace M = mlir;
 
 using namespace fir;
 
+static L::cl::opt<bool>
+    ClDisableFirToStd("disable-fir2std",
+                      L::cl::desc("disable FIR to standard pass"),
+                      L::cl::init(false), L::cl::Hidden);
+
 namespace {
 
 using SmallVecResult = L::SmallVector<M::Value *, 4>;
@@ -144,7 +148,10 @@ class FIRToStdLoweringPass : public M::ModulePass<FIRToStdLoweringPass> {
 
 public:
   void runOnModule() override {
-    return;
+    if (ClDisableFirToStd)
+      return;
+
+    return; // FIXME
 
     for (auto fn : getModule().getOps<M::FuncOp>()) {
       M::OpBuilder rewriter{&fn.getBody()};
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index 1ba031a454a4..36db1a3dbe9d 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -13,10 +13,11 @@
 // limitations under the License.
 
 #include "fir/Tilikum/Tilikum.h"
-#include "fir/Dialect.h"
+#include "fir/Attribute.h"
+#include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
+#include "fir/FIRType.h"
 #include "fir/KindMapping.h"
-#include "fir/Type.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
@@ -31,11 +32,16 @@
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
-/// The bridge that performs the conversion of FIR and standard dialect
-/// operations to the LLVM-IR dialect.
+/// The Tilikum bridge performs the conversion of operations from both the FIR
+/// and standard dialects to the LLVM-IR dialect.
+///
+/// Some FIR operations may be lowered to other dialects, such as standard, but
+/// some FIR operations will pass through to the Tilikum bridge.  This may be
+/// necessary to preserve the semantics of the Fortran program.
 
 #undef TODO
 #define TODO(X)                                                                \
@@ -45,6 +51,15 @@
 namespace L = llvm;
 namespace M = mlir;
 
+static L::cl::opt<bool>
+    ClDisableFirToLLVMIR("disable-fir2llvmir",
+                         L::cl::desc("disable FIR to LLVM-IR dialect pass"),
+                         L::cl::init(false), L::cl::Hidden);
+
+static L::cl::opt<bool> ClDisableLLVM("disable-llvm",
+                                      L::cl::desc("disable LLVM pass"),
+                                      L::cl::init(false), L::cl::Hidden);
+
 using namespace fir;
 
 namespace {
@@ -53,6 +68,8 @@ using SmallVecResult = L::SmallVector<M::Value *, 4>;
 using OperandTy = L::ArrayRef<M::Value *>;
 using AttributeTy = L::ArrayRef<M::NamedAttribute>;
 
+const unsigned defaultAlign = 8;
+
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
 class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
@@ -63,20 +80,24 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
   FIRToLLVMTypeConverter(M::MLIRContext *context)
       : LLVMTypeConverter(context), kindMapping(context) {}
 
+  // This returns the type of a single column. Rows are added by the caller.
   // fir.dims<r>  -->  llvm<"[r x [3 x i64]]">
-  // FIXME
   M::LLVM::LLVMType dimsType() {
     auto i64Ty{M::LLVM::LLVMType::getInt64Ty(llvmDialect)};
     return M::LLVM::LLVMType::getArrayTy(i64Ty, 3);
   }
 
   // i32 is used here because LLVM wants i32 constants when indexing into struct
-  // types. Indexing into other aggregate types is more flexible. TODO: See if
-  // we can't use i64 anyway; the restiction may not longer hold.
-  M::LLVM::LLVMType indexType() {
+  // types. Indexing into other aggregate types is more flexible.
+  M::LLVM::LLVMType offsetType() {
     return M::LLVM::LLVMType::getInt32Ty(llvmDialect);
   }
 
+  // i64 can be used to index into aggregates like arrays
+  M::LLVM::LLVMType indexType() {
+    return M::LLVM::LLVMType::getInt64Ty(llvmDialect);
+  }
+
   // This corresponds to the descriptor as defined ISO_Fortran_binding.h and the
   // addendum defined in descriptor.h.
   // FIXME: This code should be generated and follow SPOT
@@ -166,9 +187,10 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
     return fromRealTypeID(kindMapping.getRealTypeID(kind), kind);
   }
 
-  // The cache is needed to keep a unique mapping from name -> StructType
+  // fir.type<name(p : TY'...){f : TY...}>  -->  llvm<"%name = { ty... }">
   M::LLVM::LLVMType convertRecordType(RecordType derived) {
     auto name{derived.getName()};
+    // The cache is needed to keep a unique mapping from name -> StructType
     auto iter{identStructCache.find(name)};
     if (iter != identStructCache.end())
       return iter->second;
@@ -184,17 +206,28 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
   // fir.array<c ... :any>  -->  llvm<"[...[c x any]]">
   M::LLVM::LLVMType convertSequenceType(SequenceType seq) {
     auto baseTy = unwrap(convertType(seq.getEleTy()));
-    if (auto shape = seq.getShape()) {
-      for (auto e : shape.getValue())
-        if (e.hasValue())
-          baseTy = M::LLVM::LLVMType::getArrayTy(baseTy, e.getValue());
-        else
-          return baseTy.getPointerTo();
+    auto shape = seq.getShape();
+    if (shape.size()) {
+      for (auto e : shape) {
+        if (e < 0)
+          e = 0;
+        baseTy = M::LLVM::LLVMType::getArrayTy(baseTy, e);
+      }
       return baseTy;
     }
     return baseTy.getPointerTo();
   }
 
+  // tuple<TS...>  -->  llvm<"{ ts... }">
+  M::LLVM::LLVMType convertTupleType(M::TupleType tuple) {
+    L::SmallVector<M::Type, 8> inMembers;
+    tuple.getFlattenedTypes(inMembers);
+    L::SmallVector<M::LLVM::LLVMType, 8> members;
+    for (auto mem : inMembers)
+      members.push_back(convertType(mem).cast<M::LLVM::LLVMType>());
+    return M::LLVM::LLVMType::getStructTy(llvmDialect, members);
+  }
+
   // fir.tdesc<any>  -->  llvm<"i8*">
   // FIXME: for now use a void*, however pointer identity is not sufficient for
   // the f18 object v. class distinction
@@ -219,11 +252,13 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
     if (auto dims = t.dyn_cast<DimsType>())
       return M::LLVM::LLVMType::getArrayTy(dimsType(), dims.getRank());
     if (auto field = t.dyn_cast<FieldType>())
-      return M::LLVM::LLVMType::getInt64Ty(llvmDialect);
+      return M::LLVM::LLVMType::getInt32Ty(llvmDialect);
     if (auto heap = t.dyn_cast<HeapType>())
       return convertPointerLike(heap);
     if (auto integer = t.dyn_cast<IntType>())
       return convertIntegerType(integer);
+    if (auto field = t.dyn_cast<LenType>())
+      return M::LLVM::LLVMType::getInt32Ty(llvmDialect);
     if (auto logical = t.dyn_cast<LogicalType>())
       return convertLogicalType(logical);
     if (auto pointer = t.dyn_cast<PointerType>())
@@ -236,6 +271,10 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
       return convertSequenceType(sequence);
     if (auto tdesc = t.dyn_cast<TypeDescType>())
       return convertTypeDescType(tdesc.getContext());
+    if (auto tuple = t.dyn_cast<M::TupleType>())
+      return convertTupleType(tuple);
+    if (auto none = t.dyn_cast<M::NoneType>())
+      return M::LLVM::LLVMType::getStructTy(llvmDialect, {});
     return LLVMTypeConverter::convertType(t);
   }
 
@@ -275,6 +314,7 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
 // instantiate static data member
 L::StringMap<M::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
 
+/// remove `omitNames` (by name) from the attribute dictionary
 L::SmallVector<M::NamedAttribute, 4>
 pruneNamedAttrDict(L::ArrayRef<M::NamedAttribute> attrs,
                    L::ArrayRef<L::StringRef> omitNames) {
@@ -292,6 +332,10 @@ pruneNamedAttrDict(L::ArrayRef<M::NamedAttribute> attrs,
   return result;
 }
 
+inline M::LLVM::LLVMType getVoidPtrType(M::LLVM::LLVMDialect *dialect) {
+  return M::LLVM::LLVMType::getInt8PtrTy(dialect);
+}
+
 /// FIR conversion pattern template
 template <typename FromOp>
 class FIROpConversion : public M::ConversionPattern {
@@ -304,6 +348,17 @@ class FIROpConversion : public M::ConversionPattern {
 protected:
   L::LLVMContext &getLLVMContext() const { return lowering.getLLVMContext(); }
   M::LLVM::LLVMDialect *getDialect() const { return lowering.getDialect(); }
+  M::Type convertType(M::Type ty) const { return lowering.convertType(ty); }
+  M::LLVM::LLVMType unwrap(M::Type ty) const { return lowering.unwrap(ty); }
+  M::LLVM::LLVMType voidPtrTy() const { return getVoidPtrType(getDialect()); }
+
+  M::LLVM::ConstantOp genConstantOffset(M::Location loc,
+                                        M::ConversionPatternRewriter &rewriter,
+                                        int offset) const {
+    auto ity = lowering.offsetType();
+    auto cattr = rewriter.getI32IntegerAttr(offset);
+    return rewriter.create<M::LLVM::ConstantOp>(loc, ity, cattr);
+  }
 
   FIRToLLVMTypeConverter &lowering;
 };
@@ -315,15 +370,22 @@ struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto addr = M::cast<fir::AddrOfOp>(op);
-    auto ty = lowering.unwrap(lowering.convertType(addr.getType()));
+    auto ty = unwrap(convertType(addr.getType()));
     auto attrs = pruneNamedAttrDict(addr.getAttrs(), {"symbol"});
-    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(addr, ty, addr.symbol(),
-                                                      attrs);
+    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(
+        addr, ty, addr.symbol().getRootReference(), attrs);
     return matchSuccess();
   }
 };
 
-// convert to LLVM IR dialect `alloca`
+M::LLVM::ConstantOp genConstantIndex(M::Location loc, M::LLVM::LLVMType ity,
+                                     M::ConversionPatternRewriter &rewriter,
+                                     int offset) {
+  auto cattr = rewriter.getI64IntegerAttr(offset);
+  return rewriter.create<M::LLVM::ConstantOp>(loc, ity, cattr);
+}
+
+/// convert to LLVM IR dialect `alloca`
 struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -332,11 +394,13 @@ struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
                   M::ConversionPatternRewriter &rewriter) const override {
     auto alloc = M::cast<fir::AllocaOp>(op);
     auto loc = alloc.getLoc();
-    auto ty = lowering.convertType(alloc.getType());
     auto ity = lowering.indexType();
-    auto c1attr = rewriter.getI32IntegerAttr(1);
-    auto c1 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
-    rewriter.replaceOpWithNewOp<M::LLVM::AllocaOp>(alloc, ty, c1.getResult(),
+    auto c1 = genConstantIndex(loc, ity, rewriter, 1);
+    auto *size = c1.getResult();
+    for (auto *opnd : operands)
+      size = rewriter.create<M::LLVM::MulOp>(loc, ity, size, opnd);
+    auto ty = convertType(alloc.getType());
+    rewriter.replaceOpWithNewOp<M::LLVM::AllocaOp>(alloc, ty, size,
                                                    alloc.getAttrs());
     return matchSuccess();
   }
@@ -346,21 +410,17 @@ M::LLVM::LLVMFuncOp getMalloc(AllocMemOp op,
                               M::ConversionPatternRewriter &rewriter,
                               M::LLVM::LLVMDialect *dialect) {
   auto module = op.getParentOfType<M::ModuleOp>();
-  auto mallocFunc = module.lookupSymbol<M::LLVM::LLVMFuncOp>("malloc");
-  if (!mallocFunc) {
-    M::OpBuilder moduleBuilder(
-        op.getParentOfType<M::ModuleOp>().getBodyRegion());
-    auto voidPtrType = M::LLVM::LLVMType::getInt8PtrTy(dialect);
-    auto indexType = M::LLVM::LLVMType::getInt64Ty(dialect);
-    mallocFunc = moduleBuilder.create<M::LLVM::LLVMFuncOp>(
-        rewriter.getUnknownLoc(), "malloc",
-        M::LLVM::LLVMType::getFunctionTy(voidPtrType, indexType,
-                                         /*isVarArg=*/false));
-  }
-  return mallocFunc;
+  if (auto mallocFunc = module.lookupSymbol<M::LLVM::LLVMFuncOp>("malloc"))
+    return mallocFunc;
+  M::OpBuilder moduleBuilder(op.getParentOfType<M::ModuleOp>().getBodyRegion());
+  auto indexType = M::LLVM::LLVMType::getInt64Ty(dialect);
+  return moduleBuilder.create<M::LLVM::LLVMFuncOp>(
+      rewriter.getUnknownLoc(), "malloc",
+      M::LLVM::LLVMType::getFunctionTy(getVoidPtrType(dialect), indexType,
+                                       /*isVarArg=*/false));
 }
 
-// convert to `call` to the runtime to `malloc` memory
+/// convert to `call` to the runtime to `malloc` memory
 struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -368,18 +428,67 @@ struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto heap = M::cast<AllocMemOp>(op);
-    auto ty = lowering.convertType(heap.getType());
-    // FIXME: should be a call to malloc
+    auto ty = convertType(heap.getType());
+    auto dialect = getDialect();
+    auto mallocFunc = getMalloc(heap, rewriter, dialect);
     auto loc = heap.getLoc();
     auto ity = lowering.indexType();
-    auto c1attr = rewriter.getI32IntegerAttr(1);
-    auto c1 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
-    rewriter.replaceOpWithNewOp<M::LLVM::AllocaOp>(heap, ty, c1.getResult(),
-                                                   heap.getAttrs());
+    auto c1 = genConstantIndex(loc, ity, rewriter, 1);
+    auto *size = c1.getResult();
+    for (auto *opnd : operands)
+      size = rewriter.create<M::LLVM::MulOp>(loc, ity, size, opnd);
+    heap.setAttr("callee", rewriter.getSymbolRefAttr(mallocFunc));
+    L::SmallVector<M::Value *, 1> args{size};
+    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(heap, ty, args,
+                                                 heap.getAttrs());
+    return matchSuccess();
+  }
+};
+
+/// obtain the free() function
+M::LLVM::LLVMFuncOp getFree(FreeMemOp op,
+                            M::ConversionPatternRewriter &rewriter,
+                            M::LLVM::LLVMDialect *dialect) {
+  auto module = op.getParentOfType<M::ModuleOp>();
+  if (auto freeFunc = module.lookupSymbol<M::LLVM::LLVMFuncOp>("free"))
+    return freeFunc;
+  M::OpBuilder moduleBuilder(op.getParentOfType<M::ModuleOp>().getBodyRegion());
+  auto voidType = M::LLVM::LLVMType::getVoidTy(dialect);
+  return moduleBuilder.create<M::LLVM::LLVMFuncOp>(
+      rewriter.getUnknownLoc(), "free",
+      M::LLVM::LLVMType::getFunctionTy(voidType, getVoidPtrType(dialect),
+                                       /*isVarArg=*/false));
+}
+
+/// lower a freemem instruction into a call to free()
+struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto freemem = M::cast<fir::FreeMemOp>(op);
+    auto dialect = getDialect();
+    auto freeFunc = getFree(freemem, rewriter, dialect);
+    auto bitcast = rewriter.create<M::LLVM::BitcastOp>(
+        freemem.getLoc(), voidPtrTy(), operands[0]);
+    freemem.setAttr("callee", rewriter.getSymbolRefAttr(freeFunc));
+    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(
+        freemem, M::LLVM::LLVMType::getVoidTy(dialect),
+        L::SmallVector<M::Value *, 1>{bitcast}, freemem.getAttrs());
     return matchSuccess();
   }
 };
 
+template <typename... ARGS>
+M::LLVM::GEPOp genGEP(M::Location loc, M::LLVM::LLVMType ty,
+                      M::ConversionPatternRewriter &rewriter, M::Value *base,
+                      ARGS... args) {
+  L::SmallVector<M::Value *, 8> cv{args...};
+  return rewriter.create<M::LLVM::GEPOp>(loc, ty, base, cv);
+}
+
+/// convert to returning the first element of the box (any flavor)
 struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -389,16 +498,15 @@ struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
     auto boxaddr = M::cast<BoxAddrOp>(op);
     auto a = operands[0];
     auto loc = boxaddr.getLoc();
-    auto ty = lowering.convertType(boxaddr.getType());
-    auto c0attr = rewriter.getI32IntegerAttr(0);
+    auto ty = convertType(boxaddr.getType());
     if (auto argty = boxaddr.val()->getType().dyn_cast<BoxType>()) {
-      auto ity = lowering.indexType();
-      auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-      L::SmallVector<M::Value *, 4> args({a, c0, c0});
-      auto pty = lowering.unwrap(ty).getPointerTo();
-      auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
+      auto c0 = genConstantOffset(loc, rewriter, 0);
+      auto pty = unwrap(ty).getPointerTo();
+      auto p = genGEP(loc, unwrap(pty), rewriter, a, c0, c0);
+      // load the pointer from the buffer
       rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxaddr, ty, p);
     } else {
+      auto c0attr = rewriter.getI32IntegerAttr(0);
       auto c0 = M::ArrayAttr::get(c0attr, boxaddr.getContext());
       rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxaddr, ty, a, c0);
     }
@@ -406,6 +514,7 @@ struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
   }
 };
 
+/// convert to an extractvalue for the 2nd part of the boxchar
 struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -414,7 +523,7 @@ struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
                   M::ConversionPatternRewriter &rewriter) const override {
     auto boxchar = M::cast<BoxCharLenOp>(op);
     auto a = operands[0];
-    auto ty = lowering.convertType(boxchar.getType());
+    auto ty = convertType(boxchar.getType());
     auto ctx = boxchar.getContext();
     auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxchar, ty, a, c1);
@@ -422,6 +531,7 @@ struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
   }
 };
 
+/// convert to a triple set of GEPs and loads
 struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -432,17 +542,26 @@ struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
     auto a = operands[0];
     auto dim = operands[1];
     auto loc = boxdims.getLoc();
-    auto ity = lowering.indexType();
-    auto c0attr = rewriter.getI32IntegerAttr(0);
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-    auto c7attr = rewriter.getI32IntegerAttr(7);
-    auto c7 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c7attr);
-    auto ty = lowering.convertType(boxdims.getResult(0)->getType());
-    L::SmallVector<M::Value *, 4> args({a, c0, c7, dim});
-    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
-    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxdims, ty, p);
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c7 = genConstantOffset(loc, rewriter, 7);
+    auto l0 = loadFromOffset(boxdims, loc, a, c0, c7, dim, 0, rewriter);
+    auto l1 = loadFromOffset(boxdims, loc, a, c0, c7, dim, 1, rewriter);
+    auto l2 = loadFromOffset(boxdims, loc, a, c0, c7, dim, 2, rewriter);
+    rewriter.replaceOp(boxdims,
+                       {l0.getResult(), l1.getResult(), l2.getResult()});
     return matchSuccess();
   }
+
+  M::LLVM::LoadOp loadFromOffset(BoxDimsOp boxdims, M::Location loc,
+                                 M::Value *a, M::LLVM::ConstantOp c0,
+                                 M::LLVM::ConstantOp c7, M::Value *dim, int off,
+                                 M::ConversionPatternRewriter &rewriter) const {
+    auto ty = convertType(boxdims.getResult(off)->getType());
+    auto pty = unwrap(ty).getPointerTo();
+    auto c = genConstantOffset(loc, rewriter, off);
+    auto p = genGEP(loc, pty, rewriter, a, c0, c7, dim, c);
+    return rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+  }
 };
 
 struct BoxEleSizeOpConversion : public FIROpConversion<BoxEleSizeOp> {
@@ -454,14 +573,10 @@ struct BoxEleSizeOpConversion : public FIROpConversion<BoxEleSizeOp> {
     auto boxelesz = M::cast<BoxEleSizeOp>(op);
     auto a = operands[0];
     auto loc = boxelesz.getLoc();
-    auto ty = lowering.convertType(boxelesz.getType());
-    auto ity = lowering.indexType();
-    auto c0attr = rewriter.getI32IntegerAttr(0);
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-    auto c1attr = rewriter.getI32IntegerAttr(1);
-    auto c1 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
-    L::SmallVector<M::Value *, 4> args({a, c0, c1});
-    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c1 = genConstantOffset(loc, rewriter, 1);
+    auto ty = convertType(boxelesz.getType());
+    auto p = genGEP(loc, unwrap(ty), rewriter, a, c0, c1);
     rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxelesz, ty, p);
     return matchSuccess();
   }
@@ -476,17 +591,13 @@ struct BoxIsAllocOpConversion : public FIROpConversion<BoxIsAllocOp> {
     auto boxisalloc = M::cast<BoxIsAllocOp>(op);
     auto a = operands[0];
     auto loc = boxisalloc.getLoc();
-    auto ty = lowering.convertType(boxisalloc.getType());
-    auto ity = lowering.indexType();
-    auto c0attr = rewriter.getI32IntegerAttr(0);
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-    auto c5attr = rewriter.getI32IntegerAttr(5);
-    auto c5 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c5attr);
-    L::SmallVector<M::Value *, 4> args({a, c0, c5});
-    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    auto ity = lowering.offsetType();
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c5 = genConstantOffset(loc, rewriter, 5);
+    auto ty = convertType(boxisalloc.getType());
+    auto p = genGEP(loc, unwrap(ty), rewriter, a, c0, c5);
     auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
-    auto c2attr = rewriter.getI32IntegerAttr(2);
-    auto ab = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c2attr);
+    auto ab = genConstantOffset(loc, rewriter, 2);
     auto bit = rewriter.create<M::LLVM::AndOp>(loc, ity, ld, ab);
     rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
         boxisalloc, M::LLVM::ICmpPredicate::ne, bit, c0);
@@ -503,14 +614,10 @@ struct BoxIsArrayOpConversion : public FIROpConversion<BoxIsArrayOp> {
     auto boxisarray = M::cast<BoxIsArrayOp>(op);
     auto a = operands[0];
     auto loc = boxisarray.getLoc();
-    auto ty = lowering.convertType(boxisarray.getType());
-    auto ity = lowering.indexType();
-    auto c0attr = rewriter.getI32IntegerAttr(0);
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-    auto c3attr = rewriter.getI32IntegerAttr(3);
-    auto c3 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c3attr);
-    L::SmallVector<M::Value *, 4> args({a, c0, c3});
-    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c3 = genConstantOffset(loc, rewriter, 3);
+    auto ty = convertType(boxisarray.getType());
+    auto p = genGEP(loc, unwrap(ty), rewriter, a, c0, c3);
     auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
     rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
         boxisarray, M::LLVM::ICmpPredicate::ne, ld, c0);
@@ -527,17 +634,14 @@ struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
     auto boxisptr = M::cast<BoxIsPtrOp>(op);
     auto a = operands[0];
     auto loc = boxisptr.getLoc();
-    auto ty = lowering.convertType(boxisptr.getType());
-    auto ity = lowering.indexType();
-    auto c0attr = rewriter.getI32IntegerAttr(0);
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-    auto c5attr = rewriter.getI32IntegerAttr(5);
-    auto c5 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c5attr);
-    L::SmallVector<M::Value *, 4> args({a, c0, c5});
+    auto ty = convertType(boxisptr.getType());
+    auto ity = lowering.offsetType();
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c5 = genConstantOffset(loc, rewriter, 5);
+    L::SmallVector<M::Value *, 4> args{a, c0, c5};
     auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
     auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
-    auto c1attr = rewriter.getI32IntegerAttr(1);
-    auto ab = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c1attr);
+    auto ab = genConstantOffset(loc, rewriter, 1);
     auto bit = rewriter.create<M::LLVM::AndOp>(loc, ity, ld, ab);
     rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
         boxisptr, M::LLVM::ICmpPredicate::ne, bit, c0);
@@ -553,7 +657,7 @@ struct BoxProcHostOpConversion : public FIROpConversion<BoxProcHostOp> {
                   M::ConversionPatternRewriter &rewriter) const override {
     auto boxprochost = M::cast<BoxProcHostOp>(op);
     auto a = operands[0];
-    auto ty = lowering.convertType(boxprochost.getType());
+    auto ty = convertType(boxprochost.getType());
     auto ctx = boxprochost.getContext();
     auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxprochost, ty, a,
@@ -571,14 +675,11 @@ struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
     auto boxrank = M::cast<BoxRankOp>(op);
     auto a = operands[0];
     auto loc = boxrank.getLoc();
-    auto ty = lowering.convertType(boxrank.getType());
-    auto ity = lowering.indexType();
-    auto c0attr = rewriter.getI32IntegerAttr(0);
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-    auto c3attr = rewriter.getI32IntegerAttr(3);
-    auto c3 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c3attr);
-    L::SmallVector<M::Value *, 4> args({a, c0, c3});
-    auto pty = lowering.unwrap(ty).getPointerTo();
+    auto ty = convertType(boxrank.getType());
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c3 = genConstantOffset(loc, rewriter, 3);
+    L::SmallVector<M::Value *, 4> args{a, c0, c3};
+    auto pty = unwrap(ty).getPointerTo();
     auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
     rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxrank, ty, p);
     return matchSuccess();
@@ -594,14 +695,11 @@ struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
     auto boxtypedesc = M::cast<BoxTypeDescOp>(op);
     auto a = operands[0];
     auto loc = boxtypedesc.getLoc();
-    auto ty = lowering.convertType(boxtypedesc.getType());
-    auto ity = lowering.indexType();
-    auto c0attr = rewriter.getI32IntegerAttr(0);
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c0attr);
-    auto c4attr = rewriter.getI32IntegerAttr(4);
-    auto c4 = rewriter.create<M::LLVM::ConstantOp>(loc, ity, c4attr);
-    L::SmallVector<M::Value *, 4> args({a, c0, c4});
-    auto pty = lowering.unwrap(ty).getPointerTo();
+    auto ty = convertType(boxtypedesc.getType());
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c4 = genConstantOffset(loc, rewriter, 4);
+    L::SmallVector<M::Value *, 4> args{a, c0, c4};
+    auto pty = unwrap(ty).getPointerTo();
     auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
     auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
     auto i8ptr = M::LLVM::LLVMType::getInt8PtrTy(getDialect());
@@ -610,7 +708,28 @@ struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
   }
 };
 
-// direct call LLVM function
+struct ConstantOpConversion : public FIROpConversion<fir::ConstantOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto constop = M::cast<fir::ConstantOp>(op);
+    auto ty_ = constop.getType();
+    auto ty = convertType(ty_);
+    auto attr = constop.getValue();
+    auto attr_ = attr.cast<M::StringAttr>();
+    if (auto ft = ty_.dyn_cast<fir::RealType>()) {
+      auto kind = ft.getFKind();
+      L::APFloat f{L::APFloat::IEEEdouble(), attr_.getValue()};
+      attr = M::FloatAttr::get(M::FloatType::getF64(constop.getContext()), f);
+    }
+    rewriter.replaceOpWithNewOp<M::LLVM::ConstantOp>(constop, ty, attr);
+    return matchSuccess();
+  }
+};
+
+/// direct call LLVM function
 struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -620,14 +739,70 @@ struct CallOpConversion : public FIROpConversion<fir::CallOp> {
     auto call = M::cast<fir::CallOp>(op);
     L::SmallVector<M::Type, 4> resultTys;
     for (auto r : call.getResults())
-      resultTys.push_back(lowering.convertType(r->getType()));
+      resultTys.push_back(convertType(r->getType()));
     rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(call, resultTys, operands,
                                                  call.getAttrs());
     return matchSuccess();
   }
 };
 
-// convert value of from-type to value of to-type
+/// Compare complex values
+///
+/// Per 10.1, the only comparisons available are .EQ. (oeq) and .NE. (une).
+///
+/// For completeness, all other comparison are done on the real component only.
+struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto cmp = M::cast<fir::CmpcOp>(op);
+    auto ctxt = cmp.getContext();
+    auto kind = cmp.lhs()->getType().cast<fir::CplxType>().getFKind();
+    auto ty = convertType(fir::RealType::get(ctxt, kind));
+    auto loc = cmp.getLoc();
+    auto pos0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
+    L::SmallVector<M::Value *, 2> rp{
+        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[0], pos0),
+        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[1], pos0)};
+    auto rcp = rewriter.create<M::LLVM::FCmpOp>(loc, ty, rp, cmp.getAttrs());
+    auto pos1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
+    L::SmallVector<M::Value *, 2> ip{
+        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[0], pos1),
+        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[1], pos1)};
+    auto icp = rewriter.create<M::LLVM::FCmpOp>(loc, ty, ip, cmp.getAttrs());
+    L::SmallVector<M::Value *, 2> cp{rcp, icp};
+    switch (cmp.getPredicate()) {
+    case fir::CmpFPredicate::OEQ: // .EQ.
+      rewriter.replaceOpWithNewOp<M::LLVM::AndOp>(cmp, ty, cp);
+      break;
+    case fir::CmpFPredicate::UNE: // .NE.
+      rewriter.replaceOpWithNewOp<M::LLVM::OrOp>(cmp, ty, cp);
+      break;
+    default:
+      rewriter.replaceOp(cmp, rcp.getResult());
+      break;
+    }
+    return matchSuccess();
+  }
+};
+
+struct CmpfOpConversion : public FIROpConversion<fir::CmpfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto cmp = M::cast<fir::CmpfOp>(op);
+    auto type = convertType(cmp.getType());
+    rewriter.replaceOpWithNewOp<M::LLVM::FCmpOp>(cmp, type, operands,
+                                                 cmp.getAttrs());
+    return matchSuccess();
+  }
+};
+
+/// convert value of from-type to value of to-type
 struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -635,10 +810,10 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto convert = M::cast<ConvertOp>(op);
-    auto fromTy_ = lowering.convertType(convert.value()->getType());
-    auto fromTy = lowering.unwrap(fromTy_);
-    auto toTy_ = lowering.convertType(convert.res()->getType());
-    auto toTy = lowering.unwrap(toTy_);
+    auto fromTy_ = convertType(convert.value()->getType());
+    auto fromTy = unwrap(fromTy_);
+    auto toTy_ = convertType(convert.res()->getType());
+    auto toTy = unwrap(toTy_);
     auto *fromLLVMTy = fromTy.getUnderlyingType();
     auto *toLLVMTy = toTy.getUnderlyingType();
     auto *op0 = operands[0];
@@ -652,7 +827,7 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
       if (toLLVMTy->isFloatingPointTy()) {
         unsigned fromBits = fromLLVMTy->getPrimitiveSizeInBits();
         unsigned toBits = toLLVMTy->getPrimitiveSizeInBits();
-        // TODO: what if different reps (F16, BF16) are the same size?
+        // FIXME: what if different reps (F16, BF16) are the same size?
         assert(fromBits != toBits);
         if (fromBits > toBits)
           v = rewriter.create<M::LLVM::FPTruncOp>(loc, toTy, op0);
@@ -690,29 +865,7 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
   }
 };
 
-// convert to reference to a reference to a subobject
-struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
-  using FIROpConversion::FIROpConversion;
-
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto coor = M::cast<CoordinateOp>(op);
-    auto baseOp = coor.ref()->getDefiningOp();
-    auto loc = coor.getLoc();
-    if (auto box = M::dyn_cast<EmboxOp>(baseOp)) {
-      // FIXME: for now assume this is always an array
-      M::Value *v = rewriter.create<M::LLVM::GEPOp>(
-          loc, lowering.convertType(coor.getType()), box.memref(), operands);
-      rewriter.replaceOp(op, v);
-      return matchSuccess();
-    }
-    TODO(coor);
-    return matchSuccess();
-  }
-};
-
-// virtual call to a method in a dispatch table
+/// virtual call to a method in a dispatch table
 struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -720,7 +873,7 @@ struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto dispatch = M::cast<DispatchOp>(op);
-    auto ty = lowering.convertType(dispatch.getFunctionType());
+    auto ty = convertType(dispatch.getFunctionType());
     // get the table, lookup the method, fetch the func-ptr
     rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(dispatch, ty, operands);
     TODO(dispatch);
@@ -728,7 +881,7 @@ struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
   }
 };
 
-// dispatch table for a Fortran derived type
+/// dispatch table for a Fortran derived type
 struct DispatchTableOpConversion : public FIROpConversion<DispatchTableOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -741,7 +894,7 @@ struct DispatchTableOpConversion : public FIROpConversion<DispatchTableOp> {
   }
 };
 
-// entry in a dispatch table; binds a method-name to a function
+/// entry in a dispatch table; binds a method-name to a function
 struct DTEntryOpConversion : public FIROpConversion<DTEntryOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -754,7 +907,7 @@ struct DTEntryOpConversion : public FIROpConversion<DTEntryOp> {
   }
 };
 
-// create a CHARACTER box
+/// create a CHARACTER box
 struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -766,7 +919,7 @@ struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
     auto b = operands[1];
     auto loc = emboxchar.getLoc();
     auto ctx = emboxchar.getContext();
-    auto ty = lowering.convertType(emboxchar.getType());
+    auto ty = convertType(emboxchar.getType());
     auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
     auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     auto un = rewriter.create<M::LLVM::UndefOp>(loc, ty);
@@ -777,7 +930,7 @@ struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
   }
 };
 
-// create a generic box on a memory reference
+/// create a generic box on a memory reference
 struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -785,12 +938,67 @@ struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto embox = M::cast<EmboxOp>(op);
-    TODO(embox);
+    auto loc = embox.getLoc();
+    auto dialect = getDialect();
+    auto ty = unwrap(convertType(embox.getType()));
+    auto alloca = genAllocaWithType(loc, ty, 24, defaultAlign, rewriter);
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto rty = unwrap(operands[0]->getType()).getPointerTo();
+    auto f0p = genGEP(loc, rty, rewriter, alloca, c0, c0);
+    auto f0p_ = rewriter.create<M::LLVM::BitcastOp>(loc, rty, f0p);
+    rewriter.create<M::LLVM::StoreOp>(loc, operands[0], f0p_);
+    auto i64Ty = M::LLVM::LLVMType::getInt64Ty(dialect);
+    auto i64PtrTy = i64Ty.getPointerTo();
+    auto f1p = genGEPToField(loc, i64PtrTy, rewriter, alloca, c0, 1);
+    auto c0_ = rewriter.create<M::LLVM::SExtOp>(loc, i64Ty, c0);
+    rewriter.create<M::LLVM::StoreOp>(loc, c0_, f1p);
+    auto i32PtrTy = M::LLVM::LLVMType::getInt32Ty(dialect).getPointerTo();
+    auto f2p = genGEPToField(loc, i32PtrTy, rewriter, alloca, c0, 2);
+    rewriter.create<M::LLVM::StoreOp>(loc, c0, f2p);
+    auto i8Ty = M::LLVM::LLVMType::getInt8Ty(dialect);
+    auto i8PtrTy = M::LLVM::LLVMType::getInt8PtrTy(dialect);
+    auto c0__ = rewriter.create<M::LLVM::TruncOp>(loc, i8Ty, c0);
+    auto f3p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 3);
+    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f3p);
+    auto f4p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 4);
+    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f4p);
+    auto f5p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 5);
+    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f5p);
+    auto f6p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 6);
+    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f6p);
+    // FIXME: copy the dims info, etc.
+
+    rewriter.replaceOp(embox, alloca.getResult());
     return matchSuccess();
   }
+
+  /// Generate an alloca of size `size` and cast it to type `toTy`
+  M::LLVM::BitcastOp
+  genAllocaWithType(M::Location loc, M::LLVM::LLVMType toTy, unsigned size,
+                    unsigned alignment,
+                    M::ConversionPatternRewriter &rewriter) const {
+    auto i8Ty = M::LLVM::LLVMType::getInt8PtrTy(getDialect());
+    auto thisPt = rewriter.saveInsertionPoint();
+    auto *thisBlock = rewriter.getInsertionBlock();
+    auto func = M::cast<M::LLVM::LLVMFuncOp>(thisBlock->getParentOp());
+    rewriter.setInsertionPointToStart(&func.front());
+    auto size_ = genConstantOffset(loc, rewriter, size);
+    auto al = rewriter.create<M::LLVM::AllocaOp>(loc, i8Ty, size_, alignment);
+    rewriter.restoreInsertionPoint(thisPt);
+    return rewriter.create<M::LLVM::BitcastOp>(loc, toTy, al);
+  }
+
+  M::LLVM::BitcastOp genGEPToField(M::Location loc, M::LLVM::LLVMType ty,
+                                   M::ConversionPatternRewriter &rewriter,
+                                   M::Value *base, M::Value *zero,
+                                   int field) const {
+    auto coff = genConstantOffset(loc, rewriter, field);
+    auto gep = genGEP(loc, ty, rewriter, base, zero, coff);
+    return rewriter.create<M::LLVM::BitcastOp>(loc, ty, gep);
+  }
 };
 
-// create a procedure pointer box
+/// create a procedure pointer box
 struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -802,7 +1010,7 @@ struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
     auto b = operands[1];
     auto loc = emboxproc.getLoc();
     auto ctx = emboxproc.getContext();
-    auto ty = lowering.convertType(emboxproc.getType());
+    auto ty = convertType(emboxproc.getType());
     auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
     auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     auto un = rewriter.create<M::LLVM::UndefOp>(loc, ty);
@@ -813,7 +1021,34 @@ struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
   }
 };
 
-// extract a subobject value from an ssa-value of aggregate type
+/// return true if all `Value`s in `operands` are `ConstantOp`s
+bool allConstants(OperandTy operands) {
+  for (auto *opnd : operands) {
+    if (auto defop = opnd->getDefiningOp())
+      if (dyn_cast<M::LLVM::ConstantOp>(defop) ||
+          dyn_cast<M::ConstantOp>(defop))
+        continue;
+    return false;
+  }
+  return true;
+}
+
+M::Attribute getValue(M::Value *value) {
+  assert(value->getDefiningOp());
+  if (auto v = dyn_cast<M::LLVM::ConstantOp>(value->getDefiningOp()))
+    return v.value();
+  if (auto v = dyn_cast<M::ConstantOp>(value->getDefiningOp()))
+    return v.value();
+  assert(false && "must be a constant op");
+  return {};
+}
+
+template <typename A>
+inline void appendTo(L::SmallVectorImpl<A> &dest, L::ArrayRef<A> from) {
+  dest.append(from.begin(), from.end());
+}
+
+/// Extract a subobject value from an ssa-value of aggregate type
 struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -821,73 +1056,231 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto extractVal = M::cast<ExtractValueOp>(op);
-    TODO(extractVal);
+    auto ty = convertType(extractVal.getType());
+    assert(allConstants(operands.drop_front(1)));
+    // since all indices are constants use LLVM's extractvalue instruction
+    L::SmallVector<M::Attribute, 8> attrs;
+    for (int i = 1, end = operands.size(); i < end; ++i)
+      attrs.push_back(getValue(operands[i]));
+    auto position = M::ArrayAttr::get(attrs, extractVal.getContext());
+    rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(extractVal, ty,
+                                                         operands[0], position);
     return matchSuccess();
   }
 };
 
-// Compute the offset of a field in a variable of derived type. A value of type
-// field can only be used as an argument to a coordinate_of, extract_value, or
-// insert_value operation. It derives it's meaning from the context of where it
-// is used.
-struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
+/// InsertValue is the generalized instruction for the composition of new
+/// aggregate type values.
+struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
   using FIROpConversion::FIROpConversion;
 
   M::PatternMatchResult
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
-    auto fieldindex = M::cast<FieldIndexOp>(op);
-    rewriter.replaceOp(fieldindex, {});
+    auto insertVal = cast<InsertValueOp>(op);
+    auto ty = convertType(insertVal.getType());
+    assert(allConstants(operands.drop_front(2)));
+    // since all indices must be constants use LLVM's insertvalue instruction
+    L::SmallVector<M::Attribute, 8> attrs;
+    for (int i = 2, end = operands.size(); i < end; ++i)
+      attrs.push_back(getValue(operands[i]));
+    auto position = M::ArrayAttr::get(attrs, insertVal.getContext());
+    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(
+        insertVal, ty, operands[0], operands[1], position);
     return matchSuccess();
   }
 };
 
-// Replace the fir-end op with a null
-struct FirEndOpConversion : public FIROpConversion<FirEndOp> {
+/// return true if all `Value`s in `operands` are not `FieldIndexOp`s
+bool noFieldIndexOps(M::Operation::operand_range operands) {
+  for (auto *opnd : operands) {
+    if (auto defop = opnd->getDefiningOp())
+      if (dyn_cast<FieldIndexOp>(defop))
+        return false;
+  }
+  return true;
+}
+
+/// convert to reference to a reference to a subobject
+struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
   using FIROpConversion::FIROpConversion;
 
   M::PatternMatchResult
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOp(op, {});
+    auto coor = M::cast<CoordinateOp>(op);
+    auto ty = convertType(coor.getType());
+    auto loc = coor.getLoc();
+    M::Value *base = operands[0];
+    auto c0 = genConstantIndex(loc, lowering.indexType(), rewriter, 0);
+
+    // The base can be a boxed reference or a raw reference
+    if (auto boxTy = coor.ref()->getType().dyn_cast<BoxType>()) {
+      if (coor.getNumOperands() == 2) {
+        auto *coorPtr = *coor.coor().begin();
+        auto *s = coorPtr->getDefiningOp();
+        if (dyn_cast_or_null<LenParamIndexOp>(s)) {
+          auto *lenParam = operands[1]; // byte offset
+          auto bc = rewriter.create<M::LLVM::BitcastOp>(loc, voidPtrTy(), base);
+          auto uty = unwrap(ty);
+          auto gep = genGEP(loc, uty, rewriter, bc, lenParam);
+          rewriter.replaceOpWithNewOp<M::LLVM::BitcastOp>(coor, uty, gep);
+          return matchSuccess();
+        }
+      }
+      auto c0_ = genConstantOffset(loc, rewriter, 0);
+      auto pty = unwrap(convertType(boxTy.getEleTy())).getPointerTo();
+      // Extract the boxed reference
+      auto p = genGEP(loc, pty, rewriter, base, c0, c0_);
+      base = rewriter.create<M::LLVM::LoadOp>(loc, pty, p);
+    }
+
+    L::SmallVector<M::Value *, 8> offs{c0};
+    auto indices = operands.drop_front(1);
+    offs.append(indices.begin(), indices.end());
+    if (noFieldIndexOps(coor.coor())) {
+      // do not need to lower any field index ops, so use a GEP
+      rewriter.replaceOpWithNewOp<M::LLVM::GEPOp>(coor, ty, base, offs);
+      return matchSuccess();
+    }
+
+    // lower the field index ops by walking the indices
+    auto bty = coor.ref()->getType().cast<BoxType>();
+    M::Type baseTy = ReferenceType::get(bty.getEleTy());
+    L::SmallVector<M::Value *, 8> args{c0};
+    args.append(coor.coor().begin(), coor.coor().end());
+
+    M::Value *retval = base;
+    assert(offs.size() == args.size() && "must have same arity");
+    unsigned pos = 0;
+    for (unsigned i = 0, sz = offs.size(); i != sz; ++i) {
+      assert(pos <= i);
+      if (auto *defop = args[i]->getDefiningOp())
+        if (auto field = dyn_cast<FieldIndexOp>(defop)) {
+          auto memTy = unwrap(convertType(baseTy)).getPointerTo();
+          M::Value *gep = retval;
+          if (i - pos > 0)
+            gep = genGEP(loc, memTy, rewriter, gep, arguments(offs, pos, i));
+          auto bc = rewriter.create<M::LLVM::BitcastOp>(loc, voidPtrTy(), gep);
+          auto gep_ = genGEP(loc, voidPtrTy(), rewriter, bc, offs[i]);
+          pos = i + 1;
+          baseTy = baseTy.cast<RecordType>().getType(field.field_id());
+          retval = rewriter.create<M::LLVM::BitcastOp>(loc, convertType(baseTy),
+                                                       gep_);
+          continue;
+        }
+      if (auto ptrTy = baseTy.dyn_cast<ReferenceType>()) {
+        baseTy = ptrTy.getEleTy();
+      } else if (auto ptrTy = baseTy.dyn_cast<fir::PointerType>()) {
+        baseTy = ptrTy.getEleTy();
+      } else if (auto ptrTy = baseTy.dyn_cast<HeapType>()) {
+        baseTy = ptrTy.getEleTy();
+      } else if (auto arrTy = baseTy.dyn_cast<SequenceType>()) {
+        // FIXME: unchecked advance over array dims
+        i += arrTy.getDimension() - 1;
+        baseTy = arrTy.getEleTy();
+      } else if (auto strTy = baseTy.dyn_cast<RecordType>()) {
+        baseTy = strTy.getType(getIntValue(offs[i]));
+      } else if (auto strTy = baseTy.dyn_cast<M::TupleType>()) {
+        baseTy = strTy.getType(getIntValue(offs[i]));
+      } else {
+        assert(false && "unhandled type");
+      }
+    }
+    if (pos < offs.size())
+      retval = genGEP(loc, unwrap(ty), rewriter, retval,
+                      arguments(offs, pos, offs.size()));
+    rewriter.replaceOp(coor, retval);
     return matchSuccess();
   }
+
+  L::SmallVector<M::Value *, 8> arguments(L::ArrayRef<M::Value *> vec,
+                                          unsigned s, unsigned e) const {
+    return {vec.begin() + s, vec.begin() + e};
+  }
+
+  int64_t getIntValue(M::Value *val) const {
+    if (val)
+      if (auto *defop = val->getDefiningOp())
+        if (auto constOp = dyn_cast<M::ConstantIntOp>(defop))
+          return constOp.getValue();
+    assert(false && "must be a constant");
+    return 0;
+  }
 };
 
-// call free function
-struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
+/// convert a field index to a runtime function that computes the byte offset of
+/// the dynamic field
+struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::LLVM::LLVMType getVoidPtrType() const {
-    return M::LLVM::LLVMType::getInt8PtrTy(getDialect());
+  // NB: most field references should be resolved by this point
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto field = M::cast<FieldIndexOp>(op);
+    // call the compiler generated function to determine the byte offset of
+    // the field at runtime
+    auto symAttr = M::SymbolRefAttr::get(methodName(field), field.getContext());
+    L::SmallVector<M::NamedAttribute, 1> attrs{
+        rewriter.getNamedAttr("callee", symAttr)};
+    auto ty = lowering.offsetType();
+    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(field, ty, operands, attrs);
+    return matchSuccess();
   }
 
-  M::FuncOp genFreeFunc(M::Operation *op,
-                        M::ConversionPatternRewriter &rewriter) const {
-    M::FuncOp freeFunc =
-        op->getParentOfType<M::ModuleOp>().lookupSymbol<M::FuncOp>("free");
-    if (!freeFunc) {
-      auto freeType = rewriter.getFunctionType(getVoidPtrType(), {});
-      freeFunc = M::FuncOp::create(rewriter.getUnknownLoc(), "free", freeType);
-      op->getParentOfType<M::ModuleOp>().push_back(freeFunc);
+  // constructing the name of the method
+  inline static std::string methodName(FieldIndexOp field) {
+    L::Twine fldName = field.field_id();
+    // note: using std::string to dodge a bug in g++ 7.4.0
+    std::string tyName = field.on_type().cast<RecordType>().getName();
+    L::Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
+    return methodName.str();
+  }
+};
+
+struct LenParamIndexOpConversion
+    : public FIROpConversion<fir::LenParamIndexOp> {
+  using FIROpConversion::FIROpConversion;
+
+  // FIXME: this should be specialized by the runtime target
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto lenp = M::cast<LenParamIndexOp>(op);
+    auto ity = lowering.indexType();
+    auto onty = lenp.getOnType();
+    // size of portable descriptor
+    const unsigned boxsize = 24; // FIXME
+    unsigned offset = boxsize;
+    // add the size of the rows of triples
+    if (auto arr = onty.dyn_cast<SequenceType>()) {
+      offset += 3 * arr.getDimension();
     }
-    return freeFunc;
+    // advance over some addendum fields
+    const unsigned addendumOffset = sizeof(void *) + sizeof(uint64_t);
+    offset += addendumOffset;
+    // add the offset into the LENs
+    offset += 0; // FIXME
+    auto attr = rewriter.getI64IntegerAttr(offset);
+    rewriter.replaceOpWithNewOp<M::LLVM::ConstantOp>(lenp, ity, attr);
+    return matchSuccess();
   }
+};
+
+/// lower the fir.end operation to a null (erasing it)
+struct FirEndOpConversion : public FIROpConversion<FirEndOp> {
+  using FIROpConversion::FIROpConversion;
 
   M::PatternMatchResult
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
-    auto freemem = M::cast<fir::FreeMemOp>(op);
-    auto freeFunc = genFreeFunc(freemem, rewriter);
-    M::Value *casted = rewriter.create<M::LLVM::BitcastOp>(
-        freemem.getLoc(), getVoidPtrType(), operands[0]);
-    auto sym = rewriter.getSymbolRefAttr(freeFunc);
-    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(
-        freemem, llvm::ArrayRef<M::Type>(), sym, casted);
+    rewriter.replaceOp(op, {});
     return matchSuccess();
   }
 };
 
+/// lower a gendims operation into a sequence of writes to a temp
 struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -896,9 +1289,35 @@ struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto gendims = M::cast<GenDimsOp>(op);
-    TODO(gendims);
+    auto loc = gendims.getLoc();
+    auto ty = convertType(gendims.getType());
+    auto ptrTy = unwrap(ty).getPointerTo();
+    auto alloca = genAlloca(loc, ptrTy, defaultAlign, rewriter);
+    unsigned offIndex = 0;
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto ipty = lowering.indexType().getPointerTo();
+    for (auto op : operands) {
+      auto offset = genConstantOffset(loc, rewriter, offIndex);
+      auto gep = genGEP(loc, ipty, rewriter, alloca, c0, offset);
+      rewriter.create<M::LLVM::StoreOp>(loc, op, gep);
+    }
+    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(gendims, ptrTy, alloca);
     return matchSuccess();
   }
+
+  // Generate an alloca of size `size` and cast it to type `toTy`
+  M::LLVM::AllocaOp genAlloca(M::Location loc, M::LLVM::LLVMType toTy,
+                              unsigned alignment,
+                              M::ConversionPatternRewriter &rewriter) const {
+    auto thisPt = rewriter.saveInsertionPoint();
+    auto *thisBlock = rewriter.getInsertionBlock();
+    auto func = M::cast<M::LLVM::LLVMFuncOp>(thisBlock->getParentOp());
+    rewriter.setInsertionPointToStart(&func.front());
+    auto size = genConstantOffset(loc, rewriter, 1);
+    auto rv = rewriter.create<M::LLVM::AllocaOp>(loc, toTy, size, alignment);
+    rewriter.restoreInsertionPoint(thisPt);
+    return rv;
+  }
 };
 
 struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
@@ -908,7 +1327,9 @@ struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto gentypedesc = M::cast<GenTypeDescOp>(op);
-    TODO(gentypedesc);
+    auto ty = unwrap(convertType(gentypedesc.getInType())).getPointerTo();
+    std::string name = "fixme"; // FIXME: get the mangled name
+    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(gentypedesc, ty, name);
     return matchSuccess();
   }
 };
@@ -932,9 +1353,9 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto global = M::cast<fir::GlobalOp>(op);
-    auto tyAttr = M::TypeAttr::get(lowering.convertType(global.getType()));
+    auto tyAttr = M::TypeAttr::get(convertType(global.getType()));
     M::UnitAttr isConst;
-    if (global.getAttrOfType<M::BoolAttr>("constant").getValue())
+    if (global.getAttr("constant"))
       isConst = M::UnitAttr::get(global.getContext());
     auto name = M::StringAttr::get(
         global.getAttrOfType<M::StringAttr>(M::SymbolTable::getSymbolAttrName())
@@ -949,39 +1370,6 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   }
 };
 
-// InsertValue is the generalized instruction for the composition of new
-// aggregate type values.
-struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
-  using FIROpConversion::FIROpConversion;
-
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto insertVal = cast<InsertValueOp>(op);
-    TODO(insertVal);
-    // rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(insertVal, ...);
-    return matchSuccess();
-  }
-};
-
-// Compute the index of the LEN param in the descriptor addendum.  A value of
-// type field can only be used as an argument to a coordinate_of, extract_value,
-// or insert_value operation. It derives it's meaning from the context of where
-// it is used.  A LEN parameter cannot be an aggregate itself and thus a
-// LenParamIndexOp can appear only once and must be last in the argument list.
-struct LenParamIndexOpConversion
-    : public FIROpConversion<fir::LenParamIndexOp> {
-  using FIROpConversion::FIROpConversion;
-
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto lenparam = M::cast<LenParamIndexOp>(op);
-    rewriter.replaceOp(lenparam, {});
-    return matchSuccess();
-  }
-};
-
 // convert to LLVM IR dialect `load`
 struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
   using FIROpConversion::FIROpConversion;
@@ -990,7 +1378,7 @@ struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto load = M::cast<fir::LoadOp>(op);
-    auto ty = lowering.convertType(load.getType());
+    auto ty = convertType(load.getType());
     auto at = load.getAttrs();
     rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(op, ty, operands, at);
     return matchSuccess();
@@ -1010,7 +1398,7 @@ struct LoopOpConversion : public FIROpConversion<fir::LoopOp> {
   }
 };
 
-// TODO: how do we want to enforce this in LLVM-IR?
+// FIXME: how do we want to enforce this in LLVM-IR?
 struct NoReassocOpConversion : public FIROpConversion<NoReassocOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1024,6 +1412,22 @@ struct NoReassocOpConversion : public FIROpConversion<NoReassocOp> {
   }
 };
 
+void genCaseLadderStep(M::Location loc, M::Value *cmp, M::Block *dest,
+                       OperandTy destOps,
+                       M::ConversionPatternRewriter &rewriter) {
+  auto *thisBlock = rewriter.getInsertionBlock();
+  auto *newBlock = rewriter.createBlock(dest);
+  rewriter.setInsertionPointToEnd(thisBlock);
+  L::SmallVector<M::Block *, 2> dest_{dest, newBlock};
+  L::SmallVector<L::ArrayRef<M::Value *>, 2> destOps_{destOps, {}};
+  rewriter.create<M::LLVM::CondBrOp>(loc, L::ArrayRef<M::Value *>{cmp}, dest_,
+                                     destOps_);
+  rewriter.setInsertionPointToEnd(newBlock);
+}
+
+/// Conversion of `fir.select_case`
+///
+/// TODO: lowering of CHARACTER type cases
 struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1033,12 +1437,106 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
                   L::ArrayRef<OperandTy> destOperands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto selectcase = M::cast<SelectCaseOp>(op);
-    TODO(selectcase);
+    auto conds = selectcase.getNumConditions();
+    auto attrName = SelectCaseOp::AttrName;
+    auto caseAttr = selectcase.getAttrOfType<M::ArrayAttr>(attrName);
+    auto cases = caseAttr.getValue();
+    // Type can be CHARACTER, INTEGER, or LOGICAL (C1145)
+    auto ty = selectcase.getSelector()->getType();
+    (void)ty;
+    auto &selector = operands[0];
+    unsigned nextOp = 1;
+    auto loc = selectcase.getLoc();
+    assert(conds > 0 && "selectcase must have cases");
+    for (unsigned t = 0; t != conds; ++t) {
+      auto &attr = cases[t];
+      if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
+        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
+            loc, M::LLVM::ICmpPredicate::eq, selector, operands[nextOp++]);
+        genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+        continue;
+      }
+      if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
+        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
+            loc, M::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
+        genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+        continue;
+      }
+      if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
+        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
+            loc, M::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
+        genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+        continue;
+      }
+      if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
+            loc, M::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
+        auto *thisBlock = rewriter.getInsertionBlock();
+        auto *newBlock1 = rewriter.createBlock(destinations[t]);
+        auto *newBlock2 = rewriter.createBlock(destinations[t]);
+        rewriter.setInsertionPointToEnd(thisBlock);
+        L::SmallVector<M::Block *, 2> dests{newBlock1, newBlock2};
+        L::SmallVector<L::ArrayRef<M::Value *>, 2> destOps{{}, {}};
+        rewriter.create<M::LLVM::CondBrOp>(loc, L::ArrayRef<M::Value *>{cmp},
+                                           dests, destOps);
+        rewriter.setInsertionPointToEnd(newBlock1);
+        auto cmp2 = rewriter.create<M::LLVM::ICmpOp>(
+            loc, M::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
+        L::SmallVector<M::Block *, 2> dest2{destinations[t], newBlock2};
+        L::SmallVector<L::ArrayRef<M::Value *>, 2> destOp2{destOperands[t], {}};
+        rewriter.create<M::LLVM::CondBrOp>(loc, L::ArrayRef<M::Value *>{cmp2},
+                                           dest2, destOp2);
+        rewriter.setInsertionPointToEnd(newBlock2);
+        continue;
+      }
+      assert(attr.dyn_cast_or_null<M::UnitAttr>());
+      assert((t + 1 == conds) && "unit must be last");
+      L::SmallVector<M::Value *, 1> empty;
+      rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(
+          selectcase, empty, destinations[t], destOperands[t]);
+    }
     return matchSuccess();
   }
 };
 
-// conversion of fir::SelectOp
+template <typename OP>
+void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, M::Operation *op,
+                           OperandTy operands,
+                           L::ArrayRef<M::Block *> destinations,
+                           L::ArrayRef<OperandTy> destOperands,
+                           M::ConversionPatternRewriter &rewriter) {
+  auto select = M::cast<OP>(op);
+
+  // We could target the LLVM switch instruction, but it isn't part of the
+  // LLVM IR dialect.  Create an if-then-else ladder instead.
+  auto conds = select.getNumConditions();
+  auto attrName = OP::AttrName;
+  auto caseAttr = select.template getAttrOfType<M::ArrayAttr>(attrName);
+  auto cases = caseAttr.getValue();
+  auto ty = select.getSelector()->getType();
+  auto ity = lowering.convertType(ty);
+  auto &selector = operands[0];
+  auto loc = select.getLoc();
+  assert(conds > 0 && "select must have cases");
+  for (unsigned t = 0; t != conds; ++t) {
+    auto &attr = cases[t];
+    if (auto intAttr = attr.template dyn_cast_or_null<M::IntegerAttr>()) {
+      auto ci = rewriter.create<M::LLVM::ConstantOp>(
+          loc, ity, rewriter.getIntegerAttr(ty, intAttr.getInt()));
+      auto cmp = rewriter.create<M::LLVM::ICmpOp>(
+          loc, M::LLVM::ICmpPredicate::eq, selector, ci);
+      genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+      continue;
+    }
+    assert(attr.template dyn_cast_or_null<M::UnitAttr>());
+    assert((t + 1 == conds) && "unit must be last");
+    L::SmallVector<M::Value *, 1> empty;
+    rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(select, empty, destinations[t],
+                                               destOperands[t]);
+  }
+}
+
+/// conversion of fir::SelectOp to an if-then-else ladder
 struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1047,12 +1545,13 @@ struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
                   L::ArrayRef<M::Block *> destinations,
                   L::ArrayRef<OperandTy> destOperands,
                   M::ConversionPatternRewriter &rewriter) const override {
-    auto select = M::cast<fir::SelectOp>(op);
-    TODO(select);
+    selectMatchAndRewrite<fir::SelectOp>(lowering, op, operands, destinations,
+                                         destOperands, rewriter);
     return matchSuccess();
   }
 };
 
+/// conversion of fir::SelectRankOp to an if-then-else ladder
 struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1061,8 +1560,8 @@ struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
                   L::ArrayRef<M::Block *> destinations,
                   L::ArrayRef<OperandTy> destOperands,
                   M::ConversionPatternRewriter &rewriter) const override {
-    auto selectrank = M::cast<SelectRankOp>(op);
-    TODO(selectrank);
+    selectMatchAndRewrite<fir::SelectRankOp>(
+        lowering, op, operands, destinations, destOperands, rewriter);
     return matchSuccess();
   }
 };
@@ -1076,7 +1575,7 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
                   L::ArrayRef<M::Block *> destinations,
                   L::ArrayRef<OperandTy> destOperands,
                   M::ConversionPatternRewriter &rewriter) const override {
-    auto selecttype = M::cast<SelectRankOp>(op);
+    auto selecttype = M::cast<SelectTypeOp>(op);
     TODO(selecttype);
     return matchSuccess();
   }
@@ -1146,8 +1645,8 @@ struct UndefOpConversion : public FIROpConversion<UndefOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto undef = M::cast<UndefOp>(op);
-    rewriter.replaceOpWithNewOp<M::LLVM::UndefOp>(
-        undef, lowering.convertType(undef.getType()));
+    rewriter.replaceOpWithNewOp<M::LLVM::UndefOp>(undef,
+                                                  convertType(undef.getType()));
     return matchSuccess();
   }
 };
@@ -1181,29 +1680,11 @@ struct WhereOpConversion : public FIROpConversion<fir::WhereOp> {
   }
 };
 
-// Generate code for complex addition/subtraction
-template <typename LLVMOP, typename OPTY>
-M::LLVM::InsertValueOp complexSum(OPTY sumop, OperandTy opnds,
-                                  M::ConversionPatternRewriter &rewriter,
-                                  FIRToLLVMTypeConverter &lowering) {
-  auto a = opnds[0];
-  auto b = opnds[1];
-  auto loc = sumop.getLoc();
-  auto ctx = sumop.getContext();
-  auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
-  auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
-  auto ty = lowering.convertType(sumop.getType());
-  auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
-  auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
-  auto rx = rewriter.create<LLVMOP>(loc, ty, x, x_);
-  auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
-  auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
-  auto ry = rewriter.create<LLVMOP>(loc, ty, y, y_);
-  auto r = rewriter.create<M::LLVM::UndefOp>(loc, ty);
-  auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r, rx, c0);
-  return rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ry, c1);
-}
+//
+// Primitive operations on Real (floating-point) types
+//
 
+/// Convert a floating-point primitive
 template <typename BINOP, typename LLVMOP>
 void lowerRealBinaryOp(M::Operation *op, OperandTy operands,
                        M::ConversionPatternRewriter &rewriter,
@@ -1269,6 +1750,46 @@ struct ModfOpConversion : public FIROpConversion<fir::ModfOp> {
   }
 };
 
+struct NegfOpConversion : public FIROpConversion<fir::NegfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto neg = M::cast<fir::NegfOp>(op);
+    auto ty = convertType(neg.getType());
+    rewriter.replaceOpWithNewOp<M::LLVM::FNegOp>(neg, ty, operands);
+    return matchSuccess();
+  }
+};
+
+//
+// Primitive operations on Complex types
+//
+
+/// Generate code for complex addition/subtraction
+template <typename LLVMOP, typename OPTY>
+M::LLVM::InsertValueOp complexSum(OPTY sumop, OperandTy opnds,
+                                  M::ConversionPatternRewriter &rewriter,
+                                  FIRToLLVMTypeConverter &lowering) {
+  auto a = opnds[0];
+  auto b = opnds[1];
+  auto loc = sumop.getLoc();
+  auto ctx = sumop.getContext();
+  auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+  auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+  auto ty = lowering.convertType(sumop.getType());
+  auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
+  auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
+  auto rx = rewriter.create<LLVMOP>(loc, ty, x, x_);
+  auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
+  auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
+  auto ry = rewriter.create<LLVMOP>(loc, ty, y, y_);
+  auto r = rewriter.create<M::LLVM::UndefOp>(loc, ty);
+  auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r, rx, c0);
+  return rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ry, c1);
+}
+
 struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1299,6 +1820,7 @@ struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
   }
 };
 
+/// Inlined complex multiply
 struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1306,7 +1828,7 @@ struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto mulc = M::cast<fir::MulcOp>(op);
-    // TODO: should this just call __muldc3 ?
+    // FIXME: should this just call __muldc3 ?
     // result: (xx'-yy')+i(xy'+yx')
     auto a = operands[0];
     auto b = operands[1];
@@ -1314,7 +1836,7 @@ struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
     auto ctx = mulc.getContext();
     auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
     auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
-    auto ty = lowering.convertType(mulc.getType());
+    auto ty = convertType(mulc.getType());
     auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
     auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
     auto xx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, x_);
@@ -1334,6 +1856,7 @@ struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
   }
 };
 
+/// Inlined complex division
 struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1341,7 +1864,7 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto divc = M::cast<fir::DivcOp>(op);
-    // TODO: should this just call __divdc3 ?
+    // FIXME: should this just call __divdc3 ?
     // result: ((xx'+yy')/d) + i((yx'-xy')/d) where d = x'x' + y'y'
     auto a = operands[0];
     auto b = operands[1];
@@ -1349,7 +1872,7 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
     auto ctx = divc.getContext();
     auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
     auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
-    auto ty = lowering.convertType(divc.getType());
+    auto ty = convertType(divc.getType());
     auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
     auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
     auto xx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, x_);
@@ -1374,41 +1897,40 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   }
 };
 
+struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto neg = M::cast<fir::NegcOp>(op);
+    auto ctxt = neg.getContext();
+    auto ty = convertType(neg.getType());
+    auto loc = neg.getLoc();
+    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
+    auto &o0 = operands[0];
+    auto rp = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, o0, c0);
+    auto nrp = rewriter.create<M::LLVM::FNegOp>(loc, ty, rp);
+    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
+    auto ip = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, o0, c1);
+    auto nip = rewriter.create<M::LLVM::FNegOp>(loc, ty, ip);
+    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, o0, nrp, c0);
+    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(neg, ty, r, nip, c1);
+    return matchSuccess();
+  }
+};
+
 // Lower a SELECT operation into a cascade of conditional branches. The last
 // case must be the `true` condition.
-inline void rewriteSelectConstruct(M::Operation *op, OperandTy operands,
-                                   L::ArrayRef<M::Block *> dests,
-                                   L::ArrayRef<OperandTy> destOperands,
-                                   M::OpBuilder &rewriter) {
-  L::SmallVector<M::Value *, 1> noargs;
-  L::SmallVector<M::Block *, 8> blocks;
-  auto loc{op->getLoc()};
-  blocks.push_back(rewriter.getInsertionBlock());
-  for (std::size_t i = 1; i < dests.size(); ++i)
-    blocks.push_back(rewriter.createBlock(dests[0]));
-  rewriter.setInsertionPointToEnd(blocks[0]);
-  if (dests.size() == 1) {
-    rewriter.create<M::BranchOp>(loc, dests[0], destOperands[0]);
-    return;
-  }
-  rewriter.create<M::CondBranchOp>(loc, operands[1], dests[0], destOperands[0],
-                                   blocks[1], noargs);
-  for (std::size_t i = 1; i < dests.size() - 1; ++i) {
-    rewriter.setInsertionPointToEnd(blocks[i]);
-    rewriter.create<M::CondBranchOp>(loc, operands[i + 1], dests[i],
-                                     destOperands[i], blocks[i + 1], noargs);
-  }
-  std::size_t last{dests.size() - 1};
-  rewriter.setInsertionPointToEnd(blocks[last]);
-  rewriter.create<M::BranchOp>(loc, dests[last], destOperands[last]);
-}
-
 /// Convert FIR dialect to LLVM dialect
 ///
 /// This pass lowers all FIR dialect operations to LLVM IR dialect.  An
 /// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
 struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
   void runOnModule() override {
+    if (ClDisableFirToLLVMIR)
+      return;
+
     auto &context{getContext()};
     FIRToLLVMTypeConverter typeConverter{&context};
     M::OwningRewritePatternList patterns;
@@ -1418,29 +1940,30 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
         BoxCharLenOpConversion, BoxDimsOpConversion, BoxEleSizeOpConversion,
         BoxIsAllocOpConversion, BoxIsArrayOpConversion, BoxIsPtrOpConversion,
         BoxProcHostOpConversion, BoxRankOpConversion, BoxTypeDescOpConversion,
-        CallOpConversion, ConvertOpConversion, CoordinateOpConversion,
+        CallOpConversion, CmpcOpConversion, CmpfOpConversion,
+        ConstantOpConversion, ConvertOpConversion, CoordinateOpConversion,
         DispatchOpConversion, DispatchTableOpConversion, DivcOpConversion,
         DivfOpConversion, DTEntryOpConversion, EmboxCharOpConversion,
-        EmboxOpConversion, EmboxProcOpConversion, FirEndOpConversion,
-        ExtractValueOpConversion, FieldIndexOpConversion, FreeMemOpConversion,
+        EmboxOpConversion, EmboxProcOpConversion, FieldIndexOpConversion,
+        FirEndOpConversion, ExtractValueOpConversion, FreeMemOpConversion,
         GenDimsOpConversion, GenTypeDescOpConversion, GlobalEntryOpConversion,
         GlobalOpConversion, InsertValueOpConversion, LenParamIndexOpConversion,
         LoadOpConversion, LoopOpConversion, ModfOpConversion, MulcOpConversion,
-        MulfOpConversion, NoReassocOpConversion, SelectCaseOpConversion,
-        SelectOpConversion, SelectRankOpConversion, SelectTypeOpConversion,
-        StoreOpConversion, SubcOpConversion, SubfOpConversion,
-        UnboxCharOpConversion, UnboxOpConversion, UnboxProcOpConversion,
-        UndefOpConversion, UnreachableOpConversion, WhereOpConversion>(
-        &context, typeConverter);
+        MulfOpConversion, NegcOpConversion, NegfOpConversion,
+        NoReassocOpConversion, SelectCaseOpConversion, SelectOpConversion,
+        SelectRankOpConversion, SelectTypeOpConversion, StoreOpConversion,
+        SubcOpConversion, SubfOpConversion, UnboxCharOpConversion,
+        UnboxOpConversion, UnboxProcOpConversion, UndefOpConversion,
+        UnreachableOpConversion, WhereOpConversion>(&context, typeConverter);
     M::populateStdToLLVMConversionPatterns(typeConverter, patterns);
     M::ConversionTarget target{context};
     target.addLegalDialect<M::LLVM::LLVMDialect>();
 
     // required NOP stubs for applying a full conversion
     target.addDynamicallyLegalOp<M::ModuleOp>(
-        [&](M::ModuleOp op) { return true; });
+        [&](M::ModuleOp) { return true; });
     target.addDynamicallyLegalOp<M::ModuleTerminatorOp>(
-        [&](M::ModuleTerminatorOp op) { return true; });
+        [&](M::ModuleTerminatorOp) { return true; });
 
     // apply the patterns
     if (M::failed(M::applyFullConversion(
@@ -1455,16 +1978,32 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
 struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
   void runOnModule() override {
+    if (ClDisableLLVM)
+      return;
+
+    genDispatchTableMap();
+
     if (auto llvmModule{M::translateModuleToLLVMIR(getModule())}) {
       std::error_code ec;
-      L::raw_fd_ostream stream("a.ll", ec, L::sys::fs::F_None);
+      L::raw_fd_ostream stream(outputName, ec, L::sys::fs::F_None);
       stream << *llvmModule << '\n';
-    } else {
-      auto ctxt{getModule().getContext()};
-      M::emitError(M::UnknownLoc::get(ctxt), "could not emit LLVM-IR\n");
-      signalPassFailure();
+      L::errs() << outputName << " written\n";
+      return;
     }
+
+    auto ctxt{getModule().getContext()};
+    M::emitError(M::UnknownLoc::get(ctxt), "could not emit LLVM-IR\n");
+    signalPassFailure();
   }
+
+  void setOutputName(L::StringRef output) { outputName = output; }
+
+private:
+  void genDispatchTableMap() {
+    // TODO
+  }
+
+  L::StringRef outputName;
 };
 
 } // namespace
@@ -1473,6 +2012,8 @@ std::unique_ptr<M::Pass> fir::createFIRToLLVMPass() {
   return std::make_unique<FIRToLLVMLoweringPass>();
 }
 
-std::unique_ptr<M::Pass> fir::createLLVMDialectToLLVMPass() {
-  return std::make_unique<LLVMIRLoweringPass>();
+std::unique_ptr<M::Pass> fir::createLLVMDialectToLLVMPass(L::StringRef output) {
+  auto pass = std::make_unique<LLVMIRLoweringPass>();
+  pass->setOutputName(output);
+  return pass;
 }
diff --git a/lib/fir/Transforms/CSE.cpp b/lib/fir/Transforms/CSE.cpp
index 3092f6a61eca..2e765dfedb46 100644
--- a/lib/fir/Transforms/CSE.cpp
+++ b/lib/fir/Transforms/CSE.cpp
@@ -44,6 +44,10 @@ static llvm::cl::opt<bool>
     ClLeaveEffects("keep-effects",
                    llvm::cl::desc("disable cleaning up effects attributes"),
                    llvm::cl::init(false), llvm::cl::Hidden);
+static llvm::cl::opt<bool> ClDisableCSE("disable-cse",
+                                        llvm::cl::desc("disable CSE pass"),
+                                        llvm::cl::init(false),
+                                        llvm::cl::Hidden);
 
 namespace {
 
@@ -146,7 +150,7 @@ struct BasicCSE : public FunctionPass<BasicCSE> {
 
   void cleanupBlock(Block *bb) {
     for (auto &inst : *bb) {
-      if (fir::nonVolatileLoad(&inst)) {
+      if (fir::nonVolatileLoad(&inst) || fir::pureCall(&inst)) {
         inst.removeAttr(Identifier::get("effects_token", inst.getContext()));
       } else if (inst.getNumRegions()) {
         for (auto &region : inst.getRegions())
@@ -175,7 +179,7 @@ LogicalResult BasicCSE::simplifyOperation(ScopedMapTy &knownValues,
   if (op->getNumRegions() != 0)
     return failure();
 
-  if (!op->hasNoSideEffect() && !fir::nonVolatileLoad(op))
+  if (!op->hasNoSideEffect() && !fir::nonVolatileLoad(op) && !fir::pureCall(op))
     return failure();
 
   // If the operation is already trivially dead just add it to the erase list.
@@ -210,7 +214,7 @@ void BasicCSE::simplifyBlock(ScopedMapTy &knownValues, DominanceInfo &domInfo,
                              Block *bb) {
   std::intptr_t token = reinterpret_cast<std::intptr_t>(bb);
   for (auto &inst : *bb) {
-    if (fir::nonVolatileLoad(&inst))
+    if (fir::nonVolatileLoad(&inst) || fir::pureCall(&inst))
       inst.setAttr("effects_token",
                    IntegerAttr::get(IndexType::get(inst.getContext()), token));
     if (dyn_cast<fir::StoreOp>(&inst) || fir::impureCall(&inst))
@@ -285,6 +289,9 @@ void BasicCSE::simplifyRegion(ScopedMapTy &knownValues, DominanceInfo &domInfo,
 }
 
 void BasicCSE::runOnFunction() {
+  if (ClDisableCSE)
+    return;
+
   /// A scoped hash table of defining operations within a function.
   {
     ScopedMapTy knownValues;
diff --git a/lib/fir/Transforms/MemToReg.cpp b/lib/fir/Transforms/MemToReg.cpp
index 2104f8ddf97c..f94198fd7674 100644
--- a/lib/fir/Transforms/MemToReg.cpp
+++ b/lib/fir/Transforms/MemToReg.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "fir/Analysis/IteratedDominanceFrontier.h"
-#include "fir/Dialect.h"
+#include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
 #include "fir/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
@@ -18,12 +18,18 @@
 #include <utility>
 #include <vector>
 
+namespace L = llvm;
 namespace M = mlir;
 
 using namespace fir;
 
 using DominatorTree = M::DominanceInfo;
 
+static L::cl::opt<bool>
+    ClDisableMemToReg("disable-mem2reg",
+                      L::cl::desc("disable memory to register pass"),
+                      L::cl::init(false), L::cl::Hidden);
+
 /// A generalized version of a mem-to-reg pass suitable for use with an MLIR
 /// dialect. This code was ported from the LLVM project. MLIR differs with its
 /// use of block arguments rather than PHI nodes, etc.
@@ -49,8 +55,8 @@ bool isAllocaPromotable(ALLOCA &ae) {
 
 template <typename LOAD, typename STORE, typename ALLOCA>
 struct AllocaInfo {
-  llvm::SmallVector<M::Block *, 32> definingBlocks;
-  llvm::SmallVector<M::Block *, 32> usingBlocks;
+  L::SmallVector<M::Block *, 32> definingBlocks;
+  L::SmallVector<M::Block *, 32> usingBlocks;
 
   M::Operation *onlyStore;
   M::Block *onlyBlock;
@@ -103,9 +109,10 @@ struct RenamePassData {
 
   RenamePassData(M::Block *b, M::Block *p, const ValVector &v)
       : BB(b), Pred(p), Values(v) {}
+  RenamePassData(RenamePassData &&) = default;
+  RenamePassData &operator=(RenamePassData &&) = delete;
   RenamePassData(const RenamePassData &) = delete;
   RenamePassData &operator=(const RenamePassData &) = delete;
-  RenamePassData(RenamePassData &&) = default;
   ~RenamePassData() = default;
 
   M::Block *BB;
@@ -115,7 +122,7 @@ struct RenamePassData {
 
 template <typename LOAD, typename STORE, typename ALLOCA>
 struct LargeBlockInfo {
-  using INMap = llvm::DenseMap<M::Operation *, unsigned>;
+  using INMap = L::DenseMap<M::Operation *, unsigned>;
   INMap instNumbers;
 
   static bool isInterestingInstruction(M::Operation &I) {
@@ -169,16 +176,16 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
   /// Contains a stable numbering of basic blocks to avoid non-determinstic
   /// behavior.
-  llvm::DenseMap<M::Block *, unsigned> BBNumbers;
+  L::DenseMap<M::Block *, unsigned> BBNumbers;
 
   /// Reverse mapping of Allocas.
-  llvm::DenseMap<M::Operation *, unsigned> allocaLookup;
+  L::DenseMap<M::Operation *, unsigned> allocaLookup;
 
   /// The set of basic blocks the renamer has already visited.
-  llvm::SmallPtrSet<M::Block *, 16> Visited;
+  L::SmallPtrSet<M::Block *, 16> Visited;
 
-  llvm::DenseMap<std::pair<M::Block *, M::Operation *>, unsigned> BlockArgs;
-  llvm::DenseMap<std::pair<M::Block *, unsigned>, unsigned> argToAllocaMap;
+  L::DenseMap<std::pair<M::Block *, M::Operation *>, unsigned> BlockArgs;
+  L::DenseMap<std::pair<M::Block *, unsigned>, unsigned> argToAllocaMap;
 
   bool rewriteSingleStoreAlloca(ALLOCA &AI,
                                 AllocaInfo<LOAD, STORE, ALLOCA> &Info,
@@ -225,13 +232,13 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       }
 
       // Otherwise, we *can* safely rewrite this load.
-      M::Value *ReplVal = onlyStore.getOperand(0);
+      M::Value *replVal = onlyStore.getOperand(0);
       // If the replacement value is the load, this must occur in unreachable
       // code.
-      if (ReplVal == LI.getResult())
-        ReplVal = builder->create<UNDEF>(LI.getLoc(), LI.getType());
+      if (replVal == LI.getResult())
+        replVal = builder->create<UNDEF>(LI.getLoc(), LI.getType());
 
-      LI.replaceAllUsesWith(ReplVal);
+      LI.replaceAllUsesWith(replVal);
       LI.erase();
       LBI.deleteValue(LI);
     }
@@ -251,17 +258,19 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
                                 AllocaInfo<LOAD, STORE, ALLOCA> &Info,
                                 LargeBlockInfo<LOAD, STORE, ALLOCA> &LBI) {
     // Walk the use-def list of the alloca, getting the locations of all stores.
-    using StoresByIndexTy = llvm::SmallVector<std::pair<unsigned, STORE *>, 64>;
-    StoresByIndexTy StoresByIndex;
+    using StoresByIndexTy =
+        L::SmallVector<std::pair<unsigned, M::Operation *>, 64>;
+    StoresByIndexTy storesByIndex;
 
     for (auto U = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
          U != E; U++)
       if (STORE SI = M::dyn_cast<STORE>(U->getOwner()))
-        StoresByIndex.emplace_back(LBI.getInstructionIndex(SI), &SI);
+        storesByIndex.emplace_back(LBI.getInstructionIndex(SI),
+                                   SI.getOperation());
 
     // Sort the stores by their index, making it efficient to do a lookup with a
     // binary search.
-    llvm::sort(StoresByIndex, llvm::less_first());
+    L::sort(storesByIndex, L::less_first());
 
     // Walk all of the loads from this alloca, replacing them with the nearest
     // store above them, if any.
@@ -275,11 +284,12 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       unsigned LoadIdx = LBI.getInstructionIndex(LI);
 
       // Find the nearest store that has a lower index than this load.
-      typename StoresByIndexTy::iterator I = llvm::lower_bound(
-          StoresByIndex, std::make_pair(LoadIdx, static_cast<STORE *>(nullptr)),
-          llvm::less_first());
-      if (I == StoresByIndex.begin()) {
-        if (StoresByIndex.empty()) {
+      typename StoresByIndexTy::iterator I = L::lower_bound(
+          storesByIndex,
+          std::make_pair(LoadIdx, static_cast<M::Operation *>(nullptr)),
+          L::less_first());
+      if (I == storesByIndex.begin()) {
+        if (storesByIndex.empty()) {
           // If there are no stores, the load takes the undef value.
           auto undef = builder->create<UNDEF>(LI.getLoc(), LI.getType());
           LI.replaceAllUsesWith(undef.getResult());
@@ -292,14 +302,14 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         // Otherwise, there was a store before this load, the load takes its
         // value. Note, if the load was marked as nonnull we don't want to lose
         // that information when we erase it. So we preserve it with an assume.
-        M::Value *ReplVal = std::prev(I)->second->getOperand(0);
+        M::Value *replVal = std::prev(I)->second->getOperand(0);
 
         // If the replacement value is the load, this must occur in unreachable
         // code.
-        if (ReplVal == LI)
-          ReplVal = builder->create<UNDEF>(LI.getLoc(), LI.getType());
+        if (replVal == LI)
+          replVal = builder->create<UNDEF>(LI.getLoc(), LI.getType());
 
-        LI.replaceAllUsesWith(ReplVal);
+        LI.replaceAllUsesWith(replVal);
       }
 
       LI.erase();
@@ -310,9 +320,9 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     while (!AI.use_empty()) {
       auto *ae = AI.getResult();
       for (auto ai = ae->user_begin(), E = ae->user_end(); ai != E; ai++)
-        if (STORE SI = M::dyn_cast<STORE>(*ai)) {
-          SI.erase();
-          LBI.deleteValue(SI);
+        if (STORE si = M::dyn_cast<STORE>(*ai)) {
+          si.erase();
+          LBI.deleteValue(si);
         }
     }
 
@@ -321,14 +331,14 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
   }
 
   void computeLiveInBlocks(ALLOCA &ae, AllocaInfo<LOAD, STORE, ALLOCA> &Info,
-                           const llvm::SmallPtrSetImpl<M::Block *> &DefBlocks,
-                           llvm::SmallPtrSetImpl<M::Block *> &liveInBlks) {
+                           const L::SmallPtrSetImpl<M::Block *> &DefBlocks,
+                           L::SmallPtrSetImpl<M::Block *> &liveInBlks) {
     auto *AI = ae.getOperation();
     // To determine liveness, we must iterate through the predecessors of blocks
     // where the def is live.  Blocks are added to the worklist if we need to
     // check their predecessors.  Start with all the using blocks.
-    llvm::SmallVector<M::Block *, 64> LiveInBlockWorklist(
-        Info.usingBlocks.begin(), Info.usingBlocks.end());
+    L::SmallVector<M::Block *, 64> LiveInBlockWorklist(Info.usingBlocks.begin(),
+                                                       Info.usingBlocks.end());
 
     // If any of the using blocks is also a definition block, check to see if
     // the definition occurs before or after the use.  If it happens before the
@@ -535,39 +545,34 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         if (!srcOpn)
           continue;
 
-        auto Src = M::dyn_cast<ALLOCA>(srcOpn);
-        if (!Src)
+        if (!M::dyn_cast<ALLOCA>(srcOpn))
           continue;
 
-        llvm::DenseMap<M::Operation *, unsigned>::iterator AI =
+        L::DenseMap<M::Operation *, unsigned>::iterator ai =
             allocaLookup.find(srcOpn);
-        if (AI == allocaLookup.end())
+        if (ai == allocaLookup.end())
           continue;
 
-        M::Value *V = IncomingVals[AI->second];
-
         // Anything using the load now uses the current value.
-        LI.replaceAllUsesWith(V);
+        LI.replaceAllUsesWith(IncomingVals[ai->second]);
         LI.erase();
       } else if (auto SI = M::dyn_cast<STORE>(opn)) {
         auto *dstOpn = SI.getOperand(1)->getDefiningOp();
         if (!dstOpn)
           continue;
 
-        // Delete this instruction and mark the name as the current holder of
-        // the value
-        auto Dest = M::dyn_cast<ALLOCA>(dstOpn);
-        if (!Dest)
+        if (!M::dyn_cast<ALLOCA>(dstOpn))
           continue;
 
-        llvm::DenseMap<M::Operation *, unsigned>::iterator ai =
+        L::DenseMap<M::Operation *, unsigned>::iterator ai =
             allocaLookup.find(dstOpn);
         if (ai == allocaLookup.end())
           continue;
 
-        // what value were we writing?
-        unsigned AllocaNo = ai->second;
-        addValue(IncomingVals, AllocaNo, SI.getOperand(0));
+        // Delete this instruction and mark the name as the current holder of
+        // the value
+        unsigned allocaNo = ai->second;
+        addValue(IncomingVals, allocaNo, SI.getOperand(0));
         SI.erase();
       }
     }
@@ -579,7 +584,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       return;
 
     // Keep track of the successors so we don't visit the same successor twice
-    llvm::SmallPtrSet<M::Block *, 8> VisitedSuccs;
+    L::SmallPtrSet<M::Block *, 8> VisitedSuccs;
 
     // Handle the first successor without using the worklist.
     VisitedSuccs.insert(*I);
@@ -622,9 +627,9 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       // If we haven't computed a numbering for the BB's in the function, do
       // so now.
       if (BBNumbers.empty()) {
-        unsigned ID = 0;
+        unsigned id = 0;
         for (auto &BB : F)
-          BBNumbers[&BB] = ID++;
+          BBNumbers[&BB] = id++;
       }
 
       // Keep the reverse mapping of the 'Allocas' array for the rename pass.
@@ -636,27 +641,27 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       // insertion of dead phi nodes.
 
       // Unique the set of defining blocks for efficient lookup.
-      llvm::SmallPtrSet<M::Block *, 32> DefBlocks(info.definingBlocks.begin(),
-                                                  info.definingBlocks.end());
+      L::SmallPtrSet<M::Block *, 32> defBlocks(info.definingBlocks.begin(),
+                                               info.definingBlocks.end());
 
       // Determine which blocks the value is live in.  These are blocks which
       // lead to uses.
-      llvm::SmallPtrSet<M::Block *, 32> liveInBlks;
-      computeLiveInBlocks(ae, info, DefBlocks, liveInBlks);
+      L::SmallPtrSet<M::Block *, 32> liveInBlks;
+      computeLiveInBlocks(ae, info, defBlocks, liveInBlks);
 
       // At this point, we're committed to promoting the alloca using IDF's,
       // and the standard SSA construction algorithm.  Determine which blocks
       // need phi nodes and see if we can optimize out some work by avoiding
       // insertion of dead phi nodes.
       IDF.setLiveInBlocks(liveInBlks);
-      IDF.setDefiningBlocks(DefBlocks);
-      llvm::SmallVector<M::Block *, 32> PHIBlocks;
-      IDF.calculate(PHIBlocks);
-      llvm::sort(PHIBlocks, [this](M::Block *A, M::Block *B) {
+      IDF.setDefiningBlocks(defBlocks);
+      L::SmallVector<M::Block *, 32> phiBlocks;
+      IDF.calculate(phiBlocks);
+      L::sort(phiBlocks, [this](M::Block *A, M::Block *B) {
         return BBNumbers.find(A)->second < BBNumbers.find(B)->second;
       });
 
-      for (M::Block *BB : PHIBlocks)
+      for (M::Block *BB : phiBlocks)
         addBlockArgument(BB, ae, allocaNum);
 
       aes.push_back(ae);
@@ -671,20 +676,20 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     // Set the incoming values for the basic block to be null values for all
     // of the alloca's.  We do this in case there is a load of a value that
     // has not been stored yet.  In this case, it will get this null value.
-    RenamePassData::ValVector Values(allocas.size());
+    RenamePassData::ValVector values(allocas.size());
     for (unsigned i = 0, e = allocas.size(); i != e; ++i)
-      Values[i] = builder->create<UNDEF>(allocas[i].getLoc(),
+      values[i] = builder->create<UNDEF>(allocas[i].getLoc(),
                                          allocas[i].getAllocatedType());
 
     // Walks all basic blocks in the function performing the SSA rename
     // algorithm and inserting the phi nodes we marked as necessary
     std::vector<RenamePassData> renameWorklist;
-    renameWorklist.emplace_back(&F.front(), nullptr, Values);
+    renameWorklist.emplace_back(&F.front(), nullptr, values);
     do {
-      RenamePassData RPD(std::move(renameWorklist.back()));
+      RenamePassData rpd(std::move(renameWorklist.back()));
       renameWorklist.pop_back();
       // renamePass may add new worklist entries.
-      renamePass(RPD.BB, RPD.Pred, RPD.Values, renameWorklist);
+      renamePass(rpd.BB, rpd.Pred, rpd.Values, renameWorklist);
     } while (!renameWorklist.empty());
 
     // The renamer uses the Visited set to avoid infinite loops.  Clear it
@@ -707,6 +712,9 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
   /// run the MemToReg pass on the FIR dialect
   void runOnFunction() override {
+    if (ClDisableMemToReg)
+      return;
+
     auto f = this->getFunction();
     auto &entry = f.front();
     auto bldr = M::OpBuilder(f.getBody());
diff --git a/test/fir/aggregate.fir b/test/fir/aggregate.fir
new file mode 100644
index 000000000000..c306ec117230
--- /dev/null
+++ b/test/fir/aggregate.fir
@@ -0,0 +1,11 @@
+func @f_tuple(%a : tuple<i32, i64>) -> i64 {
+  %0 = constant 1 : i32
+  %1 = fir.extract_value %a, %0 : (tuple<i32, i64>, i32) -> i64
+  return %1 : i64
+}
+
+func @f_record(%a : !fir.type<rec1{fa:i32, fb:i64}>) -> i64 {
+  %0 = fir.field_index("fb")
+  %1 = fir.extract_value %a, %0 : (!fir.type<rec1{fa:i32, fb:i64}>, !fir.field) -> i64
+  return %1 : i64
+}
diff --git a/test/fir/alloc.fir b/test/fir/alloc.fir
new file mode 100644
index 000000000000..a1081c123a44
--- /dev/null
+++ b/test/fir/alloc.fir
@@ -0,0 +1,21 @@
+func @f1() -> !fir.ref<i32> {
+  %1 = fir.alloca i32 : !fir.ref<i32>
+  return %1 : !fir.ref<i32>
+}
+
+func @f2() -> !fir.ref<i32> {
+  %0 = constant 100 : index
+  %1 = fir.alloca i32, %0 : !fir.ref<i32>
+  return %1 : !fir.ref<i32>
+}
+
+func @f3() -> !fir.heap<i32> {
+  %1 = fir.allocmem i32 : !fir.heap<i32>
+  return %1 : !fir.heap<i32>
+}
+
+func @f4() -> !fir.heap<i32> {
+  %0 = constant 100 : index
+  %1 = fir.allocmem i32, %0 : !fir.heap<i32>
+  return %1 : !fir.heap<i32>
+}
diff --git a/test/fir/bugs/bug0001.fir b/test/fir/bugs/bug0001.fir
new file mode 100644
index 000000000000..5535adb6d0e3
--- /dev/null
+++ b/test/fir/bugs/bug0001.fir
@@ -0,0 +1,41 @@
+func @r_incr(%arg0: !fir.ref<f64>) -> f64 {
+    %0 = fir.alloca f64 {name = "r_incr"} : !fir.ref<f64>
+    %1 = fir.load %arg0 : !fir.ref<f64>
+    fir.store %1 to %0 : !fir.ref<f64>
+    %2 = fir.load %arg0 : !fir.ref<f64>
+    %cst = constant 1.000000e+00 : f64
+    %3 = fir.addf %2, %cst : f64
+    fir.store %3 to %arg0 : !fir.ref<f64>
+    %4 = fir.load %0 : !fir.ref<f64>
+    return %4 : f64
+}
+
+func @_MAIN() {
+    %0 = fir.alloca f64 {name = "y"} : !fir.ref<f64>
+    %1 = fir.alloca f64 {name = "y2"} : !fir.ref<f64>
+    %2 = fir.alloca f64 {name = "y1"} : !fir.ref<f64>
+    %3 = fir.alloca f64 {name = "x"} : !fir.ref<f64>
+    %cst = constant 1.000000e+00 : f64
+    fir.store %cst to %3 : !fir.ref<f64>
+    %4 = fir.load %3 : !fir.ref<f64>
+    fir.store %4 to %2 : !fir.ref<f64>
+    %5 = fir.load %2 : !fir.ref<f64>
+    %6 = call @r_incr(%3) : (!fir.ref<f64>) -> f64
+    %7 = fir.addf %5, %6 : f64
+    fir.store %7 to %1 : !fir.ref<f64>
+    %8 = fir.load %1 : !fir.ref<f64>
+    %9 = fir.load %3 : !fir.ref<f64>
+    %10 = fir.addf %8, %9 : f64
+    fir.store %10 to %0 : !fir.ref<f64>
+    %c1_i32 = constant 1 : i32
+    %11 = call @__F18IOa_BeginExternalListOutput(%c1_i32) : (i32) -> !fir.ref<i32>
+    %12 = fir.load %0 : !fir.ref<f64>
+    call @__F18IOa_OutputReal64(%11, %12) : (!fir.ref<i32>, f64) -> ()
+    call @__F18IOa_EndIOStatement(%11) : (!fir.ref<i32>) -> ()
+    return
+}
+
+func @__F18IOa_BeginExternalListOutput(i32) -> !fir.ref<i32>
+func @__F18IOa_OutputInteger64(!fir.ref<i32>, i64)
+func @__F18IOa_OutputReal64(!fir.ref<i32>, f64)
+func @__F18IOa_EndIOStatement(!fir.ref<i32>)
diff --git a/test/fir/bugs/bug0002.fir b/test/fir/bugs/bug0002.fir
new file mode 100644
index 000000000000..f163e76035e9
--- /dev/null
+++ b/test/fir/bugs/bug0002.fir
@@ -0,0 +1,12 @@
+func @foo() -> f32 {
+    %0 = fir.alloca f32 {name = "foo"} : !fir.ref<f32>
+    %1 = fir.alloca f32 {name = "x"} : !fir.ref<f32>
+    %cst = constant 4.200000e+01 : f32
+    fir.store %cst to %1 : !fir.ref<f32>
+    %cst_0 = constant 6.600000e+01 : f32
+    fir.store %cst_0 to %1 : !fir.ref<f32>
+    %2 = fir.load %1 : !fir.ref<f32>
+    fir.store %2 to %0 : !fir.ref<f32>
+    %3 = fir.load %0 : !fir.ref<f32>
+    return %3 : f32
+}
diff --git a/test/fir/compare.fir b/test/fir/compare.fir
new file mode 100644
index 000000000000..8aa9f6864dc1
--- /dev/null
+++ b/test/fir/compare.fir
@@ -0,0 +1,29 @@
+func @cmp(%a : !fir.real<10>, %b : !fir.real<10>) -> i1 {
+  %1 = "fir.cmpf"(%a, %b) {predicate = 1} : (!fir.real<10>, !fir.real<10>) -> i1
+  return %1 : i1
+}
+
+func @cmp2(%a : !fir.real<16>, %b : !fir.real<16>) -> i1 {
+  %1 = fir.cmpf "ult", %a, %b : !fir.real<16>
+  return %1 : i1
+}
+
+func @cmp3(%a : !fir.complex<4>, %b : !fir.complex<4>) -> i1 {
+  %1 = fir.cmpc "ueq", %a, %b : !fir.complex<4>
+  return %1 : i1
+}
+
+func @neg1(%a : !fir.real<8>) -> !fir.real<8> {
+  %1 = "fir.negf"(%a) : (!fir.real<8>) -> !fir.real<8>
+  return %1 : !fir.real<8>
+}
+
+func @neg2(%a : !fir.real<8>) -> !fir.real<8> {
+  %1 = fir.negf %a : !fir.real<8>
+  return %1 : !fir.real<8>
+}
+
+func @neg3(%a : !fir.complex<8>) -> !fir.complex<8> {
+  %1 = fir.negc %a : !fir.complex<8>
+  return %1 : !fir.complex<8>
+}
diff --git a/test/fir/complex.fir b/test/fir/complex.fir
index 9f69e41bbd2b..958baa430ff4 100644
--- a/test/fir/complex.fir
+++ b/test/fir/complex.fir
@@ -5,3 +5,18 @@ func @foo(%a : !fir.complex<4>, %b : !fir.complex<4>, %c : !fir.complex<4>, %d :
   %4 = fir.divc %3, %e : !fir.complex<4>
   return %4 : !fir.complex<4>
 }
+
+func @f2(%a : !fir.complex<4>) -> f32 {
+  %0 = constant 0 : i32
+  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
+  return %1 : f32
+}
+
+func @f3(%a : !fir.complex<4>) -> !fir.complex<4> {
+  %0 = constant 1 : i32
+  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
+  %2 = constant 0.0 : f32
+  %3 = fir.subf %2, %1 : f32
+  %4 = fir.insert_value %a, %3, %0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  return %4 : !fir.complex<4>
+}
diff --git a/test/fir/constant.fir b/test/fir/constant.fir
new file mode 100644
index 000000000000..67ca40f36611
--- /dev/null
+++ b/test/fir/constant.fir
@@ -0,0 +1,19 @@
+func @x() -> !fir.array<3x!fir.char<1>> {
+  %1 = fir.constant "xyz" : !fir.array<3x!fir.char<1>>
+  return %1 : !fir.array<3x!fir.char<1>>
+}
+
+func @y() -> !fir.real<10> {
+  %1 = fir.constant "42.4" : !fir.real<10>
+  return %1 : !fir.real<10>
+}
+
+func @z() -> !fir.logical<1> {
+  %1 = fir.constant "true" : !fir.logical<1>
+  return %1 : !fir.logical<1>
+}
+
+func @z2() -> !fir.ref<!fir.char<1>> {
+  %1 = fir.constant "abc" : !fir.ref<!fir.char<1>>
+  return %1 : !fir.ref<!fir.char<1>>
+}
diff --git a/test/fir/dynlayout.fir b/test/fir/dynlayout.fir
new file mode 100644
index 000000000000..5646db53975e
--- /dev/null
+++ b/test/fir/dynlayout.fir
@@ -0,0 +1,38 @@
+// dynamic case
+
+// dynamically sized type
+func @_QQSIZEOF_a(%p1 : i64, %p2 : i64) -> i64 {
+  %c1 = constant 1 : i64  // sizeof CHARACTER(1)
+  %1 = muli %p1, %c1 : i64
+  %c2 = constant 2 : i64  // sizeof CHARACTER(2)
+  %2 = muli %p2, %c2 : i64
+  %3 = addi %1, %2 : i64
+  return %3 : i64
+}
+
+func @_QQOFFSETOF_a_f1(%p1 : i64, %p2 : i64) -> i32 {
+  %0 = constant 0 : i64
+  %1 = fir.convert %0 : (i64) -> i32
+  return %1 : i32
+}
+
+func @_QQOFFSETOF_a_f2(%p1 : i64, %p2 : i64) -> i32 {
+  %c1 = constant 1 : i64
+  %1 = muli %p1, %c1 : i64
+  %2 = fir.convert %1 : (i64) -> i32
+  return %2 : i32
+}
+
+// get 'a%f2(x)'
+func @f(%a : !fir.box<!fir.type<a(p1:i64,p2:i64){f1:!fir.array<?x!fir.char<1>>, f2:!fir.array<?x!fir.char<2>>}>>, %x : i32, %q1 : i64, %q2 : i64) -> !fir.char<2> {
+  %p1p = fir.len_param_index p1, !fir.type<a>
+  %p2p = fir.len_param_index p2, !fir.type<a>
+  %p1c = fir.coordinate_of %a, %p1p : (!fir.box<!fir.type<a>>, !fir.len) -> !fir.ref<i64>
+  %p2c = fir.coordinate_of %a, %p2p : (!fir.box<!fir.type<a>>, !fir.len) -> !fir.ref<i64>
+  %p1 = fir.load %p1c : !fir.ref<i64>
+  %p2 = fir.load %p2c : !fir.ref<i64>
+  %1 = fir.field_index f2, !fir.type<a>(%p1, %p2) : i64, i64
+  %2 = fir.coordinate_of %a, %1, %x : (!fir.box<!fir.type<a>>, !fir.field, i32) -> !fir.ref<!fir.char<2>>
+  %3 = fir.load %2 : !fir.ref<!fir.char<2>>
+  return %3 : !fir.char<2>
+}
diff --git a/test/fir/embox.fir b/test/fir/embox.fir
index e3750a3c8b55..801e7241b424 100644
--- a/test/fir/embox.fir
+++ b/test/fir/embox.fir
@@ -1,6 +1,6 @@
 #x0 = (d0, d1) -> (d1, d0)
 
-func @f(%arg : !fir.ref<!fir.array<?:f64>>) {
-  %1 = fir.embox %arg [#x0] : (!fir.ref<!fir.array<?:f64>>) -> !fir.box<!fir.array<?:f64>, >
+func @f(%arg : !fir.ref<!fir.array<?xf64>>) {
+  %1 = fir.embox %arg [#x0] : (!fir.ref<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>, >
   return
 }
diff --git a/test/fir/fir-ops.fir b/test/fir/fir-ops.fir
index 6d025b2cf24b..5f980f7406ac 100644
--- a/test/fir/fir-ops.fir
+++ b/test/fir/fir-ops.fir
@@ -9,11 +9,11 @@ func @dvd2() -> !fir.type<derived2(p:i32)>
 func @dvd3() -> !fir.type<derived3{f:f32}>
 func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
 
-func @arr1() -> !fir.array<10:f32>
-func @arr2() -> !fir.array<10x10:f32>
-func @arr3() -> !fir.array<?:f32>
-func @arr4() -> !fir.array<10x?:f32>
-func @arr5() -> !fir.array<?x?:f32>
+func @arr1() -> !fir.array<10xf32>
+func @arr2() -> !fir.array<10x10xf32>
+func @arr3() -> !fir.array<?xf32>
+func @arr4() -> !fir.array<10x?xf32>
+func @arr5() -> !fir.array<?x?xf32>
 func @arr6() -> !fir.array<*:f32>
 
 func @mem1() -> !fir.ref<i32>
@@ -21,7 +21,7 @@ func @mem2() -> !fir.ptr<i32>
 func @mem3() -> !fir.heap<i32>
 func @mem4() -> !fir.ref<() -> ()>
 
-func @box1() -> !fir.box<!fir.array<?:f32>>
+func @box1() -> !fir.box<!fir.array<?xf32>>
 func @box2() -> !fir.boxchar<2>
 func @box3() -> !fir.boxproc<(i32, i32) -> i64>
 func @box4() -> !fir.box<!fir.type<derived3{f:f32}>>
@@ -43,39 +43,39 @@ func @nop()
 func @get_func() -> (() -> ())
 
 func @instructions() {
-  %0 = fir.alloca !fir.array<10:i32> : !fir.ref<!fir.array<10:i32>>
-  %1 = fir.load %0 : !fir.ref<!fir.array<10:i32>>
+  %0 = fir.alloca !fir.array<10xi32> : !fir.ref<!fir.array<10xi32>>
+  %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
   %2 = fir.alloca i32 : !fir.ref<i32>
   %3 = constant 22 : i32
   fir.store %3 to %2 : !fir.ref<i32>
   %4 = fir.undefined i32
-  %5 = fir.allocmem !fir.array<100:f32> : !fir.heap<!fir.array<100:f32>>
-  %6 = fir.embox %5 : (!fir.heap<!fir.array<100:f32>>) -> !fir.box<!fir.array<100:f32>>
-  %7 = fir.box_addr %6 : (!fir.box<!fir.array<100:f32>>) -> !fir.ref<!fir.array<100:f32>>
+  %5 = fir.allocmem !fir.array<100xf32> : !fir.heap<!fir.array<100xf32>>
+  %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
+  %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
   %c0 = constant 0 : index
-  %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100:f32>>, index) -> (index, index, index)
+  %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
   fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()
   %8 = fir.call @it1() : () -> !fir.int<4>
-  %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100:f32>>) -> i64
-  %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100:f32>>) -> i1
-  %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100:f32>>) -> i1
-  %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100:f32>>) -> i1
-  %13 = fir.box_rank %6 : (!fir.box<!fir.array<100:f32>>) -> i64
-  %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100:f32>>) -> !fir.tdesc<!fir.array<100:f32>>
+  %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i64
+  %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64
+  %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
   %15 = fir.call @box2() : () -> !fir.boxchar<2>
   %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
   %17 = fir.call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
   %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
   %19 = constant 10 : i32
-  %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100:f32>>, i32) -> !fir.ref<f32>
-  %21 = fir.field_index("f") : !fir.field
+  %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
+  %21 = fir.field_index f, !fir.type<derived{f:f32}>
   %22 = fir.undefined !fir.type<derived{f:f32}>
   %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32
   %c1 = constant 1 : i32
   %24 = fir.gendims %c1, %19, %c1 : (i32, i32, i32) -> !fir.dims<1>
   %cf1 = constant 1.0 : f32
   %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
-  %26 = fir.len_param_index("f") : !fir.field
+  %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>
   %27 = fir.call @box4() : () -> !fir.box<!fir.type<derived3{f:f32}>>
   %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
   %29 = fir.convert %28 : (i32) -> i64
@@ -83,7 +83,7 @@ func @instructions() {
   fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
   %31 = fir.no_reassoc %29 : i64
   fir.call @user_i64(%31) : (i64) -> ()
-  fir.freemem %5 : !fir.heap<!fir.array<100:f32>>
+  fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
   %32 = fir.call @get_func() : () -> (() -> ())
   fir.call %32() : () -> ()
   %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
diff --git a/test/fir/fir-types.fir b/test/fir/fir-types.fir
index c61b7d98bde3..7cfcfc6363a7 100644
--- a/test/fir/fir-types.fir
+++ b/test/fir/fir-types.fir
@@ -13,20 +13,20 @@ func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
 func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
 func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
 
-func @arr1() -> !fir.array<10:f32>
-func @arr2() -> !fir.array<10x10:f32>
-func @arr3() -> !fir.array<?:f32>
-func @arr4() -> !fir.array<10x?:f32>
-func @arr5() -> !fir.array<?x?:f32>
+func @arr1() -> !fir.array<10xf32>
+func @arr2() -> !fir.array<10x10xf32>
+func @arr3() -> !fir.array<?xf32>
+func @arr4() -> !fir.array<10x?xf32>
+func @arr5() -> !fir.array<?x?xf32>
 func @arr6() -> !fir.array<*:f32>
-func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9:f32>
+func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
 
 func @mem1() -> !fir.ref<i32>
 func @mem2() -> !fir.ptr<i32>
 func @mem3() -> !fir.heap<i32>
 func @mem4() -> !fir.ref<() -> ()>
 
-func @box1() -> !fir.box<!fir.array<?:f32>>
+func @box1() -> !fir.box<!fir.array<?xf32>>
 func @box2() -> !fir.boxchar<2>
 func @box3() -> !fir.boxproc<(i32, i32) -> i64>
 func @box4() -> !fir.box<none>
@@ -34,5 +34,5 @@ func @box4() -> !fir.box<none>
 
 func @oth1() -> !fir.dims<1>
 func @oth2() -> !fir.field
-func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
+func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
 func @oth4() -> !fir.dims<15>
diff --git a/test/fir/loads.fir b/test/fir/loads.fir
new file mode 100644
index 000000000000..2b05e7372633
--- /dev/null
+++ b/test/fir/loads.fir
@@ -0,0 +1,35 @@
+func @fun(%a : !fir.ref<i64>) -> i64 {
+  %1 = fir.load %a : !fir.ref<i64>
+  %2 = fir.load %a : !fir.ref<i64>
+  %3 = addi %1, %2 : i64
+  %4 = fir.load %a : !fir.ref<i64>
+  %5 = addi %3, %4 : i64
+  %6 = fir.load %a : !fir.ref<i64>
+  %7 = addi %5, %6 : i64
+  %8 = fir.load %a : !fir.ref<i64>
+  %9 = addi %7, %8 : i64
+  %10 = fir.load %a : !fir.ref<i64>
+  %11 = addi %10, %9 : i64
+  %12 = fir.load %a : !fir.ref<i64>
+  %13 = addi %11, %12 : i64
+  return %13 : i64
+}
+
+func @bar(%a : !fir.ref<i64>) -> i64
+
+func @fun2(%a : !fir.ref<i64>) -> i64 {
+  %1 = fir.load %a : !fir.ref<i64>
+  %2 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
+  %3 = addi %1, %2 : i64
+  %4 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
+  %5 = addi %3, %4 : i64
+  %6 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
+  %7 = addi %5, %6 : i64
+  %8 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
+  %9 = addi %7, %8 : i64
+  %10 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
+  %11 = addi %10, %9 : i64
+  %12 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
+  %13 = addi %11, %12 : i64
+  return %13 : i64
+}
diff --git a/test/fir/select.fir b/test/fir/select.fir
new file mode 100644
index 000000000000..026d97b5a9f5
--- /dev/null
+++ b/test/fir/select.fir
@@ -0,0 +1,45 @@
+func @f(%a : i32) -> i32 {
+   %1 = constant 1 : i32
+   %2 = constant 42 : i32
+   fir.select %a : i32 [1, ^bb2(%1:i32), unit, ^bb3(%2:i32)]
+^bb2(%3 : i32) :
+   return %3 : i32
+^bb3(%4 : i32) :
+   %5 = addi %4, %4 : i32
+   return %5 : i32 
+}
+
+func @g(%a : i32) -> i32 {
+   %1 = constant 1 : i32
+   %2 = constant 42 : i32
+   fir.select_rank %a : i32 [1, ^bb2(%1:i32), -1, ^bb4, unit, ^bb3(%2:i32)]
+^bb2(%3 : i32) :
+   return %3 : i32
+^bb3(%4 : i32) :
+   %5 = addi %4, %4 : i32
+   return %5 : i32 
+^bb4:
+   return %a : i32
+}
+
+func @h(%a : i32) -> i32 {
+   %1 = constant 1 : i32
+   %2 = constant 42 : i32
+   %b1 = constant 4 : i32
+   %b2 = constant 14 : i32
+   %b3 = constant 82 : i32
+   %b4 = constant 96 : i32
+   fir.select_case %a : i32 [#fir.point, %1, ^bb2(%1:i32), #fir.lower, %b1, ^bb4, #fir.upper, %b2, ^bb6, #fir.interval, %b3, %b4, ^bb5, unit, ^bb3(%2:i32)]
+^bb2(%3 : i32) :
+   return %3 : i32
+^bb3(%4 : i32) :
+   %5 = addi %4, %4 : i32
+   br ^bb2(%5 : i32) 
+^bb4:
+   return %a : i32
+^bb5:
+   return %1 : i32
+^bb6:
+   %x = addi %b4, %b3 : i32
+   return %x : i32
+}
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index e1dc5d702475..62016d7370d6 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -1,3 +1,4 @@
 add_subdirectory(f18)
 add_subdirectory(f18-parse-demo)
+add_subdirectory(bbc)
 add_subdirectory(tco)
diff --git a/tools/fml/CMakeLists.txt b/tools/bbc/CMakeLists.txt
similarity index 85%
rename from tools/fml/CMakeLists.txt
rename to tools/bbc/CMakeLists.txt
index 1f79d37d0233..58e011fb18ed 100644
--- a/tools/fml/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -14,19 +14,21 @@
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
 
-add_executable(fml
-  fml.cc
+add_executable(bbc
+  bbc.cc
 )
 
 set(LIBS
+  FIR
+  FIRTransforms
   MLIRAffineOps
   MLIRLLVMIR
   MLIRLoopOps
   MLIRStandardOps
 )
 
-whole_archive_link(fml ${LIBS})
-target_link_libraries(fml
+whole_archive_link(bbc ${LIBS})
+target_link_libraries(bbc
   FortranCommon
   FortranParser
   FortranEvaluate
@@ -36,4 +38,4 @@ target_link_libraries(fml
   ${LIBS}
 )
 
-install(TARGETS fml DESTINATION bin)
+install(TARGETS bbc DESTINATION bin)
diff --git a/tools/fml/fml.cc b/tools/bbc/bbc.cc
similarity index 89%
rename from tools/fml/fml.cc
rename to tools/bbc/bbc.cc
index 05293d6f54c1..1cc749a6d23b 100644
--- a/tools/fml/fml.cc
+++ b/tools/bbc/bbc.cc
@@ -14,7 +14,7 @@
 
 // Temporary Fortran front end driver main program for development scaffolding.
 
-#include "fir/Dialect.h"
+#include "fir/FIRDialect.h"
 #include "fir/Tilikum/Tilikum.h"
 #include "fir/Transforms/Passes.h"
 #include "fir/Transforms/StdConverter.h"
@@ -23,7 +23,7 @@
 #include "../../lib/common/default-kinds.h"
 #include "../../lib/parser/characters.h"
 #include "../../lib/parser/dump-parse-tree.h"
-#include "../../lib/parser/flang-features.h"
+#include "../../lib/common/Fortran-features.h"
 #include "../../lib/parser/message.h"
 #include "../../lib/parser/parse-tree-visitor.h"
 #include "../../lib/parser/parse-tree.h"
@@ -286,68 +286,15 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
     pm.addPass(fir::createFIRToLLVMPass());
   }
   if (driver.lowerToLLVMIR) {
-    pm.addPass(fir::createLLVMDialectToLLVMPass());
+    pm.addPass(fir::createLLVMDialectToLLVMPass("a.ll"));
   }
-  auto result{pm.run(mlirModule)};
-  if (driver.dumpFIR) {
-    llvm::errs() << ";== 2 ==\n";
-    mlirModule.dump();
-  }
-  return {};
-}
-
-// For handling .fir files (MLIR+FIR)
-std::string CompileFir(std::string path, Fortran::parser::Options options,
-    DriverOptions &driver,
-    Fortran::semantics::SemanticsContext &semanticsContext) {
-  Br::instantiateBurnsideBridge(semanticsContext.defaultKinds());
-
-  // check that there is a file to load
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
-      llvm::MemoryBuffer::getFileOrSTDIN(path);
-  if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open file: " << EC.message() << '\n';
-    std::exit(-1);
-  }
-
-  // load the file into a module
-  llvm::SourceMgr sourceMgr;
-  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
-  Br::getBridge().parseSourceFile(sourceMgr);
-  auto mlirModule = Br::getBridge().getModule();
-  if (!Br::getBridge().validModule()) {
-    llvm::errs() << "Error can't load file " << path << '\n';
-    std::exit(3);
-  }
-  if (mlir::failed(mlirModule.verify())) {
-    llvm::errs() << "Error verifying FIR module\n";
-    std::exit(4);
-  }
-
-  llvm::errs() << ";== 3 ==\n";
-  mlirModule.dump();
-
-  // run passes
-  mlir::PassManager pm{mlirModule.getContext()};
-  pm.addPass(fir::createMemToRegPass());
-  pm.addPass(fir::createCSEPass());
-  if (driver.lowerToStd) {
-    pm.addPass(fir::createFIRToStdPass());
-  }
-  if (driver.lowerToLLVM) {
-    pm.addPass(fir::createFIRToLLVMPass());
-  }
-  if (driver.lowerToLLVMIR) {
-    pm.addPass(fir::createLLVMDialectToLLVMPass());
-  }
-  auto result{pm.run(mlirModule)};
-  llvm::errs() << ";== 4 ==\n";
-  mlirModule.dump();
-  if (mlir::succeeded(result)) {
-    llvm::errs() << "a.ll written\n";
+  if (mlir::succeeded(pm.run(mlirModule))) {
+    if (driver.dumpFIR) {
+      llvm::errs() << ";== 2 ==\n";
+      mlirModule.dump();
+    }
   } else {
-    llvm::errs() << "FAILED\n";
-    std::exit(5);
+    llvm::errs() << "oops, pass manager reported failure\n";
   }
   return {};
 }
@@ -407,8 +354,7 @@ int main(int argc, char *const argv[]) {
 
   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
 
-  std::vector<std::string> fortranSources, firSources, otherSources,
-      relocatables;
+  std::vector<std::string> fortranSources, otherSources, relocatables;
   bool anyFiles{false};
 
   while (!args.empty()) {
@@ -428,8 +374,6 @@ int main(int argc, char *const argv[]) {
             suffix == "cuf" || suffix == "CUF" || suffix == "f18" ||
             suffix == "F18" || suffix == "ff18") {
           fortranSources.push_back(arg);
-        } else if (suffix == "fir" || suffix == "ir" || suffix == "mlir") {
-          firSources.push_back(arg);
         } else if (suffix == "o" || suffix == "a") {
           relocatables.push_back(arg);
         } else {
@@ -622,12 +566,6 @@ int main(int argc, char *const argv[]) {
       relocatables.push_back(relo);
     }
   }
-  for (const auto &path : firSources) {
-    std::string relo{CompileFir(path, options, driver, semanticsContext)};
-    if (!driver.compileOnly && !relo.empty()) {
-      relocatables.push_back(relo);
-    }
-  }
   for (const auto &path : otherSources) {
     std::string relo{CompileOtherLanguage(path, driver)};
     if (!driver.compileOnly && !relo.empty()) {
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
new file mode 100644
index 000000000000..3e2ae6844ea4
--- /dev/null
+++ b/tools/tco/CMakeLists.txt
@@ -0,0 +1,46 @@
+# Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(LIBS
+  FIR
+  FIRTransforms
+  MLIRAffineToStandard
+  MLIRAnalysis
+  MLIRLLVMIR
+  MLIRParser
+  MLIRPass
+  MLIRTransforms
+  MLIRSupport
+)
+
+add_llvm_library(FirTcoLib tco.cpp)
+target_link_libraries(FirTcoLib ${LIBS})
+
+set(EXE_LIBS
+  ${LIBS}
+  MLIRAffineOps
+  MLIRLoopToStandard
+  MLIREDSC
+  MLIRLinalg
+  MLIRLoopOps
+  MLIRStandardOps
+  MLIRStandardToLLVM
+  MLIRVectorOps
+  MLIRVectorToLLVM
+)
+
+add_llvm_tool(tco tco.cpp)
+llvm_update_compile_flags(tco)
+whole_archive_link(tco ${EXE_LIBS})
+target_link_libraries(tco PRIVATE FIR MLIRIR FirTcoLib ${EXE_LIBS} LLVMSupport)
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
new file mode 100644
index 000000000000..ca68472abb78
--- /dev/null
+++ b/tools/tco/tco.cpp
@@ -0,0 +1,87 @@
+//===- tco.cpp - Tilikum Crossing Opt ---------------------------*- 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
+//
+// =============================================================================
+//
+// This is to be like LLVM's opt program, only for FIR.  Such a program is
+// required for roundtrip testing, etc.
+//
+//===----------------------------------------------------------------------===//
+
+#include "fir/FIRDialect.h"
+#include "fir/Tilikum/Tilikum.h"
+#include "fir/Transforms/Passes.h"
+#include "fir/Transforms/StdConverter.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Module.h"
+#include "mlir/Parser.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/Passes.h"
+
+using namespace llvm;
+
+static cl::opt<std::string> ClInput(
+    cl::Positional, cl::Required, cl::desc("<input file>"));
+
+static cl::opt<std::string> ClOutput("o", cl::desc("Specify output filename"),
+    cl::value_desc("filename"), cl::init("a.ll"));
+
+// compile a .fir file
+int compileFIR() {
+  // check that there is a file to load
+  ErrorOr<std::unique_ptr<MemoryBuffer>> fileOrErr =
+      MemoryBuffer::getFileOrSTDIN(ClInput);
+
+  if (std::error_code EC = fileOrErr.getError()) {
+    errs() << "Could not open file: " << EC.message() << '\n';
+    return 1;
+  }
+
+  // load the file into a module
+  SourceMgr sourceMgr;
+  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), SMLoc());
+  auto context = std::make_unique<mlir::MLIRContext>();
+  auto owningRef = mlir::parseSourceFile(sourceMgr, context.get());
+
+  if (!owningRef) {
+    errs() << "Error can't load file " << ClInput << '\n';
+    return 2;
+  }
+  if (mlir::failed(owningRef->verify())) {
+    errs() << "Error verifying FIR module\n";
+    return 4;
+  }
+
+  errs() << ";== input ==\n";
+  owningRef->dump();
+
+  // run passes
+  mlir::PassManager pm{context.get()};
+  pm.addPass(fir::createMemToRegPass());
+  pm.addPass(fir::createCSEPass());
+  pm.addPass(fir::createFIRToStdPass());
+  pm.addPass(fir::createFIRToLLVMPass());
+  pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput));
+  if (mlir::succeeded(pm.run(*owningRef))) {
+    errs() << ";== output ==\n";
+    owningRef->dump();
+  } else {
+    errs() << "FAILED: " << ClInput << '\n';
+    return 8;
+  }
+  return 0;
+}
+
+int main(int argc, char *const argv[]) {
+  cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Opt\n");
+  return compileFIR();
+}

From 080b54601fc50a7816157fc55448a752db63606e Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 18 Nov 2019 09:56:39 -0800
Subject: [PATCH 123/345] fix build failures

---
 lib/burnside/convert-expr.cc | 14 ++++++--------
 lib/burnside/fe-helper.cc    | 12 ++++++------
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 62a47c794f3e..ea7cd324a53e 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -576,15 +576,13 @@ class ExprLowering {
     auto unwrapTy{arrTy.cast<fir::ReferenceType>().getEleTy()};
     auto seqTy{unwrapTy.cast<fir::SequenceType>()};
     auto shape = seqTy.getShape();
-    if (shape.hasValue()) {
-      if (dims < shape->size()) {
-        fir::SequenceType::Bounds newBnds;
-        // follow Fortran semantics and remove columns
-        for (unsigned i = 0; i < dims; ++i) {
-          newBnds.push_back((*shape)[i]);
-        }
-        return fir::SequenceType::get({newBnds}, seqTy.getEleTy());
+    if ((shape.size() > 0) && (dims < shape.size())) {
+      fir::SequenceType::Shape newBnds;
+      // follow Fortran semantics and remove columns
+      for (unsigned i = 0; i < dims; ++i) {
+        newBnds.push_back(shape[i]);
       }
+      return fir::SequenceType::get(newBnds, seqTy.getEleTy());
     }
     return seqTy.getEleTy();
   }
diff --git a/lib/burnside/fe-helper.cc b/lib/burnside/fe-helper.cc
index eaa649afed19..0e5083be440a 100644
--- a/lib/burnside/fe-helper.cc
+++ b/lib/burnside/fe-helper.cc
@@ -222,7 +222,7 @@ class TypeBuilder {
 
   fir::SequenceType::Shape genSeqShape(Se::SymbolRef symbol) {
     assert(symbol->IsObjectArray());
-    fir::SequenceType::Bounds bounds;
+    fir::SequenceType::Shape bounds;
     auto &details = symbol->get<Se::ObjectEntityDetails>();
     const auto size = details.shape().size();
     for (auto &ss : details.shape()) {
@@ -239,13 +239,13 @@ class TypeBuilder {
           bounds.emplace_back(
               toConstant(ubv.value()) - toConstant(lbv.value()) + 1);
         } else {
-          bounds.emplace_back(0);
+          bounds.emplace_back(-1);
         }
       } else {
-        bounds.emplace_back(0);
+        bounds.emplace_back(-1);
       }
     }
-    return {bounds};
+    return bounds;
   }
 
   /// Type consing from a symbol. A symbol's type must be created from the type
@@ -307,9 +307,9 @@ class TypeBuilder {
   }
 
   fir::SequenceType::Shape trivialShape(int size) {
-    fir::SequenceType::Bounds bounds;
+    fir::SequenceType::Shape bounds;
     bounds.emplace_back(size);
-    return {bounds};
+    return bounds;
   }
 
   // some sequence of `n` bytes

From 3bb3f72a85f7e4ecdcce41c2f89128f85ac2ac3c Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 19 Nov 2019 07:32:19 -0800
Subject: [PATCH 124/345] fix .NOT. lowering and clean warning

---
 lib/burnside/convert-expr.cc | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index ea7cd324a53e..7f6a141198b6 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -117,11 +117,19 @@ class ExprLowering {
   }
 
   /// Generate a logical/boolean constant of `value`
+  M::Type getMLIRlogicalType() {
+    return M::IntegerType::get(1, builder.getContext());
+  }
+  M::Value *genMLIRLogicalConstant(M::MLIRContext *context, bool value) {
+    auto attr{builder.getIntegerAttr(getMLIRlogicalType(), value ? 1 : 0)};
+    return builder.create<M::ConstantOp>(getLoc(), getMLIRlogicalType(), attr)
+        .getResult();
+  }
   template<int KIND>
   M::Value *genLogicalConstant(M::MLIRContext *context, bool value) {
-    auto attr{builder.getBoolAttr(value)};
-    M::Type logTy{getFIRType(context, defaults, LogicalCat, KIND)};
-    auto res{builder.create<M::ConstantOp>(getLoc(), logTy, attr)};
+    auto mlirCst{genMLIRLogicalConstant(context, value)};
+    M::Type firLogicalTy{getFIRType(context, defaults, LogicalCat, KIND)};
+    auto res{builder.create<fir::ConvertOp>(getLoc(), firLogicalTy, mlirCst)};
     return res.getResult();
   }
 
@@ -394,9 +402,15 @@ class ExprLowering {
     return builder.create<fir::ConvertOp>(getLoc(), ty, genval(convert.left()));
   }
   template<typename A> M::Value *genval(Ev::Parentheses<A> const &) { TODO(); }
+
   template<int KIND> M::Value *genval(const Ev::Not<KIND> &op) {
     auto *context{builder.getContext()};
-    return createBinaryOp<M::XOrOp>(op, genLogicalConstant<KIND>(context, 1));
+    auto mlirLogical{builder.create<fir::ConvertOp>(
+        getLoc(), getMLIRlogicalType(), genval(op.left()))};
+    auto i1One{genMLIRLogicalConstant(context, 1)};
+    auto mlirRes{builder.create<M::XOrOp>(getLoc(), mlirLogical, i1One)};
+    auto firTy{getFIRType(builder.getContext(), defaults, LogicalCat, KIND)};
+    return builder.create<fir::ConvertOp>(getLoc(), firTy, mlirRes).getResult();
   }
 
   template<int KIND> M::Value *genval(Ev::LogicalOperation<KIND> const &op) {
@@ -412,6 +426,11 @@ class ExprLowering {
     case Ev::LogicalOperator::Neqv:
       result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::ne);
       break;
+    case Ev::LogicalOperator::Not:
+      // LogicalOperations are binary operations. Expr for Not is
+      // evaluate::Not<KIND>.
+      assert(false);
+      break;
     }
     if (!result) {
       assert(false && "unhandled logical operation");

From 9622d9f8a6300951434d1f4fbe8c884cf58e88a1 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 19 Nov 2019 11:07:38 -0800
Subject: [PATCH 125/345] add lowering of fir.loop

---
 include/fir/Transforms/Passes.h    |   6 +-
 lib/fir/Tilikum.cpp                |  40 ++----
 lib/fir/Transforms/CMakeLists.txt  |   1 +
 lib/fir/Transforms/RewriteLoop.cpp | 193 +++++++++++++++++++++++++++++
 tools/tco/tco.cpp                  |   7 ++
 5 files changed, 213 insertions(+), 34 deletions(-)
 create mode 100644 lib/fir/Transforms/RewriteLoop.cpp

diff --git a/include/fir/Transforms/Passes.h b/include/fir/Transforms/Passes.h
index faafc64608ed..a33a570464ba 100644
--- a/include/fir/Transforms/Passes.h
+++ b/include/fir/Transforms/Passes.h
@@ -21,6 +21,7 @@ namespace mlir {
 class FuncOp;
 template <typename>
 class OpPassBase;
+class Pass;
 } // namespace mlir
 
 namespace fir {
@@ -28,10 +29,13 @@ namespace fir {
 /// Effects aware CSE pass
 std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createCSEPass();
 
+/// Convert FIR loop constructs to the Affine dialect
+std::unique_ptr<mlir::Pass> createPromoteToAffinePass();
+
 /// Convert `fir.loop` and `fir.where` to `loop.for` and `loop.if`.  This
 /// conversion enables the `createLowerToCFGPass` to transform these to CFG
 /// form.
-std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createFirToLoopPass();
+std::unique_ptr<mlir::Pass> createLowerToLoopPass();
 
 /// A pass to convert the FIR dialect from "Mem-SSA" form to "Reg-SSA"
 /// form. This pass is a port of LLVM's mem2reg pass, but modified for the FIR
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index 36db1a3dbe9d..a717b95850b9 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -1385,19 +1385,6 @@ struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
   }
 };
 
-// abstract loop construct
-struct LoopOpConversion : public FIROpConversion<fir::LoopOp> {
-  using FIROpConversion::FIROpConversion;
-
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto loop = M::cast<fir::LoopOp>(op);
-    TODO(loop);
-    return matchSuccess();
-  }
-};
-
 // FIXME: how do we want to enforce this in LLVM-IR?
 struct NoReassocOpConversion : public FIROpConversion<NoReassocOp> {
   using FIROpConversion::FIROpConversion;
@@ -1667,19 +1654,6 @@ struct UnreachableOpConversion : public FIROpConversion<UnreachableOp> {
   }
 };
 
-// abstract conditional construct
-struct WhereOpConversion : public FIROpConversion<fir::WhereOp> {
-  using FIROpConversion::FIROpConversion;
-
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto where = M::cast<fir::WhereOp>(op);
-    TODO(where);
-    return matchSuccess();
-  }
-};
-
 //
 // Primitive operations on Real (floating-point) types
 //
@@ -1948,13 +1922,13 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
         FirEndOpConversion, ExtractValueOpConversion, FreeMemOpConversion,
         GenDimsOpConversion, GenTypeDescOpConversion, GlobalEntryOpConversion,
         GlobalOpConversion, InsertValueOpConversion, LenParamIndexOpConversion,
-        LoadOpConversion, LoopOpConversion, ModfOpConversion, MulcOpConversion,
-        MulfOpConversion, NegcOpConversion, NegfOpConversion,
-        NoReassocOpConversion, SelectCaseOpConversion, SelectOpConversion,
-        SelectRankOpConversion, SelectTypeOpConversion, StoreOpConversion,
-        SubcOpConversion, SubfOpConversion, UnboxCharOpConversion,
-        UnboxOpConversion, UnboxProcOpConversion, UndefOpConversion,
-        UnreachableOpConversion, WhereOpConversion>(&context, typeConverter);
+        LoadOpConversion, ModfOpConversion, MulcOpConversion, MulfOpConversion,
+        NegcOpConversion, NegfOpConversion, NoReassocOpConversion,
+        SelectCaseOpConversion, SelectOpConversion, SelectRankOpConversion,
+        SelectTypeOpConversion, StoreOpConversion, SubcOpConversion,
+        SubfOpConversion, UnboxCharOpConversion, UnboxOpConversion,
+        UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion>(
+        &context, typeConverter);
     M::populateStdToLLVMConversionPatterns(typeConverter, patterns);
     M::ConversionTarget target{context};
     target.addLegalDialect<M::LLVM::LLVMDialect>();
diff --git a/lib/fir/Transforms/CMakeLists.txt b/lib/fir/Transforms/CMakeLists.txt
index a8ddb6d71ba9..6c0ad1179d2e 100644
--- a/lib/fir/Transforms/CMakeLists.txt
+++ b/lib/fir/Transforms/CMakeLists.txt
@@ -15,6 +15,7 @@
 add_llvm_library(FIRTransforms
   CSE.cpp
   MemToReg.cpp
+  RewriteLoop.cpp
 )
 
 add_dependencies(FIRTransforms FIROpsIncGen)
diff --git a/lib/fir/Transforms/RewriteLoop.cpp b/lib/fir/Transforms/RewriteLoop.cpp
new file mode 100644
index 000000000000..7f8a065a5857
--- /dev/null
+++ b/lib/fir/Transforms/RewriteLoop.cpp
@@ -0,0 +1,193 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fir/FIRDialect.h"
+#include "fir/FIROps.h"
+#include "fir/Transforms/Passes.h"
+#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/LoopOps/LoopOps.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/Support/CommandLine.h"
+#include <memory>
+
+namespace M = mlir;
+
+/// disable FIR to affine dialect conversion
+static llvm::cl::opt<bool>
+    ClDisableAffinePromo("disable-affine-promotion",
+                         llvm::cl::desc("disable FIR to Affine pass"),
+                         llvm::cl::init(false));
+
+/// disable FIR to loop dialect conversion
+static llvm::cl::opt<bool>
+    ClDisableLoopConversion("disable-loop-conversion",
+                            llvm::cl::desc("disable FIR to Loop pass"),
+                            llvm::cl::init(false));
+
+using namespace fir;
+
+namespace {
+
+template <typename FROM>
+class OpRewrite : public M::RewritePattern {
+public:
+  explicit OpRewrite(M::MLIRContext *ctx)
+      : RewritePattern(FROM::getOperationName(), 1, ctx) {}
+};
+
+/// Convert `fir.loop` to `affine.for`
+class AffineLoopConv : public OpRewrite<LoopOp> {
+public:
+  using OpRewrite::OpRewrite;
+};
+
+/// Convert `fir.where` to `affine.if`
+class AffineWhereConv : public OpRewrite<WhereOp> {
+public:
+  using OpRewrite::OpRewrite;
+};
+
+/// Promote fir.loop and fir.where to affine.for and affine.if, in the cases
+/// where such a promotion is possible.
+class AffineDialectPromotion : public M::FunctionPass<AffineDialectPromotion> {
+public:
+  void runOnFunction() override {
+    if (ClDisableAffinePromo)
+      return;
+
+    auto *context{&getContext()};
+    M::OwningRewritePatternList patterns;
+    patterns.insert<AffineLoopConv, AffineWhereConv>(context);
+    M::ConversionTarget target{*context};
+    target.addLegalDialect<M::AffineOpsDialect, FIROpsDialect,
+                           M::loop::LoopOpsDialect, M::StandardOpsDialect>();
+    // target.addDynamicallyLegalOp<LoopOp, WhereOp>();
+
+    // apply the patterns
+    if (M::failed(M::applyPartialConversion(getFunction(), target,
+                                            std::move(patterns)))) {
+      M::emitError(M::UnknownLoc::get(context),
+                   "error in converting to affine dialect\n");
+      signalPassFailure();
+    }
+  }
+};
+
+// Conversion to the MLIR loop dialect
+//
+// FIR loops that cannot be converted to the affine dialect will remain as
+// `fir.loop` operations.  These can be converted to `loop.for` operations. MLIR
+// includes a pass to lower `loop.for` operations to a CFG.
+
+template <typename FROM>
+class OpConversion : public M::ConversionPattern {
+public:
+  explicit OpConversion(M::MLIRContext *ctx)
+      : ConversionPattern(FROM::getOperationName(), 1, ctx) {}
+};
+
+/// Convert `fir.loop` to `loop.for`
+class LoopLoopConv : public OpConversion<LoopOp> {
+public:
+  using OpConversion::OpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, llvm::ArrayRef<M::Value *> operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto loop = M::cast<LoopOp>(op);
+    auto *low = loop.lowerBound();
+    auto *high = loop.upperBound();
+    auto optStep = loop.optstep();
+    auto loc = loop.getLoc();
+    M::Value *step;
+    if (optStep.begin() != optStep.end()) {
+      step = *optStep.begin();
+    } else {
+      auto conStep = loop.constep();
+      step = rewriter.create<M::ConstantIndexOp>(
+          loc, conStep.hasValue() ? conStep.getValue().getSExtValue() : 1);
+    }
+    auto f = rewriter.create<M::loop::ForOp>(loc, low, high, step);
+    f.region().getBlocks().clear();
+    rewriter.inlineRegionBefore(loop.region(), f.region(), f.region().end());
+    rewriter.eraseOp(op);
+    return matchSuccess();
+  }
+};
+
+/// Convert `fir.where` to `loop.if`
+class LoopWhereConv : public OpConversion<WhereOp> {
+public:
+  using OpConversion::OpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, llvm::ArrayRef<M::Value *> operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto where = M::cast<WhereOp>(op);
+    return matchSuccess();
+  }
+};
+
+class LoopFirEndConv : public OpConversion<FirEndOp> {
+public:
+  using OpConversion::OpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, llvm::ArrayRef<M::Value *> operands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<M::loop::TerminatorOp>(op);
+    return matchSuccess();
+  }
+};
+
+/// Convert `fir.loop` and `fir.where` to `loop.for` and `loop.if`.
+class LoopDialectConversion : public M::FunctionPass<LoopDialectConversion> {
+public:
+  void runOnFunction() override {
+    if (ClDisableLoopConversion)
+      return;
+
+    auto *context{&getContext()};
+    M::OwningRewritePatternList patterns;
+    patterns.insert<LoopLoopConv, LoopWhereConv, LoopFirEndConv>(context);
+    M::ConversionTarget target{*context};
+    target.addLegalDialect<M::AffineOpsDialect, FIROpsDialect,
+                           M::loop::LoopOpsDialect, M::StandardOpsDialect>();
+    target.addIllegalOp<FirEndOp, LoopOp, WhereOp>();
+
+    // apply the patterns
+    if (M::failed(M::applyPartialConversion(getFunction(), target,
+                                            std::move(patterns)))) {
+      M::emitError(M::UnknownLoc::get(context),
+                   "error in converting to MLIR loop dialect\n");
+      signalPassFailure();
+    }
+  }
+};
+
+} // namespace
+
+/// Convert FIR loop constructs to the Affine dialect
+std::unique_ptr<M::Pass> fir::createPromoteToAffinePass() {
+  return std::make_unique<AffineDialectPromotion>();
+}
+
+/// Convert `fir.loop` and `fir.where` to `loop.for` and `loop.if`.  This
+/// conversion enables the `createLowerToCFGPass` to transform these to CFG
+/// form.
+std::unique_ptr<M::Pass> fir::createLowerToLoopPass() {
+  return std::make_unique<LoopDialectConversion>();
+}
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index ca68472abb78..b524dd31aa1f 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -20,6 +20,7 @@
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
+#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/Parser.h"
@@ -68,7 +69,13 @@ int compileFIR() {
   mlir::PassManager pm{context.get()};
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
+  // convert fir dialect to affine
+  pm.addPass(fir::createPromoteToAffinePass());
+  // convert fir dialect to loop
+  pm.addPass(fir::createLowerToLoopPass());
   pm.addPass(fir::createFIRToStdPass());
+  // convert loop dialect to standard
+  pm.addPass(mlir::createLowerToCFGPass());
   pm.addPass(fir::createFIRToLLVMPass());
   pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput));
   if (mlir::succeeded(pm.run(*owningRef))) {

From df9cbab6484ae066850d386bb77441b346b888e1 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 19 Nov 2019 12:36:27 -0800
Subject: [PATCH 126/345] rename fe-helper to convert-type

---
 .clang-format                                  |  2 +-
 lib/burnside/CMakeLists.txt                    |  2 +-
 lib/burnside/bridge.cc                         |  8 ++++----
 lib/burnside/builder.cc                        |  2 +-
 lib/burnside/complex-handler.h                 |  8 ++++----
 lib/burnside/convert-expr.cc                   |  8 ++++----
 lib/burnside/{fe-helper.cc => convert-type.cc} |  6 +++---
 lib/burnside/{fe-helper.h => convert-type.h}   | 10 +++++++---
 lib/burnside/intrinsics.cc                     |  4 ++--
 9 files changed, 27 insertions(+), 23 deletions(-)
 rename lib/burnside/{fe-helper.cc => convert-type.cc} (99%)
 rename lib/burnside/{fe-helper.h => convert-type.h} (94%)

diff --git a/.clang-format b/.clang-format
index 064f60c2fb90..c2673ced5070 100644
--- a/.clang-format
+++ b/.clang-format
@@ -10,7 +10,7 @@ AlignTrailingComments: false
 IncludeCategories:
   - Regex:           '^<'
     Priority:        4
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c|mlir|mlir-c)/'
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c|fir|mlir|mlir-c)/'
     Priority:        3
   - Regex:           '^"(flang|\.\.)/'
     Priority:        2
diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
index c4b1c3e9b6ca..9a7e83937775 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/burnside/CMakeLists.txt
@@ -18,7 +18,7 @@ add_library(FortranBurnside
   bridge.cc
   builder.cc
   convert-expr.cc
-  fe-helper.cc
+  convert-type.cc
   flattened.cc
   intrinsics.cc
   runtime.cc
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 87922bfeba47..19b5f59647b6 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -15,16 +15,16 @@
 #include "bridge.h"
 #include "builder.h"
 #include "convert-expr.h"
-#include "fe-helper.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
+#include "convert-type.h"
 #include "flattened.h"
 #include "intrinsics.h"
 #include "io.h"
 #include "runtime.h"
 #include "../parser/parse-tree-visitor.h"
 #include "../semantics/tools.h"
+#include "fir/FIRDialect.h"
+#include "fir/FIROps.h"
+#include "fir/FIRType.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index 409203483f2b..e789d2843a31 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -14,7 +14,7 @@
 
 #include "builder.h"
 #include "bridge.h"
-#include "fe-helper.h"
+#include "convert-type.h"
 #include "llvm/ADT/StringRef.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Value.h"
diff --git a/lib/burnside/complex-handler.h b/lib/burnside/complex-handler.h
index 6c408c0e9879..4400e98a2b60 100644
--- a/lib/burnside/complex-handler.h
+++ b/lib/burnside/complex-handler.h
@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FORTRAN_BURNSIDE_COMPLEX_H_
-#define FORTRAN_BURNSIDE_COMPLEX_H_
+#ifndef FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
+#define FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-#include "fe-helper.h"
+#include "convert-type.h"
 #include "fir/FIROps.h"
 #include "fir/FIRType.h"
 
@@ -107,4 +107,4 @@ class ComplexHandler {
 };
 
 }
-#endif  // FORTRAN_BURNSIDE_COMPLEX_H_
+#endif  // FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 7f6a141198b6..0f2343f5f264 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -15,10 +15,7 @@
 #include "convert-expr.h"
 #include "builder.h"
 #include "complex-handler.h"
-#include "fe-helper.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
+#include "convert-type.h"
 #include "intrinsics.h"
 #include "runtime.h"
 #include "../common/default-kinds.h"
@@ -28,6 +25,9 @@
 #include "../semantics/expression.h"
 #include "../semantics/symbol.h"
 #include "../semantics/type.h"
+#include "fir/FIRDialect.h"
+#include "fir/FIROps.h"
+#include "fir/FIRType.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/Type.h"
diff --git a/lib/burnside/fe-helper.cc b/lib/burnside/convert-type.cc
similarity index 99%
rename from lib/burnside/fe-helper.cc
rename to lib/burnside/convert-type.cc
index 0e5083be440a..1b5cbe5575b3 100644
--- a/lib/burnside/fe-helper.cc
+++ b/lib/burnside/convert-type.cc
@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fe-helper.h"
+#include "convert-type.h"
 #include "bridge.h"
-#include "fir/FIRType.h"
 #include "../semantics/expression.h"
 #include "../semantics/tools.h"
 #include "../semantics/type.h"
+#include "fir/FIRType.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
@@ -288,7 +288,7 @@ class TypeBuilder {
         case DerivedCat: TODO(); break;
         }
       } else if (auto *tySpec{type->AsDerived()}) {
-        (void)tySpec; // FIXME
+        (void)tySpec;  // FIXME
         TODO();
       } else {
         assert(false && "type spec not found");
diff --git a/lib/burnside/fe-helper.h b/lib/burnside/convert-type.h
similarity index 94%
rename from lib/burnside/fe-helper.h
rename to lib/burnside/convert-type.h
index bc7352339212..34218eb87b97 100644
--- a/lib/burnside/fe-helper.h
+++ b/lib/burnside/convert-type.h
@@ -12,12 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FORTRAN_BURNSIDE_FE_HELPER_H_
-#define FORTRAN_BURNSIDE_FE_HELPER_H_
+#ifndef FORTRAN_BURNSIDE_CONVERT_TYPE_H_
+#define FORTRAN_BURNSIDE_CONVERT_TYPE_H_
 
 /// Traversal and conversion of Fortran type data structures into the FIR
 /// dialect of MLIR.
 ///
+/// Lowering of parse tree TYPE, KIND, ATTRIBUTE information to the FIR type
+/// system.
+///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
 #include "../common/Fortran.h"
@@ -108,4 +111,5 @@ mlir::Type convertReal(mlir::MLIRContext *context, int KIND);
 
 }  // burnside
 }  // Fortran
-#endif  // FORTRAN_BURNSIDE_FE_HELPER_H_
+
+#endif  // FORTRAN_BURNSIDE_CONVERT_TYPE_H_
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index a80471fa4a12..e5beb1432e4a 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -15,10 +15,10 @@
 #include "intrinsics.h"
 #include "builder.h"
 #include "complex-handler.h"
-#include "fe-helper.h"
+#include "convert-type.h"
+#include "runtime.h"
 #include "fir/FIROps.h"
 #include "fir/FIRType.h"
-#include "runtime.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include <string>

From abc425acc06a73d09f66964bfea8a81ce65054ed Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 19 Nov 2019 14:10:33 -0800
Subject: [PATCH 127/345] get rid of singleton; start threading internal name
 mangler

---
 include/fir/FIROps.td         |  6 ++++--
 include/fir/InternalNames.h   |  2 +-
 include/fir/Tilikum/Tilikum.h |  5 ++++-
 lib/burnside/bridge.cc        | 13 +++++--------
 lib/burnside/bridge.h         | 22 ++++++++++------------
 lib/fir/Tilikum.cpp           | 15 +++++++++------
 tools/bbc/CMakeLists.txt      | 22 ++++++++++------------
 tools/bbc/bbc.cc              | 20 +++++++++++---------
 tools/tco/CMakeLists.txt      | 24 ++++++++++++------------
 tools/tco/tco.cpp             |  4 +++-
 10 files changed, 69 insertions(+), 64 deletions(-)

diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
index f13d626baae1..aa7faa89deb9 100644
--- a/include/fir/FIROps.td
+++ b/include/fir/FIROps.td
@@ -493,7 +493,7 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
     llvm::SmallVector<M::Block *, 4> dests;
     llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
     while (true) {
-      M::IntegerAttr ivalue;
+      M::Attribute ivalue; // Integer or Unit
       M::Block *dest;
       llvm::SmallVector<M::Value *, 4> destArg;
       llvm::SmallVector<M::NamedAttribute, 1> temp;
@@ -789,6 +789,7 @@ def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
   let parser = [{
     return M::success();
   }];
+
   let printer = [{
     p << getOperationName();
   }];
@@ -1281,7 +1282,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
     if (!recty.dyn_cast<RecordType>())
       return M::failure();
     result.addAttribute(typeAttrName(), M::TypeAttr::get(recty));
-    if (!parser.parseLParen()) {
+    if (!parser.parseOptionalLParen()) {
       L::SmallVector<M::OpAsmParser::OperandType, 8> operands;
       L::SmallVector<M::Type, 8> types;
       auto loc = parser.getNameLoc();
@@ -1549,6 +1550,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
     }
     p.printOptionalAttrDict(getAttrs());
   }];
+
   let verifier = [{
     for (auto &region : getOperation()->getRegions()) {
       if (region.empty())
diff --git a/include/fir/InternalNames.h b/include/fir/InternalNames.h
index 9f00d150cd53..83ad0b9e49ef 100644
--- a/include/fir/InternalNames.h
+++ b/include/fir/InternalNames.h
@@ -32,7 +32,7 @@ namespace fir {
 struct NameMangler {
   enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };
 
-  NameMangler();
+  NameMangler() = default;
 
   /// Mangle a common block name
   llvm::Twine doCommonBlock(llvm::StringRef name);
diff --git a/include/fir/Tilikum/Tilikum.h b/include/fir/Tilikum/Tilikum.h
index dca126e0491e..25d8205a491c 100644
--- a/include/fir/Tilikum/Tilikum.h
+++ b/include/fir/Tilikum/Tilikum.h
@@ -26,11 +26,14 @@ class Pass;
 
 namespace fir {
 
+struct NameMangler;
+
 /// Convert FIR to the LLVM IR dialect
 std::unique_ptr<mlir::Pass> createFIRToLLVMPass();
 
 /// Convert the LLVM IR dialect to LLVM-IR proper
-std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass(llvm::StringRef output);
+std::unique_ptr<mlir::Pass>
+createLLVMDialectToLLVMPass(llvm::StringRef output, NameMangler &mangler);
 
 } // namespace fir
 
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 19b5f59647b6..b79bcd3831ba 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -25,6 +25,7 @@
 #include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
 #include "fir/FIRType.h"
+#include "fir/InternalNames.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
@@ -49,8 +50,6 @@ namespace {
 
 using SomeExpr = Ev::Expr<Ev::SomeType>;
 
-std::unique_ptr<BurnsideBridge> bridgeInstance;
-
 constexpr bool isStopStmt(Pa::StopStmt::Kind kind) {
   return kind == Pa::StopStmt::Kind::Stop;
 }
@@ -1028,7 +1027,8 @@ void FIRConverter::translateRoutine(
 
 }  // namespace
 
-void Br::crossBurnsideBridge(BurnsideBridge &bridge, const Pa::Program &prg) {
+void Br::crossBurnsideBridge(
+    BurnsideBridge &bridge, const Pa::Program &prg, fir::NameMangler &mangler) {
   FIRConverter converter{bridge};
   Walk(prg, converter);
 }
@@ -1052,11 +1052,8 @@ Br::BurnsideBridge::BurnsideBridge(
       M::ModuleOp::create(M::UnknownLoc::get(context.get())));
 }
 
-void Br::instantiateBurnsideBridge(
+BurnsideBridge Br::getBurnsideBridge(
     const Co::IntrinsicTypeDefaultKinds &defaultKinds,
     const Pa::CookedSource *cooked) {
-  auto p{BurnsideBridge::create(defaultKinds, cooked)};
-  bridgeInstance.swap(p);
+  return BurnsideBridge::create(defaultKinds, cooked);
 }
-
-BurnsideBridge &Br::getBridge() { return *bridgeInstance.get(); }
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index b4614a050099..00955159f8f0 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -38,17 +38,18 @@ class Module;
 class SourceMgr;
 }
 
+namespace fir {
+struct NameMangler;
+}
+
 namespace Fortran::burnside {
 
-/// An instance of BurnsideBridge is a singleton that owns the state of the
-/// bridge
 class BurnsideBridge {
 public:
-  static std::unique_ptr<BurnsideBridge> create(
+  static BurnsideBridge create(
       const common::IntrinsicTypeDefaultKinds &defaultKinds,
       const parser::CookedSource *cooked) {
-    BurnsideBridge *p = new BurnsideBridge{defaultKinds, cooked};
-    return std::unique_ptr<BurnsideBridge>{p};
+    return BurnsideBridge{defaultKinds, cooked};
   }
 
   mlir::MLIRContext &getMLIRContext() { return *context.get(); }
@@ -77,20 +78,17 @@ class BurnsideBridge {
 };
 
 /// Cross the bridge from the Fortran parse-tree, etc. to FIR+OpenMP+MLIR
-void crossBurnsideBridge(
-    BurnsideBridge &bridge, const parser::Program &program);
+void crossBurnsideBridge(BurnsideBridge &bridge, const parser::Program &program,
+    fir::NameMangler &mangler);
 
 /// Bridge from MLIR to LLVM-IR
 std::unique_ptr<llvm::Module> LLVMBridge(mlir::ModuleOp &module);
 
-/// instantiate the BURNSIDE bridge singleton
-void instantiateBurnsideBridge(
+/// Get an instance of the Burnside bridge
+BurnsideBridge getBurnsideBridge(
     const common::IntrinsicTypeDefaultKinds &defaultKinds,
     const parser::CookedSource *cooked = nullptr);
 
-/// get the burnside bridge singleton
-BurnsideBridge &getBridge();
-
 }  // Fortran::burnside
 
 #endif  // FORTRAN_BURNSIDE_BRIDGE_H_
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index a717b95850b9..fe517f559513 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -17,6 +17,7 @@
 #include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
 #include "fir/FIRType.h"
+#include "fir/InternalNames.h"
 #include "fir/KindMapping.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
@@ -1951,6 +1952,9 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
 struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
+  LLVMIRLoweringPass(L::StringRef outputName, NameMangler &mangler)
+      : outputName{outputName}, mangler{mangler} {}
+
   void runOnModule() override {
     if (ClDisableLLVM)
       return;
@@ -1970,14 +1974,13 @@ struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
     signalPassFailure();
   }
 
-  void setOutputName(L::StringRef output) { outputName = output; }
-
 private:
   void genDispatchTableMap() {
     // TODO
   }
 
   L::StringRef outputName;
+  NameMangler &mangler;
 };
 
 } // namespace
@@ -1986,8 +1989,8 @@ std::unique_ptr<M::Pass> fir::createFIRToLLVMPass() {
   return std::make_unique<FIRToLLVMLoweringPass>();
 }
 
-std::unique_ptr<M::Pass> fir::createLLVMDialectToLLVMPass(L::StringRef output) {
-  auto pass = std::make_unique<LLVMIRLoweringPass>();
-  pass->setOutputName(output);
-  return pass;
+std::unique_ptr<M::Pass>
+fir::createLLVMDialectToLLVMPass(L::StringRef output,
+                                 fir::NameMangler &nameMangler) {
+  return std::make_unique<LLVMIRLoweringPass>(output, nameMangler);
 }
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index 58e011fb18ed..3366006bfe55 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -12,30 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
-
-add_executable(bbc
-  bbc.cc
-)
-
 set(LIBS
   FIR
-  FIRTransforms
   MLIRAffineOps
   MLIRLLVMIR
   MLIRLoopOps
   MLIRStandardOps
 )
 
-whole_archive_link(bbc ${LIBS})
-target_link_libraries(bbc
+add_llvm_library(FirBbcLib bbc.cc)
+target_link_libraries(FirBbcLib ${LIBS} FIRTransforms)
+
+set(EXE_LIBS
+  ${LIBS}
+  FIRTransforms
   FortranCommon
   FortranParser
   FortranEvaluate
   FortranSemantics
   FortranBurnside
-  FIRTransforms
-  ${LIBS}
 )
 
-install(TARGETS bbc DESTINATION bin)
+add_llvm_tool(bbc bbc.cc)
+llvm_update_compile_flags(bbc)
+whole_archive_link(bbc ${LIBS})
+target_link_libraries(bbc PRIVATE FIR MLIRIR FirBbcLib ${EXE_LIBS} LLVMSupport)
diff --git a/tools/bbc/bbc.cc b/tools/bbc/bbc.cc
index 1cc749a6d23b..4ac7de37e0f3 100644
--- a/tools/bbc/bbc.cc
+++ b/tools/bbc/bbc.cc
@@ -14,16 +14,12 @@
 
 // Temporary Fortran front end driver main program for development scaffolding.
 
-#include "fir/FIRDialect.h"
-#include "fir/Tilikum/Tilikum.h"
-#include "fir/Transforms/Passes.h"
-#include "fir/Transforms/StdConverter.h"
 #include "../../lib/burnside/bridge.h"
 #include "../../lib/burnside/convert-expr.h"
+#include "../../lib/common/Fortran-features.h"
 #include "../../lib/common/default-kinds.h"
 #include "../../lib/parser/characters.h"
 #include "../../lib/parser/dump-parse-tree.h"
-#include "../../lib/common/Fortran-features.h"
 #include "../../lib/parser/message.h"
 #include "../../lib/parser/parse-tree-visitor.h"
 #include "../../lib/parser/parse-tree.h"
@@ -33,6 +29,11 @@
 #include "../../lib/semantics/expression.h"
 #include "../../lib/semantics/semantics.h"
 #include "../../lib/semantics/unparse-with-symbols.h"
+#include "fir/FIRDialect.h"
+#include "fir/InternalNames.h"
+#include "fir/Tilikum/Tilikum.h"
+#include "fir/Transforms/Passes.h"
+#include "fir/Transforms/StdConverter.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
@@ -267,10 +268,11 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   }
 
   // MLIR+FIR
-  Br::instantiateBurnsideBridge(
+  fir::NameMangler nameMangler;
+  auto burnside = Br::getBurnsideBridge(
       semanticsContext.defaultKinds(), &parsing.cooked());
-  Br::crossBurnsideBridge(Br::getBridge(), parseTree);
-  mlir::ModuleOp mlirModule{Br::getBridge().getModule()};
+  Br::crossBurnsideBridge(burnside, parseTree, nameMangler);
+  mlir::ModuleOp mlirModule{burnside.getModule()};
   mlir::PassManager pm{mlirModule.getContext()};
   if (driver.dumpHLFIR) {
     llvm::errs() << ";== 1 ==\n";
@@ -286,7 +288,7 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
     pm.addPass(fir::createFIRToLLVMPass());
   }
   if (driver.lowerToLLVMIR) {
-    pm.addPass(fir::createLLVMDialectToLLVMPass("a.ll"));
+    pm.addPass(fir::createLLVMDialectToLLVMPass("a.ll", nameMangler));
   }
   if (mlir::succeeded(pm.run(mlirModule))) {
     if (driver.dumpFIR) {
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 3e2ae6844ea4..4c927d8548c3 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -14,33 +14,33 @@
 
 set(LIBS
   FIR
-  FIRTransforms
-  MLIRAffineToStandard
-  MLIRAnalysis
+  MLIRAffineOps
   MLIRLLVMIR
-  MLIRParser
-  MLIRPass
-  MLIRTransforms
-  MLIRSupport
+  MLIRLoopOps
+  MLIRStandardOps
 )
 
 add_llvm_library(FirTcoLib tco.cpp)
-target_link_libraries(FirTcoLib ${LIBS})
+target_link_libraries(FirTcoLib ${LIBS} FIRTransforms)
 
 set(EXE_LIBS
   ${LIBS}
-  MLIRAffineOps
+  FIRTransforms
+  MLIRAffineToStandard
+  MLIRAnalysis
   MLIRLoopToStandard
   MLIREDSC
   MLIRLinalg
-  MLIRLoopOps
-  MLIRStandardOps
+  MLIRParser
+  MLIRPass
   MLIRStandardToLLVM
+  MLIRSupport
+  MLIRTransforms
   MLIRVectorOps
   MLIRVectorToLLVM
 )
 
 add_llvm_tool(tco tco.cpp)
 llvm_update_compile_flags(tco)
-whole_archive_link(tco ${EXE_LIBS})
+whole_archive_link(tco ${LIBS})
 target_link_libraries(tco PRIVATE FIR MLIRIR FirTcoLib ${EXE_LIBS} LLVMSupport)
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index b524dd31aa1f..1ce63241f2e0 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "fir/FIRDialect.h"
+#include "fir/InternalNames.h"
 #include "fir/Tilikum/Tilikum.h"
 #include "fir/Transforms/Passes.h"
 #include "fir/Transforms/StdConverter.h"
@@ -66,6 +67,7 @@ int compileFIR() {
   owningRef->dump();
 
   // run passes
+  fir::NameMangler mangler;
   mlir::PassManager pm{context.get()};
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
@@ -77,7 +79,7 @@ int compileFIR() {
   // convert loop dialect to standard
   pm.addPass(mlir::createLowerToCFGPass());
   pm.addPass(fir::createFIRToLLVMPass());
-  pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput));
+  pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput, mangler));
   if (mlir::succeeded(pm.run(*owningRef))) {
     errs() << ";== output ==\n";
     owningRef->dump();

From 93dc0fa6f7498bd8c8f4a7376a6217ae1d77d4a4 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 20 Nov 2019 10:40:39 -0800
Subject: [PATCH 128/345] simplify syntax for alloca and allocmem

lowering of fir.where operation
name mangling threading
build thin ast
interface cleanup
---
 include/fir/FIROps.td              |  61 ++--
 include/fir/Tilikum/Tilikum.h      |   4 +-
 lib/burnside/CMakeLists.txt        |   1 +
 lib/burnside/ast-builder.cc        | 445 +++++++++++++++++++++++++++++
 lib/burnside/ast-builder.h         | 250 ++++++++++++++++
 lib/burnside/bridge.cc             |  16 +-
 lib/burnside/bridge.h              |  15 +-
 lib/burnside/flattened.cc          |  26 --
 lib/fir/FIROps.cpp                 |  21 +-
 lib/fir/Tilikum.cpp                |  52 ++--
 lib/fir/Transforms/RewriteLoop.cpp |  45 +--
 test/fir/alloc.fir                 |   8 +-
 test/fir/arrayset.fir              |  16 ++
 test/fir/fir-ops.fir               |  12 +-
 test/fir/loop.fir                  |  11 +
 tools/bbc/bbc.cc                   |   8 +-
 tools/tco/tco.cpp                  |   4 +-
 17 files changed, 853 insertions(+), 142 deletions(-)
 create mode 100644 lib/burnside/ast-builder.cc
 create mode 100644 lib/burnside/ast-builder.h
 create mode 100644 test/fir/arrayset.fir
 create mode 100644 test/fir/loop.fir

diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
index aa7faa89deb9..981201b83be2 100644
--- a/include/fir/FIROps.td
+++ b/include/fir/FIROps.td
@@ -211,9 +211,13 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
         parser.resolveOperands(operands, builder.getIndexType(),
             parser.getNameLoc(), result.operands))
       return M::failure();
-    M::Type restype;
+    M::Type restype = wrapResultType(intype);
+    if (!restype) {
+      parser.emitError(parser.getNameLoc(), "invalid allocate type: ")
+          << intype;
+      return M::failure();
+    }
     if (parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(restype) ||
         parser.addTypeToList(restype, result.types))
       return M::failure();
     return M::success();
@@ -231,10 +235,9 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
       p.printOperand(sh);
     }
     p.printOptionalAttrDict(getAttrs(), {"in_type", lenpName()});
-    p << " : " << getType();
   }];
 
-  let extraClassDeclaration = [{
+  string extraAllocClassDeclaration = [{
     constexpr static llvm::StringRef lenpName() { return "len_param_count"; }
     mlir::Type getAllocatedType();
     bool hasLenParams() { return bool{getAttr(lenpName())}; }
@@ -264,19 +267,21 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
     object has an undefined state.  The allocation can be given an optional
     name.  The allocation may have a dynamic repetition count for allocating
     a sequence of locations for the specified type.
+
+      %0 = fir.alloca f32
+      %1 = fir.call @foo(%0) : (!fir.ref<f32>) -> i32
   }];
 
   let verifier = [{
-    M::Type inType = getAttrOfType<M::TypeAttr>("in_type").getValue();
     M::Type outType = getType();
-    if (auto ref = outType.dyn_cast<fir::ReferenceType>()) {
-      if (inType != ref.getEleTy())
-        return emitOpError("input type and !fir.ref element type mismatch");
-    } else {
+    if (!outType.dyn_cast<fir::ReferenceType>())
       return emitOpError("must be a !fir.ref type");
-    }
     return M::success();
   }];
+
+  let extraClassDeclaration = extraAllocClassDeclaration#[{
+    static mlir::Type wrapResultType(mlir::Type intype);
+  }];
 }
 
 def fir_LoadOp : fir_OneResultOp<"load", []>,
@@ -399,19 +404,21 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
     given type, T.  The heap refernce returned has type `!fir.heap<T>`.
     The memory object is in an undefined state.  `allocmem` operations must
     be paired with `freemem` operations to avoid memory leaks.
+
+      %0 = fir.allocmem !fir.array<10xf32>
+      fir.freemem %0 : !fir.heap<!fir.array<10xf32>>
   }];
 
   let verifier = [{
-    M::Type inType = getAttrOfType<M::TypeAttr>("in_type").getValue();
     M::Type outType = getType();
-    if (auto ref = outType.dyn_cast<fir::HeapType>()) {
-      if (inType != ref.getEleTy())
-        return emitOpError("input type and !fir.heap element type mismatch");
-    } else {
+    if (!outType.dyn_cast<fir::HeapType>())
       return emitOpError("must be a !fir.heap type");
-    }
     return M::success();
   }];
+
+  let extraClassDeclaration = extraAllocClassDeclaration#[{
+    static mlir::Type wrapResultType(mlir::Type intype);
+  }];
 }
 
 def fir_FreeMemOp : fir_Op<"freemem", []>,
@@ -422,7 +429,11 @@ def fir_FreeMemOp : fir_Op<"freemem", []>,
     Deallocates a heap memory reference that was allocated by an `allocmem`.
     The memory object that is deallocated is placed in an undefined state
     after `fir.freemem`.  Optimizations may treat the loading of an object
-    in the undefined state as undefined behavior.
+    in the undefined state as undefined behavior.  This includes aliasing
+    references, such as the result of an `fir.embox`.
+
+      %0 = fir.allocmem !fir.array<10xf32>
+      fir.freemem %0 : !fir.heap<!fir.array<10xf32>>
   }];
 
   let parser = [{
@@ -440,7 +451,7 @@ def fir_FreeMemOp : fir_Op<"freemem", []>,
     p << getOperationName() << ' ';
     p.printOperand(heapref());
     p.printOptionalAttrDict(getAttrs(), {});
-    p << " : " << getOperand()->getType();    
+    p << " : " << getOperand()->getType();
   }];
 }
 
@@ -1256,7 +1267,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
     lowered into exact offsets when the layout of a Fortran derived type is
     known at compile-time. The type of a field value is `!fir.field` and
     these values can be used with the `fir.coordinate_of`, `fir.extract_value`,
-    or `fir.insert_value` instructions to compute (abstract) addresses of 
+    or `fir.insert_value` instructions to compute (abstract) addresses of
     subobjects.
   }];
 
@@ -1323,7 +1334,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
   }];
 }
 
-def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>, 
+def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>,
     Arguments<(ins Variadic<AnyIntegerType>:$triples)> {
   let summary = "generate a value of type `!fir.dims`";
 
@@ -1515,9 +1526,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     void setStep(mlir::Value *step) {
       getOperation()->setOperand(2, step);
     }
-    static char const* getStepKeyword() {
-      return "step";
-    }
+    static char const* getStepKeyword() { return "step"; }
   }];
 }
 
@@ -1626,7 +1635,7 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
     return M::success();
   }];
 
-  let printer = [{ 
+  let printer = [{
     p << getOperationName() << ' ' << getAttr("method") << '(';
     p.printOperand(object());
     if (arg_operand_begin() != arg_operand_end()) {
@@ -1959,7 +1968,7 @@ def fir_GlobalEntryOp : fir_Op<"global_entry", []>,
     result.addAttribute("in_type", M::TypeAttr::get(type));
     return M::success();
   }];
-  let printer = [{ 
+  let printer = [{
     p << getOperationName() << ' ' << getAttr("field") << ", ";
     p.printOperand(constant());
     p.printOptionalAttrDict(getAttrs(), {"in_type", "field"});
@@ -1995,7 +2004,7 @@ def fir_DTEntryOp : fir_Op<"dt_entry", []>,
       return M::failure();
     return M::success();
   }];
-  let printer = [{ 
+  let printer = [{
     p << getOperationName() << ' ' << getAttr("method") << ", "
       << getAttr("proc");
   }];
diff --git a/include/fir/Tilikum/Tilikum.h b/include/fir/Tilikum/Tilikum.h
index 25d8205a491c..a2c8571fdaf5 100644
--- a/include/fir/Tilikum/Tilikum.h
+++ b/include/fir/Tilikum/Tilikum.h
@@ -29,11 +29,11 @@ namespace fir {
 struct NameMangler;
 
 /// Convert FIR to the LLVM IR dialect
-std::unique_ptr<mlir::Pass> createFIRToLLVMPass();
+std::unique_ptr<mlir::Pass> createFIRToLLVMPass(NameMangler &mangler);
 
 /// Convert the LLVM IR dialect to LLVM-IR proper
 std::unique_ptr<mlir::Pass>
-createLLVMDialectToLLVMPass(llvm::StringRef output, NameMangler &mangler);
+createLLVMDialectToLLVMPass(llvm::StringRef output);
 
 } // namespace fir
 
diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
index 9a7e83937775..1d9ef68e3af7 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/burnside/CMakeLists.txt
@@ -15,6 +15,7 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
 
 add_library(FortranBurnside
+  ast-builder.cc
   bridge.cc
   builder.cc
   convert-expr.cc
diff --git a/lib/burnside/ast-builder.cc b/lib/burnside/ast-builder.cc
new file mode 100644
index 000000000000..f222622f4299
--- /dev/null
+++ b/lib/burnside/ast-builder.cc
@@ -0,0 +1,445 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ast-builder.h"
+#include "../parser/parse-tree-visitor.h"
+#include <cassert>
+#include <utility>
+
+/// Build an light-weight AST to help with lowering to FIR.  The AST will
+/// capture pointers back into the parse tree, so the parse tree data structure
+/// may <em>not</em> be changed between the construction of the AST and all of
+/// its uses.
+///
+/// The AST captures a structured view of the program.  The program is a list of
+/// units.  Function like units will contain lists of evaluations.  Evaluations
+/// are either statements or constructs, where a construct contains a list of
+/// evaluations.  The resulting AST structure can then be used to create FIR.
+
+namespace Br = Fortran::burnside;
+namespace Co = Fortran::common;
+namespace Pa = Fortran::parser;
+
+using namespace Fortran;
+using namespace Br;
+
+namespace {
+
+/// The instantiation of a parse tree visitor (Pre and Post) is extremely
+/// expensive in terms of compile and link time, so one goal here is to limit
+/// the bridge to one such instantiation.
+class ASTBuilder {
+public:
+  ASTBuilder() = default;
+
+  /// Get the result
+  AST::Program result() { return pgm; }
+
+  template<typename A> constexpr bool Pre(const A &) { return true; }
+  template<typename A> constexpr void Post(const A &) {}
+
+  // Module like
+
+  bool Pre(const Pa::Module &x) { return enterModule(x); }
+  bool Pre(const Pa::Submodule &x) { return enterModule(x); }
+
+  void Post(const Pa::Module &) { exitModule(); }
+  void Post(const Pa::Submodule &) { exitModule(); }
+
+  // Function like
+
+  bool Pre(const Pa::MainProgram &x) { return enterFunc(x); }
+  bool Pre(const Pa::FunctionSubprogram &x) { return enterFunc(x); }
+  bool Pre(const Pa::SubroutineSubprogram &x) { return enterFunc(x); }
+  bool Pre(const Pa::SeparateModuleSubprogram &x) { return enterFunc(x); }
+
+  void Post(const Pa::MainProgram &) { exitFunc(); }
+  void Post(const Pa::FunctionSubprogram &) { exitFunc(); }
+  void Post(const Pa::SubroutineSubprogram &) { exitFunc(); }
+  void Post(const Pa::SeparateModuleSubprogram &) { exitFunc(); }
+
+  // Block data
+
+  void Post(const Pa::BlockData &x) {
+    AST::BlockDataUnit unit{x};
+    addUnit(unit);
+  }
+
+  // Evaluation
+
+  void Post(const Pa::Statement<Pa::ActionStmt> &s) {
+    addEval(makeEvalAction(s));
+  }
+  void Post(const Pa::Statement<Co::Indirection<Pa::FormatStmt>> &s) {
+    addEval(makeEvalIndirect(s));
+  }
+  void Post(const Pa::Statement<Co::Indirection<Pa::EntryStmt>> &s) {
+    addEval(makeEvalIndirect(s));
+  }
+  void Post(const Pa::Statement<Co::Indirection<Pa::DataStmt>> &s) {
+    addEval(makeEvalIndirect(s));
+  }
+  void Post(const Pa::Statement<Co::Indirection<Pa::NamelistStmt>> &s) {
+    addEval(makeEvalIndirect(s));
+  }
+
+  bool Pre(const Pa::AssociateConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::BlockConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::CaseConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::ChangeTeamConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::CriticalConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::DoConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::IfConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::SelectRankConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::SelectTypeConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::WhereConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::ForallConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::CompilerDirective &c) { return enterConstruct(c); }
+  bool Pre(const Pa::OpenMPConstruct &c) { return enterConstruct(c); }
+  bool Pre(const Pa::OmpEndLoopDirective &c) { return enterConstruct(c); }
+
+  void Post(const Pa::AssociateConstruct &) { exitConstruct(); }
+  void Post(const Pa::BlockConstruct &) { exitConstruct(); }
+  void Post(const Pa::CaseConstruct &) { exitConstruct(); }
+  void Post(const Pa::ChangeTeamConstruct &) { exitConstruct(); }
+  void Post(const Pa::CriticalConstruct &) { exitConstruct(); }
+  void Post(const Pa::DoConstruct &) { exitConstruct(); }
+  void Post(const Pa::IfConstruct &) { exitConstruct(); }
+  void Post(const Pa::SelectRankConstruct &) { exitConstruct(); }
+  void Post(const Pa::SelectTypeConstruct &) { exitConstruct(); }
+  void Post(const Pa::WhereConstruct &) { exitConstruct(); }
+  void Post(const Pa::ForallConstruct &) { exitConstruct(); }
+  void Post(const Pa::CompilerDirective &) { exitConstruct(); }
+  void Post(const Pa::OpenMPConstruct &) { exitConstruct(); }
+  void Post(const Pa::OmpEndLoopDirective &) { exitConstruct(); }
+
+private:
+  // ActionStmt has a couple of non-conforming cases, which get handled
+  // explicitly here.  The other cases use an Indirection, which we discard in
+  // the AST.
+  AST::Evaluation makeEvalAction(const Pa::Statement<Pa::ActionStmt> &s) {
+    return std::visit(
+        common::visitors{
+            [&](const Pa::ContinueStmt &x) {
+              return AST::Evaluation{x, s.source, s.label};
+            },
+            [&](const Pa::FailImageStmt &x) {
+              return AST::Evaluation{x, s.source, s.label};
+            },
+            [&](const auto &x) {
+              return AST::Evaluation{x.value(), s.source, s.label};
+            },
+        },
+        s.statement.u);
+  }
+
+  template<typename A>
+  AST::Evaluation makeEvalIndirect(const Pa::Statement<Co::Indirection<A>> &s) {
+    return AST::Evaluation{s.statement.value(), s.source, s.label};
+  }
+
+  // When we enter a function-like structure, we want to build a new unit and
+  // set the builder's cursors to point to it.
+  template<typename A> bool enterFunc(const A &f) {
+    AST::FunctionLikeUnit unit{f};
+    funclist = &unit.funcs;
+    pushEval(&unit.evals);
+    addFunc(unit);
+    return true;
+  }
+
+  void exitFunc() {
+    funclist = nullptr;
+    popEval();
+  }
+
+  // When we enter a construct structure, we want to build a new construct and
+  // set the builder's evaluation cursor to point to it.
+  template<typename A> bool enterConstruct(const A &c) {
+    AST::Evaluation con{c};
+    addEval(con);
+    pushEval(con.getConstructEvals());
+    return true;
+  }
+
+  void exitConstruct() { popEval(); }
+
+  // When we enter a module structure, we want to build a new module and
+  // set the builder's function cursor to point to it.
+  template<typename A> bool enterModule(const A &f) {
+    AST::ModuleLikeUnit unit{f};
+    funclist = &unit.funcs;
+    addUnit(unit);
+    return true;
+  }
+
+  void exitModule() { funclist = nullptr; }
+
+  template<typename A> void addUnit(const A &unit) {
+    pgm.units.emplace_back(unit);
+  }
+
+  template<typename A> void addFunc(const A &func) {
+    if (funclist)
+      funclist->emplace_back(func);
+    else
+      addUnit(func);
+  }
+
+  void addEval(const AST::Evaluation &eval) {
+    assert(funclist);
+    evallist.back()->emplace_back(eval);
+  }
+
+  void pushEval(std::list<AST::Evaluation> *eval) {
+    assert(funclist);
+    evallist.push_back(eval);
+  }
+
+  void popEval() {
+    assert(funclist);
+    evallist.pop_back();
+  }
+
+  AST::Program pgm;
+  std::list<AST::FunctionLikeUnit> *funclist{nullptr};
+  std::vector<std::list<AST::Evaluation> *> evallist;
+};
+
+template<typename A> constexpr bool hasErrLabel(const A &stmt) {
+  if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
+      std::is_same_v<A, Pa::WriteStmt>) {
+    for (const auto &control : stmt.controls) {
+      if (std::holds_alternative<Pa::ErrLabel>(control.u)) {
+        return true;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, Pa::WaitStmt> ||
+      std::is_same_v<A, Pa::OpenStmt> || std::is_same_v<A, Pa::CloseStmt> ||
+      std::is_same_v<A, Pa::BackspaceStmt> ||
+      std::is_same_v<A, Pa::EndfileStmt> || std::is_same_v<A, Pa::RewindStmt> ||
+      std::is_same_v<A, Pa::FlushStmt>) {
+    for (const auto &spec : stmt.v) {
+      if (std::holds_alternative<Pa::ErrLabel>(spec.u)) {
+        return true;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, Pa::InquireStmt>) {
+    for (const auto &spec : std::get<std::list<Pa::InquireSpec>>(stmt.u)) {
+      if (std::holds_alternative<Pa::ErrLabel>(spec.u)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+template<typename A> constexpr bool hasEorLabel(const A &stmt) {
+  if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
+      std::is_same_v<A, Pa::WriteStmt>) {
+    for (const auto &control : stmt.controls) {
+      if (std::holds_alternative<Pa::EorLabel>(control.u)) {
+        return true;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, Pa::WaitStmt>) {
+    for (const auto &waitSpec : stmt.v) {
+      if (std::holds_alternative<Pa::EorLabel>(waitSpec.u)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+template<typename A> constexpr bool hasEndLabel(const A &stmt) {
+  if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
+      std::is_same_v<A, Pa::WriteStmt>) {
+    for (const auto &control : stmt.controls) {
+      if (std::holds_alternative<Pa::EndLabel>(control.u)) {
+        return true;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<A, Pa::WaitStmt>) {
+    for (const auto &waitSpec : stmt.v) {
+      if (std::holds_alternative<Pa::EndLabel>(waitSpec.u)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool hasAltReturns(const Pa::CallStmt &callStmt) {
+  const auto &args{std::get<std::list<Pa::ActualArgSpec>>(callStmt.v.t)};
+  for (const auto &arg : args) {
+    const auto &actual{std::get<Pa::ActualArg>(arg.t)};
+    if (std::holds_alternative<Pa::AltReturnSpec>(actual.u)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/// Determine if `callStmt` has alternate returns and if so set `e` to be the
+/// origin of a switch-like control flow
+void altRet(
+    AST::Evaluation &e, const Pa::CallStmt *callStmt, AST::Evaluation *cstr) {
+  if (hasAltReturns(*callStmt)) {
+    e.setCFG(AST::CFGAnnotation::Switch, cstr);
+  }
+}
+
+template<typename A>
+void ioLabel(AST::Evaluation &e, const A *s, AST::Evaluation *cstr) {
+  if (hasErrLabel(*s) || hasEorLabel(*s) || hasEndLabel(*s)) {
+    e.setCFG(AST::CFGAnnotation::IoSwitch, cstr);
+  }
+}
+
+void annotateEvalListCFG(
+    std::list<AST::Evaluation> &evals, AST::Evaluation *cstr) {
+  bool nextIsTarget = false;
+  for (auto e : evals) {
+    e.isTarget = nextIsTarget;
+    nextIsTarget = false;
+    if (e.isConstruct()) {
+      annotateEvalListCFG(*e.getConstructEvals(), &e);
+      // assume that the entry and exit are both possible branch targets
+      e.isTarget = nextIsTarget = true;
+      continue;
+    }
+    std::visit(
+        common::visitors{
+            [&](Pa::BackspaceStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::CallStmt *s) { altRet(e, s, cstr); },
+            [&](Pa::CloseStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::CycleStmt *) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
+            [&](Pa::EndfileStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::ExitStmt *) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
+            [&](Pa::FailImageStmt *) {
+              e.setCFG(AST::CFGAnnotation::Return, cstr);
+            },
+            [&](Pa::FlushStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::GotoStmt *) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
+            [&](Pa::IfStmt *) { e.setCFG(AST::CFGAnnotation::CondGoto, cstr); },
+            [&](Pa::InquireStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::OpenStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::ReadStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::ReturnStmt *) {
+              e.setCFG(AST::CFGAnnotation::Return, cstr);
+            },
+            [&](Pa::RewindStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::StopStmt *) { e.setCFG(AST::CFGAnnotation::Return, cstr); },
+            [&](Pa::WaitStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::WriteStmt *s) { ioLabel(e, s, cstr); },
+            [&](Pa::ArithmeticIfStmt *) {
+              e.setCFG(AST::CFGAnnotation::Switch, cstr);
+            },
+            [&](Pa::AssignedGotoStmt *) {
+              e.setCFG(AST::CFGAnnotation::IndGoto, cstr);
+            },
+            [&](Pa::ComputedGotoStmt *) {
+              e.setCFG(AST::CFGAnnotation::Switch, cstr);
+            },
+            [](auto *) { /* do nothing */ },
+        },
+        e.u);
+    if (e.isActionStmt &&
+        std::get<std::optional<parser::Label>>(
+            std::get<AST::Evaluation::StmtExtra>(e.ux))
+            .has_value()) {
+      e.isTarget = true;
+    }
+  }
+}
+
+inline void annotateFuncCFG(AST::FunctionLikeUnit &flu) {
+  annotateEvalListCFG(flu.evals, nullptr);
+}
+
+}  // namespace
+
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::MainProgram &f)
+  : ProgramUnit{&f} {
+  auto &ps{std::get<std::optional<Pa::Statement<Pa::ProgramStmt>>>(f.t)};
+  if (ps.has_value()) {
+    const Pa::Statement<Pa::ProgramStmt> &s{ps.value()};
+    funStmts.push_back(&s);
+  }
+  funStmts.push_back(&std::get<Pa::Statement<Pa::EndProgramStmt>>(f.t));
+}
+
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::FunctionSubprogram &f)
+  : ProgramUnit{&f} {
+  funStmts.push_back(&std::get<Pa::Statement<Pa::FunctionStmt>>(f.t));
+  funStmts.push_back(&std::get<Pa::Statement<Pa::EndFunctionStmt>>(f.t));
+}
+
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::SubroutineSubprogram &f)
+  : ProgramUnit{&f} {
+  funStmts.push_back(&std::get<Pa::Statement<Pa::SubroutineStmt>>(f.t));
+  funStmts.push_back(&std::get<Pa::Statement<Pa::EndSubroutineStmt>>(f.t));
+}
+
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(
+    const Pa::SeparateModuleSubprogram &f)
+  : ProgramUnit{&f} {
+  funStmts.push_back(&std::get<Pa::Statement<Pa::MpSubprogramStmt>>(f.t));
+  funStmts.push_back(&std::get<Pa::Statement<Pa::EndMpSubprogramStmt>>(f.t));
+}
+
+Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Module &m) : ProgramUnit{&m} {
+  modStmts.push_back(&std::get<Pa::Statement<Pa::ModuleStmt>>(m.t));
+  modStmts.push_back(&std::get<Pa::Statement<Pa::EndModuleStmt>>(m.t));
+}
+
+Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Submodule &m)
+  : ProgramUnit{&m} {
+  modStmts.push_back(&std::get<Pa::Statement<Pa::SubmoduleStmt>>(m.t));
+  modStmts.push_back(&std::get<Pa::Statement<Pa::EndSubmoduleStmt>>(m.t));
+}
+
+Br::AST::BlockDataUnit::BlockDataUnit(const Pa::BlockData &db)
+  : ProgramUnit{&db} {}
+
+AST::Program Br::createAST(const Pa::Program &root) {
+  ASTBuilder walker;
+  Walk(root, walker);
+  return walker.result();
+}
+
+void Br::annotateControl(AST::Program &ast) {
+  for (auto unit : ast.units) {
+    std::visit(common::visitors{
+                   [](AST::BlockDataUnit &) {},
+                   [](AST::FunctionLikeUnit &f) {
+                     annotateFuncCFG(f);
+                     for (auto s : f.funcs) {
+                       annotateFuncCFG(s);
+                     }
+                   },
+                   [](AST::ModuleLikeUnit &u) {
+                     for (auto f : u.funcs) {
+                       annotateFuncCFG(f);
+                     }
+                   },
+               },
+        unit);
+  }
+}
diff --git a/lib/burnside/ast-builder.h b/lib/burnside/ast-builder.h
new file mode 100644
index 000000000000..189f5b212729
--- /dev/null
+++ b/lib/burnside/ast-builder.h
@@ -0,0 +1,250 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_AST_BUILDER_H_
+#define FORTRAN_BURNSIDE_AST_BUILDER_H_
+
+#include "../parser/parse-tree.h"
+#include "../semantics/scope.h"
+
+namespace Fortran::burnside {
+namespace AST {
+
+enum class CFGAnnotation {
+  None,
+  Goto,
+  CondGoto,
+  IndGoto,
+  IoSwitch,
+  Switch,
+  Return
+};
+
+/// Function-like units can contains lists of evaluations.  These can be
+/// (simple) statements or constructs, where a construct contains its own
+/// evaluations.
+struct Evaluation {
+  using EvalVariant = std::variant<const parser::AllocateStmt *,
+      const parser::AssignmentStmt *, const parser::BackspaceStmt *,
+      const parser::CallStmt *, const parser::CloseStmt *,
+      const parser::ContinueStmt *, const parser::CycleStmt *,
+      const parser::DeallocateStmt *, const parser::EndfileStmt *,
+      const parser::EventPostStmt *, const parser::EventWaitStmt *,
+      const parser::ExitStmt *, const parser::FailImageStmt *,
+      const parser::FlushStmt *, const parser::FormTeamStmt *,
+      const parser::GotoStmt *, const parser::IfStmt *,
+      const parser::InquireStmt *, const parser::LockStmt *,
+      const parser::NullifyStmt *, const parser::OpenStmt *,
+      const parser::PointerAssignmentStmt *, const parser::PrintStmt *,
+      const parser::ReadStmt *, const parser::ReturnStmt *,
+      const parser::RewindStmt *, const parser::StopStmt *,
+      const parser::SyncAllStmt *, const parser::SyncImagesStmt *,
+      const parser::SyncMemoryStmt *, const parser::SyncTeamStmt *,
+      const parser::UnlockStmt *, const parser::WaitStmt *,
+      const parser::WhereStmt *, const parser::WriteStmt *,
+      const parser::ComputedGotoStmt *, const parser::ForallStmt *,
+      const parser::ArithmeticIfStmt *, const parser::AssignStmt *,
+      const parser::AssignedGotoStmt *, const parser::PauseStmt *,
+      const parser::FormatStmt *, const parser::EntryStmt *,
+      const parser::DataStmt *, const parser::NamelistStmt *,
+      const parser::AssociateConstruct *, const parser::BlockConstruct *,
+      const parser::CaseConstruct *, const parser::ChangeTeamConstruct *,
+      const parser::CriticalConstruct *, const parser::DoConstruct *,
+      const parser::IfConstruct *, const parser::SelectRankConstruct *,
+      const parser::SelectTypeConstruct *, const parser::WhereConstruct *,
+      const parser::ForallConstruct *, const parser::CompilerDirective *,
+      const parser::OpenMPConstruct *, const parser::OmpEndLoopDirective *>;
+  using StmtExtra = std::tuple<parser::CharBlock, std::optional<parser::Label>>;
+
+  Evaluation() = delete;
+
+  /// Statement ctor
+  template<typename A>
+  Evaluation(const A &a, const parser::CharBlock &pos,
+      const std::optional<parser::Label> &lab)
+    : u{&a}, ux{StmtExtra{pos, lab}} {
+    static_assert(!isConstruct(a) && "must be a statement");
+    if constexpr (isAction(a)) {
+      isActionStmt = true;
+    }
+    if constexpr (isAction(a) || isOther(a)) {
+      isStatement = true;
+    }
+  }
+
+  /// Construct ctor
+  template<typename A>
+  Evaluation(const A &a) : u{&a}, ux{std::list<Evaluation>{}} {
+    static_assert(isConstruct(a) && "must be a construct");
+  }
+
+  /// statements that are executable (actions)
+  template<typename A> constexpr static bool isAction(const A &a) {
+    if constexpr (!isConstruct(a) && !isOther(a)) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /// constructs (and directives)
+  template<typename A> constexpr static bool isConstruct(const A &) {
+    if constexpr (std::is_same_v<A, parser::AssociateConstruct> ||
+        std::is_same_v<A, parser::BlockConstruct> ||
+        std::is_same_v<A, parser::CaseConstruct> ||
+        std::is_same_v<A, parser::ChangeTeamConstruct> ||
+        std::is_same_v<A, parser::CriticalConstruct> ||
+        std::is_same_v<A, parser::DoConstruct> ||
+        std::is_same_v<A, parser::IfConstruct> ||
+        std::is_same_v<A, parser::SelectRankConstruct> ||
+        std::is_same_v<A, parser::SelectTypeConstruct> ||
+        std::is_same_v<A, parser::WhereConstruct> ||
+        std::is_same_v<A, parser::ForallConstruct> ||
+        std::is_same_v<A, parser::CompilerDirective> ||
+        std::is_same_v<A, parser::OpenMPConstruct> ||
+        std::is_same_v<A, parser::OmpEndLoopDirective>) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /// statements that are not executable
+  template<typename A> constexpr static bool isOther(const A &) {
+    if constexpr (std::is_same_v<A, parser::FormatStmt> ||
+        std::is_same_v<A, parser::EntryStmt> ||
+        std::is_same_v<A, parser::DataStmt> ||
+        std::is_same_v<A, parser::NamelistStmt>) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  constexpr bool isStmt() const { return isStatement; }
+  constexpr bool isConstruct() const { return !isStmt(); }
+
+  /// Set the type of originating control flow type for this evaluation.
+  void setCFG(CFGAnnotation a, Evaluation *cstr) {
+    cfg = a;
+    setBranches(cstr);
+  }
+
+  /// Is this evaluation a control-flow origin? (The AST must be annotated)
+  bool isControlOrigin() const { return cfg != CFGAnnotation::None; }
+
+  /// Is this evaluation a control-flow target? (The AST must be annotated)
+  bool isControlTarget() const { return isTarget; }
+
+  /// Set the hasBranches flag iff this evaluation (a construct) contains
+  /// control flow
+  void setBranches() { hasBranches = true; }
+
+  constexpr std::list<Evaluation> *getConstructEvals() {
+    return isStatement ? nullptr : std::get_if<std::list<Evaluation>>(&ux);
+  }
+
+  /// Set that the construct `cstr` (if not a nullptr) has branches.
+  static void setBranches(Evaluation *cstr) {
+    if (cstr) {
+      cstr->setBranches();
+    }
+  }
+
+  EvalVariant u;
+  std::variant<StmtExtra, std::list<Evaluation>> ux;
+  CFGAnnotation cfg{CFGAnnotation::None};
+  bool isStatement{false};
+  bool isActionStmt{false};
+  bool isTarget{false};
+  bool hasBranches{false};
+};
+
+/// A program is a list of program units.
+/// These units can be function like, module like, or block data
+struct ProgramUnit {
+  template<typename A> ProgramUnit(A *ptr) : p{ptr} {}
+
+  std::variant<const parser::MainProgram *, const parser::FunctionSubprogram *,
+      const parser::SubroutineSubprogram *, const parser::Module *,
+      const parser::Submodule *, const parser::SeparateModuleSubprogram *,
+      const parser::BlockData *>
+      p;
+};
+
+/// Function-like units have similar structure. They all can contain executable
+/// statements.
+struct FunctionLikeUnit : public ProgramUnit {
+  // wrapper statements for function-like syntactic structures
+  using FunctionStatement =
+      std::variant<const parser::Statement<parser::ProgramStmt> *,
+          const parser::Statement<parser::EndProgramStmt> *,
+          const parser::Statement<parser::FunctionStmt> *,
+          const parser::Statement<parser::EndFunctionStmt> *,
+          const parser::Statement<parser::SubroutineStmt> *,
+          const parser::Statement<parser::EndSubroutineStmt> *,
+          const parser::Statement<parser::MpSubprogramStmt> *,
+          const parser::Statement<parser::EndMpSubprogramStmt> *>;
+
+  FunctionLikeUnit(const parser::MainProgram &f);
+  FunctionLikeUnit(const parser::FunctionSubprogram &f);
+  FunctionLikeUnit(const parser::SubroutineSubprogram &f);
+  FunctionLikeUnit(const parser::SeparateModuleSubprogram &f);
+
+  const semantics::Scope *scope{nullptr};
+  std::list<FunctionStatement> funStmts;
+  std::list<Evaluation> evals;
+  std::list<FunctionLikeUnit> funcs;
+};
+
+/// Module-like units have similar structure. They all can contain a list of
+/// function-like units.
+struct ModuleLikeUnit : public ProgramUnit {
+  // wrapper statements for module-like syntactic structures
+  using ModuleStatement =
+      std::variant<const parser::Statement<parser::ModuleStmt> *,
+          const parser::Statement<parser::EndModuleStmt> *,
+          const parser::Statement<parser::SubmoduleStmt> *,
+          const parser::Statement<parser::EndSubmoduleStmt> *>;
+
+  ModuleLikeUnit(const parser::Module &m);
+  ModuleLikeUnit(const parser::Submodule &m);
+  ~ModuleLikeUnit() = default;
+
+  const semantics::Scope *scope{nullptr};
+  std::list<ModuleStatement> modStmts;
+  std::list<FunctionLikeUnit> funcs;
+};
+
+struct BlockDataUnit : public ProgramUnit {
+  BlockDataUnit(const parser::BlockData &db);
+};
+
+/// A Program is the top-level AST
+struct Program {
+  using Units = std::variant<FunctionLikeUnit, ModuleLikeUnit, BlockDataUnit>;
+  std::list<Units> units;
+};
+
+}  // namespace AST
+
+/// Create an AST from the parse tree
+AST::Program createAST(const parser::Program &root);
+
+/// Decorate the AST with control flow annotations
+void annotateControl(AST::Program &ast);
+
+}  // namespace burnside
+
+#endif  // FORTRAN_BURNSIDE_AST_BUILDER_H_
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index b79bcd3831ba..54853c7c21a5 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -1027,16 +1027,12 @@ void FIRConverter::translateRoutine(
 
 }  // namespace
 
-void Br::crossBurnsideBridge(
-    BurnsideBridge &bridge, const Pa::Program &prg, fir::NameMangler &mangler) {
-  FIRConverter converter{bridge};
+void Br::BurnsideBridge::lower(
+    const Pa::Program &prg, fir::NameMangler &mangler) {
+  FIRConverter converter{*this};
   Walk(prg, converter);
 }
 
-std::unique_ptr<llvm::Module> Br::LLVMBridge(M::ModuleOp &module) {
-  return M::translateModuleToLLVMIR(module);
-}
-
 void Br::BurnsideBridge::parseSourceFile(llvm::SourceMgr &srcMgr) {
   auto owningRef = M::parseSourceFile(srcMgr, context.get());
   module.reset(new M::ModuleOp(owningRef.get().getOperation()));
@@ -1051,9 +1047,3 @@ Br::BurnsideBridge::BurnsideBridge(
   module = std::make_unique<M::ModuleOp>(
       M::ModuleOp::create(M::UnknownLoc::get(context.get())));
 }
-
-BurnsideBridge Br::getBurnsideBridge(
-    const Co::IntrinsicTypeDefaultKinds &defaultKinds,
-    const Pa::CookedSource *cooked) {
-  return BurnsideBridge::create(defaultKinds, cooked);
-}
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index 00955159f8f0..58207be1a542 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -65,6 +65,9 @@ class BurnsideBridge {
 
   const parser::CookedSource *getCookedSource() const { return cooked; }
 
+  /// Cross the bridge from the Fortran parse-tree, etc. to FIR+OpenMP+MLIR
+  void lower(const parser::Program &program, fir::NameMangler &mangler);
+
 private:
   explicit BurnsideBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
       const parser::CookedSource *cooked);
@@ -77,18 +80,6 @@ class BurnsideBridge {
   std::unique_ptr<mlir::ModuleOp> module;
 };
 
-/// Cross the bridge from the Fortran parse-tree, etc. to FIR+OpenMP+MLIR
-void crossBurnsideBridge(BurnsideBridge &bridge, const parser::Program &program,
-    fir::NameMangler &mangler);
-
-/// Bridge from MLIR to LLVM-IR
-std::unique_ptr<llvm::Module> LLVMBridge(mlir::ModuleOp &module);
-
-/// Get an instance of the Burnside bridge
-BurnsideBridge getBurnsideBridge(
-    const common::IntrinsicTypeDefaultKinds &defaultKinds,
-    const parser::CookedSource *cooked = nullptr);
-
 }  // Fortran::burnside
 
 #endif  // FORTRAN_BURNSIDE_BRIDGE_H_
diff --git a/lib/burnside/flattened.cc b/lib/burnside/flattened.cc
index 0a5f6c91e9b2..54c0a9e8cc01 100644
--- a/lib/burnside/flattened.cc
+++ b/lib/burnside/flattened.cc
@@ -277,26 +277,6 @@ template<typename A, typename B> std::string GetSource(const B *s) {
   return GetSource(&std::get<parser::Statement<A>>(s->t));
 }
 
-static bool meetsBlockConstraints(const parser::Block &block) { return false; }
-
-static bool meetsLoopConstraints(const parser::DoConstruct &loop) {
-  return meetsBlockConstraints(std::get<parser::Block>(loop.t));
-}
-
-static bool meetsWhereConstraints(const parser::IfConstruct &w) {
-  // we can do better, but for now don't allow ELSE IF constructs
-  if (std::get<std::list<parser::IfConstruct::ElseIfBlock>>(w.t).empty()) {
-    const auto &optElse{
-        std::get<std::optional<parser::IfConstruct::ElseBlock>>(w.t)};
-    if (optElse.has_value() &&
-        !meetsBlockConstraints(std::get<parser::Block>(optElse->t))) {
-      return false;
-    }
-    return meetsBlockConstraints(std::get<parser::Block>(w.t));
-  }
-  return false;
-}
-
 void Op::Build(std::list<Op> &ops,
     const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
   std::visit(
@@ -504,9 +484,6 @@ struct ControlFlowAnalyzer {
   /// `DO` constructs can be lowered to `fir.loop` if they meet some
   /// constraints, otherwise they are lowered to a CFG.
   bool Pre(const parser::DoConstruct &construct) {
-    if (meetsLoopConstraints(construct)) {
-      // use `fir.loop`
-    }
     std::list<Op> ops;
     LabelOp backedgeLab{buildNewLabel()};
     LabelOp incrementLab{buildNewLabel()};
@@ -543,9 +520,6 @@ struct ControlFlowAnalyzer {
   /// `IF` constructs can be lowered to `fir.where` if they meet some
   /// constraints, otherwise they are lowered to a CFG.
   bool Pre(const parser::IfConstruct &construct) {
-    if (meetsWhereConstraints(construct)) {
-      // use `fir.where`
-    }
     std::list<Op> ops;
     LabelOp thenLab{buildNewLabel()};
     LabelOp elseLab{buildNewLabel()};
diff --git a/lib/fir/FIROps.cpp b/lib/fir/FIROps.cpp
index bdff4e57f8df..55e2da3cffee 100644
--- a/lib/fir/FIROps.cpp
+++ b/lib/fir/FIROps.cpp
@@ -29,21 +29,38 @@ namespace fir {
 // AllocaOp
 
 M::Type AllocaOp::getAllocatedType() {
-  // return getAttrOfType<M::TypeAttr>("in_type").getType();
   return getType().cast<ReferenceType>().getEleTy();
 }
 
+/// Create a legal memory reference as return type
+M::Type AllocaOp::wrapResultType(M::Type intype) {
+  // FIR semantics: memory references to memory references are disallowed
+  if (intype.dyn_cast<ReferenceType>())
+    return {};
+  return ReferenceType::get(intype);
+}
+
 M::Type AllocaOp::getRefTy(M::Type ty) { return ReferenceType::get(ty); }
 
 // AllocMemOp
 
 M::Type AllocMemOp::getAllocatedType() {
-  // return getAttrOfType<M::TypeAttr>("in_type").getType();
   return getType().cast<HeapType>().getEleTy();
 }
 
 M::Type AllocMemOp::getRefTy(M::Type ty) { return HeapType::get(ty); }
 
+/// Create a legal heap reference as return type
+M::Type AllocMemOp::wrapResultType(M::Type intype) {
+  // Fortran semantics: C852 an entity cannot be both ALLOCATABLE and POINTER
+  // 8.5.3 note 1 prohibits ALLOCATABLE procedures as well
+  // FIR semantics: one may not allocate a memory reference value
+  if (intype.dyn_cast<ReferenceType>() || intype.dyn_cast<HeapType>() ||
+      intype.dyn_cast<PointerType>() || intype.dyn_cast<FunctionType>())
+    return {};
+  return HeapType::get(intype);
+}
+
 // BoxDimsOp
 
 /// Get the result types packed in a tuple tuple
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index fe517f559513..f97f1ca00bca 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -78,8 +78,8 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
   static L::StringMap<M::LLVM::LLVMType> identStructCache;
 
 public:
-  FIRToLLVMTypeConverter(M::MLIRContext *context)
-      : LLVMTypeConverter(context), kindMapping(context) {}
+  FIRToLLVMTypeConverter(M::MLIRContext *context, NameMangler &mangler)
+      : LLVMTypeConverter(context), kindMapping(context), mangler(mangler) {}
 
   // This returns the type of a single column. Rows are added by the caller.
   // fir.dims<r>  -->  llvm<"[r x [3 x i64]]">
@@ -310,6 +310,8 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
                 "conversion resulted in a non-LLVM type");
     return wrappedLLVMType;
   }
+
+  NameMangler &mangler;
 };
 
 // instantiate static data member
@@ -721,7 +723,6 @@ struct ConstantOpConversion : public FIROpConversion<fir::ConstantOp> {
     auto attr = constop.getValue();
     auto attr_ = attr.cast<M::StringAttr>();
     if (auto ft = ty_.dyn_cast<fir::RealType>()) {
-      auto kind = ft.getFKind();
       L::APFloat f{L::APFloat::IEEEdouble(), attr_.getValue()};
       attr = M::FloatAttr::get(M::FloatType::getF64(constop.getContext()), f);
     }
@@ -1902,12 +1903,14 @@ struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
 /// This pass lowers all FIR dialect operations to LLVM IR dialect.  An
 /// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
 struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
+  FIRToLLVMLoweringPass(NameMangler &mangler) : mangler{mangler} {}
+
   void runOnModule() override {
     if (ClDisableFirToLLVMIR)
       return;
 
-    auto &context{getContext()};
-    FIRToLLVMTypeConverter typeConverter{&context};
+    auto *context{&getContext()};
+    FIRToLLVMTypeConverter typeConverter{context, mangler};
     M::OwningRewritePatternList patterns;
     patterns.insert<
         AddcOpConversion, AddfOpConversion, AddrOfOpConversion,
@@ -1929,9 +1932,9 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
         SelectTypeOpConversion, StoreOpConversion, SubcOpConversion,
         SubfOpConversion, UnboxCharOpConversion, UnboxOpConversion,
         UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion>(
-        &context, typeConverter);
+        context, typeConverter);
     M::populateStdToLLVMConversionPatterns(typeConverter, patterns);
-    M::ConversionTarget target{context};
+    M::ConversionTarget target{*context};
     target.addLegalDialect<M::LLVM::LLVMDialect>();
 
     // required NOP stubs for applying a full conversion
@@ -1940,27 +1943,36 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
     target.addDynamicallyLegalOp<M::ModuleTerminatorOp>(
         [&](M::ModuleTerminatorOp) { return true; });
 
+    genDispatchTableMap();
+
     // apply the patterns
     if (M::failed(M::applyFullConversion(
             getModule(), target, std::move(patterns), &typeConverter))) {
-      M::emitError(M::UnknownLoc::get(&context),
+      M::emitError(M::UnknownLoc::get(context),
                    "error in converting to LLVM-IR dialect\n");
       signalPassFailure();
     }
   }
+
+private:
+  void genDispatchTableMap() {
+    for (auto dt : getModule().getOps<DispatchTableOp>()) {
+      // FIXME
+      (void)dt;
+    }
+  }
+
+  NameMangler &mangler;
 };
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
 struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
-  LLVMIRLoweringPass(L::StringRef outputName, NameMangler &mangler)
-      : outputName{outputName}, mangler{mangler} {}
+  LLVMIRLoweringPass(L::StringRef outputName) : outputName{outputName} {}
 
   void runOnModule() override {
     if (ClDisableLLVM)
       return;
 
-    genDispatchTableMap();
-
     if (auto llvmModule{M::translateModuleToLLVMIR(getModule())}) {
       std::error_code ec;
       L::raw_fd_ostream stream(outputName, ec, L::sys::fs::F_None);
@@ -1975,22 +1987,16 @@ struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
   }
 
 private:
-  void genDispatchTableMap() {
-    // TODO
-  }
-
   L::StringRef outputName;
-  NameMangler &mangler;
 };
 
 } // namespace
 
-std::unique_ptr<M::Pass> fir::createFIRToLLVMPass() {
-  return std::make_unique<FIRToLLVMLoweringPass>();
+std::unique_ptr<M::Pass>
+fir::createFIRToLLVMPass(fir::NameMangler &nameMangler) {
+  return std::make_unique<FIRToLLVMLoweringPass>(nameMangler);
 }
 
-std::unique_ptr<M::Pass>
-fir::createLLVMDialectToLLVMPass(L::StringRef output,
-                                 fir::NameMangler &nameMangler) {
-  return std::make_unique<LLVMIRLoweringPass>(output, nameMangler);
+std::unique_ptr<M::Pass> fir::createLLVMDialectToLLVMPass(L::StringRef output) {
+  return std::make_unique<LLVMIRLoweringPass>(output);
 }
diff --git a/lib/fir/Transforms/RewriteLoop.cpp b/lib/fir/Transforms/RewriteLoop.cpp
index 7f8a065a5857..8a06f16df986 100644
--- a/lib/fir/Transforms/RewriteLoop.cpp
+++ b/lib/fir/Transforms/RewriteLoop.cpp
@@ -92,22 +92,13 @@ class AffineDialectPromotion : public M::FunctionPass<AffineDialectPromotion> {
 // `fir.loop` operations.  These can be converted to `loop.for` operations. MLIR
 // includes a pass to lower `loop.for` operations to a CFG.
 
-template <typename FROM>
-class OpConversion : public M::ConversionPattern {
-public:
-  explicit OpConversion(M::MLIRContext *ctx)
-      : ConversionPattern(FROM::getOperationName(), 1, ctx) {}
-};
-
 /// Convert `fir.loop` to `loop.for`
-class LoopLoopConv : public OpConversion<LoopOp> {
+class LoopLoopConv : public M::OpRewritePattern<LoopOp> {
 public:
-  using OpConversion::OpConversion;
+  using OpRewritePattern::OpRewritePattern;
 
   M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, llvm::ArrayRef<M::Value *> operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto loop = M::cast<LoopOp>(op);
+  matchAndRewrite(LoopOp loop, M::PatternRewriter &rewriter) const override {
     auto *low = loop.lowerBound();
     auto *high = loop.upperBound();
     auto optStep = loop.optstep();
@@ -123,31 +114,41 @@ class LoopLoopConv : public OpConversion<LoopOp> {
     auto f = rewriter.create<M::loop::ForOp>(loc, low, high, step);
     f.region().getBlocks().clear();
     rewriter.inlineRegionBefore(loop.region(), f.region(), f.region().end());
-    rewriter.eraseOp(op);
+    rewriter.eraseOp(loop);
     return matchSuccess();
   }
 };
 
 /// Convert `fir.where` to `loop.if`
-class LoopWhereConv : public OpConversion<WhereOp> {
+class LoopWhereConv : public M::OpRewritePattern<WhereOp> {
 public:
-  using OpConversion::OpConversion;
+  using OpRewritePattern::OpRewritePattern;
 
   M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, llvm::ArrayRef<M::Value *> operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto where = M::cast<WhereOp>(op);
+  matchAndRewrite(WhereOp where, M::PatternRewriter &rewriter) const override {
+    auto loc = where.getLoc();
+    bool hasOtherRegion = !where.otherRegion().empty();
+    auto cond = where.condition();
+    auto ifOp = rewriter.create<M::loop::IfOp>(loc, cond, hasOtherRegion);
+    rewriter.inlineRegionBefore(where.whereRegion(), &ifOp.thenRegion().back());
+    ifOp.thenRegion().back().erase();
+    if (hasOtherRegion) {
+      rewriter.inlineRegionBefore(where.otherRegion(),
+                                  &ifOp.elseRegion().back());
+      ifOp.elseRegion().back().erase();
+    }
+    rewriter.eraseOp(where);
     return matchSuccess();
   }
 };
 
-class LoopFirEndConv : public OpConversion<FirEndOp> {
+/// Replace FirEndOp with TerminatorOp
+class LoopFirEndConv : public M::OpRewritePattern<FirEndOp> {
 public:
-  using OpConversion::OpConversion;
+  using OpRewritePattern::OpRewritePattern;
 
   M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, llvm::ArrayRef<M::Value *> operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
+  matchAndRewrite(FirEndOp op, M::PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<M::loop::TerminatorOp>(op);
     return matchSuccess();
   }
diff --git a/test/fir/alloc.fir b/test/fir/alloc.fir
index a1081c123a44..e7c0d663c128 100644
--- a/test/fir/alloc.fir
+++ b/test/fir/alloc.fir
@@ -1,21 +1,21 @@
 func @f1() -> !fir.ref<i32> {
-  %1 = fir.alloca i32 : !fir.ref<i32>
+  %1 = fir.alloca i32
   return %1 : !fir.ref<i32>
 }
 
 func @f2() -> !fir.ref<i32> {
   %0 = constant 100 : index
-  %1 = fir.alloca i32, %0 : !fir.ref<i32>
+  %1 = fir.alloca i32, %0
   return %1 : !fir.ref<i32>
 }
 
 func @f3() -> !fir.heap<i32> {
-  %1 = fir.allocmem i32 : !fir.heap<i32>
+  %1 = fir.allocmem i32
   return %1 : !fir.heap<i32>
 }
 
 func @f4() -> !fir.heap<i32> {
   %0 = constant 100 : index
-  %1 = fir.allocmem i32, %0 : !fir.heap<i32>
+  %1 = fir.allocmem i32, %0
   return %1 : !fir.heap<i32>
 }
diff --git a/test/fir/arrayset.fir b/test/fir/arrayset.fir
new file mode 100644
index 000000000000..2f45aabb0da7
--- /dev/null
+++ b/test/fir/arrayset.fir
@@ -0,0 +1,16 @@
+func @x(%arr : !fir.ref<!fir.array<10xf32>>) {
+  %1 = constant 0 : index
+  %2 = constant 9 : index
+  %a = fir.alloca !fir.array<10xf32>
+  fir.loop %iv = %1 to %2 unordered {
+    %3 = fir.coordinate_of %arr, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
+    %4 = fir.load %3 : !fir.ref<f32>
+    %5 = fir.coordinate_of %a, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
+    fir.store %4 to %5 : !fir.ref<f32>
+  } { arrayset }
+  %6 = fir.embox %a : (!fir.ref<!fir.array<10xf32>>) -> !fir.box<!fir.array<10xf32>>
+  fir.call @y(%6) : (!fir.box<!fir.array<10xf32>>) -> ()
+  return
+}
+
+func @y(!fir.box<!fir.array<10xf32>>) -> ()
diff --git a/test/fir/fir-ops.fir b/test/fir/fir-ops.fir
index 5f980f7406ac..686356add888 100644
--- a/test/fir/fir-ops.fir
+++ b/test/fir/fir-ops.fir
@@ -43,13 +43,13 @@ func @nop()
 func @get_func() -> (() -> ())
 
 func @instructions() {
-  %0 = fir.alloca !fir.array<10xi32> : !fir.ref<!fir.array<10xi32>>
+  %0 = fir.alloca !fir.array<10xi32>
   %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
-  %2 = fir.alloca i32 : !fir.ref<i32>
+  %2 = fir.alloca i32
   %3 = constant 22 : i32
   fir.store %3 to %2 : !fir.ref<i32>
   %4 = fir.undefined i32
-  %5 = fir.allocmem !fir.array<100xf32> : !fir.heap<!fir.array<100xf32>>
+  %5 = fir.allocmem !fir.array<100xf32>
   %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
   %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
   %c0 = constant 0 : index
@@ -91,15 +91,15 @@ func @instructions() {
 }
 
 func @boxing_match() {
-  %0 = fir.alloca i32 : !fir.ref<i32>
+  %0 = fir.alloca i32
   %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>
   %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.dims<0>)
   %c8 = constant 8 : i32
-  %3 = fir.alloca !fir.char<1> : !fir.ref<!fir.char<1>>
+  %3 = fir.alloca !fir.char<1>
   %b3 = fir.undefined !fir.char<1>
   %4 = fir.emboxchar %3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
   %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
-  %6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}> : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
+  %6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
   %a1 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
   %z = constant 0 : i32
   %c12 = constant 12 : i32
diff --git a/test/fir/loop.fir b/test/fir/loop.fir
new file mode 100644
index 000000000000..fabc2caf5b6b
--- /dev/null
+++ b/test/fir/loop.fir
@@ -0,0 +1,11 @@
+func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
+  fir.loop %iv = %lb to %ub step %step unordered {
+    fir.where %b {
+      fir.store %iv to %addr : !fir.ref<index>
+    } otherwise {
+      %zero = constant 0 : index
+      fir.store %zero to %addr : !fir.ref<index>
+    }
+  }
+  return
+}
diff --git a/tools/bbc/bbc.cc b/tools/bbc/bbc.cc
index 4ac7de37e0f3..cbe64733df58 100644
--- a/tools/bbc/bbc.cc
+++ b/tools/bbc/bbc.cc
@@ -269,9 +269,9 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
 
   // MLIR+FIR
   fir::NameMangler nameMangler;
-  auto burnside = Br::getBurnsideBridge(
+  auto burnside = Br::BurnsideBridge::create(
       semanticsContext.defaultKinds(), &parsing.cooked());
-  Br::crossBurnsideBridge(burnside, parseTree, nameMangler);
+  burnside.lower(parseTree, nameMangler);
   mlir::ModuleOp mlirModule{burnside.getModule()};
   mlir::PassManager pm{mlirModule.getContext()};
   if (driver.dumpHLFIR) {
@@ -285,10 +285,10 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
     pm.addPass(fir::createFIRToStdPass());
   }
   if (driver.lowerToLLVM) {
-    pm.addPass(fir::createFIRToLLVMPass());
+    pm.addPass(fir::createFIRToLLVMPass(nameMangler));
   }
   if (driver.lowerToLLVMIR) {
-    pm.addPass(fir::createLLVMDialectToLLVMPass("a.ll", nameMangler));
+    pm.addPass(fir::createLLVMDialectToLLVMPass("a.ll"));
   }
   if (mlir::succeeded(pm.run(mlirModule))) {
     if (driver.dumpFIR) {
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 1ce63241f2e0..dbb8bbbe7709 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -78,8 +78,8 @@ int compileFIR() {
   pm.addPass(fir::createFIRToStdPass());
   // convert loop dialect to standard
   pm.addPass(mlir::createLowerToCFGPass());
-  pm.addPass(fir::createFIRToLLVMPass());
-  pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput, mangler));
+  pm.addPass(fir::createFIRToLLVMPass(mangler));
+  pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput));
   if (mlir::succeeded(pm.run(*owningRef))) {
     errs() << ";== output ==\n";
     owningRef->dump();

From 3b653410489ce5658f8241eb9285f1d046e706eb Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 20 Nov 2019 05:45:00 -0800
Subject: [PATCH 129/345] Propagate logicals in the type required by consumers:
 Inside the `ExprLowering` facility: - After evaluating an `Expr<Type<Logical,
 KIND>>` expression, convert   the result to the type requested by the
 consumer of the expression   if needed. - A state `genLogicalAsI1` is added
 to `ExprLowering` facility. It allows   to propagate the final consumer type
 through nodes where the type   manipulated does not matter (e.g. parantheses)
 while also allowing   a node of a tree to locally change the requested type
 to produce its   logical operands.

At the external interface of `ExprLowering` facility:
- Add `createI1LogicalExpression` external methods that can be used
  to the bridge.
- The default expression generation `createSomeExpression` generate
  `fir.logical` which is what is needed in assignements and calls
  as well as in weird intrinsics (TRANSFER) where the physical
  representation matters.

This design fulfills:
- It will be possible to lower `TRANSFER(TRANSFER(int, logical))` in
  such as it still evaluate to `int` as requested by 16.9.193.
- It avoids generating useless conversions in the middle of logical
  operations such as `if(x.le.y.AND.x.gt.z) then ...`
- It has a "low" footprint on the rest of the bridge. Parts that
  handle logical expressions without caring about what it is do
  not have to add code to handle the FIR/MLIR type possibilities.

Also addresses https://github.com/schweitzpgi/f18/pull/16 comments
- Add assert message for `.NOT.`.
- Move `getMLIRLogicaType` to `convert-type.h`.

fix constant expression issues

Address https://github.com/schweitzpgi/f18/pull/17 review comments
- Rename `genMLIRLogicalConstant` to `genLogicalConstantAsI1`
- Remove `getMLIRLogicalType` based on comment about `MLIR` meaning.
- Add assert that Fortran function calls have a single result in MLIR
- Editorial changes

Also apply logical type control around intrinsic and user function calls.
---
 lib/burnside/ast-builder.h   |  16 ++---
 lib/burnside/bridge.cc       |   9 ++-
 lib/burnside/convert-expr.cc | 133 +++++++++++++++++++++--------------
 lib/burnside/convert-expr.h  |   6 ++
 lib/burnside/convert-type.h  |   2 +-
 lib/fir/Tilikum.cpp          |  17 ++---
 tools/tco/CMakeLists.txt     |   2 +-
 7 files changed, 111 insertions(+), 74 deletions(-)

diff --git a/lib/burnside/ast-builder.h b/lib/burnside/ast-builder.h
index 189f5b212729..41d98d2d5902 100644
--- a/lib/burnside/ast-builder.h
+++ b/lib/burnside/ast-builder.h
@@ -74,11 +74,11 @@ struct Evaluation {
   Evaluation(const A &a, const parser::CharBlock &pos,
       const std::optional<parser::Label> &lab)
     : u{&a}, ux{StmtExtra{pos, lab}} {
-    static_assert(!isConstruct(a) && "must be a statement");
-    if constexpr (isAction(a)) {
+    static_assert(!isConstruct<A>() && "must be a statement");
+    if constexpr (isAction<A>()) {
       isActionStmt = true;
     }
-    if constexpr (isAction(a) || isOther(a)) {
+    if constexpr (isAction<A>() || isOther<A>()) {
       isStatement = true;
     }
   }
@@ -86,12 +86,12 @@ struct Evaluation {
   /// Construct ctor
   template<typename A>
   Evaluation(const A &a) : u{&a}, ux{std::list<Evaluation>{}} {
-    static_assert(isConstruct(a) && "must be a construct");
+    static_assert(isConstruct<A>() && "must be a construct");
   }
 
   /// statements that are executable (actions)
-  template<typename A> constexpr static bool isAction(const A &a) {
-    if constexpr (!isConstruct(a) && !isOther(a)) {
+  template<typename A> constexpr static bool isAction() {
+    if constexpr (!isConstruct<A>() && !isOther<A>()) {
       return true;
     } else {
       return false;
@@ -99,7 +99,7 @@ struct Evaluation {
   }
 
   /// constructs (and directives)
-  template<typename A> constexpr static bool isConstruct(const A &) {
+  template<typename A> constexpr static bool isConstruct() {
     if constexpr (std::is_same_v<A, parser::AssociateConstruct> ||
         std::is_same_v<A, parser::BlockConstruct> ||
         std::is_same_v<A, parser::CaseConstruct> ||
@@ -121,7 +121,7 @@ struct Evaluation {
   }
 
   /// statements that are not executable
-  template<typename A> constexpr static bool isOther(const A &) {
+  template<typename A> constexpr static bool isOther() {
     if constexpr (std::is_same_v<A, parser::FormatStmt> ||
         std::is_same_v<A, parser::EntryStmt> ||
         std::is_same_v<A, parser::DataStmt> ||
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 54853c7c21a5..f571f9985f0f 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -117,6 +117,10 @@ class FIRConverter {
     return createSomeExpression(
         loc, build(), *expr, symbolMap, defaults, intrinsics);
   }
+  M::Value *createLogicalExprAsI1(M::Location loc, const SomeExpr *expr) {
+    return createI1LogicalExpression(
+        loc, build(), *expr, symbolMap, defaults, intrinsics);
+  }
   M::Value *createTemp(M::Type type, Se::Symbol *symbol = nullptr) {
     return createTemporary(toLocation(), build(), symbolMap, type, symbol);
   }
@@ -516,7 +520,7 @@ class FIRConverter {
       const A &tuple, Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
     auto *exprRef{Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(tuple))};
     assert(exprRef && "condition expression missing");
-    auto *cond{createFIRExpr(toLocation(), exprRef)};
+    auto *cond{createLogicalExprAsI1(toLocation(), exprRef)};
     genCondBranch(cond, trueLabel, falseLabel);
   }
   void genFIR(const Pa::Statement<Pa::IfThenStmt> &stmt,
@@ -561,7 +565,7 @@ class FIRConverter {
               [&](const parser::ScalarLogicalExpr &logical) {
                 auto loc{toLocation(stmt.source)};
                 auto *exp{Se::GetExpr(logical)};
-                condition = createFIRExpr(loc, exp);
+                condition = createLogicalExprAsI1(loc, exp);
                 return false;
               },
               [&](const parser::LoopControl::Concurrent &concurrent) {
@@ -583,6 +587,7 @@ class FIRConverter {
 
   // Action statements
   void genFIR(const Pa::AllocateStmt &stmt) { TODO(); }
+
   void genFIR(const Pa::AssignmentStmt &stmt) {
     auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
     auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 0f2343f5f264..e6a57e853aef 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -73,6 +73,7 @@ class ExprLowering {
   SymMap loadedSymbols{};
   Co::IntrinsicTypeDefaultKinds const &defaults;
   IntrinsicLibrary const &intrinsics;
+  bool genLogicalAsI1{false};
 
   M::Location getLoc() { return location; }
 
@@ -117,20 +118,10 @@ class ExprLowering {
   }
 
   /// Generate a logical/boolean constant of `value`
-  M::Type getMLIRlogicalType() {
-    return M::IntegerType::get(1, builder.getContext());
-  }
-  M::Value *genMLIRLogicalConstant(M::MLIRContext *context, bool value) {
-    auto attr{builder.getIntegerAttr(getMLIRlogicalType(), value ? 1 : 0)};
-    return builder.create<M::ConstantOp>(getLoc(), getMLIRlogicalType(), attr)
-        .getResult();
-  }
-  template<int KIND>
-  M::Value *genLogicalConstant(M::MLIRContext *context, bool value) {
-    auto mlirCst{genMLIRLogicalConstant(context, value)};
-    M::Type firLogicalTy{getFIRType(context, defaults, LogicalCat, KIND)};
-    auto res{builder.create<fir::ConvertOp>(getLoc(), firLogicalTy, mlirCst)};
-    return res.getResult();
+  M::Value *genLogicalConstantAsI1(M::MLIRContext *context, bool value) {
+    M::Type i1Type{M::IntegerType::get(1, builder.getContext())};
+    auto attr{builder.getIntegerAttr(i1Type, value ? 1 : 0)};
+    return builder.create<M::ConstantOp>(getLoc(), i1Type, attr).getResult();
   }
 
   template<int KIND>
@@ -158,19 +149,6 @@ class ExprLowering {
   template<typename OpTy, typename A> M::Value *createBinaryOp(A const &ex) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), genval(ex.right()));
   }
-  template<typename OpTy, typename A> M::Value *createLogicalOp(A const &ex) {
-    auto mlirTy{M::IntegerType::get(1, builder.getContext())};
-    auto *lhs{genval(ex.left())};
-    auto *rhs{genval(ex.right())};
-    // mlir logical ops do not work with fir.logical<k>, so the operation
-    // is wrapped in conversions
-    auto lhsConv{builder.create<fir::ConvertOp>(getLoc(), mlirTy, lhs)};
-    auto rhsConv{builder.create<fir::ConvertOp>(getLoc(), mlirTy, rhs)};
-    auto op{createBinaryOp<OpTy>(ex, lhsConv, rhsConv)};
-    assert(lhs);
-    auto resType{lhs->getType()};
-    return builder.create<fir::ConvertOp>(getLoc(), resType, op);
-  }
 
   M::FuncOp getFunction(L::StringRef name, M::FunctionType funTy) {
     auto module{getModule(&builder)};
@@ -251,6 +229,7 @@ class ExprLowering {
         translateSymbolToFIRType(builder.getContext(), defaults, sym), &*sym);
   }
   M::Value *gendef(Se::SymbolRef sym) { return gen(sym); }
+
   M::Value *genval(Se::SymbolRef sym) {
     // Do not load the same symbols several time in one expression.
     // Fortran guarantees variable value must be the same wherever it
@@ -387,11 +366,9 @@ class ExprLowering {
       static_assert(TC == CharacterCat);
       TODO();
     }
-    auto logicalTy{getFIRType(builder.getContext(), defaults, LogicalCat)};
-    return builder.create<fir::ConvertOp>(getLoc(), logicalTy, result);
+    return result;
   }
 
-  // TODO JP: the thing below should not be required.
   M::Value *genval(Ev::Relational<Ev::SomeType> const &op) {
     return std::visit([&](const auto &x) { return genval(x); }, op.u);
   }
@@ -399,27 +376,33 @@ class ExprLowering {
   template<Co::TypeCategory TC1, int KIND, Co::TypeCategory TC2>
   M::Value *genval(Ev::Convert<Ev::Type<TC1, KIND>, TC2> const &convert) {
     auto ty{getFIRType(builder.getContext(), defaults, TC1, KIND)};
-    return builder.create<fir::ConvertOp>(getLoc(), ty, genval(convert.left()));
+    M::Value *operand{genval(convert.left())};
+    if (TC1 == LogicalCat && genLogicalAsI1) {
+      // If an i1 result is needed, it does not make sens to convert between
+      // `fir.logical` types to later convert back to the result to i1.
+      return operand;
+    }
+    return builder.create<fir::ConvertOp>(getLoc(), ty, operand);
   }
+
   template<typename A> M::Value *genval(Ev::Parentheses<A> const &) { TODO(); }
 
   template<int KIND> M::Value *genval(const Ev::Not<KIND> &op) {
+    // Request operands to be generated as `i1` and restore after this scope.
+    auto restorer{common::ScopedSet(genLogicalAsI1, true)};
     auto *context{builder.getContext()};
-    auto mlirLogical{builder.create<fir::ConvertOp>(
-        getLoc(), getMLIRlogicalType(), genval(op.left()))};
-    auto i1One{genMLIRLogicalConstant(context, 1)};
-    auto mlirRes{builder.create<M::XOrOp>(getLoc(), mlirLogical, i1One)};
-    auto firTy{getFIRType(builder.getContext(), defaults, LogicalCat, KIND)};
-    return builder.create<fir::ConvertOp>(getLoc(), firTy, mlirRes).getResult();
+    auto logical{genval(op.left())};
+    auto one{genLogicalConstantAsI1(context, true)};
+    return builder.create<M::XOrOp>(getLoc(), logical, one).getResult();
   }
 
   template<int KIND> M::Value *genval(Ev::LogicalOperation<KIND> const &op) {
+    // Request operands to be generated as `i1` and restore after this scope.
+    auto restorer{common::ScopedSet(genLogicalAsI1, true)};
     mlir::Value *result{nullptr};
     switch (op.logicalOperator) {
-    case Ev::LogicalOperator::And:
-      result = createLogicalOp<M::AndOp>(op);
-      break;
-    case Ev::LogicalOperator::Or: result = createLogicalOp<M::OrOp>(op); break;
+    case Ev::LogicalOperator::And: result = createBinaryOp<M::AndOp>(op); break;
+    case Ev::LogicalOperator::Or: result = createBinaryOp<M::OrOp>(op); break;
     case Ev::LogicalOperator::Eqv:
       result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::eq);
       break;
@@ -427,16 +410,14 @@ class ExprLowering {
       result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::ne);
       break;
     case Ev::LogicalOperator::Not:
-      // LogicalOperations are binary operations. Expr for Not is
-      // evaluate::Not<KIND>.
-      assert(false);
+      // lib/evaluate expression for .NOT. is evaluate::Not<KIND>.
+      assert(false && ".NOT. is not a binary operator");
       break;
     }
     if (!result) {
       assert(false && "unhandled logical operation");
     }
-    auto logicalTy{getFIRType(builder.getContext(), defaults, LogicalCat)};
-    return builder.create<fir::ConvertOp>(getLoc(), logicalTy, result);
+    return result;
   }
 
   template<Co::TypeCategory TC, int KIND>
@@ -454,7 +435,7 @@ class ExprLowering {
     } else if constexpr (TC == LogicalCat) {
       auto opt{con.GetScalarValue()};
       if (opt.has_value())
-        return genLogicalConstant<KIND>(builder.getContext(), opt->IsTrue());
+        return genLogicalConstantAsI1(builder.getContext(), opt->IsTrue());
       assert(false && "logical constant has no value");
       return {};
     } else if constexpr (TC == RealCat) {
@@ -664,6 +645,12 @@ class ExprLowering {
       M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
       L::SmallVector<M::Value *, 2> operands;
       // Lower arguments
+      // For now, logical arguments for intrinsic are lowered to `fir.logical`
+      // so that TRANSFER can work. For some arguments, it could lead to useless
+      // conversions (e.g scalar MASK of MERGE will be converted to `i1`), but
+      // the generated code is at least correct. To improve this, the intrinsic
+      // lowering facility should control argument lowering.
+      auto restorer{common::ScopedSet(genLogicalAsI1, false)};
       for (const auto &arg : funRef.arguments()) {
         if (auto *expr{Ev::UnwrapExpr<Ev::Expr<Ev::SomeType>>(arg)}) {
           operands.push_back(genval(*expr));
@@ -679,6 +666,9 @@ class ExprLowering {
       // TODO: explicit interface
       L::SmallVector<M::Type, 2> argTypes;
       L::SmallVector<M::Value *, 2> operands;
+      // Logical arguments of user functions must be lowered to `fir.logical`
+      // and not `i1`.
+      auto restorer{common::ScopedSet(genLogicalAsI1, false)};
       for (const auto &arg : funRef.arguments()) {
         assert(
             arg.has_value() && "optional argument requires explicit interface");
@@ -698,7 +688,11 @@ class ExprLowering {
       M::FunctionType funTy{
           M::FunctionType::get(argTypes, resultType, builder.getContext())};
       M::FuncOp func{getFunction(funRef.proc().GetName(), funTy)};
-      M::CallOp call{builder.create<M::CallOp>(getLoc(), func, operands)};
+      auto call{builder.create<M::CallOp>(getLoc(), func, operands)};
+      // For now, Fortran return value are implemented with a single MLIR
+      // function return value.
+      assert(call.getNumResults() == 1 &&
+          "Expected exactly one result in FUNCTION call");
       return call.getResult(0);
     }
   }
@@ -714,6 +708,35 @@ class ExprLowering {
     return std::visit([&](const auto &e) { return genval(e); }, exp.u);
   }
 
+  template<int KIND>
+  M::Value *genval(Ev::Expr<Ev::Type<LogicalCat, KIND>> const &exp) {
+    auto *result{std::visit([&](const auto &e) { return genval(e); }, exp.u)};
+    // Handle the `i1` to `fir.logical` conversions as needed.
+    if (result) {
+      M::Type type{result->getType()};
+      if (type.isa<fir::LogicalType>()) {
+        if (genLogicalAsI1) {
+          M::Type i1Type{M::IntegerType::get(1, builder.getContext())};
+          result = builder.create<fir::ConvertOp>(getLoc(), i1Type, result);
+        }
+      } else if (type.isa<M::IntegerType>()) {
+        if (!genLogicalAsI1) {
+          M::Type firLogicalType{
+              getFIRType(builder.getContext(), defaults, LogicalCat, KIND)};
+          result =
+              builder.create<fir::ConvertOp>(getLoc(), firLogicalType, result);
+        }
+      } else if (auto seqType{type.dyn_cast_or_null<fir::SequenceType>()}) {
+        // TODO: Conversions at array level should probably be avoided.
+        // This depends on how array expressions will be lowered.
+        assert(false && "logical array loads not yet implemented");
+      } else {
+        assert(false && "unexpected logical type in expression");
+      }
+    }
+    return result;
+  }
+
   template<typename A> M::Value *gendef(const A &) {
     assert(false && "expression error");
     return {};
@@ -723,9 +746,9 @@ class ExprLowering {
   explicit ExprLowering(M::Location loc, M::OpBuilder &bldr,
       SomeExpr const &vop, SymMap &map,
       Co::IntrinsicTypeDefaultKinds const &defaults,
-      IntrinsicLibrary const &intr)
+      IntrinsicLibrary const &intr, bool logicalAsI1 = false)
     : location{loc}, builder{bldr}, expr{vop}, symMap{map}, defaults{defaults},
-      intrinsics{intr} {}
+      intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
 
   /// Lower the expression `expr` into MLIR standard dialect
   M::Value *gen() { return gen(expr); }
@@ -738,7 +761,15 @@ M::Value *Br::createSomeExpression(M::Location loc, M::OpBuilder &builder,
     Ev::Expr<Ev::SomeType> const &expr, SymMap &symMap,
     Co::IntrinsicTypeDefaultKinds const &defaults,
     IntrinsicLibrary const &intrinsics) {
-  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics}
+  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics, false}
+      .genval();
+}
+
+M::Value *Br::createI1LogicalExpression(M::Location loc, M::OpBuilder &builder,
+    Ev::Expr<Ev::SomeType> const &expr, SymMap &symMap,
+    Co::IntrinsicTypeDefaultKinds const &defaults,
+    IntrinsicLibrary const &intrinsics) {
+  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics, true}
       .genval();
 }
 
diff --git a/lib/burnside/convert-expr.h b/lib/burnside/convert-expr.h
index 5334fe72cb03..b731b3390d91 100644
--- a/lib/burnside/convert-expr.h
+++ b/lib/burnside/convert-expr.h
@@ -50,6 +50,12 @@ mlir::Value *createSomeExpression(mlir::Location loc, mlir::OpBuilder &builder,
     evaluate::Expr<evaluate::SomeType> const &expr, SymMap &symMap,
     common::IntrinsicTypeDefaultKinds const &defaults,
     IntrinsicLibrary const &intrinsics);
+
+mlir::Value *createI1LogicalExpression(mlir::Location loc,
+    mlir::OpBuilder &builder, evaluate::Expr<evaluate::SomeType> const &expr,
+    SymMap &symMap, common::IntrinsicTypeDefaultKinds const &defaults,
+    IntrinsicLibrary const &intrinsics);
+
 mlir::Value *createSomeAddress(mlir::Location loc, mlir::OpBuilder &builder,
     evaluate::Expr<evaluate::SomeType> const &expr, SymMap &symMap,
     common::IntrinsicTypeDefaultKinds const &defaults,
diff --git a/lib/burnside/convert-type.h b/lib/burnside/convert-type.h
index 34218eb87b97..2c4f7b94741b 100644
--- a/lib/burnside/convert-type.h
+++ b/lib/burnside/convert-type.h
@@ -107,7 +107,7 @@ mlir::Type translateSymbolToFIRType(mlir::MLIRContext *ctxt,
     common::IntrinsicTypeDefaultKinds const &defaults,
     const semantics::SymbolRef symbol);
 
-mlir::Type convertReal(mlir::MLIRContext *context, int KIND);
+mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
 }  // burnside
 }  // Fortran
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index f97f1ca00bca..f8147d848bff 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -1355,19 +1355,14 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto global = M::cast<fir::GlobalOp>(op);
-    auto tyAttr = M::TypeAttr::get(convertType(global.getType()));
-    M::UnitAttr isConst;
-    if (global.getAttr("constant"))
-      isConst = M::UnitAttr::get(global.getContext());
-    auto name = M::StringAttr::get(
+    auto tyAttr = unwrap(convertType(global.getType()));
+    bool isConst = global.getAttr("constant") ? true : false;
+    auto name =
         global.getAttrOfType<M::StringAttr>(M::SymbolTable::getSymbolAttrName())
-            .getValue(),
-        global.getContext());
+            .getValue();
     M::Attribute value;
-    auto addrSpace = /* FIXME: hard-coded i32 here; is that ok? */
-        rewriter.getI32IntegerAttr(0);
-    rewriter.replaceOpWithNewOp<M::LLVM::GlobalOp>(global, tyAttr, isConst,
-                                                   name, value, addrSpace);
+    rewriter.replaceOpWithNewOp<M::LLVM::GlobalOp>(
+        global, tyAttr, isConst, M::LLVM::Linkage::External, name, value);
     return matchSuccess();
   }
 };
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 4c927d8548c3..6037e10ea66a 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -37,7 +37,7 @@ set(EXE_LIBS
   MLIRSupport
   MLIRTransforms
   MLIRVectorOps
-  MLIRVectorToLLVM
+  MLIRVectorConversions
 )
 
 add_llvm_tool(tco tco.cpp)

From 19a1d09c9e23109218a51631e21e2065333c6f3a Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 3 Dec 2019 12:50:01 -0800
Subject: [PATCH 130/345] Remove the legacy "flatten" representation, which was
 an intermediate step to create CFGs.  Replace the flat, linear representation
 with an AST to preserve the input structure. This is a "thin" AST as it is a
 tree structure superimposed upon the parse tree with pointers back into the
 parse tree representation.  The AST is decorated with control annotations to
 provide both a way to construct a CFG and a way to preserve high-level
 operations on iteration spaces where possible. Burnside can use either the
 annotations (by group) or the specific pointers (case-by-case basis) to
 instantiate the FIR.

remove flattened code

WIP: loops and conditionals
add some passes to bbc
---
 include/fir/InternalNames.h   |    5 +
 lib/burnside/CMakeLists.txt   |    1 -
 lib/burnside/ast-builder.cc   |  396 +++++--
 lib/burnside/ast-builder.h    |  267 +++--
 lib/burnside/bridge.cc        | 2009 +++++++++++++++++++--------------
 lib/burnside/builder.h        |    3 +
 lib/burnside/convert-type.h   |   10 +-
 lib/burnside/flattened.cc     |  688 -----------
 lib/burnside/flattened.h      |  235 ----
 lib/burnside/intrinsics.cc    |    1 +
 tools/bbc/CMakeLists.txt      |    4 +-
 tools/bbc/{bbc.cc => bbc.cpp} |    4 +
 12 files changed, 1673 insertions(+), 1950 deletions(-)
 delete mode 100644 lib/burnside/flattened.cc
 delete mode 100644 lib/burnside/flattened.h
 rename tools/bbc/{bbc.cc => bbc.cpp} (99%)

diff --git a/include/fir/InternalNames.h b/include/fir/InternalNames.h
index 83ad0b9e49ef..48ceb870ebca 100644
--- a/include/fir/InternalNames.h
+++ b/include/fir/InternalNames.h
@@ -75,6 +75,11 @@ struct NameMangler {
   llvm::Twine doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                          llvm::StringRef name);
 
+  /// Entry point for the PROGRAM (called by the runtime)
+  constexpr static llvm::StringRef getProgramEntry() {
+    return "__MAIN";
+  }
+
 private:
   llvm::Twine addAsString(std::int64_t i);
   llvm::Twine doKind(std::int64_t kind);
diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
index 1d9ef68e3af7..cdbdfbffa227 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/burnside/CMakeLists.txt
@@ -20,7 +20,6 @@ add_library(FortranBurnside
   builder.cc
   convert-expr.cc
   convert-type.cc
-  flattened.cc
   intrinsics.cc
   runtime.cc
   io.cc
diff --git a/lib/burnside/ast-builder.cc b/lib/burnside/ast-builder.cc
index f222622f4299..db06e7457d32 100644
--- a/lib/burnside/ast-builder.cc
+++ b/lib/burnside/ast-builder.cc
@@ -41,10 +41,13 @@ namespace {
 /// the bridge to one such instantiation.
 class ASTBuilder {
 public:
-  ASTBuilder() = default;
+  ASTBuilder() {
+    pgm = new AST::Program;
+    parents.push_back(pgm);
+  }
 
   /// Get the result
-  AST::Program result() { return pgm; }
+  AST::Program *result() { return pgm; }
 
   template<typename A> constexpr bool Pre(const A &) { return true; }
   template<typename A> constexpr void Post(const A &) {}
@@ -72,15 +75,25 @@ class ASTBuilder {
   // Block data
 
   void Post(const Pa::BlockData &x) {
-    AST::BlockDataUnit unit{x};
+    AST::BlockDataUnit unit{x, parents.back()};
     addUnit(unit);
   }
 
-  // Evaluation
+  //
+  // Action statements
+  //
 
   void Post(const Pa::Statement<Pa::ActionStmt> &s) {
     addEval(makeEvalAction(s));
   }
+  void Post(const Pa::UnlabeledStatement<Pa::ActionStmt> &s) {
+    addEval(makeEvalAction(s));
+  }
+
+  //
+  // Non-executable statements
+  //
+
   void Post(const Pa::Statement<Co::Indirection<Pa::FormatStmt>> &s) {
     addEval(makeEvalIndirect(s));
   }
@@ -94,6 +107,111 @@ class ASTBuilder {
     addEval(makeEvalIndirect(s));
   }
 
+  //
+  // Construct statements
+  //
+
+  void Post(const Pa::Statement<parser::AssociateStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndAssociateStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::BlockStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndBlockStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::SelectCaseStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::CaseStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndSelectStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::ChangeTeamStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndChangeTeamStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::CriticalStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndCriticalStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::NonLabelDoStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndDoStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::IfThenStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::ElseIfStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::ElseStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndIfStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::SelectRankStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::SelectRankCaseStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::SelectTypeStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::TypeGuardStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::WhereConstructStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::MaskedElsewhereStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::ElsewhereStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndWhereStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::ForallConstructStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  void Post(const Pa::Statement<parser::EndForallStmt> &s) {
+    addEval(makeEvalDirect(s));
+  }
+  // Get rid of production wrapper
+  void Post(const Pa::UnlabeledStatement<parser::ForallAssignmentStmt> &s) {
+    addEval(std::visit(
+        [&](const auto &x) {
+          return AST::Evaluation{x, s.source, {}, parents.back()};
+        },
+        s.statement.u));
+  }
+  void Post(const Pa::Statement<parser::ForallAssignmentStmt> &s) {
+    addEval(std::visit(
+        [&](const auto &x) {
+          return AST::Evaluation{x, s.source, s.label, parents.back()};
+        },
+        s.statement.u));
+  }
+
+  //
+  // Constructs (enter and exit)
+  //
+
   bool Pre(const Pa::AssociateConstruct &c) { return enterConstruct(c); }
   bool Pre(const Pa::BlockConstruct &c) { return enterConstruct(c); }
   bool Pre(const Pa::CaseConstruct &c) { return enterConstruct(c); }
@@ -132,13 +250,30 @@ class ASTBuilder {
     return std::visit(
         common::visitors{
             [&](const Pa::ContinueStmt &x) {
-              return AST::Evaluation{x, s.source, s.label};
+              return AST::Evaluation{x, s.source, s.label, parents.back()};
+            },
+            [&](const Pa::FailImageStmt &x) {
+              return AST::Evaluation{x, s.source, s.label, parents.back()};
+            },
+            [&](const auto &x) {
+              return AST::Evaluation{
+                  x.value(), s.source, s.label, parents.back()};
+            },
+        },
+        s.statement.u);
+  }
+  AST::Evaluation makeEvalAction(
+      const Pa::UnlabeledStatement<Pa::ActionStmt> &s) {
+    return std::visit(
+        common::visitors{
+            [&](const Pa::ContinueStmt &x) {
+              return AST::Evaluation{x, s.source, {}, parents.back()};
             },
             [&](const Pa::FailImageStmt &x) {
-              return AST::Evaluation{x, s.source, s.label};
+              return AST::Evaluation{x, s.source, {}, parents.back()};
             },
             [&](const auto &x) {
-              return AST::Evaluation{x.value(), s.source, s.label};
+              return AST::Evaluation{x.value(), s.source, {}, parents.back()};
             },
         },
         s.statement.u);
@@ -146,75 +281,98 @@ class ASTBuilder {
 
   template<typename A>
   AST::Evaluation makeEvalIndirect(const Pa::Statement<Co::Indirection<A>> &s) {
-    return AST::Evaluation{s.statement.value(), s.source, s.label};
+    return AST::Evaluation{
+        s.statement.value(), s.source, s.label, parents.back()};
+  }
+
+  template<typename A>
+  AST::Evaluation makeEvalDirect(const Pa::Statement<A> &s) {
+    return AST::Evaluation{s.statement, s.source, s.label, parents.back()};
   }
 
   // When we enter a function-like structure, we want to build a new unit and
   // set the builder's cursors to point to it.
   template<typename A> bool enterFunc(const A &f) {
-    AST::FunctionLikeUnit unit{f};
+    auto &unit = addFunc(AST::FunctionLikeUnit{f, parents.back()});
     funclist = &unit.funcs;
     pushEval(&unit.evals);
-    addFunc(unit);
+    parents.emplace_back(&unit);
     return true;
   }
 
   void exitFunc() {
-    funclist = nullptr;
     popEval();
+    funclist = nullptr;
+    parents.pop_back();
   }
 
   // When we enter a construct structure, we want to build a new construct and
   // set the builder's evaluation cursor to point to it.
   template<typename A> bool enterConstruct(const A &c) {
-    AST::Evaluation con{c};
-    addEval(con);
-    pushEval(con.getConstructEvals());
+    auto &con = addEval(AST::Evaluation{c, parents.back()});
+    con.subs = new std::list<AST::Evaluation>();
+    pushEval(con.subs);
+    parents.emplace_back(&con);
     return true;
   }
 
-  void exitConstruct() { popEval(); }
+  void exitConstruct() {
+    popEval();
+    parents.pop_back();
+  }
 
   // When we enter a module structure, we want to build a new module and
   // set the builder's function cursor to point to it.
   template<typename A> bool enterModule(const A &f) {
-    AST::ModuleLikeUnit unit{f};
+    auto &unit = addUnit(AST::ModuleLikeUnit{f, parents.back()});
     funclist = &unit.funcs;
-    addUnit(unit);
+    parents.emplace_back(&unit);
     return true;
   }
 
-  void exitModule() { funclist = nullptr; }
+  void exitModule() {
+    funclist = nullptr;
+    parents.pop_back();
+  }
 
-  template<typename A> void addUnit(const A &unit) {
-    pgm.units.emplace_back(unit);
+  template<typename A> A &addUnit(const A &unit) {
+    pgm->getUnits().emplace_back(unit);
+    return std::get<A>(pgm->getUnits().back());
   }
 
-  template<typename A> void addFunc(const A &func) {
-    if (funclist)
+  template<typename A> A &addFunc(const A &func) {
+    if (funclist) {
       funclist->emplace_back(func);
-    else
-      addUnit(func);
+      return funclist->back();
+    }
+    return addUnit(func);
   }
 
-  void addEval(const AST::Evaluation &eval) {
-    assert(funclist);
-    evallist.back()->emplace_back(eval);
+  /// move the Evaluation to the end of the current list
+  AST::Evaluation &addEval(AST::Evaluation &&eval) {
+    assert(funclist && "not in a function");
+    assert(evallist.size() > 0);
+    evallist.back()->emplace_back(std::move(eval));
+    return evallist.back()->back();
   }
 
+  /// push a new list on the stack of Evaluation lists
   void pushEval(std::list<AST::Evaluation> *eval) {
-    assert(funclist);
-    evallist.push_back(eval);
+    assert(funclist && "not in a function");
+    assert(eval && eval->empty() && "evaluation list isn't correct");
+    evallist.emplace_back(eval);
   }
 
+  /// pop the current list and return to the last Evaluation list
   void popEval() {
-    assert(funclist);
+    assert(funclist && "not in a function");
     evallist.pop_back();
   }
 
-  AST::Program pgm;
+  AST::Program *pgm;
   std::list<AST::FunctionLikeUnit> *funclist{nullptr};
   std::vector<std::list<AST::Evaluation> *> evallist;
+  std::vector<AST::ParentType> parents;
 };
 
 template<typename A> constexpr bool hasErrLabel(const A &stmt) {
@@ -315,68 +473,140 @@ void ioLabel(AST::Evaluation &e, const A *s, AST::Evaluation *cstr) {
 void annotateEvalListCFG(
     std::list<AST::Evaluation> &evals, AST::Evaluation *cstr) {
   bool nextIsTarget = false;
-  for (auto e : evals) {
+  for (auto &e : evals) {
     e.isTarget = nextIsTarget;
     nextIsTarget = false;
     if (e.isConstruct()) {
       annotateEvalListCFG(*e.getConstructEvals(), &e);
       // assume that the entry and exit are both possible branch targets
-      e.isTarget = nextIsTarget = true;
-      continue;
+      nextIsTarget = true;
+    }
+    if (e.isActionStmt() && e.lab.has_value()) {
+      e.isTarget = true;
     }
     std::visit(
         common::visitors{
-            [&](Pa::BackspaceStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::CallStmt *s) { altRet(e, s, cstr); },
-            [&](Pa::CloseStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::CycleStmt *) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
-            [&](Pa::EndfileStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::ExitStmt *) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
-            [&](Pa::FailImageStmt *) {
-              e.setCFG(AST::CFGAnnotation::Return, cstr);
+            [&](const Pa::BackspaceStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::CallStmt *s) { altRet(e, s, cstr); },
+            [&](const Pa::CloseStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::CycleStmt *) {
+              e.setCFG(AST::CFGAnnotation::Goto, cstr);
+            },
+            [&](const Pa::EndfileStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::ExitStmt *) {
+              e.setCFG(AST::CFGAnnotation::Goto, cstr);
+            },
+            [&](const Pa::FailImageStmt *) {
+              e.setCFG(AST::CFGAnnotation::Terminate, cstr);
+            },
+            [&](const Pa::FlushStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::GotoStmt *) {
+              e.setCFG(AST::CFGAnnotation::Goto, cstr);
+            },
+            [&](const Pa::IfStmt *) {
+              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
             },
-            [&](Pa::FlushStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::GotoStmt *) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
-            [&](Pa::IfStmt *) { e.setCFG(AST::CFGAnnotation::CondGoto, cstr); },
-            [&](Pa::InquireStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::OpenStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::ReadStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::ReturnStmt *) {
+            [&](const Pa::InquireStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::OpenStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::ReadStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::ReturnStmt *) {
               e.setCFG(AST::CFGAnnotation::Return, cstr);
             },
-            [&](Pa::RewindStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::StopStmt *) { e.setCFG(AST::CFGAnnotation::Return, cstr); },
-            [&](Pa::WaitStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::WriteStmt *s) { ioLabel(e, s, cstr); },
-            [&](Pa::ArithmeticIfStmt *) {
+            [&](const Pa::RewindStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::StopStmt *) {
+              e.setCFG(AST::CFGAnnotation::Terminate, cstr);
+            },
+            [&](const Pa::WaitStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::WriteStmt *s) { ioLabel(e, s, cstr); },
+            [&](const Pa::ArithmeticIfStmt *) {
               e.setCFG(AST::CFGAnnotation::Switch, cstr);
             },
-            [&](Pa::AssignedGotoStmt *) {
+            [&](const Pa::AssignedGotoStmt *) {
               e.setCFG(AST::CFGAnnotation::IndGoto, cstr);
             },
-            [&](Pa::ComputedGotoStmt *) {
+            [&](const Pa::ComputedGotoStmt *) {
+              e.setCFG(AST::CFGAnnotation::Switch, cstr);
+            },
+            [&](const Pa::WhereStmt *) {
+              // fir.loop + fir.where around the next stmt
+              e.isTarget = true;
+              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
+            },
+            [&](const Pa::ForallStmt *) {
+              // fir.loop around the next stmt
+              e.isTarget = true;
+              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
+            },
+            [&](AST::CGJump &) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
+            [&](const Pa::EndAssociateStmt *) { e.isTarget = true; },
+            [&](const Pa::EndBlockStmt *) { e.isTarget = true; },
+            [&](const Pa::SelectCaseStmt *) {
+              e.setCFG(AST::CFGAnnotation::Switch, cstr);
+            },
+            [&](const Pa::CaseStmt *) { e.isTarget = true; },
+            [&](const Pa::EndSelectStmt *) { e.isTarget = true; },
+            [&](const Pa::EndChangeTeamStmt *) { e.isTarget = true; },
+            [&](const Pa::EndCriticalStmt *) { e.isTarget = true; },
+            [&](const Pa::NonLabelDoStmt *) {
+              e.isTarget = true;
+              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
+            },
+            [&](const Pa::EndDoStmt *) {
+              e.isTarget = true;
+              e.setCFG(AST::CFGAnnotation::Goto, cstr);
+            },
+            [&](const Pa::IfThenStmt *) {
+              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
+            },
+            [&](const Pa::ElseIfStmt *) {
+              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
+            },
+            [&](const Pa::ElseStmt *) { e.isTarget = true; },
+            [&](const Pa::EndIfStmt *) { e.isTarget = true; },
+            [&](const Pa::SelectRankStmt *) {
               e.setCFG(AST::CFGAnnotation::Switch, cstr);
             },
-            [](auto *) { /* do nothing */ },
+            [&](const Pa::SelectRankCaseStmt *) { e.isTarget = true; },
+            [&](const Pa::SelectTypeStmt *) {
+              e.setCFG(AST::CFGAnnotation::Switch, cstr);
+            },
+            [&](const Pa::TypeGuardStmt *) { e.isTarget = true; },
+            [&](const Pa::WhereConstruct *) {
+              // mark the WHERE as if it were a DO loop
+              e.isTarget = true;
+              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
+            },
+            [&](const Pa::WhereConstructStmt *) {
+              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
+            },
+            [&](const Pa::MaskedElsewhereStmt *) {
+              e.isTarget = true;
+              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
+            },
+            [&](const Pa::ElsewhereStmt *) { e.isTarget = true; },
+            [&](const Pa::EndWhereStmt *) { e.isTarget = true; },
+            [&](const Pa::ForallConstructStmt *) {
+              e.isTarget = true;
+              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
+            },
+            [&](const Pa::EndForallStmt *) { e.isTarget = true; },
+            [](const auto *) { /* do nothing */ },
         },
         e.u);
-    if (e.isActionStmt &&
-        std::get<std::optional<parser::Label>>(
-            std::get<AST::Evaluation::StmtExtra>(e.ux))
-            .has_value()) {
-      e.isTarget = true;
-    }
   }
 }
 
+/// Annotate the AST with CFG source decorations (see CFGAnnotation) and mark
+/// potential branch targets
 inline void annotateFuncCFG(AST::FunctionLikeUnit &flu) {
   annotateEvalListCFG(flu.evals, nullptr);
 }
 
 }  // namespace
 
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::MainProgram &f)
-  : ProgramUnit{&f} {
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(
+    const Pa::MainProgram &f, const AST::ParentType &parent)
+  : ProgramUnit{&f, parent} {
   auto &ps{std::get<std::optional<Pa::Statement<Pa::ProgramStmt>>>(f.t)};
   if (ps.has_value()) {
     const Pa::Statement<Pa::ProgramStmt> &s{ps.value()};
@@ -385,57 +615,63 @@ Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::MainProgram &f)
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndProgramStmt>>(f.t));
 }
 
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::FunctionSubprogram &f)
-  : ProgramUnit{&f} {
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(
+    const Pa::FunctionSubprogram &f, const AST::ParentType &parent)
+  : ProgramUnit{&f, parent} {
   funStmts.push_back(&std::get<Pa::Statement<Pa::FunctionStmt>>(f.t));
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndFunctionStmt>>(f.t));
 }
 
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::SubroutineSubprogram &f)
-  : ProgramUnit{&f} {
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(
+    const Pa::SubroutineSubprogram &f, const AST::ParentType &parent)
+  : ProgramUnit{&f, parent} {
   funStmts.push_back(&std::get<Pa::Statement<Pa::SubroutineStmt>>(f.t));
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndSubroutineStmt>>(f.t));
 }
 
 Br::AST::FunctionLikeUnit::FunctionLikeUnit(
-    const Pa::SeparateModuleSubprogram &f)
-  : ProgramUnit{&f} {
+    const Pa::SeparateModuleSubprogram &f, const AST::ParentType &parent)
+  : ProgramUnit{&f, parent} {
   funStmts.push_back(&std::get<Pa::Statement<Pa::MpSubprogramStmt>>(f.t));
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndMpSubprogramStmt>>(f.t));
 }
 
-Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Module &m) : ProgramUnit{&m} {
+Br::AST::ModuleLikeUnit::ModuleLikeUnit(
+    const Pa::Module &m, const AST::ParentType &parent)
+  : ProgramUnit{&m, parent} {
   modStmts.push_back(&std::get<Pa::Statement<Pa::ModuleStmt>>(m.t));
   modStmts.push_back(&std::get<Pa::Statement<Pa::EndModuleStmt>>(m.t));
 }
 
-Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Submodule &m)
-  : ProgramUnit{&m} {
+Br::AST::ModuleLikeUnit::ModuleLikeUnit(
+    const Pa::Submodule &m, const AST::ParentType &parent)
+  : ProgramUnit{&m, parent} {
   modStmts.push_back(&std::get<Pa::Statement<Pa::SubmoduleStmt>>(m.t));
   modStmts.push_back(&std::get<Pa::Statement<Pa::EndSubmoduleStmt>>(m.t));
 }
 
-Br::AST::BlockDataUnit::BlockDataUnit(const Pa::BlockData &db)
-  : ProgramUnit{&db} {}
+Br::AST::BlockDataUnit::BlockDataUnit(
+    const Pa::BlockData &db, const AST::ParentType &parent)
+  : ProgramUnit{&db, parent} {}
 
-AST::Program Br::createAST(const Pa::Program &root) {
+AST::Program *Br::createAST(const Pa::Program &root) {
   ASTBuilder walker;
   Walk(root, walker);
   return walker.result();
 }
 
 void Br::annotateControl(AST::Program &ast) {
-  for (auto unit : ast.units) {
+  for (auto &unit : ast.getUnits()) {
     std::visit(common::visitors{
                    [](AST::BlockDataUnit &) {},
                    [](AST::FunctionLikeUnit &f) {
                      annotateFuncCFG(f);
-                     for (auto s : f.funcs) {
+                     for (auto &s : f.funcs) {
                        annotateFuncCFG(s);
                      }
                    },
                    [](AST::ModuleLikeUnit &u) {
-                     for (auto f : u.funcs) {
+                     for (auto &f : u.funcs) {
                        annotateFuncCFG(f);
                      }
                    },
diff --git a/lib/burnside/ast-builder.h b/lib/burnside/ast-builder.h
index 41d98d2d5902..c639d6044cd1 100644
--- a/lib/burnside/ast-builder.h
+++ b/lib/burnside/ast-builder.h
@@ -21,6 +21,14 @@
 namespace Fortran::burnside {
 namespace AST {
 
+struct Evaluation;
+struct Program;
+struct ModuleLikeUnit;
+struct FunctionLikeUnit;
+
+using ParentType =
+    std::variant<Program *, ModuleLikeUnit *, FunctionLikeUnit *, Evaluation *>;
+
 enum class CFGAnnotation {
   None,
   Goto,
@@ -28,111 +36,147 @@ enum class CFGAnnotation {
   IndGoto,
   IoSwitch,
   Switch,
-  Return
+  Iterative,
+  FirStructuredOp,
+  Return,
+  Terminate
+};
+
+/// Compiler-generated jump
+///
+/// This is used to convert implicit control-flow edges to explicit form in the
+/// decorated AST
+struct CGJump {
+  CGJump(Evaluation *to) : target{to} {}
+  Evaluation *target{nullptr};
 };
 
+/// is `A` a construct (or directive)?
+template<typename A> constexpr static bool isConstruct() {
+  return std::is_same_v<A, parser::AssociateConstruct> ||
+      std::is_same_v<A, parser::BlockConstruct> ||
+      std::is_same_v<A, parser::CaseConstruct> ||
+      std::is_same_v<A, parser::ChangeTeamConstruct> ||
+      std::is_same_v<A, parser::CriticalConstruct> ||
+      std::is_same_v<A, parser::DoConstruct> ||
+      std::is_same_v<A, parser::IfConstruct> ||
+      std::is_same_v<A, parser::SelectRankConstruct> ||
+      std::is_same_v<A, parser::SelectTypeConstruct> ||
+      std::is_same_v<A, parser::WhereConstruct> ||
+      std::is_same_v<A, parser::ForallConstruct> ||
+      std::is_same_v<A, parser::CompilerDirective> ||
+      std::is_same_v<A, parser::OpenMPConstruct> ||
+      std::is_same_v<A, parser::OmpEndLoopDirective>;
+}
+
 /// Function-like units can contains lists of evaluations.  These can be
 /// (simple) statements or constructs, where a construct contains its own
 /// evaluations.
 struct Evaluation {
-  using EvalVariant = std::variant<const parser::AllocateStmt *,
-      const parser::AssignmentStmt *, const parser::BackspaceStmt *,
-      const parser::CallStmt *, const parser::CloseStmt *,
-      const parser::ContinueStmt *, const parser::CycleStmt *,
-      const parser::DeallocateStmt *, const parser::EndfileStmt *,
-      const parser::EventPostStmt *, const parser::EventWaitStmt *,
-      const parser::ExitStmt *, const parser::FailImageStmt *,
-      const parser::FlushStmt *, const parser::FormTeamStmt *,
-      const parser::GotoStmt *, const parser::IfStmt *,
-      const parser::InquireStmt *, const parser::LockStmt *,
-      const parser::NullifyStmt *, const parser::OpenStmt *,
-      const parser::PointerAssignmentStmt *, const parser::PrintStmt *,
-      const parser::ReadStmt *, const parser::ReturnStmt *,
-      const parser::RewindStmt *, const parser::StopStmt *,
-      const parser::SyncAllStmt *, const parser::SyncImagesStmt *,
-      const parser::SyncMemoryStmt *, const parser::SyncTeamStmt *,
-      const parser::UnlockStmt *, const parser::WaitStmt *,
-      const parser::WhereStmt *, const parser::WriteStmt *,
-      const parser::ComputedGotoStmt *, const parser::ForallStmt *,
-      const parser::ArithmeticIfStmt *, const parser::AssignStmt *,
-      const parser::AssignedGotoStmt *, const parser::PauseStmt *,
+  using EvalVariant = std::variant<
+      // action statements
+      const parser::AllocateStmt *, const parser::AssignmentStmt *,
+      const parser::BackspaceStmt *, const parser::CallStmt *,
+      const parser::CloseStmt *, const parser::ContinueStmt *,
+      const parser::CycleStmt *, const parser::DeallocateStmt *,
+      const parser::EndfileStmt *, const parser::EventPostStmt *,
+      const parser::EventWaitStmt *, const parser::ExitStmt *,
+      const parser::FailImageStmt *, const parser::FlushStmt *,
+      const parser::FormTeamStmt *, const parser::GotoStmt *,
+      const parser::IfStmt *, const parser::InquireStmt *,
+      const parser::LockStmt *, const parser::NullifyStmt *,
+      const parser::OpenStmt *, const parser::PointerAssignmentStmt *,
+      const parser::PrintStmt *, const parser::ReadStmt *,
+      const parser::ReturnStmt *, const parser::RewindStmt *,
+      const parser::StopStmt *, const parser::SyncAllStmt *,
+      const parser::SyncImagesStmt *, const parser::SyncMemoryStmt *,
+      const parser::SyncTeamStmt *, const parser::UnlockStmt *,
+      const parser::WaitStmt *, const parser::WhereStmt *,
+      const parser::WriteStmt *, const parser::ComputedGotoStmt *,
+      const parser::ForallStmt *, const parser::ArithmeticIfStmt *,
+      const parser::AssignStmt *, const parser::AssignedGotoStmt *,
+      const parser::PauseStmt *,
+      // compiler generated ops
+      CGJump,
+      // other statements
       const parser::FormatStmt *, const parser::EntryStmt *,
       const parser::DataStmt *, const parser::NamelistStmt *,
+      // constructs
       const parser::AssociateConstruct *, const parser::BlockConstruct *,
       const parser::CaseConstruct *, const parser::ChangeTeamConstruct *,
       const parser::CriticalConstruct *, const parser::DoConstruct *,
       const parser::IfConstruct *, const parser::SelectRankConstruct *,
       const parser::SelectTypeConstruct *, const parser::WhereConstruct *,
       const parser::ForallConstruct *, const parser::CompilerDirective *,
-      const parser::OpenMPConstruct *, const parser::OmpEndLoopDirective *>;
-  using StmtExtra = std::tuple<parser::CharBlock, std::optional<parser::Label>>;
+      const parser::OpenMPConstruct *, const parser::OmpEndLoopDirective *,
+      // construct statements
+      const parser::AssociateStmt *, const parser::EndAssociateStmt *,
+      const parser::BlockStmt *, const parser::EndBlockStmt *,
+      const parser::SelectCaseStmt *, const parser::CaseStmt *,
+      const parser::EndSelectStmt *, const parser::ChangeTeamStmt *,
+      const parser::EndChangeTeamStmt *, const parser::CriticalStmt *,
+      const parser::EndCriticalStmt *, const parser::NonLabelDoStmt *,
+      const parser::EndDoStmt *, const parser::IfThenStmt *,
+      const parser::ElseIfStmt *, const parser::ElseStmt *,
+      const parser::EndIfStmt *, const parser::SelectRankStmt *,
+      const parser::SelectRankCaseStmt *, const parser::SelectTypeStmt *,
+      const parser::TypeGuardStmt *, const parser::WhereConstructStmt *,
+      const parser::MaskedElsewhereStmt *, const parser::ElsewhereStmt *,
+      const parser::EndWhereStmt *, const parser::ForallConstructStmt *,
+      const parser::EndForallStmt *>;
 
   Evaluation() = delete;
+  Evaluation(const Evaluation &) = default;
 
-  /// Statement ctor
+  /// General ctor
   template<typename A>
   Evaluation(const A &a, const parser::CharBlock &pos,
-      const std::optional<parser::Label> &lab)
-    : u{&a}, ux{StmtExtra{pos, lab}} {
-    static_assert(!isConstruct<A>() && "must be a statement");
-    if constexpr (isAction<A>()) {
-      isActionStmt = true;
-    }
-    if constexpr (isAction<A>() || isOther<A>()) {
-      isStatement = true;
-    }
-  }
+      const std::optional<parser::Label> &lab, const ParentType &p)
+    : u{&a}, parent{p}, pos{pos}, lab{lab} {}
+
+  /// Compiler-generated jump
+  Evaluation(const CGJump &jump, const ParentType &p)
+    : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
 
   /// Construct ctor
   template<typename A>
-  Evaluation(const A &a) : u{&a}, ux{std::list<Evaluation>{}} {
-    static_assert(isConstruct<A>() && "must be a construct");
+  Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
+    static_assert(AST::isConstruct<A>(), "must be a construct");
   }
 
-  /// statements that are executable (actions)
-  template<typename A> constexpr static bool isAction() {
-    if constexpr (!isConstruct<A>() && !isOther<A>()) {
-      return true;
-    } else {
-      return false;
-    }
+  /// is `A` executable (an action statement or compiler generated)?
+  template<typename A> constexpr static bool isAction(const A &a) {
+    return !AST::isConstruct<A>() && !isOther(a);
   }
 
-  /// constructs (and directives)
-  template<typename A> constexpr static bool isConstruct() {
-    if constexpr (std::is_same_v<A, parser::AssociateConstruct> ||
-        std::is_same_v<A, parser::BlockConstruct> ||
-        std::is_same_v<A, parser::CaseConstruct> ||
-        std::is_same_v<A, parser::ChangeTeamConstruct> ||
-        std::is_same_v<A, parser::CriticalConstruct> ||
-        std::is_same_v<A, parser::DoConstruct> ||
-        std::is_same_v<A, parser::IfConstruct> ||
-        std::is_same_v<A, parser::SelectRankConstruct> ||
-        std::is_same_v<A, parser::SelectTypeConstruct> ||
-        std::is_same_v<A, parser::WhereConstruct> ||
-        std::is_same_v<A, parser::ForallConstruct> ||
-        std::is_same_v<A, parser::CompilerDirective> ||
-        std::is_same_v<A, parser::OpenMPConstruct> ||
-        std::is_same_v<A, parser::OmpEndLoopDirective>) {
-      return true;
-    } else {
-      return false;
-    }
+  /// is `A` a compiler-generated evaluation?
+  template<typename A> constexpr static bool isGenerated(const A &) {
+    return std::is_same_v<A, CGJump>;
   }
 
-  /// statements that are not executable
-  template<typename A> constexpr static bool isOther() {
-    if constexpr (std::is_same_v<A, parser::FormatStmt> ||
+  /// is `A` not an executable statement?
+  template<typename A> constexpr static bool isOther(const A &) {
+    return std::is_same_v<A, parser::FormatStmt> ||
         std::is_same_v<A, parser::EntryStmt> ||
         std::is_same_v<A, parser::DataStmt> ||
-        std::is_same_v<A, parser::NamelistStmt>) {
-      return true;
-    } else {
-      return false;
-    }
+        std::is_same_v<A, parser::NamelistStmt>;
+  }
+
+  constexpr bool isActionStmt() const {
+    return std::visit(common::visitors{
+                          [](auto *p) { return isAction(*p); },
+                          [](auto &r) { return isGenerated(r); },
+                      },
+        u);
   }
 
-  constexpr bool isStmt() const { return isStatement; }
+  constexpr bool isStmt() const {
+    return std::visit(common::visitors{
+                          [](auto *p) { return isAction(*p) || isOther(*p); },
+                          [](auto &r) { return isGenerated(r); },
+                      },
+        u);
+  }
   constexpr bool isConstruct() const { return !isStmt(); }
 
   /// Set the type of originating control flow type for this evaluation.
@@ -147,12 +191,12 @@ struct Evaluation {
   /// Is this evaluation a control-flow target? (The AST must be annotated)
   bool isControlTarget() const { return isTarget; }
 
-  /// Set the hasBranches flag iff this evaluation (a construct) contains
+  /// Set the containsBranches flag iff this evaluation (a construct) contains
   /// control flow
-  void setBranches() { hasBranches = true; }
+  void setBranches() { containsBranches = true; }
 
   constexpr std::list<Evaluation> *getConstructEvals() {
-    return isStatement ? nullptr : std::get_if<std::list<Evaluation>>(&ux);
+    return isStmt() ? nullptr : subs;
   }
 
   /// Set that the construct `cstr` (if not a nullptr) has branches.
@@ -163,24 +207,27 @@ struct Evaluation {
   }
 
   EvalVariant u;
-  std::variant<StmtExtra, std::list<Evaluation>> ux;
+  ParentType parent;
+  parser::CharBlock pos;
+  std::optional<parser::Label> lab;
+  std::list<Evaluation> *subs{nullptr};  // construct sub-statements
   CFGAnnotation cfg{CFGAnnotation::None};
-  bool isStatement{false};
-  bool isActionStmt{false};
-  bool isTarget{false};
-  bool hasBranches{false};
+  bool isTarget{false};  // this evaluation is a control target
+  bool containsBranches{false};  // construct contains branches
 };
 
 /// A program is a list of program units.
 /// These units can be function like, module like, or block data
 struct ProgramUnit {
-  template<typename A> ProgramUnit(A *ptr) : p{ptr} {}
+  template<typename A>
+  ProgramUnit(A *ptr, const ParentType &parent) : p{ptr}, parent{parent} {}
 
   std::variant<const parser::MainProgram *, const parser::FunctionSubprogram *,
       const parser::SubroutineSubprogram *, const parser::Module *,
       const parser::Submodule *, const parser::SeparateModuleSubprogram *,
       const parser::BlockData *>
       p;
+  ParentType parent;
 };
 
 /// Function-like units have similar structure. They all can contain executable
@@ -197,15 +244,40 @@ struct FunctionLikeUnit : public ProgramUnit {
           const parser::Statement<parser::MpSubprogramStmt> *,
           const parser::Statement<parser::EndMpSubprogramStmt> *>;
 
-  FunctionLikeUnit(const parser::MainProgram &f);
-  FunctionLikeUnit(const parser::FunctionSubprogram &f);
-  FunctionLikeUnit(const parser::SubroutineSubprogram &f);
-  FunctionLikeUnit(const parser::SeparateModuleSubprogram &f);
+  FunctionLikeUnit(const parser::MainProgram &f, const ParentType &parent);
+  FunctionLikeUnit(
+      const parser::FunctionSubprogram &f, const ParentType &parent);
+  FunctionLikeUnit(
+      const parser::SubroutineSubprogram &f, const ParentType &parent);
+  FunctionLikeUnit(
+      const parser::SeparateModuleSubprogram &f, const ParentType &parent);
+
+  bool isMainProgram() {
+    return std::get_if<const parser::Statement<parser::EndProgramStmt> *>(
+        &funStmts.back());
+  }
+  const parser::FunctionStmt *isFunction() {
+    return isA<parser::FunctionStmt>();
+  }
+  const parser::SubroutineStmt *isSubroutine() {
+    return isA<parser::SubroutineStmt>();
+  }
+  const parser::MpSubprogramStmt *isMPSubp() {
+    return isA<parser::MpSubprogramStmt>();
+  }
 
-  const semantics::Scope *scope{nullptr};
-  std::list<FunctionStatement> funStmts;
-  std::list<Evaluation> evals;
-  std::list<FunctionLikeUnit> funcs;
+  const semantics::Scope *scope{nullptr};  // scope from front-end
+  std::list<FunctionStatement> funStmts;  // begin/end pair
+  std::list<Evaluation> evals;  // statements
+  std::list<FunctionLikeUnit> funcs;  // internal procedures
+
+private:
+  template<typename A> const A *isA() {
+    if (auto p = std::get_if<const parser::Statement<A> *>(&funStmts.front())) {
+      return &(*p)->statement;
+    }
+    return nullptr;
+  }
 };
 
 /// Module-like units have similar structure. They all can contain a list of
@@ -218,8 +290,8 @@ struct ModuleLikeUnit : public ProgramUnit {
           const parser::Statement<parser::SubmoduleStmt> *,
           const parser::Statement<parser::EndSubmoduleStmt> *>;
 
-  ModuleLikeUnit(const parser::Module &m);
-  ModuleLikeUnit(const parser::Submodule &m);
+  ModuleLikeUnit(const parser::Module &m, const ParentType &parent);
+  ModuleLikeUnit(const parser::Submodule &m, const ParentType &parent);
   ~ModuleLikeUnit() = default;
 
   const semantics::Scope *scope{nullptr};
@@ -228,21 +300,28 @@ struct ModuleLikeUnit : public ProgramUnit {
 };
 
 struct BlockDataUnit : public ProgramUnit {
-  BlockDataUnit(const parser::BlockData &db);
+  BlockDataUnit(const parser::BlockData &db, const ParentType &parent);
 };
 
 /// A Program is the top-level AST
 struct Program {
   using Units = std::variant<FunctionLikeUnit, ModuleLikeUnit, BlockDataUnit>;
+
+  std::list<Units> &getUnits() { return units; }
+
+private:
   std::list<Units> units;
 };
 
 }  // namespace AST
 
 /// Create an AST from the parse tree
-AST::Program createAST(const parser::Program &root);
+AST::Program *createAST(const parser::Program &root);
 
 /// Decorate the AST with control flow annotations
+///
+/// The AST must be decorated with control-flow annotations to prepare it for
+/// use in generating a CFG-like structure.
 void annotateControl(AST::Program &ast);
 
 }  // namespace burnside
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index f571f9985f0f..172b99c504d0 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -13,14 +13,14 @@
 // limitations under the License.
 
 #include "bridge.h"
+#include "ast-builder.h"
 #include "builder.h"
 #include "convert-expr.h"
 #include "convert-type.h"
-#include "flattened.h"
 #include "intrinsics.h"
 #include "io.h"
 #include "runtime.h"
-#include "../parser/parse-tree-visitor.h"
+#include "../parser/parse-tree.h"
 #include "../semantics/tools.h"
 #include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
@@ -33,12 +33,18 @@
 #include "mlir/Target/LLVMIR.h"
 
 #undef TODO
-#define TODO() assert(false && "not yet implemented")
+#define TODO() \
+  llvm::errs() << __FILE__ << ":" << __LINE__ << " not yet implemented\n"; \
+  std::exit(1)
+
+#undef SOFT_TODO
+#define SOFT_TODO() \
+  llvm::errs() << __FILE__ << ":" << __LINE__ << " not yet implemented\n";
 
 namespace Br = Fortran::burnside;
 namespace Co = Fortran::common;
 namespace Ev = Fortran::evaluate;
-namespace Fl = Fortran::burnside::flat;
+namespace L = llvm;
 namespace M = mlir;
 namespace Pa = Fortran::parser;
 namespace Se = Fortran::semantics;
@@ -48,88 +54,387 @@ using namespace Fortran::burnside;
 
 namespace {
 
-using SomeExpr = Ev::Expr<Ev::SomeType>;
+using SelectCaseConstruct = Pa::CaseConstruct;
+using SelectRankConstruct = Pa::SelectRankConstruct;
+using SelectTypeConstruct = Pa::SelectTypeConstruct;
+
+using CFGSinkListType = L::SmallVector<AST::Evaluation *, 2>;
+using CFGMapType = L::DenseMap<AST::Evaluation *, CFGSinkListType *>;
 
-constexpr bool isStopStmt(Pa::StopStmt::Kind kind) {
-  return kind == Pa::StopStmt::Kind::Stop;
+constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
+  return std::get<Pa::StopStmt::Kind>(stm.t) == Pa::StopStmt::Kind::Stop;
 }
 
-constexpr bool firLoopOp{false};
+/// Traverse the AST and complete the CFG by drawing the arcs, pruning unused
+/// potential targets, making implied jumps explicit, etc.
+class CfgBuilder {
 
-/// Converter from Fortran to FIR
-class FIRConverter {
-  using LabelMapType = std::map<Fl::LabelMention, M::Block *>;
-  using Closure = std::function<void(const LabelMapType &)>;
+  AST::Evaluation *getEvalByLabel(const Pa::Label &label) {
+    auto iter = labels.find(label);
+    if (iter != labels.end()) {
+      return iter->second;
+    }
+    return nullptr;
+  }
 
-  struct DoBoundsInfo {
-    M::Value *doVar;
+  /// Collect all the potential targets and initialize them to unreferenced
+  void resetPotentialTargets(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      if (e.isTarget) {
+        e.isTarget = false;
+      }
+      if (e.lab.has_value()) {
+        labels.try_emplace(*e.lab, &e);
+      }
+      if (e.subs) {
+        resetPotentialTargets(*e.subs);
+      }
+    }
+  }
 
-    M::Value *counter;
-    M::Value *stepExpr;
-    M::Operation *condition;
-  };
+  /// cache ASSIGN statements that may yield a live branch target
+  void cacheAssigns(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      std::visit(Co::visitors{
+                     [&](const Pa::AssignStmt *stmt) {
+                       auto *trg = getEvalByLabel(std::get<Pa::Label>(stmt->t));
+                       auto *sym = std::get<Pa::Name>(stmt->t).symbol;
+                       assert(sym);
+                       auto jter = assignedGotoMap.find(sym);
+                       if (jter == assignedGotoMap.end()) {
+                         std::list<AST::Evaluation *> lst = {trg};
+                         assignedGotoMap.try_emplace(sym, lst);
+                       } else {
+                         jter->second.emplace_back(trg);
+                       }
+                     },
+                     [](auto) { /* do nothing */ },
+                 },
+          e.u);
+      if (e.subs) {
+        cacheAssigns(*e.subs);
+      }
+    }
+  }
 
-  M::MLIRContext &mlirContext;
-  const Pa::CookedSource *cooked;
-  M::ModuleOp &module;
-  Co::IntrinsicTypeDefaultKinds const &defaults;
-  std::unique_ptr<M::OpBuilder> builder;
-  LabelMapType blockMap;  // map from flattened labels to MLIR blocks
-  std::list<Closure> edgeQ;
-  std::map<const Pa::NonLabelDoStmt *, DoBoundsInfo> doMap;
-  SymMap symbolMap;
-  IntrinsicLibrary intrinsics;
-  Pa::CharBlock lastKnownPos;
-  bool noInsPt{false};
+  void deannotate(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      e.cfg = AST::CFGAnnotation::None;
+      if (e.subs) {
+        deannotate(*e.subs);
+      }
+    }
+  }
 
-  inline M::OpBuilder &build() { return *builder.get(); }
-  inline M::ModuleOp &getMod() { return module; }
-  inline LabelMapType &blkMap() { return blockMap; }
-  void setCurrentPos(const Pa::CharBlock &pos) { lastKnownPos = pos; }
+  bool structuredLoop(const std::optional<Pa::LoopControl> &optLoopCtrl) {
+    if (optLoopCtrl.has_value())
+      return std::visit(
+          Co::visitors{
+              [](const Pa::LoopControl::Bounds &) { return true; },
+              [](const Pa::ScalarLogicalExpr &) { return false; },
+              [](const Pa::LoopControl::Concurrent &) { return true; },
+          },
+          optLoopCtrl->u);
+    return false;
+  }
+
+  bool structuredCheck(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      if (auto **s = std::get_if<const Pa::DoConstruct *>(&e.u)) {
+        if (!structuredLoop(std::get<std::optional<Pa::LoopControl>>(
+                std::get<Pa::Statement<Pa::NonLabelDoStmt>>((*s)->t)
+                    .statement.t)))
+          return false;
+        return structuredCheck(*e.subs);
+      }
+      if (std::holds_alternative<const Pa::IfConstruct *>(e.u)) {
+        return structuredCheck(*e.subs);
+      }
+      if (e.subs) {
+        return false;
+      }
+      switch (e.cfg) {
+      case AST::CFGAnnotation::None: break;
+      case AST::CFGAnnotation::CondGoto: break;
+      case AST::CFGAnnotation::Iterative: break;
+      case AST::CFGAnnotation::FirStructuredOp: break;
+      case AST::CFGAnnotation::IndGoto: return false;
+      case AST::CFGAnnotation::IoSwitch: return false;
+      case AST::CFGAnnotation::Switch: return false;
+      case AST::CFGAnnotation::Return: return false;
+      case AST::CFGAnnotation::Terminate: return false;
+      case AST::CFGAnnotation::Goto:
+        if (!std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
+          return false;
+        }
+        break;
+      }
+    }
+    return true;
+  }
 
-  /// Convert a parser CharBlock to a Location
-  M::Location toLocation(const Pa::CharBlock &cb) {
-    return parserPosToLoc(mlirContext, cooked, cb);
+  void wrapIterationSpaces(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      if (std::holds_alternative<const Pa::DoConstruct *>(e.u))
+        if (structuredCheck(*e.subs)) {
+          deannotate(*e.subs);
+          e.cfg = AST::CFGAnnotation::FirStructuredOp;
+          continue;
+        }
+      if (std::holds_alternative<const Pa::IfConstruct *>(e.u))
+        if (structuredCheck(*e.subs)) {
+          deannotate(*e.subs);
+          e.cfg = AST::CFGAnnotation::FirStructuredOp;
+          continue;
+        }
+      // FIXME: ForallConstruct? WhereConstruct?
+      if (e.subs) {
+        wrapIterationSpaces(*e.subs);
+      }
+    }
   }
-  M::Location toLocation() { return toLocation(lastKnownPos); }
 
-  /// Construct the type of an Expr<A> expression
-  M::Type exprType(const SomeExpr *expr) {
-    return translateSomeExprToFIRType(&mlirContext, defaults, expr);
+  /// Add source->sink edge to CFG map
+  void addSourceToSink(AST::Evaluation *src, AST::Evaluation *snk) {
+    auto iter = cfgMap.find(src);
+    if (iter == cfgMap.end()) {
+      CFGSinkListType sink{snk};
+      cfgEdgeSetPool.emplace_back(std::move(sink));
+      auto rc{cfgMap.try_emplace(src, &cfgEdgeSetPool.back())};
+      assert(rc.second && "insert failed unexpectedly");
+      (void)rc;  // for release build
+      return;
+    }
+    for (auto *s : *iter->second)
+      if (s == snk) {
+        return;
+      }
+    iter->second->push_back(snk);
+  }
+
+  void addSourceToSink(AST::Evaluation *src, const Pa::Label &label) {
+    auto iter = labels.find(label);
+    assert(iter != labels.end());
+    addSourceToSink(src, iter->second);
+  }
+
+  /// Find the next ELSE IF, ELSE or END IF statement in the list
+  template<typename A> A nextFalseTarget(A iter, const A &endi) {
+    for (; iter != endi; ++iter)
+      if (std::visit(Co::visitors{
+                         [&](const Pa::ElseIfStmt *) { return true; },
+                         [&](const Pa::ElseStmt *) { return true; },
+                         [&](const Pa::EndIfStmt *) { return true; },
+                         [](auto) { return false; },
+                     },
+              iter->u)) {
+        break;
+      }
+    return iter;
   }
-  M::Type refExprType(const SomeExpr *expr) {
-    auto type{translateSomeExprToFIRType(&mlirContext, defaults, expr)};
-    return fir::ReferenceType::get(type);
+
+  /// Add branches for this IF block like construct.
+  /// Branch to the "true block", the "false block", and from the end of the
+  /// true block to the end of the construct.
+  template<typename A>
+  void doNextIfBlock(std::list<AST::Evaluation> &evals, AST::Evaluation &e,
+      const A &iter, const A &endif) {
+    A i{iter};
+    A j{nextFalseTarget(++i, endif)};
+    auto *cstr = std::get<AST::Evaluation *>(e.parent);
+    AST::CGJump jump{&*endif};
+    A k{evals.insert(j, AST::Evaluation{std::move(jump), j->parent})};
+    if (i == j) {
+      // block was empty, so adjust "true" target
+      i = k;
+    }
+    addSourceToSink(&*k, cstr);
+    addSourceToSink(&e, &*i);
+    addSourceToSink(&e, &*j);
+  }
+
+  /// Determine which branch targets are reachable. The target map must
+  /// already be initialized.
+  void reachabilityAnalysis(std::list<AST::Evaluation> &evals) {
+    for (auto iter = evals.begin(); iter != evals.end(); ++iter) {
+      auto &e = *iter;
+      switch (e.cfg) {
+      case AST::CFGAnnotation::None:
+        // do nothing - does not impart control flow
+        break;
+      case AST::CFGAnnotation::Goto:
+        std::visit(
+            Co::visitors{
+                [&](const Pa::CycleStmt *) {
+                  // FIXME: deal with construct name
+                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  addSourceToSink(&e, &cstr->subs->front());
+                },
+                [&](const Pa::ExitStmt *) {
+                  // FIXME: deal with construct name
+                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  addSourceToSink(&e, &cstr->subs->back());
+                },
+                [&](const Pa::GotoStmt *stmt) { addSourceToSink(&e, stmt->v); },
+                [&](const Pa::EndDoStmt *) {
+                  // the END DO is the loop exit landing pad
+                  // insert a JUMP as the backedge right before the END DO
+                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  AST::CGJump jump{&cstr->subs->front()};
+                  AST::Evaluation jumpEval{std::move(jump), iter->parent};
+                  evals.insert(iter, std::move(jumpEval));
+                  addSourceToSink(&e, &cstr->subs->front());
+                },
+                [&](const AST::CGJump &jump) {
+                  addSourceToSink(&e, jump.target);
+                },
+                [](auto) { assert(false && "unhandled GOTO case"); },
+            },
+            e.u);
+        break;
+      case AST::CFGAnnotation::CondGoto:
+        std::visit(Co::visitors{
+                       [&](const Pa::IfStmt *) {
+                         // check if these are marked; they must targets here
+                         auto i{iter};
+                         addSourceToSink(&e, &*(++i));
+                         addSourceToSink(&e, &*(++i));
+                       },
+                       [&](const Pa::IfThenStmt *) {
+                         doNextIfBlock(evals, e, iter, evals.end());
+                       },
+                       [&](const Pa::ElseIfStmt *) {
+                         doNextIfBlock(evals, e, iter, evals.end());
+                       },
+                       [](const Pa::WhereConstructStmt *stmt) { TODO(); },
+                       [](const Pa::MaskedElsewhereStmt *stmt) { TODO(); },
+                       [](auto) { assert(false && "unhandled CGOTO case"); },
+                   },
+            e.u);
+        break;
+      case AST::CFGAnnotation::IndGoto:
+        std::visit(
+            Co::visitors{
+                [&](const Pa::AssignedGotoStmt *stmt) {
+                  auto *sym = std::get<Pa::Name>(stmt->t).symbol;
+                  if (assignedGotoMap.find(sym) != assignedGotoMap.end())
+                    for (auto *x : assignedGotoMap[sym]) {
+                      addSourceToSink(&e, x);
+                    }
+                  for (auto &l : std::get<std::list<Pa::Label>>(stmt->t)) {
+                    addSourceToSink(&e, l);
+                  }
+                },
+                [](auto) { assert(false && "unhandled IGOTO case"); },
+            },
+            e.u);
+        break;
+      case AST::CFGAnnotation::IoSwitch:
+        std::visit(
+            Co::visitors{
+                [](const Pa::BackspaceStmt *stmt) { TODO(); },
+                [](const Pa::CloseStmt *stmt) { TODO(); },
+                [](const Pa::EndfileStmt *stmt) { TODO(); },
+                [](const Pa::FlushStmt *stmt) { TODO(); },
+                [](const Pa::InquireStmt *stmt) { TODO(); },
+                [](const Pa::OpenStmt *stmt) { TODO(); },
+                [](const Pa::ReadStmt *stmt) { TODO(); },
+                [](const Pa::RewindStmt *stmt) { TODO(); },
+                [](const Pa::WaitStmt *stmt) { TODO(); },
+                [](const Pa::WriteStmt *stmt) { TODO(); },
+                [](auto) { assert(false && "unhandled IO switch case"); },
+            },
+            e.u);
+        break;
+      case AST::CFGAnnotation::Switch:
+        std::visit(Co::visitors{
+                       [](const Pa::CallStmt *stmt) { TODO(); },
+                       [](const Pa::ArithmeticIfStmt *stmt) { TODO(); },
+                       [](const Pa::ComputedGotoStmt *stmt) { TODO(); },
+                       [](const Pa::SelectCaseStmt *stmt) { TODO(); },
+                       [](const Pa::SelectRankStmt *stmt) { TODO(); },
+                       [](const Pa::SelectTypeStmt *stmt) { TODO(); },
+                       [](auto) { assert(false && "unhandled switch case"); },
+                   },
+            e.u);
+        break;
+      case AST::CFGAnnotation::Iterative:
+        std::visit(Co::visitors{
+                       [](const Pa::NonLabelDoStmt *stmt) { TODO(); },
+                       [](const Pa::WhereStmt *stmt) { TODO(); },
+                       [](const Pa::ForallStmt *stmt) { TODO(); },
+                       [](const Pa::WhereConstruct *stmt) { TODO(); },
+                       [](const Pa::ForallConstructStmt *stmt) { TODO(); },
+                       [](auto) { assert(false && "unhandled loop case"); },
+                   },
+            e.u);
+        break;
+      case AST::CFGAnnotation::FirStructuredOp:
+        // do not visit the subs
+        continue;
+      case AST::CFGAnnotation::Return:
+        // do nothing - exits the function
+        break;
+      case AST::CFGAnnotation::Terminate:
+        // do nothing - exits the function
+        break;
+      }
+      if (e.subs) {
+        reachabilityAnalysis(*e.subs);
+      }
+    }
   }
 
-  M::Type getDefaultIntegerType() {
-    return getFIRType(&mlirContext, defaults, IntegerCat);
+  void setActualTargets(std::list<AST::Evaluation> &evals) {
+    for (auto &lst1 : cfgEdgeSetPool)
+      for (auto *e : lst1) {
+        e->isTarget = true;
+      }
   }
-  M::Type getDefaultLogicalType() {
-    return getFIRType(&mlirContext, defaults, LogicalCat);
+
+  CFGMapType &cfgMap;
+  std::list<CFGSinkListType> &cfgEdgeSetPool;
+
+  L::DenseMap<Pa::Label, AST::Evaluation *> labels;
+  std::map<Se::Symbol *, std::list<AST::Evaluation *>> assignedGotoMap;
+
+public:
+  CfgBuilder(CFGMapType &m, std::list<CFGSinkListType> &p)
+    : cfgMap{m}, cfgEdgeSetPool{p} {}
+
+  void run(AST::FunctionLikeUnit &func) {
+    resetPotentialTargets(func.evals);
+    cacheAssigns(func.evals);
+    wrapIterationSpaces(func.evals);
+    reachabilityAnalysis(func.evals);
+    setActualTargets(func.evals);
   }
+};
 
-  M::Value *createFIRAddr(M::Location loc, const SomeExpr *expr) {
+/// Converter from AST to FIR
+///
+/// After building the AST and decorating it, the FirConverter processes that
+/// representation and lowers it to the FIR executable representation.
+class FirConverter {
+  using LabelMapType = std::map<AST::Evaluation *, M::Block *>;
+  using Closure = std::function<void(const LabelMapType &)>;
+
+  //
+  // Helper function members
+  //
+
+  M::Value *createFIRAddr(M::Location loc, const Se::SomeExpr *expr) {
     return createSomeAddress(
-        loc, build(), *expr, symbolMap, defaults, intrinsics);
+        loc, *builder, *expr, localSymbols, defaults, intrinsics);
   }
-  M::Value *createFIRExpr(M::Location loc, const SomeExpr *expr) {
+
+  M::Value *createFIRExpr(M::Location loc, const Se::SomeExpr *expr) {
     return createSomeExpression(
-        loc, build(), *expr, symbolMap, defaults, intrinsics);
+        loc, *builder, *expr, localSymbols, defaults, intrinsics);
   }
-  M::Value *createLogicalExprAsI1(M::Location loc, const SomeExpr *expr) {
+  M::Value *createLogicalExprAsI1(M::Location loc, const Se::SomeExpr *expr) {
     return createI1LogicalExpression(
-        loc, build(), *expr, symbolMap, defaults, intrinsics);
-  }
-  M::Value *createTemp(M::Type type, Se::Symbol *symbol = nullptr) {
-    return createTemporary(toLocation(), build(), symbolMap, type, symbol);
-  }
-
-  M::FuncOp genFunctionFIR(llvm::StringRef callee, M::FunctionType funcTy) {
-    if (auto func{getNamedFunction(getMod(), callee)}) {
-      return func;
-    }
-    return createFunction(getMod(), callee, funcTy);
+        loc, *builder, *expr, localSymbols, defaults, intrinsics);
   }
 
   M::FuncOp genRuntimeFunction(RuntimeEntryCode rec, int kind) {
@@ -137,908 +442,922 @@ class FIRConverter {
         getRuntimeEntryName(rec), getRuntimeEntryType(rec, mlirContext, kind));
   }
 
-  template<typename T> DoBoundsInfo *getBoundsInfo(const T &linearOp) {
-    auto &st{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(linearOp.v->t)};
-    setCurrentPos(st.source);
-    auto *s{&st.statement};
-    auto iter{doMap.find(s)};
-    if (iter != doMap.end()) {
-      return &iter->second;
+  M::FuncOp genFunctionFIR(L::StringRef callee, M::FunctionType funcTy) {
+    if (auto func{getNamedFunction(module, callee)}) {
+      return func;
     }
-    assert(false && "DO context not present");
-    return nullptr;
+    return createFunction(module, callee, funcTy);
   }
 
-  // Simple scalar expression builders
-  // TODO: handle REAL and COMPLEX (iff needed)
-  template<M::CmpIPredicate ICMPOPC>
-  M::Value *genCompare(M::Value *lhs, M::Value *rhs) {
-    auto lty{lhs->getType()};
-    assert(lty == rhs->getType());
-    if (lty.isIntOrIndex()) {
-      return build().create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
-    }
-    if (fir::LogicalType::kindof(lty.getKind())) {
-      return build().create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
-    }
-    if (fir::CharacterType::kindof(lty.getKind())) {
-      // return build().create<M::CallOp>(lhs->getLoc(), );
-      return {};
-    }
-    assert(false && "cannot generate operation on this type");
-    return {};
-  }
-  M::Value *genGE(M::Value *lhs, M::Value *rhs) {
-    return genCompare<M::CmpIPredicate::sge>(lhs, rhs);
+  bool inMainProgram(AST::Evaluation *cstr) {
+    return std::visit(
+        Co::visitors{
+            [](AST::FunctionLikeUnit *c) { return c->isMainProgram(); },
+            [&](AST::Evaluation *c) { return inMainProgram(c); },
+            [](auto *) { return false; },
+        },
+        cstr->parent);
   }
-  M::Value *genLE(M::Value *lhs, M::Value *rhs) {
-    return genCompare<M::CmpIPredicate::sle>(lhs, rhs);
+  const Pa::SubroutineStmt *inSubroutine(AST::Evaluation *cstr) {
+    return std::visit(
+        Co::visitors{
+            [](AST::FunctionLikeUnit *c) { return c->isSubroutine(); },
+            [&](AST::Evaluation *c) { return inSubroutine(c); },
+            [](auto *) -> const Pa::SubroutineStmt * { return nullptr; },
+        },
+        cstr->parent);
   }
-  M::Value *genEQ(M::Value *lhs, M::Value *rhs) {
-    return genCompare<M::CmpIPredicate::eq>(lhs, rhs);
+  const Pa::FunctionStmt *inFunction(AST::Evaluation *cstr) {
+    return std::visit(
+        Co::visitors{
+            [](AST::FunctionLikeUnit *c) { return c->isFunction(); },
+            [&](AST::Evaluation *c) { return inFunction(c); },
+            [](auto *) -> const Pa::FunctionStmt * { return nullptr; },
+        },
+        cstr->parent);
   }
-  M::Value *genAND(M::Value *lhs, M::Value *rhs) {
-    return build().create<M::AndOp>(lhs->getLoc(), lhs, rhs);
+  const Pa::MpSubprogramStmt *inMPSubp(AST::Evaluation *cstr) {
+    return std::visit(
+        Co::visitors{
+            [](AST::FunctionLikeUnit *c) { return c->isMPSubp(); },
+            [&](AST::Evaluation *c) { return inMPSubp(c); },
+            [](auto *) -> const Pa::MpSubprogramStmt * { return nullptr; },
+        },
+        cstr->parent);
   }
 
-  template<typename A> void genFIR(const Co::Indirection<A> &indirection) {
-    genFIR(indirection.value());
+  template<typename A>
+  const Se::SomeExpr *getScalarExprOfTuple(const A &tuple) {
+    return Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(tuple));
+  }
+  template<typename A> const Se::SomeExpr *getExprOfTuple(const A &tuple) {
+    return Se::GetExpr(std::get<Pa::LogicalExpr>(tuple));
+  }
+  /// Get the condition expression for a CondGoto evaluation
+  const Se::SomeExpr *getEvaluationCondition(AST::Evaluation &eval) {
+    return std::visit(Co::visitors{
+                          [&](const Pa::IfStmt *stmt) {
+                            return getScalarExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::IfThenStmt *stmt) {
+                            return getScalarExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::ElseIfStmt *stmt) {
+                            return getScalarExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::WhereConstructStmt *stmt) {
+                            return getExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::MaskedElsewhereStmt *stmt) {
+                            return getExprOfTuple(stmt->t);
+                          },
+                          [](auto) -> const Se::SomeExpr * {
+                            assert(
+                                false && "unexpected conditional branch case");
+                            return nullptr;
+                          },
+                      },
+        eval.u);
+  }
+
+  //
+  // Function-like AST entry and exit statements
+  //
+
+  void genFIR(const Pa::Statement<Pa::ProgramStmt> &stmt, std::string &name,
+      Se::Symbol const *&) {
+    setCurrentPosition(stmt.source);
+    name = mangler.getProgramEntry();
+  }
+  void genFIR(const Pa::Statement<Pa::EndProgramStmt> &stmt, std::string &,
+      Se::Symbol const *&) {
+    setCurrentPosition(stmt.source);
+    genFIR(stmt.statement);
+  }
+  void genFIR(const Pa::Statement<Pa::FunctionStmt> &stmt, std::string &name,
+      Se::Symbol const *&symbol) {
+    setCurrentPosition(stmt.source);
+    auto &n{std::get<Pa::Name>(stmt.statement.t)};
+    name = n.ToString();
+    symbol = n.symbol;
   }
-  template<typename A> void genFIR(const Pa::Statement<A> &stmt) {
-    setCurrentPos(stmt.source);
+  void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
+      Se::Symbol const *&) {
+    setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
-  template<typename A> void genFIR(const std::list<A> &list) {
-    for (auto &a : list) {
-      genFIR(a);
-    }
+  void genFIR(const Pa::Statement<Pa::SubroutineStmt> &stmt, std::string &name,
+      Se::Symbol const *&symbol) {
+    setCurrentPosition(stmt.source);
+    auto &n{std::get<Pa::Name>(stmt.statement.t)};
+    name = n.ToString();
+    symbol = n.symbol;
   }
-  template<typename A> void genFIROnVariant(const A &variant) {
-    std::visit([&](auto &s) { genFIR(s); }, variant.u);
+  void genFIR(const Pa::Statement<Pa::EndSubroutineStmt> &stmt, std::string &,
+      Se::Symbol const *&) {
+    setCurrentPosition(stmt.source);
+    genFIR(stmt.statement);
+  }
+  void genFIR(const Pa::Statement<Pa::MpSubprogramStmt> &stmt,
+      std::string &name, Se::Symbol const *&symbol) {
+    setCurrentPosition(stmt.source);
+    auto &n{stmt.statement.v};
+    name = n.ToString();
+    symbol = n.symbol;
+  }
+  void genFIR(const Pa::Statement<Pa::EndMpSubprogramStmt> &stmt, std::string &,
+      Se::Symbol const *&) {
+    setCurrentPosition(stmt.source);
+    genFIR(stmt.statement);
   }
 
-  void genFIR(AnalysisData &ad, std::list<Fl::Op> &operations);
+  //
+  // Termination of symbolically referenced execution units
+  //
 
-  // Control flow destination
-  void genFIR(bool lastWasLabel, const Fl::LabelOp &op) {
-    if (lastWasLabel) {
-      blkMap().insert({op.get(), build().getInsertionBlock()});
-    } else {
-      auto *currBlock{build().getInsertionBlock()};
-      auto *newBlock{createBlock(&build())};
-      blkMap().insert({op.get(), newBlock});
-      if (!noInsPt) {
-        build().setInsertionPointToEnd(currBlock);
-        build().create<M::BranchOp>(toLocation(), newBlock);
-      }
-      build().setInsertionPointToStart(newBlock);
-    }
+  /// END of program
+  ///
+  /// Generate the cleanup block before the program exits
+  void genFIRProgramExit() { builder->create<M::ReturnOp>(toLocation()); }
+  void genFIR(const Pa::EndProgramStmt &) { genFIRProgramExit(); }
+
+  /// END of procedure-like constructs
+  ///
+  /// Generate the cleanup block before the procedure exits
+  void genFIRFunctionReturn(const Pa::FunctionStmt *stmt) {
+    auto &name = std::get<Pa::Name>(stmt->t);
+    assert(name.symbol);
+    const auto &details{name.symbol->get<Se::SubprogramDetails>()};
+    M::Value *resultRef{localSymbols.lookupSymbol(details.result())};
+    // FIXME: what happens if result was never referenced before and hence no
+    // temp was created?
+    assert(resultRef);
+    M::Value *r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
+    builder->create<M::ReturnOp>(toLocation(), r);
+  }
+  void genFIR(const Pa::EndFunctionStmt &stmt) {
+    genFIRFunctionReturn(inFunction(currentEvaluation));
+  }
+  template<typename A> void genFIRProcedureExit(const A *) {
+    // FIXME: alt-returns
+    builder->create<M::ReturnOp>(toLocation());
+  }
+  void genFIR(const Pa::EndSubroutineStmt &stmt) {
+    genFIRProcedureExit(inSubroutine(currentEvaluation));
+  }
+  void genFIR(const Pa::EndMpSubprogramStmt &stmt) {
+    genFIRProcedureExit(inMPSubp(currentEvaluation));
+  }
+
+  //
+  // Statements that have control-flow semantics
+  //
+
+  // Conditional goto control-flow semantics
+  void genFIREvalCondGoto(AST::Evaluation &eval) {
+    genFIR(eval);
+    auto targets{findTargetsOf(eval)};
+    auto *expr{getEvaluationCondition(eval)};
+    assert(expr && "condition expression missing");
+    auto *cond{createLogicalExprAsI1(toLocation(), expr)};
+    genFIRCondBranch(cond, targets[0], targets[1]);
+  }
+
+  void genFIRCondBranch(
+      M::Value *cond, AST::Evaluation *trueDest, AST::Evaluation *falseDest) {
+    using namespace std::placeholders;
+    localEdgeQ.emplace_back(std::bind(
+        [](M::OpBuilder *builder, M::Block *block, M::Value *cnd,
+            AST::Evaluation *trueDest, AST::Evaluation *falseDest,
+            M::Location location, const LabelMapType &map) {
+          L::SmallVector<M::Value *, 2> blk;
+          builder->setInsertionPointToEnd(block);
+          auto tdp{map.find(trueDest)};
+          auto fdp{map.find(falseDest)};
+          assert(tdp != map.end() && fdp != map.end());
+          builder->create<M::CondBranchOp>(
+              location, cnd, tdp->second, blk, fdp->second, blk);
+        },
+        builder, builder->getInsertionBlock(), cond, trueDest, falseDest,
+        toLocation(), _1));
+  }
+
+  // Goto control-flow semantics
+  //
+  // These are unconditional jumps. There is nothing to evaluate.
+  void genFIREvalGoto(AST::Evaluation &eval) {
+    using namespace std::placeholders;
+    localEdgeQ.emplace_back(std::bind(
+        [](M::OpBuilder *builder, M::Block *block, AST::Evaluation *dest,
+            M::Location location, const LabelMapType &map) {
+          builder->setInsertionPointToEnd(block);
+          assert(map.find(dest) != map.end() && "no destination");
+          builder->create<M::BranchOp>(location, map.find(dest)->second);
+        },
+        builder, builder->getInsertionBlock(), findSinkOf(eval), toLocation(),
+        _1));
+  }
+
+  // Indirect goto control-flow semantics
+  //
+  // For assigned gotos, which is an obsolescent feature. Lower to a switch.
+  void genFIREvalIndGoto(AST::Evaluation &eval) {
+    genFIR(eval);
+    // FIXME
   }
 
-  // Goto statements
-  void genFIR(const Fl::GotoOp &op) {
-    auto iter{blkMap().find(op.target)};
-    if (iter != blkMap().end()) {
-      build().create<M::BranchOp>(toLocation(), iter->second);
+  // IO statements that have control-flow semantics
+  //
+  // First lower the IO statement and then do the multiway switch op
+  void genFIREvalIoSwitch(AST::Evaluation &eval) {
+    genFIR(eval);
+    genFIRIOSwitch(eval);
+  }
+  void genFIRIOSwitch(AST::Evaluation &) { TODO(); }
+
+  // Iterative loop control-flow semantics
+  void genFIREvalIterative(AST::Evaluation &eval) {
+    // FIXME
+  }
+
+  void switchInsertionPointToWhere(fir::WhereOp &where) {
+    builder->setInsertionPointToStart(&where.whereRegion().front());
+  }
+  void switchInsertionPointToOtherwise(fir::WhereOp &where) {
+    builder->setInsertionPointToStart(&where.otherRegion().front());
+  }
+  template<typename A>
+  void handleCondition(fir::WhereOp &where, const A *stmt) {
+    auto *cond{createLogicalExprAsI1(
+        toLocation(), Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(stmt->t)))};
+    where = builder->create<fir::WhereOp>(toLocation(), cond, true);
+    switchInsertionPointToWhere(where);
+  }
+
+  // Structured control op (fir.loop, fir.where)
+  void genFIREvalStructuredOp(AST::Evaluation &eval) {
+    // process the list of Evaluations
+    assert(eval.subs);
+    auto *insPt = builder->getInsertionBlock();
+
+    if (std::holds_alternative<const Pa::DoConstruct *>(eval.u)) {
+      // Construct fir.loop
+      fir::LoopOp doLoop;
+      for (auto &e : *eval.subs) {
+        if (auto **s = std::get_if<const Pa::NonLabelDoStmt *>(&e.u)) {
+          // do bounds, fir.loop op
+          std::visit(
+              Co::visitors{
+                  [&](const Pa::LoopControl::Bounds &x) {
+                    auto *lo =
+                        createFIRExpr(toLocation(), Se::GetExpr(x.lower));
+                    auto *hi =
+                        createFIRExpr(toLocation(), Se::GetExpr(x.upper));
+                    L::SmallVector<M::Value *, 1> step;
+                    if (x.step.has_value()) {
+                      step.emplace_back(
+                          createFIRExpr(toLocation(), Se::GetExpr(*x.step)));
+                    }
+                    doLoop = builder->create<fir::LoopOp>(
+                        toLocation(), lo, hi, step);
+                    builder->setInsertionPointToStart(doLoop.getBody());
+                  },
+                  [](const Pa::ScalarLogicalExpr &) {
+                    assert(false && "loop lacks iteration space");
+                  },
+                  [&](const Pa::LoopControl::Concurrent &x) {
+                    // FIXME: can project a multi-dimensional space
+                    doLoop = builder->create<fir::LoopOp>(toLocation(),
+                        (M::Value *)nullptr, (M::Value *)nullptr,
+                        L::ArrayRef<M::Value *>{});
+                    builder->setInsertionPointToStart(doLoop.getBody());
+                  },
+              },
+              std::get<std::optional<Pa::LoopControl>>((*s)->t)->u);
+        } else if (std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
+          // close fir.loop op
+          builder->clearInsertionPoint();
+        } else {
+          genFIR(e);
+        }
+      }
+    } else if (std::holds_alternative<const Pa::IfConstruct *>(eval.u)) {
+      // Construct fir.where
+      fir::WhereOp where;
+      for (auto &e : *eval.subs) {
+        if (auto **s = std::get_if<const Pa::IfThenStmt *>(&e.u)) {
+          // fir.where op
+          handleCondition(where, *s);
+        } else if (auto **s = std::get_if<const Pa::ElseIfStmt *>(&e.u)) {
+          // otherwise block, then nested fir.where
+          switchInsertionPointToOtherwise(where);
+          handleCondition(where, *s);
+        } else if (std::holds_alternative<const Pa::ElseStmt *>(e.u)) {
+          // otherwise block
+          switchInsertionPointToOtherwise(where);
+        } else if (std::holds_alternative<const Pa::EndIfStmt *>(e.u)) {
+          // close all open fir.where ops
+          builder->clearInsertionPoint();
+        } else {
+          genFIR(e);
+        }
+      }
     } else {
-      using namespace std::placeholders;
-      edgeQ.emplace_back(std::bind(
-          [](M::OpBuilder *builder, M::Block *block, Fl::LabelMention dest,
-              M::Location location, const LabelMapType &map) {
-            builder->setInsertionPointToEnd(block);
-            assert(map.find(dest) != map.end() && "no destination");
-            builder->create<M::BranchOp>(location, map.find(dest)->second);
-          },
-          &build(), build().getInsertionBlock(), op.target, toLocation(), _1));
+      assert(false && "not yet implemented");
     }
-    noInsPt = true;
+    builder->setInsertionPointToEnd(insPt);
   }
-  void genFIR(AnalysisData &ad, const Fl::ReturnOp &op) {
-    std::visit(Co::visitors{
-                   [&](const Pa::ReturnStmt *stmt) { genReturnStmt(ad, stmt); },
-                   [&](const auto *stmt) { genFIR(*stmt); },
-               },
-        op.u);
-    noInsPt = true;
+
+  // Return from subprogram control-flow semantics
+  void genFIREvalReturn(AST::Evaluation &eval) {
+    // Handled case-by-case
+    // FIXME: think about moving the case code here
   }
-  void genFIR(const Fl::ConditionalGotoOp &op) {
-    std::visit(
-        [&](const auto *stmt) { genFIR(*stmt, op.trueLabel, op.falseLabel); },
-        op.u);
-    noInsPt = true;
+
+  // Multiway switch control-flow semantics
+  void genFIREvalSwitch(AST::Evaluation &eval) {
+    genFIR(eval);
+    // FIXME
   }
 
-  // IO statement with END, ERR, EOR labels
-  void genFIR(const Fl::SwitchIOOp &op) {
-    auto loc{toLocation(op.source)};
-    (void)loc;
-    TODO();
+  // Terminate process control-flow semantics
+  //
+  // Call a runtime routine that does not return
+  void genFIREvalTerminate(AST::Evaluation &eval) {
+    genFIR(eval);
+    builder->create<fir::UnreachableOp>(toLocation());
   }
 
-  // CALL with alt-return value returned
-  void genFIR(const Fl::SwitchOp &op, const Pa::CallStmt &stmt) {
-    auto loc{toLocation(op.source)};
+  // No control-flow
+  void genFIREvalNone(AST::Evaluation &eval) { genFIR(eval); }
+
+  void genFIR(const Pa::CallStmt &stmt) {
+    // FIXME handle alternate return
+    auto loc{toLocation()};
     (void)loc;
     TODO();
   }
-  void genFIR(const Fl::SwitchOp &op, const Pa::ComputedGotoStmt &stmt) {
-    auto loc{toLocation(op.source)};
+  void genFIR(const Pa::IfStmt &) { TODO(); }
+  void genFIR(const Pa::WaitStmt &) { TODO(); }
+  void genFIR(const Pa::WhereStmt &) { TODO(); }
+  void genFIR(const Pa::ComputedGotoStmt &stmt) {
     auto *exp{Se::GetExpr(std::get<Pa::ScalarIntExpr>(stmt.t))};
-    auto *e1{createFIRExpr(loc, exp)};
+    auto *e1{createFIRExpr(toLocation(), exp)};
     (void)e1;
     TODO();
   }
-  void genFIR(const Fl::SwitchOp &op, const Pa::ArithmeticIfStmt &stmt) {
-    auto loc{toLocation(op.source)};
+  void genFIR(const Pa::ForallStmt &) { TODO(); }
+  void genFIR(const Pa::ArithmeticIfStmt &stmt) {
     auto *exp{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
-    auto *e1{createFIRExpr(loc, exp)};
+    auto *e1{createFIRExpr(toLocation(), exp)};
     (void)e1;
     TODO();
   }
-  M::Value *fromCaseValue(const M::Location &locs, const Pa::CaseValue &val) {
-    return createFIRExpr(locs, Se::GetExpr(val));
-  }
-  void genFIR(const Fl::SwitchOp &op, const Pa::CaseConstruct &stmt);
-  void genFIR(const Fl::SwitchOp &op, const Pa::SelectRankConstruct &stmt);
-  void genFIR(const Fl::SwitchOp &op, const Pa::SelectTypeConstruct &stmt);
-  void genFIR(const Fl::SwitchOp &op) {
-    std::visit([&](auto *construct) { genFIR(op, *construct); }, op.u);
-    noInsPt = true;
-  }
-
-  void genFIR(AnalysisData &ad, const Fl::ActionOp &op);
-
-  void pushDoContext(const Pa::NonLabelDoStmt *doStmt,
-      M::Value *doVar = nullptr, M::Value *counter = nullptr,
-      M::Value *stepExpr = nullptr) {
-    doMap.emplace(doStmt, DoBoundsInfo{doVar, counter, stepExpr, 0});
-  }
-
-  void genLoopEnterFIR(const Pa::LoopControl::Bounds &bounds,
-      const Pa::NonLabelDoStmt *stmt, const Pa::CharBlock &source) {
-    auto loc{toLocation(source)};
-    // evaluate e1, e2 [, e3] ...
-    auto *e1{createFIRExpr(loc, Se::GetExpr(bounds.lower))};
-    auto *e2{createFIRExpr(loc, Se::GetExpr(bounds.upper))};
-    if (firLoopOp) {
-      std::vector<M::Value *> step;
-      if (bounds.step.has_value())
-        step.push_back(createFIRExpr(loc, Se::GetExpr(bounds.step)));
-      auto loopOp{build().create<fir::LoopOp>(loc, e1, e2, step)};
-      auto *block = createBlock(&build(), &loopOp.getOperation()->getRegion(0));
-      block->addArgument(M::IndexType::get(build().getContext()));
-      return;
-    }
-    auto *nameExpr{bounds.name.thing.symbol};
-    auto *name{createTemp(getDefaultIntegerType(), nameExpr)};
-    M::Value *e3;
-    if (bounds.step.has_value()) {
-      auto *stepExpr{Se::GetExpr(bounds.step)};
-      e3 = createFIRExpr(loc, stepExpr);
-    } else {
-      auto attr{build().getIntegerAttr(e2->getType(), 1)};
-      e3 = build().create<M::ConstantOp>(loc, attr);
-    }
-    // name <- e1
-    build().create<fir::StoreOp>(loc, e1, name);
-    auto tripCounter{createTemp(getDefaultIntegerType())};
-    // See 11.1.7.4.1, para. 1, item (3)
-    // totalTrips ::= iteration count = a
-    //   where a = (e2 - e1 + e3) / e3 if a > 0 and 0 otherwise
-    auto c1{build().create<M::SubIOp>(loc, e2, e1)};
-    auto c2{build().create<M::AddIOp>(loc, c1.getResult(), e3)};
-    auto c3{build().create<M::DivISOp>(loc, c2.getResult(), e3)};
-    auto *totalTrips{c3.getResult()};
-    build().create<fir::StoreOp>(loc, totalTrips, tripCounter);
-    pushDoContext(stmt, name, tripCounter, e3);
-  }
-
-  void genLoopEnterFIR(const Pa::ScalarLogicalExpr &logicalExpr,
-      const Pa::NonLabelDoStmt *stmt, const Pa::CharBlock &source) {
-    // See 11.1.7.4.1, para. 2
-    // See BuildLoopHeaderExpression()
-    pushDoContext(stmt);
-  }
-
-  void genLoopEnterFIR(const Pa::LoopControl::Concurrent &concurrent,
-      const Pa::NonLabelDoStmt *stmt, const Pa::CharBlock &source) {
-    // See 11.1.7.4.2
-    TODO();
-  }
+  void genFIR(const Pa::AssignedGotoStmt &) { TODO(); }
 
-  void genEnterFIR(const Pa::DoConstruct &construct) {
-    auto &stmt{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(construct.t)};
-    setCurrentPos(stmt.source);
+  void genFIR(const Pa::AssociateConstruct &) { TODO(); }
+  void genFIR(const Pa::BlockConstruct &) { TODO(); }
+  void genFIR(const Pa::ChangeTeamConstruct &) { TODO(); }
+  void genFIR(const Pa::CriticalConstruct &) { TODO(); }
+  void genFIR(const Pa::DoConstruct &d) {
+#if 0
+    auto &stmt{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(d.t)};
     const Pa::NonLabelDoStmt &ss{stmt.statement};
     auto &ctrl{std::get<std::optional<Pa::LoopControl>>(ss.t)};
     if (ctrl.has_value()) {
-      std::visit([&](const auto &x) { genLoopEnterFIR(x, &ss, stmt.source); },
-          ctrl->u);
+      // std::visit([&](const auto &x) { genLoopEnterFIR(x, &ss, stmt.source);
+      // }, ctrl->u);
     } else {
       // loop forever (See 11.1.7.4.1, para. 2)
-      pushDoContext(&ss);
+      // pushDoContext(&ss);
     }
+#endif
+    SOFT_TODO();
   }
+  void genFIR(const Pa::IfConstruct &) { SOFT_TODO(); }
+
+  void genFIR(const SelectCaseConstruct &) { TODO(); }
+  void genFIR(const SelectRankConstruct &) { TODO(); }
+  void genFIR(const SelectTypeConstruct &) { TODO(); }
+
+  void genFIR(const Pa::WhereConstruct &) { TODO(); }
 
   /// Lower FORALL construct (See 10.2.4)
-  void genEnterFIR(const Pa::ForallConstruct &forall) {
+  void genFIR(const Pa::ForallConstruct &forall) {
     auto &stmt{std::get<Pa::Statement<Pa::ForallConstructStmt>>(forall.t)};
-    setCurrentPos(stmt.source);
+    setCurrentPosition(stmt.source);
     auto &fas{stmt.statement};
     auto &ctrl{std::get<Co::Indirection<Pa::ConcurrentHeader>>(fas.t).value()};
-    auto &bld{build()};
     (void)ctrl;
-    (void)bld;  // FIXME
-    // bld.create<fir::LoopOp>();
     for (auto &s : std::get<std::list<Pa::ForallBodyConstruct>>(forall.t)) {
-      genFIROnVariant(s);
+      std::visit(Co::visitors{
+                     [&](const Pa::Statement<Pa::ForallAssignmentStmt> &b) {
+                       setCurrentPosition(b.source);
+                       genFIR(b.statement);
+                     },
+                     [&](const Pa::Statement<Pa::WhereStmt> &b) {
+                       setCurrentPosition(b.source);
+                       genFIR(b.statement);
+                     },
+                     [&](const Pa::WhereConstruct &b) { genFIR(b); },
+                     [&](const Co::Indirection<Pa::ForallConstruct> &b) {
+                       genFIR(b.value());
+                     },
+                     [&](const Pa::Statement<Pa::ForallStmt> &b) {
+                       setCurrentPosition(b.source);
+                       genFIR(b.statement);
+                     },
+                 },
+          s.u);
     }
     TODO();
   }
-  void genFIR(const Pa::ForallConstruct &forall) { genEnterFIR(forall); }
-  void genFIR(const Pa::ForallAssignmentStmt &s) { genFIROnVariant(s); }
-
-  void genEnterFIR(const Pa::WhereConstruct &where) { TODO(); }
-  void genFIR(const Pa::WhereConstruct &where) { genEnterFIR(where); }
-
-  void genFIR(const Fl::BeginOp &op) {
-    std::visit([&](auto *construct) { genEnterFIR(*construct); }, op.u);
+  void genFIR(const Pa::ForallAssignmentStmt &s) {
+    std::visit([&](auto &b) { genFIR(b); }, s.u);
+  }
+
+  void genFIR(const Pa::CompilerDirective &) { TODO(); }
+  void genFIR(const Pa::OpenMPConstruct &) { TODO(); }
+  void genFIR(const Pa::OmpEndLoopDirective &) { TODO(); }
+
+  void genFIR(const parser::AssociateStmt &) { TODO(); }
+  void genFIR(const parser::EndAssociateStmt &) { TODO(); }
+  void genFIR(const parser::BlockStmt &) { TODO(); }
+  void genFIR(const parser::EndBlockStmt &) { TODO(); }
+  void genFIR(const parser::SelectCaseStmt &) { TODO(); }
+  void genFIR(const parser::CaseStmt &) { TODO(); }
+  void genFIR(const parser::EndSelectStmt &) { TODO(); }
+  void genFIR(const parser::ChangeTeamStmt &) { TODO(); }
+  void genFIR(const parser::EndChangeTeamStmt &) { TODO(); }
+  void genFIR(const parser::CriticalStmt &) { TODO(); }
+  void genFIR(const parser::EndCriticalStmt &) { TODO(); }
+
+  // Do loop is handled by EvalIterative(), EvalStructuredOp()
+  void genFIR(const parser::NonLabelDoStmt &) {}  // do nothing
+  void genFIR(const parser::EndDoStmt &) {}  // do nothing
+
+  // If-Then-Else is handled by EvalCondGoto(), EvalStructuredOp()
+  void genFIR(const parser::IfThenStmt &) {}  // do nothing
+  void genFIR(const parser::ElseIfStmt &) {}  // do nothing
+  void genFIR(const parser::ElseStmt &) {}  // do nothing
+  void genFIR(const parser::EndIfStmt &) {}  // do nothing
+
+  void genFIR(const parser::SelectRankStmt &) { TODO(); }
+  void genFIR(const parser::SelectRankCaseStmt &) { TODO(); }
+  void genFIR(const parser::SelectTypeStmt &) { TODO(); }
+  void genFIR(const parser::TypeGuardStmt &) { TODO(); }
+
+  void genFIR(const parser::WhereConstructStmt &) { TODO(); }
+  void genFIR(const parser::MaskedElsewhereStmt &) { TODO(); }
+  void genFIR(const parser::ElsewhereStmt &) { TODO(); }
+  void genFIR(const parser::EndWhereStmt &) { TODO(); }
+  void genFIR(const parser::ForallConstructStmt &) { TODO(); }
+  void genFIR(const parser::EndForallStmt &) { TODO(); }
+
+  //
+  // Statements that do not have control-flow semantics
+  //
+
+  void genFIR(const Pa::AllocateStmt &) { TODO(); }
+  void genFIR(const Pa::AssignmentStmt &stmt) {
+    auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
+    auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
+    auto loc{toLocation()};
+    builder->create<fir::StoreOp>(
+        loc, createFIRExpr(loc, rhs), createFIRAddr(loc, lhs));
   }
 
-  void genEnterFIR(const Pa::AssociateConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::BlockConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::CaseConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::ChangeTeamConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::CriticalConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::IfConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::CompilerDirective &) { TODO(); }
-  void genEnterFIR(const Pa::OpenMPConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::OmpEndLoopDirective &) { TODO(); }
-  void genEnterFIR(const Pa::SelectRankConstruct &) { TODO(); }
-  void genEnterFIR(const Pa::SelectTypeConstruct &) { TODO(); }
+  void genFIR(const Pa::BackspaceStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::CloseStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::ContinueStmt &) {}  // do nothing
+  void genFIR(const Pa::DeallocateStmt &) { TODO(); }
+  void genFIR(const Pa::EndfileStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::EventPostStmt &) {
+    // call some runtime routine
+    TODO();
+  }
+  void genFIR(const Pa::EventWaitStmt &) {
+    // call some runtime routine
+    TODO();
+  }
+  void genFIR(const Pa::FlushStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::FormTeamStmt &) { TODO(); }
+  void genFIR(const Pa::InquireStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::LockStmt &) {
+    // call some runtime routine
+    TODO();
+  }
+  void genFIR(const Pa::NullifyStmt &) { TODO(); }
+  void genFIR(const Pa::OpenStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::PointerAssignmentStmt &) { TODO(); }
 
-  void genExitFIR(const Pa::DoConstruct &construct) {
-    if (firLoopOp) {
-      build().setInsertionPointAfter(
-          build().getBlock()->getParent()->getParentOp());
-      return;
-    }
-    auto &stmt{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(construct.t)};
-    setCurrentPos(stmt.source);
-    const Pa::NonLabelDoStmt &ss{stmt.statement};
-    auto &ctrl{std::get<std::optional<parser::LoopControl>>(ss.t)};
-    if (ctrl.has_value() &&
-        std::holds_alternative<parser::LoopControl::Bounds>(ctrl->u)) {
-      doMap.erase(&ss);
+  void genFIR(const Pa::PrintStmt &stmt) {
+    L::SmallVector<mlir::Value *, 4> args;
+    for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
+      if (auto *parserExpr{std::get_if<Pa::Expr>(&item.u)}) {
+        auto loc{toLocation(parserExpr->source)};
+        args.push_back(createFIRExpr(loc, Se::GetExpr(*parserExpr)));
+      } else {
+        TODO();  // implied do
+      }
     }
-    noInsPt = true;  // backedge already processed
+    genPrintStatement(*builder, toLocation(), args);
   }
 
-  void genFIR(const Fl::EndOp &op) {
-    if (auto *construct{std::get_if<const Pa::DoConstruct *>(&op.u)})
-      genExitFIR(**construct);
+  void genFIR(const Pa::ReadStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
   }
-
-  void genFIR(AnalysisData &ad, const Fl::IndirectGotoOp &op);
-
-  void genFIR(const Fl::DoIncrementOp &op) {
-    if (firLoopOp) {
-      return;
-    }
-    auto *info{getBoundsInfo(op)};
-    if (info->doVar && info->stepExpr) {
-      // add: do_var = do_var + e3
-      auto load{
-          build().create<fir::LoadOp>(info->doVar->getLoc(), info->doVar)};
-      auto incremented{build().create<M::AddIOp>(
-          load.getLoc(), load.getResult(), info->stepExpr)};
-      build().create<fir::StoreOp>(load.getLoc(), incremented, info->doVar);
-      // add: counter--
-      auto loadCtr{
-          build().create<fir::LoadOp>(info->counter->getLoc(), info->counter)};
-      auto one{build().create<M::ConstantOp>(
-          loadCtr.getLoc(), build().getIntegerAttr(loadCtr.getType(), 1))};
-      auto decremented{build().create<M::SubIOp>(
-          loadCtr.getLoc(), loadCtr.getResult(), one)};
-      build().create<fir::StoreOp>(
-          loadCtr.getLoc(), decremented, info->counter);
-    }
+  void genFIR(const Pa::RewindStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::SyncAllStmt &) {
+    // call some runtime routine
+    TODO();
+  }
+  void genFIR(const Pa::SyncImagesStmt &) {
+    // call some runtime routine
+    TODO();
+  }
+  void genFIR(const Pa::SyncMemoryStmt &) {
+    // call some runtime routine
+    TODO();
+  }
+  void genFIR(const Pa::SyncTeamStmt &) {
+    // call some runtime routine
+    TODO();
+  }
+  void genFIR(const Pa::UnlockStmt &) {
+    // call some runtime routine
+    TODO();
   }
 
-  void genFIR(const Fl::DoCompareOp &op) {
-    if (firLoopOp) {
-      return;
-    }
-    auto *info{getBoundsInfo(op)};
-    if (info->doVar && info->stepExpr) {
-      // add: cond = counter > 0 (signed)
-      auto load{
-          build().create<fir::LoadOp>(info->counter->getLoc(), info->counter)};
-      auto zero{build().create<M::ConstantOp>(
-          load.getLoc(), build().getIntegerAttr(load.getType(), 0))};
-      auto cond{build().create<M::CmpIOp>(
-          load.getLoc(), M::CmpIPredicate::sgt, load, zero)};
-      info->condition = cond;
-    }
+  void genFIR(const Pa::WriteStmt &) {
+    // call some IO runtime routine(s)
+    TODO();
+  }
+  void genFIR(const Pa::AssignStmt &) { TODO(); }
+  void genFIR(const Pa::FormatStmt &) { TODO(); }
+  void genFIR(const Pa::EntryStmt &) { TODO(); }
+  void genFIR(const Pa::PauseStmt &) {
+    // call some runtime routine
+    TODO();
   }
+  void genFIR(const Pa::DataStmt &) { TODO(); }
+  void genFIR(const Pa::NamelistStmt &) { TODO(); }
 
+  // call FAIL IMAGE in runtime
   void genFIR(const Pa::FailImageStmt &stmt) {
     auto callee{genRuntimeFunction(FIRT_FAIL_IMAGE, 0)};
-    llvm::SmallVector<M::Value *, 1> operands;  // FAIL IMAGE has no args
-    build().create<M::CallOp>(toLocation(), callee, operands);
-    build().create<fir::UnreachableOp>(toLocation());
+    L::SmallVector<M::Value *, 1> operands;  // FAIL IMAGE has no args
+    builder->create<M::CallOp>(toLocation(), callee, operands);
   }
 
-  void genReturnStmt(AnalysisData &, const Pa::FunctionSubprogram &func) {
-    auto &stmt{std::get<Pa::Statement<Pa::FunctionStmt>>(func.t)};
-    auto &name{std::get<Pa::Name>(stmt.statement.t)};
-    assert(name.symbol);
-    const auto &details{name.symbol->get<Se::SubprogramDetails>()};
-    M::Value *resultRef{symbolMap.lookupSymbol(details.result())};
-    assert(resultRef);  // FIXME might die if result
-    // was never referenced before and temp not created.
-    M::Value *resultVal{build().create<fir::LoadOp>(toLocation(), resultRef)};
-    build().create<M::ReturnOp>(toLocation(), resultVal);
+  // call STOP, ERROR STOP in runtime
+  void genFIR(const Pa::StopStmt &stm) {
+    auto callee{
+        genRuntimeFunction(isStopStmt(stm) ? FIRT_STOP : FIRT_ERROR_STOP,
+            defaults.GetDefaultKind(IntegerCat))};
+    // 2 args: stop-code-opt, quiet-opt
+    L::SmallVector<M::Value *, 8> operands;
+    builder->create<M::CallOp>(toLocation(), callee, operands);
+  }
+
+  // gen expression, if any; share code with END of procedure
+  void genFIR(const Pa::ReturnStmt &stmt) {
+    if (inMainProgram(currentEvaluation)) {
+      builder->create<M::ReturnOp>(toLocation());
+    } else if (auto *stmt = inSubroutine(currentEvaluation)) {
+      genFIRProcedureExit(stmt);
+    } else if (auto *stmt = inFunction(currentEvaluation)) {
+      genFIRFunctionReturn(stmt);
+    } else if (auto *stmt = inMPSubp(currentEvaluation)) {
+      genFIRProcedureExit(stmt);
+    } else {
+      assert(false && "unknown subprogram type");
+    }
   }
 
-  void genReturnStmt(const Pa::MainProgram &) {
-    build().create<M::ReturnOp>(toLocation());
-  }
+  // stubs for generic goto statements; see genFIREvalGoto()
+  void genFIR(const Pa::CycleStmt &) {}  // do nothing
+  void genFIR(const Pa::ExitStmt &) {}  // do nothing
+  void genFIR(const Pa::GotoStmt &) {}  // do nothing
 
-  void genReturnStmt(
-      const Pa::SubroutineSubprogram &, const Pa::ReturnStmt * = nullptr) {
-    // TODO use Pa::ReturnStmt for alternate return
-    build().create<M::ReturnOp>(toLocation());
-  }
-  void genReturnStmt(AnalysisData &ad, const Pa::ReturnStmt *stmt = nullptr) {
+  void genFIR(AST::Evaluation &eval) {
+    currentEvaluation = &eval;
     std::visit(Co::visitors{
-                   [&](const Pa::SubroutineSubprogram *sub) {
-                     genReturnStmt(*sub, stmt);
-                   },
-                   [&](const Pa::FunctionSubprogram *func) {
-                     genReturnStmt(ad, *func);
-                   },
-                   [&](const Pa::MainProgram *main) { genReturnStmt(*main); },
+                   [&](const auto *p) { genFIR(*p); },
+                   [](const AST::CGJump &) { /* do nothing */ },
                },
-        ad.parseTreeRoot);
+        eval.u);
+  }
+
+  /// Lower an Evaluation
+  ///
+  /// If the Evaluation is annotated, we can attempt to lower it by the class of
+  /// annotation. Otherwise, attempt to lower the Evaluation on a case-by-case
+  /// basis.
+  void lowerEval(AST::Evaluation &eval) {
+    setCurrentPosition(eval.pos);
+    if (eval.isControlTarget()) {
+      // start a new block
+    }
+    switch (eval.cfg) {
+    case AST::CFGAnnotation::None: genFIREvalNone(eval); break;
+    case AST::CFGAnnotation::Goto: genFIREvalGoto(eval); break;
+    case AST::CFGAnnotation::CondGoto: genFIREvalCondGoto(eval); break;
+    case AST::CFGAnnotation::IndGoto: genFIREvalIndGoto(eval); break;
+    case AST::CFGAnnotation::IoSwitch: genFIREvalIoSwitch(eval); break;
+    case AST::CFGAnnotation::Switch: genFIREvalSwitch(eval); break;
+    case AST::CFGAnnotation::Iterative: genFIREvalIterative(eval); break;
+    case AST::CFGAnnotation::FirStructuredOp:
+      genFIREvalStructuredOp(eval);
+      break;
+    case AST::CFGAnnotation::Return: genFIREvalReturn(eval); break;
+    case AST::CFGAnnotation::Terminate: genFIREvalTerminate(eval); break;
+    }
   }
 
-  void genFIR(const Pa::StopStmt &stmt) {
-    auto callee{genRuntimeFunction(
-        isStopStmt(std::get<Pa::StopStmt::Kind>(stmt.t)) ? FIRT_STOP
-                                                         : FIRT_ERROR_STOP,
-        defaults.GetDefaultKind(IntegerCat))};
-    // 2 args: stop-code-opt, quiet-opt
-    llvm::SmallVector<M::Value *, 8> operands;
-    build().create<M::CallOp>(toLocation(), callee, operands);
-    build().create<fir::UnreachableOp>(toLocation());
+  M::FuncOp createNewFunction(L::StringRef name, const Se::Symbol *symbol) {
+    // get arguments and return type if any, otherwise just use empty vectors
+    L::SmallVector<M::Type, 8> args;
+    L::SmallVector<M::Type, 2> results;
+    if (symbol) {
+      auto *details{symbol->detailsIf<Se::SubprogramDetails>()};
+      assert(details && "details for semantics::Symbol must be subprogram");
+      for (auto *a : details->dummyArgs()) {
+        if (a) {  // nullptr indicates alternate return argument
+          auto type{translateSymbolToFIRType(&mlirContext, defaults, *a)};
+          args.push_back(fir::ReferenceType::get(type));
+        }
+      }
+      if (details->isFunction()) {
+        // FIXME: handle subroutines that return magic values
+        auto result{details->result()};
+        results.push_back(
+            translateSymbolToFIRType(&mlirContext, defaults, result));
+      }
+    }
+    auto funcTy{M::FunctionType::get(args, results, &mlirContext)};
+    return createFunction(module, name, funcTy);
   }
 
-  // Conditional branch-like statements
-  template<typename A>
-  void genFIR(
-      const A &tuple, Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
-    auto *exprRef{Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(tuple))};
-    assert(exprRef && "condition expression missing");
-    auto *cond{createLogicalExprAsI1(toLocation(), exprRef)};
-    genCondBranch(cond, trueLabel, falseLabel);
-  }
-  void genFIR(const Pa::Statement<Pa::IfThenStmt> &stmt,
-      Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
-    setCurrentPos(stmt.source);
-    genFIR(stmt.statement.t, trueLabel, falseLabel);
-  }
-  void genFIR(const Pa::Statement<Pa::ElseIfStmt> &stmt,
-      Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
-    setCurrentPos(stmt.source);
-    genFIR(stmt.statement.t, trueLabel, falseLabel);
-  }
-  void genFIR(const Pa::IfStmt &stmt, Fl::LabelMention trueLabel,
-      Fl::LabelMention falseLabel) {
-    genFIR(stmt.t, trueLabel, falseLabel);
-  }
-
-  M::Value *getTrueConstant() {
-    auto attr{build().getBoolAttr(true)};
-    return build().create<M::ConstantOp>(toLocation(), attr).getResult();
-  }
-
-  // Conditional branch to enter loop body or exit
-  void genFIR(const Pa::Statement<Pa::NonLabelDoStmt> &stmt,
-      Fl::LabelMention trueLabel, Fl::LabelMention falseLabel) {
-    setCurrentPos(stmt.source);
-    auto &loopCtrl{std::get<std::optional<Pa::LoopControl>>(stmt.statement.t)};
-    M::Value *condition{nullptr};
-    bool exitNow{false};
-    if (loopCtrl.has_value()) {
-      exitNow = std::visit(
-          Co::visitors{
-              [&](const parser::LoopControl::Bounds &) {
-                if (firLoopOp) {
-                  return true;
-                }
-                auto iter{doMap.find(&stmt.statement)};
-                assert(iter != doMap.end());
-                condition = iter->second.condition->getResult(0);
-                return false;
-              },
-              [&](const parser::ScalarLogicalExpr &logical) {
-                auto loc{toLocation(stmt.source)};
-                auto *exp{Se::GetExpr(logical)};
-                condition = createLogicalExprAsI1(loc, exp);
-                return false;
-              },
-              [&](const parser::LoopControl::Concurrent &concurrent) {
-                // FIXME: incorrectly lowering DO CONCURRENT
-                condition = getTrueConstant();
-                return false;
-              },
-          },
-          loopCtrl->u);
-      if (firLoopOp && exitNow) {
-        return;
+  /// Prepare to translate a new function
+  void startNewFunction(AST::FunctionLikeUnit &funit, L::StringRef name,
+      const Se::Symbol *symbol) {
+    M::FuncOp func{getNamedFunction(module, name)};
+    if (!func) {
+      func = createNewFunction(name, symbol);
+    }
+    func.addEntryBlock();
+    assert(!builder && "expected nullptr");
+    builder = new M::OpBuilder(func);
+    assert(builder && "OpBuilder did not instantiate");
+    builder->setInsertionPointToStart(&func.front());
+
+    // plumb function's arguments
+    if (symbol) {
+      auto *entryBlock{&func.front()};
+      auto *details{symbol->detailsIf<Se::SubprogramDetails>()};
+      assert(details && "details for semantics::Symbol must be subprogram");
+      for (const auto &v :
+          L::zip(details->dummyArgs(), entryBlock->getArguments())) {
+        if (std::get<0>(v)) {
+          localSymbols.addSymbol(*std::get<0>(v), std::get<1>(v));
+        } else {
+          TODO();  // handle alternate return
+        }
       }
-    } else {
-      condition = getTrueConstant();
     }
-    assert(condition && "condition must be a Value");
-    genCondBranch(condition, trueLabel, falseLabel);
   }
 
-  // Action statements
-  void genFIR(const Pa::AllocateStmt &stmt) { TODO(); }
+  void finalizeQueuedEdges() {
+    for (auto &edgeFunc : localEdgeQ) {
+      edgeFunc(localBlockMap);
+    }
+    localEdgeQ.clear();
+    localBlockMap.clear();
+  }
 
-  void genFIR(const Pa::AssignmentStmt &stmt) {
-    auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
-    auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
-    auto loc{toLocation()};
-    build().create<fir::StoreOp>(
-        loc, createFIRExpr(loc, rhs), createFIRAddr(loc, lhs));
+  /// Cleanup after the function has been translated
+  void endNewFunction() {
+    finalizeQueuedEdges();
+    delete builder;
+    builder = nullptr;
+    localSymbols.clear();
   }
-  void genFIR(const Pa::BackspaceStmt &stmt) { TODO(); }
-  void genFIR(const Pa::CallStmt &stmt) { TODO(); }
-  void genFIR(const Pa::CloseStmt &stmt) { TODO(); }
-  void genFIR(const Pa::DeallocateStmt &stmt) { TODO(); }
-  void genFIR(const Pa::EndfileStmt &stmt) { TODO(); }
-  void genFIR(const Pa::EventPostStmt &stmt) { TODO(); }
-  void genFIR(const Pa::EventWaitStmt &stmt) { TODO(); }
-  void genFIR(const Pa::FlushStmt &stmt) { TODO(); }
-  void genFIR(const Pa::FormTeamStmt &stmt) { TODO(); }
-  void genFIR(const Pa::InquireStmt &stmt) { TODO(); }
-  void genFIR(const Pa::LockStmt &stmt) { TODO(); }
-  void genFIR(const Pa::NullifyStmt &stmt) { TODO(); }
-  void genFIR(const Pa::OpenStmt &stmt) { TODO(); }
-  void genFIR(const Pa::PointerAssignmentStmt &stmt) { TODO(); }
-  void genFIR(const Pa::PrintStmt &stmt) {
-    llvm::SmallVector<mlir::Value *, 4> args;
-    for (const Pa::OutputItem &item :
-        std::get<std::list<Pa::OutputItem>>(stmt.t)) {
-      if (const Pa::Expr * parserExpr{std::get_if<Pa::Expr>(&item.u)}) {
-        mlir::Location loc{toLocation(parserExpr->source)};
-        args.push_back(createFIRExpr(loc, Se::GetExpr(*parserExpr)));
-      } else {
-        assert(false);  // implied do TODO
-      }
-    }
-    genPrintStatement(build(), toLocation(lastKnownPos), args);
-  }
-  void genFIR(const Pa::ReadStmt &stmt) { TODO(); }
-  void genFIR(const Pa::RewindStmt &stmt) { TODO(); }
-  void genFIR(const Pa::SyncAllStmt &stmt) { TODO(); }
-  void genFIR(const Pa::SyncImagesStmt &stmt) { TODO(); }
-  void genFIR(const Pa::SyncMemoryStmt &stmt) { TODO(); }
-  void genFIR(const Pa::SyncTeamStmt &stmt) { TODO(); }
-  void genFIR(const Pa::UnlockStmt &stmt) { TODO(); }
-  void genFIR(const Pa::WaitStmt &stmt) { TODO(); }
-  void genFIR(const Pa::WhereStmt &stmt) { TODO(); }
-  void genFIR(const Pa::WriteStmt &stmt) { TODO(); }
-  void genFIR(const Pa::ForallStmt &stmt) { TODO(); }
-  void genFIR(AnalysisData &ad, const Pa::AssignStmt &stmt) { TODO(); }
-  void genFIR(const Pa::PauseStmt &stmt) { TODO(); }
 
-  template<typename A>
-  void translateRoutine(
-      const A &routine, llvm::StringRef name, const Se::Symbol *funcSym);
-
-  void genCondBranch(
-      M::Value *cond, Fl::LabelMention trueBlock, Fl::LabelMention falseBlock) {
-    auto trueIter{blkMap().find(trueBlock)};
-    auto falseIter{blkMap().find(falseBlock)};
-    if (trueIter != blkMap().end() && falseIter != blkMap().end()) {
-      llvm::SmallVector<M::Value *, 2> blanks;
-      build().create<M::CondBranchOp>(toLocation(), cond, trueIter->second,
-          blanks, falseIter->second, blanks);
+  /// Lower a procedure-like construct
+  void lowerFunc(AST::FunctionLikeUnit &func, L::ArrayRef<L::StringRef> modules,
+      L::Optional<L::StringRef> host = {}) {
+    std::string name;
+    const Se::Symbol *symbol{nullptr};
+    auto size{func.funStmts.size()};
+
+    assert((size == 1 || size == 2) && "ill-formed subprogram");
+    if (size == 2) {
+      std::visit(
+          [&](auto *p) { genFIR(*p, name, symbol); }, func.funStmts.front());
     } else {
-      using namespace std::placeholders;
-      edgeQ.emplace_back(std::bind(
-          [](M::OpBuilder *builder, M::Block *block, M::Value *cnd,
-              Fl::LabelMention trueDest, Fl::LabelMention falseDest,
-              M::Location location, const LabelMapType &map) {
-            llvm::SmallVector<M::Value *, 2> blk;
-            builder->setInsertionPointToEnd(block);
-            auto tdp{map.find(trueDest)};
-            auto fdp{map.find(falseDest)};
-            assert(tdp != map.end() && fdp != map.end());
-            builder->create<M::CondBranchOp>(
-                location, cnd, tdp->second, blk, fdp->second, blk);
-          },
-          &build(), build().getInsertionBlock(), cond, trueBlock, falseBlock,
-          toLocation(), _1));
+      name = mangler.getProgramEntry();
     }
-  }
 
-  template<typename A>
-  void genSwitchBranch(const M::Location &loc, M::Value *selector,
-      std::list<typename A::Conditions> &&conditions,
-      const std::vector<Fl::LabelMention> &labels) {
-    assert(conditions.size() == labels.size());
-    bool haveAllLabels{true};
-    std::size_t u{0};
-    // do we already have all the targets?
-    for (auto last{labels.size()}; u != last; ++u) {
-      haveAllLabels = blkMap().find(labels[u]) != blkMap().end();
-      if (!haveAllLabels) break;
+    startNewFunction(func, name, symbol);
+
+    // lower this procedure
+    for (auto &e : func.evals) {
+      lowerEval(e);
     }
-    if (haveAllLabels) {
-      // yes, so generate the FIR operation now
-      u = 0;
-      std::vector<M::Value *> conds;
-      std::vector<M::Block *> blocks;
-      std::vector<llvm::ArrayRef<M::Value *>> blockArgs;
-      llvm::SmallVector<M::Value *, 2> blanks;
-      for (auto cond : conditions) {
-        conds.emplace_back(cond);
-        blocks.emplace_back(blkMap().find(labels[u++])->second);
-        blockArgs.emplace_back(blanks);
-      }
-      build().create<A>(loc, selector, conds, blocks, blockArgs);
-    } else {
-      // no, so queue the FIR operation for later
-      using namespace std::placeholders;
-      edgeQ.emplace_back(std::bind(
-          [](M::OpBuilder *builder, M::Block *block, M::Value *sel,
-              const std::list<typename A::Conditions> &conditions,
-              const std::vector<Fl::LabelMention> &labels, M::Location location,
-              const LabelMapType &map) {
-            std::size_t u{0};
-            std::vector<M::Value *> conds;
-            std::vector<M::Block *> blocks;
-            std::vector<llvm::ArrayRef<M::Value *>> blockArgs;
-            llvm::SmallVector<M::Value *, 2> blanks;
-            for (auto &cond : conditions) {
-              auto iter{map.find(labels[u++])};
-              assert(iter != map.end());
-              conds.emplace_back(cond);
-              blocks.emplace_back(iter->second);
-              blockArgs.emplace_back(blanks);
-            }
-            builder->setInsertionPointToEnd(block);
-            builder->create<A>(location, sel, conds, blocks, blockArgs);
-          },
-          &build(), build().getInsertionBlock(), selector, conditions, labels,
-          loc, _1));
+    std::visit(
+        [&](auto *p) { genFIR(*p, name, symbol); }, func.funStmts.back());
+
+    endNewFunction();
+
+    // recursively lower internal procedures
+    L::Optional<L::StringRef> optName{name};
+    for (auto &f : func.funcs) {
+      lowerFunc(f, modules, optName);
     }
   }
 
-  void finalizeQueued() {
-    for (auto &edgeFunc : edgeQ) {
-      edgeFunc(blkMap());
+  void lowerMod(AST::ModuleLikeUnit &mod) {
+    // FIXME: build the vector of module names
+    std::vector<L::StringRef> moduleName;
+
+    // FIXME: do we need to visit the module statements?
+    for (auto &f : mod.funcs) {
+      lowerFunc(f, moduleName);
     }
   }
 
-public:
-  FIRConverter(BurnsideBridge &bridge)
-    : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
-      module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
-      intrinsics{IntrinsicLibrary::create(
-          IntrinsicLibrary::Version::LLVM, mlirContext)} {}
-  FIRConverter() = delete;
+  //
+  // Finalization of the CFG structure
+  //
 
-  template<typename A> constexpr bool Pre(const A &) { return true; }
-  template<typename A> constexpr void Post(const A &) {
-    // FIXME: make sure we lower all of the parse tree
+  /// Lookup the set of sinks for this source. There must be at least one.
+  L::ArrayRef<AST::Evaluation *> findTargetsOf(AST::Evaluation &eval) {
+    auto iter = cfgMap.find(&eval);
+    assert(iter != cfgMap.end());
+    return *iter->second;
   }
 
-  /// Translate the various routines from the parse tree
-  void Post(const Pa::MainProgram &mainp) {
-    std::string mainName{"_MAIN"s};
-    if (auto &ps{
-            std::get<std::optional<Pa::Statement<Pa::ProgramStmt>>>(mainp.t)}) {
-      mainName = ps->statement.v.ToString();
-      setCurrentPos(ps->source);
-    }
-    translateRoutine(mainp, mainName, nullptr);
+  /// Lookup the sink for this source. There must be exactly one.
+  AST::Evaluation *findSinkOf(AST::Evaluation &eval) {
+    auto iter = cfgMap.find(&eval);
+    assert((iter != cfgMap.end()) && (iter->second->size() == 1));
+    return iter->second->front();
   }
-  void Post(const Pa::FunctionSubprogram &subp) {
-    auto &stmt{std::get<Pa::Statement<Pa::FunctionStmt>>(subp.t)};
-    setCurrentPos(stmt.source);
-    auto &name{std::get<Pa::Name>(stmt.statement.t)};
-    translateRoutine(subp, name.ToString(), name.symbol);
+
+  /// prune the CFG for `f`
+  void pruneFunc(AST::FunctionLikeUnit &func) {
+    // find and cache arcs, etc.
+    if (!func.evals.empty()) {
+      CfgBuilder{cfgMap, cfgEdgeSetPool}.run(func);
+    }
+
+    // do any internal procedures
+    for (auto &f : func.funcs) {
+      pruneFunc(f);
+    }
   }
-  void Post(const Pa::SubroutineSubprogram &subp) {
-    auto &stmt{std::get<Pa::Statement<Pa::SubroutineStmt>>(subp.t)};
-    setCurrentPos(stmt.source);
-    auto &name{std::get<Pa::Name>(stmt.statement.t)};
-    translateRoutine(subp, name.ToString(), name.symbol);
+
+  void pruneMod(AST::ModuleLikeUnit &mod) {
+    for (auto &f : mod.funcs) {
+      pruneFunc(f);
+    }
   }
-};
 
-/// SELECT CASE
-/// Build a switch-like structure for a SELECT CASE
-void FIRConverter::genFIR(
-    const Fl::SwitchOp &op, const Pa::CaseConstruct &stmt) {
-  auto loc{toLocation(op.source)};
-  auto &cstm{std::get<Pa::Statement<Pa::SelectCaseStmt>>(stmt.t)};
-  auto *exp{Se::GetExpr(std::get<Pa::Scalar<Pa::Expr>>(cstm.statement.t))};
-  auto *e1{createFIRExpr(loc, exp)};
-  auto &cases{std::get<std::list<Pa::CaseConstruct::Case>>(stmt.t)};
-  std::list<fir::SelectCaseOp::Conditions> conds;
-  // Per C1145, we know each `case-expr` must have type INTEGER, CHARACTER, or
-  // LOGICAL
-  for (auto &sel : cases) {
-    auto &cs{std::get<Pa::Statement<Pa::CaseStmt>>(sel.t)};
-    auto locs{toLocation(cs.source)};
-    auto &csel{std::get<Pa::CaseSelector>(cs.statement.t)};
-    std::visit(
-        Co::visitors{
-            [&](const std::list<Pa::CaseValueRange> &ranges) {
-              for (auto &r : ranges) {
-                std::visit(Co::visitors{
-                               [&](const Pa::CaseValue &val) {
-                                 auto *term{fromCaseValue(locs, val)};
-                                 conds.emplace_back(genEQ(e1, term));
-                               },
-                               [&](const Pa::CaseValueRange::Range &rng) {
-                                 fir::SelectCaseOp::Conditions rangeComparison =
-                                     nullptr;
-                                 if (rng.lower.has_value()) {
-                                   auto *term{fromCaseValue(locs, *rng.lower)};
-                                   // rc = e1 >= lower.term
-                                   rangeComparison = genGE(e1, term);
-                                 }
-                                 if (rng.upper.has_value()) {
-                                   auto *term{fromCaseValue(locs, *rng.upper)};
-                                   // c = e1 <= upper.term
-                                   auto *comparison{genLE(e1, term)};
-                                   // rc = if rc then (rc && c) else c
-                                   if (rangeComparison) {
-                                     rangeComparison =
-                                         genAND(rangeComparison, comparison);
-                                   } else {
-                                     rangeComparison = comparison;
-                                   }
-                                 }
-                                 conds.emplace_back(rangeComparison);
-                               },
-                           },
-                    r.u);
-              }
-            },
-            [&](const Pa::Default &) { conds.emplace_back(getTrueConstant()); },
-        },
-        csel.u);
+  void setCurrentPosition(const Pa::CharBlock &pos) {
+    if (pos != Pa::CharBlock{}) {
+      currentPosition = pos;
+    }
   }
-  genSwitchBranch<fir::SelectCaseOp>(loc, e1, std::move(conds), op.refs);
-}
 
-/// SELECT RANK
-/// Build a switch-like structure for a SELECT RANK
-void FIRConverter::genFIR(
-    const Fl::SwitchOp &op, const Pa::SelectRankConstruct &stmt) {
-  auto loc{toLocation(op.source)};
-  auto &rstm{std::get<Pa::Statement<Pa::SelectRankStmt>>(stmt.t)};
-  auto *exp{std::visit([](auto &x) { return Se::GetExpr(x); },
-      std::get<Pa::Selector>(rstm.statement.t).u)};
-  auto *e1{createFIRExpr(loc, exp)};
-  auto &ranks{std::get<std::list<Pa::SelectRankConstruct::RankCase>>(stmt.t)};
-  std::list<fir::SelectRankOp::Conditions> conds;
-  for (auto &r : ranks) {
-    auto &rs{std::get<Pa::Statement<Pa::SelectRankCaseStmt>>(r.t)};
-    auto &rank{std::get<Pa::SelectRankCaseStmt::Rank>(rs.statement.t)};
-    std::visit(
-        Co::visitors{
-            [&](const Pa::ScalarIntConstantExpr &ex) {
-              auto *ie{createFIRExpr(loc, Se::GetExpr(ex))};
-              conds.emplace_back(ie);
-            },
-            [&](const Pa::Star &) {
-              // FIXME: using a bogon for now.  Special value per
-              // whatever the runtime returns.
-              auto attr{build().getIntegerAttr(e1->getType(), -1)};
-              conds.emplace_back(build().create<M::ConstantOp>(loc, attr));
-            },
-            [&](const Pa::Default &) { conds.emplace_back(getTrueConstant()); },
-        },
-        rank.u);
-  }
-  // FIXME: fix the type of the function
-  auto callee{genRuntimeFunction(FIRT_GET_RANK, 0)};
-  llvm::SmallVector<M::Value *, 1> operands{e1};
-  auto e3{build().create<M::CallOp>(loc, callee, operands)};
-  genSwitchBranch<fir::SelectRankOp>(
-      loc, e3.getResult(0), std::move(conds), op.refs);
-}
+  //
+  // Utility methods
+  //
 
-/// SELECT TYPE
-/// Build a switch-like structure for a SELECT TYPE
-void FIRConverter::genFIR(
-    const Fl::SwitchOp &op, const Pa::SelectTypeConstruct &stmt) {
-  auto loc{toLocation(op.source)};
-  auto &tstm{std::get<Pa::Statement<Pa::SelectTypeStmt>>(stmt.t)};
-  auto *exp{std::visit([](auto &x) { return Se::GetExpr(x); },
-      std::get<Pa::Selector>(tstm.statement.t).u)};
-  auto *e1{createFIRExpr(loc, exp)};
-  auto &types{std::get<std::list<Pa::SelectTypeConstruct::TypeCase>>(stmt.t)};
-  std::list<fir::SelectTypeOp::Conditions> conds;
-  for (auto &t : types) {
-    auto &ts{std::get<Pa::Statement<Pa::TypeGuardStmt>>(t.t)};
-    auto &ty{std::get<Pa::TypeGuardStmt::Guard>(ts.statement.t)};
-    std::visit(
-        Co::visitors{
-            [&](const Pa::TypeSpec &) {
-              // FIXME: add arguments
-              auto func{genRuntimeFunction(FIRT_ISA_TYPE, 0)};
-              llvm::SmallVector<M::Value *, 2> operands;
-              auto call{build().create<M::CallOp>(loc, func, operands)};
-              conds.emplace_back(call.getResult(0));
-            },
-            [&](const Pa::DerivedTypeSpec &) {
-              // FIXME: add arguments
-              auto func{genRuntimeFunction(FIRT_ISA_SUBTYPE, 0)};
-              llvm::SmallVector<M::Value *, 2> operands;
-              auto call{build().create<M::CallOp>(loc, func, operands)};
-              conds.emplace_back(call.getResult(0));
-            },
-            [&](const Pa::Default &) { conds.emplace_back(getTrueConstant()); },
-        },
-        ty.u);
+  /// Convert a parser CharBlock to a Location
+  M::Location toLocation(const Pa::CharBlock &cb) {
+    return parserPosToLoc(mlirContext, cooked, cb);
   }
-  auto callee{genRuntimeFunction(FIRT_GET_ELETYPE, 0)};
-  llvm::SmallVector<M::Value *, 1> operands{e1};
-  auto e3{build().create<M::CallOp>(loc, callee, operands)};
-  genSwitchBranch<fir::SelectTypeOp>(
-      loc, e3.getResult(0), std::move(conds), op.refs);
-}
 
-/// translate action statements
-void FIRConverter::genFIR(AnalysisData &ad, const Fl::ActionOp &op) {
-  setCurrentPos(op.v->source);
-  std::visit(Co::visitors{
-                 [](const Pa::ContinueStmt &) { TODO(); },
-                 [](const Pa::FailImageStmt &) { TODO(); },
-                 [](const Co::Indirection<Pa::ArithmeticIfStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::AssignedGotoStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::ComputedGotoStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::CycleStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::ExitStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::GotoStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::IfStmt> &) { TODO(); },
-                 [](const Co::Indirection<Pa::StopStmt> &) { TODO(); },
-                 [&](const Co::Indirection<Pa::AssignStmt> &assign) {
-                   genFIR(ad, assign.value());
-                 },
-                 [](const Co::Indirection<Pa::ReturnStmt> &) {
-                   assert(false && "should be a ReturnOp");
-                 },
-                 [&](const auto &stmt) { genFIR(stmt); },
-             },
-      op.v->statement.u);
-}
+  M::Location toLocation() { return toLocation(currentPosition); }
 
-void FIRConverter::genFIR(AnalysisData &ad, const Fl::IndirectGotoOp &op) {
-  // add or queue an igoto
-  TODO();
-}
-
-void FIRConverter::genFIR(AnalysisData &ad, std::list<Fl::Op> &operations) {
-  bool lastWasLabel{false};
-  for (auto &op : operations) {
-    std::visit(Co::visitors{
-                   [&](const Fl::IndirectGotoOp &oper) {
-                     genFIR(ad, oper);
-                     lastWasLabel = false;
-                   },
-                   [&](const Fl::ActionOp &oper) {
-                     noInsPt = false;
-                     genFIR(ad, oper);
-                     lastWasLabel = false;
-                   },
-                   [&](const Fl::LabelOp &oper) {
-                     genFIR(lastWasLabel, oper);
-                     lastWasLabel = true;
-                   },
-                   [&](const Fl::BeginOp &oper) {
-                     noInsPt = false;
-                     genFIR(oper);
-                     lastWasLabel = true;
-                   },
-                   [&](const Fl::ReturnOp &oper) {
-                     noInsPt = false;
-                     genFIR(ad, oper);
-                     lastWasLabel = true;
-                   },
-                   [&](const auto &oper) {
-                     noInsPt = false;
-                     genFIR(oper);
-                     lastWasLabel = false;
-                   },
-               },
-        op.u);
+  // TODO: should these be moved to convert-expr?
+  template<M::CmpIPredicate ICMPOPC>
+  M::Value *genCompare(M::Value *lhs, M::Value *rhs) {
+    auto lty{lhs->getType()};
+    assert(lty == rhs->getType());
+    if (lty.isIntOrIndex()) {
+      return builder->create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
+    }
+    if (fir::LogicalType::kindof(lty.getKind())) {
+      return builder->create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
+    }
+    if (fir::CharacterType::kindof(lty.getKind())) {
+      // FIXME
+      // return builder->create<M::CallOp>(lhs->getLoc(), );
+    }
+    assert(false && "cannot generate operation on this type");
+    return {};
   }
-  if (build().getInsertionBlock()) {
-    genReturnStmt(ad);
+  M::Value *genGE(M::Value *lhs, M::Value *rhs) {
+    return genCompare<M::CmpIPredicate::sge>(lhs, rhs);
+  }
+  M::Value *genLE(M::Value *lhs, M::Value *rhs) {
+    return genCompare<M::CmpIPredicate::sle>(lhs, rhs);
+  }
+  M::Value *genEQ(M::Value *lhs, M::Value *rhs) {
+    return genCompare<M::CmpIPredicate::eq>(lhs, rhs);
+  }
+  M::Value *genAND(M::Value *lhs, M::Value *rhs) {
+    return builder->create<M::AndOp>(lhs->getLoc(), lhs, rhs);
   }
-}
 
-/// Translate the routine to MLIR
-template<typename A>
-void FIRConverter::translateRoutine(
-    const A &routine, llvm::StringRef name, const Se::Symbol *funcSym) {
-  M::FuncOp func{getNamedFunction(getMod(), name)};
-  if (!func) {
-    // get arguments and return type if any, otherwise just use empty vectors
-    llvm::SmallVector<M::Type, 8> args;
-    llvm::SmallVector<M::Type, 2> results;
-    if (funcSym) {
-      if (auto *details{funcSym->detailsIf<Se::SubprogramDetails>()}) {
-        for (auto *a : details->dummyArgs()) {
-          if (a) {  // nullptr indicates alternate return argument
-            auto type{translateSymbolToFIRType(&mlirContext, defaults, *a)};
-            args.push_back(fir::ReferenceType::get(type));
-          }
-        }
-        if (details->isFunction()) {
-          // FIXME: handle subroutines that return magic values
-          auto result{details->result()};
-          results.push_back(
-              translateSymbolToFIRType(&mlirContext, defaults, result));
-        }
-      } else {
-        llvm::errs() << "Symbol: " << funcSym->name().ToString() << " @ "
-                     << funcSym->details().index() << '\n';
-        assert(false && "symbol misidentified by front-end");
-      }
+private:
+  M::MLIRContext &mlirContext;
+  const Pa::CookedSource *cooked;
+  M::ModuleOp &module;
+  Co::IntrinsicTypeDefaultKinds const &defaults;
+  IntrinsicLibrary intrinsics;
+  M::OpBuilder *builder{nullptr};
+  fir::NameMangler &mangler;
+  SymMap localSymbols;
+  std::list<Closure> localEdgeQ;
+  LabelMapType localBlockMap;
+  Pa::CharBlock currentPosition;
+  CFGMapType cfgMap;
+  std::list<CFGSinkListType> cfgEdgeSetPool;
+  AST::Evaluation *currentEvaluation;  // FIXME: this is a hack
+
+public:
+  FirConverter() = delete;
+  FirConverter(const FirConverter &) = delete;
+  FirConverter &operator=(const FirConverter &) = delete;
+
+  explicit FirConverter(BurnsideBridge &bridge, fir::NameMangler &mangler)
+    : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
+      module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
+      intrinsics{IntrinsicLibrary::create(
+          IntrinsicLibrary::Version::LLVM, bridge.getMLIRContext())},
+      mangler{mangler} {}
+
+  /// Convert the AST to FIR
+  void run(AST::Program &ast) {
+    // build pruned control
+    for (auto &u : ast.getUnits()) {
+      std::visit(common::visitors{
+                     [&](AST::FunctionLikeUnit &f) { pruneFunc(f); },
+                     [&](AST::ModuleLikeUnit &m) { pruneMod(m); },
+                     [](AST::BlockDataUnit &) { /* do nothing */ },
+                 },
+          u);
     }
-    auto funcTy{M::FunctionType::get(args, results, &mlirContext)};
-    func = createFunction(getMod(), name, funcTy);
-  }
-  func.addEntryBlock();
-  builder = std::make_unique<M::OpBuilder>(func);
-  build().setInsertionPointToStart(&func.front());
-  if (funcSym) {
-    auto *entryBlock{&func.front()};
-    if (auto *details{funcSym->detailsIf<Se::SubprogramDetails>()}) {
-      // TODO zipping might be an issue in case of alternate returns
-      for (const auto &v :
-          llvm::zip(details->dummyArgs(), entryBlock->getArguments())) {
-        if (std::get<0>(v)) {
-          symbolMap.addSymbol(*std::get<0>(v), std::get<1>(v));
-        } else {
-          TODO();  // handle alternate return, maybe nothing todo here though
-        }
-      }
-    } else {
-      llvm::errs() << "Symbol: " << funcSym->name().ToString() << " @ "
-                   << funcSym->details().index() << '\n';
-      assert(false && "symbol misidentified by front-end");
+
+    // do translation
+    for (auto &u : ast.getUnits()) {
+      std::visit(common::visitors{
+                     [&](AST::FunctionLikeUnit &f) { lowerFunc(f, {}); },
+                     [&](AST::ModuleLikeUnit &m) { lowerMod(m); },
+                     [](AST::BlockDataUnit &) { SOFT_TODO(); },
+                 },
+          u);
     }
   }
-  AnalysisData ad{routine};
-  std::list<Fl::Op> operations;
-  CreateFlatIR(operations, ad);
-  genFIR(ad, operations);
-  finalizeQueued();
-}
+};
 
 }  // namespace
 
 void Br::BurnsideBridge::lower(
     const Pa::Program &prg, fir::NameMangler &mangler) {
-  FIRConverter converter{*this};
-  Walk(prg, converter);
+  AST::Program *ast{Br::createAST(prg)};
+  Br::annotateControl(*ast);
+  FirConverter converter{*this, mangler};
+  converter.run(*ast);
+  delete ast;
 }
 
-void Br::BurnsideBridge::parseSourceFile(llvm::SourceMgr &srcMgr) {
+void Br::BurnsideBridge::parseSourceFile(L::SourceMgr &srcMgr) {
   auto owningRef = M::parseSourceFile(srcMgr, context.get());
   module.reset(new M::ModuleOp(owningRef.get().getOperation()));
   owningRef.release();
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index 563a13e0db6f..d340652840be 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -34,6 +34,7 @@ class CookedSource;
 namespace burnside {
 
 /// Miscellaneous helper routines for building MLIR
+///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
 class SymMap {
@@ -43,6 +44,8 @@ class SymMap {
   void addSymbol(semantics::SymbolRef symbol, mlir::Value *value);
 
   mlir::Value *lookupSymbol(semantics::SymbolRef symbol);
+
+  void clear() { symbolMap.clear(); }
 };
 
 std::string applyNameMangling(llvm::StringRef parserName);
diff --git a/lib/burnside/convert-type.h b/lib/burnside/convert-type.h
index 2c4f7b94741b..05e570082a96 100644
--- a/lib/burnside/convert-type.h
+++ b/lib/burnside/convert-type.h
@@ -15,11 +15,11 @@
 #ifndef FORTRAN_BURNSIDE_CONVERT_TYPE_H_
 #define FORTRAN_BURNSIDE_CONVERT_TYPE_H_
 
-/// Traversal and conversion of Fortran type data structures into the FIR
-/// dialect of MLIR.
-///
-/// Lowering of parse tree TYPE, KIND, ATTRIBUTE information to the FIR type
-/// system.
+/// Conversion of front-end TYPE, KIND, ATTRIBUTE (TKA) information to FIR/MLIR.
+/// This is meant to be the single point of truth (SPOT) for all type
+/// conversions when lowering to FIR.  This implements all lowering of parse
+/// tree TKA to the FIR type system. If one is converting front-end types and
+/// not using one of the routines provided here, it's being done wrong.
 ///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
diff --git a/lib/burnside/flattened.cc b/lib/burnside/flattened.cc
deleted file mode 100644
index 54c0a9e8cc01..000000000000
--- a/lib/burnside/flattened.cc
+++ /dev/null
@@ -1,688 +0,0 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "flattened.h"
-#include "../parser/parse-tree-visitor.h"
-#include "../semantics/symbol.h"
-
-namespace Fortran::burnside {
-namespace flat {
-
-// Labels are numbered [0 .. `n`] consecutively. They are unsigned. Not all
-// labels are numbered. The unnumbered ones are given the value UINT_MAX. `n`
-// should never approach UINT_MAX.
-LabelBuilder::LabelBuilder() : referenced(32), counter{0u} {}
-
-LabelMention LabelBuilder::getNext() {
-  LabelMention next{counter++};
-  auto cap{referenced.size()};
-  if (cap < counter) {
-    referenced.resize(2 * cap);
-  }
-  referenced.reset(next);
-  return next;
-}
-
-void LabelBuilder::setReferenced(LabelMention label) {
-  CHECK(label < referenced.getBitCapacity());
-  referenced.set(label);
-}
-
-bool LabelBuilder::isReferenced(LabelMention label) const {
-  CHECK(label < referenced.getBitCapacity());
-  return referenced.test(label);
-}
-
-LabelOp::LabelOp(LabelBuilder &builder)
-  : builder{builder}, label{builder.getNext()} {}
-
-LabelOp::LabelOp(const LabelOp &that)
-  : builder{that.builder}, label{that.label} {}
-
-LabelOp &LabelOp::operator=(const LabelOp &that) {
-  CHECK(&builder == &that.builder);
-  label = that.label;
-  return *this;
-}
-
-void LabelOp::setReferenced() const { builder.setReferenced(label); }
-
-bool LabelOp::isReferenced() const { return builder.isReferenced(label); }
-
-static void AddAssign(AnalysisData &ad, const semantics::Symbol *symbol,
-    const parser::Label &label) {
-  ad.assignMap[symbol].insert(label);
-}
-
-std::vector<LabelMention> GetAssign(
-    AnalysisData &ad, const semantics::Symbol *symbol) {
-  std::vector<LabelMention> result;
-  for (auto lab : ad.assignMap[symbol]) {
-    result.emplace_back(lab);
-  }
-  return result;
-}
-
-static std::tuple<const parser::Name *, LabelMention, LabelMention> FindStack(
-    const std::vector<
-        std::tuple<const parser::Name *, LabelMention, LabelMention>> &stack,
-    const parser::Name *key) {
-  for (auto iter{stack.rbegin()}, iend{stack.rend()}; iter != iend; ++iter) {
-    if (std::get<0>(*iter) == key) {
-      return *iter;
-    }
-  }
-  assert(false && "construct name not on stack");
-  return {};
-}
-
-LabelOp FetchLabel(AnalysisData &ad, const parser::Label &label) {
-  auto iter{ad.labelMap.find(label)};
-  if (iter == ad.labelMap.end()) {
-    LabelOp ll{ad.labelBuilder};
-    ll.setReferenced();
-    ad.labelMap.insert({label, ll});
-    return ll;
-  }
-  return iter->second;
-}
-
-static LabelOp BuildNewLabel(AnalysisData &ad) {
-  return LabelOp{ad.labelBuilder};
-}
-
-template<typename A> parser::Label GetErr(const A &stmt) {
-  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
-      std::is_same_v<A, parser::WriteStmt>) {
-    for (const auto &control : stmt.controls) {
-      if (std::holds_alternative<parser::ErrLabel>(control.u)) {
-        return std::get<parser::ErrLabel>(control.u).v;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, parser::WaitStmt> ||
-      std::is_same_v<A, parser::OpenStmt> ||
-      std::is_same_v<A, parser::CloseStmt> ||
-      std::is_same_v<A, parser::BackspaceStmt> ||
-      std::is_same_v<A, parser::EndfileStmt> ||
-      std::is_same_v<A, parser::RewindStmt> ||
-      std::is_same_v<A, parser::FlushStmt>) {
-    for (const auto &spec : stmt.v) {
-      if (std::holds_alternative<parser::ErrLabel>(spec.u)) {
-        return std::get<parser::ErrLabel>(spec.u).v;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, parser::InquireStmt>) {
-    for (const auto &spec : std::get<std::list<parser::InquireSpec>>(stmt.u)) {
-      if (std::holds_alternative<parser::ErrLabel>(spec.u)) {
-        return std::get<parser::ErrLabel>(spec.u).v;
-      }
-    }
-  }
-  return 0;
-}
-
-template<typename A> parser::Label GetEor(const A &stmt) {
-  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
-      std::is_same_v<A, parser::WriteStmt>) {
-    for (const auto &control : stmt.controls) {
-      if (std::holds_alternative<parser::EorLabel>(control.u)) {
-        return std::get<parser::EorLabel>(control.u).v;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, parser::WaitStmt>) {
-    for (const auto &waitSpec : stmt.v) {
-      if (std::holds_alternative<parser::EorLabel>(waitSpec.u)) {
-        return std::get<parser::EorLabel>(waitSpec.u).v;
-      }
-    }
-  }
-  return 0;
-}
-
-template<typename A> parser::Label GetEnd(const A &stmt) {
-  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
-      std::is_same_v<A, parser::WriteStmt>) {
-    for (const auto &control : stmt.controls) {
-      if (std::holds_alternative<parser::EndLabel>(control.u)) {
-        return std::get<parser::EndLabel>(control.u).v;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, parser::WaitStmt>) {
-    for (const auto &waitSpec : stmt.v) {
-      if (std::holds_alternative<parser::EndLabel>(waitSpec.u)) {
-        return std::get<parser::EndLabel>(waitSpec.u).v;
-      }
-    }
-  }
-  return 0;
-}
-
-template<typename A>
-void errLabelSpec(const A &s, std::list<Op> &ops,
-    const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
-  if (auto errLab{GetErr(s)}) {
-    std::optional<LabelMention> errRef{FetchLabel(ad, errLab).get()};
-    LabelOp next{BuildNewLabel(ad)};
-    ops.emplace_back(SwitchIOOp{s, next, ec.source, errRef});
-    ops.emplace_back(next);
-  } else {
-    ops.emplace_back(ActionOp{ec});
-  }
-}
-
-template<typename A>
-void threeLabelSpec(const A &s, std::list<Op> &ops,
-    const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
-  auto errLab{GetErr(s)};
-  auto eorLab{GetEor(s)};
-  auto endLab{GetEnd(s)};
-  if (errLab || eorLab || endLab) {
-    std::optional<LabelMention> errRef;
-    if (errLab) {
-      errRef = FetchLabel(ad, errLab).get();
-    }
-    std::optional<LabelMention> eorRef;
-    if (eorLab) {
-      eorRef = FetchLabel(ad, eorLab).get();
-    }
-    std::optional<LabelMention> endRef;
-    if (endLab) {
-      endRef = FetchLabel(ad, endLab).get();
-    }
-    auto next{BuildNewLabel(ad)};
-    ops.emplace_back(SwitchIOOp{s, next, ec.source, errRef, eorRef, endRef});
-    ops.emplace_back(next);
-  } else {
-    ops.emplace_back(ActionOp{ec});
-  }
-}
-
-template<typename A>
-std::vector<LabelMention> toLabelMention(AnalysisData &ad, const A &labels) {
-  std::vector<LabelMention> result;
-  for (auto label : labels) {
-    result.emplace_back(FetchLabel(ad, label).get());
-  }
-  CHECK(result.size() == labels.size());
-  return result;
-}
-
-template<typename A>
-std::vector<LabelMention> toLabelMention(
-    const LabelOp &next, AnalysisData &ad, const A &labels) {
-  std::vector<LabelMention> result;
-  result.emplace_back(next);
-  auto refs{toLabelMention(ad, labels)};
-  result.insert(result.end(), refs.begin(), refs.end());
-  CHECK(result.size() == labels.size() + 1);
-  return result;
-}
-
-static bool hasAltReturns(const parser::CallStmt &callStmt) {
-  const auto &args{std::get<std::list<parser::ActualArgSpec>>(callStmt.v.t)};
-  for (const auto &arg : args) {
-    const auto &actual{std::get<parser::ActualArg>(arg.t)};
-    if (std::holds_alternative<parser::AltReturnSpec>(actual.u)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-static std::list<parser::Label> getAltReturnLabels(const parser::Call &call) {
-  std::list<parser::Label> result;
-  const auto &args{std::get<std::list<parser::ActualArgSpec>>(call.t)};
-  for (const auto &arg : args) {
-    const auto &actual{std::get<parser::ActualArg>(arg.t)};
-    if (const auto *p{std::get_if<parser::AltReturnSpec>(&actual.u)}) {
-      result.push_back(p->v);
-    }
-  }
-  return result;
-}
-
-static LabelMention NearestEnclosingDoConstruct(AnalysisData &ad) {
-  for (auto iterator{ad.constructContextStack.rbegin()},
-       endIterator{ad.constructContextStack.rend()};
-       iterator != endIterator; ++iterator) {
-    auto labelReference{std::get<2>(*iterator)};
-    if (labelReference != UnspecifiedLabel) {
-      return labelReference;
-    }
-  }
-  assert(false && "CYCLE|EXIT not in loop");
-  return UnspecifiedLabel;
-}
-
-template<typename A> std::string GetSource(const A *s) {
-  return s->source.ToString();
-}
-
-template<typename A, typename B> std::string GetSource(const B *s) {
-  return GetSource(&std::get<parser::Statement<A>>(s->t));
-}
-
-void Op::Build(std::list<Op> &ops,
-    const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad) {
-  std::visit(
-      common::visitors{
-          [&](const auto &) { ops.emplace_back(ActionOp{ec}); },
-          [&](const common::Indirection<parser::CallStmt> &s) {
-            if (hasAltReturns(s.value())) {
-              auto next{BuildNewLabel(ad)};
-              auto alts{getAltReturnLabels(s.value().v)};
-              auto labels{toLabelMention(next, ad, alts)};
-              ops.emplace_back(
-                  SwitchOp{s.value(), std::move(labels), ec.source});
-              ops.emplace_back(next);
-            } else {
-              ops.emplace_back(ActionOp{ec});
-            }
-          },
-          [&](const common::Indirection<parser::AssignStmt> &s) {
-            AddAssign(ad, std::get<parser::Name>(s.value().t).symbol,
-                std::get<parser::Label>(s.value().t));
-            ops.emplace_back(ActionOp{ec});
-          },
-          [&](const common::Indirection<parser::CycleStmt> &s) {
-            ops.emplace_back(GotoOp{s.value(),
-                s.value().v ? std::get<2>(FindStack(ad.constructContextStack,
-                                  &s.value().v.value()))
-                            : NearestEnclosingDoConstruct(ad),
-                ec.source});
-          },
-          [&](const common::Indirection<parser::ExitStmt> &s) {
-            ops.emplace_back(GotoOp{s.value(),
-                s.value().v ? std::get<1>(FindStack(ad.constructContextStack,
-                                  &s.value().v.value()))
-                            : NearestEnclosingDoConstruct(ad),
-                ec.source});
-          },
-          [&](const common::Indirection<parser::GotoStmt> &s) {
-            ops.emplace_back(GotoOp{
-                s.value(), FetchLabel(ad, s.value().v).get(), ec.source});
-          },
-          [&](const parser::FailImageStmt &s) {
-            ops.emplace_back(ReturnOp{s, ec.source});
-          },
-          [&](const common::Indirection<parser::ReturnStmt> &s) {
-            ops.emplace_back(ReturnOp{s.value(), ec.source});
-          },
-          [&](const common::Indirection<parser::StopStmt> &s) {
-            ops.emplace_back(ActionOp{ec});
-            ops.emplace_back(ReturnOp{s.value(), ec.source});
-          },
-          [&](const common::Indirection<const parser::ReadStmt> &s) {
-            threeLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::WriteStmt> &s) {
-            threeLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::WaitStmt> &s) {
-            threeLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::OpenStmt> &s) {
-            errLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::CloseStmt> &s) {
-            errLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::BackspaceStmt> &s) {
-            errLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::EndfileStmt> &s) {
-            errLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::RewindStmt> &s) {
-            errLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::FlushStmt> &s) {
-            errLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<const parser::InquireStmt> &s) {
-            errLabelSpec(s.value(), ops, ec, ad);
-          },
-          [&](const common::Indirection<parser::ComputedGotoStmt> &s) {
-            auto next{BuildNewLabel(ad)};
-            auto labels{toLabelMention(
-                next, ad, std::get<std::list<parser::Label>>(s.value().t))};
-            ops.emplace_back(SwitchOp{s.value(), std::move(labels), ec.source});
-            ops.emplace_back(next);
-          },
-          [&](const common::Indirection<parser::ArithmeticIfStmt> &s) {
-            ops.emplace_back(SwitchOp{s.value(),
-                toLabelMention(ad,
-                    std::list{std::get<1>(s.value().t),
-                        std::get<2>(s.value().t), std::get<3>(s.value().t)}),
-                ec.source});
-          },
-          [&](const common::Indirection<parser::AssignedGotoStmt> &s) {
-            ops.emplace_back(
-                IndirectGotoOp{std::get<parser::Name>(s.value().t).symbol,
-                    toLabelMention(
-                        ad, std::get<std::list<parser::Label>>(s.value().t))});
-          },
-          [&](const common::Indirection<parser::IfStmt> &s) {
-            auto then{BuildNewLabel(ad)};
-            auto endif{BuildNewLabel(ad)};
-            ops.emplace_back(ConditionalGotoOp{s.value(), then, endif});
-            ops.emplace_back(then);
-            ops.emplace_back(ActionOp{ec});
-            ops.emplace_back(endif);
-          },
-      },
-      ec.statement.u);
-}
-
-template<typename> struct ElementMap;
-template<> struct ElementMap<parser::CaseConstruct> {
-  using type = parser::CaseConstruct::Case;
-};
-template<> struct ElementMap<parser::SelectRankConstruct> {
-  using type = parser::SelectRankConstruct::RankCase;
-};
-template<> struct ElementMap<parser::SelectTypeConstruct> {
-  using type = parser::SelectTypeConstruct::TypeCase;
-};
-
-struct ControlFlowAnalyzer {
-  explicit ControlFlowAnalyzer(std::list<Op> &ops, AnalysisData &ad)
-    : linearOps{ops}, ad{ad} {}
-
-  LabelOp buildNewLabel() { return BuildNewLabel(ad); }
-
-  Op findLabel(const parser::Label &lab) {
-    auto iter{ad.labelMap.find(lab)};
-    if (iter == ad.labelMap.end()) {
-      LabelOp ll{ad.labelBuilder};
-      ad.labelMap.insert({lab, ll});
-      return {ll};
-    }
-    return {iter->second};
-  }
-
-  template<typename A> constexpr bool Pre(const A &) { return true; }
-  template<typename A> constexpr void Post(const A &) {}
-
-  template<typename A> bool Pre(const parser::Statement<A> &stmt) {
-    if (stmt.label) {
-      linearOps.emplace_back(findLabel(*stmt.label));
-    }
-    if constexpr (std::is_same_v<A, parser::ActionStmt>) {
-      Op::Build(linearOps, stmt, ad);
-    }
-    return true;
-  }
-  template<typename A>
-  void appendIfLabeled(const parser::Statement<A> &stmt, std::list<Op> &ops) {
-    if (stmt.label) {
-      ops.emplace_back(findLabel(*stmt.label));
-    }
-  }
-
-  // named constructs
-  template<typename A> bool linearConstruct(const A &construct) {
-    std::list<Op> ops;
-    LabelOp label{buildNewLabel()};
-    const parser::Name *name{getName(construct)};
-    ad.constructContextStack.emplace_back(
-        name, GetLabelMention(label), UnspecifiedLabel);
-    appendIfLabeled(std::get<0>(construct.t), ops);
-    ops.emplace_back(BeginOp{construct});
-    ControlFlowAnalyzer cfa{ops, ad};
-    Walk(std::get<parser::Block>(construct.t), cfa);
-    ops.emplace_back(label);
-    appendIfLabeled(std::get<2>(construct.t), ops);
-    ops.emplace_back(EndOp{construct});
-    linearOps.splice(linearOps.end(), ops);
-    ad.constructContextStack.pop_back();
-    return false;
-  }
-
-  bool Pre(const parser::AssociateConstruct &c) { return linearConstruct(c); }
-  bool Pre(const parser::ChangeTeamConstruct &c) { return linearConstruct(c); }
-  bool Pre(const parser::CriticalConstruct &c) { return linearConstruct(c); }
-
-  bool Pre(const parser::BlockConstruct &construct) {
-    std::list<Op> ops;
-    LabelOp label{buildNewLabel()};
-    const auto &optName{
-        std::get<parser::Statement<parser::BlockStmt>>(construct.t)
-            .statement.v};
-    const parser::Name *name{optName ? &*optName : nullptr};
-    ad.constructContextStack.emplace_back(
-        name, GetLabelMention(label), UnspecifiedLabel);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::BlockStmt>>(construct.t), ops);
-    ops.emplace_back(BeginOp{construct});
-    ControlFlowAnalyzer cfa{ops, ad};
-    Walk(std::get<parser::Block>(construct.t), cfa);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::EndBlockStmt>>(construct.t), ops);
-    ops.emplace_back(EndOp{construct});
-    ops.emplace_back(label);
-    linearOps.splice(linearOps.end(), ops);
-    ad.constructContextStack.pop_back();
-    return false;
-  }
-
-  /// `DO` constructs can be lowered to `fir.loop` if they meet some
-  /// constraints, otherwise they are lowered to a CFG.
-  bool Pre(const parser::DoConstruct &construct) {
-    std::list<Op> ops;
-    LabelOp backedgeLab{buildNewLabel()};
-    LabelOp incrementLab{buildNewLabel()};
-    LabelOp entryLab{buildNewLabel()};
-    LabelOp exitLab{buildNewLabel()};
-    const parser::Name *name{getName(construct)};
-    LabelMention exitOpRef{GetLabelMention(exitLab)};
-    ad.constructContextStack.emplace_back(
-        name, exitOpRef, GetLabelMention(incrementLab));
-    appendIfLabeled(
-        std::get<parser::Statement<parser::NonLabelDoStmt>>(construct.t), ops);
-    ops.emplace_back(BeginOp{construct});
-    ops.emplace_back(GotoOp{GetLabelMention(backedgeLab)});
-    ops.emplace_back(incrementLab);
-    ops.emplace_back(DoIncrementOp{construct});
-    ops.emplace_back(backedgeLab);
-    ops.emplace_back(DoCompareOp{construct});
-    ops.emplace_back(ConditionalGotoOp{
-        std::get<parser::Statement<parser::NonLabelDoStmt>>(construct.t),
-        GetLabelMention(entryLab), exitOpRef});
-    ops.push_back(entryLab);
-    ControlFlowAnalyzer cfa{ops, ad};
-    Walk(std::get<parser::Block>(construct.t), cfa);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::EndDoStmt>>(construct.t), ops);
-    ops.emplace_back(GotoOp{GetLabelMention(incrementLab)});
-    ops.emplace_back(EndOp{construct});
-    ops.emplace_back(exitLab);
-    linearOps.splice(linearOps.end(), ops);
-    ad.constructContextStack.pop_back();
-    return false;
-  }
-
-  /// `IF` constructs can be lowered to `fir.where` if they meet some
-  /// constraints, otherwise they are lowered to a CFG.
-  bool Pre(const parser::IfConstruct &construct) {
-    std::list<Op> ops;
-    LabelOp thenLab{buildNewLabel()};
-    LabelOp elseLab{buildNewLabel()};
-    LabelOp exitLab{buildNewLabel()};
-    const parser::Name *name{getName(construct)};
-    ad.constructContextStack.emplace_back(
-        name, GetLabelMention(exitLab), UnspecifiedLabel);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::IfThenStmt>>(construct.t), ops);
-    ops.emplace_back(BeginOp{construct});
-    ops.emplace_back(ConditionalGotoOp{
-        std::get<parser::Statement<parser::IfThenStmt>>(construct.t),
-        GetLabelMention(thenLab), GetLabelMention(elseLab)});
-    ops.emplace_back(thenLab);
-    ControlFlowAnalyzer cfa{ops, ad};
-    Walk(std::get<parser::Block>(construct.t), cfa);
-    LabelMention exitOpRef{GetLabelMention(exitLab)};
-    ops.emplace_back(GotoOp{exitOpRef});
-    for (const auto &elseIfBlock :
-        std::get<std::list<parser::IfConstruct::ElseIfBlock>>(construct.t)) {
-      appendIfLabeled(
-          std::get<parser::Statement<parser::ElseIfStmt>>(elseIfBlock.t), ops);
-      ops.emplace_back(elseLab);
-      LabelOp newThenLab{buildNewLabel()};
-      LabelOp newElseLab{buildNewLabel()};
-      ops.emplace_back(ConditionalGotoOp{
-          std::get<parser::Statement<parser::ElseIfStmt>>(elseIfBlock.t),
-          GetLabelMention(newThenLab), GetLabelMention(newElseLab)});
-      ops.emplace_back(newThenLab);
-      Walk(std::get<parser::Block>(elseIfBlock.t), cfa);
-      ops.emplace_back(GotoOp{exitOpRef});
-      elseLab = newElseLab;
-    }
-    ops.emplace_back(elseLab);
-    if (const auto &optElseBlock{
-            std::get<std::optional<parser::IfConstruct::ElseBlock>>(
-                construct.t)}) {
-      appendIfLabeled(
-          std::get<parser::Statement<parser::ElseStmt>>(optElseBlock->t), ops);
-      Walk(std::get<parser::Block>(optElseBlock->t), cfa);
-    }
-    ops.emplace_back(GotoOp{exitOpRef});
-    ops.emplace_back(exitLab);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::EndIfStmt>>(construct.t), ops);
-    ops.emplace_back(EndOp{construct});
-    linearOps.splice(linearOps.end(), ops);
-    ad.constructContextStack.pop_back();
-    return false;
-  }
-
-  template<typename A> bool Multiway(const A &construct) {
-    using B = typename ElementMap<A>::type;
-    std::list<Op> ops;
-    LabelOp exitLab{buildNewLabel()};
-    const parser::Name *name{getName(construct)};
-    ad.constructContextStack.emplace_back(
-        name, GetLabelMention(exitLab), UnspecifiedLabel);
-    appendIfLabeled(std::get<0>(construct.t), ops);
-    ops.emplace_back(BeginOp{construct});
-    const auto N{std::get<std::list<B>>(construct.t).size()};
-    LabelMention exitOpRef{GetLabelMention(exitLab)};
-    if (N > 0) {
-      typename std::list<B>::size_type i;
-      std::vector<LabelOp> toLabels;
-      for (i = 0; i != N; ++i) {
-        toLabels.emplace_back(buildNewLabel());
-      }
-      std::vector<LabelMention> targets;
-      for (i = 0; i != N; ++i) {
-        targets.emplace_back(GetLabelMention(toLabels[i]));
-      }
-      ops.emplace_back(
-          SwitchOp{construct, targets, std::get<0>(construct.t).source});
-      ControlFlowAnalyzer cfa{ops, ad};
-      i = 0;
-      for (const auto &caseBlock : std::get<std::list<B>>(construct.t)) {
-        ops.emplace_back(toLabels[i++]);
-        appendIfLabeled(std::get<0>(caseBlock.t), ops);
-        Walk(std::get<parser::Block>(caseBlock.t), cfa);
-        ops.emplace_back(GotoOp{exitOpRef});
-      }
-    }
-    ops.emplace_back(exitLab);
-    appendIfLabeled(std::get<2>(construct.t), ops);
-    ops.emplace_back(EndOp{construct});
-    linearOps.splice(linearOps.end(), ops);
-    ad.constructContextStack.pop_back();
-    return false;
-  }
-
-  bool Pre(const parser::CaseConstruct &c) { return Multiway(c); }
-  bool Pre(const parser::SelectRankConstruct &c) { return Multiway(c); }
-  bool Pre(const parser::SelectTypeConstruct &c) { return Multiway(c); }
-
-  bool Pre(const parser::WhereConstruct &c) {
-    std::list<Op> ops;
-    LabelOp label{buildNewLabel()};
-    const parser::Name *name{getName(c)};
-    ad.constructContextStack.emplace_back(
-        name, GetLabelMention(label), UnspecifiedLabel);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::WhereConstructStmt>>(c.t), ops);
-    ops.emplace_back(BeginOp{c});
-    ControlFlowAnalyzer cfa{ops, ad};
-    Walk(std::get<std::list<parser::WhereBodyConstruct>>(c.t), cfa);
-    Walk(
-        std::get<std::list<parser::WhereConstruct::MaskedElsewhere>>(c.t), cfa);
-    Walk(std::get<std::optional<parser::WhereConstruct::Elsewhere>>(c.t), cfa);
-    ops.emplace_back(label);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::EndWhereStmt>>(c.t), ops);
-    ops.emplace_back(EndOp{c});
-    linearOps.splice(linearOps.end(), ops);
-    ad.constructContextStack.pop_back();
-    return false;
-  }
-
-  bool Pre(const parser::ForallConstruct &construct) {
-    std::list<Op> ops;
-    LabelOp label{buildNewLabel()};
-    const parser::Name *name{getName(construct)};
-    ad.constructContextStack.emplace_back(
-        name, GetLabelMention(label), UnspecifiedLabel);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::ForallConstructStmt>>(construct.t),
-        ops);
-    ops.emplace_back(BeginOp{construct});
-    ControlFlowAnalyzer cfa{ops, ad};
-    Walk(std::get<std::list<parser::ForallBodyConstruct>>(construct.t), cfa);
-    ops.emplace_back(label);
-    appendIfLabeled(
-        std::get<parser::Statement<parser::EndForallStmt>>(construct.t), ops);
-    ops.emplace_back(EndOp{construct});
-    linearOps.splice(linearOps.end(), ops);
-    ad.constructContextStack.pop_back();
-    return false;
-  }
-
-  template<typename A> const parser::Name *getName(const A &a) {
-    const auto &optName{std::get<0>(std::get<0>(a.t).statement.t)};
-    return optName ? &*optName : nullptr;
-  }
-
-  LabelMention GetLabelMention(const LabelOp &label) {
-    label.setReferenced();
-    return label;
-  }
-
-  LabelMention GetLabelMention(const parser::Label &label) {
-    return FetchLabel(ad, label);
-  }
-
-  std::list<Op> &linearOps;
-  AnalysisData &ad;
-};
-
-}  // namespace flat
-
-void CreateFlatIR(std::list<flat::Op> &ops, AnalysisData &ad) {
-  flat::ControlFlowAnalyzer linearize{ops, ad};
-  std::visit(
-      [&](const auto *ptree) { Walk(*ptree, linearize); }, ad.parseTreeRoot);
-}
-
-}  // namespace burnside
diff --git a/lib/burnside/flattened.h b/lib/burnside/flattened.h
deleted file mode 100644
index 36c32c3c98d0..000000000000
--- a/lib/burnside/flattened.h
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef FORTRAN_BURNSIDE_FLATTENED_H_
-#define FORTRAN_BURNSIDE_FLATTENED_H_
-
-#include "mixin.h"
-#include "../parser/parse-tree.h"
-#include "llvm/ADT/BitVector.h"
-#include <cstdint>
-#include <list>
-#include <map>
-#include <set>
-#include <vector>
-
-namespace Fortran::burnside {
-
-struct AnalysisData;
-
-namespace flat {
-
-/// This is a flattened, linearized representation of the parse
-/// tree. It captures the executable specification of the input
-/// program. The flattened IR can be used to construct FIR.
-///
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
-
-using LabelMention = unsigned;
-constexpr LabelMention UnspecifiedLabel{UINT_MAX};
-
-using Location = parser::CharBlock;
-struct LabelBuilder;
-
-// target for a control-flow edge
-struct LabelOp {
-  explicit LabelOp(LabelBuilder &builder);
-  LabelOp(const LabelOp &that);
-  LabelOp &operator=(const LabelOp &that);
-  void setReferenced() const;
-  bool isReferenced() const;
-  LabelMention get() const { return label; }
-  operator LabelMention() const { return get(); }
-
-private:
-  LabelBuilder &builder;
-  LabelMention label;
-};
-
-struct ArtificialJump {};
-
-// a source of an absolute control flow edge
-struct GotoOp
-  : public SumTypeCopyMixin<const parser::CycleStmt *, const parser::ExitStmt *,
-        const parser::GotoStmt *, ArtificialJump> {
-  template<typename A>
-  explicit GotoOp(const A &stmt, LabelMention dest, const Location &source)
-    : SumTypeCopyMixin{&stmt}, target{dest}, source{source} {}
-  explicit GotoOp(LabelMention dest)
-    : SumTypeCopyMixin{ArtificialJump{}}, target{dest} {}
-
-  LabelMention target;
-  Location source;
-};
-
-// control exits the procedure
-struct ReturnOp : public SumTypeCopyMixin<const parser::FailImageStmt *,
-                      const parser::ReturnStmt *, const parser::StopStmt *> {
-  template<typename A>
-  explicit ReturnOp(const A &stmt, const Location &source)
-    : SumTypeCopyMixin{&stmt}, source{source} {}
-
-  Location source;
-};
-
-// two-way branch based on a condition
-struct ConditionalGotoOp
-  : public SumTypeCopyMixin<const parser::Statement<parser::IfThenStmt> *,
-        const parser::Statement<parser::ElseIfStmt> *, const parser::IfStmt *,
-        const parser::Statement<parser::NonLabelDoStmt> *> {
-  template<typename A>
-  explicit ConditionalGotoOp(const A &cond, LabelMention tb, LabelMention fb)
-    : SumTypeCopyMixin{&cond}, trueLabel{tb}, falseLabel{fb} {}
-
-  LabelMention trueLabel;
-  LabelMention falseLabel;
-};
-
-// multi-way branch based on a target-value of a variable
-struct IndirectGotoOp {
-  explicit IndirectGotoOp(
-      const semantics::Symbol *symbol, std::vector<LabelMention> &&labelRefs)
-    : labelRefs{labelRefs}, symbol{symbol} {}
-
-  std::vector<LabelMention> labelRefs;
-  const semantics::Symbol *symbol;
-};
-
-// intrinsic IO operations can return with an implied multi-way branch
-struct SwitchIOOp
-  : public SumTypeCopyMixin<const parser::ReadStmt *, const parser::WriteStmt *,
-        const parser::WaitStmt *, const parser::OpenStmt *,
-        const parser::CloseStmt *, const parser::BackspaceStmt *,
-        const parser::EndfileStmt *, const parser::RewindStmt *,
-        const parser::FlushStmt *, const parser::InquireStmt *> {
-  template<typename A>
-  explicit SwitchIOOp(const A &io, LabelMention next, const Location &source,
-      std::optional<LabelMention> errLab,
-      std::optional<LabelMention> eorLab = std::nullopt,
-      std::optional<LabelMention> endLab = std::nullopt)
-    : SumTypeCopyMixin{&io}, next{next}, source{source}, errLabel{errLab},
-      eorLabel{eorLab}, endLabel{endLab} {}
-  LabelMention next;
-  Location source;
-  std::optional<LabelMention> errLabel;
-  std::optional<LabelMention> eorLabel;
-  std::optional<LabelMention> endLabel;
-};
-
-// multi-way branch based on conditions
-struct SwitchOp
-  : public SumTypeCopyMixin<const parser::CallStmt *,
-        const parser::ComputedGotoStmt *, const parser::ArithmeticIfStmt *,
-        const parser::CaseConstruct *, const parser::SelectRankConstruct *,
-        const parser::SelectTypeConstruct *> {
-  template<typename A>
-  explicit SwitchOp(const A &sw, const std::vector<LabelMention> &refs,
-      const Location &source)
-    : SumTypeCopyMixin{&sw}, refs{refs}, source{source} {}
-
-  const std::vector<LabelMention> refs;
-  Location source;
-};
-
-// a compute step
-struct ActionOp {
-  explicit ActionOp(const parser::Statement<parser::ActionStmt> &stmt)
-    : v{&stmt} {}
-
-  const parser::Statement<parser::ActionStmt> *v;
-};
-
-#define CONSTRUCT_TYPES \
-  const parser::AssociateConstruct *, const parser::BlockConstruct *, \
-      const parser::CaseConstruct *, const parser::ChangeTeamConstruct *, \
-      const parser::CriticalConstruct *, const parser::DoConstruct *, \
-      const parser::IfConstruct *, const parser::SelectRankConstruct *, \
-      const parser::SelectTypeConstruct *, const parser::WhereConstruct *, \
-      const parser::ForallConstruct *, const parser::CompilerDirective *, \
-      const parser::OpenMPConstruct *, const parser::OmpEndLoopDirective *
-
-// entry into a Fortran construct
-struct BeginOp : public SumTypeCopyMixin<CONSTRUCT_TYPES> {
-  SUM_TYPE_COPY_MIXIN(BeginOp)
-
-  template<typename A> explicit BeginOp(const A &c) : SumTypeCopyMixin{&c} {}
-};
-
-// exit from a Fortran construct
-struct EndOp : public SumTypeCopyMixin<CONSTRUCT_TYPES> {
-  SUM_TYPE_COPY_MIXIN(EndOp)
-
-  template<typename A> explicit EndOp(const A &c) : SumTypeCopyMixin{&c} {}
-};
-
-struct DoIncrementOp {
-  explicit DoIncrementOp(const parser::DoConstruct &stmt) : v{&stmt} {}
-
-  const parser::DoConstruct *v;
-};
-
-struct DoCompareOp {
-  DoCompareOp(const parser::DoConstruct &stmt) : v{&stmt} {}
-
-  const parser::DoConstruct *v;
-};
-
-// the flat structure is a list of Ops, where an Op is any of ...
-struct Op : public SumTypeMixin<LabelOp, GotoOp, ReturnOp, ConditionalGotoOp,
-                SwitchIOOp, SwitchOp, ActionOp, BeginOp, EndOp, IndirectGotoOp,
-                DoIncrementOp, DoCompareOp> {
-  template<typename A> Op(const A &thing) : SumTypeMixin{thing} {}
-
-  static void Build(std::list<Op> &ops,
-      const parser::Statement<parser::ActionStmt> &ec, AnalysisData &ad);
-};
-
-// helper to build unique labels
-struct LabelBuilder {
-  LabelBuilder();
-  LabelMention getNext();
-  void setReferenced(LabelMention label);
-  bool isReferenced(LabelMention label) const;
-  llvm::BitVector referenced;
-  unsigned counter;
-};
-
-LabelOp FetchLabel(AnalysisData &ad, const parser::Label &label);
-
-std::vector<LabelMention> GetAssign(
-    AnalysisData &ad, const semantics::Symbol *symbol);
-
-}  // namespace flat
-
-// Collection of data maintained internally by the flattening algorithm
-struct AnalysisData {
-  template<typename Node>
-  AnalysisData(const Node &node) : parseTreeRoot{&node} {}
-
-  std::map<parser::Label, flat::LabelOp> labelMap;
-  std::vector<
-      std::tuple<const parser::Name *, flat::LabelMention, flat::LabelMention>>
-      constructContextStack;
-  flat::LabelBuilder labelBuilder;
-  std::map<const semantics::Symbol *, std::set<parser::Label>> assignMap;
-  const std::variant<const parser::MainProgram *,
-      const parser::FunctionSubprogram *, const parser::SubroutineSubprogram *>
-      parseTreeRoot;
-};
-
-void CreateFlatIR(std::list<flat::Op> &, AnalysisData &);
-
-}  // namespace burnside
-
-#endif  // FORTRAN_BURNSIDE_FLATTENED_H_
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index e5beb1432e4a..5b231903d6b2 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -438,6 +438,7 @@ mlir::Value *IntrinsicLibrary::Implementation::genRuntimeCall(
     // TODO: better error handling ?
     //  - Try to have compile time check of runtime compltness ?
   }
+  return {}; // gets rid of warnings
 }
 
 // CONJG
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index 3366006bfe55..a13b7b96d446 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -20,7 +20,7 @@ set(LIBS
   MLIRStandardOps
 )
 
-add_llvm_library(FirBbcLib bbc.cc)
+add_llvm_library(FirBbcLib bbc.cpp)
 target_link_libraries(FirBbcLib ${LIBS} FIRTransforms)
 
 set(EXE_LIBS
@@ -33,7 +33,7 @@ set(EXE_LIBS
   FortranBurnside
 )
 
-add_llvm_tool(bbc bbc.cc)
+add_llvm_tool(bbc bbc.cpp)
 llvm_update_compile_flags(bbc)
 whole_archive_link(bbc ${LIBS})
 target_link_libraries(bbc PRIVATE FIR MLIRIR FirBbcLib ${EXE_LIBS} LLVMSupport)
diff --git a/tools/bbc/bbc.cc b/tools/bbc/bbc.cpp
similarity index 99%
rename from tools/bbc/bbc.cc
rename to tools/bbc/bbc.cpp
index cbe64733df58..d21bfbeea490 100644
--- a/tools/bbc/bbc.cc
+++ b/tools/bbc/bbc.cpp
@@ -38,6 +38,7 @@
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
+#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/Parser.h"
@@ -285,6 +286,9 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
     pm.addPass(fir::createFIRToStdPass());
   }
   if (driver.lowerToLLVM) {
+    pm.addPass(fir::createLowerToLoopPass());
+    pm.addPass(fir::createFIRToStdPass());
+    pm.addPass(mlir::createLowerToCFGPass());
     pm.addPass(fir::createFIRToLLVMPass(nameMangler));
   }
   if (driver.lowerToLLVMIR) {

From 93fbe342cde6ec7651355174eb9ad4c630628f58 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 5 Dec 2019 04:33:28 -0800
Subject: [PATCH 131/345] [PATCH 1/2] Intrinsic operations lowering tests and
 fixes

+ Implement TODO: better runtime function selection for intrinsics
When no runtime function specialization exits for a type, select
the "best" runtime version available that does not destroy
information (e.g. narrows arguments).

+ Also change function mangling to match pgfortran/gfortran for
external functions so that f18 compiled functions can be tested
against. Use semantics::Symbol information to drive mangling
(all required information for mangling regarding scopes and what
the symbol is should be available inside this).

+ Better intrinsic function wrapper name in FIR
Mangle argument types in name so that a difference can be made
for cases where the result type is not sufficient (e.g. atan, power...)

+ Add expression evaluation test facility

Conflicts:
	lib/burnside/bridge.cc
  Note: kept AST version only

[PATCH 2/2] Fix rebase logical conflicts with new "ast" - Apply pgfortran mangling for external functions - Change expression lowering symbol map to the newly added   `localSymbols` map. Also load return value from there.
---
 lib/burnside/bridge.cc                    |   6 +-
 lib/burnside/builder.cc                   |  40 ++
 lib/burnside/builder.h                    |   6 +
 lib/burnside/convert-expr.cc              |  16 +-
 lib/burnside/intrinsics.cc                | 166 +++++-
 test/burnside/expr-test-generator.cc      | 689 ++++++++++++++++++++++
 test/burnside/test_expression_lowering.sh |  65 ++
 7 files changed, 958 insertions(+), 30 deletions(-)
 create mode 100644 test/burnside/expr-test-generator.cc
 create mode 100755 test/burnside/test_expression_lowering.sh

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 172b99c504d0..bcd1a73690d7 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -538,8 +538,9 @@ class FirConverter {
       Se::Symbol const *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
-    name = n.ToString();
     symbol = n.symbol;
+    assert(symbol && "Name resolution failure");
+    name = applyNameMangling(*symbol);  // FIXME: use NameMangler
   }
   void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
       Se::Symbol const *&) {
@@ -550,8 +551,9 @@ class FirConverter {
       Se::Symbol const *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
-    name = n.ToString();
     symbol = n.symbol;
+    assert(symbol && "Name resolution failure");
+    name = applyNameMangling(*symbol);  // FIXME: use NameMangler
   }
   void genFIR(const Pa::Statement<Pa::EndSubroutineStmt> &stmt, std::string &,
       Se::Symbol const *&) {
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index e789d2843a31..9508b3398d1d 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -30,6 +30,46 @@ std::string B::applyNameMangling(llvm::StringRef parserName) {
   return "_Qp_"s + parserName.str();
 }
 
+std::string B::applyNameMangling(const evaluate::ProcedureDesignator &proc) {
+  if (const auto *symbol{proc.GetSymbol()}) {
+    return applyNameMangling(*symbol);
+  } else {
+    // Do not mangle intrinsic for now
+    assert(proc.GetSpecificIntrinsic() &&
+        "expected intrinsic procedure in designator");
+    return proc.GetName();
+  }
+}
+
+std::string B::applyNameMangling(semantics::SymbolRef symbol) {
+  // FIXME: this is fake for now, add type info, etc.
+  // For now, only works for external procedures
+  // TODO: apply binding
+  // TODO: determine if procedure are:
+  //   - external, internal or  module
+  // TODO: Apply proposed mangling with _Qp_ ....
+  return std::visit(
+      common::visitors{
+          [&](const semantics::MainProgramDetails &) { return "MAIN_"s; },
+          [&](const semantics::SubprogramDetails &) {
+            return symbol->name().ToString() + "_";
+          },
+          [&](const semantics::ProcEntityDetails &) {
+            return symbol->name().ToString() + "_";
+          },
+          [&](const semantics::SubprogramNameDetails &) {
+            assert(false &&
+                "SubprogramNameDetails not expected after semantic analysis");
+            return ""s;
+          },
+          [&](const auto &) {
+            assert(false && "Symbol mangling TODO");
+            return ""s;
+          },
+      },
+      symbol->details());
+}
+
 mlir::FuncOp B::createFunction(mlir::ModuleOp module, llvm::StringRef name,
     mlir::FunctionType funcTy, parser::CookedSource const *cooked,
     parser::CharBlock const *cb) {
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index d340652840be..2eed75590d7f 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -31,6 +31,10 @@ namespace parser {
 class CookedSource;
 }
 
+namespace evaluate {
+struct ProcedureDesignator;
+}
+
 namespace burnside {
 
 /// Miscellaneous helper routines for building MLIR
@@ -49,6 +53,8 @@ class SymMap {
 };
 
 std::string applyNameMangling(llvm::StringRef parserName);
+std::string applyNameMangling(const evaluate::ProcedureDesignator &proc);
+std::string applyNameMangling(semantics::SymbolRef symbol);
 
 /// Get the current Module
 inline mlir::ModuleOp getModule(mlir::OpBuilder *bldr) {
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index e6a57e853aef..3ae2cc893edd 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -260,8 +260,18 @@ class ExprLowering {
   }
 
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Negate<Ev::Type<TC, KIND>> const &) {
-    TODO();
+  M::Value *genval(Ev::Negate<Ev::Type<TC, KIND>> const &op) {
+    auto input{genval(op.left())};
+    if constexpr (TC == IntegerCat) {
+      // Currently no Standard/FIR op for integer negation.
+      auto zero{genIntegerConstant<KIND>(builder.getContext(), 0)};
+      return builder.create<M::SubIOp>(getLoc(), zero, input);
+    } else if constexpr (TC == RealCat) {
+      return builder.create<fir::NegfOp>(getLoc(), input);
+    } else {
+      static_assert(TC == ComplexCat, "Expected numeric type");
+      return createBinaryOp<fir::NegcOp>(op);
+    }
   }
 
   template<Co::TypeCategory TC, int KIND>
@@ -687,7 +697,7 @@ class ExprLowering {
       M::Type resultType{getFIRType(builder.getContext(), defaults, TC, KIND)};
       M::FunctionType funTy{
           M::FunctionType::get(argTypes, resultType, builder.getContext())};
-      M::FuncOp func{getFunction(funRef.proc().GetName(), funTy)};
+      M::FuncOp func{getFunction(applyNameMangling(funRef.proc()), funTy)};
       auto call{builder.create<M::CallOp>(getLoc(), func, operands)};
       // For now, Fortran return value are implemented with a single MLIR
       // function return value.
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index 5b231903d6b2..5f7487d20183 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -21,6 +21,7 @@
 #include "fir/FIRType.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
+#include <algorithm>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -118,7 +119,7 @@ class IntrinsicLibrary::Implementation {
 
   /// Define the different FIR generators that can be mapped to intrinsic to
   /// generate the related code.
-  using Generator = mlir::Value *(Implementation::*)(Context &) const;
+  using Generator = mlir::Value *(Implementation::*)(Context &)const;
   /// Search a runtime function that is associated to the generic intrinsic name
   /// and whose signature matches the intrinsic arguments and result types.
   /// If no such runtime function is found but a runtime function associated
@@ -276,29 +277,135 @@ mlir::FuncOp MathRuntimeLibrary::getFuncOp(
   return function;
 }
 
+// This helper class computes a "distance" between two function types.
+// The distance represents the argument and result conversions
+// that are required if one use "to" instead of "from".
+// Note that this is not a reflexive distance, and it does not
+// define a total order at all.
+class FunctionDistance {
+public:
+  FunctionDistance() : infinite{true} {}
+  FunctionDistance(mlir::FunctionType from, mlir::FunctionType to) {
+    auto nInputs{from.getNumInputs()};
+    auto nResults{from.getNumResults()};
+    if (nResults != to.getNumResults() || nInputs != to.getNumInputs()) {
+      infinite = true;
+    } else {
+      for (unsigned int i{0}; i < nInputs; ++i) {
+        addArgumentDistance(from.getInput(i), to.getInput(i));
+      }
+      for (unsigned int i{0}; i < nResults; ++i) {
+        addResultDistance(to.getResult(i), from.getResult(i));
+      }
+    }
+  }
+  bool isSmallerThan(const FunctionDistance &d) const {
+    return d.infinite ||
+        (!infinite &&
+            std::lexicographical_compare(conversions.begin(), conversions.end(),
+                d.conversions.begin(), d.conversions.end()));
+  }
+  bool isLoosingPrecision() const {
+    return conversions[narrowingArg] != 0 || conversions[extendingResult] != 0;
+  }
+  bool isInfinite() const { return infinite; }
+
+private:
+  enum class Conversion { Forbidden, None, Narrow, Extend };
+
+  void addArgumentDistance(mlir::Type from, mlir::Type to) {
+    switch (conversionBetweenTypes(from, to)) {
+    case Conversion::Forbidden: infinite = true; break;
+    case Conversion::None: break;
+    case Conversion::Narrow: conversions[narrowingArg]++; break;
+    case Conversion::Extend: conversions[nonNarrowingArg]++; break;
+    }
+  }
+  void addResultDistance(mlir::Type from, mlir::Type to) {
+    switch (conversionBetweenTypes(from, to)) {
+    case Conversion::Forbidden: infinite = true; break;
+    case Conversion::None: break;
+    case Conversion::Narrow: conversions[nonExtendingResult]++; break;
+    case Conversion::Extend: conversions[extendingResult]++; break;
+    }
+  }
+
+  static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
+    if (from == to) {
+      return Conversion::None;
+    }
+    if (auto fromIntTy{from.dyn_cast<mlir::IntegerType>()}) {
+      if (auto toIntTy{to.dyn_cast<mlir::IntegerType>()}) {
+        return fromIntTy.getWidth() > toIntTy.getWidth() ? Conversion::Narrow
+                                                         : Conversion::Extend;
+      }
+    }
+    if (auto fromRealTy{from.dyn_cast<fir::RealType>()}) {
+      if (auto toRealTy{to.dyn_cast<fir::RealType>()}) {
+        // FIXME: With the current runtime (no functions with f16 and bf16
+        // types), and the current kinds to representation mapping, that
+        // just works, but that is not that simple:
+        //    - conversions between f16 and bf16 destroy information in both
+        //    ways.
+        //    - No assumptions regarding kind <-> representation should be made
+        //    here.
+        return fromRealTy.getFKind() > toRealTy.getFKind() ? Conversion::Narrow
+                                                           : Conversion::Extend;
+      }
+    }
+    if (auto fromCplxTy{from.dyn_cast<fir::CplxType>()}) {
+      if (auto toCplxTy{to.dyn_cast<fir::RealType>()}) {
+        // FIXME: Same as for Real.
+        return fromCplxTy.getFKind() > toCplxTy.getFKind() ? Conversion::Narrow
+                                                           : Conversion::Extend;
+      }
+    }
+    // Notes:
+    // - No conversion between character types, specialization of runtime
+    // functions should be made instead.
+    // - It is not clear there is a use case for automatic conversions
+    // around Logical and it may damage hidden information in the physical
+    // storage so do not do it.
+    return Conversion::Forbidden;
+  }
+
+  // Below are indexes to access data in conversions.
+  // The order in data does matter for lexicographical_compare
+  enum {
+    narrowingArg = 0,  // usually bad
+    extendingResult,  // usually bad
+    nonExtendingResult,  // usually ok
+    nonNarrowingArg,  // usually ok
+    dataSize
+  };
+  std::array<int, dataSize> conversions{/* zero init*/};
+  bool infinite{false};  // When forbidden conversion or wrong argument number
+};
+
+// Select runtime function that has the smallest distance to the intrinsic
+// function type and that will not imply narrowing arguments or extending the
+// result.
 llvm::Optional<mlir::FuncOp> MathRuntimeLibrary::getFunction(
     mlir::OpBuilder &builder, llvm::StringRef name,
     mlir::FunctionType funcType) const {
   auto range{library.equal_range(name)};
   const RuntimeFunction *bestNearMatch{nullptr};
+  FunctionDistance bestMatchDistance{};
   for (auto iter{range.first}; iter != range.second; ++iter) {
     const RuntimeFunction &impl{iter->second};
     if (funcType == impl.type) {
       return getFuncOp(builder, impl);  // exact match
     } else {
-      if (!bestNearMatch &&
-          impl.type.getNumResults() == funcType.getNumResults() &&
-          impl.type.getNumInputs() == funcType.getNumInputs()) {
+      FunctionDistance distance(funcType, impl.type);
+      if (distance.isSmallerThan(bestMatchDistance)) {
         bestNearMatch = &impl;
-      } else {
-        // TODO the best near match should not be the first hit.
-        // It should apply rules:
-        //  -> Non narrowing argument conversion are better
-        //  -> The "nearest" conversions are better
+        bestMatchDistance = std::move(distance);
       }
     }
   }
   if (bestNearMatch != nullptr) {
+    assert(!bestMatchDistance.isLoosingPrecision() &&
+        "runtime selection looses precision");
     return getFuncOp(builder, *bestNearMatch);
   } else {
     return {};
@@ -334,26 +441,35 @@ static mlir::FunctionType getFunctionType(mlir::Type resultType,
       argumentTypes, resultType, getModule(&builder).getContext());
 }
 
+// TODO find nicer type to string infra or move this in a mangling utility
+// mlir as Type::dump(ostream) methods but it may adds !
+static std::string typeToString(mlir::Type t) {
+  if (auto i{t.dyn_cast<mlir::IntegerType>()}) {
+    return "i" + std::to_string(i.getWidth());
+  } else if (auto cplx{t.dyn_cast<fir::CplxType>()}) {
+    return "z" + std::to_string(cplx.getFKind());
+  } else if (auto real{t.dyn_cast<fir::RealType>()}) {
+    return "r" + std::to_string(real.getFKind());
+  } else if (auto f{t.dyn_cast<mlir::FloatType>()}) {
+    return "f" + std::to_string(f.getWidth());
+  } else if (auto logical{t.dyn_cast<fir::LogicalType>()}) {
+    return "l" + std::to_string(logical.getFKind());
+  } else if (auto character{t.dyn_cast<fir::CharacterType>()}) {
+    return "c" + std::to_string(character.getFKind());
+  } else {
+    assert(false && "no mangling for type");
+    return ""s;
+  }
+}
 static std::string getIntrinsicWrapperName(
     const llvm::StringRef &intrinsic, mlir::FunctionType funTy) {
-  // TODO find nicer type to string infra or move this in a mangling utility
-  auto addSuffix{[&](const llvm::Twine &suffix) -> std::string {
-    return ("fir." + intrinsic + suffix).str();
-  }};
+  std::string name{"fir." + intrinsic.str() + "."};
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
-  mlir::Type resultType{funTy.getResult(0)};
-  if (auto f{resultType.dyn_cast<mlir::FloatType>()}) {
-    return addSuffix(".f" + llvm::Twine(f.getWidth()));
-  } else if (auto i{resultType.dyn_cast<mlir::IntegerType>()}) {
-    return addSuffix(".i" + llvm::Twine(i.getWidth()));
-  } else if (auto cplx{resultType.dyn_cast<fir::CplxType>()}) {
-    return addSuffix(".c" + llvm::Twine(cplx.getFKind()));
-  } else if (auto real{resultType.dyn_cast<fir::RealType>()}) {
-    return addSuffix(".r" + llvm::Twine(real.getFKind()));
-  } else {
-    assert(false);
-    return addSuffix(".unknown");
+  name += typeToString(funTy.getResult(0));
+  for (std::size_t i{0}; i < funTy.getNumInputs(); ++i) {
+    name += "." + typeToString(funTy.getInput(i));
   }
+  return name;
 }
 
 mlir::Value *IntrinsicLibrary::Implementation::outlineInWrapper(
diff --git a/test/burnside/expr-test-generator.cc b/test/burnside/expr-test-generator.cc
new file mode 100644
index 000000000000..96e6fad39298
--- /dev/null
+++ b/test/burnside/expr-test-generator.cc
@@ -0,0 +1,689 @@
+// Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <optional>
+#include <sstream>
+#include <vector>
+
+// Utility to generate Fortran expression evaluation tests.
+// Given an expression "x op y", this utility can generates
+// functions that evaluate the expression and takes x and y
+// as argument and return the result.
+// The utility allows to describe fortran intrinsic operations
+// and their possible operand types in a table driven way.
+// Functions to test all possible intrinsic operations can then be
+// generated.
+// The utility can also generate a driver function that calls the
+// previous and compare the results with expectations
+// (currently provided by calling a similar function compiled by a reference
+// compiler).
+
+// TODO: Integrate with f18 libs to remove redundancies ?
+// TODO: How could Peter's intrinsic table be used to generate
+//       intrinsic expression tests in a similar way ?
+
+enum class TypeCategory { Integer, Real, Complex, Logical, Character };
+
+struct Type {
+  constexpr Type(TypeCategory c) : cat{c}, kind{} {}
+  constexpr Type(TypeCategory c, int k) : cat{c}, kind{k} {}
+  bool operator==(const Type &that) const {
+    return cat == that.cat && kind == that.kind;
+  }
+  bool operator!=(const Type &that) const { return !(*this == that); }
+  std::ostream &Dump(std::ostream &s) const {
+    switch (cat) {
+    case TypeCategory::Integer: s << "INTEGER"; break;
+    case TypeCategory::Real: s << "REAL"; break;
+    case TypeCategory::Logical: s << "LOGICAL"; break;
+    case TypeCategory::Complex: s << "COMPLEX"; break;
+    case TypeCategory::Character: s << "CHARACTER"; break;
+    }
+    if (kind) {
+      s << "(" << *kind << ")";
+    }
+    return s;
+  }
+
+  TypeCategory cat;
+  std::optional<int> kind;  // none = default
+};
+
+static constexpr Type DefaultReal{TypeCategory::Real};
+static constexpr Type Real4{TypeCategory::Real, 4};
+static constexpr Type Real8{TypeCategory::Real, 8};
+static constexpr Type DefaultInteger{TypeCategory::Integer};
+static constexpr Type Integer1{TypeCategory::Integer, 1};
+static constexpr Type Integer2{TypeCategory::Integer, 2};
+static constexpr Type Integer4{TypeCategory::Integer, 4};
+static constexpr Type Integer8{TypeCategory::Integer, 8};
+static constexpr Type DefaultComplex{TypeCategory::Complex};
+static constexpr Type Complex4{TypeCategory::Complex, 4};
+static constexpr Type Complex8{TypeCategory::Complex, 4};
+static constexpr Type DefaultLogical{TypeCategory::Logical};
+// Currently other types are not testable because existing Fortran
+// compilers do not provide these types.
+
+enum class TypePattern {
+  OperandNumeric,
+  OperandLogical,
+  OperandComparable,
+  OperandOrdered
+};
+enum class Constraint { None, NonZeroRHS, NoNegativeLHSWhenRealRHS };
+
+struct Operation {
+  bool IsUnaryOp() const { return isUnaryOp; }
+  std::optional<Type> GetResultTypeForArguments(Type, Type) const;
+  std::optional<Type> GetResultTypeForArgument(Type) const;
+  const char *name;
+  const char *symbol;
+  TypePattern pattern;
+  Constraint constraint{Constraint::None};
+  bool isUnaryOp{false};
+};
+
+// Sorted by increasing precedence (not stricly increasing). See F2018
+// table 10.1.
+static Operation operations[]{
+    // TODO should be OK constexpr but g++ 8.2 not happy
+    // defined-binary-op cannot be described here.
+    {"eqv", ".EQV.", TypePattern::OperandLogical},
+    {"neqv", ".NEQV.", TypePattern::OperandLogical},
+    {"or", ".OR.", TypePattern::OperandLogical},
+    {"and", ".AND.", TypePattern::OperandLogical},
+    {"not", ".NOT.", TypePattern::OperandLogical, Constraint::None, true},
+    {"eq", ".EQ.", TypePattern::OperandComparable},
+    {"ne", ".NE.", TypePattern::OperandComparable},
+    {"lt", ".LT.", TypePattern::OperandOrdered},
+    {"le", ".LE.", TypePattern::OperandOrdered},
+    {"gt", ".GT.", TypePattern::OperandOrdered},
+    {"ge", ".GE.", TypePattern::OperandOrdered},
+    // TODO: Concat
+    {"add", "+", TypePattern::OperandNumeric},
+    {"sub", "-", TypePattern::OperandNumeric},
+    {"minus", "-", TypePattern::OperandNumeric, Constraint::None, true},
+    {"plus", "+", TypePattern::OperandNumeric, Constraint::None, true},
+    {"mult", "*", TypePattern::OperandNumeric},
+    {"div", "/", TypePattern::OperandNumeric, Constraint::NonZeroRHS},
+    {"power", "**", TypePattern::OperandNumeric,
+        Constraint::NoNegativeLHSWhenRealRHS},  // TODO: check power pattern
+    // defined-unary-op cannot be described here.
+};
+
+static bool IsLogical(const Type t) { return t.cat == TypeCategory::Logical; }
+static bool IsCharacter(const Type t) {
+  return t.cat == TypeCategory::Character;
+}
+static bool IsComplex(const Type t) { return t.cat == TypeCategory::Complex; }
+static bool IsReal(const Type t) { return t.cat == TypeCategory::Real; }
+
+static bool IsOrderedNumeric(const Type t) {
+  return t.cat == TypeCategory::Real || t.cat == TypeCategory::Integer;
+}
+
+static bool IsNumeric(const Type t) {
+  return t.cat == TypeCategory::Real || t.cat == TypeCategory::Integer ||
+      t.cat == TypeCategory::Complex;
+}
+
+std::optional<Type> Operation::GetResultTypeForArgument(Type t) const {
+  switch (pattern) {
+  case TypePattern::OperandNumeric:
+    if (IsNumeric(t)) {
+      return t;
+    }
+    break;
+  case TypePattern::OperandLogical:
+    if (IsLogical(t)) {
+      return t;
+    }
+    break;
+  case TypePattern::OperandComparable:
+  case TypePattern::OperandOrdered:
+    assert(false && "No unary comparisons");
+    break;
+  }
+  return std::nullopt;
+}
+
+static std::optional<Type> SelectBiggestKindForResult(
+    TypeCategory resultCat, Type lhs, Type rhs) {
+  if (!lhs.kind && !rhs.kind) {
+    return Type{resultCat};
+  } else if (lhs.kind && rhs.kind) {
+    return Type{resultCat, std::max(*lhs.kind, *rhs.kind)};
+  } else {
+    // Cannot know without more info about compiler what default compares to.
+    return std::nullopt;
+  }
+}
+
+std::optional<Type> Operation::GetResultTypeForArguments(
+    Type lhs, Type rhs) const {
+  // See Fortran 2018 table 10.2 and section 10.1.9.3
+  switch (pattern) {
+  case TypePattern::OperandNumeric:
+    if (!IsNumeric(rhs) || !IsNumeric(lhs)) {
+      return std::nullopt;
+    }
+    if (lhs.cat == rhs.cat) {
+      return SelectBiggestKindForResult(lhs.cat, lhs, rhs);
+    }
+    // different categories
+    if (IsComplex(lhs)) {
+      if (IsReal(rhs)) {
+        return SelectBiggestKindForResult(TypeCategory::Complex, lhs, rhs);
+      }
+      return lhs;
+    }
+    if (IsComplex(rhs)) {
+      if (IsReal(lhs)) {
+        return SelectBiggestKindForResult(TypeCategory::Complex, lhs, rhs);
+      }
+      return rhs;
+    }
+    if (IsReal(lhs)) {
+      // rhs must be integer
+      return lhs;
+    }
+    if (IsReal(rhs)) {
+      // lhs must be integer
+      return rhs;
+    }
+    assert(false && "no more operand cases");
+  case TypePattern::OperandLogical:
+    if (IsLogical(rhs) && IsLogical(lhs)) {
+      return SelectBiggestKindForResult(TypeCategory::Logical, lhs, rhs);
+    }
+    break;
+  case TypePattern::OperandComparable:
+    if (IsNumeric(lhs) && IsNumeric(rhs)) {
+      return DefaultLogical;
+    } else if (IsCharacter(lhs) && IsCharacter(lhs) && lhs.kind == rhs.kind) {
+      return DefaultLogical;
+    }
+    break;
+  case TypePattern::OperandOrdered:
+    if (IsOrderedNumeric(lhs) && IsOrderedNumeric(rhs)) {
+      return DefaultLogical;
+    } else if (IsCharacter(lhs) && IsCharacter(lhs) && lhs.kind == rhs.kind) {
+      return DefaultLogical;
+    }
+    break;
+  }
+  return std::nullopt;
+}
+
+// Test Plan Part
+
+// Only string list input for now
+using Input = std::vector<const char *>;
+// TODO: more inputs method (e.g. random pick)
+
+enum class Eval { Constant, Dynamic };
+struct TestPlan {
+  std::vector<const char *> operationToTests;
+  std::vector<std::pair<Type, Input>> inputs;
+  Eval referenceEvaluationMethod{Eval::Dynamic};
+  Eval testEvaluationMethod{Eval::Dynamic};
+};
+
+static inline std::string IndexedName(const char *name, std::size_t index) {
+  return std::string{name} + std::to_string(index);
+}
+
+static constexpr auto passedName{"passed"};
+static constexpr auto failedName{"failed"};
+
+struct CodeGenerator {
+  static constexpr auto varNameBase{"x"};
+  static constexpr auto paramNameBase{"a"};
+  static constexpr auto loopIndexNameBase{"i"};
+  static constexpr auto testResultName{"test_res"};
+  static constexpr auto refResultName{"ref_res"};
+
+  template<Eval Ev>
+  void GenerateEvaluationFunction(
+      const std::string &functionName, std::ostream &s) const {
+    GenerateEvaluationFunctionStmtAndSpec<Ev>(functionName, s);
+    GenerateExpressionEvaluation<Ev>(functionName, s);
+    s << "END FUNCTION" << std::endl;
+    s << std::endl;
+  }
+
+  void GenerateEvaluationFunction(const std::string &functionNameBase,
+      std::ostream &s, Eval ev, bool isReference) const {
+    auto functionName{isReference ? GetReferenceFunctionName(functionNameBase)
+                                  : GetTestFunctionName(functionNameBase)};
+    switch (ev) {
+    case Eval::Constant:
+      GenerateEvaluationFunction<Eval::Constant>(functionName, s);
+      break;
+    case Eval::Dynamic:
+      GenerateEvaluationFunction<Eval::Dynamic>(functionName, s);
+      break;
+    }
+  }
+
+  void GenerateDriverSubroutine(const std::string &functionNameBase,
+      std::ostream &s, Eval refEval, Eval testEval) const {
+    s << "SUBROUTINE " << GetDriverName(functionNameBase) << "(" << passedName
+      << ", " << failedName << ")" << std::endl;
+    std::size_t numInputs{inputs.size()};
+    assert(numInputs > 0 && "Expected non empty inputs in driver");
+    if (refEval == Eval::Dynamic || testEval == Eval::Dynamic) {
+      // Inputs are required inside the driver only if one evaluation function
+      // is dynamic and inputs need to be passed to it from the driver.
+      for (std::size_t i{0}; i < numInputs; ++i) {
+        GenerateInputAsArrayParameter(i, s);
+      }
+    }
+    s << "INTEGER :: " << passedName << ", " << failedName << std::endl;
+    resultType.Dump(s) << " :: " << testResultName << ", " << refResultName
+                       << std::endl;
+
+    // TODO: Add a test number limit in cases there are many inputs ? This would
+    // need to be kept in sync with folding evaluation.
+    for (std::size_t i{0}; i < numInputs; ++i) {
+      s << "DO " << IndexedName(loopIndexNameBase, i) << " = 1,"
+        << inputs[i]->second.size() << std::endl;
+    }
+
+    // TODO: Handle constraints (e.g divide by zero). Would also need to be kept
+    // in sync with folding evaluation.
+    s << refResultName << " = ";
+    auto refFuncName{GetReferenceFunctionName(functionNameBase)};
+    switch (refEval) {
+    case Eval::Dynamic:
+      GenerateEvaluationFunctionCall<Eval::Dynamic>(refFuncName, s);
+      break;
+    case Eval::Constant:
+      GenerateEvaluationFunctionCall<Eval::Constant>(refFuncName, s);
+      break;
+    }
+    s << testResultName << " = ";
+    auto testFuncName{GetTestFunctionName(functionNameBase)};
+    switch (testEval) {
+    case Eval::Dynamic:
+      GenerateEvaluationFunctionCall<Eval::Dynamic>(testFuncName, s);
+      break;
+    case Eval::Constant:
+      GenerateEvaluationFunctionCall<Eval::Constant>(testFuncName, s);
+      break;
+    }
+
+    s << "IF (";
+    GenerateResultsComparison(s);
+    s << ") THEN" << std::endl;
+    s << passedName << " = " << passedName << " + 1" << std::endl;
+    s << "ELSE" << std::endl;
+    s << failedName << " = " << failedName << " + 1" << std::endl;
+    GenerateFailureMessage(functionNameBase, s);
+    s << "END IF" << std::endl;
+
+    for (std::size_t i{0}; i < numInputs; ++i) {
+      s << "END DO" << std::endl;
+    }
+    s << "END SUBROUTINE" << std::endl;
+    s << std::endl;
+  }
+
+  template<Eval Ev>
+  void GenerateEvaluationFunctionCall(
+      const std::string &functionName, std::ostream &s) const {
+    s << functionName << "(";
+    if constexpr (Ev == Eval::Dynamic) {
+      ApplyOnInputIndexes(
+          [&](std::size_t i) {
+            return GetArrayElement(paramNameBase, loopIndexNameBase, i);
+          },
+          ", ", s);
+    } else {
+      static_assert(Ev == Eval::Constant, "unhandled evaluation method");
+      ApplyOnInputIndexes(
+          [&](std::size_t i) { return IndexedName(loopIndexNameBase, i); },
+          ", ", s);
+    }
+    s << ")" << std::endl;
+  }
+
+  void GenerateFailureMessage(
+      const std::string &functionNameBase, std::ostream &s) const {
+    s << "PRINT *, \"FAILED " << functionNameBase << " test: \"";
+    for (std::size_t i{0}; i < inputs.size(); ++i) {
+      auto loopId{IndexedName(loopIndexNameBase, i)};
+      s << ", \"" << loopId << " = \", " << loopId;
+    }
+    s << std::endl;
+    s << "PRINT *, \"  expected \", " << refResultName << ", \" got: \","
+      << testResultName << std::endl;
+  }
+
+  void GenerateInputAsArrayParameter(std::size_t i, std::ostream &s) const {
+    const auto &literals{inputs[i]->second};
+    const auto size{literals.size()};
+    assert(size > 0 && "No actual literal input for test");
+    inputs[i]->first.Dump(s)
+        << ", PARAMETER :: " << IndexedName(paramNameBase, i) << "(" << size
+        << ") = [";
+    s << literals[0];
+    for (std::size_t i{1}; i < size; ++i) {
+      s << ", " << literals[i];
+    }
+    s << "]" << std::endl;
+  }
+
+  void GenerateDriverCall(
+      const std::string &functionNameBase, std::ostream &s) const {
+    s << "CALL " << GetDriverName(functionNameBase) << "(" << passedName << ", "
+      << failedName << ")" << std::endl;
+  }
+
+  template<Eval Ev>
+  void GenerateEvaluationFunctionStmtAndSpec(
+      const std::string &functionName, std::ostream &s) const {
+    resultType.Dump(s) << " FUNCTION " << functionName << "(";
+    assert(inputs.size() && "expect at least on argument");
+    const auto &name{Ev == Eval::Constant ? loopIndexNameBase : varNameBase};
+    s << IndexedName(name, 0);
+    for (std::size_t i{1}; i < inputs.size(); ++i) {
+      s << ", " << IndexedName(name, i);
+    }
+    s << ")" << std::endl;
+    std::size_t i{0};
+    if constexpr (Ev == Eval::Constant) {
+      for (const auto *input : inputs) {
+        s << "INTEGER :: " << IndexedName(name, i++) << std::endl;
+      }
+    } else {
+      for (const auto *input : inputs) {
+        input->first.Dump(s) << " :: " << IndexedName(name, i++) << std::endl;
+      }
+    }
+  }
+
+  template<Eval Ev>
+  void GenerateExpressionEvaluation(
+      const std::string &resultName, std::ostream &s) const {
+    if constexpr (Ev == Eval::Constant) {
+      GenerateConstantExpressionEvaluation(resultName, s);
+    } else {
+      static_assert(
+          Ev == Eval::Dynamic, "unhandled expression evaluation method");
+      s << resultName << " = ";
+      GenerateExpression(
+          [&](std::size_t i) { return IndexedName(varNameBase, i); }, s);
+      s << std::endl;
+    }
+  }
+
+  void GenerateConstantExpressionEvaluation(
+      const std::string &resultName, std::ostream &s) const {
+    // Declare constant inputs
+    for (std::size_t i{0}; i < inputs.size(); ++i) {
+      GenerateInputAsArrayParameter(i, s);
+    }
+    // Evaluate in a parameter array using ac-implied-do
+    auto cstResultName{IndexedName(paramNameBase, inputs.size())};
+    assert(inputs.size() > 0 && "expected at least one operands");
+    resultType.Dump(s) << " , PARAMETER :: " << cstResultName << "(*";
+    for (std::size_t i{1}; i < inputs.size(); ++i) {
+      s << ", *";
+    }
+    s << ") = RESHAPE ([(";
+    for (std::size_t i{1}; i < inputs.size(); ++i) {
+      s << "(";
+    }
+
+    // Expression evaluation inside ac-implied-do
+    // TODO: how to handle constraints ?
+    GenerateExpression(
+        [&](std::size_t i) {
+          return GetArrayElement(paramNameBase, loopIndexNameBase, i);
+        },
+        s);
+
+    // ac-implied-do (opening ")" were emited before).
+    s << ", ";
+    ApplyOnInputIndexes(
+        [&](std::size_t i) {
+          return IndexedName(loopIndexNameBase, i) + " = 1," +
+              std::to_string(inputs[i]->second.size()) + ")";
+        },
+        ",", s);
+
+    // RESHAPE SHAPE argument
+    s << "], [";
+    ApplyOnInputIndexes(
+        [&](std::size_t i) { return inputs[i]->second.size(); }, ",", s);
+    s << "])" << std::endl;
+
+    // dynamically fetch requested result from the constant array
+    s << resultName << " = " << cstResultName << "(";
+    ApplyOnInputIndexes(
+        [&](std::size_t i) { return IndexedName(loopIndexNameBase, i); }, ",",
+        s);
+    s << ")" << std::endl;
+  }
+
+  template<typename T>
+  void inline ApplyOnInputIndexes(
+      const T &callable, const std::string &sep, std::ostream &s) const {
+    auto size{inputs.size()};
+    if (size != 0) {
+      s << callable(0);
+    }
+    for (std::size_t i{1}; i < size; ++i) {
+      s << ", " << callable(i);
+    }
+  }
+
+  template<typename T>
+  void inline GenerateExpression(
+      const T &operandGenerator, std::ostream &s) const {
+    if (inputs.size() == 1) {
+      s << op.symbol << " " << operandGenerator(0);
+    } else {
+      assert(inputs.size() == 2 && "expected binary opreation");
+      s << operandGenerator(0) << " " << op.symbol << " "
+        << operandGenerator(1);
+    }
+  }
+
+  void GenerateEvaluationFunctionInterface(const std::string &functionNameBase,
+      std::ostream &s, Eval ev, bool isReference) const {
+    auto functionName{isReference ? GetReferenceFunctionName(functionNameBase)
+                                  : GetTestFunctionName(functionNameBase)};
+    switch (ev) {
+    case Eval::Constant:
+      GenerateEvaluationFunctionStmtAndSpec<Eval::Constant>(functionName, s);
+      break;
+    case Eval::Dynamic:
+      GenerateEvaluationFunctionStmtAndSpec<Eval::Dynamic>(functionName, s);
+      break;
+    }
+    s << "END FUNCTION" << std::endl;
+  }
+
+  void GenerateResultsComparison(std::ostream &s) const {
+    const auto *compareOp{
+        resultType.cat == TypeCategory::Logical ? ".EQV." : ".EQ."};
+    if (resultType.cat == TypeCategory::Real) {
+      // TODO: This should not always be an absolute comparison (epsilon margin
+      // for fp.). Complex needs similar checks.
+      s << refResultName << compareOp << testResultName << " .OR. ";
+      s << "(IEEE_IS_NAN(" << refResultName << ") .AND. IEEE_IS_NAN("
+        << testResultName << "))";
+    } else {
+      s << refResultName << compareOp << testResultName;
+    }
+  }
+
+  // a0(i0) and such
+  static std::string GetArrayElement(
+      const char *arrayNameBase, const char *indexNameBase, std::size_t i) {
+    return IndexedName(arrayNameBase, i) + "(" + IndexedName(indexNameBase, i) +
+        ")";
+  }
+
+  static std::string GetTestFunctionName(const std::string &functionNameBase) {
+    return functionNameBase + "_test";
+  }
+  static std::string GetReferenceFunctionName(
+      const std::string &functionNameBase) {
+    return functionNameBase + "_ref";
+  }
+  static std::string GetDriverName(const std::string &functionNameBase) {
+    return functionNameBase + "_driver";
+  }
+  Type resultType;
+  const Operation &op;
+  std::vector<const std::pair<Type, Input> *> inputs;
+};
+
+// Test Generator
+struct TestGenerator {
+
+  void GenerateTests(std::ostream &testFile, std::ostream &refFile) {
+    std::stringstream testContentStream;
+    std::stringstream testInterfaceStream;
+    std::stringstream referenceAndDriverContentStream;
+    std::stringstream programContentStream;
+    auto generateInBuffers{
+        [&](const CodeGenerator &codeGen, const std::string &functionNameBase) {
+          codeGen.GenerateEvaluationFunction(functionNameBase,
+              testContentStream, plan.testEvaluationMethod, false);
+          codeGen.GenerateEvaluationFunctionInterface(functionNameBase,
+              testInterfaceStream, plan.testEvaluationMethod, false);
+          codeGen.GenerateEvaluationFunction(functionNameBase,
+              referenceAndDriverContentStream, plan.referenceEvaluationMethod,
+              true);
+          codeGen.GenerateDriverSubroutine(functionNameBase,
+              referenceAndDriverContentStream, plan.referenceEvaluationMethod,
+              plan.testEvaluationMethod);
+          codeGen.GenerateDriverCall(functionNameBase, programContentStream);
+        }};
+
+    for (const auto *opName : plan.operationToTests) {
+      const auto *op{GetOperation(opName)};
+      assert(op && "Broken test plan: undefined operation");
+      for (const auto &input1 : plan.inputs) {
+        if (op->IsUnaryOp()) {
+          if (auto resultType{op->GetResultTypeForArgument(input1.first)}) {
+            CodeGenerator codeGen{*resultType, *op, {&input1}};
+            auto functionNameBase{GetDistinctFunctionNameBase(*op)};
+            generateInBuffers(codeGen, functionNameBase);
+          }
+        } else {
+          for (const auto &input2 : plan.inputs) {
+            if (auto resultType{op->GetResultTypeForArguments(
+                    input1.first, input2.first)}) {
+              CodeGenerator codeGen{*resultType, *op, {&input1, &input2}};
+              auto functionNameBase{GetDistinctFunctionNameBase(*op)};
+              generateInBuffers(codeGen, functionNameBase);
+            }
+          }
+        }
+      }
+    }
+
+    // Organize generated code
+    testFile << "! Generated test file" << std::endl;
+    testFile << testContentStream.rdbuf();
+    testFile << "! End of generated test file" << std::endl;
+
+    refFile << "! Generated reference and driver " << std::endl;
+    refFile << "MODULE REFERENCE_AND_DRIVER" << std::endl;
+    refFile << "USE IEEE_ARITHMETIC" << std::endl;  // for IEEE_IS_NAN
+    refFile << "INTERFACE" << std::endl;
+    refFile << testInterfaceStream.rdbuf();
+    refFile << "END INTERFACE" << std::endl;
+    refFile << std::endl;
+    refFile << "CONTAINS" << std::endl;
+    refFile << referenceAndDriverContentStream.rdbuf();
+    refFile << "END MODULE" << std::endl;
+    refFile << std::endl;
+    refFile << "PROGRAM EXPR_TEST" << std::endl;
+    refFile << "USE REFERENCE_AND_DRIVER" << std::endl;
+    refFile << "INTEGER :: " << passedName << ", " << failedName << std::endl;
+    refFile << passedName << " = 0 " << std::endl;
+    refFile << failedName << " = 0 " << std::endl;
+    refFile << programContentStream.rdbuf();
+    refFile << "PRINT *, \"Passed: \"," << passedName << ", \" Failed: \", "
+            << failedName << std::endl;
+    refFile << "IF (" << failedName << ".GT. 0) ERROR STOP 1" << std::endl;
+    refFile << "END PROGRAM" << std::endl;
+    refFile << "! End of generated reference and driver" << std::endl;
+  }
+
+  const Operation *GetOperation(const char *name) {
+    assert(name && "nullptr string for test name");
+    for (const auto &op : operations) {
+      assert(op.name && "Broken operation");
+      if (std::strcmp(name, op.name) == 0) {
+        return &op;
+      }
+    }
+    return nullptr;
+  }
+
+  std::string GetDistinctFunctionNameBase(const Operation &op) {
+    return IndexedName(op.name, funcId++);
+  }
+
+  TestPlan plan;
+  std::size_t funcId{0};
+};
+
+// Test driver
+int main(int argc, char **argv) {
+  Eval testEvalMethod{Eval::Dynamic};
+  Eval refEvalMethod{Eval::Dynamic};
+  int planId{0};
+  for (int i{0}; i < argc; ++i) {
+    if (std::strcmp(argv[i], "test=folding") == 0) {
+      testEvalMethod = Eval::Constant;
+    } else if (std::strcmp(argv[i], "ref=folding") == 0) {
+      refEvalMethod = Eval::Constant;
+    }
+  }
+
+  TestGenerator{
+      {
+          {"eqv", "neqv", "or", "and", "not", "eq", "ne", "lt", "le", "gt",
+              "ge", "add", "sub", "minus", "plus", "mult", "div", "power"},
+          {
+              {Integer1, {"-1_1", "12_1", "2_1"}},
+              {Integer2, {"-1_2", "12500_2", "2_2"}},
+              {Integer4, {"31000_4", "-64354_4"}},
+              {Integer8, {"3000001_8", "-2654637545_8"}},
+              {Real4, {"1.03687448_4", "3.1254641_4"}},
+              {Real8, {"1.036874168446448_8", "3.12254533554641_8"}},
+              // TODO: fix expression analysis bug with REAL(8)**COMPLEX(4)
+              //   {Complex4, {"(-0.5_4,10.35544_4)", "(-5._4, 0.15647_4)"}},
+              //   {Complex8,
+              //    {"(-0.5_8,10.35546579874_8)",
+              //     "(-5.64654654_8, 0.155876974647_8)"}},
+              {DefaultLogical, {".false.", ".true."}},
+          },
+          refEvalMethod,
+          testEvalMethod,
+      }}
+      .GenerateTests(std::cout, std::cerr);
+}
diff --git a/test/burnside/test_expression_lowering.sh b/test/burnside/test_expression_lowering.sh
new file mode 100755
index 000000000000..f6389b6d3bde
--- /dev/null
+++ b/test/burnside/test_expression_lowering.sh
@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Test Fortran expression lowering by driving compilations
+# and executions of programs generated by expr-test-generation.cc
+#   usage: cmd llvm_build_directory
+
+LLVM=$1
+BBC=$LLVM/bin/bbc
+LLC=$LLVM/bin/llc
+CPP=g++
+FCC=pgfortran # So far, only works with pgfortran because of pgmath linking.
+FCC_OPTIONS="-Kieee" # That is required because bit to bit compare so far.
+SRC=$PWD/expr-test-generator.cc
+
+function die {
+  echo "$(basename $0): $*" >&2
+  exit 1
+}
+
+temp=`mktemp -d ./tmp.XXXXXX`
+cd $temp
+[[ $KEEP ]] || trap "cd .. && rm -rf $temp" EXIT
+
+testGen=./genTests
+testFile=test.f90
+driverFile=driver.f90
+bbcLog=bbc.log
+assembly=a.s
+testObject=test.o
+testExec=./test_exec
+testLog=test.log
+
+$CPP $SRC -std=c++17 -o $testGen
+[[ $? -ne 0 ]] && die "test generator compilation failure"
+$testGen 1>$testFile 2>$driverFile
+[[ $? -ne 0 ]] && die "test generation failure"
+$BBC $testFile 2>$bbcLog
+[[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
+$LLC a.ll -o $assembly
+[[ $? -ne 0 ]] && die "llc failed compiling bbc output"
+as $assembly -o $testObject
+[[ $? -ne 0 ]] && die "as failed compiling llc output"
+$FCC $testObject $driverFile -o $testExec $FCC_OPTIONS
+[[ $? -ne 0 ]] && die "driver.f90 compilation/linking failure"
+$testExec > $testLog
+result=$?
+cat $testLog
+if [ $result -ne 0 ]; then
+  echo "FAIL"
+else
+  echo "PASS"
+fi

From faba5771fedf214e8a24bdfa7a708b7905d09688 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 6 Dec 2019 11:43:07 -0800
Subject: [PATCH 132/345] fix array ref

---
 lib/burnside/bridge.cc       | 404 +++--------------------------------
 lib/burnside/cfg-builder.h   | 348 ++++++++++++++++++++++++++++++
 lib/burnside/convert-expr.cc |  28 +--
 3 files changed, 389 insertions(+), 391 deletions(-)
 create mode 100644 lib/burnside/cfg-builder.h

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index bcd1a73690d7..32ec0f89bf9c 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -65,351 +65,8 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
   return std::get<Pa::StopStmt::Kind>(stm.t) == Pa::StopStmt::Kind::Stop;
 }
 
-/// Traverse the AST and complete the CFG by drawing the arcs, pruning unused
-/// potential targets, making implied jumps explicit, etc.
-class CfgBuilder {
-
-  AST::Evaluation *getEvalByLabel(const Pa::Label &label) {
-    auto iter = labels.find(label);
-    if (iter != labels.end()) {
-      return iter->second;
-    }
-    return nullptr;
-  }
-
-  /// Collect all the potential targets and initialize them to unreferenced
-  void resetPotentialTargets(std::list<AST::Evaluation> &evals) {
-    for (auto &e : evals) {
-      if (e.isTarget) {
-        e.isTarget = false;
-      }
-      if (e.lab.has_value()) {
-        labels.try_emplace(*e.lab, &e);
-      }
-      if (e.subs) {
-        resetPotentialTargets(*e.subs);
-      }
-    }
-  }
-
-  /// cache ASSIGN statements that may yield a live branch target
-  void cacheAssigns(std::list<AST::Evaluation> &evals) {
-    for (auto &e : evals) {
-      std::visit(Co::visitors{
-                     [&](const Pa::AssignStmt *stmt) {
-                       auto *trg = getEvalByLabel(std::get<Pa::Label>(stmt->t));
-                       auto *sym = std::get<Pa::Name>(stmt->t).symbol;
-                       assert(sym);
-                       auto jter = assignedGotoMap.find(sym);
-                       if (jter == assignedGotoMap.end()) {
-                         std::list<AST::Evaluation *> lst = {trg};
-                         assignedGotoMap.try_emplace(sym, lst);
-                       } else {
-                         jter->second.emplace_back(trg);
-                       }
-                     },
-                     [](auto) { /* do nothing */ },
-                 },
-          e.u);
-      if (e.subs) {
-        cacheAssigns(*e.subs);
-      }
-    }
-  }
-
-  void deannotate(std::list<AST::Evaluation> &evals) {
-    for (auto &e : evals) {
-      e.cfg = AST::CFGAnnotation::None;
-      if (e.subs) {
-        deannotate(*e.subs);
-      }
-    }
-  }
-
-  bool structuredLoop(const std::optional<Pa::LoopControl> &optLoopCtrl) {
-    if (optLoopCtrl.has_value())
-      return std::visit(
-          Co::visitors{
-              [](const Pa::LoopControl::Bounds &) { return true; },
-              [](const Pa::ScalarLogicalExpr &) { return false; },
-              [](const Pa::LoopControl::Concurrent &) { return true; },
-          },
-          optLoopCtrl->u);
-    return false;
-  }
-
-  bool structuredCheck(std::list<AST::Evaluation> &evals) {
-    for (auto &e : evals) {
-      if (auto **s = std::get_if<const Pa::DoConstruct *>(&e.u)) {
-        if (!structuredLoop(std::get<std::optional<Pa::LoopControl>>(
-                std::get<Pa::Statement<Pa::NonLabelDoStmt>>((*s)->t)
-                    .statement.t)))
-          return false;
-        return structuredCheck(*e.subs);
-      }
-      if (std::holds_alternative<const Pa::IfConstruct *>(e.u)) {
-        return structuredCheck(*e.subs);
-      }
-      if (e.subs) {
-        return false;
-      }
-      switch (e.cfg) {
-      case AST::CFGAnnotation::None: break;
-      case AST::CFGAnnotation::CondGoto: break;
-      case AST::CFGAnnotation::Iterative: break;
-      case AST::CFGAnnotation::FirStructuredOp: break;
-      case AST::CFGAnnotation::IndGoto: return false;
-      case AST::CFGAnnotation::IoSwitch: return false;
-      case AST::CFGAnnotation::Switch: return false;
-      case AST::CFGAnnotation::Return: return false;
-      case AST::CFGAnnotation::Terminate: return false;
-      case AST::CFGAnnotation::Goto:
-        if (!std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
-          return false;
-        }
-        break;
-      }
-    }
-    return true;
-  }
-
-  void wrapIterationSpaces(std::list<AST::Evaluation> &evals) {
-    for (auto &e : evals) {
-      if (std::holds_alternative<const Pa::DoConstruct *>(e.u))
-        if (structuredCheck(*e.subs)) {
-          deannotate(*e.subs);
-          e.cfg = AST::CFGAnnotation::FirStructuredOp;
-          continue;
-        }
-      if (std::holds_alternative<const Pa::IfConstruct *>(e.u))
-        if (structuredCheck(*e.subs)) {
-          deannotate(*e.subs);
-          e.cfg = AST::CFGAnnotation::FirStructuredOp;
-          continue;
-        }
-      // FIXME: ForallConstruct? WhereConstruct?
-      if (e.subs) {
-        wrapIterationSpaces(*e.subs);
-      }
-    }
-  }
-
-  /// Add source->sink edge to CFG map
-  void addSourceToSink(AST::Evaluation *src, AST::Evaluation *snk) {
-    auto iter = cfgMap.find(src);
-    if (iter == cfgMap.end()) {
-      CFGSinkListType sink{snk};
-      cfgEdgeSetPool.emplace_back(std::move(sink));
-      auto rc{cfgMap.try_emplace(src, &cfgEdgeSetPool.back())};
-      assert(rc.second && "insert failed unexpectedly");
-      (void)rc;  // for release build
-      return;
-    }
-    for (auto *s : *iter->second)
-      if (s == snk) {
-        return;
-      }
-    iter->second->push_back(snk);
-  }
-
-  void addSourceToSink(AST::Evaluation *src, const Pa::Label &label) {
-    auto iter = labels.find(label);
-    assert(iter != labels.end());
-    addSourceToSink(src, iter->second);
-  }
-
-  /// Find the next ELSE IF, ELSE or END IF statement in the list
-  template<typename A> A nextFalseTarget(A iter, const A &endi) {
-    for (; iter != endi; ++iter)
-      if (std::visit(Co::visitors{
-                         [&](const Pa::ElseIfStmt *) { return true; },
-                         [&](const Pa::ElseStmt *) { return true; },
-                         [&](const Pa::EndIfStmt *) { return true; },
-                         [](auto) { return false; },
-                     },
-              iter->u)) {
-        break;
-      }
-    return iter;
-  }
-
-  /// Add branches for this IF block like construct.
-  /// Branch to the "true block", the "false block", and from the end of the
-  /// true block to the end of the construct.
-  template<typename A>
-  void doNextIfBlock(std::list<AST::Evaluation> &evals, AST::Evaluation &e,
-      const A &iter, const A &endif) {
-    A i{iter};
-    A j{nextFalseTarget(++i, endif)};
-    auto *cstr = std::get<AST::Evaluation *>(e.parent);
-    AST::CGJump jump{&*endif};
-    A k{evals.insert(j, AST::Evaluation{std::move(jump), j->parent})};
-    if (i == j) {
-      // block was empty, so adjust "true" target
-      i = k;
-    }
-    addSourceToSink(&*k, cstr);
-    addSourceToSink(&e, &*i);
-    addSourceToSink(&e, &*j);
-  }
-
-  /// Determine which branch targets are reachable. The target map must
-  /// already be initialized.
-  void reachabilityAnalysis(std::list<AST::Evaluation> &evals) {
-    for (auto iter = evals.begin(); iter != evals.end(); ++iter) {
-      auto &e = *iter;
-      switch (e.cfg) {
-      case AST::CFGAnnotation::None:
-        // do nothing - does not impart control flow
-        break;
-      case AST::CFGAnnotation::Goto:
-        std::visit(
-            Co::visitors{
-                [&](const Pa::CycleStmt *) {
-                  // FIXME: deal with construct name
-                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
-                  addSourceToSink(&e, &cstr->subs->front());
-                },
-                [&](const Pa::ExitStmt *) {
-                  // FIXME: deal with construct name
-                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
-                  addSourceToSink(&e, &cstr->subs->back());
-                },
-                [&](const Pa::GotoStmt *stmt) { addSourceToSink(&e, stmt->v); },
-                [&](const Pa::EndDoStmt *) {
-                  // the END DO is the loop exit landing pad
-                  // insert a JUMP as the backedge right before the END DO
-                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
-                  AST::CGJump jump{&cstr->subs->front()};
-                  AST::Evaluation jumpEval{std::move(jump), iter->parent};
-                  evals.insert(iter, std::move(jumpEval));
-                  addSourceToSink(&e, &cstr->subs->front());
-                },
-                [&](const AST::CGJump &jump) {
-                  addSourceToSink(&e, jump.target);
-                },
-                [](auto) { assert(false && "unhandled GOTO case"); },
-            },
-            e.u);
-        break;
-      case AST::CFGAnnotation::CondGoto:
-        std::visit(Co::visitors{
-                       [&](const Pa::IfStmt *) {
-                         // check if these are marked; they must targets here
-                         auto i{iter};
-                         addSourceToSink(&e, &*(++i));
-                         addSourceToSink(&e, &*(++i));
-                       },
-                       [&](const Pa::IfThenStmt *) {
-                         doNextIfBlock(evals, e, iter, evals.end());
-                       },
-                       [&](const Pa::ElseIfStmt *) {
-                         doNextIfBlock(evals, e, iter, evals.end());
-                       },
-                       [](const Pa::WhereConstructStmt *stmt) { TODO(); },
-                       [](const Pa::MaskedElsewhereStmt *stmt) { TODO(); },
-                       [](auto) { assert(false && "unhandled CGOTO case"); },
-                   },
-            e.u);
-        break;
-      case AST::CFGAnnotation::IndGoto:
-        std::visit(
-            Co::visitors{
-                [&](const Pa::AssignedGotoStmt *stmt) {
-                  auto *sym = std::get<Pa::Name>(stmt->t).symbol;
-                  if (assignedGotoMap.find(sym) != assignedGotoMap.end())
-                    for (auto *x : assignedGotoMap[sym]) {
-                      addSourceToSink(&e, x);
-                    }
-                  for (auto &l : std::get<std::list<Pa::Label>>(stmt->t)) {
-                    addSourceToSink(&e, l);
-                  }
-                },
-                [](auto) { assert(false && "unhandled IGOTO case"); },
-            },
-            e.u);
-        break;
-      case AST::CFGAnnotation::IoSwitch:
-        std::visit(
-            Co::visitors{
-                [](const Pa::BackspaceStmt *stmt) { TODO(); },
-                [](const Pa::CloseStmt *stmt) { TODO(); },
-                [](const Pa::EndfileStmt *stmt) { TODO(); },
-                [](const Pa::FlushStmt *stmt) { TODO(); },
-                [](const Pa::InquireStmt *stmt) { TODO(); },
-                [](const Pa::OpenStmt *stmt) { TODO(); },
-                [](const Pa::ReadStmt *stmt) { TODO(); },
-                [](const Pa::RewindStmt *stmt) { TODO(); },
-                [](const Pa::WaitStmt *stmt) { TODO(); },
-                [](const Pa::WriteStmt *stmt) { TODO(); },
-                [](auto) { assert(false && "unhandled IO switch case"); },
-            },
-            e.u);
-        break;
-      case AST::CFGAnnotation::Switch:
-        std::visit(Co::visitors{
-                       [](const Pa::CallStmt *stmt) { TODO(); },
-                       [](const Pa::ArithmeticIfStmt *stmt) { TODO(); },
-                       [](const Pa::ComputedGotoStmt *stmt) { TODO(); },
-                       [](const Pa::SelectCaseStmt *stmt) { TODO(); },
-                       [](const Pa::SelectRankStmt *stmt) { TODO(); },
-                       [](const Pa::SelectTypeStmt *stmt) { TODO(); },
-                       [](auto) { assert(false && "unhandled switch case"); },
-                   },
-            e.u);
-        break;
-      case AST::CFGAnnotation::Iterative:
-        std::visit(Co::visitors{
-                       [](const Pa::NonLabelDoStmt *stmt) { TODO(); },
-                       [](const Pa::WhereStmt *stmt) { TODO(); },
-                       [](const Pa::ForallStmt *stmt) { TODO(); },
-                       [](const Pa::WhereConstruct *stmt) { TODO(); },
-                       [](const Pa::ForallConstructStmt *stmt) { TODO(); },
-                       [](auto) { assert(false && "unhandled loop case"); },
-                   },
-            e.u);
-        break;
-      case AST::CFGAnnotation::FirStructuredOp:
-        // do not visit the subs
-        continue;
-      case AST::CFGAnnotation::Return:
-        // do nothing - exits the function
-        break;
-      case AST::CFGAnnotation::Terminate:
-        // do nothing - exits the function
-        break;
-      }
-      if (e.subs) {
-        reachabilityAnalysis(*e.subs);
-      }
-    }
-  }
-
-  void setActualTargets(std::list<AST::Evaluation> &evals) {
-    for (auto &lst1 : cfgEdgeSetPool)
-      for (auto *e : lst1) {
-        e->isTarget = true;
-      }
-  }
-
-  CFGMapType &cfgMap;
-  std::list<CFGSinkListType> &cfgEdgeSetPool;
-
-  L::DenseMap<Pa::Label, AST::Evaluation *> labels;
-  std::map<Se::Symbol *, std::list<AST::Evaluation *>> assignedGotoMap;
-
-public:
-  CfgBuilder(CFGMapType &m, std::list<CFGSinkListType> &p)
-    : cfgMap{m}, cfgEdgeSetPool{p} {}
-
-  void run(AST::FunctionLikeUnit &func) {
-    resetPotentialTargets(func.evals);
-    cacheAssigns(func.evals);
-    wrapIterationSpaces(func.evals);
-    reachabilityAnalysis(func.evals);
-    setActualTargets(func.evals);
-  }
-};
+// CfgBuilder implementation
+#include "cfg-builder.h"
 
 /// Converter from AST to FIR
 ///
@@ -696,6 +353,12 @@ class FirConverter {
     switchInsertionPointToWhere(where);
   }
 
+  M::Value *genFIRLoopIndex(const Pa::ScalarExpr &x) {
+    return builder->create<fir::ConvertOp>(toLocation(),
+        M::IndexType::get(&mlirContext),
+        createFIRExpr(toLocation(), Se::GetExpr(x)));
+  }
+
   // Structured control op (fir.loop, fir.where)
   void genFIREvalStructuredOp(AST::Evaluation &eval) {
     // process the list of Evaluations
@@ -708,33 +371,30 @@ class FirConverter {
       for (auto &e : *eval.subs) {
         if (auto **s = std::get_if<const Pa::NonLabelDoStmt *>(&e.u)) {
           // do bounds, fir.loop op
-          std::visit(
-              Co::visitors{
-                  [&](const Pa::LoopControl::Bounds &x) {
-                    auto *lo =
-                        createFIRExpr(toLocation(), Se::GetExpr(x.lower));
-                    auto *hi =
-                        createFIRExpr(toLocation(), Se::GetExpr(x.upper));
-                    L::SmallVector<M::Value *, 1> step;
-                    if (x.step.has_value()) {
-                      step.emplace_back(
-                          createFIRExpr(toLocation(), Se::GetExpr(*x.step)));
-                    }
-                    doLoop = builder->create<fir::LoopOp>(
-                        toLocation(), lo, hi, step);
-                    builder->setInsertionPointToStart(doLoop.getBody());
-                  },
-                  [](const Pa::ScalarLogicalExpr &) {
-                    assert(false && "loop lacks iteration space");
-                  },
-                  [&](const Pa::LoopControl::Concurrent &x) {
-                    // FIXME: can project a multi-dimensional space
-                    doLoop = builder->create<fir::LoopOp>(toLocation(),
-                        (M::Value *)nullptr, (M::Value *)nullptr,
-                        L::ArrayRef<M::Value *>{});
-                    builder->setInsertionPointToStart(doLoop.getBody());
-                  },
-              },
+          std::visit(Co::visitors{
+                         [&](const Pa::LoopControl::Bounds &x) {
+                           M::Value *lo = genFIRLoopIndex(x.lower);
+                           M::Value *hi = genFIRLoopIndex(x.upper);
+                           L::SmallVector<M::Value *, 1> step;
+                           if (x.step.has_value()) {
+                             step.emplace_back(createFIRExpr(
+                                 toLocation(), Se::GetExpr(*x.step)));
+                           }
+                           doLoop = builder->create<fir::LoopOp>(
+                               toLocation(), lo, hi, step);
+                           builder->setInsertionPointToStart(doLoop.getBody());
+                         },
+                         [](const Pa::ScalarLogicalExpr &) {
+                           assert(false && "loop lacks iteration space");
+                         },
+                         [&](const Pa::LoopControl::Concurrent &x) {
+                           // FIXME: can project a multi-dimensional space
+                           doLoop = builder->create<fir::LoopOp>(toLocation(),
+                               (M::Value *)nullptr, (M::Value *)nullptr,
+                               L::ArrayRef<M::Value *>{});
+                           builder->setInsertionPointToStart(doLoop.getBody());
+                         },
+                     },
               std::get<std::optional<Pa::LoopControl>>((*s)->t)->u);
         } else if (std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
           // close fir.loop op
diff --git a/lib/burnside/cfg-builder.h b/lib/burnside/cfg-builder.h
new file mode 100644
index 000000000000..a76b4edbd838
--- /dev/null
+++ b/lib/burnside/cfg-builder.h
@@ -0,0 +1,348 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_BRIDGE_CFG_BUILDER_H_
+#define FORTRAN_BURNSIDE_BRIDGE_CFG_BUILDER_H_
+
+/// Traverse the AST and complete the CFG by drawing the arcs, pruning unused
+/// potential targets, making implied jumps explicit, etc.
+class CfgBuilder {
+
+  AST::Evaluation *getEvalByLabel(const Pa::Label &label) {
+    auto iter = labels.find(label);
+    if (iter != labels.end()) {
+      return iter->second;
+    }
+    return nullptr;
+  }
+
+  /// Collect all the potential targets and initialize them to unreferenced
+  void resetPotentialTargets(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      if (e.isTarget) {
+        e.isTarget = false;
+      }
+      if (e.lab.has_value()) {
+        labels.try_emplace(*e.lab, &e);
+      }
+      if (e.subs) {
+        resetPotentialTargets(*e.subs);
+      }
+    }
+  }
+
+  /// cache ASSIGN statements that may yield a live branch target
+  void cacheAssigns(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      std::visit(Co::visitors{
+                     [&](const Pa::AssignStmt *stmt) {
+                       auto *trg = getEvalByLabel(std::get<Pa::Label>(stmt->t));
+                       auto *sym = std::get<Pa::Name>(stmt->t).symbol;
+                       assert(sym);
+                       auto jter = assignedGotoMap.find(sym);
+                       if (jter == assignedGotoMap.end()) {
+                         std::list<AST::Evaluation *> lst = {trg};
+                         assignedGotoMap.try_emplace(sym, lst);
+                       } else {
+                         jter->second.emplace_back(trg);
+                       }
+                     },
+                     [](auto) { /* do nothing */ },
+                 },
+          e.u);
+      if (e.subs) {
+        cacheAssigns(*e.subs);
+      }
+    }
+  }
+
+  void deannotate(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      e.cfg = AST::CFGAnnotation::None;
+      if (e.subs) {
+        deannotate(*e.subs);
+      }
+    }
+  }
+
+  bool structuredCheck(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      if (auto **s = std::get_if<const Pa::DoConstruct *>(&e.u)) {
+        return (*s)->IsDoWhile() ? false : structuredCheck(*e.subs);
+      }
+      if (std::holds_alternative<const Pa::IfConstruct *>(e.u)) {
+        return structuredCheck(*e.subs);
+      }
+      if (e.subs) {
+        return false;
+      }
+      switch (e.cfg) {
+      case AST::CFGAnnotation::None: break;
+      case AST::CFGAnnotation::CondGoto: break;
+      case AST::CFGAnnotation::Iterative: break;
+      case AST::CFGAnnotation::FirStructuredOp: break;
+      case AST::CFGAnnotation::IndGoto: return false;
+      case AST::CFGAnnotation::IoSwitch: return false;
+      case AST::CFGAnnotation::Switch: return false;
+      case AST::CFGAnnotation::Return: return false;
+      case AST::CFGAnnotation::Terminate: return false;
+      case AST::CFGAnnotation::Goto:
+        if (!std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
+          return false;
+        }
+        break;
+      }
+    }
+    return true;
+  }
+
+  void wrapIterationSpaces(std::list<AST::Evaluation> &evals) {
+    for (auto &e : evals) {
+      if (std::holds_alternative<const Pa::DoConstruct *>(e.u))
+        if (structuredCheck(*e.subs)) {
+          deannotate(*e.subs);
+          e.cfg = AST::CFGAnnotation::FirStructuredOp;
+          continue;
+        }
+      if (std::holds_alternative<const Pa::IfConstruct *>(e.u))
+        if (structuredCheck(*e.subs)) {
+          deannotate(*e.subs);
+          e.cfg = AST::CFGAnnotation::FirStructuredOp;
+          continue;
+        }
+      // FIXME: ForallConstruct? WhereConstruct?
+      if (e.subs) {
+        wrapIterationSpaces(*e.subs);
+      }
+    }
+  }
+
+  /// Add source->sink edge to CFG map
+  void addSourceToSink(AST::Evaluation *src, AST::Evaluation *snk) {
+    auto iter = cfgMap.find(src);
+    if (iter == cfgMap.end()) {
+      CFGSinkListType sink{snk};
+      cfgEdgeSetPool.emplace_back(std::move(sink));
+      auto rc{cfgMap.try_emplace(src, &cfgEdgeSetPool.back())};
+      assert(rc.second && "insert failed unexpectedly");
+      (void)rc;  // for release build
+      return;
+    }
+    for (auto *s : *iter->second)
+      if (s == snk) {
+        return;
+      }
+    iter->second->push_back(snk);
+  }
+
+  void addSourceToSink(AST::Evaluation *src, const Pa::Label &label) {
+    auto iter = labels.find(label);
+    assert(iter != labels.end());
+    addSourceToSink(src, iter->second);
+  }
+
+  /// Find the next ELSE IF, ELSE or END IF statement in the list
+  template<typename A> A nextFalseTarget(A iter, const A &endi) {
+    for (; iter != endi; ++iter)
+      if (std::visit(Co::visitors{
+                         [&](const Pa::ElseIfStmt *) { return true; },
+                         [&](const Pa::ElseStmt *) { return true; },
+                         [&](const Pa::EndIfStmt *) { return true; },
+                         [](auto) { return false; },
+                     },
+              iter->u)) {
+        break;
+      }
+    return iter;
+  }
+
+  /// Add branches for this IF block like construct.
+  /// Branch to the "true block", the "false block", and from the end of the
+  /// true block to the end of the construct.
+  template<typename A>
+  void doNextIfBlock(std::list<AST::Evaluation> &evals, AST::Evaluation &e,
+      const A &iter, const A &endif) {
+    A i{iter};
+    A j{nextFalseTarget(++i, endif)};
+    auto *cstr = std::get<AST::Evaluation *>(e.parent);
+    AST::CGJump jump{&*endif};
+    A k{evals.insert(j, AST::Evaluation{std::move(jump), j->parent})};
+    if (i == j) {
+      // block was empty, so adjust "true" target
+      i = k;
+    }
+    addSourceToSink(&*k, cstr);
+    addSourceToSink(&e, &*i);
+    addSourceToSink(&e, &*j);
+  }
+
+  /// Determine which branch targets are reachable. The target map must
+  /// already be initialized.
+  void reachabilityAnalysis(std::list<AST::Evaluation> &evals) {
+    for (auto iter = evals.begin(); iter != evals.end(); ++iter) {
+      auto &e = *iter;
+      switch (e.cfg) {
+      case AST::CFGAnnotation::None:
+        // do nothing - does not impart control flow
+        break;
+      case AST::CFGAnnotation::Goto:
+        std::visit(
+            Co::visitors{
+                [&](const Pa::CycleStmt *) {
+                  // FIXME: deal with construct name
+                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  addSourceToSink(&e, &cstr->subs->front());
+                },
+                [&](const Pa::ExitStmt *) {
+                  // FIXME: deal with construct name
+                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  addSourceToSink(&e, &cstr->subs->back());
+                },
+                [&](const Pa::GotoStmt *stmt) { addSourceToSink(&e, stmt->v); },
+                [&](const Pa::EndDoStmt *) {
+                  // the END DO is the loop exit landing pad
+                  // insert a JUMP as the backedge right before the END DO
+                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  AST::CGJump jump{&cstr->subs->front()};
+                  AST::Evaluation jumpEval{std::move(jump), iter->parent};
+                  evals.insert(iter, std::move(jumpEval));
+                  addSourceToSink(&e, &cstr->subs->front());
+                },
+                [&](const AST::CGJump &jump) {
+                  addSourceToSink(&e, jump.target);
+                },
+                [](auto) { assert(false && "unhandled GOTO case"); },
+            },
+            e.u);
+        break;
+      case AST::CFGAnnotation::CondGoto:
+        std::visit(Co::visitors{
+                       [&](const Pa::IfStmt *) {
+                         // check if these are marked; they must targets here
+                         auto i{iter};
+                         addSourceToSink(&e, &*(++i));
+                         addSourceToSink(&e, &*(++i));
+                       },
+                       [&](const Pa::IfThenStmt *) {
+                         doNextIfBlock(evals, e, iter, evals.end());
+                       },
+                       [&](const Pa::ElseIfStmt *) {
+                         doNextIfBlock(evals, e, iter, evals.end());
+                       },
+                       [](const Pa::WhereConstructStmt *stmt) { TODO(); },
+                       [](const Pa::MaskedElsewhereStmt *stmt) { TODO(); },
+                       [](auto) { assert(false && "unhandled CGOTO case"); },
+                   },
+            e.u);
+        break;
+      case AST::CFGAnnotation::IndGoto:
+        std::visit(
+            Co::visitors{
+                [&](const Pa::AssignedGotoStmt *stmt) {
+                  auto *sym = std::get<Pa::Name>(stmt->t).symbol;
+                  if (assignedGotoMap.find(sym) != assignedGotoMap.end())
+                    for (auto *x : assignedGotoMap[sym]) {
+                      addSourceToSink(&e, x);
+                    }
+                  for (auto &l : std::get<std::list<Pa::Label>>(stmt->t)) {
+                    addSourceToSink(&e, l);
+                  }
+                },
+                [](auto) { assert(false && "unhandled IGOTO case"); },
+            },
+            e.u);
+        break;
+      case AST::CFGAnnotation::IoSwitch:
+        std::visit(
+            Co::visitors{
+                [](const Pa::BackspaceStmt *stmt) { TODO(); },
+                [](const Pa::CloseStmt *stmt) { TODO(); },
+                [](const Pa::EndfileStmt *stmt) { TODO(); },
+                [](const Pa::FlushStmt *stmt) { TODO(); },
+                [](const Pa::InquireStmt *stmt) { TODO(); },
+                [](const Pa::OpenStmt *stmt) { TODO(); },
+                [](const Pa::ReadStmt *stmt) { TODO(); },
+                [](const Pa::RewindStmt *stmt) { TODO(); },
+                [](const Pa::WaitStmt *stmt) { TODO(); },
+                [](const Pa::WriteStmt *stmt) { TODO(); },
+                [](auto) { assert(false && "unhandled IO switch case"); },
+            },
+            e.u);
+        break;
+      case AST::CFGAnnotation::Switch:
+        std::visit(Co::visitors{
+                       [](const Pa::CallStmt *stmt) { TODO(); },
+                       [](const Pa::ArithmeticIfStmt *stmt) { TODO(); },
+                       [](const Pa::ComputedGotoStmt *stmt) { TODO(); },
+                       [](const Pa::SelectCaseStmt *stmt) { TODO(); },
+                       [](const Pa::SelectRankStmt *stmt) { TODO(); },
+                       [](const Pa::SelectTypeStmt *stmt) { TODO(); },
+                       [](auto) { assert(false && "unhandled switch case"); },
+                   },
+            e.u);
+        break;
+      case AST::CFGAnnotation::Iterative:
+        std::visit(Co::visitors{
+                       [](const Pa::NonLabelDoStmt *stmt) { TODO(); },
+                       [](const Pa::WhereStmt *stmt) { TODO(); },
+                       [](const Pa::ForallStmt *stmt) { TODO(); },
+                       [](const Pa::WhereConstruct *stmt) { TODO(); },
+                       [](const Pa::ForallConstructStmt *stmt) { TODO(); },
+                       [](auto) { assert(false && "unhandled loop case"); },
+                   },
+            e.u);
+        break;
+      case AST::CFGAnnotation::FirStructuredOp:
+        // do not visit the subs
+        continue;
+      case AST::CFGAnnotation::Return:
+        // do nothing - exits the function
+        break;
+      case AST::CFGAnnotation::Terminate:
+        // do nothing - exits the function
+        break;
+      }
+      if (e.subs) {
+        reachabilityAnalysis(*e.subs);
+      }
+    }
+  }
+
+  void setActualTargets(std::list<AST::Evaluation> &evals) {
+    for (auto &lst1 : cfgEdgeSetPool)
+      for (auto *e : lst1) {
+        e->isTarget = true;
+      }
+  }
+
+  CFGMapType &cfgMap;
+  std::list<CFGSinkListType> &cfgEdgeSetPool;
+
+  L::DenseMap<Pa::Label, AST::Evaluation *> labels;
+  std::map<Se::Symbol *, std::list<AST::Evaluation *>> assignedGotoMap;
+
+public:
+  CfgBuilder(CFGMapType &m, std::list<CFGSinkListType> &p)
+    : cfgMap{m}, cfgEdgeSetPool{p} {}
+
+  void run(AST::FunctionLikeUnit &func) {
+    resetPotentialTargets(func.evals);
+    cacheAssigns(func.evals);
+    wrapIterationSpaces(func.evals);
+    reachabilityAnalysis(func.evals);
+    setActualTargets(func.evals);
+  }
+};
+
+#endif  // FORTRAN_BURNSIDE_BRIDGE_CFG_BUILDER_H_
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 3ae2cc893edd..8dac27b24303 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -571,27 +571,17 @@ class ExprLowering {
   // Determine the result type after removing `dims` dimensions from the array
   // type `arrTy`
   M::Type genSubType(M::Type arrTy, unsigned dims) {
-    if (auto memRef{arrTy.dyn_cast<M::MemRefType>()}) {
-      if (dims < memRef.getRank()) {
-        auto shape{memRef.getShape()};
-        llvm::SmallVector<int64_t, 4> newShape;
-        // TODO: should we really remove rows here?
-        for (unsigned i = dims, e = memRef.getRank(); i < e; ++i) {
-          newShape.push_back(shape[i]);
-        }
-        return M::MemRefType::get(newShape, memRef.getElementType());
-      }
-      return memRef.getElementType();
-    }
     auto unwrapTy{arrTy.cast<fir::ReferenceType>().getEleTy()};
     auto seqTy{unwrapTy.cast<fir::SequenceType>()};
     auto shape = seqTy.getShape();
-    if ((shape.size() > 0) && (dims < shape.size())) {
-      fir::SequenceType::Shape newBnds;
-      // follow Fortran semantics and remove columns
-      for (unsigned i = 0; i < dims; ++i) {
-        newBnds.push_back(shape[i]);
-      }
+    assert(shape.size() > 0 && "removing columns for sequence sans shape");
+    assert(dims <= shape.size() && "removing more columns than exist");
+    fir::SequenceType::Shape newBnds;
+    // follow Fortran semantics and remove columns (from right)
+    for (unsigned i = 0, e = shape.size() - dims; i < e; ++i) {
+      newBnds.push_back(shape[i]);
+    }
+    if (!newBnds.empty()) {
       return fir::SequenceType::get(newBnds, seqTy.getEleTy());
     }
     return seqTy.getEleTy();
@@ -608,7 +598,7 @@ class ExprLowering {
     for (auto &subsc : aref.subscript()) {
       args.push_back(genval(subsc));
     }
-    auto ty{genSubType(base->getType(), args.size() - 1)};
+    auto ty{genSubType(base->getType(), args.size())};
     ty = fir::ReferenceType::get(ty);
     return builder.create<fir::CoordinateOp>(getLoc(), ty, base, args);
   }

From a5aab7d615ff9479faea3ee2613092c3af957e0d Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 6 Dec 2019 14:35:22 -0800
Subject: [PATCH 133/345] Burnside: simple DO to fir.loop conversion

---
 include/fir/FIROps.h         |   2 +
 include/fir/FIROps.td        |   7 +-
 lib/burnside/bridge.cc       | 174 ++++++++++++++++++++++-------------
 lib/burnside/builder.cc      |  19 ++++
 lib/burnside/builder.h       |   9 +-
 lib/burnside/convert-expr.cc |  14 ++-
 lib/fir/FIROps.cpp           |   5 +
 7 files changed, 160 insertions(+), 70 deletions(-)

diff --git a/include/fir/FIROps.h b/include/fir/FIROps.h
index 37938137567c..d4d656c15d6a 100644
--- a/include/fir/FIROps.h
+++ b/include/fir/FIROps.h
@@ -139,6 +139,8 @@ mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
 
 LoopOp getForInductionVarOwner(mlir::Value *val);
 
+bool isReferenceLike(mlir::Type type);
+
 } // namespace fir
 
 #endif // FIR_FIROPS_H
diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
index 981201b83be2..f127d78cd632 100644
--- a/include/fir/FIROps.td
+++ b/include/fir/FIROps.td
@@ -296,8 +296,11 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, Value *refVal",
     [{
-      fir::ReferenceType refTy =
-        refVal->getType().cast<fir::ReferenceType>();
+      if (!refVal) {
+        mlir::emitError(result.location, "LoadOp has null argument");
+        return;
+      }
+      fir::ReferenceType refTy = refVal->getType().cast<fir::ReferenceType>();
       result.addOperands(refVal);
       result.addTypes(refTy.getEleTy());
     }]
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 32ec0f89bf9c..506bfe5e23ce 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -94,6 +94,7 @@ class FirConverter {
         loc, *builder, *expr, localSymbols, defaults, intrinsics);
   }
 
+  // TODO: we need a map for the various Fortran runtime entry points
   M::FuncOp genRuntimeFunction(RuntimeEntryCode rec, int kind) {
     return genFunctionFIR(
         getRuntimeEntryName(rec), getRuntimeEntryType(rec, mlirContext, kind));
@@ -106,7 +107,7 @@ class FirConverter {
     return createFunction(module, callee, funcTy);
   }
 
-  bool inMainProgram(AST::Evaluation *cstr) {
+  static bool inMainProgram(AST::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
             [](AST::FunctionLikeUnit *c) { return c->isMainProgram(); },
@@ -115,7 +116,7 @@ class FirConverter {
         },
         cstr->parent);
   }
-  const Pa::SubroutineStmt *inSubroutine(AST::Evaluation *cstr) {
+  static const Pa::SubroutineStmt *inSubroutine(AST::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
             [](AST::FunctionLikeUnit *c) { return c->isSubroutine(); },
@@ -124,7 +125,7 @@ class FirConverter {
         },
         cstr->parent);
   }
-  const Pa::FunctionStmt *inFunction(AST::Evaluation *cstr) {
+  static const Pa::FunctionStmt *inFunction(AST::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
             [](AST::FunctionLikeUnit *c) { return c->isFunction(); },
@@ -133,7 +134,7 @@ class FirConverter {
         },
         cstr->parent);
   }
-  const Pa::MpSubprogramStmt *inMPSubp(AST::Evaluation *cstr) {
+  static const Pa::MpSubprogramStmt *inMPSubp(AST::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
             [](AST::FunctionLikeUnit *c) { return c->isMPSubp(); },
@@ -144,36 +145,37 @@ class FirConverter {
   }
 
   template<typename A>
-  const Se::SomeExpr *getScalarExprOfTuple(const A &tuple) {
+  static const Se::SomeExpr *getScalarExprOfTuple(const A &tuple) {
     return Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(tuple));
   }
-  template<typename A> const Se::SomeExpr *getExprOfTuple(const A &tuple) {
+  template<typename A>
+  static const Se::SomeExpr *getExprOfTuple(const A &tuple) {
     return Se::GetExpr(std::get<Pa::LogicalExpr>(tuple));
   }
   /// Get the condition expression for a CondGoto evaluation
   const Se::SomeExpr *getEvaluationCondition(AST::Evaluation &eval) {
-    return std::visit(Co::visitors{
-                          [&](const Pa::IfStmt *stmt) {
-                            return getScalarExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::IfThenStmt *stmt) {
-                            return getScalarExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::ElseIfStmt *stmt) {
-                            return getScalarExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::WhereConstructStmt *stmt) {
-                            return getExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::MaskedElsewhereStmt *stmt) {
-                            return getExprOfTuple(stmt->t);
-                          },
-                          [](auto) -> const Se::SomeExpr * {
-                            assert(
-                                false && "unexpected conditional branch case");
-                            return nullptr;
-                          },
-                      },
+    return std::visit(
+        Co::visitors{
+            [&](const Pa::IfStmt *stmt) {
+              return getScalarExprOfTuple(stmt->t);
+            },
+            [&](const Pa::IfThenStmt *stmt) {
+              return getScalarExprOfTuple(stmt->t);
+            },
+            [&](const Pa::ElseIfStmt *stmt) {
+              return getScalarExprOfTuple(stmt->t);
+            },
+            [&](const Pa::WhereConstructStmt *stmt) {
+              return getExprOfTuple(stmt->t);
+            },
+            [&](const Pa::MaskedElsewhereStmt *stmt) {
+              return getExprOfTuple(stmt->t);
+            },
+            [&](auto) -> const Se::SomeExpr * {
+              M::emitError(toLocation(), "unexpected conditional branch case");
+              return nullptr;
+            },
+        },
         eval.u);
   }
 
@@ -346,7 +348,7 @@ class FirConverter {
     builder->setInsertionPointToStart(&where.otherRegion().front());
   }
   template<typename A>
-  void handleCondition(fir::WhereOp &where, const A *stmt) {
+  void genWhereCondition(fir::WhereOp &where, const A *stmt) {
     auto *cond{createLogicalExprAsI1(
         toLocation(), Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(stmt->t)))};
     where = builder->create<fir::WhereOp>(toLocation(), cond, true);
@@ -359,10 +361,16 @@ class FirConverter {
         createFIRExpr(toLocation(), Se::GetExpr(x)));
   }
 
-  // Structured control op (fir.loop, fir.where)
+  /// Structured control op (`fir.loop`, `fir.where`)
+  ///
+  /// Convert a DoConstruct to a `fir.loop` op.
+  /// Convert an IfConstruct to a `fir.where` op.
+  ///
   void genFIREvalStructuredOp(AST::Evaluation &eval) {
+    // TODO: array expressions, FORALL, WHERE ...
+
     // process the list of Evaluations
-    assert(eval.subs);
+    assert(eval.subs && "eval must have a body");
     auto *insPt = builder->getInsertionBlock();
 
     if (std::holds_alternative<const Pa::DoConstruct *>(eval.u)) {
@@ -371,34 +379,45 @@ class FirConverter {
       for (auto &e : *eval.subs) {
         if (auto **s = std::get_if<const Pa::NonLabelDoStmt *>(&e.u)) {
           // do bounds, fir.loop op
-          std::visit(Co::visitors{
-                         [&](const Pa::LoopControl::Bounds &x) {
-                           M::Value *lo = genFIRLoopIndex(x.lower);
-                           M::Value *hi = genFIRLoopIndex(x.upper);
-                           L::SmallVector<M::Value *, 1> step;
-                           if (x.step.has_value()) {
-                             step.emplace_back(createFIRExpr(
-                                 toLocation(), Se::GetExpr(*x.step)));
-                           }
-                           doLoop = builder->create<fir::LoopOp>(
-                               toLocation(), lo, hi, step);
-                           builder->setInsertionPointToStart(doLoop.getBody());
-                         },
-                         [](const Pa::ScalarLogicalExpr &) {
-                           assert(false && "loop lacks iteration space");
-                         },
-                         [&](const Pa::LoopControl::Concurrent &x) {
-                           // FIXME: can project a multi-dimensional space
-                           doLoop = builder->create<fir::LoopOp>(toLocation(),
-                               (M::Value *)nullptr, (M::Value *)nullptr,
-                               L::ArrayRef<M::Value *>{});
-                           builder->setInsertionPointToStart(doLoop.getBody());
-                         },
-                     },
+          std::visit(
+              Co::visitors{
+                  [&](const Pa::LoopControl::Bounds &x) {
+                    // create the fir.loop op
+                    M::Value *lo = genFIRLoopIndex(x.lower);
+                    M::Value *hi = genFIRLoopIndex(x.upper);
+                    L::SmallVector<M::Value *, 1> step;
+                    if (x.step.has_value()) {
+                      step.emplace_back(
+                          createFIRExpr(toLocation(), Se::GetExpr(*x.step)));
+                    }
+                    doLoop = builder->create<fir::LoopOp>(
+                        toLocation(), lo, hi, step);
+                    builder->setInsertionPointToStart(doLoop.getBody());
+                    auto *sym{x.name.thing.symbol};
+                    auto ty{
+                        translateSymbolToFIRType(&mlirContext, defaults, *sym)};
+                    // TODO: should push this cast down to the uses
+                    auto cvt{builder->create<fir::ConvertOp>(
+                        toLocation(), ty, doLoop.getInductionVar())};
+                    localSymbols.pushShadowSymbol(*sym, cvt);
+                  },
+                  [&](const Pa::ScalarLogicalExpr &) {
+                    // we should never reach here
+                    M::emitError(toLocation(), "loop lacks iteration space");
+                  },
+                  [&](const Pa::LoopControl::Concurrent &x) {
+                    // FIXME: can project a multi-dimensional space
+                    doLoop = builder->create<fir::LoopOp>(toLocation(),
+                        (M::Value *)nullptr, (M::Value *)nullptr,
+                        L::ArrayRef<M::Value *>{});
+                    builder->setInsertionPointToStart(doLoop.getBody());
+                  },
+              },
               std::get<std::optional<Pa::LoopControl>>((*s)->t)->u);
         } else if (std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
           // close fir.loop op
           builder->clearInsertionPoint();
+          localSymbols.popShadowSymbol();
         } else {
           genFIR(e);
         }
@@ -409,11 +428,11 @@ class FirConverter {
       for (auto &e : *eval.subs) {
         if (auto **s = std::get_if<const Pa::IfThenStmt *>(&e.u)) {
           // fir.where op
-          handleCondition(where, *s);
+          genWhereCondition(where, *s);
         } else if (auto **s = std::get_if<const Pa::ElseIfStmt *>(&e.u)) {
           // otherwise block, then nested fir.where
           switchInsertionPointToOtherwise(where);
-          handleCondition(where, *s);
+          genWhereCondition(where, *s);
         } else if (std::holds_alternative<const Pa::ElseStmt *>(e.u)) {
           // otherwise block
           switchInsertionPointToOtherwise(where);
@@ -580,13 +599,12 @@ class FirConverter {
   // Statements that do not have control-flow semantics
   //
 
-  void genFIR(const Pa::AllocateStmt &) { TODO(); }
+  void genFIR(const Pa::AllocateStmt &) { SOFT_TODO(); }
   void genFIR(const Pa::AssignmentStmt &stmt) {
     auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
     auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
-    auto loc{toLocation()};
-    builder->create<fir::StoreOp>(
-        loc, createFIRExpr(loc, rhs), createFIRAddr(loc, lhs));
+    builder->create<fir::StoreOp>(toLocation(),
+        createFIRExpr(toLocation(), rhs), createFIRAddr(toLocation(), lhs));
   }
 
   void genFIR(const Pa::BackspaceStmt &) {
@@ -598,7 +616,7 @@ class FirConverter {
     TODO();
   }
   void genFIR(const Pa::ContinueStmt &) {}  // do nothing
-  void genFIR(const Pa::DeallocateStmt &) { TODO(); }
+  void genFIR(const Pa::DeallocateStmt &) { SOFT_TODO(); }
   void genFIR(const Pa::EndfileStmt &) {
     // call some IO runtime routine(s)
     TODO();
@@ -624,12 +642,36 @@ class FirConverter {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::NullifyStmt &) { TODO(); }
+
+  /// Nullify pointer object list
+  ///
+  /// For each pointer object, reset the pointer to a disassociated status.
+  /// We do this by setting each pointer to null.
+  void genFIR(const Pa::NullifyStmt &stmt) {
+    for (auto &po : stmt.v) {
+      std::visit(Co::visitors{
+                     [&](const Pa::Name &sym) {
+                       auto ty{translateSymbolToFIRType(
+                           &mlirContext, defaults, *sym.symbol)};
+                       auto load{builder->create<fir::LoadOp>(toLocation(),
+                           localSymbols.lookupSymbol(*sym.symbol))};
+                       auto idxTy{M::IndexType::get(&mlirContext)};
+                       auto zero{builder->create<M::ConstantOp>(toLocation(),
+                           idxTy, builder->getIntegerAttr(idxTy, 0))};
+                       auto cast{builder->create<fir::ConvertOp>(
+                           toLocation(), ty, zero)};
+                       builder->create<fir::StoreOp>(toLocation(), cast, load);
+                     },
+                     [&](const Pa::StructureComponent &) { TODO(); },
+                 },
+          po.u);
+    }
+  }
   void genFIR(const Pa::OpenStmt &) {
     // call some IO runtime routine(s)
     TODO();
   }
-  void genFIR(const Pa::PointerAssignmentStmt &) { TODO(); }
+  void genFIR(const Pa::PointerAssignmentStmt &) { SOFT_TODO(); }
 
   void genFIR(const Pa::PrintStmt &stmt) {
     L::SmallVector<mlir::Value *, 4> args;
@@ -715,7 +757,7 @@ class FirConverter {
     } else if (auto *stmt = inMPSubp(currentEvaluation)) {
       genFIRProcedureExit(stmt);
     } else {
-      assert(false && "unknown subprogram type");
+      M::emitError(toLocation(), "unknown subprogram type");
     }
   }
 
@@ -940,7 +982,7 @@ class FirConverter {
       // FIXME
       // return builder->create<M::CallOp>(lhs->getLoc(), );
     }
-    assert(false && "cannot generate operation on this type");
+    M::emitError(toLocation(), "cannot generate operation on this type");
     return {};
   }
   M::Value *genGE(M::Value *lhs, M::Value *rhs) {
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index 9508b3398d1d..e768ad0ecec4 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -93,3 +93,22 @@ mlir::Value *B::SymMap::lookupSymbol(semantics::SymbolRef symbol) {
   auto iter{symbolMap.find(&*symbol)};
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
+
+void B::SymMap::pushShadowSymbol(
+    semantics::SymbolRef symbol, mlir::Value *value) {
+  // find any existing mapping for symbol
+  auto iter{symbolMap.find(&*symbol)};
+  const semantics::Symbol *sym{nullptr};
+  mlir::Value *val{nullptr};
+  // if mapping exists, save it on the shadow stack
+  if (iter != symbolMap.end()) {
+    sym = iter->first;
+    val = iter->second;
+    symbolMap.erase(iter);
+  }
+  shadowStack.emplace_back(sym, val);
+  // insert new shadow mapping
+  auto r{symbolMap.try_emplace(&*symbol, value)};
+  assert(r.second && "unexpected insertion failure");
+  (void)r;
+}
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index 2eed75590d7f..9ac477e8211a 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -43,13 +43,20 @@ namespace burnside {
 
 class SymMap {
   llvm::DenseMap<const semantics::Symbol *, mlir::Value *> symbolMap;
+  std::vector<std::pair<const semantics::Symbol *, mlir::Value *>> shadowStack;
 
 public:
   void addSymbol(semantics::SymbolRef symbol, mlir::Value *value);
 
   mlir::Value *lookupSymbol(semantics::SymbolRef symbol);
 
-  void clear() { symbolMap.clear(); }
+  void pushShadowSymbol(semantics::SymbolRef symbol, mlir::Value *value);
+  void popShadowSymbol() { shadowStack.pop_back(); }
+
+  void clear() {
+    symbolMap.clear();
+    shadowStack.clear();
+  }
 };
 
 std::string applyNameMangling(llvm::StringRef parserName);
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 8dac27b24303..5e46fdaa5747 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -70,7 +70,9 @@ class ExprLowering {
   M::OpBuilder &builder;
   SomeExpr const &expr;
   SymMap &symMap;
-  SymMap loadedSymbols{};
+#if 0
+  SymMap loadedSymbols;
+#endif
   Co::IntrinsicTypeDefaultKinds const &defaults;
   IntrinsicLibrary const &intrinsics;
   bool genLogicalAsI1{false};
@@ -231,6 +233,7 @@ class ExprLowering {
   M::Value *gendef(Se::SymbolRef sym) { return gen(sym); }
 
   M::Value *genval(Se::SymbolRef sym) {
+#if 0
     // Do not load the same symbols several time in one expression.
     // Fortran guarantees variable value must be the same wherever it
     // appears in one expression.
@@ -241,6 +244,15 @@ class ExprLowering {
       loadedSymbols.addSymbol(sym, load);
       return load;
     }
+#else
+    // Multiple loads should be CSEd. If they aren't, it's a bug in CSE that
+    // should not use a workaround here.
+    M::Value *var{gen(sym)};
+    if (fir::isReferenceLike(var->getType())) {
+      return builder.create<fir::LoadOp>(getLoc(), var);
+    }
+    return var;
+#endif
   }
 
   M::Value *genval(Ev::BOZLiteralConstant const &) { TODO(); }
diff --git a/lib/fir/FIROps.cpp b/lib/fir/FIROps.cpp
index 55e2da3cffee..b3653c777c98 100644
--- a/lib/fir/FIROps.cpp
+++ b/lib/fir/FIROps.cpp
@@ -582,6 +582,11 @@ void printUnaryOp(Operation *op, OpAsmPrinter &p) {
   p << " : " << op->getResult(0)->getType();
 }
 
+bool isReferenceLike(M::Type type) {
+  return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
+         type.isa<fir::PointerType>();
+}
+
 // Tablegen operators
 
 #define GET_OP_CLASSES

From 8ed9f058ef9526361052b66496e700acb4b9708f Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 9 Dec 2019 14:54:02 -0800
Subject: [PATCH 134/345] do a little work on calls

---
 lib/burnside/bridge.cc | 88 +++++++++++++++++++++++++++++++++++-------
 1 file changed, 75 insertions(+), 13 deletions(-)

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 506bfe5e23ce..4c86689a063e 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -184,17 +184,17 @@ class FirConverter {
   //
 
   void genFIR(const Pa::Statement<Pa::ProgramStmt> &stmt, std::string &name,
-      Se::Symbol const *&) {
+      const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     name = mangler.getProgramEntry();
   }
   void genFIR(const Pa::Statement<Pa::EndProgramStmt> &stmt, std::string &,
-      Se::Symbol const *&) {
+      const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
   void genFIR(const Pa::Statement<Pa::FunctionStmt> &stmt, std::string &name,
-      Se::Symbol const *&symbol) {
+      const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
@@ -202,12 +202,12 @@ class FirConverter {
     name = applyNameMangling(*symbol);  // FIXME: use NameMangler
   }
   void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
-      Se::Symbol const *&) {
+      const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
   void genFIR(const Pa::Statement<Pa::SubroutineStmt> &stmt, std::string &name,
-      Se::Symbol const *&symbol) {
+      const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
@@ -215,19 +215,19 @@ class FirConverter {
     name = applyNameMangling(*symbol);  // FIXME: use NameMangler
   }
   void genFIR(const Pa::Statement<Pa::EndSubroutineStmt> &stmt, std::string &,
-      Se::Symbol const *&) {
+      const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
   void genFIR(const Pa::Statement<Pa::MpSubprogramStmt> &stmt,
-      std::string &name, Se::Symbol const *&symbol) {
+      std::string &name, const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{stmt.statement.v};
     name = n.ToString();
     symbol = n.symbol;
   }
   void genFIR(const Pa::Statement<Pa::EndMpSubprogramStmt> &stmt, std::string &,
-      Se::Symbol const *&) {
+      const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
@@ -472,12 +472,74 @@ class FirConverter {
   // No control-flow
   void genFIREvalNone(AST::Evaluation &eval) { genFIR(eval); }
 
+  M::FuncOp getFunc(L::StringRef name, M::FunctionType ty) {
+    if (auto func = getNamedFunction(module, name)) {
+      assert(func.getType() == ty);
+      return func;
+    }
+    return createFunction(module, name, ty);
+  }
+
+  /// Lowering of CALL statement
+  ///
+  /// 1. Determine what function is being called/dispatched to
+  /// 2. Build a tuple of arguments to be passed to that function
+  /// 3. Emit fir.call/fir.dispatch on arguments
   void genFIR(const Pa::CallStmt &stmt) {
-    // FIXME handle alternate return
-    auto loc{toLocation()};
-    (void)loc;
-    TODO();
+    L::SmallVector<M::Type, 8> argTy;
+    L::SmallVector<M::Type, 2> resTy;
+    L::StringRef funName;
+    std::vector<Se::Symbol *> argsList;
+    setCurrentPosition(stmt.v.source);
+    std::visit(Co::visitors{
+                   [&](const Pa::Name &name) {
+                     auto *sym = name.symbol;
+                     auto n{sym->name()};
+                     funName = L::StringRef{n.begin(), n.size()};
+                     auto &details = sym->get<Se::SubprogramDetails>();
+                     // TODO ProcEntityDetails?
+                     // TODO bindName()?
+                     argsList = details.dummyArgs();
+                   },
+                   [](const Pa::ProcComponentRef &) { TODO(); },
+               },
+        std::get<Pa::ProcedureDesignator>(stmt.v.t).u);
+    for (auto *d : argsList) {
+      Se::SymbolRef sr{*d};
+      // FIXME:
+      argTy.push_back(fir::ReferenceType::get(
+          translateSymbolToFIRType(&mlirContext, defaults, sr)));
+    }
+    auto funTy{M::FunctionType::get(argTy, resTy, builder->getContext())};
+    // FIXME: mangle name
+    M::FuncOp func{getFunc(funName, funTy)};
+    std::vector<M::Value *> actuals;
+    for (auto &aa : std::get<std::list<Pa::ActualArgSpec>>(stmt.v.t)) {
+      auto &kw = std::get<std::optional<Pa::Keyword>>(aa.t);
+      auto &arg = std::get<Pa::ActualArg>(aa.t);
+      M::Value *fe{nullptr};
+      std::visit(Co::visitors{
+                     [&](const Co::Indirection<Pa::Expr> &e) {
+                       auto *exp{Se::GetExpr(e)};
+                       // FIXME: needs to match argument, assumes trivial by-ref
+                       fe = createFIRAddr(toLocation(), exp);
+                     },
+                     [](const Pa::AltReturnSpec &) { TODO(); },
+                     [](const Pa::ActualArg::PercentRef &) { TODO(); },
+                     [](const Pa::ActualArg::PercentVal &) { TODO(); },
+                 },
+          arg.u);
+      if (kw.has_value()) {
+        TODO();
+        continue;
+      }
+      actuals.push_back(fe);
+    }
+
+    builder->create<fir::CallOp>(
+        toLocation(), resTy, builder->getSymbolRefAttr(funName), actuals);
   }
+
   void genFIR(const Pa::IfStmt &) { TODO(); }
   void genFIR(const Pa::WaitStmt &) { TODO(); }
   void genFIR(const Pa::WhereStmt &) { TODO(); }
@@ -1002,7 +1064,7 @@ class FirConverter {
   M::MLIRContext &mlirContext;
   const Pa::CookedSource *cooked;
   M::ModuleOp &module;
-  Co::IntrinsicTypeDefaultKinds const &defaults;
+  const Co::IntrinsicTypeDefaultKinds &defaults;
   IntrinsicLibrary intrinsics;
   M::OpBuilder *builder{nullptr};
   fir::NameMangler &mangler;

From 7d29b57368c6b203ed8d1a3573cf030ee1179955 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 9 Dec 2019 17:27:06 -0800
Subject: [PATCH 135/345] rebase changes; move IO statements

---
 lib/burnside/bridge.cc |  90 ++++++++++++++++------------------
 lib/burnside/io.cc     | 107 ++++++++++++++++++++++++++++++-----------
 lib/burnside/io.h      |  46 +++++++++++++++---
 lib/fir/Tilikum.cpp    |  34 ++++++-------
 4 files changed, 178 insertions(+), 99 deletions(-)

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 4c86689a063e..baa47db943ac 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -661,6 +661,45 @@ class FirConverter {
   // Statements that do not have control-flow semantics
   //
 
+  // IO statements (see io.h)
+
+  void genFIR(const Pa::BackspaceStmt &stmt) {
+    genBackspaceStatement(*builder, toLocation(), stmt);
+  }
+  void genFIR(const Pa::CloseStmt &stmt) {
+    genCloseStatement(*builder, toLocation(), stmt);
+  }
+  void genFIR(const Pa::EndfileStmt &stmt) {
+    genEndfileStatement(*builder, toLocation(), stmt);
+  }
+  void genFIR(const Pa::FlushStmt &stmt) {
+    genFlushStatement(*builder, toLocation(), stmt);
+  }
+  void genFIR(const Pa::OpenStmt &stmt) {
+    genOpenStatement(*builder, toLocation(), stmt);
+  }
+  void genFIR(const Pa::PrintStmt &stmt) {
+    llvm::SmallVector<M::Value *, 4> args;
+    for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
+      if (auto *parserExpr{std::get_if<Pa::Expr>(&item.u)}) {
+        auto loc{toLocation(parserExpr->source)};
+        args.push_back(createFIRExpr(loc, Se::GetExpr(*parserExpr)));
+      } else {
+        assert(false);  // TODO implied do
+      }
+    }
+    genPrintStatement(*builder, toLocation(), args);
+  }
+  void genFIR(const Pa::ReadStmt &stmt) {
+    genReadStatement(*builder, toLocation(), stmt);
+  }
+  void genFIR(const Pa::RewindStmt &stmt) {
+    genRewindStatement(*builder, toLocation(), stmt);
+  }
+  void genFIR(const Pa::WriteStmt &stmt) {
+    genWriteStatement(*builder, toLocation(), stmt);
+  }
+
   void genFIR(const Pa::AllocateStmt &) { SOFT_TODO(); }
   void genFIR(const Pa::AssignmentStmt &stmt) {
     auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
@@ -669,20 +708,8 @@ class FirConverter {
         createFIRExpr(toLocation(), rhs), createFIRAddr(toLocation(), lhs));
   }
 
-  void genFIR(const Pa::BackspaceStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
-  void genFIR(const Pa::CloseStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
   void genFIR(const Pa::ContinueStmt &) {}  // do nothing
   void genFIR(const Pa::DeallocateStmt &) { SOFT_TODO(); }
-  void genFIR(const Pa::EndfileStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
   void genFIR(const Pa::EventPostStmt &) {
     // call some runtime routine
     TODO();
@@ -691,14 +718,10 @@ class FirConverter {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::FlushStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
+
   void genFIR(const Pa::FormTeamStmt &) { TODO(); }
-  void genFIR(const Pa::InquireStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
+  void genFIR(const Pa::InquireStmt &stmt) {
+    genInquireStatement(*builder, toLocation(), stmt);
   }
   void genFIR(const Pa::LockStmt &) {
     // call some runtime routine
@@ -729,33 +752,8 @@ class FirConverter {
           po.u);
     }
   }
-  void genFIR(const Pa::OpenStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
   void genFIR(const Pa::PointerAssignmentStmt &) { SOFT_TODO(); }
 
-  void genFIR(const Pa::PrintStmt &stmt) {
-    L::SmallVector<mlir::Value *, 4> args;
-    for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
-      if (auto *parserExpr{std::get_if<Pa::Expr>(&item.u)}) {
-        auto loc{toLocation(parserExpr->source)};
-        args.push_back(createFIRExpr(loc, Se::GetExpr(*parserExpr)));
-      } else {
-        TODO();  // implied do
-      }
-    }
-    genPrintStatement(*builder, toLocation(), args);
-  }
-
-  void genFIR(const Pa::ReadStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
-  void genFIR(const Pa::RewindStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
   void genFIR(const Pa::SyncAllStmt &) {
     // call some runtime routine
     TODO();
@@ -777,10 +775,6 @@ class FirConverter {
     TODO();
   }
 
-  void genFIR(const Pa::WriteStmt &) {
-    // call some IO runtime routine(s)
-    TODO();
-  }
   void genFIR(const Pa::AssignStmt &) { TODO(); }
   void genFIR(const Pa::FormatStmt &) { TODO(); }
   void genFIR(const Pa::EntryStmt &) { TODO(); }
diff --git a/lib/burnside/io.cc b/lib/burnside/io.cc
index 038e022fa625..b8c3db23aa90 100644
--- a/lib/burnside/io.cc
+++ b/lib/burnside/io.cc
@@ -15,10 +15,19 @@
 #include "io.h"
 #include "builder.h"
 #include "runtime.h"
+#include "../parser/parse-tree.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
+#include <cassert>
 
-namespace Fortran::burnside {
+namespace Br = Fortran::burnside;
+namespace M = mlir;
+namespace Pa = Fortran::parser;
+
+using namespace Fortran;
+using namespace Fortran::burnside;
+
+namespace {
 
 /// Define actions to sort runtime functions. One actions
 /// may be associated to one or more runtime function.
@@ -32,7 +41,7 @@ class IORuntimeDescription : public RuntimeStaticDescription {
   constexpr IORuntimeDescription(
       IOAction act, const char *s, MaybeTypeCode r, TypeCodeVector a)
     : RuntimeStaticDescription{s, r, a}, key{act} {}
-  static mlir::Type getIOCookieType(mlir::MLIRContext *context) {
+  static M::Type getIOCookieType(M::MLIRContext *context) {
     return getMLIRType(TypeCode::IOCookie, context);
   }
   IOAction key;
@@ -66,7 +75,7 @@ static constexpr IORuntimeMap ioRuntimeMap{ioRuntimeTable};
 /// exactly one runtime function. This constraint is enforced
 /// at compile time. This search is resolved at compile time.
 template<IORuntimeDescription::Key key>
-static mlir::FuncOp getIORuntimeFunction(mlir::OpBuilder &builder) {
+static M::FuncOp getIORuntimeFunction(M::OpBuilder &builder) {
   static constexpr auto runtimeDescription{ioRuntimeMap.find(key)};
   static_assert(runtimeDescription != ioRuntimeMap.end());
   return runtimeDescription->getFuncOp(builder);
@@ -76,18 +85,17 @@ static mlir::FuncOp getIORuntimeFunction(mlir::OpBuilder &builder) {
 /// are mapped to Output IOAction that must be mapped to at least one
 /// runtime function but can be mapped to more functions.
 /// This helper returns the function that has the same
-/// mlir::FunctionType as the one seeked. It may therefore dynamically fail
-/// if no function mapped to the Action has the seeked mlir::FunctionType.
-static mlir::FuncOp getOutputRuntimeFunction(
-    mlir::OpBuilder &builder, mlir::Type type) {
+/// M::FunctionType as the one seeked. It may therefore dynamically fail
+/// if no function mapped to the Action has the seeked M::FunctionType.
+static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
   static constexpr auto descriptionRange{ioRuntimeMap.getRange(IOA::Output)};
   static_assert(!descriptionRange.empty());
 
-  mlir::MLIRContext *context{getModule(&builder).getContext()};
-  llvm::SmallVector<mlir::Type, 2> argTypes{
+  M::MLIRContext *context{getModule(&builder).getContext()};
+  llvm::SmallVector<M::Type, 2> argTypes{
       IORuntimeDescription::getIOCookieType(context), type};
 
-  mlir::FunctionType seekedType{mlir::FunctionType::get(argTypes, {}, context)};
+  M::FunctionType seekedType{M::FunctionType::get(argTypes, {}, context)};
   for (const auto &description : descriptionRange) {
     if (description.getMLIRFunctionType(context) == seekedType) {
       return description.getFuncOp(builder);
@@ -97,34 +105,79 @@ static mlir::FuncOp getOutputRuntimeFunction(
   return {};
 }
 
+}  // namespace
+
+void Br::genBackspaceStatement(
+    M::OpBuilder &, M::Location loc, const Pa::BackspaceStmt &) {
+  assert(false);
+}
+
+void Br::genCloseStatement(
+    M::OpBuilder &, M::Location loc, const Pa::CloseStmt &) {
+  assert(false);
+}
+
+void Br::genEndfileStatement(
+    M::OpBuilder &, M::Location loc, const Pa::EndfileStmt &) {
+  assert(false);
+}
+
+void Br::genFlushStatement(
+    M::OpBuilder &, M::Location loc, const Pa::FlushStmt &) {
+  assert(false);
+}
+
+void Br::genInquireStatement(
+    M::OpBuilder &, M::Location loc, const Pa::InquireStmt &) {
+  assert(false);
+}
+
+void Br::genOpenStatement(
+    M::OpBuilder &, M::Location loc, const Pa::OpenStmt &) {
+  assert(false);
+}
+
 /// Lower print statement assuming a dummy runtime interface for now.
-void genPrintStatement(mlir::OpBuilder &builder, mlir::Location loc,
-    llvm::ArrayRef<mlir::Value *> args) {
-  mlir::ModuleOp module{getModule(&builder)};
-  mlir::MLIRContext *mlirContext{module.getContext()};
+void Br::genPrintStatement(
+    M::OpBuilder &builder, M::Location loc, M::ValueRange args) {
+  M::ModuleOp module{getModule(&builder)};
+  M::MLIRContext *mlirContext{module.getContext()};
 
-  mlir::FuncOp beginFunc{
+  M::FuncOp beginFunc{
       getIORuntimeFunction<IOAction::BeginExternalList>(builder)};
 
   // Initiate io
-  mlir::Type externalUnitType{mlir::IntegerType::get(32, mlirContext)};
-  mlir::Value *defaultUnit{builder.create<mlir::ConstantOp>(
+  M::Type externalUnitType{M::IntegerType::get(32, mlirContext)};
+  M::Value *defaultUnit{builder.create<M::ConstantOp>(
       loc, builder.getIntegerAttr(externalUnitType, 1))};
-  llvm::SmallVector<mlir::Value *, 1> beginArgs{defaultUnit};
-  mlir::Value *cookie{
-      builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0)};
+  llvm::SmallVector<M::Value *, 1> beginArgs{defaultUnit};
+  M::Value *cookie{
+      builder.create<M::CallOp>(loc, beginFunc, beginArgs).getResult(0)};
 
   // Call data transfer runtime function
-  for (mlir::Value *arg : args) {
-    llvm::SmallVector<mlir::Value *, 1> operands{cookie, arg};
-    mlir::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg->getType())};
-    builder.create<mlir::CallOp>(loc, outputFunc, operands);
+  for (M::Value *arg : args) {
+    llvm::SmallVector<M::Value *, 1> operands{cookie, arg};
+    M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg->getType())};
+    builder.create<M::CallOp>(loc, outputFunc, operands);
   }
 
   // Terminate IO
-  mlir::FuncOp endIOFunc{getIORuntimeFunction<IOAction::EndIO>(builder)};
-  llvm::SmallVector<mlir::Value *, 1> endArgs{cookie};
-  builder.create<mlir::CallOp>(loc, endIOFunc, endArgs);
+  M::FuncOp endIOFunc{getIORuntimeFunction<IOAction::EndIO>(builder)};
+  llvm::SmallVector<M::Value *, 1> endArgs{cookie};
+  builder.create<M::CallOp>(loc, endIOFunc, endArgs);
+}
+
+void Br::genReadStatement(
+    M::OpBuilder &, M::Location loc, const Pa::ReadStmt &) {
+  assert(false);
+}
+
+void Br::genRewindStatement(
+    M::OpBuilder &, M::Location loc, const Pa::RewindStmt &) {
+  assert(false);
 }
 
+void Br::genWriteStatement(
+    M::OpBuilder &, M::Location loc, const Pa::WriteStmt &) {
+  assert(false);
 }
diff --git a/lib/burnside/io.h b/lib/burnside/io.h
index bae368609d9b..7f5d96d09b92 100644
--- a/lib/burnside/io.h
+++ b/lib/burnside/io.h
@@ -18,10 +18,22 @@
 namespace mlir {
 class OpBuilder;
 class Location;
-class Value;
+class ValueRange;
 }
-namespace llvm {
-template<typename T> class ArrayRef;
+
+namespace Fortran {
+
+namespace parser {
+struct BackspaceStmt;
+struct CloseStmt;
+struct EndfileStmt;
+struct FlushStmt;
+struct InquireStmt;
+struct OpenStmt;
+struct PrintStmt;
+struct ReadStmt;
+struct RewindStmt;
+struct WriteStmt;
 }
 
 /// Experimental IO lowering to FIR + runtime. The Runtime design is under
@@ -30,9 +42,31 @@ template<typename T> class ArrayRef;
 /// nodes and lower expressions as needed or should it get every expression
 /// already lowered as mlir::Value* ? (currently second options, not sure it
 /// will provide enough information for complex IO statements).
-namespace Fortran::burnside {
-void genPrintStatement(
-    mlir::OpBuilder &, mlir::Location loc, llvm::ArrayRef<mlir::Value *>);
+namespace burnside {
+
+class BridgeImpl;
+
+void genBackspaceStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::BackspaceStmt &);
+void genCloseStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::CloseStmt &);
+void genEndfileStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::EndfileStmt &);
+void genFlushStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::FlushStmt &);
+void genInquireStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::InquireStmt &);
+void genOpenStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::OpenStmt &);
+void genPrintStatement(mlir::OpBuilder &, mlir::Location, mlir::ValueRange);
+void genReadStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::ReadStmt &);
+void genRewindStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::RewindStmt &);
+void genWriteStatement(
+    mlir::OpBuilder &, mlir::Location, const parser::WriteStmt &);
+
+}
 }
 
 #endif  // FORTRAN_BURNSIDE_IO_H_
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index f8147d848bff..38a42db10dca 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -1403,9 +1403,8 @@ void genCaseLadderStep(M::Location loc, M::Value *cmp, M::Block *dest,
   auto *newBlock = rewriter.createBlock(dest);
   rewriter.setInsertionPointToEnd(thisBlock);
   L::SmallVector<M::Block *, 2> dest_{dest, newBlock};
-  L::SmallVector<L::ArrayRef<M::Value *>, 2> destOps_{destOps, {}};
-  rewriter.create<M::LLVM::CondBrOp>(loc, L::ArrayRef<M::Value *>{cmp}, dest_,
-                                     destOps_);
+  L::SmallVector<M::ValueRange, 2> destOps_{destOps, {}};
+  rewriter.create<M::LLVM::CondBrOp>(loc, M::ValueRange{cmp}, dest_, destOps_);
   rewriter.setInsertionPointToEnd(newBlock);
 }
 
@@ -1460,24 +1459,24 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
         auto *newBlock2 = rewriter.createBlock(destinations[t]);
         rewriter.setInsertionPointToEnd(thisBlock);
         L::SmallVector<M::Block *, 2> dests{newBlock1, newBlock2};
-        L::SmallVector<L::ArrayRef<M::Value *>, 2> destOps{{}, {}};
-        rewriter.create<M::LLVM::CondBrOp>(loc, L::ArrayRef<M::Value *>{cmp},
-                                           dests, destOps);
+        L::SmallVector<M::ValueRange, 2> destOps{{}, {}};
+        rewriter.create<M::LLVM::CondBrOp>(loc, M::ValueRange{cmp}, dests,
+                                           destOps);
         rewriter.setInsertionPointToEnd(newBlock1);
-        auto cmp2 = rewriter.create<M::LLVM::ICmpOp>(
+        auto cmp_ = rewriter.create<M::LLVM::ICmpOp>(
             loc, M::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
         L::SmallVector<M::Block *, 2> dest2{destinations[t], newBlock2};
-        L::SmallVector<L::ArrayRef<M::Value *>, 2> destOp2{destOperands[t], {}};
-        rewriter.create<M::LLVM::CondBrOp>(loc, L::ArrayRef<M::Value *>{cmp2},
-                                           dest2, destOp2);
+        L::SmallVector<M::ValueRange, 2> destOp2{destOperands[t], {}};
+        rewriter.create<M::LLVM::CondBrOp>(loc, M::ValueRange{cmp_}, dest2,
+                                           destOp2);
         rewriter.setInsertionPointToEnd(newBlock2);
         continue;
       }
       assert(attr.dyn_cast_or_null<M::UnitAttr>());
       assert((t + 1 == conds) && "unit must be last");
-      L::SmallVector<M::Value *, 1> empty;
       rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(
-          selectcase, empty, destinations[t], destOperands[t]);
+          selectcase, M::ValueRange{}, destinations[t],
+          M::ValueRange{destOperands[t]});
     }
     return matchSuccess();
   }
@@ -1514,9 +1513,9 @@ void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, M::Operation *op,
     }
     assert(attr.template dyn_cast_or_null<M::UnitAttr>());
     assert((t + 1 == conds) && "unit must be last");
-    L::SmallVector<M::Value *, 1> empty;
-    rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(select, empty, destinations[t],
-                                               destOperands[t]);
+    rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(
+        select, M::ValueRange{}, destinations[t],
+        M::ValueRange{destOperands[t]});
   }
 }
 
@@ -1643,10 +1642,9 @@ struct UnreachableOpConversion : public FIROpConversion<UnreachableOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto unreach = M::cast<UnreachableOp>(op);
-    L::SmallVector<M::Block *, 1> destinations; // none
-    L::SmallVector<OperandTy, 1> destOperands;  // none
     rewriter.replaceOpWithNewOp<M::LLVM::UnreachableOp>(
-        unreach, operands, destinations, destOperands, unreach.getAttrs());
+        unreach, operands, L::ArrayRef<M::Block *>{},
+        L::ArrayRef<M::ValueRange>{}, unreach.getAttrs());
     return matchSuccess();
   }
 };

From 2b210b582cbf2d01d528c83115ad591c4a2c4e99 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 10 Dec 2019 13:47:08 -0800
Subject: [PATCH 136/345] introduce AbstractConverter

---
 lib/burnside/bridge.cc | 113 ++++++++++++++++++++---------------------
 lib/burnside/bridge.h  |  67 ++++++++++++++++++++++--
 lib/burnside/io.cc     |  86 +++++++++++++++++--------------
 lib/burnside/io.h      |  30 ++++-------
 4 files changed, 176 insertions(+), 120 deletions(-)

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index baa47db943ac..f255ff7476f2 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -72,7 +72,7 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 ///
 /// After building the AST and decorating it, the FirConverter processes that
 /// representation and lowers it to the FIR executable representation.
-class FirConverter {
+class FirConverter : public AbstractConverter {
   using LabelMapType = std::map<AST::Evaluation *, M::Block *>;
   using Closure = std::function<void(const LabelMapType &)>;
 
@@ -357,8 +357,7 @@ class FirConverter {
 
   M::Value *genFIRLoopIndex(const Pa::ScalarExpr &x) {
     return builder->create<fir::ConvertOp>(toLocation(),
-        M::IndexType::get(&mlirContext),
-        createFIRExpr(toLocation(), Se::GetExpr(x)));
+        M::IndexType::get(&mlirContext), genExprValue(*Se::GetExpr(x)));
   }
 
   /// Structured control op (`fir.loop`, `fir.where`)
@@ -387,15 +386,13 @@ class FirConverter {
                     M::Value *hi = genFIRLoopIndex(x.upper);
                     L::SmallVector<M::Value *, 1> step;
                     if (x.step.has_value()) {
-                      step.emplace_back(
-                          createFIRExpr(toLocation(), Se::GetExpr(*x.step)));
+                      step.emplace_back(genExprValue(*Se::GetExpr(*x.step)));
                     }
                     doLoop = builder->create<fir::LoopOp>(
                         toLocation(), lo, hi, step);
                     builder->setInsertionPointToStart(doLoop.getBody());
                     auto *sym{x.name.thing.symbol};
-                    auto ty{
-                        translateSymbolToFIRType(&mlirContext, defaults, *sym)};
+                    auto ty{genType(*sym)};
                     // TODO: should push this cast down to the uses
                     auto cvt{builder->create<fir::ConvertOp>(
                         toLocation(), ty, doLoop.getInductionVar())};
@@ -507,8 +504,7 @@ class FirConverter {
     for (auto *d : argsList) {
       Se::SymbolRef sr{*d};
       // FIXME:
-      argTy.push_back(fir::ReferenceType::get(
-          translateSymbolToFIRType(&mlirContext, defaults, sr)));
+      argTy.push_back(fir::ReferenceType::get(genType(sr)));
     }
     auto funTy{M::FunctionType::get(argTy, resTy, builder->getContext())};
     // FIXME: mangle name
@@ -520,9 +516,8 @@ class FirConverter {
       M::Value *fe{nullptr};
       std::visit(Co::visitors{
                      [&](const Co::Indirection<Pa::Expr> &e) {
-                       auto *exp{Se::GetExpr(e)};
                        // FIXME: needs to match argument, assumes trivial by-ref
-                       fe = createFIRAddr(toLocation(), exp);
+                       fe = genExprAddr(*Se::GetExpr(e));
                      },
                      [](const Pa::AltReturnSpec &) { TODO(); },
                      [](const Pa::ActualArg::PercentRef &) { TODO(); },
@@ -545,14 +540,14 @@ class FirConverter {
   void genFIR(const Pa::WhereStmt &) { TODO(); }
   void genFIR(const Pa::ComputedGotoStmt &stmt) {
     auto *exp{Se::GetExpr(std::get<Pa::ScalarIntExpr>(stmt.t))};
-    auto *e1{createFIRExpr(toLocation(), exp)};
+    auto *e1{genExprValue(*exp)};
     (void)e1;
     TODO();
   }
   void genFIR(const Pa::ForallStmt &) { TODO(); }
   void genFIR(const Pa::ArithmeticIfStmt &stmt) {
     auto *exp{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
-    auto *e1{createFIRExpr(toLocation(), exp)};
+    auto *e1{genExprValue(*exp)};
     (void)e1;
     TODO();
   }
@@ -664,48 +659,24 @@ class FirConverter {
   // IO statements (see io.h)
 
   void genFIR(const Pa::BackspaceStmt &stmt) {
-    genBackspaceStatement(*builder, toLocation(), stmt);
-  }
-  void genFIR(const Pa::CloseStmt &stmt) {
-    genCloseStatement(*builder, toLocation(), stmt);
-  }
-  void genFIR(const Pa::EndfileStmt &stmt) {
-    genEndfileStatement(*builder, toLocation(), stmt);
-  }
-  void genFIR(const Pa::FlushStmt &stmt) {
-    genFlushStatement(*builder, toLocation(), stmt);
-  }
-  void genFIR(const Pa::OpenStmt &stmt) {
-    genOpenStatement(*builder, toLocation(), stmt);
-  }
-  void genFIR(const Pa::PrintStmt &stmt) {
-    llvm::SmallVector<M::Value *, 4> args;
-    for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
-      if (auto *parserExpr{std::get_if<Pa::Expr>(&item.u)}) {
-        auto loc{toLocation(parserExpr->source)};
-        args.push_back(createFIRExpr(loc, Se::GetExpr(*parserExpr)));
-      } else {
-        assert(false);  // TODO implied do
-      }
-    }
-    genPrintStatement(*builder, toLocation(), args);
-  }
-  void genFIR(const Pa::ReadStmt &stmt) {
-    genReadStatement(*builder, toLocation(), stmt);
-  }
-  void genFIR(const Pa::RewindStmt &stmt) {
-    genRewindStatement(*builder, toLocation(), stmt);
-  }
-  void genFIR(const Pa::WriteStmt &stmt) {
-    genWriteStatement(*builder, toLocation(), stmt);
-  }
+    genBackspaceStatement(*this, stmt);
+  }
+  void genFIR(const Pa::CloseStmt &stmt) { genCloseStatement(*this, stmt); }
+  void genFIR(const Pa::EndfileStmt &stmt) { genEndfileStatement(*this, stmt); }
+  void genFIR(const Pa::FlushStmt &stmt) { genFlushStatement(*this, stmt); }
+  void genFIR(const Pa::InquireStmt &stmt) { genInquireStatement(*this, stmt); }
+  void genFIR(const Pa::OpenStmt &stmt) { genOpenStatement(*this, stmt); }
+  void genFIR(const Pa::PrintStmt &stmt) { genPrintStatement(*this, stmt); }
+  void genFIR(const Pa::ReadStmt &stmt) { genReadStatement(*this, stmt); }
+  void genFIR(const Pa::RewindStmt &stmt) { genRewindStatement(*this, stmt); }
+  void genFIR(const Pa::WriteStmt &stmt) { genWriteStatement(*this, stmt); }
 
   void genFIR(const Pa::AllocateStmt &) { SOFT_TODO(); }
   void genFIR(const Pa::AssignmentStmt &stmt) {
     auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
     auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
-    builder->create<fir::StoreOp>(toLocation(),
-        createFIRExpr(toLocation(), rhs), createFIRAddr(toLocation(), lhs));
+    builder->create<fir::StoreOp>(
+        toLocation(), genExprValue(*rhs), genExprAddr(*lhs));
   }
 
   void genFIR(const Pa::ContinueStmt &) {}  // do nothing
@@ -720,9 +691,6 @@ class FirConverter {
   }
 
   void genFIR(const Pa::FormTeamStmt &) { TODO(); }
-  void genFIR(const Pa::InquireStmt &stmt) {
-    genInquireStatement(*builder, toLocation(), stmt);
-  }
   void genFIR(const Pa::LockStmt &) {
     // call some runtime routine
     TODO();
@@ -736,8 +704,7 @@ class FirConverter {
     for (auto &po : stmt.v) {
       std::visit(Co::visitors{
                      [&](const Pa::Name &sym) {
-                       auto ty{translateSymbolToFIRType(
-                           &mlirContext, defaults, *sym.symbol)};
+                       auto ty{genType(*sym.symbol)};
                        auto load{builder->create<fir::LoadOp>(toLocation(),
                            localSymbols.lookupSymbol(*sym.symbol))};
                        auto idxTy{M::IndexType::get(&mlirContext)};
@@ -866,15 +833,14 @@ class FirConverter {
       assert(details && "details for semantics::Symbol must be subprogram");
       for (auto *a : details->dummyArgs()) {
         if (a) {  // nullptr indicates alternate return argument
-          auto type{translateSymbolToFIRType(&mlirContext, defaults, *a)};
+          auto type{genType(*a)};
           args.push_back(fir::ReferenceType::get(type));
         }
       }
       if (details->isFunction()) {
         // FIXME: handle subroutines that return magic values
         auto result{details->result()};
-        results.push_back(
-            translateSymbolToFIRType(&mlirContext, defaults, result));
+        results.push_back(genType(result));
       }
     }
     auto funcTy{M::FunctionType::get(args, results, &mlirContext)};
@@ -1074,6 +1040,7 @@ class FirConverter {
   FirConverter() = delete;
   FirConverter(const FirConverter &) = delete;
   FirConverter &operator=(const FirConverter &) = delete;
+  virtual ~FirConverter() = default;
 
   explicit FirConverter(BurnsideBridge &bridge, fir::NameMangler &mangler)
     : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
@@ -1104,6 +1071,36 @@ class FirConverter {
           u);
     }
   }
+
+  //
+  // AbstractConverter overrides
+
+  M::Value *genExprAddr(
+      const SomeExpr &expr, M::Location *loc = nullptr) override {
+    return createFIRAddr(loc ? *loc : toLocation(), &expr);
+  }
+  M::Value *genExprValue(
+      const SomeExpr &expr, M::Location *loc = nullptr) override {
+    return createFIRExpr(loc ? *loc : toLocation(), &expr);
+  }
+
+  M::Type genType(const Ev::DataRef &data) override {
+    return translateDataRefToFIRType(&mlirContext, defaults, data);
+  }
+  M::Type genType(const SomeExpr &expr) override {
+    return translateSomeExprToFIRType(&mlirContext, defaults, &expr);
+  }
+  M::Type genType(const SymbolRef &sym) override {
+    return translateSymbolToFIRType(&mlirContext, defaults, sym);
+  }
+
+  M::Location getCurrentLocation() override { return toLocation(); }
+  M::Location genLocation() override { return dummyLoc(mlirContext); }
+  M::Location genLocation(const Pa::CharBlock &block) override {
+    return parserPosToLoc(mlirContext, cooked, block);
+  }
+
+  M::OpBuilder &getOpBuilder() override { return *builder; }
 };
 
 }  // namespace
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index 58207be1a542..0ec81b7d569e 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -24,26 +24,85 @@
 ///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-namespace Fortran::common {
+namespace Fortran {
+namespace common {
 class IntrinsicTypeDefaultKinds;
+template<typename> class Reference;
 }
-
-namespace Fortran::parser {
+namespace evaluate {
+struct DataRef;
+template<typename> class Expr;
+struct SomeType;
+}
+namespace parser {
+class CharBlock;
 class CookedSource;
 struct Program;
 }
+namespace semantics {
+class Symbol;
+}
+}  // namespace Fortran
 
 namespace llvm {
 class Module;
 class SourceMgr;
 }
-
+namespace mlir {
+class OpBuilder;
+}
 namespace fir {
 struct NameMangler;
 }
 
 namespace Fortran::burnside {
 
+using SomeExpr = evaluate::Expr<evaluate::SomeType>;
+using SymbolRef = common::Reference<const semantics::Symbol>;
+
+/// The abstract interface for converter implementations to lower Fortran
+/// front-end fragments such as expressions, types, etc.
+class AbstractConverter {
+public:
+  //
+  // Expressions
+
+  /// Generate the address of the location holding the expression
+  virtual mlir::Value *genExprAddr(
+      const SomeExpr &, mlir::Location *loc = nullptr) = 0;
+  /// Generate the computations of the expression to produce a value
+  virtual mlir::Value *genExprValue(
+      const SomeExpr &, mlir::Location *loc = nullptr) = 0;
+
+  //
+  // Types
+
+  /// Generate the type of a DataRef
+  virtual mlir::Type genType(const evaluate::DataRef &) = 0;
+  /// Generate the type of an Expr
+  virtual mlir::Type genType(const SomeExpr &) = 0;
+  /// Generate the type of a Symbol
+  virtual mlir::Type genType(const SymbolRef &) = 0;
+
+  //
+  // Locations
+
+  /// Get the converter's current location
+  virtual mlir::Location getCurrentLocation() = 0;
+  /// Generate a dummy location
+  virtual mlir::Location genLocation() = 0;
+  /// Generate the location as converted from a CharBlock
+  virtual mlir::Location genLocation(const parser::CharBlock &) = 0;
+
+  //
+  // FIR/MLIR
+
+  /// Get the OpBuilder
+  virtual mlir::OpBuilder &getOpBuilder() = 0;
+
+  virtual ~AbstractConverter() = default;
+};
+
 class BurnsideBridge {
 public:
   static BurnsideBridge create(
diff --git a/lib/burnside/io.cc b/lib/burnside/io.cc
index b8c3db23aa90..3d4a847bf06d 100644
--- a/lib/burnside/io.cc
+++ b/lib/burnside/io.cc
@@ -13,9 +13,11 @@
 // limitations under the License.
 
 #include "io.h"
+#include "bridge.h"
 #include "builder.h"
 #include "runtime.h"
 #include "../parser/parse-tree.h"
+#include "../semantics/tools.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
 #include <cassert>
@@ -105,40 +107,8 @@ static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
   return {};
 }
 
-}  // namespace
-
-void Br::genBackspaceStatement(
-    M::OpBuilder &, M::Location loc, const Pa::BackspaceStmt &) {
-  assert(false);
-}
-
-void Br::genCloseStatement(
-    M::OpBuilder &, M::Location loc, const Pa::CloseStmt &) {
-  assert(false);
-}
-
-void Br::genEndfileStatement(
-    M::OpBuilder &, M::Location loc, const Pa::EndfileStmt &) {
-  assert(false);
-}
-
-void Br::genFlushStatement(
-    M::OpBuilder &, M::Location loc, const Pa::FlushStmt &) {
-  assert(false);
-}
-
-void Br::genInquireStatement(
-    M::OpBuilder &, M::Location loc, const Pa::InquireStmt &) {
-  assert(false);
-}
-
-void Br::genOpenStatement(
-    M::OpBuilder &, M::Location loc, const Pa::OpenStmt &) {
-  assert(false);
-}
-
 /// Lower print statement assuming a dummy runtime interface for now.
-void Br::genPrintStatement(
+void lowerPrintStatement(
     M::OpBuilder &builder, M::Location loc, M::ValueRange args) {
   M::ModuleOp module{getModule(&builder)};
   M::MLIRContext *mlirContext{module.getContext()};
@@ -167,17 +137,55 @@ void Br::genPrintStatement(
   builder.create<M::CallOp>(loc, endIOFunc, endArgs);
 }
 
-void Br::genReadStatement(
-    M::OpBuilder &, M::Location loc, const Pa::ReadStmt &) {
+}  // namespace
+
+void Br::genBackspaceStatement(AbstractConverter &, const Pa::BackspaceStmt &) {
+  assert(false);
+}
+
+void Br::genCloseStatement(AbstractConverter &, const Pa::CloseStmt &) {
+  assert(false);
+}
+
+void Br::genEndfileStatement(AbstractConverter &, const Pa::EndfileStmt &) {
+  assert(false);
+}
+
+void Br::genFlushStatement(AbstractConverter &, const Pa::FlushStmt &) {
+  assert(false);
+}
+
+void Br::genInquireStatement(AbstractConverter &, const Pa::InquireStmt &) {
+  assert(false);
+}
+
+void Br::genOpenStatement(AbstractConverter &, const Pa::OpenStmt &) {
+  assert(false);
+}
+
+void Br::genPrintStatement(
+    Br::AbstractConverter &converter, const Pa::PrintStmt &stmt) {
+  llvm::SmallVector<M::Value *, 4> args;
+  for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
+    if (auto *pe{std::get_if<Pa::Expr>(&item.u)}) {
+      auto loc{converter.genLocation(pe->source)};
+      args.push_back(converter.genExprValue(*semantics::GetExpr(*pe), &loc));
+    } else {
+      assert(false);  // TODO implied do
+    }
+  }
+  lowerPrintStatement(
+      converter.getOpBuilder(), converter.getCurrentLocation(), args);
+}
+
+void Br::genReadStatement(AbstractConverter &, const Pa::ReadStmt &) {
   assert(false);
 }
 
-void Br::genRewindStatement(
-    M::OpBuilder &, M::Location loc, const Pa::RewindStmt &) {
+void Br::genRewindStatement(AbstractConverter &, const Pa::RewindStmt &) {
   assert(false);
 }
 
-void Br::genWriteStatement(
-    M::OpBuilder &, M::Location loc, const Pa::WriteStmt &) {
+void Br::genWriteStatement(AbstractConverter &, const Pa::WriteStmt &) {
   assert(false);
 }
diff --git a/lib/burnside/io.h b/lib/burnside/io.h
index 7f5d96d09b92..8a425529ca79 100644
--- a/lib/burnside/io.h
+++ b/lib/burnside/io.h
@@ -44,27 +44,19 @@ struct WriteStmt;
 /// will provide enough information for complex IO statements).
 namespace burnside {
 
+class AbstractConverter;
 class BridgeImpl;
 
-void genBackspaceStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::BackspaceStmt &);
-void genCloseStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::CloseStmt &);
-void genEndfileStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::EndfileStmt &);
-void genFlushStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::FlushStmt &);
-void genInquireStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::InquireStmt &);
-void genOpenStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::OpenStmt &);
-void genPrintStatement(mlir::OpBuilder &, mlir::Location, mlir::ValueRange);
-void genReadStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::ReadStmt &);
-void genRewindStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::RewindStmt &);
-void genWriteStatement(
-    mlir::OpBuilder &, mlir::Location, const parser::WriteStmt &);
+void genBackspaceStatement(AbstractConverter &, const parser::BackspaceStmt &);
+void genCloseStatement(AbstractConverter &, const parser::CloseStmt &);
+void genEndfileStatement(AbstractConverter &, const parser::EndfileStmt &);
+void genFlushStatement(AbstractConverter &, const parser::FlushStmt &);
+void genInquireStatement(AbstractConverter &, const parser::InquireStmt &);
+void genOpenStatement(AbstractConverter &, const parser::OpenStmt &);
+void genPrintStatement(AbstractConverter &, const parser::PrintStmt &);
+void genReadStatement(AbstractConverter &, const parser::ReadStmt &);
+void genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
+void genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
 
 }
 }

From a41fa9726edaf82ed4eda58a5d89fc48c90dc927 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 10 Dec 2019 16:37:29 -0800
Subject: [PATCH 137/345] start threading name mangler fix parent bug remove
 lazy string building in name uniquer

---
 include/fir/InternalNames.h  |  30 ++++-----
 lib/burnside/CMakeLists.txt  |   1 +
 lib/burnside/bridge.cc       |  49 ++++++++++-----
 lib/burnside/bridge.h        |   2 +
 lib/burnside/builder.cc      |  52 ++++++++-------
 lib/burnside/builder.h       |  17 ++---
 lib/burnside/convert-type.cc |  20 +-----
 lib/burnside/convert-type.h  |  15 +----
 lib/burnside/mangler.cc      | 100 +++++++++++++++++++++++++++++
 lib/burnside/mangler.h       |  51 +++++++++++++++
 lib/fir/InternalNames.cpp    | 118 ++++++++++++++++++++---------------
 11 files changed, 313 insertions(+), 142 deletions(-)
 create mode 100644 lib/burnside/mangler.cc
 create mode 100644 lib/burnside/mangler.h

diff --git a/include/fir/InternalNames.h b/include/fir/InternalNames.h
index 48ceb870ebca..49637e26d47c 100644
--- a/include/fir/InternalNames.h
+++ b/include/fir/InternalNames.h
@@ -35,56 +35,56 @@ struct NameMangler {
   NameMangler() = default;
 
   /// Mangle a common block name
-  llvm::Twine doCommonBlock(llvm::StringRef name);
+  std::string doCommonBlock(llvm::StringRef name);
 
   /// Mangle a (global) constant name
-  llvm::Twine doConstant(llvm::ArrayRef<llvm::StringRef> modules,
+  std::string doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                          llvm::StringRef name);
 
   /// Mangle a dispatch table name
-  llvm::Twine doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
+  std::string doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
                               llvm::Optional<llvm::StringRef> host,
                               llvm::StringRef name,
                               llvm::ArrayRef<std::int64_t> kinds);
 
   /// Mangle a compiler generated name
-  llvm::Twine doGenerated(llvm::StringRef name);
+  std::string doGenerated(llvm::StringRef name);
 
   /// Mangle an intrinsic type descriptor
-  llvm::Twine doIntrinsicTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+  std::string doIntrinsicTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                                         llvm::Optional<llvm::StringRef> host,
                                         IntrinsicType type, std::int64_t kind);
 
   /// Mangle a procedure name
-  llvm::Twine doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
+  std::string doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
                           llvm::Optional<llvm::StringRef> host,
                           llvm::StringRef name);
 
   /// Mangle a derived type name
-  llvm::Twine doType(llvm::ArrayRef<llvm::StringRef> modules,
+  std::string doType(llvm::ArrayRef<llvm::StringRef> modules,
                      llvm::Optional<llvm::StringRef> host, llvm::StringRef name,
                      llvm::ArrayRef<std::int64_t> kinds);
 
   /// Mangle a (derived) type descriptor name
-  llvm::Twine doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+  std::string doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                                llvm::Optional<llvm::StringRef> host,
                                llvm::StringRef name,
                                llvm::ArrayRef<std::int64_t> kinds);
 
   /// Mangle a (global) variable name
-  llvm::Twine doVariable(llvm::ArrayRef<llvm::StringRef> modules,
+  std::string doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                          llvm::StringRef name);
 
   /// Entry point for the PROGRAM (called by the runtime)
-  constexpr static llvm::StringRef getProgramEntry() {
-    return "__MAIN";
+  constexpr static llvm::StringRef doProgramEntry() {
+    return "MAIN_";
   }
 
 private:
-  llvm::Twine addAsString(std::int64_t i);
-  llvm::Twine doKind(std::int64_t kind);
-  llvm::Twine doKinds(llvm::ArrayRef<std::int64_t> kinds);
-  llvm::Twine toLower(llvm::StringRef name);
+  llvm::StringRef addAsString(std::int64_t i);
+  std::string doKind(std::int64_t kind);
+  std::string doKinds(llvm::ArrayRef<std::int64_t> kinds);
+  llvm::StringRef toLower(llvm::StringRef name);
 
   llvm::StringSet<> cache;
 };
diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
index cdbdfbffa227..9844363ac39e 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/burnside/CMakeLists.txt
@@ -21,6 +21,7 @@ add_library(FortranBurnside
   convert-expr.cc
   convert-type.cc
   intrinsics.cc
+  mangler.cc
   runtime.cc
   io.cc
 )
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index f255ff7476f2..5607189dc746 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -19,6 +19,7 @@
 #include "convert-type.h"
 #include "intrinsics.h"
 #include "io.h"
+#include "mangler.h"
 #include "runtime.h"
 #include "../parser/parse-tree.h"
 #include "../semantics/tools.h"
@@ -94,6 +95,10 @@ class FirConverter : public AbstractConverter {
         loc, *builder, *expr, localSymbols, defaults, intrinsics);
   }
 
+  std::string mangledName(SymbolRef symbol) {
+    return mangle::mangleName(mangler, symbol);
+  }
+
   // TODO: we need a map for the various Fortran runtime entry points
   M::FuncOp genRuntimeFunction(RuntimeEntryCode rec, int kind) {
     return genFunctionFIR(
@@ -104,7 +109,7 @@ class FirConverter : public AbstractConverter {
     if (auto func{getNamedFunction(module, callee)}) {
       return func;
     }
-    return createFunction(module, callee, funcTy);
+    return createFunction(*this, callee, funcTy);
   }
 
   static bool inMainProgram(AST::Evaluation *cstr) {
@@ -186,7 +191,7 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::Statement<Pa::ProgramStmt> &stmt, std::string &name,
       const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
-    name = mangler.getProgramEntry();
+    name = mangler.doProgramEntry();
   }
   void genFIR(const Pa::Statement<Pa::EndProgramStmt> &stmt, std::string &,
       const Se::Symbol *&) {
@@ -199,7 +204,7 @@ class FirConverter : public AbstractConverter {
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
-    name = applyNameMangling(*symbol);  // FIXME: use NameMangler
+    name = mangledName(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
       const Se::Symbol *&) {
@@ -212,7 +217,7 @@ class FirConverter : public AbstractConverter {
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
-    name = applyNameMangling(*symbol);  // FIXME: use NameMangler
+    name = mangledName(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::EndSubroutineStmt> &stmt, std::string &,
       const Se::Symbol *&) {
@@ -257,17 +262,17 @@ class FirConverter : public AbstractConverter {
     builder->create<M::ReturnOp>(toLocation(), r);
   }
   void genFIR(const Pa::EndFunctionStmt &stmt) {
-    genFIRFunctionReturn(inFunction(currentEvaluation));
+    genFIRFunctionReturn(static_cast<const Pa::FunctionStmt *>(nullptr));
   }
   template<typename A> void genFIRProcedureExit(const A *) {
     // FIXME: alt-returns
     builder->create<M::ReturnOp>(toLocation());
   }
   void genFIR(const Pa::EndSubroutineStmt &stmt) {
-    genFIRProcedureExit(inSubroutine(currentEvaluation));
+    genFIRProcedureExit(static_cast<const Pa::SubroutineStmt *>(nullptr));
   }
   void genFIR(const Pa::EndMpSubprogramStmt &stmt) {
-    genFIRProcedureExit(inMPSubp(currentEvaluation));
+    genFIRProcedureExit(static_cast<const Pa::MpSubprogramStmt *>(nullptr));
   }
 
   //
@@ -474,7 +479,7 @@ class FirConverter : public AbstractConverter {
       assert(func.getType() == ty);
       return func;
     }
-    return createFunction(module, name, ty);
+    return createFunction(*this, name, ty);
   }
 
   /// Lowering of CALL statement
@@ -844,7 +849,7 @@ class FirConverter : public AbstractConverter {
       }
     }
     auto funcTy{M::FunctionType::get(args, results, &mlirContext)};
-    return createFunction(module, name, funcTy);
+    return createFunction(*this, name, funcTy);
   }
 
   /// Prepare to translate a new function
@@ -901,10 +906,11 @@ class FirConverter : public AbstractConverter {
 
     assert((size == 1 || size == 2) && "ill-formed subprogram");
     if (size == 2) {
+      currentEvaluation = nullptr;
       std::visit(
           [&](auto *p) { genFIR(*p, name, symbol); }, func.funStmts.front());
     } else {
-      name = mangler.getProgramEntry();
+      name = mangler.doProgramEntry();
     }
 
     startNewFunction(func, name, symbol);
@@ -913,6 +919,7 @@ class FirConverter : public AbstractConverter {
     for (auto &e : func.evals) {
       lowerEval(e);
     }
+    currentEvaluation = nullptr;
     std::visit(
         [&](auto *p) { genFIR(*p, name, symbol); }, func.funStmts.back());
 
@@ -983,9 +990,7 @@ class FirConverter : public AbstractConverter {
   //
 
   /// Convert a parser CharBlock to a Location
-  M::Location toLocation(const Pa::CharBlock &cb) {
-    return parserPosToLoc(mlirContext, cooked, cb);
-  }
+  M::Location toLocation(const Pa::CharBlock &cb) { return genLocation(cb); }
 
   M::Location toLocation() { return toLocation(currentPosition); }
 
@@ -1034,7 +1039,7 @@ class FirConverter : public AbstractConverter {
   Pa::CharBlock currentPosition;
   CFGMapType cfgMap;
   std::list<CFGSinkListType> cfgEdgeSetPool;
-  AST::Evaluation *currentEvaluation;  // FIXME: this is a hack
+  AST::Evaluation *currentEvaluation{nullptr};  // FIXME: this is a hack
 
 public:
   FirConverter() = delete;
@@ -1095,12 +1100,24 @@ class FirConverter : public AbstractConverter {
   }
 
   M::Location getCurrentLocation() override { return toLocation(); }
-  M::Location genLocation() override { return dummyLoc(mlirContext); }
+  M::Location genLocation() override {
+    return M::UnknownLoc::get(&mlirContext);
+  }
   M::Location genLocation(const Pa::CharBlock &block) override {
-    return parserPosToLoc(mlirContext, cooked, block);
+    if (cooked) {
+      auto loc{cooked->GetSourcePositionRange(block)};
+      if (loc.has_value()) {
+        // loc is a pair (begin, end); use the beginning position
+        auto &filePos{loc->first};
+        return M::FileLineColLoc::get(
+            filePos.file.path(), filePos.line, filePos.column, &mlirContext);
+      }
+    }
+    return genLocation();
   }
 
   M::OpBuilder &getOpBuilder() override { return *builder; }
+  M::ModuleOp &getModuleOp() override { return module; }
 };
 
 }  // namespace
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index 0ec81b7d569e..52fba728845d 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -99,6 +99,8 @@ class AbstractConverter {
 
   /// Get the OpBuilder
   virtual mlir::OpBuilder &getOpBuilder() = 0;
+  /// Get the ModuleOp
+  virtual mlir::ModuleOp &getModuleOp() = 0;
 
   virtual ~AbstractConverter() = default;
 };
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index e768ad0ecec4..e064fb365641 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -20,17 +20,22 @@
 #include "mlir/IR/Value.h"
 
 namespace B = Fortran::burnside;
+namespace Ev = Fortran::evaluate;
+namespace M = mlir;
+namespace Se = Fortran::semantics;
 
 using namespace Fortran;
-using namespace B;
+using namespace Fortran::burnside;
 
+#if 0
 // This will need to be extended to consider the type of what is being mangled
 std::string B::applyNameMangling(llvm::StringRef parserName) {
   // FIXME: this is fake for now, add type info, etc.
   return "_Qp_"s + parserName.str();
 }
+#endif
 
-std::string B::applyNameMangling(const evaluate::ProcedureDesignator &proc) {
+std::string B::applyNameMangling(const Ev::ProcedureDesignator &proc) {
   if (const auto *symbol{proc.GetSymbol()}) {
     return applyNameMangling(*symbol);
   } else {
@@ -41,7 +46,7 @@ std::string B::applyNameMangling(const evaluate::ProcedureDesignator &proc) {
   }
 }
 
-std::string B::applyNameMangling(semantics::SymbolRef symbol) {
+std::string B::applyNameMangling(Se::SymbolRef symbol) {
   // FIXME: this is fake for now, add type info, etc.
   // For now, only works for external procedures
   // TODO: apply binding
@@ -50,14 +55,14 @@ std::string B::applyNameMangling(semantics::SymbolRef symbol) {
   // TODO: Apply proposed mangling with _Qp_ ....
   return std::visit(
       common::visitors{
-          [&](const semantics::MainProgramDetails &) { return "MAIN_"s; },
-          [&](const semantics::SubprogramDetails &) {
+          [&](const Se::MainProgramDetails &) { return "MAIN_"s; },
+          [&](const Se::SubprogramDetails &) {
             return symbol->name().ToString() + "_";
           },
-          [&](const semantics::ProcEntityDetails &) {
+          [&](const Se::ProcEntityDetails &) {
             return symbol->name().ToString() + "_";
           },
-          [&](const semantics::SubprogramNameDetails &) {
+          [&](const Se::SubprogramNameDetails &) {
             assert(false &&
                 "SubprogramNameDetails not expected after semantic analysis");
             return ""s;
@@ -70,36 +75,39 @@ std::string B::applyNameMangling(semantics::SymbolRef symbol) {
       symbol->details());
 }
 
-mlir::FuncOp B::createFunction(mlir::ModuleOp module, llvm::StringRef name,
-    mlir::FunctionType funcTy, parser::CookedSource const *cooked,
-    parser::CharBlock const *cb) {
-  mlir::MLIRContext *ctxt{module.getContext()};
-  mlir::Location loc{
-      (cooked && cb) ? parserPosToLoc(*ctxt, cooked, *cb) : dummyLoc(*ctxt)};
-  auto func{mlir::FuncOp::create(loc, name, funcTy)};
+M::FuncOp B::createFunction(B::AbstractConverter &converter,
+    llvm::StringRef name, M::FunctionType funcTy) {
+  auto func{M::FuncOp::create(converter.getCurrentLocation(), name, funcTy)};
+  converter.getModuleOp().push_back(func);
+  return func;
+}
+
+M::FuncOp B::createFunction(
+    M::ModuleOp module, llvm::StringRef name, M::FunctionType funcTy) {
+  auto loc{M::UnknownLoc::get(module.getContext())};
+  auto func{M::FuncOp::create(loc, name, funcTy)};
   module.push_back(func);
   return func;
 }
 
-mlir::FuncOp B::getNamedFunction(mlir::ModuleOp module, llvm::StringRef name) {
-  return module.lookupSymbol<mlir::FuncOp>(name);
+M::FuncOp B::getNamedFunction(M::ModuleOp module, llvm::StringRef name) {
+  return module.lookupSymbol<M::FuncOp>(name);
 }
 
-void B::SymMap::addSymbol(semantics::SymbolRef symbol, mlir::Value *value) {
+void B::SymMap::addSymbol(Se::SymbolRef symbol, M::Value *value) {
   symbolMap.try_emplace(&*symbol, value);
 }
 
-mlir::Value *B::SymMap::lookupSymbol(semantics::SymbolRef symbol) {
+M::Value *B::SymMap::lookupSymbol(Se::SymbolRef symbol) {
   auto iter{symbolMap.find(&*symbol)};
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
 
-void B::SymMap::pushShadowSymbol(
-    semantics::SymbolRef symbol, mlir::Value *value) {
+void B::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value *value) {
   // find any existing mapping for symbol
   auto iter{symbolMap.find(&*symbol)};
-  const semantics::Symbol *sym{nullptr};
-  mlir::Value *val{nullptr};
+  const Se::Symbol *sym{nullptr};
+  M::Value *val{nullptr};
   // if mapping exists, save it on the shadow stack
   if (iter != symbolMap.end()) {
     sym = iter->first;
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index 9ac477e8211a..02eef8144b89 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -41,6 +41,8 @@ namespace burnside {
 ///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
+class AbstractConverter;
+
 class SymMap {
   llvm::DenseMap<const semantics::Symbol *, mlir::Value *> symbolMap;
   std::vector<std::pair<const semantics::Symbol *, mlir::Value *>> shadowStack;
@@ -59,7 +61,6 @@ class SymMap {
   }
 };
 
-std::string applyNameMangling(llvm::StringRef parserName);
 std::string applyNameMangling(const evaluate::ProcedureDesignator &proc);
 std::string applyNameMangling(semantics::SymbolRef symbol);
 
@@ -90,12 +91,14 @@ inline mlir::Block *createBlock(mlir::OpBuilder *bldr) {
 /// Get a function by name (or null)
 mlir::FuncOp getNamedFunction(mlir::ModuleOp, llvm::StringRef name);
 
-/// Create a new Function
-/// Both the `CookedSource` and `CharBlock` position should be provided to
-/// properly track source position information.
-mlir::FuncOp createFunction(mlir::ModuleOp module, llvm::StringRef name,
-    mlir::FunctionType funcTy, parser::CookedSource const *cooked = nullptr,
-    parser::CharBlock const *cb = nullptr);
+/// Create a new FuncOp
+mlir::FuncOp createFunction(AbstractConverter &converter, llvm::StringRef name,
+    mlir::FunctionType funcTy);
+
+/// Create a new FuncOp
+/// The function is created with no Location information
+mlir::FuncOp createFunction(
+    mlir::ModuleOp module, llvm::StringRef name, mlir::FunctionType funcTy);
 
 }  // burnside
 }  // Fortran
diff --git a/lib/burnside/convert-type.cc b/lib/burnside/convert-type.cc
index 1b5cbe5575b3..81c53a2e70da 100644
--- a/lib/burnside/convert-type.cc
+++ b/lib/burnside/convert-type.cc
@@ -338,24 +338,6 @@ class TypeBuilder {
 
 }  // namespace
 
-M::Location Br::dummyLoc(M::MLIRContext &context) {
-  return M::UnknownLoc::get(&context);
-}
-
-M::Location Br::parserPosToLoc(M::MLIRContext &context,
-    const Pa::CookedSource *cooked, const Pa::CharBlock &position) {
-  if (cooked) {
-    auto loc{cooked->GetSourcePositionRange(position)};
-    if (loc.has_value()) {
-      // loc is a pair (begin, end); use the beginning position
-      auto &filePos{loc->first};
-      return M::FileLineColLoc::get(
-          filePos.file.path(), filePos.line, filePos.column, &context);
-    }
-  }
-  return dummyLoc(context);
-}
-
 M::Type Br::getFIRType(M::MLIRContext *context,
     Co::IntrinsicTypeDefaultKinds const &defaults, Co::TypeCategory tc,
     int kind) {
@@ -381,7 +363,7 @@ M::Type Br::translateSomeExprToFIRType(M::MLIRContext *context,
 // This entry point avoids gratuitously wrapping the Symbol instance in layers
 // of Expr<T> that will then be immediately peeled back off and discarded.
 M::Type Br::translateSymbolToFIRType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, Se::SymbolRef symbol) {
+    Co::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol) {
   return TypeBuilder{context, defaults}.gen(symbol);
 }
 
diff --git a/lib/burnside/convert-type.h b/lib/burnside/convert-type.h
index 05e570082a96..658340396c82 100644
--- a/lib/burnside/convert-type.h
+++ b/lib/burnside/convert-type.h
@@ -35,7 +35,7 @@ class Type;
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
-template<typename T> class Reference;
+template<typename> class Reference;
 }  // common
 
 namespace evaluate {
@@ -54,12 +54,12 @@ class CookedSource;
 
 namespace semantics {
 class Symbol;
-using SymbolRef = common::Reference<const Symbol>;
 }  // semantics
 
 namespace burnside {
 
 using SomeExpr = evaluate::Expr<evaluate::SomeType>;
+using SymbolRef = common::Reference<const semantics::Symbol>;
 
 constexpr common::TypeCategory IntegerCat{common::TypeCategory::Integer};
 constexpr common::TypeCategory RealCat{common::TypeCategory::Real};
@@ -68,14 +68,6 @@ constexpr common::TypeCategory CharacterCat{common::TypeCategory::Character};
 constexpr common::TypeCategory LogicalCat{common::TypeCategory::Logical};
 constexpr common::TypeCategory DerivedCat{common::TypeCategory::Derived};
 
-/// Generate a dummy location when there is no origin
-mlir::Location dummyLoc(mlir::MLIRContext &context);
-
-/// Convert a `CharBlock` front-end position pointer into the `(file, line,
-/// column)` triple for use in MLIR, LLVM, and ultimately DWARF.
-mlir::Location parserPosToLoc(mlir::MLIRContext &context,
-    parser::CookedSource const *cooked, parser::CharBlock const &position);
-
 mlir::Type getFIRType(mlir::MLIRContext *ctxt,
     common::IntrinsicTypeDefaultKinds const &defaults, common::TypeCategory tc,
     int kind);
@@ -104,8 +96,7 @@ mlir::Type translateSomeExprToFIRType(mlir::MLIRContext *ctxt,
     common::IntrinsicTypeDefaultKinds const &defaults, const SomeExpr *expr);
 
 mlir::Type translateSymbolToFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults,
-    const semantics::SymbolRef symbol);
+    common::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol);
 
 mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
diff --git a/lib/burnside/mangler.cc b/lib/burnside/mangler.cc
new file mode 100644
index 000000000000..ee05cc836dd2
--- /dev/null
+++ b/lib/burnside/mangler.cc
@@ -0,0 +1,100 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "mangler.h"
+#include "../common/reference.h"
+#include "../semantics/tools.h"
+#include "fir/InternalNames.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+
+namespace Br = Fortran::burnside;
+namespace Co = Fortran::common;
+namespace L = llvm;
+namespace Ma = Fortran::burnside::mangle;
+namespace Se = Fortran::semantics;
+
+using namespace Fortran;
+
+namespace {
+
+L::StringRef toStringRef(const parser::CharBlock &cb) {
+  return L::StringRef{cb.begin(), cb.size()};
+}
+
+// recursively build the vector of module scopes
+void moduleNames(
+    const Se::Scope *scope, L::SmallVector<L::StringRef, 2> &result) {
+  if (scope->kind() == Se::Scope::Kind::Global) {
+    return;
+  }
+  moduleNames(&scope->parent(), result);
+  if (scope->kind() == Se::Scope::Kind::Module)
+    if (auto *symbol = scope->symbol())
+      result.emplace_back(toStringRef(symbol->name()));
+}
+
+L::SmallVector<L::StringRef, 2> moduleNames(const Se::Scope *scope) {
+  L::SmallVector<L::StringRef, 2> result;
+  moduleNames(scope, result);
+  return result;
+}
+
+L::Optional<L::StringRef> hostName(const Se::Scope *scope) {
+  if (scope->kind() == Se::Scope::Kind::Subprogram) {
+    auto &parent = scope->parent();
+    if (parent.kind() == Se::Scope::Kind::Subprogram)
+      if (auto *symbol = parent.symbol()) {
+        return {toStringRef(symbol->name())};
+      }
+  }
+  return {};
+}
+
+}  // namespace
+
+// Mangle the name of `symbol` to make it unique within FIR's symbol table using
+// the FIR name mangler, `mangler`
+std::string Ma::mangleName(
+    fir::NameMangler &mangler, const Se::SymbolRef symbol) {
+  return std::visit(Co::visitors{
+                        [&](const Se::MainProgramDetails &) {
+                          return mangler.doProgramEntry().str();
+                        },
+                        [&](const Se::SubprogramDetails &) {
+                          auto &cb{symbol->name()};
+                          auto modNames{moduleNames(symbol->scope())};
+                          return mangler.doProcedure(modNames,
+                              hostName(symbol->scope()), toStringRef(cb));
+                        },
+                        [&](const Se::ProcEntityDetails &) {
+                          auto &cb{symbol->name()};
+                          auto modNames{moduleNames(symbol->scope())};
+                          return mangler.doProcedure(modNames,
+                              hostName(symbol->scope()), toStringRef(cb));
+                        },
+                        [](const auto &) -> std::string {
+                          assert(false);
+                          return {};
+                        },
+                    },
+      symbol->details());
+}
+
+std::string Ma::demangleName(L::StringRef name) {
+  return name.str();
+}
diff --git a/lib/burnside/mangler.h b/lib/burnside/mangler.h
new file mode 100644
index 000000000000..145640ac5135
--- /dev/null
+++ b/lib/burnside/mangler.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FORTRAN_BURNSIDE_MANGLER_H_
+#define FORTRAN_BURNSIDE_MANGLER_H_
+
+#include <string>
+
+namespace fir {
+struct NameMangler;
+}
+
+namespace llvm {
+class StringRef;
+}
+
+namespace Fortran {
+namespace common {
+template<typename> class Reference;
+}
+
+namespace semantics {
+class Symbol;
+}
+
+namespace burnside {
+using SymbolRef = common::Reference<const semantics::Symbol>;
+
+namespace mangle {
+
+/// Convert a front-end Symbol to an internal name
+std::string mangleName(fir::NameMangler &mangler, const SymbolRef symbol);
+
+std::string demangleName(llvm::StringRef name);
+
+}  // mangle
+}  // burnside
+}  // Fortran
+
+#endif  // FORTRAN_BURNSIDE_MANGLER_H_
diff --git a/lib/fir/InternalNames.cpp b/lib/fir/InternalNames.cpp
index 3f7657a462ba..b9a47cfd24b0 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/fir/InternalNames.cpp
@@ -22,74 +22,84 @@ namespace L = llvm;
 
 namespace {
 
-inline L::Twine prefix() { return "_Q"; }
+inline L::StringRef prefix() { return "_Q"; }
 
-L::Twine doModules(L::ArrayRef<L::StringRef> mods) {
-  L::Twine result;
+std::string doModules(L::ArrayRef<L::StringRef> mods) {
+  std::string result;
   auto *token = "M";
   for (auto mod : mods) {
-    result.concat(token).concat(mod);
+    L::Twine t = result + token + mod;
+    result = t.str();
     token = "S";
   }
   return result;
 }
 
-L::Twine doModulesHost(L::ArrayRef<L::StringRef> mods,
-                       L::Optional<L::StringRef> host) {
-  L::Twine result = doModules(mods);
-  if (host.hasValue())
-    result.concat("F").concat(*host);
+std::string doModulesHost(L::ArrayRef<L::StringRef> mods,
+                          L::Optional<L::StringRef> host) {
+  auto result = doModules(mods);
+  if (host.hasValue()) {
+    L::Twine t = result + "F" + *host;
+    result = t.str();
+  }
   return result;
 }
 
 } // namespace
 
-L::Twine fir::NameMangler::toLower(L::StringRef name) {
+L::StringRef fir::NameMangler::toLower(L::StringRef name) {
   auto lo = name.lower();
   if (name.equals(lo))
     return name;
   return cache.insert(lo).first->getKey();
 }
 
-L::Twine fir::NameMangler::addAsString(std::int64_t i) {
+L::StringRef fir::NameMangler::addAsString(std::int64_t i) {
   return cache.insert(std::to_string(i)).first->getKey();
 }
 
-L::Twine fir::NameMangler::doKind(std::int64_t kind) {
-  if (kind < 0)
-    return "KN" + addAsString(-kind);
-  return "K" + addAsString(kind);
+std::string fir::NameMangler::doKind(std::int64_t kind) {
+  if (kind < 0) {
+    L::Twine result = "KN" + addAsString(-kind);
+    return result.str();
+  }
+  L::Twine result = "K" + addAsString(kind);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doKinds(L::ArrayRef<std::int64_t> kinds) {
+std::string fir::NameMangler::doKinds(L::ArrayRef<std::int64_t> kinds) {
   L::Twine result;
   for (auto i : kinds)
     result.concat(doKind(i));
-  return result;
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doCommonBlock(L::StringRef name) {
-  return prefix() + "B" + toLower(name);
+std::string fir::NameMangler::doCommonBlock(L::StringRef name) {
+  L::Twine result = prefix() + "B" + toLower(name);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doConstant(L::ArrayRef<L::StringRef> modules,
-                                      L::StringRef name) {
-  return prefix() + doModules(modules) + "EC" + toLower(name);
+std::string fir::NameMangler::doConstant(L::ArrayRef<L::StringRef> modules,
+                                         L::StringRef name) {
+  L::Twine result = prefix() + doModules(modules) + "EC" + toLower(name);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doDispatchTable(L::ArrayRef<L::StringRef> modules,
-                                           L::Optional<L::StringRef> host,
-                                           L::StringRef name,
-                                           L::ArrayRef<std::int64_t> kinds) {
-  return prefix() + doModulesHost(modules, host) + "DT" + toLower(name) +
-         doKinds(kinds);
+std::string fir::NameMangler::doDispatchTable(L::ArrayRef<L::StringRef> modules,
+                                              L::Optional<L::StringRef> host,
+                                              L::StringRef name,
+                                              L::ArrayRef<std::int64_t> kinds) {
+  L::Twine result = prefix() + doModulesHost(modules, host) + "DT" +
+                    toLower(name) + doKinds(kinds);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doGenerated(L::StringRef name) {
-  return prefix() + "Q" + toLower(name);
+std::string fir::NameMangler::doGenerated(L::StringRef name) {
+  L::Twine result = prefix() + "Q" + toLower(name);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doIntrinsicTypeDescriptor(
+std::string fir::NameMangler::doIntrinsicTypeDescriptor(
     L::ArrayRef<L::StringRef> modules, L::Optional<L::StringRef> host,
     IntrinsicType type, std::int64_t kind) {
   char const *name;
@@ -110,32 +120,38 @@ L::Twine fir::NameMangler::doIntrinsicTypeDescriptor(
     name = "real";
     break;
   }
-  return prefix() + doModulesHost(modules, host) + "C" + name + doKind(kind);
+  L::Twine result =
+      prefix() + doModulesHost(modules, host) + "C" + name + doKind(kind);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doProcedure(L::ArrayRef<L::StringRef> modules,
-                                       L::Optional<L::StringRef> host,
-                                       L::StringRef name) {
-  return prefix() + doModulesHost(modules, host) + "P" + toLower(name);
+std::string fir::NameMangler::doProcedure(L::ArrayRef<L::StringRef> modules,
+                                          L::Optional<L::StringRef> host,
+                                          L::StringRef name) {
+  L::Twine result =
+      prefix() + doModulesHost(modules, host) + "P" + toLower(name);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doType(L::ArrayRef<L::StringRef> modules,
-                                  L::Optional<L::StringRef> host,
-                                  L::StringRef name,
-                                  L::ArrayRef<std::int64_t> kinds) {
-  return prefix() + doModulesHost(modules, host) + "T" + toLower(name) +
-         doKinds(kinds);
+std::string fir::NameMangler::doType(L::ArrayRef<L::StringRef> modules,
+                                     L::Optional<L::StringRef> host,
+                                     L::StringRef name,
+                                     L::ArrayRef<std::int64_t> kinds) {
+  L::Twine result = prefix() + doModulesHost(modules, host) + "T" +
+                    toLower(name) + doKinds(kinds);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doTypeDescriptor(L::ArrayRef<L::StringRef> modules,
-                                            L::Optional<L::StringRef> host,
-                                            L::StringRef name,
-                                            L::ArrayRef<std::int64_t> kinds) {
-  return prefix() + doModulesHost(modules, host) + "CT" + toLower(name) +
-         doKinds(kinds);
+std::string fir::NameMangler::doTypeDescriptor(
+    L::ArrayRef<L::StringRef> modules, L::Optional<L::StringRef> host,
+    L::StringRef name, L::ArrayRef<std::int64_t> kinds) {
+  L::Twine result = prefix() + doModulesHost(modules, host) + "CT" +
+                    toLower(name) + doKinds(kinds);
+  return result.str();
 }
 
-L::Twine fir::NameMangler::doVariable(L::ArrayRef<L::StringRef> modules,
-                                      L::StringRef name) {
-  return prefix() + doModules(modules) + "E" + toLower(name);
+std::string fir::NameMangler::doVariable(L::ArrayRef<L::StringRef> modules,
+                                         L::StringRef name) {
+  L::Twine result = prefix() + doModules(modules) + "E" + toLower(name);
+  return result.str();
 }

From d75a8489986874566b5e64c25178e50d8047ba27 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 11 Dec 2019 05:52:58 -0800
Subject: [PATCH 138/345] Fix function returns and enable more expression tests
 - fix function distance to support fir.real vs mlir.float - fix function
 returns when no explicit parser::ReturnStmt - enable expression lowering
 tests with complex

---
 lib/burnside/bridge.cc               | 30 ++++++++-------
 lib/burnside/intrinsics.cc           | 55 +++++++++++++++++-----------
 test/burnside/expr-test-generator.cc | 33 +++++++++++------
 3 files changed, 70 insertions(+), 48 deletions(-)

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 5607189dc746..67109fb813ba 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -94,6 +94,10 @@ class FirConverter : public AbstractConverter {
     return createI1LogicalExpression(
         loc, *builder, *expr, localSymbols, defaults, intrinsics);
   }
+  M::Value *createTemporary(M::Location loc, const Se::Symbol &sym) {
+    return ::createTemporary(loc, *builder, localSymbols,
+        translateSymbolToFIRType(builder->getContext(), defaults, sym), &sym);
+  }
 
   std::string mangledName(SymbolRef symbol) {
     return mangle::mangleName(mangler, symbol);
@@ -207,9 +211,10 @@ class FirConverter : public AbstractConverter {
     name = mangledName(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
-      const Se::Symbol *&) {
+      const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    genFIR(stmt.statement);
+    assert(symbol);
+    genFIRFunctionReturn(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::SubroutineStmt> &stmt, std::string &name,
       const Se::Symbol *&symbol) {
@@ -250,20 +255,12 @@ class FirConverter : public AbstractConverter {
   /// END of procedure-like constructs
   ///
   /// Generate the cleanup block before the procedure exits
-  void genFIRFunctionReturn(const Pa::FunctionStmt *stmt) {
-    auto &name = std::get<Pa::Name>(stmt->t);
-    assert(name.symbol);
-    const auto &details{name.symbol->get<Se::SubprogramDetails>()};
+  void genFIRFunctionReturn(const Se::Symbol &functionSymbol) {
+    const auto &details{functionSymbol.get<Se::SubprogramDetails>()};
     M::Value *resultRef{localSymbols.lookupSymbol(details.result())};
-    // FIXME: what happens if result was never referenced before and hence no
-    // temp was created?
-    assert(resultRef);
     M::Value *r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
     builder->create<M::ReturnOp>(toLocation(), r);
   }
-  void genFIR(const Pa::EndFunctionStmt &stmt) {
-    genFIRFunctionReturn(static_cast<const Pa::FunctionStmt *>(nullptr));
-  }
   template<typename A> void genFIRProcedureExit(const A *) {
     // FIXME: alt-returns
     builder->create<M::ReturnOp>(toLocation());
@@ -775,13 +772,15 @@ class FirConverter : public AbstractConverter {
   }
 
   // gen expression, if any; share code with END of procedure
-  void genFIR(const Pa::ReturnStmt &stmt) {
+  void genFIR(const Pa::ReturnStmt &) {
     if (inMainProgram(currentEvaluation)) {
       builder->create<M::ReturnOp>(toLocation());
     } else if (auto *stmt = inSubroutine(currentEvaluation)) {
       genFIRProcedureExit(stmt);
     } else if (auto *stmt = inFunction(currentEvaluation)) {
-      genFIRFunctionReturn(stmt);
+      auto *symbol = std::get<Pa::Name>(stmt->t).symbol;
+      assert(symbol);
+      genFIRFunctionReturn(*symbol);
     } else if (auto *stmt = inMPSubp(currentEvaluation)) {
       genFIRProcedureExit(stmt);
     } else {
@@ -878,6 +877,9 @@ class FirConverter : public AbstractConverter {
           TODO();  // handle alternate return
         }
       }
+      if (details->isFunction()) {
+        createTemporary(toLocation(), details->result());
+      }
     }
   }
 
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index 5f7487d20183..753d30b7e7f8 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -278,10 +278,15 @@ mlir::FuncOp MathRuntimeLibrary::getFuncOp(
 }
 
 // This helper class computes a "distance" between two function types.
-// The distance represents the argument and result conversions
-// that are required if one use "to" instead of "from".
-// Note that this is not a reflexive distance, and it does not
-// define a total order at all.
+// The distance measures how many narrowing conversions of actual arguments
+// and result of "from" must be made in order to use "to" instead of "from".
+// For instance, the distance between ACOS(REAL(10)) and ACOS(REAL(8)) is
+// greater than the one between ACOS(REAL(10)) and ACOS(REAL(16)). This means
+// if no implementation of ACOS(REAL(10)) is available, it is better to use
+// ACOS(REAL(16)) with casts rather than ACOS(REAL(8)).
+// Note that this is not a symmetric distance and the order of "from" and "to"
+// arguments matters, d(foo, bar) may not be the same as d(bar, foo) because it
+// may be safe to replace foo by bar, but not the opposite.
 class FunctionDistance {
 public:
   FunctionDistance() : infinite{true} {}
@@ -329,7 +334,20 @@ class FunctionDistance {
     case Conversion::Extend: conversions[extendingResult]++; break;
     }
   }
-
+  // Floating point can be mlir::FloatType or fir::real
+  static unsigned getFloatingPointWidth(mlir::Type t) {
+    if (auto f{t.dyn_cast<mlir::FloatType>()}) return f.getWidth();
+    // FIXME: Get width another way for fir.real/complex
+    // - use fir/KindMapping.h and LLVM::Type
+    // - or use evaluate/type.h
+    if (auto r{t.dyn_cast<fir::RealType>()}) return r.getFKind() * 4;
+    if (auto cplx{t.dyn_cast<fir::CplxType>()}) return cplx.getFKind() * 4;
+    assert(false && "not a floating-point type");
+    return 0;
+  }
+  static bool isFloatingPointType(mlir::Type t) {
+    return t.isa<mlir::FloatType>() || t.isa<fir::RealType>();
+  }
   static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
     if (from == to) {
       return Conversion::None;
@@ -340,24 +358,17 @@ class FunctionDistance {
                                                          : Conversion::Extend;
       }
     }
-    if (auto fromRealTy{from.dyn_cast<fir::RealType>()}) {
-      if (auto toRealTy{to.dyn_cast<fir::RealType>()}) {
-        // FIXME: With the current runtime (no functions with f16 and bf16
-        // types), and the current kinds to representation mapping, that
-        // just works, but that is not that simple:
-        //    - conversions between f16 and bf16 destroy information in both
-        //    ways.
-        //    - No assumptions regarding kind <-> representation should be made
-        //    here.
-        return fromRealTy.getFKind() > toRealTy.getFKind() ? Conversion::Narrow
-                                                           : Conversion::Extend;
-      }
+    if (isFloatingPointType(from) && isFloatingPointType(to)) {
+      return getFloatingPointWidth(from) > getFloatingPointWidth(to)
+          ? Conversion::Narrow
+          : Conversion::Extend;
     }
     if (auto fromCplxTy{from.dyn_cast<fir::CplxType>()}) {
-      if (auto toCplxTy{to.dyn_cast<fir::RealType>()}) {
-        // FIXME: Same as for Real.
-        return fromCplxTy.getFKind() > toCplxTy.getFKind() ? Conversion::Narrow
-                                                           : Conversion::Extend;
+      if (auto toCplxTy{to.dyn_cast<fir::CplxType>()}) {
+        return getFloatingPointWidth(fromCplxTy) >
+                getFloatingPointWidth(toCplxTy)
+            ? Conversion::Narrow
+            : Conversion::Extend;
       }
     }
     // Notes:
@@ -554,7 +565,7 @@ mlir::Value *IntrinsicLibrary::Implementation::genRuntimeCall(
     // TODO: better error handling ?
     //  - Try to have compile time check of runtime compltness ?
   }
-  return {}; // gets rid of warnings
+  return {};  // gets rid of warnings
 }
 
 // CONJG
diff --git a/test/burnside/expr-test-generator.cc b/test/burnside/expr-test-generator.cc
index 96e6fad39298..fa246d14efff 100644
--- a/test/burnside/expr-test-generator.cc
+++ b/test/burnside/expr-test-generator.cc
@@ -522,15 +522,25 @@ struct CodeGenerator {
   }
 
   void GenerateResultsComparison(std::ostream &s) const {
-    const auto *compareOp{
-        resultType.cat == TypeCategory::Logical ? ".EQV." : ".EQ."};
-    if (resultType.cat == TypeCategory::Real) {
+    auto compareReal{[&](const std::string &x, const std::string &y) {
       // TODO: This should not always be an absolute comparison (epsilon margin
-      // for fp.). Complex needs similar checks.
-      s << refResultName << compareOp << testResultName << " .OR. ";
-      s << "(IEEE_IS_NAN(" << refResultName << ") .AND. IEEE_IS_NAN("
-        << testResultName << "))";
+      // for fp.).
+      s << x << ".EQ." << y << " .OR. ";
+      s << "(IEEE_IS_NAN(" << x << ") .AND. IEEE_IS_NAN(" << y << "))";
+    }};
+    if (resultType.cat == TypeCategory::Real) {
+      compareReal(refResultName, testResultName);
+    } else if (resultType.cat == TypeCategory::Complex) {
+      s << "(";
+      compareReal(std::string{refResultName} + "%RE",
+          std::string{testResultName} + "%RE");
+      s << ") .AND. (";
+      compareReal(std::string{refResultName} + "%IM",
+          std::string{testResultName} + "%IM");
+      s << ")";
     } else {
+      const auto *compareOp{
+          resultType.cat == TypeCategory::Logical ? ".EQV." : ".EQ."};
       s << refResultName << compareOp << testResultName;
     }
   }
@@ -675,11 +685,10 @@ int main(int argc, char **argv) {
               {Integer8, {"3000001_8", "-2654637545_8"}},
               {Real4, {"1.03687448_4", "3.1254641_4"}},
               {Real8, {"1.036874168446448_8", "3.12254533554641_8"}},
-              // TODO: fix expression analysis bug with REAL(8)**COMPLEX(4)
-              //   {Complex4, {"(-0.5_4,10.35544_4)", "(-5._4, 0.15647_4)"}},
-              //   {Complex8,
-              //    {"(-0.5_8,10.35546579874_8)",
-              //     "(-5.64654654_8, 0.155876974647_8)"}},
+              {Complex4, {"(-0.5_4,10.35544_4)", "(-5._4, 0.15647_4)"}},
+              {Complex8,
+                  {"(-0.5_8,10.35546579874_8)",
+                      "(-5.64654654_8, 0.155876974647_8)"}},
               {DefaultLogical, {".false.", ".true."}},
           },
           refEvalMethod,

From d202eeeab0ff976483cd570f29cf57ad763bebfd Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 12 Dec 2019 10:19:34 -0800
Subject: [PATCH 139/345] add a decompose interface change "mangle" to "unique"
 more threading of abstract converter library name change make the asserts
 have a command line control use -disable-burnside-todo to disable the
 assertions

---
 include/fir/InternalNames.h   |  61 ++++++++++++-----
 include/fir/Tilikum/Tilikum.h |   4 +-
 lib/burnside/bridge.cc        | 120 +++++++++++++++++++---------------
 lib/burnside/bridge.h         |  13 +++-
 lib/burnside/builder.cc       |  48 --------------
 lib/burnside/builder.h        |   3 -
 lib/burnside/cfg-builder.h    |  48 +++++++-------
 lib/burnside/convert-expr.cc  |  83 ++++++++++++-----------
 lib/burnside/convert-expr.h   |  22 +++----
 lib/burnside/convert-type.cc  |   3 +-
 lib/burnside/mangler.cc       |  11 ++--
 lib/burnside/mangler.h        |   4 +-
 lib/fir/InternalNames.cpp     |  37 ++++++-----
 lib/fir/Tilikum.cpp           |  18 ++---
 tools/bbc/bbc.cpp             |   6 +-
 tools/tco/CMakeLists.txt      |   2 +-
 tools/tco/tco.cpp             |   4 +-
 17 files changed, 246 insertions(+), 241 deletions(-)

diff --git a/include/fir/InternalNames.h b/include/fir/InternalNames.h
index 49637e26d47c..78c58af996b1 100644
--- a/include/fir/InternalNames.h
+++ b/include/fir/InternalNames.h
@@ -29,56 +29,87 @@ class Twine;
 namespace fir {
 
 /// Internal name mangling of identifiers
-struct NameMangler {
+///
+/// In order to generate symbolically referencable artifacts in a ModuleOp,
+/// it is required that those symbols be uniqued.  This is a simple interface
+/// for converting Fortran symbols into unique names.
+///
+/// This is intentionally bijective. Given a symbol's parse name, type, and
+/// scope-like information, we can generate a uniqued (mangled) name.  Given a
+/// uniqued name, we can return the symbol parse name, type of the symbol, and
+/// any scope-like information for that symbol.
+struct NameUniquer {
   enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };
 
-  NameMangler() = default;
-
-  /// Mangle a common block name
+  enum class NameKind {
+    NOT_UNIQUED,
+    COMMON,
+    CONSTANT,
+    DERIVED_TYPE,
+    DISPATCH_TABLE,
+    GENERATED,
+    INTRINSIC_TYPE_DESC,
+    PROCEDURE,
+    TYPE_DESC,
+    VARIABLE
+  };
+
+  struct DeconstructedName {
+    llvm::SmallVector<std::string, 2> modules;
+    llvm::Optional<std::string> host;
+    std::string name;
+    llvm::SmallVector<std::int64_t, 4> kinds;
+  };
+
+  NameUniquer() = default;
+
+  /// Unique a common block name
   std::string doCommonBlock(llvm::StringRef name);
 
-  /// Mangle a (global) constant name
+  /// Unique a (global) constant name
   std::string doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                          llvm::StringRef name);
 
-  /// Mangle a dispatch table name
+  /// Unique a dispatch table name
   std::string doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
                               llvm::Optional<llvm::StringRef> host,
                               llvm::StringRef name,
                               llvm::ArrayRef<std::int64_t> kinds);
 
-  /// Mangle a compiler generated name
+  /// Unique a compiler generated name
   std::string doGenerated(llvm::StringRef name);
 
-  /// Mangle an intrinsic type descriptor
+  /// Unique an intrinsic type descriptor
   std::string doIntrinsicTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                                         llvm::Optional<llvm::StringRef> host,
                                         IntrinsicType type, std::int64_t kind);
 
-  /// Mangle a procedure name
+  /// Unique a procedure name
   std::string doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
                           llvm::Optional<llvm::StringRef> host,
                           llvm::StringRef name);
 
-  /// Mangle a derived type name
+  /// Unique a derived type name
   std::string doType(llvm::ArrayRef<llvm::StringRef> modules,
                      llvm::Optional<llvm::StringRef> host, llvm::StringRef name,
                      llvm::ArrayRef<std::int64_t> kinds);
 
-  /// Mangle a (derived) type descriptor name
+  /// Unique a (derived) type descriptor name
   std::string doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                                llvm::Optional<llvm::StringRef> host,
                                llvm::StringRef name,
                                llvm::ArrayRef<std::int64_t> kinds);
 
-  /// Mangle a (global) variable name
+  /// Unique a (global) variable name
   std::string doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                          llvm::StringRef name);
 
   /// Entry point for the PROGRAM (called by the runtime)
-  constexpr static llvm::StringRef doProgramEntry() {
-    return "MAIN_";
-  }
+  constexpr static llvm::StringRef doProgramEntry() { return "MAIN_"; }
+
+  /// Decompose `uniquedName` into the parse name, symbol type, and scope info
+  static std::pair<NameKind, DeconstructedName>
+  deconstruct(llvm::StringRef uniquedName);
 
 private:
   llvm::StringRef addAsString(std::int64_t i);
diff --git a/include/fir/Tilikum/Tilikum.h b/include/fir/Tilikum/Tilikum.h
index a2c8571fdaf5..691e56f00d13 100644
--- a/include/fir/Tilikum/Tilikum.h
+++ b/include/fir/Tilikum/Tilikum.h
@@ -26,10 +26,10 @@ class Pass;
 
 namespace fir {
 
-struct NameMangler;
+struct NameUniquer;
 
 /// Convert FIR to the LLVM IR dialect
-std::unique_ptr<mlir::Pass> createFIRToLLVMPass(NameMangler &mangler);
+std::unique_ptr<mlir::Pass> createFIRToLLVMPass(NameUniquer &uniquer);
 
 /// Convert the LLVM IR dialect to LLVM-IR proper
 std::unique_ptr<mlir::Pass>
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 67109fb813ba..53ef8b7a2518 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -27,21 +27,13 @@
 #include "fir/FIROps.h"
 #include "fir/FIRType.h"
 #include "fir/InternalNames.h"
+#include "llvm/Support/CommandLine.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Parser.h"
 #include "mlir/Target/LLVMIR.h"
 
-#undef TODO
-#define TODO() \
-  llvm::errs() << __FILE__ << ":" << __LINE__ << " not yet implemented\n"; \
-  std::exit(1)
-
-#undef SOFT_TODO
-#define SOFT_TODO() \
-  llvm::errs() << __FILE__ << ":" << __LINE__ << " not yet implemented\n";
-
 namespace Br = Fortran::burnside;
 namespace Co = Fortran::common;
 namespace Ev = Fortran::evaluate;
@@ -55,6 +47,14 @@ using namespace Fortran::burnside;
 
 namespace {
 
+L::cl::opt<bool> ClDisableToDoAssert("disable-burnside-todo",
+    L::cl::desc("disable burnside bridge asserts"), L::cl::init(false),
+    L::cl::Hidden);
+
+#undef TODO
+#define TODO() \
+  assert(false && "not implemented yet")
+
 using SelectCaseConstruct = Pa::CaseConstruct;
 using SelectRankConstruct = Pa::SelectRankConstruct;
 using SelectTypeConstruct = Pa::SelectTypeConstruct;
@@ -69,6 +69,16 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 // CfgBuilder implementation
 #include "cfg-builder.h"
 
+#undef TODO
+#define TODO() \
+  { \
+    if (ClDisableToDoAssert) \
+      mlir::emitError(toLocation(), __FILE__) \
+          << ":" << __LINE__ << " not implemented"; \
+    else \
+      assert(false && "not yet implemented"); \
+  }
+
 /// Converter from AST to FIR
 ///
 /// After building the AST and decorating it, the FirConverter processes that
@@ -82,25 +92,18 @@ class FirConverter : public AbstractConverter {
   //
 
   M::Value *createFIRAddr(M::Location loc, const Se::SomeExpr *expr) {
-    return createSomeAddress(
-        loc, *builder, *expr, localSymbols, defaults, intrinsics);
+    return createSomeAddress(loc, *this, *expr, localSymbols, intrinsics);
   }
 
   M::Value *createFIRExpr(M::Location loc, const Se::SomeExpr *expr) {
-    return createSomeExpression(
-        loc, *builder, *expr, localSymbols, defaults, intrinsics);
+    return createSomeExpression(loc, *this, *expr, localSymbols, intrinsics);
   }
   M::Value *createLogicalExprAsI1(M::Location loc, const Se::SomeExpr *expr) {
     return createI1LogicalExpression(
-        loc, *builder, *expr, localSymbols, defaults, intrinsics);
+        loc, *this, *expr, localSymbols, intrinsics);
   }
   M::Value *createTemporary(M::Location loc, const Se::Symbol &sym) {
-    return ::createTemporary(loc, *builder, localSymbols,
-        translateSymbolToFIRType(builder->getContext(), defaults, sym), &sym);
-  }
-
-  std::string mangledName(SymbolRef symbol) {
-    return mangle::mangleName(mangler, symbol);
+    return Br::createTemporary(loc, *builder, localSymbols, genType(sym), &sym);
   }
 
   // TODO: we need a map for the various Fortran runtime entry points
@@ -195,7 +198,7 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::Statement<Pa::ProgramStmt> &stmt, std::string &name,
       const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
-    name = mangler.doProgramEntry();
+    name = uniquer.doProgramEntry();
   }
   void genFIR(const Pa::Statement<Pa::EndProgramStmt> &stmt, std::string &,
       const Se::Symbol *&) {
@@ -208,7 +211,7 @@ class FirConverter : public AbstractConverter {
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
-    name = mangledName(*symbol);
+    name = mangleName(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
       const Se::Symbol *&symbol) {
@@ -222,7 +225,7 @@ class FirConverter : public AbstractConverter {
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
-    name = mangledName(*symbol);
+    name = mangleName(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::EndSubroutineStmt> &stmt, std::string &,
       const Se::Symbol *&) {
@@ -265,10 +268,10 @@ class FirConverter : public AbstractConverter {
     // FIXME: alt-returns
     builder->create<M::ReturnOp>(toLocation());
   }
-  void genFIR(const Pa::EndSubroutineStmt &stmt) {
+  void genFIR(const Pa::EndSubroutineStmt &) {
     genFIRProcedureExit(static_cast<const Pa::SubroutineStmt *>(nullptr));
   }
-  void genFIR(const Pa::EndMpSubprogramStmt &stmt) {
+  void genFIR(const Pa::EndMpSubprogramStmt &) {
     genFIRProcedureExit(static_cast<const Pa::MpSubprogramStmt *>(nullptr));
   }
 
@@ -339,8 +342,8 @@ class FirConverter : public AbstractConverter {
   void genFIRIOSwitch(AST::Evaluation &) { TODO(); }
 
   // Iterative loop control-flow semantics
-  void genFIREvalIterative(AST::Evaluation &eval) {
-    // FIXME
+  void genFIREvalIterative(AST::Evaluation &) {
+    TODO();
   }
 
   void switchInsertionPointToWhere(fir::WhereOp &where) {
@@ -500,7 +503,7 @@ class FirConverter : public AbstractConverter {
                      // TODO bindName()?
                      argsList = details.dummyArgs();
                    },
-                   [](const Pa::ProcComponentRef &) { TODO(); },
+                   [&](const Pa::ProcComponentRef &) { TODO(); },
                },
         std::get<Pa::ProcedureDesignator>(stmt.v.t).u);
     for (auto *d : argsList) {
@@ -511,6 +514,7 @@ class FirConverter : public AbstractConverter {
     auto funTy{M::FunctionType::get(argTy, resTy, builder->getContext())};
     // FIXME: mangle name
     M::FuncOp func{getFunc(funName, funTy)};
+    (void)func; // FIXME
     std::vector<M::Value *> actuals;
     for (auto &aa : std::get<std::list<Pa::ActualArgSpec>>(stmt.v.t)) {
       auto &kw = std::get<std::optional<Pa::Keyword>>(aa.t);
@@ -521,9 +525,9 @@ class FirConverter : public AbstractConverter {
                        // FIXME: needs to match argument, assumes trivial by-ref
                        fe = genExprAddr(*Se::GetExpr(e));
                      },
-                     [](const Pa::AltReturnSpec &) { TODO(); },
-                     [](const Pa::ActualArg::PercentRef &) { TODO(); },
-                     [](const Pa::ActualArg::PercentVal &) { TODO(); },
+                     [&](const Pa::AltReturnSpec &) { TODO(); },
+                     [&](const Pa::ActualArg::PercentRef &) { TODO(); },
+                     [&](const Pa::ActualArg::PercentVal &) { TODO(); },
                  },
           arg.u);
       if (kw.has_value()) {
@@ -572,9 +576,9 @@ class FirConverter : public AbstractConverter {
       // pushDoContext(&ss);
     }
 #endif
-    SOFT_TODO();
+    TODO();
   }
-  void genFIR(const Pa::IfConstruct &) { SOFT_TODO(); }
+  void genFIR(const Pa::IfConstruct &) { TODO(); }
 
   void genFIR(const SelectCaseConstruct &) { TODO(); }
   void genFIR(const SelectRankConstruct &) { TODO(); }
@@ -673,7 +677,7 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::RewindStmt &stmt) { genRewindStatement(*this, stmt); }
   void genFIR(const Pa::WriteStmt &stmt) { genWriteStatement(*this, stmt); }
 
-  void genFIR(const Pa::AllocateStmt &) { SOFT_TODO(); }
+  void genFIR(const Pa::AllocateStmt &) { TODO(); }
   void genFIR(const Pa::AssignmentStmt &stmt) {
     auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
     auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
@@ -682,7 +686,7 @@ class FirConverter : public AbstractConverter {
   }
 
   void genFIR(const Pa::ContinueStmt &) {}  // do nothing
-  void genFIR(const Pa::DeallocateStmt &) { SOFT_TODO(); }
+  void genFIR(const Pa::DeallocateStmt &) { TODO(); }
   void genFIR(const Pa::EventPostStmt &) {
     // call some runtime routine
     TODO();
@@ -721,7 +725,7 @@ class FirConverter : public AbstractConverter {
           po.u);
     }
   }
-  void genFIR(const Pa::PointerAssignmentStmt &) { SOFT_TODO(); }
+  void genFIR(const Pa::PointerAssignmentStmt &) { TODO(); }
 
   void genFIR(const Pa::SyncAllStmt &) {
     // call some runtime routine
@@ -912,7 +916,7 @@ class FirConverter : public AbstractConverter {
       std::visit(
           [&](auto *p) { genFIR(*p, name, symbol); }, func.funStmts.front());
     } else {
-      name = mangler.doProgramEntry();
+      name = uniquer.doProgramEntry();
     }
 
     startNewFunction(func, name, symbol);
@@ -1034,7 +1038,7 @@ class FirConverter : public AbstractConverter {
   const Co::IntrinsicTypeDefaultKinds &defaults;
   IntrinsicLibrary intrinsics;
   M::OpBuilder *builder{nullptr};
-  fir::NameMangler &mangler;
+  fir::NameUniquer &uniquer;
   SymMap localSymbols;
   std::list<Closure> localEdgeQ;
   LabelMapType localBlockMap;
@@ -1049,12 +1053,12 @@ class FirConverter : public AbstractConverter {
   FirConverter &operator=(const FirConverter &) = delete;
   virtual ~FirConverter() = default;
 
-  explicit FirConverter(BurnsideBridge &bridge, fir::NameMangler &mangler)
+  explicit FirConverter(BurnsideBridge &bridge, fir::NameUniquer &uniquer)
     : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
       module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
       intrinsics{IntrinsicLibrary::create(
           IntrinsicLibrary::Version::LLVM, bridge.getMLIRContext())},
-      mangler{mangler} {}
+      uniquer{uniquer} {}
 
   /// Convert the AST to FIR
   void run(AST::Program &ast) {
@@ -1073,7 +1077,7 @@ class FirConverter : public AbstractConverter {
       std::visit(common::visitors{
                      [&](AST::FunctionLikeUnit &f) { lowerFunc(f, {}); },
                      [&](AST::ModuleLikeUnit &m) { lowerMod(m); },
-                     [](AST::BlockDataUnit &) { SOFT_TODO(); },
+                     [&](AST::BlockDataUnit &) { TODO(); },
                  },
           u);
     }
@@ -1083,29 +1087,35 @@ class FirConverter : public AbstractConverter {
   // AbstractConverter overrides
 
   M::Value *genExprAddr(
-      const SomeExpr &expr, M::Location *loc = nullptr) override {
+      const SomeExpr &expr, M::Location *loc = nullptr) override final {
     return createFIRAddr(loc ? *loc : toLocation(), &expr);
   }
   M::Value *genExprValue(
-      const SomeExpr &expr, M::Location *loc = nullptr) override {
+      const SomeExpr &expr, M::Location *loc = nullptr) override final {
     return createFIRExpr(loc ? *loc : toLocation(), &expr);
   }
 
-  M::Type genType(const Ev::DataRef &data) override {
+  M::Type genType(const Ev::DataRef &data) override final {
     return translateDataRefToFIRType(&mlirContext, defaults, data);
   }
-  M::Type genType(const SomeExpr &expr) override {
+  M::Type genType(const SomeExpr &expr) override final {
     return translateSomeExprToFIRType(&mlirContext, defaults, &expr);
   }
-  M::Type genType(const SymbolRef &sym) override {
+  M::Type genType(SymbolRef sym) override final {
     return translateSymbolToFIRType(&mlirContext, defaults, sym);
   }
+  M::Type genType(common::TypeCategory tc, int kind) override final {
+    return getFIRType(&mlirContext, defaults, tc, kind);
+  }
+  M::Type genType(common::TypeCategory tc) override final {
+    return getFIRType(&mlirContext, defaults, tc);
+  }
 
-  M::Location getCurrentLocation() override { return toLocation(); }
-  M::Location genLocation() override {
+  M::Location getCurrentLocation() override final { return toLocation(); }
+  M::Location genLocation() override final {
     return M::UnknownLoc::get(&mlirContext);
   }
-  M::Location genLocation(const Pa::CharBlock &block) override {
+  M::Location genLocation(const Pa::CharBlock &block) override final {
     if (cooked) {
       auto loc{cooked->GetSourcePositionRange(block)};
       if (loc.has_value()) {
@@ -1118,17 +1128,21 @@ class FirConverter : public AbstractConverter {
     return genLocation();
   }
 
-  M::OpBuilder &getOpBuilder() override { return *builder; }
-  M::ModuleOp &getModuleOp() override { return module; }
+  M::OpBuilder &getOpBuilder() override final { return *builder; }
+  M::ModuleOp &getModuleOp() override final { return module; }
+
+  std::string mangleName(SymbolRef symbol) override final {
+    return mangle::mangleName(uniquer, symbol);
+  }
 };
 
 }  // namespace
 
 void Br::BurnsideBridge::lower(
-    const Pa::Program &prg, fir::NameMangler &mangler) {
+    const Pa::Program &prg, fir::NameUniquer &uniquer) {
   AST::Program *ast{Br::createAST(prg)};
   Br::annotateControl(*ast);
-  FirConverter converter{*this, mangler};
+  FirConverter converter{*this, uniquer};
   converter.run(*ast);
   delete ast;
 }
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index 52fba728845d..16763f262525 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -15,6 +15,7 @@
 #ifndef FORTRAN_BURNSIDE_BRIDGE_H_
 #define FORTRAN_BURNSIDE_BRIDGE_H_
 
+#include "../common/Fortran.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include <memory>
@@ -52,7 +53,7 @@ namespace mlir {
 class OpBuilder;
 }
 namespace fir {
-struct NameMangler;
+struct NameUniquer;
 }
 
 namespace Fortran::burnside {
@@ -82,7 +83,11 @@ class AbstractConverter {
   /// Generate the type of an Expr
   virtual mlir::Type genType(const SomeExpr &) = 0;
   /// Generate the type of a Symbol
-  virtual mlir::Type genType(const SymbolRef &) = 0;
+  virtual mlir::Type genType(SymbolRef) = 0;
+  /// Generate the type from a category
+  virtual mlir::Type genType(common::TypeCategory tc) = 0;
+  /// Generate the type from a category and kind
+  virtual mlir::Type genType(common::TypeCategory tc, int kind) = 0;
 
   //
   // Locations
@@ -101,6 +106,8 @@ class AbstractConverter {
   virtual mlir::OpBuilder &getOpBuilder() = 0;
   /// Get the ModuleOp
   virtual mlir::ModuleOp &getModuleOp() = 0;
+  /// Unique a symbol
+  virtual std::string mangleName(SymbolRef) = 0;
 
   virtual ~AbstractConverter() = default;
 };
@@ -127,7 +134,7 @@ class BurnsideBridge {
   const parser::CookedSource *getCookedSource() const { return cooked; }
 
   /// Cross the bridge from the Fortran parse-tree, etc. to FIR+OpenMP+MLIR
-  void lower(const parser::Program &program, fir::NameMangler &mangler);
+  void lower(const parser::Program &program, fir::NameUniquer &uniquer);
 
 private:
   explicit BurnsideBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index e064fb365641..9f2b834b95f7 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -27,54 +27,6 @@ namespace Se = Fortran::semantics;
 using namespace Fortran;
 using namespace Fortran::burnside;
 
-#if 0
-// This will need to be extended to consider the type of what is being mangled
-std::string B::applyNameMangling(llvm::StringRef parserName) {
-  // FIXME: this is fake for now, add type info, etc.
-  return "_Qp_"s + parserName.str();
-}
-#endif
-
-std::string B::applyNameMangling(const Ev::ProcedureDesignator &proc) {
-  if (const auto *symbol{proc.GetSymbol()}) {
-    return applyNameMangling(*symbol);
-  } else {
-    // Do not mangle intrinsic for now
-    assert(proc.GetSpecificIntrinsic() &&
-        "expected intrinsic procedure in designator");
-    return proc.GetName();
-  }
-}
-
-std::string B::applyNameMangling(Se::SymbolRef symbol) {
-  // FIXME: this is fake for now, add type info, etc.
-  // For now, only works for external procedures
-  // TODO: apply binding
-  // TODO: determine if procedure are:
-  //   - external, internal or  module
-  // TODO: Apply proposed mangling with _Qp_ ....
-  return std::visit(
-      common::visitors{
-          [&](const Se::MainProgramDetails &) { return "MAIN_"s; },
-          [&](const Se::SubprogramDetails &) {
-            return symbol->name().ToString() + "_";
-          },
-          [&](const Se::ProcEntityDetails &) {
-            return symbol->name().ToString() + "_";
-          },
-          [&](const Se::SubprogramNameDetails &) {
-            assert(false &&
-                "SubprogramNameDetails not expected after semantic analysis");
-            return ""s;
-          },
-          [&](const auto &) {
-            assert(false && "Symbol mangling TODO");
-            return ""s;
-          },
-      },
-      symbol->details());
-}
-
 M::FuncOp B::createFunction(B::AbstractConverter &converter,
     llvm::StringRef name, M::FunctionType funcTy) {
   auto func{M::FuncOp::create(converter.getCurrentLocation(), name, funcTy)};
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index 02eef8144b89..8f663c59f5ee 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -61,9 +61,6 @@ class SymMap {
   }
 };
 
-std::string applyNameMangling(const evaluate::ProcedureDesignator &proc);
-std::string applyNameMangling(semantics::SymbolRef symbol);
-
 /// Get the current Module
 inline mlir::ModuleOp getModule(mlir::OpBuilder *bldr) {
   return bldr->getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
diff --git a/lib/burnside/cfg-builder.h b/lib/burnside/cfg-builder.h
index a76b4edbd838..754c4314629b 100644
--- a/lib/burnside/cfg-builder.h
+++ b/lib/burnside/cfg-builder.h
@@ -240,8 +240,8 @@ class CfgBuilder {
                        [&](const Pa::ElseIfStmt *) {
                          doNextIfBlock(evals, e, iter, evals.end());
                        },
-                       [](const Pa::WhereConstructStmt *stmt) { TODO(); },
-                       [](const Pa::MaskedElsewhereStmt *stmt) { TODO(); },
+                       [](const Pa::WhereConstructStmt *) { TODO(); },
+                       [](const Pa::MaskedElsewhereStmt *) { TODO(); },
                        [](auto) { assert(false && "unhandled CGOTO case"); },
                    },
             e.u);
@@ -266,39 +266,39 @@ class CfgBuilder {
       case AST::CFGAnnotation::IoSwitch:
         std::visit(
             Co::visitors{
-                [](const Pa::BackspaceStmt *stmt) { TODO(); },
-                [](const Pa::CloseStmt *stmt) { TODO(); },
-                [](const Pa::EndfileStmt *stmt) { TODO(); },
-                [](const Pa::FlushStmt *stmt) { TODO(); },
-                [](const Pa::InquireStmt *stmt) { TODO(); },
-                [](const Pa::OpenStmt *stmt) { TODO(); },
-                [](const Pa::ReadStmt *stmt) { TODO(); },
-                [](const Pa::RewindStmt *stmt) { TODO(); },
-                [](const Pa::WaitStmt *stmt) { TODO(); },
-                [](const Pa::WriteStmt *stmt) { TODO(); },
+                [](const Pa::BackspaceStmt *) { TODO(); },
+                [](const Pa::CloseStmt *) { TODO(); },
+                [](const Pa::EndfileStmt *) { TODO(); },
+                [](const Pa::FlushStmt *) { TODO(); },
+                [](const Pa::InquireStmt *) { TODO(); },
+                [](const Pa::OpenStmt *) { TODO(); },
+                [](const Pa::ReadStmt *) { TODO(); },
+                [](const Pa::RewindStmt *) { TODO(); },
+                [](const Pa::WaitStmt *) { TODO(); },
+                [](const Pa::WriteStmt *) { TODO(); },
                 [](auto) { assert(false && "unhandled IO switch case"); },
             },
             e.u);
         break;
       case AST::CFGAnnotation::Switch:
         std::visit(Co::visitors{
-                       [](const Pa::CallStmt *stmt) { TODO(); },
-                       [](const Pa::ArithmeticIfStmt *stmt) { TODO(); },
-                       [](const Pa::ComputedGotoStmt *stmt) { TODO(); },
-                       [](const Pa::SelectCaseStmt *stmt) { TODO(); },
-                       [](const Pa::SelectRankStmt *stmt) { TODO(); },
-                       [](const Pa::SelectTypeStmt *stmt) { TODO(); },
+                       [](const Pa::CallStmt *) { TODO(); },
+                       [](const Pa::ArithmeticIfStmt *) { TODO(); },
+                       [](const Pa::ComputedGotoStmt *) { TODO(); },
+                       [](const Pa::SelectCaseStmt *) { TODO(); },
+                       [](const Pa::SelectRankStmt *) { TODO(); },
+                       [](const Pa::SelectTypeStmt *) { TODO(); },
                        [](auto) { assert(false && "unhandled switch case"); },
                    },
             e.u);
         break;
       case AST::CFGAnnotation::Iterative:
         std::visit(Co::visitors{
-                       [](const Pa::NonLabelDoStmt *stmt) { TODO(); },
-                       [](const Pa::WhereStmt *stmt) { TODO(); },
-                       [](const Pa::ForallStmt *stmt) { TODO(); },
-                       [](const Pa::WhereConstruct *stmt) { TODO(); },
-                       [](const Pa::ForallConstructStmt *stmt) { TODO(); },
+                       [](const Pa::NonLabelDoStmt *) { TODO(); },
+                       [](const Pa::WhereStmt *) { TODO(); },
+                       [](const Pa::ForallStmt *) { TODO(); },
+                       [](const Pa::WhereConstruct *) { TODO(); },
+                       [](const Pa::ForallConstructStmt *) { TODO(); },
                        [](auto) { assert(false && "unhandled loop case"); },
                    },
             e.u);
@@ -319,7 +319,7 @@ class CfgBuilder {
     }
   }
 
-  void setActualTargets(std::list<AST::Evaluation> &evals) {
+  void setActualTargets(std::list<AST::Evaluation> &) {
     for (auto &lst1 : cfgEdgeSetPool)
       for (auto *e : lst1) {
         e->isTarget = true;
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 5e46fdaa5747..240dbc650472 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -13,10 +13,10 @@
 // limitations under the License.
 
 #include "convert-expr.h"
+#include "bridge.h"
 #include "builder.h"
 #include "complex-handler.h"
 #include "convert-type.h"
-#include "intrinsics.h"
 #include "runtime.h"
 #include "../common/default-kinds.h"
 #include "../common/unwrap.h"
@@ -36,12 +36,8 @@
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Attributes.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/PatternMatch.h"
-#include "mlir/IR/Value.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
@@ -67,13 +63,13 @@ namespace {
 /// Lowering of Fortran::evaluate::Expr<T> expressions
 class ExprLowering {
   M::Location location;
+  AbstractConverter &converter;
   M::OpBuilder &builder;
   SomeExpr const &expr;
   SymMap &symMap;
 #if 0
   SymMap loadedSymbols;
 #endif
-  Co::IntrinsicTypeDefaultKinds const &defaults;
   IntrinsicLibrary const &intrinsics;
   bool genLogicalAsI1{false};
 
@@ -113,7 +109,7 @@ class ExprLowering {
   /// Generate an integral constant of `value`
   template<int KIND>
   M::Value *genIntegerConstant(M::MLIRContext *context, std::int64_t value) {
-    M::Type type{getFIRType(context, defaults, IntegerCat, KIND)};
+    M::Type type{converter.genType(IntegerCat, KIND)};
     auto attr{builder.getIntegerAttr(type, value)};
     auto res{builder.create<M::ConstantOp>(getLoc(), type, attr)};
     return res.getResult();
@@ -170,8 +166,7 @@ class ExprLowering {
   // FIXME binary operation :: ('a, 'a) -> 'a
   template<Co::TypeCategory TC, int KIND> M::FunctionType createFunctionType() {
     if constexpr (TC == IntegerCat) {
-      M::Type output{
-          getFIRType(builder.getContext(), defaults, IntegerCat, KIND)};
+      M::Type output{converter.genType(IntegerCat, KIND)};
       L::SmallVector<M::Type, 2> inputs;
       inputs.push_back(output);
       inputs.push_back(output);
@@ -227,8 +222,8 @@ class ExprLowering {
 
   M::Value *gen(Se::SymbolRef sym) {
     // FIXME: not all symbols are local
-    return createTemporary(getLoc(), builder, symMap,
-        translateSymbolToFIRType(builder.getContext(), defaults, sym), &*sym);
+    return createTemporary(
+        getLoc(), builder, symMap, converter.genType(sym), &*sym);
   }
   M::Value *gendef(Se::SymbolRef sym) { return gen(sym); }
 
@@ -334,7 +329,7 @@ class ExprLowering {
   M::Value *genval(Ev::Power<Ev::Type<TC, KIND>> const &op) {
     llvm::SmallVector<mlir::Value *, 2> operands{
         genval(op.left()), genval(op.right())};
-    M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
+    M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
   template<Co::TypeCategory TC, int KIND>
@@ -343,7 +338,7 @@ class ExprLowering {
     // are ok
     llvm::SmallVector<mlir::Value *, 2> operands{
         genval(op.left()), genval(op.right())};
-    M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
+    M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
 
@@ -397,7 +392,7 @@ class ExprLowering {
 
   template<Co::TypeCategory TC1, int KIND, Co::TypeCategory TC2>
   M::Value *genval(Ev::Convert<Ev::Type<TC1, KIND>, TC2> const &convert) {
-    auto ty{getFIRType(builder.getContext(), defaults, TC1, KIND)};
+    auto ty{converter.genType(TC1, KIND)};
     M::Value *operand{genval(convert.left())};
     if (TC1 == LogicalCat && genLogicalAsI1) {
       // If an i1 result is needed, it does not make sens to convert between
@@ -563,7 +558,7 @@ class ExprLowering {
     L::SmallVector<M::Value *, 2> coorArgs;
     auto obj{gen(*base)};
     const Se::Symbol *sym{nullptr};
-    M::Type ty{translateSymbolToFIRType(builder.getContext(), defaults, *sym)};
+    M::Type ty{converter.genType(*sym)};
     for (auto *field : list) {
       sym = &field->GetLastSymbol();
       auto name{sym->name().ToString()};
@@ -654,7 +649,7 @@ class ExprLowering {
   template<Co::TypeCategory TC, int KIND>
   M::Value *genval(const Ev::FunctionRef<Ev::Type<TC, KIND>> &funRef) {
     if (const auto &intrinsic{funRef.proc().GetSpecificIntrinsic()}) {
-      M::Type ty{getFIRType(builder.getContext(), defaults, TC, KIND)};
+      M::Type ty{converter.genType(TC, KIND)};
       L::SmallVector<M::Value *, 2> operands;
       // Lower arguments
       // For now, logical arguments for intrinsic are lowered to `fir.logical`
@@ -696,7 +691,7 @@ class ExprLowering {
           TODO();
         }
       }
-      M::Type resultType{getFIRType(builder.getContext(), defaults, TC, KIND)};
+      M::Type resultType{converter.genType(TC, KIND)};
       M::FunctionType funTy{
           M::FunctionType::get(argTypes, resultType, builder.getContext())};
       M::FuncOp func{getFunction(applyNameMangling(funRef.proc()), funTy)};
@@ -733,8 +728,7 @@ class ExprLowering {
         }
       } else if (type.isa<M::IntegerType>()) {
         if (!genLogicalAsI1) {
-          M::Type firLogicalType{
-              getFIRType(builder.getContext(), defaults, LogicalCat, KIND)};
+          M::Type firLogicalType{converter.genType(LogicalCat, KIND)};
           result =
               builder.create<fir::ConvertOp>(getLoc(), firLogicalType, result);
         }
@@ -754,13 +748,23 @@ class ExprLowering {
     return {};
   }
 
+  std::string applyNameMangling(const Ev::ProcedureDesignator &proc) {
+    if (const auto *symbol{proc.GetSymbol()}) {
+      return converter.mangleName(*symbol);
+    } else {
+      // Do not mangle intrinsic for now
+      assert(proc.GetSpecificIntrinsic() &&
+          "expected intrinsic procedure in designator");
+      return proc.GetName();
+    }
+  }
+
 public:
-  explicit ExprLowering(M::Location loc, M::OpBuilder &bldr,
-      SomeExpr const &vop, SymMap &map,
-      Co::IntrinsicTypeDefaultKinds const &defaults,
-      IntrinsicLibrary const &intr, bool logicalAsI1 = false)
-    : location{loc}, builder{bldr}, expr{vop}, symMap{map}, defaults{defaults},
-      intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
+  explicit ExprLowering(M::Location loc, AbstractConverter &converter,
+      SomeExpr const &vop, SymMap &map, IntrinsicLibrary const &intr,
+      bool logicalAsI1 = false)
+    : location{loc}, converter{converter}, builder{converter.getOpBuilder()},
+      expr{vop}, symMap{map}, intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
 
   /// Lower the expression `expr` into MLIR standard dialect
   M::Value *gen() { return gen(expr); }
@@ -769,27 +773,22 @@ class ExprLowering {
 
 }  // namespace
 
-M::Value *Br::createSomeExpression(M::Location loc, M::OpBuilder &builder,
-    Ev::Expr<Ev::SomeType> const &expr, SymMap &symMap,
-    Co::IntrinsicTypeDefaultKinds const &defaults,
-    IntrinsicLibrary const &intrinsics) {
-  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics, false}
-      .genval();
+M::Value *Br::createSomeExpression(M::Location loc,
+    Br::AbstractConverter &converter, Ev::Expr<Ev::SomeType> const &expr,
+    SymMap &symMap, IntrinsicLibrary const &intrinsics) {
+  return ExprLowering{loc, converter, expr, symMap, intrinsics, false}.genval();
 }
 
-M::Value *Br::createI1LogicalExpression(M::Location loc, M::OpBuilder &builder,
-    Ev::Expr<Ev::SomeType> const &expr, SymMap &symMap,
-    Co::IntrinsicTypeDefaultKinds const &defaults,
-    IntrinsicLibrary const &intrinsics) {
-  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics, true}
-      .genval();
+M::Value *Br::createI1LogicalExpression(M::Location loc,
+    Br::AbstractConverter &converter, Ev::Expr<Ev::SomeType> const &expr,
+    SymMap &symMap, IntrinsicLibrary const &intrinsics) {
+  return ExprLowering{loc, converter, expr, symMap, intrinsics, true}.genval();
 }
 
-M::Value *Br::createSomeAddress(M::Location loc, M::OpBuilder &builder,
-    Ev::Expr<Ev::SomeType> const &expr, SymMap &symMap,
-    Co::IntrinsicTypeDefaultKinds const &defaults,
-    IntrinsicLibrary const &intrinsics) {
-  return ExprLowering{loc, builder, expr, symMap, defaults, intrinsics}.gen();
+M::Value *Br::createSomeAddress(M::Location loc,
+    Br::AbstractConverter &converter, Ev::Expr<Ev::SomeType> const &expr,
+    SymMap &symMap, IntrinsicLibrary const &intrinsics) {
+  return ExprLowering{loc, converter, expr, symMap, intrinsics}.gen();
 }
 
 /// Create a temporary variable
diff --git a/lib/burnside/convert-expr.h b/lib/burnside/convert-expr.h
index b731b3390d91..a05ab6efad08 100644
--- a/lib/burnside/convert-expr.h
+++ b/lib/burnside/convert-expr.h
@@ -44,22 +44,22 @@ class Symbol;
 
 namespace burnside {
 
+class AbstractConverter;
 class SymMap;
 
-mlir::Value *createSomeExpression(mlir::Location loc, mlir::OpBuilder &builder,
-    evaluate::Expr<evaluate::SomeType> const &expr, SymMap &symMap,
-    common::IntrinsicTypeDefaultKinds const &defaults,
-    IntrinsicLibrary const &intrinsics);
+mlir::Value *createSomeExpression(mlir::Location loc,
+    AbstractConverter &converter,
+    const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
+    const IntrinsicLibrary &intrinsics);
 
 mlir::Value *createI1LogicalExpression(mlir::Location loc,
-    mlir::OpBuilder &builder, evaluate::Expr<evaluate::SomeType> const &expr,
-    SymMap &symMap, common::IntrinsicTypeDefaultKinds const &defaults,
-    IntrinsicLibrary const &intrinsics);
+    AbstractConverter &converter,
+    const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
+    const IntrinsicLibrary &intrinsics);
 
-mlir::Value *createSomeAddress(mlir::Location loc, mlir::OpBuilder &builder,
-    evaluate::Expr<evaluate::SomeType> const &expr, SymMap &symMap,
-    common::IntrinsicTypeDefaultKinds const &defaults,
-    IntrinsicLibrary const &intrinsics);
+mlir::Value *createSomeAddress(mlir::Location loc, AbstractConverter &converter,
+    const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
+    const IntrinsicLibrary &intrinsics);
 
 mlir::Value *createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
     SymMap &symMap, mlir::Type type, const semantics::Symbol *symbol);
diff --git a/lib/burnside/convert-type.cc b/lib/burnside/convert-type.cc
index 81c53a2e70da..35b61daac0e0 100644
--- a/lib/burnside/convert-type.cc
+++ b/lib/burnside/convert-type.cc
@@ -51,8 +51,7 @@ template<typename A> int64_t toConstant(const Ev::Expr<A> &e) {
   return {}
 
 // one argument template, must be specialized
-template<Co::TypeCategory TC>
-M::Type genFIRType(M::MLIRContext *context, int kind) {
+template<Co::TypeCategory TC> M::Type genFIRType(M::MLIRContext *, int) {
   return {};
 }
 
diff --git a/lib/burnside/mangler.cc b/lib/burnside/mangler.cc
index ee05cc836dd2..1cbca9e387d0 100644
--- a/lib/burnside/mangler.cc
+++ b/lib/burnside/mangler.cc
@@ -70,21 +70,21 @@ L::Optional<L::StringRef> hostName(const Se::Scope *scope) {
 // Mangle the name of `symbol` to make it unique within FIR's symbol table using
 // the FIR name mangler, `mangler`
 std::string Ma::mangleName(
-    fir::NameMangler &mangler, const Se::SymbolRef symbol) {
+    fir::NameUniquer &uniquer, const Se::SymbolRef symbol) {
   return std::visit(Co::visitors{
                         [&](const Se::MainProgramDetails &) {
-                          return mangler.doProgramEntry().str();
+                          return uniquer.doProgramEntry().str();
                         },
                         [&](const Se::SubprogramDetails &) {
                           auto &cb{symbol->name()};
                           auto modNames{moduleNames(symbol->scope())};
-                          return mangler.doProcedure(modNames,
+                          return uniquer.doProcedure(modNames,
                               hostName(symbol->scope()), toStringRef(cb));
                         },
                         [&](const Se::ProcEntityDetails &) {
                           auto &cb{symbol->name()};
                           auto modNames{moduleNames(symbol->scope())};
-                          return mangler.doProcedure(modNames,
+                          return uniquer.doProcedure(modNames,
                               hostName(symbol->scope()), toStringRef(cb));
                         },
                         [](const auto &) -> std::string {
@@ -96,5 +96,6 @@ std::string Ma::mangleName(
 }
 
 std::string Ma::demangleName(L::StringRef name) {
-  return name.str();
+  auto result{fir::NameUniquer::deconstruct(name)};
+  return result.second.name;
 }
diff --git a/lib/burnside/mangler.h b/lib/burnside/mangler.h
index 145640ac5135..11da39c38d4b 100644
--- a/lib/burnside/mangler.h
+++ b/lib/burnside/mangler.h
@@ -18,7 +18,7 @@
 #include <string>
 
 namespace fir {
-struct NameMangler;
+struct NameUniquer;
 }
 
 namespace llvm {
@@ -40,7 +40,7 @@ using SymbolRef = common::Reference<const semantics::Symbol>;
 namespace mangle {
 
 /// Convert a front-end Symbol to an internal name
-std::string mangleName(fir::NameMangler &mangler, const SymbolRef symbol);
+std::string mangleName(fir::NameUniquer &uniquer, const SymbolRef symbol);
 
 std::string demangleName(llvm::StringRef name);
 
diff --git a/lib/fir/InternalNames.cpp b/lib/fir/InternalNames.cpp
index b9a47cfd24b0..f6b160cc44e9 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/fir/InternalNames.cpp
@@ -13,9 +13,8 @@
 // limitations under the License.
 
 #include "fir/InternalNames.h"
-#include "llvm/ADT/ArrayRef.h"
+#include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 
 namespace L = llvm;
@@ -47,18 +46,18 @@ std::string doModulesHost(L::ArrayRef<L::StringRef> mods,
 
 } // namespace
 
-L::StringRef fir::NameMangler::toLower(L::StringRef name) {
+L::StringRef fir::NameUniquer::toLower(L::StringRef name) {
   auto lo = name.lower();
   if (name.equals(lo))
     return name;
   return cache.insert(lo).first->getKey();
 }
 
-L::StringRef fir::NameMangler::addAsString(std::int64_t i) {
+L::StringRef fir::NameUniquer::addAsString(std::int64_t i) {
   return cache.insert(std::to_string(i)).first->getKey();
 }
 
-std::string fir::NameMangler::doKind(std::int64_t kind) {
+std::string fir::NameUniquer::doKind(std::int64_t kind) {
   if (kind < 0) {
     L::Twine result = "KN" + addAsString(-kind);
     return result.str();
@@ -67,25 +66,25 @@ std::string fir::NameMangler::doKind(std::int64_t kind) {
   return result.str();
 }
 
-std::string fir::NameMangler::doKinds(L::ArrayRef<std::int64_t> kinds) {
+std::string fir::NameUniquer::doKinds(L::ArrayRef<std::int64_t> kinds) {
   L::Twine result;
   for (auto i : kinds)
     result.concat(doKind(i));
   return result.str();
 }
 
-std::string fir::NameMangler::doCommonBlock(L::StringRef name) {
+std::string fir::NameUniquer::doCommonBlock(L::StringRef name) {
   L::Twine result = prefix() + "B" + toLower(name);
   return result.str();
 }
 
-std::string fir::NameMangler::doConstant(L::ArrayRef<L::StringRef> modules,
+std::string fir::NameUniquer::doConstant(L::ArrayRef<L::StringRef> modules,
                                          L::StringRef name) {
   L::Twine result = prefix() + doModules(modules) + "EC" + toLower(name);
   return result.str();
 }
 
-std::string fir::NameMangler::doDispatchTable(L::ArrayRef<L::StringRef> modules,
+std::string fir::NameUniquer::doDispatchTable(L::ArrayRef<L::StringRef> modules,
                                               L::Optional<L::StringRef> host,
                                               L::StringRef name,
                                               L::ArrayRef<std::int64_t> kinds) {
@@ -94,15 +93,15 @@ std::string fir::NameMangler::doDispatchTable(L::ArrayRef<L::StringRef> modules,
   return result.str();
 }
 
-std::string fir::NameMangler::doGenerated(L::StringRef name) {
+std::string fir::NameUniquer::doGenerated(L::StringRef name) {
   L::Twine result = prefix() + "Q" + toLower(name);
   return result.str();
 }
 
-std::string fir::NameMangler::doIntrinsicTypeDescriptor(
+std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
     L::ArrayRef<L::StringRef> modules, L::Optional<L::StringRef> host,
     IntrinsicType type, std::int64_t kind) {
-  char const *name;
+  const char *name{nullptr};
   switch (type) {
   case IntrinsicType::CHARACTER:
     name = "character";
@@ -125,7 +124,7 @@ std::string fir::NameMangler::doIntrinsicTypeDescriptor(
   return result.str();
 }
 
-std::string fir::NameMangler::doProcedure(L::ArrayRef<L::StringRef> modules,
+std::string fir::NameUniquer::doProcedure(L::ArrayRef<L::StringRef> modules,
                                           L::Optional<L::StringRef> host,
                                           L::StringRef name) {
   L::Twine result =
@@ -133,7 +132,7 @@ std::string fir::NameMangler::doProcedure(L::ArrayRef<L::StringRef> modules,
   return result.str();
 }
 
-std::string fir::NameMangler::doType(L::ArrayRef<L::StringRef> modules,
+std::string fir::NameUniquer::doType(L::ArrayRef<L::StringRef> modules,
                                      L::Optional<L::StringRef> host,
                                      L::StringRef name,
                                      L::ArrayRef<std::int64_t> kinds) {
@@ -142,7 +141,7 @@ std::string fir::NameMangler::doType(L::ArrayRef<L::StringRef> modules,
   return result.str();
 }
 
-std::string fir::NameMangler::doTypeDescriptor(
+std::string fir::NameUniquer::doTypeDescriptor(
     L::ArrayRef<L::StringRef> modules, L::Optional<L::StringRef> host,
     L::StringRef name, L::ArrayRef<std::int64_t> kinds) {
   L::Twine result = prefix() + doModulesHost(modules, host) + "CT" +
@@ -150,8 +149,14 @@ std::string fir::NameMangler::doTypeDescriptor(
   return result.str();
 }
 
-std::string fir::NameMangler::doVariable(L::ArrayRef<L::StringRef> modules,
+std::string fir::NameUniquer::doVariable(L::ArrayRef<L::StringRef> modules,
                                          L::StringRef name) {
   L::Twine result = prefix() + doModules(modules) + "E" + toLower(name);
   return result.str();
 }
+
+std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
+fir::NameUniquer::deconstruct(L::StringRef uniquedName) {
+  assert(false && "not yet implemented");
+  return {};
+}
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index 38a42db10dca..38f9643f4c7e 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -78,8 +78,8 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
   static L::StringMap<M::LLVM::LLVMType> identStructCache;
 
 public:
-  FIRToLLVMTypeConverter(M::MLIRContext *context, NameMangler &mangler)
-      : LLVMTypeConverter(context), kindMapping(context), mangler(mangler) {}
+  FIRToLLVMTypeConverter(M::MLIRContext *context, NameUniquer &uniquer)
+      : LLVMTypeConverter(context), kindMapping(context), uniquer(uniquer) {}
 
   // This returns the type of a single column. Rows are added by the caller.
   // fir.dims<r>  -->  llvm<"[r x [3 x i64]]">
@@ -311,7 +311,7 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
     return wrappedLLVMType;
   }
 
-  NameMangler &mangler;
+  NameUniquer &uniquer;
 };
 
 // instantiate static data member
@@ -1330,7 +1330,7 @@ struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
                   M::ConversionPatternRewriter &rewriter) const override {
     auto gentypedesc = M::cast<GenTypeDescOp>(op);
     auto ty = unwrap(convertType(gentypedesc.getInType())).getPointerTo();
-    std::string name = "fixme"; // FIXME: get the mangled name
+    std::string name = "fixme"; // FIXME: get the uniqued name
     rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(gentypedesc, ty, name);
     return matchSuccess();
   }
@@ -1896,14 +1896,14 @@ struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
 /// This pass lowers all FIR dialect operations to LLVM IR dialect.  An
 /// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
 struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
-  FIRToLLVMLoweringPass(NameMangler &mangler) : mangler{mangler} {}
+  FIRToLLVMLoweringPass(NameUniquer &uniquer) : uniquer{uniquer} {}
 
   void runOnModule() override {
     if (ClDisableFirToLLVMIR)
       return;
 
     auto *context{&getContext()};
-    FIRToLLVMTypeConverter typeConverter{context, mangler};
+    FIRToLLVMTypeConverter typeConverter{context, uniquer};
     M::OwningRewritePatternList patterns;
     patterns.insert<
         AddcOpConversion, AddfOpConversion, AddrOfOpConversion,
@@ -1955,7 +1955,7 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
     }
   }
 
-  NameMangler &mangler;
+  NameUniquer &uniquer;
 };
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
@@ -1986,8 +1986,8 @@ struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
 } // namespace
 
 std::unique_ptr<M::Pass>
-fir::createFIRToLLVMPass(fir::NameMangler &nameMangler) {
-  return std::make_unique<FIRToLLVMLoweringPass>(nameMangler);
+fir::createFIRToLLVMPass(fir::NameUniquer &nameUniquer) {
+  return std::make_unique<FIRToLLVMLoweringPass>(nameUniquer);
 }
 
 std::unique_ptr<M::Pass> fir::createLLVMDialectToLLVMPass(L::StringRef output) {
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index d21bfbeea490..372ad88370de 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -269,10 +269,10 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   }
 
   // MLIR+FIR
-  fir::NameMangler nameMangler;
+  fir::NameUniquer nameUniquer;
   auto burnside = Br::BurnsideBridge::create(
       semanticsContext.defaultKinds(), &parsing.cooked());
-  burnside.lower(parseTree, nameMangler);
+  burnside.lower(parseTree, nameUniquer);
   mlir::ModuleOp mlirModule{burnside.getModule()};
   mlir::PassManager pm{mlirModule.getContext()};
   if (driver.dumpHLFIR) {
@@ -289,7 +289,7 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
     pm.addPass(fir::createLowerToLoopPass());
     pm.addPass(fir::createFIRToStdPass());
     pm.addPass(mlir::createLowerToCFGPass());
-    pm.addPass(fir::createFIRToLLVMPass(nameMangler));
+    pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
   }
   if (driver.lowerToLLVMIR) {
     pm.addPass(fir::createLLVMDialectToLLVMPass("a.ll"));
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 6037e10ea66a..4c927d8548c3 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -37,7 +37,7 @@ set(EXE_LIBS
   MLIRSupport
   MLIRTransforms
   MLIRVectorOps
-  MLIRVectorConversions
+  MLIRVectorToLLVM
 )
 
 add_llvm_tool(tco tco.cpp)
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index dbb8bbbe7709..b51b0be2481d 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -67,7 +67,7 @@ int compileFIR() {
   owningRef->dump();
 
   // run passes
-  fir::NameMangler mangler;
+  fir::NameUniquer uniquer;
   mlir::PassManager pm{context.get()};
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
@@ -78,7 +78,7 @@ int compileFIR() {
   pm.addPass(fir::createFIRToStdPass());
   // convert loop dialect to standard
   pm.addPass(mlir::createLowerToCFGPass());
-  pm.addPass(fir::createFIRToLLVMPass(mangler));
+  pm.addPass(fir::createFIRToLLVMPass(uniquer));
   pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput));
   if (mlir::succeeded(pm.run(*owningRef))) {
     errs() << ";== output ==\n";

From a66d0dd090c5b1037f8580ca48efb6513eef62de Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 13 Dec 2019 04:46:49 -0800
Subject: [PATCH 140/345] MERGE lowering and MIN/MAX/CONJG/Comparisons lowering
 update - MERGE: use MLIR `SelectOP` - MIN/MAX: also use `SelectOp`. Provide
 different ways to   compare MIN/MAX operands to match existing behaviors  
 with NaNs. Use Minss/Maxss for now because it matches   ifort, nagfor and
 pgfortran -noillvm behavior. - CONJG: use `fir::NegfOp` instead of a
 substraction - Comparisons: Changed Real comparions to ordered comparions  
 but for .NE. that remains `UNE`. This matches other compilers   behavior and
 is closer from Fortran 2018 table 17.1 requirements   in IEEE contexts.
 Comments regarding failure to fulfill IEEE requirements regarding the
 signaling/quiet aspect of the result for MIN/MAX/Comparisons is added (Need
 llvm update or custom runtime).

---
 lib/burnside/convert-expr.cc |  20 +++--
 lib/burnside/intrinsics.cc   | 137 ++++++++++++++++++++++++++---------
 2 files changed, 114 insertions(+), 43 deletions(-)

diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 240dbc650472..93977060607e 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -90,17 +90,23 @@ class ExprLowering {
     return {};
   }
 
-  /// Convert parser's REAL relational operators to MLIR.  TODO: using
-  /// unordered, but we may want to cons ordered in certain situation.
+  /// Convert parser's REAL relational operators to MLIR.
+  /// The choice of order (O prefix) vs unorder (U prefix) follows Fortran 2018
+  /// requirements in the IEEE context (table 17.1 of F2018). This choice is
+  /// also applied in other contexts because it is easier and in line with
+  /// other Fortran compilers.
+  /// FIXME: The signaling/quiet aspect of the table 17.1 requirement is not
+  /// fully enforced. FIR and LLVM `fcmp` instructions do not give any guarantee
+  /// whether the comparison will signal or not in case of quiet NaN argument.
   static fir::CmpFPredicate translateFloatRelational(
       Co::RelationalOperator rop) {
     switch (rop) {
-    case Co::RelationalOperator::LT: return fir::CmpFPredicate::ULT;
-    case Co::RelationalOperator::LE: return fir::CmpFPredicate::ULE;
-    case Co::RelationalOperator::EQ: return fir::CmpFPredicate::UEQ;
+    case Co::RelationalOperator::LT: return fir::CmpFPredicate::OLT;
+    case Co::RelationalOperator::LE: return fir::CmpFPredicate::OLE;
+    case Co::RelationalOperator::EQ: return fir::CmpFPredicate::OEQ;
     case Co::RelationalOperator::NE: return fir::CmpFPredicate::UNE;
-    case Co::RelationalOperator::GT: return fir::CmpFPredicate::UGT;
-    case Co::RelationalOperator::GE: return fir::CmpFPredicate::UGE;
+    case Co::RelationalOperator::GT: return fir::CmpFPredicate::OGT;
+    case Co::RelationalOperator::GE: return fir::CmpFPredicate::OGE;
     }
     assert(false && "unhandled REAL relational operator");
     return {};
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index 753d30b7e7f8..253a973c146a 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -72,8 +72,47 @@ class MathRuntimeLibrary {
   Map library;
 };
 
-/// enum used to templatized code gen for intrinsics that are alike.
+/// Enums used to templatize and share lowering of MIN and MAX.
 enum class Extremum { Min, Max };
+// There are different ways to deal with NaNs in MIN and MAX.
+// Known existing behaviors are listed below and can be selected for
+// f18 MIN/MAX implementation.
+enum class ExtremumBehavior {
+  // Note: the Signaling/quiet aspect of NaNs in the behaviors below are
+  // not described because there is no way to control/observe such aspect in
+  // MLIR/LLVM yet. The IEEE behaviors come with requirements regarding this
+  // aspect that are therefore currently not enforced. In the descriptions
+  // below, NaNs can be signaling or quite. Returned NaNs may be signaling
+  // if one of the input NaN was signaling but it cannot be guaranteed either.
+  // Existing compilers using an IEEE behavior (gfortran) also do not fulfill
+  // signaling/quiet requirements.
+  IeeeMinMaximumNumber,
+  // IEEE minimumNumber/maximumNumber behavior (754-2019, section 9.6):
+  // If one of the argument is and number and the other is NaN, return the
+  // number. If both arguements are NaN, return NaN.
+  // Compilers: gfortran.
+  IeeeMinMaximum,
+  // IEEE minimum/maximum behavior (754-2019, section 9.6):
+  // If one of the argument is NaN, return NaN.
+  MinMaxss,
+  // x86 minss/maxss behavior:
+  // If the second argument is a number and the other is NaN, return the number.
+  // In all other cases where at least one operand is NaN, return NaN.
+  // Compilers: xlf (only for MAX), ifort, pgfortran -nollvm, and nagfor.
+  PgfortranLlvm,
+  // "Opposite of" x86 minss/maxss behavior:
+  // If the first argument is a number and the other is NaN, return the
+  // number.
+  // In all other cases where at least one operand is NaN, return NaN.
+  // Compilers: xlf (only for MIN), and pgfortran (with llvm).
+  IeeeMinMaxNum
+  // IEEE minNum/maxNum behavior (754-2008, section 5.3.1):
+  // TODO: Not implemented.
+  // It is the only behavior where the signaling/quiet aspect of a NaN argument
+  // impacts if the result should be NaN or the argument that is a number.
+  // LLVM/MLIR do not provide ways to observe this aspect, so it is not
+  // possible to implement it without some target dependent runtime.
+};
 
 /// The implementation of IntrinsicLibrary is based on a map that associates
 /// Fortran intrinsics generic names to the related FIR generator functions.
@@ -141,7 +180,9 @@ class IntrinsicLibrary::Implementation {
     return genWrapperCall<&I::genRuntimeCall>(c);
   }
   mlir::Value *genConjg(Context &) const;
-  template<Extremum extremum> mlir::Value *genExtremum(Context &) const;
+  template<Extremum, ExtremumBehavior>
+  mlir::Value *genExtremum(Context &) const;
+  mlir::Value *genMerge(Context &) const;
 
   struct IntrinsicHanlder {
     const char *name;
@@ -154,8 +195,9 @@ class IntrinsicLibrary::Implementation {
   /// be attempted.
   static constexpr IntrinsicHanlder handlers[]{
       {"conjg", &I::genConjg},
-      {"max", &I::genExtremum<Extremum::Max>},
-      {"min", &I::genExtremum<Extremum::Min>},
+      {"max", &I::genExtremum<Extremum::Max, ExtremumBehavior::MinMaxss>},
+      {"min", &I::genExtremum<Extremum::Min, ExtremumBehavior::MinMaxss>},
+      {"merge", &I::genMerge},
   };
 
   // helpers
@@ -577,41 +619,71 @@ mlir::Value *IntrinsicLibrary::Implementation::genConjg(
   mlir::OpBuilder &builder{*genCtxt.builder};
   ComplexHandler cplxHandler{builder, genCtxt.loc};
 
-  // TODO a negation unary would be better than a sub to zero ?
   mlir::Value *cplx{genCtxt.arguments[0]};
-  mlir::Type realType{cplxHandler.getComplexPartType(cplx)};
-  mlir::Value *zero{builder.create<mlir::ConstantOp>(
-      genCtxt.loc, realType, builder.getZeroAttr(realType))};
   mlir::Value *imag{cplxHandler.extract<ComplexHandler::Part::Imag>(cplx)};
-  mlir::Value *negImag{
-      genCtxt.builder->create<mlir::SubFOp>(genCtxt.loc, zero, imag)};
+  mlir::Value *negImag{genCtxt.builder->create<fir::NegfOp>(genCtxt.loc, imag)};
   return cplxHandler.insert<ComplexHandler::Part::Imag>(cplx, negImag);
 }
 
-static mlir::FuncOp getMergeFunc(mlir::Type type, mlir::ModuleOp module) {
-  llvm::SmallVector<mlir::Type, 3> argTypes{
-      type, type, fir::LogicalType::get(module.getContext(), 4)};
-  auto mergeType{
-      mlir::FunctionType::get(argTypes, {type}, module.getContext())};
-  auto mergeName{getIntrinsicWrapperName("merge", mergeType)};
-  return createFunction(module, mergeName, mergeType);
+// MERGE
+mlir::Value *IntrinsicLibrary::Implementation::genMerge(
+    Context &genCtxt) const {
+  assert(genCtxt.arguments.size() == 3);
+  mlir::Type resType{genCtxt.getResultType()};
+  mlir::OpBuilder &builder{*genCtxt.builder};
+
+  auto *trueVal{genCtxt.arguments[0]};
+  auto *falseVal{genCtxt.arguments[1]};
+  auto *mask{genCtxt.arguments[2]};
+  mlir::Type i1Type{mlir::IntegerType::get(1, builder.getContext())};
+  mask = builder.create<fir::ConvertOp>(genCtxt.loc, i1Type, mask);
+  return builder.create<mlir::SelectOp>(genCtxt.loc, mask, trueVal, falseVal);
 }
 
-template<Extremum extremum>
-static mlir::Value *createCompare(mlir::Location loc, mlir::OpBuilder &builder,
-    mlir::Value *left, mlir::Value *right) {
+// Compare two FIR values and return boolean result as i1.
+template<Extremum extremum, ExtremumBehavior behavior>
+static mlir::Value *createExtremumCompare(mlir::Location loc,
+    mlir::OpBuilder &builder, mlir::Value *left, mlir::Value *right) {
   static constexpr auto integerPredicate{extremum == Extremum::Max
           ? mlir::CmpIPredicate::sgt
           : mlir::CmpIPredicate::slt};
-  static constexpr auto realPredicate{extremum == Extremum::Max
+  static constexpr auto unorderedCmp{extremum == Extremum::Max
           ? fir::CmpFPredicate::UGT
           : fir::CmpFPredicate::ULT};
+  static constexpr auto orderedCmp{extremum == Extremum::Max
+          ? fir::CmpFPredicate::OGT
+          : fir::CmpFPredicate::OLT};
   auto type{left->getType()};
   mlir::Value *result{nullptr};
   if (type.isa<mlir::FloatType>() || type.isa<fir::RealType>()) {
-    // TODO: The type we get from CmpfOp is a bit weird (it is the operands
-    // types, and not a boolean).
-    result = builder.create<fir::CmpfOp>(loc, realPredicate, left, right);
+    // Note: the signaling/quit aspect of the result required by IEEE
+    // cannot currently be obtained with LLVM without ad-hoc runtime.
+    if constexpr (behavior == ExtremumBehavior::IeeeMinMaximumNumber) {
+      // Return the number if one of the inputs is NaN and the other is
+      // a number.
+      auto leftIsResult{
+          builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
+      auto rightIsNan{builder.create<fir::CmpfOp>(
+          loc, fir::CmpFPredicate::UNE, right, right)};
+      result = builder.create<mlir::OrOp>(loc, leftIsResult, rightIsNan);
+    } else if constexpr (behavior == ExtremumBehavior::IeeeMinMaximum) {
+      // Always return NaNs if one the input is NaNs
+      auto leftIsResult{
+          builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
+      auto leftIsNan{builder.create<fir::CmpfOp>(
+          loc, fir::CmpFPredicate::UNE, left, left)};
+      result = builder.create<mlir::OrOp>(loc, leftIsResult, leftIsNan);
+    } else if constexpr (behavior == ExtremumBehavior::MinMaxss) {
+      // If the left is a NaN, return the right whatever it is.
+      result = builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
+    } else if constexpr (behavior == ExtremumBehavior::PgfortranLlvm) {
+      // If one of the operand is a NaN, return left whatever it is.
+      result = builder.create<fir::CmpfOp>(loc, unorderedCmp, left, right);
+    } else {
+      // TODO: ieeMinNum/ieeeMaxNum
+      static_assert(behavior == ExtremumBehavior::IeeeMinMaxNum,
+          "ieeeMinNum/ieeMaxNum behavior not implemented");
+    }
   } else if (type.isa<mlir::IntegerType>()) {
     result = builder.create<mlir::CmpIOp>(loc, integerPredicate, left, right);
   } else if (type.isa<fir::CharacterType>()) {
@@ -620,28 +692,21 @@ static mlir::Value *createCompare(mlir::Location loc, mlir::OpBuilder &builder,
     // So we may need a temp.
   }
   assert(result);
-  // TODO which logical type should comparisons return ?
-  // This is also currently not observed in convert-expr
-  auto resTy{fir::LogicalType::get(getModule(&builder).getContext(), 4)};
-  return builder.create<fir::ConvertOp>(loc, resTy, result);
+  return result;
 }
 
 // MIN and MAX
-// Extremum intrinsic are lowered using the MERGE intrinsic
-// to avoid introducing branches.
-template<Extremum extremum>
+template<Extremum extremum, ExtremumBehavior behavior>
 mlir::Value *IntrinsicLibrary::Implementation::genExtremum(
     Context &genCtxt) const {
   auto &builder{*genCtxt.builder};
   auto loc{genCtxt.loc};
   assert(genCtxt.arguments.size() >= 2);
   auto *result{genCtxt.arguments[0]};
-  auto mergeFunc{getMergeFunc(result->getType(), genCtxt.getModuleOp())};
   for (auto *arg : genCtxt.arguments.drop_front()) {
-    auto mask{createCompare<extremum>(loc, builder, result, arg)};
-    llvm::SmallVector<mlir::Value *, 3> mergeArgs{result, arg, mask};
-    result =
-        builder.create<mlir::CallOp>(loc, mergeFunc, mergeArgs).getResult(0);
+    auto mask{
+        createExtremumCompare<extremum, behavior>(loc, builder, result, arg)};
+    result = builder.create<mlir::SelectOp>(loc, mask, result, arg);
   }
   return result;
 }

From 8499e376eb40bb0ca563463aed8f4485a696ac45 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 13 Dec 2019 13:49:55 -0800
Subject: [PATCH 141/345] Fixes to the CMake files to enable in-tree and
 out-of-tree building.  Out-of-tree also requires changes a few changes to
 MLIR to get all the pieces installed for use.

How To Notes:

1. For an in-tree build, we cloned the monorepo and put a link to mlir in llvm/projects and a link to f18 named flang in the top-level.  The usual process should work.

  mkdir build ; cd build
  export CC=<c compiler>
  export CXX=<c++ compiler>
  cmake ../llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD=X86 -DCMAKE_CXX_STANDARD=17 -DLLVM_ENABLE_PROJECTS=flang -DCMAKE_INSTALL_PREFIX=/tmp
  make

2. For an out-of-tree build, we have two steps. First, build and install LLVM and MLIR. Second, build f18.

For part one, we still need to link mlir in llvm/projects.  No flang link is needed.

  mkdir build ; cd build
  export CC=<c compiler>
  export CXX=<c++ compiler>
  cmake ../llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD=X86 -DCMAKE_CXX_STANDARD=17 -DCMAKE_INSTALL_PREFIX=/tmp/llvm
  make
  make install

For part two, we create a second build area and build the f18 bits there.

  cd .../flang-compiler/f18 ; mkdir build ; cd build
  PATH=/tmp/llvm/bin:$PATH
  cmake .. -DLLVM_DIR=/tmp/llvm -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/tmp/flang -DLLVM_BUILD_TOOLS=On
  make
---
 include/fir/CMakeLists.txt  | 4 ++++
 lib/burnside/CMakeLists.txt | 2 +-
 lib/fir/CMakeLists.txt      | 2 ++
 tools/bbc/CMakeLists.txt    | 1 +
 tools/tco/CMakeLists.txt    | 1 +
 5 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/include/fir/CMakeLists.txt b/include/fir/CMakeLists.txt
index 9528b1abffb0..1e75d7e3efbc 100644
--- a/include/fir/CMakeLists.txt
+++ b/include/fir/CMakeLists.txt
@@ -1,3 +1,7 @@
+if (LLVM_DIR)
+  include(AddMLIR)
+endif()
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 set(LLVM_TARGET_DEFINITIONS FIROps.td)
 mlir_tablegen(FIROps.h.inc -gen-op-decls)
 mlir_tablegen(FIROps.cpp.inc -gen-op-defs)
diff --git a/lib/burnside/CMakeLists.txt b/lib/burnside/CMakeLists.txt
index 9844363ac39e..1c004e731e96 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/burnside/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 
 add_library(FortranBurnside
   ast-builder.cc
diff --git a/lib/fir/CMakeLists.txt b/lib/fir/CMakeLists.txt
index 54587daaf7f1..cb11645a22c0 100644
--- a/lib/fir/CMakeLists.txt
+++ b/lib/fir/CMakeLists.txt
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
+
 add_subdirectory(Transforms)
 
 add_llvm_library(FIR
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index a13b7b96d446..36f351529fd1 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIR
   MLIRAffineOps
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 4c927d8548c3..115f949ae573 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIR
   MLIRAffineOps

From aa52ef6238ef1983f28e931f7f2dc6ec9086218b Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 18 Dec 2019 07:58:18 -0800
Subject: [PATCH 142/345] Lowering Character dummy argument to boxchar type
 This commit does it for all character dummy arguments. IsDescriptor need to
 be changed or another function used to determine when a descriptor is needed.
 Do not make a difference between external/internal procedure for now.

---
 lib/burnside/bridge.cc       | 31 +++++++---------------
 lib/burnside/convert-type.cc | 50 +++++++++++++++++++++++++++++-------
 lib/burnside/convert-type.h  |  3 +++
 3 files changed, 53 insertions(+), 31 deletions(-)

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 53ef8b7a2518..24fa8975492f 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -52,8 +52,7 @@ L::cl::opt<bool> ClDisableToDoAssert("disable-burnside-todo",
     L::cl::Hidden);
 
 #undef TODO
-#define TODO() \
-  assert(false && "not implemented yet")
+#define TODO() assert(false && "not implemented yet")
 
 using SelectCaseConstruct = Pa::CaseConstruct;
 using SelectRankConstruct = Pa::SelectRankConstruct;
@@ -342,9 +341,7 @@ class FirConverter : public AbstractConverter {
   void genFIRIOSwitch(AST::Evaluation &) { TODO(); }
 
   // Iterative loop control-flow semantics
-  void genFIREvalIterative(AST::Evaluation &) {
-    TODO();
-  }
+  void genFIREvalIterative(AST::Evaluation &) { TODO(); }
 
   void switchInsertionPointToWhere(fir::WhereOp &where) {
     builder->setInsertionPointToStart(&where.whereRegion().front());
@@ -514,7 +511,7 @@ class FirConverter : public AbstractConverter {
     auto funTy{M::FunctionType::get(argTy, resTy, builder->getContext())};
     // FIXME: mangle name
     M::FuncOp func{getFunc(funName, funTy)};
-    (void)func; // FIXME
+    (void)func;  // FIXME
     std::vector<M::Value *> actuals;
     for (auto &aa : std::get<std::list<Pa::ActualArgSpec>>(stmt.v.t)) {
       auto &kw = std::get<std::optional<Pa::Keyword>>(aa.t);
@@ -836,22 +833,8 @@ class FirConverter : public AbstractConverter {
     // get arguments and return type if any, otherwise just use empty vectors
     L::SmallVector<M::Type, 8> args;
     L::SmallVector<M::Type, 2> results;
-    if (symbol) {
-      auto *details{symbol->detailsIf<Se::SubprogramDetails>()};
-      assert(details && "details for semantics::Symbol must be subprogram");
-      for (auto *a : details->dummyArgs()) {
-        if (a) {  // nullptr indicates alternate return argument
-          auto type{genType(*a)};
-          args.push_back(fir::ReferenceType::get(type));
-        }
-      }
-      if (details->isFunction()) {
-        // FIXME: handle subroutines that return magic values
-        auto result{details->result()};
-        results.push_back(genType(result));
-      }
-    }
-    auto funcTy{M::FunctionType::get(args, results, &mlirContext)};
+    auto funcTy{symbol ? genFunctionType(*symbol)
+                       : M::FunctionType::get(args, results, &mlirContext)};
     return createFunction(*this, name, funcTy);
   }
 
@@ -1083,6 +1066,10 @@ class FirConverter : public AbstractConverter {
     }
   }
 
+  M::FunctionType genFunctionType(SymbolRef sym) {
+    return translateSymbolToFIRFunctionType(&mlirContext, defaults, sym);
+  }
+
   //
   // AbstractConverter overrides
 
diff --git a/lib/burnside/convert-type.cc b/lib/burnside/convert-type.cc
index 35b61daac0e0..173f82d3d213 100644
--- a/lib/burnside/convert-type.cc
+++ b/lib/burnside/convert-type.cc
@@ -247,24 +247,51 @@ class TypeBuilder {
     return bounds;
   }
 
-  /// Type consing from a symbol. A symbol's type must be created from the type
-  /// discovered by the front-end at runtime.
-  M::Type gen(Se::SymbolRef symbol) {
+  M::Type genDummyArgType(const Se::Symbol &dummy) {
+    if (auto *type{dummy.GetType()}) {
+      auto *tySpec{type->AsIntrinsic()};
+      if (tySpec && tySpec->category() == CharacterCat) {
+        auto kind = toConstant(tySpec->kind());
+        return fir::BoxCharType::get(context, kind);
+      }
+    }
+    if (Se::IsDescriptor(dummy)) {
+      // FIXME: This should be the first case, but it seems to
+      // fire at assumed length character on purpose which is
+      // not what I expect.
+      TODO();
+    }
+    return fir::ReferenceType::get(gen(dummy));
+  }
+
+  M::FunctionType genFunctionType(Se::SymbolRef symbol) {
+    llvm::SmallVector<M::Type, 1> returnTys;
+    llvm::SmallVector<M::Type, 4> inputTys;
     if (auto *proc = symbol->detailsIf<Se::SubprogramDetails>()) {
-      M::Type returnTy{mkVoid()};
       if (proc->isFunction()) {
-        returnTy = gen(proc->result());
+        returnTys.emplace_back(gen(proc->result()));
       }
       // FIXME: handle alt-return
-      llvm::SmallVector<M::Type, 4> inputTys;
       for (auto *arg : proc->dummyArgs()) {
-        // FIXME: not all args are pass by ref
         // Nullptr args are alternate returns indicators
         if (arg) {
-          inputTys.emplace_back(fir::ReferenceType::get(gen(*arg)));
+          inputTys.emplace_back(genDummyArgType(*arg));
         }
       }
-      return M::FunctionType::get(inputTys, returnTy, context);
+    } else if (auto *proc = symbol->detailsIf<Se::ProcEntityDetails>()) {
+      // TODO Should probably use evaluate::Characteristics for that.
+      TODO();
+    } else {
+      assert(false && "unexpected symbol details for function");
+    }
+    return M::FunctionType::get(inputTys, returnTys, context);
+  }
+
+  /// Type consing from a symbol. A symbol's type must be created from the type
+  /// discovered by the front-end at runtime.
+  M::Type gen(Se::SymbolRef symbol) {
+    if (symbol->detailsIf<Se::SubprogramDetails>()) {
+      return genFunctionType(symbol);
     }
     M::Type returnTy{};
     if (auto *type{symbol->GetType()}) {
@@ -366,6 +393,11 @@ M::Type Br::translateSymbolToFIRType(M::MLIRContext *context,
   return TypeBuilder{context, defaults}.gen(symbol);
 }
 
+M::FunctionType Br::translateSymbolToFIRFunctionType(M::MLIRContext *context,
+    Co::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol) {
+  return TypeBuilder{context, defaults}.genFunctionType(symbol);
+}
+
 M::Type Br::convertReal(M::MLIRContext *context, int kind) {
   return genFIRType<RealCat>(context, kind);
 }
diff --git a/lib/burnside/convert-type.h b/lib/burnside/convert-type.h
index 658340396c82..a842f0862782 100644
--- a/lib/burnside/convert-type.h
+++ b/lib/burnside/convert-type.h
@@ -98,6 +98,9 @@ mlir::Type translateSomeExprToFIRType(mlir::MLIRContext *ctxt,
 mlir::Type translateSymbolToFIRType(mlir::MLIRContext *ctxt,
     common::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol);
 
+mlir::FunctionType translateSymbolToFIRFunctionType(mlir::MLIRContext *ctxt,
+    common::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol);
+
 mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
 }  // burnside

From 16be3c1ada3b4891c541db38f4b79066409d5c0c Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Wed, 18 Dec 2019 10:23:30 -0800
Subject: [PATCH 143/345] Implement an -fdebug-dump-pre-fir option to dump FIR
 AST code.

Dump output reflects the nesting structure of the AST.  For example, an
IF statement appears at the same level as a dependent assignment statement,
with both nested under an IF construct.

Example:

    subroutine s(a, b)
      integer :: a, b
      if (a .eq. 1) then
         b = 1
      else if (a .lt. -4) then
         b = -1
      else
         b = 42
      end if
    end subroutine s

    subroutine sub(nn)
      do kk = 1, nn
        block
          do ii = 1, 3
            if (ii .eq. 3) then
              block
                integer jj
                jj = -3
                print*, jj
              endblock
            endif
            print*, kk, ii
          enddo
        endblock
      enddo
      print*, 'ok'
    end

      call s(1, 7)
      call sub(2)
    end

$ bbc -fdebug-dump-pre-fir -fno-dump-hl-fir -fno-dump-fir file.f90

    Subroutine s: subroutine s(a, b)
      <<IfConstruct>>
        IfThenStmt: if(a .eq. 1) then
        AssignmentStmt: b = 1
        ElseIfStmt: else if(a .lt. -4) then
        AssignmentStmt: b = -1
        ElseStmt: else
        AssignmentStmt: b = 42
        EndIfStmt: end if
      <<EndIfConstruct>>
    EndSubroutine s

    Subroutine sub: subroutine sub(nn)
      <<DoConstruct>>
        NonLabelDoStmt: do kk = 1, nn
        <<BlockConstruct>>
          BlockStmt: block
          <<DoConstruct>>
            NonLabelDoStmt: do ii = 1, 3
            <<IfConstruct>>
              IfThenStmt: if(ii .eq. 3) then
              <<BlockConstruct>>
                BlockStmt: block
                AssignmentStmt: jj = -3
                PrintStmt: print*, jj
                EndBlockStmt: endblock
              <<EndBlockConstruct>>
              EndIfStmt: endif
            <<EndIfConstruct>>
            PrintStmt: print*, kk, ii
            EndDoStmt: enddo
          <<EndDoConstruct>>
          EndBlockStmt: endblock
        <<EndBlockConstruct>>
        EndDoStmt: enddo
      <<EndDoConstruct>>
      PrintStmt: print*, 'ok'
    EndSubroutine sub

    Program <anonymous>
      CallStmt: call s(1, 7)
      CallStmt: call sub(2)
    EndProgram <anonymous>
---
 lib/burnside/ast-builder.cc | 182 ++++++++++++++++++++++++++++++++++++
 lib/burnside/ast-builder.h  |   3 +
 lib/burnside/bridge.cc      |   3 +
 lib/burnside/bridge.h       |   4 +
 tools/bbc/bbc.cpp           |  14 +--
 5 files changed, 200 insertions(+), 6 deletions(-)

diff --git a/lib/burnside/ast-builder.cc b/lib/burnside/ast-builder.cc
index db06e7457d32..5a4b26ceab12 100644
--- a/lib/burnside/ast-builder.cc
+++ b/lib/burnside/ast-builder.cc
@@ -602,6 +602,166 @@ inline void annotateFuncCFG(AST::FunctionLikeUnit &flu) {
   annotateEvalListCFG(flu.evals, nullptr);
 }
 
+const char *evalName(AST::Evaluation &e) {
+  return std::visit(
+      Co::visitors{
+          [](const Pa::AllocateStmt *) { return "AllocateStmt"; },
+          [](const Pa::ArithmeticIfStmt *) { return "ArithmeticIfStmt"; },
+          [](const Pa::AssignedGotoStmt *) { return "AssignedGotoStmt"; },
+          [](const Pa::AssignmentStmt *x) { return "AssignmentStmt"; },
+          [](const Pa::AssignStmt *) { return "AssignStmt"; },
+          [](const Pa::BackspaceStmt *) { return "BackspaceStmt"; },
+          [](const Pa::CallStmt *) { return "CallStmt"; },
+          [](const Pa::CloseStmt *) { return "CloseStmt"; },
+          [](const Pa::ComputedGotoStmt *) { return "ComputedGotoStmt"; },
+          [](const Pa::ContinueStmt *) { return "ContinueStmt"; },
+          [](const Pa::CycleStmt *) { return "CycleStmt"; },
+          [](const Pa::DeallocateStmt *) { return "DeallocateStmt"; },
+          [](const Pa::EndfileStmt *) { return "EndfileStmt"; },
+          [](const Pa::EventPostStmt *) { return "EventPostStmt"; },
+          [](const Pa::EventWaitStmt *) { return "EventWaitStmt"; },
+          [](const Pa::ExitStmt *) { return "ExitStmt"; },
+          [](const Pa::FailImageStmt *) { return "FailImageStmt"; },
+          [](const Pa::FlushStmt *) { return "FlushStmt"; },
+          [](const Pa::ForallStmt *) { return "ForallStmt"; },
+          [](const Pa::FormTeamStmt *) { return "FormTeamStmt"; },
+          [](const Pa::GotoStmt *) { return "GotoStmt"; },
+          [](const Pa::IfStmt *x) { return "IfStmt"; },
+          [](const Pa::InquireStmt *) { return "InquireStmt"; },
+          [](const Pa::LockStmt *) { return "LockStmt"; },
+          [](const Pa::NullifyStmt *) { return "NullifyStmt"; },
+          [](const Pa::OpenStmt *) { return "OpenStmt"; },
+          [](const Pa::PauseStmt *) { return "PauseStmt"; },
+          [](const Pa::PointerAssignmentStmt *) {
+            return "PointerAssignmentStmt";
+          },
+          [](const Pa::PrintStmt *) { return "PrintStmt"; },
+          [](const Pa::ReadStmt *) { return "ReadStmt"; },
+          [](const Pa::ReturnStmt *) { return "ReturnStmt"; },
+          [](const Pa::RewindStmt *) { return "RewindStmt"; },
+          [](const Pa::StopStmt *) { return "StopStmt"; },
+          [](const Pa::SyncAllStmt *) { return "SyncAllStmt"; },
+          [](const Pa::SyncImagesStmt *) { return "SyncImagesStmt"; },
+          [](const Pa::SyncMemoryStmt *) { return "SyncMemoryStmt"; },
+          [](const Pa::SyncTeamStmt *) { return "SyncTeamStmt"; },
+          [](const Pa::UnlockStmt *) { return "UnlockStmt"; },
+          [](const Pa::WaitStmt *) { return "WaitStmt"; },
+          [](const Pa::WhereStmt *) { return "WhereStmt"; },
+          [](const Pa::WriteStmt *) { return "WriteStmt"; },
+
+          [](const AST::CGJump) { return "CGJump"; },
+
+          [](const Pa::DataStmt *) { return "DataStmt"; },
+          [](const Pa::EntryStmt *) { return "EntryStmt"; },
+          [](const Pa::FormatStmt *) { return "FormatStmt"; },
+          [](const Pa::NamelistStmt *) { return "NamelistStmt"; },
+
+          [](const Pa::AssociateConstruct *) { return "AssociateConstruct"; },
+          [](const Pa::BlockConstruct *) { return "BlockConstruct"; },
+          [](const Pa::CaseConstruct *) { return "CaseConstruct"; },
+          [](const Pa::ChangeTeamConstruct *) { return "ChangeTeamConstruct"; },
+          [](const Pa::CompilerDirective *) { return "CompilerDirective"; },
+          [](const Pa::CriticalConstruct *) { return "CriticalConstruct"; },
+          [](const Pa::DoConstruct *) { return "DoConstruct"; },
+          [](const Pa::ForallConstruct *) { return "ForallConstruct"; },
+          [](const Pa::IfConstruct *) { return "IfConstruct"; },
+          [](const Pa::OmpEndLoopDirective *) { return "OmpEndLoopDirective"; },
+          [](const Pa::OpenMPConstruct *) { return "OpenMPConstruct"; },
+          [](const Pa::SelectRankConstruct *) { return "SelectRankConstruct"; },
+          [](const Pa::SelectTypeConstruct *) { return "SelectTypeConstruct"; },
+          [](const Pa::WhereConstruct *) { return "WhereConstruct"; },
+
+          [](const Pa::AssociateStmt *) { return "AssociateStmt"; },
+          [](const Pa::BlockStmt *) { return "BlockStmt"; },
+          [](const Pa::CaseStmt *) { return "CaseStmt"; },
+          [](const Pa::ChangeTeamStmt *) { return "ChangeTeamStmt"; },
+          [](const Pa::CriticalStmt *) { return "CriticalStmt"; },
+          [](const Pa::ElseIfStmt *x) { return "ElseIfStmt"; },
+          [](const Pa::ElseStmt *) { return "ElseStmt"; },
+          [](const Pa::ElsewhereStmt *) { return "ElsewhereStmt"; },
+          [](const Pa::EndAssociateStmt *) { return "EndAssociateStmt"; },
+          [](const Pa::EndBlockStmt *) { return "EndBlockStmt"; },
+          [](const Pa::EndChangeTeamStmt *) { return "EndChangeTeamStmt"; },
+          [](const Pa::EndCriticalStmt *) { return "EndCriticalStmt"; },
+          [](const Pa::EndDoStmt *) { return "EndDoStmt"; },
+          [](const Pa::EndForallStmt *) { return "EndForallStmt"; },
+          [](const Pa::EndIfStmt *) { return "EndIfStmt"; },
+          [](const Pa::EndSelectStmt *) { return "EndSelectStmt"; },
+          [](const Pa::EndWhereStmt *) { return "EndWhereStmt"; },
+          [](const Pa::ForallConstructStmt *) { return "ForallConstructStmt"; },
+          [](const Pa::IfThenStmt *x) { return "IfThenStmt"; },
+          [](const Pa::MaskedElsewhereStmt *) { return "MaskedElsewhereStmt"; },
+          [](const Pa::NonLabelDoStmt *) { return "NonLabelDoStmt"; },
+          [](const Pa::SelectCaseStmt *) { return "SelectCaseStmt"; },
+          [](const Pa::SelectRankCaseStmt *) { return "SelectRankCaseStmt"; },
+          [](const Pa::SelectRankStmt *) { return "SelectRankStmt"; },
+          [](const Pa::SelectTypeStmt *) { return "SelectTypeStmt"; },
+          [](const Pa::TypeGuardStmt *) { return "TypeGuardStmt"; },
+          [](const Pa::WhereConstructStmt *) { return "WhereConstructStmt"; },
+      },
+      e.u);
+}
+
+void dumpEvalList(
+    llvm::raw_ostream &o, std::list<AST::Evaluation> &evals, int indent = 1) {
+  static const std::string white{"                                      ++"};
+  std::string indentString{white.substr(0, indent * 2)};
+  for (AST::Evaluation &e : evals) {
+    const char *name{evalName(e)};
+    if (e.isConstruct()) {
+      o << indentString << "<<" << name << ">>\n";
+      dumpEvalList(o, *e.getConstructEvals(), indent + 1);
+      o << indentString << "<<End" << name << ">>\n";
+    } else {
+      o << indentString << name << ": " << e.pos.ToString() << '\n';
+    }
+  }
+}
+
+void dumpFunctionLikeUnit(llvm::raw_ostream &o, AST::FunctionLikeUnit &flu) {
+  const char *unitKind{};
+  std::string name{};
+  std::string header{};
+  std::visit(Co::visitors{
+                 [&](const Pa::Statement<Pa::ProgramStmt> *s) {
+                   unitKind = "Program";
+                   name = s->statement.v.ToString();
+                 },
+                 [&](const Pa::Statement<Pa::FunctionStmt> *s) {
+                   unitKind = "Function";
+                   name = std::get<Pa::Name>(s->statement.t).ToString();
+                   header = s->source.ToString();
+                 },
+                 [&](const Pa::Statement<Pa::SubroutineStmt> *s) {
+                   unitKind = "Subroutine";
+                   name = std::get<Pa::Name>(s->statement.t).ToString();
+                   header = s->source.ToString();
+                 },
+                 [&](const Pa::Statement<Pa::MpSubprogramStmt> *s) {
+                   unitKind = "MpSubprogram";
+                   name = s->statement.v.ToString();
+                   header = s->source.ToString();
+                 },
+                 [&](auto *) {
+                   if (std::get_if<const Pa::Statement<Pa::EndProgramStmt> *>(
+                           &flu.funStmts.back())) {
+                     unitKind = "Program";
+                     name = "<anonymous>";
+                   } else {
+                     unitKind = ">>>>> Error - no program unit <<<<<";
+                   }
+                 },
+             },
+      flu.funStmts.front());
+  o << unitKind << ' ' << name;
+  if (header.size()) {
+    o << ": " << header;
+  }
+  o << '\n';
+  dumpEvalList(o, flu.evals);
+  o << "End" << unitKind << ' ' << name << "\n\n";
+}
+
 }  // namespace
 
 Br::AST::FunctionLikeUnit::FunctionLikeUnit(
@@ -679,3 +839,25 @@ void Br::annotateControl(AST::Program &ast) {
         unit);
   }
 }
+
+/// Dump an AST.
+void Br::dumpAST(llvm::raw_ostream &o, AST::Program &ast) {
+  for (auto &unit : ast.getUnits()) {
+    std::visit(
+        Co::visitors{
+            [&](AST::BlockDataUnit &) { o << "BlockData\nEndBlockData\n\n"; },
+            [&](AST::FunctionLikeUnit &f) {
+              dumpFunctionLikeUnit(o, f);
+              for (auto &f : f.funcs) {
+                dumpFunctionLikeUnit(o, f);
+              }
+            },
+            [&](AST::ModuleLikeUnit &u) {
+              for (auto &f : u.funcs) {
+                dumpFunctionLikeUnit(o, f);
+              }
+            },
+        },
+        unit);
+  }
+}
diff --git a/lib/burnside/ast-builder.h b/lib/burnside/ast-builder.h
index c639d6044cd1..a29afe61122d 100644
--- a/lib/burnside/ast-builder.h
+++ b/lib/burnside/ast-builder.h
@@ -17,6 +17,7 @@
 
 #include "../parser/parse-tree.h"
 #include "../semantics/scope.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::burnside {
 namespace AST {
@@ -324,6 +325,8 @@ AST::Program *createAST(const parser::Program &root);
 /// use in generating a CFG-like structure.
 void annotateControl(AST::Program &ast);
 
+void dumpAST(llvm::raw_ostream &o, AST::Program &ast);
+
 }  // namespace burnside
 
 #endif  // FORTRAN_BURNSIDE_AST_BUILDER_H_
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 24fa8975492f..93341c54b6a3 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -1129,6 +1129,9 @@ void Br::BurnsideBridge::lower(
     const Pa::Program &prg, fir::NameUniquer &uniquer) {
   AST::Program *ast{Br::createAST(prg)};
   Br::annotateControl(*ast);
+  if (getDumpPreFIR()) {
+    Br::dumpAST(llvm::errs(), *ast);
+  }
   FirConverter converter{*this, uniquer};
   converter.run(*ast);
   delete ast;
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index 16763f262525..a354409f52af 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -136,6 +136,9 @@ class BurnsideBridge {
   /// Cross the bridge from the Fortran parse-tree, etc. to FIR+OpenMP+MLIR
   void lower(const parser::Program &program, fir::NameUniquer &uniquer);
 
+  void dumpPreFIR(bool flag = true) { dumpPreFIR_ = flag; }
+  bool getDumpPreFIR() { return dumpPreFIR_; }
+
 private:
   explicit BurnsideBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
       const parser::CookedSource *cooked);
@@ -146,6 +149,7 @@ class BurnsideBridge {
   const parser::CookedSource *cooked;
   std::unique_ptr<mlir::MLIRContext> context;
   std::unique_ptr<mlir::ModuleOp> module;
+  bool dumpPreFIR_{false};
 };
 
 }  // Fortran::burnside
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 372ad88370de..c60d310b4741 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -115,11 +115,11 @@ struct DriverOptions {
   bool dumpUnparseWithSymbols{false};
   bool dumpParseTree{false};
   bool dumpSymbols{false};
-  bool debugLinearFIR{false};
   bool debugResolveNames{false};
   bool debugSemantics{false};
   bool measureTree{false};
   bool runBackend{true};
+  bool dumpPreFIR{false};
   bool dumpHLFIR{true};
   bool dumpFIR{true};
   bool lowerToStd{true};
@@ -244,8 +244,7 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   }
   // TODO: Change this predicate to just "if (!driver.debugNoSemantics)"
   if (driver.debugSemantics || driver.debugResolveNames || driver.dumpSymbols ||
-      driver.dumpUnparseWithSymbols || driver.debugLinearFIR ||
-      driver.runBackend) {
+      driver.dumpUnparseWithSymbols || driver.runBackend) {
     Fortran::semantics::Semantics semantics{
         semanticsContext, parseTree, parsing.cooked()};
     semantics.Perform();
@@ -272,6 +271,9 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   fir::NameUniquer nameUniquer;
   auto burnside = Br::BurnsideBridge::create(
       semanticsContext.defaultKinds(), &parsing.cooked());
+  if (driver.dumpPreFIR) {
+    burnside.dumpPreFIR();
+  }
   burnside.lower(parseTree, nameUniquer);
   mlir::ModuleOp mlirModule{burnside.getModule()};
   mlir::PassManager pm{mlirModule.getContext()};
@@ -444,8 +446,8 @@ int main(int argc, char *const argv[]) {
       driver.dumpUnparse = true;
     } else if (arg == "-funparse-with-symbols") {
       driver.dumpUnparseWithSymbols = true;
-    } else if (arg == "-fdebug-dump-linear-ir") {
-      driver.debugLinearFIR = true;
+    } else if (arg == "-fdebug-dump-pre-fir") {
+      driver.dumpPreFIR = true;
     } else if (arg == "-fno-dump-hl-fir") {
       driver.dumpHLFIR = false;
     } else if (arg == "-fno-dump-fir") {
@@ -512,8 +514,8 @@ int main(int argc, char *const argv[]) {
           << "  -fdebug-resolve-names\n"
           << "  -fdebug-instrumented-parse\n"
           << "  -fdebug-semantics    perform semantic checks\n"
+          << "  -fdebug-dump-pre-fir dump the IR tree prior to FIR\n"
           << "  -fdotty              print FIR as a dotty graph\n"
-          << "  -fdebug-dump-linear-ir dump the flat linear FIR for debug\n"
           << "  -v -c -o -I -D -U    have their usual meanings\n"
           << "  -help                print this again\n"
           << "Other options are passed through to the compiler.\n";

From 7636f81eb691bf9628e829835284afd6ed88b731 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 17 Dec 2019 16:03:47 -0800
Subject: [PATCH 144/345] initial work on lowering select_type

---
 include/fir/FIROps.td       |   8 ++
 include/fir/FIROpsSupport.h |   7 ++
 lib/fir/FIROps.cpp          |  12 +++
 lib/fir/StdConverter.cpp    | 191 ++++++++++++++++++++----------------
 tools/bbc/CMakeLists.txt    |   1 +
 tools/bbc/bbc.cpp           |   7 +-
 6 files changed, 136 insertions(+), 90 deletions(-)

diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
index f127d78cd632..322082ee2aba 100644
--- a/include/fir/FIROps.td
+++ b/include/fir/FIROps.td
@@ -1900,6 +1900,14 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
     return M::success();
   }];
 
+  let builders = [OpBuilder<
+    "Builder *, OperationState &result, mlir::TypeAttr res",
+    [{
+      result.addAttribute("in_type", res);
+      result.addTypes(res.getValue());
+    }]
+  >];
+
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
     p << " : " << getType();
diff --git a/include/fir/FIROpsSupport.h b/include/fir/FIROpsSupport.h
index a0f48de4c69e..34c1c1db4fdc 100644
--- a/include/fir/FIROpsSupport.h
+++ b/include/fir/FIROpsSupport.h
@@ -61,6 +61,13 @@ inline bool pureCall(mlir::Operation *op) {
   return false;
 }
 
+/// Get or create a FuncOp in a module.
+///
+/// If `module` already contains FuncOp `name`, it is returned. Otherwise, a new
+/// FuncOp is created, and that new FuncOp is returned.
+mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
+                          llvm::StringRef name, mlir::FunctionType type);
+
 } // namespace fir
 
 #endif // FIR_FIROPS_SUPPORT_H
diff --git a/lib/fir/FIROps.cpp b/lib/fir/FIROps.cpp
index b3653c777c98..aafd99354c8a 100644
--- a/lib/fir/FIROps.cpp
+++ b/lib/fir/FIROps.cpp
@@ -14,9 +14,12 @@
 
 #include "fir/FIROps.h"
 #include "fir/Attribute.h"
+#include "fir/FIROpsSupport.h"
 #include "fir/FIRType.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/Function.h"
+#include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -587,6 +590,15 @@ bool isReferenceLike(M::Type type) {
          type.isa<fir::PointerType>();
 }
 
+M::FuncOp createFuncOp(M::Location loc, M::ModuleOp module, StringRef name,
+                       M::FunctionType type) {
+  if (auto f = module.lookupSymbol<M::FuncOp>(name))
+    return f;
+  auto f = M::FuncOp::create(loc, name, type);
+  module.push_back(f);
+  return f;
+}
+
 // Tablegen operators
 
 #define GET_OP_CLASSES
diff --git a/lib/fir/StdConverter.cpp b/lib/fir/StdConverter.cpp
index e25fbda94baa..c98fabdf8870 100644
--- a/lib/fir/StdConverter.cpp
+++ b/lib/fir/StdConverter.cpp
@@ -13,25 +13,16 @@
 // limitations under the License.
 
 #include "fir/Transforms/StdConverter.h"
+#include "fir/Attribute.h"
 #include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
+#include "fir/FIROpsSupport.h"
 #include "fir/FIRType.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
-#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
-#include "mlir/Dialect/AffineOps/AffineOps.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Target/LLVMIR.h"
+#include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/Config/abi-breaking.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/Module.h"
-#include "llvm/IR/Type.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/raw_ostream.h"
 
 // This module performs the conversion of FIR operations to MLIR standard and/or
 // LLVM-IR dialects.
@@ -59,6 +50,7 @@ class FIRToStdTypeConverter : public M::TypeConverter {
   using TypeConverter::TypeConverter;
 
   // convert a front-end kind value to either a std dialect type
+  // FIXME: use KindMapping
   static M::Type kindToRealType(M::MLIRContext *ctx, KindTy kind) {
     switch (kind) {
     case 2:
@@ -75,109 +67,136 @@ class FIRToStdTypeConverter : public M::TypeConverter {
 
   /// Convert FIR types to MLIR standard dialect types
   M::Type convertType(M::Type t) override {
-    if (auto cplx = t.dyn_cast<CplxType>()) {
+    if (auto cplx = t.dyn_cast<CplxType>())
       return M::ComplexType::get(
           kindToRealType(cplx.getContext(), cplx.getFKind()));
-    }
-    if (auto integer = t.dyn_cast<IntType>()) {
+    if (auto integer = t.dyn_cast<IntType>())
       return M::IntegerType::get(integer.getFKind() * 8, integer.getContext());
-    }
-    if (auto real = t.dyn_cast<RealType>()) {
+    if (auto real = t.dyn_cast<RealType>())
       return kindToRealType(real.getContext(), real.getFKind());
-    }
     return t;
   }
 };
 
-// Lower a SELECT operation into a cascade of conditional branches. The last
-// case must be the `true` condition.
-inline void rewriteSelectConstruct(M::Operation *op, OperandTy operands,
-                                   L::ArrayRef<M::Block *> dests,
-                                   L::ArrayRef<OperandTy> destOperands,
-                                   M::OpBuilder &rewriter) {
-  L::SmallVector<M::Value *, 1> noargs;
-  L::SmallVector<M::Block *, 8> blocks;
-  auto loc{op->getLoc()};
-  blocks.push_back(rewriter.getInsertionBlock());
-  for (std::size_t i = 1; i < dests.size(); ++i)
-    blocks.push_back(rewriter.createBlock(dests[0]));
-  rewriter.setInsertionPointToEnd(blocks[0]);
-  if (dests.size() == 1) {
-    rewriter.create<M::BranchOp>(loc, dests[0], destOperands[0]);
-    return;
-  }
-  rewriter.create<M::CondBranchOp>(loc, operands[1], dests[0], destOperands[0],
-                                   blocks[1], noargs);
-  for (std::size_t i = 1; i < dests.size() - 1; ++i) {
-    rewriter.setInsertionPointToEnd(blocks[i]);
-    rewriter.create<M::CondBranchOp>(loc, operands[i + 1], dests[i],
-                                     destOperands[i], blocks[i + 1], noargs);
-  }
-  std::size_t last{dests.size() - 1};
-  rewriter.setInsertionPointToEnd(blocks[last]);
-  rewriter.create<M::BranchOp>(loc, dests[last], destOperands[last]);
-}
+/// FIR conversion pattern template
+template <typename FromOp>
+class FIROpConversion : public M::ConversionPattern {
+public:
+  explicit FIROpConversion(M::MLIRContext *ctx, FIRToStdTypeConverter &lowering)
+      : ConversionPattern(FromOp::getOperationName(), 1, ctx),
+        lowering(lowering) {}
+
+protected:
+  M::Type convertType(M::Type ty) const { return lowering.convertType(ty); }
+
+  FIRToStdTypeConverter &lowering;
+};
 
-/// Convert FIR dialect to standard dialect
-class FIRToStdLoweringPass : public M::ModulePass<FIRToStdLoweringPass> {
-  M::OpBuilder *builder;
-
-  void lowerSelect(M::Operation *op) {
-    if (M::dyn_cast<SelectCaseOp>(op) || M::dyn_cast<SelectRankOp>(op) ||
-        M::dyn_cast<SelectTypeOp>(op)) {
-      // build the lists of operands and successors
-      L::SmallVector<M::Value *, 4> operands{op->operand_begin(),
-                                             op->operand_end()};
-      L::SmallVector<M::Block *, 2> destinations;
-      destinations.reserve(op->getNumSuccessors());
-      L::SmallVector<OperandTy, 2> destOperands;
-      unsigned firstSuccOpd = op->getSuccessorOperandIndex(0);
-      for (unsigned i = 0, seen = 0, e = op->getNumSuccessors(); i < e; ++i) {
-        destinations.push_back(op->getSuccessor(i));
-        unsigned n = op->getNumSuccessorOperands(i);
-        destOperands.push_back(
-            L::makeArrayRef(operands.data() + firstSuccOpd + seen, n));
-        seen += n;
+/// SelectTypeOp converted to an if-then-else chain
+///
+/// This lowers the test conditions to calls into the runtime
+struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
+  using FIROpConversion::FIROpConversion;
+
+  M::PatternMatchResult
+  matchAndRewrite(M::Operation *op, OperandTy operands,
+                  L::ArrayRef<M::Block *> destinations,
+                  L::ArrayRef<OperandTy> destOperands,
+                  M::ConversionPatternRewriter &rewriter) const override {
+    auto selecttype = M::cast<SelectTypeOp>(op);
+    auto conds = selecttype.getNumConditions();
+    auto attrName = SelectTypeOp::AttrName;
+    auto caseAttr = selecttype.getAttrOfType<M::ArrayAttr>(attrName);
+    auto cases = caseAttr.getValue();
+    // Selector must be of type !fir.box<T>
+    auto &selector = operands[0];
+    auto loc = selecttype.getLoc();
+    auto mod = op->getParentOfType<M::ModuleOp>();
+    for (unsigned t = 0; t != conds; ++t) {
+      auto &attr = cases[t];
+      if (auto a = attr.dyn_cast_or_null<fir::ExactTypeAttr>()) {
+        genTypeLadderStep(loc, true, selector, a.getType(), destinations[t],
+                          destOperands[t], mod, rewriter);
+        continue;
       }
-      // do the rewrite
-      rewriteSelectConstruct(
-          op, L::makeArrayRef(operands.data(), operands.data() + firstSuccOpd),
-          destinations, destOperands, *builder);
+      if (auto a = attr.dyn_cast_or_null<fir::SubclassAttr>()) {
+        genTypeLadderStep(loc, false, selector, a.getType(), destinations[t],
+                          destOperands[t], mod, rewriter);
+        continue;
+      }
+      assert(attr.dyn_cast_or_null<M::UnitAttr>());
+      assert((t + 1 == conds) && "unit must be last");
+      rewriter.replaceOpWithNewOp<M::BranchOp>(selecttype, destinations[t],
+                                               M::ValueRange{destOperands[t]});
     }
+    return matchSuccess();
+  }
+
+  static void lookupFunction(L::StringRef name, M::FunctionType type,
+                             M::ModuleOp module,
+                             M::ConversionPatternRewriter &rewriter) {
+    fir::createFuncOp(rewriter.getUnknownLoc(), module, name, type);
+  }
+
+  static void genTypeLadderStep(M::Location loc, bool exactTest,
+                                M::Value *selector, M::Type ty, M::Block *dest,
+                                OperandTy destOps, M::ModuleOp module,
+                                M::ConversionPatternRewriter &rewriter) {
+    M::Type tydesc = fir::TypeDescType::get(ty);
+    M::Value *t = rewriter.create<GenTypeDescOp>(loc, M::TypeAttr::get(tydesc));
+    std::vector<M::Value *> actuals = {selector, t};
+    auto fty = rewriter.getI1Type();
+    std::vector<M::Type> argTy = {fir::BoxType::get(rewriter.getNoneType()),
+                                  tydesc};
+    L::StringRef funName =
+        exactTest ? "FIXME_exact_type_match" : "FIXME_isa_type_test";
+    lookupFunction(funName, rewriter.getFunctionType(argTy, fty), module,
+                   rewriter);
+    // FIXME: need to call actual runtime routines for (1) testing if the
+    // runtime type of the selector is an exact match to a derived type or (2)
+    // testing if the runtime type of the selector is a derived type or one of
+    // that derived type's subtypes.
+    auto cmp = rewriter.create<M::CallOp>(
+        loc, fty, rewriter.getSymbolRefAttr(funName), actuals);
+    auto *thisBlock = rewriter.getInsertionBlock();
+    auto *newBlock = rewriter.createBlock(dest);
+    rewriter.setInsertionPointToEnd(thisBlock);
+    rewriter.create<M::CondBranchOp>(loc, cmp.getResult(0), dest, destOps,
+                                     newBlock, OperandTy{});
+    rewriter.setInsertionPointToEnd(newBlock);
   }
+};
 
+/// Convert affine dialect, fir.select_type to standard dialect
+class FIRToStdLoweringPass : public M::FunctionPass<FIRToStdLoweringPass> {
 public:
-  void runOnModule() override {
+  void runOnFunction() override {
     if (ClDisableFirToStd)
       return;
 
-    return; // FIXME
-
-    for (auto fn : getModule().getOps<M::FuncOp>()) {
-      M::OpBuilder rewriter{&fn.getBody()};
-      builder = &rewriter;
-      fn.walk([&](M::Operation *op) { lowerSelect(op); });
-    }
-    auto &context{getContext()};
+    auto *context{&getContext()};
     FIRToStdTypeConverter typeConverter;
     M::OwningRewritePatternList patterns;
-    // patterns.insert<>(&context, typeConverter);
-    M::populateAffineToStdConversionPatterns(patterns, &context);
-    M::populateFuncOpTypeConversionPattern(patterns, &context, typeConverter);
-    M::ConversionTarget target{context};
+    patterns.insert<SelectTypeOpConversion>(context, typeConverter);
+    M::populateAffineToStdConversionPatterns(patterns, context);
+    M::populateFuncOpTypeConversionPattern(patterns, context, typeConverter);
+    M::ConversionTarget target{*context};
     target.addLegalDialect<M::StandardOpsDialect, fir::FIROpsDialect>();
     target.addDynamicallyLegalOp<M::FuncOp>([&](M::FuncOp op) {
       return typeConverter.isSignatureLegal(op.getType());
     });
-    target.addDynamicallyLegalOp<M::ModuleOp>(
-        [&](M::ModuleOp op) { return true; });
+    target.addIllegalOp<SelectTypeOp>();
     if (M::failed(M::applyPartialConversion(
             getModule(), target, std::move(patterns), &typeConverter))) {
-      M::emitError(M::UnknownLoc::get(&context),
+      M::emitError(M::UnknownLoc::get(context),
                    "error in converting to standard dialect\n");
       signalPassFailure();
     }
   }
+
+  M::ModuleOp getModule() {
+    return getFunction().getParentOfType<M::ModuleOp>();
+  }
 };
 
 } // namespace
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index 36f351529fd1..f0917485a173 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -27,6 +27,7 @@ target_link_libraries(FirBbcLib ${LIBS} FIRTransforms)
 set(EXE_LIBS
   ${LIBS}
   FIRTransforms
+  MLIRAffineToStandard
   FortranCommon
   FortranParser
   FortranEvaluate
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index c60d310b4741..78402849a5aa 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -284,12 +284,11 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   // Run FIR mem2reg and CSE as a pair
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
-  if (driver.lowerToStd) {
-    pm.addPass(fir::createFIRToStdPass());
-  }
   if (driver.lowerToLLVM) {
     pm.addPass(fir::createLowerToLoopPass());
-    pm.addPass(fir::createFIRToStdPass());
+    if (driver.lowerToStd) {
+      pm.addPass(fir::createFIRToStdPass());
+    }
     pm.addPass(mlir::createLowerToCFGPass());
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
   }

From c19f418801477a65b1d51aa7ab14319bcb3e3f21 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 18 Dec 2019 13:25:33 -0800
Subject: [PATCH 145/345] Split assignment lowering into different cases

---
 lib/burnside/bridge.cc | 51 ++++++++++++++++++++++++++++++++++++++----
 1 file changed, 47 insertions(+), 4 deletions(-)

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 93341c54b6a3..ad8cafb567b1 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -676,10 +676,53 @@ class FirConverter : public AbstractConverter {
 
   void genFIR(const Pa::AllocateStmt &) { TODO(); }
   void genFIR(const Pa::AssignmentStmt &stmt) {
-    auto *rhs{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
-    auto *lhs{Se::GetExpr(std::get<Pa::Variable>(stmt.t))};
-    builder->create<fir::StoreOp>(
-        toLocation(), genExprValue(*rhs), genExprAddr(*lhs));
+    assert(stmt.typedAssignment && "assignment analysis failed");
+    // Warning: v->u must become v.u after next f18 rebase
+    if (auto *assignment{std::get_if<Ev::Assignment::IntrinsicAssignment>(
+            &stmt.typedAssignment->v->u)}) {
+      const Se::Symbol *sym{Ev::UnwrapWholeSymbolDataRef(assignment->lhs)};
+      if (sym && Se::IsAllocatable(*sym)) {
+        // Assignment of allocatable are more complex, the lhs
+        // may need to be deallocated/reallocated.
+        // See Fortran 2018 10.2.1.3 p3
+        TODO();
+      } else if (sym && Se::IsPointer(*sym)) {
+        // Target of the pointer must be assigned.
+        // See Fortran 2018 10.2.1.3 p2
+        TODO();
+      } else if (assignment->lhs.Rank() > 0) {
+        // Array assignment
+        // See Fortran 2018 10.2.1.3 p5, p6, and p7
+        TODO();
+      } else {
+        // Scalar assignments
+        std::optional<Ev::DynamicType> lhsType{assignment->lhs.GetType()};
+        assert(lhsType && "lhs cannot be typeless");
+        switch (lhsType->category()) {
+        case IntegerCat:
+        case RealCat:
+        case ComplexCat:
+        case LogicalCat:
+          // Fortran 2018 10.2.1.3 p8 and p9
+          // Conversions are already inserted by semantic
+          // analysis.
+          builder->create<fir::StoreOp>(toLocation(),
+              genExprValue(assignment->rhs), genExprAddr(assignment->lhs));
+          break;
+        case CharacterCat:
+          // Fortran 2018 10.2.1.3 p10 and p11
+          TODO();
+          break;
+        case DerivedCat:
+          // Fortran 2018 10.2.1.3 p12 and p13
+          TODO();
+          break;
+        }
+      }
+    } else {
+      // Defined assignment: call ProcRef
+      TODO();
+    }
   }
 
   void genFIR(const Pa::ContinueStmt &) {}  // do nothing

From a936f299e03160597bb9258670df70c6f747a66a Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 18 Dec 2019 14:57:59 -0800
Subject: [PATCH 146/345] tweaks to FuncOp getter

thread KindMapping through the eyes of the needles

correct the plumbing of unboxchar and unboxproc

work on unbox

add notes on kind mapping
---
 include/fir/FIROpsSupport.h           |  4 ++
 include/fir/KindMapping.h             | 23 +++++++++
 include/fir/Transforms/StdConverter.h |  4 +-
 lib/burnside/builder.cc               | 12 ++---
 lib/fir/StdConverter.cpp              | 57 ++++++++++++---------
 lib/fir/Tilikum.cpp                   | 73 +++++++++++++++++++++++----
 test/fir/select-type.fir              | 14 +++++
 tools/bbc/bbc.cpp                     |  4 +-
 tools/tco/tco.cpp                     |  4 +-
 9 files changed, 151 insertions(+), 44 deletions(-)
 create mode 100644 test/fir/select-type.fir

diff --git a/include/fir/FIROpsSupport.h b/include/fir/FIROpsSupport.h
index 34c1c1db4fdc..6a133045975d 100644
--- a/include/fir/FIROpsSupport.h
+++ b/include/fir/FIROpsSupport.h
@@ -68,6 +68,10 @@ inline bool pureCall(mlir::Operation *op) {
 mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                           llvm::StringRef name, mlir::FunctionType type);
 
+/// Get or create a GlobalOp in a module.
+fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
+                             llvm::StringRef name, mlir::Type type);
+
 } // namespace fir
 
 #endif // FIR_FIROPS_SUPPORT_H
diff --git a/include/fir/KindMapping.h b/include/fir/KindMapping.h
index f5e3ca7cc504..e747c484a8b9 100644
--- a/include/fir/KindMapping.h
+++ b/include/fir/KindMapping.h
@@ -29,6 +29,27 @@ class MLIRContext;
 
 namespace fir {
 
+/// The kind mapping is an encoded string that informs FIR how the Fortran KIND
+/// values from the front-end should be converted to LLVM IR types.  This
+/// encoding allows the mapping from front-end KIND values to backend LLVM IR
+/// types to be customized by the front-end.
+///
+/// The provided string uses the following syntax.
+///
+///   intrinsic-key `:` kind-value (`,` intrinsic-key `:` kind-value)*
+///
+/// intrinsic-key is a single character for the intrinsic type.
+///   'i' : INTEGER   (size in bits)
+///   'l' : LOGICAL   (size in bits)
+///   'a' : CHARACTER (size in bits)
+///   'r' : REAL    (encoding value)
+///   'c' : COMPLEX (encoding value)
+///
+/// kind-value is either an unsigned integer (for 'i', 'l', and 'a') or one of
+/// 'Half', 'Float', 'Double', 'X86_FP80', or 'FP128' (for 'r' and 'c').
+///
+/// If LLVM adds support for new floating-point types, the final list should be
+/// extended.
 class KindMapping {
 public:
   using KindTy = unsigned;
@@ -54,6 +75,8 @@ class KindMapping {
   /// Get the LLVM Type::TypeID of !fir.complex<kind>
   LLVMTypeID getComplexTypeID(KindTy kind);
 
+  mlir::MLIRContext *getContext() const { return context; }
+
 private:
   MatchResult badMapString(llvm::Twine const &ptr);
   MatchResult parse(llvm::StringRef kindMap);
diff --git a/include/fir/Transforms/StdConverter.h b/include/fir/Transforms/StdConverter.h
index 80ef0aca2615..b0ac1fa7aa80 100644
--- a/include/fir/Transforms/StdConverter.h
+++ b/include/fir/Transforms/StdConverter.h
@@ -23,8 +23,10 @@ class Pass;
 
 namespace fir {
 
+class KindMapping;
+
 /// Convert FIR to the standard dialect
-std::unique_ptr<mlir::Pass> createFIRToStdPass();
+std::unique_ptr<mlir::Pass> createFIRToStdPass(KindMapping &);
 
 } // namespace fir
 
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index 9f2b834b95f7..b523ffaf097b 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -15,6 +15,7 @@
 #include "builder.h"
 #include "bridge.h"
 #include "convert-type.h"
+#include "fir/FIROpsSupport.h"
 #include "llvm/ADT/StringRef.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Value.h"
@@ -29,17 +30,14 @@ using namespace Fortran::burnside;
 
 M::FuncOp B::createFunction(B::AbstractConverter &converter,
     llvm::StringRef name, M::FunctionType funcTy) {
-  auto func{M::FuncOp::create(converter.getCurrentLocation(), name, funcTy)};
-  converter.getModuleOp().push_back(func);
-  return func;
+  return fir::createFuncOp(
+      converter.getCurrentLocation(), converter.getModuleOp(), name, funcTy);
 }
 
 M::FuncOp B::createFunction(
     M::ModuleOp module, llvm::StringRef name, M::FunctionType funcTy) {
-  auto loc{M::UnknownLoc::get(module.getContext())};
-  auto func{M::FuncOp::create(loc, name, funcTy)};
-  module.push_back(func);
-  return func;
+  return fir::createFuncOp(
+      M::UnknownLoc::get(module.getContext()), module, name, funcTy);
 }
 
 M::FuncOp B::getNamedFunction(M::ModuleOp module, llvm::StringRef name) {
diff --git a/lib/fir/StdConverter.cpp b/lib/fir/StdConverter.cpp
index c98fabdf8870..a0684a131c82 100644
--- a/lib/fir/StdConverter.cpp
+++ b/lib/fir/StdConverter.cpp
@@ -17,6 +17,7 @@
 #include "fir/FIRDialect.h"
 #include "fir/FIROpsSupport.h"
 #include "fir/FIRType.h"
+#include "fir/KindMapping.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/StandardTypes.h"
@@ -49,33 +50,42 @@ class FIRToStdTypeConverter : public M::TypeConverter {
 public:
   using TypeConverter::TypeConverter;
 
-  // convert a front-end kind value to either a std dialect type
-  // FIXME: use KindMapping
-  static M::Type kindToRealType(M::MLIRContext *ctx, KindTy kind) {
-    switch (kind) {
-    case 2:
+  explicit FIRToStdTypeConverter(KindMapping &kindMap) : kindMap{kindMap} {}
+
+  // convert front-end REAL kind value to a std dialect type, if possible
+  static M::Type kindToRealType(KindMapping &kindMap, KindTy kind) {
+    auto *ctx = kindMap.getContext();
+    switch (kindMap.getRealTypeID(kind)) {
+    case L::Type::TypeID::HalfTyID:
       return M::FloatType::getF16(ctx);
-    case 3:
+#if 0
+    case L::Type::TypeID:: FIXME TyID:
       return M::FloatType::getBF16(ctx);
-    case 4:
+#endif
+    case L::Type::TypeID::FloatTyID:
       return M::FloatType::getF32(ctx);
-    case 8:
+    case L::Type::TypeID::DoubleTyID:
       return M::FloatType::getF64(ctx);
+    case L::Type::TypeID::X86_FP80TyID: // MLIR does not support yet
+    case L::Type::TypeID::FP128TyID:    // MLIR does not support yet
+    default:
+      return fir::RealType::get(ctx, kind);
     }
-    return fir::RealType::get(ctx, kind);
   }
 
-  /// Convert FIR types to MLIR standard dialect types
+  /// Convert some FIR types to MLIR standard dialect types
   M::Type convertType(M::Type t) override {
     if (auto cplx = t.dyn_cast<CplxType>())
-      return M::ComplexType::get(
-          kindToRealType(cplx.getContext(), cplx.getFKind()));
+      return M::ComplexType::get(kindToRealType(kindMap, cplx.getFKind()));
     if (auto integer = t.dyn_cast<IntType>())
       return M::IntegerType::get(integer.getFKind() * 8, integer.getContext());
     if (auto real = t.dyn_cast<RealType>())
-      return kindToRealType(real.getContext(), real.getFKind());
+      return kindToRealType(kindMap, real.getFKind());
     return t;
   }
+
+private:
+  KindMapping &kindMap;
 };
 
 /// FIR conversion pattern template
@@ -132,12 +142,6 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
     return matchSuccess();
   }
 
-  static void lookupFunction(L::StringRef name, M::FunctionType type,
-                             M::ModuleOp module,
-                             M::ConversionPatternRewriter &rewriter) {
-    fir::createFuncOp(rewriter.getUnknownLoc(), module, name, type);
-  }
-
   static void genTypeLadderStep(M::Location loc, bool exactTest,
                                 M::Value *selector, M::Type ty, M::Block *dest,
                                 OperandTy destOps, M::ModuleOp module,
@@ -150,8 +154,8 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
                                   tydesc};
     L::StringRef funName =
         exactTest ? "FIXME_exact_type_match" : "FIXME_isa_type_test";
-    lookupFunction(funName, rewriter.getFunctionType(argTy, fty), module,
-                   rewriter);
+    createFuncOp(rewriter.getUnknownLoc(), module, funName,
+                 rewriter.getFunctionType(argTy, fty));
     // FIXME: need to call actual runtime routines for (1) testing if the
     // runtime type of the selector is an exact match to a derived type or (2)
     // testing if the runtime type of the selector is a derived type or one of
@@ -170,12 +174,14 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
 /// Convert affine dialect, fir.select_type to standard dialect
 class FIRToStdLoweringPass : public M::FunctionPass<FIRToStdLoweringPass> {
 public:
+  explicit FIRToStdLoweringPass(KindMapping &kindMap) : kindMap{kindMap} {}
+
   void runOnFunction() override {
     if (ClDisableFirToStd)
       return;
 
     auto *context{&getContext()};
-    FIRToStdTypeConverter typeConverter;
+    FIRToStdTypeConverter typeConverter{kindMap};
     M::OwningRewritePatternList patterns;
     patterns.insert<SelectTypeOpConversion>(context, typeConverter);
     M::populateAffineToStdConversionPatterns(patterns, context);
@@ -197,10 +203,13 @@ class FIRToStdLoweringPass : public M::FunctionPass<FIRToStdLoweringPass> {
   M::ModuleOp getModule() {
     return getFunction().getParentOfType<M::ModuleOp>();
   }
+
+private:
+  KindMapping &kindMap;
 };
 
 } // namespace
 
-std::unique_ptr<M::Pass> fir::createFIRToStdPass() {
-  return std::make_unique<FIRToStdLoweringPass>();
+std::unique_ptr<M::Pass> fir::createFIRToStdPass(fir::KindMapping &kindMap) {
+  return std::make_unique<FIRToStdLoweringPass>(kindMap);
 }
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index 38f9643f4c7e..e426b108a74b 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -1513,9 +1513,9 @@ void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, M::Operation *op,
     }
     assert(attr.template dyn_cast_or_null<M::UnitAttr>());
     assert((t + 1 == conds) && "unit must be last");
-    rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(
-        select, M::ValueRange{}, destinations[t],
-        M::ValueRange{destOperands[t]});
+    rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(select, M::ValueRange{},
+                                               destinations[t],
+                                               M::ValueRange{destOperands[t]});
   }
 }
 
@@ -1578,6 +1578,16 @@ struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
   }
 };
 
+// cons an extractvalue on a tuple value, returning value at element `x`
+M::LLVM::ExtractValueOp
+genExtractValueWithIndex(M::Location loc, M::Value *tuple, M::LLVM::LLVMType ty,
+                         M::ConversionPatternRewriter &rewriter,
+                         M::MLIRContext *ctx, int x) {
+  auto cx = M::ArrayAttr::get(rewriter.getI32IntegerAttr(x), ctx);
+  auto xty = ty.getStructElementType(x);
+  return rewriter.create<M::LLVM::ExtractValueOp>(loc, xty, tuple, cx);
+}
+
 // unbox a CHARACTER box value, yielding its components
 struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
   using FIROpConversion::FIROpConversion;
@@ -1586,13 +1596,33 @@ struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto unboxchar = M::cast<UnboxCharOp>(op);
-    unboxchar.replaceAllUsesWith(operands);
-    rewriter.replaceOp(unboxchar, {});
+    auto *ctx = unboxchar.getContext();
+    auto loc = unboxchar.getLoc();
+    auto *tuple = operands[0];
+    auto ty = unwrap(tuple->getType());
+    auto ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
+    auto len = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
+    std::vector<M::Value *> repls = {ptr, len};
+    unboxchar.replaceAllUsesWith(repls);
+    rewriter.eraseOp(unboxchar);
     return matchSuccess();
   }
 };
 
-// unbox a generic box value, yielding its components
+// generate a GEP into a structure and load the element at position `x`
+M::LLVM::LoadOp genLoadWithIndex(M::Location loc, M::Value *tuple,
+                                 M::LLVM::LLVMType ty,
+                                 M::ConversionPatternRewriter &rewriter,
+                                 M::MLIRContext *ctx, M::LLVM::LLVMType oty,
+                                 M::LLVM::ConstantOp c0, int x) {
+  auto ax = rewriter.getI32IntegerAttr(x);
+  auto cx = rewriter.create<M::LLVM::ConstantOp>(loc, oty, ax);
+  auto xty = ty.getStructElementType(x);
+  auto gep = genGEP(loc, xty.getPointerTo(), rewriter, tuple, c0, cx);
+  return rewriter.create<M::LLVM::LoadOp>(loc, xty, gep);
+}
+
+// unbox a generic box reference, yielding its components
 struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1600,8 +1630,24 @@ struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto unbox = M::cast<UnboxOp>(op);
-    unbox.replaceAllUsesWith(operands);
-    rewriter.replaceOp(unbox, {});
+    auto *ctx = unbox.getContext();
+    auto loc = unbox.getLoc();
+    auto *tuple = operands[0];
+    auto ty = unwrap(tuple->getType());
+    auto oty = lowering.offsetType();
+    auto c0 = rewriter.create<M::LLVM::ConstantOp>(
+        loc, oty, rewriter.getI32IntegerAttr(0));
+    auto ptr = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 0);
+    auto len = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 1);
+    auto ver = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 2);
+    auto rank = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 3);
+    auto type = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 4);
+    auto attr = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 5);
+    auto xtra = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 6);
+    // FIXME: add dims, etc.
+    std::vector<M::Value *> repls = {ptr, len, ver, rank, type, attr, xtra};
+    unbox.replaceAllUsesWith(repls);
+    rewriter.eraseOp(unbox);
     return matchSuccess();
   }
 };
@@ -1614,8 +1660,15 @@ struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto unboxproc = M::cast<UnboxProcOp>(op);
-    unboxproc.replaceAllUsesWith(operands);
-    rewriter.replaceOp(unboxproc, {});
+    auto *ctx = unboxproc.getContext();
+    auto loc = unboxproc.getLoc();
+    auto *tuple = operands[0];
+    auto ty = unwrap(tuple->getType());
+    auto ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
+    auto host = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
+    std::vector<M::Value *> repls = {ptr, host};
+    unboxproc.replaceAllUsesWith(repls);
+    rewriter.eraseOp(unboxproc);
     return matchSuccess();
   }
 };
diff --git a/test/fir/select-type.fir b/test/fir/select-type.fir
new file mode 100644
index 000000000000..5c24bc01578b
--- /dev/null
+++ b/test/fir/select-type.fir
@@ -0,0 +1,14 @@
+func @f(%a : !fir.box<none>) -> i32 {
+   %1 = constant 4 : i32
+   %2 = constant 8 : i32
+   %3 = constant 16 : i32
+   fir.select_type %a : !fir.box<none> [#fir.instance<!fir.type<a>>, ^bb2(%1:i32), #fir.subsumed<!fir.type<b>>, ^bb3(%3:i32), unit, ^bb4(%2:i32)]
+^bb2(%4 : i32) :
+   return %4 : i32
+^bb3(%5 : i32) :
+   %6 = addi %5, %5 : i32
+   return %6 : i32
+^bb4(%7 : i32) :
+   %8 = muli %7, %7 : i32
+   return %8 : i32
+}
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 78402849a5aa..b1695c7363d9 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -31,6 +31,7 @@
 #include "../../lib/semantics/unparse-with-symbols.h"
 #include "fir/FIRDialect.h"
 #include "fir/InternalNames.h"
+#include "fir/KindMapping.h"
 #include "fir/Tilikum/Tilikum.h"
 #include "fir/Transforms/Passes.h"
 #include "fir/Transforms/StdConverter.h"
@@ -271,6 +272,7 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   fir::NameUniquer nameUniquer;
   auto burnside = Br::BurnsideBridge::create(
       semanticsContext.defaultKinds(), &parsing.cooked());
+  fir::KindMapping kindMap{&burnside.getMLIRContext()};
   if (driver.dumpPreFIR) {
     burnside.dumpPreFIR();
   }
@@ -287,7 +289,7 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   if (driver.lowerToLLVM) {
     pm.addPass(fir::createLowerToLoopPass());
     if (driver.lowerToStd) {
-      pm.addPass(fir::createFIRToStdPass());
+      pm.addPass(fir::createFIRToStdPass(kindMap));
     }
     pm.addPass(mlir::createLowerToCFGPass());
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index b51b0be2481d..09ee4d82ca28 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -13,6 +13,7 @@
 
 #include "fir/FIRDialect.h"
 #include "fir/InternalNames.h"
+#include "fir/KindMapping.h"
 #include "fir/Tilikum/Tilikum.h"
 #include "fir/Transforms/Passes.h"
 #include "fir/Transforms/StdConverter.h"
@@ -68,6 +69,7 @@ int compileFIR() {
 
   // run passes
   fir::NameUniquer uniquer;
+  fir::KindMapping kindMap{context.get()};
   mlir::PassManager pm{context.get()};
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
@@ -75,7 +77,7 @@ int compileFIR() {
   pm.addPass(fir::createPromoteToAffinePass());
   // convert fir dialect to loop
   pm.addPass(fir::createLowerToLoopPass());
-  pm.addPass(fir::createFIRToStdPass());
+  pm.addPass(fir::createFIRToStdPass(kindMap));
   // convert loop dialect to standard
   pm.addPass(mlir::createLowerToCFGPass());
   pm.addPass(fir::createFIRToLLVMPass(uniquer));

From 86565f80dde430b900d747a5f56e53bd6fe1a85d Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Thu, 19 Dec 2019 16:11:42 -0800
Subject: [PATCH 147/345] Address review comments in prior commit; use more
 name shortcuts.

---
 lib/burnside/ast-builder.cc | 81 +++++++++++++++++++------------------
 lib/burnside/bridge.cc      | 75 +++++++++++++++++-----------------
 lib/burnside/bridge.h       |  4 --
 tools/bbc/bbc.cpp           |  7 ----
 4 files changed, 80 insertions(+), 87 deletions(-)

diff --git a/lib/burnside/ast-builder.cc b/lib/burnside/ast-builder.cc
index 5a4b26ceab12..21a4e236c0bb 100644
--- a/lib/burnside/ast-builder.cc
+++ b/lib/burnside/ast-builder.cc
@@ -17,7 +17,7 @@
 #include <cassert>
 #include <utility>
 
-/// Build an light-weight AST to help with lowering to FIR.  The AST will
+/// Build a light-weight AST to help with lowering to FIR.  The AST will
 /// capture pointers back into the parse tree, so the parse tree data structure
 /// may <em>not</em> be changed between the construction of the AST and all of
 /// its uses.
@@ -29,6 +29,7 @@
 
 namespace Br = Fortran::burnside;
 namespace Co = Fortran::common;
+namespace L = llvm;
 namespace Pa = Fortran::parser;
 
 using namespace Fortran;
@@ -111,96 +112,96 @@ class ASTBuilder {
   // Construct statements
   //
 
-  void Post(const Pa::Statement<parser::AssociateStmt> &s) {
+  void Post(const Pa::Statement<Pa::AssociateStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndAssociateStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndAssociateStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::BlockStmt> &s) {
+  void Post(const Pa::Statement<Pa::BlockStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndBlockStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndBlockStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::SelectCaseStmt> &s) {
+  void Post(const Pa::Statement<Pa::SelectCaseStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::CaseStmt> &s) {
+  void Post(const Pa::Statement<Pa::CaseStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndSelectStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndSelectStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::ChangeTeamStmt> &s) {
+  void Post(const Pa::Statement<Pa::ChangeTeamStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndChangeTeamStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndChangeTeamStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::CriticalStmt> &s) {
+  void Post(const Pa::Statement<Pa::CriticalStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndCriticalStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndCriticalStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::NonLabelDoStmt> &s) {
+  void Post(const Pa::Statement<Pa::NonLabelDoStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndDoStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndDoStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::IfThenStmt> &s) {
+  void Post(const Pa::Statement<Pa::IfThenStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::ElseIfStmt> &s) {
+  void Post(const Pa::Statement<Pa::ElseIfStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::ElseStmt> &s) {
+  void Post(const Pa::Statement<Pa::ElseStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndIfStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndIfStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::SelectRankStmt> &s) {
+  void Post(const Pa::Statement<Pa::SelectRankStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::SelectRankCaseStmt> &s) {
+  void Post(const Pa::Statement<Pa::SelectRankCaseStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::SelectTypeStmt> &s) {
+  void Post(const Pa::Statement<Pa::SelectTypeStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::TypeGuardStmt> &s) {
+  void Post(const Pa::Statement<Pa::TypeGuardStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::WhereConstructStmt> &s) {
+  void Post(const Pa::Statement<Pa::WhereConstructStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::MaskedElsewhereStmt> &s) {
+  void Post(const Pa::Statement<Pa::MaskedElsewhereStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::ElsewhereStmt> &s) {
+  void Post(const Pa::Statement<Pa::ElsewhereStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndWhereStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndWhereStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::ForallConstructStmt> &s) {
+  void Post(const Pa::Statement<Pa::ForallConstructStmt> &s) {
     addEval(makeEvalDirect(s));
   }
-  void Post(const Pa::Statement<parser::EndForallStmt> &s) {
+  void Post(const Pa::Statement<Pa::EndForallStmt> &s) {
     addEval(makeEvalDirect(s));
   }
   // Get rid of production wrapper
-  void Post(const Pa::UnlabeledStatement<parser::ForallAssignmentStmt> &s) {
+  void Post(const Pa::UnlabeledStatement<Pa::ForallAssignmentStmt> &s) {
     addEval(std::visit(
         [&](const auto &x) {
           return AST::Evaluation{x, s.source, {}, parents.back()};
         },
         s.statement.u));
   }
-  void Post(const Pa::Statement<parser::ForallAssignmentStmt> &s) {
+  void Post(const Pa::Statement<Pa::ForallAssignmentStmt> &s) {
     addEval(std::visit(
         [&](const auto &x) {
           return AST::Evaluation{x, s.source, s.label, parents.back()};
@@ -248,7 +249,7 @@ class ASTBuilder {
   // the AST.
   AST::Evaluation makeEvalAction(const Pa::Statement<Pa::ActionStmt> &s) {
     return std::visit(
-        common::visitors{
+        Co::visitors{
             [&](const Pa::ContinueStmt &x) {
               return AST::Evaluation{x, s.source, s.label, parents.back()};
             },
@@ -265,7 +266,7 @@ class ASTBuilder {
   AST::Evaluation makeEvalAction(
       const Pa::UnlabeledStatement<Pa::ActionStmt> &s) {
     return std::visit(
-        common::visitors{
+        Co::visitors{
             [&](const Pa::ContinueStmt &x) {
               return AST::Evaluation{x, s.source, {}, parents.back()};
             },
@@ -485,7 +486,7 @@ void annotateEvalListCFG(
       e.isTarget = true;
     }
     std::visit(
-        common::visitors{
+        Co::visitors{
             [&](const Pa::BackspaceStmt *s) { ioLabel(e, s, cstr); },
             [&](const Pa::CallStmt *s) { altRet(e, s, cstr); },
             [&](const Pa::CloseStmt *s) { ioLabel(e, s, cstr); },
@@ -602,7 +603,7 @@ inline void annotateFuncCFG(AST::FunctionLikeUnit &flu) {
   annotateEvalListCFG(flu.evals, nullptr);
 }
 
-const char *evalName(AST::Evaluation &e) {
+L::StringRef evalName(AST::Evaluation &e) {
   return std::visit(
       Co::visitors{
           [](const Pa::AllocateStmt *) { return "AllocateStmt"; },
@@ -703,11 +704,11 @@ const char *evalName(AST::Evaluation &e) {
 }
 
 void dumpEvalList(
-    llvm::raw_ostream &o, std::list<AST::Evaluation> &evals, int indent = 1) {
+    L::raw_ostream &o, std::list<AST::Evaluation> &evals, int indent = 1) {
   static const std::string white{"                                      ++"};
   std::string indentString{white.substr(0, indent * 2)};
   for (AST::Evaluation &e : evals) {
-    const char *name{evalName(e)};
+    L::StringRef name{evalName(e)};
     if (e.isConstruct()) {
       o << indentString << "<<" << name << ">>\n";
       dumpEvalList(o, *e.getConstructEvals(), indent + 1);
@@ -718,8 +719,8 @@ void dumpEvalList(
   }
 }
 
-void dumpFunctionLikeUnit(llvm::raw_ostream &o, AST::FunctionLikeUnit &flu) {
-  const char *unitKind{};
+void dumpFunctionLikeUnit(L::raw_ostream &o, AST::FunctionLikeUnit &flu) {
+  L::StringRef unitKind{};
   std::string name{};
   std::string header{};
   std::visit(Co::visitors{
@@ -822,7 +823,7 @@ AST::Program *Br::createAST(const Pa::Program &root) {
 
 void Br::annotateControl(AST::Program &ast) {
   for (auto &unit : ast.getUnits()) {
-    std::visit(common::visitors{
+    std::visit(Co::visitors{
                    [](AST::BlockDataUnit &) {},
                    [](AST::FunctionLikeUnit &f) {
                      annotateFuncCFG(f);
@@ -841,7 +842,7 @@ void Br::annotateControl(AST::Program &ast) {
 }
 
 /// Dump an AST.
-void Br::dumpAST(llvm::raw_ostream &o, AST::Program &ast) {
+void Br::dumpAST(L::raw_ostream &o, AST::Program &ast) {
   for (auto &unit : ast.getUnits()) {
     std::visit(
         Co::visitors{
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index ad8cafb567b1..7ed1782259b1 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -47,6 +47,9 @@ using namespace Fortran::burnside;
 
 namespace {
 
+L::cl::opt<bool> ClDumpPreFir("fdebug-dump-pre-fir", L::cl::init(false),
+    L::cl::desc("dump the IR tree prior to FIR"));
+
 L::cl::opt<bool> ClDisableToDoAssert("disable-burnside-todo",
     L::cl::desc("disable burnside bridge asserts"), L::cl::init(false),
     L::cl::Hidden);
@@ -72,7 +75,7 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 #define TODO() \
   { \
     if (ClDisableToDoAssert) \
-      mlir::emitError(toLocation(), __FILE__) \
+      M::emitError(toLocation(), __FILE__) \
           << ":" << __LINE__ << " not implemented"; \
     else \
       assert(false && "not yet implemented"); \
@@ -621,39 +624,39 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::OpenMPConstruct &) { TODO(); }
   void genFIR(const Pa::OmpEndLoopDirective &) { TODO(); }
 
-  void genFIR(const parser::AssociateStmt &) { TODO(); }
-  void genFIR(const parser::EndAssociateStmt &) { TODO(); }
-  void genFIR(const parser::BlockStmt &) { TODO(); }
-  void genFIR(const parser::EndBlockStmt &) { TODO(); }
-  void genFIR(const parser::SelectCaseStmt &) { TODO(); }
-  void genFIR(const parser::CaseStmt &) { TODO(); }
-  void genFIR(const parser::EndSelectStmt &) { TODO(); }
-  void genFIR(const parser::ChangeTeamStmt &) { TODO(); }
-  void genFIR(const parser::EndChangeTeamStmt &) { TODO(); }
-  void genFIR(const parser::CriticalStmt &) { TODO(); }
-  void genFIR(const parser::EndCriticalStmt &) { TODO(); }
+  void genFIR(const Pa::AssociateStmt &) { TODO(); }
+  void genFIR(const Pa::EndAssociateStmt &) { TODO(); }
+  void genFIR(const Pa::BlockStmt &) { TODO(); }
+  void genFIR(const Pa::EndBlockStmt &) { TODO(); }
+  void genFIR(const Pa::SelectCaseStmt &) { TODO(); }
+  void genFIR(const Pa::CaseStmt &) { TODO(); }
+  void genFIR(const Pa::EndSelectStmt &) { TODO(); }
+  void genFIR(const Pa::ChangeTeamStmt &) { TODO(); }
+  void genFIR(const Pa::EndChangeTeamStmt &) { TODO(); }
+  void genFIR(const Pa::CriticalStmt &) { TODO(); }
+  void genFIR(const Pa::EndCriticalStmt &) { TODO(); }
 
   // Do loop is handled by EvalIterative(), EvalStructuredOp()
-  void genFIR(const parser::NonLabelDoStmt &) {}  // do nothing
-  void genFIR(const parser::EndDoStmt &) {}  // do nothing
+  void genFIR(const Pa::NonLabelDoStmt &) {}  // do nothing
+  void genFIR(const Pa::EndDoStmt &) {}  // do nothing
 
   // If-Then-Else is handled by EvalCondGoto(), EvalStructuredOp()
-  void genFIR(const parser::IfThenStmt &) {}  // do nothing
-  void genFIR(const parser::ElseIfStmt &) {}  // do nothing
-  void genFIR(const parser::ElseStmt &) {}  // do nothing
-  void genFIR(const parser::EndIfStmt &) {}  // do nothing
-
-  void genFIR(const parser::SelectRankStmt &) { TODO(); }
-  void genFIR(const parser::SelectRankCaseStmt &) { TODO(); }
-  void genFIR(const parser::SelectTypeStmt &) { TODO(); }
-  void genFIR(const parser::TypeGuardStmt &) { TODO(); }
-
-  void genFIR(const parser::WhereConstructStmt &) { TODO(); }
-  void genFIR(const parser::MaskedElsewhereStmt &) { TODO(); }
-  void genFIR(const parser::ElsewhereStmt &) { TODO(); }
-  void genFIR(const parser::EndWhereStmt &) { TODO(); }
-  void genFIR(const parser::ForallConstructStmt &) { TODO(); }
-  void genFIR(const parser::EndForallStmt &) { TODO(); }
+  void genFIR(const Pa::IfThenStmt &) {}  // do nothing
+  void genFIR(const Pa::ElseIfStmt &) {}  // do nothing
+  void genFIR(const Pa::ElseStmt &) {}  // do nothing
+  void genFIR(const Pa::EndIfStmt &) {}  // do nothing
+
+  void genFIR(const Pa::SelectRankStmt &) { TODO(); }
+  void genFIR(const Pa::SelectRankCaseStmt &) { TODO(); }
+  void genFIR(const Pa::SelectTypeStmt &) { TODO(); }
+  void genFIR(const Pa::TypeGuardStmt &) { TODO(); }
+
+  void genFIR(const Pa::WhereConstructStmt &) { TODO(); }
+  void genFIR(const Pa::MaskedElsewhereStmt &) { TODO(); }
+  void genFIR(const Pa::ElsewhereStmt &) { TODO(); }
+  void genFIR(const Pa::EndWhereStmt &) { TODO(); }
+  void genFIR(const Pa::ForallConstructStmt &) { TODO(); }
+  void genFIR(const Pa::EndForallStmt &) { TODO(); }
 
   //
   // Statements that do not have control-flow semantics
@@ -1090,7 +1093,7 @@ class FirConverter : public AbstractConverter {
   void run(AST::Program &ast) {
     // build pruned control
     for (auto &u : ast.getUnits()) {
-      std::visit(common::visitors{
+      std::visit(Co::visitors{
                      [&](AST::FunctionLikeUnit &f) { pruneFunc(f); },
                      [&](AST::ModuleLikeUnit &m) { pruneMod(m); },
                      [](AST::BlockDataUnit &) { /* do nothing */ },
@@ -1100,7 +1103,7 @@ class FirConverter : public AbstractConverter {
 
     // do translation
     for (auto &u : ast.getUnits()) {
-      std::visit(common::visitors{
+      std::visit(Co::visitors{
                      [&](AST::FunctionLikeUnit &f) { lowerFunc(f, {}); },
                      [&](AST::ModuleLikeUnit &m) { lowerMod(m); },
                      [&](AST::BlockDataUnit &) { TODO(); },
@@ -1134,10 +1137,10 @@ class FirConverter : public AbstractConverter {
   M::Type genType(SymbolRef sym) override final {
     return translateSymbolToFIRType(&mlirContext, defaults, sym);
   }
-  M::Type genType(common::TypeCategory tc, int kind) override final {
+  M::Type genType(Co::TypeCategory tc, int kind) override final {
     return getFIRType(&mlirContext, defaults, tc, kind);
   }
-  M::Type genType(common::TypeCategory tc) override final {
+  M::Type genType(Co::TypeCategory tc) override final {
     return getFIRType(&mlirContext, defaults, tc);
   }
 
@@ -1172,8 +1175,8 @@ void Br::BurnsideBridge::lower(
     const Pa::Program &prg, fir::NameUniquer &uniquer) {
   AST::Program *ast{Br::createAST(prg)};
   Br::annotateControl(*ast);
-  if (getDumpPreFIR()) {
-    Br::dumpAST(llvm::errs(), *ast);
+  if (ClDumpPreFir) {
+    Br::dumpAST(L::errs(), *ast);
   }
   FirConverter converter{*this, uniquer};
   converter.run(*ast);
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index a354409f52af..16763f262525 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -136,9 +136,6 @@ class BurnsideBridge {
   /// Cross the bridge from the Fortran parse-tree, etc. to FIR+OpenMP+MLIR
   void lower(const parser::Program &program, fir::NameUniquer &uniquer);
 
-  void dumpPreFIR(bool flag = true) { dumpPreFIR_ = flag; }
-  bool getDumpPreFIR() { return dumpPreFIR_; }
-
 private:
   explicit BurnsideBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
       const parser::CookedSource *cooked);
@@ -149,7 +146,6 @@ class BurnsideBridge {
   const parser::CookedSource *cooked;
   std::unique_ptr<mlir::MLIRContext> context;
   std::unique_ptr<mlir::ModuleOp> module;
-  bool dumpPreFIR_{false};
 };
 
 }  // Fortran::burnside
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index b1695c7363d9..34e9471c0f35 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -120,7 +120,6 @@ struct DriverOptions {
   bool debugSemantics{false};
   bool measureTree{false};
   bool runBackend{true};
-  bool dumpPreFIR{false};
   bool dumpHLFIR{true};
   bool dumpFIR{true};
   bool lowerToStd{true};
@@ -273,9 +272,6 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   auto burnside = Br::BurnsideBridge::create(
       semanticsContext.defaultKinds(), &parsing.cooked());
   fir::KindMapping kindMap{&burnside.getMLIRContext()};
-  if (driver.dumpPreFIR) {
-    burnside.dumpPreFIR();
-  }
   burnside.lower(parseTree, nameUniquer);
   mlir::ModuleOp mlirModule{burnside.getModule()};
   mlir::PassManager pm{mlirModule.getContext()};
@@ -447,8 +443,6 @@ int main(int argc, char *const argv[]) {
       driver.dumpUnparse = true;
     } else if (arg == "-funparse-with-symbols") {
       driver.dumpUnparseWithSymbols = true;
-    } else if (arg == "-fdebug-dump-pre-fir") {
-      driver.dumpPreFIR = true;
     } else if (arg == "-fno-dump-hl-fir") {
       driver.dumpHLFIR = false;
     } else if (arg == "-fno-dump-fir") {
@@ -515,7 +509,6 @@ int main(int argc, char *const argv[]) {
           << "  -fdebug-resolve-names\n"
           << "  -fdebug-instrumented-parse\n"
           << "  -fdebug-semantics    perform semantic checks\n"
-          << "  -fdebug-dump-pre-fir dump the IR tree prior to FIR\n"
           << "  -fdotty              print FIR as a dotty graph\n"
           << "  -v -c -o -I -D -U    have their usual meanings\n"
           << "  -help                print this again\n"

From 2ddbe31500ff01bab27836823beaf2f26b158c11 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 19 Dec 2019 04:56:34 -0800
Subject: [PATCH 148/345] fix unused var warnings

---
 lib/burnside/convert-type.cc | 2 +-
 lib/burnside/intrinsics.cc   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/burnside/convert-type.cc b/lib/burnside/convert-type.cc
index 173f82d3d213..b82630dc60f3 100644
--- a/lib/burnside/convert-type.cc
+++ b/lib/burnside/convert-type.cc
@@ -278,7 +278,7 @@ class TypeBuilder {
           inputTys.emplace_back(genDummyArgType(*arg));
         }
       }
-    } else if (auto *proc = symbol->detailsIf<Se::ProcEntityDetails>()) {
+    } else if (symbol->detailsIf<Se::ProcEntityDetails>()) {
       // TODO Should probably use evaluate::Characteristics for that.
       TODO();
     } else {
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index 253a973c146a..e0d32015a76b 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -647,9 +647,6 @@ static mlir::Value *createExtremumCompare(mlir::Location loc,
   static constexpr auto integerPredicate{extremum == Extremum::Max
           ? mlir::CmpIPredicate::sgt
           : mlir::CmpIPredicate::slt};
-  static constexpr auto unorderedCmp{extremum == Extremum::Max
-          ? fir::CmpFPredicate::UGT
-          : fir::CmpFPredicate::ULT};
   static constexpr auto orderedCmp{extremum == Extremum::Max
           ? fir::CmpFPredicate::OGT
           : fir::CmpFPredicate::OLT};
@@ -678,6 +675,9 @@ static mlir::Value *createExtremumCompare(mlir::Location loc,
       result = builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
     } else if constexpr (behavior == ExtremumBehavior::PgfortranLlvm) {
       // If one of the operand is a NaN, return left whatever it is.
+      static constexpr auto unorderedCmp{extremum == Extremum::Max
+              ? fir::CmpFPredicate::UGT
+              : fir::CmpFPredicate::ULT};
       result = builder.create<fir::CmpfOp>(loc, unorderedCmp, left, right);
     } else {
       // TODO: ieeMinNum/ieeeMaxNum

From f502f90ac44cf343620f0f2d8ca84cf232ebe834 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 20 Dec 2019 02:14:04 -0800
Subject: [PATCH 149/345] Primitive scalar character assignement lowering:

This lowering of character assignment works for `c1 = c2` where:
 - c1 and c2 are scalar variables with an explicit length (constant or not).
 - c1 and c2 do not overlap.
It handles the case where c1 and c2 do not have the same length.
The implementation is based on `fir.loop` and does not use any runtime. This
is more a proof of concept than a profond design choice.

After this commit, it is possible to lower to FIR and to get an functional
executable for:

SUBROUTINE foo(c1, c2, n)
  INTEGER :: n
  CHARACTER(n) :: c1
  CHARACTER(10) :: c2
  c1 = c2
END SUBROUTINE

FIXME/TODO are inserted for:
- The case where c1 or c2 is assumed length should "work" once rebased with
more up-do-date version of lib/evaluate, though `evaluate::DescriptorInquiry`
will also need to be lowered then.
- The case where c2 is not a variable needs more work.
- To support overlaps, a temporary might be considered.
---
 lib/burnside/bridge.cc       | 97 +++++++++++++++++++++++++++++++++++-
 lib/burnside/convert-expr.cc | 16 +++++-
 2 files changed, 109 insertions(+), 4 deletions(-)

diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index 7ed1782259b1..b84b7752d44c 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -678,10 +678,103 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::WriteStmt &stmt) { genWriteStatement(*this, stmt); }
 
   void genFIR(const Pa::AllocateStmt &) { TODO(); }
+
+  void genCharacterAssignement(
+      const Ev::Assignment::IntrinsicAssignment &assignment) {
+    // Helper to get address and length from an Expr that is a character
+    // variable designator
+    auto getAddrAndLength{[&](const SomeExpr &charDesignatorExpr)
+                              -> std::pair<mlir::Value *, mlir::Value *> {
+      auto *addr{genExprAddr(charDesignatorExpr)};
+      const auto &charExpr{
+          std::get<Ev::Expr<Ev::SomeCharacter>>(charDesignatorExpr.u)};
+      // FIXME LEN() should also succeed on character(*) and return a
+      // DescriptorInquiry, this does not work but should be fixed after FIR f18
+      // is rebased with master f18 that contains PR871.
+      std::optional<Ev::Expr<Ev::SubscriptInteger>> lenExpr{charExpr.LEN()};
+      assert(lenExpr && "could not get expression to compute character length");
+      auto *len{genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)))};
+      return {addr, len};
+    }};
+
+    auto lhsAddrAndLen{getAddrAndLength(assignment.lhs)};
+    // FIXME:  In general an address cannot be obtained for rhs because it does
+    // not have to be a variable. rhs either needs to be materialized (but this
+    // just push the problem into assigning into a temp), or each element of the
+    // character rhs must be computed and directly assigned in the related lhs
+    // element.
+    auto rhsAddrAndLen{getAddrAndLength(assignment.rhs)};
+
+    // Generate the copy.
+    // FIXME: Currently assumes no overlap (else a temp should be used).
+
+    // Get reference and character type.
+    assert(lhsAddrAndLen.first && "could not get character variable address");
+    auto charRefType{
+        lhsAddrAndLen.first->getType().dyn_cast<fir::ReferenceType>()};
+    assert(charRefType && "expected character reference type");
+    auto charType{charRefType.getEleTy()};
+    // Cast character string to array of character to index it in fir.loop
+    // This is currently required by fir::CoordinateOp.
+    fir::SequenceType::Shape shape{-1};
+    auto arrayRefCharType{
+        fir::ReferenceType::get(fir::SequenceType::get(shape, charType))};
+    auto lhsArrayView{builder->create<fir::ConvertOp>(
+        toLocation(), arrayRefCharType, lhsAddrAndLen.first)};
+    auto rhsArrayView{builder->create<fir::ConvertOp>(
+        toLocation(), arrayRefCharType, rhsAddrAndLen.first)};
+
+    // Build loop to copy rhs
+    auto indexTy{M::IndexType::get(builder->getContext())};
+    auto zero{builder->create<M::ConstantOp>(
+        toLocation(), indexTy, builder->getIntegerAttr(indexTy, 0))};
+    auto one{builder->create<M::ConstantOp>(
+        toLocation(), indexTy, builder->getIntegerAttr(indexTy, 1))};
+    L::SmallVector<M::Value *, 1> step;
+    step.emplace_back(one);
+    // Copy the minimum of the lhs and rhs lengths
+    auto cmpLen{builder->create<M::CmpIOp>(toLocation(), M::CmpIPredicate::slt,
+        lhsAddrAndLen.second, rhsAddrAndLen.second)};
+    auto copyLen{builder->create<M::SelectOp>(
+        toLocation(), cmpLen, lhsAddrAndLen.second, rhsAddrAndLen.second)};
+    auto copyMaxIndex{
+        builder->create<fir::ConvertOp>(toLocation(), indexTy, copyLen)};
+    auto copyLoop{
+        builder->create<fir::LoopOp>(toLocation(), zero, copyMaxIndex, step)};
+    auto *insPt{builder->getInsertionBlock()};
+    builder->setInsertionPointToStart(copyLoop.getBody());
+    auto index{copyLoop.getInductionVar()};
+    auto lhsElementAddr{builder->create<fir::CoordinateOp>(
+        toLocation(), charRefType, lhsArrayView, index)};
+    auto rhsElementAddr{builder->create<fir::CoordinateOp>(
+        toLocation(), charRefType, rhsArrayView, index)};
+    auto elementVal{builder->create<fir::LoadOp>(toLocation(), rhsElementAddr)};
+    builder->create<fir::StoreOp>(toLocation(), elementVal, lhsElementAddr);
+    builder->setInsertionPointToEnd(insPt);
+
+    // Build loop to pad lhs with blanks if needed.
+    auto padMaxIndex{builder->create<fir::ConvertOp>(
+        toLocation(), indexTy, lhsAddrAndLen.second)};
+    auto byteTy{M::IntegerType::get(8, builder->getContext())};
+    auto asciiSpace{builder->create<M::ConstantOp>(
+        toLocation(), byteTy, builder->getIntegerAttr(byteTy, 32))};
+    auto blank{
+        builder->create<fir::ConvertOp>(toLocation(), charType, asciiSpace)};
+    auto padLoop{builder->create<fir::LoopOp>(
+        toLocation(), copyMaxIndex, padMaxIndex, step)};
+    insPt = builder->getInsertionBlock();
+    builder->setInsertionPointToStart(padLoop.getBody());
+    auto padIndex{padLoop.getInductionVar()};
+    auto lhsElementAddrPad{builder->create<fir::CoordinateOp>(
+        toLocation(), charRefType, lhsArrayView, padIndex)};
+    builder->create<fir::StoreOp>(toLocation(), blank, lhsElementAddrPad);
+    builder->setInsertionPointToEnd(insPt);
+  }
+
   void genFIR(const Pa::AssignmentStmt &stmt) {
     assert(stmt.typedAssignment && "assignment analysis failed");
     // Warning: v->u must become v.u after next f18 rebase
-    if (auto *assignment{std::get_if<Ev::Assignment::IntrinsicAssignment>(
+    if (const auto *assignment{std::get_if<Ev::Assignment::IntrinsicAssignment>(
             &stmt.typedAssignment->v->u)}) {
       const Se::Symbol *sym{Ev::UnwrapWholeSymbolDataRef(assignment->lhs)};
       if (sym && Se::IsAllocatable(*sym)) {
@@ -714,7 +807,7 @@ class FirConverter : public AbstractConverter {
           break;
         case CharacterCat:
           // Fortran 2018 10.2.1.3 p10 and p11
-          TODO();
+          genCharacterAssignement(*assignment);
           break;
         case DerivedCat:
           // Fortran 2018 10.2.1.3 p12 and p13
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index 93977060607e..b458a286549c 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -228,8 +228,20 @@ class ExprLowering {
 
   M::Value *gen(Se::SymbolRef sym) {
     // FIXME: not all symbols are local
-    return createTemporary(
-        getLoc(), builder, symMap, converter.genType(sym), &*sym);
+    auto *addr{createTemporary(
+        getLoc(), builder, symMap, converter.genType(sym), &*sym)};
+    assert(addr && "failed generating symbol address");
+    // Get address from descriptor if symbol has one.
+    auto type{addr->getType()};
+    if (auto boxCharType{type.dyn_cast<fir::BoxCharType>()}) {
+      auto refType{fir::ReferenceType::get(boxCharType.getEleTy())};
+      auto lenType{mlir::IntegerType::get(64, builder.getContext())};
+      addr = builder.create<fir::UnboxCharOp>(getLoc(), refType, lenType, addr)
+                 .getResult(0);
+    } else if (type.isa<fir::BoxType>()) {
+      TODO();
+    }
+    return addr;
   }
   M::Value *gendef(Se::SymbolRef sym) { return gen(sym); }
 

From 02ad563ef13c985be81d8c6590c720a31af6bb32 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 20 Dec 2019 11:22:30 -0800
Subject: [PATCH 150/345] get select_type lowered build changes lower complex
 and some cleanup

changes to fix rebasing

port over to MLIR post the merge of MLIR to the monorepo

rename file
fix merge problems
---
 ...ng.md => BijectiveInternalNameUniquing.md} |   0
 include/fir/FIROps.h                          |  75 ++---
 include/fir/FIROps.td                         | 129 +++----
 include/fir/FIROpsSupport.h                   |   6 +-
 include/fir/InternalNames.h                   |  19 +-
 lib/burnside/ast-builder.cc                   |   8 +-
 lib/burnside/bridge.cc                        |  86 +++--
 lib/burnside/bridge.h                         |  20 +-
 lib/burnside/builder.cc                       |  24 +-
 lib/burnside/builder.h                        |  26 +-
 lib/burnside/complex-handler.h                |  76 ++---
 lib/burnside/convert-expr.cc                  | 262 +++++++--------
 lib/burnside/convert-expr.h                   |  26 +-
 lib/burnside/intrinsics.cc                    | 315 +++++++++---------
 lib/burnside/intrinsics.h                     |  26 +-
 lib/burnside/io.cc                            |  30 +-
 lib/burnside/io.h                             |  18 +-
 lib/burnside/runtime.h                        |  30 +-
 lib/fir/FIRDialect.cpp                        |  20 +-
 lib/fir/FIROps.cpp                            |  86 +++--
 lib/fir/InternalNames.cpp                     | 116 ++++++-
 lib/fir/KindMapping.cpp                       |   3 +
 lib/fir/StdConverter.cpp                      |  38 +--
 lib/fir/Tilikum.cpp                           | 181 ++++++----
 lib/fir/Transforms/CSE.cpp                    |  36 +-
 lib/fir/Transforms/MemToReg.cpp               |  44 +--
 lib/fir/Transforms/RewriteLoop.cpp            |  22 +-
 test/fir/fir-ops.fir                          |   4 +-
 tools/tco/CMakeLists.txt                      |   6 +-
 tools/tco/tco.cpp                             |   7 +-
 30 files changed, 923 insertions(+), 816 deletions(-)
 rename documentation/{BijectiveInternalNameMangling.md => BijectiveInternalNameUniquing.md} (100%)

diff --git a/documentation/BijectiveInternalNameMangling.md b/documentation/BijectiveInternalNameUniquing.md
similarity index 100%
rename from documentation/BijectiveInternalNameMangling.md
rename to documentation/BijectiveInternalNameUniquing.md
diff --git a/include/fir/FIROps.h b/include/fir/FIROps.h
index d4d656c15d6a..2bf565c1da01 100644
--- a/include/fir/FIROps.h
+++ b/include/fir/FIROps.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- FIROps.h - FIR operations -------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FIR_FIROPS_H
 #define FIR_FIROPS_H
@@ -58,10 +52,9 @@ enum class CmpFPredicate {
 
 /// `fir.global` is a typed symbol with an optional list of initializers.
 class GlobalOp
-    : public mlir::Op<
-          GlobalOp, mlir::OpTrait::ZeroOperands, mlir::OpTrait::ZeroResult,
-          mlir::OpTrait::IsIsolatedFromAbove,
-          mlir::OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
+    : public mlir::Op<GlobalOp, OpTrait::ZeroOperands, OpTrait::ZeroResult,
+                      OpTrait::IsIsolatedFromAbove,
+                      OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
 public:
   using Op::Op;
   using Op::print;
@@ -69,15 +62,17 @@ class GlobalOp
   static llvm::StringRef getOperationName() { return "fir.global"; }
   static llvm::StringRef getTypeAttrName() { return "type"; }
 
-  static void build(mlir::Builder *builder, mlir::OperationState *result,
+  static void build(mlir::Builder *builder, OperationState &result,
                     llvm::StringRef name, mlir::Type type,
-                    llvm::ArrayRef<mlir::NamedAttribute> attrs);
+                    llvm::ArrayRef<NamedAttribute> attrs);
+
+  static GlobalOp create(Location loc, llvm::StringRef name, mlir::Type type,
+                         llvm::ArrayRef<NamedAttribute> attrs = {});
 
   /// Operation hooks.
-  static mlir::ParseResult parse(mlir::OpAsmParser &parser,
-                                 mlir::OperationState &result);
-  void print(mlir::OpAsmPrinter &p);
-  mlir::LogicalResult verify();
+  static ParseResult parse(OpAsmParser &parser, OperationState &result);
+  void print(OpAsmPrinter &p);
+  LogicalResult verify();
 
   mlir::Type getType() {
     return getAttrOfType<TypeAttr>(getTypeAttrName()).getValue();
@@ -92,24 +87,22 @@ class GlobalOp
 /// `fir.dispatch_table` is an untyped symbol that is a list of associations
 /// between method identifiers and a FuncOp symbol.
 class DispatchTableOp
-    : public mlir::Op<
-          DispatchTableOp, mlir::OpTrait::ZeroOperands,
-          mlir::OpTrait::ZeroResult, mlir::OpTrait::IsIsolatedFromAbove,
-          mlir::OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
+    : public mlir::Op<DispatchTableOp, OpTrait::ZeroOperands,
+                      OpTrait::ZeroResult, OpTrait::IsIsolatedFromAbove,
+                      OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
 public:
   using Op::Op;
 
   static llvm::StringRef getOperationName() { return "fir.dispatch_table"; }
 
-  static void build(mlir::Builder *builder, mlir::OperationState *result,
+  static void build(mlir::Builder *builder, OperationState *result,
                     llvm::StringRef name, mlir::Type type,
-                    llvm::ArrayRef<mlir::NamedAttribute> attrs);
+                    llvm::ArrayRef<NamedAttribute> attrs);
 
   /// Operation hooks.
-  static mlir::ParseResult parse(mlir::OpAsmParser &parser,
-                                 mlir::OperationState &result);
-  void print(mlir::OpAsmPrinter &p);
-  mlir::LogicalResult verify();
+  static ParseResult parse(OpAsmParser &parser, OperationState &result);
+  void print(OpAsmPrinter &p);
+  LogicalResult verify();
 
   void appendTableEntry(mlir::Operation *op);
 
@@ -117,27 +110,23 @@ class DispatchTableOp
   mlir::Region &front();
 };
 
-mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);
+ParseResult isValidCaseAttr(mlir::Attribute attr);
 unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
                                unsigned dest);
-mlir::ParseResult parseSelector(mlir::OpAsmParser *parser,
-                                mlir::OperationState *result,
-                                mlir::OpAsmParser::OperandType &selector,
-                                mlir::Type &type);
+ParseResult parseSelector(OpAsmParser *parser, OperationState *result,
+                          OpAsmParser::OperandType &selector, mlir::Type &type);
 
 void buildCmpFOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value *lhs, Value *rhs);
+                 CmpFPredicate predicate, Value lhs, Value rhs);
 void buildCmpCOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value *lhs, Value *rhs);
-mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result);
-mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result);
+                 CmpFPredicate predicate, Value lhs, Value rhs);
+ParseResult parseCmpfOp(OpAsmParser &parser, OperationState &result);
+ParseResult parseCmpcOp(OpAsmParser &parser, OperationState &result);
 
 #define GET_OP_CLASSES
 #include "fir/FIROps.h.inc"
 
-LoopOp getForInductionVarOwner(mlir::Value *val);
+LoopOp getForInductionVarOwner(mlir::Value val);
 
 bool isReferenceLike(mlir::Type type);
 
diff --git a/include/fir/FIROps.td b/include/fir/FIROps.td
index 322082ee2aba..bf4926dc0f72 100644
--- a/include/fir/FIROps.td
+++ b/include/fir/FIROps.td
@@ -1,20 +1,15 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- FIROps.td - FIR operation definitions --------------*- tablegen -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//
-// Definition of the FIR dialect operations
+// 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
+/// Definition of the FIR dialect operations
+///
+//===----------------------------------------------------------------------===//
 
 #ifdef FIR_DIALECT_FIR_OPS
 #else
@@ -126,7 +121,7 @@ class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
 
 def fir_AllocateOpBuilder : OpBuilder<
   "Builder *builder, OperationState &result, Type inType,"
-  "ArrayRef<Value *> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
+  "ArrayRef<Value> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
     result.addAttribute("in_type", M::TypeAttr::get(inType));
@@ -137,7 +132,7 @@ def fir_AllocateOpBuilder : OpBuilder<
 
 def fir_NamedAllocateOpBuilder : OpBuilder<
   "Builder *builder, OperationState &result, Type inType, StringRef name,"
-  "ArrayRef<Value *> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
+  "ArrayRef<Value> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
     result.addAttribute("in_type", M::TypeAttr::get(inType));
@@ -149,7 +144,7 @@ def fir_NamedAllocateOpBuilder : OpBuilder<
 
 def fir_OneResultOpBuilder : OpBuilder<
   "Builder *, OperationState &result, Type resultType,"
-  "ArrayRef<Value *> operands, ArrayRef<NamedAttribute> attributes = {}",
+  "ArrayRef<Value> operands, ArrayRef<NamedAttribute> attributes = {}",
   [{
     if (resultType)
       result.addTypes(resultType);
@@ -294,7 +289,7 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
   }];
 
   let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, Value *refVal",
+    "Builder *builder, OperationState &result, Value refVal",
     [{
       if (!refVal) {
         mlir::emitError(result.location, "LoadOp has null argument");
@@ -464,9 +459,9 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic, !listconcat(traits, [Terminator])>,
     Arguments<(ins Variadic<AnyType>:$args)>, Results<(outs)> {
   let builders = [OpBuilder<
-    "Builder *, OperationState &result, Value *selector,"
-    "ArrayRef<Value *> properOperands, ArrayRef<Block *> destinations,"
-    "ArrayRef<ArrayRef<Value *>> operands = {},"
+    "Builder *, OperationState &result, Value selector,"
+    "ArrayRef<Value> properOperands, ArrayRef<Block *> destinations,"
+    "ArrayRef<ArrayRef<Value>> operands = {},"
     "ArrayRef<NamedAttribute> attributes = {}",
     [{
       result.addOperands(selector);
@@ -481,14 +476,14 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
   >];
 
   string extraSwitchClassDeclaration = [{
-    using Conditions = mlir::Value *;
+    using Conditions = mlir::Value;
     constexpr static auto AttrName = "cases";
 
     // The number of destination conditions that may be tested
     unsigned getNumConditions() { return getNumDest(); }
 
     // The selector is the value being tested to determine the destination
-    mlir::Value *getSelector() { return getOperand(0); }
+    mlir::Value getSelector() { return getOperand(0); }
 
     // The number of blocks that may be branched to
     unsigned getNumDest() { return getOperation()->getNumSuccessors(); }
@@ -505,11 +500,11 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
 
     llvm::SmallVector<M::Attribute, 4> ivalues;
     llvm::SmallVector<M::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
+    llvm::SmallVector<llvm::SmallVector<M::Value, 4>, 4> destArgs;
     while (true) {
       M::Attribute ivalue; // Integer or Unit
       M::Block *dest;
-      llvm::SmallVector<M::Value *, 4> destArg;
+      llvm::SmallVector<M::Value, 4> destArg;
       llvm::SmallVector<M::NamedAttribute, 1> temp;
       if (parser.parseAttribute(ivalue, "i", temp) ||
           parser.parseComma() ||
@@ -616,11 +611,11 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     llvm::SmallVector<M::Attribute, 4> attrs;
     llvm::SmallVector<M::OpAsmParser::OperandType, 4> opers;
     llvm::SmallVector<M::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
+    llvm::SmallVector<llvm::SmallVector<M::Value, 4>, 4> destArgs;
     while (true) {
       M::Attribute attr;
       M::Block *dest;
-      llvm::SmallVector<M::Value *, 4> destArg;
+      llvm::SmallVector<M::Value, 4> destArg;
       llvm::SmallVector<M::NamedAttribute, 1> temp;
       if (parser.parseAttribute(attr, "a", temp) ||
           isValidCaseAttr(attr) ||
@@ -700,7 +695,7 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
 
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
 
-    mlir::Value* getCaseArg(unsigned dest, unsigned ele) {
+    mlir::Value getCaseArg(unsigned dest, unsigned ele) {
       assert(ele < 2);
       assert(dest < getNumConditions());
       auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
@@ -730,11 +725,11 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
 
     llvm::SmallVector<M::Attribute, 4> attrs;
     llvm::SmallVector<M::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<M::Value *, 4>, 4> destArgs;
+    llvm::SmallVector<llvm::SmallVector<M::Value, 4>, 4> destArgs;
     while (true) {
       M::Attribute attr;
       M::Block *dest;
-      llvm::SmallVector<M::Value *, 4> destArg;
+      llvm::SmallVector<M::Value, 4> destArg;
       llvm::SmallVector<M::NamedAttribute, 1> temp;
       if (parser.parseAttribute(attr, "a", temp) ||
           parser.parseComma() ||
@@ -980,7 +975,7 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
 
   let printer = [{
     p << getOperationName() << ' ' << getAttr("funcname");
-    auto *h = host();
+    auto h = host();
     if (h) {
       p << ", ";
       p.printOperand(h);
@@ -1216,7 +1211,7 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
 
   let verifier = [{
     // Recovering a LEN type parameter only makes sense from a boxed value
-    for (auto *co : coor())
+    for (auto co : coor())
       if (auto *s = co->getDefiningOp())
         if (dyn_cast_or_null<LenParamIndexOp>(s)) {
           if (getNumOperands() != 2)
@@ -1276,7 +1271,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, StringRef fieldName,"
-    "Type recTy, ArrayRef<Value*> operands = {}",
+    "Type recTy, ArrayRef<Value> operands = {}",
     [{
       result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
       result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
@@ -1320,7 +1315,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
       p << '(';
       p.printOperands(lenparams());
       auto sep = ") : ";
-      for (auto *op : lenparams()) {
+      for (auto op : lenparams()) {
         p << sep;
         if (op)
           p.printType(op->getType());
@@ -1475,8 +1470,8 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
               "int64_t lowerBound, int64_t upperBound, int64_t step = 1">,
     OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
-              "mlir::Value *lowerBound, mlir::Value *upperBound,"
-              "llvm::ArrayRef<mlir::Value*> step">
+              "mlir::Value lowerBound, mlir::Value upperBound,"
+              "llvm::ArrayRef<mlir::Value> step">
   ];
   let parser = [{ return parseLoopOp(parser, result); }];
 
@@ -1516,17 +1511,17 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
 
   let extraClassDeclaration = [{
     mlir::Block *getBody() { return &region().front(); }
-    mlir::Value *getInductionVar() { return getBody()->getArgument(0); }
+    mlir::Value getInductionVar() { return getBody()->getArgument(0); }
     mlir::OpBuilder getBodyBuilder() {
       return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
     }
-    void setLowerBound(mlir::Value *bound) {
+    void setLowerBound(mlir::Value bound) {
       getOperation()->setOperand(0, bound);
     }
-    void setUpperBound(mlir::Value *bound) {
+    void setUpperBound(mlir::Value bound) {
       getOperation()->setOperand(1, bound);
      }
-    void setStep(mlir::Value *step) {
+    void setStep(mlir::Value step) {
       getOperation()->setOperand(2, step);
     }
     static char const* getStepKeyword() { return "step"; }
@@ -1544,7 +1539,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"Builder *builder, OperationState &result, "
-              "Value *cond, bool withOtherRegion">
+              "Value cond, bool withOtherRegion">
   ];
   let parser = [{ return parseWhereOp(parser, result); }];
 
@@ -1750,7 +1745,7 @@ def fir_CmpfOp : fir_Op<"cmpf",
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpFPredicate predicate,"
-    "Value *lhs, Value *rhs", [{
+    "Value lhs, Value rhs", [{
       fir::buildCmpFOp(builder, result, predicate, lhs, rhs);
   }]>];
 
@@ -1798,7 +1793,7 @@ def fir_CmpcOp : fir_Op<"cmpc",
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpFPredicate predicate,"
-    "Value *lhs, Value *rhs", [{
+    "Value lhs, Value rhs", [{
       fir::buildCmpCOp(builder, result, predicate, lhs, rhs);
   }]>];
 
@@ -1879,7 +1874,21 @@ def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]>,
   }];
 }
 
-def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
+def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
+    Or<[CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CharacterType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CplxType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::IntType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::LogicalType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RealType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RecordType>()">]>]>,
+    "Fortran surface type"> {
+  let storageType = [{ TypeAttr }];
+  let returnType = "Type";
+  let convertFromStorage = "$_self.getValue().cast<Type>()";
+}
+
+def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]>,
+  Arguments<(ins FortranTypeAttr:$in_type)> {
   let summary = "generate a type descriptor for a given type";
 
   let description = [{
@@ -1893,30 +1902,36 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
     if (parser.parseType(intype))
       return M::failure();
     result.addAttribute("in_type", M::TypeAttr::get(intype));
-    M::Type restype;
-    if (parser.parseColonType(restype) ||
-        parser.addTypeToList(restype, result.types))
+    M::Type restype = TypeDescType::get(intype);
+    if (parser.addTypeToList(restype, result.types))
       return M::failure();
     return M::success();
   }];
 
-  let builders = [OpBuilder<
-    "Builder *, OperationState &result, mlir::TypeAttr res",
-    [{
-      result.addAttribute("in_type", res);
-      result.addTypes(res.getValue());
-    }]
-  >];
+  let builders = [
+    OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty">
+  ];
 
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
-    p << " : " << getType();
     p.printOptionalAttrDict(getAttrs(), {"in_type"});
   }];
 
+  let verifier = [{
+    M::Type resultTy = getType();
+    if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
+      if (tdesc.getOfTy() != getInType())
+        return emitOpError("wrapped type mismatched");
+    } else {
+      return emitOpError("must be !fir.tdesc type");
+    }
+    return M::success();
+  }];
+
   let extraClassDeclaration = [{
     mlir::Type getInType() {
-      return getAttrOfType<mlir::TypeAttr>("in_type").getType();
+      // get the type that the type descriptor describes
+      return getAttrOfType<mlir::TypeAttr>("in_type").getValue();
     }
   }];
 }
diff --git a/include/fir/FIROpsSupport.h b/include/fir/FIROpsSupport.h
index 6a133045975d..450fd20f596e 100644
--- a/include/fir/FIROpsSupport.h
+++ b/include/fir/FIROpsSupport.h
@@ -66,11 +66,13 @@ inline bool pureCall(mlir::Operation *op) {
 /// If `module` already contains FuncOp `name`, it is returned. Otherwise, a new
 /// FuncOp is created, and that new FuncOp is returned.
 mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
-                          llvm::StringRef name, mlir::FunctionType type);
+                          llvm::StringRef name, mlir::FunctionType type,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
 
 /// Get or create a GlobalOp in a module.
 fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
-                             llvm::StringRef name, mlir::Type type);
+                             llvm::StringRef name, mlir::Type type,
+                             llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
 
 } // namespace fir
 
diff --git a/include/fir/InternalNames.h b/include/fir/InternalNames.h
index 78c58af996b1..2fb47a1d5c07 100644
--- a/include/fir/InternalNames.h
+++ b/include/fir/InternalNames.h
@@ -15,14 +15,12 @@
 #ifndef FIR_INTERNAL_NAMES_H
 #define FIR_INTERNAL_NAMES_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSet.h"
 #include <cstdint>
 
 namespace llvm {
-template <typename>
-class ArrayRef;
-template <typename>
-class Optional;
 class Twine;
 } // namespace llvm
 
@@ -41,6 +39,7 @@ namespace fir {
 struct NameUniquer {
   enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };
 
+  /// The sort of the unique name
   enum class NameKind {
     NOT_UNIQUED,
     COMMON,
@@ -54,7 +53,15 @@ struct NameUniquer {
     VARIABLE
   };
 
+  /// Components of an unparsed unique name
   struct DeconstructedName {
+    DeconstructedName(llvm::StringRef name) : name{name} {}
+    DeconstructedName(llvm::ArrayRef<std::string> modules,
+                      llvm::Optional<std::string> host, llvm::StringRef name,
+                      llvm::ArrayRef<std::int64_t> kinds)
+        : modules{modules.begin(), modules.end()}, host{host}, name{name},
+          kinds{kinds.begin(), kinds.end()} {}
+
     llvm::SmallVector<std::string, 2> modules;
     llvm::Optional<std::string> host;
     std::string name;
@@ -99,6 +106,10 @@ struct NameUniquer {
                                llvm::Optional<llvm::StringRef> host,
                                llvm::StringRef name,
                                llvm::ArrayRef<std::int64_t> kinds);
+  std::string doTypeDescriptor(llvm::ArrayRef<std::string> modules,
+                               llvm::Optional<std::string> host,
+                               llvm::StringRef name,
+                               llvm::ArrayRef<std::int64_t> kinds);
 
   /// Unique a (global) variable name
   std::string doVariable(llvm::ArrayRef<llvm::StringRef> modules,
diff --git a/lib/burnside/ast-builder.cc b/lib/burnside/ast-builder.cc
index 21a4e236c0bb..6627d9272538 100644
--- a/lib/burnside/ast-builder.cc
+++ b/lib/burnside/ast-builder.cc
@@ -609,7 +609,7 @@ L::StringRef evalName(AST::Evaluation &e) {
           [](const Pa::AllocateStmt *) { return "AllocateStmt"; },
           [](const Pa::ArithmeticIfStmt *) { return "ArithmeticIfStmt"; },
           [](const Pa::AssignedGotoStmt *) { return "AssignedGotoStmt"; },
-          [](const Pa::AssignmentStmt *x) { return "AssignmentStmt"; },
+          [](const Pa::AssignmentStmt *) { return "AssignmentStmt"; },
           [](const Pa::AssignStmt *) { return "AssignStmt"; },
           [](const Pa::BackspaceStmt *) { return "BackspaceStmt"; },
           [](const Pa::CallStmt *) { return "CallStmt"; },
@@ -627,7 +627,7 @@ L::StringRef evalName(AST::Evaluation &e) {
           [](const Pa::ForallStmt *) { return "ForallStmt"; },
           [](const Pa::FormTeamStmt *) { return "FormTeamStmt"; },
           [](const Pa::GotoStmt *) { return "GotoStmt"; },
-          [](const Pa::IfStmt *x) { return "IfStmt"; },
+          [](const Pa::IfStmt *) { return "IfStmt"; },
           [](const Pa::InquireStmt *) { return "InquireStmt"; },
           [](const Pa::LockStmt *) { return "LockStmt"; },
           [](const Pa::NullifyStmt *) { return "NullifyStmt"; },
@@ -677,7 +677,7 @@ L::StringRef evalName(AST::Evaluation &e) {
           [](const Pa::CaseStmt *) { return "CaseStmt"; },
           [](const Pa::ChangeTeamStmt *) { return "ChangeTeamStmt"; },
           [](const Pa::CriticalStmt *) { return "CriticalStmt"; },
-          [](const Pa::ElseIfStmt *x) { return "ElseIfStmt"; },
+          [](const Pa::ElseIfStmt *) { return "ElseIfStmt"; },
           [](const Pa::ElseStmt *) { return "ElseStmt"; },
           [](const Pa::ElsewhereStmt *) { return "ElsewhereStmt"; },
           [](const Pa::EndAssociateStmt *) { return "EndAssociateStmt"; },
@@ -690,7 +690,7 @@ L::StringRef evalName(AST::Evaluation &e) {
           [](const Pa::EndSelectStmt *) { return "EndSelectStmt"; },
           [](const Pa::EndWhereStmt *) { return "EndWhereStmt"; },
           [](const Pa::ForallConstructStmt *) { return "ForallConstructStmt"; },
-          [](const Pa::IfThenStmt *x) { return "IfThenStmt"; },
+          [](const Pa::IfThenStmt *) { return "IfThenStmt"; },
           [](const Pa::MaskedElsewhereStmt *) { return "MaskedElsewhereStmt"; },
           [](const Pa::NonLabelDoStmt *) { return "NonLabelDoStmt"; },
           [](const Pa::SelectCaseStmt *) { return "SelectCaseStmt"; },
diff --git a/lib/burnside/bridge.cc b/lib/burnside/bridge.cc
index b84b7752d44c..b4ca23ce0a89 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/burnside/bridge.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/bridge.cc ----------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "bridge.h"
 #include "ast-builder.h"
@@ -93,18 +87,18 @@ class FirConverter : public AbstractConverter {
   // Helper function members
   //
 
-  M::Value *createFIRAddr(M::Location loc, const Se::SomeExpr *expr) {
+  M::Value createFIRAddr(M::Location loc, const Se::SomeExpr *expr) {
     return createSomeAddress(loc, *this, *expr, localSymbols, intrinsics);
   }
 
-  M::Value *createFIRExpr(M::Location loc, const Se::SomeExpr *expr) {
+  M::Value createFIRExpr(M::Location loc, const Se::SomeExpr *expr) {
     return createSomeExpression(loc, *this, *expr, localSymbols, intrinsics);
   }
-  M::Value *createLogicalExprAsI1(M::Location loc, const Se::SomeExpr *expr) {
+  M::Value createLogicalExprAsI1(M::Location loc, const Se::SomeExpr *expr) {
     return createI1LogicalExpression(
         loc, *this, *expr, localSymbols, intrinsics);
   }
-  M::Value *createTemporary(M::Location loc, const Se::Symbol &sym) {
+  M::Value createTemporary(M::Location loc, const Se::Symbol &sym) {
     return Br::createTemporary(loc, *builder, localSymbols, genType(sym), &sym);
   }
 
@@ -262,8 +256,8 @@ class FirConverter : public AbstractConverter {
   /// Generate the cleanup block before the procedure exits
   void genFIRFunctionReturn(const Se::Symbol &functionSymbol) {
     const auto &details{functionSymbol.get<Se::SubprogramDetails>()};
-    M::Value *resultRef{localSymbols.lookupSymbol(details.result())};
-    M::Value *r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
+    M::Value resultRef{localSymbols.lookupSymbol(details.result())};
+    M::Value r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
     builder->create<M::ReturnOp>(toLocation(), r);
   }
   template<typename A> void genFIRProcedureExit(const A *) {
@@ -287,18 +281,18 @@ class FirConverter : public AbstractConverter {
     auto targets{findTargetsOf(eval)};
     auto *expr{getEvaluationCondition(eval)};
     assert(expr && "condition expression missing");
-    auto *cond{createLogicalExprAsI1(toLocation(), expr)};
+    auto cond{createLogicalExprAsI1(toLocation(), expr)};
     genFIRCondBranch(cond, targets[0], targets[1]);
   }
 
   void genFIRCondBranch(
-      M::Value *cond, AST::Evaluation *trueDest, AST::Evaluation *falseDest) {
+      M::Value cond, AST::Evaluation *trueDest, AST::Evaluation *falseDest) {
     using namespace std::placeholders;
     localEdgeQ.emplace_back(std::bind(
-        [](M::OpBuilder *builder, M::Block *block, M::Value *cnd,
+        [](M::OpBuilder *builder, M::Block *block, M::Value cnd,
             AST::Evaluation *trueDest, AST::Evaluation *falseDest,
             M::Location location, const LabelMapType &map) {
-          L::SmallVector<M::Value *, 2> blk;
+          L::SmallVector<M::Value, 2> blk;
           builder->setInsertionPointToEnd(block);
           auto tdp{map.find(trueDest)};
           auto fdp{map.find(falseDest)};
@@ -354,13 +348,13 @@ class FirConverter : public AbstractConverter {
   }
   template<typename A>
   void genWhereCondition(fir::WhereOp &where, const A *stmt) {
-    auto *cond{createLogicalExprAsI1(
+    auto cond{createLogicalExprAsI1(
         toLocation(), Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(stmt->t)))};
     where = builder->create<fir::WhereOp>(toLocation(), cond, true);
     switchInsertionPointToWhere(where);
   }
 
-  M::Value *genFIRLoopIndex(const Pa::ScalarExpr &x) {
+  M::Value genFIRLoopIndex(const Pa::ScalarExpr &x) {
     return builder->create<fir::ConvertOp>(toLocation(),
         M::IndexType::get(&mlirContext), genExprValue(*Se::GetExpr(x)));
   }
@@ -387,9 +381,9 @@ class FirConverter : public AbstractConverter {
               Co::visitors{
                   [&](const Pa::LoopControl::Bounds &x) {
                     // create the fir.loop op
-                    M::Value *lo = genFIRLoopIndex(x.lower);
-                    M::Value *hi = genFIRLoopIndex(x.upper);
-                    L::SmallVector<M::Value *, 1> step;
+                    M::Value lo = genFIRLoopIndex(x.lower);
+                    M::Value hi = genFIRLoopIndex(x.upper);
+                    L::SmallVector<M::Value, 1> step;
                     if (x.step.has_value()) {
                       step.emplace_back(genExprValue(*Se::GetExpr(*x.step)));
                     }
@@ -410,8 +404,7 @@ class FirConverter : public AbstractConverter {
                   [&](const Pa::LoopControl::Concurrent &x) {
                     // FIXME: can project a multi-dimensional space
                     doLoop = builder->create<fir::LoopOp>(toLocation(),
-                        (M::Value *)nullptr, (M::Value *)nullptr,
-                        L::ArrayRef<M::Value *>{});
+                        M::Value{}, M::Value{}, L::ArrayRef<M::Value>{});
                     builder->setInsertionPointToStart(doLoop.getBody());
                   },
               },
@@ -515,11 +508,11 @@ class FirConverter : public AbstractConverter {
     // FIXME: mangle name
     M::FuncOp func{getFunc(funName, funTy)};
     (void)func;  // FIXME
-    std::vector<M::Value *> actuals;
+    std::vector<M::Value> actuals;
     for (auto &aa : std::get<std::list<Pa::ActualArgSpec>>(stmt.v.t)) {
       auto &kw = std::get<std::optional<Pa::Keyword>>(aa.t);
       auto &arg = std::get<Pa::ActualArg>(aa.t);
-      M::Value *fe{nullptr};
+      M::Value fe;
       std::visit(Co::visitors{
                      [&](const Co::Indirection<Pa::Expr> &e) {
                        // FIXME: needs to match argument, assumes trivial by-ref
@@ -546,14 +539,14 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::WhereStmt &) { TODO(); }
   void genFIR(const Pa::ComputedGotoStmt &stmt) {
     auto *exp{Se::GetExpr(std::get<Pa::ScalarIntExpr>(stmt.t))};
-    auto *e1{genExprValue(*exp)};
+    auto e1{genExprValue(*exp)};
     (void)e1;
     TODO();
   }
   void genFIR(const Pa::ForallStmt &) { TODO(); }
   void genFIR(const Pa::ArithmeticIfStmt &stmt) {
     auto *exp{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
-    auto *e1{genExprValue(*exp)};
+    auto e1{genExprValue(*exp)};
     (void)e1;
     TODO();
   }
@@ -684,8 +677,8 @@ class FirConverter : public AbstractConverter {
     // Helper to get address and length from an Expr that is a character
     // variable designator
     auto getAddrAndLength{[&](const SomeExpr &charDesignatorExpr)
-                              -> std::pair<mlir::Value *, mlir::Value *> {
-      auto *addr{genExprAddr(charDesignatorExpr)};
+                              -> std::pair<mlir::Value, mlir::Value> {
+      M::Value addr = genExprAddr(charDesignatorExpr);
       const auto &charExpr{
           std::get<Ev::Expr<Ev::SomeCharacter>>(charDesignatorExpr.u)};
       // FIXME LEN() should also succeed on character(*) and return a
@@ -693,7 +686,7 @@ class FirConverter : public AbstractConverter {
       // is rebased with master f18 that contains PR871.
       std::optional<Ev::Expr<Ev::SubscriptInteger>> lenExpr{charExpr.LEN()};
       assert(lenExpr && "could not get expression to compute character length");
-      auto *len{genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)))};
+      M::Value len = genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)));
       return {addr, len};
     }};
 
@@ -730,7 +723,7 @@ class FirConverter : public AbstractConverter {
         toLocation(), indexTy, builder->getIntegerAttr(indexTy, 0))};
     auto one{builder->create<M::ConstantOp>(
         toLocation(), indexTy, builder->getIntegerAttr(indexTy, 1))};
-    L::SmallVector<M::Value *, 1> step;
+    L::SmallVector<M::Value, 1> step;
     step.emplace_back(one);
     // Copy the minimum of the lhs and rhs lengths
     auto cmpLen{builder->create<M::CmpIOp>(toLocation(), M::CmpIPredicate::slt,
@@ -773,9 +766,8 @@ class FirConverter : public AbstractConverter {
 
   void genFIR(const Pa::AssignmentStmt &stmt) {
     assert(stmt.typedAssignment && "assignment analysis failed");
-    // Warning: v->u must become v.u after next f18 rebase
     if (const auto *assignment{std::get_if<Ev::Assignment::IntrinsicAssignment>(
-            &stmt.typedAssignment->v->u)}) {
+            &stmt.typedAssignment->v.u)}) {
       const Se::Symbol *sym{Ev::UnwrapWholeSymbolDataRef(assignment->lhs)};
       if (sym && Se::IsAllocatable(*sym)) {
         // Assignment of allocatable are more complex, the lhs
@@ -897,7 +889,7 @@ class FirConverter : public AbstractConverter {
   // call FAIL IMAGE in runtime
   void genFIR(const Pa::FailImageStmt &stmt) {
     auto callee{genRuntimeFunction(FIRT_FAIL_IMAGE, 0)};
-    L::SmallVector<M::Value *, 1> operands;  // FAIL IMAGE has no args
+    L::SmallVector<M::Value, 1> operands;  // FAIL IMAGE has no args
     builder->create<M::CallOp>(toLocation(), callee, operands);
   }
 
@@ -907,7 +899,7 @@ class FirConverter : public AbstractConverter {
         genRuntimeFunction(isStopStmt(stm) ? FIRT_STOP : FIRT_ERROR_STOP,
             defaults.GetDefaultKind(IntegerCat))};
     // 2 args: stop-code-opt, quiet-opt
-    L::SmallVector<M::Value *, 8> operands;
+    L::SmallVector<M::Value, 8> operands;
     builder->create<M::CallOp>(toLocation(), callee, operands);
   }
 
@@ -1124,7 +1116,7 @@ class FirConverter : public AbstractConverter {
 
   // TODO: should these be moved to convert-expr?
   template<M::CmpIPredicate ICMPOPC>
-  M::Value *genCompare(M::Value *lhs, M::Value *rhs) {
+  M::Value genCompare(M::Value lhs, M::Value rhs) {
     auto lty{lhs->getType()};
     assert(lty == rhs->getType());
     if (lty.isIntOrIndex()) {
@@ -1140,16 +1132,16 @@ class FirConverter : public AbstractConverter {
     M::emitError(toLocation(), "cannot generate operation on this type");
     return {};
   }
-  M::Value *genGE(M::Value *lhs, M::Value *rhs) {
+  M::Value genGE(M::Value lhs, M::Value rhs) {
     return genCompare<M::CmpIPredicate::sge>(lhs, rhs);
   }
-  M::Value *genLE(M::Value *lhs, M::Value *rhs) {
+  M::Value genLE(M::Value lhs, M::Value rhs) {
     return genCompare<M::CmpIPredicate::sle>(lhs, rhs);
   }
-  M::Value *genEQ(M::Value *lhs, M::Value *rhs) {
+  M::Value genEQ(M::Value lhs, M::Value rhs) {
     return genCompare<M::CmpIPredicate::eq>(lhs, rhs);
   }
-  M::Value *genAND(M::Value *lhs, M::Value *rhs) {
+  M::Value genAND(M::Value lhs, M::Value rhs) {
     return builder->create<M::AndOp>(lhs->getLoc(), lhs, rhs);
   }
 
@@ -1212,11 +1204,11 @@ class FirConverter : public AbstractConverter {
   //
   // AbstractConverter overrides
 
-  M::Value *genExprAddr(
+  M::Value genExprAddr(
       const SomeExpr &expr, M::Location *loc = nullptr) override final {
     return createFIRAddr(loc ? *loc : toLocation(), &expr);
   }
-  M::Value *genExprValue(
+  M::Value genExprValue(
       const SomeExpr &expr, M::Location *loc = nullptr) override final {
     return createFIRExpr(loc ? *loc : toLocation(), &expr);
   }
diff --git a/lib/burnside/bridge.h b/lib/burnside/bridge.h
index 16763f262525..50f58a119ab6 100644
--- a/lib/burnside/bridge.h
+++ b/lib/burnside/bridge.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/bridge.h -----------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_BURNSIDE_BRIDGE_H_
 #define FORTRAN_BURNSIDE_BRIDGE_H_
@@ -69,10 +63,10 @@ class AbstractConverter {
   // Expressions
 
   /// Generate the address of the location holding the expression
-  virtual mlir::Value *genExprAddr(
+  virtual mlir::Value genExprAddr(
       const SomeExpr &, mlir::Location *loc = nullptr) = 0;
   /// Generate the computations of the expression to produce a value
-  virtual mlir::Value *genExprValue(
+  virtual mlir::Value genExprValue(
       const SomeExpr &, mlir::Location *loc = nullptr) = 0;
 
   //
diff --git a/lib/burnside/builder.cc b/lib/burnside/builder.cc
index b523ffaf097b..60b1e5f97a96 100644
--- a/lib/burnside/builder.cc
+++ b/lib/burnside/builder.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/builder.cc ---------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "builder.h"
 #include "bridge.h"
@@ -44,20 +38,20 @@ M::FuncOp B::getNamedFunction(M::ModuleOp module, llvm::StringRef name) {
   return module.lookupSymbol<M::FuncOp>(name);
 }
 
-void B::SymMap::addSymbol(Se::SymbolRef symbol, M::Value *value) {
+void B::SymMap::addSymbol(Se::SymbolRef symbol, M::Value value) {
   symbolMap.try_emplace(&*symbol, value);
 }
 
-M::Value *B::SymMap::lookupSymbol(Se::SymbolRef symbol) {
+M::Value B::SymMap::lookupSymbol(Se::SymbolRef symbol) {
   auto iter{symbolMap.find(&*symbol)};
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
 
-void B::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value *value) {
+void B::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
   // find any existing mapping for symbol
   auto iter{symbolMap.find(&*symbol)};
   const Se::Symbol *sym{nullptr};
-  M::Value *val{nullptr};
+  M::Value val;
   // if mapping exists, save it on the shadow stack
   if (iter != symbolMap.end()) {
     sym = iter->first;
diff --git a/lib/burnside/builder.h b/lib/burnside/builder.h
index 8f663c59f5ee..39ae62b6c4eb 100644
--- a/lib/burnside/builder.h
+++ b/lib/burnside/builder.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/builder.h ----------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_BURNSIDE_BUILDER_H_
 #define FORTRAN_BURNSIDE_BUILDER_H_
@@ -44,15 +38,15 @@ namespace burnside {
 class AbstractConverter;
 
 class SymMap {
-  llvm::DenseMap<const semantics::Symbol *, mlir::Value *> symbolMap;
-  std::vector<std::pair<const semantics::Symbol *, mlir::Value *>> shadowStack;
+  llvm::DenseMap<const semantics::Symbol *, mlir::Value> symbolMap;
+  std::vector<std::pair<const semantics::Symbol *, mlir::Value>> shadowStack;
 
 public:
-  void addSymbol(semantics::SymbolRef symbol, mlir::Value *value);
+  void addSymbol(semantics::SymbolRef symbol, mlir::Value value);
 
-  mlir::Value *lookupSymbol(semantics::SymbolRef symbol);
+  mlir::Value lookupSymbol(semantics::SymbolRef symbol);
 
-  void pushShadowSymbol(semantics::SymbolRef symbol, mlir::Value *value);
+  void pushShadowSymbol(semantics::SymbolRef symbol, mlir::Value value);
   void popShadowSymbol() { shadowStack.pop_back(); }
 
   void clear() {
diff --git a/lib/burnside/complex-handler.h b/lib/burnside/complex-handler.h
index 4400e98a2b60..c16c192462d4 100644
--- a/lib/burnside/complex-handler.h
+++ b/lib/burnside/complex-handler.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/complex-handler.h --------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
 #define FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
@@ -31,14 +25,15 @@ class ComplexHandler {
   enum class Part { Real = 0, Imag = 1 };
 
   ComplexHandler(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
+
   mlir::Type getComplexPartType(fir::KindTy complexKind) {
     return convertReal(builder.getContext(), complexKind);
   }
 
-  mlir::Value *createComplex(
-      fir::KindTy kind, mlir::Value *real, mlir::Value *imag) {
+  mlir::Value createComplex(
+      fir::KindTy kind, mlir::Value real, mlir::Value imag) {
     mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
-    mlir::Value *und{builder.create<fir::UndefOp>(loc, complexTy)};
+    mlir::Value und = builder.create<fir::UndefOp>(loc, complexTy);
     return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
   }
 
@@ -46,59 +41,56 @@ class ComplexHandler {
   mlir::Type getComplexPartType(mlir::Type complexType) {
     return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
   }
-  mlir::Type getComplexPartType(mlir::Value *cplx) {
+  mlir::Type getComplexPartType(mlir::Value cplx) {
     assert(cplx != nullptr);
     return getComplexPartType(cplx->getType());
   }
 
-  template<Part partId> mlir::Value *extract(mlir::Value *cplx) {
+  template<Part partId> mlir::Value extract(mlir::Value cplx) {
     return builder.create<fir::ExtractValueOp>(
         loc, getComplexPartType(cplx), cplx, getPartId<partId>());
   }
-  template<Part partId>
-  mlir::Value *insert(mlir::Value *cplx, mlir::Value *part) {
+  template<Part partId> mlir::Value insert(mlir::Value cplx, mlir::Value part) {
     assert(cplx != nullptr);
     return builder.create<fir::InsertValueOp>(
         loc, cplx->getType(), cplx, part, getPartId<partId>());
   }
 
   /// Complex part access helper dynamic versions
-  mlir::Value *extractComplexPart(mlir::Value *cplx, bool isImagPart) {
+  mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart) {
     return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
   }
-  mlir::Value *insertComplexPart(
-      mlir::Value *cplx, mlir::Value *part, bool isImagPart) {
+  mlir::Value insertComplexPart(
+      mlir::Value cplx, mlir::Value part, bool isImagPart) {
     return isImagPart ? insert<Part::Imag>(cplx, part)
                       : insert<Part::Real>(cplx, part);
   }
 
   // Complex operation helpers
-  mlir::Value *createComplexCompare(
-      mlir::Value *cplx1, mlir::Value *cplx2, bool eq) {
-    mlir::Value *real1{extract<Part::Real>(cplx1)};
-    mlir::Value *real2{extract<Part::Real>(cplx2)};
-    mlir::Value *imag1{extract<Part::Imag>(cplx1)};
-    mlir::Value *imag2{extract<Part::Imag>(cplx2)};
-
-    mlir::CmpFPredicate predicate{
-        eq ? mlir::CmpFPredicate::UEQ : mlir::CmpFPredicate::UNE};
-    mlir::Value *realCmp{
-        builder.create<mlir::CmpFOp>(loc, predicate, real1, real2).getResult()};
-    mlir::Value *imagCmp{
-        builder.create<mlir::CmpFOp>(loc, predicate, imag1, imag2).getResult()};
-
-    if (eq) {
+  mlir::Value createComplexCompare(
+      mlir::Value cplx1, mlir::Value cplx2, bool eq) {
+    mlir::Value real1 = extract<Part::Real>(cplx1);
+    mlir::Value real2 = extract<Part::Real>(cplx2);
+    mlir::Value imag1 = extract<Part::Imag>(cplx1);
+    mlir::Value imag2 = extract<Part::Imag>(cplx2);
+
+    mlir::CmpFPredicate predicate =
+        eq ? mlir::CmpFPredicate::UEQ : mlir::CmpFPredicate::UNE;
+    mlir::Value realCmp =
+        builder.create<mlir::CmpFOp>(loc, predicate, real1, real2).getResult();
+    mlir::Value imagCmp =
+        builder.create<mlir::CmpFOp>(loc, predicate, imag1, imag2).getResult();
+
+    if (eq)
       return builder.create<mlir::AndOp>(loc, realCmp, imagCmp).getResult();
-    } else {
-      return builder.create<mlir::OrOp>(loc, realCmp, imagCmp).getResult();
-    }
+    return builder.create<mlir::OrOp>(loc, realCmp, imagCmp).getResult();
   }
 
 private:
   // Make mlir ConstantOp from template part id.
-  template<Part partId> inline mlir::Value *getPartId() {
-    auto type{mlir::IntegerType::get(32, builder.getContext())};
-    auto attr{builder.getIntegerAttr(type, static_cast<int>(partId))};
+  template<Part partId> inline mlir::Value getPartId() {
+    auto type = mlir::IntegerType::get(32, builder.getContext());
+    auto attr = builder.getIntegerAttr(type, static_cast<int>(partId));
     return builder.create<mlir::ConstantOp>(loc, type, attr).getResult();
   }
 
diff --git a/lib/burnside/convert-expr.cc b/lib/burnside/convert-expr.cc
index b458a286549c..1265cb2cb743 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/burnside/convert-expr.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/convert-expr.cc ----------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "convert-expr.h"
 #include "bridge.h"
@@ -114,7 +108,7 @@ class ExprLowering {
 
   /// Generate an integral constant of `value`
   template<int KIND>
-  M::Value *genIntegerConstant(M::MLIRContext *context, std::int64_t value) {
+  M::Value genIntegerConstant(M::MLIRContext *context, std::int64_t value) {
     M::Type type{converter.genType(IntegerCat, KIND)};
     auto attr{builder.getIntegerAttr(type, value)};
     auto res{builder.create<M::ConstantOp>(getLoc(), type, attr)};
@@ -122,14 +116,14 @@ class ExprLowering {
   }
 
   /// Generate a logical/boolean constant of `value`
-  M::Value *genLogicalConstantAsI1(M::MLIRContext *context, bool value) {
+  M::Value genLogicalConstantAsI1(M::MLIRContext *context, bool value) {
     M::Type i1Type{M::IntegerType::get(1, builder.getContext())};
     auto attr{builder.getIntegerAttr(i1Type, value ? 1 : 0)};
     return builder.create<M::ConstantOp>(getLoc(), i1Type, attr).getResult();
   }
 
   template<int KIND>
-  M::Value *genRealConstant(M::MLIRContext *context, L::APFloat const &value) {
+  M::Value genRealConstant(M::MLIRContext *context, L::APFloat const &value) {
     M::Type fltTy{convertReal(context, KIND)};
     auto attr{builder.getFloatAttr(fltTy, value)};
     auto res{builder.create<M::ConstantOp>(getLoc(), fltTy, attr)};
@@ -141,16 +135,16 @@ class ExprLowering {
   }
 
   template<typename OpTy, typename A>
-  M::Value *createBinaryOp(A const &ex, M::Value *lhs, M::Value *rhs) {
+  M::Value createBinaryOp(A const &ex, M::Value lhs, M::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), lhs, rhs);
     return x.getResult();
   }
   template<typename OpTy, typename A>
-  M::Value *createBinaryOp(A const &ex, M::Value *rhs) {
+  M::Value createBinaryOp(A const &ex, M::Value rhs) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), rhs);
   }
-  template<typename OpTy, typename A> M::Value *createBinaryOp(A const &ex) {
+  template<typename OpTy, typename A> M::Value createBinaryOp(A const &ex) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), genval(ex.right()));
   }
 
@@ -191,8 +185,8 @@ class ExprLowering {
 
   /// Create a call to a Fortran runtime entry point
   template<Co::TypeCategory TC, int KIND, typename A>
-  M::Value *createBinaryFIRTCall(A const &ex, RuntimeEntryCode callee) {
-    L::SmallVector<M::Value *, 2> operands;
+  M::Value createBinaryFIRTCall(A const &ex, RuntimeEntryCode callee) {
+    L::SmallVector<M::Value, 2> operands;
     operands.push_back(genval(ex.left()));
     operands.push_back(genval(ex.right()));
     M::FunctionType funTy = createFunctionType<TC, KIND>();
@@ -202,34 +196,34 @@ class ExprLowering {
   }
 
   template<typename OpTy, typename A>
-  M::Value *createCompareOp(
-      A const &ex, M::CmpIPredicate pred, M::Value *lhs, M::Value *rhs) {
+  M::Value createCompareOp(
+      A const &ex, M::CmpIPredicate pred, M::Value lhs, M::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
   template<typename OpTy, typename A>
-  M::Value *createCompareOp(A const &ex, M::CmpIPredicate pred) {
+  M::Value createCompareOp(A const &ex, M::CmpIPredicate pred) {
     return createCompareOp<OpTy>(
         ex, pred, genval(ex.left()), genval(ex.right()));
   }
   template<typename OpTy, typename A>
-  M::Value *createFltCmpOp(
-      A const &ex, fir::CmpFPredicate pred, M::Value *lhs, M::Value *rhs) {
+  M::Value createFltCmpOp(
+      A const &ex, fir::CmpFPredicate pred, M::Value lhs, M::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
   template<typename OpTy, typename A>
-  M::Value *createFltCmpOp(A const &ex, fir::CmpFPredicate pred) {
+  M::Value createFltCmpOp(A const &ex, fir::CmpFPredicate pred) {
     return createFltCmpOp<OpTy>(
         ex, pred, genval(ex.left()), genval(ex.right()));
   }
 
-  M::Value *gen(Se::SymbolRef sym) {
+  M::Value gen(Se::SymbolRef sym) {
     // FIXME: not all symbols are local
-    auto *addr{createTemporary(
-        getLoc(), builder, symMap, converter.genType(sym), &*sym)};
+    M::Value addr = createTemporary(
+        getLoc(), builder, symMap, converter.genType(sym), &*sym);
     assert(addr && "failed generating symbol address");
     // Get address from descriptor if symbol has one.
     auto type{addr->getType()};
@@ -243,24 +237,22 @@ class ExprLowering {
     }
     return addr;
   }
-  M::Value *gendef(Se::SymbolRef sym) { return gen(sym); }
+  M::Value gendef(Se::SymbolRef sym) { return gen(sym); }
 
-  M::Value *genval(Se::SymbolRef sym) {
+  M::Value genval(Se::SymbolRef sym) {
 #if 0
     // Do not load the same symbols several time in one expression.
     // Fortran guarantees variable value must be the same wherever it
     // appears in one expression.
-    if (mlir::Value * loaded{loadedSymbols.lookupSymbol(sym)}) {
+    if (mlir::Value loaded = loadedSymbols.lookupSymbol(sym)) 
       return loaded;
-    } else {
-      mlir::Value *load{builder.create<fir::LoadOp>(getLoc(), gen(sym))};
-      loadedSymbols.addSymbol(sym, load);
-      return load;
-    }
+    mlir::Value load = builder.create<fir::LoadOp>(getLoc(), gen(sym));
+    loadedSymbols.addSymbol(sym, load);
+    return load;
 #else
     // Multiple loads should be CSEd. If they aren't, it's a bug in CSE that
     // should not use a workaround here.
-    M::Value *var{gen(sym)};
+    auto var = gen(sym);
     if (fir::isReferenceLike(var->getType())) {
       return builder.create<fir::LoadOp>(getLoc(), var);
     }
@@ -268,24 +260,24 @@ class ExprLowering {
 #endif
   }
 
-  M::Value *genval(Ev::BOZLiteralConstant const &) { TODO(); }
-  M::Value *genval(Ev::ProcedureRef const &) { TODO(); }
-  M::Value *genval(Ev::ProcedureDesignator const &) { TODO(); }
-  M::Value *genval(Ev::NullPointer const &) { TODO(); }
-  M::Value *genval(Ev::StructureConstructor const &) { TODO(); }
-  M::Value *genval(Ev::ImpliedDoIndex const &) { TODO(); }
-  M::Value *genval(Ev::DescriptorInquiry const &) { TODO(); }
-  template<int KIND> M::Value *genval(Ev::TypeParamInquiry<KIND> const &) {
+  M::Value genval(Ev::BOZLiteralConstant const &) { TODO(); }
+  M::Value genval(Ev::ProcedureRef const &) { TODO(); }
+  M::Value genval(Ev::ProcedureDesignator const &) { TODO(); }
+  M::Value genval(Ev::NullPointer const &) { TODO(); }
+  M::Value genval(Ev::StructureConstructor const &) { TODO(); }
+  M::Value genval(Ev::ImpliedDoIndex const &) { TODO(); }
+  M::Value genval(Ev::DescriptorInquiry const &) { TODO(); }
+  template<int KIND> M::Value genval(Ev::TypeParamInquiry<KIND> const &) {
     TODO();
   }
 
-  template<int KIND> M::Value *genval(Ev::ComplexComponent<KIND> const &part) {
+  template<int KIND> M::Value genval(Ev::ComplexComponent<KIND> const &part) {
     return ComplexHandler{builder, getLoc()}.extractComplexPart(
         genval(part.left()), part.isImaginaryPart);
   }
 
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Negate<Ev::Type<TC, KIND>> const &op) {
+  M::Value genval(Ev::Negate<Ev::Type<TC, KIND>> const &op) {
     auto input{genval(op.left())};
     if constexpr (TC == IntegerCat) {
       // Currently no Standard/FIR op for integer negation.
@@ -300,7 +292,7 @@ class ExprLowering {
   }
 
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Add<Ev::Type<TC, KIND>> const &op) {
+  M::Value genval(Ev::Add<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::AddIOp>(op);
     } else if constexpr (TC == RealCat) {
@@ -311,7 +303,7 @@ class ExprLowering {
     }
   }
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Subtract<Ev::Type<TC, KIND>> const &op) {
+  M::Value genval(Ev::Subtract<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::SubIOp>(op);
     } else if constexpr (TC == RealCat) {
@@ -322,7 +314,7 @@ class ExprLowering {
     }
   }
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Multiply<Ev::Type<TC, KIND>> const &op) {
+  M::Value genval(Ev::Multiply<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::MulIOp>(op);
     } else if constexpr (TC == RealCat) {
@@ -333,9 +325,9 @@ class ExprLowering {
     }
   }
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Divide<Ev::Type<TC, KIND>> const &op) {
+  M::Value genval(Ev::Divide<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
-      return createBinaryOp<M::DivISOp>(op);
+      return createBinaryOp<M::SignedDivIOp>(op);
     } else if constexpr (TC == RealCat) {
       return createBinaryOp<fir::DivfOp>(op);
     } else {
@@ -344,34 +336,34 @@ class ExprLowering {
     }
   }
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Power<Ev::Type<TC, KIND>> const &op) {
-    llvm::SmallVector<mlir::Value *, 2> operands{
+  M::Value genval(Ev::Power<Ev::Type<TC, KIND>> const &op) {
+    llvm::SmallVector<mlir::Value, 2> operands{
         genval(op.left()), genval(op.right())};
     M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::RealToIntPower<Ev::Type<TC, KIND>> const &op) {
+  M::Value genval(Ev::RealToIntPower<Ev::Type<TC, KIND>> const &op) {
     // TODO: runtime as limited integer kind support. Look if the conversions
     // are ok
-    llvm::SmallVector<mlir::Value *, 2> operands{
+    llvm::SmallVector<mlir::Value, 2> operands{
         genval(op.left()), genval(op.right())};
     M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
 
-  template<int KIND> M::Value *genval(Ev::ComplexConstructor<KIND> const &op) {
+  template<int KIND> M::Value genval(Ev::ComplexConstructor<KIND> const &op) {
     return ComplexHandler{builder, getLoc()}.createComplex(
         KIND, genval(op.left()), genval(op.right()));
   }
-  template<int KIND> M::Value *genval(Ev::Concat<KIND> const &op) {
+  template<int KIND> M::Value genval(Ev::Concat<KIND> const &op) {
     // TODO this is a bogus call
     return createBinaryFIRTCall<CharacterCat, KIND>(op, FIRT_CONCAT);
   }
 
   /// MIN and MAX operations
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Extremum<Ev::Type<TC, KIND>> const &op) {
+  M::Value genval(Ev::Extremum<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryFIRTCall<TC, KIND>(
           op, op.ordering == Ev::Ordering::Greater ? FIRT_MAX : FIRT_MIN);
@@ -380,11 +372,11 @@ class ExprLowering {
     }
   }
 
-  template<int KIND> M::Value *genval(Ev::SetLength<KIND> const &) { TODO(); }
+  template<int KIND> M::Value genval(Ev::SetLength<KIND> const &) { TODO(); }
 
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Relational<Ev::Type<TC, KIND>> const &op) {
-    mlir::Value *result{nullptr};
+  M::Value genval(Ev::Relational<Ev::Type<TC, KIND>> const &op) {
+    mlir::Value result{nullptr};
     if constexpr (TC == IntegerCat) {
       result = createCompareOp<M::CmpIOp>(op, translateRelational(op.opr));
     } else if constexpr (TC == RealCat) {
@@ -404,14 +396,14 @@ class ExprLowering {
     return result;
   }
 
-  M::Value *genval(Ev::Relational<Ev::SomeType> const &op) {
+  M::Value genval(Ev::Relational<Ev::SomeType> const &op) {
     return std::visit([&](const auto &x) { return genval(x); }, op.u);
   }
 
   template<Co::TypeCategory TC1, int KIND, Co::TypeCategory TC2>
-  M::Value *genval(Ev::Convert<Ev::Type<TC1, KIND>, TC2> const &convert) {
+  M::Value genval(Ev::Convert<Ev::Type<TC1, KIND>, TC2> const &convert) {
     auto ty{converter.genType(TC1, KIND)};
-    M::Value *operand{genval(convert.left())};
+    M::Value operand{genval(convert.left())};
     if (TC1 == LogicalCat && genLogicalAsI1) {
       // If an i1 result is needed, it does not make sens to convert between
       // `fir.logical` types to later convert back to the result to i1.
@@ -420,9 +412,9 @@ class ExprLowering {
     return builder.create<fir::ConvertOp>(getLoc(), ty, operand);
   }
 
-  template<typename A> M::Value *genval(Ev::Parentheses<A> const &) { TODO(); }
+  template<typename A> M::Value genval(Ev::Parentheses<A> const &) { TODO(); }
 
-  template<int KIND> M::Value *genval(const Ev::Not<KIND> &op) {
+  template<int KIND> M::Value genval(const Ev::Not<KIND> &op) {
     // Request operands to be generated as `i1` and restore after this scope.
     auto restorer{common::ScopedSet(genLogicalAsI1, true)};
     auto *context{builder.getContext()};
@@ -431,10 +423,10 @@ class ExprLowering {
     return builder.create<M::XOrOp>(getLoc(), logical, one).getResult();
   }
 
-  template<int KIND> M::Value *genval(Ev::LogicalOperation<KIND> const &op) {
+  template<int KIND> M::Value genval(Ev::LogicalOperation<KIND> const &op) {
     // Request operands to be generated as `i1` and restore after this scope.
     auto restorer{common::ScopedSet(genLogicalAsI1, true)};
-    mlir::Value *result{nullptr};
+    mlir::Value result;
     switch (op.logicalOperator) {
     case Ev::LogicalOperator::And: result = createBinaryOp<M::AndOp>(op); break;
     case Ev::LogicalOperator::Or: result = createBinaryOp<M::OrOp>(op); break;
@@ -456,7 +448,7 @@ class ExprLowering {
   }
 
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(Ev::Constant<Ev::Type<TC, KIND>> const &con) {
+  M::Value genval(Ev::Constant<Ev::Type<TC, KIND>> const &con) {
     // TODO:
     // - character type constant
     // - array constant not handled
@@ -514,7 +506,7 @@ class ExprLowering {
   }
 
   template<Co::TypeCategory TC>
-  M::Value *genval(Ev::Constant<Ev::SomeKind<TC>> const &con) {
+  M::Value genval(Ev::Constant<Ev::SomeKind<TC>> const &con) {
     if constexpr (TC == IntegerCat) {
       auto opt = (*con).ToInt64();
       M::Type type{getSomeKindInteger()};
@@ -527,18 +519,18 @@ class ExprLowering {
     }
   }
 
-  template<typename A> M::Value *genval(Ev::ArrayConstructor<A> const &) {
+  template<typename A> M::Value genval(Ev::ArrayConstructor<A> const &) {
     TODO();
   }
-  M::Value *gen(Ev::ComplexPart const &) { TODO(); }
-  M::Value *gendef(Ev::ComplexPart const &cp) { return gen(cp); }
-  M::Value *genval(Ev::ComplexPart const &) { TODO(); }
-  M::Value *gen(const Ev::Substring &) { TODO(); }
-  M::Value *gendef(const Ev::Substring &ss) { return gen(ss); }
-  M::Value *genval(const Ev::Substring &) { TODO(); }
-  M::Value *genval(const Ev::Triplet &trip) { TODO(); }
+  M::Value gen(Ev::ComplexPart const &) { TODO(); }
+  M::Value gendef(Ev::ComplexPart const &cp) { return gen(cp); }
+  M::Value genval(Ev::ComplexPart const &) { TODO(); }
+  M::Value gen(const Ev::Substring &) { TODO(); }
+  M::Value gendef(const Ev::Substring &ss) { return gen(ss); }
+  M::Value genval(const Ev::Substring &) { TODO(); }
+  M::Value genval(const Ev::Triplet &trip) { TODO(); }
 
-  M::Value *genval(const Ev::Subscript &subs) {
+  M::Value genval(const Ev::Subscript &subs) {
     return std::visit(Co::visitors{
                           [&](const Ev::IndirectSubscriptIntegerExpr &x) {
                             return genval(x.value());
@@ -548,11 +540,11 @@ class ExprLowering {
         subs.u);
   }
 
-  M::Value *gen(const Ev::DataRef &dref) {
+  M::Value gen(const Ev::DataRef &dref) {
     return std::visit([&](const auto &x) { return gen(x); }, dref.u);
   }
-  M::Value *gendef(Ev::DataRef const &dref) { return gen(dref); }
-  M::Value *genval(Ev::DataRef const &dref) {
+  M::Value gendef(Ev::DataRef const &dref) { return gen(dref); }
+  M::Value genval(Ev::DataRef const &dref) {
     return std::visit([&](const auto &x) { return genval(x); }, dref.u);
   }
 
@@ -570,10 +562,10 @@ class ExprLowering {
   }
 
   // Return the coordinate of the component reference
-  M::Value *gen(const Ev::Component &cmpt) {
+  M::Value gen(const Ev::Component &cmpt) {
     std::list<const Ev::Component *> list;
     auto *base{reverseComponents(cmpt, list)};
-    L::SmallVector<M::Value *, 2> coorArgs;
+    L::SmallVector<M::Value, 2> coorArgs;
     auto obj{gen(*base)};
     const Se::Symbol *sym{nullptr};
     M::Type ty{converter.genType(*sym)};
@@ -588,8 +580,8 @@ class ExprLowering {
     ty = fir::ReferenceType::get(ty);
     return builder.create<fir::CoordinateOp>(getLoc(), ty, obj, coorArgs);
   }
-  M::Value *gendef(const Ev::Component &cmpt) { return gen(cmpt); }
-  M::Value *genval(const Ev::Component &cmpt) {
+  M::Value gendef(const Ev::Component &cmpt) { return gen(cmpt); }
+  M::Value genval(const Ev::Component &cmpt) {
     return builder.create<fir::LoadOp>(getLoc(), gen(cmpt));
   }
 
@@ -613,13 +605,10 @@ class ExprLowering {
   }
 
   // Return the coordinate of the array reference
-  M::Value *gen(Ev::ArrayRef const &aref) {
-    M::Value *base;
-    if (aref.base().IsSymbol())
-      base = gen(aref.base().GetFirstSymbol());
-    else
-      base = gen(aref.base().GetComponent());
-    llvm::SmallVector<M::Value *, 8> args;
+  M::Value gen(Ev::ArrayRef const &aref) {
+    M::Value base = aref.base().IsSymbol() ? gen(aref.base().GetFirstSymbol())
+                                           : gen(aref.base().GetComponent());
+    llvm::SmallVector<M::Value, 8> args;
     for (auto &subsc : aref.subscript()) {
       args.push_back(genval(subsc));
     }
@@ -627,48 +616,49 @@ class ExprLowering {
     ty = fir::ReferenceType::get(ty);
     return builder.create<fir::CoordinateOp>(getLoc(), ty, base, args);
   }
-  M::Value *gendef(const Ev::ArrayRef &aref) { return gen(aref); }
-  M::Value *genval(const Ev::ArrayRef &aref) {
+
+  M::Value gendef(const Ev::ArrayRef &aref) { return gen(aref); }
+  M::Value genval(const Ev::ArrayRef &aref) {
     return builder.create<fir::LoadOp>(getLoc(), gen(aref));
   }
 
   // Return a coordinate of the coarray reference. This is necessary as a
   // Component may have a CoarrayRef as its base coordinate.
-  M::Value *gen(Ev::CoarrayRef const &coref) {
+  M::Value gen(Ev::CoarrayRef const &coref) {
     // FIXME: need to visit the cosubscripts...
     // return gen(coref.base());
     TODO();
   }
-  M::Value *gendef(const Ev::CoarrayRef &coref) { return gen(coref); }
-  M::Value *genval(const Ev::CoarrayRef &coref) {
+  M::Value gendef(const Ev::CoarrayRef &coref) { return gen(coref); }
+  M::Value genval(const Ev::CoarrayRef &coref) {
     return builder.create<fir::LoadOp>(getLoc(), gen(coref));
   }
 
-  template<typename A> M::Value *gen(Ev::Designator<A> const &des) {
+  template<typename A> M::Value gen(Ev::Designator<A> const &des) {
     return std::visit([&](const auto &x) { return gen(x); }, des.u);
   }
-  template<typename A> M::Value *gendef(Ev::Designator<A> const &des) {
+  template<typename A> M::Value gendef(Ev::Designator<A> const &des) {
     return gen(des);
   }
-  template<typename A> M::Value *genval(Ev::Designator<A> const &des) {
+  template<typename A> M::Value genval(Ev::Designator<A> const &des) {
     return std::visit([&](const auto &x) { return genval(x); }, des.u);
   }
 
   // call a function
-  template<typename A> M::Value *gen(const Ev::FunctionRef<A> &funRef) {
+  template<typename A> M::Value gen(const Ev::FunctionRef<A> &funRef) {
     TODO();
   }
-  template<typename A> M::Value *gendef(const Ev::FunctionRef<A> &funRef) {
+  template<typename A> M::Value gendef(const Ev::FunctionRef<A> &funRef) {
     return gen(funRef);
   }
-  template<typename A> M::Value *genval(const Ev::FunctionRef<A> &funRef) {
+  template<typename A> M::Value genval(const Ev::FunctionRef<A> &funRef) {
     TODO();  // Derived type functions (user + intrinsics)
   }
   template<Co::TypeCategory TC, int KIND>
-  M::Value *genval(const Ev::FunctionRef<Ev::Type<TC, KIND>> &funRef) {
+  M::Value genval(const Ev::FunctionRef<Ev::Type<TC, KIND>> &funRef) {
     if (const auto &intrinsic{funRef.proc().GetSpecificIntrinsic()}) {
       M::Type ty{converter.genType(TC, KIND)};
-      L::SmallVector<M::Value *, 2> operands;
+      L::SmallVector<M::Value, 2> operands;
       // Lower arguments
       // For now, logical arguments for intrinsic are lowered to `fir.logical`
       // so that TRANSFER can work. For some arguments, it could lead to useless
@@ -690,7 +680,7 @@ class ExprLowering {
       // implicit interface implementation only
       // TODO: explicit interface
       L::SmallVector<M::Type, 2> argTypes;
-      L::SmallVector<M::Value *, 2> operands;
+      L::SmallVector<M::Value, 2> operands;
       // Logical arguments of user functions must be lowered to `fir.logical`
       // and not `i1`.
       auto restorer{common::ScopedSet(genLogicalAsI1, false)};
@@ -700,7 +690,7 @@ class ExprLowering {
         const auto *expr{arg->UnwrapExpr()};
         assert(expr && "assumed type argument requires explicit interface");
         if (const Se::Symbol * sym{Ev::UnwrapWholeSymbolDataRef(*expr)}) {
-          M::Value *argRef{symMap.lookupSymbol(*sym)};
+          M::Value argRef{symMap.lookupSymbol(*sym)};
           assert(argRef && "could not get symbol reference");
           argTypes.push_back(argRef->getType());
           operands.push_back(argRef);
@@ -722,20 +712,20 @@ class ExprLowering {
     }
   }
 
-  template<typename A> M::Value *gen(const Ev::Expr<A> &exp) {
+  template<typename A> M::Value gen(const Ev::Expr<A> &exp) {
     // must be a designator or function-reference (R902)
     return std::visit([&](const auto &e) { return gendef(e); }, exp.u);
   }
-  template<typename A> M::Value *gendef(Ev::Expr<A> const &exp) {
+  template<typename A> M::Value gendef(Ev::Expr<A> const &exp) {
     return gen(exp);
   }
-  template<typename A> M::Value *genval(Ev::Expr<A> const &exp) {
+  template<typename A> M::Value genval(Ev::Expr<A> const &exp) {
     return std::visit([&](const auto &e) { return genval(e); }, exp.u);
   }
 
   template<int KIND>
-  M::Value *genval(Ev::Expr<Ev::Type<LogicalCat, KIND>> const &exp) {
-    auto *result{std::visit([&](const auto &e) { return genval(e); }, exp.u)};
+  M::Value genval(Ev::Expr<Ev::Type<LogicalCat, KIND>> const &exp) {
+    auto result{std::visit([&](const auto &e) { return genval(e); }, exp.u)};
     // Handle the `i1` to `fir.logical` conversions as needed.
     if (result) {
       M::Type type{result->getType()};
@@ -761,20 +751,18 @@ class ExprLowering {
     return result;
   }
 
-  template<typename A> M::Value *gendef(const A &) {
+  template<typename A> M::Value gendef(const A &) {
     assert(false && "expression error");
     return {};
   }
 
   std::string applyNameMangling(const Ev::ProcedureDesignator &proc) {
-    if (const auto *symbol{proc.GetSymbol()}) {
+    if (const auto *symbol{proc.GetSymbol()})
       return converter.mangleName(*symbol);
-    } else {
-      // Do not mangle intrinsic for now
-      assert(proc.GetSpecificIntrinsic() &&
-          "expected intrinsic procedure in designator");
-      return proc.GetName();
-    }
+    // Do not mangle intrinsic for now
+    assert(proc.GetSpecificIntrinsic() &&
+        "expected intrinsic procedure in designator");
+    return proc.GetName();
   }
 
 public:
@@ -785,37 +773,37 @@ class ExprLowering {
       expr{vop}, symMap{map}, intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
 
   /// Lower the expression `expr` into MLIR standard dialect
-  M::Value *gen() { return gen(expr); }
-  M::Value *genval() { return genval(expr); }
+  M::Value gen() { return gen(expr); }
+  M::Value genval() { return genval(expr); }
 };
 
 }  // namespace
 
-M::Value *Br::createSomeExpression(M::Location loc,
-    Br::AbstractConverter &converter, Ev::Expr<Ev::SomeType> const &expr,
-    SymMap &symMap, IntrinsicLibrary const &intrinsics) {
+M::Value Br::createSomeExpression(M::Location loc,
+    Br::AbstractConverter &converter, const Ev::Expr<Ev::SomeType> &expr,
+    SymMap &symMap, const IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics, false}.genval();
 }
 
-M::Value *Br::createI1LogicalExpression(M::Location loc,
-    Br::AbstractConverter &converter, Ev::Expr<Ev::SomeType> const &expr,
-    SymMap &symMap, IntrinsicLibrary const &intrinsics) {
+M::Value Br::createI1LogicalExpression(M::Location loc,
+    Br::AbstractConverter &converter, const Ev::Expr<Ev::SomeType> &expr,
+    SymMap &symMap, const IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics, true}.genval();
 }
 
-M::Value *Br::createSomeAddress(M::Location loc,
-    Br::AbstractConverter &converter, Ev::Expr<Ev::SomeType> const &expr,
-    SymMap &symMap, IntrinsicLibrary const &intrinsics) {
+M::Value Br::createSomeAddress(M::Location loc,
+    Br::AbstractConverter &converter, const Ev::Expr<Ev::SomeType> &expr,
+    SymMap &symMap, const IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics}.gen();
 }
 
 /// Create a temporary variable
 /// `symbol` will be nullptr for an anonymous temporary
-M::Value *Br::createTemporary(M::Location loc, M::OpBuilder &builder,
-    SymMap &symMap, M::Type type, Se::Symbol const *symbol) {
+M::Value Br::createTemporary(M::Location loc, M::OpBuilder &builder,
+    SymMap &symMap, M::Type type, const Se::Symbol *symbol) {
   if (symbol)
-    if (auto *val{symMap.lookupSymbol(*symbol)}) {
-      if (auto *op{val->getDefiningOp()}) {
+    if (auto val = symMap.lookupSymbol(*symbol)) {
+      if (auto op = val->getDefiningOp()) {
         return op->getResult(0);
       }
       return val;
diff --git a/lib/burnside/convert-expr.h b/lib/burnside/convert-expr.h
index a05ab6efad08..66360ae6e146 100644
--- a/lib/burnside/convert-expr.h
+++ b/lib/burnside/convert-expr.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/convert-expr.h -----------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_BURNSIDE_CONVERT_EXPR_H_
 #define FORTRAN_BURNSIDE_CONVERT_EXPR_H_
@@ -34,10 +28,12 @@ namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
 }  //  common
+
 namespace evaluate {
 template<typename> class Expr;
 class SomeType;
 }  // evaluate
+
 namespace semantics {
 class Symbol;
 }  // semantics
@@ -47,21 +43,21 @@ namespace burnside {
 class AbstractConverter;
 class SymMap;
 
-mlir::Value *createSomeExpression(mlir::Location loc,
+mlir::Value createSomeExpression(mlir::Location loc,
     AbstractConverter &converter,
     const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
     const IntrinsicLibrary &intrinsics);
 
-mlir::Value *createI1LogicalExpression(mlir::Location loc,
+mlir::Value createI1LogicalExpression(mlir::Location loc,
     AbstractConverter &converter,
     const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
     const IntrinsicLibrary &intrinsics);
 
-mlir::Value *createSomeAddress(mlir::Location loc, AbstractConverter &converter,
+mlir::Value createSomeAddress(mlir::Location loc, AbstractConverter &converter,
     const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
     const IntrinsicLibrary &intrinsics);
 
-mlir::Value *createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
+mlir::Value createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
     SymMap &symMap, mlir::Type type, const semantics::Symbol *symbol);
 
 }  // burnside
diff --git a/lib/burnside/intrinsics.cc b/lib/burnside/intrinsics.cc
index e0d32015a76b..5d981160d4b2 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/burnside/intrinsics.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/intrinsics.cc ------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "intrinsics.h"
 #include "builder.h"
@@ -28,52 +22,55 @@
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
+namespace L = llvm;
+namespace M = mlir;
+
 namespace Fortran::burnside {
 
 /// MathRuntimeLibrary maps Fortran generic intrinsic names to runtime function
 /// signatures. There is no guarantee that that runtime functions are available
 /// for all intrinsic functions and possible types.
 /// To be easy and fast to use, this class holds a map and uses
-/// mlir::FunctionType to represent the runtime function type. This imply that
+/// M::FunctionType to represent the runtime function type. This imply that
 /// MathRuntimeLibrary cannot be constexpr built and requires an
-/// mlir::MLIRContext to be built. Its constructor uses a constexpr table
+/// M::MLIRContext to be built. Its constructor uses a constexpr table
 /// description of the runtime. The runtime functions are not declared into the
-/// mlir::module until there is a query that needs them. This is to avoid
+/// M::module until there is a query that needs them. This is to avoid
 /// polluting the FIR/LLVM IR dumps with unused functions.
 class MathRuntimeLibrary {
 public:
   /// The map key are Fortran generic intrinsic names.
-  using Key = llvm::StringRef;
+  using Key = L::StringRef;
   struct Hash {  // Need custom hash for this kind of key
-    size_t operator()(const Key &k) const { return llvm::hash_value(k); }
+    size_t operator()(const Key &k) const { return L::hash_value(k); }
   };
   /// Runtime function description that is sufficient to build an
-  /// mlir::FuncOp and to compare function types.
+  /// M::FuncOp and to compare function types.
   struct RuntimeFunction {
-    RuntimeFunction(llvm::StringRef n, mlir::FunctionType t)
-      : symbol{n}, type{t} {};
-    llvm::StringRef symbol;
-    mlir::FunctionType type;
+    RuntimeFunction(L::StringRef n, M::FunctionType t) : symbol{n}, type{t} {};
+    L::StringRef symbol;
+    M::FunctionType type;
   };
   using Map = std::unordered_multimap<Key, RuntimeFunction, Hash>;
 
-  MathRuntimeLibrary(IntrinsicLibrary::Version, mlir::MLIRContext &);
+  MathRuntimeLibrary(IntrinsicLibrary::Version, M::MLIRContext &);
 
   /// Probe the intrinsic library for a certain intrinsic and get/build the
-  /// related mlir::FuncOp if a runtime description is found.
+  /// related M::FuncOp if a runtime description is found.
   /// Also add a unit attribute "fir.runtime" to the function so that later
   /// it is possible to quickly know what function are intrinsics vs users.
-  llvm::Optional<mlir::FuncOp> getFunction(
-      mlir::OpBuilder &, llvm::StringRef, mlir::FunctionType) const;
+  L::Optional<M::FuncOp> getFunction(
+      M::OpBuilder &, L::StringRef, M::FunctionType) const;
 
 private:
-  mlir::FuncOp getFuncOp(
-      mlir::OpBuilder &builder, const RuntimeFunction &runtime) const;
+  M::FuncOp getFuncOp(
+      M::OpBuilder &builder, const RuntimeFunction &runtime) const;
   Map library;
 };
 
 /// Enums used to templatize and share lowering of MIN and MAX.
 enum class Extremum { Min, Max };
+
 // There are different ways to deal with NaNs in MIN and MAX.
 // Known existing behaviors are listed below and can be selected for
 // f18 MIN/MAX implementation.
@@ -132,25 +129,22 @@ enum class ExtremumBehavior {
 // TODO error handling -> return a code or directly emit messages ?
 class IntrinsicLibrary::Implementation {
 public:
-  Implementation(Version v, mlir::MLIRContext &c) : runtime{v, c} {}
-  inline mlir::Value *genval(mlir::Location loc, mlir::OpBuilder &builder,
-      llvm::StringRef name, mlir::Type resultType,
-      llvm::ArrayRef<mlir::Value *> args) const;
+  Implementation(Version v, M::MLIRContext &c) : runtime{v, c} {}
+  inline M::Value genval(M::Location loc, M::OpBuilder &builder,
+      L::StringRef name, M::Type resultType, L::ArrayRef<M::Value> args);
 
 private:
   // Info needed by Generators is passed in Context struct to keep Generator
   // signatures modification easy.
   struct Context {
-    mlir::Location loc;
-    mlir::OpBuilder *builder{nullptr};
-    llvm::StringRef name;
-    llvm::ArrayRef<mlir::Value *> arguments;
-    mlir::FunctionType funcType;
-    mlir::ModuleOp getModuleOp() { return getModule(builder); }
-    mlir::MLIRContext *getMLIRContext() {
-      return getModule(builder).getContext();
-    }
-    mlir::Type getResultType() {
+    M::Location loc;
+    M::OpBuilder *builder{nullptr};
+    L::StringRef name;
+    L::ArrayRef<M::Value> arguments;
+    M::FunctionType funcType;
+    M::ModuleOp getModuleOp() { return getModule(builder); }
+    M::MLIRContext *getMLIRContext() { return getModule(builder).getContext(); }
+    M::Type getResultType() {
       assert(funcType.getNumResults() == 1);
       return funcType.getResult(0);
     }
@@ -158,7 +152,8 @@ class IntrinsicLibrary::Implementation {
 
   /// Define the different FIR generators that can be mapped to intrinsic to
   /// generate the related code.
-  using Generator = mlir::Value *(Implementation::*)(Context &)const;
+  using Generator = M::Value (*)(Context &, MathRuntimeLibrary &);
+
   /// Search a runtime function that is associated to the generic intrinsic name
   /// and whose signature matches the intrinsic arguments and result types.
   /// If no such runtime function is found but a runtime function associated
@@ -166,23 +161,27 @@ class IntrinsicLibrary::Implementation {
   /// conversions will be inserted before and/or after the call. This is to
   /// mainly to allow 16 bits float support even-though little or no math
   /// runtime is currently available for it.
-  mlir::Value *genRuntimeCall(Context &) const;
+  static M::Value genRuntimeCall(Context &, MathRuntimeLibrary &);
+
   /// All generators can be combined with genWrapperCall that will build a
   /// function named "fir."+ <generic name> + "." + <result type code> and
   /// generate the intrinsic implementation inside instead of at the intrinsic
   /// call sites. This can be used to keep the FIR more readable.
-  template<Generator g> mlir::Value *genWrapperCall(Context &c) const {
-    return outlineInWrapper(g, c);
+  template<Generator g>
+  static M::Value genWrapperCall(Context &c, MathRuntimeLibrary &r) {
+    return outlineInWrapper(g, c, r);
   }
+
   /// The defaultGenerator is always attempted if no mapping was found for the
   /// generic name provided.
-  mlir::Value *defaultGenerator(Context &c) const {
-    return genWrapperCall<&I::genRuntimeCall>(c);
+  static M::Value defaultGenerator(Context &c, MathRuntimeLibrary &r) {
+    return genWrapperCall<&I::genRuntimeCall>(c, r);
   }
-  mlir::Value *genConjg(Context &) const;
+
+  static M::Value genConjg(Context &, MathRuntimeLibrary &);
   template<Extremum, ExtremumBehavior>
-  mlir::Value *genExtremum(Context &) const;
-  mlir::Value *genMerge(Context &) const;
+  static M::Value genExtremum(Context &, MathRuntimeLibrary &);
+  static M::Value genMerge(Context &, MathRuntimeLibrary &);
 
   struct IntrinsicHanlder {
     const char *name;
@@ -201,16 +200,17 @@ class IntrinsicLibrary::Implementation {
   };
 
   // helpers
-  mlir::Value *outlineInWrapper(Generator, Context &) const;
+  static M::Value outlineInWrapper(
+      Generator, Context &c, MathRuntimeLibrary &r);
 
   MathRuntimeLibrary runtime;
 };
 
 // helpers
 static std::string getIntrinsicWrapperName(
-    const llvm::StringRef &intrinsic, mlir::FunctionType funTy);
-static mlir::FunctionType getFunctionType(mlir::Type resultType,
-    llvm::ArrayRef<mlir::Value *> arguments, mlir::OpBuilder &);
+    const L::StringRef &intrinsic, M::FunctionType funTy);
+static M::FunctionType getFunctionType(
+    M::Type resultType, L::ArrayRef<M::Value> arguments, M::OpBuilder &);
 
 /// Define a simple static runtime description that will be transformed into
 /// RuntimeFunction when building the IntrinsicLibrary.
@@ -219,7 +219,7 @@ class MathsRuntimeStaticDescription : public RuntimeStaticDescription {
   constexpr MathsRuntimeStaticDescription(
       const char *n, const char *s, MaybeTypeCode r, TypeCodeVector a)
     : RuntimeStaticDescription{s, r, a}, name{n} {}
-  llvm::StringRef getName() const { return name; }
+  L::StringRef getName() const { return name; }
 
 private:
   // Generic math function name
@@ -275,7 +275,7 @@ static constexpr MathsRuntimeStaticDescription pgmathPreciseRuntime[] = {
 // IntrinsicLibrary implementation
 
 IntrinsicLibrary IntrinsicLibrary::create(
-    IntrinsicLibrary::Version v, mlir::MLIRContext &context) {
+    IntrinsicLibrary::Version v, M::MLIRContext &context) {
   IntrinsicLibrary lib{};
   lib.impl = new Implementation(v, context);
   return lib;
@@ -283,9 +283,8 @@ IntrinsicLibrary IntrinsicLibrary::create(
 
 IntrinsicLibrary::~IntrinsicLibrary() { delete impl; }
 
-mlir::Value *IntrinsicLibrary::genval(mlir::Location loc,
-    mlir::OpBuilder &builder, llvm::StringRef name, mlir::Type resultType,
-    llvm::ArrayRef<mlir::Value *> args) const {
+M::Value IntrinsicLibrary::genval(M::Location loc, M::OpBuilder &builder,
+    L::StringRef name, M::Type resultType, L::ArrayRef<M::Value> args) const {
   assert(impl);
   return impl->genval(loc, builder, name, resultType, args);
 }
@@ -295,7 +294,7 @@ mlir::Value *IntrinsicLibrary::genval(mlir::Location loc,
 // Create the runtime description for the targeted library version.
 // So far ignore the version an only load the dummy llvm lib and pgmath precise
 MathRuntimeLibrary::MathRuntimeLibrary(
-    IntrinsicLibrary::Version, mlir::MLIRContext &mlirContext) {
+    IntrinsicLibrary::Version, M::MLIRContext &mlirContext) {
   for (const MathsRuntimeStaticDescription &func : llvmRuntime) {
     RuntimeFunction impl{
         func.getSymbol(), func.getMLIRFunctionType(&mlirContext)};
@@ -308,10 +307,10 @@ MathRuntimeLibrary::MathRuntimeLibrary(
   }
 }
 
-mlir::FuncOp MathRuntimeLibrary::getFuncOp(
-    mlir::OpBuilder &builder, const RuntimeFunction &runtime) const {
+M::FuncOp MathRuntimeLibrary::getFuncOp(
+    M::OpBuilder &builder, const RuntimeFunction &runtime) const {
   auto module{getModule(&builder)};
-  mlir::FuncOp function{getNamedFunction(module, runtime.symbol)};
+  M::FuncOp function{getNamedFunction(module, runtime.symbol)};
   if (!function) {
     function = createFunction(module, runtime.symbol, runtime.type);
     function.setAttr("fir.runtime", builder.getUnitAttr());
@@ -332,7 +331,7 @@ mlir::FuncOp MathRuntimeLibrary::getFuncOp(
 class FunctionDistance {
 public:
   FunctionDistance() : infinite{true} {}
-  FunctionDistance(mlir::FunctionType from, mlir::FunctionType to) {
+  FunctionDistance(M::FunctionType from, M::FunctionType to) {
     auto nInputs{from.getNumInputs()};
     auto nResults{from.getNumResults()};
     if (nResults != to.getNumResults() || nInputs != to.getNumInputs()) {
@@ -360,7 +359,7 @@ class FunctionDistance {
 private:
   enum class Conversion { Forbidden, None, Narrow, Extend };
 
-  void addArgumentDistance(mlir::Type from, mlir::Type to) {
+  void addArgumentDistance(M::Type from, M::Type to) {
     switch (conversionBetweenTypes(from, to)) {
     case Conversion::Forbidden: infinite = true; break;
     case Conversion::None: break;
@@ -368,7 +367,7 @@ class FunctionDistance {
     case Conversion::Extend: conversions[nonNarrowingArg]++; break;
     }
   }
-  void addResultDistance(mlir::Type from, mlir::Type to) {
+  void addResultDistance(M::Type from, M::Type to) {
     switch (conversionBetweenTypes(from, to)) {
     case Conversion::Forbidden: infinite = true; break;
     case Conversion::None: break;
@@ -376,26 +375,26 @@ class FunctionDistance {
     case Conversion::Extend: conversions[extendingResult]++; break;
     }
   }
-  // Floating point can be mlir::FloatType or fir::real
-  static unsigned getFloatingPointWidth(mlir::Type t) {
-    if (auto f{t.dyn_cast<mlir::FloatType>()}) return f.getWidth();
+  // Floating point can be M::FloatType or fir::real
+  static unsigned getFloatingPointWidth(M::Type t) {
+    if (auto f{t.dyn_cast<M::FloatType>()}) return f.getWidth();
     // FIXME: Get width another way for fir.real/complex
-    // - use fir/KindMapping.h and LLVM::Type
+    // - use fir/KindMapping.h and L::Type
     // - or use evaluate/type.h
     if (auto r{t.dyn_cast<fir::RealType>()}) return r.getFKind() * 4;
     if (auto cplx{t.dyn_cast<fir::CplxType>()}) return cplx.getFKind() * 4;
     assert(false && "not a floating-point type");
     return 0;
   }
-  static bool isFloatingPointType(mlir::Type t) {
-    return t.isa<mlir::FloatType>() || t.isa<fir::RealType>();
+  static bool isFloatingPointType(M::Type t) {
+    return t.isa<M::FloatType>() || t.isa<fir::RealType>();
   }
-  static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
+  static Conversion conversionBetweenTypes(M::Type from, M::Type to) {
     if (from == to) {
       return Conversion::None;
     }
-    if (auto fromIntTy{from.dyn_cast<mlir::IntegerType>()}) {
-      if (auto toIntTy{to.dyn_cast<mlir::IntegerType>()}) {
+    if (auto fromIntTy{from.dyn_cast<M::IntegerType>()}) {
+      if (auto toIntTy{to.dyn_cast<M::IntegerType>()}) {
         return fromIntTy.getWidth() > toIntTy.getWidth() ? Conversion::Narrow
                                                          : Conversion::Extend;
       }
@@ -438,9 +437,8 @@ class FunctionDistance {
 // Select runtime function that has the smallest distance to the intrinsic
 // function type and that will not imply narrowing arguments or extending the
 // result.
-llvm::Optional<mlir::FuncOp> MathRuntimeLibrary::getFunction(
-    mlir::OpBuilder &builder, llvm::StringRef name,
-    mlir::FunctionType funcType) const {
+L::Optional<M::FuncOp> MathRuntimeLibrary::getFunction(
+    M::OpBuilder &builder, L::StringRef name, M::FunctionType funcType) const {
   auto range{library.equal_range(name)};
   const RuntimeFunction *bestNearMatch{nullptr};
   FunctionDistance bestMatchDistance{};
@@ -460,62 +458,65 @@ llvm::Optional<mlir::FuncOp> MathRuntimeLibrary::getFunction(
     assert(!bestMatchDistance.isLoosingPrecision() &&
         "runtime selection looses precision");
     return getFuncOp(builder, *bestNearMatch);
-  } else {
-    return {};
   }
+  return {};
 }
 
 // IntrinsicLibrary::Implementation implementation
 
-mlir::Value *IntrinsicLibrary::Implementation::genval(mlir::Location loc,
-    mlir::OpBuilder &builder, llvm::StringRef name, mlir::Type resultType,
-    llvm::ArrayRef<mlir::Value *> args) const {
+M::Value IntrinsicLibrary::Implementation::genval(M::Location loc,
+    M::OpBuilder &builder, L::StringRef name, M::Type resultType,
+    L::ArrayRef<M::Value> args) {
   Context context{
       loc, &builder, name, args, getFunctionType(resultType, args, builder)};
-  for (const IntrinsicHanlder &handler : handlers) {
+  for (auto &handler : handlers) {
     if (name == handler.name) {
       assert(handler.generator != nullptr);
-      return (this->*handler.generator)(context);
+      return handler.generator(context, runtime);
     }
   }
   // Try the default generator if no special handler was defined for the
   // intrinsic being called.
-  return this->defaultGenerator(context);
+  return defaultGenerator(context, runtime);
 }
 
-static mlir::FunctionType getFunctionType(mlir::Type resultType,
-    llvm::ArrayRef<mlir::Value *> arguments, mlir::OpBuilder &builder) {
-  llvm::SmallVector<mlir::Type, 2> argumentTypes;
-  for (const auto &arg : arguments) {
+static M::FunctionType getFunctionType(M::Type resultType,
+    L::ArrayRef<M::Value> arguments, M::OpBuilder &builder) {
+  L::SmallVector<M::Type, 2> argumentTypes;
+  for (auto &arg : arguments) {
     assert(arg != nullptr);  // TODO think about optionals
     argumentTypes.push_back(arg->getType());
   }
-  return mlir::FunctionType::get(
+  return M::FunctionType::get(
       argumentTypes, resultType, getModule(&builder).getContext());
 }
 
 // TODO find nicer type to string infra or move this in a mangling utility
 // mlir as Type::dump(ostream) methods but it may adds !
-static std::string typeToString(mlir::Type t) {
-  if (auto i{t.dyn_cast<mlir::IntegerType>()}) {
+static std::string typeToString(M::Type t) {
+  if (auto i{t.dyn_cast<M::IntegerType>()}) {
     return "i" + std::to_string(i.getWidth());
-  } else if (auto cplx{t.dyn_cast<fir::CplxType>()}) {
+  }
+  if (auto cplx{t.dyn_cast<fir::CplxType>()}) {
     return "z" + std::to_string(cplx.getFKind());
-  } else if (auto real{t.dyn_cast<fir::RealType>()}) {
+  }
+  if (auto real{t.dyn_cast<fir::RealType>()}) {
     return "r" + std::to_string(real.getFKind());
-  } else if (auto f{t.dyn_cast<mlir::FloatType>()}) {
+  }
+  if (auto f{t.dyn_cast<M::FloatType>()}) {
     return "f" + std::to_string(f.getWidth());
-  } else if (auto logical{t.dyn_cast<fir::LogicalType>()}) {
+  }
+  if (auto logical{t.dyn_cast<fir::LogicalType>()}) {
     return "l" + std::to_string(logical.getFKind());
-  } else if (auto character{t.dyn_cast<fir::CharacterType>()}) {
+  }
+  if (auto character{t.dyn_cast<fir::CharacterType>()}) {
     return "c" + std::to_string(character.getFKind());
-  } else {
-    assert(false && "no mangling for type");
-    return ""s;
   }
+  assert(false && "no mangling for type");
+  return ""s;
 }
 static std::string getIntrinsicWrapperName(
-    const llvm::StringRef &intrinsic, mlir::FunctionType funTy) {
+    const L::StringRef &intrinsic, M::FunctionType funTy) {
   std::string name{"fir." + intrinsic.str() + "."};
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
   name += typeToString(funTy.getResult(0));
@@ -525,13 +526,13 @@ static std::string getIntrinsicWrapperName(
   return name;
 }
 
-mlir::Value *IntrinsicLibrary::Implementation::outlineInWrapper(
-    Generator generator, Context &context) const {
-  mlir::ModuleOp module{getModule(context.builder)};
-  mlir::MLIRContext *mlirContext{module.getContext()};
+M::Value IntrinsicLibrary::Implementation::outlineInWrapper(
+    Generator generator, Context &context, MathRuntimeLibrary &runtime) {
+  M::ModuleOp module{getModule(context.builder)};
+  M::MLIRContext *mlirContext{module.getContext()};
   std::string wrapperName{
       getIntrinsicWrapperName(context.name, context.funcType)};
-  mlir::FuncOp function{getNamedFunction(module, wrapperName)};
+  M::FuncOp function{getNamedFunction(module, wrapperName)};
   if (!function) {
     // First time this wrapper is needed, build it.
     function = createFunction(module, wrapperName, context.funcType);
@@ -542,34 +543,34 @@ mlir::Value *IntrinsicLibrary::Implementation::outlineInWrapper(
     // This new function is not linked to a source file location, only
     // its calls will be.
     Context localContext{context};
-    auto localBuilder{std::make_unique<mlir::OpBuilder>(function)};
+    auto localBuilder{std::make_unique<M::OpBuilder>(function)};
     localBuilder->setInsertionPointToStart(&function.front());
     localContext.builder = &(*localBuilder);
-    llvm::SmallVector<mlir::Value *, 2> localArguments;
-    for (mlir::BlockArgument *bArg : function.front().getArguments()) {
+    L::SmallVector<M::Value, 2> localArguments;
+    for (M::BlockArgument bArg : function.front().getArguments()) {
       localArguments.push_back(bArg);
     }
     localContext.arguments = localArguments;
-    localContext.loc = mlir::UnknownLoc::get(mlirContext);
+    localContext.loc = M::UnknownLoc::get(mlirContext);
 
-    mlir::Value *result{(this->*generator)(localContext)};
-    localBuilder->create<mlir::ReturnOp>(localContext.loc, result);
+    M::Value result = generator(localContext, runtime);
+    localBuilder->create<M::ReturnOp>(localContext.loc, result);
   } else {
     // Wrapper was already built, ensure it has the sought type
     assert(function.getType() == context.funcType);
   }
-  auto call{context.builder->create<mlir::CallOp>(
+  auto call{context.builder->create<M::CallOp>(
       context.loc, function, context.arguments)};
   return call.getResult(0);
 }
 
-mlir::Value *IntrinsicLibrary::Implementation::genRuntimeCall(
-    Context &context) const {
+M::Value IntrinsicLibrary::Implementation::genRuntimeCall(
+    Context &context, MathRuntimeLibrary &runtime) {
   // Look up runtime
-  mlir::FunctionType soughtFuncType{context.funcType};
+  M::FunctionType soughtFuncType{context.funcType};
   if (auto funcOp{runtime.getFunction(
           *context.builder, context.name, soughtFuncType)}) {
-    mlir::FunctionType actualFuncType{funcOp->getType()};
+    M::FunctionType actualFuncType{funcOp->getType()};
     if (actualFuncType.getNumResults() != soughtFuncType.getNumResults() ||
         actualFuncType.getNumInputs() != soughtFuncType.getNumInputs() ||
         actualFuncType.getNumInputs() != context.arguments.size() ||
@@ -577,10 +578,10 @@ mlir::Value *IntrinsicLibrary::Implementation::genRuntimeCall(
       assert(false);  // TODO better error handling
       return nullptr;
     }
-    llvm::SmallVector<mlir::Value *, 2> convertedArguments;
+    L::SmallVector<M::Value, 2> convertedArguments;
     int i{0};
-    for (mlir::Value *arg : context.arguments) {
-      mlir::Type actualType{actualFuncType.getInput(i)};
+    for (M::Value arg : context.arguments) {
+      M::Type actualType{actualFuncType.getInput(i)};
       if (soughtFuncType.getInput(i) != actualType) {
         auto castedArg{context.builder->create<fir::ConvertOp>(
             context.loc, actualType, arg)};
@@ -590,10 +591,10 @@ mlir::Value *IntrinsicLibrary::Implementation::genRuntimeCall(
       }
       ++i;
     }
-    auto call{context.builder->create<mlir::CallOp>(
+    auto call{context.builder->create<M::CallOp>(
         context.loc, *funcOp, convertedArguments)};
-    mlir::Type soughtType{soughtFuncType.getResult(0)};
-    mlir::Value *res{call.getResult(0)};
+    M::Type soughtType{soughtFuncType.getResult(0)};
+    M::Value res = call.getResult(0);
     if (actualFuncType.getResult(0) != soughtType) {
       auto castedRes{context.builder->create<fir::ConvertOp>(
           context.loc, soughtType, res)};
@@ -611,48 +612,48 @@ mlir::Value *IntrinsicLibrary::Implementation::genRuntimeCall(
 }
 
 // CONJG
-mlir::Value *IntrinsicLibrary::Implementation::genConjg(
-    Context &genCtxt) const {
+M::Value IntrinsicLibrary::Implementation::genConjg(
+    Context &genCtxt, MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 1);
-  mlir::Type resType{genCtxt.getResultType()};
+  M::Type resType{genCtxt.getResultType()};
   assert(resType == genCtxt.arguments[0]->getType());
-  mlir::OpBuilder &builder{*genCtxt.builder};
+  M::OpBuilder &builder{*genCtxt.builder};
   ComplexHandler cplxHandler{builder, genCtxt.loc};
 
-  mlir::Value *cplx{genCtxt.arguments[0]};
-  mlir::Value *imag{cplxHandler.extract<ComplexHandler::Part::Imag>(cplx)};
-  mlir::Value *negImag{genCtxt.builder->create<fir::NegfOp>(genCtxt.loc, imag)};
+  M::Value cplx = genCtxt.arguments[0];
+  M::Value imag = cplxHandler.extract<ComplexHandler::Part::Imag>(cplx);
+  M::Value negImag = genCtxt.builder->create<fir::NegfOp>(genCtxt.loc, imag);
   return cplxHandler.insert<ComplexHandler::Part::Imag>(cplx, negImag);
 }
 
 // MERGE
-mlir::Value *IntrinsicLibrary::Implementation::genMerge(
-    Context &genCtxt) const {
+M::Value IntrinsicLibrary::Implementation::genMerge(
+    Context &genCtxt, MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 3);
-  mlir::Type resType{genCtxt.getResultType()};
-  mlir::OpBuilder &builder{*genCtxt.builder};
-
-  auto *trueVal{genCtxt.arguments[0]};
-  auto *falseVal{genCtxt.arguments[1]};
-  auto *mask{genCtxt.arguments[2]};
-  mlir::Type i1Type{mlir::IntegerType::get(1, builder.getContext())};
-  mask = builder.create<fir::ConvertOp>(genCtxt.loc, i1Type, mask);
-  return builder.create<mlir::SelectOp>(genCtxt.loc, mask, trueVal, falseVal);
+  M::Type resType{genCtxt.getResultType()};
+  M::OpBuilder &builder{*genCtxt.builder};
+
+  auto &trueVal = genCtxt.arguments[0];
+  auto &falseVal = genCtxt.arguments[1];
+  auto &mask = genCtxt.arguments[2];
+  M::Type i1Type{M::IntegerType::get(1, builder.getContext())};
+  auto msk = builder.create<fir::ConvertOp>(genCtxt.loc, i1Type, mask);
+  return builder.create<M::SelectOp>(genCtxt.loc, msk, trueVal, falseVal);
 }
 
 // Compare two FIR values and return boolean result as i1.
 template<Extremum extremum, ExtremumBehavior behavior>
-static mlir::Value *createExtremumCompare(mlir::Location loc,
-    mlir::OpBuilder &builder, mlir::Value *left, mlir::Value *right) {
+static M::Value createExtremumCompare(
+    M::Location loc, M::OpBuilder &builder, M::Value left, M::Value right) {
   static constexpr auto integerPredicate{extremum == Extremum::Max
-          ? mlir::CmpIPredicate::sgt
-          : mlir::CmpIPredicate::slt};
+          ? M::CmpIPredicate::sgt
+          : M::CmpIPredicate::slt};
   static constexpr auto orderedCmp{extremum == Extremum::Max
           ? fir::CmpFPredicate::OGT
           : fir::CmpFPredicate::OLT};
   auto type{left->getType()};
-  mlir::Value *result{nullptr};
-  if (type.isa<mlir::FloatType>() || type.isa<fir::RealType>()) {
+  M::Value result;
+  if (type.isa<M::FloatType>() || type.isa<fir::RealType>()) {
     // Note: the signaling/quit aspect of the result required by IEEE
     // cannot currently be obtained with LLVM without ad-hoc runtime.
     if constexpr (behavior == ExtremumBehavior::IeeeMinMaximumNumber) {
@@ -662,14 +663,14 @@ static mlir::Value *createExtremumCompare(mlir::Location loc,
           builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
       auto rightIsNan{builder.create<fir::CmpfOp>(
           loc, fir::CmpFPredicate::UNE, right, right)};
-      result = builder.create<mlir::OrOp>(loc, leftIsResult, rightIsNan);
+      result = builder.create<M::OrOp>(loc, leftIsResult, rightIsNan);
     } else if constexpr (behavior == ExtremumBehavior::IeeeMinMaximum) {
       // Always return NaNs if one the input is NaNs
       auto leftIsResult{
           builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
       auto leftIsNan{builder.create<fir::CmpfOp>(
           loc, fir::CmpFPredicate::UNE, left, left)};
-      result = builder.create<mlir::OrOp>(loc, leftIsResult, leftIsNan);
+      result = builder.create<M::OrOp>(loc, leftIsResult, leftIsNan);
     } else if constexpr (behavior == ExtremumBehavior::MinMaxss) {
       // If the left is a NaN, return the right whatever it is.
       result = builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
@@ -684,8 +685,8 @@ static mlir::Value *createExtremumCompare(mlir::Location loc,
       static_assert(behavior == ExtremumBehavior::IeeeMinMaxNum,
           "ieeeMinNum/ieeMaxNum behavior not implemented");
     }
-  } else if (type.isa<mlir::IntegerType>()) {
-    result = builder.create<mlir::CmpIOp>(loc, integerPredicate, left, right);
+  } else if (type.isa<M::IntegerType>()) {
+    result = builder.create<M::CmpIOp>(loc, integerPredicate, left, right);
   } else if (type.isa<fir::CharacterType>()) {
     // TODO: ! character min and max is tricky because the result
     // length is the length of the longest argument!
@@ -697,16 +698,16 @@ static mlir::Value *createExtremumCompare(mlir::Location loc,
 
 // MIN and MAX
 template<Extremum extremum, ExtremumBehavior behavior>
-mlir::Value *IntrinsicLibrary::Implementation::genExtremum(
-    Context &genCtxt) const {
+M::Value IntrinsicLibrary::Implementation::genExtremum(
+    Context &genCtxt, MathRuntimeLibrary &) {
   auto &builder{*genCtxt.builder};
   auto loc{genCtxt.loc};
   assert(genCtxt.arguments.size() >= 2);
-  auto *result{genCtxt.arguments[0]};
-  for (auto *arg : genCtxt.arguments.drop_front()) {
+  M::Value result = genCtxt.arguments[0];
+  for (auto arg : genCtxt.arguments.drop_front()) {
     auto mask{
         createExtremumCompare<extremum, behavior>(loc, builder, result, arg)};
-    result = builder.create<mlir::SelectOp>(loc, mask, result, arg);
+    result = builder.create<M::SelectOp>(loc, mask, result, arg);
   }
   return result;
 }
diff --git a/lib/burnside/intrinsics.h b/lib/burnside/intrinsics.h
index d2534b71d1e3..ae72852602dc 100644
--- a/lib/burnside/intrinsics.h
+++ b/lib/burnside/intrinsics.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/intrinsics.h -------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_BURNSIDE_INTRINSICS_H_
 #define FORTRAN_BURNSIDE_INTRINSICS_H_
@@ -28,7 +22,7 @@ namespace Fortran::burnside {
 /// that it can be used at different lowering level if needed.
 /// IntrinsicLibrary is not in charge of generating code for the argument
 /// expressions/symbols. These must be generated before and the resulting
-/// mlir::Values* are inputs for the IntrinsicLibrary operation generation.
+/// mlir::Values are inputs for the IntrinsicLibrary operation generation.
 ///
 /// The operations generated can be as simple as a single runtime library call
 /// or they may fully implement the intrinsic without runtime help. This
@@ -46,17 +40,17 @@ class IntrinsicLibrary {
 
   ~IntrinsicLibrary();
   /// Generate the FIR+MLIR operations for the generic intrinsic "name".
-  /// On failure, returns a nullptr, else the returned mlir::Value* is
+  /// On failure, returns a nullptr, else the returned mlir::Value is
   /// the returned Fortran intrinsic value.
-  mlir::Value *genval(mlir::Location loc, mlir::OpBuilder &builder,
+  mlir::Value genval(mlir::Location loc, mlir::OpBuilder &builder,
       llvm::StringRef name, mlir::Type resultType,
-      llvm::ArrayRef<mlir::Value *> args) const;
+      llvm::ArrayRef<mlir::Value> args) const;
 
   // TODO: Expose interface to get specific intrinsic function address.
   // TODO: Handle intrinsic subroutine.
   // TODO: Intrinsics that do not require their arguments to be defined
   //   (e.g shape inquiries) might not fit in the current interface that
-  //   requires mlir::Value* to be provided.
+  //   requires mlir::Value to be provided.
   // TODO: Error handling interface ?
   // TODO: Implementation is incomplete. Many intrinsics to tbd.
 
diff --git a/lib/burnside/io.cc b/lib/burnside/io.cc
index 3d4a847bf06d..392b06dbec93 100644
--- a/lib/burnside/io.cc
+++ b/lib/burnside/io.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/io.cc --------------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "io.h"
 #include "bridge.h"
@@ -118,22 +112,22 @@ void lowerPrintStatement(
 
   // Initiate io
   M::Type externalUnitType{M::IntegerType::get(32, mlirContext)};
-  M::Value *defaultUnit{builder.create<M::ConstantOp>(
+  M::Value defaultUnit{builder.create<M::ConstantOp>(
       loc, builder.getIntegerAttr(externalUnitType, 1))};
-  llvm::SmallVector<M::Value *, 1> beginArgs{defaultUnit};
-  M::Value *cookie{
+  llvm::SmallVector<M::Value, 1> beginArgs{defaultUnit};
+  M::Value cookie{
       builder.create<M::CallOp>(loc, beginFunc, beginArgs).getResult(0)};
 
   // Call data transfer runtime function
-  for (M::Value *arg : args) {
-    llvm::SmallVector<M::Value *, 1> operands{cookie, arg};
+  for (M::Value arg : args) {
+    llvm::SmallVector<M::Value, 1> operands{cookie, arg};
     M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg->getType())};
     builder.create<M::CallOp>(loc, outputFunc, operands);
   }
 
   // Terminate IO
   M::FuncOp endIOFunc{getIORuntimeFunction<IOAction::EndIO>(builder)};
-  llvm::SmallVector<M::Value *, 1> endArgs{cookie};
+  llvm::SmallVector<M::Value, 1> endArgs{cookie};
   builder.create<M::CallOp>(loc, endIOFunc, endArgs);
 }
 
@@ -165,7 +159,7 @@ void Br::genOpenStatement(AbstractConverter &, const Pa::OpenStmt &) {
 
 void Br::genPrintStatement(
     Br::AbstractConverter &converter, const Pa::PrintStmt &stmt) {
-  llvm::SmallVector<M::Value *, 4> args;
+  llvm::SmallVector<M::Value, 4> args;
   for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
     if (auto *pe{std::get_if<Pa::Expr>(&item.u)}) {
       auto loc{converter.genLocation(pe->source)};
diff --git a/lib/burnside/io.h b/lib/burnside/io.h
index 8a425529ca79..1cb09d7daa32 100644
--- a/lib/burnside/io.h
+++ b/lib/burnside/io.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/io.h ---------------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_BURNSIDE_IO_H_
 #define FORTRAN_BURNSIDE_IO_H_
@@ -40,7 +34,7 @@ struct WriteStmt;
 /// design.
 /// FIXME This interface is also not final. Should it be based on parser::..
 /// nodes and lower expressions as needed or should it get every expression
-/// already lowered as mlir::Value* ? (currently second options, not sure it
+/// already lowered as mlir::Value? (currently second options, not sure it
 /// will provide enough information for complex IO statements).
 namespace burnside {
 
diff --git a/lib/burnside/runtime.h b/lib/burnside/runtime.h
index c8d77126fb27..b919f4640ef0 100644
--- a/lib/burnside/runtime.h
+++ b/lib/burnside/runtime.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/runtime.h ----------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_BURNSIDE_RUNTIME_H_
 #define FORTRAN_BURNSIDE_RUNTIME_H_
@@ -120,11 +114,11 @@ class RuntimeStaticDescription {
 // This is currently here because this was designed to provide
 // maps over runtime description without the burden of having to
 // instantiate these maps dynamically and to keep them somewhere.
-template<typename Value> class StaticMultimapView {
+template<typename V> class StaticMultimapView {
 public:
-  using Key = typename Value::Key;
+  using Key = typename V::Key;
   struct Range {
-    using const_iterator = const Value *;
+    using const_iterator = const V *;
     constexpr const_iterator begin() const { return startPtr; }
     constexpr const_iterator end() const { return endPtr; }
     constexpr bool empty() const {
@@ -133,13 +127,13 @@ template<typename Value> class StaticMultimapView {
     constexpr std::size_t size() const {
       return empty() ? 0 : static_cast<std::size_t>(endPtr - startPtr);
     }
-    const Value *startPtr{nullptr};
-    const Value *endPtr{nullptr};
+    const V *startPtr{nullptr};
+    const V *endPtr{nullptr};
   };
   using const_iterator = typename Range::const_iterator;
 
   template<std::size_t N>
-  constexpr StaticMultimapView(const Value (&array)[N])
+  constexpr StaticMultimapView(const V (&array)[N])
     : range{&array[0], &array[0] + N} {}
   template<typename Key> constexpr bool verify() {
     // TODO: sorted
@@ -154,7 +148,7 @@ template<typename Value> class StaticMultimapView {
   // std::equal_range will be constexpr in C++20 only.
   constexpr Range getRange(const Key &key) const {
     bool matched{false};
-    const Value *start{nullptr}, *end{nullptr};
+    const V *start{nullptr}, *end{nullptr};
     for (const auto &desc : range) {
       if (desc.key == key) {
         if (!matched) {
diff --git a/lib/fir/FIRDialect.cpp b/lib/fir/FIRDialect.cpp
index a8b869202ba2..c3d3ba580e56 100644
--- a/lib/fir/FIRDialect.cpp
+++ b/lib/fir/FIRDialect.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/FIRDialect.cpp ----------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "fir/FIRDialect.h"
 #include "fir/Attribute.h"
@@ -28,7 +22,7 @@ namespace {
 
 template <typename A>
 void selectBuild(M::OpBuilder *builder, M::OperationState *result,
-                 M::Value *condition,
+                 M::Value condition,
                  llvm::ArrayRef<typename A::BranchTuple> tuples) {
   result->addOperands(condition);
   for (auto &tup : tuples) {
@@ -39,7 +33,7 @@ void selectBuild(M::OpBuilder *builder, M::OperationState *result,
   for (auto &tup : tuples) {
     auto *block{std::get<M::Block *>(tup)};
     assert(block);
-    auto blkArgs{std::get<llvm::ArrayRef<M::Value *>>(tup)};
+    auto blkArgs{std::get<llvm::ArrayRef<M::Value>>(tup)};
     result->addSuccessor(block, blkArgs);
   }
 }
diff --git a/lib/fir/FIROps.cpp b/lib/fir/FIROps.cpp
index aafd99354c8a..a6c5aa30eeac 100644
--- a/lib/fir/FIROps.cpp
+++ b/lib/fir/FIROps.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/FIROps.cpp --------------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "fir/FIROps.h"
 #include "fir/Attribute.h"
@@ -123,7 +117,7 @@ M::ParseResult parseCallOp(M::OpAsmParser &parser, M::OperationState &result) {
   } else {
     auto funcArgs =
         L::ArrayRef<M::OpAsmParser::OperandType>(operands).drop_front();
-    L::SmallVector<M::Value *, 8> resultArgs(
+    L::SmallVector<M::Value, 8> resultArgs(
         result.operands.begin() + (result.operands.empty() ? 0 : 1),
         result.operands.end());
     if (parser.resolveOperand(operands[0], funcType, result.operands) ||
@@ -160,7 +154,7 @@ fir::CmpFPredicate CmpfOp::getPredicateByName(llvm::StringRef name) {
 }
 
 void buildCmpFOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value *lhs, Value *rhs) {
+                 CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder->getI1Type());
   result.addAttribute(
@@ -253,7 +247,7 @@ M::ParseResult parseCmpfOp(M::OpAsmParser &parser, M::OperationState &result) {
 // CmpcOp
 
 void buildCmpCOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value *lhs, Value *rhs) {
+                 CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder->getI1Type());
   result.addAttribute(
@@ -327,16 +321,39 @@ void DispatchTableOp::appendTableEntry(M::Operation *op) {
   front().front().push_back(op);
 }
 
+// GenTypeDescOp
+
+#if 0
+void GenTypeDescOp::build(Builder *, OperationState &result, M::Type resty,
+                          M::TypeAttr inty) {
+  result.addAttribute("in_type", inty);
+  result.addTypes(resty);
+}
+#endif
+
+void GenTypeDescOp::build(Builder *, OperationState &result, M::TypeAttr inty) {
+  result.addAttribute("in_type", inty);
+  result.addTypes(TypeDescType::get(inty.getValue()));
+}
+
 // GlobalOp
 
-void GlobalOp::build(M::Builder *builder, M::OperationState *result,
+GlobalOp GlobalOp::create(M::Location location, L::StringRef name, M::Type type,
+                          L::ArrayRef<M::NamedAttribute> attrs) {
+  M::OperationState state(location, "global");
+  M::Builder builder(location->getContext());
+  GlobalOp::build(&builder, state, name, type, attrs);
+  return cast<GlobalOp>(Operation::create(state));
+}
+
+void GlobalOp::build(M::Builder *builder, M::OperationState &result,
                      L::StringRef name, M::Type type,
                      L::ArrayRef<M::NamedAttribute> attrs) {
-  result->addAttribute(getTypeAttrName(), M::TypeAttr::get(type));
-  result->addAttribute(M::SymbolTable::getSymbolAttrName(),
-                       builder->getStringAttr(name));
+  result.addAttribute(getTypeAttrName(), M::TypeAttr::get(type));
+  result.addAttribute(M::SymbolTable::getSymbolAttrName(),
+                      builder->getStringAttr(name));
   for (const auto &pair : attrs)
-    result->addAttribute(pair.first, pair.second);
+    result.addAttribute(pair.first, pair.second);
 }
 
 M::ParseResult GlobalOp::parse(M::OpAsmParser &parser,
@@ -418,8 +435,13 @@ M::ParseResult LoadOp::getElementOf(M::Type &ele, M::Type ref) {
 
 // LoopOp
 
-void LoopOp::build(M::Builder *builder, M::OperationState &result, M::Value *lb,
-                   M::Value *ub, L::ArrayRef<M::Value *> step) {
+void LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
+                   int64_t lowerBound, int64_t upperBound, int64_t step) {
+  assert(false && "not implemented");
+}
+
+void LoopOp::build(M::Builder *builder, M::OperationState &result, M::Value lb,
+                   M::Value ub, L::ArrayRef<M::Value> step) {
   if (step.empty())
     result.addOperands({lb, ub});
   else
@@ -467,8 +489,8 @@ M::ParseResult parseLoopOp(M::OpAsmParser &parser, M::OperationState &result) {
   return M::success();
 }
 
-fir::LoopOp getForInductionVarOwner(M::Value *val) {
-  auto *ivArg = dyn_cast<M::BlockArgument>(val);
+fir::LoopOp getForInductionVarOwner(M::Value val) {
+  auto ivArg = val.dyn_cast<M::BlockArgument>();
   if (!ivArg)
     return fir::LoopOp();
   assert(ivArg->getOwner() && "unlinked block argument");
@@ -491,7 +513,7 @@ M::Type StoreOp::elementType(M::Type refType) {
 // WhereOp
 
 void WhereOp::build(M::Builder *builder, M::OperationState &result,
-                    M::Value *cond, bool withElseRegion) {
+                    M::Value cond, bool withElseRegion) {
   result.addOperands(cond);
   M::Region *thenRegion = result.addRegion();
   M::Region *elseRegion = result.addRegion();
@@ -591,12 +613,20 @@ bool isReferenceLike(M::Type type) {
 }
 
 M::FuncOp createFuncOp(M::Location loc, M::ModuleOp module, StringRef name,
-                       M::FunctionType type) {
+                       M::FunctionType type,
+                       L::ArrayRef<M::NamedAttribute> attrs) {
   if (auto f = module.lookupSymbol<M::FuncOp>(name))
     return f;
-  auto f = M::FuncOp::create(loc, name, type);
-  module.push_back(f);
-  return f;
+  M::OpBuilder modBuilder(module.getBodyRegion());
+  return modBuilder.create<M::FuncOp>(loc, name, type, attrs);
+}
+
+GlobalOp createGlobalOp(M::Location loc, M::ModuleOp module, StringRef name,
+                        M::Type type, L::ArrayRef<M::NamedAttribute> attrs) {
+  if (auto g = module.lookupSymbol<GlobalOp>(name))
+    return g;
+  M::OpBuilder modBuilder(module.getBodyRegion());
+  return modBuilder.create<GlobalOp>(loc, name, type, attrs);
 }
 
 // Tablegen operators
diff --git a/lib/fir/InternalNames.cpp b/lib/fir/InternalNames.cpp
index f6b160cc44e9..2dcd04114222 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/fir/InternalNames.cpp
@@ -44,6 +44,40 @@ std::string doModulesHost(L::ArrayRef<L::StringRef> mods,
   return result;
 }
 
+inline L::SmallVector<L::StringRef, 2>
+convertToStringRef(L::ArrayRef<std::string> from) {
+  L::SmallVector<L::StringRef, 2> to;
+  for (auto &f : from)
+    to.push_back(f);
+  return to;
+}
+
+inline L::Optional<L::StringRef>
+convertToStringRef(const L::Optional<std::string> &from) {
+  L::Optional<L::StringRef> to;
+  if (from.hasValue())
+    to = from.getValue();
+  return to;
+}
+
+std::string readName(L::StringRef uniq, std::size_t &i, std::size_t init,
+                     std::size_t end) {
+  for (i = init; i < end && uniq[i] >= 'a' && uniq[i] <= 'z'; ++i) {
+    // do nothing
+  }
+  return uniq.substr(init, i);
+}
+
+std::int64_t readInt(L::StringRef uniq, std::size_t &i, std::size_t init,
+                     std::size_t end) {
+  for (i = init; i < end && uniq[i] >= '0' && uniq[i] <= '9'; ++i) {
+    // do nothing
+  }
+  std::int64_t result;
+  uniq.substr(init, i).getAsInteger(10, result);
+  return result;
+}
+
 } // namespace
 
 L::StringRef fir::NameUniquer::toLower(L::StringRef name) {
@@ -149,6 +183,14 @@ std::string fir::NameUniquer::doTypeDescriptor(
   return result.str();
 }
 
+std::string fir::NameUniquer::doTypeDescriptor(
+    L::ArrayRef<std::string> modules, L::Optional<std::string> host,
+    L::StringRef name, L::ArrayRef<std::int64_t> kinds) {
+  auto rmodules = convertToStringRef(modules);
+  auto rhost = convertToStringRef(host);
+  return doTypeDescriptor(rmodules, rhost, name, kinds);
+}
+
 std::string fir::NameUniquer::doVariable(L::ArrayRef<L::StringRef> modules,
                                          L::StringRef name) {
   L::Twine result = prefix() + doModules(modules) + "E" + toLower(name);
@@ -156,7 +198,75 @@ std::string fir::NameUniquer::doVariable(L::ArrayRef<L::StringRef> modules,
 }
 
 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
-fir::NameUniquer::deconstruct(L::StringRef uniquedName) {
-  assert(false && "not yet implemented");
-  return {};
+fir::NameUniquer::deconstruct(L::StringRef uniq) {
+  if (uniq.startswith("_Q")) {
+    L::SmallVector<std::string, 4> modules;
+    L::Optional<std::string> host;
+    std::string name;
+    L::SmallVector<std::int64_t, 8> kinds;
+    NameKind nk = NameKind::NOT_UNIQUED;
+    for (std::size_t i = 2, end = uniq.size(); i != end;) {
+      switch (uniq[i]) {
+      case 'B':
+        nk = NameKind::COMMON;
+        name = readName(uniq, i, i + 1, end);
+        break;
+      case 'C':
+        if (uniq[i + 1] == 'T') {
+          nk = NameKind::TYPE_DESC;
+          name = readName(uniq, i, i + 2, end);
+        } else {
+          nk = NameKind::INTRINSIC_TYPE_DESC;
+          name = readName(uniq, i, i + 1, end);
+        }
+        break;
+      case 'D':
+        nk = NameKind::DISPATCH_TABLE;
+        assert(uniq[i + 1] == 'T');
+        name = readName(uniq, i, i + 2, end);
+        break;
+      case 'E':
+        if (uniq[i + 1] == 'C') {
+          nk = NameKind::CONSTANT;
+          name = readName(uniq, i, i + 2, end);
+        } else {
+          nk = NameKind::VARIABLE;
+          name = readName(uniq, i, i + 1, end);
+        }
+        break;
+      case 'P':
+        nk = NameKind::PROCEDURE;
+        name = readName(uniq, i, i + 1, end);
+        break;
+      case 'Q':
+        nk = NameKind::GENERATED;
+        name = readName(uniq, i, i + 1, end);
+        break;
+      case 'T':
+        nk = NameKind::DERIVED_TYPE;
+        name = readName(uniq, i, i + 1, end);
+        break;
+
+      case 'M':
+      case 'S':
+        modules.push_back(readName(uniq, i, i + 1, end));
+        break;
+      case 'F':
+        host = readName(uniq, i, i + 1, end);
+        break;
+      case 'K':
+        if (uniq[i + 1] == 'N')
+          kinds.push_back(-readInt(uniq, i, i + 2, end));
+        else
+          kinds.push_back(readInt(uniq, i, i + 1, end));
+        break;
+
+      default:
+        assert(false && "unknown uniquing code");
+        break;
+      }
+    }
+    return {nk, DeconstructedName(modules, host, name, kinds)};
+  }
+  return {NameKind::NOT_UNIQUED, DeconstructedName(uniq)};
 }
diff --git a/lib/fir/KindMapping.cpp b/lib/fir/KindMapping.cpp
index f762e75cc0e7..6860667e2ae2 100644
--- a/lib/fir/KindMapping.cpp
+++ b/lib/fir/KindMapping.cpp
@@ -66,6 +66,7 @@ LLVMTypeID defaultRealKind(KindTy kind) {
   }
 }
 
+// lookup the kind-value given the defaults, the mappings, and a KIND key
 template <typename RT, char KEY>
 RT doLookup(std::function<RT(KindTy)> def,
             std::map<char, std::map<KindTy, RT>> const &map, KindTy kind) {
@@ -78,11 +79,13 @@ RT doLookup(std::function<RT(KindTy)> def,
   return def(kind);
 }
 
+// do a lookup for INTERGER, LOGICAL, or CHARACTER
 template <char KEY, typename MAP>
 Bitsize getIntegerLikeBitsize(KindTy kind, MAP const &map) {
   return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
 }
 
+// do a lookup for REAL or COMPLEX
 template <char KEY, typename MAP>
 LLVMTypeID getFloatLikeTypeID(KindTy kind, MAP const &map) {
   return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
diff --git a/lib/fir/StdConverter.cpp b/lib/fir/StdConverter.cpp
index a0684a131c82..d211c2dcae75 100644
--- a/lib/fir/StdConverter.cpp
+++ b/lib/fir/StdConverter.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/StdConverter.cpp --------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "fir/Transforms/StdConverter.h"
 #include "fir/Attribute.h"
@@ -25,8 +19,8 @@
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/ArrayRef.h"
 
-// This module performs the conversion of FIR operations to MLIR standard and/or
-// LLVM-IR dialects.
+// This module performs the conversion of some FIR operations.
+// Convert some FIR types to standard dialect?
 
 namespace L = llvm;
 namespace M = mlir;
@@ -40,8 +34,8 @@ static L::cl::opt<bool>
 
 namespace {
 
-using SmallVecResult = L::SmallVector<M::Value *, 4>;
-using OperandTy = L::ArrayRef<M::Value *>;
+using SmallVecResult = L::SmallVector<M::Value, 4>;
+using OperandTy = L::ArrayRef<M::Value>;
 using AttributeTy = L::ArrayRef<M::NamedAttribute>;
 
 /// FIR to standard type converter
@@ -143,15 +137,19 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
   }
 
   static void genTypeLadderStep(M::Location loc, bool exactTest,
-                                M::Value *selector, M::Type ty, M::Block *dest,
+                                M::Value selector, M::Type ty, M::Block *dest,
                                 OperandTy destOps, M::ModuleOp module,
                                 M::ConversionPatternRewriter &rewriter) {
     M::Type tydesc = fir::TypeDescType::get(ty);
-    M::Value *t = rewriter.create<GenTypeDescOp>(loc, M::TypeAttr::get(tydesc));
-    std::vector<M::Value *> actuals = {selector, t};
+    auto tyattr = M::TypeAttr::get(ty);
+    M::Value t = rewriter.create<GenTypeDescOp>(loc, tydesc, tyattr);
+    M::Type selty = fir::BoxType::get(rewriter.getNoneType());
+    M::Value csel = rewriter.create<ConvertOp>(loc, selty, selector);
+    M::Type tty = fir::ReferenceType::get(rewriter.getNoneType());
+    M::Value ct = rewriter.create<ConvertOp>(loc, tty, t);
+    std::vector<M::Value> actuals = {csel, ct};
     auto fty = rewriter.getI1Type();
-    std::vector<M::Type> argTy = {fir::BoxType::get(rewriter.getNoneType()),
-                                  tydesc};
+    std::vector<M::Type> argTy = {selty, tty};
     L::StringRef funName =
         exactTest ? "FIXME_exact_type_match" : "FIXME_isa_type_test";
     createFuncOp(rewriter.getUnknownLoc(), module, funName,
diff --git a/lib/fir/Tilikum.cpp b/lib/fir/Tilikum.cpp
index e426b108a74b..c02fa34b3122 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/fir/Tilikum.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/Tilikum.cpp -------------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "fir/Tilikum/Tilikum.h"
 #include "fir/Attribute.h"
@@ -65,8 +59,8 @@ using namespace fir;
 
 namespace {
 
-using SmallVecResult = L::SmallVector<M::Value *, 4>;
-using OperandTy = L::ArrayRef<M::Value *>;
+using SmallVecResult = L::SmallVector<M::Value, 4>;
+using OperandTy = L::ArrayRef<M::Value>;
 using AttributeTy = L::ArrayRef<M::NamedAttribute>;
 
 const unsigned defaultAlign = 8;
@@ -229,6 +223,13 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
     return M::LLVM::LLVMType::getStructTy(llvmDialect, members);
   }
 
+  // complex<T>  --> llvm<"{t,t}">
+  M::LLVM::LLVMType convertComplexType(M::ComplexType complex) {
+    auto eleTy = unwrap(convertType(complex.getElementType()));
+    L::SmallVector<M::LLVM::LLVMType, 2> tuple{eleTy, eleTy};
+    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+  }
+
   // fir.tdesc<any>  -->  llvm<"i8*">
   // FIXME: for now use a void*, however pointer identity is not sufficient for
   // the f18 object v. class distinction
@@ -274,6 +275,8 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
       return convertTypeDescType(tdesc.getContext());
     if (auto tuple = t.dyn_cast<M::TupleType>())
       return convertTupleType(tuple);
+    if (auto cmplx = t.dyn_cast<M::ComplexType>())
+      return convertComplexType(cmplx);
     if (auto none = t.dyn_cast<M::NoneType>())
       return M::LLVM::LLVMType::getStructTy(llvmDialect, {});
     return LLVMTypeConverter::convertType(t);
@@ -366,6 +369,18 @@ class FIROpConversion : public M::ConversionPattern {
   FIRToLLVMTypeConverter &lowering;
 };
 
+/// Create an LLVM dialect global
+void createGlobal(M::Location loc, M::ModuleOp mod, L::StringRef name,
+                  M::LLVM::LLVMType type,
+                  M::ConversionPatternRewriter &rewriter) {
+  if (mod.lookupSymbol<M::LLVM::GlobalOp>(name))
+    return;
+  M::OpBuilder modBuilder(mod.getBodyRegion());
+  modBuilder.create<M::LLVM::GlobalOp>(loc, type, /*isConstant=*/true,
+                                       M::LLVM::Linkage::Weak, name,
+                                       M::Attribute{});
+}
+
 struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -399,8 +414,8 @@ struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
     auto loc = alloc.getLoc();
     auto ity = lowering.indexType();
     auto c1 = genConstantIndex(loc, ity, rewriter, 1);
-    auto *size = c1.getResult();
-    for (auto *opnd : operands)
+    auto size = c1.getResult();
+    for (auto opnd : operands)
       size = rewriter.create<M::LLVM::MulOp>(loc, ity, size, opnd);
     auto ty = convertType(alloc.getType());
     rewriter.replaceOpWithNewOp<M::LLVM::AllocaOp>(alloc, ty, size,
@@ -437,11 +452,11 @@ struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
     auto loc = heap.getLoc();
     auto ity = lowering.indexType();
     auto c1 = genConstantIndex(loc, ity, rewriter, 1);
-    auto *size = c1.getResult();
-    for (auto *opnd : operands)
+    auto size = c1.getResult();
+    for (auto opnd : operands)
       size = rewriter.create<M::LLVM::MulOp>(loc, ity, size, opnd);
     heap.setAttr("callee", rewriter.getSymbolRefAttr(mallocFunc));
-    L::SmallVector<M::Value *, 1> args{size};
+    L::SmallVector<M::Value, 1> args{size};
     rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(heap, ty, args,
                                                  heap.getAttrs());
     return matchSuccess();
@@ -455,7 +470,7 @@ M::LLVM::LLVMFuncOp getFree(FreeMemOp op,
   auto module = op.getParentOfType<M::ModuleOp>();
   if (auto freeFunc = module.lookupSymbol<M::LLVM::LLVMFuncOp>("free"))
     return freeFunc;
-  M::OpBuilder moduleBuilder(op.getParentOfType<M::ModuleOp>().getBodyRegion());
+  M::OpBuilder moduleBuilder(module.getBodyRegion());
   auto voidType = M::LLVM::LLVMType::getVoidTy(dialect);
   return moduleBuilder.create<M::LLVM::LLVMFuncOp>(
       rewriter.getUnknownLoc(), "free",
@@ -478,16 +493,16 @@ struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
     freemem.setAttr("callee", rewriter.getSymbolRefAttr(freeFunc));
     rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(
         freemem, M::LLVM::LLVMType::getVoidTy(dialect),
-        L::SmallVector<M::Value *, 1>{bitcast}, freemem.getAttrs());
+        L::SmallVector<M::Value, 1>{bitcast}, freemem.getAttrs());
     return matchSuccess();
   }
 };
 
 template <typename... ARGS>
 M::LLVM::GEPOp genGEP(M::Location loc, M::LLVM::LLVMType ty,
-                      M::ConversionPatternRewriter &rewriter, M::Value *base,
+                      M::ConversionPatternRewriter &rewriter, M::Value base,
                       ARGS... args) {
-  L::SmallVector<M::Value *, 8> cv{args...};
+  L::SmallVector<M::Value, 8> cv{args...};
   return rewriter.create<M::LLVM::GEPOp>(loc, ty, base, cv);
 }
 
@@ -555,9 +570,9 @@ struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
     return matchSuccess();
   }
 
-  M::LLVM::LoadOp loadFromOffset(BoxDimsOp boxdims, M::Location loc,
-                                 M::Value *a, M::LLVM::ConstantOp c0,
-                                 M::LLVM::ConstantOp c7, M::Value *dim, int off,
+  M::LLVM::LoadOp loadFromOffset(BoxDimsOp boxdims, M::Location loc, M::Value a,
+                                 M::LLVM::ConstantOp c0, M::LLVM::ConstantOp c7,
+                                 M::Value dim, int off,
                                  M::ConversionPatternRewriter &rewriter) const {
     auto ty = convertType(boxdims.getResult(off)->getType());
     auto pty = unwrap(ty).getPointerTo();
@@ -641,7 +656,7 @@ struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
     auto ity = lowering.offsetType();
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c5 = genConstantOffset(loc, rewriter, 5);
-    L::SmallVector<M::Value *, 4> args{a, c0, c5};
+    L::SmallVector<M::Value, 4> args{a, c0, c5};
     auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
     auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
     auto ab = genConstantOffset(loc, rewriter, 1);
@@ -681,7 +696,7 @@ struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
     auto ty = convertType(boxrank.getType());
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c3 = genConstantOffset(loc, rewriter, 3);
-    L::SmallVector<M::Value *, 4> args{a, c0, c3};
+    L::SmallVector<M::Value, 4> args{a, c0, c3};
     auto pty = unwrap(ty).getPointerTo();
     auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
     rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxrank, ty, p);
@@ -701,7 +716,7 @@ struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
     auto ty = convertType(boxtypedesc.getType());
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c4 = genConstantOffset(loc, rewriter, 4);
-    L::SmallVector<M::Value *, 4> args{a, c0, c4};
+    L::SmallVector<M::Value, 4> args{a, c0, c4};
     auto pty = unwrap(ty).getPointerTo();
     auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
     auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
@@ -765,16 +780,16 @@ struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
     auto ty = convertType(fir::RealType::get(ctxt, kind));
     auto loc = cmp.getLoc();
     auto pos0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
-    L::SmallVector<M::Value *, 2> rp{
+    L::SmallVector<M::Value, 2> rp{
         rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[0], pos0),
         rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[1], pos0)};
     auto rcp = rewriter.create<M::LLVM::FCmpOp>(loc, ty, rp, cmp.getAttrs());
     auto pos1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
-    L::SmallVector<M::Value *, 2> ip{
+    L::SmallVector<M::Value, 2> ip{
         rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[0], pos1),
         rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[1], pos1)};
     auto icp = rewriter.create<M::LLVM::FCmpOp>(loc, ty, ip, cmp.getAttrs());
-    L::SmallVector<M::Value *, 2> cp{rcp, icp};
+    L::SmallVector<M::Value, 2> cp{rcp, icp};
     switch (cmp.getPredicate()) {
     case fir::CmpFPredicate::OEQ: // .EQ.
       rewriter.replaceOpWithNewOp<M::LLVM::AndOp>(cmp, ty, cp);
@@ -818,13 +833,13 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
     auto toTy = unwrap(toTy_);
     auto *fromLLVMTy = fromTy.getUnderlyingType();
     auto *toLLVMTy = toTy.getUnderlyingType();
-    auto *op0 = operands[0];
+    auto &op0 = operands[0];
     if (fromLLVMTy == toLLVMTy) {
       rewriter.replaceOp(convert, op0);
       return matchSuccess();
     }
     auto loc = convert.getLoc();
-    M::Value *v = {};
+    M::Value v;
     if (fromLLVMTy->isFloatingPointTy()) {
       if (toLLVMTy->isFloatingPointTy()) {
         unsigned fromBits = fromLLVMTy->getPrimitiveSizeInBits();
@@ -992,7 +1007,7 @@ struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
 
   M::LLVM::BitcastOp genGEPToField(M::Location loc, M::LLVM::LLVMType ty,
                                    M::ConversionPatternRewriter &rewriter,
-                                   M::Value *base, M::Value *zero,
+                                   M::Value base, M::Value zero,
                                    int field) const {
     auto coff = genConstantOffset(loc, rewriter, field);
     auto gep = genGEP(loc, ty, rewriter, base, zero, coff);
@@ -1025,7 +1040,7 @@ struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
 
 /// return true if all `Value`s in `operands` are `ConstantOp`s
 bool allConstants(OperandTy operands) {
-  for (auto *opnd : operands) {
+  for (auto opnd : operands) {
     if (auto defop = opnd->getDefiningOp())
       if (dyn_cast<M::LLVM::ConstantOp>(defop) ||
           dyn_cast<M::ConstantOp>(defop))
@@ -1035,7 +1050,7 @@ bool allConstants(OperandTy operands) {
   return true;
 }
 
-M::Attribute getValue(M::Value *value) {
+M::Attribute getValue(M::Value value) {
   assert(value->getDefiningOp());
   if (auto v = dyn_cast<M::LLVM::ConstantOp>(value->getDefiningOp()))
     return v.value();
@@ -1095,7 +1110,7 @@ struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
 
 /// return true if all `Value`s in `operands` are not `FieldIndexOp`s
 bool noFieldIndexOps(M::Operation::operand_range operands) {
-  for (auto *opnd : operands) {
+  for (auto opnd : operands) {
     if (auto defop = opnd->getDefiningOp())
       if (dyn_cast<FieldIndexOp>(defop))
         return false;
@@ -1113,16 +1128,16 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     auto coor = M::cast<CoordinateOp>(op);
     auto ty = convertType(coor.getType());
     auto loc = coor.getLoc();
-    M::Value *base = operands[0];
+    M::Value base = operands[0];
     auto c0 = genConstantIndex(loc, lowering.indexType(), rewriter, 0);
 
     // The base can be a boxed reference or a raw reference
     if (auto boxTy = coor.ref()->getType().dyn_cast<BoxType>()) {
       if (coor.getNumOperands() == 2) {
-        auto *coorPtr = *coor.coor().begin();
+        auto coorPtr = *coor.coor().begin();
         auto *s = coorPtr->getDefiningOp();
         if (dyn_cast_or_null<LenParamIndexOp>(s)) {
-          auto *lenParam = operands[1]; // byte offset
+          auto &lenParam = operands[1]; // byte offset
           auto bc = rewriter.create<M::LLVM::BitcastOp>(loc, voidPtrTy(), base);
           auto uty = unwrap(ty);
           auto gep = genGEP(loc, uty, rewriter, bc, lenParam);
@@ -1137,7 +1152,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
       base = rewriter.create<M::LLVM::LoadOp>(loc, pty, p);
     }
 
-    L::SmallVector<M::Value *, 8> offs{c0};
+    L::SmallVector<M::Value, 8> offs{c0};
     auto indices = operands.drop_front(1);
     offs.append(indices.begin(), indices.end());
     if (noFieldIndexOps(coor.coor())) {
@@ -1149,10 +1164,10 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     // lower the field index ops by walking the indices
     auto bty = coor.ref()->getType().cast<BoxType>();
     M::Type baseTy = ReferenceType::get(bty.getEleTy());
-    L::SmallVector<M::Value *, 8> args{c0};
+    L::SmallVector<M::Value, 8> args{c0};
     args.append(coor.coor().begin(), coor.coor().end());
 
-    M::Value *retval = base;
+    M::Value retval = base;
     assert(offs.size() == args.size() && "must have same arity");
     unsigned pos = 0;
     for (unsigned i = 0, sz = offs.size(); i != sz; ++i) {
@@ -1160,7 +1175,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
       if (auto *defop = args[i]->getDefiningOp())
         if (auto field = dyn_cast<FieldIndexOp>(defop)) {
           auto memTy = unwrap(convertType(baseTy)).getPointerTo();
-          M::Value *gep = retval;
+          M::Value gep = retval;
           if (i - pos > 0)
             gep = genGEP(loc, memTy, rewriter, gep, arguments(offs, pos, i));
           auto bc = rewriter.create<M::LLVM::BitcastOp>(loc, voidPtrTy(), gep);
@@ -1196,12 +1211,12 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     return matchSuccess();
   }
 
-  L::SmallVector<M::Value *, 8> arguments(L::ArrayRef<M::Value *> vec,
-                                          unsigned s, unsigned e) const {
+  L::SmallVector<M::Value, 8> arguments(L::ArrayRef<M::Value> vec, unsigned s,
+                                        unsigned e) const {
     return {vec.begin() + s, vec.begin() + e};
   }
 
-  int64_t getIntValue(M::Value *val) const {
+  int64_t getIntValue(M::Value val) const {
     if (val)
       if (auto *defop = val->getDefiningOp())
         if (auto constOp = dyn_cast<M::ConstantIntOp>(defop))
@@ -1322,6 +1337,7 @@ struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
   }
 };
 
+/// lower a type descriptor to a global constant
 struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1329,11 +1345,29 @@ struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto gentypedesc = M::cast<GenTypeDescOp>(op);
-    auto ty = unwrap(convertType(gentypedesc.getInType())).getPointerTo();
-    std::string name = "fixme"; // FIXME: get the uniqued name
-    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(gentypedesc, ty, name);
+    auto loc = gentypedesc.getLoc();
+    auto inTy = gentypedesc.getInType();
+    auto name = consName(rewriter, inTy);
+    auto gty = unwrap(convertType(inTy));
+    auto pty = gty.getPointerTo();
+    auto module = gentypedesc.getParentOfType<M::ModuleOp>();
+    createGlobal(loc, module, name, gty, rewriter);
+    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(gentypedesc, pty, name);
     return matchSuccess();
   }
+
+  std::string consName(M::ConversionPatternRewriter &rewriter,
+                       M::Type type) const {
+    if (auto d = type.dyn_cast<RecordType>()) {
+      auto name = d.getName();
+      auto pair = NameUniquer::deconstruct(name);
+      return lowering.uniquer.doTypeDescriptor(
+          pair.second.modules, pair.second.host, pair.second.name,
+          pair.second.kinds);
+    }
+    assert(false);
+    return {};
+  }
 };
 
 struct GlobalEntryOpConversion : public FIROpConversion<GlobalEntryOp> {
@@ -1396,7 +1430,7 @@ struct NoReassocOpConversion : public FIROpConversion<NoReassocOp> {
   }
 };
 
-void genCaseLadderStep(M::Location loc, M::Value *cmp, M::Block *dest,
+void genCaseLadderStep(M::Location loc, M::Value cmp, M::Block *dest,
                        OperandTy destOps,
                        M::ConversionPatternRewriter &rewriter) {
   auto *thisBlock = rewriter.getInsertionBlock();
@@ -1580,7 +1614,7 @@ struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
 
 // cons an extractvalue on a tuple value, returning value at element `x`
 M::LLVM::ExtractValueOp
-genExtractValueWithIndex(M::Location loc, M::Value *tuple, M::LLVM::LLVMType ty,
+genExtractValueWithIndex(M::Location loc, M::Value tuple, M::LLVM::LLVMType ty,
                          M::ConversionPatternRewriter &rewriter,
                          M::MLIRContext *ctx, int x) {
   auto cx = M::ArrayAttr::get(rewriter.getI32IntegerAttr(x), ctx);
@@ -1598,11 +1632,11 @@ struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
     auto unboxchar = M::cast<UnboxCharOp>(op);
     auto *ctx = unboxchar.getContext();
     auto loc = unboxchar.getLoc();
-    auto *tuple = operands[0];
+    auto &tuple = operands[0];
     auto ty = unwrap(tuple->getType());
-    auto ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
-    auto len = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
-    std::vector<M::Value *> repls = {ptr, len};
+    M::Value ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
+    M::Value len = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
+    std::vector<M::Value> repls = {ptr, len};
     unboxchar.replaceAllUsesWith(repls);
     rewriter.eraseOp(unboxchar);
     return matchSuccess();
@@ -1610,11 +1644,11 @@ struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
 };
 
 // generate a GEP into a structure and load the element at position `x`
-M::LLVM::LoadOp genLoadWithIndex(M::Location loc, M::Value *tuple,
+M::LLVM::LoadOp genLoadWithIndex(M::Location loc, M::Value tuple,
                                  M::LLVM::LLVMType ty,
                                  M::ConversionPatternRewriter &rewriter,
-                                 M::MLIRContext *ctx, M::LLVM::LLVMType oty,
-                                 M::LLVM::ConstantOp c0, int x) {
+                                 M::LLVM::LLVMType oty, M::LLVM::ConstantOp c0,
+                                 int x) {
   auto ax = rewriter.getI32IntegerAttr(x);
   auto cx = rewriter.create<M::LLVM::ConstantOp>(loc, oty, ax);
   auto xty = ty.getStructElementType(x);
@@ -1630,22 +1664,21 @@ struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto unbox = M::cast<UnboxOp>(op);
-    auto *ctx = unbox.getContext();
     auto loc = unbox.getLoc();
-    auto *tuple = operands[0];
+    auto &tuple = operands[0];
     auto ty = unwrap(tuple->getType());
     auto oty = lowering.offsetType();
     auto c0 = rewriter.create<M::LLVM::ConstantOp>(
         loc, oty, rewriter.getI32IntegerAttr(0));
-    auto ptr = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 0);
-    auto len = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 1);
-    auto ver = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 2);
-    auto rank = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 3);
-    auto type = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 4);
-    auto attr = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 5);
-    auto xtra = genLoadWithIndex(loc, tuple, ty, rewriter, ctx, oty, c0, 6);
+    M::Value ptr = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 0);
+    M::Value len = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 1);
+    M::Value ver = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 2);
+    M::Value rank = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 3);
+    M::Value type = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 4);
+    M::Value attr = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 5);
+    M::Value xtra = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 6);
     // FIXME: add dims, etc.
-    std::vector<M::Value *> repls = {ptr, len, ver, rank, type, attr, xtra};
+    std::vector<M::Value> repls = {ptr, len, ver, rank, type, attr, xtra};
     unbox.replaceAllUsesWith(repls);
     rewriter.eraseOp(unbox);
     return matchSuccess();
@@ -1662,11 +1695,11 @@ struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
     auto unboxproc = M::cast<UnboxProcOp>(op);
     auto *ctx = unboxproc.getContext();
     auto loc = unboxproc.getLoc();
-    auto *tuple = operands[0];
+    auto &tuple = operands[0];
     auto ty = unwrap(tuple->getType());
-    auto ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
-    auto host = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
-    std::vector<M::Value *> repls = {ptr, host};
+    M::Value ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
+    M::Value host = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
+    std::vector<M::Value> repls = {ptr, host};
     unboxproc.replaceAllUsesWith(repls);
     rewriter.eraseOp(unboxproc);
     return matchSuccess();
@@ -1678,7 +1711,7 @@ struct UndefOpConversion : public FIROpConversion<UndefOp> {
   using FIROpConversion::FIROpConversion;
 
   M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
+  matchAndRewrite(M::Operation *op, OperandTy,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto undef = M::cast<UndefOp>(op);
     rewriter.replaceOpWithNewOp<M::LLVM::UndefOp>(undef,
diff --git a/lib/fir/Transforms/CSE.cpp b/lib/fir/Transforms/CSE.cpp
index 2e765dfedb46..a5f8fcd14d73 100644
--- a/lib/fir/Transforms/CSE.cpp
+++ b/lib/fir/Transforms/CSE.cpp
@@ -1,24 +1,16 @@
-//===- CSE.cpp - Common Sub-expression Elimination ------------------------===//
+//===-- lib/fir/Transforms/CSE.cpp ------------------------------*- C++ -*-===//
 //
-// Copyright 2019 The MLIR Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// =============================================================================
-//
-// This transformation pass performs a simple common sub-expression elimination
-// algorithm on operations within a function.
+// 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
+/// This transformation pass performs a simple common sub-expression elimination
+/// algorithm on operations within a function.
+///
+//===----------------------------------------------------------------------===//
 
 #include "fir/FIROpsSupport.h"
 #include "fir/Transforms/Passes.h"
@@ -61,7 +53,9 @@ struct SimpleOperationInfo : public llvm::DenseMapInfo<Operation *> {
     //   - Operands
     unsigned hashOps;
     if (op->isCommutative()) {
-      std::vector<void *> vec(op->operand_begin(), op->operand_end());
+      std::vector<void *> vec;
+      for (auto i = op->operand_begin(), e = op->operand_end(); i != e; ++i)
+        vec.push_back((*i).getAsOpaquePointer());
       llvm::sort(vec.begin(), vec.end());
       hashOps = llvm::hash_combine_range(vec.begin(), vec.end());
     } else {
@@ -94,9 +88,9 @@ struct SimpleOperationInfo : public llvm::DenseMapInfo<Operation *> {
       return false;
     // Compare operands.
     if (lhs->isCommutative()) {
-      SmallVector<Value *, 8> lops(lhs->operand_begin(), lhs->operand_end());
+      SmallVector<Value, 8> lops(lhs->operand_begin(), lhs->operand_end());
       llvm::sort(lops.begin(), lops.end());
-      SmallVector<Value *, 8> rops(rhs->operand_begin(), rhs->operand_end());
+      SmallVector<Value, 8> rops(rhs->operand_begin(), rhs->operand_end());
       llvm::sort(rops.begin(), rops.end());
       if (!std::equal(lops.begin(), lops.end(), rops.begin()))
         return false;
diff --git a/lib/fir/Transforms/MemToReg.cpp b/lib/fir/Transforms/MemToReg.cpp
index f94198fd7674..5e4d550db0dc 100644
--- a/lib/fir/Transforms/MemToReg.cpp
+++ b/lib/fir/Transforms/MemToReg.cpp
@@ -1,4 +1,4 @@
-//===- MemToReg.cpp - Generalized mem to reg pass for MLIR dialects     ---===//
+//===-- lib/fir/Transforms/MemToReg.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.
@@ -105,7 +105,7 @@ struct AllocaInfo {
 };
 
 struct RenamePassData {
-  using ValVector = std::vector<M::Value *>;
+  using ValVector = std::vector<M::Value>;
 
   RenamePassData(M::Block *b, M::Block *p, const ValVector &v)
       : BB(b), Pred(p), Values(v) {}
@@ -232,7 +232,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       }
 
       // Otherwise, we *can* safely rewrite this load.
-      M::Value *replVal = onlyStore.getOperand(0);
+      M::Value replVal = onlyStore.getOperand(0);
       // If the replacement value is the load, this must occur in unreachable
       // code.
       if (replVal == LI.getResult())
@@ -302,7 +302,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         // Otherwise, there was a store before this load, the load takes its
         // value. Note, if the load was marked as nonnull we don't want to lose
         // that information when we erase it. So we preserve it with an assume.
-        M::Value *replVal = std::prev(I)->second->getOperand(0);
+        M::Value replVal = std::prev(I)->second->getOperand(0);
 
         // If the replacement value is the load, this must occur in unreachable
         // code.
@@ -318,7 +318,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
     // Remove the (now dead) stores and alloca.
     while (!AI.use_empty()) {
-      auto *ae = AI.getResult();
+      auto ae = AI.getResult();
       for (auto ai = ae->user_begin(), E = ae->user_end(); ai != E; ai++)
         if (STORE si = M::dyn_cast<STORE>(*ai)) {
           si.erase();
@@ -411,8 +411,8 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
   }
 
   template <typename A>
-  void initOperands(std::vector<M::Value *> &opers, M::Location &&loc,
-                    M::Block *dest, unsigned size, unsigned ai, M::Value *val,
+  void initOperands(std::vector<M::Value> &opers, M::Location &&loc,
+                    M::Block *dest, unsigned size, unsigned ai, M::Value val,
                     A &&oldOpers) {
     unsigned i = 0;
     for (auto v : oldOpers)
@@ -429,27 +429,27 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     opers[ai] = val;
   }
 
-  static void eraseIfNoUse(M::Value *val) {
+  static void eraseIfNoUse(M::Value val) {
     if (val->use_begin() == val->use_end()) {
       val->getDefiningOp()->erase();
     }
   }
 
   /// Set the incoming value on the branch side for the `ai`th block argument
-  void setParam(M::Block *blk, unsigned ai, M::Value *val, M::Block *target,
+  void setParam(M::Block *blk, unsigned ai, M::Value val, M::Block *target,
                 unsigned size) {
     auto *term = blk->getTerminator();
     if (auto br = M::dyn_cast<M::BranchOp>(term)) {
       if (br.getNumOperands() <= ai) {
         // construct a new BranchOp to replace term
-        std::vector<M::Value *> opers(size);
+        std::vector<M::Value> opers(size);
         auto *dest = br.getDest();
         builder->setInsertionPoint(term);
         initOperands(opers, br.getLoc(), dest, size, ai, val, br.getOperands());
         builder->create<M::BranchOp>(br.getLoc(), dest, opers);
         br.erase();
       } else {
-        auto *oldParam = br.getOperand(ai);
+        auto oldParam = br.getOperand(ai);
         br.setOperand(ai, val);
         eraseIfNoUse(oldParam);
       }
@@ -457,40 +457,40 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       if (target == cond.getTrueDest()) {
         if (cond.getNumTrueOperands() <= ai) {
           // construct a new CondBranchOp to replace term
-          std::vector<M::Value *> opers(size);
+          std::vector<M::Value> opers(size);
           auto *dest = cond.getTrueDest();
           builder->setInsertionPoint(term);
           initOperands(opers, cond.getLoc(), dest, size, ai, val,
                        cond.getTrueOperands());
-          auto *c = cond.getCondition();
+          auto c = cond.getCondition();
           auto *othDest = cond.getFalseDest();
-          std::vector<M::Value *> othOpers(cond.false_operand_begin(),
-                                           cond.false_operand_end());
+          std::vector<M::Value> othOpers(cond.false_operand_begin(),
+                                         cond.false_operand_end());
           builder->create<M::CondBranchOp>(cond.getLoc(), c, dest, opers,
                                            othDest, othOpers);
           cond.erase();
         } else {
-          auto *oldParam = cond.getTrueOperand(ai);
+          auto oldParam = cond.getTrueOperand(ai);
           cond.setTrueOperand(ai, val);
           eraseIfNoUse(oldParam);
         }
       } else {
         if (cond.getNumFalseOperands() <= ai) {
           // construct a new CondBranchOp to replace term
-          std::vector<M::Value *> opers(size);
+          std::vector<M::Value> opers(size);
           auto *dest = cond.getFalseDest();
           builder->setInsertionPoint(term);
           initOperands(opers, cond.getLoc(), dest, size, ai, val,
                        cond.getFalseOperands());
-          auto *c = cond.getCondition();
+          auto c = cond.getCondition();
           auto *othDest = cond.getTrueDest();
-          std::vector<M::Value *> othOpers(cond.true_operand_begin(),
-                                           cond.true_operand_end());
+          std::vector<M::Value> othOpers(cond.true_operand_begin(),
+                                         cond.true_operand_end());
           builder->create<M::CondBranchOp>(cond.getLoc(), c, othDest, othOpers,
                                            dest, opers);
           cond.erase();
         } else {
-          auto *oldParam = cond.getFalseOperand(ai);
+          auto oldParam = cond.getFalseOperand(ai);
           cond.setFalseOperand(ai, val);
           eraseIfNoUse(oldParam);
         }
@@ -502,7 +502,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
   inline static void addValue(RenamePassData::ValVector &vector,
                               RenamePassData::ValVector::size_type size,
-                              M::Value *value) {
+                              M::Value value) {
     if (vector.size() < size + 1)
       vector.resize(size + 1);
     vector[size] = value;
diff --git a/lib/fir/Transforms/RewriteLoop.cpp b/lib/fir/Transforms/RewriteLoop.cpp
index 8a06f16df986..548beed9fb3c 100644
--- a/lib/fir/Transforms/RewriteLoop.cpp
+++ b/lib/fir/Transforms/RewriteLoop.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/Transforms/RewriteLoop.cpp ----------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "fir/FIRDialect.h"
 #include "fir/FIROps.h"
@@ -99,11 +93,11 @@ class LoopLoopConv : public M::OpRewritePattern<LoopOp> {
 
   M::PatternMatchResult
   matchAndRewrite(LoopOp loop, M::PatternRewriter &rewriter) const override {
-    auto *low = loop.lowerBound();
-    auto *high = loop.upperBound();
+    auto low = loop.lowerBound();
+    auto high = loop.upperBound();
     auto optStep = loop.optstep();
     auto loc = loop.getLoc();
-    M::Value *step;
+    M::Value step;
     if (optStep.begin() != optStep.end()) {
       step = *optStep.begin();
     } else {
diff --git a/test/fir/fir-ops.fir b/test/fir/fir-ops.fir
index 686356add888..1dbc0ff50eda 100644
--- a/test/fir/fir-ops.fir
+++ b/test/fir/fir-ops.fir
@@ -79,7 +79,7 @@ func @instructions() {
   %27 = fir.call @box4() : () -> !fir.box<!fir.type<derived3{f:f32}>>
   %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
   %29 = fir.convert %28 : (i32) -> i64
-  %30 = fir.gentypedesc !fir.type<x> : !fir.tdesc<!fir.type<x>>
+  %30 = fir.gentypedesc !fir.type<x>
   fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
   %31 = fir.no_reassoc %29 : i64
   fir.call @user_i64(%31) : (i64) -> ()
@@ -182,7 +182,7 @@ func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1
   %1 = constant 2 : i32
   %2 = constant 3 : i32
   %3 = constant 4 : i32
-  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<i32>,^bb1(%0:i32), #fir.instance<i64>,^bb2(%2:i32), #fir.subsumed<i16>,^bb3(%2:i32), #fir.instance<i8>,^bb4(%1:i32), unit,^bb5 ]
+  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
 ^bb1(%a : i32) :
   return %a : i32
 ^bb2(%b : i32) :
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 115f949ae573..3332c025d303 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -16,9 +16,13 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIR
   MLIRAffineOps
+  MLIRIR
   MLIRLLVMIR
   MLIRLoopOps
+  MLIRPass
   MLIRStandardOps
+  MLIRStandardToLLVM
+  MLIRTransforms
 )
 
 add_llvm_library(FirTcoLib tco.cpp)
@@ -33,10 +37,8 @@ set(EXE_LIBS
   MLIREDSC
   MLIRLinalg
   MLIRParser
-  MLIRPass
   MLIRStandardToLLVM
   MLIRSupport
-  MLIRTransforms
   MLIRVectorOps
   MLIRVectorToLLVM
 )
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 09ee4d82ca28..88c5f4efad32 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -19,6 +19,7 @@
 #include "fir/Transforms/StdConverter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
@@ -92,7 +93,11 @@ int compileFIR() {
   return 0;
 }
 
-int main(int argc, char *const argv[]) {
+int main(int argc, char **argv) {
+  llvm::InitLLVM y(argc, argv);
+  (void)y;
+  mlir::registerPassManagerCLOptions();
+  mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
   cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Opt\n");
   return compileFIR();
 }

From ec6c50d2c03b511463f86245d8c211f6c3c3c17b Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 6 Jan 2020 13:17:32 -0800
Subject: [PATCH 151/345] remove the type conversion to avoid problems. look
 for a canonical way to do these type rewrites efficiently.

---
 lib/fir/StdConverter.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/fir/StdConverter.cpp b/lib/fir/StdConverter.cpp
index d211c2dcae75..9aec45902e10 100644
--- a/lib/fir/StdConverter.cpp
+++ b/lib/fir/StdConverter.cpp
@@ -69,12 +69,15 @@ class FIRToStdTypeConverter : public M::TypeConverter {
 
   /// Convert some FIR types to MLIR standard dialect types
   M::Type convertType(M::Type t) override {
+#if 0
+    // To lower types, we have to convert everything that uses these types...
     if (auto cplx = t.dyn_cast<CplxType>())
       return M::ComplexType::get(kindToRealType(kindMap, cplx.getFKind()));
     if (auto integer = t.dyn_cast<IntType>())
       return M::IntegerType::get(integer.getFKind() * 8, integer.getContext());
     if (auto real = t.dyn_cast<RealType>())
       return kindToRealType(kindMap, real.getFKind());
+#endif
     return t;
   }
 

From 025a4fac911375de870d6aeea1782f3426ccf786 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 6 Jan 2020 17:36:51 -0800
Subject: [PATCH 152/345] rename burnside namespace to lower

---
 lib/{burnside => lower}/CMakeLists.txt    |  6 +++---
 lib/{burnside => lower}/ast-builder.cc    |  2 +-
 lib/{burnside => lower}/ast-builder.h     | 10 +++++-----
 lib/{burnside => lower}/bridge.cc         |  6 +++---
 lib/{burnside => lower}/bridge.h          | 12 ++++++------
 lib/{burnside => lower}/builder.cc        |  6 +++---
 lib/{burnside => lower}/builder.h         | 12 ++++++------
 lib/{burnside => lower}/cfg-builder.h     |  6 +++---
 lib/{burnside => lower}/complex-handler.h | 10 +++++-----
 lib/{burnside => lower}/convert-expr.cc   |  6 +++---
 lib/{burnside => lower}/convert-expr.h    | 12 ++++++------
 lib/{burnside => lower}/convert-type.cc   |  4 ++--
 lib/{burnside => lower}/convert-type.h    | 10 +++++-----
 lib/{burnside => lower}/intrinsics.cc     |  6 +++---
 lib/{burnside => lower}/intrinsics.h      | 10 +++++-----
 lib/{burnside => lower}/io.cc             |  6 +++---
 lib/{burnside => lower}/io.h              | 10 +++++-----
 lib/{burnside => lower}/mangler.cc        |  4 ++--
 lib/{burnside => lower}/mangler.h         | 10 +++++-----
 lib/{burnside => lower}/mixin.h           | 10 +++++-----
 lib/{burnside => lower}/runtime.cc        |  6 +++---
 lib/{burnside => lower}/runtime.def       |  0
 lib/{burnside => lower}/runtime.h         | 12 ++++++------
 tools/bbc/CMakeLists.txt                  |  2 +-
 tools/bbc/bbc.cpp                         |  6 +++---
 25 files changed, 92 insertions(+), 92 deletions(-)
 rename lib/{burnside => lower}/CMakeLists.txt (90%)
 rename lib/{burnside => lower}/ast-builder.cc (99%)
 rename lib/{burnside => lower}/ast-builder.h (98%)
 rename lib/{burnside => lower}/bridge.cc (99%)
 rename lib/{burnside => lower}/bridge.h (94%)
 rename lib/{burnside => lower}/builder.cc (93%)
 rename lib/{burnside => lower}/builder.h (92%)
 rename lib/{burnside => lower}/cfg-builder.h (98%)
 rename lib/{burnside => lower}/complex-handler.h (93%)
 rename lib/{burnside => lower}/convert-expr.cc (99%)
 rename lib/{burnside => lower}/convert-expr.h (87%)
 rename lib/{burnside => lower}/convert-type.cc (99%)
 rename lib/{burnside => lower}/convert-type.h (95%)
 rename lib/{burnside => lower}/intrinsics.cc (99%)
 rename lib/{burnside => lower}/intrinsics.h (92%)
 rename lib/{burnside => lower}/io.cc (97%)
 rename lib/{burnside => lower}/io.h (90%)
 rename lib/{burnside => lower}/mangler.cc (97%)
 rename lib/{burnside => lower}/mangler.h (88%)
 rename lib/{burnside => lower}/mixin.h (94%)
 rename lib/{burnside => lower}/runtime.cc (98%)
 rename lib/{burnside => lower}/runtime.def (100%)
 rename lib/{burnside => lower}/runtime.h (96%)

diff --git a/lib/burnside/CMakeLists.txt b/lib/lower/CMakeLists.txt
similarity index 90%
rename from lib/burnside/CMakeLists.txt
rename to lib/lower/CMakeLists.txt
index 1c004e731e96..914abd95d4ef 100644
--- a/lib/burnside/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -14,7 +14,7 @@
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 
-add_library(FortranBurnside
+add_library(FortranLower
   ast-builder.cc
   bridge.cc
   builder.cc
@@ -26,14 +26,14 @@ add_library(FortranBurnside
   io.cc
 )
 
-target_link_libraries(FortranBurnside
+target_link_libraries(FortranLower
   FIR
   MLIRAffineOps
   MLIRLLVMIR
   MLIRStandardOps
 )
 
-install (TARGETS FortranBurnside
+install (TARGETS FortranLower
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib
   RUNTIME DESTINATION bin
diff --git a/lib/burnside/ast-builder.cc b/lib/lower/ast-builder.cc
similarity index 99%
rename from lib/burnside/ast-builder.cc
rename to lib/lower/ast-builder.cc
index 6627d9272538..460249cce0eb 100644
--- a/lib/burnside/ast-builder.cc
+++ b/lib/lower/ast-builder.cc
@@ -27,7 +27,7 @@
 /// are either statements or constructs, where a construct contains a list of
 /// evaluations.  The resulting AST structure can then be used to create FIR.
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
 namespace L = llvm;
 namespace Pa = Fortran::parser;
diff --git a/lib/burnside/ast-builder.h b/lib/lower/ast-builder.h
similarity index 98%
rename from lib/burnside/ast-builder.h
rename to lib/lower/ast-builder.h
index a29afe61122d..fbb70830e613 100644
--- a/lib/burnside/ast-builder.h
+++ b/lib/lower/ast-builder.h
@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FORTRAN_BURNSIDE_AST_BUILDER_H_
-#define FORTRAN_BURNSIDE_AST_BUILDER_H_
+#ifndef FORTRAN_LOWER_AST_BUILDER_H_
+#define FORTRAN_LOWER_AST_BUILDER_H_
 
 #include "../parser/parse-tree.h"
 #include "../semantics/scope.h"
 #include "llvm/Support/raw_ostream.h"
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 namespace AST {
 
 struct Evaluation;
@@ -327,6 +327,6 @@ void annotateControl(AST::Program &ast);
 
 void dumpAST(llvm::raw_ostream &o, AST::Program &ast);
 
-}  // namespace burnside
+}  // namespace lower
 
-#endif  // FORTRAN_BURNSIDE_AST_BUILDER_H_
+#endif  // FORTRAN_LOWER_AST_BUILDER_H_
diff --git a/lib/burnside/bridge.cc b/lib/lower/bridge.cc
similarity index 99%
rename from lib/burnside/bridge.cc
rename to lib/lower/bridge.cc
index b4ca23ce0a89..468201c0d1d0 100644
--- a/lib/burnside/bridge.cc
+++ b/lib/lower/bridge.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/bridge.cc ----------------------------------*- C++ -*-===//
+//===-- lib/lower/bridge.cc -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -28,7 +28,7 @@
 #include "mlir/Parser.h"
 #include "mlir/Target/LLVMIR.h"
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
 namespace Ev = Fortran::evaluate;
 namespace L = llvm;
@@ -37,7 +37,7 @@ namespace Pa = Fortran::parser;
 namespace Se = Fortran::semantics;
 
 using namespace Fortran;
-using namespace Fortran::burnside;
+using namespace Fortran::lower;
 
 namespace {
 
diff --git a/lib/burnside/bridge.h b/lib/lower/bridge.h
similarity index 94%
rename from lib/burnside/bridge.h
rename to lib/lower/bridge.h
index 50f58a119ab6..eab05f4d0123 100644
--- a/lib/burnside/bridge.h
+++ b/lib/lower/bridge.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/bridge.h -----------------------------------*- C++ -*-===//
+//===-- lib/lower/bridge.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_BURNSIDE_BRIDGE_H_
-#define FORTRAN_BURNSIDE_BRIDGE_H_
+#ifndef FORTRAN_LOWER_BRIDGE_H_
+#define FORTRAN_LOWER_BRIDGE_H_
 
 #include "../common/Fortran.h"
 #include "mlir/IR/MLIRContext.h"
@@ -50,7 +50,7 @@ namespace fir {
 struct NameUniquer;
 }
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 
 using SomeExpr = evaluate::Expr<evaluate::SomeType>;
 using SymbolRef = common::Reference<const semantics::Symbol>;
@@ -142,6 +142,6 @@ class BurnsideBridge {
   std::unique_ptr<mlir::ModuleOp> module;
 };
 
-}  // Fortran::burnside
+}  // Fortran::lower
 
-#endif  // FORTRAN_BURNSIDE_BRIDGE_H_
+#endif  // FORTRAN_LOWER_BRIDGE_H_
diff --git a/lib/burnside/builder.cc b/lib/lower/builder.cc
similarity index 93%
rename from lib/burnside/builder.cc
rename to lib/lower/builder.cc
index 60b1e5f97a96..61ca189974bb 100644
--- a/lib/burnside/builder.cc
+++ b/lib/lower/builder.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/builder.cc ---------------------------------*- C++ -*-===//
+//===-- lib/lower/builder.cc ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -14,13 +14,13 @@
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Value.h"
 
-namespace B = Fortran::burnside;
+namespace B = Fortran::lower;
 namespace Ev = Fortran::evaluate;
 namespace M = mlir;
 namespace Se = Fortran::semantics;
 
 using namespace Fortran;
-using namespace Fortran::burnside;
+using namespace Fortran::lower;
 
 M::FuncOp B::createFunction(B::AbstractConverter &converter,
     llvm::StringRef name, M::FunctionType funcTy) {
diff --git a/lib/burnside/builder.h b/lib/lower/builder.h
similarity index 92%
rename from lib/burnside/builder.h
rename to lib/lower/builder.h
index 39ae62b6c4eb..aa0cb78373fe 100644
--- a/lib/burnside/builder.h
+++ b/lib/lower/builder.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/builder.h ----------------------------------*- C++ -*-===//
+//===-- lib/lower/builder.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_BURNSIDE_BUILDER_H_
-#define FORTRAN_BURNSIDE_BUILDER_H_
+#ifndef FORTRAN_LOWER_BUILDER_H_
+#define FORTRAN_LOWER_BUILDER_H_
 
 #include "../semantics/symbol.h"
 #include "llvm/ADT/DenseMap.h"
@@ -29,7 +29,7 @@ namespace evaluate {
 struct ProcedureDesignator;
 }
 
-namespace burnside {
+namespace lower {
 
 /// Miscellaneous helper routines for building MLIR
 ///
@@ -91,7 +91,7 @@ mlir::FuncOp createFunction(AbstractConverter &converter, llvm::StringRef name,
 mlir::FuncOp createFunction(
     mlir::ModuleOp module, llvm::StringRef name, mlir::FunctionType funcTy);
 
-}  // burnside
+}  // lower
 }  // Fortran
 
-#endif  // FORTRAN_BURNSIDE_BUILDER_H_
+#endif  // FORTRAN_LOWER_BUILDER_H_
diff --git a/lib/burnside/cfg-builder.h b/lib/lower/cfg-builder.h
similarity index 98%
rename from lib/burnside/cfg-builder.h
rename to lib/lower/cfg-builder.h
index 754c4314629b..cbae0da3a08e 100644
--- a/lib/burnside/cfg-builder.h
+++ b/lib/lower/cfg-builder.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FORTRAN_BURNSIDE_BRIDGE_CFG_BUILDER_H_
-#define FORTRAN_BURNSIDE_BRIDGE_CFG_BUILDER_H_
+#ifndef FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
+#define FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
 
 /// Traverse the AST and complete the CFG by drawing the arcs, pruning unused
 /// potential targets, making implied jumps explicit, etc.
@@ -345,4 +345,4 @@ class CfgBuilder {
   }
 };
 
-#endif  // FORTRAN_BURNSIDE_BRIDGE_CFG_BUILDER_H_
+#endif  // FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
diff --git a/lib/burnside/complex-handler.h b/lib/lower/complex-handler.h
similarity index 93%
rename from lib/burnside/complex-handler.h
rename to lib/lower/complex-handler.h
index c16c192462d4..cc77d96c40c3 100644
--- a/lib/burnside/complex-handler.h
+++ b/lib/lower/complex-handler.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/complex-handler.h --------------------------*- C++ -*-===//
+//===-- lib/lower/complex-handler.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
-#define FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
+#ifndef FORTRAN_LOWER_COMPLEX_HANDLER_H_
+#define FORTRAN_LOWER_COMPLEX_HANDLER_H_
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
@@ -15,7 +15,7 @@
 #include "fir/FIROps.h"
 #include "fir/FIRType.h"
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 /// Provide helpers to generate Complex manipulations in FIR.
 
 class ComplexHandler {
@@ -99,4 +99,4 @@ class ComplexHandler {
 };
 
 }
-#endif  // FORTRAN_BURNSIDE_COMPLEX_HANDLER_H_
+#endif  // FORTRAN_LOWER_COMPLEX_HANDLER_H_
diff --git a/lib/burnside/convert-expr.cc b/lib/lower/convert-expr.cc
similarity index 99%
rename from lib/burnside/convert-expr.cc
rename to lib/lower/convert-expr.cc
index 1265cb2cb743..da1ed79b8189 100644
--- a/lib/burnside/convert-expr.cc
+++ b/lib/lower/convert-expr.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/convert-expr.cc ----------------------------*- C++ -*-===//
+//===-- lib/lower/convert-expr.cc -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -37,7 +37,7 @@
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
 namespace Ev = Fortran::evaluate;
 namespace L = llvm;
@@ -46,7 +46,7 @@ namespace Pa = Fortran::parser;
 namespace Se = Fortran::semantics;
 
 using namespace Fortran;
-using namespace Fortran::burnside;
+using namespace Fortran::lower;
 
 namespace {
 
diff --git a/lib/burnside/convert-expr.h b/lib/lower/convert-expr.h
similarity index 87%
rename from lib/burnside/convert-expr.h
rename to lib/lower/convert-expr.h
index 66360ae6e146..e02d26593826 100644
--- a/lib/burnside/convert-expr.h
+++ b/lib/lower/convert-expr.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/convert-expr.h -----------------------------*- C++ -*-===//
+//===-- lib/lower/convert-expr.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_BURNSIDE_CONVERT_EXPR_H_
-#define FORTRAN_BURNSIDE_CONVERT_EXPR_H_
+#ifndef FORTRAN_LOWER_CONVERT_EXPR_H_
+#define FORTRAN_LOWER_CONVERT_EXPR_H_
 
 #include "intrinsics.h"
 
@@ -38,7 +38,7 @@ namespace semantics {
 class Symbol;
 }  // semantics
 
-namespace burnside {
+namespace lower {
 
 class AbstractConverter;
 class SymMap;
@@ -60,7 +60,7 @@ mlir::Value createSomeAddress(mlir::Location loc, AbstractConverter &converter,
 mlir::Value createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
     SymMap &symMap, mlir::Type type, const semantics::Symbol *symbol);
 
-}  // burnside
+}  // lower
 }  // Fortran
 
-#endif  // FORTRAN_BURNSIDE_CONVERT_EXPR_H_
+#endif  // FORTRAN_LOWER_CONVERT_EXPR_H_
diff --git a/lib/burnside/convert-type.cc b/lib/lower/convert-type.cc
similarity index 99%
rename from lib/burnside/convert-type.cc
rename to lib/lower/convert-type.cc
index b82630dc60f3..3ec61b744a7c 100644
--- a/lib/burnside/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -23,7 +23,7 @@
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
 namespace Ev = Fortran::evaluate;
 namespace M = mlir;
@@ -31,7 +31,7 @@ namespace Pa = Fortran::parser;
 namespace Se = Fortran::semantics;
 
 using namespace Fortran;
-using namespace Fortran::burnside;
+using namespace Fortran::lower;
 
 namespace {
 
diff --git a/lib/burnside/convert-type.h b/lib/lower/convert-type.h
similarity index 95%
rename from lib/burnside/convert-type.h
rename to lib/lower/convert-type.h
index a842f0862782..377c7e75dde5 100644
--- a/lib/burnside/convert-type.h
+++ b/lib/lower/convert-type.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FORTRAN_BURNSIDE_CONVERT_TYPE_H_
-#define FORTRAN_BURNSIDE_CONVERT_TYPE_H_
+#ifndef FORTRAN_LOWER_CONVERT_TYPE_H_
+#define FORTRAN_LOWER_CONVERT_TYPE_H_
 
 /// Conversion of front-end TYPE, KIND, ATTRIBUTE (TKA) information to FIR/MLIR.
 /// This is meant to be the single point of truth (SPOT) for all type
@@ -56,7 +56,7 @@ namespace semantics {
 class Symbol;
 }  // semantics
 
-namespace burnside {
+namespace lower {
 
 using SomeExpr = evaluate::Expr<evaluate::SomeType>;
 using SymbolRef = common::Reference<const semantics::Symbol>;
@@ -103,7 +103,7 @@ mlir::FunctionType translateSymbolToFIRFunctionType(mlir::MLIRContext *ctxt,
 
 mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
-}  // burnside
+}  // lower
 }  // Fortran
 
-#endif  // FORTRAN_BURNSIDE_CONVERT_TYPE_H_
+#endif  // FORTRAN_LOWER_CONVERT_TYPE_H_
diff --git a/lib/burnside/intrinsics.cc b/lib/lower/intrinsics.cc
similarity index 99%
rename from lib/burnside/intrinsics.cc
rename to lib/lower/intrinsics.cc
index 5d981160d4b2..24c22efbf251 100644
--- a/lib/burnside/intrinsics.cc
+++ b/lib/lower/intrinsics.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/intrinsics.cc ------------------------------*- C++ -*-===//
+//===-- lib/lower/intrinsics.cc ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -25,7 +25,7 @@
 namespace L = llvm;
 namespace M = mlir;
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 
 /// MathRuntimeLibrary maps Fortran generic intrinsic names to runtime function
 /// signatures. There is no guarantee that that runtime functions are available
@@ -712,4 +712,4 @@ M::Value IntrinsicLibrary::Implementation::genExtremum(
   return result;
 }
 
-}  // namespace Fortran::burnside
+}  // namespace Fortran::lower
diff --git a/lib/burnside/intrinsics.h b/lib/lower/intrinsics.h
similarity index 92%
rename from lib/burnside/intrinsics.h
rename to lib/lower/intrinsics.h
index ae72852602dc..168dec84d298 100644
--- a/lib/burnside/intrinsics.h
+++ b/lib/lower/intrinsics.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/intrinsics.h -------------------------------*- C++ -*-===//
+//===-- lib/lower/intrinsics.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_BURNSIDE_INTRINSICS_H_
-#define FORTRAN_BURNSIDE_INTRINSICS_H_
+#ifndef FORTRAN_LOWER_INTRINSICS_H_
+#define FORTRAN_LOWER_INTRINSICS_H_
 
 #include "llvm/ADT/StringRef.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
@@ -15,7 +15,7 @@
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 
 /// IntrinsicLibrary generates FIR+MLIR operations that implement Fortran
 /// generic intrinsic function calls. It operates purely on FIR+MLIR types so
@@ -65,4 +65,4 @@ class IntrinsicLibrary {
 
 }
 
-#endif  // FORTRAN_BURNSIDE_INTRINSICS_H_
+#endif  // FORTRAN_LOWER_INTRINSICS_H_
diff --git a/lib/burnside/io.cc b/lib/lower/io.cc
similarity index 97%
rename from lib/burnside/io.cc
rename to lib/lower/io.cc
index 392b06dbec93..b3d12c9cf230 100644
--- a/lib/burnside/io.cc
+++ b/lib/lower/io.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/io.cc --------------------------------------*- C++ -*-===//
+//===-- lib/lower/io.cc -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -16,12 +16,12 @@
 #include "mlir/IR/Builders.h"
 #include <cassert>
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 namespace M = mlir;
 namespace Pa = Fortran::parser;
 
 using namespace Fortran;
-using namespace Fortran::burnside;
+using namespace Fortran::lower;
 
 namespace {
 
diff --git a/lib/burnside/io.h b/lib/lower/io.h
similarity index 90%
rename from lib/burnside/io.h
rename to lib/lower/io.h
index 1cb09d7daa32..3bb95999f36d 100644
--- a/lib/burnside/io.h
+++ b/lib/lower/io.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/io.h ---------------------------------------*- C++ -*-===//
+//===-- lib/lower/io.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_BURNSIDE_IO_H_
-#define FORTRAN_BURNSIDE_IO_H_
+#ifndef FORTRAN_LOWER_IO_H_
+#define FORTRAN_LOWER_IO_H_
 
 namespace mlir {
 class OpBuilder;
@@ -36,7 +36,7 @@ struct WriteStmt;
 /// nodes and lower expressions as needed or should it get every expression
 /// already lowered as mlir::Value? (currently second options, not sure it
 /// will provide enough information for complex IO statements).
-namespace burnside {
+namespace lower {
 
 class AbstractConverter;
 class BridgeImpl;
@@ -55,4 +55,4 @@ void genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
 }
 }
 
-#endif  // FORTRAN_BURNSIDE_IO_H_
+#endif  // FORTRAN_LOWER_IO_H_
diff --git a/lib/burnside/mangler.cc b/lib/lower/mangler.cc
similarity index 97%
rename from lib/burnside/mangler.cc
rename to lib/lower/mangler.cc
index 1cbca9e387d0..1b2e59fb0786 100644
--- a/lib/burnside/mangler.cc
+++ b/lib/lower/mangler.cc
@@ -22,10 +22,10 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
 namespace L = llvm;
-namespace Ma = Fortran::burnside::mangle;
+namespace Ma = Fortran::lower::mangle;
 namespace Se = Fortran::semantics;
 
 using namespace Fortran;
diff --git a/lib/burnside/mangler.h b/lib/lower/mangler.h
similarity index 88%
rename from lib/burnside/mangler.h
rename to lib/lower/mangler.h
index 11da39c38d4b..7d1691f91af2 100644
--- a/lib/burnside/mangler.h
+++ b/lib/lower/mangler.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FORTRAN_BURNSIDE_MANGLER_H_
-#define FORTRAN_BURNSIDE_MANGLER_H_
+#ifndef FORTRAN_LOWER_MANGLER_H_
+#define FORTRAN_LOWER_MANGLER_H_
 
 #include <string>
 
@@ -34,7 +34,7 @@ namespace semantics {
 class Symbol;
 }
 
-namespace burnside {
+namespace lower {
 using SymbolRef = common::Reference<const semantics::Symbol>;
 
 namespace mangle {
@@ -45,7 +45,7 @@ std::string mangleName(fir::NameUniquer &uniquer, const SymbolRef symbol);
 std::string demangleName(llvm::StringRef name);
 
 }  // mangle
-}  // burnside
+}  // lower
 }  // Fortran
 
-#endif  // FORTRAN_BURNSIDE_MANGLER_H_
+#endif  // FORTRAN_LOWER_MANGLER_H_
diff --git a/lib/burnside/mixin.h b/lib/lower/mixin.h
similarity index 94%
rename from lib/burnside/mixin.h
rename to lib/lower/mixin.h
index f24ccc2b1b08..0d75f7aaa4ed 100644
--- a/lib/burnside/mixin.h
+++ b/lib/lower/mixin.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FORTRAN_BURNSIDE_MIXIN_H_
-#define FORTRAN_BURNSIDE_MIXIN_H_
+#ifndef FORTRAN_LOWER_MIXIN_H_
+#define FORTRAN_LOWER_MIXIN_H_
 
 // Mixin classes are "partial" classes (not used standalone) that can be used to
 // add a repetitive (ad hoc) interface (and implementation) to a class.  It's
@@ -28,7 +28,7 @@
 #include <type_traits>
 #include <variant>
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 
 // implementation of a (moveable) sum type (variant)
 template<typename... Ts> struct SumTypeMixin {
@@ -67,6 +67,6 @@ template<typename... Ts> struct SumTypeCopyMixin {
     return *this; \
   }
 
-} // namespace burnside
+} // namespace lower
 
-#endif  // FORTRAN_BURNSIDE_MIXIN_H_
+#endif  // FORTRAN_LOWER_MIXIN_H_
diff --git a/lib/burnside/runtime.cc b/lib/lower/runtime.cc
similarity index 98%
rename from lib/burnside/runtime.cc
rename to lib/lower/runtime.cc
index fcf7f9d1d722..415fe48b4afc 100644
--- a/lib/burnside/runtime.cc
+++ b/lib/lower/runtime.cc
@@ -22,7 +22,7 @@
 #include "mlir/IR/Types.h"
 #include <cassert>
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 mlir::Type RuntimeStaticDescription::getMLIRType(
     TypeCode t, mlir::MLIRContext *context) {
   switch (t) {
@@ -72,9 +72,9 @@ mlir::FuncOp RuntimeStaticDescription::getFuncOp(
 
 // TODO remove dependencies to stub rt below
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 using namespace Fortran;
-using namespace Fortran::burnside;
+using namespace Fortran::lower;
 
 namespace {
 
diff --git a/lib/burnside/runtime.def b/lib/lower/runtime.def
similarity index 100%
rename from lib/burnside/runtime.def
rename to lib/lower/runtime.def
diff --git a/lib/burnside/runtime.h b/lib/lower/runtime.h
similarity index 96%
rename from lib/burnside/runtime.h
rename to lib/lower/runtime.h
index b919f4640ef0..6477ef74e9c7 100644
--- a/lib/burnside/runtime.h
+++ b/lib/lower/runtime.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/runtime.h ----------------------------------*- C++ -*-===//
+//===-- lib/lower/runtime.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_BURNSIDE_RUNTIME_H_
-#define FORTRAN_BURNSIDE_RUNTIME_H_
+#ifndef FORTRAN_LOWER_RUNTIME_H_
+#define FORTRAN_LOWER_RUNTIME_H_
 
 #include <optional>
 
@@ -22,7 +22,7 @@ class OpBuilder;
 class FuncOp;
 }
 
-namespace Fortran::burnside {
+namespace Fortran::lower {
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
@@ -196,6 +196,6 @@ mlir::FunctionType getRuntimeEntryType(
 mlir::FunctionType getRuntimeEntryType(RuntimeEntryCode code,
     mlir::MLIRContext &mlirContext, int inpKind, int resKind);
 
-}  // Fortran::burnside
+}  // Fortran::lower
 
-#endif  // FORTRAN_BURNSIDE_RUNTIME_H_
+#endif  // FORTRAN_LOWER_RUNTIME_H_
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index f0917485a173..579f6c6e98b9 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -32,7 +32,7 @@ set(EXE_LIBS
   FortranParser
   FortranEvaluate
   FortranSemantics
-  FortranBurnside
+  FortranLower
 )
 
 add_llvm_tool(bbc bbc.cpp)
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 34e9471c0f35..e88df7ad1853 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -14,8 +14,8 @@
 
 // Temporary Fortran front end driver main program for development scaffolding.
 
-#include "../../lib/burnside/bridge.h"
-#include "../../lib/burnside/convert-expr.h"
+#include "../../lib/lower/bridge.h"
+#include "../../lib/lower/convert-expr.h"
 #include "../../lib/common/Fortran-features.h"
 #include "../../lib/common/default-kinds.h"
 #include "../../lib/parser/characters.h"
@@ -61,7 +61,7 @@
 #include <unistd.h>
 #include <vector>
 
-namespace Br = Fortran::burnside;
+namespace Br = Fortran::lower;
 
 static std::list<std::string> argList(int argc, char *const argv[]) {
   std::list<std::string> result;

From 3b3e476357de72b35bb4d4e55a2e9b0e0e7ef11e Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Jan 2020 10:34:28 -0800
Subject: [PATCH 153/345] rename "fir" directories to "optimizer"

Conflicts:
	lib/Fir/.clang-format
	lib/lower/convert-expr.h
---
 include/CMakeLists.txt                        |   2 +-
 include/optimizer/.clang-format               |   2 +
 .../Analysis/IteratedDominanceFrontier.h      |   7 +-
 include/{fir => optimizer}/Attribute.h        |   6 +-
 include/{fir => optimizer}/CMakeLists.txt     |   0
 .../Tilikum.h => optimizer/CodeGen/CodeGen.h} |   9 +-
 include/{fir => optimizer}/FIRDialect.h       |   6 +-
 include/{fir => optimizer}/FIROps.h           |   8 +-
 include/{fir => optimizer}/FIROps.td          |   0
 include/{fir => optimizer}/FIROpsSupport.h    |   8 +-
 include/{fir => optimizer}/FIRType.h          |   6 +-
 include/{fir => optimizer}/InternalNames.h    |   6 +-
 include/{fir => optimizer}/KindMapping.h      |   6 +-
 .../{fir => optimizer}/Transforms/Passes.h    |   6 +-
 .../Transforms/StdConverter.h                 |   6 +-
 lib/lower/ast-builder.cc                      | 122 ++++---
 lib/lower/ast-builder.h                       | 120 +++----
 lib/lower/bridge.cc                           | 309 ++++++++++--------
 lib/lower/bridge.h                            |  36 +-
 lib/lower/builder.cc                          |  18 +-
 lib/lower/builder.h                           |  14 +-
 lib/lower/cfg-builder.h                       |  80 +++--
 lib/lower/complex-handler.h                   |  37 ++-
 lib/lower/convert-expr.cc                     | 276 +++++++++-------
 lib/lower/convert-expr.h                      |  44 +--
 lib/lower/convert-type.cc                     | 182 +++++++----
 lib/lower/convert-type.h                      |  74 +++--
 lib/lower/intrinsics.cc                       | 237 ++++++++------
 lib/lower/intrinsics.h                        |  12 +-
 lib/lower/io.cc                               |  38 +--
 lib/lower/io.h                                |  10 +-
 lib/lower/mangler.cc                          |  55 ++--
 lib/lower/mangler.h                           |  11 +-
 lib/lower/mixin.h                             |  42 ++-
 lib/lower/runtime.cc                          |  56 ++--
 lib/lower/runtime.h                           |  50 +--
 lib/{fir => optimizer}/Attribute.cpp          |   6 +-
 lib/{fir => optimizer}/CMakeLists.txt         |   2 +-
 .../Tilikum.cpp => optimizer/CodeGen.cpp}     |  16 +-
 lib/{fir => optimizer}/FIRDialect.cpp         |  12 +-
 lib/{fir => optimizer}/FIROps.cpp             |  12 +-
 lib/{fir => optimizer}/FIRType.cpp            |   4 +-
 lib/{fir => optimizer}/InternalNames.cpp      |   2 +-
 .../IteratedDominanceFrontier.cpp             |   2 +-
 lib/{fir => optimizer}/KindMapping.cpp        |   2 +-
 lib/{fir => optimizer}/StdConverter.cpp       |  14 +-
 .../Transforms/CMakeLists.txt                 |   0
 lib/{fir => optimizer}/Transforms/CSE.cpp     |   6 +-
 .../Transforms/MemToReg.cpp                   |  10 +-
 .../Transforms/RewriteLoop.cpp                |   6 +-
 tools/bbc/bbc.cpp                             |  16 +-
 tools/tco/tco.cpp                             |  31 +-
 52 files changed, 1134 insertions(+), 908 deletions(-)
 create mode 100644 include/optimizer/.clang-format
 rename include/{fir => optimizer}/Analysis/IteratedDominanceFrontier.h (97%)
 rename include/{fir => optimizer}/Attribute.h (97%)
 rename include/{fir => optimizer}/CMakeLists.txt (100%)
 rename include/{fir/Tilikum/Tilikum.h => optimizer/CodeGen/CodeGen.h} (82%)
 rename include/{fir => optimizer}/FIRDialect.h (93%)
 rename include/{fir => optimizer}/FIROps.h (97%)
 rename include/{fir => optimizer}/FIROps.td (100%)
 rename include/{fir => optimizer}/FIROpsSupport.h (95%)
 rename include/{fir => optimizer}/FIRType.h (99%)
 rename include/{fir => optimizer}/InternalNames.h (97%)
 rename include/{fir => optimizer}/KindMapping.h (96%)
 rename include/{fir => optimizer}/Transforms/Passes.h (92%)
 rename include/{fir => optimizer}/Transforms/StdConverter.h (86%)
 rename lib/{fir => optimizer}/Attribute.cpp (98%)
 rename lib/{fir => optimizer}/CMakeLists.txt (98%)
 rename lib/{fir/Tilikum.cpp => optimizer/CodeGen.cpp} (99%)
 rename lib/{fir => optimizer}/FIRDialect.cpp (91%)
 rename lib/{fir => optimizer}/FIROps.cpp (98%)
 rename lib/{fir => optimizer}/FIRType.cpp (99%)
 rename lib/{fir => optimizer}/InternalNames.cpp (99%)
 rename lib/{fir => optimizer}/IteratedDominanceFrontier.cpp (98%)
 rename lib/{fir => optimizer}/KindMapping.cpp (99%)
 rename lib/{fir => optimizer}/StdConverter.cpp (96%)
 rename lib/{fir => optimizer}/Transforms/CMakeLists.txt (100%)
 rename lib/{fir => optimizer}/Transforms/CSE.cpp (98%)
 rename lib/{fir => optimizer}/Transforms/MemToReg.cpp (99%)
 rename lib/{fir => optimizer}/Transforms/RewriteLoop.cpp (98%)

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index bd3543028a2c..53f754abd9a1 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1,2 +1,2 @@
-add_subdirectory(fir)
 add_subdirectory(flang)
+add_subdirectory(optimizer)
diff --git a/include/optimizer/.clang-format b/include/optimizer/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/include/optimizer/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/include/fir/Analysis/IteratedDominanceFrontier.h b/include/optimizer/Analysis/IteratedDominanceFrontier.h
similarity index 97%
rename from include/fir/Analysis/IteratedDominanceFrontier.h
rename to include/optimizer/Analysis/IteratedDominanceFrontier.h
index c8858d0a8f70..0ecdd2d29de2 100644
--- a/include/fir/Analysis/IteratedDominanceFrontier.h
+++ b/include/optimizer/Analysis/IteratedDominanceFrontier.h
@@ -20,8 +20,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FIR_ANALYSIS_IDF_H
-#define FIR_ANALYSIS_IDF_H
+#ifndef OPTIMIZER_ANALYSIS_IDF_H
+#define OPTIMIZER_ANALYSIS_IDF_H
 
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/IR/Block.h"
@@ -94,4 +94,5 @@ class IDFCalculator {
 typedef IDFCalculator<mlir::Block, false> ForwardIDFCalculator;
 
 } // namespace fir
-#endif
+
+#endif // OPTIMIZER_ANALYSIS_IDF_H
diff --git a/include/fir/Attribute.h b/include/optimizer/Attribute.h
similarity index 97%
rename from include/fir/Attribute.h
rename to include/optimizer/Attribute.h
index 9299774dd102..217096c6a33a 100644
--- a/include/fir/Attribute.h
+++ b/include/optimizer/Attribute.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef DIALECT_FIR_FIRATTRIBUTE_H
-#define DIALECT_FIR_FIRATTRIBUTE_H
+#ifndef OPTIMIZER_FIRATTRIBUTE_H
+#define OPTIMIZER_FIRATTRIBUTE_H
 
 #include "mlir/IR/Attributes.h"
 
@@ -139,4 +139,4 @@ void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
 
 } // namespace fir
 
-#endif // DIALECT_FIR_FIRATTRIBUTE_H
+#endif // OPTIMIZER_FIRATTRIBUTE_H
diff --git a/include/fir/CMakeLists.txt b/include/optimizer/CMakeLists.txt
similarity index 100%
rename from include/fir/CMakeLists.txt
rename to include/optimizer/CMakeLists.txt
diff --git a/include/fir/Tilikum/Tilikum.h b/include/optimizer/CodeGen/CodeGen.h
similarity index 82%
rename from include/fir/Tilikum/Tilikum.h
rename to include/optimizer/CodeGen/CodeGen.h
index 691e56f00d13..0b51eff16661 100644
--- a/include/fir/Tilikum/Tilikum.h
+++ b/include/optimizer/CodeGen/CodeGen.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_TILIKUM_TILIKUM_H
-#define FIR_TILIKUM_TILIKUM_H
+#ifndef OPTIMIZER_CODEGEN_CODEGEN_H
+#define OPTIMIZER_CODEGEN_CODEGEN_H
 
 #include <memory>
 
@@ -32,9 +32,8 @@ struct NameUniquer;
 std::unique_ptr<mlir::Pass> createFIRToLLVMPass(NameUniquer &uniquer);
 
 /// Convert the LLVM IR dialect to LLVM-IR proper
-std::unique_ptr<mlir::Pass>
-createLLVMDialectToLLVMPass(llvm::StringRef output);
+std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass(llvm::StringRef output);
 
 } // namespace fir
 
-#endif // FIR_TILIKUM_TILIKUM_H
+#endif // OPTIMIZER_CODEGEN_CODEGEN_H
diff --git a/include/fir/FIRDialect.h b/include/optimizer/FIRDialect.h
similarity index 93%
rename from include/fir/FIRDialect.h
rename to include/optimizer/FIRDialect.h
index 708b81bdadc9..1741ead46eaf 100644
--- a/include/fir/FIRDialect.h
+++ b/include/optimizer/FIRDialect.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef DIALECT_FIR_FIRDIALECT_H
-#define DIALECT_FIR_FIRDIALECT_H
+#ifndef OPTIMIZER_FIRDIALECT_H
+#define OPTIMIZER_FIRDIALECT_H
 
 #include "mlir/IR/Dialect.h"
 
@@ -52,4 +52,4 @@ class FIROpsDialect final : public mlir::Dialect {
 
 } // namespace fir
 
-#endif // DIALECT_FIR_FIRDIALECT_H
+#endif // OPTIMIZER_FIRDIALECT_H
diff --git a/include/fir/FIROps.h b/include/optimizer/FIROps.h
similarity index 97%
rename from include/fir/FIROps.h
rename to include/optimizer/FIROps.h
index 2bf565c1da01..f720ca941a55 100644
--- a/include/fir/FIROps.h
+++ b/include/optimizer/FIROps.h
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FIR_FIROPS_H
-#define FIR_FIROPS_H
+#ifndef OPTIMIZER_FIROPS_H
+#define OPTIMIZER_FIROPS_H
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpImplementation.h"
@@ -124,7 +124,7 @@ ParseResult parseCmpfOp(OpAsmParser &parser, OperationState &result);
 ParseResult parseCmpcOp(OpAsmParser &parser, OperationState &result);
 
 #define GET_OP_CLASSES
-#include "fir/FIROps.h.inc"
+#include "optimizer/FIROps.h.inc"
 
 LoopOp getForInductionVarOwner(mlir::Value val);
 
@@ -132,4 +132,4 @@ bool isReferenceLike(mlir::Type type);
 
 } // namespace fir
 
-#endif // FIR_FIROPS_H
+#endif // OPTIMIZER_FIROPS_H
diff --git a/include/fir/FIROps.td b/include/optimizer/FIROps.td
similarity index 100%
rename from include/fir/FIROps.td
rename to include/optimizer/FIROps.td
diff --git a/include/fir/FIROpsSupport.h b/include/optimizer/FIROpsSupport.h
similarity index 95%
rename from include/fir/FIROpsSupport.h
rename to include/optimizer/FIROpsSupport.h
index 450fd20f596e..e7b391480059 100644
--- a/include/fir/FIROpsSupport.h
+++ b/include/optimizer/FIROpsSupport.h
@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_FIROPS_SUPPORT_H
-#define FIR_FIROPS_SUPPORT_H
+#ifndef OPTIMIZER_FIROPS_SUPPORT_H
+#define OPTIMIZER_FIROPS_SUPPORT_H
 
-#include "fir/FIROps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
+#include "optimizer/FIROps.h"
 
 namespace fir {
 
@@ -76,4 +76,4 @@ fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
 
 } // namespace fir
 
-#endif // FIR_FIROPS_SUPPORT_H
+#endif // OPTIMIZER_FIROPS_SUPPORT_H
diff --git a/include/fir/FIRType.h b/include/optimizer/FIRType.h
similarity index 99%
rename from include/fir/FIRType.h
rename to include/optimizer/FIRType.h
index a5161c3afa03..13d7c030187b 100644
--- a/include/fir/FIRType.h
+++ b/include/optimizer/FIRType.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef DIALECT_FIR_FIRTYPE_H
-#define DIALECT_FIR_FIRTYPE_H
+#ifndef OPTIMIZER_FIRTYPE_H
+#define OPTIMIZER_FIRTYPE_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Types.h"
@@ -324,4 +324,4 @@ void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);
 
 } // namespace fir
 
-#endif // DIALECT_FIR_FIRTYPE_H
+#endif // OPTIMIZER_FIRTYPE_H
diff --git a/include/fir/InternalNames.h b/include/optimizer/InternalNames.h
similarity index 97%
rename from include/fir/InternalNames.h
rename to include/optimizer/InternalNames.h
index 2fb47a1d5c07..29b8ed912a13 100644
--- a/include/fir/InternalNames.h
+++ b/include/optimizer/InternalNames.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_INTERNAL_NAMES_H
-#define FIR_INTERNAL_NAMES_H
+#ifndef OPTIMIZER_INTERNAL_NAMES_H
+#define OPTIMIZER_INTERNAL_NAMES_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
@@ -133,4 +133,4 @@ struct NameUniquer {
 
 } // namespace fir
 
-#endif // FIR_INTERNAL_NAMES_H
+#endif // OPTIMIZER_INTERNAL_NAMES_H
diff --git a/include/fir/KindMapping.h b/include/optimizer/KindMapping.h
similarity index 96%
rename from include/fir/KindMapping.h
rename to include/optimizer/KindMapping.h
index e747c484a8b9..cca81e64f1be 100644
--- a/include/fir/KindMapping.h
+++ b/include/optimizer/KindMapping.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_KINDMAPPING_H
-#define FIR_KINDMAPPING_H
+#ifndef OPTIMIZER_KINDMAPPING_H
+#define OPTIMIZER_KINDMAPPING_H
 
 #include "llvm/IR/Type.h"
 #include <map>
@@ -88,4 +88,4 @@ class KindMapping {
 
 } // namespace fir
 
-#endif // FIR_KINDMAPPING_H
+#endif // OPTIMIZER_KINDMAPPING_H
diff --git a/include/fir/Transforms/Passes.h b/include/optimizer/Transforms/Passes.h
similarity index 92%
rename from include/fir/Transforms/Passes.h
rename to include/optimizer/Transforms/Passes.h
index a33a570464ba..3e09d8711ad9 100644
--- a/include/fir/Transforms/Passes.h
+++ b/include/optimizer/Transforms/Passes.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_TRANSFORMS_PASSES_H
-#define FIR_TRANSFORMS_PASSES_H
+#ifndef OPTIMIZER_TRANSFORMS_PASSES_H
+#define OPTIMIZER_TRANSFORMS_PASSES_H
 
 #include <memory>
 
@@ -45,4 +45,4 @@ std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createMemToRegPass();
 
 } // namespace fir
 
-#endif // FIR_TRANSFORMS_PASSES_H
+#endif // OPTIMIZER_TRANSFORMS_PASSES_H
diff --git a/include/fir/Transforms/StdConverter.h b/include/optimizer/Transforms/StdConverter.h
similarity index 86%
rename from include/fir/Transforms/StdConverter.h
rename to include/optimizer/Transforms/StdConverter.h
index b0ac1fa7aa80..2121a8c50640 100644
--- a/include/fir/Transforms/StdConverter.h
+++ b/include/optimizer/Transforms/StdConverter.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef FIR_STD_CONVERTER_H
-#define FIR_STD_CONVERTER_H
+#ifndef OPTIMIZER_TRANSFORMS_STDCONVERTER_H
+#define OPTIMIZER_TRANSFORMS_STDCONVERTER_H
 
 #include <memory>
 
@@ -30,4 +30,4 @@ std::unique_ptr<mlir::Pass> createFIRToStdPass(KindMapping &);
 
 } // namespace fir
 
-#endif // FIR_STD_CONVERSION_H
+#endif // OPTIMIZER_TRANSFORMS_STDCONVERTER_H
diff --git a/lib/lower/ast-builder.cc b/lib/lower/ast-builder.cc
index 460249cce0eb..3b763d59db89 100644
--- a/lib/lower/ast-builder.cc
+++ b/lib/lower/ast-builder.cc
@@ -50,8 +50,12 @@ class ASTBuilder {
   /// Get the result
   AST::Program *result() { return pgm; }
 
-  template<typename A> constexpr bool Pre(const A &) { return true; }
-  template<typename A> constexpr void Post(const A &) {}
+  template <typename A>
+  constexpr bool Pre(const A &) {
+    return true;
+  }
+  template <typename A>
+  constexpr void Post(const A &) {}
 
   // Module like
 
@@ -257,14 +261,14 @@ class ASTBuilder {
               return AST::Evaluation{x, s.source, s.label, parents.back()};
             },
             [&](const auto &x) {
-              return AST::Evaluation{
-                  x.value(), s.source, s.label, parents.back()};
+              return AST::Evaluation{x.value(), s.source, s.label,
+                                     parents.back()};
             },
         },
         s.statement.u);
   }
-  AST::Evaluation makeEvalAction(
-      const Pa::UnlabeledStatement<Pa::ActionStmt> &s) {
+  AST::Evaluation
+  makeEvalAction(const Pa::UnlabeledStatement<Pa::ActionStmt> &s) {
     return std::visit(
         Co::visitors{
             [&](const Pa::ContinueStmt &x) {
@@ -280,20 +284,21 @@ class ASTBuilder {
         s.statement.u);
   }
 
-  template<typename A>
+  template <typename A>
   AST::Evaluation makeEvalIndirect(const Pa::Statement<Co::Indirection<A>> &s) {
-    return AST::Evaluation{
-        s.statement.value(), s.source, s.label, parents.back()};
+    return AST::Evaluation{s.statement.value(), s.source, s.label,
+                           parents.back()};
   }
 
-  template<typename A>
+  template <typename A>
   AST::Evaluation makeEvalDirect(const Pa::Statement<A> &s) {
     return AST::Evaluation{s.statement, s.source, s.label, parents.back()};
   }
 
   // When we enter a function-like structure, we want to build a new unit and
   // set the builder's cursors to point to it.
-  template<typename A> bool enterFunc(const A &f) {
+  template <typename A>
+  bool enterFunc(const A &f) {
     auto &unit = addFunc(AST::FunctionLikeUnit{f, parents.back()});
     funclist = &unit.funcs;
     pushEval(&unit.evals);
@@ -309,7 +314,8 @@ class ASTBuilder {
 
   // When we enter a construct structure, we want to build a new construct and
   // set the builder's evaluation cursor to point to it.
-  template<typename A> bool enterConstruct(const A &c) {
+  template <typename A>
+  bool enterConstruct(const A &c) {
     auto &con = addEval(AST::Evaluation{c, parents.back()});
     con.subs = new std::list<AST::Evaluation>();
     pushEval(con.subs);
@@ -324,7 +330,8 @@ class ASTBuilder {
 
   // When we enter a module structure, we want to build a new module and
   // set the builder's function cursor to point to it.
-  template<typename A> bool enterModule(const A &f) {
+  template <typename A>
+  bool enterModule(const A &f) {
     auto &unit = addUnit(AST::ModuleLikeUnit{f, parents.back()});
     funclist = &unit.funcs;
     parents.emplace_back(&unit);
@@ -336,12 +343,14 @@ class ASTBuilder {
     parents.pop_back();
   }
 
-  template<typename A> A &addUnit(const A &unit) {
+  template <typename A>
+  A &addUnit(const A &unit) {
     pgm->getUnits().emplace_back(unit);
     return std::get<A>(pgm->getUnits().back());
   }
 
-  template<typename A> A &addFunc(const A &func) {
+  template <typename A>
+  A &addFunc(const A &func) {
     if (funclist) {
       funclist->emplace_back(func);
       return funclist->back();
@@ -376,9 +385,10 @@ class ASTBuilder {
   std::vector<AST::ParentType> parents;
 };
 
-template<typename A> constexpr bool hasErrLabel(const A &stmt) {
+template <typename A>
+constexpr bool hasErrLabel(const A &stmt) {
   if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
-      std::is_same_v<A, Pa::WriteStmt>) {
+                std::is_same_v<A, Pa::WriteStmt>) {
     for (const auto &control : stmt.controls) {
       if (std::holds_alternative<Pa::ErrLabel>(control.u)) {
         return true;
@@ -386,10 +396,12 @@ template<typename A> constexpr bool hasErrLabel(const A &stmt) {
     }
   }
   if constexpr (std::is_same_v<A, Pa::WaitStmt> ||
-      std::is_same_v<A, Pa::OpenStmt> || std::is_same_v<A, Pa::CloseStmt> ||
-      std::is_same_v<A, Pa::BackspaceStmt> ||
-      std::is_same_v<A, Pa::EndfileStmt> || std::is_same_v<A, Pa::RewindStmt> ||
-      std::is_same_v<A, Pa::FlushStmt>) {
+                std::is_same_v<A, Pa::OpenStmt> ||
+                std::is_same_v<A, Pa::CloseStmt> ||
+                std::is_same_v<A, Pa::BackspaceStmt> ||
+                std::is_same_v<A, Pa::EndfileStmt> ||
+                std::is_same_v<A, Pa::RewindStmt> ||
+                std::is_same_v<A, Pa::FlushStmt>) {
     for (const auto &spec : stmt.v) {
       if (std::holds_alternative<Pa::ErrLabel>(spec.u)) {
         return true;
@@ -406,9 +418,10 @@ template<typename A> constexpr bool hasErrLabel(const A &stmt) {
   return false;
 }
 
-template<typename A> constexpr bool hasEorLabel(const A &stmt) {
+template <typename A>
+constexpr bool hasEorLabel(const A &stmt) {
   if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
-      std::is_same_v<A, Pa::WriteStmt>) {
+                std::is_same_v<A, Pa::WriteStmt>) {
     for (const auto &control : stmt.controls) {
       if (std::holds_alternative<Pa::EorLabel>(control.u)) {
         return true;
@@ -425,9 +438,10 @@ template<typename A> constexpr bool hasEorLabel(const A &stmt) {
   return false;
 }
 
-template<typename A> constexpr bool hasEndLabel(const A &stmt) {
+template <typename A>
+constexpr bool hasEndLabel(const A &stmt) {
   if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
-      std::is_same_v<A, Pa::WriteStmt>) {
+                std::is_same_v<A, Pa::WriteStmt>) {
     for (const auto &control : stmt.controls) {
       if (std::holds_alternative<Pa::EndLabel>(control.u)) {
         return true;
@@ -457,22 +471,22 @@ bool hasAltReturns(const Pa::CallStmt &callStmt) {
 
 /// Determine if `callStmt` has alternate returns and if so set `e` to be the
 /// origin of a switch-like control flow
-void altRet(
-    AST::Evaluation &e, const Pa::CallStmt *callStmt, AST::Evaluation *cstr) {
+void altRet(AST::Evaluation &e, const Pa::CallStmt *callStmt,
+            AST::Evaluation *cstr) {
   if (hasAltReturns(*callStmt)) {
     e.setCFG(AST::CFGAnnotation::Switch, cstr);
   }
 }
 
-template<typename A>
+template <typename A>
 void ioLabel(AST::Evaluation &e, const A *s, AST::Evaluation *cstr) {
   if (hasErrLabel(*s) || hasEorLabel(*s) || hasEndLabel(*s)) {
     e.setCFG(AST::CFGAnnotation::IoSwitch, cstr);
   }
 }
 
-void annotateEvalListCFG(
-    std::list<AST::Evaluation> &evals, AST::Evaluation *cstr) {
+void annotateEvalListCFG(std::list<AST::Evaluation> &evals,
+                         AST::Evaluation *cstr) {
   bool nextIsTarget = false;
   for (auto &e : evals) {
     e.isTarget = nextIsTarget;
@@ -703,8 +717,8 @@ L::StringRef evalName(AST::Evaluation &e) {
       e.u);
 }
 
-void dumpEvalList(
-    L::raw_ostream &o, std::list<AST::Evaluation> &evals, int indent = 1) {
+void dumpEvalList(L::raw_ostream &o, std::list<AST::Evaluation> &evals,
+                  int indent = 1) {
   static const std::string white{"                                      ++"};
   std::string indentString{white.substr(0, indent * 2)};
   for (AST::Evaluation &e : evals) {
@@ -753,7 +767,7 @@ void dumpFunctionLikeUnit(L::raw_ostream &o, AST::FunctionLikeUnit &flu) {
                    }
                  },
              },
-      flu.funStmts.front());
+             flu.funStmts.front());
   o << unitKind << ' ' << name;
   if (header.size()) {
     o << ": " << header;
@@ -763,11 +777,11 @@ void dumpFunctionLikeUnit(L::raw_ostream &o, AST::FunctionLikeUnit &flu) {
   o << "End" << unitKind << ' ' << name << "\n\n";
 }
 
-}  // namespace
+} // namespace
 
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(
-    const Pa::MainProgram &f, const AST::ParentType &parent)
-  : ProgramUnit{&f, parent} {
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::MainProgram &f,
+                                            const AST::ParentType &parent)
+    : ProgramUnit{&f, parent} {
   auto &ps{std::get<std::optional<Pa::Statement<Pa::ProgramStmt>>>(f.t)};
   if (ps.has_value()) {
     const Pa::Statement<Pa::ProgramStmt> &s{ps.value()};
@@ -776,44 +790,44 @@ Br::AST::FunctionLikeUnit::FunctionLikeUnit(
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndProgramStmt>>(f.t));
 }
 
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(
-    const Pa::FunctionSubprogram &f, const AST::ParentType &parent)
-  : ProgramUnit{&f, parent} {
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::FunctionSubprogram &f,
+                                            const AST::ParentType &parent)
+    : ProgramUnit{&f, parent} {
   funStmts.push_back(&std::get<Pa::Statement<Pa::FunctionStmt>>(f.t));
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndFunctionStmt>>(f.t));
 }
 
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(
-    const Pa::SubroutineSubprogram &f, const AST::ParentType &parent)
-  : ProgramUnit{&f, parent} {
+Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::SubroutineSubprogram &f,
+                                            const AST::ParentType &parent)
+    : ProgramUnit{&f, parent} {
   funStmts.push_back(&std::get<Pa::Statement<Pa::SubroutineStmt>>(f.t));
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndSubroutineStmt>>(f.t));
 }
 
 Br::AST::FunctionLikeUnit::FunctionLikeUnit(
     const Pa::SeparateModuleSubprogram &f, const AST::ParentType &parent)
-  : ProgramUnit{&f, parent} {
+    : ProgramUnit{&f, parent} {
   funStmts.push_back(&std::get<Pa::Statement<Pa::MpSubprogramStmt>>(f.t));
   funStmts.push_back(&std::get<Pa::Statement<Pa::EndMpSubprogramStmt>>(f.t));
 }
 
-Br::AST::ModuleLikeUnit::ModuleLikeUnit(
-    const Pa::Module &m, const AST::ParentType &parent)
-  : ProgramUnit{&m, parent} {
+Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Module &m,
+                                        const AST::ParentType &parent)
+    : ProgramUnit{&m, parent} {
   modStmts.push_back(&std::get<Pa::Statement<Pa::ModuleStmt>>(m.t));
   modStmts.push_back(&std::get<Pa::Statement<Pa::EndModuleStmt>>(m.t));
 }
 
-Br::AST::ModuleLikeUnit::ModuleLikeUnit(
-    const Pa::Submodule &m, const AST::ParentType &parent)
-  : ProgramUnit{&m, parent} {
+Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Submodule &m,
+                                        const AST::ParentType &parent)
+    : ProgramUnit{&m, parent} {
   modStmts.push_back(&std::get<Pa::Statement<Pa::SubmoduleStmt>>(m.t));
   modStmts.push_back(&std::get<Pa::Statement<Pa::EndSubmoduleStmt>>(m.t));
 }
 
-Br::AST::BlockDataUnit::BlockDataUnit(
-    const Pa::BlockData &db, const AST::ParentType &parent)
-  : ProgramUnit{&db, parent} {}
+Br::AST::BlockDataUnit::BlockDataUnit(const Pa::BlockData &db,
+                                      const AST::ParentType &parent)
+    : ProgramUnit{&db, parent} {}
 
 AST::Program *Br::createAST(const Pa::Program &root) {
   ASTBuilder walker;
@@ -837,7 +851,7 @@ void Br::annotateControl(AST::Program &ast) {
                      }
                    },
                },
-        unit);
+               unit);
   }
 }
 
diff --git a/lib/lower/ast-builder.h b/lib/lower/ast-builder.h
index fbb70830e613..4e232e6257e4 100644
--- a/lib/lower/ast-builder.h
+++ b/lib/lower/ast-builder.h
@@ -53,21 +53,22 @@ struct CGJump {
 };
 
 /// is `A` a construct (or directive)?
-template<typename A> constexpr static bool isConstruct() {
+template <typename A>
+constexpr static bool isConstruct() {
   return std::is_same_v<A, parser::AssociateConstruct> ||
-      std::is_same_v<A, parser::BlockConstruct> ||
-      std::is_same_v<A, parser::CaseConstruct> ||
-      std::is_same_v<A, parser::ChangeTeamConstruct> ||
-      std::is_same_v<A, parser::CriticalConstruct> ||
-      std::is_same_v<A, parser::DoConstruct> ||
-      std::is_same_v<A, parser::IfConstruct> ||
-      std::is_same_v<A, parser::SelectRankConstruct> ||
-      std::is_same_v<A, parser::SelectTypeConstruct> ||
-      std::is_same_v<A, parser::WhereConstruct> ||
-      std::is_same_v<A, parser::ForallConstruct> ||
-      std::is_same_v<A, parser::CompilerDirective> ||
-      std::is_same_v<A, parser::OpenMPConstruct> ||
-      std::is_same_v<A, parser::OmpEndLoopDirective>;
+         std::is_same_v<A, parser::BlockConstruct> ||
+         std::is_same_v<A, parser::CaseConstruct> ||
+         std::is_same_v<A, parser::ChangeTeamConstruct> ||
+         std::is_same_v<A, parser::CriticalConstruct> ||
+         std::is_same_v<A, parser::DoConstruct> ||
+         std::is_same_v<A, parser::IfConstruct> ||
+         std::is_same_v<A, parser::SelectRankConstruct> ||
+         std::is_same_v<A, parser::SelectTypeConstruct> ||
+         std::is_same_v<A, parser::WhereConstruct> ||
+         std::is_same_v<A, parser::ForallConstruct> ||
+         std::is_same_v<A, parser::CompilerDirective> ||
+         std::is_same_v<A, parser::OpenMPConstruct> ||
+         std::is_same_v<A, parser::OmpEndLoopDirective>;
 }
 
 /// Function-like units can contains lists of evaluations.  These can be
@@ -130,37 +131,40 @@ struct Evaluation {
   Evaluation(const Evaluation &) = default;
 
   /// General ctor
-  template<typename A>
+  template <typename A>
   Evaluation(const A &a, const parser::CharBlock &pos,
-      const std::optional<parser::Label> &lab, const ParentType &p)
-    : u{&a}, parent{p}, pos{pos}, lab{lab} {}
+             const std::optional<parser::Label> &lab, const ParentType &p)
+      : u{&a}, parent{p}, pos{pos}, lab{lab} {}
 
   /// Compiler-generated jump
   Evaluation(const CGJump &jump, const ParentType &p)
-    : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
+      : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
 
   /// Construct ctor
-  template<typename A>
+  template <typename A>
   Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
     static_assert(AST::isConstruct<A>(), "must be a construct");
   }
 
   /// is `A` executable (an action statement or compiler generated)?
-  template<typename A> constexpr static bool isAction(const A &a) {
+  template <typename A>
+  constexpr static bool isAction(const A &a) {
     return !AST::isConstruct<A>() && !isOther(a);
   }
 
   /// is `A` a compiler-generated evaluation?
-  template<typename A> constexpr static bool isGenerated(const A &) {
+  template <typename A>
+  constexpr static bool isGenerated(const A &) {
     return std::is_same_v<A, CGJump>;
   }
 
   /// is `A` not an executable statement?
-  template<typename A> constexpr static bool isOther(const A &) {
+  template <typename A>
+  constexpr static bool isOther(const A &) {
     return std::is_same_v<A, parser::FormatStmt> ||
-        std::is_same_v<A, parser::EntryStmt> ||
-        std::is_same_v<A, parser::DataStmt> ||
-        std::is_same_v<A, parser::NamelistStmt>;
+           std::is_same_v<A, parser::EntryStmt> ||
+           std::is_same_v<A, parser::DataStmt> ||
+           std::is_same_v<A, parser::NamelistStmt>;
   }
 
   constexpr bool isActionStmt() const {
@@ -168,7 +172,7 @@ struct Evaluation {
                           [](auto *p) { return isAction(*p); },
                           [](auto &r) { return isGenerated(r); },
                       },
-        u);
+                      u);
   }
 
   constexpr bool isStmt() const {
@@ -176,7 +180,7 @@ struct Evaluation {
                           [](auto *p) { return isAction(*p) || isOther(*p); },
                           [](auto &r) { return isGenerated(r); },
                       },
-        u);
+                      u);
   }
   constexpr bool isConstruct() const { return !isStmt(); }
 
@@ -211,22 +215,23 @@ struct Evaluation {
   ParentType parent;
   parser::CharBlock pos;
   std::optional<parser::Label> lab;
-  std::list<Evaluation> *subs{nullptr};  // construct sub-statements
+  std::list<Evaluation> *subs{nullptr}; // construct sub-statements
   CFGAnnotation cfg{CFGAnnotation::None};
-  bool isTarget{false};  // this evaluation is a control target
-  bool containsBranches{false};  // construct contains branches
+  bool isTarget{false};         // this evaluation is a control target
+  bool containsBranches{false}; // construct contains branches
 };
 
 /// A program is a list of program units.
 /// These units can be function like, module like, or block data
 struct ProgramUnit {
-  template<typename A>
+  template <typename A>
   ProgramUnit(A *ptr, const ParentType &parent) : p{ptr}, parent{parent} {}
 
   std::variant<const parser::MainProgram *, const parser::FunctionSubprogram *,
-      const parser::SubroutineSubprogram *, const parser::Module *,
-      const parser::Submodule *, const parser::SeparateModuleSubprogram *,
-      const parser::BlockData *>
+               const parser::SubroutineSubprogram *, const parser::Module *,
+               const parser::Submodule *,
+               const parser::SeparateModuleSubprogram *,
+               const parser::BlockData *>
       p;
   ParentType parent;
 };
@@ -237,21 +242,21 @@ struct FunctionLikeUnit : public ProgramUnit {
   // wrapper statements for function-like syntactic structures
   using FunctionStatement =
       std::variant<const parser::Statement<parser::ProgramStmt> *,
-          const parser::Statement<parser::EndProgramStmt> *,
-          const parser::Statement<parser::FunctionStmt> *,
-          const parser::Statement<parser::EndFunctionStmt> *,
-          const parser::Statement<parser::SubroutineStmt> *,
-          const parser::Statement<parser::EndSubroutineStmt> *,
-          const parser::Statement<parser::MpSubprogramStmt> *,
-          const parser::Statement<parser::EndMpSubprogramStmt> *>;
+                   const parser::Statement<parser::EndProgramStmt> *,
+                   const parser::Statement<parser::FunctionStmt> *,
+                   const parser::Statement<parser::EndFunctionStmt> *,
+                   const parser::Statement<parser::SubroutineStmt> *,
+                   const parser::Statement<parser::EndSubroutineStmt> *,
+                   const parser::Statement<parser::MpSubprogramStmt> *,
+                   const parser::Statement<parser::EndMpSubprogramStmt> *>;
 
   FunctionLikeUnit(const parser::MainProgram &f, const ParentType &parent);
-  FunctionLikeUnit(
-      const parser::FunctionSubprogram &f, const ParentType &parent);
-  FunctionLikeUnit(
-      const parser::SubroutineSubprogram &f, const ParentType &parent);
-  FunctionLikeUnit(
-      const parser::SeparateModuleSubprogram &f, const ParentType &parent);
+  FunctionLikeUnit(const parser::FunctionSubprogram &f,
+                   const ParentType &parent);
+  FunctionLikeUnit(const parser::SubroutineSubprogram &f,
+                   const ParentType &parent);
+  FunctionLikeUnit(const parser::SeparateModuleSubprogram &f,
+                   const ParentType &parent);
 
   bool isMainProgram() {
     return std::get_if<const parser::Statement<parser::EndProgramStmt> *>(
@@ -267,13 +272,14 @@ struct FunctionLikeUnit : public ProgramUnit {
     return isA<parser::MpSubprogramStmt>();
   }
 
-  const semantics::Scope *scope{nullptr};  // scope from front-end
+  const semantics::Scope *scope{nullptr}; // scope from front-end
   std::list<FunctionStatement> funStmts;  // begin/end pair
-  std::list<Evaluation> evals;  // statements
-  std::list<FunctionLikeUnit> funcs;  // internal procedures
+  std::list<Evaluation> evals;            // statements
+  std::list<FunctionLikeUnit> funcs;      // internal procedures
 
 private:
-  template<typename A> const A *isA() {
+  template <typename A>
+  const A *isA() {
     if (auto p = std::get_if<const parser::Statement<A> *>(&funStmts.front())) {
       return &(*p)->statement;
     }
@@ -287,9 +293,9 @@ struct ModuleLikeUnit : public ProgramUnit {
   // wrapper statements for module-like syntactic structures
   using ModuleStatement =
       std::variant<const parser::Statement<parser::ModuleStmt> *,
-          const parser::Statement<parser::EndModuleStmt> *,
-          const parser::Statement<parser::SubmoduleStmt> *,
-          const parser::Statement<parser::EndSubmoduleStmt> *>;
+                   const parser::Statement<parser::EndModuleStmt> *,
+                   const parser::Statement<parser::SubmoduleStmt> *,
+                   const parser::Statement<parser::EndSubmoduleStmt> *>;
 
   ModuleLikeUnit(const parser::Module &m, const ParentType &parent);
   ModuleLikeUnit(const parser::Submodule &m, const ParentType &parent);
@@ -314,7 +320,7 @@ struct Program {
   std::list<Units> units;
 };
 
-}  // namespace AST
+} // namespace AST
 
 /// Create an AST from the parse tree
 AST::Program *createAST(const parser::Program &root);
@@ -327,6 +333,6 @@ void annotateControl(AST::Program &ast);
 
 void dumpAST(llvm::raw_ostream &o, AST::Program &ast);
 
-}  // namespace lower
+} // namespace Fortran::lower
 
-#endif  // FORTRAN_LOWER_AST_BUILDER_H_
+#endif // FORTRAN_LOWER_AST_BUILDER_H_
diff --git a/lib/lower/bridge.cc b/lib/lower/bridge.cc
index 468201c0d1d0..fbdbde349be8 100644
--- a/lib/lower/bridge.cc
+++ b/lib/lower/bridge.cc
@@ -7,6 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "bridge.h"
+#include "../parser/parse-tree.h"
+#include "../semantics/tools.h"
 #include "ast-builder.h"
 #include "builder.h"
 #include "convert-expr.h"
@@ -14,19 +16,17 @@
 #include "intrinsics.h"
 #include "io.h"
 #include "mangler.h"
-#include "runtime.h"
-#include "../parser/parse-tree.h"
-#include "../semantics/tools.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
-#include "fir/InternalNames.h"
-#include "llvm/Support/CommandLine.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Parser.h"
 #include "mlir/Target/LLVMIR.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/FIRType.h"
+#include "optimizer/InternalNames.h"
+#include "runtime.h"
+#include "llvm/Support/CommandLine.h"
 
 namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
@@ -42,11 +42,12 @@ using namespace Fortran::lower;
 namespace {
 
 L::cl::opt<bool> ClDumpPreFir("fdebug-dump-pre-fir", L::cl::init(false),
-    L::cl::desc("dump the IR tree prior to FIR"));
+                              L::cl::desc("dump the IR tree prior to FIR"));
 
-L::cl::opt<bool> ClDisableToDoAssert("disable-burnside-todo",
-    L::cl::desc("disable burnside bridge asserts"), L::cl::init(false),
-    L::cl::Hidden);
+L::cl::opt<bool>
+    ClDisableToDoAssert("disable-burnside-todo",
+                        L::cl::desc("disable burnside bridge asserts"),
+                        L::cl::init(false), L::cl::Hidden);
 
 #undef TODO
 #define TODO() assert(false && "not implemented yet")
@@ -66,13 +67,13 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 #include "cfg-builder.h"
 
 #undef TODO
-#define TODO() \
-  { \
-    if (ClDisableToDoAssert) \
-      M::emitError(toLocation(), __FILE__) \
-          << ":" << __LINE__ << " not implemented"; \
-    else \
-      assert(false && "not yet implemented"); \
+#define TODO()                                                                 \
+  {                                                                            \
+    if (ClDisableToDoAssert)                                                   \
+      M::emitError(toLocation(), __FILE__)                                     \
+          << ":" << __LINE__ << " not implemented";                            \
+    else                                                                       \
+      assert(false && "not yet implemented");                                  \
   }
 
 /// Converter from AST to FIR
@@ -95,8 +96,8 @@ class FirConverter : public AbstractConverter {
     return createSomeExpression(loc, *this, *expr, localSymbols, intrinsics);
   }
   M::Value createLogicalExprAsI1(M::Location loc, const Se::SomeExpr *expr) {
-    return createI1LogicalExpression(
-        loc, *this, *expr, localSymbols, intrinsics);
+    return createI1LogicalExpression(loc, *this, *expr, localSymbols,
+                                     intrinsics);
   }
   M::Value createTemporary(M::Location loc, const Se::Symbol &sym) {
     return Br::createTemporary(loc, *builder, localSymbols, genType(sym), &sym);
@@ -104,8 +105,8 @@ class FirConverter : public AbstractConverter {
 
   // TODO: we need a map for the various Fortran runtime entry points
   M::FuncOp genRuntimeFunction(RuntimeEntryCode rec, int kind) {
-    return genFunctionFIR(
-        getRuntimeEntryName(rec), getRuntimeEntryType(rec, mlirContext, kind));
+    return genFunctionFIR(getRuntimeEntryName(rec),
+                          getRuntimeEntryType(rec, mlirContext, kind));
   }
 
   M::FuncOp genFunctionFIR(L::StringRef callee, M::FunctionType funcTy) {
@@ -152,39 +153,39 @@ class FirConverter : public AbstractConverter {
         cstr->parent);
   }
 
-  template<typename A>
+  template <typename A>
   static const Se::SomeExpr *getScalarExprOfTuple(const A &tuple) {
     return Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(tuple));
   }
-  template<typename A>
+  template <typename A>
   static const Se::SomeExpr *getExprOfTuple(const A &tuple) {
     return Se::GetExpr(std::get<Pa::LogicalExpr>(tuple));
   }
   /// Get the condition expression for a CondGoto evaluation
   const Se::SomeExpr *getEvaluationCondition(AST::Evaluation &eval) {
-    return std::visit(
-        Co::visitors{
-            [&](const Pa::IfStmt *stmt) {
-              return getScalarExprOfTuple(stmt->t);
-            },
-            [&](const Pa::IfThenStmt *stmt) {
-              return getScalarExprOfTuple(stmt->t);
-            },
-            [&](const Pa::ElseIfStmt *stmt) {
-              return getScalarExprOfTuple(stmt->t);
-            },
-            [&](const Pa::WhereConstructStmt *stmt) {
-              return getExprOfTuple(stmt->t);
-            },
-            [&](const Pa::MaskedElsewhereStmt *stmt) {
-              return getExprOfTuple(stmt->t);
-            },
-            [&](auto) -> const Se::SomeExpr * {
-              M::emitError(toLocation(), "unexpected conditional branch case");
-              return nullptr;
-            },
-        },
-        eval.u);
+    return std::visit(Co::visitors{
+                          [&](const Pa::IfStmt *stmt) {
+                            return getScalarExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::IfThenStmt *stmt) {
+                            return getScalarExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::ElseIfStmt *stmt) {
+                            return getScalarExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::WhereConstructStmt *stmt) {
+                            return getExprOfTuple(stmt->t);
+                          },
+                          [&](const Pa::MaskedElsewhereStmt *stmt) {
+                            return getExprOfTuple(stmt->t);
+                          },
+                          [&](auto) -> const Se::SomeExpr * {
+                            M::emitError(toLocation(),
+                                         "unexpected conditional branch case");
+                            return nullptr;
+                          },
+                      },
+                      eval.u);
   }
 
   //
@@ -192,17 +193,17 @@ class FirConverter : public AbstractConverter {
   //
 
   void genFIR(const Pa::Statement<Pa::ProgramStmt> &stmt, std::string &name,
-      const Se::Symbol *&) {
+              const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     name = uniquer.doProgramEntry();
   }
   void genFIR(const Pa::Statement<Pa::EndProgramStmt> &stmt, std::string &,
-      const Se::Symbol *&) {
+              const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
   void genFIR(const Pa::Statement<Pa::FunctionStmt> &stmt, std::string &name,
-      const Se::Symbol *&symbol) {
+              const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
@@ -210,13 +211,13 @@ class FirConverter : public AbstractConverter {
     name = mangleName(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
-      const Se::Symbol *&symbol) {
+              const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     assert(symbol);
     genFIRFunctionReturn(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::SubroutineStmt> &stmt, std::string &name,
-      const Se::Symbol *&symbol) {
+              const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{std::get<Pa::Name>(stmt.statement.t)};
     symbol = n.symbol;
@@ -224,19 +225,19 @@ class FirConverter : public AbstractConverter {
     name = mangleName(*symbol);
   }
   void genFIR(const Pa::Statement<Pa::EndSubroutineStmt> &stmt, std::string &,
-      const Se::Symbol *&) {
+              const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
   void genFIR(const Pa::Statement<Pa::MpSubprogramStmt> &stmt,
-      std::string &name, const Se::Symbol *&symbol) {
+              std::string &name, const Se::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n{stmt.statement.v};
     name = n.ToString();
     symbol = n.symbol;
   }
   void genFIR(const Pa::Statement<Pa::EndMpSubprogramStmt> &stmt, std::string &,
-      const Se::Symbol *&) {
+              const Se::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
@@ -260,7 +261,8 @@ class FirConverter : public AbstractConverter {
     M::Value r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
     builder->create<M::ReturnOp>(toLocation(), r);
   }
-  template<typename A> void genFIRProcedureExit(const A *) {
+  template <typename A>
+  void genFIRProcedureExit(const A *) {
     // FIXME: alt-returns
     builder->create<M::ReturnOp>(toLocation());
   }
@@ -285,20 +287,20 @@ class FirConverter : public AbstractConverter {
     genFIRCondBranch(cond, targets[0], targets[1]);
   }
 
-  void genFIRCondBranch(
-      M::Value cond, AST::Evaluation *trueDest, AST::Evaluation *falseDest) {
+  void genFIRCondBranch(M::Value cond, AST::Evaluation *trueDest,
+                        AST::Evaluation *falseDest) {
     using namespace std::placeholders;
     localEdgeQ.emplace_back(std::bind(
         [](M::OpBuilder *builder, M::Block *block, M::Value cnd,
-            AST::Evaluation *trueDest, AST::Evaluation *falseDest,
-            M::Location location, const LabelMapType &map) {
+           AST::Evaluation *trueDest, AST::Evaluation *falseDest,
+           M::Location location, const LabelMapType &map) {
           L::SmallVector<M::Value, 2> blk;
           builder->setInsertionPointToEnd(block);
           auto tdp{map.find(trueDest)};
           auto fdp{map.find(falseDest)};
           assert(tdp != map.end() && fdp != map.end());
-          builder->create<M::CondBranchOp>(
-              location, cnd, tdp->second, blk, fdp->second, blk);
+          builder->create<M::CondBranchOp>(location, cnd, tdp->second, blk,
+                                           fdp->second, blk);
         },
         builder, builder->getInsertionBlock(), cond, trueDest, falseDest,
         toLocation(), _1));
@@ -311,7 +313,7 @@ class FirConverter : public AbstractConverter {
     using namespace std::placeholders;
     localEdgeQ.emplace_back(std::bind(
         [](M::OpBuilder *builder, M::Block *block, AST::Evaluation *dest,
-            M::Location location, const LabelMapType &map) {
+           M::Location location, const LabelMapType &map) {
           builder->setInsertionPointToEnd(block);
           assert(map.find(dest) != map.end() && "no destination");
           builder->create<M::BranchOp>(location, map.find(dest)->second);
@@ -346,7 +348,7 @@ class FirConverter : public AbstractConverter {
   void switchInsertionPointToOtherwise(fir::WhereOp &where) {
     builder->setInsertionPointToStart(&where.otherRegion().front());
   }
-  template<typename A>
+  template <typename A>
   void genWhereCondition(fir::WhereOp &where, const A *stmt) {
     auto cond{createLogicalExprAsI1(
         toLocation(), Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(stmt->t)))};
@@ -356,7 +358,8 @@ class FirConverter : public AbstractConverter {
 
   M::Value genFIRLoopIndex(const Pa::ScalarExpr &x) {
     return builder->create<fir::ConvertOp>(toLocation(),
-        M::IndexType::get(&mlirContext), genExprValue(*Se::GetExpr(x)));
+                                           M::IndexType::get(&mlirContext),
+                                           genExprValue(*Se::GetExpr(x)));
   }
 
   /// Structured control op (`fir.loop`, `fir.where`)
@@ -387,8 +390,8 @@ class FirConverter : public AbstractConverter {
                     if (x.step.has_value()) {
                       step.emplace_back(genExprValue(*Se::GetExpr(*x.step)));
                     }
-                    doLoop = builder->create<fir::LoopOp>(
-                        toLocation(), lo, hi, step);
+                    doLoop = builder->create<fir::LoopOp>(toLocation(), lo, hi,
+                                                          step);
                     builder->setInsertionPointToStart(doLoop.getBody());
                     auto *sym{x.name.thing.symbol};
                     auto ty{genType(*sym)};
@@ -403,8 +406,9 @@ class FirConverter : public AbstractConverter {
                   },
                   [&](const Pa::LoopControl::Concurrent &x) {
                     // FIXME: can project a multi-dimensional space
-                    doLoop = builder->create<fir::LoopOp>(toLocation(),
-                        M::Value{}, M::Value{}, L::ArrayRef<M::Value>{});
+                    doLoop = builder->create<fir::LoopOp>(
+                        toLocation(), M::Value{}, M::Value{},
+                        L::ArrayRef<M::Value>{});
                     builder->setInsertionPointToStart(doLoop.getBody());
                   },
               },
@@ -498,7 +502,7 @@ class FirConverter : public AbstractConverter {
                    },
                    [&](const Pa::ProcComponentRef &) { TODO(); },
                },
-        std::get<Pa::ProcedureDesignator>(stmt.v.t).u);
+               std::get<Pa::ProcedureDesignator>(stmt.v.t).u);
     for (auto *d : argsList) {
       Se::SymbolRef sr{*d};
       // FIXME:
@@ -507,7 +511,7 @@ class FirConverter : public AbstractConverter {
     auto funTy{M::FunctionType::get(argTy, resTy, builder->getContext())};
     // FIXME: mangle name
     M::FuncOp func{getFunc(funName, funTy)};
-    (void)func;  // FIXME
+    (void)func; // FIXME
     std::vector<M::Value> actuals;
     for (auto &aa : std::get<std::list<Pa::ActualArgSpec>>(stmt.v.t)) {
       auto &kw = std::get<std::optional<Pa::Keyword>>(aa.t);
@@ -522,7 +526,7 @@ class FirConverter : public AbstractConverter {
                      [&](const Pa::ActualArg::PercentRef &) { TODO(); },
                      [&](const Pa::ActualArg::PercentVal &) { TODO(); },
                  },
-          arg.u);
+                 arg.u);
       if (kw.has_value()) {
         TODO();
         continue;
@@ -530,8 +534,8 @@ class FirConverter : public AbstractConverter {
       actuals.push_back(fe);
     }
 
-    builder->create<fir::CallOp>(
-        toLocation(), resTy, builder->getSymbolRefAttr(funName), actuals);
+    builder->create<fir::CallOp>(toLocation(), resTy,
+                                 builder->getSymbolRefAttr(funName), actuals);
   }
 
   void genFIR(const Pa::IfStmt &) { TODO(); }
@@ -605,7 +609,7 @@ class FirConverter : public AbstractConverter {
                        genFIR(b.statement);
                      },
                  },
-          s.u);
+                 s.u);
     }
     TODO();
   }
@@ -630,13 +634,13 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::EndCriticalStmt &) { TODO(); }
 
   // Do loop is handled by EvalIterative(), EvalStructuredOp()
-  void genFIR(const Pa::NonLabelDoStmt &) {}  // do nothing
-  void genFIR(const Pa::EndDoStmt &) {}  // do nothing
+  void genFIR(const Pa::NonLabelDoStmt &) {} // do nothing
+  void genFIR(const Pa::EndDoStmt &) {}      // do nothing
 
   // If-Then-Else is handled by EvalCondGoto(), EvalStructuredOp()
-  void genFIR(const Pa::IfThenStmt &) {}  // do nothing
-  void genFIR(const Pa::ElseIfStmt &) {}  // do nothing
-  void genFIR(const Pa::ElseStmt &) {}  // do nothing
+  void genFIR(const Pa::IfThenStmt &) {} // do nothing
+  void genFIR(const Pa::ElseIfStmt &) {} // do nothing
+  void genFIR(const Pa::ElseStmt &) {}   // do nothing
   void genFIR(const Pa::EndIfStmt &) {}  // do nothing
 
   void genFIR(const Pa::SelectRankStmt &) { TODO(); }
@@ -727,7 +731,8 @@ class FirConverter : public AbstractConverter {
     step.emplace_back(one);
     // Copy the minimum of the lhs and rhs lengths
     auto cmpLen{builder->create<M::CmpIOp>(toLocation(), M::CmpIPredicate::slt,
-        lhsAddrAndLen.second, rhsAddrAndLen.second)};
+                                           lhsAddrAndLen.second,
+                                           rhsAddrAndLen.second)};
     auto copyLen{builder->create<M::SelectOp>(
         toLocation(), cmpLen, lhsAddrAndLen.second, rhsAddrAndLen.second)};
     auto copyMaxIndex{
@@ -746,15 +751,15 @@ class FirConverter : public AbstractConverter {
     builder->setInsertionPointToEnd(insPt);
 
     // Build loop to pad lhs with blanks if needed.
-    auto padMaxIndex{builder->create<fir::ConvertOp>(
-        toLocation(), indexTy, lhsAddrAndLen.second)};
+    auto padMaxIndex{builder->create<fir::ConvertOp>(toLocation(), indexTy,
+                                                     lhsAddrAndLen.second)};
     auto byteTy{M::IntegerType::get(8, builder->getContext())};
     auto asciiSpace{builder->create<M::ConstantOp>(
         toLocation(), byteTy, builder->getIntegerAttr(byteTy, 32))};
     auto blank{
         builder->create<fir::ConvertOp>(toLocation(), charType, asciiSpace)};
-    auto padLoop{builder->create<fir::LoopOp>(
-        toLocation(), copyMaxIndex, padMaxIndex, step)};
+    auto padLoop{builder->create<fir::LoopOp>(toLocation(), copyMaxIndex,
+                                              padMaxIndex, step)};
     insPt = builder->getInsertionBlock();
     builder->setInsertionPointToStart(padLoop.getBody());
     auto padIndex{padLoop.getInductionVar()};
@@ -795,7 +800,8 @@ class FirConverter : public AbstractConverter {
           // Conversions are already inserted by semantic
           // analysis.
           builder->create<fir::StoreOp>(toLocation(),
-              genExprValue(assignment->rhs), genExprAddr(assignment->lhs));
+                                        genExprValue(assignment->rhs),
+                                        genExprAddr(assignment->lhs));
           break;
         case CharacterCat:
           // Fortran 2018 10.2.1.3 p10 and p11
@@ -813,7 +819,7 @@ class FirConverter : public AbstractConverter {
     }
   }
 
-  void genFIR(const Pa::ContinueStmt &) {}  // do nothing
+  void genFIR(const Pa::ContinueStmt &) {} // do nothing
   void genFIR(const Pa::DeallocateStmt &) { TODO(); }
   void genFIR(const Pa::EventPostStmt &) {
     // call some runtime routine
@@ -836,20 +842,21 @@ class FirConverter : public AbstractConverter {
   /// We do this by setting each pointer to null.
   void genFIR(const Pa::NullifyStmt &stmt) {
     for (auto &po : stmt.v) {
-      std::visit(Co::visitors{
-                     [&](const Pa::Name &sym) {
-                       auto ty{genType(*sym.symbol)};
-                       auto load{builder->create<fir::LoadOp>(toLocation(),
-                           localSymbols.lookupSymbol(*sym.symbol))};
-                       auto idxTy{M::IndexType::get(&mlirContext)};
-                       auto zero{builder->create<M::ConstantOp>(toLocation(),
-                           idxTy, builder->getIntegerAttr(idxTy, 0))};
-                       auto cast{builder->create<fir::ConvertOp>(
-                           toLocation(), ty, zero)};
-                       builder->create<fir::StoreOp>(toLocation(), cast, load);
-                     },
-                     [&](const Pa::StructureComponent &) { TODO(); },
-                 },
+      std::visit(
+          Co::visitors{
+              [&](const Pa::Name &sym) {
+                auto ty{genType(*sym.symbol)};
+                auto load{builder->create<fir::LoadOp>(
+                    toLocation(), localSymbols.lookupSymbol(*sym.symbol))};
+                auto idxTy{M::IndexType::get(&mlirContext)};
+                auto zero{builder->create<M::ConstantOp>(
+                    toLocation(), idxTy, builder->getIntegerAttr(idxTy, 0))};
+                auto cast{
+                    builder->create<fir::ConvertOp>(toLocation(), ty, zero)};
+                builder->create<fir::StoreOp>(toLocation(), cast, load);
+              },
+              [&](const Pa::StructureComponent &) { TODO(); },
+          },
           po.u);
     }
   }
@@ -889,7 +896,7 @@ class FirConverter : public AbstractConverter {
   // call FAIL IMAGE in runtime
   void genFIR(const Pa::FailImageStmt &stmt) {
     auto callee{genRuntimeFunction(FIRT_FAIL_IMAGE, 0)};
-    L::SmallVector<M::Value, 1> operands;  // FAIL IMAGE has no args
+    L::SmallVector<M::Value, 1> operands; // FAIL IMAGE has no args
     builder->create<M::CallOp>(toLocation(), callee, operands);
   }
 
@@ -897,7 +904,7 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::StopStmt &stm) {
     auto callee{
         genRuntimeFunction(isStopStmt(stm) ? FIRT_STOP : FIRT_ERROR_STOP,
-            defaults.GetDefaultKind(IntegerCat))};
+                           defaults.GetDefaultKind(IntegerCat))};
     // 2 args: stop-code-opt, quiet-opt
     L::SmallVector<M::Value, 8> operands;
     builder->create<M::CallOp>(toLocation(), callee, operands);
@@ -921,7 +928,7 @@ class FirConverter : public AbstractConverter {
   }
 
   // stubs for generic goto statements; see genFIREvalGoto()
-  void genFIR(const Pa::CycleStmt &) {}  // do nothing
+  void genFIR(const Pa::CycleStmt &) {} // do nothing
   void genFIR(const Pa::ExitStmt &) {}  // do nothing
   void genFIR(const Pa::GotoStmt &) {}  // do nothing
 
@@ -931,7 +938,7 @@ class FirConverter : public AbstractConverter {
                    [&](const auto *p) { genFIR(*p); },
                    [](const AST::CGJump &) { /* do nothing */ },
                },
-        eval.u);
+               eval.u);
   }
 
   /// Lower an Evaluation
@@ -945,18 +952,36 @@ class FirConverter : public AbstractConverter {
       // start a new block
     }
     switch (eval.cfg) {
-    case AST::CFGAnnotation::None: genFIREvalNone(eval); break;
-    case AST::CFGAnnotation::Goto: genFIREvalGoto(eval); break;
-    case AST::CFGAnnotation::CondGoto: genFIREvalCondGoto(eval); break;
-    case AST::CFGAnnotation::IndGoto: genFIREvalIndGoto(eval); break;
-    case AST::CFGAnnotation::IoSwitch: genFIREvalIoSwitch(eval); break;
-    case AST::CFGAnnotation::Switch: genFIREvalSwitch(eval); break;
-    case AST::CFGAnnotation::Iterative: genFIREvalIterative(eval); break;
+    case AST::CFGAnnotation::None:
+      genFIREvalNone(eval);
+      break;
+    case AST::CFGAnnotation::Goto:
+      genFIREvalGoto(eval);
+      break;
+    case AST::CFGAnnotation::CondGoto:
+      genFIREvalCondGoto(eval);
+      break;
+    case AST::CFGAnnotation::IndGoto:
+      genFIREvalIndGoto(eval);
+      break;
+    case AST::CFGAnnotation::IoSwitch:
+      genFIREvalIoSwitch(eval);
+      break;
+    case AST::CFGAnnotation::Switch:
+      genFIREvalSwitch(eval);
+      break;
+    case AST::CFGAnnotation::Iterative:
+      genFIREvalIterative(eval);
+      break;
     case AST::CFGAnnotation::FirStructuredOp:
       genFIREvalStructuredOp(eval);
       break;
-    case AST::CFGAnnotation::Return: genFIREvalReturn(eval); break;
-    case AST::CFGAnnotation::Terminate: genFIREvalTerminate(eval); break;
+    case AST::CFGAnnotation::Return:
+      genFIREvalReturn(eval);
+      break;
+    case AST::CFGAnnotation::Terminate:
+      genFIREvalTerminate(eval);
+      break;
     }
   }
 
@@ -971,7 +996,7 @@ class FirConverter : public AbstractConverter {
 
   /// Prepare to translate a new function
   void startNewFunction(AST::FunctionLikeUnit &funit, L::StringRef name,
-      const Se::Symbol *symbol) {
+                        const Se::Symbol *symbol) {
     M::FuncOp func{getNamedFunction(module, name)};
     if (!func) {
       func = createNewFunction(name, symbol);
@@ -988,11 +1013,11 @@ class FirConverter : public AbstractConverter {
       auto *details{symbol->detailsIf<Se::SubprogramDetails>()};
       assert(details && "details for semantics::Symbol must be subprogram");
       for (const auto &v :
-          L::zip(details->dummyArgs(), entryBlock->getArguments())) {
+           L::zip(details->dummyArgs(), entryBlock->getArguments())) {
         if (std::get<0>(v)) {
           localSymbols.addSymbol(*std::get<0>(v), std::get<1>(v));
         } else {
-          TODO();  // handle alternate return
+          TODO(); // handle alternate return
         }
       }
       if (details->isFunction()) {
@@ -1019,7 +1044,7 @@ class FirConverter : public AbstractConverter {
 
   /// Lower a procedure-like construct
   void lowerFunc(AST::FunctionLikeUnit &func, L::ArrayRef<L::StringRef> modules,
-      L::Optional<L::StringRef> host = {}) {
+                 L::Optional<L::StringRef> host = {}) {
     std::string name;
     const Se::Symbol *symbol{nullptr};
     auto size{func.funStmts.size()};
@@ -1027,8 +1052,8 @@ class FirConverter : public AbstractConverter {
     assert((size == 1 || size == 2) && "ill-formed subprogram");
     if (size == 2) {
       currentEvaluation = nullptr;
-      std::visit(
-          [&](auto *p) { genFIR(*p, name, symbol); }, func.funStmts.front());
+      std::visit([&](auto *p) { genFIR(*p, name, symbol); },
+                 func.funStmts.front());
     } else {
       name = uniquer.doProgramEntry();
     }
@@ -1040,8 +1065,8 @@ class FirConverter : public AbstractConverter {
       lowerEval(e);
     }
     currentEvaluation = nullptr;
-    std::visit(
-        [&](auto *p) { genFIR(*p, name, symbol); }, func.funStmts.back());
+    std::visit([&](auto *p) { genFIR(*p, name, symbol); },
+               func.funStmts.back());
 
     endNewFunction();
 
@@ -1115,7 +1140,7 @@ class FirConverter : public AbstractConverter {
   M::Location toLocation() { return toLocation(currentPosition); }
 
   // TODO: should these be moved to convert-expr?
-  template<M::CmpIPredicate ICMPOPC>
+  template <M::CmpIPredicate ICMPOPC>
   M::Value genCompare(M::Value lhs, M::Value rhs) {
     auto lty{lhs->getType()};
     assert(lty == rhs->getType());
@@ -1159,7 +1184,7 @@ class FirConverter : public AbstractConverter {
   Pa::CharBlock currentPosition;
   CFGMapType cfgMap;
   std::list<CFGSinkListType> cfgEdgeSetPool;
-  AST::Evaluation *currentEvaluation{nullptr};  // FIXME: this is a hack
+  AST::Evaluation *currentEvaluation{nullptr}; // FIXME: this is a hack
 
 public:
   FirConverter() = delete;
@@ -1168,11 +1193,11 @@ class FirConverter : public AbstractConverter {
   virtual ~FirConverter() = default;
 
   explicit FirConverter(BurnsideBridge &bridge, fir::NameUniquer &uniquer)
-    : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
-      module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
-      intrinsics{IntrinsicLibrary::create(
-          IntrinsicLibrary::Version::LLVM, bridge.getMLIRContext())},
-      uniquer{uniquer} {}
+      : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
+        module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
+        intrinsics{IntrinsicLibrary::create(IntrinsicLibrary::Version::LLVM,
+                                            bridge.getMLIRContext())},
+        uniquer{uniquer} {}
 
   /// Convert the AST to FIR
   void run(AST::Program &ast) {
@@ -1183,7 +1208,7 @@ class FirConverter : public AbstractConverter {
                      [&](AST::ModuleLikeUnit &m) { pruneMod(m); },
                      [](AST::BlockDataUnit &) { /* do nothing */ },
                  },
-          u);
+                 u);
     }
 
     // do translation
@@ -1193,7 +1218,7 @@ class FirConverter : public AbstractConverter {
                      [&](AST::ModuleLikeUnit &m) { lowerMod(m); },
                      [&](AST::BlockDataUnit &) { TODO(); },
                  },
-          u);
+                 u);
     }
   }
 
@@ -1204,12 +1229,12 @@ class FirConverter : public AbstractConverter {
   //
   // AbstractConverter overrides
 
-  M::Value genExprAddr(
-      const SomeExpr &expr, M::Location *loc = nullptr) override final {
+  M::Value genExprAddr(const SomeExpr &expr,
+                       M::Location *loc = nullptr) override final {
     return createFIRAddr(loc ? *loc : toLocation(), &expr);
   }
-  M::Value genExprValue(
-      const SomeExpr &expr, M::Location *loc = nullptr) override final {
+  M::Value genExprValue(const SomeExpr &expr,
+                        M::Location *loc = nullptr) override final {
     return createFIRExpr(loc ? *loc : toLocation(), &expr);
   }
 
@@ -1239,8 +1264,8 @@ class FirConverter : public AbstractConverter {
       if (loc.has_value()) {
         // loc is a pair (begin, end); use the beginning position
         auto &filePos{loc->first};
-        return M::FileLineColLoc::get(
-            filePos.file.path(), filePos.line, filePos.column, &mlirContext);
+        return M::FileLineColLoc::get(filePos.file.path(), filePos.line,
+                                      filePos.column, &mlirContext);
       }
     }
     return genLocation();
@@ -1254,10 +1279,10 @@ class FirConverter : public AbstractConverter {
   }
 };
 
-}  // namespace
+} // namespace
 
-void Br::BurnsideBridge::lower(
-    const Pa::Program &prg, fir::NameUniquer &uniquer) {
+void Br::BurnsideBridge::lower(const Pa::Program &prg,
+                               fir::NameUniquer &uniquer) {
   AST::Program *ast{Br::createAST(prg)};
   Br::annotateControl(*ast);
   if (ClDumpPreFir) {
@@ -1277,7 +1302,7 @@ void Br::BurnsideBridge::parseSourceFile(L::SourceMgr &srcMgr) {
 Br::BurnsideBridge::BurnsideBridge(
     const Co::IntrinsicTypeDefaultKinds &defaultKinds,
     const Pa::CookedSource *cooked)
-  : defaultKinds{defaultKinds}, cooked{cooked} {
+    : defaultKinds{defaultKinds}, cooked{cooked} {
   context = std::make_unique<M::MLIRContext>();
   module = std::make_unique<M::ModuleOp>(
       M::ModuleOp::create(M::UnknownLoc::get(context.get())));
diff --git a/lib/lower/bridge.h b/lib/lower/bridge.h
index eab05f4d0123..3272d5319aaf 100644
--- a/lib/lower/bridge.h
+++ b/lib/lower/bridge.h
@@ -22,27 +22,29 @@
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
-template<typename> class Reference;
-}
+template <typename>
+class Reference;
+} // namespace common
 namespace evaluate {
 struct DataRef;
-template<typename> class Expr;
+template <typename>
+class Expr;
 struct SomeType;
-}
+} // namespace evaluate
 namespace parser {
 class CharBlock;
 class CookedSource;
 struct Program;
-}
+} // namespace parser
 namespace semantics {
 class Symbol;
 }
-}  // namespace Fortran
+} // namespace Fortran
 
 namespace llvm {
 class Module;
 class SourceMgr;
-}
+} // namespace llvm
 namespace mlir {
 class OpBuilder;
 }
@@ -63,11 +65,11 @@ class AbstractConverter {
   // Expressions
 
   /// Generate the address of the location holding the expression
-  virtual mlir::Value genExprAddr(
-      const SomeExpr &, mlir::Location *loc = nullptr) = 0;
+  virtual mlir::Value genExprAddr(const SomeExpr &,
+                                  mlir::Location *loc = nullptr) = 0;
   /// Generate the computations of the expression to produce a value
-  virtual mlir::Value genExprValue(
-      const SomeExpr &, mlir::Location *loc = nullptr) = 0;
+  virtual mlir::Value genExprValue(const SomeExpr &,
+                                   mlir::Location *loc = nullptr) = 0;
 
   //
   // Types
@@ -108,9 +110,9 @@ class AbstractConverter {
 
 class BurnsideBridge {
 public:
-  static BurnsideBridge create(
-      const common::IntrinsicTypeDefaultKinds &defaultKinds,
-      const parser::CookedSource *cooked) {
+  static BurnsideBridge
+  create(const common::IntrinsicTypeDefaultKinds &defaultKinds,
+         const parser::CookedSource *cooked) {
     return BurnsideBridge{defaultKinds, cooked};
   }
 
@@ -132,7 +134,7 @@ class BurnsideBridge {
 
 private:
   explicit BurnsideBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
-      const parser::CookedSource *cooked);
+                          const parser::CookedSource *cooked);
   BurnsideBridge() = delete;
   BurnsideBridge(const BurnsideBridge &) = delete;
 
@@ -142,6 +144,6 @@ class BurnsideBridge {
   std::unique_ptr<mlir::ModuleOp> module;
 };
 
-}  // Fortran::lower
+} // namespace Fortran::lower
 
-#endif  // FORTRAN_LOWER_BRIDGE_H_
+#endif // FORTRAN_LOWER_BRIDGE_H_
diff --git a/lib/lower/builder.cc b/lib/lower/builder.cc
index 61ca189974bb..e73168d1ae72 100644
--- a/lib/lower/builder.cc
+++ b/lib/lower/builder.cc
@@ -9,10 +9,10 @@
 #include "builder.h"
 #include "bridge.h"
 #include "convert-type.h"
-#include "fir/FIROpsSupport.h"
-#include "llvm/ADT/StringRef.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Value.h"
+#include "optimizer/FIROpsSupport.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace B = Fortran::lower;
 namespace Ev = Fortran::evaluate;
@@ -23,15 +23,15 @@ using namespace Fortran;
 using namespace Fortran::lower;
 
 M::FuncOp B::createFunction(B::AbstractConverter &converter,
-    llvm::StringRef name, M::FunctionType funcTy) {
-  return fir::createFuncOp(
-      converter.getCurrentLocation(), converter.getModuleOp(), name, funcTy);
+                            llvm::StringRef name, M::FunctionType funcTy) {
+  return fir::createFuncOp(converter.getCurrentLocation(),
+                           converter.getModuleOp(), name, funcTy);
 }
 
-M::FuncOp B::createFunction(
-    M::ModuleOp module, llvm::StringRef name, M::FunctionType funcTy) {
-  return fir::createFuncOp(
-      M::UnknownLoc::get(module.getContext()), module, name, funcTy);
+M::FuncOp B::createFunction(M::ModuleOp module, llvm::StringRef name,
+                            M::FunctionType funcTy) {
+  return fir::createFuncOp(M::UnknownLoc::get(module.getContext()), module,
+                           name, funcTy);
 }
 
 M::FuncOp B::getNamedFunction(M::ModuleOp module, llvm::StringRef name) {
diff --git a/lib/lower/builder.h b/lib/lower/builder.h
index aa0cb78373fe..2d96e3462f4f 100644
--- a/lib/lower/builder.h
+++ b/lib/lower/builder.h
@@ -10,10 +10,10 @@
 #define FORTRAN_LOWER_BUILDER_H_
 
 #include "../semantics/symbol.h"
-#include "llvm/ADT/DenseMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
+#include "llvm/ADT/DenseMap.h"
 #include <string>
 
 namespace llvm {
@@ -84,14 +84,14 @@ mlir::FuncOp getNamedFunction(mlir::ModuleOp, llvm::StringRef name);
 
 /// Create a new FuncOp
 mlir::FuncOp createFunction(AbstractConverter &converter, llvm::StringRef name,
-    mlir::FunctionType funcTy);
+                            mlir::FunctionType funcTy);
 
 /// Create a new FuncOp
 /// The function is created with no Location information
-mlir::FuncOp createFunction(
-    mlir::ModuleOp module, llvm::StringRef name, mlir::FunctionType funcTy);
+mlir::FuncOp createFunction(mlir::ModuleOp module, llvm::StringRef name,
+                            mlir::FunctionType funcTy);
 
-}  // lower
-}  // Fortran
+} // namespace lower
+} // namespace Fortran
 
-#endif  // FORTRAN_LOWER_BUILDER_H_
+#endif // FORTRAN_LOWER_BUILDER_H_
diff --git a/lib/lower/cfg-builder.h b/lib/lower/cfg-builder.h
index cbae0da3a08e..1ab88c15a109 100644
--- a/lib/lower/cfg-builder.h
+++ b/lib/lower/cfg-builder.h
@@ -60,7 +60,7 @@ class CfgBuilder {
                      },
                      [](auto) { /* do nothing */ },
                  },
-          e.u);
+                 e.u);
       if (e.subs) {
         cacheAssigns(*e.subs);
       }
@@ -88,15 +88,24 @@ class CfgBuilder {
         return false;
       }
       switch (e.cfg) {
-      case AST::CFGAnnotation::None: break;
-      case AST::CFGAnnotation::CondGoto: break;
-      case AST::CFGAnnotation::Iterative: break;
-      case AST::CFGAnnotation::FirStructuredOp: break;
-      case AST::CFGAnnotation::IndGoto: return false;
-      case AST::CFGAnnotation::IoSwitch: return false;
-      case AST::CFGAnnotation::Switch: return false;
-      case AST::CFGAnnotation::Return: return false;
-      case AST::CFGAnnotation::Terminate: return false;
+      case AST::CFGAnnotation::None:
+        break;
+      case AST::CFGAnnotation::CondGoto:
+        break;
+      case AST::CFGAnnotation::Iterative:
+        break;
+      case AST::CFGAnnotation::FirStructuredOp:
+        break;
+      case AST::CFGAnnotation::IndGoto:
+        return false;
+      case AST::CFGAnnotation::IoSwitch:
+        return false;
+      case AST::CFGAnnotation::Switch:
+        return false;
+      case AST::CFGAnnotation::Return:
+        return false;
+      case AST::CFGAnnotation::Terminate:
+        return false;
       case AST::CFGAnnotation::Goto:
         if (!std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
           return false;
@@ -136,7 +145,7 @@ class CfgBuilder {
       cfgEdgeSetPool.emplace_back(std::move(sink));
       auto rc{cfgMap.try_emplace(src, &cfgEdgeSetPool.back())};
       assert(rc.second && "insert failed unexpectedly");
-      (void)rc;  // for release build
+      (void)rc; // for release build
       return;
     }
     for (auto *s : *iter->second)
@@ -153,7 +162,8 @@ class CfgBuilder {
   }
 
   /// Find the next ELSE IF, ELSE or END IF statement in the list
-  template<typename A> A nextFalseTarget(A iter, const A &endi) {
+  template <typename A>
+  A nextFalseTarget(A iter, const A &endi) {
     for (; iter != endi; ++iter)
       if (std::visit(Co::visitors{
                          [&](const Pa::ElseIfStmt *) { return true; },
@@ -161,7 +171,7 @@ class CfgBuilder {
                          [&](const Pa::EndIfStmt *) { return true; },
                          [](auto) { return false; },
                      },
-              iter->u)) {
+                     iter->u)) {
         break;
       }
     return iter;
@@ -170,9 +180,9 @@ class CfgBuilder {
   /// Add branches for this IF block like construct.
   /// Branch to the "true block", the "false block", and from the end of the
   /// true block to the end of the construct.
-  template<typename A>
+  template <typename A>
   void doNextIfBlock(std::list<AST::Evaluation> &evals, AST::Evaluation &e,
-      const A &iter, const A &endif) {
+                     const A &iter, const A &endif) {
     A i{iter};
     A j{nextFalseTarget(++i, endif)};
     auto *cstr = std::get<AST::Evaluation *>(e.parent);
@@ -244,24 +254,24 @@ class CfgBuilder {
                        [](const Pa::MaskedElsewhereStmt *) { TODO(); },
                        [](auto) { assert(false && "unhandled CGOTO case"); },
                    },
-            e.u);
+                   e.u);
         break;
       case AST::CFGAnnotation::IndGoto:
-        std::visit(
-            Co::visitors{
-                [&](const Pa::AssignedGotoStmt *stmt) {
-                  auto *sym = std::get<Pa::Name>(stmt->t).symbol;
-                  if (assignedGotoMap.find(sym) != assignedGotoMap.end())
-                    for (auto *x : assignedGotoMap[sym]) {
-                      addSourceToSink(&e, x);
-                    }
-                  for (auto &l : std::get<std::list<Pa::Label>>(stmt->t)) {
-                    addSourceToSink(&e, l);
-                  }
-                },
-                [](auto) { assert(false && "unhandled IGOTO case"); },
-            },
-            e.u);
+        std::visit(Co::visitors{
+                       [&](const Pa::AssignedGotoStmt *stmt) {
+                         auto *sym = std::get<Pa::Name>(stmt->t).symbol;
+                         if (assignedGotoMap.find(sym) != assignedGotoMap.end())
+                           for (auto *x : assignedGotoMap[sym]) {
+                             addSourceToSink(&e, x);
+                           }
+                         for (auto &l :
+                              std::get<std::list<Pa::Label>>(stmt->t)) {
+                           addSourceToSink(&e, l);
+                         }
+                       },
+                       [](auto) { assert(false && "unhandled IGOTO case"); },
+                   },
+                   e.u);
         break;
       case AST::CFGAnnotation::IoSwitch:
         std::visit(
@@ -290,7 +300,7 @@ class CfgBuilder {
                        [](const Pa::SelectTypeStmt *) { TODO(); },
                        [](auto) { assert(false && "unhandled switch case"); },
                    },
-            e.u);
+                   e.u);
         break;
       case AST::CFGAnnotation::Iterative:
         std::visit(Co::visitors{
@@ -301,7 +311,7 @@ class CfgBuilder {
                        [](const Pa::ForallConstructStmt *) { TODO(); },
                        [](auto) { assert(false && "unhandled loop case"); },
                    },
-            e.u);
+                   e.u);
         break;
       case AST::CFGAnnotation::FirStructuredOp:
         // do not visit the subs
@@ -334,7 +344,7 @@ class CfgBuilder {
 
 public:
   CfgBuilder(CFGMapType &m, std::list<CFGSinkListType> &p)
-    : cfgMap{m}, cfgEdgeSetPool{p} {}
+      : cfgMap{m}, cfgEdgeSetPool{p} {}
 
   void run(AST::FunctionLikeUnit &func) {
     resetPotentialTargets(func.evals);
@@ -345,4 +355,4 @@ class CfgBuilder {
   }
 };
 
-#endif  // FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
+#endif // FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
diff --git a/lib/lower/complex-handler.h b/lib/lower/complex-handler.h
index cc77d96c40c3..2b310eb9f5d1 100644
--- a/lib/lower/complex-handler.h
+++ b/lib/lower/complex-handler.h
@@ -12,8 +12,8 @@
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
 #include "convert-type.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/FIRType.h"
 
 namespace Fortran::lower {
 /// Provide helpers to generate Complex manipulations in FIR.
@@ -30,8 +30,8 @@ class ComplexHandler {
     return convertReal(builder.getContext(), complexKind);
   }
 
-  mlir::Value createComplex(
-      fir::KindTy kind, mlir::Value real, mlir::Value imag) {
+  mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
+                            mlir::Value imag) {
     mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
     mlir::Value und = builder.create<fir::UndefOp>(loc, complexTy);
     return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
@@ -46,29 +46,31 @@ class ComplexHandler {
     return getComplexPartType(cplx->getType());
   }
 
-  template<Part partId> mlir::Value extract(mlir::Value cplx) {
-    return builder.create<fir::ExtractValueOp>(
-        loc, getComplexPartType(cplx), cplx, getPartId<partId>());
+  template <Part partId>
+  mlir::Value extract(mlir::Value cplx) {
+    return builder.create<fir::ExtractValueOp>(loc, getComplexPartType(cplx),
+                                               cplx, getPartId<partId>());
   }
-  template<Part partId> mlir::Value insert(mlir::Value cplx, mlir::Value part) {
+  template <Part partId>
+  mlir::Value insert(mlir::Value cplx, mlir::Value part) {
     assert(cplx != nullptr);
-    return builder.create<fir::InsertValueOp>(
-        loc, cplx->getType(), cplx, part, getPartId<partId>());
+    return builder.create<fir::InsertValueOp>(loc, cplx->getType(), cplx, part,
+                                              getPartId<partId>());
   }
 
   /// Complex part access helper dynamic versions
   mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart) {
     return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
   }
-  mlir::Value insertComplexPart(
-      mlir::Value cplx, mlir::Value part, bool isImagPart) {
+  mlir::Value insertComplexPart(mlir::Value cplx, mlir::Value part,
+                                bool isImagPart) {
     return isImagPart ? insert<Part::Imag>(cplx, part)
                       : insert<Part::Real>(cplx, part);
   }
 
   // Complex operation helpers
-  mlir::Value createComplexCompare(
-      mlir::Value cplx1, mlir::Value cplx2, bool eq) {
+  mlir::Value createComplexCompare(mlir::Value cplx1, mlir::Value cplx2,
+                                   bool eq) {
     mlir::Value real1 = extract<Part::Real>(cplx1);
     mlir::Value real2 = extract<Part::Real>(cplx2);
     mlir::Value imag1 = extract<Part::Imag>(cplx1);
@@ -88,7 +90,8 @@ class ComplexHandler {
 
 private:
   // Make mlir ConstantOp from template part id.
-  template<Part partId> inline mlir::Value getPartId() {
+  template <Part partId>
+  inline mlir::Value getPartId() {
     auto type = mlir::IntegerType::get(32, builder.getContext());
     auto attr = builder.getIntegerAttr(type, static_cast<int>(partId));
     return builder.create<mlir::ConstantOp>(loc, type, attr).getResult();
@@ -98,5 +101,5 @@ class ComplexHandler {
   mlir::Location loc;
 };
 
-}
-#endif  // FORTRAN_LOWER_COMPLEX_HANDLER_H_
+} // namespace Fortran::lower
+#endif // FORTRAN_LOWER_COMPLEX_HANDLER_H_
diff --git a/lib/lower/convert-expr.cc b/lib/lower/convert-expr.cc
index da1ed79b8189..03012217f0fb 100644
--- a/lib/lower/convert-expr.cc
+++ b/lib/lower/convert-expr.cc
@@ -7,11 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "convert-expr.h"
-#include "bridge.h"
-#include "builder.h"
-#include "complex-handler.h"
-#include "convert-type.h"
-#include "runtime.h"
 #include "../common/default-kinds.h"
 #include "../common/unwrap.h"
 #include "../evaluate/fold.h"
@@ -19,13 +14,10 @@
 #include "../semantics/expression.h"
 #include "../semantics/symbol.h"
 #include "../semantics/type.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/IR/Type.h"
-#include "llvm/Support/raw_ostream.h"
+#include "bridge.h"
+#include "builder.h"
+#include "complex-handler.h"
+#include "convert-type.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
@@ -36,6 +28,14 @@
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/FIRType.h"
+#include "runtime.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
@@ -50,8 +50,8 @@ using namespace Fortran::lower;
 
 namespace {
 
-#define TODO() \
-  assert(false); \
+#define TODO()                                                                 \
+  assert(false);                                                               \
   return {}
 
 /// Lowering of Fortran::evaluate::Expr<T> expressions
@@ -73,12 +73,18 @@ class ExprLowering {
   /// unordered, but we may want to cons ordered in certain situation.
   static M::CmpIPredicate translateRelational(Co::RelationalOperator rop) {
     switch (rop) {
-    case Co::RelationalOperator::LT: return M::CmpIPredicate::slt;
-    case Co::RelationalOperator::LE: return M::CmpIPredicate::sle;
-    case Co::RelationalOperator::EQ: return M::CmpIPredicate::eq;
-    case Co::RelationalOperator::NE: return M::CmpIPredicate::ne;
-    case Co::RelationalOperator::GT: return M::CmpIPredicate::sgt;
-    case Co::RelationalOperator::GE: return M::CmpIPredicate::sge;
+    case Co::RelationalOperator::LT:
+      return M::CmpIPredicate::slt;
+    case Co::RelationalOperator::LE:
+      return M::CmpIPredicate::sle;
+    case Co::RelationalOperator::EQ:
+      return M::CmpIPredicate::eq;
+    case Co::RelationalOperator::NE:
+      return M::CmpIPredicate::ne;
+    case Co::RelationalOperator::GT:
+      return M::CmpIPredicate::sgt;
+    case Co::RelationalOperator::GE:
+      return M::CmpIPredicate::sge;
     }
     assert(false && "unhandled INTEGER relational operator");
     return {};
@@ -92,22 +98,28 @@ class ExprLowering {
   /// FIXME: The signaling/quiet aspect of the table 17.1 requirement is not
   /// fully enforced. FIR and LLVM `fcmp` instructions do not give any guarantee
   /// whether the comparison will signal or not in case of quiet NaN argument.
-  static fir::CmpFPredicate translateFloatRelational(
-      Co::RelationalOperator rop) {
+  static fir::CmpFPredicate
+  translateFloatRelational(Co::RelationalOperator rop) {
     switch (rop) {
-    case Co::RelationalOperator::LT: return fir::CmpFPredicate::OLT;
-    case Co::RelationalOperator::LE: return fir::CmpFPredicate::OLE;
-    case Co::RelationalOperator::EQ: return fir::CmpFPredicate::OEQ;
-    case Co::RelationalOperator::NE: return fir::CmpFPredicate::UNE;
-    case Co::RelationalOperator::GT: return fir::CmpFPredicate::OGT;
-    case Co::RelationalOperator::GE: return fir::CmpFPredicate::OGE;
+    case Co::RelationalOperator::LT:
+      return fir::CmpFPredicate::OLT;
+    case Co::RelationalOperator::LE:
+      return fir::CmpFPredicate::OLE;
+    case Co::RelationalOperator::EQ:
+      return fir::CmpFPredicate::OEQ;
+    case Co::RelationalOperator::NE:
+      return fir::CmpFPredicate::UNE;
+    case Co::RelationalOperator::GT:
+      return fir::CmpFPredicate::OGT;
+    case Co::RelationalOperator::GE:
+      return fir::CmpFPredicate::OGE;
     }
     assert(false && "unhandled REAL relational operator");
     return {};
   }
 
   /// Generate an integral constant of `value`
-  template<int KIND>
+  template <int KIND>
   M::Value genIntegerConstant(M::MLIRContext *context, std::int64_t value) {
     M::Type type{converter.genType(IntegerCat, KIND)};
     auto attr{builder.getIntegerAttr(type, value)};
@@ -122,7 +134,7 @@ class ExprLowering {
     return builder.create<M::ConstantOp>(getLoc(), i1Type, attr).getResult();
   }
 
-  template<int KIND>
+  template <int KIND>
   M::Value genRealConstant(M::MLIRContext *context, L::APFloat const &value) {
     M::Type fltTy{convertReal(context, KIND)};
     auto attr{builder.getFloatAttr(fltTy, value)};
@@ -134,17 +146,18 @@ class ExprLowering {
     return M::IndexType::get(builder.getContext());
   }
 
-  template<typename OpTy, typename A>
+  template <typename OpTy, typename A>
   M::Value createBinaryOp(A const &ex, M::Value lhs, M::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), lhs, rhs);
     return x.getResult();
   }
-  template<typename OpTy, typename A>
+  template <typename OpTy, typename A>
   M::Value createBinaryOp(A const &ex, M::Value rhs) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), rhs);
   }
-  template<typename OpTy, typename A> M::Value createBinaryOp(A const &ex) {
+  template <typename OpTy, typename A>
+  M::Value createBinaryOp(A const &ex) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), genval(ex.right()));
   }
 
@@ -152,7 +165,7 @@ class ExprLowering {
     auto module{getModule(&builder)};
     if (M::FuncOp func{getNamedFunction(module, name)}) {
       assert(func.getType() == funTy &&
-          "function already declared with a different type");
+             "function already declared with a different type");
       return func;
     }
     return createFunction(module, name, funTy);
@@ -164,7 +177,8 @@ class ExprLowering {
   }
 
   // FIXME binary operation :: ('a, 'a) -> 'a
-  template<Co::TypeCategory TC, int KIND> M::FunctionType createFunctionType() {
+  template <Co::TypeCategory TC, int KIND>
+  M::FunctionType createFunctionType() {
     if constexpr (TC == IntegerCat) {
       M::Type output{converter.genType(IntegerCat, KIND)};
       L::SmallVector<M::Type, 2> inputs;
@@ -184,7 +198,7 @@ class ExprLowering {
   }
 
   /// Create a call to a Fortran runtime entry point
-  template<Co::TypeCategory TC, int KIND, typename A>
+  template <Co::TypeCategory TC, int KIND, typename A>
   M::Value createBinaryFIRTCall(A const &ex, RuntimeEntryCode callee) {
     L::SmallVector<M::Value, 2> operands;
     operands.push_back(genval(ex.left()));
@@ -192,38 +206,38 @@ class ExprLowering {
     M::FunctionType funTy = createFunctionType<TC, KIND>();
     auto func{getRuntimeFunction(callee, funTy)};
     auto x{builder.create<M::CallOp>(getLoc(), func, operands)};
-    return x.getResult(0);  // FIXME
+    return x.getResult(0); // FIXME
   }
 
-  template<typename OpTy, typename A>
-  M::Value createCompareOp(
-      A const &ex, M::CmpIPredicate pred, M::Value lhs, M::Value rhs) {
+  template <typename OpTy, typename A>
+  M::Value createCompareOp(A const &ex, M::CmpIPredicate pred, M::Value lhs,
+                           M::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
-  template<typename OpTy, typename A>
+  template <typename OpTy, typename A>
   M::Value createCompareOp(A const &ex, M::CmpIPredicate pred) {
-    return createCompareOp<OpTy>(
-        ex, pred, genval(ex.left()), genval(ex.right()));
+    return createCompareOp<OpTy>(ex, pred, genval(ex.left()),
+                                 genval(ex.right()));
   }
-  template<typename OpTy, typename A>
-  M::Value createFltCmpOp(
-      A const &ex, fir::CmpFPredicate pred, M::Value lhs, M::Value rhs) {
+  template <typename OpTy, typename A>
+  M::Value createFltCmpOp(A const &ex, fir::CmpFPredicate pred, M::Value lhs,
+                          M::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
-  template<typename OpTy, typename A>
+  template <typename OpTy, typename A>
   M::Value createFltCmpOp(A const &ex, fir::CmpFPredicate pred) {
-    return createFltCmpOp<OpTy>(
-        ex, pred, genval(ex.left()), genval(ex.right()));
+    return createFltCmpOp<OpTy>(ex, pred, genval(ex.left()),
+                                genval(ex.right()));
   }
 
   M::Value gen(Se::SymbolRef sym) {
     // FIXME: not all symbols are local
-    M::Value addr = createTemporary(
-        getLoc(), builder, symMap, converter.genType(sym), &*sym);
+    M::Value addr = createTemporary(getLoc(), builder, symMap,
+                                    converter.genType(sym), &*sym);
     assert(addr && "failed generating symbol address");
     // Get address from descriptor if symbol has one.
     auto type{addr->getType()};
@@ -267,16 +281,18 @@ class ExprLowering {
   M::Value genval(Ev::StructureConstructor const &) { TODO(); }
   M::Value genval(Ev::ImpliedDoIndex const &) { TODO(); }
   M::Value genval(Ev::DescriptorInquiry const &) { TODO(); }
-  template<int KIND> M::Value genval(Ev::TypeParamInquiry<KIND> const &) {
+  template <int KIND>
+  M::Value genval(Ev::TypeParamInquiry<KIND> const &) {
     TODO();
   }
 
-  template<int KIND> M::Value genval(Ev::ComplexComponent<KIND> const &part) {
+  template <int KIND>
+  M::Value genval(Ev::ComplexComponent<KIND> const &part) {
     return ComplexHandler{builder, getLoc()}.extractComplexPart(
         genval(part.left()), part.isImaginaryPart);
   }
 
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Negate<Ev::Type<TC, KIND>> const &op) {
     auto input{genval(op.left())};
     if constexpr (TC == IntegerCat) {
@@ -291,7 +307,7 @@ class ExprLowering {
     }
   }
 
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Add<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::AddIOp>(op);
@@ -302,7 +318,7 @@ class ExprLowering {
       return createBinaryOp<fir::AddcOp>(op);
     }
   }
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Subtract<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::SubIOp>(op);
@@ -313,7 +329,7 @@ class ExprLowering {
       return createBinaryOp<fir::SubcOp>(op);
     }
   }
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Multiply<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::MulIOp>(op);
@@ -324,7 +340,7 @@ class ExprLowering {
       return createBinaryOp<fir::MulcOp>(op);
     }
   }
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Divide<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryOp<M::SignedDivIOp>(op);
@@ -335,34 +351,36 @@ class ExprLowering {
       return createBinaryOp<fir::DivcOp>(op);
     }
   }
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Power<Ev::Type<TC, KIND>> const &op) {
-    llvm::SmallVector<mlir::Value, 2> operands{
-        genval(op.left()), genval(op.right())};
+    llvm::SmallVector<mlir::Value, 2> operands{genval(op.left()),
+                                               genval(op.right())};
     M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::RealToIntPower<Ev::Type<TC, KIND>> const &op) {
     // TODO: runtime as limited integer kind support. Look if the conversions
     // are ok
-    llvm::SmallVector<mlir::Value, 2> operands{
-        genval(op.left()), genval(op.right())};
+    llvm::SmallVector<mlir::Value, 2> operands{genval(op.left()),
+                                               genval(op.right())};
     M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
 
-  template<int KIND> M::Value genval(Ev::ComplexConstructor<KIND> const &op) {
+  template <int KIND>
+  M::Value genval(Ev::ComplexConstructor<KIND> const &op) {
     return ComplexHandler{builder, getLoc()}.createComplex(
         KIND, genval(op.left()), genval(op.right()));
   }
-  template<int KIND> M::Value genval(Ev::Concat<KIND> const &op) {
+  template <int KIND>
+  M::Value genval(Ev::Concat<KIND> const &op) {
     // TODO this is a bogus call
     return createBinaryFIRTCall<CharacterCat, KIND>(op, FIRT_CONCAT);
   }
 
   /// MIN and MAX operations
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Extremum<Ev::Type<TC, KIND>> const &op) {
     if constexpr (TC == IntegerCat) {
       return createBinaryFIRTCall<TC, KIND>(
@@ -372,9 +390,12 @@ class ExprLowering {
     }
   }
 
-  template<int KIND> M::Value genval(Ev::SetLength<KIND> const &) { TODO(); }
+  template <int KIND>
+  M::Value genval(Ev::SetLength<KIND> const &) {
+    TODO();
+  }
 
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Relational<Ev::Type<TC, KIND>> const &op) {
     mlir::Value result{nullptr};
     if constexpr (TC == IntegerCat) {
@@ -384,9 +405,8 @@ class ExprLowering {
           createFltCmpOp<fir::CmpfOp>(op, translateFloatRelational(op.opr));
     } else if constexpr (TC == ComplexCat) {
       bool eq{op.opr == Co::RelationalOperator::EQ};
-      assert(eq ||
-          op.opr == Co::RelationalOperator::NE &&
-              "relation undefined for complex");
+      assert(eq || op.opr == Co::RelationalOperator::NE &&
+                       "relation undefined for complex");
       result = ComplexHandler{builder, getLoc()}.createComplexCompare(
           genval(op.left()), genval(op.right()), eq);
     } else {
@@ -400,7 +420,7 @@ class ExprLowering {
     return std::visit([&](const auto &x) { return genval(x); }, op.u);
   }
 
-  template<Co::TypeCategory TC1, int KIND, Co::TypeCategory TC2>
+  template <Co::TypeCategory TC1, int KIND, Co::TypeCategory TC2>
   M::Value genval(Ev::Convert<Ev::Type<TC1, KIND>, TC2> const &convert) {
     auto ty{converter.genType(TC1, KIND)};
     M::Value operand{genval(convert.left())};
@@ -412,9 +432,13 @@ class ExprLowering {
     return builder.create<fir::ConvertOp>(getLoc(), ty, operand);
   }
 
-  template<typename A> M::Value genval(Ev::Parentheses<A> const &) { TODO(); }
+  template <typename A>
+  M::Value genval(Ev::Parentheses<A> const &) {
+    TODO();
+  }
 
-  template<int KIND> M::Value genval(const Ev::Not<KIND> &op) {
+  template <int KIND>
+  M::Value genval(const Ev::Not<KIND> &op) {
     // Request operands to be generated as `i1` and restore after this scope.
     auto restorer{common::ScopedSet(genLogicalAsI1, true)};
     auto *context{builder.getContext()};
@@ -423,13 +447,18 @@ class ExprLowering {
     return builder.create<M::XOrOp>(getLoc(), logical, one).getResult();
   }
 
-  template<int KIND> M::Value genval(Ev::LogicalOperation<KIND> const &op) {
+  template <int KIND>
+  M::Value genval(Ev::LogicalOperation<KIND> const &op) {
     // Request operands to be generated as `i1` and restore after this scope.
     auto restorer{common::ScopedSet(genLogicalAsI1, true)};
     mlir::Value result;
     switch (op.logicalOperator) {
-    case Ev::LogicalOperator::And: result = createBinaryOp<M::AndOp>(op); break;
-    case Ev::LogicalOperator::Or: result = createBinaryOp<M::OrOp>(op); break;
+    case Ev::LogicalOperator::And:
+      result = createBinaryOp<M::AndOp>(op);
+      break;
+    case Ev::LogicalOperator::Or:
+      result = createBinaryOp<M::OrOp>(op);
+      break;
     case Ev::LogicalOperator::Eqv:
       result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::eq);
       break;
@@ -447,7 +476,7 @@ class ExprLowering {
     return result;
   }
 
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Constant<Ev::Type<TC, KIND>> const &con) {
     // TODO:
     // - character type constant
@@ -505,7 +534,7 @@ class ExprLowering {
     }
   }
 
-  template<Co::TypeCategory TC>
+  template <Co::TypeCategory TC>
   M::Value genval(Ev::Constant<Ev::SomeKind<TC>> const &con) {
     if constexpr (TC == IntegerCat) {
       auto opt = (*con).ToInt64();
@@ -519,7 +548,8 @@ class ExprLowering {
     }
   }
 
-  template<typename A> M::Value genval(Ev::ArrayConstructor<A> const &) {
+  template <typename A>
+  M::Value genval(Ev::ArrayConstructor<A> const &) {
     TODO();
   }
   M::Value gen(Ev::ComplexPart const &) { TODO(); }
@@ -537,7 +567,7 @@ class ExprLowering {
                           },
                           [&](const Ev::Triplet &x) { return genval(x); },
                       },
-        subs.u);
+                      subs.u);
   }
 
   M::Value gen(const Ev::DataRef &dref) {
@@ -550,8 +580,9 @@ class ExprLowering {
 
   // Helper function to turn the left-recursive Component structure into a list.
   // Returns the object used as the base coordinate for the component chain.
-  static Ev::DataRef const *reverseComponents(
-      Ev::Component const &cmpt, std::list<Ev::Component const *> &list) {
+  static Ev::DataRef const *
+  reverseComponents(Ev::Component const &cmpt,
+                    std::list<Ev::Component const *> &list) {
     list.push_front(&cmpt);
     return std::visit(
         Co::visitors{
@@ -634,27 +665,33 @@ class ExprLowering {
     return builder.create<fir::LoadOp>(getLoc(), gen(coref));
   }
 
-  template<typename A> M::Value gen(Ev::Designator<A> const &des) {
+  template <typename A>
+  M::Value gen(Ev::Designator<A> const &des) {
     return std::visit([&](const auto &x) { return gen(x); }, des.u);
   }
-  template<typename A> M::Value gendef(Ev::Designator<A> const &des) {
+  template <typename A>
+  M::Value gendef(Ev::Designator<A> const &des) {
     return gen(des);
   }
-  template<typename A> M::Value genval(Ev::Designator<A> const &des) {
+  template <typename A>
+  M::Value genval(Ev::Designator<A> const &des) {
     return std::visit([&](const auto &x) { return genval(x); }, des.u);
   }
 
   // call a function
-  template<typename A> M::Value gen(const Ev::FunctionRef<A> &funRef) {
+  template <typename A>
+  M::Value gen(const Ev::FunctionRef<A> &funRef) {
     TODO();
   }
-  template<typename A> M::Value gendef(const Ev::FunctionRef<A> &funRef) {
+  template <typename A>
+  M::Value gendef(const Ev::FunctionRef<A> &funRef) {
     return gen(funRef);
   }
-  template<typename A> M::Value genval(const Ev::FunctionRef<A> &funRef) {
-    TODO();  // Derived type functions (user + intrinsics)
+  template <typename A>
+  M::Value genval(const Ev::FunctionRef<A> &funRef) {
+    TODO(); // Derived type functions (user + intrinsics)
   }
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Value genval(const Ev::FunctionRef<Ev::Type<TC, KIND>> &funRef) {
     if (const auto &intrinsic{funRef.proc().GetSpecificIntrinsic()}) {
       M::Type ty{converter.genType(TC, KIND)};
@@ -670,7 +707,7 @@ class ExprLowering {
         if (auto *expr{Ev::UnwrapExpr<Ev::Expr<Ev::SomeType>>(arg)}) {
           operands.push_back(genval(*expr));
         } else {
-          operands.push_back(nullptr);  // optional
+          operands.push_back(nullptr); // optional
         }
       }
       // Let the intrinsic library lower the intrinsic function call
@@ -685,8 +722,8 @@ class ExprLowering {
       // and not `i1`.
       auto restorer{common::ScopedSet(genLogicalAsI1, false)};
       for (const auto &arg : funRef.arguments()) {
-        assert(
-            arg.has_value() && "optional argument requires explicit interface");
+        assert(arg.has_value() &&
+               "optional argument requires explicit interface");
         const auto *expr{arg->UnwrapExpr()};
         assert(expr && "assumed type argument requires explicit interface");
         if (const Se::Symbol * sym{Ev::UnwrapWholeSymbolDataRef(*expr)}) {
@@ -707,23 +744,26 @@ class ExprLowering {
       // For now, Fortran return value are implemented with a single MLIR
       // function return value.
       assert(call.getNumResults() == 1 &&
-          "Expected exactly one result in FUNCTION call");
+             "Expected exactly one result in FUNCTION call");
       return call.getResult(0);
     }
   }
 
-  template<typename A> M::Value gen(const Ev::Expr<A> &exp) {
+  template <typename A>
+  M::Value gen(const Ev::Expr<A> &exp) {
     // must be a designator or function-reference (R902)
     return std::visit([&](const auto &e) { return gendef(e); }, exp.u);
   }
-  template<typename A> M::Value gendef(Ev::Expr<A> const &exp) {
+  template <typename A>
+  M::Value gendef(Ev::Expr<A> const &exp) {
     return gen(exp);
   }
-  template<typename A> M::Value genval(Ev::Expr<A> const &exp) {
+  template <typename A>
+  M::Value genval(Ev::Expr<A> const &exp) {
     return std::visit([&](const auto &e) { return genval(e); }, exp.u);
   }
 
-  template<int KIND>
+  template <int KIND>
   M::Value genval(Ev::Expr<Ev::Type<LogicalCat, KIND>> const &exp) {
     auto result{std::visit([&](const auto &e) { return genval(e); }, exp.u)};
     // Handle the `i1` to `fir.logical` conversions as needed.
@@ -751,7 +791,8 @@ class ExprLowering {
     return result;
   }
 
-  template<typename A> M::Value gendef(const A &) {
+  template <typename A>
+  M::Value gendef(const A &) {
     assert(false && "expression error");
     return {};
   }
@@ -761,46 +802,53 @@ class ExprLowering {
       return converter.mangleName(*symbol);
     // Do not mangle intrinsic for now
     assert(proc.GetSpecificIntrinsic() &&
-        "expected intrinsic procedure in designator");
+           "expected intrinsic procedure in designator");
     return proc.GetName();
   }
 
 public:
   explicit ExprLowering(M::Location loc, AbstractConverter &converter,
-      SomeExpr const &vop, SymMap &map, IntrinsicLibrary const &intr,
-      bool logicalAsI1 = false)
-    : location{loc}, converter{converter}, builder{converter.getOpBuilder()},
-      expr{vop}, symMap{map}, intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
+                        SomeExpr const &vop, SymMap &map,
+                        IntrinsicLibrary const &intr, bool logicalAsI1 = false)
+      : location{loc}, converter{converter}, builder{converter.getOpBuilder()},
+        expr{vop}, symMap{map}, intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
 
   /// Lower the expression `expr` into MLIR standard dialect
   M::Value gen() { return gen(expr); }
   M::Value genval() { return genval(expr); }
 };
 
-}  // namespace
+} // namespace
 
 M::Value Br::createSomeExpression(M::Location loc,
-    Br::AbstractConverter &converter, const Ev::Expr<Ev::SomeType> &expr,
-    SymMap &symMap, const IntrinsicLibrary &intrinsics) {
+                                  Br::AbstractConverter &converter,
+                                  const Ev::Expr<Ev::SomeType> &expr,
+                                  SymMap &symMap,
+                                  const IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics, false}.genval();
 }
 
 M::Value Br::createI1LogicalExpression(M::Location loc,
-    Br::AbstractConverter &converter, const Ev::Expr<Ev::SomeType> &expr,
-    SymMap &symMap, const IntrinsicLibrary &intrinsics) {
+                                       Br::AbstractConverter &converter,
+                                       const Ev::Expr<Ev::SomeType> &expr,
+                                       SymMap &symMap,
+                                       const IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics, true}.genval();
 }
 
 M::Value Br::createSomeAddress(M::Location loc,
-    Br::AbstractConverter &converter, const Ev::Expr<Ev::SomeType> &expr,
-    SymMap &symMap, const IntrinsicLibrary &intrinsics) {
+                               Br::AbstractConverter &converter,
+                               const Ev::Expr<Ev::SomeType> &expr,
+                               SymMap &symMap,
+                               const IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics}.gen();
 }
 
 /// Create a temporary variable
 /// `symbol` will be nullptr for an anonymous temporary
 M::Value Br::createTemporary(M::Location loc, M::OpBuilder &builder,
-    SymMap &symMap, M::Type type, const Se::Symbol *symbol) {
+                             SymMap &symMap, M::Type type,
+                             const Se::Symbol *symbol) {
   if (symbol)
     if (auto val = symMap.lookupSymbol(*symbol)) {
       if (auto op = val->getDefiningOp()) {
diff --git a/lib/lower/convert-expr.h b/lib/lower/convert-expr.h
index e02d26593826..8ca0a7c77b00 100644
--- a/lib/lower/convert-expr.h
+++ b/lib/lower/convert-expr.h
@@ -18,25 +18,26 @@ class Location;
 class OpBuilder;
 class Type;
 class Value;
-}  // mlir
+} // namespace mlir
 
 namespace fir {
 class AllocaExpr;
-}  // fir
+} // namespace fir
 
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
-}  //  common
+} // namespace common
 
 namespace evaluate {
-template<typename> class Expr;
-class SomeType;
-}  // evaluate
+template <typename>
+class Expr;
+struct SomeType;
+} // namespace evaluate
 
 namespace semantics {
 class Symbol;
-}  // semantics
+} // namespace semantics
 
 namespace lower {
 
@@ -44,23 +45,26 @@ class AbstractConverter;
 class SymMap;
 
 mlir::Value createSomeExpression(mlir::Location loc,
-    AbstractConverter &converter,
-    const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
-    const IntrinsicLibrary &intrinsics);
+                                 AbstractConverter &converter,
+                                 const evaluate::Expr<evaluate::SomeType> &expr,
+                                 SymMap &symMap,
+                                 const IntrinsicLibrary &intrinsics);
 
-mlir::Value createI1LogicalExpression(mlir::Location loc,
-    AbstractConverter &converter,
-    const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
-    const IntrinsicLibrary &intrinsics);
+mlir::Value
+createI1LogicalExpression(mlir::Location loc, AbstractConverter &converter,
+                          const evaluate::Expr<evaluate::SomeType> &expr,
+                          SymMap &symMap, const IntrinsicLibrary &intrinsics);
 
 mlir::Value createSomeAddress(mlir::Location loc, AbstractConverter &converter,
-    const evaluate::Expr<evaluate::SomeType> &expr, SymMap &symMap,
-    const IntrinsicLibrary &intrinsics);
+                              const evaluate::Expr<evaluate::SomeType> &expr,
+                              SymMap &symMap,
+                              const IntrinsicLibrary &intrinsics);
 
 mlir::Value createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
-    SymMap &symMap, mlir::Type type, const semantics::Symbol *symbol);
+                            SymMap &symMap, mlir::Type type,
+                            const semantics::Symbol *symbol);
 
-}  // lower
-}  // Fortran
+} // namespace lower
+} // namespace Fortran
 
-#endif  // FORTRAN_LOWER_CONVERT_EXPR_H_
+#endif // FORTRAN_LOWER_CONVERT_EXPR_H_
diff --git a/lib/lower/convert-type.cc b/lib/lower/convert-type.cc
index 3ec61b744a7c..f44bcebedc37 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -13,15 +13,15 @@
 // limitations under the License.
 
 #include "convert-type.h"
-#include "bridge.h"
 #include "../semantics/expression.h"
 #include "../semantics/tools.h"
 #include "../semantics/type.h"
-#include "fir/FIRType.h"
+#include "bridge.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
+#include "optimizer/FIRType.h"
 
 namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
@@ -35,106 +35,131 @@ using namespace Fortran::lower;
 
 namespace {
 
-template<typename A> bool isConstant(const Ev::Expr<A> &e) {
+template <typename A>
+bool isConstant(const Ev::Expr<A> &e) {
   return Ev::IsConstantExpr(SomeExpr{e});
 }
 
-template<typename A> int64_t toConstant(const Ev::Expr<A> &e) {
+template <typename A>
+int64_t toConstant(const Ev::Expr<A> &e) {
   auto opt = Ev::ToInt64(e);
   assert(opt.has_value() && "expression didn't resolve to a constant");
   return opt.value();
 }
 
 #undef TODO
-#define TODO() \
-  assert(false && "not yet implemented"); \
+#define TODO()                                                                 \
+  assert(false && "not yet implemented");                                      \
   return {}
 
 // one argument template, must be specialized
-template<Co::TypeCategory TC> M::Type genFIRType(M::MLIRContext *, int) {
+template <Co::TypeCategory TC>
+M::Type genFIRType(M::MLIRContext *, int) {
   return {};
 }
 
 // two argument template
-template<Co::TypeCategory TC, int KIND>
+template <Co::TypeCategory TC, int KIND>
 M::Type genFIRType(M::MLIRContext *context) {
   if constexpr (TC == IntegerCat) {
     auto bits{Ev::Type<IntegerCat, KIND>::Scalar::bits};
     return M::IntegerType::get(bits, context);
   } else if constexpr (TC == LogicalCat || TC == CharacterCat ||
-      TC == ComplexCat) {
+                       TC == ComplexCat) {
     return genFIRType<TC>(context, KIND);
   } else {
     return {};
   }
 }
 
-template<> M::Type genFIRType<RealCat, 2>(M::MLIRContext *context) {
+template <>
+M::Type genFIRType<RealCat, 2>(M::MLIRContext *context) {
   return M::FloatType::getF16(context);
 }
 
-template<> M::Type genFIRType<RealCat, 3>(M::MLIRContext *context) {
+template <>
+M::Type genFIRType<RealCat, 3>(M::MLIRContext *context) {
   return M::FloatType::getBF16(context);
 }
 
-template<> M::Type genFIRType<RealCat, 4>(M::MLIRContext *context) {
+template <>
+M::Type genFIRType<RealCat, 4>(M::MLIRContext *context) {
   return M::FloatType::getF32(context);
 }
 
-template<> M::Type genFIRType<RealCat, 8>(M::MLIRContext *context) {
+template <>
+M::Type genFIRType<RealCat, 8>(M::MLIRContext *context) {
   return M::FloatType::getF64(context);
 }
 
-template<> M::Type genFIRType<RealCat, 10>(M::MLIRContext *context) {
+template <>
+M::Type genFIRType<RealCat, 10>(M::MLIRContext *context) {
   return fir::RealType::get(context, 10);
 }
 
-template<> M::Type genFIRType<RealCat, 16>(M::MLIRContext *context) {
+template <>
+M::Type genFIRType<RealCat, 16>(M::MLIRContext *context) {
   return fir::RealType::get(context, 16);
 }
 
-template<> M::Type genFIRType<RealCat>(M::MLIRContext *context, int kind) {
+template <>
+M::Type genFIRType<RealCat>(M::MLIRContext *context, int kind) {
   if (Ev::IsValidKindOfIntrinsicType(RealCat, kind)) {
     switch (kind) {
-    case 2: return genFIRType<RealCat, 2>(context);
-    case 3: return genFIRType<RealCat, 3>(context);
-    case 4: return genFIRType<RealCat, 4>(context);
-    case 8: return genFIRType<RealCat, 8>(context);
-    case 10: return genFIRType<RealCat, 10>(context);
-    case 16: return genFIRType<RealCat, 16>(context);
+    case 2:
+      return genFIRType<RealCat, 2>(context);
+    case 3:
+      return genFIRType<RealCat, 3>(context);
+    case 4:
+      return genFIRType<RealCat, 4>(context);
+    case 8:
+      return genFIRType<RealCat, 8>(context);
+    case 10:
+      return genFIRType<RealCat, 10>(context);
+    case 16:
+      return genFIRType<RealCat, 16>(context);
     }
     assert(false && "type translation not implemented");
   }
   return {};
 }
 
-template<> M::Type genFIRType<IntegerCat>(M::MLIRContext *context, int kind) {
+template <>
+M::Type genFIRType<IntegerCat>(M::MLIRContext *context, int kind) {
   if (Ev::IsValidKindOfIntrinsicType(IntegerCat, kind)) {
     switch (kind) {
-    case 1: return genFIRType<IntegerCat, 1>(context);
-    case 2: return genFIRType<IntegerCat, 2>(context);
-    case 4: return genFIRType<IntegerCat, 4>(context);
-    case 8: return genFIRType<IntegerCat, 8>(context);
-    case 16: return genFIRType<IntegerCat, 16>(context);
+    case 1:
+      return genFIRType<IntegerCat, 1>(context);
+    case 2:
+      return genFIRType<IntegerCat, 2>(context);
+    case 4:
+      return genFIRType<IntegerCat, 4>(context);
+    case 8:
+      return genFIRType<IntegerCat, 8>(context);
+    case 16:
+      return genFIRType<IntegerCat, 16>(context);
     }
     assert(false && "type translation not implemented");
   }
   return {};
 }
 
-template<> M::Type genFIRType<LogicalCat>(M::MLIRContext *context, int KIND) {
+template <>
+M::Type genFIRType<LogicalCat>(M::MLIRContext *context, int KIND) {
   if (Ev::IsValidKindOfIntrinsicType(LogicalCat, KIND))
     return fir::LogicalType::get(context, KIND);
   return {};
 }
 
-template<> M::Type genFIRType<CharacterCat>(M::MLIRContext *context, int KIND) {
+template <>
+M::Type genFIRType<CharacterCat>(M::MLIRContext *context, int KIND) {
   if (Ev::IsValidKindOfIntrinsicType(CharacterCat, KIND))
     return fir::CharacterType::get(context, KIND);
   return {};
 }
 
-template<> M::Type genFIRType<ComplexCat>(M::MLIRContext *context, int KIND) {
+template <>
+M::Type genFIRType<ComplexCat>(M::MLIRContext *context, int KIND) {
   if (Ev::IsValidKindOfIntrinsicType(ComplexCat, KIND))
     return fir::CplxType::get(context, KIND);
   return {};
@@ -146,23 +171,32 @@ class TypeBuilder {
   M::MLIRContext *context;
   Co::IntrinsicTypeDefaultKinds const &defaults;
 
-  template<Co::TypeCategory TC> int defaultKind() { return defaultKind(TC); }
+  template <Co::TypeCategory TC>
+  int defaultKind() {
+    return defaultKind(TC);
+  }
   int defaultKind(Co::TypeCategory TC) { return defaults.GetDefaultKind(TC); }
 
 public:
-  explicit TypeBuilder(
-      M::MLIRContext *context, Co::IntrinsicTypeDefaultKinds const &defaults)
-    : context{context}, defaults{defaults} {}
+  explicit TypeBuilder(M::MLIRContext *context,
+                       Co::IntrinsicTypeDefaultKinds const &defaults)
+      : context{context}, defaults{defaults} {}
 
   // non-template, arguments are runtime values
   M::Type genFIRTy(Co::TypeCategory tc, int kind) {
     switch (tc) {
-    case RealCat: return genFIRType<RealCat>(context, kind);
-    case IntegerCat: return genFIRType<IntegerCat>(context, kind);
-    case ComplexCat: return genFIRType<ComplexCat>(context, kind);
-    case LogicalCat: return genFIRType<LogicalCat>(context, kind);
-    case CharacterCat: return genFIRType<CharacterCat>(context, kind);
-    default: break;
+    case RealCat:
+      return genFIRType<RealCat>(context, kind);
+    case IntegerCat:
+      return genFIRType<IntegerCat>(context, kind);
+    case ComplexCat:
+      return genFIRType<ComplexCat>(context, kind);
+    case LogicalCat:
+      return genFIRType<LogicalCat>(context, kind);
+    case CharacterCat:
+      return genFIRType<CharacterCat>(context, kind);
+    default:
+      break;
     }
     assert(false && "unhandled type category");
     return {};
@@ -177,41 +211,45 @@ class TypeBuilder {
     return genFIRType<IntegerCat>(context, defaultKind<IntegerCat>());
   }
 
-  template<template<typename> typename A, Co::TypeCategory TC>
+  template <template <typename> typename A, Co::TypeCategory TC>
   M::Type gen(const A<Ev::SomeKind<TC>> &) {
     return genFIRType<TC>(context, defaultKind<TC>());
   }
 
-  template<int KIND> M::Type gen(const Ev::TypeParamInquiry<KIND> &) {
+  template <int KIND>
+  M::Type gen(const Ev::TypeParamInquiry<KIND> &) {
     return genFIRType<IntegerCat, KIND>(context);
   }
 
-  template<typename A> M::Type gen(const Ev::Relational<A> &) {
+  template <typename A>
+  M::Type gen(const Ev::Relational<A> &) {
     return genFIRType<LogicalCat, 1>(context);
   }
 
-  template<template<typename> typename A, Co::TypeCategory TC, int KIND>
+  template <template <typename> typename A, Co::TypeCategory TC, int KIND>
   M::Type gen(const A<Ev::Type<TC, KIND>> &) {
     return genFIRType<TC, KIND>(context);
   }
 
   // breaks the conflict between A<Type<TC,KIND>> and Expr<B> deduction
-  template<Co::TypeCategory TC, int KIND>
+  template <Co::TypeCategory TC, int KIND>
   M::Type gen(const Ev::Expr<Ev::Type<TC, KIND>> &) {
     return genFIRType<TC, KIND>(context);
   }
 
-  template<typename A> M::Type genVariant(const A &variant) {
+  template <typename A>
+  M::Type genVariant(const A &variant) {
     return std::visit([&](const auto &x) { return gen(x); }, variant.u);
   }
 
   // breaks the conflict between A<SomeKind<TC>> and Expr<B> deduction
-  template<Co::TypeCategory TC>
+  template <Co::TypeCategory TC>
   M::Type gen(const Ev::Expr<Ev::SomeKind<TC>> &expr) {
     return genVariant(expr);
   }
 
-  template<typename A> M::Type gen(const Ev::Expr<A> &expr) {
+  template <typename A>
+  M::Type gen(const Ev::Expr<A> &expr) {
     return genVariant(expr);
   }
 
@@ -235,8 +273,8 @@ class TypeBuilder {
         auto &ubv = ub.GetExplicit();
         if (lbv.has_value() && ubv.has_value() && isConstant(lbv.value()) &&
             isConstant(ubv.value())) {
-          bounds.emplace_back(
-              toConstant(ubv.value()) - toConstant(lbv.value()) + 1);
+          bounds.emplace_back(toConstant(ubv.value()) -
+                              toConstant(lbv.value()) + 1);
         } else {
           bounds.emplace_back(-1);
         }
@@ -301,7 +339,9 @@ class TypeBuilder {
         case IntegerCat:
           returnTy = genFIRType<IntegerCat>(context, kind);
           break;
-        case RealCat: returnTy = genFIRType<RealCat>(context, kind); break;
+        case RealCat:
+          returnTy = genFIRType<RealCat>(context, kind);
+          break;
         case ComplexCat:
           returnTy = genFIRType<ComplexCat>(context, kind);
           break;
@@ -311,10 +351,12 @@ class TypeBuilder {
         case LogicalCat:
           returnTy = genFIRType<LogicalCat>(context, kind);
           break;
-        case DerivedCat: TODO(); break;
+        case DerivedCat:
+          TODO();
+          break;
         }
       } else if (auto *tySpec{type->AsDerived()}) {
-        (void)tySpec;  // FIXME
+        (void)tySpec; // FIXME
         TODO();
       } else {
         assert(false && "type spec not found");
@@ -362,39 +404,47 @@ class TypeBuilder {
   M::Type gen(const Ev::StructureConstructor &) { TODO(); }
 };
 
-}  // namespace
+} // namespace
 
 M::Type Br::getFIRType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, Co::TypeCategory tc,
-    int kind) {
+                       Co::IntrinsicTypeDefaultKinds const &defaults,
+                       Co::TypeCategory tc, int kind) {
   return TypeBuilder{context, defaults}.genFIRTy(tc, kind);
 }
 
 M::Type Br::getFIRType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, Co::TypeCategory tc) {
+                       Co::IntrinsicTypeDefaultKinds const &defaults,
+                       Co::TypeCategory tc) {
   return TypeBuilder{context, defaults}.genFIRTy(tc);
 }
 
-M::Type Br::translateDataRefToFIRType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, const Ev::DataRef &dataRef) {
+M::Type
+Br::translateDataRefToFIRType(M::MLIRContext *context,
+                              Co::IntrinsicTypeDefaultKinds const &defaults,
+                              const Ev::DataRef &dataRef) {
   return TypeBuilder{context, defaults}.gen(dataRef);
 }
 
 // Builds the FIR type from an instance of SomeExpr
-M::Type Br::translateSomeExprToFIRType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, const SomeExpr *expr) {
+M::Type
+Br::translateSomeExprToFIRType(M::MLIRContext *context,
+                               Co::IntrinsicTypeDefaultKinds const &defaults,
+                               const SomeExpr *expr) {
   return TypeBuilder{context, defaults}.gen(*expr);
 }
 
 // This entry point avoids gratuitously wrapping the Symbol instance in layers
 // of Expr<T> that will then be immediately peeled back off and discarded.
-M::Type Br::translateSymbolToFIRType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol) {
+M::Type
+Br::translateSymbolToFIRType(M::MLIRContext *context,
+                             Co::IntrinsicTypeDefaultKinds const &defaults,
+                             const SymbolRef symbol) {
   return TypeBuilder{context, defaults}.gen(symbol);
 }
 
-M::FunctionType Br::translateSymbolToFIRFunctionType(M::MLIRContext *context,
-    Co::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol) {
+M::FunctionType Br::translateSymbolToFIRFunctionType(
+    M::MLIRContext *context, Co::IntrinsicTypeDefaultKinds const &defaults,
+    const SymbolRef symbol) {
   return TypeBuilder{context, defaults}.genFunctionType(symbol);
 }
 
diff --git a/lib/lower/convert-type.h b/lib/lower/convert-type.h
index 377c7e75dde5..eab38f38da30 100644
--- a/lib/lower/convert-type.h
+++ b/lib/lower/convert-type.h
@@ -30,31 +30,36 @@ namespace mlir {
 class Location;
 class MLIRContext;
 class Type;
-}
+} // namespace mlir
 
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
-template<typename> class Reference;
-}  // common
+template <typename>
+class Reference;
+} // namespace common
 
 namespace evaluate {
 struct DataRef;
-template<typename> class Designator;
-template<typename> class Expr;
-template<common::TypeCategory> struct SomeKind;
+template <typename>
+class Designator;
+template <typename>
+class Expr;
+template <common::TypeCategory>
+struct SomeKind;
 struct SomeType;
-template<common::TypeCategory, int> class Type;
-}  // evaluate
+template <common::TypeCategory, int>
+class Type;
+} // namespace evaluate
 
 namespace parser {
 class CharBlock;
 class CookedSource;
-}  // parser
+} // namespace parser
 
 namespace semantics {
 class Symbol;
-}  // semantics
+} // namespace semantics
 
 namespace lower {
 
@@ -69,41 +74,48 @@ constexpr common::TypeCategory LogicalCat{common::TypeCategory::Logical};
 constexpr common::TypeCategory DerivedCat{common::TypeCategory::Derived};
 
 mlir::Type getFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults, common::TypeCategory tc,
-    int kind);
+                      common::IntrinsicTypeDefaultKinds const &defaults,
+                      common::TypeCategory tc, int kind);
 mlir::Type getFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults, common::TypeCategory tc);
+                      common::IntrinsicTypeDefaultKinds const &defaults,
+                      common::TypeCategory tc);
 
-mlir::Type translateDataRefToFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults,
-    const evaluate::DataRef &dataRef);
+mlir::Type
+translateDataRefToFIRType(mlir::MLIRContext *ctxt,
+                          common::IntrinsicTypeDefaultKinds const &defaults,
+                          const evaluate::DataRef &dataRef);
 
-template<common::TypeCategory TC, int KIND>
-inline mlir::Type translateDesignatorToFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults,
+template <common::TypeCategory TC, int KIND>
+inline mlir::Type translateDesignatorToFIRType(
+    mlir::MLIRContext *ctxt, common::IntrinsicTypeDefaultKinds const &defaults,
     const evaluate::Designator<evaluate::Type<TC, KIND>> &) {
   return getFIRType(ctxt, defaults, TC, KIND);
 }
 
-template<common::TypeCategory TC>
-inline mlir::Type translateDesignatorToFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults,
+template <common::TypeCategory TC>
+inline mlir::Type translateDesignatorToFIRType(
+    mlir::MLIRContext *ctxt, common::IntrinsicTypeDefaultKinds const &defaults,
     const evaluate::Designator<evaluate::SomeKind<TC>> &) {
   return getFIRType(ctxt, defaults, TC);
 }
 
-mlir::Type translateSomeExprToFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults, const SomeExpr *expr);
+mlir::Type
+translateSomeExprToFIRType(mlir::MLIRContext *ctxt,
+                           common::IntrinsicTypeDefaultKinds const &defaults,
+                           const SomeExpr *expr);
 
-mlir::Type translateSymbolToFIRType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol);
+mlir::Type
+translateSymbolToFIRType(mlir::MLIRContext *ctxt,
+                         common::IntrinsicTypeDefaultKinds const &defaults,
+                         const SymbolRef symbol);
 
-mlir::FunctionType translateSymbolToFIRFunctionType(mlir::MLIRContext *ctxt,
-    common::IntrinsicTypeDefaultKinds const &defaults, const SymbolRef symbol);
+mlir::FunctionType translateSymbolToFIRFunctionType(
+    mlir::MLIRContext *ctxt, common::IntrinsicTypeDefaultKinds const &defaults,
+    const SymbolRef symbol);
 
 mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
-}  // lower
-}  // Fortran
+} // namespace lower
+} // namespace Fortran
 
-#endif  // FORTRAN_LOWER_CONVERT_TYPE_H_
+#endif // FORTRAN_LOWER_CONVERT_TYPE_H_
diff --git a/lib/lower/intrinsics.cc b/lib/lower/intrinsics.cc
index 24c22efbf251..230ecd489ddc 100644
--- a/lib/lower/intrinsics.cc
+++ b/lib/lower/intrinsics.cc
@@ -10,9 +10,9 @@
 #include "builder.h"
 #include "complex-handler.h"
 #include "convert-type.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/FIRType.h"
 #include "runtime.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include <algorithm>
@@ -41,7 +41,7 @@ class MathRuntimeLibrary {
 public:
   /// The map key are Fortran generic intrinsic names.
   using Key = L::StringRef;
-  struct Hash {  // Need custom hash for this kind of key
+  struct Hash { // Need custom hash for this kind of key
     size_t operator()(const Key &k) const { return L::hash_value(k); }
   };
   /// Runtime function description that is sufficient to build an
@@ -59,12 +59,12 @@ class MathRuntimeLibrary {
   /// related M::FuncOp if a runtime description is found.
   /// Also add a unit attribute "fir.runtime" to the function so that later
   /// it is possible to quickly know what function are intrinsics vs users.
-  L::Optional<M::FuncOp> getFunction(
-      M::OpBuilder &, L::StringRef, M::FunctionType) const;
+  L::Optional<M::FuncOp> getFunction(M::OpBuilder &, L::StringRef,
+                                     M::FunctionType) const;
 
 private:
-  M::FuncOp getFuncOp(
-      M::OpBuilder &builder, const RuntimeFunction &runtime) const;
+  M::FuncOp getFuncOp(M::OpBuilder &builder,
+                      const RuntimeFunction &runtime) const;
   Map library;
 };
 
@@ -131,7 +131,8 @@ class IntrinsicLibrary::Implementation {
 public:
   Implementation(Version v, M::MLIRContext &c) : runtime{v, c} {}
   inline M::Value genval(M::Location loc, M::OpBuilder &builder,
-      L::StringRef name, M::Type resultType, L::ArrayRef<M::Value> args);
+                         L::StringRef name, M::Type resultType,
+                         L::ArrayRef<M::Value> args);
 
 private:
   // Info needed by Generators is passed in Context struct to keep Generator
@@ -167,7 +168,7 @@ class IntrinsicLibrary::Implementation {
   /// function named "fir."+ <generic name> + "." + <result type code> and
   /// generate the intrinsic implementation inside instead of at the intrinsic
   /// call sites. This can be used to keep the FIR more readable.
-  template<Generator g>
+  template <Generator g>
   static M::Value genWrapperCall(Context &c, MathRuntimeLibrary &r) {
     return outlineInWrapper(g, c, r);
   }
@@ -179,7 +180,7 @@ class IntrinsicLibrary::Implementation {
   }
 
   static M::Value genConjg(Context &, MathRuntimeLibrary &);
-  template<Extremum, ExtremumBehavior>
+  template <Extremum, ExtremumBehavior>
   static M::Value genExtremum(Context &, MathRuntimeLibrary &);
   static M::Value genMerge(Context &, MathRuntimeLibrary &);
 
@@ -200,25 +201,26 @@ class IntrinsicLibrary::Implementation {
   };
 
   // helpers
-  static M::Value outlineInWrapper(
-      Generator, Context &c, MathRuntimeLibrary &r);
+  static M::Value outlineInWrapper(Generator, Context &c,
+                                   MathRuntimeLibrary &r);
 
   MathRuntimeLibrary runtime;
 };
 
 // helpers
-static std::string getIntrinsicWrapperName(
-    const L::StringRef &intrinsic, M::FunctionType funTy);
-static M::FunctionType getFunctionType(
-    M::Type resultType, L::ArrayRef<M::Value> arguments, M::OpBuilder &);
+static std::string getIntrinsicWrapperName(const L::StringRef &intrinsic,
+                                           M::FunctionType funTy);
+static M::FunctionType getFunctionType(M::Type resultType,
+                                       L::ArrayRef<M::Value> arguments,
+                                       M::OpBuilder &);
 
 /// Define a simple static runtime description that will be transformed into
 /// RuntimeFunction when building the IntrinsicLibrary.
 class MathsRuntimeStaticDescription : public RuntimeStaticDescription {
 public:
-  constexpr MathsRuntimeStaticDescription(
-      const char *n, const char *s, MaybeTypeCode r, TypeCodeVector a)
-    : RuntimeStaticDescription{s, r, a}, name{n} {}
+  constexpr MathsRuntimeStaticDescription(const char *n, const char *s,
+                                          MaybeTypeCode r, TypeCodeVector a)
+      : RuntimeStaticDescription{s, r, a}, name{n} {}
   L::StringRef getName() const { return name; }
 
 private:
@@ -260,11 +262,11 @@ static constexpr MathsRuntimeStaticDescription pgmathPreciseRuntime[] = {
     {"pow", "__pz_powi_1", RType::c64, Args::create<RType::c64, RType::i32>()},
     {"pow", "__pz_powk_1", RType::c64, Args::create<RType::c64, RType::i64>()},
     {"pow", "__mth_i_ipowi", RType::i32,
-        Args::create<RType::i32, RType::i32>()},
+     Args::create<RType::i32, RType::i32>()},
     {"pow", "__mth_i_kpowi", RType::i64,
-        Args::create<RType::i64, RType::i32>()},
+     Args::create<RType::i64, RType::i32>()},
     {"pow", "__mth_i_kpowk", RType::i64,
-        Args::create<RType::i64, RType::i64>()},
+     Args::create<RType::i64, RType::i64>()},
 };
 
 // TODO : Tables above should be generated in a clever ways and probably shared
@@ -274,8 +276,8 @@ static constexpr MathsRuntimeStaticDescription pgmathPreciseRuntime[] = {
 
 // IntrinsicLibrary implementation
 
-IntrinsicLibrary IntrinsicLibrary::create(
-    IntrinsicLibrary::Version v, M::MLIRContext &context) {
+IntrinsicLibrary IntrinsicLibrary::create(IntrinsicLibrary::Version v,
+                                          M::MLIRContext &context) {
   IntrinsicLibrary lib{};
   lib.impl = new Implementation(v, context);
   return lib;
@@ -284,7 +286,8 @@ IntrinsicLibrary IntrinsicLibrary::create(
 IntrinsicLibrary::~IntrinsicLibrary() { delete impl; }
 
 M::Value IntrinsicLibrary::genval(M::Location loc, M::OpBuilder &builder,
-    L::StringRef name, M::Type resultType, L::ArrayRef<M::Value> args) const {
+                                  L::StringRef name, M::Type resultType,
+                                  L::ArrayRef<M::Value> args) const {
   assert(impl);
   return impl->genval(loc, builder, name, resultType, args);
 }
@@ -293,22 +296,22 @@ M::Value IntrinsicLibrary::genval(M::Location loc, M::OpBuilder &builder,
 
 // Create the runtime description for the targeted library version.
 // So far ignore the version an only load the dummy llvm lib and pgmath precise
-MathRuntimeLibrary::MathRuntimeLibrary(
-    IntrinsicLibrary::Version, M::MLIRContext &mlirContext) {
+MathRuntimeLibrary::MathRuntimeLibrary(IntrinsicLibrary::Version,
+                                       M::MLIRContext &mlirContext) {
   for (const MathsRuntimeStaticDescription &func : llvmRuntime) {
-    RuntimeFunction impl{
-        func.getSymbol(), func.getMLIRFunctionType(&mlirContext)};
+    RuntimeFunction impl{func.getSymbol(),
+                         func.getMLIRFunctionType(&mlirContext)};
     library.insert({Key{func.getName()}, impl});
   }
   for (const MathsRuntimeStaticDescription &func : pgmathPreciseRuntime) {
-    RuntimeFunction impl{
-        func.getSymbol(), func.getMLIRFunctionType(&mlirContext)};
+    RuntimeFunction impl{func.getSymbol(),
+                         func.getMLIRFunctionType(&mlirContext)};
     library.insert({Key{func.getName()}, impl});
   }
 }
 
-M::FuncOp MathRuntimeLibrary::getFuncOp(
-    M::OpBuilder &builder, const RuntimeFunction &runtime) const {
+M::FuncOp MathRuntimeLibrary::getFuncOp(M::OpBuilder &builder,
+                                        const RuntimeFunction &runtime) const {
   auto module{getModule(&builder)};
   M::FuncOp function{getNamedFunction(module, runtime.symbol)};
   if (!function) {
@@ -347,9 +350,9 @@ class FunctionDistance {
   }
   bool isSmallerThan(const FunctionDistance &d) const {
     return d.infinite ||
-        (!infinite &&
-            std::lexicographical_compare(conversions.begin(), conversions.end(),
-                d.conversions.begin(), d.conversions.end()));
+           (!infinite && std::lexicographical_compare(
+                             conversions.begin(), conversions.end(),
+                             d.conversions.begin(), d.conversions.end()));
   }
   bool isLoosingPrecision() const {
     return conversions[narrowingArg] != 0 || conversions[extendingResult] != 0;
@@ -361,28 +364,45 @@ class FunctionDistance {
 
   void addArgumentDistance(M::Type from, M::Type to) {
     switch (conversionBetweenTypes(from, to)) {
-    case Conversion::Forbidden: infinite = true; break;
-    case Conversion::None: break;
-    case Conversion::Narrow: conversions[narrowingArg]++; break;
-    case Conversion::Extend: conversions[nonNarrowingArg]++; break;
+    case Conversion::Forbidden:
+      infinite = true;
+      break;
+    case Conversion::None:
+      break;
+    case Conversion::Narrow:
+      conversions[narrowingArg]++;
+      break;
+    case Conversion::Extend:
+      conversions[nonNarrowingArg]++;
+      break;
     }
   }
   void addResultDistance(M::Type from, M::Type to) {
     switch (conversionBetweenTypes(from, to)) {
-    case Conversion::Forbidden: infinite = true; break;
-    case Conversion::None: break;
-    case Conversion::Narrow: conversions[nonExtendingResult]++; break;
-    case Conversion::Extend: conversions[extendingResult]++; break;
+    case Conversion::Forbidden:
+      infinite = true;
+      break;
+    case Conversion::None:
+      break;
+    case Conversion::Narrow:
+      conversions[nonExtendingResult]++;
+      break;
+    case Conversion::Extend:
+      conversions[extendingResult]++;
+      break;
     }
   }
   // Floating point can be M::FloatType or fir::real
   static unsigned getFloatingPointWidth(M::Type t) {
-    if (auto f{t.dyn_cast<M::FloatType>()}) return f.getWidth();
+    if (auto f{t.dyn_cast<M::FloatType>()})
+      return f.getWidth();
     // FIXME: Get width another way for fir.real/complex
-    // - use fir/KindMapping.h and L::Type
+    // - use optimizer/KindMapping.h and L::Type
     // - or use evaluate/type.h
-    if (auto r{t.dyn_cast<fir::RealType>()}) return r.getFKind() * 4;
-    if (auto cplx{t.dyn_cast<fir::CplxType>()}) return cplx.getFKind() * 4;
+    if (auto r{t.dyn_cast<fir::RealType>()})
+      return r.getFKind() * 4;
+    if (auto cplx{t.dyn_cast<fir::CplxType>()})
+      return cplx.getFKind() * 4;
     assert(false && "not a floating-point type");
     return 0;
   }
@@ -401,15 +421,15 @@ class FunctionDistance {
     }
     if (isFloatingPointType(from) && isFloatingPointType(to)) {
       return getFloatingPointWidth(from) > getFloatingPointWidth(to)
-          ? Conversion::Narrow
-          : Conversion::Extend;
+                 ? Conversion::Narrow
+                 : Conversion::Extend;
     }
     if (auto fromCplxTy{from.dyn_cast<fir::CplxType>()}) {
       if (auto toCplxTy{to.dyn_cast<fir::CplxType>()}) {
         return getFloatingPointWidth(fromCplxTy) >
-                getFloatingPointWidth(toCplxTy)
-            ? Conversion::Narrow
-            : Conversion::Extend;
+                       getFloatingPointWidth(toCplxTy)
+                   ? Conversion::Narrow
+                   : Conversion::Extend;
       }
     }
     // Notes:
@@ -424,28 +444,29 @@ class FunctionDistance {
   // Below are indexes to access data in conversions.
   // The order in data does matter for lexicographical_compare
   enum {
-    narrowingArg = 0,  // usually bad
-    extendingResult,  // usually bad
-    nonExtendingResult,  // usually ok
-    nonNarrowingArg,  // usually ok
+    narrowingArg = 0,   // usually bad
+    extendingResult,    // usually bad
+    nonExtendingResult, // usually ok
+    nonNarrowingArg,    // usually ok
     dataSize
   };
   std::array<int, dataSize> conversions{/* zero init*/};
-  bool infinite{false};  // When forbidden conversion or wrong argument number
+  bool infinite{false}; // When forbidden conversion or wrong argument number
 };
 
 // Select runtime function that has the smallest distance to the intrinsic
 // function type and that will not imply narrowing arguments or extending the
 // result.
-L::Optional<M::FuncOp> MathRuntimeLibrary::getFunction(
-    M::OpBuilder &builder, L::StringRef name, M::FunctionType funcType) const {
+L::Optional<M::FuncOp>
+MathRuntimeLibrary::getFunction(M::OpBuilder &builder, L::StringRef name,
+                                M::FunctionType funcType) const {
   auto range{library.equal_range(name)};
   const RuntimeFunction *bestNearMatch{nullptr};
   FunctionDistance bestMatchDistance{};
   for (auto iter{range.first}; iter != range.second; ++iter) {
     const RuntimeFunction &impl{iter->second};
     if (funcType == impl.type) {
-      return getFuncOp(builder, impl);  // exact match
+      return getFuncOp(builder, impl); // exact match
     } else {
       FunctionDistance distance(funcType, impl.type);
       if (distance.isSmallerThan(bestMatchDistance)) {
@@ -456,7 +477,7 @@ L::Optional<M::FuncOp> MathRuntimeLibrary::getFunction(
   }
   if (bestNearMatch != nullptr) {
     assert(!bestMatchDistance.isLoosingPrecision() &&
-        "runtime selection looses precision");
+           "runtime selection looses precision");
     return getFuncOp(builder, *bestNearMatch);
   }
   return {};
@@ -465,10 +486,12 @@ L::Optional<M::FuncOp> MathRuntimeLibrary::getFunction(
 // IntrinsicLibrary::Implementation implementation
 
 M::Value IntrinsicLibrary::Implementation::genval(M::Location loc,
-    M::OpBuilder &builder, L::StringRef name, M::Type resultType,
-    L::ArrayRef<M::Value> args) {
-  Context context{
-      loc, &builder, name, args, getFunctionType(resultType, args, builder)};
+                                                  M::OpBuilder &builder,
+                                                  L::StringRef name,
+                                                  M::Type resultType,
+                                                  L::ArrayRef<M::Value> args) {
+  Context context{loc, &builder, name, args,
+                  getFunctionType(resultType, args, builder)};
   for (auto &handler : handlers) {
     if (name == handler.name) {
       assert(handler.generator != nullptr);
@@ -481,14 +504,15 @@ M::Value IntrinsicLibrary::Implementation::genval(M::Location loc,
 }
 
 static M::FunctionType getFunctionType(M::Type resultType,
-    L::ArrayRef<M::Value> arguments, M::OpBuilder &builder) {
+                                       L::ArrayRef<M::Value> arguments,
+                                       M::OpBuilder &builder) {
   L::SmallVector<M::Type, 2> argumentTypes;
   for (auto &arg : arguments) {
-    assert(arg != nullptr);  // TODO think about optionals
+    assert(arg != nullptr); // TODO think about optionals
     argumentTypes.push_back(arg->getType());
   }
-  return M::FunctionType::get(
-      argumentTypes, resultType, getModule(&builder).getContext());
+  return M::FunctionType::get(argumentTypes, resultType,
+                              getModule(&builder).getContext());
 }
 
 // TODO find nicer type to string infra or move this in a mangling utility
@@ -515,8 +539,8 @@ static std::string typeToString(M::Type t) {
   assert(false && "no mangling for type");
   return ""s;
 }
-static std::string getIntrinsicWrapperName(
-    const L::StringRef &intrinsic, M::FunctionType funTy) {
+static std::string getIntrinsicWrapperName(const L::StringRef &intrinsic,
+                                           M::FunctionType funTy) {
   std::string name{"fir." + intrinsic.str() + "."};
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
   name += typeToString(funTy.getResult(0));
@@ -559,23 +583,24 @@ M::Value IntrinsicLibrary::Implementation::outlineInWrapper(
     // Wrapper was already built, ensure it has the sought type
     assert(function.getType() == context.funcType);
   }
-  auto call{context.builder->create<M::CallOp>(
-      context.loc, function, context.arguments)};
+  auto call{context.builder->create<M::CallOp>(context.loc, function,
+                                               context.arguments)};
   return call.getResult(0);
 }
 
-M::Value IntrinsicLibrary::Implementation::genRuntimeCall(
-    Context &context, MathRuntimeLibrary &runtime) {
+M::Value
+IntrinsicLibrary::Implementation::genRuntimeCall(Context &context,
+                                                 MathRuntimeLibrary &runtime) {
   // Look up runtime
   M::FunctionType soughtFuncType{context.funcType};
-  if (auto funcOp{runtime.getFunction(
-          *context.builder, context.name, soughtFuncType)}) {
+  if (auto funcOp{runtime.getFunction(*context.builder, context.name,
+                                      soughtFuncType)}) {
     M::FunctionType actualFuncType{funcOp->getType()};
     if (actualFuncType.getNumResults() != soughtFuncType.getNumResults() ||
         actualFuncType.getNumInputs() != soughtFuncType.getNumInputs() ||
         actualFuncType.getNumInputs() != context.arguments.size() ||
         actualFuncType.getNumResults() != 1) {
-      assert(false);  // TODO better error handling
+      assert(false); // TODO better error handling
       return nullptr;
     }
     L::SmallVector<M::Value, 2> convertedArguments;
@@ -591,13 +616,13 @@ M::Value IntrinsicLibrary::Implementation::genRuntimeCall(
       }
       ++i;
     }
-    auto call{context.builder->create<M::CallOp>(
-        context.loc, *funcOp, convertedArguments)};
+    auto call{context.builder->create<M::CallOp>(context.loc, *funcOp,
+                                                 convertedArguments)};
     M::Type soughtType{soughtFuncType.getResult(0)};
     M::Value res = call.getResult(0);
     if (actualFuncType.getResult(0) != soughtType) {
-      auto castedRes{context.builder->create<fir::ConvertOp>(
-          context.loc, soughtType, res)};
+      auto castedRes{context.builder->create<fir::ConvertOp>(context.loc,
+                                                             soughtType, res)};
       return castedRes.getResult();
     } else {
       return res;
@@ -608,12 +633,12 @@ M::Value IntrinsicLibrary::Implementation::genRuntimeCall(
     // TODO: better error handling ?
     //  - Try to have compile time check of runtime compltness ?
   }
-  return {};  // gets rid of warnings
+  return {}; // gets rid of warnings
 }
 
 // CONJG
-M::Value IntrinsicLibrary::Implementation::genConjg(
-    Context &genCtxt, MathRuntimeLibrary &) {
+M::Value IntrinsicLibrary::Implementation::genConjg(Context &genCtxt,
+                                                    MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 1);
   M::Type resType{genCtxt.getResultType()};
   assert(resType == genCtxt.arguments[0]->getType());
@@ -627,8 +652,8 @@ M::Value IntrinsicLibrary::Implementation::genConjg(
 }
 
 // MERGE
-M::Value IntrinsicLibrary::Implementation::genMerge(
-    Context &genCtxt, MathRuntimeLibrary &) {
+M::Value IntrinsicLibrary::Implementation::genMerge(Context &genCtxt,
+                                                    MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 3);
   M::Type resType{genCtxt.getResultType()};
   M::OpBuilder &builder{*genCtxt.builder};
@@ -642,15 +667,15 @@ M::Value IntrinsicLibrary::Implementation::genMerge(
 }
 
 // Compare two FIR values and return boolean result as i1.
-template<Extremum extremum, ExtremumBehavior behavior>
-static M::Value createExtremumCompare(
-    M::Location loc, M::OpBuilder &builder, M::Value left, M::Value right) {
+template <Extremum extremum, ExtremumBehavior behavior>
+static M::Value createExtremumCompare(M::Location loc, M::OpBuilder &builder,
+                                      M::Value left, M::Value right) {
   static constexpr auto integerPredicate{extremum == Extremum::Max
-          ? M::CmpIPredicate::sgt
-          : M::CmpIPredicate::slt};
+                                             ? M::CmpIPredicate::sgt
+                                             : M::CmpIPredicate::slt};
   static constexpr auto orderedCmp{extremum == Extremum::Max
-          ? fir::CmpFPredicate::OGT
-          : fir::CmpFPredicate::OLT};
+                                       ? fir::CmpFPredicate::OGT
+                                       : fir::CmpFPredicate::OLT};
   auto type{left->getType()};
   M::Value result;
   if (type.isa<M::FloatType>() || type.isa<fir::RealType>()) {
@@ -661,15 +686,15 @@ static M::Value createExtremumCompare(
       // a number.
       auto leftIsResult{
           builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
-      auto rightIsNan{builder.create<fir::CmpfOp>(
-          loc, fir::CmpFPredicate::UNE, right, right)};
+      auto rightIsNan{builder.create<fir::CmpfOp>(loc, fir::CmpFPredicate::UNE,
+                                                  right, right)};
       result = builder.create<M::OrOp>(loc, leftIsResult, rightIsNan);
     } else if constexpr (behavior == ExtremumBehavior::IeeeMinMaximum) {
       // Always return NaNs if one the input is NaNs
       auto leftIsResult{
           builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
-      auto leftIsNan{builder.create<fir::CmpfOp>(
-          loc, fir::CmpFPredicate::UNE, left, left)};
+      auto leftIsNan{builder.create<fir::CmpfOp>(loc, fir::CmpFPredicate::UNE,
+                                                 left, left)};
       result = builder.create<M::OrOp>(loc, leftIsResult, leftIsNan);
     } else if constexpr (behavior == ExtremumBehavior::MinMaxss) {
       // If the left is a NaN, return the right whatever it is.
@@ -677,13 +702,13 @@ static M::Value createExtremumCompare(
     } else if constexpr (behavior == ExtremumBehavior::PgfortranLlvm) {
       // If one of the operand is a NaN, return left whatever it is.
       static constexpr auto unorderedCmp{extremum == Extremum::Max
-              ? fir::CmpFPredicate::UGT
-              : fir::CmpFPredicate::ULT};
+                                             ? fir::CmpFPredicate::UGT
+                                             : fir::CmpFPredicate::ULT};
       result = builder.create<fir::CmpfOp>(loc, unorderedCmp, left, right);
     } else {
       // TODO: ieeMinNum/ieeeMaxNum
       static_assert(behavior == ExtremumBehavior::IeeeMinMaxNum,
-          "ieeeMinNum/ieeMaxNum behavior not implemented");
+                    "ieeeMinNum/ieeMaxNum behavior not implemented");
     }
   } else if (type.isa<M::IntegerType>()) {
     result = builder.create<M::CmpIOp>(loc, integerPredicate, left, right);
@@ -697,9 +722,9 @@ static M::Value createExtremumCompare(
 }
 
 // MIN and MAX
-template<Extremum extremum, ExtremumBehavior behavior>
-M::Value IntrinsicLibrary::Implementation::genExtremum(
-    Context &genCtxt, MathRuntimeLibrary &) {
+template <Extremum extremum, ExtremumBehavior behavior>
+M::Value IntrinsicLibrary::Implementation::genExtremum(Context &genCtxt,
+                                                       MathRuntimeLibrary &) {
   auto &builder{*genCtxt.builder};
   auto loc{genCtxt.loc};
   assert(genCtxt.arguments.size() >= 2);
@@ -712,4 +737,4 @@ M::Value IntrinsicLibrary::Implementation::genExtremum(
   return result;
 }
 
-}  // namespace Fortran::lower
+} // namespace Fortran::lower
diff --git a/lib/lower/intrinsics.h b/lib/lower/intrinsics.h
index 168dec84d298..4b25b372af21 100644
--- a/lib/lower/intrinsics.h
+++ b/lib/lower/intrinsics.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_LOWER_INTRINSICS_H_
 #define FORTRAN_LOWER_INTRINSICS_H_
 
-#include "llvm/ADT/StringRef.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
+#include "llvm/ADT/StringRef.h"
 #include <optional>
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
@@ -43,8 +43,8 @@ class IntrinsicLibrary {
   /// On failure, returns a nullptr, else the returned mlir::Value is
   /// the returned Fortran intrinsic value.
   mlir::Value genval(mlir::Location loc, mlir::OpBuilder &builder,
-      llvm::StringRef name, mlir::Type resultType,
-      llvm::ArrayRef<mlir::Value> args) const;
+                     llvm::StringRef name, mlir::Type resultType,
+                     llvm::ArrayRef<mlir::Value> args) const;
 
   // TODO: Expose interface to get specific intrinsic function address.
   // TODO: Handle intrinsic subroutine.
@@ -60,9 +60,9 @@ class IntrinsicLibrary {
 private:
   /// Actual implementation is hidden.
   class Implementation;
-  Implementation *impl{nullptr};  // owning pointer
+  Implementation *impl{nullptr}; // owning pointer
 };
 
-}
+} // namespace Fortran::lower
 
-#endif  // FORTRAN_LOWER_INTRINSICS_H_
+#endif // FORTRAN_LOWER_INTRINSICS_H_
diff --git a/lib/lower/io.cc b/lib/lower/io.cc
index b3d12c9cf230..98087e3dd83d 100644
--- a/lib/lower/io.cc
+++ b/lib/lower/io.cc
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "io.h"
-#include "bridge.h"
-#include "builder.h"
-#include "runtime.h"
 #include "../parser/parse-tree.h"
 #include "../semantics/tools.h"
+#include "bridge.h"
+#include "builder.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
+#include "runtime.h"
 #include <cassert>
 
 namespace Br = Fortran::lower;
@@ -34,9 +34,9 @@ enum class IOAction { BeginExternalList, Output, EndIO };
 class IORuntimeDescription : public RuntimeStaticDescription {
 public:
   using Key = IOAction;
-  constexpr IORuntimeDescription(
-      IOAction act, const char *s, MaybeTypeCode r, TypeCodeVector a)
-    : RuntimeStaticDescription{s, r, a}, key{act} {}
+  constexpr IORuntimeDescription(IOAction act, const char *s, MaybeTypeCode r,
+                                 TypeCodeVector a)
+      : RuntimeStaticDescription{s, r, a}, key{act} {}
   static M::Type getIOCookieType(M::MLIRContext *context) {
     return getMLIRType(TypeCode::IOCookie, context);
   }
@@ -55,13 +55,13 @@ using IOA = IOAction;
 /// Experimental runtime for now.
 static constexpr IORuntimeDescription ioRuntimeTable[]{
     {IOA::BeginExternalList, "__F18IOa_BeginExternalListOutput",
-        RType::IOCookie, Args::create<RType::i32>()},
+     RType::IOCookie, Args::create<RType::i32>()},
     {IOA::Output, "__F18IOa_OutputInteger64", RT::voidTy,
-        Args::create<RType::IOCookie, RType::i64>()},
+     Args::create<RType::IOCookie, RType::i64>()},
     {IOA::Output, "__F18IOa_OutputReal64", RT::voidTy,
-        Args::create<RType::IOCookie, RType::f64>()},
+     Args::create<RType::IOCookie, RType::f64>()},
     {IOA::EndIO, "__F18IOa_EndIOStatement", RT::voidTy,
-        Args::create<RType::IOCookie>()},
+     Args::create<RType::IOCookie>()},
 };
 
 static constexpr IORuntimeMap ioRuntimeMap{ioRuntimeTable};
@@ -70,7 +70,7 @@ static constexpr IORuntimeMap ioRuntimeMap{ioRuntimeTable};
 /// are mapped to an IOAction that must be mapped to one and
 /// exactly one runtime function. This constraint is enforced
 /// at compile time. This search is resolved at compile time.
-template<IORuntimeDescription::Key key>
+template <IORuntimeDescription::Key key>
 static M::FuncOp getIORuntimeFunction(M::OpBuilder &builder) {
   static constexpr auto runtimeDescription{ioRuntimeMap.find(key)};
   static_assert(runtimeDescription != ioRuntimeMap.end());
@@ -102,8 +102,8 @@ static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
 }
 
 /// Lower print statement assuming a dummy runtime interface for now.
-void lowerPrintStatement(
-    M::OpBuilder &builder, M::Location loc, M::ValueRange args) {
+void lowerPrintStatement(M::OpBuilder &builder, M::Location loc,
+                         M::ValueRange args) {
   M::ModuleOp module{getModule(&builder)};
   M::MLIRContext *mlirContext{module.getContext()};
 
@@ -131,7 +131,7 @@ void lowerPrintStatement(
   builder.create<M::CallOp>(loc, endIOFunc, endArgs);
 }
 
-}  // namespace
+} // namespace
 
 void Br::genBackspaceStatement(AbstractConverter &, const Pa::BackspaceStmt &) {
   assert(false);
@@ -157,19 +157,19 @@ void Br::genOpenStatement(AbstractConverter &, const Pa::OpenStmt &) {
   assert(false);
 }
 
-void Br::genPrintStatement(
-    Br::AbstractConverter &converter, const Pa::PrintStmt &stmt) {
+void Br::genPrintStatement(Br::AbstractConverter &converter,
+                           const Pa::PrintStmt &stmt) {
   llvm::SmallVector<M::Value, 4> args;
   for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
     if (auto *pe{std::get_if<Pa::Expr>(&item.u)}) {
       auto loc{converter.genLocation(pe->source)};
       args.push_back(converter.genExprValue(*semantics::GetExpr(*pe), &loc));
     } else {
-      assert(false);  // TODO implied do
+      assert(false); // TODO implied do
     }
   }
-  lowerPrintStatement(
-      converter.getOpBuilder(), converter.getCurrentLocation(), args);
+  lowerPrintStatement(converter.getOpBuilder(), converter.getCurrentLocation(),
+                      args);
 }
 
 void Br::genReadStatement(AbstractConverter &, const Pa::ReadStmt &) {
diff --git a/lib/lower/io.h b/lib/lower/io.h
index 3bb95999f36d..b130e61db58f 100644
--- a/lib/lower/io.h
+++ b/lib/lower/io.h
@@ -13,7 +13,7 @@ namespace mlir {
 class OpBuilder;
 class Location;
 class ValueRange;
-}
+} // namespace mlir
 
 namespace Fortran {
 
@@ -28,7 +28,7 @@ struct PrintStmt;
 struct ReadStmt;
 struct RewindStmt;
 struct WriteStmt;
-}
+} // namespace parser
 
 /// Experimental IO lowering to FIR + runtime. The Runtime design is under
 /// design.
@@ -52,7 +52,7 @@ void genReadStatement(AbstractConverter &, const parser::ReadStmt &);
 void genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
 void genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
 
-}
-}
+} // namespace lower
+} // namespace Fortran
 
-#endif  // FORTRAN_LOWER_IO_H_
+#endif // FORTRAN_LOWER_IO_H_
diff --git a/lib/lower/mangler.cc b/lib/lower/mangler.cc
index 1b2e59fb0786..53fd14d3258b 100644
--- a/lib/lower/mangler.cc
+++ b/lib/lower/mangler.cc
@@ -15,7 +15,7 @@
 #include "mangler.h"
 #include "../common/reference.h"
 #include "../semantics/tools.h"
-#include "fir/InternalNames.h"
+#include "optimizer/InternalNames.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
@@ -37,8 +37,8 @@ L::StringRef toStringRef(const parser::CharBlock &cb) {
 }
 
 // recursively build the vector of module scopes
-void moduleNames(
-    const Se::Scope *scope, L::SmallVector<L::StringRef, 2> &result) {
+void moduleNames(const Se::Scope *scope,
+                 L::SmallVector<L::StringRef, 2> &result) {
   if (scope->kind() == Se::Scope::Kind::Global) {
     return;
   }
@@ -65,33 +65,34 @@ L::Optional<L::StringRef> hostName(const Se::Scope *scope) {
   return {};
 }
 
-}  // namespace
+} // namespace
 
 // Mangle the name of `symbol` to make it unique within FIR's symbol table using
 // the FIR name mangler, `mangler`
-std::string Ma::mangleName(
-    fir::NameUniquer &uniquer, const Se::SymbolRef symbol) {
-  return std::visit(Co::visitors{
-                        [&](const Se::MainProgramDetails &) {
-                          return uniquer.doProgramEntry().str();
-                        },
-                        [&](const Se::SubprogramDetails &) {
-                          auto &cb{symbol->name()};
-                          auto modNames{moduleNames(symbol->scope())};
-                          return uniquer.doProcedure(modNames,
-                              hostName(symbol->scope()), toStringRef(cb));
-                        },
-                        [&](const Se::ProcEntityDetails &) {
-                          auto &cb{symbol->name()};
-                          auto modNames{moduleNames(symbol->scope())};
-                          return uniquer.doProcedure(modNames,
-                              hostName(symbol->scope()), toStringRef(cb));
-                        },
-                        [](const auto &) -> std::string {
-                          assert(false);
-                          return {};
-                        },
-                    },
+std::string Ma::mangleName(fir::NameUniquer &uniquer,
+                           const Se::SymbolRef symbol) {
+  return std::visit(
+      Co::visitors{
+          [&](const Se::MainProgramDetails &) {
+            return uniquer.doProgramEntry().str();
+          },
+          [&](const Se::SubprogramDetails &) {
+            auto &cb{symbol->name()};
+            auto modNames{moduleNames(symbol->scope())};
+            return uniquer.doProcedure(modNames, hostName(symbol->scope()),
+                                       toStringRef(cb));
+          },
+          [&](const Se::ProcEntityDetails &) {
+            auto &cb{symbol->name()};
+            auto modNames{moduleNames(symbol->scope())};
+            return uniquer.doProcedure(modNames, hostName(symbol->scope()),
+                                       toStringRef(cb));
+          },
+          [](const auto &) -> std::string {
+            assert(false);
+            return {};
+          },
+      },
       symbol->details());
 }
 
diff --git a/lib/lower/mangler.h b/lib/lower/mangler.h
index 7d1691f91af2..9571fa9f9321 100644
--- a/lib/lower/mangler.h
+++ b/lib/lower/mangler.h
@@ -27,7 +27,8 @@ class StringRef;
 
 namespace Fortran {
 namespace common {
-template<typename> class Reference;
+template <typename>
+class Reference;
 }
 
 namespace semantics {
@@ -44,8 +45,8 @@ std::string mangleName(fir::NameUniquer &uniquer, const SymbolRef symbol);
 
 std::string demangleName(llvm::StringRef name);
 
-}  // mangle
-}  // lower
-}  // Fortran
+} // namespace mangle
+} // namespace lower
+} // namespace Fortran
 
-#endif  // FORTRAN_LOWER_MANGLER_H_
+#endif // FORTRAN_LOWER_MANGLER_H_
diff --git a/lib/lower/mixin.h b/lib/lower/mixin.h
index 0d75f7aaa4ed..a1b810312baa 100644
--- a/lib/lower/mixin.h
+++ b/lib/lower/mixin.h
@@ -31,10 +31,13 @@
 namespace Fortran::lower {
 
 // implementation of a (moveable) sum type (variant)
-template<typename... Ts> struct SumTypeMixin {
+template <typename... Ts>
+struct SumTypeMixin {
   using SumTypeTrait = std::true_type;
-  template<typename A> SumTypeMixin(const A &x) : u{x} {}
-  template<typename A> SumTypeMixin(A &&x) : u{std::forward<A>(x)} {}
+  template <typename A>
+  SumTypeMixin(const A &x) : u{x} {}
+  template <typename A>
+  SumTypeMixin(A &&x) : u{std::forward<A>(x)} {}
   SumTypeMixin(SumTypeMixin &&) = default;
   SumTypeMixin &operator=(SumTypeMixin &&) = default;
   SumTypeMixin(const SumTypeMixin &) = delete;
@@ -44,10 +47,13 @@ template<typename... Ts> struct SumTypeMixin {
 };
 
 // implementation of a copyable sum type
-template<typename... Ts> struct SumTypeCopyMixin {
+template <typename... Ts>
+struct SumTypeCopyMixin {
   using CopyableSumTypeTrait = std::true_type;
-  template<typename A> SumTypeCopyMixin(const A &x) : u{x} {}
-  template<typename A> SumTypeCopyMixin(A &&x) : u{std::forward<A>(x)} {}
+  template <typename A>
+  SumTypeCopyMixin(const A &x) : u{x} {}
+  template <typename A>
+  SumTypeCopyMixin(A &&x) : u{std::forward<A>(x)} {}
   SumTypeCopyMixin(SumTypeCopyMixin &&) = default;
   SumTypeCopyMixin &operator=(SumTypeCopyMixin &&) = default;
   SumTypeCopyMixin(const SumTypeCopyMixin &) = default;
@@ -55,18 +61,18 @@ template<typename... Ts> struct SumTypeCopyMixin {
   SumTypeCopyMixin() = delete;
   std::variant<Ts...> u;
 };
-#define SUM_TYPE_COPY_MIXIN(DT) \
-  DT(const DT &derived) : SumTypeCopyMixin(derived.u) {} \
-  DT(DT &&derived) : SumTypeCopyMixin(std::move(derived.u)) {} \
-  DT &operator=(const DT &derived) { \
-    SumTypeCopyMixin::operator=(derived.u); \
-    return *this; \
-  } \
-  DT &operator=(DT &&derived) { \
-    SumTypeCopyMixin::operator=(std::move(derived.u)); \
-    return *this; \
+#define SUM_TYPE_COPY_MIXIN(DT)                                                \
+  DT(const DT &derived) : SumTypeCopyMixin(derived.u) {}                       \
+  DT(DT &&derived) : SumTypeCopyMixin(std::move(derived.u)) {}                 \
+  DT &operator=(const DT &derived) {                                           \
+    SumTypeCopyMixin::operator=(derived.u);                                    \
+    return *this;                                                              \
+  }                                                                            \
+  DT &operator=(DT &&derived) {                                                \
+    SumTypeCopyMixin::operator=(std::move(derived.u));                         \
+    return *this;                                                              \
   }
 
-} // namespace lower
+} // namespace Fortran::lower
 
-#endif  // FORTRAN_LOWER_MIXIN_H_
+#endif // FORTRAN_LOWER_MIXIN_H_
diff --git a/lib/lower/runtime.cc b/lib/lower/runtime.cc
index 415fe48b4afc..3dfaf3362413 100644
--- a/lib/lower/runtime.cc
+++ b/lib/lower/runtime.cc
@@ -14,25 +14,31 @@
 
 #include "runtime.h"
 #include "builder.h"
-#include "fir/FIRType.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/IR/Types.h"
+#include "optimizer/FIRType.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/IR/Types.h"
 #include <cassert>
 
 namespace Fortran::lower {
-mlir::Type RuntimeStaticDescription::getMLIRType(
-    TypeCode t, mlir::MLIRContext *context) {
+mlir::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
+                                                 mlir::MLIRContext *context) {
   switch (t) {
-  case TypeCode::i32: return mlir::IntegerType::get(32, context);
-  case TypeCode::i64: return mlir::IntegerType::get(64, context);
-  case TypeCode::f32: return mlir::FloatType::getF32(context);
-  case TypeCode::f64: return mlir::FloatType::getF64(context);
+  case TypeCode::i32:
+    return mlir::IntegerType::get(32, context);
+  case TypeCode::i64:
+    return mlir::IntegerType::get(64, context);
+  case TypeCode::f32:
+    return mlir::FloatType::getF32(context);
+  case TypeCode::f64:
+    return mlir::FloatType::getF64(context);
   // TODO need to access mapping between fe/target
-  case TypeCode::c32: return fir::CplxType::get(context, 4);
-  case TypeCode::c64: return fir::CplxType::get(context, 8);
+  case TypeCode::c32:
+    return fir::CplxType::get(context, 4);
+  case TypeCode::c64:
+    return fir::CplxType::get(context, 8);
   // ! IOCookie is experimental only so far
   case TypeCode::IOCookie:
     return fir::ReferenceType::get(mlir::IntegerType::get(64, context));
@@ -55,8 +61,8 @@ mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
   }
 }
 
-mlir::FuncOp RuntimeStaticDescription::getFuncOp(
-    mlir::OpBuilder &builder) const {
+mlir::FuncOp
+RuntimeStaticDescription::getFuncOp(mlir::OpBuilder &builder) const {
   mlir::ModuleOp module{getModule(&builder)};
   mlir::FunctionType funTy{getMLIRFunctionType(module.getContext())};
   auto function{getNamedFunction(module, symbol)};
@@ -68,7 +74,7 @@ mlir::FuncOp RuntimeStaticDescription::getFuncOp(
   }
   return function;
 }
-}
+} // namespace Fortran::lower
 
 // TODO remove dependencies to stub rt below
 
@@ -78,17 +84,17 @@ using namespace Fortran::lower;
 
 namespace {
 
-using FuncPointer = llvm::SmallVector<mlir::Type, 4> (*)(
-    mlir::MLIRContext *, int kind);
+using FuncPointer = llvm::SmallVector<mlir::Type, 4> (*)(mlir::MLIRContext *,
+                                                         int kind);
 
 // FIXME: these are wrong and just serving as temporary placeholders
 using Cplx = mlir::IntegerType;
 using Intopt = mlir::IntegerType;
 using TypeDesc = mlir::IntegerType;
 
-template<typename A, typename... B>
-void consType(
-    llvm::SmallVector<mlir::Type, 4> &types, mlir::MLIRContext *ctx, int kind) {
+template <typename A, typename... B>
+void consType(llvm::SmallVector<mlir::Type, 4> &types, mlir::MLIRContext *ctx,
+              int kind) {
   if constexpr (std::is_same_v<A, mlir::IntegerType>) {
     types.emplace_back(A::get(kind, ctx));
   } else if constexpr (std::is_same_v<A, mlir::ComplexType>) {
@@ -103,7 +109,7 @@ void consType(
   }
 }
 
-template<typename... A>
+template <typename... A>
 llvm::SmallVector<mlir::Type, 4> consType(mlir::MLIRContext *ctx, int kind) {
   llvm::SmallVector<mlir::Type, 4> types;
   if constexpr (sizeof...(A) > 0) {
@@ -132,15 +138,16 @@ FuncPointer RuntimeEntryResultType[FIRT_LAST_ENTRY_CODE] = {
 };
 #undef UNPACK_TYPES
 
-}  // namespace
+} // namespace
 
 llvm::StringRef Br::getRuntimeEntryName(RuntimeEntryCode code) {
   assert(code < FIRT_LAST_ENTRY_CODE);
   return {RuntimeEntryNames[code]};
 }
 
-mlir::FunctionType Br::getRuntimeEntryType(
-    RuntimeEntryCode code, mlir::MLIRContext &mlirContext, int kind) {
+mlir::FunctionType Br::getRuntimeEntryType(RuntimeEntryCode code,
+                                           mlir::MLIRContext &mlirContext,
+                                           int kind) {
   assert(code < FIRT_LAST_ENTRY_CODE);
   return mlir::FunctionType::get(
       RuntimeEntryInputType[code](&mlirContext, kind),
@@ -148,7 +155,8 @@ mlir::FunctionType Br::getRuntimeEntryType(
 }
 
 mlir::FunctionType Br::getRuntimeEntryType(RuntimeEntryCode code,
-    mlir::MLIRContext &mlirContext, int inpKind, int resKind) {
+                                           mlir::MLIRContext &mlirContext,
+                                           int inpKind, int resKind) {
   assert(code < FIRT_LAST_ENTRY_CODE);
   return mlir::FunctionType::get(
       RuntimeEntryInputType[code](&mlirContext, inpKind),
diff --git a/lib/lower/runtime.h b/lib/lower/runtime.h
index 6477ef74e9c7..e722e3cf0613 100644
--- a/lib/lower/runtime.h
+++ b/lib/lower/runtime.h
@@ -20,7 +20,7 @@ class FunctionType;
 class MLIRContext;
 class OpBuilder;
 class FuncOp;
-}
+} // namespace mlir
 
 namespace Fortran::lower {
 
@@ -43,12 +43,14 @@ namespace Fortran::lower {
 /// This is the class where the constexpr data is "allocated". In fact
 /// the data is stored "in" the type. Objects of this type are not meant to
 /// be ever constructed.
-template<typename T, T... v> struct StaticVectorStorage {
+template <typename T, T... v>
+struct StaticVectorStorage {
   static constexpr T values[]{v...};
   static constexpr const T *start{&values[0]};
   static constexpr const T *end{start + sizeof...(v)};
 };
-template<typename T> struct StaticVectorStorage<T> {
+template <typename T>
+struct StaticVectorStorage<T> {
   static constexpr const T *start{nullptr}, *end{nullptr};
 };
 
@@ -57,8 +59,10 @@ template<typename T> struct StaticVectorStorage<T> {
 /// StaticVector are views over the StaticVectorStorage type that was built
 /// while instantiating the create method. They do not duplicate the values from
 /// these read-only storages.
-template<typename T> struct StaticVector {
-  template<T... v> static constexpr StaticVector create() {
+template <typename T>
+struct StaticVector {
+  template <T... v>
+  static constexpr StaticVector create() {
     using storage = StaticVectorStorage<T, v...>;
     return StaticVector{storage::start, storage::end};
   }
@@ -83,13 +87,13 @@ class RuntimeStaticDescription {
   /// descriptions. They follow mlir standard types naming. MLIR types cannot
   /// directly be used because they can only be dynamically built.
   enum TypeCode { i32, i64, f32, f64, c32, c64, IOCookie };
-  using MaybeTypeCode = std::optional<TypeCode>;  // for results
-  using TypeCodeVector = StaticVector<TypeCode>;  // for arguments
+  using MaybeTypeCode = std::optional<TypeCode>; // for results
+  using TypeCodeVector = StaticVector<TypeCode>; // for arguments
   static constexpr MaybeTypeCode voidTy{MaybeTypeCode{std::nullopt}};
 
-  constexpr RuntimeStaticDescription(
-      const char *s, MaybeTypeCode r, TypeCodeVector a)
-    : symbol{s}, resultTypeCode{r}, argumentTypeCodes{a} {}
+  constexpr RuntimeStaticDescription(const char *s, MaybeTypeCode r,
+                                     TypeCodeVector a)
+      : symbol{s}, resultTypeCode{r}, argumentTypeCodes{a} {}
   const char *getSymbol() const { return symbol; }
   /// Conversion between types of the static representation and MLIR types.
   mlir::FunctionType getMLIRFunctionType(mlir::MLIRContext *) const;
@@ -114,7 +118,8 @@ class RuntimeStaticDescription {
 // This is currently here because this was designed to provide
 // maps over runtime description without the burden of having to
 // instantiate these maps dynamically and to keep them somewhere.
-template<typename V> class StaticMultimapView {
+template <typename V>
+class StaticMultimapView {
 public:
   using Key = typename V::Key;
   struct Range {
@@ -132,10 +137,11 @@ template<typename V> class StaticMultimapView {
   };
   using const_iterator = typename Range::const_iterator;
 
-  template<std::size_t N>
+  template <std::size_t N>
   constexpr StaticMultimapView(const V (&array)[N])
-    : range{&array[0], &array[0] + N} {}
-  template<typename Key> constexpr bool verify() {
+      : range{&array[0], &array[0] + N} {}
+  template <typename Key>
+  constexpr bool verify() {
     // TODO: sorted
     // non empty increasing pointer direction
     return !range.empty();
@@ -166,8 +172,8 @@ template<typename V> class StaticMultimapView {
     return Range{start, end};
   }
 
-  constexpr std::pair<const_iterator, const_iterator> equal_range(
-      const Key &key) const {
+  constexpr std::pair<const_iterator, const_iterator>
+  equal_range(const Key &key) const {
     Range range{getRange(key)};
     return {range.begin(), range.end()};
   }
@@ -190,12 +196,14 @@ enum RuntimeEntryCode {
 
 llvm::StringRef getRuntimeEntryName(RuntimeEntryCode code);
 
-mlir::FunctionType getRuntimeEntryType(
-    RuntimeEntryCode code, mlir::MLIRContext &mlirContext, int kind);
+mlir::FunctionType getRuntimeEntryType(RuntimeEntryCode code,
+                                       mlir::MLIRContext &mlirContext,
+                                       int kind);
 
 mlir::FunctionType getRuntimeEntryType(RuntimeEntryCode code,
-    mlir::MLIRContext &mlirContext, int inpKind, int resKind);
+                                       mlir::MLIRContext &mlirContext,
+                                       int inpKind, int resKind);
 
-}  // Fortran::lower
+} // namespace Fortran::lower
 
-#endif  // FORTRAN_LOWER_RUNTIME_H_
+#endif // FORTRAN_LOWER_RUNTIME_H_
diff --git a/lib/fir/Attribute.cpp b/lib/optimizer/Attribute.cpp
similarity index 98%
rename from lib/fir/Attribute.cpp
rename to lib/optimizer/Attribute.cpp
index 62338be35e3c..1595f0161896 100644
--- a/lib/fir/Attribute.cpp
+++ b/lib/optimizer/Attribute.cpp
@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fir/Attribute.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIRType.h"
+#include "optimizer/Attribute.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/FIRType.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 
diff --git a/lib/fir/CMakeLists.txt b/lib/optimizer/CMakeLists.txt
similarity index 98%
rename from lib/fir/CMakeLists.txt
rename to lib/optimizer/CMakeLists.txt
index cb11645a22c0..33885e026597 100644
--- a/lib/fir/CMakeLists.txt
+++ b/lib/optimizer/CMakeLists.txt
@@ -18,6 +18,7 @@ add_subdirectory(Transforms)
 
 add_llvm_library(FIR
   Attribute.cpp
+  CodeGen.cpp
   FIRDialect.cpp
   FIROps.cpp
   FIRType.cpp
@@ -25,7 +26,6 @@ add_llvm_library(FIR
   IteratedDominanceFrontier.cpp
   KindMapping.cpp
   StdConverter.cpp
-  Tilikum.cpp
 )
 
 add_dependencies(FIR FIROpsIncGen)
diff --git a/lib/fir/Tilikum.cpp b/lib/optimizer/CodeGen.cpp
similarity index 99%
rename from lib/fir/Tilikum.cpp
rename to lib/optimizer/CodeGen.cpp
index c02fa34b3122..778da284c884 100644
--- a/lib/fir/Tilikum.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/Tilikum.cpp -------------------------------------*- C++ -*-===//
+//===-- lib/optimizer/CodeGen.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.
@@ -6,13 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Tilikum/Tilikum.h"
-#include "fir/Attribute.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
-#include "fir/InternalNames.h"
-#include "fir/KindMapping.h"
+#include "optimizer/CodeGen/CodeGen.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
@@ -22,6 +16,12 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Target/LLVMIR.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "optimizer/Attribute.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/FIRType.h"
+#include "optimizer/InternalNames.h"
+#include "optimizer/KindMapping.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Config/abi-breaking.h"
 #include "llvm/IR/IRBuilder.h"
diff --git a/lib/fir/FIRDialect.cpp b/lib/optimizer/FIRDialect.cpp
similarity index 91%
rename from lib/fir/FIRDialect.cpp
rename to lib/optimizer/FIRDialect.cpp
index c3d3ba580e56..56c2bd4d5269 100644
--- a/lib/fir/FIRDialect.cpp
+++ b/lib/optimizer/FIRDialect.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/FIRDialect.cpp ----------------------------------*- C++ -*-===//
+//===-- lib/optimizer/FIRDialect.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.
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/FIRDialect.h"
-#include "fir/Attribute.h"
-#include "fir/FIROps.h"
-#include "fir/FIRType.h"
+#include "optimizer/FIRDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Transforms/SideEffectsInterface.h"
+#include "optimizer/Attribute.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/FIRType.h"
 
 namespace M = mlir;
 
@@ -51,7 +51,7 @@ fir::FIROpsDialect::FIROpsDialect(M::MLIRContext *ctx)
                 PointIntervalAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<GlobalOp, DispatchTableOp,
 #define GET_OP_LIST
-#include "fir/FIROps.cpp.inc"
+#include "optimizer/FIROps.cpp.inc"
                 >();
 }
 
diff --git a/lib/fir/FIROps.cpp b/lib/optimizer/FIROps.cpp
similarity index 98%
rename from lib/fir/FIROps.cpp
rename to lib/optimizer/FIROps.cpp
index a6c5aa30eeac..817a95dc0208 100644
--- a/lib/fir/FIROps.cpp
+++ b/lib/optimizer/FIROps.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/FIROps.cpp --------------------------------------*- C++ -*-===//
+//===-- lib/optimizer/FIROps.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.
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/FIROps.h"
-#include "fir/Attribute.h"
-#include "fir/FIROpsSupport.h"
-#include "fir/FIRType.h"
+#include "optimizer/FIROps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
+#include "optimizer/Attribute.h"
+#include "optimizer/FIROpsSupport.h"
+#include "optimizer/FIRType.h"
 #include "llvm/ADT/StringSwitch.h"
 
 namespace L = llvm;
@@ -632,6 +632,6 @@ GlobalOp createGlobalOp(M::Location loc, M::ModuleOp module, StringRef name,
 // Tablegen operators
 
 #define GET_OP_CLASSES
-#include "fir/FIROps.cpp.inc"
+#include "optimizer/FIROps.cpp.inc"
 
 } // namespace fir
diff --git a/lib/fir/FIRType.cpp b/lib/optimizer/FIRType.cpp
similarity index 99%
rename from lib/fir/FIRType.cpp
rename to lib/optimizer/FIRType.cpp
index 8b020f6e88d7..a6fa1f4b8f55 100644
--- a/lib/fir/FIRType.cpp
+++ b/lib/optimizer/FIRType.cpp
@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fir/FIRType.h"
-#include "fir/FIRDialect.h"
+#include "optimizer/FIRType.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Parser.h"
+#include "optimizer/FIRDialect.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
 
diff --git a/lib/fir/InternalNames.cpp b/lib/optimizer/InternalNames.cpp
similarity index 99%
rename from lib/fir/InternalNames.cpp
rename to lib/optimizer/InternalNames.cpp
index 2dcd04114222..21996aeaa661 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/optimizer/InternalNames.cpp
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fir/InternalNames.h"
+#include "optimizer/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
diff --git a/lib/fir/IteratedDominanceFrontier.cpp b/lib/optimizer/IteratedDominanceFrontier.cpp
similarity index 98%
rename from lib/fir/IteratedDominanceFrontier.cpp
rename to lib/optimizer/IteratedDominanceFrontier.cpp
index d35ce321bc7a..855b9d55abc7 100644
--- a/lib/fir/IteratedDominanceFrontier.cpp
+++ b/lib/optimizer/IteratedDominanceFrontier.cpp
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Analysis/IteratedDominanceFrontier.h"
+#include "optimizer/Analysis/IteratedDominanceFrontier.h"
 #include "mlir/Analysis/Dominance.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
diff --git a/lib/fir/KindMapping.cpp b/lib/optimizer/KindMapping.cpp
similarity index 99%
rename from lib/fir/KindMapping.cpp
rename to lib/optimizer/KindMapping.cpp
index 6860667e2ae2..25041c0c3f57 100644
--- a/lib/fir/KindMapping.cpp
+++ b/lib/optimizer/KindMapping.cpp
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fir/KindMapping.h"
+#include "optimizer/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
diff --git a/lib/fir/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
similarity index 96%
rename from lib/fir/StdConverter.cpp
rename to lib/optimizer/StdConverter.cpp
index 9aec45902e10..378d6058962d 100644
--- a/lib/fir/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/StdConverter.cpp --------------------------------*- C++ -*-===//
+//===-- lib/optimizer/StdConverter.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.
@@ -6,17 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Transforms/StdConverter.h"
-#include "fir/Attribute.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIROpsSupport.h"
-#include "fir/FIRType.h"
-#include "fir/KindMapping.h"
+#include "optimizer/Transforms/StdConverter.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "optimizer/Attribute.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/FIROpsSupport.h"
+#include "optimizer/FIRType.h"
+#include "optimizer/KindMapping.h"
 #include "llvm/ADT/ArrayRef.h"
 
 // This module performs the conversion of some FIR operations.
diff --git a/lib/fir/Transforms/CMakeLists.txt b/lib/optimizer/Transforms/CMakeLists.txt
similarity index 100%
rename from lib/fir/Transforms/CMakeLists.txt
rename to lib/optimizer/Transforms/CMakeLists.txt
diff --git a/lib/fir/Transforms/CSE.cpp b/lib/optimizer/Transforms/CSE.cpp
similarity index 98%
rename from lib/fir/Transforms/CSE.cpp
rename to lib/optimizer/Transforms/CSE.cpp
index a5f8fcd14d73..83e718fdc5ca 100644
--- a/lib/fir/Transforms/CSE.cpp
+++ b/lib/optimizer/Transforms/CSE.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/Transforms/CSE.cpp ------------------------------*- C++ -*-===//
+//===-- lib/optimizer/Transforms/CSE.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.
@@ -12,8 +12,6 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#include "fir/FIROpsSupport.h"
-#include "fir/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
@@ -22,6 +20,8 @@
 #include "mlir/Support/Functional.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
+#include "optimizer/FIROpsSupport.h"
+#include "optimizer/Transforms/Passes.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/ScopedHashTable.h"
diff --git a/lib/fir/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
similarity index 99%
rename from lib/fir/Transforms/MemToReg.cpp
rename to lib/optimizer/Transforms/MemToReg.cpp
index 5e4d550db0dc..bd565a4d2c04 100644
--- a/lib/fir/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/Transforms/MemToReg.cpp -------------------------*- C++ -*-===//
+//===-- lib/optimizer/Transforms/MemToReg.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.
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Analysis/IteratedDominanceFrontier.h"
-#include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
-#include "fir/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/Pass/Pass.h"
+#include "optimizer/Analysis/IteratedDominanceFrontier.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/Transforms/Passes.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include <utility>
diff --git a/lib/fir/Transforms/RewriteLoop.cpp b/lib/optimizer/Transforms/RewriteLoop.cpp
similarity index 98%
rename from lib/fir/Transforms/RewriteLoop.cpp
rename to lib/optimizer/Transforms/RewriteLoop.cpp
index 548beed9fb3c..0c80e835b178 100644
--- a/lib/fir/Transforms/RewriteLoop.cpp
+++ b/lib/optimizer/Transforms/RewriteLoop.cpp
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/FIRDialect.h"
-#include "fir/FIROps.h"
-#include "fir/Transforms/Passes.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/FIROps.h"
+#include "optimizer/Transforms/Passes.h"
 #include "llvm/Support/CommandLine.h"
 #include <memory>
 
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index e88df7ad1853..90f7620e70f2 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -14,10 +14,16 @@
 
 // Temporary Fortran front end driver main program for development scaffolding.
 
-#include "../../lib/lower/bridge.h"
-#include "../../lib/lower/convert-expr.h"
+#include "optimizer/CodeGen/CodeGen.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/InternalNames.h"
+#include "optimizer/KindMapping.h"
+#include "optimizer/Transforms/Passes.h"
+#include "optimizer/Transforms/StdConverter.h"
 #include "../../lib/common/Fortran-features.h"
 #include "../../lib/common/default-kinds.h"
+#include "../../lib/lower/bridge.h"
+#include "../../lib/lower/convert-expr.h"
 #include "../../lib/parser/characters.h"
 #include "../../lib/parser/dump-parse-tree.h"
 #include "../../lib/parser/message.h"
@@ -29,12 +35,6 @@
 #include "../../lib/semantics/expression.h"
 #include "../../lib/semantics/semantics.h"
 #include "../../lib/semantics/unparse-with-symbols.h"
-#include "fir/FIRDialect.h"
-#include "fir/InternalNames.h"
-#include "fir/KindMapping.h"
-#include "fir/Tilikum/Tilikum.h"
-#include "fir/Transforms/Passes.h"
-#include "fir/Transforms/StdConverter.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 88c5f4efad32..5b473b863073 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -11,18 +11,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/FIRDialect.h"
-#include "fir/InternalNames.h"
-#include "fir/KindMapping.h"
-#include "fir/Tilikum/Tilikum.h"
-#include "fir/Transforms/Passes.h"
-#include "fir/Transforms/StdConverter.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/InitLLVM.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/raw_ostream.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
@@ -30,14 +18,27 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"
+#include "optimizer/CodeGen/CodeGen.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/InternalNames.h"
+#include "optimizer/KindMapping.h"
+#include "optimizer/Transforms/Passes.h"
+#include "optimizer/Transforms/StdConverter.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-static cl::opt<std::string> ClInput(
-    cl::Positional, cl::Required, cl::desc("<input file>"));
+static cl::opt<std::string> ClInput(cl::Positional, cl::Required,
+                                    cl::desc("<input file>"));
 
 static cl::opt<std::string> ClOutput("o", cl::desc("Specify output filename"),
-    cl::value_desc("filename"), cl::init("a.ll"));
+                                     cl::value_desc("filename"),
+                                     cl::init("a.ll"));
 
 // compile a .fir file
 int compileFIR() {

From 77a44ad5a84da3179ed00c9c364604ae0cd9469f Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Jan 2020 12:17:30 -0800
Subject: [PATCH 154/345] turn some asserts into emitErrors

---
 lib/lower/convert-type.cc | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/lib/lower/convert-type.cc b/lib/lower/convert-type.cc
index f44bcebedc37..ed0c34d71045 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -177,6 +177,10 @@ class TypeBuilder {
   }
   int defaultKind(Co::TypeCategory TC) { return defaults.GetDefaultKind(TC); }
 
+  M::InFlightDiagnostic emitError(const llvm::Twine &message) {
+    return M::emitError(M::UnknownLoc::get(context), message);
+  }
+
 public:
   explicit TypeBuilder(M::MLIRContext *context,
                        Co::IntrinsicTypeDefaultKinds const &defaults)
@@ -331,7 +335,7 @@ class TypeBuilder {
     if (symbol->detailsIf<Se::SubprogramDetails>()) {
       return genFunctionType(symbol);
     }
-    M::Type returnTy{};
+    M::Type returnTy;
     if (auto *type{symbol->GetType()}) {
       if (auto *tySpec{type->AsIntrinsic()}) {
         int kind = toConstant(tySpec->kind());
@@ -351,18 +355,20 @@ class TypeBuilder {
         case LogicalCat:
           returnTy = genFIRType<LogicalCat>(context, kind);
           break;
-        case DerivedCat:
-          TODO();
-          break;
+        default:
+          emitError("unhandled intrinsic type; should not reach here");
+          return {};
         }
       } else if (auto *tySpec{type->AsDerived()}) {
         (void)tySpec; // FIXME
         TODO();
       } else {
-        assert(false && "type spec not found");
+        emitError("symbol's type must have a type spec");
+        return {};
       }
     } else {
-      assert(false && "symbol has no type");
+      emitError("symbol must have a type");
+      return {};
     }
     if (symbol->IsObjectArray()) {
       // FIXME: add bounds info

From cb926e9b87163afa49411fa65fed239cab99a5fd Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Jan 2020 13:44:06 -0800
Subject: [PATCH 155/345] a little work on lowering of fortran derived types.
 the front-end doesn't provide enough information, so we can't really lower
 these properly yet.

---
 lib/lower/convert-expr.cc |  2 +-
 lib/lower/convert-type.cc | 37 ++++++++++++++++++++++++++++++++++---
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/lib/lower/convert-expr.cc b/lib/lower/convert-expr.cc
index 03012217f0fb..eaa85cfc8b8e 100644
--- a/lib/lower/convert-expr.cc
+++ b/lib/lower/convert-expr.cc
@@ -598,7 +598,7 @@ class ExprLowering {
     auto *base{reverseComponents(cmpt, list)};
     L::SmallVector<M::Value, 2> coorArgs;
     auto obj{gen(*base)};
-    const Se::Symbol *sym{nullptr};
+    auto *sym = &cmpt.GetFirstSymbol();
     M::Type ty{converter.genType(*sym)};
     for (auto *field : list) {
       sym = &field->GetLastSymbol();
diff --git a/lib/lower/convert-type.cc b/lib/lower/convert-type.cc
index ed0c34d71045..a9013aecd85f 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -181,6 +181,14 @@ class TypeBuilder {
     return M::emitError(M::UnknownLoc::get(context), message);
   }
 
+  M::InFlightDiagnostic emitWarning(const llvm::Twine &message) {
+    return M::emitWarning(M::UnknownLoc::get(context), message);
+  }
+
+  llvm::StringRef toStrRef(const Pa::CharBlock &cb) {
+    return {cb.begin(), cb.size()};
+  }
+
 public:
   explicit TypeBuilder(M::MLIRContext *context,
                        Co::IntrinsicTypeDefaultKinds const &defaults)
@@ -356,12 +364,35 @@ class TypeBuilder {
           returnTy = genFIRType<LogicalCat>(context, kind);
           break;
         default:
-          emitError("unhandled intrinsic type; should not reach here");
+          emitError("symbol has unknown intrinsic type");
           return {};
         }
       } else if (auto *tySpec{type->AsDerived()}) {
-        (void)tySpec; // FIXME
-        TODO();
+        std::vector<std::pair<std::string, M::Type>> ps;
+        std::vector<std::pair<std::string, M::Type>> cs;
+        auto &symbol = tySpec->typeSymbol();
+        // FIXME: don't want to recurse forever here, but this won't happen
+        // since we don't know the components at this time
+        auto rec = fir::RecordType::get(context, toStrRef(symbol.name()));
+        auto &details = symbol.get<Se::DerivedTypeDetails>();
+        for (auto &param : details.paramDecls()) {
+          auto &p{*param};
+          ps.push_back(std::pair{p.name().ToString(), gen(p)});
+        }
+#if 0
+        // this functionality is missing in the front-end
+        for (auto &comp : details.componentDecls()) {
+          auto &c{*comp};
+          cs.push_back(std::pair{c.name().ToString(), gen(c)});
+        }
+#else
+        emitWarning("the front-end returns symbols of derived type that have "
+                    "components that are simple names and not symbols, so "
+                    "cannot construct type " +
+                    toStrRef(symbol.name()));
+#endif
+        rec.finalize(ps, cs);
+        returnTy = rec;
       } else {
         emitError("symbol's type must have a type spec");
         return {};

From 3473671d68eed3b657326d0a54d02bd34b6b6867 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Jan 2020 14:14:45 -0800
Subject: [PATCH 156/345] remove unused file

---
 lib/lower/mixin.h | 78 -----------------------------------------------
 1 file changed, 78 deletions(-)
 delete mode 100644 lib/lower/mixin.h

diff --git a/lib/lower/mixin.h b/lib/lower/mixin.h
deleted file mode 100644
index a1b810312baa..000000000000
--- a/lib/lower/mixin.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef FORTRAN_LOWER_MIXIN_H_
-#define FORTRAN_LOWER_MIXIN_H_
-
-// Mixin classes are "partial" classes (not used standalone) that can be used to
-// add a repetitive (ad hoc) interface (and implementation) to a class.  It's
-// better to think of these as "included in" a class, rather than as an
-// "inherited from" base class.
-
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
-
-#include "llvm/ADT/ilist.h"
-#include <optional>
-#include <tuple>
-#include <type_traits>
-#include <variant>
-
-namespace Fortran::lower {
-
-// implementation of a (moveable) sum type (variant)
-template <typename... Ts>
-struct SumTypeMixin {
-  using SumTypeTrait = std::true_type;
-  template <typename A>
-  SumTypeMixin(const A &x) : u{x} {}
-  template <typename A>
-  SumTypeMixin(A &&x) : u{std::forward<A>(x)} {}
-  SumTypeMixin(SumTypeMixin &&) = default;
-  SumTypeMixin &operator=(SumTypeMixin &&) = default;
-  SumTypeMixin(const SumTypeMixin &) = delete;
-  SumTypeMixin &operator=(const SumTypeMixin &) = delete;
-  SumTypeMixin() = delete;
-  std::variant<Ts...> u;
-};
-
-// implementation of a copyable sum type
-template <typename... Ts>
-struct SumTypeCopyMixin {
-  using CopyableSumTypeTrait = std::true_type;
-  template <typename A>
-  SumTypeCopyMixin(const A &x) : u{x} {}
-  template <typename A>
-  SumTypeCopyMixin(A &&x) : u{std::forward<A>(x)} {}
-  SumTypeCopyMixin(SumTypeCopyMixin &&) = default;
-  SumTypeCopyMixin &operator=(SumTypeCopyMixin &&) = default;
-  SumTypeCopyMixin(const SumTypeCopyMixin &) = default;
-  SumTypeCopyMixin &operator=(const SumTypeCopyMixin &) = default;
-  SumTypeCopyMixin() = delete;
-  std::variant<Ts...> u;
-};
-#define SUM_TYPE_COPY_MIXIN(DT)                                                \
-  DT(const DT &derived) : SumTypeCopyMixin(derived.u) {}                       \
-  DT(DT &&derived) : SumTypeCopyMixin(std::move(derived.u)) {}                 \
-  DT &operator=(const DT &derived) {                                           \
-    SumTypeCopyMixin::operator=(derived.u);                                    \
-    return *this;                                                              \
-  }                                                                            \
-  DT &operator=(DT &&derived) {                                                \
-    SumTypeCopyMixin::operator=(std::move(derived.u));                         \
-    return *this;                                                              \
-  }
-
-} // namespace Fortran::lower
-
-#endif // FORTRAN_LOWER_MIXIN_H_

From 422c20c9967c2b2342533a6ca0f126d791225c49 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Mon, 6 Jan 2020 11:22:18 -0800
Subject: [PATCH 157/345] Implement substring and character(*) assignement
 lowering

---
 lib/lower/bridge.cc       | 21 ++++---------
 lib/lower/convert-expr.cc | 66 ++++++++++++++++++++++++++++++++++-----
 lib/lower/convert-type.cc |  8 +++++
 lib/lower/convert-type.h  |  7 +++++
 4 files changed, 79 insertions(+), 23 deletions(-)

diff --git a/lib/lower/bridge.cc b/lib/lower/bridge.cc
index fbdbde349be8..3d593869dd23 100644
--- a/lib/lower/bridge.cc
+++ b/lib/lower/bridge.cc
@@ -685,9 +685,6 @@ class FirConverter : public AbstractConverter {
       M::Value addr = genExprAddr(charDesignatorExpr);
       const auto &charExpr{
           std::get<Ev::Expr<Ev::SomeCharacter>>(charDesignatorExpr.u)};
-      // FIXME LEN() should also succeed on character(*) and return a
-      // DescriptorInquiry, this does not work but should be fixed after FIR f18
-      // is rebased with master f18 that contains PR871.
       std::optional<Ev::Expr<Ev::SubscriptInteger>> lenExpr{charExpr.LEN()};
       assert(lenExpr && "could not get expression to compute character length");
       M::Value len = genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)));
@@ -705,21 +702,14 @@ class FirConverter : public AbstractConverter {
     // Generate the copy.
     // FIXME: Currently assumes no overlap (else a temp should be used).
 
-    // Get reference and character type.
+    // Get character sequence reference type for fir::CoordinateOp.
     assert(lhsAddrAndLen.first && "could not get character variable address");
-    auto charRefType{
-        lhsAddrAndLen.first->getType().dyn_cast<fir::ReferenceType>()};
-    assert(charRefType && "expected character reference type");
-    auto charType{charRefType.getEleTy()};
-    // Cast character string to array of character to index it in fir.loop
-    // This is currently required by fir::CoordinateOp.
-    fir::SequenceType::Shape shape{-1};
-    auto arrayRefCharType{
-        fir::ReferenceType::get(fir::SequenceType::get(shape, charType))};
+    auto charRefType{lhsAddrAndLen.first.getType()};
+    auto charSequenceRefType{getSequenceRefType(charRefType)};
     auto lhsArrayView{builder->create<fir::ConvertOp>(
-        toLocation(), arrayRefCharType, lhsAddrAndLen.first)};
+        toLocation(), charSequenceRefType, lhsAddrAndLen.first)};
     auto rhsArrayView{builder->create<fir::ConvertOp>(
-        toLocation(), arrayRefCharType, rhsAddrAndLen.first)};
+        toLocation(), charSequenceRefType, rhsAddrAndLen.first)};
 
     // Build loop to copy rhs
     auto indexTy{M::IndexType::get(builder->getContext())};
@@ -756,6 +746,7 @@ class FirConverter : public AbstractConverter {
     auto byteTy{M::IntegerType::get(8, builder->getContext())};
     auto asciiSpace{builder->create<M::ConstantOp>(
         toLocation(), byteTy, builder->getIntegerAttr(byteTy, 32))};
+    auto charType{charRefType.dyn_cast<fir::ReferenceType>().getEleTy()};
     auto blank{
         builder->create<fir::ConvertOp>(toLocation(), charType, asciiSpace)};
     auto padLoop{builder->create<fir::LoopOp>(toLocation(), copyMaxIndex,
diff --git a/lib/lower/convert-expr.cc b/lib/lower/convert-expr.cc
index eaa85cfc8b8e..103879d54aee 100644
--- a/lib/lower/convert-expr.cc
+++ b/lib/lower/convert-expr.cc
@@ -280,7 +280,31 @@ class ExprLowering {
   M::Value genval(Ev::NullPointer const &) { TODO(); }
   M::Value genval(Ev::StructureConstructor const &) { TODO(); }
   M::Value genval(Ev::ImpliedDoIndex const &) { TODO(); }
-  M::Value genval(Ev::DescriptorInquiry const &) { TODO(); }
+  M::Value genval(Ev::DescriptorInquiry const &desc) {
+    auto descRef{symMap.lookupSymbol(desc.base().GetLastSymbol())};
+    assert(descRef && "no mlir::Value associated to Symbol");
+    auto descType{descRef->getType()};
+    M::Value res{};
+    switch (desc.field()) {
+    case Ev::DescriptorInquiry::Field::Len:
+      if (auto boxCharType{descType.dyn_cast<fir::BoxCharType>()}) {
+        auto refType{fir::ReferenceType::get(boxCharType.getEleTy())};
+        auto lenType{mlir::IntegerType::get(64, builder.getContext())};
+        res = builder
+                  .create<fir::UnboxCharOp>(getLoc(), refType, lenType, descRef)
+                  .getResult(1);
+      } else if (descType.isa<fir::BoxType>()) {
+        TODO();
+      } else {
+        assert(false && "not a descriptor");
+      }
+      break;
+    default:
+      TODO();
+    }
+    return res;
+  }
+
   template <int KIND>
   M::Value genval(Ev::TypeParamInquiry<KIND> const &) {
     TODO();
@@ -382,12 +406,10 @@ class ExprLowering {
   /// MIN and MAX operations
   template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Extremum<Ev::Type<TC, KIND>> const &op) {
-    if constexpr (TC == IntegerCat) {
-      return createBinaryFIRTCall<TC, KIND>(
-          op, op.ordering == Ev::Ordering::Greater ? FIRT_MAX : FIRT_MIN);
-    } else {
-      TODO();
-    }
+    std::string name{op.ordering == Ev::Ordering::Greater ? "max" : "min"};
+    M::Type type{converter.genType(TC, KIND)};
+    L::SmallVector<M::Value, 2> operands{genval(op.left()), genval(op.right())};
+    return intrinsics.genval(getLoc(), builder, name, type, operands);
   }
 
   template <int KIND>
@@ -555,7 +577,35 @@ class ExprLowering {
   M::Value gen(Ev::ComplexPart const &) { TODO(); }
   M::Value gendef(Ev::ComplexPart const &cp) { return gen(cp); }
   M::Value genval(Ev::ComplexPart const &) { TODO(); }
-  M::Value gen(const Ev::Substring &) { TODO(); }
+
+  M::Value gen(const Ev::Substring &s) {
+    // Get base address
+    auto baseAddr{std::visit(
+        Co::visitors{
+            [&](const Ev::DataRef &x) { return gen(x); },
+            [&](const Ev::StaticDataObject::Pointer &) -> M::Value { TODO(); },
+        },
+        s.parent())};
+    // Get a SequenceType to compute address with fir::CoordinateOp
+    auto charRefType{baseAddr.getType()};
+    auto arrayRefType{getSequenceRefType(charRefType)};
+    auto arrayView{
+        builder.create<fir::ConvertOp>(getLoc(), arrayRefType, baseAddr)};
+    // Compute lower bound
+    auto indexType{M::IndexType::get(builder.getContext())};
+    auto lowerBoundExpr{s.lower()};
+    auto lowerBoundValue{builder.create<fir::ConvertOp>(
+        getLoc(), indexType, genval(lowerBoundExpr))};
+    // FIR CoordinateOp is zero based but Fortran substring are one based.
+    auto one{builder.create<M::ConstantOp>(
+        getLoc(), indexType, builder.getIntegerAttr(indexType, 1))};
+    auto offsetIndex{
+        builder.create<M::SubIOp>(getLoc(), lowerBoundValue, one).getResult()};
+    // Get address from offset and base address
+    return builder.create<fir::CoordinateOp>(getLoc(), charRefType, arrayView,
+                                             offsetIndex);
+  }
+
   M::Value gendef(const Ev::Substring &ss) { return gen(ss); }
   M::Value genval(const Ev::Substring &) { TODO(); }
   M::Value genval(const Ev::Triplet &trip) { TODO(); }
diff --git a/lib/lower/convert-type.cc b/lib/lower/convert-type.cc
index a9013aecd85f..d2cf08af883f 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -488,3 +488,11 @@ M::FunctionType Br::translateSymbolToFIRFunctionType(
 M::Type Br::convertReal(M::MLIRContext *context, int kind) {
   return genFIRType<RealCat>(context, kind);
 }
+
+M::Type Br::getSequenceRefType(M::Type refType) {
+  auto type{refType.dyn_cast<fir::ReferenceType>()};
+  assert(type && "expected a reference type");
+  auto elementType{type.getEleTy()};
+  fir::SequenceType::Shape shape{-1};
+  return fir::ReferenceType::get(fir::SequenceType::get(shape, elementType));
+}
diff --git a/lib/lower/convert-type.h b/lib/lower/convert-type.h
index eab38f38da30..71a51a140236 100644
--- a/lib/lower/convert-type.h
+++ b/lib/lower/convert-type.h
@@ -115,6 +115,13 @@ mlir::FunctionType translateSymbolToFIRFunctionType(
 
 mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
+// Given a ReferenceType of a base type, returns the ReferenceType to
+// the SequenceType of this base type.
+// The created SequenceType has one dimension of unknown extent.
+// This is useful to do pointer arithmetic using fir::CoordinateOp that requires
+// a memory reference to a sequence type.
+mlir::Type getSequenceRefType(mlir::Type referenceType);
+
 } // namespace lower
 } // namespace Fortran
 

From 62e1d07aa64fc796405e81d055e9d18a896c0769 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Jan 2020 13:07:01 -0800
Subject: [PATCH 158/345] strip down bbc

---
 tools/bbc/bbc.cpp | 574 ++++++++--------------------------------------
 1 file changed, 98 insertions(+), 476 deletions(-)

diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 90f7620e70f2..b1b21a2f783f 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -1,25 +1,15 @@
-// Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+//===- bbc.cpp - Burnside Bridge Compiler -----------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
+// =============================================================================
 //
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Temporary Fortran front end driver main program for development scaffolding.
+// This is a tool for translating Fortran sources to the FIR dialect of MLIR.
+//
+//===----------------------------------------------------------------------===//
 
-#include "optimizer/CodeGen/CodeGen.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/InternalNames.h"
-#include "optimizer/KindMapping.h"
-#include "optimizer/Transforms/Passes.h"
-#include "optimizer/Transforms/StdConverter.h"
 #include "../../lib/common/Fortran-features.h"
 #include "../../lib/common/default-kinds.h"
 #include "../../lib/lower/bridge.h"
@@ -35,10 +25,6 @@
 #include "../../lib/semantics/expression.h"
 #include "../../lib/semantics/semantics.h"
 #include "../../lib/semantics/unparse-with-symbols.h"
-#include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/raw_ostream.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
@@ -46,151 +32,59 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"
-#include <cerrno>
-#include <cstdio>
-#include <cstring>
-#include <fstream>
-#include <functional>
+#include "optimizer/CodeGen/CodeGen.h"
+#include "optimizer/FIRDialect.h"
+#include "optimizer/InternalNames.h"
+#include "optimizer/KindMapping.h"
+#include "optimizer/Transforms/Passes.h"
+#include "optimizer/Transforms/StdConverter.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
 #include <iostream>
-#include <list>
-#include <memory>
-#include <optional>
-#include <stdlib.h>
-#include <string>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <vector>
 
 namespace Br = Fortran::lower;
 
-static std::list<std::string> argList(int argc, char *const argv[]) {
-  std::list<std::string> result;
-  for (int j = 0; j < argc; ++j) {
-    result.emplace_back(argv[j]);
-  }
-  return result;
-}
-
-struct MeasurementVisitor {
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {
-    ++objects;
-    bytes += sizeof(A);
-  }
-  size_t objects{0}, bytes{0};
-};
+using namespace llvm;
 
-void MeasureParseTree(const Fortran::parser::Program &program) {
-  MeasurementVisitor visitor;
-  Fortran::parser::Walk(program, visitor);
-  std::cout << "Parse tree comprises " << visitor.objects
-            << " objects and occupies " << visitor.bytes << " total bytes.\n";
-}
+namespace {
 
-std::vector<std::string> filesToDelete;
+// Some basic command-line options
+cl::opt<std::string> InputFilename(cl::Positional, cl::Required,
+                                   cl::desc("<input file>"));
 
-void CleanUpAtExit() {
-  for (const auto &path : filesToDelete) {
-    if (!path.empty()) {
-      unlink(path.data());
-    }
-  }
-}
+cl::opt<std::string> OutputFilename("o",
+                                    cl::desc("Specify the output filename"),
+                                    cl::value_desc("filename"),
+                                    cl::init("a.mlir"));
 
-struct DriverOptions {
-  DriverOptions() {}
-  bool verbose{false};  // -v
-  bool compileOnly{false};  // -c
-  std::string outputPath;  // -o path
-  std::vector<std::string> searchDirectories{"."s};  // -I dir
-  std::string moduleDirectory{"."s};  // -module dir
-  std::string moduleFileSuffix{".mod"};  // -moduleSuffix suff
-  bool forcedForm{false};  // -Mfixed or -Mfree appeared
-  bool warnOnNonstandardUsage{false};  // -Mstandard
-  bool warningsAreErrors{false};  // -Werror
-  Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
-  bool parseOnly{false};
-  bool dumpProvenance{false};
-  bool dumpCookedChars{false};
-  bool dumpUnparse{false};
-  bool dumpUnparseWithSymbols{false};
-  bool dumpParseTree{false};
-  bool dumpSymbols{false};
-  bool debugResolveNames{false};
-  bool debugSemantics{false};
-  bool measureTree{false};
-  bool runBackend{true};
-  bool dumpHLFIR{true};
-  bool dumpFIR{true};
-  bool lowerToStd{true};
-  bool lowerToLLVM{true};
-  bool lowerToLLVMIR{true};
-  bool isFirInput{false};
-  std::vector<std::string> pgf90Args;
-  const char *prefix{nullptr};
-};
+cl::list<std::string> IncludeDirs("I", cl::desc("include search paths"));
 
-bool ParentProcess() {
-  if (fork() == 0) {
-    return false;  // in child process
-  }
-  int childStat{0};
-  wait(&childStat);
-  if (!WIFEXITED(childStat) || WEXITSTATUS(childStat) != 0) {
-    exit(EXIT_FAILURE);
-  }
-  return true;
-}
+cl::list<std::string> ModuleDirs("module", cl::desc("module search paths"));
 
-void Exec(std::vector<char *> &argv, bool verbose = false) {
-  if (verbose) {
-    for (size_t j{0}; j < argv.size(); ++j) {
-      std::cerr << (j > 0 ? " " : "") << argv[j];
-    }
-    std::cerr << '\n';
-  }
-  argv.push_back(nullptr);
-  execvp(argv[0], &argv[0]);
-  std::cerr << "execvp(" << argv[0] << ") failed: " << std::strerror(errno)
-            << '\n';
-  exit(EXIT_FAILURE);
-}
+cl::opt<std::string> ModuleSuffix("module-suffix",
+                                  cl::desc("module file suffix override"),
+                                  cl::init(".mod"));
 
-void RunOtherCompiler(DriverOptions &driver, char *source, char *relo) {
-  std::vector<char *> argv;
-  for (size_t j{0}; j < driver.pgf90Args.size(); ++j) {
-    argv.push_back(driver.pgf90Args[j].data());
-  }
-  char dashC[3] = "-c", dashO[3] = "-o";
-  argv.push_back(dashC);
-  argv.push_back(dashO);
-  argv.push_back(relo);
-  argv.push_back(source);
-  Exec(argv, driver.verbose);
-}
+cl::opt<bool> EmitLLVM("emit-llvm", cl::desc("emit LLVM IR"), cl::init(false));
 
-std::string RelocatableName(const DriverOptions &driver, std::string path) {
-  if (driver.compileOnly && !driver.outputPath.empty()) {
-    return driver.outputPath;
-  }
-  std::string base{path};
-  auto slash{base.rfind("/")};
-  if (slash != std::string::npos) {
-    base = base.substr(slash + 1);
-  }
-  std::string relo{base};
-  auto dot{base.rfind(".")};
-  if (dot != std::string::npos) {
-    relo = base.substr(0, dot);
-  }
-  relo += ".o";
-  return relo;
-}
+// vestigal struct that should be deleted
+struct DriverOptions {
+  bool forcedForm{false};             // -Mfixed or -Mfree appeared
+  bool warnOnNonstandardUsage{false}; // -Mstandard
+  bool warningsAreErrors{false};      // -Werror
+  Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
+  std::string prefix;
+};
 
 int exitStatus{EXIT_SUCCESS};
 
-std::string CompileFortran(std::string path, Fortran::parser::Options options,
-    DriverOptions &driver,
+// Convert Fortran input to MLIR (target is FIR dialect)
+void convertFortranSourceToMLIR(
+    std::string path, Fortran::parser::Options options, DriverOptions &driver,
     Fortran::semantics::SemanticsContext &semanticsContext) {
   if (!driver.forcedForm) {
     auto dot{path.rfind(".")};
@@ -199,154 +93,91 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
       options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
     }
   }
-  options.searchDirectories = driver.searchDirectories;
+  options.searchDirectories = IncludeDirs;
   Fortran::parser::Parsing parsing{semanticsContext.allSources()};
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
-    std::cerr << driver.prefix << "could not scan " << path << '\n';
+    errs() << driver.prefix << "could not scan " << path << '\n';
     parsing.messages().Emit(std::cerr, parsing.cooked());
     exitStatus = EXIT_FAILURE;
-    return {};
-  }
-  if (driver.dumpProvenance) {
-    parsing.DumpProvenance(std::cout);
-    return {};
-  }
-  if (driver.dumpCookedChars) {
-    parsing.messages().Emit(std::cerr, parsing.cooked());
-    parsing.DumpCookedChars(std::cout);
-    return {};
+    return;
   }
   parsing.Parse(&std::cout);
-  if (options.instrumentedParse) {
-    parsing.DumpParsingLog(std::cout);
-    return {};
-  }
-  parsing.ClearLog();
   parsing.messages().Emit(std::cerr, parsing.cooked());
   if (!parsing.consumedWholeFile()) {
-    parsing.EmitMessage(
-        std::cerr, parsing.finalRestingPlace(), "parser FAIL (final position)");
+    parsing.EmitMessage(std::cerr, parsing.finalRestingPlace(),
+                        "parser FAIL (final position)");
     exitStatus = EXIT_FAILURE;
-    return {};
+    return;
   }
   if ((!parsing.messages().empty() &&
-          (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
+       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
       !parsing.parseTree().has_value()) {
-    std::cerr << driver.prefix << "could not parse " << path << '\n';
+    errs() << driver.prefix << "could not parse " << path << '\n';
     exitStatus = EXIT_FAILURE;
-    return {};
+    return;
   }
   auto &parseTree{*parsing.parseTree()};
-  if (driver.measureTree) {
-    MeasureParseTree(parseTree);
-  }
-  // TODO: Change this predicate to just "if (!driver.debugNoSemantics)"
-  if (driver.debugSemantics || driver.debugResolveNames || driver.dumpSymbols ||
-      driver.dumpUnparseWithSymbols || driver.runBackend) {
-    Fortran::semantics::Semantics semantics{
-        semanticsContext, parseTree, parsing.cooked()};
-    semantics.Perform();
-    semantics.EmitMessages(std::cerr);
-    if (driver.dumpSymbols) {
-      semantics.DumpSymbols(std::cout);
-    }
-    if (semantics.AnyFatalError()) {
-      std::cerr << driver.prefix << "semantic errors in " << path << '\n';
-      exitStatus = EXIT_FAILURE;
-      if (driver.dumpParseTree) {
-        Fortran::parser::DumpTree(std::cout, parseTree);
-      }
-      return {};
-    }
-    if (driver.dumpUnparseWithSymbols) {
-      Fortran::semantics::UnparseWithSymbols(
-          std::cout, parseTree, driver.encoding);
-      return {};
-    }
+  Fortran::semantics::Semantics semantics{semanticsContext, parseTree,
+                                          parsing.cooked()};
+  semantics.Perform();
+  semantics.EmitMessages(std::cerr);
+  if (semantics.AnyFatalError()) {
+    errs() << driver.prefix << "semantic errors in " << path << '\n';
+    exitStatus = EXIT_FAILURE;
+    return;
   }
 
   // MLIR+FIR
   fir::NameUniquer nameUniquer;
-  auto burnside = Br::BurnsideBridge::create(
-      semanticsContext.defaultKinds(), &parsing.cooked());
+  auto burnside = Br::BurnsideBridge::create(semanticsContext.defaultKinds(),
+                                             &parsing.cooked());
   fir::KindMapping kindMap{&burnside.getMLIRContext()};
   burnside.lower(parseTree, nameUniquer);
-  mlir::ModuleOp mlirModule{burnside.getModule()};
-  mlir::PassManager pm{mlirModule.getContext()};
-  if (driver.dumpHLFIR) {
-    llvm::errs() << ";== 1 ==\n";
-    mlirModule.dump();
-  }
-  // Run FIR mem2reg and CSE as a pair
+  mlir::ModuleOp mlirModule = burnside.getModule();
+  mlir::PassManager pm = mlirModule.getContext();
+
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
-  if (driver.lowerToLLVM) {
-    pm.addPass(fir::createLowerToLoopPass());
-    if (driver.lowerToStd) {
-      pm.addPass(fir::createFIRToStdPass(kindMap));
-    }
-    pm.addPass(mlir::createLowerToCFGPass());
+  pm.addPass(fir::createLowerToLoopPass());
+  pm.addPass(fir::createFIRToStdPass(kindMap));
+  pm.addPass(mlir::createLowerToCFGPass());
+
+  if (EmitLLVM) {
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
+    pm.addPass(fir::createLLVMDialectToLLVMPass(OutputFilename + ".ll"));
   }
-  if (driver.lowerToLLVMIR) {
-    pm.addPass(fir::createLLVMDialectToLLVMPass("a.ll"));
-  }
+
   if (mlir::succeeded(pm.run(mlirModule))) {
-    if (driver.dumpFIR) {
-      llvm::errs() << ";== 2 ==\n";
-      mlirModule.dump();
-    }
+    std::error_code ec;
+    raw_fd_ostream out(OutputFilename, ec);
+    if (!ec)
+      mlirModule.print(out);
   } else {
-    llvm::errs() << "oops, pass manager reported failure\n";
+    errs() << "oops, pass manager reported failure\n";
   }
-  return {};
 }
 
-std::string CompileOtherLanguage(std::string path, DriverOptions &driver) {
-  std::string relo{RelocatableName(driver, path)};
-  if (ParentProcess()) {
-    if (!driver.compileOnly && driver.outputPath.empty()) {
-      filesToDelete.push_back(relo);
-    }
-    return relo;
-  }
-  RunOtherCompiler(driver, path.data(), relo.data());
-  return {};
-}
+} // namespace
 
-void Link(std::vector<std::string> &relocatables, DriverOptions &driver) {
-  if (!ParentProcess()) {
-    std::vector<char *> argv;
-    for (size_t j{0}; j < driver.pgf90Args.size(); ++j) {
-      argv.push_back(driver.pgf90Args[j].data());
-    }
-    for (auto &relo : relocatables) {
-      argv.push_back(relo.data());
-    }
-    if (!driver.outputPath.empty()) {
-      char dashO[3] = "-o";
-      argv.push_back(dashO);
-      argv.push_back(driver.outputPath.data());
-    }
-    Exec(argv, driver.verbose);
-  }
-}
-
-int main(int argc, char *const argv[]) {
+int main(int argc, char **argv) {
+  InitLLVM y(argc, argv);
+  (void)y;
 
-  atexit(CleanUpAtExit);
+  mlir::registerPassManagerCLOptions();
+  mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
+  cl::ParseCommandLineOptions(argc, argv, "bbc\n");
 
   DriverOptions driver;
-  const char *pgf90{getenv("F18_FC")};
-  driver.pgf90Args.push_back(pgf90 ? pgf90 : "pgf90");
+  driver.prefix = argv[0] + ": "s;
 
-  std::list<std::string> args{argList(argc, argv)};
-  std::string prefix{args.front()};
-  args.pop_front();
-  prefix += ": ";
-  driver.prefix = prefix.data();
+  if (IncludeDirs.size() == 0) {
+    IncludeDirs.push_back(".");
+  }
+  if (ModuleDirs.size() == 0) {
+    ModuleDirs.push_back(".");
+  }
 
   Fortran::parser::Options options;
   options.predefinitions.emplace_back("__F18", "1");
@@ -358,224 +189,15 @@ int main(int argc, char *const argv[]) {
 #endif
 
   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
-
-  std::vector<std::string> fortranSources, otherSources, relocatables;
-  bool anyFiles{false};
-
-  while (!args.empty()) {
-    std::string arg{std::move(args.front())};
-    args.pop_front();
-    if (arg.empty()) {
-    } else if (arg.at(0) != '-') {
-      anyFiles = true;
-      auto dot{arg.rfind(".")};
-      if (dot == std::string::npos) {
-        driver.pgf90Args.push_back(arg);
-      } else {
-        std::string suffix{arg.substr(dot + 1)};
-        if (suffix == "f" || suffix == "F" || suffix == "ff" ||
-            suffix == "f90" || suffix == "F90" || suffix == "ff90" ||
-            suffix == "f95" || suffix == "F95" || suffix == "ff95" ||
-            suffix == "cuf" || suffix == "CUF" || suffix == "f18" ||
-            suffix == "F18" || suffix == "ff18") {
-          fortranSources.push_back(arg);
-        } else if (suffix == "o" || suffix == "a") {
-          relocatables.push_back(arg);
-        } else {
-          otherSources.push_back(arg);
-        }
-      }
-    } else if (arg == "-") {
-      fortranSources.push_back("-");
-    } else if (arg == "--") {
-      while (!args.empty()) {
-        fortranSources.emplace_back(std::move(args.front()));
-        args.pop_front();
-      }
-      break;
-    } else if (arg == "-Mfixed") {
-      driver.forcedForm = true;
-      options.isFixedForm = true;
-    } else if (arg == "-Mfree") {
-      driver.forcedForm = true;
-      options.isFixedForm = false;
-    } else if (arg == "-Mextend") {
-      options.fixedFormColumns = 132;
-    } else if (arg == "-Mbackslash") {
-      options.features.Enable(
-          Fortran::parser::LanguageFeature::BackslashEscapes, false);
-    } else if (arg == "-Mnobackslash") {
-      options.features.Enable(
-          Fortran::parser::LanguageFeature::BackslashEscapes);
-    } else if (arg == "-Mstandard") {
-      driver.warnOnNonstandardUsage = true;
-    } else if (arg == "-fopenmp") {
-      options.features.Enable(Fortran::parser::LanguageFeature::OpenMP);
-      options.predefinitions.emplace_back("_OPENMP", "201511");
-    } else if (arg == "-Werror") {
-      driver.warningsAreErrors = true;
-    } else if (arg == "-ed") {
-      options.features.Enable(Fortran::parser::LanguageFeature::OldDebugLines);
-    } else if (arg == "-E") {
-      driver.dumpCookedChars = true;
-    } else if (arg == "-fbackslash") {
-      options.features.Enable(
-          Fortran::parser::LanguageFeature::BackslashEscapes);
-    } else if (arg == "-fno-backslash") {
-      options.features.Enable(
-          Fortran::parser::LanguageFeature::BackslashEscapes, false);
-    } else if (arg == "-fdebug-dump-provenance") {
-      driver.dumpProvenance = true;
-    } else if (arg == "-fdebug-dump-parse-tree") {
-      driver.dumpParseTree = true;
-    } else if (arg == "-fdebug-dump-symbols") {
-      driver.dumpSymbols = true;
-    } else if (arg == "-fdebug-resolve-names") {
-      driver.debugResolveNames = true;
-    } else if (arg == "-fdebug-measure-parse-tree") {
-      driver.measureTree = true;
-    } else if (arg == "-fdebug-instrumented-parse") {
-      options.instrumentedParse = true;
-    } else if (arg == "-fdebug-semantics") {
-      // TODO: Enable by default once basic tests pass
-      driver.debugSemantics = true;
-    } else if (arg == "-funparse") {
-      driver.dumpUnparse = true;
-    } else if (arg == "-funparse-with-symbols") {
-      driver.dumpUnparseWithSymbols = true;
-    } else if (arg == "-fno-dump-hl-fir") {
-      driver.dumpHLFIR = false;
-    } else if (arg == "-fno-dump-fir") {
-      driver.dumpFIR = false;
-    } else if (arg == "-fno-lower-to-llvm") {
-      driver.lowerToLLVMIR = false;
-    } else if (arg == "-fno-lower-to-llvm-dialect") {
-      driver.lowerToLLVM = false;
-      driver.lowerToLLVMIR = false;
-    } else if (arg == "-fno-lower-to-std") {
-      driver.lowerToStd = false;
-      driver.lowerToLLVM = false;
-      driver.lowerToLLVMIR = false;
-    } else if (arg == "-fparse-only") {
-      driver.parseOnly = true;
-    } else if (arg == "-c") {
-      driver.compileOnly = true;
-    } else if (arg == "-o") {
-      driver.outputPath = args.front();
-      args.pop_front();
-    } else if (arg.substr(0, 2) == "-D") {
-      auto eq{arg.find('=')};
-      if (eq == std::string::npos) {
-        options.predefinitions.emplace_back(arg.substr(2), "1");
-      } else {
-        options.predefinitions.emplace_back(
-            arg.substr(2, eq - 2), arg.substr(eq + 1));
-      }
-    } else if (arg.substr(0, 2) == "-U") {
-      options.predefinitions.emplace_back(
-          arg.substr(2), std::optional<std::string>{});
-    } else if (arg == "-r8" || arg == "-fdefault-real-8") {
-      defaultKinds.set_defaultRealKind(8);
-    } else if (arg == "-i8" || arg == "-fdefault-integer-8") {
-      defaultKinds.set_defaultIntegerKind(8);
-    } else if (arg == "-module") {
-      driver.moduleDirectory = args.front();
-      args.pop_front();
-    } else if (arg == "-module-suffix") {
-      driver.moduleFileSuffix = args.front();
-      args.pop_front();
-    } else if (arg == "-help" || arg == "--help" || arg == "-?") {
-      std::cerr
-          << "f18 options:\n"
-          << "  -Mfixed | -Mfree     force the source form\n"
-          << "  -Mextend             132-column fixed form\n"
-          << "  -f[no-]backslash     enable[disable] \\escapes in literals\n"
-          << "  -M[no]backslash      disable[enable] \\escapes in literals\n"
-          << "  -Mstandard           enable conformance warnings\n"
-          << "  -r8 | -fdefault-real-8 | -i8 | -fdefault-integer-8  "
-             "change default kinds of intrinsic types\n"
-          << "  -Werror              treat warnings as errors\n"
-          << "  -ed                  enable fixed form D lines\n"
-          << "  -E                   prescan & preprocess only\n"
-          << "  -module dir          module output directory (default .)\n"
-          << "  -fparse-only         parse only, no output except messages\n"
-          << "  -funparse            parse & reformat only, no code "
-             "generation\n"
-          << "  -funparse-with-symbols  parse, resolve symbols, and unparse\n"
-          << "  -fdebug-measure-parse-tree\n"
-          << "  -fdebug-dump-provenance\n"
-          << "  -fdebug-dump-parse-tree\n"
-          << "  -fdebug-dump-symbols\n"
-          << "  -fdebug-resolve-names\n"
-          << "  -fdebug-instrumented-parse\n"
-          << "  -fdebug-semantics    perform semantic checks\n"
-          << "  -fdotty              print FIR as a dotty graph\n"
-          << "  -v -c -o -I -D -U    have their usual meanings\n"
-          << "  -help                print this again\n"
-          << "Other options are passed through to the compiler.\n";
-      return exitStatus;
-    } else if (arg == "-V") {
-      std::cerr << "\nf18 compiler (under development)\n";
-      return exitStatus;
-    } else {
-      driver.pgf90Args.push_back(arg);
-      if (arg == "-v") {
-        driver.verbose = true;
-      } else if (arg == "-I") {
-        driver.pgf90Args.push_back(args.front());
-        driver.searchDirectories.push_back(args.front());
-        args.pop_front();
-      } else if (arg.substr(0, 2) == "-I") {
-        driver.searchDirectories.push_back(arg.substr(2));
-      }
-    }
-  }
-
-  if (driver.warnOnNonstandardUsage) {
-    options.features.WarnOnAllNonstandard();
-  }
-
-  if (driver.pgf90Args.size() > 0) {
-    // marshal the arguments for cl parsing
-    int argc_cp = driver.pgf90Args.size();
-    const char **argv_cp = new const char *[argc_cp + 1];
-    for (int i = 0; i < argc_cp; ++i)
-      argv_cp[i] = driver.pgf90Args[i].c_str();
-    argv_cp[argc_cp] = nullptr;
-    llvm::cl::ParseCommandLineOptions(
-        argc_cp, argv_cp, "Fortran/FIR/MLIR compiler\n");
-    delete[] argv_cp;
-  }
-
   Fortran::parser::AllSources allSources;
   Fortran::semantics::SemanticsContext semanticsContext{
       defaultKinds, options.features, allSources};
-  semanticsContext.set_moduleDirectory(driver.moduleDirectory)
-      .set_moduleFileSuffix(driver.moduleFileSuffix)
-      .set_searchDirectories(driver.searchDirectories)
+  semanticsContext.set_moduleDirectory(ModuleDirs.front())
+      .set_moduleFileSuffix(ModuleSuffix)
+      .set_searchDirectories(IncludeDirs)
       .set_warnOnNonstandardUsage(driver.warnOnNonstandardUsage)
       .set_warningsAreErrors(driver.warningsAreErrors);
 
-  if (!anyFiles) {
-    driver.measureTree = true;
-    driver.dumpUnparse = true;
-    CompileFortran("-", options, driver, semanticsContext);
-    return exitStatus;
-  }
-  for (const auto &path : fortranSources) {
-    std::string relo{CompileFortran(path, options, driver, semanticsContext)};
-    if (!driver.compileOnly && !relo.empty()) {
-      relocatables.push_back(relo);
-    }
-  }
-  for (const auto &path : otherSources) {
-    std::string relo{CompileOtherLanguage(path, driver)};
-    if (!driver.compileOnly && !relo.empty()) {
-      relocatables.push_back(relo);
-    }
-  }
-  if (!relocatables.empty()) {
-    Link(relocatables, driver);
-  }
+  convertFortranSourceToMLIR(InputFilename, options, driver, semanticsContext);
   return exitStatus;
 }

From 8cfbf3072a9049230ad8a69a8a7ef6ffbf8d4065 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 9 Jan 2020 07:53:16 -0800
Subject: [PATCH 159/345] Update expression tests and introduce
 `fir::SequenceType::getUnknownExtent()`

---
 include/optimizer/FIRType.h                      |  1 +
 lib/lower/convert-type.cc                        |  6 +++---
 test/{burnside => lower}/expr-test-generator.cc  |  0
 .../test_expression_lowering.sh                  | 16 ++++++++++------
 4 files changed, 14 insertions(+), 9 deletions(-)
 rename test/{burnside => lower}/expr-test-generator.cc (100%)
 rename test/{burnside => lower}/test_expression_lowering.sh (84%)

diff --git a/include/optimizer/FIRType.h b/include/optimizer/FIRType.h
index 13d7c030187b..0dcb0c0f560b 100644
--- a/include/optimizer/FIRType.h
+++ b/include/optimizer/FIRType.h
@@ -260,6 +260,7 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
 
   static SequenceType get(const Shape &shape, mlir::Type elementType,
                           mlir::AffineMapAttr map = {});
+  constexpr static Extent getUnkownExtent() { return -1; }
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
   static mlir::LogicalResult
   verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
diff --git a/lib/lower/convert-type.cc b/lib/lower/convert-type.cc
index d2cf08af883f..467f6f7fcd43 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -288,10 +288,10 @@ class TypeBuilder {
           bounds.emplace_back(toConstant(ubv.value()) -
                               toConstant(lbv.value()) + 1);
         } else {
-          bounds.emplace_back(-1);
+          bounds.emplace_back(fir::SequenceType::getUnkownExtent());
         }
       } else {
-        bounds.emplace_back(-1);
+        bounds.emplace_back(fir::SequenceType::getUnkownExtent());
       }
     }
     return bounds;
@@ -493,6 +493,6 @@ M::Type Br::getSequenceRefType(M::Type refType) {
   auto type{refType.dyn_cast<fir::ReferenceType>()};
   assert(type && "expected a reference type");
   auto elementType{type.getEleTy()};
-  fir::SequenceType::Shape shape{-1};
+  fir::SequenceType::Shape shape{fir::SequenceType::getUnkownExtent()};
   return fir::ReferenceType::get(fir::SequenceType::get(shape, elementType));
 }
diff --git a/test/burnside/expr-test-generator.cc b/test/lower/expr-test-generator.cc
similarity index 100%
rename from test/burnside/expr-test-generator.cc
rename to test/lower/expr-test-generator.cc
diff --git a/test/burnside/test_expression_lowering.sh b/test/lower/test_expression_lowering.sh
similarity index 84%
rename from test/burnside/test_expression_lowering.sh
rename to test/lower/test_expression_lowering.sh
index f6389b6d3bde..4dd259887ad0 100755
--- a/test/burnside/test_expression_lowering.sh
+++ b/test/lower/test_expression_lowering.sh
@@ -15,11 +15,12 @@
 
 # Test Fortran expression lowering by driving compilations
 # and executions of programs generated by expr-test-generation.cc
-#   usage: cmd llvm_build_directory
+#
+# Usage: cmd bbc llc
+# To keep generated files, run `export KEEP=TRUE` before the test call.
 
-LLVM=$1
-BBC=$LLVM/bin/bbc
-LLC=$LLVM/bin/llc
+BBC=$1
+LLC=$2
 CPP=g++
 FCC=pgfortran # So far, only works with pgfortran because of pgmath linking.
 FCC_OPTIONS="-Kieee" # That is required because bit to bit compare so far.
@@ -42,14 +43,17 @@ assembly=a.s
 testObject=test.o
 testExec=./test_exec
 testLog=test.log
+llFile=a.mlir.ll
 
 $CPP $SRC -std=c++17 -o $testGen
 [[ $? -ne 0 ]] && die "test generator compilation failure"
 $testGen 1>$testFile 2>$driverFile
 [[ $? -ne 0 ]] && die "test generation failure"
-$BBC $testFile 2>$bbcLog
+$BBC -disable-fir2std -emit-llvm $testFile 2>$bbcLog
 [[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
-$LLC a.ll -o $assembly
+# FIR internal mangling -> pgfortran mangling (until done by FIR lowering)
+sed -i 's,_QP\([[:alnum:]_]*\),\1_,g' $llFile
+$LLC $llFile -o $assembly
 [[ $? -ne 0 ]] && die "llc failed compiling bbc output"
 as $assembly -o $testObject
 [[ $? -ne 0 ]] && die "as failed compiling llc output"

From b9c82e63985f84678330202adc50b41af1e16f01 Mon Sep 17 00:00:00 2001
From: Gary Klimowicz <gklimowicz@pobox.com>
Date: Thu, 9 Jan 2020 09:33:41 -0800
Subject: [PATCH 160/345] Flang relicensing changes for LLVM Apache 2.0 license

This changes the license information in many of the flang source files.
- NVIDIA Copyright lines have been removed.
- Initial lines for files follow the LLVM coding convention (file name on the first line; Emacs mode information on the first line).
- License references have been replaced with the abridged LLVM text.
- License information was removed from the test files.

We did not add brief file summaries to the initial line.

See http://llvm.org/docs/DeveloperPolicy.html#new-llvm-project-license-framework
for a description of the new license.

See http://llvm.org/docs/CodingStandards.html#file-headers
for a description of the new LLVM standard file header.

Conflicts:
	include/fir/FIROps.h
	include/optimizer/FIROps.td
	lib/burnside/builder.cc
	lib/burnside/complex-handler.h
	lib/burnside/convert-expr.h
	lib/burnside/mixin.h
	lib/lower/bridge.cc
	lib/lower/bridge.h
	lib/lower/builder.h
	lib/lower/convert-expr.cc
	lib/lower/intrinsics.cc
	lib/lower/intrinsics.h
	lib/lower/io.cc
	lib/lower/io.h
	lib/lower/runtime.h
	lib/optimizer/CodeGen.cpp
	lib/optimizer/FIRDialect.cpp
	lib/optimizer/FIROps.cpp
	lib/optimizer/StdConverter.cpp
	lib/optimizer/Transforms/CSE.cpp
	lib/optimizer/Transforms/RewriteLoop.cpp
	tools/bbc/bbc.cpp

Respond to review comments

Fix trailing comment lines (===---...---=== not just dashes).
Fix header in test file geenrator test/burnside/expr-test-generator.cc.
Leave existing headers in files taken from MLIR.

Conflicts:
	include/fir/FIROps.h
	include/optimizer/FIROps.td
	lib/burnside/complex-handler.h
	lib/burnside/convert-expr.h
	lib/burnside/convert-type.h
	lib/burnside/mixin.h
	lib/optimizer/CodeGen.cpp
	lib/optimizer/StdConverter.cpp
	lib/optimizer/Transforms/CSE.cpp
	tools/bbc/bbc.cpp
---
 include/optimizer/Attribute.h               | 16 +++++-----------
 include/optimizer/CodeGen/CodeGen.h         | 16 +++++-----------
 include/optimizer/FIRDialect.h              | 16 +++++-----------
 include/optimizer/FIROpsSupport.h           | 16 +++++-----------
 include/optimizer/FIRType.h                 | 16 +++++-----------
 include/optimizer/InternalNames.h           | 16 +++++-----------
 include/optimizer/KindMapping.h             | 16 +++++-----------
 include/optimizer/Transforms/Passes.h       | 16 +++++-----------
 include/optimizer/Transforms/StdConverter.h | 16 +++++-----------
 lib/lower/CMakeLists.txt                    | 16 +++++-----------
 lib/lower/ast-builder.cc                    | 16 +++++-----------
 lib/lower/ast-builder.h                     | 16 +++++-----------
 lib/lower/cfg-builder.h                     | 16 +++++-----------
 lib/lower/convert-type.cc                   | 16 +++++-----------
 lib/lower/convert-type.h                    | 16 +++++-----------
 lib/lower/mangler.cc                        | 16 +++++-----------
 lib/lower/mangler.h                         | 16 +++++-----------
 lib/lower/runtime.cc                        | 16 +++++-----------
 lib/lower/runtime.def                       | 16 +++++-----------
 lib/optimizer/Attribute.cpp                 | 16 +++++-----------
 lib/optimizer/CMakeLists.txt                | 16 +++++-----------
 lib/optimizer/FIRType.cpp                   | 16 +++++-----------
 lib/optimizer/InternalNames.cpp             | 16 +++++-----------
 lib/optimizer/KindMapping.cpp               | 16 +++++-----------
 lib/optimizer/Transforms/CMakeLists.txt     | 16 +++++-----------
 test/lower/expr-test-generator.cc           | 16 +++++-----------
 test/lower/test_expression_lowering.sh      | 14 --------------
 tools/bbc/CMakeLists.txt                    | 16 +++++-----------
 tools/bbc/bbc.cpp                           |  9 +++++----
 tools/tco/CMakeLists.txt                    | 16 +++++-----------
 30 files changed, 145 insertions(+), 326 deletions(-)

diff --git a/include/optimizer/Attribute.h b/include/optimizer/Attribute.h
index 217096c6a33a..7f437cc90f86 100644
--- a/include/optimizer/Attribute.h
+++ b/include/optimizer/Attribute.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/Attribute.h ---------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_FIRATTRIBUTE_H
 #define OPTIMIZER_FIRATTRIBUTE_H
diff --git a/include/optimizer/CodeGen/CodeGen.h b/include/optimizer/CodeGen/CodeGen.h
index 0b51eff16661..224d67f248b8 100644
--- a/include/optimizer/CodeGen/CodeGen.h
+++ b/include/optimizer/CodeGen/CodeGen.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/Tilikum/Tilikum.h ---------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_CODEGEN_CODEGEN_H
 #define OPTIMIZER_CODEGEN_CODEGEN_H
diff --git a/include/optimizer/FIRDialect.h b/include/optimizer/FIRDialect.h
index 1741ead46eaf..95e482673932 100644
--- a/include/optimizer/FIRDialect.h
+++ b/include/optimizer/FIRDialect.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/FIRDialect.h --------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_FIRDIALECT_H
 #define OPTIMIZER_FIRDIALECT_H
diff --git a/include/optimizer/FIROpsSupport.h b/include/optimizer/FIROpsSupport.h
index e7b391480059..63791e43bdfc 100644
--- a/include/optimizer/FIROpsSupport.h
+++ b/include/optimizer/FIROpsSupport.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/FIROpsSupport.h -----------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_FIROPS_SUPPORT_H
 #define OPTIMIZER_FIROPS_SUPPORT_H
diff --git a/include/optimizer/FIRType.h b/include/optimizer/FIRType.h
index 0dcb0c0f560b..6cb42cc0de03 100644
--- a/include/optimizer/FIRType.h
+++ b/include/optimizer/FIRType.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/FIRType.h -----------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_FIRTYPE_H
 #define OPTIMIZER_FIRTYPE_H
diff --git a/include/optimizer/InternalNames.h b/include/optimizer/InternalNames.h
index 29b8ed912a13..444e8c6b0430 100644
--- a/include/optimizer/InternalNames.h
+++ b/include/optimizer/InternalNames.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/InternalNames.h -----------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_INTERNAL_NAMES_H
 #define OPTIMIZER_INTERNAL_NAMES_H
diff --git a/include/optimizer/KindMapping.h b/include/optimizer/KindMapping.h
index cca81e64f1be..9f77209dc75c 100644
--- a/include/optimizer/KindMapping.h
+++ b/include/optimizer/KindMapping.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/KindMapping.h -------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_KINDMAPPING_H
 #define OPTIMIZER_KINDMAPPING_H
diff --git a/include/optimizer/Transforms/Passes.h b/include/optimizer/Transforms/Passes.h
index 3e09d8711ad9..a23cf5c0cf48 100644
--- a/include/optimizer/Transforms/Passes.h
+++ b/include/optimizer/Transforms/Passes.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/Transforms/Passes.h -------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_TRANSFORMS_PASSES_H
 #define OPTIMIZER_TRANSFORMS_PASSES_H
diff --git a/include/optimizer/Transforms/StdConverter.h b/include/optimizer/Transforms/StdConverter.h
index 2121a8c50640..dc49e6ed473b 100644
--- a/include/optimizer/Transforms/StdConverter.h
+++ b/include/optimizer/Transforms/StdConverter.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- include/fir/Transforms/StdConverter.h -------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_TRANSFORMS_STDCONVERTER_H
 #define OPTIMIZER_TRANSFORMS_STDCONVERTER_H
diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
index 914abd95d4ef..5e7bf77f4870 100644
--- a/lib/lower/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -1,16 +1,10 @@
-# Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+#===-- lib/burnside/CMakeLists.txt -----------------------------------------===#
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# 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
 #
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#===----------------------------------------------------------------------===--#
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 
diff --git a/lib/lower/ast-builder.cc b/lib/lower/ast-builder.cc
index 3b763d59db89..d8703016b6e2 100644
--- a/lib/lower/ast-builder.cc
+++ b/lib/lower/ast-builder.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/ast-builder.cc ---------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "ast-builder.h"
 #include "../parser/parse-tree-visitor.h"
diff --git a/lib/lower/ast-builder.h b/lib/lower/ast-builder.h
index 4e232e6257e4..8f2b332af5ea 100644
--- a/lib/lower/ast-builder.h
+++ b/lib/lower/ast-builder.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/ast-builder.h ------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_AST_BUILDER_H_
 #define FORTRAN_LOWER_AST_BUILDER_H_
diff --git a/lib/lower/cfg-builder.h b/lib/lower/cfg-builder.h
index 1ab88c15a109..b89be4d76aea 100644
--- a/lib/lower/cfg-builder.h
+++ b/lib/lower/cfg-builder.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/cfg-builder.h ------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
 #define FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
diff --git a/lib/lower/convert-type.cc b/lib/lower/convert-type.cc
index 467f6f7fcd43..6f00f642b46f 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/convert-type.cc --------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "convert-type.h"
 #include "../semantics/expression.h"
diff --git a/lib/lower/convert-type.h b/lib/lower/convert-type.h
index 71a51a140236..2626eed80e34 100644
--- a/lib/lower/convert-type.h
+++ b/lib/lower/convert-type.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/convert-type.h -----------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//----------------------------------------------------------------------------//
 
 #ifndef FORTRAN_LOWER_CONVERT_TYPE_H_
 #define FORTRAN_LOWER_CONVERT_TYPE_H_
diff --git a/lib/lower/mangler.cc b/lib/lower/mangler.cc
index 53fd14d3258b..bc6d2e106309 100644
--- a/lib/lower/mangler.cc
+++ b/lib/lower/mangler.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/mangler.cc -------------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "mangler.h"
 #include "../common/reference.h"
diff --git a/lib/lower/mangler.h b/lib/lower/mangler.h
index 9571fa9f9321..51377235e55f 100644
--- a/lib/lower/mangler.h
+++ b/lib/lower/mangler.h
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/mangler.h ----------------------------------*- C++ -*-===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_MANGLER_H_
 #define FORTRAN_LOWER_MANGLER_H_
diff --git a/lib/lower/runtime.cc b/lib/lower/runtime.cc
index 3dfaf3362413..6792e01dddac 100644
--- a/lib/lower/runtime.cc
+++ b/lib/lower/runtime.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/runtime.cc -------------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "runtime.h"
 #include "builder.h"
diff --git a/lib/lower/runtime.def b/lib/lower/runtime.def
index 9121321fc80a..b29ce728a742 100644
--- a/lib/lower/runtime.def
+++ b/lib/lower/runtime.def
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/burnside/runtime.def ------------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 // Define the various runtime entry points. At this point, these are entirely
 // bogons as we don't have a runtime library nor even a definition for one.
diff --git a/lib/optimizer/Attribute.cpp b/lib/optimizer/Attribute.cpp
index 1595f0161896..dc72fdbc3f3d 100644
--- a/lib/optimizer/Attribute.cpp
+++ b/lib/optimizer/Attribute.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/Attribute.cpp ---------------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "optimizer/Attribute.h"
 #include "mlir/IR/AttributeSupport.h"
diff --git a/lib/optimizer/CMakeLists.txt b/lib/optimizer/CMakeLists.txt
index 33885e026597..784e3cec9a62 100644
--- a/lib/optimizer/CMakeLists.txt
+++ b/lib/optimizer/CMakeLists.txt
@@ -1,16 +1,10 @@
-# Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+#===-- lib/fir/CMakeLists.txt ----------------------------------------------===#
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# 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
 #
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#===----------------------------------------------------------------------===--#
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 
diff --git a/lib/optimizer/FIRType.cpp b/lib/optimizer/FIRType.cpp
index a6fa1f4b8f55..1eac68ab6800 100644
--- a/lib/optimizer/FIRType.cpp
+++ b/lib/optimizer/FIRType.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/FIRType.cpp -----------------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "optimizer/FIRType.h"
 #include "mlir/IR/Builders.h"
diff --git a/lib/optimizer/InternalNames.cpp b/lib/optimizer/InternalNames.cpp
index 21996aeaa661..0e1d49ff1210 100644
--- a/lib/optimizer/InternalNames.cpp
+++ b/lib/optimizer/InternalNames.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/InternalNames.cpp -----------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "optimizer/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
diff --git a/lib/optimizer/KindMapping.cpp b/lib/optimizer/KindMapping.cpp
index 25041c0c3f57..f9c12aaf8065 100644
--- a/lib/optimizer/KindMapping.cpp
+++ b/lib/optimizer/KindMapping.cpp
@@ -1,16 +1,10 @@
-// Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- lib/fir/KindMapping.cpp -------------------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include "optimizer/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
diff --git a/lib/optimizer/Transforms/CMakeLists.txt b/lib/optimizer/Transforms/CMakeLists.txt
index 6c0ad1179d2e..5dfee56b6527 100644
--- a/lib/optimizer/Transforms/CMakeLists.txt
+++ b/lib/optimizer/Transforms/CMakeLists.txt
@@ -1,16 +1,10 @@
-# Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+#===-- lib/fir/Transforms/CMakeLists.txt -----------------------------------===#
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# 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
 #
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#===----------------------------------------------------------------------===--#
 
 add_llvm_library(FIRTransforms
   CSE.cpp
diff --git a/test/lower/expr-test-generator.cc b/test/lower/expr-test-generator.cc
index fa246d14efff..7acded6c273d 100644
--- a/test/lower/expr-test-generator.cc
+++ b/test/lower/expr-test-generator.cc
@@ -1,16 +1,10 @@
-// Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+//===-- test/burnside/expr-test-generator.cc ------------------------------===//
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
+// 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
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+//===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include <cstring>
diff --git a/test/lower/test_expression_lowering.sh b/test/lower/test_expression_lowering.sh
index 4dd259887ad0..d39e5faccf00 100755
--- a/test/lower/test_expression_lowering.sh
+++ b/test/lower/test_expression_lowering.sh
@@ -1,18 +1,4 @@
 #!/usr/bin/env bash
-# Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
 # Test Fortran expression lowering by driving compilations
 # and executions of programs generated by expr-test-generation.cc
 #
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index 579f6c6e98b9..f1d7a48d9b74 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -1,16 +1,10 @@
-# Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+#===-- tools/bbc/CMakeLists.txt --------------------------------------------===#
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# 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
 #
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#===----------------------------------------------------------------------===--#
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index b1b21a2f783f..e2beae108da3 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -4,10 +4,11 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-// =============================================================================
-//
-// This is a tool for translating Fortran sources to the FIR dialect of MLIR.
-//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This is a tool for translating Fortran sources to the FIR dialect of MLIR.
+///
 //===----------------------------------------------------------------------===//
 
 #include "../../lib/common/Fortran-features.h"
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 3332c025d303..e7b909052cd1 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -1,16 +1,10 @@
-# Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+#===-- tools/tco/CMakeLists.txt --------------------------------------------===#
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# 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
 #
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#===----------------------------------------------------------------------===--#
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS

From 5597d5d44fff38d3476399c042a79b10a21af53d Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 9 Jan 2020 12:59:50 -0800
Subject: [PATCH 161/345] document fix typo "Unkown" to "Unknown" rolled up
 changes from PR#920 add newlines to .clang-format remove old school (void)
 casts and replace with new school [[maybe_unused]] remove unneeded headers
 move toStringRef to a separate file mlir-tablegen now supports #ifndef remove
 some vestiges of the codename for the FIR bridge remove a newline remove a
 few lines make code more succinct remove the workaround code for building on
 macOS. no longer see link-time failures with the latest Xcode tools. don't
 dump output automatically PR#920 review comments [from Jean] review comments
 from Caroline

---
 include/flang/CMakeLists.txt                  |  4 +-
 include/flang/Version.h                       | 26 +++++-----
 .../Analysis/IteratedDominanceFrontier.h      |  3 --
 include/optimizer/FIROps.h                    |  2 -
 include/optimizer/FIROps.td                   | 15 +++---
 include/optimizer/FIRType.h                   | 43 +++++++++++-----
 lib/lower/CMakeLists.txt                      |  2 +-
 lib/lower/ast-builder.cc                      |  2 +-
 lib/lower/ast-builder.h                       |  2 +-
 lib/lower/bridge.cc                           | 20 ++------
 lib/lower/cfg-builder.h                       |  2 +-
 lib/lower/convert-expr.cc                     | 16 ------
 lib/lower/convert-type.cc                     | 17 +++----
 lib/lower/convert-type.h                      |  2 +-
 lib/lower/intrinsics.cc                       | 12 ++---
 lib/lower/intrinsics.h                        |  8 +--
 lib/lower/mangler.cc                          |  8 +--
 lib/lower/mangler.h                           |  2 +-
 lib/lower/runtime.cc                          |  2 +-
 lib/lower/runtime.def                         |  2 +-
 lib/lower/utils.h                             | 20 ++++++++
 lib/optimizer/FIROps.cpp                      |  4 +-
 lib/optimizer/FIRType.cpp                     | 11 +----
 lib/optimizer/InternalNames.cpp               |  5 +-
 lib/optimizer/StdConverter.cpp                | 10 ++--
 test/fir/aggregate.fir                        |  4 +-
 tools/bbc/CMakeLists.txt                      |  8 ---
 tools/bbc/bbc.cpp                             |  3 +-
 tools/tco/CMakeLists.txt                      |  8 ---
 tools/tco/tco.cpp                             | 49 +++++++++----------
 30 files changed, 133 insertions(+), 179 deletions(-)
 create mode 100644 lib/lower/utils.h

diff --git a/include/flang/CMakeLists.txt b/include/flang/CMakeLists.txt
index db5d26a83b56..8fa6447f19be 100644
--- a/include/flang/CMakeLists.txt
+++ b/include/flang/CMakeLists.txt
@@ -1,3 +1 @@
-if(LINK_WITH_FIR)
-  add_subdirectory(Optimizer)
-endif()
+add_subdirectory(Optimizer)
diff --git a/include/flang/Version.h b/include/flang/Version.h
index 79da179cfaac..e1d78eca58d0 100644
--- a/include/flang/Version.h
+++ b/include/flang/Version.h
@@ -8,7 +8,7 @@
 ///
 /// \file
 /// Defines version macros and version-related utility functions
-/// for Clang.
+/// for Flang.
 ///
 //===----------------------------------------------------------------------===//
 
@@ -20,40 +20,40 @@
 
 namespace flang {
   /// Retrieves the repository path (e.g., Subversion path) that
-  /// identifies the particular Clang branch, tag, or trunk from which this
-  /// Clang was built.
+  /// 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 clang.
+  /// This supports LLVM residing in a separate repository from flang.
   std::string getLLVMRepositoryPath();
 
   /// Retrieves the repository revision number (or identifier) from which
-  /// this Clang was built.
+  /// this Flang was built.
   std::string getFlangRevision();
 
   /// Retrieves the repository revision number (or identifier) from which
   /// LLVM was built.
   ///
-  /// If Clang and LLVM are in the same repository, this returns the same
-  /// string as getClangRevision.
+  /// 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 getClangRepositoryPath() and getClangRevision().
+  /// the information in getFlangRepositoryPath() and getFlangRevision().
   std::string getFlangFullRepositoryVersion();
 
-  /// Retrieves a string representing the complete clang version,
-  /// which includes the clang version number, the repository version,
+  /// 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 getClangFullVersion(), but with a custom tool name.
+  /// Like getFlangFullVersion(), but with a custom tool name.
   std::string getFlangToolFullVersion(llvm::StringRef ToolName);
 
-  /// Retrieves a string representing the complete clang version suitable
-  /// for use in the CPP __VERSION__ macro, which includes the clang version
+  /// Retrieves a string representing the complete flang version suitable
+  /// for use in the CPP __VERSION__ macro, which includes the flang version
   /// number, the repository version, and the vendor tag.
   std::string getFlangFullCPPVersion();
 }
diff --git a/include/optimizer/Analysis/IteratedDominanceFrontier.h b/include/optimizer/Analysis/IteratedDominanceFrontier.h
index 0ecdd2d29de2..5f686d594745 100644
--- a/include/optimizer/Analysis/IteratedDominanceFrontier.h
+++ b/include/optimizer/Analysis/IteratedDominanceFrontier.h
@@ -23,8 +23,6 @@
 #ifndef OPTIMIZER_ANALYSIS_IDF_H
 #define OPTIMIZER_ANALYSIS_IDF_H
 
-#include "mlir/Analysis/Dominance.h"
-#include "mlir/IR/Block.h"
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
@@ -63,7 +61,6 @@ class IDFCalculator {
   /// not include blocks where any phi insertion would be dead.
   ///
   /// Note: This set *must* live for the entire lifetime of the IDF calculator.
-
   void setLiveInBlocks(const llvm::SmallPtrSetImpl<NodeTy *> &Blocks) {
     LiveInBlocks = &Blocks;
     useLiveIn = true;
diff --git a/include/optimizer/FIROps.h b/include/optimizer/FIROps.h
index f720ca941a55..8b85b4bb2b7d 100644
--- a/include/optimizer/FIROps.h
+++ b/include/optimizer/FIROps.h
@@ -15,8 +15,6 @@
 #include "llvm/ADT/StringRef.h"
 
 using namespace mlir;
-using llvm::ArrayRef;
-using llvm::StringRef;
 
 namespace fir {
 
diff --git a/include/optimizer/FIROps.td b/include/optimizer/FIROps.td
index bf4926dc0f72..73074af16fbe 100644
--- a/include/optimizer/FIROps.td
+++ b/include/optimizer/FIROps.td
@@ -11,12 +11,10 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifdef FIR_DIALECT_FIR_OPS
-#else
+#ifndef FIR_DIALECT_FIR_OPS
 #define FIR_DIALECT_FIR_OPS
 
-#ifdef OP_BASE
-#else
+#ifndef OP_BASE
 include "mlir/IR/OpBase.td"
 #endif
 
@@ -689,6 +687,7 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
           getSelector()->getType().isa<fir::CharacterType>()))
       return emitOpError("must be an integer, character, or logical");
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+      // TODO: add checks!
     }
     return M::success();
   }];
@@ -770,11 +769,9 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.dyn_cast_or_null<fir::ExactTypeAttr>()) {
-        // ok
-      } else if (attr.dyn_cast_or_null<fir::SubclassAttr>()) {
-        // ok
-      } else if (attr.dyn_cast_or_null<M::UnitAttr>()) {
+      if (attr.dyn_cast_or_null<fir::ExactTypeAttr>() ||
+          attr.dyn_cast_or_null<fir::SubclassAttr>() ||
+          attr.dyn_cast_or_null<M::UnitAttr>()) {
         // ok
       } else {
         return emitOpError("invalid type-case alternative");
diff --git a/include/optimizer/FIRType.h b/include/optimizer/FIRType.h
index 6cb42cc0de03..9471e36ee9d9 100644
--- a/include/optimizer/FIRType.h
+++ b/include/optimizer/FIRType.h
@@ -55,22 +55,22 @@ struct TypeDescTypeStorage;
 enum TypeKind {
   // The enum starts at the range reserved for this dialect.
   FIR_TYPE = mlir::Type::FIRST_FIR_TYPE,
-  FIR_BOX,
-  FIR_BOXCHAR,
-  FIR_BOXPROC,
-  FIR_CHARACTER, // intrinsic
-  FIR_COMPLEX,   // intrinsic
+  FIR_BOX,       // (static) descriptor
+  FIR_BOXCHAR,   // CHARACTER pointer and length
+  FIR_BOXPROC,   // procedure with host association
+  FIR_CHARACTER, // intrinsic type
+  FIR_COMPLEX,   // intrinsic type
   FIR_DERIVED,   // derived
   FIR_DIMS,
   FIR_FIELD,
   FIR_HEAP,
-  FIR_INT, // intrinsic
+  FIR_INT, // intrinsic type
   FIR_LEN,
-  FIR_LOGICAL, // intrinsic
-  FIR_POINTER,
-  FIR_REAL, // intrinsic
+  FIR_LOGICAL, // intrinsic type
+  FIR_POINTER, // POINTER attr
+  FIR_REAL,    // intrinsic type
   FIR_REFERENCE,
-  FIR_SEQUENCE,
+  FIR_SEQUENCE, // DIMENSION attr
   FIR_TYPEDESC,
 };
 
@@ -240,6 +240,11 @@ class ReferenceType
                                mlir::MLIRContext *context, mlir::Type eleTy);
 };
 
+/// A sequence type is a multi-dimensional array of values. The sequence type
+/// may have an unknown number of dimensions or the extent of dimensions may be
+/// unknown. A sequence type models a Fortran array entity, giving it a type in
+/// FIR. A sequence type is assumed to be stored in a column-major order, which
+/// differs from LLVM IR and other dialects of MLIR.
 class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
                                                  detail::SequenceTypeStorage> {
 public:
@@ -247,15 +252,27 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
   using Extent = int64_t;
   using Shape = llvm::SmallVector<Extent, 8>;
 
+  /// Return a sequence type with the specified shape and element type
+  static SequenceType get(const Shape &shape, mlir::Type elementType,
+                          mlir::AffineMapAttr map = {});
+
+  /// The element type of this sequence
   mlir::Type getEleTy() const;
+
+  /// The shape of the sequence. If the sequence has an unknown shape, the shape
+  /// returned will be empty.
   Shape getShape() const;
+
   mlir::AffineMapAttr getLayoutMap() const;
+
+  /// The number of dimensions of the sequence
   unsigned getDimension() const { return getShape().size(); }
 
-  static SequenceType get(const Shape &shape, mlir::Type elementType,
-                          mlir::AffineMapAttr map = {});
-  constexpr static Extent getUnkownExtent() { return -1; }
+  /// The value `-1` represents an unknown extent for a dimension
+  constexpr static Extent getUnknownExtent() { return -1; }
+
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
+
   static mlir::LogicalResult
   verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
                                mlir::MLIRContext *context, const Shape &shape,
diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
index 5e7bf77f4870..164c51c90b43 100644
--- a/lib/lower/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -1,4 +1,4 @@
-#===-- lib/burnside/CMakeLists.txt -----------------------------------------===#
+#===-- lib/lower/CMakeLists.txt --------------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/lower/ast-builder.cc b/lib/lower/ast-builder.cc
index d8703016b6e2..1a28ebc7f9e1 100644
--- a/lib/lower/ast-builder.cc
+++ b/lib/lower/ast-builder.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/ast-builder.cc ---------------------------------------===//
+//===-- lib/lower/ast-builder.cc ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/lower/ast-builder.h b/lib/lower/ast-builder.h
index 8f2b332af5ea..6f8c74f47360 100644
--- a/lib/lower/ast-builder.h
+++ b/lib/lower/ast-builder.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/ast-builder.h ------------------------------*- C++ -*-===//
+//===-- lib/lower/ast-builder.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.
diff --git a/lib/lower/bridge.cc b/lib/lower/bridge.cc
index 3d593869dd23..360fe6f2aad6 100644
--- a/lib/lower/bridge.cc
+++ b/lib/lower/bridge.cc
@@ -560,21 +560,7 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::BlockConstruct &) { TODO(); }
   void genFIR(const Pa::ChangeTeamConstruct &) { TODO(); }
   void genFIR(const Pa::CriticalConstruct &) { TODO(); }
-  void genFIR(const Pa::DoConstruct &d) {
-#if 0
-    auto &stmt{std::get<Pa::Statement<Pa::NonLabelDoStmt>>(d.t)};
-    const Pa::NonLabelDoStmt &ss{stmt.statement};
-    auto &ctrl{std::get<std::optional<Pa::LoopControl>>(ss.t)};
-    if (ctrl.has_value()) {
-      // std::visit([&](const auto &x) { genLoopEnterFIR(x, &ss, stmt.source);
-      // }, ctrl->u);
-    } else {
-      // loop forever (See 11.1.7.4.1, para. 2)
-      // pushDoContext(&ss);
-    }
-#endif
-    TODO();
-  }
+  void genFIR(const Pa::DoConstruct &) { TODO(); }
   void genFIR(const Pa::IfConstruct &) { TODO(); }
 
   void genFIR(const SelectCaseConstruct &) { TODO(); }
@@ -1186,8 +1172,8 @@ class FirConverter : public AbstractConverter {
   explicit FirConverter(BurnsideBridge &bridge, fir::NameUniquer &uniquer)
       : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
         module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
-        intrinsics{IntrinsicLibrary::create(IntrinsicLibrary::Version::LLVM,
-                                            bridge.getMLIRContext())},
+        intrinsics{IntrinsicLibrary(IntrinsicLibrary::Version::LLVM,
+                                    bridge.getMLIRContext())},
         uniquer{uniquer} {}
 
   /// Convert the AST to FIR
diff --git a/lib/lower/cfg-builder.h b/lib/lower/cfg-builder.h
index b89be4d76aea..85e26b1e1759 100644
--- a/lib/lower/cfg-builder.h
+++ b/lib/lower/cfg-builder.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/cfg-builder.h ------------------------------*- C++ -*-===//
+//===-- lib/lower/cfg-builder.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.
diff --git a/lib/lower/convert-expr.cc b/lib/lower/convert-expr.cc
index 103879d54aee..dd0ffde5f69c 100644
--- a/lib/lower/convert-expr.cc
+++ b/lib/lower/convert-expr.cc
@@ -61,9 +61,6 @@ class ExprLowering {
   M::OpBuilder &builder;
   SomeExpr const &expr;
   SymMap &symMap;
-#if 0
-  SymMap loadedSymbols;
-#endif
   IntrinsicLibrary const &intrinsics;
   bool genLogicalAsI1{false};
 
@@ -254,24 +251,11 @@ class ExprLowering {
   M::Value gendef(Se::SymbolRef sym) { return gen(sym); }
 
   M::Value genval(Se::SymbolRef sym) {
-#if 0
-    // Do not load the same symbols several time in one expression.
-    // Fortran guarantees variable value must be the same wherever it
-    // appears in one expression.
-    if (mlir::Value loaded = loadedSymbols.lookupSymbol(sym)) 
-      return loaded;
-    mlir::Value load = builder.create<fir::LoadOp>(getLoc(), gen(sym));
-    loadedSymbols.addSymbol(sym, load);
-    return load;
-#else
-    // Multiple loads should be CSEd. If they aren't, it's a bug in CSE that
-    // should not use a workaround here.
     auto var = gen(sym);
     if (fir::isReferenceLike(var->getType())) {
       return builder.create<fir::LoadOp>(getLoc(), var);
     }
     return var;
-#endif
   }
 
   M::Value genval(Ev::BOZLiteralConstant const &) { TODO(); }
diff --git a/lib/lower/convert-type.cc b/lib/lower/convert-type.cc
index 6f00f642b46f..718fd6564528 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/convert-type.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/convert-type.cc --------------------------------------===//
+//===-- lib/lower/convert-type.cc -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -16,6 +16,7 @@
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 #include "optimizer/FIRType.h"
+#include "utils.h"
 
 namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
@@ -179,10 +180,6 @@ class TypeBuilder {
     return M::emitWarning(M::UnknownLoc::get(context), message);
   }
 
-  llvm::StringRef toStrRef(const Pa::CharBlock &cb) {
-    return {cb.begin(), cb.size()};
-  }
-
 public:
   explicit TypeBuilder(M::MLIRContext *context,
                        Co::IntrinsicTypeDefaultKinds const &defaults)
@@ -282,10 +279,10 @@ class TypeBuilder {
           bounds.emplace_back(toConstant(ubv.value()) -
                               toConstant(lbv.value()) + 1);
         } else {
-          bounds.emplace_back(fir::SequenceType::getUnkownExtent());
+          bounds.emplace_back(fir::SequenceType::getUnknownExtent());
         }
       } else {
-        bounds.emplace_back(fir::SequenceType::getUnkownExtent());
+        bounds.emplace_back(fir::SequenceType::getUnknownExtent());
       }
     }
     return bounds;
@@ -367,7 +364,7 @@ class TypeBuilder {
         auto &symbol = tySpec->typeSymbol();
         // FIXME: don't want to recurse forever here, but this won't happen
         // since we don't know the components at this time
-        auto rec = fir::RecordType::get(context, toStrRef(symbol.name()));
+        auto rec = fir::RecordType::get(context, toStringRef(symbol.name()));
         auto &details = symbol.get<Se::DerivedTypeDetails>();
         for (auto &param : details.paramDecls()) {
           auto &p{*param};
@@ -383,7 +380,7 @@ class TypeBuilder {
         emitWarning("the front-end returns symbols of derived type that have "
                     "components that are simple names and not symbols, so "
                     "cannot construct type " +
-                    toStrRef(symbol.name()));
+                    toStringRef(symbol.name()));
 #endif
         rec.finalize(ps, cs);
         returnTy = rec;
@@ -487,6 +484,6 @@ M::Type Br::getSequenceRefType(M::Type refType) {
   auto type{refType.dyn_cast<fir::ReferenceType>()};
   assert(type && "expected a reference type");
   auto elementType{type.getEleTy()};
-  fir::SequenceType::Shape shape{fir::SequenceType::getUnkownExtent()};
+  fir::SequenceType::Shape shape{fir::SequenceType::getUnknownExtent()};
   return fir::ReferenceType::get(fir::SequenceType::get(shape, elementType));
 }
diff --git a/lib/lower/convert-type.h b/lib/lower/convert-type.h
index 2626eed80e34..d8c65d1f7d40 100644
--- a/lib/lower/convert-type.h
+++ b/lib/lower/convert-type.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/convert-type.h -----------------------------*- C++ -*-===//
+//===-- lib/lower/convert-type.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.
diff --git a/lib/lower/intrinsics.cc b/lib/lower/intrinsics.cc
index 230ecd489ddc..166c2e23c89f 100644
--- a/lib/lower/intrinsics.cc
+++ b/lib/lower/intrinsics.cc
@@ -276,14 +276,10 @@ static constexpr MathsRuntimeStaticDescription pgmathPreciseRuntime[] = {
 
 // IntrinsicLibrary implementation
 
-IntrinsicLibrary IntrinsicLibrary::create(IntrinsicLibrary::Version v,
-                                          M::MLIRContext &context) {
-  IntrinsicLibrary lib{};
-  lib.impl = new Implementation(v, context);
-  return lib;
-}
-
-IntrinsicLibrary::~IntrinsicLibrary() { delete impl; }
+IntrinsicLibrary::IntrinsicLibrary(IntrinsicLibrary::Version v,
+                                   M::MLIRContext &context)
+    : impl{new Implementation(v, context)} {}
+IntrinsicLibrary::~IntrinsicLibrary() = default;
 
 M::Value IntrinsicLibrary::genval(M::Location loc, M::OpBuilder &builder,
                                   L::StringRef name, M::Type resultType,
diff --git a/lib/lower/intrinsics.h b/lib/lower/intrinsics.h
index 4b25b372af21..f12a6fe58c04 100644
--- a/lib/lower/intrinsics.h
+++ b/lib/lower/intrinsics.h
@@ -11,6 +11,7 @@
 
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "llvm/ADT/StringRef.h"
+#include <memory>
 #include <optional>
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
@@ -38,6 +39,8 @@ class IntrinsicLibrary {
   /// Available runtime library versions.
   enum class Version { PgmathFast, PgmathRelaxed, PgmathPrecise, LLVM };
 
+  /// Create an IntrinsicLibrary targeting the desired runtime library version.
+  IntrinsicLibrary(Version, mlir::MLIRContext &);
   ~IntrinsicLibrary();
   /// Generate the FIR+MLIR operations for the generic intrinsic "name".
   /// On failure, returns a nullptr, else the returned mlir::Value is
@@ -54,13 +57,10 @@ class IntrinsicLibrary {
   // TODO: Error handling interface ?
   // TODO: Implementation is incomplete. Many intrinsics to tbd.
 
-  /// Create an IntrinsicLibrary targeting the desired runtime library version.
-  static IntrinsicLibrary create(Version, mlir::MLIRContext &);
-
 private:
   /// Actual implementation is hidden.
   class Implementation;
-  Implementation *impl{nullptr}; // owning pointer
+  std::unique_ptr<Implementation> impl;
 };
 
 } // namespace Fortran::lower
diff --git a/lib/lower/mangler.cc b/lib/lower/mangler.cc
index bc6d2e106309..74380dbd8057 100644
--- a/lib/lower/mangler.cc
+++ b/lib/lower/mangler.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/mangler.cc -------------------------------------------===//
+//===-- lib/lower/mangler.cc ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -10,10 +10,10 @@
 #include "../common/reference.h"
 #include "../semantics/tools.h"
 #include "optimizer/InternalNames.h"
+#include "utils.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 
 namespace Br = Fortran::lower;
@@ -26,10 +26,6 @@ using namespace Fortran;
 
 namespace {
 
-L::StringRef toStringRef(const parser::CharBlock &cb) {
-  return L::StringRef{cb.begin(), cb.size()};
-}
-
 // recursively build the vector of module scopes
 void moduleNames(const Se::Scope *scope,
                  L::SmallVector<L::StringRef, 2> &result) {
diff --git a/lib/lower/mangler.h b/lib/lower/mangler.h
index 51377235e55f..ea933f30a05e 100644
--- a/lib/lower/mangler.h
+++ b/lib/lower/mangler.h
@@ -1,4 +1,4 @@
-//===-- lib/burnside/mangler.h ----------------------------------*- C++ -*-===//
+//===-- lib/lower/mangler.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.
diff --git a/lib/lower/runtime.cc b/lib/lower/runtime.cc
index 6792e01dddac..4d51b4733d55 100644
--- a/lib/lower/runtime.cc
+++ b/lib/lower/runtime.cc
@@ -1,4 +1,4 @@
-//===-- lib/burnside/runtime.cc -------------------------------------------===//
+//===-- lib/lower/runtime.cc ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/lower/runtime.def b/lib/lower/runtime.def
index b29ce728a742..94e5822dac04 100644
--- a/lib/lower/runtime.def
+++ b/lib/lower/runtime.def
@@ -1,4 +1,4 @@
-//===-- lib/burnside/runtime.def ------------------------------------------===//
+//===-- lib/lower/runtime.def ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/lower/utils.h b/lib/lower/utils.h
new file mode 100644
index 000000000000..0802d4f80c22
--- /dev/null
+++ b/lib/lower/utils.h
@@ -0,0 +1,20 @@
+//===-- lib/lower/utils.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_UTILS_H
+#define FORTRAN_LOWER_UTILS_H
+
+#include "../parser/char-block.h"
+#include "llvm/ADT/StringRef.h"
+
+/// Convert an F18 CharBlock to an LLVM StringRef
+inline llvm::StringRef toStringRef(const Fortran::parser::CharBlock &cb) {
+  return {cb.begin(), cb.size()};
+}
+
+#endif // FORTRAN_LOWER_UTILS_H
diff --git a/lib/optimizer/FIROps.cpp b/lib/optimizer/FIROps.cpp
index 817a95dc0208..81ce46bdd2c9 100644
--- a/lib/optimizer/FIROps.cpp
+++ b/lib/optimizer/FIROps.cpp
@@ -65,7 +65,7 @@ M::Type BoxDimsOp::getTupleType() {
   L::SmallVector<M::Type, 3> triple{getResult(0)->getType(),
                                     getResult(1)->getType(),
                                     getResult(2)->getType()};
-  return mlir::TupleType::get(triple, getContext());
+  return M::TupleType::get(triple, getContext());
 }
 
 // CallOp
@@ -435,7 +435,7 @@ M::ParseResult LoadOp::getElementOf(M::Type &ele, M::Type ref) {
 
 // LoopOp
 
-void LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
+void LoopOp::build(M::Builder *builder, M::OperationState &result,
                    int64_t lowerBound, int64_t upperBound, int64_t step) {
   assert(false && "not implemented");
 }
diff --git a/lib/optimizer/FIRType.cpp b/lib/optimizer/FIRType.cpp
index 1eac68ab6800..d73636e72d73 100644
--- a/lib/optimizer/FIRType.cpp
+++ b/lib/optimizer/FIRType.cpp
@@ -195,15 +195,8 @@ bool verifyRecordMemberType(M::Type ty) {
 
 bool verifySameLists(L::ArrayRef<RecordType::TypePair> a1,
                      L::ArrayRef<RecordType::TypePair> a2) {
-  if (a1.size() != a2.size())
-    return false;
-  auto iter = a1.begin();
-  for (auto lp : a2) {
-    if (!((iter->first == lp.first) && (iter->second == lp.second)))
-      return false;
-    ++iter;
-  }
-  return true;
+  // FIXME: do we need to allow for any variance here?
+  return a1 == a2;
 }
 
 RecordType verifyDerived(M::DialectAsmParser &parser, RecordType derivedTy,
diff --git a/lib/optimizer/InternalNames.cpp b/lib/optimizer/InternalNames.cpp
index 0e1d49ff1210..dbd43db4d03f 100644
--- a/lib/optimizer/InternalNames.cpp
+++ b/lib/optimizer/InternalNames.cpp
@@ -40,10 +40,7 @@ std::string doModulesHost(L::ArrayRef<L::StringRef> mods,
 
 inline L::SmallVector<L::StringRef, 2>
 convertToStringRef(L::ArrayRef<std::string> from) {
-  L::SmallVector<L::StringRef, 2> to;
-  for (auto &f : from)
-    to.push_back(f);
-  return to;
+  return {from.begin(), from.end()};
 }
 
 inline L::Optional<L::StringRef>
diff --git a/lib/optimizer/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
index 378d6058962d..43f3b184c488 100644
--- a/lib/optimizer/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -110,14 +110,14 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
                   L::ArrayRef<M::Block *> destinations,
                   L::ArrayRef<OperandTy> destOperands,
                   M::ConversionPatternRewriter &rewriter) const override {
-    auto selecttype = M::cast<SelectTypeOp>(op);
-    auto conds = selecttype.getNumConditions();
+    auto selectType = M::cast<SelectTypeOp>(op);
+    auto conds = selectType.getNumConditions();
     auto attrName = SelectTypeOp::AttrName;
-    auto caseAttr = selecttype.getAttrOfType<M::ArrayAttr>(attrName);
+    auto caseAttr = selectType.getAttrOfType<M::ArrayAttr>(attrName);
     auto cases = caseAttr.getValue();
     // Selector must be of type !fir.box<T>
     auto &selector = operands[0];
-    auto loc = selecttype.getLoc();
+    auto loc = selectType.getLoc();
     auto mod = op->getParentOfType<M::ModuleOp>();
     for (unsigned t = 0; t != conds; ++t) {
       auto &attr = cases[t];
@@ -133,7 +133,7 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
       }
       assert(attr.dyn_cast_or_null<M::UnitAttr>());
       assert((t + 1 == conds) && "unit must be last");
-      rewriter.replaceOpWithNewOp<M::BranchOp>(selecttype, destinations[t],
+      rewriter.replaceOpWithNewOp<M::BranchOp>(selectType, destinations[t],
                                                M::ValueRange{destOperands[t]});
     }
     return matchSuccess();
diff --git a/test/fir/aggregate.fir b/test/fir/aggregate.fir
index c306ec117230..c65e38deadd5 100644
--- a/test/fir/aggregate.fir
+++ b/test/fir/aggregate.fir
@@ -5,7 +5,7 @@ func @f_tuple(%a : tuple<i32, i64>) -> i64 {
 }
 
 func @f_record(%a : !fir.type<rec1{fa:i32, fb:i64}>) -> i64 {
-  %0 = fir.field_index("fb")
-  %1 = fir.extract_value %a, %0 : (!fir.type<rec1{fa:i32, fb:i64}>, !fir.field) -> i64
+  %0 = fir.field_index fb, !fir.type<rec1>
+  %1 = fir.extract_value %a, %0 : (!fir.type<rec1>, !fir.field) -> i64
   return %1 : i64
 }
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index f1d7a48d9b74..df69de6aa880 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -1,11 +1,3 @@
-#===-- tools/bbc/CMakeLists.txt --------------------------------------------===#
-#
-# 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
-#
-#===----------------------------------------------------------------------===--#
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIR
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index e2beae108da3..1ec88c1c713b 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -163,8 +163,7 @@ void convertFortranSourceToMLIR(
 } // namespace
 
 int main(int argc, char **argv) {
-  InitLLVM y(argc, argv);
-  (void)y;
+  [[maybe_unused]] InitLLVM y(argc, argv);
 
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index e7b909052cd1..ef60b9891d47 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -1,11 +1,3 @@
-#===-- tools/tco/CMakeLists.txt --------------------------------------------===#
-#
-# 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
-#
-#===----------------------------------------------------------------------===--#
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIR
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 5b473b863073..022fdfa6f8cb 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -31,48 +31,47 @@
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 
-using namespace llvm;
+namespace {
 
-static cl::opt<std::string> ClInput(cl::Positional, cl::Required,
-                                    cl::desc("<input file>"));
+namespace Cl = llvm::cl;
 
-static cl::opt<std::string> ClOutput("o", cl::desc("Specify output filename"),
-                                     cl::value_desc("filename"),
-                                     cl::init("a.ll"));
+Cl::opt<std::string> ClInput(Cl::Positional, Cl::Required,
+                             Cl::desc("<input file>"));
+
+Cl::opt<std::string> ClOutput("o", Cl::desc("Specify output filename"),
+                              Cl::value_desc("filename"), Cl::init("a.ll"));
 
 // compile a .fir file
 int compileFIR() {
   // check that there is a file to load
-  ErrorOr<std::unique_ptr<MemoryBuffer>> fileOrErr =
-      MemoryBuffer::getFileOrSTDIN(ClInput);
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
+      llvm::MemoryBuffer::getFileOrSTDIN(ClInput);
 
   if (std::error_code EC = fileOrErr.getError()) {
-    errs() << "Could not open file: " << EC.message() << '\n';
+    llvm::errs() << "Could not open file: " << EC.message() << '\n';
     return 1;
   }
 
   // load the file into a module
-  SourceMgr sourceMgr;
-  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), SMLoc());
+  llvm::SourceMgr sourceMgr;
+  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   auto context = std::make_unique<mlir::MLIRContext>();
   auto owningRef = mlir::parseSourceFile(sourceMgr, context.get());
 
   if (!owningRef) {
-    errs() << "Error can't load file " << ClInput << '\n';
+    llvm::errs() << "Error can't load file " << ClInput << '\n';
     return 2;
   }
   if (mlir::failed(owningRef->verify())) {
-    errs() << "Error verifying FIR module\n";
+    llvm::errs() << "Error verifying FIR module\n";
     return 4;
   }
 
-  errs() << ";== input ==\n";
-  owningRef->dump();
-
   // run passes
   fir::NameUniquer uniquer;
   fir::KindMapping kindMap{context.get()};
   mlir::PassManager pm{context.get()};
+  mlir::applyPassManagerCLOptions(pm);
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
   // convert fir dialect to affine
@@ -84,21 +83,17 @@ int compileFIR() {
   pm.addPass(mlir::createLowerToCFGPass());
   pm.addPass(fir::createFIRToLLVMPass(uniquer));
   pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput));
-  if (mlir::succeeded(pm.run(*owningRef))) {
-    errs() << ";== output ==\n";
-    owningRef->dump();
-  } else {
-    errs() << "FAILED: " << ClInput << '\n';
-    return 8;
-  }
-  return 0;
+  if (mlir::succeeded(pm.run(*owningRef)))
+    return 0;
+  llvm::errs() << "FAILED: " << ClInput << '\n';
+  return 8;
 }
+} // namespace
 
 int main(int argc, char **argv) {
-  llvm::InitLLVM y(argc, argv);
-  (void)y;
+  [[maybe_unused]] llvm::InitLLVM y(argc, argv);
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
-  cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Opt\n");
+  Cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Opt\n");
   return compileFIR();
 }

From 6318a9bdc18de8bdd6df9670cc9e83be22d4c8f9 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 14 Jan 2020 13:11:44 -0800
Subject: [PATCH 162/345] moving and renaming files to follow the LLVM
 conventions fix deps

---
 include/CMakeLists.txt                        |  2 +-
 include/{optimizer => fir}/.clang-format      |  0
 include/fir/CMakeLists.txt                    |  1 +
 .../{optimizer => fir/Dialect}/CMakeLists.txt |  4 ---
 .../Attribute.h => fir/Dialect/FIRAttr.h}     |  0
 .../{optimizer => fir/Dialect}/FIRDialect.h   |  0
 include/{optimizer => fir/Dialect}/FIROps.h   |  0
 include/{optimizer => fir/Dialect}/FIROps.td  |  0
 .../Dialect}/FIROpsSupport.h                  |  2 +-
 include/{optimizer => fir/Dialect}/FIRType.h  |  0
 .../flang/lower/ASTBuilder.h                  |  0
 .../bridge.h => include/flang/lower/Bridge.h  |  2 +-
 .../flang/lower/ComplexHandler.h              |  6 ++--
 .../flang/lower/ConvertExpr.h                 |  2 +-
 .../flang/lower/ConvertType.h                 |  0
 lib/lower/io.h => include/flang/lower/IO.h    |  0
 .../flang/lower/Intrinsics.h                  |  0
 .../flang/lower/Mangler.h                     |  0
 .../flang/lower/OpBuilder.h                   |  0
 .../flang/lower/Runtime.h                     |  0
 .../utils.h => include/flang/lower/Utils.h    |  0
 .../Analysis/IteratedDominanceFrontier.h      |  0
 .../{ => flang}/optimizer/CodeGen/CodeGen.h   |  0
 include/{ => flang}/optimizer/InternalNames.h |  0
 include/{ => flang}/optimizer/KindMapping.h   |  0
 .../{ => flang}/optimizer/Transforms/Passes.h |  0
 .../optimizer/Transforms/StdConverter.h       |  0
 lib/fir/.clang-format                         |  2 ++
 lib/fir/CMakeLists.txt                        |  1 +
 lib/fir/Dialect/CMakeLists.txt                | 29 +++++++++++++++++
 .../Attribute.cpp => fir/Dialect/FIRAttr.cpp} |  8 ++---
 lib/{optimizer => fir/Dialect}/FIRDialect.cpp | 10 +++---
 lib/{optimizer => fir/Dialect}/FIROps.cpp     | 10 +++---
 lib/{optimizer => fir/Dialect}/FIRType.cpp    |  6 ++--
 lib/lower/{ast-builder.cc => ASTBuilder.cpp}  |  2 +-
 lib/lower/{bridge.cc => Bridge.cpp}           | 28 ++++++++--------
 lib/lower/{cfg-builder.h => CFGBuilder.h}     |  0
 lib/lower/CMakeLists.txt                      | 28 ++++++----------
 .../{convert-expr.cc => ConvertExpr.cpp}      | 18 +++++------
 .../{convert-type.cc => ConvertType.cpp}      |  8 ++---
 lib/lower/{io.cc => IO.cpp}                   | 10 +++---
 lib/lower/{intrinsics.cc => Intrinsics.cpp}   | 14 ++++----
 lib/lower/{mangler.cc => Mangler.cpp}         |  8 ++---
 lib/lower/{builder.cc => OpBuilder.cpp}       |  8 ++---
 lib/lower/{runtime.cc => Runtime.cpp}         |  8 ++---
 lib/optimizer/CMakeLists.txt                  | 32 +++----------------
 lib/optimizer/CodeGen.cpp                     | 14 ++++----
 lib/optimizer/InternalNames.cpp               |  2 +-
 lib/optimizer/IteratedDominanceFrontier.cpp   |  2 +-
 lib/optimizer/KindMapping.cpp                 |  2 +-
 lib/optimizer/StdConverter.cpp                | 12 +++----
 lib/optimizer/Transforms/CMakeLists.txt       | 10 +-----
 lib/optimizer/Transforms/CSE.cpp              |  4 +--
 lib/optimizer/Transforms/MemToReg.cpp         |  8 ++---
 lib/optimizer/Transforms/RewriteLoop.cpp      |  6 ++--
 tools/bbc/CMakeLists.txt                      |  4 +--
 tools/bbc/bbc.cpp                             | 16 +++++-----
 tools/tco/CMakeLists.txt                      |  4 +--
 tools/tco/tco.cpp                             | 12 +++----
 59 files changed, 167 insertions(+), 178 deletions(-)
 rename include/{optimizer => fir}/.clang-format (100%)
 create mode 100644 include/fir/CMakeLists.txt
 rename include/{optimizer => fir/Dialect}/CMakeLists.txt (63%)
 rename include/{optimizer/Attribute.h => fir/Dialect/FIRAttr.h} (100%)
 rename include/{optimizer => fir/Dialect}/FIRDialect.h (100%)
 rename include/{optimizer => fir/Dialect}/FIROps.h (100%)
 rename include/{optimizer => fir/Dialect}/FIROps.td (100%)
 rename include/{optimizer => fir/Dialect}/FIROpsSupport.h (98%)
 rename include/{optimizer => fir/Dialect}/FIRType.h (100%)
 rename lib/lower/ast-builder.h => include/flang/lower/ASTBuilder.h (100%)
 rename lib/lower/bridge.h => include/flang/lower/Bridge.h (99%)
 rename lib/lower/complex-handler.h => include/flang/lower/ComplexHandler.h (97%)
 rename lib/lower/convert-expr.h => include/flang/lower/ConvertExpr.h (98%)
 rename lib/lower/convert-type.h => include/flang/lower/ConvertType.h (100%)
 rename lib/lower/io.h => include/flang/lower/IO.h (100%)
 rename lib/lower/intrinsics.h => include/flang/lower/Intrinsics.h (100%)
 rename lib/lower/mangler.h => include/flang/lower/Mangler.h (100%)
 rename lib/lower/builder.h => include/flang/lower/OpBuilder.h (100%)
 rename lib/lower/runtime.h => include/flang/lower/Runtime.h (100%)
 rename lib/lower/utils.h => include/flang/lower/Utils.h (100%)
 rename include/{ => flang}/optimizer/Analysis/IteratedDominanceFrontier.h (100%)
 rename include/{ => flang}/optimizer/CodeGen/CodeGen.h (100%)
 rename include/{ => flang}/optimizer/InternalNames.h (100%)
 rename include/{ => flang}/optimizer/KindMapping.h (100%)
 rename include/{ => flang}/optimizer/Transforms/Passes.h (100%)
 rename include/{ => flang}/optimizer/Transforms/StdConverter.h (100%)
 create mode 100644 lib/fir/.clang-format
 create mode 100644 lib/fir/CMakeLists.txt
 create mode 100644 lib/fir/Dialect/CMakeLists.txt
 rename lib/{optimizer/Attribute.cpp => fir/Dialect/FIRAttr.cpp} (96%)
 rename lib/{optimizer => fir/Dialect}/FIRDialect.cpp (92%)
 rename lib/{optimizer => fir/Dialect}/FIROps.cpp (99%)
 rename lib/{optimizer => fir/Dialect}/FIRType.cpp (99%)
 rename lib/lower/{ast-builder.cc => ASTBuilder.cpp} (99%)
 rename lib/lower/{bridge.cc => Bridge.cpp} (99%)
 rename lib/lower/{cfg-builder.h => CFGBuilder.h} (100%)
 rename lib/lower/{convert-expr.cc => ConvertExpr.cpp} (99%)
 rename lib/lower/{convert-type.cc => ConvertType.cpp} (99%)
 rename lib/lower/{io.cc => IO.cpp} (96%)
 rename lib/lower/{intrinsics.cc => Intrinsics.cpp} (99%)
 rename lib/lower/{mangler.cc => Mangler.cpp} (94%)
 rename lib/lower/{builder.cc => OpBuilder.cpp} (93%)
 rename lib/lower/{runtime.cc => Runtime.cpp} (96%)

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 53f754abd9a1..bd3543028a2c 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1,2 +1,2 @@
+add_subdirectory(fir)
 add_subdirectory(flang)
-add_subdirectory(optimizer)
diff --git a/include/optimizer/.clang-format b/include/fir/.clang-format
similarity index 100%
rename from include/optimizer/.clang-format
rename to include/fir/.clang-format
diff --git a/include/fir/CMakeLists.txt b/include/fir/CMakeLists.txt
new file mode 100644
index 000000000000..0ca0f41c5af4
--- /dev/null
+++ b/include/fir/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(Dialect)
diff --git a/include/optimizer/CMakeLists.txt b/include/fir/Dialect/CMakeLists.txt
similarity index 63%
rename from include/optimizer/CMakeLists.txt
rename to include/fir/Dialect/CMakeLists.txt
index 1e75d7e3efbc..9528b1abffb0 100644
--- a/include/optimizer/CMakeLists.txt
+++ b/include/fir/Dialect/CMakeLists.txt
@@ -1,7 +1,3 @@
-if (LLVM_DIR)
-  include(AddMLIR)
-endif()
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 set(LLVM_TARGET_DEFINITIONS FIROps.td)
 mlir_tablegen(FIROps.h.inc -gen-op-decls)
 mlir_tablegen(FIROps.cpp.inc -gen-op-defs)
diff --git a/include/optimizer/Attribute.h b/include/fir/Dialect/FIRAttr.h
similarity index 100%
rename from include/optimizer/Attribute.h
rename to include/fir/Dialect/FIRAttr.h
diff --git a/include/optimizer/FIRDialect.h b/include/fir/Dialect/FIRDialect.h
similarity index 100%
rename from include/optimizer/FIRDialect.h
rename to include/fir/Dialect/FIRDialect.h
diff --git a/include/optimizer/FIROps.h b/include/fir/Dialect/FIROps.h
similarity index 100%
rename from include/optimizer/FIROps.h
rename to include/fir/Dialect/FIROps.h
diff --git a/include/optimizer/FIROps.td b/include/fir/Dialect/FIROps.td
similarity index 100%
rename from include/optimizer/FIROps.td
rename to include/fir/Dialect/FIROps.td
diff --git a/include/optimizer/FIROpsSupport.h b/include/fir/Dialect/FIROpsSupport.h
similarity index 98%
rename from include/optimizer/FIROpsSupport.h
rename to include/fir/Dialect/FIROpsSupport.h
index 63791e43bdfc..4126a619ab03 100644
--- a/include/optimizer/FIROpsSupport.h
+++ b/include/fir/Dialect/FIROpsSupport.h
@@ -9,8 +9,8 @@
 #ifndef OPTIMIZER_FIROPS_SUPPORT_H
 #define OPTIMIZER_FIROPS_SUPPORT_H
 
+#include "fir/Dialect/FIROps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
-#include "optimizer/FIROps.h"
 
 namespace fir {
 
diff --git a/include/optimizer/FIRType.h b/include/fir/Dialect/FIRType.h
similarity index 100%
rename from include/optimizer/FIRType.h
rename to include/fir/Dialect/FIRType.h
diff --git a/lib/lower/ast-builder.h b/include/flang/lower/ASTBuilder.h
similarity index 100%
rename from lib/lower/ast-builder.h
rename to include/flang/lower/ASTBuilder.h
diff --git a/lib/lower/bridge.h b/include/flang/lower/Bridge.h
similarity index 99%
rename from lib/lower/bridge.h
rename to include/flang/lower/Bridge.h
index 3272d5319aaf..c37c18aa90e6 100644
--- a/lib/lower/bridge.h
+++ b/include/flang/lower/Bridge.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_BRIDGE_H_
 #define FORTRAN_LOWER_BRIDGE_H_
 
-#include "../common/Fortran.h"
+#include "../../../lib/common/Fortran.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include <memory>
diff --git a/lib/lower/complex-handler.h b/include/flang/lower/ComplexHandler.h
similarity index 97%
rename from lib/lower/complex-handler.h
rename to include/flang/lower/ComplexHandler.h
index 2b310eb9f5d1..172c1d77a2fd 100644
--- a/lib/lower/complex-handler.h
+++ b/include/flang/lower/ComplexHandler.h
@@ -11,9 +11,9 @@
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-#include "convert-type.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/FIRType.h"
+#include "ConvertType.h"
+#include "fir/Dialect/FIROps.h"
+#include "fir/Dialect/FIRType.h"
 
 namespace Fortran::lower {
 /// Provide helpers to generate Complex manipulations in FIR.
diff --git a/lib/lower/convert-expr.h b/include/flang/lower/ConvertExpr.h
similarity index 98%
rename from lib/lower/convert-expr.h
rename to include/flang/lower/ConvertExpr.h
index 8ca0a7c77b00..c648a891a319 100644
--- a/lib/lower/convert-expr.h
+++ b/include/flang/lower/ConvertExpr.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_CONVERT_EXPR_H_
 #define FORTRAN_LOWER_CONVERT_EXPR_H_
 
-#include "intrinsics.h"
+#include "Intrinsics.h"
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
diff --git a/lib/lower/convert-type.h b/include/flang/lower/ConvertType.h
similarity index 100%
rename from lib/lower/convert-type.h
rename to include/flang/lower/ConvertType.h
diff --git a/lib/lower/io.h b/include/flang/lower/IO.h
similarity index 100%
rename from lib/lower/io.h
rename to include/flang/lower/IO.h
diff --git a/lib/lower/intrinsics.h b/include/flang/lower/Intrinsics.h
similarity index 100%
rename from lib/lower/intrinsics.h
rename to include/flang/lower/Intrinsics.h
diff --git a/lib/lower/mangler.h b/include/flang/lower/Mangler.h
similarity index 100%
rename from lib/lower/mangler.h
rename to include/flang/lower/Mangler.h
diff --git a/lib/lower/builder.h b/include/flang/lower/OpBuilder.h
similarity index 100%
rename from lib/lower/builder.h
rename to include/flang/lower/OpBuilder.h
diff --git a/lib/lower/runtime.h b/include/flang/lower/Runtime.h
similarity index 100%
rename from lib/lower/runtime.h
rename to include/flang/lower/Runtime.h
diff --git a/lib/lower/utils.h b/include/flang/lower/Utils.h
similarity index 100%
rename from lib/lower/utils.h
rename to include/flang/lower/Utils.h
diff --git a/include/optimizer/Analysis/IteratedDominanceFrontier.h b/include/flang/optimizer/Analysis/IteratedDominanceFrontier.h
similarity index 100%
rename from include/optimizer/Analysis/IteratedDominanceFrontier.h
rename to include/flang/optimizer/Analysis/IteratedDominanceFrontier.h
diff --git a/include/optimizer/CodeGen/CodeGen.h b/include/flang/optimizer/CodeGen/CodeGen.h
similarity index 100%
rename from include/optimizer/CodeGen/CodeGen.h
rename to include/flang/optimizer/CodeGen/CodeGen.h
diff --git a/include/optimizer/InternalNames.h b/include/flang/optimizer/InternalNames.h
similarity index 100%
rename from include/optimizer/InternalNames.h
rename to include/flang/optimizer/InternalNames.h
diff --git a/include/optimizer/KindMapping.h b/include/flang/optimizer/KindMapping.h
similarity index 100%
rename from include/optimizer/KindMapping.h
rename to include/flang/optimizer/KindMapping.h
diff --git a/include/optimizer/Transforms/Passes.h b/include/flang/optimizer/Transforms/Passes.h
similarity index 100%
rename from include/optimizer/Transforms/Passes.h
rename to include/flang/optimizer/Transforms/Passes.h
diff --git a/include/optimizer/Transforms/StdConverter.h b/include/flang/optimizer/Transforms/StdConverter.h
similarity index 100%
rename from include/optimizer/Transforms/StdConverter.h
rename to include/flang/optimizer/Transforms/StdConverter.h
diff --git a/lib/fir/.clang-format b/lib/fir/.clang-format
new file mode 100644
index 000000000000..a74fda4b6734
--- /dev/null
+++ b/lib/fir/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+AlwaysBreakTemplateDeclarations: Yes
diff --git a/lib/fir/CMakeLists.txt b/lib/fir/CMakeLists.txt
new file mode 100644
index 000000000000..0ca0f41c5af4
--- /dev/null
+++ b/lib/fir/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(Dialect)
diff --git a/lib/fir/Dialect/CMakeLists.txt b/lib/fir/Dialect/CMakeLists.txt
new file mode 100644
index 000000000000..2022e104bffb
--- /dev/null
+++ b/lib/fir/Dialect/CMakeLists.txt
@@ -0,0 +1,29 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
+
+add_llvm_library(FIRDialect
+  FIRAttr.cpp
+  FIRDialect.cpp
+  FIROps.cpp
+  FIRType.cpp
+)
+
+add_dependencies(FIRDialect FIROpsIncGen)
+
+target_link_libraries(FIRDialect
+  MLIRTargetLLVMIR
+  MLIRTargetLLVMIRModuleTranslation
+  MLIREDSC
+  MLIRExecutionEngine
+  MLIRParser
+  MLIRSupport
+  MLIRStandardToLLVM
+  MLIRTransforms
+  LLVMAsmParser
+  LLVMAsmPrinter
+  LLVMRemarks
+)
+
+install (TARGETS FIRDialect
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+)
diff --git a/lib/optimizer/Attribute.cpp b/lib/fir/Dialect/FIRAttr.cpp
similarity index 96%
rename from lib/optimizer/Attribute.cpp
rename to lib/fir/Dialect/FIRAttr.cpp
index dc72fdbc3f3d..fb20b28f4092 100644
--- a/lib/optimizer/Attribute.cpp
+++ b/lib/fir/Dialect/FIRAttr.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/Attribute.cpp ---------------------------------------------===//
+//===-- fir/FIRAttr.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/Attribute.h"
+#include "fir/Dialect/FIRAttr.h"
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIRType.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/FIRType.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 
diff --git a/lib/optimizer/FIRDialect.cpp b/lib/fir/Dialect/FIRDialect.cpp
similarity index 92%
rename from lib/optimizer/FIRDialect.cpp
rename to lib/fir/Dialect/FIRDialect.cpp
index 56c2bd4d5269..2b01a6d67d97 100644
--- a/lib/optimizer/FIRDialect.cpp
+++ b/lib/fir/Dialect/FIRDialect.cpp
@@ -1,4 +1,4 @@
-//===-- lib/optimizer/FIRDialect.cpp ----------------------------*- C++ -*-===//
+//===-- fir/FIRDialect.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/FIRDialect.h"
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIRAttr.h"
+#include "fir/Dialect/FIROps.h"
+#include "fir/Dialect/FIRType.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Transforms/SideEffectsInterface.h"
-#include "optimizer/Attribute.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/FIRType.h"
 
 namespace M = mlir;
 
diff --git a/lib/optimizer/FIROps.cpp b/lib/fir/Dialect/FIROps.cpp
similarity index 99%
rename from lib/optimizer/FIROps.cpp
rename to lib/fir/Dialect/FIROps.cpp
index 81ce46bdd2c9..f82b3cf780b8 100644
--- a/lib/optimizer/FIROps.cpp
+++ b/lib/fir/Dialect/FIROps.cpp
@@ -1,4 +1,4 @@
-//===-- lib/optimizer/FIROps.cpp --------------------------------*- C++ -*-===//
+//===-- fir/FIROps.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,16 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/FIROps.h"
+#include "fir/Dialect/FIROps.h"
+#include "fir/Dialect/FIRAttr.h"
+#include "fir/Dialect/FIROpsSupport.h"
+#include "fir/Dialect/FIRType.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
-#include "optimizer/Attribute.h"
-#include "optimizer/FIROpsSupport.h"
-#include "optimizer/FIRType.h"
 #include "llvm/ADT/StringSwitch.h"
 
 namespace L = llvm;
diff --git a/lib/optimizer/FIRType.cpp b/lib/fir/Dialect/FIRType.cpp
similarity index 99%
rename from lib/optimizer/FIRType.cpp
rename to lib/fir/Dialect/FIRType.cpp
index d73636e72d73..7217f9820b20 100644
--- a/lib/optimizer/FIRType.cpp
+++ b/lib/fir/Dialect/FIRType.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/FIRType.cpp -----------------------------------------------===//
+//===-- fir/Dialect/FIRType.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/FIRType.h"
+#include "fir/Dialect/FIRType.h"
+#include "fir/Dialect/FIRDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Parser.h"
-#include "optimizer/FIRDialect.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
 
diff --git a/lib/lower/ast-builder.cc b/lib/lower/ASTBuilder.cpp
similarity index 99%
rename from lib/lower/ast-builder.cc
rename to lib/lower/ASTBuilder.cpp
index 1a28ebc7f9e1..7adab9d05d3f 100644
--- a/lib/lower/ast-builder.cc
+++ b/lib/lower/ASTBuilder.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "ast-builder.h"
+#include "flang/lower/ASTBuilder.h"
 #include "../parser/parse-tree-visitor.h"
 #include <cassert>
 #include <utility>
diff --git a/lib/lower/bridge.cc b/lib/lower/Bridge.cpp
similarity index 99%
rename from lib/lower/bridge.cc
rename to lib/lower/Bridge.cpp
index 360fe6f2aad6..9f2b8cb707dc 100644
--- a/lib/lower/bridge.cc
+++ b/lib/lower/Bridge.cpp
@@ -6,26 +6,26 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "bridge.h"
+#include "flang/lower/Bridge.h"
 #include "../parser/parse-tree.h"
 #include "../semantics/tools.h"
-#include "ast-builder.h"
-#include "builder.h"
-#include "convert-expr.h"
-#include "convert-type.h"
-#include "intrinsics.h"
-#include "io.h"
-#include "mangler.h"
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIROps.h"
+#include "fir/Dialect/FIRType.h"
+#include "flang/lower/ASTBuilder.h"
+#include "flang/lower/ConvertExpr.h"
+#include "flang/lower/ConvertType.h"
+#include "flang/lower/IO.h"
+#include "flang/lower/Intrinsics.h"
+#include "flang/lower/Mangler.h"
+#include "flang/lower/OpBuilder.h"
+#include "flang/lower/Runtime.h"
+#include "flang/optimizer/InternalNames.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Parser.h"
 #include "mlir/Target/LLVMIR.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/FIRType.h"
-#include "optimizer/InternalNames.h"
-#include "runtime.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace Br = Fortran::lower;
@@ -64,7 +64,7 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 }
 
 // CfgBuilder implementation
-#include "cfg-builder.h"
+#include "CFGBuilder.h"
 
 #undef TODO
 #define TODO()                                                                 \
diff --git a/lib/lower/cfg-builder.h b/lib/lower/CFGBuilder.h
similarity index 100%
rename from lib/lower/cfg-builder.h
rename to lib/lower/CFGBuilder.h
diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
index 164c51c90b43..2a8afaa0eb4e 100644
--- a/lib/lower/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -1,27 +1,19 @@
-#===-- lib/lower/CMakeLists.txt --------------------------------------------===#
-#
-# 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
-#
-#===----------------------------------------------------------------------===--#
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 
 add_library(FortranLower
-  ast-builder.cc
-  bridge.cc
-  builder.cc
-  convert-expr.cc
-  convert-type.cc
-  intrinsics.cc
-  mangler.cc
-  runtime.cc
-  io.cc
+  ASTBuilder.cpp
+  Bridge.cpp
+  OpBuilder.cpp
+  ConvertExpr.cpp
+  ConvertType.cpp
+  Intrinsics.cpp
+  Mangler.cpp
+  Runtime.cpp
+  IO.cpp
 )
 
 target_link_libraries(FortranLower
-  FIR
+  FIRDialect
   MLIRAffineOps
   MLIRLLVMIR
   MLIRStandardOps
diff --git a/lib/lower/convert-expr.cc b/lib/lower/ConvertExpr.cpp
similarity index 99%
rename from lib/lower/convert-expr.cc
rename to lib/lower/ConvertExpr.cpp
index dd0ffde5f69c..0d35eba8b0a5 100644
--- a/lib/lower/convert-expr.cc
+++ b/lib/lower/ConvertExpr.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "convert-expr.h"
+#include "flang/lower/ConvertExpr.h"
 #include "../common/default-kinds.h"
 #include "../common/unwrap.h"
 #include "../evaluate/fold.h"
@@ -14,10 +14,14 @@
 #include "../semantics/expression.h"
 #include "../semantics/symbol.h"
 #include "../semantics/type.h"
-#include "bridge.h"
-#include "builder.h"
-#include "complex-handler.h"
-#include "convert-type.h"
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIROps.h"
+#include "fir/Dialect/FIRType.h"
+#include "flang/lower/Bridge.h"
+#include "flang/lower/ComplexHandler.h"
+#include "flang/lower/ConvertType.h"
+#include "flang/lower/OpBuilder.h"
+#include "flang/lower/Runtime.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
@@ -28,10 +32,6 @@
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/FIRType.h"
-#include "runtime.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/Type.h"
diff --git a/lib/lower/convert-type.cc b/lib/lower/ConvertType.cpp
similarity index 99%
rename from lib/lower/convert-type.cc
rename to lib/lower/ConvertType.cpp
index 718fd6564528..92a5f343e53b 100644
--- a/lib/lower/convert-type.cc
+++ b/lib/lower/ConvertType.cpp
@@ -6,17 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "convert-type.h"
+#include "flang/lower/ConvertType.h"
 #include "../semantics/expression.h"
 #include "../semantics/tools.h"
 #include "../semantics/type.h"
-#include "bridge.h"
+#include "fir/Dialect/FIRType.h"
+#include "flang/lower/Bridge.h"
+#include "flang/lower/Utils.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
-#include "optimizer/FIRType.h"
-#include "utils.h"
 
 namespace Br = Fortran::lower;
 namespace Co = Fortran::common;
diff --git a/lib/lower/io.cc b/lib/lower/IO.cpp
similarity index 96%
rename from lib/lower/io.cc
rename to lib/lower/IO.cpp
index 98087e3dd83d..6c654fccb129 100644
--- a/lib/lower/io.cc
+++ b/lib/lower/IO.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/io.cc -----------------------------------------*- C++ -*-===//
+//===-- lower/IO.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "io.h"
+#include "flang/lower/IO.h"
 #include "../parser/parse-tree.h"
 #include "../semantics/tools.h"
-#include "bridge.h"
-#include "builder.h"
+#include "flang/lower/Bridge.h"
+#include "flang/lower/OpBuilder.h"
+#include "flang/lower/Runtime.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
-#include "runtime.h"
 #include <cassert>
 
 namespace Br = Fortran::lower;
diff --git a/lib/lower/intrinsics.cc b/lib/lower/Intrinsics.cpp
similarity index 99%
rename from lib/lower/intrinsics.cc
rename to lib/lower/Intrinsics.cpp
index 166c2e23c89f..93587d2a5e00 100644
--- a/lib/lower/intrinsics.cc
+++ b/lib/lower/Intrinsics.cpp
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "intrinsics.h"
-#include "builder.h"
-#include "complex-handler.h"
-#include "convert-type.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/FIRType.h"
-#include "runtime.h"
+#include "flang/lower/Intrinsics.h"
+#include "fir/Dialect/FIROps.h"
+#include "fir/Dialect/FIRType.h"
+#include "flang/lower/ComplexHandler.h"
+#include "flang/lower/ConvertType.h"
+#include "flang/lower/OpBuilder.h"
+#include "flang/lower/Runtime.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include <algorithm>
diff --git a/lib/lower/mangler.cc b/lib/lower/Mangler.cpp
similarity index 94%
rename from lib/lower/mangler.cc
rename to lib/lower/Mangler.cpp
index 74380dbd8057..79258e2076d0 100644
--- a/lib/lower/mangler.cc
+++ b/lib/lower/Mangler.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/mangler.cc ----------------------------------------------===//
+//===-- lower/Mangler.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mangler.h"
+#include "flang/lower/Mangler.h"
 #include "../common/reference.h"
 #include "../semantics/tools.h"
-#include "optimizer/InternalNames.h"
-#include "utils.h"
+#include "flang/lower/Utils.h"
+#include "flang/optimizer/InternalNames.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/lower/builder.cc b/lib/lower/OpBuilder.cpp
similarity index 93%
rename from lib/lower/builder.cc
rename to lib/lower/OpBuilder.cpp
index e73168d1ae72..d6ad7efe7bc4 100644
--- a/lib/lower/builder.cc
+++ b/lib/lower/OpBuilder.cpp
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "builder.h"
-#include "bridge.h"
-#include "convert-type.h"
+#include "flang/lower/OpBuilder.h"
+#include "fir/Dialect/FIROpsSupport.h"
+#include "flang/lower/Bridge.h"
+#include "flang/lower/ConvertType.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Value.h"
-#include "optimizer/FIROpsSupport.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace B = Fortran::lower;
diff --git a/lib/lower/runtime.cc b/lib/lower/Runtime.cpp
similarity index 96%
rename from lib/lower/runtime.cc
rename to lib/lower/Runtime.cpp
index 4d51b4733d55..6800a318c8b0 100644
--- a/lib/lower/runtime.cc
+++ b/lib/lower/Runtime.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/runtime.cc ----------------------------------------------===//
+//===-- lower/Runtime.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "runtime.h"
-#include "builder.h"
+#include "flang/lower/Runtime.h"
+#include "fir/Dialect/FIRType.h"
+#include "flang/lower/OpBuilder.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
-#include "optimizer/FIRType.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
diff --git a/lib/optimizer/CMakeLists.txt b/lib/optimizer/CMakeLists.txt
index 784e3cec9a62..8f0d7a8cf228 100644
--- a/lib/optimizer/CMakeLists.txt
+++ b/lib/optimizer/CMakeLists.txt
@@ -1,44 +1,20 @@
-#===-- lib/fir/CMakeLists.txt ----------------------------------------------===#
-#
-# 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
-#
-#===----------------------------------------------------------------------===--#
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
 
 add_subdirectory(Transforms)
 
-add_llvm_library(FIR
-  Attribute.cpp
+add_llvm_library(FortranOptimizer
   CodeGen.cpp
-  FIRDialect.cpp
-  FIROps.cpp
-  FIRType.cpp
   InternalNames.cpp
   IteratedDominanceFrontier.cpp
   KindMapping.cpp
   StdConverter.cpp
 )
 
-add_dependencies(FIR FIROpsIncGen)
-
-target_link_libraries(FIR
-  MLIRTargetLLVMIR
-  MLIRTargetLLVMIRModuleTranslation
-  MLIREDSC
-  MLIRExecutionEngine
-  MLIRParser
-  MLIRSupport
-  MLIRStandardToLLVM
-  MLIRTransforms
-  LLVMAsmParser
-  LLVMAsmPrinter
-  LLVMRemarks
+target_link_libraries(FortranOptimizer
+  FIRDialect
 )
 
-install (TARGETS FIR
+install (TARGETS FortranOptimizer
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib
 )
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index 778da284c884..a7b88413efc0 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -6,7 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/CodeGen/CodeGen.h"
+#include "flang/optimizer/CodeGen/CodeGen.h"
+#include "fir/Dialect/FIRAttr.h"
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIROps.h"
+#include "fir/Dialect/FIRType.h"
+#include "flang/optimizer/InternalNames.h"
+#include "flang/optimizer/KindMapping.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
@@ -16,12 +22,6 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Target/LLVMIR.h"
 #include "mlir/Transforms/DialectConversion.h"
-#include "optimizer/Attribute.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/FIRType.h"
-#include "optimizer/InternalNames.h"
-#include "optimizer/KindMapping.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Config/abi-breaking.h"
 #include "llvm/IR/IRBuilder.h"
diff --git a/lib/optimizer/InternalNames.cpp b/lib/optimizer/InternalNames.cpp
index dbd43db4d03f..5509374c5538 100644
--- a/lib/optimizer/InternalNames.cpp
+++ b/lib/optimizer/InternalNames.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/InternalNames.h"
+#include "flang/optimizer/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
diff --git a/lib/optimizer/IteratedDominanceFrontier.cpp b/lib/optimizer/IteratedDominanceFrontier.cpp
index 855b9d55abc7..65e7e653e132 100644
--- a/lib/optimizer/IteratedDominanceFrontier.cpp
+++ b/lib/optimizer/IteratedDominanceFrontier.cpp
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/Analysis/IteratedDominanceFrontier.h"
+#include "flang/optimizer/Analysis/IteratedDominanceFrontier.h"
 #include "mlir/Analysis/Dominance.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
diff --git a/lib/optimizer/KindMapping.cpp b/lib/optimizer/KindMapping.cpp
index f9c12aaf8065..da72e7849295 100644
--- a/lib/optimizer/KindMapping.cpp
+++ b/lib/optimizer/KindMapping.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/KindMapping.h"
+#include "flang/optimizer/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
diff --git a/lib/optimizer/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
index 43f3b184c488..c1d3698acbce 100644
--- a/lib/optimizer/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -6,17 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "optimizer/Transforms/StdConverter.h"
+#include "flang/optimizer/Transforms/StdConverter.h"
+#include "fir/Dialect/FIRAttr.h"
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIROpsSupport.h"
+#include "fir/Dialect/FIRType.h"
+#include "flang/optimizer/KindMapping.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
-#include "optimizer/Attribute.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/FIROpsSupport.h"
-#include "optimizer/FIRType.h"
-#include "optimizer/KindMapping.h"
 #include "llvm/ADT/ArrayRef.h"
 
 // This module performs the conversion of some FIR operations.
diff --git a/lib/optimizer/Transforms/CMakeLists.txt b/lib/optimizer/Transforms/CMakeLists.txt
index 5dfee56b6527..51f27a9eb531 100644
--- a/lib/optimizer/Transforms/CMakeLists.txt
+++ b/lib/optimizer/Transforms/CMakeLists.txt
@@ -1,11 +1,3 @@
-#===-- lib/fir/Transforms/CMakeLists.txt -----------------------------------===#
-#
-# 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
-#
-#===----------------------------------------------------------------------===--#
-
 add_llvm_library(FIRTransforms
   CSE.cpp
   MemToReg.cpp
@@ -15,7 +7,7 @@ add_llvm_library(FIRTransforms
 add_dependencies(FIRTransforms FIROpsIncGen)
 
 target_link_libraries(FIRTransforms
-  FIR
+  FIRDialect
 )
 
 install (TARGETS FIRTransforms
diff --git a/lib/optimizer/Transforms/CSE.cpp b/lib/optimizer/Transforms/CSE.cpp
index 83e718fdc5ca..1d3d2600f719 100644
--- a/lib/optimizer/Transforms/CSE.cpp
+++ b/lib/optimizer/Transforms/CSE.cpp
@@ -12,6 +12,8 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "fir/Dialect/FIROpsSupport.h"
+#include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
@@ -20,8 +22,6 @@
 #include "mlir/Support/Functional.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
-#include "optimizer/FIROpsSupport.h"
-#include "optimizer/Transforms/Passes.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/ScopedHashTable.h"
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
index bd565a4d2c04..ba2264cd59a2 100644
--- a/lib/optimizer/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIROps.h"
+#include "flang/optimizer/Analysis/IteratedDominanceFrontier.h"
+#include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/Pass/Pass.h"
-#include "optimizer/Analysis/IteratedDominanceFrontier.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/Transforms/Passes.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include <utility>
diff --git a/lib/optimizer/Transforms/RewriteLoop.cpp b/lib/optimizer/Transforms/RewriteLoop.cpp
index 0c80e835b178..80b4fb67620f 100644
--- a/lib/optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/optimizer/Transforms/RewriteLoop.cpp
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "fir/Dialect/FIRDialect.h"
+#include "fir/Dialect/FIROps.h"
+#include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/FIROps.h"
-#include "optimizer/Transforms/Passes.h"
 #include "llvm/Support/CommandLine.h"
 #include <memory>
 
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index df69de6aa880..ae58ccfb6446 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -1,6 +1,6 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
-  FIR
+  FIRDialect
   MLIRAffineOps
   MLIRLLVMIR
   MLIRLoopOps
@@ -24,4 +24,4 @@ set(EXE_LIBS
 add_llvm_tool(bbc bbc.cpp)
 llvm_update_compile_flags(bbc)
 whole_archive_link(bbc ${LIBS})
-target_link_libraries(bbc PRIVATE FIR MLIRIR FirBbcLib ${EXE_LIBS} LLVMSupport)
+target_link_libraries(bbc PRIVATE FIRDialect MLIRIR FirBbcLib ${EXE_LIBS} LLVMSupport)
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 1ec88c1c713b..351a74b9e158 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -13,8 +13,6 @@
 
 #include "../../lib/common/Fortran-features.h"
 #include "../../lib/common/default-kinds.h"
-#include "../../lib/lower/bridge.h"
-#include "../../lib/lower/convert-expr.h"
 #include "../../lib/parser/characters.h"
 #include "../../lib/parser/dump-parse-tree.h"
 #include "../../lib/parser/message.h"
@@ -26,6 +24,14 @@
 #include "../../lib/semantics/expression.h"
 #include "../../lib/semantics/semantics.h"
 #include "../../lib/semantics/unparse-with-symbols.h"
+#include "fir/Dialect/FIRDialect.h"
+#include "flang/lower/Bridge.h"
+#include "flang/lower/ConvertExpr.h"
+#include "flang/optimizer/CodeGen/CodeGen.h"
+#include "flang/optimizer/InternalNames.h"
+#include "flang/optimizer/KindMapping.h"
+#include "flang/optimizer/Transforms/Passes.h"
+#include "flang/optimizer/Transforms/StdConverter.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
@@ -33,12 +39,6 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"
-#include "optimizer/CodeGen/CodeGen.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/InternalNames.h"
-#include "optimizer/KindMapping.h"
-#include "optimizer/Transforms/Passes.h"
-#include "optimizer/Transforms/StdConverter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/InitLLVM.h"
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index ef60b9891d47..e3b55e773a94 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -1,6 +1,6 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
-  FIR
+  FIRDialect
   MLIRAffineOps
   MLIRIR
   MLIRLLVMIR
@@ -32,4 +32,4 @@ set(EXE_LIBS
 add_llvm_tool(tco tco.cpp)
 llvm_update_compile_flags(tco)
 whole_archive_link(tco ${LIBS})
-target_link_libraries(tco PRIVATE FIR MLIRIR FirTcoLib ${EXE_LIBS} LLVMSupport)
+target_link_libraries(tco PRIVATE FIRDialect MLIRIR FirTcoLib ${EXE_LIBS} LLVMSupport)
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 022fdfa6f8cb..1f5f8cc5385e 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -11,6 +11,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "fir/Dialect/FIRDialect.h"
+#include "flang/optimizer/CodeGen/CodeGen.h"
+#include "flang/optimizer/InternalNames.h"
+#include "flang/optimizer/KindMapping.h"
+#include "flang/optimizer/Transforms/Passes.h"
+#include "flang/optimizer/Transforms/StdConverter.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
@@ -18,12 +24,6 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"
-#include "optimizer/CodeGen/CodeGen.h"
-#include "optimizer/FIRDialect.h"
-#include "optimizer/InternalNames.h"
-#include "optimizer/KindMapping.h"
-#include "optimizer/Transforms/Passes.h"
-#include "optimizer/Transforms/StdConverter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/InitLLVM.h"

From e1ef015ff15450f6b99ebf6c701382c9ebbec5ea Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 14 Jan 2020 15:04:40 -0800
Subject: [PATCH 163/345] add test-lit

---
 test-lit/CMakeLists.txt | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 test-lit/CMakeLists.txt

diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
new file mode 100644
index 000000000000..7cc38bc97ae3
--- /dev/null
+++ b/test-lit/CMakeLists.txt
@@ -0,0 +1,36 @@
+# Test runner infrastructure for Flang. This configures the Flang test trees
+# for use by Lit, and delegates to LLVM's lit test handlers.
+
+set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/tools/f18/include)
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
+)
+
+set(FLANG_TEST_PARAMS
+  flang_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py)
+
+set(FLANG_TEST_DEPENDS
+  f18
+  llvm-lit
+  FileCheck
+  count
+  not
+  bbc
+  tco
+)
+
+add_lit_testsuite(check-flang "Running the Flang regression tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  PARAMS ${FLANG_TEST_PARAMS}
+  DEPENDS ${FLANG_TEST_DEPENS}
+)
+
+set_target_properties(check-flang PROPERTIES FOLDER "Tests")
+add_lit_testsuites(FLANG ${CMAKE_CURRENT_SOURCE_DIR}
+  DEPENDS ${FLANG_TEST_DEPS}
+)
+

From ebb80cb72bda74309ca29d06ebf65394e7c5a305 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 15 Jan 2020 04:08:52 -0800
Subject: [PATCH 164/345] Clean-up include names after fir headers directory
 changes

---
 include/fir/Dialect/FIROps.h      |  2 +-
 include/flang/lower/ASTBuilder.h  |  4 ++--
 include/flang/lower/ConvertType.h |  2 +-
 include/flang/lower/OpBuilder.h   |  2 +-
 include/flang/lower/Utils.h       |  2 +-
 lib/fir/Dialect/FIRDialect.cpp    |  2 +-
 lib/fir/Dialect/FIROps.cpp        |  2 +-
 lib/lower/runtime.def             | 36 -------------------------------
 8 files changed, 8 insertions(+), 44 deletions(-)
 delete mode 100644 lib/lower/runtime.def

diff --git a/include/fir/Dialect/FIROps.h b/include/fir/Dialect/FIROps.h
index 8b85b4bb2b7d..33ed70bdc50e 100644
--- a/include/fir/Dialect/FIROps.h
+++ b/include/fir/Dialect/FIROps.h
@@ -122,7 +122,7 @@ ParseResult parseCmpfOp(OpAsmParser &parser, OperationState &result);
 ParseResult parseCmpcOp(OpAsmParser &parser, OperationState &result);
 
 #define GET_OP_CLASSES
-#include "optimizer/FIROps.h.inc"
+#include "fir/Dialect/FIROps.h.inc"
 
 LoopOp getForInductionVarOwner(mlir::Value val);
 
diff --git a/include/flang/lower/ASTBuilder.h b/include/flang/lower/ASTBuilder.h
index 6f8c74f47360..370d136b3076 100644
--- a/include/flang/lower/ASTBuilder.h
+++ b/include/flang/lower/ASTBuilder.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_LOWER_AST_BUILDER_H_
 #define FORTRAN_LOWER_AST_BUILDER_H_
 
-#include "../parser/parse-tree.h"
-#include "../semantics/scope.h"
+#include "../../../lib/parser/parse-tree.h"
+#include "../../../lib/semantics/scope.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::lower {
diff --git a/include/flang/lower/ConvertType.h b/include/flang/lower/ConvertType.h
index d8c65d1f7d40..083793cb3361 100644
--- a/include/flang/lower/ConvertType.h
+++ b/include/flang/lower/ConvertType.h
@@ -17,7 +17,7 @@
 ///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-#include "../common/Fortran.h"
+#include "../../../lib/common/Fortran.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
diff --git a/include/flang/lower/OpBuilder.h b/include/flang/lower/OpBuilder.h
index 2d96e3462f4f..8efc89343e1b 100644
--- a/include/flang/lower/OpBuilder.h
+++ b/include/flang/lower/OpBuilder.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_BUILDER_H_
 #define FORTRAN_LOWER_BUILDER_H_
 
-#include "../semantics/symbol.h"
+#include "../../../lib/semantics/symbol.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
diff --git a/include/flang/lower/Utils.h b/include/flang/lower/Utils.h
index 0802d4f80c22..a1a807da88c3 100644
--- a/include/flang/lower/Utils.h
+++ b/include/flang/lower/Utils.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_UTILS_H
 #define FORTRAN_LOWER_UTILS_H
 
-#include "../parser/char-block.h"
+#include "../../../lib/parser/char-block.h"
 #include "llvm/ADT/StringRef.h"
 
 /// Convert an F18 CharBlock to an LLVM StringRef
diff --git a/lib/fir/Dialect/FIRDialect.cpp b/lib/fir/Dialect/FIRDialect.cpp
index 2b01a6d67d97..6106fa49d1e1 100644
--- a/lib/fir/Dialect/FIRDialect.cpp
+++ b/lib/fir/Dialect/FIRDialect.cpp
@@ -51,7 +51,7 @@ fir::FIROpsDialect::FIROpsDialect(M::MLIRContext *ctx)
                 PointIntervalAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<GlobalOp, DispatchTableOp,
 #define GET_OP_LIST
-#include "optimizer/FIROps.cpp.inc"
+#include "fir/Dialect/FIROps.cpp.inc"
                 >();
 }
 
diff --git a/lib/fir/Dialect/FIROps.cpp b/lib/fir/Dialect/FIROps.cpp
index f82b3cf780b8..8e7f70390a92 100644
--- a/lib/fir/Dialect/FIROps.cpp
+++ b/lib/fir/Dialect/FIROps.cpp
@@ -632,6 +632,6 @@ GlobalOp createGlobalOp(M::Location loc, M::ModuleOp module, StringRef name,
 // Tablegen operators
 
 #define GET_OP_CLASSES
-#include "optimizer/FIROps.cpp.inc"
+#include "fir/Dialect/FIROps.cpp.inc"
 
 } // namespace fir
diff --git a/lib/lower/runtime.def b/lib/lower/runtime.def
deleted file mode 100644
index 94e5822dac04..000000000000
--- a/lib/lower/runtime.def
+++ /dev/null
@@ -1,36 +0,0 @@
-//===-- lib/lower/runtime.def ---------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// Define the various runtime entry points. At this point, these are entirely
-// bogons as we don't have a runtime library nor even a definition for one.
-
-// Fortran execution control primitive ops
-DEFINE_RUNTIME_ENTRY(STOP, "stop", (Intopt, Intopt), ())
-DEFINE_RUNTIME_ENTRY(ERROR_STOP, "error_stop", (Intopt, Intopt), ())
-DEFINE_RUNTIME_ENTRY(FAIL_IMAGE, "fail_image", (), ())
-
-// INTEGER ops
-DEFINE_RUNTIME_ENTRY(MAX, "int_max", (mlir::IntegerType, mlir::IntegerType), (mlir::IntegerType))
-DEFINE_RUNTIME_ENTRY(MIN, "int_min", (mlir::IntegerType, mlir::IntegerType), (mlir::IntegerType))
-DEFINE_RUNTIME_ENTRY(POW, "int_pow", (mlir::IntegerType, mlir::IntegerType), (mlir::IntegerType))
-
-// COMPLEX ops
-DEFINE_RUNTIME_ENTRY(CDIV, "complex_div", (Cplx, Cplx), (Cplx))
-
-// CHARACTER ops
-DEFINE_RUNTIME_ENTRY(CONCAT, "char_concat", (fir::CharacterType, fir::CharacterType), (fir::CharacterType))
-
-// TYPE descriptor queries
-DEFINE_RUNTIME_ENTRY(ISA_TYPE, "isa_type", (TypeDesc), (mlir::IntegerType))
-DEFINE_RUNTIME_ENTRY(ISA_SUBTYPE, "isa_subtype", (TypeDesc), (mlir::IntegerType))
-
-// ARRAY descriptor queries
-DEFINE_RUNTIME_ENTRY(GET_RANK, "get_rank", (TypeDesc), (mlir::IntegerType))
-DEFINE_RUNTIME_ENTRY(GET_ELETYPE, "get_element_type", (TypeDesc), (mlir::IntegerType))
-
-#undef DEFINE_RUNTIME_ENTRY

From 32325d3b07d3d45a0d2c6f7f534352791ca1b4f4 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 15 Jan 2020 04:10:13 -0800
Subject: [PATCH 165/345] Remove old runtime representation based on
 runtime.def runtime.def path was wrong after directory merry-round and rather
 than fixing the pass I took the oportunity to replace it and remove old code.
 The new representation used the constexpr runtime description
 `RuntimeStaticDescription` that was already defined.

---
 include/flang/lower/Runtime.h |  23 +++----
 lib/lower/Bridge.cpp          |  16 ++---
 lib/lower/ConvertExpr.cpp     |  20 +-----
 lib/lower/Runtime.cpp         | 114 +++++++++-------------------------
 4 files changed, 45 insertions(+), 128 deletions(-)

diff --git a/include/flang/lower/Runtime.h b/include/flang/lower/Runtime.h
index e722e3cf0613..7af965a72ec9 100644
--- a/include/flang/lower/Runtime.h
+++ b/include/flang/lower/Runtime.h
@@ -86,7 +86,7 @@ class RuntimeStaticDescription {
   /// Define possible runtime function argument/return type used in signature
   /// descriptions. They follow mlir standard types naming. MLIR types cannot
   /// directly be used because they can only be dynamically built.
-  enum TypeCode { i32, i64, f32, f64, c32, c64, IOCookie };
+  enum TypeCode { i32, i64, f32, f64, c32, c64, boolean, charPtr, IOCookie };
   using MaybeTypeCode = std::optional<TypeCode>; // for results
   using TypeCodeVector = StaticVector<TypeCode>; // for arguments
   static constexpr MaybeTypeCode voidTy{MaybeTypeCode{std::nullopt}};
@@ -186,23 +186,16 @@ class StaticMultimapView {
 private:
   Range range{nullptr, nullptr};
 };
-// TODO get rid of fake runtime below
 
-#define DEFINE_RUNTIME_ENTRY(A, B, C, D) FIRT_##A,
-enum RuntimeEntryCode {
-#include "runtime.def"
-  FIRT_LAST_ENTRY_CODE
+// Define Fortran related language (other than IO and maths)
+// TODO: complete this list while working on the runtime.
+enum class RuntimeEntryCode {
+  StopStatement,
+  StopStatementText,
+  FailImageStatement
 };
 
-llvm::StringRef getRuntimeEntryName(RuntimeEntryCode code);
-
-mlir::FunctionType getRuntimeEntryType(RuntimeEntryCode code,
-                                       mlir::MLIRContext &mlirContext,
-                                       int kind);
-
-mlir::FunctionType getRuntimeEntryType(RuntimeEntryCode code,
-                                       mlir::MLIRContext &mlirContext,
-                                       int inpKind, int resKind);
+mlir::FuncOp genRuntimeFunction(RuntimeEntryCode code, mlir::OpBuilder &);
 
 } // namespace Fortran::lower
 
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 9f2b8cb707dc..22da13ed8750 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -103,12 +103,6 @@ class FirConverter : public AbstractConverter {
     return Br::createTemporary(loc, *builder, localSymbols, genType(sym), &sym);
   }
 
-  // TODO: we need a map for the various Fortran runtime entry points
-  M::FuncOp genRuntimeFunction(RuntimeEntryCode rec, int kind) {
-    return genFunctionFIR(getRuntimeEntryName(rec),
-                          getRuntimeEntryType(rec, mlirContext, kind));
-  }
-
   M::FuncOp genFunctionFIR(L::StringRef callee, M::FunctionType funcTy) {
     if (auto func{getNamedFunction(module, callee)}) {
       return func;
@@ -872,17 +866,17 @@ class FirConverter : public AbstractConverter {
 
   // call FAIL IMAGE in runtime
   void genFIR(const Pa::FailImageStmt &stmt) {
-    auto callee{genRuntimeFunction(FIRT_FAIL_IMAGE, 0)};
+    auto callee{
+        genRuntimeFunction(RuntimeEntryCode::FailImageStatement, *builder)};
     L::SmallVector<M::Value, 1> operands; // FAIL IMAGE has no args
     builder->create<M::CallOp>(toLocation(), callee, operands);
   }
 
   // call STOP, ERROR STOP in runtime
   void genFIR(const Pa::StopStmt &stm) {
-    auto callee{
-        genRuntimeFunction(isStopStmt(stm) ? FIRT_STOP : FIRT_ERROR_STOP,
-                           defaults.GetDefaultKind(IntegerCat))};
-    // 2 args: stop-code-opt, quiet-opt
+    auto callee{genRuntimeFunction(RuntimeEntryCode::StopStatement, *builder)};
+    // TODO: 3 args: stop-code-opt, ierror, quiet-opt
+    // auto isError{genFIRLo!isStopStmt(stmt)}
     L::SmallVector<M::Value, 8> operands;
     builder->create<M::CallOp>(toLocation(), callee, operands);
   }
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 0d35eba8b0a5..327753f6062b 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -168,11 +168,6 @@ class ExprLowering {
     return createFunction(module, name, funTy);
   }
 
-  M::FuncOp getRuntimeFunction(RuntimeEntryCode callee, M::FunctionType funTy) {
-    auto name{getRuntimeEntryName(callee)};
-    return getFunction(name, funTy);
-  }
-
   // FIXME binary operation :: ('a, 'a) -> 'a
   template <Co::TypeCategory TC, int KIND>
   M::FunctionType createFunctionType() {
@@ -194,18 +189,6 @@ class ExprLowering {
     }
   }
 
-  /// Create a call to a Fortran runtime entry point
-  template <Co::TypeCategory TC, int KIND, typename A>
-  M::Value createBinaryFIRTCall(A const &ex, RuntimeEntryCode callee) {
-    L::SmallVector<M::Value, 2> operands;
-    operands.push_back(genval(ex.left()));
-    operands.push_back(genval(ex.right()));
-    M::FunctionType funTy = createFunctionType<TC, KIND>();
-    auto func{getRuntimeFunction(callee, funTy)};
-    auto x{builder.create<M::CallOp>(getLoc(), func, operands)};
-    return x.getResult(0); // FIXME
-  }
-
   template <typename OpTy, typename A>
   M::Value createCompareOp(A const &ex, M::CmpIPredicate pred, M::Value lhs,
                            M::Value rhs) {
@@ -383,8 +366,7 @@ class ExprLowering {
   }
   template <int KIND>
   M::Value genval(Ev::Concat<KIND> const &op) {
-    // TODO this is a bogus call
-    return createBinaryFIRTCall<CharacterCat, KIND>(op, FIRT_CONCAT);
+    TODO();
   }
 
   /// MIN and MAX operations
diff --git a/lib/lower/Runtime.cpp b/lib/lower/Runtime.cpp
index 6800a318c8b0..2cc9a49d800e 100644
--- a/lib/lower/Runtime.cpp
+++ b/lib/lower/Runtime.cpp
@@ -11,9 +11,7 @@
 #include "flang/lower/OpBuilder.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include <cassert>
 
 namespace Fortran::lower {
@@ -33,6 +31,10 @@ mlir::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
     return fir::CplxType::get(context, 4);
   case TypeCode::c64:
     return fir::CplxType::get(context, 8);
+  case TypeCode::boolean:
+    return mlir::IntegerType::get(8, context);
+  case TypeCode::charPtr:
+    return fir::ReferenceType::get(fir::CharacterType::get(context, 1));
   // ! IOCookie is experimental only so far
   case TypeCode::IOCookie:
     return fir::ReferenceType::get(mlir::IntegerType::get(64, context));
@@ -68,91 +70,37 @@ RuntimeStaticDescription::getFuncOp(mlir::OpBuilder &builder) const {
   }
   return function;
 }
-} // namespace Fortran::lower
-
-// TODO remove dependencies to stub rt below
-
-namespace Br = Fortran::lower;
-using namespace Fortran;
-using namespace Fortran::lower;
-
-namespace {
-
-using FuncPointer = llvm::SmallVector<mlir::Type, 4> (*)(mlir::MLIRContext *,
-                                                         int kind);
-
-// FIXME: these are wrong and just serving as temporary placeholders
-using Cplx = mlir::IntegerType;
-using Intopt = mlir::IntegerType;
-using TypeDesc = mlir::IntegerType;
-
-template <typename A, typename... B>
-void consType(llvm::SmallVector<mlir::Type, 4> &types, mlir::MLIRContext *ctx,
-              int kind) {
-  if constexpr (std::is_same_v<A, mlir::IntegerType>) {
-    types.emplace_back(A::get(kind, ctx));
-  } else if constexpr (std::is_same_v<A, mlir::ComplexType>) {
-    // FIXME: this is wrong
-    assert(false);
-    types.emplace_back(mlir::IntegerType::get(kind, ctx));
-  } else {
-    types.emplace_back(A::get(ctx, kind));
-  }
-  if constexpr (sizeof...(B) > 0) {
-    consType<B...>(types, ctx, kind);
-  }
-}
 
-template <typename... A>
-llvm::SmallVector<mlir::Type, 4> consType(mlir::MLIRContext *ctx, int kind) {
-  llvm::SmallVector<mlir::Type, 4> types;
-  if constexpr (sizeof...(A) > 0) {
-    consType<A...>(types, ctx, kind);
-  } else {
-    (void)ctx;
-    (void)kind;
-  }
-  return types;
-}
-
-#define DEFINE_RUNTIME_ENTRY(A, B, C, D) "Fortran_" B,
-char const *const RuntimeEntryNames[FIRT_LAST_ENTRY_CODE] = {
-#include "runtime.def"
+class RuntimeEntryDescription : public RuntimeStaticDescription {
+public:
+  using Key = RuntimeEntryCode;
+  constexpr RuntimeEntryDescription(Key k, const char *s, MaybeTypeCode r,
+                                    TypeCodeVector a)
+      : RuntimeStaticDescription{s, r, a}, key{k} {}
+  Key key;
 };
-
-#define UNPACK_TYPES(...) __VA_ARGS__
-#define DEFINE_RUNTIME_ENTRY(A, B, C, D) consType<UNPACK_TYPES C>,
-FuncPointer RuntimeEntryInputType[FIRT_LAST_ENTRY_CODE] = {
-#include "runtime.def"
+using RT = RuntimeStaticDescription;
+using RType = typename RT::TypeCode;
+using Args = typename RT::TypeCodeVector;
+using RTC = RuntimeEntryCode;
+static constexpr RuntimeEntryDescription runtimeTable[]{
+    {RTC::StopStatement, "StopStatement", RT::voidTy,
+     Args::create<RType::i32, RType::boolean, RType::boolean>()},
+    {RTC::StopStatementText, "StopStatementText", RT::voidTy,
+     Args::create<RType::charPtr, RType::i32, RType::boolean,
+                  RType::boolean>()},
+    {RTC::FailImageStatement, "StopStatementText", RT::voidTy,
+     Args::create<>()},
 };
 
-#define DEFINE_RUNTIME_ENTRY(A, B, C, D) consType<UNPACK_TYPES D>,
-FuncPointer RuntimeEntryResultType[FIRT_LAST_ENTRY_CODE] = {
-#include "runtime.def"
-};
-#undef UNPACK_TYPES
+static constexpr StaticMultimapView<RuntimeEntryDescription> runtimeMap{
+    runtimeTable};
 
-} // namespace
-
-llvm::StringRef Br::getRuntimeEntryName(RuntimeEntryCode code) {
-  assert(code < FIRT_LAST_ENTRY_CODE);
-  return {RuntimeEntryNames[code]};
-}
-
-mlir::FunctionType Br::getRuntimeEntryType(RuntimeEntryCode code,
-                                           mlir::MLIRContext &mlirContext,
-                                           int kind) {
-  assert(code < FIRT_LAST_ENTRY_CODE);
-  return mlir::FunctionType::get(
-      RuntimeEntryInputType[code](&mlirContext, kind),
-      RuntimeEntryResultType[code](&mlirContext, kind), &mlirContext);
+mlir::FuncOp genRuntimeFunction(RuntimeEntryCode code,
+                                mlir::OpBuilder &builder) {
+  auto description{runtimeMap.find(code)};
+  assert(description != runtimeMap.end());
+  return description->getFuncOp(builder);
 }
 
-mlir::FunctionType Br::getRuntimeEntryType(RuntimeEntryCode code,
-                                           mlir::MLIRContext &mlirContext,
-                                           int inpKind, int resKind) {
-  assert(code < FIRT_LAST_ENTRY_CODE);
-  return mlir::FunctionType::get(
-      RuntimeEntryInputType[code](&mlirContext, inpKind),
-      RuntimeEntryResultType[code](&mlirContext, resKind), &mlirContext);
-}
+} // namespace Fortran::lower

From c6412d04ef85f6c37d12ef9985f1e3a7acecda0e Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 15 Jan 2020 06:59:25 -0800
Subject: [PATCH 166/345] Make bbc and tco link against new FortranOptimizer
 lib

---
 tools/bbc/CMakeLists.txt | 1 +
 tools/tco/CMakeLists.txt | 1 +
 2 files changed, 2 insertions(+)

diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index ae58ccfb6446..ec55e8c785aa 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -1,6 +1,7 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIRDialect
+  FortranOptimizer
   MLIRAffineOps
   MLIRLLVMIR
   MLIRLoopOps
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index e3b55e773a94..cb016fc344eb 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -1,6 +1,7 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIRDialect
+  FortranOptimizer
   MLIRAffineOps
   MLIRIR
   MLIRLLVMIR

From fdf13153942fd8b46cd7794c8f63255eb958a035 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 15 Jan 2020 12:54:38 -0800
Subject: [PATCH 167/345] work on getting lit up

---
 include/fir/Dialect/FIROps.td             |  74 ++++-
 include/flang/optimizer/CodeGen/CodeGen.h |   5 +-
 lib/optimizer/CodeGen.cpp                 |  12 +-
 test-lit/CMakeLists.txt                   |   2 +-
 test-lit/fir/fir-ops.fir                  | 341 ++++++++++++++++++++++
 tools/bbc/bbc.cpp                         |  10 +-
 tools/tco/tco.cpp                         |  63 ++--
 7 files changed, 461 insertions(+), 46 deletions(-)
 create mode 100644 test-lit/fir/fir-ops.fir

diff --git a/include/fir/Dialect/FIROps.td b/include/fir/Dialect/FIROps.td
index 73074af16fbe..8f657b26d7d2 100644
--- a/include/fir/Dialect/FIROps.td
+++ b/include/fir/Dialect/FIROps.td
@@ -93,9 +93,12 @@ def AnyCoordinateLike : TypeConstraint<Or<[AnyInteger.predicate,
     fir_LenType.predicate]>, "any coordinate index">;
 def AnyCoordinateType : Type<AnyCoordinateLike.predicate, "coordinate type">;
 
+// Base class for FIR operations.
+// All operations automatically get a prefix of "fir.".
 class fir_Op<string mnemonic, list<OpTrait> traits>
   : Op<fir_Dialect, mnemonic, traits>;
 
+// Base class for FIR operations that take a single argument
 class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   : fir_Op<mnemonic, traits> {
   let parser = [{
@@ -117,6 +120,7 @@ class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   }];
 }
 
+// Base builder for allocate operations
 def fir_AllocateOpBuilder : OpBuilder<
   "Builder *builder, OperationState &result, Type inType,"
   "ArrayRef<Value> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
@@ -151,11 +155,13 @@ def fir_OneResultOpBuilder : OpBuilder<
       result.addAttribute(namedAttr.first, namedAttr.second);
   }]>;
 
+// Base class of FIR operations that return 1 result
 class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
   let builders = [fir_OneResultOpBuilder];
 }
 
+// Base class of FIR operations that have 1 argument and return 1 result
 class fir_SimpleOneResultOp<string mnemonic, list<OpTrait> traits = []> :
     fir_SimpleOp<mnemonic, traits>, Results<(outs fir_Type:$res)> {
   let builders = [fir_OneResultOpBuilder];
@@ -941,31 +947,52 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
   let summary = "boxes a given procedure and optional host context";
 
   let description = [{
-    Creates an abstract encapsulation of a PROCEDURE POINTER
-    along with an optional pointer to a host instance context. An internal
-    procedure may require a host instance for execution.
+    Creates an abstract encapsulation of a PROCEDURE POINTER along with an
+    optional pointer to a host instance context. If the pointer is not to an
+    internal procedure or the internal procedure does not need a host context
+    then the form takes only the procedure's symbol.
+
+      %0 = fir.emboxproc @f : ((i32) -> i32) -> !fir.boxproc<(i32) -> i32>
+
+    An internal procedure requiring a host instance for correct execution uses
+    the second form. The closure of the host procedure's state is passed as a
+    reference to a tuple. It is the responsibility of the host to manage the
+    context's values accordingly, up to and including inhibiting register
+    promotion of local values.
+
+      %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) ->
+                                  !fir.boxproc<(i32) -> i32>
   }];
 
   let parser = [{
-    M::FunctionType type;
-    M::SymbolRefAttr procref;
-    M::OpAsmParser::OperandType tupleref;
-    if (parser.parseAttribute(procref, "funcname", result.attributes))
+    M::SymbolRefAttr procRef;
+    if (parser.parseAttribute(procRef, "funcname", result.attributes))
       return M::failure();
     bool hasTuple = false;
+    M::OpAsmParser::OperandType tupleRef;
     if (!parser.parseOptionalComma()) {
-      if (parser.parseOperand(tupleref))
+      if (parser.parseOperand(tupleRef))
         return M::failure();
       hasTuple = true;
     }
-    if (parser.parseColonType(type))
+    M::FunctionType type;
+    if (parser.parseColon() ||
+        parser.parseLParen() ||
+        parser.parseType(type))
       return M::failure();
+    result.addAttribute("functype", M::TypeAttr::get(type));
     if (hasTuple) {
-      auto input = type.getInputs()[1];
-      if (parser.resolveOperand(tupleref, input, result.operands))
+      M::Type tupleType;
+      if (parser.parseComma() ||
+          parser.parseType(tupleType) ||
+          parser.resolveOperand(tupleRef, tupleType, result.operands))
         return M::failure();
     }
-    if (parser.addTypesToList(type.getResults(), result.types))
+    M::Type boxType;
+    if (parser.parseRParen() ||
+        parser.parseArrow() ||
+        parser.parseType(boxType) ||
+        parser.addTypesToList(boxType, result.types))
       return M::failure();
     return M::success();
   }];
@@ -977,8 +1004,23 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
       p << ", ";
       p.printOperand(h);
     }
-    p << " : ";
-    p.printFunctionalType(getOperation());
+    p << " : (" << getAttr("functype");
+    if (h)
+      p << ", " << h->getType();
+    p << ") -> " << getType();
+  }];
+
+  let verifier = [{
+    // host bindings (optional) must be a reference to a tuple
+    if (auto h = host()) {
+      if (auto r = h.getType().dyn_cast<ReferenceType>()) {
+        if (!r.getEleTy().dyn_cast<M::TupleType>())
+          return M::failure();
+      } else {
+        return M::failure();
+      }
+    }
+    return M::success();
   }];
 }
 
@@ -1388,7 +1430,9 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]>,
 
   let printer = [{
     p << getOperationName() << ' ';
-    p.printOperand(adt());
+    p.printOperand(adt());    
+    p << ", ";
+    p.printOperand(val());    
     p << ", ";
     p.printOperands(coor());
     p << " : ";
diff --git a/include/flang/optimizer/CodeGen/CodeGen.h b/include/flang/optimizer/CodeGen/CodeGen.h
index 224d67f248b8..02846e907c53 100644
--- a/include/flang/optimizer/CodeGen/CodeGen.h
+++ b/include/flang/optimizer/CodeGen/CodeGen.h
@@ -12,7 +12,7 @@
 #include <memory>
 
 namespace llvm {
-class StringRef;
+class raw_ostream;
 }
 namespace mlir {
 class Pass;
@@ -26,7 +26,8 @@ struct NameUniquer;
 std::unique_ptr<mlir::Pass> createFIRToLLVMPass(NameUniquer &uniquer);
 
 /// Convert the LLVM IR dialect to LLVM-IR proper
-std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass(llvm::StringRef output);
+std::unique_ptr<mlir::Pass>
+createLLVMDialectToLLVMPass(llvm::raw_ostream &output);
 
 } // namespace fir
 
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index a7b88413efc0..8b8e780fc58f 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -2046,17 +2046,14 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
 struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
-  LLVMIRLoweringPass(L::StringRef outputName) : outputName{outputName} {}
+  LLVMIRLoweringPass(L::raw_ostream &output) : output{output} {}
 
   void runOnModule() override {
     if (ClDisableLLVM)
       return;
 
     if (auto llvmModule{M::translateModuleToLLVMIR(getModule())}) {
-      std::error_code ec;
-      L::raw_fd_ostream stream(outputName, ec, L::sys::fs::F_None);
-      stream << *llvmModule << '\n';
-      L::errs() << outputName << " written\n";
+      output << *llvmModule;
       return;
     }
 
@@ -2066,7 +2063,7 @@ struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
   }
 
 private:
-  L::StringRef outputName;
+  L::raw_ostream &output;
 };
 
 } // namespace
@@ -2076,6 +2073,7 @@ fir::createFIRToLLVMPass(fir::NameUniquer &nameUniquer) {
   return std::make_unique<FIRToLLVMLoweringPass>(nameUniquer);
 }
 
-std::unique_ptr<M::Pass> fir::createLLVMDialectToLLVMPass(L::StringRef output) {
+std::unique_ptr<M::Pass>
+fir::createLLVMDialectToLLVMPass(L::raw_ostream &output) {
   return std::make_unique<LLVMIRLoweringPass>(output);
 }
diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index 7cc38bc97ae3..5fee7aab5333 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -33,4 +33,4 @@ set_target_properties(check-flang PROPERTIES FOLDER "Tests")
 add_lit_testsuites(FLANG ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${FLANG_TEST_DEPS}
 )
-
+set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
diff --git a/test-lit/fir/fir-ops.fir b/test-lit/fir/fir-ops.fir
new file mode 100644
index 000000000000..f8958882079d
--- /dev/null
+++ b/test-lit/fir/fir-ops.fir
@@ -0,0 +1,341 @@
+// Test the FIR operations
+
+// RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
+
+// Fortran Intrinsic types
+// CHECK-LABEL: func @it1() -> !fir.int<4>
+// CHECK-LABEL: func @it2() -> !fir.real<8>
+// CHECK-LABEL: func @it3() -> !fir.complex<8>
+// CHECK-LABEL: func @it4() -> !fir.logical<1>
+// CHECK-LABEL: func @it5() -> !fir.char<1>
+func @it1() -> !fir.int<4>
+func @it2() -> !fir.real<8>
+func @it3() -> !fir.complex<8>
+func @it4() -> !fir.logical<1>
+func @it5() -> !fir.char<1>
+
+// Fortran Derived types (records)
+// CHECK-LABEL: func @dvd1() -> !fir.type<derived1>
+// CHECK-LABEL: func @dvd2() -> !fir.type<derived2(p:i32)>
+// CHECK-LABEL: func @dvd3() -> !fir.type<derived3{f:f32}>
+// CHECK-LABEL: func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+func @dvd1() -> !fir.type<derived1>
+func @dvd2() -> !fir.type<derived2(p:i32)>
+func @dvd3() -> !fir.type<derived3{f:f32}>
+func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+
+// FIR array types
+// CHECK-LABEL: func @arr1() -> !fir.array<10xf32>
+// CHECK-LABEL: func @arr2() -> !fir.array<10x10xf32>
+// CHECK-LABEL: func @arr3() -> !fir.array<?xf32>
+// CHECK-LABEL: func @arr4() -> !fir.array<10x?xf32>
+// CHECK-LABEL: func @arr5() -> !fir.array<?x?xf32>
+// CHECK-LABEL: func @arr6() -> !fir.array<*:f32>
+func @arr1() -> !fir.array<10xf32>
+func @arr2() -> !fir.array<10x10xf32>
+func @arr3() -> !fir.array<?xf32>
+func @arr4() -> !fir.array<10x?xf32>
+func @arr5() -> !fir.array<?x?xf32>
+func @arr6() -> !fir.array<*:f32>
+
+// FIR pointer-like types
+// CHECK-LABEL: func @mem1() -> !fir.ref<i32>
+// CHECK-LABEL: func @mem2() -> !fir.ptr<i32>
+// CHECK-LABEL: func @mem3() -> !fir.heap<i32>
+// CHECK-LABEL: func @mem4() -> !fir.ref<() -> ()>
+func @mem1() -> !fir.ref<i32>
+func @mem2() -> !fir.ptr<i32>
+func @mem3() -> !fir.heap<i32>
+func @mem4() -> !fir.ref<() -> ()>
+
+// FIR box types (descriptors)
+// CHECK-LABEL: func @box1() -> !fir.box<!fir.array<?xf32>>
+// CHECK-LABEL: func @box2() -> !fir.boxchar<2>
+// CHECK-LABEL: func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK-LABEL: func @box4() -> !fir.box<!fir.type<derived3{f:f32}>>
+func @box1() -> !fir.box<!fir.array<?xf32>>
+func @box2() -> !fir.boxchar<2>
+func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+func @box4() -> !fir.box<!fir.type<derived3{f:f32}>>
+
+// FIR misc. types
+// CHECK-LABEL: func @oth1() -> !fir.dims<1>
+// CHECK-LABEL: func @oth2() -> !fir.field
+// CHECK-LABEL: func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
+func @oth1() -> !fir.dims<1>
+func @oth2() -> !fir.field
+func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
+
+// Fortran SUBROUTINE and FUNCTION
+// CHECK-LABEL: func @print_index3(index, index, index)
+// CHECK-LABEL: func @user_i64(i64)
+// CHECK-LABEL: func @user_tdesc(!fir.tdesc<!fir.type<x>>)
+func @print_index3(index, index, index)
+func @user_i64(i64)
+func @user_tdesc(!fir.tdesc<!fir.type<x>>)
+
+// expect the void return to be omitted
+// CHECK-LABEL: func @store_tuple(!fir.type<qq1{f1:i32}>)
+func @store_tuple(!fir.type<qq1{f1:i32}>) -> ()
+
+// CHECK-LABEL: func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
+// CHECK-LABEL: func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
+func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+
+// CHECK-LABEL: func @nop()
+func @nop()
+
+// CHECK-LABEL: func @get_func() -> (() -> ())
+func @get_func() -> (() -> ())
+
+// CHECK-LABEL: @instructions
+func @instructions() {
+  // CHECK: %[[A0:.*]] = fir.alloca !fir.array<10xi32>
+  %0 = fir.alloca !fir.array<10xi32>
+  // CHECK: fir.load %[[A0]] : !fir.ref<!fir.array<10xi32>>
+  %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
+  %2 = fir.alloca i32
+  %3 = constant 22 : i32
+  // CHECK: fir.store %{{.*}} to %{{.*}} : !fir.ref<i32>
+  fir.store %3 to %2 : !fir.ref<i32>
+  // CHECK: fir.undefined i32
+  %4 = fir.undefined i32
+  // CHECK: %[[A5:.*]] = fir.allocmem !fir.array<100xf32>
+  %5 = fir.allocmem !fir.array<100xf32>
+  // CHECK: %[[A6:.*]] = fir.embox %[[A5]] : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
+  %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
+  // CHECK: fir.box_addr %{{.*}} : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
+  %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
+  %c0 = constant 0 : index
+  // CHECK: %[[A8:.*]]:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
+  %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
+  // CHECK: fir.call @print_index3(%[[A8]]#0, %[[A8]]#1, %[[A8]]#2) : (index, index, index)
+  fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()
+  %8 = fir.call @it1() : () -> !fir.int<4>
+  // CHECK: fir.box_elesize %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
+  %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i64
+  // CHECK: fir.box_isalloc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+  %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  // CHECK: fir.box_isarray %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+  %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  // CHECK: fir.box_isptr %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+  %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i1
+  // CHECK: fir.box_rank %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
+  %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64
+  // CHECK: fir.box_tdesc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
+  %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
+  %15 = fir.call @box2() : () -> !fir.boxchar<2>
+  // CHECK: fir.boxchar_len %{{.*}} : (!fir.boxchar<2>) -> i32
+  %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
+  %17 = fir.call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
+  // CHECK: fir.boxproc_host %{{.*}} : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
+  %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
+  %19 = constant 10 : i32
+  // CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
+  %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
+  // CHECK: fir.field_index f, !fir.type<derived{f:f32}>
+  %21 = fir.field_index f, !fir.type<derived{f:f32}>
+  // CHECK: fir.undefined !fir.type<derived{f:f32}>
+  %22 = fir.undefined !fir.type<derived{f:f32}>
+  // CHECK: fir.extract_value %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, !fir.field) -> f32
+  %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32
+  %c1 = constant 1 : i32
+  // CHECK: fir.gendims %{{.*}}, %{{.*}}, %{{.*}} : (i32, i32, i32) -> !fir.dims<1>
+  %24 = fir.gendims %c1, %19, %c1 : (i32, i32, i32) -> !fir.dims<1>
+  %cf1 = constant 1.0 : f32
+  // CHECK: fir.insert_value %{{.*}}, %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
+  %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
+  // CHECK: fir.len_param_index f, !fir.type<derived3{f:f32}>
+  %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>
+  %27 = fir.call @box4() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+  // CHECK: fir.dispatch "method"(%{{.*}}) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
+  %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
+  // CHECK: fir.convert %{{.*}} : (i32) -> i64
+  %29 = fir.convert %28 : (i32) -> i64
+  // CHECK: fir.gentypedesc !fir.type<x>
+  %30 = fir.gentypedesc !fir.type<x>
+  fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
+  // CHECK: fir.no_reassoc %{{.*}} : i64
+  %31 = fir.no_reassoc %29 : i64
+  fir.call @user_i64(%31) : (i64) -> ()
+  // CHECK: fir.freemem %{{.*}} : !fir.heap<!fir.array<100xf32>>
+  fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
+  %32 = fir.call @get_func() : () -> (() -> ())
+  fir.call %32() : () -> ()
+  // CHECK: fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
+  %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
+  return
+}
+
+// CHECK-LABEL: @boxing_match
+func @boxing_match() {
+  %0 = fir.alloca i32
+  %d6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
+  %d3 = fir.alloca !fir.char<1>
+  %e6 = fir.alloca tuple<i32,f64>
+  %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>
+  // CHECK: fir.unbox %{{.*}} : (!fir.box<i32>) -> (!fir.ref<i32>, i32, i32, !fir.tdesc<i32>, i32, !fir.dims<0>)
+  %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.dims<0>)
+  %c8 = constant 8 : i32
+  %3 = fir.undefined !fir.char<1>
+  // CHECK: fir.emboxchar %{{.*}}, %{{.*}} : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
+  // CHECK: fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
+  %4 = fir.emboxchar %d3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
+  %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
+  %6 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
+  %z = constant 0 : i32
+  %c12 = constant 12 : i32
+  %a2 = fir.insert_value %6, %c12, %z : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+  %z1 = constant 1 : i32
+  %c42 = constant 42.13 : f64
+  %a3 = fir.insert_value %6, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+  fir.store %a3 to %d6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
+  %7 = fir.emboxproc @method_impl, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
+  %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>)
+  // CHECK: fir.emboxproc @method_impl, %{{.*}} : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
+  // CHECK: fir.unboxproc %{{.*}} : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>)
+  %9 = call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
+  %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<!fir.type<qq1{f1:i32}>>)
+  %11 = fir.load %10#1 : !fir.ref<!fir.type<qq1{f1:i32}>>
+  fir.call @store_tuple(%11) : (!fir.type<qq1{f1:i32}>) -> ()
+  return
+}
+
+// CHECK-LABEL: @loop
+func @loop() {
+  %c1 = constant 1 : index
+  %c10 = constant 10 : index
+  %ct = constant true
+  // CHECK: fir.loop %{{.*}} = %{{.*}} to %{{.*}} {
+  fir.loop %i = %c1 to %c10 {
+    // CHECK: fir.where %{{.*}} {
+    fir.where %ct {
+      fir.call @nop() : () -> ()
+    // CHECK: } otherwise {
+    } otherwise {
+      fir.call @nop() : () -> ()
+    }
+  }
+  // CHECK: fir.unreachable
+  fir.unreachable
+}
+
+// CHECK-LABEL: @bar_select
+func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), -3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), 4, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2 : i32, %b3:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = addi %4, %b3 : i32
+  return %5 : i32
+^bb3(%c:i32, %c2:i32) :
+  %6 = addi %c, %c2 : i32
+  return %6 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+// CHECK-LABEL: @bar_select_rank
+func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select_rank %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), 3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), -1, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2 : i32, %b3:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = addi %4, %b3 : i32
+  return %5 : i32
+^bb3(%c:i32, %c2:i32) :
+  %6 = addi %c, %c2 : i32
+  return %6 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  %7 = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+  fir.dispatch method(%7) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
+  return %zero : i32
+}
+
+// CHECK-LABEL: @bar_select_type
+func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select_type %{{.*}} : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.instance<!fir.int<4>>, ^bb1(%{{.*}} : i32), #fir.instance<!fir.int<8>>, ^bb2(%{{.*}} : i32), #fir.subsumed<!fir.int<2>>, ^bb3(%{{.*}} : i32), #fir.instance<!fir.int<1>>, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32) :
+  return %b : i32
+^bb3(%c : i32) :
+  return %c : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+// CHECK-LABEL: @bar_select_case
+func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
+  %0 = constant 1 : i32
+  %1 = constant 2 : i32
+  %2 = constant 3 : i32
+  %3 = constant 4 : i32
+  // CHECK: fir.select_case %{{.*}} : i32 [#fir.point, %{{.*}}, ^bb1(%{{.*}} : i32), #fir.lower, %{{.*}}, ^bb2(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32, i32), #fir.interval, %{{.*}}, %{{.*}}, ^bb3(%{{.*}}, %{{.*}} : i32, i32), #fir.upper, %{{.*}}, ^bb4(%{{.*}} : i32), unit, ^bb5]
+  fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) :
+  %4 = addi %b, %b2 : i32
+  %5 = muli %4, %b3 : i32
+  %6 = addi %5, %b4 : i32
+  return %6 : i32
+^bb3(%c : i32, %c2 : i32) :
+  %7 = addi %c, %c2 : i32
+  return %7 : i32
+^bb4(%d : i32) :
+  return %d : i32
+^bb5 :
+  %zero = constant 0 : i32
+  return %zero : i32
+}
+
+// CHECK-LABEL: @global_var
+fir.global @global_var : i32 {
+  %0 = constant 1 : i32
+}
+
+// CHECK-LABEL: @global_constant
+fir.global @global_constant constant : i32 {
+  %0 = constant 934 : i32
+}
+
+// CHECK-LABEL: @global_derived
+fir.global @global_derived : !fir.type<mine{f:i32}> {
+  %0 = constant 1 : i32
+  // CHECK: fir.global_entry "f", %{{.*}} : i32
+  fir.global_entry "f", %0 : i32
+}
+
+// CHECK-LABEL: @dispatch_tbl
+fir.dispatch_table @dispatch_tbl {
+  // CHECK: fir.dt_entry "method", @method_impl
+  fir.dt_entry "method", @method_impl
+}
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 351a74b9e158..2cb5cfdd1df1 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -44,6 +44,7 @@
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iostream>
 
@@ -147,7 +148,14 @@ void convertFortranSourceToMLIR(
 
   if (EmitLLVM) {
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
-    pm.addPass(fir::createLLVMDialectToLLVMPass(OutputFilename + ".ll"));
+    std::error_code ec;
+    llvm::ToolOutputFile out(OutputFilename + ".ll", ec,
+                             llvm::sys::fs::OF_None);
+    if (ec) {
+      errs() << "can't open output file " + OutputFilename + ".ll";
+      return;
+    }
+    pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
   }
 
   if (mlir::succeeded(pm.run(mlirModule))) {
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 1f5f8cc5385e..3db3f9d606db 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -4,7 +4,7 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-// =============================================================================
+//===----------------------------------------------------------------------===//
 //
 // This is to be like LLVM's opt program, only for FIR.  Such a program is
 // required for roundtrip testing, etc.
@@ -29,23 +29,36 @@
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace {
 
 namespace Cl = llvm::cl;
 
-Cl::opt<std::string> ClInput(Cl::Positional, Cl::Required,
-                             Cl::desc("<input file>"));
+Cl::opt<std::string> inputFilename(Cl::Positional, Cl::desc("<input file>"),
+                                   Cl::init("-"));
+
+Cl::opt<std::string> outputFilename("o", Cl::desc("Specify output filename"),
+                                    Cl::value_desc("filename"), Cl::init("-"));
 
-Cl::opt<std::string> ClOutput("o", Cl::desc("Specify output filename"),
-                              Cl::value_desc("filename"), Cl::init("a.ll"));
+Cl::opt<bool> emitFir("emit-fir", Cl::desc("Parse and pretty-print the input"),
+                      Cl::init(false));
+
+void printModuleBody(mlir::ModuleOp mod) {
+  // don't output the terminator bogo-op
+  auto e{--mod.end()};
+  for (auto i{mod.begin()}; i != e; ++i) {
+    i->print(llvm::outs());
+    llvm::outs() << '\n';
+  }
+}
 
 // compile a .fir file
 int compileFIR() {
   // check that there is a file to load
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
-      llvm::MemoryBuffer::getFileOrSTDIN(ClInput);
+      llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
 
   if (std::error_code EC = fileOrErr.getError()) {
     llvm::errs() << "Could not open file: " << EC.message() << '\n';
@@ -59,7 +72,7 @@ int compileFIR() {
   auto owningRef = mlir::parseSourceFile(sourceMgr, context.get());
 
   if (!owningRef) {
-    llvm::errs() << "Error can't load file " << ClInput << '\n';
+    llvm::errs() << "Error can't load file " << inputFilename << '\n';
     return 2;
   }
   if (mlir::failed(owningRef->verify())) {
@@ -67,25 +80,35 @@ int compileFIR() {
     return 4;
   }
 
+  std::error_code ec;
+  llvm::ToolOutputFile out(outputFilename, ec, llvm::sys::fs::OF_None);
+
   // run passes
   fir::NameUniquer uniquer;
   fir::KindMapping kindMap{context.get()};
   mlir::PassManager pm{context.get()};
   mlir::applyPassManagerCLOptions(pm);
-  pm.addPass(fir::createMemToRegPass());
-  pm.addPass(fir::createCSEPass());
-  // convert fir dialect to affine
-  pm.addPass(fir::createPromoteToAffinePass());
-  // convert fir dialect to loop
-  pm.addPass(fir::createLowerToLoopPass());
-  pm.addPass(fir::createFIRToStdPass(kindMap));
-  // convert loop dialect to standard
-  pm.addPass(mlir::createLowerToCFGPass());
-  pm.addPass(fir::createFIRToLLVMPass(uniquer));
-  pm.addPass(fir::createLLVMDialectToLLVMPass(ClOutput));
-  if (mlir::succeeded(pm.run(*owningRef)))
+  if (emitFir) {
+    // parse the input and pretty-print it back out
+  } else {
+    pm.addPass(fir::createMemToRegPass());
+    pm.addPass(fir::createCSEPass());
+    // convert fir dialect to affine
+    pm.addPass(fir::createPromoteToAffinePass());
+    // convert fir dialect to loop
+    pm.addPass(fir::createLowerToLoopPass());
+    pm.addPass(fir::createFIRToStdPass(kindMap));
+    // convert loop dialect to standard
+    pm.addPass(mlir::createLowerToCFGPass());
+    pm.addPass(fir::createFIRToLLVMPass(uniquer));
+    pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
+  }
+  if (mlir::succeeded(pm.run(*owningRef))) {
+    if (emitFir)
+      printModuleBody(*owningRef);
     return 0;
-  llvm::errs() << "FAILED: " << ClInput << '\n';
+  }
+  llvm::errs() << "FAILED: " << inputFilename << '\n';
   return 8;
 }
 } // namespace

From 75a9663752a3db5b43c561f1f5dc01b2316cc09a Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 16 Jan 2020 06:26:36 -0800
Subject: [PATCH 168/345] Make flang lit test run with in-tree builds - Fix
 flang path to export to lit config - Add ".fir" extension in lit config to be
 considered as tests. Tested with intree builds, it will probably still not
 work with out-of-tree builds due to llvm-lit paths issues.

---
 test-lit/CMakeLists.txt | 10 ++++++++--
 test/lit.cfg.py         |  7 +++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index 5fee7aab5333..f5393623f802 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -1,7 +1,14 @@
 # Test runner infrastructure for Flang. This configures the Flang test trees
 # for use by Lit, and delegates to LLVM's lit test handlers.
 
-set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/tools/f18/include)
+# f18/flang tools path for lit
+set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
+# bbc/tco tools path for lit
+if (FLANG_BUILT_STANDALONE)
+ set(FLANG_LLVM_TOOLS_DIR  ${FLANG_BINARY_DIR}/bin)
+else()
+ set(FLANG_LLVM_TOOLS_DIR  ${LLVM_BINARY_DIR}/bin)
+endif()
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
@@ -33,4 +40,3 @@ set_target_properties(check-flang PROPERTIES FOLDER "Tests")
 add_lit_testsuites(FLANG ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${FLANG_TEST_DEPS}
 )
-set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index 439f9710ef66..f4eccd0b203f 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -29,6 +29,13 @@
                    '.ff90', '.f95', '.F95', '.ff95', '.fpp', '.FPP', '.cuf',
                    '.CUF', '.f18', '.F18', '.fir' ]
 
+# test_source_root: The root path where tests are located.
+config.test_source_root = os.path.dirname(__file__)
+
+
+# test_exec_root: The root path where tests should be run.
+config.test_exec_root = os.path.join(config.flang_obj_root, 'test-lit')
+
 config.substitutions.append(('%PATH%', config.environment['PATH']))
 
 llvm_config.use_default_substitutions()

From 4df66572f23076f54cf6ff5f0fa441ffabf2759e Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 16 Jan 2020 08:38:46 -0800
Subject: [PATCH 169/345] Enable out of tree lit regression tests and add
 related instructions

Conflicts:
	test/lit.site.cfg.py.in
---
 README.md               | 17 ++++++++++++++++-
 test/lit.cfg.py         |  4 ++++
 test/lit.site.cfg.py.in |  4 ++--
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 3ee6a3ea590d..e71e46ff509b 100644
--- a/README.md
+++ b/README.md
@@ -69,7 +69,7 @@ Or, of course, use their favorite build tool (such as ninja).
   cd build
   export CC=<my-favorite-C-compiler>
   export CXX=<my-favorite-C++-compiler>
-  cmake -GNinja ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DCMAKE_INSTALL_PREFIX=<install-llvm-here> <other-arguments>
+  cmake -GNinja ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DLLVM_INSTALL_UTILS=On -DCMAKE_INSTALL_PREFIX=<install-llvm-here> <other-arguments>
 ```
 
 5. Build and install
@@ -92,6 +92,11 @@ Or, of course, use their favorite build tool (such as ninja).
   cd build-flang
   cmake -GNinja ../f18 -DLLVM_DIR=<install-llvm-here> -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86 -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DCMAKE_INSTALL_PREFIX=<install-flang-here> <other-arguments>
 ```
+Note: if you plan on running lit regression tests, you should either:
+- Use `-DLLVM_DIR=<build-llvm-here>` instead of `-DLLVM_DIR=<install-llvm-here>`
+- Or, keep `-DLLVM_DIR=<install-llvm-here>` but add `-DLLVM_EXTERNAL_LIT=<path to llvm-lit>`.
+A valid `llvm-lit` path is `<build-llvm-here>/bin/llvm-lit`.
+Note that LLVM must also have been built with `-DLLVM_INSTALL_UTILS=On` so that tools required by tests like `FileCheck` are available in `<install-llvm-here>`.
 
 8. Build and install
 
@@ -101,6 +106,16 @@ Or, of course, use their favorite build tool (such as ninja).
   ninja install
 ```
 
+### Running regression tests
+
+Inside `build` for in-tree builds or inside `build-flang` for out-of-tree builds:
+
+```
+  ninja check-flang
+```
+
+Special CMake instructions given above are required while building out-of-tree so that lit regression tests can be run.
+
 ### Problems
 
 Despite best efforts, there may be situations where the above repos will
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index f4eccd0b203f..72faae7ef36c 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -54,6 +54,10 @@
 # Tweak the PATH to include the tools dir.
 llvm_config.with_environment('PATH', config.flang_tools_dir, append_path=True)
 llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
+# For out-of-tree builds, path to bbc and tco needs to be added
+
+if config.llvm_tools_dir != config.flang_llvm_tools_dir :
+  llvm_config.with_environment('PATH', config.flang_llvm_tools_dir, append_path=True)
 
 # For builds with FIR, set path for tco and enable related tests
 if config.flang_llvm_tools_dir != "" :
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index 92bd926ab5ca..ac50c3d7921a 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -6,8 +6,8 @@ config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
-config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
-config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
+#config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
+config.flang_llvm_tools_dir = "@FLANG_LLVM_TOOLS_DIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 
 # Support substitution of the tools_dir with user parameters. This is

From f96ac79778c50f5880bbe8fac4922024a023de13 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 16 Jan 2020 21:24:35 -0800
Subject: [PATCH 170/345] rebasing changes

---
 include/fir/Dialect/FIROps.td         | 52 +++++++++++++--------------
 include/flang/lower/ComplexHandler.h  |  4 +--
 lib/fir/Dialect/FIROps.cpp            | 22 ++++++------
 lib/lower/Bridge.cpp                  | 17 +++++----
 lib/lower/ConvertExpr.cpp             | 24 ++++++-------
 lib/lower/IO.cpp                      |  7 ++--
 lib/lower/Intrinsics.cpp              |  6 ++--
 lib/optimizer/CodeGen.cpp             | 50 +++++++++++++-------------
 lib/optimizer/Transforms/MemToReg.cpp | 32 ++++++++---------
 9 files changed, 105 insertions(+), 109 deletions(-)

diff --git a/include/fir/Dialect/FIROps.td b/include/fir/Dialect/FIROps.td
index 8f657b26d7d2..359b011164a0 100644
--- a/include/fir/Dialect/FIROps.td
+++ b/include/fir/Dialect/FIROps.td
@@ -299,7 +299,7 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
         mlir::emitError(result.location, "LoadOp has null argument");
         return;
       }
-      fir::ReferenceType refTy = refVal->getType().cast<fir::ReferenceType>();
+      fir::ReferenceType refTy = refVal.getType().cast<fir::ReferenceType>();
       result.addOperands(refVal);
       result.addTypes(refTy.getEleTy());
     }]
@@ -324,7 +324,7 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
     p << getOperationName() << ' ';
     p.printOperand(memref());
     p.printOptionalAttrDict(getAttrs(), {});
-    p << " : " << memref()->getType();
+    p << " : " << memref().getType();
   }];
 
   let extraClassDeclaration = [{
@@ -364,7 +364,7 @@ def fir_StoreOp : fir_Op<"store", []>,
     p << " to ";
     p.printOperand(memref());
     p.printOptionalAttrDict(getAttrs(), {});
-    p << " : " << memref()->getType();
+    p << " : " << memref().getType();
   }];
 
   let extraClassDeclaration = [{
@@ -453,7 +453,7 @@ def fir_FreeMemOp : fir_Op<"freemem", []>,
     p << getOperationName() << ' ';
     p.printOperand(heapref());
     p.printOptionalAttrDict(getAttrs(), {});
-    p << " : " << getOperand()->getType();
+    p << " : " << getOperand().getType();
   }];
 }
 
@@ -531,7 +531,7 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
-    p << " : " << getSelector()->getType() << " [";
+    p << " : " << getSelector().getType() << " [";
     auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       if (i)
@@ -549,9 +549,9 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
   }];
 
   let verifier = [{
-    if (!(getSelector()->getType().isa<M::IntegerType>() ||
-          getSelector()->getType().isa<M::IndexType>() ||
-          getSelector()->getType().isa<fir::IntType>()))
+    if (!(getSelector().getType().isa<M::IntegerType>() ||
+          getSelector().getType().isa<M::IndexType>() ||
+          getSelector().getType().isa<fir::IntType>()))
       return emitOpError("must be an integer");
     auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
@@ -665,7 +665,7 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
-    p << " : " << getSelector()->getType() << " [";
+    p << " : " << getSelector().getType() << " [";
     auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       if (i)
@@ -686,11 +686,11 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
   }];
 
   let verifier = [{
-    if (!(getSelector()->getType().isa<M::IntegerType>() ||
-          getSelector()->getType().isa<M::IndexType>() ||
-          getSelector()->getType().isa<fir::IntType>() ||
-          getSelector()->getType().isa<fir::LogicalType>() ||
-          getSelector()->getType().isa<fir::CharacterType>()))
+    if (!(getSelector().getType().isa<M::IntegerType>() ||
+          getSelector().getType().isa<M::IndexType>() ||
+          getSelector().getType().isa<fir::IntType>() ||
+          getSelector().getType().isa<fir::LogicalType>() ||
+          getSelector().getType().isa<fir::CharacterType>()))
       return emitOpError("must be an integer, character, or logical");
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       // TODO: add checks!
@@ -757,7 +757,7 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
-    p << " : " << getSelector()->getType() << " [";
+    p << " : " << getSelector().getType() << " [";
     auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       if (i)
@@ -770,7 +770,7 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
   }];
 
   let verifier = [{
-    if (!(getSelector()->getType().isa<fir::BoxType>()))
+    if (!(getSelector().getType().isa<fir::BoxType>()))
       return emitOpError("must be a boxed type");
     auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
@@ -934,7 +934,7 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
   }];
 
   let verifier = [{
-    auto eleTy = elementTypeOf(memref()->getType());
+    auto eleTy = elementTypeOf(memref().getType());
     if (!eleTy.dyn_cast<CharacterType>())
       return M::failure();
     return M::success();
@@ -1006,7 +1006,7 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
     }
     p << " : (" << getAttr("functype");
     if (h)
-      p << ", " << h->getType();
+      p << ", " << h.getType();
     p << ") -> " << getType();
   }];
 
@@ -1251,11 +1251,11 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
   let verifier = [{
     // Recovering a LEN type parameter only makes sense from a boxed value
     for (auto co : coor())
-      if (auto *s = co->getDefiningOp())
+      if (auto *s = co.getDefiningOp())
         if (dyn_cast_or_null<LenParamIndexOp>(s)) {
           if (getNumOperands() != 2)
             return emitOpError("len_param_index must be last argument");
-          if (!ref()->getType().dyn_cast<BoxType>())
+          if (!ref().getType().dyn_cast<BoxType>())
             return emitOpError("len_param_index must be used on box type");
         }
     return M::success();
@@ -1357,7 +1357,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
       for (auto op : lenparams()) {
         p << sep;
         if (op)
-          p.printType(op->getType());
+          p.printType(op.getType());
         else
           p << "()";
         sep = ", ";
@@ -1517,8 +1517,8 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   let parser = [{ return parseLoopOp(parser, result); }];
 
   let printer = [{
-    p << getOperationName() << ' ' << *getInductionVar() << " = "
-      << *lowerBound() << " to " << *upperBound();
+    p << getOperationName() << ' ' << getInductionVar() << " = "
+      << lowerBound() << " to " << upperBound();
     auto s = optstep();
     if (s.begin() != s.end()) {
       p << " step ";
@@ -1534,7 +1534,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   let verifier = [{
     auto step = optstep();
     if (step.begin() != step.end()) {
-      auto *s = (*step.begin())->getDefiningOp();
+      auto *s = (*step.begin()).getDefiningOp();
       if (auto cst = dyn_cast_or_null<M::ConstantIndexOp>(s))
         if (cst.getValue() == 0)
           return emitOpError("constant step operand must be nonzero");
@@ -1544,7 +1544,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     // variable.
     auto *body = getBody();
     if (body->getNumArguments() != 1 ||
-        !body->getArgument(0)->getType().isIndex())
+        !body->getArgument(0).getType().isIndex())
       return emitOpError("expected body to have a single index argument for "
                          "the induction variable");
     return M::success();
@@ -1585,7 +1585,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
   let parser = [{ return parseWhereOp(parser, result); }];
 
   let printer = [{
-    p << getOperationName() << ' ' << *condition();
+    p << getOperationName() << ' ' << condition();
     p.printRegion(whereRegion(), /*printEntryBlockArgs=*/false,
         /*printBlockTerminators=*/false);
 
diff --git a/include/flang/lower/ComplexHandler.h b/include/flang/lower/ComplexHandler.h
index 172c1d77a2fd..bd27bd2666c0 100644
--- a/include/flang/lower/ComplexHandler.h
+++ b/include/flang/lower/ComplexHandler.h
@@ -43,7 +43,7 @@ class ComplexHandler {
   }
   mlir::Type getComplexPartType(mlir::Value cplx) {
     assert(cplx != nullptr);
-    return getComplexPartType(cplx->getType());
+    return getComplexPartType(cplx.getType());
   }
 
   template <Part partId>
@@ -54,7 +54,7 @@ class ComplexHandler {
   template <Part partId>
   mlir::Value insert(mlir::Value cplx, mlir::Value part) {
     assert(cplx != nullptr);
-    return builder.create<fir::InsertValueOp>(loc, cplx->getType(), cplx, part,
+    return builder.create<fir::InsertValueOp>(loc, cplx.getType(), cplx, part,
                                               getPartId<partId>());
   }
 
diff --git a/lib/fir/Dialect/FIROps.cpp b/lib/fir/Dialect/FIROps.cpp
index 8e7f70390a92..e3f23f65d06e 100644
--- a/lib/fir/Dialect/FIROps.cpp
+++ b/lib/fir/Dialect/FIROps.cpp
@@ -62,9 +62,9 @@ M::Type AllocMemOp::wrapResultType(M::Type intype) {
 
 /// Get the result types packed in a tuple tuple
 M::Type BoxDimsOp::getTupleType() {
-  L::SmallVector<M::Type, 3> triple{getResult(0)->getType(),
-                                    getResult(1)->getType(),
-                                    getResult(2)->getType()};
+  L::SmallVector<M::Type, 3> triple{getResult(0).getType(),
+                                    getResult(1).getType(),
+                                    getResult(2).getType()};
   return M::TupleType::get(triple, getContext());
 }
 
@@ -77,7 +77,7 @@ void printCallOp(M::OpAsmPrinter &p, fir::CallOp &op) {
   if (isDirect)
     p << callee.getValue();
   else
-    p << *op.getOperand(0);
+    p << op.getOperand(0);
   p << '(';
   p.printOperands(L::drop_begin(op.getOperands(), isDirect ? 0 : 1));
   p << ')';
@@ -201,7 +201,7 @@ void printCmpOp(OpAsmPrinter &p, OPTY op) {
   p.printOperand(op.rhs());
   p.printOptionalAttrDict(op.getAttrs(),
                           /*elidedAttrs=*/{OPTY::getPredicateAttrName()});
-  p << " : " << op.lhs()->getType();
+  p << " : " << op.lhs().getType();
 }
 
 void printCmpfOp(OpAsmPrinter &p, CmpfOp op) { printCmpOp(p, op); }
@@ -493,8 +493,8 @@ fir::LoopOp getForInductionVarOwner(M::Value val) {
   auto ivArg = val.dyn_cast<M::BlockArgument>();
   if (!ivArg)
     return fir::LoopOp();
-  assert(ivArg->getOwner() && "unlinked block argument");
-  auto *containingInst = ivArg->getOwner()->getParentOp();
+  assert(ivArg.getOwner() && "unlinked block argument");
+  auto *containingInst = ivArg.getOwner()->getParentOp();
   return dyn_cast_or_null<fir::LoopOp>(containingInst);
 }
 
@@ -592,9 +592,9 @@ void printBinaryOp(Operation *op, OpAsmPrinter &p) {
   assert(op->getNumOperands() == 2 && "binary op must have two operands");
   assert(op->getNumResults() == 1 && "binary op must have one result");
 
-  p << op->getName() << ' ' << *op->getOperand(0) << ", " << *op->getOperand(1);
+  p << op->getName() << ' ' << op->getOperand(0) << ", " << op->getOperand(1);
   p.printOptionalAttrDict(op->getAttrs());
-  p << " : " << op->getResult(0)->getType();
+  p << " : " << op->getResult(0).getType();
 }
 
 /// Generic pretty-printer of an unary operation
@@ -602,9 +602,9 @@ void printUnaryOp(Operation *op, OpAsmPrinter &p) {
   assert(op->getNumOperands() == 1 && "unary op must have one operand");
   assert(op->getNumResults() == 1 && "unary op must have one result");
 
-  p << op->getName() << ' ' << *op->getOperand(0);
+  p << op->getName() << ' ' << op->getOperand(0);
   p.printOptionalAttrDict(op->getAttrs());
-  p << " : " << op->getResult(0)->getType();
+  p << " : " << op->getResult(0).getType();
 }
 
 bool isReferenceLike(M::Type type) {
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 22da13ed8750..7cd2012acd31 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -1113,14 +1113,12 @@ class FirConverter : public AbstractConverter {
   // TODO: should these be moved to convert-expr?
   template <M::CmpIPredicate ICMPOPC>
   M::Value genCompare(M::Value lhs, M::Value rhs) {
-    auto lty{lhs->getType()};
-    assert(lty == rhs->getType());
-    if (lty.isIntOrIndex()) {
-      return builder->create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
-    }
-    if (fir::LogicalType::kindof(lty.getKind())) {
-      return builder->create<M::CmpIOp>(lhs->getLoc(), ICMPOPC, lhs, rhs);
-    }
+    auto lty{lhs.getType()};
+    assert(lty == rhs.getType());
+    if (lty.isIntOrIndex())
+      return builder->create<M::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
+    if (fir::LogicalType::kindof(lty.getKind()))
+      return builder->create<M::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
     if (fir::CharacterType::kindof(lty.getKind())) {
       // FIXME
       // return builder->create<M::CallOp>(lhs->getLoc(), );
@@ -1128,6 +1126,7 @@ class FirConverter : public AbstractConverter {
     M::emitError(toLocation(), "cannot generate operation on this type");
     return {};
   }
+
   M::Value genGE(M::Value lhs, M::Value rhs) {
     return genCompare<M::CmpIPredicate::sge>(lhs, rhs);
   }
@@ -1138,7 +1137,7 @@ class FirConverter : public AbstractConverter {
     return genCompare<M::CmpIPredicate::eq>(lhs, rhs);
   }
   M::Value genAND(M::Value lhs, M::Value rhs) {
-    return builder->create<M::AndOp>(lhs->getLoc(), lhs, rhs);
+    return builder->create<M::AndOp>(lhs.getLoc(), lhs, rhs);
   }
 
 private:
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 327753f6062b..fb420d171684 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -216,11 +216,11 @@ class ExprLowering {
 
   M::Value gen(Se::SymbolRef sym) {
     // FIXME: not all symbols are local
-    M::Value addr = createTemporary(getLoc(), builder, symMap,
-                                    converter.genType(sym), &*sym);
+    auto addr{createTemporary(getLoc(), builder, symMap, converter.genType(sym),
+                              &*sym)};
     assert(addr && "failed generating symbol address");
     // Get address from descriptor if symbol has one.
-    auto type{addr->getType()};
+    auto type{addr.getType()};
     if (auto boxCharType{type.dyn_cast<fir::BoxCharType>()}) {
       auto refType{fir::ReferenceType::get(boxCharType.getEleTy())};
       auto lenType{mlir::IntegerType::get(64, builder.getContext())};
@@ -231,11 +231,12 @@ class ExprLowering {
     }
     return addr;
   }
+
   M::Value gendef(Se::SymbolRef sym) { return gen(sym); }
 
   M::Value genval(Se::SymbolRef sym) {
     auto var = gen(sym);
-    if (fir::isReferenceLike(var->getType())) {
+    if (fir::isReferenceLike(var.getType())) {
       return builder.create<fir::LoadOp>(getLoc(), var);
     }
     return var;
@@ -250,7 +251,7 @@ class ExprLowering {
   M::Value genval(Ev::DescriptorInquiry const &desc) {
     auto descRef{symMap.lookupSymbol(desc.base().GetLastSymbol())};
     assert(descRef && "no mlir::Value associated to Symbol");
-    auto descType{descRef->getType()};
+    auto descType{descRef.getType()};
     M::Value res{};
     switch (desc.field()) {
     case Ev::DescriptorInquiry::Field::Len:
@@ -659,7 +660,7 @@ class ExprLowering {
     for (auto &subsc : aref.subscript()) {
       args.push_back(genval(subsc));
     }
-    auto ty{genSubType(base->getType(), args.size())};
+    auto ty{genSubType(base.getType(), args.size())};
     ty = fir::ReferenceType::get(ty);
     return builder.create<fir::CoordinateOp>(getLoc(), ty, base, args);
   }
@@ -745,7 +746,7 @@ class ExprLowering {
         if (const Se::Symbol * sym{Ev::UnwrapWholeSymbolDataRef(*expr)}) {
           M::Value argRef{symMap.lookupSymbol(*sym)};
           assert(argRef && "could not get symbol reference");
-          argTypes.push_back(argRef->getType());
+          argTypes.push_back(argRef.getType());
           operands.push_back(argRef);
         } else {
           // TODO create temps for expressions
@@ -784,11 +785,11 @@ class ExprLowering {
     auto result{std::visit([&](const auto &e) { return genval(e); }, exp.u)};
     // Handle the `i1` to `fir.logical` conversions as needed.
     if (result) {
-      M::Type type{result->getType()};
+      M::Type type{result.getType()};
       if (type.isa<fir::LogicalType>()) {
         if (genLogicalAsI1) {
-          M::Type i1Type{M::IntegerType::get(1, builder.getContext())};
-          result = builder.create<fir::ConvertOp>(getLoc(), i1Type, result);
+          result = builder.create<fir::ConvertOp>(getLoc(), builder.getI1Type(),
+                                                  result);
         }
       } else if (type.isa<M::IntegerType>()) {
         if (!genLogicalAsI1) {
@@ -867,9 +868,8 @@ M::Value Br::createTemporary(M::Location loc, M::OpBuilder &builder,
                              const Se::Symbol *symbol) {
   if (symbol)
     if (auto val = symMap.lookupSymbol(*symbol)) {
-      if (auto op = val->getDefiningOp()) {
+      if (auto op = val.getDefiningOp())
         return op->getResult(0);
-      }
       return val;
     }
   auto insPt(builder.saveInsertionPoint());
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 6c654fccb129..61008235ea1c 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -104,14 +104,11 @@ static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
 /// Lower print statement assuming a dummy runtime interface for now.
 void lowerPrintStatement(M::OpBuilder &builder, M::Location loc,
                          M::ValueRange args) {
-  M::ModuleOp module{getModule(&builder)};
-  M::MLIRContext *mlirContext{module.getContext()};
-
   M::FuncOp beginFunc{
       getIORuntimeFunction<IOAction::BeginExternalList>(builder)};
 
   // Initiate io
-  M::Type externalUnitType{M::IntegerType::get(32, mlirContext)};
+  M::Type externalUnitType{builder.getIntegerType(32)};
   M::Value defaultUnit{builder.create<M::ConstantOp>(
       loc, builder.getIntegerAttr(externalUnitType, 1))};
   llvm::SmallVector<M::Value, 1> beginArgs{defaultUnit};
@@ -121,7 +118,7 @@ void lowerPrintStatement(M::OpBuilder &builder, M::Location loc,
   // Call data transfer runtime function
   for (M::Value arg : args) {
     llvm::SmallVector<M::Value, 1> operands{cookie, arg};
-    M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg->getType())};
+    M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg.getType())};
     builder.create<M::CallOp>(loc, outputFunc, operands);
   }
 
diff --git a/lib/lower/Intrinsics.cpp b/lib/lower/Intrinsics.cpp
index 93587d2a5e00..b843af49e599 100644
--- a/lib/lower/Intrinsics.cpp
+++ b/lib/lower/Intrinsics.cpp
@@ -505,7 +505,7 @@ static M::FunctionType getFunctionType(M::Type resultType,
   L::SmallVector<M::Type, 2> argumentTypes;
   for (auto &arg : arguments) {
     assert(arg != nullptr); // TODO think about optionals
-    argumentTypes.push_back(arg->getType());
+    argumentTypes.push_back(arg.getType());
   }
   return M::FunctionType::get(argumentTypes, resultType,
                               getModule(&builder).getContext());
@@ -637,7 +637,7 @@ M::Value IntrinsicLibrary::Implementation::genConjg(Context &genCtxt,
                                                     MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 1);
   M::Type resType{genCtxt.getResultType()};
-  assert(resType == genCtxt.arguments[0]->getType());
+  assert(resType == genCtxt.arguments[0].getType());
   M::OpBuilder &builder{*genCtxt.builder};
   ComplexHandler cplxHandler{builder, genCtxt.loc};
 
@@ -672,7 +672,7 @@ static M::Value createExtremumCompare(M::Location loc, M::OpBuilder &builder,
   static constexpr auto orderedCmp{extremum == Extremum::Max
                                        ? fir::CmpFPredicate::OGT
                                        : fir::CmpFPredicate::OLT};
-  auto type{left->getType()};
+  auto type{left.getType()};
   M::Value result;
   if (type.isa<M::FloatType>() || type.isa<fir::RealType>()) {
     // Note: the signaling/quit aspect of the result required by IEEE
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index 8b8e780fc58f..8615656604cc 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -517,7 +517,7 @@ struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
     auto a = operands[0];
     auto loc = boxaddr.getLoc();
     auto ty = convertType(boxaddr.getType());
-    if (auto argty = boxaddr.val()->getType().dyn_cast<BoxType>()) {
+    if (auto argty = boxaddr.val().getType().dyn_cast<BoxType>()) {
       auto c0 = genConstantOffset(loc, rewriter, 0);
       auto pty = unwrap(ty).getPointerTo();
       auto p = genGEP(loc, unwrap(pty), rewriter, a, c0, c0);
@@ -574,7 +574,7 @@ struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
                                  M::LLVM::ConstantOp c0, M::LLVM::ConstantOp c7,
                                  M::Value dim, int off,
                                  M::ConversionPatternRewriter &rewriter) const {
-    auto ty = convertType(boxdims.getResult(off)->getType());
+    auto ty = convertType(boxdims.getResult(off).getType());
     auto pty = unwrap(ty).getPointerTo();
     auto c = genConstantOffset(loc, rewriter, off);
     auto p = genGEP(loc, pty, rewriter, a, c0, c7, dim, c);
@@ -756,7 +756,7 @@ struct CallOpConversion : public FIROpConversion<fir::CallOp> {
     auto call = M::cast<fir::CallOp>(op);
     L::SmallVector<M::Type, 4> resultTys;
     for (auto r : call.getResults())
-      resultTys.push_back(convertType(r->getType()));
+      resultTys.push_back(convertType(r.getType()));
     rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(call, resultTys, operands,
                                                  call.getAttrs());
     return matchSuccess();
@@ -776,7 +776,7 @@ struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
                   M::ConversionPatternRewriter &rewriter) const override {
     auto cmp = M::cast<fir::CmpcOp>(op);
     auto ctxt = cmp.getContext();
-    auto kind = cmp.lhs()->getType().cast<fir::CplxType>().getFKind();
+    auto kind = cmp.lhs().getType().cast<fir::CplxType>().getFKind();
     auto ty = convertType(fir::RealType::get(ctxt, kind));
     auto loc = cmp.getLoc();
     auto pos0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
@@ -827,9 +827,9 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
   matchAndRewrite(M::Operation *op, OperandTy operands,
                   M::ConversionPatternRewriter &rewriter) const override {
     auto convert = M::cast<ConvertOp>(op);
-    auto fromTy_ = convertType(convert.value()->getType());
+    auto fromTy_ = convertType(convert.value().getType());
     auto fromTy = unwrap(fromTy_);
-    auto toTy_ = convertType(convert.res()->getType());
+    auto toTy_ = convertType(convert.res().getType());
     auto toTy = unwrap(toTy_);
     auto *fromLLVMTy = fromTy.getUnderlyingType();
     auto *toLLVMTy = toTy.getUnderlyingType();
@@ -960,7 +960,7 @@ struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
     auto ty = unwrap(convertType(embox.getType()));
     auto alloca = genAllocaWithType(loc, ty, 24, defaultAlign, rewriter);
     auto c0 = genConstantOffset(loc, rewriter, 0);
-    auto rty = unwrap(operands[0]->getType()).getPointerTo();
+    auto rty = unwrap(operands[0].getType()).getPointerTo();
     auto f0p = genGEP(loc, rty, rewriter, alloca, c0, c0);
     auto f0p_ = rewriter.create<M::LLVM::BitcastOp>(loc, rty, f0p);
     rewriter.create<M::LLVM::StoreOp>(loc, operands[0], f0p_);
@@ -1041,7 +1041,7 @@ struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
 /// return true if all `Value`s in `operands` are `ConstantOp`s
 bool allConstants(OperandTy operands) {
   for (auto opnd : operands) {
-    if (auto defop = opnd->getDefiningOp())
+    if (auto defop = opnd.getDefiningOp())
       if (dyn_cast<M::LLVM::ConstantOp>(defop) ||
           dyn_cast<M::ConstantOp>(defop))
         continue;
@@ -1051,10 +1051,10 @@ bool allConstants(OperandTy operands) {
 }
 
 M::Attribute getValue(M::Value value) {
-  assert(value->getDefiningOp());
-  if (auto v = dyn_cast<M::LLVM::ConstantOp>(value->getDefiningOp()))
+  assert(value.getDefiningOp());
+  if (auto v = dyn_cast<M::LLVM::ConstantOp>(value.getDefiningOp()))
     return v.value();
-  if (auto v = dyn_cast<M::ConstantOp>(value->getDefiningOp()))
+  if (auto v = dyn_cast<M::ConstantOp>(value.getDefiningOp()))
     return v.value();
   assert(false && "must be a constant op");
   return {};
@@ -1111,7 +1111,7 @@ struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
 /// return true if all `Value`s in `operands` are not `FieldIndexOp`s
 bool noFieldIndexOps(M::Operation::operand_range operands) {
   for (auto opnd : operands) {
-    if (auto defop = opnd->getDefiningOp())
+    if (auto defop = opnd.getDefiningOp())
       if (dyn_cast<FieldIndexOp>(defop))
         return false;
   }
@@ -1132,10 +1132,10 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     auto c0 = genConstantIndex(loc, lowering.indexType(), rewriter, 0);
 
     // The base can be a boxed reference or a raw reference
-    if (auto boxTy = coor.ref()->getType().dyn_cast<BoxType>()) {
+    if (auto boxTy = coor.ref().getType().dyn_cast<BoxType>()) {
       if (coor.getNumOperands() == 2) {
         auto coorPtr = *coor.coor().begin();
-        auto *s = coorPtr->getDefiningOp();
+        auto s = coorPtr.getDefiningOp();
         if (dyn_cast_or_null<LenParamIndexOp>(s)) {
           auto &lenParam = operands[1]; // byte offset
           auto bc = rewriter.create<M::LLVM::BitcastOp>(loc, voidPtrTy(), base);
@@ -1162,7 +1162,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     }
 
     // lower the field index ops by walking the indices
-    auto bty = coor.ref()->getType().cast<BoxType>();
+    auto bty = coor.ref().getType().cast<BoxType>();
     M::Type baseTy = ReferenceType::get(bty.getEleTy());
     L::SmallVector<M::Value, 8> args{c0};
     args.append(coor.coor().begin(), coor.coor().end());
@@ -1172,7 +1172,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     unsigned pos = 0;
     for (unsigned i = 0, sz = offs.size(); i != sz; ++i) {
       assert(pos <= i);
-      if (auto *defop = args[i]->getDefiningOp())
+      if (auto defop = args[i].getDefiningOp())
         if (auto field = dyn_cast<FieldIndexOp>(defop)) {
           auto memTy = unwrap(convertType(baseTy)).getPointerTo();
           M::Value gep = retval;
@@ -1218,7 +1218,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
 
   int64_t getIntValue(M::Value val) const {
     if (val)
-      if (auto *defop = val->getDefiningOp())
+      if (auto defop = val.getDefiningOp())
         if (auto constOp = dyn_cast<M::ConstantIntOp>(defop))
           return constOp.getValue();
     assert(false && "must be a constant");
@@ -1459,7 +1459,7 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
     auto caseAttr = selectcase.getAttrOfType<M::ArrayAttr>(attrName);
     auto cases = caseAttr.getValue();
     // Type can be CHARACTER, INTEGER, or LOGICAL (C1145)
-    auto ty = selectcase.getSelector()->getType();
+    auto ty = selectcase.getSelector().getType();
     (void)ty;
     auto &selector = operands[0];
     unsigned nextOp = 1;
@@ -1530,7 +1530,7 @@ void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, M::Operation *op,
   auto attrName = OP::AttrName;
   auto caseAttr = select.template getAttrOfType<M::ArrayAttr>(attrName);
   auto cases = caseAttr.getValue();
-  auto ty = select.getSelector()->getType();
+  auto ty = select.getSelector().getType();
   auto ity = lowering.convertType(ty);
   auto &selector = operands[0];
   auto loc = select.getLoc();
@@ -1632,8 +1632,8 @@ struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
     auto unboxchar = M::cast<UnboxCharOp>(op);
     auto *ctx = unboxchar.getContext();
     auto loc = unboxchar.getLoc();
-    auto &tuple = operands[0];
-    auto ty = unwrap(tuple->getType());
+    auto tuple = operands[0];
+    auto ty = unwrap(tuple.getType());
     M::Value ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
     M::Value len = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
     std::vector<M::Value> repls = {ptr, len};
@@ -1665,8 +1665,8 @@ struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
                   M::ConversionPatternRewriter &rewriter) const override {
     auto unbox = M::cast<UnboxOp>(op);
     auto loc = unbox.getLoc();
-    auto &tuple = operands[0];
-    auto ty = unwrap(tuple->getType());
+    auto tuple = operands[0];
+    auto ty = unwrap(tuple.getType());
     auto oty = lowering.offsetType();
     auto c0 = rewriter.create<M::LLVM::ConstantOp>(
         loc, oty, rewriter.getI32IntegerAttr(0));
@@ -1695,8 +1695,8 @@ struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
     auto unboxproc = M::cast<UnboxProcOp>(op);
     auto *ctx = unboxproc.getContext();
     auto loc = unboxproc.getLoc();
-    auto &tuple = operands[0];
-    auto ty = unwrap(tuple->getType());
+    auto tuple = operands[0];
+    auto ty = unwrap(tuple.getType());
     M::Value ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
     M::Value host = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
     std::vector<M::Value> repls = {ptr, host};
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
index ba2264cd59a2..a7b17714a834 100644
--- a/lib/optimizer/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -38,12 +38,12 @@ namespace {
 
 template <typename LOAD, typename STORE, typename ALLOCA>
 bool isAllocaPromotable(ALLOCA &ae) {
-  for (auto &use : ae.getResult()->getUses()) {
+  for (auto &use : ae.getResult().getUses()) {
     auto *op = use.getOwner();
     if (auto load = M::dyn_cast<LOAD>(op)) {
       // do nothing
     } else if (auto stor = M::dyn_cast<STORE>(op)) {
-      if (stor.getOperand(0)->getDefiningOp() == op) {
+      if (stor.getOperand(0).getDefiningOp() == op) {
         return false;
       }
     } else {
@@ -78,7 +78,7 @@ struct AllocaInfo {
     // As we scan the uses of the alloca instruction, keep track of stores,
     // and decide whether all of the loads and stores to the alloca are within
     // the same basic block.
-    for (auto UI = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+    for (auto UI = AI.getResult().use_begin(), E = AI.getResult().use_end();
          UI != E;) {
       auto *User = UI->getOwner();
       UI++;
@@ -127,10 +127,10 @@ struct LargeBlockInfo {
 
   static bool isInterestingInstruction(M::Operation &I) {
     if (M::isa<LOAD>(I)) {
-      if (auto *op = I.getOperand(0)->getDefiningOp())
+      if (auto op = I.getOperand(0).getDefiningOp())
         return M::isa<ALLOCA>(op);
     } else if (M::isa<STORE>(I)) {
-      if (auto *op = I.getOperand(1)->getDefiningOp())
+      if (auto op = I.getOperand(1).getDefiningOp())
         return M::isa<ALLOCA>(op);
     }
     return false;
@@ -197,7 +197,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     // Clear out usingBlocks.  We will reconstruct it here if needed.
     Info.usingBlocks.clear();
 
-    for (auto UI = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+    for (auto UI = AI.getResult().use_begin(), E = AI.getResult().use_end();
          UI != E;) {
       auto *UserInst = UI->getOwner();
       UI++;
@@ -262,7 +262,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         L::SmallVector<std::pair<unsigned, M::Operation *>, 64>;
     StoresByIndexTy storesByIndex;
 
-    for (auto U = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+    for (auto U = AI.getResult().use_begin(), E = AI.getResult().use_end();
          U != E; U++)
       if (STORE SI = M::dyn_cast<STORE>(U->getOwner()))
         storesByIndex.emplace_back(LBI.getInstructionIndex(SI),
@@ -274,7 +274,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
     // Walk all of the loads from this alloca, replacing them with the nearest
     // store above them, if any.
-    for (auto UI = AI.getResult()->use_begin(), E = AI.getResult()->use_end();
+    for (auto UI = AI.getResult().use_begin(), E = AI.getResult().use_end();
          UI != E;) {
       auto LI = M::dyn_cast<LOAD>(UI->getOwner());
       UI++;
@@ -319,7 +319,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     // Remove the (now dead) stores and alloca.
     while (!AI.use_empty()) {
       auto ae = AI.getResult();
-      for (auto ai = ae->user_begin(), E = ae->user_end(); ai != E; ai++)
+      for (auto ai = ae.user_begin(), E = ae.user_end(); ai != E; ai++)
         if (STORE si = M::dyn_cast<STORE>(*ai)) {
           si.erase();
           LBI.deleteValue(si);
@@ -353,7 +353,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       // live-in.
       for (M::Block::iterator I = BB->begin();; ++I) {
         if (STORE SI = M::dyn_cast<STORE>(I)) {
-          if (SI.getOperand(1)->getDefiningOp() != AI)
+          if (SI.getOperand(1).getDefiningOp() != AI)
             continue;
 
           // We found a store to the alloca before a load.  The alloca is not
@@ -368,7 +368,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         if (auto LI = M::dyn_cast<LOAD>(I))
           // Okay, we found a load before a store to the alloca.  It is actually
           // live into this block.
-          if (LI.getOperand()->getDefiningOp() == AI)
+          if (LI.getOperand().getDefiningOp() == AI)
             break;
       }
     }
@@ -422,7 +422,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     for (; i < size; ++i) {
       if (i == ai)
         continue;
-      auto opTy = dest->getArgument(i)->getType();
+      auto opTy = dest->getArgument(i).getType();
       auto typedUndef = builder->create<UNDEF>(loc, opTy);
       opers[i] = typedUndef;
     }
@@ -430,8 +430,8 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
   }
 
   static void eraseIfNoUse(M::Value val) {
-    if (val->use_begin() == val->use_end()) {
-      val->getDefiningOp()->erase();
+    if (val.use_begin() == val.use_end()) {
+      val.getDefiningOp()->erase();
     }
   }
 
@@ -541,7 +541,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       II++;
 
       if (auto LI = M::dyn_cast<LOAD>(opn)) {
-        auto *srcOpn = LI.getOperand()->getDefiningOp();
+        auto *srcOpn = LI.getOperand().getDefiningOp();
         if (!srcOpn)
           continue;
 
@@ -557,7 +557,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         LI.replaceAllUsesWith(IncomingVals[ai->second]);
         LI.erase();
       } else if (auto SI = M::dyn_cast<STORE>(opn)) {
-        auto *dstOpn = SI.getOperand(1)->getDefiningOp();
+        auto *dstOpn = SI.getOperand(1).getDefiningOp();
         if (!dstOpn)
           continue;
 

From e5a60f2e84b3521795389115fc66b3da6b139b13 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Mon, 13 Jan 2020 03:35:16 -0800
Subject: [PATCH 171/345] Refactor character assignment lowering Facilitate
 OpBuilder manipulations by introducing the OpBuilderWrapper class that
 automatically add the location and help removing the boilerplate to create
 intreger constants. Create a LoopCreator class that inherits this class and
 helps generating simple (one nesting level) loops. Create a
 ChararacterOpsCreator that also inherits OpBuilderWrapper and provides
 character copy/padding implementation.

---
 include/flang/lower/OpBuilder.h |  70 +++++++++++++++++++++
 lib/lower/Bridge.cpp            |  90 ++++++---------------------
 lib/lower/OpBuilder.cpp         | 106 ++++++++++++++++++++++++++++++++
 3 files changed, 196 insertions(+), 70 deletions(-)

diff --git a/include/flang/lower/OpBuilder.h b/include/flang/lower/OpBuilder.h
index 8efc89343e1b..b597accf0cb1 100644
--- a/include/flang/lower/OpBuilder.h
+++ b/include/flang/lower/OpBuilder.h
@@ -20,6 +20,11 @@ namespace llvm {
 class StringRef;
 }
 
+namespace fir {
+class CharacterType;
+class ReferenceType;
+} // namespace fir
+
 namespace Fortran {
 namespace parser {
 class CookedSource;
@@ -55,6 +60,71 @@ class SymMap {
   }
 };
 
+/// Helper class that can be inherited from in order to
+/// facilitate mlir::OpBuilder usage.
+class OpBuilderHandler {
+public:
+  OpBuilderHandler(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
+  template <typename T, typename... Args>
+  auto create(Args... args) {
+    return builder.create<T>(loc, std::forward<Args>(args)...);
+  }
+  mlir::Value getIntegerConstant(mlir::Type integerType, std::int64_t);
+
+protected:
+  mlir::OpBuilder &builder;
+  mlir::Location loc;
+};
+
+/// Facilitate lowering to fir::loop
+class LoopCreator : public OpBuilderHandler {
+public:
+  LoopCreator(mlir::OpBuilder &b, mlir::Location l) : OpBuilderHandler{b, l} {}
+  LoopCreator(OpBuilderHandler &b) : OpBuilderHandler{b} {}
+  // In genLoop functions, lb, ub, and count arguments must have integer types.
+  // They will be automatically converted the IndexType if needed.
+  // Build loop [lb, ub) with step "step".
+  using BodyGenerator = std::function<void(OpBuilderHandler &, mlir::Value)>;
+  void genLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
+               const BodyGenerator &bodyGenerator);
+  /// Build loop [lb, ub) with step 1.
+  void genLoop(mlir::Value lb, mlir::Value ub,
+               const BodyGenerator &bodyGenerator);
+  /// Build loop [0, count) with step 1.
+  void genLoop(mlir::Value count, const BodyGenerator &bodyGenerator);
+
+private:
+  mlir::Type getIndexType();
+  mlir::Value convertToIndexType(mlir::Value integer);
+};
+
+/// Facilitate lowering of CHARACTER operation
+class CharacterOpsCreator : public OpBuilderHandler {
+public:
+  CharacterOpsCreator(mlir::OpBuilder &b, mlir::Location l)
+      : OpBuilderHandler{b, l} {}
+  CharacterOpsCreator(OpBuilderHandler &b) : OpBuilderHandler{b} {}
+  /// Interchange format to avoid inserting unbox/embox everywhere while
+  /// evaluating character expressions.
+  struct CharValue {
+    fir::ReferenceType getReferenceType();
+    fir::CharacterType getCharacterType();
+
+    mlir::Value reference;
+    mlir::Value len;
+  };
+
+  /// Copy count first characters of src into dest.
+  void genCopy(CharValue &dest, CharValue &src, mlir::Value count);
+  /// Pad str(from:to) with blanks. If to <= from, no padding is done.
+  void genPadding(CharValue &str, mlir::Value from, mlir::Value to);
+  /// allocate (on the stack) storage for character given the kind and length.
+  CharValue createTemp(fir::CharacterType type, mlir::Value len);
+
+private:
+  mlir::Value getBlankConstant(fir::CharacterType type);
+};
+
 /// Get the current Module
 inline mlir::ModuleOp getModule(mlir::OpBuilder *bldr) {
   return bldr->getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 7cd2012acd31..7490c02ddca4 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -661,83 +661,33 @@ class FirConverter : public AbstractConverter {
     // Helper to get address and length from an Expr that is a character
     // variable designator
     auto getAddrAndLength{[&](const SomeExpr &charDesignatorExpr)
-                              -> std::pair<mlir::Value, mlir::Value> {
+                              -> CharacterOpsCreator::CharValue {
       M::Value addr = genExprAddr(charDesignatorExpr);
       const auto &charExpr{
           std::get<Ev::Expr<Ev::SomeCharacter>>(charDesignatorExpr.u)};
       std::optional<Ev::Expr<Ev::SubscriptInteger>> lenExpr{charExpr.LEN()};
       assert(lenExpr && "could not get expression to compute character length");
-      M::Value len = genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)));
-      return {addr, len};
+      M::Value len{genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)))};
+      return CharacterOpsCreator::CharValue{addr, len};
     }};
 
-    auto lhsAddrAndLen{getAddrAndLength(assignment.lhs)};
-    // FIXME:  In general an address cannot be obtained for rhs because it does
-    // not have to be a variable. rhs either needs to be materialized (but this
-    // just push the problem into assigning into a temp), or each element of the
-    // character rhs must be computed and directly assigned in the related lhs
-    // element.
-    auto rhsAddrAndLen{getAddrAndLength(assignment.rhs)};
-
-    // Generate the copy.
-    // FIXME: Currently assumes no overlap (else a temp should be used).
-
-    // Get character sequence reference type for fir::CoordinateOp.
-    assert(lhsAddrAndLen.first && "could not get character variable address");
-    auto charRefType{lhsAddrAndLen.first.getType()};
-    auto charSequenceRefType{getSequenceRefType(charRefType)};
-    auto lhsArrayView{builder->create<fir::ConvertOp>(
-        toLocation(), charSequenceRefType, lhsAddrAndLen.first)};
-    auto rhsArrayView{builder->create<fir::ConvertOp>(
-        toLocation(), charSequenceRefType, rhsAddrAndLen.first)};
-
-    // Build loop to copy rhs
-    auto indexTy{M::IndexType::get(builder->getContext())};
-    auto zero{builder->create<M::ConstantOp>(
-        toLocation(), indexTy, builder->getIntegerAttr(indexTy, 0))};
-    auto one{builder->create<M::ConstantOp>(
-        toLocation(), indexTy, builder->getIntegerAttr(indexTy, 1))};
-    L::SmallVector<M::Value, 1> step;
-    step.emplace_back(one);
-    // Copy the minimum of the lhs and rhs lengths
-    auto cmpLen{builder->create<M::CmpIOp>(toLocation(), M::CmpIPredicate::slt,
-                                           lhsAddrAndLen.second,
-                                           rhsAddrAndLen.second)};
-    auto copyLen{builder->create<M::SelectOp>(
-        toLocation(), cmpLen, lhsAddrAndLen.second, rhsAddrAndLen.second)};
-    auto copyMaxIndex{
-        builder->create<fir::ConvertOp>(toLocation(), indexTy, copyLen)};
-    auto copyLoop{
-        builder->create<fir::LoopOp>(toLocation(), zero, copyMaxIndex, step)};
-    auto *insPt{builder->getInsertionBlock()};
-    builder->setInsertionPointToStart(copyLoop.getBody());
-    auto index{copyLoop.getInductionVar()};
-    auto lhsElementAddr{builder->create<fir::CoordinateOp>(
-        toLocation(), charRefType, lhsArrayView, index)};
-    auto rhsElementAddr{builder->create<fir::CoordinateOp>(
-        toLocation(), charRefType, rhsArrayView, index)};
-    auto elementVal{builder->create<fir::LoadOp>(toLocation(), rhsElementAddr)};
-    builder->create<fir::StoreOp>(toLocation(), elementVal, lhsElementAddr);
-    builder->setInsertionPointToEnd(insPt);
-
-    // Build loop to pad lhs with blanks if needed.
-    auto padMaxIndex{builder->create<fir::ConvertOp>(toLocation(), indexTy,
-                                                     lhsAddrAndLen.second)};
-    auto byteTy{M::IntegerType::get(8, builder->getContext())};
-    auto asciiSpace{builder->create<M::ConstantOp>(
-        toLocation(), byteTy, builder->getIntegerAttr(byteTy, 32))};
-    auto charType{charRefType.dyn_cast<fir::ReferenceType>().getEleTy()};
-    auto blank{
-        builder->create<fir::ConvertOp>(toLocation(), charType, asciiSpace)};
-    auto padLoop{builder->create<fir::LoopOp>(toLocation(), copyMaxIndex,
-                                              padMaxIndex, step)};
-    insPt = builder->getInsertionBlock();
-    builder->setInsertionPointToStart(padLoop.getBody());
-    auto padIndex{padLoop.getInductionVar()};
-    auto lhsElementAddrPad{builder->create<fir::CoordinateOp>(
-        toLocation(), charRefType, lhsArrayView, padIndex)};
-    builder->create<fir::StoreOp>(toLocation(), blank, lhsElementAddrPad);
-    builder->setInsertionPointToEnd(insPt);
+    CharacterOpsCreator creator{*builder, toLocation()};
+
+    // RHS evaluation.
+    // FIXME:  Only works with rhs that are variable reference.
+    // Other expression evaluation are not simple copies.
+    auto rhs{getAddrAndLength(assignment.rhs)};
+    // A temp is needed to evaluate rhs until proven it does not depend on lhs.
+    auto tempToEvalRhs{creator.createTemp(rhs.getCharacterType(), rhs.len)};
+    creator.genCopy(tempToEvalRhs, rhs, rhs.len);
+
+    // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
+    auto lhs{getAddrAndLength(assignment.lhs)};
+    auto cmpLen{
+        creator.create<M::CmpIOp>(M::CmpIPredicate::slt, lhs.len, rhs.len)};
+    auto copyCount{creator.create<M::SelectOp>(cmpLen, lhs.len, rhs.len)};
+    creator.genCopy(lhs, tempToEvalRhs, copyCount);
+    creator.genPadding(lhs, copyCount, lhs.len);
   }
 
   void genFIR(const Pa::AssignmentStmt &stmt) {
diff --git a/lib/lower/OpBuilder.cpp b/lib/lower/OpBuilder.cpp
index d6ad7efe7bc4..4ea3902004e1 100644
--- a/lib/lower/OpBuilder.cpp
+++ b/lib/lower/OpBuilder.cpp
@@ -8,6 +8,7 @@
 
 #include "flang/lower/OpBuilder.h"
 #include "fir/Dialect/FIROpsSupport.h"
+#include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/ConvertType.h"
 #include "mlir/IR/Module.h"
@@ -16,6 +17,7 @@
 
 namespace B = Fortran::lower;
 namespace Ev = Fortran::evaluate;
+namespace L = llvm;
 namespace M = mlir;
 namespace Se = Fortran::semantics;
 
@@ -64,3 +66,107 @@ void B::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
   assert(r.second && "unexpected insertion failure");
   (void)r;
 }
+
+M::Value B::OpBuilderHandler::getIntegerConstant(M::Type integerType,
+                                                 std::int64_t cst) {
+  return create<M::ConstantOp>(integerType,
+                               builder.getIntegerAttr(integerType, cst));
+}
+void B::LoopCreator::genLoop(M::Value lb, M::Value ub, M::Value step,
+                             const BodyGenerator &bodyGenerator) {
+  auto lbi{convertToIndexType(lb)};
+  auto ubi{convertToIndexType(ub)};
+  auto stepi{convertToIndexType(step)};
+  L::SmallVector<M::Value, 1> steps;
+  steps.emplace_back(stepi);
+  auto loop{create<fir::LoopOp>(lbi, ubi, steps)};
+  auto *insPt{builder.getInsertionBlock()};
+  builder.setInsertionPointToStart(loop.getBody());
+  auto index{loop.getInductionVar()};
+  bodyGenerator(*this, index);
+  builder.setInsertionPointToEnd(insPt);
+}
+
+void B::LoopCreator::genLoop(M::Value lb, M::Value ub,
+                             const BodyGenerator &bodyGenerator) {
+  auto one{getIntegerConstant(getIndexType(), 1)};
+  genLoop(lb, ub, one, bodyGenerator);
+}
+
+void B::LoopCreator::genLoop(M::Value count,
+                             const BodyGenerator &bodyGenerator) {
+  auto indexType{getIndexType()};
+  auto zero{getIntegerConstant(indexType, 0)};
+  auto one{getIntegerConstant(indexType, 1)};
+  genLoop(zero, count, one, bodyGenerator);
+}
+
+M::Type B::LoopCreator::getIndexType() {
+  return M::IndexType::get(builder.getContext());
+}
+
+M::Value B::LoopCreator::convertToIndexType(M::Value integer) {
+  auto type{integer.getType()};
+  if (type.isa<M::IndexType>()) {
+    return integer;
+  }
+  assert((type.isa<M::IntegerType>() || type.isa<fir::IntType>()) &&
+         "expected integer");
+  return create<fir::ConvertOp>(getIndexType(), integer);
+}
+
+void B::CharacterOpsCreator::genCopy(CharValue &dest, CharValue &src,
+                                     M::Value count) {
+  auto refType{dest.getReferenceType()};
+  // Cast to character sequence reference type for fir::CoordinateOp.
+  auto sequenceType{getSequenceRefType(refType)};
+  auto destRef{create<fir::ConvertOp>(sequenceType, dest.reference)};
+  auto srcRef{create<fir::ConvertOp>(sequenceType, src.reference)};
+
+  LoopCreator{*this}.genLoop(count, [&](OpBuilderHandler &handler,
+                                        M::Value index) {
+    auto destAddr{handler.create<fir::CoordinateOp>(refType, destRef, index)};
+    auto srcAddr{handler.create<fir::CoordinateOp>(refType, srcRef, index)};
+    auto val{handler.create<fir::LoadOp>(srcAddr)};
+    handler.create<fir::StoreOp>(val, destAddr);
+  });
+}
+
+void B::CharacterOpsCreator::genPadding(CharValue &str, M::Value from,
+                                        M::Value to) {
+  auto refType{str.getReferenceType()};
+  auto sequenceType{getSequenceRefType(refType)};
+  auto strRef{create<fir::ConvertOp>(sequenceType, str.reference)};
+  auto blank{getBlankConstant(str.getCharacterType())};
+
+  LoopCreator{*this}.genLoop(
+      from, to, [&](OpBuilderHandler &handler, M::Value index) {
+        auto strAddr{handler.create<fir::CoordinateOp>(refType, strRef, index)};
+        handler.create<fir::StoreOp>(blank, strAddr);
+      });
+}
+
+M::Value B::CharacterOpsCreator::getBlankConstant(fir::CharacterType type) {
+  auto byteTy{M::IntegerType::get(8, builder.getContext())};
+  auto asciiSpace{getIntegerConstant(byteTy, 0x20)};
+  return create<fir::ConvertOp>(type, asciiSpace);
+}
+
+B::CharacterOpsCreator::CharValue
+B::CharacterOpsCreator::createTemp(fir::CharacterType type, M::Value len) {
+  // FIXME Does this need to be emitted somewhere safe ?
+  // convert-expr.cc generates alloca at the beginning of the mlir block.
+  return CharValue{create<fir::AllocaOp>(type, len), len};
+}
+
+fir::ReferenceType B::CharacterOpsCreator::CharValue::getReferenceType() {
+  auto type{reference.getType().dyn_cast<fir::ReferenceType>()};
+  assert(type && "expected reference type");
+  return type;
+}
+
+fir::CharacterType B::CharacterOpsCreator::CharValue::getCharacterType() {
+  auto type{getReferenceType().getEleTy().dyn_cast<fir::CharacterType>()};
+  assert(type && "expected character type");
+  return type;
+}

From 79c0442783bffc420e9cb4b949a28d0d923c2d0c Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 16 Jan 2020 04:00:03 -0800
Subject: [PATCH 172/345] Move ComplexHandler to OpBuilder.h and refactor it a
 bit Its interface remains unchanged, but it now inherits the recently added
 OpBuilderHandler class to make some op creation easier. Also remove the
 implementation from the header into OpBuilder.cpp so that the include file is
 cleaner. ComplexHandler.h is deleted.

Use LoopBuilder helper to lower do loops.
Also rename some classes and functions accodring to review comments
here: https://github.com/schweitzpgi/f18/pull/38
`xxCreator` -> `xxBuilder`
---
 include/flang/lower/ComplexHandler.h | 105 -------------------
 include/flang/lower/OpBuilder.h      | 103 ++++++++++++++-----
 lib/lower/Bridge.cpp                 | 108 ++++++++++----------
 lib/lower/ConvertExpr.cpp            |   7 +-
 lib/lower/Intrinsics.cpp             |   7 +-
 lib/lower/OpBuilder.cpp              | 147 +++++++++++++++++++++------
 6 files changed, 250 insertions(+), 227 deletions(-)
 delete mode 100644 include/flang/lower/ComplexHandler.h

diff --git a/include/flang/lower/ComplexHandler.h b/include/flang/lower/ComplexHandler.h
deleted file mode 100644
index bd27bd2666c0..000000000000
--- a/include/flang/lower/ComplexHandler.h
+++ /dev/null
@@ -1,105 +0,0 @@
-//===-- lib/lower/complex-handler.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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef FORTRAN_LOWER_COMPLEX_HANDLER_H_
-#define FORTRAN_LOWER_COMPLEX_HANDLER_H_
-
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
-
-#include "ConvertType.h"
-#include "fir/Dialect/FIROps.h"
-#include "fir/Dialect/FIRType.h"
-
-namespace Fortran::lower {
-/// Provide helpers to generate Complex manipulations in FIR.
-
-class ComplexHandler {
-public:
-  // The values of part enum members are meaningful for
-  // InsertValueOp and ExtractValueOp so they are explicit.
-  enum class Part { Real = 0, Imag = 1 };
-
-  ComplexHandler(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
-
-  mlir::Type getComplexPartType(fir::KindTy complexKind) {
-    return convertReal(builder.getContext(), complexKind);
-  }
-
-  mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
-                            mlir::Value imag) {
-    mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
-    mlir::Value und = builder.create<fir::UndefOp>(loc, complexTy);
-    return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
-  }
-
-  // Complex part manipulation helpers
-  mlir::Type getComplexPartType(mlir::Type complexType) {
-    return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
-  }
-  mlir::Type getComplexPartType(mlir::Value cplx) {
-    assert(cplx != nullptr);
-    return getComplexPartType(cplx.getType());
-  }
-
-  template <Part partId>
-  mlir::Value extract(mlir::Value cplx) {
-    return builder.create<fir::ExtractValueOp>(loc, getComplexPartType(cplx),
-                                               cplx, getPartId<partId>());
-  }
-  template <Part partId>
-  mlir::Value insert(mlir::Value cplx, mlir::Value part) {
-    assert(cplx != nullptr);
-    return builder.create<fir::InsertValueOp>(loc, cplx.getType(), cplx, part,
-                                              getPartId<partId>());
-  }
-
-  /// Complex part access helper dynamic versions
-  mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart) {
-    return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
-  }
-  mlir::Value insertComplexPart(mlir::Value cplx, mlir::Value part,
-                                bool isImagPart) {
-    return isImagPart ? insert<Part::Imag>(cplx, part)
-                      : insert<Part::Real>(cplx, part);
-  }
-
-  // Complex operation helpers
-  mlir::Value createComplexCompare(mlir::Value cplx1, mlir::Value cplx2,
-                                   bool eq) {
-    mlir::Value real1 = extract<Part::Real>(cplx1);
-    mlir::Value real2 = extract<Part::Real>(cplx2);
-    mlir::Value imag1 = extract<Part::Imag>(cplx1);
-    mlir::Value imag2 = extract<Part::Imag>(cplx2);
-
-    mlir::CmpFPredicate predicate =
-        eq ? mlir::CmpFPredicate::UEQ : mlir::CmpFPredicate::UNE;
-    mlir::Value realCmp =
-        builder.create<mlir::CmpFOp>(loc, predicate, real1, real2).getResult();
-    mlir::Value imagCmp =
-        builder.create<mlir::CmpFOp>(loc, predicate, imag1, imag2).getResult();
-
-    if (eq)
-      return builder.create<mlir::AndOp>(loc, realCmp, imagCmp).getResult();
-    return builder.create<mlir::OrOp>(loc, realCmp, imagCmp).getResult();
-  }
-
-private:
-  // Make mlir ConstantOp from template part id.
-  template <Part partId>
-  inline mlir::Value getPartId() {
-    auto type = mlir::IntegerType::get(32, builder.getContext());
-    auto attr = builder.getIntegerAttr(type, static_cast<int>(partId));
-    return builder.create<mlir::ConstantOp>(loc, type, attr).getResult();
-  }
-
-  mlir::OpBuilder &builder;
-  mlir::Location loc;
-};
-
-} // namespace Fortran::lower
-#endif // FORTRAN_LOWER_COMPLEX_HANDLER_H_
diff --git a/include/flang/lower/OpBuilder.h b/include/flang/lower/OpBuilder.h
index b597accf0cb1..462b31a1fbd9 100644
--- a/include/flang/lower/OpBuilder.h
+++ b/include/flang/lower/OpBuilder.h
@@ -23,6 +23,7 @@ class StringRef;
 namespace fir {
 class CharacterType;
 class ReferenceType;
+using KindTy = int;
 } // namespace fir
 
 namespace Fortran {
@@ -62,14 +63,16 @@ class SymMap {
 
 /// Helper class that can be inherited from in order to
 /// facilitate mlir::OpBuilder usage.
-class OpBuilderHandler {
+class OpBuilderWrapper {
 public:
-  OpBuilderHandler(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
+  OpBuilderWrapper(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
+  /// Insert the location and forwards create call to the builder member.
   template <typename T, typename... Args>
   auto create(Args... args) {
     return builder.create<T>(loc, std::forward<Args>(args)...);
   }
-  mlir::Value getIntegerConstant(mlir::Type integerType, std::int64_t);
+  /// Create an integer constant of type \p type and value \p i.
+  mlir::Value createIntegerConstant(mlir::Type integerType, std::int64_t i);
 
 protected:
   mlir::OpBuilder &builder;
@@ -77,21 +80,27 @@ class OpBuilderHandler {
 };
 
 /// Facilitate lowering to fir::loop
-class LoopCreator : public OpBuilderHandler {
+class LoopBuilder : public OpBuilderWrapper {
 public:
-  LoopCreator(mlir::OpBuilder &b, mlir::Location l) : OpBuilderHandler{b, l} {}
-  LoopCreator(OpBuilderHandler &b) : OpBuilderHandler{b} {}
-  // In genLoop functions, lb, ub, and count arguments must have integer types.
-  // They will be automatically converted the IndexType if needed.
-  // Build loop [lb, ub) with step "step".
-  using BodyGenerator = std::function<void(OpBuilderHandler &, mlir::Value)>;
-  void genLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
-               const BodyGenerator &bodyGenerator);
-  /// Build loop [lb, ub) with step 1.
-  void genLoop(mlir::Value lb, mlir::Value ub,
-               const BodyGenerator &bodyGenerator);
-  /// Build loop [0, count) with step 1.
-  void genLoop(mlir::Value count, const BodyGenerator &bodyGenerator);
+  LoopBuilder(mlir::OpBuilder &b, mlir::Location l) : OpBuilderWrapper{b, l} {}
+  LoopBuilder(OpBuilderWrapper &b) : OpBuilderWrapper{b} {}
+
+  // In createLoop functions, lb, ub, and count arguments must have integer
+  // types. They will be automatically converted the IndexType if needed.
+
+  using BodyGenerator = std::function<void(OpBuilderWrapper &, mlir::Value)>;
+
+  /// Build loop [\p lb, \p ub) with step \p step.
+  /// If \p is an empty value, 1 is used for the step.
+  void createLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
+                  const BodyGenerator &bodyGenerator);
+
+  /// Build loop [\p lb,  \p ub) with step 1.
+  void createLoop(mlir::Value lb, mlir::Value ub,
+                  const BodyGenerator &bodyGenerator);
+
+  /// Build loop [0, \p count) with step 1.
+  void createLoop(mlir::Value count, const BodyGenerator &bodyGenerator);
 
 private:
   mlir::Type getIndexType();
@@ -99,11 +108,11 @@ class LoopCreator : public OpBuilderHandler {
 };
 
 /// Facilitate lowering of CHARACTER operation
-class CharacterOpsCreator : public OpBuilderHandler {
+class CharacterOpsBuilder : public OpBuilderWrapper {
 public:
-  CharacterOpsCreator(mlir::OpBuilder &b, mlir::Location l)
-      : OpBuilderHandler{b, l} {}
-  CharacterOpsCreator(OpBuilderHandler &b) : OpBuilderHandler{b} {}
+  CharacterOpsBuilder(mlir::OpBuilder &b, mlir::Location l)
+      : OpBuilderWrapper{b, l} {}
+  CharacterOpsBuilder(OpBuilderWrapper &b) : OpBuilderWrapper{b} {}
   /// Interchange format to avoid inserting unbox/embox everywhere while
   /// evaluating character expressions.
   struct CharValue {
@@ -114,15 +123,55 @@ class CharacterOpsCreator : public OpBuilderHandler {
     mlir::Value len;
   };
 
-  /// Copy count first characters of src into dest.
-  void genCopy(CharValue &dest, CharValue &src, mlir::Value count);
-  /// Pad str(from:to) with blanks. If to <= from, no padding is done.
-  void genPadding(CharValue &str, mlir::Value from, mlir::Value to);
-  /// allocate (on the stack) storage for character given the kind and length.
+  /// Copy the \p count first characters of \p src into \p dest.
+  void createCopy(CharValue &dest, CharValue &src, mlir::Value count);
+
+  /// Set characters of \p str at position [\p lower, \p upper) to blanks.
+  /// \p lower and \upper bounds are zero based.
+  /// If \p upper <= \p lower, no padding is done.
+  void createPadding(CharValue &str, mlir::Value lower, mlir::Value upper);
+
+  /// Allocate storage (on the stack) for character given the kind and length.
   CharValue createTemp(fir::CharacterType type, mlir::Value len);
 
 private:
-  mlir::Value getBlankConstant(fir::CharacterType type);
+  mlir::Value createBlankConstant(fir::CharacterType type);
+};
+
+/// Provide helper to generate Complex manipulations in FIR.
+class ComplexOpsBuilder : public OpBuilderWrapper {
+public:
+  // The values of part enum members are meaningful for
+  // InsertValueOp and ExtractValueOp so they are explicit.
+  enum class Part { Real = 0, Imag = 1 };
+
+  ComplexOpsBuilder(mlir::OpBuilder &b, mlir::Location l)
+      : OpBuilderWrapper{b, l} {}
+  ComplexOpsBuilder(OpBuilderWrapper &bw) : OpBuilderWrapper{bw} {}
+
+  // Type helper. They do not create MLIR operations.
+  mlir::Type getComplexPartType(mlir::Value cplx);
+  mlir::Type getComplexPartType(mlir::Type complexType);
+  mlir::Type getComplexPartType(fir::KindTy complexKind);
+
+  // Complex operation creation helper. They create MLIR operations.
+  mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
+                            mlir::Value imag);
+  mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart);
+  mlir::Value insertComplexPart(mlir::Value cplx, mlir::Value part,
+                                bool isImagPart);
+
+  template <Part partId>
+  mlir::Value extract(mlir::Value cplx);
+  template <Part partId>
+  mlir::Value insert(mlir::Value cplx, mlir::Value part);
+
+  mlir::Value createComplexCompare(mlir::Value cplx1, mlir::Value cplx2,
+                                   bool eq);
+
+private:
+  template <Part partId>
+  mlir::Value createPartId();
 };
 
 /// Get the current Module
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 7490c02ddca4..8f618d36a539 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -368,52 +368,50 @@ class FirConverter : public AbstractConverter {
     assert(eval.subs && "eval must have a body");
     auto *insPt = builder->getInsertionBlock();
 
-    if (std::holds_alternative<const Pa::DoConstruct *>(eval.u)) {
-      // Construct fir.loop
-      fir::LoopOp doLoop;
-      for (auto &e : *eval.subs) {
-        if (auto **s = std::get_if<const Pa::NonLabelDoStmt *>(&e.u)) {
-          // do bounds, fir.loop op
-          std::visit(
-              Co::visitors{
-                  [&](const Pa::LoopControl::Bounds &x) {
-                    // create the fir.loop op
-                    M::Value lo = genFIRLoopIndex(x.lower);
-                    M::Value hi = genFIRLoopIndex(x.upper);
-                    L::SmallVector<M::Value, 1> step;
-                    if (x.step.has_value()) {
-                      step.emplace_back(genExprValue(*Se::GetExpr(*x.step)));
-                    }
-                    doLoop = builder->create<fir::LoopOp>(toLocation(), lo, hi,
-                                                          step);
-                    builder->setInsertionPointToStart(doLoop.getBody());
-                    auto *sym{x.name.thing.symbol};
-                    auto ty{genType(*sym)};
-                    // TODO: should push this cast down to the uses
-                    auto cvt{builder->create<fir::ConvertOp>(
-                        toLocation(), ty, doLoop.getInductionVar())};
-                    localSymbols.pushShadowSymbol(*sym, cvt);
-                  },
-                  [&](const Pa::ScalarLogicalExpr &) {
-                    // we should never reach here
-                    M::emitError(toLocation(), "loop lacks iteration space");
-                  },
-                  [&](const Pa::LoopControl::Concurrent &x) {
-                    // FIXME: can project a multi-dimensional space
-                    doLoop = builder->create<fir::LoopOp>(
-                        toLocation(), M::Value{}, M::Value{},
-                        L::ArrayRef<M::Value>{});
-                    builder->setInsertionPointToStart(doLoop.getBody());
-                  },
-              },
-              std::get<std::optional<Pa::LoopControl>>((*s)->t)->u);
-        } else if (std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
-          // close fir.loop op
-          builder->clearInsertionPoint();
-          localSymbols.popShadowSymbol();
-        } else {
-          genFIR(e);
-        }
+    if (const auto **doConstruct{
+            std::get_if<const Pa::DoConstruct *>(&eval.u)}) {
+      if (const auto &loopControl{(*doConstruct)->GetLoopControl()}) {
+        std::visit(Co::visitors{
+                       [&](const Pa::LoopControl::Bounds &x) {
+                         M::Value lo{genFIRLoopIndex(x.lower)};
+                         M::Value hi{genFIRLoopIndex(x.upper)};
+                         auto step{x.step.has_value()
+                                       ? genExprValue(*Se::GetExpr(*x.step))
+                                       : M::Value{}};
+                         auto *sym{x.name.thing.symbol};
+                         LoopBuilder{*builder, toLocation()}.createLoop(
+                             lo, hi, step,
+                             [&](OpBuilderWrapper &handler, M::Value index) {
+                               // TODO: should push this cast down to the uses
+                               auto cvt{handler.create<fir::ConvertOp>(
+                                   genType(*sym), index)};
+                               localSymbols.pushShadowSymbol(*sym, cvt);
+                               for (auto &e : *eval.subs) {
+                                 genFIR(e);
+                               }
+                               localSymbols.popShadowSymbol();
+                             });
+                       },
+                       [&](const Pa::ScalarLogicalExpr &) {
+                         // we should never reach here
+                         M::emitError(toLocation(),
+                                      "loop lacks iteration space");
+                       },
+                       [&](const Pa::LoopControl::Concurrent &x) {
+                         // FIXME: can project a multi-dimensional space
+                         LoopBuilder{*builder, toLocation()}.createLoop(
+                             M::Value{}, M::Value{},
+                             [&](OpBuilderWrapper &, M::Value) {
+                               for (auto &e : *eval.subs) {
+                                 genFIR(e);
+                               }
+                             });
+                       },
+                   },
+                   loopControl->u);
+      } else {
+        // TODO: Infinite loop: 11.1.7.4.1 par 2
+        TODO();
       }
     } else if (std::holds_alternative<const Pa::IfConstruct *>(eval.u)) {
       // Construct fir.where
@@ -661,33 +659,33 @@ class FirConverter : public AbstractConverter {
     // Helper to get address and length from an Expr that is a character
     // variable designator
     auto getAddrAndLength{[&](const SomeExpr &charDesignatorExpr)
-                              -> CharacterOpsCreator::CharValue {
+                              -> CharacterOpsBuilder::CharValue {
       M::Value addr = genExprAddr(charDesignatorExpr);
       const auto &charExpr{
           std::get<Ev::Expr<Ev::SomeCharacter>>(charDesignatorExpr.u)};
       std::optional<Ev::Expr<Ev::SubscriptInteger>> lenExpr{charExpr.LEN()};
       assert(lenExpr && "could not get expression to compute character length");
       M::Value len{genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)))};
-      return CharacterOpsCreator::CharValue{addr, len};
+      return CharacterOpsBuilder::CharValue{addr, len};
     }};
 
-    CharacterOpsCreator creator{*builder, toLocation()};
+    CharacterOpsBuilder charBuilder{*builder, toLocation()};
 
     // RHS evaluation.
     // FIXME:  Only works with rhs that are variable reference.
     // Other expression evaluation are not simple copies.
     auto rhs{getAddrAndLength(assignment.rhs)};
     // A temp is needed to evaluate rhs until proven it does not depend on lhs.
-    auto tempToEvalRhs{creator.createTemp(rhs.getCharacterType(), rhs.len)};
-    creator.genCopy(tempToEvalRhs, rhs, rhs.len);
+    auto tempToEvalRhs{charBuilder.createTemp(rhs.getCharacterType(), rhs.len)};
+    charBuilder.createCopy(tempToEvalRhs, rhs, rhs.len);
 
     // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
     auto lhs{getAddrAndLength(assignment.lhs)};
     auto cmpLen{
-        creator.create<M::CmpIOp>(M::CmpIPredicate::slt, lhs.len, rhs.len)};
-    auto copyCount{creator.create<M::SelectOp>(cmpLen, lhs.len, rhs.len)};
-    creator.genCopy(lhs, tempToEvalRhs, copyCount);
-    creator.genPadding(lhs, copyCount, lhs.len);
+        charBuilder.create<M::CmpIOp>(M::CmpIPredicate::slt, lhs.len, rhs.len)};
+    auto copyCount{charBuilder.create<M::SelectOp>(cmpLen, lhs.len, rhs.len)};
+    charBuilder.createCopy(lhs, tempToEvalRhs, copyCount);
+    charBuilder.createPadding(lhs, copyCount, lhs.len);
   }
 
   void genFIR(const Pa::AssignmentStmt &stmt) {
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index fb420d171684..bfadf209f923 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -18,7 +18,6 @@
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
-#include "flang/lower/ComplexHandler.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
@@ -280,7 +279,7 @@ class ExprLowering {
 
   template <int KIND>
   M::Value genval(Ev::ComplexComponent<KIND> const &part) {
-    return ComplexHandler{builder, getLoc()}.extractComplexPart(
+    return ComplexOpsBuilder{builder, getLoc()}.extractComplexPart(
         genval(part.left()), part.isImaginaryPart);
   }
 
@@ -362,7 +361,7 @@ class ExprLowering {
 
   template <int KIND>
   M::Value genval(Ev::ComplexConstructor<KIND> const &op) {
-    return ComplexHandler{builder, getLoc()}.createComplex(
+    return ComplexOpsBuilder{builder, getLoc()}.createComplex(
         KIND, genval(op.left()), genval(op.right()));
   }
   template <int KIND>
@@ -396,7 +395,7 @@ class ExprLowering {
       bool eq{op.opr == Co::RelationalOperator::EQ};
       assert(eq || op.opr == Co::RelationalOperator::NE &&
                        "relation undefined for complex");
-      result = ComplexHandler{builder, getLoc()}.createComplexCompare(
+      result = ComplexOpsBuilder{builder, getLoc()}.createComplexCompare(
           genval(op.left()), genval(op.right()), eq);
     } else {
       static_assert(TC == CharacterCat);
diff --git a/lib/lower/Intrinsics.cpp b/lib/lower/Intrinsics.cpp
index b843af49e599..97bab12d85aa 100644
--- a/lib/lower/Intrinsics.cpp
+++ b/lib/lower/Intrinsics.cpp
@@ -9,7 +9,6 @@
 #include "flang/lower/Intrinsics.h"
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
-#include "flang/lower/ComplexHandler.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
@@ -639,12 +638,12 @@ M::Value IntrinsicLibrary::Implementation::genConjg(Context &genCtxt,
   M::Type resType{genCtxt.getResultType()};
   assert(resType == genCtxt.arguments[0].getType());
   M::OpBuilder &builder{*genCtxt.builder};
-  ComplexHandler cplxHandler{builder, genCtxt.loc};
+  ComplexOpsBuilder cplxHandler{builder, genCtxt.loc};
 
   M::Value cplx = genCtxt.arguments[0];
-  M::Value imag = cplxHandler.extract<ComplexHandler::Part::Imag>(cplx);
+  M::Value imag = cplxHandler.extract<ComplexOpsBuilder::Part::Imag>(cplx);
   M::Value negImag = genCtxt.builder->create<fir::NegfOp>(genCtxt.loc, imag);
-  return cplxHandler.insert<ComplexHandler::Part::Imag>(cplx, negImag);
+  return cplxHandler.insert<ComplexOpsBuilder::Part::Imag>(cplx, negImag);
 }
 
 // MERGE
diff --git a/lib/lower/OpBuilder.cpp b/lib/lower/OpBuilder.cpp
index 4ea3902004e1..aae19f0ac951 100644
--- a/lib/lower/OpBuilder.cpp
+++ b/lib/lower/OpBuilder.cpp
@@ -67,18 +67,23 @@ void B::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
   (void)r;
 }
 
-M::Value B::OpBuilderHandler::getIntegerConstant(M::Type integerType,
-                                                 std::int64_t cst) {
+M::Value B::OpBuilderWrapper::createIntegerConstant(M::Type integerType,
+                                                    std::int64_t cst) {
   return create<M::ConstantOp>(integerType,
                                builder.getIntegerAttr(integerType, cst));
 }
-void B::LoopCreator::genLoop(M::Value lb, M::Value ub, M::Value step,
-                             const BodyGenerator &bodyGenerator) {
+
+// LoopBuilder implementation
+
+void B::LoopBuilder::createLoop(M::Value lb, M::Value ub, M::Value step,
+                                const BodyGenerator &bodyGenerator) {
   auto lbi{convertToIndexType(lb)};
   auto ubi{convertToIndexType(ub)};
-  auto stepi{convertToIndexType(step)};
   L::SmallVector<M::Value, 1> steps;
-  steps.emplace_back(stepi);
+  if (step) {
+    auto stepi{convertToIndexType(step)};
+    steps.emplace_back(stepi);
+  }
   auto loop{create<fir::LoopOp>(lbi, ubi, steps)};
   auto *insPt{builder.getInsertionBlock()};
   builder.setInsertionPointToStart(loop.getBody());
@@ -87,25 +92,25 @@ void B::LoopCreator::genLoop(M::Value lb, M::Value ub, M::Value step,
   builder.setInsertionPointToEnd(insPt);
 }
 
-void B::LoopCreator::genLoop(M::Value lb, M::Value ub,
-                             const BodyGenerator &bodyGenerator) {
-  auto one{getIntegerConstant(getIndexType(), 1)};
-  genLoop(lb, ub, one, bodyGenerator);
+void B::LoopBuilder::createLoop(M::Value lb, M::Value ub,
+                                const BodyGenerator &bodyGenerator) {
+  auto one{createIntegerConstant(getIndexType(), 1)};
+  createLoop(lb, ub, one, bodyGenerator);
 }
 
-void B::LoopCreator::genLoop(M::Value count,
-                             const BodyGenerator &bodyGenerator) {
+void B::LoopBuilder::createLoop(M::Value count,
+                                const BodyGenerator &bodyGenerator) {
   auto indexType{getIndexType()};
-  auto zero{getIntegerConstant(indexType, 0)};
-  auto one{getIntegerConstant(indexType, 1)};
-  genLoop(zero, count, one, bodyGenerator);
+  auto zero{createIntegerConstant(indexType, 0)};
+  auto one{createIntegerConstant(indexType, 1)};
+  createLoop(zero, count, one, bodyGenerator);
 }
 
-M::Type B::LoopCreator::getIndexType() {
+M::Type B::LoopBuilder::getIndexType() {
   return M::IndexType::get(builder.getContext());
 }
 
-M::Value B::LoopCreator::convertToIndexType(M::Value integer) {
+M::Value B::LoopBuilder::convertToIndexType(M::Value integer) {
   auto type{integer.getType()};
   if (type.isa<M::IndexType>()) {
     return integer;
@@ -115,16 +120,18 @@ M::Value B::LoopCreator::convertToIndexType(M::Value integer) {
   return create<fir::ConvertOp>(getIndexType(), integer);
 }
 
-void B::CharacterOpsCreator::genCopy(CharValue &dest, CharValue &src,
-                                     M::Value count) {
+// CharacterOpsBuilder implementation
+
+void B::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
+                                        M::Value count) {
   auto refType{dest.getReferenceType()};
   // Cast to character sequence reference type for fir::CoordinateOp.
   auto sequenceType{getSequenceRefType(refType)};
   auto destRef{create<fir::ConvertOp>(sequenceType, dest.reference)};
   auto srcRef{create<fir::ConvertOp>(sequenceType, src.reference)};
 
-  LoopCreator{*this}.genLoop(count, [&](OpBuilderHandler &handler,
-                                        M::Value index) {
+  LoopBuilder{*this}.createLoop(count, [&](OpBuilderWrapper &handler,
+                                           M::Value index) {
     auto destAddr{handler.create<fir::CoordinateOp>(refType, destRef, index)};
     auto srcAddr{handler.create<fir::CoordinateOp>(refType, srcRef, index)};
     auto val{handler.create<fir::LoadOp>(srcAddr)};
@@ -132,41 +139,117 @@ void B::CharacterOpsCreator::genCopy(CharValue &dest, CharValue &src,
   });
 }
 
-void B::CharacterOpsCreator::genPadding(CharValue &str, M::Value from,
-                                        M::Value to) {
+void B::CharacterOpsBuilder::createPadding(CharValue &str, M::Value lower,
+                                           M::Value upper) {
   auto refType{str.getReferenceType()};
   auto sequenceType{getSequenceRefType(refType)};
   auto strRef{create<fir::ConvertOp>(sequenceType, str.reference)};
-  auto blank{getBlankConstant(str.getCharacterType())};
+  auto blank{createBlankConstant(str.getCharacterType())};
 
-  LoopCreator{*this}.genLoop(
-      from, to, [&](OpBuilderHandler &handler, M::Value index) {
+  LoopBuilder{*this}.createLoop(
+      lower, upper, [&](OpBuilderWrapper &handler, M::Value index) {
         auto strAddr{handler.create<fir::CoordinateOp>(refType, strRef, index)};
         handler.create<fir::StoreOp>(blank, strAddr);
       });
 }
 
-M::Value B::CharacterOpsCreator::getBlankConstant(fir::CharacterType type) {
+M::Value B::CharacterOpsBuilder::createBlankConstant(fir::CharacterType type) {
   auto byteTy{M::IntegerType::get(8, builder.getContext())};
-  auto asciiSpace{getIntegerConstant(byteTy, 0x20)};
+  auto asciiSpace{createIntegerConstant(byteTy, 0x20)};
   return create<fir::ConvertOp>(type, asciiSpace);
 }
 
-B::CharacterOpsCreator::CharValue
-B::CharacterOpsCreator::createTemp(fir::CharacterType type, M::Value len) {
+B::CharacterOpsBuilder::CharValue
+B::CharacterOpsBuilder::createTemp(fir::CharacterType type, M::Value len) {
   // FIXME Does this need to be emitted somewhere safe ?
   // convert-expr.cc generates alloca at the beginning of the mlir block.
   return CharValue{create<fir::AllocaOp>(type, len), len};
 }
 
-fir::ReferenceType B::CharacterOpsCreator::CharValue::getReferenceType() {
+fir::ReferenceType B::CharacterOpsBuilder::CharValue::getReferenceType() {
   auto type{reference.getType().dyn_cast<fir::ReferenceType>()};
   assert(type && "expected reference type");
   return type;
 }
 
-fir::CharacterType B::CharacterOpsCreator::CharValue::getCharacterType() {
+fir::CharacterType B::CharacterOpsBuilder::CharValue::getCharacterType() {
   auto type{getReferenceType().getEleTy().dyn_cast<fir::CharacterType>()};
   assert(type && "expected character type");
   return type;
 }
+
+// ComplexOpsBuilder implementation
+
+mlir::Type B::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
+  return convertReal(builder.getContext(), complexKind);
+}
+mlir::Type B::ComplexOpsBuilder::getComplexPartType(mlir::Type complexType) {
+  return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
+}
+mlir::Type B::ComplexOpsBuilder::getComplexPartType(mlir::Value cplx) {
+  assert(cplx != nullptr);
+  return getComplexPartType(cplx->getType());
+}
+
+mlir::Value B::ComplexOpsBuilder::createComplex(fir::KindTy kind,
+                                                mlir::Value real,
+                                                mlir::Value imag) {
+  mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
+  mlir::Value und{create<fir::UndefOp>(complexTy)};
+  return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
+}
+
+using CplxPart = B::ComplexOpsBuilder::Part;
+template <CplxPart partId>
+mlir::Value B::ComplexOpsBuilder::createPartId() {
+  auto type{mlir::IntegerType::get(32, builder.getContext())};
+  return createIntegerConstant(type, static_cast<int>(partId));
+}
+
+template <CplxPart partId>
+mlir::Value B::ComplexOpsBuilder::extract(mlir::Value cplx) {
+  return create<fir::ExtractValueOp>(getComplexPartType(cplx), cplx,
+                                     createPartId<partId>());
+}
+template mlir::Value B::ComplexOpsBuilder::extract<CplxPart::Real>(mlir::Value);
+template mlir::Value B::ComplexOpsBuilder::extract<CplxPart::Imag>(mlir::Value);
+
+template <CplxPart partId>
+mlir::Value B::ComplexOpsBuilder::insert(mlir::Value cplx, mlir::Value part) {
+  assert(cplx != nullptr);
+  return create<fir::InsertValueOp>(cplx->getType(), cplx, part,
+                                    createPartId<partId>());
+}
+template mlir::Value B::ComplexOpsBuilder::insert<CplxPart::Real>(mlir::Value,
+                                                                  mlir::Value);
+template mlir::Value B::ComplexOpsBuilder::insert<CplxPart::Imag>(mlir::Value,
+                                                                  mlir::Value);
+
+mlir::Value B::ComplexOpsBuilder::extractComplexPart(mlir::Value cplx,
+                                                     bool isImagPart) {
+  return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
+}
+
+mlir::Value B::ComplexOpsBuilder::insertComplexPart(mlir::Value cplx,
+                                                    mlir::Value part,
+                                                    bool isImagPart) {
+  return isImagPart ? insert<Part::Imag>(cplx, part)
+                    : insert<Part::Real>(cplx, part);
+}
+
+mlir::Value B::ComplexOpsBuilder::createComplexCompare(mlir::Value cplx1,
+                                                       mlir::Value cplx2,
+                                                       bool eq) {
+  mlir::Value real1{extract<Part::Real>(cplx1)};
+  mlir::Value real2{extract<Part::Real>(cplx2)};
+  mlir::Value imag1{extract<Part::Imag>(cplx1)};
+  mlir::Value imag2{extract<Part::Imag>(cplx2)};
+
+  mlir::CmpFPredicate predicate{eq ? mlir::CmpFPredicate::UEQ
+                                   : mlir::CmpFPredicate::UNE};
+  mlir::Value realCmp{create<mlir::CmpFOp>(predicate, real1, real2)};
+  mlir::Value imagCmp{create<mlir::CmpFOp>(predicate, imag1, imag2)};
+
+  return eq ? create<mlir::AndOp>(realCmp, imagCmp).getResult()
+            : create<mlir::OrOp>(realCmp, imagCmp).getResult();
+}

From 976f2524b0be1eb8773f51d418efeddb9ee94ea1 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 17 Jan 2020 06:01:15 -0800
Subject: [PATCH 173/345] Add character expression test framework and tests for
 assignment Because character constant cannot yet be expressed in FIR, more
 scaffolding is needed to tests expression with characters for now. This
 commit adds a samll framework to produce character variable from a C++
 program and pass them to f18 compile subroutines taking character arguments.
 The framework is used to test various scenarios of character assignment for
 the different character kinds.

---
 test/lower/character-assignment.f90     |  69 +++++
 test/lower/expr-test-generator.cc       |   2 +-
 test/lower/test-character-assignment.cc | 357 ++++++++++++++++++++++++
 test/lower/test_character_assignment.sh |  45 +++
 4 files changed, 472 insertions(+), 1 deletion(-)
 create mode 100644 test/lower/character-assignment.f90
 create mode 100644 test/lower/test-character-assignment.cc
 create mode 100755 test/lower/test_character_assignment.sh

diff --git a/test/lower/character-assignment.f90 b/test/lower/character-assignment.f90
new file mode 100644
index 000000000000..65550902e8d5
--- /dev/null
+++ b/test/lower/character-assignment.f90
@@ -0,0 +1,69 @@
+! Simple character assignment tests
+subroutine assign1(s1, s2)
+  character(*, 1) :: s1, s2
+  s1 = s2
+end subroutine
+subroutine assign2(s1, s2)
+  character(*, 2) :: s1, s2
+  s1 = s2
+end subroutine
+subroutine assign4(s1, s2)
+  character(*, 4) :: s1, s2
+  s1 = s2
+end subroutine
+
+! Test substring assignment
+subroutine assign_substring1(s1, s2, lb, ub)
+  character(*, 1) :: s1, s2
+  integer :: lb, ub
+  s1(lb:ub) = s2
+end subroutine
+subroutine assign_substring2(s1, s2, lb, ub)
+  character(*, 2) :: s1, s2
+  integer :: lb, ub
+  s1(lb:ub) = s2
+end subroutine
+subroutine assign_substring4(s1, s2, lb, ub)
+  character(*, 4) :: s1, s2
+  integer :: lb, ub
+  s1(lb:ub) = s2
+end subroutine
+
+! Test overlapping assignments
+! RHS depends on LHS in a way that if no temp is made to evaluate
+! RHS, these tests should fail.
+subroutine assign_overlap1(s1, s2, lb)
+  character(*, 1) :: s1, s2
+  integer :: lb
+  s1(lb:) = s1
+end subroutine
+subroutine assign_overlap2(s1, s2, lb)
+  character(*, 2) :: s1, s2
+  integer :: lb
+  s1(lb:) = s1
+end subroutine
+subroutine assign_overlap4(s1, s2, lb)
+  character(*, 4) :: s1, s2
+  integer :: lb
+  s1(lb:) = s1
+end subroutine
+
+! Test when length is given in specification expressions
+subroutine assign_spec_expr_len1(s1, s2, l1, l2)
+  integer :: l1, l2
+  character(l1, 1) :: s1
+  character(l2, 1) :: s2
+  s1 = s2
+end subroutine
+subroutine assign_spec_expr_len2(s1, s2, l1, l2)
+  integer :: l1, l2
+  character(l1, 2) :: s1
+  character(l2, 2) :: s2
+  s1 = s2
+end subroutine
+subroutine assign_spec_expr_len4(s1, s2, l1, l2)
+  integer :: l1, l2
+  character(l1, 4) :: s1
+  character(l2, 4) :: s2
+  s1 = s2
+end subroutine
diff --git a/test/lower/expr-test-generator.cc b/test/lower/expr-test-generator.cc
index 7acded6c273d..a4f3a741bfb6 100644
--- a/test/lower/expr-test-generator.cc
+++ b/test/lower/expr-test-generator.cc
@@ -1,4 +1,4 @@
-//===-- test/burnside/expr-test-generator.cc ------------------------------===//
+//===-- test/lower/expr-test-generator.cc -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/test/lower/test-character-assignment.cc b/test/lower/test-character-assignment.cc
new file mode 100644
index 000000000000..ef7da61f3f30
--- /dev/null
+++ b/test/lower/test-character-assignment.cc
@@ -0,0 +1,357 @@
+//===-- test/lower/test-character-assignment.cc -----------------*- 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 <cassert>
+#include <codecvt>
+#include <iomanip>
+#include <iostream>
+#include <locale>
+#include <string>
+#include <type_traits>
+
+// Driver to tests Fortran subroutine from character-assignment.f90
+
+// So far lowering of fir::boxchar dummy to llvm does not layout character
+// arguments like other compiler do for F77. Templates provides a patch for
+// that.
+
+using LenT = std::int64_t;
+struct Fchar {
+  char *data;
+  LenT len;
+};
+
+template<typename... T> using SubF18 = void (*)(Fchar, Fchar, T...);
+template<typename... T>
+using SubF77 = void (*)(char *, char *, T..., LenT, LenT);
+template<typename... T>
+void CallSubroutine(SubF18<T...> f, Fchar s1, Fchar s2, T... args) {
+  f(s1, s2, args...);
+}
+
+template<typename... T>
+void CallSubroutine(SubF77<T...> f, Fchar s1, Fchar s2, T... args) {
+  f(s1.data, s2.data, args..., s1.len, s2.len);
+}
+
+// Define structures to create and manipulate Fortran Character
+// A canary is always added at the end of character storage so that
+// invalid overwrites can be detected.
+template<int K> struct CharStorage {};
+template<> struct CharStorage<1> {
+  using Type = std::string;
+  static const Type canary;
+};
+const CharStorage<1>::Type CharStorage<1>::canary{"_CaNaRy"};
+
+template<> struct CharStorage<2> {
+  using Type = std::u16string;
+  static const Type canary;
+};
+const CharStorage<2>::Type CharStorage<2>::canary{u"_CaNaRy"};
+
+template<> struct CharStorage<4> {
+  using Type = std::u32string;
+  static const Type canary;
+};
+const CharStorage<4>::Type CharStorage<4>::canary{U"_CaNaRy"};
+
+template<int Kind> struct FcharData {
+  using String = typename CharStorage<Kind>::Type;
+  using CharT = typename String::value_type;
+  FcharData(String str)
+    : data{str + CharStorage<Kind>::canary}, len{static_cast<LenT>(
+                                                 str.length())} {}
+  Fchar getFchar() {
+    const char *addr{reinterpret_cast<const char *>(data.data())};
+    return Fchar{const_cast<char *>(addr), len};
+  }
+
+  // UTF-8 dump
+  std::ostream &dump(std::ostream &os) const {
+    if constexpr (std::is_same_v<CharT, char>) {
+      os << data;
+    } else {
+      std::wstring_convert<std::codecvt_utf8<CharT>, CharT> cvt;
+      os << cvt.to_bytes(data);
+    }
+    return os;
+  }
+  // Hex dump
+  std::ostream &dumpHex(std::ostream &os) const {
+    os << std::hex;
+    for (auto c : data) {
+      if constexpr (std::is_same_v<CharT, char>) {
+        os << " 0x" << std::setw(2) << std::setfill('0')
+           << (int)((unsigned char)c);
+      } else {
+        os << " 0x" << std::setw(sizeof(CharT) * 2) << std::setfill('0') << c;
+      }
+    }
+    os << std::dec;
+    return os;
+  }
+
+  String data;
+  LenT len;  // may differ from string length for test purposes
+};
+
+template<int Kind>
+bool Check(const FcharData<Kind> &test, const FcharData<Kind> &ref,
+    const std::string &desc) {
+  if (test.data != ref.data) {
+    std::cout << "Failed: " << desc << std::endl;
+    ref.dump(std::cout << "  expected: '") << "'" << std::endl;
+    test.dump(std::cout << "  got     : '") << "'" << std::endl;
+    return false;
+  }
+  return true;
+}
+
+// Call compiled test subroutine and compare variable afterwards with a
+// reference. Compare against result from reference subroutine.
+template<int Kind, typename... T>
+bool TestSubroutine(const std::string &testName, SubF18<T...> fooTest,
+    SubF18<T...> fooRef, const FcharData<Kind> &s1, const FcharData<Kind> &s2,
+    T... otherArgs) {
+  // Make copies because data may be modified
+  FcharData<Kind> testS1{s1}, testS2{s2};
+  CallSubroutine(fooTest, testS1.getFchar(), testS2.getFchar(), otherArgs...);
+
+  // Compare against reference subroutine
+  FcharData<Kind> refS1{s1}, refS2{s2};
+  CallSubroutine(fooRef, refS1.getFchar(), refS2.getFchar(), otherArgs...);
+
+  auto description{testName + " KIND=" + std::to_string(Kind)};
+  bool result{Check(testS1, refS1, description + " s1")};
+  result &= Check(testS2, refS2, description + " s2");
+  return result;
+}
+
+// Compare against precomputed results.
+template<int Kind, typename... T>
+bool TestSubroutine(const std::string &testName, SubF18<T...> fooTest,
+    const FcharData<Kind> &s1, const FcharData<Kind> &refS1,
+    const FcharData<Kind> &s2, const FcharData<Kind> &refS2, T... otherArgs) {
+  // Make copies because data may be modified
+  FcharData<Kind> testS1{s1}, testS2{s2};
+  CallSubroutine(fooTest, testS1.getFchar(), testS2.getFchar(), otherArgs...);
+  auto description{testName + " KIND=" + std::to_string(Kind)};
+  bool result{Check(testS1, refS1, description + " s1")};
+  result &= Check(testS2, refS2, description + " s2");
+  return result;
+}
+
+// Test driver code (could maybe generated somehow)
+
+// String data to be used as inputs during the tests.
+template<int Kind> struct Inputs { static FcharData<Kind> s1, s2, s3; };
+
+template<> FcharData<1> Inputs<1>::s1{"aw*lSe4frliaw"};
+template<> FcharData<1> Inputs<1>::s2{"8\n e7t4$%&52Z"};
+template<> FcharData<1> Inputs<1>::s3{"quAli64^&$*#$8gl6"};
+
+template<> FcharData<2> Inputs<2>::s1{u"\u4e4dhy7&3o8%\u4e24"};
+template<> FcharData<2> Inputs<2>::s2{u"\u4f60\u4e0d\u662f F18 !\uff1f"};
+template<>
+FcharData<2> Inputs<2>::s3{
+    u"\u4f60\u597d\uff0c\u6211\u66df F18 ! \u4f60\u5462\uff1f"};
+
+template<> FcharData<4> Inputs<4>::s1{U"\u4e4dhy7&3o8%\u4e24"};
+template<> FcharData<4> Inputs<4>::s2{U"\u4f60\u4e0d\u662f F18 !\uff1f"};
+template<>
+FcharData<4> Inputs<4>::s3{
+    U"\u4f60\u597d\uff0c\u6211\u66df F18 ! \u4f60\u5462\uff1f"};
+
+// Test simple assignment
+extern "C" {
+// Declare Fortran subroutine to be tested
+//
+// SUBROUTINE assignK(s1, s2)
+//   CHARACTER(*, K) :: s1, s2
+//   s1 = s2
+// END SUBROUTINE
+void assign1(Fchar, Fchar);
+void assign2(Fchar, Fchar);
+void assign4(Fchar, Fchar);
+}
+
+template<int Kind, typename Func>
+void TestNormalAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s1};
+  auto &s2{Inputs<Kind>::s2};
+  auto &s3{Inputs<Kind>::s3};
+
+  assert(s1.len == s2.len && s1.len < s3.len &&
+      "Test requires len(s1) = len(s2) < len(s3)");
+  const std::string &desc{"normal character assignment"};
+
+  // s1 = s2 ! len(s1) == len(s3)
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, /* expect*/ s2, s2, /*expect*/ s2)) {
+    passed++;
+  }
+
+  // s1 = s3 ! len(s1) < len(s3)
+  FcharData<Kind> s3Tos1{s3.data.substr(0, s1.len)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, /* expect*/ s3Tos1, s3, s3)) {
+    passed++;
+  }
+
+  // s3 = s1 ! len(s1) < len(s3)
+  using ST = typename CharStorage<Kind>::Type;
+  FcharData<Kind> s1Tos3{
+      s1.data.substr(0, s1.len) + ST(s3.len - s1.len, /* space */ 0x20)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s3, /* expect*/ s1Tos3, s1, s1)) {
+    passed++;
+  }
+}
+
+// Test substring assignment
+extern "C" {
+// SUBROUTINE assign_substringK(s1, s2, lb, ub)
+//   CHARACTER(*, K) :: s1, s2
+//   INTEGER :: lb, ub
+//   s1(lb:ub) = s2
+// END SUBROUTINE
+void assign_substring1(Fchar s1, Fchar s2, int *lb, int *ub);
+void assign_substring2(Fchar, Fchar, int *, int *);
+void assign_substring4(Fchar, Fchar, int *, int *);
+}
+
+template<int Kind, typename Func>
+void TestSubstringAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s3};
+  auto &s2{Inputs<Kind>::s1};
+  int lb{3};
+  int ub{14};
+  assert(1 <= lb && lb < ub && ub <= s1.len && "Failed test requirements");
+  const std::string &desc{"substring character assignment"};
+
+  // s1(lb:ub) = s2
+  auto delta{ub - lb + 1};
+  auto s2CpyLen{s2.len < delta ? s2.len : delta};
+  auto str{s1.data.substr(0, lb - 1) + s2.data.substr(0, s2CpyLen)};
+  if (auto padding{delta - s2.len}; padding >= 0) {
+    using ST = typename CharStorage<Kind>::Type;
+    str += ST(padding, /* space */ 0x20);
+  }
+  FcharData<Kind> expected{str + s1.data.substr(ub, s1.len - ub)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, expected, s2, s2, &lb, &ub)) {
+    passed++;
+  }
+}
+
+// Test when RHS depends on LHS in a way that require a temp to evaluate RHS
+extern "C" {
+// SUBROUTINE assign_overlapK(s1, s2, lb)
+//   CHARACTER(*, K) :: s1, s2
+//   INTEGER :: lb
+//   s1(lb:) = s2
+// END SUBROUTINE
+void assign_overlap1(Fchar s1, Fchar s2, int *lb);
+void assign_overlap2(Fchar, Fchar, int *);
+void assign_overlap4(Fchar, Fchar, int *);
+}
+
+template<int Kind, typename Func>
+void TestOverlappingAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s1};
+  auto &s2{Inputs<Kind>::s2};
+  int lb{2};
+  assert(lb >= 2 && "Test requires lb>=2");
+  assert(s1.len >= lb && "Test requires len(s1)>=lb");
+  const std::string &desc{"overlapping character assignment"};
+
+  // s1(lb:) = s1 ! len(s1) >= lb
+  auto delta{lb - 1};
+  FcharData<Kind> expected{
+      s1.data.substr(0, delta) + s1.data.substr(0, s1.len - delta)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, expected, s2, s2, &lb)) {
+    passed++;
+  }
+}
+
+// Test assignment of character whose length is specified in specification
+// expression.
+extern "C" {
+// SUBROUTINE assign_spec_expr_lenK(s1, s2, l1, l2)
+//   INTEGER :: l1, l2
+//   CHARACTER(l1, K) :: s1
+//   CHARACTER(l2, K) :: s2
+//   s1 = s2
+// END SUBROUTINE
+void assign_spec_expr_len1(Fchar s1, Fchar s2, int *l1, int *l2);
+void assign_spec_expr_len2(Fchar s1, Fchar s2, int *l1, int *l2);
+void assign_spec_expr_len4(Fchar s1, Fchar s2, int *l1, int *l2);
+}
+
+template<int Kind, typename Func>
+void TestSpecExprLenAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s1};
+  auto &s2{Inputs<Kind>::s2};
+  auto &s3{Inputs<Kind>::s3};
+
+  int l1{static_cast<int>(s1.len / 2)};
+  int l2{static_cast<int>(s2.len / 2)};
+  int l3{static_cast<int>(s3.len / 2)};
+  assert(l1 == l2 && l1 < l3 && "Test requires l1 = l2 < l3");
+  const std::string &desc{"assignment of character with specified expr length"};
+
+  // s1 = s2 ! l1 == l3
+  tests++;
+  FcharData<Kind> expect1{
+      s2.data.substr(0, l1) + s1.data.substr(l1, s1.len - l1)};
+  if (TestSubroutine(desc, testedSub, s1, expect1, s2, s2, &l1, &l2)) {
+    passed++;
+  }
+
+  // s1 = s3 ! l1 < l3
+  FcharData<Kind> expect2{
+      s3.data.substr(0, l1) + s1.data.substr(l1, s1.len - l1)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, expect2, s3, s3, &l1, &l3)) {
+    passed++;
+  }
+
+  // s3 = s1 ! l1 < l3
+  using ST = typename CharStorage<Kind>::Type;
+  FcharData<Kind> expect3{s1.data.substr(0, l1) +
+      ST(l3 - l1, /* space */ 0x20) + s3.data.substr(l3, s3.len - l3)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s3, expect3, s1, s1, &l3, &l1)) {
+    passed++;
+  }
+}
+
+int main(int, char **) {
+  int tests{0}, passed{0};
+
+  TestNormalAssignement<1>(assign1, tests, passed);
+  TestNormalAssignement<2>(assign2, tests, passed);
+  TestNormalAssignement<4>(assign4, tests, passed);
+
+  TestSubstringAssignement<1>(assign_substring1, tests, passed);
+  TestSubstringAssignement<2>(assign_substring2, tests, passed);
+  TestSubstringAssignement<4>(assign_substring4, tests, passed);
+
+  TestOverlappingAssignement<1>(assign_overlap1, tests, passed);
+  TestOverlappingAssignement<2>(assign_overlap2, tests, passed);
+  TestOverlappingAssignement<4>(assign_overlap4, tests, passed);
+
+  TestSpecExprLenAssignement<1>(assign_spec_expr_len1, tests, passed);
+  TestSpecExprLenAssignement<2>(assign_spec_expr_len2, tests, passed);
+  TestSpecExprLenAssignement<4>(assign_spec_expr_len4, tests, passed);
+
+  std::cout << passed << " tests passed out of " << tests << std::endl;
+  return tests == passed ? 0 : -1;
+}
diff --git a/test/lower/test_character_assignment.sh b/test/lower/test_character_assignment.sh
new file mode 100755
index 000000000000..c16177a3c5ee
--- /dev/null
+++ b/test/lower/test_character_assignment.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Test Fortran character assignment/expression lowering by driving compilation
+# and executions of Fortran and C++ source codes.
+#
+# Usage: cmd bbc llc
+# To keep generated files, run `export KEEP=TRUE` before the test call.
+
+BBC=$1
+LLC=$2
+CPP=g++
+CPP_SRC=$PWD/test-character-assignment.cc
+F_SRC=$PWD/character-assignment.f90
+
+function die {
+  echo "$(basename $0): $*" >&2
+  exit 1
+}
+
+temp=`mktemp -d ./tmp.XXXXXX`
+cd $temp
+[[ $KEEP ]] || trap "cd .. && rm -rf $temp" EXIT
+
+bbcLog=bbc.log
+assembly=a.s
+testObject=test.o
+testExec=./test_exec
+testLog=test.log
+llFile=a.mlir.ll
+$BBC -emit-llvm -disable-fir2std $F_SRC 2>$bbcLog
+[[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
+sed -i 's/_QP//g' -i $llFile
+$LLC $llFile -o $assembly
+[[ $? -ne 0 ]] && die "llc failed compiling bbc output"
+as $assembly -o $testObject
+[[ $? -ne 0 ]] && die "as failed compiling llc output"
+$CPP -std=c++17 $testObject $CPP_SRC -o $testExec
+[[ $? -ne 0 ]] && die "driver.f90 compilation/linking failure"
+$testExec > $testLog
+result=$?
+cat $testLog
+if [ $result -ne 0 ]; then
+  echo "FAIL"
+else
+  echo "PASS"
+fi

From 36d657eeea5fb9fedc374c51eb6150144dc259f3 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 17 Jan 2020 08:54:21 -0800
Subject: [PATCH 174/345] more rebasing changes add type test add remaining ops
 add select test add loop test add recursive type test, cse test, select type
 test add complex test

remove the type converter. it was causing crashes in tco.

rebase breakage

misc. runtime changes

move InternalNames and KindMapping to FIR

add runtime builder

use the new table for BeginExternalListOutput and EndIoStatement
remove unused code
---
 include/fir/Dialect/FIROps.td               |   7 +
 include/flang/lower/Runtime.h               |   2 +-
 lib/fir/CMakeLists.txt                      |  14 ++
 lib/{optimizer => fir}/InternalNames.cpp    |   0
 lib/{optimizer => fir}/KindMapping.cpp      |   0
 lib/lower/Bridge.cpp                        |  16 +-
 lib/lower/CFGBuilder.h                      |   4 +-
 lib/lower/CMakeLists.txt                    |   2 +-
 lib/lower/IO.cpp                            | 111 +++++++--
 lib/lower/OpBuilder.cpp                     |   4 +-
 lib/lower/RTBuilder.h                       | 136 +++++++++++
 lib/lower/Runtime.cpp                       |   6 +-
 lib/optimizer/CMakeLists.txt                |   4 +-
 lib/optimizer/StdConverter.cpp              |  33 +--
 lib/optimizer/Transforms/CMakeLists.txt     |   2 +-
 runtime/io-api.h                            |   9 +-
 test-lit/fir/complex.fir                    |  82 +++++++
 test/fir/loads.fir => test-lit/fir/cse.fir  |  15 ++
 test-lit/fir/fir-ops.fir                    | 113 ++++++++++
 test-lit/fir/fir-types.fir                  |  69 ++++++
 {test => test-lit}/fir/loop.fir             |  11 +
 test-lit/fir/print_complex.c                |   5 +
 test/fir/float.fir => test-lit/fir/real.fir |  28 ++-
 test-lit/fir/recursive-type.fir             |  11 +
 {test => test-lit}/fir/select-type.fir      |   8 +
 {test => test-lit}/fir/select.fir           |  18 ++
 test/fir/fir-ops.fir                        | 237 --------------------
 test/fir/fir-types.fir                      |  38 ----
 test/fir/recursive-type.fir                 |   5 -
 tools/tco/CMakeLists.txt                    |   2 +-
 30 files changed, 647 insertions(+), 345 deletions(-)
 rename lib/{optimizer => fir}/InternalNames.cpp (100%)
 rename lib/{optimizer => fir}/KindMapping.cpp (100%)
 create mode 100644 lib/lower/RTBuilder.h
 create mode 100644 test-lit/fir/complex.fir
 rename test/fir/loads.fir => test-lit/fir/cse.fir (77%)
 create mode 100644 test-lit/fir/fir-types.fir
 rename {test => test-lit}/fir/loop.fir (54%)
 create mode 100644 test-lit/fir/print_complex.c
 rename test/fir/float.fir => test-lit/fir/real.fir (59%)
 create mode 100644 test-lit/fir/recursive-type.fir
 rename {test => test-lit}/fir/select-type.fir (64%)
 rename {test => test-lit}/fir/select.fir (66%)
 delete mode 100644 test/fir/fir-ops.fir
 delete mode 100644 test/fir/fir-types.fir
 delete mode 100644 test/fir/recursive-type.fir

diff --git a/include/fir/Dialect/FIROps.td b/include/fir/Dialect/FIROps.td
index 359b011164a0..3a8e2b3bd761 100644
--- a/include/fir/Dialect/FIROps.td
+++ b/include/fir/Dialect/FIROps.td
@@ -909,6 +909,13 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
     parameter, the value of which may only be known at runtime.  Therefore,
     a variable of type CHARACTER has both its data reference as well as a
     LEN type parameter.
+
+      CHARACTER(LEN=10) :: var
+
+      %4 = ...         : !fir.ref<!fir.array<10:!fir.char<1>>>
+      %5 = constant 10 : i32
+      %6 = fir.emboxchar %4, %5 : (!fir.ref<!fir.array<10:!fir.char<1>>>,
+                                   i32) -> !fir.boxchar<1>
   }];
 
   let parser = [{
diff --git a/include/flang/lower/Runtime.h b/include/flang/lower/Runtime.h
index 7af965a72ec9..b13c360c17a3 100644
--- a/include/flang/lower/Runtime.h
+++ b/include/flang/lower/Runtime.h
@@ -49,6 +49,7 @@ struct StaticVectorStorage {
   static constexpr const T *start{&values[0]};
   static constexpr const T *end{start + sizeof...(v)};
 };
+
 template <typename T>
 struct StaticVectorStorage<T> {
   static constexpr const T *start{nullptr}, *end{nullptr};
@@ -80,7 +81,6 @@ struct StaticVector {
 /// these descriptions in a meaningful way.
 /// It is constexpr constructible so that static tables of such descriptions can
 /// be safely stored as global variables without requiring global constructors.
-
 class RuntimeStaticDescription {
 public:
   /// Define possible runtime function argument/return type used in signature
diff --git a/lib/fir/CMakeLists.txt b/lib/fir/CMakeLists.txt
index 0ca0f41c5af4..ef5c33e99890 100644
--- a/lib/fir/CMakeLists.txt
+++ b/lib/fir/CMakeLists.txt
@@ -1 +1,15 @@
 add_subdirectory(Dialect)
+
+add_llvm_library(FIR
+  InternalNames.cpp
+  KindMapping.cpp
+)
+
+target_link_libraries(FIR
+  FIRDialect
+)
+
+install (TARGETS FIR
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+)
diff --git a/lib/optimizer/InternalNames.cpp b/lib/fir/InternalNames.cpp
similarity index 100%
rename from lib/optimizer/InternalNames.cpp
rename to lib/fir/InternalNames.cpp
diff --git a/lib/optimizer/KindMapping.cpp b/lib/fir/KindMapping.cpp
similarity index 100%
rename from lib/optimizer/KindMapping.cpp
rename to lib/fir/KindMapping.cpp
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 8f618d36a539..23c1db969c1d 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -41,13 +41,13 @@ using namespace Fortran::lower;
 
 namespace {
 
-L::cl::opt<bool> ClDumpPreFir("fdebug-dump-pre-fir", L::cl::init(false),
-                              L::cl::desc("dump the IR tree prior to FIR"));
+L::cl::opt<bool> dumpBeforeFir("fdebug-dump-pre-fir", L::cl::init(false),
+                               L::cl::desc("dump the IR tree prior to FIR"));
 
 L::cl::opt<bool>
-    ClDisableToDoAssert("disable-burnside-todo",
-                        L::cl::desc("disable burnside bridge asserts"),
-                        L::cl::init(false), L::cl::Hidden);
+    disableToDoAssertions("disable-burnside-todo",
+                          L::cl::desc("disable burnside bridge asserts"),
+                          L::cl::init(false), L::cl::Hidden);
 
 #undef TODO
 #define TODO() assert(false && "not implemented yet")
@@ -69,7 +69,7 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 #undef TODO
 #define TODO()                                                                 \
   {                                                                            \
-    if (ClDisableToDoAssert)                                                   \
+    if (disableToDoAssertions)                                                 \
       M::emitError(toLocation(), __FILE__)                                     \
           << ":" << __LINE__ << " not implemented";                            \
     else                                                                       \
@@ -691,7 +691,7 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::AssignmentStmt &stmt) {
     assert(stmt.typedAssignment && "assignment analysis failed");
     if (const auto *assignment{std::get_if<Ev::Assignment::IntrinsicAssignment>(
-            &stmt.typedAssignment->v.u)}) {
+            &stmt.typedAssignment->v->u)}) {
       const Se::Symbol *sym{Ev::UnwrapWholeSymbolDataRef(assignment->lhs)};
       if (sym && Se::IsAllocatable(*sym)) {
         // Assignment of allocatable are more complex, the lhs
@@ -1203,7 +1203,7 @@ void Br::BurnsideBridge::lower(const Pa::Program &prg,
                                fir::NameUniquer &uniquer) {
   AST::Program *ast{Br::createAST(prg)};
   Br::annotateControl(*ast);
-  if (ClDumpPreFir) {
+  if (dumpBeforeFir) {
     Br::dumpAST(L::errs(), *ast);
   }
   FirConverter converter{*this, uniquer};
diff --git a/lib/lower/CFGBuilder.h b/lib/lower/CFGBuilder.h
index 85e26b1e1759..4f30f3676ae3 100644
--- a/lib/lower/CFGBuilder.h
+++ b/lib/lower/CFGBuilder.h
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
-#define FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
+#ifndef FORTRAN_LOWER_CFG_BUILDER_H_
+#define FORTRAN_LOWER_CFG_BUILDER_H_
 
 /// Traverse the AST and complete the CFG by drawing the arcs, pruning unused
 /// potential targets, making implied jumps explicit, etc.
diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
index 2a8afaa0eb4e..815d31e4a484 100644
--- a/lib/lower/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -13,7 +13,7 @@ add_library(FortranLower
 )
 
 target_link_libraries(FortranLower
-  FIRDialect
+  FIR
   MLIRAffineOps
   MLIRLLVMIR
   MLIRStandardOps
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 61008235ea1c..d4d6701ad85a 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -7,14 +7,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/IO.h"
+#include "../../runtime/io-api.h"
 #include "../parser/parse-tree.h"
 #include "../semantics/tools.h"
+#include "RTBuilder.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
-#include <cassert>
+
+#define NAMIFY_HELPER(X) #X
+#define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
 
 namespace Br = Fortran::lower;
 namespace M = mlir;
@@ -23,8 +27,54 @@ namespace Pa = Fortran::parser;
 using namespace Fortran;
 using namespace Fortran::lower;
 
+#define TODO() assert(false && "not yet implemented")
+
 namespace {
 
+#define mkIOKey(X) mkKey(IONAME(X))
+
+/// Static table of IO runtime calls
+///
+/// This logical map contains the name and type builder function for each IO
+/// runtime function listed in the tuple. This table is fully constructed at
+/// compile-time. Use the `mkIOKey` macro to access the table.
+static constexpr std::tuple<
+    mkIOKey(BeginExternalListOutput), mkIOKey(BeginExternalListInput),
+    mkIOKey(BeginExternalFormattedOutput), mkIOKey(BeginExternalFormattedInput),
+    mkIOKey(BeginUnformattedOutput), mkIOKey(BeginUnformattedInput),
+    mkIOKey(EndIoStatement), mkIOKey(OutputInteger64), mkIOKey(InputInteger64),
+    mkIOKey(OutputReal64), mkIOKey(InputReal64), mkIOKey(OutputReal32),
+    mkIOKey(InputReal64), mkIOKey(OutputComplex64), mkIOKey(OutputComplex32),
+    mkIOKey(BeginClose), mkIOKey(OutputAscii), mkIOKey(InputAscii),
+    mkIOKey(OutputLogical), mkIOKey(InputLogical), mkIOKey(BeginFlush),
+    mkIOKey(BeginBackspace), mkIOKey(BeginEndfile), mkIOKey(BeginRewind),
+    mkIOKey(BeginOpenUnit), mkIOKey(BeginOpenNewUnit),
+    mkIOKey(BeginInquireUnit), mkIOKey(BeginInquireFile),
+    mkIOKey(BeginInquireIoLength), mkIOKey(EnableHandlers), mkIOKey(SetAdvance),
+    mkIOKey(SetBlank), mkIOKey(SetDecimal), mkIOKey(SetDelim), mkIOKey(SetPad),
+    mkIOKey(SetPos), mkIOKey(SetRec), mkIOKey(SetRound), mkIOKey(SetSign),
+    mkIOKey(SetAccess), mkIOKey(SetAction), mkIOKey(SetAsynchronous),
+    mkIOKey(SetEncoding), mkIOKey(SetEncoding), mkIOKey(SetForm),
+    mkIOKey(SetPosition), mkIOKey(SetRecl), mkIOKey(SetStatus),
+    mkIOKey(SetFile), mkIOKey(GetNewUnit), mkIOKey(GetSize),
+    mkIOKey(GetIoLength), mkIOKey(GetIoMsg), mkIOKey(InquireCharacter),
+    mkIOKey(InquireLogical), mkIOKey(InquirePendingId),
+    mkIOKey(InquireInteger64)>
+    newIOTable;
+
+/// Helper function to retrieve the name of the IO function given the key `A`
+template <typename A>
+static constexpr const char *getName() {
+  return std::get<A>(newIOTable).name;
+}
+
+/// Helper function to retrieve the type model signature builder of the IO
+/// function as defined by the key `A`
+template <typename A>
+static constexpr FuncTypeBuilderFunc getTypeModel() {
+  return std::get<A>(newIOTable).getTypeModel();
+}
+
 /// Define actions to sort runtime functions. One actions
 /// may be associated to one or more runtime function.
 /// Actions are the keys in the StaticMultimapView used to
@@ -54,13 +104,13 @@ using IOA = IOAction;
 /// The array need to be sorted on the Actions.
 /// Experimental runtime for now.
 static constexpr IORuntimeDescription ioRuntimeTable[]{
-    {IOA::BeginExternalList, "__F18IOa_BeginExternalListOutput",
-     RType::IOCookie, Args::create<RType::i32>()},
-    {IOA::Output, "__F18IOa_OutputInteger64", RT::voidTy,
+    {IOA::BeginExternalList, NAMIFY(BeginExternalListOutput), RType::IOCookie,
+     Args::create<RType::i32>()},
+    {IOA::Output, NAMIFY(OutputInteger64), RT::voidTy,
      Args::create<RType::IOCookie, RType::i64>()},
-    {IOA::Output, "__F18IOa_OutputReal64", RT::voidTy,
+    {IOA::Output, NAMIFY(OutputReal64), RT::voidTy,
      Args::create<RType::IOCookie, RType::f64>()},
-    {IOA::EndIO, "__F18IOa_EndIOStatement", RT::voidTy,
+    {IOA::EndIO, NAMIFY(EndIOStatement), RT::voidTy,
      Args::create<RType::IOCookie>()},
 };
 
@@ -101,11 +151,25 @@ static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
   return {};
 }
 
+template <typename E>
+M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
+  auto module = getModule(&builder);
+  auto name = getName<E>();
+  auto func = getNamedFunction(module, name);
+  if (func)
+    return func;
+  auto funTy = getTypeModel<E>()(builder.getContext());
+  func = createFunction(module, name, funTy);
+  func.setAttr("fir.runtime", builder.getUnitAttr());
+  func.setAttr("fir.io", builder.getUnitAttr());
+  return func;
+}
+
 /// Lower print statement assuming a dummy runtime interface for now.
-void lowerPrintStatement(M::OpBuilder &builder, M::Location loc,
+void lowerPrintStatement(M::OpBuilder &builder, M::Location loc, int format,
                          M::ValueRange args) {
   M::FuncOp beginFunc{
-      getIORuntimeFunction<IOAction::BeginExternalList>(builder)};
+      getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder)};
 
   // Initiate io
   M::Type externalUnitType{builder.getIntegerType(32)};
@@ -123,36 +187,37 @@ void lowerPrintStatement(M::OpBuilder &builder, M::Location loc,
   }
 
   // Terminate IO
-  M::FuncOp endIOFunc{getIORuntimeFunction<IOAction::EndIO>(builder)};
+  M::FuncOp endIOFunc{getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder)};
   llvm::SmallVector<M::Value, 1> endArgs{cookie};
   builder.create<M::CallOp>(loc, endIOFunc, endArgs);
 }
 
+/// FIXME: this is a stub; process the format and return it
+int lowerFormat(const Pa::Format &format) { return 0; }
+
 } // namespace
 
 void Br::genBackspaceStatement(AbstractConverter &, const Pa::BackspaceStmt &) {
-  assert(false);
+  TODO();
 }
 
 void Br::genCloseStatement(AbstractConverter &, const Pa::CloseStmt &) {
-  assert(false);
+  TODO();
 }
 
 void Br::genEndfileStatement(AbstractConverter &, const Pa::EndfileStmt &) {
-  assert(false);
+  TODO();
 }
 
 void Br::genFlushStatement(AbstractConverter &, const Pa::FlushStmt &) {
-  assert(false);
+  TODO();
 }
 
 void Br::genInquireStatement(AbstractConverter &, const Pa::InquireStmt &) {
-  assert(false);
+  TODO();
 }
 
-void Br::genOpenStatement(AbstractConverter &, const Pa::OpenStmt &) {
-  assert(false);
-}
+void Br::genOpenStatement(AbstractConverter &, const Pa::OpenStmt &) { TODO(); }
 
 void Br::genPrintStatement(Br::AbstractConverter &converter,
                            const Pa::PrintStmt &stmt) {
@@ -162,21 +227,19 @@ void Br::genPrintStatement(Br::AbstractConverter &converter,
       auto loc{converter.genLocation(pe->source)};
       args.push_back(converter.genExprValue(*semantics::GetExpr(*pe), &loc));
     } else {
-      assert(false); // TODO implied do
+      TODO(); // TODO implied do
     }
   }
   lowerPrintStatement(converter.getOpBuilder(), converter.getCurrentLocation(),
-                      args);
+                      lowerFormat(std::get<Pa::Format>(stmt.t)), args);
 }
 
-void Br::genReadStatement(AbstractConverter &, const Pa::ReadStmt &) {
-  assert(false);
-}
+void Br::genReadStatement(AbstractConverter &, const Pa::ReadStmt &) { TODO(); }
 
 void Br::genRewindStatement(AbstractConverter &, const Pa::RewindStmt &) {
-  assert(false);
+  TODO();
 }
 
 void Br::genWriteStatement(AbstractConverter &, const Pa::WriteStmt &) {
-  assert(false);
+  TODO();
 }
diff --git a/lib/lower/OpBuilder.cpp b/lib/lower/OpBuilder.cpp
index aae19f0ac951..dd7c18c2a0a9 100644
--- a/lib/lower/OpBuilder.cpp
+++ b/lib/lower/OpBuilder.cpp
@@ -188,7 +188,7 @@ mlir::Type B::ComplexOpsBuilder::getComplexPartType(mlir::Type complexType) {
 }
 mlir::Type B::ComplexOpsBuilder::getComplexPartType(mlir::Value cplx) {
   assert(cplx != nullptr);
-  return getComplexPartType(cplx->getType());
+  return getComplexPartType(cplx.getType());
 }
 
 mlir::Value B::ComplexOpsBuilder::createComplex(fir::KindTy kind,
@@ -217,7 +217,7 @@ template mlir::Value B::ComplexOpsBuilder::extract<CplxPart::Imag>(mlir::Value);
 template <CplxPart partId>
 mlir::Value B::ComplexOpsBuilder::insert(mlir::Value cplx, mlir::Value part) {
   assert(cplx != nullptr);
-  return create<fir::InsertValueOp>(cplx->getType(), cplx, part,
+  return create<fir::InsertValueOp>(cplx.getType(), cplx, part,
                                     createPartId<partId>());
 }
 template mlir::Value B::ComplexOpsBuilder::insert<CplxPart::Real>(mlir::Value,
diff --git a/lib/lower/RTBuilder.h b/lib/lower/RTBuilder.h
new file mode 100644
index 000000000000..48843c7252fc
--- /dev/null
+++ b/lib/lower/RTBuilder.h
@@ -0,0 +1,136 @@
+//===-- lib/lower/cfg-builder.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_RT_BUILDER_H_
+#define FORTRAN_LOWER_RT_BUILDER_H_
+
+#include "fir/Dialect/FIRType.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/StandardTypes.h"
+#include <cstddef>
+#include <functional>
+
+// List the runtime headers we want to be able to dissect
+#include "../../runtime/io-api.h"
+
+namespace Fortran::lower {
+
+using TypeBuilderFunc = std::function<mlir::Type(mlir::MLIRContext *)>;
+using FuncTypeBuilderFunc =
+    std::function<mlir::FunctionType(mlir::MLIRContext *)>;
+
+template <typename>
+struct errorNoBuilderForType;
+
+/// Return a function that returns the type signature model for the type `T`
+/// when provided an MLIRContext*. This allows one to translate C(++) function
+/// signatures from runtime header files to MLIR signatures into a static table
+/// at compile-time.
+///
+/// For example, when `T` is `int`, return a function that returns the MLIR
+/// standard type `i32` when `sizeof(int)` is 4.
+template <typename T>
+static constexpr TypeBuilderFunc getModel() {
+  using namespace std::placeholders;
+  if constexpr (std::is_same_v<T, int>) {
+    return [](mlir::MLIRContext *c) {
+      return mlir::IntegerType::get(8 * sizeof(int), c);
+    };
+  } else if constexpr (std::is_same_v<T, int &>) {
+    return [](mlir::MLIRContext *c) {
+      return fir::ReferenceType::get(
+          mlir::IntegerType::get(8 * sizeof(int), c));
+    };
+  } else if constexpr (std::is_same_v<T, std::int64_t>) {
+    return [](mlir::MLIRContext *c) { return mlir::IntegerType::get(64, c); };
+  } else if constexpr (std::is_same_v<T, std::int64_t &>) {
+    return [](mlir::MLIRContext *c) {
+      return fir::ReferenceType::get(mlir::IntegerType::get(64, c));
+    };
+  } else if constexpr (std::is_same_v<std::decay_t<T>, std::size_t>) {
+    return [](mlir::MLIRContext *c) {
+      return mlir::IntegerType::get(8 * sizeof(std::size_t), c);
+    };
+  } else if constexpr (std::is_same_v<T, double>) {
+    return [](mlir::MLIRContext *c) { return mlir::FloatType::getF64(c); };
+  } else if constexpr (std::is_same_v<T, double &>) {
+    return [](mlir::MLIRContext *c) {
+      return fir::ReferenceType::get(mlir::FloatType::getF64(c));
+    };
+  } else if constexpr (std::is_same_v<T, float>) {
+    return [](mlir::MLIRContext *c) { return mlir::FloatType::getF32(c); };
+  } else if constexpr (std::is_same_v<T, float &>) {
+    return [](mlir::MLIRContext *c) {
+      return fir::ReferenceType::get(mlir::FloatType::getF32(c));
+    };
+  } else if constexpr (std::is_same_v<std::decay_t<T>, Iostat>) {
+    return [](mlir::MLIRContext *c) {
+      return mlir::IntegerType::get(8 * sizeof(Iostat), c);
+    };
+  } else if constexpr (std::is_same_v<T, bool>) {
+    return [](mlir::MLIRContext *c) { return mlir::IntegerType::get(1, c); };
+  } else if constexpr (std::is_same_v<T, bool &>) {
+    return [](mlir::MLIRContext *c) {
+      return fir::ReferenceType::get(mlir::IntegerType::get(1, c));
+    };
+  } else if constexpr (std::is_same_v<std::decay_t<T>,
+                                      runtime::io::IoStatementState *>) {
+    return [](mlir::MLIRContext *c) {
+      return fir::ReferenceType::get(mlir::IntegerType::get(8, c));
+    };
+  } else if constexpr (std::is_same_v<std::decay_t<T>, const char *>) {
+    return [](mlir::MLIRContext *c) {
+      return fir::ReferenceType::get(mlir::IntegerType::get(8, c));
+    };
+  } else {
+    return errorNoBuilderForType<T>{}; // intentionally force compile-time error
+  }
+}
+
+template <typename...>
+struct RuntimeTableKey;
+template <typename RT, typename... ATs>
+struct RuntimeTableKey<RT(ATs...)> {
+  static constexpr FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctxt) {
+      TypeBuilderFunc ret = getModel<RT>();
+      std::array<TypeBuilderFunc, sizeof...(ATs)> args = {getModel<ATs>()...};
+      mlir::Type retTy = ret(ctxt);
+      llvm::SmallVector<mlir::Type, sizeof...(ATs)> argTys;
+      for (auto f : args)
+        argTys.push_back(f(ctxt));
+      return mlir::FunctionType::get(argTys, {retTy}, ctxt);
+    };
+  }
+};
+
+template <char... Cs>
+using RuntimeIdentifier = std::integer_sequence<char, Cs...>;
+template <typename T, T... Cs>
+static constexpr RuntimeIdentifier<Cs...> operator""_rt_ident() {
+  return {};
+}
+
+template <typename...>
+struct RuntimeTableEntry;
+template <typename KT, char... Cs>
+struct RuntimeTableEntry<RuntimeTableKey<KT>, RuntimeIdentifier<Cs...>> {
+  static constexpr FuncTypeBuilderFunc getTypeModel() {
+    return RuntimeTableKey<KT>::getTypeModel();
+  }
+  static constexpr const char name[sizeof...(Cs) + 1] = {Cs..., '\0'};
+};
+
+#define QuoteKey(X) #X##_rt_ident
+#define ExpandKey(X) QuoteKey(X)
+#define mkKey(X)                                                               \
+  RuntimeTableEntry<RuntimeTableKey<decltype(X)>, decltype(ExpandKey(X))>
+
+} // namespace Fortran::lower
+
+#endif // FORTRAN_LOWER_RT_BUILDER_H_
diff --git a/lib/lower/Runtime.cpp b/lib/lower/Runtime.cpp
index 2cc9a49d800e..d9b32f62338d 100644
--- a/lib/lower/Runtime.cpp
+++ b/lib/lower/Runtime.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 
 namespace Fortran::lower {
+
 mlir::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
                                                  mlir::MLIRContext *context) {
   switch (t) {
@@ -52,9 +53,8 @@ mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
   if (resultTypeCode.has_value()) {
     mlir::Type resMLIRType{getMLIRType(*resultTypeCode, context)};
     return mlir::FunctionType::get(argMLIRTypes, resMLIRType, context);
-  } else {
-    return mlir::FunctionType::get(argMLIRTypes, {}, context);
   }
+  return mlir::FunctionType::get(argMLIRTypes, {}, context);
 }
 
 mlir::FuncOp
@@ -79,10 +79,12 @@ class RuntimeEntryDescription : public RuntimeStaticDescription {
       : RuntimeStaticDescription{s, r, a}, key{k} {}
   Key key;
 };
+
 using RT = RuntimeStaticDescription;
 using RType = typename RT::TypeCode;
 using Args = typename RT::TypeCodeVector;
 using RTC = RuntimeEntryCode;
+
 static constexpr RuntimeEntryDescription runtimeTable[]{
     {RTC::StopStatement, "StopStatement", RT::voidTy,
      Args::create<RType::i32, RType::boolean, RType::boolean>()},
diff --git a/lib/optimizer/CMakeLists.txt b/lib/optimizer/CMakeLists.txt
index 8f0d7a8cf228..b4a82c58bbb5 100644
--- a/lib/optimizer/CMakeLists.txt
+++ b/lib/optimizer/CMakeLists.txt
@@ -4,14 +4,12 @@ add_subdirectory(Transforms)
 
 add_llvm_library(FortranOptimizer
   CodeGen.cpp
-  InternalNames.cpp
   IteratedDominanceFrontier.cpp
-  KindMapping.cpp
   StdConverter.cpp
 )
 
 target_link_libraries(FortranOptimizer
-  FIRDialect
+  FIR
 )
 
 install (TARGETS FortranOptimizer
diff --git a/lib/optimizer/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
index c1d3698acbce..249075c3aa98 100644
--- a/lib/optimizer/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -1,4 +1,4 @@
-//===-- lib/optimizer/StdConverter.cpp --------------------------*- C++ -*-===//
+//===-- lib/optimizer/StdConverter.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -53,6 +53,7 @@ class FIRToStdTypeConverter : public M::TypeConverter {
     case L::Type::TypeID::HalfTyID:
       return M::FloatType::getF16(ctx);
 #if 0
+    // FIXME: there is no BF16 type in LLVM yet
     case L::Type::TypeID:: FIXME TyID:
       return M::FloatType::getBF16(ctx);
 #endif
@@ -69,7 +70,6 @@ class FIRToStdTypeConverter : public M::TypeConverter {
 
   /// Convert some FIR types to MLIR standard dialect types
   M::Type convertType(M::Type t) override {
-#if 0
     // To lower types, we have to convert everything that uses these types...
     if (auto cplx = t.dyn_cast<CplxType>())
       return M::ComplexType::get(kindToRealType(kindMap, cplx.getFKind()));
@@ -77,7 +77,6 @@ class FIRToStdTypeConverter : public M::TypeConverter {
       return M::IntegerType::get(integer.getFKind() * 8, integer.getContext());
     if (auto real = t.dyn_cast<RealType>())
       return kindToRealType(kindMap, real.getFKind());
-#endif
     return t;
   }
 
@@ -89,14 +88,16 @@ class FIRToStdTypeConverter : public M::TypeConverter {
 template <typename FromOp>
 class FIROpConversion : public M::ConversionPattern {
 public:
-  explicit FIROpConversion(M::MLIRContext *ctx, FIRToStdTypeConverter &lowering)
-      : ConversionPattern(FromOp::getOperationName(), 1, ctx),
-        lowering(lowering) {}
+  explicit FIROpConversion(
+      M::MLIRContext *ctx /*, FIRToStdTypeConverter &lowering*/)
+      : ConversionPattern(FromOp::getOperationName(), 1,
+                          ctx) /*, lowering(lowering)*/
+  {}
 
 protected:
-  M::Type convertType(M::Type ty) const { return lowering.convertType(ty); }
+  // M::Type convertType(M::Type ty) const { return lowering.convertType(ty); }
 
-  FIRToStdTypeConverter &lowering;
+  // FIRToStdTypeConverter &lowering;
 };
 
 /// SelectTypeOp converted to an if-then-else chain
@@ -182,19 +183,21 @@ class FIRToStdLoweringPass : public M::FunctionPass<FIRToStdLoweringPass> {
       return;
 
     auto *context{&getContext()};
-    FIRToStdTypeConverter typeConverter{kindMap};
+    // FIRToStdTypeConverter typeConverter{kindMap};
     M::OwningRewritePatternList patterns;
-    patterns.insert<SelectTypeOpConversion>(context, typeConverter);
+    // patterns.insert<SelectTypeOpConversion>(context, typeConverter);
+    patterns.insert<SelectTypeOpConversion>(context);
     M::populateAffineToStdConversionPatterns(patterns, context);
-    M::populateFuncOpTypeConversionPattern(patterns, context, typeConverter);
+    // M::populateFuncOpTypeConversionPattern(patterns, context, typeConverter);
     M::ConversionTarget target{*context};
     target.addLegalDialect<M::StandardOpsDialect, fir::FIROpsDialect>();
-    target.addDynamicallyLegalOp<M::FuncOp>([&](M::FuncOp op) {
-      return typeConverter.isSignatureLegal(op.getType());
-    });
+    // target.addDynamicallyLegalOp<M::FuncOp>([&](M::FuncOp op) {
+    //  return typeConverter.isSignatureLegal(op.getType());
+    //});
     target.addIllegalOp<SelectTypeOp>();
     if (M::failed(M::applyPartialConversion(
-            getModule(), target, std::move(patterns), &typeConverter))) {
+            // getModule(), target, std::move(patterns), &typeConverter))) {
+            getModule(), target, std::move(patterns)))) {
       M::emitError(M::UnknownLoc::get(context),
                    "error in converting to standard dialect\n");
       signalPassFailure();
diff --git a/lib/optimizer/Transforms/CMakeLists.txt b/lib/optimizer/Transforms/CMakeLists.txt
index 51f27a9eb531..f9c6d10fa548 100644
--- a/lib/optimizer/Transforms/CMakeLists.txt
+++ b/lib/optimizer/Transforms/CMakeLists.txt
@@ -7,7 +7,7 @@ add_llvm_library(FIRTransforms
 add_dependencies(FIRTransforms FIROpsIncGen)
 
 target_link_libraries(FIRTransforms
-  FIRDialect
+  FIR
 )
 
 install (TARGETS FIRTransforms
diff --git a/runtime/io-api.h b/runtime/io-api.h
index 6b394dbdec02..c9eaea093d2b 100644
--- a/runtime/io-api.h
+++ b/runtime/io-api.h
@@ -22,12 +22,15 @@ class NamelistGroup;
 } // namespace Fortran::runtime
 
 namespace Fortran::runtime::io {
-
 class IoStatementState;
 using Cookie = IoStatementState *;
 using ExternalUnit = int;
 using AsynchronousId = int;
 static constexpr ExternalUnit DefaultUnit{-1}; // READ(*), WRITE(*), PRINT
+}
+
+using namespace Fortran::runtime;
+using namespace Fortran::runtime::io;
 
 extern "C" {
 
@@ -293,6 +296,6 @@ bool IONAME(InquireInteger64)(
 // rather than by terminating the image.
 enum Iostat IONAME(EndIoStatement)(Cookie);
 
-} // extern "C"
-} // namespace Fortran::runtime::io
+}  // extern "C"
+
 #endif
diff --git a/test-lit/fir/complex.fir b/test-lit/fir/complex.fir
new file mode 100644
index 000000000000..4578fd8372a4
--- /dev/null
+++ b/test-lit/fir/complex.fir
@@ -0,0 +1,82 @@
+// RUN: cc -c %S/print_complex.c
+// RUN: tco %s | llc | as -o %t 
+// RUN: cc %t print_complex.o 
+// RUN: ./a.out | FileCheck %s
+
+// CHECK: <0.935893, 2.252526>
+
+func @foo(%a : !fir.complex<4>, %b : !fir.complex<4>, %c : !fir.complex<4>, %d : !fir.complex<4>, %e : !fir.complex<4>) -> !fir.complex<4> {
+  %1 = fir.addc %a, %b : !fir.complex<4>
+  %2 = fir.mulc %1, %c : !fir.complex<4>
+  %3 = fir.subc %2, %d : !fir.complex<4>
+  %4 = fir.divc %3, %e : !fir.complex<4>
+  return %4 : !fir.complex<4>
+}
+
+func @real_part(%a : !fir.complex<4>) -> f32 {
+  %0 = constant 0 : i32
+  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
+  return %1 : f32
+}
+
+func @conj(%a : !fir.complex<4>) -> !fir.complex<4> {
+  %0 = constant 1 : i32
+  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
+  %2 = fir.negf %1 : f32
+  %3 = fir.insert_value %a, %2, %0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  return %3 : !fir.complex<4>
+}
+
+func @print_complex(f32, f32)
+
+func @main() -> i32 {
+  %0 = fir.alloca !fir.complex<4>
+  %1 = fir.alloca !fir.complex<4>
+  %2 = fir.alloca !fir.complex<4>
+  %3 = fir.alloca !fir.complex<4>
+  %4 = fir.alloca !fir.complex<4>
+
+  %5 = fir.undefined !fir.complex<4>
+  %c0 = constant 0 : i32
+  %c1 = constant 1 : i32
+
+  %f0 = constant 4.0 : f32
+  %f1 = constant 52.5 : f32
+  %6 = fir.insert_value %5, %f0, %c0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  %7 = fir.insert_value %6, %f1, %c1 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  fir.store %7 to %0 : !fir.ref<!fir.complex<4>>
+
+  %8 = fir.load %0 : !fir.ref<!fir.complex<4>>
+  %9 = fir.call @conj(%8) : (!fir.complex<4>) -> !fir.complex<4>
+  fir.store %9 to %1 : !fir.ref<!fir.complex<4>>
+
+  %a0 = constant 95.65 : f32
+  %a1 = constant 234.1 : f32
+  %a2 = fir.insert_value %5, %a0, %c0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  %a3 = fir.insert_value %a2, %a1, %c1 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  fir.store %a3 to %2 : !fir.ref<!fir.complex<4>>
+
+  %b0 = constant 33.0 : f32
+  %b1 = constant 87.69 : f32
+  %b2 = fir.insert_value %5, %b0, %c0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  %b3 = fir.insert_value %b2, %b1, %c1 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  fir.store %b3 to %3 : !fir.ref<!fir.complex<4>>
+
+  %d0 = constant 791.0 : f32
+  %d1 = constant 3.5923 : f32
+  %d2 = fir.insert_value %5, %d0, %c0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  %d3 = fir.insert_value %d2, %d1, %c1 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  fir.store %d3 to %4 : !fir.ref<!fir.complex<4>>
+
+  %l0 = fir.load %0 : !fir.ref<!fir.complex<4>>
+  %l1 = fir.load %1 : !fir.ref<!fir.complex<4>>
+  %l2 = fir.load %2 : !fir.ref<!fir.complex<4>>
+  %l3 = fir.load %3 : !fir.ref<!fir.complex<4>>
+  %l4 = fir.load %4 : !fir.ref<!fir.complex<4>>
+
+  %10 = fir.call @foo(%l0, %l1, %l2, %l3, %l4) : (!fir.complex<4>, !fir.complex<4>, !fir.complex<4>, !fir.complex<4>, !fir.complex<4>) -> !fir.complex<4>
+  %11 = fir.extract_value %10, %c0 : (!fir.complex<4>, i32) -> f32
+  %12 = fir.extract_value %10, %c1 : (!fir.complex<4>, i32) -> f32
+  fir.call @print_complex(%11, %12) : (f32, f32) -> ()
+  return %c0 : i32
+}
diff --git a/test/fir/loads.fir b/test-lit/fir/cse.fir
similarity index 77%
rename from test/fir/loads.fir
rename to test-lit/fir/cse.fir
index 2b05e7372633..91272292a118 100644
--- a/test/fir/loads.fir
+++ b/test-lit/fir/cse.fir
@@ -1,6 +1,14 @@
+// Test CSE pass
+
+// RUN: tco -emit-fir %s | tco | FileCheck %s
+
+// CHECK-LABEL: @fun
 func @fun(%a : !fir.ref<i64>) -> i64 {
+  // CHECK: load i64
   %1 = fir.load %a : !fir.ref<i64>
   %2 = fir.load %a : !fir.ref<i64>
+  // CHECK-NOT: load i64
+  // CHECK-COUNT-6: add i64
   %3 = addi %1, %2 : i64
   %4 = fir.load %a : !fir.ref<i64>
   %5 = addi %3, %4 : i64
@@ -12,14 +20,20 @@ func @fun(%a : !fir.ref<i64>) -> i64 {
   %11 = addi %10, %9 : i64
   %12 = fir.load %a : !fir.ref<i64>
   %13 = addi %11, %12 : i64
+  // CHECK-NEXT: ret i64
   return %13 : i64
 }
 
+// CHECK-LABEL: @bar
 func @bar(%a : !fir.ref<i64>) -> i64
 
+// CHECK-LABEL: @fun2
 func @fun2(%a : !fir.ref<i64>) -> i64 {
+  // CHECK: load i64
   %1 = fir.load %a : !fir.ref<i64>
+  // CHECK-NEXT: call i64
   %2 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
+  // CHECK-COUNT-6: add i64
   %3 = addi %1, %2 : i64
   %4 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
   %5 = addi %3, %4 : i64
@@ -31,5 +45,6 @@ func @fun2(%a : !fir.ref<i64>) -> i64 {
   %11 = addi %10, %9 : i64
   %12 = fir.call @bar(%a) { pure = true } : (!fir.ref<i64>) -> i64
   %13 = addi %11, %12 : i64
+  // CHECK-NEXT: ret i64
   return %13 : i64
 }
diff --git a/test-lit/fir/fir-ops.fir b/test-lit/fir/fir-ops.fir
index f8958882079d..6d3c4e120889 100644
--- a/test-lit/fir/fir-ops.fir
+++ b/test-lit/fir/fir-ops.fir
@@ -339,3 +339,116 @@ fir.dispatch_table @dispatch_tbl {
   // CHECK: fir.dt_entry "method", @method_impl
   fir.dt_entry "method", @method_impl
 }
+
+// CHECK-LABEL: @compare_real
+func @compare_real(%a : !fir.real<16>, %b : !fir.real<16>) {
+  // CHECK: fir.cmpf "false", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "oeq", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ogt", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "oge", %{{.*}}, %{{.*}} : !fir.real<16>
+  %d0 = fir.cmpf "false", %a, %b : !fir.real<16>
+  %d1 = fir.cmpf "oeq", %a, %b : !fir.real<16>
+  %d2 = fir.cmpf "ogt", %a, %b : !fir.real<16>
+  %d3 = fir.cmpf "oge", %a, %b : !fir.real<16>
+  // CHECK: fir.cmpf "olt", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ole", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "one", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ord", %{{.*}}, %{{.*}} : !fir.real<16>
+  %a0 = fir.cmpf "olt", %a, %b : !fir.real<16>
+  %a1 = fir.cmpf "ole", %a, %b : !fir.real<16>
+  %a2 = fir.cmpf "one", %a, %b : !fir.real<16>
+  %a3 = fir.cmpf "ord", %a, %b : !fir.real<16>
+  // CHECK: fir.cmpf "ueq", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ugt", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "uge", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "ult", %{{.*}}, %{{.*}} : !fir.real<16>
+  %b0 = fir.cmpf "ueq", %a, %b : !fir.real<16>
+  %b1 = fir.cmpf "ugt", %a, %b : !fir.real<16>
+  %b2 = fir.cmpf "uge", %a, %b : !fir.real<16>
+  %b3 = fir.cmpf "ult", %a, %b : !fir.real<16>
+  // CHECK: fir.cmpf "ule", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "une", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "uno", %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.cmpf "true", %{{.*}}, %{{.*}} : !fir.real<16>
+  %c0 = fir.cmpf "ule", %a, %b : !fir.real<16>
+  %c1 = fir.cmpf "une", %a, %b : !fir.real<16>
+  %c2 = fir.cmpf "uno", %a, %b : !fir.real<16>
+  %c3 = fir.cmpf "true", %a, %b : !fir.real<16>
+  return
+}
+
+// CHECK-LABEL: @compare_complex
+func @compare_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) {
+  // CHECK: fir.cmpc "false", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "oeq", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ogt", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "oge", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %d0 = fir.cmpc "false", %a, %b : !fir.complex<16>
+  %d1 = fir.cmpc "oeq", %a, %b : !fir.complex<16>
+  %d2 = fir.cmpc "ogt", %a, %b : !fir.complex<16>
+  %d3 = fir.cmpc "oge", %a, %b : !fir.complex<16>
+  // CHECK: fir.cmpc "olt", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ole", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "one", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ord", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %a0 = fir.cmpc "olt", %a, %b : !fir.complex<16>
+  %a1 = fir.cmpc "ole", %a, %b : !fir.complex<16>
+  %a2 = fir.cmpc "one", %a, %b : !fir.complex<16>
+  %a3 = fir.cmpc "ord", %a, %b : !fir.complex<16>
+  // CHECK: fir.cmpc "ueq", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ugt", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "uge", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "ult", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %b0 = fir.cmpc "ueq", %a, %b : !fir.complex<16>
+  %b1 = fir.cmpc "ugt", %a, %b : !fir.complex<16>
+  %b2 = fir.cmpc "uge", %a, %b : !fir.complex<16>
+  %b3 = fir.cmpc "ult", %a, %b : !fir.complex<16>
+  // CHECK: fir.cmpc "ule", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "une", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "uno", %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.cmpc "true", %{{.*}}, %{{.*}} : !fir.complex<16>
+  %c0 = fir.cmpc "ule", %a, %b : !fir.complex<16>
+  %c1 = fir.cmpc "une", %a, %b : !fir.complex<16>
+  %c2 = fir.cmpc "uno", %a, %b : !fir.complex<16>
+  %c3 = fir.cmpc "true", %a, %b : !fir.complex<16>
+  return
+}
+
+// CHECK-LABEL: @arith_real
+func @arith_real(%a : !fir.real<16>, %b : !fir.real<16>) -> !fir.real<16> {
+  %c1 = constant 1.0 : f32
+  %0 = fir.convert %c1 : (f32) -> !fir.real<16>
+  // CHECK: %[[R1:.*]] = fir.negf %{{.*}} : !fir.real<16>
+  // CHECK: fir.addf %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: %[[R3:.*]] = fir.subf %{{.*}}, %{{.*}} : !fir.real<16>
+  // CHECK: fir.mulf %[[R1]], %[[R3]] : !fir.real<16>
+  // CHECK: fir.divf %{{.*}}, %{{.*}} : !fir.real<16>
+  %1 = fir.negf %a : !fir.real<16>
+  %2 = fir.addf %0, %1 : !fir.real<16>
+  %3 = fir.subf %2, %b : !fir.real<16>
+  %4 = fir.mulf %1, %3 : !fir.real<16>
+  %5 = fir.divf %4, %a : !fir.real<16>
+  return %5 : !fir.real<16>
+}
+
+// CHECK-LABEL: @arith_complex
+func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> {
+  // CHECK: fir.negc %{{.*}} : !fir.complex<16>
+  // CHECK: fir.addc %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.subc %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.mulc %{{.*}}, %{{.*}} : !fir.complex<16>
+  // CHECK: fir.divc %{{.*}}, %{{.*}} : !fir.complex<16>
+  %1 = fir.negc %a : !fir.complex<16>
+  %2 = fir.addc %b, %1 : !fir.complex<16>
+  %3 = fir.subc %2, %b : !fir.complex<16>
+  %4 = fir.mulc %1, %3 : !fir.complex<16>
+  %5 = fir.divc %4, %a : !fir.complex<16>
+  return %5 : !fir.complex<16>
+}
+
+// CHECK-LABEL: @character_literal
+func @character_literal() -> !fir.char<1> {
+  // CHECK: fir.constant "Hello, World!" : !fir.char<1>
+  %0 = fir.constant "Hello, World!" : !fir.char<1>
+  return %0 : !fir.char<1>
+}
diff --git a/test-lit/fir/fir-types.fir b/test-lit/fir/fir-types.fir
new file mode 100644
index 000000000000..75a39372c2fc
--- /dev/null
+++ b/test-lit/fir/fir-types.fir
@@ -0,0 +1,69 @@
+// Test the FIR types
+
+// RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
+
+// CHECK-LABEL: func @it1() -> !fir.int<4>
+// CHECK-LABEL: func @it2() -> !fir.real<8>
+// CHECK-LABEL: func @it3() -> !fir.complex<8>
+// CHECK-LABEL: func @it4() -> !fir.logical<1>
+// CHECK-LABEL: func @it5() -> !fir.char<1>
+func @it1() -> !fir.int<4>
+func @it2() -> !fir.real<8>
+func @it3() -> !fir.complex<8>
+func @it4() -> !fir.logical<1>
+func @it5() -> !fir.char<1>
+
+// CHECK-LABEL: func @dvd1() -> !fir.type<derived1>
+// CHECK-LABEL: func @dvd2() -> !fir.type<derived2(p:i32)>
+// CHECK-LABEL: func @dvd3() -> !fir.type<derived3{f:f32}>
+// CHECK-LABEL: func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+// CHECK-LABEL: func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
+// CHECK-LABEL: func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
+func @dvd1() -> !fir.type<derived1>
+func @dvd2() -> !fir.type<derived2(p:i32)>
+func @dvd3() -> !fir.type<derived3{f:f32}>
+func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
+func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
+
+// CHECK-LABEL: func @arr1() -> !fir.array<10xf32>
+// CHECK-LABEL: func @arr2() -> !fir.array<10x10xf32>
+// CHECK-LABEL: func @arr3() -> !fir.array<?xf32>
+// CHECK-LABEL: func @arr4() -> !fir.array<10x?xf32>
+// CHECK-LABEL: func @arr5() -> !fir.array<?x?xf32>
+// CHECK-LABEL: func @arr6() -> !fir.array<*:f32>
+// CHECK-LABEL: func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
+func @arr1() -> !fir.array<10xf32>
+func @arr2() -> !fir.array<10x10xf32>
+func @arr3() -> !fir.array<?xf32>
+func @arr4() -> !fir.array<10x?xf32>
+func @arr5() -> !fir.array<?x?xf32>
+func @arr6() -> !fir.array<*:f32>
+func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
+
+// CHECK-LABEL: func @mem1() -> !fir.ref<i32>
+// CHECK-LABEL: func @mem2() -> !fir.ptr<i32>
+// CHECK-LABEL: func @mem3() -> !fir.heap<i32>
+// CHECK-LABEL: func @mem4() -> !fir.ref<() -> ()>
+func @mem1() -> !fir.ref<i32>
+func @mem2() -> !fir.ptr<i32>
+func @mem3() -> !fir.heap<i32>
+func @mem4() -> !fir.ref<() -> ()>
+
+// CHECK-LABEL: func @box1() -> !fir.box<!fir.array<?xf32>>
+// CHECK-LABEL: func @box2() -> !fir.boxchar<2>
+// CHECK-LABEL: func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK-LABEL: func @box4() -> !fir.box<none>
+func @box1() -> !fir.box<!fir.array<?xf32>>
+func @box2() -> !fir.boxchar<2>
+func @box3() -> !fir.boxproc<(i32, i32) -> i64>
+func @box4() -> !fir.box<none>
+
+// CHECK-LABEL: func @oth1() -> !fir.dims<1>
+// CHECK-LABEL: func @oth2() -> !fir.field
+// CHECK-LABEL: func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
+// CHECK-LABEL: func @oth4() -> !fir.dims<15>
+func @oth1() -> !fir.dims<1>
+func @oth2() -> !fir.field
+func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
+func @oth4() -> !fir.dims<15>
diff --git a/test/fir/loop.fir b/test-lit/fir/loop.fir
similarity index 54%
rename from test/fir/loop.fir
rename to test-lit/fir/loop.fir
index fabc2caf5b6b..d85bb2e20226 100644
--- a/test/fir/loop.fir
+++ b/test-lit/fir/loop.fir
@@ -1,11 +1,22 @@
+// Test lowering FIR to LLVM IR of fir.select{|_rank|_case}
+
+// RUN: tco %s | FileCheck %s
+
+// CHECK-LABEL: @x
 func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
+  // CHECK: %[[COND:.*]] = icmp slt i64
+  // CHECK: br i1 %[[COND]]
   fir.loop %iv = %lb to %ub step %step unordered {
+    // CHECK: br i1 %
     fir.where %b {
+      // CHECK: store i64
       fir.store %iv to %addr : !fir.ref<index>
     } otherwise {
       %zero = constant 0 : index
+      // CHECK: store i64
       fir.store %zero to %addr : !fir.ref<index>
     }
   }
+  // CHECK: ret void
   return
 }
diff --git a/test-lit/fir/print_complex.c b/test-lit/fir/print_complex.c
new file mode 100644
index 000000000000..c821bc25de55
--- /dev/null
+++ b/test-lit/fir/print_complex.c
@@ -0,0 +1,5 @@
+#include <stdio.h>
+
+void print_complex(float x, float y) {
+  printf("<%f, %f>\n", x, y);
+}
diff --git a/test/fir/float.fir b/test-lit/fir/real.fir
similarity index 59%
rename from test/fir/float.fir
rename to test-lit/fir/real.fir
index f12b1383d6ab..45cafbee369e 100644
--- a/test/fir/float.fir
+++ b/test-lit/fir/real.fir
@@ -1,27 +1,51 @@
+// Test lowering of REAL operations from FIR to LLVM IR
+
+// RUN: tco %s | FileCheck %s
+
+// CHECK-LABEL: @bar
 func @bar(%a : !fir.real<2>, %b : !fir.real<4>, %c : !fir.real<8>, %d : !fir.real<10>, %e : !fir.real<16>) -> !fir.real<10> {
+  // CHECK: fpext half %{{.*}} to x86_fp80
   %1 = fir.convert %a : (!fir.real<2>) -> !fir.real<10>
+  // CHECK: fpext float %{{.*}} to x86_fp80
   %2 = fir.convert %b : (!fir.real<4>) -> !fir.real<10>
+  // CHECK: fpext double %{{.*}} to x86_fp80
   %3 = fir.convert %c : (!fir.real<8>) -> !fir.real<10>
+  // CHECK-NOT: fpext
+  // CHECK-NOT: fptrunc
   %4 = fir.convert %d : (!fir.real<10>) -> !fir.real<10>
+  // CHECK: fptrunc fp128 %{{.*}} to x86_fp80
   %5 = fir.convert %e : (!fir.real<16>) -> !fir.real<10>
-  %6 = call @foo2(%1, %2, %3, %4, %5) : (!fir.real<10>, !fir.real<10>, !fir.real<10>, !fir.real<10>, !fir.real<10>) -> !fir.real<10>
+  // CHECK-NEXT: call x86_fp80
+  %6 = call @foop(%1, %2, %3, %4, %5) : (!fir.real<10>, !fir.real<10>, !fir.real<10>, !fir.real<10>, !fir.real<10>) -> !fir.real<10>
   return %6 : !fir.real<10>
 }
 
+// CHECK-LABEL: @foo
 func @foo(%a : !fir.real<16>, %b : !fir.real<16>, %c : !fir.real<16>, %d : !fir.real<16>, %e : !fir.real<16>) -> !fir.real<16> {
+  // CHECK: fadd fp128
   %1 = fir.addf %a, %b : !fir.real<16>
+  // CHECK: fmul fp128
   %2 = fir.mulf %1, %c : !fir.real<16>
+  // CHECK: fsub fp128
   %3 = fir.subf %2, %d : !fir.real<16>
+  // CHECK: fdiv fp128
   %4 = fir.divf %3, %e : !fir.real<16>
+  // CHECK: frem fp128
   %5 = fir.modf %4, %a : !fir.real<16>
   return %5 : !fir.real<16>
 }
 
-func @foo2(%a : !fir.real<10>, %b : !fir.real<10>, %c : !fir.real<10>, %d : !fir.real<10>, %e : !fir.real<10>) -> !fir.real<10> {
+// CHECK-LABEL: @foop
+func @foop(%a : !fir.real<10>, %b : !fir.real<10>, %c : !fir.real<10>, %d : !fir.real<10>, %e : !fir.real<10>) -> !fir.real<10> {
+  // CHECK: fadd x86_fp80
   %1 = fir.addf %a, %b : !fir.real<10>
+  // CHECK: fmul x86_fp80
   %2 = fir.mulf %1, %c : !fir.real<10>
+  // CHECK: fsub x86_fp80
   %3 = fir.subf %2, %d : !fir.real<10>
+  // CHECK: fdiv x86_fp80
   %4 = fir.divf %3, %e : !fir.real<10>
+  // CHECK: frem x86_fp80
   %5 = fir.modf %4, %a : !fir.real<10>
   return %5 : !fir.real<10>
 }
diff --git a/test-lit/fir/recursive-type.fir b/test-lit/fir/recursive-type.fir
new file mode 100644
index 000000000000..595302e7f0ac
--- /dev/null
+++ b/test-lit/fir/recursive-type.fir
@@ -0,0 +1,11 @@
+// Test lowering FIR to LLVM IR for a recursive type
+
+// RUN: tco %s | FileCheck %s
+
+// CHECK-LABEL: %t = type { %t* }
+!t = type !fir.type<t {p : !fir.ptr<!fir.type<t>>}>
+
+// CHECK-LABEL: @a(%t %{{.*}})
+func @a(%a : !t) {
+  return
+}
diff --git a/test/fir/select-type.fir b/test-lit/fir/select-type.fir
similarity index 64%
rename from test/fir/select-type.fir
rename to test-lit/fir/select-type.fir
index 5c24bc01578b..8882d6a89a32 100644
--- a/test/fir/select-type.fir
+++ b/test-lit/fir/select-type.fir
@@ -1,7 +1,14 @@
+// Test lowering of select_type for FIR to LLVM IR
+
+// RUN: tco -emit-fir %s | tco | FileCheck %s
+
+// CHECK-LABEL: @f
 func @f(%a : !fir.box<none>) -> i32 {
    %1 = constant 4 : i32
    %2 = constant 8 : i32
    %3 = constant 16 : i32
+   // CHECK-DAG: call i1 @FIXME_exact_type_match
+   // CHECK-DAG: call i1 @FIXME_isa_type_test
    fir.select_type %a : !fir.box<none> [#fir.instance<!fir.type<a>>, ^bb2(%1:i32), #fir.subsumed<!fir.type<b>>, ^bb3(%3:i32), unit, ^bb4(%2:i32)]
 ^bb2(%4 : i32) :
    return %4 : i32
@@ -10,5 +17,6 @@ func @f(%a : !fir.box<none>) -> i32 {
    return %6 : i32
 ^bb4(%7 : i32) :
    %8 = muli %7, %7 : i32
+   // CHECK: ret i32 %
    return %8 : i32
 }
diff --git a/test/fir/select.fir b/test-lit/fir/select.fir
similarity index 66%
rename from test/fir/select.fir
rename to test-lit/fir/select.fir
index 026d97b5a9f5..cc326809d6a3 100644
--- a/test/fir/select.fir
+++ b/test-lit/fir/select.fir
@@ -1,17 +1,27 @@
+// Test lowering FIR to LLVM IR of fir.select{|_rank|_case}
+
+// RUN: tco %s | FileCheck %s
+
+// CHECK-LABEL: @f
 func @f(%a : i32) -> i32 {
    %1 = constant 1 : i32
    %2 = constant 42 : i32
+   // CHECK: icmp eq i32 %{{.*}}, 1
    fir.select %a : i32 [1, ^bb2(%1:i32), unit, ^bb3(%2:i32)]
 ^bb2(%3 : i32) :
    return %3 : i32
 ^bb3(%4 : i32) :
    %5 = addi %4, %4 : i32
+   // CHECK: ret i32
    return %5 : i32 
 }
 
+// CHECK-LABEL: @g
 func @g(%a : i32) -> i32 {
    %1 = constant 1 : i32
    %2 = constant 42 : i32
+   // CHECK-DAG: icmp eq i32 %{{.*}}, 1
+   // CHECK-DAG: icmp eq i32 %{{.*}}, -1
    fir.select_rank %a : i32 [1, ^bb2(%1:i32), -1, ^bb4, unit, ^bb3(%2:i32)]
 ^bb2(%3 : i32) :
    return %3 : i32
@@ -19,9 +29,11 @@ func @g(%a : i32) -> i32 {
    %5 = addi %4, %4 : i32
    return %5 : i32 
 ^bb4:
+   // CHECK: ret i32
    return %a : i32
 }
 
+// CHECK-LABEL: @h
 func @h(%a : i32) -> i32 {
    %1 = constant 1 : i32
    %2 = constant 42 : i32
@@ -29,6 +41,11 @@ func @h(%a : i32) -> i32 {
    %b2 = constant 14 : i32
    %b3 = constant 82 : i32
    %b4 = constant 96 : i32
+   // CHECK-DAG: icmp eq i32 %{{.*}}, 1
+   // CHECK-DAG: icmp sle i32 4, %{{.*}}
+   // CHECK-DAG: icmp sle i32 %{{.*}}, 14
+   // CHECK-DAG: icmp sle i32 82, %{{.*}}
+   // CHECK-DAG: icmp sle i32 %{{.*}}, 96
    fir.select_case %a : i32 [#fir.point, %1, ^bb2(%1:i32), #fir.lower, %b1, ^bb4, #fir.upper, %b2, ^bb6, #fir.interval, %b3, %b4, ^bb5, unit, ^bb3(%2:i32)]
 ^bb2(%3 : i32) :
    return %3 : i32
@@ -41,5 +58,6 @@ func @h(%a : i32) -> i32 {
    return %1 : i32
 ^bb6:
    %x = addi %b4, %b3 : i32
+   // CHECK: ret i32
    return %x : i32
 }
diff --git a/test/fir/fir-ops.fir b/test/fir/fir-ops.fir
deleted file mode 100644
index 1dbc0ff50eda..000000000000
--- a/test/fir/fir-ops.fir
+++ /dev/null
@@ -1,237 +0,0 @@
-func @it1() -> !fir.int<4>
-func @it2() -> !fir.real<8>
-func @it3() -> !fir.complex<8>
-func @it4() -> !fir.logical<1>
-func @it5() -> !fir.char<1>
-
-func @dvd1() -> !fir.type<derived1>
-func @dvd2() -> !fir.type<derived2(p:i32)>
-func @dvd3() -> !fir.type<derived3{f:f32}>
-func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
-
-func @arr1() -> !fir.array<10xf32>
-func @arr2() -> !fir.array<10x10xf32>
-func @arr3() -> !fir.array<?xf32>
-func @arr4() -> !fir.array<10x?xf32>
-func @arr5() -> !fir.array<?x?xf32>
-func @arr6() -> !fir.array<*:f32>
-
-func @mem1() -> !fir.ref<i32>
-func @mem2() -> !fir.ptr<i32>
-func @mem3() -> !fir.heap<i32>
-func @mem4() -> !fir.ref<() -> ()>
-
-func @box1() -> !fir.box<!fir.array<?xf32>>
-func @box2() -> !fir.boxchar<2>
-func @box3() -> !fir.boxproc<(i32, i32) -> i64>
-func @box4() -> !fir.box<!fir.type<derived3{f:f32}>>
-
-func @oth1() -> !fir.dims<1>
-func @oth2() -> !fir.field
-func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
-
-func @print_index3(index, index, index)
-func @user_i64(i64)
-func @user_tdesc(!fir.tdesc<!fir.type<x>>)
-func @store_tuple(!fir.type<qq1{f1:i32}>) -> ()
-
-func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
-func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
-
-func @nop()
-
-func @get_func() -> (() -> ())
-
-func @instructions() {
-  %0 = fir.alloca !fir.array<10xi32>
-  %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
-  %2 = fir.alloca i32
-  %3 = constant 22 : i32
-  fir.store %3 to %2 : !fir.ref<i32>
-  %4 = fir.undefined i32
-  %5 = fir.allocmem !fir.array<100xf32>
-  %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
-  %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
-  %c0 = constant 0 : index
-  %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
-  fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()
-  %8 = fir.call @it1() : () -> !fir.int<4>
-  %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i64
-  %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64
-  %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
-  %15 = fir.call @box2() : () -> !fir.boxchar<2>
-  %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
-  %17 = fir.call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
-  %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
-  %19 = constant 10 : i32
-  %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
-  %21 = fir.field_index f, !fir.type<derived{f:f32}>
-  %22 = fir.undefined !fir.type<derived{f:f32}>
-  %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32
-  %c1 = constant 1 : i32
-  %24 = fir.gendims %c1, %19, %c1 : (i32, i32, i32) -> !fir.dims<1>
-  %cf1 = constant 1.0 : f32
-  %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
-  %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>
-  %27 = fir.call @box4() : () -> !fir.box<!fir.type<derived3{f:f32}>>
-  %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
-  %29 = fir.convert %28 : (i32) -> i64
-  %30 = fir.gentypedesc !fir.type<x>
-  fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
-  %31 = fir.no_reassoc %29 : i64
-  fir.call @user_i64(%31) : (i64) -> ()
-  fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
-  %32 = fir.call @get_func() : () -> (() -> ())
-  fir.call %32() : () -> ()
-  %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
-  return
-}
-
-func @boxing_match() {
-  %0 = fir.alloca i32
-  %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>
-  %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.dims<0>)
-  %c8 = constant 8 : i32
-  %3 = fir.alloca !fir.char<1>
-  %b3 = fir.undefined !fir.char<1>
-  %4 = fir.emboxchar %3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
-  %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
-  %6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
-  %a1 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
-  %z = constant 0 : i32
-  %c12 = constant 12 : i32
-  %a2 = fir.insert_value %a1, %c12, %z : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
-  %z1 = constant 1 : i32
-  %c42 = constant 42.13 : f64
-  %a3 = fir.insert_value %a1, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
-  fir.store %a3 to %6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
-  %7 = fir.emboxproc @method_impl, %6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
-  %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>)
-  %9 = call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
-  %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<!fir.type<qq1{f1:i32}>>)
-  %11 = fir.load %10#1 : !fir.ref<!fir.type<qq1{f1:i32}>>
-  fir.call @store_tuple(%11) : (!fir.type<qq1{f1:i32}>) -> ()
-  return
-}
-
-func @loop() {
-  %c1 = constant 1 : index
-  %c10 = constant 10 : index
-  %ct = constant true
-  fir.loop %i = %c1 to %c10 {
-    fir.where %ct {
-      fir.call @nop() : () -> ()
-    } otherwise {
-      fir.call @nop() : () -> ()
-    }
-  }
-  fir.unreachable
-}
-
-func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32, %b2 : i32, %b3:i32) :
-  %4 = addi %b, %b2 : i32
-  %5 = addi %4, %b3 : i32
-  return %5 : i32
-^bb3(%c:i32, %c2:i32) :
-  %6 = addi %c, %c2 : i32
-  return %6 : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  return %zero : i32
-}
-
-func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32, %b2 : i32, %b3:i32) :
-  %4 = addi %b, %b2 : i32
-  %5 = addi %4, %b3 : i32
-  return %5 : i32
-^bb3(%c:i32, %c2:i32) :
-  %6 = addi %c, %c2 : i32
-  return %6 : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  %7 = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>>
-  fir.dispatch method(%7) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
-  return %zero : i32
-}
-
-func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32) :
-  return %b : i32
-^bb3(%c : i32) :
-  return %c : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  return %zero : i32
-}
-
-func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) :
-  %4 = addi %b, %b2 : i32
-  %5 = muli %4, %b3 : i32
-  %6 = addi %5, %b4 : i32
-  return %6 : i32
-^bb3(%c : i32, %c2 : i32) :
-  %7 = addi %c, %c2 : i32
-  return %7 : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  return %zero : i32
-}
-
-fir.global @global_var : i32 {
-  %0 = constant 1 : i32
-}
-
-fir.global @global_constant constant : i32 {
-  %0 = constant 934 : i32
-}
-
-fir.global @global_derived : !fir.type<mine{f:i32}> {
-  %0 = constant 1 : i32
-  fir.global_entry "f", %0 : i32
-}
-
-fir.dispatch_table @dispatch_tbl {
-  fir.dt_entry "method", @method_impl
-}
diff --git a/test/fir/fir-types.fir b/test/fir/fir-types.fir
deleted file mode 100644
index 7cfcfc6363a7..000000000000
--- a/test/fir/fir-types.fir
+++ /dev/null
@@ -1,38 +0,0 @@
-// Test the FIR operations
-
-func @it1() -> !fir.int<4>
-func @it2() -> !fir.real<8>
-func @it3() -> !fir.complex<8>
-func @it4() -> !fir.logical<1>
-func @it5() -> !fir.char<1>
-
-func @dvd1() -> !fir.type<derived1>
-func @dvd2() -> !fir.type<derived2(p:i32)>
-func @dvd3() -> !fir.type<derived3{f:f32}>
-func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
-func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
-func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
-
-func @arr1() -> !fir.array<10xf32>
-func @arr2() -> !fir.array<10x10xf32>
-func @arr3() -> !fir.array<?xf32>
-func @arr4() -> !fir.array<10x?xf32>
-func @arr5() -> !fir.array<?x?xf32>
-func @arr6() -> !fir.array<*:f32>
-func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
-
-func @mem1() -> !fir.ref<i32>
-func @mem2() -> !fir.ptr<i32>
-func @mem3() -> !fir.heap<i32>
-func @mem4() -> !fir.ref<() -> ()>
-
-func @box1() -> !fir.box<!fir.array<?xf32>>
-func @box2() -> !fir.boxchar<2>
-func @box3() -> !fir.boxproc<(i32, i32) -> i64>
-func @box4() -> !fir.box<none>
-//func @box5() -> !fir.box<()>
-
-func @oth1() -> !fir.dims<1>
-func @oth2() -> !fir.field
-func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
-func @oth4() -> !fir.dims<15>
diff --git a/test/fir/recursive-type.fir b/test/fir/recursive-type.fir
deleted file mode 100644
index 26f76c3d4ddf..000000000000
--- a/test/fir/recursive-type.fir
+++ /dev/null
@@ -1,5 +0,0 @@
-!t = type !fir.type<t {p : !fir.ptr<!fir.type<t>>}>
-
-func @a(%a : !t) {
-  return
-}
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index cb016fc344eb..14728265bc26 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -22,7 +22,7 @@ set(EXE_LIBS
   MLIRAnalysis
   MLIRLoopToStandard
   MLIREDSC
-  MLIRLinalg
+  MLIRLinalgOps
   MLIRParser
   MLIRStandardToLLVM
   MLIRSupport

From 0bd99af8db3ffffba7d2591a243f09e996b1d5f4 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 28 Jan 2020 06:02:13 -0800
Subject: [PATCH 175/345] add more table references in io

---
 include/flang/lower/IO.h |  19 +++++++
 lib/lower/IO.cpp         | 106 +++++++++++++++++++++++++++++++--------
 2 files changed, 104 insertions(+), 21 deletions(-)

diff --git a/include/flang/lower/IO.h b/include/flang/lower/IO.h
index b130e61db58f..45f96e99ee85 100644
--- a/include/flang/lower/IO.h
+++ b/include/flang/lower/IO.h
@@ -41,15 +41,34 @@ namespace lower {
 class AbstractConverter;
 class BridgeImpl;
 
+/// Generate IO call(s) for BACKSPACE
 void genBackspaceStatement(AbstractConverter &, const parser::BackspaceStmt &);
+
+/// Generate IO call(s) for CLOSE
 void genCloseStatement(AbstractConverter &, const parser::CloseStmt &);
+
+/// Generate IO call(s) for ENDFILE
 void genEndfileStatement(AbstractConverter &, const parser::EndfileStmt &);
+
+/// Generate IO call(s) for FLUSH
 void genFlushStatement(AbstractConverter &, const parser::FlushStmt &);
+
+/// Generate IO call(s) for INQUIRE
 void genInquireStatement(AbstractConverter &, const parser::InquireStmt &);
+
+/// Generate IO call(s) for OPEN
 void genOpenStatement(AbstractConverter &, const parser::OpenStmt &);
+
+/// Generate IO call(s) for PRINT
 void genPrintStatement(AbstractConverter &, const parser::PrintStmt &);
+
+/// Generate IO call(s) for READ
 void genReadStatement(AbstractConverter &, const parser::ReadStmt &);
+
+/// Generate IO call(s) for REWIND
 void genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
+
+/// Generate IO call(s) for WRITE
 void genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
 
 } // namespace lower
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index d4d6701ad85a..1081e5bd43f5 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -151,6 +151,8 @@ static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
   return {};
 }
 
+/// Get (or generate) the MLIR FuncOp for a given IO runtime function. This
+/// replaces getIORuntimeFunction.
 template <typename E>
 M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
   auto module = getModule(&builder);
@@ -165,11 +167,19 @@ M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
   return func;
 }
 
+/// Generate a call to end an IO statement
+void genEndIO(M::OpBuilder &builder, M::Location loc, M::Value cookie) {
+  // Terminate IO
+  M::FuncOp endIOFunc{getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder)};
+  llvm::SmallVector<M::Value, 1> endArgs{cookie};
+  builder.create<M::CallOp>(loc, endIOFunc, endArgs);
+}
+
 /// Lower print statement assuming a dummy runtime interface for now.
 void lowerPrintStatement(M::OpBuilder &builder, M::Location loc, int format,
                          M::ValueRange args) {
-  M::FuncOp beginFunc{
-      getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder)};
+  M::FuncOp beginFunc =
+      getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
 
   // Initiate io
   M::Type externalUnitType{builder.getIntegerType(32)};
@@ -181,43 +191,75 @@ void lowerPrintStatement(M::OpBuilder &builder, M::Location loc, int format,
 
   // Call data transfer runtime function
   for (M::Value arg : args) {
+    // FIXME: this loop is still using the older table
     llvm::SmallVector<M::Value, 1> operands{cookie, arg};
     M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg.getType())};
     builder.create<M::CallOp>(loc, outputFunc, operands);
   }
+  endIO(builder, loc, cookie);
+}
 
-  // Terminate IO
-  M::FuncOp endIOFunc{getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder)};
-  llvm::SmallVector<M::Value, 1> endArgs{cookie};
-  builder.create<M::CallOp>(loc, endIOFunc, endArgs);
+int lowerFormat(const Pa::Format &format) {
+  /// FIXME: this is a stub; process the format and return it
+  return {};
+  TODO();
 }
 
-/// FIXME: this is a stub; process the format and return it
-int lowerFormat(const Pa::Format &format) { return 0; }
+M::Value lowerPositionOrFlush(M::OpBuilder &builder, M::Location loc,
+                              const std::list<Pa::PositionOrFlushSpec> &specs) {
+  TODO();
+  return {};
+}
+
+/// Generate IO calls for any of the "position or flush" like IO statements.
+/// This is templatized with a statement type `S` and a key `K` for genericity.
+template <typename S, typename K>
+void genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
+  auto builder = converter.getOpBuilder();
+  auto loc = converter.getCurrentLocation();
+  auto beginFunc = getIORuntimeFunc<K>(builder);
+  auto cookie = lowerPositionOrFlush(builder, loc, stmt.v);
+  genEndIO(builder, converter.getCurrentLocation(), cookie);
+}
 
 } // namespace
 
-void Br::genBackspaceStatement(AbstractConverter &, const Pa::BackspaceStmt &) {
-  TODO();
+void Br::genBackspaceStatement(AbstractConverter &converter,
+                               const Pa::BackspaceStmt &stmt) {
+  genPosOrFlushLikeStmt<mkIOKey(BeginBackspace)>(converter, stmt);
 }
 
-void Br::genCloseStatement(AbstractConverter &, const Pa::CloseStmt &) {
-  TODO();
+void Br::genEndfileStatement(AbstractConverter &converter,
+                             const Pa::EndfileStmt &stmt) {
+  genPosOrFlushLikeStmt<mkIOKey(BeginEndfile)>(converter, stmt);
 }
 
-void Br::genEndfileStatement(AbstractConverter &, const Pa::EndfileStmt &) {
-  TODO();
+void Br::genFlushStatement(AbstractConverter &converter,
+                           const Pa::FlushStmt &stmt) {
+  genPosOrFlushLikeStmt<mkIOKey(BeginFlush)>(converter, stmt);
 }
 
-void Br::genFlushStatement(AbstractConverter &, const Pa::FlushStmt &) {
-  TODO();
+void Br::genRewindStatement(AbstractConverter &converter,
+                            const Pa::RewindStmt &stmt) {
+  genPosOrFlushLikeStmt<mkIOKey(BeginRewind)>(converter, stmt);
 }
 
-void Br::genInquireStatement(AbstractConverter &, const Pa::InquireStmt &) {
+void Br::genOpenStatement(AbstractConverter &converter, const Pa::OpenStmt &) {
+  auto builder = converter.getOpBuilder();
+  M::FuncOp beginFunc;
+  // if (...
+  beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
+  // else
+  beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(builder);
   TODO();
 }
 
-void Br::genOpenStatement(AbstractConverter &, const Pa::OpenStmt &) { TODO(); }
+void Br::genCloseStatement(AbstractConverter &converter,
+                           const Pa::CloseStmt &) {
+  auto builder = converter.getOpBuilder();
+  M::FuncOp beginFunc{getIORuntimeFunc<mkIOKey(BeginClose)>(builder)};
+  TODO();
+}
 
 void Br::genPrintStatement(Br::AbstractConverter &converter,
                            const Pa::PrintStmt &stmt) {
@@ -234,12 +276,34 @@ void Br::genPrintStatement(Br::AbstractConverter &converter,
                       lowerFormat(std::get<Pa::Format>(stmt.t)), args);
 }
 
-void Br::genReadStatement(AbstractConverter &, const Pa::ReadStmt &) { TODO(); }
+void Br::genReadStatement(AbstractConverter &converter, const Pa::ReadStmt &) {
+  auto builder = converter.getOpBuilder();
+  M::FuncOp beginFunc;
+  // if (...
+  beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
+  // else if (...
+  TODO();
+}
 
-void Br::genRewindStatement(AbstractConverter &, const Pa::RewindStmt &) {
+void Br::genWriteStatement(AbstractConverter &converter,
+                           const Pa::WriteStmt &) {
+  auto builder = converter.getOpBuilder();
+  M::FuncOp beginFunc;
+  // if (...
+  beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
+  // else if (...
   TODO();
 }
 
-void Br::genWriteStatement(AbstractConverter &, const Pa::WriteStmt &) {
+void Br::genInquireStatement(AbstractConverter &converter,
+                             const Pa::InquireStmt &) {
+  auto builder = converter.getOpBuilder();
+  M::FuncOp beginFunc;
+  // if (...
+  beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(builder);
+  // else if (...
+  beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireFile)>(builder);
+  // else
+  beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireIoLength)>(builder);
   TODO();
 }

From 2df779c0b3aeb7a40891a2f4214cdceb74c44a91 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 28 Jan 2020 09:35:46 -0800
Subject: [PATCH 176/345] fix compilation issues

---
 lib/lower/IO.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 1081e5bd43f5..424cbfc1eefc 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -196,7 +196,7 @@ void lowerPrintStatement(M::OpBuilder &builder, M::Location loc, int format,
     M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg.getType())};
     builder.create<M::CallOp>(loc, outputFunc, operands);
   }
-  endIO(builder, loc, cookie);
+  genEndIO(builder, loc, cookie);
 }
 
 int lowerFormat(const Pa::Format &format) {
@@ -213,11 +213,12 @@ M::Value lowerPositionOrFlush(M::OpBuilder &builder, M::Location loc,
 
 /// Generate IO calls for any of the "position or flush" like IO statements.
 /// This is templatized with a statement type `S` and a key `K` for genericity.
-template <typename S, typename K>
+template <typename K, typename S>
 void genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
   auto builder = converter.getOpBuilder();
   auto loc = converter.getCurrentLocation();
   auto beginFunc = getIORuntimeFunc<K>(builder);
+  (void)beginFunc; // FIXME
   auto cookie = lowerPositionOrFlush(builder, loc, stmt.v);
   genEndIO(builder, converter.getCurrentLocation(), cookie);
 }

From 28389d18327ad169cd8b9e7e76367bd4e12eb469 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 28 Jan 2020 06:05:03 -0800
Subject: [PATCH 177/345] rebase lib/lower finish header rebase header rebase
 in bbc Complete InternalNames.h KindMapping.h move to include/fir another
 header fix another header rebase fix final header rebase fixes

---
 .../{flang/optimizer => fir}/InternalNames.h  |  0
 .../{flang/optimizer => fir}/KindMapping.h    |  0
 include/flang/lower/ASTBuilder.h              |  4 +--
 include/flang/lower/Bridge.h                  |  2 +-
 include/flang/lower/ConvertType.h             |  2 +-
 include/flang/lower/OpBuilder.h               |  2 +-
 include/flang/lower/Utils.h                   |  2 +-
 lib/fir/InternalNames.cpp                     |  2 +-
 lib/fir/KindMapping.cpp                       |  2 +-
 lib/lower/ASTBuilder.cpp                      |  2 +-
 lib/lower/Bridge.cpp                          |  6 ++--
 lib/lower/ConvertExpr.cpp                     | 14 ++++-----
 lib/lower/ConvertType.cpp                     |  6 ++--
 lib/lower/IO.cpp                              |  5 ++--
 lib/lower/Intrinsics.cpp                      |  2 +-
 lib/lower/Mangler.cpp                         |  6 ++--
 lib/lower/RTBuilder.h                         |  1 +
 lib/optimizer/CodeGen.cpp                     |  4 +--
 lib/optimizer/StdConverter.cpp                |  2 +-
 tools/bbc/bbc.cpp                             | 30 +++++++++----------
 tools/tco/tco.cpp                             |  4 +--
 21 files changed, 50 insertions(+), 48 deletions(-)
 rename include/{flang/optimizer => fir}/InternalNames.h (100%)
 rename include/{flang/optimizer => fir}/KindMapping.h (100%)

diff --git a/include/flang/optimizer/InternalNames.h b/include/fir/InternalNames.h
similarity index 100%
rename from include/flang/optimizer/InternalNames.h
rename to include/fir/InternalNames.h
diff --git a/include/flang/optimizer/KindMapping.h b/include/fir/KindMapping.h
similarity index 100%
rename from include/flang/optimizer/KindMapping.h
rename to include/fir/KindMapping.h
diff --git a/include/flang/lower/ASTBuilder.h b/include/flang/lower/ASTBuilder.h
index 370d136b3076..9dc1ce713fbc 100644
--- a/include/flang/lower/ASTBuilder.h
+++ b/include/flang/lower/ASTBuilder.h
@@ -9,8 +9,8 @@
 #ifndef FORTRAN_LOWER_AST_BUILDER_H_
 #define FORTRAN_LOWER_AST_BUILDER_H_
 
-#include "../../../lib/parser/parse-tree.h"
-#include "../../../lib/semantics/scope.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/scope.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::lower {
diff --git a/include/flang/lower/Bridge.h b/include/flang/lower/Bridge.h
index c37c18aa90e6..767df35f7837 100644
--- a/include/flang/lower/Bridge.h
+++ b/include/flang/lower/Bridge.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_BRIDGE_H_
 #define FORTRAN_LOWER_BRIDGE_H_
 
-#include "../../../lib/common/Fortran.h"
+#include "flang/common/Fortran.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include <memory>
diff --git a/include/flang/lower/ConvertType.h b/include/flang/lower/ConvertType.h
index 083793cb3361..f944c4885ffa 100644
--- a/include/flang/lower/ConvertType.h
+++ b/include/flang/lower/ConvertType.h
@@ -17,7 +17,7 @@
 ///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-#include "../../../lib/common/Fortran.h"
+#include "flang/common/Fortran.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
diff --git a/include/flang/lower/OpBuilder.h b/include/flang/lower/OpBuilder.h
index 462b31a1fbd9..43fdf2040376 100644
--- a/include/flang/lower/OpBuilder.h
+++ b/include/flang/lower/OpBuilder.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_BUILDER_H_
 #define FORTRAN_LOWER_BUILDER_H_
 
-#include "../../../lib/semantics/symbol.h"
+#include "flang/semantics/symbol.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
diff --git a/include/flang/lower/Utils.h b/include/flang/lower/Utils.h
index a1a807da88c3..179f74d2d30c 100644
--- a/include/flang/lower/Utils.h
+++ b/include/flang/lower/Utils.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_UTILS_H
 #define FORTRAN_LOWER_UTILS_H
 
-#include "../../../lib/parser/char-block.h"
+#include "flang/parser/char-block.h"
 #include "llvm/ADT/StringRef.h"
 
 /// Convert an F18 CharBlock to an LLVM StringRef
diff --git a/lib/fir/InternalNames.cpp b/lib/fir/InternalNames.cpp
index 5509374c5538..5680ad8ab940 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/fir/InternalNames.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/InternalNames.h"
+#include "fir/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
diff --git a/lib/fir/KindMapping.cpp b/lib/fir/KindMapping.cpp
index da72e7849295..7e9a07d976f2 100644
--- a/lib/fir/KindMapping.cpp
+++ b/lib/fir/KindMapping.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/KindMapping.h"
+#include "fir/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
diff --git a/lib/lower/ASTBuilder.cpp b/lib/lower/ASTBuilder.cpp
index 7adab9d05d3f..c234c8f02d2b 100644
--- a/lib/lower/ASTBuilder.cpp
+++ b/lib/lower/ASTBuilder.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/ASTBuilder.h"
-#include "../parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree-visitor.h"
 #include <cassert>
 #include <utility>
 
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 23c1db969c1d..6f78f1ecebd7 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -7,11 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Bridge.h"
-#include "../parser/parse-tree.h"
-#include "../semantics/tools.h"
 #include "fir/Dialect/FIRDialect.h"
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
+#include "fir/InternalNames.h"
 #include "flang/lower/ASTBuilder.h"
 #include "flang/lower/ConvertExpr.h"
 #include "flang/lower/ConvertType.h"
@@ -20,7 +19,8 @@
 #include "flang/lower/Mangler.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
-#include "flang/optimizer/InternalNames.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/tools.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index bfadf209f923..4c827a7ceb3e 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -7,20 +7,20 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/ConvertExpr.h"
-#include "../common/default-kinds.h"
-#include "../common/unwrap.h"
-#include "../evaluate/fold.h"
-#include "../evaluate/real.h"
-#include "../semantics/expression.h"
-#include "../semantics/symbol.h"
-#include "../semantics/type.h"
 #include "fir/Dialect/FIRDialect.h"
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
+#include "flang/common/default-kinds.h"
+#include "flang/common/unwrap.h"
+#include "flang/evaluate/fold.h"
+#include "flang/evaluate/real.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/symbol.h"
+#include "flang/semantics/type.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
diff --git a/lib/lower/ConvertType.cpp b/lib/lower/ConvertType.cpp
index 92a5f343e53b..7e529a6aaa2b 100644
--- a/lib/lower/ConvertType.cpp
+++ b/lib/lower/ConvertType.cpp
@@ -7,12 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/ConvertType.h"
-#include "../semantics/expression.h"
-#include "../semantics/tools.h"
-#include "../semantics/type.h"
 #include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/Utils.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/tools.h"
+#include "flang/semantics/type.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 424cbfc1eefc..c3e63265124a 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -8,12 +8,12 @@
 
 #include "flang/lower/IO.h"
 #include "../../runtime/io-api.h"
-#include "../parser/parse-tree.h"
-#include "../semantics/tools.h"
 #include "RTBuilder.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/semantics/tools.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
 
@@ -33,6 +33,7 @@ namespace {
 
 #define mkIOKey(X) mkKey(IONAME(X))
 
+using namespace runtime::io;
 /// Static table of IO runtime calls
 ///
 /// This logical map contains the name and type builder function for each IO
diff --git a/lib/lower/Intrinsics.cpp b/lib/lower/Intrinsics.cpp
index 97bab12d85aa..ecc30ff43116 100644
--- a/lib/lower/Intrinsics.cpp
+++ b/lib/lower/Intrinsics.cpp
@@ -392,7 +392,7 @@ class FunctionDistance {
     if (auto f{t.dyn_cast<M::FloatType>()})
       return f.getWidth();
     // FIXME: Get width another way for fir.real/complex
-    // - use optimizer/KindMapping.h and L::Type
+    // - use fir/KindMapping.h and L::Type
     // - or use evaluate/type.h
     if (auto r{t.dyn_cast<fir::RealType>()})
       return r.getFKind() * 4;
diff --git a/lib/lower/Mangler.cpp b/lib/lower/Mangler.cpp
index 79258e2076d0..8f68134ee029 100644
--- a/lib/lower/Mangler.cpp
+++ b/lib/lower/Mangler.cpp
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Mangler.h"
-#include "../common/reference.h"
-#include "../semantics/tools.h"
+#include "fir/InternalNames.h"
+#include "flang/common/reference.h"
 #include "flang/lower/Utils.h"
-#include "flang/optimizer/InternalNames.h"
+#include "flang/semantics/tools.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/lower/RTBuilder.h b/lib/lower/RTBuilder.h
index 48843c7252fc..30f5de6d264c 100644
--- a/lib/lower/RTBuilder.h
+++ b/lib/lower/RTBuilder.h
@@ -37,6 +37,7 @@ struct errorNoBuilderForType;
 template <typename T>
 static constexpr TypeBuilderFunc getModel() {
   using namespace std::placeholders;
+  using Iostat = typename runtime::io::Iostat;
   if constexpr (std::is_same_v<T, int>) {
     return [](mlir::MLIRContext *c) {
       return mlir::IntegerType::get(8 * sizeof(int), c);
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index 8615656604cc..c6cf539a7ad6 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -11,8 +11,8 @@
 #include "fir/Dialect/FIRDialect.h"
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
-#include "flang/optimizer/InternalNames.h"
-#include "flang/optimizer/KindMapping.h"
+#include "fir/InternalNames.h"
+#include "fir/KindMapping.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
diff --git a/lib/optimizer/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
index 249075c3aa98..0eddcf163f45 100644
--- a/lib/optimizer/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -11,7 +11,7 @@
 #include "fir/Dialect/FIRDialect.h"
 #include "fir/Dialect/FIROpsSupport.h"
 #include "fir/Dialect/FIRType.h"
-#include "flang/optimizer/KindMapping.h"
+#include "fir/KindMapping.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/StandardTypes.h"
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 2cb5cfdd1df1..f3514fd8a959 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -11,27 +11,27 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#include "../../lib/common/Fortran-features.h"
-#include "../../lib/common/default-kinds.h"
-#include "../../lib/parser/characters.h"
-#include "../../lib/parser/dump-parse-tree.h"
-#include "../../lib/parser/message.h"
-#include "../../lib/parser/parse-tree-visitor.h"
-#include "../../lib/parser/parse-tree.h"
-#include "../../lib/parser/parsing.h"
-#include "../../lib/parser/provenance.h"
-#include "../../lib/parser/unparse.h"
-#include "../../lib/semantics/expression.h"
-#include "../../lib/semantics/semantics.h"
-#include "../../lib/semantics/unparse-with-symbols.h"
 #include "fir/Dialect/FIRDialect.h"
+#include "fir/InternalNames.h"
+#include "fir/KindMapping.h"
+#include "flang/common/Fortran-features.h"
+#include "flang/common/default-kinds.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/ConvertExpr.h"
 #include "flang/optimizer/CodeGen/CodeGen.h"
-#include "flang/optimizer/InternalNames.h"
-#include "flang/optimizer/KindMapping.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "flang/optimizer/Transforms/StdConverter.h"
+#include "flang/parser/characters.h"
+#include "flang/parser/dump-parse-tree.h"
+#include "flang/parser/message.h"
+#include "flang/parser/parse-tree-visitor.h"
+#include "flang/parser/parse-tree.h"
+#include "flang/parser/parsing.h"
+#include "flang/parser/provenance.h"
+#include "flang/parser/unparse.h"
+#include "flang/semantics/expression.h"
+#include "flang/semantics/semantics.h"
+#include "flang/semantics/unparse-with-symbols.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 3db3f9d606db..325720d366ec 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -12,9 +12,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "fir/Dialect/FIRDialect.h"
+#include "fir/InternalNames.h"
+#include "fir/KindMapping.h"
 #include "flang/optimizer/CodeGen/CodeGen.h"
-#include "flang/optimizer/InternalNames.h"
-#include "flang/optimizer/KindMapping.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "flang/optimizer/Transforms/StdConverter.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"

From 41e5b48c9eb68abbfdeca3720fbcdc665c34141e Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 28 Jan 2020 10:08:07 -0800
Subject: [PATCH 178/345] get rid of warnings from rebase and merge

changes to support rebase of llvm-project

more on IO

get rid of gratuitous warnings

clang++ doesn't accept std::function as a constexpr

more code cleanup
IO changes

Conflicts:
	lib/lower/NSAliases.h
---
 .clang-format                            |    2 +-
 include/fir/Dialect/FIROps.td            |  492 ++++----
 include/flang/lower/ASTBuilder.h         |   23 +-
 include/flang/lower/Bridge.h             |   22 +-
 include/flang/lower/ConvertType.h        |   21 +
 include/flang/lower/IO.h                 |   62 +-
 lib/fir/CMakeLists.txt                   |    2 +
 lib/fir/Dialect/FIRAttr.cpp              |   38 +-
 lib/fir/Dialect/FIRDialect.cpp           |   30 +-
 lib/fir/Dialect/FIROps.cpp               |  306 ++---
 lib/fir/Dialect/FIRType.cpp              |  474 +++----
 lib/fir/InternalNames.cpp                |  129 +-
 lib/fir/KindMapping.cpp                  |   69 +-
 lib/lower/ASTBuilder.cpp                 |    2 +-
 lib/lower/Bridge.cpp                     |    8 +-
 lib/lower/CMakeLists.txt                 |    2 +-
 lib/lower/ConvertType.cpp                |   78 ++
 lib/lower/IO.cpp                         |  181 ++-
 lib/lower/OpBuilder.cpp                  |  137 +-
 lib/lower/RTBuilder.h                    |   85 +-
 lib/optimizer/CMakeLists.txt             |    2 +-
 lib/optimizer/CodeGen.cpp                | 1467 +++++++++++-----------
 lib/optimizer/StdConverter.cpp           |  150 +--
 lib/optimizer/Transforms/CSE.cpp         |   15 +-
 lib/optimizer/Transforms/MemToReg.cpp    |  202 +--
 lib/optimizer/Transforms/RewriteLoop.cpp |   85 +-
 26 files changed, 2159 insertions(+), 1925 deletions(-)

diff --git a/.clang-format b/.clang-format
index c2673ced5070..c1dfe06fdf57 100644
--- a/.clang-format
+++ b/.clang-format
@@ -10,7 +10,7 @@ AlignTrailingComments: false
 IncludeCategories:
   - Regex:           '^<'
     Priority:        4
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c|fir|mlir|mlir-c)/'
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
     Priority:        3
   - Regex:           '^"(flang|\.\.)/'
     Priority:        2
diff --git a/include/fir/Dialect/FIROps.td b/include/fir/Dialect/FIROps.td
index 3a8e2b3bd761..1d557ff380fa 100644
--- a/include/fir/Dialect/FIROps.td
+++ b/include/fir/Dialect/FIROps.td
@@ -102,14 +102,14 @@ class fir_Op<string mnemonic, list<OpTrait> traits>
 class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   : fir_Op<mnemonic, traits> {
   let parser = [{
-    M::FunctionType type;
-    M::OpAsmParser::OperandType opnd;
+    mlir::FunctionType type;
+    mlir::OpAsmParser::OperandType opnd;
     if (parser.parseOperand(opnd) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(opnd, type.getInput(0), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -126,7 +126,7 @@ def fir_AllocateOpBuilder : OpBuilder<
   "ArrayRef<Value> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", M::TypeAttr::get(inType));
+    result.addAttribute("in_type", mlir::TypeAttr::get(inType));
     result.addOperands(sizes);
     for (auto namedAttr : attributes)
       result.addAttribute(namedAttr.first, namedAttr.second);
@@ -137,7 +137,7 @@ def fir_NamedAllocateOpBuilder : OpBuilder<
   "ArrayRef<Value> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", M::TypeAttr::get(inType));
+    result.addAttribute("in_type", mlir::TypeAttr::get(inType));
     result.addAttribute("name", builder->getStringAttr(name));
     result.addOperands(sizes);
     for (auto namedAttr : attributes)
@@ -185,41 +185,42 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
     Arguments<(ins TypeAttr:$in_type, Variadic<AnyIntegerType>:$args)> {
 
   let parser = [{
-    M::Type intype;
+    mlir::Type intype;
     if (parser.parseType(intype))
-      return M::failure();
+      return mlir::failure();
     auto &builder = parser.getBuilder();
-    result.addAttribute("in_type", M::TypeAttr::get(intype));
-    L::SmallVector<M::OpAsmParser::OperandType, 8> operands;
-    L::SmallVector<M::Type, 8> typeVec;
+    result.addAttribute("in_type", mlir::TypeAttr::get(intype));
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+    llvm::SmallVector<mlir::Type, 8> typeVec;
     bool hasOperands = false;
     if (!parser.parseOptionalLParen()) {
-      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None) ||
+      if (parser.parseOperandList(operands,
+                                  mlir::OpAsmParser::Delimiter::None) ||
           parser.parseRParen())
-        return M::failure();
+        return mlir::failure();
       auto lens = builder.getI32IntegerAttr(operands.size());
       result.addAttribute(lenpName(), lens);
       hasOperands = true;
     }
     if (!parser.parseOptionalComma()) {
-      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None))
-        return M::failure();
+      if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None))
+        return mlir::failure();
       hasOperands = true;
     }
     if (hasOperands &&
         parser.resolveOperands(operands, builder.getIndexType(),
             parser.getNameLoc(), result.operands))
-      return M::failure();
-    M::Type restype = wrapResultType(intype);
+      return mlir::failure();
+    mlir::Type restype = wrapResultType(intype);
     if (!restype) {
       parser.emitError(parser.getNameLoc(), "invalid allocate type: ")
           << intype;
-      return M::failure();
+      return mlir::failure();
     }
     if (parser.parseOptionalAttrDict(result.attributes) ||
         parser.addTypeToList(restype, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -272,10 +273,10 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
   }];
 
   let verifier = [{
-    M::Type outType = getType();
+    mlir::Type outType = getType();
     if (!outType.dyn_cast<fir::ReferenceType>())
       return emitOpError("must be a !fir.ref type");
-    return M::success();
+    return mlir::success();
   }];
 
   let extraClassDeclaration = extraAllocClassDeclaration#[{
@@ -306,18 +307,18 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
   >];
 
   let parser = [{
-    M::Type type;
-    M::OpAsmParser::OperandType oper;
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType oper;
     if (parser.parseOperand(oper) ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, type, result.operands))
-       return M::failure();
-    M::Type eleTy;
+       return mlir::failure();
+    mlir::Type eleTy;
     if (getElementOf(eleTy, type) ||
         parser.addTypeToList(eleTy, result.types))
-       return M::failure();
-    return M::success();
+       return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -343,9 +344,9 @@ def fir_StoreOp : fir_Op<"store", []>,
   }];
 
   let parser = [{
-    M::Type type;
-    M::OpAsmParser::OperandType oper;
-    M::OpAsmParser::OperandType store;
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType oper;
+    mlir::OpAsmParser::OperandType store;
     if (parser.parseOperand(oper) ||
         parser.parseKeyword("to") ||
         parser.parseOperand(store) ||
@@ -354,8 +355,8 @@ def fir_StoreOp : fir_Op<"store", []>,
         parser.resolveOperand(oper, elementType(type),
           result.operands) ||
         parser.resolveOperand(store, type, result.operands))
-       return M::failure();
-    return M::success();
+       return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -382,11 +383,11 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   }];
 
   let parser = [{
-    M::Type intype;
+    mlir::Type intype;
     if (parser.parseType(intype) ||
         parser.addTypeToList(intype, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{ p << getOperationName() << ' ' << getType(); }];
@@ -394,7 +395,7 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   let verifier = [{
     if (auto ref = getType().dyn_cast<fir::ReferenceType>())
       return emitOpError("undefined values of type !fir.ref not allowed");
-    return M::success();
+    return mlir::success();
   }];
 }
 
@@ -412,10 +413,10 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
   }];
 
   let verifier = [{
-    M::Type outType = getType();
+    mlir::Type outType = getType();
     if (!outType.dyn_cast<fir::HeapType>())
       return emitOpError("must be a !fir.heap type");
-    return M::success();
+    return mlir::success();
   }];
 
   let extraClassDeclaration = extraAllocClassDeclaration#[{
@@ -439,14 +440,14 @@ def fir_FreeMemOp : fir_Op<"freemem", []>,
   }];
 
   let parser = [{
-    M::Type type;
-    M::OpAsmParser::OperandType oper;
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType oper;
     if (parser.parseOperand(oper) ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, type, result.operands))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -497,47 +498,47 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
   let parser = [{
-    M::OpAsmParser::OperandType selector;
-    M::Type type;
+    mlir::OpAsmParser::OperandType selector;
+    mlir::Type type;
     if (parseSelector(parser, result, selector, type))
-      return M::failure();
+      return mlir::failure();
 
-    llvm::SmallVector<M::Attribute, 4> ivalues;
-    llvm::SmallVector<M::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<M::Value, 4>, 4> destArgs;
+    llvm::SmallVector<mlir::Attribute, 4> ivalues;
+    llvm::SmallVector<mlir::Block *, 4> dests;
+    llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
     while (true) {
-      M::Attribute ivalue; // Integer or Unit
-      M::Block *dest;
-      llvm::SmallVector<M::Value, 4> destArg;
-      llvm::SmallVector<M::NamedAttribute, 1> temp;
+      mlir::Attribute ivalue; // Integer or Unit
+      mlir::Block *dest;
+      llvm::SmallVector<mlir::Value, 4> destArg;
+      llvm::SmallVector<mlir::NamedAttribute, 1> temp;
       if (parser.parseAttribute(ivalue, "i", temp) ||
           parser.parseComma() ||
           parser.parseSuccessorAndUseList(dest, destArg))
-        return M::failure();
+        return mlir::failure();
       ivalues.push_back(ivalue);
       dests.push_back(dest);
       destArgs.push_back(destArg);
       if (!parser.parseOptionalRSquare())
         break;
       if (parser.parseComma())
-        return M::failure();
+        return mlir::failure();
     }
     result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(ivalues));
     for (unsigned i = 0, count = dests.size(); i != count; ++i)
       result.addSuccessor(dests[i], destArgs[i]);
-    return M::success();
+    return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       if (i)
         p << ", ";
       auto &attr = cases[i];
-      if (auto intAttr = attr.dyn_cast_or_null<M::IntegerAttr>())
+      if (auto intAttr = attr.dyn_cast_or_null<mlir::IntegerAttr>())
         p << intAttr.getValue();
       else
         p.printAttribute(attr);
@@ -549,22 +550,22 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
   }];
 
   let verifier = [{
-    if (!(getSelector().getType().isa<M::IntegerType>() ||
-          getSelector().getType().isa<M::IndexType>() ||
+    if (!(getSelector().getType().isa<mlir::IntegerType>() ||
+          getSelector().getType().isa<mlir::IndexType>() ||
           getSelector().getType().isa<fir::IntType>()))
       return emitOpError("must be an integer");
-    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.dyn_cast_or_null<M::IntegerAttr>()) {
+      if (attr.dyn_cast_or_null<mlir::IntegerAttr>()) {
         // ok
-      } else if (attr.dyn_cast_or_null<M::UnitAttr>()) {
+      } else if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
         // ok
       } else {
         return emitOpError("invalid case alternative");
       }
     }
-    return M::success();
+    return mlir::success();
   }];
 
   let extraClassDeclaration = extraSwitchClassDeclaration;
@@ -607,71 +608,71 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
   }];
 
   let parser = [{
-    M::OpAsmParser::OperandType selector;
-    M::Type type;
+    mlir::OpAsmParser::OperandType selector;
+    mlir::Type type;
     if (parseSelector(parser, result, selector, type))
-      return M::failure();
+      return mlir::failure();
 
-    llvm::SmallVector<M::Attribute, 4> attrs;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 4> opers;
-    llvm::SmallVector<M::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<M::Value, 4>, 4> destArgs;
+    llvm::SmallVector<mlir::Attribute, 4> attrs;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> opers;
+    llvm::SmallVector<mlir::Block *, 4> dests;
+    llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
     while (true) {
-      M::Attribute attr;
-      M::Block *dest;
-      llvm::SmallVector<M::Value, 4> destArg;
-      llvm::SmallVector<M::NamedAttribute, 1> temp;
+      mlir::Attribute attr;
+      mlir::Block *dest;
+      llvm::SmallVector<mlir::Value, 4> destArg;
+      llvm::SmallVector<mlir::NamedAttribute, 1> temp;
       if (parser.parseAttribute(attr, "a", temp) ||
           isValidCaseAttr(attr) ||
           parser.parseComma())
-        return M::failure();
+        return mlir::failure();
       attrs.push_back(attr);
-      if (attr.dyn_cast_or_null<M::UnitAttr>()) {
+      if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
         // do nothing
       } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
-        M::OpAsmParser::OperandType oper1;
-        M::OpAsmParser::OperandType oper2;
+        mlir::OpAsmParser::OperandType oper1;
+        mlir::OpAsmParser::OperandType oper2;
         if (parser.parseOperand(oper1) ||
             parser.parseComma() ||
             parser.parseOperand(oper2) ||
             parser.parseComma())
-          return M::failure();
+          return mlir::failure();
         opers.push_back(oper1);
         opers.push_back(oper2);
       } else {
-        M::OpAsmParser::OperandType oper;
+        mlir::OpAsmParser::OperandType oper;
         if (parser.parseOperand(oper) ||
             parser.parseComma())
-          return M::failure();
+          return mlir::failure();
         opers.push_back(oper);
       }
       if (parser.parseSuccessorAndUseList(dest, destArg))
-        return M::failure();
+        return mlir::failure();
       dests.push_back(dest);
       destArgs.push_back(destArg);
       if (!parser.parseOptionalRSquare())
         break;
       if (parser.parseComma())
-        return M::failure();
+        return mlir::failure();
     }
     result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(attrs));
     if (parser.resolveOperands(opers, type, result.operands))
-      return M::failure();
+      return mlir::failure();
     for (unsigned i = 0, count = dests.size(); i != count; ++i)
       result.addSuccessor(dests[i], destArgs[i]);
-    return M::success();
+    return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       if (i)
         p << ", ";
       p << cases[i] << ", ";
-      if (!cases[i].dyn_cast_or_null<M::UnitAttr>()) {
+      if (!cases[i].dyn_cast_or_null<mlir::UnitAttr>()) {
         p.printOperand(getCaseArg(i, 0));
         p << ", ";
         if (cases[i].dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
@@ -686,8 +687,8 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
   }];
 
   let verifier = [{
-    if (!(getSelector().getType().isa<M::IntegerType>() ||
-          getSelector().getType().isa<M::IndexType>() ||
+    if (!(getSelector().getType().isa<mlir::IntegerType>() ||
+          getSelector().getType().isa<mlir::IndexType>() ||
           getSelector().getType().isa<fir::IntType>() ||
           getSelector().getType().isa<fir::LogicalType>() ||
           getSelector().getType().isa<fir::CharacterType>()))
@@ -695,7 +696,7 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       // TODO: add checks!
     }
-    return M::success();
+    return mlir::success();
   }];
 
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
@@ -723,42 +724,42 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
   }];
 
   let parser = [{
-    M::OpAsmParser::OperandType selector;
-    M::Type type;
+    mlir::OpAsmParser::OperandType selector;
+    mlir::Type type;
     if (parseSelector(parser, result, selector, type))
-      return M::failure();
+      return mlir::failure();
 
-    llvm::SmallVector<M::Attribute, 4> attrs;
-    llvm::SmallVector<M::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<M::Value, 4>, 4> destArgs;
+    llvm::SmallVector<mlir::Attribute, 4> attrs;
+    llvm::SmallVector<mlir::Block *, 4> dests;
+    llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
     while (true) {
-      M::Attribute attr;
-      M::Block *dest;
-      llvm::SmallVector<M::Value, 4> destArg;
-      llvm::SmallVector<M::NamedAttribute, 1> temp;
+      mlir::Attribute attr;
+      mlir::Block *dest;
+      llvm::SmallVector<mlir::Value, 4> destArg;
+      llvm::SmallVector<mlir::NamedAttribute, 1> temp;
       if (parser.parseAttribute(attr, "a", temp) ||
           parser.parseComma() ||
           parser.parseSuccessorAndUseList(dest, destArg))
-        return M::failure();
+        return mlir::failure();
       attrs.push_back(attr);
       dests.push_back(dest);
       destArgs.push_back(destArg);
       if (!parser.parseOptionalRSquare())
         break;
       if (parser.parseComma())
-        return M::failure();
+        return mlir::failure();
     }
     result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(attrs));
     for (unsigned i = 0, count = dests.size(); i != count; ++i)
       result.addSuccessor(dests[i], destArgs[i]);
-    return M::success();
+    return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       if (i)
         p << ", ";
@@ -772,18 +773,18 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
   let verifier = [{
     if (!(getSelector().getType().isa<fir::BoxType>()))
       return emitOpError("must be a boxed type");
-    auto cases = getAttrOfType<M::ArrayAttr>(AttrName).getValue();
+    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
       auto &attr = cases[i];
       if (attr.dyn_cast_or_null<fir::ExactTypeAttr>() ||
           attr.dyn_cast_or_null<fir::SubclassAttr>() ||
-          attr.dyn_cast_or_null<M::UnitAttr>()) {
+          attr.dyn_cast_or_null<mlir::UnitAttr>()) {
         // ok
       } else {
         return emitOpError("invalid type-case alternative");
       }
     }
-    return M::success();
+    return mlir::success();
   }];
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
@@ -799,7 +800,7 @@ def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
   }];
 
   let parser = [{
-    return M::success();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -831,37 +832,38 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 8> operands;
-    M::OpAsmParser::OperandType memref;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+    mlir::OpAsmParser::OperandType memref;
     if (parser.parseOperand(memref))
-      return M::failure();
+      return mlir::failure();
     operands.push_back(memref);
     auto &builder = parser.getBuilder();
     if (!parser.parseOptionalLParen()) {
-      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None) ||
+      if (parser.parseOperandList(operands,
+                                  mlir::OpAsmParser::Delimiter::None) ||
           parser.parseRParen())
-        return M::failure();
+        return mlir::failure();
       auto lens = builder.getI32IntegerAttr(operands.size());
       result.addAttribute(lenpName(), lens);
     }
     if (!parser.parseOptionalComma()) {
-      M::OpAsmParser::OperandType dims;
+      mlir::OpAsmParser::OperandType dims;
       if (parser.parseOperand(dims))
-        return M::failure();
+        return mlir::failure();
       operands.push_back(dims);
     } else if (!parser.parseOptionalLSquare()) {
-      M::AffineMapAttr map;
+      mlir::AffineMapAttr map;
       if (parser.parseAttribute(map, "layout_map", result.attributes) ||
           parser.parseRSquare())
-        return M::failure();
+        return mlir::failure();
     }
     if (parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -919,16 +921,16 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 2> operands;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
     if (parser.parseOperandList(operands, 2,
-            M::OpAsmParser::Delimiter::None) ||
+            mlir::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -943,8 +945,8 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
   let verifier = [{
     auto eleTy = elementTypeOf(memref().getType());
     if (!eleTy.dyn_cast<CharacterType>())
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 }
 
@@ -972,36 +974,36 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::SymbolRefAttr procRef;
+    mlir::SymbolRefAttr procRef;
     if (parser.parseAttribute(procRef, "funcname", result.attributes))
-      return M::failure();
+      return mlir::failure();
     bool hasTuple = false;
-    M::OpAsmParser::OperandType tupleRef;
+    mlir::OpAsmParser::OperandType tupleRef;
     if (!parser.parseOptionalComma()) {
       if (parser.parseOperand(tupleRef))
-        return M::failure();
+        return mlir::failure();
       hasTuple = true;
     }
-    M::FunctionType type;
+    mlir::FunctionType type;
     if (parser.parseColon() ||
         parser.parseLParen() ||
         parser.parseType(type))
-      return M::failure();
-    result.addAttribute("functype", M::TypeAttr::get(type));
+      return mlir::failure();
+    result.addAttribute("functype", mlir::TypeAttr::get(type));
     if (hasTuple) {
-      M::Type tupleType;
+      mlir::Type tupleType;
       if (parser.parseComma() ||
           parser.parseType(tupleType) ||
           parser.resolveOperand(tupleRef, tupleType, result.operands))
-        return M::failure();
+        return mlir::failure();
     }
-    M::Type boxType;
+    mlir::Type boxType;
     if (parser.parseRParen() ||
         parser.parseArrow() ||
         parser.parseType(boxType) ||
         parser.addTypesToList(boxType, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1021,13 +1023,13 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
     // host bindings (optional) must be a reference to a tuple
     if (auto h = host()) {
       if (auto r = h.getType().dyn_cast<ReferenceType>()) {
-        if (!r.getEleTy().dyn_cast<M::TupleType>())
-          return M::failure();
+        if (!r.getEleTy().dyn_cast<mlir::TupleType>())
+          return mlir::failure();
       } else {
-        return M::failure();
+        return mlir::failure();
       }
     }
-    return M::success();
+    return mlir::success();
   }];
 }
 
@@ -1077,14 +1079,14 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    M::OpAsmParser::OperandType opnd;
+    mlir::FunctionType type;
+    mlir::OpAsmParser::OperandType opnd;
     if (parser.parseOperand(opnd) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(opnd, type.getInput(0), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1117,16 +1119,16 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 2> operands;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
     if (parser.parseOperandList(operands, 2,
-            M::OpAsmParser::Delimiter::None) ||
+            mlir::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1234,16 +1236,16 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
     if (parser.parseOperandList(operands,
-            M::OpAsmParser::Delimiter::None) ||
+            mlir::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1265,7 +1267,7 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
           if (!ref().getType().dyn_cast<BoxType>())
             return emitOpError("len_param_index must be used on box type");
         }
-    return M::success();
+    return mlir::success();
   }];
 }
 
@@ -1279,16 +1281,16 @@ def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
     if (parser.parseOperandList(operands,
-            M::OpAsmParser::Delimiter::None) ||
+            mlir::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1328,34 +1330,35 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
   let parser = [{
     llvm::StringRef fieldName;
     auto &builder = parser.getBuilder();
-    M::Type recty;
+    mlir::Type recty;
     if (parser.parseOptionalKeyword(&fieldName) ||
         parser.parseComma() ||
         parser.parseType(recty))
-      return M::failure();
+      return mlir::failure();
     result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
     if (!recty.dyn_cast<RecordType>())
-      return M::failure();
-    result.addAttribute(typeAttrName(), M::TypeAttr::get(recty));
+      return mlir::failure();
+    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(recty));
     if (!parser.parseOptionalLParen()) {
-      L::SmallVector<M::OpAsmParser::OperandType, 8> operands;
-      L::SmallVector<M::Type, 8> types;
+      llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+      llvm::SmallVector<mlir::Type, 8> types;
       auto loc = parser.getNameLoc();
-      if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::None) ||
+      if (parser.parseOperandList(operands,
+                                  mlir::OpAsmParser::Delimiter::None) ||
           parser.parseRParen() ||
           parser.parseColonTypeList(types) ||
           parser.resolveOperands(operands, types, loc, result.operands))
-        return M::failure();
+        return mlir::failure();
     }
-    M::Type fieldType = fir::FieldType::get(builder.getContext());
+    mlir::Type fieldType = fir::FieldType::get(builder.getContext());
     if (parser.addTypeToList(fieldType, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' '
-      << getAttrOfType<M::StringAttr>(fieldAttrName()).getValue() << ", "
+      << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
       << getAttr(typeAttrName());
     if (getNumOperands()) {
       p << '(';
@@ -1393,16 +1396,16 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 6> operands;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 6> operands;
     if (parser.parseOperandList(operands,
-            M::OpAsmParser::Delimiter::None) ||
+            mlir::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1423,16 +1426,16 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
     if (parser.parseOperandList(operands,
-            M::OpAsmParser::Delimiter::None) ||
+            mlir::OpAsmParser::Delimiter::None) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1470,24 +1473,24 @@ def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]>,
   let parser = [{
     llvm::StringRef fieldName;
     auto &builder = parser.getBuilder();
-    M::Type recty;
+    mlir::Type recty;
     if (parser.parseOptionalKeyword(&fieldName) ||
         parser.parseComma() ||
         parser.parseType(recty))
-      return M::failure();
+      return mlir::failure();
     result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
     if (!recty.dyn_cast<RecordType>())
-      return M::failure();
-    result.addAttribute(typeAttrName(), M::TypeAttr::get(recty));
-    M::Type lenType = fir::LenType::get(builder.getContext());
+      return mlir::failure();
+    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(recty));
+    mlir::Type lenType = fir::LenType::get(builder.getContext());
     if (parser.addTypeToList(lenType, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' '
-      << getAttrOfType<M::StringAttr>(fieldAttrName()).getValue() << ", "
+      << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
       << getAttr(typeAttrName());
   }];
 
@@ -1542,7 +1545,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     auto step = optstep();
     if (step.begin() != step.end()) {
       auto *s = (*step.begin()).getDefiningOp();
-      if (auto cst = dyn_cast_or_null<M::ConstantIndexOp>(s))
+      if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s))
         if (cst.getValue() == 0)
           return emitOpError("constant step operand must be nonzero");
     }
@@ -1554,7 +1557,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
         !body->getArgument(0).getType().isIndex())
       return emitOpError("expected body to have a single index argument for "
                          "the induction variable");
-    return M::success();
+    return mlir::success();
   }];
 
   let extraClassDeclaration = [{
@@ -1614,7 +1617,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
         if (b.getNumArguments() != 0)
           return emitOpError("requires that child entry blocks have no args");
     }
-    return M::success();
+    return mlir::success();
   }];
 
   let extraClassDeclaration = [{
@@ -1658,27 +1661,28 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
   }];
 
   let parser = [{
-    M::FunctionType calleeType;
-    L::SmallVector<M::OpAsmParser::OperandType, 4> operands;
+    mlir::FunctionType calleeType;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
     auto calleeLoc = parser.getNameLoc();
     llvm::StringRef calleeName;
     if (parser.parseOptionalKeyword(&calleeName)) {
-      M::StringAttr calleeAttr;
+      mlir::StringAttr calleeAttr;
       if (parser.parseAttribute(calleeAttr, "method", result.attributes))
-        return M::failure();
+        return mlir::failure();
     } else {
       result.addAttribute("method",
           parser.getBuilder().getStringAttr(calleeName));
     }
-    if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
+    if (parser.parseOperandList(operands,
+                                mlir::OpAsmParser::Delimiter::Paren) ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(calleeType) ||
         parser.addTypesToList(calleeType.getResults(), result.types) ||
         parser.resolveOperands(
             operands, calleeType.getInputs(), calleeLoc, result.operands))
-      return M::failure();
-    result.addAttribute("fn_type", M::TypeAttr::get(calleeType));
-    return M::success();
+      return mlir::failure();
+    result.addAttribute("fn_type", mlir::TypeAttr::get(calleeType));
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1690,9 +1694,9 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
     }
     p << ')';
     p.printOptionalAttrDict(getAttrs(), {"fn_type", "method"});
-    llvm::SmallVector<M::Type, 2> resTy(getResultTypes());
-    llvm::SmallVector<M::Type, 8> argTy(getOperandTypes());
-    p << " : " << M::FunctionType::get(argTy, resTy, getContext());
+    auto resTy{getResultTypes()};
+    llvm::SmallVector<mlir::Type, 8> argTy(getOperandTypes());
+    p << " : " << mlir::FunctionType::get(argTy, resTy, getContext());
   }];
 
   let extraClassDeclaration = [{
@@ -1718,11 +1722,11 @@ def fir_ConstantOp : fir_Op<"constant", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::StringAttr attr;
+    mlir::StringAttr attr;
     if (parser.parseAttribute(attr, value(), result.attributes) ||
         parser.addTypesToList(attr.getType(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1873,16 +1877,16 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
   let arguments = (ins SymbolRefAttr:$symbol);
 
   let parser = [{
-    M::SymbolRefAttr attr;
-    M::Type type;
+    mlir::SymbolRefAttr attr;
+    mlir::Type type;
     if (parser.parseLParen() ||
         parser.parseAttribute(attr, "symbol", result.attributes) ||
         parser.parseRParen() ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.addTypeToList(type, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let printer = [{
@@ -1901,17 +1905,17 @@ def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::FunctionType type;
-    llvm::SmallVector<M::OpAsmParser::OperandType, 1> operands;
+    mlir::FunctionType type;
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 1> operands;
     if (parser.parseOperandList(operands, 1,
-            M::OpAsmParser::Delimiter::None) ||
+            mlir::OpAsmParser::Delimiter::None) ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
   let printer = [{
     p << getOperationName() << ' ';
@@ -1946,14 +1950,14 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]>,
   }];
 
   let parser = [{
-    M::Type intype;
+    mlir::Type intype;
     if (parser.parseType(intype))
-      return M::failure();
-    result.addAttribute("in_type", M::TypeAttr::get(intype));
-    M::Type restype = TypeDescType::get(intype);
+      return mlir::failure();
+    result.addAttribute("in_type", mlir::TypeAttr::get(intype));
+    mlir::Type restype = TypeDescType::get(intype);
     if (parser.addTypeToList(restype, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
 
   let builders = [
@@ -1966,14 +1970,14 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]>,
   }];
 
   let verifier = [{
-    M::Type resultTy = getType();
+    mlir::Type resultTy = getType();
     if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
       if (tdesc.getOfTy() != getInType())
         return emitOpError("wrapped type mismatched");
     } else {
       return emitOpError("must be !fir.tdesc type");
     }
-    return M::success();
+    return mlir::success();
   }];
 
   let extraClassDeclaration = [{
@@ -1995,14 +1999,14 @@ def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
   }];
 
   let parser = [{
-    M::Type type;
-    M::OpAsmParser::OperandType opnd;
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType opnd;
     if (parser.parseOperand(opnd) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(opnd, type, result.operands) ||
         parser.addTypeToList(type, result.types))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
   let printer = [{
     p << getOperationName() << ' ';
@@ -2022,13 +2026,13 @@ def fir_GlobalEntryOp : fir_Op<"global_entry", []>,
   }];
 
   let parser = [{
-    M::Type type;
-    M::OpAsmParser::OperandType constant;
+    mlir::Type type;
+    mlir::OpAsmParser::OperandType constant;
     llvm::StringRef fieldName;
     if (parser.parseOptionalKeyword(&fieldName)) {
-      M::StringAttr fieldAttr;
+      mlir::StringAttr fieldAttr;
       if (parser.parseAttribute(fieldAttr, "field", result.attributes))
-        return M::failure();
+        return mlir::failure();
     } else {
       result.addAttribute("field",
           parser.getBuilder().getStringAttr(fieldName));
@@ -2038,9 +2042,9 @@ def fir_GlobalEntryOp : fir_Op<"global_entry", []>,
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(constant, type, result.operands))
-      return M::failure();
-    result.addAttribute("in_type", M::TypeAttr::get(type));
-    return M::success();
+      return mlir::failure();
+    result.addAttribute("in_type", mlir::TypeAttr::get(type));
+    return mlir::success();
   }];
   let printer = [{
     p << getOperationName() << ' ' << getAttr("field") << ", ";
@@ -2063,20 +2067,20 @@ def fir_DTEntryOp : fir_Op<"dt_entry", []>,
   }];
 
   let parser = [{
-    M::SymbolRefAttr calleeAttr;
+    mlir::SymbolRefAttr calleeAttr;
     llvm::StringRef methodName;
     if (parser.parseOptionalKeyword(&methodName)) {
-      M::StringAttr methodAttr;
+      mlir::StringAttr methodAttr;
       if (parser.parseAttribute(methodAttr, "method", result.attributes))
-        return M::failure();
+        return mlir::failure();
     } else {
       result.addAttribute("method",
           parser.getBuilder().getStringAttr(methodName));
     }
     if (parser.parseComma() ||
         parser.parseAttribute(calleeAttr, "proc", result.attributes))
-      return M::failure();
-    return M::success();
+      return mlir::failure();
+    return mlir::success();
   }];
   let printer = [{
     p << getOperationName() << ' ' << getAttr("method") << ", "
diff --git a/include/flang/lower/ASTBuilder.h b/include/flang/lower/ASTBuilder.h
index 9dc1ce713fbc..d99d57daf8f6 100644
--- a/include/flang/lower/ASTBuilder.h
+++ b/include/flang/lower/ASTBuilder.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/ast-builder.h ---------------------------------*- C++ -*-===//
+//===-- flang/lower/AstBuilder.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.
@@ -200,9 +200,8 @@ struct Evaluation {
 
   /// Set that the construct `cstr` (if not a nullptr) has branches.
   static void setBranches(Evaluation *cstr) {
-    if (cstr) {
+    if (cstr)
       cstr->setBranches();
-    }
   }
 
   EvalVariant u;
@@ -256,14 +255,14 @@ struct FunctionLikeUnit : public ProgramUnit {
     return std::get_if<const parser::Statement<parser::EndProgramStmt> *>(
         &funStmts.back());
   }
-  const parser::FunctionStmt *isFunction() {
-    return isA<parser::FunctionStmt>();
+  const parser::FunctionStmt *getFunction() {
+    return getA<parser::FunctionStmt>();
   }
-  const parser::SubroutineStmt *isSubroutine() {
-    return isA<parser::SubroutineStmt>();
+  const parser::SubroutineStmt *getSubroutine() {
+    return getA<parser::SubroutineStmt>();
   }
-  const parser::MpSubprogramStmt *isMPSubp() {
-    return isA<parser::MpSubprogramStmt>();
+  const parser::MpSubprogramStmt *getMPSubp() {
+    return getA<parser::MpSubprogramStmt>();
   }
 
   const semantics::Scope *scope{nullptr}; // scope from front-end
@@ -273,10 +272,9 @@ struct FunctionLikeUnit : public ProgramUnit {
 
 private:
   template <typename A>
-  const A *isA() {
-    if (auto p = std::get_if<const parser::Statement<A> *>(&funStmts.front())) {
+  const A *getA() {
+    if (auto p = std::get_if<const parser::Statement<A> *>(&funStmts.front()))
       return &(*p)->statement;
-    }
     return nullptr;
   }
 };
@@ -300,6 +298,7 @@ struct ModuleLikeUnit : public ProgramUnit {
   std::list<FunctionLikeUnit> funcs;
 };
 
+// TODO: lower data too
 struct BlockDataUnit : public ProgramUnit {
   BlockDataUnit(const parser::BlockData &db, const ParentType &parent);
 };
diff --git a/include/flang/lower/Bridge.h b/include/flang/lower/Bridge.h
index 767df35f7837..dd0f19099d4c 100644
--- a/include/flang/lower/Bridge.h
+++ b/include/flang/lower/Bridge.h
@@ -5,6 +5,14 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+///
+/// \file
+/// Implements lowering. Convert Fortran source to
+/// [MLIR](https://github.com/tensorflow/mlir).
+///
+/// [Coding style](https://llvm.org/docs/CodingStandards.html)
+///
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_BRIDGE_H_
 #define FORTRAN_LOWER_BRIDGE_H_
@@ -14,11 +22,6 @@
 #include "mlir/IR/Module.h"
 #include <memory>
 
-/// Implement the burnside bridge from Fortran to
-/// [MLIR](https://github.com/tensorflow/mlir).
-///
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
-
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
@@ -38,7 +41,7 @@ struct Program;
 } // namespace parser
 namespace semantics {
 class Symbol;
-}
+} // namespace semantics
 } // namespace Fortran
 
 namespace llvm {
@@ -67,9 +70,16 @@ class AbstractConverter {
   /// Generate the address of the location holding the expression
   virtual mlir::Value genExprAddr(const SomeExpr &,
                                   mlir::Location *loc = nullptr) = 0;
+  mlir::Value genExprAddr(const SomeExpr *someExpr, mlir::Location loc) {
+    return genExprAddr(*someExpr, &loc);
+  }
+
   /// Generate the computations of the expression to produce a value
   virtual mlir::Value genExprValue(const SomeExpr &,
                                    mlir::Location *loc = nullptr) = 0;
+  mlir::Value genExprValue(const SomeExpr *someExpr, mlir::Location loc) {
+    return genExprValue(*someExpr, &loc);
+  }
 
   //
   // Types
diff --git a/include/flang/lower/ConvertType.h b/include/flang/lower/ConvertType.h
index f944c4885ffa..d29d8979d7d2 100644
--- a/include/flang/lower/ConvertType.h
+++ b/include/flang/lower/ConvertType.h
@@ -116,6 +116,27 @@ mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 // a memory reference to a sequence type.
 mlir::Type getSequenceRefType(mlir::Type referenceType);
 
+// Models for C (language) types
+
+mlir::Type getModelForInt(mlir::MLIRContext *);
+mlir::Type getModelForIntRef(mlir::MLIRContext *);
+mlir::Type getModelForIostat(mlir::MLIRContext *);
+mlir::Type getModelForCharPtr(mlir::MLIRContext *);
+mlir::Type getModelForConstCharPtr(mlir::MLIRContext *);
+mlir::Type getModelForInt64(mlir::MLIRContext *);
+mlir::Type getModelForInt64Ref(mlir::MLIRContext *);
+mlir::Type getModelForSize(mlir::MLIRContext *);
+mlir::Type getModelForCookie(mlir::MLIRContext *);
+mlir::Type getModelForDouble(mlir::MLIRContext *);
+mlir::Type getModelForDoubleRef(mlir::MLIRContext *);
+mlir::Type getModelForFloat(mlir::MLIRContext *);
+mlir::Type getModelForFloatRef(mlir::MLIRContext *);
+mlir::Type getModelForBool(mlir::MLIRContext *);
+mlir::Type getModelForBoolRef(mlir::MLIRContext *);
+mlir::Type getModelForDescriptor(mlir::MLIRContext *);
+mlir::Type getModelForNamelistGroup(mlir::MLIRContext *);
+mlir::Type getModelForVoid(mlir::MLIRContext *);
+
 } // namespace lower
 } // namespace Fortran
 
diff --git a/include/flang/lower/IO.h b/include/flang/lower/IO.h
index 45f96e99ee85..06e1be1c93bc 100644
--- a/include/flang/lower/IO.h
+++ b/include/flang/lower/IO.h
@@ -1,22 +1,29 @@
-//===-- lib/lower/io.h ------------------------------------------*- C++ -*-===//
+//===-- flang/lower/IO.h -- lower I/O statements ----------------*- 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
 //
 //===----------------------------------------------------------------------===//
+///
+/// Experimental IO lowering to FIR + runtime. The Runtime design is under
+/// design.
+///
+/// FIXME This interface is also not final. Should it be based on parser::..
+/// nodes and lower expressions as needed or should it get every expression
+/// already lowered as mlir::Value? (currently second options, not sure it will
+/// provide enough information for complex IO statements).
+///
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_IO_H_
 #define FORTRAN_LOWER_IO_H_
 
 namespace mlir {
-class OpBuilder;
-class Location;
-class ValueRange;
+class Value;
 } // namespace mlir
 
 namespace Fortran {
-
 namespace parser {
 struct BackspaceStmt;
 struct CloseStmt;
@@ -30,46 +37,43 @@ struct RewindStmt;
 struct WriteStmt;
 } // namespace parser
 
-/// Experimental IO lowering to FIR + runtime. The Runtime design is under
-/// design.
-/// FIXME This interface is also not final. Should it be based on parser::..
-/// nodes and lower expressions as needed or should it get every expression
-/// already lowered as mlir::Value? (currently second options, not sure it
-/// will provide enough information for complex IO statements).
 namespace lower {
 
 class AbstractConverter;
 class BridgeImpl;
 
-/// Generate IO call(s) for BACKSPACE
-void genBackspaceStatement(AbstractConverter &, const parser::BackspaceStmt &);
+/// Generate IO call(s) for BACKSPACE; return the IOSTAT code
+mlir::Value genBackspaceStatement(AbstractConverter &,
+                                  const parser::BackspaceStmt &);
 
-/// Generate IO call(s) for CLOSE
-void genCloseStatement(AbstractConverter &, const parser::CloseStmt &);
+/// Generate IO call(s) for CLOSE; return the IOSTAT code
+mlir::Value genCloseStatement(AbstractConverter &, const parser::CloseStmt &);
 
-/// Generate IO call(s) for ENDFILE
-void genEndfileStatement(AbstractConverter &, const parser::EndfileStmt &);
+/// Generate IO call(s) for ENDFILE; return the IOSTAT code
+mlir::Value genEndfileStatement(AbstractConverter &,
+                                const parser::EndfileStmt &);
 
-/// Generate IO call(s) for FLUSH
-void genFlushStatement(AbstractConverter &, const parser::FlushStmt &);
+/// Generate IO call(s) for FLUSH; return the IOSTAT code
+mlir::Value genFlushStatement(AbstractConverter &, const parser::FlushStmt &);
 
-/// Generate IO call(s) for INQUIRE
-void genInquireStatement(AbstractConverter &, const parser::InquireStmt &);
+/// Generate IO call(s) for INQUIRE; return the IOSTAT code
+mlir::Value genInquireStatement(AbstractConverter &,
+                                const parser::InquireStmt &);
 
-/// Generate IO call(s) for OPEN
-void genOpenStatement(AbstractConverter &, const parser::OpenStmt &);
+/// Generate IO call(s) for OPEN; return the IOSTAT code
+mlir::Value genOpenStatement(AbstractConverter &, const parser::OpenStmt &);
 
 /// Generate IO call(s) for PRINT
 void genPrintStatement(AbstractConverter &, const parser::PrintStmt &);
 
-/// Generate IO call(s) for READ
-void genReadStatement(AbstractConverter &, const parser::ReadStmt &);
+/// Generate IO call(s) for READ; return the IOSTAT code
+mlir::Value genReadStatement(AbstractConverter &, const parser::ReadStmt &);
 
-/// Generate IO call(s) for REWIND
-void genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
+/// Generate IO call(s) for REWIND; return the IOSTAT code
+mlir::Value genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
 
-/// Generate IO call(s) for WRITE
-void genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
+/// Generate IO call(s) for WRITE; return the IOSTAT code
+mlir::Value genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
 
 } // namespace lower
 } // namespace Fortran
diff --git a/lib/fir/CMakeLists.txt b/lib/fir/CMakeLists.txt
index ef5c33e99890..6b77fd10587e 100644
--- a/lib/fir/CMakeLists.txt
+++ b/lib/fir/CMakeLists.txt
@@ -1,3 +1,5 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wno-unused-parameter")
+
 add_subdirectory(Dialect)
 
 add_llvm_library(FIR
diff --git a/lib/fir/Dialect/FIRAttr.cpp b/lib/fir/Dialect/FIRAttr.cpp
index fb20b28f4092..fa53bd3fbf56 100644
--- a/lib/fir/Dialect/FIRAttr.cpp
+++ b/lib/fir/Dialect/FIRAttr.cpp
@@ -17,45 +17,42 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 
-namespace L = llvm;
-namespace M = mlir;
-
 using namespace fir;
 
 namespace fir {
 namespace detail {
 
 /// An attribute representing a reference to a type.
-struct TypeAttributeStorage : public M::AttributeStorage {
-  using KeyTy = M::Type;
+struct TypeAttributeStorage : public mlir::AttributeStorage {
+  using KeyTy = mlir::Type;
 
-  TypeAttributeStorage(M::Type value) : value(value) {}
+  TypeAttributeStorage(mlir::Type value) : value(value) {}
 
   /// Key equality function.
   bool operator==(const KeyTy &key) const { return key == value; }
 
   /// Construct a new storage instance.
   static TypeAttributeStorage *
-  construct(M::AttributeStorageAllocator &allocator, KeyTy key) {
+  construct(mlir::AttributeStorageAllocator &allocator, KeyTy key) {
     return new (allocator.allocate<TypeAttributeStorage>())
         TypeAttributeStorage(key);
   }
 
-  M::Type value;
+  mlir::Type value;
 };
 } // namespace detail
 
-ExactTypeAttr ExactTypeAttr::get(M::Type value) {
+ExactTypeAttr ExactTypeAttr::get(mlir::Type value) {
   return Base::get(value.getContext(), FIR_EXACTTYPE, value);
 }
 
-M::Type ExactTypeAttr::getType() const { return getImpl()->value; }
+mlir::Type ExactTypeAttr::getType() const { return getImpl()->value; }
 
-SubclassAttr SubclassAttr::get(M::Type value) {
+SubclassAttr SubclassAttr::get(mlir::Type value) {
   return Base::get(value.getContext(), FIR_SUBCLASS, value);
 }
 
-M::Type SubclassAttr::getType() const { return getImpl()->value; }
+mlir::Type SubclassAttr::getType() const { return getImpl()->value; }
 
 using AttributeUniquer = mlir::detail::AttributeUniquer;
 
@@ -75,24 +72,25 @@ PointIntervalAttr PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<PointIntervalAttr>(ctxt, getId());
 }
 
-M::Attribute parseFirAttribute(FIROpsDialect *dialect,
-                               M::DialectAsmParser &parser, M::Type type) {
+mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
+                                  mlir::DialectAsmParser &parser,
+                                  mlir::Type type) {
   auto loc = parser.getNameLoc();
-  L::StringRef attrName;
+  llvm::StringRef attrName;
   if (parser.parseKeyword(&attrName)) {
     parser.emitError(loc, "expected an attribute name");
     return {};
   }
 
   if (attrName == ExactTypeAttr::getAttrName()) {
-    M::Type type;
+    mlir::Type type;
     if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
       parser.emitError(loc, "expected a type");
     }
     return ExactTypeAttr::get(type);
   }
   if (attrName == SubclassAttr::getAttrName()) {
-    M::Type type;
+    mlir::Type type;
     if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
       parser.emitError(loc, "expected a subtype");
     }
@@ -111,13 +109,13 @@ M::Attribute parseFirAttribute(FIROpsDialect *dialect,
     return ClosedIntervalAttr::get(dialect->getContext());
   }
 
-  L::Twine msg{"unknown FIR attribute: "};
+  llvm::Twine msg{"unknown FIR attribute: "};
   parser.emitError(loc, msg.concat(attrName));
   return {};
 }
 
-void printFirAttribute(FIROpsDialect *dialect, M::Attribute attr,
-                       M::DialectAsmPrinter &p) {
+void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
+                       mlir::DialectAsmPrinter &p) {
   auto &os = p.getStream();
   if (auto exact = attr.dyn_cast<fir::ExactTypeAttr>()) {
     os << fir::ExactTypeAttr::getAttrName() << '<';
diff --git a/lib/fir/Dialect/FIRDialect.cpp b/lib/fir/Dialect/FIRDialect.cpp
index 6106fa49d1e1..18489f3985fe 100644
--- a/lib/fir/Dialect/FIRDialect.cpp
+++ b/lib/fir/Dialect/FIRDialect.cpp
@@ -14,15 +14,13 @@
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Transforms/SideEffectsInterface.h"
 
-namespace M = mlir;
-
 using namespace fir;
 
 namespace {
 
 template <typename A>
-void selectBuild(M::OpBuilder *builder, M::OperationState *result,
-                 M::Value condition,
+void selectBuild(mlir::OpBuilder *builder, mlir::OperationState *result,
+                 mlir::Value condition,
                  llvm::ArrayRef<typename A::BranchTuple> tuples) {
   result->addOperands(condition);
   for (auto &tup : tuples) {
@@ -31,19 +29,19 @@ void selectBuild(M::OpBuilder *builder, M::OperationState *result,
   }
   // Note: succs must be added *after* operands
   for (auto &tup : tuples) {
-    auto *block{std::get<M::Block *>(tup)};
+    auto *block{std::get<mlir::Block *>(tup)};
     assert(block);
-    auto blkArgs{std::get<llvm::ArrayRef<M::Value>>(tup)};
+    auto blkArgs{std::get<llvm::ArrayRef<mlir::Value>>(tup)};
     result->addSuccessor(block, blkArgs);
   }
 }
 
-M::DialectRegistration<fir::FIROpsDialect> FIROps;
+mlir::DialectRegistration<fir::FIROpsDialect> FIROps;
 
 } // namespace
 
-fir::FIROpsDialect::FIROpsDialect(M::MLIRContext *ctx)
-    : M::Dialect("fir", ctx) {
+fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
+    : mlir::Dialect("fir", ctx) {
   addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
            FieldType, HeapType, IntType, LenType, LogicalType, PointerType,
            RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
@@ -60,20 +58,22 @@ fir::FIROpsDialect::~FIROpsDialect() {
   // do nothing
 }
 
-M::Type fir::FIROpsDialect::parseType(M::DialectAsmParser &parser) const {
+mlir::Type fir::FIROpsDialect::parseType(mlir::DialectAsmParser &parser) const {
   return parseFirType(const_cast<FIROpsDialect *>(this), parser);
 }
 
-void fir::FIROpsDialect::printType(M::Type ty, M::DialectAsmPrinter &p) const {
+void fir::FIROpsDialect::printType(mlir::Type ty,
+                                   mlir::DialectAsmPrinter &p) const {
   return printFirType(const_cast<FIROpsDialect *>(this), ty, p);
 }
 
-M::Attribute fir::FIROpsDialect::parseAttribute(M::DialectAsmParser &parser,
-                                                M::Type type) const {
+mlir::Attribute
+fir::FIROpsDialect::parseAttribute(mlir::DialectAsmParser &parser,
+                                   mlir::Type type) const {
   return parseFirAttribute(const_cast<FIROpsDialect *>(this), parser, type);
 }
 
-void fir::FIROpsDialect::printAttribute(M::Attribute attr,
-                                        M::DialectAsmPrinter &p) const {
+void fir::FIROpsDialect::printAttribute(mlir::Attribute attr,
+                                        mlir::DialectAsmPrinter &p) const {
   printFirAttribute(const_cast<FIROpsDialect *>(this), attr, p);
 }
diff --git a/lib/fir/Dialect/FIROps.cpp b/lib/fir/Dialect/FIROps.cpp
index e3f23f65d06e..d853b002d859 100644
--- a/lib/fir/Dialect/FIROps.cpp
+++ b/lib/fir/Dialect/FIROps.cpp
@@ -18,37 +18,34 @@
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/StringSwitch.h"
 
-namespace L = llvm;
-namespace M = mlir;
-
 namespace fir {
 
 // AllocaOp
 
-M::Type AllocaOp::getAllocatedType() {
+mlir::Type AllocaOp::getAllocatedType() {
   return getType().cast<ReferenceType>().getEleTy();
 }
 
 /// Create a legal memory reference as return type
-M::Type AllocaOp::wrapResultType(M::Type intype) {
+mlir::Type AllocaOp::wrapResultType(mlir::Type intype) {
   // FIR semantics: memory references to memory references are disallowed
   if (intype.dyn_cast<ReferenceType>())
     return {};
   return ReferenceType::get(intype);
 }
 
-M::Type AllocaOp::getRefTy(M::Type ty) { return ReferenceType::get(ty); }
+mlir::Type AllocaOp::getRefTy(mlir::Type ty) { return ReferenceType::get(ty); }
 
 // AllocMemOp
 
-M::Type AllocMemOp::getAllocatedType() {
+mlir::Type AllocMemOp::getAllocatedType() {
   return getType().cast<HeapType>().getEleTy();
 }
 
-M::Type AllocMemOp::getRefTy(M::Type ty) { return HeapType::get(ty); }
+mlir::Type AllocMemOp::getRefTy(mlir::Type ty) { return HeapType::get(ty); }
 
 /// Create a legal heap reference as return type
-M::Type AllocMemOp::wrapResultType(M::Type intype) {
+mlir::Type AllocMemOp::wrapResultType(mlir::Type intype) {
   // Fortran semantics: C852 an entity cannot be both ALLOCATABLE and POINTER
   // 8.5.3 note 1 prohibits ALLOCATABLE procedures as well
   // FIR semantics: one may not allocate a memory reference value
@@ -61,16 +58,15 @@ M::Type AllocMemOp::wrapResultType(M::Type intype) {
 // BoxDimsOp
 
 /// Get the result types packed in a tuple tuple
-M::Type BoxDimsOp::getTupleType() {
-  L::SmallVector<M::Type, 3> triple{getResult(0).getType(),
-                                    getResult(1).getType(),
-                                    getResult(2).getType()};
-  return M::TupleType::get(triple, getContext());
+mlir::Type BoxDimsOp::getTupleType() {
+  llvm::SmallVector<mlir::Type, 3> triple{
+      getResult(0).getType(), getResult(1).getType(), getResult(2).getType()};
+  return mlir::TupleType::get(triple, getContext());
 }
 
 // CallOp
 
-void printCallOp(M::OpAsmPrinter &p, fir::CallOp &op) {
+void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
   auto callee = op.callee();
   bool isDirect = callee.hasValue();
   p << op.getOperationName() << ' ';
@@ -79,55 +75,56 @@ void printCallOp(M::OpAsmPrinter &p, fir::CallOp &op) {
   else
     p << op.getOperand(0);
   p << '(';
-  p.printOperands(L::drop_begin(op.getOperands(), isDirect ? 0 : 1));
+  p.printOperands(llvm::drop_begin(op.getOperands(), isDirect ? 0 : 1));
   p << ')';
   p.printOptionalAttrDict(op.getAttrs(), {"callee"});
-  L::SmallVector<Type, 1> resultTypes(op.getResultTypes());
-  L::SmallVector<Type, 8> argTypes(
-      L::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
+  auto resultTypes{op.getResultTypes()};
+  llvm::SmallVector<Type, 8> argTypes(
+      llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
   p << " : " << FunctionType::get(argTypes, resultTypes, op.getContext());
 }
 
-M::ParseResult parseCallOp(M::OpAsmParser &parser, M::OperationState &result) {
-  L::SmallVector<M::OpAsmParser::OperandType, 8> operands;
+mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result) {
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
 
   if (parser.parseOperandList(operands))
-    return M::failure();
+    return mlir::failure();
   bool isDirect = operands.empty();
   SmallVector<NamedAttribute, 4> attrs;
   SymbolRefAttr funcAttr;
 
   if (isDirect)
     if (parser.parseAttribute(funcAttr, "callee", attrs))
-      return M::failure();
+      return mlir::failure();
   Type type;
 
-  if (parser.parseOperandList(operands, M::OpAsmParser::Delimiter::Paren) ||
+  if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
       parser.parseOptionalAttrDict(attrs) || parser.parseColon() ||
       parser.parseType(type))
-    return M::failure();
+    return mlir::failure();
 
-  auto funcType = type.dyn_cast<M::FunctionType>();
+  auto funcType = type.dyn_cast<mlir::FunctionType>();
   if (!funcType)
     return parser.emitError(parser.getNameLoc(), "expected function type");
   if (isDirect) {
     if (parser.resolveOperands(operands, funcType.getInputs(),
                                parser.getNameLoc(), result.operands))
-      return M::failure();
+      return mlir::failure();
   } else {
     auto funcArgs =
-        L::ArrayRef<M::OpAsmParser::OperandType>(operands).drop_front();
-    L::SmallVector<M::Value, 8> resultArgs(
+        llvm::ArrayRef<mlir::OpAsmParser::OperandType>(operands).drop_front();
+    llvm::SmallVector<mlir::Value, 8> resultArgs(
         result.operands.begin() + (result.operands.empty() ? 0 : 1),
         result.operands.end());
     if (parser.resolveOperand(operands[0], funcType, result.operands) ||
         parser.resolveOperands(funcArgs, funcType.getInputs(),
                                parser.getNameLoc(), resultArgs))
-      return M::failure();
+      return mlir::failure();
   }
   result.addTypes(funcType.getResults());
   result.attributes = attrs;
-  return M::success();
+  return mlir::success();
 }
 
 // CmpfOp
@@ -187,7 +184,7 @@ void printCmpOp(OpAsmPrinter &p, OPTY op) {
                 "wrong number of predicate names");
   p << op.getOperationName() << ' ';
   auto predicateValue =
-      op.template getAttrOfType<M::IntegerAttr>(OPTY::getPredicateAttrName())
+      op.template getAttrOfType<mlir::IntegerAttr>(OPTY::getPredicateAttrName())
           .getInt();
   assert(predicateValue >= static_cast<int>(CmpFPredicate::FirstValidValue) &&
          predicateValue < static_cast<int>(CmpFPredicate::NumPredicates) &&
@@ -207,11 +204,12 @@ void printCmpOp(OpAsmPrinter &p, OPTY op) {
 void printCmpfOp(OpAsmPrinter &p, CmpfOp op) { printCmpOp(p, op); }
 
 template <typename OPTY>
-M::ParseResult parseCmpOp(M::OpAsmParser &parser, M::OperationState &result) {
-  L::SmallVector<M::OpAsmParser::OperandType, 2> ops;
-  L::SmallVector<M::NamedAttribute, 4> attrs;
-  M::Attribute predicateNameAttr;
-  M::Type type;
+mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
+                             mlir::OperationState &result) {
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> ops;
+  llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
+  mlir::Attribute predicateNameAttr;
+  mlir::Type type;
   if (parser.parseAttribute(predicateNameAttr, OPTY::getPredicateAttrName(),
                             attrs) ||
       parser.parseComma() || parser.parseOperandList(ops, 2) ||
@@ -219,13 +217,13 @@ M::ParseResult parseCmpOp(M::OpAsmParser &parser, M::OperationState &result) {
       parser.resolveOperands(ops, type, result.operands))
     return failure();
 
-  if (!predicateNameAttr.isa<M::StringAttr>())
+  if (!predicateNameAttr.isa<mlir::StringAttr>())
     return parser.emitError(parser.getNameLoc(),
                             "expected string comparison predicate attribute");
 
   // Rewrite string attribute to an enum value.
-  L::StringRef predicateName =
-      predicateNameAttr.cast<M::StringAttr>().getValue();
+  llvm::StringRef predicateName =
+      predicateNameAttr.cast<mlir::StringAttr>().getValue();
   auto predicate = CmpfOp::getPredicateByName(predicateName);
   if (predicate == CmpFPredicate::NumPredicates)
     return parser.emitError(parser.getNameLoc(),
@@ -233,14 +231,15 @@ M::ParseResult parseCmpOp(M::OpAsmParser &parser, M::OperationState &result) {
                                 "\"");
 
   auto builder = parser.getBuilder();
-  M::Type i1Type = builder.getI1Type();
+  mlir::Type i1Type = builder.getI1Type();
   attrs[0].second = builder.getI64IntegerAttr(static_cast<int64_t>(predicate));
   result.attributes = attrs;
   result.addTypes({i1Type});
   return success();
 }
 
-M::ParseResult parseCmpfOp(M::OpAsmParser &parser, M::OperationState &result) {
+mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result) {
   return parseCmpOp<fir::CmpfOp>(parser, result);
 }
 
@@ -257,29 +256,31 @@ void buildCmpCOp(Builder *builder, OperationState &result,
 
 void printCmpcOp(OpAsmPrinter &p, CmpcOp op) { printCmpOp(p, op); }
 
-M::ParseResult parseCmpcOp(M::OpAsmParser &parser, M::OperationState &result) {
+mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result) {
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
 // DispatchOp
 
-M::FunctionType DispatchOp::getFunctionType() {
-  auto attr = getAttr("fn_type").cast<M::TypeAttr>();
-  return attr.getValue().cast<M::FunctionType>();
+mlir::FunctionType DispatchOp::getFunctionType() {
+  auto attr = getAttr("fn_type").cast<mlir::TypeAttr>();
+  return attr.getValue().cast<mlir::FunctionType>();
 }
 
 // DispatchTableOp
 
-void DispatchTableOp::build(M::Builder *builder, M::OperationState *result,
-                            L::StringRef name, M::Type type,
-                            L::ArrayRef<M::NamedAttribute> attrs) {
+void DispatchTableOp::build(mlir::Builder *builder,
+                            mlir::OperationState *result, llvm::StringRef name,
+                            mlir::Type type,
+                            llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   result->addAttribute("method", builder->getStringAttr(name));
   for (const auto &pair : attrs)
     result->addAttribute(pair.first, pair.second);
 }
 
-M::ParseResult DispatchTableOp::parse(M::OpAsmParser &parser,
-                                      M::OperationState &result) {
+mlir::ParseResult DispatchTableOp::parse(mlir::OpAsmParser &parser,
+                                         mlir::OperationState &result) {
   // Parse the name as a symbol reference attribute.
   SymbolRefAttr nameAttr;
   if (parser.parseAttribute(nameAttr, "method", result.attributes))
@@ -290,17 +291,17 @@ M::ParseResult DispatchTableOp::parse(M::OpAsmParser &parser,
       parser.getBuilder().getStringAttr(nameAttr.getRootReference());
 
   // Parse the optional table body.
-  M::Region *body = result.addRegion();
-  if (parser.parseOptionalRegion(*body,
-                                 L::ArrayRef<M::OpAsmParser::OperandType>{},
-                                 L::ArrayRef<M::Type>{}))
-    return M::failure();
+  mlir::Region *body = result.addRegion();
+  if (parser.parseOptionalRegion(
+          *body, llvm::ArrayRef<mlir::OpAsmParser::OperandType>{},
+          llvm::ArrayRef<mlir::Type>{}))
+    return mlir::failure();
 
   ensureTerminator(*body, parser.getBuilder(), result.location);
-  return M::success();
+  return mlir::success();
 }
 
-void DispatchTableOp::print(M::OpAsmPrinter &p) {
+void DispatchTableOp::print(mlir::OpAsmPrinter &p) {
   auto tableName = getAttrOfType<StringAttr>("method").getValue();
   p << getOperationName() << " @" << tableName;
 
@@ -310,57 +311,59 @@ void DispatchTableOp::print(M::OpAsmPrinter &p) {
                   /*printBlockTerminators=*/false);
 }
 
-M::LogicalResult DispatchTableOp::verify() { return M::success(); }
+mlir::LogicalResult DispatchTableOp::verify() { return mlir::success(); }
 
-M::Region &DispatchTableOp::front() {
+mlir::Region &DispatchTableOp::front() {
   return this->getOperation()->getRegion(0);
 }
 
-void DispatchTableOp::appendTableEntry(M::Operation *op) {
-  assert(M::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
+void DispatchTableOp::appendTableEntry(mlir::Operation *op) {
+  assert(mlir::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
   front().front().push_back(op);
 }
 
 // GenTypeDescOp
 
 #if 0
-void GenTypeDescOp::build(Builder *, OperationState &result, M::Type resty,
-                          M::TypeAttr inty) {
+void GenTypeDescOp::build(Builder *, OperationState &result, mlir::Type resty,
+                          mlir::TypeAttr inty) {
   result.addAttribute("in_type", inty);
   result.addTypes(resty);
 }
 #endif
 
-void GenTypeDescOp::build(Builder *, OperationState &result, M::TypeAttr inty) {
+void GenTypeDescOp::build(Builder *, OperationState &result,
+                          mlir::TypeAttr inty) {
   result.addAttribute("in_type", inty);
   result.addTypes(TypeDescType::get(inty.getValue()));
 }
 
 // GlobalOp
 
-GlobalOp GlobalOp::create(M::Location location, L::StringRef name, M::Type type,
-                          L::ArrayRef<M::NamedAttribute> attrs) {
-  M::OperationState state(location, "global");
-  M::Builder builder(location->getContext());
+GlobalOp GlobalOp::create(mlir::Location location, llvm::StringRef name,
+                          mlir::Type type,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  mlir::OperationState state(location, "global");
+  mlir::Builder builder(location->getContext());
   GlobalOp::build(&builder, state, name, type, attrs);
   return cast<GlobalOp>(Operation::create(state));
 }
 
-void GlobalOp::build(M::Builder *builder, M::OperationState &result,
-                     L::StringRef name, M::Type type,
-                     L::ArrayRef<M::NamedAttribute> attrs) {
-  result.addAttribute(getTypeAttrName(), M::TypeAttr::get(type));
-  result.addAttribute(M::SymbolTable::getSymbolAttrName(),
+void GlobalOp::build(mlir::Builder *builder, mlir::OperationState &result,
+                     llvm::StringRef name, mlir::Type type,
+                     llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(type));
+  result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       builder->getStringAttr(name));
   for (const auto &pair : attrs)
     result.addAttribute(pair.first, pair.second);
 }
 
-M::ParseResult GlobalOp::parse(M::OpAsmParser &parser,
-                               M::OperationState &result) {
+mlir::ParseResult GlobalOp::parse(mlir::OpAsmParser &parser,
+                                  mlir::OperationState &result) {
   // Parse the name as a symbol reference attribute.
   SymbolRefAttr nameAttr;
-  if (parser.parseAttribute(nameAttr, M::SymbolTable::getSymbolAttrName(),
+  if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
                             result.attributes))
     return failure();
 
@@ -373,26 +376,27 @@ M::ParseResult GlobalOp::parse(M::OpAsmParser &parser,
     result.addAttribute("constant", builder.getUnitAttr());
   }
 
-  M::Type globalType;
+  mlir::Type globalType;
   if (parser.parseColonType(globalType))
-    return M::failure();
+    return mlir::failure();
 
-  result.addAttribute(getTypeAttrName(), M::TypeAttr::get(globalType));
+  result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(globalType));
 
   // Parse the optional initializer body.
-  M::Region *body = result.addRegion();
-  if (parser.parseOptionalRegion(*body,
-                                 L::ArrayRef<M::OpAsmParser::OperandType>{},
-                                 L::ArrayRef<M::Type>{}))
-    return M::failure();
+  mlir::Region *body = result.addRegion();
+  if (parser.parseOptionalRegion(
+          *body, llvm::ArrayRef<mlir::OpAsmParser::OperandType>{},
+          llvm::ArrayRef<mlir::Type>{}))
+    return mlir::failure();
 
   ensureTerminator(*body, builder, result.location);
-  return M::success();
+  return mlir::success();
 }
 
-void GlobalOp::print(M::OpAsmPrinter &p) {
+void GlobalOp::print(mlir::OpAsmPrinter &p) {
   auto varName =
-      getAttrOfType<StringAttr>(M::SymbolTable::getSymbolAttrName()).getValue();
+      getAttrOfType<StringAttr>(mlir::SymbolTable::getSymbolAttrName())
+          .getValue();
   p << getOperationName() << " @" << varName;
   if (getAttr("constant"))
     p << " constant";
@@ -404,18 +408,18 @@ void GlobalOp::print(M::OpAsmPrinter &p) {
                   /*printBlockTerminators=*/false);
 }
 
-M::LogicalResult GlobalOp::verify() { return M::success(); }
+mlir::LogicalResult GlobalOp::verify() { return mlir::success(); }
 
-void GlobalOp::appendInitialValue(M::Operation *op) {
+void GlobalOp::appendInitialValue(mlir::Operation *op) {
   front().front().push_back(op);
 }
 
-M::Region &GlobalOp::front() { return this->getOperation()->getRegion(0); }
+mlir::Region &GlobalOp::front() { return this->getOperation()->getRegion(0); }
 
 // LoadOp
 
 /// Get the element type of a reference like type; otherwise null
-M::Type elementTypeOf(M::Type ref) {
+mlir::Type elementTypeOf(mlir::Type ref) {
   if (auto r = ref.dyn_cast_or_null<ReferenceType>())
     return r.getEleTy();
   if (auto r = ref.dyn_cast_or_null<PointerType>())
@@ -425,72 +429,74 @@ M::Type elementTypeOf(M::Type ref) {
   return {};
 }
 
-M::ParseResult LoadOp::getElementOf(M::Type &ele, M::Type ref) {
-  if (M::Type r = elementTypeOf(ref)) {
+mlir::ParseResult LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
+  if (mlir::Type r = elementTypeOf(ref)) {
     ele = r;
-    return M::success();
+    return mlir::success();
   }
-  return M::failure();
+  return mlir::failure();
 }
 
 // LoopOp
 
-void LoopOp::build(M::Builder *builder, M::OperationState &result,
+void LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
                    int64_t lowerBound, int64_t upperBound, int64_t step) {
   assert(false && "not implemented");
 }
 
-void LoopOp::build(M::Builder *builder, M::OperationState &result, M::Value lb,
-                   M::Value ub, L::ArrayRef<M::Value> step) {
+void LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
+                   mlir::Value lb, mlir::Value ub,
+                   llvm::ArrayRef<mlir::Value> step) {
   if (step.empty())
     result.addOperands({lb, ub});
   else
     result.addOperands({lb, ub, step[0]});
-  M::Region *bodyRegion = result.addRegion();
+  mlir::Region *bodyRegion = result.addRegion();
   LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
   bodyRegion->front().addArgument(builder->getIndexType());
 }
 
-M::ParseResult parseLoopOp(M::OpAsmParser &parser, M::OperationState &result) {
+mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
-  M::OpAsmParser::OperandType inductionVariable, lb, ub, step;
+  mlir::OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
   if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
-    return M::failure();
+    return mlir::failure();
 
   // Parse loop bounds.
-  M::Type indexType = builder.getIndexType();
+  mlir::Type indexType = builder.getIndexType();
   if (parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands))
-    return M::failure();
+    return mlir::failure();
 
   if (parser.parseOptionalKeyword(LoopOp::getStepKeyword()))
     result.addAttribute(LoopOp::getStepKeyword(),
                         builder.getIntegerAttr(builder.getIndexType(), 1));
   else if (parser.parseOperand(step) ||
            parser.resolveOperand(step, indexType, result.operands))
-    return M::failure();
+    return mlir::failure();
 
   if (!parser.parseOptionalKeyword("unordered"))
     result.addAttribute("unordered", builder.getUnitAttr());
 
   // Parse the body region.
-  M::Region *body = result.addRegion();
+  mlir::Region *body = result.addRegion();
   if (parser.parseRegion(*body, inductionVariable, indexType))
-    return M::failure();
+    return mlir::failure();
 
   fir::LoopOp::ensureTerminator(*body, builder, result.location);
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
-fir::LoopOp getForInductionVarOwner(M::Value val) {
-  auto ivArg = val.dyn_cast<M::BlockArgument>();
+fir::LoopOp getForInductionVarOwner(mlir::Value val) {
+  auto ivArg = val.dyn_cast<mlir::BlockArgument>();
   if (!ivArg)
     return fir::LoopOp();
   assert(ivArg.getOwner() && "unlinked block argument");
@@ -500,7 +506,7 @@ fir::LoopOp getForInductionVarOwner(M::Value val) {
 
 // StoreOp
 
-M::Type StoreOp::elementType(M::Type refType) {
+mlir::Type StoreOp::elementType(mlir::Type refType) {
   if (auto ref = refType.dyn_cast<ReferenceType>())
     return ref.getEleTy();
   if (auto ref = refType.dyn_cast<PointerType>())
@@ -512,63 +518,65 @@ M::Type StoreOp::elementType(M::Type refType) {
 
 // WhereOp
 
-void WhereOp::build(M::Builder *builder, M::OperationState &result,
-                    M::Value cond, bool withElseRegion) {
+void WhereOp::build(mlir::Builder *builder, mlir::OperationState &result,
+                    mlir::Value cond, bool withElseRegion) {
   result.addOperands(cond);
-  M::Region *thenRegion = result.addRegion();
-  M::Region *elseRegion = result.addRegion();
+  mlir::Region *thenRegion = result.addRegion();
+  mlir::Region *elseRegion = result.addRegion();
   WhereOp::ensureTerminator(*thenRegion, *builder, result.location);
   if (withElseRegion)
     WhereOp::ensureTerminator(*elseRegion, *builder, result.location);
 }
 
-M::ParseResult parseWhereOp(M::OpAsmParser &parser, M::OperationState &result) {
+mlir::ParseResult parseWhereOp(mlir::OpAsmParser &parser,
+                               mlir::OperationState &result) {
   // Create the regions for 'then'.
   result.regions.reserve(2);
-  M::Region *thenRegion = result.addRegion();
-  M::Region *elseRegion = result.addRegion();
+  mlir::Region *thenRegion = result.addRegion();
+  mlir::Region *elseRegion = result.addRegion();
 
   auto &builder = parser.getBuilder();
-  M::OpAsmParser::OperandType cond;
-  M::Type i1Type = builder.getIntegerType(1);
+  mlir::OpAsmParser::OperandType cond;
+  mlir::Type i1Type = builder.getIntegerType(1);
   if (parser.parseOperand(cond) ||
       parser.resolveOperand(cond, i1Type, result.operands))
-    return M::failure();
+    return mlir::failure();
 
   if (parser.parseRegion(*thenRegion, {}, {}))
-    return M::failure();
+    return mlir::failure();
 
   WhereOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
 
   if (!parser.parseOptionalKeyword("otherwise")) {
     if (parser.parseRegion(*elseRegion, {}, {}))
-      return M::failure();
+      return mlir::failure();
     WhereOp::ensureTerminator(*elseRegion, parser.getBuilder(),
                               result.location);
   }
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
-    return M::failure();
+    return mlir::failure();
 
-  return M::success();
+  return mlir::success();
 }
 
-M::ParseResult isValidCaseAttr(M::Attribute attr) {
-  if (attr.dyn_cast_or_null<M::UnitAttr>() ||
+mlir::ParseResult isValidCaseAttr(mlir::Attribute attr) {
+  if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||
       attr.dyn_cast_or_null<ClosedIntervalAttr>() ||
       attr.dyn_cast_or_null<PointIntervalAttr>() ||
       attr.dyn_cast_or_null<LowerBoundAttr>() ||
       attr.dyn_cast_or_null<UpperBoundAttr>())
-    return M::success();
-  return M::failure();
+    return mlir::success();
+  return mlir::failure();
 }
 
-unsigned getCaseArgumentOffset(L::ArrayRef<M::Attribute> cases, unsigned dest) {
+unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
+                               unsigned dest) {
   unsigned o = 0;
   for (unsigned i = 0; i < dest; ++i) {
     auto &attr = cases[i];
-    if (!attr.dyn_cast_or_null<M::UnitAttr>()) {
+    if (!attr.dyn_cast_or_null<mlir::UnitAttr>()) {
       ++o;
       if (attr.dyn_cast_or_null<ClosedIntervalAttr>())
         ++o;
@@ -577,14 +585,15 @@ unsigned getCaseArgumentOffset(L::ArrayRef<M::Attribute> cases, unsigned dest) {
   return o;
 }
 
-M::ParseResult parseSelector(M::OpAsmParser &parser, M::OperationState &result,
-                             M::OpAsmParser::OperandType &selector,
-                             M::Type &type) {
+mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result,
+                                mlir::OpAsmParser::OperandType &selector,
+                                mlir::Type &type) {
   if (parser.parseOperand(selector) || parser.parseColonType(type) ||
       parser.resolveOperand(selector, type, result.operands) ||
       parser.parseLSquare())
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
 /// Generic pretty-printer of a binary operation
@@ -607,25 +616,26 @@ void printUnaryOp(Operation *op, OpAsmPrinter &p) {
   p << " : " << op->getResult(0).getType();
 }
 
-bool isReferenceLike(M::Type type) {
+bool isReferenceLike(mlir::Type type) {
   return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
          type.isa<fir::PointerType>();
 }
 
-M::FuncOp createFuncOp(M::Location loc, M::ModuleOp module, StringRef name,
-                       M::FunctionType type,
-                       L::ArrayRef<M::NamedAttribute> attrs) {
-  if (auto f = module.lookupSymbol<M::FuncOp>(name))
+mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
+                          StringRef name, mlir::FunctionType type,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
-  M::OpBuilder modBuilder(module.getBodyRegion());
-  return modBuilder.create<M::FuncOp>(loc, name, type, attrs);
+  mlir::OpBuilder modBuilder(module.getBodyRegion());
+  return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
 }
 
-GlobalOp createGlobalOp(M::Location loc, M::ModuleOp module, StringRef name,
-                        M::Type type, L::ArrayRef<M::NamedAttribute> attrs) {
+GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
+                        StringRef name, mlir::Type type,
+                        llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto g = module.lookupSymbol<GlobalOp>(name))
     return g;
-  M::OpBuilder modBuilder(module.getBodyRegion());
+  mlir::OpBuilder modBuilder(module.getBodyRegion());
   return modBuilder.create<GlobalOp>(loc, name, type, attrs);
 }
 
diff --git a/lib/fir/Dialect/FIRType.cpp b/lib/fir/Dialect/FIRType.cpp
index 7217f9820b20..3504631e23ee 100644
--- a/lib/fir/Dialect/FIRType.cpp
+++ b/lib/fir/Dialect/FIRType.cpp
@@ -17,15 +17,12 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
 
-namespace L = llvm;
-namespace M = mlir;
-
 using namespace fir;
 
 namespace {
 
 template <typename TYPE>
-TYPE parseIntSingleton(M::DialectAsmParser &parser) {
+TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
   int kind = 0;
   if (parser.parseLess() || parser.parseInteger(kind) ||
       parser.parseGreater()) {
@@ -36,18 +33,18 @@ TYPE parseIntSingleton(M::DialectAsmParser &parser) {
 }
 
 template <typename TYPE>
-TYPE parseKindSingleton(M::DialectAsmParser &parser) {
+TYPE parseKindSingleton(mlir::DialectAsmParser &parser) {
   return parseIntSingleton<TYPE>(parser);
 }
 
 template <typename TYPE>
-TYPE parseRankSingleton(M::DialectAsmParser &parser) {
+TYPE parseRankSingleton(mlir::DialectAsmParser &parser) {
   return parseIntSingleton<TYPE>(parser);
 }
 
 template <typename TYPE>
-TYPE parseTypeSingleton(M::DialectAsmParser &parser, M::Location) {
-  M::Type ty;
+TYPE parseTypeSingleton(mlir::DialectAsmParser &parser, mlir::Location) {
+  mlir::Type ty;
   if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
     parser.emitError(parser.getCurrentLocation(), "type expected");
     return {};
@@ -56,14 +53,14 @@ TYPE parseTypeSingleton(M::DialectAsmParser &parser, M::Location) {
 }
 
 // `box` `<` type (',' affine-map)? `>`
-BoxType parseBox(M::DialectAsmParser &parser, M::Location loc) {
-  M::Type ofTy;
+BoxType parseBox(mlir::DialectAsmParser &parser, mlir::Location loc) {
+  mlir::Type ofTy;
   if (parser.parseLess() || parser.parseType(ofTy)) {
     parser.emitError(parser.getCurrentLocation(), "expected type parameter");
     return {};
   }
 
-  M::AffineMapAttr map;
+  mlir::AffineMapAttr map;
   if (!parser.parseOptionalComma())
     if (parser.parseAttribute(map)) {
       parser.emitError(parser.getCurrentLocation(), "expected affine map");
@@ -77,83 +74,84 @@ BoxType parseBox(M::DialectAsmParser &parser, M::Location loc) {
 }
 
 // `boxchar` `<` kind `>`
-BoxCharType parseBoxChar(M::DialectAsmParser &parser) {
+BoxCharType parseBoxChar(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<BoxCharType>(parser);
 }
 
 // `boxproc` `<` return-type `>`
-BoxProcType parseBoxProc(M::DialectAsmParser &parser, M::Location loc) {
+BoxProcType parseBoxProc(mlir::DialectAsmParser &parser, mlir::Location loc) {
   return parseTypeSingleton<BoxProcType>(parser, loc);
 }
 
 // `char` `<` kind `>`
-CharacterType parseCharacter(M::DialectAsmParser &parser) {
+CharacterType parseCharacter(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<CharacterType>(parser);
 }
 
 // `complex` `<` kind `>`
-CplxType parseComplex(M::DialectAsmParser &parser) {
+CplxType parseComplex(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<CplxType>(parser);
 }
 
 // `dims` `<` rank `>`
-DimsType parseDims(M::DialectAsmParser &parser) {
+DimsType parseDims(mlir::DialectAsmParser &parser) {
   return parseRankSingleton<DimsType>(parser);
 }
 
 // `field`
-FieldType parseField(M::DialectAsmParser &parser) {
+FieldType parseField(mlir::DialectAsmParser &parser) {
   return FieldType::get(parser.getBuilder().getContext());
 }
 
 // `heap` `<` type `>`
-HeapType parseHeap(M::DialectAsmParser &parser, M::Location loc) {
+HeapType parseHeap(mlir::DialectAsmParser &parser, mlir::Location loc) {
   return parseTypeSingleton<HeapType>(parser, loc);
 }
 
 // `int` `<` kind `>`
-IntType parseInteger(M::DialectAsmParser &parser) {
+IntType parseInteger(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<IntType>(parser);
 }
 
 // `len`
-LenType parseLen(M::DialectAsmParser &parser) {
+LenType parseLen(mlir::DialectAsmParser &parser) {
   return LenType::get(parser.getBuilder().getContext());
 }
 
 // `logical` `<` kind `>`
-LogicalType parseLogical(M::DialectAsmParser &parser) {
+LogicalType parseLogical(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<LogicalType>(parser);
 }
 
 // `ptr` `<` type `>`
-PointerType parsePointer(M::DialectAsmParser &parser, M::Location loc) {
+PointerType parsePointer(mlir::DialectAsmParser &parser, mlir::Location loc) {
   return parseTypeSingleton<PointerType>(parser, loc);
 }
 
 // `real` `<` kind `>`
-RealType parseReal(M::DialectAsmParser &parser) {
+RealType parseReal(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<RealType>(parser);
 }
 
 // `ref` `<` type `>`
-ReferenceType parseReference(M::DialectAsmParser &parser, M::Location loc) {
+ReferenceType parseReference(mlir::DialectAsmParser &parser,
+                             mlir::Location loc) {
   return parseTypeSingleton<ReferenceType>(parser, loc);
 }
 
 // `tdesc` `<` type `>`
-TypeDescType parseTypeDesc(M::DialectAsmParser &parser, M::Location loc) {
+TypeDescType parseTypeDesc(mlir::DialectAsmParser &parser, mlir::Location loc) {
   return parseTypeSingleton<TypeDescType>(parser, loc);
 }
 
 // `void`
-M::Type parseVoid(M::DialectAsmParser &parser) {
+mlir::Type parseVoid(mlir::DialectAsmParser &parser) {
   return parser.getBuilder().getNoneType();
 }
 
 // `array` `<` `*` | bounds (`x` bounds)* `:` type (',' affine-map)? `>`
 // bounds ::= `?` | int-lit
-SequenceType parseSequence(M::DialectAsmParser &parser, M::Location) {
+SequenceType parseSequence(mlir::DialectAsmParser &parser, mlir::Location) {
   if (parser.parseLess()) {
     parser.emitError(parser.getNameLoc(), "expecting '<'");
     return {};
@@ -168,12 +166,12 @@ SequenceType parseSequence(M::DialectAsmParser &parser, M::Location) {
     parser.emitError(parser.getNameLoc(), "expected ':'");
     return {};
   }
-  M::Type eleTy;
+  mlir::Type eleTy;
   if (parser.parseType(eleTy) || parser.parseGreater()) {
     parser.emitError(parser.getNameLoc(), "expecting element type");
     return {};
   }
-  M::AffineMapAttr map;
+  mlir::AffineMapAttr map;
   if (!parser.parseOptionalComma())
     if (parser.parseAttribute(map)) {
       parser.emitError(parser.getNameLoc(), "expecting affine map");
@@ -182,26 +180,26 @@ SequenceType parseSequence(M::DialectAsmParser &parser, M::Location) {
   return SequenceType::get(shape, eleTy, map);
 }
 
-bool verifyIntegerType(M::Type ty) {
-  return ty.dyn_cast<M::IntegerType>() || ty.dyn_cast<IntType>();
+bool verifyIntegerType(mlir::Type ty) {
+  return ty.dyn_cast<mlir::IntegerType>() || ty.dyn_cast<IntType>();
 }
 
-bool verifyRecordMemberType(M::Type ty) {
+bool verifyRecordMemberType(mlir::Type ty) {
   return !(ty.dyn_cast<BoxType>() || ty.dyn_cast<BoxCharType>() ||
            ty.dyn_cast<BoxProcType>() || ty.dyn_cast<DimsType>() ||
            ty.dyn_cast<FieldType>() || ty.dyn_cast<LenType>() ||
            ty.dyn_cast<ReferenceType>() || ty.dyn_cast<TypeDescType>());
 }
 
-bool verifySameLists(L::ArrayRef<RecordType::TypePair> a1,
-                     L::ArrayRef<RecordType::TypePair> a2) {
+bool verifySameLists(llvm::ArrayRef<RecordType::TypePair> a1,
+                     llvm::ArrayRef<RecordType::TypePair> a2) {
   // FIXME: do we need to allow for any variance here?
   return a1 == a2;
 }
 
-RecordType verifyDerived(M::DialectAsmParser &parser, RecordType derivedTy,
-                         L::ArrayRef<RecordType::TypePair> lenPList,
-                         L::ArrayRef<RecordType::TypePair> typeList) {
+RecordType verifyDerived(mlir::DialectAsmParser &parser, RecordType derivedTy,
+                         llvm::ArrayRef<RecordType::TypePair> lenPList,
+                         llvm::ArrayRef<RecordType::TypePair> typeList) {
   auto loc = parser.getNameLoc();
   if (!verifySameLists(derivedTy.getLenParamList(), lenPList) ||
       !verifySameLists(derivedTy.getTypeList(), typeList)) {
@@ -236,8 +234,8 @@ RecordType verifyDerived(M::DialectAsmParser &parser, RecordType derivedTy,
 // `type` `<` name
 //           (`(` id `:` type (`,` id `:` type)* `)`)?
 //           (`{` id `:` type (`,` id `:` type)* `}`)? '>'
-RecordType parseDerived(M::DialectAsmParser &parser, M::Location) {
-  L::StringRef name;
+RecordType parseDerived(mlir::DialectAsmParser &parser, mlir::Location) {
+  llvm::StringRef name;
   if (parser.parseLess() || parser.parseKeyword(&name)) {
     parser.emitError(parser.getNameLoc(),
                      "expected a identifier as name of derived type");
@@ -248,8 +246,8 @@ RecordType parseDerived(M::DialectAsmParser &parser, M::Location) {
   RecordType::TypeList lenParamList;
   if (!parser.parseOptionalLParen()) {
     while (true) {
-      L::StringRef lenparam;
-      M::Type intTy;
+      llvm::StringRef lenparam;
+      mlir::Type intTy;
       if (parser.parseKeyword(&lenparam) || parser.parseColon() ||
           parser.parseType(intTy)) {
         parser.emitError(parser.getNameLoc(), "expected LEN parameter list");
@@ -268,8 +266,8 @@ RecordType parseDerived(M::DialectAsmParser &parser, M::Location) {
   RecordType::TypeList typeList;
   if (!parser.parseOptionalLBrace()) {
     while (true) {
-      L::StringRef field;
-      M::Type fldTy;
+      llvm::StringRef field;
+      mlir::Type fldTy;
       if (parser.parseKeyword(&field) || parser.parseColon() ||
           parser.parseType(fldTy)) {
         parser.emitError(parser.getNameLoc(), "expected field type list");
@@ -299,7 +297,7 @@ RecordType parseDerived(M::DialectAsmParser &parser, M::Location) {
 
 // !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
 // is undefined and disallowed.
-bool singleIndirectionLevel(M::Type ty) {
+bool singleIndirectionLevel(mlir::Type ty) {
   return !(ty.dyn_cast<ReferenceType>() || ty.dyn_cast<PointerType>() ||
            ty.dyn_cast<HeapType>());
 }
@@ -308,9 +306,9 @@ bool singleIndirectionLevel(M::Type ty) {
 
 // Implementation of the thin interface from dialect to type parser
 
-M::Type fir::parseFirType(FIROpsDialect *, M::DialectAsmParser &parser) {
-  L::StringRef typeNameLit;
-  if (M::failed(parser.parseKeyword(&typeNameLit)))
+mlir::Type fir::parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser) {
+  llvm::StringRef typeNameLit;
+  if (mlir::failed(parser.parseKeyword(&typeNameLit)))
     return {};
 
   auto loc = parser.getEncodedSourceLoc(parser.getNameLoc());
@@ -361,14 +359,14 @@ namespace detail {
 // Type storage classes
 
 /// `CHARACTER` storage
-struct CharacterTypeStorage : public M::TypeStorage {
+struct CharacterTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getFKind(); }
 
-  static CharacterTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static CharacterTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                          KindTy kind) {
     auto *storage = allocator.allocate<CharacterTypeStorage>();
     return new (storage) CharacterTypeStorage{kind};
@@ -384,16 +382,16 @@ struct CharacterTypeStorage : public M::TypeStorage {
   explicit CharacterTypeStorage(KindTy kind) : kind{kind} {}
 };
 
-struct DimsTypeStorage : public M::TypeStorage {
+struct DimsTypeStorage : public mlir::TypeStorage {
   using KeyTy = unsigned;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const {
     return key == static_cast<unsigned>(getRank());
   }
 
-  static DimsTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static DimsTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                     int rank) {
     auto *storage = allocator.allocate<DimsTypeStorage>();
     return new (storage) DimsTypeStorage{rank};
@@ -410,14 +408,14 @@ struct DimsTypeStorage : public M::TypeStorage {
 };
 
 /// The type of a derived type part reference
-struct FieldTypeStorage : public M::TypeStorage {
+struct FieldTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &) { return L::hash_combine(0); }
+  static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
 
   bool operator==(const KeyTy &) const { return true; }
 
-  static FieldTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static FieldTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                      KindTy) {
     auto *storage = allocator.allocate<FieldTypeStorage>();
     return new (storage) FieldTypeStorage{0};
@@ -429,14 +427,15 @@ struct FieldTypeStorage : public M::TypeStorage {
 };
 
 /// The type of a derived type LEN parameter reference
-struct LenTypeStorage : public M::TypeStorage {
+struct LenTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &) { return L::hash_combine(0); }
+  static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
 
   bool operator==(const KeyTy &) const { return true; }
 
-  static LenTypeStorage *construct(M::TypeStorageAllocator &allocator, KindTy) {
+  static LenTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                   KindTy) {
     auto *storage = allocator.allocate<LenTypeStorage>();
     return new (storage) LenTypeStorage{0};
   }
@@ -447,14 +446,14 @@ struct LenTypeStorage : public M::TypeStorage {
 };
 
 /// `LOGICAL` storage
-struct LogicalTypeStorage : public M::TypeStorage {
+struct LogicalTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getFKind(); }
 
-  static LogicalTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static LogicalTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                        KindTy kind) {
     auto *storage = allocator.allocate<LogicalTypeStorage>();
     return new (storage) LogicalTypeStorage{kind};
@@ -471,14 +470,14 @@ struct LogicalTypeStorage : public M::TypeStorage {
 };
 
 /// `INTEGER` storage
-struct IntTypeStorage : public M::TypeStorage {
+struct IntTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getFKind(); }
 
-  static IntTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static IntTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                    KindTy kind) {
     auto *storage = allocator.allocate<IntTypeStorage>();
     return new (storage) IntTypeStorage{kind};
@@ -495,14 +494,14 @@ struct IntTypeStorage : public M::TypeStorage {
 };
 
 /// `COMPLEX` storage
-struct CplxTypeStorage : public M::TypeStorage {
+struct CplxTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getFKind(); }
 
-  static CplxTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static CplxTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                     KindTy kind) {
     auto *storage = allocator.allocate<CplxTypeStorage>();
     return new (storage) CplxTypeStorage{kind};
@@ -519,14 +518,14 @@ struct CplxTypeStorage : public M::TypeStorage {
 };
 
 /// `REAL` storage (for reals of unsupported sizes)
-struct RealTypeStorage : public M::TypeStorage {
+struct RealTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getFKind(); }
 
-  static RealTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static RealTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                     KindTy kind) {
     auto *storage = allocator.allocate<RealTypeStorage>();
     return new (storage) RealTypeStorage{kind};
@@ -543,49 +542,49 @@ struct RealTypeStorage : public M::TypeStorage {
 };
 
 /// Boxed object (a Fortran descriptor)
-struct BoxTypeStorage : public M::TypeStorage {
-  using KeyTy = std::tuple<M::Type, M::AffineMapAttr>;
+struct BoxTypeStorage : public mlir::TypeStorage {
+  using KeyTy = std::tuple<mlir::Type, mlir::AffineMapAttr>;
 
   static unsigned hashKey(const KeyTy &key) {
-    auto hashVal{L::hash_combine(std::get<M::Type>(key))};
-    return L::hash_combine(hashVal,
-                           L::hash_combine(std::get<M::AffineMapAttr>(key)));
+    auto hashVal{llvm::hash_combine(std::get<mlir::Type>(key))};
+    return llvm::hash_combine(
+        hashVal, llvm::hash_combine(std::get<mlir::AffineMapAttr>(key)));
   }
 
   bool operator==(const KeyTy &key) const {
-    return std::get<M::Type>(key) == getElementType() &&
-           std::get<M::AffineMapAttr>(key) == getLayoutMap();
+    return std::get<mlir::Type>(key) == getElementType() &&
+           std::get<mlir::AffineMapAttr>(key) == getLayoutMap();
   }
 
-  static BoxTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static BoxTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                    const KeyTy &key) {
     auto *storage = allocator.allocate<BoxTypeStorage>();
-    return new (storage)
-        BoxTypeStorage{std::get<M::Type>(key), std::get<M::AffineMapAttr>(key)};
+    return new (storage) BoxTypeStorage{std::get<mlir::Type>(key),
+                                        std::get<mlir::AffineMapAttr>(key)};
   }
 
-  M::Type getElementType() const { return eleTy; }
-  M::AffineMapAttr getLayoutMap() const { return map; }
+  mlir::Type getElementType() const { return eleTy; }
+  mlir::AffineMapAttr getLayoutMap() const { return map; }
 
 protected:
-  M::Type eleTy;
-  M::AffineMapAttr map;
+  mlir::Type eleTy;
+  mlir::AffineMapAttr map;
 
 private:
   BoxTypeStorage() = delete;
-  explicit BoxTypeStorage(M::Type eleTy, M::AffineMapAttr map)
+  explicit BoxTypeStorage(mlir::Type eleTy, mlir::AffineMapAttr map)
       : eleTy{eleTy}, map{map} {}
 };
 
 /// Boxed CHARACTER object type
-struct BoxCharTypeStorage : public M::TypeStorage {
+struct BoxCharTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getFKind(); }
 
-  static BoxCharTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static BoxCharTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                        KindTy kind) {
     auto *storage = allocator.allocate<BoxCharTypeStorage>();
     return new (storage) BoxCharTypeStorage{kind};
@@ -594,7 +593,7 @@ struct BoxCharTypeStorage : public M::TypeStorage {
   KindTy getFKind() const { return kind; }
 
   // a !fir.boxchar<k> always wraps a !fir.char<k>
-  CharacterType getElementType(M::MLIRContext *ctxt) const {
+  CharacterType getElementType(mlir::MLIRContext *ctxt) const {
     return CharacterType::get(ctxt, getFKind());
   }
 
@@ -607,169 +606,172 @@ struct BoxCharTypeStorage : public M::TypeStorage {
 };
 
 /// Boxed PROCEDURE POINTER object type
-struct BoxProcTypeStorage : public M::TypeStorage {
-  using KeyTy = M::Type;
+struct BoxProcTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getElementType(); }
 
-  static BoxProcTypeStorage *construct(M::TypeStorageAllocator &allocator,
-                                       M::Type eleTy) {
+  static BoxProcTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                       mlir::Type eleTy) {
     assert(eleTy && "element type is null");
     auto *storage = allocator.allocate<BoxProcTypeStorage>();
     return new (storage) BoxProcTypeStorage{eleTy};
   }
 
-  M::Type getElementType() const { return eleTy; }
+  mlir::Type getElementType() const { return eleTy; }
 
 protected:
-  M::Type eleTy;
+  mlir::Type eleTy;
 
 private:
   BoxProcTypeStorage() = delete;
-  explicit BoxProcTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+  explicit BoxProcTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
 };
 
 /// Pointer-like object storage
-struct ReferenceTypeStorage : public M::TypeStorage {
-  using KeyTy = M::Type;
+struct ReferenceTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getElementType(); }
 
-  static ReferenceTypeStorage *construct(M::TypeStorageAllocator &allocator,
-                                         M::Type eleTy) {
+  static ReferenceTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                         mlir::Type eleTy) {
     assert(eleTy && "element type is null");
     auto *storage = allocator.allocate<ReferenceTypeStorage>();
     return new (storage) ReferenceTypeStorage{eleTy};
   }
 
-  M::Type getElementType() const { return eleTy; }
+  mlir::Type getElementType() const { return eleTy; }
 
 protected:
-  M::Type eleTy;
+  mlir::Type eleTy;
 
 private:
   ReferenceTypeStorage() = delete;
-  explicit ReferenceTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+  explicit ReferenceTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
 };
 
 /// Pointer object storage
-struct PointerTypeStorage : public M::TypeStorage {
-  using KeyTy = M::Type;
+struct PointerTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getElementType(); }
 
-  static PointerTypeStorage *construct(M::TypeStorageAllocator &allocator,
-                                       M::Type eleTy) {
+  static PointerTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                       mlir::Type eleTy) {
     assert(eleTy && "element type is null");
     auto *storage = allocator.allocate<PointerTypeStorage>();
     return new (storage) PointerTypeStorage{eleTy};
   }
 
-  M::Type getElementType() const { return eleTy; }
+  mlir::Type getElementType() const { return eleTy; }
 
 protected:
-  M::Type eleTy;
+  mlir::Type eleTy;
 
 private:
   PointerTypeStorage() = delete;
-  explicit PointerTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+  explicit PointerTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
 };
 
 /// Heap memory reference object storage
-struct HeapTypeStorage : public M::TypeStorage {
-  using KeyTy = M::Type;
+struct HeapTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getElementType(); }
 
-  static HeapTypeStorage *construct(M::TypeStorageAllocator &allocator,
-                                    M::Type eleTy) {
+  static HeapTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                    mlir::Type eleTy) {
     assert(eleTy && "element type is null");
     auto *storage = allocator.allocate<HeapTypeStorage>();
     return new (storage) HeapTypeStorage{eleTy};
   }
 
-  M::Type getElementType() const { return eleTy; }
+  mlir::Type getElementType() const { return eleTy; }
 
 protected:
-  M::Type eleTy;
+  mlir::Type eleTy;
 
 private:
   HeapTypeStorage() = delete;
-  explicit HeapTypeStorage(M::Type eleTy) : eleTy{eleTy} {}
+  explicit HeapTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
 };
 
 /// Sequence-like object storage
-struct SequenceTypeStorage : public M::TypeStorage {
-  using KeyTy = std::tuple<SequenceType::Shape, M::Type, M::AffineMapAttr>;
+struct SequenceTypeStorage : public mlir::TypeStorage {
+  using KeyTy =
+      std::tuple<SequenceType::Shape, mlir::Type, mlir::AffineMapAttr>;
 
   static unsigned hashKey(const KeyTy &key) {
     auto shapeHash{hash_value(std::get<SequenceType::Shape>(key))};
-    shapeHash = L::hash_combine(shapeHash, std::get<M::Type>(key));
-    return L::hash_combine(shapeHash, std::get<M::AffineMapAttr>(key));
+    shapeHash = llvm::hash_combine(shapeHash, std::get<mlir::Type>(key));
+    return llvm::hash_combine(shapeHash, std::get<mlir::AffineMapAttr>(key));
   }
 
   bool operator==(const KeyTy &key) const {
     return key == KeyTy{getShape(), getElementType(), getLayoutMap()};
   }
 
-  static SequenceTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static SequenceTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                         const KeyTy &key) {
     auto *storage = allocator.allocate<SequenceTypeStorage>();
-    return new (storage) SequenceTypeStorage{std::get<SequenceType::Shape>(key),
-                                             std::get<M::Type>(key),
-                                             std::get<M::AffineMapAttr>(key)};
+    return new (storage) SequenceTypeStorage{
+        std::get<SequenceType::Shape>(key), std::get<mlir::Type>(key),
+        std::get<mlir::AffineMapAttr>(key)};
   }
 
   SequenceType::Shape getShape() const { return shape; }
-  M::Type getElementType() const { return eleTy; }
-  M::AffineMapAttr getLayoutMap() const { return map; }
+  mlir::Type getElementType() const { return eleTy; }
+  mlir::AffineMapAttr getLayoutMap() const { return map; }
 
 protected:
   SequenceType::Shape shape;
-  M::Type eleTy;
-  M::AffineMapAttr map;
+  mlir::Type eleTy;
+  mlir::AffineMapAttr map;
 
 private:
   SequenceTypeStorage() = delete;
-  explicit SequenceTypeStorage(const SequenceType::Shape &shape, M::Type eleTy,
-                               M::AffineMapAttr map)
+  explicit SequenceTypeStorage(const SequenceType::Shape &shape,
+                               mlir::Type eleTy, mlir::AffineMapAttr map)
       : shape{shape}, eleTy{eleTy}, map{map} {}
 };
 
 /// Derived type storage
-struct RecordTypeStorage : public M::TypeStorage {
-  using KeyTy = L::StringRef;
+struct RecordTypeStorage : public mlir::TypeStorage {
+  using KeyTy = llvm::StringRef;
 
   static unsigned hashKey(const KeyTy &key) {
-    return L::hash_combine(key.str());
+    return llvm::hash_combine(key.str());
   }
 
   bool operator==(const KeyTy &key) const { return key == getName(); }
 
-  static RecordTypeStorage *construct(M::TypeStorageAllocator &allocator,
+  static RecordTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                       const KeyTy &key) {
     auto *storage = allocator.allocate<RecordTypeStorage>();
     return new (storage) RecordTypeStorage{key};
   }
 
-  L::StringRef getName() const { return name; }
+  llvm::StringRef getName() const { return name; }
 
-  void setLenParamList(L::ArrayRef<RecordType::TypePair> list) { lens = list; }
-  L::ArrayRef<RecordType::TypePair> getLenParamList() const { return lens; }
+  void setLenParamList(llvm::ArrayRef<RecordType::TypePair> list) {
+    lens = list;
+  }
+  llvm::ArrayRef<RecordType::TypePair> getLenParamList() const { return lens; }
 
-  void setTypeList(L::ArrayRef<RecordType::TypePair> list) { types = list; }
-  L::ArrayRef<RecordType::TypePair> getTypeList() const { return types; }
+  void setTypeList(llvm::ArrayRef<RecordType::TypePair> list) { types = list; }
+  llvm::ArrayRef<RecordType::TypePair> getTypeList() const { return types; }
 
-  void finalize(L::ArrayRef<RecordType::TypePair> lenParamList,
-                L::ArrayRef<RecordType::TypePair> typeList) {
+  void finalize(llvm::ArrayRef<RecordType::TypePair> lenParamList,
+                llvm::ArrayRef<RecordType::TypePair> typeList) {
     if (finalized)
       return;
     finalized = true;
@@ -785,34 +787,34 @@ struct RecordTypeStorage : public M::TypeStorage {
 
 private:
   RecordTypeStorage() = delete;
-  explicit RecordTypeStorage(L::StringRef name)
+  explicit RecordTypeStorage(llvm::StringRef name)
       : name{name}, finalized{false} {}
 };
 
 /// Type descriptor type storage
-struct TypeDescTypeStorage : public M::TypeStorage {
-  using KeyTy = M::Type;
+struct TypeDescTypeStorage : public mlir::TypeStorage {
+  using KeyTy = mlir::Type;
 
-  static unsigned hashKey(const KeyTy &key) { return L::hash_combine(key); }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getOfType(); }
 
-  static TypeDescTypeStorage *construct(M::TypeStorageAllocator &allocator,
-                                        M::Type ofTy) {
+  static TypeDescTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+                                        mlir::Type ofTy) {
     assert(ofTy && "descriptor type is null");
     auto *storage = allocator.allocate<TypeDescTypeStorage>();
     return new (storage) TypeDescTypeStorage{ofTy};
   }
 
   // The type described by this type descriptor instance
-  M::Type getOfType() const { return ofTy; }
+  mlir::Type getOfType() const { return ofTy; }
 
 protected:
-  M::Type ofTy;
+  mlir::Type ofTy;
 
 private:
   TypeDescTypeStorage() = delete;
-  explicit TypeDescTypeStorage(M::Type ofTy) : ofTy{ofTy} {}
+  explicit TypeDescTypeStorage(mlir::Type ofTy) : ofTy{ofTy} {}
 };
 
 } // namespace detail
@@ -824,12 +826,13 @@ bool inbounds(A v, B lb, B ub) {
 }
 
 bool fir::isa_fir_type(mlir::Type t) {
-  return inbounds(t.getKind(), M::Type::FIRST_FIR_TYPE, M::Type::LAST_FIR_TYPE);
+  return inbounds(t.getKind(), mlir::Type::FIRST_FIR_TYPE,
+                  mlir::Type::LAST_FIR_TYPE);
 }
 
 bool fir::isa_std_type(mlir::Type t) {
-  return inbounds(t.getKind(), M::Type::FIRST_STANDARD_TYPE,
-                  M::Type::LAST_STANDARD_TYPE);
+  return inbounds(t.getKind(), mlir::Type::FIRST_STANDARD_TYPE,
+                  mlir::Type::LAST_STANDARD_TYPE);
 }
 
 bool fir::isa_fir_or_std_type(mlir::Type t) {
@@ -838,7 +841,7 @@ bool fir::isa_fir_or_std_type(mlir::Type t) {
 
 // CHARACTER
 
-CharacterType fir::CharacterType::get(M::MLIRContext *ctxt, KindTy kind) {
+CharacterType fir::CharacterType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_CHARACTER, kind);
 }
 
@@ -846,7 +849,7 @@ int fir::CharacterType::getFKind() const { return getImpl()->getFKind(); }
 
 // Dims
 
-DimsType fir::DimsType::get(M::MLIRContext *ctxt, unsigned rank) {
+DimsType fir::DimsType::get(mlir::MLIRContext *ctxt, unsigned rank) {
   return Base::get(ctxt, FIR_DIMS, rank);
 }
 
@@ -854,19 +857,19 @@ int fir::DimsType::getRank() const { return getImpl()->getRank(); }
 
 // Field
 
-FieldType fir::FieldType::get(M::MLIRContext *ctxt, KindTy) {
+FieldType fir::FieldType::get(mlir::MLIRContext *ctxt, KindTy) {
   return Base::get(ctxt, FIR_FIELD, 0);
 }
 
 // Len
 
-LenType fir::LenType::get(M::MLIRContext *ctxt, KindTy) {
+LenType fir::LenType::get(mlir::MLIRContext *ctxt, KindTy) {
   return Base::get(ctxt, FIR_LEN, 0);
 }
 
 // LOGICAL
 
-LogicalType fir::LogicalType::get(M::MLIRContext *ctxt, KindTy kind) {
+LogicalType fir::LogicalType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_LOGICAL, kind);
 }
 
@@ -874,7 +877,7 @@ int fir::LogicalType::getFKind() const { return getImpl()->getFKind(); }
 
 // INTEGER
 
-IntType fir::IntType::get(M::MLIRContext *ctxt, KindTy kind) {
+IntType fir::IntType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_INT, kind);
 }
 
@@ -882,7 +885,7 @@ int fir::IntType::getFKind() const { return getImpl()->getFKind(); }
 
 // COMPLEX
 
-CplxType fir::CplxType::get(M::MLIRContext *ctxt, KindTy kind) {
+CplxType fir::CplxType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_COMPLEX, kind);
 }
 
@@ -890,7 +893,7 @@ KindTy fir::CplxType::getFKind() const { return getImpl()->getFKind(); }
 
 // REAL
 
-RealType fir::RealType::get(M::MLIRContext *ctxt, KindTy kind) {
+RealType fir::RealType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_REAL, kind);
 }
 
@@ -898,27 +901,28 @@ int fir::RealType::getFKind() const { return getImpl()->getFKind(); }
 
 // Box<T>
 
-BoxType fir::BoxType::get(M::Type elementType, M::AffineMapAttr map) {
+BoxType fir::BoxType::get(mlir::Type elementType, mlir::AffineMapAttr map) {
   return Base::get(elementType.getContext(), FIR_BOX, elementType, map);
 }
 
-M::Type fir::BoxType::getEleTy() const { return getImpl()->getElementType(); }
+mlir::Type fir::BoxType::getEleTy() const {
+  return getImpl()->getElementType();
+}
 
-M::AffineMapAttr fir::BoxType::getLayoutMap() const {
+mlir::AffineMapAttr fir::BoxType::getLayoutMap() const {
   return getImpl()->getLayoutMap();
 }
 
-M::LogicalResult
-fir::BoxType::verifyConstructionInvariants(L::Optional<M::Location>,
-                                           M::MLIRContext *ctx, M::Type eleTy,
-                                           mlir::AffineMapAttr map) {
+mlir::LogicalResult fir::BoxType::verifyConstructionInvariants(
+    llvm::Optional<mlir::Location>, mlir::MLIRContext *ctx, mlir::Type eleTy,
+    mlir::AffineMapAttr map) {
   // TODO
-  return M::success();
+  return mlir::success();
 }
 
 // BoxChar<C>
 
-BoxCharType fir::BoxCharType::get(M::MLIRContext *ctxt, KindTy kind) {
+BoxCharType fir::BoxCharType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_BOXCHAR, kind);
 }
 
@@ -928,43 +932,45 @@ CharacterType fir::BoxCharType::getEleTy() const {
 
 // BoxProc<T>
 
-BoxProcType fir::BoxProcType::get(M::Type elementType) {
+BoxProcType fir::BoxProcType::get(mlir::Type elementType) {
   return Base::get(elementType.getContext(), FIR_BOXPROC, elementType);
 }
 
-M::Type fir::BoxProcType::getEleTy() const {
+mlir::Type fir::BoxProcType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-M::LogicalResult fir::BoxProcType::verifyConstructionInvariants(
-    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
-  if (eleTy.dyn_cast<M::FunctionType>() || eleTy.dyn_cast<ReferenceType>())
-    return M::success();
-  return M::failure();
+mlir::LogicalResult fir::BoxProcType::verifyConstructionInvariants(
+    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
+    mlir::Type eleTy) {
+  if (eleTy.dyn_cast<mlir::FunctionType>() || eleTy.dyn_cast<ReferenceType>())
+    return mlir::success();
+  return mlir::failure();
 }
 
 // Reference<T>
 
-ReferenceType fir::ReferenceType::get(M::Type elementType) {
+ReferenceType fir::ReferenceType::get(mlir::Type elementType) {
   return Base::get(elementType.getContext(), FIR_REFERENCE, elementType);
 }
 
-M::Type fir::ReferenceType::getEleTy() const {
+mlir::Type fir::ReferenceType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-M::LogicalResult fir::ReferenceType::verifyConstructionInvariants(
-    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+mlir::LogicalResult fir::ReferenceType::verifyConstructionInvariants(
+    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
+    mlir::Type eleTy) {
   if (eleTy.dyn_cast<DimsType>() || eleTy.dyn_cast<FieldType>() ||
       eleTy.dyn_cast<LenType>() || eleTy.dyn_cast<ReferenceType>() ||
       eleTy.dyn_cast<TypeDescType>())
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
 // Pointer<T>
 
-PointerType fir::PointerType::get(M::Type elementType) {
+PointerType fir::PointerType::get(mlir::Type elementType) {
   if (!singleIndirectionLevel(elementType)) {
     assert(false && "FIXME: invalid element type");
     return {};
@@ -972,24 +978,25 @@ PointerType fir::PointerType::get(M::Type elementType) {
   return Base::get(elementType.getContext(), FIR_POINTER, elementType);
 }
 
-M::Type fir::PointerType::getEleTy() const {
+mlir::Type fir::PointerType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-M::LogicalResult fir::PointerType::verifyConstructionInvariants(
-    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+mlir::LogicalResult fir::PointerType::verifyConstructionInvariants(
+    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
+    mlir::Type eleTy) {
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
       eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
       eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
       eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
 // Heap<T>
 
-HeapType fir::HeapType::get(M::Type elementType) {
+HeapType fir::HeapType::get(mlir::Type elementType) {
   if (!singleIndirectionLevel(elementType)) {
     assert(false && "FIXME: invalid element type");
     return {};
@@ -997,32 +1004,36 @@ HeapType fir::HeapType::get(M::Type elementType) {
   return Base::get(elementType.getContext(), FIR_HEAP, elementType);
 }
 
-M::Type fir::HeapType::getEleTy() const { return getImpl()->getElementType(); }
+mlir::Type fir::HeapType::getEleTy() const {
+  return getImpl()->getElementType();
+}
 
-M::LogicalResult fir::HeapType::verifyConstructionInvariants(
-    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+mlir::LogicalResult
+fir::HeapType::verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
+                                            mlir::MLIRContext *context,
+                                            mlir::Type eleTy) {
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
       eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
       eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
       eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
 // Sequence<T>
 
-SequenceType fir::SequenceType::get(const Shape &shape, M::Type elementType,
-                                    M::AffineMapAttr map) {
+SequenceType fir::SequenceType::get(const Shape &shape, mlir::Type elementType,
+                                    mlir::AffineMapAttr map) {
   auto *ctxt = elementType.getContext();
   return Base::get(ctxt, FIR_SEQUENCE, shape, elementType, map);
 }
 
-M::Type fir::SequenceType::getEleTy() const {
+mlir::Type fir::SequenceType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-M::AffineMapAttr fir::SequenceType::getLayoutMap() const {
+mlir::AffineMapAttr fir::SequenceType::getLayoutMap() const {
   return getImpl()->getLayoutMap();
 }
 
@@ -1030,9 +1041,10 @@ SequenceType::Shape fir::SequenceType::getShape() const {
   return getImpl()->getShape();
 }
 
-M::LogicalResult fir::SequenceType::verifyConstructionInvariants(
-    L::Optional<mlir::Location> loc, M::MLIRContext *context,
-    const SequenceType::Shape &shape, M::Type eleTy, M::AffineMapAttr map) {
+mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
+    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
+    const SequenceType::Shape &shape, mlir::Type eleTy,
+    mlir::AffineMapAttr map) {
   // DIMENSION attribute can only be applied to an intrinsic or record type
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
@@ -1040,8 +1052,8 @@ M::LogicalResult fir::SequenceType::verifyConstructionInvariants(
       eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
       eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>() ||
       eleTy.dyn_cast<SequenceType>())
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
 // compare if two shapes are equivalent
@@ -1056,27 +1068,27 @@ bool fir::operator==(const SequenceType::Shape &sh_1,
 }
 
 // compute the hash of a Shape
-L::hash_code fir::hash_value(const SequenceType::Shape &sh) {
+llvm::hash_code fir::hash_value(const SequenceType::Shape &sh) {
   if (sh.size()) {
-    return L::hash_combine_range(sh.begin(), sh.end());
+    return llvm::hash_combine_range(sh.begin(), sh.end());
   }
-  return L::hash_combine(0);
+  return llvm::hash_combine(0);
 }
 
 /// RecordType
 ///
 /// This type captures a Fortran "derived type"
 
-RecordType fir::RecordType::get(M::MLIRContext *ctxt, L::StringRef name) {
+RecordType fir::RecordType::get(mlir::MLIRContext *ctxt, llvm::StringRef name) {
   return Base::get(ctxt, FIR_DERIVED, name);
 }
 
-void fir::RecordType::finalize(L::ArrayRef<TypePair> lenPList,
-                               L::ArrayRef<TypePair> typeList) {
+void fir::RecordType::finalize(llvm::ArrayRef<TypePair> lenPList,
+                               llvm::ArrayRef<TypePair> typeList) {
   getImpl()->finalize(lenPList, typeList);
 }
 
-L::StringRef fir::RecordType::getName() { return getImpl()->getName(); }
+llvm::StringRef fir::RecordType::getName() { return getImpl()->getName(); }
 
 RecordType::TypeList fir::RecordType::getTypeList() {
   return getImpl()->getTypeList();
@@ -1090,14 +1102,16 @@ detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
   return getImpl();
 }
 
-M::LogicalResult fir::RecordType::verifyConstructionInvariants(
-    L::Optional<mlir::Location>, M::MLIRContext *context, L::StringRef name) {
+mlir::LogicalResult
+fir::RecordType::verifyConstructionInvariants(llvm::Optional<mlir::Location>,
+                                              mlir::MLIRContext *context,
+                                              llvm::StringRef name) {
   if (name.size() == 0)
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
-M::Type fir::RecordType::getType(L::StringRef ident) {
+mlir::Type fir::RecordType::getType(llvm::StringRef ident) {
   for (auto f : getTypeList())
     if (ident == f.first)
       return f.second;
@@ -1109,21 +1123,22 @@ M::Type fir::RecordType::getType(L::StringRef ident) {
 ///
 /// This is the type of a type descriptor object (similar to a class instance)
 
-TypeDescType fir::TypeDescType::get(M::Type ofType) {
+TypeDescType fir::TypeDescType::get(mlir::Type ofType) {
   assert(!ofType.dyn_cast<ReferenceType>());
   return Base::get(ofType.getContext(), FIR_TYPEDESC, ofType);
 }
 
-M::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
+mlir::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
 
-M::LogicalResult fir::TypeDescType::verifyConstructionInvariants(
-    L::Optional<M::Location> loc, M::MLIRContext *context, M::Type eleTy) {
+mlir::LogicalResult fir::TypeDescType::verifyConstructionInvariants(
+    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
+    mlir::Type eleTy) {
   if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
       eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
       eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
       eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
-    return M::failure();
-  return M::success();
+    return mlir::failure();
+  return mlir::success();
 }
 
 namespace {
@@ -1143,7 +1158,8 @@ llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4> recordTypeVisited;
 
 } // namespace
 
-void fir::printFirType(FIROpsDialect *, M::Type ty, M::DialectAsmPrinter &p) {
+void fir::printFirType(FIROpsDialect *, mlir::Type ty,
+                       mlir::DialectAsmPrinter &p) {
   auto &os = p.getStream();
   switch (ty.getKind()) {
   case fir::FIR_BOX: {
diff --git a/lib/fir/InternalNames.cpp b/lib/fir/InternalNames.cpp
index 5680ad8ab940..ca4ed337d344 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/fir/InternalNames.cpp
@@ -11,55 +11,53 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 
-namespace L = llvm;
-
 namespace {
 
-inline L::StringRef prefix() { return "_Q"; }
+inline llvm::StringRef prefix() { return "_Q"; }
 
-std::string doModules(L::ArrayRef<L::StringRef> mods) {
+std::string doModules(llvm::ArrayRef<llvm::StringRef> mods) {
   std::string result;
   auto *token = "M";
   for (auto mod : mods) {
-    L::Twine t = result + token + mod;
+    llvm::Twine t = result + token + mod;
     result = t.str();
     token = "S";
   }
   return result;
 }
 
-std::string doModulesHost(L::ArrayRef<L::StringRef> mods,
-                          L::Optional<L::StringRef> host) {
+std::string doModulesHost(llvm::ArrayRef<llvm::StringRef> mods,
+                          llvm::Optional<llvm::StringRef> host) {
   auto result = doModules(mods);
   if (host.hasValue()) {
-    L::Twine t = result + "F" + *host;
+    llvm::Twine t = result + "F" + *host;
     result = t.str();
   }
   return result;
 }
 
-inline L::SmallVector<L::StringRef, 2>
-convertToStringRef(L::ArrayRef<std::string> from) {
+inline llvm::SmallVector<llvm::StringRef, 2>
+convertToStringRef(llvm::ArrayRef<std::string> from) {
   return {from.begin(), from.end()};
 }
 
-inline L::Optional<L::StringRef>
-convertToStringRef(const L::Optional<std::string> &from) {
-  L::Optional<L::StringRef> to;
+inline llvm::Optional<llvm::StringRef>
+convertToStringRef(const llvm::Optional<std::string> &from) {
+  llvm::Optional<llvm::StringRef> to;
   if (from.hasValue())
     to = from.getValue();
   return to;
 }
 
-std::string readName(L::StringRef uniq, std::size_t &i, std::size_t init,
+std::string readName(llvm::StringRef uniq, std::size_t &i, std::size_t init,
                      std::size_t end) {
   for (i = init; i < end && uniq[i] >= 'a' && uniq[i] <= 'z'; ++i) {
     // do nothing
   }
-  return uniq.substr(init, i);
+  return uniq.substr(init, i).str();
 }
 
-std::int64_t readInt(L::StringRef uniq, std::size_t &i, std::size_t init,
+std::int64_t readInt(llvm::StringRef uniq, std::size_t &i, std::size_t init,
                      std::size_t end) {
   for (i = init; i < end && uniq[i] >= '0' && uniq[i] <= '9'; ++i) {
     // do nothing
@@ -71,61 +69,64 @@ std::int64_t readInt(L::StringRef uniq, std::size_t &i, std::size_t init,
 
 } // namespace
 
-L::StringRef fir::NameUniquer::toLower(L::StringRef name) {
+llvm::StringRef fir::NameUniquer::toLower(llvm::StringRef name) {
   auto lo = name.lower();
   if (name.equals(lo))
     return name;
   return cache.insert(lo).first->getKey();
 }
 
-L::StringRef fir::NameUniquer::addAsString(std::int64_t i) {
+llvm::StringRef fir::NameUniquer::addAsString(std::int64_t i) {
   return cache.insert(std::to_string(i)).first->getKey();
 }
 
 std::string fir::NameUniquer::doKind(std::int64_t kind) {
   if (kind < 0) {
-    L::Twine result = "KN" + addAsString(-kind);
+    llvm::Twine result = "KN" + addAsString(-kind);
     return result.str();
   }
-  L::Twine result = "K" + addAsString(kind);
+  llvm::Twine result = "K" + addAsString(kind);
   return result.str();
 }
 
-std::string fir::NameUniquer::doKinds(L::ArrayRef<std::int64_t> kinds) {
-  L::Twine result;
+std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
+  llvm::Twine result;
   for (auto i : kinds)
     result.concat(doKind(i));
   return result.str();
 }
 
-std::string fir::NameUniquer::doCommonBlock(L::StringRef name) {
-  L::Twine result = prefix() + "B" + toLower(name);
+std::string fir::NameUniquer::doCommonBlock(llvm::StringRef name) {
+  llvm::Twine result = prefix() + "B" + toLower(name);
   return result.str();
 }
 
-std::string fir::NameUniquer::doConstant(L::ArrayRef<L::StringRef> modules,
-                                         L::StringRef name) {
-  L::Twine result = prefix() + doModules(modules) + "EC" + toLower(name);
+std::string
+fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules,
+                             llvm::StringRef name) {
+  llvm::Twine result = prefix() + doModules(modules) + "EC" + toLower(name);
   return result.str();
 }
 
-std::string fir::NameUniquer::doDispatchTable(L::ArrayRef<L::StringRef> modules,
-                                              L::Optional<L::StringRef> host,
-                                              L::StringRef name,
-                                              L::ArrayRef<std::int64_t> kinds) {
-  L::Twine result = prefix() + doModulesHost(modules, host) + "DT" +
-                    toLower(name) + doKinds(kinds);
+std::string
+fir::NameUniquer::doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
+                                  llvm::Optional<llvm::StringRef> host,
+                                  llvm::StringRef name,
+                                  llvm::ArrayRef<std::int64_t> kinds) {
+  llvm::Twine result = prefix() + doModulesHost(modules, host) + "DT" +
+                       toLower(name) + doKinds(kinds);
   return result.str();
 }
 
-std::string fir::NameUniquer::doGenerated(L::StringRef name) {
-  L::Twine result = prefix() + "Q" + toLower(name);
+std::string fir::NameUniquer::doGenerated(llvm::StringRef name) {
+  llvm::Twine result = prefix() + "Q" + toLower(name);
   return result.str();
 }
 
 std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
-    L::ArrayRef<L::StringRef> modules, L::Optional<L::StringRef> host,
-    IntrinsicType type, std::int64_t kind) {
+    llvm::ArrayRef<llvm::StringRef> modules,
+    llvm::Optional<llvm::StringRef> host, IntrinsicType type,
+    std::int64_t kind) {
   const char *name{nullptr};
   switch (type) {
   case IntrinsicType::CHARACTER:
@@ -144,57 +145,61 @@ std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
     name = "real";
     break;
   }
-  L::Twine result =
+  llvm::Twine result =
       prefix() + doModulesHost(modules, host) + "C" + name + doKind(kind);
   return result.str();
 }
 
-std::string fir::NameUniquer::doProcedure(L::ArrayRef<L::StringRef> modules,
-                                          L::Optional<L::StringRef> host,
-                                          L::StringRef name) {
-  L::Twine result =
+std::string
+fir::NameUniquer::doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
+                              llvm::Optional<llvm::StringRef> host,
+                              llvm::StringRef name) {
+  llvm::Twine result =
       prefix() + doModulesHost(modules, host) + "P" + toLower(name);
   return result.str();
 }
 
-std::string fir::NameUniquer::doType(L::ArrayRef<L::StringRef> modules,
-                                     L::Optional<L::StringRef> host,
-                                     L::StringRef name,
-                                     L::ArrayRef<std::int64_t> kinds) {
-  L::Twine result = prefix() + doModulesHost(modules, host) + "T" +
-                    toLower(name) + doKinds(kinds);
+std::string fir::NameUniquer::doType(llvm::ArrayRef<llvm::StringRef> modules,
+                                     llvm::Optional<llvm::StringRef> host,
+                                     llvm::StringRef name,
+                                     llvm::ArrayRef<std::int64_t> kinds) {
+  llvm::Twine result = prefix() + doModulesHost(modules, host) + "T" +
+                       toLower(name) + doKinds(kinds);
   return result.str();
 }
 
-std::string fir::NameUniquer::doTypeDescriptor(
-    L::ArrayRef<L::StringRef> modules, L::Optional<L::StringRef> host,
-    L::StringRef name, L::ArrayRef<std::int64_t> kinds) {
-  L::Twine result = prefix() + doModulesHost(modules, host) + "CT" +
-                    toLower(name) + doKinds(kinds);
+std::string
+fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+                                   llvm::Optional<llvm::StringRef> host,
+                                   llvm::StringRef name,
+                                   llvm::ArrayRef<std::int64_t> kinds) {
+  llvm::Twine result = prefix() + doModulesHost(modules, host) + "CT" +
+                       toLower(name) + doKinds(kinds);
   return result.str();
 }
 
 std::string fir::NameUniquer::doTypeDescriptor(
-    L::ArrayRef<std::string> modules, L::Optional<std::string> host,
-    L::StringRef name, L::ArrayRef<std::int64_t> kinds) {
+    llvm::ArrayRef<std::string> modules, llvm::Optional<std::string> host,
+    llvm::StringRef name, llvm::ArrayRef<std::int64_t> kinds) {
   auto rmodules = convertToStringRef(modules);
   auto rhost = convertToStringRef(host);
   return doTypeDescriptor(rmodules, rhost, name, kinds);
 }
 
-std::string fir::NameUniquer::doVariable(L::ArrayRef<L::StringRef> modules,
-                                         L::StringRef name) {
-  L::Twine result = prefix() + doModules(modules) + "E" + toLower(name);
+std::string
+fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules,
+                             llvm::StringRef name) {
+  llvm::Twine result = prefix() + doModules(modules) + "E" + toLower(name);
   return result.str();
 }
 
 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
-fir::NameUniquer::deconstruct(L::StringRef uniq) {
+fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
   if (uniq.startswith("_Q")) {
-    L::SmallVector<std::string, 4> modules;
-    L::Optional<std::string> host;
+    llvm::SmallVector<std::string, 4> modules;
+    llvm::Optional<std::string> host;
     std::string name;
-    L::SmallVector<std::int64_t, 8> kinds;
+    llvm::SmallVector<std::int64_t, 8> kinds;
     NameKind nk = NameKind::NOT_UNIQUED;
     for (std::size_t i = 2, end = uniq.size(); i != end;) {
       switch (uniq[i]) {
diff --git a/lib/fir/KindMapping.cpp b/lib/fir/KindMapping.cpp
index 7e9a07d976f2..231505bd3c10 100644
--- a/lib/fir/KindMapping.cpp
+++ b/lib/fir/KindMapping.cpp
@@ -16,21 +16,16 @@
 /// other MLIR dialect, only to LLVM IR. The default values follow the f18
 /// front-end kind mappings.
 
-namespace M = mlir;
+using Bitsize = fir::KindMapping::Bitsize;
+using KindTy = fir::KindMapping::KindTy;
+using LLVMTypeID = fir::KindMapping::LLVMTypeID;
+using MatchResult = fir::KindMapping::MatchResult;
 
-using namespace fir;
-using namespace llvm;
-
-using Bitsize = KindMapping::Bitsize;
-using KindTy = KindMapping::KindTy;
-using LLVMTypeID = KindMapping::LLVMTypeID;
-using MatchResult = KindMapping::MatchResult;
-
-static cl::opt<std::string>
-    ClKindMapping("kind-mapping",
-                  cl::desc("kind mapping string to set kind precision"),
-                  cl::value_desc("kind-mapping-string"), cl::init(""));
+static llvm::cl::opt<std::string> ClKindMapping(
+    "kind-mapping", llvm::cl::desc("kind mapping string to set kind precision"),
+    llvm::cl::value_desc("kind-mapping-string"), llvm::cl::init(""));
 
+namespace fir {
 namespace {
 
 /// Integral types default to the kind value being the size of the value in
@@ -63,7 +58,7 @@ LLVMTypeID defaultRealKind(KindTy kind) {
 // lookup the kind-value given the defaults, the mappings, and a KIND key
 template <typename RT, char KEY>
 RT doLookup(std::function<RT(KindTy)> def,
-            std::map<char, std::map<KindTy, RT>> const &map, KindTy kind) {
+            const std::map<char, std::map<KindTy, RT>> &map, KindTy kind) {
   auto iter = map.find(KEY);
   if (iter != map.end()) {
     auto iter2 = iter->second.find(kind);
@@ -75,17 +70,17 @@ RT doLookup(std::function<RT(KindTy)> def,
 
 // do a lookup for INTERGER, LOGICAL, or CHARACTER
 template <char KEY, typename MAP>
-Bitsize getIntegerLikeBitsize(KindTy kind, MAP const &map) {
+Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
   return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
 }
 
 // do a lookup for REAL or COMPLEX
 template <char KEY, typename MAP>
-LLVMTypeID getFloatLikeTypeID(KindTy kind, MAP const &map) {
+LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
   return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
 }
 
-MatchResult parseCode(char &code, char const *&ptr) {
+MatchResult parseCode(char &code, const char *&ptr) {
   if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
     return {};
   code = *ptr++;
@@ -93,24 +88,24 @@ MatchResult parseCode(char &code, char const *&ptr) {
 }
 
 template <char ch>
-MatchResult parseSingleChar(char const *&ptr) {
+MatchResult parseSingleChar(const char *&ptr) {
   if (*ptr != ch)
     return {};
   ++ptr;
   return {true};
 }
 
-MatchResult parseColon(char const *&ptr) { return parseSingleChar<':'>(ptr); }
+MatchResult parseColon(const char *&ptr) { return parseSingleChar<':'>(ptr); }
 
-MatchResult parseComma(char const *&ptr) { return parseSingleChar<','>(ptr); }
+MatchResult parseComma(const char *&ptr) { return parseSingleChar<','>(ptr); }
 
-MatchResult parseInt(unsigned &result, char const *&ptr) {
-  char const *beg = ptr;
+MatchResult parseInt(unsigned &result, const char *&ptr) {
+  const char *beg = ptr;
   while (*ptr >= '0' && *ptr <= '9')
     ptr++;
   if (beg == ptr)
     return {};
-  StringRef ref(beg, ptr - beg);
+  llvm::StringRef ref(beg, ptr - beg);
   int temp;
   if (ref.consumeInteger(10, temp))
     return {};
@@ -118,8 +113,8 @@ MatchResult parseInt(unsigned &result, char const *&ptr) {
   return {true};
 }
 
-bool matchString(char const *&ptr, StringRef literal) {
-  StringRef s(ptr);
+bool matchString(const char *&ptr, llvm::StringRef literal) {
+  llvm::StringRef s(ptr);
   if (s.startswith(literal)) {
     ptr += literal.size();
     return true;
@@ -127,7 +122,7 @@ bool matchString(char const *&ptr, StringRef literal) {
   return false;
 }
 
-MatchResult parseTypeID(LLVMTypeID &result, char const *&ptr) {
+MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
   if (matchString(ptr, "Half")) {
     result = LLVMTypeID::HalfTyID;
     return {true};
@@ -153,24 +148,24 @@ MatchResult parseTypeID(LLVMTypeID &result, char const *&ptr) {
 
 } // namespace
 
-fir::KindMapping::KindMapping(mlir::MLIRContext *context, StringRef map)
+KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map)
     : context{context} {
   parse(map);
 }
 
-fir::KindMapping::KindMapping(mlir::MLIRContext *context)
+KindMapping::KindMapping(mlir::MLIRContext *context)
     : KindMapping{context, ClKindMapping} {}
 
-MatchResult fir::KindMapping::badMapString(Twine const &ptr) {
+MatchResult KindMapping::badMapString(const llvm::Twine &ptr) {
   auto unknown = mlir::UnknownLoc::get(context);
   mlir::emitError(unknown, ptr);
   return {};
 }
 
-MatchResult fir::KindMapping::parse(StringRef kindMap) {
+MatchResult KindMapping::parse(llvm::StringRef kindMap) {
   if (kindMap.empty())
     return {true};
-  char const *srcPtr = kindMap.begin();
+  const char *srcPtr = kindMap.begin();
   while (true) {
     char code;
     KindTy kind;
@@ -197,22 +192,24 @@ MatchResult fir::KindMapping::parse(StringRef kindMap) {
   return {true};
 }
 
-Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) {
+Bitsize KindMapping::getCharacterBitsize(KindTy kind) {
   return getIntegerLikeBitsize<'a'>(kind, intMap);
 }
 
-Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) {
+Bitsize KindMapping::getIntegerBitsize(KindTy kind) {
   return getIntegerLikeBitsize<'i'>(kind, intMap);
 }
 
-Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) {
+Bitsize KindMapping::getLogicalBitsize(KindTy kind) {
   return getIntegerLikeBitsize<'l'>(kind, intMap);
 }
 
-LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) {
+LLVMTypeID KindMapping::getRealTypeID(KindTy kind) {
   return getFloatLikeTypeID<'r'>(kind, floatMap);
 }
 
-LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) {
+LLVMTypeID KindMapping::getComplexTypeID(KindTy kind) {
   return getFloatLikeTypeID<'c'>(kind, floatMap);
 }
+
+} // namespace fir
diff --git a/lib/lower/ASTBuilder.cpp b/lib/lower/ASTBuilder.cpp
index c234c8f02d2b..ead8243ccedd 100644
--- a/lib/lower/ASTBuilder.cpp
+++ b/lib/lower/ASTBuilder.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/ast-builder.cc ------------------------------------------===//
+//===-- lib/lower/AstBuilder.cc -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 6f78f1ecebd7..1566b5ee6e6f 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/bridge.cc -------------------------------------*- C++ -*-===//
+//===-- Bridge.cc ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -122,7 +122,7 @@ class FirConverter : public AbstractConverter {
   static const Pa::SubroutineStmt *inSubroutine(AST::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
-            [](AST::FunctionLikeUnit *c) { return c->isSubroutine(); },
+            [](AST::FunctionLikeUnit *c) { return c->getSubroutine(); },
             [&](AST::Evaluation *c) { return inSubroutine(c); },
             [](auto *) -> const Pa::SubroutineStmt * { return nullptr; },
         },
@@ -131,7 +131,7 @@ class FirConverter : public AbstractConverter {
   static const Pa::FunctionStmt *inFunction(AST::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
-            [](AST::FunctionLikeUnit *c) { return c->isFunction(); },
+            [](AST::FunctionLikeUnit *c) { return c->getFunction(); },
             [&](AST::Evaluation *c) { return inFunction(c); },
             [](auto *) -> const Pa::FunctionStmt * { return nullptr; },
         },
@@ -140,7 +140,7 @@ class FirConverter : public AbstractConverter {
   static const Pa::MpSubprogramStmt *inMPSubp(AST::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
-            [](AST::FunctionLikeUnit *c) { return c->isMPSubp(); },
+            [](AST::FunctionLikeUnit *c) { return c->getMPSubp(); },
             [&](AST::Evaluation *c) { return inMPSubp(c); },
             [](auto *) -> const Pa::MpSubprogramStmt * { return nullptr; },
         },
diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
index 815d31e4a484..1603cc173297 100644
--- a/lib/lower/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -1,4 +1,4 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wno-unused-parameter")
 
 add_library(FortranLower
   ASTBuilder.cpp
diff --git a/lib/lower/ConvertType.cpp b/lib/lower/ConvertType.cpp
index 7e529a6aaa2b..5d6b80d5c9c3 100644
--- a/lib/lower/ConvertType.cpp
+++ b/lib/lower/ConvertType.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/ConvertType.h"
+#include "../../runtime/io-api.h"
 #include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/Utils.h"
@@ -487,3 +488,80 @@ M::Type Br::getSequenceRefType(M::Type refType) {
   fir::SequenceType::Shape shape{fir::SequenceType::getUnknownExtent()};
   return fir::ReferenceType::get(fir::SequenceType::get(shape, elementType));
 }
+
+// Models of C (language) types. These models are used to construct the FIR
+// signatures of runtime support routines.
+
+mlir::Type Br::getModelForInt(mlir::MLIRContext *context) {
+  return mlir::IntegerType::get(8 * sizeof(int), context);
+}
+
+mlir::Type Br::getModelForIntRef(mlir::MLIRContext *context) {
+  return fir::ReferenceType::get(getModelForInt(context));
+}
+
+mlir::Type Br::getModelForIostat(mlir::MLIRContext *context) {
+  return mlir::IntegerType::get(8 * sizeof(runtime::io::Iostat), context);
+}
+
+mlir::Type Br::getModelForCharPtr(mlir::MLIRContext *context) {
+  return fir::ReferenceType::get(mlir::IntegerType::get(8, context));
+}
+
+mlir::Type Br::getModelForConstCharPtr(mlir::MLIRContext *context) {
+  return getModelForCharPtr(context);
+}
+
+mlir::Type Br::getModelForInt64(mlir::MLIRContext *context) {
+  return mlir::IntegerType::get(64, context);
+}
+
+mlir::Type Br::getModelForInt64Ref(mlir::MLIRContext *context) {
+  return fir::ReferenceType::get(getModelForInt64(context));
+}
+
+mlir::Type Br::getModelForSize(mlir::MLIRContext *context) {
+  return mlir::IntegerType::get(8 * sizeof(std::size_t), context);
+}
+
+mlir::Type Br::getModelForCookie(mlir::MLIRContext *context) {
+  return fir::ReferenceType::get(mlir::IntegerType::get(8, context));
+}
+
+mlir::Type Br::getModelForDouble(mlir::MLIRContext *context) {
+  return mlir::FloatType::getF64(context);
+}
+
+mlir::Type Br::getModelForDoubleRef(mlir::MLIRContext *context) {
+  return fir::ReferenceType::get(getModelForDouble(context));
+}
+
+mlir::Type Br::getModelForFloat(mlir::MLIRContext *context) {
+  return mlir::FloatType::getF32(context);
+}
+
+mlir::Type Br::getModelForFloatRef(mlir::MLIRContext *context) {
+  return fir::ReferenceType::get(getModelForFloat(context));
+}
+
+mlir::Type Br::getModelForBool(mlir::MLIRContext *context) {
+  return mlir::IntegerType::get(1, context);
+}
+
+mlir::Type Br::getModelForBoolRef(mlir::MLIRContext *context) {
+  return fir::ReferenceType::get(getModelForBool(context));
+}
+
+mlir::Type Br::getModelForDescriptor(mlir::MLIRContext *context) {
+  return fir::BoxType::get(mlir::NoneType::get(context));
+}
+
+mlir::Type Br::getModelForNamelistGroup(mlir::MLIRContext *context) {
+  // FIXME: a namelist group must be some well-defined data structure, use a
+  // tuple as a proxy for the moment
+  return mlir::TupleType::get(llvm::None, context);
+}
+
+mlir::Type Br::getModelForVoid(mlir::MLIRContext *context) {
+  return mlir::NoneType::get(context);
+}
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index c3e63265124a..ef0cf617ea45 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -1,4 +1,4 @@
-//===-- lower/IO.cpp ------------------------------------------------------===//
+//===-- IO.cpp -- I/O statement lowering ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,7 +8,9 @@
 
 #include "flang/lower/IO.h"
 #include "../../runtime/io-api.h"
+#include "NSAliases.h"
 #include "RTBuilder.h"
+#include "fir/Dialect/FIROps.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
@@ -20,47 +22,51 @@
 #define NAMIFY_HELPER(X) #X
 #define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
 
-namespace Br = Fortran::lower;
-namespace M = mlir;
-namespace Pa = Fortran::parser;
-
-using namespace Fortran;
-using namespace Fortran::lower;
-
 #define TODO() assert(false && "not yet implemented")
 
+using namespace Io;
+namespace Fortran::lower {
 namespace {
 
 #define mkIOKey(X) mkKey(IONAME(X))
 
-using namespace runtime::io;
 /// Static table of IO runtime calls
 ///
 /// This logical map contains the name and type builder function for each IO
 /// runtime function listed in the tuple. This table is fully constructed at
 /// compile-time. Use the `mkIOKey` macro to access the table.
 static constexpr std::tuple<
-    mkIOKey(BeginExternalListOutput), mkIOKey(BeginExternalListInput),
-    mkIOKey(BeginExternalFormattedOutput), mkIOKey(BeginExternalFormattedInput),
-    mkIOKey(BeginUnformattedOutput), mkIOKey(BeginUnformattedInput),
-    mkIOKey(EndIoStatement), mkIOKey(OutputInteger64), mkIOKey(InputInteger64),
-    mkIOKey(OutputReal64), mkIOKey(InputReal64), mkIOKey(OutputReal32),
-    mkIOKey(InputReal64), mkIOKey(OutputComplex64), mkIOKey(OutputComplex32),
-    mkIOKey(BeginClose), mkIOKey(OutputAscii), mkIOKey(InputAscii),
-    mkIOKey(OutputLogical), mkIOKey(InputLogical), mkIOKey(BeginFlush),
-    mkIOKey(BeginBackspace), mkIOKey(BeginEndfile), mkIOKey(BeginRewind),
-    mkIOKey(BeginOpenUnit), mkIOKey(BeginOpenNewUnit),
-    mkIOKey(BeginInquireUnit), mkIOKey(BeginInquireFile),
-    mkIOKey(BeginInquireIoLength), mkIOKey(EnableHandlers), mkIOKey(SetAdvance),
-    mkIOKey(SetBlank), mkIOKey(SetDecimal), mkIOKey(SetDelim), mkIOKey(SetPad),
-    mkIOKey(SetPos), mkIOKey(SetRec), mkIOKey(SetRound), mkIOKey(SetSign),
+    mkIOKey(BeginInternalArrayListOutput), mkIOKey(BeginInternalArrayListInput),
+    mkIOKey(BeginInternalArrayFormattedOutput),
+    mkIOKey(BeginInternalArrayFormattedInput), mkIOKey(BeginInternalListOutput),
+    mkIOKey(BeginInternalListInput), mkIOKey(BeginInternalFormattedOutput),
+    mkIOKey(BeginInternalFormattedInput), mkIOKey(BeginInternalNamelistOutput),
+    mkIOKey(BeginInternalNamelistInput), mkIOKey(BeginExternalListOutput),
+    mkIOKey(BeginExternalListInput), mkIOKey(BeginExternalFormattedOutput),
+    mkIOKey(BeginExternalFormattedInput), mkIOKey(BeginUnformattedOutput),
+    mkIOKey(BeginUnformattedInput), mkIOKey(BeginExternalNamelistOutput),
+    mkIOKey(BeginExternalNamelistInput), mkIOKey(BeginAsynchronousOutput),
+    mkIOKey(BeginAsynchronousInput), mkIOKey(BeginWait), mkIOKey(BeginWaitAll),
+    mkIOKey(BeginClose), mkIOKey(BeginFlush), mkIOKey(BeginBackspace),
+    mkIOKey(BeginEndfile), mkIOKey(BeginRewind), mkIOKey(BeginOpenUnit),
+    mkIOKey(BeginOpenNewUnit), mkIOKey(BeginInquireUnit),
+    mkIOKey(BeginInquireFile), mkIOKey(BeginInquireIoLength),
+    mkIOKey(EnableHandlers), mkIOKey(SetAdvance), mkIOKey(SetBlank),
+    mkIOKey(SetDecimal), mkIOKey(SetDelim), mkIOKey(SetPad), mkIOKey(SetPos),
+    mkIOKey(SetRec), mkIOKey(SetRound), mkIOKey(SetSign),
+    mkIOKey(OutputDescriptor), mkIOKey(InputDescriptor),
+    mkIOKey(OutputUnformattedBlock), mkIOKey(InputUnformattedBlock),
+    mkIOKey(OutputInteger64), mkIOKey(InputInteger64), mkIOKey(OutputReal32),
+    mkIOKey(InputReal32), mkIOKey(OutputReal64), mkIOKey(InputReal64),
+    mkIOKey(OutputComplex64), mkIOKey(OutputComplex32), mkIOKey(OutputAscii),
+    mkIOKey(InputAscii), mkIOKey(OutputLogical), mkIOKey(InputLogical),
     mkIOKey(SetAccess), mkIOKey(SetAction), mkIOKey(SetAsynchronous),
     mkIOKey(SetEncoding), mkIOKey(SetEncoding), mkIOKey(SetForm),
     mkIOKey(SetPosition), mkIOKey(SetRecl), mkIOKey(SetStatus),
     mkIOKey(SetFile), mkIOKey(GetNewUnit), mkIOKey(GetSize),
     mkIOKey(GetIoLength), mkIOKey(GetIoMsg), mkIOKey(InquireCharacter),
     mkIOKey(InquireLogical), mkIOKey(InquirePendingId),
-    mkIOKey(InquireInteger64)>
+    mkIOKey(InquireInteger64), mkIOKey(EndIoStatement)>
     newIOTable;
 
 /// Helper function to retrieve the name of the IO function given the key `A`
@@ -139,14 +145,13 @@ static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
   static_assert(!descriptionRange.empty());
 
   M::MLIRContext *context{getModule(&builder).getContext()};
-  llvm::SmallVector<M::Type, 2> argTypes{
+  L::SmallVector<M::Type, 2> argTypes{
       IORuntimeDescription::getIOCookieType(context), type};
 
   M::FunctionType seekedType{M::FunctionType::get(argTypes, {}, context)};
   for (const auto &description : descriptionRange) {
-    if (description.getMLIRFunctionType(context) == seekedType) {
+    if (description.getMLIRFunctionType(context) == seekedType)
       return description.getFuncOp(builder);
-    }
   }
   assert(false && "IO output runtime function not defined for this type");
   return {};
@@ -156,7 +161,7 @@ static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
 /// replaces getIORuntimeFunction.
 template <typename E>
 M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
-  auto module = getModule(&builder);
+  M::ModuleOp module{getModule(&builder)};
   auto name = getName<E>();
   auto func = getNamedFunction(module, name);
   if (func)
@@ -169,11 +174,11 @@ M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
 }
 
 /// Generate a call to end an IO statement
-void genEndIO(M::OpBuilder &builder, M::Location loc, M::Value cookie) {
+M::Value genEndIO(M::OpBuilder &builder, M::Location loc, M::Value cookie) {
   // Terminate IO
   M::FuncOp endIOFunc{getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder)};
-  llvm::SmallVector<M::Value, 1> endArgs{cookie};
-  builder.create<M::CallOp>(loc, endIOFunc, endArgs);
+  L::SmallVector<M::Value, 1> endArgs{cookie};
+  return builder.create<M::CallOp>(loc, endIOFunc, endArgs).getResult(0);
 }
 
 /// Lower print statement assuming a dummy runtime interface for now.
@@ -186,14 +191,14 @@ void lowerPrintStatement(M::OpBuilder &builder, M::Location loc, int format,
   M::Type externalUnitType{builder.getIntegerType(32)};
   M::Value defaultUnit{builder.create<M::ConstantOp>(
       loc, builder.getIntegerAttr(externalUnitType, 1))};
-  llvm::SmallVector<M::Value, 1> beginArgs{defaultUnit};
+  L::SmallVector<M::Value, 1> beginArgs{defaultUnit};
   M::Value cookie{
       builder.create<M::CallOp>(loc, beginFunc, beginArgs).getResult(0)};
 
   // Call data transfer runtime function
   for (M::Value arg : args) {
     // FIXME: this loop is still using the older table
-    llvm::SmallVector<M::Value, 1> operands{cookie, arg};
+    L::SmallVector<M::Value, 1> operands{cookie, arg};
     M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg.getType())};
     builder.create<M::CallOp>(loc, outputFunc, operands);
   }
@@ -206,47 +211,101 @@ int lowerFormat(const Pa::Format &format) {
   TODO();
 }
 
-M::Value lowerPositionOrFlush(M::OpBuilder &builder, M::Location loc,
+L::SmallVector<M::Value, 4>
+lowerBeginArgsPositionOrFlush(AbstractConverter &converter, M::Location loc,
                               const std::list<Pa::PositionOrFlushSpec> &specs) {
-  TODO();
-  return {};
+  L::SmallVector<M::Value, 4> args;
+  // 1. find the unit number expression and append it
+  for (auto &sp : specs)
+    if (auto *un = std::get_if<Pa::FileUnitNumber>(&sp.u)) {
+      auto *expr{semantics::GetExpr(un->v)};
+      args.push_back(converter.genExprValue(expr, loc));
+      break;
+    }
+  // 2 & 3. add the filename and line as extracted from `loc`
+  // FIXME
+  return args;
+}
+
+/// 3 of the 4 cases in a position (or flush) spec concern the error handling of
+/// the statement. We handle those 3 cases here.
+M::Value lowerErrorHandlingPositionOrFlush(
+    AbstractConverter &converter, M::Value endRes,
+    const std::list<Pa::PositionOrFlushSpec> &specs) {
+  M::Value result;
+  auto builder{converter.getOpBuilder()};
+  auto loc = converter.getCurrentLocation();
+  for (auto &sp : specs) {
+    std::visit(
+        Co::visitors{
+            [](const Pa::FileUnitNumber &) {
+              // this is passed to the BeginFoo function
+              // do nothing here
+            },
+            [&](const Pa::MsgVariable &var) {
+              // call GetIoMsg, passing it the address of `var` and a length (in
+              // bytes, or?). Effectively, we have to decompose a boxchar here.
+              // TODO: this has to be a CHARACTER type, no?
+              M::Value varAddr = converter.genExprAddr(Se::GetExpr(var), loc);
+              M::FuncOp getIoMsg = getIORuntimeFunc<mkIOKey(GetIoMsg)>(builder);
+              L::SmallVector<M::Value, 1> ioMsgArgs{
+                  builder.create<fir::ConvertOp>(
+                      loc, getModelForCharPtr(builder.getContext()), varAddr)
+                  /*, FIXME add length here */};
+              builder.create<M::CallOp>(loc, getIoMsg, ioMsgArgs);
+            },
+            [&](const Pa::StatVariable &var) {
+              /* store `endRes` to the variable `var` */
+              M::Value varAddr = converter.genExprAddr(Se::GetExpr(var), loc);
+              builder.create<fir::StoreOp>(loc, endRes, varAddr);
+            },
+            [&](const Pa::ErrLabel &label) {
+              /* pass the `endRes` value for `fir.switch` op */
+              result = endRes;
+            },
+        },
+        sp.u);
+  }
+  return result;
 }
 
 /// Generate IO calls for any of the "position or flush" like IO statements.
 /// This is templatized with a statement type `S` and a key `K` for genericity.
 template <typename K, typename S>
-void genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
+M::Value genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
   auto builder = converter.getOpBuilder();
   auto loc = converter.getCurrentLocation();
   auto beginFunc = getIORuntimeFunc<K>(builder);
-  (void)beginFunc; // FIXME
-  auto cookie = lowerPositionOrFlush(builder, loc, stmt.v);
-  genEndIO(builder, converter.getCurrentLocation(), cookie);
+  auto args = lowerBeginArgsPositionOrFlush(converter, loc, stmt.v);
+  auto call = builder.create<M::CallOp>(loc, beginFunc, args);
+  // FIXME: add call to EnableHandlers as apropos
+  auto cookie = call.getResult(0);
+  auto endVal = genEndIO(builder, converter.getCurrentLocation(), cookie);
+  return lowerErrorHandlingPositionOrFlush(converter, endVal, stmt.v);
 }
-
 } // namespace
 
-void Br::genBackspaceStatement(AbstractConverter &converter,
+M::Value genBackspaceStatement(AbstractConverter &converter,
                                const Pa::BackspaceStmt &stmt) {
-  genPosOrFlushLikeStmt<mkIOKey(BeginBackspace)>(converter, stmt);
+  return genPosOrFlushLikeStmt<mkIOKey(BeginBackspace)>(converter, stmt);
 }
 
-void Br::genEndfileStatement(AbstractConverter &converter,
+M::Value genEndfileStatement(AbstractConverter &converter,
                              const Pa::EndfileStmt &stmt) {
-  genPosOrFlushLikeStmt<mkIOKey(BeginEndfile)>(converter, stmt);
+  return genPosOrFlushLikeStmt<mkIOKey(BeginEndfile)>(converter, stmt);
 }
 
-void Br::genFlushStatement(AbstractConverter &converter,
+M::Value genFlushStatement(AbstractConverter &converter,
                            const Pa::FlushStmt &stmt) {
-  genPosOrFlushLikeStmt<mkIOKey(BeginFlush)>(converter, stmt);
+  return genPosOrFlushLikeStmt<mkIOKey(BeginFlush)>(converter, stmt);
 }
 
-void Br::genRewindStatement(AbstractConverter &converter,
+M::Value genRewindStatement(AbstractConverter &converter,
                             const Pa::RewindStmt &stmt) {
-  genPosOrFlushLikeStmt<mkIOKey(BeginRewind)>(converter, stmt);
+  return genPosOrFlushLikeStmt<mkIOKey(BeginRewind)>(converter, stmt);
 }
 
-void Br::genOpenStatement(AbstractConverter &converter, const Pa::OpenStmt &) {
+M::Value genOpenStatement(AbstractConverter &converter, const Pa::OpenStmt &) {
   auto builder = converter.getOpBuilder();
   M::FuncOp beginFunc;
   // if (...
@@ -254,22 +313,24 @@ void Br::genOpenStatement(AbstractConverter &converter, const Pa::OpenStmt &) {
   // else
   beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(builder);
   TODO();
+  return {};
 }
 
-void Br::genCloseStatement(AbstractConverter &converter,
+M::Value genCloseStatement(AbstractConverter &converter,
                            const Pa::CloseStmt &) {
   auto builder = converter.getOpBuilder();
   M::FuncOp beginFunc{getIORuntimeFunc<mkIOKey(BeginClose)>(builder)};
   TODO();
+  return {};
 }
 
-void Br::genPrintStatement(Br::AbstractConverter &converter,
-                           const Pa::PrintStmt &stmt) {
-  llvm::SmallVector<M::Value, 4> args;
+void genPrintStatement(Br::AbstractConverter &converter,
+                       const Pa::PrintStmt &stmt) {
+  L::SmallVector<M::Value, 4> args;
   for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
     if (auto *pe{std::get_if<Pa::Expr>(&item.u)}) {
       auto loc{converter.genLocation(pe->source)};
-      args.push_back(converter.genExprValue(*semantics::GetExpr(*pe), &loc));
+      args.push_back(converter.genExprValue(Se::GetExpr(*pe), loc));
     } else {
       TODO(); // TODO implied do
     }
@@ -278,16 +339,17 @@ void Br::genPrintStatement(Br::AbstractConverter &converter,
                       lowerFormat(std::get<Pa::Format>(stmt.t)), args);
 }
 
-void Br::genReadStatement(AbstractConverter &converter, const Pa::ReadStmt &) {
+M::Value genReadStatement(AbstractConverter &converter, const Pa::ReadStmt &) {
   auto builder = converter.getOpBuilder();
   M::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
   // else if (...
   TODO();
+  return {};
 }
 
-void Br::genWriteStatement(AbstractConverter &converter,
+M::Value genWriteStatement(AbstractConverter &converter,
                            const Pa::WriteStmt &) {
   auto builder = converter.getOpBuilder();
   M::FuncOp beginFunc;
@@ -295,9 +357,10 @@ void Br::genWriteStatement(AbstractConverter &converter,
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
   // else if (...
   TODO();
+  return {};
 }
 
-void Br::genInquireStatement(AbstractConverter &converter,
+M::Value genInquireStatement(AbstractConverter &converter,
                              const Pa::InquireStmt &) {
   auto builder = converter.getOpBuilder();
   M::FuncOp beginFunc;
@@ -308,4 +371,6 @@ void Br::genInquireStatement(AbstractConverter &converter,
   // else
   beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireIoLength)>(builder);
   TODO();
+  return {};
 }
+} // namespace Fortran::lower
diff --git a/lib/lower/OpBuilder.cpp b/lib/lower/OpBuilder.cpp
index dd7c18c2a0a9..40b53b0d5e18 100644
--- a/lib/lower/OpBuilder.cpp
+++ b/lib/lower/OpBuilder.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/builder.cc ------------------------------------*- C++ -*-===//
+//===-- OpBuilder.cc ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -15,45 +15,44 @@
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/StringRef.h"
 
-namespace B = Fortran::lower;
+namespace Br = Fortran::lower;
 namespace Ev = Fortran::evaluate;
-namespace L = llvm;
-namespace M = mlir;
 namespace Se = Fortran::semantics;
 
 using namespace Fortran;
 using namespace Fortran::lower;
 
-M::FuncOp B::createFunction(B::AbstractConverter &converter,
-                            llvm::StringRef name, M::FunctionType funcTy) {
+mlir::FuncOp Br::createFunction(Br::AbstractConverter &converter,
+                                llvm::StringRef name,
+                                mlir::FunctionType funcTy) {
   return fir::createFuncOp(converter.getCurrentLocation(),
                            converter.getModuleOp(), name, funcTy);
 }
 
-M::FuncOp B::createFunction(M::ModuleOp module, llvm::StringRef name,
-                            M::FunctionType funcTy) {
-  return fir::createFuncOp(M::UnknownLoc::get(module.getContext()), module,
+mlir::FuncOp Br::createFunction(mlir::ModuleOp module, llvm::StringRef name,
+                                mlir::FunctionType funcTy) {
+  return fir::createFuncOp(mlir::UnknownLoc::get(module.getContext()), module,
                            name, funcTy);
 }
 
-M::FuncOp B::getNamedFunction(M::ModuleOp module, llvm::StringRef name) {
-  return module.lookupSymbol<M::FuncOp>(name);
+mlir::FuncOp Br::getNamedFunction(mlir::ModuleOp module, llvm::StringRef name) {
+  return module.lookupSymbol<mlir::FuncOp>(name);
 }
 
-void B::SymMap::addSymbol(Se::SymbolRef symbol, M::Value value) {
+void Br::SymMap::addSymbol(Se::SymbolRef symbol, mlir::Value value) {
   symbolMap.try_emplace(&*symbol, value);
 }
 
-M::Value B::SymMap::lookupSymbol(Se::SymbolRef symbol) {
+mlir::Value Br::SymMap::lookupSymbol(Se::SymbolRef symbol) {
   auto iter{symbolMap.find(&*symbol)};
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
 
-void B::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
+void Br::SymMap::pushShadowSymbol(Se::SymbolRef symbol, mlir::Value value) {
   // find any existing mapping for symbol
   auto iter{symbolMap.find(&*symbol)};
   const Se::Symbol *sym{nullptr};
-  M::Value val;
+  mlir::Value val;
   // if mapping exists, save it on the shadow stack
   if (iter != symbolMap.end()) {
     sym = iter->first;
@@ -67,19 +66,20 @@ void B::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
   (void)r;
 }
 
-M::Value B::OpBuilderWrapper::createIntegerConstant(M::Type integerType,
-                                                    std::int64_t cst) {
-  return create<M::ConstantOp>(integerType,
-                               builder.getIntegerAttr(integerType, cst));
+mlir::Value Br::OpBuilderWrapper::createIntegerConstant(mlir::Type integerType,
+                                                        std::int64_t cst) {
+  return create<mlir::ConstantOp>(integerType,
+                                  builder.getIntegerAttr(integerType, cst));
 }
 
 // LoopBuilder implementation
 
-void B::LoopBuilder::createLoop(M::Value lb, M::Value ub, M::Value step,
-                                const BodyGenerator &bodyGenerator) {
+void Br::LoopBuilder::createLoop(mlir::Value lb, mlir::Value ub,
+                                 mlir::Value step,
+                                 const BodyGenerator &bodyGenerator) {
   auto lbi{convertToIndexType(lb)};
   auto ubi{convertToIndexType(ub)};
-  L::SmallVector<M::Value, 1> steps;
+  llvm::SmallVector<mlir::Value, 1> steps;
   if (step) {
     auto stepi{convertToIndexType(step)};
     steps.emplace_back(stepi);
@@ -92,38 +92,38 @@ void B::LoopBuilder::createLoop(M::Value lb, M::Value ub, M::Value step,
   builder.setInsertionPointToEnd(insPt);
 }
 
-void B::LoopBuilder::createLoop(M::Value lb, M::Value ub,
-                                const BodyGenerator &bodyGenerator) {
+void Br::LoopBuilder::createLoop(mlir::Value lb, mlir::Value ub,
+                                 const BodyGenerator &bodyGenerator) {
   auto one{createIntegerConstant(getIndexType(), 1)};
   createLoop(lb, ub, one, bodyGenerator);
 }
 
-void B::LoopBuilder::createLoop(M::Value count,
-                                const BodyGenerator &bodyGenerator) {
+void Br::LoopBuilder::createLoop(mlir::Value count,
+                                 const BodyGenerator &bodyGenerator) {
   auto indexType{getIndexType()};
   auto zero{createIntegerConstant(indexType, 0)};
   auto one{createIntegerConstant(indexType, 1)};
   createLoop(zero, count, one, bodyGenerator);
 }
 
-M::Type B::LoopBuilder::getIndexType() {
-  return M::IndexType::get(builder.getContext());
+mlir::Type Br::LoopBuilder::getIndexType() {
+  return mlir::IndexType::get(builder.getContext());
 }
 
-M::Value B::LoopBuilder::convertToIndexType(M::Value integer) {
+mlir::Value Br::LoopBuilder::convertToIndexType(mlir::Value integer) {
   auto type{integer.getType()};
-  if (type.isa<M::IndexType>()) {
+  if (type.isa<mlir::IndexType>()) {
     return integer;
   }
-  assert((type.isa<M::IntegerType>() || type.isa<fir::IntType>()) &&
+  assert((type.isa<mlir::IntegerType>() || type.isa<fir::IntType>()) &&
          "expected integer");
   return create<fir::ConvertOp>(getIndexType(), integer);
 }
 
 // CharacterOpsBuilder implementation
 
-void B::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
-                                        M::Value count) {
+void Br::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
+                                         mlir::Value count) {
   auto refType{dest.getReferenceType()};
   // Cast to character sequence reference type for fir::CoordinateOp.
   auto sequenceType{getSequenceRefType(refType)};
@@ -131,7 +131,7 @@ void B::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
   auto srcRef{create<fir::ConvertOp>(sequenceType, src.reference)};
 
   LoopBuilder{*this}.createLoop(count, [&](OpBuilderWrapper &handler,
-                                           M::Value index) {
+                                           mlir::Value index) {
     auto destAddr{handler.create<fir::CoordinateOp>(refType, destRef, index)};
     auto srcAddr{handler.create<fir::CoordinateOp>(refType, srcRef, index)};
     auto val{handler.create<fir::LoadOp>(srcAddr)};
@@ -139,40 +139,41 @@ void B::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
   });
 }
 
-void B::CharacterOpsBuilder::createPadding(CharValue &str, M::Value lower,
-                                           M::Value upper) {
+void Br::CharacterOpsBuilder::createPadding(CharValue &str, mlir::Value lower,
+                                            mlir::Value upper) {
   auto refType{str.getReferenceType()};
   auto sequenceType{getSequenceRefType(refType)};
   auto strRef{create<fir::ConvertOp>(sequenceType, str.reference)};
   auto blank{createBlankConstant(str.getCharacterType())};
 
   LoopBuilder{*this}.createLoop(
-      lower, upper, [&](OpBuilderWrapper &handler, M::Value index) {
+      lower, upper, [&](OpBuilderWrapper &handler, mlir::Value index) {
         auto strAddr{handler.create<fir::CoordinateOp>(refType, strRef, index)};
         handler.create<fir::StoreOp>(blank, strAddr);
       });
 }
 
-M::Value B::CharacterOpsBuilder::createBlankConstant(fir::CharacterType type) {
-  auto byteTy{M::IntegerType::get(8, builder.getContext())};
+mlir::Value
+Br::CharacterOpsBuilder::createBlankConstant(fir::CharacterType type) {
+  auto byteTy{mlir::IntegerType::get(8, builder.getContext())};
   auto asciiSpace{createIntegerConstant(byteTy, 0x20)};
   return create<fir::ConvertOp>(type, asciiSpace);
 }
 
-B::CharacterOpsBuilder::CharValue
-B::CharacterOpsBuilder::createTemp(fir::CharacterType type, M::Value len) {
+Br::CharacterOpsBuilder::CharValue
+Br::CharacterOpsBuilder::createTemp(fir::CharacterType type, mlir::Value len) {
   // FIXME Does this need to be emitted somewhere safe ?
   // convert-expr.cc generates alloca at the beginning of the mlir block.
   return CharValue{create<fir::AllocaOp>(type, len), len};
 }
 
-fir::ReferenceType B::CharacterOpsBuilder::CharValue::getReferenceType() {
+fir::ReferenceType Br::CharacterOpsBuilder::CharValue::getReferenceType() {
   auto type{reference.getType().dyn_cast<fir::ReferenceType>()};
   assert(type && "expected reference type");
   return type;
 }
 
-fir::CharacterType B::CharacterOpsBuilder::CharValue::getCharacterType() {
+fir::CharacterType Br::CharacterOpsBuilder::CharValue::getCharacterType() {
   auto type{getReferenceType().getEleTy().dyn_cast<fir::CharacterType>()};
   assert(type && "expected character type");
   return type;
@@ -180,66 +181,68 @@ fir::CharacterType B::CharacterOpsBuilder::CharValue::getCharacterType() {
 
 // ComplexOpsBuilder implementation
 
-mlir::Type B::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
+mlir::Type Br::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
   return convertReal(builder.getContext(), complexKind);
 }
-mlir::Type B::ComplexOpsBuilder::getComplexPartType(mlir::Type complexType) {
+mlir::Type Br::ComplexOpsBuilder::getComplexPartType(mlir::Type complexType) {
   return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
 }
-mlir::Type B::ComplexOpsBuilder::getComplexPartType(mlir::Value cplx) {
+mlir::Type Br::ComplexOpsBuilder::getComplexPartType(mlir::Value cplx) {
   assert(cplx != nullptr);
   return getComplexPartType(cplx.getType());
 }
 
-mlir::Value B::ComplexOpsBuilder::createComplex(fir::KindTy kind,
-                                                mlir::Value real,
-                                                mlir::Value imag) {
+mlir::Value Br::ComplexOpsBuilder::createComplex(fir::KindTy kind,
+                                                 mlir::Value real,
+                                                 mlir::Value imag) {
   mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
   mlir::Value und{create<fir::UndefOp>(complexTy)};
   return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
 }
 
-using CplxPart = B::ComplexOpsBuilder::Part;
+using CplxPart = Br::ComplexOpsBuilder::Part;
 template <CplxPart partId>
-mlir::Value B::ComplexOpsBuilder::createPartId() {
+mlir::Value Br::ComplexOpsBuilder::createPartId() {
   auto type{mlir::IntegerType::get(32, builder.getContext())};
   return createIntegerConstant(type, static_cast<int>(partId));
 }
 
 template <CplxPart partId>
-mlir::Value B::ComplexOpsBuilder::extract(mlir::Value cplx) {
+mlir::Value Br::ComplexOpsBuilder::extract(mlir::Value cplx) {
   return create<fir::ExtractValueOp>(getComplexPartType(cplx), cplx,
                                      createPartId<partId>());
 }
-template mlir::Value B::ComplexOpsBuilder::extract<CplxPart::Real>(mlir::Value);
-template mlir::Value B::ComplexOpsBuilder::extract<CplxPart::Imag>(mlir::Value);
+template mlir::Value
+    Br::ComplexOpsBuilder::extract<CplxPart::Real>(mlir::Value);
+template mlir::Value
+    Br::ComplexOpsBuilder::extract<CplxPart::Imag>(mlir::Value);
 
 template <CplxPart partId>
-mlir::Value B::ComplexOpsBuilder::insert(mlir::Value cplx, mlir::Value part) {
+mlir::Value Br::ComplexOpsBuilder::insert(mlir::Value cplx, mlir::Value part) {
   assert(cplx != nullptr);
   return create<fir::InsertValueOp>(cplx.getType(), cplx, part,
                                     createPartId<partId>());
 }
-template mlir::Value B::ComplexOpsBuilder::insert<CplxPart::Real>(mlir::Value,
-                                                                  mlir::Value);
-template mlir::Value B::ComplexOpsBuilder::insert<CplxPart::Imag>(mlir::Value,
-                                                                  mlir::Value);
+template mlir::Value Br::ComplexOpsBuilder::insert<CplxPart::Real>(mlir::Value,
+                                                                   mlir::Value);
+template mlir::Value Br::ComplexOpsBuilder::insert<CplxPart::Imag>(mlir::Value,
+                                                                   mlir::Value);
 
-mlir::Value B::ComplexOpsBuilder::extractComplexPart(mlir::Value cplx,
-                                                     bool isImagPart) {
+mlir::Value Br::ComplexOpsBuilder::extractComplexPart(mlir::Value cplx,
+                                                      bool isImagPart) {
   return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
 }
 
-mlir::Value B::ComplexOpsBuilder::insertComplexPart(mlir::Value cplx,
-                                                    mlir::Value part,
-                                                    bool isImagPart) {
+mlir::Value Br::ComplexOpsBuilder::insertComplexPart(mlir::Value cplx,
+                                                     mlir::Value part,
+                                                     bool isImagPart) {
   return isImagPart ? insert<Part::Imag>(cplx, part)
                     : insert<Part::Real>(cplx, part);
 }
 
-mlir::Value B::ComplexOpsBuilder::createComplexCompare(mlir::Value cplx1,
-                                                       mlir::Value cplx2,
-                                                       bool eq) {
+mlir::Value Br::ComplexOpsBuilder::createComplexCompare(mlir::Value cplx1,
+                                                        mlir::Value cplx2,
+                                                        bool eq) {
   mlir::Value real1{extract<Part::Real>(cplx1)};
   mlir::Value real2{extract<Part::Real>(cplx2)};
   mlir::Value imag1{extract<Part::Imag>(cplx1)};
diff --git a/lib/lower/RTBuilder.h b/lib/lower/RTBuilder.h
index 30f5de6d264c..0c914d7f4e53 100644
--- a/lib/lower/RTBuilder.h
+++ b/lib/lower/RTBuilder.h
@@ -5,13 +5,23 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines some C++17 template classes that are used to convert the
+/// signatures of plain old C functions into a model that can be used to
+/// generate MLIR calls to those functions. This can be used to autogenerate
+/// tables at compiler compile-time to call runtime support code.
+///
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_RT_BUILDER_H_
 #define FORTRAN_LOWER_RT_BUILDER_H_
 
 #include "fir/Dialect/FIRType.h"
+#include "flang/lower/ConvertType.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
+#include "llvm/ADT/SmallVector.h"
 #include <cstddef>
 #include <functional>
 
@@ -20,9 +30,8 @@
 
 namespace Fortran::lower {
 
-using TypeBuilderFunc = std::function<mlir::Type(mlir::MLIRContext *)>;
-using FuncTypeBuilderFunc =
-    std::function<mlir::FunctionType(mlir::MLIRContext *)>;
+using TypeBuilderFunc = mlir::Type (*)(mlir::MLIRContext *);
+using FuncTypeBuilderFunc = mlir::FunctionType (*)(mlir::MLIRContext *);
 
 template <typename>
 struct errorNoBuilderForType;
@@ -37,57 +46,42 @@ struct errorNoBuilderForType;
 template <typename T>
 static constexpr TypeBuilderFunc getModel() {
   using namespace std::placeholders;
-  using Iostat = typename runtime::io::Iostat;
   if constexpr (std::is_same_v<T, int>) {
-    return [](mlir::MLIRContext *c) {
-      return mlir::IntegerType::get(8 * sizeof(int), c);
-    };
+    return getModelForInt;
   } else if constexpr (std::is_same_v<T, int &>) {
-    return [](mlir::MLIRContext *c) {
-      return fir::ReferenceType::get(
-          mlir::IntegerType::get(8 * sizeof(int), c));
-    };
+    return getModelForIntRef;
   } else if constexpr (std::is_same_v<T, std::int64_t>) {
-    return [](mlir::MLIRContext *c) { return mlir::IntegerType::get(64, c); };
+    return getModelForInt64;
   } else if constexpr (std::is_same_v<T, std::int64_t &>) {
-    return [](mlir::MLIRContext *c) {
-      return fir::ReferenceType::get(mlir::IntegerType::get(64, c));
-    };
-  } else if constexpr (std::is_same_v<std::decay_t<T>, std::size_t>) {
-    return [](mlir::MLIRContext *c) {
-      return mlir::IntegerType::get(8 * sizeof(std::size_t), c);
-    };
+    return getModelForInt64Ref;
+  } else if constexpr (std::is_same_v<T, std::size_t>) {
+    return getModelForSize;
   } else if constexpr (std::is_same_v<T, double>) {
-    return [](mlir::MLIRContext *c) { return mlir::FloatType::getF64(c); };
+    return getModelForDouble;
   } else if constexpr (std::is_same_v<T, double &>) {
-    return [](mlir::MLIRContext *c) {
-      return fir::ReferenceType::get(mlir::FloatType::getF64(c));
-    };
+    return getModelForDoubleRef;
   } else if constexpr (std::is_same_v<T, float>) {
-    return [](mlir::MLIRContext *c) { return mlir::FloatType::getF32(c); };
+    return getModelForFloat;
   } else if constexpr (std::is_same_v<T, float &>) {
-    return [](mlir::MLIRContext *c) {
-      return fir::ReferenceType::get(mlir::FloatType::getF32(c));
-    };
-  } else if constexpr (std::is_same_v<std::decay_t<T>, Iostat>) {
-    return [](mlir::MLIRContext *c) {
-      return mlir::IntegerType::get(8 * sizeof(Iostat), c);
-    };
+    return getModelForFloatRef;
+  } else if constexpr (std::is_same_v<T, runtime::io::Iostat>) {
+    return getModelForIostat;
   } else if constexpr (std::is_same_v<T, bool>) {
-    return [](mlir::MLIRContext *c) { return mlir::IntegerType::get(1, c); };
+    return getModelForBool;
   } else if constexpr (std::is_same_v<T, bool &>) {
-    return [](mlir::MLIRContext *c) {
-      return fir::ReferenceType::get(mlir::IntegerType::get(1, c));
-    };
-  } else if constexpr (std::is_same_v<std::decay_t<T>,
-                                      runtime::io::IoStatementState *>) {
-    return [](mlir::MLIRContext *c) {
-      return fir::ReferenceType::get(mlir::IntegerType::get(8, c));
-    };
-  } else if constexpr (std::is_same_v<std::decay_t<T>, const char *>) {
-    return [](mlir::MLIRContext *c) {
-      return fir::ReferenceType::get(mlir::IntegerType::get(8, c));
-    };
+    return getModelForBoolRef;
+  } else if constexpr (std::is_same_v<T, runtime::io::IoStatementState *>) {
+    return getModelForCookie;
+  } else if constexpr (std::is_same_v<T, char *>) {
+    return getModelForCharPtr;
+  } else if constexpr (std::is_same_v<T, const char *>) {
+    return getModelForConstCharPtr;
+  } else if constexpr (std::is_same_v<T, void>) {
+    return getModelForVoid;
+  } else if constexpr (std::is_same_v<T, const runtime::Descriptor &>) {
+    return getModelForDescriptor;
+  } else if constexpr (std::is_same_v<T, const runtime::NamelistGroup &>) {
+    return getModelForNamelistGroup;
   } else {
     return errorNoBuilderForType<T>{}; // intentionally force compile-time error
   }
@@ -130,7 +124,8 @@ struct RuntimeTableEntry<RuntimeTableKey<KT>, RuntimeIdentifier<Cs...>> {
 #define QuoteKey(X) #X##_rt_ident
 #define ExpandKey(X) QuoteKey(X)
 #define mkKey(X)                                                               \
-  RuntimeTableEntry<RuntimeTableKey<decltype(X)>, decltype(ExpandKey(X))>
+  Br::RuntimeTableEntry<Br::RuntimeTableKey<decltype(X)>,                      \
+                        decltype(ExpandKey(X))>
 
 } // namespace Fortran::lower
 
diff --git a/lib/optimizer/CMakeLists.txt b/lib/optimizer/CMakeLists.txt
index b4a82c58bbb5..2e3a960e7c00 100644
--- a/lib/optimizer/CMakeLists.txt
+++ b/lib/optimizer/CMakeLists.txt
@@ -1,4 +1,4 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wno-unused-parameter")
 
 add_subdirectory(Transforms)
 
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index c6cf539a7ad6..ebd6b8f314f4 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -1,4 +1,4 @@
-//===-- lib/optimizer/CodeGen.cpp -------------------------------*- C++ -*-===//
+//===-- CodeGen.cpp -- bridge to lower to LLVM ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -43,170 +43,168 @@
   (void)X;                                                                     \
   assert(false && "not yet implemented")
 
-namespace L = llvm;
-namespace M = mlir;
-
-static L::cl::opt<bool>
+static llvm::cl::opt<bool>
     ClDisableFirToLLVMIR("disable-fir2llvmir",
-                         L::cl::desc("disable FIR to LLVM-IR dialect pass"),
-                         L::cl::init(false), L::cl::Hidden);
+                         llvm::cl::desc("disable FIR to LLVM-IR dialect pass"),
+                         llvm::cl::init(false), llvm::cl::Hidden);
 
-static L::cl::opt<bool> ClDisableLLVM("disable-llvm",
-                                      L::cl::desc("disable LLVM pass"),
-                                      L::cl::init(false), L::cl::Hidden);
+static llvm::cl::opt<bool> ClDisableLLVM("disable-llvm",
+                                         llvm::cl::desc("disable LLVM pass"),
+                                         llvm::cl::init(false),
+                                         llvm::cl::Hidden);
 
 using namespace fir;
 
 namespace {
 
-using SmallVecResult = L::SmallVector<M::Value, 4>;
-using OperandTy = L::ArrayRef<M::Value>;
-using AttributeTy = L::ArrayRef<M::NamedAttribute>;
+using SmallVecResult = llvm::SmallVector<mlir::Value, 4>;
+using OperandTy = llvm::ArrayRef<mlir::Value>;
+using AttributeTy = llvm::ArrayRef<mlir::NamedAttribute>;
 
 const unsigned defaultAlign = 8;
 
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
-class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
+class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   KindMapping kindMapping;
-  static L::StringMap<M::LLVM::LLVMType> identStructCache;
+  static llvm::StringMap<mlir::LLVM::LLVMType> identStructCache;
 
 public:
-  FIRToLLVMTypeConverter(M::MLIRContext *context, NameUniquer &uniquer)
+  FIRToLLVMTypeConverter(mlir::MLIRContext *context, NameUniquer &uniquer)
       : LLVMTypeConverter(context), kindMapping(context), uniquer(uniquer) {}
 
   // This returns the type of a single column. Rows are added by the caller.
   // fir.dims<r>  -->  llvm<"[r x [3 x i64]]">
-  M::LLVM::LLVMType dimsType() {
-    auto i64Ty{M::LLVM::LLVMType::getInt64Ty(llvmDialect)};
-    return M::LLVM::LLVMType::getArrayTy(i64Ty, 3);
+  mlir::LLVM::LLVMType dimsType() {
+    auto i64Ty{mlir::LLVM::LLVMType::getInt64Ty(llvmDialect)};
+    return mlir::LLVM::LLVMType::getArrayTy(i64Ty, 3);
   }
 
   // i32 is used here because LLVM wants i32 constants when indexing into struct
   // types. Indexing into other aggregate types is more flexible.
-  M::LLVM::LLVMType offsetType() {
-    return M::LLVM::LLVMType::getInt32Ty(llvmDialect);
+  mlir::LLVM::LLVMType offsetType() {
+    return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
   }
 
   // i64 can be used to index into aggregates like arrays
-  M::LLVM::LLVMType indexType() {
-    return M::LLVM::LLVMType::getInt64Ty(llvmDialect);
+  mlir::LLVM::LLVMType indexType() {
+    return mlir::LLVM::LLVMType::getInt64Ty(llvmDialect);
   }
 
   // This corresponds to the descriptor as defined ISO_Fortran_binding.h and the
   // addendum defined in descriptor.h.
   // FIXME: This code should be generated and follow SPOT
-  M::LLVM::LLVMType convertBoxType(BoxType box) {
+  mlir::LLVM::LLVMType convertBoxType(BoxType box) {
     // (buffer*, ele-size, rank, type-descriptor, attribute, [dims])
-    L::SmallVector<M::LLVM::LLVMType, 6> parts;
-    M::Type ele = box.getEleTy();
+    llvm::SmallVector<mlir::LLVM::LLVMType, 6> parts;
+    mlir::Type ele = box.getEleTy();
     // auto *ctx = box.getContext();
     auto eleTy = unwrap(convertType(ele));
     // buffer*
     parts.push_back(eleTy.getPointerTo());
     // ele-size
-    parts.push_back(M::LLVM::LLVMType::getInt64Ty(llvmDialect));
+    parts.push_back(mlir::LLVM::LLVMType::getInt64Ty(llvmDialect));
     // version
-    parts.push_back(M::LLVM::LLVMType::getInt32Ty(llvmDialect));
+    parts.push_back(mlir::LLVM::LLVMType::getInt32Ty(llvmDialect));
     // rank
-    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    parts.push_back(mlir::LLVM::LLVMType::getInt8Ty(llvmDialect));
     // type (code)
-    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    parts.push_back(mlir::LLVM::LLVMType::getInt8Ty(llvmDialect));
     // attribute
-    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    parts.push_back(mlir::LLVM::LLVMType::getInt8Ty(llvmDialect));
     // addendum
-    parts.push_back(M::LLVM::LLVMType::getInt8Ty(llvmDialect));
+    parts.push_back(mlir::LLVM::LLVMType::getInt8Ty(llvmDialect));
     // opt-dims: [0..15 x [int,int,int]]  (see fir.dims)
     // opt-type-ptr: i8* (see fir.tdesc)
     // opt-flags: i64
     // opt-len-params: [? x i64]
-    return M::LLVM::LLVMType::getStructTy(llvmDialect, parts).getPointerTo();
+    return mlir::LLVM::LLVMType::getStructTy(llvmDialect, parts).getPointerTo();
   }
 
   // fir.boxchar<n>  -->  llvm<"{ ix*, i64 }">   where ix is kind mapping
-  M::LLVM::LLVMType convertBoxCharType(BoxCharType boxchar) {
+  mlir::LLVM::LLVMType convertBoxCharType(BoxCharType boxchar) {
     auto ptrTy = convertCharType(boxchar.getEleTy()).getPointerTo();
-    auto i64Ty = M::LLVM::LLVMType::getInt64Ty(llvmDialect);
-    L::SmallVector<M::LLVM::LLVMType, 2> tuple = {ptrTy, i64Ty};
-    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+    auto i64Ty = mlir::LLVM::LLVMType::getInt64Ty(llvmDialect);
+    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple = {ptrTy, i64Ty};
+    return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
   // fir.boxproc<any>  -->  llvm<"{ any*, i8* }">
-  M::LLVM::LLVMType convertBoxProcType(BoxProcType boxproc) {
+  mlir::LLVM::LLVMType convertBoxProcType(BoxProcType boxproc) {
     auto funcTy = convertType(boxproc.getEleTy());
     auto ptrTy = unwrap(funcTy).getPointerTo();
-    auto i8Ty = M::LLVM::LLVMType::getInt8Ty(llvmDialect);
-    L::SmallVector<M::LLVM::LLVMType, 2> tuple{ptrTy, i8Ty};
-    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+    auto i8Ty = mlir::LLVM::LLVMType::getInt8Ty(llvmDialect);
+    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple{ptrTy, i8Ty};
+    return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
   // fir.char<n>  -->  llvm<"ix*">   where ix is scaled by kind mapping
-  M::LLVM::LLVMType convertCharType(CharacterType charTy) {
-    return M::LLVM::LLVMType::getIntNTy(
+  mlir::LLVM::LLVMType convertCharType(CharacterType charTy) {
+    return mlir::LLVM::LLVMType::getIntNTy(
         llvmDialect, kindMapping.getCharacterBitsize(charTy.getFKind()));
   }
 
   // fir.complex<n>  -->  llvm<"{ anyfloat, anyfloat }">
-  M::LLVM::LLVMType convertComplexType(KindTy kind) {
+  mlir::LLVM::LLVMType convertComplexType(KindTy kind) {
     auto realID = kindMapping.getComplexTypeID(kind);
     auto realTy = fromRealTypeID(realID, kind);
-    L::SmallVector<M::LLVM::LLVMType, 2> tuple{realTy, realTy};
-    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple{realTy, realTy};
+    return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
-  LLVM::LLVMType getDefaultInt() {
+  mlir::LLVM::LLVMType getDefaultInt() {
     // FIXME: this should be tied to the front-end default
-    return M::LLVM::LLVMType::getInt64Ty(llvmDialect);
+    return mlir::LLVM::LLVMType::getInt64Ty(llvmDialect);
   }
 
   // fir.int<n>  -->  llvm.ix   where ix is a kind mapping
-  M::LLVM::LLVMType convertIntegerType(IntType intTy) {
-    return M::LLVM::LLVMType::getIntNTy(
+  mlir::LLVM::LLVMType convertIntegerType(IntType intTy) {
+    return mlir::LLVM::LLVMType::getIntNTy(
         llvmDialect, kindMapping.getIntegerBitsize(intTy.getFKind()));
   }
 
   // fir.logical<n>  -->  llvm.ix  where ix is a kind mapping
-  M::LLVM::LLVMType convertLogicalType(LogicalType boolTy) {
-    return M::LLVM::LLVMType::getIntNTy(
+  mlir::LLVM::LLVMType convertLogicalType(LogicalType boolTy) {
+    return mlir::LLVM::LLVMType::getIntNTy(
         llvmDialect, kindMapping.getLogicalBitsize(boolTy.getFKind()));
   }
 
   template <typename A>
-  M::LLVM::LLVMType convertPointerLike(A &ty) {
+  mlir::LLVM::LLVMType convertPointerLike(A &ty) {
     return unwrap(convertType(ty.getEleTy())).getPointerTo();
   }
 
   // convert a front-end kind value to either a std or LLVM IR dialect type
   // fir.real<n>  -->  llvm.anyfloat  where anyfloat is a kind mapping
-  M::LLVM::LLVMType convertRealType(KindTy kind) {
+  mlir::LLVM::LLVMType convertRealType(KindTy kind) {
     return fromRealTypeID(kindMapping.getRealTypeID(kind), kind);
   }
 
   // fir.type<name(p : TY'...){f : TY...}>  -->  llvm<"%name = { ty... }">
-  M::LLVM::LLVMType convertRecordType(RecordType derived) {
+  mlir::LLVM::LLVMType convertRecordType(RecordType derived) {
     auto name{derived.getName()};
     // The cache is needed to keep a unique mapping from name -> StructType
     auto iter{identStructCache.find(name)};
     if (iter != identStructCache.end())
       return iter->second;
-    auto st{M::LLVM::LLVMType::createStructTy(llvmDialect, name)};
+    auto st{mlir::LLVM::LLVMType::createStructTy(llvmDialect, name)};
     identStructCache[name] = st;
-    L::SmallVector<M::LLVM::LLVMType, 8> members;
+    llvm::SmallVector<mlir::LLVM::LLVMType, 8> members;
     for (auto mem : derived.getTypeList())
-      members.push_back(convertType(mem.second).cast<M::LLVM::LLVMType>());
-    M::LLVM::LLVMType::setStructTyBody(st, members);
+      members.push_back(convertType(mem.second).cast<mlir::LLVM::LLVMType>());
+    mlir::LLVM::LLVMType::setStructTyBody(st, members);
     return st;
   }
 
   // fir.array<c ... :any>  -->  llvm<"[...[c x any]]">
-  M::LLVM::LLVMType convertSequenceType(SequenceType seq) {
+  mlir::LLVM::LLVMType convertSequenceType(SequenceType seq) {
     auto baseTy = unwrap(convertType(seq.getEleTy()));
     auto shape = seq.getShape();
     if (shape.size()) {
       for (auto e : shape) {
         if (e < 0)
           e = 0;
-        baseTy = M::LLVM::LLVMType::getArrayTy(baseTy, e);
+        baseTy = mlir::LLVM::LLVMType::getArrayTy(baseTy, e);
       }
       return baseTy;
     }
@@ -214,31 +212,31 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
   }
 
   // tuple<TS...>  -->  llvm<"{ ts... }">
-  M::LLVM::LLVMType convertTupleType(M::TupleType tuple) {
-    L::SmallVector<M::Type, 8> inMembers;
+  mlir::LLVM::LLVMType convertTupleType(mlir::TupleType tuple) {
+    llvm::SmallVector<mlir::Type, 8> inMembers;
     tuple.getFlattenedTypes(inMembers);
-    L::SmallVector<M::LLVM::LLVMType, 8> members;
+    llvm::SmallVector<mlir::LLVM::LLVMType, 8> members;
     for (auto mem : inMembers)
-      members.push_back(convertType(mem).cast<M::LLVM::LLVMType>());
-    return M::LLVM::LLVMType::getStructTy(llvmDialect, members);
+      members.push_back(convertType(mem).cast<mlir::LLVM::LLVMType>());
+    return mlir::LLVM::LLVMType::getStructTy(llvmDialect, members);
   }
 
   // complex<T>  --> llvm<"{t,t}">
-  M::LLVM::LLVMType convertComplexType(M::ComplexType complex) {
+  mlir::LLVM::LLVMType convertComplexType(mlir::ComplexType complex) {
     auto eleTy = unwrap(convertType(complex.getElementType()));
-    L::SmallVector<M::LLVM::LLVMType, 2> tuple{eleTy, eleTy};
-    return M::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
+    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple{eleTy, eleTy};
+    return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
   // fir.tdesc<any>  -->  llvm<"i8*">
   // FIXME: for now use a void*, however pointer identity is not sufficient for
   // the f18 object v. class distinction
-  M::LLVM::LLVMType convertTypeDescType(M::MLIRContext *ctx) {
-    return M::LLVM::LLVMType::getInt8PtrTy(llvmDialect);
+  mlir::LLVM::LLVMType convertTypeDescType(mlir::MLIRContext *ctx) {
+    return mlir::LLVM::LLVMType::getInt8PtrTy(llvmDialect);
   }
 
   /// Convert FIR types to LLVM IR dialect types
-  M::Type convertType(M::Type t) override {
+  mlir::Type convertType(mlir::Type t) override {
     if (auto box = t.dyn_cast<BoxType>())
       return convertBoxType(box);
     if (auto boxchar = t.dyn_cast<BoxCharType>())
@@ -252,15 +250,15 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
     if (auto derived = t.dyn_cast<RecordType>())
       return convertRecordType(derived);
     if (auto dims = t.dyn_cast<DimsType>())
-      return M::LLVM::LLVMType::getArrayTy(dimsType(), dims.getRank());
+      return mlir::LLVM::LLVMType::getArrayTy(dimsType(), dims.getRank());
     if (auto field = t.dyn_cast<FieldType>())
-      return M::LLVM::LLVMType::getInt32Ty(llvmDialect);
+      return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
     if (auto heap = t.dyn_cast<HeapType>())
       return convertPointerLike(heap);
     if (auto integer = t.dyn_cast<IntType>())
       return convertIntegerType(integer);
     if (auto field = t.dyn_cast<LenType>())
-      return M::LLVM::LLVMType::getInt32Ty(llvmDialect);
+      return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
     if (auto logical = t.dyn_cast<LogicalType>())
       return convertLogicalType(logical);
     if (auto pointer = t.dyn_cast<PointerType>())
@@ -273,28 +271,28 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
       return convertSequenceType(sequence);
     if (auto tdesc = t.dyn_cast<TypeDescType>())
       return convertTypeDescType(tdesc.getContext());
-    if (auto tuple = t.dyn_cast<M::TupleType>())
+    if (auto tuple = t.dyn_cast<mlir::TupleType>())
       return convertTupleType(tuple);
-    if (auto cmplx = t.dyn_cast<M::ComplexType>())
+    if (auto cmplx = t.dyn_cast<mlir::ComplexType>())
       return convertComplexType(cmplx);
-    if (auto none = t.dyn_cast<M::NoneType>())
-      return M::LLVM::LLVMType::getStructTy(llvmDialect, {});
+    if (auto none = t.dyn_cast<mlir::NoneType>())
+      return mlir::LLVM::LLVMType::getStructTy(llvmDialect, {});
     return LLVMTypeConverter::convertType(t);
   }
 
   /// Convert llvm::Type::TypeID to mlir::LLVM::LLVMType
-  M::LLVM::LLVMType fromRealTypeID(L::Type::TypeID typeID, KindTy kind) {
+  mlir::LLVM::LLVMType fromRealTypeID(llvm::Type::TypeID typeID, KindTy kind) {
     switch (typeID) {
-    case L::Type::TypeID::HalfTyID:
-      return M::LLVM::LLVMType::getHalfTy(llvmDialect);
-    case L::Type::TypeID::FloatTyID:
-      return M::LLVM::LLVMType::getFloatTy(llvmDialect);
-    case L::Type::TypeID::DoubleTyID:
-      return M::LLVM::LLVMType::getDoubleTy(llvmDialect);
-    case L::Type::TypeID::X86_FP80TyID:
-      return M::LLVM::LLVMType::getX86_FP80Ty(llvmDialect);
-    case L::Type::TypeID::FP128TyID:
-      return M::LLVM::LLVMType::getFP128Ty(llvmDialect);
+    case llvm::Type::TypeID::HalfTyID:
+      return mlir::LLVM::LLVMType::getHalfTy(llvmDialect);
+    case llvm::Type::TypeID::FloatTyID:
+      return mlir::LLVM::LLVMType::getFloatTy(llvmDialect);
+    case llvm::Type::TypeID::DoubleTyID:
+      return mlir::LLVM::LLVMType::getDoubleTy(llvmDialect);
+    case llvm::Type::TypeID::X86_FP80TyID:
+      return mlir::LLVM::LLVMType::getX86_FP80Ty(llvmDialect);
+    case llvm::Type::TypeID::FP128TyID:
+      return mlir::LLVM::LLVMType::getFP128Ty(llvmDialect);
     default:
       emitError(UnknownLoc::get(llvmDialect->getContext()))
           << "unsupported type: !fir.real<" << kind << ">";
@@ -303,11 +301,11 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
   }
 
   /// HACK: cloned from LLVMTypeConverter since this is private there
-  LLVM::LLVMType unwrap(Type type) {
+  mlir::LLVM::LLVMType unwrap(Type type) {
     if (!type)
       return nullptr;
     auto *mlirContext = type.getContext();
-    auto wrappedLLVMType = type.dyn_cast<LLVM::LLVMType>();
+    auto wrappedLLVMType = type.dyn_cast<mlir::LLVM::LLVMType>();
     if (!wrappedLLVMType)
       emitError(UnknownLoc::get(mlirContext),
                 "conversion resulted in a non-LLVM type");
@@ -318,13 +316,13 @@ class FIRToLLVMTypeConverter : public M::LLVMTypeConverter {
 };
 
 // instantiate static data member
-L::StringMap<M::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
+llvm::StringMap<mlir::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
 
 /// remove `omitNames` (by name) from the attribute dictionary
-L::SmallVector<M::NamedAttribute, 4>
-pruneNamedAttrDict(L::ArrayRef<M::NamedAttribute> attrs,
-                   L::ArrayRef<L::StringRef> omitNames) {
-  L::SmallVector<M::NamedAttribute, 4> result;
+llvm::SmallVector<mlir::NamedAttribute, 4>
+pruneNamedAttrDict(llvm::ArrayRef<mlir::NamedAttribute> attrs,
+                   llvm::ArrayRef<llvm::StringRef> omitNames) {
+  llvm::SmallVector<mlir::NamedAttribute, 4> result;
   for (auto x : attrs) {
     bool omit = false;
     for (auto o : omitNames)
@@ -338,114 +336,124 @@ pruneNamedAttrDict(L::ArrayRef<M::NamedAttribute> attrs,
   return result;
 }
 
-inline M::LLVM::LLVMType getVoidPtrType(M::LLVM::LLVMDialect *dialect) {
-  return M::LLVM::LLVMType::getInt8PtrTy(dialect);
+inline mlir::LLVM::LLVMType getVoidPtrType(mlir::LLVM::LLVMDialect *dialect) {
+  return mlir::LLVM::LLVMType::getInt8PtrTy(dialect);
 }
 
 /// FIR conversion pattern template
 template <typename FromOp>
-class FIROpConversion : public M::ConversionPattern {
+class FIROpConversion : public mlir::ConversionPattern {
 public:
-  explicit FIROpConversion(M::MLIRContext *ctx,
+  explicit FIROpConversion(mlir::MLIRContext *ctx,
                            FIRToLLVMTypeConverter &lowering)
       : ConversionPattern(FromOp::getOperationName(), 1, ctx),
         lowering(lowering) {}
 
 protected:
-  L::LLVMContext &getLLVMContext() const { return lowering.getLLVMContext(); }
-  M::LLVM::LLVMDialect *getDialect() const { return lowering.getDialect(); }
-  M::Type convertType(M::Type ty) const { return lowering.convertType(ty); }
-  M::LLVM::LLVMType unwrap(M::Type ty) const { return lowering.unwrap(ty); }
-  M::LLVM::LLVMType voidPtrTy() const { return getVoidPtrType(getDialect()); }
-
-  M::LLVM::ConstantOp genConstantOffset(M::Location loc,
-                                        M::ConversionPatternRewriter &rewriter,
-                                        int offset) const {
+  llvm::LLVMContext &getLLVMContext() const {
+    return lowering.getLLVMContext();
+  }
+  mlir::LLVM::LLVMDialect *getDialect() const { return lowering.getDialect(); }
+  mlir::Type convertType(mlir::Type ty) const {
+    return lowering.convertType(ty);
+  }
+  mlir::LLVM::LLVMType unwrap(mlir::Type ty) const {
+    return lowering.unwrap(ty);
+  }
+  mlir::LLVM::LLVMType voidPtrTy() const {
+    return getVoidPtrType(getDialect());
+  }
+
+  mlir::LLVM::ConstantOp
+  genConstantOffset(mlir::Location loc,
+                    mlir::ConversionPatternRewriter &rewriter,
+                    int offset) const {
     auto ity = lowering.offsetType();
     auto cattr = rewriter.getI32IntegerAttr(offset);
-    return rewriter.create<M::LLVM::ConstantOp>(loc, ity, cattr);
+    return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
   }
 
   FIRToLLVMTypeConverter &lowering;
 };
 
 /// Create an LLVM dialect global
-void createGlobal(M::Location loc, M::ModuleOp mod, L::StringRef name,
-                  M::LLVM::LLVMType type,
-                  M::ConversionPatternRewriter &rewriter) {
-  if (mod.lookupSymbol<M::LLVM::GlobalOp>(name))
+void createGlobal(mlir::Location loc, mlir::ModuleOp mod, llvm::StringRef name,
+                  mlir::LLVM::LLVMType type,
+                  mlir::ConversionPatternRewriter &rewriter) {
+  if (mod.lookupSymbol<mlir::LLVM::GlobalOp>(name))
     return;
-  M::OpBuilder modBuilder(mod.getBodyRegion());
-  modBuilder.create<M::LLVM::GlobalOp>(loc, type, /*isConstant=*/true,
-                                       M::LLVM::Linkage::Weak, name,
-                                       M::Attribute{});
+  mlir::OpBuilder modBuilder(mod.getBodyRegion());
+  modBuilder.create<mlir::LLVM::GlobalOp>(loc, type, /*isConstant=*/true,
+                                          mlir::LLVM::Linkage::Weak, name,
+                                          mlir::Attribute{});
 }
 
 struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto addr = M::cast<fir::AddrOfOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto addr = mlir::cast<fir::AddrOfOp>(op);
     auto ty = unwrap(convertType(addr.getType()));
     auto attrs = pruneNamedAttrDict(addr.getAttrs(), {"symbol"});
-    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(
+    rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(
         addr, ty, addr.symbol().getRootReference(), attrs);
     return matchSuccess();
   }
 };
 
-M::LLVM::ConstantOp genConstantIndex(M::Location loc, M::LLVM::LLVMType ity,
-                                     M::ConversionPatternRewriter &rewriter,
-                                     int offset) {
+mlir::LLVM::ConstantOp
+genConstantIndex(mlir::Location loc, mlir::LLVM::LLVMType ity,
+                 mlir::ConversionPatternRewriter &rewriter, int offset) {
   auto cattr = rewriter.getI64IntegerAttr(offset);
-  return rewriter.create<M::LLVM::ConstantOp>(loc, ity, cattr);
+  return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
 }
 
 /// convert to LLVM IR dialect `alloca`
 struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto alloc = M::cast<fir::AllocaOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto alloc = mlir::cast<fir::AllocaOp>(op);
     auto loc = alloc.getLoc();
     auto ity = lowering.indexType();
     auto c1 = genConstantIndex(loc, ity, rewriter, 1);
     auto size = c1.getResult();
     for (auto opnd : operands)
-      size = rewriter.create<M::LLVM::MulOp>(loc, ity, size, opnd);
+      size = rewriter.create<mlir::LLVM::MulOp>(loc, ity, size, opnd);
     auto ty = convertType(alloc.getType());
-    rewriter.replaceOpWithNewOp<M::LLVM::AllocaOp>(alloc, ty, size,
-                                                   alloc.getAttrs());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::AllocaOp>(alloc, ty, size,
+                                                      alloc.getAttrs());
     return matchSuccess();
   }
 };
 
-M::LLVM::LLVMFuncOp getMalloc(AllocMemOp op,
-                              M::ConversionPatternRewriter &rewriter,
-                              M::LLVM::LLVMDialect *dialect) {
-  auto module = op.getParentOfType<M::ModuleOp>();
-  if (auto mallocFunc = module.lookupSymbol<M::LLVM::LLVMFuncOp>("malloc"))
+mlir::LLVM::LLVMFuncOp getMalloc(AllocMemOp op,
+                                 mlir::ConversionPatternRewriter &rewriter,
+                                 mlir::LLVM::LLVMDialect *dialect) {
+  auto module = op.getParentOfType<mlir::ModuleOp>();
+  if (auto mallocFunc = module.lookupSymbol<mlir::LLVM::LLVMFuncOp>("malloc"))
     return mallocFunc;
-  M::OpBuilder moduleBuilder(op.getParentOfType<M::ModuleOp>().getBodyRegion());
-  auto indexType = M::LLVM::LLVMType::getInt64Ty(dialect);
-  return moduleBuilder.create<M::LLVM::LLVMFuncOp>(
+  mlir::OpBuilder moduleBuilder(
+      op.getParentOfType<mlir::ModuleOp>().getBodyRegion());
+  auto indexType = mlir::LLVM::LLVMType::getInt64Ty(dialect);
+  return moduleBuilder.create<mlir::LLVM::LLVMFuncOp>(
       rewriter.getUnknownLoc(), "malloc",
-      M::LLVM::LLVMType::getFunctionTy(getVoidPtrType(dialect), indexType,
-                                       /*isVarArg=*/false));
+      mlir::LLVM::LLVMType::getFunctionTy(getVoidPtrType(dialect), indexType,
+                                          /*isVarArg=*/false));
 }
 
 /// convert to `call` to the runtime to `malloc` memory
 struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto heap = M::cast<AllocMemOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto heap = mlir::cast<AllocMemOp>(op);
     auto ty = convertType(heap.getType());
     auto dialect = getDialect();
     auto mallocFunc = getMalloc(heap, rewriter, dialect);
@@ -454,66 +462,66 @@ struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
     auto c1 = genConstantIndex(loc, ity, rewriter, 1);
     auto size = c1.getResult();
     for (auto opnd : operands)
-      size = rewriter.create<M::LLVM::MulOp>(loc, ity, size, opnd);
+      size = rewriter.create<mlir::LLVM::MulOp>(loc, ity, size, opnd);
     heap.setAttr("callee", rewriter.getSymbolRefAttr(mallocFunc));
-    L::SmallVector<M::Value, 1> args{size};
-    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(heap, ty, args,
-                                                 heap.getAttrs());
+    llvm::SmallVector<mlir::Value, 1> args{size};
+    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(heap, ty, args,
+                                                    heap.getAttrs());
     return matchSuccess();
   }
 };
 
 /// obtain the free() function
-M::LLVM::LLVMFuncOp getFree(FreeMemOp op,
-                            M::ConversionPatternRewriter &rewriter,
-                            M::LLVM::LLVMDialect *dialect) {
-  auto module = op.getParentOfType<M::ModuleOp>();
-  if (auto freeFunc = module.lookupSymbol<M::LLVM::LLVMFuncOp>("free"))
+mlir::LLVM::LLVMFuncOp getFree(FreeMemOp op,
+                               mlir::ConversionPatternRewriter &rewriter,
+                               mlir::LLVM::LLVMDialect *dialect) {
+  auto module = op.getParentOfType<mlir::ModuleOp>();
+  if (auto freeFunc = module.lookupSymbol<mlir::LLVM::LLVMFuncOp>("free"))
     return freeFunc;
-  M::OpBuilder moduleBuilder(module.getBodyRegion());
-  auto voidType = M::LLVM::LLVMType::getVoidTy(dialect);
-  return moduleBuilder.create<M::LLVM::LLVMFuncOp>(
+  mlir::OpBuilder moduleBuilder(module.getBodyRegion());
+  auto voidType = mlir::LLVM::LLVMType::getVoidTy(dialect);
+  return moduleBuilder.create<mlir::LLVM::LLVMFuncOp>(
       rewriter.getUnknownLoc(), "free",
-      M::LLVM::LLVMType::getFunctionTy(voidType, getVoidPtrType(dialect),
-                                       /*isVarArg=*/false));
+      mlir::LLVM::LLVMType::getFunctionTy(voidType, getVoidPtrType(dialect),
+                                          /*isVarArg=*/false));
 }
 
 /// lower a freemem instruction into a call to free()
 struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto freemem = M::cast<fir::FreeMemOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto freemem = mlir::cast<fir::FreeMemOp>(op);
     auto dialect = getDialect();
     auto freeFunc = getFree(freemem, rewriter, dialect);
-    auto bitcast = rewriter.create<M::LLVM::BitcastOp>(
+    auto bitcast = rewriter.create<mlir::LLVM::BitcastOp>(
         freemem.getLoc(), voidPtrTy(), operands[0]);
     freemem.setAttr("callee", rewriter.getSymbolRefAttr(freeFunc));
-    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(
-        freemem, M::LLVM::LLVMType::getVoidTy(dialect),
-        L::SmallVector<M::Value, 1>{bitcast}, freemem.getAttrs());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
+        freemem, mlir::LLVM::LLVMType::getVoidTy(dialect),
+        llvm::SmallVector<mlir::Value, 1>{bitcast}, freemem.getAttrs());
     return matchSuccess();
   }
 };
 
 template <typename... ARGS>
-M::LLVM::GEPOp genGEP(M::Location loc, M::LLVM::LLVMType ty,
-                      M::ConversionPatternRewriter &rewriter, M::Value base,
-                      ARGS... args) {
-  L::SmallVector<M::Value, 8> cv{args...};
-  return rewriter.create<M::LLVM::GEPOp>(loc, ty, base, cv);
+mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::LLVM::LLVMType ty,
+                         mlir::ConversionPatternRewriter &rewriter,
+                         mlir::Value base, ARGS... args) {
+  llvm::SmallVector<mlir::Value, 8> cv{args...};
+  return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
 }
 
 /// convert to returning the first element of the box (any flavor)
 struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxaddr = M::cast<BoxAddrOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxaddr = mlir::cast<BoxAddrOp>(op);
     auto a = operands[0];
     auto loc = boxaddr.getLoc();
     auto ty = convertType(boxaddr.getType());
@@ -522,11 +530,12 @@ struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
       auto pty = unwrap(ty).getPointerTo();
       auto p = genGEP(loc, unwrap(pty), rewriter, a, c0, c0);
       // load the pointer from the buffer
-      rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxaddr, ty, p);
+      rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(boxaddr, ty, p);
     } else {
       auto c0attr = rewriter.getI32IntegerAttr(0);
-      auto c0 = M::ArrayAttr::get(c0attr, boxaddr.getContext());
-      rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxaddr, ty, a, c0);
+      auto c0 = mlir::ArrayAttr::get(c0attr, boxaddr.getContext());
+      rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxaddr, ty, a,
+                                                              c0);
     }
     return matchSuccess();
   }
@@ -536,15 +545,15 @@ struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
 struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxchar = M::cast<BoxCharLenOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxchar = mlir::cast<BoxCharLenOp>(op);
     auto a = operands[0];
     auto ty = convertType(boxchar.getType());
     auto ctx = boxchar.getContext();
-    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
-    rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxchar, ty, a, c1);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxchar, ty, a, c1);
     return matchSuccess();
   }
 };
@@ -553,10 +562,10 @@ struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
 struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxdims = M::cast<BoxDimsOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxdims = mlir::cast<BoxDimsOp>(op);
     auto a = operands[0];
     auto dim = operands[1];
     auto loc = boxdims.getLoc();
@@ -570,32 +579,33 @@ struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
     return matchSuccess();
   }
 
-  M::LLVM::LoadOp loadFromOffset(BoxDimsOp boxdims, M::Location loc, M::Value a,
-                                 M::LLVM::ConstantOp c0, M::LLVM::ConstantOp c7,
-                                 M::Value dim, int off,
-                                 M::ConversionPatternRewriter &rewriter) const {
+  mlir::LLVM::LoadOp
+  loadFromOffset(BoxDimsOp boxdims, mlir::Location loc, mlir::Value a,
+                 mlir::LLVM::ConstantOp c0, mlir::LLVM::ConstantOp c7,
+                 mlir::Value dim, int off,
+                 mlir::ConversionPatternRewriter &rewriter) const {
     auto ty = convertType(boxdims.getResult(off).getType());
     auto pty = unwrap(ty).getPointerTo();
     auto c = genConstantOffset(loc, rewriter, off);
     auto p = genGEP(loc, pty, rewriter, a, c0, c7, dim, c);
-    return rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+    return rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
   }
 };
 
 struct BoxEleSizeOpConversion : public FIROpConversion<BoxEleSizeOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxelesz = M::cast<BoxEleSizeOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxelesz = mlir::cast<BoxEleSizeOp>(op);
     auto a = operands[0];
     auto loc = boxelesz.getLoc();
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c1 = genConstantOffset(loc, rewriter, 1);
     auto ty = convertType(boxelesz.getType());
     auto p = genGEP(loc, unwrap(ty), rewriter, a, c0, c1);
-    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxelesz, ty, p);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(boxelesz, ty, p);
     return matchSuccess();
   }
 };
@@ -603,10 +613,10 @@ struct BoxEleSizeOpConversion : public FIROpConversion<BoxEleSizeOp> {
 struct BoxIsAllocOpConversion : public FIROpConversion<BoxIsAllocOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxisalloc = M::cast<BoxIsAllocOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxisalloc = mlir::cast<BoxIsAllocOp>(op);
     auto a = operands[0];
     auto loc = boxisalloc.getLoc();
     auto ity = lowering.offsetType();
@@ -614,11 +624,11 @@ struct BoxIsAllocOpConversion : public FIROpConversion<BoxIsAllocOp> {
     auto c5 = genConstantOffset(loc, rewriter, 5);
     auto ty = convertType(boxisalloc.getType());
     auto p = genGEP(loc, unwrap(ty), rewriter, a, c0, c5);
-    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+    auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
     auto ab = genConstantOffset(loc, rewriter, 2);
-    auto bit = rewriter.create<M::LLVM::AndOp>(loc, ity, ld, ab);
-    rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
-        boxisalloc, M::LLVM::ICmpPredicate::ne, bit, c0);
+    auto bit = rewriter.create<mlir::LLVM::AndOp>(loc, ity, ld, ab);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
+        boxisalloc, mlir::LLVM::ICmpPredicate::ne, bit, c0);
     return matchSuccess();
   }
 };
@@ -626,19 +636,19 @@ struct BoxIsAllocOpConversion : public FIROpConversion<BoxIsAllocOp> {
 struct BoxIsArrayOpConversion : public FIROpConversion<BoxIsArrayOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxisarray = M::cast<BoxIsArrayOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxisarray = mlir::cast<BoxIsArrayOp>(op);
     auto a = operands[0];
     auto loc = boxisarray.getLoc();
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c3 = genConstantOffset(loc, rewriter, 3);
     auto ty = convertType(boxisarray.getType());
     auto p = genGEP(loc, unwrap(ty), rewriter, a, c0, c3);
-    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
-    rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
-        boxisarray, M::LLVM::ICmpPredicate::ne, ld, c0);
+    auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
+        boxisarray, mlir::LLVM::ICmpPredicate::ne, ld, c0);
     return matchSuccess();
   }
 };
@@ -646,23 +656,23 @@ struct BoxIsArrayOpConversion : public FIROpConversion<BoxIsArrayOp> {
 struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxisptr = M::cast<BoxIsPtrOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxisptr = mlir::cast<BoxIsPtrOp>(op);
     auto a = operands[0];
     auto loc = boxisptr.getLoc();
     auto ty = convertType(boxisptr.getType());
     auto ity = lowering.offsetType();
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c5 = genConstantOffset(loc, rewriter, 5);
-    L::SmallVector<M::Value, 4> args{a, c0, c5};
-    auto p = rewriter.create<M::LLVM::GEPOp>(loc, ty, args);
-    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
+    llvm::SmallVector<mlir::Value, 4> args{a, c0, c5};
+    auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, ty, args);
+    auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
     auto ab = genConstantOffset(loc, rewriter, 1);
-    auto bit = rewriter.create<M::LLVM::AndOp>(loc, ity, ld, ab);
-    rewriter.replaceOpWithNewOp<M::LLVM::ICmpOp>(
-        boxisptr, M::LLVM::ICmpPredicate::ne, bit, c0);
+    auto bit = rewriter.create<mlir::LLVM::AndOp>(loc, ity, ld, ab);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
+        boxisptr, mlir::LLVM::ICmpPredicate::ne, bit, c0);
     return matchSuccess();
   }
 };
@@ -670,16 +680,16 @@ struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
 struct BoxProcHostOpConversion : public FIROpConversion<BoxProcHostOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxprochost = M::cast<BoxProcHostOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxprochost = mlir::cast<BoxProcHostOp>(op);
     auto a = operands[0];
     auto ty = convertType(boxprochost.getType());
     auto ctx = boxprochost.getContext();
-    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
-    rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(boxprochost, ty, a,
-                                                         c1);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxprochost, ty, a,
+                                                            c1);
     return matchSuccess();
   }
 };
@@ -687,19 +697,19 @@ struct BoxProcHostOpConversion : public FIROpConversion<BoxProcHostOp> {
 struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxrank = M::cast<BoxRankOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxrank = mlir::cast<BoxRankOp>(op);
     auto a = operands[0];
     auto loc = boxrank.getLoc();
     auto ty = convertType(boxrank.getType());
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c3 = genConstantOffset(loc, rewriter, 3);
-    L::SmallVector<M::Value, 4> args{a, c0, c3};
+    llvm::SmallVector<mlir::Value, 4> args{a, c0, c3};
     auto pty = unwrap(ty).getPointerTo();
-    auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
-    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(boxrank, ty, p);
+    auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, pty, args);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(boxrank, ty, p);
     return matchSuccess();
   }
 };
@@ -707,21 +717,21 @@ struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
 struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto boxtypedesc = M::cast<BoxTypeDescOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto boxtypedesc = mlir::cast<BoxTypeDescOp>(op);
     auto a = operands[0];
     auto loc = boxtypedesc.getLoc();
     auto ty = convertType(boxtypedesc.getType());
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c4 = genConstantOffset(loc, rewriter, 4);
-    L::SmallVector<M::Value, 4> args{a, c0, c4};
+    llvm::SmallVector<mlir::Value, 4> args{a, c0, c4};
     auto pty = unwrap(ty).getPointerTo();
-    auto p = rewriter.create<M::LLVM::GEPOp>(loc, pty, args);
-    auto ld = rewriter.create<M::LLVM::LoadOp>(loc, ty, p);
-    auto i8ptr = M::LLVM::LLVMType::getInt8PtrTy(getDialect());
-    rewriter.replaceOpWithNewOp<M::LLVM::IntToPtrOp>(boxtypedesc, i8ptr, ld);
+    auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, pty, args);
+    auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
+    auto i8ptr = mlir::LLVM::LLVMType::getInt8PtrTy(getDialect());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::IntToPtrOp>(boxtypedesc, i8ptr, ld);
     return matchSuccess();
   }
 };
@@ -729,19 +739,20 @@ struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
 struct ConstantOpConversion : public FIROpConversion<fir::ConstantOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto constop = M::cast<fir::ConstantOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto constop = mlir::cast<fir::ConstantOp>(op);
     auto ty_ = constop.getType();
     auto ty = convertType(ty_);
     auto attr = constop.getValue();
-    auto attr_ = attr.cast<M::StringAttr>();
+    auto attr_ = attr.cast<mlir::StringAttr>();
     if (auto ft = ty_.dyn_cast<fir::RealType>()) {
-      L::APFloat f{L::APFloat::IEEEdouble(), attr_.getValue()};
-      attr = M::FloatAttr::get(M::FloatType::getF64(constop.getContext()), f);
+      llvm::APFloat f{llvm::APFloat::IEEEdouble(), attr_.getValue()};
+      attr = mlir::FloatAttr::get(mlir::FloatType::getF64(constop.getContext()),
+                                  f);
     }
-    rewriter.replaceOpWithNewOp<M::LLVM::ConstantOp>(constop, ty, attr);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, attr);
     return matchSuccess();
   }
 };
@@ -750,15 +761,15 @@ struct ConstantOpConversion : public FIROpConversion<fir::ConstantOp> {
 struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto call = M::cast<fir::CallOp>(op);
-    L::SmallVector<M::Type, 4> resultTys;
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto call = mlir::cast<fir::CallOp>(op);
+    llvm::SmallVector<mlir::Type, 4> resultTys;
     for (auto r : call.getResults())
       resultTys.push_back(convertType(r.getType()));
-    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(call, resultTys, operands,
-                                                 call.getAttrs());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(call, resultTys, operands,
+                                                    call.getAttrs());
     return matchSuccess();
   }
 };
@@ -771,31 +782,33 @@ struct CallOpConversion : public FIROpConversion<fir::CallOp> {
 struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto cmp = M::cast<fir::CmpcOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto cmp = mlir::cast<fir::CmpcOp>(op);
     auto ctxt = cmp.getContext();
     auto kind = cmp.lhs().getType().cast<fir::CplxType>().getFKind();
     auto ty = convertType(fir::RealType::get(ctxt, kind));
     auto loc = cmp.getLoc();
-    auto pos0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
-    L::SmallVector<M::Value, 2> rp{
-        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[0], pos0),
-        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[1], pos0)};
-    auto rcp = rewriter.create<M::LLVM::FCmpOp>(loc, ty, rp, cmp.getAttrs());
-    auto pos1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
-    L::SmallVector<M::Value, 2> ip{
-        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[0], pos1),
-        rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, operands[1], pos1)};
-    auto icp = rewriter.create<M::LLVM::FCmpOp>(loc, ty, ip, cmp.getAttrs());
-    L::SmallVector<M::Value, 2> cp{rcp, icp};
+    auto pos0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
+    llvm::SmallVector<mlir::Value, 2> rp{
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[0], pos0),
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[1],
+                                                    pos0)};
+    auto rcp = rewriter.create<mlir::LLVM::FCmpOp>(loc, ty, rp, cmp.getAttrs());
+    auto pos1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
+    llvm::SmallVector<mlir::Value, 2> ip{
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[0], pos1),
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[1],
+                                                    pos1)};
+    auto icp = rewriter.create<mlir::LLVM::FCmpOp>(loc, ty, ip, cmp.getAttrs());
+    llvm::SmallVector<mlir::Value, 2> cp{rcp, icp};
     switch (cmp.getPredicate()) {
     case fir::CmpFPredicate::OEQ: // .EQ.
-      rewriter.replaceOpWithNewOp<M::LLVM::AndOp>(cmp, ty, cp);
+      rewriter.replaceOpWithNewOp<mlir::LLVM::AndOp>(cmp, ty, cp);
       break;
     case fir::CmpFPredicate::UNE: // .NE.
-      rewriter.replaceOpWithNewOp<M::LLVM::OrOp>(cmp, ty, cp);
+      rewriter.replaceOpWithNewOp<mlir::LLVM::OrOp>(cmp, ty, cp);
       break;
     default:
       rewriter.replaceOp(cmp, rcp.getResult());
@@ -808,13 +821,13 @@ struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
 struct CmpfOpConversion : public FIROpConversion<fir::CmpfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto cmp = M::cast<fir::CmpfOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto cmp = mlir::cast<fir::CmpfOp>(op);
     auto type = convertType(cmp.getType());
-    rewriter.replaceOpWithNewOp<M::LLVM::FCmpOp>(cmp, type, operands,
-                                                 cmp.getAttrs());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::FCmpOp>(cmp, type, operands,
+                                                    cmp.getAttrs());
     return matchSuccess();
   }
 };
@@ -823,10 +836,10 @@ struct CmpfOpConversion : public FIROpConversion<fir::CmpfOp> {
 struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto convert = M::cast<ConvertOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto convert = mlir::cast<ConvertOp>(op);
     auto fromTy_ = convertType(convert.value().getType());
     auto fromTy = unwrap(fromTy_);
     auto toTy_ = convertType(convert.res().getType());
@@ -839,7 +852,7 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
       return matchSuccess();
     }
     auto loc = convert.getLoc();
-    M::Value v;
+    mlir::Value v;
     if (fromLLVMTy->isFloatingPointTy()) {
       if (toLLVMTy->isFloatingPointTy()) {
         unsigned fromBits = fromLLVMTy->getPrimitiveSizeInBits();
@@ -847,11 +860,11 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
         // FIXME: what if different reps (F16, BF16) are the same size?
         assert(fromBits != toBits);
         if (fromBits > toBits)
-          v = rewriter.create<M::LLVM::FPTruncOp>(loc, toTy, op0);
+          v = rewriter.create<mlir::LLVM::FPTruncOp>(loc, toTy, op0);
         else
-          v = rewriter.create<M::LLVM::FPExtOp>(loc, toTy, op0);
+          v = rewriter.create<mlir::LLVM::FPExtOp>(loc, toTy, op0);
       } else if (toLLVMTy->isIntegerTy()) {
-        v = rewriter.create<M::LLVM::FPToSIOp>(loc, toTy, op0);
+        v = rewriter.create<mlir::LLVM::FPToSIOp>(loc, toTy, op0);
       }
     } else if (fromLLVMTy->isIntegerTy()) {
       if (toLLVMTy->isIntegerTy()) {
@@ -859,19 +872,19 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
         unsigned toBits = toLLVMTy->getIntegerBitWidth();
         assert(fromBits != toBits);
         if (fromBits > toBits)
-          v = rewriter.create<M::LLVM::TruncOp>(loc, toTy, op0);
+          v = rewriter.create<mlir::LLVM::TruncOp>(loc, toTy, op0);
         else
-          v = rewriter.create<M::LLVM::SExtOp>(loc, toTy, op0);
+          v = rewriter.create<mlir::LLVM::SExtOp>(loc, toTy, op0);
       } else if (toLLVMTy->isFloatingPointTy()) {
-        v = rewriter.create<M::LLVM::SIToFPOp>(loc, toTy, op0);
+        v = rewriter.create<mlir::LLVM::SIToFPOp>(loc, toTy, op0);
       } else if (toLLVMTy->isPointerTy()) {
-        v = rewriter.create<M::LLVM::IntToPtrOp>(loc, toTy, op0);
+        v = rewriter.create<mlir::LLVM::IntToPtrOp>(loc, toTy, op0);
       }
     } else if (fromLLVMTy->isPointerTy()) {
       if (toLLVMTy->isIntegerTy()) {
-        v = rewriter.create<M::LLVM::PtrToIntOp>(loc, toTy, op0);
+        v = rewriter.create<mlir::LLVM::PtrToIntOp>(loc, toTy, op0);
       } else if (toLLVMTy->isPointerTy()) {
-        v = rewriter.create<M::LLVM::BitcastOp>(loc, toTy, op0);
+        v = rewriter.create<mlir::LLVM::BitcastOp>(loc, toTy, op0);
       }
     }
     if (v)
@@ -886,13 +899,13 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
 struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto dispatch = M::cast<DispatchOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto dispatch = mlir::cast<DispatchOp>(op);
     auto ty = convertType(dispatch.getFunctionType());
     // get the table, lookup the method, fetch the func-ptr
-    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(dispatch, ty, operands);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(dispatch, ty, operands);
     TODO(dispatch);
     return matchSuccess();
   }
@@ -902,10 +915,10 @@ struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
 struct DispatchTableOpConversion : public FIROpConversion<DispatchTableOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto disptable = M::cast<DispatchTableOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto disptable = mlir::cast<DispatchTableOp>(op);
     TODO(disptable);
     return matchSuccess();
   }
@@ -915,10 +928,10 @@ struct DispatchTableOpConversion : public FIROpConversion<DispatchTableOp> {
 struct DTEntryOpConversion : public FIROpConversion<DTEntryOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto dtentry = M::cast<DTEntryOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto dtentry = mlir::cast<DTEntryOp>(op);
     TODO(dtentry);
     return matchSuccess();
   }
@@ -928,21 +941,21 @@ struct DTEntryOpConversion : public FIROpConversion<DTEntryOp> {
 struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto emboxchar = M::cast<EmboxCharOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto emboxchar = mlir::cast<EmboxCharOp>(op);
     auto a = operands[0];
     auto b = operands[1];
     auto loc = emboxchar.getLoc();
     auto ctx = emboxchar.getContext();
     auto ty = convertType(emboxchar.getType());
-    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
-    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
-    auto un = rewriter.create<M::LLVM::UndefOp>(loc, ty);
-    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, un, a, c0);
-    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(emboxchar, ty, r, b,
-                                                        c1);
+    auto c0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto un = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+    auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, un, a, c0);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(emboxchar, ty, r, b,
+                                                           c1);
     return matchSuccess();
   }
 };
@@ -951,10 +964,10 @@ struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
 struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto embox = M::cast<EmboxOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto embox = mlir::cast<EmboxOp>(op);
     auto loc = embox.getLoc();
     auto dialect = getDialect();
     auto ty = unwrap(convertType(embox.getType()));
@@ -962,27 +975,27 @@ struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto rty = unwrap(operands[0].getType()).getPointerTo();
     auto f0p = genGEP(loc, rty, rewriter, alloca, c0, c0);
-    auto f0p_ = rewriter.create<M::LLVM::BitcastOp>(loc, rty, f0p);
-    rewriter.create<M::LLVM::StoreOp>(loc, operands[0], f0p_);
-    auto i64Ty = M::LLVM::LLVMType::getInt64Ty(dialect);
+    auto f0p_ = rewriter.create<mlir::LLVM::BitcastOp>(loc, rty, f0p);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, operands[0], f0p_);
+    auto i64Ty = mlir::LLVM::LLVMType::getInt64Ty(dialect);
     auto i64PtrTy = i64Ty.getPointerTo();
     auto f1p = genGEPToField(loc, i64PtrTy, rewriter, alloca, c0, 1);
-    auto c0_ = rewriter.create<M::LLVM::SExtOp>(loc, i64Ty, c0);
-    rewriter.create<M::LLVM::StoreOp>(loc, c0_, f1p);
-    auto i32PtrTy = M::LLVM::LLVMType::getInt32Ty(dialect).getPointerTo();
+    auto c0_ = rewriter.create<mlir::LLVM::SExtOp>(loc, i64Ty, c0);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, c0_, f1p);
+    auto i32PtrTy = mlir::LLVM::LLVMType::getInt32Ty(dialect).getPointerTo();
     auto f2p = genGEPToField(loc, i32PtrTy, rewriter, alloca, c0, 2);
-    rewriter.create<M::LLVM::StoreOp>(loc, c0, f2p);
-    auto i8Ty = M::LLVM::LLVMType::getInt8Ty(dialect);
-    auto i8PtrTy = M::LLVM::LLVMType::getInt8PtrTy(dialect);
-    auto c0__ = rewriter.create<M::LLVM::TruncOp>(loc, i8Ty, c0);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, c0, f2p);
+    auto i8Ty = mlir::LLVM::LLVMType::getInt8Ty(dialect);
+    auto i8PtrTy = mlir::LLVM::LLVMType::getInt8PtrTy(dialect);
+    auto c0__ = rewriter.create<mlir::LLVM::TruncOp>(loc, i8Ty, c0);
     auto f3p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 3);
-    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f3p);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, c0__, f3p);
     auto f4p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 4);
-    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f4p);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, c0__, f4p);
     auto f5p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 5);
-    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f5p);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, c0__, f5p);
     auto f6p = genGEPToField(loc, i8PtrTy, rewriter, alloca, c0, 6);
-    rewriter.create<M::LLVM::StoreOp>(loc, c0__, f6p);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, c0__, f6p);
     // FIXME: copy the dims info, etc.
 
     rewriter.replaceOp(embox, alloca.getResult());
@@ -990,28 +1003,30 @@ struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
   }
 
   /// Generate an alloca of size `size` and cast it to type `toTy`
-  M::LLVM::BitcastOp
-  genAllocaWithType(M::Location loc, M::LLVM::LLVMType toTy, unsigned size,
-                    unsigned alignment,
-                    M::ConversionPatternRewriter &rewriter) const {
-    auto i8Ty = M::LLVM::LLVMType::getInt8PtrTy(getDialect());
+  mlir::LLVM::BitcastOp
+  genAllocaWithType(mlir::Location loc, mlir::LLVM::LLVMType toTy,
+                    unsigned size, unsigned alignment,
+                    mlir::ConversionPatternRewriter &rewriter) const {
+    auto i8Ty = mlir::LLVM::LLVMType::getInt8PtrTy(getDialect());
     auto thisPt = rewriter.saveInsertionPoint();
     auto *thisBlock = rewriter.getInsertionBlock();
-    auto func = M::cast<M::LLVM::LLVMFuncOp>(thisBlock->getParentOp());
+    auto func = mlir::cast<mlir::LLVM::LLVMFuncOp>(thisBlock->getParentOp());
     rewriter.setInsertionPointToStart(&func.front());
     auto size_ = genConstantOffset(loc, rewriter, size);
-    auto al = rewriter.create<M::LLVM::AllocaOp>(loc, i8Ty, size_, alignment);
+    auto al =
+        rewriter.create<mlir::LLVM::AllocaOp>(loc, i8Ty, size_, alignment);
     rewriter.restoreInsertionPoint(thisPt);
-    return rewriter.create<M::LLVM::BitcastOp>(loc, toTy, al);
+    return rewriter.create<mlir::LLVM::BitcastOp>(loc, toTy, al);
   }
 
-  M::LLVM::BitcastOp genGEPToField(M::Location loc, M::LLVM::LLVMType ty,
-                                   M::ConversionPatternRewriter &rewriter,
-                                   M::Value base, M::Value zero,
-                                   int field) const {
+  mlir::LLVM::BitcastOp genGEPToField(mlir::Location loc,
+                                      mlir::LLVM::LLVMType ty,
+                                      mlir::ConversionPatternRewriter &rewriter,
+                                      mlir::Value base, mlir::Value zero,
+                                      int field) const {
     auto coff = genConstantOffset(loc, rewriter, field);
     auto gep = genGEP(loc, ty, rewriter, base, zero, coff);
-    return rewriter.create<M::LLVM::BitcastOp>(loc, ty, gep);
+    return rewriter.create<mlir::LLVM::BitcastOp>(loc, ty, gep);
   }
 };
 
@@ -1019,21 +1034,21 @@ struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
 struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto emboxproc = M::cast<EmboxProcOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto emboxproc = mlir::cast<EmboxProcOp>(op);
     auto a = operands[0];
     auto b = operands[1];
     auto loc = emboxproc.getLoc();
     auto ctx = emboxproc.getContext();
     auto ty = convertType(emboxproc.getType());
-    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
-    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
-    auto un = rewriter.create<M::LLVM::UndefOp>(loc, ty);
-    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, un, a, c0);
-    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(emboxproc, ty, r, b,
-                                                        c1);
+    auto c0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto un = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+    auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, un, a, c0);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(emboxproc, ty, r, b,
+                                                           c1);
     return matchSuccess();
   }
 };
@@ -1042,26 +1057,26 @@ struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
 bool allConstants(OperandTy operands) {
   for (auto opnd : operands) {
     if (auto defop = opnd.getDefiningOp())
-      if (dyn_cast<M::LLVM::ConstantOp>(defop) ||
-          dyn_cast<M::ConstantOp>(defop))
+      if (dyn_cast<mlir::LLVM::ConstantOp>(defop) ||
+          dyn_cast<mlir::ConstantOp>(defop))
         continue;
     return false;
   }
   return true;
 }
 
-M::Attribute getValue(M::Value value) {
+mlir::Attribute getValue(mlir::Value value) {
   assert(value.getDefiningOp());
-  if (auto v = dyn_cast<M::LLVM::ConstantOp>(value.getDefiningOp()))
+  if (auto v = dyn_cast<mlir::LLVM::ConstantOp>(value.getDefiningOp()))
     return v.value();
-  if (auto v = dyn_cast<M::ConstantOp>(value.getDefiningOp()))
+  if (auto v = dyn_cast<mlir::ConstantOp>(value.getDefiningOp()))
     return v.value();
   assert(false && "must be a constant op");
   return {};
 }
 
 template <typename A>
-inline void appendTo(L::SmallVectorImpl<A> &dest, L::ArrayRef<A> from) {
+inline void appendTo(llvm::SmallVectorImpl<A> &dest, llvm::ArrayRef<A> from) {
   dest.append(from.begin(), from.end());
 }
 
@@ -1069,19 +1084,19 @@ inline void appendTo(L::SmallVectorImpl<A> &dest, L::ArrayRef<A> from) {
 struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto extractVal = M::cast<ExtractValueOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto extractVal = mlir::cast<ExtractValueOp>(op);
     auto ty = convertType(extractVal.getType());
     assert(allConstants(operands.drop_front(1)));
     // since all indices are constants use LLVM's extractvalue instruction
-    L::SmallVector<M::Attribute, 8> attrs;
+    llvm::SmallVector<mlir::Attribute, 8> attrs;
     for (int i = 1, end = operands.size(); i < end; ++i)
       attrs.push_back(getValue(operands[i]));
-    auto position = M::ArrayAttr::get(attrs, extractVal.getContext());
-    rewriter.replaceOpWithNewOp<M::LLVM::ExtractValueOp>(extractVal, ty,
-                                                         operands[0], position);
+    auto position = mlir::ArrayAttr::get(attrs, extractVal.getContext());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(
+        extractVal, ty, operands[0], position);
     return matchSuccess();
   }
 };
@@ -1091,25 +1106,25 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
 struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
     auto insertVal = cast<InsertValueOp>(op);
     auto ty = convertType(insertVal.getType());
     assert(allConstants(operands.drop_front(2)));
     // since all indices must be constants use LLVM's insertvalue instruction
-    L::SmallVector<M::Attribute, 8> attrs;
+    llvm::SmallVector<mlir::Attribute, 8> attrs;
     for (int i = 2, end = operands.size(); i < end; ++i)
       attrs.push_back(getValue(operands[i]));
-    auto position = M::ArrayAttr::get(attrs, insertVal.getContext());
-    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(
+    auto position = mlir::ArrayAttr::get(attrs, insertVal.getContext());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
         insertVal, ty, operands[0], operands[1], position);
     return matchSuccess();
   }
 };
 
 /// return true if all `Value`s in `operands` are not `FieldIndexOp`s
-bool noFieldIndexOps(M::Operation::operand_range operands) {
+bool noFieldIndexOps(mlir::Operation::operand_range operands) {
   for (auto opnd : operands) {
     if (auto defop = opnd.getDefiningOp())
       if (dyn_cast<FieldIndexOp>(defop))
@@ -1122,13 +1137,13 @@ bool noFieldIndexOps(M::Operation::operand_range operands) {
 struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto coor = M::cast<CoordinateOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto coor = mlir::cast<CoordinateOp>(op);
     auto ty = convertType(coor.getType());
     auto loc = coor.getLoc();
-    M::Value base = operands[0];
+    mlir::Value base = operands[0];
     auto c0 = genConstantIndex(loc, lowering.indexType(), rewriter, 0);
 
     // The base can be a boxed reference or a raw reference
@@ -1138,10 +1153,11 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
         auto s = coorPtr.getDefiningOp();
         if (dyn_cast_or_null<LenParamIndexOp>(s)) {
           auto &lenParam = operands[1]; // byte offset
-          auto bc = rewriter.create<M::LLVM::BitcastOp>(loc, voidPtrTy(), base);
+          auto bc =
+              rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy(), base);
           auto uty = unwrap(ty);
           auto gep = genGEP(loc, uty, rewriter, bc, lenParam);
-          rewriter.replaceOpWithNewOp<M::LLVM::BitcastOp>(coor, uty, gep);
+          rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, uty, gep);
           return matchSuccess();
         }
       }
@@ -1149,25 +1165,25 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
       auto pty = unwrap(convertType(boxTy.getEleTy())).getPointerTo();
       // Extract the boxed reference
       auto p = genGEP(loc, pty, rewriter, base, c0, c0_);
-      base = rewriter.create<M::LLVM::LoadOp>(loc, pty, p);
+      base = rewriter.create<mlir::LLVM::LoadOp>(loc, pty, p);
     }
 
-    L::SmallVector<M::Value, 8> offs{c0};
+    llvm::SmallVector<mlir::Value, 8> offs{c0};
     auto indices = operands.drop_front(1);
     offs.append(indices.begin(), indices.end());
     if (noFieldIndexOps(coor.coor())) {
       // do not need to lower any field index ops, so use a GEP
-      rewriter.replaceOpWithNewOp<M::LLVM::GEPOp>(coor, ty, base, offs);
+      rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(coor, ty, base, offs);
       return matchSuccess();
     }
 
     // lower the field index ops by walking the indices
     auto bty = coor.ref().getType().cast<BoxType>();
-    M::Type baseTy = ReferenceType::get(bty.getEleTy());
-    L::SmallVector<M::Value, 8> args{c0};
+    mlir::Type baseTy = ReferenceType::get(bty.getEleTy());
+    llvm::SmallVector<mlir::Value, 8> args{c0};
     args.append(coor.coor().begin(), coor.coor().end());
 
-    M::Value retval = base;
+    mlir::Value retval = base;
     assert(offs.size() == args.size() && "must have same arity");
     unsigned pos = 0;
     for (unsigned i = 0, sz = offs.size(); i != sz; ++i) {
@@ -1175,15 +1191,16 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
       if (auto defop = args[i].getDefiningOp())
         if (auto field = dyn_cast<FieldIndexOp>(defop)) {
           auto memTy = unwrap(convertType(baseTy)).getPointerTo();
-          M::Value gep = retval;
+          mlir::Value gep = retval;
           if (i - pos > 0)
             gep = genGEP(loc, memTy, rewriter, gep, arguments(offs, pos, i));
-          auto bc = rewriter.create<M::LLVM::BitcastOp>(loc, voidPtrTy(), gep);
+          auto bc =
+              rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy(), gep);
           auto gep_ = genGEP(loc, voidPtrTy(), rewriter, bc, offs[i]);
           pos = i + 1;
           baseTy = baseTy.cast<RecordType>().getType(field.field_id());
-          retval = rewriter.create<M::LLVM::BitcastOp>(loc, convertType(baseTy),
-                                                       gep_);
+          retval = rewriter.create<mlir::LLVM::BitcastOp>(
+              loc, convertType(baseTy), gep_);
           continue;
         }
       if (auto ptrTy = baseTy.dyn_cast<ReferenceType>()) {
@@ -1198,7 +1215,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
         baseTy = arrTy.getEleTy();
       } else if (auto strTy = baseTy.dyn_cast<RecordType>()) {
         baseTy = strTy.getType(getIntValue(offs[i]));
-      } else if (auto strTy = baseTy.dyn_cast<M::TupleType>()) {
+      } else if (auto strTy = baseTy.dyn_cast<mlir::TupleType>()) {
         baseTy = strTy.getType(getIntValue(offs[i]));
       } else {
         assert(false && "unhandled type");
@@ -1211,15 +1228,15 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     return matchSuccess();
   }
 
-  L::SmallVector<M::Value, 8> arguments(L::ArrayRef<M::Value> vec, unsigned s,
-                                        unsigned e) const {
+  llvm::SmallVector<mlir::Value, 8> arguments(llvm::ArrayRef<mlir::Value> vec,
+                                              unsigned s, unsigned e) const {
     return {vec.begin() + s, vec.begin() + e};
   }
 
-  int64_t getIntValue(M::Value val) const {
+  int64_t getIntValue(mlir::Value val) const {
     if (val)
       if (auto defop = val.getDefiningOp())
-        if (auto constOp = dyn_cast<M::ConstantIntOp>(defop))
+        if (auto constOp = dyn_cast<mlir::ConstantIntOp>(defop))
           return constOp.getValue();
     assert(false && "must be a constant");
     return 0;
@@ -1232,26 +1249,27 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   using FIROpConversion::FIROpConversion;
 
   // NB: most field references should be resolved by this point
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto field = M::cast<FieldIndexOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto field = mlir::cast<FieldIndexOp>(op);
     // call the compiler generated function to determine the byte offset of
     // the field at runtime
-    auto symAttr = M::SymbolRefAttr::get(methodName(field), field.getContext());
-    L::SmallVector<M::NamedAttribute, 1> attrs{
+    auto symAttr =
+        mlir::SymbolRefAttr::get(methodName(field), field.getContext());
+    llvm::SmallVector<mlir::NamedAttribute, 1> attrs{
         rewriter.getNamedAttr("callee", symAttr)};
     auto ty = lowering.offsetType();
-    rewriter.replaceOpWithNewOp<M::LLVM::CallOp>(field, ty, operands, attrs);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(field, ty, operands, attrs);
     return matchSuccess();
   }
 
   // constructing the name of the method
   inline static std::string methodName(FieldIndexOp field) {
-    L::Twine fldName = field.field_id();
+    llvm::Twine fldName = field.field_id();
     // note: using std::string to dodge a bug in g++ 7.4.0
-    std::string tyName = field.on_type().cast<RecordType>().getName();
-    L::Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
+    std::string tyName = field.on_type().cast<RecordType>().getName().str();
+    llvm::Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
     return methodName.str();
   }
 };
@@ -1261,10 +1279,10 @@ struct LenParamIndexOpConversion
   using FIROpConversion::FIROpConversion;
 
   // FIXME: this should be specialized by the runtime target
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto lenp = M::cast<LenParamIndexOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto lenp = mlir::cast<LenParamIndexOp>(op);
     auto ity = lowering.indexType();
     auto onty = lenp.getOnType();
     // size of portable descriptor
@@ -1280,7 +1298,7 @@ struct LenParamIndexOpConversion
     // add the offset into the LENs
     offset += 0; // FIXME
     auto attr = rewriter.getI64IntegerAttr(offset);
-    rewriter.replaceOpWithNewOp<M::LLVM::ConstantOp>(lenp, ity, attr);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(lenp, ity, attr);
     return matchSuccess();
   }
 };
@@ -1289,9 +1307,9 @@ struct LenParamIndexOpConversion
 struct FirEndOpConversion : public FIROpConversion<FirEndOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOp(op, {});
     return matchSuccess();
   }
@@ -1302,10 +1320,10 @@ struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
   using FIROpConversion::FIROpConversion;
 
   // gendims(args:index, ...) ==> %v = ... : [size x <3 x index>]
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto gendims = M::cast<GenDimsOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto gendims = mlir::cast<GenDimsOp>(op);
     auto loc = gendims.getLoc();
     auto ty = convertType(gendims.getType());
     auto ptrTy = unwrap(ty).getPointerTo();
@@ -1316,22 +1334,22 @@ struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
     for (auto op : operands) {
       auto offset = genConstantOffset(loc, rewriter, offIndex);
       auto gep = genGEP(loc, ipty, rewriter, alloca, c0, offset);
-      rewriter.create<M::LLVM::StoreOp>(loc, op, gep);
+      rewriter.create<mlir::LLVM::StoreOp>(loc, op, gep);
     }
-    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(gendims, ptrTy, alloca);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(gendims, ptrTy, alloca);
     return matchSuccess();
   }
 
   // Generate an alloca of size `size` and cast it to type `toTy`
-  M::LLVM::AllocaOp genAlloca(M::Location loc, M::LLVM::LLVMType toTy,
-                              unsigned alignment,
-                              M::ConversionPatternRewriter &rewriter) const {
+  mlir::LLVM::AllocaOp
+  genAlloca(mlir::Location loc, mlir::LLVM::LLVMType toTy, unsigned alignment,
+            mlir::ConversionPatternRewriter &rewriter) const {
     auto thisPt = rewriter.saveInsertionPoint();
     auto *thisBlock = rewriter.getInsertionBlock();
-    auto func = M::cast<M::LLVM::LLVMFuncOp>(thisBlock->getParentOp());
+    auto func = mlir::cast<mlir::LLVM::LLVMFuncOp>(thisBlock->getParentOp());
     rewriter.setInsertionPointToStart(&func.front());
     auto size = genConstantOffset(loc, rewriter, 1);
-    auto rv = rewriter.create<M::LLVM::AllocaOp>(loc, toTy, size, alignment);
+    auto rv = rewriter.create<mlir::LLVM::AllocaOp>(loc, toTy, size, alignment);
     rewriter.restoreInsertionPoint(thisPt);
     return rv;
   }
@@ -1341,23 +1359,24 @@ struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
 struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto gentypedesc = M::cast<GenTypeDescOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto gentypedesc = mlir::cast<GenTypeDescOp>(op);
     auto loc = gentypedesc.getLoc();
     auto inTy = gentypedesc.getInType();
     auto name = consName(rewriter, inTy);
     auto gty = unwrap(convertType(inTy));
     auto pty = gty.getPointerTo();
-    auto module = gentypedesc.getParentOfType<M::ModuleOp>();
+    auto module = gentypedesc.getParentOfType<mlir::ModuleOp>();
     createGlobal(loc, module, name, gty, rewriter);
-    rewriter.replaceOpWithNewOp<M::LLVM::AddressOfOp>(gentypedesc, pty, name);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(gentypedesc, pty,
+                                                         name);
     return matchSuccess();
   }
 
-  std::string consName(M::ConversionPatternRewriter &rewriter,
-                       M::Type type) const {
+  std::string consName(mlir::ConversionPatternRewriter &rewriter,
+                       mlir::Type type) const {
     if (auto d = type.dyn_cast<RecordType>()) {
       auto name = d.getName();
       auto pair = NameUniquer::deconstruct(name);
@@ -1373,10 +1392,10 @@ struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
 struct GlobalEntryOpConversion : public FIROpConversion<GlobalEntryOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto globalentry = M::cast<GlobalEntryOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto globalentry = mlir::cast<GlobalEntryOp>(op);
     TODO(globalentry);
     return matchSuccess();
   }
@@ -1385,18 +1404,19 @@ struct GlobalEntryOpConversion : public FIROpConversion<GlobalEntryOp> {
 struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto global = M::cast<fir::GlobalOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto global = mlir::cast<fir::GlobalOp>(op);
     auto tyAttr = unwrap(convertType(global.getType()));
     bool isConst = global.getAttr("constant") ? true : false;
-    auto name =
-        global.getAttrOfType<M::StringAttr>(M::SymbolTable::getSymbolAttrName())
-            .getValue();
-    M::Attribute value;
-    rewriter.replaceOpWithNewOp<M::LLVM::GlobalOp>(
-        global, tyAttr, isConst, M::LLVM::Linkage::External, name, value);
+    auto name = global
+                    .getAttrOfType<mlir::StringAttr>(
+                        mlir::SymbolTable::getSymbolAttrName())
+                    .getValue();
+    mlir::Attribute value;
+    rewriter.replaceOpWithNewOp<mlir::LLVM::GlobalOp>(
+        global, tyAttr, isConst, mlir::LLVM::Linkage::External, name, value);
     return matchSuccess();
   }
 };
@@ -1405,13 +1425,13 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
 struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto load = M::cast<fir::LoadOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto load = mlir::cast<fir::LoadOp>(op);
     auto ty = convertType(load.getType());
     auto at = load.getAttrs();
-    rewriter.replaceOpWithNewOp<M::LLVM::LoadOp>(op, ty, operands, at);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(op, ty, operands, at);
     return matchSuccess();
   }
 };
@@ -1420,25 +1440,26 @@ struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
 struct NoReassocOpConversion : public FIROpConversion<NoReassocOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto noreassoc = M::cast<NoReassocOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto noreassoc = mlir::cast<NoReassocOp>(op);
     noreassoc.replaceAllUsesWith(operands[0]);
     rewriter.replaceOp(noreassoc, {});
     return matchSuccess();
   }
 };
 
-void genCaseLadderStep(M::Location loc, M::Value cmp, M::Block *dest,
+void genCaseLadderStep(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
                        OperandTy destOps,
-                       M::ConversionPatternRewriter &rewriter) {
+                       mlir::ConversionPatternRewriter &rewriter) {
   auto *thisBlock = rewriter.getInsertionBlock();
   auto *newBlock = rewriter.createBlock(dest);
   rewriter.setInsertionPointToEnd(thisBlock);
-  L::SmallVector<M::Block *, 2> dest_{dest, newBlock};
-  L::SmallVector<M::ValueRange, 2> destOps_{destOps, {}};
-  rewriter.create<M::LLVM::CondBrOp>(loc, M::ValueRange{cmp}, dest_, destOps_);
+  llvm::SmallVector<mlir::Block *, 2> dest_{dest, newBlock};
+  llvm::SmallVector<mlir::ValueRange, 2> destOps_{destOps, {}};
+  rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp}, dest_,
+                                        destOps_);
   rewriter.setInsertionPointToEnd(newBlock);
 }
 
@@ -1448,15 +1469,15 @@ void genCaseLadderStep(M::Location loc, M::Value cmp, M::Block *dest,
 struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  L::ArrayRef<M::Block *> destinations,
-                  L::ArrayRef<OperandTy> destOperands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto selectcase = M::cast<SelectCaseOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  llvm::ArrayRef<mlir::Block *> destinations,
+                  llvm::ArrayRef<OperandTy> destOperands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto selectcase = mlir::cast<SelectCaseOp>(op);
     auto conds = selectcase.getNumConditions();
     auto attrName = SelectCaseOp::AttrName;
-    auto caseAttr = selectcase.getAttrOfType<M::ArrayAttr>(attrName);
+    auto caseAttr = selectcase.getAttrOfType<mlir::ArrayAttr>(attrName);
     auto cases = caseAttr.getValue();
     // Type can be CHARACTER, INTEGER, or LOGICAL (C1145)
     auto ty = selectcase.getSelector().getType();
@@ -1468,67 +1489,67 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
     for (unsigned t = 0; t != conds; ++t) {
       auto &attr = cases[t];
       if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
-        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
-            loc, M::LLVM::ICmpPredicate::eq, selector, operands[nextOp++]);
+        auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+            loc, mlir::LLVM::ICmpPredicate::eq, selector, operands[nextOp++]);
         genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
         continue;
       }
       if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
-        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
-            loc, M::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
+        auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+            loc, mlir::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
         genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
         continue;
       }
       if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
-        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
-            loc, M::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
+        auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+            loc, mlir::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
         genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
         continue;
       }
       if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
-        auto cmp = rewriter.create<M::LLVM::ICmpOp>(
-            loc, M::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
+        auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+            loc, mlir::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
         auto *thisBlock = rewriter.getInsertionBlock();
         auto *newBlock1 = rewriter.createBlock(destinations[t]);
         auto *newBlock2 = rewriter.createBlock(destinations[t]);
         rewriter.setInsertionPointToEnd(thisBlock);
-        L::SmallVector<M::Block *, 2> dests{newBlock1, newBlock2};
-        L::SmallVector<M::ValueRange, 2> destOps{{}, {}};
-        rewriter.create<M::LLVM::CondBrOp>(loc, M::ValueRange{cmp}, dests,
-                                           destOps);
+        llvm::SmallVector<mlir::Block *, 2> dests{newBlock1, newBlock2};
+        llvm::SmallVector<mlir::ValueRange, 2> destOps{{}, {}};
+        rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp}, dests,
+                                              destOps);
         rewriter.setInsertionPointToEnd(newBlock1);
-        auto cmp_ = rewriter.create<M::LLVM::ICmpOp>(
-            loc, M::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
-        L::SmallVector<M::Block *, 2> dest2{destinations[t], newBlock2};
-        L::SmallVector<M::ValueRange, 2> destOp2{destOperands[t], {}};
-        rewriter.create<M::LLVM::CondBrOp>(loc, M::ValueRange{cmp_}, dest2,
-                                           destOp2);
+        auto cmp_ = rewriter.create<mlir::LLVM::ICmpOp>(
+            loc, mlir::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
+        llvm::SmallVector<mlir::Block *, 2> dest2{destinations[t], newBlock2};
+        llvm::SmallVector<mlir::ValueRange, 2> destOp2{destOperands[t], {}};
+        rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp_},
+                                              dest2, destOp2);
         rewriter.setInsertionPointToEnd(newBlock2);
         continue;
       }
-      assert(attr.dyn_cast_or_null<M::UnitAttr>());
+      assert(attr.dyn_cast_or_null<mlir::UnitAttr>());
       assert((t + 1 == conds) && "unit must be last");
-      rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(
-          selectcase, M::ValueRange{}, destinations[t],
-          M::ValueRange{destOperands[t]});
+      rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(
+          selectcase, mlir::ValueRange{}, destinations[t],
+          mlir::ValueRange{destOperands[t]});
     }
     return matchSuccess();
   }
 };
 
 template <typename OP>
-void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, M::Operation *op,
-                           OperandTy operands,
-                           L::ArrayRef<M::Block *> destinations,
-                           L::ArrayRef<OperandTy> destOperands,
-                           M::ConversionPatternRewriter &rewriter) {
-  auto select = M::cast<OP>(op);
+void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering,
+                           mlir::Operation *op, OperandTy operands,
+                           llvm::ArrayRef<mlir::Block *> destinations,
+                           llvm::ArrayRef<OperandTy> destOperands,
+                           mlir::ConversionPatternRewriter &rewriter) {
+  auto select = mlir::cast<OP>(op);
 
   // We could target the LLVM switch instruction, but it isn't part of the
   // LLVM IR dialect.  Create an if-then-else ladder instead.
   auto conds = select.getNumConditions();
   auto attrName = OP::AttrName;
-  auto caseAttr = select.template getAttrOfType<M::ArrayAttr>(attrName);
+  auto caseAttr = select.template getAttrOfType<mlir::ArrayAttr>(attrName);
   auto cases = caseAttr.getValue();
   auto ty = select.getSelector().getType();
   auto ity = lowering.convertType(ty);
@@ -1537,19 +1558,19 @@ void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, M::Operation *op,
   assert(conds > 0 && "select must have cases");
   for (unsigned t = 0; t != conds; ++t) {
     auto &attr = cases[t];
-    if (auto intAttr = attr.template dyn_cast_or_null<M::IntegerAttr>()) {
-      auto ci = rewriter.create<M::LLVM::ConstantOp>(
+    if (auto intAttr = attr.template dyn_cast_or_null<mlir::IntegerAttr>()) {
+      auto ci = rewriter.create<mlir::LLVM::ConstantOp>(
           loc, ity, rewriter.getIntegerAttr(ty, intAttr.getInt()));
-      auto cmp = rewriter.create<M::LLVM::ICmpOp>(
-          loc, M::LLVM::ICmpPredicate::eq, selector, ci);
+      auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+          loc, mlir::LLVM::ICmpPredicate::eq, selector, ci);
       genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
       continue;
     }
-    assert(attr.template dyn_cast_or_null<M::UnitAttr>());
+    assert(attr.template dyn_cast_or_null<mlir::UnitAttr>());
     assert((t + 1 == conds) && "unit must be last");
-    rewriter.replaceOpWithNewOp<M::LLVM::BrOp>(select, M::ValueRange{},
-                                               destinations[t],
-                                               M::ValueRange{destOperands[t]});
+    rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(
+        select, mlir::ValueRange{}, destinations[t],
+        mlir::ValueRange{destOperands[t]});
   }
 }
 
@@ -1557,11 +1578,11 @@ void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, M::Operation *op,
 struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  L::ArrayRef<M::Block *> destinations,
-                  L::ArrayRef<OperandTy> destOperands,
-                  M::ConversionPatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  llvm::ArrayRef<mlir::Block *> destinations,
+                  llvm::ArrayRef<OperandTy> destOperands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectOp>(lowering, op, operands, destinations,
                                          destOperands, rewriter);
     return matchSuccess();
@@ -1572,11 +1593,11 @@ struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
 struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  L::ArrayRef<M::Block *> destinations,
-                  L::ArrayRef<OperandTy> destOperands,
-                  M::ConversionPatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  llvm::ArrayRef<mlir::Block *> destinations,
+                  llvm::ArrayRef<OperandTy> destOperands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectRankOp>(
         lowering, op, operands, destinations, destOperands, rewriter);
     return matchSuccess();
@@ -1587,12 +1608,12 @@ struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
 struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  L::ArrayRef<M::Block *> destinations,
-                  L::ArrayRef<OperandTy> destOperands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto selecttype = M::cast<SelectTypeOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  llvm::ArrayRef<mlir::Block *> destinations,
+                  llvm::ArrayRef<OperandTy> destOperands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto selecttype = mlir::cast<SelectTypeOp>(op);
     TODO(selecttype);
     return matchSuccess();
   }
@@ -1602,41 +1623,42 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
 struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto store = M::cast<fir::StoreOp>(op);
-    rewriter.replaceOpWithNewOp<M::LLVM::StoreOp>(store, operands[0],
-                                                  operands[1]);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto store = mlir::cast<fir::StoreOp>(op);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::StoreOp>(store, operands[0],
+                                                     operands[1]);
     return matchSuccess();
   }
 };
 
 // cons an extractvalue on a tuple value, returning value at element `x`
-M::LLVM::ExtractValueOp
-genExtractValueWithIndex(M::Location loc, M::Value tuple, M::LLVM::LLVMType ty,
-                         M::ConversionPatternRewriter &rewriter,
-                         M::MLIRContext *ctx, int x) {
-  auto cx = M::ArrayAttr::get(rewriter.getI32IntegerAttr(x), ctx);
+mlir::LLVM::ExtractValueOp genExtractValueWithIndex(
+    mlir::Location loc, mlir::Value tuple, mlir::LLVM::LLVMType ty,
+    mlir::ConversionPatternRewriter &rewriter, mlir::MLIRContext *ctx, int x) {
+  auto cx = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(x), ctx);
   auto xty = ty.getStructElementType(x);
-  return rewriter.create<M::LLVM::ExtractValueOp>(loc, xty, tuple, cx);
+  return rewriter.create<mlir::LLVM::ExtractValueOp>(loc, xty, tuple, cx);
 }
 
 // unbox a CHARACTER box value, yielding its components
 struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto unboxchar = M::cast<UnboxCharOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto unboxchar = mlir::cast<UnboxCharOp>(op);
     auto *ctx = unboxchar.getContext();
     auto loc = unboxchar.getLoc();
     auto tuple = operands[0];
     auto ty = unwrap(tuple.getType());
-    M::Value ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
-    M::Value len = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
-    std::vector<M::Value> repls = {ptr, len};
+    mlir::Value ptr =
+        genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
+    mlir::Value len =
+        genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
+    std::vector<mlir::Value> repls = {ptr, len};
     unboxchar.replaceAllUsesWith(repls);
     rewriter.eraseOp(unboxchar);
     return matchSuccess();
@@ -1644,41 +1666,41 @@ struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
 };
 
 // generate a GEP into a structure and load the element at position `x`
-M::LLVM::LoadOp genLoadWithIndex(M::Location loc, M::Value tuple,
-                                 M::LLVM::LLVMType ty,
-                                 M::ConversionPatternRewriter &rewriter,
-                                 M::LLVM::LLVMType oty, M::LLVM::ConstantOp c0,
-                                 int x) {
+mlir::LLVM::LoadOp genLoadWithIndex(mlir::Location loc, mlir::Value tuple,
+                                    mlir::LLVM::LLVMType ty,
+                                    mlir::ConversionPatternRewriter &rewriter,
+                                    mlir::LLVM::LLVMType oty,
+                                    mlir::LLVM::ConstantOp c0, int x) {
   auto ax = rewriter.getI32IntegerAttr(x);
-  auto cx = rewriter.create<M::LLVM::ConstantOp>(loc, oty, ax);
+  auto cx = rewriter.create<mlir::LLVM::ConstantOp>(loc, oty, ax);
   auto xty = ty.getStructElementType(x);
   auto gep = genGEP(loc, xty.getPointerTo(), rewriter, tuple, c0, cx);
-  return rewriter.create<M::LLVM::LoadOp>(loc, xty, gep);
+  return rewriter.create<mlir::LLVM::LoadOp>(loc, xty, gep);
 }
 
 // unbox a generic box reference, yielding its components
 struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto unbox = M::cast<UnboxOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto unbox = mlir::cast<UnboxOp>(op);
     auto loc = unbox.getLoc();
     auto tuple = operands[0];
     auto ty = unwrap(tuple.getType());
     auto oty = lowering.offsetType();
-    auto c0 = rewriter.create<M::LLVM::ConstantOp>(
+    auto c0 = rewriter.create<mlir::LLVM::ConstantOp>(
         loc, oty, rewriter.getI32IntegerAttr(0));
-    M::Value ptr = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 0);
-    M::Value len = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 1);
-    M::Value ver = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 2);
-    M::Value rank = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 3);
-    M::Value type = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 4);
-    M::Value attr = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 5);
-    M::Value xtra = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 6);
+    mlir::Value ptr = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 0);
+    mlir::Value len = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 1);
+    mlir::Value ver = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 2);
+    mlir::Value rank = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 3);
+    mlir::Value type = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 4);
+    mlir::Value attr = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 5);
+    mlir::Value xtra = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 6);
     // FIXME: add dims, etc.
-    std::vector<M::Value> repls = {ptr, len, ver, rank, type, attr, xtra};
+    std::vector<mlir::Value> repls = {ptr, len, ver, rank, type, attr, xtra};
     unbox.replaceAllUsesWith(repls);
     rewriter.eraseOp(unbox);
     return matchSuccess();
@@ -1689,17 +1711,19 @@ struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
 struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto unboxproc = M::cast<UnboxProcOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto unboxproc = mlir::cast<UnboxProcOp>(op);
     auto *ctx = unboxproc.getContext();
     auto loc = unboxproc.getLoc();
     auto tuple = operands[0];
     auto ty = unwrap(tuple.getType());
-    M::Value ptr = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
-    M::Value host = genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
-    std::vector<M::Value> repls = {ptr, host};
+    mlir::Value ptr =
+        genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
+    mlir::Value host =
+        genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
+    std::vector<mlir::Value> repls = {ptr, host};
     unboxproc.replaceAllUsesWith(repls);
     rewriter.eraseOp(unboxproc);
     return matchSuccess();
@@ -1710,12 +1734,12 @@ struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
 struct UndefOpConversion : public FIROpConversion<UndefOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto undef = M::cast<UndefOp>(op);
-    rewriter.replaceOpWithNewOp<M::LLVM::UndefOp>(undef,
-                                                  convertType(undef.getType()));
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto undef = mlir::cast<UndefOp>(op);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::UndefOp>(
+        undef, convertType(undef.getType()));
     return matchSuccess();
   }
 };
@@ -1724,13 +1748,12 @@ struct UndefOpConversion : public FIROpConversion<UndefOp> {
 struct UnreachableOpConversion : public FIROpConversion<UnreachableOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto unreach = M::cast<UnreachableOp>(op);
-    rewriter.replaceOpWithNewOp<M::LLVM::UnreachableOp>(
-        unreach, operands, L::ArrayRef<M::Block *>{},
-        L::ArrayRef<M::ValueRange>{}, unreach.getAttrs());
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto unreach = mlir::cast<UnreachableOp>(op);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(
+        unreach, operands, llvm::None, llvm::None, unreach.getAttrs());
     return matchSuccess();
   }
 };
@@ -1741,8 +1764,8 @@ struct UnreachableOpConversion : public FIROpConversion<UnreachableOp> {
 
 /// Convert a floating-point primitive
 template <typename BINOP, typename LLVMOP>
-void lowerRealBinaryOp(M::Operation *op, OperandTy operands,
-                       M::ConversionPatternRewriter &rewriter,
+void lowerRealBinaryOp(mlir::Operation *op, OperandTy operands,
+                       mlir::ConversionPatternRewriter &rewriter,
                        FIRToLLVMTypeConverter &lowering) {
   auto binop = cast<BINOP>(op);
   auto ty = lowering.convertType(binop.getType());
@@ -1752,55 +1775,55 @@ void lowerRealBinaryOp(M::Operation *op, OperandTy operands,
 struct AddfOpConversion : public FIROpConversion<fir::AddfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::AddfOp, M::LLVM::FAddOp>(op, operands, rewriter,
-                                                    lowering);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::AddfOp, mlir::LLVM::FAddOp>(op, operands, rewriter,
+                                                       lowering);
     return matchSuccess();
   }
 };
 struct SubfOpConversion : public FIROpConversion<fir::SubfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::SubfOp, M::LLVM::FSubOp>(op, operands, rewriter,
-                                                    lowering);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::SubfOp, mlir::LLVM::FSubOp>(op, operands, rewriter,
+                                                       lowering);
     return matchSuccess();
   }
 };
 struct MulfOpConversion : public FIROpConversion<fir::MulfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::MulfOp, M::LLVM::FMulOp>(op, operands, rewriter,
-                                                    lowering);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::MulfOp, mlir::LLVM::FMulOp>(op, operands, rewriter,
+                                                       lowering);
     return matchSuccess();
   }
 };
 struct DivfOpConversion : public FIROpConversion<fir::DivfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::DivfOp, M::LLVM::FDivOp>(op, operands, rewriter,
-                                                    lowering);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::DivfOp, mlir::LLVM::FDivOp>(op, operands, rewriter,
+                                                       lowering);
     return matchSuccess();
   }
 };
 struct ModfOpConversion : public FIROpConversion<fir::ModfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::ModfOp, M::LLVM::FRemOp>(op, operands, rewriter,
-                                                    lowering);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    lowerRealBinaryOp<fir::ModfOp, mlir::LLVM::FRemOp>(op, operands, rewriter,
+                                                       lowering);
     return matchSuccess();
   }
 };
@@ -1808,12 +1831,12 @@ struct ModfOpConversion : public FIROpConversion<fir::ModfOp> {
 struct NegfOpConversion : public FIROpConversion<fir::NegfOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto neg = M::cast<fir::NegfOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto neg = mlir::cast<fir::NegfOp>(op);
     auto ty = convertType(neg.getType());
-    rewriter.replaceOpWithNewOp<M::LLVM::FNegOp>(neg, ty, operands);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::FNegOp>(neg, ty, operands);
     return matchSuccess();
   }
 };
@@ -1824,36 +1847,36 @@ struct NegfOpConversion : public FIROpConversion<fir::NegfOp> {
 
 /// Generate code for complex addition/subtraction
 template <typename LLVMOP, typename OPTY>
-M::LLVM::InsertValueOp complexSum(OPTY sumop, OperandTy opnds,
-                                  M::ConversionPatternRewriter &rewriter,
-                                  FIRToLLVMTypeConverter &lowering) {
+mlir::LLVM::InsertValueOp complexSum(OPTY sumop, OperandTy opnds,
+                                     mlir::ConversionPatternRewriter &rewriter,
+                                     FIRToLLVMTypeConverter &lowering) {
   auto a = opnds[0];
   auto b = opnds[1];
   auto loc = sumop.getLoc();
   auto ctx = sumop.getContext();
-  auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
-  auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+  auto c0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+  auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
   auto ty = lowering.convertType(sumop.getType());
-  auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
-  auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
+  auto x = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, a, c0);
+  auto x_ = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, b, c0);
   auto rx = rewriter.create<LLVMOP>(loc, ty, x, x_);
-  auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
-  auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
+  auto y = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, a, c1);
+  auto y_ = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, b, c1);
   auto ry = rewriter.create<LLVMOP>(loc, ty, y, y_);
-  auto r = rewriter.create<M::LLVM::UndefOp>(loc, ty);
-  auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r, rx, c0);
-  return rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ry, c1);
+  auto r = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+  auto r_ = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r, rx, c0);
+  return rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r_, ry, c1);
 }
 
 struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
     // result: (x + x') + i(y + y')
     auto addc = cast<fir::AddcOp>(op);
-    auto r = complexSum<M::LLVM::FAddOp>(addc, operands, rewriter, lowering);
+    auto r = complexSum<mlir::LLVM::FAddOp>(addc, operands, rewriter, lowering);
     addc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(addc, r.getResult());
     return matchSuccess();
@@ -1863,12 +1886,12 @@ struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
 struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
     // result: (x - x') + i(y - y')
-    auto subc = M::cast<fir::SubcOp>(op);
-    auto r = complexSum<M::LLVM::FSubOp>(subc, operands, rewriter, lowering);
+    auto subc = mlir::cast<fir::SubcOp>(op);
+    auto r = complexSum<mlir::LLVM::FSubOp>(subc, operands, rewriter, lowering);
     subc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(subc, r.getResult());
     return matchSuccess();
@@ -1879,32 +1902,32 @@ struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
 struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto mulc = M::cast<fir::MulcOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto mulc = mlir::cast<fir::MulcOp>(op);
     // FIXME: should this just call __muldc3 ?
     // result: (xx'-yy')+i(xy'+yx')
     auto a = operands[0];
     auto b = operands[1];
     auto loc = mulc.getLoc();
     auto ctx = mulc.getContext();
-    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
-    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto c0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     auto ty = convertType(mulc.getType());
-    auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
-    auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
-    auto xx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, x_);
-    auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
-    auto yx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, x_);
-    auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
-    auto xy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, y_);
-    auto ri = rewriter.create<M::LLVM::FAddOp>(loc, ty, xy_, yx_);
-    auto yy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, y_);
-    auto rr = rewriter.create<M::LLVM::FSubOp>(loc, ty, xx_, yy_);
-    auto ra = rewriter.create<M::LLVM::UndefOp>(loc, ty);
-    auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
-    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
+    auto x = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, a, c0);
+    auto x_ = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, b, c0);
+    auto xx_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, x, x_);
+    auto y = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, a, c1);
+    auto yx_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, y, x_);
+    auto y_ = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, b, c1);
+    auto xy_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, x, y_);
+    auto ri = rewriter.create<mlir::LLVM::FAddOp>(loc, ty, xy_, yx_);
+    auto yy_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, y, y_);
+    auto rr = rewriter.create<mlir::LLVM::FSubOp>(loc, ty, xx_, yy_);
+    auto ra = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+    auto r_ = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
+    auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
     mulc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(mulc, r.getResult());
     return matchSuccess();
@@ -1915,37 +1938,37 @@ struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
 struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto divc = M::cast<fir::DivcOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto divc = mlir::cast<fir::DivcOp>(op);
     // FIXME: should this just call __divdc3 ?
     // result: ((xx'+yy')/d) + i((yx'-xy')/d) where d = x'x' + y'y'
     auto a = operands[0];
     auto b = operands[1];
     auto loc = divc.getLoc();
     auto ctx = divc.getContext();
-    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
-    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto c0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     auto ty = convertType(divc.getType());
-    auto x = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c0);
-    auto x_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c0);
-    auto xx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, x_);
-    auto x_x_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x_, x_);
-    auto y = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, a, c1);
-    auto yx_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, x_);
-    auto y_ = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, b, c1);
-    auto xy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, x, y_);
-    auto yy_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y, y_);
-    auto y_y_ = rewriter.create<M::LLVM::FMulOp>(loc, ty, y_, y_);
-    auto d = rewriter.create<M::LLVM::FAddOp>(loc, ty, x_x_, y_y_);
-    auto rrn = rewriter.create<M::LLVM::FAddOp>(loc, ty, xx_, yy_);
-    auto rin = rewriter.create<M::LLVM::FSubOp>(loc, ty, yx_, xy_);
-    auto rr = rewriter.create<M::LLVM::FDivOp>(loc, ty, rrn, d);
-    auto ri = rewriter.create<M::LLVM::FDivOp>(loc, ty, rin, d);
-    auto ra = rewriter.create<M::LLVM::UndefOp>(loc, ty);
-    auto r_ = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
-    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
+    auto x = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, a, c0);
+    auto x_ = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, b, c0);
+    auto xx_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, x, x_);
+    auto x_x_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, x_, x_);
+    auto y = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, a, c1);
+    auto yx_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, y, x_);
+    auto y_ = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, b, c1);
+    auto xy_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, x, y_);
+    auto yy_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, y, y_);
+    auto y_y_ = rewriter.create<mlir::LLVM::FMulOp>(loc, ty, y_, y_);
+    auto d = rewriter.create<mlir::LLVM::FAddOp>(loc, ty, x_x_, y_y_);
+    auto rrn = rewriter.create<mlir::LLVM::FAddOp>(loc, ty, xx_, yy_);
+    auto rin = rewriter.create<mlir::LLVM::FSubOp>(loc, ty, yx_, xy_);
+    auto rr = rewriter.create<mlir::LLVM::FDivOp>(loc, ty, rrn, d);
+    auto ri = rewriter.create<mlir::LLVM::FDivOp>(loc, ty, rin, d);
+    auto ra = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+    auto r_ = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
+    auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
     divc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(divc, r.getResult());
     return matchSuccess();
@@ -1955,22 +1978,22 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
 struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto neg = M::cast<fir::NegcOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto neg = mlir::cast<fir::NegcOp>(op);
     auto ctxt = neg.getContext();
     auto ty = convertType(neg.getType());
     auto loc = neg.getLoc();
-    auto c0 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
+    auto c0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
     auto &o0 = operands[0];
-    auto rp = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, o0, c0);
-    auto nrp = rewriter.create<M::LLVM::FNegOp>(loc, ty, rp);
-    auto c1 = M::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
-    auto ip = rewriter.create<M::LLVM::ExtractValueOp>(loc, ty, o0, c1);
-    auto nip = rewriter.create<M::LLVM::FNegOp>(loc, ty, ip);
-    auto r = rewriter.create<M::LLVM::InsertValueOp>(loc, ty, o0, nrp, c0);
-    rewriter.replaceOpWithNewOp<M::LLVM::InsertValueOp>(neg, ty, r, nip, c1);
+    auto rp = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, o0, c0);
+    auto nrp = rewriter.create<mlir::LLVM::FNegOp>(loc, ty, rp);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
+    auto ip = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, o0, c1);
+    auto nip = rewriter.create<mlir::LLVM::FNegOp>(loc, ty, ip);
+    auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, o0, nrp, c0);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(neg, ty, r, nip, c1);
     return matchSuccess();
   }
 };
@@ -1981,7 +2004,7 @@ struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
 ///
 /// This pass lowers all FIR dialect operations to LLVM IR dialect.  An
 /// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
-struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
+struct FIRToLLVMLoweringPass : public mlir::ModulePass<FIRToLLVMLoweringPass> {
   FIRToLLVMLoweringPass(NameUniquer &uniquer) : uniquer{uniquer} {}
 
   void runOnModule() override {
@@ -1990,7 +2013,7 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
 
     auto *context{&getContext()};
     FIRToLLVMTypeConverter typeConverter{context, uniquer};
-    M::OwningRewritePatternList patterns;
+    mlir::OwningRewritePatternList patterns;
     patterns.insert<
         AddcOpConversion, AddfOpConversion, AddrOfOpConversion,
         AllocaOpConversion, AllocMemOpConversion, BoxAddrOpConversion,
@@ -2012,23 +2035,23 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
         SubfOpConversion, UnboxCharOpConversion, UnboxOpConversion,
         UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion>(
         context, typeConverter);
-    M::populateStdToLLVMConversionPatterns(typeConverter, patterns);
-    M::ConversionTarget target{*context};
-    target.addLegalDialect<M::LLVM::LLVMDialect>();
+    mlir::populateStdToLLVMConversionPatterns(typeConverter, patterns);
+    mlir::ConversionTarget target{*context};
+    target.addLegalDialect<mlir::LLVM::LLVMDialect>();
 
     // required NOP stubs for applying a full conversion
-    target.addDynamicallyLegalOp<M::ModuleOp>(
-        [&](M::ModuleOp) { return true; });
-    target.addDynamicallyLegalOp<M::ModuleTerminatorOp>(
-        [&](M::ModuleTerminatorOp) { return true; });
+    target.addDynamicallyLegalOp<mlir::ModuleOp>(
+        [&](mlir::ModuleOp) { return true; });
+    target.addDynamicallyLegalOp<mlir::ModuleTerminatorOp>(
+        [&](mlir::ModuleTerminatorOp) { return true; });
 
     genDispatchTableMap();
 
     // apply the patterns
-    if (M::failed(M::applyFullConversion(
+    if (mlir::failed(mlir::applyFullConversion(
             getModule(), target, std::move(patterns), &typeConverter))) {
-      M::emitError(M::UnknownLoc::get(context),
-                   "error in converting to LLVM-IR dialect\n");
+      mlir::emitError(mlir::UnknownLoc::get(context),
+                      "error in converting to LLVM-IR dialect\n");
       signalPassFailure();
     }
   }
@@ -2045,35 +2068,35 @@ struct FIRToLLVMLoweringPass : public M::ModulePass<FIRToLLVMLoweringPass> {
 };
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
-struct LLVMIRLoweringPass : public M::ModulePass<LLVMIRLoweringPass> {
-  LLVMIRLoweringPass(L::raw_ostream &output) : output{output} {}
+struct LLVMIRLoweringPass : public mlir::ModulePass<LLVMIRLoweringPass> {
+  LLVMIRLoweringPass(llvm::raw_ostream &output) : output{output} {}
 
   void runOnModule() override {
     if (ClDisableLLVM)
       return;
 
-    if (auto llvmModule{M::translateModuleToLLVMIR(getModule())}) {
+    if (auto llvmModule{mlir::translateModuleToLLVMIR(getModule())}) {
       output << *llvmModule;
       return;
     }
 
     auto ctxt{getModule().getContext()};
-    M::emitError(M::UnknownLoc::get(ctxt), "could not emit LLVM-IR\n");
+    mlir::emitError(mlir::UnknownLoc::get(ctxt), "could not emit LLVM-IR\n");
     signalPassFailure();
   }
 
 private:
-  L::raw_ostream &output;
+  llvm::raw_ostream &output;
 };
 
 } // namespace
 
-std::unique_ptr<M::Pass>
+std::unique_ptr<mlir::Pass>
 fir::createFIRToLLVMPass(fir::NameUniquer &nameUniquer) {
   return std::make_unique<FIRToLLVMLoweringPass>(nameUniquer);
 }
 
-std::unique_ptr<M::Pass>
-fir::createLLVMDialectToLLVMPass(L::raw_ostream &output) {
+std::unique_ptr<mlir::Pass>
+fir::createLLVMDialectToLLVMPass(llvm::raw_ostream &output) {
   return std::make_unique<LLVMIRLoweringPass>(output);
 }
diff --git a/lib/optimizer/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
index 0eddcf163f45..2580709265ef 100644
--- a/lib/optimizer/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -1,4 +1,4 @@
-//===-- lib/optimizer/StdConverter.cpp ------------------------------------===//
+//===-- StdConverter.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -22,59 +22,56 @@
 // This module performs the conversion of some FIR operations.
 // Convert some FIR types to standard dialect?
 
-namespace L = llvm;
-namespace M = mlir;
-
-using namespace fir;
-
-static L::cl::opt<bool>
+static llvm::cl::opt<bool>
     ClDisableFirToStd("disable-fir2std",
-                      L::cl::desc("disable FIR to standard pass"),
-                      L::cl::init(false), L::cl::Hidden);
+                      llvm::cl::desc("disable FIR to standard pass"),
+                      llvm::cl::init(false), llvm::cl::Hidden);
 
+namespace fir {
 namespace {
 
-using SmallVecResult = L::SmallVector<M::Value, 4>;
-using OperandTy = L::ArrayRef<M::Value>;
-using AttributeTy = L::ArrayRef<M::NamedAttribute>;
+using SmallVecResult = llvm::SmallVector<mlir::Value, 4>;
+using OperandTy = llvm::ArrayRef<mlir::Value>;
+using AttributeTy = llvm::ArrayRef<mlir::NamedAttribute>;
 
 /// FIR to standard type converter
 /// This converts a subset of FIR types to standard types
-class FIRToStdTypeConverter : public M::TypeConverter {
+class FIRToStdTypeConverter : public mlir::TypeConverter {
 public:
   using TypeConverter::TypeConverter;
 
   explicit FIRToStdTypeConverter(KindMapping &kindMap) : kindMap{kindMap} {}
 
   // convert front-end REAL kind value to a std dialect type, if possible
-  static M::Type kindToRealType(KindMapping &kindMap, KindTy kind) {
+  static mlir::Type kindToRealType(KindMapping &kindMap, KindTy kind) {
     auto *ctx = kindMap.getContext();
     switch (kindMap.getRealTypeID(kind)) {
-    case L::Type::TypeID::HalfTyID:
-      return M::FloatType::getF16(ctx);
+    case llvm::Type::TypeID::HalfTyID:
+      return mlir::FloatType::getF16(ctx);
 #if 0
     // FIXME: there is no BF16 type in LLVM yet
-    case L::Type::TypeID:: FIXME TyID:
-      return M::FloatType::getBF16(ctx);
+    case llvm::Type::TypeID:: FIXME TyID:
+      return mlir::FloatType::getBF16(ctx);
 #endif
-    case L::Type::TypeID::FloatTyID:
-      return M::FloatType::getF32(ctx);
-    case L::Type::TypeID::DoubleTyID:
-      return M::FloatType::getF64(ctx);
-    case L::Type::TypeID::X86_FP80TyID: // MLIR does not support yet
-    case L::Type::TypeID::FP128TyID:    // MLIR does not support yet
+    case llvm::Type::TypeID::FloatTyID:
+      return mlir::FloatType::getF32(ctx);
+    case llvm::Type::TypeID::DoubleTyID:
+      return mlir::FloatType::getF64(ctx);
+    case llvm::Type::TypeID::X86_FP80TyID: // MLIR does not support yet
+    case llvm::Type::TypeID::FP128TyID:    // MLIR does not support yet
     default:
-      return fir::RealType::get(ctx, kind);
+      return RealType::get(ctx, kind);
     }
   }
 
   /// Convert some FIR types to MLIR standard dialect types
-  M::Type convertType(M::Type t) override {
+  mlir::Type convertType(mlir::Type t) override {
     // To lower types, we have to convert everything that uses these types...
     if (auto cplx = t.dyn_cast<CplxType>())
-      return M::ComplexType::get(kindToRealType(kindMap, cplx.getFKind()));
+      return mlir::ComplexType::get(kindToRealType(kindMap, cplx.getFKind()));
     if (auto integer = t.dyn_cast<IntType>())
-      return M::IntegerType::get(integer.getFKind() * 8, integer.getContext());
+      return mlir::IntegerType::get(integer.getFKind() * 8,
+                                    integer.getContext());
     if (auto real = t.dyn_cast<RealType>())
       return kindToRealType(kindMap, real.getFKind());
     return t;
@@ -86,16 +83,17 @@ class FIRToStdTypeConverter : public M::TypeConverter {
 
 /// FIR conversion pattern template
 template <typename FromOp>
-class FIROpConversion : public M::ConversionPattern {
+class FIROpConversion : public mlir::ConversionPattern {
 public:
   explicit FIROpConversion(
-      M::MLIRContext *ctx /*, FIRToStdTypeConverter &lowering*/)
+      mlir::MLIRContext *ctx /*, FIRToStdTypeConverter &lowering*/)
       : ConversionPattern(FromOp::getOperationName(), 1,
                           ctx) /*, lowering(lowering)*/
   {}
 
 protected:
-  // M::Type convertType(M::Type ty) const { return lowering.convertType(ty); }
+  // mlir::Type convertType(mlir::Type ty) const { return
+  // lowering.convertType(ty); }
 
   // FIRToStdTypeConverter &lowering;
 };
@@ -106,55 +104,56 @@ class FIROpConversion : public M::ConversionPattern {
 struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
   using FIROpConversion::FIROpConversion;
 
-  M::PatternMatchResult
-  matchAndRewrite(M::Operation *op, OperandTy operands,
-                  L::ArrayRef<M::Block *> destinations,
-                  L::ArrayRef<OperandTy> destOperands,
-                  M::ConversionPatternRewriter &rewriter) const override {
-    auto selectType = M::cast<SelectTypeOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  llvm::ArrayRef<mlir::Block *> destinations,
+                  llvm::ArrayRef<OperandTy> destOperands,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto selectType = mlir::cast<SelectTypeOp>(op);
     auto conds = selectType.getNumConditions();
     auto attrName = SelectTypeOp::AttrName;
-    auto caseAttr = selectType.getAttrOfType<M::ArrayAttr>(attrName);
+    auto caseAttr = selectType.getAttrOfType<mlir::ArrayAttr>(attrName);
     auto cases = caseAttr.getValue();
     // Selector must be of type !fir.box<T>
     auto &selector = operands[0];
     auto loc = selectType.getLoc();
-    auto mod = op->getParentOfType<M::ModuleOp>();
+    auto mod = op->getParentOfType<mlir::ModuleOp>();
     for (unsigned t = 0; t != conds; ++t) {
       auto &attr = cases[t];
-      if (auto a = attr.dyn_cast_or_null<fir::ExactTypeAttr>()) {
+      if (auto a = attr.dyn_cast_or_null<ExactTypeAttr>()) {
         genTypeLadderStep(loc, true, selector, a.getType(), destinations[t],
                           destOperands[t], mod, rewriter);
         continue;
       }
-      if (auto a = attr.dyn_cast_or_null<fir::SubclassAttr>()) {
+      if (auto a = attr.dyn_cast_or_null<SubclassAttr>()) {
         genTypeLadderStep(loc, false, selector, a.getType(), destinations[t],
                           destOperands[t], mod, rewriter);
         continue;
       }
-      assert(attr.dyn_cast_or_null<M::UnitAttr>());
+      assert(attr.dyn_cast_or_null<mlir::UnitAttr>());
       assert((t + 1 == conds) && "unit must be last");
-      rewriter.replaceOpWithNewOp<M::BranchOp>(selectType, destinations[t],
-                                               M::ValueRange{destOperands[t]});
+      rewriter.replaceOpWithNewOp<mlir::BranchOp>(
+          selectType, destinations[t], mlir::ValueRange{destOperands[t]});
     }
     return matchSuccess();
   }
 
-  static void genTypeLadderStep(M::Location loc, bool exactTest,
-                                M::Value selector, M::Type ty, M::Block *dest,
-                                OperandTy destOps, M::ModuleOp module,
-                                M::ConversionPatternRewriter &rewriter) {
-    M::Type tydesc = fir::TypeDescType::get(ty);
-    auto tyattr = M::TypeAttr::get(ty);
-    M::Value t = rewriter.create<GenTypeDescOp>(loc, tydesc, tyattr);
-    M::Type selty = fir::BoxType::get(rewriter.getNoneType());
-    M::Value csel = rewriter.create<ConvertOp>(loc, selty, selector);
-    M::Type tty = fir::ReferenceType::get(rewriter.getNoneType());
-    M::Value ct = rewriter.create<ConvertOp>(loc, tty, t);
-    std::vector<M::Value> actuals = {csel, ct};
+  static void genTypeLadderStep(mlir::Location loc, bool exactTest,
+                                mlir::Value selector, mlir::Type ty,
+                                mlir::Block *dest, OperandTy destOps,
+                                mlir::ModuleOp module,
+                                mlir::ConversionPatternRewriter &rewriter) {
+    mlir::Type tydesc = TypeDescType::get(ty);
+    auto tyattr = mlir::TypeAttr::get(ty);
+    mlir::Value t = rewriter.create<GenTypeDescOp>(loc, tydesc, tyattr);
+    mlir::Type selty = BoxType::get(rewriter.getNoneType());
+    mlir::Value csel = rewriter.create<ConvertOp>(loc, selty, selector);
+    mlir::Type tty = ReferenceType::get(rewriter.getNoneType());
+    mlir::Value ct = rewriter.create<ConvertOp>(loc, tty, t);
+    std::vector<mlir::Value> actuals = {csel, ct};
     auto fty = rewriter.getI1Type();
-    std::vector<M::Type> argTy = {selty, tty};
-    L::StringRef funName =
+    std::vector<mlir::Type> argTy = {selty, tty};
+    llvm::StringRef funName =
         exactTest ? "FIXME_exact_type_match" : "FIXME_isa_type_test";
     createFuncOp(rewriter.getUnknownLoc(), module, funName,
                  rewriter.getFunctionType(argTy, fty));
@@ -162,19 +161,19 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
     // runtime type of the selector is an exact match to a derived type or (2)
     // testing if the runtime type of the selector is a derived type or one of
     // that derived type's subtypes.
-    auto cmp = rewriter.create<M::CallOp>(
+    auto cmp = rewriter.create<mlir::CallOp>(
         loc, fty, rewriter.getSymbolRefAttr(funName), actuals);
     auto *thisBlock = rewriter.getInsertionBlock();
     auto *newBlock = rewriter.createBlock(dest);
     rewriter.setInsertionPointToEnd(thisBlock);
-    rewriter.create<M::CondBranchOp>(loc, cmp.getResult(0), dest, destOps,
-                                     newBlock, OperandTy{});
+    rewriter.create<mlir::CondBranchOp>(loc, cmp.getResult(0), dest, destOps,
+                                        newBlock, OperandTy{});
     rewriter.setInsertionPointToEnd(newBlock);
   }
 };
 
 /// Convert affine dialect, fir.select_type to standard dialect
-class FIRToStdLoweringPass : public M::FunctionPass<FIRToStdLoweringPass> {
+class FIRToStdLoweringPass : public mlir::FunctionPass<FIRToStdLoweringPass> {
 public:
   explicit FIRToStdLoweringPass(KindMapping &kindMap) : kindMap{kindMap} {}
 
@@ -184,36 +183,37 @@ class FIRToStdLoweringPass : public M::FunctionPass<FIRToStdLoweringPass> {
 
     auto *context{&getContext()};
     // FIRToStdTypeConverter typeConverter{kindMap};
-    M::OwningRewritePatternList patterns;
+    mlir::OwningRewritePatternList patterns;
     // patterns.insert<SelectTypeOpConversion>(context, typeConverter);
     patterns.insert<SelectTypeOpConversion>(context);
-    M::populateAffineToStdConversionPatterns(patterns, context);
-    // M::populateFuncOpTypeConversionPattern(patterns, context, typeConverter);
-    M::ConversionTarget target{*context};
-    target.addLegalDialect<M::StandardOpsDialect, fir::FIROpsDialect>();
-    // target.addDynamicallyLegalOp<M::FuncOp>([&](M::FuncOp op) {
+    mlir::populateAffineToStdConversionPatterns(patterns, context);
+    // mlir::populateFuncOpTypeConversionPattern(patterns, context,
+    // typeConverter);
+    mlir::ConversionTarget target{*context};
+    target.addLegalDialect<mlir::StandardOpsDialect, FIROpsDialect>();
+    // target.addDynamicallyLegalOp<mlir::FuncOp>([&](mlir::FuncOp op) {
     //  return typeConverter.isSignatureLegal(op.getType());
     //});
     target.addIllegalOp<SelectTypeOp>();
-    if (M::failed(M::applyPartialConversion(
+    if (mlir::failed(mlir::applyPartialConversion(
             // getModule(), target, std::move(patterns), &typeConverter))) {
             getModule(), target, std::move(patterns)))) {
-      M::emitError(M::UnknownLoc::get(context),
-                   "error in converting to standard dialect\n");
+      mlir::emitError(mlir::UnknownLoc::get(context),
+                      "error in converting to standard dialect\n");
       signalPassFailure();
     }
   }
 
-  M::ModuleOp getModule() {
-    return getFunction().getParentOfType<M::ModuleOp>();
+  mlir::ModuleOp getModule() {
+    return getFunction().getParentOfType<mlir::ModuleOp>();
   }
 
 private:
   KindMapping &kindMap;
 };
-
 } // namespace
 
-std::unique_ptr<M::Pass> fir::createFIRToStdPass(fir::KindMapping &kindMap) {
+std::unique_ptr<mlir::Pass> createFIRToStdPass(KindMapping &kindMap) {
   return std::make_unique<FIRToStdLoweringPass>(kindMap);
 }
+} // namespace fir
diff --git a/lib/optimizer/Transforms/CSE.cpp b/lib/optimizer/Transforms/CSE.cpp
index 1d3d2600f719..91a30971820a 100644
--- a/lib/optimizer/Transforms/CSE.cpp
+++ b/lib/optimizer/Transforms/CSE.cpp
@@ -1,4 +1,4 @@
-//===-- lib/optimizer/Transforms/CSE.cpp ------------------------*- C++ -*-===//
+//===-- CSE.cpp -- common subexpression elimination -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -44,6 +44,8 @@ static llvm::cl::opt<bool> ClDisableCSE("disable-cse",
 namespace {
 
 struct SimpleOperationInfo : public llvm::DenseMapInfo<Operation *> {
+
+  /// Compute the hash value of an Operation
   static unsigned getHashValue(const Operation *opC) {
     auto *op = const_cast<Operation *>(opC);
     // Hash the operations based upon their:
@@ -59,12 +61,13 @@ struct SimpleOperationInfo : public llvm::DenseMapInfo<Operation *> {
       llvm::sort(vec.begin(), vec.end());
       hashOps = llvm::hash_combine_range(vec.begin(), vec.end());
     } else {
-      hashOps = hash_combine_range(op->operand_begin(), op->operand_end());
+      hashOps =
+          llvm::hash_combine_range(op->operand_begin(), op->operand_end());
     }
-    return hash_combine(
-        op->getName(), op->getAttrs(),
-        hash_combine_range(op->result_type_begin(), op->result_type_end()),
-        hashOps);
+    auto hashResTys{llvm::hash_combine_range(op->result_type_begin(),
+                                             op->result_type_end())};
+    return llvm::hash_combine(op->getName(), op->getAttrs(), hashResTys,
+                              hashOps);
   }
 
   static bool isEqual(const Operation *lhsC, const Operation *rhsC) {
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
index a7b17714a834..e05956e79144 100644
--- a/lib/optimizer/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -1,4 +1,4 @@
-//===-- lib/optimizer/Transforms/MemToReg.cpp -------------------*- C++ -*-===//
+//===-- MemToReg.cpp -- convert mem to reg SSA form -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -18,17 +18,14 @@
 #include <utility>
 #include <vector>
 
-namespace L = llvm;
-namespace M = mlir;
-
 using namespace fir;
 
-using DominatorTree = M::DominanceInfo;
+using DominatorTree = mlir::DominanceInfo;
 
-static L::cl::opt<bool>
+static llvm::cl::opt<bool>
     ClDisableMemToReg("disable-mem2reg",
-                      L::cl::desc("disable memory to register pass"),
-                      L::cl::init(false), L::cl::Hidden);
+                      llvm::cl::desc("disable memory to register pass"),
+                      llvm::cl::init(false), llvm::cl::Hidden);
 
 /// A generalized version of a mem-to-reg pass suitable for use with an MLIR
 /// dialect. This code was ported from the LLVM project. MLIR differs with its
@@ -40,9 +37,9 @@ template <typename LOAD, typename STORE, typename ALLOCA>
 bool isAllocaPromotable(ALLOCA &ae) {
   for (auto &use : ae.getResult().getUses()) {
     auto *op = use.getOwner();
-    if (auto load = M::dyn_cast<LOAD>(op)) {
+    if (auto load = mlir::dyn_cast<LOAD>(op)) {
       // do nothing
-    } else if (auto stor = M::dyn_cast<STORE>(op)) {
+    } else if (auto stor = mlir::dyn_cast<STORE>(op)) {
       if (stor.getOperand(0).getDefiningOp() == op) {
         return false;
       }
@@ -55,11 +52,11 @@ bool isAllocaPromotable(ALLOCA &ae) {
 
 template <typename LOAD, typename STORE, typename ALLOCA>
 struct AllocaInfo {
-  L::SmallVector<M::Block *, 32> definingBlocks;
-  L::SmallVector<M::Block *, 32> usingBlocks;
+  llvm::SmallVector<mlir::Block *, 32> definingBlocks;
+  llvm::SmallVector<mlir::Block *, 32> usingBlocks;
 
-  M::Operation *onlyStore;
-  M::Block *onlyBlock;
+  mlir::Operation *onlyStore;
+  mlir::Block *onlyBlock;
   bool onlyUsedInOneBlock;
 
   void clear() {
@@ -83,12 +80,12 @@ struct AllocaInfo {
       auto *User = UI->getOwner();
       UI++;
 
-      if (auto SI = M::dyn_cast<STORE>(User)) {
+      if (auto SI = mlir::dyn_cast<STORE>(User)) {
         // Remember the basic blocks which define new values for the alloca
         definingBlocks.push_back(SI.getOperation()->getBlock());
         onlyStore = SI.getOperation();
       } else {
-        auto LI = M::cast<LOAD>(User);
+        auto LI = mlir::cast<LOAD>(User);
         // Otherwise it must be a load instruction, keep track of variable
         // reads.
         usingBlocks.push_back(LI.getOperation()->getBlock());
@@ -105,9 +102,9 @@ struct AllocaInfo {
 };
 
 struct RenamePassData {
-  using ValVector = std::vector<M::Value>;
+  using ValVector = std::vector<mlir::Value>;
 
-  RenamePassData(M::Block *b, M::Block *p, const ValVector &v)
+  RenamePassData(mlir::Block *b, mlir::Block *p, const ValVector &v)
       : BB(b), Pred(p), Values(v) {}
   RenamePassData(RenamePassData &&) = default;
   RenamePassData &operator=(RenamePassData &&) = delete;
@@ -115,23 +112,23 @@ struct RenamePassData {
   RenamePassData &operator=(const RenamePassData &) = delete;
   ~RenamePassData() = default;
 
-  M::Block *BB;
-  M::Block *Pred;
+  mlir::Block *BB;
+  mlir::Block *Pred;
   ValVector Values;
 };
 
 template <typename LOAD, typename STORE, typename ALLOCA>
 struct LargeBlockInfo {
-  using INMap = L::DenseMap<M::Operation *, unsigned>;
+  using INMap = llvm::DenseMap<mlir::Operation *, unsigned>;
   INMap instNumbers;
 
-  static bool isInterestingInstruction(M::Operation &I) {
-    if (M::isa<LOAD>(I)) {
+  static bool isInterestingInstruction(mlir::Operation &I) {
+    if (mlir::isa<LOAD>(I)) {
       if (auto op = I.getOperand(0).getDefiningOp())
-        return M::isa<ALLOCA>(op);
-    } else if (M::isa<STORE>(I)) {
+        return mlir::isa<ALLOCA>(op);
+    } else if (mlir::isa<STORE>(I)) {
       if (auto op = I.getOperand(1).getDefiningOp())
-        return M::isa<ALLOCA>(op);
+        return mlir::isa<ALLOCA>(op);
     }
     return false;
   }
@@ -167,31 +164,33 @@ struct LargeBlockInfo {
 };
 
 template <typename LOAD, typename STORE, typename ALLOCA, typename UNDEF>
-struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
+struct MemToReg
+    : public mlir::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
   explicit MemToReg() {}
 
   std::vector<ALLOCA> allocas;
   DominatorTree *domTree = nullptr;
-  M::OpBuilder *builder = nullptr;
+  mlir::OpBuilder *builder = nullptr;
 
   /// Contains a stable numbering of basic blocks to avoid non-determinstic
   /// behavior.
-  L::DenseMap<M::Block *, unsigned> BBNumbers;
+  llvm::DenseMap<mlir::Block *, unsigned> BBNumbers;
 
   /// Reverse mapping of Allocas.
-  L::DenseMap<M::Operation *, unsigned> allocaLookup;
+  llvm::DenseMap<mlir::Operation *, unsigned> allocaLookup;
 
   /// The set of basic blocks the renamer has already visited.
-  L::SmallPtrSet<M::Block *, 16> Visited;
+  llvm::SmallPtrSet<mlir::Block *, 16> Visited;
 
-  L::DenseMap<std::pair<M::Block *, M::Operation *>, unsigned> BlockArgs;
-  L::DenseMap<std::pair<M::Block *, unsigned>, unsigned> argToAllocaMap;
+  llvm::DenseMap<std::pair<mlir::Block *, mlir::Operation *>, unsigned>
+      BlockArgs;
+  llvm::DenseMap<std::pair<mlir::Block *, unsigned>, unsigned> argToAllocaMap;
 
   bool rewriteSingleStoreAlloca(ALLOCA &AI,
                                 AllocaInfo<LOAD, STORE, ALLOCA> &Info,
                                 LargeBlockInfo<LOAD, STORE, ALLOCA> &LBI) {
-    STORE onlyStore(M::cast<STORE>(Info.onlyStore));
-    M::Block *StoreBB = Info.onlyStore->getBlock();
+    STORE onlyStore(mlir::cast<STORE>(Info.onlyStore));
+    mlir::Block *StoreBB = Info.onlyStore->getBlock();
     int StoreIndex = -1;
 
     // Clear out usingBlocks.  We will reconstruct it here if needed.
@@ -202,10 +201,10 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       auto *UserInst = UI->getOwner();
       UI++;
 
-      if (M::dyn_cast<STORE>(UserInst))
+      if (mlir::dyn_cast<STORE>(UserInst))
         continue;
 
-      auto LI = M::cast<LOAD>(UserInst);
+      auto LI = mlir::cast<LOAD>(UserInst);
 
       // Okay, if we have a load from the alloca, we want to replace it with the
       // only value stored to the alloca.  We can do this if the value is
@@ -232,7 +231,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       }
 
       // Otherwise, we *can* safely rewrite this load.
-      M::Value replVal = onlyStore.getOperand(0);
+      mlir::Value replVal = onlyStore.getOperand(0);
       // If the replacement value is the load, this must occur in unreachable
       // code.
       if (replVal == LI.getResult())
@@ -259,24 +258,24 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
                                 LargeBlockInfo<LOAD, STORE, ALLOCA> &LBI) {
     // Walk the use-def list of the alloca, getting the locations of all stores.
     using StoresByIndexTy =
-        L::SmallVector<std::pair<unsigned, M::Operation *>, 64>;
+        llvm::SmallVector<std::pair<unsigned, mlir::Operation *>, 64>;
     StoresByIndexTy storesByIndex;
 
     for (auto U = AI.getResult().use_begin(), E = AI.getResult().use_end();
          U != E; U++)
-      if (STORE SI = M::dyn_cast<STORE>(U->getOwner()))
+      if (STORE SI = mlir::dyn_cast<STORE>(U->getOwner()))
         storesByIndex.emplace_back(LBI.getInstructionIndex(SI),
                                    SI.getOperation());
 
     // Sort the stores by their index, making it efficient to do a lookup with a
     // binary search.
-    L::sort(storesByIndex, L::less_first());
+    llvm::sort(storesByIndex, llvm::less_first());
 
     // Walk all of the loads from this alloca, replacing them with the nearest
     // store above them, if any.
     for (auto UI = AI.getResult().use_begin(), E = AI.getResult().use_end();
          UI != E;) {
-      auto LI = M::dyn_cast<LOAD>(UI->getOwner());
+      auto LI = mlir::dyn_cast<LOAD>(UI->getOwner());
       UI++;
       if (!LI)
         continue;
@@ -284,10 +283,10 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       unsigned LoadIdx = LBI.getInstructionIndex(LI);
 
       // Find the nearest store that has a lower index than this load.
-      typename StoresByIndexTy::iterator I = L::lower_bound(
+      typename StoresByIndexTy::iterator I = llvm::lower_bound(
           storesByIndex,
-          std::make_pair(LoadIdx, static_cast<M::Operation *>(nullptr)),
-          L::less_first());
+          std::make_pair(LoadIdx, static_cast<mlir::Operation *>(nullptr)),
+          llvm::less_first());
       if (I == storesByIndex.begin()) {
         if (storesByIndex.empty()) {
           // If there are no stores, the load takes the undef value.
@@ -302,7 +301,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         // Otherwise, there was a store before this load, the load takes its
         // value. Note, if the load was marked as nonnull we don't want to lose
         // that information when we erase it. So we preserve it with an assume.
-        M::Value replVal = std::prev(I)->second->getOperand(0);
+        mlir::Value replVal = std::prev(I)->second->getOperand(0);
 
         // If the replacement value is the load, this must occur in unreachable
         // code.
@@ -320,7 +319,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     while (!AI.use_empty()) {
       auto ae = AI.getResult();
       for (auto ai = ae.user_begin(), E = ae.user_end(); ai != E; ai++)
-        if (STORE si = M::dyn_cast<STORE>(*ai)) {
+        if (STORE si = mlir::dyn_cast<STORE>(*ai)) {
           si.erase();
           LBI.deleteValue(si);
         }
@@ -330,29 +329,30 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     return true;
   }
 
-  void computeLiveInBlocks(ALLOCA &ae, AllocaInfo<LOAD, STORE, ALLOCA> &Info,
-                           const L::SmallPtrSetImpl<M::Block *> &DefBlocks,
-                           L::SmallPtrSetImpl<M::Block *> &liveInBlks) {
+  void
+  computeLiveInBlocks(ALLOCA &ae, AllocaInfo<LOAD, STORE, ALLOCA> &Info,
+                      const llvm::SmallPtrSetImpl<mlir::Block *> &DefBlocks,
+                      llvm::SmallPtrSetImpl<mlir::Block *> &liveInBlks) {
     auto *AI = ae.getOperation();
     // To determine liveness, we must iterate through the predecessors of blocks
     // where the def is live.  Blocks are added to the worklist if we need to
     // check their predecessors.  Start with all the using blocks.
-    L::SmallVector<M::Block *, 64> LiveInBlockWorklist(Info.usingBlocks.begin(),
-                                                       Info.usingBlocks.end());
+    llvm::SmallVector<mlir::Block *, 64> LiveInBlockWorklist(
+        Info.usingBlocks.begin(), Info.usingBlocks.end());
 
     // If any of the using blocks is also a definition block, check to see if
     // the definition occurs before or after the use.  If it happens before the
     // use, the value isn't really live-in.
     for (unsigned i = 0, e = LiveInBlockWorklist.size(); i != e; ++i) {
-      M::Block *BB = LiveInBlockWorklist[i];
+      mlir::Block *BB = LiveInBlockWorklist[i];
       if (!DefBlocks.count(BB))
         continue;
 
       // Okay, this is a block that both uses and defines the value.  If the
       // first reference to the alloca is a def (store), then we know it isn't
       // live-in.
-      for (M::Block::iterator I = BB->begin();; ++I) {
-        if (STORE SI = M::dyn_cast<STORE>(I)) {
+      for (mlir::Block::iterator I = BB->begin();; ++I) {
+        if (STORE SI = mlir::dyn_cast<STORE>(I)) {
           if (SI.getOperand(1).getDefiningOp() != AI)
             continue;
 
@@ -365,7 +365,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
           break;
         }
 
-        if (auto LI = M::dyn_cast<LOAD>(I))
+        if (auto LI = mlir::dyn_cast<LOAD>(I))
           // Okay, we found a load before a store to the alloca.  It is actually
           // live into this block.
           if (LI.getOperand().getDefiningOp() == AI)
@@ -376,7 +376,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     // Now that we have a set of blocks where the phi is live-in, recursively
     // add their predecessors until we find the full region the value is live.
     while (!LiveInBlockWorklist.empty()) {
-      M::Block *BB = LiveInBlockWorklist.pop_back_val();
+      mlir::Block *BB = LiveInBlockWorklist.pop_back_val();
 
       // The block really is live in here, insert it into the set.  If already
       // in the set, then it has already been processed.
@@ -386,7 +386,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       // Since the value is live into BB, it is either defined in a predecessor
       // or live into it to.  Add the preds to the worklist unless they are a
       // defining block.
-      for (M::Block *P : BB->getPredecessors()) {
+      for (mlir::Block *P : BB->getPredecessors()) {
         // The value is not live into a predecessor if it defines the value.
         if (DefBlocks.count(P))
           continue;
@@ -397,7 +397,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     }
   }
 
-  bool addBlockArgument(M::Block *BB, ALLOCA &Alloca, unsigned allocaNum) {
+  bool addBlockArgument(mlir::Block *BB, ALLOCA &Alloca, unsigned allocaNum) {
     auto *ae = Alloca.getOperation();
     auto key = std::make_pair(BB, ae);
     auto argNoIter = BlockArgs.find(key);
@@ -411,9 +411,9 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
   }
 
   template <typename A>
-  void initOperands(std::vector<M::Value> &opers, M::Location &&loc,
-                    M::Block *dest, unsigned size, unsigned ai, M::Value val,
-                    A &&oldOpers) {
+  void initOperands(std::vector<mlir::Value> &opers, mlir::Location &&loc,
+                    mlir::Block *dest, unsigned size, unsigned ai,
+                    mlir::Value val, A &&oldOpers) {
     unsigned i = 0;
     for (auto v : oldOpers)
       opers[i++] = v;
@@ -429,45 +429,45 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     opers[ai] = val;
   }
 
-  static void eraseIfNoUse(M::Value val) {
+  static void eraseIfNoUse(mlir::Value val) {
     if (val.use_begin() == val.use_end()) {
       val.getDefiningOp()->erase();
     }
   }
 
   /// Set the incoming value on the branch side for the `ai`th block argument
-  void setParam(M::Block *blk, unsigned ai, M::Value val, M::Block *target,
-                unsigned size) {
+  void setParam(mlir::Block *blk, unsigned ai, mlir::Value val,
+                mlir::Block *target, unsigned size) {
     auto *term = blk->getTerminator();
-    if (auto br = M::dyn_cast<M::BranchOp>(term)) {
+    if (auto br = mlir::dyn_cast<mlir::BranchOp>(term)) {
       if (br.getNumOperands() <= ai) {
         // construct a new BranchOp to replace term
-        std::vector<M::Value> opers(size);
+        std::vector<mlir::Value> opers(size);
         auto *dest = br.getDest();
         builder->setInsertionPoint(term);
         initOperands(opers, br.getLoc(), dest, size, ai, val, br.getOperands());
-        builder->create<M::BranchOp>(br.getLoc(), dest, opers);
+        builder->create<mlir::BranchOp>(br.getLoc(), dest, opers);
         br.erase();
       } else {
         auto oldParam = br.getOperand(ai);
         br.setOperand(ai, val);
         eraseIfNoUse(oldParam);
       }
-    } else if (auto cond = M::dyn_cast<M::CondBranchOp>(term)) {
+    } else if (auto cond = mlir::dyn_cast<mlir::CondBranchOp>(term)) {
       if (target == cond.getTrueDest()) {
         if (cond.getNumTrueOperands() <= ai) {
           // construct a new CondBranchOp to replace term
-          std::vector<M::Value> opers(size);
+          std::vector<mlir::Value> opers(size);
           auto *dest = cond.getTrueDest();
           builder->setInsertionPoint(term);
           initOperands(opers, cond.getLoc(), dest, size, ai, val,
                        cond.getTrueOperands());
           auto c = cond.getCondition();
           auto *othDest = cond.getFalseDest();
-          std::vector<M::Value> othOpers(cond.false_operand_begin(),
-                                         cond.false_operand_end());
-          builder->create<M::CondBranchOp>(cond.getLoc(), c, dest, opers,
-                                           othDest, othOpers);
+          std::vector<mlir::Value> othOpers(cond.false_operand_begin(),
+                                            cond.false_operand_end());
+          builder->create<mlir::CondBranchOp>(cond.getLoc(), c, dest, opers,
+                                              othDest, othOpers);
           cond.erase();
         } else {
           auto oldParam = cond.getTrueOperand(ai);
@@ -477,17 +477,17 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       } else {
         if (cond.getNumFalseOperands() <= ai) {
           // construct a new CondBranchOp to replace term
-          std::vector<M::Value> opers(size);
+          std::vector<mlir::Value> opers(size);
           auto *dest = cond.getFalseDest();
           builder->setInsertionPoint(term);
           initOperands(opers, cond.getLoc(), dest, size, ai, val,
                        cond.getFalseOperands());
           auto c = cond.getCondition();
           auto *othDest = cond.getTrueDest();
-          std::vector<M::Value> othOpers(cond.true_operand_begin(),
-                                         cond.true_operand_end());
-          builder->create<M::CondBranchOp>(cond.getLoc(), c, othDest, othOpers,
-                                           dest, opers);
+          std::vector<mlir::Value> othOpers(cond.true_operand_begin(),
+                                            cond.true_operand_end());
+          builder->create<mlir::CondBranchOp>(cond.getLoc(), c, othDest,
+                                              othOpers, dest, opers);
           cond.erase();
         } else {
           auto oldParam = cond.getFalseOperand(ai);
@@ -502,7 +502,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
   inline static void addValue(RenamePassData::ValVector &vector,
                               RenamePassData::ValVector::size_type size,
-                              M::Value value) {
+                              mlir::Value value) {
     if (vector.size() < size + 1)
       vector.resize(size + 1);
     vector[size] = value;
@@ -513,7 +513,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
   ///
   /// IncomingVals indicates what value each Alloca contains on exit from the
   /// predecessor block Pred.
-  void renamePass(M::Block *BB, M::Block *Pred,
+  void renamePass(mlir::Block *BB, mlir::Block *Pred,
                   RenamePassData::ValVector &IncomingVals,
                   std::vector<RenamePassData> &Worklist) {
   NextIteration:
@@ -533,22 +533,22 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     if (!Visited.insert(BB).second)
       return;
 
-    M::Block::iterator II = BB->begin();
+    mlir::Block::iterator II = BB->begin();
     while (true) {
       if (II == BB->end())
         break;
-      M::Operation &opn = *II;
+      mlir::Operation &opn = *II;
       II++;
 
-      if (auto LI = M::dyn_cast<LOAD>(opn)) {
+      if (auto LI = mlir::dyn_cast<LOAD>(opn)) {
         auto *srcOpn = LI.getOperand().getDefiningOp();
         if (!srcOpn)
           continue;
 
-        if (!M::dyn_cast<ALLOCA>(srcOpn))
+        if (!mlir::dyn_cast<ALLOCA>(srcOpn))
           continue;
 
-        L::DenseMap<M::Operation *, unsigned>::iterator ai =
+        llvm::DenseMap<mlir::Operation *, unsigned>::iterator ai =
             allocaLookup.find(srcOpn);
         if (ai == allocaLookup.end())
           continue;
@@ -556,15 +556,15 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
         // Anything using the load now uses the current value.
         LI.replaceAllUsesWith(IncomingVals[ai->second]);
         LI.erase();
-      } else if (auto SI = M::dyn_cast<STORE>(opn)) {
+      } else if (auto SI = mlir::dyn_cast<STORE>(opn)) {
         auto *dstOpn = SI.getOperand(1).getDefiningOp();
         if (!dstOpn)
           continue;
 
-        if (!M::dyn_cast<ALLOCA>(dstOpn))
+        if (!mlir::dyn_cast<ALLOCA>(dstOpn))
           continue;
 
-        L::DenseMap<M::Operation *, unsigned>::iterator ai =
+        llvm::DenseMap<mlir::Operation *, unsigned>::iterator ai =
             allocaLookup.find(dstOpn);
         if (ai == allocaLookup.end())
           continue;
@@ -584,7 +584,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       return;
 
     // Keep track of the successors so we don't visit the same successor twice
-    L::SmallPtrSet<M::Block *, 8> VisitedSuccs;
+    llvm::SmallPtrSet<mlir::Block *, 8> VisitedSuccs;
 
     // Handle the first successor without using the worklist.
     VisitedSuccs.insert(*I);
@@ -610,7 +610,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
     for (unsigned allocaNum = 0, End = allocas.size(); allocaNum != End;
          ++allocaNum) {
       auto ae = allocas[allocaNum];
-      assert(ae.template getParentOfType<M::FuncOp>() == F);
+      assert(ae.template getParentOfType<mlir::FuncOp>() == F);
       if (ae.use_empty()) {
         ae.erase();
         continue;
@@ -641,12 +641,12 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       // insertion of dead phi nodes.
 
       // Unique the set of defining blocks for efficient lookup.
-      L::SmallPtrSet<M::Block *, 32> defBlocks(info.definingBlocks.begin(),
-                                               info.definingBlocks.end());
+      llvm::SmallPtrSet<mlir::Block *, 32> defBlocks(
+          info.definingBlocks.begin(), info.definingBlocks.end());
 
       // Determine which blocks the value is live in.  These are blocks which
       // lead to uses.
-      L::SmallPtrSet<M::Block *, 32> liveInBlks;
+      llvm::SmallPtrSet<mlir::Block *, 32> liveInBlks;
       computeLiveInBlocks(ae, info, defBlocks, liveInBlks);
 
       // At this point, we're committed to promoting the alloca using IDF's,
@@ -655,13 +655,13 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       // insertion of dead phi nodes.
       IDF.setLiveInBlocks(liveInBlks);
       IDF.setDefiningBlocks(defBlocks);
-      L::SmallVector<M::Block *, 32> phiBlocks;
+      llvm::SmallVector<mlir::Block *, 32> phiBlocks;
       IDF.calculate(phiBlocks);
-      L::sort(phiBlocks, [this](M::Block *A, M::Block *B) {
+      llvm::sort(phiBlocks, [this](mlir::Block *A, mlir::Block *B) {
         return BBNumbers.find(A)->second < BBNumbers.find(B)->second;
       });
 
-      for (M::Block *BB : phiBlocks)
+      for (mlir::Block *BB : phiBlocks)
         addBlockArgument(BB, ae, allocaNum);
 
       aes.push_back(ae);
@@ -698,7 +698,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
     // Remove the allocas themselves from the function.
     for (auto aa : allocas) {
-      M::Operation *A = aa.getOperation();
+      mlir::Operation *A = aa.getOperation();
       // If there are any uses of the alloca instructions left, they must be
       // in unreachable basic blocks that were not processed by walking the
       // dominator tree. Just delete the users now.
@@ -717,7 +717,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
     auto f = this->getFunction();
     auto &entry = f.front();
-    auto bldr = M::OpBuilder(f.getBody());
+    auto bldr = mlir::OpBuilder(f.getBody());
 
     domTree = &this->template getAnalysis<DominatorTree>();
     builder = &bldr;
@@ -726,7 +726,7 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
       allocas.clear();
 
       for (auto &op : entry)
-        if (ALLOCA ae = M::dyn_cast<ALLOCA>(op))
+        if (ALLOCA ae = mlir::dyn_cast<ALLOCA>(op))
           if (isAllocaPromotable<LOAD, STORE>(ae))
             allocas.push_back(ae);
 
@@ -743,6 +743,6 @@ struct MemToReg : public M::FunctionPass<MemToReg<LOAD, STORE, ALLOCA, UNDEF>> {
 
 } // namespace
 
-std::unique_ptr<M::OpPassBase<M::FuncOp>> fir::createMemToRegPass() {
+std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> fir::createMemToRegPass() {
   return std::make_unique<MemToReg<LoadOp, StoreOp, AllocaOp, UndefOp>>();
 }
diff --git a/lib/optimizer/Transforms/RewriteLoop.cpp b/lib/optimizer/Transforms/RewriteLoop.cpp
index 80b4fb67620f..f7943bbd61d7 100644
--- a/lib/optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/optimizer/Transforms/RewriteLoop.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/Transforms/RewriteLoop.cpp ----------------------*- C++ -*-===//
+//===-- RewriteLoop.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -17,8 +17,6 @@
 #include "llvm/Support/CommandLine.h"
 #include <memory>
 
-namespace M = mlir;
-
 /// disable FIR to affine dialect conversion
 static llvm::cl::opt<bool>
     ClDisableAffinePromo("disable-affine-promotion",
@@ -31,14 +29,13 @@ static llvm::cl::opt<bool>
                             llvm::cl::desc("disable FIR to Loop pass"),
                             llvm::cl::init(false));
 
-using namespace fir;
-
+namespace fir {
 namespace {
 
 template <typename FROM>
-class OpRewrite : public M::RewritePattern {
+class OpRewrite : public mlir::RewritePattern {
 public:
-  explicit OpRewrite(M::MLIRContext *ctx)
+  explicit OpRewrite(mlir::MLIRContext *ctx)
       : RewritePattern(FROM::getOperationName(), 1, ctx) {}
 };
 
@@ -56,25 +53,27 @@ class AffineWhereConv : public OpRewrite<WhereOp> {
 
 /// Promote fir.loop and fir.where to affine.for and affine.if, in the cases
 /// where such a promotion is possible.
-class AffineDialectPromotion : public M::FunctionPass<AffineDialectPromotion> {
+class AffineDialectPromotion
+    : public mlir::FunctionPass<AffineDialectPromotion> {
 public:
   void runOnFunction() override {
     if (ClDisableAffinePromo)
       return;
 
     auto *context{&getContext()};
-    M::OwningRewritePatternList patterns;
+    mlir::OwningRewritePatternList patterns;
     patterns.insert<AffineLoopConv, AffineWhereConv>(context);
-    M::ConversionTarget target{*context};
-    target.addLegalDialect<M::AffineOpsDialect, FIROpsDialect,
-                           M::loop::LoopOpsDialect, M::StandardOpsDialect>();
+    mlir::ConversionTarget target{*context};
+    target.addLegalDialect<mlir::AffineOpsDialect, FIROpsDialect,
+                           mlir::loop::LoopOpsDialect,
+                           mlir::StandardOpsDialect>();
     // target.addDynamicallyLegalOp<LoopOp, WhereOp>();
 
     // apply the patterns
-    if (M::failed(M::applyPartialConversion(getFunction(), target,
-                                            std::move(patterns)))) {
-      M::emitError(M::UnknownLoc::get(context),
-                   "error in converting to affine dialect\n");
+    if (mlir::failed(mlir::applyPartialConversion(getFunction(), target,
+                                                  std::move(patterns)))) {
+      mlir::emitError(mlir::UnknownLoc::get(context),
+                      "error in converting to affine dialect\n");
       signalPassFailure();
     }
   }
@@ -87,25 +86,25 @@ class AffineDialectPromotion : public M::FunctionPass<AffineDialectPromotion> {
 // includes a pass to lower `loop.for` operations to a CFG.
 
 /// Convert `fir.loop` to `loop.for`
-class LoopLoopConv : public M::OpRewritePattern<LoopOp> {
+class LoopLoopConv : public mlir::OpRewritePattern<LoopOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
-  M::PatternMatchResult
-  matchAndRewrite(LoopOp loop, M::PatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(LoopOp loop, mlir::PatternRewriter &rewriter) const override {
     auto low = loop.lowerBound();
     auto high = loop.upperBound();
     auto optStep = loop.optstep();
     auto loc = loop.getLoc();
-    M::Value step;
+    mlir::Value step;
     if (optStep.begin() != optStep.end()) {
       step = *optStep.begin();
     } else {
       auto conStep = loop.constep();
-      step = rewriter.create<M::ConstantIndexOp>(
+      step = rewriter.create<mlir::ConstantIndexOp>(
           loc, conStep.hasValue() ? conStep.getValue().getSExtValue() : 1);
     }
-    auto f = rewriter.create<M::loop::ForOp>(loc, low, high, step);
+    auto f = rewriter.create<mlir::loop::ForOp>(loc, low, high, step);
     f.region().getBlocks().clear();
     rewriter.inlineRegionBefore(loop.region(), f.region(), f.region().end());
     rewriter.eraseOp(loop);
@@ -114,16 +113,17 @@ class LoopLoopConv : public M::OpRewritePattern<LoopOp> {
 };
 
 /// Convert `fir.where` to `loop.if`
-class LoopWhereConv : public M::OpRewritePattern<WhereOp> {
+class LoopWhereConv : public mlir::OpRewritePattern<WhereOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
-  M::PatternMatchResult
-  matchAndRewrite(WhereOp where, M::PatternRewriter &rewriter) const override {
+  mlir::PatternMatchResult
+  matchAndRewrite(WhereOp where,
+                  mlir::PatternRewriter &rewriter) const override {
     auto loc = where.getLoc();
     bool hasOtherRegion = !where.otherRegion().empty();
     auto cond = where.condition();
-    auto ifOp = rewriter.create<M::loop::IfOp>(loc, cond, hasOtherRegion);
+    auto ifOp = rewriter.create<mlir::loop::IfOp>(loc, cond, hasOtherRegion);
     rewriter.inlineRegionBefore(where.whereRegion(), &ifOp.thenRegion().back());
     ifOp.thenRegion().back().erase();
     if (hasOtherRegion) {
@@ -137,52 +137,53 @@ class LoopWhereConv : public M::OpRewritePattern<WhereOp> {
 };
 
 /// Replace FirEndOp with TerminatorOp
-class LoopFirEndConv : public M::OpRewritePattern<FirEndOp> {
+class LoopFirEndConv : public mlir::OpRewritePattern<FirEndOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
-  M::PatternMatchResult
-  matchAndRewrite(FirEndOp op, M::PatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<M::loop::TerminatorOp>(op);
+  mlir::PatternMatchResult
+  matchAndRewrite(FirEndOp op, mlir::PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<mlir::loop::TerminatorOp>(op);
     return matchSuccess();
   }
 };
 
 /// Convert `fir.loop` and `fir.where` to `loop.for` and `loop.if`.
-class LoopDialectConversion : public M::FunctionPass<LoopDialectConversion> {
+class LoopDialectConversion : public mlir::FunctionPass<LoopDialectConversion> {
 public:
   void runOnFunction() override {
     if (ClDisableLoopConversion)
       return;
 
     auto *context{&getContext()};
-    M::OwningRewritePatternList patterns;
+    mlir::OwningRewritePatternList patterns;
     patterns.insert<LoopLoopConv, LoopWhereConv, LoopFirEndConv>(context);
-    M::ConversionTarget target{*context};
-    target.addLegalDialect<M::AffineOpsDialect, FIROpsDialect,
-                           M::loop::LoopOpsDialect, M::StandardOpsDialect>();
+    mlir::ConversionTarget target{*context};
+    target.addLegalDialect<mlir::AffineOpsDialect, FIROpsDialect,
+                           mlir::loop::LoopOpsDialect,
+                           mlir::StandardOpsDialect>();
     target.addIllegalOp<FirEndOp, LoopOp, WhereOp>();
 
     // apply the patterns
-    if (M::failed(M::applyPartialConversion(getFunction(), target,
-                                            std::move(patterns)))) {
-      M::emitError(M::UnknownLoc::get(context),
-                   "error in converting to MLIR loop dialect\n");
+    if (mlir::failed(mlir::applyPartialConversion(getFunction(), target,
+                                                  std::move(patterns)))) {
+      mlir::emitError(mlir::UnknownLoc::get(context),
+                      "error in converting to MLIR loop dialect\n");
       signalPassFailure();
     }
   }
 };
-
 } // namespace
 
 /// Convert FIR loop constructs to the Affine dialect
-std::unique_ptr<M::Pass> fir::createPromoteToAffinePass() {
+std::unique_ptr<mlir::Pass> createPromoteToAffinePass() {
   return std::make_unique<AffineDialectPromotion>();
 }
 
 /// Convert `fir.loop` and `fir.where` to `loop.for` and `loop.if`.  This
 /// conversion enables the `createLowerToCFGPass` to transform these to CFG
 /// form.
-std::unique_ptr<M::Pass> fir::createLowerToLoopPass() {
+std::unique_ptr<mlir::Pass> createLowerToLoopPass() {
   return std::make_unique<LoopDialectConversion>();
 }
+} // namespace fir

From ab242b9dbb17d703b7fd29039f6b27026a14c657 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 29 Jan 2020 06:25:40 -0800
Subject: [PATCH 179/345] Address PR959 review comments

- change Evaluation ctor argument order to match member order
- db -> bd for BlockData argument name
- Use dump-parse-tree.h for the AST pretty printer.
---
 include/flang/lower/ASTBuilder.h |   6 +-
 lib/lower/ASTBuilder.cpp         | 129 +++++--------------------------
 2 files changed, 23 insertions(+), 112 deletions(-)

diff --git a/include/flang/lower/ASTBuilder.h b/include/flang/lower/ASTBuilder.h
index d99d57daf8f6..b0aeb211fe78 100644
--- a/include/flang/lower/ASTBuilder.h
+++ b/include/flang/lower/ASTBuilder.h
@@ -126,8 +126,8 @@ struct Evaluation {
 
   /// General ctor
   template <typename A>
-  Evaluation(const A &a, const parser::CharBlock &pos,
-             const std::optional<parser::Label> &lab, const ParentType &p)
+  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &pos,
+             const std::optional<parser::Label> &lab)
       : u{&a}, parent{p}, pos{pos}, lab{lab} {}
 
   /// Compiler-generated jump
@@ -300,7 +300,7 @@ struct ModuleLikeUnit : public ProgramUnit {
 
 // TODO: lower data too
 struct BlockDataUnit : public ProgramUnit {
-  BlockDataUnit(const parser::BlockData &db, const ParentType &parent);
+  BlockDataUnit(const parser::BlockData &bd, const ParentType &parent);
 };
 
 /// A Program is the top-level AST
diff --git a/lib/lower/ASTBuilder.cpp b/lib/lower/ASTBuilder.cpp
index ead8243ccedd..e187f483a8fa 100644
--- a/lib/lower/ASTBuilder.cpp
+++ b/lib/lower/ASTBuilder.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/ASTBuilder.h"
+#include "flang/parser/dump-parse-tree.h"
 #include "flang/parser/parse-tree-visitor.h"
 #include <cassert>
 #include <utility>
@@ -195,14 +196,14 @@ class ASTBuilder {
   void Post(const Pa::UnlabeledStatement<Pa::ForallAssignmentStmt> &s) {
     addEval(std::visit(
         [&](const auto &x) {
-          return AST::Evaluation{x, s.source, {}, parents.back()};
+          return AST::Evaluation{x, parents.back(), s.source, {}};
         },
         s.statement.u));
   }
   void Post(const Pa::Statement<Pa::ForallAssignmentStmt> &s) {
     addEval(std::visit(
         [&](const auto &x) {
-          return AST::Evaluation{x, s.source, s.label, parents.back()};
+          return AST::Evaluation{x, parents.back(), s.source, s.label};
         },
         s.statement.u));
   }
@@ -249,14 +250,14 @@ class ASTBuilder {
     return std::visit(
         Co::visitors{
             [&](const Pa::ContinueStmt &x) {
-              return AST::Evaluation{x, s.source, s.label, parents.back()};
+              return AST::Evaluation{x, parents.back(), s.source, s.label};
             },
             [&](const Pa::FailImageStmt &x) {
-              return AST::Evaluation{x, s.source, s.label, parents.back()};
+              return AST::Evaluation{x, parents.back(), s.source, s.label};
             },
             [&](const auto &x) {
-              return AST::Evaluation{x.value(), s.source, s.label,
-                                     parents.back()};
+              return AST::Evaluation{x.value(), parents.back(), s.source,
+                                     s.label};
             },
         },
         s.statement.u);
@@ -266,13 +267,13 @@ class ASTBuilder {
     return std::visit(
         Co::visitors{
             [&](const Pa::ContinueStmt &x) {
-              return AST::Evaluation{x, s.source, {}, parents.back()};
+              return AST::Evaluation{x, parents.back(), s.source, {}};
             },
             [&](const Pa::FailImageStmt &x) {
-              return AST::Evaluation{x, s.source, {}, parents.back()};
+              return AST::Evaluation{x, parents.back(), s.source, {}};
             },
             [&](const auto &x) {
-              return AST::Evaluation{x.value(), s.source, {}, parents.back()};
+              return AST::Evaluation{x.value(), parents.back(), s.source, {}};
             },
         },
         s.statement.u);
@@ -280,13 +281,13 @@ class ASTBuilder {
 
   template <typename A>
   AST::Evaluation makeEvalIndirect(const Pa::Statement<Co::Indirection<A>> &s) {
-    return AST::Evaluation{s.statement.value(), s.source, s.label,
-                           parents.back()};
+    return AST::Evaluation{s.statement.value(), parents.back(), s.source,
+                           s.label};
   }
 
   template <typename A>
   AST::Evaluation makeEvalDirect(const Pa::Statement<A> &s) {
-    return AST::Evaluation{s.statement, s.source, s.label, parents.back()};
+    return AST::Evaluation{s.statement, parents.back(), s.source, s.label};
   }
 
   // When we enter a function-like structure, we want to build a new unit and
@@ -613,101 +614,11 @@ inline void annotateFuncCFG(AST::FunctionLikeUnit &flu) {
 
 L::StringRef evalName(AST::Evaluation &e) {
   return std::visit(
-      Co::visitors{
-          [](const Pa::AllocateStmt *) { return "AllocateStmt"; },
-          [](const Pa::ArithmeticIfStmt *) { return "ArithmeticIfStmt"; },
-          [](const Pa::AssignedGotoStmt *) { return "AssignedGotoStmt"; },
-          [](const Pa::AssignmentStmt *) { return "AssignmentStmt"; },
-          [](const Pa::AssignStmt *) { return "AssignStmt"; },
-          [](const Pa::BackspaceStmt *) { return "BackspaceStmt"; },
-          [](const Pa::CallStmt *) { return "CallStmt"; },
-          [](const Pa::CloseStmt *) { return "CloseStmt"; },
-          [](const Pa::ComputedGotoStmt *) { return "ComputedGotoStmt"; },
-          [](const Pa::ContinueStmt *) { return "ContinueStmt"; },
-          [](const Pa::CycleStmt *) { return "CycleStmt"; },
-          [](const Pa::DeallocateStmt *) { return "DeallocateStmt"; },
-          [](const Pa::EndfileStmt *) { return "EndfileStmt"; },
-          [](const Pa::EventPostStmt *) { return "EventPostStmt"; },
-          [](const Pa::EventWaitStmt *) { return "EventWaitStmt"; },
-          [](const Pa::ExitStmt *) { return "ExitStmt"; },
-          [](const Pa::FailImageStmt *) { return "FailImageStmt"; },
-          [](const Pa::FlushStmt *) { return "FlushStmt"; },
-          [](const Pa::ForallStmt *) { return "ForallStmt"; },
-          [](const Pa::FormTeamStmt *) { return "FormTeamStmt"; },
-          [](const Pa::GotoStmt *) { return "GotoStmt"; },
-          [](const Pa::IfStmt *) { return "IfStmt"; },
-          [](const Pa::InquireStmt *) { return "InquireStmt"; },
-          [](const Pa::LockStmt *) { return "LockStmt"; },
-          [](const Pa::NullifyStmt *) { return "NullifyStmt"; },
-          [](const Pa::OpenStmt *) { return "OpenStmt"; },
-          [](const Pa::PauseStmt *) { return "PauseStmt"; },
-          [](const Pa::PointerAssignmentStmt *) {
-            return "PointerAssignmentStmt";
-          },
-          [](const Pa::PrintStmt *) { return "PrintStmt"; },
-          [](const Pa::ReadStmt *) { return "ReadStmt"; },
-          [](const Pa::ReturnStmt *) { return "ReturnStmt"; },
-          [](const Pa::RewindStmt *) { return "RewindStmt"; },
-          [](const Pa::StopStmt *) { return "StopStmt"; },
-          [](const Pa::SyncAllStmt *) { return "SyncAllStmt"; },
-          [](const Pa::SyncImagesStmt *) { return "SyncImagesStmt"; },
-          [](const Pa::SyncMemoryStmt *) { return "SyncMemoryStmt"; },
-          [](const Pa::SyncTeamStmt *) { return "SyncTeamStmt"; },
-          [](const Pa::UnlockStmt *) { return "UnlockStmt"; },
-          [](const Pa::WaitStmt *) { return "WaitStmt"; },
-          [](const Pa::WhereStmt *) { return "WhereStmt"; },
-          [](const Pa::WriteStmt *) { return "WriteStmt"; },
-
-          [](const AST::CGJump) { return "CGJump"; },
-
-          [](const Pa::DataStmt *) { return "DataStmt"; },
-          [](const Pa::EntryStmt *) { return "EntryStmt"; },
-          [](const Pa::FormatStmt *) { return "FormatStmt"; },
-          [](const Pa::NamelistStmt *) { return "NamelistStmt"; },
-
-          [](const Pa::AssociateConstruct *) { return "AssociateConstruct"; },
-          [](const Pa::BlockConstruct *) { return "BlockConstruct"; },
-          [](const Pa::CaseConstruct *) { return "CaseConstruct"; },
-          [](const Pa::ChangeTeamConstruct *) { return "ChangeTeamConstruct"; },
-          [](const Pa::CompilerDirective *) { return "CompilerDirective"; },
-          [](const Pa::CriticalConstruct *) { return "CriticalConstruct"; },
-          [](const Pa::DoConstruct *) { return "DoConstruct"; },
-          [](const Pa::ForallConstruct *) { return "ForallConstruct"; },
-          [](const Pa::IfConstruct *) { return "IfConstruct"; },
-          [](const Pa::OmpEndLoopDirective *) { return "OmpEndLoopDirective"; },
-          [](const Pa::OpenMPConstruct *) { return "OpenMPConstruct"; },
-          [](const Pa::SelectRankConstruct *) { return "SelectRankConstruct"; },
-          [](const Pa::SelectTypeConstruct *) { return "SelectTypeConstruct"; },
-          [](const Pa::WhereConstruct *) { return "WhereConstruct"; },
-
-          [](const Pa::AssociateStmt *) { return "AssociateStmt"; },
-          [](const Pa::BlockStmt *) { return "BlockStmt"; },
-          [](const Pa::CaseStmt *) { return "CaseStmt"; },
-          [](const Pa::ChangeTeamStmt *) { return "ChangeTeamStmt"; },
-          [](const Pa::CriticalStmt *) { return "CriticalStmt"; },
-          [](const Pa::ElseIfStmt *) { return "ElseIfStmt"; },
-          [](const Pa::ElseStmt *) { return "ElseStmt"; },
-          [](const Pa::ElsewhereStmt *) { return "ElsewhereStmt"; },
-          [](const Pa::EndAssociateStmt *) { return "EndAssociateStmt"; },
-          [](const Pa::EndBlockStmt *) { return "EndBlockStmt"; },
-          [](const Pa::EndChangeTeamStmt *) { return "EndChangeTeamStmt"; },
-          [](const Pa::EndCriticalStmt *) { return "EndCriticalStmt"; },
-          [](const Pa::EndDoStmt *) { return "EndDoStmt"; },
-          [](const Pa::EndForallStmt *) { return "EndForallStmt"; },
-          [](const Pa::EndIfStmt *) { return "EndIfStmt"; },
-          [](const Pa::EndSelectStmt *) { return "EndSelectStmt"; },
-          [](const Pa::EndWhereStmt *) { return "EndWhereStmt"; },
-          [](const Pa::ForallConstructStmt *) { return "ForallConstructStmt"; },
-          [](const Pa::IfThenStmt *) { return "IfThenStmt"; },
-          [](const Pa::MaskedElsewhereStmt *) { return "MaskedElsewhereStmt"; },
-          [](const Pa::NonLabelDoStmt *) { return "NonLabelDoStmt"; },
-          [](const Pa::SelectCaseStmt *) { return "SelectCaseStmt"; },
-          [](const Pa::SelectRankCaseStmt *) { return "SelectRankCaseStmt"; },
-          [](const Pa::SelectRankStmt *) { return "SelectRankStmt"; },
-          [](const Pa::SelectTypeStmt *) { return "SelectTypeStmt"; },
-          [](const Pa::TypeGuardStmt *) { return "TypeGuardStmt"; },
-          [](const Pa::WhereConstructStmt *) { return "WhereConstructStmt"; },
-      },
+      Co::visitors{[](const AST::CGJump) { return "CGJump"; },
+                   [](const auto *parseTreeNode) {
+                     assert(parseTreeNode && "nullptr node in AST ");
+                     return Pa::ParseTreeDumper::GetNodeName(*parseTreeNode);
+                   }},
       e.u);
 }
 
@@ -819,9 +730,9 @@ Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Submodule &m,
   modStmts.push_back(&std::get<Pa::Statement<Pa::EndSubmoduleStmt>>(m.t));
 }
 
-Br::AST::BlockDataUnit::BlockDataUnit(const Pa::BlockData &db,
+Br::AST::BlockDataUnit::BlockDataUnit(const Pa::BlockData &bd,
                                       const AST::ParentType &parent)
-    : ProgramUnit{&db, parent} {}
+    : ProgramUnit{&bd, parent} {}
 
 AST::Program *Br::createAST(const Pa::Program &root) {
   ASTBuilder walker;

From 6a5894379fd4482921f8ccf7afd5e4f9ac3fbbd4 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 31 Jan 2020 12:36:47 -0800
Subject: [PATCH 180/345] PFT rename fix for complex

---
 include/CMakeLists.txt            |   1 -
 include/fir/Dialect/FIROps.td     |   2 +-
 include/flang/lower/ASTBuilder.h  | 331 -------------
 include/flang/lower/ConvertType.h |  21 -
 lib/fir/InternalNames.cpp         |   7 +-
 lib/fir/KindMapping.cpp           |   8 +-
 lib/lower/ASTBuilder.cpp          | 783 ------------------------------
 lib/lower/Bridge.cpp              | 143 +++---
 lib/lower/CFGBuilder.h            |  96 ++--
 lib/lower/CMakeLists.txt          |   7 +-
 lib/lower/ConvertExpr.cpp         |  39 +-
 lib/lower/ConvertType.cpp         |  99 +---
 lib/lower/IO.cpp                  | 226 +++++----
 lib/lower/Intrinsics.cpp          |   4 +-
 lib/lower/Mangler.cpp             |   7 +-
 lib/lower/OpBuilder.cpp           | 147 +++---
 lib/lower/RTBuilder.h             | 156 ++++--
 lib/lower/Runtime.cpp             |  39 +-
 18 files changed, 478 insertions(+), 1638 deletions(-)
 delete mode 100644 include/flang/lower/ASTBuilder.h
 delete mode 100644 lib/lower/ASTBuilder.cpp

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index bd3543028a2c..8f8c016cb1d2 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1,2 +1 @@
 add_subdirectory(fir)
-add_subdirectory(flang)
diff --git a/include/fir/Dialect/FIROps.td b/include/fir/Dialect/FIROps.td
index 1d557ff380fa..f2980975404e 100644
--- a/include/fir/Dialect/FIROps.td
+++ b/include/fir/Dialect/FIROps.td
@@ -208,7 +208,7 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
       hasOperands = true;
     }
     if (hasOperands &&
-        parser.resolveOperands(operands, builder.getIndexType(),
+        parser.resolveOperands(operands, {builder.getIndexType()},
             parser.getNameLoc(), result.operands))
       return mlir::failure();
     mlir::Type restype = wrapResultType(intype);
diff --git a/include/flang/lower/ASTBuilder.h b/include/flang/lower/ASTBuilder.h
deleted file mode 100644
index b0aeb211fe78..000000000000
--- a/include/flang/lower/ASTBuilder.h
+++ /dev/null
@@ -1,331 +0,0 @@
-//===-- flang/lower/AstBuilder.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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef FORTRAN_LOWER_AST_BUILDER_H_
-#define FORTRAN_LOWER_AST_BUILDER_H_
-
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/scope.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace Fortran::lower {
-namespace AST {
-
-struct Evaluation;
-struct Program;
-struct ModuleLikeUnit;
-struct FunctionLikeUnit;
-
-using ParentType =
-    std::variant<Program *, ModuleLikeUnit *, FunctionLikeUnit *, Evaluation *>;
-
-enum class CFGAnnotation {
-  None,
-  Goto,
-  CondGoto,
-  IndGoto,
-  IoSwitch,
-  Switch,
-  Iterative,
-  FirStructuredOp,
-  Return,
-  Terminate
-};
-
-/// Compiler-generated jump
-///
-/// This is used to convert implicit control-flow edges to explicit form in the
-/// decorated AST
-struct CGJump {
-  CGJump(Evaluation *to) : target{to} {}
-  Evaluation *target{nullptr};
-};
-
-/// is `A` a construct (or directive)?
-template <typename A>
-constexpr static bool isConstruct() {
-  return std::is_same_v<A, parser::AssociateConstruct> ||
-         std::is_same_v<A, parser::BlockConstruct> ||
-         std::is_same_v<A, parser::CaseConstruct> ||
-         std::is_same_v<A, parser::ChangeTeamConstruct> ||
-         std::is_same_v<A, parser::CriticalConstruct> ||
-         std::is_same_v<A, parser::DoConstruct> ||
-         std::is_same_v<A, parser::IfConstruct> ||
-         std::is_same_v<A, parser::SelectRankConstruct> ||
-         std::is_same_v<A, parser::SelectTypeConstruct> ||
-         std::is_same_v<A, parser::WhereConstruct> ||
-         std::is_same_v<A, parser::ForallConstruct> ||
-         std::is_same_v<A, parser::CompilerDirective> ||
-         std::is_same_v<A, parser::OpenMPConstruct> ||
-         std::is_same_v<A, parser::OmpEndLoopDirective>;
-}
-
-/// Function-like units can contains lists of evaluations.  These can be
-/// (simple) statements or constructs, where a construct contains its own
-/// evaluations.
-struct Evaluation {
-  using EvalVariant = std::variant<
-      // action statements
-      const parser::AllocateStmt *, const parser::AssignmentStmt *,
-      const parser::BackspaceStmt *, const parser::CallStmt *,
-      const parser::CloseStmt *, const parser::ContinueStmt *,
-      const parser::CycleStmt *, const parser::DeallocateStmt *,
-      const parser::EndfileStmt *, const parser::EventPostStmt *,
-      const parser::EventWaitStmt *, const parser::ExitStmt *,
-      const parser::FailImageStmt *, const parser::FlushStmt *,
-      const parser::FormTeamStmt *, const parser::GotoStmt *,
-      const parser::IfStmt *, const parser::InquireStmt *,
-      const parser::LockStmt *, const parser::NullifyStmt *,
-      const parser::OpenStmt *, const parser::PointerAssignmentStmt *,
-      const parser::PrintStmt *, const parser::ReadStmt *,
-      const parser::ReturnStmt *, const parser::RewindStmt *,
-      const parser::StopStmt *, const parser::SyncAllStmt *,
-      const parser::SyncImagesStmt *, const parser::SyncMemoryStmt *,
-      const parser::SyncTeamStmt *, const parser::UnlockStmt *,
-      const parser::WaitStmt *, const parser::WhereStmt *,
-      const parser::WriteStmt *, const parser::ComputedGotoStmt *,
-      const parser::ForallStmt *, const parser::ArithmeticIfStmt *,
-      const parser::AssignStmt *, const parser::AssignedGotoStmt *,
-      const parser::PauseStmt *,
-      // compiler generated ops
-      CGJump,
-      // other statements
-      const parser::FormatStmt *, const parser::EntryStmt *,
-      const parser::DataStmt *, const parser::NamelistStmt *,
-      // constructs
-      const parser::AssociateConstruct *, const parser::BlockConstruct *,
-      const parser::CaseConstruct *, const parser::ChangeTeamConstruct *,
-      const parser::CriticalConstruct *, const parser::DoConstruct *,
-      const parser::IfConstruct *, const parser::SelectRankConstruct *,
-      const parser::SelectTypeConstruct *, const parser::WhereConstruct *,
-      const parser::ForallConstruct *, const parser::CompilerDirective *,
-      const parser::OpenMPConstruct *, const parser::OmpEndLoopDirective *,
-      // construct statements
-      const parser::AssociateStmt *, const parser::EndAssociateStmt *,
-      const parser::BlockStmt *, const parser::EndBlockStmt *,
-      const parser::SelectCaseStmt *, const parser::CaseStmt *,
-      const parser::EndSelectStmt *, const parser::ChangeTeamStmt *,
-      const parser::EndChangeTeamStmt *, const parser::CriticalStmt *,
-      const parser::EndCriticalStmt *, const parser::NonLabelDoStmt *,
-      const parser::EndDoStmt *, const parser::IfThenStmt *,
-      const parser::ElseIfStmt *, const parser::ElseStmt *,
-      const parser::EndIfStmt *, const parser::SelectRankStmt *,
-      const parser::SelectRankCaseStmt *, const parser::SelectTypeStmt *,
-      const parser::TypeGuardStmt *, const parser::WhereConstructStmt *,
-      const parser::MaskedElsewhereStmt *, const parser::ElsewhereStmt *,
-      const parser::EndWhereStmt *, const parser::ForallConstructStmt *,
-      const parser::EndForallStmt *>;
-
-  Evaluation() = delete;
-  Evaluation(const Evaluation &) = default;
-
-  /// General ctor
-  template <typename A>
-  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &pos,
-             const std::optional<parser::Label> &lab)
-      : u{&a}, parent{p}, pos{pos}, lab{lab} {}
-
-  /// Compiler-generated jump
-  Evaluation(const CGJump &jump, const ParentType &p)
-      : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
-
-  /// Construct ctor
-  template <typename A>
-  Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
-    static_assert(AST::isConstruct<A>(), "must be a construct");
-  }
-
-  /// is `A` executable (an action statement or compiler generated)?
-  template <typename A>
-  constexpr static bool isAction(const A &a) {
-    return !AST::isConstruct<A>() && !isOther(a);
-  }
-
-  /// is `A` a compiler-generated evaluation?
-  template <typename A>
-  constexpr static bool isGenerated(const A &) {
-    return std::is_same_v<A, CGJump>;
-  }
-
-  /// is `A` not an executable statement?
-  template <typename A>
-  constexpr static bool isOther(const A &) {
-    return std::is_same_v<A, parser::FormatStmt> ||
-           std::is_same_v<A, parser::EntryStmt> ||
-           std::is_same_v<A, parser::DataStmt> ||
-           std::is_same_v<A, parser::NamelistStmt>;
-  }
-
-  constexpr bool isActionStmt() const {
-    return std::visit(common::visitors{
-                          [](auto *p) { return isAction(*p); },
-                          [](auto &r) { return isGenerated(r); },
-                      },
-                      u);
-  }
-
-  constexpr bool isStmt() const {
-    return std::visit(common::visitors{
-                          [](auto *p) { return isAction(*p) || isOther(*p); },
-                          [](auto &r) { return isGenerated(r); },
-                      },
-                      u);
-  }
-  constexpr bool isConstruct() const { return !isStmt(); }
-
-  /// Set the type of originating control flow type for this evaluation.
-  void setCFG(CFGAnnotation a, Evaluation *cstr) {
-    cfg = a;
-    setBranches(cstr);
-  }
-
-  /// Is this evaluation a control-flow origin? (The AST must be annotated)
-  bool isControlOrigin() const { return cfg != CFGAnnotation::None; }
-
-  /// Is this evaluation a control-flow target? (The AST must be annotated)
-  bool isControlTarget() const { return isTarget; }
-
-  /// Set the containsBranches flag iff this evaluation (a construct) contains
-  /// control flow
-  void setBranches() { containsBranches = true; }
-
-  constexpr std::list<Evaluation> *getConstructEvals() {
-    return isStmt() ? nullptr : subs;
-  }
-
-  /// Set that the construct `cstr` (if not a nullptr) has branches.
-  static void setBranches(Evaluation *cstr) {
-    if (cstr)
-      cstr->setBranches();
-  }
-
-  EvalVariant u;
-  ParentType parent;
-  parser::CharBlock pos;
-  std::optional<parser::Label> lab;
-  std::list<Evaluation> *subs{nullptr}; // construct sub-statements
-  CFGAnnotation cfg{CFGAnnotation::None};
-  bool isTarget{false};         // this evaluation is a control target
-  bool containsBranches{false}; // construct contains branches
-};
-
-/// A program is a list of program units.
-/// These units can be function like, module like, or block data
-struct ProgramUnit {
-  template <typename A>
-  ProgramUnit(A *ptr, const ParentType &parent) : p{ptr}, parent{parent} {}
-
-  std::variant<const parser::MainProgram *, const parser::FunctionSubprogram *,
-               const parser::SubroutineSubprogram *, const parser::Module *,
-               const parser::Submodule *,
-               const parser::SeparateModuleSubprogram *,
-               const parser::BlockData *>
-      p;
-  ParentType parent;
-};
-
-/// Function-like units have similar structure. They all can contain executable
-/// statements.
-struct FunctionLikeUnit : public ProgramUnit {
-  // wrapper statements for function-like syntactic structures
-  using FunctionStatement =
-      std::variant<const parser::Statement<parser::ProgramStmt> *,
-                   const parser::Statement<parser::EndProgramStmt> *,
-                   const parser::Statement<parser::FunctionStmt> *,
-                   const parser::Statement<parser::EndFunctionStmt> *,
-                   const parser::Statement<parser::SubroutineStmt> *,
-                   const parser::Statement<parser::EndSubroutineStmt> *,
-                   const parser::Statement<parser::MpSubprogramStmt> *,
-                   const parser::Statement<parser::EndMpSubprogramStmt> *>;
-
-  FunctionLikeUnit(const parser::MainProgram &f, const ParentType &parent);
-  FunctionLikeUnit(const parser::FunctionSubprogram &f,
-                   const ParentType &parent);
-  FunctionLikeUnit(const parser::SubroutineSubprogram &f,
-                   const ParentType &parent);
-  FunctionLikeUnit(const parser::SeparateModuleSubprogram &f,
-                   const ParentType &parent);
-
-  bool isMainProgram() {
-    return std::get_if<const parser::Statement<parser::EndProgramStmt> *>(
-        &funStmts.back());
-  }
-  const parser::FunctionStmt *getFunction() {
-    return getA<parser::FunctionStmt>();
-  }
-  const parser::SubroutineStmt *getSubroutine() {
-    return getA<parser::SubroutineStmt>();
-  }
-  const parser::MpSubprogramStmt *getMPSubp() {
-    return getA<parser::MpSubprogramStmt>();
-  }
-
-  const semantics::Scope *scope{nullptr}; // scope from front-end
-  std::list<FunctionStatement> funStmts;  // begin/end pair
-  std::list<Evaluation> evals;            // statements
-  std::list<FunctionLikeUnit> funcs;      // internal procedures
-
-private:
-  template <typename A>
-  const A *getA() {
-    if (auto p = std::get_if<const parser::Statement<A> *>(&funStmts.front()))
-      return &(*p)->statement;
-    return nullptr;
-  }
-};
-
-/// Module-like units have similar structure. They all can contain a list of
-/// function-like units.
-struct ModuleLikeUnit : public ProgramUnit {
-  // wrapper statements for module-like syntactic structures
-  using ModuleStatement =
-      std::variant<const parser::Statement<parser::ModuleStmt> *,
-                   const parser::Statement<parser::EndModuleStmt> *,
-                   const parser::Statement<parser::SubmoduleStmt> *,
-                   const parser::Statement<parser::EndSubmoduleStmt> *>;
-
-  ModuleLikeUnit(const parser::Module &m, const ParentType &parent);
-  ModuleLikeUnit(const parser::Submodule &m, const ParentType &parent);
-  ~ModuleLikeUnit() = default;
-
-  const semantics::Scope *scope{nullptr};
-  std::list<ModuleStatement> modStmts;
-  std::list<FunctionLikeUnit> funcs;
-};
-
-// TODO: lower data too
-struct BlockDataUnit : public ProgramUnit {
-  BlockDataUnit(const parser::BlockData &bd, const ParentType &parent);
-};
-
-/// A Program is the top-level AST
-struct Program {
-  using Units = std::variant<FunctionLikeUnit, ModuleLikeUnit, BlockDataUnit>;
-
-  std::list<Units> &getUnits() { return units; }
-
-private:
-  std::list<Units> units;
-};
-
-} // namespace AST
-
-/// Create an AST from the parse tree
-AST::Program *createAST(const parser::Program &root);
-
-/// Decorate the AST with control flow annotations
-///
-/// The AST must be decorated with control-flow annotations to prepare it for
-/// use in generating a CFG-like structure.
-void annotateControl(AST::Program &ast);
-
-void dumpAST(llvm::raw_ostream &o, AST::Program &ast);
-
-} // namespace Fortran::lower
-
-#endif // FORTRAN_LOWER_AST_BUILDER_H_
diff --git a/include/flang/lower/ConvertType.h b/include/flang/lower/ConvertType.h
index d29d8979d7d2..f944c4885ffa 100644
--- a/include/flang/lower/ConvertType.h
+++ b/include/flang/lower/ConvertType.h
@@ -116,27 +116,6 @@ mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 // a memory reference to a sequence type.
 mlir::Type getSequenceRefType(mlir::Type referenceType);
 
-// Models for C (language) types
-
-mlir::Type getModelForInt(mlir::MLIRContext *);
-mlir::Type getModelForIntRef(mlir::MLIRContext *);
-mlir::Type getModelForIostat(mlir::MLIRContext *);
-mlir::Type getModelForCharPtr(mlir::MLIRContext *);
-mlir::Type getModelForConstCharPtr(mlir::MLIRContext *);
-mlir::Type getModelForInt64(mlir::MLIRContext *);
-mlir::Type getModelForInt64Ref(mlir::MLIRContext *);
-mlir::Type getModelForSize(mlir::MLIRContext *);
-mlir::Type getModelForCookie(mlir::MLIRContext *);
-mlir::Type getModelForDouble(mlir::MLIRContext *);
-mlir::Type getModelForDoubleRef(mlir::MLIRContext *);
-mlir::Type getModelForFloat(mlir::MLIRContext *);
-mlir::Type getModelForFloatRef(mlir::MLIRContext *);
-mlir::Type getModelForBool(mlir::MLIRContext *);
-mlir::Type getModelForBoolRef(mlir::MLIRContext *);
-mlir::Type getModelForDescriptor(mlir::MLIRContext *);
-mlir::Type getModelForNamelistGroup(mlir::MLIRContext *);
-mlir::Type getModelForVoid(mlir::MLIRContext *);
-
 } // namespace lower
 } // namespace Fortran
 
diff --git a/lib/fir/InternalNames.cpp b/lib/fir/InternalNames.cpp
index ca4ed337d344..9db82e1936d5 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/fir/InternalNames.cpp
@@ -13,6 +13,8 @@
 
 namespace {
 
+const std::int64_t BAD_VALUE = -1;
+
 inline llvm::StringRef prefix() { return "_Q"; }
 
 std::string doModules(llvm::ArrayRef<llvm::StringRef> mods) {
@@ -62,8 +64,9 @@ std::int64_t readInt(llvm::StringRef uniq, std::size_t &i, std::size_t init,
   for (i = init; i < end && uniq[i] >= '0' && uniq[i] <= '9'; ++i) {
     // do nothing
   }
-  std::int64_t result;
-  uniq.substr(init, i).getAsInteger(10, result);
+  std::int64_t result = BAD_VALUE;
+  if (uniq.substr(init, i).getAsInteger(10, result))
+    return BAD_VALUE;
   return result;
 }
 
diff --git a/lib/fir/KindMapping.cpp b/lib/fir/KindMapping.cpp
index 231505bd3c10..5f9a2c9300fe 100644
--- a/lib/fir/KindMapping.cpp
+++ b/lib/fir/KindMapping.cpp
@@ -167,17 +167,17 @@ MatchResult KindMapping::parse(llvm::StringRef kindMap) {
     return {true};
   const char *srcPtr = kindMap.begin();
   while (true) {
-    char code;
-    KindTy kind;
+    char code = '\0';
+    KindTy kind = 0;
     if (parseCode(code, srcPtr) || parseInt(kind, srcPtr))
       return badMapString(srcPtr);
     if (code == 'a' || code == 'i' || code == 'l') {
-      Bitsize bits;
+      Bitsize bits = 0;
       if (parseColon(srcPtr) || parseInt(bits, srcPtr))
         return badMapString(srcPtr);
       intMap[code][kind] = bits;
     } else if (code == 'r' || code == 'c') {
-      LLVMTypeID id;
+      LLVMTypeID id{};
       if (parseColon(srcPtr) || parseTypeID(id, srcPtr))
         return badMapString(srcPtr);
       floatMap[code][kind] = id;
diff --git a/lib/lower/ASTBuilder.cpp b/lib/lower/ASTBuilder.cpp
deleted file mode 100644
index e187f483a8fa..000000000000
--- a/lib/lower/ASTBuilder.cpp
+++ /dev/null
@@ -1,783 +0,0 @@
-//===-- lib/lower/AstBuilder.cc -------------------------------------------===//
-//
-// 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/lower/ASTBuilder.h"
-#include "flang/parser/dump-parse-tree.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include <cassert>
-#include <utility>
-
-/// Build a light-weight AST to help with lowering to FIR.  The AST will
-/// capture pointers back into the parse tree, so the parse tree data structure
-/// may <em>not</em> be changed between the construction of the AST and all of
-/// its uses.
-///
-/// The AST captures a structured view of the program.  The program is a list of
-/// units.  Function like units will contain lists of evaluations.  Evaluations
-/// are either statements or constructs, where a construct contains a list of
-/// evaluations.  The resulting AST structure can then be used to create FIR.
-
-namespace Br = Fortran::lower;
-namespace Co = Fortran::common;
-namespace L = llvm;
-namespace Pa = Fortran::parser;
-
-using namespace Fortran;
-using namespace Br;
-
-namespace {
-
-/// The instantiation of a parse tree visitor (Pre and Post) is extremely
-/// expensive in terms of compile and link time, so one goal here is to limit
-/// the bridge to one such instantiation.
-class ASTBuilder {
-public:
-  ASTBuilder() {
-    pgm = new AST::Program;
-    parents.push_back(pgm);
-  }
-
-  /// Get the result
-  AST::Program *result() { return pgm; }
-
-  template <typename A>
-  constexpr bool Pre(const A &) {
-    return true;
-  }
-  template <typename A>
-  constexpr void Post(const A &) {}
-
-  // Module like
-
-  bool Pre(const Pa::Module &x) { return enterModule(x); }
-  bool Pre(const Pa::Submodule &x) { return enterModule(x); }
-
-  void Post(const Pa::Module &) { exitModule(); }
-  void Post(const Pa::Submodule &) { exitModule(); }
-
-  // Function like
-
-  bool Pre(const Pa::MainProgram &x) { return enterFunc(x); }
-  bool Pre(const Pa::FunctionSubprogram &x) { return enterFunc(x); }
-  bool Pre(const Pa::SubroutineSubprogram &x) { return enterFunc(x); }
-  bool Pre(const Pa::SeparateModuleSubprogram &x) { return enterFunc(x); }
-
-  void Post(const Pa::MainProgram &) { exitFunc(); }
-  void Post(const Pa::FunctionSubprogram &) { exitFunc(); }
-  void Post(const Pa::SubroutineSubprogram &) { exitFunc(); }
-  void Post(const Pa::SeparateModuleSubprogram &) { exitFunc(); }
-
-  // Block data
-
-  void Post(const Pa::BlockData &x) {
-    AST::BlockDataUnit unit{x, parents.back()};
-    addUnit(unit);
-  }
-
-  //
-  // Action statements
-  //
-
-  void Post(const Pa::Statement<Pa::ActionStmt> &s) {
-    addEval(makeEvalAction(s));
-  }
-  void Post(const Pa::UnlabeledStatement<Pa::ActionStmt> &s) {
-    addEval(makeEvalAction(s));
-  }
-
-  //
-  // Non-executable statements
-  //
-
-  void Post(const Pa::Statement<Co::Indirection<Pa::FormatStmt>> &s) {
-    addEval(makeEvalIndirect(s));
-  }
-  void Post(const Pa::Statement<Co::Indirection<Pa::EntryStmt>> &s) {
-    addEval(makeEvalIndirect(s));
-  }
-  void Post(const Pa::Statement<Co::Indirection<Pa::DataStmt>> &s) {
-    addEval(makeEvalIndirect(s));
-  }
-  void Post(const Pa::Statement<Co::Indirection<Pa::NamelistStmt>> &s) {
-    addEval(makeEvalIndirect(s));
-  }
-
-  //
-  // Construct statements
-  //
-
-  void Post(const Pa::Statement<Pa::AssociateStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndAssociateStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::BlockStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndBlockStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::SelectCaseStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::CaseStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndSelectStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::ChangeTeamStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndChangeTeamStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::CriticalStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndCriticalStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::NonLabelDoStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndDoStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::IfThenStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::ElseIfStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::ElseStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndIfStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::SelectRankStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::SelectRankCaseStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::SelectTypeStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::TypeGuardStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::WhereConstructStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::MaskedElsewhereStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::ElsewhereStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndWhereStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::ForallConstructStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  void Post(const Pa::Statement<Pa::EndForallStmt> &s) {
-    addEval(makeEvalDirect(s));
-  }
-  // Get rid of production wrapper
-  void Post(const Pa::UnlabeledStatement<Pa::ForallAssignmentStmt> &s) {
-    addEval(std::visit(
-        [&](const auto &x) {
-          return AST::Evaluation{x, parents.back(), s.source, {}};
-        },
-        s.statement.u));
-  }
-  void Post(const Pa::Statement<Pa::ForallAssignmentStmt> &s) {
-    addEval(std::visit(
-        [&](const auto &x) {
-          return AST::Evaluation{x, parents.back(), s.source, s.label};
-        },
-        s.statement.u));
-  }
-
-  //
-  // Constructs (enter and exit)
-  //
-
-  bool Pre(const Pa::AssociateConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::BlockConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::CaseConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::ChangeTeamConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::CriticalConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::DoConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::IfConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::SelectRankConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::SelectTypeConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::WhereConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::ForallConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::CompilerDirective &c) { return enterConstruct(c); }
-  bool Pre(const Pa::OpenMPConstruct &c) { return enterConstruct(c); }
-  bool Pre(const Pa::OmpEndLoopDirective &c) { return enterConstruct(c); }
-
-  void Post(const Pa::AssociateConstruct &) { exitConstruct(); }
-  void Post(const Pa::BlockConstruct &) { exitConstruct(); }
-  void Post(const Pa::CaseConstruct &) { exitConstruct(); }
-  void Post(const Pa::ChangeTeamConstruct &) { exitConstruct(); }
-  void Post(const Pa::CriticalConstruct &) { exitConstruct(); }
-  void Post(const Pa::DoConstruct &) { exitConstruct(); }
-  void Post(const Pa::IfConstruct &) { exitConstruct(); }
-  void Post(const Pa::SelectRankConstruct &) { exitConstruct(); }
-  void Post(const Pa::SelectTypeConstruct &) { exitConstruct(); }
-  void Post(const Pa::WhereConstruct &) { exitConstruct(); }
-  void Post(const Pa::ForallConstruct &) { exitConstruct(); }
-  void Post(const Pa::CompilerDirective &) { exitConstruct(); }
-  void Post(const Pa::OpenMPConstruct &) { exitConstruct(); }
-  void Post(const Pa::OmpEndLoopDirective &) { exitConstruct(); }
-
-private:
-  // ActionStmt has a couple of non-conforming cases, which get handled
-  // explicitly here.  The other cases use an Indirection, which we discard in
-  // the AST.
-  AST::Evaluation makeEvalAction(const Pa::Statement<Pa::ActionStmt> &s) {
-    return std::visit(
-        Co::visitors{
-            [&](const Pa::ContinueStmt &x) {
-              return AST::Evaluation{x, parents.back(), s.source, s.label};
-            },
-            [&](const Pa::FailImageStmt &x) {
-              return AST::Evaluation{x, parents.back(), s.source, s.label};
-            },
-            [&](const auto &x) {
-              return AST::Evaluation{x.value(), parents.back(), s.source,
-                                     s.label};
-            },
-        },
-        s.statement.u);
-  }
-  AST::Evaluation
-  makeEvalAction(const Pa::UnlabeledStatement<Pa::ActionStmt> &s) {
-    return std::visit(
-        Co::visitors{
-            [&](const Pa::ContinueStmt &x) {
-              return AST::Evaluation{x, parents.back(), s.source, {}};
-            },
-            [&](const Pa::FailImageStmt &x) {
-              return AST::Evaluation{x, parents.back(), s.source, {}};
-            },
-            [&](const auto &x) {
-              return AST::Evaluation{x.value(), parents.back(), s.source, {}};
-            },
-        },
-        s.statement.u);
-  }
-
-  template <typename A>
-  AST::Evaluation makeEvalIndirect(const Pa::Statement<Co::Indirection<A>> &s) {
-    return AST::Evaluation{s.statement.value(), parents.back(), s.source,
-                           s.label};
-  }
-
-  template <typename A>
-  AST::Evaluation makeEvalDirect(const Pa::Statement<A> &s) {
-    return AST::Evaluation{s.statement, parents.back(), s.source, s.label};
-  }
-
-  // When we enter a function-like structure, we want to build a new unit and
-  // set the builder's cursors to point to it.
-  template <typename A>
-  bool enterFunc(const A &f) {
-    auto &unit = addFunc(AST::FunctionLikeUnit{f, parents.back()});
-    funclist = &unit.funcs;
-    pushEval(&unit.evals);
-    parents.emplace_back(&unit);
-    return true;
-  }
-
-  void exitFunc() {
-    popEval();
-    funclist = nullptr;
-    parents.pop_back();
-  }
-
-  // When we enter a construct structure, we want to build a new construct and
-  // set the builder's evaluation cursor to point to it.
-  template <typename A>
-  bool enterConstruct(const A &c) {
-    auto &con = addEval(AST::Evaluation{c, parents.back()});
-    con.subs = new std::list<AST::Evaluation>();
-    pushEval(con.subs);
-    parents.emplace_back(&con);
-    return true;
-  }
-
-  void exitConstruct() {
-    popEval();
-    parents.pop_back();
-  }
-
-  // When we enter a module structure, we want to build a new module and
-  // set the builder's function cursor to point to it.
-  template <typename A>
-  bool enterModule(const A &f) {
-    auto &unit = addUnit(AST::ModuleLikeUnit{f, parents.back()});
-    funclist = &unit.funcs;
-    parents.emplace_back(&unit);
-    return true;
-  }
-
-  void exitModule() {
-    funclist = nullptr;
-    parents.pop_back();
-  }
-
-  template <typename A>
-  A &addUnit(const A &unit) {
-    pgm->getUnits().emplace_back(unit);
-    return std::get<A>(pgm->getUnits().back());
-  }
-
-  template <typename A>
-  A &addFunc(const A &func) {
-    if (funclist) {
-      funclist->emplace_back(func);
-      return funclist->back();
-    }
-    return addUnit(func);
-  }
-
-  /// move the Evaluation to the end of the current list
-  AST::Evaluation &addEval(AST::Evaluation &&eval) {
-    assert(funclist && "not in a function");
-    assert(evallist.size() > 0);
-    evallist.back()->emplace_back(std::move(eval));
-    return evallist.back()->back();
-  }
-
-  /// push a new list on the stack of Evaluation lists
-  void pushEval(std::list<AST::Evaluation> *eval) {
-    assert(funclist && "not in a function");
-    assert(eval && eval->empty() && "evaluation list isn't correct");
-    evallist.emplace_back(eval);
-  }
-
-  /// pop the current list and return to the last Evaluation list
-  void popEval() {
-    assert(funclist && "not in a function");
-    evallist.pop_back();
-  }
-
-  AST::Program *pgm;
-  std::list<AST::FunctionLikeUnit> *funclist{nullptr};
-  std::vector<std::list<AST::Evaluation> *> evallist;
-  std::vector<AST::ParentType> parents;
-};
-
-template <typename A>
-constexpr bool hasErrLabel(const A &stmt) {
-  if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
-                std::is_same_v<A, Pa::WriteStmt>) {
-    for (const auto &control : stmt.controls) {
-      if (std::holds_alternative<Pa::ErrLabel>(control.u)) {
-        return true;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, Pa::WaitStmt> ||
-                std::is_same_v<A, Pa::OpenStmt> ||
-                std::is_same_v<A, Pa::CloseStmt> ||
-                std::is_same_v<A, Pa::BackspaceStmt> ||
-                std::is_same_v<A, Pa::EndfileStmt> ||
-                std::is_same_v<A, Pa::RewindStmt> ||
-                std::is_same_v<A, Pa::FlushStmt>) {
-    for (const auto &spec : stmt.v) {
-      if (std::holds_alternative<Pa::ErrLabel>(spec.u)) {
-        return true;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, Pa::InquireStmt>) {
-    for (const auto &spec : std::get<std::list<Pa::InquireSpec>>(stmt.u)) {
-      if (std::holds_alternative<Pa::ErrLabel>(spec.u)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-template <typename A>
-constexpr bool hasEorLabel(const A &stmt) {
-  if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
-                std::is_same_v<A, Pa::WriteStmt>) {
-    for (const auto &control : stmt.controls) {
-      if (std::holds_alternative<Pa::EorLabel>(control.u)) {
-        return true;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, Pa::WaitStmt>) {
-    for (const auto &waitSpec : stmt.v) {
-      if (std::holds_alternative<Pa::EorLabel>(waitSpec.u)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-template <typename A>
-constexpr bool hasEndLabel(const A &stmt) {
-  if constexpr (std::is_same_v<A, Pa::ReadStmt> ||
-                std::is_same_v<A, Pa::WriteStmt>) {
-    for (const auto &control : stmt.controls) {
-      if (std::holds_alternative<Pa::EndLabel>(control.u)) {
-        return true;
-      }
-    }
-  }
-  if constexpr (std::is_same_v<A, Pa::WaitStmt>) {
-    for (const auto &waitSpec : stmt.v) {
-      if (std::holds_alternative<Pa::EndLabel>(waitSpec.u)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-bool hasAltReturns(const Pa::CallStmt &callStmt) {
-  const auto &args{std::get<std::list<Pa::ActualArgSpec>>(callStmt.v.t)};
-  for (const auto &arg : args) {
-    const auto &actual{std::get<Pa::ActualArg>(arg.t)};
-    if (std::holds_alternative<Pa::AltReturnSpec>(actual.u)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/// Determine if `callStmt` has alternate returns and if so set `e` to be the
-/// origin of a switch-like control flow
-void altRet(AST::Evaluation &e, const Pa::CallStmt *callStmt,
-            AST::Evaluation *cstr) {
-  if (hasAltReturns(*callStmt)) {
-    e.setCFG(AST::CFGAnnotation::Switch, cstr);
-  }
-}
-
-template <typename A>
-void ioLabel(AST::Evaluation &e, const A *s, AST::Evaluation *cstr) {
-  if (hasErrLabel(*s) || hasEorLabel(*s) || hasEndLabel(*s)) {
-    e.setCFG(AST::CFGAnnotation::IoSwitch, cstr);
-  }
-}
-
-void annotateEvalListCFG(std::list<AST::Evaluation> &evals,
-                         AST::Evaluation *cstr) {
-  bool nextIsTarget = false;
-  for (auto &e : evals) {
-    e.isTarget = nextIsTarget;
-    nextIsTarget = false;
-    if (e.isConstruct()) {
-      annotateEvalListCFG(*e.getConstructEvals(), &e);
-      // assume that the entry and exit are both possible branch targets
-      nextIsTarget = true;
-    }
-    if (e.isActionStmt() && e.lab.has_value()) {
-      e.isTarget = true;
-    }
-    std::visit(
-        Co::visitors{
-            [&](const Pa::BackspaceStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::CallStmt *s) { altRet(e, s, cstr); },
-            [&](const Pa::CloseStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::CycleStmt *) {
-              e.setCFG(AST::CFGAnnotation::Goto, cstr);
-            },
-            [&](const Pa::EndfileStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::ExitStmt *) {
-              e.setCFG(AST::CFGAnnotation::Goto, cstr);
-            },
-            [&](const Pa::FailImageStmt *) {
-              e.setCFG(AST::CFGAnnotation::Terminate, cstr);
-            },
-            [&](const Pa::FlushStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::GotoStmt *) {
-              e.setCFG(AST::CFGAnnotation::Goto, cstr);
-            },
-            [&](const Pa::IfStmt *) {
-              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
-            },
-            [&](const Pa::InquireStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::OpenStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::ReadStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::ReturnStmt *) {
-              e.setCFG(AST::CFGAnnotation::Return, cstr);
-            },
-            [&](const Pa::RewindStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::StopStmt *) {
-              e.setCFG(AST::CFGAnnotation::Terminate, cstr);
-            },
-            [&](const Pa::WaitStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::WriteStmt *s) { ioLabel(e, s, cstr); },
-            [&](const Pa::ArithmeticIfStmt *) {
-              e.setCFG(AST::CFGAnnotation::Switch, cstr);
-            },
-            [&](const Pa::AssignedGotoStmt *) {
-              e.setCFG(AST::CFGAnnotation::IndGoto, cstr);
-            },
-            [&](const Pa::ComputedGotoStmt *) {
-              e.setCFG(AST::CFGAnnotation::Switch, cstr);
-            },
-            [&](const Pa::WhereStmt *) {
-              // fir.loop + fir.where around the next stmt
-              e.isTarget = true;
-              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
-            },
-            [&](const Pa::ForallStmt *) {
-              // fir.loop around the next stmt
-              e.isTarget = true;
-              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
-            },
-            [&](AST::CGJump &) { e.setCFG(AST::CFGAnnotation::Goto, cstr); },
-            [&](const Pa::EndAssociateStmt *) { e.isTarget = true; },
-            [&](const Pa::EndBlockStmt *) { e.isTarget = true; },
-            [&](const Pa::SelectCaseStmt *) {
-              e.setCFG(AST::CFGAnnotation::Switch, cstr);
-            },
-            [&](const Pa::CaseStmt *) { e.isTarget = true; },
-            [&](const Pa::EndSelectStmt *) { e.isTarget = true; },
-            [&](const Pa::EndChangeTeamStmt *) { e.isTarget = true; },
-            [&](const Pa::EndCriticalStmt *) { e.isTarget = true; },
-            [&](const Pa::NonLabelDoStmt *) {
-              e.isTarget = true;
-              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
-            },
-            [&](const Pa::EndDoStmt *) {
-              e.isTarget = true;
-              e.setCFG(AST::CFGAnnotation::Goto, cstr);
-            },
-            [&](const Pa::IfThenStmt *) {
-              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
-            },
-            [&](const Pa::ElseIfStmt *) {
-              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
-            },
-            [&](const Pa::ElseStmt *) { e.isTarget = true; },
-            [&](const Pa::EndIfStmt *) { e.isTarget = true; },
-            [&](const Pa::SelectRankStmt *) {
-              e.setCFG(AST::CFGAnnotation::Switch, cstr);
-            },
-            [&](const Pa::SelectRankCaseStmt *) { e.isTarget = true; },
-            [&](const Pa::SelectTypeStmt *) {
-              e.setCFG(AST::CFGAnnotation::Switch, cstr);
-            },
-            [&](const Pa::TypeGuardStmt *) { e.isTarget = true; },
-            [&](const Pa::WhereConstruct *) {
-              // mark the WHERE as if it were a DO loop
-              e.isTarget = true;
-              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
-            },
-            [&](const Pa::WhereConstructStmt *) {
-              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
-            },
-            [&](const Pa::MaskedElsewhereStmt *) {
-              e.isTarget = true;
-              e.setCFG(AST::CFGAnnotation::CondGoto, cstr);
-            },
-            [&](const Pa::ElsewhereStmt *) { e.isTarget = true; },
-            [&](const Pa::EndWhereStmt *) { e.isTarget = true; },
-            [&](const Pa::ForallConstructStmt *) {
-              e.isTarget = true;
-              e.setCFG(AST::CFGAnnotation::Iterative, cstr);
-            },
-            [&](const Pa::EndForallStmt *) { e.isTarget = true; },
-            [](const auto *) { /* do nothing */ },
-        },
-        e.u);
-  }
-}
-
-/// Annotate the AST with CFG source decorations (see CFGAnnotation) and mark
-/// potential branch targets
-inline void annotateFuncCFG(AST::FunctionLikeUnit &flu) {
-  annotateEvalListCFG(flu.evals, nullptr);
-}
-
-L::StringRef evalName(AST::Evaluation &e) {
-  return std::visit(
-      Co::visitors{[](const AST::CGJump) { return "CGJump"; },
-                   [](const auto *parseTreeNode) {
-                     assert(parseTreeNode && "nullptr node in AST ");
-                     return Pa::ParseTreeDumper::GetNodeName(*parseTreeNode);
-                   }},
-      e.u);
-}
-
-void dumpEvalList(L::raw_ostream &o, std::list<AST::Evaluation> &evals,
-                  int indent = 1) {
-  static const std::string white{"                                      ++"};
-  std::string indentString{white.substr(0, indent * 2)};
-  for (AST::Evaluation &e : evals) {
-    L::StringRef name{evalName(e)};
-    if (e.isConstruct()) {
-      o << indentString << "<<" << name << ">>\n";
-      dumpEvalList(o, *e.getConstructEvals(), indent + 1);
-      o << indentString << "<<End" << name << ">>\n";
-    } else {
-      o << indentString << name << ": " << e.pos.ToString() << '\n';
-    }
-  }
-}
-
-void dumpFunctionLikeUnit(L::raw_ostream &o, AST::FunctionLikeUnit &flu) {
-  L::StringRef unitKind{};
-  std::string name{};
-  std::string header{};
-  std::visit(Co::visitors{
-                 [&](const Pa::Statement<Pa::ProgramStmt> *s) {
-                   unitKind = "Program";
-                   name = s->statement.v.ToString();
-                 },
-                 [&](const Pa::Statement<Pa::FunctionStmt> *s) {
-                   unitKind = "Function";
-                   name = std::get<Pa::Name>(s->statement.t).ToString();
-                   header = s->source.ToString();
-                 },
-                 [&](const Pa::Statement<Pa::SubroutineStmt> *s) {
-                   unitKind = "Subroutine";
-                   name = std::get<Pa::Name>(s->statement.t).ToString();
-                   header = s->source.ToString();
-                 },
-                 [&](const Pa::Statement<Pa::MpSubprogramStmt> *s) {
-                   unitKind = "MpSubprogram";
-                   name = s->statement.v.ToString();
-                   header = s->source.ToString();
-                 },
-                 [&](auto *) {
-                   if (std::get_if<const Pa::Statement<Pa::EndProgramStmt> *>(
-                           &flu.funStmts.back())) {
-                     unitKind = "Program";
-                     name = "<anonymous>";
-                   } else {
-                     unitKind = ">>>>> Error - no program unit <<<<<";
-                   }
-                 },
-             },
-             flu.funStmts.front());
-  o << unitKind << ' ' << name;
-  if (header.size()) {
-    o << ": " << header;
-  }
-  o << '\n';
-  dumpEvalList(o, flu.evals);
-  o << "End" << unitKind << ' ' << name << "\n\n";
-}
-
-} // namespace
-
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::MainProgram &f,
-                                            const AST::ParentType &parent)
-    : ProgramUnit{&f, parent} {
-  auto &ps{std::get<std::optional<Pa::Statement<Pa::ProgramStmt>>>(f.t)};
-  if (ps.has_value()) {
-    const Pa::Statement<Pa::ProgramStmt> &s{ps.value()};
-    funStmts.push_back(&s);
-  }
-  funStmts.push_back(&std::get<Pa::Statement<Pa::EndProgramStmt>>(f.t));
-}
-
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::FunctionSubprogram &f,
-                                            const AST::ParentType &parent)
-    : ProgramUnit{&f, parent} {
-  funStmts.push_back(&std::get<Pa::Statement<Pa::FunctionStmt>>(f.t));
-  funStmts.push_back(&std::get<Pa::Statement<Pa::EndFunctionStmt>>(f.t));
-}
-
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(const Pa::SubroutineSubprogram &f,
-                                            const AST::ParentType &parent)
-    : ProgramUnit{&f, parent} {
-  funStmts.push_back(&std::get<Pa::Statement<Pa::SubroutineStmt>>(f.t));
-  funStmts.push_back(&std::get<Pa::Statement<Pa::EndSubroutineStmt>>(f.t));
-}
-
-Br::AST::FunctionLikeUnit::FunctionLikeUnit(
-    const Pa::SeparateModuleSubprogram &f, const AST::ParentType &parent)
-    : ProgramUnit{&f, parent} {
-  funStmts.push_back(&std::get<Pa::Statement<Pa::MpSubprogramStmt>>(f.t));
-  funStmts.push_back(&std::get<Pa::Statement<Pa::EndMpSubprogramStmt>>(f.t));
-}
-
-Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Module &m,
-                                        const AST::ParentType &parent)
-    : ProgramUnit{&m, parent} {
-  modStmts.push_back(&std::get<Pa::Statement<Pa::ModuleStmt>>(m.t));
-  modStmts.push_back(&std::get<Pa::Statement<Pa::EndModuleStmt>>(m.t));
-}
-
-Br::AST::ModuleLikeUnit::ModuleLikeUnit(const Pa::Submodule &m,
-                                        const AST::ParentType &parent)
-    : ProgramUnit{&m, parent} {
-  modStmts.push_back(&std::get<Pa::Statement<Pa::SubmoduleStmt>>(m.t));
-  modStmts.push_back(&std::get<Pa::Statement<Pa::EndSubmoduleStmt>>(m.t));
-}
-
-Br::AST::BlockDataUnit::BlockDataUnit(const Pa::BlockData &bd,
-                                      const AST::ParentType &parent)
-    : ProgramUnit{&bd, parent} {}
-
-AST::Program *Br::createAST(const Pa::Program &root) {
-  ASTBuilder walker;
-  Walk(root, walker);
-  return walker.result();
-}
-
-void Br::annotateControl(AST::Program &ast) {
-  for (auto &unit : ast.getUnits()) {
-    std::visit(Co::visitors{
-                   [](AST::BlockDataUnit &) {},
-                   [](AST::FunctionLikeUnit &f) {
-                     annotateFuncCFG(f);
-                     for (auto &s : f.funcs) {
-                       annotateFuncCFG(s);
-                     }
-                   },
-                   [](AST::ModuleLikeUnit &u) {
-                     for (auto &f : u.funcs) {
-                       annotateFuncCFG(f);
-                     }
-                   },
-               },
-               unit);
-  }
-}
-
-/// Dump an AST.
-void Br::dumpAST(L::raw_ostream &o, AST::Program &ast) {
-  for (auto &unit : ast.getUnits()) {
-    std::visit(
-        Co::visitors{
-            [&](AST::BlockDataUnit &) { o << "BlockData\nEndBlockData\n\n"; },
-            [&](AST::FunctionLikeUnit &f) {
-              dumpFunctionLikeUnit(o, f);
-              for (auto &f : f.funcs) {
-                dumpFunctionLikeUnit(o, f);
-              }
-            },
-            [&](AST::ModuleLikeUnit &u) {
-              for (auto &f : u.funcs) {
-                dumpFunctionLikeUnit(o, f);
-              }
-            },
-        },
-        unit);
-  }
-}
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 1566b5ee6e6f..15b8309ef0a3 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -7,17 +7,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Bridge.h"
+#include "NSAliases.h"
 #include "fir/Dialect/FIRDialect.h"
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
 #include "fir/InternalNames.h"
-#include "flang/lower/ASTBuilder.h"
 #include "flang/lower/ConvertExpr.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/IO.h"
 #include "flang/lower/Intrinsics.h"
 #include "flang/lower/Mangler.h"
 #include "flang/lower/OpBuilder.h"
+#include "flang/lower/PFTBuilder.h"
 #include "flang/lower/Runtime.h"
 #include "flang/parser/parse-tree.h"
 #include "flang/semantics/tools.h"
@@ -28,14 +29,6 @@
 #include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/CommandLine.h"
 
-namespace Br = Fortran::lower;
-namespace Co = Fortran::common;
-namespace Ev = Fortran::evaluate;
-namespace L = llvm;
-namespace M = mlir;
-namespace Pa = Fortran::parser;
-namespace Se = Fortran::semantics;
-
 using namespace Fortran;
 using namespace Fortran::lower;
 
@@ -56,8 +49,8 @@ using SelectCaseConstruct = Pa::CaseConstruct;
 using SelectRankConstruct = Pa::SelectRankConstruct;
 using SelectTypeConstruct = Pa::SelectTypeConstruct;
 
-using CFGSinkListType = L::SmallVector<AST::Evaluation *, 2>;
-using CFGMapType = L::DenseMap<AST::Evaluation *, CFGSinkListType *>;
+using CFGSinkListType = L::SmallVector<PFT::Evaluation *, 2>;
+using CFGMapType = L::DenseMap<PFT::Evaluation *, CFGSinkListType *>;
 
 constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
   return std::get<Pa::StopStmt::Kind>(stm.t) == Pa::StopStmt::Kind::Stop;
@@ -76,12 +69,12 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
       assert(false && "not yet implemented");                                  \
   }
 
-/// Converter from AST to FIR
+/// Converter from PFT to FIR
 ///
-/// After building the AST and decorating it, the FirConverter processes that
+/// After building the PFT and decorating it, the FirConverter processes that
 /// representation and lowers it to the FIR executable representation.
 class FirConverter : public AbstractConverter {
-  using LabelMapType = std::map<AST::Evaluation *, M::Block *>;
+  using LabelMapType = std::map<PFT::Evaluation *, M::Block *>;
   using Closure = std::function<void(const LabelMapType &)>;
 
   //
@@ -110,38 +103,38 @@ class FirConverter : public AbstractConverter {
     return createFunction(*this, callee, funcTy);
   }
 
-  static bool inMainProgram(AST::Evaluation *cstr) {
+  static bool inMainProgram(PFT::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
-            [](AST::FunctionLikeUnit *c) { return c->isMainProgram(); },
-            [&](AST::Evaluation *c) { return inMainProgram(c); },
+            [](PFT::FunctionLikeUnit *c) { return c->isMainProgram(); },
+            [&](PFT::Evaluation *c) { return inMainProgram(c); },
             [](auto *) { return false; },
         },
         cstr->parent);
   }
-  static const Pa::SubroutineStmt *inSubroutine(AST::Evaluation *cstr) {
+  static const Pa::SubroutineStmt *inSubroutine(PFT::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
-            [](AST::FunctionLikeUnit *c) { return c->getSubroutine(); },
-            [&](AST::Evaluation *c) { return inSubroutine(c); },
+            [](PFT::FunctionLikeUnit *c) { return c->getSubroutine(); },
+            [&](PFT::Evaluation *c) { return inSubroutine(c); },
             [](auto *) -> const Pa::SubroutineStmt * { return nullptr; },
         },
         cstr->parent);
   }
-  static const Pa::FunctionStmt *inFunction(AST::Evaluation *cstr) {
+  static const Pa::FunctionStmt *inFunction(PFT::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
-            [](AST::FunctionLikeUnit *c) { return c->getFunction(); },
-            [&](AST::Evaluation *c) { return inFunction(c); },
+            [](PFT::FunctionLikeUnit *c) { return c->getFunction(); },
+            [&](PFT::Evaluation *c) { return inFunction(c); },
             [](auto *) -> const Pa::FunctionStmt * { return nullptr; },
         },
         cstr->parent);
   }
-  static const Pa::MpSubprogramStmt *inMPSubp(AST::Evaluation *cstr) {
+  static const Pa::MpSubprogramStmt *inMPSubp(PFT::Evaluation *cstr) {
     return std::visit(
         Co::visitors{
-            [](AST::FunctionLikeUnit *c) { return c->getMPSubp(); },
-            [&](AST::Evaluation *c) { return inMPSubp(c); },
+            [](PFT::FunctionLikeUnit *c) { return c->getMPSubp(); },
+            [&](PFT::Evaluation *c) { return inMPSubp(c); },
             [](auto *) -> const Pa::MpSubprogramStmt * { return nullptr; },
         },
         cstr->parent);
@@ -156,7 +149,7 @@ class FirConverter : public AbstractConverter {
     return Se::GetExpr(std::get<Pa::LogicalExpr>(tuple));
   }
   /// Get the condition expression for a CondGoto evaluation
-  const Se::SomeExpr *getEvaluationCondition(AST::Evaluation &eval) {
+  const Se::SomeExpr *getEvaluationCondition(PFT::Evaluation &eval) {
     return std::visit(Co::visitors{
                           [&](const Pa::IfStmt *stmt) {
                             return getScalarExprOfTuple(stmt->t);
@@ -183,7 +176,7 @@ class FirConverter : public AbstractConverter {
   }
 
   //
-  // Function-like AST entry and exit statements
+  // Function-like PFT entry and exit statements
   //
 
   void genFIR(const Pa::Statement<Pa::ProgramStmt> &stmt, std::string &name,
@@ -272,7 +265,7 @@ class FirConverter : public AbstractConverter {
   //
 
   // Conditional goto control-flow semantics
-  void genFIREvalCondGoto(AST::Evaluation &eval) {
+  void genFIREvalCondGoto(PFT::Evaluation &eval) {
     genFIR(eval);
     auto targets{findTargetsOf(eval)};
     auto *expr{getEvaluationCondition(eval)};
@@ -281,12 +274,12 @@ class FirConverter : public AbstractConverter {
     genFIRCondBranch(cond, targets[0], targets[1]);
   }
 
-  void genFIRCondBranch(M::Value cond, AST::Evaluation *trueDest,
-                        AST::Evaluation *falseDest) {
+  void genFIRCondBranch(M::Value cond, PFT::Evaluation *trueDest,
+                        PFT::Evaluation *falseDest) {
     using namespace std::placeholders;
     localEdgeQ.emplace_back(std::bind(
         [](M::OpBuilder *builder, M::Block *block, M::Value cnd,
-           AST::Evaluation *trueDest, AST::Evaluation *falseDest,
+           PFT::Evaluation *trueDest, PFT::Evaluation *falseDest,
            M::Location location, const LabelMapType &map) {
           L::SmallVector<M::Value, 2> blk;
           builder->setInsertionPointToEnd(block);
@@ -303,10 +296,10 @@ class FirConverter : public AbstractConverter {
   // Goto control-flow semantics
   //
   // These are unconditional jumps. There is nothing to evaluate.
-  void genFIREvalGoto(AST::Evaluation &eval) {
+  void genFIREvalGoto(PFT::Evaluation &eval) {
     using namespace std::placeholders;
     localEdgeQ.emplace_back(std::bind(
-        [](M::OpBuilder *builder, M::Block *block, AST::Evaluation *dest,
+        [](M::OpBuilder *builder, M::Block *block, PFT::Evaluation *dest,
            M::Location location, const LabelMapType &map) {
           builder->setInsertionPointToEnd(block);
           assert(map.find(dest) != map.end() && "no destination");
@@ -319,7 +312,7 @@ class FirConverter : public AbstractConverter {
   // Indirect goto control-flow semantics
   //
   // For assigned gotos, which is an obsolescent feature. Lower to a switch.
-  void genFIREvalIndGoto(AST::Evaluation &eval) {
+  void genFIREvalIndGoto(PFT::Evaluation &eval) {
     genFIR(eval);
     // FIXME
   }
@@ -327,14 +320,14 @@ class FirConverter : public AbstractConverter {
   // IO statements that have control-flow semantics
   //
   // First lower the IO statement and then do the multiway switch op
-  void genFIREvalIoSwitch(AST::Evaluation &eval) {
+  void genFIREvalIoSwitch(PFT::Evaluation &eval) {
     genFIR(eval);
     genFIRIOSwitch(eval);
   }
-  void genFIRIOSwitch(AST::Evaluation &) { TODO(); }
+  void genFIRIOSwitch(PFT::Evaluation &) { TODO(); }
 
   // Iterative loop control-flow semantics
-  void genFIREvalIterative(AST::Evaluation &) { TODO(); }
+  void genFIREvalIterative(PFT::Evaluation &) { TODO(); }
 
   void switchInsertionPointToWhere(fir::WhereOp &where) {
     builder->setInsertionPointToStart(&where.whereRegion().front());
@@ -361,7 +354,7 @@ class FirConverter : public AbstractConverter {
   /// Convert a DoConstruct to a `fir.loop` op.
   /// Convert an IfConstruct to a `fir.where` op.
   ///
-  void genFIREvalStructuredOp(AST::Evaluation &eval) {
+  void genFIREvalStructuredOp(PFT::Evaluation &eval) {
     // TODO: array expressions, FORALL, WHERE ...
 
     // process the list of Evaluations
@@ -441,13 +434,13 @@ class FirConverter : public AbstractConverter {
   }
 
   // Return from subprogram control-flow semantics
-  void genFIREvalReturn(AST::Evaluation &eval) {
+  void genFIREvalReturn(PFT::Evaluation &eval) {
     // Handled case-by-case
     // FIXME: think about moving the case code here
   }
 
   // Multiway switch control-flow semantics
-  void genFIREvalSwitch(AST::Evaluation &eval) {
+  void genFIREvalSwitch(PFT::Evaluation &eval) {
     genFIR(eval);
     // FIXME
   }
@@ -455,13 +448,13 @@ class FirConverter : public AbstractConverter {
   // Terminate process control-flow semantics
   //
   // Call a runtime routine that does not return
-  void genFIREvalTerminate(AST::Evaluation &eval) {
+  void genFIREvalTerminate(PFT::Evaluation &eval) {
     genFIR(eval);
     builder->create<fir::UnreachableOp>(toLocation());
   }
 
   // No control-flow
-  void genFIREvalNone(AST::Evaluation &eval) { genFIR(eval); }
+  void genFIREvalNone(PFT::Evaluation &eval) { genFIR(eval); }
 
   M::FuncOp getFunc(L::StringRef name, M::FunctionType ty) {
     if (auto func = getNamedFunction(module, name)) {
@@ -851,11 +844,11 @@ class FirConverter : public AbstractConverter {
   void genFIR(const Pa::ExitStmt &) {}  // do nothing
   void genFIR(const Pa::GotoStmt &) {}  // do nothing
 
-  void genFIR(AST::Evaluation &eval) {
+  void genFIR(PFT::Evaluation &eval) {
     currentEvaluation = &eval;
     std::visit(Co::visitors{
                    [&](const auto *p) { genFIR(*p); },
-                   [](const AST::CGJump &) { /* do nothing */ },
+                   [](const PFT::CGJump &) { /* do nothing */ },
                },
                eval.u);
   }
@@ -865,40 +858,40 @@ class FirConverter : public AbstractConverter {
   /// If the Evaluation is annotated, we can attempt to lower it by the class of
   /// annotation. Otherwise, attempt to lower the Evaluation on a case-by-case
   /// basis.
-  void lowerEval(AST::Evaluation &eval) {
+  void lowerEval(PFT::Evaluation &eval) {
     setCurrentPosition(eval.pos);
     if (eval.isControlTarget()) {
       // start a new block
     }
     switch (eval.cfg) {
-    case AST::CFGAnnotation::None:
+    case PFT::CFGAnnotation::None:
       genFIREvalNone(eval);
       break;
-    case AST::CFGAnnotation::Goto:
+    case PFT::CFGAnnotation::Goto:
       genFIREvalGoto(eval);
       break;
-    case AST::CFGAnnotation::CondGoto:
+    case PFT::CFGAnnotation::CondGoto:
       genFIREvalCondGoto(eval);
       break;
-    case AST::CFGAnnotation::IndGoto:
+    case PFT::CFGAnnotation::IndGoto:
       genFIREvalIndGoto(eval);
       break;
-    case AST::CFGAnnotation::IoSwitch:
+    case PFT::CFGAnnotation::IoSwitch:
       genFIREvalIoSwitch(eval);
       break;
-    case AST::CFGAnnotation::Switch:
+    case PFT::CFGAnnotation::Switch:
       genFIREvalSwitch(eval);
       break;
-    case AST::CFGAnnotation::Iterative:
+    case PFT::CFGAnnotation::Iterative:
       genFIREvalIterative(eval);
       break;
-    case AST::CFGAnnotation::FirStructuredOp:
+    case PFT::CFGAnnotation::FirStructuredOp:
       genFIREvalStructuredOp(eval);
       break;
-    case AST::CFGAnnotation::Return:
+    case PFT::CFGAnnotation::Return:
       genFIREvalReturn(eval);
       break;
-    case AST::CFGAnnotation::Terminate:
+    case PFT::CFGAnnotation::Terminate:
       genFIREvalTerminate(eval);
       break;
     }
@@ -914,7 +907,7 @@ class FirConverter : public AbstractConverter {
   }
 
   /// Prepare to translate a new function
-  void startNewFunction(AST::FunctionLikeUnit &funit, L::StringRef name,
+  void startNewFunction(PFT::FunctionLikeUnit &funit, L::StringRef name,
                         const Se::Symbol *symbol) {
     M::FuncOp func{getNamedFunction(module, name)};
     if (!func) {
@@ -930,7 +923,7 @@ class FirConverter : public AbstractConverter {
     if (symbol) {
       auto *entryBlock{&func.front()};
       auto *details{symbol->detailsIf<Se::SubprogramDetails>()};
-      assert(details && "details for semantics::Symbol must be subprogram");
+      assert(details && "details for semantics symbol must be subprogram");
       for (const auto &v :
            L::zip(details->dummyArgs(), entryBlock->getArguments())) {
         if (std::get<0>(v)) {
@@ -962,7 +955,7 @@ class FirConverter : public AbstractConverter {
   }
 
   /// Lower a procedure-like construct
-  void lowerFunc(AST::FunctionLikeUnit &func, L::ArrayRef<L::StringRef> modules,
+  void lowerFunc(PFT::FunctionLikeUnit &func, L::ArrayRef<L::StringRef> modules,
                  L::Optional<L::StringRef> host = {}) {
     std::string name;
     const Se::Symbol *symbol{nullptr};
@@ -996,7 +989,7 @@ class FirConverter : public AbstractConverter {
     }
   }
 
-  void lowerMod(AST::ModuleLikeUnit &mod) {
+  void lowerMod(PFT::ModuleLikeUnit &mod) {
     // FIXME: build the vector of module names
     std::vector<L::StringRef> moduleName;
 
@@ -1011,21 +1004,21 @@ class FirConverter : public AbstractConverter {
   //
 
   /// Lookup the set of sinks for this source. There must be at least one.
-  L::ArrayRef<AST::Evaluation *> findTargetsOf(AST::Evaluation &eval) {
+  L::ArrayRef<PFT::Evaluation *> findTargetsOf(PFT::Evaluation &eval) {
     auto iter = cfgMap.find(&eval);
     assert(iter != cfgMap.end());
     return *iter->second;
   }
 
   /// Lookup the sink for this source. There must be exactly one.
-  AST::Evaluation *findSinkOf(AST::Evaluation &eval) {
+  PFT::Evaluation *findSinkOf(PFT::Evaluation &eval) {
     auto iter = cfgMap.find(&eval);
     assert((iter != cfgMap.end()) && (iter->second->size() == 1));
     return iter->second->front();
   }
 
   /// prune the CFG for `f`
-  void pruneFunc(AST::FunctionLikeUnit &func) {
+  void pruneFunc(PFT::FunctionLikeUnit &func) {
     // find and cache arcs, etc.
     if (!func.evals.empty()) {
       CfgBuilder{cfgMap, cfgEdgeSetPool}.run(func);
@@ -1037,7 +1030,7 @@ class FirConverter : public AbstractConverter {
     }
   }
 
-  void pruneMod(AST::ModuleLikeUnit &mod) {
+  void pruneMod(PFT::ModuleLikeUnit &mod) {
     for (auto &f : mod.funcs) {
       pruneFunc(f);
     }
@@ -1102,7 +1095,7 @@ class FirConverter : public AbstractConverter {
   Pa::CharBlock currentPosition;
   CFGMapType cfgMap;
   std::list<CFGSinkListType> cfgEdgeSetPool;
-  AST::Evaluation *currentEvaluation{nullptr}; // FIXME: this is a hack
+  PFT::Evaluation *currentEvaluation{nullptr}; // FIXME: this is a hack
 
 public:
   FirConverter() = delete;
@@ -1117,14 +1110,14 @@ class FirConverter : public AbstractConverter {
                                     bridge.getMLIRContext())},
         uniquer{uniquer} {}
 
-  /// Convert the AST to FIR
-  void run(AST::Program &ast) {
+  /// Convert the PFT to FIR
+  void run(PFT::Program &ast) {
     // build pruned control
     for (auto &u : ast.getUnits()) {
       std::visit(Co::visitors{
-                     [&](AST::FunctionLikeUnit &f) { pruneFunc(f); },
-                     [&](AST::ModuleLikeUnit &m) { pruneMod(m); },
-                     [](AST::BlockDataUnit &) { /* do nothing */ },
+                     [&](PFT::FunctionLikeUnit &f) { pruneFunc(f); },
+                     [&](PFT::ModuleLikeUnit &m) { pruneMod(m); },
+                     [](PFT::BlockDataUnit &) { /* do nothing */ },
                  },
                  u);
     }
@@ -1132,9 +1125,9 @@ class FirConverter : public AbstractConverter {
     // do translation
     for (auto &u : ast.getUnits()) {
       std::visit(Co::visitors{
-                     [&](AST::FunctionLikeUnit &f) { lowerFunc(f, {}); },
-                     [&](AST::ModuleLikeUnit &m) { lowerMod(m); },
-                     [&](AST::BlockDataUnit &) { TODO(); },
+                     [&](PFT::FunctionLikeUnit &f) { lowerFunc(f, {}); },
+                     [&](PFT::ModuleLikeUnit &m) { lowerMod(m); },
+                     [&](PFT::BlockDataUnit &) { TODO(); },
                  },
                  u);
     }
@@ -1201,10 +1194,10 @@ class FirConverter : public AbstractConverter {
 
 void Br::BurnsideBridge::lower(const Pa::Program &prg,
                                fir::NameUniquer &uniquer) {
-  AST::Program *ast{Br::createAST(prg)};
+  PFT::Program *ast{Br::createPFT(prg)};
   Br::annotateControl(*ast);
   if (dumpBeforeFir) {
-    Br::dumpAST(L::errs(), *ast);
+    Br::dumpPFT(L::errs(), *ast);
   }
   FirConverter converter{*this, uniquer};
   converter.run(*ast);
diff --git a/lib/lower/CFGBuilder.h b/lib/lower/CFGBuilder.h
index 4f30f3676ae3..fcebe8221756 100644
--- a/lib/lower/CFGBuilder.h
+++ b/lib/lower/CFGBuilder.h
@@ -9,11 +9,11 @@
 #ifndef FORTRAN_LOWER_CFG_BUILDER_H_
 #define FORTRAN_LOWER_CFG_BUILDER_H_
 
-/// Traverse the AST and complete the CFG by drawing the arcs, pruning unused
+/// Traverse the PFT and complete the CFG by drawing the arcs, pruning unused
 /// potential targets, making implied jumps explicit, etc.
 class CfgBuilder {
 
-  AST::Evaluation *getEvalByLabel(const Pa::Label &label) {
+  PFT::Evaluation *getEvalByLabel(const Pa::Label &label) {
     auto iter = labels.find(label);
     if (iter != labels.end()) {
       return iter->second;
@@ -22,7 +22,7 @@ class CfgBuilder {
   }
 
   /// Collect all the potential targets and initialize them to unreferenced
-  void resetPotentialTargets(std::list<AST::Evaluation> &evals) {
+  void resetPotentialTargets(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
       if (e.isTarget) {
         e.isTarget = false;
@@ -37,7 +37,7 @@ class CfgBuilder {
   }
 
   /// cache ASSIGN statements that may yield a live branch target
-  void cacheAssigns(std::list<AST::Evaluation> &evals) {
+  void cacheAssigns(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
       std::visit(Co::visitors{
                      [&](const Pa::AssignStmt *stmt) {
@@ -46,7 +46,7 @@ class CfgBuilder {
                        assert(sym);
                        auto jter = assignedGotoMap.find(sym);
                        if (jter == assignedGotoMap.end()) {
-                         std::list<AST::Evaluation *> lst = {trg};
+                         std::list<PFT::Evaluation *> lst = {trg};
                          assignedGotoMap.try_emplace(sym, lst);
                        } else {
                          jter->second.emplace_back(trg);
@@ -61,16 +61,16 @@ class CfgBuilder {
     }
   }
 
-  void deannotate(std::list<AST::Evaluation> &evals) {
+  void deannotate(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
-      e.cfg = AST::CFGAnnotation::None;
+      e.cfg = PFT::CFGAnnotation::None;
       if (e.subs) {
         deannotate(*e.subs);
       }
     }
   }
 
-  bool structuredCheck(std::list<AST::Evaluation> &evals) {
+  bool structuredCheck(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
       if (auto **s = std::get_if<const Pa::DoConstruct *>(&e.u)) {
         return (*s)->IsDoWhile() ? false : structuredCheck(*e.subs);
@@ -82,25 +82,25 @@ class CfgBuilder {
         return false;
       }
       switch (e.cfg) {
-      case AST::CFGAnnotation::None:
+      case PFT::CFGAnnotation::None:
         break;
-      case AST::CFGAnnotation::CondGoto:
+      case PFT::CFGAnnotation::CondGoto:
         break;
-      case AST::CFGAnnotation::Iterative:
+      case PFT::CFGAnnotation::Iterative:
         break;
-      case AST::CFGAnnotation::FirStructuredOp:
+      case PFT::CFGAnnotation::FirStructuredOp:
         break;
-      case AST::CFGAnnotation::IndGoto:
+      case PFT::CFGAnnotation::IndGoto:
         return false;
-      case AST::CFGAnnotation::IoSwitch:
+      case PFT::CFGAnnotation::IoSwitch:
         return false;
-      case AST::CFGAnnotation::Switch:
+      case PFT::CFGAnnotation::Switch:
         return false;
-      case AST::CFGAnnotation::Return:
+      case PFT::CFGAnnotation::Return:
         return false;
-      case AST::CFGAnnotation::Terminate:
+      case PFT::CFGAnnotation::Terminate:
         return false;
-      case AST::CFGAnnotation::Goto:
+      case PFT::CFGAnnotation::Goto:
         if (!std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
           return false;
         }
@@ -110,18 +110,18 @@ class CfgBuilder {
     return true;
   }
 
-  void wrapIterationSpaces(std::list<AST::Evaluation> &evals) {
+  void wrapIterationSpaces(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
       if (std::holds_alternative<const Pa::DoConstruct *>(e.u))
         if (structuredCheck(*e.subs)) {
           deannotate(*e.subs);
-          e.cfg = AST::CFGAnnotation::FirStructuredOp;
+          e.cfg = PFT::CFGAnnotation::FirStructuredOp;
           continue;
         }
       if (std::holds_alternative<const Pa::IfConstruct *>(e.u))
         if (structuredCheck(*e.subs)) {
           deannotate(*e.subs);
-          e.cfg = AST::CFGAnnotation::FirStructuredOp;
+          e.cfg = PFT::CFGAnnotation::FirStructuredOp;
           continue;
         }
       // FIXME: ForallConstruct? WhereConstruct?
@@ -132,7 +132,7 @@ class CfgBuilder {
   }
 
   /// Add source->sink edge to CFG map
-  void addSourceToSink(AST::Evaluation *src, AST::Evaluation *snk) {
+  void addSourceToSink(PFT::Evaluation *src, PFT::Evaluation *snk) {
     auto iter = cfgMap.find(src);
     if (iter == cfgMap.end()) {
       CFGSinkListType sink{snk};
@@ -149,7 +149,7 @@ class CfgBuilder {
     iter->second->push_back(snk);
   }
 
-  void addSourceToSink(AST::Evaluation *src, const Pa::Label &label) {
+  void addSourceToSink(PFT::Evaluation *src, const Pa::Label &label) {
     auto iter = labels.find(label);
     assert(iter != labels.end());
     addSourceToSink(src, iter->second);
@@ -175,13 +175,13 @@ class CfgBuilder {
   /// Branch to the "true block", the "false block", and from the end of the
   /// true block to the end of the construct.
   template <typename A>
-  void doNextIfBlock(std::list<AST::Evaluation> &evals, AST::Evaluation &e,
+  void doNextIfBlock(std::list<PFT::Evaluation> &evals, PFT::Evaluation &e,
                      const A &iter, const A &endif) {
     A i{iter};
     A j{nextFalseTarget(++i, endif)};
-    auto *cstr = std::get<AST::Evaluation *>(e.parent);
-    AST::CGJump jump{&*endif};
-    A k{evals.insert(j, AST::Evaluation{std::move(jump), j->parent})};
+    auto *cstr = std::get<PFT::Evaluation *>(e.parent);
+    PFT::CGJump jump{&*endif};
+    A k{evals.insert(j, PFT::Evaluation{std::move(jump), j->parent})};
     if (i == j) {
       // block was empty, so adjust "true" target
       i = k;
@@ -193,44 +193,44 @@ class CfgBuilder {
 
   /// Determine which branch targets are reachable. The target map must
   /// already be initialized.
-  void reachabilityAnalysis(std::list<AST::Evaluation> &evals) {
+  void reachabilityAnalysis(std::list<PFT::Evaluation> &evals) {
     for (auto iter = evals.begin(); iter != evals.end(); ++iter) {
       auto &e = *iter;
       switch (e.cfg) {
-      case AST::CFGAnnotation::None:
+      case PFT::CFGAnnotation::None:
         // do nothing - does not impart control flow
         break;
-      case AST::CFGAnnotation::Goto:
+      case PFT::CFGAnnotation::Goto:
         std::visit(
             Co::visitors{
                 [&](const Pa::CycleStmt *) {
                   // FIXME: deal with construct name
-                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  auto *cstr = std::get<PFT::Evaluation *>(e.parent);
                   addSourceToSink(&e, &cstr->subs->front());
                 },
                 [&](const Pa::ExitStmt *) {
                   // FIXME: deal with construct name
-                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
+                  auto *cstr = std::get<PFT::Evaluation *>(e.parent);
                   addSourceToSink(&e, &cstr->subs->back());
                 },
                 [&](const Pa::GotoStmt *stmt) { addSourceToSink(&e, stmt->v); },
                 [&](const Pa::EndDoStmt *) {
                   // the END DO is the loop exit landing pad
                   // insert a JUMP as the backedge right before the END DO
-                  auto *cstr = std::get<AST::Evaluation *>(e.parent);
-                  AST::CGJump jump{&cstr->subs->front()};
-                  AST::Evaluation jumpEval{std::move(jump), iter->parent};
+                  auto *cstr = std::get<PFT::Evaluation *>(e.parent);
+                  PFT::CGJump jump{&cstr->subs->front()};
+                  PFT::Evaluation jumpEval{std::move(jump), iter->parent};
                   evals.insert(iter, std::move(jumpEval));
                   addSourceToSink(&e, &cstr->subs->front());
                 },
-                [&](const AST::CGJump &jump) {
+                [&](const PFT::CGJump &jump) {
                   addSourceToSink(&e, jump.target);
                 },
                 [](auto) { assert(false && "unhandled GOTO case"); },
             },
             e.u);
         break;
-      case AST::CFGAnnotation::CondGoto:
+      case PFT::CFGAnnotation::CondGoto:
         std::visit(Co::visitors{
                        [&](const Pa::IfStmt *) {
                          // check if these are marked; they must targets here
@@ -250,7 +250,7 @@ class CfgBuilder {
                    },
                    e.u);
         break;
-      case AST::CFGAnnotation::IndGoto:
+      case PFT::CFGAnnotation::IndGoto:
         std::visit(Co::visitors{
                        [&](const Pa::AssignedGotoStmt *stmt) {
                          auto *sym = std::get<Pa::Name>(stmt->t).symbol;
@@ -267,7 +267,7 @@ class CfgBuilder {
                    },
                    e.u);
         break;
-      case AST::CFGAnnotation::IoSwitch:
+      case PFT::CFGAnnotation::IoSwitch:
         std::visit(
             Co::visitors{
                 [](const Pa::BackspaceStmt *) { TODO(); },
@@ -284,7 +284,7 @@ class CfgBuilder {
             },
             e.u);
         break;
-      case AST::CFGAnnotation::Switch:
+      case PFT::CFGAnnotation::Switch:
         std::visit(Co::visitors{
                        [](const Pa::CallStmt *) { TODO(); },
                        [](const Pa::ArithmeticIfStmt *) { TODO(); },
@@ -296,7 +296,7 @@ class CfgBuilder {
                    },
                    e.u);
         break;
-      case AST::CFGAnnotation::Iterative:
+      case PFT::CFGAnnotation::Iterative:
         std::visit(Co::visitors{
                        [](const Pa::NonLabelDoStmt *) { TODO(); },
                        [](const Pa::WhereStmt *) { TODO(); },
@@ -307,13 +307,13 @@ class CfgBuilder {
                    },
                    e.u);
         break;
-      case AST::CFGAnnotation::FirStructuredOp:
+      case PFT::CFGAnnotation::FirStructuredOp:
         // do not visit the subs
         continue;
-      case AST::CFGAnnotation::Return:
+      case PFT::CFGAnnotation::Return:
         // do nothing - exits the function
         break;
-      case AST::CFGAnnotation::Terminate:
+      case PFT::CFGAnnotation::Terminate:
         // do nothing - exits the function
         break;
       }
@@ -323,7 +323,7 @@ class CfgBuilder {
     }
   }
 
-  void setActualTargets(std::list<AST::Evaluation> &) {
+  void setActualTargets(std::list<PFT::Evaluation> &) {
     for (auto &lst1 : cfgEdgeSetPool)
       for (auto *e : lst1) {
         e->isTarget = true;
@@ -333,14 +333,14 @@ class CfgBuilder {
   CFGMapType &cfgMap;
   std::list<CFGSinkListType> &cfgEdgeSetPool;
 
-  L::DenseMap<Pa::Label, AST::Evaluation *> labels;
-  std::map<Se::Symbol *, std::list<AST::Evaluation *>> assignedGotoMap;
+  L::DenseMap<Pa::Label, PFT::Evaluation *> labels;
+  std::map<Se::Symbol *, std::list<PFT::Evaluation *>> assignedGotoMap;
 
 public:
   CfgBuilder(CFGMapType &m, std::list<CFGSinkListType> &p)
       : cfgMap{m}, cfgEdgeSetPool{p} {}
 
-  void run(AST::FunctionLikeUnit &func) {
+  void run(PFT::FunctionLikeUnit &func) {
     resetPotentialTargets(func.evals);
     cacheAssigns(func.evals);
     wrapIterationSpaces(func.evals);
diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
index 1603cc173297..5fa8e22f4b92 100644
--- a/lib/lower/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -1,21 +1,22 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wno-unused-parameter")
 
 add_library(FortranLower
-  ASTBuilder.cpp
   Bridge.cpp
-  OpBuilder.cpp
   ConvertExpr.cpp
   ConvertType.cpp
   Intrinsics.cpp
+  IO.cpp
   Mangler.cpp
+  OpBuilder.cpp
+  PFTBuilder.cpp
   Runtime.cpp
-  IO.cpp
 )
 
 target_link_libraries(FortranLower
   FIR
   MLIRAffineOps
   MLIRLLVMIR
+  MLIRLoopToStandard
   MLIRStandardOps
 )
 
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 4c827a7ceb3e..135e1fedf789 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/ConvertExpr.h"
+#include "NSAliases.h"
 #include "fir/Dialect/FIRDialect.h"
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
@@ -36,14 +37,6 @@
 #include "llvm/IR/Type.h"
 #include "llvm/Support/raw_ostream.h"
 
-namespace Br = Fortran::lower;
-namespace Co = Fortran::common;
-namespace Ev = Fortran::evaluate;
-namespace L = llvm;
-namespace M = mlir;
-namespace Pa = Fortran::parser;
-namespace Se = Fortran::semantics;
-
 using namespace Fortran;
 using namespace Fortran::lower;
 
@@ -53,7 +46,7 @@ namespace {
   assert(false);                                                               \
   return {}
 
-/// Lowering of Fortran::evaluate::Expr<T> expressions
+/// Lowering of Ev::Expr<T> expressions
 class ExprLowering {
   M::Location location;
   AbstractConverter &converter;
@@ -222,7 +215,7 @@ class ExprLowering {
     auto type{addr.getType()};
     if (auto boxCharType{type.dyn_cast<fir::BoxCharType>()}) {
       auto refType{fir::ReferenceType::get(boxCharType.getEleTy())};
-      auto lenType{mlir::IntegerType::get(64, builder.getContext())};
+      auto lenType{M::IntegerType::get(64, builder.getContext())};
       addr = builder.create<fir::UnboxCharOp>(getLoc(), refType, lenType, addr)
                  .getResult(0);
     } else if (type.isa<fir::BoxType>()) {
@@ -249,14 +242,14 @@ class ExprLowering {
   M::Value genval(Ev::ImpliedDoIndex const &) { TODO(); }
   M::Value genval(Ev::DescriptorInquiry const &desc) {
     auto descRef{symMap.lookupSymbol(desc.base().GetLastSymbol())};
-    assert(descRef && "no mlir::Value associated to Symbol");
+    assert(descRef && "no M::Value associated to Symbol");
     auto descType{descRef.getType()};
     M::Value res{};
     switch (desc.field()) {
     case Ev::DescriptorInquiry::Field::Len:
       if (auto boxCharType{descType.dyn_cast<fir::BoxCharType>()}) {
         auto refType{fir::ReferenceType::get(boxCharType.getEleTy())};
-        auto lenType{mlir::IntegerType::get(64, builder.getContext())};
+        auto lenType{M::IntegerType::get(64, builder.getContext())};
         res = builder
                   .create<fir::UnboxCharOp>(getLoc(), refType, lenType, descRef)
                   .getResult(1);
@@ -344,8 +337,7 @@ class ExprLowering {
   }
   template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Power<Ev::Type<TC, KIND>> const &op) {
-    llvm::SmallVector<mlir::Value, 2> operands{genval(op.left()),
-                                               genval(op.right())};
+    L::SmallVector<M::Value, 2> operands{genval(op.left()), genval(op.right())};
     M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
@@ -353,8 +345,7 @@ class ExprLowering {
   M::Value genval(Ev::RealToIntPower<Ev::Type<TC, KIND>> const &op) {
     // TODO: runtime as limited integer kind support. Look if the conversions
     // are ok
-    llvm::SmallVector<mlir::Value, 2> operands{genval(op.left()),
-                                               genval(op.right())};
+    L::SmallVector<M::Value, 2> operands{genval(op.left()), genval(op.right())};
     M::Type ty{converter.genType(TC, KIND)};
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
@@ -385,7 +376,7 @@ class ExprLowering {
 
   template <Co::TypeCategory TC, int KIND>
   M::Value genval(Ev::Relational<Ev::Type<TC, KIND>> const &op) {
-    mlir::Value result{nullptr};
+    M::Value result{nullptr};
     if constexpr (TC == IntegerCat) {
       result = createCompareOp<M::CmpIOp>(op, translateRelational(op.opr));
     } else if constexpr (TC == RealCat) {
@@ -428,7 +419,7 @@ class ExprLowering {
   template <int KIND>
   M::Value genval(const Ev::Not<KIND> &op) {
     // Request operands to be generated as `i1` and restore after this scope.
-    auto restorer{common::ScopedSet(genLogicalAsI1, true)};
+    auto restorer{Co::ScopedSet(genLogicalAsI1, true)};
     auto *context{builder.getContext()};
     auto logical{genval(op.left())};
     auto one{genLogicalConstantAsI1(context, true)};
@@ -438,8 +429,8 @@ class ExprLowering {
   template <int KIND>
   M::Value genval(Ev::LogicalOperation<KIND> const &op) {
     // Request operands to be generated as `i1` and restore after this scope.
-    auto restorer{common::ScopedSet(genLogicalAsI1, true)};
-    mlir::Value result;
+    auto restorer{Co::ScopedSet(genLogicalAsI1, true)};
+    M::Value result;
     switch (op.logicalOperator) {
     case Ev::LogicalOperator::And:
       result = createBinaryOp<M::AndOp>(op);
@@ -454,7 +445,7 @@ class ExprLowering {
       result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::ne);
       break;
     case Ev::LogicalOperator::Not:
-      // lib/evaluate expression for .NOT. is evaluate::Not<KIND>.
+      // lib/evaluate expression for .NOT. is Ev::Not<KIND>.
       assert(false && ".NOT. is not a binary operator");
       break;
     }
@@ -655,7 +646,7 @@ class ExprLowering {
   M::Value gen(Ev::ArrayRef const &aref) {
     M::Value base = aref.base().IsSymbol() ? gen(aref.base().GetFirstSymbol())
                                            : gen(aref.base().GetComponent());
-    llvm::SmallVector<M::Value, 8> args;
+    L::SmallVector<M::Value, 8> args;
     for (auto &subsc : aref.subscript()) {
       args.push_back(genval(subsc));
     }
@@ -718,7 +709,7 @@ class ExprLowering {
       // conversions (e.g scalar MASK of MERGE will be converted to `i1`), but
       // the generated code is at least correct. To improve this, the intrinsic
       // lowering facility should control argument lowering.
-      auto restorer{common::ScopedSet(genLogicalAsI1, false)};
+      auto restorer{Co::ScopedSet(genLogicalAsI1, false)};
       for (const auto &arg : funRef.arguments()) {
         if (auto *expr{Ev::UnwrapExpr<Ev::Expr<Ev::SomeType>>(arg)}) {
           operands.push_back(genval(*expr));
@@ -736,7 +727,7 @@ class ExprLowering {
       L::SmallVector<M::Value, 2> operands;
       // Logical arguments of user functions must be lowered to `fir.logical`
       // and not `i1`.
-      auto restorer{common::ScopedSet(genLogicalAsI1, false)};
+      auto restorer{Co::ScopedSet(genLogicalAsI1, false)};
       for (const auto &arg : funRef.arguments()) {
         assert(arg.has_value() &&
                "optional argument requires explicit interface");
diff --git a/lib/lower/ConvertType.cpp b/lib/lower/ConvertType.cpp
index 5d6b80d5c9c3..cf25ca3e4da5 100644
--- a/lib/lower/ConvertType.cpp
+++ b/lib/lower/ConvertType.cpp
@@ -8,6 +8,7 @@
 
 #include "flang/lower/ConvertType.h"
 #include "../../runtime/io-api.h"
+#include "NSAliases.h"
 #include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/Utils.h"
@@ -19,13 +20,6 @@
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 
-namespace Br = Fortran::lower;
-namespace Co = Fortran::common;
-namespace Ev = Fortran::evaluate;
-namespace M = mlir;
-namespace Pa = Fortran::parser;
-namespace Se = Fortran::semantics;
-
 using namespace Fortran;
 using namespace Fortran::lower;
 
@@ -161,8 +155,8 @@ M::Type genFIRType<ComplexCat>(M::MLIRContext *context, int KIND) {
   return {};
 }
 
-/// Recover the type of an evaluate::Expr<T> and convert it to an
-/// mlir::Type. The type returned can be a MLIR standard or FIR type.
+/// Recover the type of an Ev::Expr<T> and convert it to an
+/// M::Type. The type returned can be a MLIR standard or FIR type.
 class TypeBuilder {
   M::MLIRContext *context;
   Co::IntrinsicTypeDefaultKinds const &defaults;
@@ -173,11 +167,11 @@ class TypeBuilder {
   }
   int defaultKind(Co::TypeCategory TC) { return defaults.GetDefaultKind(TC); }
 
-  M::InFlightDiagnostic emitError(const llvm::Twine &message) {
+  M::InFlightDiagnostic emitError(const L::Twine &message) {
     return M::emitError(M::UnknownLoc::get(context), message);
   }
 
-  M::InFlightDiagnostic emitWarning(const llvm::Twine &message) {
+  M::InFlightDiagnostic emitWarning(const L::Twine &message) {
     return M::emitWarning(M::UnknownLoc::get(context), message);
   }
 
@@ -307,8 +301,8 @@ class TypeBuilder {
   }
 
   M::FunctionType genFunctionType(Se::SymbolRef symbol) {
-    llvm::SmallVector<M::Type, 1> returnTys;
-    llvm::SmallVector<M::Type, 4> inputTys;
+    L::SmallVector<M::Type, 1> returnTys;
+    L::SmallVector<M::Type, 4> inputTys;
     if (auto *proc = symbol->detailsIf<Se::SubprogramDetails>()) {
       if (proc->isFunction()) {
         returnTys.emplace_back(gen(proc->result()));
@@ -321,7 +315,7 @@ class TypeBuilder {
         }
       }
     } else if (symbol->detailsIf<Se::ProcEntityDetails>()) {
-      // TODO Should probably use evaluate::Characteristics for that.
+      // TODO Should probably use Ev::Characteristics for that.
       TODO();
     } else {
       assert(false && "unexpected symbol details for function");
@@ -488,80 +482,3 @@ M::Type Br::getSequenceRefType(M::Type refType) {
   fir::SequenceType::Shape shape{fir::SequenceType::getUnknownExtent()};
   return fir::ReferenceType::get(fir::SequenceType::get(shape, elementType));
 }
-
-// Models of C (language) types. These models are used to construct the FIR
-// signatures of runtime support routines.
-
-mlir::Type Br::getModelForInt(mlir::MLIRContext *context) {
-  return mlir::IntegerType::get(8 * sizeof(int), context);
-}
-
-mlir::Type Br::getModelForIntRef(mlir::MLIRContext *context) {
-  return fir::ReferenceType::get(getModelForInt(context));
-}
-
-mlir::Type Br::getModelForIostat(mlir::MLIRContext *context) {
-  return mlir::IntegerType::get(8 * sizeof(runtime::io::Iostat), context);
-}
-
-mlir::Type Br::getModelForCharPtr(mlir::MLIRContext *context) {
-  return fir::ReferenceType::get(mlir::IntegerType::get(8, context));
-}
-
-mlir::Type Br::getModelForConstCharPtr(mlir::MLIRContext *context) {
-  return getModelForCharPtr(context);
-}
-
-mlir::Type Br::getModelForInt64(mlir::MLIRContext *context) {
-  return mlir::IntegerType::get(64, context);
-}
-
-mlir::Type Br::getModelForInt64Ref(mlir::MLIRContext *context) {
-  return fir::ReferenceType::get(getModelForInt64(context));
-}
-
-mlir::Type Br::getModelForSize(mlir::MLIRContext *context) {
-  return mlir::IntegerType::get(8 * sizeof(std::size_t), context);
-}
-
-mlir::Type Br::getModelForCookie(mlir::MLIRContext *context) {
-  return fir::ReferenceType::get(mlir::IntegerType::get(8, context));
-}
-
-mlir::Type Br::getModelForDouble(mlir::MLIRContext *context) {
-  return mlir::FloatType::getF64(context);
-}
-
-mlir::Type Br::getModelForDoubleRef(mlir::MLIRContext *context) {
-  return fir::ReferenceType::get(getModelForDouble(context));
-}
-
-mlir::Type Br::getModelForFloat(mlir::MLIRContext *context) {
-  return mlir::FloatType::getF32(context);
-}
-
-mlir::Type Br::getModelForFloatRef(mlir::MLIRContext *context) {
-  return fir::ReferenceType::get(getModelForFloat(context));
-}
-
-mlir::Type Br::getModelForBool(mlir::MLIRContext *context) {
-  return mlir::IntegerType::get(1, context);
-}
-
-mlir::Type Br::getModelForBoolRef(mlir::MLIRContext *context) {
-  return fir::ReferenceType::get(getModelForBool(context));
-}
-
-mlir::Type Br::getModelForDescriptor(mlir::MLIRContext *context) {
-  return fir::BoxType::get(mlir::NoneType::get(context));
-}
-
-mlir::Type Br::getModelForNamelistGroup(mlir::MLIRContext *context) {
-  // FIXME: a namelist group must be some well-defined data structure, use a
-  // tuple as a proxy for the moment
-  return mlir::TupleType::get(llvm::None, context);
-}
-
-mlir::Type Br::getModelForVoid(mlir::MLIRContext *context) {
-  return mlir::NoneType::get(context);
-}
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index ef0cf617ea45..cadb17e37f2b 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -82,81 +82,6 @@ static constexpr FuncTypeBuilderFunc getTypeModel() {
   return std::get<A>(newIOTable).getTypeModel();
 }
 
-/// Define actions to sort runtime functions. One actions
-/// may be associated to one or more runtime function.
-/// Actions are the keys in the StaticMultimapView used to
-/// hold the io runtime description in a static constexpr way.
-enum class IOAction { BeginExternalList, Output, EndIO };
-
-class IORuntimeDescription : public RuntimeStaticDescription {
-public:
-  using Key = IOAction;
-  constexpr IORuntimeDescription(IOAction act, const char *s, MaybeTypeCode r,
-                                 TypeCodeVector a)
-      : RuntimeStaticDescription{s, r, a}, key{act} {}
-  static M::Type getIOCookieType(M::MLIRContext *context) {
-    return getMLIRType(TypeCode::IOCookie, context);
-  }
-  IOAction key;
-};
-
-using IORuntimeMap = StaticMultimapView<IORuntimeDescription>;
-
-using RT = RuntimeStaticDescription;
-using RType = typename RT::TypeCode;
-using Args = typename RT::TypeCodeVector;
-using IOA = IOAction;
-
-/// This is were the IO runtime are to be described.
-/// The array need to be sorted on the Actions.
-/// Experimental runtime for now.
-static constexpr IORuntimeDescription ioRuntimeTable[]{
-    {IOA::BeginExternalList, NAMIFY(BeginExternalListOutput), RType::IOCookie,
-     Args::create<RType::i32>()},
-    {IOA::Output, NAMIFY(OutputInteger64), RT::voidTy,
-     Args::create<RType::IOCookie, RType::i64>()},
-    {IOA::Output, NAMIFY(OutputReal64), RT::voidTy,
-     Args::create<RType::IOCookie, RType::f64>()},
-    {IOA::EndIO, NAMIFY(EndIOStatement), RT::voidTy,
-     Args::create<RType::IOCookie>()},
-};
-
-static constexpr IORuntimeMap ioRuntimeMap{ioRuntimeTable};
-
-/// This helper can be used to access io runtime functions that
-/// are mapped to an IOAction that must be mapped to one and
-/// exactly one runtime function. This constraint is enforced
-/// at compile time. This search is resolved at compile time.
-template <IORuntimeDescription::Key key>
-static M::FuncOp getIORuntimeFunction(M::OpBuilder &builder) {
-  static constexpr auto runtimeDescription{ioRuntimeMap.find(key)};
-  static_assert(runtimeDescription != ioRuntimeMap.end());
-  return runtimeDescription->getFuncOp(builder);
-}
-
-/// This helper can be used to access io runtime functions that
-/// are mapped to Output IOAction that must be mapped to at least one
-/// runtime function but can be mapped to more functions.
-/// This helper returns the function that has the same
-/// M::FunctionType as the one seeked. It may therefore dynamically fail
-/// if no function mapped to the Action has the seeked M::FunctionType.
-static M::FuncOp getOutputRuntimeFunction(M::OpBuilder &builder, M::Type type) {
-  static constexpr auto descriptionRange{ioRuntimeMap.getRange(IOA::Output)};
-  static_assert(!descriptionRange.empty());
-
-  M::MLIRContext *context{getModule(&builder).getContext()};
-  L::SmallVector<M::Type, 2> argTypes{
-      IORuntimeDescription::getIOCookieType(context), type};
-
-  M::FunctionType seekedType{M::FunctionType::get(argTypes, {}, context)};
-  for (const auto &description : descriptionRange) {
-    if (description.getMLIRFunctionType(context) == seekedType)
-      return description.getFuncOp(builder);
-  }
-  assert(false && "IO output runtime function not defined for this type");
-  return {};
-}
-
 /// Get (or generate) the MLIR FuncOp for a given IO runtime function. This
 /// replaces getIORuntimeFunction.
 template <typename E>
@@ -176,41 +101,137 @@ M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
 /// Generate a call to end an IO statement
 M::Value genEndIO(M::OpBuilder &builder, M::Location loc, M::Value cookie) {
   // Terminate IO
-  M::FuncOp endIOFunc{getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder)};
+  M::FuncOp endIOFunc = getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder);
   L::SmallVector<M::Value, 1> endArgs{cookie};
-  return builder.create<M::CallOp>(loc, endIOFunc, endArgs).getResult(0);
+  auto call = builder.create<M::CallOp>(loc, endIOFunc, endArgs);
+  return call.getResult(0);
+}
+
+using FormatItems = std::optional<std::pair<M::Value, M::Value>>;
+
+/// Translate a list of format-items into a set of call-backs that can be
+/// emitted into the MLIR stream before each data item is processed
+FormatItems lowerFormat(AbstractConverter &converter,
+                        const Pa::Format &format) {
+  FormatItems formatItems;
+  std::visit(Co::visitors{
+                 [](const Pa::DefaultCharExpr &) { /* string expression */ },
+                 [](const Pa::Label &) { /* FORMAT statement */ },
+                 [](const Pa::Star &) {},
+             },
+             format.u);
+  return formatItems;
+}
+
+M::FuncOp getOutputRuntimeFunc(M::OpBuilder &builder, M::Type type) {
+  if (auto ty = type.dyn_cast<M::IntegerType>()) {
+    if (ty.getWidth() == 1)
+      return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
+    return getIORuntimeFunc<mkIOKey(OutputInteger64)>(builder);
+  } else if (auto ty = type.dyn_cast<M::FloatType>()) {
+    if (ty.getWidth() <= 32)
+      return getIORuntimeFunc<mkIOKey(OutputReal32)>(builder);
+    return getIORuntimeFunc<mkIOKey(OutputReal64)>(builder);
+  } else if (auto ty = type.dyn_cast<fir::CplxType>()) {
+    if (ty.getFKind() <= 4)
+      return getIORuntimeFunc<mkIOKey(OutputComplex32)>(builder);
+    return getIORuntimeFunc<mkIOKey(OutputComplex64)>(builder);
+  } else if (auto ty = type.dyn_cast<fir::LogicalType>()) {
+    return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
+  } else if (auto ty = type.dyn_cast<fir::BoxType>()) {
+    return getIORuntimeFunc<mkIOKey(OutputDescriptor)>(builder);
+  } else {
+    return getIORuntimeFunc<mkIOKey(OutputAscii)>(builder);
+  }
+}
+
+/// The I/O library interface requires that COMPLEX and CHARACTER typed values
+/// be extracted and passed as separate values.
+L::SmallVector<M::Value, 4> splitArguments(M::OpBuilder &builder,
+                                           M::Location loc, M::Value arg) {
+  M::Value zero;
+  M::Value one;
+  M::Type argTy = arg.getType();
+  M::MLIRContext *context = argTy.getContext();
+  bool isComplex = argTy.isa<fir::CplxType>();
+  bool isBoxChar = argTy.isa<fir::BoxCharType>();
+
+  if (isComplex || isBoxChar) {
+    // Only create these constants when needed and not every time
+    zero = builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(0));
+    one = builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(1));
+  }
+  if (isComplex) {
+    auto eleTy =
+        fir::RealType::get(context, argTy.cast<fir::CplxType>().getFKind());
+    M::Value realPart =
+        builder.create<fir::ExtractValueOp>(loc, eleTy, arg, zero);
+    M::Value imaginaryPart =
+        builder.create<fir::ExtractValueOp>(loc, eleTy, arg, one);
+    return {realPart, imaginaryPart};
+  }
+  if (isBoxChar) {
+    M::Type ptrTy = fir::ReferenceType::get(M::IntegerType::get(8, context));
+    M::Type sizeTy = M::IntegerType::get(64, context);
+    M::Value pointerPart =
+        builder.create<fir::ExtractValueOp>(loc, ptrTy, arg, zero);
+    M::Value sizePart =
+        builder.create<fir::ExtractValueOp>(loc, sizeTy, arg, one);
+    return {pointerPart, sizePart};
+  }
+  return {arg};
+}
+
+/// Generate a call to an Output I/O function.
+/// The specific call is determined dynamically by the argument type.
+void genOutputRuntimeFunc(M::OpBuilder &builder, M::Location loc,
+                          M::Type argType, M::Value cookie,
+                          L::SmallVector<M::Value, 4> &operands) {
+  int i = 1;
+  L::SmallVector<M::Value, 4> actuals{cookie};
+  auto outputFunc = getOutputRuntimeFunc(builder, argType);
+
+  for (auto &op : operands)
+    actuals.emplace_back(builder.create<fir::ConvertOp>(
+        loc, outputFunc.getType().getInput(i++), op));
+  builder.create<M::CallOp>(loc, outputFunc, actuals);
 }
 
 /// Lower print statement assuming a dummy runtime interface for now.
-void lowerPrintStatement(M::OpBuilder &builder, M::Location loc, int format,
-                         M::ValueRange args) {
-  M::FuncOp beginFunc =
-      getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
+void lowerPrintStatement(AbstractConverter &converter, M::Location loc,
+                         M::ValueRange args, const Pa::Format &format) {
+  M::FuncOp beginFunc;
+  M::OpBuilder &builder = converter.getOpBuilder();
+  auto formatItems = lowerFormat(converter, format);
+  if (formatItems.has_value()) {
+    // has a format
+    TODO();
+  } else {
+    beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
+  }
+  M::FunctionType beginFuncTy = beginFunc.getType();
 
   // Initiate io
-  M::Type externalUnitType{builder.getIntegerType(32)};
-  M::Value defaultUnit{builder.create<M::ConstantOp>(
-      loc, builder.getIntegerAttr(externalUnitType, 1))};
-  L::SmallVector<M::Value, 1> beginArgs{defaultUnit};
-  M::Value cookie{
-      builder.create<M::CallOp>(loc, beginFunc, beginArgs).getResult(0)};
+  M::Value defaultUnit = builder.create<M::ConstantOp>(
+      loc, builder.getIntegerAttr(beginFuncTy.getInput(0), 1));
+  M::Value null =
+      builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(0));
+  M::Value srcFileName =
+      builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(1), null);
+  M::Value lineNo = builder.create<M::ConstantOp>(
+      loc, builder.getIntegerAttr(beginFuncTy.getInput(2), 0));
+  L::SmallVector<M::Value, 3> beginArgs{defaultUnit, srcFileName, lineNo};
+  M::Value cookie =
+      builder.create<M::CallOp>(loc, beginFunc, beginArgs).getResult(0);
 
   // Call data transfer runtime function
   for (M::Value arg : args) {
-    // FIXME: this loop is still using the older table
-    L::SmallVector<M::Value, 1> operands{cookie, arg};
-    M::FuncOp outputFunc{getOutputRuntimeFunction(builder, arg.getType())};
-    builder.create<M::CallOp>(loc, outputFunc, operands);
+    auto operands = splitArguments(builder, loc, arg);
+    genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
   }
   genEndIO(builder, loc, cookie);
 }
 
-int lowerFormat(const Pa::Format &format) {
-  /// FIXME: this is a stub; process the format and return it
-  return {};
-  TODO();
-}
-
 L::SmallVector<M::Value, 4>
 lowerBeginArgsPositionOrFlush(AbstractConverter &converter, M::Location loc,
                               const std::list<Pa::PositionOrFlushSpec> &specs) {
@@ -218,7 +239,7 @@ lowerBeginArgsPositionOrFlush(AbstractConverter &converter, M::Location loc,
   // 1. find the unit number expression and append it
   for (auto &sp : specs)
     if (auto *un = std::get_if<Pa::FileUnitNumber>(&sp.u)) {
-      auto *expr{semantics::GetExpr(un->v)};
+      auto *expr{Se::GetExpr(un->v)};
       args.push_back(converter.genExprValue(expr, loc));
       break;
     }
@@ -250,7 +271,7 @@ M::Value lowerErrorHandlingPositionOrFlush(
               M::FuncOp getIoMsg = getIORuntimeFunc<mkIOKey(GetIoMsg)>(builder);
               L::SmallVector<M::Value, 1> ioMsgArgs{
                   builder.create<fir::ConvertOp>(
-                      loc, getModelForCharPtr(builder.getContext()), varAddr)
+                      loc, getModel<char *>()(builder.getContext()), varAddr)
                   /*, FIXME add length here */};
               builder.create<M::CallOp>(loc, getIoMsg, ioMsgArgs);
             },
@@ -320,11 +341,12 @@ M::Value genCloseStatement(AbstractConverter &converter,
                            const Pa::CloseStmt &) {
   auto builder = converter.getOpBuilder();
   M::FuncOp beginFunc{getIORuntimeFunc<mkIOKey(BeginClose)>(builder)};
+  (void)beginFunc;
   TODO();
   return {};
 }
 
-void genPrintStatement(Br::AbstractConverter &converter,
+void genPrintStatement(AbstractConverter &converter,
                        const Pa::PrintStmt &stmt) {
   L::SmallVector<M::Value, 4> args;
   for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
@@ -335,8 +357,8 @@ void genPrintStatement(Br::AbstractConverter &converter,
       TODO(); // TODO implied do
     }
   }
-  lowerPrintStatement(converter.getOpBuilder(), converter.getCurrentLocation(),
-                      lowerFormat(std::get<Pa::Format>(stmt.t)), args);
+  lowerPrintStatement(converter, converter.getCurrentLocation(), args,
+                      std::get<Pa::Format>(stmt.t));
 }
 
 M::Value genReadStatement(AbstractConverter &converter, const Pa::ReadStmt &) {
diff --git a/lib/lower/Intrinsics.cpp b/lib/lower/Intrinsics.cpp
index ecc30ff43116..1a640b0675e6 100644
--- a/lib/lower/Intrinsics.cpp
+++ b/lib/lower/Intrinsics.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Intrinsics.h"
+#include "NSAliases.h"
 #include "fir/Dialect/FIROps.h"
 #include "fir/Dialect/FIRType.h"
 #include "flang/lower/ConvertType.h"
@@ -21,9 +22,6 @@
 
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-namespace L = llvm;
-namespace M = mlir;
-
 namespace Fortran::lower {
 
 /// MathRuntimeLibrary maps Fortran generic intrinsic names to runtime function
diff --git a/lib/lower/Mangler.cpp b/lib/lower/Mangler.cpp
index 8f68134ee029..87c718bb4330 100644
--- a/lib/lower/Mangler.cpp
+++ b/lib/lower/Mangler.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Mangler.h"
+#include "NSAliases.h"
 #include "fir/InternalNames.h"
 #include "flang/common/reference.h"
 #include "flang/lower/Utils.h"
@@ -16,12 +17,6 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
 
-namespace Br = Fortran::lower;
-namespace Co = Fortran::common;
-namespace L = llvm;
-namespace Ma = Fortran::lower::mangle;
-namespace Se = Fortran::semantics;
-
 using namespace Fortran;
 
 namespace {
diff --git a/lib/lower/OpBuilder.cpp b/lib/lower/OpBuilder.cpp
index 40b53b0d5e18..4c1d338feb4a 100644
--- a/lib/lower/OpBuilder.cpp
+++ b/lib/lower/OpBuilder.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/OpBuilder.h"
+#include "NSAliases.h"
 #include "fir/Dialect/FIROpsSupport.h"
 #include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
@@ -15,44 +16,39 @@
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/StringRef.h"
 
-namespace Br = Fortran::lower;
-namespace Ev = Fortran::evaluate;
-namespace Se = Fortran::semantics;
-
 using namespace Fortran;
 using namespace Fortran::lower;
 
-mlir::FuncOp Br::createFunction(Br::AbstractConverter &converter,
-                                llvm::StringRef name,
-                                mlir::FunctionType funcTy) {
+M::FuncOp Br::createFunction(Br::AbstractConverter &converter,
+                             L::StringRef name, M::FunctionType funcTy) {
   return fir::createFuncOp(converter.getCurrentLocation(),
                            converter.getModuleOp(), name, funcTy);
 }
 
-mlir::FuncOp Br::createFunction(mlir::ModuleOp module, llvm::StringRef name,
-                                mlir::FunctionType funcTy) {
-  return fir::createFuncOp(mlir::UnknownLoc::get(module.getContext()), module,
+M::FuncOp Br::createFunction(M::ModuleOp module, L::StringRef name,
+                             M::FunctionType funcTy) {
+  return fir::createFuncOp(M::UnknownLoc::get(module.getContext()), module,
                            name, funcTy);
 }
 
-mlir::FuncOp Br::getNamedFunction(mlir::ModuleOp module, llvm::StringRef name) {
-  return module.lookupSymbol<mlir::FuncOp>(name);
+M::FuncOp Br::getNamedFunction(M::ModuleOp module, L::StringRef name) {
+  return module.lookupSymbol<M::FuncOp>(name);
 }
 
-void Br::SymMap::addSymbol(Se::SymbolRef symbol, mlir::Value value) {
+void Br::SymMap::addSymbol(Se::SymbolRef symbol, M::Value value) {
   symbolMap.try_emplace(&*symbol, value);
 }
 
-mlir::Value Br::SymMap::lookupSymbol(Se::SymbolRef symbol) {
+M::Value Br::SymMap::lookupSymbol(Se::SymbolRef symbol) {
   auto iter{symbolMap.find(&*symbol)};
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
 
-void Br::SymMap::pushShadowSymbol(Se::SymbolRef symbol, mlir::Value value) {
+void Br::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
   // find any existing mapping for symbol
   auto iter{symbolMap.find(&*symbol)};
   const Se::Symbol *sym{nullptr};
-  mlir::Value val;
+  M::Value val;
   // if mapping exists, save it on the shadow stack
   if (iter != symbolMap.end()) {
     sym = iter->first;
@@ -66,20 +62,19 @@ void Br::SymMap::pushShadowSymbol(Se::SymbolRef symbol, mlir::Value value) {
   (void)r;
 }
 
-mlir::Value Br::OpBuilderWrapper::createIntegerConstant(mlir::Type integerType,
-                                                        std::int64_t cst) {
-  return create<mlir::ConstantOp>(integerType,
-                                  builder.getIntegerAttr(integerType, cst));
+M::Value Br::OpBuilderWrapper::createIntegerConstant(M::Type integerType,
+                                                     std::int64_t cst) {
+  return create<M::ConstantOp>(integerType,
+                               builder.getIntegerAttr(integerType, cst));
 }
 
 // LoopBuilder implementation
 
-void Br::LoopBuilder::createLoop(mlir::Value lb, mlir::Value ub,
-                                 mlir::Value step,
+void Br::LoopBuilder::createLoop(M::Value lb, M::Value ub, M::Value step,
                                  const BodyGenerator &bodyGenerator) {
   auto lbi{convertToIndexType(lb)};
   auto ubi{convertToIndexType(ub)};
-  llvm::SmallVector<mlir::Value, 1> steps;
+  L::SmallVector<M::Value, 1> steps;
   if (step) {
     auto stepi{convertToIndexType(step)};
     steps.emplace_back(stepi);
@@ -92,13 +87,13 @@ void Br::LoopBuilder::createLoop(mlir::Value lb, mlir::Value ub,
   builder.setInsertionPointToEnd(insPt);
 }
 
-void Br::LoopBuilder::createLoop(mlir::Value lb, mlir::Value ub,
+void Br::LoopBuilder::createLoop(M::Value lb, M::Value ub,
                                  const BodyGenerator &bodyGenerator) {
   auto one{createIntegerConstant(getIndexType(), 1)};
   createLoop(lb, ub, one, bodyGenerator);
 }
 
-void Br::LoopBuilder::createLoop(mlir::Value count,
+void Br::LoopBuilder::createLoop(M::Value count,
                                  const BodyGenerator &bodyGenerator) {
   auto indexType{getIndexType()};
   auto zero{createIntegerConstant(indexType, 0)};
@@ -106,16 +101,16 @@ void Br::LoopBuilder::createLoop(mlir::Value count,
   createLoop(zero, count, one, bodyGenerator);
 }
 
-mlir::Type Br::LoopBuilder::getIndexType() {
-  return mlir::IndexType::get(builder.getContext());
+M::Type Br::LoopBuilder::getIndexType() {
+  return M::IndexType::get(builder.getContext());
 }
 
-mlir::Value Br::LoopBuilder::convertToIndexType(mlir::Value integer) {
+M::Value Br::LoopBuilder::convertToIndexType(M::Value integer) {
   auto type{integer.getType()};
-  if (type.isa<mlir::IndexType>()) {
+  if (type.isa<M::IndexType>()) {
     return integer;
   }
-  assert((type.isa<mlir::IntegerType>() || type.isa<fir::IntType>()) &&
+  assert((type.isa<M::IntegerType>() || type.isa<fir::IntType>()) &&
          "expected integer");
   return create<fir::ConvertOp>(getIndexType(), integer);
 }
@@ -123,7 +118,7 @@ mlir::Value Br::LoopBuilder::convertToIndexType(mlir::Value integer) {
 // CharacterOpsBuilder implementation
 
 void Br::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
-                                         mlir::Value count) {
+                                         M::Value count) {
   auto refType{dest.getReferenceType()};
   // Cast to character sequence reference type for fir::CoordinateOp.
   auto sequenceType{getSequenceRefType(refType)};
@@ -131,7 +126,7 @@ void Br::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
   auto srcRef{create<fir::ConvertOp>(sequenceType, src.reference)};
 
   LoopBuilder{*this}.createLoop(count, [&](OpBuilderWrapper &handler,
-                                           mlir::Value index) {
+                                           M::Value index) {
     auto destAddr{handler.create<fir::CoordinateOp>(refType, destRef, index)};
     auto srcAddr{handler.create<fir::CoordinateOp>(refType, srcRef, index)};
     auto val{handler.create<fir::LoadOp>(srcAddr)};
@@ -139,29 +134,28 @@ void Br::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
   });
 }
 
-void Br::CharacterOpsBuilder::createPadding(CharValue &str, mlir::Value lower,
-                                            mlir::Value upper) {
+void Br::CharacterOpsBuilder::createPadding(CharValue &str, M::Value lower,
+                                            M::Value upper) {
   auto refType{str.getReferenceType()};
   auto sequenceType{getSequenceRefType(refType)};
   auto strRef{create<fir::ConvertOp>(sequenceType, str.reference)};
   auto blank{createBlankConstant(str.getCharacterType())};
 
   LoopBuilder{*this}.createLoop(
-      lower, upper, [&](OpBuilderWrapper &handler, mlir::Value index) {
+      lower, upper, [&](OpBuilderWrapper &handler, M::Value index) {
         auto strAddr{handler.create<fir::CoordinateOp>(refType, strRef, index)};
         handler.create<fir::StoreOp>(blank, strAddr);
       });
 }
 
-mlir::Value
-Br::CharacterOpsBuilder::createBlankConstant(fir::CharacterType type) {
-  auto byteTy{mlir::IntegerType::get(8, builder.getContext())};
+M::Value Br::CharacterOpsBuilder::createBlankConstant(fir::CharacterType type) {
+  auto byteTy{M::IntegerType::get(8, builder.getContext())};
   auto asciiSpace{createIntegerConstant(byteTy, 0x20)};
   return create<fir::ConvertOp>(type, asciiSpace);
 }
 
 Br::CharacterOpsBuilder::CharValue
-Br::CharacterOpsBuilder::createTemp(fir::CharacterType type, mlir::Value len) {
+Br::CharacterOpsBuilder::createTemp(fir::CharacterType type, M::Value len) {
   // FIXME Does this need to be emitted somewhere safe ?
   // convert-expr.cc generates alloca at the beginning of the mlir block.
   return CharValue{create<fir::AllocaOp>(type, len), len};
@@ -181,78 +175,73 @@ fir::CharacterType Br::CharacterOpsBuilder::CharValue::getCharacterType() {
 
 // ComplexOpsBuilder implementation
 
-mlir::Type Br::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
+M::Type Br::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
   return convertReal(builder.getContext(), complexKind);
 }
-mlir::Type Br::ComplexOpsBuilder::getComplexPartType(mlir::Type complexType) {
+M::Type Br::ComplexOpsBuilder::getComplexPartType(M::Type complexType) {
   return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
 }
-mlir::Type Br::ComplexOpsBuilder::getComplexPartType(mlir::Value cplx) {
+M::Type Br::ComplexOpsBuilder::getComplexPartType(M::Value cplx) {
   assert(cplx != nullptr);
   return getComplexPartType(cplx.getType());
 }
 
-mlir::Value Br::ComplexOpsBuilder::createComplex(fir::KindTy kind,
-                                                 mlir::Value real,
-                                                 mlir::Value imag) {
-  mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
-  mlir::Value und{create<fir::UndefOp>(complexTy)};
+M::Value Br::ComplexOpsBuilder::createComplex(fir::KindTy kind, M::Value real,
+                                              M::Value imag) {
+  M::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
+  M::Value und{create<fir::UndefOp>(complexTy)};
   return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
 }
 
 using CplxPart = Br::ComplexOpsBuilder::Part;
 template <CplxPart partId>
-mlir::Value Br::ComplexOpsBuilder::createPartId() {
-  auto type{mlir::IntegerType::get(32, builder.getContext())};
+M::Value Br::ComplexOpsBuilder::createPartId() {
+  auto type{M::IntegerType::get(32, builder.getContext())};
   return createIntegerConstant(type, static_cast<int>(partId));
 }
 
 template <CplxPart partId>
-mlir::Value Br::ComplexOpsBuilder::extract(mlir::Value cplx) {
+M::Value Br::ComplexOpsBuilder::extract(M::Value cplx) {
   return create<fir::ExtractValueOp>(getComplexPartType(cplx), cplx,
                                      createPartId<partId>());
 }
-template mlir::Value
-    Br::ComplexOpsBuilder::extract<CplxPart::Real>(mlir::Value);
-template mlir::Value
-    Br::ComplexOpsBuilder::extract<CplxPart::Imag>(mlir::Value);
+template M::Value Br::ComplexOpsBuilder::extract<CplxPart::Real>(M::Value);
+template M::Value Br::ComplexOpsBuilder::extract<CplxPart::Imag>(M::Value);
 
 template <CplxPart partId>
-mlir::Value Br::ComplexOpsBuilder::insert(mlir::Value cplx, mlir::Value part) {
+M::Value Br::ComplexOpsBuilder::insert(M::Value cplx, M::Value part) {
   assert(cplx != nullptr);
   return create<fir::InsertValueOp>(cplx.getType(), cplx, part,
                                     createPartId<partId>());
 }
-template mlir::Value Br::ComplexOpsBuilder::insert<CplxPart::Real>(mlir::Value,
-                                                                   mlir::Value);
-template mlir::Value Br::ComplexOpsBuilder::insert<CplxPart::Imag>(mlir::Value,
-                                                                   mlir::Value);
+template M::Value Br::ComplexOpsBuilder::insert<CplxPart::Real>(M::Value,
+                                                                M::Value);
+template M::Value Br::ComplexOpsBuilder::insert<CplxPart::Imag>(M::Value,
+                                                                M::Value);
 
-mlir::Value Br::ComplexOpsBuilder::extractComplexPart(mlir::Value cplx,
-                                                      bool isImagPart) {
+M::Value Br::ComplexOpsBuilder::extractComplexPart(M::Value cplx,
+                                                   bool isImagPart) {
   return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
 }
 
-mlir::Value Br::ComplexOpsBuilder::insertComplexPart(mlir::Value cplx,
-                                                     mlir::Value part,
-                                                     bool isImagPart) {
+M::Value Br::ComplexOpsBuilder::insertComplexPart(M::Value cplx, M::Value part,
+                                                  bool isImagPart) {
   return isImagPart ? insert<Part::Imag>(cplx, part)
                     : insert<Part::Real>(cplx, part);
 }
 
-mlir::Value Br::ComplexOpsBuilder::createComplexCompare(mlir::Value cplx1,
-                                                        mlir::Value cplx2,
-                                                        bool eq) {
-  mlir::Value real1{extract<Part::Real>(cplx1)};
-  mlir::Value real2{extract<Part::Real>(cplx2)};
-  mlir::Value imag1{extract<Part::Imag>(cplx1)};
-  mlir::Value imag2{extract<Part::Imag>(cplx2)};
-
-  mlir::CmpFPredicate predicate{eq ? mlir::CmpFPredicate::UEQ
-                                   : mlir::CmpFPredicate::UNE};
-  mlir::Value realCmp{create<mlir::CmpFOp>(predicate, real1, real2)};
-  mlir::Value imagCmp{create<mlir::CmpFOp>(predicate, imag1, imag2)};
-
-  return eq ? create<mlir::AndOp>(realCmp, imagCmp).getResult()
-            : create<mlir::OrOp>(realCmp, imagCmp).getResult();
+M::Value Br::ComplexOpsBuilder::createComplexCompare(M::Value cplx1,
+                                                     M::Value cplx2, bool eq) {
+  M::Value real1{extract<Part::Real>(cplx1)};
+  M::Value real2{extract<Part::Real>(cplx2)};
+  M::Value imag1{extract<Part::Imag>(cplx1)};
+  M::Value imag2{extract<Part::Imag>(cplx2)};
+
+  M::CmpFPredicate predicate{eq ? M::CmpFPredicate::UEQ
+                                : M::CmpFPredicate::UNE};
+  M::Value realCmp{create<M::CmpFOp>(predicate, real1, real2)};
+  M::Value imagCmp{create<M::CmpFOp>(predicate, imag1, imag2)};
+
+  return eq ? create<M::AndOp>(realCmp, imagCmp).getResult()
+            : create<M::OrOp>(realCmp, imagCmp).getResult();
 }
diff --git a/lib/lower/RTBuilder.h b/lib/lower/RTBuilder.h
index 0c914d7f4e53..30cfa5c6671c 100644
--- a/lib/lower/RTBuilder.h
+++ b/lib/lower/RTBuilder.h
@@ -33,9 +33,6 @@ namespace Fortran::lower {
 using TypeBuilderFunc = mlir::Type (*)(mlir::MLIRContext *);
 using FuncTypeBuilderFunc = mlir::FunctionType (*)(mlir::MLIRContext *);
 
-template <typename>
-struct errorNoBuilderForType;
-
 /// Return a function that returns the type signature model for the type `T`
 /// when provided an MLIRContext*. This allows one to translate C(++) function
 /// signatures from runtime header files to MLIR signatures into a static table
@@ -44,47 +41,118 @@ struct errorNoBuilderForType;
 /// For example, when `T` is `int`, return a function that returns the MLIR
 /// standard type `i32` when `sizeof(int)` is 4.
 template <typename T>
-static constexpr TypeBuilderFunc getModel() {
-  using namespace std::placeholders;
-  if constexpr (std::is_same_v<T, int>) {
-    return getModelForInt;
-  } else if constexpr (std::is_same_v<T, int &>) {
-    return getModelForIntRef;
-  } else if constexpr (std::is_same_v<T, std::int64_t>) {
-    return getModelForInt64;
-  } else if constexpr (std::is_same_v<T, std::int64_t &>) {
-    return getModelForInt64Ref;
-  } else if constexpr (std::is_same_v<T, std::size_t>) {
-    return getModelForSize;
-  } else if constexpr (std::is_same_v<T, double>) {
-    return getModelForDouble;
-  } else if constexpr (std::is_same_v<T, double &>) {
-    return getModelForDoubleRef;
-  } else if constexpr (std::is_same_v<T, float>) {
-    return getModelForFloat;
-  } else if constexpr (std::is_same_v<T, float &>) {
-    return getModelForFloatRef;
-  } else if constexpr (std::is_same_v<T, runtime::io::Iostat>) {
-    return getModelForIostat;
-  } else if constexpr (std::is_same_v<T, bool>) {
-    return getModelForBool;
-  } else if constexpr (std::is_same_v<T, bool &>) {
-    return getModelForBoolRef;
-  } else if constexpr (std::is_same_v<T, runtime::io::IoStatementState *>) {
-    return getModelForCookie;
-  } else if constexpr (std::is_same_v<T, char *>) {
-    return getModelForCharPtr;
-  } else if constexpr (std::is_same_v<T, const char *>) {
-    return getModelForConstCharPtr;
-  } else if constexpr (std::is_same_v<T, void>) {
-    return getModelForVoid;
-  } else if constexpr (std::is_same_v<T, const runtime::Descriptor &>) {
-    return getModelForDescriptor;
-  } else if constexpr (std::is_same_v<T, const runtime::NamelistGroup &>) {
-    return getModelForNamelistGroup;
-  } else {
-    return errorNoBuilderForType<T>{}; // intentionally force compile-time error
-  }
+static constexpr TypeBuilderFunc getModel();
+template <>
+constexpr TypeBuilderFunc getModel<int>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(8 * sizeof(int), context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<int &>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    TypeBuilderFunc f{getModel<int>()};
+    return fir::ReferenceType::get(f(context));
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<Fortran::runtime::io::Iostat>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(8 * sizeof(Fortran::runtime::io::Iostat),
+                                  context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<char *>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return fir::ReferenceType::get(mlir::IntegerType::get(8, context));
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<const char *>() {
+  return getModel<char *>();
+}
+template <>
+constexpr TypeBuilderFunc getModel<std::int64_t>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(64, context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<std::int64_t &>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    TypeBuilderFunc f{getModel<std::int64_t>()};
+    return fir::ReferenceType::get(f(context));
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<std::size_t>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(8 * sizeof(std::size_t), context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<Fortran::runtime::io::IoStatementState *>() {
+  return getModel<char *>();
+}
+template <>
+constexpr TypeBuilderFunc getModel<double>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::FloatType::getF64(context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<double &>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    TypeBuilderFunc f{getModel<double>()};
+    return fir::ReferenceType::get(f(context));
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<float>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::FloatType::getF32(context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<float &>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    TypeBuilderFunc f{getModel<float>()};
+    return fir::ReferenceType::get(f(context));
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<bool>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(1, context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<bool &>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    TypeBuilderFunc f{getModel<bool>()};
+    return fir::ReferenceType::get(f(context));
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<const Fortran::runtime::Descriptor &>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return fir::BoxType::get(mlir::NoneType::get(context));
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<const Fortran::runtime::NamelistGroup &>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    // FIXME: a namelist group must be some well-defined data structure, use a
+    // tuple as a proxy for the moment
+    return mlir::TupleType::get(llvm::None, context);
+  };
+}
+template <>
+constexpr TypeBuilderFunc getModel<void>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::NoneType::get(context);
+  };
 }
 
 template <typename...>
diff --git a/lib/lower/Runtime.cpp b/lib/lower/Runtime.cpp
index d9b32f62338d..b72a34d9e6d0 100644
--- a/lib/lower/Runtime.cpp
+++ b/lib/lower/Runtime.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Runtime.h"
+#include "NSAliases.h"
 #include "fir/Dialect/FIRType.h"
 #include "flang/lower/OpBuilder.h"
 #include "mlir/IR/StandardTypes.h"
@@ -16,51 +17,50 @@
 
 namespace Fortran::lower {
 
-mlir::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
-                                                 mlir::MLIRContext *context) {
+M::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
+                                              M::MLIRContext *context) {
   switch (t) {
   case TypeCode::i32:
-    return mlir::IntegerType::get(32, context);
+    return M::IntegerType::get(32, context);
   case TypeCode::i64:
-    return mlir::IntegerType::get(64, context);
+    return M::IntegerType::get(64, context);
   case TypeCode::f32:
-    return mlir::FloatType::getF32(context);
+    return M::FloatType::getF32(context);
   case TypeCode::f64:
-    return mlir::FloatType::getF64(context);
+    return M::FloatType::getF64(context);
   // TODO need to access mapping between fe/target
   case TypeCode::c32:
     return fir::CplxType::get(context, 4);
   case TypeCode::c64:
     return fir::CplxType::get(context, 8);
   case TypeCode::boolean:
-    return mlir::IntegerType::get(8, context);
+    return M::IntegerType::get(8, context);
   case TypeCode::charPtr:
     return fir::ReferenceType::get(fir::CharacterType::get(context, 1));
   // ! IOCookie is experimental only so far
   case TypeCode::IOCookie:
-    return fir::ReferenceType::get(mlir::IntegerType::get(64, context));
+    return fir::ReferenceType::get(M::IntegerType::get(64, context));
   }
   assert(false && "bug");
   return {};
 }
 
-mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
-    mlir::MLIRContext *context) const {
-  llvm::SmallVector<mlir::Type, 2> argMLIRTypes;
+M::FunctionType
+RuntimeStaticDescription::getMLIRFunctionType(M::MLIRContext *context) const {
+  L::SmallVector<M::Type, 2> argMLIRTypes;
   for (const TypeCode &t : argumentTypeCodes) {
     argMLIRTypes.push_back(getMLIRType(t, context));
   }
   if (resultTypeCode.has_value()) {
-    mlir::Type resMLIRType{getMLIRType(*resultTypeCode, context)};
-    return mlir::FunctionType::get(argMLIRTypes, resMLIRType, context);
+    M::Type resMLIRType{getMLIRType(*resultTypeCode, context)};
+    return M::FunctionType::get(argMLIRTypes, resMLIRType, context);
   }
-  return mlir::FunctionType::get(argMLIRTypes, {}, context);
+  return M::FunctionType::get(argMLIRTypes, {}, context);
 }
 
-mlir::FuncOp
-RuntimeStaticDescription::getFuncOp(mlir::OpBuilder &builder) const {
-  mlir::ModuleOp module{getModule(&builder)};
-  mlir::FunctionType funTy{getMLIRFunctionType(module.getContext())};
+M::FuncOp RuntimeStaticDescription::getFuncOp(M::OpBuilder &builder) const {
+  M::ModuleOp module{getModule(&builder)};
+  M::FunctionType funTy{getMLIRFunctionType(module.getContext())};
   auto function{getNamedFunction(module, symbol)};
   if (!function) {
     function = createFunction(module, symbol, funTy);
@@ -98,8 +98,7 @@ static constexpr RuntimeEntryDescription runtimeTable[]{
 static constexpr StaticMultimapView<RuntimeEntryDescription> runtimeMap{
     runtimeTable};
 
-mlir::FuncOp genRuntimeFunction(RuntimeEntryCode code,
-                                mlir::OpBuilder &builder) {
+M::FuncOp genRuntimeFunction(RuntimeEntryCode code, M::OpBuilder &builder) {
   auto description{runtimeMap.find(code)};
   assert(description != runtimeMap.end());
   return description->getFuncOp(builder);

From 24fe81710db6ef6c43d7bbd2913263581be940c5 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 4 Feb 2020 16:00:10 -0800
Subject: [PATCH 181/345] merge fir directory with opt

Conflicts:
	lib/CMakeLists.txt
---
 include/CMakeLists.txt                        |  2 +-
 include/fir/.clang-format                     |  2 -
 .../{fir => flang/optimizer}/CMakeLists.txt   |  0
 include/flang/optimizer/CodeGen/CodeGen.h     |  2 +-
 .../optimizer}/Dialect/CMakeLists.txt         |  0
 .../optimizer}/Dialect/FIRAttr.h              |  8 ++--
 .../optimizer}/Dialect/FIRDialect.h           |  8 ++--
 .../{fir => flang/optimizer}/Dialect/FIROps.h | 10 ++---
 .../optimizer}/Dialect/FIROps.td              | 42 ++++++++++++++-----
 .../optimizer}/Dialect/FIROpsSupport.h        | 10 ++---
 .../optimizer}/Dialect/FIRType.h              |  8 ++--
 .../optimizer/Support}/InternalNames.h        |  8 ++--
 .../optimizer/Support}/KindMapping.h          |  8 ++--
 include/flang/optimizer/Transforms/Passes.h   |  2 +-
 .../flang/optimizer/Transforms/StdConverter.h |  2 +-
 lib/fir/.clang-format                         |  2 -
 lib/lower/Bridge.cpp                          |  8 ++--
 lib/lower/ConvertExpr.cpp                     | 30 ++++++++++---
 lib/lower/ConvertType.cpp                     |  4 +-
 lib/lower/IO.cpp                              |  2 +-
 lib/lower/Intrinsics.cpp                      |  6 +--
 lib/lower/Mangler.cpp                         |  4 +-
 lib/lower/OpBuilder.cpp                       |  6 +--
 lib/lower/RTBuilder.h                         |  4 +-
 lib/lower/Runtime.cpp                         |  4 +-
 lib/optimizer/CMakeLists.txt                  |  2 +
 lib/optimizer/CodeGen.cpp                     | 16 +++----
 lib/{fir => optimizer}/Dialect/CMakeLists.txt |  2 -
 lib/{fir => optimizer}/Dialect/FIRAttr.cpp    |  8 ++--
 lib/{fir => optimizer}/Dialect/FIRDialect.cpp | 12 +++---
 lib/{fir => optimizer}/Dialect/FIROps.cpp     | 12 +++---
 lib/{fir => optimizer}/Dialect/FIRType.cpp    |  6 +--
 lib/optimizer/StdConverter.cpp                | 10 ++---
 lib/{fir => optimizer/Support}/CMakeLists.txt |  4 --
 .../Support}/InternalNames.cpp                |  4 +-
 .../Support}/KindMapping.cpp                  |  4 +-
 lib/optimizer/Transforms/CSE.cpp              |  2 +-
 lib/optimizer/Transforms/MemToReg.cpp         |  4 +-
 lib/optimizer/Transforms/RewriteLoop.cpp      |  4 +-
 test-lit/fir/fir-ops.fir                      |  8 ++--
 tools/bbc/bbc.cpp                             |  7 ++--
 tools/tco/tco.cpp                             |  9 ++--
 42 files changed, 165 insertions(+), 131 deletions(-)
 delete mode 100644 include/fir/.clang-format
 rename include/{fir => flang/optimizer}/CMakeLists.txt (100%)
 rename include/{fir => flang/optimizer}/Dialect/CMakeLists.txt (100%)
 rename include/{fir => flang/optimizer}/Dialect/FIRAttr.h (95%)
 rename include/{fir => flang/optimizer}/Dialect/FIRDialect.h (86%)
 rename include/{fir => flang/optimizer}/Dialect/FIROps.h (94%)
 rename include/{fir => flang/optimizer}/Dialect/FIROps.td (97%)
 rename include/{fir => flang/optimizer}/Dialect/FIROpsSupport.h (92%)
 rename include/{fir => flang/optimizer}/Dialect/FIRType.h (98%)
 rename include/{fir => flang/optimizer/Support}/InternalNames.h (96%)
 rename include/{fir => flang/optimizer/Support}/KindMapping.h (93%)
 delete mode 100644 lib/fir/.clang-format
 rename lib/{fir => optimizer}/Dialect/CMakeLists.txt (89%)
 rename lib/{fir => optimizer}/Dialect/FIRAttr.cpp (95%)
 rename lib/{fir => optimizer}/Dialect/FIRDialect.cpp (89%)
 rename lib/{fir => optimizer}/Dialect/FIROps.cpp (98%)
 rename lib/{fir => optimizer}/Dialect/FIRType.cpp (99%)
 rename lib/{fir => optimizer/Support}/CMakeLists.txt (63%)
 rename lib/{fir => optimizer/Support}/InternalNames.cpp (98%)
 rename lib/{fir => optimizer/Support}/KindMapping.cpp (98%)

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 8f8c016cb1d2..c6a154638e65 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1 +1 @@
-add_subdirectory(fir)
+add_subdirectory(flang/optimizer)
diff --git a/include/fir/.clang-format b/include/fir/.clang-format
deleted file mode 100644
index a74fda4b6734..000000000000
--- a/include/fir/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-BasedOnStyle: LLVM
-AlwaysBreakTemplateDeclarations: Yes
diff --git a/include/fir/CMakeLists.txt b/include/flang/optimizer/CMakeLists.txt
similarity index 100%
rename from include/fir/CMakeLists.txt
rename to include/flang/optimizer/CMakeLists.txt
diff --git a/include/flang/optimizer/CodeGen/CodeGen.h b/include/flang/optimizer/CodeGen/CodeGen.h
index 02846e907c53..d156cd1e8a44 100644
--- a/include/flang/optimizer/CodeGen/CodeGen.h
+++ b/include/flang/optimizer/CodeGen/CodeGen.h
@@ -1,4 +1,4 @@
-//===-- include/fir/Tilikum/Tilikum.h ---------------------------*- C++ -*-===//
+//===-- optimizer/CodeGen/CodeGen.h -- code generation ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/fir/Dialect/CMakeLists.txt b/include/flang/optimizer/Dialect/CMakeLists.txt
similarity index 100%
rename from include/fir/Dialect/CMakeLists.txt
rename to include/flang/optimizer/Dialect/CMakeLists.txt
diff --git a/include/fir/Dialect/FIRAttr.h b/include/flang/optimizer/Dialect/FIRAttr.h
similarity index 95%
rename from include/fir/Dialect/FIRAttr.h
rename to include/flang/optimizer/Dialect/FIRAttr.h
index 7f437cc90f86..530bb22a429e 100644
--- a/include/fir/Dialect/FIRAttr.h
+++ b/include/flang/optimizer/Dialect/FIRAttr.h
@@ -1,4 +1,4 @@
-//===-- include/fir/Attribute.h ---------------------------------*- C++ -*-===//
+//===-- optimizer/Dialect/FIRAttr.h -- FIR attributes -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef OPTIMIZER_FIRATTRIBUTE_H
-#define OPTIMIZER_FIRATTRIBUTE_H
+#ifndef OPTIMIZER_DIALECT_FIRATTR_H
+#define OPTIMIZER_DIALECT_FIRATTR_H
 
 #include "mlir/IR/Attributes.h"
 
@@ -133,4 +133,4 @@ void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
 
 } // namespace fir
 
-#endif // OPTIMIZER_FIRATTRIBUTE_H
+#endif // OPTIMIZER_DIALECT_FIRATTR_H
diff --git a/include/fir/Dialect/FIRDialect.h b/include/flang/optimizer/Dialect/FIRDialect.h
similarity index 86%
rename from include/fir/Dialect/FIRDialect.h
rename to include/flang/optimizer/Dialect/FIRDialect.h
index 95e482673932..91d4f37f08af 100644
--- a/include/fir/Dialect/FIRDialect.h
+++ b/include/flang/optimizer/Dialect/FIRDialect.h
@@ -1,4 +1,4 @@
-//===-- include/fir/FIRDialect.h --------------------------------*- C++ -*-===//
+//===-- optimizer/Dialect/FIRDialect.h -- FIR dialect -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef OPTIMIZER_FIRDIALECT_H
-#define OPTIMIZER_FIRDIALECT_H
+#ifndef OPTIMIZER_DIALECT_FIRDIALECT_H
+#define OPTIMIZER_DIALECT_FIRDIALECT_H
 
 #include "mlir/IR/Dialect.h"
 
@@ -46,4 +46,4 @@ class FIROpsDialect final : public mlir::Dialect {
 
 } // namespace fir
 
-#endif // OPTIMIZER_FIRDIALECT_H
+#endif // OPTIMIZER_DIALECT_FIRDIALECT_H
diff --git a/include/fir/Dialect/FIROps.h b/include/flang/optimizer/Dialect/FIROps.h
similarity index 94%
rename from include/fir/Dialect/FIROps.h
rename to include/flang/optimizer/Dialect/FIROps.h
index 33ed70bdc50e..77d130d1d1ab 100644
--- a/include/fir/Dialect/FIROps.h
+++ b/include/flang/optimizer/Dialect/FIROps.h
@@ -1,4 +1,4 @@
-//===-- FIROps.h - FIR operations -------------------------------*- C++ -*-===//
+//===-- optimizer/Dialect/FIROps.h - FIR operations -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef OPTIMIZER_FIROPS_H
-#define OPTIMIZER_FIROPS_H
+#ifndef OPTIMIZER_DIALECT_FIROPS_H
+#define OPTIMIZER_DIALECT_FIROPS_H
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpImplementation.h"
@@ -122,7 +122,7 @@ ParseResult parseCmpfOp(OpAsmParser &parser, OperationState &result);
 ParseResult parseCmpcOp(OpAsmParser &parser, OperationState &result);
 
 #define GET_OP_CLASSES
-#include "fir/Dialect/FIROps.h.inc"
+#include "flang/optimizer/Dialect/FIROps.h.inc"
 
 LoopOp getForInductionVarOwner(mlir::Value val);
 
@@ -130,4 +130,4 @@ bool isReferenceLike(mlir::Type type);
 
 } // namespace fir
 
-#endif // OPTIMIZER_FIROPS_H
+#endif // OPTIMIZER_DIALECT_FIROPS_H
diff --git a/include/fir/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
similarity index 97%
rename from include/fir/Dialect/FIROps.td
rename to include/flang/optimizer/Dialect/FIROps.td
index f2980975404e..e863b1417a4b 100644
--- a/include/fir/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -1713,32 +1713,52 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
 
 // Constant operations that support Fortran
 
-def fir_ConstantOp : fir_Op<"constant", [NoSideEffect]>,
+def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
     Results<(outs AnyType)> {
-  let summary = "create a constant of FIR type";
+  let summary = "create a string literal constant";
 
   let description = [{
-    An FIR constant
+    An FIR constant that represents a sequence of characters that correspond
+    to Fortran's CHARACTER type, including a LEN.
   }];
 
   let parser = [{
-    mlir::StringAttr attr;
-    if (parser.parseAttribute(attr, value(), result.attributes) ||
-        parser.addTypesToList(attr.getType(), result.types))
+    mlir::StringAttr val;
+    mlir::IntegerAttr sz;
+    mlir::Type type;
+    if (parser.parseAttribute(val, value(), result.attributes) ||
+        parser.parseLParen() ||
+        parser.parseAttribute(sz, size(), result.attributes) ||
+        parser.parseRParen() || parser.parseColonType(type))
+      return mlir::failure();
+    type = fir::SequenceType::get({sz.getInt()}, type);
+    if (parser.addTypesToList(type, result.types))
       return mlir::failure();
     return mlir::success();
   }];
 
   let printer = [{
-    p << getOperationName() << ' ' << getAttr(value());
+    p << getOperationName() << ' ' << getAttr(value()) << '(';
+    p << getAttr(size()).cast<mlir::IntegerAttr>().getValue() << ") : ";
+    p.printType(getType().cast<fir::SequenceType>().getEleTy());
   }];
 
-  //let verifier = [{
-  // FIXME!
-  //}];
+  let verifier = [{
+    if (getAttr(size()).cast<mlir::IntegerAttr>().getValue().isNegative())
+      return emitOpError("size must be non-negative");
+    auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
+    if (!eleTy.dyn_cast<fir::CharacterType>())
+      return emitOpError("must have !fir.char type");
+    return mlir::success();
+  }];
 
   let extraClassDeclaration = [{
-    constexpr static char const *value() { return "value"; }
+    static constexpr const char *size() { return "size"; }
+    static constexpr const char *value() { return "value"; }
+
+    // Get the LEN attribute of this character constant
+    mlir::Attribute getSize() { return getAttr(size()); }
+    // Get the string value of this character constant
     mlir::Attribute getValue() { return getAttr(value()); }
   }];
 }
diff --git a/include/fir/Dialect/FIROpsSupport.h b/include/flang/optimizer/Dialect/FIROpsSupport.h
similarity index 92%
rename from include/fir/Dialect/FIROpsSupport.h
rename to include/flang/optimizer/Dialect/FIROpsSupport.h
index 4126a619ab03..ce936152ab0b 100644
--- a/include/fir/Dialect/FIROpsSupport.h
+++ b/include/flang/optimizer/Dialect/FIROpsSupport.h
@@ -1,4 +1,4 @@
-//===-- include/fir/FIROpsSupport.h -----------------------------*- C++ -*-===//
+//===-- optimizer/Dialect/FIROpsSupport.h -- FIR op support -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef OPTIMIZER_FIROPS_SUPPORT_H
-#define OPTIMIZER_FIROPS_SUPPORT_H
+#ifndef OPTIMIZER_DIALECT_FIROPSSUPPORT_H
+#define OPTIMIZER_DIALECT_FIROPSSUPPORT_H
 
-#include "fir/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIROps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 
 namespace fir {
@@ -70,4 +70,4 @@ fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
 
 } // namespace fir
 
-#endif // OPTIMIZER_FIROPS_SUPPORT_H
+#endif // OPTIMIZER_DIALECT_FIROPSSUPPORT_H
diff --git a/include/fir/Dialect/FIRType.h b/include/flang/optimizer/Dialect/FIRType.h
similarity index 98%
rename from include/fir/Dialect/FIRType.h
rename to include/flang/optimizer/Dialect/FIRType.h
index 9471e36ee9d9..116e9f6e939e 100644
--- a/include/fir/Dialect/FIRType.h
+++ b/include/flang/optimizer/Dialect/FIRType.h
@@ -1,4 +1,4 @@
-//===-- include/fir/FIRType.h -----------------------------------*- C++ -*-===//
+//===-- optimizer/Dialect/FIRType.h -- FIR types ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef OPTIMIZER_FIRTYPE_H
-#define OPTIMIZER_FIRTYPE_H
+#ifndef OPTIMIZER_DIALECT_FIRTYPE_H
+#define OPTIMIZER_DIALECT_FIRTYPE_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Types.h"
@@ -336,4 +336,4 @@ void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);
 
 } // namespace fir
 
-#endif // OPTIMIZER_FIRTYPE_H
+#endif // OPTIMIZER_DIALECT_FIRTYPE_H
diff --git a/include/fir/InternalNames.h b/include/flang/optimizer/Support/InternalNames.h
similarity index 96%
rename from include/fir/InternalNames.h
rename to include/flang/optimizer/Support/InternalNames.h
index 444e8c6b0430..2d661bc7bf96 100644
--- a/include/fir/InternalNames.h
+++ b/include/flang/optimizer/Support/InternalNames.h
@@ -1,4 +1,4 @@
-//===-- include/fir/InternalNames.h -----------------------------*- C++ -*-===//
+//===-- optimizer/Support/InternalNames.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef OPTIMIZER_INTERNAL_NAMES_H
-#define OPTIMIZER_INTERNAL_NAMES_H
+#ifndef OPTIMIZER_SUPPORT_INTERNALNAMES_H
+#define OPTIMIZER_SUPPORT_INTERNALNAMES_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
@@ -127,4 +127,4 @@ struct NameUniquer {
 
 } // namespace fir
 
-#endif // OPTIMIZER_INTERNAL_NAMES_H
+#endif // OPTIMIZER_SUPPORT_INTERNALNAMES_H
diff --git a/include/fir/KindMapping.h b/include/flang/optimizer/Support/KindMapping.h
similarity index 93%
rename from include/fir/KindMapping.h
rename to include/flang/optimizer/Support/KindMapping.h
index 9f77209dc75c..5eb6b03840da 100644
--- a/include/fir/KindMapping.h
+++ b/include/flang/optimizer/Support/KindMapping.h
@@ -1,4 +1,4 @@
-//===-- include/fir/KindMapping.h -------------------------------*- C++ -*-===//
+//===-- optimizer/Support/KindMapping.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef OPTIMIZER_KINDMAPPING_H
-#define OPTIMIZER_KINDMAPPING_H
+#ifndef OPTIMIZER_SUPPORT_KINDMAPPING_H
+#define OPTIMIZER_SUPPORT_KINDMAPPING_H
 
 #include "llvm/IR/Type.h"
 #include <map>
@@ -82,4 +82,4 @@ class KindMapping {
 
 } // namespace fir
 
-#endif // OPTIMIZER_KINDMAPPING_H
+#endif // OPTIMIZER_SUPPORT_KINDMAPPING_H
diff --git a/include/flang/optimizer/Transforms/Passes.h b/include/flang/optimizer/Transforms/Passes.h
index a23cf5c0cf48..186b76435626 100644
--- a/include/flang/optimizer/Transforms/Passes.h
+++ b/include/flang/optimizer/Transforms/Passes.h
@@ -1,4 +1,4 @@
-//===-- include/fir/Transforms/Passes.h -------------------------*- C++ -*-===//
+//===-- optimizer/Transforms/Passes.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.
diff --git a/include/flang/optimizer/Transforms/StdConverter.h b/include/flang/optimizer/Transforms/StdConverter.h
index dc49e6ed473b..c0796c3275b7 100644
--- a/include/flang/optimizer/Transforms/StdConverter.h
+++ b/include/flang/optimizer/Transforms/StdConverter.h
@@ -1,4 +1,4 @@
-//===-- include/fir/Transforms/StdConverter.h -------------------*- C++ -*-===//
+//===-- optimizer/Transforms/StdConverter.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.
diff --git a/lib/fir/.clang-format b/lib/fir/.clang-format
deleted file mode 100644
index a74fda4b6734..000000000000
--- a/lib/fir/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-BasedOnStyle: LLVM
-AlwaysBreakTemplateDeclarations: Yes
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 15b8309ef0a3..8bed5fbd0e08 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -8,10 +8,6 @@
 
 #include "flang/lower/Bridge.h"
 #include "NSAliases.h"
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIROps.h"
-#include "fir/Dialect/FIRType.h"
-#include "fir/InternalNames.h"
 #include "flang/lower/ConvertExpr.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/IO.h"
@@ -20,6 +16,10 @@
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/PFTBuilder.h"
 #include "flang/lower/Runtime.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/optimizer/Support/InternalNames.h"
 #include "flang/parser/parse-tree.h"
 #include "flang/semantics/tools.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 135e1fedf789..4b633bf35b60 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/convert-expr.cc -------------------------------*- C++ -*-===//
+//===-- ConvertExpr.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,9 +8,6 @@
 
 #include "flang/lower/ConvertExpr.h"
 #include "NSAliases.h"
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIROps.h"
-#include "fir/Dialect/FIRType.h"
 #include "flang/common/default-kinds.h"
 #include "flang/common/unwrap.h"
 #include "flang/evaluate/fold.h"
@@ -19,6 +16,9 @@
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "flang/semantics/expression.h"
 #include "flang/semantics/symbol.h"
 #include "flang/semantics/type.h"
@@ -455,8 +455,26 @@ class ExprLowering {
     return result;
   }
 
+  /// Construct a CHARACTER literal
+  template <int KIND, typename E>
+  M::Value genCharLit(const E &data, std::size_t size) {
+    auto context = builder.getContext();
+    auto valTag = M::Identifier::get(fir::StringLitOp::value(), context);
+    // FIXME: for wider char types, use an array of i16 or i32
+    // for now, just fake it that it's a i8 to get it past the C++ compiler
+    auto strAttr = M::StringAttr::get((const char *)data.c_str(), context);
+    M::NamedAttribute dataAttr(valTag, strAttr);
+    auto sizeTag = M::Identifier::get(fir::StringLitOp::size(), context);
+    M::NamedAttribute sizeAttr(sizeTag, builder.getI64IntegerAttr(size));
+    L::SmallVector<M::NamedAttribute, 2> attrs{dataAttr, sizeAttr};
+    auto type =
+        fir::SequenceType::get({size}, fir::CharacterType::get(context, KIND));
+    return builder.create<fir::StringLitOp>(
+        getLoc(), L::ArrayRef<M::Type>{type}, llvm::None, attrs);
+  }
+
   template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Constant<Ev::Type<TC, KIND>> const &con) {
+  M::Value genval(const Ev::Constant<Ev::Type<TC, KIND>> &con) {
     // TODO:
     // - character type constant
     // - array constant not handled
@@ -507,6 +525,8 @@ class ExprLowering {
       }
       assert(false && "array of complex unhandled");
       return {};
+    } else if constexpr (TC == CharacterCat) {
+      return genCharLit<KIND>(con.GetScalarValue().value(), con.size());
     } else {
       assert(false && "unhandled constant");
       return {};
diff --git a/lib/lower/ConvertType.cpp b/lib/lower/ConvertType.cpp
index cf25ca3e4da5..3e9d165c2aee 100644
--- a/lib/lower/ConvertType.cpp
+++ b/lib/lower/ConvertType.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/convert-type.cc -----------------------------------------===//
+//===-- ConvertType.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,9 +9,9 @@
 #include "flang/lower/ConvertType.h"
 #include "../../runtime/io-api.h"
 #include "NSAliases.h"
-#include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/Utils.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "flang/semantics/expression.h"
 #include "flang/semantics/tools.h"
 #include "flang/semantics/type.h"
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index cadb17e37f2b..2f864e21eaeb 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -10,10 +10,10 @@
 #include "../../runtime/io-api.h"
 #include "NSAliases.h"
 #include "RTBuilder.h"
-#include "fir/Dialect/FIROps.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
+#include "flang/optimizer/Dialect/FIROps.h"
 #include "flang/parser/parse-tree.h"
 #include "flang/semantics/tools.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
diff --git a/lib/lower/Intrinsics.cpp b/lib/lower/Intrinsics.cpp
index 1a640b0675e6..0e6bd4cdd0eb 100644
--- a/lib/lower/Intrinsics.cpp
+++ b/lib/lower/Intrinsics.cpp
@@ -1,4 +1,4 @@
-//===-- lib/lower/intrinsics.cc ---------------------------------*- C++ -*-===//
+//===-- Intrinsics.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,11 +8,11 @@
 
 #include "flang/lower/Intrinsics.h"
 #include "NSAliases.h"
-#include "fir/Dialect/FIROps.h"
-#include "fir/Dialect/FIRType.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
+#include "flang/optimizer/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include <algorithm>
diff --git a/lib/lower/Mangler.cpp b/lib/lower/Mangler.cpp
index 87c718bb4330..0160a703526a 100644
--- a/lib/lower/Mangler.cpp
+++ b/lib/lower/Mangler.cpp
@@ -1,4 +1,4 @@
-//===-- lower/Mangler.cpp -------------------------------------------------===//
+//===-- Mangler.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,9 +8,9 @@
 
 #include "flang/lower/Mangler.h"
 #include "NSAliases.h"
-#include "fir/InternalNames.h"
 #include "flang/common/reference.h"
 #include "flang/lower/Utils.h"
+#include "flang/optimizer/Support/InternalNames.h"
 #include "flang/semantics/tools.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
diff --git a/lib/lower/OpBuilder.cpp b/lib/lower/OpBuilder.cpp
index 4c1d338feb4a..09ebe21e137f 100644
--- a/lib/lower/OpBuilder.cpp
+++ b/lib/lower/OpBuilder.cpp
@@ -1,4 +1,4 @@
-//===-- OpBuilder.cc ------------------------------------------------------===//
+//===-- OpBuilder.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,10 +8,10 @@
 
 #include "flang/lower/OpBuilder.h"
 #include "NSAliases.h"
-#include "fir/Dialect/FIROpsSupport.h"
-#include "fir/Dialect/FIRType.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/ConvertType.h"
+#include "flang/optimizer/Dialect/FIROpsSupport.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/StringRef.h"
diff --git a/lib/lower/RTBuilder.h b/lib/lower/RTBuilder.h
index 30cfa5c6671c..9ddff111ac87 100644
--- a/lib/lower/RTBuilder.h
+++ b/lib/lower/RTBuilder.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/cfg-builder.h ---------------------------------*- C++ -*-===//
+//===-- RTBuilder.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.
@@ -17,8 +17,8 @@
 #ifndef FORTRAN_LOWER_RT_BUILDER_H_
 #define FORTRAN_LOWER_RT_BUILDER_H_
 
-#include "fir/Dialect/FIRType.h"
 #include "flang/lower/ConvertType.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/lower/Runtime.cpp b/lib/lower/Runtime.cpp
index b72a34d9e6d0..2acb5f9685f7 100644
--- a/lib/lower/Runtime.cpp
+++ b/lib/lower/Runtime.cpp
@@ -1,4 +1,4 @@
-//===-- lower/Runtime.cpp -------------------------------------------------===//
+//===-- Runtime.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,8 +8,8 @@
 
 #include "flang/lower/Runtime.h"
 #include "NSAliases.h"
-#include "fir/Dialect/FIRType.h"
 #include "flang/lower/OpBuilder.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/optimizer/CMakeLists.txt b/lib/optimizer/CMakeLists.txt
index 2e3a960e7c00..5b6bc5b8e7f2 100644
--- a/lib/optimizer/CMakeLists.txt
+++ b/lib/optimizer/CMakeLists.txt
@@ -1,5 +1,7 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wno-unused-parameter")
 
+add_subdirectory(Dialect)
+add_subdirectory(Support)
 add_subdirectory(Transforms)
 
 add_llvm_library(FortranOptimizer
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index ebd6b8f314f4..7a35b55fe7ca 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -7,12 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/optimizer/CodeGen/CodeGen.h"
-#include "fir/Dialect/FIRAttr.h"
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIROps.h"
-#include "fir/Dialect/FIRType.h"
-#include "fir/InternalNames.h"
-#include "fir/KindMapping.h"
+#include "flang/optimizer/Dialect/FIRAttr.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/optimizer/Support/InternalNames.h"
+#include "flang/optimizer/Support/KindMapping.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
@@ -736,13 +736,13 @@ struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
   }
 };
 
-struct ConstantOpConversion : public FIROpConversion<fir::ConstantOp> {
+struct ConstantOpConversion : public FIROpConversion<fir::StringLitOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto constop = mlir::cast<fir::ConstantOp>(op);
+    auto constop = mlir::cast<fir::StringLitOp>(op);
     auto ty_ = constop.getType();
     auto ty = convertType(ty_);
     auto attr = constop.getValue();
diff --git a/lib/fir/Dialect/CMakeLists.txt b/lib/optimizer/Dialect/CMakeLists.txt
similarity index 89%
rename from lib/fir/Dialect/CMakeLists.txt
rename to lib/optimizer/Dialect/CMakeLists.txt
index 2022e104bffb..711fc64c5a2a 100644
--- a/lib/fir/Dialect/CMakeLists.txt
+++ b/lib/optimizer/Dialect/CMakeLists.txt
@@ -1,5 +1,3 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error")
-
 add_llvm_library(FIRDialect
   FIRAttr.cpp
   FIRDialect.cpp
diff --git a/lib/fir/Dialect/FIRAttr.cpp b/lib/optimizer/Dialect/FIRAttr.cpp
similarity index 95%
rename from lib/fir/Dialect/FIRAttr.cpp
rename to lib/optimizer/Dialect/FIRAttr.cpp
index fa53bd3fbf56..8694e99b2d9b 100644
--- a/lib/fir/Dialect/FIRAttr.cpp
+++ b/lib/optimizer/Dialect/FIRAttr.cpp
@@ -1,4 +1,4 @@
-//===-- fir/FIRAttr.cpp ---------------------------------------------------===//
+//===-- FIRAttr.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIRAttr.h"
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIRType.h"
+#include "flang/optimizer/Dialect/FIRAttr.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
diff --git a/lib/fir/Dialect/FIRDialect.cpp b/lib/optimizer/Dialect/FIRDialect.cpp
similarity index 89%
rename from lib/fir/Dialect/FIRDialect.cpp
rename to lib/optimizer/Dialect/FIRDialect.cpp
index 18489f3985fe..c8bc3baa4b2f 100644
--- a/lib/fir/Dialect/FIRDialect.cpp
+++ b/lib/optimizer/Dialect/FIRDialect.cpp
@@ -1,4 +1,4 @@
-//===-- fir/FIRDialect.cpp ------------------------------------------------===//
+//===-- FIRDialect.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIRAttr.h"
-#include "fir/Dialect/FIROps.h"
-#include "fir/Dialect/FIRType.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIRAttr.h"
+#include "flang/optimizer/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Transforms/SideEffectsInterface.h"
@@ -49,7 +49,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
                 PointIntervalAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<GlobalOp, DispatchTableOp,
 #define GET_OP_LIST
-#include "fir/Dialect/FIROps.cpp.inc"
+#include "flang/optimizer/Dialect/FIROps.cpp.inc"
                 >();
 }
 
diff --git a/lib/fir/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
similarity index 98%
rename from lib/fir/Dialect/FIROps.cpp
rename to lib/optimizer/Dialect/FIROps.cpp
index d853b002d859..e00995ec9175 100644
--- a/lib/fir/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -1,4 +1,4 @@
-//===-- fir/FIROps.cpp ----------------------------------------------------===//
+//===-- FIROps.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIROps.h"
-#include "fir/Dialect/FIRAttr.h"
-#include "fir/Dialect/FIROpsSupport.h"
-#include "fir/Dialect/FIRType.h"
+#include "flang/optimizer/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIRAttr.h"
+#include "flang/optimizer/Dialect/FIROpsSupport.h"
+#include "flang/optimizer/Dialect/FIRType.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
@@ -642,6 +642,6 @@ GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
 // Tablegen operators
 
 #define GET_OP_CLASSES
-#include "fir/Dialect/FIROps.cpp.inc"
+#include "flang/optimizer/Dialect/FIROps.cpp.inc"
 
 } // namespace fir
diff --git a/lib/fir/Dialect/FIRType.cpp b/lib/optimizer/Dialect/FIRType.cpp
similarity index 99%
rename from lib/fir/Dialect/FIRType.cpp
rename to lib/optimizer/Dialect/FIRType.cpp
index 3504631e23ee..10a6b60e896f 100644
--- a/lib/fir/Dialect/FIRType.cpp
+++ b/lib/optimizer/Dialect/FIRType.cpp
@@ -1,4 +1,4 @@
-//===-- fir/Dialect/FIRType.cpp -------------------------------------------===//
+//===-- FIRType.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIRType.h"
-#include "fir/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
diff --git a/lib/optimizer/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
index 2580709265ef..e82490ff5936 100644
--- a/lib/optimizer/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/optimizer/Transforms/StdConverter.h"
-#include "fir/Dialect/FIRAttr.h"
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIROpsSupport.h"
-#include "fir/Dialect/FIRType.h"
-#include "fir/KindMapping.h"
+#include "flang/optimizer/Dialect/FIRAttr.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIROpsSupport.h"
+#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/optimizer/Support/KindMapping.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/StandardTypes.h"
diff --git a/lib/fir/CMakeLists.txt b/lib/optimizer/Support/CMakeLists.txt
similarity index 63%
rename from lib/fir/CMakeLists.txt
rename to lib/optimizer/Support/CMakeLists.txt
index 6b77fd10587e..f0aecd7c5da4 100644
--- a/lib/fir/CMakeLists.txt
+++ b/lib/optimizer/Support/CMakeLists.txt
@@ -1,7 +1,3 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wno-unused-parameter")
-
-add_subdirectory(Dialect)
-
 add_llvm_library(FIR
   InternalNames.cpp
   KindMapping.cpp
diff --git a/lib/fir/InternalNames.cpp b/lib/optimizer/Support/InternalNames.cpp
similarity index 98%
rename from lib/fir/InternalNames.cpp
rename to lib/optimizer/Support/InternalNames.cpp
index 9db82e1936d5..b95d8df60390 100644
--- a/lib/fir/InternalNames.cpp
+++ b/lib/optimizer/Support/InternalNames.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/InternalNames.cpp -----------------------------------------===//
+//===-- InternalNames.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/InternalNames.h"
+#include "flang/optimizer/Support/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
diff --git a/lib/fir/KindMapping.cpp b/lib/optimizer/Support/KindMapping.cpp
similarity index 98%
rename from lib/fir/KindMapping.cpp
rename to lib/optimizer/Support/KindMapping.cpp
index 5f9a2c9300fe..aec5882c82c9 100644
--- a/lib/fir/KindMapping.cpp
+++ b/lib/optimizer/Support/KindMapping.cpp
@@ -1,4 +1,4 @@
-//===-- lib/fir/KindMapping.cpp -------------------------------------------===//
+//===-- KindMapping.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/KindMapping.h"
+#include "flang/optimizer/Support/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
diff --git a/lib/optimizer/Transforms/CSE.cpp b/lib/optimizer/Transforms/CSE.cpp
index 91a30971820a..9a692e08b5d3 100644
--- a/lib/optimizer/Transforms/CSE.cpp
+++ b/lib/optimizer/Transforms/CSE.cpp
@@ -12,7 +12,7 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIROpsSupport.h"
+#include "flang/optimizer/Dialect/FIROpsSupport.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/IR/Attributes.h"
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
index e05956e79144..6811eb88e256 100644
--- a/lib/optimizer/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIROps.h"
 #include "flang/optimizer/Analysis/IteratedDominanceFrontier.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIROps.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
diff --git a/lib/optimizer/Transforms/RewriteLoop.cpp b/lib/optimizer/Transforms/RewriteLoop.cpp
index f7943bbd61d7..bb99f4147b35 100644
--- a/lib/optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/optimizer/Transforms/RewriteLoop.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/Dialect/FIROps.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Dialect/FIROps.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
diff --git a/test-lit/fir/fir-ops.fir b/test-lit/fir/fir-ops.fir
index 6d3c4e120889..20d404c0e4ac 100644
--- a/test-lit/fir/fir-ops.fir
+++ b/test-lit/fir/fir-ops.fir
@@ -447,8 +447,8 @@ func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.comple
 }
 
 // CHECK-LABEL: @character_literal
-func @character_literal() -> !fir.char<1> {
-  // CHECK: fir.constant "Hello, World!" : !fir.char<1>
-  %0 = fir.constant "Hello, World!" : !fir.char<1>
-  return %0 : !fir.char<1>
+func @character_literal() -> !fir.array<13 x !fir.char<1>> {
+  // CHECK: fir.string_lit "Hello, World!"(13) : !fir.char<1>
+  %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1>
+  return %0 : !fir.array<13 x !fir.char<1>>
 }
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index f3514fd8a959..8e34c8d65efa 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -11,14 +11,14 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/InternalNames.h"
-#include "fir/KindMapping.h"
 #include "flang/common/Fortran-features.h"
 #include "flang/common/default-kinds.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/ConvertExpr.h"
 #include "flang/optimizer/CodeGen/CodeGen.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Support/InternalNames.h"
+#include "flang/optimizer/Support/KindMapping.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "flang/optimizer/Transforms/StdConverter.h"
 #include "flang/parser/characters.h"
@@ -165,6 +165,7 @@ void convertFortranSourceToMLIR(
       mlirModule.print(out);
   } else {
     errs() << "oops, pass manager reported failure\n";
+    mlirModule.dump();
   }
 }
 
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 325720d366ec..544c4ad7e76d 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -11,10 +11,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "fir/Dialect/FIRDialect.h"
-#include "fir/InternalNames.h"
-#include "fir/KindMapping.h"
 #include "flang/optimizer/CodeGen/CodeGen.h"
+#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/optimizer/Support/InternalNames.h"
+#include "flang/optimizer/Support/KindMapping.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "flang/optimizer/Transforms/StdConverter.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
@@ -50,7 +50,7 @@ void printModuleBody(mlir::ModuleOp mod) {
   auto e{--mod.end()};
   for (auto i{mod.begin()}; i != e; ++i) {
     i->print(llvm::outs());
-    llvm::outs() << '\n';
+    llvm::outs() << "\n\n";
   }
 }
 
@@ -106,6 +106,7 @@ int compileFIR() {
   if (mlir::succeeded(pm.run(*owningRef))) {
     if (emitFir)
       printModuleBody(*owningRef);
+    out.keep();
     return 0;
   }
   llvm::errs() << "FAILED: " << inputFilename << '\n';

From 584ad541c7672578e6185ab0deff6d7b4e20c53e Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 6 Feb 2020 03:27:36 -0800
Subject: [PATCH 182/345] Fix issues comming from clang-10 warnings

---
 include/flang/Semantics/symbol.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/include/flang/Semantics/symbol.h b/include/flang/Semantics/symbol.h
index 947535c59a7e..037423399182 100644
--- a/include/flang/Semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -58,6 +58,14 @@ class MainProgramDetails {
 
 class SubprogramDetails {
 public:
+  SubprogramDetails() {}
+  SubprogramDetails(const SubprogramDetails &that)
+    : dummyArgs_{that.dummyArgs_}, result_{that.result_} {}
+  SubprogramDetails &operator=(const SubprogramDetails &) = delete;
+  ~SubprogramDetails() = default;
+  SubprogramDetails &operator=(SubprogramDetails &&) = default;
+  SubprogramDetails(SubprogramDetails &&) = default;
+
   bool isFunction() const { return result_ != nullptr; }
   bool isInterface() const { return isInterface_; }
   void set_isInterface(bool value = true) { isInterface_ = value; }

From bb808de7cf4910caba450bb80dc46decb469cef0 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 6 Feb 2020 10:51:09 -0800
Subject: [PATCH 183/345] rebase fix bugs in lowering of PRINT "Hello, World!"
 fix comment add array to stringlit character(kind={2|4}) some work on
 fir.constc and fir.constf operations. this is a snapshot. lowering of trivial
 intrinsic type globals with initializers fixes (from Tyler Gobran) and
 cleanup

---
 include/flang/lower/OpBuilder.h               |   2 +-
 include/flang/optimizer/Dialect/FIRAttr.h     |  50 ++-
 include/flang/optimizer/Dialect/FIROps.td     | 136 +++++++-
 include/flang/optimizer/Dialect/FIRType.h     |   1 +
 include/flang/optimizer/Support/KindMapping.h |   4 +
 lib/lower/ConvertExpr.cpp                     |   4 +-
 lib/lower/IO.cpp                              |  24 +-
 lib/lower/RTBuilder.h                         |   7 +
 lib/optimizer/CodeGen.cpp                     | 290 +++++++++++-------
 lib/optimizer/Dialect/FIRAttr.cpp             | 125 +++++++-
 lib/optimizer/Dialect/FIRDialect.cpp          |   2 +-
 lib/optimizer/Dialect/FIROps.cpp              |   7 +
 lib/optimizer/Support/KindMapping.cpp         |  24 ++
 test-lit/fir/widechar.fir                     |  22 ++
 tools/tco/tco.cpp                             |  55 ++--
 15 files changed, 582 insertions(+), 171 deletions(-)
 create mode 100644 test-lit/fir/widechar.fir

diff --git a/include/flang/lower/OpBuilder.h b/include/flang/lower/OpBuilder.h
index 43fdf2040376..06f46b344f15 100644
--- a/include/flang/lower/OpBuilder.h
+++ b/include/flang/lower/OpBuilder.h
@@ -91,7 +91,7 @@ class LoopBuilder : public OpBuilderWrapper {
   using BodyGenerator = std::function<void(OpBuilderWrapper &, mlir::Value)>;
 
   /// Build loop [\p lb, \p ub) with step \p step.
-  /// If \p is an empty value, 1 is used for the step.
+  /// If \p step is an empty value, 1 is used for the step.
   void createLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
                   const BodyGenerator &bodyGenerator);
 
diff --git a/include/flang/optimizer/Dialect/FIRAttr.h b/include/flang/optimizer/Dialect/FIRAttr.h
index 530bb22a429e..c642ac8476d8 100644
--- a/include/flang/optimizer/Dialect/FIRAttr.h
+++ b/include/flang/optimizer/Dialect/FIRAttr.h
@@ -21,8 +21,9 @@ namespace fir {
 class FIROpsDialect;
 
 namespace detail {
+struct RealAttributeStorage;
 struct TypeAttributeStorage;
-}
+} // namespace detail
 
 enum AttributeKind {
   FIR_ATTR = mlir::Attribute::FIRST_FIR_ATTR,
@@ -42,7 +43,7 @@ class ExactTypeAttr
   using Base::Base;
   using ValueType = mlir::Type;
 
-  static llvm::StringRef getAttrName() { return "instance"; }
+  constexpr static llvm::StringRef getAttrName() { return "instance"; }
   static ExactTypeAttr get(mlir::Type value);
 
   mlir::Type getType() const;
@@ -58,7 +59,7 @@ class SubclassAttr
   using Base::Base;
   using ValueType = mlir::Type;
 
-  static llvm::StringRef getAttrName() { return "subsumed"; }
+  constexpr static llvm::StringRef getAttrName() { return "subsumed"; }
   static SubclassAttr get(mlir::Type value);
 
   mlir::Type getType() const;
@@ -67,12 +68,18 @@ class SubclassAttr
   constexpr static unsigned getId() { return AttributeKind::FIR_SUBCLASS; }
 };
 
+// Attributes for building SELECT CASE multiway branches
+
+/// A closed interval (including the bound values) is an interval with both an
+/// upper and lower bound as given as ssa-values.
+/// A case selector of `CASE (n:m)` corresponds to any value from `n` to `m` and
+/// is encoded as `#fir.interval, %n, %m`.
 class ClosedIntervalAttr
     : public mlir::Attribute::AttrBase<ClosedIntervalAttr> {
 public:
   using Base::Base;
 
-  static llvm::StringRef getAttrName() { return "interval"; }
+  constexpr static llvm::StringRef getAttrName() { return "interval"; }
   static ClosedIntervalAttr get(mlir::MLIRContext *ctxt);
   constexpr static bool kindof(unsigned kind) { return kind == getId(); }
   constexpr static unsigned getId() {
@@ -80,11 +87,15 @@ class ClosedIntervalAttr
   }
 };
 
+/// An upper bound is an open interval (including the bound value) as given as
+/// an ssa-value.
+/// A case selector of `CASE (:m)` corresponds to any value up to and including
+/// `m` and is encoded as `#fir.upper, %m`.
 class UpperBoundAttr : public mlir::Attribute::AttrBase<UpperBoundAttr> {
 public:
   using Base::Base;
 
-  static llvm::StringRef getAttrName() { return "upper"; }
+  constexpr static llvm::StringRef getAttrName() { return "upper"; }
   static UpperBoundAttr get(mlir::MLIRContext *ctxt);
   constexpr static bool kindof(unsigned kind) { return kind == getId(); }
   constexpr static unsigned getId() {
@@ -92,11 +103,15 @@ class UpperBoundAttr : public mlir::Attribute::AttrBase<UpperBoundAttr> {
   }
 };
 
+/// A lower bound is an open interval (including the bound value) as given as
+/// an ssa-value.
+/// A case selector of `CASE (n:)` corresponds to any value down to and
+/// including `n` and is encoded as `#fir.lower, %n`.
 class LowerBoundAttr : public mlir::Attribute::AttrBase<LowerBoundAttr> {
 public:
   using Base::Base;
 
-  static llvm::StringRef getAttrName() { return "lower"; }
+  constexpr static llvm::StringRef getAttrName() { return "lower"; }
   static LowerBoundAttr get(mlir::MLIRContext *ctxt);
   constexpr static bool kindof(unsigned kind) { return kind == getId(); }
   constexpr static unsigned getId() {
@@ -104,22 +119,37 @@ class LowerBoundAttr : public mlir::Attribute::AttrBase<LowerBoundAttr> {
   }
 };
 
+/// A pointer interval is an closed interval as given as an ssa-value. The
+/// interval contains exactly one value.
+/// A case selector of `CASE (p)` corresponds to exactly the value `p` and is
+/// encoded as `#fir.point, %p`.
 class PointIntervalAttr : public mlir::Attribute::AttrBase<PointIntervalAttr> {
 public:
   using Base::Base;
 
-  static llvm::StringRef getAttrName() { return "point"; }
+  constexpr static llvm::StringRef getAttrName() { return "point"; }
   static PointIntervalAttr get(mlir::MLIRContext *ctxt);
   constexpr static bool kindof(unsigned kind) { return kind == getId(); }
   constexpr static unsigned getId() { return AttributeKind::FIR_POINT; }
 };
 
-class RealAttr : public mlir::Attribute::AttrBase<RealAttr, mlir::Attribute> {
+/// A real attribute is used to workaround MLIR's default parsing of a real
+/// constant.
+/// `#fir.real<10, 3.14>` is used to introduce a real constant of value `3.14`
+/// with a kind of `10`.
+class RealAttr
+    : public mlir::Attribute::AttrBase<RealAttr, mlir::Attribute,
+                                       detail::RealAttributeStorage> {
 public:
   using Base::Base;
+  using ValueType = std::pair<int, llvm::APFloat>;
+
+  constexpr static llvm::StringRef getAttrName() { return "real"; }
+  static RealAttr get(mlir::MLIRContext *ctxt, const ValueType &key);
+
+  int getFKind() const;
+  llvm::APFloat getValue() const;
 
-  static llvm::StringRef getAttrName() { return "real"; }
-  static RealAttr get(mlir::MLIRContext *ctxt, const llvm::APFloat &flt);
   constexpr static bool kindof(unsigned kind) { return kind == getId(); }
   constexpr static unsigned getId() { return AttributeKind::FIR_REAL_ATTR; }
 };
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index e863b1417a4b..129db80413ef 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -822,7 +822,7 @@ def fir_FirEndOp : fir_Op<"end", [Terminator]> {
 // Operations on !fir.box<T> type objects
 
 def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
-    Arguments<(ins AnyReferenceLike:$memref, Variadic<AnyIntegerType>:$args)> {
+    Arguments<(ins AnyReferenceLike:$memref, Variadic<fir_DimsType>:$args)> {
   let summary = "boxes a given reference and (optional) dimension information";
 
   let description = [{
@@ -854,7 +854,7 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
       operands.push_back(dims);
     } else if (!parser.parseOptionalLSquare()) {
       mlir::AffineMapAttr map;
-      if (parser.parseAttribute(map, "layout_map", result.attributes) ||
+      if (parser.parseAttribute(map, layoutName(), result.attributes) ||
           parser.parseRSquare())
         return mlir::failure();
     }
@@ -877,7 +877,7 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
     if (getNumOperands() == 2) {
       p << ", ";
       p.printOperands(dims());
-    } else if (auto map = getAttr("layout_map")) {
+    } else if (auto map = getAttr(layoutName())) {
       p << " [" << map << ']';
     }
     p << " : ";
@@ -885,7 +885,8 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
   }];
 
   let extraClassDeclaration = [{
-    constexpr static llvm::StringRef lenpName() { return "len_param_count"; }
+    static constexpr llvm::StringRef layoutName() { return "layout_map"; }
+    static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
     bool hasLenParams() { return bool{getAttr(lenpName())}; }
     unsigned numLenParams() {
       if (auto x = getAttrOfType<mlir::IntegerAttr>(lenpName()))
@@ -896,7 +897,7 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
       return {operand_begin(), operand_begin() + numLenParams()};
     }
     operand_range dims() {
-      return {operand_begin() + numLenParams(), operand_end()};
+      return {operand_begin() + numLenParams() + 1, operand_end()};
     }
   }];
 }
@@ -1723,11 +1724,20 @@ def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
   }];
 
   let parser = [{
-    mlir::StringAttr val;
+    auto &builder = parser.getBuilder();
+    mlir::Attribute val;
+    llvm::SmallVector<mlir::NamedAttribute, 2> attrs;
+    if (parser.parseAttribute(val, "fake", attrs))
+      return mlir::failure();
+    if (auto v = val.dyn_cast<mlir::StringAttr>())
+      result.attributes.push_back(builder.getNamedAttr(value(), v));
+    else if (auto v = val.dyn_cast<mlir::ArrayAttr>())
+      result.attributes.push_back(builder.getNamedAttr(xlist(), v));
+    else
+      return mlir::failure();
     mlir::IntegerAttr sz;
     mlir::Type type;
-    if (parser.parseAttribute(val, value(), result.attributes) ||
-        parser.parseLParen() ||
+    if (parser.parseLParen() ||
         parser.parseAttribute(sz, size(), result.attributes) ||
         parser.parseRParen() || parser.parseColonType(type))
       return mlir::failure();
@@ -1738,28 +1748,42 @@ def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
   }];
 
   let printer = [{
-    p << getOperationName() << ' ' << getAttr(value()) << '(';
-    p << getAttr(size()).cast<mlir::IntegerAttr>().getValue() << ") : ";
+    p << getOperationName() << ' ' << getValue() << '(';
+    p << getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
     p.printType(getType().cast<fir::SequenceType>().getEleTy());
   }];
 
   let verifier = [{
-    if (getAttr(size()).cast<mlir::IntegerAttr>().getValue().isNegative())
+    if (getSize().cast<mlir::IntegerAttr>().getValue().isNegative())
       return emitOpError("size must be non-negative");
     auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
     if (!eleTy.dyn_cast<fir::CharacterType>())
       return emitOpError("must have !fir.char type");
+    if (auto xl = getAttr(xlist())) {
+      auto xList = xl.cast<mlir::ArrayAttr>();
+      for (auto a : xList)
+        if (!a.isa<mlir::IntegerAttr>())
+	  return emitOpError("values in list must be integers");
+    }
     return mlir::success();
   }];
 
   let extraClassDeclaration = [{
     static constexpr const char *size() { return "size"; }
     static constexpr const char *value() { return "value"; }
+    static constexpr const char *xlist() { return "xlist"; }
 
     // Get the LEN attribute of this character constant
     mlir::Attribute getSize() { return getAttr(size()); }
     // Get the string value of this character constant
-    mlir::Attribute getValue() { return getAttr(value()); }
+    mlir::Attribute getValue() {
+      if (auto attr = getAttr(value()))
+        return attr;
+      return getAttr(xlist());
+    }
+
+    /// Is this a wide character literal (1 character > 8 bits)
+    bool isWideValue();
   }];
 }
 
@@ -1787,6 +1811,43 @@ class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
   let printer = [{ return fir::printUnaryOp(this->getOperation(), p); }];
 }
 
+def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]>,
+    Results<(outs fir_RealType)> {
+  let summary = "create a floating point constant";
+
+  let description = [{
+    FIXME
+  }];
+
+  let parser = [{
+    fir::RealAttr flt;
+    mlir::Type type;
+    if (parser.parseLParen() ||
+        parser.parseAttribute(flt, constAttrName(), result.attributes) ||
+        parser.parseRParen() || parser.parseColonType(type) ||
+        parser.addTypesToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << ' ' << getAttr(constAttrName()) << " : ";
+    p.printType(getType());
+  }];
+
+  let verifier = [{
+    if (!getType().isa<fir::RealType>())
+      return emitOpError("must be a !fir.real type");
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef constAttrName() { return "constant"; }
+
+    mlir::Attribute getValue() { return getAttr(constAttrName()); }
+  }];
+}
+
 class RealUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_UnaryArithmeticOp<mnemonic, traits>,
       Arguments<(ins AnyRealLike:$operand)>;
@@ -1837,6 +1898,57 @@ def fir_CmpfOp : fir_Op<"cmpf",
   }];
 }
 
+def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]>,
+    Results<(outs fir_ComplexType)> {
+  let summary = "create a complex constant";
+
+  let description = [{
+    FIXME
+  }];
+
+  let parser = [{
+    fir::RealAttr realp;
+    fir::RealAttr imagp;
+    mlir::Type type;
+    if (parser.parseLParen() ||
+        parser.parseAttribute(realp, realAttrName(), result.attributes) ||
+        parser.parseComma() ||
+        parser.parseAttribute(imagp, imagAttrName(), result.attributes) ||
+        parser.parseRParen() ||
+        parser.parseColonType(type) ||
+        parser.addTypesToList(type, result.types))
+      return mlir::failure();
+    return mlir::success();
+  }];
+
+  let printer = [{
+    p << getOperationName() << " (0x";
+    auto f1 = getAttr(realAttrName()).cast<mlir::FloatAttr>();
+    auto i1 = f1.getValue().bitcastToAPInt();
+    p.getStream().write_hex(i1.getZExtValue());
+    p << ", 0x";
+    auto f2 = getAttr(imagAttrName()).cast<mlir::FloatAttr>();
+    auto i2 = f2.getValue().bitcastToAPInt();
+    p.getStream().write_hex(i2.getZExtValue());
+    p << ") : ";
+    p.printType(getType());
+  }];
+
+  let verifier = [{
+    if (!getType().isa<fir::CplxType>())
+      return emitOpError("must be a !fir.complex type");
+    return mlir::success();
+  }];
+
+  let extraClassDeclaration = [{
+    constexpr static llvm::StringRef realAttrName() { return "real"; }
+    constexpr static llvm::StringRef imagAttrName() { return "imaginary"; }
+
+    mlir::Attribute getReal() { return getAttr(realAttrName()); }
+    mlir::Attribute getImaginary() { return getAttr(imagAttrName()); }
+  }];
+}
+
 class ComplexUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_UnaryArithmeticOp<mnemonic, traits>,
       Arguments<(ins fir_ComplexType:$operand)>;
diff --git a/include/flang/optimizer/Dialect/FIRType.h b/include/flang/optimizer/Dialect/FIRType.h
index 116e9f6e939e..3e21553e0c1c 100644
--- a/include/flang/optimizer/Dialect/FIRType.h
+++ b/include/flang/optimizer/Dialect/FIRType.h
@@ -52,6 +52,7 @@ struct SequenceTypeStorage;
 struct TypeDescTypeStorage;
 } // namespace detail
 
+/// Integral identifier for all the types comprising the FIR type system
 enum TypeKind {
   // The enum starts at the range reserved for this dialect.
   FIR_TYPE = mlir::Type::FIRST_FIR_TYPE,
diff --git a/include/flang/optimizer/Support/KindMapping.h b/include/flang/optimizer/Support/KindMapping.h
index 5eb6b03840da..a549a7ed3df2 100644
--- a/include/flang/optimizer/Support/KindMapping.h
+++ b/include/flang/optimizer/Support/KindMapping.h
@@ -15,6 +15,7 @@
 namespace llvm {
 template <typename>
 class Optional;
+struct fltSemantics;
 } // namespace llvm
 
 namespace mlir {
@@ -71,6 +72,9 @@ class KindMapping {
 
   mlir::MLIRContext *getContext() const { return context; }
 
+  /// Get the float semantics of !fir.real<kind>
+  const llvm::fltSemantics &getFloatSemantics(KindTy kind);
+
 private:
   MatchResult badMapString(llvm::Twine const &ptr);
   MatchResult parse(llvm::StringRef kindMap);
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 4b633bf35b60..7ef07a6179c1 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -457,7 +457,7 @@ class ExprLowering {
 
   /// Construct a CHARACTER literal
   template <int KIND, typename E>
-  M::Value genCharLit(const E &data, std::size_t size) {
+  M::Value genCharLit(const E &data, int64_t size) {
     auto context = builder.getContext();
     auto valTag = M::Identifier::get(fir::StringLitOp::value(), context);
     // FIXME: for wider char types, use an array of i16 or i32
@@ -526,7 +526,7 @@ class ExprLowering {
       assert(false && "array of complex unhandled");
       return {};
     } else if constexpr (TC == CharacterCat) {
-      return genCharLit<KIND>(con.GetScalarValue().value(), con.size());
+      return genCharLit<KIND>(con.GetScalarValue().value(), con.LEN());
     } else {
       assert(false && "unhandled constant");
       return {};
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 2f864e21eaeb..6b83ca936beb 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -145,6 +145,16 @@ M::FuncOp getOutputRuntimeFunc(M::OpBuilder &builder, M::Type type) {
   }
 }
 
+inline bool isCharacterLiteral(M::Type argTy) {
+  if (auto arrTy = argTy.dyn_cast<fir::SequenceType>())
+    return arrTy.getEleTy().isa<fir::CharacterType>();
+  return false;
+}
+
+inline int64_t getLength(M::Type argTy) {
+  return argTy.cast<fir::SequenceType>().getShape()[0];
+}
+
 /// The I/O library interface requires that COMPLEX and CHARACTER typed values
 /// be extracted and passed as separate values.
 L::SmallVector<M::Value, 4> splitArguments(M::OpBuilder &builder,
@@ -153,10 +163,11 @@ L::SmallVector<M::Value, 4> splitArguments(M::OpBuilder &builder,
   M::Value one;
   M::Type argTy = arg.getType();
   M::MLIRContext *context = argTy.getContext();
-  bool isComplex = argTy.isa<fir::CplxType>();
-  bool isBoxChar = argTy.isa<fir::BoxCharType>();
+  const bool isComplex = argTy.isa<fir::CplxType>();
+  const bool isCharLit = isCharacterLiteral(argTy);
+  const bool isBoxChar = argTy.isa<fir::BoxCharType>();
 
-  if (isComplex || isBoxChar) {
+  if (isComplex || isCharLit || isBoxChar) {
     // Only create these constants when needed and not every time
     zero = builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(0));
     one = builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(1));
@@ -179,6 +190,13 @@ L::SmallVector<M::Value, 4> splitArguments(M::OpBuilder &builder,
         builder.create<fir::ExtractValueOp>(loc, sizeTy, arg, one);
     return {pointerPart, sizePart};
   }
+  if (isCharLit) {
+    M::Value variable = builder.create<fir::AllocaOp>(loc, argTy);
+    builder.create<fir::StoreOp>(loc, arg, variable);
+    M::Value sizePart = builder.create<M::ConstantOp>(
+        loc, builder.getI64IntegerAttr(getLength(argTy)));
+    return {variable, sizePart};
+  }
   return {arg};
 }
 
diff --git a/lib/lower/RTBuilder.h b/lib/lower/RTBuilder.h
index 9ddff111ac87..870f33511b40 100644
--- a/lib/lower/RTBuilder.h
+++ b/lib/lower/RTBuilder.h
@@ -172,12 +172,19 @@ struct RuntimeTableKey<RT(ATs...)> {
   }
 };
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgcc-extension"
+#endif
 template <char... Cs>
 using RuntimeIdentifier = std::integer_sequence<char, Cs...>;
 template <typename T, T... Cs>
 static constexpr RuntimeIdentifier<Cs...> operator""_rt_ident() {
   return {};
 }
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
 
 template <typename...>
 struct RuntimeTableEntry;
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index 7a35b55fe7ca..240d45b2df48 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -43,23 +43,24 @@
   (void)X;                                                                     \
   assert(false && "not yet implemented")
 
-static llvm::cl::opt<bool>
+using namespace llvm;
+
+static cl::opt<bool>
     ClDisableFirToLLVMIR("disable-fir2llvmir",
-                         llvm::cl::desc("disable FIR to LLVM-IR dialect pass"),
-                         llvm::cl::init(false), llvm::cl::Hidden);
+                         cl::desc("disable FIR to LLVM-IR dialect pass"),
+                         cl::init(false), cl::Hidden);
 
-static llvm::cl::opt<bool> ClDisableLLVM("disable-llvm",
-                                         llvm::cl::desc("disable LLVM pass"),
-                                         llvm::cl::init(false),
-                                         llvm::cl::Hidden);
+static cl::opt<bool> ClDisableLLVM("disable-llvm",
+                                   cl::desc("disable LLVM pass"),
+                                   cl::init(false), cl::Hidden);
 
 using namespace fir;
 
 namespace {
 
-using SmallVecResult = llvm::SmallVector<mlir::Value, 4>;
-using OperandTy = llvm::ArrayRef<mlir::Value>;
-using AttributeTy = llvm::ArrayRef<mlir::NamedAttribute>;
+using SmallVecResult = SmallVector<mlir::Value, 4>;
+using OperandTy = ArrayRef<mlir::Value>;
+using AttributeTy = ArrayRef<mlir::NamedAttribute>;
 
 const unsigned defaultAlign = 8;
 
@@ -67,7 +68,7 @@ const unsigned defaultAlign = 8;
 /// This converts FIR types to LLVM types (for now)
 class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   KindMapping kindMapping;
-  static llvm::StringMap<mlir::LLVM::LLVMType> identStructCache;
+  static StringMap<mlir::LLVM::LLVMType> identStructCache;
 
 public:
   FIRToLLVMTypeConverter(mlir::MLIRContext *context, NameUniquer &uniquer)
@@ -96,7 +97,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   // FIXME: This code should be generated and follow SPOT
   mlir::LLVM::LLVMType convertBoxType(BoxType box) {
     // (buffer*, ele-size, rank, type-descriptor, attribute, [dims])
-    llvm::SmallVector<mlir::LLVM::LLVMType, 6> parts;
+    SmallVector<mlir::LLVM::LLVMType, 6> parts;
     mlir::Type ele = box.getEleTy();
     // auto *ctx = box.getContext();
     auto eleTy = unwrap(convertType(ele));
@@ -125,7 +126,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   mlir::LLVM::LLVMType convertBoxCharType(BoxCharType boxchar) {
     auto ptrTy = convertCharType(boxchar.getEleTy()).getPointerTo();
     auto i64Ty = mlir::LLVM::LLVMType::getInt64Ty(llvmDialect);
-    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple = {ptrTy, i64Ty};
+    SmallVector<mlir::LLVM::LLVMType, 2> tuple = {ptrTy, i64Ty};
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
@@ -134,21 +135,29 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
     auto funcTy = convertType(boxproc.getEleTy());
     auto ptrTy = unwrap(funcTy).getPointerTo();
     auto i8Ty = mlir::LLVM::LLVMType::getInt8Ty(llvmDialect);
-    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple{ptrTy, i8Ty};
+    SmallVector<mlir::LLVM::LLVMType, 2> tuple{ptrTy, i8Ty};
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
+  unsigned characterBitsize(CharacterType charTy) {
+    return kindMapping.getCharacterBitsize(charTy.getFKind());
+  }
+
   // fir.char<n>  -->  llvm<"ix*">   where ix is scaled by kind mapping
   mlir::LLVM::LLVMType convertCharType(CharacterType charTy) {
-    return mlir::LLVM::LLVMType::getIntNTy(
-        llvmDialect, kindMapping.getCharacterBitsize(charTy.getFKind()));
+    return mlir::LLVM::LLVMType::getIntNTy(llvmDialect,
+                                           characterBitsize(charTy));
+  }
+
+  mlir::LLVM::LLVMType convertComplexPartType(KindTy kind) {
+    auto realID = kindMapping.getComplexTypeID(kind);
+    return fromRealTypeID(realID, kind);
   }
 
   // fir.complex<n>  -->  llvm<"{ anyfloat, anyfloat }">
   mlir::LLVM::LLVMType convertComplexType(KindTy kind) {
-    auto realID = kindMapping.getComplexTypeID(kind);
-    auto realTy = fromRealTypeID(realID, kind);
-    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple{realTy, realTy};
+    auto realTy = convertComplexPartType(kind);
+    SmallVector<mlir::LLVM::LLVMType, 2> tuple{realTy, realTy};
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
@@ -189,7 +198,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
       return iter->second;
     auto st{mlir::LLVM::LLVMType::createStructTy(llvmDialect, name)};
     identStructCache[name] = st;
-    llvm::SmallVector<mlir::LLVM::LLVMType, 8> members;
+    SmallVector<mlir::LLVM::LLVMType, 8> members;
     for (auto mem : derived.getTypeList())
       members.push_back(convertType(mem.second).cast<mlir::LLVM::LLVMType>());
     mlir::LLVM::LLVMType::setStructTyBody(st, members);
@@ -213,9 +222,9 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
 
   // tuple<TS...>  -->  llvm<"{ ts... }">
   mlir::LLVM::LLVMType convertTupleType(mlir::TupleType tuple) {
-    llvm::SmallVector<mlir::Type, 8> inMembers;
+    SmallVector<mlir::Type, 8> inMembers;
     tuple.getFlattenedTypes(inMembers);
-    llvm::SmallVector<mlir::LLVM::LLVMType, 8> members;
+    SmallVector<mlir::LLVM::LLVMType, 8> members;
     for (auto mem : inMembers)
       members.push_back(convertType(mem).cast<mlir::LLVM::LLVMType>());
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, members);
@@ -224,7 +233,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   // complex<T>  --> llvm<"{t,t}">
   mlir::LLVM::LLVMType convertComplexType(mlir::ComplexType complex) {
     auto eleTy = unwrap(convertType(complex.getElementType()));
-    llvm::SmallVector<mlir::LLVM::LLVMType, 2> tuple{eleTy, eleTy};
+    SmallVector<mlir::LLVM::LLVMType, 2> tuple{eleTy, eleTy};
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
@@ -261,7 +270,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
       return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
     if (auto logical = t.dyn_cast<LogicalType>())
       return convertLogicalType(logical);
-    if (auto pointer = t.dyn_cast<PointerType>())
+    if (auto pointer = t.dyn_cast<fir::PointerType>())
       return convertPointerLike(pointer);
     if (auto real = t.dyn_cast<RealType>())
       return convertRealType(real.getFKind());
@@ -301,7 +310,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   }
 
   /// HACK: cloned from LLVMTypeConverter since this is private there
-  mlir::LLVM::LLVMType unwrap(Type type) {
+  mlir::LLVM::LLVMType unwrap(mlir::Type type) {
     if (!type)
       return nullptr;
     auto *mlirContext = type.getContext();
@@ -316,13 +325,13 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
 };
 
 // instantiate static data member
-llvm::StringMap<mlir::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
+StringMap<mlir::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
 
 /// remove `omitNames` (by name) from the attribute dictionary
-llvm::SmallVector<mlir::NamedAttribute, 4>
-pruneNamedAttrDict(llvm::ArrayRef<mlir::NamedAttribute> attrs,
-                   llvm::ArrayRef<llvm::StringRef> omitNames) {
-  llvm::SmallVector<mlir::NamedAttribute, 4> result;
+SmallVector<mlir::NamedAttribute, 4>
+pruneNamedAttrDict(ArrayRef<mlir::NamedAttribute> attrs,
+                   ArrayRef<StringRef> omitNames) {
+  SmallVector<mlir::NamedAttribute, 4> result;
   for (auto x : attrs) {
     bool omit = false;
     for (auto o : omitNames)
@@ -350,9 +359,7 @@ class FIROpConversion : public mlir::ConversionPattern {
         lowering(lowering) {}
 
 protected:
-  llvm::LLVMContext &getLLVMContext() const {
-    return lowering.getLLVMContext();
-  }
+  LLVMContext &getLLVMContext() const { return lowering.getLLVMContext(); }
   mlir::LLVM::LLVMDialect *getDialect() const { return lowering.getDialect(); }
   mlir::Type convertType(mlir::Type ty) const {
     return lowering.convertType(ty);
@@ -377,7 +384,7 @@ class FIROpConversion : public mlir::ConversionPattern {
 };
 
 /// Create an LLVM dialect global
-void createGlobal(mlir::Location loc, mlir::ModuleOp mod, llvm::StringRef name,
+void createGlobal(mlir::Location loc, mlir::ModuleOp mod, StringRef name,
                   mlir::LLVM::LLVMType type,
                   mlir::ConversionPatternRewriter &rewriter) {
   if (mod.lookupSymbol<mlir::LLVM::GlobalOp>(name))
@@ -464,7 +471,7 @@ struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
     for (auto opnd : operands)
       size = rewriter.create<mlir::LLVM::MulOp>(loc, ity, size, opnd);
     heap.setAttr("callee", rewriter.getSymbolRefAttr(mallocFunc));
-    llvm::SmallVector<mlir::Value, 1> args{size};
+    SmallVector<mlir::Value, 1> args{size};
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(heap, ty, args,
                                                     heap.getAttrs());
     return matchSuccess();
@@ -501,7 +508,7 @@ struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
     freemem.setAttr("callee", rewriter.getSymbolRefAttr(freeFunc));
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
         freemem, mlir::LLVM::LLVMType::getVoidTy(dialect),
-        llvm::SmallVector<mlir::Value, 1>{bitcast}, freemem.getAttrs());
+        SmallVector<mlir::Value, 1>{bitcast}, freemem.getAttrs());
     return matchSuccess();
   }
 };
@@ -510,7 +517,7 @@ template <typename... ARGS>
 mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::LLVM::LLVMType ty,
                          mlir::ConversionPatternRewriter &rewriter,
                          mlir::Value base, ARGS... args) {
-  llvm::SmallVector<mlir::Value, 8> cv{args...};
+  SmallVector<mlir::Value, 8> cv{args...};
   return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
 }
 
@@ -666,7 +673,7 @@ struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
     auto ity = lowering.offsetType();
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c5 = genConstantOffset(loc, rewriter, 5);
-    llvm::SmallVector<mlir::Value, 4> args{a, c0, c5};
+    SmallVector<mlir::Value, 4> args{a, c0, c5};
     auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, ty, args);
     auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
     auto ab = genConstantOffset(loc, rewriter, 1);
@@ -706,7 +713,7 @@ struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
     auto ty = convertType(boxrank.getType());
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c3 = genConstantOffset(loc, rewriter, 3);
-    llvm::SmallVector<mlir::Value, 4> args{a, c0, c3};
+    SmallVector<mlir::Value, 4> args{a, c0, c3};
     auto pty = unwrap(ty).getPointerTo();
     auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, pty, args);
     rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(boxrank, ty, p);
@@ -726,7 +733,7 @@ struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
     auto ty = convertType(boxtypedesc.getType());
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto c4 = genConstantOffset(loc, rewriter, 4);
-    llvm::SmallVector<mlir::Value, 4> args{a, c0, c4};
+    SmallVector<mlir::Value, 4> args{a, c0, c4};
     auto pty = unwrap(ty).getPointerTo();
     auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, pty, args);
     auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
@@ -736,23 +743,34 @@ struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
   }
 };
 
-struct ConstantOpConversion : public FIROpConversion<fir::StringLitOp> {
+struct StringLitOpConversion : public FIROpConversion<fir::StringLitOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto constop = mlir::cast<fir::StringLitOp>(op);
-    auto ty_ = constop.getType();
-    auto ty = convertType(ty_);
+    auto ty = convertType(constop.getType());
     auto attr = constop.getValue();
-    auto attr_ = attr.cast<mlir::StringAttr>();
-    if (auto ft = ty_.dyn_cast<fir::RealType>()) {
-      llvm::APFloat f{llvm::APFloat::IEEEdouble(), attr_.getValue()};
-      attr = mlir::FloatAttr::get(mlir::FloatType::getF64(constop.getContext()),
-                                  f);
+    if (attr.isa<mlir::StringAttr>()) {
+      rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, attr);
+    } else {
+      // convert the array attr to a dense elements attr
+      // LLVMIR dialect knows how to lower the latter to LLVM IR
+      auto arr = attr.cast<mlir::ArrayAttr>();
+      auto size = constop.getSize().cast<mlir::IntegerAttr>().getInt();
+      auto eleTy = constop.getType().cast<fir::SequenceType>().getEleTy();
+      auto bits = lowering.characterBitsize(eleTy.cast<fir::CharacterType>());
+      auto charTy = rewriter.getIntegerType(bits);
+      auto det = mlir::VectorType::get({size}, charTy);
+      // convert each character to a precise bitsize
+      llvm::SmallVector<mlir::Attribute, 64> vec;
+      for (auto a : arr.getValue())
+        vec.push_back(mlir::IntegerAttr::get(
+            charTy, a.cast<mlir::IntegerAttr>().getValue().sextOrTrunc(bits)));
+      auto dea = mlir::DenseElementsAttr::get(det, vec);
+      rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, dea);
     }
-    rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, attr);
     return matchSuccess();
   }
 };
@@ -765,7 +783,7 @@ struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto call = mlir::cast<fir::CallOp>(op);
-    llvm::SmallVector<mlir::Type, 4> resultTys;
+    SmallVector<mlir::Type, 4> resultTys;
     for (auto r : call.getResults())
       resultTys.push_back(convertType(r.getType()));
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(call, resultTys, operands,
@@ -791,18 +809,18 @@ struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
     auto ty = convertType(fir::RealType::get(ctxt, kind));
     auto loc = cmp.getLoc();
     auto pos0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctxt);
-    llvm::SmallVector<mlir::Value, 2> rp{
+    SmallVector<mlir::Value, 2> rp{
         rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[0], pos0),
         rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[1],
                                                     pos0)};
     auto rcp = rewriter.create<mlir::LLVM::FCmpOp>(loc, ty, rp, cmp.getAttrs());
     auto pos1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctxt);
-    llvm::SmallVector<mlir::Value, 2> ip{
+    SmallVector<mlir::Value, 2> ip{
         rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[0], pos1),
         rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, operands[1],
                                                     pos1)};
     auto icp = rewriter.create<mlir::LLVM::FCmpOp>(loc, ty, ip, cmp.getAttrs());
-    llvm::SmallVector<mlir::Value, 2> cp{rcp, icp};
+    SmallVector<mlir::Value, 2> cp{rcp, icp};
     switch (cmp.getPredicate()) {
     case fir::CmpFPredicate::OEQ: // .EQ.
       rewriter.replaceOpWithNewOp<mlir::LLVM::AndOp>(cmp, ty, cp);
@@ -832,6 +850,50 @@ struct CmpfOpConversion : public FIROpConversion<fir::CmpfOp> {
   }
 };
 
+struct ConstcOpConversion : public FIROpConversion<ConstcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto conc = mlir::cast<ConstcOp>(op);
+    auto loc = conc.getLoc();
+    auto ctx = conc.getContext();
+    auto ty = convertType(conc.getType());
+    auto ct = conc.getType().cast<fir::CplxType>();
+    auto ety = lowering.convertComplexPartType(ct.getFKind());
+    auto ri = mlir::FloatAttr::get(ety, getValue(conc.getReal()));
+    auto rp = rewriter.create<mlir::LLVM::ConstantOp>(loc, ety, ri);
+    auto ii = mlir::FloatAttr::get(ety, getValue(conc.getImaginary()));
+    auto ip = rewriter.create<mlir::LLVM::ConstantOp>(loc, ety, ii);
+    auto c0 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(0), ctx);
+    auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
+    auto r = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+    auto rr = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r, rp, c0);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(conc, ty, rr, ip,
+                                                           c1);
+    return matchSuccess();
+  }
+
+  inline llvm::APFloat getValue(mlir::Attribute attr) const {
+    return attr.cast<fir::RealAttr>().getValue();
+  }
+};
+
+struct ConstfOpConversion : public FIROpConversion<ConstfOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto conf = mlir::cast<ConstfOp>(op);
+    auto ty = convertType(conf.getType());
+    auto val = conf.getValue();
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(conf, ty, val);
+    return matchSuccess();
+  }
+};
+
 /// convert value of from-type to value of to-type
 struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
   using FIROpConversion::FIROpConversion;
@@ -905,7 +967,8 @@ struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
     auto dispatch = mlir::cast<DispatchOp>(op);
     auto ty = convertType(dispatch.getFunctionType());
     // get the table, lookup the method, fetch the func-ptr
-    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(dispatch, ty, operands);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(dispatch, ty, operands,
+                                                    None);
     TODO(dispatch);
     return matchSuccess();
   }
@@ -1076,7 +1139,7 @@ mlir::Attribute getValue(mlir::Value value) {
 }
 
 template <typename A>
-inline void appendTo(llvm::SmallVectorImpl<A> &dest, llvm::ArrayRef<A> from) {
+inline void appendTo(SmallVectorImpl<A> &dest, ArrayRef<A> from) {
   dest.append(from.begin(), from.end());
 }
 
@@ -1091,7 +1154,7 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
     auto ty = convertType(extractVal.getType());
     assert(allConstants(operands.drop_front(1)));
     // since all indices are constants use LLVM's extractvalue instruction
-    llvm::SmallVector<mlir::Attribute, 8> attrs;
+    SmallVector<mlir::Attribute, 8> attrs;
     for (int i = 1, end = operands.size(); i < end; ++i)
       attrs.push_back(getValue(operands[i]));
     auto position = mlir::ArrayAttr::get(attrs, extractVal.getContext());
@@ -1113,7 +1176,7 @@ struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
     auto ty = convertType(insertVal.getType());
     assert(allConstants(operands.drop_front(2)));
     // since all indices must be constants use LLVM's insertvalue instruction
-    llvm::SmallVector<mlir::Attribute, 8> attrs;
+    SmallVector<mlir::Attribute, 8> attrs;
     for (int i = 2, end = operands.size(); i < end; ++i)
       attrs.push_back(getValue(operands[i]));
     auto position = mlir::ArrayAttr::get(attrs, insertVal.getContext());
@@ -1168,7 +1231,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
       base = rewriter.create<mlir::LLVM::LoadOp>(loc, pty, p);
     }
 
-    llvm::SmallVector<mlir::Value, 8> offs{c0};
+    SmallVector<mlir::Value, 8> offs{c0};
     auto indices = operands.drop_front(1);
     offs.append(indices.begin(), indices.end());
     if (noFieldIndexOps(coor.coor())) {
@@ -1180,7 +1243,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     // lower the field index ops by walking the indices
     auto bty = coor.ref().getType().cast<BoxType>();
     mlir::Type baseTy = ReferenceType::get(bty.getEleTy());
-    llvm::SmallVector<mlir::Value, 8> args{c0};
+    SmallVector<mlir::Value, 8> args{c0};
     args.append(coor.coor().begin(), coor.coor().end());
 
     mlir::Value retval = base;
@@ -1228,8 +1291,8 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     return matchSuccess();
   }
 
-  llvm::SmallVector<mlir::Value, 8> arguments(llvm::ArrayRef<mlir::Value> vec,
-                                              unsigned s, unsigned e) const {
+  SmallVector<mlir::Value, 8> arguments(ArrayRef<mlir::Value> vec, unsigned s,
+                                        unsigned e) const {
     return {vec.begin() + s, vec.begin() + e};
   }
 
@@ -1257,7 +1320,7 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
     // the field at runtime
     auto symAttr =
         mlir::SymbolRefAttr::get(methodName(field), field.getContext());
-    llvm::SmallVector<mlir::NamedAttribute, 1> attrs{
+    SmallVector<mlir::NamedAttribute, 1> attrs{
         rewriter.getNamedAttr("callee", symAttr)};
     auto ty = lowering.offsetType();
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(field, ty, operands, attrs);
@@ -1266,10 +1329,10 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
 
   // constructing the name of the method
   inline static std::string methodName(FieldIndexOp field) {
-    llvm::Twine fldName = field.field_id();
+    Twine fldName = field.field_id();
     // note: using std::string to dodge a bug in g++ 7.4.0
     std::string tyName = field.on_type().cast<RecordType>().getName().str();
-    llvm::Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
+    Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
     return methodName.str();
   }
 };
@@ -1316,6 +1379,8 @@ struct FirEndOpConversion : public FIROpConversion<FirEndOp> {
 };
 
 /// lower a gendims operation into a sequence of writes to a temp
+/// TODO: should this be returning a value or a ref? A !fir.dims object has
+/// very restricted application
 struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1331,10 +1396,10 @@ struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
     unsigned offIndex = 0;
     auto c0 = genConstantOffset(loc, rewriter, 0);
     auto ipty = lowering.indexType().getPointerTo();
-    for (auto op : operands) {
-      auto offset = genConstantOffset(loc, rewriter, offIndex);
-      auto gep = genGEP(loc, ipty, rewriter, alloca, c0, offset);
-      rewriter.create<mlir::LLVM::StoreOp>(loc, op, gep);
+    for (auto opd : operands) {
+      auto offset = genConstantOffset(loc, rewriter, offIndex++);
+      auto gep = genGEP(loc, ipty, rewriter, alloca, c0, c0, offset);
+      rewriter.create<mlir::LLVM::StoreOp>(loc, opd, gep);
     }
     rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(gendims, ptrTy, alloca);
     return matchSuccess();
@@ -1414,11 +1479,28 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
                     .getAttrOfType<mlir::StringAttr>(
                         mlir::SymbolTable::getSymbolAttrName())
                     .getValue();
-    mlir::Attribute value;
+    auto value = initializersToAttr(global.getOperation(), rewriter);
     rewriter.replaceOpWithNewOp<mlir::LLVM::GlobalOp>(
-        global, tyAttr, isConst, mlir::LLVM::Linkage::External, name, value);
+        global, tyAttr, isConst, mlir::LLVM::Linkage::LinkonceODR, name, value);
     return matchSuccess();
   }
+
+  // convert the operations in the body into an initializer attr
+  // TODO: only accidentally correct for very simple cases at the moment
+  mlir::Attribute
+  initializersToAttr(mlir::Operation *global,
+                     mlir::ConversionPatternRewriter &rewriter) const {
+    mlir::Attribute val;
+    if (global->getNumRegions() > 0) {
+      mlir::Block &block = global->getRegion(0).front();
+      for (auto &ini : block) {
+        if (auto cop = dyn_cast<mlir::ConstantOp>(ini)) {
+          val = cop.value();
+        }
+      }
+    }
+    return val;
+  }
 };
 
 // convert to LLVM IR dialect `load`
@@ -1456,8 +1538,8 @@ void genCaseLadderStep(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
   auto *thisBlock = rewriter.getInsertionBlock();
   auto *newBlock = rewriter.createBlock(dest);
   rewriter.setInsertionPointToEnd(thisBlock);
-  llvm::SmallVector<mlir::Block *, 2> dest_{dest, newBlock};
-  llvm::SmallVector<mlir::ValueRange, 2> destOps_{destOps, {}};
+  SmallVector<mlir::Block *, 2> dest_{dest, newBlock};
+  SmallVector<mlir::ValueRange, 2> destOps_{destOps, {}};
   rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp}, dest_,
                                         destOps_);
   rewriter.setInsertionPointToEnd(newBlock);
@@ -1471,8 +1553,8 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  llvm::ArrayRef<mlir::Block *> destinations,
-                  llvm::ArrayRef<OperandTy> destOperands,
+                  ArrayRef<mlir::Block *> destinations,
+                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto selectcase = mlir::cast<SelectCaseOp>(op);
     auto conds = selectcase.getNumConditions();
@@ -1513,15 +1595,15 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
         auto *newBlock1 = rewriter.createBlock(destinations[t]);
         auto *newBlock2 = rewriter.createBlock(destinations[t]);
         rewriter.setInsertionPointToEnd(thisBlock);
-        llvm::SmallVector<mlir::Block *, 2> dests{newBlock1, newBlock2};
-        llvm::SmallVector<mlir::ValueRange, 2> destOps{{}, {}};
+        SmallVector<mlir::Block *, 2> dests{newBlock1, newBlock2};
+        SmallVector<mlir::ValueRange, 2> destOps{{}, {}};
         rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp}, dests,
                                               destOps);
         rewriter.setInsertionPointToEnd(newBlock1);
         auto cmp_ = rewriter.create<mlir::LLVM::ICmpOp>(
             loc, mlir::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
-        llvm::SmallVector<mlir::Block *, 2> dest2{destinations[t], newBlock2};
-        llvm::SmallVector<mlir::ValueRange, 2> destOp2{destOperands[t], {}};
+        SmallVector<mlir::Block *, 2> dest2{destinations[t], newBlock2};
+        SmallVector<mlir::ValueRange, 2> destOp2{destOperands[t], {}};
         rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp_},
                                               dest2, destOp2);
         rewriter.setInsertionPointToEnd(newBlock2);
@@ -1540,8 +1622,8 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
 template <typename OP>
 void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering,
                            mlir::Operation *op, OperandTy operands,
-                           llvm::ArrayRef<mlir::Block *> destinations,
-                           llvm::ArrayRef<OperandTy> destOperands,
+                           ArrayRef<mlir::Block *> destinations,
+                           ArrayRef<OperandTy> destOperands,
                            mlir::ConversionPatternRewriter &rewriter) {
   auto select = mlir::cast<OP>(op);
 
@@ -1580,8 +1662,8 @@ struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  llvm::ArrayRef<mlir::Block *> destinations,
-                  llvm::ArrayRef<OperandTy> destOperands,
+                  ArrayRef<mlir::Block *> destinations,
+                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectOp>(lowering, op, operands, destinations,
                                          destOperands, rewriter);
@@ -1595,8 +1677,8 @@ struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  llvm::ArrayRef<mlir::Block *> destinations,
-                  llvm::ArrayRef<OperandTy> destOperands,
+                  ArrayRef<mlir::Block *> destinations,
+                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectRankOp>(
         lowering, op, operands, destinations, destOperands, rewriter);
@@ -1610,8 +1692,8 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  llvm::ArrayRef<mlir::Block *> destinations,
-                  llvm::ArrayRef<OperandTy> destOperands,
+                  ArrayRef<mlir::Block *> destinations,
+                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto selecttype = mlir::cast<SelectTypeOp>(op);
     TODO(selecttype);
@@ -1753,7 +1835,7 @@ struct UnreachableOpConversion : public FIROpConversion<UnreachableOp> {
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto unreach = mlir::cast<UnreachableOp>(op);
     rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(
-        unreach, operands, llvm::None, llvm::None, unreach.getAttrs());
+        unreach, operands, None, None, unreach.getAttrs());
     return matchSuccess();
   }
 };
@@ -2021,20 +2103,20 @@ struct FIRToLLVMLoweringPass : public mlir::ModulePass<FIRToLLVMLoweringPass> {
         BoxIsAllocOpConversion, BoxIsArrayOpConversion, BoxIsPtrOpConversion,
         BoxProcHostOpConversion, BoxRankOpConversion, BoxTypeDescOpConversion,
         CallOpConversion, CmpcOpConversion, CmpfOpConversion,
-        ConstantOpConversion, ConvertOpConversion, CoordinateOpConversion,
-        DispatchOpConversion, DispatchTableOpConversion, DivcOpConversion,
-        DivfOpConversion, DTEntryOpConversion, EmboxCharOpConversion,
-        EmboxOpConversion, EmboxProcOpConversion, FieldIndexOpConversion,
-        FirEndOpConversion, ExtractValueOpConversion, FreeMemOpConversion,
-        GenDimsOpConversion, GenTypeDescOpConversion, GlobalEntryOpConversion,
-        GlobalOpConversion, InsertValueOpConversion, LenParamIndexOpConversion,
-        LoadOpConversion, ModfOpConversion, MulcOpConversion, MulfOpConversion,
-        NegcOpConversion, NegfOpConversion, NoReassocOpConversion,
-        SelectCaseOpConversion, SelectOpConversion, SelectRankOpConversion,
-        SelectTypeOpConversion, StoreOpConversion, SubcOpConversion,
-        SubfOpConversion, UnboxCharOpConversion, UnboxOpConversion,
-        UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion>(
-        context, typeConverter);
+        ConstcOpConversion, ConstfOpConversion, ConvertOpConversion,
+        CoordinateOpConversion, DispatchOpConversion, DispatchTableOpConversion,
+        DivcOpConversion, DivfOpConversion, DTEntryOpConversion,
+        EmboxCharOpConversion, EmboxOpConversion, EmboxProcOpConversion,
+        FieldIndexOpConversion, FirEndOpConversion, ExtractValueOpConversion,
+        FreeMemOpConversion, GenDimsOpConversion, GenTypeDescOpConversion,
+        GlobalEntryOpConversion, GlobalOpConversion, InsertValueOpConversion,
+        LenParamIndexOpConversion, LoadOpConversion, ModfOpConversion,
+        MulcOpConversion, MulfOpConversion, NegcOpConversion, NegfOpConversion,
+        NoReassocOpConversion, SelectCaseOpConversion, SelectOpConversion,
+        SelectRankOpConversion, SelectTypeOpConversion, StoreOpConversion,
+        StringLitOpConversion, SubcOpConversion, SubfOpConversion,
+        UnboxCharOpConversion, UnboxOpConversion, UnboxProcOpConversion,
+        UndefOpConversion, UnreachableOpConversion>(context, typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, patterns);
     mlir::ConversionTarget target{*context};
     target.addLegalDialect<mlir::LLVM::LLVMDialect>();
@@ -2069,7 +2151,7 @@ struct FIRToLLVMLoweringPass : public mlir::ModulePass<FIRToLLVMLoweringPass> {
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
 struct LLVMIRLoweringPass : public mlir::ModulePass<LLVMIRLoweringPass> {
-  LLVMIRLoweringPass(llvm::raw_ostream &output) : output{output} {}
+  LLVMIRLoweringPass(raw_ostream &output) : output{output} {}
 
   void runOnModule() override {
     if (ClDisableLLVM)
@@ -2086,7 +2168,7 @@ struct LLVMIRLoweringPass : public mlir::ModulePass<LLVMIRLoweringPass> {
   }
 
 private:
-  llvm::raw_ostream &output;
+  raw_ostream &output;
 };
 
 } // namespace
@@ -2097,6 +2179,6 @@ fir::createFIRToLLVMPass(fir::NameUniquer &nameUniquer) {
 }
 
 std::unique_ptr<mlir::Pass>
-fir::createLLVMDialectToLLVMPass(llvm::raw_ostream &output) {
+fir::createLLVMDialectToLLVMPass(raw_ostream &output) {
   return std::make_unique<LLVMIRLoweringPass>(output);
 }
diff --git a/lib/optimizer/Dialect/FIRAttr.cpp b/lib/optimizer/Dialect/FIRAttr.cpp
index 8694e99b2d9b..45b98ff9e884 100644
--- a/lib/optimizer/Dialect/FIRAttr.cpp
+++ b/lib/optimizer/Dialect/FIRAttr.cpp
@@ -9,11 +9,13 @@
 #include "flang/optimizer/Dialect/FIRAttr.h"
 #include "flang/optimizer/Dialect/FIRDialect.h"
 #include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/optimizer/Support/KindMapping.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 
@@ -22,11 +24,45 @@ using namespace fir;
 namespace fir {
 namespace detail {
 
+struct RealAttributeStorage : public mlir::AttributeStorage {
+  using KeyTy = std::pair<int, llvm::APFloat>;
+
+  RealAttributeStorage(int kind, const llvm::APFloat &value)
+      : kind(kind), value(value) {}
+  RealAttributeStorage(const KeyTy &key)
+      : RealAttributeStorage(key.first, key.second) {}
+
+  static unsigned hashKey(const KeyTy &key) {
+    auto hashVal = llvm::hash_combine(key.first);
+    return llvm::hash_combine(hashVal, key.second);
+  }
+
+  bool operator==(const KeyTy &key) const {
+    return key.first == kind &&
+           key.second.compare(value) == llvm::APFloatBase::cmpEqual;
+  }
+
+  static RealAttributeStorage *
+  construct(mlir::AttributeStorageAllocator &allocator, const KeyTy &key) {
+    return new (allocator.allocate<RealAttributeStorage>())
+        RealAttributeStorage(key);
+  }
+
+  int getFKind() const { return kind; }
+  llvm::APFloat getValue() const { return value; }
+
+private:
+  int kind;
+  llvm::APFloat value;
+};
+
 /// An attribute representing a reference to a type.
 struct TypeAttributeStorage : public mlir::AttributeStorage {
   using KeyTy = mlir::Type;
 
-  TypeAttributeStorage(mlir::Type value) : value(value) {}
+  TypeAttributeStorage(mlir::Type value) : value(value) {
+    assert(value && "must not be of Type null");
+  }
 
   /// Key equality function.
   bool operator==(const KeyTy &key) const { return key == value; }
@@ -38,6 +74,9 @@ struct TypeAttributeStorage : public mlir::AttributeStorage {
         TypeAttributeStorage(key);
   }
 
+  mlir::Type getType() const { return value; }
+
+private:
   mlir::Type value;
 };
 } // namespace detail
@@ -46,13 +85,13 @@ ExactTypeAttr ExactTypeAttr::get(mlir::Type value) {
   return Base::get(value.getContext(), FIR_EXACTTYPE, value);
 }
 
-mlir::Type ExactTypeAttr::getType() const { return getImpl()->value; }
+mlir::Type ExactTypeAttr::getType() const { return getImpl()->getType(); }
 
 SubclassAttr SubclassAttr::get(mlir::Type value) {
   return Base::get(value.getContext(), FIR_SUBCLASS, value);
 }
 
-mlir::Type SubclassAttr::getType() const { return getImpl()->value; }
+mlir::Type SubclassAttr::getType() const { return getImpl()->getType(); }
 
 using AttributeUniquer = mlir::detail::AttributeUniquer;
 
@@ -72,6 +111,59 @@ PointIntervalAttr PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<PointIntervalAttr>(ctxt, getId());
 }
 
+// RealAttr
+
+RealAttr RealAttr::get(mlir::MLIRContext *ctxt,
+                       const RealAttr::ValueType &key) {
+  return Base::get(ctxt, getId(), key);
+}
+
+int RealAttr::getFKind() const { return getImpl()->getFKind(); }
+
+llvm::APFloat RealAttr::getValue() const { return getImpl()->getValue(); }
+
+// FIR attribute parsing
+
+namespace {
+mlir::Attribute parseFirRealAttr(FIROpsDialect *dialect,
+                                 mlir::DialectAsmParser &parser,
+                                 mlir::Type type) {
+  int kind;
+  if (parser.parseLess() || parser.parseInteger(kind) || parser.parseComma()) {
+    parser.emitError(parser.getNameLoc(), "expected '<' kind ','");
+    return {};
+  }
+  KindMapping kindMap(dialect->getContext());
+  llvm::APFloat value(0.);
+  if (parser.parseOptionalKeyword("i")) {
+    // `i` not present, so literal float must be present
+    double dontCare;
+    if (parser.parseFloat(dontCare) || parser.parseGreater()) {
+      parser.emitError(parser.getNameLoc(), "expected real constant '>'");
+      return {};
+    }
+    auto fltStr = parser.getFullSymbolSpec()
+                      .drop_until([](char c) { return c == ','; })
+                      .drop_front()
+                      .drop_while([](char c) { return c == ' ' || c == '\t'; })
+                      .take_until([](char c) {
+                        return c == '>' || c == ' ' || c == '\t';
+                      });
+    value = llvm::APFloat(kindMap.getFloatSemantics(kind), fltStr);
+  } else {
+    // `i` is present, so literal bitstring (hex) must be present
+    llvm::StringRef hex;
+    if (parser.parseKeyword(&hex) || parser.parseGreater()) {
+      parser.emitError(parser.getNameLoc(), "expected real constant '>'");
+      return {};
+    }
+    auto bits = llvm::APInt(kind * 8, hex.drop_front(), 16);
+    value = llvm::APFloat(kindMap.getFloatSemantics(kind), bits);
+  }
+  return RealAttr::get(dialect->getContext(), {kind, value});
+}
+} // namespace
+
 mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
                                   mlir::DialectAsmParser &parser,
                                   mlir::Type type) {
@@ -84,36 +176,34 @@ mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
 
   if (attrName == ExactTypeAttr::getAttrName()) {
     mlir::Type type;
-    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater())
       parser.emitError(loc, "expected a type");
-    }
     return ExactTypeAttr::get(type);
   }
   if (attrName == SubclassAttr::getAttrName()) {
     mlir::Type type;
-    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater())
       parser.emitError(loc, "expected a subtype");
-    }
     return SubclassAttr::get(type);
   }
-  if (attrName == PointIntervalAttr::getAttrName()) {
+  if (attrName == PointIntervalAttr::getAttrName())
     return PointIntervalAttr::get(dialect->getContext());
-  }
-  if (attrName == LowerBoundAttr::getAttrName()) {
+  if (attrName == LowerBoundAttr::getAttrName())
     return LowerBoundAttr::get(dialect->getContext());
-  }
-  if (attrName == UpperBoundAttr::getAttrName()) {
+  if (attrName == UpperBoundAttr::getAttrName())
     return UpperBoundAttr::get(dialect->getContext());
-  }
-  if (attrName == ClosedIntervalAttr::getAttrName()) {
+  if (attrName == ClosedIntervalAttr::getAttrName())
     return ClosedIntervalAttr::get(dialect->getContext());
-  }
+  if (attrName == RealAttr::getAttrName())
+    return parseFirRealAttr(dialect, parser, type);
 
   llvm::Twine msg{"unknown FIR attribute: "};
   parser.emitError(loc, msg.concat(attrName));
   return {};
 }
 
+// FIR attribute pretty printer
+
 void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
                        mlir::DialectAsmPrinter &p) {
   auto &os = p.getStream();
@@ -133,6 +223,11 @@ void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
     os << fir::LowerBoundAttr::getAttrName();
   } else if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
     os << fir::UpperBoundAttr::getAttrName();
+  } else if (auto a = attr.dyn_cast_or_null<fir::RealAttr>()) {
+    os << fir::RealAttr::getAttrName() << '<' << a.getFKind() << ", i x";
+    llvm::SmallString<40> ss;
+    a.getValue().bitcastToAPInt().toStringUnsigned(ss, 16);
+    os << ss << '>';
   } else {
     assert(false && "attribute pretty-printer is not implemented");
   }
diff --git a/lib/optimizer/Dialect/FIRDialect.cpp b/lib/optimizer/Dialect/FIRDialect.cpp
index c8bc3baa4b2f..c5497abbc996 100644
--- a/lib/optimizer/Dialect/FIRDialect.cpp
+++ b/lib/optimizer/Dialect/FIRDialect.cpp
@@ -46,7 +46,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
            FieldType, HeapType, IntType, LenType, LogicalType, PointerType,
            RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
   addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
-                PointIntervalAttr, SubclassAttr, UpperBoundAttr>();
+                PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<GlobalOp, DispatchTableOp,
 #define GET_OP_LIST
 #include "flang/optimizer/Dialect/FIROps.cpp.inc"
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
index e00995ec9175..9516e03b0e36 100644
--- a/lib/optimizer/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -516,6 +516,13 @@ mlir::Type StoreOp::elementType(mlir::Type refType) {
   return {};
 }
 
+// StringLitOp
+
+bool StringLitOp::isWideValue() {
+  auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
+  return eleTy.cast<fir::CharacterType>().getFKind() != 1;
+}
+
 // WhereOp
 
 void WhereOp::build(mlir::Builder *builder, mlir::OperationState &result,
diff --git a/lib/optimizer/Support/KindMapping.cpp b/lib/optimizer/Support/KindMapping.cpp
index aec5882c82c9..a4001861b57e 100644
--- a/lib/optimizer/Support/KindMapping.cpp
+++ b/lib/optimizer/Support/KindMapping.cpp
@@ -80,6 +80,26 @@ LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
   return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
 }
 
+template <char KEY, typename MAP>
+const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind, const MAP &map) {
+  switch (doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind)) {
+  case LLVMTypeID::HalfTyID:
+    return llvm::APFloat::IEEEhalf();
+  case LLVMTypeID::FloatTyID:
+    return llvm::APFloat::IEEEsingle();
+  case LLVMTypeID::DoubleTyID:
+    return llvm::APFloat::IEEEdouble();
+  case LLVMTypeID::X86_FP80TyID:
+    return llvm::APFloat::x87DoubleExtended();
+  case LLVMTypeID::FP128TyID:
+    return llvm::APFloat::IEEEquad();
+  case LLVMTypeID::PPC_FP128TyID:
+    return llvm::APFloat::PPCDoubleDouble();
+  default:
+    llvm_unreachable("Invalid floating type");
+  }
+}
+
 MatchResult parseCode(char &code, const char *&ptr) {
   if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
     return {};
@@ -212,4 +232,8 @@ LLVMTypeID KindMapping::getComplexTypeID(KindTy kind) {
   return getFloatLikeTypeID<'c'>(kind, floatMap);
 }
 
+const llvm::fltSemantics &KindMapping::getFloatSemantics(KindTy kind) {
+  return getFloatSemanticsOfKind<'r'>(kind, floatMap);
+}
+
 } // namespace fir
diff --git a/test-lit/fir/widechar.fir b/test-lit/fir/widechar.fir
new file mode 100644
index 000000000000..c6ae70309980
--- /dev/null
+++ b/test-lit/fir/widechar.fir
@@ -0,0 +1,22 @@
+// RUN: tco %s | FileCheck %s
+
+// CHECK-LABEL: @character_literal1
+func @character_literal1() -> !fir.array<13 x !fir.char<1>> {
+  %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1>
+  // CHECK: ret [13 x i8] c"Hello, World!"
+  return %0 : !fir.array<13 x !fir.char<1>>
+}
+
+// CHECK-LABEL: @character_literal2
+func @character_literal2() -> !fir.array<2 x !fir.char<2>> {
+  %0 = fir.string_lit [234, 456](2) : !fir.char<2>
+  // CHECK: ret [2 x i16] [i16 234, i16 456]
+  return %0 : !fir.array<2 x !fir.char<2>>
+}
+
+// CHECK-LABEL: @character_literal4
+func @character_literal4() -> !fir.array<3 x !fir.char<4>> {
+  %0 = fir.string_lit [89123, 999256, 4](3) : !fir.char<4>
+  // CHECK: ret [3 x i32] [i32 89123, i32 999256, i32 4]
+  return %0 : !fir.array<3 x !fir.char<4>>
+}
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 544c4ad7e76d..637bd939dc05 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -34,54 +34,54 @@
 
 namespace {
 
-namespace Cl = llvm::cl;
+using namespace llvm;
 
-Cl::opt<std::string> inputFilename(Cl::Positional, Cl::desc("<input file>"),
-                                   Cl::init("-"));
+cl::opt<std::string> inputFilename(cl::Positional, cl::desc("<input file>"),
+                                   cl::init("-"));
 
-Cl::opt<std::string> outputFilename("o", Cl::desc("Specify output filename"),
-                                    Cl::value_desc("filename"), Cl::init("-"));
+cl::opt<std::string> outputFilename("o", cl::desc("Specify output filename"),
+                                    cl::value_desc("filename"), cl::init("-"));
 
-Cl::opt<bool> emitFir("emit-fir", Cl::desc("Parse and pretty-print the input"),
-                      Cl::init(false));
+cl::opt<bool> emitFir("emit-fir", cl::desc("Parse and pretty-print the input"),
+                      cl::init(false));
 
-void printModuleBody(mlir::ModuleOp mod) {
+void printModuleBody(mlir::ModuleOp mod, raw_ostream &output) {
   // don't output the terminator bogo-op
   auto e{--mod.end()};
   for (auto i{mod.begin()}; i != e; ++i) {
-    i->print(llvm::outs());
-    llvm::outs() << "\n\n";
+    i->print(output);
+    output << "\n\n";
   }
 }
 
 // compile a .fir file
 int compileFIR() {
   // check that there is a file to load
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
-      llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> fileOrErr =
+      MemoryBuffer::getFileOrSTDIN(inputFilename);
 
   if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open file: " << EC.message() << '\n';
+    errs() << "Could not open file: " << EC.message() << '\n';
     return 1;
   }
 
   // load the file into a module
-  llvm::SourceMgr sourceMgr;
-  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
+  SourceMgr sourceMgr;
+  sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), SMLoc());
   auto context = std::make_unique<mlir::MLIRContext>();
   auto owningRef = mlir::parseSourceFile(sourceMgr, context.get());
 
   if (!owningRef) {
-    llvm::errs() << "Error can't load file " << inputFilename << '\n';
+    errs() << "Error can't load file " << inputFilename << '\n';
     return 2;
   }
   if (mlir::failed(owningRef->verify())) {
-    llvm::errs() << "Error verifying FIR module\n";
+    errs() << "Error verifying FIR module\n";
     return 4;
   }
 
   std::error_code ec;
-  llvm::ToolOutputFile out(outputFilename, ec, llvm::sys::fs::OF_None);
+  ToolOutputFile out(outputFilename, ec, sys::fs::OF_None);
 
   // run passes
   fir::NameUniquer uniquer;
@@ -90,7 +90,10 @@ int compileFIR() {
   mlir::applyPassManagerCLOptions(pm);
   if (emitFir) {
     // parse the input and pretty-print it back out
+    // -emit-fir intentionally disables all the passes
   } else {
+    // add all the passes
+    // the user can disable them individually
     pm.addPass(fir::createMemToRegPass());
     pm.addPass(fir::createCSEPass());
     // convert fir dialect to affine
@@ -103,21 +106,27 @@ int compileFIR() {
     pm.addPass(fir::createFIRToLLVMPass(uniquer));
     pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
   }
+
+  // run the pass manager
   if (mlir::succeeded(pm.run(*owningRef))) {
-    if (emitFir)
-      printModuleBody(*owningRef);
+    // passes ran successfully, so keep the output
+    if (emitFir) 
+      printModuleBody(*owningRef, out.os());
     out.keep();
     return 0;
   }
-  llvm::errs() << "FAILED: " << inputFilename << '\n';
+
+  // pass manager failed
+  printModuleBody(*owningRef, errs());
+  errs() << "\nFAILED: " << inputFilename << '\n';
   return 8;
 }
 } // namespace
 
 int main(int argc, char **argv) {
-  [[maybe_unused]] llvm::InitLLVM y(argc, argv);
+  [[maybe_unused]] InitLLVM y(argc, argv);
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
-  Cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Opt\n");
+  cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Opt\n");
   return compileFIR();
 }

From 3774da555d77727ca40cd720413a5472839a0882 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 11 Feb 2020 15:46:11 -0800
Subject: [PATCH 184/345] add test

---
 include/flang/optimizer/Dialect/FIROps.td | 29 +++++++++++++-----
 include/flang/optimizer/Dialect/FIRType.h |  1 +
 lib/optimizer/Dialect/FIROps.cpp          | 37 +++++++++++++++++++++++
 test-lit/fir/embox-write.fir              | 18 +++++++++++
 4 files changed, 78 insertions(+), 7 deletions(-)
 create mode 100644 test-lit/fir/embox-write.fir

diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index 129db80413ef..ba791b399ca4 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -189,7 +189,7 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
     if (parser.parseType(intype))
       return mlir::failure();
     auto &builder = parser.getBuilder();
-    result.addAttribute("in_type", mlir::TypeAttr::get(intype));
+    result.addAttribute(inType(), mlir::TypeAttr::get(intype));
     llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
     llvm::SmallVector<mlir::Type, 8> typeVec;
     bool hasOperands = false;
@@ -224,7 +224,7 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
   }];
 
   let printer = [{
-    p << getOperationName() << ' ' << getAttr("in_type");
+    p << getOperationName() << ' ' << getAttr(inType());
     if (hasLenParams()) {
       p << '(';
       p.printOperands(getLenParams());
@@ -234,11 +234,12 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
       p << ", ";
       p.printOperand(sh);
     }
-    p.printOptionalAttrDict(getAttrs(), {"in_type", lenpName()});
+    p.printOptionalAttrDict(getAttrs(), {inType(), lenpName()});
   }];
 
   string extraAllocClassDeclaration = [{
-    constexpr static llvm::StringRef lenpName() { return "len_param_count"; }
+    static constexpr llvm::StringRef inType() { return "in_type"; }
+    static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
     mlir::Type getAllocatedType();
     bool hasLenParams() { return bool{getAttr(lenpName())}; }
     unsigned numLenParams() {
@@ -253,6 +254,20 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
       return {operand_begin() + numLenParams(), operand_end()};
     }
     static mlir::Type getRefTy(mlir::Type ty);
+
+    /// Get the input type of the allocation
+    mlir::Type getInType() {
+      return getAttrOfType<mlir::TypeAttr>(inType()).getValue();
+    }
+  }];
+
+  // Verify checks common to all allocation operations
+  string allocVerify = [{
+    llvm::SmallVector<llvm::StringRef, 8> visited;
+    if (verifyInType(getInType(), visited))
+      return emitOpError("invalid type for allocation");
+    if (verifyRecordLenParams(getInType(), numLenParams()))
+      return emitOpError("LEN params do not correspond to type");
   }];
 }
 
@@ -272,9 +287,9 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
       %1 = fir.call @foo(%0) : (!fir.ref<f32>) -> i32
   }];
 
-  let verifier = [{
+  let verifier = allocVerify#[{
     mlir::Type outType = getType();
-    if (!outType.dyn_cast<fir::ReferenceType>())
+    if (!outType.isa<fir::ReferenceType>())
       return emitOpError("must be a !fir.ref type");
     return mlir::success();
   }];
@@ -412,7 +427,7 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
       fir.freemem %0 : !fir.heap<!fir.array<10xf32>>
   }];
 
-  let verifier = [{
+  let verifier = allocVerify#[{
     mlir::Type outType = getType();
     if (!outType.dyn_cast<fir::HeapType>())
       return emitOpError("must be a !fir.heap type");
diff --git a/include/flang/optimizer/Dialect/FIRType.h b/include/flang/optimizer/Dialect/FIRType.h
index 3e21553e0c1c..326c53353cdf 100644
--- a/include/flang/optimizer/Dialect/FIRType.h
+++ b/include/flang/optimizer/Dialect/FIRType.h
@@ -316,6 +316,7 @@ class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
     return getTypeList()[index].second;
   }
   unsigned getNumFields() { return getTypeList().size(); }
+  unsigned getNumLenParams() { return getLenParamList().size(); }
 
   static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
   void finalize(llvm::ArrayRef<TypePair> lenPList,
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
index 9516e03b0e36..440dc60387e9 100644
--- a/lib/optimizer/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -20,6 +20,43 @@
 
 namespace fir {
 
+/// return true if the sequence type is abstract or the record type is malformed
+/// or contains an abstract sequence type
+static bool verifyInType(mlir::Type inType,
+                         llvm::SmallVectorImpl<llvm::StringRef> &visited) {
+  if (auto st = inType.dyn_cast<fir::SequenceType>()) {
+    auto shape = st.getShape();
+    if (shape.size() == 0)
+      return true;
+    for (auto ext : shape)
+      if (ext < 0)
+        return true;
+  } else if (auto rt = inType.dyn_cast<fir::RecordType>()) {
+    // don't recurse if we're already visiting this one
+    for (auto name : visited)
+      if (name == rt.getName())
+        return false;
+    // keep track of record types currently being visited
+    visited.push_back(rt.getName());
+    for (auto &field : rt.getTypeList())
+      if (verifyInType(field.second, visited))
+        return true;
+    visited.pop_back();
+  } else if (auto rt = inType.dyn_cast<fir::PointerType>()) {
+    return verifyInType(rt.getEleTy(), visited);
+  }
+  return false;
+}
+
+static bool verifyRecordLenParams(mlir::Type inType, unsigned numLenParams) {
+  if (numLenParams > 0) {
+    if (auto rt = inType.dyn_cast<fir::RecordType>())
+      return numLenParams != rt.getNumLenParams();
+    return true;
+  }
+  return false;
+}
+
 // AllocaOp
 
 mlir::Type AllocaOp::getAllocatedType() {
diff --git a/test-lit/fir/embox-write.fir b/test-lit/fir/embox-write.fir
new file mode 100644
index 000000000000..465848fdbd64
--- /dev/null
+++ b/test-lit/fir/embox-write.fir
@@ -0,0 +1,18 @@
+// RUN: tco -emit-fir %s | tco | FileCheck %s
+
+// CHECK-LABEL: @set_all_n
+func @set_all_n(%n : index, %x : i32) {
+  %aTmp = fir.alloca i32, %n
+  %aMem = fir.convert %aTmp : (!fir.ref<i32>) -> !fir.ref<!fir.array<?xi32>>
+  %c1 = constant 1 : index
+  %aDim = fir.gendims %c1, %n, %c1 : (index, index, index) -> !fir.dims<1>
+  %a = fir.embox %aMem, %aDim : (!fir.ref<!fir.array<?xi32>>, !fir.dims<1>) -> !fir.box<!fir.array<?xi32>>
+  // CHECK: phi i64
+  // CHECK-NEXT: icmp
+  fir.loop %i = %c1 to %n unordered {
+    %1 = fir.coordinate_of %a, %i : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+    // CHECK: store i32 %{{.*}}, i32* %{{.*}}
+    fir.store %x to %1 : !fir.ref<i32>
+  }
+  return
+}

From bca151462fe0887494ca68771d746b0550e1eb84 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 12 Feb 2020 17:14:17 -0800
Subject: [PATCH 185/345] misc changes

---
 include/flang/lower/ConvertExpr.h         |  12 ++-
 include/flang/optimizer/Dialect/FIROps.td | 112 +++++++---------------
 lib/lower/ConvertExpr.cpp                 |   4 +-
 lib/optimizer/CodeGen.cpp                 |   8 ++
 lib/optimizer/Transforms/MemToReg.cpp     |   9 +-
 tools/bbc/bbc.cpp                         |  59 +++++++-----
 6 files changed, 99 insertions(+), 105 deletions(-)

diff --git a/include/flang/lower/ConvertExpr.h b/include/flang/lower/ConvertExpr.h
index c648a891a319..70154aafa03c 100644
--- a/include/flang/lower/ConvertExpr.h
+++ b/include/flang/lower/ConvertExpr.h
@@ -44,6 +44,9 @@ namespace lower {
 class AbstractConverter;
 class SymMap;
 
+/// Create an expression.
+/// Lowers `expr` to the FIR dialect of MLIR. The expression is lowered to a
+/// value result.
 mlir::Value createSomeExpression(mlir::Location loc,
                                  AbstractConverter &converter,
                                  const evaluate::Expr<evaluate::SomeType> &expr,
@@ -55,14 +58,21 @@ createI1LogicalExpression(mlir::Location loc, AbstractConverter &converter,
                           const evaluate::Expr<evaluate::SomeType> &expr,
                           SymMap &symMap, const IntrinsicLibrary &intrinsics);
 
+/// Create an address.
+/// Lowers `expr` to the FIR dialect of MLIR. The expression must be an entity
+/// and the address of the entity is returned.
 mlir::Value createSomeAddress(mlir::Location loc, AbstractConverter &converter,
                               const evaluate::Expr<evaluate::SomeType> &expr,
                               SymMap &symMap,
                               const IntrinsicLibrary &intrinsics);
 
+/// Create a temporary. A temp is allocated using `fir.alloca` and can be read
+/// and written using `fir.load` and `fir.store`, resp.  The temporary can be
+/// given a name via a front-end `Symbol` or a `StringRef`.
 mlir::Value createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
                             SymMap &symMap, mlir::Type type,
-                            const semantics::Symbol *symbol);
+                            const semantics::Symbol *symbol = nullptr,
+                            llvm::StringRef name = {});
 
 } // namespace lower
 } // namespace Fortran
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index ba791b399ca4..bf35b17a0666 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -101,29 +101,17 @@ class fir_Op<string mnemonic, list<OpTrait> traits>
 // Base class for FIR operations that take a single argument
 class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   : fir_Op<mnemonic, traits> {
-  let parser = [{
-    mlir::FunctionType type;
-    mlir::OpAsmParser::OperandType opnd;
-    if (parser.parseOperand(opnd) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperand(opnd, type.getInput(0), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
 
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(*getODSOperands(0).begin());
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
   }];
 }
 
 // Base builder for allocate operations
 def fir_AllocateOpBuilder : OpBuilder<
   "Builder *builder, OperationState &result, Type inType,"
-  "ArrayRef<Value> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
+  "ArrayRef<Value> lenParams = {}, ArrayRef<Value> sizes = {},"
+  "ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
     result.addAttribute("in_type", mlir::TypeAttr::get(inType));
@@ -134,7 +122,8 @@ def fir_AllocateOpBuilder : OpBuilder<
 
 def fir_NamedAllocateOpBuilder : OpBuilder<
   "Builder *builder, OperationState &result, Type inType, StringRef name,"
-  "ArrayRef<Value> sizes = {}, ArrayRef<NamedAttribute> attributes = {}",
+  "ArrayRef<Value> lenParams = {}, ArrayRef<Value> sizes = {},"
+  "ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
     result.addAttribute("in_type", mlir::TypeAttr::get(inType));
@@ -194,8 +183,10 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
     llvm::SmallVector<mlir::Type, 8> typeVec;
     bool hasOperands = false;
     if (!parser.parseOptionalLParen()) {
+      // parse the LEN params of the derived type. (<params> : <types)
       if (parser.parseOperandList(operands,
                                   mlir::OpAsmParser::Delimiter::None) ||
+          parser.parseColonTypeList(typeVec) ||
           parser.parseRParen())
         return mlir::failure();
       auto lens = builder.getI32IntegerAttr(operands.size());
@@ -203,13 +194,17 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
       hasOperands = true;
     }
     if (!parser.parseOptionalComma()) {
+      // parse size to scale by, vector of n dimensions of type index
+      auto opSize = operands.size();
       if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None))
         return mlir::failure();
+      for (auto i = opSize, end = operands.size(); i != end; ++i)
+        typeVec.push_back(builder.getIndexType());
       hasOperands = true;
     }
     if (hasOperands &&
-        parser.resolveOperands(operands, {builder.getIndexType()},
-            parser.getNameLoc(), result.operands))
+        parser.resolveOperands(operands, typeVec, parser.getNameLoc(),
+                               result.operands))
       return mlir::failure();
     mlir::Type restype = wrapResultType(intype);
     if (!restype) {
@@ -226,10 +221,17 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
   let printer = [{
     p << getOperationName() << ' ' << getAttr(inType());
     if (hasLenParams()) {
+      // print the LEN parameters to a derived type in parens
       p << '(';
       p.printOperands(getLenParams());
+      p << " : ";
+      mlir::interleaveComma(getLenParams(), p.getStream(),
+                            [&](const auto &opnd) {
+                                p.printType(opnd.getType());
+                            });
       p << ')';
     }
+    // print the shape of the allocation (if any); all must be index type
     for (auto sh : getShapeOperands()) {
       p << ", ";
       p.printOperand(sh);
@@ -917,9 +919,9 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
   }];
 }
 
-def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
-    Results<(outs fir_BoxCharType)>,
-    Arguments<(ins AnyReferenceLike:$memref, AnyIntegerLike:$len)> {
+def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
+  let results = (outs fir_BoxCharType);
+  let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
   let summary = "boxes a given CHARACTER reference and its LEN parameter";
 
   let description = [{
@@ -936,26 +938,8 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]>,
                                    i32) -> !fir.boxchar<1>
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-    if (parser.parseOperandList(operands, 2,
-            mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(memref());
-    p << ", ";
-    p.printOperand(len());
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let assemblyFormat = [{
+    $memref `,` $len attr-dict `:` functional-type(operands, results)
   }];
 
   let verifier = [{
@@ -2043,33 +2027,16 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
   }];
 }
 
-def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]>,
-    Arguments<(ins AnyType:$value)> {
+def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
+  let arguments = (ins AnyType:$value);
   let summary = "encapsulates all Fortran scalar type conversions";
 
   let description = [{
     Generalized type conversion. Not all pairs of types have conversions.
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 1> operands;
-    if (parser.parseOperandList(operands, 1,
-            mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(value());
-    p.printOptionalAttrDict(getAttrs(), {});
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let assemblyFormat = [{
+    $value attr-dict `:` functional-type($value, results)
   }];
 }
 
@@ -2136,7 +2103,8 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]>,
 }
 
 def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
-    [SameOperandsAndResultType]>, Arguments<(ins fir_Type:$val)> {
+    [SameOperandsAndResultType]> {
+  let arguments = (ins AnyType:$val);
   let summary = "synthetic op to prevent reassociation";
 
   let description = [{
@@ -2145,20 +2113,8 @@ def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
     parenthesis.
   }];
 
-  let parser = [{
-    mlir::Type type;
-    mlir::OpAsmParser::OperandType opnd;
-    if (parser.parseOperand(opnd) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperand(opnd, type, result.operands) ||
-        parser.addTypeToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(val());
-    p << " : " << getType();
+  let assemblyFormat = [{
+    $val attr-dict `:` type($val)
   }];
 }
 
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 7ef07a6179c1..2ddac9a662bb 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -875,7 +875,7 @@ M::Value Br::createSomeAddress(M::Location loc,
 /// `symbol` will be nullptr for an anonymous temporary
 M::Value Br::createTemporary(M::Location loc, M::OpBuilder &builder,
                              SymMap &symMap, M::Type type,
-                             const Se::Symbol *symbol) {
+                             const Se::Symbol *symbol, llvm::StringRef name) {
   if (symbol)
     if (auto val = symMap.lookupSymbol(*symbol)) {
       if (auto op = val.getDefiningOp())
@@ -890,7 +890,7 @@ M::Value Br::createTemporary(M::Location loc, M::OpBuilder &builder,
     ae = builder.create<fir::AllocaOp>(loc, type, symbol->name().ToString());
     symMap.addSymbol(*symbol, ae);
   } else {
-    ae = builder.create<fir::AllocaOp>(loc, type);
+    ae = builder.create<fir::AllocaOp>(loc, type, name);
   }
   builder.restoreInsertionPoint(insPt);
   return ae;
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index 240d45b2df48..f8bd60855c85 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -2182,3 +2182,11 @@ std::unique_ptr<mlir::Pass>
 fir::createLLVMDialectToLLVMPass(raw_ostream &output) {
   return std::make_unique<LLVMIRLoweringPass>(output);
 }
+
+// Register the FIR to LLVM-IR pass
+static mlir::PassRegistration<FIRToLLVMLoweringPass>
+    passLowFIR("fir-to-llvmir",
+               "Conversion of the FIR dialect to the LLVM-IR dialect", [] {
+                 NameUniquer dummy;
+                 return std::make_unique<FIRToLLVMLoweringPass>(dummy);
+               });
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
index 6811eb88e256..02aef02f51de 100644
--- a/lib/optimizer/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -743,6 +743,13 @@ struct MemToReg
 
 } // namespace
 
+using MemToRegPass =
+    MemToReg<fir::LoadOp, fir::StoreOp, fir::AllocaOp, fir::UndefOp>;
+
 std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> fir::createMemToRegPass() {
-  return std::make_unique<MemToReg<LoadOp, StoreOp, AllocaOp, UndefOp>>();
+  return std::make_unique<MemToRegPass>();
 }
+
+// Register the Mem To Reg pass
+static mlir::PassRegistration<MemToRegPass>
+    pass("mem-to-reg", "Conversion from mem to reg form");
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 8e34c8d65efa..456eba66fa4b 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -55,23 +55,28 @@ using namespace llvm;
 namespace {
 
 // Some basic command-line options
-cl::opt<std::string> InputFilename(cl::Positional, cl::Required,
+cl::opt<std::string> inputFilename(cl::Positional, cl::Required,
                                    cl::desc("<input file>"));
 
-cl::opt<std::string> OutputFilename("o",
+cl::opt<std::string> outputFilename("o",
                                     cl::desc("Specify the output filename"),
                                     cl::value_desc("filename"),
                                     cl::init("a.mlir"));
 
-cl::list<std::string> IncludeDirs("I", cl::desc("include search paths"));
+cl::list<std::string> includeDirs("I", cl::desc("include search paths"));
 
-cl::list<std::string> ModuleDirs("module", cl::desc("module search paths"));
+cl::list<std::string> moduleDirs("module", cl::desc("module search paths"));
 
-cl::opt<std::string> ModuleSuffix("module-suffix",
+cl::opt<std::string> moduleSuffix("module-suffix",
                                   cl::desc("module file suffix override"),
                                   cl::init(".mod"));
 
-cl::opt<bool> EmitLLVM("emit-llvm", cl::desc("emit LLVM IR"), cl::init(false));
+cl::opt<bool> emitLLVM("emit-llvm",
+                       cl::desc("Add passes to lower to and emit LLVM IR"),
+                       cl::init(false));
+cl::opt<bool> emitFIR("emit-fir",
+                      cl::desc("Dump the FIR created by lowering and exit"),
+                      cl::init(false));
 
 // vestigal struct that should be deleted
 struct DriverOptions {
@@ -95,7 +100,7 @@ void convertFortranSourceToMLIR(
       options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
     }
   }
-  options.searchDirectories = IncludeDirs;
+  options.searchDirectories = includeDirs;
   Fortran::parser::Parsing parsing{semanticsContext.allSources()};
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
@@ -138,31 +143,39 @@ void convertFortranSourceToMLIR(
   fir::KindMapping kindMap{&burnside.getMLIRContext()};
   burnside.lower(parseTree, nameUniquer);
   mlir::ModuleOp mlirModule = burnside.getModule();
-  mlir::PassManager pm = mlirModule.getContext();
+  std::error_code ec;
+  raw_fd_ostream out(outputFilename, ec);
+  if (ec) {
+    errs() << "could not open output file " << outputFilename << '\n';
+    return;
+  }
+  if (emitFIR) {
+    // dump FIR and exit
+    mlirModule.print(out);
+    return;
+  }
 
+  mlir::PassManager pm = mlirModule.getContext();
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
   pm.addPass(fir::createLowerToLoopPass());
   pm.addPass(fir::createFIRToStdPass(kindMap));
   pm.addPass(mlir::createLowerToCFGPass());
 
-  if (EmitLLVM) {
+  if (emitLLVM) {
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
     std::error_code ec;
-    llvm::ToolOutputFile out(OutputFilename + ".ll", ec,
+    llvm::ToolOutputFile out(outputFilename + ".ll", ec,
                              llvm::sys::fs::OF_None);
     if (ec) {
-      errs() << "can't open output file " + OutputFilename + ".ll";
+      errs() << "can't open output file " + outputFilename + ".ll";
       return;
     }
     pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
   }
 
   if (mlir::succeeded(pm.run(mlirModule))) {
-    std::error_code ec;
-    raw_fd_ostream out(OutputFilename, ec);
-    if (!ec)
-      mlirModule.print(out);
+    mlirModule.print(out);
   } else {
     errs() << "oops, pass manager reported failure\n";
     mlirModule.dump();
@@ -181,11 +194,11 @@ int main(int argc, char **argv) {
   DriverOptions driver;
   driver.prefix = argv[0] + ": "s;
 
-  if (IncludeDirs.size() == 0) {
-    IncludeDirs.push_back(".");
+  if (includeDirs.size() == 0) {
+    includeDirs.push_back(".");
   }
-  if (ModuleDirs.size() == 0) {
-    ModuleDirs.push_back(".");
+  if (moduleDirs.size() == 0) {
+    moduleDirs.push_back(".");
   }
 
   Fortran::parser::Options options;
@@ -201,12 +214,12 @@ int main(int argc, char **argv) {
   Fortran::parser::AllSources allSources;
   Fortran::semantics::SemanticsContext semanticsContext{
       defaultKinds, options.features, allSources};
-  semanticsContext.set_moduleDirectory(ModuleDirs.front())
-      .set_moduleFileSuffix(ModuleSuffix)
-      .set_searchDirectories(IncludeDirs)
+  semanticsContext.set_moduleDirectory(moduleDirs.front())
+      .set_moduleFileSuffix(moduleSuffix)
+      .set_searchDirectories(includeDirs)
       .set_warnOnNonstandardUsage(driver.warnOnNonstandardUsage)
       .set_warningsAreErrors(driver.warningsAreErrors);
 
-  convertFortranSourceToMLIR(InputFilename, options, driver, semanticsContext);
+  convertFortranSourceToMLIR(inputFilename, options, driver, semanticsContext);
   return exitStatus;
 }

From b2b63e05822c9ff7331c5c526479bd80fd6eb695 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 13 Feb 2020 12:47:17 -0800
Subject: [PATCH 186/345] rebasing and other changes changes - add verify to
 embox

---
 include/flang/optimizer/Dialect/FIRDialect.h |  37 +++
 include/flang/optimizer/Dialect/FIROps.td    | 252 ++++++++++++-------
 include/flang/optimizer/Dialect/FIRType.h    |  12 +-
 lib/lower/IO.cpp                             |   4 +-
 lib/optimizer/CMakeLists.txt                 |   8 +-
 lib/optimizer/CodeGen.cpp                    |   2 +-
 lib/optimizer/Dialect/FIRDialect.cpp         |   2 -
 lib/optimizer/Dialect/FIROps.cpp             |   1 +
 lib/optimizer/Dialect/FIRType.cpp            |  77 +++---
 lib/optimizer/Support/CMakeLists.txt         |   8 +-
 lib/optimizer/Transforms/CMakeLists.txt      |   4 +-
 lib/optimizer/Transforms/RewriteLoop.cpp     |   4 +-
 test-lit/fir/embox-write.fir                 |   2 +-
 test-lit/fir/fir-ops.fir                     |   2 +-
 test-lit/fir/loop.fir                        |   2 +-
 tools/bbc/CMakeLists.txt                     |   2 +-
 tools/tco/CMakeLists.txt                     |  23 +-
 tools/tco/tco.cpp                            |   6 +-
 18 files changed, 284 insertions(+), 164 deletions(-)

diff --git a/include/flang/optimizer/Dialect/FIRDialect.h b/include/flang/optimizer/Dialect/FIRDialect.h
index 91d4f37f08af..0c80bbe80e70 100644
--- a/include/flang/optimizer/Dialect/FIRDialect.h
+++ b/include/flang/optimizer/Dialect/FIRDialect.h
@@ -10,6 +10,7 @@
 #define OPTIMIZER_DIALECT_FIRDIALECT_H
 
 #include "mlir/IR/Dialect.h"
+#include "mlir/InitAllPasses.h"
 
 namespace llvm {
 class raw_ostream;
@@ -44,6 +45,42 @@ class FIROpsDialect final : public mlir::Dialect {
                       mlir::DialectAsmPrinter &p) const override;
 };
 
+/// Register the dialect with MLIR
+inline void registerFIR() {
+  // we want to register exactly once
+  [[maybe_unused]] static bool init_once = [] {
+    mlir::registerDialect<FIROpsDialect>();
+    return true;
+  }();
+}
+
+/// Register the standard passes we use. This comes from registerAllPasses(),
+/// but is a smaller set since we aren't using many of the passes found there.
+inline void registerGeneralPasses() {
+  mlir::createCanonicalizerPass();
+  mlir::createCSEPass();
+  mlir::createVectorizePass({});
+  mlir::createLoopUnrollPass();
+  mlir::createLoopUnrollAndJamPass();
+  mlir::createSimplifyAffineStructuresPass();
+  mlir::createLoopFusionPass();
+  mlir::createLoopInvariantCodeMotionPass();
+  mlir::createAffineLoopInvariantCodeMotionPass();
+  mlir::createPipelineDataTransferPass();
+  mlir::createLowerAffinePass();
+  mlir::createLoopTilingPass(0);
+  mlir::createLoopCoalescingPass();
+  mlir::createAffineDataCopyGenerationPass(0, 0);
+  mlir::createMemRefDataFlowOptPass();
+  mlir::createStripDebugInfoPass();
+  mlir::createPrintOpStatsPass();
+  mlir::createInlinerPass();
+  mlir::createSymbolDCEPass();
+  mlir::createLocationSnapshotPass({});
+}
+
+inline void registerFIRPasses() { registerGeneralPasses(); }
+
 } // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIRDIALECT_H
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index bf35b17a0666..a920473ce803 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -77,6 +77,11 @@ def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
     "any reference or box">;
 
 def fir_DimsType : Type<CPred<"$_self.isa<fir::DimsType>()">, "dim type">;
+def AnyEmboxLike : TypeConstraint<Or<[AnyInteger.predicate,
+    Index.predicate, fir_IntegerType.predicate, fir_DimsType.predicate]>,
+    "any legal embox argument type">;
+def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;
+
 def fir_TypeDescType : Type<CPred<"$_self.isa<fir::TypeDescType>()">,
     "type desc type">;
 def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
@@ -289,6 +294,8 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
       %1 = fir.call @foo(%0) : (!fir.ref<f32>) -> i32
   }];
 
+  let results = (outs fir_ReferenceType);
+
   let verifier = allocVerify#[{
     mlir::Type outType = getType();
     if (!outType.isa<fir::ReferenceType>())
@@ -385,6 +392,12 @@ def fir_StoreOp : fir_Op<"store", []>,
     p << " : " << memref().getType();
   }];
 
+  let verifier = [{
+    if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
+      return emitOpError("store value type must match memory reference type");
+    return mlir::success();
+  }];
+
   let extraClassDeclaration = [{
     static mlir::Type elementType(mlir::Type refType);
   }];
@@ -429,6 +442,8 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
       fir.freemem %0 : !fir.heap<!fir.array<10xf32>>
   }];
 
+  let results = (outs fir_HeapType);
+
   let verifier = allocVerify#[{
     mlir::Type outType = getType();
     if (!outType.dyn_cast<fir::HeapType>())
@@ -441,8 +456,7 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
   }];
 }
 
-def fir_FreeMemOp : fir_Op<"freemem", []>,
-    Arguments<(ins fir_HeapType:$heapref)> {
+def fir_FreeMemOp : fir_Op<"freemem", []> {
   let summary = "free a heap object";
 
   let description = [{
@@ -456,30 +470,17 @@ def fir_FreeMemOp : fir_Op<"freemem", []>,
       fir.freemem %0 : !fir.heap<!fir.array<10xf32>>
   }];
 
-  let parser = [{
-    mlir::Type type;
-    mlir::OpAsmParser::OperandType oper;
-    if (parser.parseOperand(oper) ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperand(oper, type, result.operands))
-      return mlir::failure();
-    return mlir::success();
-  }];
+  let arguments = (ins fir_HeapType:$heapref);
 
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(heapref());
-    p.printOptionalAttrDict(getAttrs(), {});
-    p << " : " << getOperand().getType();
-  }];
+  let assemblyFormat = "$heapref attr-dict `:` type($heapref)";
 }
 
 // Terminator operations
 
 class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic, !listconcat(traits, [Terminator])>,
-    Arguments<(ins Variadic<AnyType>:$args)>, Results<(outs)> {
+    Arguments<(ins Variadic<AnyType>:$args)>,
+    Results<(outs)> {
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value selector,"
     "ArrayRef<Value> properOperands, ArrayRef<Block *> destinations,"
@@ -499,7 +500,7 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
 
   string extraSwitchClassDeclaration = [{
     using Conditions = mlir::Value;
-    constexpr static auto AttrName = "cases";
+    static constexpr auto AttrName = "cases";
 
     // The number of destination conditions that may be tested
     unsigned getNumConditions() { return getNumDest(); }
@@ -816,13 +817,9 @@ def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
     program, for example.
   }];
 
-  let parser = [{
-    return mlir::success();
-  }];
+  let parser = "return mlir::success();";
 
-  let printer = [{
-    p << getOperationName();
-  }];
+  let printer = "p << getOperationName();";
 }
 
 def fir_FirEndOp : fir_Op<"end", [Terminator]> {
@@ -838,16 +835,32 @@ def fir_FirEndOp : fir_Op<"end", [Terminator]> {
 
 // Operations on !fir.box<T> type objects
 
-def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
-    Arguments<(ins AnyReferenceLike:$memref, Variadic<fir_DimsType>:$args)> {
+def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
   let summary = "boxes a given reference and (optional) dimension information";
 
   let description = [{
     Create a boxed reference value. In Fortran, the implementation can require
     extra information about an entity, such as its type, rank, etc.  This
-    auxilliary information is packaged and abstracted as a value with box type.
+    auxilliary information is packaged and abstracted as a value with box type
+    by the calling routine. (In Fortran, these are called descriptors.)
+
+    Syntax:
+      `fir.embox` mem-ref [`,` layout] `:` `(` arg-types `)` `->` res-type
+
+      where layout is dims | affine-map
+
+    Example:
+
+      %4 = fir.dims(%c1, %c10, %c1) : (index, index, index) -> !fir.dims<1>
+      %5 = ... : !fir.ref<!fir.array<10:i32>>
+      %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10:i32>>, !fir.dims<1>)
+                            -> !fir.box<!fir.array<10:i32>>
   }];
 
+  let arguments = (ins AnyReferenceLike:$memref, Variadic<AnyEmboxArg>:$args);
+
+  let results = (outs fir_BoxType);
+
   let parser = [{
     mlir::FunctionType type;
     llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
@@ -875,7 +888,8 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
           parser.parseRSquare())
         return mlir::failure();
     }
-    if (parser.parseColonType(type) ||
+    if (parser.parseOptionalAttrDict(result.attributes) ||
+        parser.parseColonType(type) ||
         parser.resolveOperands(operands, type.getInputs(),
             parser.getNameLoc(), result.operands) ||
         parser.addTypesToList(type.getResults(), result.types))
@@ -897,10 +911,41 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
     } else if (auto map = getAttr(layoutName())) {
       p << " [" << map << ']';
     }
+    p.printOptionalAttrDict(getAttrs(), {layoutName(), lenpName()});
     p << " : ";
     p.printFunctionalType(getOperation());
   }];
 
+  let verifier = [{
+    if (hasLenParams()) {
+      auto lenParams = numLenParams();
+      auto eleTy = fir::dyn_cast_ptrEleTy(memref().getType());
+      if (!eleTy)
+        return emitOpError("must embox a memory reference type");
+      if (auto rt = eleTy.dyn_cast<fir::RecordType>()) {
+        if (lenParams != rt.getNumLenParams())
+          return emitOpError("number of LEN params does not correspond"
+                             " to the !fir.type type");
+      } else {
+        return emitOpError("LEN parameters require !fir.type type");
+      }
+      for (auto lp : getLenParams())
+        if (lp.getType().isa<fir::DimsType>())
+          return emitOpError("LEN parameters must be integral type");
+    }
+    if (dims().size() == 0) {
+      // Ok. If there is no dims and no layout map, then emboxing a scalar.
+      // TODO: Should the type be enforced? It already must agree.
+    } else if (dims().size() == 1) {
+      auto d = *dims().begin();
+      if (!d.getType().isa<fir::DimsType>())
+        return emitOpError("dimension argument must have !fir.dims type");
+    } else {
+      return emitOpError("embox can only have one !fir.dim argument");
+    }
+    return mlir::success();
+  }];
+
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef layoutName() { return "layout_map"; }
     static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
@@ -920,8 +965,9 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]>, Results<(outs fir_BoxType)>,
 }
 
 def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
-  let results = (outs fir_BoxCharType);
   let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
+  let results = (outs fir_BoxCharType);
+
   let summary = "boxes a given CHARACTER reference and its LEN parameter";
 
   let description = [{
@@ -951,8 +997,8 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
 }
 
 def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
-    Results<(outs fir_BoxProcType)>,
-    Arguments<(ins SymbolRefAttr:$funcname, AnyReferenceLike:$host)> {
+    Arguments<(ins SymbolRefAttr:$funcname, AnyReferenceLike:$host)>,
+    Results<(outs fir_BoxProcType)> {
   let summary = "boxes a given procedure and optional host context";
 
   let description = [{
@@ -1033,21 +1079,29 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
   }];
 }
 
-def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]>,
-    Results<(outs fir_ReferenceType, AnyIntegerLike, AnyIntegerLike,
-             fir_TypeDescType, AnyIntegerLike, fir_DimsType)>,
-    Arguments<(ins fir_BoxType:$box)> {
+def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
   let summary = "unbox the boxed value into a tuple value";
 
   let description = [{
     Unboxes a value of `box` type into a tuple of information abstracted in
     that boxed value.
   }];
+
+  let arguments = (ins fir_BoxType:$box);
+
+  let results = (outs
+    fir_ReferenceType,  // pointer to data
+    AnyIntegerLike,     // size of a data element
+    AnyIntegerLike,     // rank of data
+    fir_TypeDescType,   // abstract type descriptor
+    AnyIntegerLike,     // attribute flags (bitfields)
+    fir_DimsType        // dimension information (if any)
+  );
 }
 
 def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]>,
-    Results<(outs fir_ReferenceType, AnyIntegerLike)>,
-    Arguments<(ins fir_BoxCharType:$boxchar)> {
+    Arguments<(ins fir_BoxCharType:$boxchar)>,
+    Results<(outs fir_ReferenceType, AnyIntegerLike)> {
   let summary = "unbox a boxchar value into a pair value";
 
   let description = [{
@@ -1057,8 +1111,8 @@ def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]>,
 }
 
 def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]>,
-    Results<(outs FunctionType, fir_ReferenceType)>,
-    Arguments<(ins fir_BoxProcType:$boxproc)> {
+    Arguments<(ins fir_BoxProcType:$boxproc)>,
+    Results<(outs FunctionType, fir_ReferenceType)> {
   let summary = "unbox a boxproc value into a pair value";
 
   let description = [{
@@ -1098,7 +1152,8 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]>,
 }
 
 def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]>,
-    Results<(outs AnyIntegerLike)>, Arguments<(ins fir_BoxCharType:$val)> {
+    Arguments<(ins fir_BoxCharType:$val)>,
+    Results<(outs AnyIntegerLike)> {
   let summary = "return the LEN type parameter from a boxchar value";
 
   let description = [{
@@ -1107,8 +1162,8 @@ def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]>,
 }
 
 def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
-    Results<(outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike)>,
-    Arguments<(ins fir_BoxType:$val, AnyIntegerLike:$dim)> {
+    Arguments<(ins fir_BoxType:$val, AnyIntegerLike:$dim)>,
+    Results<(outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike)> {
   let summary = "return the dynamic dimension information for the boxed value";
 
   let description = [{
@@ -1156,7 +1211,8 @@ def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]>,
 }
 
 def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]>,
-    Results<(outs BoolLike)>, Arguments<(ins fir_BoxType:$val)> {
+    Arguments<(ins fir_BoxType:$val)>,
+    Results<(outs BoolLike)> {
   let summary = "is the boxed value an ALLOCATABLE?";
 
   let description = [{
@@ -1169,7 +1225,8 @@ def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]>,
 }
 
 def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]>,
-    Results<(outs BoolLike)>, Arguments<(ins fir_BoxType:$val)> {
+    Arguments<(ins fir_BoxType:$val)>,
+    Results<(outs BoolLike)> {
   let summary = "is the boxed value an array?";
 
   let description = [{
@@ -1183,7 +1240,8 @@ def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]>,
 }
 
 def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]>,
-    Results<(outs BoolLike)>, Arguments<(ins fir_BoxType:$val)> {
+    Arguments<(ins fir_BoxType:$val)>,
+    Results<(outs BoolLike)> {
   let summary = "is the boxed value a POINTER?";
 
   let description = [{
@@ -1196,7 +1254,8 @@ def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]>,
 }
 
 def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]>,
-    Results<(outs fir_ReferenceType)>, Arguments<(ins fir_BoxProcType:$val)> {
+    Arguments<(ins fir_BoxProcType:$val)>,
+    Results<(outs fir_ReferenceType)> {
   let summary = "returns the host instance pointer (or null)";
 
   let description = [{
@@ -1226,8 +1285,8 @@ def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]>,
 // Record and array type operations
 
 def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
-    Results<(outs fir_ReferenceType)>, Arguments<(ins AnyRefOrBox:$ref,
-    Variadic<AnyCoordinateType>:$coor)> {
+    Arguments<(ins AnyRefOrBox:$ref, Variadic<AnyCoordinateType>:$coor)>,
+    Results<(outs fir_ReferenceType)> {
   let summary = "Finds the coordinate (location) of a value in memory";
 
   let description = [{
@@ -1376,8 +1435,8 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
   }];
 
   let extraClassDeclaration = [{
-    constexpr static llvm::StringRef fieldAttrName() { return "field_id"; }
-    constexpr static llvm::StringRef typeAttrName() { return "on_type"; }
+    static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
+    static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
   }];
 }
 
@@ -1495,8 +1554,8 @@ def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]>,
   }];
 
   let extraClassDeclaration = [{
-    constexpr static llvm::StringRef fieldAttrName() { return "field_id"; }
-    constexpr static llvm::StringRef typeAttrName() { return "on_type"; }
+    static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
+    static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
     mlir::Type getOnType() {
       return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
@@ -1512,9 +1571,17 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   let description = [{
     A generalized Fortran loop construct.
   }];
-  let arguments = (ins Index:$lowerBound, Index:$upperBound,
-                   Variadic<Index>:$optstep, OptionalAttr<I32Attr>:$constep,
-                   OptionalAttr<UnitAttr>:$unordered);
+
+  let arguments = (ins
+    Index:$lowerBound,
+    Index:$upperBound,
+    Variadic<Index>:$optStep,
+    OptionalAttr<I32Attr>:$constantStep,
+    OptionalAttr<UnitAttr>:$unordered
+  );
+
+  let results = (outs Index);
+
   let regions = (region SizedRegion<1>:$region);
   let skipDefaultBuilders = 1;
   let builders = [
@@ -1524,15 +1591,16 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
               "mlir::Value lowerBound, mlir::Value upperBound,"
               "llvm::ArrayRef<mlir::Value> step">
   ];
-  let parser = [{ return parseLoopOp(parser, result); }];
+
+  let parser = "return parseLoopOp(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ' << getInductionVar() << " = "
       << lowerBound() << " to " << upperBound();
-    auto s = optstep();
+    auto s = optStep();
     if (s.begin() != s.end()) {
       p << " step ";
-      p.printOperands(s.begin(), s.end());
+      p.printOperand(*s.begin());
     }
     if (unordered())
       p << " unordered";
@@ -1542,8 +1610,9 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   }];
 
   let verifier = [{
-    auto step = optstep();
+    auto step = optStep();
     if (step.begin() != step.end()) {
+      // FIXME: size of step must be 1
       auto *s = (*step.begin()).getDefiningOp();
       if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s))
         if (cst.getValue() == 0)
@@ -1636,9 +1705,10 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
 
 // Procedure call operations
 
-def fir_CallOp : fir_Op<"call", []>, Results<(outs Variadic<AnyType>)>,
+def fir_CallOp : fir_Op<"call", []>,
     Arguments<(ins OptionalAttr<SymbolRefAttr>:$callee,
-               Variadic<AnyType>:$args)> {
+               Variadic<AnyType>:$args)>,
+    Results<(outs Variadic<AnyType>)> {
   let summary = "call a procedure";
 
   let description = [{
@@ -1646,14 +1716,14 @@ def fir_CallOp : fir_Op<"call", []>, Results<(outs Variadic<AnyType>)>,
     in the FIR dialect, e.g. `fir.call @sub(%12)` or `fir.call %20(%22,%23)`.
   }];
 
-  let parser = [{ return parseCallOp(parser, result); }];
-  let printer = [{ printCallOp(p, *this); }];
+  let parser = "return parseCallOp(parser, result);";
+  let printer = "printCallOp(p, *this);";
 }
 
 def fir_DispatchOp : fir_Op<"dispatch", []>,
-    Results<(outs Variadic<AnyType>)>,
     Arguments<(ins StrAttr:$method, fir_BoxType:$object,
-               Variadic<AnyType>:$args)> {
+               Variadic<AnyType>:$args)>,
+    Results<(outs Variadic<AnyType>)> {
   let summary = "call a type-bound procedure";
 
   let description = [{
@@ -1714,12 +1784,18 @@ def fir_DispatchOp : fir_Op<"dispatch", []>,
 // Constant operations that support Fortran
 
 def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
-    Results<(outs AnyType)> {
+    Results<(outs fir_SequenceType)> {
   let summary = "create a string literal constant";
 
   let description = [{
     An FIR constant that represents a sequence of characters that correspond
-    to Fortran's CHARACTER type, including a LEN.
+    to Fortran's CHARACTER type, including a LEN.  We support CHARACTER values
+    of different KINDs (different constant sizes).
+
+    Example:
+
+      %1 = fir.string_lit "Hello, World!"(13) : !fir.char<1> // ASCII
+      %2 = fir.string_lit [158, 2345](2) : !fir.char<2>      // Wide chars
   }];
 
   let parser = [{
@@ -1841,7 +1917,7 @@ def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]>,
   }];
 
   let extraClassDeclaration = [{
-    constexpr static llvm::StringRef constAttrName() { return "constant"; }
+    static constexpr llvm::StringRef constAttrName() { return "constant"; }
 
     mlir::Attribute getValue() { return getAttr(constAttrName()); }
   }];
@@ -1865,9 +1941,7 @@ def fir_ModfOp : RealArithmeticOp<"modf">;
 // Pow is a builtin call and not a primitive
 
 def fir_CmpfOp : fir_Op<"cmpf",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]>,
-    Results<(outs AnyLogicalLike)>,
-    Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)> {
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
   let summary = "floating-point comparison operator";
 
   let description = [{
@@ -1875,6 +1949,10 @@ def fir_CmpfOp : fir_Op<"cmpf",
     floating-point types found in FIR.
   }];
 
+  let arguments = (ins AnyRealLike:$lhs, AnyRealLike:$rhs);
+
+  let results = (outs AnyLogicalLike);
+
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpFPredicate predicate,"
     "Value lhs, Value rhs", [{
@@ -1882,10 +1960,11 @@ def fir_CmpfOp : fir_Op<"cmpf",
   }]>];
 
   let parser = [{ return fir::parseCmpfOp(parser, result); }];
+
   let printer = [{ fir::printCmpfOp(p, *this); }];
 
   let extraClassDeclaration = [{
-    constexpr static llvm::StringRef getPredicateAttrName() {
+    static constexpr llvm::StringRef getPredicateAttrName() {
       return "predicate";
     }
     static CmpFPredicate getPredicateByName(llvm::StringRef name);
@@ -1940,8 +2019,8 @@ def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]>,
   }];
 
   let extraClassDeclaration = [{
-    constexpr static llvm::StringRef realAttrName() { return "real"; }
-    constexpr static llvm::StringRef imagAttrName() { return "imaginary"; }
+    static constexpr llvm::StringRef realAttrName() { return "real"; }
+    static constexpr llvm::StringRef imagAttrName() { return "imaginary"; }
 
     mlir::Attribute getReal() { return getAttr(realAttrName()); }
     mlir::Attribute getImaginary() { return getAttr(imagAttrName()); }
@@ -1966,8 +2045,8 @@ def fir_DivcOp : ComplexArithmeticOp<"divc">;
 
 def fir_CmpcOp : fir_Op<"cmpc",
     [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]>,
-    Results<(outs AnyLogicalLike)>,
-    Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)> {
+    Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)>,
+    Results<(outs AnyLogicalLike)> {
   let summary = "complex floating-point comparison operator";
 
   let description = [{
@@ -1984,7 +2063,7 @@ def fir_CmpcOp : fir_Op<"cmpc",
   let printer = [{ fir::printCmpcOp(p, *this); }];
 
   let extraClassDeclaration = [{
-    constexpr static llvm::StringRef getPredicateAttrName() {
+    static constexpr llvm::StringRef getPredicateAttrName() {
       return "predicate";
     }
 
@@ -2113,21 +2192,22 @@ def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
     parenthesis.
   }];
 
-  let assemblyFormat = [{
-    $val attr-dict `:` type($val)
-  }];
+  let assemblyFormat = "$val attr-dict `:` type($val)";
 }
 
-def fir_GlobalEntryOp : fir_Op<"global_entry", []>,
-    Arguments<(ins StrAttr:$field, AnyType:$constant)> {
-  let summary = "map entry in a global";
+def fir_GlobalEntryOp : fir_Op<"global_entry", []> {
+
+  let summary = "map a field entry in a global";
 
   let description = [{
     An entry in a global.  Allows a constant to be bound to a specific
     field in a record even though the layout of the record has not yet
-    been reified.
+    been reified.  This may be necessary if the object layout decisions
+    are deferred to, for example, runtime by the implementation.
   }];
 
+  let arguments = (ins StrAttr:$field, AnyType:$constant);
+
   let parser = [{
     mlir::Type type;
     mlir::OpAsmParser::OperandType constant;
diff --git a/include/flang/optimizer/Dialect/FIRType.h b/include/flang/optimizer/Dialect/FIRType.h
index 326c53353cdf..2da2bafc37d2 100644
--- a/include/flang/optimizer/Dialect/FIRType.h
+++ b/include/flang/optimizer/Dialect/FIRType.h
@@ -75,14 +75,20 @@ enum TypeKind {
   FIR_TYPEDESC,
 };
 
-bool isa_fir_type(mlir::Type);
+bool isa_fir_type(mlir::Type t);
 bool isa_std_type(mlir::Type t);
 bool isa_fir_or_std_type(mlir::Type t);
+bool isa_memref(mlir::Type t);
 
+/// Extract the `Type` pointed to from a FIR memory reference type. If `t` is
+/// not a memory reference type, then returns a null `Type`.
+mlir::Type dyn_cast_ptrEleTy(mlir::Type t);
+
+/// Boilerplate mixin template
 template <typename A, unsigned Id>
 struct IntrinsicTypeMixin {
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() { return Id; }
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return Id; }
 };
 
 class CharacterType
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 6b83ca936beb..831df544872c 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -19,8 +19,6 @@
 #include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/Builders.h"
 
-#define NAMIFY_HELPER(X) #X
-#define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
 
 #define TODO() assert(false && "not yet implemented")
 
@@ -28,6 +26,8 @@ using namespace Io;
 namespace Fortran::lower {
 namespace {
 
+#define NAMIFY_HELPER(X) #X
+#define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
 #define mkIOKey(X) mkKey(IONAME(X))
 
 /// Static table of IO runtime calls
diff --git a/lib/optimizer/CMakeLists.txt b/lib/optimizer/CMakeLists.txt
index 5b6bc5b8e7f2..b186f6586baa 100644
--- a/lib/optimizer/CMakeLists.txt
+++ b/lib/optimizer/CMakeLists.txt
@@ -4,17 +4,15 @@ add_subdirectory(Dialect)
 add_subdirectory(Support)
 add_subdirectory(Transforms)
 
-add_llvm_library(FortranOptimizer
+add_llvm_library(FIROptimizer
   CodeGen.cpp
   IteratedDominanceFrontier.cpp
   StdConverter.cpp
 )
 
-target_link_libraries(FortranOptimizer
-  FIR
-)
+target_link_libraries(FIROptimizer FIRSupport)
 
-install (TARGETS FortranOptimizer
+install (TARGETS FIROptimizer
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib
 )
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index f8bd60855c85..122aa1b3c002 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -1481,7 +1481,7 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
                     .getValue();
     auto value = initializersToAttr(global.getOperation(), rewriter);
     rewriter.replaceOpWithNewOp<mlir::LLVM::GlobalOp>(
-        global, tyAttr, isConst, mlir::LLVM::Linkage::LinkonceODR, name, value);
+        global, tyAttr, isConst, mlir::LLVM::Linkage::External, name, value);
     return matchSuccess();
   }
 
diff --git a/lib/optimizer/Dialect/FIRDialect.cpp b/lib/optimizer/Dialect/FIRDialect.cpp
index c5497abbc996..b199025c5112 100644
--- a/lib/optimizer/Dialect/FIRDialect.cpp
+++ b/lib/optimizer/Dialect/FIRDialect.cpp
@@ -36,8 +36,6 @@ void selectBuild(mlir::OpBuilder *builder, mlir::OperationState *result,
   }
 }
 
-mlir::DialectRegistration<fir::FIROpsDialect> FIROps;
-
 } // namespace
 
 fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
index 440dc60387e9..e518d36c28ab 100644
--- a/lib/optimizer/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -529,6 +529,7 @@ mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return mlir::failure();
+  result.addTypes(builder.getIndexType());
   return mlir::success();
 }
 
diff --git a/lib/optimizer/Dialect/FIRType.cpp b/lib/optimizer/Dialect/FIRType.cpp
index 10a6b60e896f..46e23a1b5e98 100644
--- a/lib/optimizer/Dialect/FIRType.cpp
+++ b/lib/optimizer/Dialect/FIRType.cpp
@@ -181,14 +181,14 @@ SequenceType parseSequence(mlir::DialectAsmParser &parser, mlir::Location) {
 }
 
 bool verifyIntegerType(mlir::Type ty) {
-  return ty.dyn_cast<mlir::IntegerType>() || ty.dyn_cast<IntType>();
+  return ty.isa<mlir::IntegerType>() || ty.isa<IntType>();
 }
 
 bool verifyRecordMemberType(mlir::Type ty) {
-  return !(ty.dyn_cast<BoxType>() || ty.dyn_cast<BoxCharType>() ||
-           ty.dyn_cast<BoxProcType>() || ty.dyn_cast<DimsType>() ||
-           ty.dyn_cast<FieldType>() || ty.dyn_cast<LenType>() ||
-           ty.dyn_cast<ReferenceType>() || ty.dyn_cast<TypeDescType>());
+  return !(ty.isa<BoxType>() || ty.isa<BoxCharType>() ||
+           ty.isa<BoxProcType>() || ty.isa<DimsType>() || ty.isa<FieldType>() ||
+           ty.isa<LenType>() || ty.isa<ReferenceType>() ||
+           ty.isa<TypeDescType>());
 }
 
 bool verifySameLists(llvm::ArrayRef<RecordType::TypePair> a1,
@@ -297,9 +297,8 @@ RecordType parseDerived(mlir::DialectAsmParser &parser, mlir::Location) {
 
 // !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
 // is undefined and disallowed.
-bool singleIndirectionLevel(mlir::Type ty) {
-  return !(ty.dyn_cast<ReferenceType>() || ty.dyn_cast<PointerType>() ||
-           ty.dyn_cast<HeapType>());
+inline bool singleIndirectionLevel(mlir::Type ty) {
+  return !fir::isa_memref(ty);
 }
 
 } // namespace
@@ -839,6 +838,20 @@ bool fir::isa_fir_or_std_type(mlir::Type t) {
   return isa_fir_type(t) || isa_std_type(t);
 }
 
+bool fir::isa_memref(mlir::Type t) {
+  return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
+}
+
+mlir::Type fir::dyn_cast_ptrEleTy(mlir::Type t) {
+  if (auto p = t.dyn_cast<fir::ReferenceType>())
+    return p.getEleTy();
+  if (auto p = t.dyn_cast<fir::PointerType>())
+    return p.getEleTy();
+  if (auto p = t.dyn_cast<fir::HeapType>())
+    return p.getEleTy();
+  return {};
+}
+
 // CHARACTER
 
 CharacterType fir::CharacterType::get(mlir::MLIRContext *ctxt, KindTy kind) {
@@ -943,7 +956,7 @@ mlir::Type fir::BoxProcType::getEleTy() const {
 mlir::LogicalResult fir::BoxProcType::verifyConstructionInvariants(
     llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
     mlir::Type eleTy) {
-  if (eleTy.dyn_cast<mlir::FunctionType>() || eleTy.dyn_cast<ReferenceType>())
+  if (eleTy.isa<mlir::FunctionType>() || eleTy.isa<ReferenceType>())
     return mlir::success();
   return mlir::failure();
 }
@@ -961,9 +974,8 @@ mlir::Type fir::ReferenceType::getEleTy() const {
 mlir::LogicalResult fir::ReferenceType::verifyConstructionInvariants(
     llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
     mlir::Type eleTy) {
-  if (eleTy.dyn_cast<DimsType>() || eleTy.dyn_cast<FieldType>() ||
-      eleTy.dyn_cast<LenType>() || eleTy.dyn_cast<ReferenceType>() ||
-      eleTy.dyn_cast<TypeDescType>())
+  if (eleTy.isa<DimsType>() || eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
+      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
     return mlir::failure();
   return mlir::success();
 }
@@ -985,11 +997,11 @@ mlir::Type fir::PointerType::getEleTy() const {
 mlir::LogicalResult fir::PointerType::verifyConstructionInvariants(
     llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
     mlir::Type eleTy) {
-  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
-      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
-      eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
-      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
+  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+      eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
+      eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
+      eleTy.isa<TypeDescType>())
     return mlir::failure();
   return mlir::success();
 }
@@ -1012,11 +1024,11 @@ mlir::LogicalResult
 fir::HeapType::verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
                                             mlir::MLIRContext *context,
                                             mlir::Type eleTy) {
-  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
-      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
-      eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
-      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
+  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+      eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
+      eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
+      eleTy.isa<TypeDescType>())
     return mlir::failure();
   return mlir::success();
 }
@@ -1046,12 +1058,11 @@ mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
     const SequenceType::Shape &shape, mlir::Type eleTy,
     mlir::AffineMapAttr map) {
   // DIMENSION attribute can only be applied to an intrinsic or record type
-  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
-      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
-      eleTy.dyn_cast<HeapType>() || eleTy.dyn_cast<PointerType>() ||
-      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>() ||
-      eleTy.dyn_cast<SequenceType>())
+  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+      eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
+      eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
+      eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>())
     return mlir::failure();
   return mlir::success();
 }
@@ -1124,7 +1135,7 @@ mlir::Type fir::RecordType::getType(llvm::StringRef ident) {
 /// This is the type of a type descriptor object (similar to a class instance)
 
 TypeDescType fir::TypeDescType::get(mlir::Type ofType) {
-  assert(!ofType.dyn_cast<ReferenceType>());
+  assert(!ofType.isa<ReferenceType>());
   return Base::get(ofType.getContext(), FIR_TYPEDESC, ofType);
 }
 
@@ -1133,10 +1144,10 @@ mlir::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
 mlir::LogicalResult fir::TypeDescType::verifyConstructionInvariants(
     llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
     mlir::Type eleTy) {
-  if (eleTy.dyn_cast<BoxType>() || eleTy.dyn_cast<BoxCharType>() ||
-      eleTy.dyn_cast<BoxProcType>() || eleTy.dyn_cast<DimsType>() ||
-      eleTy.dyn_cast<FieldType>() || eleTy.dyn_cast<LenType>() ||
-      eleTy.dyn_cast<ReferenceType>() || eleTy.dyn_cast<TypeDescType>())
+  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+      eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
+      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
     return mlir::failure();
   return mlir::success();
 }
diff --git a/lib/optimizer/Support/CMakeLists.txt b/lib/optimizer/Support/CMakeLists.txt
index f0aecd7c5da4..73602fbfa262 100644
--- a/lib/optimizer/Support/CMakeLists.txt
+++ b/lib/optimizer/Support/CMakeLists.txt
@@ -1,13 +1,11 @@
-add_llvm_library(FIR
+add_llvm_library(FIRSupport
   InternalNames.cpp
   KindMapping.cpp
 )
 
-target_link_libraries(FIR
-  FIRDialect
-)
+target_link_libraries(FIRSupport FIRDialect)
 
-install (TARGETS FIR
+install (TARGETS FIRSupport
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib
 )
diff --git a/lib/optimizer/Transforms/CMakeLists.txt b/lib/optimizer/Transforms/CMakeLists.txt
index f9c6d10fa548..97bfbd98b2c1 100644
--- a/lib/optimizer/Transforms/CMakeLists.txt
+++ b/lib/optimizer/Transforms/CMakeLists.txt
@@ -6,9 +6,7 @@ add_llvm_library(FIRTransforms
 
 add_dependencies(FIRTransforms FIROpsIncGen)
 
-target_link_libraries(FIRTransforms
-  FIR
-)
+target_link_libraries(FIRTransforms FIROptimizer)
 
 install (TARGETS FIRTransforms
   ARCHIVE DESTINATION lib
diff --git a/lib/optimizer/Transforms/RewriteLoop.cpp b/lib/optimizer/Transforms/RewriteLoop.cpp
index bb99f4147b35..57bb60d0ee1e 100644
--- a/lib/optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/optimizer/Transforms/RewriteLoop.cpp
@@ -94,13 +94,13 @@ class LoopLoopConv : public mlir::OpRewritePattern<LoopOp> {
   matchAndRewrite(LoopOp loop, mlir::PatternRewriter &rewriter) const override {
     auto low = loop.lowerBound();
     auto high = loop.upperBound();
-    auto optStep = loop.optstep();
+    auto optStep = loop.optStep();
     auto loc = loop.getLoc();
     mlir::Value step;
     if (optStep.begin() != optStep.end()) {
       step = *optStep.begin();
     } else {
-      auto conStep = loop.constep();
+      auto conStep = loop.constantStep();
       step = rewriter.create<mlir::ConstantIndexOp>(
           loc, conStep.hasValue() ? conStep.getValue().getSExtValue() : 1);
     }
diff --git a/test-lit/fir/embox-write.fir b/test-lit/fir/embox-write.fir
index 465848fdbd64..dadbfb14ccd4 100644
--- a/test-lit/fir/embox-write.fir
+++ b/test-lit/fir/embox-write.fir
@@ -9,7 +9,7 @@ func @set_all_n(%n : index, %x : i32) {
   %a = fir.embox %aMem, %aDim : (!fir.ref<!fir.array<?xi32>>, !fir.dims<1>) -> !fir.box<!fir.array<?xi32>>
   // CHECK: phi i64
   // CHECK-NEXT: icmp
-  fir.loop %i = %c1 to %n unordered {
+  %i = fir.loop %i = %c1 to %n unordered {
     %1 = fir.coordinate_of %a, %i : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
     // CHECK: store i32 %{{.*}}, i32* %{{.*}}
     fir.store %x to %1 : !fir.ref<i32>
diff --git a/test-lit/fir/fir-ops.fir b/test-lit/fir/fir-ops.fir
index 20d404c0e4ac..bab218691ac8 100644
--- a/test-lit/fir/fir-ops.fir
+++ b/test-lit/fir/fir-ops.fir
@@ -208,7 +208,7 @@ func @loop() {
   %c10 = constant 10 : index
   %ct = constant true
   // CHECK: fir.loop %{{.*}} = %{{.*}} to %{{.*}} {
-  fir.loop %i = %c1 to %c10 {
+  %i = fir.loop %i = %c1 to %c10 {
     // CHECK: fir.where %{{.*}} {
     fir.where %ct {
       fir.call @nop() : () -> ()
diff --git a/test-lit/fir/loop.fir b/test-lit/fir/loop.fir
index d85bb2e20226..df61c77ae996 100644
--- a/test-lit/fir/loop.fir
+++ b/test-lit/fir/loop.fir
@@ -6,7 +6,7 @@
 func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
   // CHECK: %[[COND:.*]] = icmp slt i64
   // CHECK: br i1 %[[COND]]
-  fir.loop %iv = %lb to %ub step %step unordered {
+  %iv = fir.loop %iv = %lb to %ub step %step unordered {
     // CHECK: br i1 %
     fir.where %b {
       // CHECK: store i64
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index ec55e8c785aa..6f896fc32d56 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 set(LIBS
   FIRDialect
-  FortranOptimizer
+  FIROptimizer
   MLIRAffineOps
   MLIRLLVMIR
   MLIRLoopOps
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 14728265bc26..6966c907ef3c 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -1,36 +1,25 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+
 set(LIBS
   FIRDialect
-  FortranOptimizer
-  MLIRAffineOps
+  FIROptimizer
+  FIRTransforms
+  MLIRAllDialects
   MLIRIR
   MLIRLLVMIR
-  MLIRLoopOps
   MLIRPass
-  MLIRStandardOps
   MLIRStandardToLLVM
   MLIRTransforms
-)
-
-add_llvm_library(FirTcoLib tco.cpp)
-target_link_libraries(FirTcoLib ${LIBS} FIRTransforms)
-
-set(EXE_LIBS
-  ${LIBS}
-  FIRTransforms
   MLIRAffineToStandard
   MLIRAnalysis
   MLIRLoopToStandard
   MLIREDSC
-  MLIRLinalgOps
   MLIRParser
   MLIRStandardToLLVM
   MLIRSupport
-  MLIRVectorOps
   MLIRVectorToLLVM
 )
 
 add_llvm_tool(tco tco.cpp)
 llvm_update_compile_flags(tco)
-whole_archive_link(tco ${LIBS})
-target_link_libraries(tco PRIVATE FIRDialect MLIRIR FirTcoLib ${EXE_LIBS} LLVMSupport)
+target_link_libraries(tco PRIVATE ${LIBS})
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 637bd939dc05..fa3761baa271 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -20,6 +20,7 @@
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
@@ -110,7 +111,7 @@ int compileFIR() {
   // run the pass manager
   if (mlir::succeeded(pm.run(*owningRef))) {
     // passes ran successfully, so keep the output
-    if (emitFir) 
+    if (emitFir)
       printModuleBody(*owningRef, out.os());
     out.keep();
     return 0;
@@ -124,6 +125,9 @@ int compileFIR() {
 } // namespace
 
 int main(int argc, char **argv) {
+  mlir::registerAllDialects();
+  fir::registerFIR();
+  fir::registerFIRPasses();
   [[maybe_unused]] InitLLVM y(argc, argv);
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");

From 1da2d57cd9ca8403518c2c7214618cc37490432c Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 14 Feb 2020 07:01:59 -0800
Subject: [PATCH 187/345] Fix linking regression

---
 lib/lower/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/lower/CMakeLists.txt b/lib/lower/CMakeLists.txt
index 5fa8e22f4b92..7984a1dc4b53 100644
--- a/lib/lower/CMakeLists.txt
+++ b/lib/lower/CMakeLists.txt
@@ -13,7 +13,7 @@ add_library(FortranLower
 )
 
 target_link_libraries(FortranLower
-  FIR
+  FIRSupport
   MLIRAffineOps
   MLIRLLVMIR
   MLIRLoopToStandard

From fcb36bd30194e74f246ab349890fdfe4b3393cbc Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 14 Feb 2020 14:31:23 -0800
Subject: [PATCH 188/345] more work on fir

---
 include/flang/optimizer/Dialect/FIRAttr.h |  42 ++--
 include/flang/optimizer/Dialect/FIROps.td | 242 +++++++++-------------
 lib/optimizer/Dialect/FIROps.cpp          |  20 +-
 lib/optimizer/Transforms/RewriteLoop.cpp  |  12 +-
 test-lit/fir/embox-write.fir              |   2 +-
 test-lit/fir/fir-ops.fir                  |  14 +-
 test-lit/fir/global.fir                   |  16 ++
 test-lit/fir/loop.fir                     |   2 +-
 test-lit/fir/loop10.fir                   |  24 +++
 9 files changed, 194 insertions(+), 180 deletions(-)
 create mode 100644 test-lit/fir/global.fir
 create mode 100644 test-lit/fir/loop10.fir

diff --git a/include/flang/optimizer/Dialect/FIRAttr.h b/include/flang/optimizer/Dialect/FIRAttr.h
index c642ac8476d8..3ce9a54a629d 100644
--- a/include/flang/optimizer/Dialect/FIRAttr.h
+++ b/include/flang/optimizer/Dialect/FIRAttr.h
@@ -43,13 +43,13 @@ class ExactTypeAttr
   using Base::Base;
   using ValueType = mlir::Type;
 
-  constexpr static llvm::StringRef getAttrName() { return "instance"; }
+  static constexpr llvm::StringRef getAttrName() { return "instance"; }
   static ExactTypeAttr get(mlir::Type value);
 
   mlir::Type getType() const;
 
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() { return AttributeKind::FIR_EXACTTYPE; }
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_EXACTTYPE; }
 };
 
 class SubclassAttr
@@ -59,13 +59,13 @@ class SubclassAttr
   using Base::Base;
   using ValueType = mlir::Type;
 
-  constexpr static llvm::StringRef getAttrName() { return "subsumed"; }
+  static constexpr llvm::StringRef getAttrName() { return "subsumed"; }
   static SubclassAttr get(mlir::Type value);
 
   mlir::Type getType() const;
 
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() { return AttributeKind::FIR_SUBCLASS; }
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_SUBCLASS; }
 };
 
 // Attributes for building SELECT CASE multiway branches
@@ -79,10 +79,10 @@ class ClosedIntervalAttr
 public:
   using Base::Base;
 
-  constexpr static llvm::StringRef getAttrName() { return "interval"; }
+  static constexpr llvm::StringRef getAttrName() { return "interval"; }
   static ClosedIntervalAttr get(mlir::MLIRContext *ctxt);
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() {
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() {
     return AttributeKind::FIR_CLOSEDCLOSED_INTERVAL;
   }
 };
@@ -95,10 +95,10 @@ class UpperBoundAttr : public mlir::Attribute::AttrBase<UpperBoundAttr> {
 public:
   using Base::Base;
 
-  constexpr static llvm::StringRef getAttrName() { return "upper"; }
+  static constexpr llvm::StringRef getAttrName() { return "upper"; }
   static UpperBoundAttr get(mlir::MLIRContext *ctxt);
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() {
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() {
     return AttributeKind::FIR_OPENCLOSED_INTERVAL;
   }
 };
@@ -111,10 +111,10 @@ class LowerBoundAttr : public mlir::Attribute::AttrBase<LowerBoundAttr> {
 public:
   using Base::Base;
 
-  constexpr static llvm::StringRef getAttrName() { return "lower"; }
+  static constexpr llvm::StringRef getAttrName() { return "lower"; }
   static LowerBoundAttr get(mlir::MLIRContext *ctxt);
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() {
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() {
     return AttributeKind::FIR_CLOSEDOPEN_INTERVAL;
   }
 };
@@ -127,10 +127,10 @@ class PointIntervalAttr : public mlir::Attribute::AttrBase<PointIntervalAttr> {
 public:
   using Base::Base;
 
-  constexpr static llvm::StringRef getAttrName() { return "point"; }
+  static constexpr llvm::StringRef getAttrName() { return "point"; }
   static PointIntervalAttr get(mlir::MLIRContext *ctxt);
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() { return AttributeKind::FIR_POINT; }
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_POINT; }
 };
 
 /// A real attribute is used to workaround MLIR's default parsing of a real
@@ -144,14 +144,14 @@ class RealAttr
   using Base::Base;
   using ValueType = std::pair<int, llvm::APFloat>;
 
-  constexpr static llvm::StringRef getAttrName() { return "real"; }
+  static constexpr llvm::StringRef getAttrName() { return "real"; }
   static RealAttr get(mlir::MLIRContext *ctxt, const ValueType &key);
 
   int getFKind() const;
   llvm::APFloat getValue() const;
 
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() { return AttributeKind::FIR_REAL_ATTR; }
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return AttributeKind::FIR_REAL_ATTR; }
 };
 
 mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index a920473ce803..b2904fb23c59 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -157,7 +157,7 @@ class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
 
 // Base class of FIR operations that have 1 argument and return 1 result
 class fir_SimpleOneResultOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_SimpleOp<mnemonic, traits>, Results<(outs fir_Type:$res)> {
+    fir_SimpleOp<mnemonic, traits> {
   let builders = [fir_OneResultOpBuilder];
 }
 
@@ -711,14 +711,23 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
           getSelector().getType().isa<fir::LogicalType>() ||
           getSelector().getType().isa<fir::CharacterType>()))
       return emitOpError("must be an integer, character, or logical");
+    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
     for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
-      // TODO: add checks!
+      auto &attr = cases[i];
+      if (attr.isa<fir::PointIntervalAttr>() ||
+          attr.isa<fir::LowerBoundAttr>() ||
+          attr.isa<fir::UpperBoundAttr>() ||
+          attr.isa<fir::ClosedIntervalAttr>() ||
+          attr.isa<mlir::UnitAttr>()) {
+        // ok
+      } else {
+        return emitOpError("incorrect select case attribute type");
+      }
     }
     return mlir::success();
   }];
 
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
-
     mlir::Value getCaseArg(unsigned dest, unsigned ele) {
       assert(ele < 2);
       assert(dest < getNumConditions());
@@ -996,9 +1005,8 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
   }];
 }
 
-def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
-    Arguments<(ins SymbolRefAttr:$funcname, AnyReferenceLike:$host)>,
-    Results<(outs fir_BoxProcType)> {
+def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
+
   let summary = "boxes a given procedure and optional host context";
 
   let description = [{
@@ -1019,6 +1027,10 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]>,
                                   !fir.boxproc<(i32) -> i32>
   }];
 
+  let arguments = (ins SymbolRefAttr:$funcname, AnyReferenceLike:$host);
+
+  let results = (outs fir_BoxProcType);
+
   let parser = [{
     mlir::SymbolRefAttr procRef;
     if (parser.parseAttribute(procRef, "funcname", result.attributes))
@@ -1112,17 +1124,24 @@ def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]>,
 
 def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]>,
     Arguments<(ins fir_BoxProcType:$boxproc)>,
-    Results<(outs FunctionType, fir_ReferenceType)> {
+    Results<(outs FunctionType, fir_ReferenceType:$refTuple)> {
   let summary = "unbox a boxproc value into a pair value";
 
   let description = [{
     Unboxes a value of `boxproc` type into a pair consisting of a procedure
     pointer and a pointer to a host context.
   }];
+
+  let verifier = [{
+    if (auto eleTy = fir::dyn_cast_ptrEleTy(refTuple().getType()))
+      if (eleTy.isa<mlir::TupleType>())
+        return mlir::success();
+    return emitOpError("second output argument has bad type");
+  }];
 }
 
-def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val)> {
+def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
+
   let summary = "return a memory reference to the boxed value";
 
   let description = [{
@@ -1132,38 +1151,24 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]>,
     CHARACTER data, and the address of the procedure.
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    mlir::OpAsmParser::OperandType opnd;
-    if (parser.parseOperand(opnd) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperand(opnd, type.getInput(0), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
+  let arguments = (ins fir_BoxType:$val);
 
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(val());
-    p << " : ";
-    p.printFunctionalType(getOperation());
-  }];
+  let results = (outs AnyReferenceLike);
 }
 
-def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]>,
-    Arguments<(ins fir_BoxCharType:$val)>,
-    Results<(outs AnyIntegerLike)> {
+def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
   let summary = "return the LEN type parameter from a boxchar value";
 
   let description = [{
     Extracts the LEN type parameter from a `boxchar` value.
   }];
+
+  let arguments = (ins fir_BoxCharType:$val);
+
+  let results = (outs AnyIntegerLike);
 }
 
-def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val, AnyIntegerLike:$dim)>,
-    Results<(outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike)> {
+def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
   let summary = "return the dynamic dimension information for the boxed value";
 
   let description = [{
@@ -1173,26 +1178,12 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
     `dim` is out of bounds.
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> operands;
-    if (parser.parseOperandList(operands, 2,
-            mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
+  let arguments = (ins fir_BoxType:$val, AnyIntegerLike:$dim);
 
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(val());
-    p << ", ";
-    p.printOperand(dim());
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let results = (outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike);
+
+  let assemblyFormat = [{
+    $val `,` $dim attr-dict `:` functional-type(operands, results)
   }];
 
   let extraClassDeclaration = [{
@@ -1200,14 +1191,17 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]>,
   }];
 }
 
-def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val)> {
+def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
   let summary = "return the size of an element of the boxed value";
 
   let description = [{
     Returns the size of an element in an entity of `box` type.  This size may
     not be known until runtime.
   }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs AnyIntegerLike);
 }
 
 def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]>,
@@ -1263,23 +1257,29 @@ def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]>,
   }];
 }
 
-def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val)> {
+def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
   let summary = "return the number of dimensions for the boxed value";
 
   let description = [{
     Return the rank of a value of `box` type.  If the value is scalar, the
     rank is 0.
   }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs AnyIntegerType);
 }
 
-def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val)> {
+def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
   let summary = "return the type descriptor for the boxed value";
 
   let description = [{
     Return the opaque type descriptor of a value of `box` type.
   }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs fir_TypeDescType);
 }
 
 // Record and array type operations
@@ -1294,26 +1294,8 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
     and a list of index values. (This returns the address of a value.)
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
-    if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(ref());
-    p << ", ";
-    p.printOperands(coor());
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
   }];
 
   let verifier = [{
@@ -1339,26 +1321,8 @@ def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]>,
     index values.
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
-    if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(adt());
-    p << ", ";
-    p.printOperands(coor());
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let assemblyFormat = [{
+    $adt `,` $coor attr-dict `:` functional-type(operands, results)
   }];
 }
 
@@ -1440,8 +1404,8 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
   }];
 }
 
-def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>,
-    Arguments<(ins Variadic<AnyIntegerType>:$triples)> {
+def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
+
   let summary = "generate a value of type `!fir.dims`";
 
   let description = [{
@@ -1454,58 +1418,37 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]>,
     stride must not be zero.
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 6> operands;
-    if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
+  let arguments = (ins Variadic<AnyIntegerType>:$triples);
+
+  let results = (outs fir_DimsType);
+
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
   }];
 
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperands(triples());
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let verifier = [{
+    auto size = triples().size();
+    if (size < 1 && size <= 16 * 3)
+      return emitOpError("incorrect number of args");
+    if (size % 3 != 0)
+      return emitOpError("requires a multiple of 3 args");
+    return mlir::success();
   }];
 }
 
-def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]>,
-    Arguments<(ins AnyCompositeLike:$adt, AnyType:$val,
-    Variadic<AnyComponentType>:$coor)> {
+def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
   let summary = "insert a new sub-value into a copy of an existing aggregate";
 
   let description = [{
     Insert a value into a composite value.
   }];
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
-    if (parser.parseOperandList(operands,
-            mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
+  let arguments = (ins AnyCompositeLike:$adt, AnyType:$val,
+                       Variadic<AnyComponentType>:$coor);
+  let results = (outs AnyCompositeLike);
 
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(adt());    
-    p << ", ";
-    p.printOperand(val());    
-    p << ", ";
-    p.printOperands(coor());
-    p << " : ";
-    p.printFunctionalType(getOperation());
+  let assemblyFormat = [{
+    operands attr-dict `:` functional-type(operands, results)
   }];
 }
 
@@ -1580,7 +1523,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     OptionalAttr<UnitAttr>:$unordered
   );
 
-  let results = (outs Index);
+  let results = (outs Variadic<Index>:$lastVal);
 
   let regions = (region SizedRegion<1>:$region);
   let skipDefaultBuilders = 1;
@@ -1606,7 +1549,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
       p << " unordered";
     p.printRegion(region(), /*printEntryBlockArgs=*/false,
         /*printBlockTerminators=*/false);
-    p.printOptionalAttrDict(getAttrs(), {"unordered", "step"});
+    p.printOptionalAttrDict(getAttrs(), {unorderedKeyword(), stepKeyword()});
   }];
 
   let verifier = [{
@@ -1626,25 +1569,40 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
         !body->getArgument(0).getType().isIndex())
       return emitOpError("expected body to have a single index argument for "
                          "the induction variable");
+    if (lastVal().size() > 1)
+      return emitOpError("can only return one final value of iterator");
     return mlir::success();
   }];
 
   let extraClassDeclaration = [{
+    static constexpr const char *unorderedKeyword() { return "unordered"; }
+    static constexpr const char *stepKeyword() { return "step"; }
+
+    bool isUnordered() { return getAttr(unorderedKeyword()).isa<UnitAttr>(); }
+
+    bool hasLastValue() { return lastVal().size(); }
+
+    /// Get the body of the loop
     mlir::Block *getBody() { return &region().front(); }
+
+    /// Get the block argument corresponding to the loop control value (PHI)
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
+
     mlir::OpBuilder getBodyBuilder() {
       return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
     }
+
     void setLowerBound(mlir::Value bound) {
       getOperation()->setOperand(0, bound);
     }
+
     void setUpperBound(mlir::Value bound) {
       getOperation()->setOperand(1, bound);
-     }
+    }
+
     void setStep(mlir::Value step) {
       getOperation()->setOperand(2, step);
     }
-    static char const* getStepKeyword() { return "step"; }
   }];
 }
 
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
index e518d36c28ab..a8d7496e255e 100644
--- a/lib/optimizer/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -509,15 +509,20 @@ mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
       parser.resolveOperand(ub, indexType, result.operands))
     return mlir::failure();
 
-  if (parser.parseOptionalKeyword(LoopOp::getStepKeyword()))
-    result.addAttribute(LoopOp::getStepKeyword(),
+  if (parser.parseOptionalKeyword(LoopOp::stepKeyword())) {
+    result.addAttribute(LoopOp::stepKeyword(),
                         builder.getIntegerAttr(builder.getIndexType(), 1));
-  else if (parser.parseOperand(step) ||
-           parser.resolveOperand(step, indexType, result.operands))
+  } else if (parser.parseOperand(step) ||
+             parser.resolveOperand(step, indexType, result.operands)) {
     return mlir::failure();
+  }
 
-  if (!parser.parseOptionalKeyword("unordered"))
-    result.addAttribute("unordered", builder.getUnitAttr());
+  // Parse the optional `unordered` keyword
+  bool isUnordered = false;
+  if (!parser.parseOptionalKeyword(LoopOp::unorderedKeyword())) {
+    result.addAttribute(LoopOp::unorderedKeyword(), builder.getUnitAttr());
+    isUnordered = true;
+  }
 
   // Parse the body region.
   mlir::Region *body = result.addRegion();
@@ -529,7 +534,8 @@ mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return mlir::failure();
-  result.addTypes(builder.getIndexType());
+  if (!isUnordered)
+    result.addTypes(builder.getIndexType());
   return mlir::success();
 }
 
diff --git a/lib/optimizer/Transforms/RewriteLoop.cpp b/lib/optimizer/Transforms/RewriteLoop.cpp
index 57bb60d0ee1e..3674dd08435f 100644
--- a/lib/optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/optimizer/Transforms/RewriteLoop.cpp
@@ -107,7 +107,17 @@ class LoopLoopConv : public mlir::OpRewritePattern<LoopOp> {
     auto f = rewriter.create<mlir::loop::ForOp>(loc, low, high, step);
     f.region().getBlocks().clear();
     rewriter.inlineRegionBefore(loop.region(), f.region(), f.region().end());
-    rewriter.eraseOp(loop);
+    if (loop.hasLastValue()) {
+      // Compute the final value of the loop iterator.
+      // FIXME: If there are no iterations?
+      auto ty = low.getType();
+      auto d = rewriter.create<mlir::SubIOp>(loc, ty, high, low);
+      auto q = rewriter.create<mlir::SignedDivIOp>(loc, ty, d, step);
+      auto dist = rewriter.create<mlir::MulIOp>(loc, ty, q, step);
+      rewriter.replaceOpWithNewOp<mlir::AddIOp>(loop, ty, low, dist);
+    } else {
+      rewriter.eraseOp(loop);
+    }
     return matchSuccess();
   }
 };
diff --git a/test-lit/fir/embox-write.fir b/test-lit/fir/embox-write.fir
index dadbfb14ccd4..465848fdbd64 100644
--- a/test-lit/fir/embox-write.fir
+++ b/test-lit/fir/embox-write.fir
@@ -9,7 +9,7 @@ func @set_all_n(%n : index, %x : i32) {
   %a = fir.embox %aMem, %aDim : (!fir.ref<!fir.array<?xi32>>, !fir.dims<1>) -> !fir.box<!fir.array<?xi32>>
   // CHECK: phi i64
   // CHECK-NEXT: icmp
-  %i = fir.loop %i = %c1 to %n unordered {
+  fir.loop %i = %c1 to %n unordered {
     %1 = fir.coordinate_of %a, %i : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
     // CHECK: store i32 %{{.*}}, i32* %{{.*}}
     fir.store %x to %1 : !fir.ref<i32>
diff --git a/test-lit/fir/fir-ops.fir b/test-lit/fir/fir-ops.fir
index bab218691ac8..8499006d173c 100644
--- a/test-lit/fir/fir-ops.fir
+++ b/test-lit/fir/fir-ops.fir
@@ -75,8 +75,8 @@ func @user_i64(i64)
 func @user_tdesc(!fir.tdesc<!fir.type<x>>)
 
 // expect the void return to be omitted
-// CHECK-LABEL: func @store_tuple(!fir.type<qq1{f1:i32}>)
-func @store_tuple(!fir.type<qq1{f1:i32}>) -> ()
+// CHECK-LABEL: func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>)
+func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> ()
 
 // CHECK-LABEL: func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
 // CHECK-LABEL: func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
@@ -192,13 +192,13 @@ func @boxing_match() {
   %a3 = fir.insert_value %6, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
   fir.store %a3 to %d6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
   %7 = fir.emboxproc @method_impl, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
-  %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>)
+  %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
   // CHECK: fir.emboxproc @method_impl, %{{.*}} : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
-  // CHECK: fir.unboxproc %{{.*}} : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>)
+  // CHECK: fir.unboxproc %{{.*}} : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
   %9 = call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
-  %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<!fir.type<qq1{f1:i32}>>)
-  %11 = fir.load %10#1 : !fir.ref<!fir.type<qq1{f1:i32}>>
-  fir.call @store_tuple(%11) : (!fir.type<qq1{f1:i32}>) -> ()
+  %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)
+  %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>
+  fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()
   return
 }
 
diff --git a/test-lit/fir/global.fir b/test-lit/fir/global.fir
new file mode 100644
index 000000000000..29a6dbc3e0e4
--- /dev/null
+++ b/test-lit/fir/global.fir
@@ -0,0 +1,16 @@
+// RUN: tco %s | FileCheck %s
+
+// CHECK: @g_i0 = global i32 0
+fir.global @g_i0 : i32 {
+  constant 0 : i32
+}
+
+// CHECK: @g_i2 = global i32 2
+fir.global @g_i2 : i32 {
+  constant 2 : i32
+}
+
+// CHECK: @g_ci5 = constant i32 5
+fir.global @g_ci5 constant : i32 {
+  constant 5 : i32
+}
diff --git a/test-lit/fir/loop.fir b/test-lit/fir/loop.fir
index df61c77ae996..d85bb2e20226 100644
--- a/test-lit/fir/loop.fir
+++ b/test-lit/fir/loop.fir
@@ -6,7 +6,7 @@
 func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
   // CHECK: %[[COND:.*]] = icmp slt i64
   // CHECK: br i1 %[[COND]]
-  %iv = fir.loop %iv = %lb to %ub step %step unordered {
+  fir.loop %iv = %lb to %ub step %step unordered {
     // CHECK: br i1 %
     fir.where %b {
       // CHECK: store i64
diff --git a/test-lit/fir/loop10.fir b/test-lit/fir/loop10.fir
new file mode 100644
index 000000000000..d9ad1e81a703
--- /dev/null
+++ b/test-lit/fir/loop10.fir
@@ -0,0 +1,24 @@
+// Test lowering FIR to LLVM IR of fir.select{|_rank|_case}
+
+// RUN: tco %s | FileCheck %s
+
+// CHECK: @x({{.*}} %[[ADDR:.*]])
+func @x(%addr : !fir.ref<!fir.array<10x10xi32>>) -> index {
+  %c0 = constant 0 : index
+  %c10 = constant 10 : index
+  // CHECK: %[[ROW:.*]] = phi i64
+  // CHECK: icmp slt i64 %[[ROW]], 10
+  %0 = fir.loop %iv = %c0 to %c10 {
+    // CHECK: %[[COL:.*]] = phi i64
+    // CHECK: icmp slt i64 %[[COL]], 10
+    %jv = fir.loop %jv = %c0 to %c10 {
+      // CHECK: getelementptr {{.*}} %[[ADDR]], i64 0, i64 %[[COL]], i64 %[[ROW]]
+      %ptr = fir.coordinate_of %addr, %jv, %iv : (!fir.ref<!fir.array<10x10xi32>>, index, index) -> !fir.ref<i32>
+      %c22 = constant 22 : i32
+      // CHECK: store i32 22,
+      fir.store %c22 to %ptr : !fir.ref<i32>
+    }
+  }
+  // CHECK: ret i64 10
+  return %0 : index
+}

From 7a369c5030726f1e9a1aec8b56e28409615fda66 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 29 Jan 2020 18:01:38 -0800
Subject: [PATCH 189/345] Fallout of review 959: only in mono

Fix fatal errors from f18.cpp + llvm headers
Silence all warnings from LLVM headers instead.
add back some dropped code to fix the lit test

Conflicts:
	include/flang/Lower/PFTBuilder.h
	lib/Lower/PFTBuilder.cpp
	test/lit.site.cfg.py.in
---
 CMakeLists.txt                   |   3 +-
 include/flang/Lower/PFTBuilder.h |  51 ++++---
 lib/Lower/PFTBuilder.cpp         | 188 ++++++++++++------------
 lib/lower/Bridge.cpp             | 103 ++++++-------
 lib/lower/CFGBuilder.h           | 243 +++++++++++++++----------------
 test-lit/CMakeLists.txt          |   4 +
 test/lit.site.cfg.py.in          |   1 +
 7 files changed, 289 insertions(+), 304 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 06381ef5da19..db20d7f5ab34 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -141,7 +141,8 @@ if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
     set(LLVM_INCLUDE_TESTS ON)
   endif()
 
-  include_directories("${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}")
+  # Adding System to prevent warning from LLVM headers.
+  include_directories(SYSTEM "${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}")
   link_directories("${LLVM_LIBRARY_DIR}")
   set(MLIR_BINARY_DIR ${LLVM_BINARY_DIR})
 
diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 733027cc425d..1d774d24fe2c 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -1,36 +1,28 @@
-//===-- include/flang/Lower/PFTBuilder.h ------------------------*- C++ -*-===//
+//===-- flang/lower/PFTBuilder.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
 //
 //===----------------------------------------------------------------------===//
+//
+// This defines the PFT abstraction interface.
+//
+//===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_LOWER_PFT_BUILDER_H_
-#define FORTRAN_LOWER_PFT_BUILDER_H_
+#ifndef FORTRAN_LOWER_PFTBUILDER_H_
+#define FORTRAN_LOWER_PFTBUILDER_H_
 
 #include "flang/Common/template.h"
 #include "flang/Parser/parse-tree.h"
 #include <memory>
 
-/// Build a light-weight tree over the parse-tree to help with lowering to FIR.
-/// It is named Pre-FIR Tree (PFT) to underline it has no other usage than
-/// helping lowering to FIR.
-/// The PFT will capture pointers back into the parse tree, so the parse tree
-/// data structure may <em>not</em> be changed between the construction of the
-/// PFT and all of its uses.
-///
-/// The PFT captures a structured view of the program.  The program is a list of
-/// units.  Function like units will contain lists of evaluations.  Evaluations
-/// are either statements or constructs, where a construct contains a list of
-/// evaluations. The resulting PFT structure can then be used to create FIR.
-
 namespace llvm {
 class raw_ostream;
 }
 
 namespace Fortran::lower {
-namespace pft {
+namespace PFT {
 
 struct Evaluation;
 struct Program;
@@ -193,7 +185,7 @@ struct Evaluation {
   /// Construct ctor
   template <typename A>
   Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
-    static_assert(pft::isConstruct<A>, "must be a construct");
+    static_assert(PFT::isConstruct<A>, "must be a construct");
   }
 
   constexpr bool isActionOrGenerated() const {
@@ -211,7 +203,7 @@ struct Evaluation {
           using T = std::decay_t<decltype(r)>;
           static constexpr bool isStmt{isActionStmt<T> || isOtherStmt<T> ||
                                        isConstructStmt<T>};
-          static_assert(!(isStmt && pft::isConstruct<T>),
+          static_assert(!(isStmt && PFT::isConstruct<T>),
                         "statement classification is inconsistent");
           return isStmt;
         },
@@ -379,19 +371,30 @@ struct Program {
   std::list<Units> units;
 };
 
-} // namespace pft
+} // namespace PFT
 
-/// Create an PFT from the parse tree
-std::unique_ptr<pft::Program> createPFT(const parser::Program &root);
+/// Create an PFT from the parse tree.
+///
+/// Build a light-weight tree over the parse-tree to help with lowering to FIR.
+/// It is named Pre-FIR Tree (PFT) to underline it has no other usage than
+/// helping lowering to FIR.  The PFT will capture pointers back into the parse
+/// tree, so the parse tree data structure may <em>not</em> be changed between
+/// the construction of the PFT and all of its uses.
+///
+/// The PFT captures a structured view of the program.  The program is a list of
+/// units.  Function like units will contain lists of evaluations.  Evaluations
+/// are either statements or constructs, where a construct contains a list of
+/// evaluations. The resulting PFT structure can then be used to create FIR.
+std::unique_ptr<PFT::Program> createPFT(const parser::Program &root);
 
 /// Decorate the PFT with control flow annotations
 ///
 /// The PFT must be decorated with control-flow annotations to prepare it for
 /// use in generating a CFG-like structure.
-void annotateControl(pft::Program &);
+void annotateControl(PFT::Program &);
 
-void dumpPFT(llvm::raw_ostream &o, pft::Program &);
+void dumpPFT(llvm::raw_ostream &o, PFT::Program &);
 
 } // namespace Fortran::lower
 
-#endif // FORTRAN_LOWER_PFT_BUILDER_H_
+#endif // FORTRAN_LOWER_PFTBUILDER_H_
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 5941b570b216..676e1b92e085 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -1,4 +1,4 @@
-//===-- lib/Lower/PFTBuilder.cc -------------------------------------------===//
+//===-- PFTBuilder.cc -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -68,17 +68,17 @@ struct UnwrapStmt<parser::UnlabeledStatement<A>> {
 /// the bridge to one such instantiation.
 class PFTBuilder {
 public:
-  PFTBuilder() : pgm{new pft::Program}, parents{*pgm.get()} {}
+  PFTBuilder() : pgm{new PFT::Program}, parents{*pgm.get()} {}
 
   /// Get the result
-  std::unique_ptr<pft::Program> result() { return std::move(pgm); }
+  std::unique_ptr<PFT::Program> result() { return std::move(pgm); }
 
   template <typename A>
   constexpr bool Pre(const A &a) {
     bool visit{true};
-    if constexpr (pft::isFunctionLike<A>) {
+    if constexpr (PFT::isFunctionLike<A>) {
       return enterFunc(a);
-    } else if constexpr (pft::isConstruct<A>) {
+    } else if constexpr (PFT::isConstruct<A>) {
       return enterConstruct(a);
     } else if constexpr (UnwrapStmt<A>::isStmt) {
       using T = typename UnwrapStmt<A>::Type;
@@ -86,8 +86,8 @@ class PFTBuilder {
       // Statement<T>, Statement<Indirection<T>, UnlabeledStatement<T>,
       // or UnlabeledStatement<Indirection<T>>
       auto stmt{UnwrapStmt<A>(a)};
-      if constexpr (pft::isConstructStmt<T> || pft::isOtherStmt<T>) {
-        addEval(pft::Evaluation{stmt.unwrapped, parents.back(), stmt.pos,
+      if constexpr (PFT::isConstructStmt<T> || PFT::isOtherStmt<T>) {
+        addEval(PFT::Evaluation{stmt.unwrapped, parents.back(), stmt.pos,
                                 stmt.lab});
         visit = false;
       } else if constexpr (std::is_same_v<T, parser::ActionStmt>) {
@@ -100,9 +100,9 @@ class PFTBuilder {
 
   template <typename A>
   constexpr void Post(const A &) {
-    if constexpr (pft::isFunctionLike<A>) {
+    if constexpr (PFT::isFunctionLike<A>) {
       exitFunc();
-    } else if constexpr (pft::isConstruct<A>) {
+    } else if constexpr (PFT::isConstruct<A>) {
       exitConstruct();
     }
   }
@@ -116,7 +116,7 @@ class PFTBuilder {
 
   // Block data
   bool Pre(const parser::BlockData &node) {
-    addUnit(pft::BlockDataUnit{node, parents.back()});
+    addUnit(PFT::BlockDataUnit{node, parents.back()});
     return false;
   }
 
@@ -125,7 +125,7 @@ class PFTBuilder {
                &statement) {
     addEval(std::visit(
         [&](const auto &x) {
-          return pft::Evaluation{x, parents.back(), statement.source, {}};
+          return PFT::Evaluation{x, parents.back(), statement.source, {}};
         },
         statement.statement.u));
     return false;
@@ -133,7 +133,7 @@ class PFTBuilder {
   bool Pre(const parser::Statement<parser::ForallAssignmentStmt> &statement) {
     addEval(std::visit(
         [&](const auto &x) {
-          return pft::Evaluation{x, parents.back(), statement.source,
+          return PFT::Evaluation{x, parents.back(), statement.source,
                                  statement.label};
         },
         statement.statement.u));
@@ -145,7 +145,7 @@ class PFTBuilder {
             [&](const parser::Statement<parser::AssignmentStmt> &stmt) {
               // Not caught as other AssignmentStmt because it is not
               // wrapped in a parser::ActionStmt.
-              addEval(pft::Evaluation{stmt.statement, parents.back(),
+              addEval(PFT::Evaluation{stmt.statement, parents.back(),
                                       stmt.source, stmt.label});
               return false;
             },
@@ -158,13 +158,13 @@ class PFTBuilder {
   // ActionStmt has a couple of non-conforming cases, which get handled
   // explicitly here.  The other cases use an Indirection, which we discard in
   // the PFT.
-  pft::Evaluation makeEvalAction(const parser::ActionStmt &statement,
+  PFT::Evaluation makeEvalAction(const parser::ActionStmt &statement,
                                  parser::CharBlock pos,
                                  std::optional<parser::Label> lab) {
     return std::visit(
         common::visitors{
             [&](const auto &x) {
-              return pft::Evaluation{removeIndirection(x), parents.back(), pos,
+              return PFT::Evaluation{removeIndirection(x), parents.back(), pos,
                                      lab};
             },
         },
@@ -175,7 +175,7 @@ class PFTBuilder {
   // set the builder's cursors to point to it.
   template <typename A>
   bool enterFunc(const A &func) {
-    auto &unit = addFunc(pft::FunctionLikeUnit{func, parents.back()});
+    auto &unit = addFunc(PFT::FunctionLikeUnit{func, parents.back()});
     funclist = &unit.funcs;
     pushEval(&unit.evals);
     parents.emplace_back(unit);
@@ -185,8 +185,8 @@ class PFTBuilder {
   void setFunctListToParentFuncs() {
     if (!parents.empty()) {
       std::visit(common::visitors{
-                     [&](pft::FunctionLikeUnit *p) { funclist = &p->funcs; },
-                     [&](pft::ModuleLikeUnit *p) { funclist = &p->funcs; },
+                     [&](PFT::FunctionLikeUnit *p) { funclist = &p->funcs; },
+                     [&](PFT::ModuleLikeUnit *p) { funclist = &p->funcs; },
                      [&](auto *) { funclist = nullptr; },
                  },
                  parents.back().p);
@@ -203,8 +203,8 @@ class PFTBuilder {
   // set the builder's evaluation cursor to point to it.
   template <typename A>
   bool enterConstruct(const A &construct) {
-    auto &con = addEval(pft::Evaluation{construct, parents.back()});
-    con.subs.reset(new pft::EvaluationCollection);
+    auto &con = addEval(PFT::Evaluation{construct, parents.back()});
+    con.subs.reset(new PFT::EvaluationCollection);
     pushEval(con.subs.get());
     parents.emplace_back(con);
     return true;
@@ -219,7 +219,7 @@ class PFTBuilder {
   // set the builder's function cursor to point to it.
   template <typename A>
   bool enterModule(const A &func) {
-    auto &unit = addUnit(pft::ModuleLikeUnit{func, parents.back()});
+    auto &unit = addUnit(PFT::ModuleLikeUnit{func, parents.back()});
     funclist = &unit.funcs;
     parents.emplace_back(unit);
     return true;
@@ -246,7 +246,7 @@ class PFTBuilder {
   }
 
   /// move the Evaluation to the end of the current list
-  pft::Evaluation &addEval(pft::Evaluation &&eval) {
+  PFT::Evaluation &addEval(PFT::Evaluation &&eval) {
     assert(funclist && "not in a function");
     assert(evallist.size() > 0);
     evallist.back()->emplace_back(std::move(eval));
@@ -254,7 +254,7 @@ class PFTBuilder {
   }
 
   /// push a new list on the stack of Evaluation lists
-  void pushEval(pft::EvaluationCollection *eval) {
+  void pushEval(PFT::EvaluationCollection *eval) {
     assert(funclist && "not in a function");
     assert(eval && eval->empty() && "evaluation list isn't correct");
     evallist.emplace_back(eval);
@@ -266,16 +266,16 @@ class PFTBuilder {
     evallist.pop_back();
   }
 
-  std::unique_ptr<pft::Program> pgm;
+  std::unique_ptr<PFT::Program> pgm;
   /// funclist points to FunctionLikeUnit::funcs list (resp.
   /// ModuleLikeUnit::funcs) when building a FunctionLikeUnit (resp.
   /// ModuleLikeUnit) to store internal procedures (resp. module procedures).
   /// Otherwise (e.g. when building the top level Program), it is null.
-  std::list<pft::FunctionLikeUnit> *funclist{nullptr};
+  std::list<PFT::FunctionLikeUnit> *funclist{nullptr};
   /// evallist is a stack of pointer to FunctionLikeUnit::evals (or
   /// Evaluation::subs) that are being build.
-  std::vector<pft::EvaluationCollection *> evallist;
-  std::vector<pft::ParentType> parents;
+  std::vector<PFT::EvaluationCollection *> evallist;
+  std::vector<PFT::ParentType> parents;
 };
 
 template <typename Label, typename A>
@@ -319,16 +319,16 @@ bool hasAltReturns(const parser::CallStmt &callStmt) {
 ///
 /// \param cstr points to the current construct. It may be null at the top-level
 /// of a FunctionLikeUnit.
-void altRet(pft::Evaluation &evaluation, const parser::CallStmt &callStmt,
-            pft::Evaluation *cstr) {
+void altRet(PFT::Evaluation &evaluation, const parser::CallStmt &callStmt,
+            PFT::Evaluation *cstr) {
   if (hasAltReturns(callStmt))
-    evaluation.setCFG(pft::CFGAnnotation::Switch, cstr);
+    evaluation.setCFG(PFT::CFGAnnotation::Switch, cstr);
 }
 
 /// \param cstr points to the current construct. It may be null at the top-level
 /// of a FunctionLikeUnit.
-void annotateEvalListCFG(pft::EvaluationCollection &evaluationCollection,
-                         pft::Evaluation *cstr) {
+void annotateEvalListCFG(PFT::EvaluationCollection &evaluationCollection,
+                         PFT::Evaluation *cstr) {
   bool nextIsTarget = false;
   for (auto &eval : evaluationCollection) {
     eval.isTarget = nextIsTarget;
@@ -346,84 +346,84 @@ void annotateEvalListCFG(pft::EvaluationCollection &evaluationCollection,
           altRet(eval, statement, cstr);
         },
         [&](const parser::CycleStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::ExitStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::FailImageStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Terminate, cstr);
         },
         [&](const parser::GotoStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::IfStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::ReturnStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Return, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Return, cstr);
         },
         [&](const parser::StopStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Terminate, cstr);
         },
         [&](const parser::ArithmeticIfStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::AssignedGotoStmt &) {
-          eval.setCFG(pft::CFGAnnotation::IndGoto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::IndGoto, cstr);
         },
         [&](const parser::ComputedGotoStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::WhereStmt &) {
           // fir.loop + fir.where around the next stmt
           eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
         },
         [&](const parser::ForallStmt &) {
           // fir.loop around the next stmt
           eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
         },
-        [&](pft::CGJump &) { eval.setCFG(pft::CFGAnnotation::Goto, cstr); },
+        [&](PFT::CGJump &) { eval.setCFG(PFT::CFGAnnotation::Goto, cstr); },
         [&](const parser::SelectCaseStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::NonLabelDoStmt &) {
           eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
         },
         [&](const parser::EndDoStmt &) {
           eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::IfThenStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::ElseIfStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::SelectRankStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::SelectTypeStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::WhereConstruct &) {
           // mark the WHERE as if it were a DO loop
           eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
         },
         [&](const parser::WhereConstructStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::MaskedElsewhereStmt &) {
           eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::ForallConstructStmt &) {
           eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
         },
 
         [&](const auto &stmt) {
@@ -452,13 +452,13 @@ void annotateEvalListCFG(pft::EvaluationCollection &evaluationCollection,
             if (hasLabel<parser::ErrLabel>(stmt) ||
                 hasLabel<parser::EorLabel>(stmt) ||
                 hasLabel<parser::EndLabel>(stmt))
-              eval.setCFG(pft::CFGAnnotation::IoSwitch, cstr);
+              eval.setCFG(PFT::CFGAnnotation::IoSwitch, cstr);
           } else if constexpr (common::HasMember<A, TargetStmts>) {
             eval.isTarget = true;
           } else if constexpr (common::HasMember<A, DoNothingConstructStmts>) {
             // Explicitly do nothing for these construct statements
           } else {
-            static_assert(!pft::isConstructStmt<A>,
+            static_assert(!PFT::isConstructStmt<A>,
                           "All ConstructStmts impact on the control flow "
                           "should be explicitly handled");
           }
@@ -470,7 +470,7 @@ void annotateEvalListCFG(pft::EvaluationCollection &evaluationCollection,
 
 /// Annotate the PFT with CFG source decorations (see CFGAnnotation) and mark
 /// potential branch targets
-inline void annotateFuncCFG(pft::FunctionLikeUnit &functionLikeUnit) {
+inline void annotateFuncCFG(PFT::FunctionLikeUnit &functionLikeUnit) {
   annotateEvalListCFG(functionLikeUnit.evals, nullptr);
   for (auto &internalFunc : functionLikeUnit.funcs)
     annotateFuncCFG(internalFunc);
@@ -478,18 +478,18 @@ inline void annotateFuncCFG(pft::FunctionLikeUnit &functionLikeUnit) {
 
 class PFTDumper {
 public:
-  void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
+  void dumpPFT(llvm::raw_ostream &outputStream, PFT::Program &pft) {
     for (auto &unit : pft.getUnits()) {
       std::visit(common::visitors{
-                     [&](pft::BlockDataUnit &unit) {
+                     [&](PFT::BlockDataUnit &unit) {
                        outputStream << getNodeIndex(unit) << " ";
                        outputStream << "BlockData: ";
                        outputStream << "\nEndBlockData\n\n";
                      },
-                     [&](pft::FunctionLikeUnit &func) {
+                     [&](PFT::FunctionLikeUnit &func) {
                        dumpFunctionLikeUnit(outputStream, func);
                      },
-                     [&](pft::ModuleLikeUnit &unit) {
+                     [&](PFT::ModuleLikeUnit &unit) {
                        dumpModuleLikeUnit(outputStream, unit);
                      },
                  },
@@ -498,9 +498,9 @@ class PFTDumper {
     resetIndexes();
   }
 
-  llvm::StringRef evalName(pft::Evaluation &eval) {
+  llvm::StringRef evalName(PFT::Evaluation &eval) {
     return eval.visit(common::visitors{
-        [](const pft::CGJump) { return "CGJump"; },
+        [](const PFT::CGJump) { return "CGJump"; },
         [](const auto &parseTreeNode) {
           return parser::ParseTreeDumper::GetNodeName(parseTreeNode);
         },
@@ -508,11 +508,11 @@ class PFTDumper {
   }
 
   void dumpEvalList(llvm::raw_ostream &outputStream,
-                    pft::EvaluationCollection &evaluationCollection,
+                    PFT::EvaluationCollection &evaluationCollection,
                     int indent = 1) {
     static const std::string white{"                                      ++"};
     std::string indentString{white.substr(0, indent * 2)};
-    for (pft::Evaluation &eval : evaluationCollection) {
+    for (PFT::Evaluation &eval : evaluationCollection) {
       outputStream << indentString << getNodeIndex(eval) << " ";
       llvm::StringRef name{evalName(eval)};
       if (auto *subs{eval.getConstructEvals()}) {
@@ -528,7 +528,7 @@ class PFTDumper {
   }
 
   void dumpFunctionLikeUnit(llvm::raw_ostream &outputStream,
-                            pft::FunctionLikeUnit &functionLikeUnit) {
+                            PFT::FunctionLikeUnit &functionLikeUnit) {
     outputStream << getNodeIndex(functionLikeUnit) << " ";
     llvm::StringRef unitKind{};
     std::string name{};
@@ -580,7 +580,7 @@ class PFTDumper {
   }
 
   void dumpModuleLikeUnit(llvm::raw_ostream &outputStream,
-                          pft::ModuleLikeUnit &moduleLikeUnit) {
+                          PFT::ModuleLikeUnit &moduleLikeUnit) {
     outputStream << getNodeIndex(moduleLikeUnit) << " ";
     outputStream << "ModuleLike: ";
     outputStream << "\nContains\n";
@@ -599,7 +599,7 @@ class PFTDumper {
     nodeIndexes.try_emplace(addr, nextIndex);
     return nextIndex++;
   }
-  std::size_t getNodeIndex(const pft::Program &) { return 0; }
+  std::size_t getNodeIndex(const PFT::Program &) { return 0; }
 
   void resetIndexes() {
     nodeIndexes.clear();
@@ -612,20 +612,20 @@ class PFTDumper {
 };
 
 template <typename A, typename T>
-pft::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
-  return pft::FunctionLikeUnit::FunctionStatement{
+PFT::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
+  return PFT::FunctionLikeUnit::FunctionStatement{
       &std::get<parser::Statement<A>>(func.t)};
 }
 template <typename A, typename T>
-pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
-  return pft::ModuleLikeUnit::ModuleStatement{
+PFT::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
+  return PFT::ModuleLikeUnit::ModuleStatement{
       &std::get<parser::Statement<A>>(mod.t)};
 }
 
 } // namespace
 
-pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
-                                        const pft::ParentType &parent)
+PFT::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
+                                        const PFT::ParentType &parent)
     : ProgramUnit{func, parent} {
   auto &ps{
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t)};
@@ -636,51 +636,51 @@ pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
   endStmt = getFunctionStmt<parser::EndProgramStmt>(func);
 }
 
-pft::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,
-                                        const pft::ParentType &parent)
+PFT::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,
+                                        const PFT::ParentType &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::FunctionStmt>(func)},
       endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)} {}
 
-pft::FunctionLikeUnit::FunctionLikeUnit(
-    const parser::SubroutineSubprogram &func, const pft::ParentType &parent)
+PFT::FunctionLikeUnit::FunctionLikeUnit(
+    const parser::SubroutineSubprogram &func, const PFT::ParentType &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::SubroutineStmt>(func)},
       endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)} {}
 
-pft::FunctionLikeUnit::FunctionLikeUnit(
-    const parser::SeparateModuleSubprogram &func, const pft::ParentType &parent)
+PFT::FunctionLikeUnit::FunctionLikeUnit(
+    const parser::SeparateModuleSubprogram &func, const PFT::ParentType &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
       endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {}
 
-pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Module &m,
-                                    const pft::ParentType &parent)
+PFT::ModuleLikeUnit::ModuleLikeUnit(const parser::Module &m,
+                                    const PFT::ParentType &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::ModuleStmt>(m)},
       endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {}
 
-pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Submodule &m,
-                                    const pft::ParentType &parent)
+PFT::ModuleLikeUnit::ModuleLikeUnit(const parser::Submodule &m,
+                                    const PFT::ParentType &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::SubmoduleStmt>(
                                   m)},
       endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {}
 
-pft::BlockDataUnit::BlockDataUnit(const parser::BlockData &bd,
-                                  const pft::ParentType &parent)
+PFT::BlockDataUnit::BlockDataUnit(const parser::BlockData &bd,
+                                  const PFT::ParentType &parent)
     : ProgramUnit{bd, parent} {}
 
-std::unique_ptr<pft::Program> createPFT(const parser::Program &root) {
+std::unique_ptr<PFT::Program> createPFT(const parser::Program &root) {
   PFTBuilder walker;
   Walk(root, walker);
   return walker.result();
 }
 
-void annotateControl(pft::Program &pft) {
+void annotateControl(PFT::Program &pft) {
   for (auto &unit : pft.getUnits()) {
     std::visit(common::visitors{
-                   [](pft::BlockDataUnit &) {},
-                   [](pft::FunctionLikeUnit &func) { annotateFuncCFG(func); },
-                   [](pft::ModuleLikeUnit &unit) {
+                   [](PFT::BlockDataUnit &) {},
+                   [](PFT::FunctionLikeUnit &func) { annotateFuncCFG(func); },
+                   [](PFT::ModuleLikeUnit &unit) {
                      for (auto &func : unit.funcs)
                        annotateFuncCFG(func);
                    },
@@ -690,7 +690,7 @@ void annotateControl(pft::Program &pft) {
 }
 
 /// Dump a PFT.
-void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
+void dumpPFT(llvm::raw_ostream &outputStream, PFT::Program &pft) {
   PFTDumper{}.dumpPFT(outputStream, pft);
 }
 
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 8bed5fbd0e08..80a309bf011f 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -110,7 +110,7 @@ class FirConverter : public AbstractConverter {
             [&](PFT::Evaluation *c) { return inMainProgram(c); },
             [](auto *) { return false; },
         },
-        cstr->parent);
+        cstr->parent.p);
   }
   static const Pa::SubroutineStmt *inSubroutine(PFT::Evaluation *cstr) {
     return std::visit(
@@ -119,7 +119,7 @@ class FirConverter : public AbstractConverter {
             [&](PFT::Evaluation *c) { return inSubroutine(c); },
             [](auto *) -> const Pa::SubroutineStmt * { return nullptr; },
         },
-        cstr->parent);
+        cstr->parent.p);
   }
   static const Pa::FunctionStmt *inFunction(PFT::Evaluation *cstr) {
     return std::visit(
@@ -128,7 +128,7 @@ class FirConverter : public AbstractConverter {
             [&](PFT::Evaluation *c) { return inFunction(c); },
             [](auto *) -> const Pa::FunctionStmt * { return nullptr; },
         },
-        cstr->parent);
+        cstr->parent.p);
   }
   static const Pa::MpSubprogramStmt *inMPSubp(PFT::Evaluation *cstr) {
     return std::visit(
@@ -137,7 +137,7 @@ class FirConverter : public AbstractConverter {
             [&](PFT::Evaluation *c) { return inMPSubp(c); },
             [](auto *) -> const Pa::MpSubprogramStmt * { return nullptr; },
         },
-        cstr->parent);
+        cstr->parent.p);
   }
 
   template <typename A>
@@ -150,29 +150,25 @@ class FirConverter : public AbstractConverter {
   }
   /// Get the condition expression for a CondGoto evaluation
   const Se::SomeExpr *getEvaluationCondition(PFT::Evaluation &eval) {
-    return std::visit(Co::visitors{
-                          [&](const Pa::IfStmt *stmt) {
-                            return getScalarExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::IfThenStmt *stmt) {
-                            return getScalarExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::ElseIfStmt *stmt) {
-                            return getScalarExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::WhereConstructStmt *stmt) {
-                            return getExprOfTuple(stmt->t);
-                          },
-                          [&](const Pa::MaskedElsewhereStmt *stmt) {
-                            return getExprOfTuple(stmt->t);
-                          },
-                          [&](auto) -> const Se::SomeExpr * {
-                            M::emitError(toLocation(),
-                                         "unexpected conditional branch case");
-                            return nullptr;
-                          },
-                      },
-                      eval.u);
+    return eval.visit(Co::visitors{
+        [&](const Pa::IfStmt &stmt) { return getScalarExprOfTuple(stmt.t); },
+        [&](const Pa::IfThenStmt &stmt) {
+          return getScalarExprOfTuple(stmt.t);
+        },
+        [&](const Pa::ElseIfStmt &stmt) {
+          return getScalarExprOfTuple(stmt.t);
+        },
+        [&](const Pa::WhereConstructStmt &stmt) {
+          return getExprOfTuple(stmt.t);
+        },
+        [&](const Pa::MaskedElsewhereStmt &stmt) {
+          return getExprOfTuple(stmt.t);
+        },
+        [&](auto &) -> const Se::SomeExpr * {
+          M::emitError(toLocation(), "unexpected conditional branch case");
+          return nullptr;
+        },
+    });
   }
 
   //
@@ -361,9 +357,8 @@ class FirConverter : public AbstractConverter {
     assert(eval.subs && "eval must have a body");
     auto *insPt = builder->getInsertionBlock();
 
-    if (const auto **doConstruct{
-            std::get_if<const Pa::DoConstruct *>(&eval.u)}) {
-      if (const auto &loopControl{(*doConstruct)->GetLoopControl()}) {
+    if (const auto *doConstruct{eval.getIf<Pa::DoConstruct>()}) {
+      if (const auto &loopControl{doConstruct->GetLoopControl()}) {
         std::visit(Co::visitors{
                        [&](const Pa::LoopControl::Bounds &x) {
                          M::Value lo{genFIRLoopIndex(x.lower)};
@@ -406,21 +401,21 @@ class FirConverter : public AbstractConverter {
         // TODO: Infinite loop: 11.1.7.4.1 par 2
         TODO();
       }
-    } else if (std::holds_alternative<const Pa::IfConstruct *>(eval.u)) {
+    } else if (eval.isA<Pa::IfConstruct>()) {
       // Construct fir.where
       fir::WhereOp where;
       for (auto &e : *eval.subs) {
-        if (auto **s = std::get_if<const Pa::IfThenStmt *>(&e.u)) {
+        if (auto *s{e.getIf<Pa::IfThenStmt>()}) {
           // fir.where op
-          genWhereCondition(where, *s);
-        } else if (auto **s = std::get_if<const Pa::ElseIfStmt *>(&e.u)) {
+          genWhereCondition(where, s);
+        } else if (auto *s{e.getIf<Pa::ElseIfStmt>()}) {
           // otherwise block, then nested fir.where
           switchInsertionPointToOtherwise(where);
-          genWhereCondition(where, *s);
-        } else if (std::holds_alternative<const Pa::ElseStmt *>(e.u)) {
+          genWhereCondition(where, s);
+        } else if (e.isA<Pa::ElseStmt>()) {
           // otherwise block
           switchInsertionPointToOtherwise(where);
-        } else if (std::holds_alternative<const Pa::EndIfStmt *>(e.u)) {
+        } else if (e.isA<Pa::EndIfStmt>()) {
           // close all open fir.where ops
           builder->clearInsertionPoint();
         } else {
@@ -846,11 +841,10 @@ class FirConverter : public AbstractConverter {
 
   void genFIR(PFT::Evaluation &eval) {
     currentEvaluation = &eval;
-    std::visit(Co::visitors{
-                   [&](const auto *p) { genFIR(*p); },
-                   [](const PFT::CGJump &) { /* do nothing */ },
-               },
-               eval.u);
+    eval.visit(Co::visitors{
+        [&](const auto &p) { genFIR(p); },
+        [](const PFT::CGJump &) { /* do nothing */ },
+    });
   }
 
   /// Lower an Evaluation
@@ -959,13 +953,10 @@ class FirConverter : public AbstractConverter {
                  L::Optional<L::StringRef> host = {}) {
     std::string name;
     const Se::Symbol *symbol{nullptr};
-    auto size{func.funStmts.size()};
 
-    assert((size == 1 || size == 2) && "ill-formed subprogram");
-    if (size == 2) {
+    if (func.beginStmt) {
       currentEvaluation = nullptr;
-      std::visit([&](auto *p) { genFIR(*p, name, symbol); },
-                 func.funStmts.front());
+      std::visit([&](auto *p) { genFIR(*p, name, symbol); }, *func.beginStmt);
     } else {
       name = uniquer.doProgramEntry();
     }
@@ -977,8 +968,7 @@ class FirConverter : public AbstractConverter {
       lowerEval(e);
     }
     currentEvaluation = nullptr;
-    std::visit([&](auto *p) { genFIR(*p, name, symbol); },
-               func.funStmts.back());
+    std::visit([&](auto *p) { genFIR(*p, name, symbol); }, func.endStmt);
 
     endNewFunction();
 
@@ -1111,9 +1101,9 @@ class FirConverter : public AbstractConverter {
         uniquer{uniquer} {}
 
   /// Convert the PFT to FIR
-  void run(PFT::Program &ast) {
+  void run(PFT::Program &pft) {
     // build pruned control
-    for (auto &u : ast.getUnits()) {
+    for (auto &u : pft.getUnits()) {
       std::visit(Co::visitors{
                      [&](PFT::FunctionLikeUnit &f) { pruneFunc(f); },
                      [&](PFT::ModuleLikeUnit &m) { pruneMod(m); },
@@ -1123,7 +1113,7 @@ class FirConverter : public AbstractConverter {
     }
 
     // do translation
-    for (auto &u : ast.getUnits()) {
+    for (auto &u : pft.getUnits()) {
       std::visit(Co::visitors{
                      [&](PFT::FunctionLikeUnit &f) { lowerFunc(f, {}); },
                      [&](PFT::ModuleLikeUnit &m) { lowerMod(m); },
@@ -1194,14 +1184,13 @@ class FirConverter : public AbstractConverter {
 
 void Br::BurnsideBridge::lower(const Pa::Program &prg,
                                fir::NameUniquer &uniquer) {
-  PFT::Program *ast{Br::createPFT(prg)};
-  Br::annotateControl(*ast);
+  std::unique_ptr<PFT::Program> pft{Br::createPFT(prg)};
+  Br::annotateControl(*pft);
   if (dumpBeforeFir) {
-    Br::dumpPFT(L::errs(), *ast);
+    Br::dumpPFT(L::errs(), *pft);
   }
   FirConverter converter{*this, uniquer};
-  converter.run(*ast);
-  delete ast;
+  converter.run(*pft);
 }
 
 void Br::BurnsideBridge::parseSourceFile(L::SourceMgr &srcMgr) {
diff --git a/lib/lower/CFGBuilder.h b/lib/lower/CFGBuilder.h
index fcebe8221756..dc3282fdf695 100644
--- a/lib/lower/CFGBuilder.h
+++ b/lib/lower/CFGBuilder.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/cfg-builder.h ---------------------------------*- C++ -*-===//
+//===-- lower/cfg-builder.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.
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_LOWER_CFG_BUILDER_H_
-#define FORTRAN_LOWER_CFG_BUILDER_H_
+#ifndef FORTRAN_LOWER_CFGBUILDER_H_
+#define FORTRAN_LOWER_CFGBUILDER_H_
 
 /// Traverse the PFT and complete the CFG by drawing the arcs, pruning unused
 /// potential targets, making implied jumps explicit, etc.
@@ -39,22 +39,21 @@ class CfgBuilder {
   /// cache ASSIGN statements that may yield a live branch target
   void cacheAssigns(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
-      std::visit(Co::visitors{
-                     [&](const Pa::AssignStmt *stmt) {
-                       auto *trg = getEvalByLabel(std::get<Pa::Label>(stmt->t));
-                       auto *sym = std::get<Pa::Name>(stmt->t).symbol;
-                       assert(sym);
-                       auto jter = assignedGotoMap.find(sym);
-                       if (jter == assignedGotoMap.end()) {
-                         std::list<PFT::Evaluation *> lst = {trg};
-                         assignedGotoMap.try_emplace(sym, lst);
-                       } else {
-                         jter->second.emplace_back(trg);
-                       }
-                     },
-                     [](auto) { /* do nothing */ },
-                 },
-                 e.u);
+      e.visit(Co::visitors{
+          [&](const Pa::AssignStmt &stmt) {
+            auto *trg = getEvalByLabel(std::get<Pa::Label>(stmt.t));
+            auto *sym = std::get<Pa::Name>(stmt.t).symbol;
+            assert(sym);
+            auto jter = assignedGotoMap.find(sym);
+            if (jter == assignedGotoMap.end()) {
+              std::list<PFT::Evaluation *> lst = {trg};
+              assignedGotoMap.try_emplace(sym, lst);
+            } else {
+              jter->second.emplace_back(trg);
+            }
+          },
+          [](auto &) { /* do nothing */ },
+      });
       if (e.subs) {
         cacheAssigns(*e.subs);
       }
@@ -72,10 +71,10 @@ class CfgBuilder {
 
   bool structuredCheck(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
-      if (auto **s = std::get_if<const Pa::DoConstruct *>(&e.u)) {
-        return (*s)->IsDoWhile() ? false : structuredCheck(*e.subs);
+      if (auto *s = e.getIf<Pa::DoConstruct>()) {
+        return s->IsDoWhile() ? false : structuredCheck(*e.subs);
       }
-      if (std::holds_alternative<const Pa::IfConstruct *>(e.u)) {
+      if (e.isA<Pa::IfConstruct>()) {
         return structuredCheck(*e.subs);
       }
       if (e.subs) {
@@ -101,7 +100,7 @@ class CfgBuilder {
       case PFT::CFGAnnotation::Terminate:
         return false;
       case PFT::CFGAnnotation::Goto:
-        if (!std::holds_alternative<const Pa::EndDoStmt *>(e.u)) {
+        if (!e.isA<Pa::EndDoStmt>()) {
           return false;
         }
         break;
@@ -112,13 +111,13 @@ class CfgBuilder {
 
   void wrapIterationSpaces(std::list<PFT::Evaluation> &evals) {
     for (auto &e : evals) {
-      if (std::holds_alternative<const Pa::DoConstruct *>(e.u))
+      if (e.isA<Pa::DoConstruct>())
         if (structuredCheck(*e.subs)) {
           deannotate(*e.subs);
           e.cfg = PFT::CFGAnnotation::FirStructuredOp;
           continue;
         }
-      if (std::holds_alternative<const Pa::IfConstruct *>(e.u))
+      if (e.isA<Pa::IfConstruct>())
         if (structuredCheck(*e.subs)) {
           deannotate(*e.subs);
           e.cfg = PFT::CFGAnnotation::FirStructuredOp;
@@ -159,13 +158,12 @@ class CfgBuilder {
   template <typename A>
   A nextFalseTarget(A iter, const A &endi) {
     for (; iter != endi; ++iter)
-      if (std::visit(Co::visitors{
-                         [&](const Pa::ElseIfStmt *) { return true; },
-                         [&](const Pa::ElseStmt *) { return true; },
-                         [&](const Pa::EndIfStmt *) { return true; },
-                         [](auto) { return false; },
-                     },
-                     iter->u)) {
+      if (iter->visit(Co::visitors{
+              [&](const Pa::ElseIfStmt &) { return true; },
+              [&](const Pa::ElseStmt &) { return true; },
+              [&](const Pa::EndIfStmt &) { return true; },
+              [](auto &) { return false; },
+          })) {
         break;
       }
     return iter;
@@ -179,8 +177,8 @@ class CfgBuilder {
                      const A &iter, const A &endif) {
     A i{iter};
     A j{nextFalseTarget(++i, endif)};
-    auto *cstr = std::get<PFT::Evaluation *>(e.parent);
-    PFT::CGJump jump{&*endif};
+    auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
+    PFT::CGJump jump{*endif};
     A k{evals.insert(j, PFT::Evaluation{std::move(jump), j->parent})};
     if (i == j) {
       // block was empty, so adjust "true" target
@@ -201,111 +199,100 @@ class CfgBuilder {
         // do nothing - does not impart control flow
         break;
       case PFT::CFGAnnotation::Goto:
-        std::visit(
-            Co::visitors{
-                [&](const Pa::CycleStmt *) {
-                  // FIXME: deal with construct name
-                  auto *cstr = std::get<PFT::Evaluation *>(e.parent);
-                  addSourceToSink(&e, &cstr->subs->front());
-                },
-                [&](const Pa::ExitStmt *) {
-                  // FIXME: deal with construct name
-                  auto *cstr = std::get<PFT::Evaluation *>(e.parent);
-                  addSourceToSink(&e, &cstr->subs->back());
-                },
-                [&](const Pa::GotoStmt *stmt) { addSourceToSink(&e, stmt->v); },
-                [&](const Pa::EndDoStmt *) {
-                  // the END DO is the loop exit landing pad
-                  // insert a JUMP as the backedge right before the END DO
-                  auto *cstr = std::get<PFT::Evaluation *>(e.parent);
-                  PFT::CGJump jump{&cstr->subs->front()};
-                  PFT::Evaluation jumpEval{std::move(jump), iter->parent};
-                  evals.insert(iter, std::move(jumpEval));
-                  addSourceToSink(&e, &cstr->subs->front());
-                },
-                [&](const PFT::CGJump &jump) {
-                  addSourceToSink(&e, jump.target);
-                },
-                [](auto) { assert(false && "unhandled GOTO case"); },
+        e.visit(Co::visitors{
+            [&](const Pa::CycleStmt &) {
+              // FIXME: deal with construct name
+              auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
+              addSourceToSink(&e, &cstr->subs->front());
             },
-            e.u);
+            [&](const Pa::ExitStmt &) {
+              // FIXME: deal with construct name
+              auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
+              addSourceToSink(&e, &cstr->subs->back());
+            },
+            [&](const Pa::GotoStmt &stmt) { addSourceToSink(&e, stmt.v); },
+            [&](const Pa::EndDoStmt &) {
+              // the END DO is the loop exit landing pad
+              // insert a JUMP as the backedge right before the END DO
+              auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
+              PFT::CGJump jump{cstr->subs->front()};
+              PFT::Evaluation jumpEval{std::move(jump), iter->parent};
+              evals.insert(iter, std::move(jumpEval));
+              addSourceToSink(&e, &cstr->subs->front());
+            },
+            [&](const PFT::CGJump &jump) { addSourceToSink(&e, &jump.target); },
+            [](auto &) { assert(false && "unhandled GOTO case"); },
+        });
         break;
       case PFT::CFGAnnotation::CondGoto:
-        std::visit(Co::visitors{
-                       [&](const Pa::IfStmt *) {
-                         // check if these are marked; they must targets here
-                         auto i{iter};
-                         addSourceToSink(&e, &*(++i));
-                         addSourceToSink(&e, &*(++i));
-                       },
-                       [&](const Pa::IfThenStmt *) {
-                         doNextIfBlock(evals, e, iter, evals.end());
-                       },
-                       [&](const Pa::ElseIfStmt *) {
-                         doNextIfBlock(evals, e, iter, evals.end());
-                       },
-                       [](const Pa::WhereConstructStmt *) { TODO(); },
-                       [](const Pa::MaskedElsewhereStmt *) { TODO(); },
-                       [](auto) { assert(false && "unhandled CGOTO case"); },
-                   },
-                   e.u);
+        e.visit(Co::visitors{
+            [&](const Pa::IfStmt &) {
+              // check if these are marked; they must targets here
+              auto i{iter};
+              addSourceToSink(&e, &*(++i));
+              addSourceToSink(&e, &*(++i));
+            },
+            [&](const Pa::IfThenStmt &) {
+              doNextIfBlock(evals, e, iter, evals.end());
+            },
+            [&](const Pa::ElseIfStmt &) {
+              doNextIfBlock(evals, e, iter, evals.end());
+            },
+            [](const Pa::WhereConstructStmt &) { TODO(); },
+            [](const Pa::MaskedElsewhereStmt &) { TODO(); },
+            [](auto &) { assert(false && "unhandled CGOTO case"); },
+        });
         break;
       case PFT::CFGAnnotation::IndGoto:
-        std::visit(Co::visitors{
-                       [&](const Pa::AssignedGotoStmt *stmt) {
-                         auto *sym = std::get<Pa::Name>(stmt->t).symbol;
-                         if (assignedGotoMap.find(sym) != assignedGotoMap.end())
-                           for (auto *x : assignedGotoMap[sym]) {
-                             addSourceToSink(&e, x);
-                           }
-                         for (auto &l :
-                              std::get<std::list<Pa::Label>>(stmt->t)) {
-                           addSourceToSink(&e, l);
-                         }
-                       },
-                       [](auto) { assert(false && "unhandled IGOTO case"); },
-                   },
-                   e.u);
+        e.visit(Co::visitors{
+            [&](const Pa::AssignedGotoStmt &stmt) {
+              auto *sym = std::get<Pa::Name>(stmt.t).symbol;
+              if (assignedGotoMap.find(sym) != assignedGotoMap.end())
+                for (auto *x : assignedGotoMap[sym]) {
+                  addSourceToSink(&e, x);
+                }
+              for (auto &l : std::get<std::list<Pa::Label>>(stmt.t)) {
+                addSourceToSink(&e, l);
+              }
+            },
+            [](auto &) { assert(false && "unhandled IGOTO case"); },
+        });
         break;
       case PFT::CFGAnnotation::IoSwitch:
-        std::visit(
-            Co::visitors{
-                [](const Pa::BackspaceStmt *) { TODO(); },
-                [](const Pa::CloseStmt *) { TODO(); },
-                [](const Pa::EndfileStmt *) { TODO(); },
-                [](const Pa::FlushStmt *) { TODO(); },
-                [](const Pa::InquireStmt *) { TODO(); },
-                [](const Pa::OpenStmt *) { TODO(); },
-                [](const Pa::ReadStmt *) { TODO(); },
-                [](const Pa::RewindStmt *) { TODO(); },
-                [](const Pa::WaitStmt *) { TODO(); },
-                [](const Pa::WriteStmt *) { TODO(); },
-                [](auto) { assert(false && "unhandled IO switch case"); },
-            },
-            e.u);
+        e.visit(Co::visitors{
+            [](const Pa::BackspaceStmt &) { TODO(); },
+            [](const Pa::CloseStmt &) { TODO(); },
+            [](const Pa::EndfileStmt &) { TODO(); },
+            [](const Pa::FlushStmt &) { TODO(); },
+            [](const Pa::InquireStmt &) { TODO(); },
+            [](const Pa::OpenStmt &) { TODO(); },
+            [](const Pa::ReadStmt &) { TODO(); },
+            [](const Pa::RewindStmt &) { TODO(); },
+            [](const Pa::WaitStmt &) { TODO(); },
+            [](const Pa::WriteStmt &) { TODO(); },
+            [](auto &) { assert(false && "unhandled IO switch case"); },
+        });
         break;
       case PFT::CFGAnnotation::Switch:
-        std::visit(Co::visitors{
-                       [](const Pa::CallStmt *) { TODO(); },
-                       [](const Pa::ArithmeticIfStmt *) { TODO(); },
-                       [](const Pa::ComputedGotoStmt *) { TODO(); },
-                       [](const Pa::SelectCaseStmt *) { TODO(); },
-                       [](const Pa::SelectRankStmt *) { TODO(); },
-                       [](const Pa::SelectTypeStmt *) { TODO(); },
-                       [](auto) { assert(false && "unhandled switch case"); },
-                   },
-                   e.u);
+        e.visit(Co::visitors{
+            [](const Pa::CallStmt &) { TODO(); },
+            [](const Pa::ArithmeticIfStmt &) { TODO(); },
+            [](const Pa::ComputedGotoStmt &) { TODO(); },
+            [](const Pa::SelectCaseStmt &) { TODO(); },
+            [](const Pa::SelectRankStmt &) { TODO(); },
+            [](const Pa::SelectTypeStmt &) { TODO(); },
+            [](auto &) { assert(false && "unhandled switch case"); },
+        });
         break;
       case PFT::CFGAnnotation::Iterative:
-        std::visit(Co::visitors{
-                       [](const Pa::NonLabelDoStmt *) { TODO(); },
-                       [](const Pa::WhereStmt *) { TODO(); },
-                       [](const Pa::ForallStmt *) { TODO(); },
-                       [](const Pa::WhereConstruct *) { TODO(); },
-                       [](const Pa::ForallConstructStmt *) { TODO(); },
-                       [](auto) { assert(false && "unhandled loop case"); },
-                   },
-                   e.u);
+        e.visit(Co::visitors{
+            [](const Pa::NonLabelDoStmt &) { TODO(); },
+            [](const Pa::WhereStmt &) { TODO(); },
+            [](const Pa::ForallStmt &) { TODO(); },
+            [](const Pa::WhereConstruct &) { TODO(); },
+            [](const Pa::ForallConstructStmt &) { TODO(); },
+            [](auto &) { assert(false && "unhandled loop case"); },
+        });
         break;
       case PFT::CFGAnnotation::FirStructuredOp:
         // do not visit the subs
diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index f5393623f802..56d7faef5265 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -1,8 +1,12 @@
 # Test runner infrastructure for Flang. This configures the Flang test trees
 # for use by Lit, and delegates to LLVM's lit test handlers.
 
+# f18 modules directory
+set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/tools/f18/include)
+
 # f18/flang tools path for lit
 set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
+
 # bbc/tco tools path for lit
 if (FLANG_BUILT_STANDALONE)
  set(FLANG_LLVM_TOOLS_DIR  ${FLANG_BINARY_DIR}/bin)
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index ac50c3d7921a..6e77ba69f079 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -6,6 +6,7 @@ config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
+config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 #config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.flang_llvm_tools_dir = "@FLANG_LLVM_TOOLS_DIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"

From 33b07af16be1d0d1e0df464be3494e51bdb59e1b Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 18 Feb 2020 16:12:54 -0800
Subject: [PATCH 190/345] move GlobalOp to tablegen

---
 include/flang/optimizer/Dialect/FIROps.h  | 36 +--------
 include/flang/optimizer/Dialect/FIROps.td | 96 +++++++++++++++++++++++
 lib/optimizer/CodeGen.cpp                 |  9 ++-
 lib/optimizer/Dialect/FIRDialect.cpp      |  2 +-
 lib/optimizer/Dialect/FIROps.cpp          | 63 ---------------
 5 files changed, 104 insertions(+), 102 deletions(-)

diff --git a/include/flang/optimizer/Dialect/FIROps.h b/include/flang/optimizer/Dialect/FIROps.h
index 77d130d1d1ab..9c09406ab7a0 100644
--- a/include/flang/optimizer/Dialect/FIROps.h
+++ b/include/flang/optimizer/Dialect/FIROps.h
@@ -10,7 +10,9 @@
 #define OPTIMIZER_DIALECT_FIROPS_H
 
 #include "mlir/IR/Builders.h"
+#include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
@@ -48,40 +50,6 @@ enum class CmpFPredicate {
   NumPredicates
 };
 
-/// `fir.global` is a typed symbol with an optional list of initializers.
-class GlobalOp
-    : public mlir::Op<GlobalOp, OpTrait::ZeroOperands, OpTrait::ZeroResult,
-                      OpTrait::IsIsolatedFromAbove,
-                      OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
-public:
-  using Op::Op;
-  using Op::print;
-
-  static llvm::StringRef getOperationName() { return "fir.global"; }
-  static llvm::StringRef getTypeAttrName() { return "type"; }
-
-  static void build(mlir::Builder *builder, OperationState &result,
-                    llvm::StringRef name, mlir::Type type,
-                    llvm::ArrayRef<NamedAttribute> attrs);
-
-  static GlobalOp create(Location loc, llvm::StringRef name, mlir::Type type,
-                         llvm::ArrayRef<NamedAttribute> attrs = {});
-
-  /// Operation hooks.
-  static ParseResult parse(OpAsmParser &parser, OperationState &result);
-  void print(OpAsmPrinter &p);
-  LogicalResult verify();
-
-  mlir::Type getType() {
-    return getAttrOfType<TypeAttr>(getTypeAttrName()).getValue();
-  }
-
-  void appendInitialValue(mlir::Operation *op);
-
-private:
-  mlir::Region &front();
-};
-
 /// `fir.dispatch_table` is an untyped symbol that is a list of associations
 /// between method identifiers and a FuncOp symbol.
 class DispatchTableOp
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index b2904fb23c59..40bcbb55d453 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -2153,6 +2153,101 @@ def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
   let assemblyFormat = "$val attr-dict `:` type($val)";
 }
 
+def fir_GlobalOp :
+    fir_Op<"global", [IsolatedFromAbove, Symbol, ImplicitFirTerminator]> {
+  let summary = "Global data";
+
+  let description = [{
+    Global data object. FIXME
+  }];
+
+  let parser = [{
+    // Parse the name as a symbol reference attribute.
+    SymbolRefAttr nameAttr;
+    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
+                              result.attributes))
+      return failure();
+
+    auto &builder = parser.getBuilder();
+    auto name = nameAttr.getRootReference();
+    result.attributes.back().second = builder.getStringAttr(name);
+
+    if (!parser.parseOptionalKeyword(getConstantName())) {
+      // if "constant" keyword then mark this as a constant, not a variable
+      result.addAttribute(getConstantName(), builder.getUnitAttr());
+    }
+
+    mlir::Type globalType;
+    if (parser.parseColonType(globalType))
+      return mlir::failure();
+
+    result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(globalType));
+
+    // Parse the optional initializer body.
+    mlir::Region *body = result.addRegion();
+    if (parser.parseOptionalRegion(
+          *body, llvm::ArrayRef<mlir::OpAsmParser::OperandType>{},
+          llvm::ArrayRef<mlir::Type>{}))
+      return mlir::failure();
+
+    ensureTerminator(*body, builder, result.location);
+    return mlir::success();
+  }];
+
+  let printer = [{
+    auto varName = getAttrOfType<StringAttr>(
+      mlir::SymbolTable::getSymbolAttrName()).getValue();
+    p << getOperationName() << " @" << varName;
+    if (getAttr(getConstantName()))
+      p << ' ' << getConstantName();
+    p << " : ";
+    p.printType(getType());
+    Region &body = getOperation()->getRegion(0);
+    if (!body.empty())
+      p.printRegion(body, /*printEntryBlockArgs=*/false,
+                    /*printBlockTerminators=*/false);
+  }];
+
+  let verifier = [{
+    // FIXME
+    return mlir::success();
+  }];
+
+  let regions = (region SizedRegion<1>:$region);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
+              "llvm::StringRef name, mlir::Type type,"
+              "llvm::ArrayRef<NamedAttribute> attrs = {}",
+    [{
+      result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(type));
+      result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                          builder->getStringAttr(name));
+      for (const auto &pair : attrs)
+        result.addAttribute(pair.first, pair.second);
+    }]>
+  ];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef getConstantName() { return "constant"; }
+    static constexpr llvm::StringRef getTypeAttrName() { return "type"; }
+
+    GlobalOp create(mlir::Location location, llvm::StringRef name,
+                    mlir::Type type, llvm::ArrayRef<NamedAttribute> attrs);
+
+    mlir::Type getType() {
+      return getAttrOfType<TypeAttr>(getTypeAttrName()).getValue();
+    }
+
+    void appendInitialValue(mlir::Operation *op);
+
+    mlir::Region &front() {
+      return getOperation()->getRegion(0);
+    }
+  }];
+}
+
 def fir_GlobalEntryOp : fir_Op<"global_entry", []> {
 
   let summary = "map a field entry in a global";
@@ -2187,6 +2282,7 @@ def fir_GlobalEntryOp : fir_Op<"global_entry", []> {
     result.addAttribute("in_type", mlir::TypeAttr::get(type));
     return mlir::success();
   }];
+
   let printer = [{
     p << getOperationName() << ' ' << getAttr("field") << ", ";
     p.printOperand(constant());
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index 122aa1b3c002..d7d93457e5ba 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -1214,10 +1214,10 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
       if (coor.getNumOperands() == 2) {
         auto coorPtr = *coor.coor().begin();
         auto s = coorPtr.getDefiningOp();
-        if (dyn_cast_or_null<LenParamIndexOp>(s)) {
-          auto &lenParam = operands[1]; // byte offset
-          auto bc =
-              rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy(), base);
+        if (s && isa<LenParamIndexOp>(s)) {
+          mlir::Value lenParam = operands[1]; // byte offset
+          auto vty = voidPtrTy();
+          auto bc = rewriter.create<mlir::LLVM::BitcastOp>(loc, vty, base);
           auto uty = unwrap(ty);
           auto gep = genGEP(loc, uty, rewriter, bc, lenParam);
           rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, uty, gep);
@@ -1228,6 +1228,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
       auto pty = unwrap(convertType(boxTy.getEleTy())).getPointerTo();
       // Extract the boxed reference
       auto p = genGEP(loc, pty, rewriter, base, c0, c0_);
+      // base = box->data : ptr
       base = rewriter.create<mlir::LLVM::LoadOp>(loc, pty, p);
     }
 
diff --git a/lib/optimizer/Dialect/FIRDialect.cpp b/lib/optimizer/Dialect/FIRDialect.cpp
index b199025c5112..9ddb463283fe 100644
--- a/lib/optimizer/Dialect/FIRDialect.cpp
+++ b/lib/optimizer/Dialect/FIRDialect.cpp
@@ -45,7 +45,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
            RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
   addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
                 PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
-  addOperations<GlobalOp, DispatchTableOp,
+  addOperations<DispatchTableOp,
 #define GET_OP_LIST
 #include "flang/optimizer/Dialect/FIROps.cpp.inc"
                 >();
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
index a8d7496e255e..1345f7327c14 100644
--- a/lib/optimizer/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -386,73 +386,10 @@ GlobalOp GlobalOp::create(mlir::Location location, llvm::StringRef name,
   return cast<GlobalOp>(Operation::create(state));
 }
 
-void GlobalOp::build(mlir::Builder *builder, mlir::OperationState &result,
-                     llvm::StringRef name, mlir::Type type,
-                     llvm::ArrayRef<mlir::NamedAttribute> attrs) {
-  result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(type));
-  result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
-                      builder->getStringAttr(name));
-  for (const auto &pair : attrs)
-    result.addAttribute(pair.first, pair.second);
-}
-
-mlir::ParseResult GlobalOp::parse(mlir::OpAsmParser &parser,
-                                  mlir::OperationState &result) {
-  // Parse the name as a symbol reference attribute.
-  SymbolRefAttr nameAttr;
-  if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
-                            result.attributes))
-    return failure();
-
-  auto &builder = parser.getBuilder();
-  auto name = nameAttr.getRootReference();
-  result.attributes.back().second = builder.getStringAttr(name);
-
-  if (!parser.parseOptionalKeyword("constant")) {
-    // if "constant" keyword then mark this as a constant, not a variable
-    result.addAttribute("constant", builder.getUnitAttr());
-  }
-
-  mlir::Type globalType;
-  if (parser.parseColonType(globalType))
-    return mlir::failure();
-
-  result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(globalType));
-
-  // Parse the optional initializer body.
-  mlir::Region *body = result.addRegion();
-  if (parser.parseOptionalRegion(
-          *body, llvm::ArrayRef<mlir::OpAsmParser::OperandType>{},
-          llvm::ArrayRef<mlir::Type>{}))
-    return mlir::failure();
-
-  ensureTerminator(*body, builder, result.location);
-  return mlir::success();
-}
-
-void GlobalOp::print(mlir::OpAsmPrinter &p) {
-  auto varName =
-      getAttrOfType<StringAttr>(mlir::SymbolTable::getSymbolAttrName())
-          .getValue();
-  p << getOperationName() << " @" << varName;
-  if (getAttr("constant"))
-    p << " constant";
-  p << " : ";
-  p.printType(getType());
-  Region &body = getOperation()->getRegion(0);
-  if (!body.empty())
-    p.printRegion(body, /*printEntryBlockArgs=*/false,
-                  /*printBlockTerminators=*/false);
-}
-
-mlir::LogicalResult GlobalOp::verify() { return mlir::success(); }
-
 void GlobalOp::appendInitialValue(mlir::Operation *op) {
   front().front().push_back(op);
 }
 
-mlir::Region &GlobalOp::front() { return this->getOperation()->getRegion(0); }
-
 // LoadOp
 
 /// Get the element type of a reference like type; otherwise null

From 66a3e038d288acbbb2e247d881fa4414e3472833 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 19 Feb 2020 11:12:44 -0800
Subject: [PATCH 191/345] gratuitous name changes

Conflicts:
	lib/Lower/PFTBuilder.cpp
	lib/lower/NSAliases.h

more cleanups
add isActionStmt back (Val)

expand namespace names

Conflicts:
	lib/Lower/PFTBuilder.cpp
---
 include/flang/Lower/PFTBuilder.h          |  44 ++-
 include/flang/optimizer/Dialect/FIROps.h  |  33 +-
 include/flang/optimizer/Dialect/FIROps.td | 413 +++++++++++++++-------
 include/flang/optimizer/Dialect/FIRType.h |  12 +-
 lib/Lower/PFTBuilder.cpp                  | 193 +++++-----
 lib/lower/ConvertExpr.cpp                 |   4 +-
 lib/optimizer/CodeGen.cpp                 |  94 +++--
 lib/optimizer/Dialect/FIRDialect.cpp      |   2 +-
 lib/optimizer/Dialect/FIROps.cpp          |  70 +---
 lib/optimizer/Dialect/FIRType.cpp         |  27 +-
 lib/optimizer/Support/InternalNames.cpp   |   2 +-
 lib/optimizer/Transforms/MemToReg.cpp     |  10 +-
 test-lit/fir/fir-ops.fir                  |  11 +-
 test-lit/fir/global.fir                   |   9 +-
 tools/bbc/CMakeLists.txt                  |  19 +-
 tools/bbc/bbc.cpp                         |   8 +-
 tools/tco/tco.cpp                         |   2 +-
 17 files changed, 534 insertions(+), 419 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 1d774d24fe2c..c30fb4583a56 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -22,7 +22,7 @@ class raw_ostream;
 }
 
 namespace Fortran::lower {
-namespace PFT {
+namespace pft {
 
 struct Evaluation;
 struct Program;
@@ -138,6 +138,7 @@ struct Evaluation {
   /// Hide non-nullable pointers to the parse-tree node.
   template <typename A>
   using MakeRefType = const A *const;
+
   using EvalVariant =
       common::CombineVariants<common::MapTemplate<MakeRefType, EvalTuple>,
                               std::variant<CGJump>>;
@@ -149,22 +150,22 @@ struct Evaluation {
                       },
                       u);
   }
+  
   template <typename A>
   constexpr const A *getIf() const {
     if constexpr (!std::is_same_v<A, CGJump>) {
-      if (auto *ptr{std::get_if<MakeRefType<A>>(&u)}) {
+      if (auto *ptr{std::get_if<MakeRefType<A>>(&u)})
         return *ptr;
-      }
     } else {
       return std::get_if<CGJump>(&u);
     }
     return nullptr;
   }
+  
   template <typename A>
   constexpr bool isA() const {
-    if constexpr (!std::is_same_v<A, CGJump>) {
+    if constexpr (!std::is_same_v<A, CGJump>)
       return std::holds_alternative<MakeRefType<A>>(u);
-    }
     return std::holds_alternative<CGJump>(u);
   }
 
@@ -185,25 +186,30 @@ struct Evaluation {
   /// Construct ctor
   template <typename A>
   Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
-    static_assert(PFT::isConstruct<A>, "must be a construct");
+    static_assert(pft::isConstruct<A>, "must be a construct");
   }
 
   constexpr bool isActionOrGenerated() const {
     return visit(common::visitors{
         [](auto &r) {
           using T = std::decay_t<decltype(r)>;
-          return isActionStmt<T> || isGenerated<T>;
+          return pft::isActionStmt<T> || isGenerated<T>;
         },
     });
   }
 
+  constexpr bool isActionStmt() const {
+    return visit(common::visitors{
+        [](auto &r) { return pft::isActionStmt<std::decay_t<decltype(r)>>; }});
+  }
+
   constexpr bool isStmt() const {
     return visit(common::visitors{
         [](auto &r) {
           using T = std::decay_t<decltype(r)>;
-          static constexpr bool isStmt{isActionStmt<T> || isOtherStmt<T> ||
+          static constexpr bool isStmt{pft::isActionStmt<T> || isOtherStmt<T> ||
                                        isConstructStmt<T>};
-          static_assert(!(isStmt && PFT::isConstruct<T>),
+          static_assert(!(isStmt && pft::isConstruct<T>),
                         "statement classification is inconsistent");
           return isStmt;
         },
@@ -229,12 +235,10 @@ struct Evaluation {
 
   EvaluationCollection *getConstructEvals() {
     auto *evals{subs.get()};
-    if (isStmt() && !evals) {
+    if (isStmt() && !evals)
       return nullptr;
-    }
-    if (isConstruct() && evals) {
+    if (isConstruct() && evals)
       return evals;
-    }
     llvm_unreachable("evaluation subs is inconsistent");
     return nullptr;
   }
@@ -357,7 +361,7 @@ struct BlockDataUnit : public ProgramUnit {
   BlockDataUnit(const BlockDataUnit &) = delete;
 };
 
-/// A Program is the top-level PFT
+/// A Program is the top-level root of the PFT.
 struct Program {
   using Units = std::variant<FunctionLikeUnit, ModuleLikeUnit, BlockDataUnit>;
 
@@ -367,11 +371,14 @@ struct Program {
 
   std::list<Units> &getUnits() { return units; }
 
+  /// LLVM dump method on a Program.
+  void dump();
+
 private:
   std::list<Units> units;
 };
 
-} // namespace PFT
+} // namespace pft
 
 /// Create an PFT from the parse tree.
 ///
@@ -385,15 +392,16 @@ struct Program {
 /// units.  Function like units will contain lists of evaluations.  Evaluations
 /// are either statements or constructs, where a construct contains a list of
 /// evaluations. The resulting PFT structure can then be used to create FIR.
-std::unique_ptr<PFT::Program> createPFT(const parser::Program &root);
+std::unique_ptr<pft::Program> createPFT(const parser::Program &root);
 
 /// Decorate the PFT with control flow annotations
 ///
 /// The PFT must be decorated with control-flow annotations to prepare it for
 /// use in generating a CFG-like structure.
-void annotateControl(PFT::Program &);
+void annotateControl(pft::Program &pft);
 
-void dumpPFT(llvm::raw_ostream &o, PFT::Program &);
+/// Dumper for displaying a PFT structure.
+void dumpPFT(llvm::raw_ostream &o, pft::Program &pft);
 
 } // namespace Fortran::lower
 
diff --git a/include/flang/optimizer/Dialect/FIROps.h b/include/flang/optimizer/Dialect/FIROps.h
index 9c09406ab7a0..1ae5a3532cf1 100644
--- a/include/flang/optimizer/Dialect/FIROps.h
+++ b/include/flang/optimizer/Dialect/FIROps.h
@@ -50,35 +50,8 @@ enum class CmpFPredicate {
   NumPredicates
 };
 
-/// `fir.dispatch_table` is an untyped symbol that is a list of associations
-/// between method identifiers and a FuncOp symbol.
-class DispatchTableOp
-    : public mlir::Op<DispatchTableOp, OpTrait::ZeroOperands,
-                      OpTrait::ZeroResult, OpTrait::IsIsolatedFromAbove,
-                      OpTrait::SingleBlockImplicitTerminator<FirEndOp>::Impl> {
-public:
-  using Op::Op;
-
-  static llvm::StringRef getOperationName() { return "fir.dispatch_table"; }
-
-  static void build(mlir::Builder *builder, OperationState *result,
-                    llvm::StringRef name, mlir::Type type,
-                    llvm::ArrayRef<NamedAttribute> attrs);
-
-  /// Operation hooks.
-  static ParseResult parse(OpAsmParser &parser, OperationState &result);
-  void print(OpAsmPrinter &p);
-  LogicalResult verify();
-
-  void appendTableEntry(mlir::Operation *op);
-
-private:
-  mlir::Region &front();
-};
-
-ParseResult isValidCaseAttr(mlir::Attribute attr);
-unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
-                               unsigned dest);
+ParseResult isValidCaseAttr(Attribute attr);
+unsigned getCaseArgumentOffset(ArrayRef<Attribute> cases, unsigned dest);
 ParseResult parseSelector(OpAsmParser *parser, OperationState *result,
                           OpAsmParser::OperandType &selector, mlir::Type &type);
 
@@ -92,7 +65,7 @@ ParseResult parseCmpcOp(OpAsmParser &parser, OperationState &result);
 #define GET_OP_CLASSES
 #include "flang/optimizer/Dialect/FIROps.h.inc"
 
-LoopOp getForInductionVarOwner(mlir::Value val);
+LoopOp getForInductionVarOwner(Value val);
 
 bool isReferenceLike(mlir::Type type);
 
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index 40bcbb55d453..8e9e16280b9d 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -22,9 +22,12 @@ def fir_Dialect : Dialect {
   let name = "fir";
 }
 
+// Types and predicates
+
 def fir_Type : Type<CPred<"fir::isa_fir_or_std_type($_self)">,
     "FIR dialect type">;
 
+// Fortran intrinsic types
 def fir_CharacterType : Type<CPred<"$_self.isa<fir::CharacterType>()">,
     "FIR character type">;
 def fir_ComplexType : Type<CPred<"$_self.isa<fir::CplxType>()">,
@@ -36,6 +39,7 @@ def fir_LogicalType : Type<CPred<"$_self.isa<fir::LogicalType>()">,
 def fir_RealType : Type<CPred<"$_self.isa<fir::RealType>()">,
     "FIR real type">;
 
+// Generalized FIR and standard dialect types representing intrinsic types
 def AnyIntegerLike : TypeConstraint<Or<[IntegerLike.predicate,
     fir_IntegerType.predicate]>, "any integer">;
 def AnyLogicalLike : TypeConstraint<Or<[BoolLike.predicate,
@@ -44,28 +48,43 @@ def AnyRealLike : TypeConstraint<Or<[FloatLike.predicate,
     fir_RealType.predicate]>, "any real">;
 def AnyIntegerType : Type<AnyIntegerLike.predicate, "any integer">;
 
+// Fortran derived (user defined) type
 def fir_RecordType : Type<CPred<"$_self.isa<fir::RecordType>()">,
     "FIR derived type">;
+
+// Fortran array attribute
 def fir_SequenceType : Type<CPred<"$_self.isa<fir::SequenceType>()">,
     "array type">;
 
+// Composable types
 def AnyCompositeLike : TypeConstraint<Or<[fir_RecordType.predicate,
     fir_SequenceType.predicate, fir_ComplexType.predicate,
     IsTupleTypePred]>, "any composite">;
 
+// Reference to an entity type
 def fir_ReferenceType : Type<CPred<"$_self.isa<fir::ReferenceType>()">,
     "reference type">;
+
+// Reference to an ALLOCATABLE attribute type
 def fir_HeapType : Type<CPred<"$_self.isa<fir::HeapType>()">,
     "allocatable type">;
+
+// Reference to a POINTER attribute type
 def fir_PointerType : Type<CPred<"$_self.isa<fir::PointerType>()">,
     "pointer type">;
 
+// Reference types
 def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
 
+// A descriptor tuple (captures a reference to an entity and other information)
 def fir_BoxType : Type<CPred<"$_self.isa<fir::BoxType>()">, "box type">;
+
+// CHARACTER type descriptor. A pair of a data reference and a LEN value.
 def fir_BoxCharType : Type<CPred<"$_self.isa<fir::BoxCharType>()">,
     "box character type">;
+
+// PROCEDURE POINTER descriptor. A pair that can capture a host closure.
 def fir_BoxProcType : Type<CPred<"$_self.isa<fir::BoxProcType>()">,
     "box procedure type">;
 
@@ -76,15 +95,21 @@ def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate, fir_BoxType.predicate]>,
     "any reference or box">;
 
+// A vector of Fortran triple notation describing a multidimensional array
 def fir_DimsType : Type<CPred<"$_self.isa<fir::DimsType>()">, "dim type">;
 def AnyEmboxLike : TypeConstraint<Or<[AnyInteger.predicate,
     Index.predicate, fir_IntegerType.predicate, fir_DimsType.predicate]>,
     "any legal embox argument type">;
 def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;
 
+// A type descriptor's type
 def fir_TypeDescType : Type<CPred<"$_self.isa<fir::TypeDescType>()">,
     "type desc type">;
+
+// A field (in a RecordType) argument's type
 def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
+
+// A LEN parameter (in a RecordType) argument's type
 def fir_LenType : Type<CPred<"$_self.isa<fir::LenType>()">,
     "LEN parameter type">;
 
@@ -188,7 +213,7 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
     llvm::SmallVector<mlir::Type, 8> typeVec;
     bool hasOperands = false;
     if (!parser.parseOptionalLParen()) {
-      // parse the LEN params of the derived type. (<params> : <types)
+      // parse the LEN params of the derived type. (<params> : <types>)
       if (parser.parseOperandList(operands,
                                   mlir::OpAsmParser::Delimiter::None) ||
           parser.parseColonTypeList(typeVec) ||
@@ -282,7 +307,6 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
 
 def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
   let summary = "allocate storage for a temporary on the stack given a type";
-
   let description = [{
     This primitive operation is used to allocate an object on the stack.  A
     reference to the object of type `!fir.ref<T>` is returned.  The returned
@@ -311,7 +335,6 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
 def fir_LoadOp : fir_OneResultOp<"load", []>,
     Arguments<(ins AnyReferenceLike:$memref)> {
   let summary = "load a value from a memory reference";
-
   let description = [{
     Load a value from a memory reference into a virtual register.  Produces
     an immutable ssa-value of the referent type.
@@ -367,6 +390,12 @@ def fir_StoreOp : fir_Op<"store", []>,
     reference.
   }];
 
+  let verifier = [{
+    if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
+      return emitOpError("store value type must match memory reference type");
+    return mlir::success();
+  }];
+
   let parser = [{
     mlir::Type type;
     mlir::OpAsmParser::OperandType oper;
@@ -392,12 +421,6 @@ def fir_StoreOp : fir_Op<"store", []>,
     p << " : " << memref().getType();
   }];
 
-  let verifier = [{
-    if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
-      return emitOpError("store value type must match memory reference type");
-    return mlir::success();
-  }];
-
   let extraClassDeclaration = [{
     static mlir::Type elementType(mlir::Type refType);
   }];
@@ -405,13 +428,18 @@ def fir_StoreOp : fir_Op<"store", []>,
 
 def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   let summary = "explicit undefined value of some type";
-
   let description = [{
     Constructs an ssa-value of the specified type with an undefined value.
     This operation is typically created internally by the mem2reg conversion
     pass.
   }];
 
+  let verifier = [{
+    if (auto ref = getType().dyn_cast<fir::ReferenceType>())
+      return emitOpError("undefined values of type !fir.ref not allowed");
+    return mlir::success();
+  }];
+
   let parser = [{
     mlir::Type intype;
     if (parser.parseType(intype) ||
@@ -421,12 +449,6 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   }];
 
   let printer = [{ p << getOperationName() << ' ' << getType(); }];
-
-  let verifier = [{
-    if (auto ref = getType().dyn_cast<fir::ReferenceType>())
-      return emitOpError("undefined values of type !fir.ref not allowed");
-    return mlir::success();
-  }];
 }
 
 def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
@@ -842,6 +864,17 @@ def fir_FirEndOp : fir_Op<"end", [Terminator]> {
   }];
 }
 
+def fir_HasValueOp : fir_Op<"has_value", [Terminator, HasParent<"GlobalOp">]> {
+  let summary = "terminator for GlobalOp";
+  let description = [{
+    The terminator for a GlobalOp with a body.
+  }];
+
+  let arguments = (ins AnyType:$resval);
+
+  let assemblyFormat = "$resval attr-dict `:` type($resval)";
+}
+
 // Operations on !fir.box<T> type objects
 
 def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
@@ -1519,20 +1552,21 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     Index:$lowerBound,
     Index:$upperBound,
     Variadic<Index>:$optStep,
-    OptionalAttr<I32Attr>:$constantStep,
+    OptionalAttr<I64Attr>:$constantStep,
     OptionalAttr<UnitAttr>:$unordered
   );
 
   let results = (outs Variadic<Index>:$lastVal);
 
   let regions = (region SizedRegion<1>:$region);
+
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
               "int64_t lowerBound, int64_t upperBound, int64_t step = 1">,
-    OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
               "mlir::Value lowerBound, mlir::Value upperBound,"
-              "llvm::ArrayRef<mlir::Value> step">
+              "ArrayRef<mlir::Value> step = {}">
   ];
 
   let parser = "return parseLoopOp(parser, result);";
@@ -1548,7 +1582,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     if (unordered())
       p << " unordered";
     p.printRegion(region(), /*printEntryBlockArgs=*/false,
-        /*printBlockTerminators=*/false);
+                            /*printBlockTerminators=*/false);
     p.printOptionalAttrDict(getAttrs(), {unorderedKeyword(), stepKeyword()});
   }];
 
@@ -1578,8 +1612,10 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     static constexpr const char *unorderedKeyword() { return "unordered"; }
     static constexpr const char *stepKeyword() { return "step"; }
 
+    /// Is this an unordered loop?
     bool isUnordered() { return getAttr(unorderedKeyword()).isa<UnitAttr>(); }
 
+    /// Does loop set (and return) the final value of the control variable?
     bool hasLastValue() { return lastVal().size(); }
 
     /// Get the body of the loop
@@ -1588,6 +1624,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     /// Get the block argument corresponding to the loop control value (PHI)
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
 
+    /// Get a builder to insert operations into the LoopOp
     mlir::OpBuilder getBodyBuilder() {
       return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
     }
@@ -1772,10 +1809,12 @@ def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
     mlir::Type type;
     if (parser.parseLParen() ||
         parser.parseAttribute(sz, size(), result.attributes) ||
-        parser.parseRParen() || parser.parseColonType(type))
+        parser.parseRParen() ||
+        parser.parseColonType(type))
       return mlir::failure();
     type = fir::SequenceType::get({sz.getInt()}, type);
-    if (parser.addTypesToList(type, result.types))
+    if (!type ||
+        parser.addTypesToList(type, result.types))
       return mlir::failure();
     return mlir::success();
   }];
@@ -1790,7 +1829,7 @@ def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
     if (getSize().cast<mlir::IntegerAttr>().getValue().isNegative())
       return emitOpError("size must be non-negative");
     auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
-    if (!eleTy.dyn_cast<fir::CharacterType>())
+    if (!eleTy.isa<fir::CharacterType>())
       return emitOpError("must have !fir.char type");
     if (auto xl = getAttr(xlist())) {
       auto xList = xl.cast<mlir::ArrayAttr>();
@@ -2036,7 +2075,6 @@ def fir_CmpcOp : fir_Op<"cmpc",
 
 def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
   let summary = "convert a symbol to an SSA value";
-
   let description = [{
     Convert a symbol (a function or global reference) to an SSA-value to be
     used in other Operations.
@@ -2065,13 +2103,13 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
 }
 
 def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
-  let arguments = (ins AnyType:$value);
   let summary = "encapsulates all Fortran scalar type conversions";
-
   let description = [{
     Generalized type conversion. Not all pairs of types have conversions.
   }];
 
+  let arguments = (ins AnyType:$value);
+
   let assemblyFormat = [{
     $value attr-dict `:` functional-type($value, results)
   }];
@@ -2090,16 +2128,31 @@ def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
   let convertFromStorage = "$_self.getValue().cast<Type>()";
 }
 
-def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]>,
-  Arguments<(ins FortranTypeAttr:$in_type)> {
+def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
   let summary = "generate a type descriptor for a given type";
-
   let description = [{
     Generates a constant object that is an abstract type descriptor of the
     specified type.  The meta-type of a type descriptor for the type `T`
     is `!fir.tdesc<T>`.
   }];
 
+  let arguments = (ins FortranTypeAttr:$in_type);
+
+  let verifier = [{
+    mlir::Type resultTy = getType();
+    if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
+      if (tdesc.getOfTy() != getInType())
+        return emitOpError("wrapped type mismatched");
+    } else {
+      return emitOpError("must be !fir.tdesc type");
+    }
+    return mlir::success();
+  }];
+
+  let builders = [
+    OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty">
+  ];
+
   let parser = [{
     mlir::Type intype;
     if (parser.parseType(intype))
@@ -2111,26 +2164,11 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]>,
     return mlir::success();
   }];
 
-  let builders = [
-    OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty">
-  ];
-
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
     p.printOptionalAttrDict(getAttrs(), {"in_type"});
   }];
 
-  let verifier = [{
-    mlir::Type resultTy = getType();
-    if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
-      if (tdesc.getOfTy() != getInType())
-        return emitOpError("wrapped type mismatched");
-    } else {
-      return emitOpError("must be !fir.tdesc type");
-    }
-    return mlir::success();
-  }];
-
   let extraClassDeclaration = [{
     mlir::Type getInType() {
       // get the type that the type descriptor describes
@@ -2141,26 +2179,62 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]>,
 
 def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
     [SameOperandsAndResultType]> {
-  let arguments = (ins AnyType:$val);
   let summary = "synthetic op to prevent reassociation";
-
   let description = [{
-    The operation is to make sure that the Fortran optimizer does not
-    reassociate operations when they are syntactically surrounded by
-    parenthesis.
+    Primitive operation meant to intrusively prevent operator reassociation.
+    The operation is otherwise a nop and the value returned is the same as the
+    argument.
+
+    The presence of this operation prevents any local optimizations. In the
+    example below, this would prevent possibly replacing the multiply and add
+    operations with a single FMA operation.
+
+      %98 = mulf %96, %97 : f32
+      %99 = fir.no_reassoc %98 : f32
+      %a0 = addf %99, %95 : f32
   }];
 
+  let arguments = (ins AnyType:$val);
+
   let assemblyFormat = "$val attr-dict `:` type($val)";
 }
 
-def fir_GlobalOp :
-    fir_Op<"global", [IsolatedFromAbove, Symbol, ImplicitFirTerminator]> {
-  let summary = "Global data";
+class AtMostRegion<int numBlocks> : Region<
+  CPred<"$_self.getBlocks().size() <= " # numBlocks>,
+  "region with " # numBlocks # " blocks">;
 
+def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
+  let summary = "Global data";
   let description = [{
-    Global data object. FIXME
+    A global variable or constant with initial values.
+
+    The example creates a global variable (writable) named
+    `@_QV_Mquark_Vvarble` with some initial values. The initializer should
+    conform to the variable's type.
+
+      fir.global @_QV_Mquark_Vvarble : tuple<i32, f32> {
+        %1 = constant 1 : i32
+        %2 = constant 2.0 : f32
+        %3 = fir.undefined tuple<i32, f32>
+        %z = constant 0 : index
+        %o = constant 1 : index
+        %4 = fir.insert_value %3, %1, %z : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
+        %5 = fir.insert_value %4, %1, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
+        return %5
+      }
   }];
 
+  let arguments = (ins
+    StrAttr:$sym_name,
+    OptionalAttr<AnyAttr>:$initval,
+    UnitAttr:$constant,
+    TypeAttr:$type
+  );
+
+  let results = (outs fir_ReferenceType:$resultType);
+
+  let regions = (region AtMostRegion<1>:$region);
+
   let parser = [{
     // Parse the name as a symbol reference attribute.
     SymbolRefAttr nameAttr;
@@ -2172,56 +2246,63 @@ def fir_GlobalOp :
     auto name = nameAttr.getRootReference();
     result.attributes.back().second = builder.getStringAttr(name);
 
-    if (!parser.parseOptionalKeyword(getConstantName())) {
+    bool simpleInitializer = false;
+    if (!parser.parseOptionalLParen()) {
+      Attribute attr;
+      if (parser.parseAttribute(attr, initValAttrName(), result.attributes) ||
+          parser.parseRParen())
+        return failure();
+      simpleInitializer = true;
+    }
+
+    if (!parser.parseOptionalKeyword(constantAttrName())) {
       // if "constant" keyword then mark this as a constant, not a variable
-      result.addAttribute(getConstantName(), builder.getUnitAttr());
+      result.addAttribute(constantAttrName(), builder.getUnitAttr());
     }
 
     mlir::Type globalType;
     if (parser.parseColonType(globalType))
-      return mlir::failure();
+      return failure();
 
-    result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(globalType));
+    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(globalType));
 
-    // Parse the optional initializer body.
-    mlir::Region *body = result.addRegion();
-    if (parser.parseOptionalRegion(
-          *body, llvm::ArrayRef<mlir::OpAsmParser::OperandType>{},
-          llvm::ArrayRef<mlir::Type>{}))
-      return mlir::failure();
+    if (!simpleInitializer) {
+      // Parse the optional initializer body.
+      if (parser.parseRegion(*result.addRegion(), llvm::None, llvm::None))
+        return failure();
+    }
 
-    ensureTerminator(*body, builder, result.location);
-    return mlir::success();
+    auto refTy = AllocaOp::wrapResultType(globalType);
+    if (parser.addTypeToList(refTy, result.types))
+      return failure();
+    return success();
   }];
 
   let printer = [{
     auto varName = getAttrOfType<StringAttr>(
       mlir::SymbolTable::getSymbolAttrName()).getValue();
     p << getOperationName() << " @" << varName;
-    if (getAttr(getConstantName()))
-      p << ' ' << getConstantName();
+    if (auto iv = initval().getValueOr(Attribute())) {
+      p << '(';
+      p.printAttribute(iv);
+      p << ')';
+    }
+    if (getAttr(constantAttrName()))
+      p << ' ' << constantAttrName();
     p << " : ";
     p.printType(getType());
     Region &body = getOperation()->getRegion(0);
     if (!body.empty())
       p.printRegion(body, /*printEntryBlockArgs=*/false,
-                    /*printBlockTerminators=*/false);
-  }];
-
-  let verifier = [{
-    // FIXME
-    return mlir::success();
+                          /*printBlockTerminators=*/true);
   }];
 
-  let regions = (region SizedRegion<1>:$region);
-
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"mlir::Builder *builder, mlir::OperationState &result,"
-              "llvm::StringRef name, mlir::Type type,"
-              "llvm::ArrayRef<NamedAttribute> attrs = {}",
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
     [{
-      result.addAttribute(getTypeAttrName(), mlir::TypeAttr::get(type));
+      result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
       result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                           builder->getStringAttr(name));
       for (const auto &pair : attrs)
@@ -2230,69 +2311,151 @@ def fir_GlobalOp :
   ];
 
   let extraClassDeclaration = [{
-    static constexpr llvm::StringRef getConstantName() { return "constant"; }
-    static constexpr llvm::StringRef getTypeAttrName() { return "type"; }
-
-    GlobalOp create(mlir::Location location, llvm::StringRef name,
-                    mlir::Type type, llvm::ArrayRef<NamedAttribute> attrs);
+    static constexpr llvm::StringRef constantAttrName() { return "constant"; }
+    static constexpr llvm::StringRef initValAttrName() { return "initval"; }
+    static constexpr llvm::StringRef typeAttrName() { return "type"; }
 
     mlir::Type getType() {
-      return getAttrOfType<TypeAttr>(getTypeAttrName()).getValue();
+      return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
 
+    /// Append the next initializer value to the `GlobalOp` to construct
+    /// the variable's initial value.
     void appendInitialValue(mlir::Operation *op);
 
-    mlir::Region &front() {
-      return getOperation()->getRegion(0);
-    }
+    /// A GlobalOp has one region.
+    mlir::Region &getRegion() { return getOperation()->getRegion(0); }
+
+    /// A GlobalOp has one block.
+    mlir::Block &getBlock() { return getRegion().front(); }
   }];
 }
 
-def fir_GlobalEntryOp : fir_Op<"global_entry", []> {
-
-  let summary = "map a field entry in a global";
-
+def fir_GlobalLenOp : fir_Op<"global_len", []> {
+  let summary = "map a LEN parameter to a global";
   let description = [{
-    An entry in a global.  Allows a constant to be bound to a specific
-    field in a record even though the layout of the record has not yet
-    been reified.  This may be necessary if the object layout decisions
-    are deferred to, for example, runtime by the implementation.
+    A global entity (that is not an automatic data object) can have extra LEN
+    parameter (compile-time) constants associated with the instance's type.
+    These values can be bound to the global instance used `fir.global_len`.
+
+      global @g : !fir.type<t(len1:i32)> {
+        fir.global_len len1, 10 : i32
+        %1 = fir.undefined : !fir.type<t(len1:i32)>
+        return %1 : !fir.type<t(len1:i32)>
+      }
   }];
 
-  let arguments = (ins StrAttr:$field, AnyType:$constant);
+  let arguments = (ins StrAttr:$lenparam, APIntAttr:$intval);
 
   let parser = [{
-    mlir::Type type;
-    mlir::OpAsmParser::OperandType constant;
     llvm::StringRef fieldName;
     if (parser.parseOptionalKeyword(&fieldName)) {
       mlir::StringAttr fieldAttr;
-      if (parser.parseAttribute(fieldAttr, "field", result.attributes))
+      if (parser.parseAttribute(fieldAttr, lenParamAttrName(),
+                                result.attributes))
         return mlir::failure();
     } else {
-      result.addAttribute("field",
+      result.addAttribute(lenParamAttrName(),
           parser.getBuilder().getStringAttr(fieldName));
     }
+    mlir::IntegerAttr constant;
     if (parser.parseComma() ||
-        parser.parseOperand(constant) ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperand(constant, type, result.operands))
+        parser.parseAttribute(constant, intAttrName(), result.attributes))
       return mlir::failure();
-    result.addAttribute("in_type", mlir::TypeAttr::get(type));
     return mlir::success();
   }];
 
   let printer = [{
-    p << getOperationName() << ' ' << getAttr("field") << ", ";
-    p.printOperand(constant());
-    p.printOptionalAttrDict(getAttrs(), {"in_type", "field"});
-    p << " : " << getAttr("in_type");
+    p << getOperationName() << ' ' << getAttr(lenParamAttrName()) << ", "
+      << getAttr(intAttrName());
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef lenParamAttrName() { return "lenparam"; }
+    static constexpr llvm::StringRef intAttrName() { return "intval"; }
   }];
 }
 
-def fir_DTEntryOp : fir_Op<"dt_entry", []>,
-    Arguments<(ins StrAttr:$method, SymbolRefAttr:$proc)> {
+def fir_DispatchTableOp : fir_Op<"dispatch_table", [IsolatedFromAbove, Symbol,
+                                 ImplicitFirTerminator]> {
+  let summary = "Dispatch table definition";
+
+  let description = [{
+    Define a dispatch table for a derived type with type-bound procedures.
+
+    A dispatch table is an untyped symbol that contains a list of associations
+    between method identifiers and corresponding `FuncOp` symbols.
+
+    The ordering of associations in the map is determined by the front-end.
+  }];
+
+  let parser = [{
+    // Parse the name as a symbol reference attribute.
+    SymbolRefAttr nameAttr;
+    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
+                              result.attributes))
+      return failure();
+
+    // Convert the parsed name attr into a string attr.
+    result.attributes.back().second =
+        parser.getBuilder().getStringAttr(nameAttr.getRootReference());
+
+    // Parse the optional table body.
+    mlir::Region *body = result.addRegion();
+    if (parser.parseOptionalRegion(*body, llvm::None, llvm::None))
+      return mlir::failure();
+
+    ensureTerminator(*body, parser.getBuilder(), result.location);
+    return mlir::success();
+  }];
+
+  let printer = [{
+    auto tableName = getAttrOfType<StringAttr>(
+      mlir::SymbolTable::getSymbolAttrName()).getValue();
+    p << getOperationName() << " @" << tableName;
+
+    Region &body = getOperation()->getRegion(0);
+    if (!body.empty())
+      p.printRegion(body, /*printEntryBlockArgs=*/false,
+                          /*printBlockTerminators=*/false);
+  }];
+
+  let verifier = [{
+    for (auto &op : getBlock())
+      if (!(isa<fir::DTEntryOp>(op) || isa<fir::FirEndOp>(op)))
+        return emitOpError("dispatch table must contain dt_entry");
+    return mlir::success();
+  }];
+
+  let regions = (region SizedRegion<1>:$region);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, OperationState *result,"
+              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
+    [{
+      result->addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                           builder->getStringAttr(name));
+      for (const auto &pair : attrs)
+        result->addAttribute(pair.first, pair.second);
+    }]>
+  ];
+
+  let extraClassDeclaration = [{
+    /// Append a dispatch table entry to the table.
+    void appendTableEntry(mlir::Operation *op);
+
+    mlir::Region &getRegion() {
+      return this->getOperation()->getRegion(0);
+    }
+
+    mlir::Block &getBlock() {
+      return getRegion().front();
+    }
+  }];
+}
+
+def fir_DTEntryOp : fir_Op<"dt_entry", []> {
   let summary = "map entry in a dispatch table";
 
   let description = [{
@@ -2301,27 +2464,39 @@ def fir_DTEntryOp : fir_Op<"dt_entry", []>,
     type of a distinguished argument to determine an exact dispatch table
     and uses the method identifier to select the type-bound procedure to
     be called.
+
+      fir.entry method_name, @uniquedProcedure
   }];
 
+  let arguments = (ins StrAttr:$method, SymbolRefAttr:$proc);
+
   let parser = [{
-    mlir::SymbolRefAttr calleeAttr;
     llvm::StringRef methodName;
+    // allow `methodName` or `"methodName"`
     if (parser.parseOptionalKeyword(&methodName)) {
       mlir::StringAttr methodAttr;
-      if (parser.parseAttribute(methodAttr, "method", result.attributes))
+      if (parser.parseAttribute(methodAttr, methodAttrName(),
+                                result.attributes))
         return mlir::failure();
     } else {
-      result.addAttribute("method",
+      result.addAttribute(methodAttrName(),
           parser.getBuilder().getStringAttr(methodName));
     }
+    mlir::SymbolRefAttr calleeAttr;
     if (parser.parseComma() ||
-        parser.parseAttribute(calleeAttr, "proc", result.attributes))
+        parser.parseAttribute(calleeAttr, procAttrName(), result.attributes))
       return mlir::failure();
     return mlir::success();
   }];
+
   let printer = [{
-    p << getOperationName() << ' ' << getAttr("method") << ", "
-      << getAttr("proc");
+    p << getOperationName() << ' ' << getAttr(methodAttrName()) << ", "
+      << getAttr(procAttrName());
+  }];
+
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef methodAttrName() { return "method"; }
+    static constexpr llvm::StringRef procAttrName() { return "proc"; }
   }];
 }
 
diff --git a/include/flang/optimizer/Dialect/FIRType.h b/include/flang/optimizer/Dialect/FIRType.h
index 2da2bafc37d2..8dfc66c8346a 100644
--- a/include/flang/optimizer/Dialect/FIRType.h
+++ b/include/flang/optimizer/Dialect/FIRType.h
@@ -75,10 +75,20 @@ enum TypeKind {
   FIR_TYPEDESC,
 };
 
+/// Is `t` any of the FIR dialect types?
 bool isa_fir_type(mlir::Type t);
+
+/// Is `t` any of the Standard dialect types?
 bool isa_std_type(mlir::Type t);
+
+/// Is `t` any of the FIR dialect or Standard dialect types?
 bool isa_fir_or_std_type(mlir::Type t);
-bool isa_memref(mlir::Type t);
+
+/// Is `t` a FIR dialect type that implies a memory (de)reference?
+bool isaMemref(mlir::Type t);
+
+/// Is `t` a FIR dialect aggregate type?
+bool isanAggregate(mlir::Type t);
 
 /// Extract the `Type` pointed to from a FIR memory reference type. If `t` is
 /// not a memory reference type, then returns a null `Type`.
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 676e1b92e085..4d5ad251b3f0 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -17,8 +17,8 @@
 namespace Fortran::lower {
 namespace {
 
-/// Helpers to unveil parser node inside parser::Statement<>,
-/// parser::UnlabeledStatement, and common::Indirection<>
+/// Helpers to unveil parser node inside Fortran::parser::Statement<>,
+/// Fortran::parser::UnlabeledStatement, and Fortran::common::Indirection<>
 template <typename A>
 struct RemoveIndirectionHelper {
   using Type = A;
@@ -68,17 +68,17 @@ struct UnwrapStmt<parser::UnlabeledStatement<A>> {
 /// the bridge to one such instantiation.
 class PFTBuilder {
 public:
-  PFTBuilder() : pgm{new PFT::Program}, parents{*pgm.get()} {}
+  PFTBuilder() : pgm{new pft::Program}, parents{*pgm.get()} {}
 
   /// Get the result
-  std::unique_ptr<PFT::Program> result() { return std::move(pgm); }
+  std::unique_ptr<pft::Program> result() { return std::move(pgm); }
 
   template <typename A>
   constexpr bool Pre(const A &a) {
     bool visit{true};
-    if constexpr (PFT::isFunctionLike<A>) {
+    if constexpr (pft::isFunctionLike<A>) {
       return enterFunc(a);
-    } else if constexpr (PFT::isConstruct<A>) {
+    } else if constexpr (pft::isConstruct<A>) {
       return enterConstruct(a);
     } else if constexpr (UnwrapStmt<A>::isStmt) {
       using T = typename UnwrapStmt<A>::Type;
@@ -86,8 +86,8 @@ class PFTBuilder {
       // Statement<T>, Statement<Indirection<T>, UnlabeledStatement<T>,
       // or UnlabeledStatement<Indirection<T>>
       auto stmt{UnwrapStmt<A>(a)};
-      if constexpr (PFT::isConstructStmt<T> || PFT::isOtherStmt<T>) {
-        addEval(PFT::Evaluation{stmt.unwrapped, parents.back(), stmt.pos,
+      if constexpr (pft::isConstructStmt<T> || pft::isOtherStmt<T>) {
+        addEval(pft::Evaluation{stmt.unwrapped, parents.back(), stmt.pos,
                                 stmt.lab});
         visit = false;
       } else if constexpr (std::is_same_v<T, parser::ActionStmt>) {
@@ -100,9 +100,9 @@ class PFTBuilder {
 
   template <typename A>
   constexpr void Post(const A &) {
-    if constexpr (PFT::isFunctionLike<A>) {
+    if constexpr (pft::isFunctionLike<A>) {
       exitFunc();
-    } else if constexpr (PFT::isConstruct<A>) {
+    } else if constexpr (pft::isConstruct<A>) {
       exitConstruct();
     }
   }
@@ -116,7 +116,7 @@ class PFTBuilder {
 
   // Block data
   bool Pre(const parser::BlockData &node) {
-    addUnit(PFT::BlockDataUnit{node, parents.back()});
+    addUnit(pft::BlockDataUnit{node, parents.back()});
     return false;
   }
 
@@ -125,7 +125,7 @@ class PFTBuilder {
                &statement) {
     addEval(std::visit(
         [&](const auto &x) {
-          return PFT::Evaluation{x, parents.back(), statement.source, {}};
+          return pft::Evaluation{x, parents.back(), statement.source, {}};
         },
         statement.statement.u));
     return false;
@@ -133,7 +133,7 @@ class PFTBuilder {
   bool Pre(const parser::Statement<parser::ForallAssignmentStmt> &statement) {
     addEval(std::visit(
         [&](const auto &x) {
-          return PFT::Evaluation{x, parents.back(), statement.source,
+          return pft::Evaluation{x, parents.back(), statement.source,
                                  statement.label};
         },
         statement.statement.u));
@@ -145,7 +145,7 @@ class PFTBuilder {
             [&](const parser::Statement<parser::AssignmentStmt> &stmt) {
               // Not caught as other AssignmentStmt because it is not
               // wrapped in a parser::ActionStmt.
-              addEval(PFT::Evaluation{stmt.statement, parents.back(),
+              addEval(pft::Evaluation{stmt.statement, parents.back(),
                                       stmt.source, stmt.label});
               return false;
             },
@@ -158,13 +158,13 @@ class PFTBuilder {
   // ActionStmt has a couple of non-conforming cases, which get handled
   // explicitly here.  The other cases use an Indirection, which we discard in
   // the PFT.
-  PFT::Evaluation makeEvalAction(const parser::ActionStmt &statement,
+  pft::Evaluation makeEvalAction(const parser::ActionStmt &statement,
                                  parser::CharBlock pos,
                                  std::optional<parser::Label> lab) {
     return std::visit(
         common::visitors{
             [&](const auto &x) {
-              return PFT::Evaluation{removeIndirection(x), parents.back(), pos,
+              return pft::Evaluation{removeIndirection(x), parents.back(), pos,
                                      lab};
             },
         },
@@ -175,7 +175,7 @@ class PFTBuilder {
   // set the builder's cursors to point to it.
   template <typename A>
   bool enterFunc(const A &func) {
-    auto &unit = addFunc(PFT::FunctionLikeUnit{func, parents.back()});
+    auto &unit = addFunc(pft::FunctionLikeUnit{func, parents.back()});
     funclist = &unit.funcs;
     pushEval(&unit.evals);
     parents.emplace_back(unit);
@@ -185,8 +185,8 @@ class PFTBuilder {
   void setFunctListToParentFuncs() {
     if (!parents.empty()) {
       std::visit(common::visitors{
-                     [&](PFT::FunctionLikeUnit *p) { funclist = &p->funcs; },
-                     [&](PFT::ModuleLikeUnit *p) { funclist = &p->funcs; },
+                     [&](pft::FunctionLikeUnit *p) { funclist = &p->funcs; },
+                     [&](pft::ModuleLikeUnit *p) { funclist = &p->funcs; },
                      [&](auto *) { funclist = nullptr; },
                  },
                  parents.back().p);
@@ -203,8 +203,8 @@ class PFTBuilder {
   // set the builder's evaluation cursor to point to it.
   template <typename A>
   bool enterConstruct(const A &construct) {
-    auto &con = addEval(PFT::Evaluation{construct, parents.back()});
-    con.subs.reset(new PFT::EvaluationCollection);
+    auto &con = addEval(pft::Evaluation{construct, parents.back()});
+    con.subs.reset(new pft::EvaluationCollection);
     pushEval(con.subs.get());
     parents.emplace_back(con);
     return true;
@@ -219,7 +219,7 @@ class PFTBuilder {
   // set the builder's function cursor to point to it.
   template <typename A>
   bool enterModule(const A &func) {
-    auto &unit = addUnit(PFT::ModuleLikeUnit{func, parents.back()});
+    auto &unit = addUnit(pft::ModuleLikeUnit{func, parents.back()});
     funclist = &unit.funcs;
     parents.emplace_back(unit);
     return true;
@@ -246,7 +246,7 @@ class PFTBuilder {
   }
 
   /// move the Evaluation to the end of the current list
-  PFT::Evaluation &addEval(PFT::Evaluation &&eval) {
+  pft::Evaluation &addEval(pft::Evaluation &&eval) {
     assert(funclist && "not in a function");
     assert(evallist.size() > 0);
     evallist.back()->emplace_back(std::move(eval));
@@ -254,7 +254,7 @@ class PFTBuilder {
   }
 
   /// push a new list on the stack of Evaluation lists
-  void pushEval(PFT::EvaluationCollection *eval) {
+  void pushEval(pft::EvaluationCollection *eval) {
     assert(funclist && "not in a function");
     assert(eval && eval->empty() && "evaluation list isn't correct");
     evallist.emplace_back(eval);
@@ -266,16 +266,16 @@ class PFTBuilder {
     evallist.pop_back();
   }
 
-  std::unique_ptr<PFT::Program> pgm;
+  std::unique_ptr<pft::Program> pgm;
   /// funclist points to FunctionLikeUnit::funcs list (resp.
   /// ModuleLikeUnit::funcs) when building a FunctionLikeUnit (resp.
   /// ModuleLikeUnit) to store internal procedures (resp. module procedures).
   /// Otherwise (e.g. when building the top level Program), it is null.
-  std::list<PFT::FunctionLikeUnit> *funclist{nullptr};
+  std::list<pft::FunctionLikeUnit> *funclist{nullptr};
   /// evallist is a stack of pointer to FunctionLikeUnit::evals (or
   /// Evaluation::subs) that are being build.
-  std::vector<PFT::EvaluationCollection *> evallist;
-  std::vector<PFT::ParentType> parents;
+  std::vector<pft::EvaluationCollection *> evallist;
+  std::vector<pft::ParentType> parents;
 };
 
 template <typename Label, typename A>
@@ -319,16 +319,16 @@ bool hasAltReturns(const parser::CallStmt &callStmt) {
 ///
 /// \param cstr points to the current construct. It may be null at the top-level
 /// of a FunctionLikeUnit.
-void altRet(PFT::Evaluation &evaluation, const parser::CallStmt &callStmt,
-            PFT::Evaluation *cstr) {
+void altRet(pft::Evaluation &evaluation, const parser::CallStmt &callStmt,
+            pft::Evaluation *cstr) {
   if (hasAltReturns(callStmt))
-    evaluation.setCFG(PFT::CFGAnnotation::Switch, cstr);
+    evaluation.setCFG(pft::CFGAnnotation::Switch, cstr);
 }
 
 /// \param cstr points to the current construct. It may be null at the top-level
 /// of a FunctionLikeUnit.
-void annotateEvalListCFG(PFT::EvaluationCollection &evaluationCollection,
-                         PFT::Evaluation *cstr) {
+void annotateEvalListCFG(pft::EvaluationCollection &evaluationCollection,
+                         pft::Evaluation *cstr) {
   bool nextIsTarget = false;
   for (auto &eval : evaluationCollection) {
     eval.isTarget = nextIsTarget;
@@ -346,84 +346,84 @@ void annotateEvalListCFG(PFT::EvaluationCollection &evaluationCollection,
           altRet(eval, statement, cstr);
         },
         [&](const parser::CycleStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::ExitStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::FailImageStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Terminate, cstr);
+          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
         },
         [&](const parser::GotoStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::IfStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::ReturnStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Return, cstr);
+          eval.setCFG(pft::CFGAnnotation::Return, cstr);
         },
         [&](const parser::StopStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Terminate, cstr);
+          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
         },
         [&](const parser::ArithmeticIfStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::AssignedGotoStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::IndGoto, cstr);
+          eval.setCFG(pft::CFGAnnotation::IndGoto, cstr);
         },
         [&](const parser::ComputedGotoStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::WhereStmt &) {
           // fir.loop + fir.where around the next stmt
           eval.isTarget = true;
-          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
         },
         [&](const parser::ForallStmt &) {
           // fir.loop around the next stmt
           eval.isTarget = true;
-          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
         },
-        [&](PFT::CGJump &) { eval.setCFG(PFT::CFGAnnotation::Goto, cstr); },
+        [&](pft::CGJump &) { eval.setCFG(pft::CFGAnnotation::Goto, cstr); },
         [&](const parser::SelectCaseStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::NonLabelDoStmt &) {
           eval.isTarget = true;
-          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
         },
         [&](const parser::EndDoStmt &) {
           eval.isTarget = true;
-          eval.setCFG(PFT::CFGAnnotation::Goto, cstr);
+          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
         },
         [&](const parser::IfThenStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::ElseIfStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::SelectRankStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::SelectTypeStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::Switch, cstr);
+          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
         },
         [&](const parser::WhereConstruct &) {
           // mark the WHERE as if it were a DO loop
           eval.isTarget = true;
-          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
         },
         [&](const parser::WhereConstructStmt &) {
-          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::MaskedElsewhereStmt &) {
           eval.isTarget = true;
-          eval.setCFG(PFT::CFGAnnotation::CondGoto, cstr);
+          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
         },
         [&](const parser::ForallConstructStmt &) {
           eval.isTarget = true;
-          eval.setCFG(PFT::CFGAnnotation::Iterative, cstr);
+          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
         },
 
         [&](const auto &stmt) {
@@ -452,13 +452,13 @@ void annotateEvalListCFG(PFT::EvaluationCollection &evaluationCollection,
             if (hasLabel<parser::ErrLabel>(stmt) ||
                 hasLabel<parser::EorLabel>(stmt) ||
                 hasLabel<parser::EndLabel>(stmt))
-              eval.setCFG(PFT::CFGAnnotation::IoSwitch, cstr);
+              eval.setCFG(pft::CFGAnnotation::IoSwitch, cstr);
           } else if constexpr (common::HasMember<A, TargetStmts>) {
             eval.isTarget = true;
           } else if constexpr (common::HasMember<A, DoNothingConstructStmts>) {
             // Explicitly do nothing for these construct statements
           } else {
-            static_assert(!PFT::isConstructStmt<A>,
+            static_assert(!pft::isConstructStmt<A>,
                           "All ConstructStmts impact on the control flow "
                           "should be explicitly handled");
           }
@@ -470,7 +470,7 @@ void annotateEvalListCFG(PFT::EvaluationCollection &evaluationCollection,
 
 /// Annotate the PFT with CFG source decorations (see CFGAnnotation) and mark
 /// potential branch targets
-inline void annotateFuncCFG(PFT::FunctionLikeUnit &functionLikeUnit) {
+inline void annotateFuncCFG(pft::FunctionLikeUnit &functionLikeUnit) {
   annotateEvalListCFG(functionLikeUnit.evals, nullptr);
   for (auto &internalFunc : functionLikeUnit.funcs)
     annotateFuncCFG(internalFunc);
@@ -478,18 +478,18 @@ inline void annotateFuncCFG(PFT::FunctionLikeUnit &functionLikeUnit) {
 
 class PFTDumper {
 public:
-  void dumpPFT(llvm::raw_ostream &outputStream, PFT::Program &pft) {
+  void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
     for (auto &unit : pft.getUnits()) {
       std::visit(common::visitors{
-                     [&](PFT::BlockDataUnit &unit) {
+                     [&](pft::BlockDataUnit &unit) {
                        outputStream << getNodeIndex(unit) << " ";
                        outputStream << "BlockData: ";
                        outputStream << "\nEndBlockData\n\n";
                      },
-                     [&](PFT::FunctionLikeUnit &func) {
+                     [&](pft::FunctionLikeUnit &func) {
                        dumpFunctionLikeUnit(outputStream, func);
                      },
-                     [&](PFT::ModuleLikeUnit &unit) {
+                     [&](pft::ModuleLikeUnit &unit) {
                        dumpModuleLikeUnit(outputStream, unit);
                      },
                  },
@@ -498,9 +498,9 @@ class PFTDumper {
     resetIndexes();
   }
 
-  llvm::StringRef evalName(PFT::Evaluation &eval) {
+  llvm::StringRef evalName(pft::Evaluation &eval) {
     return eval.visit(common::visitors{
-        [](const PFT::CGJump) { return "CGJump"; },
+        [](const pft::CGJump) { return "CGJump"; },
         [](const auto &parseTreeNode) {
           return parser::ParseTreeDumper::GetNodeName(parseTreeNode);
         },
@@ -508,11 +508,11 @@ class PFTDumper {
   }
 
   void dumpEvalList(llvm::raw_ostream &outputStream,
-                    PFT::EvaluationCollection &evaluationCollection,
+                    pft::EvaluationCollection &evaluationCollection,
                     int indent = 1) {
     static const std::string white{"                                      ++"};
     std::string indentString{white.substr(0, indent * 2)};
-    for (PFT::Evaluation &eval : evaluationCollection) {
+    for (pft::Evaluation &eval : evaluationCollection) {
       outputStream << indentString << getNodeIndex(eval) << " ";
       llvm::StringRef name{evalName(eval)};
       if (auto *subs{eval.getConstructEvals()}) {
@@ -528,7 +528,7 @@ class PFTDumper {
   }
 
   void dumpFunctionLikeUnit(llvm::raw_ostream &outputStream,
-                            PFT::FunctionLikeUnit &functionLikeUnit) {
+                            pft::FunctionLikeUnit &functionLikeUnit) {
     outputStream << getNodeIndex(functionLikeUnit) << " ";
     llvm::StringRef unitKind{};
     std::string name{};
@@ -580,7 +580,7 @@ class PFTDumper {
   }
 
   void dumpModuleLikeUnit(llvm::raw_ostream &outputStream,
-                          PFT::ModuleLikeUnit &moduleLikeUnit) {
+                          pft::ModuleLikeUnit &moduleLikeUnit) {
     outputStream << getNodeIndex(moduleLikeUnit) << " ";
     outputStream << "ModuleLike: ";
     outputStream << "\nContains\n";
@@ -599,7 +599,7 @@ class PFTDumper {
     nodeIndexes.try_emplace(addr, nextIndex);
     return nextIndex++;
   }
-  std::size_t getNodeIndex(const PFT::Program &) { return 0; }
+  std::size_t getNodeIndex(const pft::Program &) { return 0; }
 
   void resetIndexes() {
     nodeIndexes.clear();
@@ -612,20 +612,20 @@ class PFTDumper {
 };
 
 template <typename A, typename T>
-PFT::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
-  return PFT::FunctionLikeUnit::FunctionStatement{
+pft::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
+  return pft::FunctionLikeUnit::FunctionStatement{
       &std::get<parser::Statement<A>>(func.t)};
 }
 template <typename A, typename T>
-PFT::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
-  return PFT::ModuleLikeUnit::ModuleStatement{
+pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
+  return pft::ModuleLikeUnit::ModuleStatement{
       &std::get<parser::Statement<A>>(mod.t)};
 }
 
 } // namespace
 
-PFT::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
-                                        const PFT::ParentType &parent)
+pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
+                                        const pft::ParentType &parent)
     : ProgramUnit{func, parent} {
   auto &ps{
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t)};
@@ -636,51 +636,51 @@ PFT::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
   endStmt = getFunctionStmt<parser::EndProgramStmt>(func);
 }
 
-PFT::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,
-                                        const PFT::ParentType &parent)
+pft::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,
+                                        const pft::ParentType &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::FunctionStmt>(func)},
       endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)} {}
 
-PFT::FunctionLikeUnit::FunctionLikeUnit(
-    const parser::SubroutineSubprogram &func, const PFT::ParentType &parent)
+pft::FunctionLikeUnit::FunctionLikeUnit(
+    const parser::SubroutineSubprogram &func, const pft::ParentType &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::SubroutineStmt>(func)},
       endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)} {}
 
-PFT::FunctionLikeUnit::FunctionLikeUnit(
-    const parser::SeparateModuleSubprogram &func, const PFT::ParentType &parent)
+pft::FunctionLikeUnit::FunctionLikeUnit(
+    const parser::SeparateModuleSubprogram &func, const pft::ParentType &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
       endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {}
 
-PFT::ModuleLikeUnit::ModuleLikeUnit(const parser::Module &m,
-                                    const PFT::ParentType &parent)
+pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Module &m,
+                                    const pft::ParentType &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::ModuleStmt>(m)},
       endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {}
 
-PFT::ModuleLikeUnit::ModuleLikeUnit(const parser::Submodule &m,
-                                    const PFT::ParentType &parent)
+pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Submodule &m,
+                                    const pft::ParentType &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::SubmoduleStmt>(
                                   m)},
       endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {}
 
-PFT::BlockDataUnit::BlockDataUnit(const parser::BlockData &bd,
-                                  const PFT::ParentType &parent)
+pft::BlockDataUnit::BlockDataUnit(const parser::BlockData &bd,
+                                  const pft::ParentType &parent)
     : ProgramUnit{bd, parent} {}
 
-std::unique_ptr<PFT::Program> createPFT(const parser::Program &root) {
+std::unique_ptr<pft::Program> createPFT(const parser::Program &root) {
   PFTBuilder walker;
   Walk(root, walker);
   return walker.result();
 }
 
-void annotateControl(PFT::Program &pft) {
+void annotateControl(pft::Program &pft) {
   for (auto &unit : pft.getUnits()) {
     std::visit(common::visitors{
-                   [](PFT::BlockDataUnit &) {},
-                   [](PFT::FunctionLikeUnit &func) { annotateFuncCFG(func); },
-                   [](PFT::ModuleLikeUnit &unit) {
+                   [](pft::BlockDataUnit &) {},
+                   [](pft::FunctionLikeUnit &func) { annotateFuncCFG(func); },
+                   [](pft::ModuleLikeUnit &unit) {
                      for (auto &func : unit.funcs)
                        annotateFuncCFG(func);
                    },
@@ -689,9 +689,10 @@ void annotateControl(PFT::Program &pft) {
   }
 }
 
-/// Dump a PFT.
-void dumpPFT(llvm::raw_ostream &outputStream, PFT::Program &pft) {
+void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
   PFTDumper{}.dumpPFT(outputStream, pft);
 }
 
+void pft::Program::dump() { dumpPFT(llvm::errs(), *this); }
+
 } // namespace Fortran::lower
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 2ddac9a662bb..e151fc383f3e 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -470,7 +470,7 @@ class ExprLowering {
     auto type =
         fir::SequenceType::get({size}, fir::CharacterType::get(context, KIND));
     return builder.create<fir::StringLitOp>(
-        getLoc(), L::ArrayRef<M::Type>{type}, llvm::None, attrs);
+        getLoc(), L::ArrayRef<M::Type>{type}, L::None, attrs);
   }
 
   template <Co::TypeCategory TC, int KIND>
@@ -875,7 +875,7 @@ M::Value Br::createSomeAddress(M::Location loc,
 /// `symbol` will be nullptr for an anonymous temporary
 M::Value Br::createTemporary(M::Location loc, M::OpBuilder &builder,
                              SymMap &symMap, M::Type type,
-                             const Se::Symbol *symbol, llvm::StringRef name) {
+                             const Se::Symbol *symbol, L::StringRef name) {
   if (symbol)
     if (auto val = symMap.lookupSymbol(*symbol)) {
       if (auto op = val.getDefiningOp())
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index d7d93457e5ba..8f37173b89b9 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -62,7 +62,7 @@ using SmallVecResult = SmallVector<mlir::Value, 4>;
 using OperandTy = ArrayRef<mlir::Value>;
 using AttributeTy = ArrayRef<mlir::NamedAttribute>;
 
-const unsigned defaultAlign = 8;
+const unsigned defaultAlign{8};
 
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
@@ -126,7 +126,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   mlir::LLVM::LLVMType convertBoxCharType(BoxCharType boxchar) {
     auto ptrTy = convertCharType(boxchar.getEleTy()).getPointerTo();
     auto i64Ty = mlir::LLVM::LLVMType::getInt64Ty(llvmDialect);
-    SmallVector<mlir::LLVM::LLVMType, 2> tuple = {ptrTy, i64Ty};
+    SmallVector<mlir::LLVM::LLVMType, 2> tuple{ptrTy, i64Ty};
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
@@ -917,8 +917,8 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
     mlir::Value v;
     if (fromLLVMTy->isFloatingPointTy()) {
       if (toLLVMTy->isFloatingPointTy()) {
-        unsigned fromBits = fromLLVMTy->getPrimitiveSizeInBits();
-        unsigned toBits = toLLVMTy->getPrimitiveSizeInBits();
+        std::size_t fromBits{fromLLVMTy->getPrimitiveSizeInBits()};
+        std::size_t toBits{toLLVMTy->getPrimitiveSizeInBits()};
         // FIXME: what if different reps (F16, BF16) are the same size?
         assert(fromBits != toBits);
         if (fromBits > toBits)
@@ -930,8 +930,8 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
       }
     } else if (fromLLVMTy->isIntegerTy()) {
       if (toLLVMTy->isIntegerTy()) {
-        unsigned fromBits = fromLLVMTy->getIntegerBitWidth();
-        unsigned toBits = toLLVMTy->getIntegerBitWidth();
+        std::size_t fromBits{fromLLVMTy->getIntegerBitWidth()};
+        std::size_t toBits{toLLVMTy->getIntegerBitWidth()};
         assert(fromBits != toBits);
         if (fromBits > toBits)
           v = rewriter.create<mlir::LLVM::TruncOp>(loc, toTy, op0);
@@ -1155,7 +1155,7 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
     assert(allConstants(operands.drop_front(1)));
     // since all indices are constants use LLVM's extractvalue instruction
     SmallVector<mlir::Attribute, 8> attrs;
-    for (int i = 1, end = operands.size(); i < end; ++i)
+    for (std::size_t i = 1, end{operands.size()}; i < end; ++i)
       attrs.push_back(getValue(operands[i]));
     auto position = mlir::ArrayAttr::get(attrs, extractVal.getContext());
     rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(
@@ -1177,7 +1177,7 @@ struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
     assert(allConstants(operands.drop_front(2)));
     // since all indices must be constants use LLVM's insertvalue instruction
     SmallVector<mlir::Attribute, 8> attrs;
-    for (int i = 2, end = operands.size(); i < end; ++i)
+    for (std::size_t i = 2, end{operands.size()}; i < end; ++i)
       attrs.push_back(getValue(operands[i]));
     auto position = mlir::ArrayAttr::get(attrs, insertVal.getContext());
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
@@ -1250,7 +1250,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     mlir::Value retval = base;
     assert(offs.size() == args.size() && "must have same arity");
     unsigned pos = 0;
-    for (unsigned i = 0, sz = offs.size(); i != sz; ++i) {
+    for (std::size_t i = 0, sz{offs.size()}; i != sz; ++i) {
       assert(pos <= i);
       if (auto defop = args[i].getDefiningOp())
         if (auto field = dyn_cast<FieldIndexOp>(defop)) {
@@ -1357,7 +1357,7 @@ struct LenParamIndexOpConversion
       offset += 3 * arr.getDimension();
     }
     // advance over some addendum fields
-    const unsigned addendumOffset = sizeof(void *) + sizeof(uint64_t);
+    const unsigned addendumOffset{sizeof(void *) + sizeof(uint64_t)};
     offset += addendumOffset;
     // add the offset into the LENs
     offset += 0; // FIXME
@@ -1455,18 +1455,30 @@ struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
   }
 };
 
-struct GlobalEntryOpConversion : public FIROpConversion<GlobalEntryOp> {
+struct GlobalLenOpConversion : public FIROpConversion<GlobalLenOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto globalentry = mlir::cast<GlobalEntryOp>(op);
+    auto globalentry = mlir::cast<GlobalLenOp>(op);
     TODO(globalentry);
     return matchSuccess();
   }
 };
 
+struct HasValueOpConversion : public FIROpConversion<fir::HasValueOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::PatternMatchResult
+  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands, llvm::None,
+                                                op->getAttrs());
+    return matchSuccess();
+  }
+};
+
 struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1475,33 +1487,18 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto global = mlir::cast<fir::GlobalOp>(op);
     auto tyAttr = unwrap(convertType(global.getType()));
-    bool isConst = global.getAttr("constant") ? true : false;
-    auto name = global
-                    .getAttrOfType<mlir::StringAttr>(
-                        mlir::SymbolTable::getSymbolAttrName())
-                    .getValue();
-    auto value = initializersToAttr(global.getOperation(), rewriter);
-    rewriter.replaceOpWithNewOp<mlir::LLVM::GlobalOp>(
-        global, tyAttr, isConst, mlir::LLVM::Linkage::External, name, value);
+    auto loc = global.getLoc();
+    mlir::Attribute initAttr{};
+    if (global.initval())
+      initAttr = global.initval().getValue();
+    auto g = rewriter.create<mlir::LLVM::GlobalOp>(
+        loc, tyAttr, global.constant(), mlir::LLVM::Linkage::External,
+        global.sym_name(), initAttr);
+    auto &gr = g.getInitializerRegion();
+    rewriter.inlineRegionBefore(global.region(), gr, gr.end());
+    rewriter.eraseOp(global);
     return matchSuccess();
   }
-
-  // convert the operations in the body into an initializer attr
-  // TODO: only accidentally correct for very simple cases at the moment
-  mlir::Attribute
-  initializersToAttr(mlir::Operation *global,
-                     mlir::ConversionPatternRewriter &rewriter) const {
-    mlir::Attribute val;
-    if (global->getNumRegions() > 0) {
-      mlir::Block &block = global->getRegion(0).front();
-      for (auto &ini : block) {
-        if (auto cop = dyn_cast<mlir::ConstantOp>(ini)) {
-          val = cop.value();
-        }
-      }
-    }
-    return val;
-  }
 };
 
 // convert to LLVM IR dialect `load`
@@ -1639,7 +1636,7 @@ void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering,
   auto &selector = operands[0];
   auto loc = select.getLoc();
   assert(conds > 0 && "select must have cases");
-  for (unsigned t = 0; t != conds; ++t) {
+  for (unsigned t = 0, end{conds}; t != end; ++t) {
     auto &attr = cases[t];
     if (auto intAttr = attr.template dyn_cast_or_null<mlir::IntegerAttr>()) {
       auto ci = rewriter.create<mlir::LLVM::ConstantOp>(
@@ -1783,7 +1780,7 @@ struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
     mlir::Value attr = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 5);
     mlir::Value xtra = genLoadWithIndex(loc, tuple, ty, rewriter, oty, c0, 6);
     // FIXME: add dims, etc.
-    std::vector<mlir::Value> repls = {ptr, len, ver, rank, type, attr, xtra};
+    std::vector<mlir::Value> repls{ptr, len, ver, rank, type, attr, xtra};
     unbox.replaceAllUsesWith(repls);
     rewriter.eraseOp(unbox);
     return matchSuccess();
@@ -1806,7 +1803,7 @@ struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
         genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 0);
     mlir::Value host =
         genExtractValueWithIndex(loc, tuple, ty, rewriter, ctx, 1);
-    std::vector<mlir::Value> repls = {ptr, host};
+    std::vector<mlir::Value> repls{ptr, host};
     unboxproc.replaceAllUsesWith(repls);
     rewriter.eraseOp(unboxproc);
     return matchSuccess();
@@ -2110,14 +2107,15 @@ struct FIRToLLVMLoweringPass : public mlir::ModulePass<FIRToLLVMLoweringPass> {
         EmboxCharOpConversion, EmboxOpConversion, EmboxProcOpConversion,
         FieldIndexOpConversion, FirEndOpConversion, ExtractValueOpConversion,
         FreeMemOpConversion, GenDimsOpConversion, GenTypeDescOpConversion,
-        GlobalEntryOpConversion, GlobalOpConversion, InsertValueOpConversion,
-        LenParamIndexOpConversion, LoadOpConversion, ModfOpConversion,
-        MulcOpConversion, MulfOpConversion, NegcOpConversion, NegfOpConversion,
-        NoReassocOpConversion, SelectCaseOpConversion, SelectOpConversion,
-        SelectRankOpConversion, SelectTypeOpConversion, StoreOpConversion,
-        StringLitOpConversion, SubcOpConversion, SubfOpConversion,
-        UnboxCharOpConversion, UnboxOpConversion, UnboxProcOpConversion,
-        UndefOpConversion, UnreachableOpConversion>(context, typeConverter);
+        GlobalLenOpConversion, GlobalOpConversion, HasValueOpConversion,
+        InsertValueOpConversion, LenParamIndexOpConversion, LoadOpConversion,
+        ModfOpConversion, MulcOpConversion, MulfOpConversion, NegcOpConversion,
+        NegfOpConversion, NoReassocOpConversion, SelectCaseOpConversion,
+        SelectOpConversion, SelectRankOpConversion, SelectTypeOpConversion,
+        StoreOpConversion, StringLitOpConversion, SubcOpConversion,
+        SubfOpConversion, UnboxCharOpConversion, UnboxOpConversion,
+        UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion>(
+        context, typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, patterns);
     mlir::ConversionTarget target{*context};
     target.addLegalDialect<mlir::LLVM::LLVMDialect>();
diff --git a/lib/optimizer/Dialect/FIRDialect.cpp b/lib/optimizer/Dialect/FIRDialect.cpp
index 9ddb463283fe..90c2b6423c93 100644
--- a/lib/optimizer/Dialect/FIRDialect.cpp
+++ b/lib/optimizer/Dialect/FIRDialect.cpp
@@ -45,7 +45,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
            RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
   addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
                 PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
-  addOperations<DispatchTableOp,
+  addOperations<
 #define GET_OP_LIST
 #include "flang/optimizer/Dialect/FIROps.cpp.inc"
                 >();
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
index 1345f7327c14..467eaf73f503 100644
--- a/lib/optimizer/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -307,68 +307,14 @@ mlir::FunctionType DispatchOp::getFunctionType() {
 
 // DispatchTableOp
 
-void DispatchTableOp::build(mlir::Builder *builder,
-                            mlir::OperationState *result, llvm::StringRef name,
-                            mlir::Type type,
-                            llvm::ArrayRef<mlir::NamedAttribute> attrs) {
-  result->addAttribute("method", builder->getStringAttr(name));
-  for (const auto &pair : attrs)
-    result->addAttribute(pair.first, pair.second);
-}
-
-mlir::ParseResult DispatchTableOp::parse(mlir::OpAsmParser &parser,
-                                         mlir::OperationState &result) {
-  // Parse the name as a symbol reference attribute.
-  SymbolRefAttr nameAttr;
-  if (parser.parseAttribute(nameAttr, "method", result.attributes))
-    return failure();
-
-  // Convert the parsed name attr into a string attr.
-  result.attributes.back().second =
-      parser.getBuilder().getStringAttr(nameAttr.getRootReference());
-
-  // Parse the optional table body.
-  mlir::Region *body = result.addRegion();
-  if (parser.parseOptionalRegion(
-          *body, llvm::ArrayRef<mlir::OpAsmParser::OperandType>{},
-          llvm::ArrayRef<mlir::Type>{}))
-    return mlir::failure();
-
-  ensureTerminator(*body, parser.getBuilder(), result.location);
-  return mlir::success();
-}
-
-void DispatchTableOp::print(mlir::OpAsmPrinter &p) {
-  auto tableName = getAttrOfType<StringAttr>("method").getValue();
-  p << getOperationName() << " @" << tableName;
-
-  Region &body = getOperation()->getRegion(0);
-  if (!body.empty())
-    p.printRegion(body, /*printEntryBlockArgs=*/false,
-                  /*printBlockTerminators=*/false);
-}
-
-mlir::LogicalResult DispatchTableOp::verify() { return mlir::success(); }
-
-mlir::Region &DispatchTableOp::front() {
-  return this->getOperation()->getRegion(0);
-}
-
 void DispatchTableOp::appendTableEntry(mlir::Operation *op) {
   assert(mlir::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
-  front().front().push_back(op);
+  auto &block = getBlock();
+  block.getOperations().insert(block.end(), op);
 }
 
 // GenTypeDescOp
 
-#if 0
-void GenTypeDescOp::build(Builder *, OperationState &result, mlir::Type resty,
-                          mlir::TypeAttr inty) {
-  result.addAttribute("in_type", inty);
-  result.addTypes(resty);
-}
-#endif
-
 void GenTypeDescOp::build(Builder *, OperationState &result,
                           mlir::TypeAttr inty) {
   result.addAttribute("in_type", inty);
@@ -377,17 +323,9 @@ void GenTypeDescOp::build(Builder *, OperationState &result,
 
 // GlobalOp
 
-GlobalOp GlobalOp::create(mlir::Location location, llvm::StringRef name,
-                          mlir::Type type,
-                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
-  mlir::OperationState state(location, "global");
-  mlir::Builder builder(location->getContext());
-  GlobalOp::build(&builder, state, name, type, attrs);
-  return cast<GlobalOp>(Operation::create(state));
-}
-
 void GlobalOp::appendInitialValue(mlir::Operation *op) {
-  front().front().push_back(op);
+  auto &block = getBlock();
+  block.getOperations().insert(block.end(), op);
 }
 
 // LoadOp
diff --git a/lib/optimizer/Dialect/FIRType.cpp b/lib/optimizer/Dialect/FIRType.cpp
index 46e23a1b5e98..fc1789aa98fb 100644
--- a/lib/optimizer/Dialect/FIRType.cpp
+++ b/lib/optimizer/Dialect/FIRType.cpp
@@ -298,7 +298,7 @@ RecordType parseDerived(mlir::DialectAsmParser &parser, mlir::Location) {
 // !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
 // is undefined and disallowed.
 inline bool singleIndirectionLevel(mlir::Type ty) {
-  return !fir::isa_memref(ty);
+  return !fir::isaMemref(ty);
 }
 
 } // namespace
@@ -817,32 +817,35 @@ struct TypeDescTypeStorage : public mlir::TypeStorage {
 };
 
 } // namespace detail
-} // namespace fir
 
 template <typename A, typename B>
 bool inbounds(A v, B lb, B ub) {
   return v >= lb && v < ub;
 }
 
-bool fir::isa_fir_type(mlir::Type t) {
+bool isa_fir_type(mlir::Type t) {
   return inbounds(t.getKind(), mlir::Type::FIRST_FIR_TYPE,
                   mlir::Type::LAST_FIR_TYPE);
 }
 
-bool fir::isa_std_type(mlir::Type t) {
+bool isa_std_type(mlir::Type t) {
   return inbounds(t.getKind(), mlir::Type::FIRST_STANDARD_TYPE,
                   mlir::Type::LAST_STANDARD_TYPE);
 }
 
-bool fir::isa_fir_or_std_type(mlir::Type t) {
+bool isa_fir_or_std_type(mlir::Type t) {
   return isa_fir_type(t) || isa_std_type(t);
 }
 
-bool fir::isa_memref(mlir::Type t) {
+bool isaMemref(mlir::Type t) {
   return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
 }
 
-mlir::Type fir::dyn_cast_ptrEleTy(mlir::Type t) {
+bool isanAggregate(mlir::Type t) {
+  return t.isa<SequenceType>() || t.isa<RecordType>();
+}
+
+mlir::Type dyn_cast_ptrEleTy(mlir::Type t) {
   if (auto p = t.dyn_cast<fir::ReferenceType>())
     return p.getEleTy();
   if (auto p = t.dyn_cast<fir::PointerType>())
@@ -852,6 +855,8 @@ mlir::Type fir::dyn_cast_ptrEleTy(mlir::Type t) {
   return {};
 }
 
+} // namespace fir
+
 // CHARACTER
 
 CharacterType fir::CharacterType::get(mlir::MLIRContext *ctxt, KindTy kind) {
@@ -1062,8 +1067,12 @@ mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
-      eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>())
+      eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>()) {
+    mlir::emitError(mlir::UnknownLoc::get(context),
+                    "cannot build an array of this element type: ")
+        << eleTy << '\n';
     return mlir::failure();
+  }
   return mlir::success();
 }
 
@@ -1072,7 +1081,7 @@ bool fir::operator==(const SequenceType::Shape &sh_1,
                      const SequenceType::Shape &sh_2) {
   if (sh_1.size() != sh_2.size())
     return false;
-  for (std::size_t i = 0, e = sh_1.size(); i != e; ++i)
+  for (std::size_t i = 0, e{sh_1.size()}; i != e; ++i)
     if (sh_1[i] != sh_2[i])
       return false;
   return true;
diff --git a/lib/optimizer/Support/InternalNames.cpp b/lib/optimizer/Support/InternalNames.cpp
index b95d8df60390..7c292a390861 100644
--- a/lib/optimizer/Support/InternalNames.cpp
+++ b/lib/optimizer/Support/InternalNames.cpp
@@ -204,7 +204,7 @@ fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
     std::string name;
     llvm::SmallVector<std::int64_t, 8> kinds;
     NameKind nk = NameKind::NOT_UNIQUED;
-    for (std::size_t i = 2, end = uniq.size(); i != end;) {
+    for (std::size_t i = 2, end{uniq.size()}; i != end;) {
       switch (uniq[i]) {
       case 'B':
         nk = NameKind::COMMON;
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
index 02aef02f51de..f3f2f1e04449 100644
--- a/lib/optimizer/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -280,7 +280,7 @@ struct MemToReg
       if (!LI)
         continue;
 
-      unsigned LoadIdx = LBI.getInstructionIndex(LI);
+      unsigned LoadIdx{LBI.getInstructionIndex(LI)};
 
       // Find the nearest store that has a lower index than this load.
       typename StoresByIndexTy::iterator I = llvm::lower_bound(
@@ -343,7 +343,7 @@ struct MemToReg
     // If any of the using blocks is also a definition block, check to see if
     // the definition occurs before or after the use.  If it happens before the
     // use, the value isn't really live-in.
-    for (unsigned i = 0, e = LiveInBlockWorklist.size(); i != e; ++i) {
+    for (std::size_t i = 0, e{LiveInBlockWorklist.size()}; i != e; ++i) {
       mlir::Block *BB = LiveInBlockWorklist[i];
       if (!DefBlocks.count(BB))
         continue;
@@ -521,7 +521,7 @@ struct MemToReg
     if ((!BB->hasNoPredecessors()) && (BB->getNumArguments() > 0)) {
       // add the values from block `Pred` to the argument list in the proper
       // positions
-      for (unsigned ai = 0, AI = BB->getNumArguments(); ai != AI; ++ai) {
+      for (unsigned ai = 0, AI{BB->getNumArguments()}; ai != AI; ++ai) {
         auto allocaNo = argToAllocaMap[std::make_pair(BB, ai)];
         setParam(Pred, ai, IncomingVals[allocaNo], BB, AI);
         // use the block argument, not the live def in the pred block
@@ -607,7 +607,7 @@ struct MemToReg
 
     assert(!allocas.empty());
 
-    for (unsigned allocaNum = 0, End = allocas.size(); allocaNum != End;
+    for (std::size_t allocaNum = 0, End{allocas.size()}; allocaNum != End;
          ++allocaNum) {
       auto ae = allocas[allocaNum];
       assert(ae.template getParentOfType<mlir::FuncOp>() == F);
@@ -677,7 +677,7 @@ struct MemToReg
     // of the alloca's.  We do this in case there is a load of a value that
     // has not been stored yet.  In this case, it will get this null value.
     RenamePassData::ValVector values(allocas.size());
-    for (unsigned i = 0, e = allocas.size(); i != e; ++i)
+    for (std::size_t i = 0, e{allocas.size()}; i != e; ++i)
       values[i] = builder->create<UNDEF>(allocas[i].getLoc(),
                                          allocas[i].getAllocatedType());
 
diff --git a/test-lit/fir/fir-ops.fir b/test-lit/fir/fir-ops.fir
index 8499006d173c..30edc2dd169b 100644
--- a/test-lit/fir/fir-ops.fir
+++ b/test-lit/fir/fir-ops.fir
@@ -320,18 +320,21 @@ func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
 // CHECK-LABEL: @global_var
 fir.global @global_var : i32 {
   %0 = constant 1 : i32
+  fir.has_value %0 : i32
 }
 
 // CHECK-LABEL: @global_constant
 fir.global @global_constant constant : i32 {
   %0 = constant 934 : i32
+  fir.has_value %0 : i32
 }
 
 // CHECK-LABEL: @global_derived
-fir.global @global_derived : !fir.type<mine{f:i32}> {
-  %0 = constant 1 : i32
-  // CHECK: fir.global_entry "f", %{{.*}} : i32
-  fir.global_entry "f", %0 : i32
+fir.global @global_derived : !fir.type<minez(f:i32)> {
+  // CHECK: fir.global_len "f", 1 : i32
+  fir.global_len f, 1 : i32
+  %0 = fir.undefined !fir.type<minez>
+  fir.has_value %0 : !fir.type<minez>
 }
 
 // CHECK-LABEL: @dispatch_tbl
diff --git a/test-lit/fir/global.fir b/test-lit/fir/global.fir
index 29a6dbc3e0e4..a2a2a04ce25d 100644
--- a/test-lit/fir/global.fir
+++ b/test-lit/fir/global.fir
@@ -2,15 +2,18 @@
 
 // CHECK: @g_i0 = global i32 0
 fir.global @g_i0 : i32 {
-  constant 0 : i32
+  %1 = constant 0 : i32
+  fir.has_value %1 : i32
 }
 
 // CHECK: @g_i2 = global i32 2
 fir.global @g_i2 : i32 {
-  constant 2 : i32
+  %1 = constant 2 : i32
+  fir.has_value %1 : i32
 }
 
 // CHECK: @g_ci5 = constant i32 5
 fir.global @g_ci5 constant : i32 {
-  constant 5 : i32
+  %c = constant 5 : i32
+  fir.has_value %c : i32
 }
diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index 6f896fc32d56..8c6cc0818584 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -1,19 +1,11 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+
 set(LIBS
   FIRDialect
   FIROptimizer
-  MLIRAffineOps
-  MLIRLLVMIR
-  MLIRLoopOps
-  MLIRStandardOps
-)
-
-add_llvm_library(FirBbcLib bbc.cpp)
-target_link_libraries(FirBbcLib ${LIBS} FIRTransforms)
-
-set(EXE_LIBS
-  ${LIBS}
   FIRTransforms
+  MLIRAllDialects
+  MLIRLLVMIR
   MLIRAffineToStandard
   FortranCommon
   FortranParser
@@ -24,5 +16,4 @@ set(EXE_LIBS
 
 add_llvm_tool(bbc bbc.cpp)
 llvm_update_compile_flags(bbc)
-whole_archive_link(bbc ${LIBS})
-target_link_libraries(bbc PRIVATE FIRDialect MLIRIR FirBbcLib ${EXE_LIBS} LLVMSupport)
+target_link_libraries(bbc PRIVATE ${LIBS})
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 456eba66fa4b..cb01494c6984 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -35,6 +35,7 @@
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
@@ -152,6 +153,7 @@ void convertFortranSourceToMLIR(
   if (emitFIR) {
     // dump FIR and exit
     mlirModule.print(out);
+    out << '\n';
     return;
   }
 
@@ -176,6 +178,7 @@ void convertFortranSourceToMLIR(
 
   if (mlir::succeeded(pm.run(mlirModule))) {
     mlirModule.print(out);
+    out << '\n';
   } else {
     errs() << "oops, pass manager reported failure\n";
     mlirModule.dump();
@@ -185,11 +188,14 @@ void convertFortranSourceToMLIR(
 } // namespace
 
 int main(int argc, char **argv) {
+  mlir::registerAllDialects();
+  fir::registerFIR();
+  fir::registerFIRPasses();
   [[maybe_unused]] InitLLVM y(argc, argv);
 
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
-  cl::ParseCommandLineOptions(argc, argv, "bbc\n");
+  cl::ParseCommandLineOptions(argc, argv, "Burnside Bridge Compiler\n");
 
   DriverOptions driver;
   driver.prefix = argv[0] + ": "s;
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index fa3761baa271..f695d187de9e 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -131,6 +131,6 @@ int main(int argc, char **argv) {
   [[maybe_unused]] InitLLVM y(argc, argv);
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
-  cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Opt\n");
+  cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Optimizer\n");
   return compileFIR();
 }

From 2cf1b2f568cac9f77f2ff6dad073a763204785e8 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Sat, 22 Feb 2020 11:58:26 -0800
Subject: [PATCH 192/345] fix order of ctors, etc.

rebasing changes

add back the missing template instantiations to avoid link-time failures

more rebasing changes
---
 include/flang/Lower/PFTBuilder.h              |  57 +--
 include/flang/lower/Intrinsics.h              |   2 +-
 include/flang/optimizer/Dialect/FIROps.td     |  15 +-
 .../flang/optimizer/Dialect/FIROpsSupport.h   |   2 +-
 include/flang/optimizer/Dialect/FIRType.h     |  42 +-
 lib/Decimal/binary-to-decimal.cpp             |   9 +-
 lib/lower/Bridge.cpp                          |   6 +-
 lib/lower/ConvertExpr.cpp                     |   2 +-
 lib/lower/IO.cpp                              |   2 +-
 lib/optimizer/CodeGen.cpp                     | 377 +++++++++---------
 lib/optimizer/Dialect/FIROps.cpp              |   2 +-
 lib/optimizer/Dialect/FIRType.cpp             |  30 +-
 lib/optimizer/StdConverter.cpp                |  36 +-
 lib/optimizer/Transforms/MemToReg.cpp         |   2 +-
 lib/optimizer/Transforms/RewriteLoop.cpp      |   4 +-
 tools/f18/CMakeLists.txt                      |   5 +
 16 files changed, 308 insertions(+), 285 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index c30fb4583a56..1c740afe40a0 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -108,22 +108,22 @@ using ConstructStmts = std::tuple<
     parser::ForallConstructStmt, parser::EndForallStmt>;
 
 template <typename A>
-constexpr static bool isActionStmt{common::HasMember<A, ActionStmts>};
+static constexpr bool isActionStmt{common::HasMember<A, ActionStmts>};
 
 template <typename A>
-constexpr static bool isConstruct{common::HasMember<A, Constructs>};
+static constexpr bool isConstruct{common::HasMember<A, Constructs>};
 
 template <typename A>
-constexpr static bool isConstructStmt{common::HasMember<A, ConstructStmts>};
+static constexpr bool isConstructStmt{common::HasMember<A, ConstructStmts>};
 
 template <typename A>
-constexpr static bool isOtherStmt{common::HasMember<A, OtherStmts>};
+static constexpr bool isOtherStmt{common::HasMember<A, OtherStmts>};
 
 template <typename A>
-constexpr static bool isGenerated{std::is_same_v<A, CGJump>};
+static constexpr bool isGenerated{std::is_same_v<A, CGJump>};
 
 template <typename A>
-constexpr static bool isFunctionLike{common::HasMember<
+static constexpr bool isFunctionLike{common::HasMember<
     A, std::tuple<parser::MainProgram, parser::FunctionSubprogram,
                   parser::SubroutineSubprogram,
                   parser::SeparateModuleSubprogram>>};
@@ -142,6 +142,27 @@ struct Evaluation {
   using EvalVariant =
       common::CombineVariants<common::MapTemplate<MakeRefType, EvalTuple>,
                               std::variant<CGJump>>;
+
+  /// General ctor
+  template <typename A>
+  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &pos,
+             const std::optional<parser::Label> &lab)
+      : u{&a}, parent{p}, pos{pos}, lab{lab} {}
+
+  /// Compiler-generated jump
+  Evaluation(const CGJump &jump, const ParentType &p)
+      : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
+
+  /// Construct ctor
+  template <typename A>
+  Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
+    static_assert(pft::isConstruct<A>, "must be a construct");
+  }
+
+  Evaluation() = delete;
+  Evaluation(const Evaluation &) = delete;
+  Evaluation(Evaluation &&) = default;
+
   template <typename A>
   constexpr auto visit(A visitor) const {
     return std::visit(common::visitors{
@@ -169,26 +190,6 @@ struct Evaluation {
     return std::holds_alternative<CGJump>(u);
   }
 
-  Evaluation() = delete;
-  Evaluation(const Evaluation &) = delete;
-  Evaluation(Evaluation &&) = default;
-
-  /// General ctor
-  template <typename A>
-  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &pos,
-             const std::optional<parser::Label> &lab)
-      : u{&a}, parent{p}, pos{pos}, lab{lab} {}
-
-  /// Compiler-generated jump
-  Evaluation(const CGJump &jump, const ParentType &p)
-      : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
-
-  /// Construct ctor
-  template <typename A>
-  Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
-    static_assert(pft::isConstruct<A>, "must be a construct");
-  }
-
   constexpr bool isActionOrGenerated() const {
     return visit(common::visitors{
         [](auto &r) {
@@ -215,6 +216,7 @@ struct Evaluation {
         },
     });
   }
+  
   constexpr bool isConstruct() const { return !isStmt(); }
 
   /// Set the type of originating control flow type for this evaluation.
@@ -306,12 +308,15 @@ struct FunctionLikeUnit : public ProgramUnit {
     return std::holds_alternative<
         const parser::Statement<parser::EndProgramStmt> *>(endStmt);
   }
+  
   const parser::FunctionStmt *getFunction() {
     return getA<parser::FunctionStmt>();
   }
+  
   const parser::SubroutineStmt *getSubroutine() {
     return getA<parser::SubroutineStmt>();
   }
+  
   const parser::MpSubprogramStmt *getMPSubp() {
     return getA<parser::MpSubprogramStmt>();
   }
diff --git a/include/flang/lower/Intrinsics.h b/include/flang/lower/Intrinsics.h
index f12a6fe58c04..e52f36bbf603 100644
--- a/include/flang/lower/Intrinsics.h
+++ b/include/flang/lower/Intrinsics.h
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_INTRINSICS_H_
 #define FORTRAN_LOWER_INTRINSICS_H_
 
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 #include <optional>
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index 8e9e16280b9d..310008df4caa 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -40,7 +40,7 @@ def fir_RealType : Type<CPred<"$_self.isa<fir::RealType>()">,
     "FIR real type">;
 
 // Generalized FIR and standard dialect types representing intrinsic types
-def AnyIntegerLike : TypeConstraint<Or<[IntegerLike.predicate,
+def AnyIntegerLike : TypeConstraint<Or<[SignlessIntegerLike.predicate,
     fir_IntegerType.predicate]>, "any integer">;
 def AnyLogicalLike : TypeConstraint<Or<[BoolLike.predicate,
     fir_LogicalType.predicate]>, "any logical">;
@@ -97,7 +97,7 @@ def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
 
 // A vector of Fortran triple notation describing a multidimensional array
 def fir_DimsType : Type<CPred<"$_self.isa<fir::DimsType>()">, "dim type">;
-def AnyEmboxLike : TypeConstraint<Or<[AnyInteger.predicate,
+def AnyEmboxLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
     Index.predicate, fir_IntegerType.predicate, fir_DimsType.predicate]>,
     "any legal embox argument type">;
 def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;
@@ -113,12 +113,12 @@ def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
 def fir_LenType : Type<CPred<"$_self.isa<fir::LenType>()">,
     "LEN parameter type">;
 
-def AnyComponentLike : TypeConstraint<Or<[AnyInteger.predicate,
+def AnyComponentLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
     Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate]>,
     "any coordinate index">;
 def AnyComponentType : Type<AnyComponentLike.predicate, "coordinate type">;
 
-def AnyCoordinateLike : TypeConstraint<Or<[AnyInteger.predicate,
+def AnyCoordinateLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
     Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate,
     fir_LenType.predicate]>, "any coordinate index">;
 def AnyCoordinateType : Type<AnyCoordinateLike.predicate, "coordinate type">;
@@ -608,6 +608,8 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
     return mlir::success();
   }];
 
+  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
+
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
@@ -749,6 +751,8 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     return mlir::success();
   }];
 
+  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
+
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
     mlir::Value getCaseArg(unsigned dest, unsigned ele) {
       assert(ele < 2);
@@ -835,6 +839,9 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     }
     return mlir::success();
   }];
+
+  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
+
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
diff --git a/include/flang/optimizer/Dialect/FIROpsSupport.h b/include/flang/optimizer/Dialect/FIROpsSupport.h
index ce936152ab0b..04c5ed17932a 100644
--- a/include/flang/optimizer/Dialect/FIROpsSupport.h
+++ b/include/flang/optimizer/Dialect/FIROpsSupport.h
@@ -10,7 +10,7 @@
 #define OPTIMIZER_DIALECT_FIROPSSUPPORT_H
 
 #include "flang/optimizer/Dialect/FIROps.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 namespace fir {
 
diff --git a/include/flang/optimizer/Dialect/FIRType.h b/include/flang/optimizer/Dialect/FIRType.h
index 8dfc66c8346a..49764a7c3e66 100644
--- a/include/flang/optimizer/Dialect/FIRType.h
+++ b/include/flang/optimizer/Dialect/FIRType.h
@@ -160,8 +160,7 @@ class BoxType
   mlir::AffineMapAttr getLayoutMap() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location>,
-                               mlir::MLIRContext *ctx, mlir::Type eleTy,
+  verifyConstructionInvariants(const mlir::AttributeStorage *, mlir::Type eleTy,
                                mlir::AffineMapAttr map);
 };
 
@@ -183,8 +182,8 @@ class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                               mlir::MLIRContext *context, mlir::Type eleTy);
+  verifyConstructionInvariants(const mlir::AttributeStorage *,
+                               mlir::Type eleTy);
 };
 
 class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
@@ -216,8 +215,8 @@ class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                               mlir::MLIRContext *context, mlir::Type eleTy);
+  verifyConstructionInvariants(const mlir::AttributeStorage *,
+                               mlir::Type eleTy);
 };
 
 class LenType
@@ -238,8 +237,8 @@ class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                               mlir::MLIRContext *context, mlir::Type eleTy);
+  verifyConstructionInvariants(const mlir::AttributeStorage *,
+                               mlir::Type eleTy);
 };
 
 class ReferenceType
@@ -253,8 +252,8 @@ class ReferenceType
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                               mlir::MLIRContext *context, mlir::Type eleTy);
+  verifyConstructionInvariants(const mlir::AttributeStorage *,
+                               mlir::Type eleTy);
 };
 
 /// A sequence type is a multi-dimensional array of values. The sequence type
@@ -286,14 +285,14 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
   unsigned getDimension() const { return getShape().size(); }
 
   /// The value `-1` represents an unknown extent for a dimension
-  constexpr static Extent getUnknownExtent() { return -1; }
+  static constexpr Extent getUnknownExtent() { return -1; }
 
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                               mlir::MLIRContext *context, const Shape &shape,
-                               mlir::Type eleTy, mlir::AffineMapAttr map);
+  verifyConstructionInvariants(const mlir::AttributeStorage *attributeStorage,
+                               const Shape &shape, mlir::Type eleTy,
+                               mlir::AffineMapAttr map);
 };
 
 bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
@@ -305,12 +304,14 @@ class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
 public:
   using Base::Base;
   static TypeDescType get(mlir::Type ofType);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_TYPEDESC; }
+  static constexpr bool kindof(unsigned kind) {
+    return kind == TypeKind::FIR_TYPEDESC;
+  }
   mlir::Type getOfTy() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                               mlir::MLIRContext *context, mlir::Type ofType);
+  verifyConstructionInvariants(const mlir::AttributeStorage *,
+                               mlir::Type ofType);
 };
 
 // Derived types
@@ -337,14 +338,13 @@ class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
   static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
   void finalize(llvm::ArrayRef<TypePair> lenPList,
                 llvm::ArrayRef<TypePair> typeList);
-  constexpr static bool kindof(unsigned kind) { return kind == getId(); }
-  constexpr static unsigned getId() { return TypeKind::FIR_DERIVED; }
+  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
+  static constexpr unsigned getId() { return TypeKind::FIR_DERIVED; }
 
   detail::RecordTypeStorage const *uniqueKey() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                               mlir::MLIRContext *context,
+  verifyConstructionInvariants(const mlir::AttributeStorage *,
                                llvm::StringRef name);
 };
 
diff --git a/lib/Decimal/binary-to-decimal.cpp b/lib/Decimal/binary-to-decimal.cpp
index a7af4036f0d6..d1abb237ce53 100644
--- a/lib/Decimal/binary-to-decimal.cpp
+++ b/lib/Decimal/binary-to-decimal.cpp
@@ -330,7 +330,14 @@ void BigRadixFloatingPointNumber<PREC,
   }
 }
 
-template <int PREC>
+template void BigRadixFloatingPointNumber<8,16>::LoseLeastSignificantDigit();
+template void BigRadixFloatingPointNumber<11,16>::LoseLeastSignificantDigit();
+template void BigRadixFloatingPointNumber<24,16>::LoseLeastSignificantDigit();
+template void BigRadixFloatingPointNumber<53,16>::LoseLeastSignificantDigit();
+template void BigRadixFloatingPointNumber<64,16>::LoseLeastSignificantDigit();
+template void BigRadixFloatingPointNumber<112,16>::LoseLeastSignificantDigit();
+
+template<int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *buffer, std::size_t size,
     enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, BinaryFloatingPointNumber<PREC> x) {
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index 80a309bf011f..bb97cce0d680 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -1,4 +1,4 @@
-//===-- Bridge.cc ---------------------------------------------------------===//
+//===-- Bridge.cc -- bridge to lower to MLIR ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -23,7 +23,7 @@
 #include "flang/parser/parse-tree.h"
 #include "flang/semantics/tools.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Parser.h"
 #include "mlir/Target/LLVMIR.h"
@@ -1046,7 +1046,7 @@ class FirConverter : public AbstractConverter {
   M::Value genCompare(M::Value lhs, M::Value rhs) {
     auto lty{lhs.getType()};
     assert(lty == rhs.getType());
-    if (lty.isIntOrIndex())
+    if (lty.isSignlessIntOrIndex())
       return builder->create<M::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
     if (fir::LogicalType::kindof(lty.getKind()))
       return builder->create<M::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index e151fc383f3e..74dbbc55132c 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -24,7 +24,7 @@
 #include "flang/semantics/type.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/PatternMatch.h"
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 831df544872c..5925392f948f 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -16,7 +16,7 @@
 #include "flang/optimizer/Dialect/FIROps.h"
 #include "flang/parser/parse-tree.h"
 #include "flang/semantics/tools.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 
 
diff --git a/lib/optimizer/CodeGen.cpp b/lib/optimizer/CodeGen.cpp
index 8f37173b89b9..a1cefdc68d02 100644
--- a/lib/optimizer/CodeGen.cpp
+++ b/lib/optimizer/CodeGen.cpp
@@ -17,7 +17,7 @@
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Target/LLVMIR.h"
@@ -45,21 +45,33 @@
 
 using namespace llvm;
 
+using OperandTy = ArrayRef<mlir::Value>;
+
 static cl::opt<bool>
-    ClDisableFirToLLVMIR("disable-fir2llvmir",
-                         cl::desc("disable FIR to LLVM-IR dialect pass"),
-                         cl::init(false), cl::Hidden);
+    disableFirToLLVMIR("disable-fir2llvmir",
+                       cl::desc("disable FIR to LLVM-IR dialect pass"),
+                       cl::init(false), cl::Hidden);
 
-static cl::opt<bool> ClDisableLLVM("disable-llvm",
-                                   cl::desc("disable LLVM pass"),
-                                   cl::init(false), cl::Hidden);
+static cl::opt<bool> disableLLVM("disable-llvm", cl::desc("disable LLVM pass"),
+                                 cl::init(false), cl::Hidden);
 
-using namespace fir;
+namespace fir {
+/// return true if all `Value`s in `operands` are `ConstantOp`s
+bool allConstants(OperandTy operands) {
+  for (auto opnd : operands) {
+    if (auto defop = opnd.getDefiningOp())
+      if (dyn_cast<mlir::LLVM::ConstantOp>(defop) ||
+          dyn_cast<mlir::ConstantOp>(defop))
+        continue;
+    return false;
+  }
+  return true;
+}
+} // namespace fir
 
 namespace {
 
 using SmallVecResult = SmallVector<mlir::Value, 4>;
-using OperandTy = ArrayRef<mlir::Value>;
 using AttributeTy = ArrayRef<mlir::NamedAttribute>;
 
 const unsigned defaultAlign{8};
@@ -67,12 +79,57 @@ const unsigned defaultAlign{8};
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
 class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
-  KindMapping kindMapping;
+  fir::KindMapping kindMapping;
   static StringMap<mlir::LLVM::LLVMType> identStructCache;
 
 public:
-  FIRToLLVMTypeConverter(mlir::MLIRContext *context, NameUniquer &uniquer)
-      : LLVMTypeConverter(context), kindMapping(context), uniquer(uniquer) {}
+  FIRToLLVMTypeConverter(mlir::MLIRContext *context, fir::NameUniquer &uniquer)
+      : LLVMTypeConverter(context), kindMapping(context), uniquer(uniquer) {
+    addConversion([&](fir::BoxType box) { return convertBoxType(box); });
+    addConversion(
+        [&](fir::BoxCharType boxchar) { return convertBoxCharType(boxchar); });
+    addConversion(
+        [&](fir::BoxProcType boxproc) { return convertBoxProcType(boxproc); });
+    addConversion(
+        [&](fir::CharacterType charTy) { return convertCharType(charTy); });
+    addConversion([&](fir::CplxType cplx) {
+      return convertComplexType(cplx.getFKind());
+    });
+    addConversion(
+        [&](fir::RecordType derived) { return convertRecordType(derived); });
+    addConversion([&](fir::DimsType dims) {
+      return mlir::LLVM::LLVMType::getArrayTy(dimsType(), dims.getRank());
+    });
+    addConversion([&](fir::FieldType field) {
+      return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
+    });
+    addConversion([&](fir::HeapType heap) { return convertPointerLike(heap); });
+    addConversion([&](fir::IntType intr) { return convertIntegerType(intr); });
+    addConversion([&](fir::LenType field) {
+      return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
+    });
+    addConversion(
+        [&](fir::LogicalType logical) { return convertLogicalType(logical); });
+    addConversion(
+        [&](fir::PointerType pointer) { return convertPointerLike(pointer); });
+    addConversion(
+        [&](fir::RealType real) { return convertRealType(real.getFKind()); });
+    addConversion(
+        [&](fir::ReferenceType ref) { return convertPointerLike(ref); });
+    addConversion([&](fir::SequenceType sequence) {
+      return convertSequenceType(sequence);
+    });
+    addConversion([&](fir::TypeDescType tdesc) {
+      return convertTypeDescType(tdesc.getContext());
+    });
+    addConversion(
+        [&](mlir::TupleType tuple) { return convertTupleType(tuple); });
+    addConversion(
+        [&](mlir::ComplexType cmplx) { return convertComplexType(cmplx); });
+    addConversion([&](mlir::NoneType none) {
+      return mlir::LLVM::LLVMType::getStructTy(llvmDialect, {});
+    });
+  }
 
   // This returns the type of a single column. Rows are added by the caller.
   // fir.dims<r>  -->  llvm<"[r x [3 x i64]]">
@@ -95,7 +152,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   // This corresponds to the descriptor as defined ISO_Fortran_binding.h and the
   // addendum defined in descriptor.h.
   // FIXME: This code should be generated and follow SPOT
-  mlir::LLVM::LLVMType convertBoxType(BoxType box) {
+  mlir::LLVM::LLVMType convertBoxType(fir::BoxType box) {
     // (buffer*, ele-size, rank, type-descriptor, attribute, [dims])
     SmallVector<mlir::LLVM::LLVMType, 6> parts;
     mlir::Type ele = box.getEleTy();
@@ -123,7 +180,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   }
 
   // fir.boxchar<n>  -->  llvm<"{ ix*, i64 }">   where ix is kind mapping
-  mlir::LLVM::LLVMType convertBoxCharType(BoxCharType boxchar) {
+  mlir::LLVM::LLVMType convertBoxCharType(fir::BoxCharType boxchar) {
     auto ptrTy = convertCharType(boxchar.getEleTy()).getPointerTo();
     auto i64Ty = mlir::LLVM::LLVMType::getInt64Ty(llvmDialect);
     SmallVector<mlir::LLVM::LLVMType, 2> tuple{ptrTy, i64Ty};
@@ -131,7 +188,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   }
 
   // fir.boxproc<any>  -->  llvm<"{ any*, i8* }">
-  mlir::LLVM::LLVMType convertBoxProcType(BoxProcType boxproc) {
+  mlir::LLVM::LLVMType convertBoxProcType(fir::BoxProcType boxproc) {
     auto funcTy = convertType(boxproc.getEleTy());
     auto ptrTy = unwrap(funcTy).getPointerTo();
     auto i8Ty = mlir::LLVM::LLVMType::getInt8Ty(llvmDialect);
@@ -139,23 +196,23 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
   }
 
-  unsigned characterBitsize(CharacterType charTy) {
+  unsigned characterBitsize(fir::CharacterType charTy) {
     return kindMapping.getCharacterBitsize(charTy.getFKind());
   }
 
   // fir.char<n>  -->  llvm<"ix*">   where ix is scaled by kind mapping
-  mlir::LLVM::LLVMType convertCharType(CharacterType charTy) {
+  mlir::LLVM::LLVMType convertCharType(fir::CharacterType charTy) {
     return mlir::LLVM::LLVMType::getIntNTy(llvmDialect,
                                            characterBitsize(charTy));
   }
 
-  mlir::LLVM::LLVMType convertComplexPartType(KindTy kind) {
+  mlir::LLVM::LLVMType convertComplexPartType(fir::KindTy kind) {
     auto realID = kindMapping.getComplexTypeID(kind);
     return fromRealTypeID(realID, kind);
   }
 
   // fir.complex<n>  -->  llvm<"{ anyfloat, anyfloat }">
-  mlir::LLVM::LLVMType convertComplexType(KindTy kind) {
+  mlir::LLVM::LLVMType convertComplexType(fir::KindTy kind) {
     auto realTy = convertComplexPartType(kind);
     SmallVector<mlir::LLVM::LLVMType, 2> tuple{realTy, realTy};
     return mlir::LLVM::LLVMType::getStructTy(llvmDialect, tuple);
@@ -167,13 +224,13 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   }
 
   // fir.int<n>  -->  llvm.ix   where ix is a kind mapping
-  mlir::LLVM::LLVMType convertIntegerType(IntType intTy) {
+  mlir::LLVM::LLVMType convertIntegerType(fir::IntType intTy) {
     return mlir::LLVM::LLVMType::getIntNTy(
         llvmDialect, kindMapping.getIntegerBitsize(intTy.getFKind()));
   }
 
   // fir.logical<n>  -->  llvm.ix  where ix is a kind mapping
-  mlir::LLVM::LLVMType convertLogicalType(LogicalType boolTy) {
+  mlir::LLVM::LLVMType convertLogicalType(fir::LogicalType boolTy) {
     return mlir::LLVM::LLVMType::getIntNTy(
         llvmDialect, kindMapping.getLogicalBitsize(boolTy.getFKind()));
   }
@@ -185,12 +242,12 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
 
   // convert a front-end kind value to either a std or LLVM IR dialect type
   // fir.real<n>  -->  llvm.anyfloat  where anyfloat is a kind mapping
-  mlir::LLVM::LLVMType convertRealType(KindTy kind) {
+  mlir::LLVM::LLVMType convertRealType(fir::KindTy kind) {
     return fromRealTypeID(kindMapping.getRealTypeID(kind), kind);
   }
 
   // fir.type<name(p : TY'...){f : TY...}>  -->  llvm<"%name = { ty... }">
-  mlir::LLVM::LLVMType convertRecordType(RecordType derived) {
+  mlir::LLVM::LLVMType convertRecordType(fir::RecordType derived) {
     auto name{derived.getName()};
     // The cache is needed to keep a unique mapping from name -> StructType
     auto iter{identStructCache.find(name)};
@@ -206,7 +263,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   }
 
   // fir.array<c ... :any>  -->  llvm<"[...[c x any]]">
-  mlir::LLVM::LLVMType convertSequenceType(SequenceType seq) {
+  mlir::LLVM::LLVMType convertSequenceType(fir::SequenceType seq) {
     auto baseTy = unwrap(convertType(seq.getEleTy()));
     auto shape = seq.getShape();
     if (shape.size()) {
@@ -244,53 +301,9 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
     return mlir::LLVM::LLVMType::getInt8PtrTy(llvmDialect);
   }
 
-  /// Convert FIR types to LLVM IR dialect types
-  mlir::Type convertType(mlir::Type t) override {
-    if (auto box = t.dyn_cast<BoxType>())
-      return convertBoxType(box);
-    if (auto boxchar = t.dyn_cast<BoxCharType>())
-      return convertBoxCharType(boxchar);
-    if (auto boxproc = t.dyn_cast<BoxProcType>())
-      return convertBoxProcType(boxproc);
-    if (auto charTy = t.dyn_cast<CharacterType>())
-      return convertCharType(charTy);
-    if (auto cplx = t.dyn_cast<CplxType>())
-      return convertComplexType(cplx.getFKind());
-    if (auto derived = t.dyn_cast<RecordType>())
-      return convertRecordType(derived);
-    if (auto dims = t.dyn_cast<DimsType>())
-      return mlir::LLVM::LLVMType::getArrayTy(dimsType(), dims.getRank());
-    if (auto field = t.dyn_cast<FieldType>())
-      return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
-    if (auto heap = t.dyn_cast<HeapType>())
-      return convertPointerLike(heap);
-    if (auto integer = t.dyn_cast<IntType>())
-      return convertIntegerType(integer);
-    if (auto field = t.dyn_cast<LenType>())
-      return mlir::LLVM::LLVMType::getInt32Ty(llvmDialect);
-    if (auto logical = t.dyn_cast<LogicalType>())
-      return convertLogicalType(logical);
-    if (auto pointer = t.dyn_cast<fir::PointerType>())
-      return convertPointerLike(pointer);
-    if (auto real = t.dyn_cast<RealType>())
-      return convertRealType(real.getFKind());
-    if (auto ref = t.dyn_cast<ReferenceType>())
-      return convertPointerLike(ref);
-    if (auto sequence = t.dyn_cast<SequenceType>())
-      return convertSequenceType(sequence);
-    if (auto tdesc = t.dyn_cast<TypeDescType>())
-      return convertTypeDescType(tdesc.getContext());
-    if (auto tuple = t.dyn_cast<mlir::TupleType>())
-      return convertTupleType(tuple);
-    if (auto cmplx = t.dyn_cast<mlir::ComplexType>())
-      return convertComplexType(cmplx);
-    if (auto none = t.dyn_cast<mlir::NoneType>())
-      return mlir::LLVM::LLVMType::getStructTy(llvmDialect, {});
-    return LLVMTypeConverter::convertType(t);
-  }
-
   /// Convert llvm::Type::TypeID to mlir::LLVM::LLVMType
-  mlir::LLVM::LLVMType fromRealTypeID(llvm::Type::TypeID typeID, KindTy kind) {
+  mlir::LLVM::LLVMType fromRealTypeID(llvm::Type::TypeID typeID,
+                                      fir::KindTy kind) {
     switch (typeID) {
     case llvm::Type::TypeID::HalfTyID:
       return mlir::LLVM::LLVMType::getHalfTy(llvmDialect);
@@ -321,7 +334,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
     return wrappedLLVMType;
   }
 
-  NameUniquer &uniquer;
+  fir::NameUniquer &uniquer;
 };
 
 // instantiate static data member
@@ -438,7 +451,7 @@ struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
   }
 };
 
-mlir::LLVM::LLVMFuncOp getMalloc(AllocMemOp op,
+mlir::LLVM::LLVMFuncOp getMalloc(fir::AllocMemOp op,
                                  mlir::ConversionPatternRewriter &rewriter,
                                  mlir::LLVM::LLVMDialect *dialect) {
   auto module = op.getParentOfType<mlir::ModuleOp>();
@@ -454,13 +467,13 @@ mlir::LLVM::LLVMFuncOp getMalloc(AllocMemOp op,
 }
 
 /// convert to `call` to the runtime to `malloc` memory
-struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
+struct AllocMemOpConversion : public FIROpConversion<fir::AllocMemOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto heap = mlir::cast<AllocMemOp>(op);
+    auto heap = mlir::cast<fir::AllocMemOp>(op);
     auto ty = convertType(heap.getType());
     auto dialect = getDialect();
     auto mallocFunc = getMalloc(heap, rewriter, dialect);
@@ -479,7 +492,7 @@ struct AllocMemOpConversion : public FIROpConversion<AllocMemOp> {
 };
 
 /// obtain the free() function
-mlir::LLVM::LLVMFuncOp getFree(FreeMemOp op,
+mlir::LLVM::LLVMFuncOp getFree(fir::FreeMemOp op,
                                mlir::ConversionPatternRewriter &rewriter,
                                mlir::LLVM::LLVMDialect *dialect) {
   auto module = op.getParentOfType<mlir::ModuleOp>();
@@ -522,17 +535,17 @@ mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::LLVM::LLVMType ty,
 }
 
 /// convert to returning the first element of the box (any flavor)
-struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
+struct BoxAddrOpConversion : public FIROpConversion<fir::BoxAddrOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxaddr = mlir::cast<BoxAddrOp>(op);
+    auto boxaddr = mlir::cast<fir::BoxAddrOp>(op);
     auto a = operands[0];
     auto loc = boxaddr.getLoc();
     auto ty = convertType(boxaddr.getType());
-    if (auto argty = boxaddr.val().getType().dyn_cast<BoxType>()) {
+    if (auto argty = boxaddr.val().getType().dyn_cast<fir::BoxType>()) {
       auto c0 = genConstantOffset(loc, rewriter, 0);
       auto pty = unwrap(ty).getPointerTo();
       auto p = genGEP(loc, unwrap(pty), rewriter, a, c0, c0);
@@ -549,13 +562,13 @@ struct BoxAddrOpConversion : public FIROpConversion<BoxAddrOp> {
 };
 
 /// convert to an extractvalue for the 2nd part of the boxchar
-struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
+struct BoxCharLenOpConversion : public FIROpConversion<fir::BoxCharLenOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxchar = mlir::cast<BoxCharLenOp>(op);
+    auto boxchar = mlir::cast<fir::BoxCharLenOp>(op);
     auto a = operands[0];
     auto ty = convertType(boxchar.getType());
     auto ctx = boxchar.getContext();
@@ -566,13 +579,13 @@ struct BoxCharLenOpConversion : public FIROpConversion<BoxCharLenOp> {
 };
 
 /// convert to a triple set of GEPs and loads
-struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
+struct BoxDimsOpConversion : public FIROpConversion<fir::BoxDimsOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxdims = mlir::cast<BoxDimsOp>(op);
+    auto boxdims = mlir::cast<fir::BoxDimsOp>(op);
     auto a = operands[0];
     auto dim = operands[1];
     auto loc = boxdims.getLoc();
@@ -587,7 +600,7 @@ struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
   }
 
   mlir::LLVM::LoadOp
-  loadFromOffset(BoxDimsOp boxdims, mlir::Location loc, mlir::Value a,
+  loadFromOffset(fir::BoxDimsOp boxdims, mlir::Location loc, mlir::Value a,
                  mlir::LLVM::ConstantOp c0, mlir::LLVM::ConstantOp c7,
                  mlir::Value dim, int off,
                  mlir::ConversionPatternRewriter &rewriter) const {
@@ -599,13 +612,13 @@ struct BoxDimsOpConversion : public FIROpConversion<BoxDimsOp> {
   }
 };
 
-struct BoxEleSizeOpConversion : public FIROpConversion<BoxEleSizeOp> {
+struct BoxEleSizeOpConversion : public FIROpConversion<fir::BoxEleSizeOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxelesz = mlir::cast<BoxEleSizeOp>(op);
+    auto boxelesz = mlir::cast<fir::BoxEleSizeOp>(op);
     auto a = operands[0];
     auto loc = boxelesz.getLoc();
     auto c0 = genConstantOffset(loc, rewriter, 0);
@@ -617,13 +630,13 @@ struct BoxEleSizeOpConversion : public FIROpConversion<BoxEleSizeOp> {
   }
 };
 
-struct BoxIsAllocOpConversion : public FIROpConversion<BoxIsAllocOp> {
+struct BoxIsAllocOpConversion : public FIROpConversion<fir::BoxIsAllocOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxisalloc = mlir::cast<BoxIsAllocOp>(op);
+    auto boxisalloc = mlir::cast<fir::BoxIsAllocOp>(op);
     auto a = operands[0];
     auto loc = boxisalloc.getLoc();
     auto ity = lowering.offsetType();
@@ -640,13 +653,13 @@ struct BoxIsAllocOpConversion : public FIROpConversion<BoxIsAllocOp> {
   }
 };
 
-struct BoxIsArrayOpConversion : public FIROpConversion<BoxIsArrayOp> {
+struct BoxIsArrayOpConversion : public FIROpConversion<fir::BoxIsArrayOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxisarray = mlir::cast<BoxIsArrayOp>(op);
+    auto boxisarray = mlir::cast<fir::BoxIsArrayOp>(op);
     auto a = operands[0];
     auto loc = boxisarray.getLoc();
     auto c0 = genConstantOffset(loc, rewriter, 0);
@@ -660,13 +673,13 @@ struct BoxIsArrayOpConversion : public FIROpConversion<BoxIsArrayOp> {
   }
 };
 
-struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
+struct BoxIsPtrOpConversion : public FIROpConversion<fir::BoxIsPtrOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxisptr = mlir::cast<BoxIsPtrOp>(op);
+    auto boxisptr = mlir::cast<fir::BoxIsPtrOp>(op);
     auto a = operands[0];
     auto loc = boxisptr.getLoc();
     auto ty = convertType(boxisptr.getType());
@@ -684,13 +697,13 @@ struct BoxIsPtrOpConversion : public FIROpConversion<BoxIsPtrOp> {
   }
 };
 
-struct BoxProcHostOpConversion : public FIROpConversion<BoxProcHostOp> {
+struct BoxProcHostOpConversion : public FIROpConversion<fir::BoxProcHostOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxprochost = mlir::cast<BoxProcHostOp>(op);
+    auto boxprochost = mlir::cast<fir::BoxProcHostOp>(op);
     auto a = operands[0];
     auto ty = convertType(boxprochost.getType());
     auto ctx = boxprochost.getContext();
@@ -701,13 +714,13 @@ struct BoxProcHostOpConversion : public FIROpConversion<BoxProcHostOp> {
   }
 };
 
-struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
+struct BoxRankOpConversion : public FIROpConversion<fir::BoxRankOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxrank = mlir::cast<BoxRankOp>(op);
+    auto boxrank = mlir::cast<fir::BoxRankOp>(op);
     auto a = operands[0];
     auto loc = boxrank.getLoc();
     auto ty = convertType(boxrank.getType());
@@ -721,13 +734,13 @@ struct BoxRankOpConversion : public FIROpConversion<BoxRankOp> {
   }
 };
 
-struct BoxTypeDescOpConversion : public FIROpConversion<BoxTypeDescOp> {
+struct BoxTypeDescOpConversion : public FIROpConversion<fir::BoxTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxtypedesc = mlir::cast<BoxTypeDescOp>(op);
+    auto boxtypedesc = mlir::cast<fir::BoxTypeDescOp>(op);
     auto a = operands[0];
     auto loc = boxtypedesc.getLoc();
     auto ty = convertType(boxtypedesc.getType());
@@ -850,13 +863,13 @@ struct CmpfOpConversion : public FIROpConversion<fir::CmpfOp> {
   }
 };
 
-struct ConstcOpConversion : public FIROpConversion<ConstcOp> {
+struct ConstcOpConversion : public FIROpConversion<fir::ConstcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto conc = mlir::cast<ConstcOp>(op);
+    auto conc = mlir::cast<fir::ConstcOp>(op);
     auto loc = conc.getLoc();
     auto ctx = conc.getContext();
     auto ty = convertType(conc.getType());
@@ -880,13 +893,13 @@ struct ConstcOpConversion : public FIROpConversion<ConstcOp> {
   }
 };
 
-struct ConstfOpConversion : public FIROpConversion<ConstfOp> {
+struct ConstfOpConversion : public FIROpConversion<fir::ConstfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto conf = mlir::cast<ConstfOp>(op);
+    auto conf = mlir::cast<fir::ConstfOp>(op);
     auto ty = convertType(conf.getType());
     auto val = conf.getValue();
     rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(conf, ty, val);
@@ -895,13 +908,13 @@ struct ConstfOpConversion : public FIROpConversion<ConstfOp> {
 };
 
 /// convert value of from-type to value of to-type
-struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
+struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto convert = mlir::cast<ConvertOp>(op);
+    auto convert = mlir::cast<fir::ConvertOp>(op);
     auto fromTy_ = convertType(convert.value().getType());
     auto fromTy = unwrap(fromTy_);
     auto toTy_ = convertType(convert.res().getType());
@@ -958,13 +971,13 @@ struct ConvertOpConversion : public FIROpConversion<ConvertOp> {
 };
 
 /// virtual call to a method in a dispatch table
-struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
+struct DispatchOpConversion : public FIROpConversion<fir::DispatchOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto dispatch = mlir::cast<DispatchOp>(op);
+    auto dispatch = mlir::cast<fir::DispatchOp>(op);
     auto ty = convertType(dispatch.getFunctionType());
     // get the table, lookup the method, fetch the func-ptr
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(dispatch, ty, operands,
@@ -975,39 +988,40 @@ struct DispatchOpConversion : public FIROpConversion<DispatchOp> {
 };
 
 /// dispatch table for a Fortran derived type
-struct DispatchTableOpConversion : public FIROpConversion<DispatchTableOp> {
+struct DispatchTableOpConversion
+    : public FIROpConversion<fir::DispatchTableOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto disptable = mlir::cast<DispatchTableOp>(op);
+    auto disptable = mlir::cast<fir::DispatchTableOp>(op);
     TODO(disptable);
     return matchSuccess();
   }
 };
 
 /// entry in a dispatch table; binds a method-name to a function
-struct DTEntryOpConversion : public FIROpConversion<DTEntryOp> {
+struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto dtentry = mlir::cast<DTEntryOp>(op);
+    auto dtentry = mlir::cast<fir::DTEntryOp>(op);
     TODO(dtentry);
     return matchSuccess();
   }
 };
 
 /// create a CHARACTER box
-struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
+struct EmboxCharOpConversion : public FIROpConversion<fir::EmboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto emboxchar = mlir::cast<EmboxCharOp>(op);
+    auto emboxchar = mlir::cast<fir::EmboxCharOp>(op);
     auto a = operands[0];
     auto b = operands[1];
     auto loc = emboxchar.getLoc();
@@ -1024,13 +1038,13 @@ struct EmboxCharOpConversion : public FIROpConversion<EmboxCharOp> {
 };
 
 /// create a generic box on a memory reference
-struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
+struct EmboxOpConversion : public FIROpConversion<fir::EmboxOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto embox = mlir::cast<EmboxOp>(op);
+    auto embox = mlir::cast<fir::EmboxOp>(op);
     auto loc = embox.getLoc();
     auto dialect = getDialect();
     auto ty = unwrap(convertType(embox.getType()));
@@ -1094,13 +1108,13 @@ struct EmboxOpConversion : public FIROpConversion<EmboxOp> {
 };
 
 /// create a procedure pointer box
-struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
+struct EmboxProcOpConversion : public FIROpConversion<fir::EmboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto emboxproc = mlir::cast<EmboxProcOp>(op);
+    auto emboxproc = mlir::cast<fir::EmboxProcOp>(op);
     auto a = operands[0];
     auto b = operands[1];
     auto loc = emboxproc.getLoc();
@@ -1116,18 +1130,6 @@ struct EmboxProcOpConversion : public FIROpConversion<EmboxProcOp> {
   }
 };
 
-/// return true if all `Value`s in `operands` are `ConstantOp`s
-bool allConstants(OperandTy operands) {
-  for (auto opnd : operands) {
-    if (auto defop = opnd.getDefiningOp())
-      if (dyn_cast<mlir::LLVM::ConstantOp>(defop) ||
-          dyn_cast<mlir::ConstantOp>(defop))
-        continue;
-    return false;
-  }
-  return true;
-}
-
 mlir::Attribute getValue(mlir::Value value) {
   assert(value.getDefiningOp());
   if (auto v = dyn_cast<mlir::LLVM::ConstantOp>(value.getDefiningOp()))
@@ -1150,9 +1152,9 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto extractVal = mlir::cast<ExtractValueOp>(op);
+    auto extractVal = mlir::cast<fir::ExtractValueOp>(op);
     auto ty = convertType(extractVal.getType());
-    assert(allConstants(operands.drop_front(1)));
+    assert(fir::allConstants(operands.drop_front(1)));
     // since all indices are constants use LLVM's extractvalue instruction
     SmallVector<mlir::Attribute, 8> attrs;
     for (std::size_t i = 1, end{operands.size()}; i < end; ++i)
@@ -1166,15 +1168,15 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
 
 /// InsertValue is the generalized instruction for the composition of new
 /// aggregate type values.
-struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
+struct InsertValueOpConversion : public FIROpConversion<fir::InsertValueOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto insertVal = cast<InsertValueOp>(op);
+    auto insertVal = cast<fir::InsertValueOp>(op);
     auto ty = convertType(insertVal.getType());
-    assert(allConstants(operands.drop_front(2)));
+    assert(fir::allConstants(operands.drop_front(2)));
     // since all indices must be constants use LLVM's insertvalue instruction
     SmallVector<mlir::Attribute, 8> attrs;
     for (std::size_t i = 2, end{operands.size()}; i < end; ++i)
@@ -1190,31 +1192,31 @@ struct InsertValueOpConversion : public FIROpConversion<InsertValueOp> {
 bool noFieldIndexOps(mlir::Operation::operand_range operands) {
   for (auto opnd : operands) {
     if (auto defop = opnd.getDefiningOp())
-      if (dyn_cast<FieldIndexOp>(defop))
+      if (dyn_cast<fir::FieldIndexOp>(defop))
         return false;
   }
   return true;
 }
 
 /// convert to reference to a reference to a subobject
-struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
+struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto coor = mlir::cast<CoordinateOp>(op);
+    auto coor = mlir::cast<fir::CoordinateOp>(op);
     auto ty = convertType(coor.getType());
     auto loc = coor.getLoc();
     mlir::Value base = operands[0];
     auto c0 = genConstantIndex(loc, lowering.indexType(), rewriter, 0);
 
     // The base can be a boxed reference or a raw reference
-    if (auto boxTy = coor.ref().getType().dyn_cast<BoxType>()) {
+    if (auto boxTy = coor.ref().getType().dyn_cast<fir::BoxType>()) {
       if (coor.getNumOperands() == 2) {
         auto coorPtr = *coor.coor().begin();
         auto s = coorPtr.getDefiningOp();
-        if (s && isa<LenParamIndexOp>(s)) {
+        if (s && isa<fir::LenParamIndexOp>(s)) {
           mlir::Value lenParam = operands[1]; // byte offset
           auto vty = voidPtrTy();
           auto bc = rewriter.create<mlir::LLVM::BitcastOp>(loc, vty, base);
@@ -1242,8 +1244,8 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     }
 
     // lower the field index ops by walking the indices
-    auto bty = coor.ref().getType().cast<BoxType>();
-    mlir::Type baseTy = ReferenceType::get(bty.getEleTy());
+    auto bty = coor.ref().getType().cast<fir::BoxType>();
+    mlir::Type baseTy = fir::ReferenceType::get(bty.getEleTy());
     SmallVector<mlir::Value, 8> args{c0};
     args.append(coor.coor().begin(), coor.coor().end());
 
@@ -1253,7 +1255,7 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
     for (std::size_t i = 0, sz{offs.size()}; i != sz; ++i) {
       assert(pos <= i);
       if (auto defop = args[i].getDefiningOp())
-        if (auto field = dyn_cast<FieldIndexOp>(defop)) {
+        if (auto field = dyn_cast<fir::FieldIndexOp>(defop)) {
           auto memTy = unwrap(convertType(baseTy)).getPointerTo();
           mlir::Value gep = retval;
           if (i - pos > 0)
@@ -1262,22 +1264,22 @@ struct CoordinateOpConversion : public FIROpConversion<CoordinateOp> {
               rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy(), gep);
           auto gep_ = genGEP(loc, voidPtrTy(), rewriter, bc, offs[i]);
           pos = i + 1;
-          baseTy = baseTy.cast<RecordType>().getType(field.field_id());
+          baseTy = baseTy.cast<fir::RecordType>().getType(field.field_id());
           retval = rewriter.create<mlir::LLVM::BitcastOp>(
               loc, convertType(baseTy), gep_);
           continue;
         }
-      if (auto ptrTy = baseTy.dyn_cast<ReferenceType>()) {
+      if (auto ptrTy = baseTy.dyn_cast<fir::ReferenceType>()) {
         baseTy = ptrTy.getEleTy();
       } else if (auto ptrTy = baseTy.dyn_cast<fir::PointerType>()) {
         baseTy = ptrTy.getEleTy();
-      } else if (auto ptrTy = baseTy.dyn_cast<HeapType>()) {
+      } else if (auto ptrTy = baseTy.dyn_cast<fir::HeapType>()) {
         baseTy = ptrTy.getEleTy();
-      } else if (auto arrTy = baseTy.dyn_cast<SequenceType>()) {
+      } else if (auto arrTy = baseTy.dyn_cast<fir::SequenceType>()) {
         // FIXME: unchecked advance over array dims
         i += arrTy.getDimension() - 1;
         baseTy = arrTy.getEleTy();
-      } else if (auto strTy = baseTy.dyn_cast<RecordType>()) {
+      } else if (auto strTy = baseTy.dyn_cast<fir::RecordType>()) {
         baseTy = strTy.getType(getIntValue(offs[i]));
       } else if (auto strTy = baseTy.dyn_cast<mlir::TupleType>()) {
         baseTy = strTy.getType(getIntValue(offs[i]));
@@ -1316,7 +1318,7 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto field = mlir::cast<FieldIndexOp>(op);
+    auto field = mlir::cast<fir::FieldIndexOp>(op);
     // call the compiler generated function to determine the byte offset of
     // the field at runtime
     auto symAttr =
@@ -1329,10 +1331,11 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   }
 
   // constructing the name of the method
-  inline static std::string methodName(FieldIndexOp field) {
+  inline static std::string methodName(fir::FieldIndexOp field) {
     Twine fldName = field.field_id();
     // note: using std::string to dodge a bug in g++ 7.4.0
-    std::string tyName = field.on_type().cast<RecordType>().getName().str();
+    std::string tyName =
+        field.on_type().cast<fir::RecordType>().getName().str();
     Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
     return methodName.str();
   }
@@ -1346,14 +1349,14 @@ struct LenParamIndexOpConversion
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto lenp = mlir::cast<LenParamIndexOp>(op);
+    auto lenp = mlir::cast<fir::LenParamIndexOp>(op);
     auto ity = lowering.indexType();
     auto onty = lenp.getOnType();
     // size of portable descriptor
     const unsigned boxsize = 24; // FIXME
     unsigned offset = boxsize;
     // add the size of the rows of triples
-    if (auto arr = onty.dyn_cast<SequenceType>()) {
+    if (auto arr = onty.dyn_cast<fir::SequenceType>()) {
       offset += 3 * arr.getDimension();
     }
     // advance over some addendum fields
@@ -1368,7 +1371,7 @@ struct LenParamIndexOpConversion
 };
 
 /// lower the fir.end operation to a null (erasing it)
-struct FirEndOpConversion : public FIROpConversion<FirEndOp> {
+struct FirEndOpConversion : public FIROpConversion<fir::FirEndOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
@@ -1382,14 +1385,14 @@ struct FirEndOpConversion : public FIROpConversion<FirEndOp> {
 /// lower a gendims operation into a sequence of writes to a temp
 /// TODO: should this be returning a value or a ref? A !fir.dims object has
 /// very restricted application
-struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
+struct GenDimsOpConversion : public FIROpConversion<fir::GenDimsOp> {
   using FIROpConversion::FIROpConversion;
 
   // gendims(args:index, ...) ==> %v = ... : [size x <3 x index>]
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto gendims = mlir::cast<GenDimsOp>(op);
+    auto gendims = mlir::cast<fir::GenDimsOp>(op);
     auto loc = gendims.getLoc();
     auto ty = convertType(gendims.getType());
     auto ptrTy = unwrap(ty).getPointerTo();
@@ -1422,13 +1425,13 @@ struct GenDimsOpConversion : public FIROpConversion<GenDimsOp> {
 };
 
 /// lower a type descriptor to a global constant
-struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
+struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto gentypedesc = mlir::cast<GenTypeDescOp>(op);
+    auto gentypedesc = mlir::cast<fir::GenTypeDescOp>(op);
     auto loc = gentypedesc.getLoc();
     auto inTy = gentypedesc.getInType();
     auto name = consName(rewriter, inTy);
@@ -1443,9 +1446,9 @@ struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
 
   std::string consName(mlir::ConversionPatternRewriter &rewriter,
                        mlir::Type type) const {
-    if (auto d = type.dyn_cast<RecordType>()) {
+    if (auto d = type.dyn_cast<fir::RecordType>()) {
       auto name = d.getName();
-      auto pair = NameUniquer::deconstruct(name);
+      auto pair = fir::NameUniquer::deconstruct(name);
       return lowering.uniquer.doTypeDescriptor(
           pair.second.modules, pair.second.host, pair.second.name,
           pair.second.kinds);
@@ -1455,13 +1458,13 @@ struct GenTypeDescOpConversion : public FIROpConversion<GenTypeDescOp> {
   }
 };
 
-struct GlobalLenOpConversion : public FIROpConversion<GlobalLenOp> {
+struct GlobalLenOpConversion : public FIROpConversion<fir::GlobalLenOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto globalentry = mlir::cast<GlobalLenOp>(op);
+    auto globalentry = mlir::cast<fir::GlobalLenOp>(op);
     TODO(globalentry);
     return matchSuccess();
   }
@@ -1517,13 +1520,13 @@ struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
 };
 
 // FIXME: how do we want to enforce this in LLVM-IR?
-struct NoReassocOpConversion : public FIROpConversion<NoReassocOp> {
+struct NoReassocOpConversion : public FIROpConversion<fir::NoReassocOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto noreassoc = mlir::cast<NoReassocOp>(op);
+    auto noreassoc = mlir::cast<fir::NoReassocOp>(op);
     noreassoc.replaceAllUsesWith(operands[0]);
     rewriter.replaceOp(noreassoc, {});
     return matchSuccess();
@@ -1546,7 +1549,7 @@ void genCaseLadderStep(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
 /// Conversion of `fir.select_case`
 ///
 /// TODO: lowering of CHARACTER type cases
-struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
+struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
@@ -1554,9 +1557,9 @@ struct SelectCaseOpConversion : public FIROpConversion<SelectCaseOp> {
                   ArrayRef<mlir::Block *> destinations,
                   ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto selectcase = mlir::cast<SelectCaseOp>(op);
+    auto selectcase = mlir::cast<fir::SelectCaseOp>(op);
     auto conds = selectcase.getNumConditions();
-    auto attrName = SelectCaseOp::AttrName;
+    auto attrName = fir::SelectCaseOp::AttrName;
     auto caseAttr = selectcase.getAttrOfType<mlir::ArrayAttr>(attrName);
     auto cases = caseAttr.getValue();
     // Type can be CHARACTER, INTEGER, or LOGICAL (C1145)
@@ -1670,7 +1673,7 @@ struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
 };
 
 /// conversion of fir::SelectRankOp to an if-then-else ladder
-struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
+struct SelectRankOpConversion : public FIROpConversion<fir::SelectRankOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
@@ -1685,7 +1688,7 @@ struct SelectRankOpConversion : public FIROpConversion<SelectRankOp> {
 };
 
 // SelectTypeOp should have already been lowered
-struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
+struct SelectTypeOpConversion : public FIROpConversion<fir::SelectTypeOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
@@ -1693,7 +1696,7 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
                   ArrayRef<mlir::Block *> destinations,
                   ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto selecttype = mlir::cast<SelectTypeOp>(op);
+    auto selecttype = mlir::cast<fir::SelectTypeOp>(op);
     TODO(selecttype);
     return matchSuccess();
   }
@@ -1723,13 +1726,13 @@ mlir::LLVM::ExtractValueOp genExtractValueWithIndex(
 }
 
 // unbox a CHARACTER box value, yielding its components
-struct UnboxCharOpConversion : public FIROpConversion<UnboxCharOp> {
+struct UnboxCharOpConversion : public FIROpConversion<fir::UnboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unboxchar = mlir::cast<UnboxCharOp>(op);
+    auto unboxchar = mlir::cast<fir::UnboxCharOp>(op);
     auto *ctx = unboxchar.getContext();
     auto loc = unboxchar.getLoc();
     auto tuple = operands[0];
@@ -1759,13 +1762,13 @@ mlir::LLVM::LoadOp genLoadWithIndex(mlir::Location loc, mlir::Value tuple,
 }
 
 // unbox a generic box reference, yielding its components
-struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
+struct UnboxOpConversion : public FIROpConversion<fir::UnboxOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unbox = mlir::cast<UnboxOp>(op);
+    auto unbox = mlir::cast<fir::UnboxOp>(op);
     auto loc = unbox.getLoc();
     auto tuple = operands[0];
     auto ty = unwrap(tuple.getType());
@@ -1788,13 +1791,13 @@ struct UnboxOpConversion : public FIROpConversion<UnboxOp> {
 };
 
 // unbox a procedure box value, yielding its components
-struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
+struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unboxproc = mlir::cast<UnboxProcOp>(op);
+    auto unboxproc = mlir::cast<fir::UnboxProcOp>(op);
     auto *ctx = unboxproc.getContext();
     auto loc = unboxproc.getLoc();
     auto tuple = operands[0];
@@ -1811,13 +1814,13 @@ struct UnboxProcOpConversion : public FIROpConversion<UnboxProcOp> {
 };
 
 // convert to LLVM IR dialect `undef`
-struct UndefOpConversion : public FIROpConversion<UndefOp> {
+struct UndefOpConversion : public FIROpConversion<fir::UndefOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto undef = mlir::cast<UndefOp>(op);
+    auto undef = mlir::cast<fir::UndefOp>(op);
     rewriter.replaceOpWithNewOp<mlir::LLVM::UndefOp>(
         undef, convertType(undef.getType()));
     return matchSuccess();
@@ -1825,13 +1828,13 @@ struct UndefOpConversion : public FIROpConversion<UndefOp> {
 };
 
 // convert to LLVM IR dialect `unreachable`
-struct UnreachableOpConversion : public FIROpConversion<UnreachableOp> {
+struct UnreachableOpConversion : public FIROpConversion<fir::UnreachableOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unreach = mlir::cast<UnreachableOp>(op);
+    auto unreach = mlir::cast<fir::UnreachableOp>(op);
     rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(
         unreach, operands, None, None, unreach.getAttrs());
     return matchSuccess();
@@ -2085,10 +2088,10 @@ struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
 /// This pass lowers all FIR dialect operations to LLVM IR dialect.  An
 /// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
 struct FIRToLLVMLoweringPass : public mlir::ModulePass<FIRToLLVMLoweringPass> {
-  FIRToLLVMLoweringPass(NameUniquer &uniquer) : uniquer{uniquer} {}
+  FIRToLLVMLoweringPass(fir::NameUniquer &uniquer) : uniquer{uniquer} {}
 
   void runOnModule() override {
-    if (ClDisableFirToLLVMIR)
+    if (disableFirToLLVMIR)
       return;
 
     auto *context{&getContext()};
@@ -2139,13 +2142,13 @@ struct FIRToLLVMLoweringPass : public mlir::ModulePass<FIRToLLVMLoweringPass> {
 
 private:
   void genDispatchTableMap() {
-    for (auto dt : getModule().getOps<DispatchTableOp>()) {
+    for (auto dt : getModule().getOps<fir::DispatchTableOp>()) {
       // FIXME
       (void)dt;
     }
   }
 
-  NameUniquer &uniquer;
+  fir::NameUniquer &uniquer;
 };
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
@@ -2153,21 +2156,21 @@ struct LLVMIRLoweringPass : public mlir::ModulePass<LLVMIRLoweringPass> {
   LLVMIRLoweringPass(raw_ostream &output) : output{output} {}
 
   void runOnModule() override {
-    if (ClDisableLLVM)
+    if (disableLLVM)
       return;
 
-    if (auto llvmModule{mlir::translateModuleToLLVMIR(getModule())}) {
+    if (auto llvmModule = mlir::translateModuleToLLVMIR(getModule())) {
       output << *llvmModule;
       return;
     }
 
-    auto ctxt{getModule().getContext()};
+    auto *ctxt = getModule().getContext();
     mlir::emitError(mlir::UnknownLoc::get(ctxt), "could not emit LLVM-IR\n");
     signalPassFailure();
   }
 
 private:
-  raw_ostream &output;
+  llvm::raw_ostream &output;
 };
 
 } // namespace
@@ -2178,7 +2181,7 @@ fir::createFIRToLLVMPass(fir::NameUniquer &nameUniquer) {
 }
 
 std::unique_ptr<mlir::Pass>
-fir::createLLVMDialectToLLVMPass(raw_ostream &output) {
+fir::createLLVMDialectToLLVMPass(llvm::raw_ostream &output) {
   return std::make_unique<LLVMIRLoweringPass>(output);
 }
 
@@ -2186,6 +2189,6 @@ fir::createLLVMDialectToLLVMPass(raw_ostream &output) {
 static mlir::PassRegistration<FIRToLLVMLoweringPass>
     passLowFIR("fir-to-llvmir",
                "Conversion of the FIR dialect to the LLVM-IR dialect", [] {
-                 NameUniquer dummy;
+                 fir::NameUniquer dummy;
                  return std::make_unique<FIRToLLVMLoweringPass>(dummy);
                });
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/optimizer/Dialect/FIROps.cpp
index 467eaf73f503..9a6ad1e17cc7 100644
--- a/lib/optimizer/Dialect/FIROps.cpp
+++ b/lib/optimizer/Dialect/FIROps.cpp
@@ -10,7 +10,7 @@
 #include "flang/optimizer/Dialect/FIRAttr.h"
 #include "flang/optimizer/Dialect/FIROpsSupport.h"
 #include "flang/optimizer/Dialect/FIRType.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
diff --git a/lib/optimizer/Dialect/FIRType.cpp b/lib/optimizer/Dialect/FIRType.cpp
index fc1789aa98fb..358e8ccf9765 100644
--- a/lib/optimizer/Dialect/FIRType.cpp
+++ b/lib/optimizer/Dialect/FIRType.cpp
@@ -932,8 +932,7 @@ mlir::AffineMapAttr fir::BoxType::getLayoutMap() const {
 }
 
 mlir::LogicalResult fir::BoxType::verifyConstructionInvariants(
-    llvm::Optional<mlir::Location>, mlir::MLIRContext *ctx, mlir::Type eleTy,
-    mlir::AffineMapAttr map) {
+    const mlir::AttributeStorage *, mlir::Type eleTy, mlir::AffineMapAttr map) {
   // TODO
   return mlir::success();
 }
@@ -958,9 +957,9 @@ mlir::Type fir::BoxProcType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-mlir::LogicalResult fir::BoxProcType::verifyConstructionInvariants(
-    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
-    mlir::Type eleTy) {
+mlir::LogicalResult
+fir::BoxProcType::verifyConstructionInvariants(const mlir::AttributeStorage *,
+                                               mlir::Type eleTy) {
   if (eleTy.isa<mlir::FunctionType>() || eleTy.isa<ReferenceType>())
     return mlir::success();
   return mlir::failure();
@@ -977,8 +976,7 @@ mlir::Type fir::ReferenceType::getEleTy() const {
 }
 
 mlir::LogicalResult fir::ReferenceType::verifyConstructionInvariants(
-    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
-    mlir::Type eleTy) {
+    const mlir::AttributeStorage *context, mlir::Type eleTy) {
   if (eleTy.isa<DimsType>() || eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
       eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
     return mlir::failure();
@@ -1000,8 +998,7 @@ mlir::Type fir::PointerType::getEleTy() const {
 }
 
 mlir::LogicalResult fir::PointerType::verifyConstructionInvariants(
-    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
-    mlir::Type eleTy) {
+    const mlir::AttributeStorage *context, mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
@@ -1026,8 +1023,7 @@ mlir::Type fir::HeapType::getEleTy() const {
 }
 
 mlir::LogicalResult
-fir::HeapType::verifyConstructionInvariants(llvm::Optional<mlir::Location> loc,
-                                            mlir::MLIRContext *context,
+fir::HeapType::verifyConstructionInvariants(const mlir::AttributeStorage *,
                                             mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
@@ -1059,7 +1055,7 @@ SequenceType::Shape fir::SequenceType::getShape() const {
 }
 
 mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
-    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
+    const mlir::AttributeStorage *attributeStorage,
     const SequenceType::Shape &shape, mlir::Type eleTy,
     mlir::AffineMapAttr map) {
   // DIMENSION attribute can only be applied to an intrinsic or record type
@@ -1068,6 +1064,7 @@ mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
       eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>()) {
+    auto context = attributeStorage->getDialect().getContext();
     mlir::emitError(mlir::UnknownLoc::get(context),
                     "cannot build an array of this element type: ")
         << eleTy << '\n';
@@ -1123,8 +1120,7 @@ detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
 }
 
 mlir::LogicalResult
-fir::RecordType::verifyConstructionInvariants(llvm::Optional<mlir::Location>,
-                                              mlir::MLIRContext *context,
+fir::RecordType::verifyConstructionInvariants(const mlir::AttributeStorage *,
                                               llvm::StringRef name) {
   if (name.size() == 0)
     return mlir::failure();
@@ -1150,9 +1146,9 @@ TypeDescType fir::TypeDescType::get(mlir::Type ofType) {
 
 mlir::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
 
-mlir::LogicalResult fir::TypeDescType::verifyConstructionInvariants(
-    llvm::Optional<mlir::Location> loc, mlir::MLIRContext *context,
-    mlir::Type eleTy) {
+mlir::LogicalResult
+fir::TypeDescType::verifyConstructionInvariants(const mlir::AttributeStorage *,
+                                                mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
diff --git a/lib/optimizer/StdConverter.cpp b/lib/optimizer/StdConverter.cpp
index e82490ff5936..b202d3a045b4 100644
--- a/lib/optimizer/StdConverter.cpp
+++ b/lib/optimizer/StdConverter.cpp
@@ -13,7 +13,7 @@
 #include "flang/optimizer/Dialect/FIRType.h"
 #include "flang/optimizer/Support/KindMapping.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
@@ -40,16 +40,23 @@ class FIRToStdTypeConverter : public mlir::TypeConverter {
 public:
   using TypeConverter::TypeConverter;
 
-  explicit FIRToStdTypeConverter(KindMapping &kindMap) : kindMap{kindMap} {}
+  explicit FIRToStdTypeConverter(KindMapping &map) : kindMap{map} {
+    addConversion([&](CplxType type) {
+      return mlir::ComplexType::get(toFloatType(type.getFKind()));
+    });
+    addConversion([&](RealType type) { return toFloatType(type.getFKind()); });
+    addConversion([&](IntType type) { return toIntegerType(type.getFKind()); });
+  }
 
-  // convert front-end REAL kind value to a std dialect type, if possible
-  static mlir::Type kindToRealType(KindMapping &kindMap, KindTy kind) {
+private:
+  mlir::Type toFloatType(KindTy kind) {
     auto *ctx = kindMap.getContext();
     switch (kindMap.getRealTypeID(kind)) {
     case llvm::Type::TypeID::HalfTyID:
       return mlir::FloatType::getF16(ctx);
 #if 0
-    // FIXME: there is no BF16 type in LLVM yet
+    // TODO: there is no BF16 type in LLVM yet, so add this when one becomes
+    // available
     case llvm::Type::TypeID:: FIXME TyID:
       return mlir::FloatType::getBF16(ctx);
 #endif
@@ -58,26 +65,19 @@ class FIRToStdTypeConverter : public mlir::TypeConverter {
     case llvm::Type::TypeID::DoubleTyID:
       return mlir::FloatType::getF64(ctx);
     case llvm::Type::TypeID::X86_FP80TyID: // MLIR does not support yet
-    case llvm::Type::TypeID::FP128TyID:    // MLIR does not support yet
+      [[fallthrough]];
+    case llvm::Type::TypeID::FP128TyID: // MLIR does not support yet
+      [[fallthrough]];
     default:
       return RealType::get(ctx, kind);
     }
   }
 
-  /// Convert some FIR types to MLIR standard dialect types
-  mlir::Type convertType(mlir::Type t) override {
-    // To lower types, we have to convert everything that uses these types...
-    if (auto cplx = t.dyn_cast<CplxType>())
-      return mlir::ComplexType::get(kindToRealType(kindMap, cplx.getFKind()));
-    if (auto integer = t.dyn_cast<IntType>())
-      return mlir::IntegerType::get(integer.getFKind() * 8,
-                                    integer.getContext());
-    if (auto real = t.dyn_cast<RealType>())
-      return kindToRealType(kindMap, real.getFKind());
-    return t;
+  mlir::Type toIntegerType(KindTy kind) {
+    return mlir::IntegerType::get(kindMap.getIntegerBitsize(kind),
+                                  kindMap.getContext());
   }
 
-private:
   KindMapping &kindMap;
 };
 
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/optimizer/Transforms/MemToReg.cpp
index f3f2f1e04449..ecf9d04c790c 100644
--- a/lib/optimizer/Transforms/MemToReg.cpp
+++ b/lib/optimizer/Transforms/MemToReg.cpp
@@ -11,7 +11,7 @@
 #include "flang/optimizer/Dialect/FIROps.h"
 #include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/optimizer/Transforms/RewriteLoop.cpp b/lib/optimizer/Transforms/RewriteLoop.cpp
index 3674dd08435f..002cb514a2cd 100644
--- a/lib/optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/optimizer/Transforms/RewriteLoop.cpp
@@ -11,7 +11,7 @@
 #include "flang/optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/CommandLine.h"
@@ -153,7 +153,7 @@ class LoopFirEndConv : public mlir::OpRewritePattern<FirEndOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(FirEndOp op, mlir::PatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<mlir::loop::TerminatorOp>(op);
+    rewriter.replaceOpWithNewOp<mlir::loop::YieldOp>(op);
     return matchSuccess();
   }
 };
diff --git a/tools/f18/CMakeLists.txt b/tools/f18/CMakeLists.txt
index 553ec78a0c7b..5a65bdcc2bc8 100644
--- a/tools/f18/CMakeLists.txt
+++ b/tools/f18/CMakeLists.txt
@@ -1,3 +1,8 @@
+file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
+file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+
 add_llvm_tool(f18
   dump.cpp
   f18.cpp

From 6b87cb915ce687159f9d3e60f8b30d0b5804fb82 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 24 Feb 2020 15:52:17 -0800
Subject: [PATCH 193/345] adding descriptions

---
 include/flang/optimizer/Dialect/FIROps.td | 114 +++++++++++++++++-----
 1 file changed, 90 insertions(+), 24 deletions(-)

diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index 310008df4caa..5d3f1adc38ad 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -310,12 +310,25 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
   let description = [{
     This primitive operation is used to allocate an object on the stack.  A
     reference to the object of type `!fir.ref<T>` is returned.  The returned
-    object has an undefined state.  The allocation can be given an optional
-    name.  The allocation may have a dynamic repetition count for allocating
-    a sequence of locations for the specified type.
+    object has an undefined/uninitialized state.  The allocation can be given
+    an optional name.  The allocation may have a dynamic repetition count
+    for allocating a sequence of locations for the specified type.
 
-      %0 = fir.alloca f32
-      %1 = fir.call @foo(%0) : (!fir.ref<f32>) -> i32
+      %11 = fir.alloca i32
+      %12 = fir.alloca !fir.array<8 x i64>
+      %13 = fir.alloca f32, %5
+
+      %14 = ... : i16
+      %15 = ... : i32
+      %16 = fir.alloca !fir.type<PT(len1:i16, len2:i32)> (%14, %15 : i16, i32)
+
+    Note that in the case of `%13`, a contiguous block of memory is allocated
+    and its size is a runtime multiple of a 32-bit REAL value.
+
+    In the case of `%16`, the arguments `%14` and `%15` are LEN parameters
+    (`len1`, `len2`) to the type `PT`.
+
+    Finally, the operation is undefined if the ssa-value `%5` is negative.
   }];
 
   let results = (outs fir_ReferenceType);
@@ -336,8 +349,15 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
     Arguments<(ins AnyReferenceLike:$memref)> {
   let summary = "load a value from a memory reference";
   let description = [{
-    Load a value from a memory reference into a virtual register.  Produces
-    an immutable ssa-value of the referent type.
+    Load a value from a memory reference into an ssa-value (virtual register).
+    Produces an immutable ssa-value of the referent type. A memory reference
+    has type `!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
+
+      %14 = fir.alloca i32 : !fir.ref<i32>
+      %15 = fir.load %14 : !fir.ref<i32>
+
+    The ssa-value has an undefined value if the memory reference is undefined
+    or null.
   }];
 
   let builders = [OpBuilder<
@@ -388,6 +408,14 @@ def fir_StoreOp : fir_Op<"store", []>,
     Store an ssa-value (virtual register) to a memory reference.  The stored
     value must be of the same type as the referent type of the memory
     reference.
+
+      %16 = fir.call @foo() : f64
+      %17 = fir.call @bar() : !fir.ptr<f64>
+      fir.store %16 to %17 : !fir.ptr<f64>
+
+    The above store changes the value to which the pointer is pointing and not
+    the pointer itself. The operation is undefined if the memory reference is
+    undefined or null.
   }];
 
   let verifier = [{
@@ -431,7 +459,9 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   let description = [{
     Constructs an ssa-value of the specified type with an undefined value.
     This operation is typically created internally by the mem2reg conversion
-    pass.
+    pass. An undefined value can be of any type except `!fir.ref<T>`.
+
+      %18 = fir.undefined !fir.array<10 x !fir.type<T>>
   }];
 
   let verifier = [{
@@ -460,8 +490,8 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
     The memory object is in an undefined state.  `allocmem` operations must
     be paired with `freemem` operations to avoid memory leaks.
 
-      %0 = fir.allocmem !fir.array<10xf32>
-      fir.freemem %0 : !fir.heap<!fir.array<10xf32>>
+      %0 = fir.allocmem !fir.array<10 x f32>
+      fir.freemem %0 : !fir.heap<!fir.array<10 x f32>>
   }];
 
   let results = (outs fir_HeapType);
@@ -488,8 +518,9 @@ def fir_FreeMemOp : fir_Op<"freemem", []> {
     in the undefined state as undefined behavior.  This includes aliasing
     references, such as the result of an `fir.embox`.
 
-      %0 = fir.allocmem !fir.array<10xf32>
-      fir.freemem %0 : !fir.heap<!fir.array<10xf32>>
+      %21 = fir.allocmem !fir.type<ZT(p:i32){field:i32}>
+      ...
+      fir.freemem %21 : !fir.heap<!fir.type<ZT>>
   }];
 
   let arguments = (ins fir_HeapType:$heapref);
@@ -623,6 +654,12 @@ def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
     transferred to the corresponding basic block.  A `select` must have
     at least one basic block with a corresponding `unit` match, and
     that block will be selected when all other conditions fail to match.
+
+      fir.select %arg:i32 [1, ^bb1(%0 : i32),
+                           2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
+                          -3, ^bb3(%arg2,%2 : i32,i32),
+                           4, ^bb4(%1 : i32),
+                        unit, ^bb5]
   }];
 }
 
@@ -635,6 +672,12 @@ def fir_SelectRankOp : fir_IntegralSwitchTerminatorOp<"select_rank"> {
     is matched against constants of integer type.  The structure is the
     same as `select`, but `select_rank` determines the rank of the selector
     variable at runtime to determine the best match.
+
+      fir.select_rank %arg:i32 [1, ^bb1(%0 : i32),
+                                2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
+                                3, ^bb3(%arg2,%2 : i32,i32),
+                               -1, ^bb4(%1 : i32),
+                             unit, ^bb5]
   }];
 }
 
@@ -647,6 +690,13 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     against variables (not just constants) and ranges.  The structure is
     the same as `select`, but `select_case` allows for the expression of
     more complex match conditions.
+
+      fir.select_case %arg : i32 [
+            #fir.point, %0, ^bb1(%0 : i32),
+            #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1 : i32,i32,i32,i32),
+            #fir.interval, %2, %3, ^bb3(%2,%arg2 : i32,i32),
+            #fir.upper, %arg, ^bb4(%1 : i32),
+            unit, ^bb5]
   }];
 
   let parser = [{
@@ -774,6 +824,13 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     is matched against a list of type descriptors.  The structure is the
     same as `select`, but `select_type` determines the type of the selector
     variable at runtime to determine the best match.
+
+      fir.select_type %arg : !fir.box<()> [
+          #fir.instance<!fir.type<type1>>, ^bb1(%0 : i32),
+          #fir.instance<!fir.type<type2>>, ^bb2(%2 : i32),
+          #fir.subsumed<!fir.type<type3>>, ^bb3(%2 : i32),
+          #fir.instance<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
+          unit, ^bb5]
   }];
 
   let parser = [{
@@ -852,7 +909,10 @@ def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
     Terminates a basic block with the assertion that the end of the block
     will never be reached at runtime.  This instruction can be used
     immediately after a call to the Fortran runtime to terminate the
-    program, for example.
+    program, for example.  This instruction corresponds to the LLVM IR
+    instruction `unreachable`.
+
+      fir.unreachable
   }];
 
   let parser = "return mlir::success();";
@@ -865,7 +925,7 @@ def fir_FirEndOp : fir_Op<"end", [Terminator]> {
 
   let description = [{
     The end terminator is a special terminator used inside various FIR
-    operations that have regions.  End is thus the custom (and only) terminator
+    operations that have regions.  End is thus the custom invisible terminator
     for these operations.  It is implicit and need not appear in the textual
     representation.
   }];
@@ -875,6 +935,17 @@ def fir_HasValueOp : fir_Op<"has_value", [Terminator, HasParent<"GlobalOp">]> {
   let summary = "terminator for GlobalOp";
   let description = [{
     The terminator for a GlobalOp with a body.
+
+      global @variable : tuple<i32, f32> {
+        %0 = constant 45 : i32
+        %1 = constant 100.0 : f32
+        %2 = fir.undefined tuple<i32, f32>
+        %3 = constant 0 : index
+        %4 = fir.insert_value %2, %0, %3 : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
+        %5 = constant 1 : index
+        %6 = fir.insert_value %4, %1, %5 : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
+        fir.has_value %6 : tuple<i32, f32>
+      }
   }];
 
   let arguments = (ins AnyType:$resval);
@@ -893,17 +964,12 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
     auxilliary information is packaged and abstracted as a value with box type
     by the calling routine. (In Fortran, these are called descriptors.)
 
-    Syntax:
-      `fir.embox` mem-ref [`,` layout] `:` `(` arg-types `)` `->` res-type
-
-      where layout is dims | affine-map
-
-    Example:
-
+      %c1 = constant 1 : index
+      %c10 = constant 10 : index
       %4 = fir.dims(%c1, %c10, %c1) : (index, index, index) -> !fir.dims<1>
-      %5 = ... : !fir.ref<!fir.array<10:i32>>
-      %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10:i32>>, !fir.dims<1>)
-                            -> !fir.box<!fir.array<10:i32>>
+      %5 = ... : !fir.ref<!fir.array<10 x i32>>
+      %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10 x i32>>, !fir.dims<1>)
+                            -> !fir.box<!fir.array<10 x i32>>
   }];
 
   let arguments = (ins AnyReferenceLike:$memref, Variadic<AnyEmboxArg>:$args);

From d04d44129ed8160b6132df9f027ad47047e18f5d Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 25 Feb 2020 04:01:57 -0800
Subject: [PATCH 194/345] Rebase: evaluate::Assignment changes fallout

---
 lib/lower/Bridge.cpp | 113 ++++++++++++++++++++++++-------------------
 1 file changed, 64 insertions(+), 49 deletions(-)

diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index bb97cce0d680..b1806dc42e7c 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -642,8 +642,7 @@ class FirConverter : public AbstractConverter {
 
   void genFIR(const Pa::AllocateStmt &) { TODO(); }
 
-  void genCharacterAssignement(
-      const Ev::Assignment::IntrinsicAssignment &assignment) {
+  void genCharacterAssignement(const Ev::Assignment &assignment) {
     // Helper to get address and length from an Expr that is a character
     // variable designator
     auto getAddrAndLength{[&](const SomeExpr &charDesignatorExpr)
@@ -677,53 +676,69 @@ class FirConverter : public AbstractConverter {
   }
 
   void genFIR(const Pa::AssignmentStmt &stmt) {
-    assert(stmt.typedAssignment && "assignment analysis failed");
-    if (const auto *assignment{std::get_if<Ev::Assignment::IntrinsicAssignment>(
-            &stmt.typedAssignment->v->u)}) {
-      const Se::Symbol *sym{Ev::UnwrapWholeSymbolDataRef(assignment->lhs)};
-      if (sym && Se::IsAllocatable(*sym)) {
-        // Assignment of allocatable are more complex, the lhs
-        // may need to be deallocated/reallocated.
-        // See Fortran 2018 10.2.1.3 p3
-        TODO();
-      } else if (sym && Se::IsPointer(*sym)) {
-        // Target of the pointer must be assigned.
-        // See Fortran 2018 10.2.1.3 p2
-        TODO();
-      } else if (assignment->lhs.Rank() > 0) {
-        // Array assignment
-        // See Fortran 2018 10.2.1.3 p5, p6, and p7
-        TODO();
-      } else {
-        // Scalar assignments
-        std::optional<Ev::DynamicType> lhsType{assignment->lhs.GetType()};
-        assert(lhsType && "lhs cannot be typeless");
-        switch (lhsType->category()) {
-        case IntegerCat:
-        case RealCat:
-        case ComplexCat:
-        case LogicalCat:
-          // Fortran 2018 10.2.1.3 p8 and p9
-          // Conversions are already inserted by semantic
-          // analysis.
-          builder->create<fir::StoreOp>(toLocation(),
-                                        genExprValue(assignment->rhs),
-                                        genExprAddr(assignment->lhs));
-          break;
-        case CharacterCat:
-          // Fortran 2018 10.2.1.3 p10 and p11
-          genCharacterAssignement(*assignment);
-          break;
-        case DerivedCat:
-          // Fortran 2018 10.2.1.3 p12 and p13
-          TODO();
-          break;
-        }
-      }
-    } else {
-      // Defined assignment: call ProcRef
-      TODO();
-    }
+    assert(stmt.typedAssignment && stmt.typedAssignment->v &&
+           "assignment analysis failed");
+    const auto &assignment{*stmt.typedAssignment->v};
+    std::visit( // better formatting
+        Co::visitors{
+            [&](const Ev::Assignment::Intrinsic &) {
+              const Se::Symbol *sym{
+                  Ev::UnwrapWholeSymbolDataRef(assignment.lhs)};
+              if (sym && Se::IsAllocatable(*sym)) {
+                // Assignment of allocatable are more complex, the lhs
+                // may need to be deallocated/reallocated.
+                // See Fortran 2018 10.2.1.3 p3
+                TODO();
+              } else if (sym && Se::IsPointer(*sym)) {
+                // Target of the pointer must be assigned.
+                // See Fortran 2018 10.2.1.3 p2
+                TODO();
+              } else if (assignment.lhs.Rank() > 0) {
+                // Array assignment
+                // See Fortran 2018 10.2.1.3 p5, p6, and p7
+                TODO();
+              } else {
+                // Scalar assignments
+                std::optional<Ev::DynamicType> lhsType{
+                    assignment.lhs.GetType()};
+                assert(lhsType && "lhs cannot be typeless");
+                switch (lhsType->category()) {
+                case IntegerCat:
+                case RealCat:
+                case ComplexCat:
+                case LogicalCat:
+                  // Fortran 2018 10.2.1.3 p8 and p9
+                  // Conversions are already inserted by semantic
+                  // analysis.
+                  builder->create<fir::StoreOp>(toLocation(),
+                                                genExprValue(assignment.rhs),
+                                                genExprAddr(assignment.lhs));
+                  break;
+                case CharacterCat:
+                  // Fortran 2018 10.2.1.3 p10 and p11
+                  genCharacterAssignement(assignment);
+                  break;
+                case DerivedCat:
+                  // Fortran 2018 10.2.1.3 p12 and p13
+                  TODO();
+                  break;
+                }
+              }
+            },
+            [&](const Ev::ProcedureRef &) {
+              // Defined assignment: call ProcRef
+              TODO();
+            },
+            [&](const Ev::Assignment::BoundsSpec &) {
+              // Pointer assignment with possibly empty bounds-spec
+              TODO();
+            },
+            [&](const Ev::Assignment::BoundsRemapping &) {
+              // Pointer assignment with bounds-remapping
+              TODO();
+            },
+        },
+        assignment.u);
   }
 
   void genFIR(const Pa::ContinueStmt &) {} // do nothing

From 97bb6e4942e21438c31fa3a900375b887ba11e93 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 25 Feb 2020 10:19:42 -0800
Subject: [PATCH 195/345] expand names mechanically fix fallout follow LLVM
 coding standard

---
 include/flang/lower/Bridge.h |   12 +-
 lib/lower/Bridge.cpp         | 1129 +++++++++++++++++++---------------
 lib/lower/CFGBuilder.h       |  219 ++++---
 lib/lower/ConvertExpr.cpp    |  768 ++++++++++++-----------
 lib/lower/ConvertType.cpp    |  353 ++++++-----
 lib/lower/IO.cpp             |  241 ++++----
 lib/lower/Intrinsics.cpp     |  328 +++++-----
 lib/lower/Mangler.cpp        |   38 +-
 lib/lower/OpBuilder.cpp      |  180 +++---
 lib/lower/RTBuilder.h        |    4 +-
 lib/lower/Runtime.cpp        |   39 +-
 tools/bbc/bbc.cpp            |   66 +-
 12 files changed, 1812 insertions(+), 1565 deletions(-)

diff --git a/include/flang/lower/Bridge.h b/include/flang/lower/Bridge.h
index dd0f19099d4c..59f0c6643b15 100644
--- a/include/flang/lower/Bridge.h
+++ b/include/flang/lower/Bridge.h
@@ -118,12 +118,12 @@ class AbstractConverter {
   virtual ~AbstractConverter() = default;
 };
 
-class BurnsideBridge {
+class LoweringBridge {
 public:
-  static BurnsideBridge
+  static LoweringBridge
   create(const common::IntrinsicTypeDefaultKinds &defaultKinds,
          const parser::CookedSource *cooked) {
-    return BurnsideBridge{defaultKinds, cooked};
+    return LoweringBridge{defaultKinds, cooked};
   }
 
   mlir::MLIRContext &getMLIRContext() { return *context.get(); }
@@ -143,10 +143,10 @@ class BurnsideBridge {
   void lower(const parser::Program &program, fir::NameUniquer &uniquer);
 
 private:
-  explicit BurnsideBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
+  explicit LoweringBridge(const common::IntrinsicTypeDefaultKinds &defaultKinds,
                           const parser::CookedSource *cooked);
-  BurnsideBridge() = delete;
-  BurnsideBridge(const BurnsideBridge &) = delete;
+  LoweringBridge() = delete;
+  LoweringBridge(const LoweringBridge &) = delete;
 
   const common::IntrinsicTypeDefaultKinds &defaultKinds;
   const parser::CookedSource *cooked;
diff --git a/lib/lower/Bridge.cpp b/lib/lower/Bridge.cpp
index b1806dc42e7c..447a436e2852 100644
--- a/lib/lower/Bridge.cpp
+++ b/lib/lower/Bridge.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Bridge.h"
-#include "NSAliases.h"
 #include "flang/lower/ConvertExpr.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/IO.h"
@@ -29,31 +28,31 @@
 #include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/CommandLine.h"
 
-using namespace Fortran;
-using namespace Fortran::lower;
-
 namespace {
 
-L::cl::opt<bool> dumpBeforeFir("fdebug-dump-pre-fir", L::cl::init(false),
-                               L::cl::desc("dump the IR tree prior to FIR"));
+llvm::cl::opt<bool>
+    dumpBeforeFir("fdebug-dump-pre-fir", llvm::cl::init(false),
+                  llvm::cl::desc("dump the IR tree prior to FIR"));
 
-L::cl::opt<bool>
+llvm::cl::opt<bool>
     disableToDoAssertions("disable-burnside-todo",
-                          L::cl::desc("disable burnside bridge asserts"),
-                          L::cl::init(false), L::cl::Hidden);
+                          llvm::cl::desc("disable burnside bridge asserts"),
+                          llvm::cl::init(false), llvm::cl::Hidden);
 
 #undef TODO
 #define TODO() assert(false && "not implemented yet")
 
-using SelectCaseConstruct = Pa::CaseConstruct;
-using SelectRankConstruct = Pa::SelectRankConstruct;
-using SelectTypeConstruct = Pa::SelectTypeConstruct;
+using SelectCaseConstruct = Fortran::parser::CaseConstruct;
+using SelectRankConstruct = Fortran::parser::SelectRankConstruct;
+using SelectTypeConstruct = Fortran::parser::SelectTypeConstruct;
 
-using CFGSinkListType = L::SmallVector<PFT::Evaluation *, 2>;
-using CFGMapType = L::DenseMap<PFT::Evaluation *, CFGSinkListType *>;
+using CFGSinkListType = llvm::SmallVector<Fortran::lower::pft::Evaluation *, 2>;
+using CFGMapType =
+    llvm::DenseMap<Fortran::lower::pft::Evaluation *, CFGSinkListType *>;
 
-constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
-  return std::get<Pa::StopStmt::Kind>(stm.t) == Pa::StopStmt::Kind::Stop;
+constexpr static bool isStopStmt(const Fortran::parser::StopStmt &stm) {
+  return std::get<Fortran::parser::StopStmt::Kind>(stm.t) ==
+         Fortran::parser::StopStmt::Kind::Stop;
 }
 
 // CfgBuilder implementation
@@ -63,7 +62,7 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 #define TODO()                                                                 \
   {                                                                            \
     if (disableToDoAssertions)                                                 \
-      M::emitError(toLocation(), __FILE__)                                     \
+      mlir::emitError(toLocation(), __FILE__)                                  \
           << ":" << __LINE__ << " not implemented";                            \
     else                                                                       \
       assert(false && "not yet implemented");                                  \
@@ -73,99 +72,130 @@ constexpr static bool isStopStmt(const Pa::StopStmt &stm) {
 ///
 /// After building the PFT and decorating it, the FirConverter processes that
 /// representation and lowers it to the FIR executable representation.
-class FirConverter : public AbstractConverter {
-  using LabelMapType = std::map<PFT::Evaluation *, M::Block *>;
+class FirConverter : public Fortran::lower::AbstractConverter {
+  using LabelMapType =
+      std::map<Fortran::lower::pft::Evaluation *, mlir::Block *>;
   using Closure = std::function<void(const LabelMapType &)>;
 
   //
   // Helper function members
   //
 
-  M::Value createFIRAddr(M::Location loc, const Se::SomeExpr *expr) {
+  mlir::Value createFIRAddr(mlir::Location loc,
+                            const Fortran::semantics::SomeExpr *expr) {
     return createSomeAddress(loc, *this, *expr, localSymbols, intrinsics);
   }
 
-  M::Value createFIRExpr(M::Location loc, const Se::SomeExpr *expr) {
+  mlir::Value createFIRExpr(mlir::Location loc,
+                            const Fortran::semantics::SomeExpr *expr) {
     return createSomeExpression(loc, *this, *expr, localSymbols, intrinsics);
   }
-  M::Value createLogicalExprAsI1(M::Location loc, const Se::SomeExpr *expr) {
+  mlir::Value createLogicalExprAsI1(mlir::Location loc,
+                                    const Fortran::semantics::SomeExpr *expr) {
     return createI1LogicalExpression(loc, *this, *expr, localSymbols,
                                      intrinsics);
   }
-  M::Value createTemporary(M::Location loc, const Se::Symbol &sym) {
-    return Br::createTemporary(loc, *builder, localSymbols, genType(sym), &sym);
+  mlir::Value createTemporary(mlir::Location loc,
+                              const Fortran::semantics::Symbol &sym) {
+    return Fortran::lower::createTemporary(loc, *builder, localSymbols,
+                                           genType(sym), &sym);
   }
 
-  M::FuncOp genFunctionFIR(L::StringRef callee, M::FunctionType funcTy) {
-    if (auto func{getNamedFunction(module, callee)}) {
+  mlir::FuncOp genFunctionFIR(llvm::StringRef callee,
+                              mlir::FunctionType funcTy) {
+    if (auto func = Fortran::lower::getNamedFunction(module, callee))
       return func;
-    }
     return createFunction(*this, callee, funcTy);
   }
 
-  static bool inMainProgram(PFT::Evaluation *cstr) {
-    return std::visit(
-        Co::visitors{
-            [](PFT::FunctionLikeUnit *c) { return c->isMainProgram(); },
-            [&](PFT::Evaluation *c) { return inMainProgram(c); },
-            [](auto *) { return false; },
-        },
-        cstr->parent.p);
+  static bool inMainProgram(Fortran::lower::pft::Evaluation *cstr) {
+    return std::visit(Fortran::common::visitors{
+                          [](Fortran::lower::pft::FunctionLikeUnit *c) {
+                            return c->isMainProgram();
+                          },
+                          [&](Fortran::lower::pft::Evaluation *c) {
+                            return inMainProgram(c);
+                          },
+                          [](auto *) { return false; },
+                      },
+                      cstr->parent.p);
   }
-  static const Pa::SubroutineStmt *inSubroutine(PFT::Evaluation *cstr) {
+
+  static const Fortran::parser::SubroutineStmt *
+  inSubroutine(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
-        Co::visitors{
-            [](PFT::FunctionLikeUnit *c) { return c->getSubroutine(); },
-            [&](PFT::Evaluation *c) { return inSubroutine(c); },
-            [](auto *) -> const Pa::SubroutineStmt * { return nullptr; },
+        Fortran::common::visitors{
+            [](Fortran::lower::pft::FunctionLikeUnit *c) {
+              return c->getSubroutine();
+            },
+            [&](Fortran::lower::pft::Evaluation *c) { return inSubroutine(c); },
+            [](auto *) -> const Fortran::parser::SubroutineStmt * {
+              return nullptr;
+            },
         },
         cstr->parent.p);
   }
-  static const Pa::FunctionStmt *inFunction(PFT::Evaluation *cstr) {
+  static const Fortran::parser::FunctionStmt *
+  inFunction(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
-        Co::visitors{
-            [](PFT::FunctionLikeUnit *c) { return c->getFunction(); },
-            [&](PFT::Evaluation *c) { return inFunction(c); },
-            [](auto *) -> const Pa::FunctionStmt * { return nullptr; },
+        Fortran::common::visitors{
+            [](Fortran::lower::pft::FunctionLikeUnit *c) {
+              return c->getFunction();
+            },
+            [&](Fortran::lower::pft::Evaluation *c) { return inFunction(c); },
+            [](auto *) -> const Fortran::parser::FunctionStmt * {
+              return nullptr;
+            },
         },
         cstr->parent.p);
   }
-  static const Pa::MpSubprogramStmt *inMPSubp(PFT::Evaluation *cstr) {
+  static const Fortran::parser::MpSubprogramStmt *
+  inMPSubp(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
-        Co::visitors{
-            [](PFT::FunctionLikeUnit *c) { return c->getMPSubp(); },
-            [&](PFT::Evaluation *c) { return inMPSubp(c); },
-            [](auto *) -> const Pa::MpSubprogramStmt * { return nullptr; },
+        Fortran::common::visitors{
+            [](Fortran::lower::pft::FunctionLikeUnit *c) {
+              return c->getMPSubp();
+            },
+            [&](Fortran::lower::pft::Evaluation *c) { return inMPSubp(c); },
+            [](auto *) -> const Fortran::parser::MpSubprogramStmt * {
+              return nullptr;
+            },
         },
         cstr->parent.p);
   }
 
   template <typename A>
-  static const Se::SomeExpr *getScalarExprOfTuple(const A &tuple) {
-    return Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(tuple));
+  static const Fortran::semantics::SomeExpr *
+  getScalarExprOfTuple(const A &tuple) {
+    return Fortran::semantics::GetExpr(
+        std::get<Fortran::parser::ScalarLogicalExpr>(tuple));
   }
   template <typename A>
-  static const Se::SomeExpr *getExprOfTuple(const A &tuple) {
-    return Se::GetExpr(std::get<Pa::LogicalExpr>(tuple));
+  static const Fortran::semantics::SomeExpr *getExprOfTuple(const A &tuple) {
+    return Fortran::semantics::GetExpr(
+        std::get<Fortran::parser::LogicalExpr>(tuple));
   }
   /// Get the condition expression for a CondGoto evaluation
-  const Se::SomeExpr *getEvaluationCondition(PFT::Evaluation &eval) {
-    return eval.visit(Co::visitors{
-        [&](const Pa::IfStmt &stmt) { return getScalarExprOfTuple(stmt.t); },
-        [&](const Pa::IfThenStmt &stmt) {
+  const Fortran::semantics::SomeExpr *
+  getEvaluationCondition(Fortran::lower::pft::Evaluation &eval) {
+    return eval.visit(Fortran::common::visitors{
+        [&](const Fortran::parser::IfStmt &stmt) {
+          return getScalarExprOfTuple(stmt.t);
+        },
+        [&](const Fortran::parser::IfThenStmt &stmt) {
           return getScalarExprOfTuple(stmt.t);
         },
-        [&](const Pa::ElseIfStmt &stmt) {
+        [&](const Fortran::parser::ElseIfStmt &stmt) {
           return getScalarExprOfTuple(stmt.t);
         },
-        [&](const Pa::WhereConstructStmt &stmt) {
+        [&](const Fortran::parser::WhereConstructStmt &stmt) {
           return getExprOfTuple(stmt.t);
         },
-        [&](const Pa::MaskedElsewhereStmt &stmt) {
+        [&](const Fortran::parser::MaskedElsewhereStmt &stmt) {
           return getExprOfTuple(stmt.t);
         },
-        [&](auto &) -> const Se::SomeExpr * {
-          M::emitError(toLocation(), "unexpected conditional branch case");
+        [&](auto &) -> const Fortran::semantics::SomeExpr * {
+          mlir::emitError(toLocation(), "unexpected conditional branch case");
           return nullptr;
         },
     });
@@ -175,52 +205,62 @@ class FirConverter : public AbstractConverter {
   // Function-like PFT entry and exit statements
   //
 
-  void genFIR(const Pa::Statement<Pa::ProgramStmt> &stmt, std::string &name,
-              const Se::Symbol *&) {
+  void
+  genFIR(const Fortran::parser::Statement<Fortran::parser::ProgramStmt> &stmt,
+         std::string &name, const Fortran::semantics::Symbol *&) {
     setCurrentPosition(stmt.source);
     name = uniquer.doProgramEntry();
   }
-  void genFIR(const Pa::Statement<Pa::EndProgramStmt> &stmt, std::string &,
-              const Se::Symbol *&) {
+  void genFIR(
+      const Fortran::parser::Statement<Fortran::parser::EndProgramStmt> &stmt,
+      std::string &, const Fortran::semantics::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
-  void genFIR(const Pa::Statement<Pa::FunctionStmt> &stmt, std::string &name,
-              const Se::Symbol *&symbol) {
+  void
+  genFIR(const Fortran::parser::Statement<Fortran::parser::FunctionStmt> &stmt,
+         std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n{std::get<Pa::Name>(stmt.statement.t)};
+    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
     name = mangleName(*symbol);
   }
-  void genFIR(const Pa::Statement<Pa::EndFunctionStmt> &stmt, std::string &,
-              const Se::Symbol *&symbol) {
+  void genFIR(
+      const Fortran::parser::Statement<Fortran::parser::EndFunctionStmt> &stmt,
+      std::string &, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     assert(symbol);
     genFIRFunctionReturn(*symbol);
   }
-  void genFIR(const Pa::Statement<Pa::SubroutineStmt> &stmt, std::string &name,
-              const Se::Symbol *&symbol) {
+  void genFIR(
+      const Fortran::parser::Statement<Fortran::parser::SubroutineStmt> &stmt,
+      std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n{std::get<Pa::Name>(stmt.statement.t)};
+    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
     name = mangleName(*symbol);
   }
-  void genFIR(const Pa::Statement<Pa::EndSubroutineStmt> &stmt, std::string &,
-              const Se::Symbol *&) {
+  void
+  genFIR(const Fortran::parser::Statement<Fortran::parser::EndSubroutineStmt>
+             &stmt,
+         std::string &, const Fortran::semantics::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
-  void genFIR(const Pa::Statement<Pa::MpSubprogramStmt> &stmt,
-              std::string &name, const Se::Symbol *&symbol) {
+  void genFIR(
+      const Fortran::parser::Statement<Fortran::parser::MpSubprogramStmt> &stmt,
+      std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n{stmt.statement.v};
+    auto &n = stmt.statement.v;
     name = n.ToString();
     symbol = n.symbol;
   }
-  void genFIR(const Pa::Statement<Pa::EndMpSubprogramStmt> &stmt, std::string &,
-              const Se::Symbol *&) {
+  void
+  genFIR(const Fortran::parser::Statement<Fortran::parser::EndMpSubprogramStmt>
+             &stmt,
+         std::string &, const Fortran::semantics::Symbol *&) {
     setCurrentPosition(stmt.source);
     genFIR(stmt.statement);
   }
@@ -232,28 +272,31 @@ class FirConverter : public AbstractConverter {
   /// END of program
   ///
   /// Generate the cleanup block before the program exits
-  void genFIRProgramExit() { builder->create<M::ReturnOp>(toLocation()); }
-  void genFIR(const Pa::EndProgramStmt &) { genFIRProgramExit(); }
+  void genFIRProgramExit() { builder->create<mlir::ReturnOp>(toLocation()); }
+  void genFIR(const Fortran::parser::EndProgramStmt &) { genFIRProgramExit(); }
 
   /// END of procedure-like constructs
   ///
   /// Generate the cleanup block before the procedure exits
-  void genFIRFunctionReturn(const Se::Symbol &functionSymbol) {
-    const auto &details{functionSymbol.get<Se::SubprogramDetails>()};
-    M::Value resultRef{localSymbols.lookupSymbol(details.result())};
-    M::Value r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
-    builder->create<M::ReturnOp>(toLocation(), r);
+  void genFIRFunctionReturn(const Fortran::semantics::Symbol &functionSymbol) {
+    const auto &details =
+        functionSymbol.get<Fortran::semantics::SubprogramDetails>();
+    mlir::Value resultRef = localSymbols.lookupSymbol(details.result());
+    mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
+    builder->create<mlir::ReturnOp>(toLocation(), r);
   }
   template <typename A>
   void genFIRProcedureExit(const A *) {
     // FIXME: alt-returns
-    builder->create<M::ReturnOp>(toLocation());
+    builder->create<mlir::ReturnOp>(toLocation());
   }
-  void genFIR(const Pa::EndSubroutineStmt &) {
-    genFIRProcedureExit(static_cast<const Pa::SubroutineStmt *>(nullptr));
+  void genFIR(const Fortran::parser::EndSubroutineStmt &) {
+    genFIRProcedureExit(
+        static_cast<const Fortran::parser::SubroutineStmt *>(nullptr));
   }
-  void genFIR(const Pa::EndMpSubprogramStmt &) {
-    genFIRProcedureExit(static_cast<const Pa::MpSubprogramStmt *>(nullptr));
+  void genFIR(const Fortran::parser::EndMpSubprogramStmt &) {
+    genFIRProcedureExit(
+        static_cast<const Fortran::parser::MpSubprogramStmt *>(nullptr));
   }
 
   //
@@ -261,29 +304,31 @@ class FirConverter : public AbstractConverter {
   //
 
   // Conditional goto control-flow semantics
-  void genFIREvalCondGoto(PFT::Evaluation &eval) {
+  void genFIREvalCondGoto(Fortran::lower::pft::Evaluation &eval) {
     genFIR(eval);
-    auto targets{findTargetsOf(eval)};
-    auto *expr{getEvaluationCondition(eval)};
+    auto targets = findTargetsOf(eval);
+    auto *expr = getEvaluationCondition(eval);
     assert(expr && "condition expression missing");
-    auto cond{createLogicalExprAsI1(toLocation(), expr)};
+    auto cond = createLogicalExprAsI1(toLocation(), expr);
     genFIRCondBranch(cond, targets[0], targets[1]);
   }
 
-  void genFIRCondBranch(M::Value cond, PFT::Evaluation *trueDest,
-                        PFT::Evaluation *falseDest) {
+  void genFIRCondBranch(mlir::Value cond,
+                        Fortran::lower::pft::Evaluation *trueDest,
+                        Fortran::lower::pft::Evaluation *falseDest) {
     using namespace std::placeholders;
     localEdgeQ.emplace_back(std::bind(
-        [](M::OpBuilder *builder, M::Block *block, M::Value cnd,
-           PFT::Evaluation *trueDest, PFT::Evaluation *falseDest,
-           M::Location location, const LabelMapType &map) {
-          L::SmallVector<M::Value, 2> blk;
+        [](mlir::OpBuilder *builder, mlir::Block *block, mlir::Value cnd,
+           Fortran::lower::pft::Evaluation *trueDest,
+           Fortran::lower::pft::Evaluation *falseDest, mlir::Location location,
+           const LabelMapType &map) {
+          llvm::SmallVector<mlir::Value, 2> blk;
           builder->setInsertionPointToEnd(block);
-          auto tdp{map.find(trueDest)};
-          auto fdp{map.find(falseDest)};
+          auto tdp = map.find(trueDest);
+          auto fdp = map.find(falseDest);
           assert(tdp != map.end() && fdp != map.end());
-          builder->create<M::CondBranchOp>(location, cnd, tdp->second, blk,
-                                           fdp->second, blk);
+          builder->create<mlir::CondBranchOp>(location, cnd, tdp->second, blk,
+                                              fdp->second, blk);
         },
         builder, builder->getInsertionBlock(), cond, trueDest, falseDest,
         toLocation(), _1));
@@ -292,14 +337,15 @@ class FirConverter : public AbstractConverter {
   // Goto control-flow semantics
   //
   // These are unconditional jumps. There is nothing to evaluate.
-  void genFIREvalGoto(PFT::Evaluation &eval) {
+  void genFIREvalGoto(Fortran::lower::pft::Evaluation &eval) {
     using namespace std::placeholders;
     localEdgeQ.emplace_back(std::bind(
-        [](M::OpBuilder *builder, M::Block *block, PFT::Evaluation *dest,
-           M::Location location, const LabelMapType &map) {
+        [](mlir::OpBuilder *builder, mlir::Block *block,
+           Fortran::lower::pft::Evaluation *dest, mlir::Location location,
+           const LabelMapType &map) {
           builder->setInsertionPointToEnd(block);
           assert(map.find(dest) != map.end() && "no destination");
-          builder->create<M::BranchOp>(location, map.find(dest)->second);
+          builder->create<mlir::BranchOp>(location, map.find(dest)->second);
         },
         builder, builder->getInsertionBlock(), findSinkOf(eval), toLocation(),
         _1));
@@ -308,7 +354,7 @@ class FirConverter : public AbstractConverter {
   // Indirect goto control-flow semantics
   //
   // For assigned gotos, which is an obsolescent feature. Lower to a switch.
-  void genFIREvalIndGoto(PFT::Evaluation &eval) {
+  void genFIREvalIndGoto(Fortran::lower::pft::Evaluation &eval) {
     genFIR(eval);
     // FIXME
   }
@@ -316,14 +362,14 @@ class FirConverter : public AbstractConverter {
   // IO statements that have control-flow semantics
   //
   // First lower the IO statement and then do the multiway switch op
-  void genFIREvalIoSwitch(PFT::Evaluation &eval) {
+  void genFIREvalIoSwitch(Fortran::lower::pft::Evaluation &eval) {
     genFIR(eval);
     genFIRIOSwitch(eval);
   }
-  void genFIRIOSwitch(PFT::Evaluation &) { TODO(); }
+  void genFIRIOSwitch(Fortran::lower::pft::Evaluation &) { TODO(); }
 
   // Iterative loop control-flow semantics
-  void genFIREvalIterative(PFT::Evaluation &) { TODO(); }
+  void genFIREvalIterative(Fortran::lower::pft::Evaluation &) { TODO(); }
 
   void switchInsertionPointToWhere(fir::WhereOp &where) {
     builder->setInsertionPointToStart(&where.whereRegion().front());
@@ -333,16 +379,18 @@ class FirConverter : public AbstractConverter {
   }
   template <typename A>
   void genWhereCondition(fir::WhereOp &where, const A *stmt) {
-    auto cond{createLogicalExprAsI1(
-        toLocation(), Se::GetExpr(std::get<Pa::ScalarLogicalExpr>(stmt->t)))};
+    auto cond = createLogicalExprAsI1(
+        toLocation(),
+        Fortran::semantics::GetExpr(
+            std::get<Fortran::parser::ScalarLogicalExpr>(stmt->t)));
     where = builder->create<fir::WhereOp>(toLocation(), cond, true);
     switchInsertionPointToWhere(where);
   }
 
-  M::Value genFIRLoopIndex(const Pa::ScalarExpr &x) {
-    return builder->create<fir::ConvertOp>(toLocation(),
-                                           M::IndexType::get(&mlirContext),
-                                           genExprValue(*Se::GetExpr(x)));
+  mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x) {
+    return builder->create<fir::ConvertOp>(
+        toLocation(), mlir::IndexType::get(&mlirContext),
+        genExprValue(*Fortran::semantics::GetExpr(x)));
   }
 
   /// Structured control op (`fir.loop`, `fir.where`)
@@ -350,72 +398,76 @@ class FirConverter : public AbstractConverter {
   /// Convert a DoConstruct to a `fir.loop` op.
   /// Convert an IfConstruct to a `fir.where` op.
   ///
-  void genFIREvalStructuredOp(PFT::Evaluation &eval) {
+  void genFIREvalStructuredOp(Fortran::lower::pft::Evaluation &eval) {
     // TODO: array expressions, FORALL, WHERE ...
 
     // process the list of Evaluations
     assert(eval.subs && "eval must have a body");
     auto *insPt = builder->getInsertionBlock();
 
-    if (const auto *doConstruct{eval.getIf<Pa::DoConstruct>()}) {
+    if (const auto *doConstruct{eval.getIf<Fortran::parser::DoConstruct>()}) {
       if (const auto &loopControl{doConstruct->GetLoopControl()}) {
-        std::visit(Co::visitors{
-                       [&](const Pa::LoopControl::Bounds &x) {
-                         M::Value lo{genFIRLoopIndex(x.lower)};
-                         M::Value hi{genFIRLoopIndex(x.upper)};
-                         auto step{x.step.has_value()
-                                       ? genExprValue(*Se::GetExpr(*x.step))
-                                       : M::Value{}};
-                         auto *sym{x.name.thing.symbol};
-                         LoopBuilder{*builder, toLocation()}.createLoop(
-                             lo, hi, step,
-                             [&](OpBuilderWrapper &handler, M::Value index) {
-                               // TODO: should push this cast down to the uses
-                               auto cvt{handler.create<fir::ConvertOp>(
-                                   genType(*sym), index)};
-                               localSymbols.pushShadowSymbol(*sym, cvt);
-                               for (auto &e : *eval.subs) {
-                                 genFIR(e);
-                               }
-                               localSymbols.popShadowSymbol();
-                             });
-                       },
-                       [&](const Pa::ScalarLogicalExpr &) {
-                         // we should never reach here
-                         M::emitError(toLocation(),
-                                      "loop lacks iteration space");
-                       },
-                       [&](const Pa::LoopControl::Concurrent &x) {
-                         // FIXME: can project a multi-dimensional space
-                         LoopBuilder{*builder, toLocation()}.createLoop(
-                             M::Value{}, M::Value{},
-                             [&](OpBuilderWrapper &, M::Value) {
-                               for (auto &e : *eval.subs) {
-                                 genFIR(e);
-                               }
-                             });
-                       },
-                   },
-                   loopControl->u);
+        std::visit(
+            Fortran::common::visitors{
+                [&](const Fortran::parser::LoopControl::Bounds &x) {
+                  mlir::Value lo = genFIRLoopIndex(x.lower);
+                  mlir::Value hi = genFIRLoopIndex(x.upper);
+                  auto step =
+                      x.step.has_value()
+                          ? genExprValue(*Fortran::semantics::GetExpr(*x.step))
+                          : mlir::Value{};
+                  auto *sym = x.name.thing.symbol;
+                  Fortran::lower::LoopBuilder{*builder, toLocation()}
+                      .createLoop(lo, hi, step,
+                                  [&](Fortran::lower::OpBuilderWrapper &handler,
+                                      mlir::Value index) {
+                                    // TODO: should push this cast down to the
+                                    // uses
+                                    auto cvt = handler.create<fir::ConvertOp>(
+                                        genType(*sym), index);
+                                    localSymbols.pushShadowSymbol(*sym, cvt);
+                                    for (auto &e : *eval.subs) {
+                                      genFIR(e);
+                                    }
+                                    localSymbols.popShadowSymbol();
+                                  });
+                },
+                [&](const Fortran::parser::ScalarLogicalExpr &) {
+                  // we should never reach here
+                  mlir::emitError(toLocation(), "loop lacks iteration space");
+                },
+                [&](const Fortran::parser::LoopControl::Concurrent &x) {
+                  // FIXME: can project a multi-dimensional space
+                  Fortran::lower::LoopBuilder{*builder, toLocation()}
+                      .createLoop(
+                          mlir::Value{}, mlir::Value{},
+                          [&](Fortran::lower::OpBuilderWrapper &, mlir::Value) {
+                            for (auto &e : *eval.subs) {
+                              genFIR(e);
+                            }
+                          });
+                },
+            },
+            loopControl->u);
       } else {
         // TODO: Infinite loop: 11.1.7.4.1 par 2
         TODO();
       }
-    } else if (eval.isA<Pa::IfConstruct>()) {
+    } else if (eval.isA<Fortran::parser::IfConstruct>()) {
       // Construct fir.where
       fir::WhereOp where;
       for (auto &e : *eval.subs) {
-        if (auto *s{e.getIf<Pa::IfThenStmt>()}) {
+        if (auto *s{e.getIf<Fortran::parser::IfThenStmt>()}) {
           // fir.where op
           genWhereCondition(where, s);
-        } else if (auto *s{e.getIf<Pa::ElseIfStmt>()}) {
+        } else if (auto *s{e.getIf<Fortran::parser::ElseIfStmt>()}) {
           // otherwise block, then nested fir.where
           switchInsertionPointToOtherwise(where);
           genWhereCondition(where, s);
-        } else if (e.isA<Pa::ElseStmt>()) {
+        } else if (e.isA<Fortran::parser::ElseStmt>()) {
           // otherwise block
           switchInsertionPointToOtherwise(where);
-        } else if (e.isA<Pa::EndIfStmt>()) {
+        } else if (e.isA<Fortran::parser::EndIfStmt>()) {
           // close all open fir.where ops
           builder->clearInsertionPoint();
         } else {
@@ -429,13 +481,13 @@ class FirConverter : public AbstractConverter {
   }
 
   // Return from subprogram control-flow semantics
-  void genFIREvalReturn(PFT::Evaluation &eval) {
+  void genFIREvalReturn(Fortran::lower::pft::Evaluation &eval) {
     // Handled case-by-case
     // FIXME: think about moving the case code here
   }
 
   // Multiway switch control-flow semantics
-  void genFIREvalSwitch(PFT::Evaluation &eval) {
+  void genFIREvalSwitch(Fortran::lower::pft::Evaluation &eval) {
     genFIR(eval);
     // FIXME
   }
@@ -443,16 +495,16 @@ class FirConverter : public AbstractConverter {
   // Terminate process control-flow semantics
   //
   // Call a runtime routine that does not return
-  void genFIREvalTerminate(PFT::Evaluation &eval) {
+  void genFIREvalTerminate(Fortran::lower::pft::Evaluation &eval) {
     genFIR(eval);
     builder->create<fir::UnreachableOp>(toLocation());
   }
 
   // No control-flow
-  void genFIREvalNone(PFT::Evaluation &eval) { genFIR(eval); }
+  void genFIREvalNone(Fortran::lower::pft::Evaluation &eval) { genFIR(eval); }
 
-  M::FuncOp getFunc(L::StringRef name, M::FunctionType ty) {
-    if (auto func = getNamedFunction(module, name)) {
+  mlir::FuncOp getFunc(llvm::StringRef name, mlir::FunctionType ty) {
+    if (auto func = Fortran::lower::getNamedFunction(module, name)) {
       assert(func.getType() == ty);
       return func;
     }
@@ -464,49 +516,53 @@ class FirConverter : public AbstractConverter {
   /// 1. Determine what function is being called/dispatched to
   /// 2. Build a tuple of arguments to be passed to that function
   /// 3. Emit fir.call/fir.dispatch on arguments
-  void genFIR(const Pa::CallStmt &stmt) {
-    L::SmallVector<M::Type, 8> argTy;
-    L::SmallVector<M::Type, 2> resTy;
-    L::StringRef funName;
-    std::vector<Se::Symbol *> argsList;
+  void genFIR(const Fortran::parser::CallStmt &stmt) {
+    llvm::SmallVector<mlir::Type, 8> argTy;
+    llvm::SmallVector<mlir::Type, 2> resTy;
+    llvm::StringRef funName;
+    std::vector<Fortran::semantics::Symbol *> argsList;
     setCurrentPosition(stmt.v.source);
-    std::visit(Co::visitors{
-                   [&](const Pa::Name &name) {
+    std::visit(Fortran::common::visitors{
+                   [&](const Fortran::parser::Name &name) {
                      auto *sym = name.symbol;
-                     auto n{sym->name()};
-                     funName = L::StringRef{n.begin(), n.size()};
-                     auto &details = sym->get<Se::SubprogramDetails>();
+                     auto n = sym->name();
+                     funName = llvm::StringRef{n.begin(), n.size()};
+                     auto &details =
+                         sym->get<Fortran::semantics::SubprogramDetails>();
                      // TODO ProcEntityDetails?
                      // TODO bindName()?
                      argsList = details.dummyArgs();
                    },
-                   [&](const Pa::ProcComponentRef &) { TODO(); },
+                   [&](const Fortran::parser::ProcComponentRef &) { TODO(); },
                },
-               std::get<Pa::ProcedureDesignator>(stmt.v.t).u);
+               std::get<Fortran::parser::ProcedureDesignator>(stmt.v.t).u);
     for (auto *d : argsList) {
-      Se::SymbolRef sr{*d};
+      Fortran::semantics::SymbolRef sr = *d;
       // FIXME:
       argTy.push_back(fir::ReferenceType::get(genType(sr)));
     }
-    auto funTy{M::FunctionType::get(argTy, resTy, builder->getContext())};
+    auto funTy = mlir::FunctionType::get(argTy, resTy, builder->getContext());
     // FIXME: mangle name
-    M::FuncOp func{getFunc(funName, funTy)};
+    mlir::FuncOp func = getFunc(funName, funTy);
     (void)func; // FIXME
-    std::vector<M::Value> actuals;
-    for (auto &aa : std::get<std::list<Pa::ActualArgSpec>>(stmt.v.t)) {
-      auto &kw = std::get<std::optional<Pa::Keyword>>(aa.t);
-      auto &arg = std::get<Pa::ActualArg>(aa.t);
-      M::Value fe;
-      std::visit(Co::visitors{
-                     [&](const Co::Indirection<Pa::Expr> &e) {
-                       // FIXME: needs to match argument, assumes trivial by-ref
-                       fe = genExprAddr(*Se::GetExpr(e));
-                     },
-                     [&](const Pa::AltReturnSpec &) { TODO(); },
-                     [&](const Pa::ActualArg::PercentRef &) { TODO(); },
-                     [&](const Pa::ActualArg::PercentVal &) { TODO(); },
-                 },
-                 arg.u);
+    std::vector<mlir::Value> actuals;
+    for (auto &aa :
+         std::get<std::list<Fortran::parser::ActualArgSpec>>(stmt.v.t)) {
+      auto &kw = std::get<std::optional<Fortran::parser::Keyword>>(aa.t);
+      auto &arg = std::get<Fortran::parser::ActualArg>(aa.t);
+      mlir::Value fe;
+      std::visit(
+          Fortran::common::visitors{
+              [&](const Fortran::common::Indirection<Fortran::parser::Expr>
+                      &e) {
+                // FIXME: needs to match argument, assumes trivial by-ref
+                fe = genExprAddr(*Fortran::semantics::GetExpr(e));
+              },
+              [&](const Fortran::parser::AltReturnSpec &) { TODO(); },
+              [&](const Fortran::parser::ActualArg::PercentRef &) { TODO(); },
+              [&](const Fortran::parser::ActualArg::PercentVal &) { TODO(); },
+          },
+          arg.u);
       if (kw.has_value()) {
         TODO();
         continue;
@@ -518,108 +574,120 @@ class FirConverter : public AbstractConverter {
                                  builder->getSymbolRefAttr(funName), actuals);
   }
 
-  void genFIR(const Pa::IfStmt &) { TODO(); }
-  void genFIR(const Pa::WaitStmt &) { TODO(); }
-  void genFIR(const Pa::WhereStmt &) { TODO(); }
-  void genFIR(const Pa::ComputedGotoStmt &stmt) {
-    auto *exp{Se::GetExpr(std::get<Pa::ScalarIntExpr>(stmt.t))};
-    auto e1{genExprValue(*exp)};
+  void genFIR(const Fortran::parser::IfStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::WaitStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::WhereStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::ComputedGotoStmt &stmt) {
+    auto *exp = Fortran::semantics::GetExpr(
+        std::get<Fortran::parser::ScalarIntExpr>(stmt.t));
+    auto e1 = genExprValue(*exp);
     (void)e1;
     TODO();
   }
-  void genFIR(const Pa::ForallStmt &) { TODO(); }
-  void genFIR(const Pa::ArithmeticIfStmt &stmt) {
-    auto *exp{Se::GetExpr(std::get<Pa::Expr>(stmt.t))};
-    auto e1{genExprValue(*exp)};
+  void genFIR(const Fortran::parser::ForallStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::ArithmeticIfStmt &stmt) {
+    auto *exp =
+        Fortran::semantics::GetExpr(std::get<Fortran::parser::Expr>(stmt.t));
+    auto e1 = genExprValue(*exp);
     (void)e1;
     TODO();
   }
-  void genFIR(const Pa::AssignedGotoStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::AssignedGotoStmt &) { TODO(); }
 
-  void genFIR(const Pa::AssociateConstruct &) { TODO(); }
-  void genFIR(const Pa::BlockConstruct &) { TODO(); }
-  void genFIR(const Pa::ChangeTeamConstruct &) { TODO(); }
-  void genFIR(const Pa::CriticalConstruct &) { TODO(); }
-  void genFIR(const Pa::DoConstruct &) { TODO(); }
-  void genFIR(const Pa::IfConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::AssociateConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::BlockConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::ChangeTeamConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::CriticalConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::DoConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::IfConstruct &) { TODO(); }
 
   void genFIR(const SelectCaseConstruct &) { TODO(); }
   void genFIR(const SelectRankConstruct &) { TODO(); }
   void genFIR(const SelectTypeConstruct &) { TODO(); }
 
-  void genFIR(const Pa::WhereConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::WhereConstruct &) { TODO(); }
 
   /// Lower FORALL construct (See 10.2.4)
-  void genFIR(const Pa::ForallConstruct &forall) {
-    auto &stmt{std::get<Pa::Statement<Pa::ForallConstructStmt>>(forall.t)};
+  void genFIR(const Fortran::parser::ForallConstruct &forall) {
+    auto &stmt = std::get<
+        Fortran::parser::Statement<Fortran::parser::ForallConstructStmt>>(
+        forall.t);
     setCurrentPosition(stmt.source);
-    auto &fas{stmt.statement};
-    auto &ctrl{std::get<Co::Indirection<Pa::ConcurrentHeader>>(fas.t).value()};
+    auto &fas = stmt.statement;
+    auto &ctrl =
+        std::get<
+            Fortran::common::Indirection<Fortran::parser::ConcurrentHeader>>(
+            fas.t)
+            .value();
     (void)ctrl;
-    for (auto &s : std::get<std::list<Pa::ForallBodyConstruct>>(forall.t)) {
-      std::visit(Co::visitors{
-                     [&](const Pa::Statement<Pa::ForallAssignmentStmt> &b) {
-                       setCurrentPosition(b.source);
-                       genFIR(b.statement);
-                     },
-                     [&](const Pa::Statement<Pa::WhereStmt> &b) {
-                       setCurrentPosition(b.source);
-                       genFIR(b.statement);
-                     },
-                     [&](const Pa::WhereConstruct &b) { genFIR(b); },
-                     [&](const Co::Indirection<Pa::ForallConstruct> &b) {
-                       genFIR(b.value());
-                     },
-                     [&](const Pa::Statement<Pa::ForallStmt> &b) {
-                       setCurrentPosition(b.source);
-                       genFIR(b.statement);
-                     },
-                 },
-                 s.u);
+    for (auto &s :
+         std::get<std::list<Fortran::parser::ForallBodyConstruct>>(forall.t)) {
+      std::visit(
+          Fortran::common::visitors{
+              [&](const Fortran::parser::Statement<
+                  Fortran::parser::ForallAssignmentStmt> &b) {
+                setCurrentPosition(b.source);
+                genFIR(b.statement);
+              },
+              [&](const Fortran::parser::Statement<Fortran::parser::WhereStmt>
+                      &b) {
+                setCurrentPosition(b.source);
+                genFIR(b.statement);
+              },
+              [&](const Fortran::parser::WhereConstruct &b) { genFIR(b); },
+              [&](const Fortran::common::Indirection<
+                  Fortran::parser::ForallConstruct> &b) { genFIR(b.value()); },
+              [&](const Fortran::parser::Statement<Fortran::parser::ForallStmt>
+                      &b) {
+                setCurrentPosition(b.source);
+                genFIR(b.statement);
+              },
+          },
+          s.u);
     }
     TODO();
   }
-  void genFIR(const Pa::ForallAssignmentStmt &s) {
+  void genFIR(const Fortran::parser::ForallAssignmentStmt &s) {
     std::visit([&](auto &b) { genFIR(b); }, s.u);
   }
 
-  void genFIR(const Pa::CompilerDirective &) { TODO(); }
-  void genFIR(const Pa::OpenMPConstruct &) { TODO(); }
-  void genFIR(const Pa::OmpEndLoopDirective &) { TODO(); }
+  void genFIR(const Fortran::parser::CompilerDirective &) { TODO(); }
+  void genFIR(const Fortran::parser::OpenMPConstruct &) { TODO(); }
+  void genFIR(const Fortran::parser::OmpEndLoopDirective &) { TODO(); }
 
-  void genFIR(const Pa::AssociateStmt &) { TODO(); }
-  void genFIR(const Pa::EndAssociateStmt &) { TODO(); }
-  void genFIR(const Pa::BlockStmt &) { TODO(); }
-  void genFIR(const Pa::EndBlockStmt &) { TODO(); }
-  void genFIR(const Pa::SelectCaseStmt &) { TODO(); }
-  void genFIR(const Pa::CaseStmt &) { TODO(); }
-  void genFIR(const Pa::EndSelectStmt &) { TODO(); }
-  void genFIR(const Pa::ChangeTeamStmt &) { TODO(); }
-  void genFIR(const Pa::EndChangeTeamStmt &) { TODO(); }
-  void genFIR(const Pa::CriticalStmt &) { TODO(); }
-  void genFIR(const Pa::EndCriticalStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::AssociateStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EndAssociateStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::BlockStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EndBlockStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::SelectCaseStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::CaseStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EndSelectStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::ChangeTeamStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EndChangeTeamStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::CriticalStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EndCriticalStmt &) { TODO(); }
 
   // Do loop is handled by EvalIterative(), EvalStructuredOp()
-  void genFIR(const Pa::NonLabelDoStmt &) {} // do nothing
-  void genFIR(const Pa::EndDoStmt &) {}      // do nothing
+  void genFIR(const Fortran::parser::NonLabelDoStmt &) {} // do nothing
+  void genFIR(const Fortran::parser::EndDoStmt &) {}      // do nothing
 
   // If-Then-Else is handled by EvalCondGoto(), EvalStructuredOp()
-  void genFIR(const Pa::IfThenStmt &) {} // do nothing
-  void genFIR(const Pa::ElseIfStmt &) {} // do nothing
-  void genFIR(const Pa::ElseStmt &) {}   // do nothing
-  void genFIR(const Pa::EndIfStmt &) {}  // do nothing
-
-  void genFIR(const Pa::SelectRankStmt &) { TODO(); }
-  void genFIR(const Pa::SelectRankCaseStmt &) { TODO(); }
-  void genFIR(const Pa::SelectTypeStmt &) { TODO(); }
-  void genFIR(const Pa::TypeGuardStmt &) { TODO(); }
-
-  void genFIR(const Pa::WhereConstructStmt &) { TODO(); }
-  void genFIR(const Pa::MaskedElsewhereStmt &) { TODO(); }
-  void genFIR(const Pa::ElsewhereStmt &) { TODO(); }
-  void genFIR(const Pa::EndWhereStmt &) { TODO(); }
-  void genFIR(const Pa::ForallConstructStmt &) { TODO(); }
-  void genFIR(const Pa::EndForallStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::IfThenStmt &) {} // do nothing
+  void genFIR(const Fortran::parser::ElseIfStmt &) {} // do nothing
+  void genFIR(const Fortran::parser::ElseStmt &) {}   // do nothing
+  void genFIR(const Fortran::parser::EndIfStmt &) {}  // do nothing
+
+  void genFIR(const Fortran::parser::SelectRankStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::SelectRankCaseStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::SelectTypeStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::TypeGuardStmt &) { TODO(); }
+
+  void genFIR(const Fortran::parser::WhereConstructStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::MaskedElsewhereStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::ElsewhereStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EndWhereStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::ForallConstructStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EndForallStmt &) { TODO(); }
 
   //
   // Statements that do not have control-flow semantics
@@ -627,69 +695,93 @@ class FirConverter : public AbstractConverter {
 
   // IO statements (see io.h)
 
-  void genFIR(const Pa::BackspaceStmt &stmt) {
+  void genFIR(const Fortran::parser::BackspaceStmt &stmt) {
     genBackspaceStatement(*this, stmt);
   }
-  void genFIR(const Pa::CloseStmt &stmt) { genCloseStatement(*this, stmt); }
-  void genFIR(const Pa::EndfileStmt &stmt) { genEndfileStatement(*this, stmt); }
-  void genFIR(const Pa::FlushStmt &stmt) { genFlushStatement(*this, stmt); }
-  void genFIR(const Pa::InquireStmt &stmt) { genInquireStatement(*this, stmt); }
-  void genFIR(const Pa::OpenStmt &stmt) { genOpenStatement(*this, stmt); }
-  void genFIR(const Pa::PrintStmt &stmt) { genPrintStatement(*this, stmt); }
-  void genFIR(const Pa::ReadStmt &stmt) { genReadStatement(*this, stmt); }
-  void genFIR(const Pa::RewindStmt &stmt) { genRewindStatement(*this, stmt); }
-  void genFIR(const Pa::WriteStmt &stmt) { genWriteStatement(*this, stmt); }
+  void genFIR(const Fortran::parser::CloseStmt &stmt) {
+    genCloseStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::EndfileStmt &stmt) {
+    genEndfileStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::FlushStmt &stmt) {
+    genFlushStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::InquireStmt &stmt) {
+    genInquireStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::OpenStmt &stmt) {
+    genOpenStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::PrintStmt &stmt) {
+    genPrintStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::ReadStmt &stmt) {
+    genReadStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::RewindStmt &stmt) {
+    genRewindStatement(*this, stmt);
+  }
+  void genFIR(const Fortran::parser::WriteStmt &stmt) {
+    genWriteStatement(*this, stmt);
+  }
 
-  void genFIR(const Pa::AllocateStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::AllocateStmt &) { TODO(); }
 
-  void genCharacterAssignement(const Ev::Assignment &assignment) {
+  void
+  genCharacterAssignement(const Fortran::evaluate::Assignment &assignment) {
     // Helper to get address and length from an Expr that is a character
     // variable designator
-    auto getAddrAndLength{[&](const SomeExpr &charDesignatorExpr)
-                              -> CharacterOpsBuilder::CharValue {
-      M::Value addr = genExprAddr(charDesignatorExpr);
-      const auto &charExpr{
-          std::get<Ev::Expr<Ev::SomeCharacter>>(charDesignatorExpr.u)};
-      std::optional<Ev::Expr<Ev::SubscriptInteger>> lenExpr{charExpr.LEN()};
+    auto getAddrAndLength =
+        [&](const Fortran::lower::SomeExpr &charDesignatorExpr)
+        -> Fortran::lower::CharacterOpsBuilder::CharValue {
+      mlir::Value addr = genExprAddr(charDesignatorExpr);
+      const auto &charExpr =
+          std::get<Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
+              charDesignatorExpr.u);
+      auto lenExpr = charExpr.LEN();
       assert(lenExpr && "could not get expression to compute character length");
-      M::Value len{genExprValue(Ev::AsGenericExpr(std::move(*lenExpr)))};
-      return CharacterOpsBuilder::CharValue{addr, len};
-    }};
+      mlir::Value len =
+          genExprValue(Fortran::evaluate::AsGenericExpr(std::move(*lenExpr)));
+      return Fortran::lower::CharacterOpsBuilder::CharValue{addr, len};
+    };
 
-    CharacterOpsBuilder charBuilder{*builder, toLocation()};
+    Fortran::lower::CharacterOpsBuilder charBuilder{*builder, toLocation()};
 
     // RHS evaluation.
     // FIXME:  Only works with rhs that are variable reference.
     // Other expression evaluation are not simple copies.
-    auto rhs{getAddrAndLength(assignment.rhs)};
+    auto rhs = getAddrAndLength(assignment.rhs);
     // A temp is needed to evaluate rhs until proven it does not depend on lhs.
-    auto tempToEvalRhs{charBuilder.createTemp(rhs.getCharacterType(), rhs.len)};
+    auto tempToEvalRhs =
+        charBuilder.createTemp(rhs.getCharacterType(), rhs.len);
     charBuilder.createCopy(tempToEvalRhs, rhs, rhs.len);
 
     // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
-    auto lhs{getAddrAndLength(assignment.lhs)};
-    auto cmpLen{
-        charBuilder.create<M::CmpIOp>(M::CmpIPredicate::slt, lhs.len, rhs.len)};
-    auto copyCount{charBuilder.create<M::SelectOp>(cmpLen, lhs.len, rhs.len)};
+    auto lhs = getAddrAndLength(assignment.lhs);
+    auto cmpLen = charBuilder.create<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
+                                                   lhs.len, rhs.len);
+    auto copyCount =
+        charBuilder.create<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
     charBuilder.createCopy(lhs, tempToEvalRhs, copyCount);
     charBuilder.createPadding(lhs, copyCount, lhs.len);
   }
 
-  void genFIR(const Pa::AssignmentStmt &stmt) {
+  void genFIR(const Fortran::parser::AssignmentStmt &stmt) {
     assert(stmt.typedAssignment && stmt.typedAssignment->v &&
            "assignment analysis failed");
-    const auto &assignment{*stmt.typedAssignment->v};
+    const auto &assignment = *stmt.typedAssignment->v;
     std::visit( // better formatting
-        Co::visitors{
-            [&](const Ev::Assignment::Intrinsic &) {
-              const Se::Symbol *sym{
-                  Ev::UnwrapWholeSymbolDataRef(assignment.lhs)};
-              if (sym && Se::IsAllocatable(*sym)) {
+        Fortran::common::visitors{
+            [&](const Fortran::evaluate::Assignment::Intrinsic &) {
+              const auto *sym =
+                  Fortran::evaluate::UnwrapWholeSymbolDataRef(assignment.lhs);
+              if (sym && Fortran::semantics::IsAllocatable(*sym)) {
                 // Assignment of allocatable are more complex, the lhs
                 // may need to be deallocated/reallocated.
                 // See Fortran 2018 10.2.1.3 p3
                 TODO();
-              } else if (sym && Se::IsPointer(*sym)) {
+              } else if (sym && Fortran::semantics::IsPointer(*sym)) {
                 // Target of the pointer must be assigned.
                 // See Fortran 2018 10.2.1.3 p2
                 TODO();
@@ -699,14 +791,13 @@ class FirConverter : public AbstractConverter {
                 TODO();
               } else {
                 // Scalar assignments
-                std::optional<Ev::DynamicType> lhsType{
-                    assignment.lhs.GetType()};
+                auto lhsType = assignment.lhs.GetType();
                 assert(lhsType && "lhs cannot be typeless");
                 switch (lhsType->category()) {
-                case IntegerCat:
-                case RealCat:
-                case ComplexCat:
-                case LogicalCat:
+                case Fortran::lower::IntegerCat:
+                case Fortran::lower::RealCat:
+                case Fortran::lower::ComplexCat:
+                case Fortran::lower::LogicalCat:
                   // Fortran 2018 10.2.1.3 p8 and p9
                   // Conversions are already inserted by semantic
                   // analysis.
@@ -714,26 +805,26 @@ class FirConverter : public AbstractConverter {
                                                 genExprValue(assignment.rhs),
                                                 genExprAddr(assignment.lhs));
                   break;
-                case CharacterCat:
+                case Fortran::lower::CharacterCat:
                   // Fortran 2018 10.2.1.3 p10 and p11
                   genCharacterAssignement(assignment);
                   break;
-                case DerivedCat:
+                case Fortran::lower::DerivedCat:
                   // Fortran 2018 10.2.1.3 p12 and p13
                   TODO();
                   break;
                 }
               }
             },
-            [&](const Ev::ProcedureRef &) {
+            [&](const Fortran::evaluate::ProcedureRef &) {
               // Defined assignment: call ProcRef
               TODO();
             },
-            [&](const Ev::Assignment::BoundsSpec &) {
+            [&](const Fortran::evaluate::Assignment::BoundsSpec &) {
               // Pointer assignment with possibly empty bounds-spec
               TODO();
             },
-            [&](const Ev::Assignment::BoundsRemapping &) {
+            [&](const Fortran::evaluate::Assignment::BoundsRemapping &) {
               // Pointer assignment with bounds-remapping
               TODO();
             },
@@ -741,19 +832,19 @@ class FirConverter : public AbstractConverter {
         assignment.u);
   }
 
-  void genFIR(const Pa::ContinueStmt &) {} // do nothing
-  void genFIR(const Pa::DeallocateStmt &) { TODO(); }
-  void genFIR(const Pa::EventPostStmt &) {
+  void genFIR(const Fortran::parser::ContinueStmt &) {} // do nothing
+  void genFIR(const Fortran::parser::DeallocateStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EventPostStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::EventWaitStmt &) {
+  void genFIR(const Fortran::parser::EventWaitStmt &) {
     // call some runtime routine
     TODO();
   }
 
-  void genFIR(const Pa::FormTeamStmt &) { TODO(); }
-  void genFIR(const Pa::LockStmt &) {
+  void genFIR(const Fortran::parser::FormTeamStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::LockStmt &) {
     // call some runtime routine
     TODO();
   }
@@ -762,103 +853,103 @@ class FirConverter : public AbstractConverter {
   ///
   /// For each pointer object, reset the pointer to a disassociated status.
   /// We do this by setting each pointer to null.
-  void genFIR(const Pa::NullifyStmt &stmt) {
+  void genFIR(const Fortran::parser::NullifyStmt &stmt) {
     for (auto &po : stmt.v) {
       std::visit(
-          Co::visitors{
-              [&](const Pa::Name &sym) {
-                auto ty{genType(*sym.symbol)};
-                auto load{builder->create<fir::LoadOp>(
-                    toLocation(), localSymbols.lookupSymbol(*sym.symbol))};
-                auto idxTy{M::IndexType::get(&mlirContext)};
-                auto zero{builder->create<M::ConstantOp>(
-                    toLocation(), idxTy, builder->getIntegerAttr(idxTy, 0))};
-                auto cast{
-                    builder->create<fir::ConvertOp>(toLocation(), ty, zero)};
+          Fortran::common::visitors{
+              [&](const Fortran::parser::Name &sym) {
+                auto ty = genType(*sym.symbol);
+                auto load = builder->create<fir::LoadOp>(
+                    toLocation(), localSymbols.lookupSymbol(*sym.symbol));
+                auto idxTy = mlir::IndexType::get(&mlirContext);
+                auto zero = builder->create<mlir::ConstantOp>(
+                    toLocation(), idxTy, builder->getIntegerAttr(idxTy, 0));
+                auto cast =
+                    builder->create<fir::ConvertOp>(toLocation(), ty, zero);
                 builder->create<fir::StoreOp>(toLocation(), cast, load);
               },
-              [&](const Pa::StructureComponent &) { TODO(); },
+              [&](const Fortran::parser::StructureComponent &) { TODO(); },
           },
           po.u);
     }
   }
-  void genFIR(const Pa::PointerAssignmentStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::PointerAssignmentStmt &) { TODO(); }
 
-  void genFIR(const Pa::SyncAllStmt &) {
+  void genFIR(const Fortran::parser::SyncAllStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::SyncImagesStmt &) {
+  void genFIR(const Fortran::parser::SyncImagesStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::SyncMemoryStmt &) {
+  void genFIR(const Fortran::parser::SyncMemoryStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::SyncTeamStmt &) {
+  void genFIR(const Fortran::parser::SyncTeamStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::UnlockStmt &) {
+  void genFIR(const Fortran::parser::UnlockStmt &) {
     // call some runtime routine
     TODO();
   }
 
-  void genFIR(const Pa::AssignStmt &) { TODO(); }
-  void genFIR(const Pa::FormatStmt &) { TODO(); }
-  void genFIR(const Pa::EntryStmt &) { TODO(); }
-  void genFIR(const Pa::PauseStmt &) {
+  void genFIR(const Fortran::parser::AssignStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::FormatStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::EntryStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::PauseStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Pa::DataStmt &) { TODO(); }
-  void genFIR(const Pa::NamelistStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::DataStmt &) { TODO(); }
+  void genFIR(const Fortran::parser::NamelistStmt &) { TODO(); }
 
   // call FAIL IMAGE in runtime
-  void genFIR(const Pa::FailImageStmt &stmt) {
-    auto callee{
-        genRuntimeFunction(RuntimeEntryCode::FailImageStatement, *builder)};
-    L::SmallVector<M::Value, 1> operands; // FAIL IMAGE has no args
-    builder->create<M::CallOp>(toLocation(), callee, operands);
+  void genFIR(const Fortran::parser::FailImageStmt &stmt) {
+    auto callee = genRuntimeFunction(
+        Fortran::lower::RuntimeEntryCode::FailImageStatement, *builder);
+    llvm::SmallVector<mlir::Value, 1> operands; // FAIL IMAGE has no args
+    builder->create<mlir::CallOp>(toLocation(), callee, operands);
   }
 
   // call STOP, ERROR STOP in runtime
-  void genFIR(const Pa::StopStmt &stm) {
-    auto callee{genRuntimeFunction(RuntimeEntryCode::StopStatement, *builder)};
+  void genFIR(const Fortran::parser::StopStmt &stm) {
+    auto callee = genRuntimeFunction(
+        Fortran::lower::RuntimeEntryCode::StopStatement, *builder);
     // TODO: 3 args: stop-code-opt, ierror, quiet-opt
     // auto isError{genFIRLo!isStopStmt(stmt)}
-    L::SmallVector<M::Value, 8> operands;
-    builder->create<M::CallOp>(toLocation(), callee, operands);
+    builder->create<mlir::CallOp>(toLocation(), callee, llvm::None);
   }
 
   // gen expression, if any; share code with END of procedure
-  void genFIR(const Pa::ReturnStmt &) {
+  void genFIR(const Fortran::parser::ReturnStmt &) {
     if (inMainProgram(currentEvaluation)) {
-      builder->create<M::ReturnOp>(toLocation());
+      builder->create<mlir::ReturnOp>(toLocation());
     } else if (auto *stmt = inSubroutine(currentEvaluation)) {
       genFIRProcedureExit(stmt);
     } else if (auto *stmt = inFunction(currentEvaluation)) {
-      auto *symbol = std::get<Pa::Name>(stmt->t).symbol;
+      auto *symbol = std::get<Fortran::parser::Name>(stmt->t).symbol;
       assert(symbol);
       genFIRFunctionReturn(*symbol);
     } else if (auto *stmt = inMPSubp(currentEvaluation)) {
       genFIRProcedureExit(stmt);
     } else {
-      M::emitError(toLocation(), "unknown subprogram type");
+      mlir::emitError(toLocation(), "unknown subprogram type");
     }
   }
 
   // stubs for generic goto statements; see genFIREvalGoto()
-  void genFIR(const Pa::CycleStmt &) {} // do nothing
-  void genFIR(const Pa::ExitStmt &) {}  // do nothing
-  void genFIR(const Pa::GotoStmt &) {}  // do nothing
+  void genFIR(const Fortran::parser::CycleStmt &) {} // do nothing
+  void genFIR(const Fortran::parser::ExitStmt &) {}  // do nothing
+  void genFIR(const Fortran::parser::GotoStmt &) {}  // do nothing
 
-  void genFIR(PFT::Evaluation &eval) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval) {
     currentEvaluation = &eval;
-    eval.visit(Co::visitors{
+    eval.visit(Fortran::common::visitors{
         [&](const auto &p) { genFIR(p); },
-        [](const PFT::CGJump &) { /* do nothing */ },
+        [](const Fortran::lower::pft::CGJump &) { /* do nothing */ },
     });
   }
 
@@ -867,74 +958,76 @@ class FirConverter : public AbstractConverter {
   /// If the Evaluation is annotated, we can attempt to lower it by the class of
   /// annotation. Otherwise, attempt to lower the Evaluation on a case-by-case
   /// basis.
-  void lowerEval(PFT::Evaluation &eval) {
+  void lowerEval(Fortran::lower::pft::Evaluation &eval) {
     setCurrentPosition(eval.pos);
     if (eval.isControlTarget()) {
       // start a new block
     }
     switch (eval.cfg) {
-    case PFT::CFGAnnotation::None:
+    case Fortran::lower::pft::CFGAnnotation::None:
       genFIREvalNone(eval);
       break;
-    case PFT::CFGAnnotation::Goto:
+    case Fortran::lower::pft::CFGAnnotation::Goto:
       genFIREvalGoto(eval);
       break;
-    case PFT::CFGAnnotation::CondGoto:
+    case Fortran::lower::pft::CFGAnnotation::CondGoto:
       genFIREvalCondGoto(eval);
       break;
-    case PFT::CFGAnnotation::IndGoto:
+    case Fortran::lower::pft::CFGAnnotation::IndGoto:
       genFIREvalIndGoto(eval);
       break;
-    case PFT::CFGAnnotation::IoSwitch:
+    case Fortran::lower::pft::CFGAnnotation::IoSwitch:
       genFIREvalIoSwitch(eval);
       break;
-    case PFT::CFGAnnotation::Switch:
+    case Fortran::lower::pft::CFGAnnotation::Switch:
       genFIREvalSwitch(eval);
       break;
-    case PFT::CFGAnnotation::Iterative:
+    case Fortran::lower::pft::CFGAnnotation::Iterative:
       genFIREvalIterative(eval);
       break;
-    case PFT::CFGAnnotation::FirStructuredOp:
+    case Fortran::lower::pft::CFGAnnotation::FirStructuredOp:
       genFIREvalStructuredOp(eval);
       break;
-    case PFT::CFGAnnotation::Return:
+    case Fortran::lower::pft::CFGAnnotation::Return:
       genFIREvalReturn(eval);
       break;
-    case PFT::CFGAnnotation::Terminate:
+    case Fortran::lower::pft::CFGAnnotation::Terminate:
       genFIREvalTerminate(eval);
       break;
     }
   }
 
-  M::FuncOp createNewFunction(L::StringRef name, const Se::Symbol *symbol) {
+  mlir::FuncOp createNewFunction(llvm::StringRef name,
+                                 const Fortran::semantics::Symbol *symbol) {
     // get arguments and return type if any, otherwise just use empty vectors
-    L::SmallVector<M::Type, 8> args;
-    L::SmallVector<M::Type, 2> results;
-    auto funcTy{symbol ? genFunctionType(*symbol)
-                       : M::FunctionType::get(args, results, &mlirContext)};
+    llvm::SmallVector<mlir::Type, 8> args;
+    llvm::SmallVector<mlir::Type, 2> results;
+    auto funcTy = symbol ? genFunctionType(*symbol)
+                         : mlir::FunctionType::get(args, results, &mlirContext);
     return createFunction(*this, name, funcTy);
   }
 
   /// Prepare to translate a new function
-  void startNewFunction(PFT::FunctionLikeUnit &funit, L::StringRef name,
-                        const Se::Symbol *symbol) {
-    M::FuncOp func{getNamedFunction(module, name)};
-    if (!func) {
+  void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit,
+                        llvm::StringRef name,
+                        const Fortran::semantics::Symbol *symbol) {
+    mlir::FuncOp func = Fortran::lower::getNamedFunction(module, name);
+    if (!func)
       func = createNewFunction(name, symbol);
-    }
     func.addEntryBlock();
     assert(!builder && "expected nullptr");
-    builder = new M::OpBuilder(func);
+    builder = new mlir::OpBuilder(func);
     assert(builder && "OpBuilder did not instantiate");
     builder->setInsertionPointToStart(&func.front());
 
     // plumb function's arguments
     if (symbol) {
-      auto *entryBlock{&func.front()};
-      auto *details{symbol->detailsIf<Se::SubprogramDetails>()};
+      auto *entryBlock = &func.front();
+      auto *details =
+          symbol->detailsIf<Fortran::semantics::SubprogramDetails>();
       assert(details && "details for semantics symbol must be subprogram");
       for (const auto &v :
-           L::zip(details->dummyArgs(), entryBlock->getArguments())) {
+           llvm::zip(details->dummyArgs(), entryBlock->getArguments())) {
         if (std::get<0>(v)) {
           localSymbols.addSymbol(*std::get<0>(v), std::get<1>(v));
         } else {
@@ -948,9 +1041,8 @@ class FirConverter : public AbstractConverter {
   }
 
   void finalizeQueuedEdges() {
-    for (auto &edgeFunc : localEdgeQ) {
+    for (auto &edgeFunc : localEdgeQ)
       edgeFunc(localBlockMap);
-    }
     localEdgeQ.clear();
     localBlockMap.clear();
   }
@@ -964,10 +1056,11 @@ class FirConverter : public AbstractConverter {
   }
 
   /// Lower a procedure-like construct
-  void lowerFunc(PFT::FunctionLikeUnit &func, L::ArrayRef<L::StringRef> modules,
-                 L::Optional<L::StringRef> host = {}) {
+  void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &func,
+                 llvm::ArrayRef<llvm::StringRef> modules,
+                 llvm::Optional<llvm::StringRef> host = {}) {
     std::string name;
-    const Se::Symbol *symbol{nullptr};
+    const Fortran::semantics::Symbol *symbol = nullptr;
 
     if (func.beginStmt) {
       currentEvaluation = nullptr;
@@ -979,29 +1072,26 @@ class FirConverter : public AbstractConverter {
     startNewFunction(func, name, symbol);
 
     // lower this procedure
-    for (auto &e : func.evals) {
+    for (auto &e : func.evals)
       lowerEval(e);
-    }
     currentEvaluation = nullptr;
     std::visit([&](auto *p) { genFIR(*p, name, symbol); }, func.endStmt);
 
     endNewFunction();
 
     // recursively lower internal procedures
-    L::Optional<L::StringRef> optName{name};
-    for (auto &f : func.funcs) {
+    llvm::Optional<llvm::StringRef> optName{name};
+    for (auto &f : func.funcs)
       lowerFunc(f, modules, optName);
-    }
   }
 
-  void lowerMod(PFT::ModuleLikeUnit &mod) {
+  void lowerMod(Fortran::lower::pft::ModuleLikeUnit &mod) {
     // FIXME: build the vector of module names
-    std::vector<L::StringRef> moduleName;
+    std::vector<llvm::StringRef> moduleName;
 
     // FIXME: do we need to visit the module statements?
-    for (auto &f : mod.funcs) {
+    for (auto &f : mod.funcs)
       lowerFunc(f, moduleName);
-    }
   }
 
   //
@@ -1009,42 +1099,40 @@ class FirConverter : public AbstractConverter {
   //
 
   /// Lookup the set of sinks for this source. There must be at least one.
-  L::ArrayRef<PFT::Evaluation *> findTargetsOf(PFT::Evaluation &eval) {
+  llvm::ArrayRef<Fortran::lower::pft::Evaluation *>
+  findTargetsOf(Fortran::lower::pft::Evaluation &eval) {
     auto iter = cfgMap.find(&eval);
     assert(iter != cfgMap.end());
     return *iter->second;
   }
 
   /// Lookup the sink for this source. There must be exactly one.
-  PFT::Evaluation *findSinkOf(PFT::Evaluation &eval) {
+  Fortran::lower::pft::Evaluation *
+  findSinkOf(Fortran::lower::pft::Evaluation &eval) {
     auto iter = cfgMap.find(&eval);
     assert((iter != cfgMap.end()) && (iter->second->size() == 1));
     return iter->second->front();
   }
 
   /// prune the CFG for `f`
-  void pruneFunc(PFT::FunctionLikeUnit &func) {
+  void pruneFunc(Fortran::lower::pft::FunctionLikeUnit &func) {
     // find and cache arcs, etc.
-    if (!func.evals.empty()) {
+    if (!func.evals.empty())
       CfgBuilder{cfgMap, cfgEdgeSetPool}.run(func);
-    }
 
     // do any internal procedures
-    for (auto &f : func.funcs) {
+    for (auto &f : func.funcs)
       pruneFunc(f);
-    }
   }
 
-  void pruneMod(PFT::ModuleLikeUnit &mod) {
-    for (auto &f : mod.funcs) {
+  void pruneMod(Fortran::lower::pft::ModuleLikeUnit &mod) {
+    for (auto &f : mod.funcs)
       pruneFunc(f);
-    }
   }
 
-  void setCurrentPosition(const Pa::CharBlock &pos) {
-    if (pos != Pa::CharBlock{}) {
+  void setCurrentPosition(const Fortran::parser::CharBlock &pos) {
+    if (pos != Fortran::parser::CharBlock{})
       currentPosition = pos;
-    }
   }
 
   //
@@ -1052,55 +1140,58 @@ class FirConverter : public AbstractConverter {
   //
 
   /// Convert a parser CharBlock to a Location
-  M::Location toLocation(const Pa::CharBlock &cb) { return genLocation(cb); }
+  mlir::Location toLocation(const Fortran::parser::CharBlock &cb) {
+    return genLocation(cb);
+  }
 
-  M::Location toLocation() { return toLocation(currentPosition); }
+  mlir::Location toLocation() { return toLocation(currentPosition); }
 
   // TODO: should these be moved to convert-expr?
-  template <M::CmpIPredicate ICMPOPC>
-  M::Value genCompare(M::Value lhs, M::Value rhs) {
-    auto lty{lhs.getType()};
+  template <mlir::CmpIPredicate ICMPOPC>
+  mlir::Value genCompare(mlir::Value lhs, mlir::Value rhs) {
+    auto lty = lhs.getType();
     assert(lty == rhs.getType());
     if (lty.isSignlessIntOrIndex())
-      return builder->create<M::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
+      return builder->create<mlir::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
     if (fir::LogicalType::kindof(lty.getKind()))
-      return builder->create<M::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
+      return builder->create<mlir::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
     if (fir::CharacterType::kindof(lty.getKind())) {
       // FIXME
-      // return builder->create<M::CallOp>(lhs->getLoc(), );
+      // return builder->create<mlir::CallOp>(lhs->getLoc(), );
     }
-    M::emitError(toLocation(), "cannot generate operation on this type");
+    mlir::emitError(toLocation(), "cannot generate operation on this type");
     return {};
   }
 
-  M::Value genGE(M::Value lhs, M::Value rhs) {
-    return genCompare<M::CmpIPredicate::sge>(lhs, rhs);
+  mlir::Value genGE(mlir::Value lhs, mlir::Value rhs) {
+    return genCompare<mlir::CmpIPredicate::sge>(lhs, rhs);
   }
-  M::Value genLE(M::Value lhs, M::Value rhs) {
-    return genCompare<M::CmpIPredicate::sle>(lhs, rhs);
+  mlir::Value genLE(mlir::Value lhs, mlir::Value rhs) {
+    return genCompare<mlir::CmpIPredicate::sle>(lhs, rhs);
   }
-  M::Value genEQ(M::Value lhs, M::Value rhs) {
-    return genCompare<M::CmpIPredicate::eq>(lhs, rhs);
+  mlir::Value genEQ(mlir::Value lhs, mlir::Value rhs) {
+    return genCompare<mlir::CmpIPredicate::eq>(lhs, rhs);
   }
-  M::Value genAND(M::Value lhs, M::Value rhs) {
-    return builder->create<M::AndOp>(lhs.getLoc(), lhs, rhs);
+  mlir::Value genAND(mlir::Value lhs, mlir::Value rhs) {
+    return builder->create<mlir::AndOp>(lhs.getLoc(), lhs, rhs);
   }
 
 private:
-  M::MLIRContext &mlirContext;
-  const Pa::CookedSource *cooked;
-  M::ModuleOp &module;
-  const Co::IntrinsicTypeDefaultKinds &defaults;
-  IntrinsicLibrary intrinsics;
-  M::OpBuilder *builder{nullptr};
+  mlir::MLIRContext &mlirContext;
+  const Fortran::parser::CookedSource *cooked;
+  mlir::ModuleOp &module;
+  const Fortran::common::IntrinsicTypeDefaultKinds &defaults;
+  Fortran::lower::IntrinsicLibrary intrinsics;
+  mlir::OpBuilder *builder = nullptr;
   fir::NameUniquer &uniquer;
-  SymMap localSymbols;
+  Fortran::lower::SymMap localSymbols;
   std::list<Closure> localEdgeQ;
   LabelMapType localBlockMap;
-  Pa::CharBlock currentPosition;
+  Fortran::parser::CharBlock currentPosition;
   CFGMapType cfgMap;
   std::list<CFGSinkListType> cfgEdgeSetPool;
-  PFT::Evaluation *currentEvaluation{nullptr}; // FIXME: this is a hack
+  Fortran::lower::pft::Evaluation *currentEvaluation =
+      nullptr; // FIXME: this is a hack
 
 public:
   FirConverter() = delete;
@@ -1108,117 +1199,131 @@ class FirConverter : public AbstractConverter {
   FirConverter &operator=(const FirConverter &) = delete;
   virtual ~FirConverter() = default;
 
-  explicit FirConverter(BurnsideBridge &bridge, fir::NameUniquer &uniquer)
+  explicit FirConverter(Fortran::lower::LoweringBridge &bridge,
+                        fir::NameUniquer &uniquer)
       : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
         module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
-        intrinsics{IntrinsicLibrary(IntrinsicLibrary::Version::LLVM,
-                                    bridge.getMLIRContext())},
+        intrinsics{Fortran::lower::IntrinsicLibrary(
+            Fortran::lower::IntrinsicLibrary::Version::LLVM,
+            bridge.getMLIRContext())},
         uniquer{uniquer} {}
 
   /// Convert the PFT to FIR
-  void run(PFT::Program &pft) {
+  void run(Fortran::lower::pft::Program &pft) {
     // build pruned control
     for (auto &u : pft.getUnits()) {
-      std::visit(Co::visitors{
-                     [&](PFT::FunctionLikeUnit &f) { pruneFunc(f); },
-                     [&](PFT::ModuleLikeUnit &m) { pruneMod(m); },
-                     [](PFT::BlockDataUnit &) { /* do nothing */ },
-                 },
-                 u);
+      std::visit(
+          Fortran::common::visitors{
+              [&](Fortran::lower::pft::FunctionLikeUnit &f) { pruneFunc(f); },
+              [&](Fortran::lower::pft::ModuleLikeUnit &m) { pruneMod(m); },
+              [](Fortran::lower::pft::BlockDataUnit &) { /* do nothing */ },
+          },
+          u);
     }
 
     // do translation
     for (auto &u : pft.getUnits()) {
-      std::visit(Co::visitors{
-                     [&](PFT::FunctionLikeUnit &f) { lowerFunc(f, {}); },
-                     [&](PFT::ModuleLikeUnit &m) { lowerMod(m); },
-                     [&](PFT::BlockDataUnit &) { TODO(); },
-                 },
-                 u);
+      std::visit(
+          Fortran::common::visitors{
+              [&](Fortran::lower::pft::FunctionLikeUnit &f) {
+                lowerFunc(f, {});
+              },
+              [&](Fortran::lower::pft::ModuleLikeUnit &m) { lowerMod(m); },
+              [&](Fortran::lower::pft::BlockDataUnit &) { TODO(); },
+          },
+          u);
     }
   }
 
-  M::FunctionType genFunctionType(SymbolRef sym) {
-    return translateSymbolToFIRFunctionType(&mlirContext, defaults, sym);
+  mlir::FunctionType genFunctionType(Fortran::lower::SymbolRef sym) {
+    return Fortran::lower::translateSymbolToFIRFunctionType(&mlirContext,
+                                                            defaults, sym);
   }
 
   //
   // AbstractConverter overrides
 
-  M::Value genExprAddr(const SomeExpr &expr,
-                       M::Location *loc = nullptr) override final {
+  mlir::Value genExprAddr(const Fortran::lower::SomeExpr &expr,
+                          mlir::Location *loc = nullptr) override final {
     return createFIRAddr(loc ? *loc : toLocation(), &expr);
   }
-  M::Value genExprValue(const SomeExpr &expr,
-                        M::Location *loc = nullptr) override final {
+  mlir::Value genExprValue(const Fortran::lower::SomeExpr &expr,
+                           mlir::Location *loc = nullptr) override final {
     return createFIRExpr(loc ? *loc : toLocation(), &expr);
   }
 
-  M::Type genType(const Ev::DataRef &data) override final {
-    return translateDataRefToFIRType(&mlirContext, defaults, data);
+  mlir::Type genType(const Fortran::evaluate::DataRef &data) override final {
+    return Fortran::lower::translateDataRefToFIRType(&mlirContext, defaults,
+                                                     data);
   }
-  M::Type genType(const SomeExpr &expr) override final {
-    return translateSomeExprToFIRType(&mlirContext, defaults, &expr);
+  mlir::Type genType(const Fortran::lower::SomeExpr &expr) override final {
+    return Fortran::lower::translateSomeExprToFIRType(&mlirContext, defaults,
+                                                      &expr);
   }
-  M::Type genType(SymbolRef sym) override final {
-    return translateSymbolToFIRType(&mlirContext, defaults, sym);
+  mlir::Type genType(Fortran::lower::SymbolRef sym) override final {
+    return Fortran::lower::translateSymbolToFIRType(&mlirContext, defaults,
+                                                    sym);
   }
-  M::Type genType(Co::TypeCategory tc, int kind) override final {
-    return getFIRType(&mlirContext, defaults, tc, kind);
+  mlir::Type genType(Fortran::common::TypeCategory tc,
+                     int kind) override final {
+    return Fortran::lower::getFIRType(&mlirContext, defaults, tc, kind);
   }
-  M::Type genType(Co::TypeCategory tc) override final {
-    return getFIRType(&mlirContext, defaults, tc);
+  mlir::Type genType(Fortran::common::TypeCategory tc) override final {
+    return Fortran::lower::getFIRType(&mlirContext, defaults, tc);
   }
 
-  M::Location getCurrentLocation() override final { return toLocation(); }
-  M::Location genLocation() override final {
-    return M::UnknownLoc::get(&mlirContext);
+  mlir::Location getCurrentLocation() override final { return toLocation(); }
+
+  mlir::Location genLocation() override final {
+    return mlir::UnknownLoc::get(&mlirContext);
   }
-  M::Location genLocation(const Pa::CharBlock &block) override final {
+
+  mlir::Location
+  genLocation(const Fortran::parser::CharBlock &block) override final {
     if (cooked) {
-      auto loc{cooked->GetSourcePositionRange(block)};
+      auto loc = cooked->GetSourcePositionRange(block);
       if (loc.has_value()) {
         // loc is a pair (begin, end); use the beginning position
-        auto &filePos{loc->first};
-        return M::FileLineColLoc::get(filePos.file.path(), filePos.line,
-                                      filePos.column, &mlirContext);
+        auto &filePos = loc->first;
+        return mlir::FileLineColLoc::get(filePos.file.path(), filePos.line,
+                                         filePos.column, &mlirContext);
       }
     }
     return genLocation();
   }
 
-  M::OpBuilder &getOpBuilder() override final { return *builder; }
-  M::ModuleOp &getModuleOp() override final { return module; }
+  mlir::OpBuilder &getOpBuilder() override final { return *builder; }
+
+  mlir::ModuleOp &getModuleOp() override final { return module; }
 
-  std::string mangleName(SymbolRef symbol) override final {
-    return mangle::mangleName(uniquer, symbol);
+  std::string mangleName(Fortran::lower::SymbolRef symbol) override final {
+    return Fortran::lower::mangle::mangleName(uniquer, symbol);
   }
 };
 
 } // namespace
 
-void Br::BurnsideBridge::lower(const Pa::Program &prg,
-                               fir::NameUniquer &uniquer) {
-  std::unique_ptr<PFT::Program> pft{Br::createPFT(prg)};
-  Br::annotateControl(*pft);
-  if (dumpBeforeFir) {
-    Br::dumpPFT(L::errs(), *pft);
-  }
+void Fortran::lower::LoweringBridge::lower(const Fortran::parser::Program &prg,
+                                           fir::NameUniquer &uniquer) {
+  auto pft = Fortran::lower::createPFT(prg);
+  Fortran::lower::annotateControl(*pft);
+  if (dumpBeforeFir)
+    Fortran::lower::dumpPFT(llvm::errs(), *pft);
   FirConverter converter{*this, uniquer};
   converter.run(*pft);
 }
 
-void Br::BurnsideBridge::parseSourceFile(L::SourceMgr &srcMgr) {
-  auto owningRef = M::parseSourceFile(srcMgr, context.get());
-  module.reset(new M::ModuleOp(owningRef.get().getOperation()));
+void Fortran::lower::LoweringBridge::parseSourceFile(llvm::SourceMgr &srcMgr) {
+  auto owningRef = mlir::parseSourceFile(srcMgr, context.get());
+  module.reset(new mlir::ModuleOp(owningRef.get().getOperation()));
   owningRef.release();
 }
 
-Br::BurnsideBridge::BurnsideBridge(
-    const Co::IntrinsicTypeDefaultKinds &defaultKinds,
-    const Pa::CookedSource *cooked)
+Fortran::lower::LoweringBridge::LoweringBridge(
+    const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
+    const Fortran::parser::CookedSource *cooked)
     : defaultKinds{defaultKinds}, cooked{cooked} {
-  context = std::make_unique<M::MLIRContext>();
-  module = std::make_unique<M::ModuleOp>(
-      M::ModuleOp::create(M::UnknownLoc::get(context.get())));
+  context = std::make_unique<mlir::MLIRContext>();
+  module = std::make_unique<mlir::ModuleOp>(
+      mlir::ModuleOp::create(mlir::UnknownLoc::get(context.get())));
 }
diff --git a/lib/lower/CFGBuilder.h b/lib/lower/CFGBuilder.h
index dc3282fdf695..cfc8acece4ba 100644
--- a/lib/lower/CFGBuilder.h
+++ b/lib/lower/CFGBuilder.h
@@ -13,7 +13,8 @@
 /// potential targets, making implied jumps explicit, etc.
 class CfgBuilder {
 
-  PFT::Evaluation *getEvalByLabel(const Pa::Label &label) {
+  Fortran::lower::pft::Evaluation *
+  getEvalByLabel(const Fortran::parser::Label &label) {
     auto iter = labels.find(label);
     if (iter != labels.end()) {
       return iter->second;
@@ -22,7 +23,8 @@ class CfgBuilder {
   }
 
   /// Collect all the potential targets and initialize them to unreferenced
-  void resetPotentialTargets(std::list<PFT::Evaluation> &evals) {
+  void
+  resetPotentialTargets(std::list<Fortran::lower::pft::Evaluation> &evals) {
     for (auto &e : evals) {
       if (e.isTarget) {
         e.isTarget = false;
@@ -37,16 +39,17 @@ class CfgBuilder {
   }
 
   /// cache ASSIGN statements that may yield a live branch target
-  void cacheAssigns(std::list<PFT::Evaluation> &evals) {
+  void cacheAssigns(std::list<Fortran::lower::pft::Evaluation> &evals) {
     for (auto &e : evals) {
-      e.visit(Co::visitors{
-          [&](const Pa::AssignStmt &stmt) {
-            auto *trg = getEvalByLabel(std::get<Pa::Label>(stmt.t));
-            auto *sym = std::get<Pa::Name>(stmt.t).symbol;
+      e.visit(Fortran::common::visitors{
+          [&](const Fortran::parser::AssignStmt &stmt) {
+            auto *trg =
+                getEvalByLabel(std::get<Fortran::parser::Label>(stmt.t));
+            auto *sym = std::get<Fortran::parser::Name>(stmt.t).symbol;
             assert(sym);
             auto jter = assignedGotoMap.find(sym);
             if (jter == assignedGotoMap.end()) {
-              std::list<PFT::Evaluation *> lst = {trg};
+              std::list<Fortran::lower::pft::Evaluation *> lst = {trg};
               assignedGotoMap.try_emplace(sym, lst);
             } else {
               jter->second.emplace_back(trg);
@@ -60,47 +63,47 @@ class CfgBuilder {
     }
   }
 
-  void deannotate(std::list<PFT::Evaluation> &evals) {
+  void deannotate(std::list<Fortran::lower::pft::Evaluation> &evals) {
     for (auto &e : evals) {
-      e.cfg = PFT::CFGAnnotation::None;
+      e.cfg = Fortran::lower::pft::CFGAnnotation::None;
       if (e.subs) {
         deannotate(*e.subs);
       }
     }
   }
 
-  bool structuredCheck(std::list<PFT::Evaluation> &evals) {
+  bool structuredCheck(std::list<Fortran::lower::pft::Evaluation> &evals) {
     for (auto &e : evals) {
-      if (auto *s = e.getIf<Pa::DoConstruct>()) {
+      if (auto *s = e.getIf<Fortran::parser::DoConstruct>()) {
         return s->IsDoWhile() ? false : structuredCheck(*e.subs);
       }
-      if (e.isA<Pa::IfConstruct>()) {
+      if (e.isA<Fortran::parser::IfConstruct>()) {
         return structuredCheck(*e.subs);
       }
       if (e.subs) {
         return false;
       }
       switch (e.cfg) {
-      case PFT::CFGAnnotation::None:
+      case Fortran::lower::pft::CFGAnnotation::None:
         break;
-      case PFT::CFGAnnotation::CondGoto:
+      case Fortran::lower::pft::CFGAnnotation::CondGoto:
         break;
-      case PFT::CFGAnnotation::Iterative:
+      case Fortran::lower::pft::CFGAnnotation::Iterative:
         break;
-      case PFT::CFGAnnotation::FirStructuredOp:
+      case Fortran::lower::pft::CFGAnnotation::FirStructuredOp:
         break;
-      case PFT::CFGAnnotation::IndGoto:
+      case Fortran::lower::pft::CFGAnnotation::IndGoto:
         return false;
-      case PFT::CFGAnnotation::IoSwitch:
+      case Fortran::lower::pft::CFGAnnotation::IoSwitch:
         return false;
-      case PFT::CFGAnnotation::Switch:
+      case Fortran::lower::pft::CFGAnnotation::Switch:
         return false;
-      case PFT::CFGAnnotation::Return:
+      case Fortran::lower::pft::CFGAnnotation::Return:
         return false;
-      case PFT::CFGAnnotation::Terminate:
+      case Fortran::lower::pft::CFGAnnotation::Terminate:
         return false;
-      case PFT::CFGAnnotation::Goto:
-        if (!e.isA<Pa::EndDoStmt>()) {
+      case Fortran::lower::pft::CFGAnnotation::Goto:
+        if (!e.isA<Fortran::parser::EndDoStmt>()) {
           return false;
         }
         break;
@@ -109,18 +112,18 @@ class CfgBuilder {
     return true;
   }
 
-  void wrapIterationSpaces(std::list<PFT::Evaluation> &evals) {
+  void wrapIterationSpaces(std::list<Fortran::lower::pft::Evaluation> &evals) {
     for (auto &e : evals) {
-      if (e.isA<Pa::DoConstruct>())
+      if (e.isA<Fortran::parser::DoConstruct>())
         if (structuredCheck(*e.subs)) {
           deannotate(*e.subs);
-          e.cfg = PFT::CFGAnnotation::FirStructuredOp;
+          e.cfg = Fortran::lower::pft::CFGAnnotation::FirStructuredOp;
           continue;
         }
-      if (e.isA<Pa::IfConstruct>())
+      if (e.isA<Fortran::parser::IfConstruct>())
         if (structuredCheck(*e.subs)) {
           deannotate(*e.subs);
-          e.cfg = PFT::CFGAnnotation::FirStructuredOp;
+          e.cfg = Fortran::lower::pft::CFGAnnotation::FirStructuredOp;
           continue;
         }
       // FIXME: ForallConstruct? WhereConstruct?
@@ -131,7 +134,8 @@ class CfgBuilder {
   }
 
   /// Add source->sink edge to CFG map
-  void addSourceToSink(PFT::Evaluation *src, PFT::Evaluation *snk) {
+  void addSourceToSink(Fortran::lower::pft::Evaluation *src,
+                       Fortran::lower::pft::Evaluation *snk) {
     auto iter = cfgMap.find(src);
     if (iter == cfgMap.end()) {
       CFGSinkListType sink{snk};
@@ -148,7 +152,8 @@ class CfgBuilder {
     iter->second->push_back(snk);
   }
 
-  void addSourceToSink(PFT::Evaluation *src, const Pa::Label &label) {
+  void addSourceToSink(Fortran::lower::pft::Evaluation *src,
+                       const Fortran::parser::Label &label) {
     auto iter = labels.find(label);
     assert(iter != labels.end());
     addSourceToSink(src, iter->second);
@@ -158,10 +163,10 @@ class CfgBuilder {
   template <typename A>
   A nextFalseTarget(A iter, const A &endi) {
     for (; iter != endi; ++iter)
-      if (iter->visit(Co::visitors{
-              [&](const Pa::ElseIfStmt &) { return true; },
-              [&](const Pa::ElseStmt &) { return true; },
-              [&](const Pa::EndIfStmt &) { return true; },
+      if (iter->visit(Fortran::common::visitors{
+              [&](const Fortran::parser::ElseIfStmt &) { return true; },
+              [&](const Fortran::parser::ElseStmt &) { return true; },
+              [&](const Fortran::parser::EndIfStmt &) { return true; },
               [](auto &) { return false; },
           })) {
         break;
@@ -173,13 +178,15 @@ class CfgBuilder {
   /// Branch to the "true block", the "false block", and from the end of the
   /// true block to the end of the construct.
   template <typename A>
-  void doNextIfBlock(std::list<PFT::Evaluation> &evals, PFT::Evaluation &e,
-                     const A &iter, const A &endif) {
+  void doNextIfBlock(std::list<Fortran::lower::pft::Evaluation> &evals,
+                     Fortran::lower::pft::Evaluation &e, const A &iter,
+                     const A &endif) {
     A i{iter};
     A j{nextFalseTarget(++i, endif)};
-    auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
-    PFT::CGJump jump{*endif};
-    A k{evals.insert(j, PFT::Evaluation{std::move(jump), j->parent})};
+    auto *cstr = std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
+    Fortran::lower::pft::CGJump jump{*endif};
+    A k{evals.insert(
+        j, Fortran::lower::pft::Evaluation{std::move(jump), j->parent})};
     if (i == j) {
       // block was empty, so adjust "true" target
       i = k;
@@ -191,116 +198,125 @@ class CfgBuilder {
 
   /// Determine which branch targets are reachable. The target map must
   /// already be initialized.
-  void reachabilityAnalysis(std::list<PFT::Evaluation> &evals) {
+  void reachabilityAnalysis(std::list<Fortran::lower::pft::Evaluation> &evals) {
     for (auto iter = evals.begin(); iter != evals.end(); ++iter) {
       auto &e = *iter;
       switch (e.cfg) {
-      case PFT::CFGAnnotation::None:
+      case Fortran::lower::pft::CFGAnnotation::None:
         // do nothing - does not impart control flow
         break;
-      case PFT::CFGAnnotation::Goto:
-        e.visit(Co::visitors{
-            [&](const Pa::CycleStmt &) {
+      case Fortran::lower::pft::CFGAnnotation::Goto:
+        e.visit(Fortran::common::visitors{
+            [&](const Fortran::parser::CycleStmt &) {
               // FIXME: deal with construct name
-              auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
+              auto *cstr =
+                  std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
               addSourceToSink(&e, &cstr->subs->front());
             },
-            [&](const Pa::ExitStmt &) {
+            [&](const Fortran::parser::ExitStmt &) {
               // FIXME: deal with construct name
-              auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
+              auto *cstr =
+                  std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
               addSourceToSink(&e, &cstr->subs->back());
             },
-            [&](const Pa::GotoStmt &stmt) { addSourceToSink(&e, stmt.v); },
-            [&](const Pa::EndDoStmt &) {
+            [&](const Fortran::parser::GotoStmt &stmt) {
+              addSourceToSink(&e, stmt.v);
+            },
+            [&](const Fortran::parser::EndDoStmt &) {
               // the END DO is the loop exit landing pad
               // insert a JUMP as the backedge right before the END DO
-              auto *cstr = std::get<PFT::Evaluation *>(e.parent.p);
-              PFT::CGJump jump{cstr->subs->front()};
-              PFT::Evaluation jumpEval{std::move(jump), iter->parent};
+              auto *cstr =
+                  std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
+              Fortran::lower::pft::CGJump jump{cstr->subs->front()};
+              Fortran::lower::pft::Evaluation jumpEval{std::move(jump),
+                                                       iter->parent};
               evals.insert(iter, std::move(jumpEval));
               addSourceToSink(&e, &cstr->subs->front());
             },
-            [&](const PFT::CGJump &jump) { addSourceToSink(&e, &jump.target); },
+            [&](const Fortran::lower::pft::CGJump &jump) {
+              addSourceToSink(&e, &jump.target);
+            },
             [](auto &) { assert(false && "unhandled GOTO case"); },
         });
         break;
-      case PFT::CFGAnnotation::CondGoto:
-        e.visit(Co::visitors{
-            [&](const Pa::IfStmt &) {
+      case Fortran::lower::pft::CFGAnnotation::CondGoto:
+        e.visit(Fortran::common::visitors{
+            [&](const Fortran::parser::IfStmt &) {
               // check if these are marked; they must targets here
               auto i{iter};
               addSourceToSink(&e, &*(++i));
               addSourceToSink(&e, &*(++i));
             },
-            [&](const Pa::IfThenStmt &) {
+            [&](const Fortran::parser::IfThenStmt &) {
               doNextIfBlock(evals, e, iter, evals.end());
             },
-            [&](const Pa::ElseIfStmt &) {
+            [&](const Fortran::parser::ElseIfStmt &) {
               doNextIfBlock(evals, e, iter, evals.end());
             },
-            [](const Pa::WhereConstructStmt &) { TODO(); },
-            [](const Pa::MaskedElsewhereStmt &) { TODO(); },
+            [](const Fortran::parser::WhereConstructStmt &) { TODO(); },
+            [](const Fortran::parser::MaskedElsewhereStmt &) { TODO(); },
             [](auto &) { assert(false && "unhandled CGOTO case"); },
         });
         break;
-      case PFT::CFGAnnotation::IndGoto:
-        e.visit(Co::visitors{
-            [&](const Pa::AssignedGotoStmt &stmt) {
-              auto *sym = std::get<Pa::Name>(stmt.t).symbol;
+      case Fortran::lower::pft::CFGAnnotation::IndGoto:
+        e.visit(Fortran::common::visitors{
+            [&](const Fortran::parser::AssignedGotoStmt &stmt) {
+              auto *sym = std::get<Fortran::parser::Name>(stmt.t).symbol;
               if (assignedGotoMap.find(sym) != assignedGotoMap.end())
                 for (auto *x : assignedGotoMap[sym]) {
                   addSourceToSink(&e, x);
                 }
-              for (auto &l : std::get<std::list<Pa::Label>>(stmt.t)) {
+              for (auto &l :
+                   std::get<std::list<Fortran::parser::Label>>(stmt.t)) {
                 addSourceToSink(&e, l);
               }
             },
             [](auto &) { assert(false && "unhandled IGOTO case"); },
         });
         break;
-      case PFT::CFGAnnotation::IoSwitch:
-        e.visit(Co::visitors{
-            [](const Pa::BackspaceStmt &) { TODO(); },
-            [](const Pa::CloseStmt &) { TODO(); },
-            [](const Pa::EndfileStmt &) { TODO(); },
-            [](const Pa::FlushStmt &) { TODO(); },
-            [](const Pa::InquireStmt &) { TODO(); },
-            [](const Pa::OpenStmt &) { TODO(); },
-            [](const Pa::ReadStmt &) { TODO(); },
-            [](const Pa::RewindStmt &) { TODO(); },
-            [](const Pa::WaitStmt &) { TODO(); },
-            [](const Pa::WriteStmt &) { TODO(); },
+      case Fortran::lower::pft::CFGAnnotation::IoSwitch:
+        e.visit(Fortran::common::visitors{
+            [](const Fortran::parser::BackspaceStmt &) { TODO(); },
+            [](const Fortran::parser::CloseStmt &) { TODO(); },
+            [](const Fortran::parser::EndfileStmt &) { TODO(); },
+            [](const Fortran::parser::FlushStmt &) { TODO(); },
+            [](const Fortran::parser::InquireStmt &) { TODO(); },
+            [](const Fortran::parser::OpenStmt &) { TODO(); },
+            [](const Fortran::parser::ReadStmt &) { TODO(); },
+            [](const Fortran::parser::RewindStmt &) { TODO(); },
+            [](const Fortran::parser::WaitStmt &) { TODO(); },
+            [](const Fortran::parser::WriteStmt &) { TODO(); },
             [](auto &) { assert(false && "unhandled IO switch case"); },
         });
         break;
-      case PFT::CFGAnnotation::Switch:
-        e.visit(Co::visitors{
-            [](const Pa::CallStmt &) { TODO(); },
-            [](const Pa::ArithmeticIfStmt &) { TODO(); },
-            [](const Pa::ComputedGotoStmt &) { TODO(); },
-            [](const Pa::SelectCaseStmt &) { TODO(); },
-            [](const Pa::SelectRankStmt &) { TODO(); },
-            [](const Pa::SelectTypeStmt &) { TODO(); },
+      case Fortran::lower::pft::CFGAnnotation::Switch:
+        e.visit(Fortran::common::visitors{
+            [](const Fortran::parser::CallStmt &) { TODO(); },
+            [](const Fortran::parser::ArithmeticIfStmt &) { TODO(); },
+            [](const Fortran::parser::ComputedGotoStmt &) { TODO(); },
+            [](const Fortran::parser::SelectCaseStmt &) { TODO(); },
+            [](const Fortran::parser::SelectRankStmt &) { TODO(); },
+            [](const Fortran::parser::SelectTypeStmt &) { TODO(); },
             [](auto &) { assert(false && "unhandled switch case"); },
         });
         break;
-      case PFT::CFGAnnotation::Iterative:
-        e.visit(Co::visitors{
-            [](const Pa::NonLabelDoStmt &) { TODO(); },
-            [](const Pa::WhereStmt &) { TODO(); },
-            [](const Pa::ForallStmt &) { TODO(); },
-            [](const Pa::WhereConstruct &) { TODO(); },
-            [](const Pa::ForallConstructStmt &) { TODO(); },
+      case Fortran::lower::pft::CFGAnnotation::Iterative:
+        e.visit(Fortran::common::visitors{
+            [](const Fortran::parser::NonLabelDoStmt &) { TODO(); },
+            [](const Fortran::parser::WhereStmt &) { TODO(); },
+            [](const Fortran::parser::ForallStmt &) { TODO(); },
+            [](const Fortran::parser::WhereConstruct &) { TODO(); },
+            [](const Fortran::parser::ForallConstructStmt &) { TODO(); },
             [](auto &) { assert(false && "unhandled loop case"); },
         });
         break;
-      case PFT::CFGAnnotation::FirStructuredOp:
+      case Fortran::lower::pft::CFGAnnotation::FirStructuredOp:
         // do not visit the subs
         continue;
-      case PFT::CFGAnnotation::Return:
+      case Fortran::lower::pft::CFGAnnotation::Return:
         // do nothing - exits the function
         break;
-      case PFT::CFGAnnotation::Terminate:
+      case Fortran::lower::pft::CFGAnnotation::Terminate:
         // do nothing - exits the function
         break;
       }
@@ -310,7 +326,7 @@ class CfgBuilder {
     }
   }
 
-  void setActualTargets(std::list<PFT::Evaluation> &) {
+  void setActualTargets(std::list<Fortran::lower::pft::Evaluation> &) {
     for (auto &lst1 : cfgEdgeSetPool)
       for (auto *e : lst1) {
         e->isTarget = true;
@@ -320,14 +336,17 @@ class CfgBuilder {
   CFGMapType &cfgMap;
   std::list<CFGSinkListType> &cfgEdgeSetPool;
 
-  L::DenseMap<Pa::Label, PFT::Evaluation *> labels;
-  std::map<Se::Symbol *, std::list<PFT::Evaluation *>> assignedGotoMap;
+  llvm::DenseMap<Fortran::parser::Label, Fortran::lower::pft::Evaluation *>
+      labels;
+  std::map<Fortran::semantics::Symbol *,
+           std::list<Fortran::lower::pft::Evaluation *>>
+      assignedGotoMap;
 
 public:
   CfgBuilder(CFGMapType &m, std::list<CFGSinkListType> &p)
       : cfgMap{m}, cfgEdgeSetPool{p} {}
 
-  void run(PFT::FunctionLikeUnit &func) {
+  void run(Fortran::lower::pft::FunctionLikeUnit &func) {
     resetPotentialTargets(func.evals);
     cacheAssigns(func.evals);
     wrapIterationSpaces(func.evals);
diff --git a/lib/lower/ConvertExpr.cpp b/lib/lower/ConvertExpr.cpp
index 74dbbc55132c..8c89d6e25290 100644
--- a/lib/lower/ConvertExpr.cpp
+++ b/lib/lower/ConvertExpr.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/ConvertExpr.h"
-#include "NSAliases.h"
 #include "flang/common/default-kinds.h"
 #include "flang/common/unwrap.h"
 #include "flang/evaluate/fold.h"
@@ -37,43 +36,41 @@
 #include "llvm/IR/Type.h"
 #include "llvm/Support/raw_ostream.h"
 
-using namespace Fortran;
-using namespace Fortran::lower;
-
 namespace {
 
 #define TODO()                                                                 \
   assert(false);                                                               \
   return {}
 
-/// Lowering of Ev::Expr<T> expressions
+/// Lowering of Fortran::evaluate::Expr<T> expressions
 class ExprLowering {
-  M::Location location;
-  AbstractConverter &converter;
-  M::OpBuilder &builder;
-  SomeExpr const &expr;
-  SymMap &symMap;
-  IntrinsicLibrary const &intrinsics;
+  mlir::Location location;
+  Fortran::lower::AbstractConverter &converter;
+  mlir::OpBuilder &builder;
+  const Fortran::lower::SomeExpr &expr;
+  Fortran::lower::SymMap &symMap;
+  const Fortran::lower::IntrinsicLibrary &intrinsics;
   bool genLogicalAsI1{false};
 
-  M::Location getLoc() { return location; }
+  mlir::Location getLoc() { return location; }
 
   /// Convert parser's INTEGER relational operators to MLIR.  TODO: using
   /// unordered, but we may want to cons ordered in certain situation.
-  static M::CmpIPredicate translateRelational(Co::RelationalOperator rop) {
+  static mlir::CmpIPredicate
+  translateRelational(Fortran::common::RelationalOperator rop) {
     switch (rop) {
-    case Co::RelationalOperator::LT:
-      return M::CmpIPredicate::slt;
-    case Co::RelationalOperator::LE:
-      return M::CmpIPredicate::sle;
-    case Co::RelationalOperator::EQ:
-      return M::CmpIPredicate::eq;
-    case Co::RelationalOperator::NE:
-      return M::CmpIPredicate::ne;
-    case Co::RelationalOperator::GT:
-      return M::CmpIPredicate::sgt;
-    case Co::RelationalOperator::GE:
-      return M::CmpIPredicate::sge;
+    case Fortran::common::RelationalOperator::LT:
+      return mlir::CmpIPredicate::slt;
+    case Fortran::common::RelationalOperator::LE:
+      return mlir::CmpIPredicate::sle;
+    case Fortran::common::RelationalOperator::EQ:
+      return mlir::CmpIPredicate::eq;
+    case Fortran::common::RelationalOperator::NE:
+      return mlir::CmpIPredicate::ne;
+    case Fortran::common::RelationalOperator::GT:
+      return mlir::CmpIPredicate::sgt;
+    case Fortran::common::RelationalOperator::GE:
+      return mlir::CmpIPredicate::sge;
     }
     assert(false && "unhandled INTEGER relational operator");
     return {};
@@ -88,19 +85,19 @@ class ExprLowering {
   /// fully enforced. FIR and LLVM `fcmp` instructions do not give any guarantee
   /// whether the comparison will signal or not in case of quiet NaN argument.
   static fir::CmpFPredicate
-  translateFloatRelational(Co::RelationalOperator rop) {
+  translateFloatRelational(Fortran::common::RelationalOperator rop) {
     switch (rop) {
-    case Co::RelationalOperator::LT:
+    case Fortran::common::RelationalOperator::LT:
       return fir::CmpFPredicate::OLT;
-    case Co::RelationalOperator::LE:
+    case Fortran::common::RelationalOperator::LE:
       return fir::CmpFPredicate::OLE;
-    case Co::RelationalOperator::EQ:
+    case Fortran::common::RelationalOperator::EQ:
       return fir::CmpFPredicate::OEQ;
-    case Co::RelationalOperator::NE:
+    case Fortran::common::RelationalOperator::NE:
       return fir::CmpFPredicate::UNE;
-    case Co::RelationalOperator::GT:
+    case Fortran::common::RelationalOperator::GT:
       return fir::CmpFPredicate::OGT;
-    case Co::RelationalOperator::GE:
+    case Fortran::common::RelationalOperator::GE:
       return fir::CmpFPredicate::OGE;
     }
     assert(false && "unhandled REAL relational operator");
@@ -109,72 +106,74 @@ class ExprLowering {
 
   /// Generate an integral constant of `value`
   template <int KIND>
-  M::Value genIntegerConstant(M::MLIRContext *context, std::int64_t value) {
-    M::Type type{converter.genType(IntegerCat, KIND)};
-    auto attr{builder.getIntegerAttr(type, value)};
-    auto res{builder.create<M::ConstantOp>(getLoc(), type, attr)};
+  mlir::Value genIntegerConstant(mlir::MLIRContext *context,
+                                 std::int64_t value) {
+    auto type = converter.genType(Fortran::lower::IntegerCat, KIND);
+    auto attr = builder.getIntegerAttr(type, value);
+    auto res = builder.create<mlir::ConstantOp>(getLoc(), type, attr);
     return res.getResult();
   }
 
   /// Generate a logical/boolean constant of `value`
-  M::Value genLogicalConstantAsI1(M::MLIRContext *context, bool value) {
-    M::Type i1Type{M::IntegerType::get(1, builder.getContext())};
-    auto attr{builder.getIntegerAttr(i1Type, value ? 1 : 0)};
-    return builder.create<M::ConstantOp>(getLoc(), i1Type, attr).getResult();
+  mlir::Value genLogicalConstantAsI1(mlir::MLIRContext *context, bool value) {
+    auto i1Type = mlir::IntegerType::get(1, builder.getContext());
+    auto attr = builder.getIntegerAttr(i1Type, value ? 1 : 0);
+    return builder.create<mlir::ConstantOp>(getLoc(), i1Type, attr).getResult();
   }
 
   template <int KIND>
-  M::Value genRealConstant(M::MLIRContext *context, L::APFloat const &value) {
-    M::Type fltTy{convertReal(context, KIND)};
-    auto attr{builder.getFloatAttr(fltTy, value)};
-    auto res{builder.create<M::ConstantOp>(getLoc(), fltTy, attr)};
+  mlir::Value genRealConstant(mlir::MLIRContext *context,
+                              const llvm::APFloat &value) {
+    auto fltTy = Fortran::lower::convertReal(context, KIND);
+    auto attr = builder.getFloatAttr(fltTy, value);
+    auto res = builder.create<mlir::ConstantOp>(getLoc(), fltTy, attr);
     return res.getResult();
   }
 
-  M::Type getSomeKindInteger() {
-    return M::IndexType::get(builder.getContext());
+  mlir::Type getSomeKindInteger() {
+    return mlir::IndexType::get(builder.getContext());
   }
 
   template <typename OpTy, typename A>
-  M::Value createBinaryOp(A const &ex, M::Value lhs, M::Value rhs) {
+  mlir::Value createBinaryOp(const A &ex, mlir::Value lhs, mlir::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), lhs, rhs);
     return x.getResult();
   }
   template <typename OpTy, typename A>
-  M::Value createBinaryOp(A const &ex, M::Value rhs) {
+  mlir::Value createBinaryOp(const A &ex, mlir::Value rhs) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), rhs);
   }
   template <typename OpTy, typename A>
-  M::Value createBinaryOp(A const &ex) {
+  mlir::Value createBinaryOp(const A &ex) {
     return createBinaryOp<OpTy>(ex, genval(ex.left()), genval(ex.right()));
   }
 
-  M::FuncOp getFunction(L::StringRef name, M::FunctionType funTy) {
-    auto module{getModule(&builder)};
-    if (M::FuncOp func{getNamedFunction(module, name)}) {
+  mlir::FuncOp getFunction(llvm::StringRef name, mlir::FunctionType funTy) {
+    auto module = Fortran::lower::getModule(&builder);
+    if (auto func = Fortran::lower::getNamedFunction(module, name)) {
       assert(func.getType() == funTy &&
              "function already declared with a different type");
       return func;
     }
-    return createFunction(module, name, funTy);
+    return Fortran::lower::createFunction(module, name, funTy);
   }
 
   // FIXME binary operation :: ('a, 'a) -> 'a
-  template <Co::TypeCategory TC, int KIND>
-  M::FunctionType createFunctionType() {
-    if constexpr (TC == IntegerCat) {
-      M::Type output{converter.genType(IntegerCat, KIND)};
-      L::SmallVector<M::Type, 2> inputs;
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::FunctionType createFunctionType() {
+    if constexpr (TC == Fortran::lower::IntegerCat) {
+      auto output = converter.genType(Fortran::lower::IntegerCat, KIND);
+      llvm::SmallVector<mlir::Type, 2> inputs;
       inputs.push_back(output);
       inputs.push_back(output);
-      return M::FunctionType::get(inputs, output, builder.getContext());
-    } else if constexpr (TC == RealCat) {
-      M::Type output{convertReal(builder.getContext(), KIND)};
-      L::SmallVector<M::Type, 2> inputs;
+      return mlir::FunctionType::get(inputs, output, builder.getContext());
+    } else if constexpr (TC == Fortran::lower::RealCat) {
+      auto output = Fortran::lower::convertReal(builder.getContext(), KIND);
+      llvm::SmallVector<mlir::Type, 2> inputs;
       inputs.push_back(output);
       inputs.push_back(output);
-      return M::FunctionType::get(inputs, output, builder.getContext());
+      return mlir::FunctionType::get(inputs, output, builder.getContext());
     } else {
       assert(false);
       return {};
@@ -182,40 +181,40 @@ class ExprLowering {
   }
 
   template <typename OpTy, typename A>
-  M::Value createCompareOp(A const &ex, M::CmpIPredicate pred, M::Value lhs,
-                           M::Value rhs) {
+  mlir::Value createCompareOp(const A &ex, mlir::CmpIPredicate pred,
+                              mlir::Value lhs, mlir::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
   template <typename OpTy, typename A>
-  M::Value createCompareOp(A const &ex, M::CmpIPredicate pred) {
+  mlir::Value createCompareOp(const A &ex, mlir::CmpIPredicate pred) {
     return createCompareOp<OpTy>(ex, pred, genval(ex.left()),
                                  genval(ex.right()));
   }
   template <typename OpTy, typename A>
-  M::Value createFltCmpOp(A const &ex, fir::CmpFPredicate pred, M::Value lhs,
-                          M::Value rhs) {
+  mlir::Value createFltCmpOp(const A &ex, fir::CmpFPredicate pred,
+                             mlir::Value lhs, mlir::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
   template <typename OpTy, typename A>
-  M::Value createFltCmpOp(A const &ex, fir::CmpFPredicate pred) {
+  mlir::Value createFltCmpOp(const A &ex, fir::CmpFPredicate pred) {
     return createFltCmpOp<OpTy>(ex, pred, genval(ex.left()),
                                 genval(ex.right()));
   }
 
-  M::Value gen(Se::SymbolRef sym) {
+  mlir::Value gen(Fortran::semantics::SymbolRef sym) {
     // FIXME: not all symbols are local
-    auto addr{createTemporary(getLoc(), builder, symMap, converter.genType(sym),
-                              &*sym)};
+    auto addr = createTemporary(getLoc(), builder, symMap,
+                                converter.genType(sym), &*sym);
     assert(addr && "failed generating symbol address");
     // Get address from descriptor if symbol has one.
-    auto type{addr.getType()};
-    if (auto boxCharType{type.dyn_cast<fir::BoxCharType>()}) {
-      auto refType{fir::ReferenceType::get(boxCharType.getEleTy())};
-      auto lenType{M::IntegerType::get(64, builder.getContext())};
+    auto type = addr.getType();
+    if (auto boxCharType = type.dyn_cast<fir::BoxCharType>()) {
+      auto refType = fir::ReferenceType::get(boxCharType.getEleTy());
+      auto lenType = mlir::IntegerType::get(64, builder.getContext());
       addr = builder.create<fir::UnboxCharOp>(getLoc(), refType, lenType, addr)
                  .getResult(0);
     } else if (type.isa<fir::BoxType>()) {
@@ -224,32 +223,33 @@ class ExprLowering {
     return addr;
   }
 
-  M::Value gendef(Se::SymbolRef sym) { return gen(sym); }
+  mlir::Value gendef(Fortran::semantics::SymbolRef sym) { return gen(sym); }
 
-  M::Value genval(Se::SymbolRef sym) {
+  mlir::Value genval(Fortran::semantics::SymbolRef sym) {
     auto var = gen(sym);
-    if (fir::isReferenceLike(var.getType())) {
+    if (fir::isReferenceLike(var.getType()))
       return builder.create<fir::LoadOp>(getLoc(), var);
-    }
     return var;
   }
 
-  M::Value genval(Ev::BOZLiteralConstant const &) { TODO(); }
-  M::Value genval(Ev::ProcedureRef const &) { TODO(); }
-  M::Value genval(Ev::ProcedureDesignator const &) { TODO(); }
-  M::Value genval(Ev::NullPointer const &) { TODO(); }
-  M::Value genval(Ev::StructureConstructor const &) { TODO(); }
-  M::Value genval(Ev::ImpliedDoIndex const &) { TODO(); }
-  M::Value genval(Ev::DescriptorInquiry const &desc) {
-    auto descRef{symMap.lookupSymbol(desc.base().GetLastSymbol())};
-    assert(descRef && "no M::Value associated to Symbol");
-    auto descType{descRef.getType()};
-    M::Value res{};
+  mlir::Value genval(const Fortran::evaluate::BOZLiteralConstant &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::ProcedureRef &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::ProcedureDesignator &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::NullPointer &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::StructureConstructor &) {
+    TODO();
+  }
+  mlir::Value genval(const Fortran::evaluate::ImpliedDoIndex &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::DescriptorInquiry &desc) {
+    auto descRef = symMap.lookupSymbol(desc.base().GetLastSymbol());
+    assert(descRef && "no mlir::Value associated to Symbol");
+    auto descType = descRef.getType();
+    mlir::Value res{};
     switch (desc.field()) {
-    case Ev::DescriptorInquiry::Field::Len:
-      if (auto boxCharType{descType.dyn_cast<fir::BoxCharType>()}) {
-        auto refType{fir::ReferenceType::get(boxCharType.getEleTy())};
-        auto lenType{M::IntegerType::get(64, builder.getContext())};
+    case Fortran::evaluate::DescriptorInquiry::Field::Len:
+      if (auto boxCharType = descType.dyn_cast<fir::BoxCharType>()) {
+        auto refType = fir::ReferenceType::get(boxCharType.getEleTy());
+        auto lenType = mlir::IntegerType::get(64, builder.getContext());
         res = builder
                   .create<fir::UnboxCharOp>(getLoc(), refType, lenType, descRef)
                   .getResult(1);
@@ -266,144 +266,172 @@ class ExprLowering {
   }
 
   template <int KIND>
-  M::Value genval(Ev::TypeParamInquiry<KIND> const &) {
+  mlir::Value genval(const Fortran::evaluate::TypeParamInquiry<KIND> &) {
     TODO();
   }
 
   template <int KIND>
-  M::Value genval(Ev::ComplexComponent<KIND> const &part) {
-    return ComplexOpsBuilder{builder, getLoc()}.extractComplexPart(
-        genval(part.left()), part.isImaginaryPart);
+  mlir::Value genval(const Fortran::evaluate::ComplexComponent<KIND> &part) {
+    return Fortran::lower::ComplexOpsBuilder{builder, getLoc()}
+        .extractComplexPart(genval(part.left()), part.isImaginaryPart);
   }
 
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Negate<Ev::Type<TC, KIND>> const &op) {
-    auto input{genval(op.left())};
-    if constexpr (TC == IntegerCat) {
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value genval(
+      const Fortran::evaluate::Negate<Fortran::evaluate::Type<TC, KIND>> &op) {
+    auto input = genval(op.left());
+    if constexpr (TC == Fortran::lower::IntegerCat) {
       // Currently no Standard/FIR op for integer negation.
-      auto zero{genIntegerConstant<KIND>(builder.getContext(), 0)};
-      return builder.create<M::SubIOp>(getLoc(), zero, input);
-    } else if constexpr (TC == RealCat) {
+      auto zero = genIntegerConstant<KIND>(builder.getContext(), 0);
+      return builder.create<mlir::SubIOp>(getLoc(), zero, input);
+    } else if constexpr (TC == Fortran::lower::RealCat) {
       return builder.create<fir::NegfOp>(getLoc(), input);
     } else {
-      static_assert(TC == ComplexCat, "Expected numeric type");
+      static_assert(TC == Fortran::lower::ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::NegcOp>(op);
     }
   }
 
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Add<Ev::Type<TC, KIND>> const &op) {
-    if constexpr (TC == IntegerCat) {
-      return createBinaryOp<M::AddIOp>(op);
-    } else if constexpr (TC == RealCat) {
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::Add<Fortran::evaluate::Type<TC, KIND>> &op) {
+    if constexpr (TC == Fortran::lower::IntegerCat) {
+      return createBinaryOp<mlir::AddIOp>(op);
+    } else if constexpr (TC == Fortran::lower::RealCat) {
       return createBinaryOp<fir::AddfOp>(op);
     } else {
-      static_assert(TC == ComplexCat, "Expected numeric type");
+      static_assert(TC == Fortran::lower::ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::AddcOp>(op);
     }
   }
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Subtract<Ev::Type<TC, KIND>> const &op) {
-    if constexpr (TC == IntegerCat) {
-      return createBinaryOp<M::SubIOp>(op);
-    } else if constexpr (TC == RealCat) {
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<TC, KIND>>
+             &op) {
+    if constexpr (TC == Fortran::lower::IntegerCat) {
+      return createBinaryOp<mlir::SubIOp>(op);
+    } else if constexpr (TC == Fortran::lower::RealCat) {
       return createBinaryOp<fir::SubfOp>(op);
     } else {
-      static_assert(TC == ComplexCat, "Expected numeric type");
+      static_assert(TC == Fortran::lower::ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::SubcOp>(op);
     }
   }
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Multiply<Ev::Type<TC, KIND>> const &op) {
-    if constexpr (TC == IntegerCat) {
-      return createBinaryOp<M::MulIOp>(op);
-    } else if constexpr (TC == RealCat) {
+
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<TC, KIND>>
+             &op) {
+    if constexpr (TC == Fortran::lower::IntegerCat) {
+      return createBinaryOp<mlir::MulIOp>(op);
+    } else if constexpr (TC == Fortran::lower::RealCat) {
       return createBinaryOp<fir::MulfOp>(op);
     } else {
-      static_assert(TC == ComplexCat, "Expected numeric type");
+      static_assert(TC == Fortran::lower::ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::MulcOp>(op);
     }
   }
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Divide<Ev::Type<TC, KIND>> const &op) {
-    if constexpr (TC == IntegerCat) {
-      return createBinaryOp<M::SignedDivIOp>(op);
-    } else if constexpr (TC == RealCat) {
+
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value genval(
+      const Fortran::evaluate::Divide<Fortran::evaluate::Type<TC, KIND>> &op) {
+    if constexpr (TC == Fortran::lower::IntegerCat) {
+      return createBinaryOp<mlir::SignedDivIOp>(op);
+    } else if constexpr (TC == Fortran::lower::RealCat) {
       return createBinaryOp<fir::DivfOp>(op);
     } else {
-      static_assert(TC == ComplexCat, "Expected numeric type");
+      static_assert(TC == Fortran::lower::ComplexCat, "Expected numeric type");
       return createBinaryOp<fir::DivcOp>(op);
     }
   }
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Power<Ev::Type<TC, KIND>> const &op) {
-    L::SmallVector<M::Value, 2> operands{genval(op.left()), genval(op.right())};
-    M::Type ty{converter.genType(TC, KIND)};
+
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value genval(
+      const Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>> &op) {
+    llvm::SmallVector<mlir::Value, 2> operands{genval(op.left()),
+                                               genval(op.right())};
+    auto ty = converter.genType(TC, KIND);
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::RealToIntPower<Ev::Type<TC, KIND>> const &op) {
+
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value genval(
+      const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>
+          &op) {
     // TODO: runtime as limited integer kind support. Look if the conversions
     // are ok
-    L::SmallVector<M::Value, 2> operands{genval(op.left()), genval(op.right())};
-    M::Type ty{converter.genType(TC, KIND)};
+    llvm::SmallVector<mlir::Value, 2> operands{genval(op.left()),
+                                               genval(op.right())};
+    auto ty = converter.genType(TC, KIND);
     return intrinsics.genval(getLoc(), builder, "pow", ty, operands);
   }
 
   template <int KIND>
-  M::Value genval(Ev::ComplexConstructor<KIND> const &op) {
-    return ComplexOpsBuilder{builder, getLoc()}.createComplex(
+  mlir::Value genval(const Fortran::evaluate::ComplexConstructor<KIND> &op) {
+    return Fortran::lower::ComplexOpsBuilder{builder, getLoc()}.createComplex(
         KIND, genval(op.left()), genval(op.right()));
   }
+
   template <int KIND>
-  M::Value genval(Ev::Concat<KIND> const &op) {
+  mlir::Value genval(const Fortran::evaluate::Concat<KIND> &op) {
     TODO();
   }
 
   /// MIN and MAX operations
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Extremum<Ev::Type<TC, KIND>> const &op) {
-    std::string name{op.ordering == Ev::Ordering::Greater ? "max" : "min"};
-    M::Type type{converter.genType(TC, KIND)};
-    L::SmallVector<M::Value, 2> operands{genval(op.left()), genval(op.right())};
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>>
+             &op) {
+    std::string name =
+        op.ordering == Fortran::evaluate::Ordering::Greater ? "max"s : "min"s;
+    auto type = converter.genType(TC, KIND);
+    llvm::SmallVector<mlir::Value, 2> operands{genval(op.left()),
+                                               genval(op.right())};
     return intrinsics.genval(getLoc(), builder, name, type, operands);
   }
 
   template <int KIND>
-  M::Value genval(Ev::SetLength<KIND> const &) {
+  mlir::Value genval(const Fortran::evaluate::SetLength<KIND> &) {
     TODO();
   }
 
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(Ev::Relational<Ev::Type<TC, KIND>> const &op) {
-    M::Value result{nullptr};
-    if constexpr (TC == IntegerCat) {
-      result = createCompareOp<M::CmpIOp>(op, translateRelational(op.opr));
-    } else if constexpr (TC == RealCat) {
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::Relational<Fortran::evaluate::Type<TC, KIND>>
+             &op) {
+    mlir::Value result{};
+    if constexpr (TC == Fortran::lower::IntegerCat) {
+      result = createCompareOp<mlir::CmpIOp>(op, translateRelational(op.opr));
+    } else if constexpr (TC == Fortran::lower::RealCat) {
       result =
           createFltCmpOp<fir::CmpfOp>(op, translateFloatRelational(op.opr));
-    } else if constexpr (TC == ComplexCat) {
-      bool eq{op.opr == Co::RelationalOperator::EQ};
-      assert(eq || op.opr == Co::RelationalOperator::NE &&
+    } else if constexpr (TC == Fortran::lower::ComplexCat) {
+      bool eq{op.opr == Fortran::common::RelationalOperator::EQ};
+      assert(eq || op.opr == Fortran::common::RelationalOperator::NE &&
                        "relation undefined for complex");
-      result = ComplexOpsBuilder{builder, getLoc()}.createComplexCompare(
-          genval(op.left()), genval(op.right()), eq);
+      result =
+          Fortran::lower::ComplexOpsBuilder{builder, getLoc()}
+              .createComplexCompare(genval(op.left()), genval(op.right()), eq);
     } else {
-      static_assert(TC == CharacterCat);
+      static_assert(TC == Fortran::lower::CharacterCat);
       TODO();
     }
     return result;
   }
 
-  M::Value genval(Ev::Relational<Ev::SomeType> const &op) {
+  mlir::Value
+  genval(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &op) {
     return std::visit([&](const auto &x) { return genval(x); }, op.u);
   }
 
-  template <Co::TypeCategory TC1, int KIND, Co::TypeCategory TC2>
-  M::Value genval(Ev::Convert<Ev::Type<TC1, KIND>, TC2> const &convert) {
-    auto ty{converter.genType(TC1, KIND)};
-    M::Value operand{genval(convert.left())};
-    if (TC1 == LogicalCat && genLogicalAsI1) {
+  template <Fortran::common::TypeCategory TC1, int KIND,
+            Fortran::common::TypeCategory TC2>
+  mlir::Value
+  genval(const Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>,
+                                          TC2> &convert) {
+    auto ty = converter.genType(TC1, KIND);
+    auto operand = genval(convert.left());
+    if (TC1 == Fortran::lower::LogicalCat && genLogicalAsI1) {
       // If an i1 result is needed, it does not make sens to convert between
       // `fir.logical` types to later convert back to the result to i1.
       return operand;
@@ -412,40 +440,40 @@ class ExprLowering {
   }
 
   template <typename A>
-  M::Value genval(Ev::Parentheses<A> const &) {
+  mlir::Value genval(const Fortran::evaluate::Parentheses<A> &) {
     TODO();
   }
 
   template <int KIND>
-  M::Value genval(const Ev::Not<KIND> &op) {
+  mlir::Value genval(const Fortran::evaluate::Not<KIND> &op) {
     // Request operands to be generated as `i1` and restore after this scope.
-    auto restorer{Co::ScopedSet(genLogicalAsI1, true)};
-    auto *context{builder.getContext()};
-    auto logical{genval(op.left())};
-    auto one{genLogicalConstantAsI1(context, true)};
-    return builder.create<M::XOrOp>(getLoc(), logical, one).getResult();
+    auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, true);
+    auto *context = builder.getContext();
+    auto logical = genval(op.left());
+    auto one = genLogicalConstantAsI1(context, true);
+    return builder.create<mlir::XOrOp>(getLoc(), logical, one).getResult();
   }
 
   template <int KIND>
-  M::Value genval(Ev::LogicalOperation<KIND> const &op) {
+  mlir::Value genval(const Fortran::evaluate::LogicalOperation<KIND> &op) {
     // Request operands to be generated as `i1` and restore after this scope.
-    auto restorer{Co::ScopedSet(genLogicalAsI1, true)};
-    M::Value result;
+    auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, true);
+    mlir::Value result;
     switch (op.logicalOperator) {
-    case Ev::LogicalOperator::And:
-      result = createBinaryOp<M::AndOp>(op);
+    case Fortran::evaluate::LogicalOperator::And:
+      result = createBinaryOp<mlir::AndOp>(op);
       break;
-    case Ev::LogicalOperator::Or:
-      result = createBinaryOp<M::OrOp>(op);
+    case Fortran::evaluate::LogicalOperator::Or:
+      result = createBinaryOp<mlir::OrOp>(op);
       break;
-    case Ev::LogicalOperator::Eqv:
-      result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::eq);
+    case Fortran::evaluate::LogicalOperator::Eqv:
+      result = createCompareOp<mlir::CmpIOp>(op, mlir::CmpIPredicate::eq);
       break;
-    case Ev::LogicalOperator::Neqv:
-      result = createCompareOp<M::CmpIOp>(op, M::CmpIPredicate::ne);
+    case Fortran::evaluate::LogicalOperator::Neqv:
+      result = createCompareOp<mlir::CmpIOp>(op, mlir::CmpIPredicate::ne);
       break;
-    case Ev::LogicalOperator::Not:
-      // lib/evaluate expression for .NOT. is Ev::Not<KIND>.
+    case Fortran::evaluate::LogicalOperator::Not:
+      // lib/evaluate expression for .NOT. is Fortran::evaluate::Not<KIND>.
       assert(false && ".NOT. is not a binary operator");
       break;
     }
@@ -457,75 +485,79 @@ class ExprLowering {
 
   /// Construct a CHARACTER literal
   template <int KIND, typename E>
-  M::Value genCharLit(const E &data, int64_t size) {
+  mlir::Value genCharLit(const E &data, int64_t size) {
     auto context = builder.getContext();
-    auto valTag = M::Identifier::get(fir::StringLitOp::value(), context);
+    auto valTag = mlir::Identifier::get(fir::StringLitOp::value(), context);
     // FIXME: for wider char types, use an array of i16 or i32
     // for now, just fake it that it's a i8 to get it past the C++ compiler
-    auto strAttr = M::StringAttr::get((const char *)data.c_str(), context);
-    M::NamedAttribute dataAttr(valTag, strAttr);
-    auto sizeTag = M::Identifier::get(fir::StringLitOp::size(), context);
-    M::NamedAttribute sizeAttr(sizeTag, builder.getI64IntegerAttr(size));
-    L::SmallVector<M::NamedAttribute, 2> attrs{dataAttr, sizeAttr};
+    auto strAttr = mlir::StringAttr::get((const char *)data.c_str(), context);
+    mlir::NamedAttribute dataAttr(valTag, strAttr);
+    auto sizeTag = mlir::Identifier::get(fir::StringLitOp::size(), context);
+    mlir::NamedAttribute sizeAttr(sizeTag, builder.getI64IntegerAttr(size));
+    llvm::SmallVector<mlir::NamedAttribute, 2> attrs{dataAttr, sizeAttr};
     auto type =
         fir::SequenceType::get({size}, fir::CharacterType::get(context, KIND));
     return builder.create<fir::StringLitOp>(
-        getLoc(), L::ArrayRef<M::Type>{type}, L::None, attrs);
+        getLoc(), llvm::ArrayRef<mlir::Type>{type}, llvm::None, attrs);
   }
 
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(const Ev::Constant<Ev::Type<TC, KIND>> &con) {
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>>
+             &con) {
     // TODO:
     // - character type constant
     // - array constant not handled
     // - derived type constant
-    if constexpr (TC == IntegerCat) {
-      auto opt{con.GetScalarValue()};
+    if constexpr (TC == Fortran::lower::IntegerCat) {
+      auto opt = con.GetScalarValue();
       if (opt.has_value())
         return genIntegerConstant<KIND>(builder.getContext(), opt->ToInt64());
       assert(false && "integer constant has no value");
       return {};
-    } else if constexpr (TC == LogicalCat) {
-      auto opt{con.GetScalarValue()};
+    } else if constexpr (TC == Fortran::lower::LogicalCat) {
+      auto opt = con.GetScalarValue();
       if (opt.has_value())
         return genLogicalConstantAsI1(builder.getContext(), opt->IsTrue());
       assert(false && "logical constant has no value");
       return {};
-    } else if constexpr (TC == RealCat) {
-      auto opt{con.GetScalarValue()};
+    } else if constexpr (TC == Fortran::lower::RealCat) {
+      auto opt = con.GetScalarValue();
       if (opt.has_value()) {
-        std::string str{opt.value().DumpHexadecimal()};
+        std::string str = opt.value().DumpHexadecimal();
         if constexpr (KIND == 2) {
-          L::APFloat floatVal{L::APFloatBase::IEEEhalf(), str};
+          llvm::APFloat floatVal{llvm::APFloatBase::IEEEhalf(), str};
           return genRealConstant<KIND>(builder.getContext(), floatVal);
         } else if constexpr (KIND == 4) {
-          L::APFloat floatVal{L::APFloatBase::IEEEsingle(), str};
+          llvm::APFloat floatVal{llvm::APFloatBase::IEEEsingle(), str};
           return genRealConstant<KIND>(builder.getContext(), floatVal);
         } else if constexpr (KIND == 10) {
-          L::APFloat floatVal{L::APFloatBase::x87DoubleExtended(), str};
+          llvm::APFloat floatVal{llvm::APFloatBase::x87DoubleExtended(), str};
           return genRealConstant<KIND>(builder.getContext(), floatVal);
         } else if constexpr (KIND == 16) {
-          L::APFloat floatVal{L::APFloatBase::IEEEquad(), str};
+          llvm::APFloat floatVal{llvm::APFloatBase::IEEEquad(), str};
           return genRealConstant<KIND>(builder.getContext(), floatVal);
         } else {
           // convert everything else to double
-          L::APFloat floatVal{L::APFloatBase::IEEEdouble(), str};
+          llvm::APFloat floatVal{llvm::APFloatBase::IEEEdouble(), str};
           return genRealConstant<KIND>(builder.getContext(), floatVal);
         }
       }
       assert(false && "real constant has no value");
       return {};
-    } else if constexpr (TC == ComplexCat) {
-      auto opt{con.GetScalarValue()};
+    } else if constexpr (TC == Fortran::lower::ComplexCat) {
+      auto opt = con.GetScalarValue();
       if (opt.has_value()) {
-        using TR = Ev::Type<RealCat, KIND>;
-        return genval(Ev::ComplexConstructor<KIND>{
-            Ev::Expr<TR>{Ev::Constant<TR>{opt->REAL()}},
-            Ev::Expr<TR>{Ev::Constant<TR>{opt->AIMAG()}}});
+        using TR = Fortran::evaluate::Type<Fortran::lower::RealCat, KIND>;
+        return genval(Fortran::evaluate::ComplexConstructor<KIND>{
+            Fortran::evaluate::Expr<TR>{
+                Fortran::evaluate::Constant<TR>{opt->REAL()}},
+            Fortran::evaluate::Expr<TR>{
+                Fortran::evaluate::Constant<TR>{opt->AIMAG()}}});
       }
       assert(false && "array of complex unhandled");
       return {};
-    } else if constexpr (TC == CharacterCat) {
+    } else if constexpr (TC == Fortran::lower::CharacterCat) {
       return genCharLit<KIND>(con.GetScalarValue().value(), con.LEN());
     } else {
       assert(false && "unhandled constant");
@@ -533,13 +565,14 @@ class ExprLowering {
     }
   }
 
-  template <Co::TypeCategory TC>
-  M::Value genval(Ev::Constant<Ev::SomeKind<TC>> const &con) {
-    if constexpr (TC == IntegerCat) {
+  template <Fortran::common::TypeCategory TC>
+  mlir::Value genval(
+      const Fortran::evaluate::Constant<Fortran::evaluate::SomeKind<TC>> &con) {
+    if constexpr (TC == Fortran::lower::IntegerCat) {
       auto opt = (*con).ToInt64();
-      M::Type type{getSomeKindInteger()};
-      auto attr{builder.getIntegerAttr(type, opt)};
-      auto res{builder.create<M::ConstantOp>(getLoc(), type, attr)};
+      auto type = getSomeKindInteger();
+      auto attr = builder.getIntegerAttr(type, opt);
+      auto res = builder.create<mlir::ConstantOp>(getLoc(), type, attr);
       return res.getResult();
     } else {
       assert(false && "unhandled constant of unknown kind");
@@ -548,88 +581,96 @@ class ExprLowering {
   }
 
   template <typename A>
-  M::Value genval(Ev::ArrayConstructor<A> const &) {
+  mlir::Value genval(const Fortran::evaluate::ArrayConstructor<A> &) {
     TODO();
   }
-  M::Value gen(Ev::ComplexPart const &) { TODO(); }
-  M::Value gendef(Ev::ComplexPart const &cp) { return gen(cp); }
-  M::Value genval(Ev::ComplexPart const &) { TODO(); }
+  mlir::Value gen(const Fortran::evaluate::ComplexPart &) { TODO(); }
+  mlir::Value gendef(const Fortran::evaluate::ComplexPart &cp) {
+    return gen(cp);
+  }
+  mlir::Value genval(const Fortran::evaluate::ComplexPart &) { TODO(); }
 
-  M::Value gen(const Ev::Substring &s) {
+  mlir::Value gen(const Fortran::evaluate::Substring &s) {
     // Get base address
-    auto baseAddr{std::visit(
-        Co::visitors{
-            [&](const Ev::DataRef &x) { return gen(x); },
-            [&](const Ev::StaticDataObject::Pointer &) -> M::Value { TODO(); },
+    auto baseAddr = std::visit(
+        Fortran::common::visitors{
+            [&](const Fortran::evaluate::DataRef &x) { return gen(x); },
+            [&](const Fortran::evaluate::StaticDataObject::Pointer &)
+                -> mlir::Value { TODO(); },
         },
-        s.parent())};
+        s.parent());
     // Get a SequenceType to compute address with fir::CoordinateOp
-    auto charRefType{baseAddr.getType()};
-    auto arrayRefType{getSequenceRefType(charRefType)};
-    auto arrayView{
-        builder.create<fir::ConvertOp>(getLoc(), arrayRefType, baseAddr)};
+    auto charRefType = baseAddr.getType();
+    auto arrayRefType = Fortran::lower::getSequenceRefType(charRefType);
+    auto arrayView =
+        builder.create<fir::ConvertOp>(getLoc(), arrayRefType, baseAddr);
     // Compute lower bound
-    auto indexType{M::IndexType::get(builder.getContext())};
-    auto lowerBoundExpr{s.lower()};
-    auto lowerBoundValue{builder.create<fir::ConvertOp>(
-        getLoc(), indexType, genval(lowerBoundExpr))};
+    auto indexType = mlir::IndexType::get(builder.getContext());
+    auto lowerBoundExpr = s.lower();
+    auto lowerBoundValue = builder.create<fir::ConvertOp>(
+        getLoc(), indexType, genval(lowerBoundExpr));
     // FIR CoordinateOp is zero based but Fortran substring are one based.
-    auto one{builder.create<M::ConstantOp>(
-        getLoc(), indexType, builder.getIntegerAttr(indexType, 1))};
-    auto offsetIndex{
-        builder.create<M::SubIOp>(getLoc(), lowerBoundValue, one).getResult()};
+    auto one = builder.create<mlir::ConstantOp>(
+        getLoc(), indexType, builder.getIntegerAttr(indexType, 1));
+    auto offsetIndex =
+        builder.create<mlir::SubIOp>(getLoc(), lowerBoundValue, one)
+            .getResult();
     // Get address from offset and base address
     return builder.create<fir::CoordinateOp>(getLoc(), charRefType, arrayView,
                                              offsetIndex);
   }
 
-  M::Value gendef(const Ev::Substring &ss) { return gen(ss); }
-  M::Value genval(const Ev::Substring &) { TODO(); }
-  M::Value genval(const Ev::Triplet &trip) { TODO(); }
+  mlir::Value gendef(const Fortran::evaluate::Substring &ss) { return gen(ss); }
+  mlir::Value genval(const Fortran::evaluate::Substring &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::Triplet &trip) { TODO(); }
 
-  M::Value genval(const Ev::Subscript &subs) {
-    return std::visit(Co::visitors{
-                          [&](const Ev::IndirectSubscriptIntegerExpr &x) {
-                            return genval(x.value());
-                          },
-                          [&](const Ev::Triplet &x) { return genval(x); },
-                      },
-                      subs.u);
+  mlir::Value genval(const Fortran::evaluate::Subscript &subs) {
+    return std::visit(
+        Fortran::common::visitors{
+            [&](const Fortran::evaluate::IndirectSubscriptIntegerExpr &x) {
+              return genval(x.value());
+            },
+            [&](const Fortran::evaluate::Triplet &x) { return genval(x); },
+        },
+        subs.u);
   }
 
-  M::Value gen(const Ev::DataRef &dref) {
+  mlir::Value gen(const Fortran::evaluate::DataRef &dref) {
     return std::visit([&](const auto &x) { return gen(x); }, dref.u);
   }
-  M::Value gendef(Ev::DataRef const &dref) { return gen(dref); }
-  M::Value genval(Ev::DataRef const &dref) {
+  mlir::Value gendef(const Fortran::evaluate::DataRef &dref) {
+    return gen(dref);
+  }
+  mlir::Value genval(const Fortran::evaluate::DataRef &dref) {
     return std::visit([&](const auto &x) { return genval(x); }, dref.u);
   }
 
   // Helper function to turn the left-recursive Component structure into a list.
   // Returns the object used as the base coordinate for the component chain.
-  static Ev::DataRef const *
-  reverseComponents(Ev::Component const &cmpt,
-                    std::list<Ev::Component const *> &list) {
+  static Fortran::evaluate::DataRef const *
+  reverseComponents(const Fortran::evaluate::Component &cmpt,
+                    std::list<const Fortran::evaluate::Component *> &list) {
     list.push_front(&cmpt);
-    return std::visit(
-        Co::visitors{
-            [&](Ev::Component const &x) { return reverseComponents(x, list); },
-            [&](auto &) { return &cmpt.base(); },
-        },
-        cmpt.base().u);
+    return std::visit(Fortran::common::visitors{
+                          [&](const Fortran::evaluate::Component &x) {
+                            return reverseComponents(x, list);
+                          },
+                          [&](auto &) { return &cmpt.base(); },
+                      },
+                      cmpt.base().u);
   }
 
   // Return the coordinate of the component reference
-  M::Value gen(const Ev::Component &cmpt) {
-    std::list<const Ev::Component *> list;
-    auto *base{reverseComponents(cmpt, list)};
-    L::SmallVector<M::Value, 2> coorArgs;
-    auto obj{gen(*base)};
+  mlir::Value gen(const Fortran::evaluate::Component &cmpt) {
+    std::list<const Fortran::evaluate::Component *> list;
+    auto *base = reverseComponents(cmpt, list);
+    llvm::SmallVector<mlir::Value, 2> coorArgs;
+    auto obj = gen(*base);
     auto *sym = &cmpt.GetFirstSymbol();
-    M::Type ty{converter.genType(*sym)};
+    auto ty = converter.genType(*sym);
     for (auto *field : list) {
       sym = &field->GetLastSymbol();
-      auto name{sym->name().ToString()};
+      auto name = sym->name().ToString();
       // FIXME: as we're walking the chain of field names, we need to update the
       // subtype as we drill down
       coorArgs.push_back(builder.create<fir::FieldIndexOp>(getLoc(), name, ty));
@@ -638,123 +679,133 @@ class ExprLowering {
     ty = fir::ReferenceType::get(ty);
     return builder.create<fir::CoordinateOp>(getLoc(), ty, obj, coorArgs);
   }
-  M::Value gendef(const Ev::Component &cmpt) { return gen(cmpt); }
-  M::Value genval(const Ev::Component &cmpt) {
+
+  mlir::Value gendef(const Fortran::evaluate::Component &cmpt) {
+    return gen(cmpt);
+  }
+  mlir::Value genval(const Fortran::evaluate::Component &cmpt) {
     return builder.create<fir::LoadOp>(getLoc(), gen(cmpt));
   }
 
   // Determine the result type after removing `dims` dimensions from the array
   // type `arrTy`
-  M::Type genSubType(M::Type arrTy, unsigned dims) {
-    auto unwrapTy{arrTy.cast<fir::ReferenceType>().getEleTy()};
-    auto seqTy{unwrapTy.cast<fir::SequenceType>()};
+  mlir::Type genSubType(mlir::Type arrTy, unsigned dims) {
+    auto unwrapTy = arrTy.cast<fir::ReferenceType>().getEleTy();
+    auto seqTy = unwrapTy.cast<fir::SequenceType>();
     auto shape = seqTy.getShape();
     assert(shape.size() > 0 && "removing columns for sequence sans shape");
     assert(dims <= shape.size() && "removing more columns than exist");
     fir::SequenceType::Shape newBnds;
     // follow Fortran semantics and remove columns (from right)
-    for (unsigned i = 0, e = shape.size() - dims; i < e; ++i) {
+    auto e{shape.size() - dims};
+    for (decltype(e) i{0}; i < e; ++i)
       newBnds.push_back(shape[i]);
-    }
-    if (!newBnds.empty()) {
+    if (!newBnds.empty())
       return fir::SequenceType::get(newBnds, seqTy.getEleTy());
-    }
     return seqTy.getEleTy();
   }
 
   // Return the coordinate of the array reference
-  M::Value gen(Ev::ArrayRef const &aref) {
-    M::Value base = aref.base().IsSymbol() ? gen(aref.base().GetFirstSymbol())
-                                           : gen(aref.base().GetComponent());
-    L::SmallVector<M::Value, 8> args;
-    for (auto &subsc : aref.subscript()) {
+  mlir::Value gen(const Fortran::evaluate::ArrayRef &aref) {
+    mlir::Value base = aref.base().IsSymbol()
+                           ? gen(aref.base().GetFirstSymbol())
+                           : gen(aref.base().GetComponent());
+    llvm::SmallVector<mlir::Value, 8> args;
+    for (auto &subsc : aref.subscript())
       args.push_back(genval(subsc));
-    }
-    auto ty{genSubType(base.getType(), args.size())};
+    auto ty = genSubType(base.getType(), args.size());
     ty = fir::ReferenceType::get(ty);
     return builder.create<fir::CoordinateOp>(getLoc(), ty, base, args);
   }
 
-  M::Value gendef(const Ev::ArrayRef &aref) { return gen(aref); }
-  M::Value genval(const Ev::ArrayRef &aref) {
+  mlir::Value gendef(const Fortran::evaluate::ArrayRef &aref) {
+    return gen(aref);
+  }
+  mlir::Value genval(const Fortran::evaluate::ArrayRef &aref) {
     return builder.create<fir::LoadOp>(getLoc(), gen(aref));
   }
 
   // Return a coordinate of the coarray reference. This is necessary as a
   // Component may have a CoarrayRef as its base coordinate.
-  M::Value gen(Ev::CoarrayRef const &coref) {
+  mlir::Value gen(const Fortran::evaluate::CoarrayRef &coref) {
     // FIXME: need to visit the cosubscripts...
     // return gen(coref.base());
     TODO();
   }
-  M::Value gendef(const Ev::CoarrayRef &coref) { return gen(coref); }
-  M::Value genval(const Ev::CoarrayRef &coref) {
+  mlir::Value gendef(const Fortran::evaluate::CoarrayRef &coref) {
+    return gen(coref);
+  }
+  mlir::Value genval(const Fortran::evaluate::CoarrayRef &coref) {
     return builder.create<fir::LoadOp>(getLoc(), gen(coref));
   }
 
   template <typename A>
-  M::Value gen(Ev::Designator<A> const &des) {
+  mlir::Value gen(const Fortran::evaluate::Designator<A> &des) {
     return std::visit([&](const auto &x) { return gen(x); }, des.u);
   }
   template <typename A>
-  M::Value gendef(Ev::Designator<A> const &des) {
+  mlir::Value gendef(const Fortran::evaluate::Designator<A> &des) {
     return gen(des);
   }
   template <typename A>
-  M::Value genval(Ev::Designator<A> const &des) {
+  mlir::Value genval(const Fortran::evaluate::Designator<A> &des) {
     return std::visit([&](const auto &x) { return genval(x); }, des.u);
   }
 
   // call a function
   template <typename A>
-  M::Value gen(const Ev::FunctionRef<A> &funRef) {
+  mlir::Value gen(const Fortran::evaluate::FunctionRef<A> &funRef) {
     TODO();
   }
   template <typename A>
-  M::Value gendef(const Ev::FunctionRef<A> &funRef) {
+  mlir::Value gendef(const Fortran::evaluate::FunctionRef<A> &funRef) {
     return gen(funRef);
   }
   template <typename A>
-  M::Value genval(const Ev::FunctionRef<A> &funRef) {
+  mlir::Value genval(const Fortran::evaluate::FunctionRef<A> &funRef) {
     TODO(); // Derived type functions (user + intrinsics)
   }
-  template <Co::TypeCategory TC, int KIND>
-  M::Value genval(const Ev::FunctionRef<Ev::Type<TC, KIND>> &funRef) {
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<TC, KIND>>
+             &funRef) {
     if (const auto &intrinsic{funRef.proc().GetSpecificIntrinsic()}) {
-      M::Type ty{converter.genType(TC, KIND)};
-      L::SmallVector<M::Value, 2> operands;
+      mlir::Type ty = converter.genType(TC, KIND);
+      llvm::SmallVector<mlir::Value, 2> operands;
       // Lower arguments
       // For now, logical arguments for intrinsic are lowered to `fir.logical`
       // so that TRANSFER can work. For some arguments, it could lead to useless
       // conversions (e.g scalar MASK of MERGE will be converted to `i1`), but
       // the generated code is at least correct. To improve this, the intrinsic
       // lowering facility should control argument lowering.
-      auto restorer{Co::ScopedSet(genLogicalAsI1, false)};
+      auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, false);
       for (const auto &arg : funRef.arguments()) {
-        if (auto *expr{Ev::UnwrapExpr<Ev::Expr<Ev::SomeType>>(arg)}) {
+        if (auto *expr = Fortran::evaluate::UnwrapExpr<
+                Fortran::evaluate::Expr<Fortran::evaluate::SomeType>>(arg)) {
           operands.push_back(genval(*expr));
         } else {
           operands.push_back(nullptr); // optional
         }
       }
       // Let the intrinsic library lower the intrinsic function call
-      L::StringRef name{intrinsic->name};
+      llvm::StringRef name{intrinsic->name};
       return intrinsics.genval(getLoc(), builder, name, ty, operands);
     } else {
       // implicit interface implementation only
       // TODO: explicit interface
-      L::SmallVector<M::Type, 2> argTypes;
-      L::SmallVector<M::Value, 2> operands;
+      llvm::SmallVector<mlir::Type, 2> argTypes;
+      llvm::SmallVector<mlir::Value, 2> operands;
       // Logical arguments of user functions must be lowered to `fir.logical`
       // and not `i1`.
-      auto restorer{Co::ScopedSet(genLogicalAsI1, false)};
+      auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, false);
       for (const auto &arg : funRef.arguments()) {
         assert(arg.has_value() &&
                "optional argument requires explicit interface");
-        const auto *expr{arg->UnwrapExpr()};
+        const auto *expr = arg->UnwrapExpr();
         assert(expr && "assumed type argument requires explicit interface");
-        if (const Se::Symbol * sym{Ev::UnwrapWholeSymbolDataRef(*expr)}) {
-          M::Value argRef{symMap.lookupSymbol(*sym)};
+        if (const auto *sym =
+                Fortran::evaluate::UnwrapWholeSymbolDataRef(*expr)) {
+          mlir::Value argRef = symMap.lookupSymbol(*sym);
           assert(argRef && "could not get symbol reference");
           argTypes.push_back(argRef.getType());
           operands.push_back(argRef);
@@ -763,11 +814,11 @@ class ExprLowering {
           TODO();
         }
       }
-      M::Type resultType{converter.genType(TC, KIND)};
-      M::FunctionType funTy{
-          M::FunctionType::get(argTypes, resultType, builder.getContext())};
-      M::FuncOp func{getFunction(applyNameMangling(funRef.proc()), funTy)};
-      auto call{builder.create<M::CallOp>(getLoc(), func, operands)};
+      mlir::Type resultType = converter.genType(TC, KIND);
+      mlir::FunctionType funTy =
+          mlir::FunctionType::get(argTypes, resultType, builder.getContext());
+      mlir::FuncOp func = getFunction(applyNameMangling(funRef.proc()), funTy);
+      auto call = builder.create<mlir::CallOp>(getLoc(), func, operands);
       // For now, Fortran return value are implemented with a single MLIR
       // function return value.
       assert(call.getNumResults() == 1 &&
@@ -777,33 +828,35 @@ class ExprLowering {
   }
 
   template <typename A>
-  M::Value gen(const Ev::Expr<A> &exp) {
+  mlir::Value gen(const Fortran::evaluate::Expr<A> &exp) {
     // must be a designator or function-reference (R902)
     return std::visit([&](const auto &e) { return gendef(e); }, exp.u);
   }
   template <typename A>
-  M::Value gendef(Ev::Expr<A> const &exp) {
+  mlir::Value gendef(const Fortran::evaluate::Expr<A> &exp) {
     return gen(exp);
   }
   template <typename A>
-  M::Value genval(Ev::Expr<A> const &exp) {
+  mlir::Value genval(const Fortran::evaluate::Expr<A> &exp) {
     return std::visit([&](const auto &e) { return genval(e); }, exp.u);
   }
 
   template <int KIND>
-  M::Value genval(Ev::Expr<Ev::Type<LogicalCat, KIND>> const &exp) {
-    auto result{std::visit([&](const auto &e) { return genval(e); }, exp.u)};
+  mlir::Value
+  genval(const Fortran::evaluate::Expr<
+         Fortran::evaluate::Type<Fortran::lower::LogicalCat, KIND>> &exp) {
+    auto result = std::visit([&](const auto &e) { return genval(e); }, exp.u);
     // Handle the `i1` to `fir.logical` conversions as needed.
     if (result) {
-      M::Type type{result.getType()};
+      mlir::Type type = result.getType();
       if (type.isa<fir::LogicalType>()) {
-        if (genLogicalAsI1) {
+        if (genLogicalAsI1)
           result = builder.create<fir::ConvertOp>(getLoc(), builder.getI1Type(),
                                                   result);
-        }
-      } else if (type.isa<M::IntegerType>()) {
+      } else if (type.isa<mlir::IntegerType>()) {
         if (!genLogicalAsI1) {
-          M::Type firLogicalType{converter.genType(LogicalCat, KIND)};
+          auto firLogicalType =
+              converter.genType(Fortran::lower::LogicalCat, KIND);
           result =
               builder.create<fir::ConvertOp>(getLoc(), firLogicalType, result);
         }
@@ -819,13 +872,14 @@ class ExprLowering {
   }
 
   template <typename A>
-  M::Value gendef(const A &) {
+  mlir::Value gendef(const A &) {
     assert(false && "expression error");
     return {};
   }
 
-  std::string applyNameMangling(const Ev::ProcedureDesignator &proc) {
-    if (const auto *symbol{proc.GetSymbol()})
+  std::string
+  applyNameMangling(const Fortran::evaluate::ProcedureDesignator &proc) {
+    if (const auto *symbol = proc.GetSymbol())
       return converter.mangleName(*symbol);
     // Do not mangle intrinsic for now
     assert(proc.GetSpecificIntrinsic() &&
@@ -834,54 +888,60 @@ class ExprLowering {
   }
 
 public:
-  explicit ExprLowering(M::Location loc, AbstractConverter &converter,
-                        SomeExpr const &vop, SymMap &map,
-                        IntrinsicLibrary const &intr, bool logicalAsI1 = false)
+  explicit ExprLowering(mlir::Location loc,
+                        Fortran::lower::AbstractConverter &converter,
+                        const Fortran::lower::SomeExpr &vop,
+                        Fortran::lower::SymMap &map,
+                        const Fortran::lower::IntrinsicLibrary &intr,
+                        bool logicalAsI1 = false)
       : location{loc}, converter{converter}, builder{converter.getOpBuilder()},
         expr{vop}, symMap{map}, intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
 
   /// Lower the expression `expr` into MLIR standard dialect
-  M::Value gen() { return gen(expr); }
-  M::Value genval() { return genval(expr); }
+  mlir::Value gen() { return gen(expr); }
+  mlir::Value genval() { return genval(expr); }
 };
 
 } // namespace
 
-M::Value Br::createSomeExpression(M::Location loc,
-                                  Br::AbstractConverter &converter,
-                                  const Ev::Expr<Ev::SomeType> &expr,
-                                  SymMap &symMap,
-                                  const IntrinsicLibrary &intrinsics) {
+mlir::Value Fortran::lower::createSomeExpression(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &expr,
+    Fortran::lower::SymMap &symMap,
+    const Fortran::lower::IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics, false}.genval();
 }
 
-M::Value Br::createI1LogicalExpression(M::Location loc,
-                                       Br::AbstractConverter &converter,
-                                       const Ev::Expr<Ev::SomeType> &expr,
-                                       SymMap &symMap,
-                                       const IntrinsicLibrary &intrinsics) {
+mlir::Value Fortran::lower::createI1LogicalExpression(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &expr,
+    Fortran::lower::SymMap &symMap,
+    const Fortran::lower::IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics, true}.genval();
 }
 
-M::Value Br::createSomeAddress(M::Location loc,
-                               Br::AbstractConverter &converter,
-                               const Ev::Expr<Ev::SomeType> &expr,
-                               SymMap &symMap,
-                               const IntrinsicLibrary &intrinsics) {
+mlir::Value Fortran::lower::createSomeAddress(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &expr,
+    Fortran::lower::SymMap &symMap,
+    const Fortran::lower::IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics}.gen();
 }
 
 /// Create a temporary variable
 /// `symbol` will be nullptr for an anonymous temporary
-M::Value Br::createTemporary(M::Location loc, M::OpBuilder &builder,
-                             SymMap &symMap, M::Type type,
-                             const Se::Symbol *symbol, L::StringRef name) {
+mlir::Value
+Fortran::lower::createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
+                                Fortran::lower::SymMap &symMap, mlir::Type type,
+                                const Fortran::semantics::Symbol *symbol,
+                                llvm::StringRef name) {
   if (symbol)
     if (auto val = symMap.lookupSymbol(*symbol)) {
       if (auto op = val.getDefiningOp())
         return op->getResult(0);
       return val;
     }
+
   auto insPt(builder.saveInsertionPoint());
   builder.setInsertionPointToStart(getEntryBlock(&builder));
   fir::AllocaOp ae;
diff --git a/lib/lower/ConvertType.cpp b/lib/lower/ConvertType.cpp
index 3e9d165c2aee..2c5c2c687c9d 100644
--- a/lib/lower/ConvertType.cpp
+++ b/lib/lower/ConvertType.cpp
@@ -8,7 +8,6 @@
 
 #include "flang/lower/ConvertType.h"
 #include "../../runtime/io-api.h"
-#include "NSAliases.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/Utils.h"
 #include "flang/optimizer/Dialect/FIRType.h"
@@ -20,19 +19,16 @@
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 
-using namespace Fortran;
-using namespace Fortran::lower;
-
 namespace {
 
 template <typename A>
-bool isConstant(const Ev::Expr<A> &e) {
-  return Ev::IsConstantExpr(SomeExpr{e});
+bool isConstant(const Fortran::evaluate::Expr<A> &e) {
+  return Fortran::evaluate::IsConstantExpr(Fortran::lower::SomeExpr{e});
 }
 
 template <typename A>
-int64_t toConstant(const Ev::Expr<A> &e) {
-  auto opt = Ev::ToInt64(e);
+int64_t toConstant(const Fortran::evaluate::Expr<A> &e) {
+  auto opt = Fortran::evaluate::ToInt64(e);
   assert(opt.has_value() && "expression didn't resolve to a constant");
   return opt.value();
 }
@@ -43,19 +39,21 @@ int64_t toConstant(const Ev::Expr<A> &e) {
   return {}
 
 // one argument template, must be specialized
-template <Co::TypeCategory TC>
-M::Type genFIRType(M::MLIRContext *, int) {
+template <Fortran::common::TypeCategory TC>
+mlir::Type genFIRType(mlir::MLIRContext *, int) {
   return {};
 }
 
 // two argument template
-template <Co::TypeCategory TC, int KIND>
-M::Type genFIRType(M::MLIRContext *context) {
-  if constexpr (TC == IntegerCat) {
-    auto bits{Ev::Type<IntegerCat, KIND>::Scalar::bits};
-    return M::IntegerType::get(bits, context);
-  } else if constexpr (TC == LogicalCat || TC == CharacterCat ||
-                       TC == ComplexCat) {
+template <Fortran::common::TypeCategory TC, int KIND>
+mlir::Type genFIRType(mlir::MLIRContext *context) {
+  if constexpr (TC == Fortran::lower::IntegerCat) {
+    auto bits{Fortran::evaluate::Type<Fortran::lower::IntegerCat,
+                                      KIND>::Scalar::bits};
+    return mlir::IntegerType::get(bits, context);
+  } else if constexpr (TC == Fortran::lower::LogicalCat ||
+                       TC == Fortran::lower::CharacterCat ||
+                       TC == Fortran::lower::ComplexCat) {
     return genFIRType<TC>(context, KIND);
   } else {
     return {};
@@ -63,51 +61,53 @@ M::Type genFIRType(M::MLIRContext *context) {
 }
 
 template <>
-M::Type genFIRType<RealCat, 2>(M::MLIRContext *context) {
-  return M::FloatType::getF16(context);
+mlir::Type genFIRType<Fortran::lower::RealCat, 2>(mlir::MLIRContext *context) {
+  return mlir::FloatType::getF16(context);
 }
 
 template <>
-M::Type genFIRType<RealCat, 3>(M::MLIRContext *context) {
-  return M::FloatType::getBF16(context);
+mlir::Type genFIRType<Fortran::lower::RealCat, 3>(mlir::MLIRContext *context) {
+  return mlir::FloatType::getBF16(context);
 }
 
 template <>
-M::Type genFIRType<RealCat, 4>(M::MLIRContext *context) {
-  return M::FloatType::getF32(context);
+mlir::Type genFIRType<Fortran::lower::RealCat, 4>(mlir::MLIRContext *context) {
+  return mlir::FloatType::getF32(context);
 }
 
 template <>
-M::Type genFIRType<RealCat, 8>(M::MLIRContext *context) {
-  return M::FloatType::getF64(context);
+mlir::Type genFIRType<Fortran::lower::RealCat, 8>(mlir::MLIRContext *context) {
+  return mlir::FloatType::getF64(context);
 }
 
 template <>
-M::Type genFIRType<RealCat, 10>(M::MLIRContext *context) {
+mlir::Type genFIRType<Fortran::lower::RealCat, 10>(mlir::MLIRContext *context) {
   return fir::RealType::get(context, 10);
 }
 
 template <>
-M::Type genFIRType<RealCat, 16>(M::MLIRContext *context) {
+mlir::Type genFIRType<Fortran::lower::RealCat, 16>(mlir::MLIRContext *context) {
   return fir::RealType::get(context, 16);
 }
 
 template <>
-M::Type genFIRType<RealCat>(M::MLIRContext *context, int kind) {
-  if (Ev::IsValidKindOfIntrinsicType(RealCat, kind)) {
+mlir::Type genFIRType<Fortran::lower::RealCat>(mlir::MLIRContext *context,
+                                               int kind) {
+  if (Fortran::evaluate::IsValidKindOfIntrinsicType(Fortran::lower::RealCat,
+                                                    kind)) {
     switch (kind) {
     case 2:
-      return genFIRType<RealCat, 2>(context);
+      return genFIRType<Fortran::lower::RealCat, 2>(context);
     case 3:
-      return genFIRType<RealCat, 3>(context);
+      return genFIRType<Fortran::lower::RealCat, 3>(context);
     case 4:
-      return genFIRType<RealCat, 4>(context);
+      return genFIRType<Fortran::lower::RealCat, 4>(context);
     case 8:
-      return genFIRType<RealCat, 8>(context);
+      return genFIRType<Fortran::lower::RealCat, 8>(context);
     case 10:
-      return genFIRType<RealCat, 10>(context);
+      return genFIRType<Fortran::lower::RealCat, 10>(context);
     case 16:
-      return genFIRType<RealCat, 16>(context);
+      return genFIRType<Fortran::lower::RealCat, 16>(context);
     }
     assert(false && "type translation not implemented");
   }
@@ -115,19 +115,21 @@ M::Type genFIRType<RealCat>(M::MLIRContext *context, int kind) {
 }
 
 template <>
-M::Type genFIRType<IntegerCat>(M::MLIRContext *context, int kind) {
-  if (Ev::IsValidKindOfIntrinsicType(IntegerCat, kind)) {
+mlir::Type genFIRType<Fortran::lower::IntegerCat>(mlir::MLIRContext *context,
+                                                  int kind) {
+  if (Fortran::evaluate::IsValidKindOfIntrinsicType(Fortran::lower::IntegerCat,
+                                                    kind)) {
     switch (kind) {
     case 1:
-      return genFIRType<IntegerCat, 1>(context);
+      return genFIRType<Fortran::lower::IntegerCat, 1>(context);
     case 2:
-      return genFIRType<IntegerCat, 2>(context);
+      return genFIRType<Fortran::lower::IntegerCat, 2>(context);
     case 4:
-      return genFIRType<IntegerCat, 4>(context);
+      return genFIRType<Fortran::lower::IntegerCat, 4>(context);
     case 8:
-      return genFIRType<IntegerCat, 8>(context);
+      return genFIRType<Fortran::lower::IntegerCat, 8>(context);
     case 16:
-      return genFIRType<IntegerCat, 16>(context);
+      return genFIRType<Fortran::lower::IntegerCat, 16>(context);
     }
     assert(false && "type translation not implemented");
   }
@@ -135,64 +137,73 @@ M::Type genFIRType<IntegerCat>(M::MLIRContext *context, int kind) {
 }
 
 template <>
-M::Type genFIRType<LogicalCat>(M::MLIRContext *context, int KIND) {
-  if (Ev::IsValidKindOfIntrinsicType(LogicalCat, KIND))
+mlir::Type genFIRType<Fortran::lower::LogicalCat>(mlir::MLIRContext *context,
+                                                  int KIND) {
+  if (Fortran::evaluate::IsValidKindOfIntrinsicType(Fortran::lower::LogicalCat,
+                                                    KIND))
     return fir::LogicalType::get(context, KIND);
   return {};
 }
 
 template <>
-M::Type genFIRType<CharacterCat>(M::MLIRContext *context, int KIND) {
-  if (Ev::IsValidKindOfIntrinsicType(CharacterCat, KIND))
+mlir::Type genFIRType<Fortran::lower::CharacterCat>(mlir::MLIRContext *context,
+                                                    int KIND) {
+  if (Fortran::evaluate::IsValidKindOfIntrinsicType(
+          Fortran::lower::CharacterCat, KIND))
     return fir::CharacterType::get(context, KIND);
   return {};
 }
 
 template <>
-M::Type genFIRType<ComplexCat>(M::MLIRContext *context, int KIND) {
-  if (Ev::IsValidKindOfIntrinsicType(ComplexCat, KIND))
+mlir::Type genFIRType<Fortran::lower::ComplexCat>(mlir::MLIRContext *context,
+                                                  int KIND) {
+  if (Fortran::evaluate::IsValidKindOfIntrinsicType(Fortran::lower::ComplexCat,
+                                                    KIND))
     return fir::CplxType::get(context, KIND);
   return {};
 }
 
-/// Recover the type of an Ev::Expr<T> and convert it to an
-/// M::Type. The type returned can be a MLIR standard or FIR type.
+/// Recover the type of an Fortran::evaluate::Expr<T> and convert it to an
+/// mlir::Type. The type returned can be a MLIR standard or FIR type.
 class TypeBuilder {
-  M::MLIRContext *context;
-  Co::IntrinsicTypeDefaultKinds const &defaults;
+  mlir::MLIRContext *context;
+  const Fortran::common::IntrinsicTypeDefaultKinds &defaults;
 
-  template <Co::TypeCategory TC>
+  template <Fortran::common::TypeCategory TC>
   int defaultKind() {
     return defaultKind(TC);
   }
-  int defaultKind(Co::TypeCategory TC) { return defaults.GetDefaultKind(TC); }
+  int defaultKind(Fortran::common::TypeCategory TC) {
+    return defaults.GetDefaultKind(TC);
+  }
 
-  M::InFlightDiagnostic emitError(const L::Twine &message) {
-    return M::emitError(M::UnknownLoc::get(context), message);
+  mlir::InFlightDiagnostic emitError(const llvm::Twine &message) {
+    return mlir::emitError(mlir::UnknownLoc::get(context), message);
   }
 
-  M::InFlightDiagnostic emitWarning(const L::Twine &message) {
-    return M::emitWarning(M::UnknownLoc::get(context), message);
+  mlir::InFlightDiagnostic emitWarning(const llvm::Twine &message) {
+    return mlir::emitWarning(mlir::UnknownLoc::get(context), message);
   }
 
 public:
-  explicit TypeBuilder(M::MLIRContext *context,
-                       Co::IntrinsicTypeDefaultKinds const &defaults)
+  explicit TypeBuilder(
+      mlir::MLIRContext *context,
+      const Fortran::common::IntrinsicTypeDefaultKinds &defaults)
       : context{context}, defaults{defaults} {}
 
   // non-template, arguments are runtime values
-  M::Type genFIRTy(Co::TypeCategory tc, int kind) {
+  mlir::Type genFIRTy(Fortran::common::TypeCategory tc, int kind) {
     switch (tc) {
-    case RealCat:
-      return genFIRType<RealCat>(context, kind);
-    case IntegerCat:
-      return genFIRType<IntegerCat>(context, kind);
-    case ComplexCat:
-      return genFIRType<ComplexCat>(context, kind);
-    case LogicalCat:
-      return genFIRType<LogicalCat>(context, kind);
-    case CharacterCat:
-      return genFIRType<CharacterCat>(context, kind);
+    case Fortran::lower::RealCat:
+      return genFIRType<Fortran::lower::RealCat>(context, kind);
+    case Fortran::lower::IntegerCat:
+      return genFIRType<Fortran::lower::IntegerCat>(context, kind);
+    case Fortran::lower::ComplexCat:
+      return genFIRType<Fortran::lower::ComplexCat>(context, kind);
+    case Fortran::lower::LogicalCat:
+      return genFIRType<Fortran::lower::LogicalCat>(context, kind);
+    case Fortran::lower::CharacterCat:
+      return genFIRType<Fortran::lower::CharacterCat>(context, kind);
     default:
       break;
     }
@@ -201,71 +212,76 @@ class TypeBuilder {
   }
 
   // non-template, category is runtime values, kind is defaulted
-  M::Type genFIRTy(Co::TypeCategory tc) {
+  mlir::Type genFIRTy(Fortran::common::TypeCategory tc) {
     return genFIRTy(tc, defaultKind(tc));
   }
 
-  M::Type gen(const Ev::ImpliedDoIndex &) {
-    return genFIRType<IntegerCat>(context, defaultKind<IntegerCat>());
+  mlir::Type gen(const Fortran::evaluate::ImpliedDoIndex &) {
+    return genFIRType<Fortran::lower::IntegerCat>(
+        context, defaultKind<Fortran::lower::IntegerCat>());
   }
 
-  template <template <typename> typename A, Co::TypeCategory TC>
-  M::Type gen(const A<Ev::SomeKind<TC>> &) {
+  template <template <typename> typename A, Fortran::common::TypeCategory TC>
+  mlir::Type gen(const A<Fortran::evaluate::SomeKind<TC>> &) {
     return genFIRType<TC>(context, defaultKind<TC>());
   }
 
   template <int KIND>
-  M::Type gen(const Ev::TypeParamInquiry<KIND> &) {
-    return genFIRType<IntegerCat, KIND>(context);
+  mlir::Type gen(const Fortran::evaluate::TypeParamInquiry<KIND> &) {
+    return genFIRType<Fortran::lower::IntegerCat, KIND>(context);
   }
 
   template <typename A>
-  M::Type gen(const Ev::Relational<A> &) {
-    return genFIRType<LogicalCat, 1>(context);
+  mlir::Type gen(const Fortran::evaluate::Relational<A> &) {
+    return genFIRType<Fortran::lower::LogicalCat, 1>(context);
   }
 
-  template <template <typename> typename A, Co::TypeCategory TC, int KIND>
-  M::Type gen(const A<Ev::Type<TC, KIND>> &) {
+  template <template <typename> typename A, Fortran::common::TypeCategory TC,
+            int KIND>
+  mlir::Type gen(const A<Fortran::evaluate::Type<TC, KIND>> &) {
     return genFIRType<TC, KIND>(context);
   }
 
   // breaks the conflict between A<Type<TC,KIND>> and Expr<B> deduction
-  template <Co::TypeCategory TC, int KIND>
-  M::Type gen(const Ev::Expr<Ev::Type<TC, KIND>> &) {
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Type
+  gen(const Fortran::evaluate::Expr<Fortran::evaluate::Type<TC, KIND>> &) {
     return genFIRType<TC, KIND>(context);
   }
 
   template <typename A>
-  M::Type genVariant(const A &variant) {
+  mlir::Type genVariant(const A &variant) {
     return std::visit([&](const auto &x) { return gen(x); }, variant.u);
   }
 
   // breaks the conflict between A<SomeKind<TC>> and Expr<B> deduction
-  template <Co::TypeCategory TC>
-  M::Type gen(const Ev::Expr<Ev::SomeKind<TC>> &expr) {
+  template <Fortran::common::TypeCategory TC>
+  mlir::Type
+  gen(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<TC>> &expr) {
     return genVariant(expr);
   }
 
   template <typename A>
-  M::Type gen(const Ev::Expr<A> &expr) {
+  mlir::Type gen(const Fortran::evaluate::Expr<A> &expr) {
     return genVariant(expr);
   }
 
-  M::Type gen(const Ev::DataRef &dref) { return genVariant(dref); }
+  mlir::Type gen(const Fortran::evaluate::DataRef &dref) {
+    return genVariant(dref);
+  }
 
-  M::Type mkVoid() { return M::TupleType::get(context); }
+  mlir::Type mkVoid() { return mlir::TupleType::get(context); }
 
-  fir::SequenceType::Shape genSeqShape(Se::SymbolRef symbol) {
+  fir::SequenceType::Shape genSeqShape(Fortran::semantics::SymbolRef symbol) {
     assert(symbol->IsObjectArray());
     fir::SequenceType::Shape bounds;
-    auto &details = symbol->get<Se::ObjectEntityDetails>();
+    auto &details = symbol->get<Fortran::semantics::ObjectEntityDetails>();
     const auto size = details.shape().size();
     for (auto &ss : details.shape()) {
       auto lb = ss.lbound();
       auto ub = ss.ubound();
-      if (lb.isAssumed() && ub.isAssumed() && size == 1) {
+      if (lb.isAssumed() && ub.isAssumed() && size == 1)
         return {};
-      }
       if (lb.isExplicit() && ub.isExplicit()) {
         auto &lbv = lb.GetExplicit();
         auto &ubv = ub.GetExplicit();
@@ -283,15 +299,15 @@ class TypeBuilder {
     return bounds;
   }
 
-  M::Type genDummyArgType(const Se::Symbol &dummy) {
+  mlir::Type genDummyArgType(const Fortran::semantics::Symbol &dummy) {
     if (auto *type{dummy.GetType()}) {
       auto *tySpec{type->AsIntrinsic()};
-      if (tySpec && tySpec->category() == CharacterCat) {
+      if (tySpec && tySpec->category() == Fortran::lower::CharacterCat) {
         auto kind = toConstant(tySpec->kind());
         return fir::BoxCharType::get(context, kind);
       }
     }
-    if (Se::IsDescriptor(dummy)) {
+    if (Fortran::semantics::IsDescriptor(dummy)) {
       // FIXME: This should be the first case, but it seems to
       // fire at assumed length character on purpose which is
       // not what I expect.
@@ -300,67 +316,66 @@ class TypeBuilder {
     return fir::ReferenceType::get(gen(dummy));
   }
 
-  M::FunctionType genFunctionType(Se::SymbolRef symbol) {
-    L::SmallVector<M::Type, 1> returnTys;
-    L::SmallVector<M::Type, 4> inputTys;
-    if (auto *proc = symbol->detailsIf<Se::SubprogramDetails>()) {
-      if (proc->isFunction()) {
+  mlir::FunctionType genFunctionType(Fortran::semantics::SymbolRef symbol) {
+    llvm::SmallVector<mlir::Type, 1> returnTys;
+    llvm::SmallVector<mlir::Type, 4> inputTys;
+    if (auto *proc =
+            symbol->detailsIf<Fortran::semantics::SubprogramDetails>()) {
+      if (proc->isFunction())
         returnTys.emplace_back(gen(proc->result()));
-      }
       // FIXME: handle alt-return
       for (auto *arg : proc->dummyArgs()) {
         // Nullptr args are alternate returns indicators
-        if (arg) {
+        if (arg)
           inputTys.emplace_back(genDummyArgType(*arg));
-        }
       }
-    } else if (symbol->detailsIf<Se::ProcEntityDetails>()) {
-      // TODO Should probably use Ev::Characteristics for that.
+    } else if (symbol->detailsIf<Fortran::semantics::ProcEntityDetails>()) {
+      // TODO Should probably use Fortran::evaluate::Characteristics for that.
       TODO();
     } else {
       assert(false && "unexpected symbol details for function");
     }
-    return M::FunctionType::get(inputTys, returnTys, context);
+    return mlir::FunctionType::get(inputTys, returnTys, context);
   }
 
   /// Type consing from a symbol. A symbol's type must be created from the type
   /// discovered by the front-end at runtime.
-  M::Type gen(Se::SymbolRef symbol) {
-    if (symbol->detailsIf<Se::SubprogramDetails>()) {
+  mlir::Type gen(Fortran::semantics::SymbolRef symbol) {
+    if (symbol->detailsIf<Fortran::semantics::SubprogramDetails>()) {
       return genFunctionType(symbol);
     }
-    M::Type returnTy;
+    mlir::Type returnTy;
     if (auto *type{symbol->GetType()}) {
       if (auto *tySpec{type->AsIntrinsic()}) {
         int kind = toConstant(tySpec->kind());
         switch (tySpec->category()) {
-        case IntegerCat:
-          returnTy = genFIRType<IntegerCat>(context, kind);
+        case Fortran::lower::IntegerCat:
+          returnTy = genFIRType<Fortran::lower::IntegerCat>(context, kind);
           break;
-        case RealCat:
-          returnTy = genFIRType<RealCat>(context, kind);
+        case Fortran::lower::RealCat:
+          returnTy = genFIRType<Fortran::lower::RealCat>(context, kind);
           break;
-        case ComplexCat:
-          returnTy = genFIRType<ComplexCat>(context, kind);
+        case Fortran::lower::ComplexCat:
+          returnTy = genFIRType<Fortran::lower::ComplexCat>(context, kind);
           break;
-        case CharacterCat:
-          returnTy = genFIRType<CharacterCat>(context, kind);
+        case Fortran::lower::CharacterCat:
+          returnTy = genFIRType<Fortran::lower::CharacterCat>(context, kind);
           break;
-        case LogicalCat:
-          returnTy = genFIRType<LogicalCat>(context, kind);
+        case Fortran::lower::LogicalCat:
+          returnTy = genFIRType<Fortran::lower::LogicalCat>(context, kind);
           break;
         default:
           emitError("symbol has unknown intrinsic type");
           return {};
         }
-      } else if (auto *tySpec{type->AsDerived()}) {
-        std::vector<std::pair<std::string, M::Type>> ps;
-        std::vector<std::pair<std::string, M::Type>> cs;
+      } else if (auto *tySpec = type->AsDerived()) {
+        std::vector<std::pair<std::string, mlir::Type>> ps;
+        std::vector<std::pair<std::string, mlir::Type>> cs;
         auto &symbol = tySpec->typeSymbol();
         // FIXME: don't want to recurse forever here, but this won't happen
         // since we don't know the components at this time
         auto rec = fir::RecordType::get(context, toStringRef(symbol.name()));
-        auto &details = symbol.get<Se::DerivedTypeDetails>();
+        auto &details = symbol.get<Fortran::semantics::DerivedTypeDetails>();
         for (auto &param : details.paramDecls()) {
           auto &p{*param};
           ps.push_back(std::pair{p.name().ToString(), gen(p)});
@@ -390,7 +405,7 @@ class TypeBuilder {
     if (symbol->IsObjectArray()) {
       // FIXME: add bounds info
       returnTy = fir::SequenceType::get(genSeqShape(symbol), returnTy);
-    } else if (Se::IsPointer(*symbol)) {
+    } else if (Fortran::semantics::IsPointer(*symbol)) {
       // FIXME: what about allocatable?
       returnTy = fir::ReferenceType::get(returnTy);
     }
@@ -404,78 +419,90 @@ class TypeBuilder {
   }
 
   // some sequence of `n` bytes
-  M::Type gen(const Ev::StaticDataObject::Pointer &ptr) {
-    M::Type byteTy{M::IntegerType::get(8, context)};
+  mlir::Type gen(const Fortran::evaluate::StaticDataObject::Pointer &ptr) {
+    mlir::Type byteTy{mlir::IntegerType::get(8, context)};
     return fir::SequenceType::get(trivialShape(ptr->itemBytes()), byteTy);
   }
 
-  M::Type gen(const Ev::Substring &ss) {
+  mlir::Type gen(const Fortran::evaluate::Substring &ss) {
     return genVariant(ss.GetBaseObject());
   }
 
-  M::Type genTypelessPtr() { return fir::ReferenceType::get(mkVoid()); }
-  M::Type gen(const Ev::NullPointer &) { return genTypelessPtr(); }
-  M::Type gen(const Ev::ProcedureRef &) { return genTypelessPtr(); }
-  M::Type gen(const Ev::ProcedureDesignator &) { return genTypelessPtr(); }
-  M::Type gen(const Ev::BOZLiteralConstant &) { return genTypelessPtr(); }
-
-  M::Type gen(const Ev::ArrayRef &) { TODO(); }
-  M::Type gen(const Ev::CoarrayRef &) { TODO(); }
-  M::Type gen(const Ev::Component &) { TODO(); }
-  M::Type gen(const Ev::ComplexPart &) { TODO(); }
-  M::Type gen(const Ev::DescriptorInquiry &) { TODO(); }
-  M::Type gen(const Ev::StructureConstructor &) { TODO(); }
+  mlir::Type genTypelessPtr() { return fir::ReferenceType::get(mkVoid()); }
+
+  mlir::Type gen(const Fortran::evaluate::NullPointer &) {
+    return genTypelessPtr();
+  }
+  mlir::Type gen(const Fortran::evaluate::ProcedureRef &) {
+    return genTypelessPtr();
+  }
+  mlir::Type gen(const Fortran::evaluate::ProcedureDesignator &) {
+    return genTypelessPtr();
+  }
+  mlir::Type gen(const Fortran::evaluate::BOZLiteralConstant &) {
+    return genTypelessPtr();
+  }
+
+  mlir::Type gen(const Fortran::evaluate::ArrayRef &) { TODO(); }
+  mlir::Type gen(const Fortran::evaluate::CoarrayRef &) { TODO(); }
+  mlir::Type gen(const Fortran::evaluate::Component &) { TODO(); }
+  mlir::Type gen(const Fortran::evaluate::ComplexPart &) { TODO(); }
+  mlir::Type gen(const Fortran::evaluate::DescriptorInquiry &) { TODO(); }
+  mlir::Type gen(const Fortran::evaluate::StructureConstructor &) { TODO(); }
 };
 
 } // namespace
 
-M::Type Br::getFIRType(M::MLIRContext *context,
-                       Co::IntrinsicTypeDefaultKinds const &defaults,
-                       Co::TypeCategory tc, int kind) {
+mlir::Type Fortran::lower::getFIRType(
+    mlir::MLIRContext *context,
+    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+    Fortran::common::TypeCategory tc, int kind) {
   return TypeBuilder{context, defaults}.genFIRTy(tc, kind);
 }
 
-M::Type Br::getFIRType(M::MLIRContext *context,
-                       Co::IntrinsicTypeDefaultKinds const &defaults,
-                       Co::TypeCategory tc) {
+mlir::Type Fortran::lower::getFIRType(
+    mlir::MLIRContext *context,
+    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+    Fortran::common::TypeCategory tc) {
   return TypeBuilder{context, defaults}.genFIRTy(tc);
 }
 
-M::Type
-Br::translateDataRefToFIRType(M::MLIRContext *context,
-                              Co::IntrinsicTypeDefaultKinds const &defaults,
-                              const Ev::DataRef &dataRef) {
+mlir::Type Fortran::lower::translateDataRefToFIRType(
+    mlir::MLIRContext *context,
+    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+    const Fortran::evaluate::DataRef &dataRef) {
   return TypeBuilder{context, defaults}.gen(dataRef);
 }
 
 // Builds the FIR type from an instance of SomeExpr
-M::Type
-Br::translateSomeExprToFIRType(M::MLIRContext *context,
-                               Co::IntrinsicTypeDefaultKinds const &defaults,
-                               const SomeExpr *expr) {
+mlir::Type Fortran::lower::translateSomeExprToFIRType(
+    mlir::MLIRContext *context,
+    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+    const SomeExpr *expr) {
   return TypeBuilder{context, defaults}.gen(*expr);
 }
 
 // This entry point avoids gratuitously wrapping the Symbol instance in layers
 // of Expr<T> that will then be immediately peeled back off and discarded.
-M::Type
-Br::translateSymbolToFIRType(M::MLIRContext *context,
-                             Co::IntrinsicTypeDefaultKinds const &defaults,
-                             const SymbolRef symbol) {
+mlir::Type Fortran::lower::translateSymbolToFIRType(
+    mlir::MLIRContext *context,
+    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+    const SymbolRef symbol) {
   return TypeBuilder{context, defaults}.gen(symbol);
 }
 
-M::FunctionType Br::translateSymbolToFIRFunctionType(
-    M::MLIRContext *context, Co::IntrinsicTypeDefaultKinds const &defaults,
+mlir::FunctionType Fortran::lower::translateSymbolToFIRFunctionType(
+    mlir::MLIRContext *context,
+    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
     const SymbolRef symbol) {
   return TypeBuilder{context, defaults}.genFunctionType(symbol);
 }
 
-M::Type Br::convertReal(M::MLIRContext *context, int kind) {
+mlir::Type Fortran::lower::convertReal(mlir::MLIRContext *context, int kind) {
   return genFIRType<RealCat>(context, kind);
 }
 
-M::Type Br::getSequenceRefType(M::Type refType) {
+mlir::Type Fortran::lower::getSequenceRefType(mlir::Type refType) {
   auto type{refType.dyn_cast<fir::ReferenceType>()};
   assert(type && "expected a reference type");
   auto elementType{type.getEleTy()};
diff --git a/lib/lower/IO.cpp b/lib/lower/IO.cpp
index 5925392f948f..88bb5308817c 100644
--- a/lib/lower/IO.cpp
+++ b/lib/lower/IO.cpp
@@ -8,7 +8,6 @@
 
 #include "flang/lower/IO.h"
 #include "../../runtime/io-api.h"
-#include "NSAliases.h"
 #include "RTBuilder.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/OpBuilder.h"
@@ -19,10 +18,10 @@
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 
-
 #define TODO() assert(false && "not yet implemented")
 
-using namespace Io;
+using namespace Fortran::runtime::io;
+
 namespace Fortran::lower {
 namespace {
 
@@ -82,11 +81,20 @@ static constexpr FuncTypeBuilderFunc getTypeModel() {
   return std::get<A>(newIOTable).getTypeModel();
 }
 
-/// Get (or generate) the MLIR FuncOp for a given IO runtime function. This
-/// replaces getIORuntimeFunction.
+inline bool isCharacterLiteral(mlir::Type argTy) {
+  if (auto arrTy = argTy.dyn_cast<fir::SequenceType>())
+    return arrTy.getEleTy().isa<fir::CharacterType>();
+  return false;
+}
+
+inline int64_t getLength(mlir::Type argTy) {
+  return argTy.cast<fir::SequenceType>().getShape()[0];
+}
+
+/// Get (or generate) the MLIR FuncOp for a given IO runtime function.
 template <typename E>
-M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
-  M::ModuleOp module{getModule(&builder)};
+mlir::FuncOp getIORuntimeFunc(mlir::OpBuilder &builder) {
+  mlir::ModuleOp module = getModule(&builder);
   auto name = getName<E>();
   auto func = getNamedFunction(module, name);
   if (func)
@@ -99,36 +107,38 @@ M::FuncOp getIORuntimeFunc(M::OpBuilder &builder) {
 }
 
 /// Generate a call to end an IO statement
-M::Value genEndIO(M::OpBuilder &builder, M::Location loc, M::Value cookie) {
+mlir::Value genEndIO(mlir::OpBuilder &builder, mlir::Location loc,
+                     mlir::Value cookie) {
   // Terminate IO
-  M::FuncOp endIOFunc = getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder);
-  L::SmallVector<M::Value, 1> endArgs{cookie};
-  auto call = builder.create<M::CallOp>(loc, endIOFunc, endArgs);
+  auto endIOFunc = getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder);
+  llvm::SmallVector<mlir::Value, 1> endArgs{cookie};
+  auto call = builder.create<mlir::CallOp>(loc, endIOFunc, endArgs);
   return call.getResult(0);
 }
 
-using FormatItems = std::optional<std::pair<M::Value, M::Value>>;
+using FormatItems = std::optional<std::pair<mlir::Value, mlir::Value>>;
 
 /// Translate a list of format-items into a set of call-backs that can be
 /// emitted into the MLIR stream before each data item is processed
 FormatItems lowerFormat(AbstractConverter &converter,
-                        const Pa::Format &format) {
+                        const Fortran::parser::Format &format) {
   FormatItems formatItems;
-  std::visit(Co::visitors{
-                 [](const Pa::DefaultCharExpr &) { /* string expression */ },
-                 [](const Pa::Label &) { /* FORMAT statement */ },
-                 [](const Pa::Star &) {},
+  std::visit(Fortran::common::visitors{
+                 [](const Fortran::parser::DefaultCharExpr
+                        &) { /* string expression */ },
+                 [](const Fortran::parser::Label &) { /* FORMAT statement */ },
+                 [](const Fortran::parser::Star &) {},
              },
              format.u);
   return formatItems;
 }
 
-M::FuncOp getOutputRuntimeFunc(M::OpBuilder &builder, M::Type type) {
-  if (auto ty = type.dyn_cast<M::IntegerType>()) {
+mlir::FuncOp getOutputRuntimeFunc(mlir::OpBuilder &builder, mlir::Type type) {
+  if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
     if (ty.getWidth() == 1)
       return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
     return getIORuntimeFunc<mkIOKey(OutputInteger64)>(builder);
-  } else if (auto ty = type.dyn_cast<M::FloatType>()) {
+  } else if (auto ty = type.dyn_cast<mlir::FloatType>()) {
     if (ty.getWidth() <= 32)
       return getIORuntimeFunc<mkIOKey(OutputReal32)>(builder);
     return getIORuntimeFunc<mkIOKey(OutputReal64)>(builder);
@@ -145,55 +155,46 @@ M::FuncOp getOutputRuntimeFunc(M::OpBuilder &builder, M::Type type) {
   }
 }
 
-inline bool isCharacterLiteral(M::Type argTy) {
-  if (auto arrTy = argTy.dyn_cast<fir::SequenceType>())
-    return arrTy.getEleTy().isa<fir::CharacterType>();
-  return false;
-}
-
-inline int64_t getLength(M::Type argTy) {
-  return argTy.cast<fir::SequenceType>().getShape()[0];
-}
-
 /// The I/O library interface requires that COMPLEX and CHARACTER typed values
 /// be extracted and passed as separate values.
-L::SmallVector<M::Value, 4> splitArguments(M::OpBuilder &builder,
-                                           M::Location loc, M::Value arg) {
-  M::Value zero;
-  M::Value one;
-  M::Type argTy = arg.getType();
-  M::MLIRContext *context = argTy.getContext();
+llvm::SmallVector<mlir::Value, 4>
+splitArguments(mlir::OpBuilder &builder, mlir::Location loc, mlir::Value arg) {
+  mlir::Value zero;
+  mlir::Value one;
+  mlir::Type argTy = arg.getType();
+  mlir::MLIRContext *context = argTy.getContext();
   const bool isComplex = argTy.isa<fir::CplxType>();
   const bool isCharLit = isCharacterLiteral(argTy);
   const bool isBoxChar = argTy.isa<fir::BoxCharType>();
 
   if (isComplex || isCharLit || isBoxChar) {
     // Only create these constants when needed and not every time
-    zero = builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(0));
-    one = builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(1));
+    zero = builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
+    one = builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(1));
   }
   if (isComplex) {
     auto eleTy =
         fir::RealType::get(context, argTy.cast<fir::CplxType>().getFKind());
-    M::Value realPart =
+    mlir::Value realPart =
         builder.create<fir::ExtractValueOp>(loc, eleTy, arg, zero);
-    M::Value imaginaryPart =
+    mlir::Value imaginaryPart =
         builder.create<fir::ExtractValueOp>(loc, eleTy, arg, one);
     return {realPart, imaginaryPart};
   }
   if (isBoxChar) {
-    M::Type ptrTy = fir::ReferenceType::get(M::IntegerType::get(8, context));
-    M::Type sizeTy = M::IntegerType::get(64, context);
-    M::Value pointerPart =
+    mlir::Type ptrTy =
+        fir::ReferenceType::get(mlir::IntegerType::get(8, context));
+    mlir::Type sizeTy = mlir::IntegerType::get(64, context);
+    mlir::Value pointerPart =
         builder.create<fir::ExtractValueOp>(loc, ptrTy, arg, zero);
-    M::Value sizePart =
+    mlir::Value sizePart =
         builder.create<fir::ExtractValueOp>(loc, sizeTy, arg, one);
     return {pointerPart, sizePart};
   }
   if (isCharLit) {
-    M::Value variable = builder.create<fir::AllocaOp>(loc, argTy);
+    mlir::Value variable = builder.create<fir::AllocaOp>(loc, argTy);
     builder.create<fir::StoreOp>(loc, arg, variable);
-    M::Value sizePart = builder.create<M::ConstantOp>(
+    mlir::Value sizePart = builder.create<mlir::ConstantOp>(
         loc, builder.getI64IntegerAttr(getLength(argTy)));
     return {variable, sizePart};
   }
@@ -202,24 +203,25 @@ L::SmallVector<M::Value, 4> splitArguments(M::OpBuilder &builder,
 
 /// Generate a call to an Output I/O function.
 /// The specific call is determined dynamically by the argument type.
-void genOutputRuntimeFunc(M::OpBuilder &builder, M::Location loc,
-                          M::Type argType, M::Value cookie,
-                          L::SmallVector<M::Value, 4> &operands) {
+void genOutputRuntimeFunc(mlir::OpBuilder &builder, mlir::Location loc,
+                          mlir::Type argType, mlir::Value cookie,
+                          llvm::SmallVector<mlir::Value, 4> &operands) {
   int i = 1;
-  L::SmallVector<M::Value, 4> actuals{cookie};
+  llvm::SmallVector<mlir::Value, 4> actuals{cookie};
   auto outputFunc = getOutputRuntimeFunc(builder, argType);
 
   for (auto &op : operands)
     actuals.emplace_back(builder.create<fir::ConvertOp>(
         loc, outputFunc.getType().getInput(i++), op));
-  builder.create<M::CallOp>(loc, outputFunc, actuals);
+  builder.create<mlir::CallOp>(loc, outputFunc, actuals);
 }
 
 /// Lower print statement assuming a dummy runtime interface for now.
-void lowerPrintStatement(AbstractConverter &converter, M::Location loc,
-                         M::ValueRange args, const Pa::Format &format) {
-  M::FuncOp beginFunc;
-  M::OpBuilder &builder = converter.getOpBuilder();
+void lowerPrintStatement(AbstractConverter &converter, mlir::Location loc,
+                         mlir::ValueRange args,
+                         const Fortran::parser::Format &format) {
+  mlir::FuncOp beginFunc;
+  mlir::OpBuilder &builder = converter.getOpBuilder();
   auto formatItems = lowerFormat(converter, format);
   if (formatItems.has_value()) {
     // has a format
@@ -227,37 +229,37 @@ void lowerPrintStatement(AbstractConverter &converter, M::Location loc,
   } else {
     beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
   }
-  M::FunctionType beginFuncTy = beginFunc.getType();
+  mlir::FunctionType beginFuncTy = beginFunc.getType();
 
   // Initiate io
-  M::Value defaultUnit = builder.create<M::ConstantOp>(
+  mlir::Value defaultUnit = builder.create<mlir::ConstantOp>(
       loc, builder.getIntegerAttr(beginFuncTy.getInput(0), 1));
-  M::Value null =
-      builder.create<M::ConstantOp>(loc, builder.getI64IntegerAttr(0));
-  M::Value srcFileName =
+  mlir::Value null =
+      builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
+  mlir::Value srcFileName =
       builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(1), null);
-  M::Value lineNo = builder.create<M::ConstantOp>(
+  mlir::Value lineNo = builder.create<mlir::ConstantOp>(
       loc, builder.getIntegerAttr(beginFuncTy.getInput(2), 0));
-  L::SmallVector<M::Value, 3> beginArgs{defaultUnit, srcFileName, lineNo};
-  M::Value cookie =
-      builder.create<M::CallOp>(loc, beginFunc, beginArgs).getResult(0);
+  llvm::SmallVector<mlir::Value, 3> beginArgs{defaultUnit, srcFileName, lineNo};
+  mlir::Value cookie =
+      builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
 
   // Call data transfer runtime function
-  for (M::Value arg : args) {
+  for (mlir::Value arg : args) {
     auto operands = splitArguments(builder, loc, arg);
     genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
   }
   genEndIO(builder, loc, cookie);
 }
 
-L::SmallVector<M::Value, 4>
-lowerBeginArgsPositionOrFlush(AbstractConverter &converter, M::Location loc,
-                              const std::list<Pa::PositionOrFlushSpec> &specs) {
-  L::SmallVector<M::Value, 4> args;
+llvm::SmallVector<mlir::Value, 4> lowerBeginArgsPositionOrFlush(
+    AbstractConverter &converter, mlir::Location loc,
+    const std::list<Fortran::parser::PositionOrFlushSpec> &specs) {
+  llvm::SmallVector<mlir::Value, 4> args;
   // 1. find the unit number expression and append it
   for (auto &sp : specs)
-    if (auto *un = std::get_if<Pa::FileUnitNumber>(&sp.u)) {
-      auto *expr{Se::GetExpr(un->v)};
+    if (auto *un = std::get_if<Fortran::parser::FileUnitNumber>(&sp.u)) {
+      auto *expr = Fortran::semantics::GetExpr(un->v);
       args.push_back(converter.genExprValue(expr, loc));
       break;
     }
@@ -268,37 +270,40 @@ lowerBeginArgsPositionOrFlush(AbstractConverter &converter, M::Location loc,
 
 /// 3 of the 4 cases in a position (or flush) spec concern the error handling of
 /// the statement. We handle those 3 cases here.
-M::Value lowerErrorHandlingPositionOrFlush(
-    AbstractConverter &converter, M::Value endRes,
-    const std::list<Pa::PositionOrFlushSpec> &specs) {
-  M::Value result;
-  auto builder{converter.getOpBuilder()};
+mlir::Value lowerErrorHandlingPositionOrFlush(
+    AbstractConverter &converter, mlir::Value endRes,
+    const std::list<Fortran::parser::PositionOrFlushSpec> &specs) {
+  mlir::Value result;
+  auto builder = converter.getOpBuilder();
   auto loc = converter.getCurrentLocation();
   for (auto &sp : specs) {
     std::visit(
-        Co::visitors{
-            [](const Pa::FileUnitNumber &) {
+        Fortran::common::visitors{
+            [](const Fortran::parser::FileUnitNumber &) {
               // this is passed to the BeginFoo function
               // do nothing here
             },
-            [&](const Pa::MsgVariable &var) {
+            [&](const Fortran::parser::MsgVariable &var) {
               // call GetIoMsg, passing it the address of `var` and a length (in
               // bytes, or?). Effectively, we have to decompose a boxchar here.
               // TODO: this has to be a CHARACTER type, no?
-              M::Value varAddr = converter.genExprAddr(Se::GetExpr(var), loc);
-              M::FuncOp getIoMsg = getIORuntimeFunc<mkIOKey(GetIoMsg)>(builder);
-              L::SmallVector<M::Value, 1> ioMsgArgs{
+              mlir::Value varAddr =
+                  converter.genExprAddr(Fortran::semantics::GetExpr(var), loc);
+              mlir::FuncOp getIoMsg =
+                  getIORuntimeFunc<mkIOKey(GetIoMsg)>(builder);
+              llvm::SmallVector<mlir::Value, 1> ioMsgArgs{
                   builder.create<fir::ConvertOp>(
                       loc, getModel<char *>()(builder.getContext()), varAddr)
                   /*, FIXME add length here */};
-              builder.create<M::CallOp>(loc, getIoMsg, ioMsgArgs);
+              builder.create<mlir::CallOp>(loc, getIoMsg, ioMsgArgs);
             },
-            [&](const Pa::StatVariable &var) {
+            [&](const Fortran::parser::StatVariable &var) {
               /* store `endRes` to the variable `var` */
-              M::Value varAddr = converter.genExprAddr(Se::GetExpr(var), loc);
+              mlir::Value varAddr =
+                  converter.genExprAddr(Fortran::semantics::GetExpr(var), loc);
               builder.create<fir::StoreOp>(loc, endRes, varAddr);
             },
-            [&](const Pa::ErrLabel &label) {
+            [&](const Fortran::parser::ErrLabel &label) {
               /* pass the `endRes` value for `fir.switch` op */
               result = endRes;
             },
@@ -311,12 +316,12 @@ M::Value lowerErrorHandlingPositionOrFlush(
 /// Generate IO calls for any of the "position or flush" like IO statements.
 /// This is templatized with a statement type `S` and a key `K` for genericity.
 template <typename K, typename S>
-M::Value genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
+mlir::Value genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
   auto builder = converter.getOpBuilder();
   auto loc = converter.getCurrentLocation();
   auto beginFunc = getIORuntimeFunc<K>(builder);
   auto args = lowerBeginArgsPositionOrFlush(converter, loc, stmt.v);
-  auto call = builder.create<M::CallOp>(loc, beginFunc, args);
+  auto call = builder.create<mlir::CallOp>(loc, beginFunc, args);
   // FIXME: add call to EnableHandlers as apropos
   auto cookie = call.getResult(0);
   auto endVal = genEndIO(builder, converter.getCurrentLocation(), cookie);
@@ -324,29 +329,30 @@ M::Value genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
 }
 } // namespace
 
-M::Value genBackspaceStatement(AbstractConverter &converter,
-                               const Pa::BackspaceStmt &stmt) {
+mlir::Value genBackspaceStatement(AbstractConverter &converter,
+                                  const Fortran::parser::BackspaceStmt &stmt) {
   return genPosOrFlushLikeStmt<mkIOKey(BeginBackspace)>(converter, stmt);
 }
 
-M::Value genEndfileStatement(AbstractConverter &converter,
-                             const Pa::EndfileStmt &stmt) {
+mlir::Value genEndfileStatement(AbstractConverter &converter,
+                                const Fortran::parser::EndfileStmt &stmt) {
   return genPosOrFlushLikeStmt<mkIOKey(BeginEndfile)>(converter, stmt);
 }
 
-M::Value genFlushStatement(AbstractConverter &converter,
-                           const Pa::FlushStmt &stmt) {
+mlir::Value genFlushStatement(AbstractConverter &converter,
+                              const Fortran::parser::FlushStmt &stmt) {
   return genPosOrFlushLikeStmt<mkIOKey(BeginFlush)>(converter, stmt);
 }
 
-M::Value genRewindStatement(AbstractConverter &converter,
-                            const Pa::RewindStmt &stmt) {
+mlir::Value genRewindStatement(AbstractConverter &converter,
+                               const Fortran::parser::RewindStmt &stmt) {
   return genPosOrFlushLikeStmt<mkIOKey(BeginRewind)>(converter, stmt);
 }
 
-M::Value genOpenStatement(AbstractConverter &converter, const Pa::OpenStmt &) {
+mlir::Value genOpenStatement(AbstractConverter &converter,
+                             const Fortran::parser::OpenStmt &) {
   auto builder = converter.getOpBuilder();
-  M::FuncOp beginFunc;
+  mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
   // else
@@ -355,33 +361,35 @@ M::Value genOpenStatement(AbstractConverter &converter, const Pa::OpenStmt &) {
   return {};
 }
 
-M::Value genCloseStatement(AbstractConverter &converter,
-                           const Pa::CloseStmt &) {
+mlir::Value genCloseStatement(AbstractConverter &converter,
+                              const Fortran::parser::CloseStmt &) {
   auto builder = converter.getOpBuilder();
-  M::FuncOp beginFunc{getIORuntimeFunc<mkIOKey(BeginClose)>(builder)};
+  mlir::FuncOp beginFunc = getIORuntimeFunc<mkIOKey(BeginClose)>(builder);
   (void)beginFunc;
   TODO();
   return {};
 }
 
 void genPrintStatement(AbstractConverter &converter,
-                       const Pa::PrintStmt &stmt) {
-  L::SmallVector<M::Value, 4> args;
-  for (auto &item : std::get<std::list<Pa::OutputItem>>(stmt.t)) {
-    if (auto *pe{std::get_if<Pa::Expr>(&item.u)}) {
-      auto loc{converter.genLocation(pe->source)};
-      args.push_back(converter.genExprValue(Se::GetExpr(*pe), loc));
+                       const Fortran::parser::PrintStmt &stmt) {
+  llvm::SmallVector<mlir::Value, 4> args;
+  for (auto &item : std::get<std::list<Fortran::parser::OutputItem>>(stmt.t)) {
+    if (auto *pe{std::get_if<Fortran::parser::Expr>(&item.u)}) {
+      auto loc = converter.genLocation(pe->source);
+      args.push_back(
+          converter.genExprValue(Fortran::semantics::GetExpr(*pe), loc));
     } else {
       TODO(); // TODO implied do
     }
   }
   lowerPrintStatement(converter, converter.getCurrentLocation(), args,
-                      std::get<Pa::Format>(stmt.t));
+                      std::get<Fortran::parser::Format>(stmt.t));
 }
 
-M::Value genReadStatement(AbstractConverter &converter, const Pa::ReadStmt &) {
+mlir::Value genReadStatement(AbstractConverter &converter,
+                             const Fortran::parser::ReadStmt &) {
   auto builder = converter.getOpBuilder();
-  M::FuncOp beginFunc;
+  mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
   // else if (...
@@ -389,10 +397,10 @@ M::Value genReadStatement(AbstractConverter &converter, const Pa::ReadStmt &) {
   return {};
 }
 
-M::Value genWriteStatement(AbstractConverter &converter,
-                           const Pa::WriteStmt &) {
+mlir::Value genWriteStatement(AbstractConverter &converter,
+                              const Fortran::parser::WriteStmt &) {
   auto builder = converter.getOpBuilder();
-  M::FuncOp beginFunc;
+  mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
   // else if (...
@@ -400,10 +408,10 @@ M::Value genWriteStatement(AbstractConverter &converter,
   return {};
 }
 
-M::Value genInquireStatement(AbstractConverter &converter,
-                             const Pa::InquireStmt &) {
+mlir::Value genInquireStatement(AbstractConverter &converter,
+                                const Fortran::parser::InquireStmt &) {
   auto builder = converter.getOpBuilder();
-  M::FuncOp beginFunc;
+  mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(builder);
   // else if (...
@@ -413,4 +421,5 @@ M::Value genInquireStatement(AbstractConverter &converter,
   TODO();
   return {};
 }
+
 } // namespace Fortran::lower
diff --git a/lib/lower/Intrinsics.cpp b/lib/lower/Intrinsics.cpp
index 0e6bd4cdd0eb..359b7bd0985c 100644
--- a/lib/lower/Intrinsics.cpp
+++ b/lib/lower/Intrinsics.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Intrinsics.h"
-#include "NSAliases.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/lower/Runtime.h"
@@ -28,40 +27,41 @@ namespace Fortran::lower {
 /// signatures. There is no guarantee that that runtime functions are available
 /// for all intrinsic functions and possible types.
 /// To be easy and fast to use, this class holds a map and uses
-/// M::FunctionType to represent the runtime function type. This imply that
+/// mlir::FunctionType to represent the runtime function type. This imply that
 /// MathRuntimeLibrary cannot be constexpr built and requires an
-/// M::MLIRContext to be built. Its constructor uses a constexpr table
+/// mlir::MLIRContext to be built. Its constructor uses a constexpr table
 /// description of the runtime. The runtime functions are not declared into the
-/// M::module until there is a query that needs them. This is to avoid
+/// mlir::module until there is a query that needs them. This is to avoid
 /// polluting the FIR/LLVM IR dumps with unused functions.
 class MathRuntimeLibrary {
 public:
   /// The map key are Fortran generic intrinsic names.
-  using Key = L::StringRef;
+  using Key = llvm::StringRef;
   struct Hash { // Need custom hash for this kind of key
-    size_t operator()(const Key &k) const { return L::hash_value(k); }
+    size_t operator()(const Key &k) const { return llvm::hash_value(k); }
   };
   /// Runtime function description that is sufficient to build an
-  /// M::FuncOp and to compare function types.
+  /// mlir::FuncOp and to compare function types.
   struct RuntimeFunction {
-    RuntimeFunction(L::StringRef n, M::FunctionType t) : symbol{n}, type{t} {};
-    L::StringRef symbol;
-    M::FunctionType type;
+    RuntimeFunction(llvm::StringRef n, mlir::FunctionType t)
+        : symbol{n}, type{t} {};
+    llvm::StringRef symbol;
+    mlir::FunctionType type;
   };
   using Map = std::unordered_multimap<Key, RuntimeFunction, Hash>;
 
-  MathRuntimeLibrary(IntrinsicLibrary::Version, M::MLIRContext &);
+  MathRuntimeLibrary(IntrinsicLibrary::Version, mlir::MLIRContext &);
 
   /// Probe the intrinsic library for a certain intrinsic and get/build the
-  /// related M::FuncOp if a runtime description is found.
+  /// related mlir::FuncOp if a runtime description is found.
   /// Also add a unit attribute "fir.runtime" to the function so that later
   /// it is possible to quickly know what function are intrinsics vs users.
-  L::Optional<M::FuncOp> getFunction(M::OpBuilder &, L::StringRef,
-                                     M::FunctionType) const;
+  llvm::Optional<mlir::FuncOp> getFunction(mlir::OpBuilder &, llvm::StringRef,
+                                           mlir::FunctionType) const;
 
 private:
-  M::FuncOp getFuncOp(M::OpBuilder &builder,
-                      const RuntimeFunction &runtime) const;
+  mlir::FuncOp getFuncOp(mlir::OpBuilder &builder,
+                         const RuntimeFunction &runtime) const;
   Map library;
 };
 
@@ -126,23 +126,25 @@ enum class ExtremumBehavior {
 // TODO error handling -> return a code or directly emit messages ?
 class IntrinsicLibrary::Implementation {
 public:
-  Implementation(Version v, M::MLIRContext &c) : runtime{v, c} {}
-  inline M::Value genval(M::Location loc, M::OpBuilder &builder,
-                         L::StringRef name, M::Type resultType,
-                         L::ArrayRef<M::Value> args);
+  Implementation(Version v, mlir::MLIRContext &c) : runtime{v, c} {}
+  inline mlir::Value genval(mlir::Location loc, mlir::OpBuilder &builder,
+                            llvm::StringRef name, mlir::Type resultType,
+                            llvm::ArrayRef<mlir::Value> args);
 
 private:
   // Info needed by Generators is passed in Context struct to keep Generator
   // signatures modification easy.
   struct Context {
-    M::Location loc;
-    M::OpBuilder *builder{nullptr};
-    L::StringRef name;
-    L::ArrayRef<M::Value> arguments;
-    M::FunctionType funcType;
-    M::ModuleOp getModuleOp() { return getModule(builder); }
-    M::MLIRContext *getMLIRContext() { return getModule(builder).getContext(); }
-    M::Type getResultType() {
+    mlir::Location loc;
+    mlir::OpBuilder *builder = nullptr;
+    llvm::StringRef name;
+    llvm::ArrayRef<mlir::Value> arguments;
+    mlir::FunctionType funcType;
+    mlir::ModuleOp getModuleOp() { return getModule(builder); }
+    mlir::MLIRContext *getMLIRContext() {
+      return getModule(builder).getContext();
+    }
+    mlir::Type getResultType() {
       assert(funcType.getNumResults() == 1);
       return funcType.getResult(0);
     }
@@ -150,7 +152,7 @@ class IntrinsicLibrary::Implementation {
 
   /// Define the different FIR generators that can be mapped to intrinsic to
   /// generate the related code.
-  using Generator = M::Value (*)(Context &, MathRuntimeLibrary &);
+  using Generator = mlir::Value (*)(Context &, MathRuntimeLibrary &);
 
   /// Search a runtime function that is associated to the generic intrinsic name
   /// and whose signature matches the intrinsic arguments and result types.
@@ -159,27 +161,27 @@ class IntrinsicLibrary::Implementation {
   /// conversions will be inserted before and/or after the call. This is to
   /// mainly to allow 16 bits float support even-though little or no math
   /// runtime is currently available for it.
-  static M::Value genRuntimeCall(Context &, MathRuntimeLibrary &);
+  static mlir::Value genRuntimeCall(Context &, MathRuntimeLibrary &);
 
   /// All generators can be combined with genWrapperCall that will build a
   /// function named "fir."+ <generic name> + "." + <result type code> and
   /// generate the intrinsic implementation inside instead of at the intrinsic
   /// call sites. This can be used to keep the FIR more readable.
   template <Generator g>
-  static M::Value genWrapperCall(Context &c, MathRuntimeLibrary &r) {
+  static mlir::Value genWrapperCall(Context &c, MathRuntimeLibrary &r) {
     return outlineInWrapper(g, c, r);
   }
 
   /// The defaultGenerator is always attempted if no mapping was found for the
   /// generic name provided.
-  static M::Value defaultGenerator(Context &c, MathRuntimeLibrary &r) {
+  static mlir::Value defaultGenerator(Context &c, MathRuntimeLibrary &r) {
     return genWrapperCall<&I::genRuntimeCall>(c, r);
   }
 
-  static M::Value genConjg(Context &, MathRuntimeLibrary &);
+  static mlir::Value genConjg(Context &, MathRuntimeLibrary &);
   template <Extremum, ExtremumBehavior>
-  static M::Value genExtremum(Context &, MathRuntimeLibrary &);
-  static M::Value genMerge(Context &, MathRuntimeLibrary &);
+  static mlir::Value genExtremum(Context &, MathRuntimeLibrary &);
+  static mlir::Value genMerge(Context &, MathRuntimeLibrary &);
 
   struct IntrinsicHanlder {
     const char *name;
@@ -198,18 +200,18 @@ class IntrinsicLibrary::Implementation {
   };
 
   // helpers
-  static M::Value outlineInWrapper(Generator, Context &c,
-                                   MathRuntimeLibrary &r);
+  static mlir::Value outlineInWrapper(Generator, Context &c,
+                                      MathRuntimeLibrary &r);
 
   MathRuntimeLibrary runtime;
 };
 
 // helpers
-static std::string getIntrinsicWrapperName(const L::StringRef &intrinsic,
-                                           M::FunctionType funTy);
-static M::FunctionType getFunctionType(M::Type resultType,
-                                       L::ArrayRef<M::Value> arguments,
-                                       M::OpBuilder &);
+static std::string getIntrinsicWrapperName(const llvm::StringRef &intrinsic,
+                                           mlir::FunctionType funTy);
+static mlir::FunctionType getFunctionType(mlir::Type resultType,
+                                          llvm::ArrayRef<mlir::Value> arguments,
+                                          mlir::OpBuilder &);
 
 /// Define a simple static runtime description that will be transformed into
 /// RuntimeFunction when building the IntrinsicLibrary.
@@ -218,11 +220,11 @@ class MathsRuntimeStaticDescription : public RuntimeStaticDescription {
   constexpr MathsRuntimeStaticDescription(const char *n, const char *s,
                                           MaybeTypeCode r, TypeCodeVector a)
       : RuntimeStaticDescription{s, r, a}, name{n} {}
-  L::StringRef getName() const { return name; }
+  llvm::StringRef getName() const { return name; }
 
 private:
   // Generic math function name
-  const char *name{nullptr};
+  const char *name = nullptr;
 };
 
 /// Description of the runtime functions available on the target.
@@ -274,13 +276,15 @@ static constexpr MathsRuntimeStaticDescription pgmathPreciseRuntime[] = {
 // IntrinsicLibrary implementation
 
 IntrinsicLibrary::IntrinsicLibrary(IntrinsicLibrary::Version v,
-                                   M::MLIRContext &context)
+                                   mlir::MLIRContext &context)
     : impl{new Implementation(v, context)} {}
 IntrinsicLibrary::~IntrinsicLibrary() = default;
 
-M::Value IntrinsicLibrary::genval(M::Location loc, M::OpBuilder &builder,
-                                  L::StringRef name, M::Type resultType,
-                                  L::ArrayRef<M::Value> args) const {
+mlir::Value IntrinsicLibrary::genval(mlir::Location loc,
+                                     mlir::OpBuilder &builder,
+                                     llvm::StringRef name,
+                                     mlir::Type resultType,
+                                     llvm::ArrayRef<mlir::Value> args) const {
   assert(impl);
   return impl->genval(loc, builder, name, resultType, args);
 }
@@ -290,7 +294,7 @@ M::Value IntrinsicLibrary::genval(M::Location loc, M::OpBuilder &builder,
 // Create the runtime description for the targeted library version.
 // So far ignore the version an only load the dummy llvm lib and pgmath precise
 MathRuntimeLibrary::MathRuntimeLibrary(IntrinsicLibrary::Version,
-                                       M::MLIRContext &mlirContext) {
+                                       mlir::MLIRContext &mlirContext) {
   for (const MathsRuntimeStaticDescription &func : llvmRuntime) {
     RuntimeFunction impl{func.getSymbol(),
                          func.getMLIRFunctionType(&mlirContext)};
@@ -303,10 +307,11 @@ MathRuntimeLibrary::MathRuntimeLibrary(IntrinsicLibrary::Version,
   }
 }
 
-M::FuncOp MathRuntimeLibrary::getFuncOp(M::OpBuilder &builder,
-                                        const RuntimeFunction &runtime) const {
-  auto module{getModule(&builder)};
-  M::FuncOp function{getNamedFunction(module, runtime.symbol)};
+mlir::FuncOp
+MathRuntimeLibrary::getFuncOp(mlir::OpBuilder &builder,
+                              const RuntimeFunction &runtime) const {
+  auto module = getModule(&builder);
+  auto function = getNamedFunction(module, runtime.symbol);
   if (!function) {
     function = createFunction(module, runtime.symbol, runtime.type);
     function.setAttr("fir.runtime", builder.getUnitAttr());
@@ -327,18 +332,16 @@ M::FuncOp MathRuntimeLibrary::getFuncOp(M::OpBuilder &builder,
 class FunctionDistance {
 public:
   FunctionDistance() : infinite{true} {}
-  FunctionDistance(M::FunctionType from, M::FunctionType to) {
-    auto nInputs{from.getNumInputs()};
-    auto nResults{from.getNumResults()};
+  FunctionDistance(mlir::FunctionType from, mlir::FunctionType to) {
+    auto nInputs = from.getNumInputs();
+    auto nResults = from.getNumResults();
     if (nResults != to.getNumResults() || nInputs != to.getNumInputs()) {
       infinite = true;
     } else {
-      for (unsigned int i{0}; i < nInputs; ++i) {
+      for (decltype(nInputs) i{0}; i < nInputs; ++i)
         addArgumentDistance(from.getInput(i), to.getInput(i));
-      }
-      for (unsigned int i{0}; i < nResults; ++i) {
+      for (decltype(nResults) i{0}; i < nResults; ++i)
         addResultDistance(to.getResult(i), from.getResult(i));
-      }
     }
   }
   bool isSmallerThan(const FunctionDistance &d) const {
@@ -355,7 +358,7 @@ class FunctionDistance {
 private:
   enum class Conversion { Forbidden, None, Narrow, Extend };
 
-  void addArgumentDistance(M::Type from, M::Type to) {
+  void addArgumentDistance(mlir::Type from, mlir::Type to) {
     switch (conversionBetweenTypes(from, to)) {
     case Conversion::Forbidden:
       infinite = true;
@@ -370,7 +373,7 @@ class FunctionDistance {
       break;
     }
   }
-  void addResultDistance(M::Type from, M::Type to) {
+  void addResultDistance(mlir::Type from, mlir::Type to) {
     switch (conversionBetweenTypes(from, to)) {
     case Conversion::Forbidden:
       infinite = true;
@@ -385,12 +388,12 @@ class FunctionDistance {
       break;
     }
   }
-  // Floating point can be M::FloatType or fir::real
-  static unsigned getFloatingPointWidth(M::Type t) {
-    if (auto f{t.dyn_cast<M::FloatType>()})
+  // Floating point can be mlir::FloatType or fir::real
+  static unsigned getFloatingPointWidth(mlir::Type t) {
+    if (auto f{t.dyn_cast<mlir::FloatType>()})
       return f.getWidth();
     // FIXME: Get width another way for fir.real/complex
-    // - use fir/KindMapping.h and L::Type
+    // - use fir/KindMapping.h and llvm::Type
     // - or use evaluate/type.h
     if (auto r{t.dyn_cast<fir::RealType>()})
       return r.getFKind() * 4;
@@ -399,15 +402,15 @@ class FunctionDistance {
     assert(false && "not a floating-point type");
     return 0;
   }
-  static bool isFloatingPointType(M::Type t) {
-    return t.isa<M::FloatType>() || t.isa<fir::RealType>();
+  static bool isFloatingPointType(mlir::Type t) {
+    return t.isa<mlir::FloatType>() || t.isa<fir::RealType>();
   }
-  static Conversion conversionBetweenTypes(M::Type from, M::Type to) {
+  static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
     if (from == to) {
       return Conversion::None;
     }
-    if (auto fromIntTy{from.dyn_cast<M::IntegerType>()}) {
-      if (auto toIntTy{to.dyn_cast<M::IntegerType>()}) {
+    if (auto fromIntTy{from.dyn_cast<mlir::IntegerType>()}) {
+      if (auto toIntTy{to.dyn_cast<mlir::IntegerType>()}) {
         return fromIntTy.getWidth() > toIntTy.getWidth() ? Conversion::Narrow
                                                          : Conversion::Extend;
       }
@@ -450,14 +453,14 @@ class FunctionDistance {
 // Select runtime function that has the smallest distance to the intrinsic
 // function type and that will not imply narrowing arguments or extending the
 // result.
-L::Optional<M::FuncOp>
-MathRuntimeLibrary::getFunction(M::OpBuilder &builder, L::StringRef name,
-                                M::FunctionType funcType) const {
-  auto range{library.equal_range(name)};
-  const RuntimeFunction *bestNearMatch{nullptr};
+llvm::Optional<mlir::FuncOp>
+MathRuntimeLibrary::getFunction(mlir::OpBuilder &builder, llvm::StringRef name,
+                                mlir::FunctionType funcType) const {
+  auto range = library.equal_range(name);
+  const RuntimeFunction *bestNearMatch = nullptr;
   FunctionDistance bestMatchDistance{};
   for (auto iter{range.first}; iter != range.second; ++iter) {
-    const RuntimeFunction &impl{iter->second};
+    const RuntimeFunction &impl = iter->second;
     if (funcType == impl.type) {
       return getFuncOp(builder, impl); // exact match
     } else {
@@ -478,11 +481,9 @@ MathRuntimeLibrary::getFunction(M::OpBuilder &builder, L::StringRef name,
 
 // IntrinsicLibrary::Implementation implementation
 
-M::Value IntrinsicLibrary::Implementation::genval(M::Location loc,
-                                                  M::OpBuilder &builder,
-                                                  L::StringRef name,
-                                                  M::Type resultType,
-                                                  L::ArrayRef<M::Value> args) {
+mlir::Value IntrinsicLibrary::Implementation::genval(
+    mlir::Location loc, mlir::OpBuilder &builder, llvm::StringRef name,
+    mlir::Type resultType, llvm::ArrayRef<mlir::Value> args) {
   Context context{loc, &builder, name, args,
                   getFunctionType(resultType, args, builder)};
   for (auto &handler : handlers) {
@@ -496,22 +497,22 @@ M::Value IntrinsicLibrary::Implementation::genval(M::Location loc,
   return defaultGenerator(context, runtime);
 }
 
-static M::FunctionType getFunctionType(M::Type resultType,
-                                       L::ArrayRef<M::Value> arguments,
-                                       M::OpBuilder &builder) {
-  L::SmallVector<M::Type, 2> argumentTypes;
+static mlir::FunctionType getFunctionType(mlir::Type resultType,
+                                          llvm::ArrayRef<mlir::Value> arguments,
+                                          mlir::OpBuilder &builder) {
+  llvm::SmallVector<mlir::Type, 2> argumentTypes;
   for (auto &arg : arguments) {
     assert(arg != nullptr); // TODO think about optionals
     argumentTypes.push_back(arg.getType());
   }
-  return M::FunctionType::get(argumentTypes, resultType,
-                              getModule(&builder).getContext());
+  return mlir::FunctionType::get(argumentTypes, resultType,
+                                 getModule(&builder).getContext());
 }
 
 // TODO find nicer type to string infra or move this in a mangling utility
 // mlir as Type::dump(ostream) methods but it may adds !
-static std::string typeToString(M::Type t) {
-  if (auto i{t.dyn_cast<M::IntegerType>()}) {
+static std::string typeToString(mlir::Type t) {
+  if (auto i{t.dyn_cast<mlir::IntegerType>()}) {
     return "i" + std::to_string(i.getWidth());
   }
   if (auto cplx{t.dyn_cast<fir::CplxType>()}) {
@@ -520,7 +521,7 @@ static std::string typeToString(M::Type t) {
   if (auto real{t.dyn_cast<fir::RealType>()}) {
     return "r" + std::to_string(real.getFKind());
   }
-  if (auto f{t.dyn_cast<M::FloatType>()}) {
+  if (auto f{t.dyn_cast<mlir::FloatType>()}) {
     return "f" + std::to_string(f.getWidth());
   }
   if (auto logical{t.dyn_cast<fir::LogicalType>()}) {
@@ -532,24 +533,25 @@ static std::string typeToString(M::Type t) {
   assert(false && "no mangling for type");
   return ""s;
 }
-static std::string getIntrinsicWrapperName(const L::StringRef &intrinsic,
-                                           M::FunctionType funTy) {
+static std::string getIntrinsicWrapperName(const llvm::StringRef &intrinsic,
+                                           mlir::FunctionType funTy) {
   std::string name{"fir." + intrinsic.str() + "."};
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
   name += typeToString(funTy.getResult(0));
-  for (std::size_t i{0}; i < funTy.getNumInputs(); ++i) {
+  auto e{funTy.getNumInputs()};
+  for (decltype(e) i{0}; i < e; ++i) {
     name += "." + typeToString(funTy.getInput(i));
   }
   return name;
 }
 
-M::Value IntrinsicLibrary::Implementation::outlineInWrapper(
+mlir::Value IntrinsicLibrary::Implementation::outlineInWrapper(
     Generator generator, Context &context, MathRuntimeLibrary &runtime) {
-  M::ModuleOp module{getModule(context.builder)};
-  M::MLIRContext *mlirContext{module.getContext()};
+  auto module = getModule(context.builder);
+  auto *mlirContext = module.getContext();
   std::string wrapperName{
       getIntrinsicWrapperName(context.name, context.funcType)};
-  M::FuncOp function{getNamedFunction(module, wrapperName)};
+  auto function = getNamedFunction(module, wrapperName);
   if (!function) {
     // First time this wrapper is needed, build it.
     function = createFunction(module, wrapperName, context.funcType);
@@ -560,35 +562,35 @@ M::Value IntrinsicLibrary::Implementation::outlineInWrapper(
     // This new function is not linked to a source file location, only
     // its calls will be.
     Context localContext{context};
-    auto localBuilder{std::make_unique<M::OpBuilder>(function)};
+    auto localBuilder = std::make_unique<mlir::OpBuilder>(function);
     localBuilder->setInsertionPointToStart(&function.front());
     localContext.builder = &(*localBuilder);
-    L::SmallVector<M::Value, 2> localArguments;
-    for (M::BlockArgument bArg : function.front().getArguments()) {
+    llvm::SmallVector<mlir::Value, 2> localArguments;
+    for (mlir::BlockArgument bArg : function.front().getArguments()) {
       localArguments.push_back(bArg);
     }
     localContext.arguments = localArguments;
-    localContext.loc = M::UnknownLoc::get(mlirContext);
+    localContext.loc = mlir::UnknownLoc::get(mlirContext);
 
-    M::Value result = generator(localContext, runtime);
-    localBuilder->create<M::ReturnOp>(localContext.loc, result);
+    mlir::Value result = generator(localContext, runtime);
+    localBuilder->create<mlir::ReturnOp>(localContext.loc, result);
   } else {
     // Wrapper was already built, ensure it has the sought type
     assert(function.getType() == context.funcType);
   }
-  auto call{context.builder->create<M::CallOp>(context.loc, function,
-                                               context.arguments)};
+  auto call = context.builder->create<mlir::CallOp>(context.loc, function,
+                                                    context.arguments);
   return call.getResult(0);
 }
 
-M::Value
+mlir::Value
 IntrinsicLibrary::Implementation::genRuntimeCall(Context &context,
                                                  MathRuntimeLibrary &runtime) {
   // Look up runtime
-  M::FunctionType soughtFuncType{context.funcType};
-  if (auto funcOp{runtime.getFunction(*context.builder, context.name,
-                                      soughtFuncType)}) {
-    M::FunctionType actualFuncType{funcOp->getType()};
+  mlir::FunctionType soughtFuncType = context.funcType;
+  if (auto funcOp =
+          runtime.getFunction(*context.builder, context.name, soughtFuncType)) {
+    mlir::FunctionType actualFuncType = funcOp->getType();
     if (actualFuncType.getNumResults() != soughtFuncType.getNumResults() ||
         actualFuncType.getNumInputs() != soughtFuncType.getNumInputs() ||
         actualFuncType.getNumInputs() != context.arguments.size() ||
@@ -596,26 +598,26 @@ IntrinsicLibrary::Implementation::genRuntimeCall(Context &context,
       assert(false); // TODO better error handling
       return nullptr;
     }
-    L::SmallVector<M::Value, 2> convertedArguments;
-    int i{0};
-    for (M::Value arg : context.arguments) {
-      M::Type actualType{actualFuncType.getInput(i)};
+    llvm::SmallVector<mlir::Value, 2> convertedArguments;
+    int i = 0;
+    for (mlir::Value arg : context.arguments) {
+      auto actualType = actualFuncType.getInput(i);
       if (soughtFuncType.getInput(i) != actualType) {
-        auto castedArg{context.builder->create<fir::ConvertOp>(
-            context.loc, actualType, arg)};
+        auto castedArg = context.builder->create<fir::ConvertOp>(
+            context.loc, actualType, arg);
         convertedArguments.push_back(castedArg.getResult());
       } else {
         convertedArguments.push_back(arg);
       }
       ++i;
     }
-    auto call{context.builder->create<M::CallOp>(context.loc, *funcOp,
-                                                 convertedArguments)};
-    M::Type soughtType{soughtFuncType.getResult(0)};
-    M::Value res = call.getResult(0);
+    auto call = context.builder->create<mlir::CallOp>(context.loc, *funcOp,
+                                                      convertedArguments);
+    mlir::Type soughtType = soughtFuncType.getResult(0);
+    mlir::Value res = call.getResult(0);
     if (actualFuncType.getResult(0) != soughtType) {
-      auto castedRes{context.builder->create<fir::ConvertOp>(context.loc,
-                                                             soughtType, res)};
+      auto castedRes =
+          context.builder->create<fir::ConvertOp>(context.loc, soughtType, res);
       return castedRes.getResult();
     } else {
       return res;
@@ -630,65 +632,66 @@ IntrinsicLibrary::Implementation::genRuntimeCall(Context &context,
 }
 
 // CONJG
-M::Value IntrinsicLibrary::Implementation::genConjg(Context &genCtxt,
-                                                    MathRuntimeLibrary &) {
+mlir::Value IntrinsicLibrary::Implementation::genConjg(Context &genCtxt,
+                                                       MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 1);
-  M::Type resType{genCtxt.getResultType()};
+  mlir::Type resType = genCtxt.getResultType();
   assert(resType == genCtxt.arguments[0].getType());
-  M::OpBuilder &builder{*genCtxt.builder};
+  mlir::OpBuilder &builder{*genCtxt.builder};
   ComplexOpsBuilder cplxHandler{builder, genCtxt.loc};
 
-  M::Value cplx = genCtxt.arguments[0];
-  M::Value imag = cplxHandler.extract<ComplexOpsBuilder::Part::Imag>(cplx);
-  M::Value negImag = genCtxt.builder->create<fir::NegfOp>(genCtxt.loc, imag);
+  mlir::Value cplx = genCtxt.arguments[0];
+  mlir::Value imag = cplxHandler.extract<ComplexOpsBuilder::Part::Imag>(cplx);
+  mlir::Value negImag = genCtxt.builder->create<fir::NegfOp>(genCtxt.loc, imag);
   return cplxHandler.insert<ComplexOpsBuilder::Part::Imag>(cplx, negImag);
 }
 
 // MERGE
-M::Value IntrinsicLibrary::Implementation::genMerge(Context &genCtxt,
-                                                    MathRuntimeLibrary &) {
+mlir::Value IntrinsicLibrary::Implementation::genMerge(Context &genCtxt,
+                                                       MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 3);
-  M::Type resType{genCtxt.getResultType()};
-  M::OpBuilder &builder{*genCtxt.builder};
+  [[maybe_unused]] auto resType = genCtxt.getResultType();
+  mlir::OpBuilder &builder{*genCtxt.builder};
 
   auto &trueVal = genCtxt.arguments[0];
   auto &falseVal = genCtxt.arguments[1];
   auto &mask = genCtxt.arguments[2];
-  M::Type i1Type{M::IntegerType::get(1, builder.getContext())};
+  auto i1Type = mlir::IntegerType::get(1, builder.getContext());
   auto msk = builder.create<fir::ConvertOp>(genCtxt.loc, i1Type, mask);
-  return builder.create<M::SelectOp>(genCtxt.loc, msk, trueVal, falseVal);
+  return builder.create<mlir::SelectOp>(genCtxt.loc, msk, trueVal, falseVal);
 }
 
 // Compare two FIR values and return boolean result as i1.
 template <Extremum extremum, ExtremumBehavior behavior>
-static M::Value createExtremumCompare(M::Location loc, M::OpBuilder &builder,
-                                      M::Value left, M::Value right) {
+static mlir::Value createExtremumCompare(mlir::Location loc,
+                                         mlir::OpBuilder &builder,
+                                         mlir::Value left, mlir::Value right) {
   static constexpr auto integerPredicate{extremum == Extremum::Max
-                                             ? M::CmpIPredicate::sgt
-                                             : M::CmpIPredicate::slt};
+                                             ? mlir::CmpIPredicate::sgt
+                                             : mlir::CmpIPredicate::slt};
   static constexpr auto orderedCmp{extremum == Extremum::Max
                                        ? fir::CmpFPredicate::OGT
                                        : fir::CmpFPredicate::OLT};
-  auto type{left.getType()};
-  M::Value result;
-  if (type.isa<M::FloatType>() || type.isa<fir::RealType>()) {
+  auto type = left.getType();
+  mlir::Value result;
+  if (type.isa<mlir::FloatType>() || type.isa<fir::RealType>()) {
     // Note: the signaling/quit aspect of the result required by IEEE
     // cannot currently be obtained with LLVM without ad-hoc runtime.
     if constexpr (behavior == ExtremumBehavior::IeeeMinMaximumNumber) {
       // Return the number if one of the inputs is NaN and the other is
       // a number.
-      auto leftIsResult{
-          builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
-      auto rightIsNan{builder.create<fir::CmpfOp>(loc, fir::CmpFPredicate::UNE,
-                                                  right, right)};
-      result = builder.create<M::OrOp>(loc, leftIsResult, rightIsNan);
+      auto leftIsResult =
+          builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
+      auto rightIsNan = builder.create<fir::CmpfOp>(
+          loc, fir::CmpFPredicate::UNE, right, right);
+      result = builder.create<mlir::OrOp>(loc, leftIsResult, rightIsNan);
     } else if constexpr (behavior == ExtremumBehavior::IeeeMinMaximum) {
       // Always return NaNs if one the input is NaNs
-      auto leftIsResult{
-          builder.create<fir::CmpfOp>(loc, orderedCmp, left, right)};
-      auto leftIsNan{builder.create<fir::CmpfOp>(loc, fir::CmpFPredicate::UNE,
-                                                 left, left)};
-      result = builder.create<M::OrOp>(loc, leftIsResult, leftIsNan);
+      auto leftIsResult =
+          builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
+      auto leftIsNan =
+          builder.create<fir::CmpfOp>(loc, fir::CmpFPredicate::UNE, left, left);
+      result = builder.create<mlir::OrOp>(loc, leftIsResult, leftIsNan);
     } else if constexpr (behavior == ExtremumBehavior::MinMaxss) {
       // If the left is a NaN, return the right whatever it is.
       result = builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
@@ -703,8 +706,8 @@ static M::Value createExtremumCompare(M::Location loc, M::OpBuilder &builder,
       static_assert(behavior == ExtremumBehavior::IeeeMinMaxNum,
                     "ieeeMinNum/ieeMaxNum behavior not implemented");
     }
-  } else if (type.isa<M::IntegerType>()) {
-    result = builder.create<M::CmpIOp>(loc, integerPredicate, left, right);
+  } else if (type.isa<mlir::IntegerType>()) {
+    result = builder.create<mlir::CmpIOp>(loc, integerPredicate, left, right);
   } else if (type.isa<fir::CharacterType>()) {
     // TODO: ! character min and max is tricky because the result
     // length is the length of the longest argument!
@@ -716,16 +719,17 @@ static M::Value createExtremumCompare(M::Location loc, M::OpBuilder &builder,
 
 // MIN and MAX
 template <Extremum extremum, ExtremumBehavior behavior>
-M::Value IntrinsicLibrary::Implementation::genExtremum(Context &genCtxt,
-                                                       MathRuntimeLibrary &) {
+mlir::Value
+IntrinsicLibrary::Implementation::genExtremum(Context &genCtxt,
+                                              MathRuntimeLibrary &) {
   auto &builder{*genCtxt.builder};
-  auto loc{genCtxt.loc};
+  auto loc = genCtxt.loc;
   assert(genCtxt.arguments.size() >= 2);
-  M::Value result = genCtxt.arguments[0];
+  mlir::Value result = genCtxt.arguments[0];
   for (auto arg : genCtxt.arguments.drop_front()) {
-    auto mask{
-        createExtremumCompare<extremum, behavior>(loc, builder, result, arg)};
-    result = builder.create<M::SelectOp>(loc, mask, result, arg);
+    auto mask =
+        createExtremumCompare<extremum, behavior>(loc, builder, result, arg);
+    result = builder.create<mlir::SelectOp>(loc, mask, result, arg);
   }
   return result;
 }
diff --git a/lib/lower/Mangler.cpp b/lib/lower/Mangler.cpp
index 0160a703526a..2a06023705f3 100644
--- a/lib/lower/Mangler.cpp
+++ b/lib/lower/Mangler.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Mangler.h"
-#include "NSAliases.h"
 #include "flang/common/reference.h"
 #include "flang/lower/Utils.h"
 #include "flang/optimizer/Support/InternalNames.h"
@@ -17,32 +16,32 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
 
-using namespace Fortran;
-
 namespace {
 
 // recursively build the vector of module scopes
-void moduleNames(const Se::Scope *scope,
-                 L::SmallVector<L::StringRef, 2> &result) {
-  if (scope->kind() == Se::Scope::Kind::Global) {
+void moduleNames(const Fortran::semantics::Scope *scope,
+                 llvm::SmallVector<llvm::StringRef, 2> &result) {
+  if (scope->kind() == Fortran::semantics::Scope::Kind::Global) {
     return;
   }
   moduleNames(&scope->parent(), result);
-  if (scope->kind() == Se::Scope::Kind::Module)
+  if (scope->kind() == Fortran::semantics::Scope::Kind::Module)
     if (auto *symbol = scope->symbol())
       result.emplace_back(toStringRef(symbol->name()));
 }
 
-L::SmallVector<L::StringRef, 2> moduleNames(const Se::Scope *scope) {
-  L::SmallVector<L::StringRef, 2> result;
+llvm::SmallVector<llvm::StringRef, 2>
+moduleNames(const Fortran::semantics::Scope *scope) {
+  llvm::SmallVector<llvm::StringRef, 2> result;
   moduleNames(scope, result);
   return result;
 }
 
-L::Optional<L::StringRef> hostName(const Se::Scope *scope) {
-  if (scope->kind() == Se::Scope::Kind::Subprogram) {
+llvm::Optional<llvm::StringRef>
+hostName(const Fortran::semantics::Scope *scope) {
+  if (scope->kind() == Fortran::semantics::Scope::Kind::Subprogram) {
     auto &parent = scope->parent();
-    if (parent.kind() == Se::Scope::Kind::Subprogram)
+    if (parent.kind() == Fortran::semantics::Scope::Kind::Subprogram)
       if (auto *symbol = parent.symbol()) {
         return {toStringRef(symbol->name())};
       }
@@ -54,20 +53,21 @@ L::Optional<L::StringRef> hostName(const Se::Scope *scope) {
 
 // Mangle the name of `symbol` to make it unique within FIR's symbol table using
 // the FIR name mangler, `mangler`
-std::string Ma::mangleName(fir::NameUniquer &uniquer,
-                           const Se::SymbolRef symbol) {
+std::string
+Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
+                                   const Fortran::semantics::SymbolRef symbol) {
   return std::visit(
-      Co::visitors{
-          [&](const Se::MainProgramDetails &) {
+      Fortran::common::visitors{
+          [&](const Fortran::semantics::MainProgramDetails &) {
             return uniquer.doProgramEntry().str();
           },
-          [&](const Se::SubprogramDetails &) {
+          [&](const Fortran::semantics::SubprogramDetails &) {
             auto &cb{symbol->name()};
             auto modNames{moduleNames(symbol->scope())};
             return uniquer.doProcedure(modNames, hostName(symbol->scope()),
                                        toStringRef(cb));
           },
-          [&](const Se::ProcEntityDetails &) {
+          [&](const Fortran::semantics::ProcEntityDetails &) {
             auto &cb{symbol->name()};
             auto modNames{moduleNames(symbol->scope())};
             return uniquer.doProcedure(modNames, hostName(symbol->scope()),
@@ -81,7 +81,7 @@ std::string Ma::mangleName(fir::NameUniquer &uniquer,
       symbol->details());
 }
 
-std::string Ma::demangleName(L::StringRef name) {
+std::string Fortran::lower::mangle::demangleName(llvm::StringRef name) {
   auto result{fir::NameUniquer::deconstruct(name)};
   return result.second.name;
 }
diff --git a/lib/lower/OpBuilder.cpp b/lib/lower/OpBuilder.cpp
index 09ebe21e137f..bbc4e92acd3b 100644
--- a/lib/lower/OpBuilder.cpp
+++ b/lib/lower/OpBuilder.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/OpBuilder.h"
-#include "NSAliases.h"
 #include "flang/lower/Bridge.h"
 #include "flang/lower/ConvertType.h"
 #include "flang/optimizer/Dialect/FIROpsSupport.h"
@@ -16,39 +15,43 @@
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/StringRef.h"
 
-using namespace Fortran;
-using namespace Fortran::lower;
-
-M::FuncOp Br::createFunction(Br::AbstractConverter &converter,
-                             L::StringRef name, M::FunctionType funcTy) {
+mlir::FuncOp
+Fortran::lower::createFunction(Fortran::lower::AbstractConverter &converter,
+                               llvm::StringRef name,
+                               mlir::FunctionType funcTy) {
   return fir::createFuncOp(converter.getCurrentLocation(),
                            converter.getModuleOp(), name, funcTy);
 }
 
-M::FuncOp Br::createFunction(M::ModuleOp module, L::StringRef name,
-                             M::FunctionType funcTy) {
-  return fir::createFuncOp(M::UnknownLoc::get(module.getContext()), module,
+mlir::FuncOp Fortran::lower::createFunction(mlir::ModuleOp module,
+                                            llvm::StringRef name,
+                                            mlir::FunctionType funcTy) {
+  return fir::createFuncOp(mlir::UnknownLoc::get(module.getContext()), module,
                            name, funcTy);
 }
 
-M::FuncOp Br::getNamedFunction(M::ModuleOp module, L::StringRef name) {
-  return module.lookupSymbol<M::FuncOp>(name);
+mlir::FuncOp Fortran::lower::getNamedFunction(mlir::ModuleOp module,
+                                              llvm::StringRef name) {
+  return module.lookupSymbol<mlir::FuncOp>(name);
 }
 
-void Br::SymMap::addSymbol(Se::SymbolRef symbol, M::Value value) {
+void Fortran::lower::SymMap::addSymbol(Fortran::semantics::SymbolRef symbol,
+                                       mlir::Value value) {
   symbolMap.try_emplace(&*symbol, value);
 }
 
-M::Value Br::SymMap::lookupSymbol(Se::SymbolRef symbol) {
+mlir::Value
+Fortran::lower::SymMap::lookupSymbol(Fortran::semantics::SymbolRef symbol) {
   auto iter{symbolMap.find(&*symbol)};
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
 
-void Br::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
+void Fortran::lower::SymMap::pushShadowSymbol(
+    Fortran::semantics::SymbolRef symbol, mlir::Value value) {
   // find any existing mapping for symbol
   auto iter{symbolMap.find(&*symbol)};
-  const Se::Symbol *sym{nullptr};
-  M::Value val;
+  const Fortran::semantics::Symbol *sym{nullptr};
+  mlir::Value val;
   // if mapping exists, save it on the shadow stack
   if (iter != symbolMap.end()) {
     sym = iter->first;
@@ -62,19 +65,21 @@ void Br::SymMap::pushShadowSymbol(Se::SymbolRef symbol, M::Value value) {
   (void)r;
 }
 
-M::Value Br::OpBuilderWrapper::createIntegerConstant(M::Type integerType,
-                                                     std::int64_t cst) {
-  return create<M::ConstantOp>(integerType,
-                               builder.getIntegerAttr(integerType, cst));
+mlir::Value
+Fortran::lower::OpBuilderWrapper::createIntegerConstant(mlir::Type integerType,
+                                                        std::int64_t cst) {
+  return create<mlir::ConstantOp>(integerType,
+                                  builder.getIntegerAttr(integerType, cst));
 }
 
 // LoopBuilder implementation
 
-void Br::LoopBuilder::createLoop(M::Value lb, M::Value ub, M::Value step,
-                                 const BodyGenerator &bodyGenerator) {
+void Fortran::lower::LoopBuilder::createLoop(
+    mlir::Value lb, mlir::Value ub, mlir::Value step,
+    const BodyGenerator &bodyGenerator) {
   auto lbi{convertToIndexType(lb)};
   auto ubi{convertToIndexType(ub)};
-  L::SmallVector<M::Value, 1> steps;
+  llvm::SmallVector<mlir::Value, 1> steps;
   if (step) {
     auto stepi{convertToIndexType(step)};
     steps.emplace_back(stepi);
@@ -87,38 +92,40 @@ void Br::LoopBuilder::createLoop(M::Value lb, M::Value ub, M::Value step,
   builder.setInsertionPointToEnd(insPt);
 }
 
-void Br::LoopBuilder::createLoop(M::Value lb, M::Value ub,
-                                 const BodyGenerator &bodyGenerator) {
+void Fortran::lower::LoopBuilder::createLoop(
+    mlir::Value lb, mlir::Value ub, const BodyGenerator &bodyGenerator) {
   auto one{createIntegerConstant(getIndexType(), 1)};
   createLoop(lb, ub, one, bodyGenerator);
 }
 
-void Br::LoopBuilder::createLoop(M::Value count,
-                                 const BodyGenerator &bodyGenerator) {
+void Fortran::lower::LoopBuilder::createLoop(
+    mlir::Value count, const BodyGenerator &bodyGenerator) {
   auto indexType{getIndexType()};
   auto zero{createIntegerConstant(indexType, 0)};
   auto one{createIntegerConstant(indexType, 1)};
   createLoop(zero, count, one, bodyGenerator);
 }
 
-M::Type Br::LoopBuilder::getIndexType() {
-  return M::IndexType::get(builder.getContext());
+mlir::Type Fortran::lower::LoopBuilder::getIndexType() {
+  return mlir::IndexType::get(builder.getContext());
 }
 
-M::Value Br::LoopBuilder::convertToIndexType(M::Value integer) {
+mlir::Value
+Fortran::lower::LoopBuilder::convertToIndexType(mlir::Value integer) {
   auto type{integer.getType()};
-  if (type.isa<M::IndexType>()) {
+  if (type.isa<mlir::IndexType>()) {
     return integer;
   }
-  assert((type.isa<M::IntegerType>() || type.isa<fir::IntType>()) &&
+  assert((type.isa<mlir::IntegerType>() || type.isa<fir::IntType>()) &&
          "expected integer");
   return create<fir::ConvertOp>(getIndexType(), integer);
 }
 
 // CharacterOpsBuilder implementation
 
-void Br::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
-                                         M::Value count) {
+void Fortran::lower::CharacterOpsBuilder::createCopy(CharValue &dest,
+                                                     CharValue &src,
+                                                     mlir::Value count) {
   auto refType{dest.getReferenceType()};
   // Cast to character sequence reference type for fir::CoordinateOp.
   auto sequenceType{getSequenceRefType(refType)};
@@ -126,7 +133,7 @@ void Br::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
   auto srcRef{create<fir::ConvertOp>(sequenceType, src.reference)};
 
   LoopBuilder{*this}.createLoop(count, [&](OpBuilderWrapper &handler,
-                                           M::Value index) {
+                                           mlir::Value index) {
     auto destAddr{handler.create<fir::CoordinateOp>(refType, destRef, index)};
     auto srcAddr{handler.create<fir::CoordinateOp>(refType, srcRef, index)};
     auto val{handler.create<fir::LoadOp>(srcAddr)};
@@ -134,40 +141,45 @@ void Br::CharacterOpsBuilder::createCopy(CharValue &dest, CharValue &src,
   });
 }
 
-void Br::CharacterOpsBuilder::createPadding(CharValue &str, M::Value lower,
-                                            M::Value upper) {
+void Fortran::lower::CharacterOpsBuilder::createPadding(CharValue &str,
+                                                        mlir::Value lower,
+                                                        mlir::Value upper) {
   auto refType{str.getReferenceType()};
   auto sequenceType{getSequenceRefType(refType)};
   auto strRef{create<fir::ConvertOp>(sequenceType, str.reference)};
   auto blank{createBlankConstant(str.getCharacterType())};
 
   LoopBuilder{*this}.createLoop(
-      lower, upper, [&](OpBuilderWrapper &handler, M::Value index) {
+      lower, upper, [&](OpBuilderWrapper &handler, mlir::Value index) {
         auto strAddr{handler.create<fir::CoordinateOp>(refType, strRef, index)};
         handler.create<fir::StoreOp>(blank, strAddr);
       });
 }
 
-M::Value Br::CharacterOpsBuilder::createBlankConstant(fir::CharacterType type) {
-  auto byteTy{M::IntegerType::get(8, builder.getContext())};
+mlir::Value Fortran::lower::CharacterOpsBuilder::createBlankConstant(
+    fir::CharacterType type) {
+  auto byteTy{mlir::IntegerType::get(8, builder.getContext())};
   auto asciiSpace{createIntegerConstant(byteTy, 0x20)};
   return create<fir::ConvertOp>(type, asciiSpace);
 }
 
-Br::CharacterOpsBuilder::CharValue
-Br::CharacterOpsBuilder::createTemp(fir::CharacterType type, M::Value len) {
+Fortran::lower::CharacterOpsBuilder::CharValue
+Fortran::lower::CharacterOpsBuilder::createTemp(fir::CharacterType type,
+                                                mlir::Value len) {
   // FIXME Does this need to be emitted somewhere safe ?
   // convert-expr.cc generates alloca at the beginning of the mlir block.
   return CharValue{create<fir::AllocaOp>(type, len), len};
 }
 
-fir::ReferenceType Br::CharacterOpsBuilder::CharValue::getReferenceType() {
+fir::ReferenceType
+Fortran::lower::CharacterOpsBuilder::CharValue::getReferenceType() {
   auto type{reference.getType().dyn_cast<fir::ReferenceType>()};
   assert(type && "expected reference type");
   return type;
 }
 
-fir::CharacterType Br::CharacterOpsBuilder::CharValue::getCharacterType() {
+fir::CharacterType
+Fortran::lower::CharacterOpsBuilder::CharValue::getCharacterType() {
   auto type{getReferenceType().getEleTy().dyn_cast<fir::CharacterType>()};
   assert(type && "expected character type");
   return type;
@@ -175,73 +187,83 @@ fir::CharacterType Br::CharacterOpsBuilder::CharValue::getCharacterType() {
 
 // ComplexOpsBuilder implementation
 
-M::Type Br::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
+mlir::Type
+Fortran::lower::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
   return convertReal(builder.getContext(), complexKind);
 }
-M::Type Br::ComplexOpsBuilder::getComplexPartType(M::Type complexType) {
+mlir::Type
+Fortran::lower::ComplexOpsBuilder::getComplexPartType(mlir::Type complexType) {
   return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
 }
-M::Type Br::ComplexOpsBuilder::getComplexPartType(M::Value cplx) {
+mlir::Type
+Fortran::lower::ComplexOpsBuilder::getComplexPartType(mlir::Value cplx) {
   assert(cplx != nullptr);
   return getComplexPartType(cplx.getType());
 }
 
-M::Value Br::ComplexOpsBuilder::createComplex(fir::KindTy kind, M::Value real,
-                                              M::Value imag) {
-  M::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
-  M::Value und{create<fir::UndefOp>(complexTy)};
+mlir::Value Fortran::lower::ComplexOpsBuilder::createComplex(fir::KindTy kind,
+                                                             mlir::Value real,
+                                                             mlir::Value imag) {
+  mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
+  mlir::Value und{create<fir::UndefOp>(complexTy)};
   return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
 }
 
-using CplxPart = Br::ComplexOpsBuilder::Part;
+using CplxPart = Fortran::lower::ComplexOpsBuilder::Part;
 template <CplxPart partId>
-M::Value Br::ComplexOpsBuilder::createPartId() {
-  auto type{M::IntegerType::get(32, builder.getContext())};
+mlir::Value Fortran::lower::ComplexOpsBuilder::createPartId() {
+  auto type{mlir::IntegerType::get(32, builder.getContext())};
   return createIntegerConstant(type, static_cast<int>(partId));
 }
 
 template <CplxPart partId>
-M::Value Br::ComplexOpsBuilder::extract(M::Value cplx) {
+mlir::Value Fortran::lower::ComplexOpsBuilder::extract(mlir::Value cplx) {
   return create<fir::ExtractValueOp>(getComplexPartType(cplx), cplx,
                                      createPartId<partId>());
 }
-template M::Value Br::ComplexOpsBuilder::extract<CplxPart::Real>(M::Value);
-template M::Value Br::ComplexOpsBuilder::extract<CplxPart::Imag>(M::Value);
+template mlir::Value
+    Fortran::lower::ComplexOpsBuilder::extract<CplxPart::Real>(mlir::Value);
+template mlir::Value
+    Fortran::lower::ComplexOpsBuilder::extract<CplxPart::Imag>(mlir::Value);
 
 template <CplxPart partId>
-M::Value Br::ComplexOpsBuilder::insert(M::Value cplx, M::Value part) {
+mlir::Value Fortran::lower::ComplexOpsBuilder::insert(mlir::Value cplx,
+                                                      mlir::Value part) {
   assert(cplx != nullptr);
   return create<fir::InsertValueOp>(cplx.getType(), cplx, part,
                                     createPartId<partId>());
 }
-template M::Value Br::ComplexOpsBuilder::insert<CplxPart::Real>(M::Value,
-                                                                M::Value);
-template M::Value Br::ComplexOpsBuilder::insert<CplxPart::Imag>(M::Value,
-                                                                M::Value);
-
-M::Value Br::ComplexOpsBuilder::extractComplexPart(M::Value cplx,
-                                                   bool isImagPart) {
+template mlir::Value
+    Fortran::lower::ComplexOpsBuilder::insert<CplxPart::Real>(mlir::Value,
+                                                              mlir::Value);
+template mlir::Value
+    Fortran::lower::ComplexOpsBuilder::insert<CplxPart::Imag>(mlir::Value,
+                                                              mlir::Value);
+
+mlir::Value
+Fortran::lower::ComplexOpsBuilder::extractComplexPart(mlir::Value cplx,
+                                                      bool isImagPart) {
   return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
 }
 
-M::Value Br::ComplexOpsBuilder::insertComplexPart(M::Value cplx, M::Value part,
-                                                  bool isImagPart) {
+mlir::Value Fortran::lower::ComplexOpsBuilder::insertComplexPart(
+    mlir::Value cplx, mlir::Value part, bool isImagPart) {
   return isImagPart ? insert<Part::Imag>(cplx, part)
                     : insert<Part::Real>(cplx, part);
 }
 
-M::Value Br::ComplexOpsBuilder::createComplexCompare(M::Value cplx1,
-                                                     M::Value cplx2, bool eq) {
-  M::Value real1{extract<Part::Real>(cplx1)};
-  M::Value real2{extract<Part::Real>(cplx2)};
-  M::Value imag1{extract<Part::Imag>(cplx1)};
-  M::Value imag2{extract<Part::Imag>(cplx2)};
+mlir::Value Fortran::lower::ComplexOpsBuilder::createComplexCompare(
+    mlir::Value cplx1, mlir::Value cplx2, bool eq) {
+  mlir::Value real1{extract<Part::Real>(cplx1)};
+  mlir::Value real2{extract<Part::Real>(cplx2)};
+  mlir::Value imag1{extract<Part::Imag>(cplx1)};
+  mlir::Value imag2{extract<Part::Imag>(cplx2)};
 
-  M::CmpFPredicate predicate{eq ? M::CmpFPredicate::UEQ
-                                : M::CmpFPredicate::UNE};
-  M::Value realCmp{create<M::CmpFOp>(predicate, real1, real2)};
-  M::Value imagCmp{create<M::CmpFOp>(predicate, imag1, imag2)};
+  mlir::CmpFPredicate predicate{eq ? mlir::CmpFPredicate::UEQ
+                                   : mlir::CmpFPredicate::UNE};
+  mlir::Value realCmp{create<mlir::CmpFOp>(predicate, real1, real2)};
+  mlir::Value imagCmp{create<mlir::CmpFOp>(predicate, imag1, imag2)};
 
-  return eq ? create<M::AndOp>(realCmp, imagCmp).getResult()
-            : create<M::OrOp>(realCmp, imagCmp).getResult();
+  return eq ? create<mlir::AndOp>(realCmp, imagCmp).getResult()
+            : create<mlir::OrOp>(realCmp, imagCmp).getResult();
 }
diff --git a/lib/lower/RTBuilder.h b/lib/lower/RTBuilder.h
index 870f33511b40..34d83f5001d9 100644
--- a/lib/lower/RTBuilder.h
+++ b/lib/lower/RTBuilder.h
@@ -199,8 +199,8 @@ struct RuntimeTableEntry<RuntimeTableKey<KT>, RuntimeIdentifier<Cs...>> {
 #define QuoteKey(X) #X##_rt_ident
 #define ExpandKey(X) QuoteKey(X)
 #define mkKey(X)                                                               \
-  Br::RuntimeTableEntry<Br::RuntimeTableKey<decltype(X)>,                      \
-                        decltype(ExpandKey(X))>
+  Fortran::lower::RuntimeTableEntry<                                           \
+      Fortran::lower::RuntimeTableKey<decltype(X)>, decltype(ExpandKey(X))>
 
 } // namespace Fortran::lower
 
diff --git a/lib/lower/Runtime.cpp b/lib/lower/Runtime.cpp
index 2acb5f9685f7..c8884effef72 100644
--- a/lib/lower/Runtime.cpp
+++ b/lib/lower/Runtime.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/lower/Runtime.h"
-#include "NSAliases.h"
 #include "flang/lower/OpBuilder.h"
 #include "flang/optimizer/Dialect/FIRType.h"
 #include "mlir/IR/StandardTypes.h"
@@ -17,50 +16,51 @@
 
 namespace Fortran::lower {
 
-M::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
-                                              M::MLIRContext *context) {
+mlir::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
+                                                 mlir::MLIRContext *context) {
   switch (t) {
   case TypeCode::i32:
-    return M::IntegerType::get(32, context);
+    return mlir::IntegerType::get(32, context);
   case TypeCode::i64:
-    return M::IntegerType::get(64, context);
+    return mlir::IntegerType::get(64, context);
   case TypeCode::f32:
-    return M::FloatType::getF32(context);
+    return mlir::FloatType::getF32(context);
   case TypeCode::f64:
-    return M::FloatType::getF64(context);
+    return mlir::FloatType::getF64(context);
   // TODO need to access mapping between fe/target
   case TypeCode::c32:
     return fir::CplxType::get(context, 4);
   case TypeCode::c64:
     return fir::CplxType::get(context, 8);
   case TypeCode::boolean:
-    return M::IntegerType::get(8, context);
+    return mlir::IntegerType::get(8, context);
   case TypeCode::charPtr:
     return fir::ReferenceType::get(fir::CharacterType::get(context, 1));
   // ! IOCookie is experimental only so far
   case TypeCode::IOCookie:
-    return fir::ReferenceType::get(M::IntegerType::get(64, context));
+    return fir::ReferenceType::get(mlir::IntegerType::get(64, context));
   }
   assert(false && "bug");
   return {};
 }
 
-M::FunctionType
-RuntimeStaticDescription::getMLIRFunctionType(M::MLIRContext *context) const {
-  L::SmallVector<M::Type, 2> argMLIRTypes;
+mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
+    mlir::MLIRContext *context) const {
+  llvm::SmallVector<mlir::Type, 2> argMLIRTypes;
   for (const TypeCode &t : argumentTypeCodes) {
     argMLIRTypes.push_back(getMLIRType(t, context));
   }
   if (resultTypeCode.has_value()) {
-    M::Type resMLIRType{getMLIRType(*resultTypeCode, context)};
-    return M::FunctionType::get(argMLIRTypes, resMLIRType, context);
+    mlir::Type resMLIRType{getMLIRType(*resultTypeCode, context)};
+    return mlir::FunctionType::get(argMLIRTypes, resMLIRType, context);
   }
-  return M::FunctionType::get(argMLIRTypes, {}, context);
+  return mlir::FunctionType::get(argMLIRTypes, {}, context);
 }
 
-M::FuncOp RuntimeStaticDescription::getFuncOp(M::OpBuilder &builder) const {
-  M::ModuleOp module{getModule(&builder)};
-  M::FunctionType funTy{getMLIRFunctionType(module.getContext())};
+mlir::FuncOp
+RuntimeStaticDescription::getFuncOp(mlir::OpBuilder &builder) const {
+  mlir::ModuleOp module{getModule(&builder)};
+  mlir::FunctionType funTy{getMLIRFunctionType(module.getContext())};
   auto function{getNamedFunction(module, symbol)};
   if (!function) {
     function = createFunction(module, symbol, funTy);
@@ -98,7 +98,8 @@ static constexpr RuntimeEntryDescription runtimeTable[]{
 static constexpr StaticMultimapView<RuntimeEntryDescription> runtimeMap{
     runtimeTable};
 
-M::FuncOp genRuntimeFunction(RuntimeEntryCode code, M::OpBuilder &builder) {
+mlir::FuncOp genRuntimeFunction(RuntimeEntryCode code,
+                                mlir::OpBuilder &builder) {
   auto description{runtimeMap.find(code)};
   assert(description != runtimeMap.end());
   return description->getFuncOp(builder);
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index cb01494c6984..d75bde321012 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -49,35 +49,35 @@
 #include "llvm/Support/raw_ostream.h"
 #include <iostream>
 
-namespace Br = Fortran::lower;
-
-using namespace llvm;
-
 namespace {
 
 // Some basic command-line options
-cl::opt<std::string> inputFilename(cl::Positional, cl::Required,
-                                   cl::desc("<input file>"));
+llvm::cl::opt<std::string> inputFilename(llvm::cl::Positional,
+                                         llvm::cl::Required,
+                                         llvm::cl::desc("<input file>"));
 
-cl::opt<std::string> outputFilename("o",
-                                    cl::desc("Specify the output filename"),
-                                    cl::value_desc("filename"),
-                                    cl::init("a.mlir"));
+llvm::cl::opt<std::string>
+    outputFilename("o", llvm::cl::desc("Specify the output filename"),
+                   llvm::cl::value_desc("filename"), llvm::cl::init("a.mlir"));
 
-cl::list<std::string> includeDirs("I", cl::desc("include search paths"));
+llvm::cl::list<std::string> includeDirs("I",
+                                        llvm::cl::desc("include search paths"));
 
-cl::list<std::string> moduleDirs("module", cl::desc("module search paths"));
+llvm::cl::list<std::string> moduleDirs("module",
+                                       llvm::cl::desc("module search paths"));
 
-cl::opt<std::string> moduleSuffix("module-suffix",
-                                  cl::desc("module file suffix override"),
-                                  cl::init(".mod"));
+llvm::cl::opt<std::string>
+    moduleSuffix("module-suffix", llvm::cl::desc("module file suffix override"),
+                 llvm::cl::init(".mod"));
 
-cl::opt<bool> emitLLVM("emit-llvm",
-                       cl::desc("Add passes to lower to and emit LLVM IR"),
-                       cl::init(false));
-cl::opt<bool> emitFIR("emit-fir",
-                      cl::desc("Dump the FIR created by lowering and exit"),
-                      cl::init(false));
+llvm::cl::opt<bool>
+    emitLLVM("emit-llvm",
+             llvm::cl::desc("Add passes to lower to and emit LLVM IR"),
+             llvm::cl::init(false));
+llvm::cl::opt<bool>
+    emitFIR("emit-fir",
+            llvm::cl::desc("Dump the FIR created by lowering and exit"),
+            llvm::cl::init(false));
 
 // vestigal struct that should be deleted
 struct DriverOptions {
@@ -95,7 +95,7 @@ void convertFortranSourceToMLIR(
     std::string path, Fortran::parser::Options options, DriverOptions &driver,
     Fortran::semantics::SemanticsContext &semanticsContext) {
   if (!driver.forcedForm) {
-    auto dot{path.rfind(".")};
+    auto dot = path.rfind(".");
     if (dot != std::string::npos) {
       std::string suffix{path.substr(dot + 1)};
       options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
@@ -106,7 +106,7 @@ void convertFortranSourceToMLIR(
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
-    errs() << driver.prefix << "could not scan " << path << '\n';
+    llvm::errs() << driver.prefix << "could not scan " << path << '\n';
     parsing.messages().Emit(std::cerr, parsing.cooked());
     exitStatus = EXIT_FAILURE;
     return;
@@ -122,7 +122,7 @@ void convertFortranSourceToMLIR(
   if ((!parsing.messages().empty() &&
        (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
       !parsing.parseTree().has_value()) {
-    errs() << driver.prefix << "could not parse " << path << '\n';
+    llvm::errs() << driver.prefix << "could not parse " << path << '\n';
     exitStatus = EXIT_FAILURE;
     return;
   }
@@ -132,22 +132,22 @@ void convertFortranSourceToMLIR(
   semantics.Perform();
   semantics.EmitMessages(std::cerr);
   if (semantics.AnyFatalError()) {
-    errs() << driver.prefix << "semantic errors in " << path << '\n';
+    llvm::errs() << driver.prefix << "semantic errors in " << path << '\n';
     exitStatus = EXIT_FAILURE;
     return;
   }
 
   // MLIR+FIR
   fir::NameUniquer nameUniquer;
-  auto burnside = Br::BurnsideBridge::create(semanticsContext.defaultKinds(),
-                                             &parsing.cooked());
+  auto burnside = Fortran::lower::LoweringBridge::create(
+      semanticsContext.defaultKinds(), &parsing.cooked());
   fir::KindMapping kindMap{&burnside.getMLIRContext()};
   burnside.lower(parseTree, nameUniquer);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
-  raw_fd_ostream out(outputFilename, ec);
+  llvm::raw_fd_ostream out(outputFilename, ec);
   if (ec) {
-    errs() << "could not open output file " << outputFilename << '\n';
+    llvm::errs() << "could not open output file " << outputFilename << '\n';
     return;
   }
   if (emitFIR) {
@@ -170,7 +170,7 @@ void convertFortranSourceToMLIR(
     llvm::ToolOutputFile out(outputFilename + ".ll", ec,
                              llvm::sys::fs::OF_None);
     if (ec) {
-      errs() << "can't open output file " + outputFilename + ".ll";
+      llvm::errs() << "can't open output file " + outputFilename + ".ll";
       return;
     }
     pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
@@ -180,7 +180,7 @@ void convertFortranSourceToMLIR(
     mlirModule.print(out);
     out << '\n';
   } else {
-    errs() << "oops, pass manager reported failure\n";
+    llvm::errs() << "oops, pass manager reported failure\n";
     mlirModule.dump();
   }
 }
@@ -191,11 +191,11 @@ int main(int argc, char **argv) {
   mlir::registerAllDialects();
   fir::registerFIR();
   fir::registerFIRPasses();
-  [[maybe_unused]] InitLLVM y(argc, argv);
+  [[maybe_unused]] llvm::InitLLVM y(argc, argv);
 
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
-  cl::ParseCommandLineOptions(argc, argv, "Burnside Bridge Compiler\n");
+  llvm::cl::ParseCommandLineOptions(argc, argv, "Burnside Bridge Compiler\n");
 
   DriverOptions driver;
   driver.prefix = argv[0] + ": "s;

From 1c12527abc7e992465af5721b9d44b44c04e047d Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 25 Feb 2020 16:30:20 -0800
Subject: [PATCH 196/345] document

---
 documentation/FIRLangRef.md               | 1048 ---------------------
 include/flang/optimizer/Dialect/FIROps.td |  479 +++++++---
 2 files changed, 341 insertions(+), 1186 deletions(-)
 delete mode 100644 documentation/FIRLangRef.md

diff --git a/documentation/FIRLangRef.md b/documentation/FIRLangRef.md
deleted file mode 100644
index 759fd772b629..000000000000
--- a/documentation/FIRLangRef.md
+++ /dev/null
@@ -1,1048 +0,0 @@
-# FIR Language Reference
-
-This document describes the FIR dialect, an extension of the MLIR extensible
-IR. FIR (Fortran IR) is a higher-level compiler intermediate representation for
-Fortran compilation units used by the Flang compiler.
-
-Some familiarity with [MLIR](https://github.com/tensorflow/mlir/blob/master/g3doc/LangRef.md) and [LLVM IR](https://llvm.org/docs/LangRef.html) is encouraged.  The [LLVM tutorial](https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/index.html) may help as well.
-
-# Type System
-
-This section defines the _FIR type system_, which is related to but certainly
-not the same as Fortran's concept and definition of a type. FIR is a strongly
-typed language. FIR types subsume Fortran types and attributes that, when taken
-together, describe the operational properties applicable to a Fortran entity.
-
-Standard dialect MLIR types are available in FIR. FIR adds its own types as
-well, and this section documents the FIR dialect type system.
-
-In the most general case, the reified FIR type of a Fortran entity may not be
-known at compile-time. Specifically, the size, rank, shape, index ranges,
-strides, aggregate layout, data member sizes, and parameters of that type
-instance may all be deferred until runtime.
-
-In FIR, it is necessary to be able to abstract away much of the Fortran syntax
-and runtime specialization of an entity's properties, while maintaining the
-advantages of a strong type system. For one optimization, it may suffice to
-know that a Fortran entity has a rank. For another, it may be desirable (or
-required) for the operand entities to have a more precise reified FIR type for
-efficiency and performance.
-
-For example, for a Fortran variable with a declared type of `TYPE(*)`, it is
-possible to express this variable in FIR as the most general sort of entity
-with an unlimited polymorphic type. However, the compiler will be able to
-produce better performing (and smaller) code if it can prove and rewrite this
-value as having a FIR type of `i32`, which might be kept in a machine register,
-for example.
-
-The point here is that the FIR type system needs to allow transformations on a
-Fortran entity that express both an unlimited polymorphic type and, say like in
-the last example, a reified type as a 32-bit signed integer depending on the
-context.
-
-#### Notation
-
-* _abc-list_ is a possibly empty comma separated list of _abc_.
-* _abc-xlist_ is a non-empty 'x'-character separated list of _abc._
-* _abc-type_ is a type.
-
-## Fortran Intrinsic Types
-
-<pre><code><b>!fir.int&lt;</b><em>kind</em><b>&gt;<br>
-!fir.real&lt;</b><em>kind</em><b>&gt;<br>
-!fir.complex&lt;</b><em>kind</em><b>&gt;<br>
-!fir.logical&lt;</b><em>kind</em><b>&gt;<br>
-!fir.character&lt;</b><em>kind</em><b>&gt;</b><br>
-&nbsp;&nbsp;&nbsp; where <em>kind</em> := <em>integer-constant</em><br>
-</code></pre>
-
-Some of these types may be directly rewritten to standard dialect types. The
-intrinsic types are meant to correspond one-to-one with the front-end's
-intrinsic types. What a particular kind-value means in terms of bit-width is
-not relevant to these FIR types. However, the semantics of kind-values are
-absolutely relevant when these types are converted to a lower-level
-dialect. For example, assuming the f18 front-end definition then `!fir.int<2>`
-can be trivially rewritten to `i16`.
-
-## Fortran Derived Types
-
-<pre><code><b>!fir.type&lt;</b><em>derived-type-name [</em> <b>(</b><em>len-param-list</em><b>)</b> <em>] [</em> <b>{</b><em>field-id-list</em><b>}</b> <em>]</em> <b>&gt;</b><br>
-&nbsp;&nbsp;&nbsp; where <em>len-param</em> := <em>len-param-name</em> <b>:</b> <em>integer-type</em><br>
-&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>field-id</em> := <em>field-name</em> <b>:</b> <em>type</em><br>
-</code></pre>
-
-This is the type of a Fortran derived type. Each derived type is given a unique
-name. The data parts of the derived type are elaborated in the field list. The
-degenerate form is allowed to be able to construct recursive references. As
-these elaborated record types can become rather verbose, the intention will be
-to exploit MLIR's type alias feature to create shorter nicknames.
-
-## Modeled Types
-
-These types are not Fortran types. These modeled types capture the semantic
-properties of attributes on Fortran data entities by converting those
-attributes into the constraints of FIR's static type system.
-
-### Function Type
-
-<pre><code><b>(</b><em>argument-type-list</em><b>) -&gt; </b><em>result-type</em><br>
-</code></pre>
-
-This is the type of a Fortran procedure (function or subroutine) and is the
-same as the standard dialect. The void type is simply `()`.
-
-### Sequence Type
-
-<pre><code><b>!fir.array&lt;</b><em>extent-xlist</em> <b>:</b> <em>element-type</em><b>&gt;</b><br>
-&nbsp;&nbsp;&nbsp; where <em>extent</em> := <em>integer-constant |</em> <b>?</b> <em>|</em> <b>*</b><br>
-</code></pre>
-
-This is used to declare that the value is an array.  It may additionally
-capture the shape of the array. It maps to a Fortran column-major layout. An
-array with explicit shape can be represented with an xlist of rank length of
-integers. An unknown extent in one of the dimensions can be specified with the
-`?` character. The `*` character is used (by itself) when the shape of the
-array is not known.
-
-Examples:
-
-```mlir
-    !fir.array<10x10:i32>	; array of rank 2 and shape [10, 10]
-    !fir.array<5x?:f32>	; array of rank 2 and shape [5, unknown]
-    !fir.array<*:f64>	; array of unknown rank and shape
-```
-
-Unlike Fortran, FIR arrays have a starting index of 0 (always). This must be
-accounted for when lowering Fortran arrays. See `fir.coordinate_of` and
-`fir.embox` on how access maps can be used. (A starting index of 0 makes FIR
-array offset computation consistent with tuples, record types, etc.)
-
-### Pointer-like Types
-
-<pre><code><b>!fir.ref&lt;</b><em>ref-to-type</em><b>&gt;</b><br>
-</code></pre>
-
-This is the type of a memory reference. This is needed in a number of
-situations. For one example, dummy arguments (variables) in Fortran can refer
-to the actual argument passed from the calling procedure. Assignments to the
-dummy variable will change the value of the actual variable. This semantics can
-be reified by passing a memory reference to the actual variable to the called
-procedure. _ref-to-type_ cannot be `!fir.ref`.
-
-<pre><code><b>!fir.ptr&lt;</b><em>ptr-to-type</em><b>&gt;</b><br>
-</code></pre>
-
-This is also a memory reference type, but it is limited to Fortran's POINTER
-attribute. A variable with a POINTER attribute has a runtime defined reference
-value. This introduces aliasing (which may be important to the optimizer), and
-having a separate type allows for some refinement in alias
-analysis. _ptr-to-type_ cannot be `!fir.ptr`, `!fir.heap`, or `!fir.ref`.
-
-A value of type `!fir.ptr` can introduce aliasing (unlike `!fir.ref`).
-
-<pre><code><b>!fir.heap&lt;</b><em>heap-to-type</em><b>&gt;</b><br>
-</code></pre>
-
-This is the third memory reference type, and this one is limited to Fortran's
-ALLOCATABLE attribute. The allocation of ALLOCATABLE variables will return a
-reference of `!fir.heap` type. _heap-to-type_ cannot be `!fir.ptr`,
-`!fir.heap`, or `!fir.ref`.
-
-By having different pointer-like types, the language constraint prohibiting
-first-class pointers-to-pointers can be trivially enforced. For example, C852
-prohibits having both a POINTER and ALLOCATABLE attribute on entity. This can
-be enforced in the type system by disallowing the construction of
-`!fir.ptr<!fir.heap<T>>` and `!fir.heap<!fir.ptr<T>>` types.
-
-### Descriptor Types
-
-<pre><code><b>!fir.box&lt;</b><em>of-type</em><b>&gt;</b><br>
-</code></pre>
-
-The type of the most general object in Fortran. A boxed value can be a scalar
-or an array. A boxed value has a memory reference (to the value's data), a
-reified type value, optional type parameters, and optional array dimension
-information (if it's an array box). A value of box type can return dynamic
-values such as the rank of the object, the size of an element, or the size of
-the object.
-
-<pre><code><b>!fir.boxchar&lt;</b><em>kind</em><b>&gt;</b><br>
-</code></pre>
-
-A Fortran CHARACTER type can be a pair of values, the buffer of characters
-along with a runtime LEN value. This is the abstract type of the pair that
-describes a CHARACTER value.
-
-<pre><code><b>!fir.boxproc&lt;</b><em>function-type</em><b>&gt;</b><br>
-</code></pre>
-
-A Fortran procedure POINTER may be to an internal procedure. An internal
-procedure may require a runtime host instance value. This is the abstract type
-of a procedure pointer, including a procedure pointer with a host instance
-value.
-
-### Other Types
-
-<pre><code><b>!fir.dims&lt;</b><em>rank</em><b>&gt;</b><br>
-</code></pre>
-
-This is the type of a vector of array dimension triples. A boxed array object
-takes a vector of dimension triples to properly instantiate the box value.
-
-<pre><code><b>!fir.field</b><br>
-</code></pre>
-
-This is the type of a part reference via a field name. A field value can be
-constructed to provide an abstract value to refer to members of a value of type
-`!fir.type`. In the most general case, the layout of a parametric derived type
-may not be known until runtime and the offset of a particular field must be
-computed.
-
-<pre><code><b>!fir.tdesc&lt;</b><em>of-type</em><b>&gt;</b><br>
-</code></pre>
-
-A Fortran type has a meta-type known as a type descriptor. This is the type of
-these meta-types. A boxed value carries a `!fir.tdesc` value to identify the
-type of that instance.
-
-
-# Modules, Functions, and Basic Blocks
-
-For organizing a Fortran compilation unit, FIR uses the MLIR infrastructure for
-modules, functions, regions, and basic blocks.  These concepts are explained in
-the MLIR Language Reference.
-
-
-# Operations
-
-This section defines the _FIR operations_.  MLIR operations are a generalized
-abstraction meant to allow a dialect, like FIR, to add its own constructs with
-their own semantics.  FIR operations are meant to capture the operations and
-structures from the Fortran language for presentation to optimization passes.
-
-Some FIR operations capture execution semantics and are intended to be placed
-in Blocks. Other operations are Module level abstractions and intended to be
-referenced by name.
-
-## Executable Operations
-
-### SSA Memory Related Ops
-
-#### `fir.alloca`
-
-Syntax:	<code><b>fir.alloca</b> <em>T [</em> <b>,</b> <em>size-list ]</em> <b>: !fir.ref&lt;</b><em>T</em><b>&gt;</b></code>
-
-Allocate uninitialized space on the stack for a variable of type _T_.  If
-allocating an array of _T_, then a size-list of ssa-values sufficient rank must
-be provided to compute the array's shape.
-
-Example:
-
-```mlir
-    %11 = fir.alloca i32 : !fir.ref<i32>
-    %12 = fir.alloca !fir.array<8:i64> : !fir.ref<!fir.array<8:i64>>
-    %13 = fir.alloca f32, %5 : !fir.ref<f32>
-```
-
-Note that in the case of `%13`, a contiguous block of memory is allocated and
-its size is some runtime multiple of a 32-bit REAL value. Furthermore, the
-operation is undefined if the ssa-value `%5` is nonpositive.
-
-
-#### `fir.load`
-
-Syntax:	<code><b>fir.load</b> <em>memory-reference</em> <b>:</b> <em>reference-type</em></code>
-
-Loads a value from a memory reference. A memory reference has type
-`!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
-
-Example:
-
-```mlir
-    %14 = fir.alloca i32 : !fir.ref<i32>
-    %15 = fir.load %14 : !fir.ref<i32>
-```
-
-#### `fir.store`
-
-Syntax:	<code><b>fir.store</b> <em>ssa-value</em> <b>to</b> <em>memory-reference</em> <b>:</b> <em>reference-type</em></code>
-
-Store a value to a memory reference.
-
-Example:
-
-```mlir
-    %16 = fir.call @foo() : f64
-    %17 = fir.call @bar() : !fir.ptr<f64>
-    fir.store %16 to %17 : !fir.ptr<f64>
-```
-
-The above store changes the value to which the pointer is pointing and not
-the pointer itself.
-
-
-#### `fir.undefined`
-
-Syntax:	<code><b>fir.undefined</b> <em>T</em></code>
-
-An undefined value. This is a constant that can be used to represent an
-undefined _ssa-value_ of any type except
-<code>!fir.ref&lt;<em>U</em>&gt;</code>.
-
-Example:
-
-```mlir
-    %18 = fir.undefined !fir.array<10:!fir.type<T{...}>>
-```
-
-### Heap Memory Ops
-
-#### `fir.allocmem`
-
-Syntax:	<code><b>fir.allocmem</b> <em>T [</em> <b>,</b> <em>size-list ]</em> <b>: !fir.heap&lt;</b><em>T</em><b>&gt;</b></code>
-
-Allocate contiguous memory on the heap. It is expected that a properly
-constructed FIR program properly pairs `fir.allocmem` and `fir.freemem`
-operations.
-
-
-Example:
-
-```mlir
-    %20 = fir.allocmem !fir.type<Z(p:i32){field:i32}> : !fir.heap<!fir.type<Z(p:i32){field:i32}>>
-```
-
-#### `fir.freemem`
-
-
-Syntax:	<code><b>fir.freemem</b> <em>heap-value</em> <b>: !fir.heap&lt;</b><em>T</em><b>&gt;</b></code>
-
-Deallocate a previously allocated block of memory returned from
-`fir.allocmem`.
-
-Example:
-
-```mlir
-    %21 = fir.allocmem !fir.type<Z(p:i32){field:i32}> : !fir.heap<!fir.type<"Z"(p:i32){field:i32}>>
-    ...
-    fir.freemem %21 : !fir.heap<!fir.type<"Z"(p:i32){field:i32}>>
-```
-
-
-### Terminators
-
-#### `fir.select`
-
-
-Syntax:
-<pre><code><b>fir.select</b> <em>selector</em> <b>:</b> <em>selector-type</em> <b>[</b> <em>value-target-list</em> <b>]</b><br>
-&nbsp;&nbsp;&nbsp; where <em>value-target</em> := <em>select-const</em> <b>,</b> <em>block block-arg-list</em><br>
-&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>select-const</em> := <em>integer-const |</em> <b>unit</b><br>
-&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>block-arg-list</em> := <em>[</em> <b>(</b> <em>value-type-list</em> <b>)</b> <em>]</em>
-</code></pre>
-
-A terminator for a simple switch like control flow.
-
-Example:
-
-    fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
-
-
-#### `fir.select_case`
-
-Syntax:
-<pre><code><b>fir.select_case</b> <em>selector</em> <b>:</b> <em>selector-type</em> <b>[</b> <em>case-target-list</em> <b>]</b><br>
-&nbsp;&nbsp;&nbsp; where <em>case-target-list</em> := <em>case-attr</em> <b>,</b> <em>case-attr-values</em> <b>,</b> <em>block block-arg-list</em><br>
-&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>case-attr</em> := <b>unit</b> <em>|</em> <b>#fir.point</b> <em>|</em> <b>#fir.interval</b> <em>|</em> <b>#fir.lower</b> <em>|</em> <b>#fir.upper</b><br>
-&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>case-attr-values</em> := <em>[ ssa-value [</em> <b>,</b> <em>ssa-value ] ]</em>
-</code></pre>
-
-A terminator for the SELECT CASE construct.
-
-Example:
-
-    fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
-
-#### `fir.select_rank`
-
-Syntax:	<code><b>fir.select_rank</b> <em>selector</em> <b>:</b> <em>selector-type</em> <b>[</b> <em>value-target-list</em> <b>]</b></code>
-
-A terminator for the SELECT RANK construct.
-
-Example:
-
-    fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
-
-
-#### `fir.select_type`
-
-Syntax:
-<pre><code><b>fir.select_type</b> <em>selector</em> <b>[</b> <em>type-target-list</em> <b>]</b></code><br>
-&nbsp;&nbsp;&nbsp; where <em>type-target-list</em> := <em>type-attr</em> <b>,</b> <em>block block-arg-list</em>
-&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <em>case-attr</em> := <b>unit</b> <em>|</em> <b>#fir.instance&lt;</b><em>type</em><b>&gt;</b> <em>|</em> <b>#fir.subsumed&lt;</b><em>type</em><b>&gt;</b>
-</code></pre>
-
-A terminator for the SELECT TYPE construct.
-
-Example:
-
-    fir.select_type %arg : !fir.box<()> [ #fir.instance<!fir.type<type1{f1:i32,f2:i64,f3:i1}>>,^bb1(%0:i32), #fir.instance<!fir.type<type2{...}>>,^bb2(%2:i32), #fir.subsumed<!fir.type<type3{...}>>,^bb3(%2:i32), #fir.instance<!fir.type<type4{...}>>,^bb4(%1:i32), unit,^bb5 ]
-
-#### `fir.unreachable`
-
-Syntax:	`fir.unreachable`
-
-A terminator that should never be reached by the executing program.  This
-terminator is translated to LLVM's `unreachable` instruction.
-
-
-### Ops for Boxed Values
-
-
-#### Packing Boxed Values
-
-
-#### `fir.embox`
-
-
-Syntax:
-<pre><code><b>fir.embox</b> <em>mem-ref [</em> <b>,</b> <em>access-map ]</em> <b>: (</b> <em>arg-type-list</em> <b>) -&gt; !fir.box&lt;</b><em>T</em><b>&gt;</b><br>
-&nbsp;&nbsp;&nbsp; where <em>access-map</em> := <em>dims | affine-map</em>
-</code></pre>
-
-Creation of a boxed value.  A boxed value is a memory reference value that
-is wrapped with a Fortran descriptor.  References to scalars, arrays,
-pointers, allocatables, etc. can be boxed.
-
-Example:
-
-```mlir
-    %34 = fir.dims(%c1, %c10, %c1) : (i32, i32, i32) -> !fir.dims<1>
-    %35 = fir.call @foo() : () -> !fir.ref<!fir.array<10:i32>>
-    %36 = fir.embox %35, %34 : (!fir.ref<!fir.array<10:i32>>, !fir.dims<1>) -> !fir.box<!fir.array<10:i32>>
-```
-
-#### `fir.emboxchar`
-
-Syntax:	<code><b>fir.emboxchar</b> <em>buffer-ref</em> <b>,</b> <em>len-value</em> <b>: (</b> <em>arg-type-list</em> <b>) -&gt; !fir.boxchar&lt;</b><em>kind</em><b>&gt;</b></code>
-
-Creation of a boxed CHARACTER pair.  A variable of type CHARACTER has a
-dependent LEN type parameter that is the size of the buffer holding the
-CHARACTER value.
-
-Example:
-
-```mlir
-    %c20 = constant 20 : i32
-    %37 = fir.call @foo() : !fir.ref<!fir.character<1>>
-    %38 = fir.emboxchar %37, %c20 : !fir.boxchar<1>
-```
-
-#### `fir.emboxproc`
-
-
-Syntax:	<code><b>fir.emboxproc</b> <em>callee [</em> <b>,</b> <em>context ]</em> <b>: (</b> <em>arg-type-list</em> <b>) -&gt; !fir.boxproc&lt;(</b><em>T</em><b>) -&gt;</b> <em>U</em><b>&gt;</b></code>
-
-Creation of a boxed procedure reference.
-
-Example:
-
-```mlir
-    %39 = fir.emboxproc @proc_xyz
-```
-
-#### Unpacking Boxed Values
-
-
-#### `fir.unbox`
-
-
-Syntax:	<code><b>fir.unbox</b> <em>box-value</em> <b>: (</b> <em>arg-type</em> <b>) -&gt; (</b>!fir.ref&lt;<em>Tx</em><b>&gt;, i</b><em>v</em><b>, i</b><em>w</em><b>, !fir.tdesc&lt;</b><em>Tx</em><b>&gt;, i</b><em>y</em><b>, !fir.dims&lt;</b><em>z</em><b>&gt;)</b></code>
-
-Unbox a boxed value into a result of multiple values from the box's
-component data.  The values are, minimally, a reference to the data of the
-entity, the byte-size of one element, the rank, the type descriptor, a set
-of flags (packed in an integer, and an array of dimension information (of
-size rank).
-
-Example:
-
-```mlir
-    %40 = fir.call @foo() : !fir.box<!fir.type<"T"{field:i32}>>
-    %41 = fir.unbox %40 : (!fir.box<!fir.type<"T"{field:i32}>>) -> (!fir.ref<!fir.type<"T"{field:i32}>>, i32, i32, !fir.tdesc<!fir.type<"T"{field:i32}>>, i32, !fir.dims<4>)
-```
-
-Note: the exact type and content of the returned multiple value is still to
-be determined and may change.
-
-#### `fir.unboxchar`
-
-Syntax:	<code><b>fir.unboxchar</b> <em>boxchar-value</em> <b>: (</b> <em>boxchar-type</em> <b>) -&gt; (</b> <em>reference</em> <b>,</b> <em>len</em> <b>)</b></code>
-
-Unbox a boxed CHARACTER pair.
-
-Example:
-
-```mlir
-    %45 = fir.call @foo() : !fir.boxchar<1>
-    %46 = fir.unboxchar %45 : (!fir.boxchar<1>) -> (!fir.ref<!fir.character<1>>, i32)
-```
-
-#### `fir.unboxproc`
-
-
-Syntax:	<code><b>fir.unboxproc</b> <em>boxproc-value</em> <b>: (</b> <em>boxproc-type</em> <b>) -> (</b> <em>callee</em> <b>,</b> <em>context</em> <b>)</b></code>
-
-Unbox a boxed procedure reference.
-
-
-Example:
-
-```mlir
-    %47 = fir.call @foo() : () -> !fir.boxproc<() -> i32>
-    %48 = fir.unboxproc %47 : (!fir.ref<() -> i32>, !fir.ref<(f32, i32)>)
-```
-
-#### Queries on Boxed Values
-
-#### `fir.box_addr`
-
-
-Syntax:	<code><b>fir.box_addr</b> <em>boxable</em> <b>: (</b> <em>box-type</em> <b>) -&gt; !fir.ref&lt;</b><em>T</em><b>&gt;</b></code>
-
-
-Return the referenced entity from the boxed value. The boxable value must
-have a type of <code>!fir.box&lt;<em>T</em>&gt;</code>,
-<code>!fir.boxchar&lt;<em>C</em>&gt;</code>, or
-<code>!fir.boxproc&lt;<em>FT</em>&gt;</code>.
-
-
-Example:
-
-```mlir
-    %51 = fir.box_addr %boxvec : (!fir.box<!fir.array<?:f64>>) -> !fir.ref<!fir.array<?:f64>>
-```
-
-#### `fir.box_dims`
-
-
-Syntax:	<code><b>fir.box_dims</b> <em>box-value</em> <b>,</b> <em>dim</em> <b>: (</b> <em>box-type</em> <b>) -&gt; (i</b><em>n</em><b>, i</b><em>n</em><b>, i</b><em>n</em><b>)</b></code>
-
-
-Return the dimension vector for the boxed value, _box-value_, at dimension,
-_dim_. The returned value is the triple of lower bound, extent, and stride,
-respectively.  If _dim_ is larger than the rank of the boxed value, this
-operation has undefined behavior.
-
-
-Example:
-
-```mlir
-    %c1 = constant 1 : i32
-    %52 = fir.box_dims %40, %c1 : (!fir.box<!fir.array<*:f64>>, i32) -> (i32, i32, i32)
-```
-
-#### `fir.box_elesize`
-
-
-Syntax:	<code><b>fir.box_elesize</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i</b><em>n</em></code>
-
-
-Return the size of an element for the boxed value. The returned value may
-not be constant and only known at runtime.
-
-
-Example:
-
-```mlir
-    %53 = fir.box_elesize %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i32
-```
-
-#### `fir.box_isalloc`
-
-
-Syntax:	<code><b>fir.box_isalloc</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i1</b></code>
-
-
-Return true if the boxed value is an ALLOCATABLE. This will return true if
-the originating _box-value_ was from a `fir.embox` with a _mem-ref_ value
-that had the type <code>!fir.ref&lt;!fir.heap&lt;<em>T</em>&gt;&gt;</code>.
-
-
-Example:
-
-```mlir
-    %54 = fir.box_isalloc %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i1
-```
-
-#### `fir.box_isarray`
-
-Syntax:	<code><b>fir.box_isarray</b> <em>box-value</em> <b>:  (</b> <em>box-type</em> <b>) -&gt; i1</b></code>
-
-
-Return true if the boxed value has a rank greater than 0. This will return
-true if the originating _box-value_ was from a `fir.embox` with a _mem-ref_
-value that had the type <code>!fir.ref<!fir.array<<em>T</em>>></code> and a
-<em>dims</em> argument.
-
-
-Example:
-
-```mlir
-    %55 = fir.box_isarray %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i1
-```
-
-#### `fir.box_isptr`
-
-
-Syntax:	<code><b>fir.box_isptr</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i1</b></code>
-
-Return true if the boxed value is a POINTER. This will return true if the
-originating _box-value_ was from a `fir.embox` with a _mem-ref_ value that
-had the type <code>!fir.ref&lt;!fir.ptr&lt;<em>T</em>&gt;&gt;</code>.
-
-Example:
-
-```mlir
-    %56 = fir.box_isptr %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i1
-```
-
-#### `fir.box_rank`
-
-Syntax:	<code><b>fir.box_rank</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; i</b><em>n</em></code>
-
-Return the rank of the boxed value. The rank of a scalar is 0.
-
-Example:
-
-```mlir
-    %57 = fir.box_rank %40 : (!fir.box<!fir.array<*:f64>>, i32) -> i32
-```
-
-#### `fir.box_tdesc`
-
-Syntax:	<code><b>fir.box_tdesc</b> <em>box-value</em> <b>: (</b> <em>box-type</em> <b>) -&gt; !fir.tdesc&lt;</b> <em>ele-type</em> <b>&gt;</b></code>
-
-Return the type descriptor of the boxed value.
-
-Example:
-
-```mlir
-    %58 = fir.box_tdesc %40 : (!fir.box<!fir.array<*:f64>>) -> !fir.tdesc<!fir.array<*:f64>>
-```
-
-#### `fir.boxchar_len`
-
-Syntax:	<code><b>fir.boxchar_len</b> <em>boxchar-value</em> <b>: (!fir.boxchar&lt;1&gt;) -&gt; i</b><em>n</em></code>
-
-Return the LEN type parameter of a boxchar value.
-
-Example:
-
-```mlir
-    %59 = fir.boxchar_len %45 : (!fir.boxchar<1>) -> i32
-```
-
-#### `fir.boxproc_host`
-
-
-Syntax:	<code><b>fir.boxproc_host</b> <em>boxproc-value</em> <b>: (</b> <em>boxproc-type</em> <b>) -&gt; </b><em>host-context</em></code>
-
-
-Return the host context of a boxproc value, if any.
-
-
-Example:
-
-```mlir
-    %60 = fir.boxproc_host %47 : (!fir.boxproc<() -> none>) -> (() -> none, !fir.ref<(f32, i64)>)
-```
-
-The content and type of _host-context_ is to be determined.
-
-
-### Ops for Derived Types and Arrays
-
-#### `fir.coordinate_of`
-
-Syntax:	<code><b>fir.coordinate_of</b> <em>box-or-ref-value</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>reference-like-type</em> <b>) -&gt; !fir.ref&lt;</b><em>T</em><b>&gt;</b></code>
-
-Compute the internal coordinate address starting from a boxed value or unboxed
-memory reference. Returns a memory reference. When computing the coordinate of
-an array element, the rank of the array must be known and the number of
-indexing expressions must equal the rank of the array.
-
-This operation will apply the access map from a boxed value implicitly.
-
-Unlike LLVM's GEP instruction, one cannot stride over the outermost reference;
-therefore, the leading 0 index must be omitted.
-
-Example:
-
-```mlir
-    %57 = fir.call @foo() : () -> !fir.heap<!fir.array<?:f32>>
-    %58 = fir.coordinate_of %57, %56 : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
-```
-
-#### `fir.extract_value`
-
-Syntax:	<code><b>fir.extract_value</b> <em>entity</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>entity-type</em> <b>,</b> <em>index-type</em> <b>) -&gt;</b> <em>subobject-type</em></code>
-
-Extract a value from an entity with a type composed of tuples, arrays, and/or
-derived types. Returns the value from _entity_ with the type of the
-specified component. Cannot be used on values of `!fir.box` type.
-
-Note that the <em>entity</em> ssa-value must be of compile-time known size
-in order to use this operation.
-
-Example:
-
-```mlir
-    %59 = fir.field_index("field") : !fir.field
-    %60 = fir.call @foo3() : () -> !fir.type<X{field:i32}>
-    %61 = fir.extract_value %60, %59 : (!fir.type<X{field:i32}>, !fir.field) -> i32
-```
-
-#### `fir.insert_value`
-
-Syntax:	<code><b>fir.insert_value</b> <em>entity</em> <b>,</b> <em>value</em> <b>,</b> <em>index-field-list</em> <b>: (</b> <em>entity-type</em> <b>,</b> <em>value-type</em> <b>,</b> <em>index-field-type-list</em> <b>) -&gt;</b> <em>entity-type</em></code>
-
-Insert a value into an entity with a type composed of tuples, arrays, and/or
-derived types. Returns a new value of the same type as _entity_.  It cannot be
-used on values of `!fir.box` type.
-
-Note that the <em>entity</em> ssa-value must be of compile-time known size
-in order to use this operation.
-
-Example:
-
-```mlir
-    %64 = fir.field_index("field") : !fir.field
-    %65 = fir.call @foo2() : () -> i32
-    %66 = fir.call @foo3() : () -> !fir.type<X{field:i32}>
-    %67 = fir.insert_value(%66, %65, %64) : (!fir.type<X{field:i32}>, i32, !fir.field) -> !fir.type<X{field:i32}>
-```
-
-The above is one possible translation of the following Fortran code sequence.
-
-```Fortran
-    temp1 = foo2()
-    temp2 = foo3()
-    temp2%field = temp1
-```
-
-
-#### `fir.field_index`
-
-Syntax:	<code><b>fir.field_index ("</b><em>field-name</em><b>") : !fir.field</b></code>
-
-Compute the field offset of a particular named field in a derived
-type. Note: it is possible in Fortran to write code that can only determine
-the exact offset of a particular field in a parameterized derived type at
-runtime.
-
-Example:
-
-```mlir
-    %62 = fir.field_index ("member_1") : !fir.field
-```
-
-#### `fir.len_param_index`
-
-Syntax:	<code><b>fir.len_param_index ("</b><em>len-param-name</em><b>") : !fir.field</b></code>
-
-Compute the LEN type parameter offset of a particular named parameter in a
-derived type.
-
-Example:
-
-```mlir
-    %62 = fir.len_param_index("param_1") : !fir.field
-```
-
-#### `fir.gendims`
-
-Syntax:	<code><b>fir.gendims</b> <em>triple-list</em> <b>: (</b> <em>type-list</em> <b>) -&gt; !fir.dims&lt;</b><em>R</em><b>&gt;</b></code>
-
-
-Generate dimension information. This is needed to embox array entities. A
-triple corresponds to the definition of Fortran's array slice operator.
-Specifically, the components are `(first, last, stride)`.
-
-(These values will be lowered appropriately for the target runtime, which may
-encode the triple as a `CFI_dim_t`, for example.)
-
-Example:
-
-```mlir
-    %c1 = constant 1 : i32
-    %c10 = constant 10 : i32
-    %63 = fir.gendims %c1,%c10,%c1 : (i32,i32,i32) -> !fir.dims<1>
-```
-
-### Generalized Control Flow Ops
-
-
-#### `fir.loop`
-
-Syntax:
-<pre><code><b>fir.loop</b> <em>ssa-id</em> <b>=</b> <em>lower-bound</em> <b>to</b> <em>upper-bound [</em> <b>step</b> <em>step-value ] [</em> <b>unordered</b> <em>]</em> <b>{</b><br>
-&nbsp;&nbsp;&nbsp; <em>op-list</em><br>
-<b>}</b>
-</code></pre>
-
-Generalized high-level looping construct. This operation is similar to
-MLIR's affine.for but does not have the restriction that the loop be
-affine.
-
-Example:
-
-```mlir
-    %72 = fir.load %A : !fir.ref<!fir.type<"R"{fld:!fir.array<?:f32>}>>
-    fir.loop %i = 1 to 10 unordered {
-      %73 = fir.extract_element %72, %field, %i : (!fir.ref<!fir.type<"R"{fld:!fir.array<?:f32>}>>, !fir.field, i32) -> f32
-      %74 = fir.call @compute(%73) : (f32) -> i32
-      %75 = fir.coordinate_of %B, %74 : (!fir.ref<!fir.array<?:f32>>, i32) -> !fir.ref<f32>
-      fir.store %73 to %75 : !fir.ref<f32>
-    }
-```
-
-The above fir.loop is a possible translation for the following Fortran DO
-CONCURRENT loop.
-
-
-```Fortran
-    DO CONCURRENT (i = 1:10) LOCAL(x)
-       x = A%fld(i)
-       B(compute(x)) = x
-    END DO
-```
-
-
-#### `fir.where`
-
-Syntax:
-<pre><code><b>fir.where</b> <em>condition</em> <b>{</b><br>
-&nbsp;&nbsp;&nbsp; <em>op-list</em><br>
-<b>}</b> <em>[</em> <b>otherwise {</b><br>
-&nbsp;&nbsp;&nbsp; <em>op-list</em><br>
-<b>}</b> <em>]</em>
-</code></pre>
-
-To conditionally execute operations (typically) within the body of a
-`fir.loop` operation. This operation is similar to `affine.if`, but it is
-generalized and not restricted to affine loop nests.
-
-Example:
-
-```mlir
-    %78 = fir.call %75(%74) : !fir.ref<!T>
-    fir.where %56 {
-      fir.store %76 to %78 : !fir.ref<!T>
-    } otherwise {
-      fir.store %77 to %78 : !fir.ref<!T>
-    }
-```
-
-#### `fir.call`
-
-Syntax:	<code><b>fir.call</b> <em>callee</em> <b>(</b> <em>arg-list</em> <b>) :</b> <em>func-type</em></code>
-
-Call the specified function or function reference.
-
-Example:
-
-```mlir
-    %89 = fir.call %funcref(%arg0) : (!fir.ref<f32>) -> f32
-    %90 = fir.call @function(%arg1, %arg2) : (!fir.ref<f32>, !fir.ref<f32>) -> f32
-```
-
-#### `fir.dispatch`
-
-Syntax:	<code><b>fir.dispatch</b> <em>method-id</em> <b>(</b> <em>arg-list</em> <b>) :</b> <em>func-type</em></code>
-
-Perform a dynamic dispatch on the method name via the dispatch table
-associated with the first argument.  The attribute 'pass_arg_pos' can be
-used to select a dispatch argument other than the first one.
-
-Example:
-
-```mlir
-    %91 = fir.dispatch "methodA"(%89, %90) : (!fir.box<!fir.type<T>>, !fir.ref<f32>) -> i32
-```
-
-### Complex Ops
-
-The standard dialect does not have primitive operations for complex types.
-We've added these primitives in the FIR dialect.
-
-#### `fir.addc`
-
-Syntax: <code><b>fir.addc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
-
-Perform addition of two complex values. The result and arguments must be
-the same type.
-
-#### `fir.subc`
-
-Syntax: <code><b>fir.subc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
-
-Perform subtraction on complex values. The result and arguments must be the
-same type.
-
-#### `fir.mulc`
-
-Syntax: <code><b>fir.mulc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
-
-Perform multiplication on complex values. The result and arguments must be
-the same type.
-
-#### `fir.divc`
-
-Syntax: <code><b>fir.divc <em>ssa-value</em><b>,</b> <em>ssa-value</em> :</b> <b>!fir.complex&lt;</b><em>k</em><b>&gt;</b></code>
-
-Perform division on complex values. The result and arguments must be the
-same type.
-
-### Other Ops
-
-#### `fir.address_of`
-
-Syntax:	<code><b>fir.address_of (@</b><em>symbol</em><b>) :</b> <em>T</em></code>
-
-Converts a symbol to an SSA-value.
-
-Example:
-
-```mlir
-    %func = fir.address_of(@func) : !fir.ref<(!fir.ref<i32>) -> ()>
-```
-
-#### `fir.convert`
-
-Syntax:	<code><b>fir.convert</b> <em>ssa-value</em> <b> : (</b> <em>T</em> <b>) -&gt;</b> <em>U</em></code>
-
-
-Generalized type conversion. Convert the _ssa-value_ from type _T_ to type
-_U_.  Conversions between some types may not be defined.  When _T_ and _U_
-are the same type, this instruction is a NOP.
-
-
-Example:
-
-```mlir
-    %92 = fir.call @foo() : () -> i64
-    %93 = fir.convert %92 : (i64) -> i32
-```
-
-The above conversion truncates a 64-bit integer value to 32-bits.
-
-
-#### `fir.gentypedesc`
-
-Syntax:	<code><b>fir.gentypedesc</b> <em>T</em> <b>: !fir.tdesc&lt;</b><em>T</em><b>&gt;</b></code>
-
-Generate a type descriptor for the type _T_.  This may be useful for
-generating type discriminating code. A type descriptor is an opaque
-singleton constant value in FIR. (It is assumed to be COMDAT.)
-
-
-Example:
-
-```mlir
-    !T = type !fir.type<T{...}>
-    %97 = fir.gentypedesc !T : !fir.tdesc<!T>
-```
-
-#### `fir.no_reassoc`
-
-Syntax:	<code><b>fir.no_reassoc</b> <em>ssa-value</em> <b>:</b> <em>T</em></code>
-
-Primitive operation meant to intrusively prevent operator reassociation.
-The operation is otherwise a nop and the value returned is the same as the
-argument.
-
-
-Example:
-
-```mlir
-    %98 = mulf %96,%97 : f32
-    %99 = fir.no_reassoc %98 : f32
-    %100 = addf %99,%95 : f32
-```
-
-The presence of this operation prevents any local optimizations. In the
-above example, this would prevent replacing the multiply and add with an
-FMA operation.
-
-## Module Abstractions
-
-#### `fir.global`
-
-Syntax:
-<pre><code><b>fir.global @</b><em>global-name [</em> <b>constant</b> <em>]</em> <b>:</b> <em>type</em> <b>{</b><br>
-&nbsp;&nbsp;&nbsp; <em>initializer-list</em><br>
-<b>}</b>
-</code></pre>
-
-A global variable or constant with initial values.
-
-Example:
-
-```mlir
-    fir.global @_QV_Mquark_Vvarble : !VarType {
-      constant 1 : i32
-      constant @some_func : (i32) -> !fir.logical<1>
-    }
-```
-
-The example creates a global variable (writable) named
-`@_QV_Mquark_Vvarble` with some initial values. The initializer should
-conform to the variable's type.
-
-#### `fir.global_entry`
-
-Syntax:	<code><b>fir.global_entry</b> <em>field-id</em> <b>,</b> <em>constant</em></code>
-
-A global entry is a mapping in a global variable that binds a field-id to a
-constant value.  This allows one to specify the values composed in a
-product type and simultaneously defer layout decisions.
-
-Example:
-
-    To do.
-
-#### `fir.dispatch_table`
-
-
-Syntax:
-<pre><code><b>fir.dispatch_table @</b><em>table-name</em> <b>{</b><br>
-&nbsp;&nbsp;&nbsp; <em>dt-entry-list</em><br>
-<b>}</b>
-</code></pre>
-
-A dispatch lookup table used implicitly by a fir.dispatch operation.
-
-Example:
-
-    See below.
-
-
-#### `fir.dt_entry`
-
-Syntax:	<code><b>fir.dt_entry</b> "<em>method-id</em>" <b>,</b> <em>callee</em></code>
-
-
-A dispatch table entry is a mapping in a dispatch table that binds a
-method-id to a callee-reference.
-
-
-Example:
-
-```mlir
-    fir.dispatch_table @_QDTMquuzTfoo {
-      fir.dt_entry "method1", @_QFNMquuzTfooPmethod1AfooR
-      fir.dt_entry "method2", @_QFNMquuzTfooPmethod2AfooII
-    }
-```
-
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/optimizer/Dialect/FIROps.td
index 5d3f1adc38ad..7ce9efd40786 100644
--- a/include/flang/optimizer/Dialect/FIROps.td
+++ b/include/flang/optimizer/Dialect/FIROps.td
@@ -314,21 +314,22 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
     an optional name.  The allocation may have a dynamic repetition count
     for allocating a sequence of locations for the specified type.
 
-      %11 = fir.alloca i32
-      %12 = fir.alloca !fir.array<8 x i64>
-      %13 = fir.alloca f32, %5
+      %c = ... : i64
+      %x = fir.alloca i32
+      %y = fir.alloca !fir.array<8 x i64>
+      %z = fir.alloca f32, %c
 
-      %14 = ... : i16
-      %15 = ... : i32
-      %16 = fir.alloca !fir.type<PT(len1:i16, len2:i32)> (%14, %15 : i16, i32)
+      %i = ... : i16
+      %j = ... : i32
+      %w = fir.alloca !fir.type<PT(len1:i16, len2:i32)> (%i, %j : i16, i32)
 
-    Note that in the case of `%13`, a contiguous block of memory is allocated
+    Note that in the case of `%z`, a contiguous block of memory is allocated
     and its size is a runtime multiple of a 32-bit REAL value.
 
-    In the case of `%16`, the arguments `%14` and `%15` are LEN parameters
+    In the case of `%w`, the arguments `%i` and `%j` are LEN parameters
     (`len1`, `len2`) to the type `PT`.
 
-    Finally, the operation is undefined if the ssa-value `%5` is negative.
+    Finally, the operation is undefined if the ssa-value `%c` is negative.
   }];
 
   let results = (outs fir_ReferenceType);
@@ -345,21 +346,22 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
   }];
 }
 
-def fir_LoadOp : fir_OneResultOp<"load", []>,
-    Arguments<(ins AnyReferenceLike:$memref)> {
+def fir_LoadOp : fir_OneResultOp<"load", []> {
   let summary = "load a value from a memory reference";
   let description = [{
     Load a value from a memory reference into an ssa-value (virtual register).
     Produces an immutable ssa-value of the referent type. A memory reference
     has type `!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
 
-      %14 = fir.alloca i32 : !fir.ref<i32>
-      %15 = fir.load %14 : !fir.ref<i32>
+      %a = fir.alloca i32
+      %l = fir.load %a : !fir.ref<i32>
 
     The ssa-value has an undefined value if the memory reference is undefined
     or null.
   }];
 
+  let arguments = (ins AnyReferenceLike:$memref);
+
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, Value refVal",
     [{
@@ -400,8 +402,7 @@ def fir_LoadOp : fir_OneResultOp<"load", []>,
   }];
 }
 
-def fir_StoreOp : fir_Op<"store", []>,
-    Arguments<(ins AnyType:$value, AnyReferenceLike:$memref)> {
+def fir_StoreOp : fir_Op<"store", []> {
   let summary = "store an SSA-value to a memory location";
 
   let description = [{
@@ -409,20 +410,16 @@ def fir_StoreOp : fir_Op<"store", []>,
     value must be of the same type as the referent type of the memory
     reference.
 
-      %16 = fir.call @foo() : f64
-      %17 = fir.call @bar() : !fir.ptr<f64>
-      fir.store %16 to %17 : !fir.ptr<f64>
+      %v = ... : f64
+      %p = ... : !fir.ptr<f64>
+      fir.store %v to %p : !fir.ptr<f64>
 
     The above store changes the value to which the pointer is pointing and not
-    the pointer itself. The operation is undefined if the memory reference is
-    undefined or null.
+    the pointer itself. The operation is undefined if the memory reference,
+    `%p`, is undefined or null.
   }];
 
-  let verifier = [{
-    if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
-      return emitOpError("store value type must match memory reference type");
-    return mlir::success();
-  }];
+  let arguments = (ins AnyType:$value, AnyReferenceLike:$memref);
 
   let parser = [{
     mlir::Type type;
@@ -449,6 +446,12 @@ def fir_StoreOp : fir_Op<"store", []>,
     p << " : " << memref().getType();
   }];
 
+  let verifier = [{
+    if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
+      return emitOpError("store value type must match memory reference type");
+    return mlir::success();
+  }];
+
   let extraClassDeclaration = [{
     static mlir::Type elementType(mlir::Type refType);
   }];
@@ -461,7 +464,10 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
     This operation is typically created internally by the mem2reg conversion
     pass. An undefined value can be of any type except `!fir.ref<T>`.
 
-      %18 = fir.undefined !fir.array<10 x !fir.type<T>>
+      %a = fir.undefined !fir.array<10 x !fir.type<T>>
+
+    The example creates an array shaped ssa value. The array is rank 1, extent
+    10, and each element has type `!fir.type<T>`.
   }];
 
   let verifier = [{
@@ -473,12 +479,16 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   let parser = [{
     mlir::Type intype;
     if (parser.parseType(intype) ||
+        parser.parseOptionalAttrDict(result.attributes) ||
         parser.addTypeToList(intype, result.types))
       return mlir::failure();
     return mlir::success();
   }];
 
-  let printer = [{ p << getOperationName() << ' ' << getType(); }];
+  let printer = [{
+    p << getOperationName() << ' ' << getType();
+    p.printOptionalAttrDict(getAttrs(), {});
+  }];
 }
 
 def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
@@ -531,9 +541,11 @@ def fir_FreeMemOp : fir_Op<"freemem", []> {
 // Terminator operations
 
 class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_Op<mnemonic, !listconcat(traits, [Terminator])>,
-    Arguments<(ins Variadic<AnyType>:$args)>,
-    Results<(outs)> {
+    fir_Op<mnemonic, !listconcat(traits, [Terminator])> {
+  let arguments = (ins Variadic<AnyType>:$args);
+
+  let results = (outs);
+
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value selector,"
     "ArrayRef<Value> properOperands, ArrayRef<Block *> destinations,"
@@ -968,8 +980,10 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
       %c10 = constant 10 : index
       %4 = fir.dims(%c1, %c10, %c1) : (index, index, index) -> !fir.dims<1>
       %5 = ... : !fir.ref<!fir.array<10 x i32>>
-      %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10 x i32>>, !fir.dims<1>)
-                            -> !fir.box<!fir.array<10 x i32>>
+      %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10 x i32>>, !fir.dims<1>) -> !fir.box<!fir.array<10 x i32>>
+
+    The descriptor tuple may contain additional implementation-specific
+    information through the use of additional attributes.
   }];
 
   let arguments = (ins AnyReferenceLike:$memref, Variadic<AnyEmboxArg>:$args);
@@ -1093,10 +1107,12 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
 
       CHARACTER(LEN=10) :: var
 
-      %4 = ...         : !fir.ref<!fir.array<10:!fir.char<1>>>
+      %4 = ...         : !fir.ref<!fir.array<10 x !fir.char<1>>>
       %5 = constant 10 : i32
-      %6 = fir.emboxchar %4, %5 : (!fir.ref<!fir.array<10:!fir.char<1>>>,
-                                   i32) -> !fir.boxchar<1>
+      %6 = fir.emboxchar %4, %5 : (!fir.ref<!fir.array<10 x !fir.char<1>>>, i32) -> !fir.boxchar<1>
+
+    In the above `%4` is a memory reference to a buffer of 10 CHARACTER units.
+    This buffer and its LEN value (10) are wrapped into a pair in `%6`.
   }];
 
   let assemblyFormat = [{
@@ -1129,6 +1145,7 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
     context's values accordingly, up to and including inhibiting register
     promotion of local values.
 
+      %4 = ... : !fir.ref<tuple<i32, i32>>
       %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) ->
                                   !fir.boxproc<(i32) -> i32>
   }];
@@ -1201,8 +1218,14 @@ def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
   let summary = "unbox the boxed value into a tuple value";
 
   let description = [{
-    Unboxes a value of `box` type into a tuple of information abstracted in
-    that boxed value.
+    Unbox a boxed value into a result of multiple values from the box's
+    component data.  The values are, minimally, a reference to the data of the
+    entity, the byte-size of one element, the rank, the type descriptor, a set
+    of flags (packed in an integer, and an array of dimension information (of
+    size rank).
+
+      %40   = ... : !fir.box<!fir.type<T>>
+      %41:6 = fir.unbox %40 : (!fir.box<!fir.type<T>>) -> (!fir.ref<!fir.type<T>>, i32, i32, !fir.tdesc<!fir.type<T>>, i32, !fir.dims<4>)
   }];
 
   let arguments = (ins fir_BoxType:$box);
@@ -1217,25 +1240,31 @@ def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
   );
 }
 
-def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]>,
-    Arguments<(ins fir_BoxCharType:$boxchar)>,
-    Results<(outs fir_ReferenceType, AnyIntegerLike)> {
+def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]> {
   let summary = "unbox a boxchar value into a pair value";
 
   let description = [{
     Unboxes a value of `boxchar` type into a pair consisting of a memory
     reference to the CHARACTER data and the LEN type parameter.
+
+      %45   = ... : !fir.boxchar<1>
+      %46:2 = fir.unboxchar %45 : (!fir.boxchar<1>) -> (!fir.ref<!fir.character<1>>, i32)
   }];
+
+  let arguments = (ins fir_BoxCharType:$boxchar);
+
+  let results = (outs fir_ReferenceType, AnyIntegerLike);
 }
 
-def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]>,
-    Arguments<(ins fir_BoxProcType:$boxproc)>,
-    Results<(outs FunctionType, fir_ReferenceType:$refTuple)> {
+def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
   let summary = "unbox a boxproc value into a pair value";
 
   let description = [{
     Unboxes a value of `boxproc` type into a pair consisting of a procedure
     pointer and a pointer to a host context.
+
+      %47   = ... : !fir.boxproc<() -> i32>
+      %48:2 = fir.unboxproc %47 : (!fir.ref<() -> i32>, !fir.ref<tuple<f32, i32>>)
   }];
 
   let verifier = [{
@@ -1244,10 +1273,13 @@ def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]>,
         return mlir::success();
     return emitOpError("second output argument has bad type");
   }];
+
+  let arguments = (ins fir_BoxProcType:$boxproc);
+
+  let results = (outs FunctionType, fir_ReferenceType:$refTuple);
 }
 
 def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
-
   let summary = "return a memory reference to the boxed value";
 
   let description = [{
@@ -1255,6 +1287,10 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
     `boxchar`, and `boxproc`.  The result for each of these
     cases, respectively, is the address of the data, the address of the
     CHARACTER data, and the address of the procedure.
+
+      %51 = fir.box_addr %box : (!fir.box<f64>) -> !fir.ref<f64>
+      %52 = fir.box_addr %boxchar : (!fir.boxchar<1>) -> !fir.ref<!fir.char<1>>
+      %53 = fir.box_addr %boxproc : (!fir.boxproc<!P>) -> !fir.ref<!P>
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1267,6 +1303,9 @@ def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
 
   let description = [{
     Extracts the LEN type parameter from a `boxchar` value.
+
+      %45 = ... : !boxchar<1>  // CHARACTER(20)
+      %59 = fir.boxchar_len %45 : (!fir.boxchar<1>) -> i64  // len=20
   }];
 
   let arguments = (ins fir_BoxCharType:$val);
@@ -1282,6 +1321,12 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
     of `val`, which must have a `box` type.  The dimensions are enumerated from
     left to right from 0 to rank-1. This operation has undefined behavior if
     `dim` is out of bounds.
+
+      %c1   = constant 0 : i32
+      %52:3 = fir.box_dims %40, %c1 : (!fir.box<!fir.array<*:f64>>, i32) -> (i32, i32, i32)
+
+    The above is a request to return the left most row (at index 0) triple from
+    the box. The triple will be the lower bound, upper bound, and stride.
   }];
 
   let arguments = (ins fir_BoxType:$val, AnyIntegerLike:$dim);
@@ -1303,6 +1348,12 @@ def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
   let description = [{
     Returns the size of an element in an entity of `box` type.  This size may
     not be known until runtime.
+
+      %53 = fir.box_elesize %40 : (!fir.box<f32>, i32) -> i32  // size=4
+      %54 = fir.box_elesize %40 : (!fir.box<!fir.array<*:f32>>, i32) -> i32
+
+    In the above example, `%53` may box an array of REAL values while `%54`
+    must box an array of REAL values (with dynamic rank and extent).
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1310,57 +1361,80 @@ def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
   let results = (outs AnyIntegerLike);
 }
 
-def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val)>,
-    Results<(outs BoolLike)> {
+def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]> {
   let summary = "is the boxed value an ALLOCATABLE?";
 
   let description = [{
-    Determine if the boxed value was from an ALLOCATABLE entity.
+    Determine if the boxed value was from an ALLOCATABLE entity. This will
+    return true if the originating box value was from a `fir.embox` op
+    with a mem-ref value that had the type !fir.heap<T>.
 
-      %ref = ... : !fir.heap<i64>
-      %box = fir.embox %ref : !fir.box<i64>
-      %isheap = fir.box_isalloc %box : i1
+      %r = ... : !fir.heap<i64>
+      %b = fir.embox %r : (!fir.heap<i64>) -> !fir.box<i64>
+      %a = fir.box_isalloc %b : (!fir.box<i64>) -> i1  // true
+
+    The canonical descriptor implementation will carry a flag to record if the
+    variable is an ALLOCATABLE.
   }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs BoolLike);
 }
 
-def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val)>,
-    Results<(outs BoolLike)> {
+def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]> {
   let summary = "is the boxed value an array?";
 
   let description = [{
-    Determine if the boxed value has a positive (> 0) rank.
+    Determine if the boxed value has a positive (> 0) rank. This will return
+    true if the originating box value was from a fir.embox with a memory
+    reference value that had the type !fir.array<T> and/or a dims argument.
 
-      %ref = ... : !fir.ref<i64>
-      %dims = fir.gendims(1, 100, 1) : !fir.dims<1>
-      %box = fir.embox %ref, %dims : !fir.box<i64>
-      %isarr = fir.box_isarray %box : i1
+      %r = ... : !fir.ref<i64>
+      %d = fir.gendims(1, 100, 1) : (i32, i32, i32) -> !fir.dims<1>
+      %b = fir.embox %r, %d : (!fir.ref<i64>, !fir.dims<1>) -> !fir.box<i64>
+      %a = fir.box_isarray %b : (!fir.box<i64>) -> i1  // true
   }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs BoolLike);
 }
 
-def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]>,
-    Arguments<(ins fir_BoxType:$val)>,
-    Results<(outs BoolLike)> {
+def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]> {
   let summary = "is the boxed value a POINTER?";
 
   let description = [{
     Determine if the boxed value was from a POINTER entity.
 
-      %ptr = ... : !fir.ptr<i64>
-      %box = fir.embox %ptr : !fir.box<i64>
-      %isptr = fir.box_isptr %box : i1
+      %p = ... : !fir.ptr<i64>
+      %b = fir.embox %p : (!fir.ptr<i64>) -> !fir.box<i64>
+      %a = fir.box_isptr %b : (!fir.box<i64>) -> i1  // true
   }];
+
+  let arguments = (ins fir_BoxType:$val);
+
+  let results = (outs BoolLike);
 }
 
-def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]>,
-    Arguments<(ins fir_BoxProcType:$val)>,
-    Results<(outs fir_ReferenceType)> {
+def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]> {
   let summary = "returns the host instance pointer (or null)";
 
   let description = [{
-    Extract the host context pointer from a `boxproc` value.
+    Extract the host context pointer from a boxproc value.
+
+      %8 = ... : !fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>
+      %9 = fir.boxproc_host %8 : (!fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>) -> !fir.ref<tuple<i32, i32>>
+
+    In the example, the reference to the closure over the host procedure's
+    variables is returned. This allows an internal procedure to access the
+    host's variables. It is up to lowering to determine the contract between
+    the host and the internal procedure.
   }];
+
+  let arguments = (ins fir_BoxProcType:$val);
+
+  let results = (outs fir_ReferenceType);
 }
 
 def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
@@ -1369,6 +1443,13 @@ def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
   let description = [{
     Return the rank of a value of `box` type.  If the value is scalar, the
     rank is 0.
+
+      %57 = fir.box_rank %40 : (!fir.box<!fir.array<*:f64>>) -> i32
+      %58 = fir.box_rank %41 : (!fir.box<f64>) -> i32
+
+    The example `%57` shows how one would determine the rank of an array that
+    has deferred rank at runtime. This rank should be at least 1. In %58, the
+    descriptor may be either an array or a scalar, so the value is nonnegative.
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1380,7 +1461,11 @@ def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
   let summary = "return the type descriptor for the boxed value";
 
   let description = [{
-    Return the opaque type descriptor of a value of `box` type.
+    Return the opaque type descriptor of a value of `box` type. A type
+    descriptor is an implementation defined value that fully describes a type
+    to the Fortran runtime.
+
+      %7 = fir.box_tdesc %41 : (!fir.box<f64>) -> !fir.tdesc<f64>
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1390,16 +1475,32 @@ def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
 
 // Record and array type operations
 
-def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
-    Arguments<(ins AnyRefOrBox:$ref, Variadic<AnyCoordinateType>:$coor)>,
-    Results<(outs fir_ReferenceType)> {
+def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
   let summary = "Finds the coordinate (location) of a value in memory";
 
   let description = [{
-    Determine a memory reference given a memory reference of composite type
-    and a list of index values. (This returns the address of a value.)
+    Compute the internal coordinate address starting from a boxed value or
+    unboxed memory reference. Returns a memory reference. When computing the
+    coordinate of an array element, the rank of the array must be known and
+    the number of indexing expressions must equal the rank of the array.
+
+    This operation will apply the access map from a boxed value implicitly.
+
+    Unlike LLVM's GEP instruction, one cannot stride over the outermost
+    reference; therefore, the leading 0 index must be omitted.
+
+      %i = ... : index
+      %h = ... : !fir.heap<!fir.array<?:f32>>
+      %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
+
+    In the example, `%p` will be a pointer to the `%i`-th f32 value in the
+    array `%h`.
   }];
 
+  let arguments = (ins AnyRefOrBox:$ref, Variadic<AnyCoordinateType>:$coor);
+
+  let results = (outs fir_ReferenceType);
+
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
@@ -1418,23 +1519,33 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]>,
   }];
 }
 
-def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]>,
-    Arguments<(ins AnyCompositeLike:$adt, Variadic<AnyComponentType>:$coor)> {
+def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
   let summary = "Extract a value from an aggregate SSA-value";
 
   let description = [{
-    Extract a subobject value given a value of composite type and a list of
-    index values.
+    Extract a value from an entity with a type composed of tuples, arrays,
+    and/or derived types. Returns the value from entity with the type of the
+    specified component. Cannot be used on values of `!fir.box` type.
+
+    Note that the entity ssa-value must be of compile-time known size in order
+    to use this operation.
+
+      %f = fir.field_index field, !fir.type<X{field:i32}>
+      %s = ... : !fir.type<X>
+      %v = fir.extract_value %s, %f : (!fir.type<X>, !fir.field) -> i32
   }];
 
+  let arguments = (ins
+    AnyCompositeLike:$adt,
+    Variadic<AnyComponentType>:$coor
+  );
+
   let assemblyFormat = [{
     $adt `,` $coor attr-dict `:` functional-type(operands, results)
   }];
 }
 
-def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
-    Arguments<(ins StrAttr:$field_id, TypeAttr:$on_type,
-               Variadic<AnyIntegerType>:$lenparams)> {
+def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
   let summary = "create a field index value from a field identifier";
 
   let description = [{
@@ -1444,17 +1555,15 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
     these values can be used with the `fir.coordinate_of`, `fir.extract_value`,
     or `fir.insert_value` instructions to compute (abstract) addresses of
     subobjects.
+
+      %f = fir.field_index field, !fir.type<X{field:i32}>
   }];
 
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, StringRef fieldName,"
-    "Type recTy, ArrayRef<Value> operands = {}",
-    [{
-      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
-      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
-      result.addOperands(operands);
-    }]
-  >];
+  let arguments = (ins
+    StrAttr:$field_id,
+    TypeAttr:$on_type,
+    Variadic<AnyIntegerType>:$lenparams
+  );
 
   let parser = [{
     llvm::StringRef fieldName;
@@ -1504,6 +1613,16 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]>,
     }
   }];
 
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, StringRef fieldName,"
+    "Type recTy, ArrayRef<Value> operands = {}",
+    [{
+      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
+      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+      result.addOperands(operands);
+    }]
+  >];
+
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
@@ -1520,8 +1639,10 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
     index, the extent, and the stride for that dimension. The dimension
     information is given in the same row-to-column order as Fortran. This
     abstract dimension value must describe a reified object, so all dimension
-    information must be specified.  The extent must be non-negative and the
+    information must be specified.  The extent must be nonnegative and the
     stride must not be zero.
+
+      %d = fir.gendims %l, %u, %s : (index, index, index) -> !fir.dims<1>
   }];
 
   let arguments = (ins Variadic<AnyIntegerType>:$triples);
@@ -1546,7 +1667,18 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
   let summary = "insert a new sub-value into a copy of an existing aggregate";
 
   let description = [{
-    Insert a value into a composite value.
+    Insert a value from an entity with a type composed of tuples, arrays,
+    and/or derived types. Returns a new ssa value with the same type as the
+    original entity. Cannot be used on values of `!fir.box` type.
+
+    Note that the entity ssa-value must be of compile-time known size in order
+    to use this operation.
+
+      %a = ... : !fir.array<10xtuple<i32, f32>>
+      %f = ... : f32
+      %o = ... : i32
+      %c = constant 1 : i32
+      %b = fir.insert_value %a, %f, %o, %c : (!fir.array<10x20xtuple<i32, f32>>, f32, i32, i32) -> !fir.array<10x20xtuple<i32, f32>>
   }];
 
   let arguments = (ins AnyCompositeLike:$adt, AnyType:$val,
@@ -1558,8 +1690,7 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
   }];
 }
 
-def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]>,
-    Arguments<(ins StrAttr:$field_id, TypeAttr:$on_type)> {
+def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
   let summary =
     "create a field index value from a LEN type parameter identifier";
 
@@ -1568,15 +1699,13 @@ def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]>,
     The type of a LEN parameter value is `!fir.len` and these values can be
     used with the `fir.coordinate_of` instructions to compute (abstract)
     addresses of LEN parameters.
+
+      %e = fir.len_param_index len1, !fir.type<X(len1:i32)>
+      %p = ... : !fir.box<!fir.type<X>>
+      %q = fir.coordinate_of %p, %e : (!fir.box<!fir.type<X>>, !fir.len) -> !fir.ref<i32>
   }];
 
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, StringRef fieldName, Type recTy",
-    [{
-      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
-      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
-    }]
-  >];
+  let arguments = (ins StrAttr:$field_id, TypeAttr:$on_type);
 
   let parser = [{
     llvm::StringRef fieldName;
@@ -1602,6 +1731,14 @@ def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]>,
       << getAttr(typeAttrName());
   }];
 
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, StringRef fieldName, Type recTy",
+    [{
+      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
+      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+    }]
+  >];
+
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
@@ -1618,7 +1755,20 @@ def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
 def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   let summary = "generalized loop operation";
   let description = [{
-    A generalized Fortran loop construct.
+    Generalized high-level looping construct. This operation is similar to
+    MLIR's `loop.for`. An ordered loop will return the final value of `%i`.
+
+      %l = constant 0 : index
+      %u = constant 9 : index
+      fir.loop %i = %l to %u unordered {
+        %x = fir.convert %i : (index) -> i32
+        %v = fir.call @compute(%x) : (i32) -> f32
+        %p = fir.coordinate_of %A, %i : (!fir.ref<f32>, index) -> !fir.ref<f32>
+        fir.store %v to %p : !fir.ref<f32>
+      }
+
+    The above example iterates over the interval `[%l, %u]`. The unordered
+    keyword indicates that the iterations can be executed in any order.
   }];
 
   let arguments = (ins
@@ -1719,9 +1869,20 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
 def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
   let summary = "generalized conditional operation";
   let description = [{
-    This is a generalized conditional construct.
+    To conditionally execute operations (typically) within the body of a
+    `fir.loop` operation. This operation is similar to `loop.if`.
+
+      %56 = ... : i1
+      %78 = ... : !fir.ref<!T>
+      fir.where %56 {
+        fir.store %76 to %78 : !fir.ref<!T>
+      } otherwise {
+        fir.store %77 to %78 : !fir.ref<!T>
+      }
   }];
+
   let arguments = (ins I1:$condition);
+
   let regions = (region SizedRegion<1>:$whereRegion, AnyRegion:$otherRegion);
 
   let skipDefaultBuilders = 1;
@@ -1729,6 +1890,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
     OpBuilder<"Builder *builder, OperationState &result, "
               "Value cond, bool withOtherRegion">
   ];
+
   let parser = [{ return parseWhereOp(parser, result); }];
 
   let printer = [{
@@ -1773,31 +1935,49 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
 
 // Procedure call operations
 
-def fir_CallOp : fir_Op<"call", []>,
-    Arguments<(ins OptionalAttr<SymbolRefAttr>:$callee,
-               Variadic<AnyType>:$args)>,
-    Results<(outs Variadic<AnyType>)> {
+def fir_CallOp : fir_Op<"call", []> {
   let summary = "call a procedure";
 
   let description = [{
+    Call the specified function or function reference.
+
     Provides a custom parser and pretty printer to allow a more readable syntax
     in the FIR dialect, e.g. `fir.call @sub(%12)` or `fir.call %20(%22,%23)`.
+
+      %a = fir.call %funcref(%arg0) : (!fir.ref<f32>) -> f32
+      %b = fir.call @function(%arg1, %arg2) : (!fir.ref<f32>, !fir.ref<f32>) -> f32    
   }];
 
+  let arguments = (ins
+    OptionalAttr<SymbolRefAttr>:$callee,
+    Variadic<AnyType>:$args
+  );
+
+  let results = (outs Variadic<AnyType>);
+
   let parser = "return parseCallOp(parser, result);";
   let printer = "printCallOp(p, *this);";
 }
 
-def fir_DispatchOp : fir_Op<"dispatch", []>,
-    Arguments<(ins StrAttr:$method, fir_BoxType:$object,
-               Variadic<AnyType>:$args)>,
-    Results<(outs Variadic<AnyType>)> {
+def fir_DispatchOp : fir_Op<"dispatch", []> {
   let summary = "call a type-bound procedure";
 
   let description = [{
-    Dynamic dispatch to the specified method.
+    Perform a dynamic dispatch on the method name via the dispatch table
+    associated with the first argument.  The attribute 'pass_arg_pos' can be
+    used to select a dispatch argument other than the first one.
+
+      %r = fir.dispatch methodA(%o) : (!fir.box<none>) -> i32
   }];
 
+  let arguments = (ins
+    StrAttr:$method,
+    fir_BoxType:$object,
+    Variadic<AnyType>:$args
+  );
+
+  let results = (outs Variadic<AnyType>);
+
   let parser = [{
     mlir::FunctionType calleeType;
     llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
@@ -1961,7 +2141,8 @@ def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]>,
   let summary = "create a floating point constant";
 
   let description = [{
-    FIXME
+    A floating-point constant. This operation is to augment MLIR to be able
+    to represent APFloat values that are not supported in the standard dialect.
   }];
 
   let parser = [{
@@ -2051,7 +2232,9 @@ def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]>,
   let summary = "create a complex constant";
 
   let description = [{
-    FIXME
+    A complex constant. Similar to the standard dialect complex type, but this
+    extension allows constants with APFloat values that are not supported in
+    the standard dialect.
   }];
 
   let parser = [{
@@ -2114,24 +2297,27 @@ def fir_DivcOp : ComplexArithmeticOp<"divc">;
 // Pow is a builtin call and not a primitive
 
 def fir_CmpcOp : fir_Op<"cmpc",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]>,
-    Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)>,
-    Results<(outs AnyLogicalLike)> {
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
   let summary = "complex floating-point comparison operator";
 
   let description = [{
     A complex comparison to handle complex types found in FIR.
   }];
 
+  let arguments = (ins fir_ComplexType:$lhs, fir_ComplexType:$rhs);
+
+  let results = (outs AnyLogicalLike);
+
+  let parser = "return fir::parseCmpcOp(parser, result);";
+
+  let printer = "fir::printCmpcOp(p, *this);";
+
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpFPredicate predicate,"
     "Value lhs, Value rhs", [{
       fir::buildCmpCOp(builder, result, predicate, lhs, rhs);
   }]>];
 
-  let parser = [{ return fir::parseCmpcOp(parser, result); }];
-  let printer = [{ fir::printCmpcOp(p, *this); }];
-
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getPredicateAttrName() {
       return "predicate";
@@ -2151,6 +2337,8 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
   let description = [{
     Convert a symbol (a function or global reference) to an SSA-value to be
     used in other Operations.
+
+      %p = fir.address_of(@symbol) : !fir.ref<f64>
   }];
 
   let arguments = (ins SymbolRefAttr:$symbol);
@@ -2178,7 +2366,14 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
 def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
   let summary = "encapsulates all Fortran scalar type conversions";
   let description = [{
-    Generalized type conversion. Not all pairs of types have conversions.
+    Generalized type conversion. Convert the ssa value from type T to type U.
+    Not all pairs of types have conversions. When types T and U are the same
+    type, this instruction is a NOP and may be folded away.
+
+      %v = ... : i64
+      %w = fir.convert %v : (i64) -> i32
+
+    The example truncates the value `%v` from an i64 to an i32.
   }];
 
   let arguments = (ins AnyType:$value);
@@ -2207,24 +2402,12 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
     Generates a constant object that is an abstract type descriptor of the
     specified type.  The meta-type of a type descriptor for the type `T`
     is `!fir.tdesc<T>`.
-  }];
-
-  let arguments = (ins FortranTypeAttr:$in_type);
 
-  let verifier = [{
-    mlir::Type resultTy = getType();
-    if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
-      if (tdesc.getOfTy() != getInType())
-        return emitOpError("wrapped type mismatched");
-    } else {
-      return emitOpError("must be !fir.tdesc type");
-    }
-    return mlir::success();
+      !T = type !fir.type<T{...}>
+      %t = fir.gentypedesc !T  // returns value of !fir.tdesc<!T>
   }];
 
-  let builders = [
-    OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty">
-  ];
+  let arguments = (ins FortranTypeAttr:$in_type);
 
   let parser = [{
     mlir::Type intype;
@@ -2242,6 +2425,21 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
     p.printOptionalAttrDict(getAttrs(), {"in_type"});
   }];
 
+  let builders = [
+    OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty">
+  ];
+
+  let verifier = [{
+    mlir::Type resultTy = getType();
+    if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
+      if (tdesc.getOfTy() != getInType())
+        return emitOpError("wrapped type mismatched");
+    } else {
+      return emitOpError("must be !fir.tdesc type");
+    }
+    return mlir::success();
+  }];
+
   let extraClassDeclaration = [{
     mlir::Type getInType() {
       // get the type that the type descriptor describes
@@ -2460,6 +2658,11 @@ def fir_DispatchTableOp : fir_Op<"dispatch_table", [IsolatedFromAbove, Symbol,
     between method identifiers and corresponding `FuncOp` symbols.
 
     The ordering of associations in the map is determined by the front-end.
+
+      fir.dispatch_table @_QDTMquuzTfoo {
+        fir.dt_entry method1, @_QFNMquuzTfooPmethod1AfooR
+        fir.dt_entry method2, @_QFNMquuzTfooPmethod2AfooII
+      }
   }];
 
   let parser = [{
@@ -2538,7 +2741,7 @@ def fir_DTEntryOp : fir_Op<"dt_entry", []> {
     and uses the method identifier to select the type-bound procedure to
     be called.
 
-      fir.entry method_name, @uniquedProcedure
+      fir.dt_entry method_name, @uniquedProcedure
   }];
 
   let arguments = (ins StrAttr:$method, SymbolRefAttr:$proc);

From 44c2ccf5705e4b22d29f4fcb2579e243ebdb69b7 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 26 Feb 2020 15:05:26 -0800
Subject: [PATCH 197/345] kill files

---
 lib/Lower/CMakeLists.txt | 13 -------------
 1 file changed, 13 deletions(-)
 delete mode 100644 lib/Lower/CMakeLists.txt

diff --git a/lib/Lower/CMakeLists.txt b/lib/Lower/CMakeLists.txt
deleted file mode 100644
index 87131cd9fa53..000000000000
--- a/lib/Lower/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-add_library(FortranLower
-  PFTBuilder.cpp
-)
-
-target_link_libraries(FortranLower
-  LLVMSupport
-)
-
-install (TARGETS FortranLower
-  ARCHIVE DESTINATION lib
-  LIBRARY DESTINATION lib
-  RUNTIME DESTINATION bin
-)

From 662d4c6e532036ebee220e3b1d99c4ed7b77457f Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 26 Feb 2020 15:06:35 -0800
Subject: [PATCH 198/345] directory rename fallout

---
 lib/{lower => Lower}/Bridge.cpp      | 0
 lib/{lower => Lower}/CFGBuilder.h    | 0
 lib/{lower => Lower}/CMakeLists.txt  | 0
 lib/{lower => Lower}/ConvertExpr.cpp | 0
 lib/{lower => Lower}/ConvertType.cpp | 0
 lib/{lower => Lower}/IO.cpp          | 0
 lib/{lower => Lower}/Intrinsics.cpp  | 0
 lib/{lower => Lower}/Mangler.cpp     | 0
 lib/{lower => Lower}/OpBuilder.cpp   | 0
 lib/{lower => Lower}/RTBuilder.h     | 0
 lib/{lower => Lower}/Runtime.cpp     | 0
 11 files changed, 0 insertions(+), 0 deletions(-)
 rename lib/{lower => Lower}/Bridge.cpp (100%)
 rename lib/{lower => Lower}/CFGBuilder.h (100%)
 rename lib/{lower => Lower}/CMakeLists.txt (100%)
 rename lib/{lower => Lower}/ConvertExpr.cpp (100%)
 rename lib/{lower => Lower}/ConvertType.cpp (100%)
 rename lib/{lower => Lower}/IO.cpp (100%)
 rename lib/{lower => Lower}/Intrinsics.cpp (100%)
 rename lib/{lower => Lower}/Mangler.cpp (100%)
 rename lib/{lower => Lower}/OpBuilder.cpp (100%)
 rename lib/{lower => Lower}/RTBuilder.h (100%)
 rename lib/{lower => Lower}/Runtime.cpp (100%)

diff --git a/lib/lower/Bridge.cpp b/lib/Lower/Bridge.cpp
similarity index 100%
rename from lib/lower/Bridge.cpp
rename to lib/Lower/Bridge.cpp
diff --git a/lib/lower/CFGBuilder.h b/lib/Lower/CFGBuilder.h
similarity index 100%
rename from lib/lower/CFGBuilder.h
rename to lib/Lower/CFGBuilder.h
diff --git a/lib/lower/CMakeLists.txt b/lib/Lower/CMakeLists.txt
similarity index 100%
rename from lib/lower/CMakeLists.txt
rename to lib/Lower/CMakeLists.txt
diff --git a/lib/lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
similarity index 100%
rename from lib/lower/ConvertExpr.cpp
rename to lib/Lower/ConvertExpr.cpp
diff --git a/lib/lower/ConvertType.cpp b/lib/Lower/ConvertType.cpp
similarity index 100%
rename from lib/lower/ConvertType.cpp
rename to lib/Lower/ConvertType.cpp
diff --git a/lib/lower/IO.cpp b/lib/Lower/IO.cpp
similarity index 100%
rename from lib/lower/IO.cpp
rename to lib/Lower/IO.cpp
diff --git a/lib/lower/Intrinsics.cpp b/lib/Lower/Intrinsics.cpp
similarity index 100%
rename from lib/lower/Intrinsics.cpp
rename to lib/Lower/Intrinsics.cpp
diff --git a/lib/lower/Mangler.cpp b/lib/Lower/Mangler.cpp
similarity index 100%
rename from lib/lower/Mangler.cpp
rename to lib/Lower/Mangler.cpp
diff --git a/lib/lower/OpBuilder.cpp b/lib/Lower/OpBuilder.cpp
similarity index 100%
rename from lib/lower/OpBuilder.cpp
rename to lib/Lower/OpBuilder.cpp
diff --git a/lib/lower/RTBuilder.h b/lib/Lower/RTBuilder.h
similarity index 100%
rename from lib/lower/RTBuilder.h
rename to lib/Lower/RTBuilder.h
diff --git a/lib/lower/Runtime.cpp b/lib/Lower/Runtime.cpp
similarity index 100%
rename from lib/lower/Runtime.cpp
rename to lib/Lower/Runtime.cpp

From 224b69ce3407d6a7fb0ca90716b28aff5307dd9e Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 18 Mar 2020 13:39:19 -0700
Subject: [PATCH 199/345] [shim] remove the files from master to facilitate
 rebasing of mono

---
 .../flang/Optimizer/Dialect/CMakeLists.txt    |   22 -
 include/flang/Optimizer/Dialect/FIRAttr.h     |  166 -
 include/flang/Optimizer/Dialect/FIRDialect.h  |   92 -
 include/flang/Optimizer/Dialect/FIROps.h      |   47 -
 include/flang/Optimizer/Dialect/FIROps.td     | 2748 -----------------
 .../flang/Optimizer/Dialect/FIROpsSupport.h   |   63 -
 include/flang/Optimizer/Dialect/FIRType.h     |  399 ---
 include/flang/Optimizer/Support/KindMapping.h |   90 -
 lib/Optimizer/CMakeLists.txt                  |    5 -
 lib/Optimizer/Dialect/FIRAttr.cpp             |  236 --
 lib/Optimizer/Dialect/FIRDialect.cpp          |   54 -
 lib/Optimizer/Dialect/FIROps.cpp              |  862 ------
 lib/Optimizer/Dialect/FIRType.cpp             | 1292 --------
 lib/Optimizer/Support/CMakeLists.txt          |   10 -
 lib/Optimizer/Support/KindMapping.cpp         |  244 --
 15 files changed, 6330 deletions(-)
 delete mode 100644 include/flang/Optimizer/Dialect/CMakeLists.txt
 delete mode 100644 include/flang/Optimizer/Dialect/FIRAttr.h
 delete mode 100644 include/flang/Optimizer/Dialect/FIRDialect.h
 delete mode 100644 include/flang/Optimizer/Dialect/FIROps.h
 delete mode 100644 include/flang/Optimizer/Dialect/FIROps.td
 delete mode 100644 include/flang/Optimizer/Dialect/FIROpsSupport.h
 delete mode 100644 include/flang/Optimizer/Dialect/FIRType.h
 delete mode 100644 include/flang/Optimizer/Support/KindMapping.h
 delete mode 100644 lib/Optimizer/CMakeLists.txt
 delete mode 100644 lib/Optimizer/Dialect/FIRAttr.cpp
 delete mode 100644 lib/Optimizer/Dialect/FIRDialect.cpp
 delete mode 100644 lib/Optimizer/Dialect/FIROps.cpp
 delete mode 100644 lib/Optimizer/Dialect/FIRType.cpp
 delete mode 100644 lib/Optimizer/Support/CMakeLists.txt
 delete mode 100644 lib/Optimizer/Support/KindMapping.cpp

diff --git a/include/flang/Optimizer/Dialect/CMakeLists.txt b/include/flang/Optimizer/Dialect/CMakeLists.txt
deleted file mode 100644
index f83cb8f522a3..000000000000
--- a/include/flang/Optimizer/Dialect/CMakeLists.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-# This replicates part of the add_mlir_dialect cmake function from MLIR that
-# cannot be used her because it expects to be run inside MLIR directory which
-# is not the case for FIR.
-set(LLVM_TARGET_DEFINITIONS FIROps.td)
-mlir_tablegen(FIROps.h.inc -gen-op-decls)
-mlir_tablegen(FIROps.cpp.inc -gen-op-defs)
-add_public_tablegen_target(FIROpsIncGen)
-
-add_custom_target(flang-doc)
-set(dialect_doc_filename "FIRLangRef")
-
-set(LLVM_TARGET_DEFINITIONS FIROps.td)
-tablegen(MLIR ${dialect_doc_filename}.md -gen-op-doc "-I${MLIR_MAIN_SRC_DIR}" "-I${MLIR_INCLUDE_DIR}")
-set(GEN_DOC_FILE ${FLANG_BINARY_DIR}/docs/Dialect/${dialect_doc_filename}.md)
-add_custom_command(
-        OUTPUT ${GEN_DOC_FILE}
-        COMMAND ${CMAKE_COMMAND} -E copy
-                ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md
-                ${GEN_DOC_FILE}
-        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md)
-add_custom_target(${dialect_doc_filename}DocGen DEPENDS ${GEN_DOC_FILE})
-add_dependencies(flang-doc ${dialect_doc_filename}DocGen)
diff --git a/include/flang/Optimizer/Dialect/FIRAttr.h b/include/flang/Optimizer/Dialect/FIRAttr.h
deleted file mode 100644
index 57ce5f13bf65..000000000000
--- a/include/flang/Optimizer/Dialect/FIRAttr.h
+++ /dev/null
@@ -1,166 +0,0 @@
-//===-- Optimizer/Dialect/FIRAttr.h -- FIR attributes -----------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPTIMIZER_DIALECT_FIRATTR_H
-#define OPTIMIZER_DIALECT_FIRATTR_H
-
-#include "mlir/IR/Attributes.h"
-
-namespace mlir {
-class DialectAsmParser;
-class DialectAsmPrinter;
-} // namespace mlir
-
-namespace fir {
-
-class FIROpsDialect;
-
-namespace detail {
-struct RealAttributeStorage;
-struct TypeAttributeStorage;
-} // namespace detail
-
-enum AttributeKind {
-  FIR_ATTR = mlir::Attribute::FIRST_FIR_ATTR,
-  FIR_EXACTTYPE, // instance_of, precise type relation
-  FIR_SUBCLASS,  // subsumed_by, is-a (subclass) relation
-  FIR_POINT,
-  FIR_CLOSEDCLOSED_INTERVAL,
-  FIR_OPENCLOSED_INTERVAL,
-  FIR_CLOSEDOPEN_INTERVAL,
-  FIR_REAL_ATTR,
-};
-
-class ExactTypeAttr
-    : public mlir::Attribute::AttrBase<ExactTypeAttr, mlir::Attribute,
-                                       detail::TypeAttributeStorage> {
-public:
-  using Base::Base;
-  using ValueType = mlir::Type;
-
-  static constexpr llvm::StringRef getAttrName() { return "instance"; }
-  static ExactTypeAttr get(mlir::Type value);
-
-  mlir::Type getType() const;
-
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() { return AttributeKind::FIR_EXACTTYPE; }
-};
-
-class SubclassAttr
-    : public mlir::Attribute::AttrBase<SubclassAttr, mlir::Attribute,
-                                       detail::TypeAttributeStorage> {
-public:
-  using Base::Base;
-  using ValueType = mlir::Type;
-
-  static constexpr llvm::StringRef getAttrName() { return "subsumed"; }
-  static SubclassAttr get(mlir::Type value);
-
-  mlir::Type getType() const;
-
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() { return AttributeKind::FIR_SUBCLASS; }
-};
-
-// Attributes for building SELECT CASE multiway branches
-
-/// A closed interval (including the bound values) is an interval with both an
-/// upper and lower bound as given as ssa-values.
-/// A case selector of `CASE (n:m)` corresponds to any value from `n` to `m` and
-/// is encoded as `#fir.interval, %n, %m`.
-class ClosedIntervalAttr
-    : public mlir::Attribute::AttrBase<ClosedIntervalAttr> {
-public:
-  using Base::Base;
-
-  static constexpr llvm::StringRef getAttrName() { return "interval"; }
-  static ClosedIntervalAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() {
-    return AttributeKind::FIR_CLOSEDCLOSED_INTERVAL;
-  }
-};
-
-/// An upper bound is an open interval (including the bound value) as given as
-/// an ssa-value.
-/// A case selector of `CASE (:m)` corresponds to any value up to and including
-/// `m` and is encoded as `#fir.upper, %m`.
-class UpperBoundAttr : public mlir::Attribute::AttrBase<UpperBoundAttr> {
-public:
-  using Base::Base;
-
-  static constexpr llvm::StringRef getAttrName() { return "upper"; }
-  static UpperBoundAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() {
-    return AttributeKind::FIR_OPENCLOSED_INTERVAL;
-  }
-};
-
-/// A lower bound is an open interval (including the bound value) as given as
-/// an ssa-value.
-/// A case selector of `CASE (n:)` corresponds to any value down to and
-/// including `n` and is encoded as `#fir.lower, %n`.
-class LowerBoundAttr : public mlir::Attribute::AttrBase<LowerBoundAttr> {
-public:
-  using Base::Base;
-
-  static constexpr llvm::StringRef getAttrName() { return "lower"; }
-  static LowerBoundAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() {
-    return AttributeKind::FIR_CLOSEDOPEN_INTERVAL;
-  }
-};
-
-/// A pointer interval is a closed interval as given as an ssa-value. The
-/// interval contains exactly one value.
-/// A case selector of `CASE (p)` corresponds to exactly the value `p` and is
-/// encoded as `#fir.point, %p`.
-class PointIntervalAttr : public mlir::Attribute::AttrBase<PointIntervalAttr> {
-public:
-  using Base::Base;
-
-  static constexpr llvm::StringRef getAttrName() { return "point"; }
-  static PointIntervalAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() { return AttributeKind::FIR_POINT; }
-};
-
-/// A real attribute is used to workaround MLIR's default parsing of a real
-/// constant.
-/// `#fir.real<10, 3.14>` is used to introduce a real constant of value `3.14`
-/// with a kind of `10`.
-class RealAttr
-    : public mlir::Attribute::AttrBase<RealAttr, mlir::Attribute,
-                                       detail::RealAttributeStorage> {
-public:
-  using Base::Base;
-  using ValueType = std::pair<int, llvm::APFloat>;
-
-  static constexpr llvm::StringRef getAttrName() { return "real"; }
-  static RealAttr get(mlir::MLIRContext *ctxt, const ValueType &key);
-
-  int getFKind() const;
-  llvm::APFloat getValue() const;
-
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() { return AttributeKind::FIR_REAL_ATTR; }
-};
-
-mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
-                                  mlir::DialectAsmParser &parser,
-                                  mlir::Type type);
-
-void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
-                       mlir::DialectAsmPrinter &p);
-
-} // namespace fir
-
-#endif // OPTIMIZER_DIALECT_FIRATTR_H
diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
deleted file mode 100644
index 7a8fc18937fc..000000000000
--- a/include/flang/Optimizer/Dialect/FIRDialect.h
+++ /dev/null
@@ -1,92 +0,0 @@
-//===-- Optimizer/Dialect/FIRDialect.h -- FIR dialect -----------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPTIMIZER_DIALECT_FIRDIALECT_H
-#define OPTIMIZER_DIALECT_FIRDIALECT_H
-
-#include "mlir/IR/Dialect.h"
-#include "mlir/InitAllDialects.h"
-#include "mlir/InitAllPasses.h"
-
-namespace llvm {
-class raw_ostream;
-class StringRef;
-} // namespace llvm
-
-namespace mlir {
-class Attribute;
-class DialectAsmParser;
-class DialectAsmPrinter;
-class Location;
-class MLIRContext;
-class Type;
-} // namespace mlir
-
-namespace fir {
-
-/// FIR dialect
-class FIROpsDialect final : public mlir::Dialect {
-public:
-  explicit FIROpsDialect(mlir::MLIRContext *ctx);
-  virtual ~FIROpsDialect();
-
-  static llvm::StringRef getDialectNamespace() { return "fir"; }
-
-  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
-  void printType(mlir::Type ty, mlir::DialectAsmPrinter &p) const override;
-
-  mlir::Attribute parseAttribute(mlir::DialectAsmParser &parser,
-                                 mlir::Type type) const override;
-  void printAttribute(mlir::Attribute attr,
-                      mlir::DialectAsmPrinter &p) const override;
-};
-
-/// Register the dialect with MLIR
-inline void registerFIR() {
-  // we want to register exactly once
-  [[maybe_unused]] static bool init_once = [] {
-    mlir::registerDialect<mlir::AffineDialect>();
-    mlir::registerDialect<mlir::LLVM::LLVMDialect>();
-    mlir::registerDialect<mlir::loop::LoopOpsDialect>();
-    mlir::registerDialect<mlir::StandardOpsDialect>();
-    mlir::registerDialect<mlir::vector::VectorDialect>();
-    mlir::registerDialect<FIROpsDialect>();
-    return true;
-  }();
-}
-
-/// Register the standard passes we use. This comes from registerAllPasses(),
-/// but is a smaller set since we aren't using many of the passes found there.
-inline void registerGeneralPasses() {
-  mlir::createCanonicalizerPass();
-  mlir::createCSEPass();
-  mlir::createSuperVectorizePass({});
-  mlir::createLoopUnrollPass();
-  mlir::createLoopUnrollAndJamPass();
-  mlir::createSimplifyAffineStructuresPass();
-  mlir::createLoopFusionPass();
-  mlir::createLoopInvariantCodeMotionPass();
-  mlir::createAffineLoopInvariantCodeMotionPass();
-  mlir::createPipelineDataTransferPass();
-  mlir::createLowerAffinePass();
-  mlir::createLoopTilingPass(0);
-  mlir::createLoopCoalescingPass();
-  mlir::createAffineDataCopyGenerationPass(0, 0);
-  mlir::createMemRefDataFlowOptPass();
-  mlir::createStripDebugInfoPass();
-  mlir::createPrintOpStatsPass();
-  mlir::createInlinerPass();
-  mlir::createSymbolDCEPass();
-  mlir::createLocationSnapshotPass({});
-}
-
-inline void registerFIRPasses() { registerGeneralPasses(); }
-
-} // namespace fir
-
-#endif // OPTIMIZER_DIALECT_FIRDIALECT_H
diff --git a/include/flang/Optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
deleted file mode 100644
index f5763693f7bb..000000000000
--- a/include/flang/Optimizer/Dialect/FIROps.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//===-- Optimizer/Dialect/FIROps.h - FIR operations -------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPTIMIZER_DIALECT_FIROPS_H
-#define OPTIMIZER_DIALECT_FIROPS_H
-
-#include "mlir/Dialect/StandardOps/IR/Ops.h"
-
-using namespace mlir;
-
-namespace fir {
-
-class FirEndOp;
-class LoopOp;
-class RealAttr;
-
-void buildCmpFOp(mlir::Builder *builder, mlir::OperationState &result,
-                 mlir::CmpFPredicate predicate, mlir::Value lhs,
-                 mlir::Value rhs);
-void buildCmpCOp(mlir::Builder *builder, mlir::OperationState &result,
-                 mlir::CmpFPredicate predicate, mlir::Value lhs,
-                 mlir::Value rhs);
-unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
-                               unsigned dest);
-LoopOp getForInductionVarOwner(mlir::Value val);
-bool isReferenceLike(mlir::Type type);
-mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);
-mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result);
-mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result);
-mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
-                                mlir::OperationState &result,
-                                mlir::OpAsmParser::OperandType &selector,
-                                mlir::Type &type);
-
-#define GET_OP_CLASSES
-#include "flang/Optimizer/Dialect/FIROps.h.inc"
-
-} // namespace fir
-
-#endif // OPTIMIZER_DIALECT_FIROPS_H
diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
deleted file mode 100644
index 9d503928b25d..000000000000
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ /dev/null
@@ -1,2748 +0,0 @@
-//===-- FIROps.td - FIR operation definitions --------------*- tablegen -*-===//
-//
-// 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
-/// Definition of the FIR dialect operations
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef FIR_DIALECT_FIR_OPS
-#define FIR_DIALECT_FIR_OPS
-
-include "mlir/Interfaces/ControlFlowInterfaces.td"
-include "mlir/Interfaces/SideEffects.td"
-
-def fir_Dialect : Dialect {
-  let name = "fir";
-}
-
-// Types and predicates
-
-def fir_Type : Type<CPred<"fir::isa_fir_or_std_type($_self)">,
-    "FIR dialect type">;
-
-// Fortran intrinsic types
-def fir_CharacterType : Type<CPred<"$_self.isa<fir::CharacterType>()">,
-    "FIR character type">;
-def fir_ComplexType : Type<CPred<"$_self.isa<fir::CplxType>()">,
-    "FIR complex type">;
-def fir_IntegerType : Type<CPred<"$_self.isa<fir::IntType>()">,
-    "FIR integer type">;
-def fir_LogicalType : Type<CPred<"$_self.isa<fir::LogicalType>()">,
-    "FIR logical type">;
-def fir_RealType : Type<CPred<"$_self.isa<fir::RealType>()">,
-    "FIR real type">;
-
-// Generalized FIR and standard dialect types representing intrinsic types
-def AnyIntegerLike : TypeConstraint<Or<[SignlessIntegerLike.predicate,
-    fir_IntegerType.predicate]>, "any integer">;
-def AnyLogicalLike : TypeConstraint<Or<[BoolLike.predicate,
-    fir_LogicalType.predicate]>, "any logical">;
-def AnyRealLike : TypeConstraint<Or<[FloatLike.predicate,
-    fir_RealType.predicate]>, "any real">;
-def AnyIntegerType : Type<AnyIntegerLike.predicate, "any integer">;
-
-// Fortran derived (user defined) type
-def fir_RecordType : Type<CPred<"$_self.isa<fir::RecordType>()">,
-    "FIR derived type">;
-
-// Fortran array attribute
-def fir_SequenceType : Type<CPred<"$_self.isa<fir::SequenceType>()">,
-    "array type">;
-
-// Composable types
-def AnyCompositeLike : TypeConstraint<Or<[fir_RecordType.predicate,
-    fir_SequenceType.predicate, fir_ComplexType.predicate,
-    IsTupleTypePred]>, "any composite">;
-
-// Reference to an entity type
-def fir_ReferenceType : Type<CPred<"$_self.isa<fir::ReferenceType>()">,
-    "reference type">;
-
-// Reference to an ALLOCATABLE attribute type
-def fir_HeapType : Type<CPred<"$_self.isa<fir::HeapType>()">,
-    "allocatable type">;
-
-// Reference to a POINTER attribute type
-def fir_PointerType : Type<CPred<"$_self.isa<fir::PointerType>()">,
-    "pointer type">;
-
-// Reference types
-def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
-    fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
-
-// A descriptor tuple (captures a reference to an entity and other information)
-def fir_BoxType : Type<CPred<"$_self.isa<fir::BoxType>()">, "box type">;
-
-// CHARACTER type descriptor. A pair of a data reference and a LEN value.
-def fir_BoxCharType : Type<CPred<"$_self.isa<fir::BoxCharType>()">,
-    "box character type">;
-
-// PROCEDURE POINTER descriptor. A pair that can capture a host closure.
-def fir_BoxProcType : Type<CPred<"$_self.isa<fir::BoxProcType>()">,
-    "box procedure type">;
-
-def AnyBoxLike : TypeConstraint<Or<[fir_BoxType.predicate,
-    fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
-
-def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
-    fir_HeapType.predicate, fir_PointerType.predicate, fir_BoxType.predicate]>,
-    "any reference or box">;
-
-// A vector of Fortran triple notation describing a multidimensional array
-def fir_DimsType : Type<CPred<"$_self.isa<fir::DimsType>()">, "dim type">;
-def AnyEmboxLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
-    Index.predicate, fir_IntegerType.predicate, fir_DimsType.predicate]>,
-    "any legal embox argument type">;
-def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;
-
-// A type descriptor's type
-def fir_TypeDescType : Type<CPred<"$_self.isa<fir::TypeDescType>()">,
-    "type desc type">;
-
-// A field (in a RecordType) argument's type
-def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
-
-// A LEN parameter (in a RecordType) argument's type
-def fir_LenType : Type<CPred<"$_self.isa<fir::LenType>()">,
-    "LEN parameter type">;
-
-def AnyComponentLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
-    Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate]>,
-    "any coordinate index">;
-def AnyComponentType : Type<AnyComponentLike.predicate, "coordinate type">;
-
-def AnyCoordinateLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
-    Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate,
-    fir_LenType.predicate]>, "any coordinate index">;
-def AnyCoordinateType : Type<AnyCoordinateLike.predicate, "coordinate type">;
-
-// Base class for FIR operations.
-// All operations automatically get a prefix of "fir.".
-class fir_Op<string mnemonic, list<OpTrait> traits>
-  : Op<fir_Dialect, mnemonic, traits>;
-
-// Base class for FIR operations that take a single argument
-class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
-  : fir_Op<mnemonic, traits> {
-
-  let assemblyFormat = [{
-    operands attr-dict `:` functional-type(operands, results)
-  }];
-}
-
-// Base builder for allocate operations
-def fir_AllocateOpBuilder : OpBuilder<
-  "Builder *builder, OperationState &result, Type inType,"
-  "ValueRange lenParams = {}, ValueRange sizes = {},"
-  "ArrayRef<NamedAttribute> attributes = {}",
-  [{
-    result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", TypeAttr::get(inType));
-    result.addOperands(sizes);
-    result.addAttributes(attributes);
-  }]>;
-
-def fir_NamedAllocateOpBuilder : OpBuilder<
-  "Builder *builder, OperationState &result, Type inType, StringRef name,"
-  "ValueRange lenParams = {}, ValueRange sizes = {},"
-  "ArrayRef<NamedAttribute> attributes = {}",
-  [{
-    result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", TypeAttr::get(inType));
-    result.addAttribute("name", builder->getStringAttr(name));
-    result.addOperands(sizes);
-    result.addAttributes(attributes);
-  }]>;
-
-def fir_OneResultOpBuilder : OpBuilder<
-  "Builder *, OperationState &result, Type resultType,"
-  "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
-  [{
-    if (resultType)
-      result.addTypes(resultType);
-    result.addOperands(operands);
-    result.addAttributes(attributes);
-  }]>;
-
-// Base class of FIR operations that return 1 result
-class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
-  let builders = [fir_OneResultOpBuilder];
-}
-
-// Base class of FIR operations that have 1 argument and return 1 result
-class fir_SimpleOneResultOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_SimpleOp<mnemonic, traits> {
-  let builders = [fir_OneResultOpBuilder];
-}
-
-class fir_TwoBuilders<OpBuilder b1, OpBuilder b2> {
-  list<OpBuilder> builders = [b1, b2];
-}
-
-class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
-  let arguments = (ins
-    OptionalAttr<StrAttr>:$name,
-    OptionalAttr<BoolAttr>:$target
-  );
-}
-
-class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
-    fir_AllocatableBaseOp<mnemonic, !listconcat([NoSideEffect], traits)>,
-    fir_TwoBuilders<fir_AllocateOpBuilder, fir_NamedAllocateOpBuilder>,
-    Arguments<(ins TypeAttr:$in_type, Variadic<AnyIntegerType>:$args)> {
-
-  let parser = [{
-    mlir::Type intype;
-    if (parser.parseType(intype))
-      return mlir::failure();
-    auto &builder = parser.getBuilder();
-    result.addAttribute(inType(), mlir::TypeAttr::get(intype));
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
-    llvm::SmallVector<mlir::Type, 8> typeVec;
-    bool hasOperands = false;
-    if (!parser.parseOptionalLParen()) {
-      // parse the LEN params of the derived type. (<params> : <types>)
-      if (parser.parseOperandList(operands,
-                                  mlir::OpAsmParser::Delimiter::None) ||
-          parser.parseColonTypeList(typeVec) ||
-          parser.parseRParen())
-        return mlir::failure();
-      auto lens = builder.getI32IntegerAttr(operands.size());
-      result.addAttribute(lenpName(), lens);
-      hasOperands = true;
-    }
-    if (!parser.parseOptionalComma()) {
-      // parse size to scale by, vector of n dimensions of type index
-      auto opSize = operands.size();
-      if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None))
-        return mlir::failure();
-      for (auto i = opSize, end = operands.size(); i != end; ++i)
-        typeVec.push_back(builder.getIndexType());
-      hasOperands = true;
-    }
-    if (hasOperands &&
-        parser.resolveOperands(operands, typeVec, parser.getNameLoc(),
-                               result.operands))
-      return mlir::failure();
-    mlir::Type restype = wrapResultType(intype);
-    if (!restype) {
-      parser.emitError(parser.getNameLoc(), "invalid allocate type: ")
-          << intype;
-      return mlir::failure();
-    }
-    if (parser.parseOptionalAttrDict(result.attributes) ||
-        parser.addTypeToList(restype, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr(inType());
-    if (hasLenParams()) {
-      // print the LEN parameters to a derived type in parens
-      p << '(';
-      p.printOperands(getLenParams());
-      p << " : ";
-      mlir::interleaveComma(getLenParams(), p.getStream(),
-                            [&](const auto &opnd) {
-                                p.printType(opnd.getType());
-                            });
-      p << ')';
-    }
-    // print the shape of the allocation (if any); all must be index type
-    for (auto sh : getShapeOperands()) {
-      p << ", ";
-      p.printOperand(sh);
-    }
-    p.printOptionalAttrDict(getAttrs(), {inType(), lenpName()});
-  }];
-
-  string extraAllocClassDeclaration = [{
-    static constexpr llvm::StringRef inType() { return "in_type"; }
-    static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
-    mlir::Type getAllocatedType();
-    bool hasLenParams() { return bool{getAttr(lenpName())}; }
-    unsigned numLenParams() {
-      if (auto val = getAttrOfType<mlir::IntegerAttr>(lenpName()))
-        return val.getInt();
-      return 0;
-    }
-    operand_range getLenParams() {
-      return {operand_begin(), operand_begin() + numLenParams()};
-    }
-    operand_range getShapeOperands() {
-      return {operand_begin() + numLenParams(), operand_end()};
-    }
-    static mlir::Type getRefTy(mlir::Type ty);
-
-    /// Get the input type of the allocation
-    mlir::Type getInType() {
-      return getAttrOfType<mlir::TypeAttr>(inType()).getValue();
-    }
-  }];
-
-  // Verify checks common to all allocation operations
-  string allocVerify = [{
-    llvm::SmallVector<llvm::StringRef, 8> visited;
-    if (verifyInType(getInType(), visited))
-      return emitOpError("invalid type for allocation");
-    if (verifyRecordLenParams(getInType(), numLenParams()))
-      return emitOpError("LEN params do not correspond to type");
-  }];
-}
-
-// Memory SSA operations
-
-def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
-  let summary = "allocate storage for a temporary on the stack given a type";
-  let description = [{
-    This primitive operation is used to allocate an object on the stack.  A
-    reference to the object of type `!fir.ref<T>` is returned.  The returned
-    object has an undefined/uninitialized state.  The allocation can be given
-    an optional name.  The allocation may have a dynamic repetition count
-    for allocating a sequence of locations for the specified type.
-
-    ```mlir
-      %c = ... : i64
-      %x = fir.alloca i32
-      %y = fir.alloca !fir.array<8 x i64>
-      %z = fir.alloca f32, %c
-
-      %i = ... : i16
-      %j = ... : i32
-      %w = fir.alloca !fir.type<PT(len1:i16, len2:i32)> (%i, %j : i16, i32)
-    ```
-
-    Note that in the case of `%z`, a contiguous block of memory is allocated
-    and its size is a runtime multiple of a 32-bit REAL value.
-
-    In the case of `%w`, the arguments `%i` and `%j` are LEN parameters
-    (`len1`, `len2`) to the type `PT`.
-
-    Finally, the operation is undefined if the ssa-value `%c` is negative.
-  }];
-
-  let results = (outs fir_ReferenceType);
-
-  let verifier = allocVerify#[{
-    mlir::Type outType = getType();
-    if (!outType.isa<fir::ReferenceType>())
-      return emitOpError("must be a !fir.ref type");
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = extraAllocClassDeclaration#[{
-    static mlir::Type wrapResultType(mlir::Type intype);
-  }];
-}
-
-def fir_LoadOp : fir_OneResultOp<"load", []> {
-  let summary = "load a value from a memory reference";
-  let description = [{
-    Load a value from a memory reference into an ssa-value (virtual register).
-    Produces an immutable ssa-value of the referent type. A memory reference
-    has type `!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
-
-    ```mlir
-      %a = fir.alloca i32
-      %l = fir.load %a : !fir.ref<i32>
-    ```
-
-    The ssa-value has an undefined value if the memory reference is undefined
-    or null.
-  }];
-
-  let arguments = (ins AnyReferenceLike:$memref);
-
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, Value refVal",
-    [{
-      if (!refVal) {
-        mlir::emitError(result.location, "LoadOp has null argument");
-        return;
-      }
-      auto refTy = refVal.getType().cast<fir::ReferenceType>();
-      result.addOperands(refVal);
-      result.addTypes(refTy.getEleTy());
-    }]
-  >];
-
-  let parser = [{
-    mlir::Type type;
-    mlir::OpAsmParser::OperandType oper;
-    if (parser.parseOperand(oper) ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperand(oper, type, result.operands))
-       return mlir::failure();
-    mlir::Type eleTy;
-    if (getElementOf(eleTy, type) ||
-        parser.addTypeToList(eleTy, result.types))
-       return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(memref());
-    p.printOptionalAttrDict(getAttrs(), {});
-    p << " : " << memref().getType();
-  }];
-
-  let extraClassDeclaration = [{
-    static mlir::ParseResult getElementOf(mlir::Type &ele, mlir::Type ref);
-  }];
-}
-
-def fir_StoreOp : fir_Op<"store", []> {
-  let summary = "store an SSA-value to a memory location";
-
-  let description = [{
-    Store an ssa-value (virtual register) to a memory reference.  The stored
-    value must be of the same type as the referent type of the memory
-    reference.
-
-    ```mlir
-      %v = ... : f64
-      %p = ... : !fir.ptr<f64>
-      fir.store %v to %p : !fir.ptr<f64>
-    ```
-
-    The above store changes the value to which the pointer is pointing and not
-    the pointer itself. The operation is undefined if the memory reference,
-    `%p`, is undefined or null.
-  }];
-
-  let arguments = (ins AnyType:$value, AnyReferenceLike:$memref);
-
-  let parser = [{
-    mlir::Type type;
-    mlir::OpAsmParser::OperandType oper;
-    mlir::OpAsmParser::OperandType store;
-    if (parser.parseOperand(oper) ||
-        parser.parseKeyword("to") ||
-        parser.parseOperand(store) ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperand(oper, elementType(type),
-          result.operands) ||
-        parser.resolveOperand(store, type, result.operands))
-       return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(value());
-    p << " to ";
-    p.printOperand(memref());
-    p.printOptionalAttrDict(getAttrs(), {});
-    p << " : " << memref().getType();
-  }];
-
-  let verifier = [{
-    if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
-      return emitOpError("store value type must match memory reference type");
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = [{
-    static mlir::Type elementType(mlir::Type refType);
-  }];
-}
-
-def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
-  let summary = "explicit undefined value of some type";
-  let description = [{
-    Constructs an ssa-value of the specified type with an undefined value.
-    This operation is typically created internally by the mem2reg conversion
-    pass. An undefined value can be of any type except `!fir.ref<T>`.
-
-    ```mlir
-      %a = fir.undefined !fir.array<10 x !fir.type<T>>
-    ```
-
-    The example creates an array shaped ssa value. The array is rank 1, extent
-    10, and each element has type `!fir.type<T>`.
-  }];
-
-  let results = (outs AnyType:$intype);
-
-  let assemblyFormat = "type($intype) attr-dict";
-
-  let verifier = [{
-    if (auto ref = getType().dyn_cast<fir::ReferenceType>())
-      return emitOpError("undefined values of type !fir.ref not allowed");
-    return mlir::success();
-  }];
-}
-
-def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
-  let summary = "allocate storage on the heap for an object of a given type";
-
-  let description = [{
-    Creates a heap memory reference suitable for storing a value of the
-    given type, T.  The heap refernce returned has type `!fir.heap<T>`.
-    The memory object is in an undefined state.  `allocmem` operations must
-    be paired with `freemem` operations to avoid memory leaks.
-
-    ```mlir
-      %0 = fir.allocmem !fir.array<10 x f32>
-      fir.freemem %0 : !fir.heap<!fir.array<10 x f32>>
-    ```
-  }];
-
-  let results = (outs fir_HeapType);
-
-  let verifier = allocVerify#[{
-    mlir::Type outType = getType();
-    if (!outType.dyn_cast<fir::HeapType>())
-      return emitOpError("must be a !fir.heap type");
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = extraAllocClassDeclaration#[{
-    static mlir::Type wrapResultType(mlir::Type intype);
-  }];
-}
-
-def fir_FreeMemOp : fir_Op<"freemem", []> {
-  let summary = "free a heap object";
-
-  let description = [{
-    Deallocates a heap memory reference that was allocated by an `allocmem`.
-    The memory object that is deallocated is placed in an undefined state
-    after `fir.freemem`.  Optimizations may treat the loading of an object
-    in the undefined state as undefined behavior.  This includes aliasing
-    references, such as the result of an `fir.embox`.
-
-    ```mlir
-      %21 = fir.allocmem !fir.type<ZT(p:i32){field:i32}>
-      ...
-      fir.freemem %21 : !fir.heap<!fir.type<ZT>>
-    ```
-  }];
-
-  let arguments = (ins fir_HeapType:$heapref);
-
-  let assemblyFormat = "$heapref attr-dict `:` type($heapref)";
-}
-
-//===----------------------------------------------------------------------===//// Terminator operations
-//===----------------------------------------------------------------------===//
-
-class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_Op<mnemonic, !listconcat(traits, [AttrSizedOperandSegments,
-    DeclareOpInterfaceMethods<BranchOpInterface>, Terminator])> {
-
-  let arguments = (ins
-    AnyType:$selector,
-    Variadic<AnyType>:$compareArgs,
-    Variadic<AnyType>:$targetArgs
-  );
-
-  let results = (outs);
-
-  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
-
-  let builders = [OpBuilder<
-    "Builder *, OperationState &result, Value selector,"
-    "ValueRange properOperands, ArrayRef<Block *> destinations,"
-    "ArrayRef<ValueRange> operands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}",
-    [{
-      result.addOperands(selector);
-      result.addOperands(properOperands);
-      for (auto kvp : llvm::zip(destinations, operands)) {
-        result.addSuccessors(std::get<0>(kvp));
-        result.addOperands(std::get<1>(kvp));
-      }
-      result.addAttributes(attributes);
-    }]
-  >];
-
-  string extraSwitchClassDeclaration = [{
-    using Conditions = mlir::Value;
-
-    static constexpr llvm::StringRef getCasesAttr() { return "case_tags"; }
-
-    // The number of destination conditions that may be tested
-    unsigned getNumConditions() { return getNumDest(); }
-
-    // The selector is the value being tested to determine the destination
-    mlir::Value getSelector() { return selector(); }
-    mlir::Value getSelector(llvm::ArrayRef<mlir::Value> operands) {
-      return operands[0];
-    }
-
-    // The number of blocks that may be branched to
-    unsigned getNumDest() { return getOperation()->getNumSuccessors(); }
-
-    llvm::Optional<mlir::OperandRange> getCompareOperands(unsigned cond);
-    llvm::Optional<llvm::ArrayRef<mlir::Value>> getCompareOperands(
-        llvm::ArrayRef<mlir::Value> operands, unsigned cond);
-
-    llvm::Optional<llvm::ArrayRef<mlir::Value>> getSuccessorOperands(
-        llvm::ArrayRef<mlir::Value> operands, unsigned cond);
-
-    // Helper function to deal with Optional operand forms
-    void printSuccessorAtIndex(mlir::OpAsmPrinter &p, unsigned i) {
-      auto *succ = getSuccessor(i);
-      auto ops = getSuccessorOperands(i);
-      if (ops.hasValue())
-        p.printSuccessorAndUseList(succ, ops.getValue());
-      else
-        p.printSuccessor(succ);
-    }
-  }];
-}
-
-class fir_IntegralSwitchTerminatorOp<string mnemonic,
-    list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
-
-  let parser = [{
-    mlir::OpAsmParser::OperandType selector;
-    mlir::Type type;
-    if (parseSelector(parser, result, selector, type))
-      return mlir::failure();
-
-    llvm::SmallVector<mlir::Attribute, 8> ivalues;
-    llvm::SmallVector<mlir::Block *, 8> dests;
-    llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
-    while (true) {
-      mlir::Attribute ivalue; // Integer or Unit
-      mlir::Block *dest;
-      llvm::SmallVector<mlir::Value, 8> destArg;
-      llvm::SmallVector<mlir::NamedAttribute, 1> temp;
-      if (parser.parseAttribute(ivalue, "i", temp) ||
-          parser.parseComma() ||
-          parser.parseSuccessorAndUseList(dest, destArg))
-        return mlir::failure();
-      ivalues.push_back(ivalue);
-      dests.push_back(dest);
-      destArgs.push_back(destArg);
-      if (!parser.parseOptionalRSquare())
-        break;
-      if (parser.parseComma())
-        return mlir::failure();
-    }
-    auto &bld = parser.getBuilder();
-    result.addAttribute(getCasesAttr(), bld.getArrayAttr(ivalues));
-    llvm::SmallVector<int32_t, 8> argOffs;
-    int32_t sumArgs = 0;
-    const auto count = dests.size();
-    for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
-      result.addSuccessors(dests[i]);
-      result.addOperands(destArgs[i]);
-      auto argSize = destArgs[i].size();
-      argOffs.push_back(argSize);
-      sumArgs += argSize;
-    }
-    result.addAttribute(getOperandSegmentSizeAttr(),
-                        bld.getI32VectorAttr({1, 0, sumArgs}));
-    result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(getSelector());
-    p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
-    for (decltype(count) i = 0; i != count; ++i) {
-      if (i)
-        p << ", ";
-      auto &attr = cases[i];
-      if (auto intAttr = attr.dyn_cast_or_null<mlir::IntegerAttr>())
-        p << intAttr.getValue();
-      else
-        p.printAttribute(attr);
-      p << ", ";
-      printSuccessorAtIndex(p, i);
-    }
-    p << ']';
-    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
-        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
-  }];
-
-  let verifier = [{
-    if (!(getSelector().getType().isa<mlir::IntegerType>() ||
-          getSelector().getType().isa<mlir::IndexType>() ||
-          getSelector().getType().isa<fir::IntType>()))
-      return emitOpError("must be an integer");
-    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
-    for (decltype(count) i = 0; i != count; ++i) {
-      auto &attr = cases[i];
-      if (attr.isa<mlir::IntegerAttr>() || attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
-        return emitOpError("invalid case alternative");
-      }
-    }
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = extraSwitchClassDeclaration;
-}
-
-def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
-  let summary = "a multiway branch";
-
-  let description = [{
-    A multiway branch terminator with similar semantics to C's `switch`
-    statement.  A selector value is matched against a list of constants
-    of the same type for a match.  When a match is found, control is
-    transferred to the corresponding basic block.  A `select` must have
-    at least one basic block with a corresponding `unit` match, and
-    that block will be selected when all other conditions fail to match.
-
-    ```mlir
-      fir.select %arg:i32 [1, ^bb1(%0 : i32),
-                           2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
-                          -3, ^bb3(%arg2,%2 : i32,i32),
-                           4, ^bb4(%1 : i32),
-                        unit, ^bb5]
-    ```
-  }];
-}
-
-def fir_SelectRankOp : fir_IntegralSwitchTerminatorOp<"select_rank"> {
-  let summary = "Fortran's SELECT RANK statement";
-
-  let description = [{
-    Similar to `select`, `select_rank` provides a way to express Fortran's
-    SELECT RANK construct.  In this case, the rank of the selector value
-    is matched against constants of integer type.  The structure is the
-    same as `select`, but `select_rank` determines the rank of the selector
-    variable at runtime to determine the best match.
-
-    ```mlir
-      fir.select_rank %arg:i32 [1, ^bb1(%0 : i32),
-                                2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
-                                3, ^bb3(%arg2,%2 : i32,i32),
-                               -1, ^bb4(%1 : i32),
-                             unit, ^bb5]
-    ```
-  }];
-}
-
-def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
-  let summary = "Fortran's SELECT CASE statement";
-
-  let description = [{
-    Similar to `select`, `select_case` provides a way to express Fortran's
-    SELECT CASE construct.  In this case, the selector value is matched
-    against variables (not just constants) and ranges.  The structure is
-    the same as `select`, but `select_case` allows for the expression of
-    more complex match conditions.
-
-    ```mlir
-      fir.select_case %arg : i32 [
-            #fir.point, %0, ^bb1(%0 : i32),
-            #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1 : i32,i32,i32,i32),
-            #fir.interval, %2, %3, ^bb3(%2,%arg2 : i32,i32),
-            #fir.upper, %arg, ^bb4(%1 : i32),
-            unit, ^bb5]
-    ```
-  }];
-
-  let parser = "return parseSelectCase(parser, result);";
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(getSelector());
-    p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
-    for (decltype(count) i = 0; i != count; ++i) {
-      if (i)
-        p << ", ";
-      p << cases[i] << ", ";
-      if (!cases[i].isa<mlir::UnitAttr>()) {
-        auto caseArgs = *getCompareOperands(i);
-        p.printOperand(*caseArgs.begin());
-        p << ", ";
-        if (cases[i].isa<fir::ClosedIntervalAttr>()) {
-          p.printOperand(*(++caseArgs.begin()));
-          p << ", ";
-        }
-      }
-      printSuccessorAtIndex(p, i);
-    }
-    p << ']';
-    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
-        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
-  }];
-
-  let verifier = [{
-    if (!(getSelector().getType().isa<mlir::IntegerType>() ||
-          getSelector().getType().isa<mlir::IndexType>() ||
-          getSelector().getType().isa<fir::IntType>() ||
-          getSelector().getType().isa<fir::LogicalType>() ||
-          getSelector().getType().isa<fir::CharacterType>()))
-      return emitOpError("must be an integer, character, or logical");
-    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
-    for (decltype(count) i = 0; i != count; ++i) {
-      auto &attr = cases[i];
-      if (attr.isa<fir::PointIntervalAttr>() ||
-          attr.isa<fir::LowerBoundAttr>() ||
-          attr.isa<fir::UpperBoundAttr>() ||
-          attr.isa<fir::ClosedIntervalAttr>() ||
-          attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
-        return emitOpError("incorrect select case attribute type");
-      }
-    }
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = extraSwitchClassDeclaration;
-}
-
-def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
-  let summary = "Fortran's SELECT TYPE statement";
-
-  let description = [{
-    Similar to `select`, `select_type` provides a way to express Fortran's
-    SELECT TYPE construct.  In this case, the type of the selector value
-    is matched against a list of type descriptors.  The structure is the
-    same as `select`, but `select_type` determines the type of the selector
-    variable at runtime to determine the best match.
-
-    ```mlir
-      fir.select_type %arg : !fir.box<()> [
-          #fir.instance<!fir.type<type1>>, ^bb1(%0 : i32),
-          #fir.instance<!fir.type<type2>>, ^bb2(%2 : i32),
-          #fir.subsumed<!fir.type<type3>>, ^bb3(%2 : i32),
-          #fir.instance<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
-          unit, ^bb5]
-    ```
-  }];
-
-  let parser = "return parseSelectType(parser, result);";
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(getSelector());
-    p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
-    for (decltype(count) i = 0; i != count; ++i) {
-      if (i)
-        p << ", ";
-      p << cases[i] << ", ";
-      printSuccessorAtIndex(p, i);
-    }
-    p << ']';
-    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
-        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
-  }];
-
-  let verifier = [{
-    if (!(getSelector().getType().isa<fir::BoxType>()))
-      return emitOpError("must be a boxed type");
-    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
-    for (decltype(count) i = 0; i != count; ++i) {
-      auto &attr = cases[i];
-      if (attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
-          attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
-        return emitOpError("invalid type-case alternative");
-      }
-    }
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = extraSwitchClassDeclaration;
-}
-
-def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
-  let summary = "the unreachable instruction";
-
-  let description = [{
-    Terminates a basic block with the assertion that the end of the block
-    will never be reached at runtime.  This instruction can be used
-    immediately after a call to the Fortran runtime to terminate the
-    program, for example.  This instruction corresponds to the LLVM IR
-    instruction `unreachable`.
-
-    ```mlir
-      fir.unreachable
-    ```
-  }];
-
-  let parser = "return mlir::success();";
-
-  let printer = "p << getOperationName();";
-}
-
-def fir_FirEndOp : fir_Op<"end", [Terminator]> {
-  let summary = "the end instruction";
-
-  let description = [{
-    The end terminator is a special terminator used inside various FIR
-    operations that have regions.  End is thus the custom invisible terminator
-    for these operations.  It is implicit and need not appear in the textual
-    representation.
-  }];
-}
-
-def fir_HasValueOp : fir_Op<"has_value", [Terminator, HasParent<"GlobalOp">]> {
-  let summary = "terminator for GlobalOp";
-  let description = [{
-    The terminator for a GlobalOp with a body.
-
-    ```mlir
-      global @variable : tuple<i32, f32> {
-        %0 = constant 45 : i32
-        %1 = constant 100.0 : f32
-        %2 = fir.undefined tuple<i32, f32>
-        %3 = constant 0 : index
-        %4 = fir.insert_value %2, %0, %3 : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
-        %5 = constant 1 : index
-        %6 = fir.insert_value %4, %1, %5 : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
-        fir.has_value %6 : tuple<i32, f32>
-      }
-    ```
-  }];
-
-  let arguments = (ins AnyType:$resval);
-
-  let assemblyFormat = "$resval attr-dict `:` type($resval)";
-}
-
-// Operations on !fir.box<T> type objects
-
-def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
-  let summary = "boxes a given reference and (optional) dimension information";
-
-  let description = [{
-    Create a boxed reference value. In Fortran, the implementation can require
-    extra information about an entity, such as its type, rank, etc.  This
-    auxilliary information is packaged and abstracted as a value with box type
-    by the calling routine. (In Fortran, these are called descriptors.)
-
-    ```mlir
-      %c1 = constant 1 : index
-      %c10 = constant 10 : index
-      %4 = fir.dims(%c1, %c10, %c1) : (index, index, index) -> !fir.dims<1>
-      %5 = ... : !fir.ref<!fir.array<10 x i32>>
-      %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10 x i32>>, !fir.dims<1>) -> !fir.box<!fir.array<10 x i32>>
-    ```
-
-    The descriptor tuple may contain additional implementation-specific
-    information through the use of additional attributes.
-  }];
-
-  let arguments = (ins AnyReferenceLike:$memref, Variadic<AnyEmboxArg>:$args);
-
-  let results = (outs fir_BoxType);
-
-  let parser = "return parseEmboxOp(parser, result);";
-
-  let printer = [{
-    p << getOperationName() << ' ';
-    p.printOperand(memref());
-    if (hasLenParams()) {
-      p << '(';
-      p.printOperands(getLenParams());
-      p << ')';
-    }
-    if (getNumOperands() == 2) {
-      p << ", ";
-      p.printOperands(dims());
-    } else if (auto map = getAttr(layoutName())) {
-      p << " [" << map << ']';
-    }
-    p.printOptionalAttrDict(getAttrs(), {layoutName(), lenpName()});
-    p << " : ";
-    p.printFunctionalType(getOperation());
-  }];
-
-  let verifier = [{
-    if (hasLenParams()) {
-      auto lenParams = numLenParams();
-      auto eleTy = fir::dyn_cast_ptrEleTy(memref().getType());
-      if (!eleTy)
-        return emitOpError("must embox a memory reference type");
-      if (auto rt = eleTy.dyn_cast<fir::RecordType>()) {
-        if (lenParams != rt.getNumLenParams())
-          return emitOpError("number of LEN params does not correspond"
-                             " to the !fir.type type");
-      } else {
-        return emitOpError("LEN parameters require !fir.type type");
-      }
-      for (auto lp : getLenParams())
-        if (lp.getType().isa<fir::DimsType>())
-          return emitOpError("LEN parameters must be integral type");
-    }
-    if (dims().size() == 0) {
-      // Ok. If there is no dims and no layout map, then emboxing a scalar.
-      // TODO: Should the type be enforced? It already must agree.
-    } else if (dims().size() == 1) {
-      auto d = *dims().begin();
-      if (!d.getType().isa<fir::DimsType>())
-        return emitOpError("dimension argument must have !fir.dims type");
-    } else {
-      return emitOpError("embox can only have one !fir.dim argument");
-    }
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef layoutName() { return "layout_map"; }
-    static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
-    bool hasLenParams() { return bool{getAttr(lenpName())}; }
-    unsigned numLenParams() {
-      if (auto x = getAttrOfType<mlir::IntegerAttr>(lenpName()))
-        return x.getInt();
-      return 0;
-    }
-    operand_range getLenParams() {
-      return {operand_begin(), operand_begin() + numLenParams()};
-    }
-    operand_range dims() {
-      return {operand_begin() + numLenParams() + 1, operand_end()};
-    }
-  }];
-}
-
-def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
-  let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
-  let results = (outs fir_BoxCharType);
-
-  let summary = "boxes a given CHARACTER reference and its LEN parameter";
-
-  let description = [{
-    Create a boxed CHARACTER value. The CHARACTER type has the LEN type
-    parameter, the value of which may only be known at runtime.  Therefore,
-    a variable of type CHARACTER has both its data reference as well as a
-    LEN type parameter.
-
-    ```fortran
-      CHARACTER(LEN=10) :: var
-    ```
-    ```mlir
-      %4 = ...         : !fir.ref<!fir.array<10 x !fir.char<1>>>
-      %5 = constant 10 : i32
-      %6 = fir.emboxchar %4, %5 : (!fir.ref<!fir.array<10 x !fir.char<1>>>, i32) -> !fir.boxchar<1>
-    ```
-
-    In the above `%4` is a memory reference to a buffer of 10 CHARACTER units.
-    This buffer and its LEN value (10) are wrapped into a pair in `%6`.
-  }];
-
-  let assemblyFormat = [{
-    $memref `,` $len attr-dict `:` functional-type(operands, results)
-  }];
-
-  let verifier = [{
-    auto eleTy = elementTypeOf(memref().getType());
-    if (!eleTy.dyn_cast<CharacterType>())
-      return mlir::failure();
-    return mlir::success();
-  }];
-}
-
-def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
-
-  let summary = "boxes a given procedure and optional host context";
-
-  let description = [{
-    Creates an abstract encapsulation of a PROCEDURE POINTER along with an
-    optional pointer to a host instance context. If the pointer is not to an
-    internal procedure or the internal procedure does not need a host context
-    then the form takes only the procedure's symbol.
-
-    ```mlir
-      %0 = fir.emboxproc @f : ((i32) -> i32) -> !fir.boxproc<(i32) -> i32>
-    ```
-
-    An internal procedure requiring a host instance for correct execution uses
-    the second form. The closure of the host procedure's state is passed as a
-    reference to a tuple. It is the responsibility of the host to manage the
-    context's values accordingly, up to and including inhibiting register
-    promotion of local values.
-
-    ```mlir
-      %4 = ... : !fir.ref<tuple<i32, i32>>
-      %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) -> !fir.boxproc<(i32) -> i32>
-    ```
-  }];
-
-  let arguments = (ins SymbolRefAttr:$funcname, AnyReferenceLike:$host);
-
-  let results = (outs fir_BoxProcType);
-
-  let parser = [{
-    mlir::SymbolRefAttr procRef;
-    if (parser.parseAttribute(procRef, "funcname", result.attributes))
-      return mlir::failure();
-    bool hasTuple = false;
-    mlir::OpAsmParser::OperandType tupleRef;
-    if (!parser.parseOptionalComma()) {
-      if (parser.parseOperand(tupleRef))
-        return mlir::failure();
-      hasTuple = true;
-    }
-    mlir::FunctionType type;
-    if (parser.parseColon() ||
-        parser.parseLParen() ||
-        parser.parseType(type))
-      return mlir::failure();
-    result.addAttribute("functype", mlir::TypeAttr::get(type));
-    if (hasTuple) {
-      mlir::Type tupleType;
-      if (parser.parseComma() ||
-          parser.parseType(tupleType) ||
-          parser.resolveOperand(tupleRef, tupleType, result.operands))
-        return mlir::failure();
-    }
-    mlir::Type boxType;
-    if (parser.parseRParen() ||
-        parser.parseArrow() ||
-        parser.parseType(boxType) ||
-        parser.addTypesToList(boxType, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr("funcname");
-    auto h = host();
-    if (h) {
-      p << ", ";
-      p.printOperand(h);
-    }
-    p << " : (" << getAttr("functype");
-    if (h)
-      p << ", " << h.getType();
-    p << ") -> " << getType();
-  }];
-
-  let verifier = [{
-    // host bindings (optional) must be a reference to a tuple
-    if (auto h = host()) {
-      if (auto r = h.getType().dyn_cast<ReferenceType>()) {
-        if (!r.getEleTy().dyn_cast<mlir::TupleType>())
-          return mlir::failure();
-      } else {
-        return mlir::failure();
-      }
-    }
-    return mlir::success();
-  }];
-}
-
-def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
-  let summary = "unbox the boxed value into a tuple value";
-
-  let description = [{
-    Unbox a boxed value into a result of multiple values from the box's
-    component data.  The values are, minimally, a reference to the data of the
-    entity, the byte-size of one element, the rank, the type descriptor, a set
-    of flags (packed in an integer, and an array of dimension information (of
-    size rank).
-
-    ```mlir
-      %40   = ... : !fir.box<!fir.type<T>>
-      %41:6 = fir.unbox %40 : (!fir.box<!fir.type<T>>) -> (!fir.ref<!fir.type<T>>, i32, i32, !fir.tdesc<!fir.type<T>>, i32, !fir.dims<4>)
-    ```
-  }];
-
-  let arguments = (ins fir_BoxType:$box);
-
-  let results = (outs
-    fir_ReferenceType,  // pointer to data
-    AnyIntegerLike,     // size of a data element
-    AnyIntegerLike,     // rank of data
-    fir_TypeDescType,   // abstract type descriptor
-    AnyIntegerLike,     // attribute flags (bitfields)
-    fir_DimsType        // dimension information (if any)
-  );
-}
-
-def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]> {
-  let summary = "unbox a boxchar value into a pair value";
-
-  let description = [{
-    Unboxes a value of `boxchar` type into a pair consisting of a memory
-    reference to the CHARACTER data and the LEN type parameter.
-
-    ```mlir
-      %45   = ... : !fir.boxchar<1>
-      %46:2 = fir.unboxchar %45 : (!fir.boxchar<1>) -> (!fir.ref<!fir.character<1>>, i32)
-    ```
-  }];
-
-  let arguments = (ins fir_BoxCharType:$boxchar);
-
-  let results = (outs fir_ReferenceType, AnyIntegerLike);
-}
-
-def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
-  let summary = "unbox a boxproc value into a pair value";
-
-  let description = [{
-    Unboxes a value of `boxproc` type into a pair consisting of a procedure
-    pointer and a pointer to a host context.
-
-    ```mlir
-      %47   = ... : !fir.boxproc<() -> i32>
-      %48:2 = fir.unboxproc %47 : (!fir.ref<() -> i32>, !fir.ref<tuple<f32, i32>>)
-    ```
-  }];
-
-  let verifier = [{
-    if (auto eleTy = fir::dyn_cast_ptrEleTy(refTuple().getType()))
-      if (eleTy.isa<mlir::TupleType>())
-        return mlir::success();
-    return emitOpError("second output argument has bad type");
-  }];
-
-  let arguments = (ins fir_BoxProcType:$boxproc);
-
-  let results = (outs FunctionType, fir_ReferenceType:$refTuple);
-}
-
-def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
-  let summary = "return a memory reference to the boxed value";
-
-  let description = [{
-    This operator is overloaded to work with values of type `box`,
-    `boxchar`, and `boxproc`.  The result for each of these
-    cases, respectively, is the address of the data, the address of the
-    `CHARACTER` data, and the address of the procedure.
-
-    ```mlir
-      %51 = fir.box_addr %box : (!fir.box<f64>) -> !fir.ref<f64>
-      %52 = fir.box_addr %boxchar : (!fir.boxchar<1>) -> !fir.ref<!fir.char<1>>
-      %53 = fir.box_addr %boxproc : (!fir.boxproc<!P>) -> !fir.ref<!P>
-    ```
-  }];
-
-  let arguments = (ins fir_BoxType:$val);
-
-  let results = (outs AnyReferenceLike);
-}
-
-def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
-  let summary = "return the LEN type parameter from a boxchar value";
-
-  let description = [{
-    Extracts the LEN type parameter from a `boxchar` value.
-
-    ```mlir
-      %45 = ... : !boxchar<1>  // CHARACTER(20)
-      %59 = fir.boxchar_len %45 : (!fir.boxchar<1>) -> i64  // len=20
-    ```
-  }];
-
-  let arguments = (ins fir_BoxCharType:$val);
-
-  let results = (outs AnyIntegerLike);
-}
-
-def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
-  let summary = "return the dynamic dimension information for the boxed value";
-
-  let description = [{
-    Returns the triple of lower bound, extent, and stride for `dim` dimension
-    of `val`, which must have a `box` type.  The dimensions are enumerated from
-    left to right from 0 to rank-1. This operation has undefined behavior if
-    `dim` is out of bounds.
-
-    ```mlir
-      %c1   = constant 0 : i32
-      %52:3 = fir.box_dims %40, %c1 : (!fir.box<!fir.array<*:f64>>, i32) -> (i32, i32, i32)
-    ```
-
-    The above is a request to return the left most row (at index 0) triple from
-    the box. The triple will be the lower bound, upper bound, and stride.
-  }];
-
-  let arguments = (ins fir_BoxType:$val, AnyIntegerLike:$dim);
-
-  let results = (outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike);
-
-  let assemblyFormat = [{
-    $val `,` $dim attr-dict `:` functional-type(operands, results)
-  }];
-
-  let extraClassDeclaration = [{
-    mlir::Type getTupleType();
-  }];
-}
-
-def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
-  let summary = "return the size of an element of the boxed value";
-
-  let description = [{
-    Returns the size of an element in an entity of `box` type.  This size may
-    not be known until runtime.
-
-    ```mlir
-      %53 = fir.box_elesize %40 : (!fir.box<f32>, i32) -> i32  // size=4
-      %54 = fir.box_elesize %40 : (!fir.box<!fir.array<*:f32>>, i32) -> i32
-    ```
-
-    In the above example, `%53` may box an array of REAL values while `%54`
-    must box an array of REAL values (with dynamic rank and extent).
-  }];
-
-  let arguments = (ins fir_BoxType:$val);
-
-  let results = (outs AnyIntegerLike);
-}
-
-def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]> {
-  let summary = "is the boxed value an ALLOCATABLE?";
-
-  let description = [{
-    Determine if the boxed value was from an ALLOCATABLE entity. This will
-    return true if the originating box value was from a `fir.embox` op
-    with a mem-ref value that had the type !fir.heap<T>.
-
-    ```mlir
-      %r = ... : !fir.heap<i64>
-      %b = fir.embox %r : (!fir.heap<i64>) -> !fir.box<i64>
-      %a = fir.box_isalloc %b : (!fir.box<i64>) -> i1  // true
-    ```
-
-    The canonical descriptor implementation will carry a flag to record if the
-    variable is an `ALLOCATABLE`.
-  }];
-
-  let arguments = (ins fir_BoxType:$val);
-
-  let results = (outs BoolLike);
-}
-
-def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]> {
-  let summary = "is the boxed value an array?";
-
-  let description = [{
-    Determine if the boxed value has a positive (> 0) rank. This will return
-    true if the originating box value was from a fir.embox with a memory
-    reference value that had the type !fir.array<T> and/or a dims argument.
-
-    ```mlir
-      %r = ... : !fir.ref<i64>
-      %d = fir.gendims(1, 100, 1) : (i32, i32, i32) -> !fir.dims<1>
-      %b = fir.embox %r, %d : (!fir.ref<i64>, !fir.dims<1>) -> !fir.box<i64>
-      %a = fir.box_isarray %b : (!fir.box<i64>) -> i1  // true
-    ```
-  }];
-
-  let arguments = (ins fir_BoxType:$val);
-
-  let results = (outs BoolLike);
-}
-
-def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]> {
-  let summary = "is the boxed value a POINTER?";
-
-  let description = [{
-    Determine if the boxed value was from a POINTER entity.
-
-    ```mlir
-      %p = ... : !fir.ptr<i64>
-      %b = fir.embox %p : (!fir.ptr<i64>) -> !fir.box<i64>
-      %a = fir.box_isptr %b : (!fir.box<i64>) -> i1  // true
-    ```
-  }];
-
-  let arguments = (ins fir_BoxType:$val);
-
-  let results = (outs BoolLike);
-}
-
-def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]> {
-  let summary = "returns the host instance pointer (or null)";
-
-  let description = [{
-    Extract the host context pointer from a boxproc value.
-
-    ```mlir
-      %8 = ... : !fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>
-      %9 = fir.boxproc_host %8 : (!fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>) -> !fir.ref<tuple<i32, i32>>
-    ```
-
-    In the example, the reference to the closure over the host procedure's
-    variables is returned. This allows an internal procedure to access the
-    host's variables. It is up to lowering to determine the contract between
-    the host and the internal procedure.
-  }];
-
-  let arguments = (ins fir_BoxProcType:$val);
-
-  let results = (outs fir_ReferenceType);
-}
-
-def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
-  let summary = "return the number of dimensions for the boxed value";
-
-  let description = [{
-    Return the rank of a value of `box` type.  If the value is scalar, the
-    rank is 0.
-
-    ```mlir
-      %57 = fir.box_rank %40 : (!fir.box<!fir.array<*:f64>>) -> i32
-      %58 = fir.box_rank %41 : (!fir.box<f64>) -> i32
-    ```
-
-    The example `%57` shows how one would determine the rank of an array that
-    has deferred rank at runtime. This rank should be at least 1. In %58, the
-    descriptor may be either an array or a scalar, so the value is nonnegative.
-  }];
-
-  let arguments = (ins fir_BoxType:$val);
-
-  let results = (outs AnyIntegerType);
-}
-
-def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
-  let summary = "return the type descriptor for the boxed value";
-
-  let description = [{
-    Return the opaque type descriptor of a value of `box` type. A type
-    descriptor is an implementation defined value that fully describes a type
-    to the Fortran runtime.
-
-    ```mlir
-      %7 = fir.box_tdesc %41 : (!fir.box<f64>) -> !fir.tdesc<f64>
-    ```
-  }];
-
-  let arguments = (ins fir_BoxType:$val);
-
-  let results = (outs fir_TypeDescType);
-}
-
-// Record and array type operations
-
-def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
-  let summary = "Finds the coordinate (location) of a value in memory";
-
-  let description = [{
-    Compute the internal coordinate address starting from a boxed value or
-    unboxed memory reference. Returns a memory reference. When computing the
-    coordinate of an array element, the rank of the array must be known and
-    the number of indexing expressions must equal the rank of the array.
-
-    This operation will apply the access map from a boxed value implicitly.
-
-    Unlike LLVM's GEP instruction, one cannot stride over the outermost
-    reference; therefore, the leading 0 index must be omitted.
-
-    ```mlir
-      %i = ... : index
-      %h = ... : !fir.heap<!fir.array<?:f32>>
-      %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
-    ```
-
-    In the example, `%p` will be a pointer to the `%i`-th f32 value in the
-    array `%h`.
-  }];
-
-  let arguments = (ins AnyRefOrBox:$ref, Variadic<AnyCoordinateType>:$coor);
-
-  let results = (outs fir_ReferenceType);
-
-  let assemblyFormat = [{
-    operands attr-dict `:` functional-type(operands, results)
-  }];
-
-  let verifier = [{
-    // Recovering a LEN type parameter only makes sense from a boxed value
-    for (auto co : coor())
-      if (dyn_cast_or_null<LenParamIndexOp>(co.getDefiningOp())) {
-        if (getNumOperands() != 2)
-          return emitOpError("len_param_index must be last argument");
-        if (!ref().getType().dyn_cast<BoxType>())
-          return emitOpError("len_param_index must be used on box type");
-      }
-    return mlir::success();
-  }];
-}
-
-def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
-  let summary = "Extract a value from an aggregate SSA-value";
-
-  let description = [{
-    Extract a value from an entity with a type composed of tuples, arrays,
-    and/or derived types. Returns the value from entity with the type of the
-    specified component. Cannot be used on values of `!fir.box` type.
-
-    Note that the entity ssa-value must be of compile-time known size in order
-    to use this operation.
-
-    ```mlir
-      %f = fir.field_index field, !fir.type<X{field:i32}>
-      %s = ... : !fir.type<X>
-      %v = fir.extract_value %s, %f : (!fir.type<X>, !fir.field) -> i32
-    ```
-  }];
-
-  let arguments = (ins
-    AnyCompositeLike:$adt,
-    Variadic<AnyComponentType>:$coor
-  );
-
-  let assemblyFormat = [{
-    $adt `,` $coor attr-dict `:` functional-type(operands, results)
-  }];
-}
-
-def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
-  let summary = "create a field index value from a field identifier";
-
-  let description = [{
-    Generate a field (offset) value from an identifier.  Field values may be
-    lowered into exact offsets when the layout of a Fortran derived type is
-    known at compile-time. The type of a field value is `!fir.field` and
-    these values can be used with the `fir.coordinate_of`, `fir.extract_value`,
-    or `fir.insert_value` instructions to compute (abstract) addresses of
-    subobjects.
-
-    ```mlir
-      %f = fir.field_index field, !fir.type<X{field:i32}>
-    ```
-  }];
-
-  let arguments = (ins
-    StrAttr:$field_id,
-    TypeAttr:$on_type,
-    Variadic<AnyIntegerType>:$lenparams
-  );
-
-  let parser = [{
-    llvm::StringRef fieldName;
-    auto &builder = parser.getBuilder();
-    mlir::Type recty;
-    if (parser.parseOptionalKeyword(&fieldName) ||
-        parser.parseComma() ||
-        parser.parseType(recty))
-      return mlir::failure();
-    result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
-    if (!recty.dyn_cast<RecordType>())
-      return mlir::failure();
-    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(recty));
-    if (!parser.parseOptionalLParen()) {
-      llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
-      llvm::SmallVector<mlir::Type, 8> types;
-      auto loc = parser.getNameLoc();
-      if (parser.parseOperandList(operands,
-                                  mlir::OpAsmParser::Delimiter::None) ||
-          parser.parseRParen() ||
-          parser.parseColonTypeList(types) ||
-          parser.resolveOperands(operands, types, loc, result.operands))
-        return mlir::failure();
-    }
-    mlir::Type fieldType = fir::FieldType::get(builder.getContext());
-    if (parser.addTypeToList(fieldType, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' '
-      << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
-      << getAttr(typeAttrName());
-    if (getNumOperands()) {
-      p << '(';
-      p.printOperands(lenparams());
-      auto sep = ") : ";
-      for (auto op : lenparams()) {
-        p << sep;
-        if (op)
-          p.printType(op.getType());
-        else
-          p << "()";
-        sep = ", ";
-      }
-    }
-  }];
-
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, StringRef fieldName,"
-    "Type recTy, ValueRange operands = {}",
-    [{
-      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
-      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
-      result.addOperands(operands);
-    }]
-  >];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
-    static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
-  }];
-}
-
-def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
-
-  let summary = "generate a value of type `!fir.dims`";
-
-  let description = [{
-    The arguments are an ordered list of integral type values that is a
-    multiple of 3 in length.  Each such triple is defined as: the lower
-    index, the extent, and the stride for that dimension. The dimension
-    information is given in the same row-to-column order as Fortran. This
-    abstract dimension value must describe a reified object, so all dimension
-    information must be specified.  The extent must be nonnegative and the
-    stride must not be zero.
-
-    ```mlir
-      %d = fir.gendims %l, %u, %s : (index, index, index) -> !fir.dims<1>
-    ```
-  }];
-
-  let arguments = (ins Variadic<AnyIntegerType>:$triples);
-
-  let results = (outs fir_DimsType);
-
-  let assemblyFormat = [{
-    operands attr-dict `:` functional-type(operands, results)
-  }];
-
-  let verifier = [{
-    auto size = triples().size();
-    if (size < 1 || size > 16 * 3)
-      return emitOpError("incorrect number of args");
-    if (size % 3 != 0)
-      return emitOpError("requires a multiple of 3 args");
-    return mlir::success();
-  }];
-}
-
-def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
-  let summary = "insert a new sub-value into a copy of an existing aggregate";
-
-  let description = [{
-    Insert a value from an entity with a type composed of tuples, arrays,
-    and/or derived types. Returns a new ssa value with the same type as the
-    original entity. Cannot be used on values of `!fir.box` type.
-
-    Note that the entity ssa-value must be of compile-time known size in order
-    to use this operation.
-
-    ```mlir
-      %a = ... : !fir.array<10xtuple<i32, f32>>
-      %f = ... : f32
-      %o = ... : i32
-      %c = constant 1 : i32
-      %b = fir.insert_value %a, %f, %o, %c : (!fir.array<10x20xtuple<i32, f32>>, f32, i32, i32) -> !fir.array<10x20xtuple<i32, f32>>
-    ```
-  }];
-
-  let arguments = (ins AnyCompositeLike:$adt, AnyType:$val,
-                       Variadic<AnyComponentType>:$coor);
-  let results = (outs AnyCompositeLike);
-
-  let assemblyFormat = [{
-    operands attr-dict `:` functional-type(operands, results)
-  }];
-}
-
-def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
-  let summary =
-    "create a field index value from a LEN type parameter identifier";
-
-  let description = [{
-    Generate a LEN parameter (offset) value from an LEN parameter identifier.
-    The type of a LEN parameter value is `!fir.len` and these values can be
-    used with the `fir.coordinate_of` instructions to compute (abstract)
-    addresses of LEN parameters.
-
-    ```mlir
-      %e = fir.len_param_index len1, !fir.type<X(len1:i32)>
-      %p = ... : !fir.box<!fir.type<X>>
-      %q = fir.coordinate_of %p, %e : (!fir.box<!fir.type<X>>, !fir.len) -> !fir.ref<i32>
-    ```
-  }];
-
-  let arguments = (ins StrAttr:$field_id, TypeAttr:$on_type);
-
-  let parser = [{
-    llvm::StringRef fieldName;
-    auto &builder = parser.getBuilder();
-    mlir::Type recty;
-    if (parser.parseOptionalKeyword(&fieldName) ||
-        parser.parseComma() ||
-        parser.parseType(recty))
-      return mlir::failure();
-    result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
-    if (!recty.dyn_cast<RecordType>())
-      return mlir::failure();
-    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(recty));
-    mlir::Type lenType = fir::LenType::get(builder.getContext());
-    if (parser.addTypeToList(lenType, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' '
-      << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
-      << getAttr(typeAttrName());
-  }];
-
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, StringRef fieldName, Type recTy",
-    [{
-      result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
-      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
-    }]
-  >];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
-    static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
-    mlir::Type getOnType() {
-      return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
-    }
-  }];
-}
-
-// Fortran loops
-
-def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
-
-def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
-  let summary = "generalized loop operation";
-  let description = [{
-    Generalized high-level looping construct. This operation is similar to
-    MLIR's `loop.for`. An ordered loop will return the final value of `%i`.
-
-    ```mlir
-      %l = constant 0 : index
-      %u = constant 9 : index
-      fir.loop %i = %l to %u unordered {
-        %x = fir.convert %i : (index) -> i32
-        %v = fir.call @compute(%x) : (i32) -> f32
-        %p = fir.coordinate_of %A, %i : (!fir.ref<f32>, index) -> !fir.ref<f32>
-        fir.store %v to %p : !fir.ref<f32>
-      }
-    ```
-
-    The above example iterates over the interval `[%l, %u]`. The unordered
-    keyword indicates that the iterations can be executed in any order.
-  }];
-
-  let arguments = (ins
-    Index:$lowerBound,
-    Index:$upperBound,
-    Variadic<Index>:$optStep,
-    OptionalAttr<I64Attr>:$constantStep,
-    OptionalAttr<UnitAttr>:$unordered
-  );
-
-  let results = (outs Variadic<Index>:$lastVal);
-
-  let regions = (region SizedRegion<1>:$region);
-
-  let skipDefaultBuilders = 1;
-  let builders = [
-    OpBuilder<"mlir::Builder *builder, OperationState &result,"
-              "mlir::Value lowerBound, mlir::Value upperBound,"
-              "ValueRange step = {}, ArrayRef<NamedAttribute> attributes = {}">
-  ];
-
-  let parser = "return parseLoopOp(parser, result);";
-
-  let printer = [{
-    p << getOperationName() << ' ' << getInductionVar() << " = "
-      << lowerBound() << " to " << upperBound();
-    auto s = optStep();
-    if (s.begin() != s.end()) {
-      p << " step ";
-      p.printOperand(*s.begin());
-    }
-    if (unordered())
-      p << " unordered";
-    p.printRegion(region(), /*printEntryBlockArgs=*/false,
-                            /*printBlockTerminators=*/false);
-    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepAttrName()});
-  }];
-
-  let verifier = [{
-    auto step = optStep();
-    if (step.begin() != step.end()) {
-      // FIXME: size of step must be 1
-      auto *s = (*step.begin()).getDefiningOp();
-      if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s))
-        if (cst.getValue() == 0)
-          return emitOpError("constant step operand must be nonzero");
-    }
-
-    // Check that the body defines as single block argument for the induction
-    // variable.
-    auto *body = getBody();
-    if (body->getNumArguments() != 1 ||
-        !body->getArgument(0).getType().isIndex())
-      return emitOpError("expected body to have a single index argument for "
-                         "the induction variable");
-    if (lastVal().size() > 1)
-      return emitOpError("can only return one final value of iterator");
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = [{
-    static constexpr const char *unorderedAttrName() { return "unordered"; }
-    static constexpr const char *stepAttrName() { return "step"; }
-
-    /// Is this an unordered loop?
-    bool isUnordered() { return getAttr(unorderedAttrName()).isa<UnitAttr>(); }
-
-    /// Does loop set (and return) the final value of the control variable?
-    bool hasLastValue() { return lastVal().size(); }
-
-    /// Get the body of the loop
-    mlir::Block *getBody() { return &region().front(); }
-
-    /// Get the block argument corresponding to the loop control value (PHI)
-    mlir::Value getInductionVar() { return getBody()->getArgument(0); }
-
-    /// Get a builder to insert operations into the LoopOp
-    mlir::OpBuilder getBodyBuilder() {
-      return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
-    }
-
-    void setLowerBound(mlir::Value bound) {
-      getOperation()->setOperand(0, bound);
-    }
-
-    void setUpperBound(mlir::Value bound) {
-      getOperation()->setOperand(1, bound);
-    }
-
-    void setStep(mlir::Value step) {
-      getOperation()->setOperand(2, step);
-    }
-  }];
-}
-
-def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
-  let summary = "generalized conditional operation";
-  let description = [{
-    To conditionally execute operations (typically) within the body of a
-    `fir.loop` operation. This operation is similar to `loop.if`.
-
-    ```mlir
-      %56 = ... : i1
-      %78 = ... : !fir.ref<!T>
-      fir.where %56 {
-        fir.store %76 to %78 : !fir.ref<!T>
-      } otherwise {
-        fir.store %77 to %78 : !fir.ref<!T>
-      }
-    ```
-  }];
-
-  let arguments = (ins I1:$condition);
-
-  let regions = (region SizedRegion<1>:$whereRegion, AnyRegion:$otherRegion);
-
-  let skipDefaultBuilders = 1;
-  let builders = [
-    OpBuilder<"Builder *builder, OperationState &result, "
-              "Value cond, bool withOtherRegion">
-  ];
-
-  let parser = [{ return parseWhereOp(parser, result); }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << condition();
-    p.printRegion(whereRegion(), /*printEntryBlockArgs=*/false,
-        /*printBlockTerminators=*/false);
-
-    // Print the 'else' regions if it exists and has a block.
-    auto &otherReg = otherRegion();
-    if (!otherReg.empty()) {
-      p << " otherwise";
-      p.printRegion(otherReg, /*printEntryBlockArgs=*/false,
-          /*printBlockTerminators=*/false);
-    }
-    p.printOptionalAttrDict(getAttrs());
-  }];
-
-  let verifier = [{
-    for (auto &region : getOperation()->getRegions()) {
-      if (region.empty())
-        continue;
-      for (auto &b : region)
-        if (b.getNumArguments() != 0)
-          return emitOpError("requires that child entry blocks have no args");
-    }
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = [{
-    mlir::OpBuilder getWhereBodyBuilder() {
-      assert(!whereRegion().empty() && "Unexpected empty 'where' region.");
-      mlir::Block &body = whereRegion().front();
-      return mlir::OpBuilder(&body, std::prev(body.end()));
-    }
-    mlir::OpBuilder getOtherBodyBuilder() {
-      assert(!otherRegion().empty() && "Unexpected empty 'other' region.");
-      mlir::Block &body = otherRegion().front();
-      return mlir::OpBuilder(&body, std::prev(body.end()));
-    }
-  }];
-}
-
-// Procedure call operations
-
-def fir_CallOp : fir_Op<"call", []> {
-  let summary = "call a procedure";
-
-  let description = [{
-    Call the specified function or function reference.
-
-    Provides a custom parser and pretty printer to allow a more readable syntax
-    in the FIR dialect, e.g. `fir.call @sub(%12)` or `fir.call %20(%22,%23)`.
-
-    ```mlir
-      %a = fir.call %funcref(%arg0) : (!fir.ref<f32>) -> f32
-      %b = fir.call @function(%arg1, %arg2) : (!fir.ref<f32>, !fir.ref<f32>) -> f32
-    ```
-  }];
-
-  let arguments = (ins
-    OptionalAttr<SymbolRefAttr>:$callee,
-    Variadic<AnyType>:$args
-  );
-
-  let results = (outs Variadic<AnyType>);
-
-  let parser = "return parseCallOp(parser, result);";
-  let printer = "printCallOp(p, *this);";
-
-  let extraClassDeclaration = [{
-    static constexpr StringRef calleeAttrName() { return "callee"; }
-  }];
-}
-
-def fir_DispatchOp : fir_Op<"dispatch", []> {
-  let summary = "call a type-bound procedure";
-
-  let description = [{
-    Perform a dynamic dispatch on the method name via the dispatch table
-    associated with the first argument.  The attribute 'pass_arg_pos' can be
-    used to select a dispatch argument other than the first one.
-
-    ```mlir
-      %r = fir.dispatch methodA(%o) : (!fir.box<none>) -> i32
-    ```
-  }];
-
-  let arguments = (ins
-    StrAttr:$method,
-    fir_BoxType:$object,
-    Variadic<AnyType>:$args
-  );
-
-  let results = (outs Variadic<AnyType>);
-
-  let parser = [{
-    mlir::FunctionType calleeType;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
-    auto calleeLoc = parser.getNameLoc();
-    llvm::StringRef calleeName;
-    if (failed(parser.parseOptionalKeyword(&calleeName))) {
-      mlir::StringAttr calleeAttr;
-      if (parser.parseAttribute(calleeAttr, "method", result.attributes))
-        return mlir::failure();
-    } else {
-      result.addAttribute("method",
-          parser.getBuilder().getStringAttr(calleeName));
-    }
-    if (parser.parseOperandList(operands,
-                                mlir::OpAsmParser::Delimiter::Paren) ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(calleeType) ||
-        parser.addTypesToList(calleeType.getResults(), result.types) ||
-        parser.resolveOperands(
-            operands, calleeType.getInputs(), calleeLoc, result.operands))
-      return mlir::failure();
-    result.addAttribute("fn_type", mlir::TypeAttr::get(calleeType));
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr("method") << '(';
-    p.printOperand(object());
-    if (arg_operand_begin() != arg_operand_end()) {
-      p << ", ";
-      p.printOperands(args());
-    }
-    p << ')';
-    p.printOptionalAttrDict(getAttrs(), {"fn_type", "method"});
-    auto resTy{getResultTypes()};
-    llvm::SmallVector<mlir::Type, 8> argTy(getOperandTypes());
-    p << " : " << mlir::FunctionType::get(argTy, resTy, getContext());
-  }];
-
-  let extraClassDeclaration = [{
-    mlir::FunctionType getFunctionType();
-    operand_range getArgOperands() {
-      return {arg_operand_begin(), arg_operand_end()};
-    }
-    operand_iterator arg_operand_begin() { return operand_begin() + 1; }
-    operand_iterator arg_operand_end() { return operand_end(); }
-    llvm::StringRef passArgAttrName() { return "pass_arg_pos"; }
-    unsigned passArgPos();
-  }];
-}
-
-// Constant operations that support Fortran
-
-def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]> {
-  let summary = "create a string literal constant";
-
-  let description = [{
-    An FIR constant that represents a sequence of characters that correspond
-    to Fortran's CHARACTER type, including a LEN.  We support CHARACTER values
-    of different KINDs (different constant sizes).
-
-    ```mlir
-      %1 = fir.string_lit "Hello, World!"(13) : !fir.char<1> // ASCII
-      %2 = fir.string_lit [158, 2345](2) : !fir.char<2>      // Wide chars
-    ```
-  }];
-
-  let results = (outs fir_SequenceType);
-
-  let parser = [{
-    auto &builder = parser.getBuilder();
-    mlir::Attribute val;
-    llvm::SmallVector<mlir::NamedAttribute, 2> attrs;
-    if (parser.parseAttribute(val, "fake", attrs))
-      return mlir::failure();
-    if (auto v = val.dyn_cast<mlir::StringAttr>())
-      result.attributes.push_back(builder.getNamedAttr(value(), v));
-    else if (auto v = val.dyn_cast<mlir::ArrayAttr>())
-      result.attributes.push_back(builder.getNamedAttr(xlist(), v));
-    else
-      return mlir::failure();
-    mlir::IntegerAttr sz;
-    mlir::Type type;
-    if (parser.parseLParen() ||
-        parser.parseAttribute(sz, size(), result.attributes) ||
-        parser.parseRParen() ||
-        parser.parseColonType(type))
-      return mlir::failure();
-    type = fir::SequenceType::get({sz.getInt()}, type);
-    if (!type ||
-        parser.addTypesToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getValue() << '(';
-    p << getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
-    p.printType(getType().cast<fir::SequenceType>().getEleTy());
-  }];
-
-  let verifier = [{
-    if (getSize().cast<mlir::IntegerAttr>().getValue().isNegative())
-      return emitOpError("size must be non-negative");
-    auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
-    if (!eleTy.isa<fir::CharacterType>())
-      return emitOpError("must have !fir.char type");
-    if (auto xl = getAttr(xlist())) {
-      auto xList = xl.cast<mlir::ArrayAttr>();
-      for (auto a : xList)
-        if (!a.isa<mlir::IntegerAttr>())
-	  return emitOpError("values in list must be integers");
-    }
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = [{
-    static constexpr const char *size() { return "size"; }
-    static constexpr const char *value() { return "value"; }
-    static constexpr const char *xlist() { return "xlist"; }
-
-    // Get the LEN attribute of this character constant
-    mlir::Attribute getSize() { return getAttr(size()); }
-    // Get the string value of this character constant
-    mlir::Attribute getValue() {
-      if (auto attr = getAttr(value()))
-        return attr;
-      return getAttr(xlist());
-    }
-
-    /// Is this a wide character literal (1 character > 8 bits)
-    bool isWideValue();
-  }];
-}
-
-// Complex operations
-
-class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_Op<mnemonic,
-       !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
-    Results<(outs AnyType)> {
-  let parser = [{
-    return impl::parseOneResultSameOperandTypeOp(parser, result);
-  }];
-
-  let printer = [{ return printBinaryOp(this->getOperation(), p); }];
-}
-
-class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_Op<mnemonic,
-         !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
-      Results<(outs AnyType)> {
-  let parser = [{
-    return impl::parseOneResultSameOperandTypeOp(parser, result);
-  }];
-
-  let printer = [{ return printUnaryOp(this->getOperation(), p); }];
-}
-
-def FirRealAttr : Attr<CPred<"$_self.isa<fir::RealAttr>()">, "FIR real attr"> {
-  let storageType = [{ fir::RealAttr }];
-  let returnType = [{ llvm::APFloat }];
-}
-
-def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]> {
-  let summary = "create a floating point constant";
-
-  let description = [{
-    A floating-point constant. This operation is to augment MLIR to be able
-    to represent APFloat values that are not supported in the standard dialect.
-  }];
-
-  let arguments = (ins FirRealAttr:$constant);
-  
-  let results = (outs fir_RealType:$res);
-
-  let assemblyFormat = "`(` $constant `)` attr-dict `:` type($res)";
-  
-  let verifier = [{
-    if (!getType().isa<fir::RealType>())
-      return emitOpError("must be a !fir.real type");
-    return mlir::success();
-  }];
-}
-
-class RealUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_UnaryArithmeticOp<mnemonic, traits>,
-      Arguments<(ins AnyRealLike:$operand)>;
-
-def fir_NegfOp : RealUnaryArithmeticOp<"negf">;
-
-class RealArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_ArithmeticOp<mnemonic, traits>,
-      Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)>;
-
-def fir_AddfOp : RealArithmeticOp<"addf", [Commutative]>;
-def fir_SubfOp : RealArithmeticOp<"subf">;
-def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]>;
-def fir_DivfOp : RealArithmeticOp<"divf">;
-def fir_ModfOp : RealArithmeticOp<"modf">;
-// Pow is a builtin call and not a primitive
-
-def fir_CmpfOp : fir_Op<"cmpf",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
-  let summary = "floating-point comparison operator";
-
-  let description = [{
-    Extends the standard floating-point comparison to handle the extended
-    floating-point types found in FIR.
-  }];
-
-  let arguments = (ins AnyRealLike:$lhs, AnyRealLike:$rhs);
-
-  let results = (outs AnyLogicalLike);
-
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, CmpFPredicate predicate,"
-    "Value lhs, Value rhs", [{
-      buildCmpFOp(builder, result, predicate, lhs, rhs);
-  }]>];
-
-  let parser = [{ return parseCmpfOp(parser, result); }];
-
-  let printer = [{ printCmpfOp(p, *this); }];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef getPredicateAttrName() {
-      return "predicate";
-    }
-    static CmpFPredicate getPredicateByName(llvm::StringRef name);
-
-    CmpFPredicate getPredicate() {
-      return (CmpFPredicate)getAttrOfType<mlir::IntegerAttr>(
-          getPredicateAttrName()).getInt();
-    }
-  }];
-}
-
-def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]>,
-    Results<(outs fir_ComplexType)> {
-  let summary = "create a complex constant";
-
-  let description = [{
-    A complex constant. Similar to the standard dialect complex type, but this
-    extension allows constants with APFloat values that are not supported in
-    the standard dialect.
-  }];
-
-  let parser = [{
-    fir::RealAttr realp;
-    fir::RealAttr imagp;
-    mlir::Type type;
-    if (parser.parseLParen() ||
-        parser.parseAttribute(realp, realAttrName(), result.attributes) ||
-        parser.parseComma() ||
-        parser.parseAttribute(imagp, imagAttrName(), result.attributes) ||
-        parser.parseRParen() ||
-        parser.parseColonType(type) ||
-        parser.addTypesToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << " (0x";
-    auto f1 = getAttr(realAttrName()).cast<mlir::FloatAttr>();
-    auto i1 = f1.getValue().bitcastToAPInt();
-    p.getStream().write_hex(i1.getZExtValue());
-    p << ", 0x";
-    auto f2 = getAttr(imagAttrName()).cast<mlir::FloatAttr>();
-    auto i2 = f2.getValue().bitcastToAPInt();
-    p.getStream().write_hex(i2.getZExtValue());
-    p << ") : ";
-    p.printType(getType());
-  }];
-
-  let verifier = [{
-    if (!getType().isa<fir::CplxType>())
-      return emitOpError("must be a !fir.complex type");
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef realAttrName() { return "real"; }
-    static constexpr llvm::StringRef imagAttrName() { return "imaginary"; }
-
-    mlir::Attribute getReal() { return getAttr(realAttrName()); }
-    mlir::Attribute getImaginary() { return getAttr(imagAttrName()); }
-  }];
-}
-
-class ComplexUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_UnaryArithmeticOp<mnemonic, traits>,
-      Arguments<(ins fir_ComplexType:$operand)>;
-
-def fir_NegcOp : ComplexUnaryArithmeticOp<"negc">;
-
-class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_ArithmeticOp<mnemonic, traits>,
-      Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)>;
-
-def fir_AddcOp : ComplexArithmeticOp<"addc", [Commutative]>;
-def fir_SubcOp : ComplexArithmeticOp<"subc">;
-def fir_MulcOp : ComplexArithmeticOp<"mulc", [Commutative]>;
-def fir_DivcOp : ComplexArithmeticOp<"divc">;
-// Pow is a builtin call and not a primitive
-
-def fir_CmpcOp : fir_Op<"cmpc",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
-  let summary = "complex floating-point comparison operator";
-
-  let description = [{
-    A complex comparison to handle complex types found in FIR.
-  }];
-
-  let arguments = (ins fir_ComplexType:$lhs, fir_ComplexType:$rhs);
-
-  let results = (outs AnyLogicalLike);
-
-  let parser = "return parseCmpcOp(parser, result);";
-
-  let printer = "printCmpcOp(p, *this);";
-
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, CmpFPredicate predicate,"
-    "Value lhs, Value rhs", [{
-      buildCmpCOp(builder, result, predicate, lhs, rhs);
-  }]>];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef getPredicateAttrName() {
-      return "predicate";
-    }
-
-    CmpFPredicate getPredicate() {
-      return (CmpFPredicate)getAttrOfType<mlir::IntegerAttr>(
-          getPredicateAttrName()).getInt();
-    }
-  }];
-}
-
-// Other misc. operations
-
-def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
-  let summary = "convert a symbol to an SSA value";
-  let description = [{
-    Convert a symbol (a function or global reference) to an SSA-value to be
-    used in other Operations.
-
-    ```mlir
-      %p = fir.address_of(@symbol) : !fir.ref<f64>
-    ```
-  }];
-
-  let arguments = (ins SymbolRefAttr:$symbol);
-
-  let results = (outs fir_ReferenceType:$resTy);
-
-  let assemblyFormat = "`(` $symbol `)` attr-dict `:` type($resTy)";
-}
-
-def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
-  let summary = "encapsulates all Fortran scalar type conversions";
-  let description = [{
-    Generalized type conversion. Convert the ssa value from type T to type U.
-    Not all pairs of types have conversions. When types T and U are the same
-    type, this instruction is a NOP and may be folded away.
-
-    ```mlir
-      %v = ... : i64
-      %w = fir.convert %v : (i64) -> i32
-    ```
-
-    The example truncates the value `%v` from an i64 to an i32.
-  }];
-
-  let arguments = (ins AnyType:$value);
-
-  let assemblyFormat = [{
-    $value attr-dict `:` functional-type($value, results)
-  }];
-}
-
-def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
-    Or<[CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CharacterType>()">,
-        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CplxType>()">,
-        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::IntType>()">,
-        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::LogicalType>()">,
-        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RealType>()">,
-        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RecordType>()">]>]>,
-    "Fortran surface type"> {
-  let storageType = [{ TypeAttr }];
-  let returnType = "Type";
-  let convertFromStorage = "$_self.getValue().cast<Type>()";
-}
-
-def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
-  let summary = "generate a type descriptor for a given type";
-  let description = [{
-    Generates a constant object that is an abstract type descriptor of the
-    specified type.  The meta-type of a type descriptor for the type `T`
-    is `!fir.tdesc<T>`.
-
-    ```mlir
-      !T = type !fir.type<T{...}>
-      %t = fir.gentypedesc !T  // returns value of !fir.tdesc<!T>
-    ```
-  }];
-
-  let arguments = (ins FortranTypeAttr:$in_type);
-
-  let parser = [{
-    mlir::Type intype;
-    if (parser.parseType(intype))
-      return mlir::failure();
-    result.addAttribute("in_type", mlir::TypeAttr::get(intype));
-    mlir::Type restype = TypeDescType::get(intype);
-    if (parser.addTypeToList(restype, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr("in_type");
-    p.printOptionalAttrDict(getAttrs(), {"in_type"});
-  }];
-
-  let builders = [
-    OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty">
-  ];
-
-  let verifier = [{
-    mlir::Type resultTy = getType();
-    if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
-      if (tdesc.getOfTy() != getInType())
-        return emitOpError("wrapped type mismatched");
-    } else {
-      return emitOpError("must be !fir.tdesc type");
-    }
-    return mlir::success();
-  }];
-
-  let extraClassDeclaration = [{
-    mlir::Type getInType() {
-      // get the type that the type descriptor describes
-      return getAttrOfType<mlir::TypeAttr>("in_type").getValue();
-    }
-  }];
-}
-
-def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
-    [SameOperandsAndResultType]> {
-  let summary = "synthetic op to prevent reassociation";
-  let description = [{
-    Primitive operation meant to intrusively prevent operator reassociation.
-    The operation is otherwise a nop and the value returned is the same as the
-    argument.
-
-    The presence of this operation prevents any local optimizations. In the
-    example below, this would prevent possibly replacing the multiply and add
-    operations with a single FMA operation.
-
-    ```mlir
-      %98 = mulf %96, %97 : f32
-      %99 = fir.no_reassoc %98 : f32
-      %a0 = addf %99, %95 : f32
-    ```
-  }];
-
-  let arguments = (ins AnyType:$val);
-
-  let assemblyFormat = "$val attr-dict `:` type($val)";
-}
-
-class AtMostRegion<int numBlocks> : Region<
-  CPred<"$_self.getBlocks().size() <= " # numBlocks>,
-  "region with " # numBlocks # " blocks">;
-
-def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
-  let summary = "Global data";
-  let description = [{
-    A global variable or constant with initial values.
-
-    The example creates a global variable (writable) named
-    `@_QV_Mquark_Vvarble` with some initial values. The initializer should
-    conform to the variable's type.
-
-    ```mlir
-      fir.global @_QV_Mquark_Vvarble : tuple<i32, f32> {
-        %1 = constant 1 : i32
-        %2 = constant 2.0 : f32
-        %3 = fir.undefined tuple<i32, f32>
-        %z = constant 0 : index
-        %o = constant 1 : index
-        %4 = fir.insert_value %3, %1, %z : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
-        %5 = fir.insert_value %4, %1, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
-        return %5
-      }
-    ```
-  }];
-
-  let arguments = (ins
-    StrAttr:$sym_name,
-    OptionalAttr<AnyAttr>:$initval,
-    UnitAttr:$constant,
-    TypeAttr:$type
-  );
-
-  let results = (outs fir_ReferenceType:$resultType);
-
-  let regions = (region AtMostRegion<1>:$region);
-
-  let parser = [{
-    // Parse the name as a symbol reference attribute.
-    SymbolRefAttr nameAttr;
-    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
-                              result.attributes))
-      return failure();
-
-    auto &builder = parser.getBuilder();
-    auto name = nameAttr.getRootReference();
-    result.attributes.back().second = builder.getStringAttr(name);
-
-    bool simpleInitializer = false;
-    if (!parser.parseOptionalLParen()) {
-      Attribute attr;
-      if (parser.parseAttribute(attr, initValAttrName(), result.attributes) ||
-          parser.parseRParen())
-        return failure();
-      simpleInitializer = true;
-    }
-
-    if (succeeded(parser.parseOptionalKeyword(constantAttrName()))) {
-      // if "constant" keyword then mark this as a constant, not a variable
-      result.addAttribute(constantAttrName(), builder.getUnitAttr());
-    }
-
-    mlir::Type globalType;
-    if (parser.parseColonType(globalType))
-      return failure();
-
-    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(globalType));
-
-    if (!simpleInitializer) {
-      // Parse the optional initializer body.
-      if (parser.parseRegion(*result.addRegion(), llvm::None, llvm::None))
-        return failure();
-    }
-
-    auto refTy = AllocaOp::wrapResultType(globalType);
-    if (parser.addTypeToList(refTy, result.types))
-      return failure();
-    return success();
-  }];
-
-  let printer = [{
-    auto varName = getAttrOfType<StringAttr>(
-      mlir::SymbolTable::getSymbolAttrName()).getValue();
-    p << getOperationName() << " @" << varName;
-    if (auto iv = initval().getValueOr(Attribute())) {
-      p << '(';
-      p.printAttribute(iv);
-      p << ')';
-    }
-    if (getAttr(constantAttrName()))
-      p << ' ' << constantAttrName();
-    p << " : ";
-    p.printType(getType());
-    Region &body = getOperation()->getRegion(0);
-    if (!body.empty())
-      p.printRegion(body, /*printEntryBlockArgs=*/false,
-                          /*printBlockTerminators=*/true);
-  }];
-
-  let skipDefaultBuilders = 1;
-  let builders = [
-    OpBuilder<"mlir::Builder *builder, OperationState &result,"
-              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
-    [{
-      result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
-      result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
-                          builder->getStringAttr(name));
-      result.addAttributes(attrs);
-    }]>
-  ];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef constantAttrName() { return "constant"; }
-    static constexpr llvm::StringRef initValAttrName() { return "initval"; }
-    static constexpr llvm::StringRef typeAttrName() { return "type"; }
-
-    mlir::Type getType() {
-      return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
-    }
-
-    /// Append the next initializer value to the `GlobalOp` to construct
-    /// the variable's initial value.
-    void appendInitialValue(mlir::Operation *op);
-
-    /// A GlobalOp has one region.
-    mlir::Region &getRegion() { return getOperation()->getRegion(0); }
-
-    /// A GlobalOp has one block.
-    mlir::Block &getBlock() { return getRegion().front(); }
-  }];
-}
-
-def fir_GlobalLenOp : fir_Op<"global_len", []> {
-  let summary = "map a LEN parameter to a global";
-  let description = [{
-    A global entity (that is not an automatic data object) can have extra LEN
-    parameter (compile-time) constants associated with the instance's type.
-    These values can be bound to the global instance used `fir.global_len`.
-
-    ```mlir
-      global @g : !fir.type<t(len1:i32)> {
-        fir.global_len len1, 10 : i32
-        %1 = fir.undefined : !fir.type<t(len1:i32)>
-        return %1 : !fir.type<t(len1:i32)>
-      }
-    ```
-  }];
-
-  let arguments = (ins StrAttr:$lenparam, APIntAttr:$intval);
-
-  let parser = [{
-    llvm::StringRef fieldName;
-    if (failed(parser.parseOptionalKeyword(&fieldName))) {
-      mlir::StringAttr fieldAttr;
-      if (parser.parseAttribute(fieldAttr, lenParamAttrName(),
-                                result.attributes))
-        return mlir::failure();
-    } else {
-      result.addAttribute(lenParamAttrName(),
-          parser.getBuilder().getStringAttr(fieldName));
-    }
-    mlir::IntegerAttr constant;
-    if (parser.parseComma() ||
-        parser.parseAttribute(constant, intAttrName(), result.attributes))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr(lenParamAttrName()) << ", "
-      << getAttr(intAttrName());
-  }];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef lenParamAttrName() { return "lenparam"; }
-    static constexpr llvm::StringRef intAttrName() { return "intval"; }
-  }];
-}
-
-def fir_DispatchTableOp : fir_Op<"dispatch_table", [IsolatedFromAbove, Symbol,
-                                 ImplicitFirTerminator]> {
-  let summary = "Dispatch table definition";
-
-  let description = [{
-    Define a dispatch table for a derived type with type-bound procedures.
-
-    A dispatch table is an untyped symbol that contains a list of associations
-    between method identifiers and corresponding `FuncOp` symbols.
-
-    The ordering of associations in the map is determined by the front-end.
-
-    ```mlir
-      fir.dispatch_table @_QDTMquuzTfoo {
-        fir.dt_entry method1, @_QFNMquuzTfooPmethod1AfooR
-        fir.dt_entry method2, @_QFNMquuzTfooPmethod2AfooII
-      }
-    ```
-  }];
-
-  let parser = [{
-    // Parse the name as a symbol reference attribute.
-    SymbolRefAttr nameAttr;
-    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
-                              result.attributes))
-      return failure();
-
-    // Convert the parsed name attr into a string attr.
-    result.attributes.back().second =
-        parser.getBuilder().getStringAttr(nameAttr.getRootReference());
-
-    // Parse the optional table body.
-    mlir::Region *body = result.addRegion();
-    if (parser.parseOptionalRegion(*body, llvm::None, llvm::None))
-      return mlir::failure();
-
-    ensureTerminator(*body, parser.getBuilder(), result.location);
-    return mlir::success();
-  }];
-
-  let printer = [{
-    auto tableName = getAttrOfType<StringAttr>(
-      mlir::SymbolTable::getSymbolAttrName()).getValue();
-    p << getOperationName() << " @" << tableName;
-
-    Region &body = getOperation()->getRegion(0);
-    if (!body.empty())
-      p.printRegion(body, /*printEntryBlockArgs=*/false,
-                          /*printBlockTerminators=*/false);
-  }];
-
-  let verifier = [{
-    for (auto &op : getBlock())
-      if (!(isa<fir::DTEntryOp>(op) || isa<fir::FirEndOp>(op)))
-        return emitOpError("dispatch table must contain dt_entry");
-    return mlir::success();
-  }];
-
-  let regions = (region SizedRegion<1>:$region);
-
-  let skipDefaultBuilders = 1;
-  let builders = [
-    OpBuilder<"mlir::Builder *builder, OperationState *result,"
-              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
-    [{
-      result->addAttribute(mlir::SymbolTable::getSymbolAttrName(),
-                           builder->getStringAttr(name));
-      result->addAttributes(attrs);
-    }]>
-  ];
-
-  let extraClassDeclaration = [{
-    /// Append a dispatch table entry to the table.
-    void appendTableEntry(mlir::Operation *op);
-
-    mlir::Region &getRegion() {
-      return this->getOperation()->getRegion(0);
-    }
-
-    mlir::Block &getBlock() {
-      return getRegion().front();
-    }
-  }];
-}
-
-def fir_DTEntryOp : fir_Op<"dt_entry", []> {
-  let summary = "map entry in a dispatch table";
-
-  let description = [{
-    An entry in a dispatch table.  Allows a function symbol to be bound
-    to a specifier method identifier.  A dispatch operation uses the dynamic
-    type of a distinguished argument to determine an exact dispatch table
-    and uses the method identifier to select the type-bound procedure to
-    be called.
-
-    ```mlir
-      fir.dt_entry method_name, @uniquedProcedure
-    ```
-  }];
-
-  let arguments = (ins StrAttr:$method, SymbolRefAttr:$proc);
-
-  let parser = [{
-    llvm::StringRef methodName;
-    // allow `methodName` or `"methodName"`
-    if (failed(parser.parseOptionalKeyword(&methodName))) {
-      mlir::StringAttr methodAttr;
-      if (parser.parseAttribute(methodAttr, methodAttrName(),
-                                result.attributes))
-        return mlir::failure();
-    } else {
-      result.addAttribute(methodAttrName(),
-          parser.getBuilder().getStringAttr(methodName));
-    }
-    mlir::SymbolRefAttr calleeAttr;
-    if (parser.parseComma() ||
-        parser.parseAttribute(calleeAttr, procAttrName(), result.attributes))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr(methodAttrName()) << ", "
-      << getAttr(procAttrName());
-  }];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef methodAttrName() { return "method"; }
-    static constexpr llvm::StringRef procAttrName() { return "proc"; }
-  }];
-}
-
-#endif
diff --git a/include/flang/Optimizer/Dialect/FIROpsSupport.h b/include/flang/Optimizer/Dialect/FIROpsSupport.h
deleted file mode 100644
index 13e4e5ab71b2..000000000000
--- a/include/flang/Optimizer/Dialect/FIROpsSupport.h
+++ /dev/null
@@ -1,63 +0,0 @@
-//===-- Optimizer/Dialect/FIROpsSupport.h -- FIR op support -----*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPTIMIZER_DIALECT_FIROPSSUPPORT_H
-#define OPTIMIZER_DIALECT_FIROPSSUPPORT_H
-
-#include "flang/Optimizer/Dialect/FIROps.h"
-#include "mlir/Dialect/StandardOps/IR/Ops.h"
-
-namespace fir {
-
-/// return true iff the Operation is a non-volatile LoadOp
-inline bool nonVolatileLoad(mlir::Operation *op) {
-  if (auto load = dyn_cast<fir::LoadOp>(op))
-    return !load.getAttr("volatile");
-  return false;
-}
-
-/// return true iff the Operation is a call
-inline bool isaCall(mlir::Operation *op) {
-  return isa<fir::CallOp>(op) || isa<fir::DispatchOp>(op) ||
-         isa<mlir::CallOp>(op) || isa<mlir::CallIndirectOp>(op);
-}
-
-/// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
-/// mlir::CallOp, or mlir::CallIndirectOp and not pure
-/// NB: this is not the same as `!pureCall(op)`
-inline bool impureCall(mlir::Operation *op) {
-  // Should we also auto-detect that the called function is pure if its
-  // arguments are not references?  For now, rely on a "pure" attribute.
-  return op && isaCall(op) && !op->getAttr("pure");
-}
-
-/// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
-/// mlir::CallOp, or mlir::CallIndirectOp and is also pure.
-/// NB: this is not the same as `!impureCall(op)`
-inline bool pureCall(mlir::Operation *op) {
-  // Should we also auto-detect that the called function is pure if its
-  // arguments are not references?  For now, rely on a "pure" attribute.
-  return op && isaCall(op) && op->getAttr("pure");
-}
-
-/// Get or create a FuncOp in a module.
-///
-/// If `module` already contains FuncOp `name`, it is returned. Otherwise, a new
-/// FuncOp is created, and that new FuncOp is returned.
-mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
-                          llvm::StringRef name, mlir::FunctionType type,
-                          llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
-
-/// Get or create a GlobalOp in a module.
-fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
-                             llvm::StringRef name, mlir::Type type,
-                             llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
-
-} // namespace fir
-
-#endif // OPTIMIZER_DIALECT_FIROPSSUPPORT_H
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
deleted file mode 100644
index 73174371718a..000000000000
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ /dev/null
@@ -1,399 +0,0 @@
-//===-- Optimizer/Dialect/FIRType.h -- FIR types ----------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPTIMIZER_DIALECT_FIRTYPE_H
-#define OPTIMIZER_DIALECT_FIRTYPE_H
-
-#include "mlir/IR/Attributes.h"
-#include "mlir/IR/Types.h"
-#include "llvm/ADT/SmallVector.h"
-
-namespace llvm {
-class raw_ostream;
-class StringRef;
-template <typename>
-class ArrayRef;
-class hash_code;
-} // namespace llvm
-
-namespace mlir {
-class DialectAsmParser;
-class DialectAsmPrinter;
-} // namespace mlir
-
-namespace fir {
-
-class FIROpsDialect;
-
-using KindTy = int;
-
-namespace detail {
-struct BoxTypeStorage;
-struct BoxCharTypeStorage;
-struct BoxProcTypeStorage;
-struct CharacterTypeStorage;
-struct CplxTypeStorage;
-struct DimsTypeStorage;
-struct FieldTypeStorage;
-struct HeapTypeStorage;
-struct IntTypeStorage;
-struct LenTypeStorage;
-struct LogicalTypeStorage;
-struct PointerTypeStorage;
-struct RealTypeStorage;
-struct RecordTypeStorage;
-struct ReferenceTypeStorage;
-struct SequenceTypeStorage;
-struct TypeDescTypeStorage;
-} // namespace detail
-
-/// Integral identifier for all the types comprising the FIR type system
-enum TypeKind {
-  // The enum starts at the range reserved for this dialect.
-  FIR_TYPE = mlir::Type::FIRST_FIR_TYPE,
-  FIR_BOX,       // (static) descriptor
-  FIR_BOXCHAR,   // CHARACTER pointer and length
-  FIR_BOXPROC,   // procedure with host association
-  FIR_CHARACTER, // intrinsic type
-  FIR_COMPLEX,   // intrinsic type
-  FIR_DERIVED,   // derived
-  FIR_DIMS,
-  FIR_FIELD,
-  FIR_HEAP,
-  FIR_INT, // intrinsic type
-  FIR_LEN,
-  FIR_LOGICAL, // intrinsic type
-  FIR_POINTER, // POINTER attr
-  FIR_REAL,    // intrinsic type
-  FIR_REFERENCE,
-  FIR_SEQUENCE, // DIMENSION attr
-  FIR_TYPEDESC,
-};
-
-// These isa_ routines follow the precedent of llvm::isa_or_null<>
-
-/// Is `t` any of the FIR dialect types?
-bool isa_fir_type(mlir::Type t);
-
-/// Is `t` any of the Standard dialect types?
-bool isa_std_type(mlir::Type t);
-
-/// Is `t` any of the FIR dialect or Standard dialect types?
-bool isa_fir_or_std_type(mlir::Type t);
-
-/// Is `t` a FIR dialect type that implies a memory (de)reference?
-bool isa_ref_type(mlir::Type t);
-
-/// Is `t` a FIR dialect aggregate type?
-bool isa_aggregate(mlir::Type t);
-
-/// Extract the `Type` pointed to from a FIR memory reference type. If `t` is
-/// not a memory reference type, then returns a null `Type`.
-mlir::Type dyn_cast_ptrEleTy(mlir::Type t);
-
-/// Boilerplate mixin template
-template <typename A, unsigned Id>
-struct IntrinsicTypeMixin {
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() { return Id; }
-};
-
-// Intrinsic types
-
-/// Model of the Fortran CHARACTER intrinsic type, including the KIND type
-/// parameter. The model does not include a LEN type parameter. A CharacterType
-/// is thus the type of a single character value.
-class CharacterType
-    : public mlir::Type::TypeBase<CharacterType, mlir::Type,
-                                  detail::CharacterTypeStorage>,
-      public IntrinsicTypeMixin<CharacterType, TypeKind::FIR_CHARACTER> {
-public:
-  using Base::Base;
-  static CharacterType get(mlir::MLIRContext *ctxt, KindTy kind);
-  KindTy getFKind() const;
-};
-
-/// Model of a Fortran COMPLEX intrinsic type, including the KIND type
-/// parameter. COMPLEX is a floating point type with a real and imaginary
-/// member.
-class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
-                                             detail::CplxTypeStorage>,
-                 public IntrinsicTypeMixin<CplxType, TypeKind::FIR_COMPLEX> {
-public:
-  using Base::Base;
-  static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
-  KindTy getFKind() const;
-};
-
-/// Model of a Fortran INTEGER intrinsic type, including the KIND type
-/// parameter.
-class IntType
-    : public mlir::Type::TypeBase<IntType, mlir::Type, detail::IntTypeStorage>,
-      public IntrinsicTypeMixin<IntType, TypeKind::FIR_INT> {
-public:
-  using Base::Base;
-  static IntType get(mlir::MLIRContext *ctxt, KindTy kind);
-  KindTy getFKind() const;
-};
-
-/// Model of a Fortran LOGICAL intrinsic type, including the KIND type
-/// parameter.
-class LogicalType
-    : public mlir::Type::TypeBase<LogicalType, mlir::Type,
-                                  detail::LogicalTypeStorage>,
-      public IntrinsicTypeMixin<LogicalType, TypeKind::FIR_LOGICAL> {
-public:
-  using Base::Base;
-  static LogicalType get(mlir::MLIRContext *ctxt, KindTy kind);
-  KindTy getFKind() const;
-};
-
-/// Model of a Fortran REAL (and DOUBLE PRECISION) intrinsic type, including the
-/// KIND type parameter.
-class RealType : public mlir::Type::TypeBase<RealType, mlir::Type,
-                                             detail::RealTypeStorage>,
-                 public IntrinsicTypeMixin<RealType, TypeKind::FIR_REAL> {
-public:
-  using Base::Base;
-  static RealType get(mlir::MLIRContext *ctxt, KindTy kind);
-  KindTy getFKind() const;
-};
-
-// FIR support types
-
-/// The type of a Fortran descriptor. Descriptors are tuples of information that
-/// describe an entity being passed from a calling context. This information
-/// might include (but is not limited to) whether the entity is an array, its
-/// size, or what type it has.
-class BoxType
-    : public mlir::Type::TypeBase<BoxType, mlir::Type, detail::BoxTypeStorage> {
-public:
-  using Base::Base;
-  static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {});
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOX; }
-  mlir::Type getEleTy() const;
-  mlir::AffineMapAttr getLayoutMap() const;
-
-  static mlir::LogicalResult
-  verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
-                               mlir::AffineMapAttr map);
-};
-
-/// The type of a pair that describes a CHARACTER variable. Specifically, a
-/// CHARACTER consists of a reference to a buffer (the string value) and a LEN
-/// type parameter (the runtime length of the buffer).
-class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
-                                                detail::BoxCharTypeStorage> {
-public:
-  using Base::Base;
-  static BoxCharType get(mlir::MLIRContext *ctxt, KindTy kind);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXCHAR; }
-  CharacterType getEleTy() const;
-};
-
-/// The type of a pair that describes a PROCEDURE reference. Pointers to
-/// internal procedures must carry an additional reference to the host's
-/// variables that are referenced.
-class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
-                                                detail::BoxProcTypeStorage> {
-public:
-  using Base::Base;
-  static BoxProcType get(mlir::Type eleTy);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXPROC; }
-  mlir::Type getEleTy() const;
-
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
-};
-
-/// The type of a runtime vector that describes triples of array dimension
-/// information. A triple consists of a lower bound, upper bound, and
-/// stride. Each dimension of an array entity may have an associated triple that
-/// maps how elements of the array are accessed.
-class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
-                                             detail::DimsTypeStorage> {
-public:
-  using Base::Base;
-  static DimsType get(mlir::MLIRContext *ctx, unsigned rank);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_DIMS; }
-
-  /// returns -1 if the rank is unknown
-  int getRank() const;
-};
-
-/// The type of a field name. Implementations may defer the layout of a Fortran
-/// derived type until runtime. This implies that the runtime must be able to
-/// determine the offset of fields within the entity.
-class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
-                                              detail::FieldTypeStorage> {
-public:
-  using Base::Base;
-  static FieldType get(mlir::MLIRContext *ctxt);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_FIELD; }
-};
-
-/// The type of a heap pointer. Fortran entities with the ALLOCATABLE attribute
-/// may be allocated on the heap at runtime. These pointers are explicitly
-/// distinguished to disallow the composition of multiple levels of
-/// indirection. For example, an ALLOCATABLE POINTER is invalid.
-class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
-                                             detail::HeapTypeStorage> {
-public:
-  using Base::Base;
-  static HeapType get(mlir::Type elementType);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_HEAP; }
-
-  mlir::Type getEleTy() const;
-
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
-};
-
-/// The type of a LEN parameter name. Implementations may defer the layout of a
-/// Fortran derived type until runtime. This implies that the runtime must be
-/// able to determine the offset of LEN type parameters related to an entity.
-class LenType
-    : public mlir::Type::TypeBase<LenType, mlir::Type, detail::LenTypeStorage> {
-public:
-  using Base::Base;
-  static LenType get(mlir::MLIRContext *ctxt);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_LEN; }
-};
-
-/// The type of entities with the POINTER attribute.  These pointers are
-/// explicitly distinguished to disallow the composition of multiple levels of
-/// indirection. For example, an ALLOCATABLE POINTER is invalid.
-class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
-                                                detail::PointerTypeStorage> {
-public:
-  using Base::Base;
-  static PointerType get(mlir::Type elementType);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_POINTER; }
-
-  mlir::Type getEleTy() const;
-
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
-};
-
-/// The type of a reference to an entity in memory.
-class ReferenceType
-    : public mlir::Type::TypeBase<ReferenceType, mlir::Type,
-                                  detail::ReferenceTypeStorage> {
-public:
-  using Base::Base;
-  static ReferenceType get(mlir::Type elementType);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_REFERENCE; }
-
-  mlir::Type getEleTy() const;
-
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
-};
-
-/// A sequence type is a multi-dimensional array of values. The sequence type
-/// may have an unknown number of dimensions or the extent of dimensions may be
-/// unknown. A sequence type models a Fortran array entity, giving it a type in
-/// FIR. A sequence type is assumed to be stored in a column-major order, which
-/// differs from LLVM IR and other dialects of MLIR.
-class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
-                                                 detail::SequenceTypeStorage> {
-public:
-  using Base::Base;
-  using Extent = int64_t;
-  using Shape = llvm::SmallVector<Extent, 8>;
-
-  /// Return a sequence type with the specified shape and element type
-  static SequenceType get(const Shape &shape, mlir::Type elementType,
-                          mlir::AffineMapAttr map = {});
-
-  /// The element type of this sequence
-  mlir::Type getEleTy() const;
-
-  /// The shape of the sequence. If the sequence has an unknown shape, the shape
-  /// returned will be empty.
-  Shape getShape() const;
-
-  mlir::AffineMapAttr getLayoutMap() const;
-
-  /// The number of dimensions of the sequence
-  unsigned getDimension() const { return getShape().size(); }
-
-  /// The value `-1` represents an unknown extent for a dimension
-  static constexpr Extent getUnknownExtent() { return -1; }
-
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
-
-  static mlir::LogicalResult
-  verifyConstructionInvariants(mlir::Location loc, const Shape &shape,
-                               mlir::Type eleTy, mlir::AffineMapAttr map);
-};
-
-bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
-llvm::hash_code hash_value(const SequenceType::Extent &);
-llvm::hash_code hash_value(const SequenceType::Shape &);
-
-/// The type of a type descriptor object. The runtime may generate type
-/// descriptor objects to determine the type of an entity at runtime, etc.
-class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
-                                                 detail::TypeDescTypeStorage> {
-public:
-  using Base::Base;
-  static TypeDescType get(mlir::Type ofType);
-  static constexpr bool kindof(unsigned kind) {
-    return kind == TypeKind::FIR_TYPEDESC;
-  }
-  mlir::Type getOfTy() const;
-
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type ofType);
-};
-
-// Derived types
-
-/// Model of Fortran's derived type, TYPE. The name of the TYPE includes any
-/// KIND type parameters. The record includes runtime slots for LEN type
-/// parameters and for data components.
-class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
-                                               detail::RecordTypeStorage> {
-public:
-  using Base::Base;
-  using TypePair = std::pair<std::string, mlir::Type>;
-  using TypeList = std::vector<TypePair>;
-
-  llvm::StringRef getName();
-  TypeList getTypeList();
-  TypeList getLenParamList();
-
-  mlir::Type getType(llvm::StringRef ident);
-  mlir::Type getType(unsigned index) {
-    assert(index < getNumFields());
-    return getTypeList()[index].second;
-  }
-  unsigned getNumFields() { return getTypeList().size(); }
-  unsigned getNumLenParams() { return getLenParamList().size(); }
-
-  static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
-  void finalize(llvm::ArrayRef<TypePair> lenPList,
-                llvm::ArrayRef<TypePair> typeList);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
-  static constexpr unsigned getId() { return TypeKind::FIR_DERIVED; }
-
-  detail::RecordTypeStorage const *uniqueKey() const;
-
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          llvm::StringRef name);
-};
-
-mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
-
-void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);
-
-} // namespace fir
-
-#endif // OPTIMIZER_DIALECT_FIRTYPE_H
diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
deleted file mode 100644
index 8c8ed1f24afd..000000000000
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ /dev/null
@@ -1,90 +0,0 @@
-//===-- Optimizer/Support/KindMapping.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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPTIMIZER_SUPPORT_KINDMAPPING_H
-#define OPTIMIZER_SUPPORT_KINDMAPPING_H
-
-#include "mlir/IR/OpDefinition.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/IR/Type.h"
-
-namespace llvm {
-template <typename>
-class Optional;
-struct fltSemantics;
-} // namespace llvm
-
-namespace mlir {
-class MLIRContext;
-} // namespace mlir
-
-namespace fir {
-
-/// The kind mapping is an encoded string that informs FIR how the Fortran KIND
-/// values from the front-end should be converted to LLVM IR types.  This
-/// encoding allows the mapping from front-end KIND values to backend LLVM IR
-/// types to be customized by the front-end.
-///
-/// The provided string uses the following syntax.
-///
-///   intrinsic-key `:` kind-value (`,` intrinsic-key `:` kind-value)*
-///
-/// intrinsic-key is a single character for the intrinsic type.
-///   'i' : INTEGER   (size in bits)
-///   'l' : LOGICAL   (size in bits)
-///   'a' : CHARACTER (size in bits)
-///   'r' : REAL    (encoding value)
-///   'c' : COMPLEX (encoding value)
-///
-/// kind-value is either an unsigned integer (for 'i', 'l', and 'a') or one of
-/// 'Half', 'Float', 'Double', 'X86_FP80', or 'FP128' (for 'r' and 'c').
-///
-/// If LLVM adds support for new floating-point types, the final list should be
-/// extended.
-class KindMapping {
-public:
-  using KindTy = unsigned;
-  using Bitsize = unsigned;
-  using LLVMTypeID = llvm::Type::TypeID;
-  using MatchResult = mlir::ParseResult;
-
-  explicit KindMapping(mlir::MLIRContext *context);
-  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map);
-
-  /// Get the size in bits of !fir.char<kind>
-  Bitsize getCharacterBitsize(KindTy kind);
-
-  /// Get the size in bits of !fir.int<kind>
-  Bitsize getIntegerBitsize(KindTy kind);
-
-  /// Get the size in bits of !fir.logical<kind>
-  Bitsize getLogicalBitsize(KindTy kind);
-
-  /// Get the LLVM Type::TypeID of !fir.real<kind>
-  LLVMTypeID getRealTypeID(KindTy kind);
-
-  /// Get the LLVM Type::TypeID of !fir.complex<kind>
-  LLVMTypeID getComplexTypeID(KindTy kind);
-
-  mlir::MLIRContext *getContext() const { return context; }
-
-  /// Get the float semantics of !fir.real<kind>
-  const llvm::fltSemantics &getFloatSemantics(KindTy kind);
-
-private:
-  MatchResult badMapString(const llvm::Twine &ptr);
-  MatchResult parse(llvm::StringRef kindMap);
-
-  mlir::MLIRContext *context;
-  llvm::DenseMap<std::pair<char, KindTy>, Bitsize> intMap;
-  llvm::DenseMap<std::pair<char, KindTy>, LLVMTypeID> floatMap;
-};
-
-} // namespace fir
-
-#endif // OPTIMIZER_SUPPORT_KINDMAPPING_H
diff --git a/lib/Optimizer/CMakeLists.txt b/lib/Optimizer/CMakeLists.txt
deleted file mode 100644
index 2f8cd269dd9f..000000000000
--- a/lib/Optimizer/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-# Sources generated by tablegen have unused parameters.
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
-
-add_subdirectory(Dialect)
-add_subdirectory(Support)
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
deleted file mode 100644
index 76cccbfb06d3..000000000000
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-//===-- FIRAttr.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/Optimizer/Dialect/FIRAttr.h"
-#include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/KindMapping.h"
-#include "mlir/IR/AttributeSupport.h"
-#include "mlir/IR/Diagnostics.h"
-#include "mlir/IR/DialectImplementation.h"
-#include "mlir/IR/Types.h"
-#include "mlir/Parser.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
-
-using namespace fir;
-
-namespace fir {
-namespace detail {
-
-struct RealAttributeStorage : public mlir::AttributeStorage {
-  using KeyTy = std::pair<int, llvm::APFloat>;
-
-  RealAttributeStorage(int kind, const llvm::APFloat &value)
-      : kind(kind), value(value) {}
-  RealAttributeStorage(const KeyTy &key)
-      : RealAttributeStorage(key.first, key.second) {}
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_value(key); }
-
-  bool operator==(const KeyTy &key) const {
-    return key.first == kind &&
-           key.second.compare(value) == llvm::APFloatBase::cmpEqual;
-  }
-
-  static RealAttributeStorage *
-  construct(mlir::AttributeStorageAllocator &allocator, const KeyTy &key) {
-    return new (allocator.allocate<RealAttributeStorage>())
-        RealAttributeStorage(key);
-  }
-
-  int getFKind() const { return kind; }
-  llvm::APFloat getValue() const { return value; }
-
-private:
-  int kind;
-  llvm::APFloat value;
-};
-
-/// An attribute representing a reference to a type.
-struct TypeAttributeStorage : public mlir::AttributeStorage {
-  using KeyTy = mlir::Type;
-
-  TypeAttributeStorage(mlir::Type value) : value(value) {
-    assert(value && "must not be of Type null");
-  }
-
-  /// Key equality function.
-  bool operator==(const KeyTy &key) const { return key == value; }
-
-  /// Construct a new storage instance.
-  static TypeAttributeStorage *
-  construct(mlir::AttributeStorageAllocator &allocator, KeyTy key) {
-    return new (allocator.allocate<TypeAttributeStorage>())
-        TypeAttributeStorage(key);
-  }
-
-  mlir::Type getType() const { return value; }
-
-private:
-  mlir::Type value;
-};
-} // namespace detail
-
-ExactTypeAttr ExactTypeAttr::get(mlir::Type value) {
-  return Base::get(value.getContext(), FIR_EXACTTYPE, value);
-}
-
-mlir::Type ExactTypeAttr::getType() const { return getImpl()->getType(); }
-
-SubclassAttr SubclassAttr::get(mlir::Type value) {
-  return Base::get(value.getContext(), FIR_SUBCLASS, value);
-}
-
-mlir::Type SubclassAttr::getType() const { return getImpl()->getType(); }
-
-using AttributeUniquer = mlir::detail::AttributeUniquer;
-
-ClosedIntervalAttr ClosedIntervalAttr::get(mlir::MLIRContext *ctxt) {
-  return AttributeUniquer::get<ClosedIntervalAttr>(ctxt, getId());
-}
-
-UpperBoundAttr UpperBoundAttr::get(mlir::MLIRContext *ctxt) {
-  return AttributeUniquer::get<UpperBoundAttr>(ctxt, getId());
-}
-
-LowerBoundAttr LowerBoundAttr::get(mlir::MLIRContext *ctxt) {
-  return AttributeUniquer::get<LowerBoundAttr>(ctxt, getId());
-}
-
-PointIntervalAttr PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
-  return AttributeUniquer::get<PointIntervalAttr>(ctxt, getId());
-}
-
-// RealAttr
-
-RealAttr RealAttr::get(mlir::MLIRContext *ctxt,
-                       const RealAttr::ValueType &key) {
-  return Base::get(ctxt, getId(), key);
-}
-
-int RealAttr::getFKind() const { return getImpl()->getFKind(); }
-
-llvm::APFloat RealAttr::getValue() const { return getImpl()->getValue(); }
-
-// FIR attribute parsing
-
-namespace {
-mlir::Attribute parseFirRealAttr(FIROpsDialect *dialect,
-                                 mlir::DialectAsmParser &parser,
-                                 mlir::Type type) {
-  int kind = 0;
-  if (parser.parseLess() || parser.parseInteger(kind) || parser.parseComma()) {
-    parser.emitError(parser.getNameLoc(), "expected '<' kind ','");
-    return {};
-  }
-  KindMapping kindMap(dialect->getContext());
-  llvm::APFloat value(0.);
-  if (parser.parseOptionalKeyword("i")) {
-    // `i` not present, so literal float must be present
-    double dontCare;
-    if (parser.parseFloat(dontCare) || parser.parseGreater()) {
-      parser.emitError(parser.getNameLoc(), "expected real constant '>'");
-      return {};
-    }
-    auto fltStr = parser.getFullSymbolSpec()
-                      .drop_until([](char c) { return c == ','; })
-                      .drop_front()
-                      .drop_while([](char c) { return c == ' ' || c == '\t'; })
-                      .take_until([](char c) {
-                        return c == '>' || c == ' ' || c == '\t';
-                      });
-    value = llvm::APFloat(kindMap.getFloatSemantics(kind), fltStr);
-  } else {
-    // `i` is present, so literal bitstring (hex) must be present
-    llvm::StringRef hex;
-    if (parser.parseKeyword(&hex) || parser.parseGreater()) {
-      parser.emitError(parser.getNameLoc(), "expected real constant '>'");
-      return {};
-    }
-    auto bits = llvm::APInt(kind * 8, hex.drop_front(), 16);
-    value = llvm::APFloat(kindMap.getFloatSemantics(kind), bits);
-  }
-  return RealAttr::get(dialect->getContext(), {kind, value});
-}
-} // namespace
-
-mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
-                                  mlir::DialectAsmParser &parser,
-                                  mlir::Type type) {
-  auto loc = parser.getNameLoc();
-  llvm::StringRef attrName;
-  if (parser.parseKeyword(&attrName)) {
-    parser.emitError(loc, "expected an attribute name");
-    return {};
-  }
-
-  if (attrName == ExactTypeAttr::getAttrName()) {
-    mlir::Type type;
-    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
-      parser.emitError(loc, "expected a type");
-      return {};
-    }
-    return ExactTypeAttr::get(type);
-  }
-  if (attrName == SubclassAttr::getAttrName()) {
-    mlir::Type type;
-    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
-      parser.emitError(loc, "expected a subtype");
-      return {};
-    }
-    return SubclassAttr::get(type);
-  }
-  if (attrName == PointIntervalAttr::getAttrName())
-    return PointIntervalAttr::get(dialect->getContext());
-  if (attrName == LowerBoundAttr::getAttrName())
-    return LowerBoundAttr::get(dialect->getContext());
-  if (attrName == UpperBoundAttr::getAttrName())
-    return UpperBoundAttr::get(dialect->getContext());
-  if (attrName == ClosedIntervalAttr::getAttrName())
-    return ClosedIntervalAttr::get(dialect->getContext());
-  if (attrName == RealAttr::getAttrName())
-    return parseFirRealAttr(dialect, parser, type);
-
-  parser.emitError(loc, "unknown FIR attribute: ") << attrName;
-  return {};
-}
-
-// FIR attribute pretty printer
-
-void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
-                       mlir::DialectAsmPrinter &p) {
-  auto &os = p.getStream();
-  if (auto exact = attr.dyn_cast<fir::ExactTypeAttr>()) {
-    os << fir::ExactTypeAttr::getAttrName() << '<';
-    p.printType(exact.getType());
-    os << '>';
-  } else if (auto sub = attr.dyn_cast<fir::SubclassAttr>()) {
-    os << fir::SubclassAttr::getAttrName() << '<';
-    p.printType(sub.getType());
-    os << '>';
-  } else if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
-    os << fir::PointIntervalAttr::getAttrName();
-  } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
-    os << fir::ClosedIntervalAttr::getAttrName();
-  } else if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
-    os << fir::LowerBoundAttr::getAttrName();
-  } else if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
-    os << fir::UpperBoundAttr::getAttrName();
-  } else if (auto a = attr.dyn_cast_or_null<fir::RealAttr>()) {
-    os << fir::RealAttr::getAttrName() << '<' << a.getFKind() << ", i x";
-    llvm::SmallString<40> ss;
-    a.getValue().bitcastToAPInt().toStringUnsigned(ss, 16);
-    os << ss << '>';
-  } else {
-    llvm_unreachable("attribute pretty-printer is not implemented");
-  }
-}
-
-} // namespace fir
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
deleted file mode 100644
index 9a56c6bc403e..000000000000
--- a/lib/Optimizer/Dialect/FIRDialect.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===-- FIRDialect.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/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Dialect/FIRAttr.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/IR/StandardTypes.h"
-
-using namespace fir;
-
-fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect("fir", ctx) {
-  addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
-           FieldType, HeapType, IntType, LenType, LogicalType, PointerType,
-           RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
-  addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
-                PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
-  addOperations<
-#define GET_OP_LIST
-#include "flang/Optimizer/Dialect/FIROps.cpp.inc"
-      >();
-}
-
-// anchor the class vtable to this compilation unit
-fir::FIROpsDialect::~FIROpsDialect() {
-  // do nothing
-}
-
-mlir::Type fir::FIROpsDialect::parseType(mlir::DialectAsmParser &parser) const {
-  return parseFirType(const_cast<FIROpsDialect *>(this), parser);
-}
-
-void fir::FIROpsDialect::printType(mlir::Type ty,
-                                   mlir::DialectAsmPrinter &p) const {
-  return printFirType(const_cast<FIROpsDialect *>(this), ty, p);
-}
-
-mlir::Attribute
-fir::FIROpsDialect::parseAttribute(mlir::DialectAsmParser &parser,
-                                   mlir::Type type) const {
-  return parseFirAttribute(const_cast<FIROpsDialect *>(this), parser, type);
-}
-
-void fir::FIROpsDialect::printAttribute(mlir::Attribute attr,
-                                        mlir::DialectAsmPrinter &p) const {
-  printFirAttribute(const_cast<FIROpsDialect *>(this), attr, p);
-}
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
deleted file mode 100644
index 9c46de048336..000000000000
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ /dev/null
@@ -1,862 +0,0 @@
-//===-- FIROps.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/Optimizer/Dialect/FIROps.h"
-#include "flang/Optimizer/Dialect/FIRAttr.h"
-#include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
-#include "mlir/ADT/TypeSwitch.h"
-#include "mlir/Dialect/StandardOps/IR/Ops.h"
-#include "mlir/IR/Diagnostics.h"
-#include "mlir/IR/Function.h"
-#include "mlir/IR/Module.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/IR/SymbolTable.h"
-#include "llvm/ADT/StringSwitch.h"
-
-using namespace fir;
-
-/// return true if the sequence type is abstract or the record type is malformed
-/// or contains an abstract sequence type
-static bool verifyInType(mlir::Type inType,
-                         llvm::SmallVectorImpl<llvm::StringRef> &visited) {
-  if (auto st = inType.dyn_cast<fir::SequenceType>()) {
-    auto shape = st.getShape();
-    if (shape.size() == 0)
-      return true;
-    for (auto ext : shape)
-      if (ext < 0)
-        return true;
-  } else if (auto rt = inType.dyn_cast<fir::RecordType>()) {
-    // don't recurse if we're already visiting this one
-    if (llvm::is_contained(visited, rt.getName()))
-      return false;
-    // keep track of record types currently being visited
-    visited.push_back(rt.getName());
-    for (auto &field : rt.getTypeList())
-      if (verifyInType(field.second, visited))
-        return true;
-    visited.pop_back();
-  } else if (auto rt = inType.dyn_cast<fir::PointerType>()) {
-    return verifyInType(rt.getEleTy(), visited);
-  }
-  return false;
-}
-
-static bool verifyRecordLenParams(mlir::Type inType, unsigned numLenParams) {
-  if (numLenParams > 0) {
-    if (auto rt = inType.dyn_cast<fir::RecordType>())
-      return numLenParams != rt.getNumLenParams();
-    return true;
-  }
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// AllocaOp
-//===----------------------------------------------------------------------===//
-
-mlir::Type fir::AllocaOp::getAllocatedType() {
-  return getType().cast<ReferenceType>().getEleTy();
-}
-
-/// Create a legal memory reference as return type
-mlir::Type fir::AllocaOp::wrapResultType(mlir::Type intype) {
-  // FIR semantics: memory references to memory references are disallowed
-  if (intype.isa<ReferenceType>())
-    return {};
-  return ReferenceType::get(intype);
-}
-
-mlir::Type fir::AllocaOp::getRefTy(mlir::Type ty) {
-  return ReferenceType::get(ty);
-}
-
-//===----------------------------------------------------------------------===//
-// AllocMemOp
-//===----------------------------------------------------------------------===//
-
-mlir::Type fir::AllocMemOp::getAllocatedType() {
-  return getType().cast<HeapType>().getEleTy();
-}
-
-mlir::Type fir::AllocMemOp::getRefTy(mlir::Type ty) {
-  return HeapType::get(ty);
-}
-
-/// Create a legal heap reference as return type
-mlir::Type fir::AllocMemOp::wrapResultType(mlir::Type intype) {
-  // Fortran semantics: C852 an entity cannot be both ALLOCATABLE and POINTER
-  // 8.5.3 note 1 prohibits ALLOCATABLE procedures as well
-  // FIR semantics: one may not allocate a memory reference value
-  if (intype.isa<ReferenceType>() || intype.isa<HeapType>() ||
-      intype.isa<PointerType>() || intype.isa<FunctionType>())
-    return {};
-  return HeapType::get(intype);
-}
-
-//===----------------------------------------------------------------------===//
-// BoxDimsOp
-//===----------------------------------------------------------------------===//
-
-/// Get the result types packed in a tuple tuple
-mlir::Type fir::BoxDimsOp::getTupleType() {
-  // note: triple, but 4 is nearest power of 2
-  llvm::SmallVector<mlir::Type, 4> triple{
-      getResult(0).getType(), getResult(1).getType(), getResult(2).getType()};
-  return mlir::TupleType::get(triple, getContext());
-}
-
-//===----------------------------------------------------------------------===//
-// CallOp
-//===----------------------------------------------------------------------===//
-
-static void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
-  auto callee = op.callee();
-  bool isDirect = callee.hasValue();
-  p << op.getOperationName() << ' ';
-  if (isDirect)
-    p << callee.getValue();
-  else
-    p << op.getOperand(0);
-  p << '(' << op.getOperands().drop_front(isDirect ? 0 : 1) << ')';
-  p.printOptionalAttrDict(op.getAttrs(), {fir::CallOp::calleeAttrName()});
-  auto resultTypes{op.getResultTypes()};
-  llvm::SmallVector<Type, 8> argTypes(
-      llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
-  p << " : " << FunctionType::get(argTypes, resultTypes, op.getContext());
-}
-
-static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
-                                     mlir::OperationState &result) {
-  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
-  if (parser.parseOperandList(operands))
-    return mlir::failure();
-
-  llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
-  mlir::SymbolRefAttr funcAttr;
-  bool isDirect = operands.empty();
-  if (isDirect)
-    if (parser.parseAttribute(funcAttr, fir::CallOp::calleeAttrName(), attrs))
-      return mlir::failure();
-
-  Type type;
-  if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
-      parser.parseOptionalAttrDict(attrs) || parser.parseColon() ||
-      parser.parseType(type))
-    return mlir::failure();
-
-  auto funcType = type.dyn_cast<mlir::FunctionType>();
-  if (!funcType)
-    return parser.emitError(parser.getNameLoc(), "expected function type");
-  if (isDirect) {
-    if (parser.resolveOperands(operands, funcType.getInputs(),
-                               parser.getNameLoc(), result.operands))
-      return mlir::failure();
-  } else {
-    auto funcArgs =
-        llvm::ArrayRef<mlir::OpAsmParser::OperandType>(operands).drop_front();
-    llvm::SmallVector<mlir::Value, 8> resultArgs(
-        result.operands.begin() + (result.operands.empty() ? 0 : 1),
-        result.operands.end());
-    if (parser.resolveOperand(operands[0], funcType, result.operands) ||
-        parser.resolveOperands(funcArgs, funcType.getInputs(),
-                               parser.getNameLoc(), resultArgs))
-      return mlir::failure();
-  }
-  result.addTypes(funcType.getResults());
-  result.attributes = attrs;
-  return mlir::success();
-}
-
-//===----------------------------------------------------------------------===//
-// CmpfOp
-//===----------------------------------------------------------------------===//
-
-// Note: getCmpFPredicateNames() is inline static in StandardOps/IR/Ops.cpp
-mlir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
-  auto pred = mlir::symbolizeCmpFPredicate(name);
-  assert(pred.hasValue() && "invalid predicate name");
-  return pred.getValue();
-}
-
-void fir::buildCmpFOp(Builder *builder, OperationState &result,
-                      CmpFPredicate predicate, Value lhs, Value rhs) {
-  result.addOperands({lhs, rhs});
-  result.types.push_back(builder->getI1Type());
-  result.addAttribute(
-      CmpfOp::getPredicateAttrName(),
-      builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
-}
-
-template <typename OPTY>
-static void printCmpOp(OpAsmPrinter &p, OPTY op) {
-  p << op.getOperationName() << ' ';
-  auto predSym = mlir::symbolizeCmpFPredicate(
-      op.template getAttrOfType<mlir::IntegerAttr>(OPTY::getPredicateAttrName())
-          .getInt());
-  assert(predSym.hasValue() && "invalid symbol value for predicate");
-  p << '"' << mlir::stringifyCmpFPredicate(predSym.getValue()) << '"' << ", ";
-  p.printOperand(op.lhs());
-  p << ", ";
-  p.printOperand(op.rhs());
-  p.printOptionalAttrDict(op.getAttrs(),
-                          /*elidedAttrs=*/{OPTY::getPredicateAttrName()});
-  p << " : " << op.lhs().getType();
-}
-
-static void printCmpfOp(OpAsmPrinter &p, CmpfOp op) { printCmpOp(p, op); }
-
-template <typename OPTY>
-static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
-                                    mlir::OperationState &result) {
-  llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> ops;
-  llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
-  mlir::Attribute predicateNameAttr;
-  mlir::Type type;
-  if (parser.parseAttribute(predicateNameAttr, OPTY::getPredicateAttrName(),
-                            attrs) ||
-      parser.parseComma() || parser.parseOperandList(ops, 2) ||
-      parser.parseOptionalAttrDict(attrs) || parser.parseColonType(type) ||
-      parser.resolveOperands(ops, type, result.operands))
-    return failure();
-
-  if (!predicateNameAttr.isa<mlir::StringAttr>())
-    return parser.emitError(parser.getNameLoc(),
-                            "expected string comparison predicate attribute");
-
-  // Rewrite string attribute to an enum value.
-  llvm::StringRef predicateName =
-      predicateNameAttr.cast<mlir::StringAttr>().getValue();
-  auto predicate = fir::CmpfOp::getPredicateByName(predicateName);
-  auto builder = parser.getBuilder();
-  mlir::Type i1Type = builder.getI1Type();
-  attrs[0].second = builder.getI64IntegerAttr(static_cast<int64_t>(predicate));
-  result.attributes = attrs;
-  result.addTypes({i1Type});
-  return success();
-}
-
-mlir::ParseResult fir::parseCmpfOp(mlir::OpAsmParser &parser,
-                                   mlir::OperationState &result) {
-  return parseCmpOp<fir::CmpfOp>(parser, result);
-}
-
-//===----------------------------------------------------------------------===//
-// CmpcOp
-//===----------------------------------------------------------------------===//
-
-void fir::buildCmpCOp(Builder *builder, OperationState &result,
-                      CmpFPredicate predicate, Value lhs, Value rhs) {
-  result.addOperands({lhs, rhs});
-  result.types.push_back(builder->getI1Type());
-  result.addAttribute(
-      fir::CmpcOp::getPredicateAttrName(),
-      builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
-}
-
-static void printCmpcOp(OpAsmPrinter &p, fir::CmpcOp op) { printCmpOp(p, op); }
-
-mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
-                                   mlir::OperationState &result) {
-  return parseCmpOp<fir::CmpcOp>(parser, result);
-}
-
-//===----------------------------------------------------------------------===//
-// DispatchOp
-//===----------------------------------------------------------------------===//
-
-mlir::FunctionType fir::DispatchOp::getFunctionType() {
-  auto attr = getAttr("fn_type").cast<mlir::TypeAttr>();
-  return attr.getValue().cast<mlir::FunctionType>();
-}
-
-//===----------------------------------------------------------------------===//
-// DispatchTableOp
-//===----------------------------------------------------------------------===//
-
-void fir::DispatchTableOp::appendTableEntry(mlir::Operation *op) {
-  assert(mlir::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
-  auto &block = getBlock();
-  block.getOperations().insert(block.end(), op);
-}
-
-//===----------------------------------------------------------------------===//
-// EmboxOp
-//===----------------------------------------------------------------------===//
-
-static mlir::ParseResult parseEmboxOp(mlir::OpAsmParser &parser,
-                                      mlir::OperationState &result) {
-  mlir::FunctionType type;
-  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
-  mlir::OpAsmParser::OperandType memref;
-  if (parser.parseOperand(memref))
-    return mlir::failure();
-  operands.push_back(memref);
-  auto &builder = parser.getBuilder();
-  if (!parser.parseOptionalLParen()) {
-    if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None) ||
-        parser.parseRParen())
-      return mlir::failure();
-    auto lens = builder.getI32IntegerAttr(operands.size());
-    result.addAttribute(fir::EmboxOp::lenpName(), lens);
-  }
-  if (!parser.parseOptionalComma()) {
-    mlir::OpAsmParser::OperandType dims;
-    if (parser.parseOperand(dims))
-      return mlir::failure();
-    operands.push_back(dims);
-  } else if (!parser.parseOptionalLSquare()) {
-    mlir::AffineMapAttr map;
-    if (parser.parseAttribute(map, fir::EmboxOp::layoutName(),
-                              result.attributes) ||
-        parser.parseRSquare())
-      return mlir::failure();
-  }
-  if (parser.parseOptionalAttrDict(result.attributes) ||
-      parser.parseColonType(type) ||
-      parser.resolveOperands(operands, type.getInputs(), parser.getNameLoc(),
-                             result.operands) ||
-      parser.addTypesToList(type.getResults(), result.types))
-    return mlir::failure();
-  return mlir::success();
-}
-
-//===----------------------------------------------------------------------===//
-// GenTypeDescOp
-//===----------------------------------------------------------------------===//
-
-void fir::GenTypeDescOp::build(Builder *, OperationState &result,
-                               mlir::TypeAttr inty) {
-  result.addAttribute("in_type", inty);
-  result.addTypes(TypeDescType::get(inty.getValue()));
-}
-
-//===----------------------------------------------------------------------===//
-// GlobalOp
-//===----------------------------------------------------------------------===//
-
-void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
-  getBlock().getOperations().push_back(op);
-}
-
-//===----------------------------------------------------------------------===//
-// LoadOp
-//===----------------------------------------------------------------------===//
-
-/// Get the element type of a reference like type; otherwise null
-static mlir::Type elementTypeOf(mlir::Type ref) {
-  return mlir::TypeSwitch<mlir::Type, mlir::Type>(ref)
-      .Case<ReferenceType, PointerType, HeapType>(
-          [](auto type) { return type.getEleTy(); })
-      .Default([](mlir::Type) { return mlir::Type{}; });
-}
-
-mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
-  if ((ele = elementTypeOf(ref)))
-    return mlir::success();
-  return mlir::failure();
-}
-
-//===----------------------------------------------------------------------===//
-// LoopOp
-//===----------------------------------------------------------------------===//
-
-void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
-                        mlir::Value lb, mlir::Value ub, ValueRange step,
-                        ArrayRef<NamedAttribute> attributes) {
-  if (step.empty())
-    result.addOperands({lb, ub});
-  else
-    result.addOperands({lb, ub, step[0]});
-  mlir::Region *bodyRegion = result.addRegion();
-  LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
-  bodyRegion->front().addArgument(builder->getIndexType());
-  result.addAttributes(attributes);
-  NamedAttributeList attrs(attributes);
-  if (!attrs.get(unorderedAttrName()))
-    result.addTypes(builder->getIndexType());
-}
-
-static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
-                                     mlir::OperationState &result) {
-  auto &builder = parser.getBuilder();
-  OpAsmParser::OperandType inductionVariable, lb, ub, step;
-  // Parse the induction variable followed by '='.
-  if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
-    return mlir::failure();
-
-  // Parse loop bounds.
-  mlir::Type indexType = builder.getIndexType();
-  if (parser.parseOperand(lb) ||
-      parser.resolveOperand(lb, indexType, result.operands) ||
-      parser.parseKeyword("to") || parser.parseOperand(ub) ||
-      parser.resolveOperand(ub, indexType, result.operands))
-    return mlir::failure();
-
-  if (parser.parseOptionalKeyword(fir::LoopOp::stepAttrName())) {
-    result.addAttribute(fir::LoopOp::stepAttrName(),
-                        builder.getIntegerAttr(builder.getIndexType(), 1));
-  } else if (parser.parseOperand(step) ||
-             parser.resolveOperand(step, indexType, result.operands)) {
-    return mlir::failure();
-  }
-
-  // Parse the optional `unordered` keyword
-  bool isUnordered = false;
-  if (!parser.parseOptionalKeyword(LoopOp::unorderedAttrName())) {
-    result.addAttribute(LoopOp::unorderedAttrName(), builder.getUnitAttr());
-    isUnordered = true;
-  }
-
-  // Parse the body region.
-  mlir::Region *body = result.addRegion();
-  if (parser.parseRegion(*body, inductionVariable, indexType))
-    return mlir::failure();
-
-  fir::LoopOp::ensureTerminator(*body, builder, result.location);
-
-  // Parse the optional attribute list.
-  if (parser.parseOptionalAttrDict(result.attributes))
-    return mlir::failure();
-  if (!isUnordered)
-    result.addTypes(builder.getIndexType());
-  return mlir::success();
-}
-
-fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
-  auto ivArg = val.dyn_cast<mlir::BlockArgument>();
-  if (!ivArg)
-    return {};
-  assert(ivArg.getOwner() && "unlinked block argument");
-  auto *containingInst = ivArg.getOwner()->getParentOp();
-  return dyn_cast_or_null<fir::LoopOp>(containingInst);
-}
-
-//===----------------------------------------------------------------------===//
-// SelectOp
-//===----------------------------------------------------------------------===//
-
-static constexpr llvm::StringRef getCompareOffsetAttr() {
-  return "compare_operand_offsets";
-}
-
-static constexpr llvm::StringRef getTargetOffsetAttr() {
-  return "target_operand_offsets";
-}
-
-template <typename A>
-static A getSubOperands(unsigned pos, A allArgs,
-                        mlir::DenseIntElementsAttr ranges) {
-  unsigned start = 0;
-  for (unsigned i = 0; i < pos; ++i)
-    start += (*(ranges.begin() + i)).getZExtValue();
-  unsigned end = start + (*(ranges.begin() + pos)).getZExtValue();
-  return {std::next(allArgs.begin(), start), std::next(allArgs.begin(), end)};
-}
-
-llvm::Optional<mlir::OperandRange> fir::SelectOp::getCompareOperands(unsigned) {
-  return {};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
-  return {};
-}
-
-llvm::Optional<mlir::OperandRange>
-fir::SelectOp::getSuccessorOperands(unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  return {getSubOperands(oper, targetArgs(), a)};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
-                                    unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  auto segments =
-      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
-  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
-}
-
-bool fir::SelectOp::canEraseSuccessorOperand() { return true; }
-
-//===----------------------------------------------------------------------===//
-// SelectCaseOp
-//===----------------------------------------------------------------------===//
-
-llvm::Optional<mlir::OperandRange>
-fir::SelectCaseOp::getCompareOperands(unsigned cond) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr());
-  return {getSubOperands(cond, compareArgs(), a)};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectCaseOp::getCompareOperands(llvm::ArrayRef<mlir::Value> operands,
-                                      unsigned cond) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr());
-  auto segments =
-      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
-  return {getSubOperands(cond, getSubOperands(1, operands, segments), a)};
-}
-
-llvm::Optional<mlir::OperandRange>
-fir::SelectCaseOp::getSuccessorOperands(unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  return {getSubOperands(oper, targetArgs(), a)};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectCaseOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
-                                        unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  auto segments =
-      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
-  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
-}
-
-bool fir::SelectCaseOp::canEraseSuccessorOperand() { return true; }
-
-// parser for fir.select_case Op
-static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
-                                         mlir::OperationState &result) {
-  mlir::OpAsmParser::OperandType selector;
-  mlir::Type type;
-  if (parseSelector(parser, result, selector, type))
-    return mlir::failure();
-
-  llvm::SmallVector<mlir::Attribute, 8> attrs;
-  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> opers;
-  llvm::SmallVector<mlir::Block *, 8> dests;
-  llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
-  llvm::SmallVector<int32_t, 8> argOffs;
-  int32_t offSize = 0;
-  while (true) {
-    mlir::Attribute attr;
-    mlir::Block *dest;
-    llvm::SmallVector<mlir::Value, 8> destArg;
-    llvm::SmallVector<mlir::NamedAttribute, 1> temp;
-    if (parser.parseAttribute(attr, "a", temp) || isValidCaseAttr(attr) ||
-        parser.parseComma())
-      return mlir::failure();
-    attrs.push_back(attr);
-    if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
-      argOffs.push_back(0);
-    } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
-      mlir::OpAsmParser::OperandType oper1;
-      mlir::OpAsmParser::OperandType oper2;
-      if (parser.parseOperand(oper1) || parser.parseComma() ||
-          parser.parseOperand(oper2) || parser.parseComma())
-        return mlir::failure();
-      opers.push_back(oper1);
-      opers.push_back(oper2);
-      argOffs.push_back(2);
-      offSize += 2;
-    } else {
-      mlir::OpAsmParser::OperandType oper;
-      if (parser.parseOperand(oper) || parser.parseComma())
-        return mlir::failure();
-      opers.push_back(oper);
-      argOffs.push_back(1);
-      ++offSize;
-    }
-    if (parser.parseSuccessorAndUseList(dest, destArg))
-      return mlir::failure();
-    dests.push_back(dest);
-    destArgs.push_back(destArg);
-    if (!parser.parseOptionalRSquare())
-      break;
-    if (parser.parseComma())
-      return mlir::failure();
-  }
-  result.addAttribute(fir::SelectCaseOp::getCasesAttr(),
-                      parser.getBuilder().getArrayAttr(attrs));
-  if (parser.resolveOperands(opers, type, result.operands))
-    return mlir::failure();
-  llvm::SmallVector<int32_t, 8> targOffs;
-  int32_t toffSize = 0;
-  const auto count = dests.size();
-  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
-    result.addSuccessors(dests[i]);
-    result.addOperands(destArgs[i]);
-    auto argSize = destArgs[i].size();
-    targOffs.push_back(argSize);
-    toffSize += argSize;
-  }
-  auto &bld = parser.getBuilder();
-  result.addAttribute(fir::SelectCaseOp::getOperandSegmentSizeAttr(),
-                      bld.getI32VectorAttr({1, offSize, toffSize}));
-  result.addAttribute(getCompareOffsetAttr(), bld.getI32VectorAttr(argOffs));
-  result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(targOffs));
-  return mlir::success();
-}
-
-//===----------------------------------------------------------------------===//
-// SelectRankOp
-//===----------------------------------------------------------------------===//
-
-llvm::Optional<mlir::OperandRange>
-fir::SelectRankOp::getCompareOperands(unsigned) {
-  return {};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectRankOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
-  return {};
-}
-
-llvm::Optional<mlir::OperandRange>
-fir::SelectRankOp::getSuccessorOperands(unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  return {getSubOperands(oper, targetArgs(), a)};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectRankOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
-                                        unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  auto segments =
-      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
-  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
-}
-
-bool fir::SelectRankOp::canEraseSuccessorOperand() { return true; }
-
-//===----------------------------------------------------------------------===//
-// SelectTypeOp
-//===----------------------------------------------------------------------===//
-
-llvm::Optional<mlir::OperandRange>
-fir::SelectTypeOp::getCompareOperands(unsigned) {
-  return {};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectTypeOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
-  return {};
-}
-
-llvm::Optional<mlir::OperandRange>
-fir::SelectTypeOp::getSuccessorOperands(unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  return {getSubOperands(oper, targetArgs(), a)};
-}
-
-llvm::Optional<llvm::ArrayRef<mlir::Value>>
-fir::SelectTypeOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
-                                        unsigned oper) {
-  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
-  auto segments =
-      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
-  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
-}
-
-bool fir::SelectTypeOp::canEraseSuccessorOperand() { return true; }
-
-static ParseResult parseSelectType(OpAsmParser &parser,
-                                   OperationState &result) {
-  mlir::OpAsmParser::OperandType selector;
-  mlir::Type type;
-  if (parseSelector(parser, result, selector, type))
-    return mlir::failure();
-
-  llvm::SmallVector<mlir::Attribute, 8> attrs;
-  llvm::SmallVector<mlir::Block *, 8> dests;
-  llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
-  while (true) {
-    mlir::Attribute attr;
-    mlir::Block *dest;
-    llvm::SmallVector<mlir::Value, 8> destArg;
-    llvm::SmallVector<mlir::NamedAttribute, 1> temp;
-    if (parser.parseAttribute(attr, "a", temp) || parser.parseComma() ||
-        parser.parseSuccessorAndUseList(dest, destArg))
-      return mlir::failure();
-    attrs.push_back(attr);
-    dests.push_back(dest);
-    destArgs.push_back(destArg);
-    if (!parser.parseOptionalRSquare())
-      break;
-    if (parser.parseComma())
-      return mlir::failure();
-  }
-  auto &bld = parser.getBuilder();
-  result.addAttribute(fir::SelectTypeOp::getCasesAttr(),
-                      bld.getArrayAttr(attrs));
-  llvm::SmallVector<int32_t, 8> argOffs;
-  int32_t offSize = 0;
-  const auto count = dests.size();
-  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
-    result.addSuccessors(dests[i]);
-    result.addOperands(destArgs[i]);
-    auto argSize = destArgs[i].size();
-    argOffs.push_back(argSize);
-    offSize += argSize;
-  }
-  result.addAttribute(fir::SelectTypeOp::getOperandSegmentSizeAttr(),
-                      bld.getI32VectorAttr({1, 0, offSize}));
-  result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
-  return mlir::success();
-}
-
-//===----------------------------------------------------------------------===//
-// StoreOp
-//===----------------------------------------------------------------------===//
-
-mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
-  if (auto ref = refType.dyn_cast<ReferenceType>())
-    return ref.getEleTy();
-  if (auto ref = refType.dyn_cast<PointerType>())
-    return ref.getEleTy();
-  if (auto ref = refType.dyn_cast<HeapType>())
-    return ref.getEleTy();
-  return {};
-}
-
-//===----------------------------------------------------------------------===//
-// StringLitOp
-//===----------------------------------------------------------------------===//
-
-bool fir::StringLitOp::isWideValue() {
-  auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
-  return eleTy.cast<fir::CharacterType>().getFKind() != 1;
-}
-
-//===----------------------------------------------------------------------===//
-// WhereOp
-//===----------------------------------------------------------------------===//
-
-void fir::WhereOp::build(mlir::Builder *builder, OperationState &result,
-                         mlir::Value cond, bool withElseRegion) {
-  result.addOperands(cond);
-  mlir::Region *thenRegion = result.addRegion();
-  mlir::Region *elseRegion = result.addRegion();
-  WhereOp::ensureTerminator(*thenRegion, *builder, result.location);
-  if (withElseRegion)
-    WhereOp::ensureTerminator(*elseRegion, *builder, result.location);
-}
-
-static mlir::ParseResult parseWhereOp(OpAsmParser &parser,
-                                      OperationState &result) {
-  result.regions.reserve(2);
-  mlir::Region *thenRegion = result.addRegion();
-  mlir::Region *elseRegion = result.addRegion();
-
-  auto &builder = parser.getBuilder();
-  OpAsmParser::OperandType cond;
-  mlir::Type i1Type = builder.getIntegerType(1);
-  if (parser.parseOperand(cond) ||
-      parser.resolveOperand(cond, i1Type, result.operands))
-    return mlir::failure();
-
-  if (parser.parseRegion(*thenRegion, {}, {}))
-    return mlir::failure();
-
-  WhereOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
-
-  if (!parser.parseOptionalKeyword("otherwise")) {
-    if (parser.parseRegion(*elseRegion, {}, {}))
-      return mlir::failure();
-    WhereOp::ensureTerminator(*elseRegion, parser.getBuilder(),
-                              result.location);
-  }
-
-  // Parse the optional attribute list.
-  if (parser.parseOptionalAttrDict(result.attributes))
-    return mlir::failure();
-
-  return mlir::success();
-}
-
-//===----------------------------------------------------------------------===//
-
-mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {
-  if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||
-      attr.dyn_cast_or_null<ClosedIntervalAttr>() ||
-      attr.dyn_cast_or_null<PointIntervalAttr>() ||
-      attr.dyn_cast_or_null<LowerBoundAttr>() ||
-      attr.dyn_cast_or_null<UpperBoundAttr>())
-    return mlir::success();
-  return mlir::failure();
-}
-
-unsigned fir::getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
-                                    unsigned dest) {
-  unsigned o = 0;
-  for (unsigned i = 0; i < dest; ++i) {
-    auto &attr = cases[i];
-    if (!attr.dyn_cast_or_null<mlir::UnitAttr>()) {
-      ++o;
-      if (attr.dyn_cast_or_null<ClosedIntervalAttr>())
-        ++o;
-    }
-  }
-  return o;
-}
-
-mlir::ParseResult fir::parseSelector(mlir::OpAsmParser &parser,
-                                     mlir::OperationState &result,
-                                     mlir::OpAsmParser::OperandType &selector,
-                                     mlir::Type &type) {
-  if (parser.parseOperand(selector) || parser.parseColonType(type) ||
-      parser.resolveOperand(selector, type, result.operands) ||
-      parser.parseLSquare())
-    return mlir::failure();
-  return mlir::success();
-}
-
-/// Generic pretty-printer of a binary operation
-static void printBinaryOp(Operation *op, OpAsmPrinter &p) {
-  assert(op->getNumOperands() == 2 && "binary op must have two operands");
-  assert(op->getNumResults() == 1 && "binary op must have one result");
-
-  p << op->getName() << ' ' << op->getOperand(0) << ", " << op->getOperand(1);
-  p.printOptionalAttrDict(op->getAttrs());
-  p << " : " << op->getResult(0).getType();
-}
-
-/// Generic pretty-printer of an unary operation
-static void printUnaryOp(Operation *op, OpAsmPrinter &p) {
-  assert(op->getNumOperands() == 1 && "unary op must have one operand");
-  assert(op->getNumResults() == 1 && "unary op must have one result");
-
-  p << op->getName() << ' ' << op->getOperand(0);
-  p.printOptionalAttrDict(op->getAttrs());
-  p << " : " << op->getResult(0).getType();
-}
-
-bool fir::isReferenceLike(mlir::Type type) {
-  return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
-         type.isa<fir::PointerType>();
-}
-
-mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
-                               StringRef name, mlir::FunctionType type,
-                               llvm::ArrayRef<mlir::NamedAttribute> attrs) {
-  if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
-    return f;
-  mlir::OpBuilder modBuilder(module.getBodyRegion());
-  return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
-}
-
-fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
-                                  StringRef name, mlir::Type type,
-                                  llvm::ArrayRef<mlir::NamedAttribute> attrs) {
-  if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
-    return g;
-  mlir::OpBuilder modBuilder(module.getBodyRegion());
-  return modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
-}
-
-namespace fir {
-
-// Tablegen operators
-
-#define GET_OP_CLASSES
-#include "flang/Optimizer/Dialect/FIROps.cpp.inc"
-
-} // namespace fir
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
deleted file mode 100644
index d1fccd7be317..000000000000
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ /dev/null
@@ -1,1292 +0,0 @@
-//===-- FIRType.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/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "mlir/ADT/TypeSwitch.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/Diagnostics.h"
-#include "mlir/IR/Dialect.h"
-#include "mlir/IR/DialectImplementation.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Parser.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/StringSet.h"
-
-using namespace fir;
-
-namespace {
-
-template <typename TYPE>
-TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
-  int kind = 0;
-  if (parser.parseLess() || parser.parseInteger(kind) ||
-      parser.parseGreater()) {
-    parser.emitError(parser.getCurrentLocation(), "kind value expected");
-    return {};
-  }
-  return TYPE::get(parser.getBuilder().getContext(), kind);
-}
-
-template <typename TYPE>
-TYPE parseKindSingleton(mlir::DialectAsmParser &parser) {
-  return parseIntSingleton<TYPE>(parser);
-}
-
-template <typename TYPE>
-TYPE parseRankSingleton(mlir::DialectAsmParser &parser) {
-  return parseIntSingleton<TYPE>(parser);
-}
-
-template <typename TYPE>
-TYPE parseTypeSingleton(mlir::DialectAsmParser &parser, mlir::Location) {
-  mlir::Type ty;
-  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
-    parser.emitError(parser.getCurrentLocation(), "type expected");
-    return {};
-  }
-  return TYPE::get(ty);
-}
-
-// `box` `<` type (',' affine-map)? `>`
-BoxType parseBox(mlir::DialectAsmParser &parser, mlir::Location loc) {
-  mlir::Type ofTy;
-  if (parser.parseLess() || parser.parseType(ofTy)) {
-    parser.emitError(parser.getCurrentLocation(), "expected type parameter");
-    return {};
-  }
-
-  mlir::AffineMapAttr map;
-  if (!parser.parseOptionalComma())
-    if (parser.parseAttribute(map)) {
-      parser.emitError(parser.getCurrentLocation(), "expected affine map");
-      return {};
-    }
-  if (parser.parseGreater()) {
-    parser.emitError(parser.getCurrentLocation(), "expected '>'");
-    return {};
-  }
-  return BoxType::get(ofTy, map);
-}
-
-// `boxchar` `<` kind `>`
-BoxCharType parseBoxChar(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<BoxCharType>(parser);
-}
-
-// `boxproc` `<` return-type `>`
-BoxProcType parseBoxProc(mlir::DialectAsmParser &parser, mlir::Location loc) {
-  return parseTypeSingleton<BoxProcType>(parser, loc);
-}
-
-// `char` `<` kind `>`
-CharacterType parseCharacter(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<CharacterType>(parser);
-}
-
-// `complex` `<` kind `>`
-CplxType parseComplex(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<CplxType>(parser);
-}
-
-// `dims` `<` rank `>`
-DimsType parseDims(mlir::DialectAsmParser &parser) {
-  return parseRankSingleton<DimsType>(parser);
-}
-
-// `field`
-FieldType parseField(mlir::DialectAsmParser &parser) {
-  return FieldType::get(parser.getBuilder().getContext());
-}
-
-// `heap` `<` type `>`
-HeapType parseHeap(mlir::DialectAsmParser &parser, mlir::Location loc) {
-  return parseTypeSingleton<HeapType>(parser, loc);
-}
-
-// `int` `<` kind `>`
-IntType parseInteger(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<IntType>(parser);
-}
-
-// `len`
-LenType parseLen(mlir::DialectAsmParser &parser) {
-  return LenType::get(parser.getBuilder().getContext());
-}
-
-// `logical` `<` kind `>`
-LogicalType parseLogical(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<LogicalType>(parser);
-}
-
-// `ptr` `<` type `>`
-PointerType parsePointer(mlir::DialectAsmParser &parser, mlir::Location loc) {
-  return parseTypeSingleton<PointerType>(parser, loc);
-}
-
-// `real` `<` kind `>`
-RealType parseReal(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<RealType>(parser);
-}
-
-// `ref` `<` type `>`
-ReferenceType parseReference(mlir::DialectAsmParser &parser,
-                             mlir::Location loc) {
-  return parseTypeSingleton<ReferenceType>(parser, loc);
-}
-
-// `tdesc` `<` type `>`
-TypeDescType parseTypeDesc(mlir::DialectAsmParser &parser, mlir::Location loc) {
-  return parseTypeSingleton<TypeDescType>(parser, loc);
-}
-
-// `void`
-mlir::Type parseVoid(mlir::DialectAsmParser &parser) {
-  return parser.getBuilder().getNoneType();
-}
-
-// `array` `<` `*` | bounds (`x` bounds)* `:` type (',' affine-map)? `>`
-// bounds ::= `?` | int-lit
-SequenceType parseSequence(mlir::DialectAsmParser &parser, mlir::Location) {
-  if (parser.parseLess()) {
-    parser.emitError(parser.getNameLoc(), "expecting '<'");
-    return {};
-  }
-  SequenceType::Shape shape;
-  if (parser.parseOptionalStar()) {
-    if (parser.parseDimensionList(shape, true)) {
-      parser.emitError(parser.getNameLoc(), "invalid shape");
-      return {};
-    }
-  } else if (parser.parseColon()) {
-    parser.emitError(parser.getNameLoc(), "expected ':'");
-    return {};
-  }
-  mlir::Type eleTy;
-  if (parser.parseType(eleTy) || parser.parseGreater()) {
-    parser.emitError(parser.getNameLoc(), "expecting element type");
-    return {};
-  }
-  mlir::AffineMapAttr map;
-  if (!parser.parseOptionalComma())
-    if (parser.parseAttribute(map)) {
-      parser.emitError(parser.getNameLoc(), "expecting affine map");
-      return {};
-    }
-  return SequenceType::get(shape, eleTy, map);
-}
-
-bool verifyIntegerType(mlir::Type ty) {
-  return ty.isa<mlir::IntegerType>() || ty.isa<IntType>();
-}
-
-bool verifyRecordMemberType(mlir::Type ty) {
-  return !(ty.isa<BoxType>() || ty.isa<BoxCharType>() ||
-           ty.isa<BoxProcType>() || ty.isa<DimsType>() || ty.isa<FieldType>() ||
-           ty.isa<LenType>() || ty.isa<ReferenceType>() ||
-           ty.isa<TypeDescType>());
-}
-
-bool verifySameLists(llvm::ArrayRef<RecordType::TypePair> a1,
-                     llvm::ArrayRef<RecordType::TypePair> a2) {
-  // FIXME: do we need to allow for any variance here?
-  return a1 == a2;
-}
-
-RecordType verifyDerived(mlir::DialectAsmParser &parser, RecordType derivedTy,
-                         llvm::ArrayRef<RecordType::TypePair> lenPList,
-                         llvm::ArrayRef<RecordType::TypePair> typeList) {
-  auto loc = parser.getNameLoc();
-  if (!verifySameLists(derivedTy.getLenParamList(), lenPList) ||
-      !verifySameLists(derivedTy.getTypeList(), typeList)) {
-    parser.emitError(loc, "cannot redefine record type members");
-    return {};
-  }
-  for (auto &p : lenPList)
-    if (!verifyIntegerType(p.second)) {
-      parser.emitError(loc, "LEN parameter must be integral type");
-      return {};
-    }
-  for (auto &p : typeList)
-    if (!verifyRecordMemberType(p.second)) {
-      parser.emitError(loc, "field parameter has invalid type");
-      return {};
-    }
-  llvm::StringSet<> uniq;
-  for (auto &p : lenPList)
-    if (!uniq.insert(p.first).second) {
-      parser.emitError(loc, "LEN parameter cannot have duplicate name");
-      return {};
-    }
-  for (auto &p : typeList)
-    if (!uniq.insert(p.first).second) {
-      parser.emitError(loc, "field cannot have duplicate name");
-      return {};
-    }
-  return derivedTy;
-}
-
-// Fortran derived type
-// `type` `<` name
-//           (`(` id `:` type (`,` id `:` type)* `)`)?
-//           (`{` id `:` type (`,` id `:` type)* `}`)? '>'
-RecordType parseDerived(mlir::DialectAsmParser &parser, mlir::Location) {
-  llvm::StringRef name;
-  if (parser.parseLess() || parser.parseKeyword(&name)) {
-    parser.emitError(parser.getNameLoc(),
-                     "expected a identifier as name of derived type");
-    return {};
-  }
-  RecordType result = RecordType::get(parser.getBuilder().getContext(), name);
-
-  RecordType::TypeList lenParamList;
-  if (!parser.parseOptionalLParen()) {
-    while (true) {
-      llvm::StringRef lenparam;
-      mlir::Type intTy;
-      if (parser.parseKeyword(&lenparam) || parser.parseColon() ||
-          parser.parseType(intTy)) {
-        parser.emitError(parser.getNameLoc(), "expected LEN parameter list");
-        return {};
-      }
-      lenParamList.emplace_back(lenparam, intTy);
-      if (parser.parseOptionalComma())
-        break;
-    }
-    if (parser.parseRParen()) {
-      parser.emitError(parser.getNameLoc(), "expected ')'");
-      return {};
-    }
-  }
-
-  RecordType::TypeList typeList;
-  if (!parser.parseOptionalLBrace()) {
-    while (true) {
-      llvm::StringRef field;
-      mlir::Type fldTy;
-      if (parser.parseKeyword(&field) || parser.parseColon() ||
-          parser.parseType(fldTy)) {
-        parser.emitError(parser.getNameLoc(), "expected field type list");
-        return {};
-      }
-      typeList.emplace_back(field, fldTy);
-      if (parser.parseOptionalComma())
-        break;
-    }
-    if (parser.parseRBrace()) {
-      parser.emitError(parser.getNameLoc(), "expected '}'");
-      return {};
-    }
-  }
-
-  if (parser.parseGreater()) {
-    parser.emitError(parser.getNameLoc(), "expected '>' in type type");
-    return {};
-  }
-
-  if (lenParamList.empty() && typeList.empty())
-    return result;
-
-  result.finalize(lenParamList, typeList);
-  return verifyDerived(parser, result, lenParamList, typeList);
-}
-
-// !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
-// is undefined and disallowed.
-inline bool singleIndirectionLevel(mlir::Type ty) {
-  return !fir::isa_ref_type(ty);
-}
-
-} // namespace
-
-// Implementation of the thin interface from dialect to type parser
-
-mlir::Type fir::parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser) {
-  llvm::StringRef typeNameLit;
-  if (mlir::failed(parser.parseKeyword(&typeNameLit)))
-    return {};
-
-  auto loc = parser.getEncodedSourceLoc(parser.getNameLoc());
-  if (typeNameLit == "array")
-    return parseSequence(parser, loc);
-  if (typeNameLit == "box")
-    return parseBox(parser, loc);
-  if (typeNameLit == "boxchar")
-    return parseBoxChar(parser);
-  if (typeNameLit == "boxproc")
-    return parseBoxProc(parser, loc);
-  if (typeNameLit == "char")
-    return parseCharacter(parser);
-  if (typeNameLit == "complex")
-    return parseComplex(parser);
-  if (typeNameLit == "dims")
-    return parseDims(parser);
-  if (typeNameLit == "field")
-    return parseField(parser);
-  if (typeNameLit == "heap")
-    return parseHeap(parser, loc);
-  if (typeNameLit == "int")
-    return parseInteger(parser);
-  if (typeNameLit == "len")
-    return parseLen(parser);
-  if (typeNameLit == "logical")
-    return parseLogical(parser);
-  if (typeNameLit == "ptr")
-    return parsePointer(parser, loc);
-  if (typeNameLit == "real")
-    return parseReal(parser);
-  if (typeNameLit == "ref")
-    return parseReference(parser, loc);
-  if (typeNameLit == "tdesc")
-    return parseTypeDesc(parser, loc);
-  if (typeNameLit == "type")
-    return parseDerived(parser, loc);
-  if (typeNameLit == "void")
-    return parseVoid(parser);
-
-  parser.emitError(parser.getNameLoc(), "unknown FIR type " + typeNameLit);
-  return {};
-}
-
-namespace fir {
-namespace detail {
-
-// Type storage classes
-
-/// `CHARACTER` storage
-struct CharacterTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static CharacterTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                         KindTy kind) {
-    auto *storage = allocator.allocate<CharacterTypeStorage>();
-    return new (storage) CharacterTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-protected:
-  KindTy kind;
-
-private:
-  CharacterTypeStorage() = delete;
-  explicit CharacterTypeStorage(KindTy kind) : kind{kind} {}
-};
-
-struct DimsTypeStorage : public mlir::TypeStorage {
-  using KeyTy = unsigned;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const {
-    return key == static_cast<unsigned>(getRank());
-  }
-
-  static DimsTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                    int rank) {
-    auto *storage = allocator.allocate<DimsTypeStorage>();
-    return new (storage) DimsTypeStorage{rank};
-  }
-
-  int getRank() const { return rank; }
-
-protected:
-  int rank;
-
-private:
-  DimsTypeStorage() = delete;
-  explicit DimsTypeStorage(int rank) : rank{rank} {}
-};
-
-/// The type of a derived type part reference
-struct FieldTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
-
-  bool operator==(const KeyTy &) const { return true; }
-
-  static FieldTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                     KindTy) {
-    auto *storage = allocator.allocate<FieldTypeStorage>();
-    return new (storage) FieldTypeStorage{0};
-  }
-
-private:
-  FieldTypeStorage() = delete;
-  explicit FieldTypeStorage(KindTy) {}
-};
-
-/// The type of a derived type LEN parameter reference
-struct LenTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
-
-  bool operator==(const KeyTy &) const { return true; }
-
-  static LenTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                   KindTy) {
-    auto *storage = allocator.allocate<LenTypeStorage>();
-    return new (storage) LenTypeStorage{0};
-  }
-
-private:
-  LenTypeStorage() = delete;
-  explicit LenTypeStorage(KindTy) {}
-};
-
-/// `LOGICAL` storage
-struct LogicalTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static LogicalTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                       KindTy kind) {
-    auto *storage = allocator.allocate<LogicalTypeStorage>();
-    return new (storage) LogicalTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-protected:
-  KindTy kind;
-
-private:
-  LogicalTypeStorage() = delete;
-  explicit LogicalTypeStorage(KindTy kind) : kind{kind} {}
-};
-
-/// `INTEGER` storage
-struct IntTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static IntTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                   KindTy kind) {
-    auto *storage = allocator.allocate<IntTypeStorage>();
-    return new (storage) IntTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-protected:
-  KindTy kind;
-
-private:
-  IntTypeStorage() = delete;
-  explicit IntTypeStorage(KindTy kind) : kind{kind} {}
-};
-
-/// `COMPLEX` storage
-struct CplxTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static CplxTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                    KindTy kind) {
-    auto *storage = allocator.allocate<CplxTypeStorage>();
-    return new (storage) CplxTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-protected:
-  KindTy kind;
-
-private:
-  CplxTypeStorage() = delete;
-  explicit CplxTypeStorage(KindTy kind) : kind{kind} {}
-};
-
-/// `REAL` storage (for reals of unsupported sizes)
-struct RealTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static RealTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                    KindTy kind) {
-    auto *storage = allocator.allocate<RealTypeStorage>();
-    return new (storage) RealTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-protected:
-  KindTy kind;
-
-private:
-  RealTypeStorage() = delete;
-  explicit RealTypeStorage(KindTy kind) : kind{kind} {}
-};
-
-/// Boxed object (a Fortran descriptor)
-struct BoxTypeStorage : public mlir::TypeStorage {
-  using KeyTy = std::tuple<mlir::Type, mlir::AffineMapAttr>;
-
-  static unsigned hashKey(const KeyTy &key) {
-    auto hashVal{llvm::hash_combine(std::get<mlir::Type>(key))};
-    return llvm::hash_combine(
-        hashVal, llvm::hash_combine(std::get<mlir::AffineMapAttr>(key)));
-  }
-
-  bool operator==(const KeyTy &key) const {
-    return std::get<mlir::Type>(key) == getElementType() &&
-           std::get<mlir::AffineMapAttr>(key) == getLayoutMap();
-  }
-
-  static BoxTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                   const KeyTy &key) {
-    auto *storage = allocator.allocate<BoxTypeStorage>();
-    return new (storage) BoxTypeStorage{std::get<mlir::Type>(key),
-                                        std::get<mlir::AffineMapAttr>(key)};
-  }
-
-  mlir::Type getElementType() const { return eleTy; }
-  mlir::AffineMapAttr getLayoutMap() const { return map; }
-
-protected:
-  mlir::Type eleTy;
-  mlir::AffineMapAttr map;
-
-private:
-  BoxTypeStorage() = delete;
-  explicit BoxTypeStorage(mlir::Type eleTy, mlir::AffineMapAttr map)
-      : eleTy{eleTy}, map{map} {}
-};
-
-/// Boxed CHARACTER object type
-struct BoxCharTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static BoxCharTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                       KindTy kind) {
-    auto *storage = allocator.allocate<BoxCharTypeStorage>();
-    return new (storage) BoxCharTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-  // a !fir.boxchar<k> always wraps a !fir.char<k>
-  CharacterType getElementType(mlir::MLIRContext *ctxt) const {
-    return CharacterType::get(ctxt, getFKind());
-  }
-
-protected:
-  KindTy kind;
-
-private:
-  BoxCharTypeStorage() = delete;
-  explicit BoxCharTypeStorage(KindTy kind) : kind{kind} {}
-};
-
-/// Boxed PROCEDURE POINTER object type
-struct BoxProcTypeStorage : public mlir::TypeStorage {
-  using KeyTy = mlir::Type;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getElementType(); }
-
-  static BoxProcTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                       mlir::Type eleTy) {
-    assert(eleTy && "element type is null");
-    auto *storage = allocator.allocate<BoxProcTypeStorage>();
-    return new (storage) BoxProcTypeStorage{eleTy};
-  }
-
-  mlir::Type getElementType() const { return eleTy; }
-
-protected:
-  mlir::Type eleTy;
-
-private:
-  BoxProcTypeStorage() = delete;
-  explicit BoxProcTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
-};
-
-/// Pointer-like object storage
-struct ReferenceTypeStorage : public mlir::TypeStorage {
-  using KeyTy = mlir::Type;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getElementType(); }
-
-  static ReferenceTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                         mlir::Type eleTy) {
-    assert(eleTy && "element type is null");
-    auto *storage = allocator.allocate<ReferenceTypeStorage>();
-    return new (storage) ReferenceTypeStorage{eleTy};
-  }
-
-  mlir::Type getElementType() const { return eleTy; }
-
-protected:
-  mlir::Type eleTy;
-
-private:
-  ReferenceTypeStorage() = delete;
-  explicit ReferenceTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
-};
-
-/// Pointer object storage
-struct PointerTypeStorage : public mlir::TypeStorage {
-  using KeyTy = mlir::Type;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getElementType(); }
-
-  static PointerTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                       mlir::Type eleTy) {
-    assert(eleTy && "element type is null");
-    auto *storage = allocator.allocate<PointerTypeStorage>();
-    return new (storage) PointerTypeStorage{eleTy};
-  }
-
-  mlir::Type getElementType() const { return eleTy; }
-
-protected:
-  mlir::Type eleTy;
-
-private:
-  PointerTypeStorage() = delete;
-  explicit PointerTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
-};
-
-/// Heap memory reference object storage
-struct HeapTypeStorage : public mlir::TypeStorage {
-  using KeyTy = mlir::Type;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getElementType(); }
-
-  static HeapTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                    mlir::Type eleTy) {
-    assert(eleTy && "element type is null");
-    auto *storage = allocator.allocate<HeapTypeStorage>();
-    return new (storage) HeapTypeStorage{eleTy};
-  }
-
-  mlir::Type getElementType() const { return eleTy; }
-
-protected:
-  mlir::Type eleTy;
-
-private:
-  HeapTypeStorage() = delete;
-  explicit HeapTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
-};
-
-/// Sequence-like object storage
-struct SequenceTypeStorage : public mlir::TypeStorage {
-  using KeyTy =
-      std::tuple<SequenceType::Shape, mlir::Type, mlir::AffineMapAttr>;
-
-  static unsigned hashKey(const KeyTy &key) {
-    auto shapeHash{hash_value(std::get<SequenceType::Shape>(key))};
-    shapeHash = llvm::hash_combine(shapeHash, std::get<mlir::Type>(key));
-    return llvm::hash_combine(shapeHash, std::get<mlir::AffineMapAttr>(key));
-  }
-
-  bool operator==(const KeyTy &key) const {
-    return key == KeyTy{getShape(), getElementType(), getLayoutMap()};
-  }
-
-  static SequenceTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                        const KeyTy &key) {
-    auto *storage = allocator.allocate<SequenceTypeStorage>();
-    return new (storage) SequenceTypeStorage{
-        std::get<SequenceType::Shape>(key), std::get<mlir::Type>(key),
-        std::get<mlir::AffineMapAttr>(key)};
-  }
-
-  SequenceType::Shape getShape() const { return shape; }
-  mlir::Type getElementType() const { return eleTy; }
-  mlir::AffineMapAttr getLayoutMap() const { return map; }
-
-protected:
-  SequenceType::Shape shape;
-  mlir::Type eleTy;
-  mlir::AffineMapAttr map;
-
-private:
-  SequenceTypeStorage() = delete;
-  explicit SequenceTypeStorage(const SequenceType::Shape &shape,
-                               mlir::Type eleTy, mlir::AffineMapAttr map)
-      : shape{shape}, eleTy{eleTy}, map{map} {}
-};
-
-/// Derived type storage
-struct RecordTypeStorage : public mlir::TypeStorage {
-  using KeyTy = llvm::StringRef;
-
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_combine(key.str());
-  }
-
-  bool operator==(const KeyTy &key) const { return key == getName(); }
-
-  static RecordTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                      const KeyTy &key) {
-    auto *storage = allocator.allocate<RecordTypeStorage>();
-    return new (storage) RecordTypeStorage{key};
-  }
-
-  llvm::StringRef getName() const { return name; }
-
-  void setLenParamList(llvm::ArrayRef<RecordType::TypePair> list) {
-    lens = list;
-  }
-  llvm::ArrayRef<RecordType::TypePair> getLenParamList() const { return lens; }
-
-  void setTypeList(llvm::ArrayRef<RecordType::TypePair> list) { types = list; }
-  llvm::ArrayRef<RecordType::TypePair> getTypeList() const { return types; }
-
-  void finalize(llvm::ArrayRef<RecordType::TypePair> lenParamList,
-                llvm::ArrayRef<RecordType::TypePair> typeList) {
-    if (finalized)
-      return;
-    finalized = true;
-    setLenParamList(lenParamList);
-    setTypeList(typeList);
-  }
-
-protected:
-  std::string name;
-  bool finalized;
-  std::vector<RecordType::TypePair> lens;
-  std::vector<RecordType::TypePair> types;
-
-private:
-  RecordTypeStorage() = delete;
-  explicit RecordTypeStorage(llvm::StringRef name)
-      : name{name}, finalized{false} {}
-};
-
-/// Type descriptor type storage
-struct TypeDescTypeStorage : public mlir::TypeStorage {
-  using KeyTy = mlir::Type;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getOfType(); }
-
-  static TypeDescTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                        mlir::Type ofTy) {
-    assert(ofTy && "descriptor type is null");
-    auto *storage = allocator.allocate<TypeDescTypeStorage>();
-    return new (storage) TypeDescTypeStorage{ofTy};
-  }
-
-  // The type described by this type descriptor instance
-  mlir::Type getOfType() const { return ofTy; }
-
-protected:
-  mlir::Type ofTy;
-
-private:
-  TypeDescTypeStorage() = delete;
-  explicit TypeDescTypeStorage(mlir::Type ofTy) : ofTy{ofTy} {}
-};
-
-} // namespace detail
-
-template <typename A, typename B>
-bool inbounds(A v, B lb, B ub) {
-  return v >= lb && v < ub;
-}
-
-bool isa_fir_type(mlir::Type t) {
-  return inbounds(t.getKind(), mlir::Type::FIRST_FIR_TYPE,
-                  mlir::Type::LAST_FIR_TYPE);
-}
-
-bool isa_std_type(mlir::Type t) {
-  return inbounds(t.getKind(), mlir::Type::FIRST_STANDARD_TYPE,
-                  mlir::Type::LAST_STANDARD_TYPE);
-}
-
-bool isa_fir_or_std_type(mlir::Type t) {
-  return isa_fir_type(t) || isa_std_type(t);
-}
-
-bool isa_ref_type(mlir::Type t) {
-  return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
-}
-
-bool isa_aggregate(mlir::Type t) {
-  return t.isa<SequenceType>() || t.isa<RecordType>();
-}
-
-mlir::Type dyn_cast_ptrEleTy(mlir::Type t) {
-  return mlir::TypeSwitch<mlir::Type, mlir::Type>(t)
-      .Case<fir::ReferenceType, fir::PointerType, fir::HeapType>(
-          [](auto p) { return p.getEleTy(); })
-      .Default([](mlir::Type) { return mlir::Type{}; });
-}
-
-} // namespace fir
-
-// CHARACTER
-
-CharacterType fir::CharacterType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, FIR_CHARACTER, kind);
-}
-
-int fir::CharacterType::getFKind() const { return getImpl()->getFKind(); }
-
-// Dims
-
-DimsType fir::DimsType::get(mlir::MLIRContext *ctxt, unsigned rank) {
-  return Base::get(ctxt, FIR_DIMS, rank);
-}
-
-int fir::DimsType::getRank() const { return getImpl()->getRank(); }
-
-// Field
-
-FieldType fir::FieldType::get(mlir::MLIRContext *ctxt) {
-  return Base::get(ctxt, FIR_FIELD, 0);
-}
-
-// Len
-
-LenType fir::LenType::get(mlir::MLIRContext *ctxt) {
-  return Base::get(ctxt, FIR_LEN, 0);
-}
-
-// LOGICAL
-
-LogicalType fir::LogicalType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, FIR_LOGICAL, kind);
-}
-
-int fir::LogicalType::getFKind() const { return getImpl()->getFKind(); }
-
-// INTEGER
-
-IntType fir::IntType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, FIR_INT, kind);
-}
-
-int fir::IntType::getFKind() const { return getImpl()->getFKind(); }
-
-// COMPLEX
-
-CplxType fir::CplxType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, FIR_COMPLEX, kind);
-}
-
-KindTy fir::CplxType::getFKind() const { return getImpl()->getFKind(); }
-
-// REAL
-
-RealType fir::RealType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, FIR_REAL, kind);
-}
-
-int fir::RealType::getFKind() const { return getImpl()->getFKind(); }
-
-// Box<T>
-
-BoxType fir::BoxType::get(mlir::Type elementType, mlir::AffineMapAttr map) {
-  return Base::get(elementType.getContext(), FIR_BOX, elementType, map);
-}
-
-mlir::Type fir::BoxType::getEleTy() const {
-  return getImpl()->getElementType();
-}
-
-mlir::AffineMapAttr fir::BoxType::getLayoutMap() const {
-  return getImpl()->getLayoutMap();
-}
-
-mlir::LogicalResult
-fir::BoxType::verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
-                                           mlir::AffineMapAttr map) {
-  // TODO
-  return mlir::success();
-}
-
-// BoxChar<C>
-
-BoxCharType fir::BoxCharType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, FIR_BOXCHAR, kind);
-}
-
-CharacterType fir::BoxCharType::getEleTy() const {
-  return getImpl()->getElementType(getContext());
-}
-
-// BoxProc<T>
-
-BoxProcType fir::BoxProcType::get(mlir::Type elementType) {
-  return Base::get(elementType.getContext(), FIR_BOXPROC, elementType);
-}
-
-mlir::Type fir::BoxProcType::getEleTy() const {
-  return getImpl()->getElementType();
-}
-
-mlir::LogicalResult
-fir::BoxProcType::verifyConstructionInvariants(mlir::Location loc,
-                                               mlir::Type eleTy) {
-  if (eleTy.isa<mlir::FunctionType>())
-    return mlir::success();
-  if (auto refTy = eleTy.dyn_cast<ReferenceType>())
-    if (refTy.isa<mlir::FunctionType>())
-      return mlir::success();
-  return mlir::emitError(loc, "invalid type for boxproc") << eleTy << '\n';
-}
-
-// Reference<T>
-
-ReferenceType fir::ReferenceType::get(mlir::Type elementType) {
-  return Base::get(elementType.getContext(), FIR_REFERENCE, elementType);
-}
-
-mlir::Type fir::ReferenceType::getEleTy() const {
-  return getImpl()->getElementType();
-}
-
-mlir::LogicalResult
-fir::ReferenceType::verifyConstructionInvariants(mlir::Location loc,
-                                                 mlir::Type eleTy) {
-  if (eleTy.isa<DimsType>() || eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
-      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
-    return mlir::emitError(loc, "cannot build a reference to type: ")
-           << eleTy << '\n';
-  return mlir::success();
-}
-
-// Pointer<T>
-
-PointerType fir::PointerType::get(mlir::Type elementType) {
-  if (!singleIndirectionLevel(elementType)) {
-    llvm_unreachable("FIXME: invalid element type");
-    return {};
-  }
-  return Base::get(elementType.getContext(), FIR_POINTER, elementType);
-}
-
-mlir::Type fir::PointerType::getEleTy() const {
-  return getImpl()->getElementType();
-}
-
-static bool canBePointerOrHeapElementType(mlir::Type eleTy) {
-  return eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
-         eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
-         eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
-         eleTy.isa<HeapType>() || eleTy.isa<PointerType>() ||
-         eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>();
-}
-
-mlir::LogicalResult
-fir::PointerType::verifyConstructionInvariants(mlir::Location loc,
-                                               mlir::Type eleTy) {
-  if (canBePointerOrHeapElementType(eleTy))
-    return mlir::emitError(loc, "cannot build a pointer to type: ")
-           << eleTy << '\n';
-  return mlir::success();
-}
-
-// Heap<T>
-
-HeapType fir::HeapType::get(mlir::Type elementType) {
-  if (!singleIndirectionLevel(elementType)) {
-    llvm_unreachable("FIXME: invalid element type");
-    return {};
-  }
-  return Base::get(elementType.getContext(), FIR_HEAP, elementType);
-}
-
-mlir::Type fir::HeapType::getEleTy() const {
-  return getImpl()->getElementType();
-}
-
-mlir::LogicalResult
-fir::HeapType::verifyConstructionInvariants(mlir::Location loc,
-                                            mlir::Type eleTy) {
-  if (canBePointerOrHeapElementType(eleTy))
-    return mlir::emitError(loc, "cannot build a heap pointer to type: ")
-           << eleTy << '\n';
-  return mlir::success();
-}
-
-// Sequence<T>
-
-SequenceType fir::SequenceType::get(const Shape &shape, mlir::Type elementType,
-                                    mlir::AffineMapAttr map) {
-  auto *ctxt = elementType.getContext();
-  return Base::get(ctxt, FIR_SEQUENCE, shape, elementType, map);
-}
-
-mlir::Type fir::SequenceType::getEleTy() const {
-  return getImpl()->getElementType();
-}
-
-mlir::AffineMapAttr fir::SequenceType::getLayoutMap() const {
-  return getImpl()->getLayoutMap();
-}
-
-SequenceType::Shape fir::SequenceType::getShape() const {
-  return getImpl()->getShape();
-}
-
-mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
-    mlir::Location loc, const SequenceType::Shape &shape, mlir::Type eleTy,
-    mlir::AffineMapAttr map) {
-  // DIMENSION attribute can only be applied to an intrinsic or record type
-  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
-      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
-      eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
-      eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
-      eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>())
-    return mlir::emitError(loc, "cannot build an array of this element type: ")
-           << eleTy << '\n';
-  return mlir::success();
-}
-
-// compare if two shapes are equivalent
-bool fir::operator==(const SequenceType::Shape &sh_1,
-                     const SequenceType::Shape &sh_2) {
-  if (sh_1.size() != sh_2.size())
-    return false;
-  auto e = sh_1.size();
-  for (decltype(e) i = 0; i != e; ++i)
-    if (sh_1[i] != sh_2[i])
-      return false;
-  return true;
-}
-
-// compute the hash of a Shape
-llvm::hash_code fir::hash_value(const SequenceType::Shape &sh) {
-  if (sh.size()) {
-    return llvm::hash_combine_range(sh.begin(), sh.end());
-  }
-  return llvm::hash_combine(0);
-}
-
-/// RecordType
-///
-/// This type captures a Fortran "derived type"
-
-RecordType fir::RecordType::get(mlir::MLIRContext *ctxt, llvm::StringRef name) {
-  return Base::get(ctxt, FIR_DERIVED, name);
-}
-
-void fir::RecordType::finalize(llvm::ArrayRef<TypePair> lenPList,
-                               llvm::ArrayRef<TypePair> typeList) {
-  getImpl()->finalize(lenPList, typeList);
-}
-
-llvm::StringRef fir::RecordType::getName() { return getImpl()->getName(); }
-
-RecordType::TypeList fir::RecordType::getTypeList() {
-  return getImpl()->getTypeList();
-}
-
-RecordType::TypeList fir::RecordType::getLenParamList() {
-  return getImpl()->getLenParamList();
-}
-
-detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
-  return getImpl();
-}
-
-mlir::LogicalResult
-fir::RecordType::verifyConstructionInvariants(mlir::Location loc,
-                                              llvm::StringRef name) {
-  if (name.size() == 0)
-    return mlir::emitError(loc, "record types must have a name");
-  return mlir::success();
-}
-
-mlir::Type fir::RecordType::getType(llvm::StringRef ident) {
-  for (auto f : getTypeList())
-    if (ident == f.first)
-      return f.second;
-  llvm_unreachable("query for field not present in record");
-  return {};
-}
-
-/// Type descriptor type
-///
-/// This is the type of a type descriptor object (similar to a class instance)
-
-TypeDescType fir::TypeDescType::get(mlir::Type ofType) {
-  assert(!ofType.isa<ReferenceType>());
-  return Base::get(ofType.getContext(), FIR_TYPEDESC, ofType);
-}
-
-mlir::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
-
-mlir::LogicalResult
-fir::TypeDescType::verifyConstructionInvariants(mlir::Location loc,
-                                                mlir::Type eleTy) {
-  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
-      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
-      eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
-      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
-    return mlir::emitError(loc, "cannot build a type descriptor of type: ")
-           << eleTy << '\n';
-  return mlir::success();
-}
-
-namespace {
-
-void printBounds(llvm::raw_ostream &os, const SequenceType::Shape &bounds) {
-  os << '<';
-  for (auto &b : bounds) {
-    if (b >= 0) {
-      os << b << 'x';
-    } else {
-      os << "?x";
-    }
-  }
-}
-
-llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4> recordTypeVisited;
-
-} // namespace
-
-void fir::printFirType(FIROpsDialect *, mlir::Type ty,
-                       mlir::DialectAsmPrinter &p) {
-  auto &os = p.getStream();
-  switch (ty.getKind()) {
-  case fir::FIR_BOX: {
-    auto type = ty.cast<BoxType>();
-    os << "box<";
-    p.printType(type.getEleTy());
-    if (auto map = type.getLayoutMap()) {
-      os << ", ";
-      p.printAttribute(map);
-    }
-    os << '>';
-  } break;
-  case fir::FIR_BOXCHAR: {
-    auto type = ty.cast<BoxCharType>().getEleTy();
-    os << "boxchar<" << type.cast<fir::CharacterType>().getFKind() << '>';
-  } break;
-  case fir::FIR_BOXPROC:
-    os << "boxproc<";
-    p.printType(ty.cast<BoxProcType>().getEleTy());
-    os << '>';
-    break;
-  case fir::FIR_CHARACTER: // intrinsic
-    os << "char<" << ty.cast<CharacterType>().getFKind() << '>';
-    break;
-  case fir::FIR_COMPLEX: // intrinsic
-    os << "complex<" << ty.cast<CplxType>().getFKind() << '>';
-    break;
-  case fir::FIR_DERIVED: { // derived
-    auto type = ty.cast<fir::RecordType>();
-    os << "type<" << type.getName();
-    if (!recordTypeVisited.count(type.uniqueKey())) {
-      recordTypeVisited.insert(type.uniqueKey());
-      if (type.getLenParamList().size()) {
-        char ch = '(';
-        for (auto p : type.getLenParamList()) {
-          os << ch << p.first << ':';
-          p.second.print(os);
-          ch = ',';
-        }
-        os << ')';
-      }
-      if (type.getTypeList().size()) {
-        char ch = '{';
-        for (auto p : type.getTypeList()) {
-          os << ch << p.first << ':';
-          p.second.print(os);
-          ch = ',';
-        }
-        os << '}';
-      }
-      recordTypeVisited.erase(type.uniqueKey());
-    }
-    os << '>';
-  } break;
-  case fir::FIR_DIMS:
-    os << "dims<" << ty.cast<DimsType>().getRank() << '>';
-    break;
-  case fir::FIR_FIELD:
-    os << "field";
-    break;
-  case fir::FIR_HEAP:
-    os << "heap<";
-    p.printType(ty.cast<HeapType>().getEleTy());
-    os << '>';
-    break;
-  case fir::FIR_INT: // intrinsic
-    os << "int<" << ty.cast<fir::IntType>().getFKind() << '>';
-    break;
-  case fir::FIR_LEN:
-    os << "len";
-    break;
-  case fir::FIR_LOGICAL: // intrinsic
-    os << "logical<" << ty.cast<LogicalType>().getFKind() << '>';
-    break;
-  case fir::FIR_POINTER:
-    os << "ptr<";
-    p.printType(ty.cast<PointerType>().getEleTy());
-    os << '>';
-    break;
-  case fir::FIR_REAL: // intrinsic
-    os << "real<" << ty.cast<fir::RealType>().getFKind() << '>';
-    break;
-  case fir::FIR_REFERENCE:
-    os << "ref<";
-    p.printType(ty.cast<ReferenceType>().getEleTy());
-    os << '>';
-    break;
-  case fir::FIR_SEQUENCE: {
-    os << "array";
-    auto type = ty.cast<SequenceType>();
-    auto shape = type.getShape();
-    if (shape.size()) {
-      printBounds(os, shape);
-    } else {
-      os << "<*:";
-    }
-    p.printType(ty.cast<SequenceType>().getEleTy());
-    if (auto map = type.getLayoutMap()) {
-      os << ", ";
-      map.print(os);
-    }
-    os << '>';
-  } break;
-  case fir::FIR_TYPEDESC:
-    os << "tdesc<";
-    p.printType(ty.cast<TypeDescType>().getOfTy());
-    os << '>';
-    break;
-  }
-}
diff --git a/lib/Optimizer/Support/CMakeLists.txt b/lib/Optimizer/Support/CMakeLists.txt
deleted file mode 100644
index 88a1fc78a5f6..000000000000
--- a/lib/Optimizer/Support/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-add_llvm_library(FIRSupport
-  KindMapping.cpp
-)
-
-target_link_libraries(FIRSupport FIRDialect)
-
-install (TARGETS FIRSupport
-  ARCHIVE DESTINATION lib
-  LIBRARY DESTINATION lib
-)
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
deleted file mode 100644
index 8731c0bb087e..000000000000
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-//===-- KindMapping.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/Optimizer/Support/KindMapping.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/Support/CommandLine.h"
-
-/// Allow the user to set the FIR intrinsic type kind value to LLVM type
-/// mappings.  Note that these are not mappings from kind values to any
-/// other MLIR dialect, only to LLVM IR. The default values follow the f18
-/// front-end kind mappings.
-
-using Bitsize = fir::KindMapping::Bitsize;
-using KindTy = fir::KindMapping::KindTy;
-using LLVMTypeID = fir::KindMapping::LLVMTypeID;
-using MatchResult = fir::KindMapping::MatchResult;
-
-static llvm::cl::opt<std::string> clKindMapping(
-    "kind-mapping", llvm::cl::desc("kind mapping string to set kind precision"),
-    llvm::cl::value_desc("kind-mapping-string"), llvm::cl::init(""));
-
-/// Integral types default to the kind value being the size of the value in
-/// bytes. The default is to scale from bytes to bits.
-static Bitsize defaultScalingKind(KindTy kind) {
-  const unsigned BITS_IN_BYTE = 8;
-  return kind * BITS_IN_BYTE;
-}
-
-/// Floating-point types default to the kind value being the size of the value
-/// in bytes. The default is to translate kinds of 2, 4, 8, 10, and 16 to a
-/// valid llvm::Type::TypeID value. Otherwise, the default is FloatTyID.
-static LLVMTypeID defaultRealKind(KindTy kind) {
-  switch (kind) {
-  case 2:
-    return LLVMTypeID::HalfTyID;
-  case 4:
-    return LLVMTypeID::FloatTyID;
-  case 8:
-    return LLVMTypeID::DoubleTyID;
-  case 10:
-    return LLVMTypeID::X86_FP80TyID;
-  case 16:
-    return LLVMTypeID::FP128TyID;
-  default:
-    return LLVMTypeID::FloatTyID;
-  }
-}
-
-// lookup the kind-value given the defaults, the mappings, and a KIND key
-template <typename RT, char KEY>
-static RT doLookup(std::function<RT(KindTy)> def,
-                   const llvm::DenseMap<std::pair<char, KindTy>, RT> &map,
-                   KindTy kind) {
-  std::pair<char, KindTy> key{KEY, kind};
-  auto iter = map.find(key);
-  if (iter != map.end())
-    return iter->second;
-  return def(kind);
-}
-
-// do a lookup for INTERGER, LOGICAL, or CHARACTER
-template <char KEY, typename MAP>
-static Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
-  return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
-}
-
-// do a lookup for REAL or COMPLEX
-template <char KEY, typename MAP>
-static LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
-  return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
-}
-
-template <char KEY, typename MAP>
-static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind,
-                                                         const MAP &map) {
-  switch (doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind)) {
-  case LLVMTypeID::HalfTyID:
-    return llvm::APFloat::IEEEhalf();
-  case LLVMTypeID::FloatTyID:
-    return llvm::APFloat::IEEEsingle();
-  case LLVMTypeID::DoubleTyID:
-    return llvm::APFloat::IEEEdouble();
-  case LLVMTypeID::X86_FP80TyID:
-    return llvm::APFloat::x87DoubleExtended();
-  case LLVMTypeID::FP128TyID:
-    return llvm::APFloat::IEEEquad();
-  case LLVMTypeID::PPC_FP128TyID:
-    return llvm::APFloat::PPCDoubleDouble();
-  default:
-    llvm_unreachable("Invalid floating type");
-  }
-}
-
-static MatchResult parseCode(char &code, const char *&ptr) {
-  if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
-    return mlir::failure();
-  code = *ptr++;
-  return mlir::success();
-}
-
-template <char ch>
-static MatchResult parseSingleChar(const char *&ptr) {
-  if (*ptr != ch)
-    return mlir::failure();
-  ++ptr;
-  return mlir::success();
-}
-
-static MatchResult parseColon(const char *&ptr) {
-  return parseSingleChar<':'>(ptr);
-}
-
-static MatchResult parseComma(const char *&ptr) {
-  return parseSingleChar<','>(ptr);
-}
-
-static MatchResult parseInt(unsigned &result, const char *&ptr) {
-  const char *beg = ptr;
-  while (*ptr >= '0' && *ptr <= '9')
-    ptr++;
-  if (beg == ptr)
-    return mlir::failure();
-  llvm::StringRef ref(beg, ptr - beg);
-  int temp;
-  if (ref.consumeInteger(10, temp))
-    return mlir::failure();
-  result = temp;
-  return mlir::success();
-}
-
-static mlir::LogicalResult matchString(const char *&ptr,
-                                       llvm::StringRef literal) {
-  llvm::StringRef s(ptr);
-  if (s.startswith(literal)) {
-    ptr += literal.size();
-    return mlir::success();
-  }
-  return mlir::failure();
-}
-
-static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
-  if (mlir::succeeded(matchString(ptr, "Half"))) {
-    result = LLVMTypeID::HalfTyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, "Float"))) {
-    result = LLVMTypeID::FloatTyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, "Double"))) {
-    result = LLVMTypeID::DoubleTyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, "X86_FP80"))) {
-    result = LLVMTypeID::X86_FP80TyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, "FP128"))) {
-    result = LLVMTypeID::FP128TyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, "PPC_FP128"))) {
-    result = LLVMTypeID::PPC_FP128TyID;
-    return mlir::success();
-  }
-  return mlir::failure();
-}
-
-fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map)
-    : context{context} {
-  if (mlir::failed(parse(map))) {
-    intMap.clear();
-    floatMap.clear();
-  }
-}
-
-fir::KindMapping::KindMapping(mlir::MLIRContext *context)
-    : KindMapping{context, clKindMapping} {}
-
-MatchResult fir::KindMapping::badMapString(const llvm::Twine &ptr) {
-  auto unknown = mlir::UnknownLoc::get(context);
-  mlir::emitError(unknown, ptr);
-  return mlir::failure();
-}
-
-MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
-  if (kindMap.empty())
-    return mlir::success();
-  const char *srcPtr = kindMap.begin();
-  while (true) {
-    char code = '\0';
-    KindTy kind = 0;
-    if (parseCode(code, srcPtr) || parseInt(kind, srcPtr))
-      return badMapString(srcPtr);
-    if (code == 'a' || code == 'i' || code == 'l') {
-      Bitsize bits = 0;
-      if (parseColon(srcPtr) || parseInt(bits, srcPtr))
-        return badMapString(srcPtr);
-      intMap[std::pair<char, KindTy>{code, kind}] = bits;
-    } else if (code == 'r' || code == 'c') {
-      LLVMTypeID id{};
-      if (parseColon(srcPtr) || parseTypeID(id, srcPtr))
-        return badMapString(srcPtr);
-      floatMap[std::pair<char, KindTy>{code, kind}] = id;
-    } else {
-      return badMapString(srcPtr);
-    }
-    if (parseComma(srcPtr))
-      break;
-  }
-  if (*srcPtr)
-    return badMapString(srcPtr);
-  return mlir::success();
-}
-
-Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) {
-  return getIntegerLikeBitsize<'a'>(kind, intMap);
-}
-
-Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) {
-  return getIntegerLikeBitsize<'i'>(kind, intMap);
-}
-
-Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) {
-  return getIntegerLikeBitsize<'l'>(kind, intMap);
-}
-
-LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) {
-  return getFloatLikeTypeID<'r'>(kind, floatMap);
-}
-
-LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) {
-  return getFloatLikeTypeID<'c'>(kind, floatMap);
-}
-
-const llvm::fltSemantics &fir::KindMapping::getFloatSemantics(KindTy kind) {
-  return getFloatSemanticsOfKind<'r'>(kind, floatMap);
-}

From 7c50041275b6d4cf790988980ccb0159ca52a311 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 26 Feb 2020 15:16:10 -0800
Subject: [PATCH 200/345] directory rename fallout: move files

---
 include/CMakeLists.txt                        |  2 +-
 include/flang/{lower => Lower}/Bridge.h       |  0
 include/flang/{lower => Lower}/ConvertExpr.h  |  0
 include/flang/{lower => Lower}/ConvertType.h  |  0
 include/flang/{lower => Lower}/IO.h           |  0
 include/flang/{lower => Lower}/Intrinsics.h   |  0
 include/flang/{lower => Lower}/Mangler.h      |  0
 include/flang/{lower => Lower}/OpBuilder.h    |  0
 include/flang/{lower => Lower}/Runtime.h      |  0
 include/flang/{lower => Lower}/Utils.h        |  0
 .../Analysis/IteratedDominanceFrontier.h      |  0
 .../CodeGen/CodeGen.h                         |  0
 .../Dialect/CMakeLists.txt                    |  0
 .../Dialect/FIRAttr.h                         |  0
 .../Dialect/FIRDialect.h                      |  0
 .../{optimizer => Optimizer}/Dialect/FIROps.h |  0
 .../Dialect/FIROps.td                         |  0
 .../Dialect/FIROpsSupport.h                   |  0
 .../Dialect/FIRType.h                         |  0
 .../Support/InternalNames.h                   |  0
 .../Support/KindMapping.h                     |  0
 .../Transforms/Passes.h                       |  0
 .../Transforms/StdConverter.h                 |  0
 include/flang/optimizer/CMakeLists.txt        |  1 -
 lib/{optimizer => Optimizer}/CMakeLists.txt   |  0
 lib/{optimizer => Optimizer}/CodeGen.cpp      |  0
 .../Dialect/FIRAttr.cpp                       |  0
 .../Dialect/FIRDialect.cpp                    |  0
 .../Dialect/FIROps.cpp                        |  0
 .../Dialect/FIRType.cpp                       |  0
 .../IteratedDominanceFrontier.cpp             |  0
 lib/{optimizer => Optimizer}/StdConverter.cpp |  0
 .../Support/CMakeLists.txt                    |  0
 .../Support/InternalNames.cpp                 |  0
 .../Support/KindMapping.cpp                   |  0
 .../Transforms/CMakeLists.txt                 |  0
 .../Transforms/CSE.cpp                        |  0
 .../Transforms/MemToReg.cpp                   |  0
 .../Transforms/RewriteLoop.cpp                |  0
 lib/optimizer/Dialect/CMakeLists.txt          | 27 -------------------
 test-lit/{fir => Fir}/complex.fir             |  0
 test-lit/{fir => Fir}/cse.fir                 |  0
 test-lit/{fir => Fir}/embox-write.fir         |  0
 test-lit/{fir => Fir}/fir-ops.fir             |  0
 test-lit/{fir => Fir}/fir-types.fir           |  0
 test-lit/{fir => Fir}/global.fir              |  0
 test-lit/{fir => Fir}/loop.fir                |  0
 test-lit/{fir => Fir}/loop10.fir              |  0
 test-lit/{fir => Fir}/print_complex.c         |  0
 test-lit/{fir => Fir}/real.fir                |  0
 test-lit/{fir => Fir}/recursive-type.fir      |  0
 test-lit/{fir => Fir}/select-type.fir         |  0
 test-lit/{fir => Fir}/select.fir              |  0
 test-lit/{fir => Fir}/widechar.fir            |  0
 54 files changed, 1 insertion(+), 29 deletions(-)
 rename include/flang/{lower => Lower}/Bridge.h (100%)
 rename include/flang/{lower => Lower}/ConvertExpr.h (100%)
 rename include/flang/{lower => Lower}/ConvertType.h (100%)
 rename include/flang/{lower => Lower}/IO.h (100%)
 rename include/flang/{lower => Lower}/Intrinsics.h (100%)
 rename include/flang/{lower => Lower}/Mangler.h (100%)
 rename include/flang/{lower => Lower}/OpBuilder.h (100%)
 rename include/flang/{lower => Lower}/Runtime.h (100%)
 rename include/flang/{lower => Lower}/Utils.h (100%)
 rename include/flang/{optimizer => Optimizer}/Analysis/IteratedDominanceFrontier.h (100%)
 rename include/flang/{optimizer => Optimizer}/CodeGen/CodeGen.h (100%)
 rename include/flang/{optimizer => Optimizer}/Dialect/CMakeLists.txt (100%)
 rename include/flang/{optimizer => Optimizer}/Dialect/FIRAttr.h (100%)
 rename include/flang/{optimizer => Optimizer}/Dialect/FIRDialect.h (100%)
 rename include/flang/{optimizer => Optimizer}/Dialect/FIROps.h (100%)
 rename include/flang/{optimizer => Optimizer}/Dialect/FIROps.td (100%)
 rename include/flang/{optimizer => Optimizer}/Dialect/FIROpsSupport.h (100%)
 rename include/flang/{optimizer => Optimizer}/Dialect/FIRType.h (100%)
 rename include/flang/{optimizer => Optimizer}/Support/InternalNames.h (100%)
 rename include/flang/{optimizer => Optimizer}/Support/KindMapping.h (100%)
 rename include/flang/{optimizer => Optimizer}/Transforms/Passes.h (100%)
 rename include/flang/{optimizer => Optimizer}/Transforms/StdConverter.h (100%)
 delete mode 100644 include/flang/optimizer/CMakeLists.txt
 rename lib/{optimizer => Optimizer}/CMakeLists.txt (100%)
 rename lib/{optimizer => Optimizer}/CodeGen.cpp (100%)
 rename lib/{optimizer => Optimizer}/Dialect/FIRAttr.cpp (100%)
 rename lib/{optimizer => Optimizer}/Dialect/FIRDialect.cpp (100%)
 rename lib/{optimizer => Optimizer}/Dialect/FIROps.cpp (100%)
 rename lib/{optimizer => Optimizer}/Dialect/FIRType.cpp (100%)
 rename lib/{optimizer => Optimizer}/IteratedDominanceFrontier.cpp (100%)
 rename lib/{optimizer => Optimizer}/StdConverter.cpp (100%)
 rename lib/{optimizer => Optimizer}/Support/CMakeLists.txt (100%)
 rename lib/{optimizer => Optimizer}/Support/InternalNames.cpp (100%)
 rename lib/{optimizer => Optimizer}/Support/KindMapping.cpp (100%)
 rename lib/{optimizer => Optimizer}/Transforms/CMakeLists.txt (100%)
 rename lib/{optimizer => Optimizer}/Transforms/CSE.cpp (100%)
 rename lib/{optimizer => Optimizer}/Transforms/MemToReg.cpp (100%)
 rename lib/{optimizer => Optimizer}/Transforms/RewriteLoop.cpp (100%)
 delete mode 100644 lib/optimizer/Dialect/CMakeLists.txt
 rename test-lit/{fir => Fir}/complex.fir (100%)
 rename test-lit/{fir => Fir}/cse.fir (100%)
 rename test-lit/{fir => Fir}/embox-write.fir (100%)
 rename test-lit/{fir => Fir}/fir-ops.fir (100%)
 rename test-lit/{fir => Fir}/fir-types.fir (100%)
 rename test-lit/{fir => Fir}/global.fir (100%)
 rename test-lit/{fir => Fir}/loop.fir (100%)
 rename test-lit/{fir => Fir}/loop10.fir (100%)
 rename test-lit/{fir => Fir}/print_complex.c (100%)
 rename test-lit/{fir => Fir}/real.fir (100%)
 rename test-lit/{fir => Fir}/recursive-type.fir (100%)
 rename test-lit/{fir => Fir}/select-type.fir (100%)
 rename test-lit/{fir => Fir}/select.fir (100%)
 rename test-lit/{fir => Fir}/widechar.fir (100%)

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index c6a154638e65..9589e7b0df79 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1 +1 @@
-add_subdirectory(flang/optimizer)
+add_subdirectory(flang/Optimizer)
diff --git a/include/flang/lower/Bridge.h b/include/flang/Lower/Bridge.h
similarity index 100%
rename from include/flang/lower/Bridge.h
rename to include/flang/Lower/Bridge.h
diff --git a/include/flang/lower/ConvertExpr.h b/include/flang/Lower/ConvertExpr.h
similarity index 100%
rename from include/flang/lower/ConvertExpr.h
rename to include/flang/Lower/ConvertExpr.h
diff --git a/include/flang/lower/ConvertType.h b/include/flang/Lower/ConvertType.h
similarity index 100%
rename from include/flang/lower/ConvertType.h
rename to include/flang/Lower/ConvertType.h
diff --git a/include/flang/lower/IO.h b/include/flang/Lower/IO.h
similarity index 100%
rename from include/flang/lower/IO.h
rename to include/flang/Lower/IO.h
diff --git a/include/flang/lower/Intrinsics.h b/include/flang/Lower/Intrinsics.h
similarity index 100%
rename from include/flang/lower/Intrinsics.h
rename to include/flang/Lower/Intrinsics.h
diff --git a/include/flang/lower/Mangler.h b/include/flang/Lower/Mangler.h
similarity index 100%
rename from include/flang/lower/Mangler.h
rename to include/flang/Lower/Mangler.h
diff --git a/include/flang/lower/OpBuilder.h b/include/flang/Lower/OpBuilder.h
similarity index 100%
rename from include/flang/lower/OpBuilder.h
rename to include/flang/Lower/OpBuilder.h
diff --git a/include/flang/lower/Runtime.h b/include/flang/Lower/Runtime.h
similarity index 100%
rename from include/flang/lower/Runtime.h
rename to include/flang/Lower/Runtime.h
diff --git a/include/flang/lower/Utils.h b/include/flang/Lower/Utils.h
similarity index 100%
rename from include/flang/lower/Utils.h
rename to include/flang/Lower/Utils.h
diff --git a/include/flang/optimizer/Analysis/IteratedDominanceFrontier.h b/include/flang/Optimizer/Analysis/IteratedDominanceFrontier.h
similarity index 100%
rename from include/flang/optimizer/Analysis/IteratedDominanceFrontier.h
rename to include/flang/Optimizer/Analysis/IteratedDominanceFrontier.h
diff --git a/include/flang/optimizer/CodeGen/CodeGen.h b/include/flang/Optimizer/CodeGen/CodeGen.h
similarity index 100%
rename from include/flang/optimizer/CodeGen/CodeGen.h
rename to include/flang/Optimizer/CodeGen/CodeGen.h
diff --git a/include/flang/optimizer/Dialect/CMakeLists.txt b/include/flang/Optimizer/Dialect/CMakeLists.txt
similarity index 100%
rename from include/flang/optimizer/Dialect/CMakeLists.txt
rename to include/flang/Optimizer/Dialect/CMakeLists.txt
diff --git a/include/flang/optimizer/Dialect/FIRAttr.h b/include/flang/Optimizer/Dialect/FIRAttr.h
similarity index 100%
rename from include/flang/optimizer/Dialect/FIRAttr.h
rename to include/flang/Optimizer/Dialect/FIRAttr.h
diff --git a/include/flang/optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
similarity index 100%
rename from include/flang/optimizer/Dialect/FIRDialect.h
rename to include/flang/Optimizer/Dialect/FIRDialect.h
diff --git a/include/flang/optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
similarity index 100%
rename from include/flang/optimizer/Dialect/FIROps.h
rename to include/flang/Optimizer/Dialect/FIROps.h
diff --git a/include/flang/optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
similarity index 100%
rename from include/flang/optimizer/Dialect/FIROps.td
rename to include/flang/Optimizer/Dialect/FIROps.td
diff --git a/include/flang/optimizer/Dialect/FIROpsSupport.h b/include/flang/Optimizer/Dialect/FIROpsSupport.h
similarity index 100%
rename from include/flang/optimizer/Dialect/FIROpsSupport.h
rename to include/flang/Optimizer/Dialect/FIROpsSupport.h
diff --git a/include/flang/optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
similarity index 100%
rename from include/flang/optimizer/Dialect/FIRType.h
rename to include/flang/Optimizer/Dialect/FIRType.h
diff --git a/include/flang/optimizer/Support/InternalNames.h b/include/flang/Optimizer/Support/InternalNames.h
similarity index 100%
rename from include/flang/optimizer/Support/InternalNames.h
rename to include/flang/Optimizer/Support/InternalNames.h
diff --git a/include/flang/optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
similarity index 100%
rename from include/flang/optimizer/Support/KindMapping.h
rename to include/flang/Optimizer/Support/KindMapping.h
diff --git a/include/flang/optimizer/Transforms/Passes.h b/include/flang/Optimizer/Transforms/Passes.h
similarity index 100%
rename from include/flang/optimizer/Transforms/Passes.h
rename to include/flang/Optimizer/Transforms/Passes.h
diff --git a/include/flang/optimizer/Transforms/StdConverter.h b/include/flang/Optimizer/Transforms/StdConverter.h
similarity index 100%
rename from include/flang/optimizer/Transforms/StdConverter.h
rename to include/flang/Optimizer/Transforms/StdConverter.h
diff --git a/include/flang/optimizer/CMakeLists.txt b/include/flang/optimizer/CMakeLists.txt
deleted file mode 100644
index 0ca0f41c5af4..000000000000
--- a/include/flang/optimizer/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-add_subdirectory(Dialect)
diff --git a/lib/optimizer/CMakeLists.txt b/lib/Optimizer/CMakeLists.txt
similarity index 100%
rename from lib/optimizer/CMakeLists.txt
rename to lib/Optimizer/CMakeLists.txt
diff --git a/lib/optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
similarity index 100%
rename from lib/optimizer/CodeGen.cpp
rename to lib/Optimizer/CodeGen.cpp
diff --git a/lib/optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
similarity index 100%
rename from lib/optimizer/Dialect/FIRAttr.cpp
rename to lib/Optimizer/Dialect/FIRAttr.cpp
diff --git a/lib/optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
similarity index 100%
rename from lib/optimizer/Dialect/FIRDialect.cpp
rename to lib/Optimizer/Dialect/FIRDialect.cpp
diff --git a/lib/optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
similarity index 100%
rename from lib/optimizer/Dialect/FIROps.cpp
rename to lib/Optimizer/Dialect/FIROps.cpp
diff --git a/lib/optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
similarity index 100%
rename from lib/optimizer/Dialect/FIRType.cpp
rename to lib/Optimizer/Dialect/FIRType.cpp
diff --git a/lib/optimizer/IteratedDominanceFrontier.cpp b/lib/Optimizer/IteratedDominanceFrontier.cpp
similarity index 100%
rename from lib/optimizer/IteratedDominanceFrontier.cpp
rename to lib/Optimizer/IteratedDominanceFrontier.cpp
diff --git a/lib/optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
similarity index 100%
rename from lib/optimizer/StdConverter.cpp
rename to lib/Optimizer/StdConverter.cpp
diff --git a/lib/optimizer/Support/CMakeLists.txt b/lib/Optimizer/Support/CMakeLists.txt
similarity index 100%
rename from lib/optimizer/Support/CMakeLists.txt
rename to lib/Optimizer/Support/CMakeLists.txt
diff --git a/lib/optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
similarity index 100%
rename from lib/optimizer/Support/InternalNames.cpp
rename to lib/Optimizer/Support/InternalNames.cpp
diff --git a/lib/optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
similarity index 100%
rename from lib/optimizer/Support/KindMapping.cpp
rename to lib/Optimizer/Support/KindMapping.cpp
diff --git a/lib/optimizer/Transforms/CMakeLists.txt b/lib/Optimizer/Transforms/CMakeLists.txt
similarity index 100%
rename from lib/optimizer/Transforms/CMakeLists.txt
rename to lib/Optimizer/Transforms/CMakeLists.txt
diff --git a/lib/optimizer/Transforms/CSE.cpp b/lib/Optimizer/Transforms/CSE.cpp
similarity index 100%
rename from lib/optimizer/Transforms/CSE.cpp
rename to lib/Optimizer/Transforms/CSE.cpp
diff --git a/lib/optimizer/Transforms/MemToReg.cpp b/lib/Optimizer/Transforms/MemToReg.cpp
similarity index 100%
rename from lib/optimizer/Transforms/MemToReg.cpp
rename to lib/Optimizer/Transforms/MemToReg.cpp
diff --git a/lib/optimizer/Transforms/RewriteLoop.cpp b/lib/Optimizer/Transforms/RewriteLoop.cpp
similarity index 100%
rename from lib/optimizer/Transforms/RewriteLoop.cpp
rename to lib/Optimizer/Transforms/RewriteLoop.cpp
diff --git a/lib/optimizer/Dialect/CMakeLists.txt b/lib/optimizer/Dialect/CMakeLists.txt
deleted file mode 100644
index 711fc64c5a2a..000000000000
--- a/lib/optimizer/Dialect/CMakeLists.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-add_llvm_library(FIRDialect
-  FIRAttr.cpp
-  FIRDialect.cpp
-  FIROps.cpp
-  FIRType.cpp
-)
-
-add_dependencies(FIRDialect FIROpsIncGen)
-
-target_link_libraries(FIRDialect
-  MLIRTargetLLVMIR
-  MLIRTargetLLVMIRModuleTranslation
-  MLIREDSC
-  MLIRExecutionEngine
-  MLIRParser
-  MLIRSupport
-  MLIRStandardToLLVM
-  MLIRTransforms
-  LLVMAsmParser
-  LLVMAsmPrinter
-  LLVMRemarks
-)
-
-install (TARGETS FIRDialect
-  ARCHIVE DESTINATION lib
-  LIBRARY DESTINATION lib
-)
diff --git a/test-lit/fir/complex.fir b/test-lit/Fir/complex.fir
similarity index 100%
rename from test-lit/fir/complex.fir
rename to test-lit/Fir/complex.fir
diff --git a/test-lit/fir/cse.fir b/test-lit/Fir/cse.fir
similarity index 100%
rename from test-lit/fir/cse.fir
rename to test-lit/Fir/cse.fir
diff --git a/test-lit/fir/embox-write.fir b/test-lit/Fir/embox-write.fir
similarity index 100%
rename from test-lit/fir/embox-write.fir
rename to test-lit/Fir/embox-write.fir
diff --git a/test-lit/fir/fir-ops.fir b/test-lit/Fir/fir-ops.fir
similarity index 100%
rename from test-lit/fir/fir-ops.fir
rename to test-lit/Fir/fir-ops.fir
diff --git a/test-lit/fir/fir-types.fir b/test-lit/Fir/fir-types.fir
similarity index 100%
rename from test-lit/fir/fir-types.fir
rename to test-lit/Fir/fir-types.fir
diff --git a/test-lit/fir/global.fir b/test-lit/Fir/global.fir
similarity index 100%
rename from test-lit/fir/global.fir
rename to test-lit/Fir/global.fir
diff --git a/test-lit/fir/loop.fir b/test-lit/Fir/loop.fir
similarity index 100%
rename from test-lit/fir/loop.fir
rename to test-lit/Fir/loop.fir
diff --git a/test-lit/fir/loop10.fir b/test-lit/Fir/loop10.fir
similarity index 100%
rename from test-lit/fir/loop10.fir
rename to test-lit/Fir/loop10.fir
diff --git a/test-lit/fir/print_complex.c b/test-lit/Fir/print_complex.c
similarity index 100%
rename from test-lit/fir/print_complex.c
rename to test-lit/Fir/print_complex.c
diff --git a/test-lit/fir/real.fir b/test-lit/Fir/real.fir
similarity index 100%
rename from test-lit/fir/real.fir
rename to test-lit/Fir/real.fir
diff --git a/test-lit/fir/recursive-type.fir b/test-lit/Fir/recursive-type.fir
similarity index 100%
rename from test-lit/fir/recursive-type.fir
rename to test-lit/Fir/recursive-type.fir
diff --git a/test-lit/fir/select-type.fir b/test-lit/Fir/select-type.fir
similarity index 100%
rename from test-lit/fir/select-type.fir
rename to test-lit/Fir/select-type.fir
diff --git a/test-lit/fir/select.fir b/test-lit/Fir/select.fir
similarity index 100%
rename from test-lit/fir/select.fir
rename to test-lit/Fir/select.fir
diff --git a/test-lit/fir/widechar.fir b/test-lit/Fir/widechar.fir
similarity index 100%
rename from test-lit/fir/widechar.fir
rename to test-lit/Fir/widechar.fir

From 25b2fee5d30422f64afa8950109da22469e0f1d5 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 26 Feb 2020 15:42:15 -0800
Subject: [PATCH 201/345] fallout from 112 being changed to 113

---
 lib/Decimal/binary-to-decimal.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Decimal/binary-to-decimal.cpp b/lib/Decimal/binary-to-decimal.cpp
index d1abb237ce53..78a1ee12a05a 100644
--- a/lib/Decimal/binary-to-decimal.cpp
+++ b/lib/Decimal/binary-to-decimal.cpp
@@ -335,7 +335,7 @@ template void BigRadixFloatingPointNumber<11,16>::LoseLeastSignificantDigit();
 template void BigRadixFloatingPointNumber<24,16>::LoseLeastSignificantDigit();
 template void BigRadixFloatingPointNumber<53,16>::LoseLeastSignificantDigit();
 template void BigRadixFloatingPointNumber<64,16>::LoseLeastSignificantDigit();
-template void BigRadixFloatingPointNumber<112,16>::LoseLeastSignificantDigit();
+template void BigRadixFloatingPointNumber<113,16>::LoseLeastSignificantDigit();
 
 template<int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *buffer, std::size_t size,

From 184dfe14604f824f8870fa5b63d5efbc7f368086 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 26 Feb 2020 15:51:32 -0800
Subject: [PATCH 202/345] fall out from directory renaming - change all the
 include directives everywhere edit the tag lines

---
 include/flang/Lower/Bridge.h                  |  4 +-
 include/flang/Lower/ConvertExpr.h             |  2 +-
 include/flang/Lower/ConvertType.h             |  4 +-
 include/flang/Lower/IO.h                      |  2 +-
 include/flang/Lower/Intrinsics.h              |  2 +-
 include/flang/Lower/Mangler.h                 |  2 +-
 include/flang/Lower/OpBuilder.h               |  4 +-
 include/flang/Lower/PFTBuilder.h              |  2 +-
 include/flang/Lower/Runtime.h                 |  2 +-
 include/flang/Lower/Utils.h                   |  4 +-
 include/flang/Optimizer/CodeGen/CodeGen.h     |  2 +-
 include/flang/Optimizer/Dialect/FIRAttr.h     |  2 +-
 include/flang/Optimizer/Dialect/FIRDialect.h  |  2 +-
 include/flang/Optimizer/Dialect/FIROps.h      |  4 +-
 .../flang/Optimizer/Dialect/FIROpsSupport.h   |  4 +-
 include/flang/Optimizer/Dialect/FIRType.h     |  2 +-
 .../flang/Optimizer/Support/InternalNames.h   |  2 +-
 include/flang/Optimizer/Support/KindMapping.h |  2 +-
 include/flang/Optimizer/Transforms/Passes.h   |  2 +-
 .../flang/Optimizer/Transforms/StdConverter.h |  2 +-
 lib/Lower/Bridge.cpp                          | 30 ++++++-------
 lib/Lower/CFGBuilder.h                        |  2 +-
 lib/Lower/ConvertExpr.cpp                     | 30 ++++++-------
 lib/Lower/ConvertType.cpp                     | 14 +++----
 lib/Lower/IO.cpp                              | 14 +++----
 lib/Lower/Intrinsics.cpp                      | 12 +++---
 lib/Lower/Mangler.cpp                         | 10 ++---
 lib/Lower/OpBuilder.cpp                       | 10 ++---
 lib/Lower/RTBuilder.h                         |  4 +-
 lib/Lower/Runtime.cpp                         |  6 +--
 lib/Optimizer/CodeGen.cpp                     | 14 +++----
 lib/Optimizer/Dialect/FIRAttr.cpp             |  8 ++--
 lib/Optimizer/Dialect/FIRDialect.cpp          | 10 ++---
 lib/Optimizer/Dialect/FIROps.cpp              | 10 ++---
 lib/Optimizer/Dialect/FIRType.cpp             |  4 +-
 lib/Optimizer/IteratedDominanceFrontier.cpp   |  2 +-
 lib/Optimizer/StdConverter.cpp                | 12 +++---
 lib/Optimizer/Support/InternalNames.cpp       |  2 +-
 lib/Optimizer/Support/KindMapping.cpp         |  2 +-
 lib/Optimizer/Transforms/CSE.cpp              |  4 +-
 lib/Optimizer/Transforms/MemToReg.cpp         |  8 ++--
 lib/Optimizer/Transforms/RewriteLoop.cpp      |  6 +--
 tools/bbc/bbc.cpp                             | 42 +++++++++----------
 tools/tco/tco.cpp                             | 12 +++---
 44 files changed, 160 insertions(+), 160 deletions(-)

diff --git a/include/flang/Lower/Bridge.h b/include/flang/Lower/Bridge.h
index 59f0c6643b15..d6514eceb83e 100644
--- a/include/flang/Lower/Bridge.h
+++ b/include/flang/Lower/Bridge.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/bridge.h --------------------------------------*- C++ -*-===//
+//===-- Lower/Bridge.h -- main interface to lowering ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -17,7 +17,7 @@
 #ifndef FORTRAN_LOWER_BRIDGE_H_
 #define FORTRAN_LOWER_BRIDGE_H_
 
-#include "flang/common/Fortran.h"
+#include "flang/Common/Fortran.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include <memory>
diff --git a/include/flang/Lower/ConvertExpr.h b/include/flang/Lower/ConvertExpr.h
index 70154aafa03c..7132ff76cebd 100644
--- a/include/flang/Lower/ConvertExpr.h
+++ b/include/flang/Lower/ConvertExpr.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/convert-expr.h --------------------------------*- C++ -*-===//
+//===-- Lower/ConvertExpr.h -- lowering of expressions ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Lower/ConvertType.h b/include/flang/Lower/ConvertType.h
index f944c4885ffa..deb0ebfacafe 100644
--- a/include/flang/Lower/ConvertType.h
+++ b/include/flang/Lower/ConvertType.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/convert-type.h --------------------------------*- C++ -*-===//
+//===-- Lower/ConvertType.h -- lowering of types ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -17,7 +17,7 @@
 ///
 /// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
-#include "flang/common/Fortran.h"
+#include "flang/Common/Fortran.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
diff --git a/include/flang/Lower/IO.h b/include/flang/Lower/IO.h
index 06e1be1c93bc..d782e6a6f454 100644
--- a/include/flang/Lower/IO.h
+++ b/include/flang/Lower/IO.h
@@ -1,4 +1,4 @@
-//===-- flang/lower/IO.h -- lower I/O statements ----------------*- C++ -*-===//
+//===-- Lower/IO.h -- lower I/O statements ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Lower/Intrinsics.h b/include/flang/Lower/Intrinsics.h
index e52f36bbf603..8741c2102969 100644
--- a/include/flang/Lower/Intrinsics.h
+++ b/include/flang/Lower/Intrinsics.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/intrinsics.h ----------------------------------*- C++ -*-===//
+//===-- Lower/Intrinsics.h -- lowering of intrinsics ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Lower/Mangler.h b/include/flang/Lower/Mangler.h
index ea933f30a05e..2ee47d3adf99 100644
--- a/include/flang/Lower/Mangler.h
+++ b/include/flang/Lower/Mangler.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/mangler.h -------------------------------------*- C++ -*-===//
+//===-- Lower/Mangler.h -- name mangling ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Lower/OpBuilder.h b/include/flang/Lower/OpBuilder.h
index 06f46b344f15..94bbfbcdb457 100644
--- a/include/flang/Lower/OpBuilder.h
+++ b/include/flang/Lower/OpBuilder.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/builder.h -------------------------------------*- C++ -*-===//
+//===-- Lower/OpBuilder.h -- operation builder ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_BUILDER_H_
 #define FORTRAN_LOWER_BUILDER_H_
 
-#include "flang/semantics/symbol.h"
+#include "flang/Semantics/symbol.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 1c740afe40a0..1c5f5ff703f6 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -1,4 +1,4 @@
-//===-- flang/lower/PFTBuilder.h --------------------------------*- C++ -*-===//
+//===-- Lower/PFTBuilder.h -- PFT builder -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Lower/Runtime.h b/include/flang/Lower/Runtime.h
index b13c360c17a3..156ca920eef5 100644
--- a/include/flang/Lower/Runtime.h
+++ b/include/flang/Lower/Runtime.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/runtime.h -------------------------------------*- C++ -*-===//
+//===-- Lower/Runtime.h -- Fortran runtime codegen interface ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Lower/Utils.h b/include/flang/Lower/Utils.h
index 179f74d2d30c..74c2037754d9 100644
--- a/include/flang/Lower/Utils.h
+++ b/include/flang/Lower/Utils.h
@@ -1,4 +1,4 @@
-//===-- lib/lower/utils.h ---------------------------------------*- C++ -*-===//
+//===-- Lower/Utils.h -- utilities ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,7 +9,7 @@
 #ifndef FORTRAN_LOWER_UTILS_H
 #define FORTRAN_LOWER_UTILS_H
 
-#include "flang/parser/char-block.h"
+#include "flang/Parser/char-block.h"
 #include "llvm/ADT/StringRef.h"
 
 /// Convert an F18 CharBlock to an LLVM StringRef
diff --git a/include/flang/Optimizer/CodeGen/CodeGen.h b/include/flang/Optimizer/CodeGen/CodeGen.h
index d156cd1e8a44..9f6936e34e17 100644
--- a/include/flang/Optimizer/CodeGen/CodeGen.h
+++ b/include/flang/Optimizer/CodeGen/CodeGen.h
@@ -1,4 +1,4 @@
-//===-- optimizer/CodeGen/CodeGen.h -- code generation ----------*- C++ -*-===//
+//===-- Optimizer/CodeGen/CodeGen.h -- code generation ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Optimizer/Dialect/FIRAttr.h b/include/flang/Optimizer/Dialect/FIRAttr.h
index 3ce9a54a629d..a65675aa7d40 100644
--- a/include/flang/Optimizer/Dialect/FIRAttr.h
+++ b/include/flang/Optimizer/Dialect/FIRAttr.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Dialect/FIRAttr.h -- FIR attributes -----------*- C++ -*-===//
+//===-- Optimizer/Dialect/FIRAttr.h -- FIR attributes -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
index 0c80bbe80e70..a6761b0c0ed9 100644
--- a/include/flang/Optimizer/Dialect/FIRDialect.h
+++ b/include/flang/Optimizer/Dialect/FIRDialect.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Dialect/FIRDialect.h -- FIR dialect -----------*- C++ -*-===//
+//===-- Optimizer/Dialect/FIRDialect.h -- FIR dialect -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
index 1ae5a3532cf1..cd5c8b6ef66a 100644
--- a/include/flang/Optimizer/Dialect/FIROps.h
+++ b/include/flang/Optimizer/Dialect/FIROps.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Dialect/FIROps.h - FIR operations -------------*- C++ -*-===//
+//===-- Optimizer/Dialect/FIROps.h - FIR operations -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -63,7 +63,7 @@ ParseResult parseCmpfOp(OpAsmParser &parser, OperationState &result);
 ParseResult parseCmpcOp(OpAsmParser &parser, OperationState &result);
 
 #define GET_OP_CLASSES
-#include "flang/optimizer/Dialect/FIROps.h.inc"
+#include "flang/Optimizer/Dialect/FIROps.h.inc"
 
 LoopOp getForInductionVarOwner(Value val);
 
diff --git a/include/flang/Optimizer/Dialect/FIROpsSupport.h b/include/flang/Optimizer/Dialect/FIROpsSupport.h
index 04c5ed17932a..b8bb5480d157 100644
--- a/include/flang/Optimizer/Dialect/FIROpsSupport.h
+++ b/include/flang/Optimizer/Dialect/FIROpsSupport.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Dialect/FIROpsSupport.h -- FIR op support -----*- C++ -*-===//
+//===-- Optimizer/Dialect/FIROpsSupport.h -- FIR op support -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,7 +9,7 @@
 #ifndef OPTIMIZER_DIALECT_FIROPSSUPPORT_H
 #define OPTIMIZER_DIALECT_FIROPSSUPPORT_H
 
-#include "flang/optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 namespace fir {
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 49764a7c3e66..6b85635897b3 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Dialect/FIRType.h -- FIR types ----------------*- C++ -*-===//
+//===-- Optimizer/Dialect/FIRType.h -- FIR types ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Optimizer/Support/InternalNames.h b/include/flang/Optimizer/Support/InternalNames.h
index 2d661bc7bf96..3dba562e9abf 100644
--- a/include/flang/Optimizer/Support/InternalNames.h
+++ b/include/flang/Optimizer/Support/InternalNames.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Support/InternalNames.h -----------------------*- C++ -*-===//
+//===-- Optimizer/Support/InternalNames.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.
diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
index a549a7ed3df2..bd2b8e2e190b 100644
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Support/KindMapping.h -------------------------*- C++ -*-===//
+//===-- Optimizer/Support/KindMapping.h -- support kind mapping -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/include/flang/Optimizer/Transforms/Passes.h b/include/flang/Optimizer/Transforms/Passes.h
index 186b76435626..4ead67874b3f 100644
--- a/include/flang/Optimizer/Transforms/Passes.h
+++ b/include/flang/Optimizer/Transforms/Passes.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Transforms/Passes.h ---------------------------*- C++ -*-===//
+//===-- Optimizer/Transforms/Passes.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.
diff --git a/include/flang/Optimizer/Transforms/StdConverter.h b/include/flang/Optimizer/Transforms/StdConverter.h
index c0796c3275b7..335c28f99252 100644
--- a/include/flang/Optimizer/Transforms/StdConverter.h
+++ b/include/flang/Optimizer/Transforms/StdConverter.h
@@ -1,4 +1,4 @@
-//===-- optimizer/Transforms/StdConverter.h ---------------------*- C++ -*-===//
+//===-- Optimizer/Transforms/StdConverter.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.
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 447a436e2852..f4ba4fa22079 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -6,21 +6,21 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/Bridge.h"
-#include "flang/lower/ConvertExpr.h"
-#include "flang/lower/ConvertType.h"
-#include "flang/lower/IO.h"
-#include "flang/lower/Intrinsics.h"
-#include "flang/lower/Mangler.h"
-#include "flang/lower/OpBuilder.h"
-#include "flang/lower/PFTBuilder.h"
-#include "flang/lower/Runtime.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Dialect/FIRType.h"
-#include "flang/optimizer/Support/InternalNames.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/tools.h"
+#include "flang/Lower/Bridge.h"
+#include "flang/Lower/ConvertExpr.h"
+#include "flang/Lower/ConvertType.h"
+#include "flang/Lower/IO.h"
+#include "flang/Lower/Intrinsics.h"
+#include "flang/Lower/Mangler.h"
+#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/PFTBuilder.h"
+#include "flang/Lower/Runtime.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/tools.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
diff --git a/lib/Lower/CFGBuilder.h b/lib/Lower/CFGBuilder.h
index cfc8acece4ba..917278bb1ba7 100644
--- a/lib/Lower/CFGBuilder.h
+++ b/lib/Lower/CFGBuilder.h
@@ -1,4 +1,4 @@
-//===-- lower/cfg-builder.h -------------------------------------*- C++ -*-===//
+//===-- CFGBuilder.h -- CFG building parts of bridge ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 8c89d6e25290..d42d5fae8ddf 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -6,21 +6,21 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/ConvertExpr.h"
-#include "flang/common/default-kinds.h"
-#include "flang/common/unwrap.h"
-#include "flang/evaluate/fold.h"
-#include "flang/evaluate/real.h"
-#include "flang/lower/Bridge.h"
-#include "flang/lower/ConvertType.h"
-#include "flang/lower/OpBuilder.h"
-#include "flang/lower/Runtime.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Dialect/FIRType.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/symbol.h"
-#include "flang/semantics/type.h"
+#include "flang/Lower/ConvertExpr.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Common/unwrap.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/real.h"
+#include "flang/Lower/Bridge.h"
+#include "flang/Lower/ConvertType.h"
+#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/Runtime.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/type.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
diff --git a/lib/Lower/ConvertType.cpp b/lib/Lower/ConvertType.cpp
index 2c5c2c687c9d..93cee1b7e480 100644
--- a/lib/Lower/ConvertType.cpp
+++ b/lib/Lower/ConvertType.cpp
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/ConvertType.h"
+#include "flang/Lower/ConvertType.h"
 #include "../../runtime/io-api.h"
-#include "flang/lower/Bridge.h"
-#include "flang/lower/Utils.h"
-#include "flang/optimizer/Dialect/FIRType.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/tools.h"
-#include "flang/semantics/type.h"
+#include "flang/Lower/Bridge.h"
+#include "flang/Lower/Utils.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 88bb5308817c..eee8ffd670ce 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -6,15 +6,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/IO.h"
+#include "flang/Lower/IO.h"
 #include "../../runtime/io-api.h"
 #include "RTBuilder.h"
-#include "flang/lower/Bridge.h"
-#include "flang/lower/OpBuilder.h"
-#include "flang/lower/Runtime.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/semantics/tools.h"
+#include "flang/Lower/Bridge.h"
+#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/Runtime.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/tools.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 
diff --git a/lib/Lower/Intrinsics.cpp b/lib/Lower/Intrinsics.cpp
index 359b7bd0985c..a4bc2a89d466 100644
--- a/lib/Lower/Intrinsics.cpp
+++ b/lib/Lower/Intrinsics.cpp
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/Intrinsics.h"
-#include "flang/lower/ConvertType.h"
-#include "flang/lower/OpBuilder.h"
-#include "flang/lower/Runtime.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/Lower/Intrinsics.h"
+#include "flang/Lower/ConvertType.h"
+#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/Runtime.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include <algorithm>
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index 2a06023705f3..af324849d504 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/Mangler.h"
-#include "flang/common/reference.h"
-#include "flang/lower/Utils.h"
-#include "flang/optimizer/Support/InternalNames.h"
-#include "flang/semantics/tools.h"
+#include "flang/Lower/Mangler.h"
+#include "flang/Common/reference.h"
+#include "flang/Lower/Utils.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Semantics/tools.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/Lower/OpBuilder.cpp b/lib/Lower/OpBuilder.cpp
index bbc4e92acd3b..3f49671e28d1 100644
--- a/lib/Lower/OpBuilder.cpp
+++ b/lib/Lower/OpBuilder.cpp
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/OpBuilder.h"
-#include "flang/lower/Bridge.h"
-#include "flang/lower/ConvertType.h"
-#include "flang/optimizer/Dialect/FIROpsSupport.h"
-#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/Bridge.h"
+#include "flang/Lower/ConvertType.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/StringRef.h"
diff --git a/lib/Lower/RTBuilder.h b/lib/Lower/RTBuilder.h
index 34d83f5001d9..278cb4434075 100644
--- a/lib/Lower/RTBuilder.h
+++ b/lib/Lower/RTBuilder.h
@@ -17,8 +17,8 @@
 #ifndef FORTRAN_LOWER_RT_BUILDER_H_
 #define FORTRAN_LOWER_RT_BUILDER_H_
 
-#include "flang/lower/ConvertType.h"
-#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/Lower/ConvertType.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/Lower/Runtime.cpp b/lib/Lower/Runtime.cpp
index c8884effef72..0759299e5011 100644
--- a/lib/Lower/Runtime.cpp
+++ b/lib/Lower/Runtime.cpp
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/lower/Runtime.h"
-#include "flang/lower/OpBuilder.h"
-#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/Lower/Runtime.h"
+#include "flang/Lower/OpBuilder.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index a1cefdc68d02..cb7936096bb5 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/CodeGen/CodeGen.h"
-#include "flang/optimizer/Dialect/FIRAttr.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Dialect/FIRType.h"
-#include "flang/optimizer/Support/InternalNames.h"
-#include "flang/optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index 45b98ff9e884..c7695de1d5aa 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Dialect/FIRAttr.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIRType.h"
-#include "flang/optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
index 90c2b6423c93..e6b04072bd0b 100644
--- a/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIRAttr.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Transforms/SideEffectsInterface.h"
@@ -47,7 +47,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
                 PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<
 #define GET_OP_LIST
-#include "flang/optimizer/Dialect/FIROps.cpp.inc"
+#include "flang/Optimizer/Dialect/FIROps.cpp.inc"
                 >();
 }
 
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 9a6ad1e17cc7..aa3bbcfd5942 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Dialect/FIRAttr.h"
-#include "flang/optimizer/Dialect/FIROpsSupport.h"
-#include "flang/optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
@@ -568,6 +568,6 @@ GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
 // Tablegen operators
 
 #define GET_OP_CLASSES
-#include "flang/optimizer/Dialect/FIROps.cpp.inc"
+#include "flang/Optimizer/Dialect/FIROps.cpp.inc"
 
 } // namespace fir
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index 358e8ccf9765..7fd4547448ff 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Dialect/FIRType.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
diff --git a/lib/Optimizer/IteratedDominanceFrontier.cpp b/lib/Optimizer/IteratedDominanceFrontier.cpp
index 65e7e653e132..9fee2b7314b2 100644
--- a/lib/Optimizer/IteratedDominanceFrontier.cpp
+++ b/lib/Optimizer/IteratedDominanceFrontier.cpp
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Analysis/IteratedDominanceFrontier.h"
+#include "flang/Optimizer/Analysis/IteratedDominanceFrontier.h"
 #include "mlir/Analysis/Dominance.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
diff --git a/lib/Optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
index b202d3a045b4..7770aebf10a7 100644
--- a/lib/Optimizer/StdConverter.cpp
+++ b/lib/Optimizer/StdConverter.cpp
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Transforms/StdConverter.h"
-#include "flang/optimizer/Dialect/FIRAttr.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIROpsSupport.h"
-#include "flang/optimizer/Dialect/FIRType.h"
-#include "flang/optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Transforms/StdConverter.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/StandardTypes.h"
diff --git a/lib/Optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
index 7c292a390861..e63d5b39a844 100644
--- a/lib/Optimizer/Support/InternalNames.cpp
+++ b/lib/Optimizer/Support/InternalNames.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Support/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
index a4001861b57e..957486ab0c1b 100644
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
diff --git a/lib/Optimizer/Transforms/CSE.cpp b/lib/Optimizer/Transforms/CSE.cpp
index 9a692e08b5d3..a247b3674582 100644
--- a/lib/Optimizer/Transforms/CSE.cpp
+++ b/lib/Optimizer/Transforms/CSE.cpp
@@ -12,8 +12,8 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Dialect/FIROpsSupport.h"
-#include "flang/optimizer/Transforms/Passes.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
diff --git a/lib/Optimizer/Transforms/MemToReg.cpp b/lib/Optimizer/Transforms/MemToReg.cpp
index ecf9d04c790c..99935b70a2b6 100644
--- a/lib/Optimizer/Transforms/MemToReg.cpp
+++ b/lib/Optimizer/Transforms/MemToReg.cpp
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Analysis/IteratedDominanceFrontier.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Transforms/Passes.h"
+#include "flang/Optimizer/Analysis/IteratedDominanceFrontier.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
diff --git a/lib/Optimizer/Transforms/RewriteLoop.cpp b/lib/Optimizer/Transforms/RewriteLoop.cpp
index 002cb514a2cd..51fc6e0080a8 100644
--- a/lib/Optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/Optimizer/Transforms/RewriteLoop.cpp
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Dialect/FIROps.h"
-#include "flang/optimizer/Transforms/Passes.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index d75bde321012..dd0e47f42b96 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -11,27 +11,27 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#include "flang/common/Fortran-features.h"
-#include "flang/common/default-kinds.h"
-#include "flang/lower/Bridge.h"
-#include "flang/lower/ConvertExpr.h"
-#include "flang/optimizer/CodeGen/CodeGen.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Support/InternalNames.h"
-#include "flang/optimizer/Support/KindMapping.h"
-#include "flang/optimizer/Transforms/Passes.h"
-#include "flang/optimizer/Transforms/StdConverter.h"
-#include "flang/parser/characters.h"
-#include "flang/parser/dump-parse-tree.h"
-#include "flang/parser/message.h"
-#include "flang/parser/parse-tree-visitor.h"
-#include "flang/parser/parse-tree.h"
-#include "flang/parser/parsing.h"
-#include "flang/parser/provenance.h"
-#include "flang/parser/unparse.h"
-#include "flang/semantics/expression.h"
-#include "flang/semantics/semantics.h"
-#include "flang/semantics/unparse-with-symbols.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Lower/Bridge.h"
+#include "flang/Lower/ConvertExpr.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "flang/Optimizer/Transforms/StdConverter.h"
+#include "flang/Parser/characters.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "flang/Parser/message.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/parsing.h"
+#include "flang/Parser/provenance.h"
+#include "flang/Parser/unparse.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/unparse-with-symbols.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index f695d187de9e..168551ef0cf3 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -11,12 +11,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/optimizer/CodeGen/CodeGen.h"
-#include "flang/optimizer/Dialect/FIRDialect.h"
-#include "flang/optimizer/Support/InternalNames.h"
-#include "flang/optimizer/Support/KindMapping.h"
-#include "flang/optimizer/Transforms/Passes.h"
-#include "flang/optimizer/Transforms/StdConverter.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "flang/Optimizer/Transforms/StdConverter.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"

From c6b1ab49f3f4ecd8134be6610b62c57bc0d13953 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 27 Feb 2020 10:28:12 -0800
Subject: [PATCH 203/345] turn off clang++ warnings

---
 lib/Lower/Bridge.cpp           | 4 ++--
 lib/Lower/RTBuilder.h          | 3 ++-
 lib/Optimizer/CMakeLists.txt   | 6 +++++-
 lib/Optimizer/StdConverter.cpp | 1 +
 lib/Semantics/CMakeLists.txt   | 1 +
 5 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index f4ba4fa22079..3f2b361ebee0 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -50,7 +50,7 @@ using CFGSinkListType = llvm::SmallVector<Fortran::lower::pft::Evaluation *, 2>;
 using CFGMapType =
     llvm::DenseMap<Fortran::lower::pft::Evaluation *, CFGSinkListType *>;
 
-constexpr static bool isStopStmt(const Fortran::parser::StopStmt &stm) {
+static constexpr bool isStopStmt(const Fortran::parser::StopStmt &stm) {
   return std::get<Fortran::parser::StopStmt::Kind>(stm.t) ==
          Fortran::parser::StopStmt::Kind::Stop;
 }
@@ -919,7 +919,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     auto callee = genRuntimeFunction(
         Fortran::lower::RuntimeEntryCode::StopStatement, *builder);
     // TODO: 3 args: stop-code-opt, ierror, quiet-opt
-    // auto isError{genFIRLo!isStopStmt(stmt)}
+    [[maybe_unused]] bool isStop{isStopStmt(stm)};
     builder->create<mlir::CallOp>(toLocation(), callee, llvm::None);
   }
 
diff --git a/lib/Lower/RTBuilder.h b/lib/Lower/RTBuilder.h
index 278cb4434075..8750631c6c79 100644
--- a/lib/Lower/RTBuilder.h
+++ b/lib/Lower/RTBuilder.h
@@ -174,8 +174,9 @@ struct RuntimeTableKey<RT(ATs...)> {
 
 #if defined(__clang__)
 #pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wgcc-extension"
+#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
 #endif
+// clang++ generates warnings about usage of a GNU extension, ignore them
 template <char... Cs>
 using RuntimeIdentifier = std::integer_sequence<char, Cs...>;
 template <typename T, T... Cs>
diff --git a/lib/Optimizer/CMakeLists.txt b/lib/Optimizer/CMakeLists.txt
index b186f6586baa..8f1387218709 100644
--- a/lib/Optimizer/CMakeLists.txt
+++ b/lib/Optimizer/CMakeLists.txt
@@ -1,4 +1,8 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wno-unused-parameter")
+if ((CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-private-field")
+endif()
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 
 add_subdirectory(Dialect)
 add_subdirectory(Support)
diff --git a/lib/Optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
index 7770aebf10a7..58687bd683aa 100644
--- a/lib/Optimizer/StdConverter.cpp
+++ b/lib/Optimizer/StdConverter.cpp
@@ -78,6 +78,7 @@ class FIRToStdTypeConverter : public mlir::TypeConverter {
                                   kindMap.getContext());
   }
 
+  // clang++ erroneously complains this variable is unused (see CMakeLists.txt)
   KindMapping &kindMap;
 };
 
diff --git a/lib/Semantics/CMakeLists.txt b/lib/Semantics/CMakeLists.txt
index feedbab17860..211cfff97696 100644
--- a/lib/Semantics/CMakeLists.txt
+++ b/lib/Semantics/CMakeLists.txt
@@ -1,3 +1,4 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
 
 add_library(FortranSemantics
   assignment.cpp

From 3b81297c9dfa7f7aa6ffb75339e9b7c8cb337eb1 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 27 Feb 2020 12:50:16 -0800
Subject: [PATCH 204/345] [PR1035] changes per River's comments

---
 include/flang/Optimizer/Dialect/FIROps.td | 217 ++++++++++++++--------
 include/flang/Optimizer/Dialect/FIRType.h |  37 ++--
 lib/Optimizer/Dialect/FIRAttr.cpp         |  11 +-
 lib/Optimizer/Dialect/FIROps.cpp          |  19 +-
 lib/Optimizer/Dialect/FIRType.cpp         |  36 ++--
 test-lit/Fir/fir-ops.fir                  |   2 +-
 6 files changed, 190 insertions(+), 132 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 7ce9efd40786..b97394937195 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -140,38 +140,35 @@ class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
 // Base builder for allocate operations
 def fir_AllocateOpBuilder : OpBuilder<
   "Builder *builder, OperationState &result, Type inType,"
-  "ArrayRef<Value> lenParams = {}, ArrayRef<Value> sizes = {},"
+  "ValueRange lenParams = {}, ValueRange sizes = {},"
   "ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", mlir::TypeAttr::get(inType));
+    result.addAttribute("in_type", TypeAttr::get(inType));
     result.addOperands(sizes);
-    for (auto namedAttr : attributes)
-      result.addAttribute(namedAttr.first, namedAttr.second);
+    result.addAttributes(attributes);
   }]>;
 
 def fir_NamedAllocateOpBuilder : OpBuilder<
   "Builder *builder, OperationState &result, Type inType, StringRef name,"
-  "ArrayRef<Value> lenParams = {}, ArrayRef<Value> sizes = {},"
+  "ValueRange lenParams = {}, ValueRange sizes = {},"
   "ArrayRef<NamedAttribute> attributes = {}",
   [{
     result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", mlir::TypeAttr::get(inType));
+    result.addAttribute("in_type", TypeAttr::get(inType));
     result.addAttribute("name", builder->getStringAttr(name));
     result.addOperands(sizes);
-    for (auto namedAttr : attributes)
-      result.addAttribute(namedAttr.first, namedAttr.second);
+    result.addAttributes(attributes);
   }]>;
 
 def fir_OneResultOpBuilder : OpBuilder<
   "Builder *, OperationState &result, Type resultType,"
-  "ArrayRef<Value> operands, ArrayRef<NamedAttribute> attributes = {}",
+  "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
   [{
     if (resultType)
       result.addTypes(resultType);
     result.addOperands(operands);
-    for (auto namedAttr : attributes)
-      result.addAttribute(namedAttr.first, namedAttr.second);
+    result.addAttributes(attributes);
   }]>;
 
 // Base class of FIR operations that return 1 result
@@ -314,6 +311,7 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
     an optional name.  The allocation may have a dynamic repetition count
     for allocating a sequence of locations for the specified type.
 
+    ```mlir
       %c = ... : i64
       %x = fir.alloca i32
       %y = fir.alloca !fir.array<8 x i64>
@@ -322,6 +320,7 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
       %i = ... : i16
       %j = ... : i32
       %w = fir.alloca !fir.type<PT(len1:i16, len2:i32)> (%i, %j : i16, i32)
+    ```
 
     Note that in the case of `%z`, a contiguous block of memory is allocated
     and its size is a runtime multiple of a 32-bit REAL value.
@@ -353,8 +352,10 @@ def fir_LoadOp : fir_OneResultOp<"load", []> {
     Produces an immutable ssa-value of the referent type. A memory reference
     has type `!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
 
+    ```mlir
       %a = fir.alloca i32
       %l = fir.load %a : !fir.ref<i32>
+    ```
 
     The ssa-value has an undefined value if the memory reference is undefined
     or null.
@@ -410,9 +411,11 @@ def fir_StoreOp : fir_Op<"store", []> {
     value must be of the same type as the referent type of the memory
     reference.
 
+    ```mlir
       %v = ... : f64
       %p = ... : !fir.ptr<f64>
       fir.store %v to %p : !fir.ptr<f64>
+    ```
 
     The above store changes the value to which the pointer is pointing and not
     the pointer itself. The operation is undefined if the memory reference,
@@ -464,31 +467,23 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
     This operation is typically created internally by the mem2reg conversion
     pass. An undefined value can be of any type except `!fir.ref<T>`.
 
+    ```mlir
       %a = fir.undefined !fir.array<10 x !fir.type<T>>
+    ```
 
     The example creates an array shaped ssa value. The array is rank 1, extent
     10, and each element has type `!fir.type<T>`.
   }];
 
+  let results = (outs AnyType:$intype);
+
+  let assemblyFormat = "type($intype) attr-dict";
+
   let verifier = [{
     if (auto ref = getType().dyn_cast<fir::ReferenceType>())
       return emitOpError("undefined values of type !fir.ref not allowed");
     return mlir::success();
   }];
-
-  let parser = [{
-    mlir::Type intype;
-    if (parser.parseType(intype) ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.addTypeToList(intype, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getType();
-    p.printOptionalAttrDict(getAttrs(), {});
-  }];
 }
 
 def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
@@ -500,8 +495,10 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
     The memory object is in an undefined state.  `allocmem` operations must
     be paired with `freemem` operations to avoid memory leaks.
 
+    ```mlir
       %0 = fir.allocmem !fir.array<10 x f32>
       fir.freemem %0 : !fir.heap<!fir.array<10 x f32>>
+    ```
   }];
 
   let results = (outs fir_HeapType);
@@ -528,9 +525,11 @@ def fir_FreeMemOp : fir_Op<"freemem", []> {
     in the undefined state as undefined behavior.  This includes aliasing
     references, such as the result of an `fir.embox`.
 
+    ```mlir
       %21 = fir.allocmem !fir.type<ZT(p:i32){field:i32}>
       ...
       fir.freemem %21 : !fir.heap<!fir.type<ZT>>
+    ```
   }];
 
   let arguments = (ins fir_HeapType:$heapref);
@@ -548,8 +547,8 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
 
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value selector,"
-    "ArrayRef<Value> properOperands, ArrayRef<Block *> destinations,"
-    "ArrayRef<ArrayRef<Value>> operands = {},"
+    "ValueRange properOperands, ArrayRef<Block *> destinations,"
+    "ArrayRef<ValueRange> operands = {},"
     "ArrayRef<NamedAttribute> attributes = {}",
     [{
       result.addOperands(selector);
@@ -557,9 +556,7 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
       for (auto kvp : llvm::zip(destinations, operands)) {
         result.addSuccessor(std::get<0>(kvp), std::get<1>(kvp));
       }
-      for (auto namedAttr : attributes) {
-        result.addAttribute(namedAttr.first, namedAttr.second);
-      }
+      result.addAttributes(attributes);
     }]
   >];
 
@@ -667,11 +664,13 @@ def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
     at least one basic block with a corresponding `unit` match, and
     that block will be selected when all other conditions fail to match.
 
+    ```mlir
       fir.select %arg:i32 [1, ^bb1(%0 : i32),
                            2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
                           -3, ^bb3(%arg2,%2 : i32,i32),
                            4, ^bb4(%1 : i32),
                         unit, ^bb5]
+    ```
   }];
 }
 
@@ -685,11 +684,13 @@ def fir_SelectRankOp : fir_IntegralSwitchTerminatorOp<"select_rank"> {
     same as `select`, but `select_rank` determines the rank of the selector
     variable at runtime to determine the best match.
 
+    ```mlir
       fir.select_rank %arg:i32 [1, ^bb1(%0 : i32),
                                 2, ^bb2(%2,%arg,%arg2 : i32,i32,i32),
                                 3, ^bb3(%arg2,%2 : i32,i32),
                                -1, ^bb4(%1 : i32),
                              unit, ^bb5]
+    ```
   }];
 }
 
@@ -703,12 +704,14 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     the same as `select`, but `select_case` allows for the expression of
     more complex match conditions.
 
+    ```mlir
       fir.select_case %arg : i32 [
             #fir.point, %0, ^bb1(%0 : i32),
             #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1 : i32,i32,i32,i32),
             #fir.interval, %2, %3, ^bb3(%2,%arg2 : i32,i32),
             #fir.upper, %arg, ^bb4(%1 : i32),
             unit, ^bb5]
+    ```
   }];
 
   let parser = [{
@@ -837,12 +840,14 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     same as `select`, but `select_type` determines the type of the selector
     variable at runtime to determine the best match.
 
+    ```mlir
       fir.select_type %arg : !fir.box<()> [
           #fir.instance<!fir.type<type1>>, ^bb1(%0 : i32),
           #fir.instance<!fir.type<type2>>, ^bb2(%2 : i32),
           #fir.subsumed<!fir.type<type3>>, ^bb3(%2 : i32),
           #fir.instance<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
           unit, ^bb5]
+    ```
   }];
 
   let parser = [{
@@ -924,7 +929,9 @@ def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
     program, for example.  This instruction corresponds to the LLVM IR
     instruction `unreachable`.
 
+    ```mlir
       fir.unreachable
+    ```
   }];
 
   let parser = "return mlir::success();";
@@ -948,6 +955,7 @@ def fir_HasValueOp : fir_Op<"has_value", [Terminator, HasParent<"GlobalOp">]> {
   let description = [{
     The terminator for a GlobalOp with a body.
 
+    ```mlir
       global @variable : tuple<i32, f32> {
         %0 = constant 45 : i32
         %1 = constant 100.0 : f32
@@ -958,6 +966,7 @@ def fir_HasValueOp : fir_Op<"has_value", [Terminator, HasParent<"GlobalOp">]> {
         %6 = fir.insert_value %4, %1, %5 : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
         fir.has_value %6 : tuple<i32, f32>
       }
+    ```
   }];
 
   let arguments = (ins AnyType:$resval);
@@ -976,11 +985,13 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
     auxilliary information is packaged and abstracted as a value with box type
     by the calling routine. (In Fortran, these are called descriptors.)
 
+    ```mlir
       %c1 = constant 1 : index
       %c10 = constant 10 : index
       %4 = fir.dims(%c1, %c10, %c1) : (index, index, index) -> !fir.dims<1>
       %5 = ... : !fir.ref<!fir.array<10 x i32>>
       %6 = fir.embox %5, %4 : (!fir.ref<!fir.array<10 x i32>>, !fir.dims<1>) -> !fir.box<!fir.array<10 x i32>>
+    ```
 
     The descriptor tuple may contain additional implementation-specific
     information through the use of additional attributes.
@@ -1105,11 +1116,14 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
     a variable of type CHARACTER has both its data reference as well as a
     LEN type parameter.
 
+    ```fortran
       CHARACTER(LEN=10) :: var
-
+    ```
+    ```mlir
       %4 = ...         : !fir.ref<!fir.array<10 x !fir.char<1>>>
       %5 = constant 10 : i32
       %6 = fir.emboxchar %4, %5 : (!fir.ref<!fir.array<10 x !fir.char<1>>>, i32) -> !fir.boxchar<1>
+    ```
 
     In the above `%4` is a memory reference to a buffer of 10 CHARACTER units.
     This buffer and its LEN value (10) are wrapped into a pair in `%6`.
@@ -1137,7 +1151,9 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
     internal procedure or the internal procedure does not need a host context
     then the form takes only the procedure's symbol.
 
+    ```mlir
       %0 = fir.emboxproc @f : ((i32) -> i32) -> !fir.boxproc<(i32) -> i32>
+    ```
 
     An internal procedure requiring a host instance for correct execution uses
     the second form. The closure of the host procedure's state is passed as a
@@ -1145,9 +1161,10 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
     context's values accordingly, up to and including inhibiting register
     promotion of local values.
 
+    ```mlir
       %4 = ... : !fir.ref<tuple<i32, i32>>
-      %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) ->
-                                  !fir.boxproc<(i32) -> i32>
+      %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) -> !fir.boxproc<(i32) -> i32>
+    ```
   }];
 
   let arguments = (ins SymbolRefAttr:$funcname, AnyReferenceLike:$host);
@@ -1224,8 +1241,10 @@ def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
     of flags (packed in an integer, and an array of dimension information (of
     size rank).
 
+    ```mlir
       %40   = ... : !fir.box<!fir.type<T>>
       %41:6 = fir.unbox %40 : (!fir.box<!fir.type<T>>) -> (!fir.ref<!fir.type<T>>, i32, i32, !fir.tdesc<!fir.type<T>>, i32, !fir.dims<4>)
+    ```
   }];
 
   let arguments = (ins fir_BoxType:$box);
@@ -1247,8 +1266,10 @@ def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]> {
     Unboxes a value of `boxchar` type into a pair consisting of a memory
     reference to the CHARACTER data and the LEN type parameter.
 
+    ```mlir
       %45   = ... : !fir.boxchar<1>
       %46:2 = fir.unboxchar %45 : (!fir.boxchar<1>) -> (!fir.ref<!fir.character<1>>, i32)
+    ```
   }];
 
   let arguments = (ins fir_BoxCharType:$boxchar);
@@ -1263,8 +1284,10 @@ def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
     Unboxes a value of `boxproc` type into a pair consisting of a procedure
     pointer and a pointer to a host context.
 
+    ```mlir
       %47   = ... : !fir.boxproc<() -> i32>
       %48:2 = fir.unboxproc %47 : (!fir.ref<() -> i32>, !fir.ref<tuple<f32, i32>>)
+    ```
   }];
 
   let verifier = [{
@@ -1286,11 +1309,13 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
     This operator is overloaded to work with values of type `box`,
     `boxchar`, and `boxproc`.  The result for each of these
     cases, respectively, is the address of the data, the address of the
-    CHARACTER data, and the address of the procedure.
+    `CHARACTER` data, and the address of the procedure.
 
+    ```mlir
       %51 = fir.box_addr %box : (!fir.box<f64>) -> !fir.ref<f64>
       %52 = fir.box_addr %boxchar : (!fir.boxchar<1>) -> !fir.ref<!fir.char<1>>
       %53 = fir.box_addr %boxproc : (!fir.boxproc<!P>) -> !fir.ref<!P>
+    ```
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1304,8 +1329,10 @@ def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
   let description = [{
     Extracts the LEN type parameter from a `boxchar` value.
 
+    ```mlir
       %45 = ... : !boxchar<1>  // CHARACTER(20)
       %59 = fir.boxchar_len %45 : (!fir.boxchar<1>) -> i64  // len=20
+    ```
   }];
 
   let arguments = (ins fir_BoxCharType:$val);
@@ -1322,8 +1349,10 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
     left to right from 0 to rank-1. This operation has undefined behavior if
     `dim` is out of bounds.
 
+    ```mlir
       %c1   = constant 0 : i32
       %52:3 = fir.box_dims %40, %c1 : (!fir.box<!fir.array<*:f64>>, i32) -> (i32, i32, i32)
+    ```
 
     The above is a request to return the left most row (at index 0) triple from
     the box. The triple will be the lower bound, upper bound, and stride.
@@ -1349,8 +1378,10 @@ def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
     Returns the size of an element in an entity of `box` type.  This size may
     not be known until runtime.
 
+    ```mlir
       %53 = fir.box_elesize %40 : (!fir.box<f32>, i32) -> i32  // size=4
       %54 = fir.box_elesize %40 : (!fir.box<!fir.array<*:f32>>, i32) -> i32
+    ```
 
     In the above example, `%53` may box an array of REAL values while `%54`
     must box an array of REAL values (with dynamic rank and extent).
@@ -1369,12 +1400,14 @@ def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]> {
     return true if the originating box value was from a `fir.embox` op
     with a mem-ref value that had the type !fir.heap<T>.
 
+    ```mlir
       %r = ... : !fir.heap<i64>
       %b = fir.embox %r : (!fir.heap<i64>) -> !fir.box<i64>
       %a = fir.box_isalloc %b : (!fir.box<i64>) -> i1  // true
+    ```
 
     The canonical descriptor implementation will carry a flag to record if the
-    variable is an ALLOCATABLE.
+    variable is an `ALLOCATABLE`.
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1390,10 +1423,12 @@ def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]> {
     true if the originating box value was from a fir.embox with a memory
     reference value that had the type !fir.array<T> and/or a dims argument.
 
+    ```mlir
       %r = ... : !fir.ref<i64>
       %d = fir.gendims(1, 100, 1) : (i32, i32, i32) -> !fir.dims<1>
       %b = fir.embox %r, %d : (!fir.ref<i64>, !fir.dims<1>) -> !fir.box<i64>
       %a = fir.box_isarray %b : (!fir.box<i64>) -> i1  // true
+    ```
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1407,9 +1442,11 @@ def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]> {
   let description = [{
     Determine if the boxed value was from a POINTER entity.
 
+    ```mlir
       %p = ... : !fir.ptr<i64>
       %b = fir.embox %p : (!fir.ptr<i64>) -> !fir.box<i64>
       %a = fir.box_isptr %b : (!fir.box<i64>) -> i1  // true
+    ```
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1423,8 +1460,10 @@ def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]> {
   let description = [{
     Extract the host context pointer from a boxproc value.
 
+    ```mlir
       %8 = ... : !fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>
       %9 = fir.boxproc_host %8 : (!fir.boxproc<(!fir.ref<!fir.type<T>>) -> i32>) -> !fir.ref<tuple<i32, i32>>
+    ```
 
     In the example, the reference to the closure over the host procedure's
     variables is returned. This allows an internal procedure to access the
@@ -1444,8 +1483,10 @@ def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
     Return the rank of a value of `box` type.  If the value is scalar, the
     rank is 0.
 
+    ```mlir
       %57 = fir.box_rank %40 : (!fir.box<!fir.array<*:f64>>) -> i32
       %58 = fir.box_rank %41 : (!fir.box<f64>) -> i32
+    ```
 
     The example `%57` shows how one would determine the rank of an array that
     has deferred rank at runtime. This rank should be at least 1. In %58, the
@@ -1465,7 +1506,9 @@ def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
     descriptor is an implementation defined value that fully describes a type
     to the Fortran runtime.
 
+    ```mlir
       %7 = fir.box_tdesc %41 : (!fir.box<f64>) -> !fir.tdesc<f64>
+    ```
   }];
 
   let arguments = (ins fir_BoxType:$val);
@@ -1489,9 +1532,11 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
     Unlike LLVM's GEP instruction, one cannot stride over the outermost
     reference; therefore, the leading 0 index must be omitted.
 
+    ```mlir
       %i = ... : index
       %h = ... : !fir.heap<!fir.array<?:f32>>
       %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
+    ```
 
     In the example, `%p` will be a pointer to the `%i`-th f32 value in the
     array `%h`.
@@ -1508,13 +1553,12 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
   let verifier = [{
     // Recovering a LEN type parameter only makes sense from a boxed value
     for (auto co : coor())
-      if (auto *s = co.getDefiningOp())
-        if (dyn_cast_or_null<LenParamIndexOp>(s)) {
-          if (getNumOperands() != 2)
-            return emitOpError("len_param_index must be last argument");
-          if (!ref().getType().dyn_cast<BoxType>())
-            return emitOpError("len_param_index must be used on box type");
-        }
+      if (dyn_cast_or_null<LenParamIndexOp>(co.getDefiningOp())) {
+        if (getNumOperands() != 2)
+          return emitOpError("len_param_index must be last argument");
+        if (!ref().getType().dyn_cast<BoxType>())
+          return emitOpError("len_param_index must be used on box type");
+      }
     return mlir::success();
   }];
 }
@@ -1530,9 +1574,11 @@ def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
     Note that the entity ssa-value must be of compile-time known size in order
     to use this operation.
 
+    ```mlir
       %f = fir.field_index field, !fir.type<X{field:i32}>
       %s = ... : !fir.type<X>
       %v = fir.extract_value %s, %f : (!fir.type<X>, !fir.field) -> i32
+    ```
   }];
 
   let arguments = (ins
@@ -1556,7 +1602,9 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
     or `fir.insert_value` instructions to compute (abstract) addresses of
     subobjects.
 
+    ```mlir
       %f = fir.field_index field, !fir.type<X{field:i32}>
+    ```
   }];
 
   let arguments = (ins
@@ -1615,7 +1663,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, StringRef fieldName,"
-    "Type recTy, ArrayRef<Value> operands = {}",
+    "Type recTy, ValueRange operands = {}",
     [{
       result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
       result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
@@ -1642,7 +1690,9 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
     information must be specified.  The extent must be nonnegative and the
     stride must not be zero.
 
+    ```mlir
       %d = fir.gendims %l, %u, %s : (index, index, index) -> !fir.dims<1>
+    ```
   }];
 
   let arguments = (ins Variadic<AnyIntegerType>:$triples);
@@ -1655,7 +1705,7 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
 
   let verifier = [{
     auto size = triples().size();
-    if (size < 1 && size <= 16 * 3)
+    if (size < 1 || size > 16 * 3)
       return emitOpError("incorrect number of args");
     if (size % 3 != 0)
       return emitOpError("requires a multiple of 3 args");
@@ -1674,11 +1724,13 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
     Note that the entity ssa-value must be of compile-time known size in order
     to use this operation.
 
+    ```mlir
       %a = ... : !fir.array<10xtuple<i32, f32>>
       %f = ... : f32
       %o = ... : i32
       %c = constant 1 : i32
       %b = fir.insert_value %a, %f, %o, %c : (!fir.array<10x20xtuple<i32, f32>>, f32, i32, i32) -> !fir.array<10x20xtuple<i32, f32>>
+    ```
   }];
 
   let arguments = (ins AnyCompositeLike:$adt, AnyType:$val,
@@ -1700,9 +1752,11 @@ def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
     used with the `fir.coordinate_of` instructions to compute (abstract)
     addresses of LEN parameters.
 
+    ```mlir
       %e = fir.len_param_index len1, !fir.type<X(len1:i32)>
       %p = ... : !fir.box<!fir.type<X>>
       %q = fir.coordinate_of %p, %e : (!fir.box<!fir.type<X>>, !fir.len) -> !fir.ref<i32>
+    ```
   }];
 
   let arguments = (ins StrAttr:$field_id, TypeAttr:$on_type);
@@ -1758,6 +1812,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     Generalized high-level looping construct. This operation is similar to
     MLIR's `loop.for`. An ordered loop will return the final value of `%i`.
 
+    ```mlir
       %l = constant 0 : index
       %u = constant 9 : index
       fir.loop %i = %l to %u unordered {
@@ -1766,6 +1821,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
         %p = fir.coordinate_of %A, %i : (!fir.ref<f32>, index) -> !fir.ref<f32>
         fir.store %v to %p : !fir.ref<f32>
       }
+    ```
 
     The above example iterates over the interval `[%l, %u]`. The unordered
     keyword indicates that the iterations can be executed in any order.
@@ -1789,7 +1845,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
               "int64_t lowerBound, int64_t upperBound, int64_t step = 1">,
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
               "mlir::Value lowerBound, mlir::Value upperBound,"
-              "ArrayRef<mlir::Value> step = {}">
+              "ValueRange step = {}">
   ];
 
   let parser = "return parseLoopOp(parser, result);";
@@ -1872,6 +1928,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
     To conditionally execute operations (typically) within the body of a
     `fir.loop` operation. This operation is similar to `loop.if`.
 
+    ```mlir
       %56 = ... : i1
       %78 = ... : !fir.ref<!T>
       fir.where %56 {
@@ -1879,6 +1936,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
       } otherwise {
         fir.store %77 to %78 : !fir.ref<!T>
       }
+    ```
   }];
 
   let arguments = (ins I1:$condition);
@@ -1944,8 +2002,10 @@ def fir_CallOp : fir_Op<"call", []> {
     Provides a custom parser and pretty printer to allow a more readable syntax
     in the FIR dialect, e.g. `fir.call @sub(%12)` or `fir.call %20(%22,%23)`.
 
+    ```mlir
       %a = fir.call %funcref(%arg0) : (!fir.ref<f32>) -> f32
-      %b = fir.call @function(%arg1, %arg2) : (!fir.ref<f32>, !fir.ref<f32>) -> f32    
+      %b = fir.call @function(%arg1, %arg2) : (!fir.ref<f32>, !fir.ref<f32>) -> f32
+    ```
   }];
 
   let arguments = (ins
@@ -1967,7 +2027,9 @@ def fir_DispatchOp : fir_Op<"dispatch", []> {
     associated with the first argument.  The attribute 'pass_arg_pos' can be
     used to select a dispatch argument other than the first one.
 
+    ```mlir
       %r = fir.dispatch methodA(%o) : (!fir.box<none>) -> i32
+    ```
   }];
 
   let arguments = (ins
@@ -1983,7 +2045,7 @@ def fir_DispatchOp : fir_Op<"dispatch", []> {
     llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
     auto calleeLoc = parser.getNameLoc();
     llvm::StringRef calleeName;
-    if (parser.parseOptionalKeyword(&calleeName)) {
+    if (failed(parser.parseOptionalKeyword(&calleeName))) {
       mlir::StringAttr calleeAttr;
       if (parser.parseAttribute(calleeAttr, "method", result.attributes))
         return mlir::failure();
@@ -2031,8 +2093,7 @@ def fir_DispatchOp : fir_Op<"dispatch", []> {
 
 // Constant operations that support Fortran
 
-def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
-    Results<(outs fir_SequenceType)> {
+def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]> {
   let summary = "create a string literal constant";
 
   let description = [{
@@ -2040,12 +2101,14 @@ def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]>,
     to Fortran's CHARACTER type, including a LEN.  We support CHARACTER values
     of different KINDs (different constant sizes).
 
-    Example:
-
+    ```mlir
       %1 = fir.string_lit "Hello, World!"(13) : !fir.char<1> // ASCII
       %2 = fir.string_lit [158, 2345](2) : !fir.char<2>      // Wide chars
+    ```
   }];
 
+  let results = (outs fir_SequenceType);
+
   let parser = [{
     auto &builder = parser.getBuilder();
     mlir::Attribute val;
@@ -2136,8 +2199,7 @@ class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
   let printer = [{ return fir::printUnaryOp(this->getOperation(), p); }];
 }
 
-def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]>,
-    Results<(outs fir_RealType)> {
+def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]> {
   let summary = "create a floating point constant";
 
   let description = [{
@@ -2145,6 +2207,8 @@ def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]>,
     to represent APFloat values that are not supported in the standard dialect.
   }];
 
+  let results = (outs fir_RealType);
+
   let parser = [{
     fir::RealAttr flt;
     mlir::Type type;
@@ -2338,29 +2402,16 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
     Convert a symbol (a function or global reference) to an SSA-value to be
     used in other Operations.
 
+    ```mlir
       %p = fir.address_of(@symbol) : !fir.ref<f64>
+    ```
   }];
 
   let arguments = (ins SymbolRefAttr:$symbol);
 
-  let parser = [{
-    mlir::SymbolRefAttr attr;
-    mlir::Type type;
-    if (parser.parseLParen() ||
-        parser.parseAttribute(attr, "symbol", result.attributes) ||
-        parser.parseRParen() ||
-        parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(type) ||
-        parser.addTypeToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
+  let results = (outs fir_ReferenceType:$resTy);
 
-  let printer = [{
-    p << getOperationName() << " (" << getAttr("symbol") << ')';
-    p.printOptionalAttrDict(getAttrs(), {"symbol"});
-    p << " : " << getType();
-  }];
+  let assemblyFormat = "`(` $symbol `)` attr-dict `:` type($resTy)";
 }
 
 def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
@@ -2370,8 +2421,10 @@ def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
     Not all pairs of types have conversions. When types T and U are the same
     type, this instruction is a NOP and may be folded away.
 
+    ```mlir
       %v = ... : i64
       %w = fir.convert %v : (i64) -> i32
+    ```
 
     The example truncates the value `%v` from an i64 to an i32.
   }];
@@ -2403,8 +2456,10 @@ def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
     specified type.  The meta-type of a type descriptor for the type `T`
     is `!fir.tdesc<T>`.
 
+    ```mlir
       !T = type !fir.type<T{...}>
       %t = fir.gentypedesc !T  // returns value of !fir.tdesc<!T>
+    ```
   }];
 
   let arguments = (ins FortranTypeAttr:$in_type);
@@ -2460,9 +2515,11 @@ def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
     example below, this would prevent possibly replacing the multiply and add
     operations with a single FMA operation.
 
+    ```mlir
       %98 = mulf %96, %97 : f32
       %99 = fir.no_reassoc %98 : f32
       %a0 = addf %99, %95 : f32
+    ```
   }];
 
   let arguments = (ins AnyType:$val);
@@ -2483,6 +2540,7 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
     `@_QV_Mquark_Vvarble` with some initial values. The initializer should
     conform to the variable's type.
 
+    ```mlir
       fir.global @_QV_Mquark_Vvarble : tuple<i32, f32> {
         %1 = constant 1 : i32
         %2 = constant 2.0 : f32
@@ -2493,6 +2551,7 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
         %5 = fir.insert_value %4, %1, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
         return %5
       }
+    ```
   }];
 
   let arguments = (ins
@@ -2526,7 +2585,7 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
       simpleInitializer = true;
     }
 
-    if (!parser.parseOptionalKeyword(constantAttrName())) {
+    if (succeeded(parser.parseOptionalKeyword(constantAttrName()))) {
       // if "constant" keyword then mark this as a constant, not a variable
       result.addAttribute(constantAttrName(), builder.getUnitAttr());
     }
@@ -2576,8 +2635,7 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
       result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
       result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                           builder->getStringAttr(name));
-      for (const auto &pair : attrs)
-        result.addAttribute(pair.first, pair.second);
+      result.addAttributes(attrs);
     }]>
   ];
 
@@ -2609,18 +2667,20 @@ def fir_GlobalLenOp : fir_Op<"global_len", []> {
     parameter (compile-time) constants associated with the instance's type.
     These values can be bound to the global instance used `fir.global_len`.
 
+    ```mlir
       global @g : !fir.type<t(len1:i32)> {
         fir.global_len len1, 10 : i32
         %1 = fir.undefined : !fir.type<t(len1:i32)>
         return %1 : !fir.type<t(len1:i32)>
       }
+    ```
   }];
 
   let arguments = (ins StrAttr:$lenparam, APIntAttr:$intval);
 
   let parser = [{
     llvm::StringRef fieldName;
-    if (parser.parseOptionalKeyword(&fieldName)) {
+    if (failed(parser.parseOptionalKeyword(&fieldName))) {
       mlir::StringAttr fieldAttr;
       if (parser.parseAttribute(fieldAttr, lenParamAttrName(),
                                 result.attributes))
@@ -2659,10 +2719,12 @@ def fir_DispatchTableOp : fir_Op<"dispatch_table", [IsolatedFromAbove, Symbol,
 
     The ordering of associations in the map is determined by the front-end.
 
+    ```mlir
       fir.dispatch_table @_QDTMquuzTfoo {
         fir.dt_entry method1, @_QFNMquuzTfooPmethod1AfooR
         fir.dt_entry method2, @_QFNMquuzTfooPmethod2AfooII
       }
+    ```
   }];
 
   let parser = [{
@@ -2712,8 +2774,7 @@ def fir_DispatchTableOp : fir_Op<"dispatch_table", [IsolatedFromAbove, Symbol,
     [{
       result->addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                            builder->getStringAttr(name));
-      for (const auto &pair : attrs)
-        result->addAttribute(pair.first, pair.second);
+      result->addAttributes(attrs);
     }]>
   ];
 
@@ -2741,7 +2802,9 @@ def fir_DTEntryOp : fir_Op<"dt_entry", []> {
     and uses the method identifier to select the type-bound procedure to
     be called.
 
+    ```mlir
       fir.dt_entry method_name, @uniquedProcedure
+    ```
   }];
 
   let arguments = (ins StrAttr:$method, SymbolRefAttr:$proc);
@@ -2749,7 +2812,7 @@ def fir_DTEntryOp : fir_Op<"dt_entry", []> {
   let parser = [{
     llvm::StringRef methodName;
     // allow `methodName` or `"methodName"`
-    if (parser.parseOptionalKeyword(&methodName)) {
+    if (failed(parser.parseOptionalKeyword(&methodName))) {
       mlir::StringAttr methodAttr;
       if (parser.parseAttribute(methodAttr, methodAttrName(),
                                 result.attributes))
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 6b85635897b3..949f75c4afba 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -160,7 +160,7 @@ class BoxType
   mlir::AffineMapAttr getLayoutMap() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *, mlir::Type eleTy,
+  verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
                                mlir::AffineMapAttr map);
 };
 
@@ -181,9 +181,8 @@ class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXPROC; }
   mlir::Type getEleTy() const;
 
-  static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *,
-                               mlir::Type eleTy);
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
 };
 
 class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
@@ -214,9 +213,8 @@ class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
 
   mlir::Type getEleTy() const;
 
-  static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *,
-                               mlir::Type eleTy);
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
 };
 
 class LenType
@@ -236,9 +234,8 @@ class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
 
   mlir::Type getEleTy() const;
 
-  static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *,
-                               mlir::Type eleTy);
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
 };
 
 class ReferenceType
@@ -251,9 +248,8 @@ class ReferenceType
 
   mlir::Type getEleTy() const;
 
-  static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *,
-                               mlir::Type eleTy);
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type eleTy);
 };
 
 /// A sequence type is a multi-dimensional array of values. The sequence type
@@ -290,9 +286,8 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *attributeStorage,
-                               const Shape &shape, mlir::Type eleTy,
-                               mlir::AffineMapAttr map);
+  verifyConstructionInvariants(mlir::Location loc, const Shape &shape,
+                               mlir::Type eleTy, mlir::AffineMapAttr map);
 };
 
 bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
@@ -309,9 +304,8 @@ class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
   }
   mlir::Type getOfTy() const;
 
-  static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *,
-                               mlir::Type ofType);
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          mlir::Type ofType);
 };
 
 // Derived types
@@ -343,9 +337,8 @@ class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
 
   detail::RecordTypeStorage const *uniqueKey() const;
 
-  static mlir::LogicalResult
-  verifyConstructionInvariants(const mlir::AttributeStorage *,
-                               llvm::StringRef name);
+  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
+                                                          llvm::StringRef name);
 };
 
 mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index c7695de1d5aa..b2fe96e2e1d2 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -176,14 +176,18 @@ mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
 
   if (attrName == ExactTypeAttr::getAttrName()) {
     mlir::Type type;
-    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater())
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
       parser.emitError(loc, "expected a type");
+      return {};
+    }
     return ExactTypeAttr::get(type);
   }
   if (attrName == SubclassAttr::getAttrName()) {
     mlir::Type type;
-    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater())
+    if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
       parser.emitError(loc, "expected a subtype");
+      return {};
+    }
     return SubclassAttr::get(type);
   }
   if (attrName == PointIntervalAttr::getAttrName())
@@ -197,8 +201,7 @@ mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
   if (attrName == RealAttr::getAttrName())
     return parseFirRealAttr(dialect, parser, type);
 
-  llvm::Twine msg{"unknown FIR attribute: "};
-  parser.emitError(loc, msg.concat(attrName));
+  parser.emitError(loc, "unknown FIR attribute: ") << attrName;
   return {};
 }
 
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index aa3bbcfd5942..d898a5e3e7db 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -351,14 +351,13 @@ mlir::ParseResult LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
 
 // LoopOp
 
-void LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
+void LoopOp::build(mlir::Builder *builder, OperationState &result,
                    int64_t lowerBound, int64_t upperBound, int64_t step) {
   assert(false && "not implemented");
 }
 
-void LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
-                   mlir::Value lb, mlir::Value ub,
-                   llvm::ArrayRef<mlir::Value> step) {
+void LoopOp::build(mlir::Builder *builder, OperationState &result,
+                   mlir::Value lb, mlir::Value ub, ValueRange step) {
   if (step.empty())
     result.addOperands({lb, ub});
   else
@@ -368,10 +367,9 @@ void LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
   bodyRegion->front().addArgument(builder->getIndexType());
 }
 
-mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result) {
+mlir::ParseResult parseLoopOp(OpAsmParser &parser, OperationState &result) {
   auto &builder = parser.getBuilder();
-  mlir::OpAsmParser::OperandType inductionVariable, lb, ub, step;
+  OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
   if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
     return mlir::failure();
@@ -444,7 +442,7 @@ bool StringLitOp::isWideValue() {
 
 // WhereOp
 
-void WhereOp::build(mlir::Builder *builder, mlir::OperationState &result,
+void WhereOp::build(mlir::Builder *builder, OperationState &result,
                     mlir::Value cond, bool withElseRegion) {
   result.addOperands(cond);
   mlir::Region *thenRegion = result.addRegion();
@@ -454,15 +452,14 @@ void WhereOp::build(mlir::Builder *builder, mlir::OperationState &result,
     WhereOp::ensureTerminator(*elseRegion, *builder, result.location);
 }
 
-mlir::ParseResult parseWhereOp(mlir::OpAsmParser &parser,
-                               mlir::OperationState &result) {
+mlir::ParseResult parseWhereOp(OpAsmParser &parser, OperationState &result) {
   // Create the regions for 'then'.
   result.regions.reserve(2);
   mlir::Region *thenRegion = result.addRegion();
   mlir::Region *elseRegion = result.addRegion();
 
   auto &builder = parser.getBuilder();
-  mlir::OpAsmParser::OperandType cond;
+  OpAsmParser::OperandType cond;
   mlir::Type i1Type = builder.getIntegerType(1);
   if (parser.parseOperand(cond) ||
       parser.resolveOperand(cond, i1Type, result.operands))
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index 7fd4547448ff..f8fd7fcb9161 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -931,8 +931,9 @@ mlir::AffineMapAttr fir::BoxType::getLayoutMap() const {
   return getImpl()->getLayoutMap();
 }
 
-mlir::LogicalResult fir::BoxType::verifyConstructionInvariants(
-    const mlir::AttributeStorage *, mlir::Type eleTy, mlir::AffineMapAttr map) {
+mlir::LogicalResult
+fir::BoxType::verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
+                                           mlir::AffineMapAttr map) {
   // TODO
   return mlir::success();
 }
@@ -958,7 +959,7 @@ mlir::Type fir::BoxProcType::getEleTy() const {
 }
 
 mlir::LogicalResult
-fir::BoxProcType::verifyConstructionInvariants(const mlir::AttributeStorage *,
+fir::BoxProcType::verifyConstructionInvariants(mlir::Location,
                                                mlir::Type eleTy) {
   if (eleTy.isa<mlir::FunctionType>() || eleTy.isa<ReferenceType>())
     return mlir::success();
@@ -975,8 +976,9 @@ mlir::Type fir::ReferenceType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-mlir::LogicalResult fir::ReferenceType::verifyConstructionInvariants(
-    const mlir::AttributeStorage *context, mlir::Type eleTy) {
+mlir::LogicalResult
+fir::ReferenceType::verifyConstructionInvariants(mlir::Location,
+                                                 mlir::Type eleTy) {
   if (eleTy.isa<DimsType>() || eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
       eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
     return mlir::failure();
@@ -997,8 +999,9 @@ mlir::Type fir::PointerType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-mlir::LogicalResult fir::PointerType::verifyConstructionInvariants(
-    const mlir::AttributeStorage *context, mlir::Type eleTy) {
+mlir::LogicalResult
+fir::PointerType::verifyConstructionInvariants(mlir::Location,
+                                               mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
@@ -1023,8 +1026,7 @@ mlir::Type fir::HeapType::getEleTy() const {
 }
 
 mlir::LogicalResult
-fir::HeapType::verifyConstructionInvariants(const mlir::AttributeStorage *,
-                                            mlir::Type eleTy) {
+fir::HeapType::verifyConstructionInvariants(mlir::Location, mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
@@ -1055,8 +1057,7 @@ SequenceType::Shape fir::SequenceType::getShape() const {
 }
 
 mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
-    const mlir::AttributeStorage *attributeStorage,
-    const SequenceType::Shape &shape, mlir::Type eleTy,
+    mlir::Location loc, const SequenceType::Shape &shape, mlir::Type eleTy,
     mlir::AffineMapAttr map) {
   // DIMENSION attribute can only be applied to an intrinsic or record type
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
@@ -1064,9 +1065,7 @@ mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
       eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>()) {
-    auto context = attributeStorage->getDialect().getContext();
-    mlir::emitError(mlir::UnknownLoc::get(context),
-                    "cannot build an array of this element type: ")
+    mlir::emitError(loc, "cannot build an array of this element type: ")
         << eleTy << '\n';
     return mlir::failure();
   }
@@ -1120,7 +1119,7 @@ detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
 }
 
 mlir::LogicalResult
-fir::RecordType::verifyConstructionInvariants(const mlir::AttributeStorage *,
+fir::RecordType::verifyConstructionInvariants(mlir::Location,
                                               llvm::StringRef name) {
   if (name.size() == 0)
     return mlir::failure();
@@ -1147,13 +1146,16 @@ TypeDescType fir::TypeDescType::get(mlir::Type ofType) {
 mlir::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
 
 mlir::LogicalResult
-fir::TypeDescType::verifyConstructionInvariants(const mlir::AttributeStorage *,
+fir::TypeDescType::verifyConstructionInvariants(mlir::Location loc,
                                                 mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
-      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
+      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>()) {
+    mlir::emitError(loc, "cannot build a type descriptor of type: ")
+        << eleTy << '\n';
     return mlir::failure();
+  }
   return mlir::success();
 }
 
diff --git a/test-lit/Fir/fir-ops.fir b/test-lit/Fir/fir-ops.fir
index 30edc2dd169b..833a752815b0 100644
--- a/test-lit/Fir/fir-ops.fir
+++ b/test-lit/Fir/fir-ops.fir
@@ -163,7 +163,7 @@ func @instructions() {
   fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
   %32 = fir.call @get_func() : () -> (() -> ())
   fir.call %32() : () -> ()
-  // CHECK: fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
+  // CHECK: fir.address_of(@it1) : !fir.ref<() -> !fir.int<4>>
   %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
   return
 }

From d0185a905b49873d2dba7b7a7831dacf196270b8 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 28 Feb 2020 12:32:38 -0800
Subject: [PATCH 205/345] add ability to build loop op with attributes

---
 include/flang/Optimizer/Dialect/FIROps.td | 11 ++++++-----
 lib/Optimizer/Dialect/FIROps.cpp          | 14 ++++++++++----
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index b97394937195..83f9ff7523d3 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -1842,10 +1842,11 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
-              "int64_t lowerBound, int64_t upperBound, int64_t step = 1">,
+              "int64_t lowerBound, int64_t upperBound, int64_t step = 1,"
+              "ArrayRef<NamedAttribute> attributes = {}">,
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
               "mlir::Value lowerBound, mlir::Value upperBound,"
-              "ValueRange step = {}">
+              "ValueRange step = {}, ArrayRef<NamedAttribute> attributes = {}">
   ];
 
   let parser = "return parseLoopOp(parser, result);";
@@ -1862,7 +1863,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
       p << " unordered";
     p.printRegion(region(), /*printEntryBlockArgs=*/false,
                             /*printBlockTerminators=*/false);
-    p.printOptionalAttrDict(getAttrs(), {unorderedKeyword(), stepKeyword()});
+    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepKeyword()});
   }];
 
   let verifier = [{
@@ -1888,11 +1889,11 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   }];
 
   let extraClassDeclaration = [{
-    static constexpr const char *unorderedKeyword() { return "unordered"; }
+    static constexpr const char *unorderedAttrName() { return "unordered"; }
     static constexpr const char *stepKeyword() { return "step"; }
 
     /// Is this an unordered loop?
-    bool isUnordered() { return getAttr(unorderedKeyword()).isa<UnitAttr>(); }
+    bool isUnordered() { return getAttr(unorderedAttrName()).isa<UnitAttr>(); }
 
     /// Does loop set (and return) the final value of the control variable?
     bool hasLastValue() { return lastVal().size(); }
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index d898a5e3e7db..58e90fec1024 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -352,12 +352,14 @@ mlir::ParseResult LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
 // LoopOp
 
 void LoopOp::build(mlir::Builder *builder, OperationState &result,
-                   int64_t lowerBound, int64_t upperBound, int64_t step) {
+                   int64_t lowerBound, int64_t upperBound, int64_t step,
+                   ArrayRef<NamedAttribute> attributes) {
   assert(false && "not implemented");
 }
 
 void LoopOp::build(mlir::Builder *builder, OperationState &result,
-                   mlir::Value lb, mlir::Value ub, ValueRange step) {
+                   mlir::Value lb, mlir::Value ub, ValueRange step,
+                   ArrayRef<NamedAttribute> attributes) {
   if (step.empty())
     result.addOperands({lb, ub});
   else
@@ -365,6 +367,10 @@ void LoopOp::build(mlir::Builder *builder, OperationState &result,
   mlir::Region *bodyRegion = result.addRegion();
   LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
   bodyRegion->front().addArgument(builder->getIndexType());
+  result.addAttributes(attributes);
+  NamedAttributeList attrs(attributes);
+  if (!attrs.get(unorderedAttrName()))
+    result.addTypes(builder->getIndexType());
 }
 
 mlir::ParseResult parseLoopOp(OpAsmParser &parser, OperationState &result) {
@@ -392,8 +398,8 @@ mlir::ParseResult parseLoopOp(OpAsmParser &parser, OperationState &result) {
 
   // Parse the optional `unordered` keyword
   bool isUnordered = false;
-  if (!parser.parseOptionalKeyword(LoopOp::unorderedKeyword())) {
-    result.addAttribute(LoopOp::unorderedKeyword(), builder.getUnitAttr());
+  if (!parser.parseOptionalKeyword(LoopOp::unorderedAttrName())) {
+    result.addAttribute(LoopOp::unorderedAttrName(), builder.getUnitAttr());
     isUnordered = true;
   }
 

From 0d4004305465d0fe92493bb541cfd9ea6678a41a Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 28 Feb 2020 14:07:25 -0800
Subject: [PATCH 206/345] [PR1035] more tweaks per code review comments

---
 lib/Optimizer/Dialect/FIRAttr.cpp |  2 +-
 lib/Optimizer/Dialect/FIROps.cpp  | 40 ++++++++++++-----------
 lib/Optimizer/Dialect/FIRType.cpp | 54 +++++++++++++++++--------------
 3 files changed, 51 insertions(+), 45 deletions(-)

diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index b2fe96e2e1d2..e4ffe5e7569e 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -232,7 +232,7 @@ void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
     a.getValue().bitcastToAPInt().toStringUnsigned(ss, 16);
     os << ss << '>';
   } else {
-    assert(false && "attribute pretty-printer is not implemented");
+    llvm_unreachable("attribute pretty-printer is not implemented");
   }
 }
 
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 58e90fec1024..1e9ba80d1c19 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -33,9 +33,8 @@ static bool verifyInType(mlir::Type inType,
         return true;
   } else if (auto rt = inType.dyn_cast<fir::RecordType>()) {
     // don't recurse if we're already visiting this one
-    for (auto name : visited)
-      if (name == rt.getName())
-        return false;
+    if (llvm::is_contained(visited, rt.getName()))
+      return false;
     // keep track of record types currently being visited
     visited.push_back(rt.getName());
     for (auto &field : rt.getTypeList())
@@ -66,7 +65,7 @@ mlir::Type AllocaOp::getAllocatedType() {
 /// Create a legal memory reference as return type
 mlir::Type AllocaOp::wrapResultType(mlir::Type intype) {
   // FIR semantics: memory references to memory references are disallowed
-  if (intype.dyn_cast<ReferenceType>())
+  if (intype.isa<ReferenceType>())
     return {};
   return ReferenceType::get(intype);
 }
@@ -86,8 +85,8 @@ mlir::Type AllocMemOp::wrapResultType(mlir::Type intype) {
   // Fortran semantics: C852 an entity cannot be both ALLOCATABLE and POINTER
   // 8.5.3 note 1 prohibits ALLOCATABLE procedures as well
   // FIR semantics: one may not allocate a memory reference value
-  if (intype.dyn_cast<ReferenceType>() || intype.dyn_cast<HeapType>() ||
-      intype.dyn_cast<PointerType>() || intype.dyn_cast<FunctionType>())
+  if (intype.isa<ReferenceType>() || intype.isa<HeapType>() ||
+      intype.isa<PointerType>() || intype.isa<FunctionType>())
     return {};
   return HeapType::get(intype);
 }
@@ -96,7 +95,8 @@ mlir::Type AllocMemOp::wrapResultType(mlir::Type intype) {
 
 /// Get the result types packed in a tuple tuple
 mlir::Type BoxDimsOp::getTupleType() {
-  llvm::SmallVector<mlir::Type, 3> triple{
+  // note: triple, but 4 is nearest power of 2
+  llvm::SmallVector<mlir::Type, 4> triple{
       getResult(0).getType(), getResult(1).getType(), getResult(2).getType()};
   return mlir::TupleType::get(triple, getContext());
 }
@@ -342,10 +342,8 @@ mlir::Type elementTypeOf(mlir::Type ref) {
 }
 
 mlir::ParseResult LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
-  if (mlir::Type r = elementTypeOf(ref)) {
-    ele = r;
+  if ((ele = elementTypeOf(ref)))
     return mlir::success();
-  }
   return mlir::failure();
 }
 
@@ -354,7 +352,7 @@ mlir::ParseResult LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
 void LoopOp::build(mlir::Builder *builder, OperationState &result,
                    int64_t lowerBound, int64_t upperBound, int64_t step,
                    ArrayRef<NamedAttribute> attributes) {
-  assert(false && "not implemented");
+  llvm_unreachable("not implemented");
 }
 
 void LoopOp::build(mlir::Builder *builder, OperationState &result,
@@ -550,24 +548,28 @@ bool isReferenceLike(mlir::Type type) {
          type.isa<fir::PointerType>();
 }
 
-mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
-                          StringRef name, mlir::FunctionType type,
-                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+} // namespace fir
+
+mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
+                               StringRef name, mlir::FunctionType type,
+                               llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
 }
 
-GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
-                        StringRef name, mlir::Type type,
-                        llvm::ArrayRef<mlir::NamedAttribute> attrs) {
-  if (auto g = module.lookupSymbol<GlobalOp>(name))
+fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
+                                  StringRef name, mlir::Type type,
+                                  llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
     return g;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
-  return modBuilder.create<GlobalOp>(loc, name, type, attrs);
+  return modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
 }
 
+namespace fir {
+
 // Tablegen operators
 
 #define GET_OP_CLASSES
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index f8fd7fcb9161..edef4abb4ef5 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -959,11 +959,14 @@ mlir::Type fir::BoxProcType::getEleTy() const {
 }
 
 mlir::LogicalResult
-fir::BoxProcType::verifyConstructionInvariants(mlir::Location,
+fir::BoxProcType::verifyConstructionInvariants(mlir::Location loc,
                                                mlir::Type eleTy) {
-  if (eleTy.isa<mlir::FunctionType>() || eleTy.isa<ReferenceType>())
+  if (eleTy.isa<mlir::FunctionType>())
     return mlir::success();
-  return mlir::failure();
+  if (auto refTy = eleTy.dyn_cast<ReferenceType>())
+    if (refTy.isa<mlir::FunctionType>())
+      return mlir::success();
+  return mlir::emitError(loc, "invalid type for boxproc") << eleTy << '\n';
 }
 
 // Reference<T>
@@ -977,11 +980,12 @@ mlir::Type fir::ReferenceType::getEleTy() const {
 }
 
 mlir::LogicalResult
-fir::ReferenceType::verifyConstructionInvariants(mlir::Location,
+fir::ReferenceType::verifyConstructionInvariants(mlir::Location loc,
                                                  mlir::Type eleTy) {
   if (eleTy.isa<DimsType>() || eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
       eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
-    return mlir::failure();
+    return mlir::emitError(loc, "cannot build a reference to type: ")
+           << eleTy << '\n';
   return mlir::success();
 }
 
@@ -989,7 +993,7 @@ fir::ReferenceType::verifyConstructionInvariants(mlir::Location,
 
 PointerType fir::PointerType::get(mlir::Type elementType) {
   if (!singleIndirectionLevel(elementType)) {
-    assert(false && "FIXME: invalid element type");
+    llvm_unreachable("FIXME: invalid element type");
     return {};
   }
   return Base::get(elementType.getContext(), FIR_POINTER, elementType);
@@ -1000,14 +1004,15 @@ mlir::Type fir::PointerType::getEleTy() const {
 }
 
 mlir::LogicalResult
-fir::PointerType::verifyConstructionInvariants(mlir::Location,
+fir::PointerType::verifyConstructionInvariants(mlir::Location loc,
                                                mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
       eleTy.isa<TypeDescType>())
-    return mlir::failure();
+    return mlir::emitError(loc, "cannot build a pointer to type: ")
+           << eleTy << '\n';
   return mlir::success();
 }
 
@@ -1015,7 +1020,7 @@ fir::PointerType::verifyConstructionInvariants(mlir::Location,
 
 HeapType fir::HeapType::get(mlir::Type elementType) {
   if (!singleIndirectionLevel(elementType)) {
-    assert(false && "FIXME: invalid element type");
+    llvm_unreachable("FIXME: invalid element type");
     return {};
   }
   return Base::get(elementType.getContext(), FIR_HEAP, elementType);
@@ -1026,13 +1031,15 @@ mlir::Type fir::HeapType::getEleTy() const {
 }
 
 mlir::LogicalResult
-fir::HeapType::verifyConstructionInvariants(mlir::Location, mlir::Type eleTy) {
+fir::HeapType::verifyConstructionInvariants(mlir::Location loc,
+                                            mlir::Type eleTy) {
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
       eleTy.isa<TypeDescType>())
-    return mlir::failure();
+    return mlir::emitError(loc, "cannot build a heap pointer to type: ")
+           << eleTy << '\n';
   return mlir::success();
 }
 
@@ -1064,11 +1071,9 @@ mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
-      eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>()) {
-    mlir::emitError(loc, "cannot build an array of this element type: ")
-        << eleTy << '\n';
-    return mlir::failure();
-  }
+      eleTy.isa<TypeDescType>() || eleTy.isa<SequenceType>())
+    return mlir::emitError(loc, "cannot build an array of this element type: ")
+           << eleTy << '\n';
   return mlir::success();
 }
 
@@ -1077,7 +1082,8 @@ bool fir::operator==(const SequenceType::Shape &sh_1,
                      const SequenceType::Shape &sh_2) {
   if (sh_1.size() != sh_2.size())
     return false;
-  for (std::size_t i = 0, e{sh_1.size()}; i != e; ++i)
+  auto e = sh_1.size();
+  for (decltype(e) i = 0; i != e; ++i)
     if (sh_1[i] != sh_2[i])
       return false;
   return true;
@@ -1119,10 +1125,10 @@ detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
 }
 
 mlir::LogicalResult
-fir::RecordType::verifyConstructionInvariants(mlir::Location,
+fir::RecordType::verifyConstructionInvariants(mlir::Location loc,
                                               llvm::StringRef name) {
   if (name.size() == 0)
-    return mlir::failure();
+    return mlir::emitError(loc, "record types must have a name");
   return mlir::success();
 }
 
@@ -1130,7 +1136,7 @@ mlir::Type fir::RecordType::getType(llvm::StringRef ident) {
   for (auto f : getTypeList())
     if (ident == f.first)
       return f.second;
-  assert(false && "query for field not present in record");
+  llvm_unreachable("query for field not present in record");
   return {};
 }
 
@@ -1151,11 +1157,9 @@ fir::TypeDescType::verifyConstructionInvariants(mlir::Location loc,
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
-      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>()) {
-    mlir::emitError(loc, "cannot build a type descriptor of type: ")
-        << eleTy << '\n';
-    return mlir::failure();
-  }
+      eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
+    return mlir::emitError(loc, "cannot build a type descriptor of type: ")
+           << eleTy << '\n';
   return mlir::success();
 }
 

From a52f833de19b9e4fb335e38814c149d4885c0797 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 28 Feb 2020 17:25:42 -0800
Subject: [PATCH 207/345] rebase changes

---
 tools/bbc/CMakeLists.txt | 3 ++-
 tools/tco/CMakeLists.txt | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/tools/bbc/CMakeLists.txt b/tools/bbc/CMakeLists.txt
index 8c6cc0818584..0398a2cac76a 100644
--- a/tools/bbc/CMakeLists.txt
+++ b/tools/bbc/CMakeLists.txt
@@ -1,10 +1,11 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 set(LIBS
   FIRDialect
   FIROptimizer
   FIRTransforms
-  MLIRAllDialects
+  ${dialect_libs}
   MLIRLLVMIR
   MLIRAffineToStandard
   FortranCommon
diff --git a/tools/tco/CMakeLists.txt b/tools/tco/CMakeLists.txt
index 6966c907ef3c..3bd3f4b87aa8 100644
--- a/tools/tco/CMakeLists.txt
+++ b/tools/tco/CMakeLists.txt
@@ -1,10 +1,11 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 set(LIBS
   FIRDialect
   FIROptimizer
   FIRTransforms
-  MLIRAllDialects
+  ${dialect_libs}
   MLIRIR
   MLIRLLVMIR
   MLIRPass

From 2d53c0b5a5637beb219b195d310f16e82f6991c9 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 28 Feb 2020 17:28:03 -0800
Subject: [PATCH 208/345] [PR1035] more code cleanups

---
 include/flang/Optimizer/Dialect/FIROps.h      |  32 +--
 include/flang/Optimizer/Dialect/FIROps.td     |  26 ++-
 include/flang/Optimizer/Support/KindMapping.h |   2 +-
 lib/Optimizer/Dialect/FIROps.cpp              | 205 +++++++++---------
 tools/tco/tco.cpp                             |  32 ++-
 5 files changed, 149 insertions(+), 148 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
index cd5c8b6ef66a..3f82809d0244 100644
--- a/include/flang/Optimizer/Dialect/FIROps.h
+++ b/include/flang/Optimizer/Dialect/FIROps.h
@@ -21,6 +21,7 @@ using namespace mlir;
 namespace fir {
 
 class FirEndOp;
+class LoopOp;
 
 enum class CmpFPredicate {
   FirstValidValue,
@@ -50,25 +51,26 @@ enum class CmpFPredicate {
   NumPredicates
 };
 
-ParseResult isValidCaseAttr(Attribute attr);
-unsigned getCaseArgumentOffset(ArrayRef<Attribute> cases, unsigned dest);
-ParseResult parseSelector(OpAsmParser *parser, OperationState *result,
-                          OpAsmParser::OperandType &selector, mlir::Type &type);
-
-void buildCmpFOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value lhs, Value rhs);
-void buildCmpCOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value lhs, Value rhs);
-ParseResult parseCmpfOp(OpAsmParser &parser, OperationState &result);
-ParseResult parseCmpcOp(OpAsmParser &parser, OperationState &result);
+void buildCmpFOp(mlir::Builder *builder, mlir::OperationState &result,
+                 CmpFPredicate predicate, mlir::Value lhs, mlir::Value rhs);
+void buildCmpCOp(mlir::Builder *builder, mlir::OperationState &result,
+                 CmpFPredicate predicate, mlir::Value lhs, mlir::Value rhs);
+unsigned getCaseArgumentOffset(ArrayRef<mlir::Attribute> cases, unsigned dest);
+LoopOp getForInductionVarOwner(mlir::Value val);
+bool isReferenceLike(mlir::Type type);
+mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);
+mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result);
+mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
+                              mlir::OperationState &result);
+mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result,
+                                mlir::OpAsmParser::OperandType &selector,
+                                mlir::Type &type);
 
 #define GET_OP_CLASSES
 #include "flang/Optimizer/Dialect/FIROps.h.inc"
 
-LoopOp getForInductionVarOwner(Value val);
-
-bool isReferenceLike(mlir::Type type);
-
 } // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIROPS_H
diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 83f9ff7523d3..3ed63918f1d1 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -370,7 +370,7 @@ def fir_LoadOp : fir_OneResultOp<"load", []> {
         mlir::emitError(result.location, "LoadOp has null argument");
         return;
       }
-      fir::ReferenceType refTy = refVal.getType().cast<fir::ReferenceType>();
+      auto refTy = refVal.getType().cast<fir::ReferenceType>();
       result.addOperands(refVal);
       result.addTypes(refTy.getEleTy());
     }]
@@ -1863,7 +1863,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
       p << " unordered";
     p.printRegion(region(), /*printEntryBlockArgs=*/false,
                             /*printBlockTerminators=*/false);
-    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepKeyword()});
+    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepAttrName()});
   }];
 
   let verifier = [{
@@ -1890,7 +1890,7 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
 
   let extraClassDeclaration = [{
     static constexpr const char *unorderedAttrName() { return "unordered"; }
-    static constexpr const char *stepKeyword() { return "step"; }
+    static constexpr const char *stepAttrName() { return "step"; }
 
     /// Is this an unordered loop?
     bool isUnordered() { return getAttr(unorderedAttrName()).isa<UnitAttr>(); }
@@ -2018,6 +2018,10 @@ def fir_CallOp : fir_Op<"call", []> {
 
   let parser = "return parseCallOp(parser, result);";
   let printer = "printCallOp(p, *this);";
+
+  let extraClassDeclaration = [{
+    static constexpr StringRef calleeAttrName() { return "callee"; }
+  }];
 }
 
 def fir_DispatchOp : fir_Op<"dispatch", []> {
@@ -2186,7 +2190,7 @@ class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 
-  let printer = [{ return fir::printBinaryOp(this->getOperation(), p); }];
+  let printer = [{ return printBinaryOp(this->getOperation(), p); }];
 }
 
 class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
@@ -2197,7 +2201,7 @@ class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 
-  let printer = [{ return fir::printUnaryOp(this->getOperation(), p); }];
+  let printer = [{ return printUnaryOp(this->getOperation(), p); }];
 }
 
 def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]> {
@@ -2272,12 +2276,12 @@ def fir_CmpfOp : fir_Op<"cmpf",
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpFPredicate predicate,"
     "Value lhs, Value rhs", [{
-      fir::buildCmpFOp(builder, result, predicate, lhs, rhs);
+      buildCmpFOp(builder, result, predicate, lhs, rhs);
   }]>];
 
-  let parser = [{ return fir::parseCmpfOp(parser, result); }];
+  let parser = [{ return parseCmpfOp(parser, result); }];
 
-  let printer = [{ fir::printCmpfOp(p, *this); }];
+  let printer = [{ printCmpfOp(p, *this); }];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getPredicateAttrName() {
@@ -2373,14 +2377,14 @@ def fir_CmpcOp : fir_Op<"cmpc",
 
   let results = (outs AnyLogicalLike);
 
-  let parser = "return fir::parseCmpcOp(parser, result);";
+  let parser = "return parseCmpcOp(parser, result);";
 
-  let printer = "fir::printCmpcOp(p, *this);";
+  let printer = "printCmpcOp(p, *this);";
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpFPredicate predicate,"
     "Value lhs, Value rhs", [{
-      fir::buildCmpCOp(builder, result, predicate, lhs, rhs);
+      buildCmpCOp(builder, result, predicate, lhs, rhs);
   }]>];
 
   let extraClassDeclaration = [{
diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
index bd2b8e2e190b..c0f77ede7f5e 100644
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -76,7 +76,7 @@ class KindMapping {
   const llvm::fltSemantics &getFloatSemantics(KindTy kind);
 
 private:
-  MatchResult badMapString(llvm::Twine const &ptr);
+  MatchResult badMapString(const llvm::Twine &ptr);
   MatchResult parse(llvm::StringRef kindMap);
 
   mlir::MLIRContext *context;
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 1e9ba80d1c19..fc0e87c86981 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -10,6 +10,7 @@
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
@@ -18,7 +19,7 @@
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/StringSwitch.h"
 
-namespace fir {
+using namespace fir;
 
 /// return true if the sequence type is abstract or the record type is malformed
 /// or contains an abstract sequence type
@@ -58,30 +59,34 @@ static bool verifyRecordLenParams(mlir::Type inType, unsigned numLenParams) {
 
 // AllocaOp
 
-mlir::Type AllocaOp::getAllocatedType() {
+mlir::Type fir::AllocaOp::getAllocatedType() {
   return getType().cast<ReferenceType>().getEleTy();
 }
 
 /// Create a legal memory reference as return type
-mlir::Type AllocaOp::wrapResultType(mlir::Type intype) {
+mlir::Type fir::AllocaOp::wrapResultType(mlir::Type intype) {
   // FIR semantics: memory references to memory references are disallowed
   if (intype.isa<ReferenceType>())
     return {};
   return ReferenceType::get(intype);
 }
 
-mlir::Type AllocaOp::getRefTy(mlir::Type ty) { return ReferenceType::get(ty); }
+mlir::Type fir::AllocaOp::getRefTy(mlir::Type ty) {
+  return ReferenceType::get(ty);
+}
 
 // AllocMemOp
 
-mlir::Type AllocMemOp::getAllocatedType() {
+mlir::Type fir::AllocMemOp::getAllocatedType() {
   return getType().cast<HeapType>().getEleTy();
 }
 
-mlir::Type AllocMemOp::getRefTy(mlir::Type ty) { return HeapType::get(ty); }
+mlir::Type fir::AllocMemOp::getRefTy(mlir::Type ty) {
+  return HeapType::get(ty);
+}
 
 /// Create a legal heap reference as return type
-mlir::Type AllocMemOp::wrapResultType(mlir::Type intype) {
+mlir::Type fir::AllocMemOp::wrapResultType(mlir::Type intype) {
   // Fortran semantics: C852 an entity cannot be both ALLOCATABLE and POINTER
   // 8.5.3 note 1 prohibits ALLOCATABLE procedures as well
   // FIR semantics: one may not allocate a memory reference value
@@ -94,7 +99,7 @@ mlir::Type AllocMemOp::wrapResultType(mlir::Type intype) {
 // BoxDimsOp
 
 /// Get the result types packed in a tuple tuple
-mlir::Type BoxDimsOp::getTupleType() {
+mlir::Type fir::BoxDimsOp::getTupleType() {
   // note: triple, but 4 is nearest power of 2
   llvm::SmallVector<mlir::Type, 4> triple{
       getResult(0).getType(), getResult(1).getType(), getResult(2).getType()};
@@ -103,7 +108,7 @@ mlir::Type BoxDimsOp::getTupleType() {
 
 // CallOp
 
-void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
+static void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
   auto callee = op.callee();
   bool isDirect = callee.hasValue();
   p << op.getOperationName() << ' ';
@@ -111,31 +116,28 @@ void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
     p << callee.getValue();
   else
     p << op.getOperand(0);
-  p << '(';
-  p.printOperands(llvm::drop_begin(op.getOperands(), isDirect ? 0 : 1));
-  p << ')';
-  p.printOptionalAttrDict(op.getAttrs(), {"callee"});
+  p << '(' << op.getOperands().drop_front(isDirect ? 0 : 1) << ')';
+  p.printOptionalAttrDict(op.getAttrs(), {fir::CallOp::calleeAttrName()});
   auto resultTypes{op.getResultTypes()};
   llvm::SmallVector<Type, 8> argTypes(
       llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
   p << " : " << FunctionType::get(argTypes, resultTypes, op.getContext());
 }
 
-mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result) {
+static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
+                                     mlir::OperationState &result) {
   llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
-
   if (parser.parseOperandList(operands))
     return mlir::failure();
-  bool isDirect = operands.empty();
-  SmallVector<NamedAttribute, 4> attrs;
-  SymbolRefAttr funcAttr;
 
+  llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
+  mlir::SymbolRefAttr funcAttr;
+  bool isDirect = operands.empty();
   if (isDirect)
-    if (parser.parseAttribute(funcAttr, "callee", attrs))
+    if (parser.parseAttribute(funcAttr, fir::CallOp::calleeAttrName(), attrs))
       return mlir::failure();
-  Type type;
 
+  Type type;
   if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
       parser.parseOptionalAttrDict(attrs) || parser.parseColon() ||
       parser.parseType(type))
@@ -166,29 +168,29 @@ mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
 
 // CmpfOp
 
-fir::CmpFPredicate CmpfOp::getPredicateByName(llvm::StringRef name) {
+fir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
   return llvm::StringSwitch<fir::CmpFPredicate>(name)
-      .Case("false", CmpFPredicate::AlwaysFalse)
-      .Case("oeq", CmpFPredicate::OEQ)
-      .Case("ogt", CmpFPredicate::OGT)
-      .Case("oge", CmpFPredicate::OGE)
-      .Case("olt", CmpFPredicate::OLT)
-      .Case("ole", CmpFPredicate::OLE)
-      .Case("one", CmpFPredicate::ONE)
-      .Case("ord", CmpFPredicate::ORD)
-      .Case("ueq", CmpFPredicate::UEQ)
-      .Case("ugt", CmpFPredicate::UGT)
-      .Case("uge", CmpFPredicate::UGE)
-      .Case("ult", CmpFPredicate::ULT)
-      .Case("ule", CmpFPredicate::ULE)
-      .Case("une", CmpFPredicate::UNE)
-      .Case("uno", CmpFPredicate::UNO)
-      .Case("true", CmpFPredicate::AlwaysTrue)
-      .Default(CmpFPredicate::NumPredicates);
-}
-
-void buildCmpFOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value lhs, Value rhs) {
+      .Case("false", fir::CmpFPredicate::AlwaysFalse)
+      .Case("oeq", fir::CmpFPredicate::OEQ)
+      .Case("ogt", fir::CmpFPredicate::OGT)
+      .Case("oge", fir::CmpFPredicate::OGE)
+      .Case("olt", fir::CmpFPredicate::OLT)
+      .Case("ole", fir::CmpFPredicate::OLE)
+      .Case("one", fir::CmpFPredicate::ONE)
+      .Case("ord", fir::CmpFPredicate::ORD)
+      .Case("ueq", fir::CmpFPredicate::UEQ)
+      .Case("ugt", fir::CmpFPredicate::UGT)
+      .Case("uge", fir::CmpFPredicate::UGE)
+      .Case("ult", fir::CmpFPredicate::ULT)
+      .Case("ule", fir::CmpFPredicate::ULE)
+      .Case("une", fir::CmpFPredicate::UNE)
+      .Case("uno", fir::CmpFPredicate::UNO)
+      .Case("true", fir::CmpFPredicate::AlwaysTrue)
+      .Default(fir::CmpFPredicate::NumPredicates);
+}
+
+void fir::buildCmpFOp(Builder *builder, OperationState &result,
+                      fir::CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder->getI1Type());
   result.addAttribute(
@@ -197,7 +199,7 @@ void buildCmpFOp(Builder *builder, OperationState &result,
 }
 
 template <typename OPTY>
-void printCmpOp(OpAsmPrinter &p, OPTY op) {
+static void printCmpOp(OpAsmPrinter &p, OPTY op) {
   static const char *predicateNames[] = {
       /*AlwaysFalse*/ "false",
       /*OEQ*/ "oeq",
@@ -223,8 +225,9 @@ void printCmpOp(OpAsmPrinter &p, OPTY op) {
   auto predicateValue =
       op.template getAttrOfType<mlir::IntegerAttr>(OPTY::getPredicateAttrName())
           .getInt();
-  assert(predicateValue >= static_cast<int>(CmpFPredicate::FirstValidValue) &&
-         predicateValue < static_cast<int>(CmpFPredicate::NumPredicates) &&
+  assert(predicateValue >=
+             static_cast<int>(fir::CmpFPredicate::FirstValidValue) &&
+         predicateValue < static_cast<int>(fir::CmpFPredicate::NumPredicates) &&
          "unknown predicate index");
   Builder b(op.getContext());
   auto predicateStringAttr = b.getStringAttr(predicateNames[predicateValue]);
@@ -238,11 +241,11 @@ void printCmpOp(OpAsmPrinter &p, OPTY op) {
   p << " : " << op.lhs().getType();
 }
 
-void printCmpfOp(OpAsmPrinter &p, CmpfOp op) { printCmpOp(p, op); }
+static void printCmpfOp(OpAsmPrinter &p, CmpfOp op) { printCmpOp(p, op); }
 
 template <typename OPTY>
-mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
-                             mlir::OperationState &result) {
+static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
+                                    mlir::OperationState &result) {
   llvm::SmallVector<mlir::OpAsmParser::OperandType, 2> ops;
   llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
   mlir::Attribute predicateNameAttr;
@@ -261,8 +264,8 @@ mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
   // Rewrite string attribute to an enum value.
   llvm::StringRef predicateName =
       predicateNameAttr.cast<mlir::StringAttr>().getValue();
-  auto predicate = CmpfOp::getPredicateByName(predicateName);
-  if (predicate == CmpFPredicate::NumPredicates)
+  auto predicate = fir::CmpfOp::getPredicateByName(predicateName);
+  if (predicate == fir::CmpFPredicate::NumPredicates)
     return parser.emitError(parser.getNameLoc(),
                             "unknown comparison predicate \"" + predicateName +
                                 "\"");
@@ -275,39 +278,39 @@ mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
   return success();
 }
 
-mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result) {
+mlir::ParseResult fir::parseCmpfOp(mlir::OpAsmParser &parser,
+                                   mlir::OperationState &result) {
   return parseCmpOp<fir::CmpfOp>(parser, result);
 }
 
 // CmpcOp
 
-void buildCmpCOp(Builder *builder, OperationState &result,
-                 CmpFPredicate predicate, Value lhs, Value rhs) {
+void fir::buildCmpCOp(Builder *builder, OperationState &result,
+                      fir::CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder->getI1Type());
   result.addAttribute(
-      CmpcOp::getPredicateAttrName(),
+      fir::CmpcOp::getPredicateAttrName(),
       builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
 }
 
-void printCmpcOp(OpAsmPrinter &p, CmpcOp op) { printCmpOp(p, op); }
+static void printCmpcOp(OpAsmPrinter &p, fir::CmpcOp op) { printCmpOp(p, op); }
 
-mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
-                              mlir::OperationState &result) {
+mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
+                                   mlir::OperationState &result) {
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
 // DispatchOp
 
-mlir::FunctionType DispatchOp::getFunctionType() {
+mlir::FunctionType fir::DispatchOp::getFunctionType() {
   auto attr = getAttr("fn_type").cast<mlir::TypeAttr>();
   return attr.getValue().cast<mlir::FunctionType>();
 }
 
 // DispatchTableOp
 
-void DispatchTableOp::appendTableEntry(mlir::Operation *op) {
+void fir::DispatchTableOp::appendTableEntry(mlir::Operation *op) {
   assert(mlir::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
   auto &block = getBlock();
   block.getOperations().insert(block.end(), op);
@@ -315,33 +318,29 @@ void DispatchTableOp::appendTableEntry(mlir::Operation *op) {
 
 // GenTypeDescOp
 
-void GenTypeDescOp::build(Builder *, OperationState &result,
-                          mlir::TypeAttr inty) {
+void fir::GenTypeDescOp::build(Builder *, OperationState &result,
+                               mlir::TypeAttr inty) {
   result.addAttribute("in_type", inty);
   result.addTypes(TypeDescType::get(inty.getValue()));
 }
 
 // GlobalOp
 
-void GlobalOp::appendInitialValue(mlir::Operation *op) {
-  auto &block = getBlock();
-  block.getOperations().insert(block.end(), op);
+void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
+  getBlock().getOperations().push_back(op);
 }
 
 // LoadOp
 
 /// Get the element type of a reference like type; otherwise null
-mlir::Type elementTypeOf(mlir::Type ref) {
-  if (auto r = ref.dyn_cast_or_null<ReferenceType>())
-    return r.getEleTy();
-  if (auto r = ref.dyn_cast_or_null<PointerType>())
-    return r.getEleTy();
-  if (auto r = ref.dyn_cast_or_null<HeapType>())
-    return r.getEleTy();
-  return {};
+static mlir::Type elementTypeOf(mlir::Type ref) {
+  return mlir::TypeSwitch<mlir::Type, mlir::Type>(ref)
+      .Case<ReferenceType, PointerType, HeapType>(
+          [](auto type) { return type.getEleTy(); })
+      .Default([](mlir::Type) { return mlir::Type{}; });
 }
 
-mlir::ParseResult LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
+mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
   if ((ele = elementTypeOf(ref)))
     return mlir::success();
   return mlir::failure();
@@ -349,15 +348,15 @@ mlir::ParseResult LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
 
 // LoopOp
 
-void LoopOp::build(mlir::Builder *builder, OperationState &result,
-                   int64_t lowerBound, int64_t upperBound, int64_t step,
-                   ArrayRef<NamedAttribute> attributes) {
+void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
+                        int64_t lowerBound, int64_t upperBound, int64_t step,
+                        ArrayRef<NamedAttribute> attributes) {
   llvm_unreachable("not implemented");
 }
 
-void LoopOp::build(mlir::Builder *builder, OperationState &result,
-                   mlir::Value lb, mlir::Value ub, ValueRange step,
-                   ArrayRef<NamedAttribute> attributes) {
+void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
+                        mlir::Value lb, mlir::Value ub, ValueRange step,
+                        ArrayRef<NamedAttribute> attributes) {
   if (step.empty())
     result.addOperands({lb, ub});
   else
@@ -371,7 +370,8 @@ void LoopOp::build(mlir::Builder *builder, OperationState &result,
     result.addTypes(builder->getIndexType());
 }
 
-mlir::ParseResult parseLoopOp(OpAsmParser &parser, OperationState &result) {
+static mlir::ParseResult parseLoopOp(OpAsmParser &parser,
+                                     OperationState &result) {
   auto &builder = parser.getBuilder();
   OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
@@ -386,8 +386,8 @@ mlir::ParseResult parseLoopOp(OpAsmParser &parser, OperationState &result) {
       parser.resolveOperand(ub, indexType, result.operands))
     return mlir::failure();
 
-  if (parser.parseOptionalKeyword(LoopOp::stepKeyword())) {
-    result.addAttribute(LoopOp::stepKeyword(),
+  if (parser.parseOptionalKeyword(LoopOp::stepAttrName())) {
+    result.addAttribute(LoopOp::stepAttrName(),
                         builder.getIntegerAttr(builder.getIndexType(), 1));
   } else if (parser.parseOperand(step) ||
              parser.resolveOperand(step, indexType, result.operands)) {
@@ -416,10 +416,10 @@ mlir::ParseResult parseLoopOp(OpAsmParser &parser, OperationState &result) {
   return mlir::success();
 }
 
-fir::LoopOp getForInductionVarOwner(mlir::Value val) {
+fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
   auto ivArg = val.dyn_cast<mlir::BlockArgument>();
   if (!ivArg)
-    return fir::LoopOp();
+    return {};
   assert(ivArg.getOwner() && "unlinked block argument");
   auto *containingInst = ivArg.getOwner()->getParentOp();
   return dyn_cast_or_null<fir::LoopOp>(containingInst);
@@ -427,7 +427,7 @@ fir::LoopOp getForInductionVarOwner(mlir::Value val) {
 
 // StoreOp
 
-mlir::Type StoreOp::elementType(mlir::Type refType) {
+mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
   if (auto ref = refType.dyn_cast<ReferenceType>())
     return ref.getEleTy();
   if (auto ref = refType.dyn_cast<PointerType>())
@@ -439,15 +439,15 @@ mlir::Type StoreOp::elementType(mlir::Type refType) {
 
 // StringLitOp
 
-bool StringLitOp::isWideValue() {
+bool fir::StringLitOp::isWideValue() {
   auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
   return eleTy.cast<fir::CharacterType>().getFKind() != 1;
 }
 
 // WhereOp
 
-void WhereOp::build(mlir::Builder *builder, OperationState &result,
-                    mlir::Value cond, bool withElseRegion) {
+void fir::WhereOp::build(mlir::Builder *builder, OperationState &result,
+                         mlir::Value cond, bool withElseRegion) {
   result.addOperands(cond);
   mlir::Region *thenRegion = result.addRegion();
   mlir::Region *elseRegion = result.addRegion();
@@ -456,7 +456,8 @@ void WhereOp::build(mlir::Builder *builder, OperationState &result,
     WhereOp::ensureTerminator(*elseRegion, *builder, result.location);
 }
 
-mlir::ParseResult parseWhereOp(OpAsmParser &parser, OperationState &result) {
+static mlir::ParseResult parseWhereOp(OpAsmParser &parser,
+                                      OperationState &result) {
   // Create the regions for 'then'.
   result.regions.reserve(2);
   mlir::Region *thenRegion = result.addRegion();
@@ -488,7 +489,7 @@ mlir::ParseResult parseWhereOp(OpAsmParser &parser, OperationState &result) {
   return mlir::success();
 }
 
-mlir::ParseResult isValidCaseAttr(mlir::Attribute attr) {
+mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {
   if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||
       attr.dyn_cast_or_null<ClosedIntervalAttr>() ||
       attr.dyn_cast_or_null<PointIntervalAttr>() ||
@@ -498,8 +499,8 @@ mlir::ParseResult isValidCaseAttr(mlir::Attribute attr) {
   return mlir::failure();
 }
 
-unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
-                               unsigned dest) {
+unsigned fir::getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
+                                    unsigned dest) {
   unsigned o = 0;
   for (unsigned i = 0; i < dest; ++i) {
     auto &attr = cases[i];
@@ -512,10 +513,10 @@ unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
   return o;
 }
 
-mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
-                                mlir::OperationState &result,
-                                mlir::OpAsmParser::OperandType &selector,
-                                mlir::Type &type) {
+mlir::ParseResult fir::parseSelector(mlir::OpAsmParser &parser,
+                                     mlir::OperationState &result,
+                                     mlir::OpAsmParser::OperandType &selector,
+                                     mlir::Type &type) {
   if (parser.parseOperand(selector) || parser.parseColonType(type) ||
       parser.resolveOperand(selector, type, result.operands) ||
       parser.parseLSquare())
@@ -524,7 +525,7 @@ mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
 }
 
 /// Generic pretty-printer of a binary operation
-void printBinaryOp(Operation *op, OpAsmPrinter &p) {
+static void printBinaryOp(Operation *op, OpAsmPrinter &p) {
   assert(op->getNumOperands() == 2 && "binary op must have two operands");
   assert(op->getNumResults() == 1 && "binary op must have one result");
 
@@ -534,7 +535,7 @@ void printBinaryOp(Operation *op, OpAsmPrinter &p) {
 }
 
 /// Generic pretty-printer of an unary operation
-void printUnaryOp(Operation *op, OpAsmPrinter &p) {
+static void printUnaryOp(Operation *op, OpAsmPrinter &p) {
   assert(op->getNumOperands() == 1 && "unary op must have one operand");
   assert(op->getNumResults() == 1 && "unary op must have one result");
 
@@ -543,13 +544,11 @@ void printUnaryOp(Operation *op, OpAsmPrinter &p) {
   p << " : " << op->getResult(0).getType();
 }
 
-bool isReferenceLike(mlir::Type type) {
+bool fir::isReferenceLike(mlir::Type type) {
   return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
          type.isa<fir::PointerType>();
 }
 
-} // namespace fir
-
 mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                                StringRef name, mlir::FunctionType type,
                                llvm::ArrayRef<mlir::NamedAttribute> attrs) {
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 168551ef0cf3..46e1707fc290 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -33,30 +33,27 @@
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
-namespace {
-
 using namespace llvm;
 
-cl::opt<std::string> inputFilename(cl::Positional, cl::desc("<input file>"),
-                                   cl::init("-"));
+static cl::opt<std::string>
+    inputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
 
-cl::opt<std::string> outputFilename("o", cl::desc("Specify output filename"),
-                                    cl::value_desc("filename"), cl::init("-"));
+static cl::opt<std::string> outputFilename("o",
+                                           cl::desc("Specify output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::init("-"));
 
-cl::opt<bool> emitFir("emit-fir", cl::desc("Parse and pretty-print the input"),
-                      cl::init(false));
+static cl::opt<bool> emitFir("emit-fir",
+                             cl::desc("Parse and pretty-print the input"),
+                             cl::init(false));
 
-void printModuleBody(mlir::ModuleOp mod, raw_ostream &output) {
-  // don't output the terminator bogo-op
-  auto e{--mod.end()};
-  for (auto i{mod.begin()}; i != e; ++i) {
-    i->print(output);
-    output << "\n\n";
-  }
+static void printModuleBody(mlir::ModuleOp mod, raw_ostream &output) {
+  for (auto &op : mod.getBody()->without_terminator())
+    output << op << '\n';
 }
 
 // compile a .fir file
-int compileFIR() {
+static int compileFIR() {
   // check that there is a file to load
   ErrorOr<std::unique_ptr<MemoryBuffer>> fileOrErr =
       MemoryBuffer::getFileOrSTDIN(inputFilename);
@@ -119,10 +116,9 @@ int compileFIR() {
 
   // pass manager failed
   printModuleBody(*owningRef, errs());
-  errs() << "\nFAILED: " << inputFilename << '\n';
+  errs() << "\n\nFAILED: " << inputFilename << '\n';
   return 8;
 }
-} // namespace
 
 int main(int argc, char **argv) {
   mlir::registerAllDialects();

From 3af50ca6082c5f4d6fb688d846007950a636a272 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 2 Mar 2020 14:37:10 -0800
Subject: [PATCH 209/345] [PR1035] LLVM standards, document FIR types,
 unordered_map

---
 include/flang/Optimizer/Dialect/FIRType.h     | 47 +++++++++++++++
 include/flang/Optimizer/Support/KindMapping.h |  6 +-
 lib/Optimizer/Support/KindMapping.cpp         | 60 +++++++++----------
 3 files changed, 77 insertions(+), 36 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 949f75c4afba..1b527a0f5b8a 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -101,6 +101,11 @@ struct IntrinsicTypeMixin {
   static constexpr unsigned getId() { return Id; }
 };
 
+// Intrinsic types
+
+/// Model of the Fortran CHARACTER intrinsic type, including the KIND type
+/// parameter. The model does not include a LEN type parameter. A CharacterType
+/// is thus the type of a single character value.
 class CharacterType
     : public mlir::Type::TypeBase<CharacterType, mlir::Type,
                                   detail::CharacterTypeStorage>,
@@ -111,6 +116,9 @@ class CharacterType
   KindTy getFKind() const;
 };
 
+/// Model of a Fortran COMPLEX intrinsic type, including the KIND type
+/// parameter. COMPLEX is a floating point type with a real and imaginary
+/// member.
 class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
                                              detail::CplxTypeStorage>,
                  public IntrinsicTypeMixin<CplxType, TypeKind::FIR_COMPLEX> {
@@ -120,6 +128,8 @@ class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
   KindTy getFKind() const;
 };
 
+/// Model of a Fortran INTEGER intrinsic type, including the KIND type
+/// parameter.
 class IntType
     : public mlir::Type::TypeBase<IntType, mlir::Type, detail::IntTypeStorage>,
       public IntrinsicTypeMixin<IntType, TypeKind::FIR_INT> {
@@ -129,6 +139,8 @@ class IntType
   KindTy getFKind() const;
 };
 
+/// Model of a Fortran LOGICAL intrinsic type, including the KIND type
+/// parameter.
 class LogicalType
     : public mlir::Type::TypeBase<LogicalType, mlir::Type,
                                   detail::LogicalTypeStorage>,
@@ -139,6 +151,8 @@ class LogicalType
   KindTy getFKind() const;
 };
 
+/// Model of a Fortran REAL (and DOUBLE PRECISION) intrinsic type, including the
+/// KIND type parameter.
 class RealType : public mlir::Type::TypeBase<RealType, mlir::Type,
                                              detail::RealTypeStorage>,
                  public IntrinsicTypeMixin<RealType, TypeKind::FIR_REAL> {
@@ -150,6 +164,10 @@ class RealType : public mlir::Type::TypeBase<RealType, mlir::Type,
 
 // FIR support types
 
+/// The type of a Fortran descriptor. Descriptors are tuples of information that
+/// describe an entity being passed from a calling context. This information
+/// might include (but is not limited to) whether the entity is an array, its
+/// size, or what type it has.
 class BoxType
     : public mlir::Type::TypeBase<BoxType, mlir::Type, detail::BoxTypeStorage> {
 public:
@@ -164,6 +182,9 @@ class BoxType
                                mlir::AffineMapAttr map);
 };
 
+/// The type of a pair that describes a CHARACTER variable. Specifically, a
+/// CHARACTER consists of a reference to a buffer (the string value) and a LEN
+/// type parameter (the runtime length of the buffer).
 class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
                                                 detail::BoxCharTypeStorage> {
 public:
@@ -173,6 +194,9 @@ class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
   CharacterType getEleTy() const;
 };
 
+/// The type of a pair that describes a PROCEDURE reference. Pointers to
+/// internal procedures must carry an additional reference to the host's
+/// variables that are referenced.
 class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
                                                 detail::BoxProcTypeStorage> {
 public:
@@ -185,6 +209,10 @@ class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
                                                           mlir::Type eleTy);
 };
 
+/// The type of a runtime vector that describes triples of array dimension
+/// information. A triple consists of a lower bound, upper bound, and
+/// stride. Each dimension of an array entity may have an associated triple that
+/// maps how elements of the array are accessed.
 class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
                                              detail::DimsTypeStorage> {
 public:
@@ -196,6 +224,9 @@ class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
   int getRank() const;
 };
 
+/// The type of a field name. Implementations may defer the layout of a Fortran
+/// derived type until runtime. This implies that the runtime must be able to
+/// determine the offset of fields within the entity.
 class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
                                               detail::FieldTypeStorage> {
 public:
@@ -204,6 +235,10 @@ class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_FIELD; }
 };
 
+/// The type of a heap pointer. Fortran entities with the ALLOCATABLE attribute
+/// may be allocated on the heap at runtime. These pointers are explicitly
+/// distinguished to disallow the composition of multiple levels of
+/// indirection. For example, an ALLOCATABLE POINTER is invalid.
 class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
                                              detail::HeapTypeStorage> {
 public:
@@ -217,6 +252,9 @@ class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
                                                           mlir::Type eleTy);
 };
 
+/// The type of a LEN parameter name. Implementations may defer the layout of a
+/// Fortran derived type until runtime. This implies that the runtime must be
+/// able to determine the offset of LEN type parameters related to an entity.
 class LenType
     : public mlir::Type::TypeBase<LenType, mlir::Type, detail::LenTypeStorage> {
 public:
@@ -225,6 +263,9 @@ class LenType
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_LEN; }
 };
 
+/// The type of entities with the POINTER attribute.  These pointers are
+/// explicitly distinguished to disallow the composition of multiple levels of
+/// indirection. For example, an ALLOCATABLE POINTER is invalid.
 class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
                                                 detail::PointerTypeStorage> {
 public:
@@ -238,6 +279,7 @@ class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
                                                           mlir::Type eleTy);
 };
 
+/// The type of a reference to an entity in memory.
 class ReferenceType
     : public mlir::Type::TypeBase<ReferenceType, mlir::Type,
                                   detail::ReferenceTypeStorage> {
@@ -294,6 +336,8 @@ bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
 llvm::hash_code hash_value(const SequenceType::Extent &);
 llvm::hash_code hash_value(const SequenceType::Shape &);
 
+/// The type of a type descriptor object. The runtime may generate type
+/// descriptor objects to determine the type of an entity at runtime, etc.
 class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
                                                  detail::TypeDescTypeStorage> {
 public:
@@ -310,6 +354,9 @@ class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
 
 // Derived types
 
+/// Model of Fortran's derived type, TYPE. The name of the TYPE includes any
+/// KIND type parameters. The record includes runtime slots for LEN type
+/// parameters and for data components.
 class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
                                                detail::RecordTypeStorage> {
 public:
diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
index c0f77ede7f5e..63010c4398ac 100644
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -10,7 +10,7 @@
 #define OPTIMIZER_SUPPORT_KINDMAPPING_H
 
 #include "llvm/IR/Type.h"
-#include <map>
+#include <unordered_map>
 
 namespace llvm {
 template <typename>
@@ -80,8 +80,8 @@ class KindMapping {
   MatchResult parse(llvm::StringRef kindMap);
 
   mlir::MLIRContext *context;
-  std::map<char, std::map<KindTy, Bitsize>> intMap;
-  std::map<char, std::map<KindTy, LLVMTypeID>> floatMap;
+  std::unordered_map<char, std::unordered_map<KindTy, Bitsize>> intMap;
+  std::unordered_map<char, std::unordered_map<KindTy, LLVMTypeID>> floatMap;
 };
 
 } // namespace fir
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
index 957486ab0c1b..6d247bbe5bc9 100644
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -21,16 +21,13 @@ using KindTy = fir::KindMapping::KindTy;
 using LLVMTypeID = fir::KindMapping::LLVMTypeID;
 using MatchResult = fir::KindMapping::MatchResult;
 
-static llvm::cl::opt<std::string> ClKindMapping(
+static llvm::cl::opt<std::string> clKindMapping(
     "kind-mapping", llvm::cl::desc("kind mapping string to set kind precision"),
     llvm::cl::value_desc("kind-mapping-string"), llvm::cl::init(""));
 
-namespace fir {
-namespace {
-
 /// Integral types default to the kind value being the size of the value in
 /// bytes. The default is to scale from bytes to bits.
-Bitsize defaultScalingKind(KindTy kind) {
+static Bitsize defaultScalingKind(KindTy kind) {
   const unsigned BITS_IN_BYTE = 8;
   return kind * BITS_IN_BYTE;
 }
@@ -38,7 +35,7 @@ Bitsize defaultScalingKind(KindTy kind) {
 /// Floating-point types default to the kind value being the size of the value
 /// in bytes. The default is to translate kinds of 2, 4, 8, 10, and 16 to a
 /// valid llvm::Type::TypeID value. Otherwise, the default is FloatTyID.
-LLVMTypeID defaultRealKind(KindTy kind) {
+static LLVMTypeID defaultRealKind(KindTy kind) {
   switch (kind) {
   case 2:
     return LLVMTypeID::HalfTyID;
@@ -57,8 +54,9 @@ LLVMTypeID defaultRealKind(KindTy kind) {
 
 // lookup the kind-value given the defaults, the mappings, and a KIND key
 template <typename RT, char KEY>
-RT doLookup(std::function<RT(KindTy)> def,
-            const std::map<char, std::map<KindTy, RT>> &map, KindTy kind) {
+static RT doLookup(std::function<RT(KindTy)> def,
+            const std::unordered_map<char, std::unordered_map<KindTy, RT>> &map,
+            KindTy kind) {
   auto iter = map.find(KEY);
   if (iter != map.end()) {
     auto iter2 = iter->second.find(kind);
@@ -70,18 +68,18 @@ RT doLookup(std::function<RT(KindTy)> def,
 
 // do a lookup for INTERGER, LOGICAL, or CHARACTER
 template <char KEY, typename MAP>
-Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
+static Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
   return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
 }
 
 // do a lookup for REAL or COMPLEX
 template <char KEY, typename MAP>
-LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
+static LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
   return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
 }
 
 template <char KEY, typename MAP>
-const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind, const MAP &map) {
+static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind, const MAP &map) {
   switch (doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind)) {
   case LLVMTypeID::HalfTyID:
     return llvm::APFloat::IEEEhalf();
@@ -100,7 +98,7 @@ const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind, const MAP &map) {
   }
 }
 
-MatchResult parseCode(char &code, const char *&ptr) {
+static MatchResult parseCode(char &code, const char *&ptr) {
   if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
     return {};
   code = *ptr++;
@@ -108,18 +106,18 @@ MatchResult parseCode(char &code, const char *&ptr) {
 }
 
 template <char ch>
-MatchResult parseSingleChar(const char *&ptr) {
+static MatchResult parseSingleChar(const char *&ptr) {
   if (*ptr != ch)
     return {};
   ++ptr;
   return {true};
 }
 
-MatchResult parseColon(const char *&ptr) { return parseSingleChar<':'>(ptr); }
+static MatchResult parseColon(const char *&ptr) { return parseSingleChar<':'>(ptr); }
 
-MatchResult parseComma(const char *&ptr) { return parseSingleChar<','>(ptr); }
+static MatchResult parseComma(const char *&ptr) { return parseSingleChar<','>(ptr); }
 
-MatchResult parseInt(unsigned &result, const char *&ptr) {
+static MatchResult parseInt(unsigned &result, const char *&ptr) {
   const char *beg = ptr;
   while (*ptr >= '0' && *ptr <= '9')
     ptr++;
@@ -133,7 +131,7 @@ MatchResult parseInt(unsigned &result, const char *&ptr) {
   return {true};
 }
 
-bool matchString(const char *&ptr, llvm::StringRef literal) {
+static bool matchString(const char *&ptr, llvm::StringRef literal) {
   llvm::StringRef s(ptr);
   if (s.startswith(literal)) {
     ptr += literal.size();
@@ -142,7 +140,7 @@ bool matchString(const char *&ptr, llvm::StringRef literal) {
   return false;
 }
 
-MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
+static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
   if (matchString(ptr, "Half")) {
     result = LLVMTypeID::HalfTyID;
     return {true};
@@ -166,23 +164,21 @@ MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
   return {};
 }
 
-} // namespace
-
-KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map)
+fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map)
     : context{context} {
   parse(map);
 }
 
-KindMapping::KindMapping(mlir::MLIRContext *context)
-    : KindMapping{context, ClKindMapping} {}
+fir::KindMapping::KindMapping(mlir::MLIRContext *context)
+    : KindMapping{context, clKindMapping} {}
 
-MatchResult KindMapping::badMapString(const llvm::Twine &ptr) {
+MatchResult fir::KindMapping::badMapString(const llvm::Twine &ptr) {
   auto unknown = mlir::UnknownLoc::get(context);
   mlir::emitError(unknown, ptr);
   return {};
 }
 
-MatchResult KindMapping::parse(llvm::StringRef kindMap) {
+MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
   if (kindMap.empty())
     return {true};
   const char *srcPtr = kindMap.begin();
@@ -212,28 +208,26 @@ MatchResult KindMapping::parse(llvm::StringRef kindMap) {
   return {true};
 }
 
-Bitsize KindMapping::getCharacterBitsize(KindTy kind) {
+Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) {
   return getIntegerLikeBitsize<'a'>(kind, intMap);
 }
 
-Bitsize KindMapping::getIntegerBitsize(KindTy kind) {
+Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) {
   return getIntegerLikeBitsize<'i'>(kind, intMap);
 }
 
-Bitsize KindMapping::getLogicalBitsize(KindTy kind) {
+Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) {
   return getIntegerLikeBitsize<'l'>(kind, intMap);
 }
 
-LLVMTypeID KindMapping::getRealTypeID(KindTy kind) {
+LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) {
   return getFloatLikeTypeID<'r'>(kind, floatMap);
 }
 
-LLVMTypeID KindMapping::getComplexTypeID(KindTy kind) {
+LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) {
   return getFloatLikeTypeID<'c'>(kind, floatMap);
 }
 
-const llvm::fltSemantics &KindMapping::getFloatSemantics(KindTy kind) {
+const llvm::fltSemantics &fir::KindMapping::getFloatSemantics(KindTy kind) {
   return getFloatSemanticsOfKind<'r'>(kind, floatMap);
 }
-
-} // namespace fir

From 4a0189aaf4ade3a90451d9801c658e3ae88e1166 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Mon, 2 Mar 2020 15:07:19 -0800
Subject: [PATCH 210/345] [PR1035] rewrite KindMapping to use MLIR results
 infrastructure

---
 include/flang/Optimizer/Support/KindMapping.h |  3 +-
 lib/Optimizer/Support/KindMapping.cpp         | 72 +++++++++++--------
 2 files changed, 43 insertions(+), 32 deletions(-)

diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
index 63010c4398ac..fcd97d615eae 100644
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -9,6 +9,7 @@
 #ifndef OPTIMIZER_SUPPORT_KINDMAPPING_H
 #define OPTIMIZER_SUPPORT_KINDMAPPING_H
 
+#include "mlir/IR/OpDefinition.h"
 #include "llvm/IR/Type.h"
 #include <unordered_map>
 
@@ -50,7 +51,7 @@ class KindMapping {
   using KindTy = unsigned;
   using Bitsize = unsigned;
   using LLVMTypeID = llvm::Type::TypeID;
-  using MatchResult = llvm::Optional<bool>;
+  using MatchResult = mlir::ParseResult;
 
   explicit KindMapping(mlir::MLIRContext *context);
   explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map);
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
index 6d247bbe5bc9..9731b7d88b97 100644
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -54,9 +54,10 @@ static LLVMTypeID defaultRealKind(KindTy kind) {
 
 // lookup the kind-value given the defaults, the mappings, and a KIND key
 template <typename RT, char KEY>
-static RT doLookup(std::function<RT(KindTy)> def,
-            const std::unordered_map<char, std::unordered_map<KindTy, RT>> &map,
-            KindTy kind) {
+static RT
+doLookup(std::function<RT(KindTy)> def,
+         const std::unordered_map<char, std::unordered_map<KindTy, RT>> &map,
+         KindTy kind) {
   auto iter = map.find(KEY);
   if (iter != map.end()) {
     auto iter2 = iter->second.find(kind);
@@ -79,7 +80,8 @@ static LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
 }
 
 template <char KEY, typename MAP>
-static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind, const MAP &map) {
+static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind,
+                                                         const MAP &map) {
   switch (doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind)) {
   case LLVMTypeID::HalfTyID:
     return llvm::APFloat::IEEEhalf();
@@ -100,73 +102,81 @@ static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind, const MAP
 
 static MatchResult parseCode(char &code, const char *&ptr) {
   if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
-    return {};
+    return mlir::failure();
   code = *ptr++;
-  return {true};
+  return mlir::success();
 }
 
 template <char ch>
 static MatchResult parseSingleChar(const char *&ptr) {
   if (*ptr != ch)
-    return {};
+    return mlir::failure();
   ++ptr;
-  return {true};
+  return mlir::success();
 }
 
-static MatchResult parseColon(const char *&ptr) { return parseSingleChar<':'>(ptr); }
+static MatchResult parseColon(const char *&ptr) {
+  return parseSingleChar<':'>(ptr);
+}
 
-static MatchResult parseComma(const char *&ptr) { return parseSingleChar<','>(ptr); }
+static MatchResult parseComma(const char *&ptr) {
+  return parseSingleChar<','>(ptr);
+}
 
 static MatchResult parseInt(unsigned &result, const char *&ptr) {
   const char *beg = ptr;
   while (*ptr >= '0' && *ptr <= '9')
     ptr++;
   if (beg == ptr)
-    return {};
+    return mlir::failure();
   llvm::StringRef ref(beg, ptr - beg);
   int temp;
   if (ref.consumeInteger(10, temp))
-    return {};
+    return mlir::failure();
   result = temp;
-  return {true};
+  return mlir::success();
 }
 
-static bool matchString(const char *&ptr, llvm::StringRef literal) {
+static mlir::LogicalResult matchString(const char *&ptr,
+                                       llvm::StringRef literal) {
   llvm::StringRef s(ptr);
   if (s.startswith(literal)) {
     ptr += literal.size();
-    return true;
+    return mlir::success();
   }
-  return false;
+  return mlir::failure();
 }
 
 static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
-  if (matchString(ptr, "Half")) {
+  if (mlir::succeeded(matchString(ptr, "Half"))) {
     result = LLVMTypeID::HalfTyID;
-    return {true};
+    return mlir::success();
   }
-  if (matchString(ptr, "Float")) {
+  if (mlir::succeeded(matchString(ptr, "Float"))) {
     result = LLVMTypeID::FloatTyID;
-    return {true};
+    return mlir::success();
   }
-  if (matchString(ptr, "Double")) {
+  if (mlir::succeeded(matchString(ptr, "Double"))) {
     result = LLVMTypeID::DoubleTyID;
-    return {true};
+    return mlir::success();
   }
-  if (matchString(ptr, "X86_FP80")) {
+  if (mlir::succeeded(matchString(ptr, "X86_FP80"))) {
     result = LLVMTypeID::X86_FP80TyID;
-    return {true};
+    return mlir::success();
   }
-  if (matchString(ptr, "FP128")) {
+  if (mlir::succeeded(matchString(ptr, "FP128"))) {
     result = LLVMTypeID::FP128TyID;
-    return {true};
+    return mlir::success();
   }
-  return {};
+  return mlir::failure();
 }
 
 fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map)
     : context{context} {
-  parse(map);
+  if (mlir::failed(parse(map))) {
+    intMap.clear();
+    floatMap.clear();
+  }
 }
 
 fir::KindMapping::KindMapping(mlir::MLIRContext *context)
@@ -175,12 +185,12 @@ fir::KindMapping::KindMapping(mlir::MLIRContext *context)
 MatchResult fir::KindMapping::badMapString(const llvm::Twine &ptr) {
   auto unknown = mlir::UnknownLoc::get(context);
   mlir::emitError(unknown, ptr);
-  return {};
+  return mlir::failure();
 }
 
 MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
   if (kindMap.empty())
-    return {true};
+    return mlir::success();
   const char *srcPtr = kindMap.begin();
   while (true) {
     char code = '\0';
@@ -205,7 +215,7 @@ MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
   }
   if (*srcPtr)
     return badMapString(srcPtr);
-  return {true};
+  return mlir::success();
 }
 
 Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) {

From e3da5509b741077bcd8ca602888e80008482bf19 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 3 Mar 2020 08:13:55 -0800
Subject: [PATCH 211/345] [PR1035] Solve editorial comments

- a an typo
- missing llvm qualifier
---
 include/flang/Optimizer/Dialect/FIRAttr.h | 2 +-
 include/flang/Optimizer/Dialect/FIROps.h  | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIRAttr.h b/include/flang/Optimizer/Dialect/FIRAttr.h
index a65675aa7d40..57ce5f13bf65 100644
--- a/include/flang/Optimizer/Dialect/FIRAttr.h
+++ b/include/flang/Optimizer/Dialect/FIRAttr.h
@@ -119,7 +119,7 @@ class LowerBoundAttr : public mlir::Attribute::AttrBase<LowerBoundAttr> {
   }
 };
 
-/// A pointer interval is an closed interval as given as an ssa-value. The
+/// A pointer interval is a closed interval as given as an ssa-value. The
 /// interval contains exactly one value.
 /// A case selector of `CASE (p)` corresponds to exactly the value `p` and is
 /// encoded as `#fir.point, %p`.
diff --git a/include/flang/Optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
index 3f82809d0244..034a952eba31 100644
--- a/include/flang/Optimizer/Dialect/FIROps.h
+++ b/include/flang/Optimizer/Dialect/FIROps.h
@@ -55,7 +55,8 @@ void buildCmpFOp(mlir::Builder *builder, mlir::OperationState &result,
                  CmpFPredicate predicate, mlir::Value lhs, mlir::Value rhs);
 void buildCmpCOp(mlir::Builder *builder, mlir::OperationState &result,
                  CmpFPredicate predicate, mlir::Value lhs, mlir::Value rhs);
-unsigned getCaseArgumentOffset(ArrayRef<mlir::Attribute> cases, unsigned dest);
+unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
+                               unsigned dest);
 LoopOp getForInductionVarOwner(mlir::Value val);
 bool isReferenceLike(mlir::Type type);
 mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);

From e85efcdb6fbb8f3c04d93d6f8e200c00aa4934d7 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 3 Mar 2020 09:21:28 -0800
Subject: [PATCH 212/345] [PR1035] Solve isImpureCall... and std::unordered_map
 comments Finish moving to using DenseMap.

---
 .../flang/Optimizer/Dialect/FIROpsSupport.h   | 26 ++++++-------------
 include/flang/Optimizer/Support/KindMapping.h |  6 ++---
 lib/Optimizer/Support/KindMapping.cpp         | 21 +++++++--------
 3 files changed, 20 insertions(+), 33 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROpsSupport.h b/include/flang/Optimizer/Dialect/FIROpsSupport.h
index b8bb5480d157..13e4e5ab71b2 100644
--- a/include/flang/Optimizer/Dialect/FIROpsSupport.h
+++ b/include/flang/Optimizer/Dialect/FIROpsSupport.h
@@ -21,21 +21,19 @@ inline bool nonVolatileLoad(mlir::Operation *op) {
   return false;
 }
 
+/// return true iff the Operation is a call
+inline bool isaCall(mlir::Operation *op) {
+  return isa<fir::CallOp>(op) || isa<fir::DispatchOp>(op) ||
+         isa<mlir::CallOp>(op) || isa<mlir::CallIndirectOp>(op);
+}
+
 /// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
 /// mlir::CallOp, or mlir::CallIndirectOp and not pure
 /// NB: this is not the same as `!pureCall(op)`
 inline bool impureCall(mlir::Operation *op) {
   // Should we also auto-detect that the called function is pure if its
   // arguments are not references?  For now, rely on a "pure" attribute.
-  if (auto call = dyn_cast<fir::CallOp>(op))
-    return !call.getAttr("pure");
-  if (auto dispatch = dyn_cast<fir::DispatchOp>(op))
-    return !dispatch.getAttr("pure");
-  if (auto call = dyn_cast<mlir::CallOp>(op))
-    return !call.getAttr("pure");
-  if (auto icall = dyn_cast<mlir::CallIndirectOp>(op))
-    return !icall.getAttr("pure");
-  return false;
+  return op && isaCall(op) && !op->getAttr("pure");
 }
 
 /// return true iff the Operation is a fir::CallOp, fir::DispatchOp,
@@ -44,15 +42,7 @@ inline bool impureCall(mlir::Operation *op) {
 inline bool pureCall(mlir::Operation *op) {
   // Should we also auto-detect that the called function is pure if its
   // arguments are not references?  For now, rely on a "pure" attribute.
-  if (auto call = dyn_cast<fir::CallOp>(op))
-    return bool(call.getAttr("pure"));
-  if (auto dispatch = dyn_cast<fir::DispatchOp>(op))
-    return bool(dispatch.getAttr("pure"));
-  if (auto call = dyn_cast<mlir::CallOp>(op))
-    return bool(call.getAttr("pure"));
-  if (auto icall = dyn_cast<mlir::CallIndirectOp>(op))
-    return bool(icall.getAttr("pure"));
-  return false;
+  return op && isaCall(op) && op->getAttr("pure");
 }
 
 /// Get or create a FuncOp in a module.
diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
index fcd97d615eae..dc89e1c2d267 100644
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -10,8 +10,8 @@
 #define OPTIMIZER_SUPPORT_KINDMAPPING_H
 
 #include "mlir/IR/OpDefinition.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/Type.h"
-#include <unordered_map>
 
 namespace llvm {
 template <typename>
@@ -81,8 +81,8 @@ class KindMapping {
   MatchResult parse(llvm::StringRef kindMap);
 
   mlir::MLIRContext *context;
-  std::unordered_map<char, std::unordered_map<KindTy, Bitsize>> intMap;
-  std::unordered_map<char, std::unordered_map<KindTy, LLVMTypeID>> floatMap;
+  llvm::DenseMap<std::pair<char, KindTy>, Bitsize> intMap;
+  llvm::DenseMap<std::pair<char, KindTy>, LLVMTypeID> floatMap;
 };
 
 } // namespace fir
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
index 9731b7d88b97..fdab91edb984 100644
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -54,16 +54,13 @@ static LLVMTypeID defaultRealKind(KindTy kind) {
 
 // lookup the kind-value given the defaults, the mappings, and a KIND key
 template <typename RT, char KEY>
-static RT
-doLookup(std::function<RT(KindTy)> def,
-         const std::unordered_map<char, std::unordered_map<KindTy, RT>> &map,
-         KindTy kind) {
-  auto iter = map.find(KEY);
-  if (iter != map.end()) {
-    auto iter2 = iter->second.find(kind);
-    if (iter2 != iter->second.end())
-      return iter2->second;
-  }
+static RT doLookup(std::function<RT(KindTy)> def,
+                   const llvm::DenseMap<std::pair<char, KindTy>, RT> &map,
+                   KindTy kind) {
+  std::pair<char, KindTy> key{KEY, kind};
+  auto iter = map.find(key);
+  if (iter != map.end())
+    return iter->second;
   return def(kind);
 }
 
@@ -201,12 +198,12 @@ MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
       Bitsize bits = 0;
       if (parseColon(srcPtr) || parseInt(bits, srcPtr))
         return badMapString(srcPtr);
-      intMap[code][kind] = bits;
+      intMap[std::pair<char, KindTy>{code, kind}] = bits;
     } else if (code == 'r' || code == 'c') {
       LLVMTypeID id{};
       if (parseColon(srcPtr) || parseTypeID(id, srcPtr))
         return badMapString(srcPtr);
-      floatMap[code][kind] = id;
+      floatMap[std::pair<char, KindTy>{code, kind}] = id;
     } else {
       return badMapString(srcPtr);
     }

From 7b471b9e33e62fe732f3727f200f049dcb608f86 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 3 Mar 2020 14:46:35 -0800
Subject: [PATCH 213/345] [PR1035] make the isa helpers all follow the same
 pattern. follows the precedent of llvm::isa_or_null<>

---
 include/flang/Optimizer/Dialect/FIRType.h | 6 ++++--
 lib/Optimizer/Dialect/FIRType.cpp         | 6 +++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 1b527a0f5b8a..1d4cc9e90f53 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -75,6 +75,8 @@ enum TypeKind {
   FIR_TYPEDESC,
 };
 
+// These isa_ routines follow the precedent of llvm::isa_or_null<>
+
 /// Is `t` any of the FIR dialect types?
 bool isa_fir_type(mlir::Type t);
 
@@ -85,10 +87,10 @@ bool isa_std_type(mlir::Type t);
 bool isa_fir_or_std_type(mlir::Type t);
 
 /// Is `t` a FIR dialect type that implies a memory (de)reference?
-bool isaMemref(mlir::Type t);
+bool isa_memref(mlir::Type t);
 
 /// Is `t` a FIR dialect aggregate type?
-bool isanAggregate(mlir::Type t);
+bool isa_aggregate(mlir::Type t);
 
 /// Extract the `Type` pointed to from a FIR memory reference type. If `t` is
 /// not a memory reference type, then returns a null `Type`.
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index edef4abb4ef5..e0c73cd4186c 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -298,7 +298,7 @@ RecordType parseDerived(mlir::DialectAsmParser &parser, mlir::Location) {
 // !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
 // is undefined and disallowed.
 inline bool singleIndirectionLevel(mlir::Type ty) {
-  return !fir::isaMemref(ty);
+  return !fir::isa_memref(ty);
 }
 
 } // namespace
@@ -837,11 +837,11 @@ bool isa_fir_or_std_type(mlir::Type t) {
   return isa_fir_type(t) || isa_std_type(t);
 }
 
-bool isaMemref(mlir::Type t) {
+bool isa_memref(mlir::Type t) {
   return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
 }
 
-bool isanAggregate(mlir::Type t) {
+bool isa_aggregate(mlir::Type t) {
   return t.isa<SequenceType>() || t.isa<RecordType>();
 }
 

From ea7a13caf49fe22917f991bc7e84bf187e31203f Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 3 Mar 2020 15:25:10 -0800
Subject: [PATCH 214/345] fix the out-of-tree undefined symbols link failures

---
 include/flang/Optimizer/Dialect/FIRDialect.h | 6 ++++++
 lib/Optimizer/Dialect/FIRAttr.cpp            | 2 +-
 tools/bbc/bbc.cpp                            | 2 --
 tools/tco/tco.cpp                            | 2 --
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
index a6761b0c0ed9..4818a7100b9c 100644
--- a/include/flang/Optimizer/Dialect/FIRDialect.h
+++ b/include/flang/Optimizer/Dialect/FIRDialect.h
@@ -10,6 +10,7 @@
 #define OPTIMIZER_DIALECT_FIRDIALECT_H
 
 #include "mlir/IR/Dialect.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/InitAllPasses.h"
 
 namespace llvm {
@@ -49,6 +50,11 @@ class FIROpsDialect final : public mlir::Dialect {
 inline void registerFIR() {
   // we want to register exactly once
   [[maybe_unused]] static bool init_once = [] {
+    mlir::registerDialect<mlir::AffineOpsDialect>();
+    mlir::registerDialect<mlir::LLVM::LLVMDialect>();
+    mlir::registerDialect<mlir::loop::LoopOpsDialect>();
+    mlir::registerDialect<mlir::StandardOpsDialect>();
+    mlir::registerDialect<mlir::vector::VectorOpsDialect>();
     mlir::registerDialect<FIROpsDialect>();
     return true;
   }();
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index e4ffe5e7569e..27c2c8cb2e04 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -128,7 +128,7 @@ namespace {
 mlir::Attribute parseFirRealAttr(FIROpsDialect *dialect,
                                  mlir::DialectAsmParser &parser,
                                  mlir::Type type) {
-  int kind;
+  int kind = 0;
   if (parser.parseLess() || parser.parseInteger(kind) || parser.parseComma()) {
     parser.emitError(parser.getNameLoc(), "expected '<' kind ','");
     return {};
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index dd0e47f42b96..e7e8b5eed5ad 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -35,7 +35,6 @@
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
-#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
@@ -188,7 +187,6 @@ void convertFortranSourceToMLIR(
 } // namespace
 
 int main(int argc, char **argv) {
-  mlir::registerAllDialects();
   fir::registerFIR();
   fir::registerFIRPasses();
   [[maybe_unused]] llvm::InitLLVM y(argc, argv);
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 46e1707fc290..20a44a23ee44 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -20,7 +20,6 @@
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
-#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
@@ -121,7 +120,6 @@ static int compileFIR() {
 }
 
 int main(int argc, char **argv) {
-  mlir::registerAllDialects();
   fir::registerFIR();
   fir::registerFIRPasses();
   [[maybe_unused]] InitLLVM y(argc, argv);

From 8f540abf7e69fc4b4f1a83635c1354443ed29fdb Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 4 Mar 2020 12:40:33 -0800
Subject: [PATCH 215/345] [PR1035] more reaction to review comments

---
 include/flang/Optimizer/Dialect/FIROps.h  | 41 +++---------------
 include/flang/Optimizer/Dialect/FIRType.h |  2 +-
 lib/Lower/ConvertExpr.cpp                 | 18 ++++----
 lib/Lower/Intrinsics.cpp                  | 14 +++---
 lib/Optimizer/CodeGen.cpp                 |  4 +-
 lib/Optimizer/Dialect/FIRAttr.cpp         |  3 +-
 lib/Optimizer/Dialect/FIRDialect.cpp      | 22 ----------
 lib/Optimizer/Dialect/FIROps.cpp          | 53 +++++++++++------------
 lib/Optimizer/Dialect/FIRType.cpp         | 16 +++----
 lib/Optimizer/Support/KindMapping.cpp     |  4 ++
 10 files changed, 62 insertions(+), 115 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
index 034a952eba31..991056ad2135 100644
--- a/include/flang/Optimizer/Dialect/FIROps.h
+++ b/include/flang/Optimizer/Dialect/FIROps.h
@@ -9,12 +9,7 @@
 #ifndef OPTIMIZER_DIALECT_FIROPS_H
 #define OPTIMIZER_DIALECT_FIROPS_H
 
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/OpDefinition.h"
-#include "mlir/IR/OpImplementation.h"
-#include "mlir/IR/SymbolTable.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 using namespace mlir;
 
@@ -23,38 +18,12 @@ namespace fir {
 class FirEndOp;
 class LoopOp;
 
-enum class CmpFPredicate {
-  FirstValidValue,
-  // Always false
-  AlwaysFalse = FirstValidValue,
-  // Ordered comparisons
-  OEQ,
-  OGT,
-  OGE,
-  OLT,
-  OLE,
-  ONE,
-  // Both ordered
-  ORD,
-  // Unordered comparisons
-  UEQ,
-  UGT,
-  UGE,
-  ULT,
-  ULE,
-  UNE,
-  // Any unordered
-  UNO,
-  // Always true
-  AlwaysTrue,
-  // Number of predicates.
-  NumPredicates
-};
-
 void buildCmpFOp(mlir::Builder *builder, mlir::OperationState &result,
-                 CmpFPredicate predicate, mlir::Value lhs, mlir::Value rhs);
+                 mlir::CmpFPredicate predicate, mlir::Value lhs,
+                 mlir::Value rhs);
 void buildCmpCOp(mlir::Builder *builder, mlir::OperationState &result,
-                 CmpFPredicate predicate, mlir::Value lhs, mlir::Value rhs);
+                 mlir::CmpFPredicate predicate, mlir::Value lhs,
+                 mlir::Value rhs);
 unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
                                unsigned dest);
 LoopOp getForInductionVarOwner(mlir::Value val);
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 1d4cc9e90f53..9c494df787f9 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -87,7 +87,7 @@ bool isa_std_type(mlir::Type t);
 bool isa_fir_or_std_type(mlir::Type t);
 
 /// Is `t` a FIR dialect type that implies a memory (de)reference?
-bool isa_memref(mlir::Type t);
+bool isa_ref_type(mlir::Type t);
 
 /// Is `t` a FIR dialect aggregate type?
 bool isa_aggregate(mlir::Type t);
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index d42d5fae8ddf..6cb6ccf20df3 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -84,21 +84,21 @@ class ExprLowering {
   /// FIXME: The signaling/quiet aspect of the table 17.1 requirement is not
   /// fully enforced. FIR and LLVM `fcmp` instructions do not give any guarantee
   /// whether the comparison will signal or not in case of quiet NaN argument.
-  static fir::CmpFPredicate
+  static mlir::CmpFPredicate
   translateFloatRelational(Fortran::common::RelationalOperator rop) {
     switch (rop) {
     case Fortran::common::RelationalOperator::LT:
-      return fir::CmpFPredicate::OLT;
+      return mlir::CmpFPredicate::OLT;
     case Fortran::common::RelationalOperator::LE:
-      return fir::CmpFPredicate::OLE;
+      return mlir::CmpFPredicate::OLE;
     case Fortran::common::RelationalOperator::EQ:
-      return fir::CmpFPredicate::OEQ;
+      return mlir::CmpFPredicate::OEQ;
     case Fortran::common::RelationalOperator::NE:
-      return fir::CmpFPredicate::UNE;
+      return mlir::CmpFPredicate::UNE;
     case Fortran::common::RelationalOperator::GT:
-      return fir::CmpFPredicate::OGT;
+      return mlir::CmpFPredicate::OGT;
     case Fortran::common::RelationalOperator::GE:
-      return fir::CmpFPredicate::OGE;
+      return mlir::CmpFPredicate::OGE;
     }
     assert(false && "unhandled REAL relational operator");
     return {};
@@ -193,14 +193,14 @@ class ExprLowering {
                                  genval(ex.right()));
   }
   template <typename OpTy, typename A>
-  mlir::Value createFltCmpOp(const A &ex, fir::CmpFPredicate pred,
+  mlir::Value createFltCmpOp(const A &ex, mlir::CmpFPredicate pred,
                              mlir::Value lhs, mlir::Value rhs) {
     assert(lhs && rhs && "argument did not lower");
     auto x = builder.create<OpTy>(getLoc(), pred, lhs, rhs);
     return x.getResult();
   }
   template <typename OpTy, typename A>
-  mlir::Value createFltCmpOp(const A &ex, fir::CmpFPredicate pred) {
+  mlir::Value createFltCmpOp(const A &ex, mlir::CmpFPredicate pred) {
     return createFltCmpOp<OpTy>(ex, pred, genval(ex.left()),
                                 genval(ex.right()));
   }
diff --git a/lib/Lower/Intrinsics.cpp b/lib/Lower/Intrinsics.cpp
index a4bc2a89d466..f3ff2ceaf81c 100644
--- a/lib/Lower/Intrinsics.cpp
+++ b/lib/Lower/Intrinsics.cpp
@@ -670,8 +670,8 @@ static mlir::Value createExtremumCompare(mlir::Location loc,
                                              ? mlir::CmpIPredicate::sgt
                                              : mlir::CmpIPredicate::slt};
   static constexpr auto orderedCmp{extremum == Extremum::Max
-                                       ? fir::CmpFPredicate::OGT
-                                       : fir::CmpFPredicate::OLT};
+                                       ? mlir::CmpFPredicate::OGT
+                                       : mlir::CmpFPredicate::OLT};
   auto type = left.getType();
   mlir::Value result;
   if (type.isa<mlir::FloatType>() || type.isa<fir::RealType>()) {
@@ -683,14 +683,14 @@ static mlir::Value createExtremumCompare(mlir::Location loc,
       auto leftIsResult =
           builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
       auto rightIsNan = builder.create<fir::CmpfOp>(
-          loc, fir::CmpFPredicate::UNE, right, right);
+          loc, mlir::CmpFPredicate::UNE, right, right);
       result = builder.create<mlir::OrOp>(loc, leftIsResult, rightIsNan);
     } else if constexpr (behavior == ExtremumBehavior::IeeeMinMaximum) {
       // Always return NaNs if one the input is NaNs
       auto leftIsResult =
           builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
-      auto leftIsNan =
-          builder.create<fir::CmpfOp>(loc, fir::CmpFPredicate::UNE, left, left);
+      auto leftIsNan = builder.create<fir::CmpfOp>(
+          loc, mlir::CmpFPredicate::UNE, left, left);
       result = builder.create<mlir::OrOp>(loc, leftIsResult, leftIsNan);
     } else if constexpr (behavior == ExtremumBehavior::MinMaxss) {
       // If the left is a NaN, return the right whatever it is.
@@ -698,8 +698,8 @@ static mlir::Value createExtremumCompare(mlir::Location loc,
     } else if constexpr (behavior == ExtremumBehavior::PgfortranLlvm) {
       // If one of the operand is a NaN, return left whatever it is.
       static constexpr auto unorderedCmp{extremum == Extremum::Max
-                                             ? fir::CmpFPredicate::UGT
-                                             : fir::CmpFPredicate::ULT};
+                                             ? mlir::CmpFPredicate::UGT
+                                             : mlir::CmpFPredicate::ULT};
       result = builder.create<fir::CmpfOp>(loc, unorderedCmp, left, right);
     } else {
       // TODO: ieeMinNum/ieeeMaxNum
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index cb7936096bb5..9ee3cc391121 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -835,10 +835,10 @@ struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
     auto icp = rewriter.create<mlir::LLVM::FCmpOp>(loc, ty, ip, cmp.getAttrs());
     SmallVector<mlir::Value, 2> cp{rcp, icp};
     switch (cmp.getPredicate()) {
-    case fir::CmpFPredicate::OEQ: // .EQ.
+    case mlir::CmpFPredicate::OEQ: // .EQ.
       rewriter.replaceOpWithNewOp<mlir::LLVM::AndOp>(cmp, ty, cp);
       break;
-    case fir::CmpFPredicate::UNE: // .NE.
+    case mlir::CmpFPredicate::UNE: // .NE.
       rewriter.replaceOpWithNewOp<mlir::LLVM::OrOp>(cmp, ty, cp);
       break;
     default:
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index 27c2c8cb2e04..1ba242b9484b 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -33,8 +33,7 @@ struct RealAttributeStorage : public mlir::AttributeStorage {
       : RealAttributeStorage(key.first, key.second) {}
 
   static unsigned hashKey(const KeyTy &key) {
-    auto hashVal = llvm::hash_combine(key.first);
-    return llvm::hash_combine(hashVal, key.second);
+    return llvm::hash_value(key);
   }
 
   bool operator==(const KeyTy &key) const {
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
index e6b04072bd0b..ae4811f9f3c6 100644
--- a/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -16,28 +16,6 @@
 
 using namespace fir;
 
-namespace {
-
-template <typename A>
-void selectBuild(mlir::OpBuilder *builder, mlir::OperationState *result,
-                 mlir::Value condition,
-                 llvm::ArrayRef<typename A::BranchTuple> tuples) {
-  result->addOperands(condition);
-  for (auto &tup : tuples) {
-    auto *cond{std::get<typename A::Conditions>(tup)};
-    result->addOperands(cond);
-  }
-  // Note: succs must be added *after* operands
-  for (auto &tup : tuples) {
-    auto *block{std::get<mlir::Block *>(tup)};
-    assert(block);
-    auto blkArgs{std::get<llvm::ArrayRef<mlir::Value>>(tup)};
-    result->addSuccessor(block, blkArgs);
-  }
-}
-
-} // namespace
-
 fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
     : mlir::Dialect("fir", ctx) {
   addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index fc0e87c86981..2e8ca94e65a3 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -168,29 +168,30 @@ static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
 
 // CmpfOp
 
-fir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
-  return llvm::StringSwitch<fir::CmpFPredicate>(name)
-      .Case("false", fir::CmpFPredicate::AlwaysFalse)
-      .Case("oeq", fir::CmpFPredicate::OEQ)
-      .Case("ogt", fir::CmpFPredicate::OGT)
-      .Case("oge", fir::CmpFPredicate::OGE)
-      .Case("olt", fir::CmpFPredicate::OLT)
-      .Case("ole", fir::CmpFPredicate::OLE)
-      .Case("one", fir::CmpFPredicate::ONE)
-      .Case("ord", fir::CmpFPredicate::ORD)
-      .Case("ueq", fir::CmpFPredicate::UEQ)
-      .Case("ugt", fir::CmpFPredicate::UGT)
-      .Case("uge", fir::CmpFPredicate::UGE)
-      .Case("ult", fir::CmpFPredicate::ULT)
-      .Case("ule", fir::CmpFPredicate::ULE)
-      .Case("une", fir::CmpFPredicate::UNE)
-      .Case("uno", fir::CmpFPredicate::UNO)
-      .Case("true", fir::CmpFPredicate::AlwaysTrue)
-      .Default(fir::CmpFPredicate::NumPredicates);
+// Note: getCmpFPredicateNames() is inline static in StandardOps/IR/Ops.cpp
+mlir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
+  return llvm::StringSwitch<CmpFPredicate>(name)
+      .Case("false", mlir::CmpFPredicate::AlwaysFalse)
+      .Case("oeq", mlir::CmpFPredicate::OEQ)
+      .Case("ogt", mlir::CmpFPredicate::OGT)
+      .Case("oge", mlir::CmpFPredicate::OGE)
+      .Case("olt", mlir::CmpFPredicate::OLT)
+      .Case("ole", mlir::CmpFPredicate::OLE)
+      .Case("one", mlir::CmpFPredicate::ONE)
+      .Case("ord", mlir::CmpFPredicate::ORD)
+      .Case("ueq", mlir::CmpFPredicate::UEQ)
+      .Case("ugt", mlir::CmpFPredicate::UGT)
+      .Case("uge", mlir::CmpFPredicate::UGE)
+      .Case("ult", mlir::CmpFPredicate::ULT)
+      .Case("ule", mlir::CmpFPredicate::ULE)
+      .Case("une", mlir::CmpFPredicate::UNE)
+      .Case("uno", mlir::CmpFPredicate::UNO)
+      .Case("true", mlir::CmpFPredicate::AlwaysTrue)
+      .Default(mlir::CmpFPredicate::NumPredicates);
 }
 
 void fir::buildCmpFOp(Builder *builder, OperationState &result,
-                      fir::CmpFPredicate predicate, Value lhs, Value rhs) {
+                      CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder->getI1Type());
   result.addAttribute(
@@ -219,15 +220,14 @@ static void printCmpOp(OpAsmPrinter &p, OPTY op) {
       /*AlwaysTrue*/ "true",
   };
   static_assert(std::extent<decltype(predicateNames)>::value ==
-                    (size_t)fir::CmpFPredicate::NumPredicates,
+                    (size_t)CmpFPredicate::NumPredicates,
                 "wrong number of predicate names");
   p << op.getOperationName() << ' ';
   auto predicateValue =
       op.template getAttrOfType<mlir::IntegerAttr>(OPTY::getPredicateAttrName())
           .getInt();
-  assert(predicateValue >=
-             static_cast<int>(fir::CmpFPredicate::FirstValidValue) &&
-         predicateValue < static_cast<int>(fir::CmpFPredicate::NumPredicates) &&
+  assert(predicateValue >= static_cast<int>(CmpFPredicate::FirstValidValue) &&
+         predicateValue < static_cast<int>(CmpFPredicate::NumPredicates) &&
          "unknown predicate index");
   Builder b(op.getContext());
   auto predicateStringAttr = b.getStringAttr(predicateNames[predicateValue]);
@@ -265,7 +265,7 @@ static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
   llvm::StringRef predicateName =
       predicateNameAttr.cast<mlir::StringAttr>().getValue();
   auto predicate = fir::CmpfOp::getPredicateByName(predicateName);
-  if (predicate == fir::CmpFPredicate::NumPredicates)
+  if (predicate == CmpFPredicate::NumPredicates)
     return parser.emitError(parser.getNameLoc(),
                             "unknown comparison predicate \"" + predicateName +
                                 "\"");
@@ -286,7 +286,7 @@ mlir::ParseResult fir::parseCmpfOp(mlir::OpAsmParser &parser,
 // CmpcOp
 
 void fir::buildCmpCOp(Builder *builder, OperationState &result,
-                      fir::CmpFPredicate predicate, Value lhs, Value rhs) {
+                      CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder->getI1Type());
   result.addAttribute(
@@ -458,7 +458,6 @@ void fir::WhereOp::build(mlir::Builder *builder, OperationState &result,
 
 static mlir::ParseResult parseWhereOp(OpAsmParser &parser,
                                       OperationState &result) {
-  // Create the regions for 'then'.
   result.regions.reserve(2);
   mlir::Region *thenRegion = result.addRegion();
   mlir::Region *elseRegion = result.addRegion();
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index e0c73cd4186c..7762c974d71f 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -8,6 +8,7 @@
 
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
@@ -298,7 +299,7 @@ RecordType parseDerived(mlir::DialectAsmParser &parser, mlir::Location) {
 // !fir.ptr<X> and !fir.heap<X> where X is !fir.ptr, !fir.heap, or !fir.ref
 // is undefined and disallowed.
 inline bool singleIndirectionLevel(mlir::Type ty) {
-  return !fir::isa_memref(ty);
+  return !fir::isa_ref_type(ty);
 }
 
 } // namespace
@@ -837,7 +838,7 @@ bool isa_fir_or_std_type(mlir::Type t) {
   return isa_fir_type(t) || isa_std_type(t);
 }
 
-bool isa_memref(mlir::Type t) {
+bool isa_ref_type(mlir::Type t) {
   return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
 }
 
@@ -846,13 +847,10 @@ bool isa_aggregate(mlir::Type t) {
 }
 
 mlir::Type dyn_cast_ptrEleTy(mlir::Type t) {
-  if (auto p = t.dyn_cast<fir::ReferenceType>())
-    return p.getEleTy();
-  if (auto p = t.dyn_cast<fir::PointerType>())
-    return p.getEleTy();
-  if (auto p = t.dyn_cast<fir::HeapType>())
-    return p.getEleTy();
-  return {};
+  return mlir::TypeSwitch<mlir::Type, mlir::Type>(t)
+      .Case<fir::ReferenceType, fir::PointerType, fir::HeapType>(
+          [](auto p) { return p.getEleTy(); })
+      .Default([](mlir::Type) { return mlir::Type{}; });
 }
 
 } // namespace fir
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
index fdab91edb984..8731c0bb087e 100644
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -165,6 +165,10 @@ static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
     result = LLVMTypeID::FP128TyID;
     return mlir::success();
   }
+  if (mlir::succeeded(matchString(ptr, "PPC_FP128"))) {
+    result = LLVMTypeID::PPC_FP128TyID;
+    return mlir::success();
+  }
   return mlir::failure();
 }
 

From c5e8c4514addb648c485c514203c22d69b0f423d Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 4 Mar 2020 14:41:34 -0800
Subject: [PATCH 216/345] rebasing changes as CmpFPredicate moved

---
 lib/Optimizer/Dialect/FIROps.cpp | 60 ++++----------------------------
 1 file changed, 7 insertions(+), 53 deletions(-)

diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 2e8ca94e65a3..004282623de9 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -170,24 +170,9 @@ static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
 
 // Note: getCmpFPredicateNames() is inline static in StandardOps/IR/Ops.cpp
 mlir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
-  return llvm::StringSwitch<CmpFPredicate>(name)
-      .Case("false", mlir::CmpFPredicate::AlwaysFalse)
-      .Case("oeq", mlir::CmpFPredicate::OEQ)
-      .Case("ogt", mlir::CmpFPredicate::OGT)
-      .Case("oge", mlir::CmpFPredicate::OGE)
-      .Case("olt", mlir::CmpFPredicate::OLT)
-      .Case("ole", mlir::CmpFPredicate::OLE)
-      .Case("one", mlir::CmpFPredicate::ONE)
-      .Case("ord", mlir::CmpFPredicate::ORD)
-      .Case("ueq", mlir::CmpFPredicate::UEQ)
-      .Case("ugt", mlir::CmpFPredicate::UGT)
-      .Case("uge", mlir::CmpFPredicate::UGE)
-      .Case("ult", mlir::CmpFPredicate::ULT)
-      .Case("ule", mlir::CmpFPredicate::ULE)
-      .Case("une", mlir::CmpFPredicate::UNE)
-      .Case("uno", mlir::CmpFPredicate::UNO)
-      .Case("true", mlir::CmpFPredicate::AlwaysTrue)
-      .Default(mlir::CmpFPredicate::NumPredicates);
+  auto pred = mlir::symbolizeCmpFPredicate(name);
+  assert(pred.hasValue() && "invalid predicate name");
+  return pred.getValue();
 }
 
 void fir::buildCmpFOp(Builder *builder, OperationState &result,
@@ -201,38 +186,12 @@ void fir::buildCmpFOp(Builder *builder, OperationState &result,
 
 template <typename OPTY>
 static void printCmpOp(OpAsmPrinter &p, OPTY op) {
-  static const char *predicateNames[] = {
-      /*AlwaysFalse*/ "false",
-      /*OEQ*/ "oeq",
-      /*OGT*/ "ogt",
-      /*OGE*/ "oge",
-      /*OLT*/ "olt",
-      /*OLE*/ "ole",
-      /*ONE*/ "one",
-      /*ORD*/ "ord",
-      /*UEQ*/ "ueq",
-      /*UGT*/ "ugt",
-      /*UGE*/ "uge",
-      /*ULT*/ "ult",
-      /*ULE*/ "ule",
-      /*UNE*/ "une",
-      /*UNO*/ "uno",
-      /*AlwaysTrue*/ "true",
-  };
-  static_assert(std::extent<decltype(predicateNames)>::value ==
-                    (size_t)CmpFPredicate::NumPredicates,
-                "wrong number of predicate names");
   p << op.getOperationName() << ' ';
-  auto predicateValue =
+  auto predSym = mlir::symbolizeCmpFPredicate(
       op.template getAttrOfType<mlir::IntegerAttr>(OPTY::getPredicateAttrName())
-          .getInt();
-  assert(predicateValue >= static_cast<int>(CmpFPredicate::FirstValidValue) &&
-         predicateValue < static_cast<int>(CmpFPredicate::NumPredicates) &&
-         "unknown predicate index");
-  Builder b(op.getContext());
-  auto predicateStringAttr = b.getStringAttr(predicateNames[predicateValue]);
-  p.printAttribute(predicateStringAttr);
-  p << ", ";
+          .getInt());
+  assert(predSym.hasValue() && "invalid symbol value for predicate");
+  p << mlir::stringifyCmpFPredicate(predSym.getValue()) << ", ";
   p.printOperand(op.lhs());
   p << ", ";
   p.printOperand(op.rhs());
@@ -265,11 +224,6 @@ static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
   llvm::StringRef predicateName =
       predicateNameAttr.cast<mlir::StringAttr>().getValue();
   auto predicate = fir::CmpfOp::getPredicateByName(predicateName);
-  if (predicate == CmpFPredicate::NumPredicates)
-    return parser.emitError(parser.getNameLoc(),
-                            "unknown comparison predicate \"" + predicateName +
-                                "\"");
-
   auto builder = parser.getBuilder();
   mlir::Type i1Type = builder.getI1Type();
   attrs[0].second = builder.getI64IntegerAttr(static_cast<int64_t>(predicate));

From e2d4f10551f7289a345842f04a04b9627d35148e Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 5 Mar 2020 08:05:46 -0800
Subject: [PATCH 217/345] Fix issue after rebase to use
 mlir::stringifyCmpFPredicate

---
 lib/Optimizer/Dialect/FIROps.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 004282623de9..aa6cc3833ec2 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -191,7 +191,7 @@ static void printCmpOp(OpAsmPrinter &p, OPTY op) {
       op.template getAttrOfType<mlir::IntegerAttr>(OPTY::getPredicateAttrName())
           .getInt());
   assert(predSym.hasValue() && "invalid symbol value for predicate");
-  p << mlir::stringifyCmpFPredicate(predSym.getValue()) << ", ";
+  p << '"' << mlir::stringifyCmpFPredicate(predSym.getValue()) << '"' << ", ";
   p.printOperand(op.lhs());
   p << ", ";
   p.printOperand(op.rhs());

From aaf89492295ded2ad7368de35001f087eafdabb3 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 5 Mar 2020 09:05:11 -0800
Subject: [PATCH 218/345] [PR1035] share pointer and heap checks and remove
 redundant tests

---
 lib/Optimizer/Dialect/FIRType.cpp | 20 ++++-----
 test-lit/Fir/fir-ops.fir          | 75 +++++--------------------------
 test-lit/Fir/fir-types.fir        |  8 ++++
 3 files changed, 28 insertions(+), 75 deletions(-)

diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index 7762c974d71f..7aafd8e22643 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -1001,14 +1001,18 @@ mlir::Type fir::PointerType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
+static bool canBePointerOrHeapElementType(mlir::Type eleTy) {
+  return eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
+         eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
+         eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
+         eleTy.isa<HeapType>() || eleTy.isa<PointerType>() ||
+         eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>();
+}
+
 mlir::LogicalResult
 fir::PointerType::verifyConstructionInvariants(mlir::Location loc,
                                                mlir::Type eleTy) {
-  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
-      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
-      eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
-      eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
-      eleTy.isa<TypeDescType>())
+  if (canBePointerOrHeapElementType(eleTy))
     return mlir::emitError(loc, "cannot build a pointer to type: ")
            << eleTy << '\n';
   return mlir::success();
@@ -1031,11 +1035,7 @@ mlir::Type fir::HeapType::getEleTy() const {
 mlir::LogicalResult
 fir::HeapType::verifyConstructionInvariants(mlir::Location loc,
                                             mlir::Type eleTy) {
-  if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
-      eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
-      eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
-      eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
-      eleTy.isa<TypeDescType>())
+  if (canBePointerOrHeapElementType(eleTy))
     return mlir::emitError(loc, "cannot build a heap pointer to type: ")
            << eleTy << '\n';
   return mlir::success();
diff --git a/test-lit/Fir/fir-ops.fir b/test-lit/Fir/fir-ops.fir
index 833a752815b0..980314d7bced 100644
--- a/test-lit/Fir/fir-ops.fir
+++ b/test-lit/Fir/fir-ops.fir
@@ -2,69 +2,14 @@
 
 // RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
 
-// Fortran Intrinsic types
 // CHECK-LABEL: func @it1() -> !fir.int<4>
-// CHECK-LABEL: func @it2() -> !fir.real<8>
-// CHECK-LABEL: func @it3() -> !fir.complex<8>
-// CHECK-LABEL: func @it4() -> !fir.logical<1>
-// CHECK-LABEL: func @it5() -> !fir.char<1>
 func @it1() -> !fir.int<4>
-func @it2() -> !fir.real<8>
-func @it3() -> !fir.complex<8>
-func @it4() -> !fir.logical<1>
-func @it5() -> !fir.char<1>
-
-// Fortran Derived types (records)
-// CHECK-LABEL: func @dvd1() -> !fir.type<derived1>
-// CHECK-LABEL: func @dvd2() -> !fir.type<derived2(p:i32)>
-// CHECK-LABEL: func @dvd3() -> !fir.type<derived3{f:f32}>
-// CHECK-LABEL: func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
-func @dvd1() -> !fir.type<derived1>
-func @dvd2() -> !fir.type<derived2(p:i32)>
-func @dvd3() -> !fir.type<derived3{f:f32}>
-func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
-
-// FIR array types
-// CHECK-LABEL: func @arr1() -> !fir.array<10xf32>
-// CHECK-LABEL: func @arr2() -> !fir.array<10x10xf32>
-// CHECK-LABEL: func @arr3() -> !fir.array<?xf32>
-// CHECK-LABEL: func @arr4() -> !fir.array<10x?xf32>
-// CHECK-LABEL: func @arr5() -> !fir.array<?x?xf32>
-// CHECK-LABEL: func @arr6() -> !fir.array<*:f32>
-func @arr1() -> !fir.array<10xf32>
-func @arr2() -> !fir.array<10x10xf32>
-func @arr3() -> !fir.array<?xf32>
-func @arr4() -> !fir.array<10x?xf32>
-func @arr5() -> !fir.array<?x?xf32>
-func @arr6() -> !fir.array<*:f32>
-
-// FIR pointer-like types
-// CHECK-LABEL: func @mem1() -> !fir.ref<i32>
-// CHECK-LABEL: func @mem2() -> !fir.ptr<i32>
-// CHECK-LABEL: func @mem3() -> !fir.heap<i32>
-// CHECK-LABEL: func @mem4() -> !fir.ref<() -> ()>
-func @mem1() -> !fir.ref<i32>
-func @mem2() -> !fir.ptr<i32>
-func @mem3() -> !fir.heap<i32>
-func @mem4() -> !fir.ref<() -> ()>
-
-// FIR box types (descriptors)
-// CHECK-LABEL: func @box1() -> !fir.box<!fir.array<?xf32>>
-// CHECK-LABEL: func @box2() -> !fir.boxchar<2>
-// CHECK-LABEL: func @box3() -> !fir.boxproc<(i32, i32) -> i64>
-// CHECK-LABEL: func @box4() -> !fir.box<!fir.type<derived3{f:f32}>>
-func @box1() -> !fir.box<!fir.array<?xf32>>
-func @box2() -> !fir.boxchar<2>
-func @box3() -> !fir.boxproc<(i32, i32) -> i64>
-func @box4() -> !fir.box<!fir.type<derived3{f:f32}>>
-
-// FIR misc. types
-// CHECK-LABEL: func @oth1() -> !fir.dims<1>
-// CHECK-LABEL: func @oth2() -> !fir.field
-// CHECK-LABEL: func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
-func @oth1() -> !fir.dims<1>
-func @oth2() -> !fir.field
-func @oth3() -> !fir.tdesc<!fir.type<derived5{f1:f32,f2:f32}>>
+// CHECK-LABEL: func @box1() -> !fir.boxchar<2>
+func @box1() -> !fir.boxchar<2>
+// CHECK-LABEL: func @box2() -> !fir.boxproc<(i32, i32) -> i64>
+func @box2() -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK-LABEL: func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
+func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
 
 // Fortran SUBROUTINE and FUNCTION
 // CHECK-LABEL: func @print_index3(index, index, index)
@@ -125,10 +70,10 @@ func @instructions() {
   %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64
   // CHECK: fir.box_tdesc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
   %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
-  %15 = fir.call @box2() : () -> !fir.boxchar<2>
+  %15 = fir.call @box1() : () -> !fir.boxchar<2>
   // CHECK: fir.boxchar_len %{{.*}} : (!fir.boxchar<2>) -> i32
   %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
-  %17 = fir.call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
+  %17 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
   // CHECK: fir.boxproc_host %{{.*}} : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
   %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
   %19 = constant 10 : i32
@@ -148,7 +93,7 @@ func @instructions() {
   %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
   // CHECK: fir.len_param_index f, !fir.type<derived3{f:f32}>
   %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>
-  %27 = fir.call @box4() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+  %27 = fir.call @box3() : () -> !fir.box<!fir.type<derived3{f:f32}>>
   // CHECK: fir.dispatch "method"(%{{.*}}) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
   %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
   // CHECK: fir.convert %{{.*}} : (i32) -> i64
@@ -195,7 +140,7 @@ func @boxing_match() {
   %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
   // CHECK: fir.emboxproc @method_impl, %{{.*}} : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
   // CHECK: fir.unboxproc %{{.*}} : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
-  %9 = call @box3() : () -> !fir.boxproc<(i32, i32) -> i64>
+  %9 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
   %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)
   %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>
   fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()
diff --git a/test-lit/Fir/fir-types.fir b/test-lit/Fir/fir-types.fir
index 75a39372c2fc..9f9b6e6bdb79 100644
--- a/test-lit/Fir/fir-types.fir
+++ b/test-lit/Fir/fir-types.fir
@@ -2,6 +2,7 @@
 
 // RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
 
+// Fortran Intrinsic types
 // CHECK-LABEL: func @it1() -> !fir.int<4>
 // CHECK-LABEL: func @it2() -> !fir.real<8>
 // CHECK-LABEL: func @it3() -> !fir.complex<8>
@@ -13,6 +14,7 @@ func @it3() -> !fir.complex<8>
 func @it4() -> !fir.logical<1>
 func @it5() -> !fir.char<1>
 
+// Fortran Derived types (records)
 // CHECK-LABEL: func @dvd1() -> !fir.type<derived1>
 // CHECK-LABEL: func @dvd2() -> !fir.type<derived2(p:i32)>
 // CHECK-LABEL: func @dvd3() -> !fir.type<derived3{f:f32}>
@@ -26,6 +28,7 @@ func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
 func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
 func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
 
+// FIR array types
 // CHECK-LABEL: func @arr1() -> !fir.array<10xf32>
 // CHECK-LABEL: func @arr2() -> !fir.array<10x10xf32>
 // CHECK-LABEL: func @arr3() -> !fir.array<?xf32>
@@ -41,6 +44,7 @@ func @arr5() -> !fir.array<?x?xf32>
 func @arr6() -> !fir.array<*:f32>
 func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
 
+// FIR pointer-like types
 // CHECK-LABEL: func @mem1() -> !fir.ref<i32>
 // CHECK-LABEL: func @mem2() -> !fir.ptr<i32>
 // CHECK-LABEL: func @mem3() -> !fir.heap<i32>
@@ -50,15 +54,19 @@ func @mem2() -> !fir.ptr<i32>
 func @mem3() -> !fir.heap<i32>
 func @mem4() -> !fir.ref<() -> ()>
 
+// FIR box types (descriptors)
 // CHECK-LABEL: func @box1() -> !fir.box<!fir.array<?xf32>>
 // CHECK-LABEL: func @box2() -> !fir.boxchar<2>
 // CHECK-LABEL: func @box3() -> !fir.boxproc<(i32, i32) -> i64>
 // CHECK-LABEL: func @box4() -> !fir.box<none>
+// CHECK-LABEL: func @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
 func @box1() -> !fir.box<!fir.array<?xf32>>
 func @box2() -> !fir.boxchar<2>
 func @box3() -> !fir.boxproc<(i32, i32) -> i64>
 func @box4() -> !fir.box<none>
+func @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
 
+// FIR misc. types
 // CHECK-LABEL: func @oth1() -> !fir.dims<1>
 // CHECK-LABEL: func @oth2() -> !fir.field
 // CHECK-LABEL: func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>

From f4cf0c9f4acd78e7f9ff65308931105819cb5953 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 5 Mar 2020 15:00:30 -0800
Subject: [PATCH 219/345] work on merging the cmake changes

Conflicts:
	lib/CMakeLists.txt
	test/CMakeLists.txt
	test/Semantics/CMakeLists.txt
	unittests/Evaluate/CMakeLists.txt
	unittests/Runtime/CMakeLists.txt
---
 CMakeLists.txt                    | 537 +++++++++++-------------------
 cmake/modules/AddFlang.cmake      |   8 +
 include/CMakeLists.txt            |   2 +-
 lib/Common/CMakeLists.txt         |   1 -
 lib/Decimal/CMakeLists.txt        |   1 -
 lib/Evaluate/CMakeLists.txt       |   1 -
 lib/Parser/CMakeLists.txt         |   1 -
 unittests/Decimal/CMakeLists.txt  |   6 +-
 unittests/Evaluate/CMakeLists.txt |  95 ++----
 9 files changed, 240 insertions(+), 412 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index db20d7f5ab34..2fb1a1c7cb66 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,258 +1,123 @@
-#===-- CMakeLists.txt ------------------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
+cmake_minimum_required(VERSION 3.9.0) 
 
-cmake_minimum_required(VERSION 3.9.0)
-
-if (POLICY CMP0068)
+# RPATH settings on macOS do not affect INSTALL_NAME.
+if (POLICY CMP0068) 
   cmake_policy(SET CMP0068 NEW)
   set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
 endif()
 
-if(POLICY CMP0075)
+# Include file check macros honor CMAKE_REQUIRED_LIBRARIES.
+if(POLICY CMP0075)   
   cmake_policy(SET CMP0075 NEW)
 endif()
 
-if (POLICY CMP0077)
+# option() honors normal variables.
+if (POLICY CMP0077) 
   cmake_policy(SET CMP0077 NEW)
 endif()
 
-# If we are not building as part of LLVM (e.g., within the mono-repo),
-# build Flang as a standalone project.  This assumes the use of an
-# existing LLVM install w/ external libraries.
-if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
-  project(Flang)
+# Flang requires C++17. 
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 
-  # Rely on llvm-config.
-  set(CONFIG_OUTPUT)
-  if(LLVM_CONFIG)
-    set (LLVM_CONFIG_FOUND 1)
-    message(STATUS "Found LLVM_CONFIG as ${LLVM_CONFIG}")
-    message(DEPRECATION "Using llvm-config is deprecated.  Use the \
-                         LLVM installed CMake files instead. \
- 		         This should allow CMake to automatically find \
-			 find your install.  You can also use LLVM_DIR \
-			 to specify the path to LLVMConfig.cmake.")
-    set(CONFIG_COMMAND ${LLVM_CONFIG}
-      "--assertion-mode"
-      "--bindir"
-      "--libdir"
-      "--includedir"
-      "--prefix"
-      "--src-root"
-      "--cmakedir")
-    execute_process(
-      COMMAND ${CONFIG_COMMAND}
-      RESULT_VARIABLE HAD_ERROR
-      OUTPUT_VARIABLE CONFIG_OUTPUT
-    )
-    if(NOT HAD_ERROR)
-      string(REGEX REPLACE
-        "[ \t]*[\r\n]+[ \t]*" ";"
-        CONFIG_OUTPUT ${CONFIG_OUTPUT})
-    else()
-      string(REPLACE ";" " " CONFIG_COMMAND_STR "${CONFIG_COMMAND}")
-      message(STATUS "${CONFIG_COMMAND_STR}")
-      message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")
-    endif()
+set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
-    list(GET CONFIG_OUTPUT 0 ENABLE_ASSERTIONS)
-    list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR)
-    list(GET CONFIG_OUTPUT 2 LIBRARY_DIR)
-    list(GET CONFIG_OUTPUT 3 INCLUDE_DIR)
-    list(GET CONFIG_OUTPUT 4 LLVM_OBJ_ROOT)
-    list(GET CONFIG_OUTPUT 5 MAIN_SRC_DIR)
-    list(GET CONFIG_OUTPUT 6 LLVM_CONFIG_CMAKE_PATH)
-
-    # Normalize LLVM_CMAKE_PATH. --cmakedir might contain backslashes.
-    # CMake assumes slashes as PATH.
-    file(TO_CMAKE_PATH ${LLVM_CONFIG_CMAKE_PATH} LLVM_CMAKE_PATH)
-  endif()
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
+  message(FATAL_ERROR "In-source builds are not allowed. \
+          Please create a directory and run cmake from there,\
+          passing the path to this source directory as the last argument.\
+          This process created the file `CMakeCache.txt' and the directory\
+          `CMakeFiles'. Please delete them.")
+endif()
+
+# Add Flang-centric modules to cmake path.
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+include(AddFlang)
 
-  if(NOT MSVC_IDE)
+
+# Check for a standalone build and configure as appropriate from
+# there. 
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+  message("Building Flang as a standalone project.")
+  project(Flang)
+
+  if (NOT MSVC_IDE)
     set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
       CACHE BOOL "Enable assertions")
-    # Assertions should follow llvm-config's.
+    # Assertions follow llvm's configuration.
     mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
   endif()
 
+  # We need a pre-built/installed version of LLVM. 
   find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
   list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
 
-  # We can't check LLVM_CONFIG here, because find_package(LLVM ...) also sets
-  # LLVM_CONFIG.
-  if (NOT LLVM_CONFIG_FOUND)
-    # Pull values from LLVMConfig.cmake.  We can drop this once the llvm-config
-    # path is removed.
-    set(TOOLS_BINARY_DIR ${LLVM_TOOLS_BINARY_DIR})
-    set(LIBRARY_DIR ${LLVM_LIBRARY_DIR})
-    set(INCLUDE_DIR ${LLVM_INCLUDE_DIR})
-    set(LLVM_OBJ_DIR ${LLVM_BINARY_DIR})
-    # The LLVM_CMAKE_PATH variable is set when doing non-standalone builds and
-    # used in this project, so we need to make sure we set this value.
-    # FIXME: LLVM_CMAKE_DIR comes from LLVMConfig.cmake.  We should rename
-    # LLVM_CMAKE_PATH to LLVM_CMAKE_DIR throughout the project.
-    set(LLVM_CMAKE_PATH ${LLVM_CMAKE_DIR})
+  # If LLVM links to zlib we need the imported targets so we can too.
+  if(LLVM_ENABLE_ZLIB)
+    find_package(ZLIB REQUIRED)
   endif()
 
-  set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
-  set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib")
-  set(LLVM_MAIN_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Path to llvm/include")
-  set(LLVM_BINARY_DIR ${LLVM_OBJ_ROOT} CACHE PATH "Path to LLVM build tree")
-  set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")
-
-  find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" ${LLVM_TOOLS_BINARY_DIR}
-    NO_DEFAULT_PATH)
-  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
-    NO_DEFAULT_PATH)
-
-  # They are used as destination of target generators.
-  set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
-  set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
-  if(WIN32 OR CYGWIN)
-    # DLL platform -- put DLLs into bin.
-    set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
-  else()
-    set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
-  endif()
+  include(CMakeParseArguments)
+  include(AddLLVM)
+  include(HandleLLVMOptions)  
+  include(VersionFromVCS)
+  include(AddMLIR) 
 
   option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
   option(LLVM_INSTALL_TOOLCHAIN_ONLY
     "Only include toolchain files in the 'install' target." OFF)
-
   option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
     "Set to ON to force using an old, unsupported host toolchain." OFF)
-  option(CLANG_ENABLE_BOOTSTRAP "Generate the clang bootstrap target" OFF)
-  option(LLVM_ENABLE_LIBXML2 "Use libxml2 if available." ON)
-
-  include(AddLLVM)
-  include(TableGen)
-  include(HandleLLVMOptions)
-  include(VersionFromVCS)
-  include(AddMLIR)
 
-  set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
-
-  if (NOT DEFINED LLVM_INCLUDE_TESTS)
-    set(LLVM_INCLUDE_TESTS ON)
+  
+  # Add LLVM include files as if they were SYSTEM because there are complex unused
+  # parameter issues that may or may not appear depending on the environments and
+  # compilers (ifdefs are involved). This allows warnings from LLVM headers to be
+  # ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
+  # This may have to be fine-tuned if flang headers are consider part of this
+  # LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
+  # should not be suppressed).
+  include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
+  add_definitions(${LLVM_DEFINITIONS})
+
+  # LLVM's cmake configuration files currently sneak in a c++11 flag.
+  # We look for it here and remove it from Flang's compile flags to 
+  # avoid some mixed compilation flangs (e.g. -std=c++11 ... -std=c++17). 
+  if (DEFINED LLVM_CXX_STD) 
+    message("LLVM configuration set a C++ standard: ${LLVM_CXX_STD}")
+    if (NOT LLVM_CXX_STD EQUAL "c++17")
+      message("Flang: Overriding LLVM's 'cxx_std' setting...")
+      message("    removing '-std=${LLVM_CXX_STD}'")
+      message("    CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
+      string(REPLACE " -std=${LLVM_CXX_STD}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+      message("    [NEW] CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
+    endif()
   endif()
 
-  # Adding System to prevent warning from LLVM headers.
-  include_directories(SYSTEM "${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}")
   link_directories("${LLVM_LIBRARY_DIR}")
-  set(MLIR_BINARY_DIR ${LLVM_BINARY_DIR})
-
-  set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
-  set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
-  set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
 
-  if(LLVM_INCLUDE_TESTS)
-    include(FindPythonInterp)
-    if(NOT PYTHONINTERP_FOUND)
-      message(FATAL_ERROR
-"Unable to find Python interpreter, required for builds and testing.
-
-Please install Python or specify the PYTHON_EXECUTABLE CMake variable.")
-    endif()
-
-    if( ${PYTHON_VERSION_STRING} VERSION_LESS 2.7 )
-      message(FATAL_ERROR "Python 2.7 or newer is required")
-    endif()
-
-    # Check prebuilt llvm/utils.
-    if(EXISTS ${LLVM_TOOLS_BINARY_DIR}/FileCheck${CMAKE_EXECUTABLE_SUFFIX}
-        AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/count${CMAKE_EXECUTABLE_SUFFIX}
-        AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/not${CMAKE_EXECUTABLE_SUFFIX})
-      set(LLVM_UTILS_PROVIDED ON)
-    endif()
-
-    if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
-      # Note: path not really used, except for checking if lit was found
-      set(LLVM_LIT ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
-      if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/llvm-lit)
-        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit utils/llvm-lit)
-      endif()
-      if(NOT LLVM_UTILS_PROVIDED)
-        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/FileCheck utils/FileCheck)
-        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/count utils/count)
-        add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/not utils/not)
-        set(LLVM_UTILS_PROVIDED ON)
-        set(FLANG_TEST_DEPS FileCheck count not)
-      endif()
-      set(UNITTEST_DIR ${LLVM_MAIN_SRC_DIR}/utils/unittest)
-      if(EXISTS ${UNITTEST_DIR}/googletest/include/gtest/gtest.h
-          AND NOT EXISTS ${LLVM_LIBRARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX}
-          AND EXISTS ${UNITTEST_DIR}/CMakeLists.txt)
-        add_subdirectory(${UNITTEST_DIR} utils/unittest)
-      endif()
-    else()
-      # Seek installed Lit.
-      find_program(LLVM_LIT
-                   NAMES llvm-lit lit.py lit
-                   PATHS "${LLVM_MAIN_SRC_DIR}/utils/lit"
-                   DOC "Path to lit.py")
-    endif()
-
-    if(LLVM_LIT)
-      # Define the default arguments to use with 'lit', and an option for the user
-      # to override.
-      set(LIT_ARGS_DEFAULT "-sv")
-      if (MSVC OR XCODE)
-        set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
-      endif()
-      set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
-
-      # On Win32 hosts, provide an option to specify the path to the GnuWin32 tools.
-      if( WIN32 AND NOT CYGWIN )
-        set(LLVM_LIT_TOOLS_DIR "" CACHE PATH "Path to GnuWin32 tools")
-      endif()
-    else()
-      set(LLVM_INCLUDE_TESTS OFF)
-    endif()
-  endif()
+  set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
+  find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
+    NO_DEFAULT_PATH)
 
-  set(FLANG_BUILT_STANDALONE 1)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY 
+    ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
+  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY 
+    ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
+  
   set(BACKEND_PACKAGE_STRING "LLVM ${LLVM_PACKAGE_VERSION}")
+  set(MLIR_BINARY_DIR ${LLVM_BINARY_DIR})
 else()
   set(BACKEND_PACKAGE_STRING "${PACKAGE_STRING}")
   set(MLIR_BINARY_DIR ${LLVM_BINARY_DIR}/tools/mlir)
   set(MLIR_SOURCE_DIR ${LLVM_SOURCE_DIR}/../mlir)
 endif()
 
-# If LLVM links to zlib we need the imported targets so we can too.
-if(LLVM_ENABLE_ZLIB)
-  find_package(ZLIB REQUIRED)
-endif()
-
-# Make sure that our source directory is on the current cmake module path so that
-# we can include cmake files from this directory.
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
-
-if(LLVM_ENABLE_LIBXML2)
-  # Don't look for libxml if we're using MSan, since uninstrumented third party
-  # code may call MSan interceptors like strlen, leading to false positives.
-  if(NOT LLVM_USE_SANITIZER MATCHES "Memory.*")
-    set (LIBXML2_FOUND 0)
-    find_package(LibXml2 2.5.3 QUIET)
-    if (LIBXML2_FOUND)
-      set(FLANG_HAVE_LIBXML 1)
-    endif()
-  endif()
-endif()
-
-option(FLANG_LINK_WITH_FIR "Link Flang driver with FIR and LLVM" ON)
-if (LINK_WITH_FIR)
-  message(STATUS "Linking driver with FIR and LLVM")
-  llvm_map_components_to_libnames(LLVM_COMMON_LIBS support)
-  message(STATUS "LLVM libraries: ${LLVM_COMMON_LIBS}")
-endif()
-
-set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+include_directories(BEFORE
+  ${FLANG_BINARY_DIR}/include
+  ${FLANG_SOURCE_DIR}/include)
 
 if(MLIR_SOURCE_DIR)
   include_directories(BEFORE
@@ -275,132 +140,138 @@ endif()
 
 set(MLIR_TABLEGEN_EXE mlir-tblgen)
 
-set(FLANG_C_INCLUDE_DIRS "" CACHE STRING
-  "Colon separated list of directories flang will search for headers.")
+# Add Flang-centric modules to cmake path. 
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
-set(GCC_INSTALL_PREFIX "" CACHE PATH "Directory where gcc is installed.")
-set(DEFAULT_SYSROOT "" CACHE PATH
-  "Default <path> to all compiler invocations for --sysroot=<path>.")
+if (NOT DEFAULT_SYSROOT)
+  set(DEFAULT_SYSROOT "" CACHE PATH
+    "The <path> to use for the system root for all compiler invocations (--sysroot=<path>).")
+endif()
 
-set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
+if (NOT ENABLE_LINKER_BUILD_ID)
+  set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
+endif()
 
 set(FLANG_DEFAULT_LINKER "" CACHE STRING
   "Default linker to use (linker name or absolute path, empty for platform default)")
 
-set(FLANG_DEFAULT_RTLIB "" CACHE STRING "Default Fortran runtime library to use (\"libFortranRuntime\", empty for platform default)")
+set(FLANG_DEFAULT_RTLIB "" CACHE STRING 
+   "Default Fortran runtime library to use (\"libFortranRuntime\"), leave empty for platform default.")
+
 if (NOT(FLANG_DEFAULT_RTLIB STREQUAL ""))
-  message(WARNING "Resetting Flang's default runtime library to use platform default")
+  message(WARNING "Resetting Flang's default runtime library to use platform default.")
   set(FLANG_DEFAULT_RTLIB "" CACHE STRING
-      "Default runtime library to use (\"libgcc\" or \"compiler-rt\", empty for platform default)" FORCE)
+      "Default runtime library to use (empty for platform default)" FORCE)
 endif()
 
-set(FLANG_VENDOR ${PACKAGE_VENDOR} CACHE STRING
-  "Vendor-specific text for showing with version information.")
 
 
-if (FLANG_VENDOR)
-  add_definitions(-DFLANG_VENDOR="${FLANG_VENDOR} ")
-endif()
-
-set(FLANG_REPOSITORY_STRING "" CACHE STRING
-  "Vendor-specific text for showing the repository the source is taken from.")
-
-if (FLANG_REPOSITORY_STRING)
-  add_definitions(-DFLANG_REPOSITORY_STRING="${FLANG_REPOSITORY_STRING}")
-endif()
-
-set(FLANG_VENDOR_UTI "org.llvm.flang" CACHE STRING
-  "Vendor-specific uti.")
-
-# The libdir suffix must exactly match whatever LLVM's configuration used.
-set(FLANG_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}")
-
-set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
-
-if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
-  message(FATAL_ERROR "In-source builds are not allowed. "
-"Please create a directory and run cmake "
-"from there, passing the path to this source directory as the last argument. "
-"This process created the file `CMakeCache.txt' and the directory "
-"`CMakeFiles'. Please delete them.")
-endif()
-
-# Override version information to reflect early stages of flang vs.
-# following LLVM's versioning info...
+set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
+# Override LLVM versioning for now... 
 set(FLANG_VERSION_MAJOR      "0")
 set(FLANG_VERSION_MINOR      "1")
 set(FLANG_VERSION_PATCHLEVEL "0")
 
-# If FLANG_VERSION_* is specified, use it, if not use LLVM_VERSION_*.
+
 if (NOT DEFINED FLANG_VERSION_MAJOR)
   set(FLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 endif()
+
 if (NOT DEFINED FLANG_VERSION_MINOR)
   set(FLANG_VERSION_MINOR ${LLVM_VERSION_MINOR})
 endif()
+
 if (NOT DEFINED FLANG_VERSION_PATCHLEVEL)
   set(FLANG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
 endif()
+
 # Unlike PACKAGE_VERSION, FLANG_VERSION does not include LLVM_VERSION_SUFFIX.
 set(FLANG_VERSION "${FLANG_VERSION_MAJOR}.${FLANG_VERSION_MINOR}.${FLANG_VERSION_PATCHLEVEL}")
 message(STATUS "Flang version: ${FLANG_VERSION}")
+# Flang executable version information
+set(FLANG_EXECUTABLE_VERSION
+    "${FLANG_VERSION_MAJOR}" CACHE STRING
+    "Major version number to appended to the flang executable name.")
+set(LIBFLANG_LIBRARY_VERSION
+    "${FLANG_VERSION_MAJOR}" CACHE STRING
+    "Major version number to appended to the libflang library.")
+
+mark_as_advanced(FLANG_EXECUTABLE_VERSION LIBFLANG_LIBRARY_VERSION)
+
+set(FLANG_VENDOR ${PACKAGE_VENDOR} CACHE STRING
+  "Vendor-specific Flang version information.")
+set(FLANG_VENDOR_UTI "org.llvm.flang" CACHE STRING
+  "Vendor-specific uti.")
 
-# Configure the Version.inc file.
+if (FLANG_VENDOR)
+  add_definitions(-DFLANG_VENDOR="${FLANG_VENDOR} ")
+endif()
+
+set(FLANG_REPOSITORY_STRING "" CACHE STRING
+  "Vendor-specific text for showing the repository the source is taken from.")
+if (FLANG_REPOSITORY_STRING)
+  add_definitions(-DFLANG_REPOSITORY_STRING="${FLANG_REPOSITORY_STRING}")
+endif()
+
+# Configure Flang's Version.inc file.
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/include/flang/Version.inc.in
   ${CMAKE_CURRENT_BINARY_DIR}/include/flang/Version.inc)
-
-if (FLANG_LINK_WITH_FIR)
-  message(STATUS "Linking Flang driver with FIR and LLVM")
-  llvm_map_components_to_libnames(LLVM_COMMON_LIBS support)
-  message(STATUS "Flang using LLVM libraries: ${LLVM_COMMON_LIBS}")
-endif()
+# Configure Flang's version info header file.   
+configure_file(
+  ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
+  ${FLANG_BINARY_DIR}/include/flang/Config/config.h)
 
 # Add appropriate flags for GCC
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -fno-rtti -fno-exceptions -Wall -Wextra -Werror -Wcast-qual -Wimplicit-fallthrough -Wdelete-non-virtual-dtor")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions")
   if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -fno-semantic-interposition")
-  else ()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument -Wstring-conversion -Wcovered-switch-default")
-    # The following works around warnings in the f18 sources
-    check_cxx_compiler_flag("-Werror -Wdeprecated-copy" CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
-    if (CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy")
-    endif()
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument -Wstring-conversion \
+          -Wcovered-switch-default")
+
+    # The following works around warnings in the f18 sources.  TODO: Should these move 
+    # outside of GCC compatible block at some point? 
+    
     check_cxx_compiler_flag("-Werror -Wstring-conversion" CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
     if (CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
     endif()
-  endif ()
-
-  # Enable -pedantic for Flang even if it's not enabled for LLVM.
-  if (NOT LLVM_ENABLE_PEDANTIC)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
-  endif ()
+  endif()  # Clang. 
 
   check_cxx_compiler_flag("-Werror -Wnested-anon-types" CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
   if (CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types")
   endif()
 
+  # Add to or adjust build type flags. 
+  # 
+  # TODO: This needs some extra thought.  CMake's default for release builds 
+  # is -O3, which can cause build failures on certain platforms (and compilers)
+  # with the current code base -- some templated functions are inlined and don't
+  # become available at link time when using -O3 (with Clang under MacOS/darwin).
+  # If we reset CMake's default flags we also clobber any user provided settings;  
+  # make it difficult to customize a build in this regard...   The setup below
+  # has this side effect but enables successful builds across multiple platforms 
+  # in release mode...  
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGF18")    
+  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DCHECK=(void)")  # do we need -O2 here?  
+  set(CMAKE_CXX_FLAGS_RELEASE "-O2")  
+  
   if (GCC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --gcc-toolchain=${GCC}")
-  endif ()
-
-  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DCHECK=(void)")
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGF18")
-
-   # Building shared libraries is death on performance with GCC by default
-   # due to the need to preserve the right to override external entry points
-   # at dynamic link time.  -fno-semantic-interposition waives that right and
-   # recovers a little bit of that performance.
-   if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
-   endif()
-  
-endif ()
+  endif()
+
+  # Building shared libraries is death on performance with GCC by default
+  # due to the need to preserve the right to override external entry points
+  if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+   set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
+  endif()
+
+endif()
+
+list(REMOVE_DUPLICATES CMAKE_CXX_FLAGS)
 
 # Determine HOST_LINK_VERSION on Darwin.
 set(HOST_LINK_VERSION)
@@ -409,8 +280,7 @@ if (APPLE)
   execute_process(
     COMMAND sh -c "${CMAKE_LINKER} -v 2>&1 | head -1"
     RESULT_VARIABLE HAD_ERROR
-    OUTPUT_VARIABLE LD_V_OUTPUT
-  )
+    OUTPUT_VARIABLE LD_V_OUTPUT)
   if (NOT HAD_ERROR)
     if ("${LD_V_OUTPUT}" MATCHES ".*ld64-([0-9.]+).*")
       string(REGEX REPLACE ".*ld64-([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
@@ -425,68 +295,42 @@ endif()
 include(CMakeParseArguments)
 include(AddFlang)
 
-if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-  install(DIRECTORY include/flang
-    DESTINATION include
-    COMPONENT flang-headers
-    FILES_MATCHING
-    PATTERN "*.def"
-    PATTERN "*.h"
-    PATTERN "config.h" EXCLUDE
-    PATTERN ".svn" EXCLUDE
-    )
-
-  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/flang
-    DESTINATION include
-    COMPONENT flang-headers
-    FILES_MATCHING
-    PATTERN "CMakeFiles" EXCLUDE
-    PATTERN "*.inc"
-    PATTERN "*.h"
-    )
-
-endif()
 
-add_definitions(-D_GNU_SOURCE)
+add_subdirectory(include)
+add_subdirectory(lib)
+add_subdirectory(cmake/modules)
 
 option(FLANG_BUILD_TOOLS
   "Build the Flang tools. If OFF, just generate build targets." ON)
-
-# Flang version information
-set(FLANG_EXECUTABLE_VERSION
-    "${FLANG_VERSION_MAJOR}" CACHE STRING
-    "Major version number that will be appended to the flang executable name")
-
-set(LIBFLANG_LIBRARY_VERSION
-    "${FLANG_VERSION_MAJOR}" CACHE STRING
-    "Major version number that will be appended to the libflang library")
-
-mark_as_advanced(FLANG_EXECUTABLE_VERSION LIBFLANG_LIBRARY_VERSION)
+if (FLANG_BUILD_TOOLS)
+  add_subdirectory(tools)
+endif()
+add_subdirectory(runtime)
 
 option(FLANG_INCLUDE_TESTS
        "Generate build targets for the Flang unit tests."
        ${LLVM_INCLUDE_TESTS})
-
-add_subdirectory(include)
-add_subdirectory(lib)
-add_subdirectory(tools)
-add_subdirectory(runtime)
-
-option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
-  ${LLVM_INCLUDE_DOCS})
-
-if (FLANG_INCLUDE_DOCS)
-  add_subdirectory(docs)
+if (FLANG_INCLUDE_TESTS)
+  enable_testing()
+  add_subdirectory(test)
+  #add_subdirectory(test-lit)
 endif()
 
+# TODO: Add doxygen support.
+#option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
+#       ${LLVM_INCLUDE_DOCS})
+#if (FLANG_INCLUDE_DOCS)
+#  add_subdirectory(documentation)
+#endif()
+
 # Custom target to install Flang libraries.
 add_custom_target(flang-libraries)
 set_target_properties(flang-libraries PROPERTIES FOLDER "Misc")
 
 if (NOT LLVM_ENABLE_IDE)
   add_llvm_install_targets(install-flang-libraries
-                           DEPENDS flang-libraries
-			   COMPONENT flang-libraries)
+   DEPENDS flang-libraries
+   COMPONENT flang-libraries)
 endif()
 
 get_property(FLANG_LIBS GLOBAL PROPERTY FLANG_LIBS)
@@ -500,10 +344,17 @@ if (FLANG_LIBS)
   endforeach()
 endif()
 
-add_subdirectory(cmake/modules)
-
-configure_file(
-  ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
-  ${FLANG_BINARY_DIR}/include/flang/Config/config.h)
+if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+  install(DIRECTORY include/flang
+    DESTINATION include
+    COMPONENT flang-headers
+    FILES_MATCHING
+    PATTERN "*.def"
+    PATTERN "*.h"
+    PATTERN "*.inc"    
+    PATTERN "config.h" EXCLUDE
+    PATTERN ".git"     EXCLUDE
+    PATTERN "CMakeFiles" EXCLUDE    
+    PATTERN "*")
+endif()
 
-add_subdirectory(test-lit)
diff --git a/cmake/modules/AddFlang.cmake b/cmake/modules/AddFlang.cmake
index 84610a633a04..4d41151fbc39 100644
--- a/cmake/modules/AddFlang.cmake
+++ b/cmake/modules/AddFlang.cmake
@@ -1,3 +1,11 @@
+#===-- cmake/modules/AddFlang.cmake ----------------------------------------===#
+#
+# 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
+#
+#===------------------------------------------------------------------------===#
+
 macro(set_flang_windows_version_resource_properties name)
   if (DEFINED windows_resource_file)
     set_windows_version_resource_properties(${name} ${windows_resource_file}
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 9589e7b0df79..e6bb9db72ff6 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1 +1 @@
-add_subdirectory(flang/Optimizer)
+add_subdirectory(flang)
diff --git a/lib/Common/CMakeLists.txt b/lib/Common/CMakeLists.txt
index f1be58f0e6d0..76544ad4d7b5 100644
--- a/lib/Common/CMakeLists.txt
+++ b/lib/Common/CMakeLists.txt
@@ -1,4 +1,3 @@
-
 add_library(FortranCommon
   Fortran.cpp
   Fortran-features.cpp
diff --git a/lib/Decimal/CMakeLists.txt b/lib/Decimal/CMakeLists.txt
index 92f87621fc05..cccf31395bcd 100644
--- a/lib/Decimal/CMakeLists.txt
+++ b/lib/Decimal/CMakeLists.txt
@@ -1,4 +1,3 @@
-
 add_library(FortranDecimal
   binary-to-decimal.cpp
   decimal-to-binary.cpp
diff --git a/lib/Evaluate/CMakeLists.txt b/lib/Evaluate/CMakeLists.txt
index 2b23455165aa..fb0bd3d690f9 100644
--- a/lib/Evaluate/CMakeLists.txt
+++ b/lib/Evaluate/CMakeLists.txt
@@ -1,4 +1,3 @@
-
 add_library(FortranEvaluate
   call.cpp
   characteristics.cpp
diff --git a/lib/Parser/CMakeLists.txt b/lib/Parser/CMakeLists.txt
index 9dc6480a2e9d..b0636dc1efc2 100644
--- a/lib/Parser/CMakeLists.txt
+++ b/lib/Parser/CMakeLists.txt
@@ -1,4 +1,3 @@
-
 add_library(FortranParser
   Fortran-parsers.cpp
   char-buffer.cpp
diff --git a/unittests/Decimal/CMakeLists.txt b/unittests/Decimal/CMakeLists.txt
index f26aca5d0e9b..dd2f5a532479 100644
--- a/unittests/Decimal/CMakeLists.txt
+++ b/unittests/Decimal/CMakeLists.txt
@@ -8,11 +8,7 @@ target_link_libraries(quick-sanity-test
   LLVMSupport
 )
 
-add_executable(thorough-test
-  thorough-test.cpp
-)
-
-target_link_libraries(thorough-test
+add_flang_test(thorough-test Thorough
   FortranDecimal
   LLVMSupport
 )
diff --git a/unittests/Evaluate/CMakeLists.txt b/unittests/Evaluate/CMakeLists.txt
index 54c816ef6c55..f61f52d9fa2e 100644
--- a/unittests/Evaluate/CMakeLists.txt
+++ b/unittests/Evaluate/CMakeLists.txt
@@ -4,43 +4,22 @@ add_library(FortranEvaluateTesting
   fp-testing.cpp
 )
 
-add_executable(leading-zero-bit-count-test
-  leading-zero-bit-count.cpp
-)
-
-target_link_libraries(leading-zero-bit-count-test
+add_flang_test(leading-zero-bit-count Leadz
   FortranEvaluateTesting
   LLVMSupport
 )
 
-add_executable(bit-population-count-test
-  bit-population-count.cpp
-)
-
-target_link_libraries(bit-population-count-test
+add_flang_test(bit-population-count PopPar
   FortranEvaluateTesting
   LLVMSupport
 )
 
-add_executable(uint128-test
-  uint128.cpp
-)
-
-target_link_libraries(uint128-test
+add_flang_test(uint128 UINT128
   FortranEvaluateTesting
   LLVMSupport
 )
 
-# These routines live in lib/Common but we test them here.
-add_test(UINT128 uint128-test)
-add_test(Leadz leading-zero-bit-count-test)
-add_test(PopPar bit-population-count-test)
-
-add_executable(expression-test
-  expression.cpp
-)
-
-target_link_libraries(expression-test
+add_flang_test(expression Expression
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
@@ -48,22 +27,14 @@ target_link_libraries(expression-test
   LLVMSupport
 )
 
-add_executable(integer-test
-  integer.cpp
-)
-
-target_link_libraries(integer-test
+add_flang_test(integer Integer
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
   LLVMSupport
 )
 
-add_executable(intrinsics-test
-  intrinsics.cpp
-)
-
-target_link_libraries(intrinsics-test
+add_flang_test(intrinsics Intrinsics
   FortranEvaluateTesting
   FortranEvaluate
   FortranDecimal
@@ -73,11 +44,7 @@ target_link_libraries(intrinsics-test
   LLVMSupport
 )
 
-add_executable(logical-test
-  logical.cpp
-)
-
-target_link_libraries(logical-test
+add_flang_test(logical Logical
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
@@ -89,11 +56,8 @@ target_link_libraries(logical-test
 # in the actual hardware floating-point status register, so ensure that
 # C++ exceptions are enabled for this test.
 set_source_files_properties(real.cpp PROPERTIES COMPILE_FLAGS -fexceptions)
-add_executable(real-test
-  real.cpp
-)
 
-target_link_libraries(real-test
+add_flang_test(real Real
   FortranEvaluateTesting
   FortranEvaluate
   FortranDecimal
@@ -101,11 +65,7 @@ target_link_libraries(real-test
   LLVMSupport
 )
 
-add_executable(reshape-test
-  reshape.cpp
-)
-
-target_link_libraries(reshape-test
+add_flang_test(reshape Reshape
   FortranEvaluateTesting
   FortranSemantics
   FortranEvaluate
@@ -113,11 +73,7 @@ target_link_libraries(reshape-test
   LLVMSupport
 )
 
-add_executable(ISO-Fortran-binding-test
-  ISO-Fortran-binding.cpp
-)
-
-target_link_libraries(ISO-Fortran-binding-test
+add_flang_test(ISO-Fortran-binding ISO-binding
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
@@ -125,11 +81,7 @@ target_link_libraries(ISO-Fortran-binding-test
   LLVMSupport
 )
 
-add_executable(folding-test
-  folding.cpp
-)
-
-target_link_libraries(folding-test
+add_flang_test(folding Folding
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
@@ -144,3 +96,28 @@ add_test(Real real-test)
 add_test(RESHAPE reshape-test)
 add_test(ISO-binding ISO-Fortran-binding-test)
 add_test(folding folding-test)
+
+#set(FOLDING_TESTS
+#  folding01.f90
+#  folding02.f90
+#  folding03.f90
+#  folding04.f90
+#  folding05.f90
+#  folding06.f90
+#  folding07.f90
+#  folding08.f90
+#  folding09.f90
+#)
+
+#set(TEST_LIBPGMATH "-pgmath=false")
+#if (LIBPGMATH_DIR)
+#  find_library(LIBPGMATH pgmath PATHS ${LIBPGMATH_DIR})
+#  if(LIBPGMATH)
+#    set(TEST_LIBPGMATH "-pgmath=true")
+#  endif()
+#endif()
+
+#foreach(test ${FOLDING_TESTS})
+#  add_test(NAME ${test} COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test_folding.sh
+#    ${test} ${TEST_LIBPGMATH})
+#endforeach()

From 3350ee7d9896de806485d40e29f6653a4b1b6a5f Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Thu, 5 Mar 2020 20:05:04 -0800
Subject: [PATCH 220/345] [PR1035] remove unused dummy argument from
 LenType/FieldType

---
 include/flang/Optimizer/Dialect/FIRType.h | 4 ++--
 lib/Optimizer/Dialect/FIRType.cpp         | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 9c494df787f9..73174371718a 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -233,7 +233,7 @@ class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
                                               detail::FieldTypeStorage> {
 public:
   using Base::Base;
-  static FieldType get(mlir::MLIRContext *ctxt, KindTy _ = 0);
+  static FieldType get(mlir::MLIRContext *ctxt);
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_FIELD; }
 };
 
@@ -261,7 +261,7 @@ class LenType
     : public mlir::Type::TypeBase<LenType, mlir::Type, detail::LenTypeStorage> {
 public:
   using Base::Base;
-  static LenType get(mlir::MLIRContext *ctxt, KindTy _ = 0);
+  static LenType get(mlir::MLIRContext *ctxt);
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_LEN; }
 };
 
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index 7aafd8e22643..d1fccd7be317 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -873,13 +873,13 @@ int fir::DimsType::getRank() const { return getImpl()->getRank(); }
 
 // Field
 
-FieldType fir::FieldType::get(mlir::MLIRContext *ctxt, KindTy) {
+FieldType fir::FieldType::get(mlir::MLIRContext *ctxt) {
   return Base::get(ctxt, FIR_FIELD, 0);
 }
 
 // Len
 
-LenType fir::LenType::get(mlir::MLIRContext *ctxt, KindTy) {
+LenType fir::LenType::get(mlir::MLIRContext *ctxt) {
   return Base::get(ctxt, FIR_LEN, 0);
 }
 

From 9e4bab1b89e6ca6ac201c8f343bfd298930cb717 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Thu, 5 Mar 2020 20:36:41 -0800
Subject: [PATCH 221/345] [PR1035] simplify fir::ConstfOp

---
 include/flang/Optimizer/Dialect/FIROps.h  |  1 +
 include/flang/Optimizer/Dialect/FIROps.td | 33 +++++++----------------
 lib/Optimizer/CodeGen.cpp                 |  2 +-
 3 files changed, 12 insertions(+), 24 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.h b/include/flang/Optimizer/Dialect/FIROps.h
index 991056ad2135..f5763693f7bb 100644
--- a/include/flang/Optimizer/Dialect/FIROps.h
+++ b/include/flang/Optimizer/Dialect/FIROps.h
@@ -17,6 +17,7 @@ namespace fir {
 
 class FirEndOp;
 class LoopOp;
+class RealAttr;
 
 void buildCmpFOp(mlir::Builder *builder, mlir::OperationState &result,
                  mlir::CmpFPredicate predicate, mlir::Value lhs,
diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 3ed63918f1d1..1e5564551d07 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2204,6 +2204,11 @@ class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
   let printer = [{ return printUnaryOp(this->getOperation(), p); }];
 }
 
+def FirRealAttr : Attr<CPred<"$_self.isa<fir::RealAttr>()">, "FIR real attr"> {
+  let storageType = [{ fir::RealAttr }];
+  let returnType = [{ llvm::APFloat }];
+}
+
 def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]> {
   let summary = "create a floating point constant";
 
@@ -2212,35 +2217,17 @@ def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]> {
     to represent APFloat values that are not supported in the standard dialect.
   }];
 
-  let results = (outs fir_RealType);
-
-  let parser = [{
-    fir::RealAttr flt;
-    mlir::Type type;
-    if (parser.parseLParen() ||
-        parser.parseAttribute(flt, constAttrName(), result.attributes) ||
-        parser.parseRParen() || parser.parseColonType(type) ||
-        parser.addTypesToList(type, result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << getAttr(constAttrName()) << " : ";
-    p.printType(getType());
-  }];
+  let arguments = (ins FirRealAttr:$constant);
+  
+  let results = (outs fir_RealType:$res);
 
+  let assemblyFormat = "`(` $constant `)` attr-dict `:` type($res)";
+  
   let verifier = [{
     if (!getType().isa<fir::RealType>())
       return emitOpError("must be a !fir.real type");
     return mlir::success();
   }];
-
-  let extraClassDeclaration = [{
-    static constexpr llvm::StringRef constAttrName() { return "constant"; }
-
-    mlir::Attribute getValue() { return getAttr(constAttrName()); }
-  }];
 }
 
 class RealUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 9ee3cc391121..15a68ca4304f 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -901,7 +901,7 @@ struct ConstfOpConversion : public FIROpConversion<fir::ConstfOp> {
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto conf = mlir::cast<fir::ConstfOp>(op);
     auto ty = convertType(conf.getType());
-    auto val = conf.getValue();
+    auto val = conf.constantAttr();
     rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(conf, ty, val);
     return matchSuccess();
   }

From 1c85d37333c0fe48ac104233c3f08827a128a202 Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Sat, 29 Feb 2020 00:43:40 -0800
Subject: [PATCH 222/345] Basic FIR control flow generation

Update the PFT build (nominally complete, pending actual use), and use the
updated information to generate FIR for:
 - structured and unstructured IF constructs and statements
 - unstructured infinite and while loops
 - structured and unstructured increment ("normal") loops
 - goto, cycle, and exit statements

Generation of structured and unstructured concurrent loops is not yet
implemented, but that code should be able to reuse the code that increment
loops use.

The PFT code consists of a primary pass in PFTBuilder.cpp that generates the
tree as such, plus a secondary pass invoked at the function level (function
analyzeBranches) that adds links for branches.

Fir generation in Bridge.cpp also has a primary pass and a small secondary
prepass that creates most empty blocks in advance (function createEmptyBlocks).
(Fir generation for I/O statements may need to generate additional blocks.)

Option -no-structured-fir can be used to force generation of unstructured
code for all IF variants and all loop variants.
---
 include/flang/Lower/OpBuilder.h           |    2 +-
 include/flang/Lower/PFTBuilder.h          |  322 +++--
 include/flang/Optimizer/Dialect/FIROps.td |    3 +-
 lib/Lower/Bridge.cpp                      | 1321 ++++++++++++---------
 lib/Lower/CFGBuilder.h                    |  358 ------
 lib/Lower/OpBuilder.cpp                   |   34 +-
 lib/Lower/PFTBuilder.cpp                  |  952 ++++++++++-----
 test/Lower/pre-fir-tree01.f90             |    6 +-
 test/Lower/pre-fir-tree02.f90             |   46 +-
 test/Lower/pre-fir-tree03.f90             |   12 +-
 test/Lower/pre-fir-tree04.f90             |   10 +-
 tools/f18/f18.cpp                         |    1 -
 12 files changed, 1589 insertions(+), 1478 deletions(-)
 delete mode 100644 lib/Lower/CFGBuilder.h

diff --git a/include/flang/Lower/OpBuilder.h b/include/flang/Lower/OpBuilder.h
index 94bbfbcdb457..4a9f12fb3d9a 100644
--- a/include/flang/Lower/OpBuilder.h
+++ b/include/flang/Lower/OpBuilder.h
@@ -53,7 +53,7 @@ class SymMap {
   mlir::Value lookupSymbol(semantics::SymbolRef symbol);
 
   void pushShadowSymbol(semantics::SymbolRef symbol, mlir::Value value);
-  void popShadowSymbol() { shadowStack.pop_back(); }
+  void popShadowSymbol();
 
   void clear() {
     symbolMap.clear();
diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 1c5f5ff703f6..77e0f50256c6 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -6,7 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines the PFT abstraction interface.
+// PFT (Pre-FIR Tree) interface.
+//
+// A PFT is a light weight tree over the parse tree that is used to create FIR.
+// The PFT captures pointers back into the parse tree, so the parse tree must
+// not be changed between the construction of the PFT and its last use.
+// The PFT captures a structured view of a program.  A program is a list of
+// units.  A function like unit contains a list of evaluations.  An evaluation
+// is either a statement, or a construct with a nested list of evaluations.
 //
 //===----------------------------------------------------------------------===//
 
@@ -15,10 +22,13 @@
 
 #include "flang/Common/template.h"
 #include "flang/Parser/parse-tree.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/raw_ostream.h"
 #include <memory>
+#include <set>
 
-namespace llvm {
-class raw_ostream;
+namespace mlir {
+class Block;
 }
 
 namespace Fortran::lower {
@@ -29,44 +39,18 @@ struct Program;
 struct ModuleLikeUnit;
 struct FunctionLikeUnit;
 
-// TODO: A collection of Evaluations can obviously be any of the container
-// types; leaving this as a std::list _for now_ because we reserve the right to
-// insert PFT nodes in any order in O(1) time.
-using EvaluationCollection = std::list<Evaluation>;
+// Using std::list for a list of Evaluations preserves the option to do
+// O(1) time insertions anywhere.
+using EvaluationList = std::list<Evaluation>;
 
 struct ParentType {
   template <typename A>
-  ParentType(A &parent) : p{&parent} {}
+  ParentType(A &parentType) : p{&parentType} {}
   const std::variant<Program *, ModuleLikeUnit *, FunctionLikeUnit *,
                      Evaluation *>
       p;
 };
 
-/// Flags to describe the impact of parse-trees nodes on the program
-/// control flow. These annotations to parse-tree nodes are later used to
-/// build the control flow graph when lowering to FIR.
-enum class CFGAnnotation {
-  None,            // Node does not impact control flow.
-  Goto,            // Node acts like a goto on the control flow.
-  CondGoto,        // Node acts like a conditional goto on the control flow.
-  IndGoto,         // Node acts like an indirect goto on the control flow.
-  IoSwitch,        // Node is an IO statement with ERR, END, or EOR specifier.
-  Switch,          // Node acts like a switch on the control flow.
-  Iterative,       // Node creates iterations in the control flow.
-  FirStructuredOp, // Node is a structured loop.
-  Return,          // Node triggers a return from the current procedure.
-  Terminate        // Node terminates the program.
-};
-
-/// Compiler-generated jump
-///
-/// This is used to convert implicit control-flow edges to explicit form in the
-/// decorated PFT
-struct CGJump {
-  CGJump(Evaluation &to) : target{to} {}
-  Evaluation &target;
-};
-
 /// Classify the parse-tree nodes from ExecutablePartConstruct
 
 using ActionStmts = std::tuple<
@@ -87,15 +71,6 @@ using ActionStmts = std::tuple<
 using OtherStmts = std::tuple<parser::FormatStmt, parser::EntryStmt,
                               parser::DataStmt, parser::NamelistStmt>;
 
-using Constructs =
-    std::tuple<parser::AssociateConstruct, parser::BlockConstruct,
-               parser::CaseConstruct, parser::ChangeTeamConstruct,
-               parser::CriticalConstruct, parser::DoConstruct,
-               parser::IfConstruct, parser::SelectRankConstruct,
-               parser::SelectTypeConstruct, parser::WhereConstruct,
-               parser::ForallConstruct, parser::CompilerDirective,
-               parser::OpenMPConstruct, parser::OmpEndLoopDirective>;
-
 using ConstructStmts = std::tuple<
     parser::AssociateStmt, parser::EndAssociateStmt, parser::BlockStmt,
     parser::EndBlockStmt, parser::SelectCaseStmt, parser::CaseStmt,
@@ -107,20 +82,26 @@ using ConstructStmts = std::tuple<
     parser::MaskedElsewhereStmt, parser::ElsewhereStmt, parser::EndWhereStmt,
     parser::ForallConstructStmt, parser::EndForallStmt>;
 
+using Constructs =
+    std::tuple<parser::AssociateConstruct, parser::BlockConstruct,
+               parser::CaseConstruct, parser::ChangeTeamConstruct,
+               parser::CriticalConstruct, parser::DoConstruct,
+               parser::IfConstruct, parser::SelectRankConstruct,
+               parser::SelectTypeConstruct, parser::WhereConstruct,
+               parser::ForallConstruct, parser::CompilerDirective,
+               parser::OpenMPConstruct, parser::OmpEndLoopDirective>;
+
 template <typename A>
 static constexpr bool isActionStmt{common::HasMember<A, ActionStmts>};
 
 template <typename A>
-static constexpr bool isConstruct{common::HasMember<A, Constructs>};
+static constexpr bool isOtherStmt{common::HasMember<A, OtherStmts>};
 
 template <typename A>
 static constexpr bool isConstructStmt{common::HasMember<A, ConstructStmts>};
 
 template <typename A>
-static constexpr bool isOtherStmt{common::HasMember<A, OtherStmts>};
-
-template <typename A>
-static constexpr bool isGenerated{std::is_same_v<A, CGJump>};
+static constexpr bool isConstruct{common::HasMember<A, Constructs>};
 
 template <typename A>
 static constexpr bool isFunctionLike{common::HasMember<
@@ -128,41 +109,18 @@ static constexpr bool isFunctionLike{common::HasMember<
                   parser::SubroutineSubprogram,
                   parser::SeparateModuleSubprogram>>};
 
-/// Function-like units can contains lists of evaluations.  These can be
+/// Function-like units can contain lists of evaluations.  These can be
 /// (simple) statements or constructs, where a construct contains its own
 /// evaluations.
 struct Evaluation {
-  using EvalTuple = common::CombineTuples<ActionStmts, OtherStmts, Constructs,
-                                          ConstructStmts>;
+  using EvaluationTuple = common::CombineTuples<ActionStmts, OtherStmts,
+                                                ConstructStmts, Constructs>;
 
   /// Hide non-nullable pointers to the parse-tree node.
   template <typename A>
   using MakeRefType = const A *const;
-
-  using EvalVariant =
-      common::CombineVariants<common::MapTemplate<MakeRefType, EvalTuple>,
-                              std::variant<CGJump>>;
-
-  /// General ctor
-  template <typename A>
-  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &pos,
-             const std::optional<parser::Label> &lab)
-      : u{&a}, parent{p}, pos{pos}, lab{lab} {}
-
-  /// Compiler-generated jump
-  Evaluation(const CGJump &jump, const ParentType &p)
-      : u{jump}, parent{p}, cfg{CFGAnnotation::Goto} {}
-
-  /// Construct ctor
-  template <typename A>
-  Evaluation(const A &a, const ParentType &parent) : u{&a}, parent{parent} {
-    static_assert(pft::isConstruct<A>, "must be a construct");
-  }
-
-  Evaluation() = delete;
-  Evaluation(const Evaluation &) = delete;
-  Evaluation(Evaluation &&) = default;
-
+  using EvaluationVariant = common::CombineVariants<
+      common::MapTemplate<MakeRefType, EvaluationTuple>>;
   template <typename A>
   constexpr auto visit(A visitor) const {
     return std::visit(common::visitors{
@@ -171,102 +129,114 @@ struct Evaluation {
                       },
                       u);
   }
-  
   template <typename A>
   constexpr const A *getIf() const {
-    if constexpr (!std::is_same_v<A, CGJump>) {
-      if (auto *ptr{std::get_if<MakeRefType<A>>(&u)})
-        return *ptr;
-    } else {
-      return std::get_if<CGJump>(&u);
+    if (auto *ptr{std::get_if<MakeRefType<A>>(&u)}) {
+      return *ptr;
     }
     return nullptr;
   }
-  
   template <typename A>
   constexpr bool isA() const {
-    if constexpr (!std::is_same_v<A, CGJump>)
-      return std::holds_alternative<MakeRefType<A>>(u);
-    return std::holds_alternative<CGJump>(u);
+    return std::holds_alternative<MakeRefType<A>>(u);
   }
 
-  constexpr bool isActionOrGenerated() const {
-    return visit(common::visitors{
-        [](auto &r) {
-          using T = std::decay_t<decltype(r)>;
-          return pft::isActionStmt<T> || isGenerated<T>;
-        },
-    });
+  Evaluation() = delete;
+  Evaluation(const Evaluation &) = delete;
+  Evaluation(Evaluation &&) = default;
+
+  /// General ctor
+  template <typename A>
+  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &position,
+             const std::optional<parser::Label> &label)
+      : u{&a}, parentType{p}, position{position}, label{label} {}
+
+  /// Construct ctor
+  template <typename A>
+  Evaluation(const A &a, const ParentType &parentType)
+      : u{&a}, parentType{parentType} {
+    static_assert(pft::isConstruct<A>, "must be a construct");
   }
 
+  /// Evaluation classification predicates.
   constexpr bool isActionStmt() const {
     return visit(common::visitors{
         [](auto &r) { return pft::isActionStmt<std::decay_t<decltype(r)>>; }});
   }
-
-  constexpr bool isStmt() const {
+  constexpr bool isOtherStmt() const {
     return visit(common::visitors{
-        [](auto &r) {
-          using T = std::decay_t<decltype(r)>;
-          static constexpr bool isStmt{pft::isActionStmt<T> || isOtherStmt<T> ||
-                                       isConstructStmt<T>};
-          static_assert(!(isStmt && pft::isConstruct<T>),
-                        "statement classification is inconsistent");
-          return isStmt;
-        },
-    });
-  }
-  
-  constexpr bool isConstruct() const { return !isStmt(); }
-
-  /// Set the type of originating control flow type for this evaluation.
-  void setCFG(CFGAnnotation a, Evaluation *cstr) {
-    cfg = a;
-    setBranches(cstr);
+        [](auto &r) { return pft::isOtherStmt<std::decay_t<decltype(r)>>; }});
   }
-
-  /// Is this evaluation a control-flow origin? (The PFT must be annotated)
-  bool isControlOrigin() const { return cfg != CFGAnnotation::None; }
-
-  /// Is this evaluation a control-flow target? (The PFT must be annotated)
-  bool isControlTarget() const { return isTarget; }
-
-  /// Set the containsBranches flag iff this evaluation (a construct) contains
-  /// control flow
-  void setBranches() { containsBranches = true; }
-
-  EvaluationCollection *getConstructEvals() {
-    auto *evals{subs.get()};
-    if (isStmt() && !evals)
-      return nullptr;
-    if (isConstruct() && evals)
-      return evals;
-    llvm_unreachable("evaluation subs is inconsistent");
-    return nullptr;
+  constexpr bool isConstructStmt() const {
+    return visit(common::visitors{[](auto &r) {
+      return pft::isConstructStmt<std::decay_t<decltype(r)>>;
+    }});
   }
-
-  /// Set that the construct `cstr` (if not a nullptr) has branches.
-  static void setBranches(Evaluation *cstr) {
-    if (cstr)
-      cstr->setBranches();
+  constexpr bool isConstruct() const {
+    return visit(common::visitors{
+        [](auto &r) { return pft::isConstruct<std::decay_t<decltype(r)>>; }});
   }
 
-  EvalVariant u;
-  ParentType parent;
-  parser::CharBlock pos;
-  std::optional<parser::Label> lab;
-  std::unique_ptr<EvaluationCollection> subs; // construct sub-statements
-  CFGAnnotation cfg{CFGAnnotation::None};
-  bool isTarget{false};         // this evaluation is a control target
-  bool containsBranches{false}; // construct contains branches
+  bool LowerAsStructured() const;
+  bool LowerAsUnstructured() const;
+
+  // FIR generation looks primarily at PFT statement (leaf) nodes.  So members
+  // such as lexicalSuccessor and the various block fields are only applicable
+  // to statement nodes.  One exception is that an internal construct node is
+  // a convenient place for a constructExit link that applies to exits from any
+  // statement within the construct.  The controlSuccessor member is used for
+  // nonlexical successors, such as linking to a GOTO target.  For multiway
+  // branches, controlSuccessor is set to one of the targets (might as well be
+  // the first target).  Successor and exit links always target statements.
+  //
+  // An unstructured construct is one that contains some form of goto.  This
+  // is indicated by the isUnstructured member flag, which may be set on a
+  // statement and propagated to enclosing constructs.  This distinction allows
+  // a structured IF or DO statement to be materialized with custom structured
+  // FIR operations.  An unstructured statement is materialized as mlir
+  // operation sequences that include explicit branches.
+  //
+  // There are two mlir::Block members.  The block member is set for statements
+  // that begin a new block.  If a statement may have more than one associated
+  // block, this member must be the block that would be the target of a branch
+  // to the statement.  The prime example of a statement that may have multiple
+  // associated blocks is NonLabelDoStmt, which may have a loop preheader block
+  // for loop initialization code, and always has a header block that is the
+  // target of the loop back edge.  If the NonLabelDoStmt is a concurrent loop,
+  // there may be an arbitrary number of nested preheader, header, and mask
+  // blocks.  Any such additional blocks in the localBlocks member are local
+  // to a construct and cannot be the target of an unstructured branch.  For
+  // NonLabelDoStmt, the block member designates the preheader block, which may
+  // be absent if loop initialization code may be appended to a predecessor
+  // block.  The primary loop header block is localBlocks[0], with additional
+  // DO CONCURRENT blocks at localBlocks[1], etc.
+  //
+  // The printIndex member is only set for statements.  It is used for dumps
+  // and does not affect FIR generation.  It may also be helpful for debugging.
+
+  EvaluationVariant u;
+  ParentType parentType;
+  parser::CharBlock position{};
+  std::optional<parser::Label> label{};
+  std::unique_ptr<EvaluationList> evaluationList; // nested evaluations
+  Evaluation *parentConstruct{nullptr};  // set for nodes below the top level
+  Evaluation *lexicalSuccessor{nullptr}; // set for ActionStmt, ConstructStmt
+  Evaluation *controlSuccessor{nullptr}; // set for some statements
+  Evaluation *constructExit{nullptr};    // set for constructs
+  bool isNewBlock{false};                // evaluation begins a new basic block
+  bool isUnstructured{false};        // evaluation has unstructured control flow
+  bool skip{false};                  // evaluation has been processed in advance
+  class mlir::Block *block{nullptr}; // isNewBlock block
+  llvm::SmallVector<mlir::Block *, 1> localBlocks{}; // construct local blocks
+  int printIndex{0}; // (ActionStmt, ConstructStmt) evaluation index for dumps
 };
 
 /// A program is a list of program units.
-/// These units can be function like, module like, or block data
+/// These units can be function like, module like, or block data.
 struct ProgramUnit {
   template <typename A>
-  ProgramUnit(const A &ptr, const ParentType &parent)
-      : p{&ptr}, parent{parent} {}
+  ProgramUnit(const A &ptr, const ParentType &parentType)
+      : p{&ptr}, parentType{parentType} {}
   ProgramUnit(ProgramUnit &&) = default;
   ProgramUnit(const ProgramUnit &) = delete;
 
@@ -276,12 +246,11 @@ struct ProgramUnit {
       const parser::Submodule *, const parser::SeparateModuleSubprogram *,
       const parser::BlockData *>
       p;
-  ParentType parent;
+  ParentType parentType;
 };
 
-/// Function-like units have similar structure. They all can contain executable
-/// statements as well as other function-like units (internal procedures and
-/// function statements).
+/// Function-like units may contain evaluations (executable statements) and
+/// nested function-like units (internal procedures and function statements).
 struct FunctionLikeUnit : public ProgramUnit {
   // wrapper statements for function-like syntactic structures
   using FunctionStatement =
@@ -294,13 +263,13 @@ struct FunctionLikeUnit : public ProgramUnit {
                    const parser::Statement<parser::MpSubprogramStmt> *,
                    const parser::Statement<parser::EndMpSubprogramStmt> *>;
 
-  FunctionLikeUnit(const parser::MainProgram &f, const ParentType &parent);
+  FunctionLikeUnit(const parser::MainProgram &f, const ParentType &parentType);
   FunctionLikeUnit(const parser::FunctionSubprogram &f,
-                   const ParentType &parent);
+                   const ParentType &parentType);
   FunctionLikeUnit(const parser::SubroutineSubprogram &f,
-                   const ParentType &parent);
+                   const ParentType &parentType);
   FunctionLikeUnit(const parser::SeparateModuleSubprogram &f,
-                   const ParentType &parent);
+                   const ParentType &parentType);
   FunctionLikeUnit(FunctionLikeUnit &&) = default;
   FunctionLikeUnit(const FunctionLikeUnit &) = delete;
 
@@ -308,24 +277,23 @@ struct FunctionLikeUnit : public ProgramUnit {
     return std::holds_alternative<
         const parser::Statement<parser::EndProgramStmt> *>(endStmt);
   }
-  
   const parser::FunctionStmt *getFunction() {
     return getA<parser::FunctionStmt>();
   }
-  
   const parser::SubroutineStmt *getSubroutine() {
     return getA<parser::SubroutineStmt>();
   }
-  
-  const parser::MpSubprogramStmt *getMPSubp() {
+  const parser::MpSubprogramStmt *getMpSubprogram() {
     return getA<parser::MpSubprogramStmt>();
   }
 
   /// Anonymous programs do not have a begin statement
   std::optional<FunctionStatement> beginStmt;
   FunctionStatement endStmt;
-  EvaluationCollection evals;        // statements
-  std::list<FunctionLikeUnit> funcs; // internal procedures
+  EvaluationList evaluationList;
+  llvm::DenseMap<parser::Label, Evaluation *> labelEvaluationMap;
+  std::map<semantics::Symbol *, std::set<parser::Label>> assignSymbolLabelMap;
+  std::list<FunctionLikeUnit> containedFunctions;
 
 private:
   template <typename A>
@@ -339,8 +307,7 @@ struct FunctionLikeUnit : public ProgramUnit {
   }
 };
 
-/// Module-like units have similar structure. They all can contain a list of
-/// function-like units.
+/// Module-like units contain a list of function-like units.
 struct ModuleLikeUnit : public ProgramUnit {
   // wrapper statements for module-like syntactic structures
   using ModuleStatement =
@@ -349,19 +316,19 @@ struct ModuleLikeUnit : public ProgramUnit {
                    const parser::Statement<parser::SubmoduleStmt> *,
                    const parser::Statement<parser::EndSubmoduleStmt> *>;
 
-  ModuleLikeUnit(const parser::Module &m, const ParentType &parent);
-  ModuleLikeUnit(const parser::Submodule &m, const ParentType &parent);
+  ModuleLikeUnit(const parser::Module &m, const ParentType &parentType);
+  ModuleLikeUnit(const parser::Submodule &m, const ParentType &parentType);
   ~ModuleLikeUnit() = default;
   ModuleLikeUnit(ModuleLikeUnit &&) = default;
   ModuleLikeUnit(const ModuleLikeUnit &) = delete;
 
   ModuleStatement beginStmt;
   ModuleStatement endStmt;
-  std::list<FunctionLikeUnit> funcs;
+  std::list<FunctionLikeUnit> containedFunctions;
 };
 
 struct BlockDataUnit : public ProgramUnit {
-  BlockDataUnit(const parser::BlockData &bd, const ParentType &parent);
+  BlockDataUnit(const parser::BlockData &bd, const ParentType &parentType);
   BlockDataUnit(BlockDataUnit &&) = default;
   BlockDataUnit(const BlockDataUnit &) = delete;
 };
@@ -385,28 +352,11 @@ struct Program {
 
 } // namespace pft
 
-/// Create an PFT from the parse tree.
-///
-/// Build a light-weight tree over the parse-tree to help with lowering to FIR.
-/// It is named Pre-FIR Tree (PFT) to underline it has no other usage than
-/// helping lowering to FIR.  The PFT will capture pointers back into the parse
-/// tree, so the parse tree data structure may <em>not</em> be changed between
-/// the construction of the PFT and all of its uses.
-///
-/// The PFT captures a structured view of the program.  The program is a list of
-/// units.  Function like units will contain lists of evaluations.  Evaluations
-/// are either statements or constructs, where a construct contains a list of
-/// evaluations. The resulting PFT structure can then be used to create FIR.
+/// Create a PFT (Pre-FIR Tree) from the parse tree.
 std::unique_ptr<pft::Program> createPFT(const parser::Program &root);
 
-/// Decorate the PFT with control flow annotations
-///
-/// The PFT must be decorated with control-flow annotations to prepare it for
-/// use in generating a CFG-like structure.
-void annotateControl(pft::Program &pft);
-
-/// Dumper for displaying a PFT structure.
-void dumpPFT(llvm::raw_ostream &o, pft::Program &pft);
+/// Dumper for displaying a PFT.
+void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft);
 
 } // namespace Fortran::lower
 
diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 1e5564551d07..3355ba0286db 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -1959,7 +1959,8 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
 
     // Print the 'else' regions if it exists and has a block.
     auto &otherReg = otherRegion();
-    if (!otherReg.empty()) {
+    if (!otherReg.empty() && !otherReg.front().empty() &&
+        otherReg.front().front().isKnownNonTerminator()) {
       p << " otherwise";
       p.printRegion(otherReg, /*printEntryBlockArgs=*/false,
           /*printBlockTerminators=*/false);
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 3f2b361ebee0..72031b37b2ce 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -28,6 +28,16 @@
 #include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/CommandLine.h"
 
+#undef TODO
+#define TODO()                                                                 \
+  {                                                                            \
+    if (disableToDoAssertions)                                                 \
+      mlir::emitError(toLocation(), __FILE__)                                  \
+          << ":" << __LINE__ << " not implemented";                            \
+    else                                                                       \
+      assert(false && "not yet implemented");                                  \
+  }
+
 namespace {
 
 llvm::cl::opt<bool>
@@ -39,43 +49,16 @@ llvm::cl::opt<bool>
                           llvm::cl::desc("disable burnside bridge asserts"),
                           llvm::cl::init(false), llvm::cl::Hidden);
 
-#undef TODO
-#define TODO() assert(false && "not implemented yet")
-
-using SelectCaseConstruct = Fortran::parser::CaseConstruct;
-using SelectRankConstruct = Fortran::parser::SelectRankConstruct;
-using SelectTypeConstruct = Fortran::parser::SelectTypeConstruct;
-
-using CFGSinkListType = llvm::SmallVector<Fortran::lower::pft::Evaluation *, 2>;
-using CFGMapType =
-    llvm::DenseMap<Fortran::lower::pft::Evaluation *, CFGSinkListType *>;
-
-static constexpr bool isStopStmt(const Fortran::parser::StopStmt &stm) {
-  return std::get<Fortran::parser::StopStmt::Kind>(stm.t) ==
+static constexpr bool isStopStmt(const Fortran::parser::StopStmt &stmt) {
+  return std::get<Fortran::parser::StopStmt::Kind>(stmt.t) ==
          Fortran::parser::StopStmt::Kind::Stop;
 }
 
-// CfgBuilder implementation
-#include "CFGBuilder.h"
-
-#undef TODO
-#define TODO()                                                                 \
-  {                                                                            \
-    if (disableToDoAssertions)                                                 \
-      mlir::emitError(toLocation(), __FILE__)                                  \
-          << ":" << __LINE__ << " not implemented";                            \
-    else                                                                       \
-      assert(false && "not yet implemented");                                  \
-  }
-
 /// Converter from PFT to FIR
 ///
-/// After building the PFT and decorating it, the FirConverter processes that
-/// representation and lowers it to the FIR executable representation.
+/// After building the PFT, the FirConverter processes that representation
+/// and lowers it to the FIR executable representation.
 class FirConverter : public Fortran::lower::AbstractConverter {
-  using LabelMapType =
-      std::map<Fortran::lower::pft::Evaluation *, mlir::Block *>;
-  using Closure = std::function<void(const LabelMapType &)>;
 
   //
   // Helper function members
@@ -103,8 +86,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   mlir::FuncOp genFunctionFIR(llvm::StringRef callee,
                               mlir::FunctionType funcTy) {
-    if (auto func = Fortran::lower::getNamedFunction(module, callee))
+    if (auto func{Fortran::lower::getNamedFunction(module, callee)}) {
       return func;
+    }
     return createFunction(*this, callee, funcTy);
   }
 
@@ -118,9 +102,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                           },
                           [](auto *) { return false; },
                       },
-                      cstr->parent.p);
+                      cstr->parentType.p);
   }
-
   static const Fortran::parser::SubroutineStmt *
   inSubroutine(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
@@ -133,7 +116,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               return nullptr;
             },
         },
-        cstr->parent.p);
+        cstr->parentType.p);
   }
   static const Fortran::parser::FunctionStmt *
   inFunction(Fortran::lower::pft::Evaluation *cstr) {
@@ -147,58 +130,56 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               return nullptr;
             },
         },
-        cstr->parent.p);
+        cstr->parentType.p);
   }
   static const Fortran::parser::MpSubprogramStmt *
-  inMPSubp(Fortran::lower::pft::Evaluation *cstr) {
+  inMpSubprogram(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
         Fortran::common::visitors{
             [](Fortran::lower::pft::FunctionLikeUnit *c) {
-              return c->getMPSubp();
+              return c->getMpSubprogram();
+            },
+            [&](Fortran::lower::pft::Evaluation *c) {
+              return inMpSubprogram(c);
             },
-            [&](Fortran::lower::pft::Evaluation *c) { return inMPSubp(c); },
             [](auto *) -> const Fortran::parser::MpSubprogramStmt * {
               return nullptr;
             },
         },
-        cstr->parent.p);
+        cstr->parentType.p);
   }
 
-  template <typename A>
-  static const Fortran::semantics::SomeExpr *
-  getScalarExprOfTuple(const A &tuple) {
-    return Fortran::semantics::GetExpr(
-        std::get<Fortran::parser::ScalarLogicalExpr>(tuple));
+  void genFIRUnconditionalBranch(mlir::Block *targetBlock) {
+    assert(targetBlock && "missing unconditional target block");
+    builder->create<mlir::BranchOp>(toLocation(), targetBlock);
   }
-  template <typename A>
-  static const Fortran::semantics::SomeExpr *getExprOfTuple(const A &tuple) {
-    return Fortran::semantics::GetExpr(
-        std::get<Fortran::parser::LogicalExpr>(tuple));
-  }
-  /// Get the condition expression for a CondGoto evaluation
-  const Fortran::semantics::SomeExpr *
-  getEvaluationCondition(Fortran::lower::pft::Evaluation &eval) {
-    return eval.visit(Fortran::common::visitors{
-        [&](const Fortran::parser::IfStmt &stmt) {
-          return getScalarExprOfTuple(stmt.t);
-        },
-        [&](const Fortran::parser::IfThenStmt &stmt) {
-          return getScalarExprOfTuple(stmt.t);
-        },
-        [&](const Fortran::parser::ElseIfStmt &stmt) {
-          return getScalarExprOfTuple(stmt.t);
-        },
-        [&](const Fortran::parser::WhereConstructStmt &stmt) {
-          return getExprOfTuple(stmt.t);
-        },
-        [&](const Fortran::parser::MaskedElsewhereStmt &stmt) {
-          return getExprOfTuple(stmt.t);
-        },
-        [&](auto &) -> const Fortran::semantics::SomeExpr * {
-          mlir::emitError(toLocation(), "unexpected conditional branch case");
-          return nullptr;
-        },
-    });
+
+  void
+  genFIRUnconditionalBranch(Fortran::lower::pft::Evaluation *targetEvaluation) {
+    builder->create<mlir::BranchOp>(toLocation(), targetEvaluation->block);
+  }
+
+  void genFIRConditionalBranch(mlir::Value &cond, mlir::Block *trueTarget,
+                               mlir::Block *falseTarget) {
+    assert(trueTarget && "missing conditional branch true block");
+    assert(falseTarget && "missing conditional branch false block");
+    llvm::SmallVector<mlir::Value, 2> blk;
+    builder->create<mlir::CondBranchOp>(toLocation(), cond, trueTarget, blk,
+                                        falseTarget, blk);
+  }
+
+  void genFIRConditionalBranch(mlir::Value &cond,
+                               Fortran::lower::pft::Evaluation *trueTarget,
+                               Fortran::lower::pft::Evaluation *falseTarget) {
+    genFIRConditionalBranch(cond, trueTarget->block, falseTarget->block);
+  }
+
+  void genFIRConditionalBranch(const Fortran::parser::ScalarLogicalExpr &expr,
+                               Fortran::lower::pft::Evaluation *trueTarget,
+                               Fortran::lower::pft::Evaluation *falseTarget) {
+    mlir::Value cond{
+        createLogicalExprAsI1(toLocation(), Fortran::semantics::GetExpr(expr))};
+    genFIRConditionalBranch(cond, trueTarget->block, falseTarget->block);
   }
 
   //
@@ -215,13 +196,13 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       const Fortran::parser::Statement<Fortran::parser::EndProgramStmt> &stmt,
       std::string &, const Fortran::semantics::Symbol *&) {
     setCurrentPosition(stmt.source);
-    genFIR(stmt.statement);
+    genFIRProgramExit();
   }
   void
   genFIR(const Fortran::parser::Statement<Fortran::parser::FunctionStmt> &stmt,
          std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
+    auto &n{std::get<Fortran::parser::Name>(stmt.statement.t)};
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
     name = mangleName(*symbol);
@@ -237,7 +218,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       const Fortran::parser::Statement<Fortran::parser::SubroutineStmt> &stmt,
       std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
+    auto &n{std::get<Fortran::parser::Name>(stmt.statement.t)};
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
     name = mangleName(*symbol);
@@ -247,13 +228,14 @@ class FirConverter : public Fortran::lower::AbstractConverter {
              &stmt,
          std::string &, const Fortran::semantics::Symbol *&) {
     setCurrentPosition(stmt.source);
-    genFIR(stmt.statement);
+    genFIRProcedureExit(
+        static_cast<const Fortran::parser::SubroutineStmt *>(nullptr));
   }
   void genFIR(
       const Fortran::parser::Statement<Fortran::parser::MpSubprogramStmt> &stmt,
       std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n = stmt.statement.v;
+    auto &n{stmt.statement.v};
     name = n.ToString();
     symbol = n.symbol;
   }
@@ -261,8 +243,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   genFIR(const Fortran::parser::Statement<Fortran::parser::EndMpSubprogramStmt>
              &stmt,
          std::string &, const Fortran::semantics::Symbol *&) {
-    setCurrentPosition(stmt.source);
-    genFIR(stmt.statement);
+    genFIRProcedureExit(
+        static_cast<const Fortran::parser::MpSubprogramStmt *>(nullptr));
   }
 
   //
@@ -279,10 +261,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   ///
   /// Generate the cleanup block before the procedure exits
   void genFIRFunctionReturn(const Fortran::semantics::Symbol &functionSymbol) {
-    const auto &details =
-        functionSymbol.get<Fortran::semantics::SubprogramDetails>();
-    mlir::Value resultRef = localSymbols.lookupSymbol(details.result());
-    mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
+    const auto &details{
+        functionSymbol.get<Fortran::semantics::SubprogramDetails>()};
+    mlir::Value resultRef{localSymbols.lookupSymbol(details.result())};
+    mlir::Value r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
     builder->create<mlir::ReturnOp>(toLocation(), r);
   }
   template <typename A>
@@ -303,74 +285,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   // Statements that have control-flow semantics
   //
 
-  // Conditional goto control-flow semantics
-  void genFIREvalCondGoto(Fortran::lower::pft::Evaluation &eval) {
-    genFIR(eval);
-    auto targets = findTargetsOf(eval);
-    auto *expr = getEvaluationCondition(eval);
-    assert(expr && "condition expression missing");
-    auto cond = createLogicalExprAsI1(toLocation(), expr);
-    genFIRCondBranch(cond, targets[0], targets[1]);
-  }
-
-  void genFIRCondBranch(mlir::Value cond,
-                        Fortran::lower::pft::Evaluation *trueDest,
-                        Fortran::lower::pft::Evaluation *falseDest) {
-    using namespace std::placeholders;
-    localEdgeQ.emplace_back(std::bind(
-        [](mlir::OpBuilder *builder, mlir::Block *block, mlir::Value cnd,
-           Fortran::lower::pft::Evaluation *trueDest,
-           Fortran::lower::pft::Evaluation *falseDest, mlir::Location location,
-           const LabelMapType &map) {
-          llvm::SmallVector<mlir::Value, 2> blk;
-          builder->setInsertionPointToEnd(block);
-          auto tdp = map.find(trueDest);
-          auto fdp = map.find(falseDest);
-          assert(tdp != map.end() && fdp != map.end());
-          builder->create<mlir::CondBranchOp>(location, cnd, tdp->second, blk,
-                                              fdp->second, blk);
-        },
-        builder, builder->getInsertionBlock(), cond, trueDest, falseDest,
-        toLocation(), _1));
-  }
-
-  // Goto control-flow semantics
-  //
-  // These are unconditional jumps. There is nothing to evaluate.
-  void genFIREvalGoto(Fortran::lower::pft::Evaluation &eval) {
-    using namespace std::placeholders;
-    localEdgeQ.emplace_back(std::bind(
-        [](mlir::OpBuilder *builder, mlir::Block *block,
-           Fortran::lower::pft::Evaluation *dest, mlir::Location location,
-           const LabelMapType &map) {
-          builder->setInsertionPointToEnd(block);
-          assert(map.find(dest) != map.end() && "no destination");
-          builder->create<mlir::BranchOp>(location, map.find(dest)->second);
-        },
-        builder, builder->getInsertionBlock(), findSinkOf(eval), toLocation(),
-        _1));
-  }
-
-  // Indirect goto control-flow semantics
-  //
-  // For assigned gotos, which is an obsolescent feature. Lower to a switch.
-  void genFIREvalIndGoto(Fortran::lower::pft::Evaluation &eval) {
-    genFIR(eval);
-    // FIXME
-  }
-
-  // IO statements that have control-flow semantics
-  //
-  // First lower the IO statement and then do the multiway switch op
-  void genFIREvalIoSwitch(Fortran::lower::pft::Evaluation &eval) {
-    genFIR(eval);
-    genFIRIOSwitch(eval);
-  }
-  void genFIRIOSwitch(Fortran::lower::pft::Evaluation &) { TODO(); }
-
-  // Iterative loop control-flow semantics
-  void genFIREvalIterative(Fortran::lower::pft::Evaluation &) { TODO(); }
-
   void switchInsertionPointToWhere(fir::WhereOp &where) {
     builder->setInsertionPointToStart(&where.whereRegion().front());
   }
@@ -379,130 +293,26 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   template <typename A>
   void genWhereCondition(fir::WhereOp &where, const A *stmt) {
-    auto cond = createLogicalExprAsI1(
+    auto cond{createLogicalExprAsI1(
         toLocation(),
         Fortran::semantics::GetExpr(
-            std::get<Fortran::parser::ScalarLogicalExpr>(stmt->t)));
+            std::get<Fortran::parser::ScalarLogicalExpr>(stmt->t)))};
     where = builder->create<fir::WhereOp>(toLocation(), cond, true);
     switchInsertionPointToWhere(where);
   }
 
-  mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x) {
-    return builder->create<fir::ConvertOp>(
-        toLocation(), mlir::IndexType::get(&mlirContext),
-        genExprValue(*Fortran::semantics::GetExpr(x)));
+  mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x,
+                              mlir::Type t) {
+    mlir::Value v{genExprValue(*Fortran::semantics::GetExpr(x))};
+    return v.getType() == t
+               ? v
+               : builder->create<fir::ConvertOp>(toLocation(), t, v);
   }
 
-  /// Structured control op (`fir.loop`, `fir.where`)
-  ///
-  /// Convert a DoConstruct to a `fir.loop` op.
-  /// Convert an IfConstruct to a `fir.where` op.
-  ///
-  void genFIREvalStructuredOp(Fortran::lower::pft::Evaluation &eval) {
-    // TODO: array expressions, FORALL, WHERE ...
-
-    // process the list of Evaluations
-    assert(eval.subs && "eval must have a body");
-    auto *insPt = builder->getInsertionBlock();
-
-    if (const auto *doConstruct{eval.getIf<Fortran::parser::DoConstruct>()}) {
-      if (const auto &loopControl{doConstruct->GetLoopControl()}) {
-        std::visit(
-            Fortran::common::visitors{
-                [&](const Fortran::parser::LoopControl::Bounds &x) {
-                  mlir::Value lo = genFIRLoopIndex(x.lower);
-                  mlir::Value hi = genFIRLoopIndex(x.upper);
-                  auto step =
-                      x.step.has_value()
-                          ? genExprValue(*Fortran::semantics::GetExpr(*x.step))
-                          : mlir::Value{};
-                  auto *sym = x.name.thing.symbol;
-                  Fortran::lower::LoopBuilder{*builder, toLocation()}
-                      .createLoop(lo, hi, step,
-                                  [&](Fortran::lower::OpBuilderWrapper &handler,
-                                      mlir::Value index) {
-                                    // TODO: should push this cast down to the
-                                    // uses
-                                    auto cvt = handler.create<fir::ConvertOp>(
-                                        genType(*sym), index);
-                                    localSymbols.pushShadowSymbol(*sym, cvt);
-                                    for (auto &e : *eval.subs) {
-                                      genFIR(e);
-                                    }
-                                    localSymbols.popShadowSymbol();
-                                  });
-                },
-                [&](const Fortran::parser::ScalarLogicalExpr &) {
-                  // we should never reach here
-                  mlir::emitError(toLocation(), "loop lacks iteration space");
-                },
-                [&](const Fortran::parser::LoopControl::Concurrent &x) {
-                  // FIXME: can project a multi-dimensional space
-                  Fortran::lower::LoopBuilder{*builder, toLocation()}
-                      .createLoop(
-                          mlir::Value{}, mlir::Value{},
-                          [&](Fortran::lower::OpBuilderWrapper &, mlir::Value) {
-                            for (auto &e : *eval.subs) {
-                              genFIR(e);
-                            }
-                          });
-                },
-            },
-            loopControl->u);
-      } else {
-        // TODO: Infinite loop: 11.1.7.4.1 par 2
-        TODO();
-      }
-    } else if (eval.isA<Fortran::parser::IfConstruct>()) {
-      // Construct fir.where
-      fir::WhereOp where;
-      for (auto &e : *eval.subs) {
-        if (auto *s{e.getIf<Fortran::parser::IfThenStmt>()}) {
-          // fir.where op
-          genWhereCondition(where, s);
-        } else if (auto *s{e.getIf<Fortran::parser::ElseIfStmt>()}) {
-          // otherwise block, then nested fir.where
-          switchInsertionPointToOtherwise(where);
-          genWhereCondition(where, s);
-        } else if (e.isA<Fortran::parser::ElseStmt>()) {
-          // otherwise block
-          switchInsertionPointToOtherwise(where);
-        } else if (e.isA<Fortran::parser::EndIfStmt>()) {
-          // close all open fir.where ops
-          builder->clearInsertionPoint();
-        } else {
-          genFIR(e);
-        }
-      }
-    } else {
-      assert(false && "not yet implemented");
-    }
-    builder->setInsertionPointToEnd(insPt);
-  }
-
-  // Return from subprogram control-flow semantics
-  void genFIREvalReturn(Fortran::lower::pft::Evaluation &eval) {
-    // Handled case-by-case
-    // FIXME: think about moving the case code here
-  }
-
-  // Multiway switch control-flow semantics
-  void genFIREvalSwitch(Fortran::lower::pft::Evaluation &eval) {
-    genFIR(eval);
-    // FIXME
-  }
-
-  // Terminate process control-flow semantics
-  //
-  // Call a runtime routine that does not return
-  void genFIREvalTerminate(Fortran::lower::pft::Evaluation &eval) {
-    genFIR(eval);
-    builder->create<fir::UnreachableOp>(toLocation());
+  mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x) {
+    return genFIRLoopIndex(x, mlir::IndexType::get(&mlirContext));
   }
 
-  // No control-flow
-  void genFIREvalNone(Fortran::lower::pft::Evaluation &eval) { genFIR(eval); }
-
   mlir::FuncOp getFunc(llvm::StringRef name, mlir::FunctionType ty) {
     if (auto func = Fortran::lower::getNamedFunction(module, name)) {
       assert(func.getType() == ty);
@@ -516,7 +326,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   /// 1. Determine what function is being called/dispatched to
   /// 2. Build a tuple of arguments to be passed to that function
   /// 3. Emit fir.call/fir.dispatch on arguments
-  void genFIR(const Fortran::parser::CallStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CallStmt &stmt) {
     llvm::SmallVector<mlir::Type, 8> argTy;
     llvm::SmallVector<mlir::Type, 2> resTy;
     llvm::StringRef funName;
@@ -525,7 +336,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     std::visit(Fortran::common::visitors{
                    [&](const Fortran::parser::Name &name) {
                      auto *sym = name.symbol;
-                     auto n = sym->name();
+                     auto n{sym->name()};
                      funName = llvm::StringRef{n.begin(), n.size()};
                      auto &details =
                          sym->get<Fortran::semantics::SubprogramDetails>();
@@ -537,13 +348,13 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                },
                std::get<Fortran::parser::ProcedureDesignator>(stmt.v.t).u);
     for (auto *d : argsList) {
-      Fortran::semantics::SymbolRef sr = *d;
+      Fortran::semantics::SymbolRef sr{*d};
       // FIXME:
       argTy.push_back(fir::ReferenceType::get(genType(sr)));
     }
-    auto funTy = mlir::FunctionType::get(argTy, resTy, builder->getContext());
+    auto funTy{mlir::FunctionType::get(argTy, resTy, builder->getContext())};
     // FIXME: mangle name
-    mlir::FuncOp func = getFunc(funName, funTy);
+    mlir::FuncOp func{getFunc(funName, funTy)};
     (void)func; // FIXME
     std::vector<mlir::Value> actuals;
     for (auto &aa :
@@ -574,51 +385,338 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                                  builder->getSymbolRefAttr(funName), actuals);
   }
 
-  void genFIR(const Fortran::parser::IfStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::WaitStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::WhereStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::ComputedGotoStmt &stmt) {
-    auto *exp = Fortran::semantics::GetExpr(
-        std::get<Fortran::parser::ScalarIntExpr>(stmt.t));
-    auto e1 = genExprValue(*exp);
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::IfStmt &stmt) {
+    if (eval.LowerAsUnstructured()) {
+      genFIRConditionalBranch(
+          std::get<Fortran::parser::ScalarLogicalExpr>(stmt.t),
+          eval.lexicalSuccessor, eval.controlSuccessor);
+      return;
+    }
+
+    // Generate fir.where.
+    mlir::Block *ifStmtBlock{builder->getInsertionBlock()};
+    fir::WhereOp where;
+    genWhereCondition(where, &stmt);
+    genFIR(*eval.lexicalSuccessor, false);
+    eval.lexicalSuccessor->skip = true;
+    builder->setInsertionPointToEnd(ifStmtBlock);
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::WaitStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::WhereStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ComputedGotoStmt &stmt) {
+    auto *exp{Fortran::semantics::GetExpr(
+        std::get<Fortran::parser::ScalarIntExpr>(stmt.t))};
+    auto e1{genExprValue(*exp)};
     (void)e1;
     TODO();
   }
-  void genFIR(const Fortran::parser::ForallStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::ArithmeticIfStmt &stmt) {
-    auto *exp =
-        Fortran::semantics::GetExpr(std::get<Fortran::parser::Expr>(stmt.t));
-    auto e1 = genExprValue(*exp);
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ForallStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ArithmeticIfStmt &stmt) {
+    auto *exp{
+        Fortran::semantics::GetExpr(std::get<Fortran::parser::Expr>(stmt.t))};
+    auto e1{genExprValue(*exp)};
     (void)e1;
     TODO();
   }
-  void genFIR(const Fortran::parser::AssignedGotoStmt &) { TODO(); }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::AssignedGotoStmt &) {
+    TODO();
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::AssociateConstruct &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::BlockConstruct &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ChangeTeamConstruct &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CriticalConstruct &) {
+    TODO();
+  }
+
+  // Information for generating a structured or unstructured increment loop.
+  struct IncrementLoopInfo {
+    IncrementLoopInfo(
+        Fortran::semantics::Symbol *sym,
+        const Fortran::parser::ScalarExpr &lowerExpr,
+        const Fortran::parser::ScalarExpr &upperExpr,
+        const std::optional<Fortran::parser::ScalarExpr> &stepExpr,
+        mlir::Type type, mlir::Block *preheader)
+        : loopVariableSym{sym}, lowerExpr{lowerExpr}, upperExpr{upperExpr},
+          stepExpr{stepExpr}, loopVariableType{type} {}
+
+    bool isStructured() const { return headerBlock == nullptr; }
+
+    // Data members for both structured and unstructured loops.
+    Fortran::semantics::Symbol *loopVariableSym;
+    const Fortran::parser::ScalarExpr &lowerExpr;
+    const Fortran::parser::ScalarExpr &upperExpr;
+    const std::optional<Fortran::parser::ScalarExpr> &stepExpr;
+    mlir::Type loopVariableType;
+    mlir::Value loopVariable{mlir::Value{}};
+    mlir::Value stepValue{mlir::Value{}}; // possible uses in multiple blocks
+
+    // Data members for structured loops.
+    fir::LoopOp doLoop{};
+    mlir::OpBuilder::InsertPoint insertionPoint{};
+
+    // Data members for unstructured loops.
+    mlir::Value tripVariable{mlir::Value{}};
+    mlir::Block *headerBlock{nullptr};    // loop entry and test block
+    mlir::Block *bodyBlock{nullptr};      // first loop body block
+    mlir::Block *successorBlock{nullptr}; // loop exit target block
+  };
+
+  /// Generate FIR for a DO construct.  There are six variants:
+  ///  - unstructured infinite and while loops
+  ///  - structured and unstructured increment loops
+  ///  - structured and unstructured concurrent loops
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::DoConstruct &) {
+    bool unstructuredContext{eval.LowerAsUnstructured()};
+    Fortran::lower::pft::Evaluation &doStmtEval{eval.evaluationList->front()};
+    auto *doStmt{doStmtEval.getIf<Fortran::parser::NonLabelDoStmt>()};
+    assert(doStmt && "missing DO statement");
+    const auto &loopControl{
+        std::get<std::optional<Fortran::parser::LoopControl>>(doStmt->t)};
+    llvm::SmallVector<IncrementLoopInfo, 1> incrementLoopInfo;
+    const Fortran::parser::ScalarLogicalExpr *whileCondition{nullptr};
+    bool infiniteLoop{!loopControl.has_value()};
+    if (infiniteLoop) {
+      assert(unstructuredContext && "infinite loop must be unstructured");
+      startBlock(doStmtEval.localBlocks[0]); // header block
+    } else if ((whileCondition =
+                    std::get_if<Fortran::parser::ScalarLogicalExpr>(
+                        &loopControl->u))) {
+      assert(unstructuredContext && "while loop must be unstructured");
+      startBlock(doStmtEval.localBlocks[0]); // header block
+      genFIRConditionalBranch(*whileCondition, doStmtEval.lexicalSuccessor,
+                              doStmtEval.parentConstruct->constructExit);
+    } else if (const auto *bounds{
+                   std::get_if<Fortran::parser::LoopControl::Bounds>(
+                       &loopControl->u)}) {
+      // "Normal" increment loop.
+      incrementLoopInfo.emplace_back(IncrementLoopInfo(
+          bounds->name.thing.symbol, bounds->lower, bounds->upper, bounds->step,
+          genType(*bounds->name.thing.symbol), builder->getInsertionBlock()));
+      if (unstructuredContext) {
+        maybeStartBlock(doStmtEval.block); // preheader block
+        incrementLoopInfo[0].headerBlock = doStmtEval.localBlocks[0];
+        incrementLoopInfo[0].bodyBlock = doStmtEval.lexicalSuccessor->block;
+        incrementLoopInfo[0].successorBlock =
+            doStmtEval.parentConstruct->constructExit->block;
+      }
+    } else {
+      const auto *concurrentInfo{
+          std::get_if<Fortran::parser::LoopControl::Concurrent>(
+              &loopControl->u)};
+      assert(concurrentInfo && "DO loop variant is invalid");
+      TODO();
+      // Add entries to incrementLoopInfo.  (Define extra members for a mask.)
+    }
+    for (size_t i{0}, n{incrementLoopInfo.size()}; i < n; ++i) {
+      genFIRIncrementLoopBegin(incrementLoopInfo[i]);
+    }
+
+    // Generate loop body code.
+    for (auto &e : *eval.evaluationList) {
+      genFIR(e, unstructuredContext);
+    }
 
-  void genFIR(const Fortran::parser::AssociateConstruct &) { TODO(); }
-  void genFIR(const Fortran::parser::BlockConstruct &) { TODO(); }
-  void genFIR(const Fortran::parser::ChangeTeamConstruct &) { TODO(); }
-  void genFIR(const Fortran::parser::CriticalConstruct &) { TODO(); }
-  void genFIR(const Fortran::parser::DoConstruct &) { TODO(); }
-  void genFIR(const Fortran::parser::IfConstruct &) { TODO(); }
+    // Generate end loop code.
+    if (infiniteLoop || whileCondition) {
+      genFIRUnconditionalBranch(doStmtEval.localBlocks[0]);
+    } else {
+      for (size_t i{incrementLoopInfo.size()}; i > 0;) {
+        genFIRIncrementLoopEnd(incrementLoopInfo[--i]);
+      }
+    }
+  }
 
-  void genFIR(const SelectCaseConstruct &) { TODO(); }
-  void genFIR(const SelectRankConstruct &) { TODO(); }
-  void genFIR(const SelectTypeConstruct &) { TODO(); }
+  /// Generate FIR to begin a structured or unstructured increment loop.
+  void genFIRIncrementLoopBegin(IncrementLoopInfo &info) {
+    mlir::Location location{toLocation()};
+    mlir::Type type{info.isStructured()
+                        ? mlir::IndexType::get(builder->getContext())
+                        : info.loopVariableType};
+    mlir::Value lowerValue{genFIRLoopIndex(info.lowerExpr, type)};
+    mlir::Value upperValue{genFIRLoopIndex(info.upperExpr, type)};
+    if (info.stepExpr.has_value()) {
+      info.stepValue = genFIRLoopIndex(*info.stepExpr, type);
+    }
+    info.loopVariable = createTemporary(location, *info.loopVariableSym);
+
+    // Structured loop - generate fir.loop.
+    if (info.isStructured()) {
+      info.insertionPoint = builder->saveInsertionPoint();
+      llvm::SmallVector<mlir::Value, 1> stepVector;
+      if (info.stepValue) {
+        stepVector.push_back(info.stepValue);
+      }
+      info.doLoop = builder->create<fir::LoopOp>(location, lowerValue,
+                                                 upperValue, stepVector);
+      builder->setInsertionPointToStart(info.doLoop.getBody());
+      mlir::Value shadow{builder->create<fir::ConvertOp>(
+          location, info.loopVariableType, info.doLoop.getInductionVar())};
+      localSymbols.pushShadowSymbol(*info.loopVariableSym, shadow);
+      return;
+    }
 
-  void genFIR(const Fortran::parser::WhereConstruct &) { TODO(); }
+    // Unstructured loop preheader code - initialize tripVariable, loopVariable.
+    if (!info.stepValue) {
+      info.stepValue = builder->create<mlir::ConstantOp>(
+          location, builder->getIntegerAttr(info.loopVariableType, 1));
+    }
+    mlir::Value tripCount;
+    tripCount = builder->create<mlir::SubIOp>(location, upperValue, lowerValue);
+    tripCount =
+        builder->create<mlir::AddIOp>(location, tripCount, info.stepValue);
+    if (info.stepExpr.has_value()) {
+      tripCount = builder->create<mlir::SignedDivIOp>(location, tripCount,
+                                                      info.stepValue);
+    }
+    info.tripVariable = Fortran::lower::createTemporary(
+        location, *builder, localSymbols, info.loopVariableType, nullptr);
+    builder->create<fir::StoreOp>(location, tripCount, info.tripVariable);
+    builder->create<fir::StoreOp>(location, lowerValue, info.loopVariable);
+
+    // Unstructured loop header code - generate loop condition.
+    startBlock(info.headerBlock);
+    mlir::Value tripVariable{
+        builder->create<fir::LoadOp>(location, info.tripVariable)};
+    mlir::Value zero{builder->create<mlir::ConstantOp>(
+        location, builder->getIntegerAttr(info.loopVariableType, 0))};
+    mlir::Value cond{builder->create<mlir::CmpIOp>(
+        location, mlir::CmpIPredicate::sgt, tripVariable, zero)};
+    genFIRConditionalBranch(cond, info.bodyBlock, info.successorBlock);
+  }
+
+  /// Generate FIR to end a structured or unstructured increment loop.
+  void genFIRIncrementLoopEnd(IncrementLoopInfo &info) {
+    mlir::Location location{toLocation()};
+    if (info.isStructured()) {
+      // End fir.loop.
+      localSymbols.popShadowSymbol();
+      builder->restoreInsertionPoint(info.insertionPoint);
+      assert(info.doLoop.hasLastValue() && "loop must have a result");
+      mlir::Value result{builder->create<fir::ConvertOp>(
+          location, info.loopVariableType, info.doLoop.lastVal()[0])};
+      builder->create<fir::StoreOp>(location, result, info.loopVariable);
+      return;
+    }
+
+    // Unstructured loop - increment loopVariable.
+    mlir::Value loopVariable{
+        builder->create<fir::LoadOp>(location, info.loopVariable)};
+    loopVariable =
+        builder->create<mlir::AddIOp>(location, loopVariable, info.stepValue);
+    builder->create<fir::StoreOp>(location, loopVariable, info.loopVariable);
+
+    // Unstructured loop - decrement tripVariable.
+    mlir::Value tripVariable{
+        builder->create<fir::LoadOp>(location, info.tripVariable)};
+    mlir::Value one{builder->create<mlir::ConstantOp>(
+        location, builder->getIntegerAttr(info.loopVariableType, 1))};
+    tripVariable = builder->create<mlir::SubIOp>(location, tripVariable, one);
+    builder->create<fir::StoreOp>(location, tripVariable, info.tripVariable);
+    genFIRUnconditionalBranch(info.headerBlock);
+  }
+
+  /// Generate structured or unstructured FIR for an IF construct.
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::IfConstruct &) {
+    if (eval.LowerAsStructured()) {
+      // Structured fir.where nest.
+      fir::WhereOp where;
+      mlir::OpBuilder::InsertPoint insertionPoint{
+          builder->saveInsertionPoint()};
+      for (auto &e : *eval.evaluationList) {
+        if (auto *s{e.getIf<Fortran::parser::IfThenStmt>()}) {
+          // fir.where op
+          genWhereCondition(where, s);
+        } else if (auto *s{e.getIf<Fortran::parser::ElseIfStmt>()}) {
+          // otherwise block, then nested fir.where
+          switchInsertionPointToOtherwise(where);
+          genWhereCondition(where, s);
+        } else if (e.isA<Fortran::parser::ElseStmt>()) {
+          // otherwise block
+          switchInsertionPointToOtherwise(where);
+        } else {
+          genFIR(e, false);
+        }
+      }
+      builder->restoreInsertionPoint(insertionPoint);
+      return;
+    }
+
+    // Unstructured branch sequence.
+    for (auto &e : *eval.evaluationList) {
+      if (auto *s{e.getIf<Fortran::parser::IfThenStmt>()}) {
+        maybeStartBlock(e.block);
+        genFIRConditionalBranch(
+            std::get<Fortran::parser::ScalarLogicalExpr>(s->t),
+            e.lexicalSuccessor, e.controlSuccessor);
+      } else if (auto *s{e.getIf<Fortran::parser::ElseIfStmt>()}) {
+        startBlock(e.block);
+        genFIRConditionalBranch(
+            std::get<Fortran::parser::ScalarLogicalExpr>(s->t),
+            e.lexicalSuccessor, e.controlSuccessor);
+      } else {
+        genFIR(e);
+      }
+    }
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CaseConstruct &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SelectRankConstruct &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SelectTypeConstruct &) {
+    TODO();
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::WhereConstruct &) {
+    TODO();
+  }
 
   /// Lower FORALL construct (See 10.2.4)
-  void genFIR(const Fortran::parser::ForallConstruct &forall) {
-    auto &stmt = std::get<
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ForallConstruct &forall) {
+    auto &stmt{std::get<
         Fortran::parser::Statement<Fortran::parser::ForallConstructStmt>>(
-        forall.t);
+        forall.t)};
     setCurrentPosition(stmt.source);
-    auto &fas = stmt.statement;
-    auto &ctrl =
+    auto &fas{stmt.statement};
+    auto &ctrl{
         std::get<
             Fortran::common::Indirection<Fortran::parser::ConcurrentHeader>>(
             fas.t)
-            .value();
+            .value()};
     (void)ctrl;
     for (auto &s :
          std::get<std::list<Fortran::parser::ForallBodyConstruct>>(forall.t)) {
@@ -627,67 +725,148 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               [&](const Fortran::parser::Statement<
                   Fortran::parser::ForallAssignmentStmt> &b) {
                 setCurrentPosition(b.source);
-                genFIR(b.statement);
+                // genFIR(eval, b.statement);
               },
               [&](const Fortran::parser::Statement<Fortran::parser::WhereStmt>
                       &b) {
                 setCurrentPosition(b.source);
-                genFIR(b.statement);
+                // genFIR(eval, b.statement);
+              },
+              [&](const Fortran::parser::WhereConstruct &b) {
+                // genFIR(eval, b);
               },
-              [&](const Fortran::parser::WhereConstruct &b) { genFIR(b); },
               [&](const Fortran::common::Indirection<
-                  Fortran::parser::ForallConstruct> &b) { genFIR(b.value()); },
+                  Fortran::parser::ForallConstruct> &b) {
+                // genFIR(eval, b.value());
+              },
               [&](const Fortran::parser::Statement<Fortran::parser::ForallStmt>
                       &b) {
                 setCurrentPosition(b.source);
-                genFIR(b.statement);
+                // genFIR(eval, b.statement);
               },
           },
           s.u);
     }
     TODO();
   }
-  void genFIR(const Fortran::parser::ForallAssignmentStmt &s) {
-    std::visit([&](auto &b) { genFIR(b); }, s.u);
-  }
-
-  void genFIR(const Fortran::parser::CompilerDirective &) { TODO(); }
-  void genFIR(const Fortran::parser::OpenMPConstruct &) { TODO(); }
-  void genFIR(const Fortran::parser::OmpEndLoopDirective &) { TODO(); }
-
-  void genFIR(const Fortran::parser::AssociateStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EndAssociateStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::BlockStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EndBlockStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::SelectCaseStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::CaseStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EndSelectStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::ChangeTeamStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EndChangeTeamStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::CriticalStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EndCriticalStmt &) { TODO(); }
-
-  // Do loop is handled by EvalIterative(), EvalStructuredOp()
-  void genFIR(const Fortran::parser::NonLabelDoStmt &) {} // do nothing
-  void genFIR(const Fortran::parser::EndDoStmt &) {}      // do nothing
-
-  // If-Then-Else is handled by EvalCondGoto(), EvalStructuredOp()
-  void genFIR(const Fortran::parser::IfThenStmt &) {} // do nothing
-  void genFIR(const Fortran::parser::ElseIfStmt &) {} // do nothing
-  void genFIR(const Fortran::parser::ElseStmt &) {}   // do nothing
-  void genFIR(const Fortran::parser::EndIfStmt &) {}  // do nothing
-
-  void genFIR(const Fortran::parser::SelectRankStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::SelectRankCaseStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::SelectTypeStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::TypeGuardStmt &) { TODO(); }
-
-  void genFIR(const Fortran::parser::WhereConstructStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::MaskedElsewhereStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::ElsewhereStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EndWhereStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::ForallConstructStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EndForallStmt &) { TODO(); }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ForallAssignmentStmt &s) {
+    // std::visit([&](auto &b) { genFIR(b); }, s.u);  // ...
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CompilerDirective &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::OpenMPConstruct &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::OmpEndLoopDirective &) {
+    TODO();
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::AssociateStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndAssociateStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::BlockStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndBlockStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SelectCaseStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CaseStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndSelectStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ChangeTeamStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndChangeTeamStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CriticalStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndCriticalStmt &) {
+    TODO();
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::NonLabelDoStmt &) {} // nop
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndDoStmt &) {} // nop
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::IfThenStmt &) {} // nop
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ElseIfStmt &) {} // nop
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ElseStmt &) {} // nop
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndIfStmt &) {} // nop
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SelectRankStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SelectRankCaseStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SelectTypeStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::TypeGuardStmt &) {
+    TODO();
+  }
+
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::WhereConstructStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::MaskedElsewhereStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ElsewhereStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndWhereStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ForallConstructStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndForallStmt &) {
+    TODO();
+  }
 
   //
   // Statements that do not have control-flow semantics
@@ -695,79 +874,94 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   // IO statements (see io.h)
 
-  void genFIR(const Fortran::parser::BackspaceStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::BackspaceStmt &stmt) {
     genBackspaceStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::CloseStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CloseStmt &stmt) {
     genCloseStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::EndfileStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EndfileStmt &stmt) {
     genEndfileStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::FlushStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::FlushStmt &stmt) {
     genFlushStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::InquireStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::InquireStmt &stmt) {
     genInquireStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::OpenStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::OpenStmt &stmt) {
     genOpenStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::PrintStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::PrintStmt &stmt) {
     genPrintStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::ReadStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ReadStmt &stmt) {
     genReadStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::RewindStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::RewindStmt &stmt) {
     genRewindStatement(*this, stmt);
   }
-  void genFIR(const Fortran::parser::WriteStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::WriteStmt &stmt) {
     genWriteStatement(*this, stmt);
   }
 
-  void genFIR(const Fortran::parser::AllocateStmt &) { TODO(); }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::AllocateStmt &) {
+    TODO();
+  }
 
-  void
-  genCharacterAssignement(const Fortran::evaluate::Assignment &assignment) {
+  void genCharacterAssignment(const Fortran::evaluate::Assignment &assignment) {
     // Helper to get address and length from an Expr that is a character
     // variable designator
-    auto getAddrAndLength =
-        [&](const Fortran::lower::SomeExpr &charDesignatorExpr)
-        -> Fortran::lower::CharacterOpsBuilder::CharValue {
-      mlir::Value addr = genExprAddr(charDesignatorExpr);
-      const auto &charExpr =
-          std::get<Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
-              charDesignatorExpr.u);
-      auto lenExpr = charExpr.LEN();
-      assert(lenExpr && "could not get expression to compute character length");
-      mlir::Value len =
-          genExprValue(Fortran::evaluate::AsGenericExpr(std::move(*lenExpr)));
-      return Fortran::lower::CharacterOpsBuilder::CharValue{addr, len};
-    };
+    auto getAddrAndLength{
+        [&](const Fortran::semantics::SomeExpr &charDesignatorExpr)
+            -> Fortran::lower::CharacterOpsBuilder::CharValue {
+          mlir::Value addr = genExprAddr(charDesignatorExpr);
+          const auto &charExpr{std::get<
+              Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
+              charDesignatorExpr.u)};
+          std::optional<
+              Fortran::evaluate::Expr<Fortran::evaluate::SubscriptInteger>>
+              lenExpr{charExpr.LEN()};
+          assert(lenExpr &&
+                 "could not get expression to compute character length");
+          mlir::Value len{genExprValue(
+              Fortran::evaluate::AsGenericExpr(std::move(*lenExpr)))};
+          return Fortran::lower::CharacterOpsBuilder::CharValue{addr, len};
+        }};
 
     Fortran::lower::CharacterOpsBuilder charBuilder{*builder, toLocation()};
 
     // RHS evaluation.
     // FIXME:  Only works with rhs that are variable reference.
     // Other expression evaluation are not simple copies.
-    auto rhs = getAddrAndLength(assignment.rhs);
+    auto rhs{getAddrAndLength(assignment.rhs)};
     // A temp is needed to evaluate rhs until proven it does not depend on lhs.
-    auto tempToEvalRhs =
-        charBuilder.createTemp(rhs.getCharacterType(), rhs.len);
+    auto tempToEvalRhs{charBuilder.createTemp(rhs.getCharacterType(), rhs.len)};
     charBuilder.createCopy(tempToEvalRhs, rhs, rhs.len);
 
     // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
-    auto lhs = getAddrAndLength(assignment.lhs);
-    auto cmpLen = charBuilder.create<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
-                                                   lhs.len, rhs.len);
-    auto copyCount =
-        charBuilder.create<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
+    auto lhs{getAddrAndLength(assignment.lhs)};
+    auto cmpLen{charBuilder.create<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
+                                                 lhs.len, rhs.len)};
+    auto copyCount{
+        charBuilder.create<mlir::SelectOp>(cmpLen, lhs.len, rhs.len)};
     charBuilder.createCopy(lhs, tempToEvalRhs, copyCount);
     charBuilder.createPadding(lhs, copyCount, lhs.len);
   }
 
-  void genFIR(const Fortran::parser::AssignmentStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::AssignmentStmt &stmt) {
     assert(stmt.typedAssignment && stmt.typedAssignment->v &&
            "assignment analysis failed");
     const auto &assignment = *stmt.typedAssignment->v;
@@ -807,7 +1001,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                   break;
                 case Fortran::lower::CharacterCat:
                   // Fortran 2018 10.2.1.3 p10 and p11
-                  genCharacterAssignement(assignment);
+                  genCharacterAssignment(assignment);
                   break;
                 case Fortran::lower::DerivedCat:
                   // Fortran 2018 10.2.1.3 p12 and p13
@@ -832,19 +1026,29 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         assignment.u);
   }
 
-  void genFIR(const Fortran::parser::ContinueStmt &) {} // do nothing
-  void genFIR(const Fortran::parser::DeallocateStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EventPostStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ContinueStmt &) {} // nop
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::DeallocateStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EventPostStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Fortran::parser::EventWaitStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EventWaitStmt &) {
     // call some runtime routine
     TODO();
   }
 
-  void genFIR(const Fortran::parser::FormTeamStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::LockStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::FormTeamStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::LockStmt &) {
     // call some runtime routine
     TODO();
   }
@@ -853,19 +1057,20 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   ///
   /// For each pointer object, reset the pointer to a disassociated status.
   /// We do this by setting each pointer to null.
-  void genFIR(const Fortran::parser::NullifyStmt &stmt) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::NullifyStmt &stmt) {
     for (auto &po : stmt.v) {
       std::visit(
           Fortran::common::visitors{
               [&](const Fortran::parser::Name &sym) {
-                auto ty = genType(*sym.symbol);
-                auto load = builder->create<fir::LoadOp>(
-                    toLocation(), localSymbols.lookupSymbol(*sym.symbol));
-                auto idxTy = mlir::IndexType::get(&mlirContext);
-                auto zero = builder->create<mlir::ConstantOp>(
-                    toLocation(), idxTy, builder->getIntegerAttr(idxTy, 0));
-                auto cast =
-                    builder->create<fir::ConvertOp>(toLocation(), ty, zero);
+                auto ty{genType(*sym.symbol)};
+                auto load{builder->create<fir::LoadOp>(
+                    toLocation(), localSymbols.lookupSymbol(*sym.symbol))};
+                auto idxTy{mlir::IndexType::get(&mlirContext)};
+                auto zero{builder->create<mlir::ConstantOp>(
+                    toLocation(), idxTy, builder->getIntegerAttr(idxTy, 0))};
+                auto cast{
+                    builder->create<fir::ConvertOp>(toLocation(), ty, zero)};
                 builder->create<fir::StoreOp>(toLocation(), cast, load);
               },
               [&](const Fortran::parser::StructureComponent &) { TODO(); },
@@ -873,127 +1078,132 @@ class FirConverter : public Fortran::lower::AbstractConverter {
           po.u);
     }
   }
-  void genFIR(const Fortran::parser::PointerAssignmentStmt &) { TODO(); }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::PointerAssignmentStmt &) {
+    TODO();
+  }
 
-  void genFIR(const Fortran::parser::SyncAllStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SyncAllStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Fortran::parser::SyncImagesStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SyncImagesStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Fortran::parser::SyncMemoryStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SyncMemoryStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Fortran::parser::SyncTeamStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::SyncTeamStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Fortran::parser::UnlockStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::UnlockStmt &) {
     // call some runtime routine
     TODO();
   }
 
-  void genFIR(const Fortran::parser::AssignStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::FormatStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::EntryStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::PauseStmt &) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::AssignStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::FormatStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::EntryStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::PauseStmt &) {
     // call some runtime routine
     TODO();
   }
-  void genFIR(const Fortran::parser::DataStmt &) { TODO(); }
-  void genFIR(const Fortran::parser::NamelistStmt &) { TODO(); }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::DataStmt &) {
+    TODO();
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::NamelistStmt &) {
+    TODO();
+  }
 
   // call FAIL IMAGE in runtime
-  void genFIR(const Fortran::parser::FailImageStmt &stmt) {
-    auto callee = genRuntimeFunction(
-        Fortran::lower::RuntimeEntryCode::FailImageStatement, *builder);
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::FailImageStmt &stmt) {
+    auto callee{genRuntimeFunction(
+        Fortran::lower::RuntimeEntryCode::FailImageStatement, *builder)};
     llvm::SmallVector<mlir::Value, 1> operands; // FAIL IMAGE has no args
     builder->create<mlir::CallOp>(toLocation(), callee, operands);
   }
 
   // call STOP, ERROR STOP in runtime
-  void genFIR(const Fortran::parser::StopStmt &stm) {
-    auto callee = genRuntimeFunction(
-        Fortran::lower::RuntimeEntryCode::StopStatement, *builder);
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::StopStmt &stmt) {
+    auto callee{genRuntimeFunction(
+        Fortran::lower::RuntimeEntryCode::StopStatement, *builder)};
     // TODO: 3 args: stop-code-opt, ierror, quiet-opt
-    [[maybe_unused]] bool isStop{isStopStmt(stm)};
-    builder->create<mlir::CallOp>(toLocation(), callee, llvm::None);
+    // auto isError{genFIRLo!isStopStmt(stmt)}
+    llvm::SmallVector<mlir::Value, 8> operands;
+    builder->create<mlir::CallOp>(toLocation(), callee, operands);
   }
 
   // gen expression, if any; share code with END of procedure
-  void genFIR(const Fortran::parser::ReturnStmt &) {
-    if (inMainProgram(currentEvaluation)) {
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ReturnStmt &) {
+    if (inMainProgram(&eval)) {
       builder->create<mlir::ReturnOp>(toLocation());
-    } else if (auto *stmt = inSubroutine(currentEvaluation)) {
+    } else if (auto *stmt = inSubroutine(&eval)) {
       genFIRProcedureExit(stmt);
-    } else if (auto *stmt = inFunction(currentEvaluation)) {
+    } else if (auto *stmt = inFunction(&eval)) {
       auto *symbol = std::get<Fortran::parser::Name>(stmt->t).symbol;
       assert(symbol);
       genFIRFunctionReturn(*symbol);
-    } else if (auto *stmt = inMPSubp(currentEvaluation)) {
+    } else if (auto *stmt = inMpSubprogram(&eval)) {
       genFIRProcedureExit(stmt);
     } else {
       mlir::emitError(toLocation(), "unknown subprogram type");
     }
   }
 
-  // stubs for generic goto statements; see genFIREvalGoto()
-  void genFIR(const Fortran::parser::CycleStmt &) {} // do nothing
-  void genFIR(const Fortran::parser::ExitStmt &) {}  // do nothing
-  void genFIR(const Fortran::parser::GotoStmt &) {}  // do nothing
-
-  void genFIR(Fortran::lower::pft::Evaluation &eval) {
-    currentEvaluation = &eval;
-    eval.visit(Fortran::common::visitors{
-        [&](const auto &p) { genFIR(p); },
-        [](const Fortran::lower::pft::CGJump &) { /* do nothing */ },
-    });
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::CycleStmt &) {
+    genFIRUnconditionalBranch(eval.controlSuccessor);
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::ExitStmt &) {
+    genFIRUnconditionalBranch(eval.controlSuccessor);
+  }
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              const Fortran::parser::GotoStmt &) {
+    genFIRUnconditionalBranch(eval.controlSuccessor);
   }
 
-  /// Lower an Evaluation
-  ///
-  /// If the Evaluation is annotated, we can attempt to lower it by the class of
-  /// annotation. Otherwise, attempt to lower the Evaluation on a case-by-case
-  /// basis.
-  void lowerEval(Fortran::lower::pft::Evaluation &eval) {
-    setCurrentPosition(eval.pos);
-    if (eval.isControlTarget()) {
-      // start a new block
+  void genFIR(Fortran::lower::pft::Evaluation &eval,
+              bool unstructuredContext = true) {
+    if (eval.skip) {
+      return; // rhs of {Forall, If, Where}Stmt has already been processed
+    }
+    setCurrentPosition(eval.position);
+    if (unstructuredContext) {
+      // When transitioning from unstructured to structured code,
+      // the structured code might be a target that starts a new block.
+      maybeStartBlock(eval.isConstruct() && eval.LowerAsStructured()
+                          ? eval.evaluationList->front().block
+                          : eval.block);
     }
-    switch (eval.cfg) {
-    case Fortran::lower::pft::CFGAnnotation::None:
-      genFIREvalNone(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::Goto:
-      genFIREvalGoto(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::CondGoto:
-      genFIREvalCondGoto(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::IndGoto:
-      genFIREvalIndGoto(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::IoSwitch:
-      genFIREvalIoSwitch(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::Switch:
-      genFIREvalSwitch(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::Iterative:
-      genFIREvalIterative(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::FirStructuredOp:
-      genFIREvalStructuredOp(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::Return:
-      genFIREvalReturn(eval);
-      break;
-    case Fortran::lower::pft::CFGAnnotation::Terminate:
-      genFIREvalTerminate(eval);
-      break;
+    std::visit([&](const auto *p) { genFIR(eval, *p); }, eval.u);
+    if (unstructuredContext && eval.LowerAsUnstructured() &&
+        eval.controlSuccessor && eval.isActionStmt() && blockIsUnterminated()) {
+      // Exit from an unstructured IF or SELECT construct block.
+      genFIRUnconditionalBranch(eval.controlSuccessor);
     }
   }
 
@@ -1002,8 +1212,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     // get arguments and return type if any, otherwise just use empty vectors
     llvm::SmallVector<mlir::Type, 8> args;
     llvm::SmallVector<mlir::Type, 2> results;
-    auto funcTy = symbol ? genFunctionType(*symbol)
-                         : mlir::FunctionType::get(args, results, &mlirContext);
+    auto funcTy{symbol ? genFunctionType(*symbol)
+                       : mlir::FunctionType::get(args, results, &mlirContext)};
     return createFunction(*this, name, funcTy);
   }
 
@@ -1011,9 +1221,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit,
                         llvm::StringRef name,
                         const Fortran::semantics::Symbol *symbol) {
-    mlir::FuncOp func = Fortran::lower::getNamedFunction(module, name);
-    if (!func)
+    mlir::FuncOp func{Fortran::lower::getNamedFunction(module, name)};
+    if (!func) {
       func = createNewFunction(name, symbol);
+    }
     func.addEntryBlock();
     assert(!builder && "expected nullptr");
     builder = new mlir::OpBuilder(func);
@@ -1022,10 +1233,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     // plumb function's arguments
     if (symbol) {
-      auto *entryBlock = &func.front();
-      auto *details =
-          symbol->detailsIf<Fortran::semantics::SubprogramDetails>();
-      assert(details && "details for semantics symbol must be subprogram");
+      auto *entryBlock{&func.front()};
+      auto *details{symbol->detailsIf<Fortran::semantics::SubprogramDetails>()};
+      assert(details &&
+             "details for Fortran::semantics symbol must be subprogram");
       for (const auto &v :
            llvm::zip(details->dummyArgs(), entryBlock->getArguments())) {
         if (std::get<0>(v)) {
@@ -1038,18 +1249,65 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         createTemporary(toLocation(), details->result());
       }
     }
+
+    // Create most function blocks in advance.
+    createEmptyBlocks(funit.evaluationList);
+
+    // Reinstate entry block as the current insertion point.
+    builder->setInsertionPointToEnd(&func.front());
+  }
+
+  /// Create empty blocks for the current function.
+  void createEmptyBlocks(
+      std::list<Fortran::lower::pft::Evaluation> &evaluationList) {
+    for (auto &eval : evaluationList) {
+      if (eval.isNewBlock) {
+        eval.block = Fortran::lower::createBlock(builder);
+      }
+      for (size_t i{0}; i < eval.localBlocks.size(); ++i) {
+        eval.localBlocks[i] = Fortran::lower::createBlock(builder);
+      }
+      if (eval.isConstruct()) {
+        if (eval.LowerAsUnstructured()) {
+          createEmptyBlocks(*eval.evaluationList);
+        } else {
+          // A structured construct that is a target starts a new block.
+          Fortran::lower::pft::Evaluation &constructStmt{
+              eval.evaluationList->front()};
+          if (constructStmt.isNewBlock) {
+            constructStmt.block = Fortran::lower::createBlock(builder);
+          }
+        }
+      }
+    }
+  }
+
+  /// Return the predicate: "current block does not have a terminator branch".
+  bool blockIsUnterminated() {
+    mlir::Block *currentBlock{builder->getBlock()};
+    return currentBlock->empty() || currentBlock->back().isKnownNonTerminator();
+  }
+
+  /// Unconditionally switch code insertion to a new block.
+  void startBlock(mlir::Block *newBlock) {
+    assert(newBlock && "missing block");
+    // If the current block does not have a terminator branch,
+    // append a fallthrough branch.
+    if (blockIsUnterminated()) {
+      genFIRUnconditionalBranch(newBlock);
+    }
+    builder->setInsertionPointToStart(newBlock);
   }
 
-  void finalizeQueuedEdges() {
-    for (auto &edgeFunc : localEdgeQ)
-      edgeFunc(localBlockMap);
-    localEdgeQ.clear();
-    localBlockMap.clear();
+  /// Conditionally switch code insertion to a new block.
+  void maybeStartBlock(mlir::Block *newBlock) {
+    if (newBlock) {
+      startBlock(newBlock);
+    }
   }
 
   /// Cleanup after the function has been translated
   void endNewFunction() {
-    finalizeQueuedEdges();
     delete builder;
     builder = nullptr;
     localSymbols.clear();
@@ -1060,10 +1318,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                  llvm::ArrayRef<llvm::StringRef> modules,
                  llvm::Optional<llvm::StringRef> host = {}) {
     std::string name;
-    const Fortran::semantics::Symbol *symbol = nullptr;
+    const Fortran::semantics::Symbol *symbol{nullptr};
 
     if (func.beginStmt) {
-      currentEvaluation = nullptr;
       std::visit([&](auto *p) { genFIR(*p, name, symbol); }, *func.beginStmt);
     } else {
       name = uniquer.doProgramEntry();
@@ -1072,17 +1329,18 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     startNewFunction(func, name, symbol);
 
     // lower this procedure
-    for (auto &e : func.evals)
-      lowerEval(e);
-    currentEvaluation = nullptr;
+    for (auto &eval : func.evaluationList) {
+      genFIR(eval);
+    }
     std::visit([&](auto *p) { genFIR(*p, name, symbol); }, func.endStmt);
 
     endNewFunction();
 
     // recursively lower internal procedures
     llvm::Optional<llvm::StringRef> optName{name};
-    for (auto &f : func.funcs)
+    for (auto &f : func.containedFunctions) {
       lowerFunc(f, modules, optName);
+    }
   }
 
   void lowerMod(Fortran::lower::pft::ModuleLikeUnit &mod) {
@@ -1090,49 +1348,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     std::vector<llvm::StringRef> moduleName;
 
     // FIXME: do we need to visit the module statements?
-    for (auto &f : mod.funcs)
+    for (auto &f : mod.containedFunctions) {
       lowerFunc(f, moduleName);
+    }
   }
 
-  //
-  // Finalization of the CFG structure
-  //
-
-  /// Lookup the set of sinks for this source. There must be at least one.
-  llvm::ArrayRef<Fortran::lower::pft::Evaluation *>
-  findTargetsOf(Fortran::lower::pft::Evaluation &eval) {
-    auto iter = cfgMap.find(&eval);
-    assert(iter != cfgMap.end());
-    return *iter->second;
-  }
-
-  /// Lookup the sink for this source. There must be exactly one.
-  Fortran::lower::pft::Evaluation *
-  findSinkOf(Fortran::lower::pft::Evaluation &eval) {
-    auto iter = cfgMap.find(&eval);
-    assert((iter != cfgMap.end()) && (iter->second->size() == 1));
-    return iter->second->front();
-  }
-
-  /// prune the CFG for `f`
-  void pruneFunc(Fortran::lower::pft::FunctionLikeUnit &func) {
-    // find and cache arcs, etc.
-    if (!func.evals.empty())
-      CfgBuilder{cfgMap, cfgEdgeSetPool}.run(func);
-
-    // do any internal procedures
-    for (auto &f : func.funcs)
-      pruneFunc(f);
-  }
-
-  void pruneMod(Fortran::lower::pft::ModuleLikeUnit &mod) {
-    for (auto &f : mod.funcs)
-      pruneFunc(f);
-  }
-
-  void setCurrentPosition(const Fortran::parser::CharBlock &pos) {
-    if (pos != Fortran::parser::CharBlock{})
-      currentPosition = pos;
+  void setCurrentPosition(const Fortran::parser::CharBlock &position) {
+    if (position != Fortran::parser::CharBlock{}) {
+      currentPosition = position;
+    }
   }
 
   //
@@ -1149,7 +1373,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   // TODO: should these be moved to convert-expr?
   template <mlir::CmpIPredicate ICMPOPC>
   mlir::Value genCompare(mlir::Value lhs, mlir::Value rhs) {
-    auto lty = lhs.getType();
+    auto lty{lhs.getType()};
     assert(lty == rhs.getType());
     if (lty.isSignlessIntOrIndex())
       return builder->create<mlir::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
@@ -1182,16 +1406,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   mlir::ModuleOp &module;
   const Fortran::common::IntrinsicTypeDefaultKinds &defaults;
   Fortran::lower::IntrinsicLibrary intrinsics;
-  mlir::OpBuilder *builder = nullptr;
+  mlir::OpBuilder *builder{nullptr};
   fir::NameUniquer &uniquer;
   Fortran::lower::SymMap localSymbols;
-  std::list<Closure> localEdgeQ;
-  LabelMapType localBlockMap;
   Fortran::parser::CharBlock currentPosition;
-  CFGMapType cfgMap;
-  std::list<CFGSinkListType> cfgEdgeSetPool;
-  Fortran::lower::pft::Evaluation *currentEvaluation =
-      nullptr; // FIXME: this is a hack
 
 public:
   FirConverter() = delete;
@@ -1210,17 +1428,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   /// Convert the PFT to FIR
   void run(Fortran::lower::pft::Program &pft) {
-    // build pruned control
-    for (auto &u : pft.getUnits()) {
-      std::visit(
-          Fortran::common::visitors{
-              [&](Fortran::lower::pft::FunctionLikeUnit &f) { pruneFunc(f); },
-              [&](Fortran::lower::pft::ModuleLikeUnit &m) { pruneMod(m); },
-              [](Fortran::lower::pft::BlockDataUnit &) { /* do nothing */ },
-          },
-          u);
-    }
-
     // do translation
     for (auto &u : pft.getUnits()) {
       std::visit(
@@ -1273,18 +1480,16 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   mlir::Location getCurrentLocation() override final { return toLocation(); }
-
   mlir::Location genLocation() override final {
     return mlir::UnknownLoc::get(&mlirContext);
   }
-
   mlir::Location
   genLocation(const Fortran::parser::CharBlock &block) override final {
     if (cooked) {
-      auto loc = cooked->GetSourcePositionRange(block);
+      auto loc{cooked->GetSourcePositionRange(block)};
       if (loc.has_value()) {
         // loc is a pair (begin, end); use the beginning position
-        auto &filePos = loc->first;
+        auto &filePos{loc->first};
         return mlir::FileLineColLoc::get(filePos.file.path(), filePos.line,
                                          filePos.column, &mlirContext);
       }
@@ -1293,7 +1498,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   mlir::OpBuilder &getOpBuilder() override final { return *builder; }
-
   mlir::ModuleOp &getModuleOp() override final { return module; }
 
   std::string mangleName(Fortran::lower::SymbolRef symbol) override final {
@@ -1306,7 +1510,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 void Fortran::lower::LoweringBridge::lower(const Fortran::parser::Program &prg,
                                            fir::NameUniquer &uniquer) {
   auto pft = Fortran::lower::createPFT(prg);
-  Fortran::lower::annotateControl(*pft);
   if (dumpBeforeFir)
     Fortran::lower::dumpPFT(llvm::errs(), *pft);
   FirConverter converter{*this, uniquer};
diff --git a/lib/Lower/CFGBuilder.h b/lib/Lower/CFGBuilder.h
deleted file mode 100644
index 917278bb1ba7..000000000000
--- a/lib/Lower/CFGBuilder.h
+++ /dev/null
@@ -1,358 +0,0 @@
-//===-- CFGBuilder.h -- CFG building parts of bridge ------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef FORTRAN_LOWER_CFGBUILDER_H_
-#define FORTRAN_LOWER_CFGBUILDER_H_
-
-/// Traverse the PFT and complete the CFG by drawing the arcs, pruning unused
-/// potential targets, making implied jumps explicit, etc.
-class CfgBuilder {
-
-  Fortran::lower::pft::Evaluation *
-  getEvalByLabel(const Fortran::parser::Label &label) {
-    auto iter = labels.find(label);
-    if (iter != labels.end()) {
-      return iter->second;
-    }
-    return nullptr;
-  }
-
-  /// Collect all the potential targets and initialize them to unreferenced
-  void
-  resetPotentialTargets(std::list<Fortran::lower::pft::Evaluation> &evals) {
-    for (auto &e : evals) {
-      if (e.isTarget) {
-        e.isTarget = false;
-      }
-      if (e.lab.has_value()) {
-        labels.try_emplace(*e.lab, &e);
-      }
-      if (e.subs) {
-        resetPotentialTargets(*e.subs);
-      }
-    }
-  }
-
-  /// cache ASSIGN statements that may yield a live branch target
-  void cacheAssigns(std::list<Fortran::lower::pft::Evaluation> &evals) {
-    for (auto &e : evals) {
-      e.visit(Fortran::common::visitors{
-          [&](const Fortran::parser::AssignStmt &stmt) {
-            auto *trg =
-                getEvalByLabel(std::get<Fortran::parser::Label>(stmt.t));
-            auto *sym = std::get<Fortran::parser::Name>(stmt.t).symbol;
-            assert(sym);
-            auto jter = assignedGotoMap.find(sym);
-            if (jter == assignedGotoMap.end()) {
-              std::list<Fortran::lower::pft::Evaluation *> lst = {trg};
-              assignedGotoMap.try_emplace(sym, lst);
-            } else {
-              jter->second.emplace_back(trg);
-            }
-          },
-          [](auto &) { /* do nothing */ },
-      });
-      if (e.subs) {
-        cacheAssigns(*e.subs);
-      }
-    }
-  }
-
-  void deannotate(std::list<Fortran::lower::pft::Evaluation> &evals) {
-    for (auto &e : evals) {
-      e.cfg = Fortran::lower::pft::CFGAnnotation::None;
-      if (e.subs) {
-        deannotate(*e.subs);
-      }
-    }
-  }
-
-  bool structuredCheck(std::list<Fortran::lower::pft::Evaluation> &evals) {
-    for (auto &e : evals) {
-      if (auto *s = e.getIf<Fortran::parser::DoConstruct>()) {
-        return s->IsDoWhile() ? false : structuredCheck(*e.subs);
-      }
-      if (e.isA<Fortran::parser::IfConstruct>()) {
-        return structuredCheck(*e.subs);
-      }
-      if (e.subs) {
-        return false;
-      }
-      switch (e.cfg) {
-      case Fortran::lower::pft::CFGAnnotation::None:
-        break;
-      case Fortran::lower::pft::CFGAnnotation::CondGoto:
-        break;
-      case Fortran::lower::pft::CFGAnnotation::Iterative:
-        break;
-      case Fortran::lower::pft::CFGAnnotation::FirStructuredOp:
-        break;
-      case Fortran::lower::pft::CFGAnnotation::IndGoto:
-        return false;
-      case Fortran::lower::pft::CFGAnnotation::IoSwitch:
-        return false;
-      case Fortran::lower::pft::CFGAnnotation::Switch:
-        return false;
-      case Fortran::lower::pft::CFGAnnotation::Return:
-        return false;
-      case Fortran::lower::pft::CFGAnnotation::Terminate:
-        return false;
-      case Fortran::lower::pft::CFGAnnotation::Goto:
-        if (!e.isA<Fortran::parser::EndDoStmt>()) {
-          return false;
-        }
-        break;
-      }
-    }
-    return true;
-  }
-
-  void wrapIterationSpaces(std::list<Fortran::lower::pft::Evaluation> &evals) {
-    for (auto &e : evals) {
-      if (e.isA<Fortran::parser::DoConstruct>())
-        if (structuredCheck(*e.subs)) {
-          deannotate(*e.subs);
-          e.cfg = Fortran::lower::pft::CFGAnnotation::FirStructuredOp;
-          continue;
-        }
-      if (e.isA<Fortran::parser::IfConstruct>())
-        if (structuredCheck(*e.subs)) {
-          deannotate(*e.subs);
-          e.cfg = Fortran::lower::pft::CFGAnnotation::FirStructuredOp;
-          continue;
-        }
-      // FIXME: ForallConstruct? WhereConstruct?
-      if (e.subs) {
-        wrapIterationSpaces(*e.subs);
-      }
-    }
-  }
-
-  /// Add source->sink edge to CFG map
-  void addSourceToSink(Fortran::lower::pft::Evaluation *src,
-                       Fortran::lower::pft::Evaluation *snk) {
-    auto iter = cfgMap.find(src);
-    if (iter == cfgMap.end()) {
-      CFGSinkListType sink{snk};
-      cfgEdgeSetPool.emplace_back(std::move(sink));
-      auto rc{cfgMap.try_emplace(src, &cfgEdgeSetPool.back())};
-      assert(rc.second && "insert failed unexpectedly");
-      (void)rc; // for release build
-      return;
-    }
-    for (auto *s : *iter->second)
-      if (s == snk) {
-        return;
-      }
-    iter->second->push_back(snk);
-  }
-
-  void addSourceToSink(Fortran::lower::pft::Evaluation *src,
-                       const Fortran::parser::Label &label) {
-    auto iter = labels.find(label);
-    assert(iter != labels.end());
-    addSourceToSink(src, iter->second);
-  }
-
-  /// Find the next ELSE IF, ELSE or END IF statement in the list
-  template <typename A>
-  A nextFalseTarget(A iter, const A &endi) {
-    for (; iter != endi; ++iter)
-      if (iter->visit(Fortran::common::visitors{
-              [&](const Fortran::parser::ElseIfStmt &) { return true; },
-              [&](const Fortran::parser::ElseStmt &) { return true; },
-              [&](const Fortran::parser::EndIfStmt &) { return true; },
-              [](auto &) { return false; },
-          })) {
-        break;
-      }
-    return iter;
-  }
-
-  /// Add branches for this IF block like construct.
-  /// Branch to the "true block", the "false block", and from the end of the
-  /// true block to the end of the construct.
-  template <typename A>
-  void doNextIfBlock(std::list<Fortran::lower::pft::Evaluation> &evals,
-                     Fortran::lower::pft::Evaluation &e, const A &iter,
-                     const A &endif) {
-    A i{iter};
-    A j{nextFalseTarget(++i, endif)};
-    auto *cstr = std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
-    Fortran::lower::pft::CGJump jump{*endif};
-    A k{evals.insert(
-        j, Fortran::lower::pft::Evaluation{std::move(jump), j->parent})};
-    if (i == j) {
-      // block was empty, so adjust "true" target
-      i = k;
-    }
-    addSourceToSink(&*k, cstr);
-    addSourceToSink(&e, &*i);
-    addSourceToSink(&e, &*j);
-  }
-
-  /// Determine which branch targets are reachable. The target map must
-  /// already be initialized.
-  void reachabilityAnalysis(std::list<Fortran::lower::pft::Evaluation> &evals) {
-    for (auto iter = evals.begin(); iter != evals.end(); ++iter) {
-      auto &e = *iter;
-      switch (e.cfg) {
-      case Fortran::lower::pft::CFGAnnotation::None:
-        // do nothing - does not impart control flow
-        break;
-      case Fortran::lower::pft::CFGAnnotation::Goto:
-        e.visit(Fortran::common::visitors{
-            [&](const Fortran::parser::CycleStmt &) {
-              // FIXME: deal with construct name
-              auto *cstr =
-                  std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
-              addSourceToSink(&e, &cstr->subs->front());
-            },
-            [&](const Fortran::parser::ExitStmt &) {
-              // FIXME: deal with construct name
-              auto *cstr =
-                  std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
-              addSourceToSink(&e, &cstr->subs->back());
-            },
-            [&](const Fortran::parser::GotoStmt &stmt) {
-              addSourceToSink(&e, stmt.v);
-            },
-            [&](const Fortran::parser::EndDoStmt &) {
-              // the END DO is the loop exit landing pad
-              // insert a JUMP as the backedge right before the END DO
-              auto *cstr =
-                  std::get<Fortran::lower::pft::Evaluation *>(e.parent.p);
-              Fortran::lower::pft::CGJump jump{cstr->subs->front()};
-              Fortran::lower::pft::Evaluation jumpEval{std::move(jump),
-                                                       iter->parent};
-              evals.insert(iter, std::move(jumpEval));
-              addSourceToSink(&e, &cstr->subs->front());
-            },
-            [&](const Fortran::lower::pft::CGJump &jump) {
-              addSourceToSink(&e, &jump.target);
-            },
-            [](auto &) { assert(false && "unhandled GOTO case"); },
-        });
-        break;
-      case Fortran::lower::pft::CFGAnnotation::CondGoto:
-        e.visit(Fortran::common::visitors{
-            [&](const Fortran::parser::IfStmt &) {
-              // check if these are marked; they must targets here
-              auto i{iter};
-              addSourceToSink(&e, &*(++i));
-              addSourceToSink(&e, &*(++i));
-            },
-            [&](const Fortran::parser::IfThenStmt &) {
-              doNextIfBlock(evals, e, iter, evals.end());
-            },
-            [&](const Fortran::parser::ElseIfStmt &) {
-              doNextIfBlock(evals, e, iter, evals.end());
-            },
-            [](const Fortran::parser::WhereConstructStmt &) { TODO(); },
-            [](const Fortran::parser::MaskedElsewhereStmt &) { TODO(); },
-            [](auto &) { assert(false && "unhandled CGOTO case"); },
-        });
-        break;
-      case Fortran::lower::pft::CFGAnnotation::IndGoto:
-        e.visit(Fortran::common::visitors{
-            [&](const Fortran::parser::AssignedGotoStmt &stmt) {
-              auto *sym = std::get<Fortran::parser::Name>(stmt.t).symbol;
-              if (assignedGotoMap.find(sym) != assignedGotoMap.end())
-                for (auto *x : assignedGotoMap[sym]) {
-                  addSourceToSink(&e, x);
-                }
-              for (auto &l :
-                   std::get<std::list<Fortran::parser::Label>>(stmt.t)) {
-                addSourceToSink(&e, l);
-              }
-            },
-            [](auto &) { assert(false && "unhandled IGOTO case"); },
-        });
-        break;
-      case Fortran::lower::pft::CFGAnnotation::IoSwitch:
-        e.visit(Fortran::common::visitors{
-            [](const Fortran::parser::BackspaceStmt &) { TODO(); },
-            [](const Fortran::parser::CloseStmt &) { TODO(); },
-            [](const Fortran::parser::EndfileStmt &) { TODO(); },
-            [](const Fortran::parser::FlushStmt &) { TODO(); },
-            [](const Fortran::parser::InquireStmt &) { TODO(); },
-            [](const Fortran::parser::OpenStmt &) { TODO(); },
-            [](const Fortran::parser::ReadStmt &) { TODO(); },
-            [](const Fortran::parser::RewindStmt &) { TODO(); },
-            [](const Fortran::parser::WaitStmt &) { TODO(); },
-            [](const Fortran::parser::WriteStmt &) { TODO(); },
-            [](auto &) { assert(false && "unhandled IO switch case"); },
-        });
-        break;
-      case Fortran::lower::pft::CFGAnnotation::Switch:
-        e.visit(Fortran::common::visitors{
-            [](const Fortran::parser::CallStmt &) { TODO(); },
-            [](const Fortran::parser::ArithmeticIfStmt &) { TODO(); },
-            [](const Fortran::parser::ComputedGotoStmt &) { TODO(); },
-            [](const Fortran::parser::SelectCaseStmt &) { TODO(); },
-            [](const Fortran::parser::SelectRankStmt &) { TODO(); },
-            [](const Fortran::parser::SelectTypeStmt &) { TODO(); },
-            [](auto &) { assert(false && "unhandled switch case"); },
-        });
-        break;
-      case Fortran::lower::pft::CFGAnnotation::Iterative:
-        e.visit(Fortran::common::visitors{
-            [](const Fortran::parser::NonLabelDoStmt &) { TODO(); },
-            [](const Fortran::parser::WhereStmt &) { TODO(); },
-            [](const Fortran::parser::ForallStmt &) { TODO(); },
-            [](const Fortran::parser::WhereConstruct &) { TODO(); },
-            [](const Fortran::parser::ForallConstructStmt &) { TODO(); },
-            [](auto &) { assert(false && "unhandled loop case"); },
-        });
-        break;
-      case Fortran::lower::pft::CFGAnnotation::FirStructuredOp:
-        // do not visit the subs
-        continue;
-      case Fortran::lower::pft::CFGAnnotation::Return:
-        // do nothing - exits the function
-        break;
-      case Fortran::lower::pft::CFGAnnotation::Terminate:
-        // do nothing - exits the function
-        break;
-      }
-      if (e.subs) {
-        reachabilityAnalysis(*e.subs);
-      }
-    }
-  }
-
-  void setActualTargets(std::list<Fortran::lower::pft::Evaluation> &) {
-    for (auto &lst1 : cfgEdgeSetPool)
-      for (auto *e : lst1) {
-        e->isTarget = true;
-      }
-  }
-
-  CFGMapType &cfgMap;
-  std::list<CFGSinkListType> &cfgEdgeSetPool;
-
-  llvm::DenseMap<Fortran::parser::Label, Fortran::lower::pft::Evaluation *>
-      labels;
-  std::map<Fortran::semantics::Symbol *,
-           std::list<Fortran::lower::pft::Evaluation *>>
-      assignedGotoMap;
-
-public:
-  CfgBuilder(CFGMapType &m, std::list<CFGSinkListType> &p)
-      : cfgMap{m}, cfgEdgeSetPool{p} {}
-
-  void run(Fortran::lower::pft::FunctionLikeUnit &func) {
-    resetPotentialTargets(func.evals);
-    cacheAssigns(func.evals);
-    wrapIterationSpaces(func.evals);
-    reachabilityAnalysis(func.evals);
-    setActualTargets(func.evals);
-  }
-};
-
-#endif // FORTRAN_LOWER_BRIDGE_CFG_BUILDER_H_
diff --git a/lib/Lower/OpBuilder.cpp b/lib/Lower/OpBuilder.cpp
index 3f49671e28d1..eb1dd9c68bcb 100644
--- a/lib/Lower/OpBuilder.cpp
+++ b/lib/Lower/OpBuilder.cpp
@@ -46,23 +46,29 @@ Fortran::lower::SymMap::lookupSymbol(Fortran::semantics::SymbolRef symbol) {
   return (iter == symbolMap.end()) ? nullptr : iter->second;
 }
 
-void Fortran::lower::SymMap::pushShadowSymbol(
-    Fortran::semantics::SymbolRef symbol, mlir::Value value) {
-  // find any existing mapping for symbol
-  auto iter{symbolMap.find(&*symbol)};
-  const Fortran::semantics::Symbol *sym{nullptr};
-  mlir::Value val;
-  // if mapping exists, save it on the shadow stack
+void Fortran::lower::SymMap::pushShadowSymbol(semantics::SymbolRef symbol,
+                                              mlir::Value value) {
+  auto iter{symbolMap.find(&*symbol)}; // existing mapping, if any
+  mlir::Value originalValue;
   if (iter != symbolMap.end()) {
-    sym = iter->first;
-    val = iter->second;
+    originalValue = iter->second;
     symbolMap.erase(iter);
   }
-  shadowStack.emplace_back(sym, val);
-  // insert new shadow mapping
-  auto r{symbolMap.try_emplace(&*symbol, value)};
-  assert(r.second && "unexpected insertion failure");
-  (void)r;
+  shadowStack.emplace_back(&*symbol, originalValue); // save original value
+  symbolMap.try_emplace(&*symbol, value);            // update to new value
+}
+
+void Fortran::lower::SymMap::popShadowSymbol() {
+  auto &pair{shadowStack.back()};
+  assert(pair.first && "missing pop symbol");
+  if (pair.second) {
+    symbolMap[pair.first] = pair.second; // reinstate original value
+  } else {
+    auto iter{symbolMap.find(pair.first)};
+    assert(iter != symbolMap.end() && "missing pop symbol mapping");
+    symbolMap.erase(iter); // remove shadow symbol
+  }
+  shadowStack.pop_back();
 }
 
 mlir::Value
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 4d5ad251b3f0..491e616d63c4 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -9,7 +9,7 @@
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/parse-tree-visitor.h"
-#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/CommandLine.h"
 #include <algorithm>
 #include <cassert>
 #include <utility>
@@ -46,38 +46,37 @@ struct UnwrapStmt<parser::Statement<A>> {
   static constexpr bool isStmt{true};
   using Type = typename RemoveIndirectionHelper<A>::Type;
   constexpr UnwrapStmt(const parser::Statement<A> &a)
-      : unwrapped{removeIndirection(a.statement)}, pos{a.source}, lab{a.label} {
-  }
+      : unwrapped{removeIndirection(a.statement)}, position{a.source},
+        label{a.label} {}
   const Type &unwrapped;
-  parser::CharBlock pos;
-  std::optional<parser::Label> lab;
+  parser::CharBlock position;
+  std::optional<parser::Label> label;
 };
 template <typename A>
 struct UnwrapStmt<parser::UnlabeledStatement<A>> {
   static constexpr bool isStmt{true};
   using Type = typename RemoveIndirectionHelper<A>::Type;
   constexpr UnwrapStmt(const parser::UnlabeledStatement<A> &a)
-      : unwrapped{removeIndirection(a.statement)}, pos{a.source} {}
+      : unwrapped{removeIndirection(a.statement)}, position{a.source} {}
   const Type &unwrapped;
-  parser::CharBlock pos;
-  std::optional<parser::Label> lab;
+  parser::CharBlock position;
+  std::optional<parser::Label> label;
 };
 
 /// The instantiation of a parse tree visitor (Pre and Post) is extremely
-/// expensive in terms of compile and link time, so one goal here is to limit
-/// the bridge to one such instantiation.
+/// expensive in terms of compile and link time.  So one goal here is to
+/// limit the bridge to one such instantiation.
 class PFTBuilder {
 public:
-  PFTBuilder() : pgm{new pft::Program}, parents{*pgm.get()} {}
+  PFTBuilder() : pgm{new pft::Program}, parentTypeStack{*pgm.get()} {}
 
   /// Get the result
   std::unique_ptr<pft::Program> result() { return std::move(pgm); }
 
   template <typename A>
   constexpr bool Pre(const A &a) {
-    bool visit{true};
     if constexpr (pft::isFunctionLike<A>) {
-      return enterFunc(a);
+      return enterFunction(a);
     } else if constexpr (pft::isConstruct<A>) {
       return enterConstruct(a);
     } else if constexpr (UnwrapStmt<A>::isStmt) {
@@ -87,21 +86,22 @@ class PFTBuilder {
       // or UnlabeledStatement<Indirection<T>>
       auto stmt{UnwrapStmt<A>(a)};
       if constexpr (pft::isConstructStmt<T> || pft::isOtherStmt<T>) {
-        addEval(pft::Evaluation{stmt.unwrapped, parents.back(), stmt.pos,
-                                stmt.lab});
-        visit = false;
+        addEvaluation(pft::Evaluation{stmt.unwrapped, parentTypeStack.back(),
+                                      stmt.position, stmt.label});
+        return false;
       } else if constexpr (std::is_same_v<T, parser::ActionStmt>) {
-        addEval(makeEvalAction(stmt.unwrapped, stmt.pos, stmt.lab));
-        visit = false;
+        addEvaluation(
+            makeEvaluationAction(stmt.unwrapped, stmt.position, stmt.label));
+        return true;
       }
     }
-    return visit;
+    return true;
   }
 
   template <typename A>
   constexpr void Post(const A &) {
     if constexpr (pft::isFunctionLike<A>) {
-      exitFunc();
+      exitFunction();
     } else if constexpr (pft::isConstruct<A>) {
       exitConstruct();
     }
@@ -116,24 +116,25 @@ class PFTBuilder {
 
   // Block data
   bool Pre(const parser::BlockData &node) {
-    addUnit(pft::BlockDataUnit{node, parents.back()});
+    addUnit(pft::BlockDataUnit{node, parentTypeStack.back()});
     return false;
   }
 
   // Get rid of production wrapper
   bool Pre(const parser::UnlabeledStatement<parser::ForallAssignmentStmt>
                &statement) {
-    addEval(std::visit(
+    addEvaluation(std::visit(
         [&](const auto &x) {
-          return pft::Evaluation{x, parents.back(), statement.source, {}};
+          return pft::Evaluation{
+              x, parentTypeStack.back(), statement.source, {}};
         },
         statement.statement.u));
     return false;
   }
   bool Pre(const parser::Statement<parser::ForallAssignmentStmt> &statement) {
-    addEval(std::visit(
+    addEvaluation(std::visit(
         [&](const auto &x) {
-          return pft::Evaluation{x, parents.back(), statement.source,
+          return pft::Evaluation{x, parentTypeStack.back(), statement.source,
                                  statement.label};
         },
         statement.statement.u));
@@ -145,8 +146,9 @@ class PFTBuilder {
             [&](const parser::Statement<parser::AssignmentStmt> &stmt) {
               // Not caught as other AssignmentStmt because it is not
               // wrapped in a parser::ActionStmt.
-              addEval(pft::Evaluation{stmt.statement, parents.back(),
-                                      stmt.source, stmt.label});
+              addEvaluation(pft::Evaluation{stmt.statement,
+                                            parentTypeStack.back(), stmt.source,
+                                            stmt.label});
               return false;
             },
             [&](const auto &) { return true; },
@@ -155,79 +157,80 @@ class PFTBuilder {
   }
 
 private:
-  // ActionStmt has a couple of non-conforming cases, which get handled
-  // explicitly here.  The other cases use an Indirection, which we discard in
-  // the PFT.
-  pft::Evaluation makeEvalAction(const parser::ActionStmt &statement,
-                                 parser::CharBlock pos,
-                                 std::optional<parser::Label> lab) {
-    return std::visit(
-        common::visitors{
-            [&](const auto &x) {
-              return pft::Evaluation{removeIndirection(x), parents.back(), pos,
-                                     lab};
-            },
-        },
-        statement.u);
-  }
-
-  // When we enter a function-like structure, we want to build a new unit and
-  // set the builder's cursors to point to it.
+  /// Initialize a new module-like unit and make it the builder's focus.
   template <typename A>
-  bool enterFunc(const A &func) {
-    auto &unit = addFunc(pft::FunctionLikeUnit{func, parents.back()});
-    funclist = &unit.funcs;
-    pushEval(&unit.evals);
-    parents.emplace_back(unit);
+  bool enterModule(const A &func) {
+    auto &unit = addUnit(pft::ModuleLikeUnit{func, parentTypeStack.back()});
+    functionList = &unit.containedFunctions;
+    parentTypeStack.emplace_back(unit);
     return true;
   }
-  /// Make funclist to point to current parent function list if it exists.
-  void setFunctListToParentFuncs() {
-    if (!parents.empty()) {
-      std::visit(common::visitors{
-                     [&](pft::FunctionLikeUnit *p) { funclist = &p->funcs; },
-                     [&](pft::ModuleLikeUnit *p) { funclist = &p->funcs; },
-                     [&](auto *) { funclist = nullptr; },
-                 },
-                 parents.back().p);
-    }
-  }
 
-  void exitFunc() {
-    popEval();
-    parents.pop_back();
-    setFunctListToParentFuncs();
+  void exitModule() {
+    parentTypeStack.pop_back();
+    ResetFunctionList();
   }
 
-  // When we enter a construct structure, we want to build a new construct and
-  // set the builder's evaluation cursor to point to it.
+  /// Initialize a new function-like unit and make it the builder's focus.
   template <typename A>
-  bool enterConstruct(const A &construct) {
-    auto &con = addEval(pft::Evaluation{construct, parents.back()});
-    con.subs.reset(new pft::EvaluationCollection);
-    pushEval(con.subs.get());
-    parents.emplace_back(con);
+  bool enterFunction(const A &func) {
+    auto &unit =
+        addFunction(pft::FunctionLikeUnit{func, parentTypeStack.back()});
+    labelEvaluationMap = &unit.labelEvaluationMap;
+    assignSymbolLabelMap = &unit.assignSymbolLabelMap;
+    functionList = &unit.containedFunctions;
+    pushEvaluationList(&unit.evaluationList);
+    parentTypeStack.emplace_back(unit);
     return true;
   }
 
-  void exitConstruct() {
-    popEval();
-    parents.pop_back();
+  void exitFunction() {
+    // Guarantee that there is a branch target after the last user statement.
+    static const parser::ContinueStmt endTarget{};
+    addEvaluation(pft::Evaluation{endTarget, parentTypeStack.back(), {}, {}});
+    lastLexicalEvaluation = nullptr;
+    analyzeBranches(nullptr, *evaluationListStack.back()); // add branch links
+    popEvaluationList();
+    labelEvaluationMap = nullptr;
+    assignSymbolLabelMap = nullptr;
+    parentTypeStack.pop_back();
+    ResetFunctionList();
+    labelEvaluationMap = nullptr;
+    assignSymbolLabelMap = nullptr;
   }
 
-  // When we enter a module structure, we want to build a new module and
-  // set the builder's function cursor to point to it.
+  /// Initialize a new construct and make it the builder's focus.
   template <typename A>
-  bool enterModule(const A &func) {
-    auto &unit = addUnit(pft::ModuleLikeUnit{func, parents.back()});
-    funclist = &unit.funcs;
-    parents.emplace_back(unit);
+  bool enterConstruct(const A &construct) {
+    auto &eval =
+        addEvaluation(pft::Evaluation{construct, parentTypeStack.back()});
+    eval.evaluationList.reset(new pft::EvaluationList);
+    pushEvaluationList(eval.evaluationList.get());
+    parentTypeStack.emplace_back(eval);
+    constructStack.emplace_back(&eval);
     return true;
   }
 
-  void exitModule() {
-    parents.pop_back();
-    setFunctListToParentFuncs();
+  void exitConstruct() {
+    popEvaluationList();
+    parentTypeStack.pop_back();
+    constructStack.pop_back();
+  }
+
+  /// Reset functionList to an enclosing function's functionList.
+  void ResetFunctionList() {
+    if (!parentTypeStack.empty()) {
+      std::visit(common::visitors{
+                     [&](pft::FunctionLikeUnit *p) {
+                       functionList = &p->containedFunctions;
+                     },
+                     [&](pft::ModuleLikeUnit *p) {
+                       functionList = &p->containedFunctions;
+                     },
+                     [&](auto *) { functionList = nullptr; },
+                 },
+                 parentTypeStack.back().p);
+    }
   }
 
   template <typename A>
@@ -237,45 +240,513 @@ class PFTBuilder {
   }
 
   template <typename A>
-  A &addFunc(A &&func) {
-    if (funclist) {
-      funclist->emplace_back(std::move(func));
-      return funclist->back();
+  A &addFunction(A &&func) {
+    if (functionList) {
+      functionList->emplace_back(std::move(func));
+      return functionList->back();
     }
     return addUnit(std::move(func));
   }
 
-  /// move the Evaluation to the end of the current list
-  pft::Evaluation &addEval(pft::Evaluation &&eval) {
-    assert(funclist && "not in a function");
-    assert(evallist.size() > 0);
-    evallist.back()->emplace_back(std::move(eval));
-    return evallist.back()->back();
+  // ActionStmt has a couple of non-conforming cases, explicitly handled here.
+  // The other cases use an Indirection, which are discarded in the PFT.
+  pft::Evaluation makeEvaluationAction(const parser::ActionStmt &statement,
+                                       parser::CharBlock position,
+                                       std::optional<parser::Label> label) {
+    return std::visit(
+        common::visitors{
+            [&](const auto &x) {
+              return pft::Evaluation{removeIndirection(x),
+                                     parentTypeStack.back(), position, label};
+            },
+        },
+        statement.u);
+  }
+
+  /// Append an Evaluation to the end of the current list.
+  pft::Evaluation &addEvaluation(pft::Evaluation &&eval) {
+    assert(functionList && "not in a function");
+    assert(evaluationListStack.size() > 0);
+    if (constructStack.size() > 0) {
+      eval.parentConstruct = constructStack.back();
+    }
+    evaluationListStack.back()->emplace_back(std::move(eval));
+    pft::Evaluation *p = &evaluationListStack.back()->back();
+    if (p->isActionStmt() || p->isConstructStmt()) {
+      if (lastLexicalEvaluation) {
+        lastLexicalEvaluation->lexicalSuccessor = p;
+        p->printIndex = lastLexicalEvaluation->printIndex + 1;
+      } else {
+        p->printIndex = 1;
+      }
+      lastLexicalEvaluation = p;
+    }
+    if (p->label.has_value()) {
+      labelEvaluationMap->try_emplace(*p->label, p);
+    }
+    return evaluationListStack.back()->back();
   }
 
   /// push a new list on the stack of Evaluation lists
-  void pushEval(pft::EvaluationCollection *eval) {
-    assert(funclist && "not in a function");
+  void pushEvaluationList(pft::EvaluationList *eval) {
+    assert(functionList && "not in a function");
     assert(eval && eval->empty() && "evaluation list isn't correct");
-    evallist.emplace_back(eval);
+    evaluationListStack.emplace_back(eval);
   }
 
   /// pop the current list and return to the last Evaluation list
-  void popEval() {
-    assert(funclist && "not in a function");
-    evallist.pop_back();
+  void popEvaluationList() {
+    assert(functionList && "not in a function");
+    evaluationListStack.pop_back();
+  }
+
+  /// Mark I/O statement ERR, EOR, and END specifier branch targets.
+  template <typename A>
+  constexpr void analyzeIoBranches(pft::Evaluation &eval, const A &stmt) {
+    if constexpr (std::is_same_v<A, parser::ReadStmt> ||
+                  std::is_same_v<A, parser::WriteStmt>) {
+      for (const auto &control : stmt.controls) {
+        if (std::holds_alternative<parser::ErrLabel>(control.u) ||
+            std::holds_alternative<parser::EorLabel>(control.u) ||
+            std::holds_alternative<parser::EndLabel>(control.u)) {
+          pft::Evaluation *t{labelEvaluationMap->find(stmt->v)->second};
+          markBranchTarget(eval, *t);
+        }
+      }
+    }
+    if constexpr (std::is_same_v<A, parser::WaitStmt> ||
+                  std::is_same_v<A, parser::OpenStmt> ||
+                  std::is_same_v<A, parser::CloseStmt> ||
+                  std::is_same_v<A, parser::BackspaceStmt> ||
+                  std::is_same_v<A, parser::EndfileStmt> ||
+                  std::is_same_v<A, parser::RewindStmt> ||
+                  std::is_same_v<A, parser::FlushStmt>) {
+      for (const auto &spec : stmt.v) {
+        if (std::holds_alternative<parser::ErrLabel>(spec.u) ||
+            std::holds_alternative<parser::EorLabel>(spec.u) ||
+            std::holds_alternative<parser::EndLabel>(spec.u)) {
+          pft::Evaluation *t{labelEvaluationMap->find(stmt->v)->second};
+          markBranchTarget(eval, *t);
+        }
+      }
+    }
+    if constexpr (std::is_same_v<A, parser::InquireStmt>) {
+      for (const auto &spec :
+           std::get<std::list<parser::InquireSpec>>(stmt.u)) {
+        if (std::holds_alternative<parser::ErrLabel>(spec.u) ||
+            std::holds_alternative<parser::EorLabel>(spec.u) ||
+            std::holds_alternative<parser::EndLabel>(spec.u)) {
+          pft::Evaluation *t{labelEvaluationMap->find(stmt->v)->second};
+          markBranchTarget(eval, *t);
+        }
+      }
+    }
+  }
+
+  void markBranchTarget(pft::Evaluation &sourceEvaluation,
+                        pft::Evaluation &targetEvaluation) {
+    targetEvaluation.isNewBlock = true;
+    sourceEvaluation.isUnstructured = true;
+    if (sourceEvaluation.parentConstruct) {
+      sourceEvaluation.parentConstruct->isUnstructured = true;
+    }
+    if (!sourceEvaluation.controlSuccessor) {
+      sourceEvaluation.controlSuccessor = &targetEvaluation;
+    }
+  }
+  void markBranchTarget(pft::Evaluation &sourceEvaluation,
+                        parser::Label label) {
+    pft::Evaluation *targetEvaluation{labelEvaluationMap->find(label)->second};
+    assert(targetEvaluation && "missing branch target");
+    markBranchTarget(sourceEvaluation, *targetEvaluation);
+  }
+
+  /// Set the exit of a construct, possibly from multiple enclosing constructs.
+  void setConstructExit(pft::Evaluation &eval) {
+    pft::Evaluation *constructExit{
+        eval.evaluationList->back().lexicalSuccessor};
+    // Exit from enclosing constructs with nop end statements.
+    if (eval.parentConstruct &&
+        std::visit(common::visitors{
+                       [](const parser::EndAssociateStmt *) { return true; },
+                       [](const parser::CaseStmt *) { return true; },
+                       [](const parser::EndSelectStmt *) { return true; },
+                       [](const parser::EndChangeTeamStmt *) { return true; },
+                       [](const parser::EndCriticalStmt *) { return true; },
+                       [](const parser::ElseIfStmt *) { return true; },
+                       [](const parser::ElseStmt *) { return true; },
+                       [](const parser::EndIfStmt *) { return true; },
+                       [](const parser::SelectRankCaseStmt *) { return true; },
+                       [](const parser::TypeGuardStmt *) { return true; },
+                       [](const auto *) { return false; },
+                   },
+                   constructExit->u)) {
+      constructExit = eval.parentConstruct->constructExit;
+    }
+    assert(constructExit && "missing construct exit");
+    eval.constructExit = constructExit;
+  }
+
+  /// Return the lexical successor of an Evaluation, accounting for (some) nops.
+  pft::Evaluation *effectiveLexicalSuccessor(pft::Evaluation &eval) {
+    pft::Evaluation *successor{eval.lexicalSuccessor};
+    if (!successor->isNewBlock && eval.parentConstruct &&
+        &eval.parentConstruct->evaluationList->back() == successor) {
+      successor = eval.parentConstruct->constructExit;
+    }
+    assert(successor && "missing effective lexical successor");
+    return successor;
+  }
+
+  /// Mark the effective lexical successor of an Evaluation as a new block.
+  void markSuccessorNewBlock(pft::Evaluation &eval) {
+    effectiveLexicalSuccessor(eval)->isNewBlock = true;
+  }
+
+  template <typename A>
+  constexpr std::string getConstructName(const A &stmt) {
+    if constexpr (std::is_same_v<A, parser::BlockStmt *> ||
+                  std::is_same_v<A, const parser::CycleStmt *> ||
+                  std::is_same_v<A, const parser::ElseStmt *> ||
+                  std::is_same_v<A, const parser::ElsewhereStmt *> ||
+                  std::is_same_v<A, const parser::EndAssociateStmt *> ||
+                  std::is_same_v<A, const parser::EndBlockStmt *> ||
+                  std::is_same_v<A, const parser::EndCriticalStmt *> ||
+                  std::is_same_v<A, const parser::EndDoStmt *> ||
+                  std::is_same_v<A, const parser::EndForallStmt *> ||
+                  std::is_same_v<A, const parser::EndIfStmt *> ||
+                  std::is_same_v<A, const parser::EndSelectStmt *> ||
+                  std::is_same_v<A, const parser::EndWhereStmt *> ||
+                  std::is_same_v<A, const parser::ExitStmt *>) {
+      if (stmt->v) {
+        return stmt->v->ToString();
+      }
+    }
+    if constexpr (std::is_same_v<A, const parser::AssociateStmt *> ||
+                  std::is_same_v<A, const parser::CaseStmt *> ||
+                  std::is_same_v<A, const parser::ChangeTeamStmt *> ||
+                  std::is_same_v<A, const parser::CriticalStmt *> ||
+                  std::is_same_v<A, const parser::ElseIfStmt *> ||
+                  std::is_same_v<A, const parser::EndChangeTeamStmt *> ||
+                  std::is_same_v<A, const parser::ForallConstructStmt *> ||
+                  std::is_same_v<A, const parser::IfThenStmt *> ||
+                  std::is_same_v<A, const parser::LabelDoStmt *> ||
+                  std::is_same_v<A, const parser::MaskedElsewhereStmt *> ||
+                  std::is_same_v<A, const parser::NonLabelDoStmt *> ||
+                  std::is_same_v<A, const parser::SelectCaseStmt *> ||
+                  std::is_same_v<A, const parser::SelectRankCaseStmt *> ||
+                  std::is_same_v<A, const parser::TypeGuardStmt *> ||
+                  std::is_same_v<A, const parser::WhereConstructStmt *>) {
+      if (auto name{std::get<std::optional<parser::Name>>(stmt->t)}) {
+        return name->ToString();
+      }
+    }
+    if constexpr (std::is_same_v<A, const parser::SelectRankStmt *> ||
+                  std::is_same_v<A, const parser::SelectTypeStmt *>) {
+      if (auto name{std::get<0>(stmt->t)}) {
+        return name->ToString();
+      }
+    }
+    return {};
+  }
+
+  template <typename A>
+  void insertConstructName(const A &stmt, pft::Evaluation *parentConstruct) {
+    std::string name{getConstructName(stmt)};
+    if (!name.empty()) {
+      constructNameMap[name] = parentConstruct;
+    }
+  }
+
+  /// Insert branch links for a list of Evaluations.
+  void analyzeBranches(pft::Evaluation *parentConstruct,
+                       std::list<pft::Evaluation> &evaluationList) {
+    pft::Evaluation *lastIfConstructEvaluation{nullptr};
+    pft::Evaluation *lastIfStmtEvaluation{nullptr};
+    for (auto &eval : evaluationList) {
+      std::visit(
+          common::visitors{
+              // Action statements
+              [&](const parser::BackspaceStmt *s) {
+                analyzeIoBranches(eval, s);
+              },
+              [&](const parser::CallStmt *s) {
+                // Look for alternate return specifiers.
+                const auto &args{
+                    std::get<std::list<parser::ActualArgSpec>>(s->v.t)};
+                for (const auto &arg : args) {
+                  const auto &actual{std::get<parser::ActualArg>(arg.t)};
+                  if (const auto *altReturn{
+                          std::get_if<parser::AltReturnSpec>(&actual.u)}) {
+                    markBranchTarget(eval, altReturn->v);
+                  }
+                }
+              },
+              [&](const parser::CloseStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::CycleStmt *s) {
+                std::string name{getConstructName(s)};
+                pft::Evaluation *construct{name.empty()
+                                               ? doConstructStack.back()
+                                               : constructNameMap[name]};
+                assert(construct && "missing CYCLE construct");
+                markBranchTarget(eval, construct->evaluationList->back());
+              },
+              [&](const parser::EndfileStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::ExitStmt *s) {
+                std::string name{getConstructName(s)};
+                pft::Evaluation *construct{name.empty()
+                                               ? doConstructStack.back()
+                                               : constructNameMap[name]};
+                assert(construct && "missing EXIT construct");
+                markBranchTarget(eval, *construct->constructExit);
+              },
+              [&](const parser::FlushStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::GotoStmt *s) { markBranchTarget(eval, s->v); },
+              [&](const parser::IfStmt *) { lastIfStmtEvaluation = &eval; },
+              [&](const parser::InquireStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::OpenStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::ReadStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::ReturnStmt *) { eval.isUnstructured = true; },
+              [&](const parser::RewindStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::StopStmt *) { eval.isUnstructured = true; },
+              [&](const parser::WaitStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::WriteStmt *s) { analyzeIoBranches(eval, s); },
+              [&](const parser::ComputedGotoStmt *s) {
+                for (auto &label : std::get<std::list<parser::Label>>(s->t)) {
+                  markBranchTarget(eval, label);
+                }
+              },
+              [&](const parser::ArithmeticIfStmt *s) {
+                markBranchTarget(eval, std::get<1>(s->t));
+                markBranchTarget(eval, std::get<2>(s->t));
+                markBranchTarget(eval, std::get<3>(s->t));
+              },
+              [&](const parser::AssignStmt *s) { // legacy label assignment
+                auto &label = std::get<parser::Label>(s->t);
+                auto sym = std::get<parser::Name>(s->t).symbol;
+                assert(sym && "missing AssignStmt symbol");
+                pft::Evaluation *t{labelEvaluationMap->find(label)->second};
+                if (!std::get_if<const parser::FormatStmt *const>(&t->u)) {
+                  markBranchTarget(eval, label);
+                }
+                auto iter = assignSymbolLabelMap->find(sym);
+                if (iter == assignSymbolLabelMap->end()) {
+                  assignSymbolLabelMap->try_emplace(
+                      sym, std::set<parser::Label>{label});
+                } else {
+                  iter->second.insert(label);
+                }
+              },
+              [&](const parser::AssignedGotoStmt *) {
+                // Specific control successors are not in general known.
+                // Compensate by directly marking the successor new block.
+                markSuccessorNewBlock(eval);
+              },
+
+              // Construct statements
+              [&](const parser::AssociateStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+              },
+              [&](const parser::BlockStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+              },
+              [&](const parser::SelectCaseStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+                eval.lexicalSuccessor->isNewBlock = true;
+              },
+              [&](const parser::CaseStmt *) { eval.isNewBlock = true; },
+              [&](const parser::ChangeTeamStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+              },
+              [&](const parser::CriticalStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+              },
+              [&](const parser::NonLabelDoStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+                doConstructStack.push_back(parentConstruct);
+                auto &control{
+                    std::get<std::optional<parser::LoopControl>>(s->t)};
+                // eval.block is the loop preheader block, which will be set
+                // elsewhere if the NonLabelDoStmt is itself a target.
+                // eval.localBlocks[0] is the loop header block.
+                eval.localBlocks.emplace_back(nullptr);
+                if (!control.has_value()) {
+                  eval.isUnstructured = true; // infinite loop
+                  return;
+                }
+                eval.lexicalSuccessor->isNewBlock = true;
+                eval.controlSuccessor = &evaluationList.back();
+                if (std::holds_alternative<parser::ScalarLogicalExpr>(
+                        control->u)) {
+                  eval.isUnstructured = true; // while loop
+                }
+                // Defer additional processing for a concurrent loop to the
+                // EndDoStmt, when it is known if the loop is structured or not.
+              },
+              [&](const parser::EndDoStmt *) {
+                pft::Evaluation &doEval{evaluationList.front()};
+                eval.controlSuccessor = &doEval;
+                doConstructStack.pop_back();
+                if (parentConstruct->LowerAsStructured()) {
+                  return;
+                }
+                parentConstruct->constructExit->isNewBlock = true;
+                const auto &doStmt{doEval.getIf<parser::NonLabelDoStmt>()};
+                assert(doStmt && "missing NonLabelDoStmt");
+                auto &control{
+                    std::get<std::optional<parser::LoopControl>>(doStmt->t)};
+                if (!control.has_value()) {
+                  return; // infinite loop
+                }
+                const auto *concurrent{
+                    std::get_if<parser::LoopControl::Concurrent>(&control->u)};
+                if (!concurrent) {
+                  return;
+                }
+                // Unstructured concurrent loop.  NonLabelDoStmt code accounts
+                // for one concurrent loop dimension.  Reserve preheader,
+                // header, and latch blocks for the remaining dimensions, and
+                // one block for a mask expression.
+                const auto &header{
+                    std::get<parser::ConcurrentHeader>(concurrent->t)};
+                auto dims{
+                    std::get<std::list<parser::ConcurrentControl>>(header.t)
+                        .size()};
+                for (; dims > 1; --dims) {
+                  doEval.localBlocks.emplace_back(nullptr); // preheader
+                  doEval.localBlocks.emplace_back(nullptr); // header
+                  eval.localBlocks.emplace_back(nullptr);   // latch
+                }
+                if (std::get<std::optional<parser::ScalarLogicalExpr>>(
+                        header.t)) {
+                  doEval.localBlocks.emplace_back(nullptr); // mask
+                }
+              },
+              [&](const parser::IfThenStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+                eval.lexicalSuccessor->isNewBlock = true;
+                lastIfConstructEvaluation = &eval;
+              },
+              [&](const parser::ElseIfStmt *s) {
+                eval.isNewBlock = true;
+                eval.lexicalSuccessor->isNewBlock = true;
+                lastIfConstructEvaluation->controlSuccessor = &eval;
+                lastIfConstructEvaluation = &eval;
+              },
+              [&](const parser::ElseStmt *s) {
+                eval.isNewBlock = true;
+                lastIfConstructEvaluation->controlSuccessor = &eval;
+                lastIfConstructEvaluation = &eval;
+              },
+              [&](const parser::EndIfStmt *) {
+                if (parentConstruct->LowerAsUnstructured()) {
+                  parentConstruct->constructExit->isNewBlock = true;
+                }
+                lastIfConstructEvaluation->controlSuccessor =
+                    parentConstruct->constructExit;
+                lastIfConstructEvaluation = nullptr;
+              },
+              [&](const parser::SelectRankStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+                eval.lexicalSuccessor->isNewBlock = true;
+              },
+              [&](const parser::SelectRankCaseStmt *) {
+                eval.isNewBlock = true;
+              },
+              [&](const parser::SelectTypeStmt *s) {
+                insertConstructName(&*s, parentConstruct);
+                eval.lexicalSuccessor->isNewBlock = true;
+              },
+              [&](const parser::TypeGuardStmt *) { eval.isNewBlock = true; },
+
+              // Constructs - set (unstructured construct) exit targets
+              [&](const parser::AssociateConstruct *) {
+                setConstructExit(eval);
+              },
+              [&](const parser::BlockConstruct *) {
+                // EndBlockStmt may have exit code.
+                eval.constructExit = &eval.evaluationList->back();
+              },
+              [&](const parser::CaseConstruct *) { setConstructExit(eval); },
+              [&](const parser::ChangeTeamConstruct *) {
+                setConstructExit(eval);
+              },
+              [&](const parser::CriticalConstruct *) {
+                setConstructExit(eval);
+              },
+              [&](const parser::DoConstruct *) { setConstructExit(eval); },
+              [&](const parser::IfConstruct *) { setConstructExit(eval); },
+              [&](const parser::SelectRankConstruct *) {
+                setConstructExit(eval);
+              },
+              [&](const parser::SelectTypeConstruct *) {
+                setConstructExit(eval);
+              },
+
+              [](const auto *) { /* do nothing */ },
+          },
+          eval.u);
+
+      // Analyze branches in a nested construct.
+      if (eval.evaluationList) {
+        analyzeBranches(&eval, *eval.evaluationList);
+      }
+
+      // Insert branch links for an unstructured IF statement.
+      if (lastIfStmtEvaluation && lastIfStmtEvaluation != &eval) {
+        // eval is the action substatement of an IfStmt.
+        if (eval.LowerAsUnstructured()) {
+          eval.isNewBlock = true;
+          markSuccessorNewBlock(eval);
+          lastIfStmtEvaluation->isUnstructured = true;
+        }
+        lastIfStmtEvaluation->controlSuccessor =
+            effectiveLexicalSuccessor(eval);
+        lastIfStmtEvaluation = nullptr;
+      }
+
+      // Set the successor of the last statement in an IF or SELECT block.
+      if (!eval.controlSuccessor && eval.lexicalSuccessor &&
+          std::visit(
+              common::visitors{
+                  [](const parser::CaseStmt *) { return true; },
+                  [](const parser::ElseIfStmt *) { return true; },
+                  [](const parser::ElseStmt *) { return true; },
+                  [](const parser::SelectRankCaseStmt *) { return true; },
+                  [](const parser::TypeGuardStmt *) { return true; },
+                  [](const auto *) { return false; },
+              },
+              eval.lexicalSuccessor->u)) {
+        eval.controlSuccessor = parentConstruct->constructExit;
+        eval.lexicalSuccessor->isNewBlock = true;
+      }
+
+      // The lexical successor of a branch starts a new block.
+      if (eval.controlSuccessor && eval.isActionStmt()) {
+        markSuccessorNewBlock(eval);
+      }
+
+      // Propagate isUnstructured flag to enclosing construct.
+      if (parentConstruct && eval.isUnstructured) {
+        parentConstruct->isUnstructured = true;
+      }
+    }
   }
 
   std::unique_ptr<pft::Program> pgm;
-  /// funclist points to FunctionLikeUnit::funcs list (resp.
-  /// ModuleLikeUnit::funcs) when building a FunctionLikeUnit (resp.
-  /// ModuleLikeUnit) to store internal procedures (resp. module procedures).
-  /// Otherwise (e.g. when building the top level Program), it is null.
-  std::list<pft::FunctionLikeUnit> *funclist{nullptr};
-  /// evallist is a stack of pointer to FunctionLikeUnit::evals (or
-  /// Evaluation::subs) that are being build.
-  std::vector<pft::EvaluationCollection *> evallist;
-  std::vector<pft::ParentType> parents;
+  /// functionList points to the internal or module procedure function list
+  /// of a FunctionLikeUnit or a ModuleLikeUnit.  It may be null.
+  std::list<pft::FunctionLikeUnit> *functionList{nullptr};
+  std::vector<pft::ParentType> parentTypeStack;
+  std::vector<pft::Evaluation *> constructStack{};
+  std::vector<pft::Evaluation *> doConstructStack{};
+  /// evaluationListStack is the current nested construct evaluationList state.
+  std::vector<pft::EvaluationList *> evaluationListStack{};
+  llvm::DenseMap<parser::Label, pft::Evaluation *> *labelEvaluationMap{nullptr};
+  std::map<semantics::Symbol *, std::set<parser::Label>> *assignSymbolLabelMap{
+      nullptr};
+  std::map<std::string, pft::Evaluation *> constructNameMap{};
+  pft::Evaluation *lastLexicalEvaluation{nullptr};
 };
 
 template <typename Label, typename A>
@@ -304,178 +775,6 @@ constexpr bool hasLabel(const A &stmt) {
   return false;
 }
 
-bool hasAltReturns(const parser::CallStmt &callStmt) {
-  const auto &args{std::get<std::list<parser::ActualArgSpec>>(callStmt.v.t)};
-  for (const auto &arg : args) {
-    const auto &actual{std::get<parser::ActualArg>(arg.t)};
-    if (std::holds_alternative<parser::AltReturnSpec>(actual.u))
-      return true;
-  }
-  return false;
-}
-
-/// Determine if `callStmt` has alternate returns and if so set `e` to be the
-/// origin of a switch-like control flow
-///
-/// \param cstr points to the current construct. It may be null at the top-level
-/// of a FunctionLikeUnit.
-void altRet(pft::Evaluation &evaluation, const parser::CallStmt &callStmt,
-            pft::Evaluation *cstr) {
-  if (hasAltReturns(callStmt))
-    evaluation.setCFG(pft::CFGAnnotation::Switch, cstr);
-}
-
-/// \param cstr points to the current construct. It may be null at the top-level
-/// of a FunctionLikeUnit.
-void annotateEvalListCFG(pft::EvaluationCollection &evaluationCollection,
-                         pft::Evaluation *cstr) {
-  bool nextIsTarget = false;
-  for (auto &eval : evaluationCollection) {
-    eval.isTarget = nextIsTarget;
-    nextIsTarget = false;
-    if (auto *subs{eval.getConstructEvals()}) {
-      annotateEvalListCFG(*subs, &eval);
-      // assume that the entry and exit are both possible branch targets
-      nextIsTarget = true;
-    }
-
-    if (eval.isActionOrGenerated() && eval.lab.has_value())
-      eval.isTarget = true;
-    eval.visit(common::visitors{
-        [&](const parser::CallStmt &statement) {
-          altRet(eval, statement, cstr);
-        },
-        [&](const parser::CycleStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
-        },
-        [&](const parser::ExitStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
-        },
-        [&](const parser::FailImageStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
-        },
-        [&](const parser::GotoStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
-        },
-        [&](const parser::IfStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
-        },
-        [&](const parser::ReturnStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Return, cstr);
-        },
-        [&](const parser::StopStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Terminate, cstr);
-        },
-        [&](const parser::ArithmeticIfStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
-        },
-        [&](const parser::AssignedGotoStmt &) {
-          eval.setCFG(pft::CFGAnnotation::IndGoto, cstr);
-        },
-        [&](const parser::ComputedGotoStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
-        },
-        [&](const parser::WhereStmt &) {
-          // fir.loop + fir.where around the next stmt
-          eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
-        },
-        [&](const parser::ForallStmt &) {
-          // fir.loop around the next stmt
-          eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
-        },
-        [&](pft::CGJump &) { eval.setCFG(pft::CFGAnnotation::Goto, cstr); },
-        [&](const parser::SelectCaseStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
-        },
-        [&](const parser::NonLabelDoStmt &) {
-          eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
-        },
-        [&](const parser::EndDoStmt &) {
-          eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Goto, cstr);
-        },
-        [&](const parser::IfThenStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
-        },
-        [&](const parser::ElseIfStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
-        },
-        [&](const parser::SelectRankStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
-        },
-        [&](const parser::SelectTypeStmt &) {
-          eval.setCFG(pft::CFGAnnotation::Switch, cstr);
-        },
-        [&](const parser::WhereConstruct &) {
-          // mark the WHERE as if it were a DO loop
-          eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
-        },
-        [&](const parser::WhereConstructStmt &) {
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
-        },
-        [&](const parser::MaskedElsewhereStmt &) {
-          eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::CondGoto, cstr);
-        },
-        [&](const parser::ForallConstructStmt &) {
-          eval.isTarget = true;
-          eval.setCFG(pft::CFGAnnotation::Iterative, cstr);
-        },
-
-        [&](const auto &stmt) {
-          // Handle statements with similar impact on control flow
-          using IoStmts = std::tuple<parser::BackspaceStmt, parser::CloseStmt,
-                                     parser::EndfileStmt, parser::FlushStmt,
-                                     parser::InquireStmt, parser::OpenStmt,
-                                     parser::ReadStmt, parser::RewindStmt,
-                                     parser::WaitStmt, parser::WriteStmt>;
-
-          using TargetStmts =
-              std::tuple<parser::EndAssociateStmt, parser::EndBlockStmt,
-                         parser::CaseStmt, parser::EndSelectStmt,
-                         parser::EndChangeTeamStmt, parser::EndCriticalStmt,
-                         parser::ElseStmt, parser::EndIfStmt,
-                         parser::SelectRankCaseStmt, parser::TypeGuardStmt,
-                         parser::ElsewhereStmt, parser::EndWhereStmt,
-                         parser::EndForallStmt>;
-
-          using DoNothingConstructStmts =
-              std::tuple<parser::BlockStmt, parser::AssociateStmt,
-                         parser::CriticalStmt, parser::ChangeTeamStmt>;
-
-          using A = std::decay_t<decltype(stmt)>;
-          if constexpr (common::HasMember<A, IoStmts>) {
-            if (hasLabel<parser::ErrLabel>(stmt) ||
-                hasLabel<parser::EorLabel>(stmt) ||
-                hasLabel<parser::EndLabel>(stmt))
-              eval.setCFG(pft::CFGAnnotation::IoSwitch, cstr);
-          } else if constexpr (common::HasMember<A, TargetStmts>) {
-            eval.isTarget = true;
-          } else if constexpr (common::HasMember<A, DoNothingConstructStmts>) {
-            // Explicitly do nothing for these construct statements
-          } else {
-            static_assert(!pft::isConstructStmt<A>,
-                          "All ConstructStmts impact on the control flow "
-                          "should be explicitly handled");
-          }
-          /* else do nothing */
-        },
-    });
-  }
-}
-
-/// Annotate the PFT with CFG source decorations (see CFGAnnotation) and mark
-/// potential branch targets
-inline void annotateFuncCFG(pft::FunctionLikeUnit &functionLikeUnit) {
-  annotateEvalListCFG(functionLikeUnit.evals, nullptr);
-  for (auto &internalFunc : functionLikeUnit.funcs)
-    annotateFuncCFG(internalFunc);
-}
-
 class PFTDumper {
 public:
   void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
@@ -495,35 +794,53 @@ class PFTDumper {
                  },
                  unit);
     }
-    resetIndexes();
   }
 
-  llvm::StringRef evalName(pft::Evaluation &eval) {
+  llvm::StringRef evaluationName(pft::Evaluation &eval) {
     return eval.visit(common::visitors{
-        [](const pft::CGJump) { return "CGJump"; },
         [](const auto &parseTreeNode) {
           return parser::ParseTreeDumper::GetNodeName(parseTreeNode);
         },
     });
   }
 
-  void dumpEvalList(llvm::raw_ostream &outputStream,
-                    pft::EvaluationCollection &evaluationCollection,
-                    int indent = 1) {
+  void dumpEvaluationList(llvm::raw_ostream &outputStream,
+                          pft::EvaluationList &evaluationList, int indent = 1) {
     static const std::string white{"                                      ++"};
     std::string indentString{white.substr(0, indent * 2)};
-    for (pft::Evaluation &eval : evaluationCollection) {
-      outputStream << indentString << getNodeIndex(eval) << " ";
-      llvm::StringRef name{evalName(eval)};
-      if (auto *subs{eval.getConstructEvals()}) {
-        outputStream << "<<" << name << ">>";
-        outputStream << "\n";
-        dumpEvalList(outputStream, *subs, indent + 1);
-        outputStream << indentString << "<<End" << name << ">>\n";
-      } else {
-        outputStream << name;
-        outputStream << ": " << eval.pos.ToString() + "\n";
+    for (pft::Evaluation &eval : evaluationList) {
+      llvm::StringRef name{evaluationName(eval)};
+      std::string bang{eval.isUnstructured ? "!" : ""};
+      if (eval.isConstruct()) {
+        outputStream << indentString << "<<" << name << bang << ">>";
+        if (eval.constructExit) {
+          outputStream << " -> " << eval.constructExit->printIndex;
+        }
+        outputStream << '\n';
+        dumpEvaluationList(outputStream, *eval.evaluationList, indent + 1);
+        outputStream << indentString << "<<End " << name << bang << ">>\n";
+        continue;
+      }
+      outputStream << indentString;
+      if (eval.printIndex) {
+        outputStream << eval.printIndex << ' ';
+      }
+      if (eval.isNewBlock) {
+        outputStream << '^';
+      }
+      if (eval.localBlocks.size()) {
+        outputStream << '*';
+      }
+      outputStream << name << bang;
+      if (eval.isActionStmt() || eval.isConstructStmt()) {
+        if (eval.controlSuccessor) {
+          outputStream << " -> " << eval.controlSuccessor->printIndex;
+        }
+      }
+      if (eval.position.size()) {
+        outputStream << ": " << eval.position.ToString();
       }
+      outputStream << '\n';
     }
   }
 
@@ -569,10 +886,10 @@ class PFTDumper {
     if (header.size())
       outputStream << ": " << header;
     outputStream << '\n';
-    dumpEvalList(outputStream, functionLikeUnit.evals);
-    if (!functionLikeUnit.funcs.empty()) {
+    dumpEvaluationList(outputStream, functionLikeUnit.evaluationList);
+    if (!functionLikeUnit.containedFunctions.empty()) {
       outputStream << "\nContains\n";
-      for (auto &func : functionLikeUnit.funcs)
+      for (auto &func : functionLikeUnit.containedFunctions)
         dumpFunctionLikeUnit(outputStream, func);
       outputStream << "EndContains\n";
     }
@@ -584,7 +901,7 @@ class PFTDumper {
     outputStream << getNodeIndex(moduleLikeUnit) << " ";
     outputStream << "ModuleLike: ";
     outputStream << "\nContains\n";
-    for (auto &func : moduleLikeUnit.funcs)
+    for (auto &func : moduleLikeUnit.containedFunctions)
       dumpFunctionLikeUnit(outputStream, func);
     outputStream << "EndContains\nEndModuleLike\n\n";
   }
@@ -601,11 +918,6 @@ class PFTDumper {
   }
   std::size_t getNodeIndex(const pft::Program &) { return 0; }
 
-  void resetIndexes() {
-    nodeIndexes.clear();
-    nextIndex = 1;
-  }
-
 private:
   llvm::DenseMap<const void *, std::size_t> nodeIndexes;
   std::size_t nextIndex{1}; // 0 is the root
@@ -624,6 +936,18 @@ pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
 
 } // namespace
 
+llvm::cl::opt<bool> ClDisableStructuredFir(
+    "no-structured-fir", llvm::cl::desc("disable generation of structured FIR"),
+    llvm::cl::init(false), llvm::cl::Hidden);
+
+bool pft::Evaluation::LowerAsStructured() const {
+  return !LowerAsUnstructured();
+}
+
+bool pft::Evaluation::LowerAsUnstructured() const {
+  return isUnstructured || ClDisableStructuredFir;
+}
+
 pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
                                         const pft::ParentType &parent)
     : ProgramUnit{func, parent} {
@@ -675,20 +999,6 @@ std::unique_ptr<pft::Program> createPFT(const parser::Program &root) {
   return walker.result();
 }
 
-void annotateControl(pft::Program &pft) {
-  for (auto &unit : pft.getUnits()) {
-    std::visit(common::visitors{
-                   [](pft::BlockDataUnit &) {},
-                   [](pft::FunctionLikeUnit &func) { annotateFuncCFG(func); },
-                   [](pft::ModuleLikeUnit &unit) {
-                     for (auto &func : unit.funcs)
-                       annotateFuncCFG(func);
-                   },
-               },
-               unit);
-  }
-}
-
 void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
   PFTDumper{}.dumpPFT(outputStream, pft);
 }
diff --git a/test/Lower/pre-fir-tree01.f90 b/test/Lower/pre-fir-tree01.f90
index 97f15eea052e..6b27add4659f 100644
--- a/test/Lower/pre-fir-tree01.f90
+++ b/test/Lower/pre-fir-tree01.f90
@@ -16,10 +16,10 @@ subroutine foo()
       print *, "hello", i, j
     ! CHECK: EndDoStmt
     end do
-    ! CHECK: <<EndDoConstruct>>
+    ! CHECK: <<End DoConstruct>>
   ! CHECK: EndDoStmt
   end do
-  ! CHECK: <<EndDoConstruct>>
+  ! CHECK: <<End DoConstruct>>
 end subroutine
 ! CHECK: EndSubroutine foo
 
@@ -102,7 +102,7 @@ function subfoo2()
       write (*, 11) "test: ", xdim, pressure
     ! CHECK: EndIfStmt
     end if
-    ! CHECK: <<EndIfConstruct>>
+    ! CHECK: <<End IfConstruct>>
   end procedure
 end submodule
 ! CHECK: EndModuleLike
diff --git a/test/Lower/pre-fir-tree02.f90 b/test/Lower/pre-fir-tree02.f90
index ec9077a550a2..f2b6e47aa19e 100644
--- a/test/Lower/pre-fir-tree02.f90
+++ b/test/Lower/pre-fir-tree02.f90
@@ -27,10 +27,10 @@ subroutine incr(i)
       print *, "hello", i, j
     ! CHECK: EndDoStmt
     end do
-    ! CHECK: <<EndDoConstruct>>
+    ! CHECK: <<End DoConstruct>>
   ! CHECK: EndDoStmt
   end do
-  ! CHECK: <<EndDoConstruct>>
+  ! CHECK: <<End DoConstruct>>
 
   ! CHECK: <<AssociateConstruct>>
   ! CHECK: AssociateStmt
@@ -39,9 +39,9 @@ subroutine incr(i)
     allocate(x(k))
   ! CHECK: EndAssociateStmt
   end associate
-  ! CHECK: <<EndAssociateConstruct>>
+  ! CHECK: <<End AssociateConstruct>>
 
-  ! CHECK: <<BlockConstruct>>
+  ! CHECK: <<BlockConstruct!>>
   ! CHECK: BlockStmt
   block
     integer :: k, l
@@ -52,7 +52,7 @@ subroutine incr(i)
     k = size(p)
     ! CHECK: AssignmentStmt
     l = 1
-    ! CHECK: <<CaseConstruct>>
+    ! CHECK: <<CaseConstruct!>>
     ! CHECK: SelectCaseStmt
     select case (k)
       ! CHECK: CaseStmt
@@ -76,13 +76,13 @@ subroutine incr(i)
           print *, "-"
         ! CHECK: EndIfStmt
         end if
-        ! CHECK: <<EndIfConstruct>>
+        ! CHECK: <<End IfConstruct>>
         ! CHECK: CaseStmt
       case (2:10)
       ! CHECK: CaseStmt
       case default
         ! Note: label-do-loop are canonicalized into do constructs
-        ! CHECK: <<DoConstruct>>
+        ! CHECK: <<DoConstruct!>>
         ! CHECK: NonLabelDoStmt
         do 22 while(l<=k)
           ! CHECK: IfStmt
@@ -90,15 +90,15 @@ subroutine incr(i)
           ! CHECK: CallStmt
 22        call incr(l)
         ! CHECK: EndDoStmt
-       ! CHECK: <<EndDoConstruct>>
+       ! CHECK: <<End DoConstruct!>>
       ! CHECK: CaseStmt
       case (100:)
     ! CHECK: EndSelectStmt
     end select
-  ! CHECK: <<EndCaseConstruct>>
+  ! CHECK: <<End CaseConstruct!>>
   ! CHECK: EndBlockStmt
   end block
-  ! CHECK: <<EndBlockConstruct>>
+  ! CHECK: <<End BlockConstruct!>>
 
   ! CHECK-NOT: WhereConstruct
   ! CHECK: WhereStmt
@@ -118,14 +118,14 @@ subroutine incr(i)
       ! CHECK: AssignmentStmt
       y = y/2.
     end where
-    ! CHECK: <<EndWhereConstruct>>
+    ! CHECK: <<End WhereConstruct>>
   ! CHECK: ElsewhereStmt
   elsewhere
     ! CHECK: AssignmentStmt
     x = x + 1.
   ! CHECK: EndWhereStmt
   end where
-  ! CHECK: <<EndWhereConstruct>>
+  ! CHECK: <<End WhereConstruct>>
 
   ! CHECK-NOT: ForAllConstruct
   ! CHECK: ForallStmt
@@ -138,7 +138,7 @@ subroutine incr(i)
     x(i) = x(i) + y(10*i)
   ! CHECK: EndForallStmt
   end forall
-  ! CHECK: <<EndForallConstruct>>
+  ! CHECK: <<End ForallConstruct>>
 
   ! CHECK: DeallocateStmt
   deallocate(x)
@@ -178,13 +178,13 @@ function foo(x)
         foo = 2
     ! CHECK: EndSelectStmt
     end select
-    ! CHECK: <<EndSelectRankConstruct>>
+    ! CHECK: <<End SelectRankConstruct>>
   end function
 
   ! CHECK: Function bar
   function bar(x)
     class(*) :: x
-    ! CHECK: <<SelectTypeConstruct>>
+    ! CHECK: <<SelectTypeConstruct!>>
     ! CHECK: SelectTypeStmt
     select type(x)
       ! CHECK: TypeGuardStmt
@@ -203,7 +203,7 @@ function bar(x)
         bar = -1
     ! CHECK: EndSelectStmt
     end select
-    ! CHECK: <<EndSelectTypeConstruct>>
+    ! CHECK: <<End SelectTypeConstruct!>>
   end function
 
   ! CHECK: Subroutine sub
@@ -219,7 +219,7 @@ subroutine sub(a)
 
 ! CHECK: Subroutine altreturn
 subroutine altreturn(i, j, *, *)
-  ! CHECK: <<IfConstruct>>
+  ! CHECK: <<IfConstruct!>>
   if (i>j) then
     ! CHECK: ReturnStmt
     return 1
@@ -227,7 +227,7 @@ subroutine altreturn(i, j, *, *)
     ! CHECK: ReturnStmt
     return 2
   end if
-  ! CHECK: <<EndIfConstruct>>
+  ! CHECK: <<End IfConstruct!>>
 end subroutine
 
 
@@ -246,7 +246,7 @@ subroutine iostmts(filename, a, b, c)
     ! CHECK: OpenStmt
     open(10, FILE=filename)
   end if
-  ! CHECK: <<EndIfConstruct>>
+  ! CHECK: <<End IfConstruct>>
   ! CHECK: ReadStmt
   read(10, *) length
   ! CHECK: RewindStmt
@@ -297,18 +297,18 @@ subroutine sub2()
 5 j = j + 1
 6 i = i + j/2
 
-  ! CHECK: <<DoConstruct>>
+  ! CHECK: <<DoConstruct!>>
   do1: do k=1,10
-    ! CHECK: <<DoConstruct>>
+    ! CHECK: <<DoConstruct!>>
     do2: do l=5,20
       ! CHECK: CycleStmt
       cycle do1
       ! CHECK: ExitStmt
       exit do2
     end do do2
-    ! CHECK: <<EndDoConstruct>>
+    ! CHECK: <<End DoConstruct!>>
   end do do1
-  ! CHECK: <<EndDoConstruct>>
+  ! CHECK: <<End DoConstruct!>>
 
   ! CHECK: PauseStmt
   pause 7
diff --git a/test/Lower/pre-fir-tree03.f90 b/test/Lower/pre-fir-tree03.f90
index 2eedfe7610ce..1c8651b64f83 100644
--- a/test/Lower/pre-fir-tree03.f90
+++ b/test/Lower/pre-fir-tree03.f90
@@ -20,10 +20,10 @@ program test_omp
       print *, "in omp do"
     ! CHECK: EndDoStmt
     end do
-    ! CHECK: <<EndDoConstruct>>
+    ! CHECK: <<End DoConstruct>>
     ! CHECK: OmpEndLoopDirective
     !$omp end do
-    ! CHECK: <<EndOpenMPConstruct>>
+    ! CHECK: <<End OpenMPConstruct>>
 
     ! CHECK: PrintStmt
     print *, "not in omp do"
@@ -37,13 +37,13 @@ program test_omp
       print *, "in omp do"
     ! CHECK: EndDoStmt
     end do
-    ! CHECK: <<EndDoConstruct>>
-    ! CHECK: <<EndOpenMPConstruct>>
+    ! CHECK: <<End DoConstruct>>
+    ! CHECK: <<End OpenMPConstruct>>
     ! CHECK-NOT: OmpEndLoopDirective
     ! CHECK: PrintStmt
     print *, "no in omp do"
   !$omp end parallel
-    ! CHECK: <<EndOpenMPConstruct>>
+    ! CHECK: <<End OpenMPConstruct>>
 
   ! CHECK: PrintStmt
   print *, "sequential again"
@@ -53,7 +53,7 @@ program test_omp
     ! CHECK: PrintStmt
     print *, "in task"
   !$omp end task
-  ! CHECK: <<EndOpenMPConstruct>>
+  ! CHECK: <<End OpenMPConstruct>>
 
   ! CHECK: PrintStmt
   print *, "sequential again"
diff --git a/test/Lower/pre-fir-tree04.f90 b/test/Lower/pre-fir-tree04.f90
index 3e8516e57bbb..2e1e8f1b4377 100644
--- a/test/Lower/pre-fir-tree04.f90
+++ b/test/Lower/pre-fir-tree04.f90
@@ -16,7 +16,7 @@ Subroutine test_coarray
     ! CHECK: AssignmentStmt
     x = x[4, 1]
   end team
-  ! CHECK: <<EndChangeTeamConstruct>>
+  ! CHECK: <<End ChangeTeamConstruct>>
   ! CHECK: FormTeamStmt
   form team(1, t)
 
@@ -28,14 +28,14 @@ Subroutine test_coarray
     ! CHECK: EventWaitStmt
     event wait (done)
   end if
-  ! CHECK: <<EndIfConstruct>>
+  ! CHECK: <<End IfConstruct>>
 
   ! CHECK: <<CriticalConstruct>>
   critical
     ! CHECK: AssignmentStmt
     counter[1] = counter[1] + 1
   end critical
-  ! CHECK: <<EndCriticalConstruct>>
+  ! CHECK: <<End CriticalConstruct>>
 
   ! CHECK: LockStmt
   lock(alock)
@@ -59,12 +59,12 @@ Subroutine test_coarray
     ! CHECK: SyncImagesStmt
     sync images(1)
   end if
-  ! CHECK: <<EndIfConstruct>>
+  ! CHECK: <<End IfConstruct>>
 
   ! CHECK: <<IfConstruct>>
   if (y<0.) then
     ! CHECK: FailImageStmt
    fail image
   end if
-  ! CHECK: <<EndIfConstruct>>
+  ! CHECK: <<End IfConstruct>>
 end
diff --git a/tools/f18/f18.cpp b/tools/f18/f18.cpp
index 5538c9fc3e9a..c2492433d985 100644
--- a/tools/f18/f18.cpp
+++ b/tools/f18/f18.cpp
@@ -316,7 +316,6 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
   }
   if (driver.dumpPreFirTree) {
     if (auto ast{Fortran::lower::createPFT(parseTree)}) {
-      Fortran::lower::annotateControl(*ast);
       Fortran::lower::dumpPFT(llvm::outs(), *ast);
     } else {
       llvm::errs() << "Pre FIR Tree is NULL.\n";

From d234c40167411946a04132cbd5f72b6ea509a694 Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Mon, 2 Mar 2020 18:31:39 -0800
Subject: [PATCH 223/345] Update for review comments.

---
 include/flang/Lower/PFTBuilder.h | 27 ++++++++++++++++-----------
 lib/Lower/Bridge.cpp             | 31 ++++++++++++-------------------
 lib/Lower/PFTBuilder.cpp         | 22 ++++++++++------------
 3 files changed, 38 insertions(+), 42 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 77e0f50256c6..9de65b103842 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -8,13 +8,6 @@
 //
 // PFT (Pre-FIR Tree) interface.
 //
-// A PFT is a light weight tree over the parse tree that is used to create FIR.
-// The PFT captures pointers back into the parse tree, so the parse tree must
-// not be changed between the construction of the PFT and its last use.
-// The PFT captures a structured view of a program.  A program is a list of
-// units.  A function like unit contains a list of evaluations.  An evaluation
-// is either a statement, or a construct with a nested list of evaluations.
-//
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_PFTBUILDER_H_
@@ -23,9 +16,9 @@
 #include "flang/Common/template.h"
 #include "flang/Parser/parse-tree.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
-#include <set>
 
 namespace mlir {
 class Block;
@@ -109,6 +102,9 @@ static constexpr bool isFunctionLike{common::HasMember<
                   parser::SubroutineSubprogram,
                   parser::SeparateModuleSubprogram>>};
 
+using LabelSet = llvm::SmallSet<parser::Label, 5>;
+using SymbolLabelMap = std::map<semantics::Symbol *, LabelSet>;
+
 /// Function-like units can contain lists of evaluations.  These can be
 /// (simple) statements or constructs, where a construct contains its own
 /// evaluations.
@@ -177,8 +173,8 @@ struct Evaluation {
         [](auto &r) { return pft::isConstruct<std::decay_t<decltype(r)>>; }});
   }
 
-  bool LowerAsStructured() const;
-  bool LowerAsUnstructured() const;
+  bool lowerAsStructured() const;
+  bool lowerAsUnstructured() const;
 
   // FIR generation looks primarily at PFT statement (leaf) nodes.  So members
   // such as lexicalSuccessor and the various block fields are only applicable
@@ -277,6 +273,7 @@ struct FunctionLikeUnit : public ProgramUnit {
     return std::holds_alternative<
         const parser::Statement<parser::EndProgramStmt> *>(endStmt);
   }
+
   const parser::FunctionStmt *getFunction() {
     return getA<parser::FunctionStmt>();
   }
@@ -292,7 +289,7 @@ struct FunctionLikeUnit : public ProgramUnit {
   FunctionStatement endStmt;
   EvaluationList evaluationList;
   llvm::DenseMap<parser::Label, Evaluation *> labelEvaluationMap;
-  std::map<semantics::Symbol *, std::set<parser::Label>> assignSymbolLabelMap;
+  SymbolLabelMap assignSymbolLabelMap;
   std::list<FunctionLikeUnit> containedFunctions;
 
 private:
@@ -353,6 +350,14 @@ struct Program {
 } // namespace pft
 
 /// Create a PFT (Pre-FIR Tree) from the parse tree.
+///
+/// A PFT (Pre-FIR Tree) is a light weight tree over the parse tree that is
+/// used to create FIR.  The PFT captures pointers back into the parse tree,
+/// so the parse tree must not be changed between the construction of the
+/// PFT and its last use.  The PFT captures a structured view of a program.
+/// A program is a list of units.  A function like unit contains a list of
+/// evaluations.  An evaluation is either a statement, or a construct with a
+/// nested list of evaluations.
 std::unique_ptr<pft::Program> createPFT(const parser::Program &root);
 
 /// Dumper for displaying a PFT.
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 72031b37b2ce..7e3d42df98ec 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -49,11 +49,6 @@ llvm::cl::opt<bool>
                           llvm::cl::desc("disable burnside bridge asserts"),
                           llvm::cl::init(false), llvm::cl::Hidden);
 
-static constexpr bool isStopStmt(const Fortran::parser::StopStmt &stmt) {
-  return std::get<Fortran::parser::StopStmt::Kind>(stmt.t) ==
-         Fortran::parser::StopStmt::Kind::Stop;
-}
-
 /// Converter from PFT to FIR
 ///
 /// After building the PFT, the FirConverter processes that representation
@@ -387,7 +382,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::IfStmt &stmt) {
-    if (eval.LowerAsUnstructured()) {
+    if (eval.lowerAsUnstructured()) {
       genFIRConditionalBranch(
           std::get<Fortran::parser::ScalarLogicalExpr>(stmt.t),
           eval.lexicalSuccessor, eval.controlSuccessor);
@@ -492,7 +487,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   ///  - structured and unstructured concurrent loops
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::DoConstruct &) {
-    bool unstructuredContext{eval.LowerAsUnstructured()};
+    bool unstructuredContext{eval.lowerAsUnstructured()};
     Fortran::lower::pft::Evaluation &doStmtEval{eval.evaluationList->front()};
     auto *doStmt{doStmtEval.getIf<Fortran::parser::NonLabelDoStmt>()};
     assert(doStmt && "missing DO statement");
@@ -644,7 +639,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   /// Generate structured or unstructured FIR for an IF construct.
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::IfConstruct &) {
-    if (eval.LowerAsStructured()) {
+    if (eval.lowerAsStructured()) {
       // Structured fir.where nest.
       fir::WhereOp where;
       mlir::OpBuilder::InsertPoint insertionPoint{
@@ -725,24 +720,24 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               [&](const Fortran::parser::Statement<
                   Fortran::parser::ForallAssignmentStmt> &b) {
                 setCurrentPosition(b.source);
-                // genFIR(eval, b.statement);
+                genFIR(eval, b.statement);
               },
               [&](const Fortran::parser::Statement<Fortran::parser::WhereStmt>
                       &b) {
                 setCurrentPosition(b.source);
-                // genFIR(eval, b.statement);
+                genFIR(eval, b.statement);
               },
               [&](const Fortran::parser::WhereConstruct &b) {
-                // genFIR(eval, b);
+                genFIR(eval, b);
               },
               [&](const Fortran::common::Indirection<
                   Fortran::parser::ForallConstruct> &b) {
-                // genFIR(eval, b.value());
+                genFIR(eval, b.value());
               },
               [&](const Fortran::parser::Statement<Fortran::parser::ForallStmt>
                       &b) {
                 setCurrentPosition(b.source);
-                // genFIR(eval, b.statement);
+                genFIR(eval, b.statement);
               },
           },
           s.u);
@@ -1149,8 +1144,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               const Fortran::parser::StopStmt &stmt) {
     auto callee{genRuntimeFunction(
         Fortran::lower::RuntimeEntryCode::StopStatement, *builder)};
-    // TODO: 3 args: stop-code-opt, ierror, quiet-opt
-    // auto isError{genFIRLo!isStopStmt(stmt)}
     llvm::SmallVector<mlir::Value, 8> operands;
     builder->create<mlir::CallOp>(toLocation(), callee, operands);
   }
@@ -1195,12 +1188,12 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     if (unstructuredContext) {
       // When transitioning from unstructured to structured code,
       // the structured code might be a target that starts a new block.
-      maybeStartBlock(eval.isConstruct() && eval.LowerAsStructured()
+      maybeStartBlock(eval.isConstruct() && eval.lowerAsStructured()
                           ? eval.evaluationList->front().block
                           : eval.block);
     }
     std::visit([&](const auto *p) { genFIR(eval, *p); }, eval.u);
-    if (unstructuredContext && eval.LowerAsUnstructured() &&
+    if (unstructuredContext && eval.lowerAsUnstructured() &&
         eval.controlSuccessor && eval.isActionStmt() && blockIsUnterminated()) {
       // Exit from an unstructured IF or SELECT construct block.
       genFIRUnconditionalBranch(eval.controlSuccessor);
@@ -1264,11 +1257,11 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       if (eval.isNewBlock) {
         eval.block = Fortran::lower::createBlock(builder);
       }
-      for (size_t i{0}; i < eval.localBlocks.size(); ++i) {
+      for (size_t i{0}, n{eval.localBlocks.size()}; i < n; ++i) {
         eval.localBlocks[i] = Fortran::lower::createBlock(builder);
       }
       if (eval.isConstruct()) {
-        if (eval.LowerAsUnstructured()) {
+        if (eval.lowerAsUnstructured()) {
           createEmptyBlocks(*eval.evaluationList);
         } else {
           // A structured construct that is a target starts a new block.
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 491e616d63c4..a8b4ae2f363f 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -195,8 +195,6 @@ class PFTBuilder {
     assignSymbolLabelMap = nullptr;
     parentTypeStack.pop_back();
     ResetFunctionList();
-    labelEvaluationMap = nullptr;
-    assignSymbolLabelMap = nullptr;
   }
 
   /// Initialize a new construct and make it the builder's focus.
@@ -531,8 +529,9 @@ class PFTBuilder {
                 }
                 auto iter = assignSymbolLabelMap->find(sym);
                 if (iter == assignSymbolLabelMap->end()) {
-                  assignSymbolLabelMap->try_emplace(
-                      sym, std::set<parser::Label>{label});
+                  pft::LabelSet ls{};
+                  ls.insert(label);
+                  assignSymbolLabelMap->try_emplace(sym, ls);
                 } else {
                   iter->second.insert(label);
                 }
@@ -587,7 +586,7 @@ class PFTBuilder {
                 pft::Evaluation &doEval{evaluationList.front()};
                 eval.controlSuccessor = &doEval;
                 doConstructStack.pop_back();
-                if (parentConstruct->LowerAsStructured()) {
+                if (parentConstruct->lowerAsStructured()) {
                   return;
                 }
                 parentConstruct->constructExit->isNewBlock = true;
@@ -639,7 +638,7 @@ class PFTBuilder {
                 lastIfConstructEvaluation = &eval;
               },
               [&](const parser::EndIfStmt *) {
-                if (parentConstruct->LowerAsUnstructured()) {
+                if (parentConstruct->lowerAsUnstructured()) {
                   parentConstruct->constructExit->isNewBlock = true;
                 }
                 lastIfConstructEvaluation->controlSuccessor =
@@ -695,7 +694,7 @@ class PFTBuilder {
       // Insert branch links for an unstructured IF statement.
       if (lastIfStmtEvaluation && lastIfStmtEvaluation != &eval) {
         // eval is the action substatement of an IfStmt.
-        if (eval.LowerAsUnstructured()) {
+        if (eval.lowerAsUnstructured()) {
           eval.isNewBlock = true;
           markSuccessorNewBlock(eval);
           lastIfStmtEvaluation->isUnstructured = true;
@@ -743,8 +742,7 @@ class PFTBuilder {
   /// evaluationListStack is the current nested construct evaluationList state.
   std::vector<pft::EvaluationList *> evaluationListStack{};
   llvm::DenseMap<parser::Label, pft::Evaluation *> *labelEvaluationMap{nullptr};
-  std::map<semantics::Symbol *, std::set<parser::Label>> *assignSymbolLabelMap{
-      nullptr};
+  pft::SymbolLabelMap *assignSymbolLabelMap{nullptr};
   std::map<std::string, pft::Evaluation *> constructNameMap{};
   pft::Evaluation *lastLexicalEvaluation{nullptr};
 };
@@ -940,11 +938,11 @@ llvm::cl::opt<bool> ClDisableStructuredFir(
     "no-structured-fir", llvm::cl::desc("disable generation of structured FIR"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
-bool pft::Evaluation::LowerAsStructured() const {
-  return !LowerAsUnstructured();
+bool pft::Evaluation::lowerAsStructured() const {
+  return !lowerAsUnstructured();
 }
 
-bool pft::Evaluation::LowerAsUnstructured() const {
+bool pft::Evaluation::lowerAsUnstructured() const {
   return isUnstructured || ClDisableStructuredFir;
 }
 

From 05aecbd3600c90dab068f7ca4a5c4c8afd1a303e Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Tue, 3 Mar 2020 10:29:58 -0800
Subject: [PATCH 224/345] Switch initialization style

---
 lib/Lower/Bridge.cpp | 235 ++++++++++++++++++++++---------------------
 1 file changed, 118 insertions(+), 117 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 7e3d42df98ec..dada1e9a6534 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -81,7 +81,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   mlir::FuncOp genFunctionFIR(llvm::StringRef callee,
                               mlir::FunctionType funcTy) {
-    if (auto func{Fortran::lower::getNamedFunction(module, callee)}) {
+    if (auto func = Fortran::lower::getNamedFunction(module, callee)) {
       return func;
     }
     return createFunction(*this, callee, funcTy);
@@ -172,8 +172,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void genFIRConditionalBranch(const Fortran::parser::ScalarLogicalExpr &expr,
                                Fortran::lower::pft::Evaluation *trueTarget,
                                Fortran::lower::pft::Evaluation *falseTarget) {
-    mlir::Value cond{
-        createLogicalExprAsI1(toLocation(), Fortran::semantics::GetExpr(expr))};
+    mlir::Value cond =
+        createLogicalExprAsI1(toLocation(), Fortran::semantics::GetExpr(expr));
     genFIRConditionalBranch(cond, trueTarget->block, falseTarget->block);
   }
 
@@ -197,7 +197,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   genFIR(const Fortran::parser::Statement<Fortran::parser::FunctionStmt> &stmt,
          std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n{std::get<Fortran::parser::Name>(stmt.statement.t)};
+    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
     name = mangleName(*symbol);
@@ -213,7 +213,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       const Fortran::parser::Statement<Fortran::parser::SubroutineStmt> &stmt,
       std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n{std::get<Fortran::parser::Name>(stmt.statement.t)};
+    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
     symbol = n.symbol;
     assert(symbol && "Name resolution failure");
     name = mangleName(*symbol);
@@ -230,7 +230,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       const Fortran::parser::Statement<Fortran::parser::MpSubprogramStmt> &stmt,
       std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
-    auto &n{stmt.statement.v};
+    auto &n = stmt.statement.v;
     name = n.ToString();
     symbol = n.symbol;
   }
@@ -256,10 +256,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   ///
   /// Generate the cleanup block before the procedure exits
   void genFIRFunctionReturn(const Fortran::semantics::Symbol &functionSymbol) {
-    const auto &details{
-        functionSymbol.get<Fortran::semantics::SubprogramDetails>()};
-    mlir::Value resultRef{localSymbols.lookupSymbol(details.result())};
-    mlir::Value r{builder->create<fir::LoadOp>(toLocation(), resultRef)};
+    const auto &details =
+        functionSymbol.get<Fortran::semantics::SubprogramDetails>();
+    mlir::Value resultRef = localSymbols.lookupSymbol(details.result());
+    mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
     builder->create<mlir::ReturnOp>(toLocation(), r);
   }
   template <typename A>
@@ -288,17 +288,17 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   template <typename A>
   void genWhereCondition(fir::WhereOp &where, const A *stmt) {
-    auto cond{createLogicalExprAsI1(
+    auto cond = createLogicalExprAsI1(
         toLocation(),
         Fortran::semantics::GetExpr(
-            std::get<Fortran::parser::ScalarLogicalExpr>(stmt->t)))};
+            std::get<Fortran::parser::ScalarLogicalExpr>(stmt->t)));
     where = builder->create<fir::WhereOp>(toLocation(), cond, true);
     switchInsertionPointToWhere(where);
   }
 
   mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x,
                               mlir::Type t) {
-    mlir::Value v{genExprValue(*Fortran::semantics::GetExpr(x))};
+    mlir::Value v = genExprValue(*Fortran::semantics::GetExpr(x));
     return v.getType() == t
                ? v
                : builder->create<fir::ConvertOp>(toLocation(), t, v);
@@ -331,7 +331,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     std::visit(Fortran::common::visitors{
                    [&](const Fortran::parser::Name &name) {
                      auto *sym = name.symbol;
-                     auto n{sym->name()};
+                     auto n = sym->name();
                      funName = llvm::StringRef{n.begin(), n.size()};
                      auto &details =
                          sym->get<Fortran::semantics::SubprogramDetails>();
@@ -343,13 +343,13 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                },
                std::get<Fortran::parser::ProcedureDesignator>(stmt.v.t).u);
     for (auto *d : argsList) {
-      Fortran::semantics::SymbolRef sr{*d};
+      Fortran::semantics::SymbolRef sr = *d;
       // FIXME:
       argTy.push_back(fir::ReferenceType::get(genType(sr)));
     }
-    auto funTy{mlir::FunctionType::get(argTy, resTy, builder->getContext())};
+    auto funTy = mlir::FunctionType::get(argTy, resTy, builder->getContext());
     // FIXME: mangle name
-    mlir::FuncOp func{getFunc(funName, funTy)};
+    mlir::FuncOp func = getFunc(funName, funTy);
     (void)func; // FIXME
     std::vector<mlir::Value> actuals;
     for (auto &aa :
@@ -390,7 +390,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
 
     // Generate fir.where.
-    mlir::Block *ifStmtBlock{builder->getInsertionBlock()};
+    mlir::Block *ifStmtBlock = builder->getInsertionBlock();
     fir::WhereOp where;
     genWhereCondition(where, &stmt);
     genFIR(*eval.lexicalSuccessor, false);
@@ -408,8 +408,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::ComputedGotoStmt &stmt) {
-    auto *exp{Fortran::semantics::GetExpr(
-        std::get<Fortran::parser::ScalarIntExpr>(stmt.t))};
+    auto *exp = Fortran::semantics::GetExpr(
+        std::get<Fortran::parser::ScalarIntExpr>(stmt.t));
     auto e1{genExprValue(*exp)};
     (void)e1;
     TODO();
@@ -420,8 +420,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::ArithmeticIfStmt &stmt) {
-    auto *exp{
-        Fortran::semantics::GetExpr(std::get<Fortran::parser::Expr>(stmt.t))};
+    auto *exp =
+        Fortran::semantics::GetExpr(std::get<Fortran::parser::Expr>(stmt.t));
     auto e1{genExprValue(*exp)};
     (void)e1;
     TODO();
@@ -487,15 +487,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   ///  - structured and unstructured concurrent loops
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::DoConstruct &) {
-    bool unstructuredContext{eval.lowerAsUnstructured()};
-    Fortran::lower::pft::Evaluation &doStmtEval{eval.evaluationList->front()};
-    auto *doStmt{doStmtEval.getIf<Fortran::parser::NonLabelDoStmt>()};
+    bool unstructuredContext = eval.lowerAsUnstructured();
+    Fortran::lower::pft::Evaluation &doStmtEval = eval.evaluationList->front();
+    auto *doStmt = doStmtEval.getIf<Fortran::parser::NonLabelDoStmt>();
     assert(doStmt && "missing DO statement");
-    const auto &loopControl{
-        std::get<std::optional<Fortran::parser::LoopControl>>(doStmt->t)};
+    const auto &loopControl =
+        std::get<std::optional<Fortran::parser::LoopControl>>(doStmt->t);
     llvm::SmallVector<IncrementLoopInfo, 1> incrementLoopInfo;
-    const Fortran::parser::ScalarLogicalExpr *whileCondition{nullptr};
-    bool infiniteLoop{!loopControl.has_value()};
+    const Fortran::parser::ScalarLogicalExpr *whileCondition = nullptr;
+    bool infiniteLoop = !loopControl.has_value();
     if (infiniteLoop) {
       assert(unstructuredContext && "infinite loop must be unstructured");
       startBlock(doStmtEval.localBlocks[0]); // header block
@@ -506,9 +506,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       startBlock(doStmtEval.localBlocks[0]); // header block
       genFIRConditionalBranch(*whileCondition, doStmtEval.lexicalSuccessor,
                               doStmtEval.parentConstruct->constructExit);
-    } else if (const auto *bounds{
+    } else if (const auto *bounds =
                    std::get_if<Fortran::parser::LoopControl::Bounds>(
-                       &loopControl->u)}) {
+                       &loopControl->u)) {
       // "Normal" increment loop.
       incrementLoopInfo.emplace_back(IncrementLoopInfo(
           bounds->name.thing.symbol, bounds->lower, bounds->upper, bounds->step,
@@ -521,14 +521,14 @@ class FirConverter : public Fortran::lower::AbstractConverter {
             doStmtEval.parentConstruct->constructExit->block;
       }
     } else {
-      const auto *concurrentInfo{
+      const auto *concurrentInfo =
           std::get_if<Fortran::parser::LoopControl::Concurrent>(
-              &loopControl->u)};
+              &loopControl->u);
       assert(concurrentInfo && "DO loop variant is invalid");
       TODO();
       // Add entries to incrementLoopInfo.  (Define extra members for a mask.)
     }
-    for (size_t i{0}, n{incrementLoopInfo.size()}; i < n; ++i) {
+    for (size_t i = 0, n = incrementLoopInfo.size(); i < n; ++i) {
       genFIRIncrementLoopBegin(incrementLoopInfo[i]);
     }
 
@@ -541,7 +541,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     if (infiniteLoop || whileCondition) {
       genFIRUnconditionalBranch(doStmtEval.localBlocks[0]);
     } else {
-      for (size_t i{incrementLoopInfo.size()}; i > 0;) {
+      for (size_t i = incrementLoopInfo.size(); i > 0;) {
         genFIRIncrementLoopEnd(incrementLoopInfo[--i]);
       }
     }
@@ -549,12 +549,12 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   /// Generate FIR to begin a structured or unstructured increment loop.
   void genFIRIncrementLoopBegin(IncrementLoopInfo &info) {
-    mlir::Location location{toLocation()};
-    mlir::Type type{info.isStructured()
-                        ? mlir::IndexType::get(builder->getContext())
-                        : info.loopVariableType};
-    mlir::Value lowerValue{genFIRLoopIndex(info.lowerExpr, type)};
-    mlir::Value upperValue{genFIRLoopIndex(info.upperExpr, type)};
+    mlir::Location location = toLocation();
+    mlir::Type type = info.isStructured()
+                          ? mlir::IndexType::get(builder->getContext())
+                          : info.loopVariableType;
+    mlir::Value lowerValue = genFIRLoopIndex(info.lowerExpr, type);
+    mlir::Value upperValue = genFIRLoopIndex(info.upperExpr, type);
     if (info.stepExpr.has_value()) {
       info.stepValue = genFIRLoopIndex(*info.stepExpr, type);
     }
@@ -570,8 +570,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       info.doLoop = builder->create<fir::LoopOp>(location, lowerValue,
                                                  upperValue, stepVector);
       builder->setInsertionPointToStart(info.doLoop.getBody());
-      mlir::Value shadow{builder->create<fir::ConvertOp>(
-          location, info.loopVariableType, info.doLoop.getInductionVar())};
+      mlir::Value shadow = builder->create<fir::ConvertOp>(
+          location, info.loopVariableType, info.doLoop.getInductionVar());
       localSymbols.pushShadowSymbol(*info.loopVariableSym, shadow);
       return;
     }
@@ -596,41 +596,41 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     // Unstructured loop header code - generate loop condition.
     startBlock(info.headerBlock);
-    mlir::Value tripVariable{
-        builder->create<fir::LoadOp>(location, info.tripVariable)};
-    mlir::Value zero{builder->create<mlir::ConstantOp>(
-        location, builder->getIntegerAttr(info.loopVariableType, 0))};
-    mlir::Value cond{builder->create<mlir::CmpIOp>(
-        location, mlir::CmpIPredicate::sgt, tripVariable, zero)};
+    mlir::Value tripVariable =
+        builder->create<fir::LoadOp>(location, info.tripVariable);
+    mlir::Value zero = builder->create<mlir::ConstantOp>(
+        location, builder->getIntegerAttr(info.loopVariableType, 0));
+    mlir::Value cond = builder->create<mlir::CmpIOp>(
+        location, mlir::CmpIPredicate::sgt, tripVariable, zero);
     genFIRConditionalBranch(cond, info.bodyBlock, info.successorBlock);
   }
 
   /// Generate FIR to end a structured or unstructured increment loop.
   void genFIRIncrementLoopEnd(IncrementLoopInfo &info) {
-    mlir::Location location{toLocation()};
+    mlir::Location location = toLocation();
     if (info.isStructured()) {
       // End fir.loop.
       localSymbols.popShadowSymbol();
       builder->restoreInsertionPoint(info.insertionPoint);
       assert(info.doLoop.hasLastValue() && "loop must have a result");
-      mlir::Value result{builder->create<fir::ConvertOp>(
-          location, info.loopVariableType, info.doLoop.lastVal()[0])};
+      mlir::Value result = builder->create<fir::ConvertOp>(
+          location, info.loopVariableType, info.doLoop.lastVal()[0]);
       builder->create<fir::StoreOp>(location, result, info.loopVariable);
       return;
     }
 
     // Unstructured loop - increment loopVariable.
-    mlir::Value loopVariable{
-        builder->create<fir::LoadOp>(location, info.loopVariable)};
+    mlir::Value loopVariable =
+        builder->create<fir::LoadOp>(location, info.loopVariable);
     loopVariable =
         builder->create<mlir::AddIOp>(location, loopVariable, info.stepValue);
     builder->create<fir::StoreOp>(location, loopVariable, info.loopVariable);
 
     // Unstructured loop - decrement tripVariable.
-    mlir::Value tripVariable{
-        builder->create<fir::LoadOp>(location, info.tripVariable)};
-    mlir::Value one{builder->create<mlir::ConstantOp>(
-        location, builder->getIntegerAttr(info.loopVariableType, 1))};
+    mlir::Value tripVariable =
+        builder->create<fir::LoadOp>(location, info.tripVariable);
+    mlir::Value one = builder->create<mlir::ConstantOp>(
+        location, builder->getIntegerAttr(info.loopVariableType, 1));
     tripVariable = builder->create<mlir::SubIOp>(location, tripVariable, one);
     builder->create<fir::StoreOp>(location, tripVariable, info.tripVariable);
     genFIRUnconditionalBranch(info.headerBlock);
@@ -642,13 +642,13 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     if (eval.lowerAsStructured()) {
       // Structured fir.where nest.
       fir::WhereOp where;
-      mlir::OpBuilder::InsertPoint insertionPoint{
-          builder->saveInsertionPoint()};
+      mlir::OpBuilder::InsertPoint insertionPoint =
+          builder->saveInsertionPoint();
       for (auto &e : *eval.evaluationList) {
-        if (auto *s{e.getIf<Fortran::parser::IfThenStmt>()}) {
+        if (auto *s = e.getIf<Fortran::parser::IfThenStmt>()) {
           // fir.where op
           genWhereCondition(where, s);
-        } else if (auto *s{e.getIf<Fortran::parser::ElseIfStmt>()}) {
+        } else if (auto *s = e.getIf<Fortran::parser::ElseIfStmt>()) {
           // otherwise block, then nested fir.where
           switchInsertionPointToOtherwise(where);
           genWhereCondition(where, s);
@@ -665,12 +665,12 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     // Unstructured branch sequence.
     for (auto &e : *eval.evaluationList) {
-      if (auto *s{e.getIf<Fortran::parser::IfThenStmt>()}) {
+      if (auto *s = e.getIf<Fortran::parser::IfThenStmt>()) {
         maybeStartBlock(e.block);
         genFIRConditionalBranch(
             std::get<Fortran::parser::ScalarLogicalExpr>(s->t),
             e.lexicalSuccessor, e.controlSuccessor);
-      } else if (auto *s{e.getIf<Fortran::parser::ElseIfStmt>()}) {
+      } else if (auto *s = e.getIf<Fortran::parser::ElseIfStmt>()) {
         startBlock(e.block);
         genFIRConditionalBranch(
             std::get<Fortran::parser::ScalarLogicalExpr>(s->t),
@@ -702,16 +702,16 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   /// Lower FORALL construct (See 10.2.4)
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::ForallConstruct &forall) {
-    auto &stmt{std::get<
+    auto &stmt = std::get<
         Fortran::parser::Statement<Fortran::parser::ForallConstructStmt>>(
-        forall.t)};
+        forall.t);
     setCurrentPosition(stmt.source);
-    auto &fas{stmt.statement};
-    auto &ctrl{
+    auto &fas = stmt.statement;
+    auto &ctrl =
         std::get<
             Fortran::common::Indirection<Fortran::parser::ConcurrentHeader>>(
             fas.t)
-            .value()};
+            .value();
     (void)ctrl;
     for (auto &s :
          std::get<std::list<Fortran::parser::ForallBodyConstruct>>(forall.t)) {
@@ -918,39 +918,39 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void genCharacterAssignment(const Fortran::evaluate::Assignment &assignment) {
     // Helper to get address and length from an Expr that is a character
     // variable designator
-    auto getAddrAndLength{
+    auto getAddrAndLength =
         [&](const Fortran::semantics::SomeExpr &charDesignatorExpr)
-            -> Fortran::lower::CharacterOpsBuilder::CharValue {
-          mlir::Value addr = genExprAddr(charDesignatorExpr);
-          const auto &charExpr{std::get<
-              Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
-              charDesignatorExpr.u)};
-          std::optional<
-              Fortran::evaluate::Expr<Fortran::evaluate::SubscriptInteger>>
-              lenExpr{charExpr.LEN()};
-          assert(lenExpr &&
-                 "could not get expression to compute character length");
-          mlir::Value len{genExprValue(
-              Fortran::evaluate::AsGenericExpr(std::move(*lenExpr)))};
-          return Fortran::lower::CharacterOpsBuilder::CharValue{addr, len};
-        }};
+        -> Fortran::lower::CharacterOpsBuilder::CharValue {
+      mlir::Value addr = genExprAddr(charDesignatorExpr);
+      const auto &charExpr =
+          std::get<Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
+              charDesignatorExpr.u);
+      std::optional<
+          Fortran::evaluate::Expr<Fortran::evaluate::SubscriptInteger>>
+          lenExpr = charExpr.LEN();
+      assert(lenExpr && "could not get expression to compute character length");
+      mlir::Value len =
+          genExprValue(Fortran::evaluate::AsGenericExpr(std::move(*lenExpr)));
+      return Fortran::lower::CharacterOpsBuilder::CharValue{addr, len};
+    };
 
     Fortran::lower::CharacterOpsBuilder charBuilder{*builder, toLocation()};
 
     // RHS evaluation.
     // FIXME:  Only works with rhs that are variable reference.
     // Other expression evaluation are not simple copies.
-    auto rhs{getAddrAndLength(assignment.rhs)};
+    auto rhs = getAddrAndLength(assignment.rhs);
     // A temp is needed to evaluate rhs until proven it does not depend on lhs.
-    auto tempToEvalRhs{charBuilder.createTemp(rhs.getCharacterType(), rhs.len)};
+    auto tempToEvalRhs =
+        charBuilder.createTemp(rhs.getCharacterType(), rhs.len);
     charBuilder.createCopy(tempToEvalRhs, rhs, rhs.len);
 
     // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
-    auto lhs{getAddrAndLength(assignment.lhs)};
-    auto cmpLen{charBuilder.create<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
-                                                 lhs.len, rhs.len)};
-    auto copyCount{
-        charBuilder.create<mlir::SelectOp>(cmpLen, lhs.len, rhs.len)};
+    auto lhs = getAddrAndLength(assignment.lhs);
+    auto cmpLen = charBuilder.create<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
+                                                   lhs.len, rhs.len);
+    auto copyCount =
+        charBuilder.create<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
     charBuilder.createCopy(lhs, tempToEvalRhs, copyCount);
     charBuilder.createPadding(lhs, copyCount, lhs.len);
   }
@@ -1058,14 +1058,14 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       std::visit(
           Fortran::common::visitors{
               [&](const Fortran::parser::Name &sym) {
-                auto ty{genType(*sym.symbol)};
-                auto load{builder->create<fir::LoadOp>(
-                    toLocation(), localSymbols.lookupSymbol(*sym.symbol))};
-                auto idxTy{mlir::IndexType::get(&mlirContext)};
-                auto zero{builder->create<mlir::ConstantOp>(
-                    toLocation(), idxTy, builder->getIntegerAttr(idxTy, 0))};
-                auto cast{
-                    builder->create<fir::ConvertOp>(toLocation(), ty, zero)};
+                auto ty = genType(*sym.symbol);
+                auto load = builder->create<fir::LoadOp>(
+                    toLocation(), localSymbols.lookupSymbol(*sym.symbol));
+                auto idxTy = mlir::IndexType::get(&mlirContext);
+                auto zero = builder->create<mlir::ConstantOp>(
+                    toLocation(), idxTy, builder->getIntegerAttr(idxTy, 0));
+                auto cast =
+                    builder->create<fir::ConvertOp>(toLocation(), ty, zero);
                 builder->create<fir::StoreOp>(toLocation(), cast, load);
               },
               [&](const Fortran::parser::StructureComponent &) { TODO(); },
@@ -1133,8 +1133,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   // call FAIL IMAGE in runtime
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::FailImageStmt &stmt) {
-    auto callee{genRuntimeFunction(
-        Fortran::lower::RuntimeEntryCode::FailImageStatement, *builder)};
+    auto callee = genRuntimeFunction(
+        Fortran::lower::RuntimeEntryCode::FailImageStatement, *builder);
     llvm::SmallVector<mlir::Value, 1> operands; // FAIL IMAGE has no args
     builder->create<mlir::CallOp>(toLocation(), callee, operands);
   }
@@ -1142,8 +1142,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   // call STOP, ERROR STOP in runtime
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::StopStmt &stmt) {
-    auto callee{genRuntimeFunction(
-        Fortran::lower::RuntimeEntryCode::StopStatement, *builder)};
+    auto callee = genRuntimeFunction(
+        Fortran::lower::RuntimeEntryCode::StopStatement, *builder);
     llvm::SmallVector<mlir::Value, 8> operands;
     builder->create<mlir::CallOp>(toLocation(), callee, operands);
   }
@@ -1205,8 +1205,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     // get arguments and return type if any, otherwise just use empty vectors
     llvm::SmallVector<mlir::Type, 8> args;
     llvm::SmallVector<mlir::Type, 2> results;
-    auto funcTy{symbol ? genFunctionType(*symbol)
-                       : mlir::FunctionType::get(args, results, &mlirContext)};
+    auto funcTy = symbol ? genFunctionType(*symbol)
+                         : mlir::FunctionType::get(args, results, &mlirContext);
     return createFunction(*this, name, funcTy);
   }
 
@@ -1214,7 +1214,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit,
                         llvm::StringRef name,
                         const Fortran::semantics::Symbol *symbol) {
-    mlir::FuncOp func{Fortran::lower::getNamedFunction(module, name)};
+    mlir::FuncOp func = Fortran::lower::getNamedFunction(module, name);
     if (!func) {
       func = createNewFunction(name, symbol);
     }
@@ -1226,8 +1226,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     // plumb function's arguments
     if (symbol) {
-      auto *entryBlock{&func.front()};
-      auto *details{symbol->detailsIf<Fortran::semantics::SubprogramDetails>()};
+      auto *entryBlock = &func.front();
+      auto *details =
+          symbol->detailsIf<Fortran::semantics::SubprogramDetails>();
       assert(details &&
              "details for Fortran::semantics symbol must be subprogram");
       for (const auto &v :
@@ -1257,7 +1258,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       if (eval.isNewBlock) {
         eval.block = Fortran::lower::createBlock(builder);
       }
-      for (size_t i{0}, n{eval.localBlocks.size()}; i < n; ++i) {
+      for (size_t i = 0, n = eval.localBlocks.size(); i < n; ++i) {
         eval.localBlocks[i] = Fortran::lower::createBlock(builder);
       }
       if (eval.isConstruct()) {
@@ -1265,8 +1266,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
           createEmptyBlocks(*eval.evaluationList);
         } else {
           // A structured construct that is a target starts a new block.
-          Fortran::lower::pft::Evaluation &constructStmt{
-              eval.evaluationList->front()};
+          Fortran::lower::pft::Evaluation &constructStmt =
+              eval.evaluationList->front();
           if (constructStmt.isNewBlock) {
             constructStmt.block = Fortran::lower::createBlock(builder);
           }
@@ -1277,7 +1278,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   /// Return the predicate: "current block does not have a terminator branch".
   bool blockIsUnterminated() {
-    mlir::Block *currentBlock{builder->getBlock()};
+    mlir::Block *currentBlock = builder->getBlock();
     return currentBlock->empty() || currentBlock->back().isKnownNonTerminator();
   }
 
@@ -1311,7 +1312,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                  llvm::ArrayRef<llvm::StringRef> modules,
                  llvm::Optional<llvm::StringRef> host = {}) {
     std::string name;
-    const Fortran::semantics::Symbol *symbol{nullptr};
+    const Fortran::semantics::Symbol *symbol = nullptr;
 
     if (func.beginStmt) {
       std::visit([&](auto *p) { genFIR(*p, name, symbol); }, *func.beginStmt);
@@ -1366,7 +1367,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   // TODO: should these be moved to convert-expr?
   template <mlir::CmpIPredicate ICMPOPC>
   mlir::Value genCompare(mlir::Value lhs, mlir::Value rhs) {
-    auto lty{lhs.getType()};
+    auto lty = lhs.getType();
     assert(lty == rhs.getType());
     if (lty.isSignlessIntOrIndex())
       return builder->create<mlir::CmpIOp>(lhs.getLoc(), ICMPOPC, lhs, rhs);
@@ -1399,7 +1400,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   mlir::ModuleOp &module;
   const Fortran::common::IntrinsicTypeDefaultKinds &defaults;
   Fortran::lower::IntrinsicLibrary intrinsics;
-  mlir::OpBuilder *builder{nullptr};
+  mlir::OpBuilder *builder = nullptr;
   fir::NameUniquer &uniquer;
   Fortran::lower::SymMap localSymbols;
   Fortran::parser::CharBlock currentPosition;
@@ -1479,10 +1480,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   mlir::Location
   genLocation(const Fortran::parser::CharBlock &block) override final {
     if (cooked) {
-      auto loc{cooked->GetSourcePositionRange(block)};
+      auto loc = cooked->GetSourcePositionRange(block);
       if (loc.has_value()) {
         // loc is a pair (begin, end); use the beginning position
-        auto &filePos{loc->first};
+        auto &filePos = loc->first;
         return mlir::FileLineColLoc::get(filePos.file.path(), filePos.line,
                                          filePos.column, &mlirContext);
       }

From 2bd73ef2528e609eba48bbd32c449fcef767558a Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Tue, 3 Mar 2020 18:39:17 -0800
Subject: [PATCH 225/345] Update for review comments.

---
 include/flang/Lower/PFTBuilder.h | 42 ++++++++--------
 lib/Lower/Bridge.cpp             | 49 ++++++++-----------
 lib/Lower/PFTBuilder.cpp         | 83 +++++++++++++++++---------------
 3 files changed, 87 insertions(+), 87 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 9de65b103842..92ce0be483b5 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -36,9 +36,9 @@ struct FunctionLikeUnit;
 // O(1) time insertions anywhere.
 using EvaluationList = std::list<Evaluation>;
 
-struct ParentType {
+struct ParentVariant {
   template <typename A>
-  ParentType(A &parentType) : p{&parentType} {}
+  ParentVariant(A &parentVariant) : p{&parentVariant} {}
   const std::variant<Program *, ModuleLikeUnit *, FunctionLikeUnit *,
                      Evaluation *>
       p;
@@ -143,14 +143,15 @@ struct Evaluation {
 
   /// General ctor
   template <typename A>
-  Evaluation(const A &a, const ParentType &p, const parser::CharBlock &position,
+  Evaluation(const A &a, const ParentVariant &parentVariant,
+             const parser::CharBlock &position,
              const std::optional<parser::Label> &label)
-      : u{&a}, parentType{p}, position{position}, label{label} {}
+      : u{&a}, parentVariant{parentVariant}, position{position}, label{label} {}
 
   /// Construct ctor
   template <typename A>
-  Evaluation(const A &a, const ParentType &parentType)
-      : u{&a}, parentType{parentType} {
+  Evaluation(const A &a, const ParentVariant &parentVariant)
+      : u{&a}, parentVariant{parentVariant} {
     static_assert(pft::isConstruct<A>, "must be a construct");
   }
 
@@ -211,7 +212,7 @@ struct Evaluation {
   // and does not affect FIR generation.  It may also be helpful for debugging.
 
   EvaluationVariant u;
-  ParentType parentType;
+  ParentVariant parentVariant;
   parser::CharBlock position{};
   std::optional<parser::Label> label{};
   std::unique_ptr<EvaluationList> evaluationList; // nested evaluations
@@ -231,8 +232,8 @@ struct Evaluation {
 /// These units can be function like, module like, or block data.
 struct ProgramUnit {
   template <typename A>
-  ProgramUnit(const A &ptr, const ParentType &parentType)
-      : p{&ptr}, parentType{parentType} {}
+  ProgramUnit(const A &ptr, const ParentVariant &parentVariant)
+      : p{&ptr}, parentVariant{parentVariant} {}
   ProgramUnit(ProgramUnit &&) = default;
   ProgramUnit(const ProgramUnit &) = delete;
 
@@ -242,7 +243,7 @@ struct ProgramUnit {
       const parser::Submodule *, const parser::SeparateModuleSubprogram *,
       const parser::BlockData *>
       p;
-  ParentType parentType;
+  ParentVariant parentVariant;
 };
 
 /// Function-like units may contain evaluations (executable statements) and
@@ -259,13 +260,14 @@ struct FunctionLikeUnit : public ProgramUnit {
                    const parser::Statement<parser::MpSubprogramStmt> *,
                    const parser::Statement<parser::EndMpSubprogramStmt> *>;
 
-  FunctionLikeUnit(const parser::MainProgram &f, const ParentType &parentType);
+  FunctionLikeUnit(const parser::MainProgram &f,
+                   const ParentVariant &parentVariant);
   FunctionLikeUnit(const parser::FunctionSubprogram &f,
-                   const ParentType &parentType);
+                   const ParentVariant &parentVariant);
   FunctionLikeUnit(const parser::SubroutineSubprogram &f,
-                   const ParentType &parentType);
+                   const ParentVariant &parentVariant);
   FunctionLikeUnit(const parser::SeparateModuleSubprogram &f,
-                   const ParentType &parentType);
+                   const ParentVariant &parentVariant);
   FunctionLikeUnit(FunctionLikeUnit &&) = default;
   FunctionLikeUnit(const FunctionLikeUnit &) = delete;
 
@@ -290,7 +292,7 @@ struct FunctionLikeUnit : public ProgramUnit {
   EvaluationList evaluationList;
   llvm::DenseMap<parser::Label, Evaluation *> labelEvaluationMap;
   SymbolLabelMap assignSymbolLabelMap;
-  std::list<FunctionLikeUnit> containedFunctions;
+  std::list<FunctionLikeUnit> nestedFunctions;
 
 private:
   template <typename A>
@@ -313,19 +315,21 @@ struct ModuleLikeUnit : public ProgramUnit {
                    const parser::Statement<parser::SubmoduleStmt> *,
                    const parser::Statement<parser::EndSubmoduleStmt> *>;
 
-  ModuleLikeUnit(const parser::Module &m, const ParentType &parentType);
-  ModuleLikeUnit(const parser::Submodule &m, const ParentType &parentType);
+  ModuleLikeUnit(const parser::Module &m, const ParentVariant &parentVariant);
+  ModuleLikeUnit(const parser::Submodule &m,
+                 const ParentVariant &parentVariant);
   ~ModuleLikeUnit() = default;
   ModuleLikeUnit(ModuleLikeUnit &&) = default;
   ModuleLikeUnit(const ModuleLikeUnit &) = delete;
 
   ModuleStatement beginStmt;
   ModuleStatement endStmt;
-  std::list<FunctionLikeUnit> containedFunctions;
+  std::list<FunctionLikeUnit> nestedFunctions;
 };
 
 struct BlockDataUnit : public ProgramUnit {
-  BlockDataUnit(const parser::BlockData &bd, const ParentType &parentType);
+  BlockDataUnit(const parser::BlockData &bd,
+                const ParentVariant &parentVariant);
   BlockDataUnit(BlockDataUnit &&) = default;
   BlockDataUnit(const BlockDataUnit &) = delete;
 };
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index dada1e9a6534..d421065f99b4 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -97,7 +97,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                           },
                           [](auto *) { return false; },
                       },
-                      cstr->parentType.p);
+                      cstr->parentVariant.p);
   }
   static const Fortran::parser::SubroutineStmt *
   inSubroutine(Fortran::lower::pft::Evaluation *cstr) {
@@ -111,7 +111,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               return nullptr;
             },
         },
-        cstr->parentType.p);
+        cstr->parentVariant.p);
   }
   static const Fortran::parser::FunctionStmt *
   inFunction(Fortran::lower::pft::Evaluation *cstr) {
@@ -125,7 +125,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               return nullptr;
             },
         },
-        cstr->parentType.p);
+        cstr->parentVariant.p);
   }
   static const Fortran::parser::MpSubprogramStmt *
   inMpSubprogram(Fortran::lower::pft::Evaluation *cstr) {
@@ -141,7 +141,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               return nullptr;
             },
         },
-        cstr->parentType.p);
+        cstr->parentVariant.p);
   }
 
   void genFIRUnconditionalBranch(mlir::Block *targetBlock) {
@@ -156,22 +156,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   void genFIRConditionalBranch(mlir::Value &cond, mlir::Block *trueTarget,
                                mlir::Block *falseTarget) {
-    assert(trueTarget && "missing conditional branch true block");
-    assert(falseTarget && "missing conditional branch false block");
-    llvm::SmallVector<mlir::Value, 2> blk;
-    builder->create<mlir::CondBranchOp>(toLocation(), cond, trueTarget, blk,
-                                        falseTarget, blk);
-  }
-
-  void genFIRConditionalBranch(mlir::Value &cond,
-                               Fortran::lower::pft::Evaluation *trueTarget,
-                               Fortran::lower::pft::Evaluation *falseTarget) {
-    genFIRConditionalBranch(cond, trueTarget->block, falseTarget->block);
+    builder->create<mlir::CondBranchOp>(toLocation(), cond, trueTarget,
+                                        llvm::None, falseTarget, llvm::None);
   }
 
   void genFIRConditionalBranch(const Fortran::parser::ScalarLogicalExpr &expr,
                                Fortran::lower::pft::Evaluation *trueTarget,
                                Fortran::lower::pft::Evaluation *falseTarget) {
+    assert(trueTarget && "missing conditional branch true block");
+    assert(falseTarget && "missing conditional branch true block");
     mlir::Value cond =
         createLogicalExprAsI1(toLocation(), Fortran::semantics::GetExpr(expr));
     genFIRConditionalBranch(cond, trueTarget->block, falseTarget->block);
@@ -393,7 +386,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     mlir::Block *ifStmtBlock = builder->getInsertionBlock();
     fir::WhereOp where;
     genWhereCondition(where, &stmt);
-    genFIR(*eval.lexicalSuccessor, false);
+    genFIR(*eval.lexicalSuccessor, /*unstructuredContext*/ false);
     eval.lexicalSuccessor->skip = true;
     builder->setInsertionPointToEnd(ifStmtBlock);
   }
@@ -467,15 +460,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     const Fortran::parser::ScalarExpr &upperExpr;
     const std::optional<Fortran::parser::ScalarExpr> &stepExpr;
     mlir::Type loopVariableType;
-    mlir::Value loopVariable{mlir::Value{}};
-    mlir::Value stepValue{mlir::Value{}}; // possible uses in multiple blocks
+    mlir::Value loopVariable{};
+    mlir::Value stepValue{}; // possible uses in multiple blocks
 
     // Data members for structured loops.
     fir::LoopOp doLoop{};
     mlir::OpBuilder::InsertPoint insertionPoint{};
 
     // Data members for unstructured loops.
-    mlir::Value tripVariable{mlir::Value{}};
+    mlir::Value tripVariable{};
     mlir::Block *headerBlock{nullptr};    // loop entry and test block
     mlir::Block *bodyBlock{nullptr};      // first loop body block
     mlir::Block *successorBlock{nullptr}; // loop exit target block
@@ -510,9 +503,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                    std::get_if<Fortran::parser::LoopControl::Bounds>(
                        &loopControl->u)) {
       // "Normal" increment loop.
-      incrementLoopInfo.emplace_back(IncrementLoopInfo(
+      incrementLoopInfo.emplace_back(
           bounds->name.thing.symbol, bounds->lower, bounds->upper, bounds->step,
-          genType(*bounds->name.thing.symbol), builder->getInsertionBlock()));
+          genType(*bounds->name.thing.symbol), builder->getInsertionBlock());
       if (unstructuredContext) {
         maybeStartBlock(doStmtEval.block); // preheader block
         incrementLoopInfo[0].headerBlock = doStmtEval.localBlocks[0];
@@ -581,8 +574,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       info.stepValue = builder->create<mlir::ConstantOp>(
           location, builder->getIntegerAttr(info.loopVariableType, 1));
     }
-    mlir::Value tripCount;
-    tripCount = builder->create<mlir::SubIOp>(location, upperValue, lowerValue);
+    mlir::Value tripCount =
+        builder->create<mlir::SubIOp>(location, upperValue, lowerValue);
     tripCount =
         builder->create<mlir::AddIOp>(location, tripCount, info.stepValue);
     if (info.stepExpr.has_value()) {
@@ -656,7 +649,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
           // otherwise block
           switchInsertionPointToOtherwise(where);
         } else {
-          genFIR(e, false);
+          genFIR(e, /*unstructuredContext*/ false);
         }
       }
       builder->restoreInsertionPoint(insertionPoint);
@@ -746,7 +739,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::ForallAssignmentStmt &s) {
-    // std::visit([&](auto &b) { genFIR(b); }, s.u);  // ...
+    std::visit([&](auto &b) { genFIR(eval, b); }, s.u);
   }
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
@@ -1182,7 +1175,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               bool unstructuredContext = true) {
     if (eval.skip) {
-      return; // rhs of {Forall, If, Where}Stmt has already been processed
+      return; // rhs of {Forall,If,Where}Stmt has already been processed
     }
     setCurrentPosition(eval.position);
     if (unstructuredContext) {
@@ -1332,7 +1325,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     // recursively lower internal procedures
     llvm::Optional<llvm::StringRef> optName{name};
-    for (auto &f : func.containedFunctions) {
+    for (auto &f : func.nestedFunctions) {
       lowerFunc(f, modules, optName);
     }
   }
@@ -1342,7 +1335,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     std::vector<llvm::StringRef> moduleName;
 
     // FIXME: do we need to visit the module statements?
-    for (auto &f : mod.containedFunctions) {
+    for (auto &f : mod.nestedFunctions) {
       lowerFunc(f, moduleName);
     }
   }
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index a8b4ae2f363f..0000f101610a 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -68,7 +68,7 @@ struct UnwrapStmt<parser::UnlabeledStatement<A>> {
 /// limit the bridge to one such instantiation.
 class PFTBuilder {
 public:
-  PFTBuilder() : pgm{new pft::Program}, parentTypeStack{*pgm.get()} {}
+  PFTBuilder() : pgm{new pft::Program}, parentVariantStack{*pgm.get()} {}
 
   /// Get the result
   std::unique_ptr<pft::Program> result() { return std::move(pgm); }
@@ -86,7 +86,7 @@ class PFTBuilder {
       // or UnlabeledStatement<Indirection<T>>
       auto stmt{UnwrapStmt<A>(a)};
       if constexpr (pft::isConstructStmt<T> || pft::isOtherStmt<T>) {
-        addEvaluation(pft::Evaluation{stmt.unwrapped, parentTypeStack.back(),
+        addEvaluation(pft::Evaluation{stmt.unwrapped, parentVariantStack.back(),
                                       stmt.position, stmt.label});
         return false;
       } else if constexpr (std::is_same_v<T, parser::ActionStmt>) {
@@ -116,7 +116,7 @@ class PFTBuilder {
 
   // Block data
   bool Pre(const parser::BlockData &node) {
-    addUnit(pft::BlockDataUnit{node, parentTypeStack.back()});
+    addUnit(pft::BlockDataUnit{node, parentVariantStack.back()});
     return false;
   }
 
@@ -126,7 +126,7 @@ class PFTBuilder {
     addEvaluation(std::visit(
         [&](const auto &x) {
           return pft::Evaluation{
-              x, parentTypeStack.back(), statement.source, {}};
+              x, parentVariantStack.back(), statement.source, {}};
         },
         statement.statement.u));
     return false;
@@ -134,7 +134,7 @@ class PFTBuilder {
   bool Pre(const parser::Statement<parser::ForallAssignmentStmt> &statement) {
     addEvaluation(std::visit(
         [&](const auto &x) {
-          return pft::Evaluation{x, parentTypeStack.back(), statement.source,
+          return pft::Evaluation{x, parentVariantStack.back(), statement.source,
                                  statement.label};
         },
         statement.statement.u));
@@ -147,8 +147,8 @@ class PFTBuilder {
               // Not caught as other AssignmentStmt because it is not
               // wrapped in a parser::ActionStmt.
               addEvaluation(pft::Evaluation{stmt.statement,
-                                            parentTypeStack.back(), stmt.source,
-                                            stmt.label});
+                                            parentVariantStack.back(),
+                                            stmt.source, stmt.label});
               return false;
             },
             [&](const auto &) { return true; },
@@ -160,14 +160,14 @@ class PFTBuilder {
   /// Initialize a new module-like unit and make it the builder's focus.
   template <typename A>
   bool enterModule(const A &func) {
-    auto &unit = addUnit(pft::ModuleLikeUnit{func, parentTypeStack.back()});
-    functionList = &unit.containedFunctions;
-    parentTypeStack.emplace_back(unit);
+    auto &unit = addUnit(pft::ModuleLikeUnit{func, parentVariantStack.back()});
+    functionList = &unit.nestedFunctions;
+    parentVariantStack.emplace_back(unit);
     return true;
   }
 
   void exitModule() {
-    parentTypeStack.pop_back();
+    parentVariantStack.pop_back();
     ResetFunctionList();
   }
 
@@ -175,25 +175,26 @@ class PFTBuilder {
   template <typename A>
   bool enterFunction(const A &func) {
     auto &unit =
-        addFunction(pft::FunctionLikeUnit{func, parentTypeStack.back()});
+        addFunction(pft::FunctionLikeUnit{func, parentVariantStack.back()});
     labelEvaluationMap = &unit.labelEvaluationMap;
     assignSymbolLabelMap = &unit.assignSymbolLabelMap;
-    functionList = &unit.containedFunctions;
+    functionList = &unit.nestedFunctions;
     pushEvaluationList(&unit.evaluationList);
-    parentTypeStack.emplace_back(unit);
+    parentVariantStack.emplace_back(unit);
     return true;
   }
 
   void exitFunction() {
     // Guarantee that there is a branch target after the last user statement.
     static const parser::ContinueStmt endTarget{};
-    addEvaluation(pft::Evaluation{endTarget, parentTypeStack.back(), {}, {}});
+    addEvaluation(
+        pft::Evaluation{endTarget, parentVariantStack.back(), {}, {}});
     lastLexicalEvaluation = nullptr;
     analyzeBranches(nullptr, *evaluationListStack.back()); // add branch links
     popEvaluationList();
     labelEvaluationMap = nullptr;
     assignSymbolLabelMap = nullptr;
-    parentTypeStack.pop_back();
+    parentVariantStack.pop_back();
     ResetFunctionList();
   }
 
@@ -201,33 +202,33 @@ class PFTBuilder {
   template <typename A>
   bool enterConstruct(const A &construct) {
     auto &eval =
-        addEvaluation(pft::Evaluation{construct, parentTypeStack.back()});
+        addEvaluation(pft::Evaluation{construct, parentVariantStack.back()});
     eval.evaluationList.reset(new pft::EvaluationList);
     pushEvaluationList(eval.evaluationList.get());
-    parentTypeStack.emplace_back(eval);
+    parentVariantStack.emplace_back(eval);
     constructStack.emplace_back(&eval);
     return true;
   }
 
   void exitConstruct() {
     popEvaluationList();
-    parentTypeStack.pop_back();
+    parentVariantStack.pop_back();
     constructStack.pop_back();
   }
 
   /// Reset functionList to an enclosing function's functionList.
   void ResetFunctionList() {
-    if (!parentTypeStack.empty()) {
+    if (!parentVariantStack.empty()) {
       std::visit(common::visitors{
                      [&](pft::FunctionLikeUnit *p) {
-                       functionList = &p->containedFunctions;
+                       functionList = &p->nestedFunctions;
                      },
                      [&](pft::ModuleLikeUnit *p) {
-                       functionList = &p->containedFunctions;
+                       functionList = &p->nestedFunctions;
                      },
                      [&](auto *) { functionList = nullptr; },
                  },
-                 parentTypeStack.back().p);
+                 parentVariantStack.back().p);
     }
   }
 
@@ -255,7 +256,8 @@ class PFTBuilder {
         common::visitors{
             [&](const auto &x) {
               return pft::Evaluation{removeIndirection(x),
-                                     parentTypeStack.back(), position, label};
+                                     parentVariantStack.back(), position,
+                                     label};
             },
         },
         statement.u);
@@ -529,9 +531,9 @@ class PFTBuilder {
                 }
                 auto iter = assignSymbolLabelMap->find(sym);
                 if (iter == assignSymbolLabelMap->end()) {
-                  pft::LabelSet ls{};
-                  ls.insert(label);
-                  assignSymbolLabelMap->try_emplace(sym, ls);
+                  pft::LabelSet labelSet{};
+                  labelSet.insert(label);
+                  assignSymbolLabelMap->try_emplace(sym, labelSet);
                 } else {
                   iter->second.insert(label);
                 }
@@ -736,7 +738,7 @@ class PFTBuilder {
   /// functionList points to the internal or module procedure function list
   /// of a FunctionLikeUnit or a ModuleLikeUnit.  It may be null.
   std::list<pft::FunctionLikeUnit> *functionList{nullptr};
-  std::vector<pft::ParentType> parentTypeStack;
+  std::vector<pft::ParentVariant> parentVariantStack;
   std::vector<pft::Evaluation *> constructStack{};
   std::vector<pft::Evaluation *> doConstructStack{};
   /// evaluationListStack is the current nested construct evaluationList state.
@@ -885,9 +887,9 @@ class PFTDumper {
       outputStream << ": " << header;
     outputStream << '\n';
     dumpEvaluationList(outputStream, functionLikeUnit.evaluationList);
-    if (!functionLikeUnit.containedFunctions.empty()) {
+    if (!functionLikeUnit.nestedFunctions.empty()) {
       outputStream << "\nContains\n";
-      for (auto &func : functionLikeUnit.containedFunctions)
+      for (auto &func : functionLikeUnit.nestedFunctions)
         dumpFunctionLikeUnit(outputStream, func);
       outputStream << "EndContains\n";
     }
@@ -899,7 +901,7 @@ class PFTDumper {
     outputStream << getNodeIndex(moduleLikeUnit) << " ";
     outputStream << "ModuleLike: ";
     outputStream << "\nContains\n";
-    for (auto &func : moduleLikeUnit.containedFunctions)
+    for (auto &func : moduleLikeUnit.nestedFunctions)
       dumpFunctionLikeUnit(outputStream, func);
     outputStream << "EndContains\nEndModuleLike\n\n";
   }
@@ -934,7 +936,7 @@ pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
 
 } // namespace
 
-llvm::cl::opt<bool> ClDisableStructuredFir(
+llvm::cl::opt<bool> clDisableStructuredFir(
     "no-structured-fir", llvm::cl::desc("disable generation of structured FIR"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
@@ -943,11 +945,11 @@ bool pft::Evaluation::lowerAsStructured() const {
 }
 
 bool pft::Evaluation::lowerAsUnstructured() const {
-  return isUnstructured || ClDisableStructuredFir;
+  return isUnstructured || clDisableStructuredFir;
 }
 
 pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
-                                        const pft::ParentType &parent)
+                                        const pft::ParentVariant &parent)
     : ProgramUnit{func, parent} {
   auto &ps{
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t)};
@@ -959,36 +961,37 @@ pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
 }
 
 pft::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,
-                                        const pft::ParentType &parent)
+                                        const pft::ParentVariant &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::FunctionStmt>(func)},
       endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)} {}
 
 pft::FunctionLikeUnit::FunctionLikeUnit(
-    const parser::SubroutineSubprogram &func, const pft::ParentType &parent)
+    const parser::SubroutineSubprogram &func, const pft::ParentVariant &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::SubroutineStmt>(func)},
       endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)} {}
 
 pft::FunctionLikeUnit::FunctionLikeUnit(
-    const parser::SeparateModuleSubprogram &func, const pft::ParentType &parent)
+    const parser::SeparateModuleSubprogram &func,
+    const pft::ParentVariant &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
       endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {}
 
 pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Module &m,
-                                    const pft::ParentType &parent)
+                                    const pft::ParentVariant &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::ModuleStmt>(m)},
       endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {}
 
 pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Submodule &m,
-                                    const pft::ParentType &parent)
+                                    const pft::ParentVariant &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::SubmoduleStmt>(
                                   m)},
       endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {}
 
 pft::BlockDataUnit::BlockDataUnit(const parser::BlockData &bd,
-                                  const pft::ParentType &parent)
+                                  const pft::ParentVariant &parent)
     : ProgramUnit{bd, parent} {}
 
 std::unique_ptr<pft::Program> createPFT(const parser::Program &root) {

From 0197f28ab9ead92c0de30c270516bff1610fe1b5 Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Tue, 3 Mar 2020 20:37:08 -0800
Subject: [PATCH 226/345] fixup

---
 lib/Lower/Bridge.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index d421065f99b4..3f636884b591 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -448,7 +448,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         const Fortran::parser::ScalarExpr &lowerExpr,
         const Fortran::parser::ScalarExpr &upperExpr,
         const std::optional<Fortran::parser::ScalarExpr> &stepExpr,
-        mlir::Type type, mlir::Block *preheader)
+        mlir::Type type)
         : loopVariableSym{sym}, lowerExpr{lowerExpr}, upperExpr{upperExpr},
           stepExpr{stepExpr}, loopVariableType{type} {}
 
@@ -503,9 +503,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                    std::get_if<Fortran::parser::LoopControl::Bounds>(
                        &loopControl->u)) {
       // "Normal" increment loop.
-      incrementLoopInfo.emplace_back(
-          bounds->name.thing.symbol, bounds->lower, bounds->upper, bounds->step,
-          genType(*bounds->name.thing.symbol), builder->getInsertionBlock());
+      incrementLoopInfo.emplace_back(bounds->name.thing.symbol, bounds->lower,
+                                     bounds->upper, bounds->step,
+                                     genType(*bounds->name.thing.symbol));
       if (unstructuredContext) {
         maybeStartBlock(doStmtEval.block); // preheader block
         incrementLoopInfo[0].headerBlock = doStmtEval.localBlocks[0];
@@ -912,7 +912,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     // Helper to get address and length from an Expr that is a character
     // variable designator
     auto getAddrAndLength =
-        [&](const Fortran::semantics::SomeExpr &charDesignatorExpr)
+        [&](const Fortran::lower::SomeExpr &charDesignatorExpr)
         -> Fortran::lower::CharacterOpsBuilder::CharValue {
       mlir::Value addr = genExprAddr(charDesignatorExpr);
       const auto &charExpr =
@@ -1222,8 +1222,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       auto *entryBlock = &func.front();
       auto *details =
           symbol->detailsIf<Fortran::semantics::SubprogramDetails>();
-      assert(details &&
-             "details for Fortran::semantics symbol must be subprogram");
+      assert(details && "details for semantics symbol must be subprogram");
       for (const auto &v :
            llvm::zip(details->dummyArgs(), entryBlock->getArguments())) {
         if (std::get<0>(v)) {

From 42526f9c4a1089f004c4e7e4ef6e0fa4578722b8 Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Wed, 4 Mar 2020 21:56:57 -0800
Subject: [PATCH 227/345] Update for review comments.

---
 include/flang/Lower/PFTBuilder.h |  28 +-
 lib/Lower/OpBuilder.cpp          |   1 +
 lib/Lower/PFTBuilder.cpp         | 482 ++++++++++++++-----------------
 3 files changed, 234 insertions(+), 277 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 92ce0be483b5..007b8f7f003b 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -96,6 +96,16 @@ static constexpr bool isConstructStmt{common::HasMember<A, ConstructStmts>};
 template <typename A>
 static constexpr bool isConstruct{common::HasMember<A, Constructs>};
 
+using NopConstructStmts =
+    std::tuple<parser::EndAssociateStmt, parser::CaseStmt,
+               parser::EndSelectStmt, parser::ElseIfStmt, parser::ElseStmt,
+               parser::EndIfStmt, parser::SelectRankStmt,
+               parser::TypeGuardStmt>;
+
+template <typename A>
+static constexpr bool isNopConstructStmt{
+    common::HasMember<A, NopConstructStmts>};
+
 template <typename A>
 static constexpr bool isFunctionLike{common::HasMember<
     A, std::tuple<parser::MainProgram, parser::FunctionSubprogram,
@@ -105,14 +115,15 @@ static constexpr bool isFunctionLike{common::HasMember<
 using LabelSet = llvm::SmallSet<parser::Label, 5>;
 using SymbolLabelMap = std::map<semantics::Symbol *, LabelSet>;
 
-/// Function-like units can contain lists of evaluations.  These can be
-/// (simple) statements or constructs, where a construct contains its own
-/// evaluations.
+/// Function-like units contain lists of evaluations.  These can be simple
+/// statements or constructs, where a construct contains its own evaluations.
 struct Evaluation {
   using EvaluationTuple = common::CombineTuples<ActionStmts, OtherStmts,
                                                 ConstructStmts, Constructs>;
 
   /// Hide non-nullable pointers to the parse-tree node.
+  /// Build type std::variant<const A* const, const B* const, ...>
+  /// from EvaluationTuple type (std::tuple<A, B, ...>).
   template <typename A>
   using MakeRefType = const A *const;
   using EvaluationVariant = common::CombineVariants<
@@ -127,10 +138,8 @@ struct Evaluation {
   }
   template <typename A>
   constexpr const A *getIf() const {
-    if (auto *ptr{std::get_if<MakeRefType<A>>(&u)}) {
-      return *ptr;
-    }
-    return nullptr;
+    auto *ptr = std::get_if<MakeRefType<A>>(&u);
+    return ptr ? *ptr : nullptr;
   }
   template <typename A>
   constexpr bool isA() const {
@@ -173,6 +182,11 @@ struct Evaluation {
     return visit(common::visitors{
         [](auto &r) { return pft::isConstruct<std::decay_t<decltype(r)>>; }});
   }
+  constexpr bool isNopConstructStmt() const {
+    return visit(common::visitors{[](auto &r) {
+      return pft::isNopConstructStmt<std::decay_t<decltype(r)>>;
+    }});
+  }
 
   bool lowerAsStructured() const;
   bool lowerAsUnstructured() const;
diff --git a/lib/Lower/OpBuilder.cpp b/lib/Lower/OpBuilder.cpp
index eb1dd9c68bcb..933d9e2d521a 100644
--- a/lib/Lower/OpBuilder.cpp
+++ b/lib/Lower/OpBuilder.cpp
@@ -59,6 +59,7 @@ void Fortran::lower::SymMap::pushShadowSymbol(semantics::SymbolRef symbol,
 }
 
 void Fortran::lower::SymMap::popShadowSymbol() {
+  assert(!shadowStack.empty() && "shadow stack underflow");
   auto &pair{shadowStack.back()};
   assert(pair.first && "missing pop symbol");
   if (pair.second) {
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 0000f101610a..aad8d8bd9fda 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -345,14 +345,11 @@ class PFTBuilder {
 
   void markBranchTarget(pft::Evaluation &sourceEvaluation,
                         pft::Evaluation &targetEvaluation) {
-    targetEvaluation.isNewBlock = true;
     sourceEvaluation.isUnstructured = true;
-    if (sourceEvaluation.parentConstruct) {
-      sourceEvaluation.parentConstruct->isUnstructured = true;
-    }
     if (!sourceEvaluation.controlSuccessor) {
       sourceEvaluation.controlSuccessor = &targetEvaluation;
     }
+    targetEvaluation.isNewBlock = true;
   }
   void markBranchTarget(pft::Evaluation &sourceEvaluation,
                         parser::Label label) {
@@ -361,46 +358,20 @@ class PFTBuilder {
     markBranchTarget(sourceEvaluation, *targetEvaluation);
   }
 
-  /// Set the exit of a construct, possibly from multiple enclosing constructs.
-  void setConstructExit(pft::Evaluation &eval) {
-    pft::Evaluation *constructExit{
-        eval.evaluationList->back().lexicalSuccessor};
-    // Exit from enclosing constructs with nop end statements.
-    if (eval.parentConstruct &&
-        std::visit(common::visitors{
-                       [](const parser::EndAssociateStmt *) { return true; },
-                       [](const parser::CaseStmt *) { return true; },
-                       [](const parser::EndSelectStmt *) { return true; },
-                       [](const parser::EndChangeTeamStmt *) { return true; },
-                       [](const parser::EndCriticalStmt *) { return true; },
-                       [](const parser::ElseIfStmt *) { return true; },
-                       [](const parser::ElseStmt *) { return true; },
-                       [](const parser::EndIfStmt *) { return true; },
-                       [](const parser::SelectRankCaseStmt *) { return true; },
-                       [](const parser::TypeGuardStmt *) { return true; },
-                       [](const auto *) { return false; },
-                   },
-                   constructExit->u)) {
-      constructExit = eval.parentConstruct->constructExit;
-    }
-    assert(constructExit && "missing construct exit");
-    eval.constructExit = constructExit;
-  }
-
-  /// Return the lexical successor of an Evaluation, accounting for (some) nops.
-  pft::Evaluation *effectiveLexicalSuccessor(pft::Evaluation &eval) {
+  /// Return the first successor of an evaluation that isn't a nop,
+  /// possibly exiting from one or more enclosing constructs.
+  pft::Evaluation *exitSuccessor(pft::Evaluation &eval) {
     pft::Evaluation *successor{eval.lexicalSuccessor};
-    if (!successor->isNewBlock && eval.parentConstruct &&
-        &eval.parentConstruct->evaluationList->back() == successor) {
-      successor = eval.parentConstruct->constructExit;
+    if (successor->isNopConstructStmt()) {
+      successor = successor->parentConstruct->constructExit;
     }
-    assert(successor && "missing effective lexical successor");
+    assert(successor && "missing exit successor");
     return successor;
   }
 
-  /// Mark the effective lexical successor of an Evaluation as a new block.
-  void markSuccessorNewBlock(pft::Evaluation &eval) {
-    effectiveLexicalSuccessor(eval)->isNewBlock = true;
+  /// Mark the exit successor of an Evaluation as a new block.
+  void markExitSuccessorAsNewBlock(pft::Evaluation &eval) {
+    exitSuccessor(eval)->isNewBlock = true;
   }
 
   template <typename A>
@@ -464,232 +435,203 @@ class PFTBuilder {
     pft::Evaluation *lastIfConstructEvaluation{nullptr};
     pft::Evaluation *lastIfStmtEvaluation{nullptr};
     for (auto &eval : evaluationList) {
-      std::visit(
-          common::visitors{
-              // Action statements
-              [&](const parser::BackspaceStmt *s) {
-                analyzeIoBranches(eval, s);
-              },
-              [&](const parser::CallStmt *s) {
-                // Look for alternate return specifiers.
-                const auto &args{
-                    std::get<std::list<parser::ActualArgSpec>>(s->v.t)};
-                for (const auto &arg : args) {
-                  const auto &actual{std::get<parser::ActualArg>(arg.t)};
-                  if (const auto *altReturn{
-                          std::get_if<parser::AltReturnSpec>(&actual.u)}) {
-                    markBranchTarget(eval, altReturn->v);
-                  }
-                }
-              },
-              [&](const parser::CloseStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::CycleStmt *s) {
-                std::string name{getConstructName(s)};
-                pft::Evaluation *construct{name.empty()
-                                               ? doConstructStack.back()
-                                               : constructNameMap[name]};
-                assert(construct && "missing CYCLE construct");
-                markBranchTarget(eval, construct->evaluationList->back());
-              },
-              [&](const parser::EndfileStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::ExitStmt *s) {
-                std::string name{getConstructName(s)};
-                pft::Evaluation *construct{name.empty()
-                                               ? doConstructStack.back()
-                                               : constructNameMap[name]};
-                assert(construct && "missing EXIT construct");
-                markBranchTarget(eval, *construct->constructExit);
-              },
-              [&](const parser::FlushStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::GotoStmt *s) { markBranchTarget(eval, s->v); },
-              [&](const parser::IfStmt *) { lastIfStmtEvaluation = &eval; },
-              [&](const parser::InquireStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::OpenStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::ReadStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::ReturnStmt *) { eval.isUnstructured = true; },
-              [&](const parser::RewindStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::StopStmt *) { eval.isUnstructured = true; },
-              [&](const parser::WaitStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::WriteStmt *s) { analyzeIoBranches(eval, s); },
-              [&](const parser::ComputedGotoStmt *s) {
-                for (auto &label : std::get<std::list<parser::Label>>(s->t)) {
-                  markBranchTarget(eval, label);
-                }
-              },
-              [&](const parser::ArithmeticIfStmt *s) {
-                markBranchTarget(eval, std::get<1>(s->t));
-                markBranchTarget(eval, std::get<2>(s->t));
-                markBranchTarget(eval, std::get<3>(s->t));
-              },
-              [&](const parser::AssignStmt *s) { // legacy label assignment
-                auto &label = std::get<parser::Label>(s->t);
-                auto sym = std::get<parser::Name>(s->t).symbol;
-                assert(sym && "missing AssignStmt symbol");
-                pft::Evaluation *t{labelEvaluationMap->find(label)->second};
-                if (!std::get_if<const parser::FormatStmt *const>(&t->u)) {
-                  markBranchTarget(eval, label);
-                }
-                auto iter = assignSymbolLabelMap->find(sym);
-                if (iter == assignSymbolLabelMap->end()) {
-                  pft::LabelSet labelSet{};
-                  labelSet.insert(label);
-                  assignSymbolLabelMap->try_emplace(sym, labelSet);
-                } else {
-                  iter->second.insert(label);
-                }
-              },
-              [&](const parser::AssignedGotoStmt *) {
-                // Specific control successors are not in general known.
-                // Compensate by directly marking the successor new block.
-                markSuccessorNewBlock(eval);
-              },
-
-              // Construct statements
-              [&](const parser::AssociateStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-              },
-              [&](const parser::BlockStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-              },
-              [&](const parser::SelectCaseStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-                eval.lexicalSuccessor->isNewBlock = true;
-              },
-              [&](const parser::CaseStmt *) { eval.isNewBlock = true; },
-              [&](const parser::ChangeTeamStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-              },
-              [&](const parser::CriticalStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-              },
-              [&](const parser::NonLabelDoStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-                doConstructStack.push_back(parentConstruct);
-                auto &control{
-                    std::get<std::optional<parser::LoopControl>>(s->t)};
-                // eval.block is the loop preheader block, which will be set
-                // elsewhere if the NonLabelDoStmt is itself a target.
-                // eval.localBlocks[0] is the loop header block.
-                eval.localBlocks.emplace_back(nullptr);
-                if (!control.has_value()) {
-                  eval.isUnstructured = true; // infinite loop
-                  return;
-                }
-                eval.lexicalSuccessor->isNewBlock = true;
-                eval.controlSuccessor = &evaluationList.back();
-                if (std::holds_alternative<parser::ScalarLogicalExpr>(
-                        control->u)) {
-                  eval.isUnstructured = true; // while loop
-                }
-                // Defer additional processing for a concurrent loop to the
-                // EndDoStmt, when it is known if the loop is structured or not.
-              },
-              [&](const parser::EndDoStmt *) {
-                pft::Evaluation &doEval{evaluationList.front()};
-                eval.controlSuccessor = &doEval;
-                doConstructStack.pop_back();
-                if (parentConstruct->lowerAsStructured()) {
-                  return;
-                }
-                parentConstruct->constructExit->isNewBlock = true;
-                const auto &doStmt{doEval.getIf<parser::NonLabelDoStmt>()};
-                assert(doStmt && "missing NonLabelDoStmt");
-                auto &control{
-                    std::get<std::optional<parser::LoopControl>>(doStmt->t)};
-                if (!control.has_value()) {
-                  return; // infinite loop
-                }
-                const auto *concurrent{
-                    std::get_if<parser::LoopControl::Concurrent>(&control->u)};
-                if (!concurrent) {
-                  return;
-                }
-                // Unstructured concurrent loop.  NonLabelDoStmt code accounts
-                // for one concurrent loop dimension.  Reserve preheader,
-                // header, and latch blocks for the remaining dimensions, and
-                // one block for a mask expression.
-                const auto &header{
-                    std::get<parser::ConcurrentHeader>(concurrent->t)};
-                auto dims{
-                    std::get<std::list<parser::ConcurrentControl>>(header.t)
-                        .size()};
-                for (; dims > 1; --dims) {
-                  doEval.localBlocks.emplace_back(nullptr); // preheader
-                  doEval.localBlocks.emplace_back(nullptr); // header
-                  eval.localBlocks.emplace_back(nullptr);   // latch
-                }
-                if (std::get<std::optional<parser::ScalarLogicalExpr>>(
-                        header.t)) {
-                  doEval.localBlocks.emplace_back(nullptr); // mask
-                }
-              },
-              [&](const parser::IfThenStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-                eval.lexicalSuccessor->isNewBlock = true;
-                lastIfConstructEvaluation = &eval;
-              },
-              [&](const parser::ElseIfStmt *s) {
-                eval.isNewBlock = true;
-                eval.lexicalSuccessor->isNewBlock = true;
-                lastIfConstructEvaluation->controlSuccessor = &eval;
-                lastIfConstructEvaluation = &eval;
-              },
-              [&](const parser::ElseStmt *s) {
-                eval.isNewBlock = true;
-                lastIfConstructEvaluation->controlSuccessor = &eval;
-                lastIfConstructEvaluation = &eval;
-              },
-              [&](const parser::EndIfStmt *) {
-                if (parentConstruct->lowerAsUnstructured()) {
-                  parentConstruct->constructExit->isNewBlock = true;
-                }
-                lastIfConstructEvaluation->controlSuccessor =
-                    parentConstruct->constructExit;
-                lastIfConstructEvaluation = nullptr;
-              },
-              [&](const parser::SelectRankStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-                eval.lexicalSuccessor->isNewBlock = true;
-              },
-              [&](const parser::SelectRankCaseStmt *) {
-                eval.isNewBlock = true;
-              },
-              [&](const parser::SelectTypeStmt *s) {
-                insertConstructName(&*s, parentConstruct);
-                eval.lexicalSuccessor->isNewBlock = true;
-              },
-              [&](const parser::TypeGuardStmt *) { eval.isNewBlock = true; },
-
-              // Constructs - set (unstructured construct) exit targets
-              [&](const parser::AssociateConstruct *) {
-                setConstructExit(eval);
-              },
-              [&](const parser::BlockConstruct *) {
-                // EndBlockStmt may have exit code.
-                eval.constructExit = &eval.evaluationList->back();
-              },
-              [&](const parser::CaseConstruct *) { setConstructExit(eval); },
-              [&](const parser::ChangeTeamConstruct *) {
-                setConstructExit(eval);
-              },
-              [&](const parser::CriticalConstruct *) {
-                setConstructExit(eval);
-              },
-              [&](const parser::DoConstruct *) { setConstructExit(eval); },
-              [&](const parser::IfConstruct *) { setConstructExit(eval); },
-              [&](const parser::SelectRankConstruct *) {
-                setConstructExit(eval);
-              },
-              [&](const parser::SelectTypeConstruct *) {
-                setConstructExit(eval);
-              },
+      eval.visit(common::visitors{
+          // Action statements
+          [&](const parser::BackspaceStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::CallStmt &s) {
+            // Look for alternate return specifiers.
+            const auto &args{std::get<std::list<parser::ActualArgSpec>>(s.v.t)};
+            for (const auto &arg : args) {
+              const auto &actual{std::get<parser::ActualArg>(arg.t)};
+              if (const auto *altReturn{
+                      std::get_if<parser::AltReturnSpec>(&actual.u)}) {
+                markBranchTarget(eval, altReturn->v);
+              }
+            }
+          },
+          [&](const parser::CloseStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::CycleStmt &s) {
+            std::string name{getConstructName(&s)};
+            pft::Evaluation *construct{name.empty() ? doConstructStack.back()
+                                                    : constructNameMap[name]};
+            assert(construct && "missing CYCLE construct");
+            markBranchTarget(eval, construct->evaluationList->back());
+          },
+          [&](const parser::EndfileStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::ExitStmt &s) {
+            std::string name{getConstructName(&s)};
+            pft::Evaluation *construct{name.empty() ? doConstructStack.back()
+                                                    : constructNameMap[name]};
+            assert(construct && "missing EXIT construct");
+            markBranchTarget(eval, *construct->constructExit);
+          },
+          [&](const parser::FlushStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::GotoStmt &s) { markBranchTarget(eval, s.v); },
+          [&](const parser::IfStmt &) { lastIfStmtEvaluation = &eval; },
+          [&](const parser::InquireStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::OpenStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::ReadStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::ReturnStmt &) { eval.isUnstructured = true; },
+          [&](const parser::RewindStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::StopStmt &) { eval.isUnstructured = true; },
+          [&](const parser::WaitStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::WriteStmt &s) { analyzeIoBranches(eval, &s); },
+          [&](const parser::ComputedGotoStmt &s) {
+            for (auto &label : std::get<std::list<parser::Label>>(s.t)) {
+              markBranchTarget(eval, label);
+            }
+          },
+          [&](const parser::ArithmeticIfStmt &s) {
+            markBranchTarget(eval, std::get<1>(s.t));
+            markBranchTarget(eval, std::get<2>(s.t));
+            markBranchTarget(eval, std::get<3>(s.t));
+          },
+          [&](const parser::AssignStmt &s) { // legacy label assignment
+            auto &label = std::get<parser::Label>(s.t);
+            auto sym = std::get<parser::Name>(s.t).symbol;
+            assert(sym && "missing AssignStmt symbol");
+            pft::Evaluation *t{labelEvaluationMap->find(label)->second};
+            if (!std::get_if<const parser::FormatStmt *const>(&t->u)) {
+              markBranchTarget(eval, label);
+            }
+            auto iter = assignSymbolLabelMap->find(sym);
+            if (iter == assignSymbolLabelMap->end()) {
+              pft::LabelSet labelSet{};
+              labelSet.insert(label);
+              assignSymbolLabelMap->try_emplace(sym, labelSet);
+            } else {
+              iter->second.insert(label);
+            }
+          },
+          [&](const parser::AssignedGotoStmt &) {
+            // Although this statement is a branch, it doesn't have any
+            // explicit control successors.  So the code at the end of the
+            // loop won't mark the exit successor.  Do that here.
+            markExitSuccessorAsNewBlock(eval);
+          },
 
-              [](const auto *) { /* do nothing */ },
+          // Construct statements
+          [&](const parser::AssociateStmt &s) {
+            insertConstructName(&s, parentConstruct);
+          },
+          [&](const parser::BlockStmt &s) {
+            insertConstructName(&s, parentConstruct);
+          },
+          [&](const parser::SelectCaseStmt &s) {
+            insertConstructName(&s, parentConstruct);
+            eval.lexicalSuccessor->isNewBlock = true;
+          },
+          [&](const parser::CaseStmt &) { eval.isNewBlock = true; },
+          [&](const parser::ChangeTeamStmt &s) {
+            insertConstructName(&s, parentConstruct);
+          },
+          [&](const parser::CriticalStmt &s) {
+            insertConstructName(&s, parentConstruct);
+          },
+          [&](const parser::NonLabelDoStmt &s) {
+            insertConstructName(&s, parentConstruct);
+            doConstructStack.push_back(parentConstruct);
+            auto &control{std::get<std::optional<parser::LoopControl>>(s.t)};
+            // eval.block is the loop preheader block, which will be set
+            // elsewhere if the NonLabelDoStmt is itself a target.
+            // eval.localBlocks[0] is the loop header block.
+            eval.localBlocks.emplace_back(nullptr);
+            if (!control.has_value()) {
+              eval.isUnstructured = true; // infinite loop
+              return;
+            }
+            eval.lexicalSuccessor->isNewBlock = true;
+            eval.controlSuccessor = &evaluationList.back();
+            if (std::holds_alternative<parser::ScalarLogicalExpr>(control->u)) {
+              eval.isUnstructured = true; // while loop
+            }
+            // Defer additional processing for a concurrent loop to the
+            // EndDoStmt, when it is known if the loop is structured or not.
           },
-          eval.u);
+          [&](const parser::EndDoStmt &) {
+            pft::Evaluation &doEval{evaluationList.front()};
+            eval.controlSuccessor = &doEval;
+            doConstructStack.pop_back();
+            if (parentConstruct->lowerAsStructured()) {
+              return;
+            }
+            parentConstruct->constructExit->isNewBlock = true;
+            const auto &doStmt{doEval.getIf<parser::NonLabelDoStmt>()};
+            assert(doStmt && "missing NonLabelDoStmt");
+            auto &control{
+                std::get<std::optional<parser::LoopControl>>(doStmt->t)};
+            if (!control.has_value()) {
+              return; // infinite loop
+            }
+            const auto *concurrent{
+                std::get_if<parser::LoopControl::Concurrent>(&control->u)};
+            if (!concurrent) {
+              return;
+            }
+            // Unstructured concurrent loop.  NonLabelDoStmt code accounts
+            // for one concurrent loop dimension.  Reserve preheader,
+            // header, and latch blocks for the remaining dimensions, and
+            // one block for a mask expression.
+            const auto &header{
+                std::get<parser::ConcurrentHeader>(concurrent->t)};
+            auto dims{std::get<std::list<parser::ConcurrentControl>>(header.t)
+                          .size()};
+            for (; dims > 1; --dims) {
+              doEval.localBlocks.emplace_back(nullptr); // preheader
+              doEval.localBlocks.emplace_back(nullptr); // header
+              eval.localBlocks.emplace_back(nullptr);   // latch
+            }
+            if (std::get<std::optional<parser::ScalarLogicalExpr>>(header.t)) {
+              doEval.localBlocks.emplace_back(nullptr); // mask
+            }
+          },
+          [&](const parser::IfThenStmt &s) {
+            insertConstructName(&s, parentConstruct);
+            eval.lexicalSuccessor->isNewBlock = true;
+            lastIfConstructEvaluation = &eval;
+          },
+          [&](const parser::ElseIfStmt &) {
+            eval.isNewBlock = true;
+            eval.lexicalSuccessor->isNewBlock = true;
+            lastIfConstructEvaluation->controlSuccessor = &eval;
+            lastIfConstructEvaluation = &eval;
+          },
+          [&](const parser::ElseStmt &) {
+            eval.isNewBlock = true;
+            lastIfConstructEvaluation->controlSuccessor = &eval;
+            lastIfConstructEvaluation = &eval;
+          },
+          [&](const parser::EndIfStmt &) {
+            if (parentConstruct->lowerAsUnstructured()) {
+              parentConstruct->constructExit->isNewBlock = true;
+            }
+            lastIfConstructEvaluation->controlSuccessor =
+                parentConstruct->constructExit;
+            lastIfConstructEvaluation = nullptr;
+          },
+          [&](const parser::SelectRankStmt &s) {
+            insertConstructName(&s, parentConstruct);
+            eval.lexicalSuccessor->isNewBlock = true;
+          },
+          [&](const parser::SelectRankCaseStmt &) { eval.isNewBlock = true; },
+          [&](const parser::SelectTypeStmt &s) {
+            insertConstructName(&s, parentConstruct);
+            eval.lexicalSuccessor->isNewBlock = true;
+          },
+          [&](const parser::TypeGuardStmt &) { eval.isNewBlock = true; },
+
+          [](const auto &) { /* do nothing */ },
+      });
 
-      // Analyze branches in a nested construct.
-      if (eval.evaluationList) {
+      // Analyze construct evaluations.
+      if (eval.isConstruct()) {
+        if (eval.evaluationList) {
+          eval.constructExit = eval.evaluationList->back().lexicalSuccessor;
+          if (eval.constructExit->isNopConstructStmt()) {
+            eval.constructExit =
+                eval.constructExit->parentConstruct->constructExit;
+          }
+        }
         analyzeBranches(&eval, *eval.evaluationList);
       }
 
@@ -698,11 +640,10 @@ class PFTBuilder {
         // eval is the action substatement of an IfStmt.
         if (eval.lowerAsUnstructured()) {
           eval.isNewBlock = true;
-          markSuccessorNewBlock(eval);
+          markExitSuccessorAsNewBlock(eval);
           lastIfStmtEvaluation->isUnstructured = true;
         }
-        lastIfStmtEvaluation->controlSuccessor =
-            effectiveLexicalSuccessor(eval);
+        lastIfStmtEvaluation->controlSuccessor = exitSuccessor(eval);
         lastIfStmtEvaluation = nullptr;
       }
 
@@ -722,15 +663,16 @@ class PFTBuilder {
         eval.lexicalSuccessor->isNewBlock = true;
       }
 
-      // The lexical successor of a branch starts a new block.
-      if (eval.controlSuccessor && eval.isActionStmt()) {
-        markSuccessorNewBlock(eval);
-      }
-
       // Propagate isUnstructured flag to enclosing construct.
       if (parentConstruct && eval.isUnstructured) {
         parentConstruct->isUnstructured = true;
       }
+
+      // The lexical successor of a branch starts a new block.
+      if (eval.controlSuccessor && eval.isActionStmt() &&
+          eval.lowerAsUnstructured()) {
+        markExitSuccessorAsNewBlock(eval);
+      }
     }
   }
 

From 22adc1730c7247cebfe85ec3d03521026094b233 Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Thu, 5 Mar 2020 20:45:10 -0800
Subject: [PATCH 228/345] Update for review comments.

---
 include/flang/Lower/PFTBuilder.h | 21 ++++++----
 lib/Lower/Bridge.cpp             | 15 ++++---
 lib/Lower/PFTBuilder.cpp         | 71 +++++++++++++++++++-------------
 3 files changed, 66 insertions(+), 41 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 007b8f7f003b..60d96a076ee4 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -96,15 +96,17 @@ static constexpr bool isConstructStmt{common::HasMember<A, ConstructStmts>};
 template <typename A>
 static constexpr bool isConstruct{common::HasMember<A, Constructs>};
 
-using NopConstructStmts =
-    std::tuple<parser::EndAssociateStmt, parser::CaseStmt,
-               parser::EndSelectStmt, parser::ElseIfStmt, parser::ElseStmt,
-               parser::EndIfStmt, parser::SelectRankStmt,
-               parser::TypeGuardStmt>;
+template <typename A>
+static constexpr bool isIntermediateConstructStmt{common::HasMember<
+    A, std::tuple<parser::CaseStmt, parser::ElseIfStmt, parser::ElseStmt,
+                  parser::SelectRankCaseStmt, parser::TypeGuardStmt>>};
 
 template <typename A>
-static constexpr bool isNopConstructStmt{
-    common::HasMember<A, NopConstructStmts>};
+static constexpr bool isNopConstructStmt{common::HasMember<
+    A, std::tuple<parser::EndAssociateStmt, parser::CaseStmt,
+                  parser::EndSelectStmt, parser::ElseIfStmt, parser::ElseStmt,
+                  parser::EndIfStmt, parser::SelectRankCaseStmt,
+                  parser::TypeGuardStmt>>};
 
 template <typename A>
 static constexpr bool isFunctionLike{common::HasMember<
@@ -182,6 +184,11 @@ struct Evaluation {
     return visit(common::visitors{
         [](auto &r) { return pft::isConstruct<std::decay_t<decltype(r)>>; }});
   }
+  constexpr bool isIntermediateConstructStmt() const {
+    return visit(common::visitors{[](auto &r) {
+      return pft::isIntermediateConstructStmt<std::decay_t<decltype(r)>>;
+    }});
+  }
   constexpr bool isNopConstructStmt() const {
     return visit(common::visitors{[](auto &r) {
       return pft::isNopConstructStmt<std::decay_t<decltype(r)>>;
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 3f636884b591..88b0ba541a7c 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -658,16 +658,21 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     // Unstructured branch sequence.
     for (auto &e : *eval.evaluationList) {
+      const Fortran::parser::ScalarLogicalExpr *cond = nullptr;
       if (auto *s = e.getIf<Fortran::parser::IfThenStmt>()) {
         maybeStartBlock(e.block);
-        genFIRConditionalBranch(
-            std::get<Fortran::parser::ScalarLogicalExpr>(s->t),
-            e.lexicalSuccessor, e.controlSuccessor);
+        cond = &std::get<Fortran::parser::ScalarLogicalExpr>(s->t);
       } else if (auto *s = e.getIf<Fortran::parser::ElseIfStmt>()) {
         startBlock(e.block);
+        cond = &std::get<Fortran::parser::ScalarLogicalExpr>(s->t);
+      }
+      if (cond) {
         genFIRConditionalBranch(
-            std::get<Fortran::parser::ScalarLogicalExpr>(s->t),
-            e.lexicalSuccessor, e.controlSuccessor);
+            *cond,
+            e.lexicalSuccessor == e.controlSuccessor
+                ? e.parentConstruct->constructExit // empty block --> exit
+                : e.lexicalSuccessor,              // nonempty block
+            e.controlSuccessor);
       } else {
         genFIR(e);
       }
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index aad8d8bd9fda..4554b80a5828 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -309,8 +309,7 @@ class PFTBuilder {
         if (std::holds_alternative<parser::ErrLabel>(control.u) ||
             std::holds_alternative<parser::EorLabel>(control.u) ||
             std::holds_alternative<parser::EndLabel>(control.u)) {
-          pft::Evaluation *t{labelEvaluationMap->find(stmt->v)->second};
-          markBranchTarget(eval, *t);
+          markBranchTarget(eval, stmt->v);
         }
       }
     }
@@ -325,8 +324,7 @@ class PFTBuilder {
         if (std::holds_alternative<parser::ErrLabel>(spec.u) ||
             std::holds_alternative<parser::EorLabel>(spec.u) ||
             std::holds_alternative<parser::EndLabel>(spec.u)) {
-          pft::Evaluation *t{labelEvaluationMap->find(stmt->v)->second};
-          markBranchTarget(eval, *t);
+          markBranchTarget(eval, stmt->v);
         }
       }
     }
@@ -336,13 +334,21 @@ class PFTBuilder {
         if (std::holds_alternative<parser::ErrLabel>(spec.u) ||
             std::holds_alternative<parser::EorLabel>(spec.u) ||
             std::holds_alternative<parser::EndLabel>(spec.u)) {
-          pft::Evaluation *t{labelEvaluationMap->find(stmt->v)->second};
-          markBranchTarget(eval, *t);
+          markBranchTarget(eval, stmt->v);
         }
       }
     }
   }
 
+  /// Set the exit of a construct, possibly from multiple enclosing constructs.
+  void setConstructExit(pft::Evaluation &eval) {
+    eval.constructExit = eval.evaluationList->back().lexicalSuccessor;
+    if (eval.constructExit->isNopConstructStmt()) {
+      eval.constructExit = eval.constructExit->parentConstruct->constructExit;
+    }
+    assert(eval.constructExit && "missing construct exit");
+  }
+
   void markBranchTarget(pft::Evaluation &sourceEvaluation,
                         pft::Evaluation &targetEvaluation) {
     sourceEvaluation.isUnstructured = true;
@@ -353,13 +359,14 @@ class PFTBuilder {
   }
   void markBranchTarget(pft::Evaluation &sourceEvaluation,
                         parser::Label label) {
+    assert(label && "missing branch target label");
     pft::Evaluation *targetEvaluation{labelEvaluationMap->find(label)->second};
-    assert(targetEvaluation && "missing branch target");
+    assert(targetEvaluation && "missing branch target evaluation");
     markBranchTarget(sourceEvaluation, *targetEvaluation);
   }
 
-  /// Return the first successor of an evaluation that isn't a nop,
-  /// possibly exiting from one or more enclosing constructs.
+  /// Return the first non-nop successor of an evaluation, possibly exiting
+  /// from one or more enclosing constructs.
   pft::Evaluation *exitSuccessor(pft::Evaluation &eval) {
     pft::Evaluation *successor{eval.lexicalSuccessor};
     if (successor->isNopConstructStmt()) {
@@ -545,8 +552,8 @@ class PFTBuilder {
             if (std::holds_alternative<parser::ScalarLogicalExpr>(control->u)) {
               eval.isUnstructured = true; // while loop
             }
-            // Defer additional processing for a concurrent loop to the
-            // EndDoStmt, when it is known if the loop is structured or not.
+            // Defer additional processing for an unstructured concurrent loop
+            // to the EndDoStmt, when the loop is known to be unstructured.
           },
           [&](const parser::EndDoStmt &) {
             pft::Evaluation &doEval{evaluationList.front()};
@@ -555,6 +562,8 @@ class PFTBuilder {
             if (parentConstruct->lowerAsStructured()) {
               return;
             }
+            // Now that the loop is known to be unstructured, finish concurrent
+            // loop processing, using NonLabelDoStmt information.
             parentConstruct->constructExit->isNewBlock = true;
             const auto &doStmt{doEval.getIf<parser::NonLabelDoStmt>()};
             assert(doStmt && "missing NonLabelDoStmt");
@@ -620,18 +629,31 @@ class PFTBuilder {
           },
           [&](const parser::TypeGuardStmt &) { eval.isNewBlock = true; },
 
+          // Constructs - set (unstructured) construct exit targets
+          [&](const parser::AssociateConstruct &) { setConstructExit(eval); },
+          [&](const parser::BlockConstruct &) {
+            // EndBlockStmt may have code.
+            eval.constructExit = &eval.evaluationList->back();
+          },
+          [&](const parser::CaseConstruct &) { setConstructExit(eval); },
+          [&](const parser::ChangeTeamConstruct &) {
+            // EndChangeTeamStmt may have code.
+            eval.constructExit = &eval.evaluationList->back();
+          },
+          [&](const parser::CriticalConstruct &) {
+            // EndCriticalStmt may have code.
+            eval.constructExit = &eval.evaluationList->back();
+          },
+          [&](const parser::DoConstruct &) { setConstructExit(eval); },
+          [&](const parser::IfConstruct &) { setConstructExit(eval); },
+          [&](const parser::SelectRankConstruct &) { setConstructExit(eval); },
+          [&](const parser::SelectTypeConstruct &) { setConstructExit(eval); },
+
           [](const auto &) { /* do nothing */ },
       });
 
       // Analyze construct evaluations.
-      if (eval.isConstruct()) {
-        if (eval.evaluationList) {
-          eval.constructExit = eval.evaluationList->back().lexicalSuccessor;
-          if (eval.constructExit->isNopConstructStmt()) {
-            eval.constructExit =
-                eval.constructExit->parentConstruct->constructExit;
-          }
-        }
+      if (eval.evaluationList) {
         analyzeBranches(&eval, *eval.evaluationList);
       }
 
@@ -649,16 +671,7 @@ class PFTBuilder {
 
       // Set the successor of the last statement in an IF or SELECT block.
       if (!eval.controlSuccessor && eval.lexicalSuccessor &&
-          std::visit(
-              common::visitors{
-                  [](const parser::CaseStmt *) { return true; },
-                  [](const parser::ElseIfStmt *) { return true; },
-                  [](const parser::ElseStmt *) { return true; },
-                  [](const parser::SelectRankCaseStmt *) { return true; },
-                  [](const parser::TypeGuardStmt *) { return true; },
-                  [](const auto *) { return false; },
-              },
-              eval.lexicalSuccessor->u)) {
+          eval.lexicalSuccessor->isIntermediateConstructStmt()) {
         eval.controlSuccessor = parentConstruct->constructExit;
         eval.lexicalSuccessor->isNewBlock = true;
       }

From 2c4a644e34041b328e01873c91cf793f00e7c3c3 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 6 Mar 2020 09:02:50 -0800
Subject: [PATCH 229/345] Jean's review comment on TableGen

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2fb1a1c7cb66..89740bcf7ffc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -62,6 +62,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   include(AddLLVM)
   include(HandleLLVMOptions)  
   include(VersionFromVCS)
+  include(TableGen)
   include(AddMLIR) 
 
   option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)

From 594f4a82cd6a76edde832297d2fca05841e61e4f Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 6 Mar 2020 16:09:33 -0800
Subject: [PATCH 230/345] code cleanup

---
 lib/Lower/Intrinsics.cpp  | 34 +++++++++++++++++-----------------
 lib/Optimizer/CodeGen.cpp |  8 ++++----
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/lib/Lower/Intrinsics.cpp b/lib/Lower/Intrinsics.cpp
index f3ff2ceaf81c..94731e85c326 100644
--- a/lib/Lower/Intrinsics.cpp
+++ b/lib/Lower/Intrinsics.cpp
@@ -44,7 +44,7 @@ class MathRuntimeLibrary {
   /// mlir::FuncOp and to compare function types.
   struct RuntimeFunction {
     RuntimeFunction(llvm::StringRef n, mlir::FunctionType t)
-        : symbol{n}, type{t} {};
+        : symbol{n}, type{t} {}
     llvm::StringRef symbol;
     mlir::FunctionType type;
   };
@@ -549,8 +549,8 @@ mlir::Value IntrinsicLibrary::Implementation::outlineInWrapper(
     Generator generator, Context &context, MathRuntimeLibrary &runtime) {
   auto module = getModule(context.builder);
   auto *mlirContext = module.getContext();
-  std::string wrapperName{
-      getIntrinsicWrapperName(context.name, context.funcType)};
+  std::string wrapperName =
+      getIntrinsicWrapperName(context.name, context.funcType);
   auto function = getNamedFunction(module, wrapperName);
   if (!function) {
     // First time this wrapper is needed, build it.
@@ -635,10 +635,10 @@ IntrinsicLibrary::Implementation::genRuntimeCall(Context &context,
 mlir::Value IntrinsicLibrary::Implementation::genConjg(Context &genCtxt,
                                                        MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 1);
-  mlir::Type resType = genCtxt.getResultType();
+  [[maybe_unused]] mlir::Type resType = genCtxt.getResultType();
   assert(resType == genCtxt.arguments[0].getType());
-  mlir::OpBuilder &builder{*genCtxt.builder};
-  ComplexOpsBuilder cplxHandler{builder, genCtxt.loc};
+  mlir::OpBuilder &builder = *genCtxt.builder;
+  ComplexOpsBuilder cplxHandler(builder, genCtxt.loc);
 
   mlir::Value cplx = genCtxt.arguments[0];
   mlir::Value imag = cplxHandler.extract<ComplexOpsBuilder::Part::Imag>(cplx);
@@ -651,7 +651,7 @@ mlir::Value IntrinsicLibrary::Implementation::genMerge(Context &genCtxt,
                                                        MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 3);
   [[maybe_unused]] auto resType = genCtxt.getResultType();
-  mlir::OpBuilder &builder{*genCtxt.builder};
+  mlir::OpBuilder &builder = *genCtxt.builder;
 
   auto &trueVal = genCtxt.arguments[0];
   auto &falseVal = genCtxt.arguments[1];
@@ -666,12 +666,12 @@ template <Extremum extremum, ExtremumBehavior behavior>
 static mlir::Value createExtremumCompare(mlir::Location loc,
                                          mlir::OpBuilder &builder,
                                          mlir::Value left, mlir::Value right) {
-  static constexpr auto integerPredicate{extremum == Extremum::Max
-                                             ? mlir::CmpIPredicate::sgt
-                                             : mlir::CmpIPredicate::slt};
-  static constexpr auto orderedCmp{extremum == Extremum::Max
-                                       ? mlir::CmpFPredicate::OGT
-                                       : mlir::CmpFPredicate::OLT};
+  static constexpr auto integerPredicate = extremum == Extremum::Max
+                                               ? mlir::CmpIPredicate::sgt
+                                               : mlir::CmpIPredicate::slt;
+  static constexpr auto orderedCmp = extremum == Extremum::Max
+                                         ? mlir::CmpFPredicate::OGT
+                                         : mlir::CmpFPredicate::OLT;
   auto type = left.getType();
   mlir::Value result;
   if (type.isa<mlir::FloatType>() || type.isa<fir::RealType>()) {
@@ -697,9 +697,9 @@ static mlir::Value createExtremumCompare(mlir::Location loc,
       result = builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
     } else if constexpr (behavior == ExtremumBehavior::PgfortranLlvm) {
       // If one of the operand is a NaN, return left whatever it is.
-      static constexpr auto unorderedCmp{extremum == Extremum::Max
-                                             ? mlir::CmpFPredicate::UGT
-                                             : mlir::CmpFPredicate::ULT};
+      static constexpr auto unorderedCmp = extremum == Extremum::Max
+                                               ? mlir::CmpFPredicate::UGT
+                                               : mlir::CmpFPredicate::ULT;
       result = builder.create<fir::CmpfOp>(loc, unorderedCmp, left, right);
     } else {
       // TODO: ieeMinNum/ieeeMaxNum
@@ -722,7 +722,7 @@ template <Extremum extremum, ExtremumBehavior behavior>
 mlir::Value
 IntrinsicLibrary::Implementation::genExtremum(Context &genCtxt,
                                               MathRuntimeLibrary &) {
-  auto &builder{*genCtxt.builder};
+  auto &builder = *genCtxt.builder;
   auto loc = genCtxt.loc;
   assert(genCtxt.arguments.size() >= 2);
   mlir::Value result = genCtxt.arguments[0];
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 15a68ca4304f..f341f961ee2e 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -1332,11 +1332,11 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
 
   // constructing the name of the method
   inline static std::string methodName(fir::FieldIndexOp field) {
-    Twine fldName = field.field_id();
+    auto fldName = field.field_id();
+    auto type = field.on_type().cast<fir::RecordType>();
     // note: using std::string to dodge a bug in g++ 7.4.0
-    std::string tyName =
-        field.on_type().cast<fir::RecordType>().getName().str();
-    Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
+    std::string tyName = type.getName().str();
+    llvm::Twine methodName = "_QQOFFSETOF_" + tyName + "_" + fldName;
     return methodName.str();
   }
 };

From 0b38472273aeed8a24ad984c611360ff5e404145 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 6 Mar 2020 10:20:08 -0800
Subject: [PATCH 231/345] [PR1035] enable FIRLangRef.md generation

---
 README.md                                      | 17 +++++++++++++++--
 include/flang/Optimizer/Dialect/CMakeLists.txt | 18 ++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index e71e46ff509b..55bdd97bbd69 100644
--- a/README.md
+++ b/README.md
@@ -118,5 +118,18 @@ Special CMake instructions given above are required while building out-of-tree s
 
 ### Problems
 
-Despite best efforts, there may be situations where the above repos will
-get out of sync, and the build will fail.
+To run individual regression tests llvm-lit needs to know the lit
+configuration for f18. The parameters in charge of this are:
+flang_site_config and flang_config. And they can be set as shown bellow:
+```
+<path-to-llvm-lit>/llvm-lit \
+ --param flang_site_config=<path-to-f18-build>/test-lit/lit.site.cfg.py \
+ --param flang_config=<path-to-f18-build>/test-lit/lit.cfg.py \
+  <path-to-fortran-test>
+```
+
+# How to Generate FIR Documentation
+
+If f18 was built with `-DLINK_WITH_FIR=On` (`On` by default), it is possible to
+generate FIR language documentation by running `make flang-doc`. This will
+create `docs/Dialect/FIRLangRef.md` in f18 build directory.
diff --git a/include/flang/Optimizer/Dialect/CMakeLists.txt b/include/flang/Optimizer/Dialect/CMakeLists.txt
index 9528b1abffb0..f83cb8f522a3 100644
--- a/include/flang/Optimizer/Dialect/CMakeLists.txt
+++ b/include/flang/Optimizer/Dialect/CMakeLists.txt
@@ -1,4 +1,22 @@
+# This replicates part of the add_mlir_dialect cmake function from MLIR that
+# cannot be used her because it expects to be run inside MLIR directory which
+# is not the case for FIR.
 set(LLVM_TARGET_DEFINITIONS FIROps.td)
 mlir_tablegen(FIROps.h.inc -gen-op-decls)
 mlir_tablegen(FIROps.cpp.inc -gen-op-defs)
 add_public_tablegen_target(FIROpsIncGen)
+
+add_custom_target(flang-doc)
+set(dialect_doc_filename "FIRLangRef")
+
+set(LLVM_TARGET_DEFINITIONS FIROps.td)
+tablegen(MLIR ${dialect_doc_filename}.md -gen-op-doc "-I${MLIR_MAIN_SRC_DIR}" "-I${MLIR_INCLUDE_DIR}")
+set(GEN_DOC_FILE ${FLANG_BINARY_DIR}/docs/Dialect/${dialect_doc_filename}.md)
+add_custom_command(
+        OUTPUT ${GEN_DOC_FILE}
+        COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md
+                ${GEN_DOC_FILE}
+        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md)
+add_custom_target(${dialect_doc_filename}DocGen DEPENDS ${GEN_DOC_FILE})
+add_dependencies(flang-doc ${dialect_doc_filename}DocGen)

From 582fc124ee349ab570786ebf19a252e2895b37f5 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 6 Mar 2020 10:41:44 -0800
Subject: [PATCH 232/345] [PR1035] change README make -j to make

---
 README.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 55bdd97bbd69..ce187954669c 100644
--- a/README.md
+++ b/README.md
@@ -49,7 +49,17 @@ This is quite similar to the old way, but with a few subtle differences.
 One can, for example, do this with make as follows.
 
 ```
-  make <make-arguments>
+cd where/you/want/to/build/llvm
+git clone --depth=1 -b f18 https://github.com/flang-compiler/f18-llvm-project.git
+mkdir build
+mkdir install
+cd build
+cmake ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release \
+    -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 \
+    -DLLVM_INSTALL_UTILS=On \
+    -DCMAKE_INSTALL_PREFIX=../install
+make
+make install
 ```
 
 Or, of course, use their favorite build tool (such as ninja).

From 28032c944520d514383789676e2a0b2d5374b97f Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 6 Mar 2020 16:20:16 -0800
Subject: [PATCH 233/345] fix for check-flang. make it always available.

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 89740bcf7ffc..403f2d57c0ac 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -314,8 +314,8 @@ option(FLANG_INCLUDE_TESTS
 if (FLANG_INCLUDE_TESTS)
   enable_testing()
   add_subdirectory(test)
-  #add_subdirectory(test-lit)
 endif()
+add_subdirectory(test-lit)
 
 # TODO: Add doxygen support.
 #option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."

From 7d6044714d27387f816cfb1469f68b67e962b916 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 6 Mar 2020 17:48:20 -0800
Subject: [PATCH 234/345] NFC: code shuttling between files

---
 include/flang/Optimizer/Dialect/FIROps.td |  92 +-------------
 lib/Optimizer/Dialect/FIROps.cpp          | 143 +++++++++++++++++++++-
 2 files changed, 139 insertions(+), 96 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 3355ba0286db..e4d2e23a27c9 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -714,61 +714,7 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     ```
   }];
 
-  let parser = [{
-    mlir::OpAsmParser::OperandType selector;
-    mlir::Type type;
-    if (parseSelector(parser, result, selector, type))
-      return mlir::failure();
-
-    llvm::SmallVector<mlir::Attribute, 4> attrs;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> opers;
-    llvm::SmallVector<mlir::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
-    while (true) {
-      mlir::Attribute attr;
-      mlir::Block *dest;
-      llvm::SmallVector<mlir::Value, 4> destArg;
-      llvm::SmallVector<mlir::NamedAttribute, 1> temp;
-      if (parser.parseAttribute(attr, "a", temp) ||
-          isValidCaseAttr(attr) ||
-          parser.parseComma())
-        return mlir::failure();
-      attrs.push_back(attr);
-      if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
-        // do nothing
-      } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
-        mlir::OpAsmParser::OperandType oper1;
-        mlir::OpAsmParser::OperandType oper2;
-        if (parser.parseOperand(oper1) ||
-            parser.parseComma() ||
-            parser.parseOperand(oper2) ||
-            parser.parseComma())
-          return mlir::failure();
-        opers.push_back(oper1);
-        opers.push_back(oper2);
-      } else {
-        mlir::OpAsmParser::OperandType oper;
-        if (parser.parseOperand(oper) ||
-            parser.parseComma())
-          return mlir::failure();
-        opers.push_back(oper);
-      }
-      if (parser.parseSuccessorAndUseList(dest, destArg))
-        return mlir::failure();
-      dests.push_back(dest);
-      destArgs.push_back(destArg);
-      if (!parser.parseOptionalRSquare())
-        break;
-      if (parser.parseComma())
-        return mlir::failure();
-    }
-    result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(attrs));
-    if (parser.resolveOperands(opers, type, result.operands))
-      return mlir::failure();
-    for (unsigned i = 0, count = dests.size(); i != count; ++i)
-      result.addSuccessor(dests[i], destArgs[i]);
-    return mlir::success();
-  }];
+  let parser = "return parseSelectCase(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
@@ -1001,41 +947,7 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
 
   let results = (outs fir_BoxType);
 
-  let parser = [{
-    mlir::FunctionType type;
-    llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
-    mlir::OpAsmParser::OperandType memref;
-    if (parser.parseOperand(memref))
-      return mlir::failure();
-    operands.push_back(memref);
-    auto &builder = parser.getBuilder();
-    if (!parser.parseOptionalLParen()) {
-      if (parser.parseOperandList(operands,
-                                  mlir::OpAsmParser::Delimiter::None) ||
-          parser.parseRParen())
-        return mlir::failure();
-      auto lens = builder.getI32IntegerAttr(operands.size());
-      result.addAttribute(lenpName(), lens);
-    }
-    if (!parser.parseOptionalComma()) {
-      mlir::OpAsmParser::OperandType dims;
-      if (parser.parseOperand(dims))
-        return mlir::failure();
-      operands.push_back(dims);
-    } else if (!parser.parseOptionalLSquare()) {
-      mlir::AffineMapAttr map;
-      if (parser.parseAttribute(map, layoutName(), result.attributes) ||
-          parser.parseRSquare())
-        return mlir::failure();
-    }
-    if (parser.parseOptionalAttrDict(result.attributes) ||
-        parser.parseColonType(type) ||
-        parser.resolveOperands(operands, type.getInputs(),
-            parser.getNameLoc(), result.operands) ||
-        parser.addTypesToList(type.getResults(), result.types))
-      return mlir::failure();
-    return mlir::success();
-  }];
+  let parser = "return parseEmboxOp(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index aa6cc3833ec2..c3c1386e0f04 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -57,7 +57,9 @@ static bool verifyRecordLenParams(mlir::Type inType, unsigned numLenParams) {
   return false;
 }
 
+//===----------------------------------------------------------------------===//
 // AllocaOp
+//===----------------------------------------------------------------------===//
 
 mlir::Type fir::AllocaOp::getAllocatedType() {
   return getType().cast<ReferenceType>().getEleTy();
@@ -75,7 +77,9 @@ mlir::Type fir::AllocaOp::getRefTy(mlir::Type ty) {
   return ReferenceType::get(ty);
 }
 
+//===----------------------------------------------------------------------===//
 // AllocMemOp
+//===----------------------------------------------------------------------===//
 
 mlir::Type fir::AllocMemOp::getAllocatedType() {
   return getType().cast<HeapType>().getEleTy();
@@ -96,7 +100,9 @@ mlir::Type fir::AllocMemOp::wrapResultType(mlir::Type intype) {
   return HeapType::get(intype);
 }
 
+//===----------------------------------------------------------------------===//
 // BoxDimsOp
+//===----------------------------------------------------------------------===//
 
 /// Get the result types packed in a tuple tuple
 mlir::Type fir::BoxDimsOp::getTupleType() {
@@ -106,7 +112,9 @@ mlir::Type fir::BoxDimsOp::getTupleType() {
   return mlir::TupleType::get(triple, getContext());
 }
 
+//===----------------------------------------------------------------------===//
 // CallOp
+//===----------------------------------------------------------------------===//
 
 static void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
   auto callee = op.callee();
@@ -166,7 +174,9 @@ static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
   return mlir::success();
 }
 
+//===----------------------------------------------------------------------===//
 // CmpfOp
+//===----------------------------------------------------------------------===//
 
 // Note: getCmpFPredicateNames() is inline static in StandardOps/IR/Ops.cpp
 mlir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
@@ -237,7 +247,9 @@ mlir::ParseResult fir::parseCmpfOp(mlir::OpAsmParser &parser,
   return parseCmpOp<fir::CmpfOp>(parser, result);
 }
 
+//===----------------------------------------------------------------------===//
 // CmpcOp
+//===----------------------------------------------------------------------===//
 
 void fir::buildCmpCOp(Builder *builder, OperationState &result,
                       CmpFPredicate predicate, Value lhs, Value rhs) {
@@ -255,14 +267,18 @@ mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
+//===----------------------------------------------------------------------===//
 // DispatchOp
+//===----------------------------------------------------------------------===//
 
 mlir::FunctionType fir::DispatchOp::getFunctionType() {
   auto attr = getAttr("fn_type").cast<mlir::TypeAttr>();
   return attr.getValue().cast<mlir::FunctionType>();
 }
 
+//===----------------------------------------------------------------------===//
 // DispatchTableOp
+//===----------------------------------------------------------------------===//
 
 void fir::DispatchTableOp::appendTableEntry(mlir::Operation *op) {
   assert(mlir::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
@@ -270,7 +286,50 @@ void fir::DispatchTableOp::appendTableEntry(mlir::Operation *op) {
   block.getOperations().insert(block.end(), op);
 }
 
+//===----------------------------------------------------------------------===//
+// EmboxOp
+//===----------------------------------------------------------------------===//
+
+static mlir::ParseResult parseEmboxOp(mlir::OpAsmParser &parser,
+                                      mlir::OperationState &result) {
+  mlir::FunctionType type;
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
+  mlir::OpAsmParser::OperandType memref;
+  if (parser.parseOperand(memref))
+    return mlir::failure();
+  operands.push_back(memref);
+  auto &builder = parser.getBuilder();
+  if (!parser.parseOptionalLParen()) {
+    if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None) ||
+        parser.parseRParen())
+      return mlir::failure();
+    auto lens = builder.getI32IntegerAttr(operands.size());
+    result.addAttribute(fir::EmboxOp::lenpName(), lens);
+  }
+  if (!parser.parseOptionalComma()) {
+    mlir::OpAsmParser::OperandType dims;
+    if (parser.parseOperand(dims))
+      return mlir::failure();
+    operands.push_back(dims);
+  } else if (!parser.parseOptionalLSquare()) {
+    mlir::AffineMapAttr map;
+    if (parser.parseAttribute(map, fir::EmboxOp::layoutName(),
+                              result.attributes) ||
+        parser.parseRSquare())
+      return mlir::failure();
+  }
+  if (parser.parseOptionalAttrDict(result.attributes) ||
+      parser.parseColonType(type) ||
+      parser.resolveOperands(operands, type.getInputs(), parser.getNameLoc(),
+                             result.operands) ||
+      parser.addTypesToList(type.getResults(), result.types))
+    return mlir::failure();
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
 // GenTypeDescOp
+//===----------------------------------------------------------------------===//
 
 void fir::GenTypeDescOp::build(Builder *, OperationState &result,
                                mlir::TypeAttr inty) {
@@ -278,13 +337,17 @@ void fir::GenTypeDescOp::build(Builder *, OperationState &result,
   result.addTypes(TypeDescType::get(inty.getValue()));
 }
 
+//===----------------------------------------------------------------------===//
 // GlobalOp
+//===----------------------------------------------------------------------===//
 
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
 
+//===----------------------------------------------------------------------===//
 // LoadOp
+//===----------------------------------------------------------------------===//
 
 /// Get the element type of a reference like type; otherwise null
 static mlir::Type elementTypeOf(mlir::Type ref) {
@@ -300,11 +363,13 @@ mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
   return mlir::failure();
 }
 
+//===----------------------------------------------------------------------===//
 // LoopOp
+//===----------------------------------------------------------------------===//
 
-void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
+void fir::LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
                         int64_t lowerBound, int64_t upperBound, int64_t step,
-                        ArrayRef<NamedAttribute> attributes) {
+                        llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   llvm_unreachable("not implemented");
 }
 
@@ -324,8 +389,8 @@ void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
     result.addTypes(builder->getIndexType());
 }
 
-static mlir::ParseResult parseLoopOp(OpAsmParser &parser,
-                                     OperationState &result) {
+static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
+                                     mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
   OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
@@ -340,8 +405,8 @@ static mlir::ParseResult parseLoopOp(OpAsmParser &parser,
       parser.resolveOperand(ub, indexType, result.operands))
     return mlir::failure();
 
-  if (parser.parseOptionalKeyword(LoopOp::stepAttrName())) {
-    result.addAttribute(LoopOp::stepAttrName(),
+  if (parser.parseOptionalKeyword(fir::LoopOp::stepAttrName())) {
+    result.addAttribute(fir::LoopOp::stepAttrName(),
                         builder.getIntegerAttr(builder.getIndexType(), 1));
   } else if (parser.parseOperand(step) ||
              parser.resolveOperand(step, indexType, result.operands)) {
@@ -379,7 +444,67 @@ fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
   return dyn_cast_or_null<fir::LoopOp>(containingInst);
 }
 
+//===----------------------------------------------------------------------===//
+// SelectCaseOp
+//===----------------------------------------------------------------------===//
+
+static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
+                                         mlir::OperationState &result) {
+  mlir::OpAsmParser::OperandType selector;
+  mlir::Type type;
+  if (parseSelector(parser, result, selector, type))
+    return mlir::failure();
+
+  llvm::SmallVector<mlir::Attribute, 4> attrs;
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> opers;
+  llvm::SmallVector<mlir::Block *, 4> dests;
+  llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
+  while (true) {
+    mlir::Attribute attr;
+    mlir::Block *dest;
+    llvm::SmallVector<mlir::Value, 4> destArg;
+    llvm::SmallVector<mlir::NamedAttribute, 1> temp;
+    if (parser.parseAttribute(attr, "a", temp) || isValidCaseAttr(attr) ||
+        parser.parseComma())
+      return mlir::failure();
+    attrs.push_back(attr);
+    if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
+      // do nothing
+    } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+      mlir::OpAsmParser::OperandType oper1;
+      mlir::OpAsmParser::OperandType oper2;
+      if (parser.parseOperand(oper1) || parser.parseComma() ||
+          parser.parseOperand(oper2) || parser.parseComma())
+        return mlir::failure();
+      opers.push_back(oper1);
+      opers.push_back(oper2);
+    } else {
+      mlir::OpAsmParser::OperandType oper;
+      if (parser.parseOperand(oper) || parser.parseComma())
+        return mlir::failure();
+      opers.push_back(oper);
+    }
+    if (parser.parseSuccessorAndUseList(dest, destArg))
+      return mlir::failure();
+    dests.push_back(dest);
+    destArgs.push_back(destArg);
+    if (!parser.parseOptionalRSquare())
+      break;
+    if (parser.parseComma())
+      return mlir::failure();
+  }
+  result.addAttribute(fir::SelectCaseOp::AttrName,
+                      parser.getBuilder().getArrayAttr(attrs));
+  if (parser.resolveOperands(opers, type, result.operands))
+    return mlir::failure();
+  for (unsigned i = 0, count = dests.size(); i != count; ++i)
+    result.addSuccessor(dests[i], destArgs[i]);
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
 // StoreOp
+//===----------------------------------------------------------------------===//
 
 mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
   if (auto ref = refType.dyn_cast<ReferenceType>())
@@ -391,14 +516,18 @@ mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
   return {};
 }
 
+//===----------------------------------------------------------------------===//
 // StringLitOp
+//===----------------------------------------------------------------------===//
 
 bool fir::StringLitOp::isWideValue() {
   auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
   return eleTy.cast<fir::CharacterType>().getFKind() != 1;
 }
 
+//===----------------------------------------------------------------------===//
 // WhereOp
+//===----------------------------------------------------------------------===//
 
 void fir::WhereOp::build(mlir::Builder *builder, OperationState &result,
                          mlir::Value cond, bool withElseRegion) {
@@ -442,6 +571,8 @@ static mlir::ParseResult parseWhereOp(OpAsmParser &parser,
   return mlir::success();
 }
 
+//===----------------------------------------------------------------------===//
+
 mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {
   if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||
       attr.dyn_cast_or_null<ClosedIntervalAttr>() ||

From 9cf143e258069c6b8cccfabc1df97bbaa20c37e9 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Sat, 7 Mar 2020 11:49:03 -0800
Subject: [PATCH 235/345] Fix for Apple Clang 11 (constexpr error)

---
 lib/Lower/PFTBuilder.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 4554b80a5828..221cbb2c3616 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -382,7 +382,7 @@ class PFTBuilder {
   }
 
   template <typename A>
-  constexpr std::string getConstructName(const A &stmt) {
+  inline std::string getConstructName(const A &stmt) {
     if constexpr (std::is_same_v<A, parser::BlockStmt *> ||
                   std::is_same_v<A, const parser::CycleStmt *> ||
                   std::is_same_v<A, const parser::ElseStmt *> ||

From 7043fcaddcf469c31b464a357fe2ef396bb1c901 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Sat, 7 Mar 2020 13:27:05 -0800
Subject: [PATCH 236/345] fix check-flang broken by new cmake files

---
 test-lit/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index 56d7faef5265..f45b632d4dbb 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -2,7 +2,7 @@
 # for use by Lit, and delegates to LLVM's lit test handlers.
 
 # f18 modules directory
-set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/tools/f18/include)
+set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/include/flang)
 
 # f18/flang tools path for lit
 set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)

From acd4941a6d123621ef28c6b1f8c7430bcaf80dd9 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 10 Mar 2020 14:50:05 -0700
Subject: [PATCH 237/345] work on rebasing fallout MLIR restructured successor
 operands, so the new representation had to be worked into all the multiway
 branching operations and conversions.

---
 include/flang/Optimizer/Dialect/FIROps.td | 186 +++++++++---------
 lib/Optimizer/CodeGen.cpp                 | 140 +++++++-------
 lib/Optimizer/Dialect/FIROps.cpp          | 225 +++++++++++++++++++++-
 lib/Optimizer/StdConverter.cpp            |  38 ++--
 lib/Optimizer/Transforms/MemToReg.cpp     |   6 +-
 5 files changed, 404 insertions(+), 191 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index e4d2e23a27c9..ea42292abfe0 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -14,9 +14,7 @@
 #ifndef FIR_DIALECT_FIR_OPS
 #define FIR_DIALECT_FIR_OPS
 
-#ifndef OP_BASE
-include "mlir/IR/OpBase.td"
-#endif
+include "mlir/Analysis/ControlFlowInterfaces.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";
@@ -537,14 +535,23 @@ def fir_FreeMemOp : fir_Op<"freemem", []> {
   let assemblyFormat = "$heapref attr-dict `:` type($heapref)";
 }
 
-// Terminator operations
+//===----------------------------------------------------------------------===//// Terminator operations
+//===----------------------------------------------------------------------===//
 
 class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_Op<mnemonic, !listconcat(traits, [Terminator])> {
-  let arguments = (ins Variadic<AnyType>:$args);
+    fir_Op<mnemonic, !listconcat(traits, [AttrSizedOperandSegments,
+    DeclareOpInterfaceMethods<BranchOpInterface>, Terminator])> {
+
+  let arguments = (ins
+    AnyType:$selector,
+    Variadic<AnyType>:$compareArgs,
+    Variadic<AnyType>:$targetArgs
+  );
 
   let results = (outs);
 
+  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
+
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value selector,"
     "ValueRange properOperands, ArrayRef<Block *> destinations,"
@@ -554,7 +561,8 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
       result.addOperands(selector);
       result.addOperands(properOperands);
       for (auto kvp : llvm::zip(destinations, operands)) {
-        result.addSuccessor(std::get<0>(kvp), std::get<1>(kvp));
+        result.addSuccessors(std::get<0>(kvp));
+        result.addOperands(std::get<1>(kvp));
       }
       result.addAttributes(attributes);
     }]
@@ -562,34 +570,56 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
 
   string extraSwitchClassDeclaration = [{
     using Conditions = mlir::Value;
-    static constexpr auto AttrName = "cases";
+
+    static constexpr llvm::StringRef getCasesAttr() { return "case_tags"; }
 
     // The number of destination conditions that may be tested
     unsigned getNumConditions() { return getNumDest(); }
 
     // The selector is the value being tested to determine the destination
-    mlir::Value getSelector() { return getOperand(0); }
+    mlir::Value getSelector() { return selector(); }
+    mlir::Value getSelector(llvm::ArrayRef<mlir::Value> operands) {
+      return operands[0];
+    }
 
     // The number of blocks that may be branched to
     unsigned getNumDest() { return getOperation()->getNumSuccessors(); }
+
+    llvm::Optional<mlir::OperandRange> getCompareOperands(unsigned cond);
+    llvm::Optional<llvm::ArrayRef<mlir::Value>> getCompareOperands(
+        llvm::ArrayRef<mlir::Value> operands, unsigned cond);
+
+    llvm::Optional<llvm::ArrayRef<mlir::Value>> getSuccessorOperands(
+        llvm::ArrayRef<mlir::Value> operands, unsigned cond);
+
+    // Helper function to deal with Optional operand forms
+    void printSuccessorAtIndex(mlir::OpAsmPrinter &p, unsigned i) {
+      auto *succ = getSuccessor(i);
+      auto ops = getSuccessorOperands(i);
+      if (ops.hasValue())
+        p.printSuccessorAndUseList(succ, ops.getValue());
+      else
+        p.printSuccessor(succ);
+    }
   }];
 }
 
 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
+
   let parser = [{
     mlir::OpAsmParser::OperandType selector;
     mlir::Type type;
     if (parseSelector(parser, result, selector, type))
       return mlir::failure();
 
-    llvm::SmallVector<mlir::Attribute, 4> ivalues;
-    llvm::SmallVector<mlir::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
+    llvm::SmallVector<mlir::Attribute, 8> ivalues;
+    llvm::SmallVector<mlir::Block *, 8> dests;
+    llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
     while (true) {
       mlir::Attribute ivalue; // Integer or Unit
       mlir::Block *dest;
-      llvm::SmallVector<mlir::Value, 4> destArg;
+      llvm::SmallVector<mlir::Value, 8> destArg;
       llvm::SmallVector<mlir::NamedAttribute, 1> temp;
       if (parser.parseAttribute(ivalue, "i", temp) ||
           parser.parseComma() ||
@@ -603,9 +633,21 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
       if (parser.parseComma())
         return mlir::failure();
     }
-    result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(ivalues));
-    for (unsigned i = 0, count = dests.size(); i != count; ++i)
-      result.addSuccessor(dests[i], destArgs[i]);
+    auto &bld = parser.getBuilder();
+    result.addAttribute(getCasesAttr(), bld.getArrayAttr(ivalues));
+    llvm::SmallVector<int32_t, 8> argOffs;
+    int32_t sumArgs = 0;
+    const auto count = dests.size();
+    for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+      result.addSuccessors(dests[i]);
+      result.addOperands(destArgs[i]);
+      auto argSize = destArgs[i].size();
+      argOffs.push_back(argSize);
+      sumArgs += argSize;
+    }
+    result.addAttribute(getOperandSegmentSizeAttr(),
+                        bld.getI32VectorAttr({1, 0, sumArgs}));
+    result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
     return mlir::success();
   }];
 
@@ -613,8 +655,9 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
-    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
       if (i)
         p << ", ";
       auto &attr = cases[i];
@@ -623,10 +666,11 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
       else
         p.printAttribute(attr);
       p << ", ";
-      p.printSuccessorAndUseList(getOperation(), i);
+      printSuccessorAtIndex(p, i);
     }
     p << ']';
-    p.printOptionalAttrDict(getAttrs(), {AttrName});
+    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
+        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
   }];
 
   let verifier = [{
@@ -634,12 +678,11 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
           getSelector().getType().isa<mlir::IndexType>() ||
           getSelector().getType().isa<fir::IntType>()))
       return emitOpError("must be an integer");
-    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
-    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.dyn_cast_or_null<mlir::IntegerAttr>()) {
-        // ok
-      } else if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
+      if (attr.isa<mlir::IntegerAttr>() || attr.isa<mlir::UnitAttr>()) {
         // ok
       } else {
         return emitOpError("invalid case alternative");
@@ -648,8 +691,6 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
     return mlir::success();
   }];
 
-  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
-
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
@@ -720,23 +761,26 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
-    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
       if (i)
         p << ", ";
       p << cases[i] << ", ";
-      if (!cases[i].dyn_cast_or_null<mlir::UnitAttr>()) {
-        p.printOperand(getCaseArg(i, 0));
+      if (!cases[i].isa<mlir::UnitAttr>()) {
+        auto caseArgs = *getCompareOperands(i);
+        p.printOperand(*caseArgs.begin());
         p << ", ";
-        if (cases[i].dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
-          p.printOperand(getCaseArg(i, 1));
+        if (cases[i].isa<fir::ClosedIntervalAttr>()) {
+          p.printOperand(*(++caseArgs.begin()));
           p << ", ";
         }
       }
-      p.printSuccessorAndUseList(getOperation(), i);
+      printSuccessorAtIndex(p, i);
     }
     p << ']';
-    p.printOptionalAttrDict(getAttrs(), {AttrName});
+    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
+        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
   }];
 
   let verifier = [{
@@ -746,8 +790,9 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
           getSelector().getType().isa<fir::LogicalType>() ||
           getSelector().getType().isa<fir::CharacterType>()))
       return emitOpError("must be an integer, character, or logical");
-    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
-    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
       if (attr.isa<fir::PointIntervalAttr>() ||
           attr.isa<fir::LowerBoundAttr>() ||
@@ -762,18 +807,7 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     return mlir::success();
   }];
 
-  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
-
-  let extraClassDeclaration = extraSwitchClassDeclaration#[{
-    mlir::Value getCaseArg(unsigned dest, unsigned ele) {
-      assert(ele < 2);
-      assert(dest < getNumConditions());
-      auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
-      assert(cases.size() == getNumConditions());
-      unsigned o = getCaseArgumentOffset(cases, dest);
-      return getOperand(o + 1 + ele);
-    }
-  }];
+  let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
 def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
@@ -796,62 +830,34 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     ```
   }];
 
-  let parser = [{
-    mlir::OpAsmParser::OperandType selector;
-    mlir::Type type;
-    if (parseSelector(parser, result, selector, type))
-      return mlir::failure();
-
-    llvm::SmallVector<mlir::Attribute, 4> attrs;
-    llvm::SmallVector<mlir::Block *, 4> dests;
-    llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
-    while (true) {
-      mlir::Attribute attr;
-      mlir::Block *dest;
-      llvm::SmallVector<mlir::Value, 4> destArg;
-      llvm::SmallVector<mlir::NamedAttribute, 1> temp;
-      if (parser.parseAttribute(attr, "a", temp) ||
-          parser.parseComma() ||
-          parser.parseSuccessorAndUseList(dest, destArg))
-        return mlir::failure();
-      attrs.push_back(attr);
-      dests.push_back(dest);
-      destArgs.push_back(destArg);
-      if (!parser.parseOptionalRSquare())
-        break;
-      if (parser.parseComma())
-        return mlir::failure();
-    }
-    result.addAttribute(AttrName, parser.getBuilder().getArrayAttr(attrs));
-    for (unsigned i = 0, count = dests.size(); i != count; ++i)
-      result.addSuccessor(dests[i], destArgs[i]);
-    return mlir::success();
-  }];
+  let parser = "return parseSelectType(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
-    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
-    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
       if (i)
         p << ", ";
       p << cases[i] << ", ";
-      p.printSuccessorAndUseList(getOperation(), i);
+      printSuccessorAtIndex(p, i);
     }
     p << ']';
-    p.printOptionalAttrDict(getAttrs(), {AttrName});
+    p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
+        getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
   }];
 
   let verifier = [{
     if (!(getSelector().getType().isa<fir::BoxType>()))
       return emitOpError("must be a boxed type");
-    auto cases = getAttrOfType<mlir::ArrayAttr>(AttrName).getValue();
-    for (unsigned i = 0, count = getNumConditions(); i != count; ++i) {
+    auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+    auto count = getNumConditions();
+    for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.dyn_cast_or_null<fir::ExactTypeAttr>() ||
-          attr.dyn_cast_or_null<fir::SubclassAttr>() ||
-          attr.dyn_cast_or_null<mlir::UnitAttr>()) {
+      if (attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
+          attr.isa<mlir::UnitAttr>()) {
         // ok
       } else {
         return emitOpError("invalid type-case alternative");
@@ -860,8 +866,6 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     return mlir::success();
   }];
 
-  let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
-
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index f341f961ee2e..9eac996816be 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -342,7 +342,7 @@ StringMap<mlir::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
 
 /// remove `omitNames` (by name) from the attribute dictionary
 SmallVector<mlir::NamedAttribute, 4>
-pruneNamedAttrDict(ArrayRef<mlir::NamedAttribute> attrs,
+pruneNamedAttrDict(AttributeTy attrs,
                    ArrayRef<StringRef> omitNames) {
   SmallVector<mlir::NamedAttribute, 4> result;
   for (auto x : attrs) {
@@ -1294,7 +1294,7 @@ struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
     return matchSuccess();
   }
 
-  SmallVector<mlir::Value, 8> arguments(ArrayRef<mlir::Value> vec, unsigned s,
+  SmallVector<mlir::Value, 8> arguments(OperandTy vec, unsigned s,
                                         unsigned e) const {
     return {vec.begin() + s, vec.begin() + e};
   }
@@ -1476,8 +1476,7 @@ struct HasValueOpConversion : public FIROpConversion<fir::HasValueOp> {
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands, llvm::None,
-                                                op->getAttrs());
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands);
     return matchSuccess();
   }
 };
@@ -1533,16 +1532,34 @@ struct NoReassocOpConversion : public FIROpConversion<fir::NoReassocOp> {
   }
 };
 
+void genCondBrOp(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
+                 llvm::Optional<OperandTy> destOps,
+                 mlir::ConversionPatternRewriter &rewriter,
+                 mlir::Block *newBlock) {
+  if (destOps.hasValue())
+    rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, destOps.getValue(),
+                                          newBlock, mlir::ValueRange());
+  else
+    rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, newBlock);
+}
+
+template <typename A, typename B>
+void genBrOp(A caseOp, mlir::Block *dest, llvm::Optional<B> destOps,
+             mlir::ConversionPatternRewriter &rewriter) {
+  if (destOps.hasValue())
+    rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(caseOp, destOps.getValue(),
+                                                  dest);
+  else
+    rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(caseOp, llvm::None, dest);
+}
+
 void genCaseLadderStep(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
-                       OperandTy destOps,
+                       llvm::Optional<OperandTy> destOps,
                        mlir::ConversionPatternRewriter &rewriter) {
   auto *thisBlock = rewriter.getInsertionBlock();
   auto *newBlock = rewriter.createBlock(dest);
   rewriter.setInsertionPointToEnd(thisBlock);
-  SmallVector<mlir::Block *, 2> dest_{dest, newBlock};
-  SmallVector<mlir::ValueRange, 2> destOps_{destOps, {}};
-  rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp}, dest_,
-                                        destOps_);
+  genCondBrOp(loc, cmp, dest, destOps, rewriter, newBlock);
   rewriter.setInsertionPointToEnd(newBlock);
 }
 
@@ -1554,67 +1571,59 @@ struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  ArrayRef<mlir::Block *> destinations,
-                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto selectcase = mlir::cast<fir::SelectCaseOp>(op);
-    auto conds = selectcase.getNumConditions();
-    auto attrName = fir::SelectCaseOp::AttrName;
-    auto caseAttr = selectcase.getAttrOfType<mlir::ArrayAttr>(attrName);
-    auto cases = caseAttr.getValue();
+    auto caseOp = mlir::cast<fir::SelectCaseOp>(op);
+    const auto conds = caseOp.getNumConditions();
+    auto attrName = fir::SelectCaseOp::getCasesAttr();
+    auto cases = caseOp.getAttrOfType<mlir::ArrayAttr>(attrName).getValue();
     // Type can be CHARACTER, INTEGER, or LOGICAL (C1145)
-    auto ty = selectcase.getSelector().getType();
-    (void)ty;
-    auto &selector = operands[0];
-    unsigned nextOp = 1;
-    auto loc = selectcase.getLoc();
-    assert(conds > 0 && "selectcase must have cases");
-    for (unsigned t = 0; t != conds; ++t) {
+    [[maybe_unused]] auto ty = caseOp.getSelector().getType();
+    auto selector = caseOp.getSelector(operands);
+    auto loc = caseOp.getLoc();
+    assert(conds > 0 && "fir.selectcase must have cases");
+    for (std::remove_const_t<decltype(conds)> t = 0; t != conds; ++t) {
+      mlir::Block *dest = caseOp.getSuccessor(t);
+      auto destOps = caseOp.getSuccessorOperands(operands, t);
+      auto cmpOps = *caseOp.getCompareOperands(operands, t);
+      auto caseArg = *cmpOps.begin();
       auto &attr = cases[t];
-      if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
+      if (attr.isa<fir::PointIntervalAttr>()) {
         auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
-            loc, mlir::LLVM::ICmpPredicate::eq, selector, operands[nextOp++]);
-        genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+            loc, mlir::LLVM::ICmpPredicate::eq, selector, caseArg);
+        genCaseLadderStep(loc, cmp, dest, destOps, rewriter);
         continue;
       }
-      if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
+      if (attr.isa<fir::LowerBoundAttr>()) {
         auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
-            loc, mlir::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
-        genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+            loc, mlir::LLVM::ICmpPredicate::sle, caseArg, selector);
+        genCaseLadderStep(loc, cmp, dest, destOps, rewriter);
         continue;
       }
-      if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
+      if (attr.isa<fir::UpperBoundAttr>()) {
         auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
-            loc, mlir::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
-        genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+            loc, mlir::LLVM::ICmpPredicate::sle, selector, caseArg);
+        genCaseLadderStep(loc, cmp, dest, destOps, rewriter);
         continue;
       }
-      if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
+      if (attr.isa<fir::ClosedIntervalAttr>()) {
         auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
-            loc, mlir::LLVM::ICmpPredicate::sle, operands[nextOp++], selector);
+            loc, mlir::LLVM::ICmpPredicate::sle, caseArg, selector);
         auto *thisBlock = rewriter.getInsertionBlock();
-        auto *newBlock1 = rewriter.createBlock(destinations[t]);
-        auto *newBlock2 = rewriter.createBlock(destinations[t]);
+        auto *newBlock1 = rewriter.createBlock(dest);
+        auto *newBlock2 = rewriter.createBlock(dest);
         rewriter.setInsertionPointToEnd(thisBlock);
-        SmallVector<mlir::Block *, 2> dests{newBlock1, newBlock2};
-        SmallVector<mlir::ValueRange, 2> destOps{{}, {}};
-        rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp}, dests,
-                                              destOps);
+        rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, newBlock1, newBlock2);
         rewriter.setInsertionPointToEnd(newBlock1);
+        auto caseArg_ = *(cmpOps.begin() + 1);
         auto cmp_ = rewriter.create<mlir::LLVM::ICmpOp>(
-            loc, mlir::LLVM::ICmpPredicate::sle, selector, operands[nextOp++]);
-        SmallVector<mlir::Block *, 2> dest2{destinations[t], newBlock2};
-        SmallVector<mlir::ValueRange, 2> destOp2{destOperands[t], {}};
-        rewriter.create<mlir::LLVM::CondBrOp>(loc, mlir::ValueRange{cmp_},
-                                              dest2, destOp2);
+            loc, mlir::LLVM::ICmpPredicate::sle, selector, caseArg_);
+        genCondBrOp(loc, cmp_, dest, destOps, rewriter, newBlock2);
         rewriter.setInsertionPointToEnd(newBlock2);
         continue;
       }
-      assert(attr.dyn_cast_or_null<mlir::UnitAttr>());
+      assert(attr.isa<mlir::UnitAttr>());
       assert((t + 1 == conds) && "unit must be last");
-      rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(
-          selectcase, mlir::ValueRange{}, destinations[t],
-          mlir::ValueRange{destOperands[t]});
+      genBrOp(caseOp, dest, destOps, rewriter);
     }
     return matchSuccess();
   }
@@ -1623,37 +1632,35 @@ struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
 template <typename OP>
 void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering,
                            mlir::Operation *op, OperandTy operands,
-                           ArrayRef<mlir::Block *> destinations,
-                           ArrayRef<OperandTy> destOperands,
                            mlir::ConversionPatternRewriter &rewriter) {
   auto select = mlir::cast<OP>(op);
 
   // We could target the LLVM switch instruction, but it isn't part of the
   // LLVM IR dialect.  Create an if-then-else ladder instead.
   auto conds = select.getNumConditions();
-  auto attrName = OP::AttrName;
+  auto attrName = OP::getCasesAttr();
   auto caseAttr = select.template getAttrOfType<mlir::ArrayAttr>(attrName);
   auto cases = caseAttr.getValue();
   auto ty = select.getSelector().getType();
   auto ity = lowering.convertType(ty);
-  auto &selector = operands[0];
+  auto selector = select.getSelector(operands);
   auto loc = select.getLoc();
   assert(conds > 0 && "select must have cases");
-  for (unsigned t = 0, end{conds}; t != end; ++t) {
+  for (decltype(conds) t = 0; t != conds; ++t) {
+    mlir::Block *dest = select.getSuccessor(t);
+    auto destOps = select.getSuccessorOperands(operands, t);
     auto &attr = cases[t];
-    if (auto intAttr = attr.template dyn_cast_or_null<mlir::IntegerAttr>()) {
+    if (auto intAttr = attr.template dyn_cast<mlir::IntegerAttr>()) {
       auto ci = rewriter.create<mlir::LLVM::ConstantOp>(
           loc, ity, rewriter.getIntegerAttr(ty, intAttr.getInt()));
       auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
           loc, mlir::LLVM::ICmpPredicate::eq, selector, ci);
-      genCaseLadderStep(loc, cmp, destinations[t], destOperands[t], rewriter);
+      genCaseLadderStep(loc, cmp, dest, destOps, rewriter);
       continue;
     }
     assert(attr.template dyn_cast_or_null<mlir::UnitAttr>());
     assert((t + 1 == conds) && "unit must be last");
-    rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(
-        select, mlir::ValueRange{}, destinations[t],
-        mlir::ValueRange{destOperands[t]});
+    genBrOp(select, dest, destOps, rewriter);
   }
 }
 
@@ -1663,11 +1670,8 @@ struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  ArrayRef<mlir::Block *> destinations,
-                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    selectMatchAndRewrite<fir::SelectOp>(lowering, op, operands, destinations,
-                                         destOperands, rewriter);
+    selectMatchAndRewrite<fir::SelectOp>(lowering, op, operands, rewriter);
     return matchSuccess();
   }
 };
@@ -1678,11 +1682,8 @@ struct SelectRankOpConversion : public FIROpConversion<fir::SelectRankOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  ArrayRef<mlir::Block *> destinations,
-                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    selectMatchAndRewrite<fir::SelectRankOp>(
-        lowering, op, operands, destinations, destOperands, rewriter);
+    selectMatchAndRewrite<fir::SelectRankOp>(lowering, op, operands, rewriter);
     return matchSuccess();
   }
 };
@@ -1693,8 +1694,6 @@ struct SelectTypeOpConversion : public FIROpConversion<fir::SelectTypeOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  ArrayRef<mlir::Block *> destinations,
-                  ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto selecttype = mlir::cast<fir::SelectTypeOp>(op);
     TODO(selecttype);
@@ -1835,8 +1834,7 @@ struct UnreachableOpConversion : public FIROpConversion<fir::UnreachableOp> {
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto unreach = mlir::cast<fir::UnreachableOp>(op);
-    rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(
-        unreach, operands, None, None, unreach.getAttrs());
+    rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(unreach);
     return matchSuccess();
   }
 };
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index c3c1386e0f04..dc1e1ada5ffe 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -444,10 +444,91 @@ fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
   return dyn_cast_or_null<fir::LoopOp>(containingInst);
 }
 
+//===----------------------------------------------------------------------===//
+// SelectOp
+//===----------------------------------------------------------------------===//
+
+static constexpr llvm::StringRef getCompareOffsetAttr() {
+  return "compare_operand_offsets";
+}
+
+static constexpr llvm::StringRef getTargetOffsetAttr() {
+  return "target_operand_offsets";
+}
+
+template <typename A>
+static A getSubOperands(unsigned pos, A allArgs,
+                        mlir::DenseIntElementsAttr ranges) {
+  unsigned start = 0;
+  for (unsigned i = 0; i < pos; ++i)
+    start += (*(ranges.begin() + i)).getZExtValue();
+  unsigned end = start + (*(ranges.begin() + pos)).getZExtValue();
+  return {std::next(allArgs.begin(), start), std::next(allArgs.begin(), end)};
+}
+
+llvm::Optional<mlir::OperandRange> fir::SelectOp::getCompareOperands(unsigned) {
+  return {};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
+  return {};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                    unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectOp::canEraseSuccessorOperand() { return true; }
+
 //===----------------------------------------------------------------------===//
 // SelectCaseOp
 //===----------------------------------------------------------------------===//
 
+llvm::Optional<mlir::OperandRange>
+fir::SelectCaseOp::getCompareOperands(unsigned cond) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr());
+  return {getSubOperands(cond, compareArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectCaseOp::getCompareOperands(llvm::ArrayRef<mlir::Value> operands,
+                                      unsigned cond) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(cond, getSubOperands(1, operands, segments), a)};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectCaseOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectCaseOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                        unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectCaseOp::canEraseSuccessorOperand() { return true; }
+
+// parser for fir.select_case Op
 static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
                                          mlir::OperationState &result) {
   mlir::OpAsmParser::OperandType selector;
@@ -455,21 +536,23 @@ static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
   if (parseSelector(parser, result, selector, type))
     return mlir::failure();
 
-  llvm::SmallVector<mlir::Attribute, 4> attrs;
-  llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> opers;
-  llvm::SmallVector<mlir::Block *, 4> dests;
-  llvm::SmallVector<llvm::SmallVector<mlir::Value, 4>, 4> destArgs;
+  llvm::SmallVector<mlir::Attribute, 8> attrs;
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> opers;
+  llvm::SmallVector<mlir::Block *, 8> dests;
+  llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
+  llvm::SmallVector<int32_t, 8> argOffs;
+  int32_t offSize = 0;
   while (true) {
     mlir::Attribute attr;
     mlir::Block *dest;
-    llvm::SmallVector<mlir::Value, 4> destArg;
+    llvm::SmallVector<mlir::Value, 8> destArg;
     llvm::SmallVector<mlir::NamedAttribute, 1> temp;
     if (parser.parseAttribute(attr, "a", temp) || isValidCaseAttr(attr) ||
         parser.parseComma())
       return mlir::failure();
     attrs.push_back(attr);
     if (attr.dyn_cast_or_null<mlir::UnitAttr>()) {
-      // do nothing
+      argOffs.push_back(0);
     } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
       mlir::OpAsmParser::OperandType oper1;
       mlir::OpAsmParser::OperandType oper2;
@@ -478,11 +561,15 @@ static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
         return mlir::failure();
       opers.push_back(oper1);
       opers.push_back(oper2);
+      argOffs.push_back(2);
+      offSize += 2;
     } else {
       mlir::OpAsmParser::OperandType oper;
       if (parser.parseOperand(oper) || parser.parseComma())
         return mlir::failure();
       opers.push_back(oper);
+      argOffs.push_back(1);
+      ++offSize;
     }
     if (parser.parseSuccessorAndUseList(dest, destArg))
       return mlir::failure();
@@ -493,12 +580,132 @@ static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
     if (parser.parseComma())
       return mlir::failure();
   }
-  result.addAttribute(fir::SelectCaseOp::AttrName,
+  result.addAttribute(fir::SelectCaseOp::getCasesAttr(),
                       parser.getBuilder().getArrayAttr(attrs));
   if (parser.resolveOperands(opers, type, result.operands))
     return mlir::failure();
-  for (unsigned i = 0, count = dests.size(); i != count; ++i)
-    result.addSuccessor(dests[i], destArgs[i]);
+  llvm::SmallVector<int32_t, 8> targOffs;
+  int32_t toffSize = 0;
+  const auto count = dests.size();
+  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+    result.addSuccessors(dests[i]);
+    result.addOperands(destArgs[i]);
+    auto argSize = destArgs[i].size();
+    targOffs.push_back(argSize);
+    toffSize += argSize;
+  }
+  auto &bld = parser.getBuilder();
+  result.addAttribute(fir::SelectCaseOp::getOperandSegmentSizeAttr(),
+                      bld.getI32VectorAttr({1, offSize, toffSize}));
+  result.addAttribute(getCompareOffsetAttr(), bld.getI32VectorAttr(argOffs));
+  result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(targOffs));
+  return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// SelectRankOp
+//===----------------------------------------------------------------------===//
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectRankOp::getCompareOperands(unsigned) {
+  return {};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectRankOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
+  return {};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectRankOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectRankOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                        unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectRankOp::canEraseSuccessorOperand() { return true; }
+
+//===----------------------------------------------------------------------===//
+// SelectTypeOp
+//===----------------------------------------------------------------------===//
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectTypeOp::getCompareOperands(unsigned) {
+  return {};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectTypeOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
+  return {};
+}
+
+llvm::Optional<mlir::OperandRange>
+fir::SelectTypeOp::getSuccessorOperands(unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  return {getSubOperands(oper, targetArgs(), a)};
+}
+
+llvm::Optional<llvm::ArrayRef<mlir::Value>>
+fir::SelectTypeOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
+                                        unsigned oper) {
+  auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
+  auto segments =
+      getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
+  return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
+}
+
+bool fir::SelectTypeOp::canEraseSuccessorOperand() { return true; }
+
+static ParseResult parseSelectType(OpAsmParser &parser,
+                                   OperationState &result) {
+  mlir::OpAsmParser::OperandType selector;
+  mlir::Type type;
+  if (parseSelector(parser, result, selector, type))
+    return mlir::failure();
+
+  llvm::SmallVector<mlir::Attribute, 8> attrs;
+  llvm::SmallVector<mlir::Block *, 8> dests;
+  llvm::SmallVector<llvm::SmallVector<mlir::Value, 8>, 8> destArgs;
+  while (true) {
+    mlir::Attribute attr;
+    mlir::Block *dest;
+    llvm::SmallVector<mlir::Value, 8> destArg;
+    llvm::SmallVector<mlir::NamedAttribute, 1> temp;
+    if (parser.parseAttribute(attr, "a", temp) || parser.parseComma() ||
+        parser.parseSuccessorAndUseList(dest, destArg))
+      return mlir::failure();
+    attrs.push_back(attr);
+    dests.push_back(dest);
+    destArgs.push_back(destArg);
+    if (!parser.parseOptionalRSquare())
+      break;
+    if (parser.parseComma())
+      return mlir::failure();
+  }
+  auto &bld = parser.getBuilder();
+  result.addAttribute(fir::SelectTypeOp::getCasesAttr(),
+                      bld.getArrayAttr(attrs));
+  llvm::SmallVector<int32_t, 8> argOffs;
+  int32_t offSize = 0;
+  const auto count = dests.size();
+  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+    result.addSuccessors(dests[i]);
+    result.addOperands(destArgs[i]);
+    auto argSize = destArgs[i].size();
+    argOffs.push_back(argSize);
+    offSize += argSize;
+  }
+  result.addAttribute(fir::SelectTypeOp::getOperandSegmentSizeAttr(),
+                      bld.getI32VectorAttr({1, 0, offSize}));
+  result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
   return mlir::success();
 }
 
diff --git a/lib/Optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
index 58687bd683aa..eda3ccecaf00 100644
--- a/lib/Optimizer/StdConverter.cpp
+++ b/lib/Optimizer/StdConverter.cpp
@@ -107,41 +107,42 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
-                  llvm::ArrayRef<mlir::Block *> destinations,
-                  llvm::ArrayRef<OperandTy> destOperands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto selectType = mlir::cast<SelectTypeOp>(op);
     auto conds = selectType.getNumConditions();
-    auto attrName = SelectTypeOp::AttrName;
+    auto attrName = SelectTypeOp::getCasesAttr();
     auto caseAttr = selectType.getAttrOfType<mlir::ArrayAttr>(attrName);
     auto cases = caseAttr.getValue();
     // Selector must be of type !fir.box<T>
-    auto &selector = operands[0];
+    auto selector = selectType.getSelector(operands);
     auto loc = selectType.getLoc();
     auto mod = op->getParentOfType<mlir::ModuleOp>();
-    for (unsigned t = 0; t != conds; ++t) {
+    for (decltype(conds) t = 0; t != conds; ++t) {
+      auto *dest = selectType.getSuccessor(t);
+      auto destOps = selectType.getSuccessorOperands(operands, t);
       auto &attr = cases[t];
-      if (auto a = attr.dyn_cast_or_null<ExactTypeAttr>()) {
-        genTypeLadderStep(loc, true, selector, a.getType(), destinations[t],
-                          destOperands[t], mod, rewriter);
+      if (auto a = attr.dyn_cast<ExactTypeAttr>()) {
+        genTypeLadderStep(loc, /*exactTest=*/true, selector, a.getType(), dest,
+                          destOps, mod, rewriter);
         continue;
       }
-      if (auto a = attr.dyn_cast_or_null<SubclassAttr>()) {
-        genTypeLadderStep(loc, false, selector, a.getType(), destinations[t],
-                          destOperands[t], mod, rewriter);
+      if (auto a = attr.dyn_cast<SubclassAttr>()) {
+        genTypeLadderStep(loc, /*exactTest=*/false, selector, a.getType(), dest,
+                          destOps, mod, rewriter);
         continue;
       }
-      assert(attr.dyn_cast_or_null<mlir::UnitAttr>());
+      assert(attr.isa<mlir::UnitAttr>());
       assert((t + 1 == conds) && "unit must be last");
       rewriter.replaceOpWithNewOp<mlir::BranchOp>(
-          selectType, destinations[t], mlir::ValueRange{destOperands[t]});
+          selectType, dest, mlir::ValueRange{destOps.getValue()});
     }
     return matchSuccess();
   }
 
   static void genTypeLadderStep(mlir::Location loc, bool exactTest,
                                 mlir::Value selector, mlir::Type ty,
-                                mlir::Block *dest, OperandTy destOps,
+                                mlir::Block *dest,
+                                llvm::Optional<OperandTy> destOps,
                                 mlir::ModuleOp module,
                                 mlir::ConversionPatternRewriter &rewriter) {
     mlir::Type tydesc = TypeDescType::get(ty);
@@ -167,8 +168,13 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
     auto *thisBlock = rewriter.getInsertionBlock();
     auto *newBlock = rewriter.createBlock(dest);
     rewriter.setInsertionPointToEnd(thisBlock);
-    rewriter.create<mlir::CondBranchOp>(loc, cmp.getResult(0), dest, destOps,
-                                        newBlock, OperandTy{});
+    if (destOps.hasValue())
+      rewriter.create<mlir::CondBranchOp>(loc, cmp.getResult(0), dest,
+                                          destOps.getValue(), newBlock,
+                                          llvm::None);
+    else
+      rewriter.create<mlir::CondBranchOp>(loc, cmp.getResult(0), dest,
+                                          newBlock);
     rewriter.setInsertionPointToEnd(newBlock);
   }
 };
diff --git a/lib/Optimizer/Transforms/MemToReg.cpp b/lib/Optimizer/Transforms/MemToReg.cpp
index 99935b70a2b6..a9c0c78d6f14 100644
--- a/lib/Optimizer/Transforms/MemToReg.cpp
+++ b/lib/Optimizer/Transforms/MemToReg.cpp
@@ -464,8 +464,7 @@ struct MemToReg
                        cond.getTrueOperands());
           auto c = cond.getCondition();
           auto *othDest = cond.getFalseDest();
-          std::vector<mlir::Value> othOpers(cond.false_operand_begin(),
-                                            cond.false_operand_end());
+          auto othOpers = cond.falseDestOperands();
           builder->create<mlir::CondBranchOp>(cond.getLoc(), c, dest, opers,
                                               othDest, othOpers);
           cond.erase();
@@ -484,8 +483,7 @@ struct MemToReg
                        cond.getFalseOperands());
           auto c = cond.getCondition();
           auto *othDest = cond.getTrueDest();
-          std::vector<mlir::Value> othOpers(cond.true_operand_begin(),
-                                            cond.true_operand_end());
+          auto othOpers = cond.trueDestOperands();
           builder->create<mlir::CondBranchOp>(cond.getLoc(), c, othDest,
                                               othOpers, dest, opers);
           cond.erase();

From c13d859b17afdeb8f1902de20c77fdad9f2c34ec Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 10 Mar 2020 15:09:09 -0700
Subject: [PATCH 238/345] rebase fallout

---
 include/flang/Optimizer/Dialect/FIROps.td | 2 +-
 lib/Optimizer/Dialect/FIRDialect.cpp      | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index ea42292abfe0..5f4d9fe7f239 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -14,7 +14,7 @@
 #ifndef FIR_DIALECT_FIR_OPS
 #define FIR_DIALECT_FIR_OPS
 
-include "mlir/Analysis/ControlFlowInterfaces.td"
+include "mlir/Interfaces/ControlFlowInterfaces.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
index ae4811f9f3c6..b6dd9edb2a2f 100644
--- a/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -12,7 +12,6 @@
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/StandardTypes.h"
-#include "mlir/Transforms/SideEffectsInterface.h"
 
 using namespace fir;
 

From 538a0161a73fb4ae1b04d3f1c230d404e3d5c6cf Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 11 Mar 2020 17:57:57 -0700
Subject: [PATCH 239/345] add builders for new select internal structures

---
 include/flang/Optimizer/Dialect/FIROps.td | 204 +++++++++++++++++-----
 lib/Optimizer/Dialect/FIROps.cpp          |  32 ++++
 2 files changed, 196 insertions(+), 40 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 5f4d9fe7f239..11500c5b3514 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -552,29 +552,15 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
 
   let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
 
-  let builders = [OpBuilder<
-    "Builder *, OperationState &result, Value selector,"
-    "ValueRange properOperands, ArrayRef<Block *> destinations,"
-    "ArrayRef<ValueRange> operands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}",
-    [{
-      result.addOperands(selector);
-      result.addOperands(properOperands);
-      for (auto kvp : llvm::zip(destinations, operands)) {
-        result.addSuccessors(std::get<0>(kvp));
-        result.addOperands(std::get<1>(kvp));
-      }
-      result.addAttributes(attributes);
-    }]
-  >];
-
   string extraSwitchClassDeclaration = [{
     using Conditions = mlir::Value;
 
     static constexpr llvm::StringRef getCasesAttr() { return "case_tags"; }
 
     // The number of destination conditions that may be tested
-    unsigned getNumConditions() { return getNumDest(); }
+    unsigned getNumConditions() {
+      return getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).size();
+    }
 
     // The selector is the value being tested to determine the destination
     mlir::Value getSelector() { return selector(); }
@@ -607,6 +593,43 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
 
+  let skipDefaultBuilders = 1;
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<int64_t> compareOperands, ArrayRef<Block *> destinations,"
+    "ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}",
+    [{
+      result.addOperands(selector);
+      llvm::SmallVector<mlir::Attribute, 8> ivalues;
+      for (auto iv : compareOperands)
+        ivalues.push_back(builder->getI64IntegerAttr(iv));
+      ivalues.push_back(builder->getUnitAttr());
+      result.addAttribute(getCasesAttr(), builder->getArrayAttr(ivalues));
+      const auto count = destinations.size();
+      for (auto d : destinations)
+        result.addSuccessors(d);
+      const auto opCount = destOperands.size();
+      llvm::SmallVector<int32_t, 8> argOffs;
+      int32_t sumArgs = 0;
+      for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+        if (i < opCount) {
+          result.addOperands(destOperands[i]);
+          const auto argSz = destOperands[i].size();
+          argOffs.push_back(argSz);
+          sumArgs += argSz;
+        } else {
+          argOffs.push_back(0);
+        }
+      }
+      result.addAttribute(getOperandSegmentSizeAttr(),
+                          builder->getI32VectorAttr({1, 0, sumArgs}));
+      result.addAttribute(getTargetOffsetAttr(),
+                          builder->getI32VectorAttr(argOffs));
+      result.addAttributes(attributes);
+    }]
+  >];
+
   let parser = [{
     mlir::OpAsmParser::OperandType selector;
     mlir::Type type;
@@ -679,19 +702,24 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
           getSelector().getType().isa<fir::IntType>()))
       return emitOpError("must be an integer");
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
+    auto count = getNumDest();
+    if (count == 0)
+      return emitOpError("must have at least one successor");
+    if (getNumConditions() != count)
+      return emitOpError("number of cases and targets don't match");
+    if (targetOffsetSize() != count)
+      return emitOpError("incorrect number of successor operand groups");
     for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.isa<mlir::IntegerAttr>() || attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
+      if (!(attr.isa<mlir::IntegerAttr>() || attr.isa<mlir::UnitAttr>()))
         return emitOpError("invalid case alternative");
-      }
     }
     return mlir::success();
   }];
 
-  let extraClassDeclaration = extraSwitchClassDeclaration;
+  let extraClassDeclaration = extraSwitchClassDeclaration#[{
+    unsigned targetOffsetSize();
+  }];
 }
 
 def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
@@ -755,6 +783,56 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
     ```
   }];
 
+  let skipDefaultBuilders = 1;
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<mlir::Attribute> compareAttrs, ArrayRef<ValueRange> cmpOperands,"
+    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}",
+    [{
+      result.addOperands(selector);
+      result.addAttribute(getCasesAttr(), builder->getArrayAttr(compareAttrs));
+      llvm::SmallVector<int32_t, 8> operOffs;
+      int32_t operSize = 0;
+      for (auto attr : compareAttrs) {
+        if (attr.isa<fir::ClosedIntervalAttr>()) {
+          operOffs.push_back(2);
+          operSize += 2;
+        } else if (attr.isa<mlir::UnitAttr>()) {
+          operOffs.push_back(0);
+        } else {
+          operOffs.push_back(1);
+          ++operSize;
+        }
+      }
+      for (auto ops : cmpOperands)
+        result.addOperands(ops);
+      result.addAttribute(getCompareOffsetAttr(),
+                          builder->getI32VectorAttr(operOffs));
+      const auto count = destinations.size();
+      for (auto d : destinations)
+        result.addSuccessors(d);
+      const auto opCount = destOperands.size();
+      llvm::SmallVector<int32_t, 8> argOffs;
+      int32_t sumArgs = 0;
+      for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+        if (i < opCount) {
+          result.addOperands(destOperands[i]);
+          const auto argSz = destOperands[i].size();
+          argOffs.push_back(argSz);
+          sumArgs += argSz;
+        } else {
+          argOffs.push_back(0);
+        }
+      }
+      result.addAttribute(getOperandSegmentSizeAttr(),
+                          builder->getI32VectorAttr({1, operSize, sumArgs}));
+      result.addAttribute(getTargetOffsetAttr(),
+                          builder->getI32VectorAttr(argOffs));
+      result.addAttributes(attributes);
+    }]
+  >];
+
   let parser = "return parseSelectCase(parser, result);";
 
   let printer = [{
@@ -791,23 +869,31 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
           getSelector().getType().isa<fir::CharacterType>()))
       return emitOpError("must be an integer, character, or logical");
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
+    auto count = getNumDest();
+    if (count == 0)
+      return emitOpError("must have at least one successor");
+    if (getNumConditions() != count)
+      return emitOpError("number of conditions and successors don't match");
+    if (compareOffsetSize() != count)
+      return emitOpError("incorrect number of compare operand groups");
+    if (targetOffsetSize() != count)
+      return emitOpError("incorrect number of successor operand groups");
     for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.isa<fir::PointIntervalAttr>() ||
-          attr.isa<fir::LowerBoundAttr>() ||
-          attr.isa<fir::UpperBoundAttr>() ||
-          attr.isa<fir::ClosedIntervalAttr>() ||
-          attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
+      if (!(attr.isa<fir::PointIntervalAttr>() ||
+            attr.isa<fir::LowerBoundAttr>() ||
+            attr.isa<fir::UpperBoundAttr>() ||
+            attr.isa<fir::ClosedIntervalAttr>() ||
+            attr.isa<mlir::UnitAttr>()))
         return emitOpError("incorrect select case attribute type");
-      }
     }
     return mlir::success();
   }];
 
-  let extraClassDeclaration = extraSwitchClassDeclaration;
+  let extraClassDeclaration = extraSwitchClassDeclaration#[{
+    unsigned targetOffsetSize();
+    unsigned compareOffsetSize();
+  }];
 }
 
 def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
@@ -830,6 +916,39 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     ```
   }];
 
+  let skipDefaultBuilders = 1;
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<mlir::Attribute> typeOperands,"
+    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}",
+    [{
+      result.addOperands(selector);
+      result.addAttribute(getCasesAttr(), builder->getArrayAttr(typeOperands));
+      const auto count = destinations.size();
+      for (auto d : destinations)
+        result.addSuccessors(d);
+      const auto opCount = destOperands.size();
+      llvm::SmallVector<int32_t, 8> argOffs;
+      int32_t sumArgs = 0;
+      for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+        if (i < opCount) {
+          result.addOperands(destOperands[i]);
+          const auto argSz = destOperands[i].size();
+          argOffs.push_back(argSz);
+          sumArgs += argSz;
+        } else {
+          argOffs.push_back(0);
+        }
+      }
+      result.addAttribute(getOperandSegmentSizeAttr(),
+                          builder->getI32VectorAttr({1, 0, sumArgs}));
+      result.addAttribute(getTargetOffsetAttr(),
+                          builder->getI32VectorAttr(argOffs));
+      result.addAttributes(attributes);
+    }]
+  >];
+
   let parser = "return parseSelectType(parser, result);";
 
   let printer = [{
@@ -853,20 +972,25 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     if (!(getSelector().getType().isa<fir::BoxType>()))
       return emitOpError("must be a boxed type");
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
+    auto count = getNumDest();
+    if (count == 0)
+      return emitOpError("must have at least one successor");
+    if (getNumConditions() != count)
+      return emitOpError("number of conditions and successors don't match");
+    if (targetOffsetSize() != count)
+      return emitOpError("incorrect number of successor operand groups");
     for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
-          attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
+      if (!(attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
+            attr.isa<mlir::UnitAttr>()))
         return emitOpError("invalid type-case alternative");
-      }
     }
     return mlir::success();
   }];
 
-  let extraClassDeclaration = extraSwitchClassDeclaration;
+  let extraClassDeclaration = extraSwitchClassDeclaration#[{
+    unsigned targetOffsetSize();
+  }];
 }
 
 def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index dc1e1ada5ffe..c1e6d7495dd7 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -466,6 +466,13 @@ static A getSubOperands(unsigned pos, A allArgs,
   return {std::next(allArgs.begin(), start), std::next(allArgs.begin(), end)};
 }
 
+static unsigned denseElementsSize(mlir::DenseIntElementsAttr attr) {
+  unsigned count = 0;
+  for (auto x : attr)
+    ++count;
+  return count;
+}
+
 llvm::Optional<mlir::OperandRange> fir::SelectOp::getCompareOperands(unsigned) {
   return {};
 }
@@ -492,6 +499,11 @@ fir::SelectOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
 
 bool fir::SelectOp::canEraseSuccessorOperand() { return true; }
 
+unsigned fir::SelectOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
 //===----------------------------------------------------------------------===//
 // SelectCaseOp
 //===----------------------------------------------------------------------===//
@@ -602,6 +614,16 @@ static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
   return mlir::success();
 }
 
+unsigned fir::SelectCaseOp::compareOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr()));
+}
+
+unsigned fir::SelectCaseOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
 //===----------------------------------------------------------------------===//
 // SelectRankOp
 //===----------------------------------------------------------------------===//
@@ -633,6 +655,11 @@ fir::SelectRankOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
 
 bool fir::SelectRankOp::canEraseSuccessorOperand() { return true; }
 
+unsigned fir::SelectRankOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
 //===----------------------------------------------------------------------===//
 // SelectTypeOp
 //===----------------------------------------------------------------------===//
@@ -709,6 +736,11 @@ static ParseResult parseSelectType(OpAsmParser &parser,
   return mlir::success();
 }
 
+unsigned fir::SelectTypeOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//

From aaed28860099806c8d8a7c316f441293ede7c158 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 12 Mar 2020 12:19:46 -0700
Subject: [PATCH 240/345] fix typos in documentation

---
 include/flang/Optimizer/Dialect/FIROps.td | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 11500c5b3514..91b197d8d1b9 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2581,8 +2581,8 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
         %z = constant 0 : index
         %o = constant 1 : index
         %4 = fir.insert_value %3, %1, %z : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
-        %5 = fir.insert_value %4, %1, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
-        return %5
+        %5 = fir.insert_value %4, %2, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
+        fir.has_value %5
       }
     ```
   }];

From 3356557987159f396a77f91a0d60fbc7aed35639 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Fri, 13 Mar 2020 09:53:54 -0700
Subject: [PATCH 241/345] Deal with evolving effects

---
 include/flang/Optimizer/Dialect/FIROps.td | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 91b197d8d1b9..9543e58a97dd 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -15,6 +15,7 @@
 #define FIR_DIALECT_FIR_OPS
 
 include "mlir/Interfaces/ControlFlowInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";

From b78fbf4f06cff7aeab51eed93608d0f687cf31c5 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 11 Mar 2020 16:21:29 -0700
Subject: [PATCH 242/345] Rework the fir.loop operation. Remove the return
 value and extend the syntax to support constant iteration spaces. Fuse some
 of the ad hoc Op builders into a FirOpBuilder and thread it through the
 bridge.

---
 include/flang/Lower/Bridge.h              |   6 +-
 include/flang/Lower/ConvertExpr.h         |   9 +-
 include/flang/Lower/FIRBuilder.h          | 292 +++++++++++++++
 include/flang/Lower/Intrinsics.h          |  14 +-
 include/flang/Lower/OpBuilder.h           | 216 -----------
 include/flang/Lower/Runtime.h             |  47 ++-
 include/flang/Optimizer/Dialect/FIROps.td | 111 +++---
 include/flang/Optimizer/Dialect/FIRType.h |   4 +
 lib/Lower/Bridge.cpp                      | 436 +++++++++++-----------
 lib/Lower/CMakeLists.txt                  |   2 +-
 lib/Lower/ConvertExpr.cpp                 |  65 +---
 lib/Lower/FIRBuilder.cpp                  | 268 +++++++++++++
 lib/Lower/IO.cpp                          |  33 +-
 lib/Lower/Intrinsics.cpp                  | 106 +++---
 lib/Lower/OpBuilder.cpp                   | 276 --------------
 lib/Lower/Runtime.cpp                     |  56 +--
 lib/Optimizer/Dialect/FIRDialect.cpp      |   2 +-
 lib/Optimizer/Dialect/FIROps.cpp          | 108 ++++--
 lib/Optimizer/Dialect/FIRType.cpp         |   9 +-
 lib/Optimizer/Support/InternalNames.cpp   |  85 ++---
 lib/Optimizer/Transforms/RewriteLoop.cpp  |  43 +--
 test-lit/Fir/fir-ops.fir                  |   2 +-
 test-lit/Fir/loop10.fir                   |   6 +-
 23 files changed, 1164 insertions(+), 1032 deletions(-)
 create mode 100644 include/flang/Lower/FIRBuilder.h
 delete mode 100644 include/flang/Lower/OpBuilder.h
 create mode 100644 lib/Lower/FIRBuilder.cpp
 delete mode 100644 lib/Lower/OpBuilder.cpp

diff --git a/include/flang/Lower/Bridge.h b/include/flang/Lower/Bridge.h
index d6514eceb83e..e62eb465950a 100644
--- a/include/flang/Lower/Bridge.h
+++ b/include/flang/Lower/Bridge.h
@@ -59,9 +59,11 @@ namespace Fortran::lower {
 
 using SomeExpr = evaluate::Expr<evaluate::SomeType>;
 using SymbolRef = common::Reference<const semantics::Symbol>;
+class FirOpBuilder;
 
 /// The abstract interface for converter implementations to lower Fortran
-/// front-end fragments such as expressions, types, etc.
+/// front-end fragments such as expressions, types, etc. to the FIR dialect of
+/// MLIR.
 class AbstractConverter {
 public:
   //
@@ -109,7 +111,7 @@ class AbstractConverter {
   // FIR/MLIR
 
   /// Get the OpBuilder
-  virtual mlir::OpBuilder &getOpBuilder() = 0;
+  virtual Fortran::lower::FirOpBuilder &getFirOpBuilder() = 0;
   /// Get the ModuleOp
   virtual mlir::ModuleOp &getModuleOp() = 0;
   /// Unique a symbol
diff --git a/include/flang/Lower/ConvertExpr.h b/include/flang/Lower/ConvertExpr.h
index 7132ff76cebd..3c7676a3956c 100644
--- a/include/flang/Lower/ConvertExpr.h
+++ b/include/flang/Lower/ConvertExpr.h
@@ -42,6 +42,7 @@ class Symbol;
 namespace lower {
 
 class AbstractConverter;
+class FirOpBuilder;
 class SymMap;
 
 /// Create an expression.
@@ -66,14 +67,6 @@ mlir::Value createSomeAddress(mlir::Location loc, AbstractConverter &converter,
                               SymMap &symMap,
                               const IntrinsicLibrary &intrinsics);
 
-/// Create a temporary. A temp is allocated using `fir.alloca` and can be read
-/// and written using `fir.load` and `fir.store`, resp.  The temporary can be
-/// given a name via a front-end `Symbol` or a `StringRef`.
-mlir::Value createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
-                            SymMap &symMap, mlir::Type type,
-                            const semantics::Symbol *symbol = nullptr,
-                            llvm::StringRef name = {});
-
 } // namespace lower
 } // namespace Fortran
 
diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
new file mode 100644
index 000000000000..4924212e1b2b
--- /dev/null
+++ b/include/flang/Lower/FIRBuilder.h
@@ -0,0 +1,292 @@
+//===-- Lower/FirBuilder.h -- FIR operation builder -------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Builder routines for constructing the FIR dialect of MLIR. As FIR is a
+// dialect of MLIR, it makes extensive use of MLIR interfaces and MLIR's coding
+// style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
+// module.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_FIRBUILDER_H
+#define FORTRAN_LOWER_FIRBUILDER_H
+
+#include "flang/Common/reference.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Function.h"
+#include "mlir/IR/Module.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+
+namespace fir {
+class ExtractValueOp;
+class InsertValueOp;
+} // namespace fir
+
+namespace Fortran {
+namespace semantics {
+class Symbol;
+using SymbolRef = common::Reference<const Symbol>;
+} // namespace semantics
+
+namespace lower {
+
+class AbstractConverter;
+
+/// Helper class to map front-end symbols to their MLIR representation. This
+/// provides a way to lookup the fir.alloca location of a variable, for example.
+class SymMap {
+public:
+  /// Add `symbol` to the current map and  bind to `value`.
+  void addSymbol(semantics::SymbolRef symbol, mlir::Value value);
+
+  /// Find `symbol` and return its value if it appears in the current mappings.
+  mlir::Value lookupSymbol(semantics::SymbolRef symbol);
+
+  void clear() { symbolMap.clear(); }
+
+private:
+  llvm::DenseMap<const semantics::Symbol *, mlir::Value> symbolMap;
+};
+
+/// Pair of ssa-values that compose a CHARACTER value. The buffer that holds the
+/// data and the LEN type parameter.
+struct CharValue {
+  mlir::Value buffer;
+  mlir::Value len;
+};
+
+// TODO: Used CRTP to extend the FirOpBuilder interface, but this leads to some
+// complex and downright ugly template code.
+
+/// Extension class to facilitate lowering of CHARACTER operation
+template <typename T>
+class CharacterOpsBuilder {
+public:
+  fir::ReferenceType getReferenceType(const CharValue &pair);
+  fir::CharacterType getCharacterType(const CharValue &pair);
+
+  // access the implementation
+  T &impl() { return *static_cast<T *>(this); }
+
+  /// Copy the \p count first characters of \p src into \p dest.
+  void createCopy(CharValue &dest, const CharValue &src, mlir::Value count);
+
+  /// Set characters of \p str at position [\p lower, \p upper) to blanks.
+  /// \p lower and \upper bounds are zero based.
+  /// If \p upper <= \p lower, no padding is done.
+  void createPadding(CharValue &str, mlir::Value lower, mlir::Value upper);
+
+  /// Allocate storage (on the stack) for character given the kind and length.
+  CharValue createCharacterTemp(fir::CharacterType type, mlir::Value len);
+
+protected:
+  mlir::Value createBlankConstant(fir::CharacterType type);
+};
+
+/// Extension class to facilitate lowering of COMPLEX manipulations in FIR.
+template <typename T>
+class ComplexOpsBuilder {
+public:
+  // The values of part enum members are meaningful for
+  // InsertValueOp and ExtractValueOp so they are explicit.
+  enum class Part { Real = 0, Imag = 1 };
+
+  // access the implementation
+  T &impl() { return *static_cast<T *>(this); }
+
+  // Type helper. They do not create MLIR operations.
+  mlir::Type getComplexPartType(mlir::Value cplx);
+  mlir::Type getComplexPartType(mlir::Type complexType);
+  mlir::Type getComplexPartType(fir::KindTy complexKind);
+
+  // Complex operation creation helper. They create MLIR operations.
+  mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
+                            mlir::Value imag);
+  mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart) {
+    return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
+  }
+  mlir::Value insertComplexPart(mlir::Value cplx, mlir::Value part,
+                                bool isImagPart) {
+    return isImagPart ? insert<Part::Imag>(cplx, part)
+                      : insert<Part::Real>(cplx, part);
+  }
+
+  mlir::Value createComplexCompare(mlir::Value cplx1, mlir::Value cplx2,
+                                   bool eq);
+
+protected:
+  template <Part partId>
+  mlir::Value extract(mlir::Value cplx) {
+    return impl().template createHere<fir::ExtractValueOp>(
+        getComplexPartType(cplx), cplx, createPartId<partId>());
+  }
+
+  template <Part partId>
+  mlir::Value insert(mlir::Value cplx, mlir::Value part) {
+    return impl().template createHere<fir::InsertValueOp>(
+        cplx.getType(), cplx, part, createPartId<partId>());
+  }
+
+  template <Part partId>
+  mlir::Value createPartId() {
+    return impl().createIntegerConstant(impl().getIntegerType(32),
+                                        static_cast<int>(partId));
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// FirOpBuilder
+//===----------------------------------------------------------------------===//
+
+/// Extends the MLIR OpBuilder to provide methods for building common FIR
+/// patterns.
+class FirOpBuilder : public mlir::OpBuilder,
+                     public CharacterOpsBuilder<FirOpBuilder>,
+                     public ComplexOpsBuilder<FirOpBuilder> {
+public:
+  using OpBuilder::OpBuilder;
+
+  /// TODO: remove this as caching the location may have the location
+  /// unexpectedly overridden along the way.
+  /// Set the current location. Used by createHere template method, etc.
+  void setLocation(mlir::Location loc) { currentLoc = loc; }
+
+  /// Get the current location (if any) or return unknown location.
+  mlir::Location getLoc() {
+    return currentLoc.hasValue() ? currentLoc.getValue() : getUnknownLoc();
+  }
+
+  template <typename OP, typename... AS>
+  auto createHere(AS... args) {
+    return create<OP>(getLoc(), std::forward<AS>(args)...);
+  }
+
+  mlir::Region &getRegion() { return *getBlock()->getParent(); }
+
+  /// Get the current Module
+  mlir::ModuleOp getModule() {
+    return getRegion().getParentOfType<mlir::ModuleOp>();
+  }
+
+  /// Get the current Function
+  mlir::FuncOp getFunction() {
+    return getRegion().getParentOfType<mlir::FuncOp>();
+  }
+
+  /// Get the entry block of the current Function
+  mlir::Block *getEntryBlock() { return &getFunction().front(); }
+
+  /// Create an integer constant of type \p type and value \p i.
+  mlir::Value createIntegerConstant(mlir::Type integerType, std::int64_t i);
+
+  /// Create a temporary. A temp is allocated using `fir.alloca` and can be read
+  /// and written using `fir.load` and `fir.store`, resp.  The temporary can be
+  /// given a name via a front-end `Symbol` or a `StringRef`.
+  mlir::Value createTemporary(mlir::Location loc, SymMap &symMap,
+                              mlir::Type type,
+                              llvm::ArrayRef<mlir::Value> shape = {},
+                              const Fortran::semantics::Symbol *symbol = {},
+                              llvm::StringRef name = {});
+
+  mlir::Value createTemporary(SymMap &symMap, mlir::Type type,
+                              llvm::ArrayRef<mlir::Value> shape = {},
+                              const Fortran::semantics::Symbol *symbol = {},
+                              llvm::StringRef name = {}) {
+    return createTemporary(getLoc(), symMap, type, shape, symbol, name);
+  }
+
+  /// Create an unnamed and untracked temporary on the stack.
+  mlir::Value createTemporary(mlir::Type type,
+                              llvm::ArrayRef<mlir::Value> shape) {
+    SymMap fakeMap;
+    return createTemporary(getLoc(), fakeMap, type, shape);
+  }
+
+  mlir::Block *createBlock() {
+    return OpBuilder::createBlock(getBlock()->getParent());
+  }
+
+  /// Get a function by name. If the function exists in the current module, it
+  /// is returned. Otherwise, a null FuncOp is returned.
+  mlir::FuncOp getNamedFunction(llvm::StringRef name) {
+    return getNamedFunction(getModule(), name);
+  }
+
+  static mlir::FuncOp getNamedFunction(mlir::ModuleOp module,
+                                       llvm::StringRef name);
+
+  /// Create a new FuncOp. If the function may have already been created, use
+  /// `addNamedFunction` instead.
+  mlir::FuncOp createFunction(mlir::Location loc, llvm::StringRef name,
+                              mlir::FunctionType ty) {
+    return createFunction(loc, getModule(), name, ty);
+  }
+
+  mlir::FuncOp createFunction(llvm::StringRef name, mlir::FunctionType ty) {
+    return createFunction(getLoc(), name, ty);
+  }
+
+  static mlir::FuncOp createFunction(mlir::Location loc, mlir::ModuleOp module,
+                                     llvm::StringRef name,
+                                     mlir::FunctionType ty);
+
+  /// Determine if the named function is already in the module. Return the
+  /// instance if found, otherwise add a new named function to the module.
+  mlir::FuncOp addNamedFunction(mlir::Location loc, llvm::StringRef name,
+                                mlir::FunctionType ty) {
+    if (auto func = getNamedFunction(name))
+      return func;
+    return createFunction(loc, name, ty);
+  }
+
+  mlir::FuncOp addNamedFunction(llvm::StringRef name, mlir::FunctionType ty) {
+    if (auto func = getNamedFunction(name))
+      return func;
+    return createFunction(name, ty);
+  }
+
+  static mlir::FuncOp addNamedFunction(mlir::Location loc,
+                                       mlir::ModuleOp module,
+                                       llvm::StringRef name,
+                                       mlir::FunctionType ty) {
+    if (auto func = getNamedFunction(module, name))
+      return func;
+    return createFunction(loc, module, name, ty);
+  }
+
+  //===--------------------------------------------------------------------===//
+  // LoopOp helpers
+  //===--------------------------------------------------------------------===//
+
+  using BodyGenerator = std::function<void(FirOpBuilder &, mlir::Value)>;
+
+  /// Build loop [\p lb, \p ub) with step \p step.
+  /// If \p step is an empty value, 1 is used for the step.
+  void createLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
+                  const BodyGenerator &bodyGenerator);
+
+  /// Build loop [\p lb,  \p ub) with step 1.
+  void createLoop(mlir::Value lb, mlir::Value ub,
+                  const BodyGenerator &bodyGenerator);
+
+  /// Build loop [0, \p count) with step 1.
+  void createLoop(mlir::Value count, const BodyGenerator &bodyGenerator);
+
+  /// Cast the input value to IndexType.
+  mlir::Value convertToIndexType(mlir::Value integer);
+
+private:
+  llvm::Optional<mlir::Location> currentLoc{};
+};
+
+} // namespace lower
+} // namespace Fortran
+
+#endif // FORTRAN_LOWER_FIRBUILDER_H
diff --git a/include/flang/Lower/Intrinsics.h b/include/flang/Lower/Intrinsics.h
index 8741c2102969..fe9687d59db7 100644
--- a/include/flang/Lower/Intrinsics.h
+++ b/include/flang/Lower/Intrinsics.h
@@ -5,6 +5,13 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+//
+// Builder routines for constructing the FIR dialect of MLIR. As FIR is a
+// dialect of MLIR, it makes extensive use of MLIR interfaces and MLIR's coding
+// style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
+// module.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_INTRINSICS_H_
 #define FORTRAN_LOWER_INTRINSICS_H_
@@ -12,12 +19,11 @@
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
-#include <optional>
-
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
 
 namespace Fortran::lower {
 
+class FirOpBuilder;
+
 /// IntrinsicLibrary generates FIR+MLIR operations that implement Fortran
 /// generic intrinsic function calls. It operates purely on FIR+MLIR types so
 /// that it can be used at different lowering level if needed.
@@ -45,7 +51,7 @@ class IntrinsicLibrary {
   /// Generate the FIR+MLIR operations for the generic intrinsic "name".
   /// On failure, returns a nullptr, else the returned mlir::Value is
   /// the returned Fortran intrinsic value.
-  mlir::Value genval(mlir::Location loc, mlir::OpBuilder &builder,
+  mlir::Value genval(mlir::Location loc, Fortran::lower::FirOpBuilder &builder,
                      llvm::StringRef name, mlir::Type resultType,
                      llvm::ArrayRef<mlir::Value> args) const;
 
diff --git a/include/flang/Lower/OpBuilder.h b/include/flang/Lower/OpBuilder.h
deleted file mode 100644
index 4a9f12fb3d9a..000000000000
--- a/include/flang/Lower/OpBuilder.h
+++ /dev/null
@@ -1,216 +0,0 @@
-//===-- Lower/OpBuilder.h -- operation builder ------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef FORTRAN_LOWER_BUILDER_H_
-#define FORTRAN_LOWER_BUILDER_H_
-
-#include "flang/Semantics/symbol.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/Function.h"
-#include "mlir/IR/Module.h"
-#include "llvm/ADT/DenseMap.h"
-#include <string>
-
-namespace llvm {
-class StringRef;
-}
-
-namespace fir {
-class CharacterType;
-class ReferenceType;
-using KindTy = int;
-} // namespace fir
-
-namespace Fortran {
-namespace parser {
-class CookedSource;
-}
-
-namespace evaluate {
-struct ProcedureDesignator;
-}
-
-namespace lower {
-
-/// Miscellaneous helper routines for building MLIR
-///
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
-
-class AbstractConverter;
-
-class SymMap {
-  llvm::DenseMap<const semantics::Symbol *, mlir::Value> symbolMap;
-  std::vector<std::pair<const semantics::Symbol *, mlir::Value>> shadowStack;
-
-public:
-  void addSymbol(semantics::SymbolRef symbol, mlir::Value value);
-
-  mlir::Value lookupSymbol(semantics::SymbolRef symbol);
-
-  void pushShadowSymbol(semantics::SymbolRef symbol, mlir::Value value);
-  void popShadowSymbol();
-
-  void clear() {
-    symbolMap.clear();
-    shadowStack.clear();
-  }
-};
-
-/// Helper class that can be inherited from in order to
-/// facilitate mlir::OpBuilder usage.
-class OpBuilderWrapper {
-public:
-  OpBuilderWrapper(mlir::OpBuilder &b, mlir::Location l) : builder{b}, loc{l} {}
-  /// Insert the location and forwards create call to the builder member.
-  template <typename T, typename... Args>
-  auto create(Args... args) {
-    return builder.create<T>(loc, std::forward<Args>(args)...);
-  }
-  /// Create an integer constant of type \p type and value \p i.
-  mlir::Value createIntegerConstant(mlir::Type integerType, std::int64_t i);
-
-protected:
-  mlir::OpBuilder &builder;
-  mlir::Location loc;
-};
-
-/// Facilitate lowering to fir::loop
-class LoopBuilder : public OpBuilderWrapper {
-public:
-  LoopBuilder(mlir::OpBuilder &b, mlir::Location l) : OpBuilderWrapper{b, l} {}
-  LoopBuilder(OpBuilderWrapper &b) : OpBuilderWrapper{b} {}
-
-  // In createLoop functions, lb, ub, and count arguments must have integer
-  // types. They will be automatically converted the IndexType if needed.
-
-  using BodyGenerator = std::function<void(OpBuilderWrapper &, mlir::Value)>;
-
-  /// Build loop [\p lb, \p ub) with step \p step.
-  /// If \p step is an empty value, 1 is used for the step.
-  void createLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
-                  const BodyGenerator &bodyGenerator);
-
-  /// Build loop [\p lb,  \p ub) with step 1.
-  void createLoop(mlir::Value lb, mlir::Value ub,
-                  const BodyGenerator &bodyGenerator);
-
-  /// Build loop [0, \p count) with step 1.
-  void createLoop(mlir::Value count, const BodyGenerator &bodyGenerator);
-
-private:
-  mlir::Type getIndexType();
-  mlir::Value convertToIndexType(mlir::Value integer);
-};
-
-/// Facilitate lowering of CHARACTER operation
-class CharacterOpsBuilder : public OpBuilderWrapper {
-public:
-  CharacterOpsBuilder(mlir::OpBuilder &b, mlir::Location l)
-      : OpBuilderWrapper{b, l} {}
-  CharacterOpsBuilder(OpBuilderWrapper &b) : OpBuilderWrapper{b} {}
-  /// Interchange format to avoid inserting unbox/embox everywhere while
-  /// evaluating character expressions.
-  struct CharValue {
-    fir::ReferenceType getReferenceType();
-    fir::CharacterType getCharacterType();
-
-    mlir::Value reference;
-    mlir::Value len;
-  };
-
-  /// Copy the \p count first characters of \p src into \p dest.
-  void createCopy(CharValue &dest, CharValue &src, mlir::Value count);
-
-  /// Set characters of \p str at position [\p lower, \p upper) to blanks.
-  /// \p lower and \upper bounds are zero based.
-  /// If \p upper <= \p lower, no padding is done.
-  void createPadding(CharValue &str, mlir::Value lower, mlir::Value upper);
-
-  /// Allocate storage (on the stack) for character given the kind and length.
-  CharValue createTemp(fir::CharacterType type, mlir::Value len);
-
-private:
-  mlir::Value createBlankConstant(fir::CharacterType type);
-};
-
-/// Provide helper to generate Complex manipulations in FIR.
-class ComplexOpsBuilder : public OpBuilderWrapper {
-public:
-  // The values of part enum members are meaningful for
-  // InsertValueOp and ExtractValueOp so they are explicit.
-  enum class Part { Real = 0, Imag = 1 };
-
-  ComplexOpsBuilder(mlir::OpBuilder &b, mlir::Location l)
-      : OpBuilderWrapper{b, l} {}
-  ComplexOpsBuilder(OpBuilderWrapper &bw) : OpBuilderWrapper{bw} {}
-
-  // Type helper. They do not create MLIR operations.
-  mlir::Type getComplexPartType(mlir::Value cplx);
-  mlir::Type getComplexPartType(mlir::Type complexType);
-  mlir::Type getComplexPartType(fir::KindTy complexKind);
-
-  // Complex operation creation helper. They create MLIR operations.
-  mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
-                            mlir::Value imag);
-  mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart);
-  mlir::Value insertComplexPart(mlir::Value cplx, mlir::Value part,
-                                bool isImagPart);
-
-  template <Part partId>
-  mlir::Value extract(mlir::Value cplx);
-  template <Part partId>
-  mlir::Value insert(mlir::Value cplx, mlir::Value part);
-
-  mlir::Value createComplexCompare(mlir::Value cplx1, mlir::Value cplx2,
-                                   bool eq);
-
-private:
-  template <Part partId>
-  mlir::Value createPartId();
-};
-
-/// Get the current Module
-inline mlir::ModuleOp getModule(mlir::OpBuilder *bldr) {
-  return bldr->getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
-}
-
-/// Get the current Function
-inline mlir::FuncOp getFunction(mlir::OpBuilder *bldr) {
-  return bldr->getBlock()->getParent()->getParentOfType<mlir::FuncOp>();
-}
-
-/// Get the entry block of the current Function
-inline mlir::Block *getEntryBlock(mlir::OpBuilder *bldr) {
-  return &getFunction(bldr).front();
-}
-
-/// Create a new basic block
-inline mlir::Block *createBlock(mlir::OpBuilder *bldr, mlir::Region *region) {
-  return bldr->createBlock(region, region->end());
-}
-
-inline mlir::Block *createBlock(mlir::OpBuilder *bldr) {
-  return createBlock(bldr, bldr->getBlock()->getParent());
-}
-
-/// Get a function by name (or null)
-mlir::FuncOp getNamedFunction(mlir::ModuleOp, llvm::StringRef name);
-
-/// Create a new FuncOp
-mlir::FuncOp createFunction(AbstractConverter &converter, llvm::StringRef name,
-                            mlir::FunctionType funcTy);
-
-/// Create a new FuncOp
-/// The function is created with no Location information
-mlir::FuncOp createFunction(mlir::ModuleOp module, llvm::StringRef name,
-                            mlir::FunctionType funcTy);
-
-} // namespace lower
-} // namespace Fortran
-
-#endif // FORTRAN_LOWER_BUILDER_H_
diff --git a/include/flang/Lower/Runtime.h b/include/flang/Lower/Runtime.h
index 156ca920eef5..82b5e56e143d 100644
--- a/include/flang/Lower/Runtime.h
+++ b/include/flang/Lower/Runtime.h
@@ -5,10 +5,18 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+//
+// Builder routines for constructing the FIR dialect of MLIR. As FIR is a
+// dialect of MLIR, it makes extensive use of MLIR interfaces and MLIR's coding
+// style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
+// module.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_RUNTIME_H_
 #define FORTRAN_LOWER_RUNTIME_H_
 
+// use std::optional to effect constexpr evaluation
 #include <optional>
 
 namespace llvm {
@@ -18,27 +26,29 @@ namespace mlir {
 class Type;
 class FunctionType;
 class MLIRContext;
-class OpBuilder;
 class FuncOp;
 } // namespace mlir
 
 namespace Fortran::lower {
 
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
-
-/// C++ does not provide variable size constexpr container yet.
-/// StaticVector is a class that can be used to hold constexpr data as if it was
-/// a vector (i.e, the number of element is not reflected in the
-/// container type). This is useful to use in classes that need to be constexpr
-/// and where leaking the size as a template type would make it harder to
-/// manipulate. It can hold whatever data that can appear as non-type templates
-/// (integers, enums, pointer to objects, function pointers...).
-/// Example usage:
-///
-///  enum class Enum {A, B};
-///  constexpr StaticVector<Enum> vec{StaticVector::create<Enum::A, Enum::B>()};
-///  for (const Enum& code : vec) { /*...*/ }
-///
+class FirOpBuilder;
+
+//===----------------------------------------------------------------------===//
+// C++ does not provide variable size constexpr container yet.  StaticVector is
+// a class that can be used to hold constexpr data as if it was a vector (i.e,
+// the number of element is not reflected in the container type). This is
+// useful to use in classes that need to be constexpr and where leaking the
+// size as a template type would make it harder to manipulate. It can hold
+// whatever data that can appear as non-type templates (integers, enums,
+// pointer to objects, function pointers...).
+//
+// Example usage:
+//
+//  enum class Enum {A, B};
+//  constexpr StaticVector<Enum> vec{StaticVector::create<Enum::A, Enum::B>()};
+//  for (const Enum& code : vec) { /*...*/ }
+//
+//===----------------------------------------------------------------------===//
 
 /// This is the class where the constexpr data is "allocated". In fact
 /// the data is stored "in" the type. Objects of this type are not meant to
@@ -97,7 +107,7 @@ class RuntimeStaticDescription {
   const char *getSymbol() const { return symbol; }
   /// Conversion between types of the static representation and MLIR types.
   mlir::FunctionType getMLIRFunctionType(mlir::MLIRContext *) const;
-  mlir::FuncOp getFuncOp(mlir::OpBuilder &) const;
+  mlir::FuncOp getFuncOp(Fortran::lower::FirOpBuilder &builder) const;
   static mlir::Type getMLIRType(TypeCode, mlir::MLIRContext *);
 
 private:
@@ -195,7 +205,8 @@ enum class RuntimeEntryCode {
   FailImageStatement
 };
 
-mlir::FuncOp genRuntimeFunction(RuntimeEntryCode code, mlir::OpBuilder &);
+mlir::FuncOp genRuntimeFunction(RuntimeEntryCode code,
+                                Fortran::lower::FirOpBuilder &builder);
 
 } // namespace Fortran::lower
 
diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 9543e58a97dd..c5c9dc21c7be 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -588,6 +588,8 @@ class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
       else
         p.printSuccessor(succ);
     }
+
+    unsigned targetOffsetSize();
   }];
 }
 
@@ -718,9 +720,7 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
     return mlir::success();
   }];
 
-  let extraClassDeclaration = extraSwitchClassDeclaration#[{
-    unsigned targetOffsetSize();
-  }];
+  let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
 def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
@@ -892,7 +892,6 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
   }];
 
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
-    unsigned targetOffsetSize();
     unsigned compareOffsetSize();
   }];
 }
@@ -989,9 +988,7 @@ def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
     return mlir::success();
   }];
 
-  let extraClassDeclaration = extraSwitchClassDeclaration#[{
-    unsigned targetOffsetSize();
-  }];
+  let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
 def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
@@ -1869,14 +1866,14 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   }];
 
   let arguments = (ins
-    Index:$lowerBound,
-    Index:$upperBound,
-    Variadic<Index>:$optStep,
+    Variadic<Index>:$indexArgs,
     OptionalAttr<I64Attr>:$constantStep,
+    OptionalAttr<I64Attr>:$constantLowerBound,
+    OptionalAttr<I64Attr>:$constantUpperBound,
     OptionalAttr<UnitAttr>:$unordered
   );
 
-  let results = (outs Variadic<Index>:$lastVal);
+  let results = (outs);
 
   let regions = (region SizedRegion<1>:$region);
 
@@ -1884,34 +1881,58 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   let builders = [
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
               "int64_t lowerBound, int64_t upperBound, int64_t step = 1,"
+              "bool unordered = false,"
               "ArrayRef<NamedAttribute> attributes = {}">,
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
               "mlir::Value lowerBound, mlir::Value upperBound,"
-              "ValueRange step = {}, ArrayRef<NamedAttribute> attributes = {}">
+              "mlir::Value step, bool unordered = false,"
+              "ArrayRef<NamedAttribute> attributes = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "mlir::Value lowerBound, mlir::Value upperBound,"
+              "bool unordered = false,"
+              "ArrayRef<NamedAttribute> attributes = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "mlir::Value lowerBound, mlir::Value upperBound,"
+              "int64_t step, bool unordered = false,"
+              "ArrayRef<NamedAttribute> attributes = {}">
   ];
 
   let parser = "return parseLoopOp(parser, result);";
 
   let printer = [{
-    p << getOperationName() << ' ' << getInductionVar() << " = "
-      << lowerBound() << " to " << upperBound();
-    auto s = optStep();
-    if (s.begin() != s.end()) {
-      p << " step ";
-      p.printOperand(*s.begin());
+    p << getOperationName() << ' ' << getInductionVar() << " = ";
+    if (constantLowerBound())
+      p << "(" << *constantLowerBound() << ")";
+    else
+      p.printOperand(getLowerBoundOperand());
+    p << " to ";
+    if (constantUpperBound())
+      p << "(" << *constantUpperBound() << ")";
+    else
+      p.printOperand(getUpperBoundOperand());
+    if (constantStep()) {
+      p << " step (" << *constantStep() << ")";
+    } else {
+      if (indexArgs().size() > 2) {
+        p << " step ";
+        p.printOperand(getStepOperand());
+      }
     }
     if (unordered())
       p << " unordered";
     p.printRegion(region(), /*printEntryBlockArgs=*/false,
                             /*printBlockTerminators=*/false);
-    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepAttrName()});
+    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepAttrName(),
+                            lowerAttrName(), upperAttrName()});
   }];
 
   let verifier = [{
-    auto step = optStep();
-    if (step.begin() != step.end()) {
+    const auto argSize = indexArgs().size();
+    if (!((argSize == 0) || (argSize == 2) || (argSize == 3)))
+      return emitOpError("wrong number of ssa arguments");
+    if (argSize > 2) {
       // FIXME: size of step must be 1
-      auto *s = (*step.begin()).getDefiningOp();
+      auto *s = (*(indexArgs().begin() + 2)).getDefiningOp();
       if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s))
         if (cst.getValue() == 0)
           return emitOpError("constant step operand must be nonzero");
@@ -1924,20 +1945,18 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
         !body->getArgument(0).getType().isIndex())
       return emitOpError("expected body to have a single index argument for "
                          "the induction variable");
-    if (lastVal().size() > 1)
-      return emitOpError("can only return one final value of iterator");
     return mlir::success();
   }];
 
   let extraClassDeclaration = [{
-    static constexpr const char *unorderedAttrName() { return "unordered"; }
-    static constexpr const char *stepAttrName() { return "step"; }
-
-    /// Is this an unordered loop?
-    bool isUnordered() { return getAttr(unorderedAttrName()).isa<UnitAttr>(); }
-
-    /// Does loop set (and return) the final value of the control variable?
-    bool hasLastValue() { return lastVal().size(); }
+    static constexpr llvm::StringRef unorderedAttrName() { return "unordered"; }
+    static constexpr llvm::StringRef stepAttrName() { return "constantStep"; }
+    static constexpr llvm::StringRef upperAttrName() {
+      return "constantUpperBound";
+    }
+    static constexpr llvm::StringRef lowerAttrName() {
+      return "constantLowerBound";
+    }
 
     /// Get the body of the loop
     mlir::Block *getBody() { return &region().front(); }
@@ -1945,21 +1964,27 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
     /// Get the block argument corresponding to the loop control value (PHI)
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
 
-    /// Get a builder to insert operations into the LoopOp
-    mlir::OpBuilder getBodyBuilder() {
-      return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
+    mlir::Value getLowerBoundOperand() {
+      if (indexArgs().size() != 0)
+        return *indexArgs().begin();
+      return {};
     }
-
-    void setLowerBound(mlir::Value bound) {
-      getOperation()->setOperand(0, bound);
+    
+    mlir::Value getUpperBoundOperand() {
+      if (indexArgs().size() != 0)
+        return *(indexArgs().begin() + 1);
+      return {};
     }
 
-    void setUpperBound(mlir::Value bound) {
-      getOperation()->setOperand(1, bound);
+    mlir::Value getStepOperand() {
+      if (indexArgs().size() == 3)
+        return *(indexArgs().begin() + 2);
+      return {};
     }
 
-    void setStep(mlir::Value step) {
-      getOperation()->setOperand(2, step);
+    void setUnordered() {
+      getOperation()->setAttr(unorderedAttrName(),
+                              mlir::UnitAttr::get(getContext()));
     }
   }];
 }
@@ -2611,7 +2636,7 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
     result.attributes.back().second = builder.getStringAttr(name);
 
     bool simpleInitializer = false;
-    if (!parser.parseOptionalLParen()) {
+    if (mlir::succeeded(parser.parseOptionalLParen())) {
       Attribute attr;
       if (parser.parseAttribute(attr, initValAttrName(), result.attributes) ||
           parser.parseRParen())
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 73174371718a..ac83324f8087 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -394,6 +394,10 @@ mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
 
 void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);
 
+/// Guarantee `type` is a scalar integral type (standard Integer, standard
+/// Index, or FIR Int). Aborts execution if condition is false.
+void verifyIntegralType(mlir::Type type);
+
 } // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIRTYPE_H
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 88b0ba541a7c..d87770172d2a 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -9,10 +9,10 @@
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/ConvertExpr.h"
 #include "flang/Lower/ConvertType.h"
+#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/IO.h"
 #include "flang/Lower/Intrinsics.h"
 #include "flang/Lower/Mangler.h"
-#include "flang/Lower/OpBuilder.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
@@ -38,26 +38,160 @@
       assert(false && "not yet implemented");                                  \
   }
 
-namespace {
-
-llvm::cl::opt<bool>
+static llvm::cl::opt<bool>
     dumpBeforeFir("fdebug-dump-pre-fir", llvm::cl::init(false),
                   llvm::cl::desc("dump the IR tree prior to FIR"));
 
-llvm::cl::opt<bool>
+static llvm::cl::opt<bool>
     disableToDoAssertions("disable-burnside-todo",
                           llvm::cl::desc("disable burnside bridge asserts"),
                           llvm::cl::init(false), llvm::cl::Hidden);
 
-/// Converter from PFT to FIR
+namespace {
+/// Information for generating a structured or unstructured increment loop.
+struct IncrementLoopInfo {
+  explicit IncrementLoopInfo(
+      Fortran::semantics::Symbol *sym,
+      const Fortran::parser::ScalarExpr &lowerExpr,
+      const Fortran::parser::ScalarExpr &upperExpr,
+      const std::optional<Fortran::parser::ScalarExpr> &stepExpr,
+      mlir::Type type)
+      : loopVariableSym{sym}, lowerExpr{lowerExpr}, upperExpr{upperExpr},
+        stepExpr{stepExpr}, loopVariableType{type} {}
+
+  bool isStructured() const { return headerBlock == nullptr; }
+
+  // Data members for both structured and unstructured loops.
+  Fortran::semantics::Symbol *loopVariableSym;
+  const Fortran::parser::ScalarExpr &lowerExpr;
+  const Fortran::parser::ScalarExpr &upperExpr;
+  const std::optional<Fortran::parser::ScalarExpr> &stepExpr;
+  mlir::Type loopVariableType;
+  mlir::Value loopVariable{};
+  mlir::Value stepValue{}; // possible uses in multiple blocks
+
+  // Data members for structured loops.
+  fir::LoopOp doLoop{};
+  mlir::OpBuilder::InsertPoint insertionPoint{};
+
+  // Data members for unstructured loops.
+  mlir::Value tripVariable{};
+  mlir::Block *headerBlock{nullptr};    // loop entry and test block
+  mlir::Block *bodyBlock{nullptr};      // first loop body block
+  mlir::Block *successorBlock{nullptr}; // loop exit target block
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// FirConverter
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Walk over the pre-FIR tree (PFT) and lower it to the FIR dialect of MLIR.
 ///
 /// After building the PFT, the FirConverter processes that representation
 /// and lowers it to the FIR executable representation.
 class FirConverter : public Fortran::lower::AbstractConverter {
+public:
+  explicit FirConverter(Fortran::lower::LoweringBridge &bridge,
+                        fir::NameUniquer &uniquer)
+      : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
+        module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
+        intrinsics{Fortran::lower::IntrinsicLibrary(
+            Fortran::lower::IntrinsicLibrary::Version::LLVM,
+            bridge.getMLIRContext())},
+        uniquer{uniquer} {}
+  virtual ~FirConverter() = default;
 
-  //
-  // Helper function members
-  //
+  /// Convert the PFT to FIR
+  void run(Fortran::lower::pft::Program &pft) {
+    // do translation
+    for (auto &u : pft.getUnits()) {
+      std::visit(
+          Fortran::common::visitors{
+              [&](Fortran::lower::pft::FunctionLikeUnit &f) {
+                lowerFunc(f, {});
+              },
+              [&](Fortran::lower::pft::ModuleLikeUnit &m) { lowerMod(m); },
+              [&](Fortran::lower::pft::BlockDataUnit &) { TODO(); },
+          },
+          u);
+    }
+  }
+
+  mlir::FunctionType genFunctionType(Fortran::lower::SymbolRef sym) {
+    return Fortran::lower::translateSymbolToFIRFunctionType(&mlirContext,
+                                                            defaults, sym);
+  }
+
+  //===--------------------------------------------------------------------===//
+  // AbstractConverter overrides
+  //===--------------------------------------------------------------------===//
+
+  mlir::Value genExprAddr(const Fortran::lower::SomeExpr &expr,
+                          mlir::Location *loc = nullptr) override final {
+    return createFIRAddr(loc ? *loc : toLocation(), &expr);
+  }
+  mlir::Value genExprValue(const Fortran::lower::SomeExpr &expr,
+                           mlir::Location *loc = nullptr) override final {
+    return createFIRExpr(loc ? *loc : toLocation(), &expr);
+  }
+
+  mlir::Type genType(const Fortran::evaluate::DataRef &data) override final {
+    return Fortran::lower::translateDataRefToFIRType(&mlirContext, defaults,
+                                                     data);
+  }
+  mlir::Type genType(const Fortran::lower::SomeExpr &expr) override final {
+    return Fortran::lower::translateSomeExprToFIRType(&mlirContext, defaults,
+                                                      &expr);
+  }
+  mlir::Type genType(Fortran::lower::SymbolRef sym) override final {
+    return Fortran::lower::translateSymbolToFIRType(&mlirContext, defaults,
+                                                    sym);
+  }
+  mlir::Type genType(Fortran::common::TypeCategory tc,
+                     int kind) override final {
+    return Fortran::lower::getFIRType(&mlirContext, defaults, tc, kind);
+  }
+  mlir::Type genType(Fortran::common::TypeCategory tc) override final {
+    return Fortran::lower::getFIRType(&mlirContext, defaults, tc);
+  }
+
+  mlir::Location getCurrentLocation() override final { return toLocation(); }
+  mlir::Location genLocation() override final {
+    return builder->getUnknownLoc();
+  }
+  mlir::Location
+  genLocation(const Fortran::parser::CharBlock &block) override final {
+    if (cooked) {
+      auto loc = cooked->GetSourcePositionRange(block);
+      if (loc.has_value()) {
+        // loc is a pair (begin, end); use the beginning position
+        auto &filePos = loc->first;
+        return mlir::FileLineColLoc::get(filePos.file.path(), filePos.line,
+                                         filePos.column, &mlirContext);
+      }
+    }
+    return genLocation();
+  }
+
+  Fortran::lower::FirOpBuilder &getFirOpBuilder() override final {
+    return *builder;
+  }
+  mlir::ModuleOp &getModuleOp() override final { return module; }
+
+  std::string mangleName(Fortran::lower::SymbolRef symbol) override final {
+    return Fortran::lower::mangle::mangleName(uniquer, symbol);
+  }
+
+private:
+  FirConverter() = delete;
+  FirConverter(const FirConverter &) = delete;
+  FirConverter &operator=(const FirConverter &) = delete;
+
+  //===--------------------------------------------------------------------===//
+  // Helper member functions
+  //===--------------------------------------------------------------------===//
 
   mlir::Value createFIRAddr(mlir::Location loc,
                             const Fortran::semantics::SomeExpr *expr) {
@@ -75,16 +209,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   mlir::Value createTemporary(mlir::Location loc,
                               const Fortran::semantics::Symbol &sym) {
-    return Fortran::lower::createTemporary(loc, *builder, localSymbols,
-                                           genType(sym), &sym);
+    return builder->createTemporary(loc, localSymbols, genType(sym), llvm::None,
+                                    &sym);
   }
 
   mlir::FuncOp genFunctionFIR(llvm::StringRef callee,
                               mlir::FunctionType funcTy) {
-    if (auto func = Fortran::lower::getNamedFunction(module, callee)) {
+    if (auto func = builder->getNamedFunction(callee))
       return func;
-    }
-    return createFunction(*this, callee, funcTy);
+    return builder->createFunction(callee, funcTy);
   }
 
   static bool inMainProgram(Fortran::lower::pft::Evaluation *cstr) {
@@ -186,6 +319,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     setCurrentPosition(stmt.source);
     genFIRProgramExit();
   }
+
   void
   genFIR(const Fortran::parser::Statement<Fortran::parser::FunctionStmt> &stmt,
          std::string &name, const Fortran::semantics::Symbol *&symbol) {
@@ -292,9 +426,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x,
                               mlir::Type t) {
     mlir::Value v = genExprValue(*Fortran::semantics::GetExpr(x));
-    return v.getType() == t
-               ? v
-               : builder->create<fir::ConvertOp>(toLocation(), t, v);
+    return builder->create<fir::ConvertOp>(toLocation(), t, v);
   }
 
   mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x) {
@@ -302,11 +434,11 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   mlir::FuncOp getFunc(llvm::StringRef name, mlir::FunctionType ty) {
-    if (auto func = Fortran::lower::getNamedFunction(module, name)) {
+    if (auto func = builder->getNamedFunction(name)) {
       assert(func.getType() == ty);
       return func;
     }
-    return createFunction(*this, name, ty);
+    return builder->createFunction(name, ty);
   }
 
   /// Lowering of CALL statement
@@ -441,46 +573,13 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     TODO();
   }
 
-  // Information for generating a structured or unstructured increment loop.
-  struct IncrementLoopInfo {
-    IncrementLoopInfo(
-        Fortran::semantics::Symbol *sym,
-        const Fortran::parser::ScalarExpr &lowerExpr,
-        const Fortran::parser::ScalarExpr &upperExpr,
-        const std::optional<Fortran::parser::ScalarExpr> &stepExpr,
-        mlir::Type type)
-        : loopVariableSym{sym}, lowerExpr{lowerExpr}, upperExpr{upperExpr},
-          stepExpr{stepExpr}, loopVariableType{type} {}
-
-    bool isStructured() const { return headerBlock == nullptr; }
-
-    // Data members for both structured and unstructured loops.
-    Fortran::semantics::Symbol *loopVariableSym;
-    const Fortran::parser::ScalarExpr &lowerExpr;
-    const Fortran::parser::ScalarExpr &upperExpr;
-    const std::optional<Fortran::parser::ScalarExpr> &stepExpr;
-    mlir::Type loopVariableType;
-    mlir::Value loopVariable{};
-    mlir::Value stepValue{}; // possible uses in multiple blocks
-
-    // Data members for structured loops.
-    fir::LoopOp doLoop{};
-    mlir::OpBuilder::InsertPoint insertionPoint{};
-
-    // Data members for unstructured loops.
-    mlir::Value tripVariable{};
-    mlir::Block *headerBlock{nullptr};    // loop entry and test block
-    mlir::Block *bodyBlock{nullptr};      // first loop body block
-    mlir::Block *successorBlock{nullptr}; // loop exit target block
-  };
-
   /// Generate FIR for a DO construct.  There are six variants:
   ///  - unstructured infinite and while loops
   ///  - structured and unstructured increment loops
   ///  - structured and unstructured concurrent loops
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::DoConstruct &) {
-    bool unstructuredContext = eval.lowerAsUnstructured();
+    bool unstructuredContext{eval.lowerAsUnstructured()};
     Fortran::lower::pft::Evaluation &doStmtEval = eval.evaluationList->front();
     auto *doStmt = doStmtEval.getIf<Fortran::parser::NonLabelDoStmt>();
     assert(doStmt && "missing DO statement");
@@ -521,7 +620,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       TODO();
       // Add entries to incrementLoopInfo.  (Define extra members for a mask.)
     }
-    for (size_t i = 0, n = incrementLoopInfo.size(); i < n; ++i) {
+    auto n = incrementLoopInfo.size();
+    for (decltype(n) i = 0; i < n; ++i) {
       genFIRIncrementLoopBegin(incrementLoopInfo[i]);
     }
 
@@ -534,56 +634,51 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     if (infiniteLoop || whileCondition) {
       genFIRUnconditionalBranch(doStmtEval.localBlocks[0]);
     } else {
-      for (size_t i = incrementLoopInfo.size(); i > 0;) {
+      for (auto i = incrementLoopInfo.size(); i > 0;)
         genFIRIncrementLoopEnd(incrementLoopInfo[--i]);
-      }
     }
   }
 
   /// Generate FIR to begin a structured or unstructured increment loop.
   void genFIRIncrementLoopBegin(IncrementLoopInfo &info) {
-    mlir::Location location = toLocation();
+    auto location = toLocation();
     mlir::Type type = info.isStructured()
                           ? mlir::IndexType::get(builder->getContext())
                           : info.loopVariableType;
-    mlir::Value lowerValue = genFIRLoopIndex(info.lowerExpr, type);
-    mlir::Value upperValue = genFIRLoopIndex(info.upperExpr, type);
-    if (info.stepExpr.has_value()) {
-      info.stepValue = genFIRLoopIndex(*info.stepExpr, type);
-    }
+    auto lowerValue = genFIRLoopIndex(info.lowerExpr, type);
+    auto upperValue = genFIRLoopIndex(info.upperExpr, type);
+    info.stepValue =
+        info.stepExpr.has_value()
+            ? genFIRLoopIndex(*info.stepExpr, type)
+            : (info.isStructured()
+                   ? builder->create<mlir::ConstantIndexOp>(location, 1)
+                   : builder->createIntegerConstant(info.loopVariableType, 1));
+    assert(info.stepValue && "step value must be set");
     info.loopVariable = createTemporary(location, *info.loopVariableSym);
 
     // Structured loop - generate fir.loop.
     if (info.isStructured()) {
       info.insertionPoint = builder->saveInsertionPoint();
-      llvm::SmallVector<mlir::Value, 1> stepVector;
-      if (info.stepValue) {
-        stepVector.push_back(info.stepValue);
-      }
       info.doLoop = builder->create<fir::LoopOp>(location, lowerValue,
-                                                 upperValue, stepVector);
+                                                 upperValue, info.stepValue);
       builder->setInsertionPointToStart(info.doLoop.getBody());
-      mlir::Value shadow = builder->create<fir::ConvertOp>(
+      // Always store iteration ssa-value to the LCV to avoid missing any
+      // aliasing of the LCV.
+      auto lcv = builder->create<fir::ConvertOp>(
           location, info.loopVariableType, info.doLoop.getInductionVar());
-      localSymbols.pushShadowSymbol(*info.loopVariableSym, shadow);
+      builder->create<fir::StoreOp>(location, lcv, info.loopVariable);
       return;
     }
 
     // Unstructured loop preheader code - initialize tripVariable, loopVariable.
-    if (!info.stepValue) {
-      info.stepValue = builder->create<mlir::ConstantOp>(
-          location, builder->getIntegerAttr(info.loopVariableType, 1));
-    }
-    mlir::Value tripCount =
+    auto distance =
         builder->create<mlir::SubIOp>(location, upperValue, lowerValue);
-    tripCount =
-        builder->create<mlir::AddIOp>(location, tripCount, info.stepValue);
-    if (info.stepExpr.has_value()) {
-      tripCount = builder->create<mlir::SignedDivIOp>(location, tripCount,
-                                                      info.stepValue);
-    }
-    info.tripVariable = Fortran::lower::createTemporary(
-        location, *builder, localSymbols, info.loopVariableType, nullptr);
+    auto adjusted =
+        builder->create<mlir::AddIOp>(location, distance, info.stepValue);
+    auto tripCount =
+        builder->create<mlir::SignedDivIOp>(location, adjusted, info.stepValue);
+    info.tripVariable =
+        builder->createTemporary(location, localSymbols, info.loopVariableType);
     builder->create<fir::StoreOp>(location, tripCount, info.tripVariable);
     builder->create<fir::StoreOp>(location, lowerValue, info.loopVariable);
 
@@ -591,8 +686,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     startBlock(info.headerBlock);
     mlir::Value tripVariable =
         builder->create<fir::LoadOp>(location, info.tripVariable);
-    mlir::Value zero = builder->create<mlir::ConstantOp>(
-        location, builder->getIntegerAttr(info.loopVariableType, 0));
+    mlir::Value zero = builder->createIntegerConstant(info.loopVariableType, 0);
     mlir::Value cond = builder->create<mlir::CmpIOp>(
         location, mlir::CmpIPredicate::sgt, tripVariable, zero);
     genFIRConditionalBranch(cond, info.bodyBlock, info.successorBlock);
@@ -603,12 +697,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     mlir::Location location = toLocation();
     if (info.isStructured()) {
       // End fir.loop.
-      localSymbols.popShadowSymbol();
       builder->restoreInsertionPoint(info.insertionPoint);
-      assert(info.doLoop.hasLastValue() && "loop must have a result");
-      mlir::Value result = builder->create<fir::ConvertOp>(
-          location, info.loopVariableType, info.doLoop.lastVal()[0]);
-      builder->create<fir::StoreOp>(location, result, info.loopVariable);
       return;
     }
 
@@ -742,6 +831,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
     TODO();
   }
+
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::ForallAssignmentStmt &s) {
     std::visit([&](auto &b) { genFIR(eval, b); }, s.u);
@@ -918,21 +1008,20 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     // variable designator
     auto getAddrAndLength =
         [&](const Fortran::lower::SomeExpr &charDesignatorExpr)
-        -> Fortran::lower::CharacterOpsBuilder::CharValue {
-      mlir::Value addr = genExprAddr(charDesignatorExpr);
+        -> Fortran::lower::CharValue {
+      auto addr = genExprAddr(charDesignatorExpr);
       const auto &charExpr =
           std::get<Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
               charDesignatorExpr.u);
-      std::optional<
-          Fortran::evaluate::Expr<Fortran::evaluate::SubscriptInteger>>
-          lenExpr = charExpr.LEN();
-      assert(lenExpr && "could not get expression to compute character length");
-      mlir::Value len =
+      auto lenExpr = charExpr.LEN();
+      assert(lenExpr.has_value() &&
+             "could not get expression to compute character length");
+      auto len =
           genExprValue(Fortran::evaluate::AsGenericExpr(std::move(*lenExpr)));
-      return Fortran::lower::CharacterOpsBuilder::CharValue{addr, len};
+      return {addr, len};
     };
 
-    Fortran::lower::CharacterOpsBuilder charBuilder{*builder, toLocation()};
+    builder->setLocation(toLocation());
 
     // RHS evaluation.
     // FIXME:  Only works with rhs that are variable reference.
@@ -940,17 +1029,17 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     auto rhs = getAddrAndLength(assignment.rhs);
     // A temp is needed to evaluate rhs until proven it does not depend on lhs.
     auto tempToEvalRhs =
-        charBuilder.createTemp(rhs.getCharacterType(), rhs.len);
-    charBuilder.createCopy(tempToEvalRhs, rhs, rhs.len);
+        builder->createCharacterTemp(builder->getCharacterType(rhs), rhs.len);
+    builder->createCopy(tempToEvalRhs, rhs, rhs.len);
 
     // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
     auto lhs = getAddrAndLength(assignment.lhs);
-    auto cmpLen = charBuilder.create<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
-                                                   lhs.len, rhs.len);
+    auto cmpLen = builder->createHere<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
+                                                    lhs.len, rhs.len);
     auto copyCount =
-        charBuilder.create<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
-    charBuilder.createCopy(lhs, tempToEvalRhs, copyCount);
-    charBuilder.createPadding(lhs, copyCount, lhs.len);
+        builder->createHere<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
+    builder->createCopy(lhs, tempToEvalRhs, copyCount);
+    builder->createPadding(lhs, copyCount, lhs.len);
   }
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
@@ -1200,26 +1289,25 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   mlir::FuncOp createNewFunction(llvm::StringRef name,
                                  const Fortran::semantics::Symbol *symbol) {
-    // get arguments and return type if any, otherwise just use empty vectors
-    llvm::SmallVector<mlir::Type, 8> args;
-    llvm::SmallVector<mlir::Type, 2> results;
-    auto funcTy = symbol ? genFunctionType(*symbol)
-                         : mlir::FunctionType::get(args, results, &mlirContext);
-    return createFunction(*this, name, funcTy);
+    mlir::FunctionType ty =
+        symbol ? genFunctionType(*symbol)
+               : mlir::FunctionType::get(llvm::None, llvm::None, &mlirContext);
+    return Fortran::lower::FirOpBuilder::createFunction(toLocation(), module,
+                                                        name, ty);
   }
 
   /// Prepare to translate a new function
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit,
                         llvm::StringRef name,
                         const Fortran::semantics::Symbol *symbol) {
-    mlir::FuncOp func = Fortran::lower::getNamedFunction(module, name);
-    if (!func) {
+    assert(!builder && "expected nullptr");
+    mlir::FuncOp func =
+        Fortran::lower::FirOpBuilder::getNamedFunction(module, name);
+    if (!func)
       func = createNewFunction(name, symbol);
-    }
+    builder = new Fortran::lower::FirOpBuilder(func);
+    assert(builder && "FirOpBuilder did not instantiate");
     func.addEntryBlock();
-    assert(!builder && "expected nullptr");
-    builder = new mlir::OpBuilder(func);
-    assert(builder && "OpBuilder did not instantiate");
     builder->setInsertionPointToStart(&func.front());
 
     // plumb function's arguments
@@ -1236,9 +1324,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
           TODO(); // handle alternate return
         }
       }
-      if (details->isFunction()) {
+      if (details->isFunction())
         createTemporary(toLocation(), details->result());
-      }
     }
 
     // Create most function blocks in advance.
@@ -1252,12 +1339,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void createEmptyBlocks(
       std::list<Fortran::lower::pft::Evaluation> &evaluationList) {
     for (auto &eval : evaluationList) {
-      if (eval.isNewBlock) {
-        eval.block = Fortran::lower::createBlock(builder);
-      }
-      for (size_t i = 0, n = eval.localBlocks.size(); i < n; ++i) {
-        eval.localBlocks[i] = Fortran::lower::createBlock(builder);
-      }
+      if (eval.isNewBlock)
+        eval.block = builder->createBlock();
+      for (size_t i = 0, n = eval.localBlocks.size(); i < n; ++i)
+        eval.localBlocks[i] = builder->createBlock();
       if (eval.isConstruct()) {
         if (eval.lowerAsUnstructured()) {
           createEmptyBlocks(*eval.evaluationList);
@@ -1265,9 +1350,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
           // A structured construct that is a target starts a new block.
           Fortran::lower::pft::Evaluation &constructStmt =
               eval.evaluationList->front();
-          if (constructStmt.isNewBlock) {
-            constructStmt.block = Fortran::lower::createBlock(builder);
-          }
+          if (constructStmt.isNewBlock)
+            constructStmt.block = builder->createBlock();
         }
       }
     }
@@ -1391,109 +1475,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return builder->create<mlir::AndOp>(lhs.getLoc(), lhs, rhs);
   }
 
-private:
   mlir::MLIRContext &mlirContext;
   const Fortran::parser::CookedSource *cooked;
   mlir::ModuleOp &module;
   const Fortran::common::IntrinsicTypeDefaultKinds &defaults;
   Fortran::lower::IntrinsicLibrary intrinsics;
-  mlir::OpBuilder *builder = nullptr;
+  Fortran::lower::FirOpBuilder *builder = nullptr;
   fir::NameUniquer &uniquer;
   Fortran::lower::SymMap localSymbols;
   Fortran::parser::CharBlock currentPosition;
-
-public:
-  FirConverter() = delete;
-  FirConverter(const FirConverter &) = delete;
-  FirConverter &operator=(const FirConverter &) = delete;
-  virtual ~FirConverter() = default;
-
-  explicit FirConverter(Fortran::lower::LoweringBridge &bridge,
-                        fir::NameUniquer &uniquer)
-      : mlirContext{bridge.getMLIRContext()}, cooked{bridge.getCookedSource()},
-        module{bridge.getModule()}, defaults{bridge.getDefaultKinds()},
-        intrinsics{Fortran::lower::IntrinsicLibrary(
-            Fortran::lower::IntrinsicLibrary::Version::LLVM,
-            bridge.getMLIRContext())},
-        uniquer{uniquer} {}
-
-  /// Convert the PFT to FIR
-  void run(Fortran::lower::pft::Program &pft) {
-    // do translation
-    for (auto &u : pft.getUnits()) {
-      std::visit(
-          Fortran::common::visitors{
-              [&](Fortran::lower::pft::FunctionLikeUnit &f) {
-                lowerFunc(f, {});
-              },
-              [&](Fortran::lower::pft::ModuleLikeUnit &m) { lowerMod(m); },
-              [&](Fortran::lower::pft::BlockDataUnit &) { TODO(); },
-          },
-          u);
-    }
-  }
-
-  mlir::FunctionType genFunctionType(Fortran::lower::SymbolRef sym) {
-    return Fortran::lower::translateSymbolToFIRFunctionType(&mlirContext,
-                                                            defaults, sym);
-  }
-
-  //
-  // AbstractConverter overrides
-
-  mlir::Value genExprAddr(const Fortran::lower::SomeExpr &expr,
-                          mlir::Location *loc = nullptr) override final {
-    return createFIRAddr(loc ? *loc : toLocation(), &expr);
-  }
-  mlir::Value genExprValue(const Fortran::lower::SomeExpr &expr,
-                           mlir::Location *loc = nullptr) override final {
-    return createFIRExpr(loc ? *loc : toLocation(), &expr);
-  }
-
-  mlir::Type genType(const Fortran::evaluate::DataRef &data) override final {
-    return Fortran::lower::translateDataRefToFIRType(&mlirContext, defaults,
-                                                     data);
-  }
-  mlir::Type genType(const Fortran::lower::SomeExpr &expr) override final {
-    return Fortran::lower::translateSomeExprToFIRType(&mlirContext, defaults,
-                                                      &expr);
-  }
-  mlir::Type genType(Fortran::lower::SymbolRef sym) override final {
-    return Fortran::lower::translateSymbolToFIRType(&mlirContext, defaults,
-                                                    sym);
-  }
-  mlir::Type genType(Fortran::common::TypeCategory tc,
-                     int kind) override final {
-    return Fortran::lower::getFIRType(&mlirContext, defaults, tc, kind);
-  }
-  mlir::Type genType(Fortran::common::TypeCategory tc) override final {
-    return Fortran::lower::getFIRType(&mlirContext, defaults, tc);
-  }
-
-  mlir::Location getCurrentLocation() override final { return toLocation(); }
-  mlir::Location genLocation() override final {
-    return mlir::UnknownLoc::get(&mlirContext);
-  }
-  mlir::Location
-  genLocation(const Fortran::parser::CharBlock &block) override final {
-    if (cooked) {
-      auto loc = cooked->GetSourcePositionRange(block);
-      if (loc.has_value()) {
-        // loc is a pair (begin, end); use the beginning position
-        auto &filePos = loc->first;
-        return mlir::FileLineColLoc::get(filePos.file.path(), filePos.line,
-                                         filePos.column, &mlirContext);
-      }
-    }
-    return genLocation();
-  }
-
-  mlir::OpBuilder &getOpBuilder() override final { return *builder; }
-  mlir::ModuleOp &getModuleOp() override final { return module; }
-
-  std::string mangleName(Fortran::lower::SymbolRef symbol) override final {
-    return Fortran::lower::mangle::mangleName(uniquer, symbol);
-  }
 };
 
 } // namespace
diff --git a/lib/Lower/CMakeLists.txt b/lib/Lower/CMakeLists.txt
index 7984a1dc4b53..6e11725ef86e 100644
--- a/lib/Lower/CMakeLists.txt
+++ b/lib/Lower/CMakeLists.txt
@@ -4,10 +4,10 @@ add_library(FortranLower
   Bridge.cpp
   ConvertExpr.cpp
   ConvertType.cpp
+  FIRBuilder.cpp
   Intrinsics.cpp
   IO.cpp
   Mangler.cpp
-  OpBuilder.cpp
   PFTBuilder.cpp
   Runtime.cpp
 )
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 6cb6ccf20df3..3f018c3b3e16 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -13,7 +13,7 @@
 #include "flang/Evaluate/real.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/ConvertType.h"
-#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
@@ -46,7 +46,7 @@ namespace {
 class ExprLowering {
   mlir::Location location;
   Fortran::lower::AbstractConverter &converter;
-  mlir::OpBuilder &builder;
+  Fortran::lower::FirOpBuilder &builder;
   const Fortran::lower::SomeExpr &expr;
   Fortran::lower::SymMap &symMap;
   const Fortran::lower::IntrinsicLibrary &intrinsics;
@@ -100,7 +100,7 @@ class ExprLowering {
     case Fortran::common::RelationalOperator::GE:
       return mlir::CmpFPredicate::OGE;
     }
-    assert(false && "unhandled REAL relational operator");
+    llvm_unreachable("unhandled REAL relational operator");
     return {};
   }
 
@@ -150,13 +150,12 @@ class ExprLowering {
   }
 
   mlir::FuncOp getFunction(llvm::StringRef name, mlir::FunctionType funTy) {
-    auto module = Fortran::lower::getModule(&builder);
-    if (auto func = Fortran::lower::getNamedFunction(module, name)) {
+    if (auto func = builder.getNamedFunction(name)) {
       assert(func.getType() == funTy &&
              "function already declared with a different type");
       return func;
     }
-    return Fortran::lower::createFunction(module, name, funTy);
+    return builder.createFunction(name, funTy);
   }
 
   // FIXME binary operation :: ('a, 'a) -> 'a
@@ -207,14 +206,14 @@ class ExprLowering {
 
   mlir::Value gen(Fortran::semantics::SymbolRef sym) {
     // FIXME: not all symbols are local
-    auto addr = createTemporary(getLoc(), builder, symMap,
-                                converter.genType(sym), &*sym);
+    auto addr = builder.createTemporary(
+        getLoc(), symMap, converter.genType(sym), llvm::None, &*sym);
     assert(addr && "failed generating symbol address");
     // Get address from descriptor if symbol has one.
     auto type = addr.getType();
     if (auto boxCharType = type.dyn_cast<fir::BoxCharType>()) {
       auto refType = fir::ReferenceType::get(boxCharType.getEleTy());
-      auto lenType = mlir::IntegerType::get(64, builder.getContext());
+      auto lenType = builder.getIntegerType(64);
       addr = builder.create<fir::UnboxCharOp>(getLoc(), refType, lenType, addr)
                  .getResult(0);
     } else if (type.isa<fir::BoxType>()) {
@@ -272,8 +271,9 @@ class ExprLowering {
 
   template <int KIND>
   mlir::Value genval(const Fortran::evaluate::ComplexComponent<KIND> &part) {
-    return Fortran::lower::ComplexOpsBuilder{builder, getLoc()}
-        .extractComplexPart(genval(part.left()), part.isImaginaryPart);
+    builder.setLocation(getLoc());
+    return builder.extractComplexPart(genval(part.left()),
+                                      part.isImaginaryPart);
   }
 
   template <Fortran::common::TypeCategory TC, int KIND>
@@ -368,8 +368,8 @@ class ExprLowering {
 
   template <int KIND>
   mlir::Value genval(const Fortran::evaluate::ComplexConstructor<KIND> &op) {
-    return Fortran::lower::ComplexOpsBuilder{builder, getLoc()}.createComplex(
-        KIND, genval(op.left()), genval(op.right()));
+    builder.setLocation(getLoc());
+    return builder.createComplex(KIND, genval(op.left()), genval(op.right()));
   }
 
   template <int KIND>
@@ -409,9 +409,9 @@ class ExprLowering {
       bool eq{op.opr == Fortran::common::RelationalOperator::EQ};
       assert(eq || op.opr == Fortran::common::RelationalOperator::NE &&
                        "relation undefined for complex");
-      result =
-          Fortran::lower::ComplexOpsBuilder{builder, getLoc()}
-              .createComplexCompare(genval(op.left()), genval(op.right()), eq);
+      builder.setLocation(getLoc());
+      result = builder.createComplexCompare(genval(op.left()),
+                                            genval(op.right()), eq);
     } else {
       static_assert(TC == Fortran::lower::CharacterCat);
       TODO();
@@ -894,8 +894,9 @@ class ExprLowering {
                         Fortran::lower::SymMap &map,
                         const Fortran::lower::IntrinsicLibrary &intr,
                         bool logicalAsI1 = false)
-      : location{loc}, converter{converter}, builder{converter.getOpBuilder()},
-        expr{vop}, symMap{map}, intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
+      : location{loc}, converter{converter},
+        builder{converter.getFirOpBuilder()}, expr{vop}, symMap{map},
+        intrinsics{intr}, genLogicalAsI1{logicalAsI1} {}
 
   /// Lower the expression `expr` into MLIR standard dialect
   mlir::Value gen() { return gen(expr); }
@@ -927,31 +928,3 @@ mlir::Value Fortran::lower::createSomeAddress(
     const Fortran::lower::IntrinsicLibrary &intrinsics) {
   return ExprLowering{loc, converter, expr, symMap, intrinsics}.gen();
 }
-
-/// Create a temporary variable
-/// `symbol` will be nullptr for an anonymous temporary
-mlir::Value
-Fortran::lower::createTemporary(mlir::Location loc, mlir::OpBuilder &builder,
-                                Fortran::lower::SymMap &symMap, mlir::Type type,
-                                const Fortran::semantics::Symbol *symbol,
-                                llvm::StringRef name) {
-  if (symbol)
-    if (auto val = symMap.lookupSymbol(*symbol)) {
-      if (auto op = val.getDefiningOp())
-        return op->getResult(0);
-      return val;
-    }
-
-  auto insPt(builder.saveInsertionPoint());
-  builder.setInsertionPointToStart(getEntryBlock(&builder));
-  fir::AllocaOp ae;
-  assert(!type.dyn_cast<fir::ReferenceType>() && "cannot be a reference");
-  if (symbol) {
-    ae = builder.create<fir::AllocaOp>(loc, type, symbol->name().ToString());
-    symMap.addSymbol(*symbol, ae);
-  } else {
-    ae = builder.create<fir::AllocaOp>(loc, type, name);
-  }
-  builder.restoreInsertionPoint(insPt);
-  return ae;
-}
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
new file mode 100644
index 000000000000..3ac137291964
--- /dev/null
+++ b/lib/Lower/FIRBuilder.cpp
@@ -0,0 +1,268 @@
+//===-- OpBuilder.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/Lower/FIRBuilder.h"
+#include "flang/Lower/Bridge.h"
+#include "flang/Lower/ConvertType.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Semantics/symbol.h"
+#include "mlir/IR/Module.h"
+#include "mlir/IR/Value.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
+
+void Fortran::lower::SymMap::addSymbol(Fortran::semantics::SymbolRef symbol,
+                                       mlir::Value value) {
+  symbolMap.try_emplace(&*symbol, value);
+}
+
+mlir::Value
+Fortran::lower::SymMap::lookupSymbol(Fortran::semantics::SymbolRef symbol) {
+  auto iter{symbolMap.find(&*symbol)};
+  return (iter == symbolMap.end()) ? nullptr : iter->second;
+}
+
+mlir::FuncOp Fortran::lower::FirOpBuilder::createFunction(
+    mlir::Location loc, mlir::ModuleOp module, llvm::StringRef name,
+    mlir::FunctionType ty) {
+  return fir::createFuncOp(loc, module, name, ty);
+}
+
+mlir::FuncOp
+Fortran::lower::FirOpBuilder::getNamedFunction(mlir::ModuleOp modOp,
+                                               llvm::StringRef name) {
+  return modOp.lookupSymbol<mlir::FuncOp>(name);
+}
+
+mlir::Value
+Fortran::lower::FirOpBuilder::createIntegerConstant(mlir::Type intType,
+                                                    std::int64_t cst) {
+  return createHere<mlir::ConstantOp>(intType, getIntegerAttr(intType, cst));
+}
+
+/// Create a temporary variable
+/// `symbol` will be nullptr for an anonymous temporary
+mlir::Value Fortran::lower::FirOpBuilder::createTemporary(
+    mlir::Location loc, Fortran::lower::SymMap &symMap, mlir::Type type,
+    llvm::ArrayRef<mlir::Value> shape, const Fortran::semantics::Symbol *symbol,
+    llvm::StringRef name) {
+  if (symbol)
+    if (auto val = symMap.lookupSymbol(*symbol)) {
+      if (auto op = val.getDefiningOp())
+        return op->getResult(0);
+      return val;
+    }
+
+  auto insPt = saveInsertionPoint();
+  setInsertionPointToStart(getEntryBlock());
+  fir::AllocaOp ae;
+  assert(!type.isa<fir::ReferenceType>() && "cannot be a reference");
+  if (symbol) {
+    ae = create<fir::AllocaOp>(loc, type, symbol->name().ToString(), llvm::None,
+                               shape);
+    symMap.addSymbol(*symbol, ae);
+  } else {
+    ae = create<fir::AllocaOp>(loc, type, name, llvm::None, shape);
+  }
+  restoreInsertionPoint(insPt);
+  return ae;
+}
+
+//===----------------------------------------------------------------------===//
+// LoopOp builder
+//===----------------------------------------------------------------------===//
+
+void Fortran::lower::FirOpBuilder::createLoop(
+    mlir::Value lb, mlir::Value ub, mlir::Value step,
+    const BodyGenerator &bodyGenerator) {
+  auto lbi = convertToIndexType(lb);
+  auto ubi = convertToIndexType(ub);
+  assert(step && "step must be an actual Value");
+  auto inc = convertToIndexType(step);
+  auto loop = createHere<fir::LoopOp>(lbi, ubi, inc);
+  auto *insPt = getInsertionBlock();
+  setInsertionPointToStart(loop.getBody());
+  auto index = loop.getInductionVar();
+  bodyGenerator(*this, index);
+  setInsertionPointToEnd(insPt);
+}
+
+void Fortran::lower::FirOpBuilder::createLoop(
+    mlir::Value lb, mlir::Value ub, const BodyGenerator &bodyGenerator) {
+  createLoop(lb, ub, createIntegerConstant(getIndexType(), 1), bodyGenerator);
+}
+
+void Fortran::lower::FirOpBuilder::createLoop(
+    mlir::Value count, const BodyGenerator &bodyGenerator) {
+  auto indexType = getIndexType();
+  auto zero = createIntegerConstant(indexType, 0);
+  auto one = createIntegerConstant(indexType, 1);
+  createLoop(zero, count, one, bodyGenerator);
+}
+
+mlir::Value
+Fortran::lower::FirOpBuilder::convertToIndexType(mlir::Value integer) {
+  // abort now if not an integral type
+  fir::verifyIntegralType(integer.getType());
+  return createHere<fir::ConvertOp>(getIndexType(), integer);
+}
+
+//===----------------------------------------------------------------------===//
+// CharacterOpsBuilder implementation
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+void Fortran::lower::CharacterOpsBuilder<T>::createCopy(
+    Fortran::lower::CharValue &dest, const Fortran::lower::CharValue &src,
+    mlir::Value count) {
+  auto &b = impl();
+  auto refType = b.getReferenceType(dest);
+  // Cast to character sequence reference type for fir::CoordinateOp.
+  auto seqTy = getSequenceRefType(refType);
+  auto destRef = b.template createHere<fir::ConvertOp>(seqTy, dest.buffer);
+  auto srcRef = b.template createHere<fir::ConvertOp>(seqTy, src.buffer);
+
+  b.createLoop(count, [&](Fortran::lower::FirOpBuilder &b, mlir::Value index) {
+    auto destAddr = b.createHere<fir::CoordinateOp>(refType, destRef, index);
+    auto srcAddr = b.createHere<fir::CoordinateOp>(refType, srcRef, index);
+    auto val = b.createHere<fir::LoadOp>(srcAddr);
+    b.createHere<fir::StoreOp>(val, destAddr);
+  });
+}
+template void
+Fortran::lower::CharacterOpsBuilder<Fortran::lower::FirOpBuilder>::createCopy(
+    Fortran::lower::CharValue &, const Fortran::lower::CharValue &,
+    mlir::Value);
+
+template <typename T>
+void Fortran::lower::CharacterOpsBuilder<T>::createPadding(
+    Fortran::lower::CharValue &str, mlir::Value lower, mlir::Value upper) {
+  auto &b = impl();
+  auto loc = b.getLoc();
+  auto refType = b.getReferenceType(str);
+  auto seqTy = getSequenceRefType(refType);
+  auto strRef = b.template createHere<fir::ConvertOp>(seqTy, str.buffer);
+  auto blank = createBlankConstant(b.getCharacterType(str));
+
+  b.createLoop(lower, upper, [&](FirOpBuilder &b, mlir::Value index) {
+    auto strAddr = b.create<fir::CoordinateOp>(loc, refType, strRef, index);
+    b.create<fir::StoreOp>(loc, blank, strAddr);
+  });
+}
+template void Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createPadding(Fortran::lower::CharValue &,
+                                                 mlir::Value, mlir::Value);
+
+template <typename T>
+mlir::Value Fortran::lower::CharacterOpsBuilder<T>::createBlankConstant(
+    fir::CharacterType type) {
+  auto &b = impl();
+  auto byteTy = b.getIntegerType(8);
+  auto asciiSpace = b.createIntegerConstant(byteTy, ' ');
+  return b.template createHere<fir::ConvertOp>(type, asciiSpace);
+}
+template mlir::Value Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createBlankConstant(fir::CharacterType);
+
+template <typename T>
+Fortran::lower::CharValue
+Fortran::lower::CharacterOpsBuilder<T>::createCharacterTemp(
+    fir::CharacterType type, mlir::Value len) {
+  auto buffer = impl().createTemporary(type, {len});
+  return CharValue{buffer, len};
+}
+template Fortran::lower::CharValue Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createCharacterTemp(fir::CharacterType,
+                                                       mlir::Value);
+
+template <typename T>
+fir::ReferenceType Fortran::lower::CharacterOpsBuilder<T>::getReferenceType(
+    const Fortran::lower::CharValue &pair) {
+  auto refTy = pair.buffer.getType();
+  if (auto type = refTy.template dyn_cast<fir::ReferenceType>())
+    return type;
+  llvm_unreachable("expected reference type");
+  return {};
+}
+template fir::ReferenceType
+Fortran::lower::CharacterOpsBuilder<Fortran::lower::FirOpBuilder>::
+    getReferenceType(const Fortran::lower::CharValue &);
+
+template <typename T>
+fir::CharacterType Fortran::lower::CharacterOpsBuilder<T>::getCharacterType(
+    const Fortran::lower::CharValue &pair) {
+  auto eleTy = getReferenceType(pair).getEleTy();
+  if (auto type = eleTy.template dyn_cast<fir::CharacterType>())
+    return type;
+  llvm_unreachable("expected character type");
+  return {};
+}
+template fir::CharacterType
+Fortran::lower::CharacterOpsBuilder<Fortran::lower::FirOpBuilder>::
+    getCharacterType(const Fortran::lower::CharValue &);
+
+//===----------------------------------------------------------------------===//
+// ComplexOpsBuilder implementation
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+mlir::Type Fortran::lower::ComplexOpsBuilder<T>::getComplexPartType(
+    fir::KindTy complexKind) {
+  return convertReal(impl().getContext(), complexKind);
+}
+template mlir::Type Fortran::lower::ComplexOpsBuilder<
+    Fortran::lower::FirOpBuilder>::getComplexPartType(fir::KindTy);
+
+template <typename T>
+mlir::Type Fortran::lower::ComplexOpsBuilder<T>::getComplexPartType(
+    mlir::Type complexType) {
+  return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
+}
+template mlir::Type Fortran::lower::ComplexOpsBuilder<
+    Fortran::lower::FirOpBuilder>::getComplexPartType(mlir::Type);
+
+template <typename T>
+mlir::Type
+Fortran::lower::ComplexOpsBuilder<T>::getComplexPartType(mlir::Value cplx) {
+  return getComplexPartType(cplx.getType());
+}
+template mlir::Type Fortran::lower::ComplexOpsBuilder<
+    Fortran::lower::FirOpBuilder>::getComplexPartType(mlir::Value);
+
+template <typename T>
+mlir::Value Fortran::lower::ComplexOpsBuilder<T>::createComplex(
+    fir::KindTy kind, mlir::Value real, mlir::Value imag) {
+  auto complexTy = fir::CplxType::get(impl().getContext(), kind);
+  mlir::Value und = impl().template createHere<fir::UndefOp>(complexTy);
+  return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
+}
+template mlir::Value Fortran::lower::ComplexOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createComplex(fir::KindTy, mlir::Value,
+                                                 mlir::Value);
+
+template <typename T>
+mlir::Value Fortran::lower::ComplexOpsBuilder<T>::createComplexCompare(
+    mlir::Value cplx1, mlir::Value cplx2, bool eq) {
+  auto real1 = extract<Part::Real>(cplx1);
+  auto real2 = extract<Part::Real>(cplx2);
+  auto imag1 = extract<Part::Imag>(cplx1);
+  auto imag2 = extract<Part::Imag>(cplx2);
+
+  mlir::CmpFPredicate predicate =
+      eq ? mlir::CmpFPredicate::UEQ : mlir::CmpFPredicate::UNE;
+  auto &b = impl();
+  mlir::Value realCmp =
+      b.template createHere<mlir::CmpFOp>(predicate, real1, real2);
+  mlir::Value imagCmp =
+      b.template createHere<mlir::CmpFOp>(predicate, imag1, imag2);
+
+  return eq ? b.template createHere<mlir::AndOp>(realCmp, imagCmp).getResult()
+            : b.template createHere<mlir::OrOp>(realCmp, imagCmp).getResult();
+}
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index eee8ffd670ce..fefc7781dde1 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -10,7 +10,7 @@
 #include "../../runtime/io-api.h"
 #include "RTBuilder.h"
 #include "flang/Lower/Bridge.h"
-#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Parser/parse-tree.h"
@@ -93,21 +93,20 @@ inline int64_t getLength(mlir::Type argTy) {
 
 /// Get (or generate) the MLIR FuncOp for a given IO runtime function.
 template <typename E>
-mlir::FuncOp getIORuntimeFunc(mlir::OpBuilder &builder) {
-  mlir::ModuleOp module = getModule(&builder);
+mlir::FuncOp getIORuntimeFunc(Fortran::lower::FirOpBuilder &builder) {
   auto name = getName<E>();
-  auto func = getNamedFunction(module, name);
+  auto func = builder.getNamedFunction(name);
   if (func)
     return func;
   auto funTy = getTypeModel<E>()(builder.getContext());
-  func = createFunction(module, name, funTy);
+  func = builder.createFunction(name, funTy);
   func.setAttr("fir.runtime", builder.getUnitAttr());
   func.setAttr("fir.io", builder.getUnitAttr());
   return func;
 }
 
 /// Generate a call to end an IO statement
-mlir::Value genEndIO(mlir::OpBuilder &builder, mlir::Location loc,
+mlir::Value genEndIO(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
                      mlir::Value cookie) {
   // Terminate IO
   auto endIOFunc = getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder);
@@ -133,7 +132,7 @@ FormatItems lowerFormat(AbstractConverter &converter,
   return formatItems;
 }
 
-mlir::FuncOp getOutputRuntimeFunc(mlir::OpBuilder &builder, mlir::Type type) {
+mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder, mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
     if (ty.getWidth() == 1)
       return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
@@ -158,7 +157,7 @@ mlir::FuncOp getOutputRuntimeFunc(mlir::OpBuilder &builder, mlir::Type type) {
 /// The I/O library interface requires that COMPLEX and CHARACTER typed values
 /// be extracted and passed as separate values.
 llvm::SmallVector<mlir::Value, 4>
-splitArguments(mlir::OpBuilder &builder, mlir::Location loc, mlir::Value arg) {
+splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc, mlir::Value arg) {
   mlir::Value zero;
   mlir::Value one;
   mlir::Type argTy = arg.getType();
@@ -203,7 +202,7 @@ splitArguments(mlir::OpBuilder &builder, mlir::Location loc, mlir::Value arg) {
 
 /// Generate a call to an Output I/O function.
 /// The specific call is determined dynamically by the argument type.
-void genOutputRuntimeFunc(mlir::OpBuilder &builder, mlir::Location loc,
+void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
                           mlir::Type argType, mlir::Value cookie,
                           llvm::SmallVector<mlir::Value, 4> &operands) {
   int i = 1;
@@ -221,7 +220,7 @@ void lowerPrintStatement(AbstractConverter &converter, mlir::Location loc,
                          mlir::ValueRange args,
                          const Fortran::parser::Format &format) {
   mlir::FuncOp beginFunc;
-  mlir::OpBuilder &builder = converter.getOpBuilder();
+  Fortran::lower::FirOpBuilder &builder = converter.getFirOpBuilder();
   auto formatItems = lowerFormat(converter, format);
   if (formatItems.has_value()) {
     // has a format
@@ -274,7 +273,7 @@ mlir::Value lowerErrorHandlingPositionOrFlush(
     AbstractConverter &converter, mlir::Value endRes,
     const std::list<Fortran::parser::PositionOrFlushSpec> &specs) {
   mlir::Value result;
-  auto builder = converter.getOpBuilder();
+  auto builder = converter.getFirOpBuilder();
   auto loc = converter.getCurrentLocation();
   for (auto &sp : specs) {
     std::visit(
@@ -317,7 +316,7 @@ mlir::Value lowerErrorHandlingPositionOrFlush(
 /// This is templatized with a statement type `S` and a key `K` for genericity.
 template <typename K, typename S>
 mlir::Value genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
-  auto builder = converter.getOpBuilder();
+  auto builder = converter.getFirOpBuilder();
   auto loc = converter.getCurrentLocation();
   auto beginFunc = getIORuntimeFunc<K>(builder);
   auto args = lowerBeginArgsPositionOrFlush(converter, loc, stmt.v);
@@ -351,7 +350,7 @@ mlir::Value genRewindStatement(AbstractConverter &converter,
 
 mlir::Value genOpenStatement(AbstractConverter &converter,
                              const Fortran::parser::OpenStmt &) {
-  auto builder = converter.getOpBuilder();
+  auto builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
@@ -363,7 +362,7 @@ mlir::Value genOpenStatement(AbstractConverter &converter,
 
 mlir::Value genCloseStatement(AbstractConverter &converter,
                               const Fortran::parser::CloseStmt &) {
-  auto builder = converter.getOpBuilder();
+  auto builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc = getIORuntimeFunc<mkIOKey(BeginClose)>(builder);
   (void)beginFunc;
   TODO();
@@ -388,7 +387,7 @@ void genPrintStatement(AbstractConverter &converter,
 
 mlir::Value genReadStatement(AbstractConverter &converter,
                              const Fortran::parser::ReadStmt &) {
-  auto builder = converter.getOpBuilder();
+  auto builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
@@ -399,7 +398,7 @@ mlir::Value genReadStatement(AbstractConverter &converter,
 
 mlir::Value genWriteStatement(AbstractConverter &converter,
                               const Fortran::parser::WriteStmt &) {
-  auto builder = converter.getOpBuilder();
+  auto builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
@@ -410,7 +409,7 @@ mlir::Value genWriteStatement(AbstractConverter &converter,
 
 mlir::Value genInquireStatement(AbstractConverter &converter,
                                 const Fortran::parser::InquireStmt &) {
-  auto builder = converter.getOpBuilder();
+  auto builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(builder);
diff --git a/lib/Lower/Intrinsics.cpp b/lib/Lower/Intrinsics.cpp
index 94731e85c326..a535ed63dbf1 100644
--- a/lib/Lower/Intrinsics.cpp
+++ b/lib/Lower/Intrinsics.cpp
@@ -5,22 +5,28 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+//
+// Builder routines for constructing the FIR dialect of MLIR. As FIR is a
+// dialect of MLIR, it makes extensive use of MLIR interfaces and MLIR's coding
+// style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
+// module.
+//
+//===----------------------------------------------------------------------===//
 
 #include "flang/Lower/Intrinsics.h"
 #include "flang/Lower/ConvertType.h"
-#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <string>
-#include <unordered_map>
+#include <unordered_map> // FIXME: not allowed in LLVM?
 #include <utility>
 
-/// [Coding style](https://llvm.org/docs/CodingStandards.html)
-
 namespace Fortran::lower {
 
 /// MathRuntimeLibrary maps Fortran generic intrinsic names to runtime function
@@ -56,11 +62,12 @@ class MathRuntimeLibrary {
   /// related mlir::FuncOp if a runtime description is found.
   /// Also add a unit attribute "fir.runtime" to the function so that later
   /// it is possible to quickly know what function are intrinsics vs users.
-  llvm::Optional<mlir::FuncOp> getFunction(mlir::OpBuilder &, llvm::StringRef,
+  llvm::Optional<mlir::FuncOp> getFunction(Fortran::lower::FirOpBuilder &,
+                                           llvm::StringRef,
                                            mlir::FunctionType) const;
 
 private:
-  mlir::FuncOp getFuncOp(mlir::OpBuilder &builder,
+  mlir::FuncOp getFuncOp(Fortran::lower::FirOpBuilder &builder,
                          const RuntimeFunction &runtime) const;
   Map library;
 };
@@ -127,7 +134,8 @@ enum class ExtremumBehavior {
 class IntrinsicLibrary::Implementation {
 public:
   Implementation(Version v, mlir::MLIRContext &c) : runtime{v, c} {}
-  inline mlir::Value genval(mlir::Location loc, mlir::OpBuilder &builder,
+  inline mlir::Value genval(mlir::Location loc,
+                            Fortran::lower::FirOpBuilder &builder,
                             llvm::StringRef name, mlir::Type resultType,
                             llvm::ArrayRef<mlir::Value> args);
 
@@ -136,14 +144,12 @@ class IntrinsicLibrary::Implementation {
   // signatures modification easy.
   struct Context {
     mlir::Location loc;
-    mlir::OpBuilder *builder = nullptr;
+    Fortran::lower::FirOpBuilder *builder = nullptr;
     llvm::StringRef name;
     llvm::ArrayRef<mlir::Value> arguments;
     mlir::FunctionType funcType;
-    mlir::ModuleOp getModuleOp() { return getModule(builder); }
-    mlir::MLIRContext *getMLIRContext() {
-      return getModule(builder).getContext();
-    }
+    mlir::ModuleOp getModuleOp() { return builder->getModule(); }
+    mlir::MLIRContext *getMLIRContext() { return getModuleOp().getContext(); }
     mlir::Type getResultType() {
       assert(funcType.getNumResults() == 1);
       return funcType.getResult(0);
@@ -211,7 +217,7 @@ static std::string getIntrinsicWrapperName(const llvm::StringRef &intrinsic,
                                            mlir::FunctionType funTy);
 static mlir::FunctionType getFunctionType(mlir::Type resultType,
                                           llvm::ArrayRef<mlir::Value> arguments,
-                                          mlir::OpBuilder &);
+                                          Fortran::lower::FirOpBuilder &);
 
 /// Define a simple static runtime description that will be transformed into
 /// RuntimeFunction when building the IntrinsicLibrary.
@@ -281,7 +287,7 @@ IntrinsicLibrary::IntrinsicLibrary(IntrinsicLibrary::Version v,
 IntrinsicLibrary::~IntrinsicLibrary() = default;
 
 mlir::Value IntrinsicLibrary::genval(mlir::Location loc,
-                                     mlir::OpBuilder &builder,
+                                     Fortran::lower::FirOpBuilder &builder,
                                      llvm::StringRef name,
                                      mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) const {
@@ -308,14 +314,10 @@ MathRuntimeLibrary::MathRuntimeLibrary(IntrinsicLibrary::Version,
 }
 
 mlir::FuncOp
-MathRuntimeLibrary::getFuncOp(mlir::OpBuilder &builder,
+MathRuntimeLibrary::getFuncOp(Fortran::lower::FirOpBuilder &builder,
                               const RuntimeFunction &runtime) const {
-  auto module = getModule(&builder);
-  auto function = getNamedFunction(module, runtime.symbol);
-  if (!function) {
-    function = createFunction(module, runtime.symbol, runtime.type);
-    function.setAttr("fir.runtime", builder.getUnitAttr());
-  }
+  auto function = builder.addNamedFunction(runtime.symbol, runtime.type);
+  function.setAttr("fir.runtime", builder.getUnitAttr());
   return function;
 }
 
@@ -454,7 +456,8 @@ class FunctionDistance {
 // function type and that will not imply narrowing arguments or extending the
 // result.
 llvm::Optional<mlir::FuncOp>
-MathRuntimeLibrary::getFunction(mlir::OpBuilder &builder, llvm::StringRef name,
+MathRuntimeLibrary::getFunction(Fortran::lower::FirOpBuilder &builder,
+                                llvm::StringRef name,
                                 mlir::FunctionType funcType) const {
   auto range = library.equal_range(name);
   const RuntimeFunction *bestNearMatch = nullptr;
@@ -482,8 +485,9 @@ MathRuntimeLibrary::getFunction(mlir::OpBuilder &builder, llvm::StringRef name,
 // IntrinsicLibrary::Implementation implementation
 
 mlir::Value IntrinsicLibrary::Implementation::genval(
-    mlir::Location loc, mlir::OpBuilder &builder, llvm::StringRef name,
-    mlir::Type resultType, llvm::ArrayRef<mlir::Value> args) {
+    mlir::Location loc, Fortran::lower::FirOpBuilder &builder,
+    llvm::StringRef name, mlir::Type resultType,
+    llvm::ArrayRef<mlir::Value> args) {
   Context context{loc, &builder, name, args,
                   getFunctionType(resultType, args, builder)};
   for (auto &handler : handlers) {
@@ -497,16 +501,16 @@ mlir::Value IntrinsicLibrary::Implementation::genval(
   return defaultGenerator(context, runtime);
 }
 
-static mlir::FunctionType getFunctionType(mlir::Type resultType,
-                                          llvm::ArrayRef<mlir::Value> arguments,
-                                          mlir::OpBuilder &builder) {
+static mlir::FunctionType
+getFunctionType(mlir::Type resultType, llvm::ArrayRef<mlir::Value> arguments,
+                Fortran::lower::FirOpBuilder &builder) {
   llvm::SmallVector<mlir::Type, 2> argumentTypes;
   for (auto &arg : arguments) {
     assert(arg != nullptr); // TODO think about optionals
     argumentTypes.push_back(arg.getType());
   }
   return mlir::FunctionType::get(argumentTypes, resultType,
-                                 getModule(&builder).getContext());
+                                 builder.getModule().getContext());
 }
 
 // TODO find nicer type to string infra or move this in a mangling utility
@@ -533,13 +537,15 @@ static std::string typeToString(mlir::Type t) {
   assert(false && "no mangling for type");
   return ""s;
 }
+
 static std::string getIntrinsicWrapperName(const llvm::StringRef &intrinsic,
                                            mlir::FunctionType funTy) {
+  // TODO: use Twine here?
   std::string name{"fir." + intrinsic.str() + "."};
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
   name += typeToString(funTy.getResult(0));
-  auto e{funTy.getNumInputs()};
-  for (decltype(e) i{0}; i < e; ++i) {
+  auto e = funTy.getNumInputs();
+  for (decltype(e) i = 0; i < e; ++i) {
     name += "." + typeToString(funTy.getInput(i));
   }
   return name;
@@ -547,28 +553,29 @@ static std::string getIntrinsicWrapperName(const llvm::StringRef &intrinsic,
 
 mlir::Value IntrinsicLibrary::Implementation::outlineInWrapper(
     Generator generator, Context &context, MathRuntimeLibrary &runtime) {
-  auto module = getModule(context.builder);
+  auto *builder = context.builder;
+  auto module = builder->getModule();
   auto *mlirContext = module.getContext();
   std::string wrapperName =
       getIntrinsicWrapperName(context.name, context.funcType);
-  auto function = getNamedFunction(module, wrapperName);
+  auto function = builder->getNamedFunction(wrapperName);
   if (!function) {
     // First time this wrapper is needed, build it.
-    function = createFunction(module, wrapperName, context.funcType);
-    function.setAttr("fir.intrinsic", context.builder->getUnitAttr());
+    function = builder->createFunction(wrapperName, context.funcType);
+    function.setAttr("fir.intrinsic", builder->getUnitAttr());
     function.addEntryBlock();
 
     // Create local context to emit code into the newly created function
     // This new function is not linked to a source file location, only
     // its calls will be.
-    Context localContext{context};
-    auto localBuilder = std::make_unique<mlir::OpBuilder>(function);
+    Context localContext = context;
+    auto localBuilder =
+        std::make_unique<Fortran::lower::FirOpBuilder>(function);
     localBuilder->setInsertionPointToStart(&function.front());
     localContext.builder = &(*localBuilder);
     llvm::SmallVector<mlir::Value, 2> localArguments;
-    for (mlir::BlockArgument bArg : function.front().getArguments()) {
+    for (mlir::BlockArgument bArg : function.front().getArguments())
       localArguments.push_back(bArg);
-    }
     localContext.arguments = localArguments;
     localContext.loc = mlir::UnknownLoc::get(mlirContext);
 
@@ -578,8 +585,8 @@ mlir::Value IntrinsicLibrary::Implementation::outlineInWrapper(
     // Wrapper was already built, ensure it has the sought type
     assert(function.getType() == context.funcType);
   }
-  auto call = context.builder->create<mlir::CallOp>(context.loc, function,
-                                                    context.arguments);
+  auto call =
+      builder->create<mlir::CallOp>(context.loc, function, context.arguments);
   return call.getResult(0);
 }
 
@@ -635,15 +642,16 @@ IntrinsicLibrary::Implementation::genRuntimeCall(Context &context,
 mlir::Value IntrinsicLibrary::Implementation::genConjg(Context &genCtxt,
                                                        MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 1);
-  [[maybe_unused]] mlir::Type resType = genCtxt.getResultType();
-  assert(resType == genCtxt.arguments[0].getType());
-  mlir::OpBuilder &builder = *genCtxt.builder;
-  ComplexOpsBuilder cplxHandler(builder, genCtxt.loc);
+  mlir::Type resType = genCtxt.getResultType();
+  if (resType != genCtxt.arguments[0].getType())
+    llvm_unreachable("argument type mismatch");
+  Fortran::lower::FirOpBuilder &builder = *genCtxt.builder;
+  builder.setLocation(genCtxt.loc);
 
   mlir::Value cplx = genCtxt.arguments[0];
-  mlir::Value imag = cplxHandler.extract<ComplexOpsBuilder::Part::Imag>(cplx);
-  mlir::Value negImag = genCtxt.builder->create<fir::NegfOp>(genCtxt.loc, imag);
-  return cplxHandler.insert<ComplexOpsBuilder::Part::Imag>(cplx, negImag);
+  auto imag = builder.extractComplexPart(cplx, /*isImagPart=*/true);
+  auto negImag = builder.create<fir::NegfOp>(genCtxt.loc, imag);
+  return builder.insertComplexPart(cplx, negImag, /*isImagPart=*/true);
 }
 
 // MERGE
@@ -651,7 +659,7 @@ mlir::Value IntrinsicLibrary::Implementation::genMerge(Context &genCtxt,
                                                        MathRuntimeLibrary &) {
   assert(genCtxt.arguments.size() == 3);
   [[maybe_unused]] auto resType = genCtxt.getResultType();
-  mlir::OpBuilder &builder = *genCtxt.builder;
+  Fortran::lower::FirOpBuilder &builder = *genCtxt.builder;
 
   auto &trueVal = genCtxt.arguments[0];
   auto &falseVal = genCtxt.arguments[1];
@@ -664,7 +672,7 @@ mlir::Value IntrinsicLibrary::Implementation::genMerge(Context &genCtxt,
 // Compare two FIR values and return boolean result as i1.
 template <Extremum extremum, ExtremumBehavior behavior>
 static mlir::Value createExtremumCompare(mlir::Location loc,
-                                         mlir::OpBuilder &builder,
+                                         Fortran::lower::FirOpBuilder &builder,
                                          mlir::Value left, mlir::Value right) {
   static constexpr auto integerPredicate = extremum == Extremum::Max
                                                ? mlir::CmpIPredicate::sgt
diff --git a/lib/Lower/OpBuilder.cpp b/lib/Lower/OpBuilder.cpp
deleted file mode 100644
index 933d9e2d521a..000000000000
--- a/lib/Lower/OpBuilder.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-//===-- OpBuilder.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/Lower/OpBuilder.h"
-#include "flang/Lower/Bridge.h"
-#include "flang/Lower/ConvertType.h"
-#include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
-#include "mlir/IR/Module.h"
-#include "mlir/IR/Value.h"
-#include "llvm/ADT/StringRef.h"
-
-mlir::FuncOp
-Fortran::lower::createFunction(Fortran::lower::AbstractConverter &converter,
-                               llvm::StringRef name,
-                               mlir::FunctionType funcTy) {
-  return fir::createFuncOp(converter.getCurrentLocation(),
-                           converter.getModuleOp(), name, funcTy);
-}
-
-mlir::FuncOp Fortran::lower::createFunction(mlir::ModuleOp module,
-                                            llvm::StringRef name,
-                                            mlir::FunctionType funcTy) {
-  return fir::createFuncOp(mlir::UnknownLoc::get(module.getContext()), module,
-                           name, funcTy);
-}
-
-mlir::FuncOp Fortran::lower::getNamedFunction(mlir::ModuleOp module,
-                                              llvm::StringRef name) {
-  return module.lookupSymbol<mlir::FuncOp>(name);
-}
-
-void Fortran::lower::SymMap::addSymbol(Fortran::semantics::SymbolRef symbol,
-                                       mlir::Value value) {
-  symbolMap.try_emplace(&*symbol, value);
-}
-
-mlir::Value
-Fortran::lower::SymMap::lookupSymbol(Fortran::semantics::SymbolRef symbol) {
-  auto iter{symbolMap.find(&*symbol)};
-  return (iter == symbolMap.end()) ? nullptr : iter->second;
-}
-
-void Fortran::lower::SymMap::pushShadowSymbol(semantics::SymbolRef symbol,
-                                              mlir::Value value) {
-  auto iter{symbolMap.find(&*symbol)}; // existing mapping, if any
-  mlir::Value originalValue;
-  if (iter != symbolMap.end()) {
-    originalValue = iter->second;
-    symbolMap.erase(iter);
-  }
-  shadowStack.emplace_back(&*symbol, originalValue); // save original value
-  symbolMap.try_emplace(&*symbol, value);            // update to new value
-}
-
-void Fortran::lower::SymMap::popShadowSymbol() {
-  assert(!shadowStack.empty() && "shadow stack underflow");
-  auto &pair{shadowStack.back()};
-  assert(pair.first && "missing pop symbol");
-  if (pair.second) {
-    symbolMap[pair.first] = pair.second; // reinstate original value
-  } else {
-    auto iter{symbolMap.find(pair.first)};
-    assert(iter != symbolMap.end() && "missing pop symbol mapping");
-    symbolMap.erase(iter); // remove shadow symbol
-  }
-  shadowStack.pop_back();
-}
-
-mlir::Value
-Fortran::lower::OpBuilderWrapper::createIntegerConstant(mlir::Type integerType,
-                                                        std::int64_t cst) {
-  return create<mlir::ConstantOp>(integerType,
-                                  builder.getIntegerAttr(integerType, cst));
-}
-
-// LoopBuilder implementation
-
-void Fortran::lower::LoopBuilder::createLoop(
-    mlir::Value lb, mlir::Value ub, mlir::Value step,
-    const BodyGenerator &bodyGenerator) {
-  auto lbi{convertToIndexType(lb)};
-  auto ubi{convertToIndexType(ub)};
-  llvm::SmallVector<mlir::Value, 1> steps;
-  if (step) {
-    auto stepi{convertToIndexType(step)};
-    steps.emplace_back(stepi);
-  }
-  auto loop{create<fir::LoopOp>(lbi, ubi, steps)};
-  auto *insPt{builder.getInsertionBlock()};
-  builder.setInsertionPointToStart(loop.getBody());
-  auto index{loop.getInductionVar()};
-  bodyGenerator(*this, index);
-  builder.setInsertionPointToEnd(insPt);
-}
-
-void Fortran::lower::LoopBuilder::createLoop(
-    mlir::Value lb, mlir::Value ub, const BodyGenerator &bodyGenerator) {
-  auto one{createIntegerConstant(getIndexType(), 1)};
-  createLoop(lb, ub, one, bodyGenerator);
-}
-
-void Fortran::lower::LoopBuilder::createLoop(
-    mlir::Value count, const BodyGenerator &bodyGenerator) {
-  auto indexType{getIndexType()};
-  auto zero{createIntegerConstant(indexType, 0)};
-  auto one{createIntegerConstant(indexType, 1)};
-  createLoop(zero, count, one, bodyGenerator);
-}
-
-mlir::Type Fortran::lower::LoopBuilder::getIndexType() {
-  return mlir::IndexType::get(builder.getContext());
-}
-
-mlir::Value
-Fortran::lower::LoopBuilder::convertToIndexType(mlir::Value integer) {
-  auto type{integer.getType()};
-  if (type.isa<mlir::IndexType>()) {
-    return integer;
-  }
-  assert((type.isa<mlir::IntegerType>() || type.isa<fir::IntType>()) &&
-         "expected integer");
-  return create<fir::ConvertOp>(getIndexType(), integer);
-}
-
-// CharacterOpsBuilder implementation
-
-void Fortran::lower::CharacterOpsBuilder::createCopy(CharValue &dest,
-                                                     CharValue &src,
-                                                     mlir::Value count) {
-  auto refType{dest.getReferenceType()};
-  // Cast to character sequence reference type for fir::CoordinateOp.
-  auto sequenceType{getSequenceRefType(refType)};
-  auto destRef{create<fir::ConvertOp>(sequenceType, dest.reference)};
-  auto srcRef{create<fir::ConvertOp>(sequenceType, src.reference)};
-
-  LoopBuilder{*this}.createLoop(count, [&](OpBuilderWrapper &handler,
-                                           mlir::Value index) {
-    auto destAddr{handler.create<fir::CoordinateOp>(refType, destRef, index)};
-    auto srcAddr{handler.create<fir::CoordinateOp>(refType, srcRef, index)};
-    auto val{handler.create<fir::LoadOp>(srcAddr)};
-    handler.create<fir::StoreOp>(val, destAddr);
-  });
-}
-
-void Fortran::lower::CharacterOpsBuilder::createPadding(CharValue &str,
-                                                        mlir::Value lower,
-                                                        mlir::Value upper) {
-  auto refType{str.getReferenceType()};
-  auto sequenceType{getSequenceRefType(refType)};
-  auto strRef{create<fir::ConvertOp>(sequenceType, str.reference)};
-  auto blank{createBlankConstant(str.getCharacterType())};
-
-  LoopBuilder{*this}.createLoop(
-      lower, upper, [&](OpBuilderWrapper &handler, mlir::Value index) {
-        auto strAddr{handler.create<fir::CoordinateOp>(refType, strRef, index)};
-        handler.create<fir::StoreOp>(blank, strAddr);
-      });
-}
-
-mlir::Value Fortran::lower::CharacterOpsBuilder::createBlankConstant(
-    fir::CharacterType type) {
-  auto byteTy{mlir::IntegerType::get(8, builder.getContext())};
-  auto asciiSpace{createIntegerConstant(byteTy, 0x20)};
-  return create<fir::ConvertOp>(type, asciiSpace);
-}
-
-Fortran::lower::CharacterOpsBuilder::CharValue
-Fortran::lower::CharacterOpsBuilder::createTemp(fir::CharacterType type,
-                                                mlir::Value len) {
-  // FIXME Does this need to be emitted somewhere safe ?
-  // convert-expr.cc generates alloca at the beginning of the mlir block.
-  return CharValue{create<fir::AllocaOp>(type, len), len};
-}
-
-fir::ReferenceType
-Fortran::lower::CharacterOpsBuilder::CharValue::getReferenceType() {
-  auto type{reference.getType().dyn_cast<fir::ReferenceType>()};
-  assert(type && "expected reference type");
-  return type;
-}
-
-fir::CharacterType
-Fortran::lower::CharacterOpsBuilder::CharValue::getCharacterType() {
-  auto type{getReferenceType().getEleTy().dyn_cast<fir::CharacterType>()};
-  assert(type && "expected character type");
-  return type;
-}
-
-// ComplexOpsBuilder implementation
-
-mlir::Type
-Fortran::lower::ComplexOpsBuilder::getComplexPartType(fir::KindTy complexKind) {
-  return convertReal(builder.getContext(), complexKind);
-}
-mlir::Type
-Fortran::lower::ComplexOpsBuilder::getComplexPartType(mlir::Type complexType) {
-  return getComplexPartType(complexType.cast<fir::CplxType>().getFKind());
-}
-mlir::Type
-Fortran::lower::ComplexOpsBuilder::getComplexPartType(mlir::Value cplx) {
-  assert(cplx != nullptr);
-  return getComplexPartType(cplx.getType());
-}
-
-mlir::Value Fortran::lower::ComplexOpsBuilder::createComplex(fir::KindTy kind,
-                                                             mlir::Value real,
-                                                             mlir::Value imag) {
-  mlir::Type complexTy{fir::CplxType::get(builder.getContext(), kind)};
-  mlir::Value und{create<fir::UndefOp>(complexTy)};
-  return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
-}
-
-using CplxPart = Fortran::lower::ComplexOpsBuilder::Part;
-template <CplxPart partId>
-mlir::Value Fortran::lower::ComplexOpsBuilder::createPartId() {
-  auto type{mlir::IntegerType::get(32, builder.getContext())};
-  return createIntegerConstant(type, static_cast<int>(partId));
-}
-
-template <CplxPart partId>
-mlir::Value Fortran::lower::ComplexOpsBuilder::extract(mlir::Value cplx) {
-  return create<fir::ExtractValueOp>(getComplexPartType(cplx), cplx,
-                                     createPartId<partId>());
-}
-template mlir::Value
-    Fortran::lower::ComplexOpsBuilder::extract<CplxPart::Real>(mlir::Value);
-template mlir::Value
-    Fortran::lower::ComplexOpsBuilder::extract<CplxPart::Imag>(mlir::Value);
-
-template <CplxPart partId>
-mlir::Value Fortran::lower::ComplexOpsBuilder::insert(mlir::Value cplx,
-                                                      mlir::Value part) {
-  assert(cplx != nullptr);
-  return create<fir::InsertValueOp>(cplx.getType(), cplx, part,
-                                    createPartId<partId>());
-}
-template mlir::Value
-    Fortran::lower::ComplexOpsBuilder::insert<CplxPart::Real>(mlir::Value,
-                                                              mlir::Value);
-template mlir::Value
-    Fortran::lower::ComplexOpsBuilder::insert<CplxPart::Imag>(mlir::Value,
-                                                              mlir::Value);
-
-mlir::Value
-Fortran::lower::ComplexOpsBuilder::extractComplexPart(mlir::Value cplx,
-                                                      bool isImagPart) {
-  return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
-}
-
-mlir::Value Fortran::lower::ComplexOpsBuilder::insertComplexPart(
-    mlir::Value cplx, mlir::Value part, bool isImagPart) {
-  return isImagPart ? insert<Part::Imag>(cplx, part)
-                    : insert<Part::Real>(cplx, part);
-}
-
-mlir::Value Fortran::lower::ComplexOpsBuilder::createComplexCompare(
-    mlir::Value cplx1, mlir::Value cplx2, bool eq) {
-  mlir::Value real1{extract<Part::Real>(cplx1)};
-  mlir::Value real2{extract<Part::Real>(cplx2)};
-  mlir::Value imag1{extract<Part::Imag>(cplx1)};
-  mlir::Value imag2{extract<Part::Imag>(cplx2)};
-
-  mlir::CmpFPredicate predicate{eq ? mlir::CmpFPredicate::UEQ
-                                   : mlir::CmpFPredicate::UNE};
-  mlir::Value realCmp{create<mlir::CmpFOp>(predicate, real1, real2)};
-  mlir::Value imagCmp{create<mlir::CmpFOp>(predicate, imag1, imag2)};
-
-  return eq ? create<mlir::AndOp>(realCmp, imagCmp).getResult()
-            : create<mlir::OrOp>(realCmp, imagCmp).getResult();
-}
diff --git a/lib/Lower/Runtime.cpp b/lib/Lower/Runtime.cpp
index 0759299e5011..9420dfc595e9 100644
--- a/lib/Lower/Runtime.cpp
+++ b/lib/Lower/Runtime.cpp
@@ -7,11 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/Runtime.h"
-#include "flang/Lower/OpBuilder.h"
+#include "flang/Lower/FIRBuilder.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 
 namespace Fortran::lower {
@@ -40,7 +41,7 @@ mlir::Type RuntimeStaticDescription::getMLIRType(TypeCode t,
   case TypeCode::IOCookie:
     return fir::ReferenceType::get(mlir::IntegerType::get(64, context));
   }
-  assert(false && "bug");
+  llvm_unreachable("bug");
   return {};
 }
 
@@ -57,17 +58,14 @@ mlir::FunctionType RuntimeStaticDescription::getMLIRFunctionType(
   return mlir::FunctionType::get(argMLIRTypes, {}, context);
 }
 
-mlir::FuncOp
-RuntimeStaticDescription::getFuncOp(mlir::OpBuilder &builder) const {
-  mlir::ModuleOp module{getModule(&builder)};
-  mlir::FunctionType funTy{getMLIRFunctionType(module.getContext())};
-  auto function{getNamedFunction(module, symbol)};
-  if (!function) {
-    function = createFunction(module, symbol, funTy);
-    function.setAttr("fir.runtime", builder.getUnitAttr());
-  } else {
-    assert(funTy == function.getType() && "conflicting runtime declaration");
-  }
+mlir::FuncOp RuntimeStaticDescription::getFuncOp(
+    Fortran::lower::FirOpBuilder &builder) const {
+  auto module = builder.getModule();
+  auto funTy = getMLIRFunctionType(module.getContext());
+  auto function = builder.addNamedFunction(symbol, funTy);
+  function.setAttr("fir.runtime", builder.getUnitAttr());
+  if (funTy != function.getType())
+    llvm_unreachable("runtime function type mismatch");
   return function;
 }
 
@@ -80,27 +78,31 @@ class RuntimeEntryDescription : public RuntimeStaticDescription {
   Key key;
 };
 
-using RT = RuntimeStaticDescription;
-using RType = typename RT::TypeCode;
-using Args = typename RT::TypeCodeVector;
-using RTC = RuntimeEntryCode;
-
 static constexpr RuntimeEntryDescription runtimeTable[]{
-    {RTC::StopStatement, "StopStatement", RT::voidTy,
-     Args::create<RType::i32, RType::boolean, RType::boolean>()},
-    {RTC::StopStatementText, "StopStatementText", RT::voidTy,
-     Args::create<RType::charPtr, RType::i32, RType::boolean,
-                  RType::boolean>()},
-    {RTC::FailImageStatement, "StopStatementText", RT::voidTy,
-     Args::create<>()},
+    {RuntimeEntryCode::StopStatement, "StopStatement",
+     RuntimeStaticDescription::voidTy,
+     RuntimeStaticDescription::TypeCodeVector::create<
+         RuntimeStaticDescription::TypeCode::i32,
+         RuntimeStaticDescription::TypeCode::boolean,
+         RuntimeStaticDescription::TypeCode::boolean>()},
+    {RuntimeEntryCode::StopStatementText, "StopStatementText",
+     RuntimeStaticDescription::voidTy,
+     RuntimeStaticDescription::TypeCodeVector::create<
+         RuntimeStaticDescription::TypeCode::charPtr,
+         RuntimeStaticDescription::TypeCode::i32,
+         RuntimeStaticDescription::TypeCode::boolean,
+         RuntimeStaticDescription::TypeCode::boolean>()},
+    {RuntimeEntryCode::FailImageStatement, "StopStatementText",
+     RuntimeStaticDescription::voidTy,
+     RuntimeStaticDescription::TypeCodeVector::create<>()},
 };
 
 static constexpr StaticMultimapView<RuntimeEntryDescription> runtimeMap{
     runtimeTable};
 
 mlir::FuncOp genRuntimeFunction(RuntimeEntryCode code,
-                                mlir::OpBuilder &builder) {
-  auto description{runtimeMap.find(code)};
+                                Fortran::lower::FirOpBuilder &builder) {
+  auto description = runtimeMap.find(code);
   assert(description != runtimeMap.end());
   return description->getFuncOp(builder);
 }
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
index b6dd9edb2a2f..9a56c6bc403e 100644
--- a/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -25,7 +25,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
   addOperations<
 #define GET_OP_LIST
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
-                >();
+      >();
 }
 
 // anchor the class vtable to this compilation unit
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index c1e6d7495dd7..132a3607478c 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -369,26 +369,57 @@ mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
 
 void fir::LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
                         int64_t lowerBound, int64_t upperBound, int64_t step,
+                        bool unordered,
                         llvm::ArrayRef<mlir::NamedAttribute> attributes) {
-  llvm_unreachable("not implemented");
+  mlir::Region *bodyRegion = result.addRegion();
+  LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
+  bodyRegion->front().addArgument(builder->getIndexType());
+  result.addAttribute(lowerAttrName(), builder->getI64IntegerAttr(lowerBound));
+  result.addAttribute(upperAttrName(), builder->getI64IntegerAttr(upperBound));
+  result.addAttribute(stepAttrName(), builder->getI64IntegerAttr(step));
+  if (unordered)
+    result.addAttribute(unorderedAttrName(), builder->getUnitAttr());
+  result.addAttributes(attributes);
 }
 
 void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
-                        mlir::Value lb, mlir::Value ub, ValueRange step,
+                        mlir::Value lb, mlir::Value ub, int64_t step,
+                        bool unordered, ArrayRef<NamedAttribute> attributes) {
+  result.addOperands({lb, ub});
+  mlir::Region *bodyRegion = result.addRegion();
+  LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
+  bodyRegion->front().addArgument(builder->getIndexType());
+  result.addAttribute(stepAttrName(), builder->getI64IntegerAttr(step));
+  if (unordered)
+    result.addAttribute(unorderedAttrName(), builder->getUnitAttr());
+  result.addAttributes(attributes);
+}
+
+void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
+                        mlir::Value lb, mlir::Value ub, bool unordered,
                         ArrayRef<NamedAttribute> attributes) {
-  if (step.empty())
-    result.addOperands({lb, ub});
-  else
-    result.addOperands({lb, ub, step[0]});
+  result.addOperands({lb, ub});
   mlir::Region *bodyRegion = result.addRegion();
   LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
   bodyRegion->front().addArgument(builder->getIndexType());
+  if (unordered)
+    result.addAttribute(unorderedAttrName(), builder->getUnitAttr());
   result.addAttributes(attributes);
-  NamedAttributeList attrs(attributes);
-  if (!attrs.get(unorderedAttrName()))
-    result.addTypes(builder->getIndexType());
 }
 
+void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
+                        mlir::Value lb, mlir::Value ub, mlir::Value step,
+                        bool unordered, ArrayRef<NamedAttribute> attributes) {
+  result.addOperands({lb, ub, step});
+  mlir::Region *bodyRegion = result.addRegion();
+  LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
+  bodyRegion->front().addArgument(builder->getIndexType());
+  if (unordered)
+    result.addAttribute(unorderedAttrName(), builder->getUnitAttr());
+  result.addAttributes(attributes);
+}
+
+/// Parse a `fir.loop` operation.
 static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
@@ -398,24 +429,53 @@ static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
     return mlir::failure();
 
   // Parse loop bounds.
+  // There is a constant form and an operand form.
   mlir::Type indexType = builder.getIndexType();
-  if (parser.parseOperand(lb) ||
-      parser.resolveOperand(lb, indexType, result.operands) ||
-      parser.parseKeyword("to") || parser.parseOperand(ub) ||
-      parser.resolveOperand(ub, indexType, result.operands))
-    return mlir::failure();
-
-  if (parser.parseOptionalKeyword(fir::LoopOp::stepAttrName())) {
-    result.addAttribute(fir::LoopOp::stepAttrName(),
-                        builder.getIntegerAttr(builder.getIndexType(), 1));
-  } else if (parser.parseOperand(step) ||
-             parser.resolveOperand(step, indexType, result.operands)) {
-    return mlir::failure();
+  if (mlir::succeeded(parser.parseOptionalLParen())) {
+    // constant iteration space form (with optional constant step):
+    // `(` int `)` `to` `(` int `)` [`step` `(` int `)`]
+    mlir::IntegerAttr lvalue;
+    mlir::IntegerAttr uvalue;
+    if (parser.parseAttribute(lvalue, fir::LoopOp::lowerAttrName(),
+                              result.attributes) ||
+        parser.parseRParen() || parser.parseKeyword("to") ||
+        parser.parseLParen() ||
+        parser.parseAttribute(uvalue, fir::LoopOp::upperAttrName(),
+                              result.attributes) ||
+        parser.parseRParen())
+      return mlir::failure();
+    if (mlir::succeeded(parser.parseOptionalKeyword("step"))) {
+      mlir::IntegerAttr value;
+      if (parser.parseLParen() ||
+          parser.parseAttribute(value, fir::LoopOp::stepAttrName(),
+                                result.attributes) ||
+          parser.parseRParen())
+        return mlir::failure();
+    }
+  } else {
+    // value iteration space form (with optional value or constant step):
+    // %lb `to` %ub [`step` (%sv | `(` int `)`)]
+    if (parser.parseOperand(lb) || parser.parseKeyword("to") ||
+        parser.parseOperand(ub) ||
+        parser.resolveOperands({lb, ub}, indexType, result.operands))
+      return mlir::failure();
+    if (mlir::succeeded(parser.parseOptionalKeyword("step"))) {
+      if (mlir::succeeded(parser.parseOptionalLParen())) {
+        mlir::IntegerAttr value;
+        if (parser.parseAttribute(value, fir::LoopOp::stepAttrName(),
+                                  result.attributes) ||
+            parser.parseRParen())
+          return mlir::failure();
+      } else if (parser.parseOperand(step) ||
+                 parser.resolveOperand(step, indexType, result.operands)) {
+        return mlir::failure();
+      }
+    }
   }
-
   // Parse the optional `unordered` keyword
   bool isUnordered = false;
-  if (!parser.parseOptionalKeyword(LoopOp::unorderedAttrName())) {
+  if (mlir::succeeded(
+          parser.parseOptionalKeyword(LoopOp::unorderedAttrName()))) {
     result.addAttribute(LoopOp::unorderedAttrName(), builder.getUnitAttr());
     isUnordered = true;
   }
@@ -430,8 +490,6 @@ static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return mlir::failure();
-  if (!isUnordered)
-    result.addTypes(builder.getIndexType());
   return mlir::success();
 }
 
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index d1fccd7be317..8730a3efa3bb 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -17,6 +17,7 @@
 #include "mlir/Parser.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/Support/ErrorHandling.h"
 
 using namespace fir;
 
@@ -181,7 +182,7 @@ SequenceType parseSequence(mlir::DialectAsmParser &parser, mlir::Location) {
   return SequenceType::get(shape, eleTy, map);
 }
 
-bool verifyIntegerType(mlir::Type ty) {
+static bool verifyIntegerType(mlir::Type ty) {
   return ty.isa<mlir::IntegerType>() || ty.isa<IntType>();
 }
 
@@ -1178,6 +1179,12 @@ llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4> recordTypeVisited;
 
 } // namespace
 
+void fir::verifyIntegralType(mlir::Type type) {
+  if (verifyIntegerType(type) || type.isa<mlir::IndexType>())
+    return;
+  llvm_unreachable("expected integral type");
+}
+
 void fir::printFirType(FIROpsDialect *, mlir::Type ty,
                        mlir::DialectAsmPrinter &p) {
   auto &os = p.getStream();
diff --git a/lib/Optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
index e63d5b39a844..e8b818cb27ef 100644
--- a/lib/Optimizer/Support/InternalNames.cpp
+++ b/lib/Optimizer/Support/InternalNames.cpp
@@ -11,31 +11,26 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 
-namespace {
-
-const std::int64_t BAD_VALUE = -1;
+constexpr std::int64_t BAD_VALUE = -1;
 
 inline llvm::StringRef prefix() { return "_Q"; }
 
-std::string doModules(llvm::ArrayRef<llvm::StringRef> mods) {
-  std::string result;
+static std::string doModules(llvm::ArrayRef<llvm::StringRef> mods) {
+  llvm::Twine result;
   auto *token = "M";
   for (auto mod : mods) {
-    llvm::Twine t = result + token + mod;
-    result = t.str();
+    result.concat(token).concat(mod);
     token = "S";
   }
-  return result;
+  return result.str();
 }
 
-std::string doModulesHost(llvm::ArrayRef<llvm::StringRef> mods,
-                          llvm::Optional<llvm::StringRef> host) {
-  auto result = doModules(mods);
-  if (host.hasValue()) {
-    llvm::Twine t = result + "F" + *host;
-    result = t.str();
-  }
-  return result;
+static std::string doModulesHost(llvm::ArrayRef<llvm::StringRef> mods,
+                                 llvm::Optional<llvm::StringRef> host) {
+  llvm::Twine result(doModules(mods));
+  if (host.hasValue())
+    result.concat("F").concat(*host);
+  return result.str();
 }
 
 inline llvm::SmallVector<llvm::StringRef, 2>
@@ -51,16 +46,16 @@ convertToStringRef(const llvm::Optional<std::string> &from) {
   return to;
 }
 
-std::string readName(llvm::StringRef uniq, std::size_t &i, std::size_t init,
-                     std::size_t end) {
+static std::string readName(llvm::StringRef uniq, std::size_t &i,
+                            std::size_t init, std::size_t end) {
   for (i = init; i < end && uniq[i] >= 'a' && uniq[i] <= 'z'; ++i) {
     // do nothing
   }
   return uniq.substr(init, i).str();
 }
 
-std::int64_t readInt(llvm::StringRef uniq, std::size_t &i, std::size_t init,
-                     std::size_t end) {
+static std::int64_t readInt(llvm::StringRef uniq, std::size_t &i,
+                            std::size_t init, std::size_t end) {
   for (i = init; i < end && uniq[i] >= '0' && uniq[i] <= '9'; ++i) {
     // do nothing
   }
@@ -70,8 +65,6 @@ std::int64_t readInt(llvm::StringRef uniq, std::size_t &i, std::size_t init,
   return result;
 }
 
-} // namespace
-
 llvm::StringRef fir::NameUniquer::toLower(llvm::StringRef name) {
   auto lo = name.lower();
   if (name.equals(lo))
@@ -84,12 +77,10 @@ llvm::StringRef fir::NameUniquer::addAsString(std::int64_t i) {
 }
 
 std::string fir::NameUniquer::doKind(std::int64_t kind) {
-  if (kind < 0) {
-    llvm::Twine result = "KN" + addAsString(-kind);
-    return result.str();
-  }
-  llvm::Twine result = "K" + addAsString(kind);
-  return result.str();
+  llvm::Twine result("K");
+  if (kind < 0)
+    return result.concat("N").concat(addAsString(-kind)).str();
+  return result.concat(addAsString(kind)).str();
 }
 
 std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
@@ -100,15 +91,14 @@ std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
 }
 
 std::string fir::NameUniquer::doCommonBlock(llvm::StringRef name) {
-  llvm::Twine result = prefix() + "B" + toLower(name);
-  return result.str();
+  return llvm::Twine(prefix()).concat("B").concat(toLower(name)).str();
 }
 
 std::string
 fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                              llvm::StringRef name) {
-  llvm::Twine result = prefix() + doModules(modules) + "EC" + toLower(name);
-  return result.str();
+  auto result = llvm::Twine(prefix()) + doModules(modules) + "EC";
+  return result.concat(toLower(name)).str();
 }
 
 std::string
@@ -116,13 +106,12 @@ fir::NameUniquer::doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
                                   llvm::Optional<llvm::StringRef> host,
                                   llvm::StringRef name,
                                   llvm::ArrayRef<std::int64_t> kinds) {
-  llvm::Twine result = prefix() + doModulesHost(modules, host) + "DT" +
-                       toLower(name) + doKinds(kinds);
-  return result.str();
+  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "DT";
+  return result.concat(toLower(name)).concat(doKinds(kinds)).str();
 }
 
 std::string fir::NameUniquer::doGenerated(llvm::StringRef name) {
-  llvm::Twine result = prefix() + "Q" + toLower(name);
+  auto result = llvm::Twine(prefix()) + "Q" + toLower(name);
   return result.str();
 }
 
@@ -148,27 +137,24 @@ std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
     name = "real";
     break;
   }
-  llvm::Twine result =
-      prefix() + doModulesHost(modules, host) + "C" + name + doKind(kind);
-  return result.str();
+  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "C";
+  return result.concat(name).concat(doKind(kind)).str();
 }
 
 std::string
 fir::NameUniquer::doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
                               llvm::Optional<llvm::StringRef> host,
                               llvm::StringRef name) {
-  llvm::Twine result =
-      prefix() + doModulesHost(modules, host) + "P" + toLower(name);
-  return result.str();
+  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "P";
+  return result.concat(toLower(name)).str();
 }
 
 std::string fir::NameUniquer::doType(llvm::ArrayRef<llvm::StringRef> modules,
                                      llvm::Optional<llvm::StringRef> host,
                                      llvm::StringRef name,
                                      llvm::ArrayRef<std::int64_t> kinds) {
-  llvm::Twine result = prefix() + doModulesHost(modules, host) + "T" +
-                       toLower(name) + doKinds(kinds);
-  return result.str();
+  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "T";
+  return result.concat(toLower(name)).concat(doKinds(kinds)).str();
 }
 
 std::string
@@ -176,9 +162,8 @@ fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                                    llvm::Optional<llvm::StringRef> host,
                                    llvm::StringRef name,
                                    llvm::ArrayRef<std::int64_t> kinds) {
-  llvm::Twine result = prefix() + doModulesHost(modules, host) + "CT" +
-                       toLower(name) + doKinds(kinds);
-  return result.str();
+  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "CT";
+  return result.concat(toLower(name)).concat(doKinds(kinds)).str();
 }
 
 std::string fir::NameUniquer::doTypeDescriptor(
@@ -192,8 +177,8 @@ std::string fir::NameUniquer::doTypeDescriptor(
 std::string
 fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                              llvm::StringRef name) {
-  llvm::Twine result = prefix() + doModules(modules) + "E" + toLower(name);
-  return result.str();
+  auto result = llvm::Twine(prefix()) + doModules(modules) + "E";
+  return result.concat(toLower(name)).str();
 }
 
 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
diff --git a/lib/Optimizer/Transforms/RewriteLoop.cpp b/lib/Optimizer/Transforms/RewriteLoop.cpp
index 51fc6e0080a8..54ab8891a015 100644
--- a/lib/Optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/Optimizer/Transforms/RewriteLoop.cpp
@@ -92,32 +92,33 @@ class LoopLoopConv : public mlir::OpRewritePattern<LoopOp> {
 
   mlir::PatternMatchResult
   matchAndRewrite(LoopOp loop, mlir::PatternRewriter &rewriter) const override {
-    auto low = loop.lowerBound();
-    auto high = loop.upperBound();
-    auto optStep = loop.optStep();
     auto loc = loop.getLoc();
-    mlir::Value step;
-    if (optStep.begin() != optStep.end()) {
-      step = *optStep.begin();
-    } else {
-      auto conStep = loop.constantStep();
-      step = rewriter.create<mlir::ConstantIndexOp>(
-          loc, conStep.hasValue() ? conStep.getValue().getSExtValue() : 1);
+    auto low = loop.getLowerBoundOperand();
+    if (!low) {
+      assert(loop.constantLowerBound().hasValue());
+      auto lb = *loop.constantLowerBound();
+      low = rewriter.create<mlir::ConstantIndexOp>(loc, lb.getSExtValue());
     }
+    auto high = loop.getUpperBoundOperand();
+    if (!high) {
+      assert(loop.constantUpperBound().hasValue());
+      auto ub = *loop.constantUpperBound();
+      high = rewriter.create<mlir::ConstantIndexOp>(loc, ub.getSExtValue());
+    }
+    auto step = loop.getStepOperand();
+    if (!step) {
+      if (loop.constantStep().hasValue()) {
+        auto st = *loop.constantStep();
+        step = rewriter.create<mlir::ConstantIndexOp>(loc, st.getSExtValue());
+      } else {
+        step = rewriter.create<mlir::ConstantIndexOp>(loc, 1);
+      }
+    }
+    assert(low && high && step);
     auto f = rewriter.create<mlir::loop::ForOp>(loc, low, high, step);
     f.region().getBlocks().clear();
     rewriter.inlineRegionBefore(loop.region(), f.region(), f.region().end());
-    if (loop.hasLastValue()) {
-      // Compute the final value of the loop iterator.
-      // FIXME: If there are no iterations?
-      auto ty = low.getType();
-      auto d = rewriter.create<mlir::SubIOp>(loc, ty, high, low);
-      auto q = rewriter.create<mlir::SignedDivIOp>(loc, ty, d, step);
-      auto dist = rewriter.create<mlir::MulIOp>(loc, ty, q, step);
-      rewriter.replaceOpWithNewOp<mlir::AddIOp>(loop, ty, low, dist);
-    } else {
-      rewriter.eraseOp(loop);
-    }
+    rewriter.eraseOp(loop);
     return matchSuccess();
   }
 };
diff --git a/test-lit/Fir/fir-ops.fir b/test-lit/Fir/fir-ops.fir
index 980314d7bced..770c79b701ce 100644
--- a/test-lit/Fir/fir-ops.fir
+++ b/test-lit/Fir/fir-ops.fir
@@ -153,7 +153,7 @@ func @loop() {
   %c10 = constant 10 : index
   %ct = constant true
   // CHECK: fir.loop %{{.*}} = %{{.*}} to %{{.*}} {
-  %i = fir.loop %i = %c1 to %c10 {
+  fir.loop %i = %c1 to %c10 {
     // CHECK: fir.where %{{.*}} {
     fir.where %ct {
       fir.call @nop() : () -> ()
diff --git a/test-lit/Fir/loop10.fir b/test-lit/Fir/loop10.fir
index d9ad1e81a703..82a2e3933fd2 100644
--- a/test-lit/Fir/loop10.fir
+++ b/test-lit/Fir/loop10.fir
@@ -8,10 +8,10 @@ func @x(%addr : !fir.ref<!fir.array<10x10xi32>>) -> index {
   %c10 = constant 10 : index
   // CHECK: %[[ROW:.*]] = phi i64
   // CHECK: icmp slt i64 %[[ROW]], 10
-  %0 = fir.loop %iv = %c0 to %c10 {
+  fir.loop %iv = %c0 to %c10 {
     // CHECK: %[[COL:.*]] = phi i64
     // CHECK: icmp slt i64 %[[COL]], 10
-    %jv = fir.loop %jv = %c0 to %c10 {
+    fir.loop %jv = (0) to (10) {
       // CHECK: getelementptr {{.*}} %[[ADDR]], i64 0, i64 %[[COL]], i64 %[[ROW]]
       %ptr = fir.coordinate_of %addr, %jv, %iv : (!fir.ref<!fir.array<10x10xi32>>, index, index) -> !fir.ref<i32>
       %c22 = constant 22 : i32
@@ -20,5 +20,5 @@ func @x(%addr : !fir.ref<!fir.array<10x10xi32>>) -> index {
     }
   }
   // CHECK: ret i64 10
-  return %0 : index
+  return %c10 : index
 }

From 821d009964b7b83d12c7e4311aa67ad0e462b424 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 16 Mar 2020 12:10:07 -0700
Subject: [PATCH 243/345] add args to pass mgr

---
 tools/bbc/bbc.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index e7e8b5eed5ad..703532de7b26 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -156,7 +156,8 @@ void convertFortranSourceToMLIR(
     return;
   }
 
-  mlir::PassManager pm = mlirModule.getContext();
+  mlir::PassManager pm(mlirModule.getContext());
+  mlir::applyPassManagerCLOptions(pm);
   pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
   pm.addPass(fir::createLowerToLoopPass());

From f25f7229d308d77b5381ffdb0b2bd1b4aacdcba1 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 16 Mar 2020 17:01:11 -0700
Subject: [PATCH 244/345] fix bugs with loop iterations

---
 lib/Optimizer/CodeGen.cpp                |   2 +-
 lib/Optimizer/Transforms/RewriteLoop.cpp |   4 +-
 test-lit/Fir/loop10.fir                  |   4 +-
 tools/bbc/bbc.cpp                        | 117 ++++++++++++++---------
 4 files changed, 80 insertions(+), 47 deletions(-)

diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 9eac996816be..919d5ca920fc 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -2158,7 +2158,7 @@ struct LLVMIRLoweringPass : public mlir::ModulePass<LLVMIRLoweringPass> {
       return;
 
     if (auto llvmModule = mlir::translateModuleToLLVMIR(getModule())) {
-      output << *llvmModule;
+      llvmModule->print(output, nullptr);
       return;
     }
 
diff --git a/lib/Optimizer/Transforms/RewriteLoop.cpp b/lib/Optimizer/Transforms/RewriteLoop.cpp
index 54ab8891a015..331df3691f5b 100644
--- a/lib/Optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/Optimizer/Transforms/RewriteLoop.cpp
@@ -115,7 +115,9 @@ class LoopLoopConv : public mlir::OpRewritePattern<LoopOp> {
       }
     }
     assert(low && high && step);
-    auto f = rewriter.create<mlir::loop::ForOp>(loc, low, high, step);
+    // ForOp has different bounds semantics. Adjust upper bound.
+    auto adjustUp = rewriter.create<mlir::AddIOp>(loc, high, step);
+    auto f = rewriter.create<mlir::loop::ForOp>(loc, low, adjustUp, step);
     f.region().getBlocks().clear();
     rewriter.inlineRegionBefore(loop.region(), f.region(), f.region().end());
     rewriter.eraseOp(loop);
diff --git a/test-lit/Fir/loop10.fir b/test-lit/Fir/loop10.fir
index 82a2e3933fd2..5fc5630c6d6f 100644
--- a/test-lit/Fir/loop10.fir
+++ b/test-lit/Fir/loop10.fir
@@ -7,10 +7,10 @@ func @x(%addr : !fir.ref<!fir.array<10x10xi32>>) -> index {
   %c0 = constant 0 : index
   %c10 = constant 10 : index
   // CHECK: %[[ROW:.*]] = phi i64
-  // CHECK: icmp slt i64 %[[ROW]], 10
+  // CHECK: icmp slt i64 %[[ROW]], 11
   fir.loop %iv = %c0 to %c10 {
     // CHECK: %[[COL:.*]] = phi i64
-    // CHECK: icmp slt i64 %[[COL]], 10
+    // CHECK: icmp slt i64 %[[COL]], 11
     fir.loop %jv = (0) to (10) {
       // CHECK: getelementptr {{.*}} %[[ADDR]], i64 0, i64 %[[COL]], i64 %[[ROW]]
       %ptr = fir.coordinate_of %addr, %jv, %iv : (!fir.ref<!fir.array<10x10xi32>>, index, index) -> !fir.ref<i32>
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 703532de7b26..227a3ec7cc72 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -48,52 +48,79 @@
 #include "llvm/Support/raw_ostream.h"
 #include <iostream>
 
-namespace {
-
+//===----------------------------------------------------------------------===//
 // Some basic command-line options
-llvm::cl::opt<std::string> inputFilename(llvm::cl::Positional,
-                                         llvm::cl::Required,
-                                         llvm::cl::desc("<input file>"));
+//===----------------------------------------------------------------------===//
 
-llvm::cl::opt<std::string>
+static llvm::cl::opt<std::string> inputFilename(llvm::cl::Positional,
+                                                llvm::cl::Required,
+                                                llvm::cl::desc("<input file>"));
+
+static llvm::cl::opt<std::string>
     outputFilename("o", llvm::cl::desc("Specify the output filename"),
                    llvm::cl::value_desc("filename"), llvm::cl::init("a.mlir"));
 
-llvm::cl::list<std::string> includeDirs("I",
-                                        llvm::cl::desc("include search paths"));
+static llvm::cl::list<std::string>
+    includeDirs("I", llvm::cl::desc("include search paths"));
 
-llvm::cl::list<std::string> moduleDirs("module",
-                                       llvm::cl::desc("module search paths"));
+static llvm::cl::list<std::string>
+    moduleDirs("module", llvm::cl::desc("module search paths"));
 
-llvm::cl::opt<std::string>
+static llvm::cl::opt<std::string>
     moduleSuffix("module-suffix", llvm::cl::desc("module file suffix override"),
                  llvm::cl::init(".mod"));
 
-llvm::cl::opt<bool>
+static llvm::cl::opt<bool>
     emitLLVM("emit-llvm",
              llvm::cl::desc("Add passes to lower to and emit LLVM IR"),
              llvm::cl::init(false));
-llvm::cl::opt<bool>
+
+static llvm::cl::opt<bool>
     emitFIR("emit-fir",
             llvm::cl::desc("Dump the FIR created by lowering and exit"),
             llvm::cl::init(false));
 
-// vestigal struct that should be deleted
+static llvm::cl::opt<bool> fixedForm("Mfixed",
+                                     llvm::cl::desc("used fixed form"),
+                                     llvm::cl::init(false));
+
+static llvm::cl::opt<bool> freeForm("Mfree", llvm::cl::desc("used free form"),
+                                    llvm::cl::init(false));
+
+static llvm::cl::opt<bool> warnStdViolation("Mstandard",
+                                            llvm::cl::desc("emit warnings"),
+                                            llvm::cl::init(false));
+
+static llvm::cl::opt<bool> warnIsError("Werror",
+                                       llvm::cl::desc("warnings are errors"),
+                                       llvm::cl::init(false));
+
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+// TODO: vestigal struct that should be deleted
 struct DriverOptions {
-  bool forcedForm{false};             // -Mfixed or -Mfree appeared
-  bool warnOnNonstandardUsage{false}; // -Mstandard
-  bool warningsAreErrors{false};      // -Werror
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
   std::string prefix;
 };
 
-int exitStatus{EXIT_SUCCESS};
+} // namespace
+
+static int exitStatus{EXIT_SUCCESS};
+
+// Print the module without the "module { ... }" wrapper.
+static void printModule(mlir::ModuleOp mlirModule, llvm::raw_ostream &out) {
+  for (auto &op : mlirModule.getBody()->without_terminator())
+    out << op << '\n';
+  out << '\n';
+}
 
 // Convert Fortran input to MLIR (target is FIR dialect)
-void convertFortranSourceToMLIR(
+static void convertFortranSourceToMLIR(
     std::string path, Fortran::parser::Options options, DriverOptions &driver,
     Fortran::semantics::SemanticsContext &semanticsContext) {
-  if (!driver.forcedForm) {
+  if (!(fixedForm || freeForm)) {
     auto dot = path.rfind(".");
     if (dot != std::string::npos) {
       std::string suffix{path.substr(dot + 1)};
@@ -104,7 +131,7 @@ void convertFortranSourceToMLIR(
   Fortran::parser::Parsing parsing{semanticsContext.allSources()};
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
-      (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
+      (warnIsError || parsing.messages().AnyFatalError())) {
     llvm::errs() << driver.prefix << "could not scan " << path << '\n';
     parsing.messages().Emit(std::cerr, parsing.cooked());
     exitStatus = EXIT_FAILURE;
@@ -119,7 +146,7 @@ void convertFortranSourceToMLIR(
     return;
   }
   if ((!parsing.messages().empty() &&
-       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
+       (warnIsError || parsing.messages().AnyFatalError())) ||
       !parsing.parseTree().has_value()) {
     llvm::errs() << driver.prefix << "could not parse " << path << '\n';
     exitStatus = EXIT_FAILURE;
@@ -150,12 +177,12 @@ void convertFortranSourceToMLIR(
     return;
   }
   if (emitFIR) {
-    // dump FIR and exit
-    mlirModule.print(out);
-    out << '\n';
+    // Do lowering, but nothing else. Dump FIR and exit.
+    printModule(mlirModule, out);
     return;
   }
 
+  // Otherwise run the default passes.
   mlir::PassManager pm(mlirModule.getContext());
   mlir::applyPassManagerCLOptions(pm);
   pm.addPass(fir::createMemToRegPass());
@@ -163,30 +190,36 @@ void convertFortranSourceToMLIR(
   pm.addPass(fir::createLowerToLoopPass());
   pm.addPass(fir::createFIRToStdPass(kindMap));
   pm.addPass(mlir::createLowerToCFGPass());
+  pm.addPass(mlir::createCanonicalizerPass());
 
   if (emitLLVM) {
+    // Continue to lower from MLIR down to LLVM IR. Emit LLVM and MLIR.
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
     std::error_code ec;
-    llvm::ToolOutputFile out(outputFilename + ".ll", ec,
-                             llvm::sys::fs::OF_None);
+    llvm::ToolOutputFile outFile(outputFilename + ".ll", ec,
+                                 llvm::sys::fs::OF_None);
     if (ec) {
       llvm::errs() << "can't open output file " + outputFilename + ".ll";
       return;
     }
-    pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
-  }
-
-  if (mlir::succeeded(pm.run(mlirModule))) {
-    mlirModule.print(out);
-    out << '\n';
+    pm.addPass(fir::createLLVMDialectToLLVMPass(outFile.os()));
+    if (mlir::succeeded(pm.run(mlirModule))) {
+      outFile.keep();
+      printModule(mlirModule, out);
+      return;
+    }
   } else {
-    llvm::errs() << "oops, pass manager reported failure\n";
-    mlirModule.dump();
+    // Emit MLIR and do not lower to LLVM IR.
+    if (mlir::succeeded(pm.run(mlirModule))) {
+      printModule(mlirModule, out);
+      return;
+    }
   }
+  // Something went wrong. Try to dump the MLIR module.
+  llvm::errs() << "oops, pass manager reported failure\n";
+  mlirModule.dump();
 }
 
-} // namespace
-
 int main(int argc, char **argv) {
   fir::registerFIR();
   fir::registerFIRPasses();
@@ -199,12 +232,10 @@ int main(int argc, char **argv) {
   DriverOptions driver;
   driver.prefix = argv[0] + ": "s;
 
-  if (includeDirs.size() == 0) {
+  if (includeDirs.size() == 0)
     includeDirs.push_back(".");
-  }
-  if (moduleDirs.size() == 0) {
+  if (moduleDirs.size() == 0)
     moduleDirs.push_back(".");
-  }
 
   Fortran::parser::Options options;
   options.predefinitions.emplace_back("__F18", "1");
@@ -222,8 +253,8 @@ int main(int argc, char **argv) {
   semanticsContext.set_moduleDirectory(moduleDirs.front())
       .set_moduleFileSuffix(moduleSuffix)
       .set_searchDirectories(includeDirs)
-      .set_warnOnNonstandardUsage(driver.warnOnNonstandardUsage)
-      .set_warningsAreErrors(driver.warningsAreErrors);
+      .set_warnOnNonstandardUsage(warnStdViolation)
+      .set_warningsAreErrors(warnIsError);
 
   convertFortranSourceToMLIR(inputFilename, options, driver, semanticsContext);
   return exitStatus;

From 0e82320d012a4ca56b848828c00364c6908dc119 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 17 Mar 2020 09:44:59 -0700
Subject: [PATCH 245/345] Add LLVM definitions in CMakeLists.txt required for
 standalone builds

LLVM_RUNTIME_OUTPUT_INTDIR, LLVM_LIBRARY_OUTPUT_INTDIR are set in
llvm/CMakeList.txt, so not accessible in standalone build, but these
variables are indirectly required in add_llvm_tool and add_llvm_library
functions provided by AddLLVM cmake modules. So they need to be defined
in flang cmake in case of standalone build before any of these functions
can be used.
---
 CMakeLists.txt | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 403f2d57c0ac..303d8ba6e8d5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,7 +37,7 @@ include(AddFlang)
 
 
 # Check for a standalone build and configure as appropriate from
-# there. 
+# there.
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   message("Building Flang as a standalone project.")
   project(Flang)
@@ -49,7 +49,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
     mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
   endif()
 
-  # We need a pre-built/installed version of LLVM. 
+  # We need a pre-built/installed version of LLVM.
   find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
   list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
 
@@ -58,12 +58,16 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
     find_package(ZLIB REQUIRED)
   endif()
 
+  # They are used as destination of target generators.
+  set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
+  set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
+
   include(CMakeParseArguments)
   include(AddLLVM)
-  include(HandleLLVMOptions)  
+  include(HandleLLVMOptions)
   include(VersionFromVCS)
   include(TableGen)
-  include(AddMLIR) 
+  include(AddMLIR)
 
   option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
   option(LLVM_INSTALL_TOOLCHAIN_ONLY
@@ -71,7 +75,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
     "Set to ON to force using an old, unsupported host toolchain." OFF)
 
-  
+
   # Add LLVM include files as if they were SYSTEM because there are complex unused
   # parameter issues that may or may not appear depending on the environments and
   # compilers (ifdefs are involved). This allows warnings from LLVM headers to be

From 1e1323c0b515bbf011edb988407327b44cb49b08 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 17 Mar 2020 04:01:29 -0700
Subject: [PATCH 246/345] [cmake rebase] fix out-of-tree lit config after
 PR1045 cmake previous rebase

---
 test-lit/CMakeLists.txt | 6 +-----
 test/lit.site.cfg.py.in | 2 +-
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
index f45b632d4dbb..3d41e643f37e 100644
--- a/test-lit/CMakeLists.txt
+++ b/test-lit/CMakeLists.txt
@@ -8,11 +8,7 @@ set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/include/flang)
 set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
 
 # bbc/tco tools path for lit
-if (FLANG_BUILT_STANDALONE)
- set(FLANG_LLVM_TOOLS_DIR  ${FLANG_BINARY_DIR}/bin)
-else()
- set(FLANG_LLVM_TOOLS_DIR  ${LLVM_BINARY_DIR}/bin)
-endif()
+set(FLANG_LLVM_TOOLS_DIR  ${FLANG_BINARY_DIR}/bin)
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index 6e77ba69f079..189270127ba5 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -2,7 +2,7 @@
 
 import sys
 
-config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_BINARY_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"

From 82bc632354df8fcaafa9c75a9112d5c29c5101bd Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 17 Mar 2020 12:05:58 -0700
Subject: [PATCH 247/345] use newer converter interface

---
 lib/Optimizer/CodeGen.cpp        | 236 ++++++++++++-------------------
 lib/Optimizer/Dialect/FIROps.cpp |   6 +-
 2 files changed, 91 insertions(+), 151 deletions(-)

diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 919d5ca920fc..a15a072dda8a 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -342,8 +342,7 @@ StringMap<mlir::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
 
 /// remove `omitNames` (by name) from the attribute dictionary
 SmallVector<mlir::NamedAttribute, 4>
-pruneNamedAttrDict(AttributeTy attrs,
-                   ArrayRef<StringRef> omitNames) {
+pruneNamedAttrDict(AttributeTy attrs, ArrayRef<StringRef> omitNames) {
   SmallVector<mlir::NamedAttribute, 4> result;
   for (auto x : attrs) {
     bool omit = false;
@@ -364,12 +363,11 @@ inline mlir::LLVM::LLVMType getVoidPtrType(mlir::LLVM::LLVMDialect *dialect) {
 
 /// FIR conversion pattern template
 template <typename FromOp>
-class FIROpConversion : public mlir::ConversionPattern {
+class FIROpConversion : public mlir::OpConversionPattern<FromOp> {
 public:
   explicit FIROpConversion(mlir::MLIRContext *ctx,
                            FIRToLLVMTypeConverter &lowering)
-      : ConversionPattern(FromOp::getOperationName(), 1, ctx),
-        lowering(lowering) {}
+      : mlir::OpConversionPattern<FromOp>(ctx, 1), lowering(lowering) {}
 
 protected:
   LLVMContext &getLLVMContext() const { return lowering.getLLVMContext(); }
@@ -412,9 +410,8 @@ struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::AddrOfOp addr, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto addr = mlir::cast<fir::AddrOfOp>(op);
     auto ty = unwrap(convertType(addr.getType()));
     auto attrs = pruneNamedAttrDict(addr.getAttrs(), {"symbol"});
     rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(
@@ -435,9 +432,8 @@ struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::AllocaOp alloc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto alloc = mlir::cast<fir::AllocaOp>(op);
     auto loc = alloc.getLoc();
     auto ity = lowering.indexType();
     auto c1 = genConstantIndex(loc, ity, rewriter, 1);
@@ -471,9 +467,8 @@ struct AllocMemOpConversion : public FIROpConversion<fir::AllocMemOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::AllocMemOp heap, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto heap = mlir::cast<fir::AllocMemOp>(op);
     auto ty = convertType(heap.getType());
     auto dialect = getDialect();
     auto mallocFunc = getMalloc(heap, rewriter, dialect);
@@ -511,9 +506,8 @@ struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::FreeMemOp freemem, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto freemem = mlir::cast<fir::FreeMemOp>(op);
     auto dialect = getDialect();
     auto freeFunc = getFree(freemem, rewriter, dialect);
     auto bitcast = rewriter.create<mlir::LLVM::BitcastOp>(
@@ -539,9 +533,8 @@ struct BoxAddrOpConversion : public FIROpConversion<fir::BoxAddrOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxAddrOp boxaddr, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxaddr = mlir::cast<fir::BoxAddrOp>(op);
     auto a = operands[0];
     auto loc = boxaddr.getLoc();
     auto ty = convertType(boxaddr.getType());
@@ -566,9 +559,8 @@ struct BoxCharLenOpConversion : public FIROpConversion<fir::BoxCharLenOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxCharLenOp boxchar, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxchar = mlir::cast<fir::BoxCharLenOp>(op);
     auto a = operands[0];
     auto ty = convertType(boxchar.getType());
     auto ctx = boxchar.getContext();
@@ -583,9 +575,8 @@ struct BoxDimsOpConversion : public FIROpConversion<fir::BoxDimsOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxDimsOp boxdims, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxdims = mlir::cast<fir::BoxDimsOp>(op);
     auto a = operands[0];
     auto dim = operands[1];
     auto loc = boxdims.getLoc();
@@ -616,9 +607,8 @@ struct BoxEleSizeOpConversion : public FIROpConversion<fir::BoxEleSizeOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxEleSizeOp boxelesz, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxelesz = mlir::cast<fir::BoxEleSizeOp>(op);
     auto a = operands[0];
     auto loc = boxelesz.getLoc();
     auto c0 = genConstantOffset(loc, rewriter, 0);
@@ -634,9 +624,8 @@ struct BoxIsAllocOpConversion : public FIROpConversion<fir::BoxIsAllocOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxIsAllocOp boxisalloc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxisalloc = mlir::cast<fir::BoxIsAllocOp>(op);
     auto a = operands[0];
     auto loc = boxisalloc.getLoc();
     auto ity = lowering.offsetType();
@@ -657,9 +646,8 @@ struct BoxIsArrayOpConversion : public FIROpConversion<fir::BoxIsArrayOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxIsArrayOp boxisarray, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxisarray = mlir::cast<fir::BoxIsArrayOp>(op);
     auto a = operands[0];
     auto loc = boxisarray.getLoc();
     auto c0 = genConstantOffset(loc, rewriter, 0);
@@ -677,9 +665,8 @@ struct BoxIsPtrOpConversion : public FIROpConversion<fir::BoxIsPtrOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxIsPtrOp boxisptr, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxisptr = mlir::cast<fir::BoxIsPtrOp>(op);
     auto a = operands[0];
     auto loc = boxisptr.getLoc();
     auto ty = convertType(boxisptr.getType());
@@ -701,9 +688,8 @@ struct BoxProcHostOpConversion : public FIROpConversion<fir::BoxProcHostOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxProcHostOp boxprochost, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxprochost = mlir::cast<fir::BoxProcHostOp>(op);
     auto a = operands[0];
     auto ty = convertType(boxprochost.getType());
     auto ctx = boxprochost.getContext();
@@ -718,9 +704,8 @@ struct BoxRankOpConversion : public FIROpConversion<fir::BoxRankOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxRankOp boxrank, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxrank = mlir::cast<fir::BoxRankOp>(op);
     auto a = operands[0];
     auto loc = boxrank.getLoc();
     auto ty = convertType(boxrank.getType());
@@ -738,9 +723,8 @@ struct BoxTypeDescOpConversion : public FIROpConversion<fir::BoxTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::BoxTypeDescOp boxtypedesc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto boxtypedesc = mlir::cast<fir::BoxTypeDescOp>(op);
     auto a = operands[0];
     auto loc = boxtypedesc.getLoc();
     auto ty = convertType(boxtypedesc.getType());
@@ -760,9 +744,8 @@ struct StringLitOpConversion : public FIROpConversion<fir::StringLitOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::StringLitOp constop, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto constop = mlir::cast<fir::StringLitOp>(op);
     auto ty = convertType(constop.getType());
     auto attr = constop.getValue();
     if (attr.isa<mlir::StringAttr>()) {
@@ -793,9 +776,8 @@ struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::CallOp call, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto call = mlir::cast<fir::CallOp>(op);
     SmallVector<mlir::Type, 4> resultTys;
     for (auto r : call.getResults())
       resultTys.push_back(convertType(r.getType()));
@@ -814,9 +796,8 @@ struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::CmpcOp cmp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto cmp = mlir::cast<fir::CmpcOp>(op);
     auto ctxt = cmp.getContext();
     auto kind = cmp.lhs().getType().cast<fir::CplxType>().getFKind();
     auto ty = convertType(fir::RealType::get(ctxt, kind));
@@ -853,9 +834,8 @@ struct CmpfOpConversion : public FIROpConversion<fir::CmpfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::CmpfOp cmp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto cmp = mlir::cast<fir::CmpfOp>(op);
     auto type = convertType(cmp.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::FCmpOp>(cmp, type, operands,
                                                     cmp.getAttrs());
@@ -867,9 +847,8 @@ struct ConstcOpConversion : public FIROpConversion<fir::ConstcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy,
+  matchAndRewrite(fir::ConstcOp conc, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto conc = mlir::cast<fir::ConstcOp>(op);
     auto loc = conc.getLoc();
     auto ctx = conc.getContext();
     auto ty = convertType(conc.getType());
@@ -897,9 +876,8 @@ struct ConstfOpConversion : public FIROpConversion<fir::ConstfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy,
+  matchAndRewrite(fir::ConstfOp conf, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto conf = mlir::cast<fir::ConstfOp>(op);
     auto ty = convertType(conf.getType());
     auto val = conf.constantAttr();
     rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(conf, ty, val);
@@ -912,9 +890,8 @@ struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::ConvertOp convert, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto convert = mlir::cast<fir::ConvertOp>(op);
     auto fromTy_ = convertType(convert.value().getType());
     auto fromTy = unwrap(fromTy_);
     auto toTy_ = convertType(convert.res().getType());
@@ -963,7 +940,7 @@ struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
       }
     }
     if (v)
-      rewriter.replaceOp(op, v);
+      rewriter.replaceOp(convert, v);
     else
       emitError(loc) << "cannot convert " << fromTy_ << " to " << toTy_;
     return matchSuccess();
@@ -975,9 +952,8 @@ struct DispatchOpConversion : public FIROpConversion<fir::DispatchOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::DispatchOp dispatch, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto dispatch = mlir::cast<fir::DispatchOp>(op);
     auto ty = convertType(dispatch.getFunctionType());
     // get the table, lookup the method, fetch the func-ptr
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(dispatch, ty, operands,
@@ -993,10 +969,9 @@ struct DispatchTableOpConversion
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::DispatchTableOp dispTab, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto disptable = mlir::cast<fir::DispatchTableOp>(op);
-    TODO(disptable);
+    TODO(dispTab);
     return matchSuccess();
   }
 };
@@ -1006,10 +981,9 @@ struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::DTEntryOp dtEnt, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto dtentry = mlir::cast<fir::DTEntryOp>(op);
-    TODO(dtentry);
+    TODO(dtEnt);
     return matchSuccess();
   }
 };
@@ -1019,9 +993,8 @@ struct EmboxCharOpConversion : public FIROpConversion<fir::EmboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::EmboxCharOp emboxchar, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto emboxchar = mlir::cast<fir::EmboxCharOp>(op);
     auto a = operands[0];
     auto b = operands[1];
     auto loc = emboxchar.getLoc();
@@ -1042,9 +1015,8 @@ struct EmboxOpConversion : public FIROpConversion<fir::EmboxOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::EmboxOp embox, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto embox = mlir::cast<fir::EmboxOp>(op);
     auto loc = embox.getLoc();
     auto dialect = getDialect();
     auto ty = unwrap(convertType(embox.getType()));
@@ -1112,9 +1084,8 @@ struct EmboxProcOpConversion : public FIROpConversion<fir::EmboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::EmboxProcOp emboxproc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto emboxproc = mlir::cast<fir::EmboxProcOp>(op);
     auto a = operands[0];
     auto b = operands[1];
     auto loc = emboxproc.getLoc();
@@ -1150,9 +1121,8 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::ExtractValueOp extractVal, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto extractVal = mlir::cast<fir::ExtractValueOp>(op);
     auto ty = convertType(extractVal.getType());
     assert(fir::allConstants(operands.drop_front(1)));
     // since all indices are constants use LLVM's extractvalue instruction
@@ -1172,9 +1142,8 @@ struct InsertValueOpConversion : public FIROpConversion<fir::InsertValueOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::InsertValueOp insertVal, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto insertVal = cast<fir::InsertValueOp>(op);
     auto ty = convertType(insertVal.getType());
     assert(fir::allConstants(operands.drop_front(2)));
     // since all indices must be constants use LLVM's insertvalue instruction
@@ -1203,9 +1172,8 @@ struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::CoordinateOp coor, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto coor = mlir::cast<fir::CoordinateOp>(op);
     auto ty = convertType(coor.getType());
     auto loc = coor.getLoc();
     mlir::Value base = operands[0];
@@ -1316,9 +1284,8 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
 
   // NB: most field references should be resolved by this point
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::FieldIndexOp field, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto field = mlir::cast<fir::FieldIndexOp>(op);
     // call the compiler generated function to determine the byte offset of
     // the field at runtime
     auto symAttr =
@@ -1347,9 +1314,8 @@ struct LenParamIndexOpConversion
 
   // FIXME: this should be specialized by the runtime target
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::LenParamIndexOp lenp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto lenp = mlir::cast<fir::LenParamIndexOp>(op);
     auto ity = lowering.indexType();
     auto onty = lenp.getOnType();
     // size of portable descriptor
@@ -1375,7 +1341,7 @@ struct FirEndOpConversion : public FIROpConversion<fir::FirEndOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::FirEndOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOp(op, {});
     return matchSuccess();
@@ -1390,9 +1356,8 @@ struct GenDimsOpConversion : public FIROpConversion<fir::GenDimsOp> {
 
   // gendims(args:index, ...) ==> %v = ... : [size x <3 x index>]
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::GenDimsOp gendims, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto gendims = mlir::cast<fir::GenDimsOp>(op);
     auto loc = gendims.getLoc();
     auto ty = convertType(gendims.getType());
     auto ptrTy = unwrap(ty).getPointerTo();
@@ -1429,9 +1394,8 @@ struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::GenTypeDescOp gentypedesc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto gentypedesc = mlir::cast<fir::GenTypeDescOp>(op);
     auto loc = gentypedesc.getLoc();
     auto inTy = gentypedesc.getInType();
     auto name = consName(rewriter, inTy);
@@ -1462,10 +1426,9 @@ struct GlobalLenOpConversion : public FIROpConversion<fir::GlobalLenOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::GlobalLenOp globalLen, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto globalentry = mlir::cast<fir::GlobalLenOp>(op);
-    TODO(globalentry);
+    TODO(globalLen);
     return matchSuccess();
   }
 };
@@ -1474,7 +1437,7 @@ struct HasValueOpConversion : public FIROpConversion<fir::HasValueOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::HasValueOp op, OperandTy operands,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands);
     return matchSuccess();
@@ -1485,9 +1448,8 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::GlobalOp global, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto global = mlir::cast<fir::GlobalOp>(op);
     auto tyAttr = unwrap(convertType(global.getType()));
     auto loc = global.getLoc();
     mlir::Attribute initAttr{};
@@ -1508,12 +1470,11 @@ struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::LoadOp load, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto load = mlir::cast<fir::LoadOp>(op);
     auto ty = convertType(load.getType());
     auto at = load.getAttrs();
-    rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(op, ty, operands, at);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(load, ty, operands, at);
     return matchSuccess();
   }
 };
@@ -1523,9 +1484,8 @@ struct NoReassocOpConversion : public FIROpConversion<fir::NoReassocOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::NoReassocOp noreassoc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto noreassoc = mlir::cast<fir::NoReassocOp>(op);
     noreassoc.replaceAllUsesWith(operands[0]);
     rewriter.replaceOp(noreassoc, {});
     return matchSuccess();
@@ -1570,9 +1530,8 @@ struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::SelectCaseOp caseOp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto caseOp = mlir::cast<fir::SelectCaseOp>(op);
     const auto conds = caseOp.getNumConditions();
     auto attrName = fir::SelectCaseOp::getCasesAttr();
     auto cases = caseOp.getAttrOfType<mlir::ArrayAttr>(attrName).getValue();
@@ -1630,11 +1589,9 @@ struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
 };
 
 template <typename OP>
-void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering,
-                           mlir::Operation *op, OperandTy operands,
+void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, OP select,
+                           OperandTy operands,
                            mlir::ConversionPatternRewriter &rewriter) {
-  auto select = mlir::cast<OP>(op);
-
   // We could target the LLVM switch instruction, but it isn't part of the
   // LLVM IR dialect.  Create an if-then-else ladder instead.
   auto conds = select.getNumConditions();
@@ -1669,7 +1626,7 @@ struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::SelectOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectOp>(lowering, op, operands, rewriter);
     return matchSuccess();
@@ -1681,23 +1638,21 @@ struct SelectRankOpConversion : public FIROpConversion<fir::SelectRankOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::SelectRankOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectRankOp>(lowering, op, operands, rewriter);
     return matchSuccess();
   }
 };
 
-// SelectTypeOp should have already been lowered
 struct SelectTypeOpConversion : public FIROpConversion<fir::SelectTypeOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::SelectTypeOp select, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto selecttype = mlir::cast<fir::SelectTypeOp>(op);
-    TODO(selecttype);
-    return matchSuccess();
+    llvm_unreachable("fir.select_type should have already been converted");
+    return matchFailure();
   }
 };
 
@@ -1706,9 +1661,8 @@ struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::StoreOp store, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto store = mlir::cast<fir::StoreOp>(op);
     rewriter.replaceOpWithNewOp<mlir::LLVM::StoreOp>(store, operands[0],
                                                      operands[1]);
     return matchSuccess();
@@ -1729,9 +1683,8 @@ struct UnboxCharOpConversion : public FIROpConversion<fir::UnboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::UnboxCharOp unboxchar, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unboxchar = mlir::cast<fir::UnboxCharOp>(op);
     auto *ctx = unboxchar.getContext();
     auto loc = unboxchar.getLoc();
     auto tuple = operands[0];
@@ -1765,9 +1718,8 @@ struct UnboxOpConversion : public FIROpConversion<fir::UnboxOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::UnboxOp unbox, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unbox = mlir::cast<fir::UnboxOp>(op);
     auto loc = unbox.getLoc();
     auto tuple = operands[0];
     auto ty = unwrap(tuple.getType());
@@ -1794,9 +1746,8 @@ struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::UnboxProcOp unboxproc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unboxproc = mlir::cast<fir::UnboxProcOp>(op);
     auto *ctx = unboxproc.getContext();
     auto loc = unboxproc.getLoc();
     auto tuple = operands[0];
@@ -1817,9 +1768,8 @@ struct UndefOpConversion : public FIROpConversion<fir::UndefOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy,
+  matchAndRewrite(fir::UndefOp undef, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto undef = mlir::cast<fir::UndefOp>(op);
     rewriter.replaceOpWithNewOp<mlir::LLVM::UndefOp>(
         undef, convertType(undef.getType()));
     return matchSuccess();
@@ -1831,9 +1781,8 @@ struct UnreachableOpConversion : public FIROpConversion<fir::UnreachableOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::UnreachableOp unreach, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto unreach = mlir::cast<fir::UnreachableOp>(op);
     rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(unreach);
     return matchSuccess();
   }
@@ -1844,11 +1793,10 @@ struct UnreachableOpConversion : public FIROpConversion<fir::UnreachableOp> {
 //
 
 /// Convert a floating-point primitive
-template <typename BINOP, typename LLVMOP>
-void lowerRealBinaryOp(mlir::Operation *op, OperandTy operands,
+template <typename LLVMOP, typename BINOP>
+void lowerRealBinaryOp(BINOP binop, OperandTy operands,
                        mlir::ConversionPatternRewriter &rewriter,
                        FIRToLLVMTypeConverter &lowering) {
-  auto binop = cast<BINOP>(op);
   auto ty = lowering.convertType(binop.getType());
   rewriter.replaceOpWithNewOp<LLVMOP>(binop, ty, operands);
 }
@@ -1857,10 +1805,9 @@ struct AddfOpConversion : public FIROpConversion<fir::AddfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::AddfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::AddfOp, mlir::LLVM::FAddOp>(op, operands, rewriter,
-                                                       lowering);
+    lowerRealBinaryOp<mlir::LLVM::FAddOp>(op, operands, rewriter, lowering);
     return matchSuccess();
   }
 };
@@ -1868,10 +1815,9 @@ struct SubfOpConversion : public FIROpConversion<fir::SubfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::SubfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::SubfOp, mlir::LLVM::FSubOp>(op, operands, rewriter,
-                                                       lowering);
+    lowerRealBinaryOp<mlir::LLVM::FSubOp>(op, operands, rewriter, lowering);
     return matchSuccess();
   }
 };
@@ -1879,10 +1825,9 @@ struct MulfOpConversion : public FIROpConversion<fir::MulfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::MulfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::MulfOp, mlir::LLVM::FMulOp>(op, operands, rewriter,
-                                                       lowering);
+    lowerRealBinaryOp<mlir::LLVM::FMulOp>(op, operands, rewriter, lowering);
     return matchSuccess();
   }
 };
@@ -1890,10 +1835,9 @@ struct DivfOpConversion : public FIROpConversion<fir::DivfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::DivfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::DivfOp, mlir::LLVM::FDivOp>(op, operands, rewriter,
-                                                       lowering);
+    lowerRealBinaryOp<mlir::LLVM::FDivOp>(op, operands, rewriter, lowering);
     return matchSuccess();
   }
 };
@@ -1901,10 +1845,9 @@ struct ModfOpConversion : public FIROpConversion<fir::ModfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::ModfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    lowerRealBinaryOp<fir::ModfOp, mlir::LLVM::FRemOp>(op, operands, rewriter,
-                                                       lowering);
+    lowerRealBinaryOp<mlir::LLVM::FRemOp>(op, operands, rewriter, lowering);
     return matchSuccess();
   }
 };
@@ -1913,9 +1856,8 @@ struct NegfOpConversion : public FIROpConversion<fir::NegfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::NegfOp neg, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto neg = mlir::cast<fir::NegfOp>(op);
     auto ty = convertType(neg.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::FNegOp>(neg, ty, operands);
     return matchSuccess();
@@ -1926,7 +1868,7 @@ struct NegfOpConversion : public FIROpConversion<fir::NegfOp> {
 // Primitive operations on Complex types
 //
 
-/// Generate code for complex addition/subtraction
+/// Generate inline code for complex addition/subtraction
 template <typename LLVMOP, typename OPTY>
 mlir::LLVM::InsertValueOp complexSum(OPTY sumop, OperandTy opnds,
                                      mlir::ConversionPatternRewriter &rewriter,
@@ -1953,10 +1895,10 @@ struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::AddcOp addc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
+    // given: (x + iy) * (x' + iy')
     // result: (x + x') + i(y + y')
-    auto addc = cast<fir::AddcOp>(op);
     auto r = complexSum<mlir::LLVM::FAddOp>(addc, operands, rewriter, lowering);
     addc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(addc, r.getResult());
@@ -1968,10 +1910,10 @@ struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::SubcOp subc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
+    // given: (x + iy) * (x' + iy')
     // result: (x - x') + i(y - y')
-    auto subc = mlir::cast<fir::SubcOp>(op);
     auto r = complexSum<mlir::LLVM::FSubOp>(subc, operands, rewriter, lowering);
     subc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(subc, r.getResult());
@@ -1984,10 +1926,10 @@ struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::MulcOp mulc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto mulc = mlir::cast<fir::MulcOp>(op);
-    // FIXME: should this just call __muldc3 ?
+    // TODO: should this just call __muldc3 ?
+    // given: (x + iy) * (x' + iy')
     // result: (xx'-yy')+i(xy'+yx')
     auto a = operands[0];
     auto b = operands[1];
@@ -2020,10 +1962,10 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::DivcOp divc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto divc = mlir::cast<fir::DivcOp>(op);
-    // FIXME: should this just call __divdc3 ?
+    // TODO: should this just call __divdc3 ?
+    // given: (x + iy) / (x' + iy')
     // result: ((xx'+yy')/d) + i((yx'-xy')/d) where d = x'x' + y'y'
     auto a = operands[0];
     auto b = operands[1];
@@ -2056,13 +1998,15 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   }
 };
 
+/// Inlined complex negation
 struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::PatternMatchResult
-  matchAndRewrite(mlir::Operation *op, OperandTy operands,
+  matchAndRewrite(fir::NegcOp neg, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto neg = mlir::cast<fir::NegcOp>(op);
+    // given: -(x + iy)
+    // result: -x - iy
     auto ctxt = neg.getContext();
     auto ty = convertType(neg.getType());
     auto loc = neg.getLoc();
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 132a3607478c..88756ecfb43c 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -473,12 +473,8 @@ static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
     }
   }
   // Parse the optional `unordered` keyword
-  bool isUnordered = false;
-  if (mlir::succeeded(
-          parser.parseOptionalKeyword(LoopOp::unorderedAttrName()))) {
+  if (mlir::succeeded(parser.parseOptionalKeyword(LoopOp::unorderedAttrName())))
     result.addAttribute(LoopOp::unorderedAttrName(), builder.getUnitAttr());
-    isUnordered = true;
-  }
 
   // Parse the body region.
   mlir::Region *body = result.addRegion();

From a36cd26267d0310707a0fa45a8a50e47d517666d Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 18 Mar 2020 11:59:47 -0700
Subject: [PATCH 248/345] changes

---
 lib/Lower/Bridge.cpp | 51 ++++++++++++++++++++++++++++++--------------
 1 file changed, 35 insertions(+), 16 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index d87770172d2a..836e07d61b89 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -27,6 +27,7 @@
 #include "mlir/Parser.h"
 #include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorHandling.h"
 
 #undef TODO
 #define TODO()                                                                 \
@@ -35,7 +36,7 @@
       mlir::emitError(toLocation(), __FILE__)                                  \
           << ":" << __LINE__ << " not implemented";                            \
     else                                                                       \
-      assert(false && "not yet implemented");                                  \
+      llvm_unreachable("not yet implemented");                                 \
   }
 
 static llvm::cl::opt<bool>
@@ -220,6 +221,17 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return builder->createFunction(callee, funcTy);
   }
 
+  bool isNumericScalarCategory(Fortran::common::TypeCategory cat) {
+    return cat == Fortran::lower::IntegerCat ||
+           cat == Fortran::lower::RealCat ||
+           cat == Fortran::lower::ComplexCat ||
+           cat == Fortran::lower::LogicalCat;
+  }
+
+  bool isCharacterCategory(Fortran::common::TypeCategory cat) {
+    return cat == Fortran::lower::CharacterCat;
+  }
+
   static bool inMainProgram(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(Fortran::common::visitors{
                           [](Fortran::lower::pft::FunctionLikeUnit *c) {
@@ -232,6 +244,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                       },
                       cstr->parentVariant.p);
   }
+  
   static const Fortran::parser::SubroutineStmt *
   inSubroutine(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
@@ -246,6 +259,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         },
         cstr->parentVariant.p);
   }
+  
   static const Fortran::parser::FunctionStmt *
   inFunction(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
@@ -260,6 +274,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         },
         cstr->parentVariant.p);
   }
+  
   static const Fortran::parser::MpSubprogramStmt *
   inMpSubprogram(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
@@ -303,9 +318,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     genFIRConditionalBranch(cond, trueTarget->block, falseTarget->block);
   }
 
-  //
+  //===--------------------------------------------------------------------===//
   // Function-like PFT entry and exit statements
-  //
+  //===--------------------------------------------------------------------===//
 
   void
   genFIR(const Fortran::parser::Statement<Fortran::parser::ProgramStmt> &stmt,
@@ -474,8 +489,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
     auto funTy = mlir::FunctionType::get(argTy, resTy, builder->getContext());
     // FIXME: mangle name
-    mlir::FuncOp func = getFunc(funName, funTy);
-    (void)func; // FIXME
+    [[maybe_unused]] mlir::FuncOp func = getFunc(funName, funTy);
     std::vector<mlir::Value> actuals;
     for (auto &aa :
          std::get<std::list<Fortran::parser::ActualArgSpec>>(stmt.v.t)) {
@@ -1060,7 +1074,18 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               } else if (sym && Fortran::semantics::IsPointer(*sym)) {
                 // Target of the pointer must be assigned.
                 // See Fortran 2018 10.2.1.3 p2
-                TODO();
+                auto lhsType = assignment.lhs.GetType();
+                assert(lhsType && "lhs cannot be typeless");
+                if (isNumericScalarCategory(lhsType->category())) {
+                  builder->create<fir::StoreOp>(toLocation(),
+                                                genExprValue(assignment.rhs),
+                                                genExprValue(assignment.lhs));
+                } else if (isCharacterCategory(lhsType->category())) {
+                  TODO();
+                } else {
+                  assert(lhsType->category() == Fortran::lower::DerivedCat);
+                  TODO();
+                }
               } else if (assignment.lhs.Rank() > 0) {
                 // Array assignment
                 // See Fortran 2018 10.2.1.3 p5, p6, and p7
@@ -1069,26 +1094,20 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                 // Scalar assignments
                 auto lhsType = assignment.lhs.GetType();
                 assert(lhsType && "lhs cannot be typeless");
-                switch (lhsType->category()) {
-                case Fortran::lower::IntegerCat:
-                case Fortran::lower::RealCat:
-                case Fortran::lower::ComplexCat:
-                case Fortran::lower::LogicalCat:
+                if (isNumericScalarCategory(lhsType->category())) {
                   // Fortran 2018 10.2.1.3 p8 and p9
                   // Conversions are already inserted by semantic
                   // analysis.
                   builder->create<fir::StoreOp>(toLocation(),
                                                 genExprValue(assignment.rhs),
                                                 genExprAddr(assignment.lhs));
-                  break;
-                case Fortran::lower::CharacterCat:
+                } else if (isCharacterCategory(lhsType->category())) {
                   // Fortran 2018 10.2.1.3 p10 and p11
                   genCharacterAssignment(assignment);
-                  break;
-                case Fortran::lower::DerivedCat:
+                } else {
+                  assert(lhsType->category() == Fortran::lower::DerivedCat);
                   // Fortran 2018 10.2.1.3 p12 and p13
                   TODO();
-                  break;
                 }
               }
             },

From e3078f22c3093f754f1765ed715cd35cd1530afa Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 18 Mar 2020 14:28:38 -0700
Subject: [PATCH 249/345] fallout from rebasing to latest master changes

---
 CMakeLists.txt                            |   4 +-
 test-lit/CMakeLists.txt                   |  42 --
 test-lit/Fir/fir-ops.fir                  | 402 -------------
 test-lit/Fir/fir-types.fir                |  77 ---
 {test-lit => test}/Fir/complex.fir        |   0
 {test-lit => test}/Fir/cse.fir            |   0
 {test-lit => test}/Fir/embox-write.fir    |   0
 test/Fir/fir-ops.fir                      |   3 +-
 test/Fir/fir-types.fir                    |   1 -
 {test-lit => test}/Fir/global.fir         |   0
 {test-lit => test}/Fir/loop.fir           |   0
 {test-lit => test}/Fir/loop10.fir         |   0
 {test-lit => test}/Fir/print_complex.c    |   0
 {test-lit => test}/Fir/real.fir           |   0
 {test-lit => test}/Fir/recursive-type.fir |   0
 {test-lit => test}/Fir/select-type.fir    |   0
 {test-lit => test}/Fir/select.fir         |   0
 {test-lit => test}/Fir/widechar.fir       |   0
 test/fir/addrof.1.fir                     |   7 -
 test/fir/aggregate.fir                    |  11 -
 test/fir/alloc.fir                        |  21 -
 test/fir/arrayset.fir                     |  16 -
 test/fir/bugs/bug0001.fir                 |  41 --
 test/fir/bugs/bug0002.fir                 |  12 -
 test/fir/character.fir                    |  12 -
 test/fir/commute.fir                      |  21 -
 test/fir/compare.fir                      |  29 -
 test/fir/complex.fir                      |  22 -
 test/fir/complex.mlir                     |   6 -
 test/fir/constant.fir                     |  19 -
 test/fir/dynlayout.fir                    |  38 --
 test/fir/embox.fir                        |   6 -
 test/fir/fir-dt.fir                       |   5 -
 test/lower/character-assignment.f90       |  69 ---
 test/lower/expr-test-generator.cc         | 692 ----------------------
 test/lower/test-character-assignment.cc   | 357 -----------
 test/lower/test_character_assignment.sh   |  45 --
 test/lower/test_expression_lowering.sh    |  55 --
 38 files changed, 4 insertions(+), 2009 deletions(-)
 delete mode 100644 test-lit/CMakeLists.txt
 delete mode 100644 test-lit/Fir/fir-ops.fir
 delete mode 100644 test-lit/Fir/fir-types.fir
 rename {test-lit => test}/Fir/complex.fir (100%)
 rename {test-lit => test}/Fir/cse.fir (100%)
 rename {test-lit => test}/Fir/embox-write.fir (100%)
 rename {test-lit => test}/Fir/global.fir (100%)
 rename {test-lit => test}/Fir/loop.fir (100%)
 rename {test-lit => test}/Fir/loop10.fir (100%)
 rename {test-lit => test}/Fir/print_complex.c (100%)
 rename {test-lit => test}/Fir/real.fir (100%)
 rename {test-lit => test}/Fir/recursive-type.fir (100%)
 rename {test-lit => test}/Fir/select-type.fir (100%)
 rename {test-lit => test}/Fir/select.fir (100%)
 rename {test-lit => test}/Fir/widechar.fir (100%)
 delete mode 100644 test/fir/addrof.1.fir
 delete mode 100644 test/fir/aggregate.fir
 delete mode 100644 test/fir/alloc.fir
 delete mode 100644 test/fir/arrayset.fir
 delete mode 100644 test/fir/bugs/bug0001.fir
 delete mode 100644 test/fir/bugs/bug0002.fir
 delete mode 100644 test/fir/character.fir
 delete mode 100644 test/fir/commute.fir
 delete mode 100644 test/fir/compare.fir
 delete mode 100644 test/fir/complex.fir
 delete mode 100644 test/fir/complex.mlir
 delete mode 100644 test/fir/constant.fir
 delete mode 100644 test/fir/dynlayout.fir
 delete mode 100644 test/fir/embox.fir
 delete mode 100644 test/fir/fir-dt.fir
 delete mode 100644 test/lower/character-assignment.f90
 delete mode 100644 test/lower/expr-test-generator.cc
 delete mode 100644 test/lower/test-character-assignment.cc
 delete mode 100755 test/lower/test_character_assignment.sh
 delete mode 100755 test/lower/test_expression_lowering.sh

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 303d8ba6e8d5..d0715e9797d4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -318,8 +318,10 @@ option(FLANG_INCLUDE_TESTS
 if (FLANG_INCLUDE_TESTS)
   enable_testing()
   add_subdirectory(test)
+else()
+  enable_testing()
+  add_subdirectory(test)
 endif()
-add_subdirectory(test-lit)
 
 # TODO: Add doxygen support.
 #option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
diff --git a/test-lit/CMakeLists.txt b/test-lit/CMakeLists.txt
deleted file mode 100644
index 3d41e643f37e..000000000000
--- a/test-lit/CMakeLists.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-# Test runner infrastructure for Flang. This configures the Flang test trees
-# for use by Lit, and delegates to LLVM's lit test handlers.
-
-# f18 modules directory
-set(FLANG_INTRINSIC_MODULES_DIR ${FLANG_BINARY_DIR}/include/flang)
-
-# f18/flang tools path for lit
-set(FLANG_TOOLS_DIR  ${FLANG_BINARY_DIR}/tools/f18/bin)
-
-# bbc/tco tools path for lit
-set(FLANG_LLVM_TOOLS_DIR  ${FLANG_BINARY_DIR}/bin)
-
-configure_lit_site_cfg(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
-  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
-  MAIN_CONFIG
-  ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
-)
-
-set(FLANG_TEST_PARAMS
-  flang_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py)
-
-set(FLANG_TEST_DEPENDS
-  f18
-  llvm-lit
-  FileCheck
-  count
-  not
-  bbc
-  tco
-)
-
-add_lit_testsuite(check-flang "Running the Flang regression tests"
-  ${CMAKE_CURRENT_BINARY_DIR}
-  PARAMS ${FLANG_TEST_PARAMS}
-  DEPENDS ${FLANG_TEST_DEPENS}
-)
-
-set_target_properties(check-flang PROPERTIES FOLDER "Tests")
-add_lit_testsuites(FLANG ${CMAKE_CURRENT_SOURCE_DIR}
-  DEPENDS ${FLANG_TEST_DEPS}
-)
diff --git a/test-lit/Fir/fir-ops.fir b/test-lit/Fir/fir-ops.fir
deleted file mode 100644
index 770c79b701ce..000000000000
--- a/test-lit/Fir/fir-ops.fir
+++ /dev/null
@@ -1,402 +0,0 @@
-// Test the FIR operations
-
-// RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
-
-// CHECK-LABEL: func @it1() -> !fir.int<4>
-func @it1() -> !fir.int<4>
-// CHECK-LABEL: func @box1() -> !fir.boxchar<2>
-func @box1() -> !fir.boxchar<2>
-// CHECK-LABEL: func @box2() -> !fir.boxproc<(i32, i32) -> i64>
-func @box2() -> !fir.boxproc<(i32, i32) -> i64>
-// CHECK-LABEL: func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
-func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
-
-// Fortran SUBROUTINE and FUNCTION
-// CHECK-LABEL: func @print_index3(index, index, index)
-// CHECK-LABEL: func @user_i64(i64)
-// CHECK-LABEL: func @user_tdesc(!fir.tdesc<!fir.type<x>>)
-func @print_index3(index, index, index)
-func @user_i64(i64)
-func @user_tdesc(!fir.tdesc<!fir.type<x>>)
-
-// expect the void return to be omitted
-// CHECK-LABEL: func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>)
-func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> ()
-
-// CHECK-LABEL: func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
-// CHECK-LABEL: func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
-func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
-func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
-
-// CHECK-LABEL: func @nop()
-func @nop()
-
-// CHECK-LABEL: func @get_func() -> (() -> ())
-func @get_func() -> (() -> ())
-
-// CHECK-LABEL: @instructions
-func @instructions() {
-  // CHECK: %[[A0:.*]] = fir.alloca !fir.array<10xi32>
-  %0 = fir.alloca !fir.array<10xi32>
-  // CHECK: fir.load %[[A0]] : !fir.ref<!fir.array<10xi32>>
-  %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
-  %2 = fir.alloca i32
-  %3 = constant 22 : i32
-  // CHECK: fir.store %{{.*}} to %{{.*}} : !fir.ref<i32>
-  fir.store %3 to %2 : !fir.ref<i32>
-  // CHECK: fir.undefined i32
-  %4 = fir.undefined i32
-  // CHECK: %[[A5:.*]] = fir.allocmem !fir.array<100xf32>
-  %5 = fir.allocmem !fir.array<100xf32>
-  // CHECK: %[[A6:.*]] = fir.embox %[[A5]] : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
-  %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
-  // CHECK: fir.box_addr %{{.*}} : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
-  %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
-  %c0 = constant 0 : index
-  // CHECK: %[[A8:.*]]:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
-  %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
-  // CHECK: fir.call @print_index3(%[[A8]]#0, %[[A8]]#1, %[[A8]]#2) : (index, index, index)
-  fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()
-  %8 = fir.call @it1() : () -> !fir.int<4>
-  // CHECK: fir.box_elesize %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
-  %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i64
-  // CHECK: fir.box_isalloc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
-  %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  // CHECK: fir.box_isarray %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
-  %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  // CHECK: fir.box_isptr %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
-  %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  // CHECK: fir.box_rank %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
-  %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64
-  // CHECK: fir.box_tdesc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
-  %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
-  %15 = fir.call @box1() : () -> !fir.boxchar<2>
-  // CHECK: fir.boxchar_len %{{.*}} : (!fir.boxchar<2>) -> i32
-  %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
-  %17 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
-  // CHECK: fir.boxproc_host %{{.*}} : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
-  %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
-  %19 = constant 10 : i32
-  // CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
-  %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
-  // CHECK: fir.field_index f, !fir.type<derived{f:f32}>
-  %21 = fir.field_index f, !fir.type<derived{f:f32}>
-  // CHECK: fir.undefined !fir.type<derived{f:f32}>
-  %22 = fir.undefined !fir.type<derived{f:f32}>
-  // CHECK: fir.extract_value %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, !fir.field) -> f32
-  %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32
-  %c1 = constant 1 : i32
-  // CHECK: fir.gendims %{{.*}}, %{{.*}}, %{{.*}} : (i32, i32, i32) -> !fir.dims<1>
-  %24 = fir.gendims %c1, %19, %c1 : (i32, i32, i32) -> !fir.dims<1>
-  %cf1 = constant 1.0 : f32
-  // CHECK: fir.insert_value %{{.*}}, %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
-  %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
-  // CHECK: fir.len_param_index f, !fir.type<derived3{f:f32}>
-  %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>
-  %27 = fir.call @box3() : () -> !fir.box<!fir.type<derived3{f:f32}>>
-  // CHECK: fir.dispatch "method"(%{{.*}}) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
-  %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
-  // CHECK: fir.convert %{{.*}} : (i32) -> i64
-  %29 = fir.convert %28 : (i32) -> i64
-  // CHECK: fir.gentypedesc !fir.type<x>
-  %30 = fir.gentypedesc !fir.type<x>
-  fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
-  // CHECK: fir.no_reassoc %{{.*}} : i64
-  %31 = fir.no_reassoc %29 : i64
-  fir.call @user_i64(%31) : (i64) -> ()
-  // CHECK: fir.freemem %{{.*}} : !fir.heap<!fir.array<100xf32>>
-  fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
-  %32 = fir.call @get_func() : () -> (() -> ())
-  fir.call %32() : () -> ()
-  // CHECK: fir.address_of(@it1) : !fir.ref<() -> !fir.int<4>>
-  %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
-  return
-}
-
-// CHECK-LABEL: @boxing_match
-func @boxing_match() {
-  %0 = fir.alloca i32
-  %d6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
-  %d3 = fir.alloca !fir.char<1>
-  %e6 = fir.alloca tuple<i32,f64>
-  %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>
-  // CHECK: fir.unbox %{{.*}} : (!fir.box<i32>) -> (!fir.ref<i32>, i32, i32, !fir.tdesc<i32>, i32, !fir.dims<0>)
-  %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.dims<0>)
-  %c8 = constant 8 : i32
-  %3 = fir.undefined !fir.char<1>
-  // CHECK: fir.emboxchar %{{.*}}, %{{.*}} : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
-  // CHECK: fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
-  %4 = fir.emboxchar %d3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
-  %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
-  %6 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
-  %z = constant 0 : i32
-  %c12 = constant 12 : i32
-  %a2 = fir.insert_value %6, %c12, %z : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
-  %z1 = constant 1 : i32
-  %c42 = constant 42.13 : f64
-  %a3 = fir.insert_value %6, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
-  fir.store %a3 to %d6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
-  %7 = fir.emboxproc @method_impl, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
-  %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
-  // CHECK: fir.emboxproc @method_impl, %{{.*}} : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
-  // CHECK: fir.unboxproc %{{.*}} : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
-  %9 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
-  %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)
-  %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>
-  fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()
-  return
-}
-
-// CHECK-LABEL: @loop
-func @loop() {
-  %c1 = constant 1 : index
-  %c10 = constant 10 : index
-  %ct = constant true
-  // CHECK: fir.loop %{{.*}} = %{{.*}} to %{{.*}} {
-  fir.loop %i = %c1 to %c10 {
-    // CHECK: fir.where %{{.*}} {
-    fir.where %ct {
-      fir.call @nop() : () -> ()
-    // CHECK: } otherwise {
-    } otherwise {
-      fir.call @nop() : () -> ()
-    }
-  }
-  // CHECK: fir.unreachable
-  fir.unreachable
-}
-
-// CHECK-LABEL: @bar_select
-func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  // CHECK: fir.select %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), -3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), 4, ^bb4(%{{.*}} : i32), unit, ^bb5]
-  fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32, %b2 : i32, %b3:i32) :
-  %4 = addi %b, %b2 : i32
-  %5 = addi %4, %b3 : i32
-  return %5 : i32
-^bb3(%c:i32, %c2:i32) :
-  %6 = addi %c, %c2 : i32
-  return %6 : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  return %zero : i32
-}
-
-// CHECK-LABEL: @bar_select_rank
-func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  // CHECK: fir.select_rank %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), 3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), -1, ^bb4(%{{.*}} : i32), unit, ^bb5]
-  fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32, %b2 : i32, %b3:i32) :
-  %4 = addi %b, %b2 : i32
-  %5 = addi %4, %b3 : i32
-  return %5 : i32
-^bb3(%c:i32, %c2:i32) :
-  %6 = addi %c, %c2 : i32
-  return %6 : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  %7 = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>>
-  fir.dispatch method(%7) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
-  return %zero : i32
-}
-
-// CHECK-LABEL: @bar_select_type
-func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  // CHECK: fir.select_type %{{.*}} : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.instance<!fir.int<4>>, ^bb1(%{{.*}} : i32), #fir.instance<!fir.int<8>>, ^bb2(%{{.*}} : i32), #fir.subsumed<!fir.int<2>>, ^bb3(%{{.*}} : i32), #fir.instance<!fir.int<1>>, ^bb4(%{{.*}} : i32), unit, ^bb5]
-  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32) :
-  return %b : i32
-^bb3(%c : i32) :
-  return %c : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  return %zero : i32
-}
-
-// CHECK-LABEL: @bar_select_case
-func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
-  %0 = constant 1 : i32
-  %1 = constant 2 : i32
-  %2 = constant 3 : i32
-  %3 = constant 4 : i32
-  // CHECK: fir.select_case %{{.*}} : i32 [#fir.point, %{{.*}}, ^bb1(%{{.*}} : i32), #fir.lower, %{{.*}}, ^bb2(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32, i32), #fir.interval, %{{.*}}, %{{.*}}, ^bb3(%{{.*}}, %{{.*}} : i32, i32), #fir.upper, %{{.*}}, ^bb4(%{{.*}} : i32), unit, ^bb5]
-  fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
-^bb1(%a : i32) :
-  return %a : i32
-^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) :
-  %4 = addi %b, %b2 : i32
-  %5 = muli %4, %b3 : i32
-  %6 = addi %5, %b4 : i32
-  return %6 : i32
-^bb3(%c : i32, %c2 : i32) :
-  %7 = addi %c, %c2 : i32
-  return %7 : i32
-^bb4(%d : i32) :
-  return %d : i32
-^bb5 :
-  %zero = constant 0 : i32
-  return %zero : i32
-}
-
-// CHECK-LABEL: @global_var
-fir.global @global_var : i32 {
-  %0 = constant 1 : i32
-  fir.has_value %0 : i32
-}
-
-// CHECK-LABEL: @global_constant
-fir.global @global_constant constant : i32 {
-  %0 = constant 934 : i32
-  fir.has_value %0 : i32
-}
-
-// CHECK-LABEL: @global_derived
-fir.global @global_derived : !fir.type<minez(f:i32)> {
-  // CHECK: fir.global_len "f", 1 : i32
-  fir.global_len f, 1 : i32
-  %0 = fir.undefined !fir.type<minez>
-  fir.has_value %0 : !fir.type<minez>
-}
-
-// CHECK-LABEL: @dispatch_tbl
-fir.dispatch_table @dispatch_tbl {
-  // CHECK: fir.dt_entry "method", @method_impl
-  fir.dt_entry "method", @method_impl
-}
-
-// CHECK-LABEL: @compare_real
-func @compare_real(%a : !fir.real<16>, %b : !fir.real<16>) {
-  // CHECK: fir.cmpf "false", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "oeq", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ogt", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "oge", %{{.*}}, %{{.*}} : !fir.real<16>
-  %d0 = fir.cmpf "false", %a, %b : !fir.real<16>
-  %d1 = fir.cmpf "oeq", %a, %b : !fir.real<16>
-  %d2 = fir.cmpf "ogt", %a, %b : !fir.real<16>
-  %d3 = fir.cmpf "oge", %a, %b : !fir.real<16>
-  // CHECK: fir.cmpf "olt", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ole", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "one", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ord", %{{.*}}, %{{.*}} : !fir.real<16>
-  %a0 = fir.cmpf "olt", %a, %b : !fir.real<16>
-  %a1 = fir.cmpf "ole", %a, %b : !fir.real<16>
-  %a2 = fir.cmpf "one", %a, %b : !fir.real<16>
-  %a3 = fir.cmpf "ord", %a, %b : !fir.real<16>
-  // CHECK: fir.cmpf "ueq", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ugt", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "uge", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ult", %{{.*}}, %{{.*}} : !fir.real<16>
-  %b0 = fir.cmpf "ueq", %a, %b : !fir.real<16>
-  %b1 = fir.cmpf "ugt", %a, %b : !fir.real<16>
-  %b2 = fir.cmpf "uge", %a, %b : !fir.real<16>
-  %b3 = fir.cmpf "ult", %a, %b : !fir.real<16>
-  // CHECK: fir.cmpf "ule", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "une", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "uno", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "true", %{{.*}}, %{{.*}} : !fir.real<16>
-  %c0 = fir.cmpf "ule", %a, %b : !fir.real<16>
-  %c1 = fir.cmpf "une", %a, %b : !fir.real<16>
-  %c2 = fir.cmpf "uno", %a, %b : !fir.real<16>
-  %c3 = fir.cmpf "true", %a, %b : !fir.real<16>
-  return
-}
-
-// CHECK-LABEL: @compare_complex
-func @compare_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) {
-  // CHECK: fir.cmpc "false", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "oeq", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ogt", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "oge", %{{.*}}, %{{.*}} : !fir.complex<16>
-  %d0 = fir.cmpc "false", %a, %b : !fir.complex<16>
-  %d1 = fir.cmpc "oeq", %a, %b : !fir.complex<16>
-  %d2 = fir.cmpc "ogt", %a, %b : !fir.complex<16>
-  %d3 = fir.cmpc "oge", %a, %b : !fir.complex<16>
-  // CHECK: fir.cmpc "olt", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ole", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "one", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ord", %{{.*}}, %{{.*}} : !fir.complex<16>
-  %a0 = fir.cmpc "olt", %a, %b : !fir.complex<16>
-  %a1 = fir.cmpc "ole", %a, %b : !fir.complex<16>
-  %a2 = fir.cmpc "one", %a, %b : !fir.complex<16>
-  %a3 = fir.cmpc "ord", %a, %b : !fir.complex<16>
-  // CHECK: fir.cmpc "ueq", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ugt", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "uge", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ult", %{{.*}}, %{{.*}} : !fir.complex<16>
-  %b0 = fir.cmpc "ueq", %a, %b : !fir.complex<16>
-  %b1 = fir.cmpc "ugt", %a, %b : !fir.complex<16>
-  %b2 = fir.cmpc "uge", %a, %b : !fir.complex<16>
-  %b3 = fir.cmpc "ult", %a, %b : !fir.complex<16>
-  // CHECK: fir.cmpc "ule", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "une", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "uno", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "true", %{{.*}}, %{{.*}} : !fir.complex<16>
-  %c0 = fir.cmpc "ule", %a, %b : !fir.complex<16>
-  %c1 = fir.cmpc "une", %a, %b : !fir.complex<16>
-  %c2 = fir.cmpc "uno", %a, %b : !fir.complex<16>
-  %c3 = fir.cmpc "true", %a, %b : !fir.complex<16>
-  return
-}
-
-// CHECK-LABEL: @arith_real
-func @arith_real(%a : !fir.real<16>, %b : !fir.real<16>) -> !fir.real<16> {
-  %c1 = constant 1.0 : f32
-  %0 = fir.convert %c1 : (f32) -> !fir.real<16>
-  // CHECK: %[[R1:.*]] = fir.negf %{{.*}} : !fir.real<16>
-  // CHECK: fir.addf %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: %[[R3:.*]] = fir.subf %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.mulf %[[R1]], %[[R3]] : !fir.real<16>
-  // CHECK: fir.divf %{{.*}}, %{{.*}} : !fir.real<16>
-  %1 = fir.negf %a : !fir.real<16>
-  %2 = fir.addf %0, %1 : !fir.real<16>
-  %3 = fir.subf %2, %b : !fir.real<16>
-  %4 = fir.mulf %1, %3 : !fir.real<16>
-  %5 = fir.divf %4, %a : !fir.real<16>
-  return %5 : !fir.real<16>
-}
-
-// CHECK-LABEL: @arith_complex
-func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> {
-  // CHECK: fir.negc %{{.*}} : !fir.complex<16>
-  // CHECK: fir.addc %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.subc %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.mulc %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.divc %{{.*}}, %{{.*}} : !fir.complex<16>
-  %1 = fir.negc %a : !fir.complex<16>
-  %2 = fir.addc %b, %1 : !fir.complex<16>
-  %3 = fir.subc %2, %b : !fir.complex<16>
-  %4 = fir.mulc %1, %3 : !fir.complex<16>
-  %5 = fir.divc %4, %a : !fir.complex<16>
-  return %5 : !fir.complex<16>
-}
-
-// CHECK-LABEL: @character_literal
-func @character_literal() -> !fir.array<13 x !fir.char<1>> {
-  // CHECK: fir.string_lit "Hello, World!"(13) : !fir.char<1>
-  %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1>
-  return %0 : !fir.array<13 x !fir.char<1>>
-}
diff --git a/test-lit/Fir/fir-types.fir b/test-lit/Fir/fir-types.fir
deleted file mode 100644
index 9f9b6e6bdb79..000000000000
--- a/test-lit/Fir/fir-types.fir
+++ /dev/null
@@ -1,77 +0,0 @@
-// Test the FIR types
-
-// RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
-
-// Fortran Intrinsic types
-// CHECK-LABEL: func @it1() -> !fir.int<4>
-// CHECK-LABEL: func @it2() -> !fir.real<8>
-// CHECK-LABEL: func @it3() -> !fir.complex<8>
-// CHECK-LABEL: func @it4() -> !fir.logical<1>
-// CHECK-LABEL: func @it5() -> !fir.char<1>
-func @it1() -> !fir.int<4>
-func @it2() -> !fir.real<8>
-func @it3() -> !fir.complex<8>
-func @it4() -> !fir.logical<1>
-func @it5() -> !fir.char<1>
-
-// Fortran Derived types (records)
-// CHECK-LABEL: func @dvd1() -> !fir.type<derived1>
-// CHECK-LABEL: func @dvd2() -> !fir.type<derived2(p:i32)>
-// CHECK-LABEL: func @dvd3() -> !fir.type<derived3{f:f32}>
-// CHECK-LABEL: func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
-// CHECK-LABEL: func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
-// CHECK-LABEL: func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
-func @dvd1() -> !fir.type<derived1>
-func @dvd2() -> !fir.type<derived2(p:i32)>
-func @dvd3() -> !fir.type<derived3{f:f32}>
-func @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
-func @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
-func @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
-
-// FIR array types
-// CHECK-LABEL: func @arr1() -> !fir.array<10xf32>
-// CHECK-LABEL: func @arr2() -> !fir.array<10x10xf32>
-// CHECK-LABEL: func @arr3() -> !fir.array<?xf32>
-// CHECK-LABEL: func @arr4() -> !fir.array<10x?xf32>
-// CHECK-LABEL: func @arr5() -> !fir.array<?x?xf32>
-// CHECK-LABEL: func @arr6() -> !fir.array<*:f32>
-// CHECK-LABEL: func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
-func @arr1() -> !fir.array<10xf32>
-func @arr2() -> !fir.array<10x10xf32>
-func @arr3() -> !fir.array<?xf32>
-func @arr4() -> !fir.array<10x?xf32>
-func @arr5() -> !fir.array<?x?xf32>
-func @arr6() -> !fir.array<*:f32>
-func @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
-
-// FIR pointer-like types
-// CHECK-LABEL: func @mem1() -> !fir.ref<i32>
-// CHECK-LABEL: func @mem2() -> !fir.ptr<i32>
-// CHECK-LABEL: func @mem3() -> !fir.heap<i32>
-// CHECK-LABEL: func @mem4() -> !fir.ref<() -> ()>
-func @mem1() -> !fir.ref<i32>
-func @mem2() -> !fir.ptr<i32>
-func @mem3() -> !fir.heap<i32>
-func @mem4() -> !fir.ref<() -> ()>
-
-// FIR box types (descriptors)
-// CHECK-LABEL: func @box1() -> !fir.box<!fir.array<?xf32>>
-// CHECK-LABEL: func @box2() -> !fir.boxchar<2>
-// CHECK-LABEL: func @box3() -> !fir.boxproc<(i32, i32) -> i64>
-// CHECK-LABEL: func @box4() -> !fir.box<none>
-// CHECK-LABEL: func @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
-func @box1() -> !fir.box<!fir.array<?xf32>>
-func @box2() -> !fir.boxchar<2>
-func @box3() -> !fir.boxproc<(i32, i32) -> i64>
-func @box4() -> !fir.box<none>
-func @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
-
-// FIR misc. types
-// CHECK-LABEL: func @oth1() -> !fir.dims<1>
-// CHECK-LABEL: func @oth2() -> !fir.field
-// CHECK-LABEL: func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
-// CHECK-LABEL: func @oth4() -> !fir.dims<15>
-func @oth1() -> !fir.dims<1>
-func @oth2() -> !fir.field
-func @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
-func @oth4() -> !fir.dims<15>
diff --git a/test-lit/Fir/complex.fir b/test/Fir/complex.fir
similarity index 100%
rename from test-lit/Fir/complex.fir
rename to test/Fir/complex.fir
diff --git a/test-lit/Fir/cse.fir b/test/Fir/cse.fir
similarity index 100%
rename from test-lit/Fir/cse.fir
rename to test/Fir/cse.fir
diff --git a/test-lit/Fir/embox-write.fir b/test/Fir/embox-write.fir
similarity index 100%
rename from test-lit/Fir/embox-write.fir
rename to test/Fir/embox-write.fir
diff --git a/test/Fir/fir-ops.fir b/test/Fir/fir-ops.fir
index bdadf5cd6f58..770c79b701ce 100644
--- a/test/Fir/fir-ops.fir
+++ b/test/Fir/fir-ops.fir
@@ -1,7 +1,6 @@
 // Test the FIR operations
 
 // RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
-// UNSUPPORTED: !fir
 
 // CHECK-LABEL: func @it1() -> !fir.int<4>
 func @it1() -> !fir.int<4>
@@ -154,7 +153,7 @@ func @loop() {
   %c10 = constant 10 : index
   %ct = constant true
   // CHECK: fir.loop %{{.*}} = %{{.*}} to %{{.*}} {
-  %i = fir.loop %i = %c1 to %c10 {
+  fir.loop %i = %c1 to %c10 {
     // CHECK: fir.where %{{.*}} {
     fir.where %ct {
       fir.call @nop() : () -> ()
diff --git a/test/Fir/fir-types.fir b/test/Fir/fir-types.fir
index 19b0286f5b73..9f9b6e6bdb79 100644
--- a/test/Fir/fir-types.fir
+++ b/test/Fir/fir-types.fir
@@ -1,7 +1,6 @@
 // Test the FIR types
 
 // RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
-// UNSUPPORTED: !fir
 
 // Fortran Intrinsic types
 // CHECK-LABEL: func @it1() -> !fir.int<4>
diff --git a/test-lit/Fir/global.fir b/test/Fir/global.fir
similarity index 100%
rename from test-lit/Fir/global.fir
rename to test/Fir/global.fir
diff --git a/test-lit/Fir/loop.fir b/test/Fir/loop.fir
similarity index 100%
rename from test-lit/Fir/loop.fir
rename to test/Fir/loop.fir
diff --git a/test-lit/Fir/loop10.fir b/test/Fir/loop10.fir
similarity index 100%
rename from test-lit/Fir/loop10.fir
rename to test/Fir/loop10.fir
diff --git a/test-lit/Fir/print_complex.c b/test/Fir/print_complex.c
similarity index 100%
rename from test-lit/Fir/print_complex.c
rename to test/Fir/print_complex.c
diff --git a/test-lit/Fir/real.fir b/test/Fir/real.fir
similarity index 100%
rename from test-lit/Fir/real.fir
rename to test/Fir/real.fir
diff --git a/test-lit/Fir/recursive-type.fir b/test/Fir/recursive-type.fir
similarity index 100%
rename from test-lit/Fir/recursive-type.fir
rename to test/Fir/recursive-type.fir
diff --git a/test-lit/Fir/select-type.fir b/test/Fir/select-type.fir
similarity index 100%
rename from test-lit/Fir/select-type.fir
rename to test/Fir/select-type.fir
diff --git a/test-lit/Fir/select.fir b/test/Fir/select.fir
similarity index 100%
rename from test-lit/Fir/select.fir
rename to test/Fir/select.fir
diff --git a/test-lit/Fir/widechar.fir b/test/Fir/widechar.fir
similarity index 100%
rename from test-lit/Fir/widechar.fir
rename to test/Fir/widechar.fir
diff --git a/test/fir/addrof.1.fir b/test/fir/addrof.1.fir
deleted file mode 100644
index 75cc12a55eb1..000000000000
--- a/test/fir/addrof.1.fir
+++ /dev/null
@@ -1,7 +0,0 @@
-fir.global @var_x : !fir.int<4> {}
-
-func @getAddressOfX() -> !fir.ref<!fir.int<4>> {
-  %1 = fir.address_of(@var_x) : !fir.ref<!fir.int<4>>
-  return %1 : !fir.ref<!fir.int<4>>
-}
-
diff --git a/test/fir/aggregate.fir b/test/fir/aggregate.fir
deleted file mode 100644
index c65e38deadd5..000000000000
--- a/test/fir/aggregate.fir
+++ /dev/null
@@ -1,11 +0,0 @@
-func @f_tuple(%a : tuple<i32, i64>) -> i64 {
-  %0 = constant 1 : i32
-  %1 = fir.extract_value %a, %0 : (tuple<i32, i64>, i32) -> i64
-  return %1 : i64
-}
-
-func @f_record(%a : !fir.type<rec1{fa:i32, fb:i64}>) -> i64 {
-  %0 = fir.field_index fb, !fir.type<rec1>
-  %1 = fir.extract_value %a, %0 : (!fir.type<rec1>, !fir.field) -> i64
-  return %1 : i64
-}
diff --git a/test/fir/alloc.fir b/test/fir/alloc.fir
deleted file mode 100644
index e7c0d663c128..000000000000
--- a/test/fir/alloc.fir
+++ /dev/null
@@ -1,21 +0,0 @@
-func @f1() -> !fir.ref<i32> {
-  %1 = fir.alloca i32
-  return %1 : !fir.ref<i32>
-}
-
-func @f2() -> !fir.ref<i32> {
-  %0 = constant 100 : index
-  %1 = fir.alloca i32, %0
-  return %1 : !fir.ref<i32>
-}
-
-func @f3() -> !fir.heap<i32> {
-  %1 = fir.allocmem i32
-  return %1 : !fir.heap<i32>
-}
-
-func @f4() -> !fir.heap<i32> {
-  %0 = constant 100 : index
-  %1 = fir.allocmem i32, %0
-  return %1 : !fir.heap<i32>
-}
diff --git a/test/fir/arrayset.fir b/test/fir/arrayset.fir
deleted file mode 100644
index 2f45aabb0da7..000000000000
--- a/test/fir/arrayset.fir
+++ /dev/null
@@ -1,16 +0,0 @@
-func @x(%arr : !fir.ref<!fir.array<10xf32>>) {
-  %1 = constant 0 : index
-  %2 = constant 9 : index
-  %a = fir.alloca !fir.array<10xf32>
-  fir.loop %iv = %1 to %2 unordered {
-    %3 = fir.coordinate_of %arr, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
-    %4 = fir.load %3 : !fir.ref<f32>
-    %5 = fir.coordinate_of %a, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
-    fir.store %4 to %5 : !fir.ref<f32>
-  } { arrayset }
-  %6 = fir.embox %a : (!fir.ref<!fir.array<10xf32>>) -> !fir.box<!fir.array<10xf32>>
-  fir.call @y(%6) : (!fir.box<!fir.array<10xf32>>) -> ()
-  return
-}
-
-func @y(!fir.box<!fir.array<10xf32>>) -> ()
diff --git a/test/fir/bugs/bug0001.fir b/test/fir/bugs/bug0001.fir
deleted file mode 100644
index 5535adb6d0e3..000000000000
--- a/test/fir/bugs/bug0001.fir
+++ /dev/null
@@ -1,41 +0,0 @@
-func @r_incr(%arg0: !fir.ref<f64>) -> f64 {
-    %0 = fir.alloca f64 {name = "r_incr"} : !fir.ref<f64>
-    %1 = fir.load %arg0 : !fir.ref<f64>
-    fir.store %1 to %0 : !fir.ref<f64>
-    %2 = fir.load %arg0 : !fir.ref<f64>
-    %cst = constant 1.000000e+00 : f64
-    %3 = fir.addf %2, %cst : f64
-    fir.store %3 to %arg0 : !fir.ref<f64>
-    %4 = fir.load %0 : !fir.ref<f64>
-    return %4 : f64
-}
-
-func @_MAIN() {
-    %0 = fir.alloca f64 {name = "y"} : !fir.ref<f64>
-    %1 = fir.alloca f64 {name = "y2"} : !fir.ref<f64>
-    %2 = fir.alloca f64 {name = "y1"} : !fir.ref<f64>
-    %3 = fir.alloca f64 {name = "x"} : !fir.ref<f64>
-    %cst = constant 1.000000e+00 : f64
-    fir.store %cst to %3 : !fir.ref<f64>
-    %4 = fir.load %3 : !fir.ref<f64>
-    fir.store %4 to %2 : !fir.ref<f64>
-    %5 = fir.load %2 : !fir.ref<f64>
-    %6 = call @r_incr(%3) : (!fir.ref<f64>) -> f64
-    %7 = fir.addf %5, %6 : f64
-    fir.store %7 to %1 : !fir.ref<f64>
-    %8 = fir.load %1 : !fir.ref<f64>
-    %9 = fir.load %3 : !fir.ref<f64>
-    %10 = fir.addf %8, %9 : f64
-    fir.store %10 to %0 : !fir.ref<f64>
-    %c1_i32 = constant 1 : i32
-    %11 = call @__F18IOa_BeginExternalListOutput(%c1_i32) : (i32) -> !fir.ref<i32>
-    %12 = fir.load %0 : !fir.ref<f64>
-    call @__F18IOa_OutputReal64(%11, %12) : (!fir.ref<i32>, f64) -> ()
-    call @__F18IOa_EndIOStatement(%11) : (!fir.ref<i32>) -> ()
-    return
-}
-
-func @__F18IOa_BeginExternalListOutput(i32) -> !fir.ref<i32>
-func @__F18IOa_OutputInteger64(!fir.ref<i32>, i64)
-func @__F18IOa_OutputReal64(!fir.ref<i32>, f64)
-func @__F18IOa_EndIOStatement(!fir.ref<i32>)
diff --git a/test/fir/bugs/bug0002.fir b/test/fir/bugs/bug0002.fir
deleted file mode 100644
index f163e76035e9..000000000000
--- a/test/fir/bugs/bug0002.fir
+++ /dev/null
@@ -1,12 +0,0 @@
-func @foo() -> f32 {
-    %0 = fir.alloca f32 {name = "foo"} : !fir.ref<f32>
-    %1 = fir.alloca f32 {name = "x"} : !fir.ref<f32>
-    %cst = constant 4.200000e+01 : f32
-    fir.store %cst to %1 : !fir.ref<f32>
-    %cst_0 = constant 6.600000e+01 : f32
-    fir.store %cst_0 to %1 : !fir.ref<f32>
-    %2 = fir.load %1 : !fir.ref<f32>
-    fir.store %2 to %0 : !fir.ref<f32>
-    %3 = fir.load %0 : !fir.ref<f32>
-    return %3 : f32
-}
diff --git a/test/fir/character.fir b/test/fir/character.fir
deleted file mode 100644
index c4a11a607d7a..000000000000
--- a/test/fir/character.fir
+++ /dev/null
@@ -1,12 +0,0 @@
-
-fir.global @name constant : !fir.char<1> {
-  constant "Your name"
-  //constant 1
-}
-
-func @get_name() -> !fir.boxchar<1> {
-  %j1 = fir.address_of (@name_constant) : !fir.ref<!fir.char<1>>
-  %j2 = constant 9 : i64
-  %j3 = fir.emboxchar %j1, %j2 : (!fir.ref<!fir.char<1>>, i64) -> !fir.boxchar<1>
-  return %j3 : !fir.boxchar<1>
-}
diff --git a/test/fir/commute.fir b/test/fir/commute.fir
deleted file mode 100644
index 6e55bb0e36be..000000000000
--- a/test/fir/commute.fir
+++ /dev/null
@@ -1,21 +0,0 @@
-func @f1(%a : i32, %b : i32) -> i32 {
-  %1 = addi %a, %b : i32
-  %2 = addi %b, %a : i32
-  %3 = muli %1, %2 : i32
-  return %3 : i32
-}
-
-func @f2(%a : !fir.ref<i32>) -> i32 {
-  %1 = fir.load %a : !fir.ref<i32>
-  %2 = fir.load %a : !fir.ref<i32>
-  %3 = addi %1, %2 : i32
-  %4 = fir.load %a : !fir.ref<i32>
-  %5 = addi %3, %4 : i32
-  %6 = fir.load %a : !fir.ref<i32>
-  %7 = addi %5, %6 : i32
-  %8 = fir.load %a : !fir.ref<i32>
-  %9 = addi %7, %8 : i32
-  %10 = fir.load %a : !fir.ref<i32>
-  %11 = addi %10, %9 : i32
-  return %11 : i32
-}
diff --git a/test/fir/compare.fir b/test/fir/compare.fir
deleted file mode 100644
index 8aa9f6864dc1..000000000000
--- a/test/fir/compare.fir
+++ /dev/null
@@ -1,29 +0,0 @@
-func @cmp(%a : !fir.real<10>, %b : !fir.real<10>) -> i1 {
-  %1 = "fir.cmpf"(%a, %b) {predicate = 1} : (!fir.real<10>, !fir.real<10>) -> i1
-  return %1 : i1
-}
-
-func @cmp2(%a : !fir.real<16>, %b : !fir.real<16>) -> i1 {
-  %1 = fir.cmpf "ult", %a, %b : !fir.real<16>
-  return %1 : i1
-}
-
-func @cmp3(%a : !fir.complex<4>, %b : !fir.complex<4>) -> i1 {
-  %1 = fir.cmpc "ueq", %a, %b : !fir.complex<4>
-  return %1 : i1
-}
-
-func @neg1(%a : !fir.real<8>) -> !fir.real<8> {
-  %1 = "fir.negf"(%a) : (!fir.real<8>) -> !fir.real<8>
-  return %1 : !fir.real<8>
-}
-
-func @neg2(%a : !fir.real<8>) -> !fir.real<8> {
-  %1 = fir.negf %a : !fir.real<8>
-  return %1 : !fir.real<8>
-}
-
-func @neg3(%a : !fir.complex<8>) -> !fir.complex<8> {
-  %1 = fir.negc %a : !fir.complex<8>
-  return %1 : !fir.complex<8>
-}
diff --git a/test/fir/complex.fir b/test/fir/complex.fir
deleted file mode 100644
index 958baa430ff4..000000000000
--- a/test/fir/complex.fir
+++ /dev/null
@@ -1,22 +0,0 @@
-func @foo(%a : !fir.complex<4>, %b : !fir.complex<4>, %c : !fir.complex<4>, %d : !fir.complex<4>, %e : !fir.complex<4>) -> !fir.complex<4> {
-  %1 = fir.addc %a, %b : !fir.complex<4>
-  %2 = fir.mulc %1, %c : !fir.complex<4>
-  %3 = fir.subc %2, %d : !fir.complex<4>
-  %4 = fir.divc %3, %e : !fir.complex<4>
-  return %4 : !fir.complex<4>
-}
-
-func @f2(%a : !fir.complex<4>) -> f32 {
-  %0 = constant 0 : i32
-  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
-  return %1 : f32
-}
-
-func @f3(%a : !fir.complex<4>) -> !fir.complex<4> {
-  %0 = constant 1 : i32
-  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
-  %2 = constant 0.0 : f32
-  %3 = fir.subf %2, %1 : f32
-  %4 = fir.insert_value %a, %3, %0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
-  return %4 : !fir.complex<4>
-}
diff --git a/test/fir/complex.mlir b/test/fir/complex.mlir
deleted file mode 100644
index 5a36992c9567..000000000000
--- a/test/fir/complex.mlir
+++ /dev/null
@@ -1,6 +0,0 @@
-func @add(%a : complex<f32>, %b : complex<f32>) -> complex<f32>
-
-func @foo(%a : complex<f32>, %b : complex<f32>) -> complex<f32> {
-  %1 = call @add(%a, %b) : (complex<f32>, complex<f32>) -> complex<f32>
-  return %1 : complex<f32>
-}
diff --git a/test/fir/constant.fir b/test/fir/constant.fir
deleted file mode 100644
index 67ca40f36611..000000000000
--- a/test/fir/constant.fir
+++ /dev/null
@@ -1,19 +0,0 @@
-func @x() -> !fir.array<3x!fir.char<1>> {
-  %1 = fir.constant "xyz" : !fir.array<3x!fir.char<1>>
-  return %1 : !fir.array<3x!fir.char<1>>
-}
-
-func @y() -> !fir.real<10> {
-  %1 = fir.constant "42.4" : !fir.real<10>
-  return %1 : !fir.real<10>
-}
-
-func @z() -> !fir.logical<1> {
-  %1 = fir.constant "true" : !fir.logical<1>
-  return %1 : !fir.logical<1>
-}
-
-func @z2() -> !fir.ref<!fir.char<1>> {
-  %1 = fir.constant "abc" : !fir.ref<!fir.char<1>>
-  return %1 : !fir.ref<!fir.char<1>>
-}
diff --git a/test/fir/dynlayout.fir b/test/fir/dynlayout.fir
deleted file mode 100644
index 5646db53975e..000000000000
--- a/test/fir/dynlayout.fir
+++ /dev/null
@@ -1,38 +0,0 @@
-// dynamic case
-
-// dynamically sized type
-func @_QQSIZEOF_a(%p1 : i64, %p2 : i64) -> i64 {
-  %c1 = constant 1 : i64  // sizeof CHARACTER(1)
-  %1 = muli %p1, %c1 : i64
-  %c2 = constant 2 : i64  // sizeof CHARACTER(2)
-  %2 = muli %p2, %c2 : i64
-  %3 = addi %1, %2 : i64
-  return %3 : i64
-}
-
-func @_QQOFFSETOF_a_f1(%p1 : i64, %p2 : i64) -> i32 {
-  %0 = constant 0 : i64
-  %1 = fir.convert %0 : (i64) -> i32
-  return %1 : i32
-}
-
-func @_QQOFFSETOF_a_f2(%p1 : i64, %p2 : i64) -> i32 {
-  %c1 = constant 1 : i64
-  %1 = muli %p1, %c1 : i64
-  %2 = fir.convert %1 : (i64) -> i32
-  return %2 : i32
-}
-
-// get 'a%f2(x)'
-func @f(%a : !fir.box<!fir.type<a(p1:i64,p2:i64){f1:!fir.array<?x!fir.char<1>>, f2:!fir.array<?x!fir.char<2>>}>>, %x : i32, %q1 : i64, %q2 : i64) -> !fir.char<2> {
-  %p1p = fir.len_param_index p1, !fir.type<a>
-  %p2p = fir.len_param_index p2, !fir.type<a>
-  %p1c = fir.coordinate_of %a, %p1p : (!fir.box<!fir.type<a>>, !fir.len) -> !fir.ref<i64>
-  %p2c = fir.coordinate_of %a, %p2p : (!fir.box<!fir.type<a>>, !fir.len) -> !fir.ref<i64>
-  %p1 = fir.load %p1c : !fir.ref<i64>
-  %p2 = fir.load %p2c : !fir.ref<i64>
-  %1 = fir.field_index f2, !fir.type<a>(%p1, %p2) : i64, i64
-  %2 = fir.coordinate_of %a, %1, %x : (!fir.box<!fir.type<a>>, !fir.field, i32) -> !fir.ref<!fir.char<2>>
-  %3 = fir.load %2 : !fir.ref<!fir.char<2>>
-  return %3 : !fir.char<2>
-}
diff --git a/test/fir/embox.fir b/test/fir/embox.fir
deleted file mode 100644
index 801e7241b424..000000000000
--- a/test/fir/embox.fir
+++ /dev/null
@@ -1,6 +0,0 @@
-#x0 = (d0, d1) -> (d1, d0)
-
-func @f(%arg : !fir.ref<!fir.array<?xf64>>) {
-  %1 = fir.embox %arg [#x0] : (!fir.ref<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>, >
-  return
-}
diff --git a/test/fir/fir-dt.fir b/test/fir/fir-dt.fir
deleted file mode 100644
index 7dbd6bd13187..000000000000
--- a/test/fir/fir-dt.fir
+++ /dev/null
@@ -1,5 +0,0 @@
-func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
-
-fir.dispatch_table @dispatch_tbl {
-  fir.dt_entry method, @method_impl
-}
diff --git a/test/lower/character-assignment.f90 b/test/lower/character-assignment.f90
deleted file mode 100644
index 65550902e8d5..000000000000
--- a/test/lower/character-assignment.f90
+++ /dev/null
@@ -1,69 +0,0 @@
-! Simple character assignment tests
-subroutine assign1(s1, s2)
-  character(*, 1) :: s1, s2
-  s1 = s2
-end subroutine
-subroutine assign2(s1, s2)
-  character(*, 2) :: s1, s2
-  s1 = s2
-end subroutine
-subroutine assign4(s1, s2)
-  character(*, 4) :: s1, s2
-  s1 = s2
-end subroutine
-
-! Test substring assignment
-subroutine assign_substring1(s1, s2, lb, ub)
-  character(*, 1) :: s1, s2
-  integer :: lb, ub
-  s1(lb:ub) = s2
-end subroutine
-subroutine assign_substring2(s1, s2, lb, ub)
-  character(*, 2) :: s1, s2
-  integer :: lb, ub
-  s1(lb:ub) = s2
-end subroutine
-subroutine assign_substring4(s1, s2, lb, ub)
-  character(*, 4) :: s1, s2
-  integer :: lb, ub
-  s1(lb:ub) = s2
-end subroutine
-
-! Test overlapping assignments
-! RHS depends on LHS in a way that if no temp is made to evaluate
-! RHS, these tests should fail.
-subroutine assign_overlap1(s1, s2, lb)
-  character(*, 1) :: s1, s2
-  integer :: lb
-  s1(lb:) = s1
-end subroutine
-subroutine assign_overlap2(s1, s2, lb)
-  character(*, 2) :: s1, s2
-  integer :: lb
-  s1(lb:) = s1
-end subroutine
-subroutine assign_overlap4(s1, s2, lb)
-  character(*, 4) :: s1, s2
-  integer :: lb
-  s1(lb:) = s1
-end subroutine
-
-! Test when length is given in specification expressions
-subroutine assign_spec_expr_len1(s1, s2, l1, l2)
-  integer :: l1, l2
-  character(l1, 1) :: s1
-  character(l2, 1) :: s2
-  s1 = s2
-end subroutine
-subroutine assign_spec_expr_len2(s1, s2, l1, l2)
-  integer :: l1, l2
-  character(l1, 2) :: s1
-  character(l2, 2) :: s2
-  s1 = s2
-end subroutine
-subroutine assign_spec_expr_len4(s1, s2, l1, l2)
-  integer :: l1, l2
-  character(l1, 4) :: s1
-  character(l2, 4) :: s2
-  s1 = s2
-end subroutine
diff --git a/test/lower/expr-test-generator.cc b/test/lower/expr-test-generator.cc
deleted file mode 100644
index a4f3a741bfb6..000000000000
--- a/test/lower/expr-test-generator.cc
+++ /dev/null
@@ -1,692 +0,0 @@
-//===-- test/lower/expr-test-generator.cc -----------------------*- 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 <cassert>
-#include <cstring>
-#include <iostream>
-#include <map>
-#include <optional>
-#include <sstream>
-#include <vector>
-
-// Utility to generate Fortran expression evaluation tests.
-// Given an expression "x op y", this utility can generates
-// functions that evaluate the expression and takes x and y
-// as argument and return the result.
-// The utility allows to describe fortran intrinsic operations
-// and their possible operand types in a table driven way.
-// Functions to test all possible intrinsic operations can then be
-// generated.
-// The utility can also generate a driver function that calls the
-// previous and compare the results with expectations
-// (currently provided by calling a similar function compiled by a reference
-// compiler).
-
-// TODO: Integrate with f18 libs to remove redundancies ?
-// TODO: How could Peter's intrinsic table be used to generate
-//       intrinsic expression tests in a similar way ?
-
-enum class TypeCategory { Integer, Real, Complex, Logical, Character };
-
-struct Type {
-  constexpr Type(TypeCategory c) : cat{c}, kind{} {}
-  constexpr Type(TypeCategory c, int k) : cat{c}, kind{k} {}
-  bool operator==(const Type &that) const {
-    return cat == that.cat && kind == that.kind;
-  }
-  bool operator!=(const Type &that) const { return !(*this == that); }
-  std::ostream &Dump(std::ostream &s) const {
-    switch (cat) {
-    case TypeCategory::Integer: s << "INTEGER"; break;
-    case TypeCategory::Real: s << "REAL"; break;
-    case TypeCategory::Logical: s << "LOGICAL"; break;
-    case TypeCategory::Complex: s << "COMPLEX"; break;
-    case TypeCategory::Character: s << "CHARACTER"; break;
-    }
-    if (kind) {
-      s << "(" << *kind << ")";
-    }
-    return s;
-  }
-
-  TypeCategory cat;
-  std::optional<int> kind;  // none = default
-};
-
-static constexpr Type DefaultReal{TypeCategory::Real};
-static constexpr Type Real4{TypeCategory::Real, 4};
-static constexpr Type Real8{TypeCategory::Real, 8};
-static constexpr Type DefaultInteger{TypeCategory::Integer};
-static constexpr Type Integer1{TypeCategory::Integer, 1};
-static constexpr Type Integer2{TypeCategory::Integer, 2};
-static constexpr Type Integer4{TypeCategory::Integer, 4};
-static constexpr Type Integer8{TypeCategory::Integer, 8};
-static constexpr Type DefaultComplex{TypeCategory::Complex};
-static constexpr Type Complex4{TypeCategory::Complex, 4};
-static constexpr Type Complex8{TypeCategory::Complex, 4};
-static constexpr Type DefaultLogical{TypeCategory::Logical};
-// Currently other types are not testable because existing Fortran
-// compilers do not provide these types.
-
-enum class TypePattern {
-  OperandNumeric,
-  OperandLogical,
-  OperandComparable,
-  OperandOrdered
-};
-enum class Constraint { None, NonZeroRHS, NoNegativeLHSWhenRealRHS };
-
-struct Operation {
-  bool IsUnaryOp() const { return isUnaryOp; }
-  std::optional<Type> GetResultTypeForArguments(Type, Type) const;
-  std::optional<Type> GetResultTypeForArgument(Type) const;
-  const char *name;
-  const char *symbol;
-  TypePattern pattern;
-  Constraint constraint{Constraint::None};
-  bool isUnaryOp{false};
-};
-
-// Sorted by increasing precedence (not stricly increasing). See F2018
-// table 10.1.
-static Operation operations[]{
-    // TODO should be OK constexpr but g++ 8.2 not happy
-    // defined-binary-op cannot be described here.
-    {"eqv", ".EQV.", TypePattern::OperandLogical},
-    {"neqv", ".NEQV.", TypePattern::OperandLogical},
-    {"or", ".OR.", TypePattern::OperandLogical},
-    {"and", ".AND.", TypePattern::OperandLogical},
-    {"not", ".NOT.", TypePattern::OperandLogical, Constraint::None, true},
-    {"eq", ".EQ.", TypePattern::OperandComparable},
-    {"ne", ".NE.", TypePattern::OperandComparable},
-    {"lt", ".LT.", TypePattern::OperandOrdered},
-    {"le", ".LE.", TypePattern::OperandOrdered},
-    {"gt", ".GT.", TypePattern::OperandOrdered},
-    {"ge", ".GE.", TypePattern::OperandOrdered},
-    // TODO: Concat
-    {"add", "+", TypePattern::OperandNumeric},
-    {"sub", "-", TypePattern::OperandNumeric},
-    {"minus", "-", TypePattern::OperandNumeric, Constraint::None, true},
-    {"plus", "+", TypePattern::OperandNumeric, Constraint::None, true},
-    {"mult", "*", TypePattern::OperandNumeric},
-    {"div", "/", TypePattern::OperandNumeric, Constraint::NonZeroRHS},
-    {"power", "**", TypePattern::OperandNumeric,
-        Constraint::NoNegativeLHSWhenRealRHS},  // TODO: check power pattern
-    // defined-unary-op cannot be described here.
-};
-
-static bool IsLogical(const Type t) { return t.cat == TypeCategory::Logical; }
-static bool IsCharacter(const Type t) {
-  return t.cat == TypeCategory::Character;
-}
-static bool IsComplex(const Type t) { return t.cat == TypeCategory::Complex; }
-static bool IsReal(const Type t) { return t.cat == TypeCategory::Real; }
-
-static bool IsOrderedNumeric(const Type t) {
-  return t.cat == TypeCategory::Real || t.cat == TypeCategory::Integer;
-}
-
-static bool IsNumeric(const Type t) {
-  return t.cat == TypeCategory::Real || t.cat == TypeCategory::Integer ||
-      t.cat == TypeCategory::Complex;
-}
-
-std::optional<Type> Operation::GetResultTypeForArgument(Type t) const {
-  switch (pattern) {
-  case TypePattern::OperandNumeric:
-    if (IsNumeric(t)) {
-      return t;
-    }
-    break;
-  case TypePattern::OperandLogical:
-    if (IsLogical(t)) {
-      return t;
-    }
-    break;
-  case TypePattern::OperandComparable:
-  case TypePattern::OperandOrdered:
-    assert(false && "No unary comparisons");
-    break;
-  }
-  return std::nullopt;
-}
-
-static std::optional<Type> SelectBiggestKindForResult(
-    TypeCategory resultCat, Type lhs, Type rhs) {
-  if (!lhs.kind && !rhs.kind) {
-    return Type{resultCat};
-  } else if (lhs.kind && rhs.kind) {
-    return Type{resultCat, std::max(*lhs.kind, *rhs.kind)};
-  } else {
-    // Cannot know without more info about compiler what default compares to.
-    return std::nullopt;
-  }
-}
-
-std::optional<Type> Operation::GetResultTypeForArguments(
-    Type lhs, Type rhs) const {
-  // See Fortran 2018 table 10.2 and section 10.1.9.3
-  switch (pattern) {
-  case TypePattern::OperandNumeric:
-    if (!IsNumeric(rhs) || !IsNumeric(lhs)) {
-      return std::nullopt;
-    }
-    if (lhs.cat == rhs.cat) {
-      return SelectBiggestKindForResult(lhs.cat, lhs, rhs);
-    }
-    // different categories
-    if (IsComplex(lhs)) {
-      if (IsReal(rhs)) {
-        return SelectBiggestKindForResult(TypeCategory::Complex, lhs, rhs);
-      }
-      return lhs;
-    }
-    if (IsComplex(rhs)) {
-      if (IsReal(lhs)) {
-        return SelectBiggestKindForResult(TypeCategory::Complex, lhs, rhs);
-      }
-      return rhs;
-    }
-    if (IsReal(lhs)) {
-      // rhs must be integer
-      return lhs;
-    }
-    if (IsReal(rhs)) {
-      // lhs must be integer
-      return rhs;
-    }
-    assert(false && "no more operand cases");
-  case TypePattern::OperandLogical:
-    if (IsLogical(rhs) && IsLogical(lhs)) {
-      return SelectBiggestKindForResult(TypeCategory::Logical, lhs, rhs);
-    }
-    break;
-  case TypePattern::OperandComparable:
-    if (IsNumeric(lhs) && IsNumeric(rhs)) {
-      return DefaultLogical;
-    } else if (IsCharacter(lhs) && IsCharacter(lhs) && lhs.kind == rhs.kind) {
-      return DefaultLogical;
-    }
-    break;
-  case TypePattern::OperandOrdered:
-    if (IsOrderedNumeric(lhs) && IsOrderedNumeric(rhs)) {
-      return DefaultLogical;
-    } else if (IsCharacter(lhs) && IsCharacter(lhs) && lhs.kind == rhs.kind) {
-      return DefaultLogical;
-    }
-    break;
-  }
-  return std::nullopt;
-}
-
-// Test Plan Part
-
-// Only string list input for now
-using Input = std::vector<const char *>;
-// TODO: more inputs method (e.g. random pick)
-
-enum class Eval { Constant, Dynamic };
-struct TestPlan {
-  std::vector<const char *> operationToTests;
-  std::vector<std::pair<Type, Input>> inputs;
-  Eval referenceEvaluationMethod{Eval::Dynamic};
-  Eval testEvaluationMethod{Eval::Dynamic};
-};
-
-static inline std::string IndexedName(const char *name, std::size_t index) {
-  return std::string{name} + std::to_string(index);
-}
-
-static constexpr auto passedName{"passed"};
-static constexpr auto failedName{"failed"};
-
-struct CodeGenerator {
-  static constexpr auto varNameBase{"x"};
-  static constexpr auto paramNameBase{"a"};
-  static constexpr auto loopIndexNameBase{"i"};
-  static constexpr auto testResultName{"test_res"};
-  static constexpr auto refResultName{"ref_res"};
-
-  template<Eval Ev>
-  void GenerateEvaluationFunction(
-      const std::string &functionName, std::ostream &s) const {
-    GenerateEvaluationFunctionStmtAndSpec<Ev>(functionName, s);
-    GenerateExpressionEvaluation<Ev>(functionName, s);
-    s << "END FUNCTION" << std::endl;
-    s << std::endl;
-  }
-
-  void GenerateEvaluationFunction(const std::string &functionNameBase,
-      std::ostream &s, Eval ev, bool isReference) const {
-    auto functionName{isReference ? GetReferenceFunctionName(functionNameBase)
-                                  : GetTestFunctionName(functionNameBase)};
-    switch (ev) {
-    case Eval::Constant:
-      GenerateEvaluationFunction<Eval::Constant>(functionName, s);
-      break;
-    case Eval::Dynamic:
-      GenerateEvaluationFunction<Eval::Dynamic>(functionName, s);
-      break;
-    }
-  }
-
-  void GenerateDriverSubroutine(const std::string &functionNameBase,
-      std::ostream &s, Eval refEval, Eval testEval) const {
-    s << "SUBROUTINE " << GetDriverName(functionNameBase) << "(" << passedName
-      << ", " << failedName << ")" << std::endl;
-    std::size_t numInputs{inputs.size()};
-    assert(numInputs > 0 && "Expected non empty inputs in driver");
-    if (refEval == Eval::Dynamic || testEval == Eval::Dynamic) {
-      // Inputs are required inside the driver only if one evaluation function
-      // is dynamic and inputs need to be passed to it from the driver.
-      for (std::size_t i{0}; i < numInputs; ++i) {
-        GenerateInputAsArrayParameter(i, s);
-      }
-    }
-    s << "INTEGER :: " << passedName << ", " << failedName << std::endl;
-    resultType.Dump(s) << " :: " << testResultName << ", " << refResultName
-                       << std::endl;
-
-    // TODO: Add a test number limit in cases there are many inputs ? This would
-    // need to be kept in sync with folding evaluation.
-    for (std::size_t i{0}; i < numInputs; ++i) {
-      s << "DO " << IndexedName(loopIndexNameBase, i) << " = 1,"
-        << inputs[i]->second.size() << std::endl;
-    }
-
-    // TODO: Handle constraints (e.g divide by zero). Would also need to be kept
-    // in sync with folding evaluation.
-    s << refResultName << " = ";
-    auto refFuncName{GetReferenceFunctionName(functionNameBase)};
-    switch (refEval) {
-    case Eval::Dynamic:
-      GenerateEvaluationFunctionCall<Eval::Dynamic>(refFuncName, s);
-      break;
-    case Eval::Constant:
-      GenerateEvaluationFunctionCall<Eval::Constant>(refFuncName, s);
-      break;
-    }
-    s << testResultName << " = ";
-    auto testFuncName{GetTestFunctionName(functionNameBase)};
-    switch (testEval) {
-    case Eval::Dynamic:
-      GenerateEvaluationFunctionCall<Eval::Dynamic>(testFuncName, s);
-      break;
-    case Eval::Constant:
-      GenerateEvaluationFunctionCall<Eval::Constant>(testFuncName, s);
-      break;
-    }
-
-    s << "IF (";
-    GenerateResultsComparison(s);
-    s << ") THEN" << std::endl;
-    s << passedName << " = " << passedName << " + 1" << std::endl;
-    s << "ELSE" << std::endl;
-    s << failedName << " = " << failedName << " + 1" << std::endl;
-    GenerateFailureMessage(functionNameBase, s);
-    s << "END IF" << std::endl;
-
-    for (std::size_t i{0}; i < numInputs; ++i) {
-      s << "END DO" << std::endl;
-    }
-    s << "END SUBROUTINE" << std::endl;
-    s << std::endl;
-  }
-
-  template<Eval Ev>
-  void GenerateEvaluationFunctionCall(
-      const std::string &functionName, std::ostream &s) const {
-    s << functionName << "(";
-    if constexpr (Ev == Eval::Dynamic) {
-      ApplyOnInputIndexes(
-          [&](std::size_t i) {
-            return GetArrayElement(paramNameBase, loopIndexNameBase, i);
-          },
-          ", ", s);
-    } else {
-      static_assert(Ev == Eval::Constant, "unhandled evaluation method");
-      ApplyOnInputIndexes(
-          [&](std::size_t i) { return IndexedName(loopIndexNameBase, i); },
-          ", ", s);
-    }
-    s << ")" << std::endl;
-  }
-
-  void GenerateFailureMessage(
-      const std::string &functionNameBase, std::ostream &s) const {
-    s << "PRINT *, \"FAILED " << functionNameBase << " test: \"";
-    for (std::size_t i{0}; i < inputs.size(); ++i) {
-      auto loopId{IndexedName(loopIndexNameBase, i)};
-      s << ", \"" << loopId << " = \", " << loopId;
-    }
-    s << std::endl;
-    s << "PRINT *, \"  expected \", " << refResultName << ", \" got: \","
-      << testResultName << std::endl;
-  }
-
-  void GenerateInputAsArrayParameter(std::size_t i, std::ostream &s) const {
-    const auto &literals{inputs[i]->second};
-    const auto size{literals.size()};
-    assert(size > 0 && "No actual literal input for test");
-    inputs[i]->first.Dump(s)
-        << ", PARAMETER :: " << IndexedName(paramNameBase, i) << "(" << size
-        << ") = [";
-    s << literals[0];
-    for (std::size_t i{1}; i < size; ++i) {
-      s << ", " << literals[i];
-    }
-    s << "]" << std::endl;
-  }
-
-  void GenerateDriverCall(
-      const std::string &functionNameBase, std::ostream &s) const {
-    s << "CALL " << GetDriverName(functionNameBase) << "(" << passedName << ", "
-      << failedName << ")" << std::endl;
-  }
-
-  template<Eval Ev>
-  void GenerateEvaluationFunctionStmtAndSpec(
-      const std::string &functionName, std::ostream &s) const {
-    resultType.Dump(s) << " FUNCTION " << functionName << "(";
-    assert(inputs.size() && "expect at least on argument");
-    const auto &name{Ev == Eval::Constant ? loopIndexNameBase : varNameBase};
-    s << IndexedName(name, 0);
-    for (std::size_t i{1}; i < inputs.size(); ++i) {
-      s << ", " << IndexedName(name, i);
-    }
-    s << ")" << std::endl;
-    std::size_t i{0};
-    if constexpr (Ev == Eval::Constant) {
-      for (const auto *input : inputs) {
-        s << "INTEGER :: " << IndexedName(name, i++) << std::endl;
-      }
-    } else {
-      for (const auto *input : inputs) {
-        input->first.Dump(s) << " :: " << IndexedName(name, i++) << std::endl;
-      }
-    }
-  }
-
-  template<Eval Ev>
-  void GenerateExpressionEvaluation(
-      const std::string &resultName, std::ostream &s) const {
-    if constexpr (Ev == Eval::Constant) {
-      GenerateConstantExpressionEvaluation(resultName, s);
-    } else {
-      static_assert(
-          Ev == Eval::Dynamic, "unhandled expression evaluation method");
-      s << resultName << " = ";
-      GenerateExpression(
-          [&](std::size_t i) { return IndexedName(varNameBase, i); }, s);
-      s << std::endl;
-    }
-  }
-
-  void GenerateConstantExpressionEvaluation(
-      const std::string &resultName, std::ostream &s) const {
-    // Declare constant inputs
-    for (std::size_t i{0}; i < inputs.size(); ++i) {
-      GenerateInputAsArrayParameter(i, s);
-    }
-    // Evaluate in a parameter array using ac-implied-do
-    auto cstResultName{IndexedName(paramNameBase, inputs.size())};
-    assert(inputs.size() > 0 && "expected at least one operands");
-    resultType.Dump(s) << " , PARAMETER :: " << cstResultName << "(*";
-    for (std::size_t i{1}; i < inputs.size(); ++i) {
-      s << ", *";
-    }
-    s << ") = RESHAPE ([(";
-    for (std::size_t i{1}; i < inputs.size(); ++i) {
-      s << "(";
-    }
-
-    // Expression evaluation inside ac-implied-do
-    // TODO: how to handle constraints ?
-    GenerateExpression(
-        [&](std::size_t i) {
-          return GetArrayElement(paramNameBase, loopIndexNameBase, i);
-        },
-        s);
-
-    // ac-implied-do (opening ")" were emited before).
-    s << ", ";
-    ApplyOnInputIndexes(
-        [&](std::size_t i) {
-          return IndexedName(loopIndexNameBase, i) + " = 1," +
-              std::to_string(inputs[i]->second.size()) + ")";
-        },
-        ",", s);
-
-    // RESHAPE SHAPE argument
-    s << "], [";
-    ApplyOnInputIndexes(
-        [&](std::size_t i) { return inputs[i]->second.size(); }, ",", s);
-    s << "])" << std::endl;
-
-    // dynamically fetch requested result from the constant array
-    s << resultName << " = " << cstResultName << "(";
-    ApplyOnInputIndexes(
-        [&](std::size_t i) { return IndexedName(loopIndexNameBase, i); }, ",",
-        s);
-    s << ")" << std::endl;
-  }
-
-  template<typename T>
-  void inline ApplyOnInputIndexes(
-      const T &callable, const std::string &sep, std::ostream &s) const {
-    auto size{inputs.size()};
-    if (size != 0) {
-      s << callable(0);
-    }
-    for (std::size_t i{1}; i < size; ++i) {
-      s << ", " << callable(i);
-    }
-  }
-
-  template<typename T>
-  void inline GenerateExpression(
-      const T &operandGenerator, std::ostream &s) const {
-    if (inputs.size() == 1) {
-      s << op.symbol << " " << operandGenerator(0);
-    } else {
-      assert(inputs.size() == 2 && "expected binary opreation");
-      s << operandGenerator(0) << " " << op.symbol << " "
-        << operandGenerator(1);
-    }
-  }
-
-  void GenerateEvaluationFunctionInterface(const std::string &functionNameBase,
-      std::ostream &s, Eval ev, bool isReference) const {
-    auto functionName{isReference ? GetReferenceFunctionName(functionNameBase)
-                                  : GetTestFunctionName(functionNameBase)};
-    switch (ev) {
-    case Eval::Constant:
-      GenerateEvaluationFunctionStmtAndSpec<Eval::Constant>(functionName, s);
-      break;
-    case Eval::Dynamic:
-      GenerateEvaluationFunctionStmtAndSpec<Eval::Dynamic>(functionName, s);
-      break;
-    }
-    s << "END FUNCTION" << std::endl;
-  }
-
-  void GenerateResultsComparison(std::ostream &s) const {
-    auto compareReal{[&](const std::string &x, const std::string &y) {
-      // TODO: This should not always be an absolute comparison (epsilon margin
-      // for fp.).
-      s << x << ".EQ." << y << " .OR. ";
-      s << "(IEEE_IS_NAN(" << x << ") .AND. IEEE_IS_NAN(" << y << "))";
-    }};
-    if (resultType.cat == TypeCategory::Real) {
-      compareReal(refResultName, testResultName);
-    } else if (resultType.cat == TypeCategory::Complex) {
-      s << "(";
-      compareReal(std::string{refResultName} + "%RE",
-          std::string{testResultName} + "%RE");
-      s << ") .AND. (";
-      compareReal(std::string{refResultName} + "%IM",
-          std::string{testResultName} + "%IM");
-      s << ")";
-    } else {
-      const auto *compareOp{
-          resultType.cat == TypeCategory::Logical ? ".EQV." : ".EQ."};
-      s << refResultName << compareOp << testResultName;
-    }
-  }
-
-  // a0(i0) and such
-  static std::string GetArrayElement(
-      const char *arrayNameBase, const char *indexNameBase, std::size_t i) {
-    return IndexedName(arrayNameBase, i) + "(" + IndexedName(indexNameBase, i) +
-        ")";
-  }
-
-  static std::string GetTestFunctionName(const std::string &functionNameBase) {
-    return functionNameBase + "_test";
-  }
-  static std::string GetReferenceFunctionName(
-      const std::string &functionNameBase) {
-    return functionNameBase + "_ref";
-  }
-  static std::string GetDriverName(const std::string &functionNameBase) {
-    return functionNameBase + "_driver";
-  }
-  Type resultType;
-  const Operation &op;
-  std::vector<const std::pair<Type, Input> *> inputs;
-};
-
-// Test Generator
-struct TestGenerator {
-
-  void GenerateTests(std::ostream &testFile, std::ostream &refFile) {
-    std::stringstream testContentStream;
-    std::stringstream testInterfaceStream;
-    std::stringstream referenceAndDriverContentStream;
-    std::stringstream programContentStream;
-    auto generateInBuffers{
-        [&](const CodeGenerator &codeGen, const std::string &functionNameBase) {
-          codeGen.GenerateEvaluationFunction(functionNameBase,
-              testContentStream, plan.testEvaluationMethod, false);
-          codeGen.GenerateEvaluationFunctionInterface(functionNameBase,
-              testInterfaceStream, plan.testEvaluationMethod, false);
-          codeGen.GenerateEvaluationFunction(functionNameBase,
-              referenceAndDriverContentStream, plan.referenceEvaluationMethod,
-              true);
-          codeGen.GenerateDriverSubroutine(functionNameBase,
-              referenceAndDriverContentStream, plan.referenceEvaluationMethod,
-              plan.testEvaluationMethod);
-          codeGen.GenerateDriverCall(functionNameBase, programContentStream);
-        }};
-
-    for (const auto *opName : plan.operationToTests) {
-      const auto *op{GetOperation(opName)};
-      assert(op && "Broken test plan: undefined operation");
-      for (const auto &input1 : plan.inputs) {
-        if (op->IsUnaryOp()) {
-          if (auto resultType{op->GetResultTypeForArgument(input1.first)}) {
-            CodeGenerator codeGen{*resultType, *op, {&input1}};
-            auto functionNameBase{GetDistinctFunctionNameBase(*op)};
-            generateInBuffers(codeGen, functionNameBase);
-          }
-        } else {
-          for (const auto &input2 : plan.inputs) {
-            if (auto resultType{op->GetResultTypeForArguments(
-                    input1.first, input2.first)}) {
-              CodeGenerator codeGen{*resultType, *op, {&input1, &input2}};
-              auto functionNameBase{GetDistinctFunctionNameBase(*op)};
-              generateInBuffers(codeGen, functionNameBase);
-            }
-          }
-        }
-      }
-    }
-
-    // Organize generated code
-    testFile << "! Generated test file" << std::endl;
-    testFile << testContentStream.rdbuf();
-    testFile << "! End of generated test file" << std::endl;
-
-    refFile << "! Generated reference and driver " << std::endl;
-    refFile << "MODULE REFERENCE_AND_DRIVER" << std::endl;
-    refFile << "USE IEEE_ARITHMETIC" << std::endl;  // for IEEE_IS_NAN
-    refFile << "INTERFACE" << std::endl;
-    refFile << testInterfaceStream.rdbuf();
-    refFile << "END INTERFACE" << std::endl;
-    refFile << std::endl;
-    refFile << "CONTAINS" << std::endl;
-    refFile << referenceAndDriverContentStream.rdbuf();
-    refFile << "END MODULE" << std::endl;
-    refFile << std::endl;
-    refFile << "PROGRAM EXPR_TEST" << std::endl;
-    refFile << "USE REFERENCE_AND_DRIVER" << std::endl;
-    refFile << "INTEGER :: " << passedName << ", " << failedName << std::endl;
-    refFile << passedName << " = 0 " << std::endl;
-    refFile << failedName << " = 0 " << std::endl;
-    refFile << programContentStream.rdbuf();
-    refFile << "PRINT *, \"Passed: \"," << passedName << ", \" Failed: \", "
-            << failedName << std::endl;
-    refFile << "IF (" << failedName << ".GT. 0) ERROR STOP 1" << std::endl;
-    refFile << "END PROGRAM" << std::endl;
-    refFile << "! End of generated reference and driver" << std::endl;
-  }
-
-  const Operation *GetOperation(const char *name) {
-    assert(name && "nullptr string for test name");
-    for (const auto &op : operations) {
-      assert(op.name && "Broken operation");
-      if (std::strcmp(name, op.name) == 0) {
-        return &op;
-      }
-    }
-    return nullptr;
-  }
-
-  std::string GetDistinctFunctionNameBase(const Operation &op) {
-    return IndexedName(op.name, funcId++);
-  }
-
-  TestPlan plan;
-  std::size_t funcId{0};
-};
-
-// Test driver
-int main(int argc, char **argv) {
-  Eval testEvalMethod{Eval::Dynamic};
-  Eval refEvalMethod{Eval::Dynamic};
-  int planId{0};
-  for (int i{0}; i < argc; ++i) {
-    if (std::strcmp(argv[i], "test=folding") == 0) {
-      testEvalMethod = Eval::Constant;
-    } else if (std::strcmp(argv[i], "ref=folding") == 0) {
-      refEvalMethod = Eval::Constant;
-    }
-  }
-
-  TestGenerator{
-      {
-          {"eqv", "neqv", "or", "and", "not", "eq", "ne", "lt", "le", "gt",
-              "ge", "add", "sub", "minus", "plus", "mult", "div", "power"},
-          {
-              {Integer1, {"-1_1", "12_1", "2_1"}},
-              {Integer2, {"-1_2", "12500_2", "2_2"}},
-              {Integer4, {"31000_4", "-64354_4"}},
-              {Integer8, {"3000001_8", "-2654637545_8"}},
-              {Real4, {"1.03687448_4", "3.1254641_4"}},
-              {Real8, {"1.036874168446448_8", "3.12254533554641_8"}},
-              {Complex4, {"(-0.5_4,10.35544_4)", "(-5._4, 0.15647_4)"}},
-              {Complex8,
-                  {"(-0.5_8,10.35546579874_8)",
-                      "(-5.64654654_8, 0.155876974647_8)"}},
-              {DefaultLogical, {".false.", ".true."}},
-          },
-          refEvalMethod,
-          testEvalMethod,
-      }}
-      .GenerateTests(std::cout, std::cerr);
-}
diff --git a/test/lower/test-character-assignment.cc b/test/lower/test-character-assignment.cc
deleted file mode 100644
index ef7da61f3f30..000000000000
--- a/test/lower/test-character-assignment.cc
+++ /dev/null
@@ -1,357 +0,0 @@
-//===-- test/lower/test-character-assignment.cc -----------------*- 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 <cassert>
-#include <codecvt>
-#include <iomanip>
-#include <iostream>
-#include <locale>
-#include <string>
-#include <type_traits>
-
-// Driver to tests Fortran subroutine from character-assignment.f90
-
-// So far lowering of fir::boxchar dummy to llvm does not layout character
-// arguments like other compiler do for F77. Templates provides a patch for
-// that.
-
-using LenT = std::int64_t;
-struct Fchar {
-  char *data;
-  LenT len;
-};
-
-template<typename... T> using SubF18 = void (*)(Fchar, Fchar, T...);
-template<typename... T>
-using SubF77 = void (*)(char *, char *, T..., LenT, LenT);
-template<typename... T>
-void CallSubroutine(SubF18<T...> f, Fchar s1, Fchar s2, T... args) {
-  f(s1, s2, args...);
-}
-
-template<typename... T>
-void CallSubroutine(SubF77<T...> f, Fchar s1, Fchar s2, T... args) {
-  f(s1.data, s2.data, args..., s1.len, s2.len);
-}
-
-// Define structures to create and manipulate Fortran Character
-// A canary is always added at the end of character storage so that
-// invalid overwrites can be detected.
-template<int K> struct CharStorage {};
-template<> struct CharStorage<1> {
-  using Type = std::string;
-  static const Type canary;
-};
-const CharStorage<1>::Type CharStorage<1>::canary{"_CaNaRy"};
-
-template<> struct CharStorage<2> {
-  using Type = std::u16string;
-  static const Type canary;
-};
-const CharStorage<2>::Type CharStorage<2>::canary{u"_CaNaRy"};
-
-template<> struct CharStorage<4> {
-  using Type = std::u32string;
-  static const Type canary;
-};
-const CharStorage<4>::Type CharStorage<4>::canary{U"_CaNaRy"};
-
-template<int Kind> struct FcharData {
-  using String = typename CharStorage<Kind>::Type;
-  using CharT = typename String::value_type;
-  FcharData(String str)
-    : data{str + CharStorage<Kind>::canary}, len{static_cast<LenT>(
-                                                 str.length())} {}
-  Fchar getFchar() {
-    const char *addr{reinterpret_cast<const char *>(data.data())};
-    return Fchar{const_cast<char *>(addr), len};
-  }
-
-  // UTF-8 dump
-  std::ostream &dump(std::ostream &os) const {
-    if constexpr (std::is_same_v<CharT, char>) {
-      os << data;
-    } else {
-      std::wstring_convert<std::codecvt_utf8<CharT>, CharT> cvt;
-      os << cvt.to_bytes(data);
-    }
-    return os;
-  }
-  // Hex dump
-  std::ostream &dumpHex(std::ostream &os) const {
-    os << std::hex;
-    for (auto c : data) {
-      if constexpr (std::is_same_v<CharT, char>) {
-        os << " 0x" << std::setw(2) << std::setfill('0')
-           << (int)((unsigned char)c);
-      } else {
-        os << " 0x" << std::setw(sizeof(CharT) * 2) << std::setfill('0') << c;
-      }
-    }
-    os << std::dec;
-    return os;
-  }
-
-  String data;
-  LenT len;  // may differ from string length for test purposes
-};
-
-template<int Kind>
-bool Check(const FcharData<Kind> &test, const FcharData<Kind> &ref,
-    const std::string &desc) {
-  if (test.data != ref.data) {
-    std::cout << "Failed: " << desc << std::endl;
-    ref.dump(std::cout << "  expected: '") << "'" << std::endl;
-    test.dump(std::cout << "  got     : '") << "'" << std::endl;
-    return false;
-  }
-  return true;
-}
-
-// Call compiled test subroutine and compare variable afterwards with a
-// reference. Compare against result from reference subroutine.
-template<int Kind, typename... T>
-bool TestSubroutine(const std::string &testName, SubF18<T...> fooTest,
-    SubF18<T...> fooRef, const FcharData<Kind> &s1, const FcharData<Kind> &s2,
-    T... otherArgs) {
-  // Make copies because data may be modified
-  FcharData<Kind> testS1{s1}, testS2{s2};
-  CallSubroutine(fooTest, testS1.getFchar(), testS2.getFchar(), otherArgs...);
-
-  // Compare against reference subroutine
-  FcharData<Kind> refS1{s1}, refS2{s2};
-  CallSubroutine(fooRef, refS1.getFchar(), refS2.getFchar(), otherArgs...);
-
-  auto description{testName + " KIND=" + std::to_string(Kind)};
-  bool result{Check(testS1, refS1, description + " s1")};
-  result &= Check(testS2, refS2, description + " s2");
-  return result;
-}
-
-// Compare against precomputed results.
-template<int Kind, typename... T>
-bool TestSubroutine(const std::string &testName, SubF18<T...> fooTest,
-    const FcharData<Kind> &s1, const FcharData<Kind> &refS1,
-    const FcharData<Kind> &s2, const FcharData<Kind> &refS2, T... otherArgs) {
-  // Make copies because data may be modified
-  FcharData<Kind> testS1{s1}, testS2{s2};
-  CallSubroutine(fooTest, testS1.getFchar(), testS2.getFchar(), otherArgs...);
-  auto description{testName + " KIND=" + std::to_string(Kind)};
-  bool result{Check(testS1, refS1, description + " s1")};
-  result &= Check(testS2, refS2, description + " s2");
-  return result;
-}
-
-// Test driver code (could maybe generated somehow)
-
-// String data to be used as inputs during the tests.
-template<int Kind> struct Inputs { static FcharData<Kind> s1, s2, s3; };
-
-template<> FcharData<1> Inputs<1>::s1{"aw*lSe4frliaw"};
-template<> FcharData<1> Inputs<1>::s2{"8\n e7t4$%&52Z"};
-template<> FcharData<1> Inputs<1>::s3{"quAli64^&$*#$8gl6"};
-
-template<> FcharData<2> Inputs<2>::s1{u"\u4e4dhy7&3o8%\u4e24"};
-template<> FcharData<2> Inputs<2>::s2{u"\u4f60\u4e0d\u662f F18 !\uff1f"};
-template<>
-FcharData<2> Inputs<2>::s3{
-    u"\u4f60\u597d\uff0c\u6211\u66df F18 ! \u4f60\u5462\uff1f"};
-
-template<> FcharData<4> Inputs<4>::s1{U"\u4e4dhy7&3o8%\u4e24"};
-template<> FcharData<4> Inputs<4>::s2{U"\u4f60\u4e0d\u662f F18 !\uff1f"};
-template<>
-FcharData<4> Inputs<4>::s3{
-    U"\u4f60\u597d\uff0c\u6211\u66df F18 ! \u4f60\u5462\uff1f"};
-
-// Test simple assignment
-extern "C" {
-// Declare Fortran subroutine to be tested
-//
-// SUBROUTINE assignK(s1, s2)
-//   CHARACTER(*, K) :: s1, s2
-//   s1 = s2
-// END SUBROUTINE
-void assign1(Fchar, Fchar);
-void assign2(Fchar, Fchar);
-void assign4(Fchar, Fchar);
-}
-
-template<int Kind, typename Func>
-void TestNormalAssignement(Func testedSub, int &tests, int &passed) {
-  auto &s1{Inputs<Kind>::s1};
-  auto &s2{Inputs<Kind>::s2};
-  auto &s3{Inputs<Kind>::s3};
-
-  assert(s1.len == s2.len && s1.len < s3.len &&
-      "Test requires len(s1) = len(s2) < len(s3)");
-  const std::string &desc{"normal character assignment"};
-
-  // s1 = s2 ! len(s1) == len(s3)
-  tests++;
-  if (TestSubroutine(desc, testedSub, s1, /* expect*/ s2, s2, /*expect*/ s2)) {
-    passed++;
-  }
-
-  // s1 = s3 ! len(s1) < len(s3)
-  FcharData<Kind> s3Tos1{s3.data.substr(0, s1.len)};
-  tests++;
-  if (TestSubroutine(desc, testedSub, s1, /* expect*/ s3Tos1, s3, s3)) {
-    passed++;
-  }
-
-  // s3 = s1 ! len(s1) < len(s3)
-  using ST = typename CharStorage<Kind>::Type;
-  FcharData<Kind> s1Tos3{
-      s1.data.substr(0, s1.len) + ST(s3.len - s1.len, /* space */ 0x20)};
-  tests++;
-  if (TestSubroutine(desc, testedSub, s3, /* expect*/ s1Tos3, s1, s1)) {
-    passed++;
-  }
-}
-
-// Test substring assignment
-extern "C" {
-// SUBROUTINE assign_substringK(s1, s2, lb, ub)
-//   CHARACTER(*, K) :: s1, s2
-//   INTEGER :: lb, ub
-//   s1(lb:ub) = s2
-// END SUBROUTINE
-void assign_substring1(Fchar s1, Fchar s2, int *lb, int *ub);
-void assign_substring2(Fchar, Fchar, int *, int *);
-void assign_substring4(Fchar, Fchar, int *, int *);
-}
-
-template<int Kind, typename Func>
-void TestSubstringAssignement(Func testedSub, int &tests, int &passed) {
-  auto &s1{Inputs<Kind>::s3};
-  auto &s2{Inputs<Kind>::s1};
-  int lb{3};
-  int ub{14};
-  assert(1 <= lb && lb < ub && ub <= s1.len && "Failed test requirements");
-  const std::string &desc{"substring character assignment"};
-
-  // s1(lb:ub) = s2
-  auto delta{ub - lb + 1};
-  auto s2CpyLen{s2.len < delta ? s2.len : delta};
-  auto str{s1.data.substr(0, lb - 1) + s2.data.substr(0, s2CpyLen)};
-  if (auto padding{delta - s2.len}; padding >= 0) {
-    using ST = typename CharStorage<Kind>::Type;
-    str += ST(padding, /* space */ 0x20);
-  }
-  FcharData<Kind> expected{str + s1.data.substr(ub, s1.len - ub)};
-  tests++;
-  if (TestSubroutine(desc, testedSub, s1, expected, s2, s2, &lb, &ub)) {
-    passed++;
-  }
-}
-
-// Test when RHS depends on LHS in a way that require a temp to evaluate RHS
-extern "C" {
-// SUBROUTINE assign_overlapK(s1, s2, lb)
-//   CHARACTER(*, K) :: s1, s2
-//   INTEGER :: lb
-//   s1(lb:) = s2
-// END SUBROUTINE
-void assign_overlap1(Fchar s1, Fchar s2, int *lb);
-void assign_overlap2(Fchar, Fchar, int *);
-void assign_overlap4(Fchar, Fchar, int *);
-}
-
-template<int Kind, typename Func>
-void TestOverlappingAssignement(Func testedSub, int &tests, int &passed) {
-  auto &s1{Inputs<Kind>::s1};
-  auto &s2{Inputs<Kind>::s2};
-  int lb{2};
-  assert(lb >= 2 && "Test requires lb>=2");
-  assert(s1.len >= lb && "Test requires len(s1)>=lb");
-  const std::string &desc{"overlapping character assignment"};
-
-  // s1(lb:) = s1 ! len(s1) >= lb
-  auto delta{lb - 1};
-  FcharData<Kind> expected{
-      s1.data.substr(0, delta) + s1.data.substr(0, s1.len - delta)};
-  tests++;
-  if (TestSubroutine(desc, testedSub, s1, expected, s2, s2, &lb)) {
-    passed++;
-  }
-}
-
-// Test assignment of character whose length is specified in specification
-// expression.
-extern "C" {
-// SUBROUTINE assign_spec_expr_lenK(s1, s2, l1, l2)
-//   INTEGER :: l1, l2
-//   CHARACTER(l1, K) :: s1
-//   CHARACTER(l2, K) :: s2
-//   s1 = s2
-// END SUBROUTINE
-void assign_spec_expr_len1(Fchar s1, Fchar s2, int *l1, int *l2);
-void assign_spec_expr_len2(Fchar s1, Fchar s2, int *l1, int *l2);
-void assign_spec_expr_len4(Fchar s1, Fchar s2, int *l1, int *l2);
-}
-
-template<int Kind, typename Func>
-void TestSpecExprLenAssignement(Func testedSub, int &tests, int &passed) {
-  auto &s1{Inputs<Kind>::s1};
-  auto &s2{Inputs<Kind>::s2};
-  auto &s3{Inputs<Kind>::s3};
-
-  int l1{static_cast<int>(s1.len / 2)};
-  int l2{static_cast<int>(s2.len / 2)};
-  int l3{static_cast<int>(s3.len / 2)};
-  assert(l1 == l2 && l1 < l3 && "Test requires l1 = l2 < l3");
-  const std::string &desc{"assignment of character with specified expr length"};
-
-  // s1 = s2 ! l1 == l3
-  tests++;
-  FcharData<Kind> expect1{
-      s2.data.substr(0, l1) + s1.data.substr(l1, s1.len - l1)};
-  if (TestSubroutine(desc, testedSub, s1, expect1, s2, s2, &l1, &l2)) {
-    passed++;
-  }
-
-  // s1 = s3 ! l1 < l3
-  FcharData<Kind> expect2{
-      s3.data.substr(0, l1) + s1.data.substr(l1, s1.len - l1)};
-  tests++;
-  if (TestSubroutine(desc, testedSub, s1, expect2, s3, s3, &l1, &l3)) {
-    passed++;
-  }
-
-  // s3 = s1 ! l1 < l3
-  using ST = typename CharStorage<Kind>::Type;
-  FcharData<Kind> expect3{s1.data.substr(0, l1) +
-      ST(l3 - l1, /* space */ 0x20) + s3.data.substr(l3, s3.len - l3)};
-  tests++;
-  if (TestSubroutine(desc, testedSub, s3, expect3, s1, s1, &l3, &l1)) {
-    passed++;
-  }
-}
-
-int main(int, char **) {
-  int tests{0}, passed{0};
-
-  TestNormalAssignement<1>(assign1, tests, passed);
-  TestNormalAssignement<2>(assign2, tests, passed);
-  TestNormalAssignement<4>(assign4, tests, passed);
-
-  TestSubstringAssignement<1>(assign_substring1, tests, passed);
-  TestSubstringAssignement<2>(assign_substring2, tests, passed);
-  TestSubstringAssignement<4>(assign_substring4, tests, passed);
-
-  TestOverlappingAssignement<1>(assign_overlap1, tests, passed);
-  TestOverlappingAssignement<2>(assign_overlap2, tests, passed);
-  TestOverlappingAssignement<4>(assign_overlap4, tests, passed);
-
-  TestSpecExprLenAssignement<1>(assign_spec_expr_len1, tests, passed);
-  TestSpecExprLenAssignement<2>(assign_spec_expr_len2, tests, passed);
-  TestSpecExprLenAssignement<4>(assign_spec_expr_len4, tests, passed);
-
-  std::cout << passed << " tests passed out of " << tests << std::endl;
-  return tests == passed ? 0 : -1;
-}
diff --git a/test/lower/test_character_assignment.sh b/test/lower/test_character_assignment.sh
deleted file mode 100755
index c16177a3c5ee..000000000000
--- a/test/lower/test_character_assignment.sh
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-# Test Fortran character assignment/expression lowering by driving compilation
-# and executions of Fortran and C++ source codes.
-#
-# Usage: cmd bbc llc
-# To keep generated files, run `export KEEP=TRUE` before the test call.
-
-BBC=$1
-LLC=$2
-CPP=g++
-CPP_SRC=$PWD/test-character-assignment.cc
-F_SRC=$PWD/character-assignment.f90
-
-function die {
-  echo "$(basename $0): $*" >&2
-  exit 1
-}
-
-temp=`mktemp -d ./tmp.XXXXXX`
-cd $temp
-[[ $KEEP ]] || trap "cd .. && rm -rf $temp" EXIT
-
-bbcLog=bbc.log
-assembly=a.s
-testObject=test.o
-testExec=./test_exec
-testLog=test.log
-llFile=a.mlir.ll
-$BBC -emit-llvm -disable-fir2std $F_SRC 2>$bbcLog
-[[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
-sed -i 's/_QP//g' -i $llFile
-$LLC $llFile -o $assembly
-[[ $? -ne 0 ]] && die "llc failed compiling bbc output"
-as $assembly -o $testObject
-[[ $? -ne 0 ]] && die "as failed compiling llc output"
-$CPP -std=c++17 $testObject $CPP_SRC -o $testExec
-[[ $? -ne 0 ]] && die "driver.f90 compilation/linking failure"
-$testExec > $testLog
-result=$?
-cat $testLog
-if [ $result -ne 0 ]; then
-  echo "FAIL"
-else
-  echo "PASS"
-fi
diff --git a/test/lower/test_expression_lowering.sh b/test/lower/test_expression_lowering.sh
deleted file mode 100755
index d39e5faccf00..000000000000
--- a/test/lower/test_expression_lowering.sh
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-# Test Fortran expression lowering by driving compilations
-# and executions of programs generated by expr-test-generation.cc
-#
-# Usage: cmd bbc llc
-# To keep generated files, run `export KEEP=TRUE` before the test call.
-
-BBC=$1
-LLC=$2
-CPP=g++
-FCC=pgfortran # So far, only works with pgfortran because of pgmath linking.
-FCC_OPTIONS="-Kieee" # That is required because bit to bit compare so far.
-SRC=$PWD/expr-test-generator.cc
-
-function die {
-  echo "$(basename $0): $*" >&2
-  exit 1
-}
-
-temp=`mktemp -d ./tmp.XXXXXX`
-cd $temp
-[[ $KEEP ]] || trap "cd .. && rm -rf $temp" EXIT
-
-testGen=./genTests
-testFile=test.f90
-driverFile=driver.f90
-bbcLog=bbc.log
-assembly=a.s
-testObject=test.o
-testExec=./test_exec
-testLog=test.log
-llFile=a.mlir.ll
-
-$CPP $SRC -std=c++17 -o $testGen
-[[ $? -ne 0 ]] && die "test generator compilation failure"
-$testGen 1>$testFile 2>$driverFile
-[[ $? -ne 0 ]] && die "test generation failure"
-$BBC -disable-fir2std -emit-llvm $testFile 2>$bbcLog
-[[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
-# FIR internal mangling -> pgfortran mangling (until done by FIR lowering)
-sed -i 's,_QP\([[:alnum:]_]*\),\1_,g' $llFile
-$LLC $llFile -o $assembly
-[[ $? -ne 0 ]] && die "llc failed compiling bbc output"
-as $assembly -o $testObject
-[[ $? -ne 0 ]] && die "as failed compiling llc output"
-$FCC $testObject $driverFile -o $testExec $FCC_OPTIONS
-[[ $? -ne 0 ]] && die "driver.f90 compilation/linking failure"
-$testExec > $testLog
-result=$?
-cat $testLog
-if [ $result -ne 0 ]; then
-  echo "FAIL"
-else
-  echo "PASS"
-fi

From 206006189d8812a0642238dfcd99553d22b7d58c Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 18 Mar 2020 15:14:33 -0700
Subject: [PATCH 250/345] fallout from rebase. move files from directories with
 the same name modulo case to a new place that does not conflict.

---
 not-test/fir/addrof.1.fir                   |   7 +
 not-test/fir/aggregate.fir                  |  11 +
 not-test/fir/alloc.fir                      |  21 +
 not-test/fir/arrayset.fir                   |  16 +
 not-test/fir/bugs/bug0001.fir               |  41 ++
 not-test/fir/bugs/bug0002.fir               |  12 +
 not-test/fir/character.fir                  |  12 +
 not-test/fir/commute.fir                    |  21 +
 not-test/fir/compare.fir                    |  29 +
 not-test/fir/complex.fir                    |  22 +
 not-test/fir/complex.mlir                   |   6 +
 not-test/fir/constant.fir                   |  19 +
 not-test/fir/dynlayout.fir                  |  38 ++
 not-test/fir/embox.fir                      |   6 +
 not-test/fir/fir-dt.fir                     |   5 +
 not-test/lower/character-assignment.f90     |  69 ++
 not-test/lower/expr-test-generator.cc       | 692 ++++++++++++++++++++
 not-test/lower/test-character-assignment.cc | 357 ++++++++++
 not-test/lower/test_character_assignment.sh |  45 ++
 not-test/lower/test_expression_lowering.sh  |  55 ++
 20 files changed, 1484 insertions(+)
 create mode 100644 not-test/fir/addrof.1.fir
 create mode 100644 not-test/fir/aggregate.fir
 create mode 100644 not-test/fir/alloc.fir
 create mode 100644 not-test/fir/arrayset.fir
 create mode 100644 not-test/fir/bugs/bug0001.fir
 create mode 100644 not-test/fir/bugs/bug0002.fir
 create mode 100644 not-test/fir/character.fir
 create mode 100644 not-test/fir/commute.fir
 create mode 100644 not-test/fir/compare.fir
 create mode 100644 not-test/fir/complex.fir
 create mode 100644 not-test/fir/complex.mlir
 create mode 100644 not-test/fir/constant.fir
 create mode 100644 not-test/fir/dynlayout.fir
 create mode 100644 not-test/fir/embox.fir
 create mode 100644 not-test/fir/fir-dt.fir
 create mode 100644 not-test/lower/character-assignment.f90
 create mode 100644 not-test/lower/expr-test-generator.cc
 create mode 100644 not-test/lower/test-character-assignment.cc
 create mode 100755 not-test/lower/test_character_assignment.sh
 create mode 100755 not-test/lower/test_expression_lowering.sh

diff --git a/not-test/fir/addrof.1.fir b/not-test/fir/addrof.1.fir
new file mode 100644
index 000000000000..75cc12a55eb1
--- /dev/null
+++ b/not-test/fir/addrof.1.fir
@@ -0,0 +1,7 @@
+fir.global @var_x : !fir.int<4> {}
+
+func @getAddressOfX() -> !fir.ref<!fir.int<4>> {
+  %1 = fir.address_of(@var_x) : !fir.ref<!fir.int<4>>
+  return %1 : !fir.ref<!fir.int<4>>
+}
+
diff --git a/not-test/fir/aggregate.fir b/not-test/fir/aggregate.fir
new file mode 100644
index 000000000000..c65e38deadd5
--- /dev/null
+++ b/not-test/fir/aggregate.fir
@@ -0,0 +1,11 @@
+func @f_tuple(%a : tuple<i32, i64>) -> i64 {
+  %0 = constant 1 : i32
+  %1 = fir.extract_value %a, %0 : (tuple<i32, i64>, i32) -> i64
+  return %1 : i64
+}
+
+func @f_record(%a : !fir.type<rec1{fa:i32, fb:i64}>) -> i64 {
+  %0 = fir.field_index fb, !fir.type<rec1>
+  %1 = fir.extract_value %a, %0 : (!fir.type<rec1>, !fir.field) -> i64
+  return %1 : i64
+}
diff --git a/not-test/fir/alloc.fir b/not-test/fir/alloc.fir
new file mode 100644
index 000000000000..e7c0d663c128
--- /dev/null
+++ b/not-test/fir/alloc.fir
@@ -0,0 +1,21 @@
+func @f1() -> !fir.ref<i32> {
+  %1 = fir.alloca i32
+  return %1 : !fir.ref<i32>
+}
+
+func @f2() -> !fir.ref<i32> {
+  %0 = constant 100 : index
+  %1 = fir.alloca i32, %0
+  return %1 : !fir.ref<i32>
+}
+
+func @f3() -> !fir.heap<i32> {
+  %1 = fir.allocmem i32
+  return %1 : !fir.heap<i32>
+}
+
+func @f4() -> !fir.heap<i32> {
+  %0 = constant 100 : index
+  %1 = fir.allocmem i32, %0
+  return %1 : !fir.heap<i32>
+}
diff --git a/not-test/fir/arrayset.fir b/not-test/fir/arrayset.fir
new file mode 100644
index 000000000000..2f45aabb0da7
--- /dev/null
+++ b/not-test/fir/arrayset.fir
@@ -0,0 +1,16 @@
+func @x(%arr : !fir.ref<!fir.array<10xf32>>) {
+  %1 = constant 0 : index
+  %2 = constant 9 : index
+  %a = fir.alloca !fir.array<10xf32>
+  fir.loop %iv = %1 to %2 unordered {
+    %3 = fir.coordinate_of %arr, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
+    %4 = fir.load %3 : !fir.ref<f32>
+    %5 = fir.coordinate_of %a, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
+    fir.store %4 to %5 : !fir.ref<f32>
+  } { arrayset }
+  %6 = fir.embox %a : (!fir.ref<!fir.array<10xf32>>) -> !fir.box<!fir.array<10xf32>>
+  fir.call @y(%6) : (!fir.box<!fir.array<10xf32>>) -> ()
+  return
+}
+
+func @y(!fir.box<!fir.array<10xf32>>) -> ()
diff --git a/not-test/fir/bugs/bug0001.fir b/not-test/fir/bugs/bug0001.fir
new file mode 100644
index 000000000000..5535adb6d0e3
--- /dev/null
+++ b/not-test/fir/bugs/bug0001.fir
@@ -0,0 +1,41 @@
+func @r_incr(%arg0: !fir.ref<f64>) -> f64 {
+    %0 = fir.alloca f64 {name = "r_incr"} : !fir.ref<f64>
+    %1 = fir.load %arg0 : !fir.ref<f64>
+    fir.store %1 to %0 : !fir.ref<f64>
+    %2 = fir.load %arg0 : !fir.ref<f64>
+    %cst = constant 1.000000e+00 : f64
+    %3 = fir.addf %2, %cst : f64
+    fir.store %3 to %arg0 : !fir.ref<f64>
+    %4 = fir.load %0 : !fir.ref<f64>
+    return %4 : f64
+}
+
+func @_MAIN() {
+    %0 = fir.alloca f64 {name = "y"} : !fir.ref<f64>
+    %1 = fir.alloca f64 {name = "y2"} : !fir.ref<f64>
+    %2 = fir.alloca f64 {name = "y1"} : !fir.ref<f64>
+    %3 = fir.alloca f64 {name = "x"} : !fir.ref<f64>
+    %cst = constant 1.000000e+00 : f64
+    fir.store %cst to %3 : !fir.ref<f64>
+    %4 = fir.load %3 : !fir.ref<f64>
+    fir.store %4 to %2 : !fir.ref<f64>
+    %5 = fir.load %2 : !fir.ref<f64>
+    %6 = call @r_incr(%3) : (!fir.ref<f64>) -> f64
+    %7 = fir.addf %5, %6 : f64
+    fir.store %7 to %1 : !fir.ref<f64>
+    %8 = fir.load %1 : !fir.ref<f64>
+    %9 = fir.load %3 : !fir.ref<f64>
+    %10 = fir.addf %8, %9 : f64
+    fir.store %10 to %0 : !fir.ref<f64>
+    %c1_i32 = constant 1 : i32
+    %11 = call @__F18IOa_BeginExternalListOutput(%c1_i32) : (i32) -> !fir.ref<i32>
+    %12 = fir.load %0 : !fir.ref<f64>
+    call @__F18IOa_OutputReal64(%11, %12) : (!fir.ref<i32>, f64) -> ()
+    call @__F18IOa_EndIOStatement(%11) : (!fir.ref<i32>) -> ()
+    return
+}
+
+func @__F18IOa_BeginExternalListOutput(i32) -> !fir.ref<i32>
+func @__F18IOa_OutputInteger64(!fir.ref<i32>, i64)
+func @__F18IOa_OutputReal64(!fir.ref<i32>, f64)
+func @__F18IOa_EndIOStatement(!fir.ref<i32>)
diff --git a/not-test/fir/bugs/bug0002.fir b/not-test/fir/bugs/bug0002.fir
new file mode 100644
index 000000000000..f163e76035e9
--- /dev/null
+++ b/not-test/fir/bugs/bug0002.fir
@@ -0,0 +1,12 @@
+func @foo() -> f32 {
+    %0 = fir.alloca f32 {name = "foo"} : !fir.ref<f32>
+    %1 = fir.alloca f32 {name = "x"} : !fir.ref<f32>
+    %cst = constant 4.200000e+01 : f32
+    fir.store %cst to %1 : !fir.ref<f32>
+    %cst_0 = constant 6.600000e+01 : f32
+    fir.store %cst_0 to %1 : !fir.ref<f32>
+    %2 = fir.load %1 : !fir.ref<f32>
+    fir.store %2 to %0 : !fir.ref<f32>
+    %3 = fir.load %0 : !fir.ref<f32>
+    return %3 : f32
+}
diff --git a/not-test/fir/character.fir b/not-test/fir/character.fir
new file mode 100644
index 000000000000..c4a11a607d7a
--- /dev/null
+++ b/not-test/fir/character.fir
@@ -0,0 +1,12 @@
+
+fir.global @name constant : !fir.char<1> {
+  constant "Your name"
+  //constant 1
+}
+
+func @get_name() -> !fir.boxchar<1> {
+  %j1 = fir.address_of (@name_constant) : !fir.ref<!fir.char<1>>
+  %j2 = constant 9 : i64
+  %j3 = fir.emboxchar %j1, %j2 : (!fir.ref<!fir.char<1>>, i64) -> !fir.boxchar<1>
+  return %j3 : !fir.boxchar<1>
+}
diff --git a/not-test/fir/commute.fir b/not-test/fir/commute.fir
new file mode 100644
index 000000000000..6e55bb0e36be
--- /dev/null
+++ b/not-test/fir/commute.fir
@@ -0,0 +1,21 @@
+func @f1(%a : i32, %b : i32) -> i32 {
+  %1 = addi %a, %b : i32
+  %2 = addi %b, %a : i32
+  %3 = muli %1, %2 : i32
+  return %3 : i32
+}
+
+func @f2(%a : !fir.ref<i32>) -> i32 {
+  %1 = fir.load %a : !fir.ref<i32>
+  %2 = fir.load %a : !fir.ref<i32>
+  %3 = addi %1, %2 : i32
+  %4 = fir.load %a : !fir.ref<i32>
+  %5 = addi %3, %4 : i32
+  %6 = fir.load %a : !fir.ref<i32>
+  %7 = addi %5, %6 : i32
+  %8 = fir.load %a : !fir.ref<i32>
+  %9 = addi %7, %8 : i32
+  %10 = fir.load %a : !fir.ref<i32>
+  %11 = addi %10, %9 : i32
+  return %11 : i32
+}
diff --git a/not-test/fir/compare.fir b/not-test/fir/compare.fir
new file mode 100644
index 000000000000..8aa9f6864dc1
--- /dev/null
+++ b/not-test/fir/compare.fir
@@ -0,0 +1,29 @@
+func @cmp(%a : !fir.real<10>, %b : !fir.real<10>) -> i1 {
+  %1 = "fir.cmpf"(%a, %b) {predicate = 1} : (!fir.real<10>, !fir.real<10>) -> i1
+  return %1 : i1
+}
+
+func @cmp2(%a : !fir.real<16>, %b : !fir.real<16>) -> i1 {
+  %1 = fir.cmpf "ult", %a, %b : !fir.real<16>
+  return %1 : i1
+}
+
+func @cmp3(%a : !fir.complex<4>, %b : !fir.complex<4>) -> i1 {
+  %1 = fir.cmpc "ueq", %a, %b : !fir.complex<4>
+  return %1 : i1
+}
+
+func @neg1(%a : !fir.real<8>) -> !fir.real<8> {
+  %1 = "fir.negf"(%a) : (!fir.real<8>) -> !fir.real<8>
+  return %1 : !fir.real<8>
+}
+
+func @neg2(%a : !fir.real<8>) -> !fir.real<8> {
+  %1 = fir.negf %a : !fir.real<8>
+  return %1 : !fir.real<8>
+}
+
+func @neg3(%a : !fir.complex<8>) -> !fir.complex<8> {
+  %1 = fir.negc %a : !fir.complex<8>
+  return %1 : !fir.complex<8>
+}
diff --git a/not-test/fir/complex.fir b/not-test/fir/complex.fir
new file mode 100644
index 000000000000..958baa430ff4
--- /dev/null
+++ b/not-test/fir/complex.fir
@@ -0,0 +1,22 @@
+func @foo(%a : !fir.complex<4>, %b : !fir.complex<4>, %c : !fir.complex<4>, %d : !fir.complex<4>, %e : !fir.complex<4>) -> !fir.complex<4> {
+  %1 = fir.addc %a, %b : !fir.complex<4>
+  %2 = fir.mulc %1, %c : !fir.complex<4>
+  %3 = fir.subc %2, %d : !fir.complex<4>
+  %4 = fir.divc %3, %e : !fir.complex<4>
+  return %4 : !fir.complex<4>
+}
+
+func @f2(%a : !fir.complex<4>) -> f32 {
+  %0 = constant 0 : i32
+  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
+  return %1 : f32
+}
+
+func @f3(%a : !fir.complex<4>) -> !fir.complex<4> {
+  %0 = constant 1 : i32
+  %1 = fir.extract_value %a, %0 : (!fir.complex<4>, i32) -> f32
+  %2 = constant 0.0 : f32
+  %3 = fir.subf %2, %1 : f32
+  %4 = fir.insert_value %a, %3, %0 : (!fir.complex<4>, f32, i32) -> !fir.complex<4>
+  return %4 : !fir.complex<4>
+}
diff --git a/not-test/fir/complex.mlir b/not-test/fir/complex.mlir
new file mode 100644
index 000000000000..5a36992c9567
--- /dev/null
+++ b/not-test/fir/complex.mlir
@@ -0,0 +1,6 @@
+func @add(%a : complex<f32>, %b : complex<f32>) -> complex<f32>
+
+func @foo(%a : complex<f32>, %b : complex<f32>) -> complex<f32> {
+  %1 = call @add(%a, %b) : (complex<f32>, complex<f32>) -> complex<f32>
+  return %1 : complex<f32>
+}
diff --git a/not-test/fir/constant.fir b/not-test/fir/constant.fir
new file mode 100644
index 000000000000..67ca40f36611
--- /dev/null
+++ b/not-test/fir/constant.fir
@@ -0,0 +1,19 @@
+func @x() -> !fir.array<3x!fir.char<1>> {
+  %1 = fir.constant "xyz" : !fir.array<3x!fir.char<1>>
+  return %1 : !fir.array<3x!fir.char<1>>
+}
+
+func @y() -> !fir.real<10> {
+  %1 = fir.constant "42.4" : !fir.real<10>
+  return %1 : !fir.real<10>
+}
+
+func @z() -> !fir.logical<1> {
+  %1 = fir.constant "true" : !fir.logical<1>
+  return %1 : !fir.logical<1>
+}
+
+func @z2() -> !fir.ref<!fir.char<1>> {
+  %1 = fir.constant "abc" : !fir.ref<!fir.char<1>>
+  return %1 : !fir.ref<!fir.char<1>>
+}
diff --git a/not-test/fir/dynlayout.fir b/not-test/fir/dynlayout.fir
new file mode 100644
index 000000000000..5646db53975e
--- /dev/null
+++ b/not-test/fir/dynlayout.fir
@@ -0,0 +1,38 @@
+// dynamic case
+
+// dynamically sized type
+func @_QQSIZEOF_a(%p1 : i64, %p2 : i64) -> i64 {
+  %c1 = constant 1 : i64  // sizeof CHARACTER(1)
+  %1 = muli %p1, %c1 : i64
+  %c2 = constant 2 : i64  // sizeof CHARACTER(2)
+  %2 = muli %p2, %c2 : i64
+  %3 = addi %1, %2 : i64
+  return %3 : i64
+}
+
+func @_QQOFFSETOF_a_f1(%p1 : i64, %p2 : i64) -> i32 {
+  %0 = constant 0 : i64
+  %1 = fir.convert %0 : (i64) -> i32
+  return %1 : i32
+}
+
+func @_QQOFFSETOF_a_f2(%p1 : i64, %p2 : i64) -> i32 {
+  %c1 = constant 1 : i64
+  %1 = muli %p1, %c1 : i64
+  %2 = fir.convert %1 : (i64) -> i32
+  return %2 : i32
+}
+
+// get 'a%f2(x)'
+func @f(%a : !fir.box<!fir.type<a(p1:i64,p2:i64){f1:!fir.array<?x!fir.char<1>>, f2:!fir.array<?x!fir.char<2>>}>>, %x : i32, %q1 : i64, %q2 : i64) -> !fir.char<2> {
+  %p1p = fir.len_param_index p1, !fir.type<a>
+  %p2p = fir.len_param_index p2, !fir.type<a>
+  %p1c = fir.coordinate_of %a, %p1p : (!fir.box<!fir.type<a>>, !fir.len) -> !fir.ref<i64>
+  %p2c = fir.coordinate_of %a, %p2p : (!fir.box<!fir.type<a>>, !fir.len) -> !fir.ref<i64>
+  %p1 = fir.load %p1c : !fir.ref<i64>
+  %p2 = fir.load %p2c : !fir.ref<i64>
+  %1 = fir.field_index f2, !fir.type<a>(%p1, %p2) : i64, i64
+  %2 = fir.coordinate_of %a, %1, %x : (!fir.box<!fir.type<a>>, !fir.field, i32) -> !fir.ref<!fir.char<2>>
+  %3 = fir.load %2 : !fir.ref<!fir.char<2>>
+  return %3 : !fir.char<2>
+}
diff --git a/not-test/fir/embox.fir b/not-test/fir/embox.fir
new file mode 100644
index 000000000000..801e7241b424
--- /dev/null
+++ b/not-test/fir/embox.fir
@@ -0,0 +1,6 @@
+#x0 = (d0, d1) -> (d1, d0)
+
+func @f(%arg : !fir.ref<!fir.array<?xf64>>) {
+  %1 = fir.embox %arg [#x0] : (!fir.ref<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>, >
+  return
+}
diff --git a/not-test/fir/fir-dt.fir b/not-test/fir/fir-dt.fir
new file mode 100644
index 000000000000..7dbd6bd13187
--- /dev/null
+++ b/not-test/fir/fir-dt.fir
@@ -0,0 +1,5 @@
+func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+
+fir.dispatch_table @dispatch_tbl {
+  fir.dt_entry method, @method_impl
+}
diff --git a/not-test/lower/character-assignment.f90 b/not-test/lower/character-assignment.f90
new file mode 100644
index 000000000000..65550902e8d5
--- /dev/null
+++ b/not-test/lower/character-assignment.f90
@@ -0,0 +1,69 @@
+! Simple character assignment tests
+subroutine assign1(s1, s2)
+  character(*, 1) :: s1, s2
+  s1 = s2
+end subroutine
+subroutine assign2(s1, s2)
+  character(*, 2) :: s1, s2
+  s1 = s2
+end subroutine
+subroutine assign4(s1, s2)
+  character(*, 4) :: s1, s2
+  s1 = s2
+end subroutine
+
+! Test substring assignment
+subroutine assign_substring1(s1, s2, lb, ub)
+  character(*, 1) :: s1, s2
+  integer :: lb, ub
+  s1(lb:ub) = s2
+end subroutine
+subroutine assign_substring2(s1, s2, lb, ub)
+  character(*, 2) :: s1, s2
+  integer :: lb, ub
+  s1(lb:ub) = s2
+end subroutine
+subroutine assign_substring4(s1, s2, lb, ub)
+  character(*, 4) :: s1, s2
+  integer :: lb, ub
+  s1(lb:ub) = s2
+end subroutine
+
+! Test overlapping assignments
+! RHS depends on LHS in a way that if no temp is made to evaluate
+! RHS, these tests should fail.
+subroutine assign_overlap1(s1, s2, lb)
+  character(*, 1) :: s1, s2
+  integer :: lb
+  s1(lb:) = s1
+end subroutine
+subroutine assign_overlap2(s1, s2, lb)
+  character(*, 2) :: s1, s2
+  integer :: lb
+  s1(lb:) = s1
+end subroutine
+subroutine assign_overlap4(s1, s2, lb)
+  character(*, 4) :: s1, s2
+  integer :: lb
+  s1(lb:) = s1
+end subroutine
+
+! Test when length is given in specification expressions
+subroutine assign_spec_expr_len1(s1, s2, l1, l2)
+  integer :: l1, l2
+  character(l1, 1) :: s1
+  character(l2, 1) :: s2
+  s1 = s2
+end subroutine
+subroutine assign_spec_expr_len2(s1, s2, l1, l2)
+  integer :: l1, l2
+  character(l1, 2) :: s1
+  character(l2, 2) :: s2
+  s1 = s2
+end subroutine
+subroutine assign_spec_expr_len4(s1, s2, l1, l2)
+  integer :: l1, l2
+  character(l1, 4) :: s1
+  character(l2, 4) :: s2
+  s1 = s2
+end subroutine
diff --git a/not-test/lower/expr-test-generator.cc b/not-test/lower/expr-test-generator.cc
new file mode 100644
index 000000000000..a4f3a741bfb6
--- /dev/null
+++ b/not-test/lower/expr-test-generator.cc
@@ -0,0 +1,692 @@
+//===-- test/lower/expr-test-generator.cc -----------------------*- 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 <cassert>
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <optional>
+#include <sstream>
+#include <vector>
+
+// Utility to generate Fortran expression evaluation tests.
+// Given an expression "x op y", this utility can generates
+// functions that evaluate the expression and takes x and y
+// as argument and return the result.
+// The utility allows to describe fortran intrinsic operations
+// and their possible operand types in a table driven way.
+// Functions to test all possible intrinsic operations can then be
+// generated.
+// The utility can also generate a driver function that calls the
+// previous and compare the results with expectations
+// (currently provided by calling a similar function compiled by a reference
+// compiler).
+
+// TODO: Integrate with f18 libs to remove redundancies ?
+// TODO: How could Peter's intrinsic table be used to generate
+//       intrinsic expression tests in a similar way ?
+
+enum class TypeCategory { Integer, Real, Complex, Logical, Character };
+
+struct Type {
+  constexpr Type(TypeCategory c) : cat{c}, kind{} {}
+  constexpr Type(TypeCategory c, int k) : cat{c}, kind{k} {}
+  bool operator==(const Type &that) const {
+    return cat == that.cat && kind == that.kind;
+  }
+  bool operator!=(const Type &that) const { return !(*this == that); }
+  std::ostream &Dump(std::ostream &s) const {
+    switch (cat) {
+    case TypeCategory::Integer: s << "INTEGER"; break;
+    case TypeCategory::Real: s << "REAL"; break;
+    case TypeCategory::Logical: s << "LOGICAL"; break;
+    case TypeCategory::Complex: s << "COMPLEX"; break;
+    case TypeCategory::Character: s << "CHARACTER"; break;
+    }
+    if (kind) {
+      s << "(" << *kind << ")";
+    }
+    return s;
+  }
+
+  TypeCategory cat;
+  std::optional<int> kind;  // none = default
+};
+
+static constexpr Type DefaultReal{TypeCategory::Real};
+static constexpr Type Real4{TypeCategory::Real, 4};
+static constexpr Type Real8{TypeCategory::Real, 8};
+static constexpr Type DefaultInteger{TypeCategory::Integer};
+static constexpr Type Integer1{TypeCategory::Integer, 1};
+static constexpr Type Integer2{TypeCategory::Integer, 2};
+static constexpr Type Integer4{TypeCategory::Integer, 4};
+static constexpr Type Integer8{TypeCategory::Integer, 8};
+static constexpr Type DefaultComplex{TypeCategory::Complex};
+static constexpr Type Complex4{TypeCategory::Complex, 4};
+static constexpr Type Complex8{TypeCategory::Complex, 4};
+static constexpr Type DefaultLogical{TypeCategory::Logical};
+// Currently other types are not testable because existing Fortran
+// compilers do not provide these types.
+
+enum class TypePattern {
+  OperandNumeric,
+  OperandLogical,
+  OperandComparable,
+  OperandOrdered
+};
+enum class Constraint { None, NonZeroRHS, NoNegativeLHSWhenRealRHS };
+
+struct Operation {
+  bool IsUnaryOp() const { return isUnaryOp; }
+  std::optional<Type> GetResultTypeForArguments(Type, Type) const;
+  std::optional<Type> GetResultTypeForArgument(Type) const;
+  const char *name;
+  const char *symbol;
+  TypePattern pattern;
+  Constraint constraint{Constraint::None};
+  bool isUnaryOp{false};
+};
+
+// Sorted by increasing precedence (not stricly increasing). See F2018
+// table 10.1.
+static Operation operations[]{
+    // TODO should be OK constexpr but g++ 8.2 not happy
+    // defined-binary-op cannot be described here.
+    {"eqv", ".EQV.", TypePattern::OperandLogical},
+    {"neqv", ".NEQV.", TypePattern::OperandLogical},
+    {"or", ".OR.", TypePattern::OperandLogical},
+    {"and", ".AND.", TypePattern::OperandLogical},
+    {"not", ".NOT.", TypePattern::OperandLogical, Constraint::None, true},
+    {"eq", ".EQ.", TypePattern::OperandComparable},
+    {"ne", ".NE.", TypePattern::OperandComparable},
+    {"lt", ".LT.", TypePattern::OperandOrdered},
+    {"le", ".LE.", TypePattern::OperandOrdered},
+    {"gt", ".GT.", TypePattern::OperandOrdered},
+    {"ge", ".GE.", TypePattern::OperandOrdered},
+    // TODO: Concat
+    {"add", "+", TypePattern::OperandNumeric},
+    {"sub", "-", TypePattern::OperandNumeric},
+    {"minus", "-", TypePattern::OperandNumeric, Constraint::None, true},
+    {"plus", "+", TypePattern::OperandNumeric, Constraint::None, true},
+    {"mult", "*", TypePattern::OperandNumeric},
+    {"div", "/", TypePattern::OperandNumeric, Constraint::NonZeroRHS},
+    {"power", "**", TypePattern::OperandNumeric,
+        Constraint::NoNegativeLHSWhenRealRHS},  // TODO: check power pattern
+    // defined-unary-op cannot be described here.
+};
+
+static bool IsLogical(const Type t) { return t.cat == TypeCategory::Logical; }
+static bool IsCharacter(const Type t) {
+  return t.cat == TypeCategory::Character;
+}
+static bool IsComplex(const Type t) { return t.cat == TypeCategory::Complex; }
+static bool IsReal(const Type t) { return t.cat == TypeCategory::Real; }
+
+static bool IsOrderedNumeric(const Type t) {
+  return t.cat == TypeCategory::Real || t.cat == TypeCategory::Integer;
+}
+
+static bool IsNumeric(const Type t) {
+  return t.cat == TypeCategory::Real || t.cat == TypeCategory::Integer ||
+      t.cat == TypeCategory::Complex;
+}
+
+std::optional<Type> Operation::GetResultTypeForArgument(Type t) const {
+  switch (pattern) {
+  case TypePattern::OperandNumeric:
+    if (IsNumeric(t)) {
+      return t;
+    }
+    break;
+  case TypePattern::OperandLogical:
+    if (IsLogical(t)) {
+      return t;
+    }
+    break;
+  case TypePattern::OperandComparable:
+  case TypePattern::OperandOrdered:
+    assert(false && "No unary comparisons");
+    break;
+  }
+  return std::nullopt;
+}
+
+static std::optional<Type> SelectBiggestKindForResult(
+    TypeCategory resultCat, Type lhs, Type rhs) {
+  if (!lhs.kind && !rhs.kind) {
+    return Type{resultCat};
+  } else if (lhs.kind && rhs.kind) {
+    return Type{resultCat, std::max(*lhs.kind, *rhs.kind)};
+  } else {
+    // Cannot know without more info about compiler what default compares to.
+    return std::nullopt;
+  }
+}
+
+std::optional<Type> Operation::GetResultTypeForArguments(
+    Type lhs, Type rhs) const {
+  // See Fortran 2018 table 10.2 and section 10.1.9.3
+  switch (pattern) {
+  case TypePattern::OperandNumeric:
+    if (!IsNumeric(rhs) || !IsNumeric(lhs)) {
+      return std::nullopt;
+    }
+    if (lhs.cat == rhs.cat) {
+      return SelectBiggestKindForResult(lhs.cat, lhs, rhs);
+    }
+    // different categories
+    if (IsComplex(lhs)) {
+      if (IsReal(rhs)) {
+        return SelectBiggestKindForResult(TypeCategory::Complex, lhs, rhs);
+      }
+      return lhs;
+    }
+    if (IsComplex(rhs)) {
+      if (IsReal(lhs)) {
+        return SelectBiggestKindForResult(TypeCategory::Complex, lhs, rhs);
+      }
+      return rhs;
+    }
+    if (IsReal(lhs)) {
+      // rhs must be integer
+      return lhs;
+    }
+    if (IsReal(rhs)) {
+      // lhs must be integer
+      return rhs;
+    }
+    assert(false && "no more operand cases");
+  case TypePattern::OperandLogical:
+    if (IsLogical(rhs) && IsLogical(lhs)) {
+      return SelectBiggestKindForResult(TypeCategory::Logical, lhs, rhs);
+    }
+    break;
+  case TypePattern::OperandComparable:
+    if (IsNumeric(lhs) && IsNumeric(rhs)) {
+      return DefaultLogical;
+    } else if (IsCharacter(lhs) && IsCharacter(lhs) && lhs.kind == rhs.kind) {
+      return DefaultLogical;
+    }
+    break;
+  case TypePattern::OperandOrdered:
+    if (IsOrderedNumeric(lhs) && IsOrderedNumeric(rhs)) {
+      return DefaultLogical;
+    } else if (IsCharacter(lhs) && IsCharacter(lhs) && lhs.kind == rhs.kind) {
+      return DefaultLogical;
+    }
+    break;
+  }
+  return std::nullopt;
+}
+
+// Test Plan Part
+
+// Only string list input for now
+using Input = std::vector<const char *>;
+// TODO: more inputs method (e.g. random pick)
+
+enum class Eval { Constant, Dynamic };
+struct TestPlan {
+  std::vector<const char *> operationToTests;
+  std::vector<std::pair<Type, Input>> inputs;
+  Eval referenceEvaluationMethod{Eval::Dynamic};
+  Eval testEvaluationMethod{Eval::Dynamic};
+};
+
+static inline std::string IndexedName(const char *name, std::size_t index) {
+  return std::string{name} + std::to_string(index);
+}
+
+static constexpr auto passedName{"passed"};
+static constexpr auto failedName{"failed"};
+
+struct CodeGenerator {
+  static constexpr auto varNameBase{"x"};
+  static constexpr auto paramNameBase{"a"};
+  static constexpr auto loopIndexNameBase{"i"};
+  static constexpr auto testResultName{"test_res"};
+  static constexpr auto refResultName{"ref_res"};
+
+  template<Eval Ev>
+  void GenerateEvaluationFunction(
+      const std::string &functionName, std::ostream &s) const {
+    GenerateEvaluationFunctionStmtAndSpec<Ev>(functionName, s);
+    GenerateExpressionEvaluation<Ev>(functionName, s);
+    s << "END FUNCTION" << std::endl;
+    s << std::endl;
+  }
+
+  void GenerateEvaluationFunction(const std::string &functionNameBase,
+      std::ostream &s, Eval ev, bool isReference) const {
+    auto functionName{isReference ? GetReferenceFunctionName(functionNameBase)
+                                  : GetTestFunctionName(functionNameBase)};
+    switch (ev) {
+    case Eval::Constant:
+      GenerateEvaluationFunction<Eval::Constant>(functionName, s);
+      break;
+    case Eval::Dynamic:
+      GenerateEvaluationFunction<Eval::Dynamic>(functionName, s);
+      break;
+    }
+  }
+
+  void GenerateDriverSubroutine(const std::string &functionNameBase,
+      std::ostream &s, Eval refEval, Eval testEval) const {
+    s << "SUBROUTINE " << GetDriverName(functionNameBase) << "(" << passedName
+      << ", " << failedName << ")" << std::endl;
+    std::size_t numInputs{inputs.size()};
+    assert(numInputs > 0 && "Expected non empty inputs in driver");
+    if (refEval == Eval::Dynamic || testEval == Eval::Dynamic) {
+      // Inputs are required inside the driver only if one evaluation function
+      // is dynamic and inputs need to be passed to it from the driver.
+      for (std::size_t i{0}; i < numInputs; ++i) {
+        GenerateInputAsArrayParameter(i, s);
+      }
+    }
+    s << "INTEGER :: " << passedName << ", " << failedName << std::endl;
+    resultType.Dump(s) << " :: " << testResultName << ", " << refResultName
+                       << std::endl;
+
+    // TODO: Add a test number limit in cases there are many inputs ? This would
+    // need to be kept in sync with folding evaluation.
+    for (std::size_t i{0}; i < numInputs; ++i) {
+      s << "DO " << IndexedName(loopIndexNameBase, i) << " = 1,"
+        << inputs[i]->second.size() << std::endl;
+    }
+
+    // TODO: Handle constraints (e.g divide by zero). Would also need to be kept
+    // in sync with folding evaluation.
+    s << refResultName << " = ";
+    auto refFuncName{GetReferenceFunctionName(functionNameBase)};
+    switch (refEval) {
+    case Eval::Dynamic:
+      GenerateEvaluationFunctionCall<Eval::Dynamic>(refFuncName, s);
+      break;
+    case Eval::Constant:
+      GenerateEvaluationFunctionCall<Eval::Constant>(refFuncName, s);
+      break;
+    }
+    s << testResultName << " = ";
+    auto testFuncName{GetTestFunctionName(functionNameBase)};
+    switch (testEval) {
+    case Eval::Dynamic:
+      GenerateEvaluationFunctionCall<Eval::Dynamic>(testFuncName, s);
+      break;
+    case Eval::Constant:
+      GenerateEvaluationFunctionCall<Eval::Constant>(testFuncName, s);
+      break;
+    }
+
+    s << "IF (";
+    GenerateResultsComparison(s);
+    s << ") THEN" << std::endl;
+    s << passedName << " = " << passedName << " + 1" << std::endl;
+    s << "ELSE" << std::endl;
+    s << failedName << " = " << failedName << " + 1" << std::endl;
+    GenerateFailureMessage(functionNameBase, s);
+    s << "END IF" << std::endl;
+
+    for (std::size_t i{0}; i < numInputs; ++i) {
+      s << "END DO" << std::endl;
+    }
+    s << "END SUBROUTINE" << std::endl;
+    s << std::endl;
+  }
+
+  template<Eval Ev>
+  void GenerateEvaluationFunctionCall(
+      const std::string &functionName, std::ostream &s) const {
+    s << functionName << "(";
+    if constexpr (Ev == Eval::Dynamic) {
+      ApplyOnInputIndexes(
+          [&](std::size_t i) {
+            return GetArrayElement(paramNameBase, loopIndexNameBase, i);
+          },
+          ", ", s);
+    } else {
+      static_assert(Ev == Eval::Constant, "unhandled evaluation method");
+      ApplyOnInputIndexes(
+          [&](std::size_t i) { return IndexedName(loopIndexNameBase, i); },
+          ", ", s);
+    }
+    s << ")" << std::endl;
+  }
+
+  void GenerateFailureMessage(
+      const std::string &functionNameBase, std::ostream &s) const {
+    s << "PRINT *, \"FAILED " << functionNameBase << " test: \"";
+    for (std::size_t i{0}; i < inputs.size(); ++i) {
+      auto loopId{IndexedName(loopIndexNameBase, i)};
+      s << ", \"" << loopId << " = \", " << loopId;
+    }
+    s << std::endl;
+    s << "PRINT *, \"  expected \", " << refResultName << ", \" got: \","
+      << testResultName << std::endl;
+  }
+
+  void GenerateInputAsArrayParameter(std::size_t i, std::ostream &s) const {
+    const auto &literals{inputs[i]->second};
+    const auto size{literals.size()};
+    assert(size > 0 && "No actual literal input for test");
+    inputs[i]->first.Dump(s)
+        << ", PARAMETER :: " << IndexedName(paramNameBase, i) << "(" << size
+        << ") = [";
+    s << literals[0];
+    for (std::size_t i{1}; i < size; ++i) {
+      s << ", " << literals[i];
+    }
+    s << "]" << std::endl;
+  }
+
+  void GenerateDriverCall(
+      const std::string &functionNameBase, std::ostream &s) const {
+    s << "CALL " << GetDriverName(functionNameBase) << "(" << passedName << ", "
+      << failedName << ")" << std::endl;
+  }
+
+  template<Eval Ev>
+  void GenerateEvaluationFunctionStmtAndSpec(
+      const std::string &functionName, std::ostream &s) const {
+    resultType.Dump(s) << " FUNCTION " << functionName << "(";
+    assert(inputs.size() && "expect at least on argument");
+    const auto &name{Ev == Eval::Constant ? loopIndexNameBase : varNameBase};
+    s << IndexedName(name, 0);
+    for (std::size_t i{1}; i < inputs.size(); ++i) {
+      s << ", " << IndexedName(name, i);
+    }
+    s << ")" << std::endl;
+    std::size_t i{0};
+    if constexpr (Ev == Eval::Constant) {
+      for (const auto *input : inputs) {
+        s << "INTEGER :: " << IndexedName(name, i++) << std::endl;
+      }
+    } else {
+      for (const auto *input : inputs) {
+        input->first.Dump(s) << " :: " << IndexedName(name, i++) << std::endl;
+      }
+    }
+  }
+
+  template<Eval Ev>
+  void GenerateExpressionEvaluation(
+      const std::string &resultName, std::ostream &s) const {
+    if constexpr (Ev == Eval::Constant) {
+      GenerateConstantExpressionEvaluation(resultName, s);
+    } else {
+      static_assert(
+          Ev == Eval::Dynamic, "unhandled expression evaluation method");
+      s << resultName << " = ";
+      GenerateExpression(
+          [&](std::size_t i) { return IndexedName(varNameBase, i); }, s);
+      s << std::endl;
+    }
+  }
+
+  void GenerateConstantExpressionEvaluation(
+      const std::string &resultName, std::ostream &s) const {
+    // Declare constant inputs
+    for (std::size_t i{0}; i < inputs.size(); ++i) {
+      GenerateInputAsArrayParameter(i, s);
+    }
+    // Evaluate in a parameter array using ac-implied-do
+    auto cstResultName{IndexedName(paramNameBase, inputs.size())};
+    assert(inputs.size() > 0 && "expected at least one operands");
+    resultType.Dump(s) << " , PARAMETER :: " << cstResultName << "(*";
+    for (std::size_t i{1}; i < inputs.size(); ++i) {
+      s << ", *";
+    }
+    s << ") = RESHAPE ([(";
+    for (std::size_t i{1}; i < inputs.size(); ++i) {
+      s << "(";
+    }
+
+    // Expression evaluation inside ac-implied-do
+    // TODO: how to handle constraints ?
+    GenerateExpression(
+        [&](std::size_t i) {
+          return GetArrayElement(paramNameBase, loopIndexNameBase, i);
+        },
+        s);
+
+    // ac-implied-do (opening ")" were emited before).
+    s << ", ";
+    ApplyOnInputIndexes(
+        [&](std::size_t i) {
+          return IndexedName(loopIndexNameBase, i) + " = 1," +
+              std::to_string(inputs[i]->second.size()) + ")";
+        },
+        ",", s);
+
+    // RESHAPE SHAPE argument
+    s << "], [";
+    ApplyOnInputIndexes(
+        [&](std::size_t i) { return inputs[i]->second.size(); }, ",", s);
+    s << "])" << std::endl;
+
+    // dynamically fetch requested result from the constant array
+    s << resultName << " = " << cstResultName << "(";
+    ApplyOnInputIndexes(
+        [&](std::size_t i) { return IndexedName(loopIndexNameBase, i); }, ",",
+        s);
+    s << ")" << std::endl;
+  }
+
+  template<typename T>
+  void inline ApplyOnInputIndexes(
+      const T &callable, const std::string &sep, std::ostream &s) const {
+    auto size{inputs.size()};
+    if (size != 0) {
+      s << callable(0);
+    }
+    for (std::size_t i{1}; i < size; ++i) {
+      s << ", " << callable(i);
+    }
+  }
+
+  template<typename T>
+  void inline GenerateExpression(
+      const T &operandGenerator, std::ostream &s) const {
+    if (inputs.size() == 1) {
+      s << op.symbol << " " << operandGenerator(0);
+    } else {
+      assert(inputs.size() == 2 && "expected binary opreation");
+      s << operandGenerator(0) << " " << op.symbol << " "
+        << operandGenerator(1);
+    }
+  }
+
+  void GenerateEvaluationFunctionInterface(const std::string &functionNameBase,
+      std::ostream &s, Eval ev, bool isReference) const {
+    auto functionName{isReference ? GetReferenceFunctionName(functionNameBase)
+                                  : GetTestFunctionName(functionNameBase)};
+    switch (ev) {
+    case Eval::Constant:
+      GenerateEvaluationFunctionStmtAndSpec<Eval::Constant>(functionName, s);
+      break;
+    case Eval::Dynamic:
+      GenerateEvaluationFunctionStmtAndSpec<Eval::Dynamic>(functionName, s);
+      break;
+    }
+    s << "END FUNCTION" << std::endl;
+  }
+
+  void GenerateResultsComparison(std::ostream &s) const {
+    auto compareReal{[&](const std::string &x, const std::string &y) {
+      // TODO: This should not always be an absolute comparison (epsilon margin
+      // for fp.).
+      s << x << ".EQ." << y << " .OR. ";
+      s << "(IEEE_IS_NAN(" << x << ") .AND. IEEE_IS_NAN(" << y << "))";
+    }};
+    if (resultType.cat == TypeCategory::Real) {
+      compareReal(refResultName, testResultName);
+    } else if (resultType.cat == TypeCategory::Complex) {
+      s << "(";
+      compareReal(std::string{refResultName} + "%RE",
+          std::string{testResultName} + "%RE");
+      s << ") .AND. (";
+      compareReal(std::string{refResultName} + "%IM",
+          std::string{testResultName} + "%IM");
+      s << ")";
+    } else {
+      const auto *compareOp{
+          resultType.cat == TypeCategory::Logical ? ".EQV." : ".EQ."};
+      s << refResultName << compareOp << testResultName;
+    }
+  }
+
+  // a0(i0) and such
+  static std::string GetArrayElement(
+      const char *arrayNameBase, const char *indexNameBase, std::size_t i) {
+    return IndexedName(arrayNameBase, i) + "(" + IndexedName(indexNameBase, i) +
+        ")";
+  }
+
+  static std::string GetTestFunctionName(const std::string &functionNameBase) {
+    return functionNameBase + "_test";
+  }
+  static std::string GetReferenceFunctionName(
+      const std::string &functionNameBase) {
+    return functionNameBase + "_ref";
+  }
+  static std::string GetDriverName(const std::string &functionNameBase) {
+    return functionNameBase + "_driver";
+  }
+  Type resultType;
+  const Operation &op;
+  std::vector<const std::pair<Type, Input> *> inputs;
+};
+
+// Test Generator
+struct TestGenerator {
+
+  void GenerateTests(std::ostream &testFile, std::ostream &refFile) {
+    std::stringstream testContentStream;
+    std::stringstream testInterfaceStream;
+    std::stringstream referenceAndDriverContentStream;
+    std::stringstream programContentStream;
+    auto generateInBuffers{
+        [&](const CodeGenerator &codeGen, const std::string &functionNameBase) {
+          codeGen.GenerateEvaluationFunction(functionNameBase,
+              testContentStream, plan.testEvaluationMethod, false);
+          codeGen.GenerateEvaluationFunctionInterface(functionNameBase,
+              testInterfaceStream, plan.testEvaluationMethod, false);
+          codeGen.GenerateEvaluationFunction(functionNameBase,
+              referenceAndDriverContentStream, plan.referenceEvaluationMethod,
+              true);
+          codeGen.GenerateDriverSubroutine(functionNameBase,
+              referenceAndDriverContentStream, plan.referenceEvaluationMethod,
+              plan.testEvaluationMethod);
+          codeGen.GenerateDriverCall(functionNameBase, programContentStream);
+        }};
+
+    for (const auto *opName : plan.operationToTests) {
+      const auto *op{GetOperation(opName)};
+      assert(op && "Broken test plan: undefined operation");
+      for (const auto &input1 : plan.inputs) {
+        if (op->IsUnaryOp()) {
+          if (auto resultType{op->GetResultTypeForArgument(input1.first)}) {
+            CodeGenerator codeGen{*resultType, *op, {&input1}};
+            auto functionNameBase{GetDistinctFunctionNameBase(*op)};
+            generateInBuffers(codeGen, functionNameBase);
+          }
+        } else {
+          for (const auto &input2 : plan.inputs) {
+            if (auto resultType{op->GetResultTypeForArguments(
+                    input1.first, input2.first)}) {
+              CodeGenerator codeGen{*resultType, *op, {&input1, &input2}};
+              auto functionNameBase{GetDistinctFunctionNameBase(*op)};
+              generateInBuffers(codeGen, functionNameBase);
+            }
+          }
+        }
+      }
+    }
+
+    // Organize generated code
+    testFile << "! Generated test file" << std::endl;
+    testFile << testContentStream.rdbuf();
+    testFile << "! End of generated test file" << std::endl;
+
+    refFile << "! Generated reference and driver " << std::endl;
+    refFile << "MODULE REFERENCE_AND_DRIVER" << std::endl;
+    refFile << "USE IEEE_ARITHMETIC" << std::endl;  // for IEEE_IS_NAN
+    refFile << "INTERFACE" << std::endl;
+    refFile << testInterfaceStream.rdbuf();
+    refFile << "END INTERFACE" << std::endl;
+    refFile << std::endl;
+    refFile << "CONTAINS" << std::endl;
+    refFile << referenceAndDriverContentStream.rdbuf();
+    refFile << "END MODULE" << std::endl;
+    refFile << std::endl;
+    refFile << "PROGRAM EXPR_TEST" << std::endl;
+    refFile << "USE REFERENCE_AND_DRIVER" << std::endl;
+    refFile << "INTEGER :: " << passedName << ", " << failedName << std::endl;
+    refFile << passedName << " = 0 " << std::endl;
+    refFile << failedName << " = 0 " << std::endl;
+    refFile << programContentStream.rdbuf();
+    refFile << "PRINT *, \"Passed: \"," << passedName << ", \" Failed: \", "
+            << failedName << std::endl;
+    refFile << "IF (" << failedName << ".GT. 0) ERROR STOP 1" << std::endl;
+    refFile << "END PROGRAM" << std::endl;
+    refFile << "! End of generated reference and driver" << std::endl;
+  }
+
+  const Operation *GetOperation(const char *name) {
+    assert(name && "nullptr string for test name");
+    for (const auto &op : operations) {
+      assert(op.name && "Broken operation");
+      if (std::strcmp(name, op.name) == 0) {
+        return &op;
+      }
+    }
+    return nullptr;
+  }
+
+  std::string GetDistinctFunctionNameBase(const Operation &op) {
+    return IndexedName(op.name, funcId++);
+  }
+
+  TestPlan plan;
+  std::size_t funcId{0};
+};
+
+// Test driver
+int main(int argc, char **argv) {
+  Eval testEvalMethod{Eval::Dynamic};
+  Eval refEvalMethod{Eval::Dynamic};
+  int planId{0};
+  for (int i{0}; i < argc; ++i) {
+    if (std::strcmp(argv[i], "test=folding") == 0) {
+      testEvalMethod = Eval::Constant;
+    } else if (std::strcmp(argv[i], "ref=folding") == 0) {
+      refEvalMethod = Eval::Constant;
+    }
+  }
+
+  TestGenerator{
+      {
+          {"eqv", "neqv", "or", "and", "not", "eq", "ne", "lt", "le", "gt",
+              "ge", "add", "sub", "minus", "plus", "mult", "div", "power"},
+          {
+              {Integer1, {"-1_1", "12_1", "2_1"}},
+              {Integer2, {"-1_2", "12500_2", "2_2"}},
+              {Integer4, {"31000_4", "-64354_4"}},
+              {Integer8, {"3000001_8", "-2654637545_8"}},
+              {Real4, {"1.03687448_4", "3.1254641_4"}},
+              {Real8, {"1.036874168446448_8", "3.12254533554641_8"}},
+              {Complex4, {"(-0.5_4,10.35544_4)", "(-5._4, 0.15647_4)"}},
+              {Complex8,
+                  {"(-0.5_8,10.35546579874_8)",
+                      "(-5.64654654_8, 0.155876974647_8)"}},
+              {DefaultLogical, {".false.", ".true."}},
+          },
+          refEvalMethod,
+          testEvalMethod,
+      }}
+      .GenerateTests(std::cout, std::cerr);
+}
diff --git a/not-test/lower/test-character-assignment.cc b/not-test/lower/test-character-assignment.cc
new file mode 100644
index 000000000000..ef7da61f3f30
--- /dev/null
+++ b/not-test/lower/test-character-assignment.cc
@@ -0,0 +1,357 @@
+//===-- test/lower/test-character-assignment.cc -----------------*- 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 <cassert>
+#include <codecvt>
+#include <iomanip>
+#include <iostream>
+#include <locale>
+#include <string>
+#include <type_traits>
+
+// Driver to tests Fortran subroutine from character-assignment.f90
+
+// So far lowering of fir::boxchar dummy to llvm does not layout character
+// arguments like other compiler do for F77. Templates provides a patch for
+// that.
+
+using LenT = std::int64_t;
+struct Fchar {
+  char *data;
+  LenT len;
+};
+
+template<typename... T> using SubF18 = void (*)(Fchar, Fchar, T...);
+template<typename... T>
+using SubF77 = void (*)(char *, char *, T..., LenT, LenT);
+template<typename... T>
+void CallSubroutine(SubF18<T...> f, Fchar s1, Fchar s2, T... args) {
+  f(s1, s2, args...);
+}
+
+template<typename... T>
+void CallSubroutine(SubF77<T...> f, Fchar s1, Fchar s2, T... args) {
+  f(s1.data, s2.data, args..., s1.len, s2.len);
+}
+
+// Define structures to create and manipulate Fortran Character
+// A canary is always added at the end of character storage so that
+// invalid overwrites can be detected.
+template<int K> struct CharStorage {};
+template<> struct CharStorage<1> {
+  using Type = std::string;
+  static const Type canary;
+};
+const CharStorage<1>::Type CharStorage<1>::canary{"_CaNaRy"};
+
+template<> struct CharStorage<2> {
+  using Type = std::u16string;
+  static const Type canary;
+};
+const CharStorage<2>::Type CharStorage<2>::canary{u"_CaNaRy"};
+
+template<> struct CharStorage<4> {
+  using Type = std::u32string;
+  static const Type canary;
+};
+const CharStorage<4>::Type CharStorage<4>::canary{U"_CaNaRy"};
+
+template<int Kind> struct FcharData {
+  using String = typename CharStorage<Kind>::Type;
+  using CharT = typename String::value_type;
+  FcharData(String str)
+    : data{str + CharStorage<Kind>::canary}, len{static_cast<LenT>(
+                                                 str.length())} {}
+  Fchar getFchar() {
+    const char *addr{reinterpret_cast<const char *>(data.data())};
+    return Fchar{const_cast<char *>(addr), len};
+  }
+
+  // UTF-8 dump
+  std::ostream &dump(std::ostream &os) const {
+    if constexpr (std::is_same_v<CharT, char>) {
+      os << data;
+    } else {
+      std::wstring_convert<std::codecvt_utf8<CharT>, CharT> cvt;
+      os << cvt.to_bytes(data);
+    }
+    return os;
+  }
+  // Hex dump
+  std::ostream &dumpHex(std::ostream &os) const {
+    os << std::hex;
+    for (auto c : data) {
+      if constexpr (std::is_same_v<CharT, char>) {
+        os << " 0x" << std::setw(2) << std::setfill('0')
+           << (int)((unsigned char)c);
+      } else {
+        os << " 0x" << std::setw(sizeof(CharT) * 2) << std::setfill('0') << c;
+      }
+    }
+    os << std::dec;
+    return os;
+  }
+
+  String data;
+  LenT len;  // may differ from string length for test purposes
+};
+
+template<int Kind>
+bool Check(const FcharData<Kind> &test, const FcharData<Kind> &ref,
+    const std::string &desc) {
+  if (test.data != ref.data) {
+    std::cout << "Failed: " << desc << std::endl;
+    ref.dump(std::cout << "  expected: '") << "'" << std::endl;
+    test.dump(std::cout << "  got     : '") << "'" << std::endl;
+    return false;
+  }
+  return true;
+}
+
+// Call compiled test subroutine and compare variable afterwards with a
+// reference. Compare against result from reference subroutine.
+template<int Kind, typename... T>
+bool TestSubroutine(const std::string &testName, SubF18<T...> fooTest,
+    SubF18<T...> fooRef, const FcharData<Kind> &s1, const FcharData<Kind> &s2,
+    T... otherArgs) {
+  // Make copies because data may be modified
+  FcharData<Kind> testS1{s1}, testS2{s2};
+  CallSubroutine(fooTest, testS1.getFchar(), testS2.getFchar(), otherArgs...);
+
+  // Compare against reference subroutine
+  FcharData<Kind> refS1{s1}, refS2{s2};
+  CallSubroutine(fooRef, refS1.getFchar(), refS2.getFchar(), otherArgs...);
+
+  auto description{testName + " KIND=" + std::to_string(Kind)};
+  bool result{Check(testS1, refS1, description + " s1")};
+  result &= Check(testS2, refS2, description + " s2");
+  return result;
+}
+
+// Compare against precomputed results.
+template<int Kind, typename... T>
+bool TestSubroutine(const std::string &testName, SubF18<T...> fooTest,
+    const FcharData<Kind> &s1, const FcharData<Kind> &refS1,
+    const FcharData<Kind> &s2, const FcharData<Kind> &refS2, T... otherArgs) {
+  // Make copies because data may be modified
+  FcharData<Kind> testS1{s1}, testS2{s2};
+  CallSubroutine(fooTest, testS1.getFchar(), testS2.getFchar(), otherArgs...);
+  auto description{testName + " KIND=" + std::to_string(Kind)};
+  bool result{Check(testS1, refS1, description + " s1")};
+  result &= Check(testS2, refS2, description + " s2");
+  return result;
+}
+
+// Test driver code (could maybe generated somehow)
+
+// String data to be used as inputs during the tests.
+template<int Kind> struct Inputs { static FcharData<Kind> s1, s2, s3; };
+
+template<> FcharData<1> Inputs<1>::s1{"aw*lSe4frliaw"};
+template<> FcharData<1> Inputs<1>::s2{"8\n e7t4$%&52Z"};
+template<> FcharData<1> Inputs<1>::s3{"quAli64^&$*#$8gl6"};
+
+template<> FcharData<2> Inputs<2>::s1{u"\u4e4dhy7&3o8%\u4e24"};
+template<> FcharData<2> Inputs<2>::s2{u"\u4f60\u4e0d\u662f F18 !\uff1f"};
+template<>
+FcharData<2> Inputs<2>::s3{
+    u"\u4f60\u597d\uff0c\u6211\u66df F18 ! \u4f60\u5462\uff1f"};
+
+template<> FcharData<4> Inputs<4>::s1{U"\u4e4dhy7&3o8%\u4e24"};
+template<> FcharData<4> Inputs<4>::s2{U"\u4f60\u4e0d\u662f F18 !\uff1f"};
+template<>
+FcharData<4> Inputs<4>::s3{
+    U"\u4f60\u597d\uff0c\u6211\u66df F18 ! \u4f60\u5462\uff1f"};
+
+// Test simple assignment
+extern "C" {
+// Declare Fortran subroutine to be tested
+//
+// SUBROUTINE assignK(s1, s2)
+//   CHARACTER(*, K) :: s1, s2
+//   s1 = s2
+// END SUBROUTINE
+void assign1(Fchar, Fchar);
+void assign2(Fchar, Fchar);
+void assign4(Fchar, Fchar);
+}
+
+template<int Kind, typename Func>
+void TestNormalAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s1};
+  auto &s2{Inputs<Kind>::s2};
+  auto &s3{Inputs<Kind>::s3};
+
+  assert(s1.len == s2.len && s1.len < s3.len &&
+      "Test requires len(s1) = len(s2) < len(s3)");
+  const std::string &desc{"normal character assignment"};
+
+  // s1 = s2 ! len(s1) == len(s3)
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, /* expect*/ s2, s2, /*expect*/ s2)) {
+    passed++;
+  }
+
+  // s1 = s3 ! len(s1) < len(s3)
+  FcharData<Kind> s3Tos1{s3.data.substr(0, s1.len)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, /* expect*/ s3Tos1, s3, s3)) {
+    passed++;
+  }
+
+  // s3 = s1 ! len(s1) < len(s3)
+  using ST = typename CharStorage<Kind>::Type;
+  FcharData<Kind> s1Tos3{
+      s1.data.substr(0, s1.len) + ST(s3.len - s1.len, /* space */ 0x20)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s3, /* expect*/ s1Tos3, s1, s1)) {
+    passed++;
+  }
+}
+
+// Test substring assignment
+extern "C" {
+// SUBROUTINE assign_substringK(s1, s2, lb, ub)
+//   CHARACTER(*, K) :: s1, s2
+//   INTEGER :: lb, ub
+//   s1(lb:ub) = s2
+// END SUBROUTINE
+void assign_substring1(Fchar s1, Fchar s2, int *lb, int *ub);
+void assign_substring2(Fchar, Fchar, int *, int *);
+void assign_substring4(Fchar, Fchar, int *, int *);
+}
+
+template<int Kind, typename Func>
+void TestSubstringAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s3};
+  auto &s2{Inputs<Kind>::s1};
+  int lb{3};
+  int ub{14};
+  assert(1 <= lb && lb < ub && ub <= s1.len && "Failed test requirements");
+  const std::string &desc{"substring character assignment"};
+
+  // s1(lb:ub) = s2
+  auto delta{ub - lb + 1};
+  auto s2CpyLen{s2.len < delta ? s2.len : delta};
+  auto str{s1.data.substr(0, lb - 1) + s2.data.substr(0, s2CpyLen)};
+  if (auto padding{delta - s2.len}; padding >= 0) {
+    using ST = typename CharStorage<Kind>::Type;
+    str += ST(padding, /* space */ 0x20);
+  }
+  FcharData<Kind> expected{str + s1.data.substr(ub, s1.len - ub)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, expected, s2, s2, &lb, &ub)) {
+    passed++;
+  }
+}
+
+// Test when RHS depends on LHS in a way that require a temp to evaluate RHS
+extern "C" {
+// SUBROUTINE assign_overlapK(s1, s2, lb)
+//   CHARACTER(*, K) :: s1, s2
+//   INTEGER :: lb
+//   s1(lb:) = s2
+// END SUBROUTINE
+void assign_overlap1(Fchar s1, Fchar s2, int *lb);
+void assign_overlap2(Fchar, Fchar, int *);
+void assign_overlap4(Fchar, Fchar, int *);
+}
+
+template<int Kind, typename Func>
+void TestOverlappingAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s1};
+  auto &s2{Inputs<Kind>::s2};
+  int lb{2};
+  assert(lb >= 2 && "Test requires lb>=2");
+  assert(s1.len >= lb && "Test requires len(s1)>=lb");
+  const std::string &desc{"overlapping character assignment"};
+
+  // s1(lb:) = s1 ! len(s1) >= lb
+  auto delta{lb - 1};
+  FcharData<Kind> expected{
+      s1.data.substr(0, delta) + s1.data.substr(0, s1.len - delta)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, expected, s2, s2, &lb)) {
+    passed++;
+  }
+}
+
+// Test assignment of character whose length is specified in specification
+// expression.
+extern "C" {
+// SUBROUTINE assign_spec_expr_lenK(s1, s2, l1, l2)
+//   INTEGER :: l1, l2
+//   CHARACTER(l1, K) :: s1
+//   CHARACTER(l2, K) :: s2
+//   s1 = s2
+// END SUBROUTINE
+void assign_spec_expr_len1(Fchar s1, Fchar s2, int *l1, int *l2);
+void assign_spec_expr_len2(Fchar s1, Fchar s2, int *l1, int *l2);
+void assign_spec_expr_len4(Fchar s1, Fchar s2, int *l1, int *l2);
+}
+
+template<int Kind, typename Func>
+void TestSpecExprLenAssignement(Func testedSub, int &tests, int &passed) {
+  auto &s1{Inputs<Kind>::s1};
+  auto &s2{Inputs<Kind>::s2};
+  auto &s3{Inputs<Kind>::s3};
+
+  int l1{static_cast<int>(s1.len / 2)};
+  int l2{static_cast<int>(s2.len / 2)};
+  int l3{static_cast<int>(s3.len / 2)};
+  assert(l1 == l2 && l1 < l3 && "Test requires l1 = l2 < l3");
+  const std::string &desc{"assignment of character with specified expr length"};
+
+  // s1 = s2 ! l1 == l3
+  tests++;
+  FcharData<Kind> expect1{
+      s2.data.substr(0, l1) + s1.data.substr(l1, s1.len - l1)};
+  if (TestSubroutine(desc, testedSub, s1, expect1, s2, s2, &l1, &l2)) {
+    passed++;
+  }
+
+  // s1 = s3 ! l1 < l3
+  FcharData<Kind> expect2{
+      s3.data.substr(0, l1) + s1.data.substr(l1, s1.len - l1)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s1, expect2, s3, s3, &l1, &l3)) {
+    passed++;
+  }
+
+  // s3 = s1 ! l1 < l3
+  using ST = typename CharStorage<Kind>::Type;
+  FcharData<Kind> expect3{s1.data.substr(0, l1) +
+      ST(l3 - l1, /* space */ 0x20) + s3.data.substr(l3, s3.len - l3)};
+  tests++;
+  if (TestSubroutine(desc, testedSub, s3, expect3, s1, s1, &l3, &l1)) {
+    passed++;
+  }
+}
+
+int main(int, char **) {
+  int tests{0}, passed{0};
+
+  TestNormalAssignement<1>(assign1, tests, passed);
+  TestNormalAssignement<2>(assign2, tests, passed);
+  TestNormalAssignement<4>(assign4, tests, passed);
+
+  TestSubstringAssignement<1>(assign_substring1, tests, passed);
+  TestSubstringAssignement<2>(assign_substring2, tests, passed);
+  TestSubstringAssignement<4>(assign_substring4, tests, passed);
+
+  TestOverlappingAssignement<1>(assign_overlap1, tests, passed);
+  TestOverlappingAssignement<2>(assign_overlap2, tests, passed);
+  TestOverlappingAssignement<4>(assign_overlap4, tests, passed);
+
+  TestSpecExprLenAssignement<1>(assign_spec_expr_len1, tests, passed);
+  TestSpecExprLenAssignement<2>(assign_spec_expr_len2, tests, passed);
+  TestSpecExprLenAssignement<4>(assign_spec_expr_len4, tests, passed);
+
+  std::cout << passed << " tests passed out of " << tests << std::endl;
+  return tests == passed ? 0 : -1;
+}
diff --git a/not-test/lower/test_character_assignment.sh b/not-test/lower/test_character_assignment.sh
new file mode 100755
index 000000000000..c16177a3c5ee
--- /dev/null
+++ b/not-test/lower/test_character_assignment.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Test Fortran character assignment/expression lowering by driving compilation
+# and executions of Fortran and C++ source codes.
+#
+# Usage: cmd bbc llc
+# To keep generated files, run `export KEEP=TRUE` before the test call.
+
+BBC=$1
+LLC=$2
+CPP=g++
+CPP_SRC=$PWD/test-character-assignment.cc
+F_SRC=$PWD/character-assignment.f90
+
+function die {
+  echo "$(basename $0): $*" >&2
+  exit 1
+}
+
+temp=`mktemp -d ./tmp.XXXXXX`
+cd $temp
+[[ $KEEP ]] || trap "cd .. && rm -rf $temp" EXIT
+
+bbcLog=bbc.log
+assembly=a.s
+testObject=test.o
+testExec=./test_exec
+testLog=test.log
+llFile=a.mlir.ll
+$BBC -emit-llvm -disable-fir2std $F_SRC 2>$bbcLog
+[[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
+sed -i 's/_QP//g' -i $llFile
+$LLC $llFile -o $assembly
+[[ $? -ne 0 ]] && die "llc failed compiling bbc output"
+as $assembly -o $testObject
+[[ $? -ne 0 ]] && die "as failed compiling llc output"
+$CPP -std=c++17 $testObject $CPP_SRC -o $testExec
+[[ $? -ne 0 ]] && die "driver.f90 compilation/linking failure"
+$testExec > $testLog
+result=$?
+cat $testLog
+if [ $result -ne 0 ]; then
+  echo "FAIL"
+else
+  echo "PASS"
+fi
diff --git a/not-test/lower/test_expression_lowering.sh b/not-test/lower/test_expression_lowering.sh
new file mode 100755
index 000000000000..d39e5faccf00
--- /dev/null
+++ b/not-test/lower/test_expression_lowering.sh
@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Test Fortran expression lowering by driving compilations
+# and executions of programs generated by expr-test-generation.cc
+#
+# Usage: cmd bbc llc
+# To keep generated files, run `export KEEP=TRUE` before the test call.
+
+BBC=$1
+LLC=$2
+CPP=g++
+FCC=pgfortran # So far, only works with pgfortran because of pgmath linking.
+FCC_OPTIONS="-Kieee" # That is required because bit to bit compare so far.
+SRC=$PWD/expr-test-generator.cc
+
+function die {
+  echo "$(basename $0): $*" >&2
+  exit 1
+}
+
+temp=`mktemp -d ./tmp.XXXXXX`
+cd $temp
+[[ $KEEP ]] || trap "cd .. && rm -rf $temp" EXIT
+
+testGen=./genTests
+testFile=test.f90
+driverFile=driver.f90
+bbcLog=bbc.log
+assembly=a.s
+testObject=test.o
+testExec=./test_exec
+testLog=test.log
+llFile=a.mlir.ll
+
+$CPP $SRC -std=c++17 -o $testGen
+[[ $? -ne 0 ]] && die "test generator compilation failure"
+$testGen 1>$testFile 2>$driverFile
+[[ $? -ne 0 ]] && die "test generation failure"
+$BBC -disable-fir2std -emit-llvm $testFile 2>$bbcLog
+[[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
+# FIR internal mangling -> pgfortran mangling (until done by FIR lowering)
+sed -i 's,_QP\([[:alnum:]_]*\),\1_,g' $llFile
+$LLC $llFile -o $assembly
+[[ $? -ne 0 ]] && die "llc failed compiling bbc output"
+as $assembly -o $testObject
+[[ $? -ne 0 ]] && die "as failed compiling llc output"
+$FCC $testObject $driverFile -o $testExec $FCC_OPTIONS
+[[ $? -ne 0 ]] && die "driver.f90 compilation/linking failure"
+$testExec > $testLog
+result=$?
+cat $testLog
+if [ $result -ne 0 ]; then
+  echo "FAIL"
+else
+  echo "PASS"
+fi

From e4aa6ac3d7dc0be515d46c1ccef957ae7280b03e Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 18 Mar 2020 16:14:53 -0700
Subject: [PATCH 251/345] fix for change in io-api.h

---
 lib/Lower/IO.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index fefc7781dde1..5f74e74877b9 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -55,7 +55,7 @@ static constexpr std::tuple<
     mkIOKey(SetRec), mkIOKey(SetRound), mkIOKey(SetSign),
     mkIOKey(OutputDescriptor), mkIOKey(InputDescriptor),
     mkIOKey(OutputUnformattedBlock), mkIOKey(InputUnformattedBlock),
-    mkIOKey(OutputInteger64), mkIOKey(InputInteger64), mkIOKey(OutputReal32),
+    mkIOKey(OutputInteger64), mkIOKey(InputInteger), mkIOKey(OutputReal32),
     mkIOKey(InputReal32), mkIOKey(OutputReal64), mkIOKey(InputReal64),
     mkIOKey(OutputComplex64), mkIOKey(OutputComplex32), mkIOKey(OutputAscii),
     mkIOKey(InputAscii), mkIOKey(OutputLogical), mkIOKey(InputLogical),

From 1b873d03822d180beab9a5c985bb0333d8920550 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 18 Mar 2020 17:20:48 -0700
Subject: [PATCH 252/345] re-enable check-flang as a valid make target

---
 CMakeLists.txt      | 9 ++-------
 test/CMakeLists.txt | 1 -
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d0715e9797d4..daff4c139368 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -315,13 +315,8 @@ add_subdirectory(runtime)
 option(FLANG_INCLUDE_TESTS
        "Generate build targets for the Flang unit tests."
        ${LLVM_INCLUDE_TESTS})
-if (FLANG_INCLUDE_TESTS)
-  enable_testing()
-  add_subdirectory(test)
-else()
-  enable_testing()
-  add_subdirectory(test)
-endif()
+enable_testing()
+add_subdirectory(test)
 
 # TODO: Add doxygen support.
 #option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3e22d9f18c82..b4ee48f992b9 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -37,4 +37,3 @@ set_target_properties(check-flang PROPERTIES FOLDER "Tests")
 add_lit_testsuites(FLANG ${CMAKE_CURRENT_SOURCE_DIR}
   PARAMS ${FLANG_TEST_PARAMS}
   DEPENDS ${FLANG_TEST_DEPENDS})
-

From 7680ddd8a6708d07f95e856611377ba1e2e1e302 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Thu, 19 Mar 2020 09:09:55 -0700
Subject: [PATCH 253/345] remove caching fix macos bugs

---
 .../flang/Optimizer/Support/InternalNames.h   |  8 +-
 lib/Optimizer/Support/InternalNames.cpp       | 83 ++++++++++---------
 2 files changed, 47 insertions(+), 44 deletions(-)

diff --git a/include/flang/Optimizer/Support/InternalNames.h b/include/flang/Optimizer/Support/InternalNames.h
index 3dba562e9abf..d9d204ffb93a 100644
--- a/include/flang/Optimizer/Support/InternalNames.h
+++ b/include/flang/Optimizer/Support/InternalNames.h
@@ -11,7 +11,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringRef.h"
 #include <cstdint>
 
 namespace llvm {
@@ -117,12 +117,10 @@ struct NameUniquer {
   deconstruct(llvm::StringRef uniquedName);
 
 private:
-  llvm::StringRef addAsString(std::int64_t i);
+  std::string intAsString(std::int64_t i);
   std::string doKind(std::int64_t kind);
   std::string doKinds(llvm::ArrayRef<std::int64_t> kinds);
-  llvm::StringRef toLower(llvm::StringRef name);
-
-  llvm::StringSet<> cache;
+  std::string toLower(llvm::StringRef name);
 };
 
 } // namespace fir
diff --git a/lib/Optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
index e8b818cb27ef..58ebb278a67e 100644
--- a/lib/Optimizer/Support/InternalNames.cpp
+++ b/lib/Optimizer/Support/InternalNames.cpp
@@ -9,28 +9,27 @@
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/Twine.h"
 
 constexpr std::int64_t BAD_VALUE = -1;
 
-inline llvm::StringRef prefix() { return "_Q"; }
+inline std::string prefix() { return "_Q"; }
 
 static std::string doModules(llvm::ArrayRef<llvm::StringRef> mods) {
-  llvm::Twine result;
+  std::string result;
   auto *token = "M";
   for (auto mod : mods) {
-    result.concat(token).concat(mod);
+    result.append(token).append(mod);
     token = "S";
   }
-  return result.str();
+  return result;
 }
 
 static std::string doModulesHost(llvm::ArrayRef<llvm::StringRef> mods,
                                  llvm::Optional<llvm::StringRef> host) {
-  llvm::Twine result(doModules(mods));
+  std::string result = doModules(mods);
   if (host.hasValue())
-    result.concat("F").concat(*host);
-  return result.str();
+    result.append("F").append(*host);
+  return result;
 }
 
 inline llvm::SmallVector<llvm::StringRef, 2>
@@ -65,40 +64,39 @@ static std::int64_t readInt(llvm::StringRef uniq, std::size_t &i,
   return result;
 }
 
-llvm::StringRef fir::NameUniquer::toLower(llvm::StringRef name) {
-  auto lo = name.lower();
-  if (name.equals(lo))
-    return name;
-  return cache.insert(lo).first->getKey();
+std::string fir::NameUniquer::toLower(llvm::StringRef name) {
+  return name.lower();
 }
 
-llvm::StringRef fir::NameUniquer::addAsString(std::int64_t i) {
-  return cache.insert(std::to_string(i)).first->getKey();
+std::string fir::NameUniquer::intAsString(std::int64_t i) {
+  assert(i >= 0);
+  return std::to_string(i);
 }
 
 std::string fir::NameUniquer::doKind(std::int64_t kind) {
-  llvm::Twine result("K");
+  std::string result = "K";
   if (kind < 0)
-    return result.concat("N").concat(addAsString(-kind)).str();
-  return result.concat(addAsString(kind)).str();
+    return result.append("N").append(intAsString(-kind));
+  return result.append(intAsString(kind));
 }
 
 std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
-  llvm::Twine result;
+  std::string result;
   for (auto i : kinds)
-    result.concat(doKind(i));
-  return result.str();
+    result.append(doKind(i));
+  return result;
 }
 
 std::string fir::NameUniquer::doCommonBlock(llvm::StringRef name) {
-  return llvm::Twine(prefix()).concat("B").concat(toLower(name)).str();
+  std::string result = prefix();
+  return result.append("B").append(toLower(name));
 }
 
 std::string
 fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                              llvm::StringRef name) {
-  auto result = llvm::Twine(prefix()) + doModules(modules) + "EC";
-  return result.concat(toLower(name)).str();
+  std::string result = prefix();
+  return result.append(doModules(modules)).append("EC").append(toLower(name));
 }
 
 std::string
@@ -106,20 +104,21 @@ fir::NameUniquer::doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
                                   llvm::Optional<llvm::StringRef> host,
                                   llvm::StringRef name,
                                   llvm::ArrayRef<std::int64_t> kinds) {
-  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "DT";
-  return result.concat(toLower(name)).concat(doKinds(kinds)).str();
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("DT");
+  return result.append(toLower(name)).append(doKinds(kinds));
 }
 
 std::string fir::NameUniquer::doGenerated(llvm::StringRef name) {
-  auto result = llvm::Twine(prefix()) + "Q" + toLower(name);
-  return result.str();
+  std::string result = prefix();
+  return result.append("Q").append(toLower(name));
 }
 
 std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
     llvm::ArrayRef<llvm::StringRef> modules,
     llvm::Optional<llvm::StringRef> host, IntrinsicType type,
     std::int64_t kind) {
-  const char *name{nullptr};
+  const char *name = nullptr;
   switch (type) {
   case IntrinsicType::CHARACTER:
     name = "character";
@@ -137,24 +136,28 @@ std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
     name = "real";
     break;
   }
-  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "C";
-  return result.concat(name).concat(doKind(kind)).str();
+  assert(name && "unknown intrinsic type");
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("C");
+  return result.append(name).append(doKind(kind));
 }
 
 std::string
 fir::NameUniquer::doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
                               llvm::Optional<llvm::StringRef> host,
                               llvm::StringRef name) {
-  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "P";
-  return result.concat(toLower(name)).str();
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("P");
+  return result.append(toLower(name));
 }
 
 std::string fir::NameUniquer::doType(llvm::ArrayRef<llvm::StringRef> modules,
                                      llvm::Optional<llvm::StringRef> host,
                                      llvm::StringRef name,
                                      llvm::ArrayRef<std::int64_t> kinds) {
-  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "T";
-  return result.concat(toLower(name)).concat(doKinds(kinds)).str();
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("T");
+  return result.append(toLower(name)).append(doKinds(kinds));
 }
 
 std::string
@@ -162,8 +165,9 @@ fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                                    llvm::Optional<llvm::StringRef> host,
                                    llvm::StringRef name,
                                    llvm::ArrayRef<std::int64_t> kinds) {
-  auto result = llvm::Twine(prefix()) + doModulesHost(modules, host) + "CT";
-  return result.concat(toLower(name)).concat(doKinds(kinds)).str();
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("CT");
+  return result.append(toLower(name)).append(doKinds(kinds));
 }
 
 std::string fir::NameUniquer::doTypeDescriptor(
@@ -177,8 +181,9 @@ std::string fir::NameUniquer::doTypeDescriptor(
 std::string
 fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                              llvm::StringRef name) {
-  auto result = llvm::Twine(prefix()) + doModules(modules) + "E";
-  return result.concat(toLower(name)).str();
+  std::string result = prefix();
+  result.append(doModules(modules)).append("E");
+  return result.append(toLower(name));
 }
 
 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>

From b86eb15360a3def16f51bb62189ac28ce13b9ea0 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Thu, 19 Mar 2020 11:30:42 -0700
Subject: [PATCH 254/345] add linkage and simple initial value support to
 GlobalOp builders, parser, pretty-printer...

add linkage to Tilikum

add tests for linkage
---
 include/flang/Optimizer/Dialect/FIROps.td | 101 ++++++++-----------
 lib/Optimizer/CodeGen.cpp                 |  23 ++++-
 lib/Optimizer/Dialect/FIROps.cpp          | 113 ++++++++++++++++++++++
 test/Fir/global.fir                       |   9 ++
 4 files changed, 182 insertions(+), 64 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index c5c9dc21c7be..cee7dcb84425 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2615,69 +2615,29 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
 
   let arguments = (ins
     StrAttr:$sym_name,
-    OptionalAttr<AnyAttr>:$initval,
-    UnitAttr:$constant,
-    TypeAttr:$type
+    TypeAttr:$type,
+    OptionalAttr<AnyAttr>:$initVal,
+    OptionalAttr<UnitAttr>:$constant,
+    OptionalAttr<StrAttr>:$linkName
   );
 
   let results = (outs fir_ReferenceType:$resultType);
 
   let regions = (region AtMostRegion<1>:$region);
 
-  let parser = [{
-    // Parse the name as a symbol reference attribute.
-    SymbolRefAttr nameAttr;
-    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
-                              result.attributes))
-      return failure();
-
-    auto &builder = parser.getBuilder();
-    auto name = nameAttr.getRootReference();
-    result.attributes.back().second = builder.getStringAttr(name);
-
-    bool simpleInitializer = false;
-    if (mlir::succeeded(parser.parseOptionalLParen())) {
-      Attribute attr;
-      if (parser.parseAttribute(attr, initValAttrName(), result.attributes) ||
-          parser.parseRParen())
-        return failure();
-      simpleInitializer = true;
-    }
-
-    if (succeeded(parser.parseOptionalKeyword(constantAttrName()))) {
-      // if "constant" keyword then mark this as a constant, not a variable
-      result.addAttribute(constantAttrName(), builder.getUnitAttr());
-    }
-
-    mlir::Type globalType;
-    if (parser.parseColonType(globalType))
-      return failure();
-
-    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(globalType));
-
-    if (!simpleInitializer) {
-      // Parse the optional initializer body.
-      if (parser.parseRegion(*result.addRegion(), llvm::None, llvm::None))
-        return failure();
-    }
-
-    auto refTy = AllocaOp::wrapResultType(globalType);
-    if (parser.addTypeToList(refTy, result.types))
-      return failure();
-    return success();
-  }];
+  let parser = "return parseGlobalOp(parser, result);";
 
   let printer = [{
+    p << getOperationName();
+    if (linkName().hasValue())
+      p << ' ' << linkName().getValue();
     auto varName = getAttrOfType<StringAttr>(
       mlir::SymbolTable::getSymbolAttrName()).getValue();
-    p << getOperationName() << " @" << varName;
-    if (auto iv = initval().getValueOr(Attribute())) {
-      p << '(';
-      p.printAttribute(iv);
-      p << ')';
-    }
+    p << " @" << varName;
+    if (auto val = getValueOrNull())
+      p << '(' << val << ')';
     if (getAttr(constantAttrName()))
-      p << ' ' << constantAttrName();
+      p << " constant";
     p << " : ";
     p.printType(getType());
     Region &body = getOperation()->getRegion(0);
@@ -2689,23 +2649,41 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
-              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
-    [{
-      result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
-      result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
-                          builder->getStringAttr(name));
-      result.addAttributes(attrs);
-    }]>
+              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, bool isConstant, Type type,"
+	      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, Type type, StringAttr linkage = {},"
+	      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, bool isConstant, Type type,"
+	      "StringAttr linkage = {},"
+	      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, Type type, Attribute initVal,"
+	      "StringAttr linkage = {},"
+	      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, bool isConstant, Type type,"
+	      "Attribute initVal, StringAttr linkage = {},"
+	      "ArrayRef<NamedAttribute> attrs = {}">,
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef constantAttrName() { return "constant"; }
-    static constexpr llvm::StringRef initValAttrName() { return "initval"; }
+    static constexpr llvm::StringRef initValAttrName() { return "initVal"; }
+    static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
     static constexpr llvm::StringRef typeAttrName() { return "type"; }
 
     mlir::Type getType() {
       return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
+    
+    /// Return the initializer attribute if it exists, or a null attribute.
+    Attribute getValueOrNull() {
+      return initVal().getValueOr(Attribute());
+    }
 
     /// Append the next initializer value to the `GlobalOp` to construct
     /// the variable's initial value.
@@ -2716,6 +2694,9 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
 
     /// A GlobalOp has one block.
     mlir::Block &getBlock() { return getRegion().front(); }
+
+    /// Determine if `linkage` is a supported keyword
+    static mlir::ParseResult verifyValidLinkage(StringRef linkage);
   }];
 }
 
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index a15a072dda8a..8512d88cfbfb 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -1453,16 +1453,31 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
     auto tyAttr = unwrap(convertType(global.getType()));
     auto loc = global.getLoc();
     mlir::Attribute initAttr{};
-    if (global.initval())
-      initAttr = global.initval().getValue();
+    if (global.initVal())
+      initAttr = global.initVal().getValue();
+    auto linkage = convertLinkage(global.linkName());
+    auto isConst = global.constant().hasValue();
     auto g = rewriter.create<mlir::LLVM::GlobalOp>(
-        loc, tyAttr, global.constant(), mlir::LLVM::Linkage::External,
-        global.sym_name(), initAttr);
+        loc, tyAttr, isConst, linkage, global.sym_name(), initAttr);
     auto &gr = g.getInitializerRegion();
     rewriter.inlineRegionBefore(global.region(), gr, gr.end());
     rewriter.eraseOp(global);
     return matchSuccess();
   }
+
+  mlir::LLVM::Linkage
+  convertLinkage(llvm::Optional<llvm::StringRef> optLinkage) const {
+    if (optLinkage.hasValue()) {
+      auto name = optLinkage.getValue();
+      if (name == "internal")
+        return mlir::LLVM::Linkage::Internal;
+      if (name == "common")
+        return mlir::LLVM::Linkage::Common;
+      if (name == "weak")
+        return mlir::LLVM::Linkage::Weak;
+    }
+    return mlir::LLVM::Linkage::External;
+  }
 };
 
 // convert to LLVM IR dialect `load`
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 88756ecfb43c..5a1883409cd9 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -341,10 +341,123 @@ void fir::GenTypeDescOp::build(Builder *, OperationState &result,
 // GlobalOp
 //===----------------------------------------------------------------------===//
 
+static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
+  // Parse the optional linkage
+  llvm::StringRef linkage;
+  auto &builder = parser.getBuilder();
+  if (mlir::succeeded(parser.parseOptionalKeyword(&linkage))) {
+    if (fir::GlobalOp::verifyValidLinkage(linkage))
+      return failure();
+    mlir::StringAttr linkAttr = builder.getStringAttr(linkage);
+    result.addAttribute(fir::GlobalOp::linkageAttrName(), linkAttr);
+  }
+
+  // Parse the name as a symbol reference attribute.
+  SymbolRefAttr nameAttr;
+  if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
+                            result.attributes))
+    return failure();
+
+  auto name = nameAttr.getRootReference();
+  result.attributes.back().second = builder.getStringAttr(name);
+
+  bool simpleInitializer = false;
+  if (mlir::succeeded(parser.parseOptionalLParen())) {
+    Attribute attr;
+    if (parser.parseAttribute(attr, fir::GlobalOp::initValAttrName(),
+                              result.attributes) ||
+        parser.parseRParen())
+      return failure();
+    simpleInitializer = true;
+  }
+
+  if (succeeded(parser.parseOptionalKeyword("constant"))) {
+    // if "constant" keyword then mark this as a constant, not a variable
+    result.addAttribute(fir::GlobalOp::constantAttrName(),
+                        builder.getUnitAttr());
+  }
+
+  mlir::Type globalType;
+  if (parser.parseColonType(globalType))
+    return failure();
+
+  result.addAttribute(fir::GlobalOp::typeAttrName(),
+                      mlir::TypeAttr::get(globalType));
+
+  if (simpleInitializer) {
+    result.addRegion();
+  } else {
+    // Parse the optional initializer body.
+    if (parser.parseRegion(*result.addRegion(), llvm::None, llvm::None))
+      return failure();
+  }
+
+  auto refTy = AllocaOp::wrapResultType(globalType);
+  if (parser.addTypeToList(refTy, result.types))
+    return failure();
+  return success();
+}
+
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
 
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, bool isConstant, Type type,
+                          Attribute initialVal, StringAttr linkage,
+                          ArrayRef<NamedAttribute> attrs) {
+  result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
+  result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                      builder->getStringAttr(name));
+  if (isConstant)
+    result.addAttribute(constantAttrName(), builder->getUnitAttr());
+  if (initialVal)
+    result.addAttribute(initValAttrName(), initialVal);
+  if (linkage)
+    result.addAttribute(linkageAttrName(), linkage);
+  result.attributes.append(attrs.begin(), attrs.end());
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, Type type, Attribute initialVal,
+                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, bool isConstant, Type type,
+                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, isConstant, type, {}, linkage, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, Type type, StringAttr linkage,
+                          ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, bool isConstant, Type type,
+                          ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, isConstant, type, StringAttr{}, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, Type type,
+                          ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, /*isConstant=*/false, type, attrs);
+}
+
+mlir::ParseResult fir::GlobalOp::verifyValidLinkage(StringRef linkage) {
+  // Supporting only a subset of the LLVM linkage types for now
+  static const llvm::SmallVector<const char *, 3> validNames = {
+      "internal", "common", "weak"};
+  if (llvm::any_of(validNames,
+                   [&](const char *name) { return linkage == name; }))
+    return success();
+  return failure();
+}
+
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
diff --git a/test/Fir/global.fir b/test/Fir/global.fir
index a2a2a04ce25d..d04ca50a820f 100644
--- a/test/Fir/global.fir
+++ b/test/Fir/global.fir
@@ -17,3 +17,12 @@ fir.global @g_ci5 constant : i32 {
   %c = constant 5 : i32
   fir.has_value %c : i32
 }
+
+// CHECK: @i_i515 = internal global i32 515
+fir.global internal @i_i515 (515:i32) : i32
+
+// CHECK: @C_i511 = common global i32 511
+fir.global common @C_i511 (511:i32) : i32
+
+// CHECK: @w_i86 = weak global i32 86
+fir.global weak @w_i86 (86:i32) : i32

From f6c7c4de67980f1591e2945d681386c4ac890a67 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 20 Mar 2020 11:26:00 -0700
Subject: [PATCH 255/345] [mlir rebase] changes to build along LLVM head 20th
 march 2020

4 MLIR changes had impact on FIR:

- https://github.com/llvm/llvm-project/commit/0ddba0bd59c337f16b51a00cb205ecfda46f97fa
`hasNoSideEffect` and `MemoryEffectOpInterface` seems to be functionnaly different, for instance
after changing only this, `return` were optimized out in the CSE pass.
Following the mlir commit example, it turned out `isOpTriviallyDead` now also has to be used
instead of `op->use_empty()` to remediate this.

- https://github.com/llvm/llvm-project/commit/7ca473a27bd589457d427eee9187d49a88fc9b01
MLIR cmake changes (Now we could use an out-of-tree MLIR also)

- https://github.com/llvm/llvm-project/commit/4d60f47b082f20d93f621fb5cd4bb978c26b7bf1
VectorOpsDialect renamed to VectorOp.

- https://github.com/llvm/llvm-project/commit/3145427dd73f0ee16dac4044890e2e2d2cae5040
Replace all usages of PatternMatchResult with LogicalResult.

Tested with https://github.com/llvm/llvm-project/commit/ece6cf0fa56687d4f9fd918a7dc367cd1277d0c4.
---
 CMakeLists.txt                               |   7 +-
 include/flang/Optimizer/Dialect/FIRDialect.h |   2 +-
 lib/Optimizer/CodeGen.cpp                    | 250 +++++++++----------
 lib/Optimizer/StdConverter.cpp               |   4 +-
 lib/Optimizer/Transforms/CSE.cpp             |   6 +-
 lib/Optimizer/Transforms/RewriteLoop.cpp     |  12 +-
 6 files changed, 144 insertions(+), 137 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index daff4c139368..7d0a222c03d0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -49,10 +49,13 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
     mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
   endif()
 
-  # We need a pre-built/installed version of LLVM.
+  # We need a pre-built/installed version of LLVM and MLIR.
   find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
   list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
 
+  find_package(MLIR REQUIRED HINTS "${MLIR_CMAKE_PATH}")
+  list(APPEND CMAKE_MODULE_PATH ${MLIR_DIR})
+
   # If LLVM links to zlib we need the imported targets so we can too.
   if(LLVM_ENABLE_ZLIB)
     find_package(ZLIB REQUIRED)
@@ -85,6 +88,8 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   # should not be suppressed).
   include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
   add_definitions(${LLVM_DEFINITIONS})
+  include_directories(SYSTEM ${MLIR_INCLUDE_DIRS})
+  add_definitions(${MLIR_DEFINITIONS})
 
   # LLVM's cmake configuration files currently sneak in a c++11 flag.
   # We look for it here and remove it from Flang's compile flags to 
diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
index 4818a7100b9c..31ca29536244 100644
--- a/include/flang/Optimizer/Dialect/FIRDialect.h
+++ b/include/flang/Optimizer/Dialect/FIRDialect.h
@@ -54,7 +54,7 @@ inline void registerFIR() {
     mlir::registerDialect<mlir::LLVM::LLVMDialect>();
     mlir::registerDialect<mlir::loop::LoopOpsDialect>();
     mlir::registerDialect<mlir::StandardOpsDialect>();
-    mlir::registerDialect<mlir::vector::VectorOpsDialect>();
+    mlir::registerDialect<mlir::vector::VectorDialect>();
     mlir::registerDialect<FIROpsDialect>();
     return true;
   }();
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 8512d88cfbfb..c442778cab18 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -409,14 +409,14 @@ void createGlobal(mlir::Location loc, mlir::ModuleOp mod, StringRef name,
 struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::AddrOfOp addr, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = unwrap(convertType(addr.getType()));
     auto attrs = pruneNamedAttrDict(addr.getAttrs(), {"symbol"});
     rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(
         addr, ty, addr.symbol().getRootReference(), attrs);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -431,7 +431,7 @@ genConstantIndex(mlir::Location loc, mlir::LLVM::LLVMType ity,
 struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::AllocaOp alloc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto loc = alloc.getLoc();
@@ -443,7 +443,7 @@ struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
     auto ty = convertType(alloc.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::AllocaOp>(alloc, ty, size,
                                                       alloc.getAttrs());
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -466,7 +466,7 @@ mlir::LLVM::LLVMFuncOp getMalloc(fir::AllocMemOp op,
 struct AllocMemOpConversion : public FIROpConversion<fir::AllocMemOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::AllocMemOp heap, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(heap.getType());
@@ -482,7 +482,7 @@ struct AllocMemOpConversion : public FIROpConversion<fir::AllocMemOp> {
     SmallVector<mlir::Value, 1> args{size};
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(heap, ty, args,
                                                     heap.getAttrs());
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -505,7 +505,7 @@ mlir::LLVM::LLVMFuncOp getFree(fir::FreeMemOp op,
 struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::FreeMemOp freemem, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto dialect = getDialect();
@@ -516,7 +516,7 @@ struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
         freemem, mlir::LLVM::LLVMType::getVoidTy(dialect),
         SmallVector<mlir::Value, 1>{bitcast}, freemem.getAttrs());
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -532,7 +532,7 @@ mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::LLVM::LLVMType ty,
 struct BoxAddrOpConversion : public FIROpConversion<fir::BoxAddrOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxAddrOp boxaddr, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -550,7 +550,7 @@ struct BoxAddrOpConversion : public FIROpConversion<fir::BoxAddrOp> {
       rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxaddr, ty, a,
                                                               c0);
     }
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -558,7 +558,7 @@ struct BoxAddrOpConversion : public FIROpConversion<fir::BoxAddrOp> {
 struct BoxCharLenOpConversion : public FIROpConversion<fir::BoxCharLenOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxCharLenOp boxchar, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -566,7 +566,7 @@ struct BoxCharLenOpConversion : public FIROpConversion<fir::BoxCharLenOp> {
     auto ctx = boxchar.getContext();
     auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxchar, ty, a, c1);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -574,7 +574,7 @@ struct BoxCharLenOpConversion : public FIROpConversion<fir::BoxCharLenOp> {
 struct BoxDimsOpConversion : public FIROpConversion<fir::BoxDimsOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxDimsOp boxdims, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -587,7 +587,7 @@ struct BoxDimsOpConversion : public FIROpConversion<fir::BoxDimsOp> {
     auto l2 = loadFromOffset(boxdims, loc, a, c0, c7, dim, 2, rewriter);
     rewriter.replaceOp(boxdims,
                        {l0.getResult(), l1.getResult(), l2.getResult()});
-    return matchSuccess();
+    return success();
   }
 
   mlir::LLVM::LoadOp
@@ -606,7 +606,7 @@ struct BoxDimsOpConversion : public FIROpConversion<fir::BoxDimsOp> {
 struct BoxEleSizeOpConversion : public FIROpConversion<fir::BoxEleSizeOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxEleSizeOp boxelesz, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -616,14 +616,14 @@ struct BoxEleSizeOpConversion : public FIROpConversion<fir::BoxEleSizeOp> {
     auto ty = convertType(boxelesz.getType());
     auto p = genGEP(loc, unwrap(ty), rewriter, a, c0, c1);
     rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(boxelesz, ty, p);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct BoxIsAllocOpConversion : public FIROpConversion<fir::BoxIsAllocOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxIsAllocOp boxisalloc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -638,14 +638,14 @@ struct BoxIsAllocOpConversion : public FIROpConversion<fir::BoxIsAllocOp> {
     auto bit = rewriter.create<mlir::LLVM::AndOp>(loc, ity, ld, ab);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
         boxisalloc, mlir::LLVM::ICmpPredicate::ne, bit, c0);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct BoxIsArrayOpConversion : public FIROpConversion<fir::BoxIsArrayOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxIsArrayOp boxisarray, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -657,14 +657,14 @@ struct BoxIsArrayOpConversion : public FIROpConversion<fir::BoxIsArrayOp> {
     auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
         boxisarray, mlir::LLVM::ICmpPredicate::ne, ld, c0);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct BoxIsPtrOpConversion : public FIROpConversion<fir::BoxIsPtrOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxIsPtrOp boxisptr, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -680,14 +680,14 @@ struct BoxIsPtrOpConversion : public FIROpConversion<fir::BoxIsPtrOp> {
     auto bit = rewriter.create<mlir::LLVM::AndOp>(loc, ity, ld, ab);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
         boxisptr, mlir::LLVM::ICmpPredicate::ne, bit, c0);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct BoxProcHostOpConversion : public FIROpConversion<fir::BoxProcHostOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxProcHostOp boxprochost, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -696,14 +696,14 @@ struct BoxProcHostOpConversion : public FIROpConversion<fir::BoxProcHostOp> {
     auto c1 = mlir::ArrayAttr::get(rewriter.getI32IntegerAttr(1), ctx);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxprochost, ty, a,
                                                             c1);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct BoxRankOpConversion : public FIROpConversion<fir::BoxRankOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxRankOp boxrank, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -715,14 +715,14 @@ struct BoxRankOpConversion : public FIROpConversion<fir::BoxRankOp> {
     auto pty = unwrap(ty).getPointerTo();
     auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, pty, args);
     rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(boxrank, ty, p);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct BoxTypeDescOpConversion : public FIROpConversion<fir::BoxTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::BoxTypeDescOp boxtypedesc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -736,14 +736,14 @@ struct BoxTypeDescOpConversion : public FIROpConversion<fir::BoxTypeDescOp> {
     auto ld = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
     auto i8ptr = mlir::LLVM::LLVMType::getInt8PtrTy(getDialect());
     rewriter.replaceOpWithNewOp<mlir::LLVM::IntToPtrOp>(boxtypedesc, i8ptr, ld);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct StringLitOpConversion : public FIROpConversion<fir::StringLitOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::StringLitOp constop, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(constop.getType());
@@ -767,7 +767,7 @@ struct StringLitOpConversion : public FIROpConversion<fir::StringLitOp> {
       auto dea = mlir::DenseElementsAttr::get(det, vec);
       rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, dea);
     }
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -775,7 +775,7 @@ struct StringLitOpConversion : public FIROpConversion<fir::StringLitOp> {
 struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::CallOp call, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     SmallVector<mlir::Type, 4> resultTys;
@@ -783,7 +783,7 @@ struct CallOpConversion : public FIROpConversion<fir::CallOp> {
       resultTys.push_back(convertType(r.getType()));
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(call, resultTys, operands,
                                                     call.getAttrs());
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -795,7 +795,7 @@ struct CallOpConversion : public FIROpConversion<fir::CallOp> {
 struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::CmpcOp cmp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ctxt = cmp.getContext();
@@ -826,27 +826,27 @@ struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
       rewriter.replaceOp(cmp, rcp.getResult());
       break;
     }
-    return matchSuccess();
+    return success();
   }
 };
 
 struct CmpfOpConversion : public FIROpConversion<fir::CmpfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::CmpfOp cmp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto type = convertType(cmp.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::FCmpOp>(cmp, type, operands,
                                                     cmp.getAttrs());
-    return matchSuccess();
+    return success();
   }
 };
 
 struct ConstcOpConversion : public FIROpConversion<fir::ConstcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::ConstcOp conc, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto loc = conc.getLoc();
@@ -864,7 +864,7 @@ struct ConstcOpConversion : public FIROpConversion<fir::ConstcOp> {
     auto rr = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r, rp, c0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(conc, ty, rr, ip,
                                                            c1);
-    return matchSuccess();
+    return success();
   }
 
   inline llvm::APFloat getValue(mlir::Attribute attr) const {
@@ -875,13 +875,13 @@ struct ConstcOpConversion : public FIROpConversion<fir::ConstcOp> {
 struct ConstfOpConversion : public FIROpConversion<fir::ConstfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::ConstfOp conf, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(conf.getType());
     auto val = conf.constantAttr();
     rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(conf, ty, val);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -889,7 +889,7 @@ struct ConstfOpConversion : public FIROpConversion<fir::ConstfOp> {
 struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::ConvertOp convert, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto fromTy_ = convertType(convert.value().getType());
@@ -901,7 +901,7 @@ struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
     auto &op0 = operands[0];
     if (fromLLVMTy == toLLVMTy) {
       rewriter.replaceOp(convert, op0);
-      return matchSuccess();
+      return success();
     }
     auto loc = convert.getLoc();
     mlir::Value v;
@@ -943,7 +943,7 @@ struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
       rewriter.replaceOp(convert, v);
     else
       emitError(loc) << "cannot convert " << fromTy_ << " to " << toTy_;
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -951,7 +951,7 @@ struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
 struct DispatchOpConversion : public FIROpConversion<fir::DispatchOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::DispatchOp dispatch, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(dispatch.getFunctionType());
@@ -959,7 +959,7 @@ struct DispatchOpConversion : public FIROpConversion<fir::DispatchOp> {
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(dispatch, ty, operands,
                                                     None);
     TODO(dispatch);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -968,11 +968,11 @@ struct DispatchTableOpConversion
     : public FIROpConversion<fir::DispatchTableOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::DispatchTableOp dispTab, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(dispTab);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -980,11 +980,11 @@ struct DispatchTableOpConversion
 struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::DTEntryOp dtEnt, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(dtEnt);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -992,7 +992,7 @@ struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
 struct EmboxCharOpConversion : public FIROpConversion<fir::EmboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::EmboxCharOp emboxchar, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -1006,7 +1006,7 @@ struct EmboxCharOpConversion : public FIROpConversion<fir::EmboxCharOp> {
     auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, un, a, c0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(emboxchar, ty, r, b,
                                                            c1);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1014,7 +1014,7 @@ struct EmboxCharOpConversion : public FIROpConversion<fir::EmboxCharOp> {
 struct EmboxOpConversion : public FIROpConversion<fir::EmboxOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::EmboxOp embox, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto loc = embox.getLoc();
@@ -1048,7 +1048,7 @@ struct EmboxOpConversion : public FIROpConversion<fir::EmboxOp> {
     // FIXME: copy the dims info, etc.
 
     rewriter.replaceOp(embox, alloca.getResult());
-    return matchSuccess();
+    return success();
   }
 
   /// Generate an alloca of size `size` and cast it to type `toTy`
@@ -1083,7 +1083,7 @@ struct EmboxOpConversion : public FIROpConversion<fir::EmboxOp> {
 struct EmboxProcOpConversion : public FIROpConversion<fir::EmboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::EmboxProcOp emboxproc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto a = operands[0];
@@ -1097,7 +1097,7 @@ struct EmboxProcOpConversion : public FIROpConversion<fir::EmboxProcOp> {
     auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, un, a, c0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(emboxproc, ty, r, b,
                                                            c1);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1120,7 +1120,7 @@ inline void appendTo(SmallVectorImpl<A> &dest, ArrayRef<A> from) {
 struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::ExtractValueOp extractVal, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(extractVal.getType());
@@ -1132,7 +1132,7 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
     auto position = mlir::ArrayAttr::get(attrs, extractVal.getContext());
     rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(
         extractVal, ty, operands[0], position);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1141,7 +1141,7 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
 struct InsertValueOpConversion : public FIROpConversion<fir::InsertValueOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::InsertValueOp insertVal, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(insertVal.getType());
@@ -1153,7 +1153,7 @@ struct InsertValueOpConversion : public FIROpConversion<fir::InsertValueOp> {
     auto position = mlir::ArrayAttr::get(attrs, insertVal.getContext());
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
         insertVal, ty, operands[0], operands[1], position);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1171,7 +1171,7 @@ bool noFieldIndexOps(mlir::Operation::operand_range operands) {
 struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::CoordinateOp coor, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(coor.getType());
@@ -1191,7 +1191,7 @@ struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
           auto uty = unwrap(ty);
           auto gep = genGEP(loc, uty, rewriter, bc, lenParam);
           rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, uty, gep);
-          return matchSuccess();
+          return success();
         }
       }
       auto c0_ = genConstantOffset(loc, rewriter, 0);
@@ -1208,7 +1208,7 @@ struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
     if (noFieldIndexOps(coor.coor())) {
       // do not need to lower any field index ops, so use a GEP
       rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(coor, ty, base, offs);
-      return matchSuccess();
+      return success();
     }
 
     // lower the field index ops by walking the indices
@@ -1259,7 +1259,7 @@ struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
       retval = genGEP(loc, unwrap(ty), rewriter, retval,
                       arguments(offs, pos, offs.size()));
     rewriter.replaceOp(coor, retval);
-    return matchSuccess();
+    return success();
   }
 
   SmallVector<mlir::Value, 8> arguments(OperandTy vec, unsigned s,
@@ -1283,7 +1283,7 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   using FIROpConversion::FIROpConversion;
 
   // NB: most field references should be resolved by this point
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::FieldIndexOp field, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // call the compiler generated function to determine the byte offset of
@@ -1294,7 +1294,7 @@ struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
         rewriter.getNamedAttr("callee", symAttr)};
     auto ty = lowering.offsetType();
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(field, ty, operands, attrs);
-    return matchSuccess();
+    return success();
   }
 
   // constructing the name of the method
@@ -1313,7 +1313,7 @@ struct LenParamIndexOpConversion
   using FIROpConversion::FIROpConversion;
 
   // FIXME: this should be specialized by the runtime target
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::LenParamIndexOp lenp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ity = lowering.indexType();
@@ -1332,7 +1332,7 @@ struct LenParamIndexOpConversion
     offset += 0; // FIXME
     auto attr = rewriter.getI64IntegerAttr(offset);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(lenp, ity, attr);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1340,11 +1340,11 @@ struct LenParamIndexOpConversion
 struct FirEndOpConversion : public FIROpConversion<fir::FirEndOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::FirEndOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOp(op, {});
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1355,7 +1355,7 @@ struct GenDimsOpConversion : public FIROpConversion<fir::GenDimsOp> {
   using FIROpConversion::FIROpConversion;
 
   // gendims(args:index, ...) ==> %v = ... : [size x <3 x index>]
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::GenDimsOp gendims, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto loc = gendims.getLoc();
@@ -1371,7 +1371,7 @@ struct GenDimsOpConversion : public FIROpConversion<fir::GenDimsOp> {
       rewriter.create<mlir::LLVM::StoreOp>(loc, opd, gep);
     }
     rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(gendims, ptrTy, alloca);
-    return matchSuccess();
+    return success();
   }
 
   // Generate an alloca of size `size` and cast it to type `toTy`
@@ -1393,7 +1393,7 @@ struct GenDimsOpConversion : public FIROpConversion<fir::GenDimsOp> {
 struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::GenTypeDescOp gentypedesc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto loc = gentypedesc.getLoc();
@@ -1405,7 +1405,7 @@ struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
     createGlobal(loc, module, name, gty, rewriter);
     rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(gentypedesc, pty,
                                                          name);
-    return matchSuccess();
+    return success();
   }
 
   std::string consName(mlir::ConversionPatternRewriter &rewriter,
@@ -1425,29 +1425,29 @@ struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
 struct GlobalLenOpConversion : public FIROpConversion<fir::GlobalLenOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::GlobalLenOp globalLen, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(globalLen);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct HasValueOpConversion : public FIROpConversion<fir::HasValueOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::HasValueOp op, OperandTy operands,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::GlobalOp global, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto tyAttr = unwrap(convertType(global.getType()));
@@ -1462,7 +1462,7 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
     auto &gr = g.getInitializerRegion();
     rewriter.inlineRegionBefore(global.region(), gr, gr.end());
     rewriter.eraseOp(global);
-    return matchSuccess();
+    return success();
   }
 
   mlir::LLVM::Linkage
@@ -1484,13 +1484,13 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
 struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::LoadOp load, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(load.getType());
     auto at = load.getAttrs();
     rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(load, ty, operands, at);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1498,12 +1498,12 @@ struct LoadOpConversion : public FIROpConversion<fir::LoadOp> {
 struct NoReassocOpConversion : public FIROpConversion<fir::NoReassocOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::NoReassocOp noreassoc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     noreassoc.replaceAllUsesWith(operands[0]);
     rewriter.replaceOp(noreassoc, {});
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1544,7 +1544,7 @@ void genCaseLadderStep(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
 struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::SelectCaseOp caseOp, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     const auto conds = caseOp.getNumConditions();
@@ -1599,7 +1599,7 @@ struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
       assert((t + 1 == conds) && "unit must be last");
       genBrOp(caseOp, dest, destOps, rewriter);
     }
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1640,11 +1640,11 @@ void selectMatchAndRewrite(FIRToLLVMTypeConverter &lowering, OP select,
 struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::SelectOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectOp>(lowering, op, operands, rewriter);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1652,22 +1652,22 @@ struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
 struct SelectRankOpConversion : public FIROpConversion<fir::SelectRankOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::SelectRankOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectRankOp>(lowering, op, operands, rewriter);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct SelectTypeOpConversion : public FIROpConversion<fir::SelectTypeOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::SelectTypeOp select, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     llvm_unreachable("fir.select_type should have already been converted");
-    return matchFailure();
+    return failure();
   }
 };
 
@@ -1675,12 +1675,12 @@ struct SelectTypeOpConversion : public FIROpConversion<fir::SelectTypeOp> {
 struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::StoreOp store, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<mlir::LLVM::StoreOp>(store, operands[0],
                                                      operands[1]);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1697,7 +1697,7 @@ mlir::LLVM::ExtractValueOp genExtractValueWithIndex(
 struct UnboxCharOpConversion : public FIROpConversion<fir::UnboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::UnboxCharOp unboxchar, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto *ctx = unboxchar.getContext();
@@ -1711,7 +1711,7 @@ struct UnboxCharOpConversion : public FIROpConversion<fir::UnboxCharOp> {
     std::vector<mlir::Value> repls = {ptr, len};
     unboxchar.replaceAllUsesWith(repls);
     rewriter.eraseOp(unboxchar);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1732,7 +1732,7 @@ mlir::LLVM::LoadOp genLoadWithIndex(mlir::Location loc, mlir::Value tuple,
 struct UnboxOpConversion : public FIROpConversion<fir::UnboxOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::UnboxOp unbox, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto loc = unbox.getLoc();
@@ -1752,7 +1752,7 @@ struct UnboxOpConversion : public FIROpConversion<fir::UnboxOp> {
     std::vector<mlir::Value> repls{ptr, len, ver, rank, type, attr, xtra};
     unbox.replaceAllUsesWith(repls);
     rewriter.eraseOp(unbox);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1760,7 +1760,7 @@ struct UnboxOpConversion : public FIROpConversion<fir::UnboxOp> {
 struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::UnboxProcOp unboxproc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto *ctx = unboxproc.getContext();
@@ -1774,7 +1774,7 @@ struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
     std::vector<mlir::Value> repls{ptr, host};
     unboxproc.replaceAllUsesWith(repls);
     rewriter.eraseOp(unboxproc);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1782,12 +1782,12 @@ struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
 struct UndefOpConversion : public FIROpConversion<fir::UndefOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::UndefOp undef, OperandTy,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<mlir::LLVM::UndefOp>(
         undef, convertType(undef.getType()));
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1795,11 +1795,11 @@ struct UndefOpConversion : public FIROpConversion<fir::UndefOp> {
 struct UnreachableOpConversion : public FIROpConversion<fir::UnreachableOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::UnreachableOp unreach, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(unreach);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1819,63 +1819,63 @@ void lowerRealBinaryOp(BINOP binop, OperandTy operands,
 struct AddfOpConversion : public FIROpConversion<fir::AddfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::AddfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     lowerRealBinaryOp<mlir::LLVM::FAddOp>(op, operands, rewriter, lowering);
-    return matchSuccess();
+    return success();
   }
 };
 struct SubfOpConversion : public FIROpConversion<fir::SubfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::SubfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     lowerRealBinaryOp<mlir::LLVM::FSubOp>(op, operands, rewriter, lowering);
-    return matchSuccess();
+    return success();
   }
 };
 struct MulfOpConversion : public FIROpConversion<fir::MulfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::MulfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     lowerRealBinaryOp<mlir::LLVM::FMulOp>(op, operands, rewriter, lowering);
-    return matchSuccess();
+    return success();
   }
 };
 struct DivfOpConversion : public FIROpConversion<fir::DivfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::DivfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     lowerRealBinaryOp<mlir::LLVM::FDivOp>(op, operands, rewriter, lowering);
-    return matchSuccess();
+    return success();
   }
 };
 struct ModfOpConversion : public FIROpConversion<fir::ModfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::ModfOp op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     lowerRealBinaryOp<mlir::LLVM::FRemOp>(op, operands, rewriter, lowering);
-    return matchSuccess();
+    return success();
   }
 };
 
 struct NegfOpConversion : public FIROpConversion<fir::NegfOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::NegfOp neg, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(neg.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::FNegOp>(neg, ty, operands);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1909,7 +1909,7 @@ mlir::LLVM::InsertValueOp complexSum(OPTY sumop, OperandTy opnds,
 struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::AddcOp addc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // given: (x + iy) * (x' + iy')
@@ -1917,14 +1917,14 @@ struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
     auto r = complexSum<mlir::LLVM::FAddOp>(addc, operands, rewriter, lowering);
     addc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(addc, r.getResult());
-    return matchSuccess();
+    return success();
   }
 };
 
 struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::SubcOp subc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // given: (x + iy) * (x' + iy')
@@ -1932,7 +1932,7 @@ struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
     auto r = complexSum<mlir::LLVM::FSubOp>(subc, operands, rewriter, lowering);
     subc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(subc, r.getResult());
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1940,7 +1940,7 @@ struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
 struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::MulcOp mulc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // TODO: should this just call __muldc3 ?
@@ -1968,7 +1968,7 @@ struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
     auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
     mulc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(mulc, r.getResult());
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -1976,7 +1976,7 @@ struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
 struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::DivcOp divc, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // TODO: should this just call __divdc3 ?
@@ -2009,7 +2009,7 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
     auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r_, ri, c1);
     divc.replaceAllUsesWith(r.getResult());
     rewriter.replaceOp(divc, r.getResult());
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -2017,7 +2017,7 @@ struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
 struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(fir::NegcOp neg, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // given: -(x + iy)
@@ -2034,7 +2034,7 @@ struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
     auto nip = rewriter.create<mlir::LLVM::FNegOp>(loc, ty, ip);
     auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, o0, nrp, c0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(neg, ty, r, nip, c1);
-    return matchSuccess();
+    return success();
   }
 };
 
diff --git a/lib/Optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
index eda3ccecaf00..3fc2ccc24444 100644
--- a/lib/Optimizer/StdConverter.cpp
+++ b/lib/Optimizer/StdConverter.cpp
@@ -105,7 +105,7 @@ class FIROpConversion : public mlir::ConversionPattern {
 struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
   using FIROpConversion::FIROpConversion;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(mlir::Operation *op, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto selectType = mlir::cast<SelectTypeOp>(op);
@@ -136,7 +136,7 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
       rewriter.replaceOpWithNewOp<mlir::BranchOp>(
           selectType, dest, mlir::ValueRange{destOps.getValue()});
     }
-    return matchSuccess();
+    return success();
   }
 
   static void genTypeLadderStep(mlir::Location loc, bool exactTest,
diff --git a/lib/Optimizer/Transforms/CSE.cpp b/lib/Optimizer/Transforms/CSE.cpp
index a247b3674582..2db9c959db7a 100644
--- a/lib/Optimizer/Transforms/CSE.cpp
+++ b/lib/Optimizer/Transforms/CSE.cpp
@@ -18,6 +18,7 @@
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/Functional.h"
 #include "mlir/Transforms/Passes.h"
@@ -176,11 +177,12 @@ LogicalResult BasicCSE::simplifyOperation(ScopedMapTy &knownValues,
   if (op->getNumRegions() != 0)
     return failure();
 
-  if (!op->hasNoSideEffect() && !fir::nonVolatileLoad(op) && !fir::pureCall(op))
+  if (!MemoryEffectOpInterface::hasNoEffect(op) && !fir::nonVolatileLoad(op) &&
+      !fir::pureCall(op))
     return failure();
 
   // If the operation is already trivially dead just add it to the erase list.
-  if (op->use_empty()) {
+  if (isOpTriviallyDead(op)) {
     opsToErase.push_back(op);
     return success();
   }
diff --git a/lib/Optimizer/Transforms/RewriteLoop.cpp b/lib/Optimizer/Transforms/RewriteLoop.cpp
index 331df3691f5b..7bbce631308c 100644
--- a/lib/Optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/Optimizer/Transforms/RewriteLoop.cpp
@@ -90,7 +90,7 @@ class LoopLoopConv : public mlir::OpRewritePattern<LoopOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(LoopOp loop, mlir::PatternRewriter &rewriter) const override {
     auto loc = loop.getLoc();
     auto low = loop.getLowerBoundOperand();
@@ -121,7 +121,7 @@ class LoopLoopConv : public mlir::OpRewritePattern<LoopOp> {
     f.region().getBlocks().clear();
     rewriter.inlineRegionBefore(loop.region(), f.region(), f.region().end());
     rewriter.eraseOp(loop);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -130,7 +130,7 @@ class LoopWhereConv : public mlir::OpRewritePattern<WhereOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(WhereOp where,
                   mlir::PatternRewriter &rewriter) const override {
     auto loc = where.getLoc();
@@ -145,7 +145,7 @@ class LoopWhereConv : public mlir::OpRewritePattern<WhereOp> {
       ifOp.elseRegion().back().erase();
     }
     rewriter.eraseOp(where);
-    return matchSuccess();
+    return success();
   }
 };
 
@@ -154,10 +154,10 @@ class LoopFirEndConv : public mlir::OpRewritePattern<FirEndOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
-  mlir::PatternMatchResult
+  mlir::LogicalResult
   matchAndRewrite(FirEndOp op, mlir::PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<mlir::loop::YieldOp>(op);
-    return matchSuccess();
+    return success();
   }
 };
 

From e45b3e78d5cc0ce3abc9ecbe1c6e34ad7ec818e1 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Sat, 21 Mar 2020 17:47:35 -0700
Subject: [PATCH 256/345] fixes to lower FIR column-major array layout and
 accesses to LLVM properly.

---
 include/flang/Optimizer/Dialect/FIROps.td |   2 +-
 include/flang/Optimizer/Dialect/FIRType.h |   6 +
 lib/Optimizer/CodeGen.cpp                 | 554 +++++++++++++++-------
 lib/Optimizer/Dialect/FIRType.cpp         |  11 +
 test/Fir/loop10.fir                       |   2 +-
 5 files changed, 395 insertions(+), 180 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index cee7dcb84425..02e8fc21309f 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -1729,7 +1729,7 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
     stride must not be zero.
 
     ```mlir
-      %d = fir.gendims %l, %u, %s : (index, index, index) -> !fir.dims<1>
+      %d = fir.gendims %lo, %ext, %str : (index, index, index) -> !fir.dims<1>
     ```
   }];
 
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index ac83324f8087..c064895b02f8 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -324,6 +324,12 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
   /// The number of dimensions of the sequence
   unsigned getDimension() const { return getShape().size(); }
 
+  /// Number of rows of constant extent
+  unsigned getConstantRows() const;
+
+  /// Is the shape of the sequence constant?
+  bool hasConstantShape() const { return getConstantRows() == getDimension(); }
+  
   /// The value `-1` represents an unknown extent for a dimension
   static constexpr Extent getUnknownExtent() { return -1; }
 
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index c442778cab18..7ad91624a056 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -39,9 +39,7 @@
 /// necessary to preserve the semantics of the Fortran program.
 
 #undef TODO
-#define TODO(X)                                                                \
-  (void)X;                                                                     \
-  assert(false && "not yet implemented")
+#define TODO() llvm_unreachable("not yet implemented")
 
 using namespace llvm;
 
@@ -69,19 +67,16 @@ bool allConstants(OperandTy operands) {
 }
 } // namespace fir
 
-namespace {
-
 using SmallVecResult = SmallVector<mlir::Value, 4>;
 using AttributeTy = ArrayRef<mlir::NamedAttribute>;
 
-const unsigned defaultAlign{8};
+static constexpr unsigned defaultAlign = 8;
+
+namespace {
 
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
 class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
-  fir::KindMapping kindMapping;
-  static StringMap<mlir::LLVM::LLVMType> identStructCache;
-
 public:
   FIRToLLVMTypeConverter(mlir::MLIRContext *context, fir::NameUniquer &uniquer)
       : LLVMTypeConverter(context), kindMapping(context), uniquer(uniquer) {
@@ -159,7 +154,10 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
     // auto *ctx = box.getContext();
     auto eleTy = unwrap(convertType(ele));
     // buffer*
-    parts.push_back(eleTy.getPointerTo());
+    if (ele.isa<fir::SequenceType>() && eleTy.isPointerTy())
+      parts.push_back(eleTy);
+    else
+      parts.push_back(eleTy.getPointerTo());
     // ele-size
     parts.push_back(mlir::LLVM::LLVMType::getInt64Ty(llvmDialect));
     // version
@@ -266,13 +264,16 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   mlir::LLVM::LLVMType convertSequenceType(fir::SequenceType seq) {
     auto baseTy = unwrap(convertType(seq.getEleTy()));
     auto shape = seq.getShape();
-    if (shape.size()) {
+    auto constRows = seq.getConstantRows();
+    if (constRows) {
+      decltype(constRows) i = constRows;
       for (auto e : shape) {
-        if (e < 0)
-          e = 0;
         baseTy = mlir::LLVM::LLVMType::getArrayTy(baseTy, e);
+        if (--i == 0)
+          break;
       }
-      return baseTy;
+      if (seq.hasConstantShape())
+        return baseTy;
     }
     return baseTy.getPointerTo();
   }
@@ -334,14 +335,56 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
     return wrappedLLVMType;
   }
 
+  /// Returns false iff the sequence type has a shape and the shape is constant.
+  static bool unknownShape(fir::SequenceType::Shape shape) {
+    // does the shape even exist?
+    if (!shape.size())
+      return true;
+    // if it exists, are any dimensions deferred?
+    const auto sz = shape.size();
+    for (std::remove_const_t<decltype(sz)> i = 0; i < sz; ++i)
+      if (shape[i] < 0)
+        return true;
+    return false;
+  }
+
+  /// Does this record type have dynamically inlined subobjects? Note: this
+  /// should not look through references as they are not inlined.
+  static bool dynamicallySized(fir::RecordType seqTy) {
+    for (auto field : seqTy.getTypeList()) {
+      if (auto arr = field.second.dyn_cast<fir::SequenceType>()) {
+        if (unknownShape(arr.getShape()))
+          return true;
+      } else if (auto rec = field.second.dyn_cast<fir::RecordType>()) {
+        if (dynamicallySized(rec))
+          return true;
+      }
+    }
+    return false;
+  }
+
+  static bool dynamicallySized(mlir::Type ty) {
+    if (auto arr = ty.dyn_cast<fir::SequenceType>())
+      ty = arr.getEleTy();
+    if (auto rec = ty.dyn_cast<fir::RecordType>())
+      return dynamicallySized(rec);
+    return false;
+  }
+
+  fir::NameUniquer &getUniquer() { return uniquer; }
+
+private:
+  fir::KindMapping kindMapping;
   fir::NameUniquer &uniquer;
+  static StringMap<mlir::LLVM::LLVMType> identStructCache;
 };
 
 // instantiate static data member
 StringMap<mlir::LLVM::LLVMType> FIRToLLVMTypeConverter::identStructCache;
+} // namespace
 
 /// remove `omitNames` (by name) from the attribute dictionary
-SmallVector<mlir::NamedAttribute, 4>
+static SmallVector<mlir::NamedAttribute, 4>
 pruneNamedAttrDict(AttributeTy attrs, ArrayRef<StringRef> omitNames) {
   SmallVector<mlir::NamedAttribute, 4> result;
   for (auto x : attrs) {
@@ -361,6 +404,7 @@ inline mlir::LLVM::LLVMType getVoidPtrType(mlir::LLVM::LLVMDialect *dialect) {
   return mlir::LLVM::LLVMType::getInt8PtrTy(dialect);
 }
 
+namespace {
 /// FIR conversion pattern template
 template <typename FromOp>
 class FIROpConversion : public mlir::OpConversionPattern<FromOp> {
@@ -391,13 +435,79 @@ class FIROpConversion : public mlir::OpConversionPattern<FromOp> {
     return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
   }
 
+  /// Method to construct code sequence to get the rank from a box.
+  mlir::Value getRankFromBox(mlir::Location loc, mlir::Value box,
+                             mlir::Type resultTy,
+                             mlir::ConversionPatternRewriter &rewriter) const {
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c3 = genConstantOffset(loc, rewriter, 3);
+    llvm::SmallVector<mlir::Value, 3> args = {box, c0, c3};
+    auto pty = unwrap(resultTy).getPointerTo();
+    auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, pty, args);
+    return rewriter.create<mlir::LLVM::LoadOp>(loc, resultTy, p);
+  }
+
+  /// Method to construct code sequence to get the triple for dimension `dim`
+  /// from a box.
+  llvm::SmallVector<mlir::Value, 3>
+  getDimsFromBox(mlir::Location loc, llvm::ArrayRef<mlir::Type> retTys,
+                 mlir::Value box, mlir::Value dim,
+                 mlir::ConversionPatternRewriter &rewriter) const {
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c7 = genConstantOffset(loc, rewriter, 7);
+    auto l0 = loadFromOffset(loc, box, c0, c7, dim, 0, retTys[0], rewriter);
+    auto l1 = loadFromOffset(loc, box, c0, c7, dim, 1, retTys[1], rewriter);
+    auto l2 = loadFromOffset(loc, box, c0, c7, dim, 2, retTys[2], rewriter);
+    return {l0.getResult(), l1.getResult(), l2.getResult()};
+  }
+
+  mlir::LLVM::LoadOp
+  loadFromOffset(mlir::Location loc, mlir::Value a, mlir::LLVM::ConstantOp c0,
+                 mlir::LLVM::ConstantOp c7, mlir::Value dim, int off,
+                 mlir::Type ty,
+                 mlir::ConversionPatternRewriter &rewriter) const {
+    auto pty = unwrap(ty).getPointerTo();
+    auto c = genConstantOffset(loc, rewriter, off);
+    auto p = genGEP(loc, pty, rewriter, a, c0, c7, dim, c);
+    return rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
+  }
+
+  template <typename... ARGS>
+  mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::LLVM::LLVMType ty,
+                           mlir::ConversionPatternRewriter &rewriter,
+                           mlir::Value base, ARGS... args) const {
+    SmallVector<mlir::Value, 8> cv{args...};
+    return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
+  }
+
   FIRToLLVMTypeConverter &lowering;
 };
 
+/// FIR conversion pattern template
+template <typename FromOp>
+class FIROpAndTypeConversion : public FIROpConversion<FromOp> {
+public:
+  using FIROpConversion<FromOp>::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(FromOp op, OperandTy operands,
+                  mlir::ConversionPatternRewriter &rewriter) const final {
+    mlir::Type ty = this->convertType(op.getType());
+    return doRewrite(op, ty, operands, rewriter);
+  }
+
+  virtual mlir::LogicalResult
+  doRewrite(FromOp addr, mlir::Type ty, OperandTy operands,
+            mlir::ConversionPatternRewriter &rewriter) const {
+    llvm_unreachable("derived class must override");
+  }
+};
+} // namespace
+
 /// Create an LLVM dialect global
-void createGlobal(mlir::Location loc, mlir::ModuleOp mod, StringRef name,
-                  mlir::LLVM::LLVMType type,
-                  mlir::ConversionPatternRewriter &rewriter) {
+static void createGlobal(mlir::Location loc, mlir::ModuleOp mod, StringRef name,
+                         mlir::LLVM::LLVMType type,
+                         mlir::ConversionPatternRewriter &rewriter) {
   if (mod.lookupSymbol<mlir::LLVM::GlobalOp>(name))
     return;
   mlir::OpBuilder modBuilder(mod.getBodyRegion());
@@ -406,6 +516,7 @@ void createGlobal(mlir::Location loc, mlir::ModuleOp mod, StringRef name,
                                           mlir::Attribute{});
 }
 
+namespace {
 struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -419,14 +530,16 @@ struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
     return success();
   }
 };
+} // namespace
 
-mlir::LLVM::ConstantOp
+static mlir::LLVM::ConstantOp
 genConstantIndex(mlir::Location loc, mlir::LLVM::LLVMType ity,
                  mlir::ConversionPatternRewriter &rewriter, int offset) {
   auto cattr = rewriter.getI64IntegerAttr(offset);
   return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
 }
 
+namespace {
 /// convert to LLVM IR dialect `alloca`
 struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
   using FIROpConversion::FIROpConversion;
@@ -446,10 +559,11 @@ struct AllocaOpConversion : public FIROpConversion<fir::AllocaOp> {
     return success();
   }
 };
+} // namespace
 
-mlir::LLVM::LLVMFuncOp getMalloc(fir::AllocMemOp op,
-                                 mlir::ConversionPatternRewriter &rewriter,
-                                 mlir::LLVM::LLVMDialect *dialect) {
+static mlir::LLVM::LLVMFuncOp
+getMalloc(fir::AllocMemOp op, mlir::ConversionPatternRewriter &rewriter,
+          mlir::LLVM::LLVMDialect *dialect) {
   auto module = op.getParentOfType<mlir::ModuleOp>();
   if (auto mallocFunc = module.lookupSymbol<mlir::LLVM::LLVMFuncOp>("malloc"))
     return mallocFunc;
@@ -462,6 +576,7 @@ mlir::LLVM::LLVMFuncOp getMalloc(fir::AllocMemOp op,
                                           /*isVarArg=*/false));
 }
 
+namespace {
 /// convert to `call` to the runtime to `malloc` memory
 struct AllocMemOpConversion : public FIROpConversion<fir::AllocMemOp> {
   using FIROpConversion::FIROpConversion;
@@ -485,11 +600,12 @@ struct AllocMemOpConversion : public FIROpConversion<fir::AllocMemOp> {
     return success();
   }
 };
+} // namespace
 
 /// obtain the free() function
-mlir::LLVM::LLVMFuncOp getFree(fir::FreeMemOp op,
-                               mlir::ConversionPatternRewriter &rewriter,
-                               mlir::LLVM::LLVMDialect *dialect) {
+static mlir::LLVM::LLVMFuncOp getFree(fir::FreeMemOp op,
+                                      mlir::ConversionPatternRewriter &rewriter,
+                                      mlir::LLVM::LLVMDialect *dialect) {
   auto module = op.getParentOfType<mlir::ModuleOp>();
   if (auto freeFunc = module.lookupSymbol<mlir::LLVM::LLVMFuncOp>("free"))
     return freeFunc;
@@ -501,6 +617,7 @@ mlir::LLVM::LLVMFuncOp getFree(fir::FreeMemOp op,
                                           /*isVarArg=*/false));
 }
 
+namespace {
 /// lower a freemem instruction into a call to free()
 struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
   using FIROpConversion::FIROpConversion;
@@ -520,14 +637,6 @@ struct FreeMemOpConversion : public FIROpConversion<fir::FreeMemOp> {
   }
 };
 
-template <typename... ARGS>
-mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::LLVM::LLVMType ty,
-                         mlir::ConversionPatternRewriter &rewriter,
-                         mlir::Value base, ARGS... args) {
-  SmallVector<mlir::Value, 8> cv{args...};
-  return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
-}
-
 /// convert to returning the first element of the box (any flavor)
 struct BoxAddrOpConversion : public FIROpConversion<fir::BoxAddrOp> {
   using FIROpConversion::FIROpConversion;
@@ -577,30 +686,16 @@ struct BoxDimsOpConversion : public FIROpConversion<fir::BoxDimsOp> {
   mlir::LogicalResult
   matchAndRewrite(fir::BoxDimsOp boxdims, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto a = operands[0];
-    auto dim = operands[1];
-    auto loc = boxdims.getLoc();
-    auto c0 = genConstantOffset(loc, rewriter, 0);
-    auto c7 = genConstantOffset(loc, rewriter, 7);
-    auto l0 = loadFromOffset(boxdims, loc, a, c0, c7, dim, 0, rewriter);
-    auto l1 = loadFromOffset(boxdims, loc, a, c0, c7, dim, 1, rewriter);
-    auto l2 = loadFromOffset(boxdims, loc, a, c0, c7, dim, 2, rewriter);
-    rewriter.replaceOp(boxdims,
-                       {l0.getResult(), l1.getResult(), l2.getResult()});
+    llvm::SmallVector<mlir::Type, 3> resultTypes = {
+        convertType(boxdims.getResult(0).getType()),
+        convertType(boxdims.getResult(1).getType()),
+        convertType(boxdims.getResult(2).getType()),
+    };
+    auto results = getDimsFromBox(boxdims.getLoc(), resultTypes, operands[0],
+                                  operands[1], rewriter);
+    rewriter.replaceOp(boxdims, results);
     return success();
   }
-
-  mlir::LLVM::LoadOp
-  loadFromOffset(fir::BoxDimsOp boxdims, mlir::Location loc, mlir::Value a,
-                 mlir::LLVM::ConstantOp c0, mlir::LLVM::ConstantOp c7,
-                 mlir::Value dim, int off,
-                 mlir::ConversionPatternRewriter &rewriter) const {
-    auto ty = convertType(boxdims.getResult(off).getType());
-    auto pty = unwrap(ty).getPointerTo();
-    auto c = genConstantOffset(loc, rewriter, off);
-    auto p = genGEP(loc, pty, rewriter, a, c0, c7, dim, c);
-    return rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
-  }
 };
 
 struct BoxEleSizeOpConversion : public FIROpConversion<fir::BoxEleSizeOp> {
@@ -709,12 +804,8 @@ struct BoxRankOpConversion : public FIROpConversion<fir::BoxRankOp> {
     auto a = operands[0];
     auto loc = boxrank.getLoc();
     auto ty = convertType(boxrank.getType());
-    auto c0 = genConstantOffset(loc, rewriter, 0);
-    auto c3 = genConstantOffset(loc, rewriter, 3);
-    SmallVector<mlir::Value, 4> args{a, c0, c3};
-    auto pty = unwrap(ty).getPointerTo();
-    auto p = rewriter.create<mlir::LLVM::GEPOp>(loc, pty, args);
-    rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(boxrank, ty, p);
+    auto result = getRankFromBox(loc, a, ty, rewriter);
+    rewriter.replaceOp(boxrank, result);
     return success();
   }
 };
@@ -958,7 +1049,7 @@ struct DispatchOpConversion : public FIROpConversion<fir::DispatchOp> {
     // get the table, lookup the method, fetch the func-ptr
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(dispatch, ty, operands,
                                                     None);
-    TODO(dispatch);
+    TODO();
     return success();
   }
 };
@@ -971,7 +1062,7 @@ struct DispatchTableOpConversion
   mlir::LogicalResult
   matchAndRewrite(fir::DispatchTableOp dispTab, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    TODO(dispTab);
+    TODO();
     return success();
   }
 };
@@ -983,7 +1074,7 @@ struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
   mlir::LogicalResult
   matchAndRewrite(fir::DTEntryOp dtEnt, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    TODO(dtEnt);
+    TODO();
     return success();
   }
 };
@@ -1101,29 +1192,27 @@ struct EmboxProcOpConversion : public FIROpConversion<fir::EmboxProcOp> {
   }
 };
 
-mlir::Attribute getValue(mlir::Value value) {
-  assert(value.getDefiningOp());
-  if (auto v = dyn_cast<mlir::LLVM::ConstantOp>(value.getDefiningOp()))
-    return v.value();
-  if (auto v = dyn_cast<mlir::ConstantOp>(value.getDefiningOp()))
-    return v.value();
-  assert(false && "must be a constant op");
-  return {};
-}
-
-template <typename A>
-inline void appendTo(SmallVectorImpl<A> &dest, ArrayRef<A> from) {
-  dest.append(from.begin(), from.end());
-}
+struct ValueOpCommon {
+  static mlir::Attribute getValue(mlir::Value value) {
+    auto defOp = value.getDefiningOp();
+    if (auto v = dyn_cast<mlir::LLVM::ConstantOp>(defOp))
+      return v.value();
+    if (auto v = dyn_cast<mlir::ConstantOp>(defOp))
+      return v.value();
+    llvm_unreachable("must be a constant op");
+    return {};
+  }
+};
 
 /// Extract a subobject value from an ssa-value of aggregate type
-struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
-  using FIROpConversion::FIROpConversion;
+struct ExtractValueOpConversion
+    : public FIROpAndTypeConversion<fir::ExtractValueOp>,
+      public ValueOpCommon {
+  using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   mlir::LogicalResult
-  matchAndRewrite(fir::ExtractValueOp extractVal, OperandTy operands,
-                  mlir::ConversionPatternRewriter &rewriter) const override {
-    auto ty = convertType(extractVal.getType());
+  doRewrite(fir::ExtractValueOp extractVal, mlir::Type ty, OperandTy operands,
+            mlir::ConversionPatternRewriter &rewriter) const override {
     assert(fir::allConstants(operands.drop_front(1)));
     // since all indices are constants use LLVM's extractvalue instruction
     SmallVector<mlir::Attribute, 8> attrs;
@@ -1138,13 +1227,14 @@ struct ExtractValueOpConversion : public FIROpConversion<fir::ExtractValueOp> {
 
 /// InsertValue is the generalized instruction for the composition of new
 /// aggregate type values.
-struct InsertValueOpConversion : public FIROpConversion<fir::InsertValueOp> {
-  using FIROpConversion::FIROpConversion;
+struct InsertValueOpConversion
+    : public FIROpAndTypeConversion<fir::InsertValueOp>,
+      public ValueOpCommon {
+  using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   mlir::LogicalResult
-  matchAndRewrite(fir::InsertValueOp insertVal, OperandTy operands,
-                  mlir::ConversionPatternRewriter &rewriter) const override {
-    auto ty = convertType(insertVal.getType());
+  doRewrite(fir::InsertValueOp insertVal, mlir::Type ty, OperandTy operands,
+            mlir::ConversionPatternRewriter &rewriter) const override {
     assert(fir::allConstants(operands.drop_front(2)));
     // since all indices must be constants use LLVM's insertvalue instruction
     SmallVector<mlir::Attribute, 8> attrs;
@@ -1157,43 +1247,40 @@ struct InsertValueOpConversion : public FIROpConversion<fir::InsertValueOp> {
   }
 };
 
-/// return true if all `Value`s in `operands` are not `FieldIndexOp`s
-bool noFieldIndexOps(mlir::Operation::operand_range operands) {
-  for (auto opnd : operands) {
-    if (auto defop = opnd.getDefiningOp())
-      if (dyn_cast<fir::FieldIndexOp>(defop))
-        return false;
-  }
-  return true;
-}
-
 /// convert to reference to a reference to a subobject
-struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
-  using FIROpConversion::FIROpConversion;
+struct CoordinateOpConversion
+    : public FIROpAndTypeConversion<fir::CoordinateOp> {
+  using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   mlir::LogicalResult
-  matchAndRewrite(fir::CoordinateOp coor, OperandTy operands,
-                  mlir::ConversionPatternRewriter &rewriter) const override {
-    auto ty = convertType(coor.getType());
+  doRewrite(fir::CoordinateOp coor, mlir::Type ty, OperandTy operands,
+            mlir::ConversionPatternRewriter &rewriter) const override {
     auto loc = coor.getLoc();
-    mlir::Value base = operands[0];
     auto c0 = genConstantIndex(loc, lowering.indexType(), rewriter, 0);
+    mlir::Value base = operands[0];
+    auto firRef = coor.ref();
+    auto firTy = firRef.getType();
+
+    // if argument 0 is boxed, get the base pointer from the box
+    if (auto boxTy = firTy.dyn_cast<fir::BoxType>()) {
 
-    // The base can be a boxed reference or a raw reference
-    if (auto boxTy = coor.ref().getType().dyn_cast<fir::BoxType>()) {
+      // Special case:
+      //   %lenp = len_param_index foo, type<T(foo:i32)...>
+      //   %addr = coordinate_of %box, %lenp
       if (coor.getNumOperands() == 2) {
         auto coorPtr = *coor.coor().begin();
         auto s = coorPtr.getDefiningOp();
         if (s && isa<fir::LenParamIndexOp>(s)) {
           mlir::Value lenParam = operands[1]; // byte offset
-          auto vty = voidPtrTy();
-          auto bc = rewriter.create<mlir::LLVM::BitcastOp>(loc, vty, base);
-          auto uty = unwrap(ty);
-          auto gep = genGEP(loc, uty, rewriter, bc, lenParam);
-          rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, uty, gep);
+          auto bc =
+              rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy(), base);
+          auto gep = genGEP(loc, unwrap(ty), rewriter, bc, lenParam);
+          rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, unwrap(ty),
+                                                             gep);
           return success();
         }
       }
+
       auto c0_ = genConstantOffset(loc, rewriter, 0);
       auto pty = unwrap(convertType(boxTy.getEleTy())).getPointerTo();
       // Extract the boxed reference
@@ -1202,64 +1289,175 @@ struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
       base = rewriter.create<mlir::LLVM::LoadOp>(loc, pty, p);
     }
 
-    SmallVector<mlir::Value, 8> offs{c0};
-    auto indices = operands.drop_front(1);
-    offs.append(indices.begin(), indices.end());
-    if (noFieldIndexOps(coor.coor())) {
-      // do not need to lower any field index ops, so use a GEP
-      rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(coor, ty, base, offs);
-      return success();
+    mlir::Type cpnTy = getReferenceEleTy(firTy);
+
+    if (FIRToLLVMTypeConverter::dynamicallySized(cpnTy)) {
+      TODO();
     }
 
-    // lower the field index ops by walking the indices
-    auto bty = coor.ref().getType().cast<fir::BoxType>();
-    mlir::Type baseTy = fir::ReferenceType::get(bty.getEleTy());
-    SmallVector<mlir::Value, 8> args{c0};
-    args.append(coor.coor().begin(), coor.coor().end());
-
-    mlir::Value retval = base;
-    assert(offs.size() == args.size() && "must have same arity");
-    unsigned pos = 0;
-    for (std::size_t i = 0, sz{offs.size()}; i != sz; ++i) {
-      assert(pos <= i);
-      if (auto defop = args[i].getDefiningOp())
-        if (auto field = dyn_cast<fir::FieldIndexOp>(defop)) {
-          auto memTy = unwrap(convertType(baseTy)).getPointerTo();
-          mlir::Value gep = retval;
-          if (i - pos > 0)
-            gep = genGEP(loc, memTy, rewriter, gep, arguments(offs, pos, i));
-          auto bc =
-              rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy(), gep);
-          auto gep_ = genGEP(loc, voidPtrTy(), rewriter, bc, offs[i]);
-          pos = i + 1;
-          baseTy = baseTy.cast<fir::RecordType>().getType(field.field_id());
-          retval = rewriter.create<mlir::LLVM::BitcastOp>(
-              loc, convertType(baseTy), gep_);
+    // if arrays has known shape
+    const bool hasKnownShape =
+        arraysHaveKnownShape(cpnTy, operands.drop_front(1));
+
+    // If only the column is `?`, then we can simply place the column value in
+    // the 0-th GEP position.
+    bool columnIsDeferred = false;
+    if (!hasKnownShape)
+      if (auto arrTy = cpnTy.dyn_cast<fir::SequenceType>()) {
+        const auto sz = arrTy.getDimension();
+        if (arraysHaveKnownShape(arrTy.getEleTy(),
+                                 operands.drop_front(1 + sz))) {
+          auto shape = arrTy.getShape();
+          bool allConst = true;
+          for (std::remove_const_t<decltype(sz)> i = 0; i < sz - 1; ++i)
+            if (shape[i] < 0) {
+              allConst = false;
+              break;
+            }
+          if (allConst)
+            columnIsDeferred = true;
+        }
+      }
+
+    if (hasKnownShape || columnIsDeferred) {
+      SmallVector<mlir::Value, 8> offs;
+      if (hasKnownShape)
+        offs.push_back(c0);
+      const auto sz = operands.size();
+      llvm::Optional<int> dims;
+      SmallVector<mlir::Value, 8> arrIdx;
+      for (std::remove_const_t<decltype(sz)> i = 1; i < sz; ++i) {
+        auto nxtOpnd = operands[i];
+
+        // check if the i-th coordinate relates to an array
+        if (dims.hasValue()) {
+          arrIdx.push_back(nxtOpnd);
+          int dimsLeft = *dims;
+          if (dimsLeft > 1) {
+            dims = dimsLeft - 1;
+            continue;
+          }
+          cpnTy = cpnTy.cast<fir::SequenceType>().getEleTy();
+          // append array range in reverse (FIR arrays are column-major)
+          offs.append(arrIdx.rbegin(), arrIdx.rend());
+          arrIdx.clear();
+          dims.reset();
+          continue;
+        } else if (auto arrTy = cpnTy.dyn_cast<fir::SequenceType>()) {
+          int d = arrTy.getDimension() - 1;
+          if (d > 0) {
+            dims = d;
+            arrIdx.push_back(nxtOpnd);
+            continue;
+          }
+          cpnTy = cpnTy.cast<fir::SequenceType>().getEleTy();
+          offs.push_back(nxtOpnd);
           continue;
         }
-      if (auto ptrTy = baseTy.dyn_cast<fir::ReferenceType>()) {
-        baseTy = ptrTy.getEleTy();
-      } else if (auto ptrTy = baseTy.dyn_cast<fir::PointerType>()) {
-        baseTy = ptrTy.getEleTy();
-      } else if (auto ptrTy = baseTy.dyn_cast<fir::HeapType>()) {
-        baseTy = ptrTy.getEleTy();
-      } else if (auto arrTy = baseTy.dyn_cast<fir::SequenceType>()) {
-        // FIXME: unchecked advance over array dims
+
+        // check if the i-th coordinate relates to a field
+        if (auto strTy = cpnTy.dyn_cast<fir::RecordType>()) {
+          cpnTy = strTy.getType(getIntValue(nxtOpnd));
+        } else if (auto strTy = cpnTy.dyn_cast<mlir::TupleType>()) {
+          cpnTy = strTy.getType(getIntValue(nxtOpnd));
+        } else {
+          llvm_unreachable("unhandled type");
+        }
+        offs.push_back(nxtOpnd);
+      }
+      if (dims.hasValue())
+        return mlir::emitError(loc, "not enough arguments for array shape");
+      mlir::Value retval = genGEP(loc, unwrap(ty), rewriter, base, offs);
+      rewriter.replaceOp(coor, retval);
+      return success();
+    }
+
+    // Taking a coordinate of an array with deferred shape. In this case, the
+    // array must be boxed. We need to retrieve the array triples from the box.
+    //
+    // Given:
+    //
+    //   %box ... : box<array<? x ? x ? x i32>>
+    //   %addr = coordinate_of %box, %0, %1, %2
+    //
+    // We want to lower this into an llvm GEP as:
+    //
+    //   %i1 = (%0 - %box.dims(0).lo) * %box.dims(0).str
+    //   %i2 = (%1 - %box.dims(1).lo) * %box.dims(1).str * %box.dims(0).ext
+    //   %scale_by = %box.dims(1).ext * %box.dims(0).ext
+    //   %i3 = (%2 - %box.dims(2).lo) * %box.dims(2).str * %scale_by
+    //   %offset = %i3 + %i2 + %i1
+    //   %addr = getelementptr i32, i32* %box.ref, i64 %offset
+    //
+    // Section 18.5.3 para 3 specifies when and how to interpret the `lo`
+    // value(s) of the triple. The implication is that they must always be
+    // zero for `coordinate_of`. This is because we do not use `coordinate_of`
+    // to compute the offset into a `box<ptr>` or `box<heap>`. The coordinate
+    // is pointer arithmetic. Pointers along a path must be explicitly
+    // dereferenced with a `load`.
+
+    if (!firTy.isa<fir::BoxType>())
+      return mlir::emitError(loc, "base must have box type");
+    if (!cpnTy.isa<fir::SequenceType>())
+      return mlir::emitError(loc, "base element must be reference to array");
+    auto baseTy = cpnTy.cast<fir::SequenceType>();
+    const auto baseDim = baseTy.getDimension();
+    if (!arraysHaveKnownShape(baseTy.getEleTy(),
+                              operands.drop_front(1 + baseDim)))
+      return mlir::emitError(loc, "base element has deferred shapes");
+
+    // Generate offset computation.
+    TODO();
+
+    return failure();
+  }
+
+  /// Walk the abstract memory layout and determine if the path traverses any
+  /// array types with unknown shape. Return true iff all the array types have a
+  /// constant shape along the path.
+  bool arraysHaveKnownShape(mlir::Type type, OperandTy coors) const {
+    const auto sz = coors.size();
+    std::remove_const_t<decltype(sz)> i = 0;
+    for (; i < sz; ++i) {
+      auto nxtOpnd = coors[i];
+      if (auto arrTy = type.dyn_cast<fir::SequenceType>()) {
+        if (FIRToLLVMTypeConverter::unknownShape(arrTy.getShape()))
+          return false;
         i += arrTy.getDimension() - 1;
-        baseTy = arrTy.getEleTy();
-      } else if (auto strTy = baseTy.dyn_cast<fir::RecordType>()) {
-        baseTy = strTy.getType(getIntValue(offs[i]));
-      } else if (auto strTy = baseTy.dyn_cast<mlir::TupleType>()) {
-        baseTy = strTy.getType(getIntValue(offs[i]));
+        type = arrTy.getEleTy();
+      } else if (auto strTy = type.dyn_cast<fir::RecordType>()) {
+        type = strTy.getType(getIntValue(nxtOpnd));
+      } else if (auto strTy = type.dyn_cast<mlir::TupleType>()) {
+        type = strTy.getType(getIntValue(nxtOpnd));
       } else {
-        assert(false && "unhandled type");
+        return false;
       }
     }
-    if (pos < offs.size())
-      retval = genGEP(loc, unwrap(ty), rewriter, retval,
-                      arguments(offs, pos, offs.size()));
-    rewriter.replaceOp(coor, retval);
-    return success();
+    return i == sz;
+  }
+
+  /// Returns the element type of the reference `refTy`.
+  static mlir::Type getReferenceEleTy(mlir::Type refTy) {
+    if (auto boxTy = refTy.dyn_cast<fir::BoxType>())
+      return boxTy.getEleTy();
+    if (auto ptrTy = refTy.dyn_cast<fir::ReferenceType>())
+      return ptrTy.getEleTy();
+    if (auto ptrTy = refTy.dyn_cast<fir::PointerType>())
+      return ptrTy.getEleTy();
+    if (auto ptrTy = refTy.dyn_cast<fir::HeapType>())
+      return ptrTy.getEleTy();
+    llvm_unreachable("not a reference type");
+    return {};
+  }
+
+  /// return true if all `Value`s in `operands` are not `FieldIndexOp`s
+  static bool noFieldIndexOps(mlir::Operation::operand_range operands) {
+    for (auto opnd : operands) {
+      if (auto defop = opnd.getDefiningOp())
+        if (dyn_cast<fir::FieldIndexOp>(defop))
+          return false;
+    }
+    return true;
   }
 
   SmallVector<mlir::Value, 8> arguments(OperandTy vec, unsigned s,
@@ -1277,8 +1475,8 @@ struct CoordinateOpConversion : public FIROpConversion<fir::CoordinateOp> {
   }
 };
 
-/// convert a field index to a runtime function that computes the byte offset of
-/// the dynamic field
+/// convert a field index to a runtime function that computes the byte offset
+/// of the dynamic field
 struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   using FIROpConversion::FIROpConversion;
 
@@ -1413,7 +1611,7 @@ struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
     if (auto d = type.dyn_cast<fir::RecordType>()) {
       auto name = d.getName();
       auto pair = fir::NameUniquer::deconstruct(name);
-      return lowering.uniquer.doTypeDescriptor(
+      return lowering.getUniquer().doTypeDescriptor(
           pair.second.modules, pair.second.host, pair.second.name,
           pair.second.kinds);
     }
@@ -1428,7 +1626,7 @@ struct GlobalLenOpConversion : public FIROpConversion<fir::GlobalLenOp> {
   mlir::LogicalResult
   matchAndRewrite(fir::GlobalLenOp globalLen, OperandTy operands,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    TODO(globalLen);
+    TODO();
     return success();
   }
 };
@@ -1715,19 +1913,6 @@ struct UnboxCharOpConversion : public FIROpConversion<fir::UnboxCharOp> {
   }
 };
 
-// generate a GEP into a structure and load the element at position `x`
-mlir::LLVM::LoadOp genLoadWithIndex(mlir::Location loc, mlir::Value tuple,
-                                    mlir::LLVM::LLVMType ty,
-                                    mlir::ConversionPatternRewriter &rewriter,
-                                    mlir::LLVM::LLVMType oty,
-                                    mlir::LLVM::ConstantOp c0, int x) {
-  auto ax = rewriter.getI32IntegerAttr(x);
-  auto cx = rewriter.create<mlir::LLVM::ConstantOp>(loc, oty, ax);
-  auto xty = ty.getStructElementType(x);
-  auto gep = genGEP(loc, xty.getPointerTo(), rewriter, tuple, c0, cx);
-  return rewriter.create<mlir::LLVM::LoadOp>(loc, xty, gep);
-}
-
 // unbox a generic box reference, yielding its components
 struct UnboxOpConversion : public FIROpConversion<fir::UnboxOp> {
   using FIROpConversion::FIROpConversion;
@@ -1754,6 +1939,19 @@ struct UnboxOpConversion : public FIROpConversion<fir::UnboxOp> {
     rewriter.eraseOp(unbox);
     return success();
   }
+
+  // generate a GEP into a structure and load the element at position `x`
+  mlir::LLVM::LoadOp genLoadWithIndex(mlir::Location loc, mlir::Value tuple,
+                                      mlir::LLVM::LLVMType ty,
+                                      mlir::ConversionPatternRewriter &rewriter,
+                                      mlir::LLVM::LLVMType oty,
+                                      mlir::LLVM::ConstantOp c0, int x) const {
+    auto ax = rewriter.getI32IntegerAttr(x);
+    auto cx = rewriter.create<mlir::LLVM::ConstantOp>(loc, oty, ax);
+    auto xty = ty.getStructElementType(x);
+    auto gep = genGEP(loc, xty.getPointerTo(), rewriter, tuple, c0, cx);
+    return rewriter.create<mlir::LLVM::LoadOp>(loc, xty, gep);
+  }
 };
 
 // unbox a procedure box value, yielding its components
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index 8730a3efa3bb..cb44fe878e7d 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -1062,6 +1062,17 @@ SequenceType::Shape fir::SequenceType::getShape() const {
   return getImpl()->getShape();
 }
 
+unsigned fir::SequenceType::getConstantRows() const {
+  auto shape = getShape();
+  unsigned count = 0;
+  for (auto d : shape) {
+    if (d < 0)
+      break;
+    ++count;
+  }
+  return count;
+}
+
 mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
     mlir::Location loc, const SequenceType::Shape &shape, mlir::Type eleTy,
     mlir::AffineMapAttr map) {
diff --git a/test/Fir/loop10.fir b/test/Fir/loop10.fir
index 5fc5630c6d6f..7c657e21d286 100644
--- a/test/Fir/loop10.fir
+++ b/test/Fir/loop10.fir
@@ -12,7 +12,7 @@ func @x(%addr : !fir.ref<!fir.array<10x10xi32>>) -> index {
     // CHECK: %[[COL:.*]] = phi i64
     // CHECK: icmp slt i64 %[[COL]], 11
     fir.loop %jv = (0) to (10) {
-      // CHECK: getelementptr {{.*}} %[[ADDR]], i64 0, i64 %[[COL]], i64 %[[ROW]]
+      // CHECK: getelementptr {{.*}} %[[ADDR]], i64 0, i64 %[[ROW]], i64 %[[COL]]
       %ptr = fir.coordinate_of %addr, %jv, %iv : (!fir.ref<!fir.array<10x10xi32>>, index, index) -> !fir.ref<i32>
       %c22 = constant 22 : i32
       // CHECK: store i32 22,

From 51e78f9c806c2a2bec83cbcd801e55a4f67689d9 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 23 Mar 2020 14:16:41 -0700
Subject: [PATCH 257/345] simple lowering of array lower bound adjustment in
 Burnside. this is just to get something that works correctly in the a trivial
 case.

---
 lib/Lower/ConvertExpr.cpp      | 46 ++++++++++++++++++++++++++------
 test/Lower/array-init-driver.c | 21 +++++++++++++++
 test/Lower/array-init.f90      | 48 ++++++++++++++++++++++++++++++++++
 3 files changed, 107 insertions(+), 8 deletions(-)
 create mode 100644 test/Lower/array-init-driver.c
 create mode 100644 test/Lower/array-init.f90

diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 3f018c3b3e16..4ab871a8d4c7 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -34,13 +34,12 @@
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/Type.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace {
 
-#define TODO()                                                                 \
-  assert(false);                                                               \
-  return {}
+#define TODO() llvm_unreachable("not yet implemented")
 
 /// Lowering of Fortran::evaluate::Expr<T> expressions
 class ExprLowering {
@@ -705,11 +704,19 @@ class ExprLowering {
     return seqTy.getEleTy();
   }
 
-  // Return the coordinate of the array reference
-  mlir::Value gen(const Fortran::evaluate::ArrayRef &aref) {
-    mlir::Value base = aref.base().IsSymbol()
-                           ? gen(aref.base().GetFirstSymbol())
-                           : gen(aref.base().GetComponent());
+  // Generate the code for a Bound value.
+  mlir::Value genval(const Fortran::semantics::Bound &bound) {
+    if (bound.isExplicit()) {
+      auto sub = bound.GetExplicit();
+      if (sub.has_value())
+        return genval(*sub);
+      return genIntegerConstant<8>(builder.getContext(), 1);
+    }
+    TODO();
+  }
+
+  mlir::Value genArrayRefComponent(const Fortran::evaluate::ArrayRef &aref) {
+    mlir::Value base = gen(aref.base().GetComponent());
     llvm::SmallVector<mlir::Value, 8> args;
     for (auto &subsc : aref.subscript())
       args.push_back(genval(subsc));
@@ -718,9 +725,32 @@ class ExprLowering {
     return builder.create<fir::CoordinateOp>(getLoc(), ty, base, args);
   }
 
+  // Return the coordinate of the array reference
+  mlir::Value gen(const Fortran::evaluate::ArrayRef &aref) {
+    if (aref.base().IsSymbol()) {
+      auto &symbol = aref.base().GetFirstSymbol();
+      mlir::Value base = gen(symbol);
+      auto &shape =
+          symbol.get<Fortran::semantics::ObjectEntityDetails>().shape();
+      unsigned i = 0;
+      llvm::SmallVector<mlir::Value, 8> args;
+      for (auto &subsc : aref.subscript()) {
+        auto val = genval(subsc);
+        auto adj = genval(shape[i++].lbound());
+        auto ty = val.getType();
+        args.push_back(builder.create<mlir::SubIOp>(getLoc(), ty, val, adj));
+      }
+      auto ty = genSubType(base.getType(), args.size());
+      ty = fir::ReferenceType::get(ty);
+      return builder.create<fir::CoordinateOp>(getLoc(), ty, base, args);
+    }
+    return genArrayRefComponent(aref);
+  }
+
   mlir::Value gendef(const Fortran::evaluate::ArrayRef &aref) {
     return gen(aref);
   }
+
   mlir::Value genval(const Fortran::evaluate::ArrayRef &aref) {
     return builder.create<fir::LoadOp>(getLoc(), gen(aref));
   }
diff --git a/test/Lower/array-init-driver.c b/test/Lower/array-init-driver.c
new file mode 100644
index 000000000000..abc3abf5d364
--- /dev/null
+++ b/test/Lower/array-init-driver.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+static float arr_a[20][10];
+static float arr_b[20][10];
+static float arr_c[20][10];
+static float x;
+
+int main()
+{
+  x = 4.0;
+  _QPsetall(&arr_a, &x);
+  x = 5.0;
+  arr_a[5][5] = 2.0;
+  _QPsetall(&arr_b, &x);
+  printf("sub1\n");
+  _QPsub1(&arr_c, &arr_b, &arr_a);
+  printf("c(1,1) = %f\n", arr_c[0][0]);
+  printf("c(2,9) = %f\n", arr_c[8][1]);
+  printf("c(6,6) = %f\n", arr_c[5][5]);
+  return 0;
+}
diff --git a/test/Lower/array-init.f90 b/test/Lower/array-init.f90
new file mode 100644
index 000000000000..f87042047c25
--- /dev/null
+++ b/test/Lower/array-init.f90
@@ -0,0 +1,48 @@
+! RUN: bbc -emit-llvm -o - %s | tco | llc | as -o %t
+! RUN: cc %t %S/array-init-driver.c
+! RUN: ./a.out | FileCheck %s
+
+subroutine setall(a, x)
+  real :: a(10,20)
+  real :: x
+  integer :: i, j
+  do i = 2, 9
+!     a(i, 1) = 0.0
+     do j = 2, 19
+        a(i, j) = x
+     end do
+!     a(i, 20) = 0.0
+  end do
+!  do j = 1, 20
+!     a(1, j) = 0.0
+!     a(10, j) = 0.0
+!  end do
+end subroutine setall
+
+! Two subroutines that mean the same thing semantically. sub1 has explicit
+! loops over the arrays, but there are no loop-carried dependences. The
+! operation can be performed concurrently across the entire 2-D iteration
+! space. sub2 has implicit loops and obviates the need for any analyis.
+
+! expected results from our temporary .c driver
+!
+! CHECK-LABEL: sub1
+! CHECK: c(1,1) = 0.0
+! CHECK: c(2,9) = 9.0
+! CHECK: c(6,6) = 7.0
+
+subroutine sub1(a,b,c)
+  real :: a(10,20), b(10,20), c(10,20)
+  integer :: i, j
+  do i = 1, 10
+     do j = 1, 20
+        a(i,j) = b(i,j) + c(i,j)
+     end do
+  end do
+end subroutine sub1
+
+!subroutine sub2(a,b,c)
+!  real :: a(10,20), b(10,20), c(10,20)
+!  integer :: i, j
+!  a = b + c
+!end subroutine sub2

From cd2d9fc65d2ce9f1bde642ec75d278614499e9d1 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 23 Mar 2020 17:47:30 -0700
Subject: [PATCH 258/345] cleanup anonymous namespace

---
 include/flang/Lower/PFTBuilder.h | 19 ++++++------
 lib/Lower/PFTBuilder.cpp         | 52 ++++++++------------------------
 2 files changed, 22 insertions(+), 49 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 60d96a076ee4..56e944e31fb4 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_LOWER_PFTBUILDER_H_
-#define FORTRAN_LOWER_PFTBUILDER_H_
+#ifndef FORTRAN_LOWER_PFTBUILDER_H
+#define FORTRAN_LOWER_PFTBUILDER_H
 
 #include "flang/Common/template.h"
 #include "flang/Parser/parse-tree.h"
@@ -376,13 +376,12 @@ struct Program {
 
 /// Create a PFT (Pre-FIR Tree) from the parse tree.
 ///
-/// A PFT (Pre-FIR Tree) is a light weight tree over the parse tree that is
-/// used to create FIR.  The PFT captures pointers back into the parse tree,
-/// so the parse tree must not be changed between the construction of the
-/// PFT and its last use.  The PFT captures a structured view of a program.
-/// A program is a list of units.  A function like unit contains a list of
-/// evaluations.  An evaluation is either a statement, or a construct with a
-/// nested list of evaluations.
+/// A PFT is a light weight tree over the parse tree that is used to create FIR.
+/// The PFT captures pointers back into the parse tree, so the parse tree must
+/// not be changed between the construction of the PFT and its last use.  The
+/// PFT captures a structured view of a program.  A program is a list of units.
+/// A function like unit contains a list of evaluations.  An evaluation is
+/// either a statement, or a construct with a nested list of evaluations.
 std::unique_ptr<pft::Program> createPFT(const parser::Program &root);
 
 /// Dumper for displaying a PFT.
@@ -390,4 +389,4 @@ void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft);
 
 } // namespace Fortran::lower
 
-#endif // FORTRAN_LOWER_PFTBUILDER_H_
+#endif // FORTRAN_LOWER_PFTBUILDER_H
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 221cbb2c3616..729cf2a8bf8c 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -14,6 +14,15 @@
 #include <cassert>
 #include <utility>
 
+template <typename A>
+static const A &removeIndirection(const A &a) {
+  return a;
+}
+template <typename A>
+static const A &removeIndirection(const Fortran::common::Indirection<A> &a) {
+  return a.value();
+}
+
 namespace Fortran::lower {
 namespace {
 
@@ -22,21 +31,12 @@ namespace {
 template <typename A>
 struct RemoveIndirectionHelper {
   using Type = A;
-  static constexpr const Type &unwrap(const A &a) { return a; }
 };
 template <typename A>
 struct RemoveIndirectionHelper<common::Indirection<A>> {
   using Type = A;
-  static constexpr const Type &unwrap(const common::Indirection<A> &a) {
-    return a.value();
-  }
 };
 
-template <typename A>
-const auto &removeIndirection(const A &a) {
-  return RemoveIndirectionHelper<A>::unwrap(a);
-}
-
 template <typename A>
 struct UnwrapStmt {
   static constexpr bool isStmt{false};
@@ -704,32 +704,6 @@ class PFTBuilder {
   pft::Evaluation *lastLexicalEvaluation{nullptr};
 };
 
-template <typename Label, typename A>
-constexpr bool hasLabel(const A &stmt) {
-  auto isLabel{
-      [](const auto &v) { return std::holds_alternative<Label>(v.u); }};
-  if constexpr (std::is_same_v<A, parser::ReadStmt> ||
-                std::is_same_v<A, parser::WriteStmt>) {
-    return std::any_of(std::begin(stmt.controls), std::end(stmt.controls),
-                       isLabel);
-  }
-  if constexpr (std::is_same_v<A, parser::WaitStmt>) {
-    return std::any_of(std::begin(stmt.v), std::end(stmt.v), isLabel);
-  }
-  if constexpr (std::is_same_v<Label, parser::ErrLabel>) {
-    if constexpr (common::HasMember<
-                      A, std::tuple<parser::OpenStmt, parser::CloseStmt,
-                                    parser::BackspaceStmt, parser::EndfileStmt,
-                                    parser::RewindStmt, parser::FlushStmt>>)
-      return std::any_of(std::begin(stmt.v), std::end(stmt.v), isLabel);
-    if constexpr (std::is_same_v<A, parser::InquireStmt>) {
-      const auto &specifiers{std::get<std::list<parser::InquireSpec>>(stmt.u)};
-      return std::any_of(std::begin(specifiers), std::end(specifiers), isLabel);
-    }
-  }
-  return false;
-}
-
 class PFTDumper {
 public:
   void dumpPFT(llvm::raw_ostream &outputStream, pft::Program &pft) {
@@ -878,19 +852,19 @@ class PFTDumper {
   std::size_t nextIndex{1}; // 0 is the root
 };
 
+} // namespace
+
 template <typename A, typename T>
-pft::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
+static pft::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
   return pft::FunctionLikeUnit::FunctionStatement{
       &std::get<parser::Statement<A>>(func.t)};
 }
 template <typename A, typename T>
-pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
+static pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
   return pft::ModuleLikeUnit::ModuleStatement{
       &std::get<parser::Statement<A>>(mod.t)};
 }
 
-} // namespace
-
 llvm::cl::opt<bool> clDisableStructuredFir(
     "no-structured-fir", llvm::cl::desc("disable generation of structured FIR"),
     llvm::cl::init(false), llvm::cl::Hidden);

From 8f444f69acf8796e916ea1df9c932134de02225a Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 23 Mar 2020 18:45:52 -0700
Subject: [PATCH 259/345] get rid of iostream finally

---
 tools/bbc/bbc.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 227a3ec7cc72..c629290a5aed 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -46,7 +46,6 @@
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
-#include <iostream>
 
 //===----------------------------------------------------------------------===//
 // Some basic command-line options
@@ -133,14 +132,14 @@ static void convertFortranSourceToMLIR(
   if (!parsing.messages().empty() &&
       (warnIsError || parsing.messages().AnyFatalError())) {
     llvm::errs() << driver.prefix << "could not scan " << path << '\n';
-    parsing.messages().Emit(std::cerr, parsing.cooked());
+    parsing.messages().Emit(llvm::errs(), parsing.cooked());
     exitStatus = EXIT_FAILURE;
     return;
   }
-  parsing.Parse(&std::cout);
-  parsing.messages().Emit(std::cerr, parsing.cooked());
+  parsing.Parse(llvm::outs());
+  parsing.messages().Emit(llvm::errs(), parsing.cooked());
   if (!parsing.consumedWholeFile()) {
-    parsing.EmitMessage(std::cerr, parsing.finalRestingPlace(),
+    parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
                         "parser FAIL (final position)");
     exitStatus = EXIT_FAILURE;
     return;
@@ -156,7 +155,7 @@ static void convertFortranSourceToMLIR(
   Fortran::semantics::Semantics semantics{semanticsContext, parseTree,
                                           parsing.cooked()};
   semantics.Perform();
-  semantics.EmitMessages(std::cerr);
+  semantics.EmitMessages(llvm::errs());
   if (semantics.AnyFatalError()) {
     llvm::errs() << driver.prefix << "semantic errors in " << path << '\n';
     exitStatus = EXIT_FAILURE;

From 500bb5cd8cbc2f358ade2d0f09ced8ff01e1066c Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 20 Mar 2020 10:55:47 -0700
Subject: [PATCH 260/345] Enable lowering lit tests, test units mangling,
 related fix

- Change bbc to dump dir/mlir on standard output by default.
- Change FirOps so that functions are added in order inside an
  mlir module.
- Add tests for all kind of program units but block data
  (so all the function like units).
- Fix separate module procedure mangling to consider the
  declaration scope for the mangling.
---
 lib/Lower/Bridge.cpp                      |  21 ++--
 lib/Lower/Mangler.cpp                     |  56 +++++++----
 lib/Optimizer/Dialect/FIROps.cpp          |   3 +
 test/Lower/program-units-fir-mangling.f90 | 113 ++++++++++++++++++++++
 tools/bbc/bbc.cpp                         |  12 ++-
 5 files changed, 175 insertions(+), 30 deletions(-)
 create mode 100644 test/Lower/program-units-fir-mangling.f90

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 836e07d61b89..7e191233c98a 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -244,7 +244,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                       },
                       cstr->parentVariant.p);
   }
-  
+
   static const Fortran::parser::SubroutineStmt *
   inSubroutine(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
@@ -259,7 +259,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         },
         cstr->parentVariant.p);
   }
-  
+
   static const Fortran::parser::FunctionStmt *
   inFunction(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
@@ -274,7 +274,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         },
         cstr->parentVariant.p);
   }
-  
+
   static const Fortran::parser::MpSubprogramStmt *
   inMpSubprogram(Fortran::lower::pft::Evaluation *cstr) {
     return std::visit(
@@ -373,15 +373,22 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       std::string &name, const Fortran::semantics::Symbol *&symbol) {
     setCurrentPosition(stmt.source);
     auto &n = stmt.statement.v;
-    name = n.ToString();
     symbol = n.symbol;
+    assert(symbol && "Name resolution failure");
+    name = mangleName(*symbol);
   }
   void
   genFIR(const Fortran::parser::Statement<Fortran::parser::EndMpSubprogramStmt>
              &stmt,
-         std::string &, const Fortran::semantics::Symbol *&) {
-    genFIRProcedureExit(
-        static_cast<const Fortran::parser::MpSubprogramStmt *>(nullptr));
+         std::string &, const Fortran::semantics::Symbol *&symbol) {
+    setCurrentPosition(stmt.source);
+    assert(symbol);
+    if (symbol->get<Fortran::semantics::SubprogramDetails>().isFunction()) {
+      genFIRFunctionReturn(*symbol);
+    } else {
+      genFIRProcedureExit(
+          static_cast<const Fortran::parser::MpSubprogramStmt *>(nullptr));
+    }
   }
 
   //
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index af324849d504..c527d86b127e 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -19,32 +19,37 @@
 namespace {
 
 // recursively build the vector of module scopes
-void moduleNames(const Fortran::semantics::Scope *scope,
+void moduleNames(const Fortran::semantics::Scope &scope,
                  llvm::SmallVector<llvm::StringRef, 2> &result) {
-  if (scope->kind() == Fortran::semantics::Scope::Kind::Global) {
+  if (scope.kind() == Fortran::semantics::Scope::Kind::Global) {
     return;
   }
-  moduleNames(&scope->parent(), result);
-  if (scope->kind() == Fortran::semantics::Scope::Kind::Module)
-    if (auto *symbol = scope->symbol())
+  moduleNames(scope.parent(), result);
+  if (scope.kind() == Fortran::semantics::Scope::Kind::Module)
+    if (auto *symbol = scope.symbol())
       result.emplace_back(toStringRef(symbol->name()));
 }
 
 llvm::SmallVector<llvm::StringRef, 2>
-moduleNames(const Fortran::semantics::Scope *scope) {
+moduleNames(const Fortran::semantics::Scope &scope) {
   llvm::SmallVector<llvm::StringRef, 2> result;
   moduleNames(scope, result);
   return result;
 }
 
 llvm::Optional<llvm::StringRef>
-hostName(const Fortran::semantics::Scope *scope) {
-  if (scope->kind() == Fortran::semantics::Scope::Kind::Subprogram) {
-    auto &parent = scope->parent();
-    if (parent.kind() == Fortran::semantics::Scope::Kind::Subprogram)
-      if (auto *symbol = parent.symbol()) {
-        return {toStringRef(symbol->name())};
-      }
+hostName(const Fortran::semantics::Scope &scope) {
+  //  if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
+  //    auto &parent = scope.parent();
+  //    if (parent.kind() == Fortran::semantics::Scope::Kind::Subprogram)
+  //      if (auto *symbol = parent.symbol()) {
+  //        return {toStringRef(symbol->name())};
+  //      }
+  //  }
+  //  return {};
+  if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
+    assert(scope.symbol() && "subprogram scope must have a symbol");
+    return {toStringRef(scope.symbol()->name())};
   }
   return {};
 }
@@ -62,15 +67,28 @@ Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
             return uniquer.doProgramEntry().str();
           },
           [&](const Fortran::semantics::SubprogramDetails &) {
-            auto &cb{symbol->name()};
-            auto modNames{moduleNames(symbol->scope())};
-            return uniquer.doProcedure(modNames, hostName(symbol->scope()),
-                                       toStringRef(cb));
+            const auto *scope{&symbol->owner()};
+            auto &symbolName{symbol->name()};
+            // Separate module subprograms must be mangled according to the
+            // scope where they were declared (the symbol we have is the
+            // definition).
+            if (symbol->attrs().test(Fortran::semantics::Attr::MODULE) &&
+                scope->IsSubmodule()) {
+              // FIXME symbol from MpSubprogramStmt do not seem to have
+              // Attr::MODULE set.
+              const auto *iface{scope->parent().FindSymbol(symbolName)};
+              assert(iface && "Separate module proc must be declared");
+              scope = &iface->owner();
+            }
+            auto modNames{moduleNames(*scope)};
+            return uniquer.doProcedure(modNames, hostName(*scope),
+                                       toStringRef(symbolName));
           },
           [&](const Fortran::semantics::ProcEntityDetails &) {
+            const auto &scope{symbol->owner()};
             auto &cb{symbol->name()};
-            auto modNames{moduleNames(symbol->scope())};
-            return uniquer.doProcedure(modNames, hostName(symbol->scope()),
+            auto modNames{moduleNames(scope)};
+            return uniquer.doProcedure(modNames, hostName(scope),
                                        toStringRef(cb));
           },
           [](const auto &) -> std::string {
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 5a1883409cd9..1910de08cc3b 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -1045,6 +1045,9 @@ mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
   if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
+  // Insert new function at the end of the current module.
+  assert(modBuilder.getInsertionBlock() && "builder must have insertion block");
+  modBuilder.setInsertionPoint(modBuilder.getInsertionBlock()->getTerminator());
   return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
 }
 
diff --git a/test/Lower/program-units-fir-mangling.f90 b/test/Lower/program-units-fir-mangling.f90
new file mode 100644
index 000000000000..d96a7c4b40af
--- /dev/null
+++ b/test/Lower/program-units-fir-mangling.f90
@@ -0,0 +1,113 @@
+! RUN: bbc %s -emit-fir | FileCheck %s
+
+!CHECK: func @_QPsub() {
+subroutine sub()
+! CHECK: }
+end subroutine
+
+!CHECK: func @_QPasubroutine() {
+subroutine AsUbRoUtInE()
+! CHECK: }
+end subroutine
+
+! CHECK-LABEL: func @_QPfoo() -> f32 {
+function foo()
+  real(4) :: foo
+! CHECK: }
+end function
+
+module testMod
+contains
+  !CHECK: func @_QMtestmodPsub() {
+  subroutine sub()
+  ! CHECK: }
+  end subroutine
+
+  ! CHECK-LABEL: func @_QMtestmodPfoo() -> f32 {
+  function foo()
+    real(4) :: foo
+  ! CHECK: }
+  end function
+end module
+
+
+function foo2()
+  real(4) :: foo2
+contains
+  !CHECK: func @_QFfoo2Psub() {
+  subroutine sub()
+  ! CHECK: }
+  end subroutine
+
+  !CHECK: func @_QFfoo2Pfoo() {
+  subroutine foo()
+  ! CHECK: }
+  end subroutine
+end function
+
+subroutine sUb2()
+contains
+  !CHECK: func @_QFsub2Psub() {
+  subroutine sub()
+  ! CHECK: }
+  end subroutine
+
+  !CHECK: func @_QFsub2Pfoo() {
+  subroutine Foo()
+  ! CHECK: }
+  end subroutine
+end subroutine
+
+module testMod2
+contains
+  subroutine sub()
+  contains
+    !CHECK: func @_QMtestmod2FsubPsubsub() {
+    subroutine subSub()
+    ! CHECK: }
+    end subroutine
+  end subroutine
+end module
+
+
+module color_points
+  interface
+    module subroutine draw()
+    end subroutine
+    module function erase()
+      integer(4) :: erase
+    end function
+  end interface
+end module color_points
+
+submodule (color_points) color_points_a
+contains
+  !CHECK: func @_QMcolor_pointsScolor_points_aPsub() {
+  subroutine sub
+  end subroutine
+  ! CHECK: }
+end submodule
+
+submodule (color_points:color_points_a) impl
+contains
+  subroutine foo
+    contains
+    !CHECK: func @_QMcolor_pointsScolor_points_aSimplFfooPbar() {
+    subroutine bar
+    ! CHECK: }
+    end subroutine
+  end subroutine
+  !CHECK: func @_QMcolor_pointsPdraw() {
+  module subroutine draw()
+  end subroutine
+  !FIXME func @_QMcolor_pointsPerase() -> i32 {
+  module procedure erase
+  ! CHECK: }
+  end procedure
+end submodule
+
+
+! CHECK: func @MAIN_() {
+program test
+! CHECK: }
+end program
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index c629290a5aed..c4121baaa010 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -56,8 +56,12 @@ static llvm::cl::opt<std::string> inputFilename(llvm::cl::Positional,
                                                 llvm::cl::desc("<input file>"));
 
 static llvm::cl::opt<std::string>
-    outputFilename("o", llvm::cl::desc("Specify the output filename"),
-                   llvm::cl::value_desc("filename"), llvm::cl::init("a.mlir"));
+    outputFilename("o", llvm::cl::desc("Specify the FIR output filename"),
+                   llvm::cl::value_desc("filename"), llvm::cl::init("-"));
+
+static llvm::cl::opt<std::string> LLVMOutputFilename(
+    "ll-file", llvm::cl::desc("Specify the LLVM IR output filename"),
+    llvm::cl::value_desc("filename"), llvm::cl::init("a.mlir.ll"));
 
 static llvm::cl::list<std::string>
     includeDirs("I", llvm::cl::desc("include search paths"));
@@ -195,10 +199,10 @@ static void convertFortranSourceToMLIR(
     // Continue to lower from MLIR down to LLVM IR. Emit LLVM and MLIR.
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
     std::error_code ec;
-    llvm::ToolOutputFile outFile(outputFilename + ".ll", ec,
+    llvm::ToolOutputFile outFile(LLVMOutputFilename + ".ll", ec,
                                  llvm::sys::fs::OF_None);
     if (ec) {
-      llvm::errs() << "can't open output file " + outputFilename + ".ll";
+      llvm::errs() << "can't open output file " + LLVMOutputFilename + ".ll";
       return;
     }
     pm.addPass(fir::createLLVMDialectToLLVMPass(outFile.os()));

From 48bd26c43dfc62d6b9e3b92e2b8acbe662f2d51b Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Mon, 23 Mar 2020 14:08:04 -0700
Subject: [PATCH 261/345] first part of comment + make function symbol more
 accessible

Conflicts:
	lib/Lower/PFTBuilder.cpp
---
 include/flang/Lower/PFTBuilder.h          |  22 ++
 lib/Lower/Bridge.cpp                      | 260 ++++++----------------
 lib/Lower/ConvertType.cpp                 |   8 +-
 lib/Lower/Mangler.cpp                     |   8 -
 lib/Lower/PFTBuilder.cpp                  |  51 ++++-
 test/Lower/program-units-fir-mangling.f90 |  30 +--
 tools/bbc/bbc.cpp                         |  12 +-
 7 files changed, 164 insertions(+), 227 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 56e944e31fb4..a0d57c273185 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -195,6 +195,10 @@ struct Evaluation {
     }});
   }
 
+  /// Return FunctionLikeUnit to which this evaluation
+  /// belongs. Nullptr if it does not belong to such unit.
+  FunctionLikeUnit *getOwningProcedure() const;
+
   bool lowerAsStructured() const;
   bool lowerAsUnstructured() const;
 
@@ -307,6 +311,19 @@ struct FunctionLikeUnit : public ProgramUnit {
     return getA<parser::MpSubprogramStmt>();
   }
 
+  bool isMainProgram() const {
+    return !beginStmt ||
+           std::holds_alternative<
+               const parser::Statement<parser::ProgramStmt> *>(*beginStmt);
+  }
+
+  /// Returns reference to the subprogram symbol of this FunctionLikeUnit.
+  /// Dies if the FunctionLikeUnit is not a subprogram.
+  const semantics::Symbol &getSubprogramSymbol() const {
+    assert(symbol && "not inside a procedure");
+    return *symbol;
+  }
+
   /// Anonymous programs do not have a begin statement
   std::optional<FunctionStatement> beginStmt;
   FunctionStatement endStmt;
@@ -314,6 +331,11 @@ struct FunctionLikeUnit : public ProgramUnit {
   llvm::DenseMap<parser::Label, Evaluation *> labelEvaluationMap;
   SymbolLabelMap assignSymbolLabelMap;
   std::list<FunctionLikeUnit> nestedFunctions;
+  /// Symbol associated to this FunctionLikeUnit.
+  /// Null if the FunctionLikeUnit is an anonymous program.
+  /// The symbol has MainProgramDetails for named programs, otherwise it has
+  /// SubprogramDetails.
+  const semantics::Symbol *symbol{nullptr};
 
 private:
   template <typename A>
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 7e191233c98a..6303377578d1 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -110,9 +110,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     for (auto &u : pft.getUnits()) {
       std::visit(
           Fortran::common::visitors{
-              [&](Fortran::lower::pft::FunctionLikeUnit &f) {
-                lowerFunc(f, {});
-              },
+              [&](Fortran::lower::pft::FunctionLikeUnit &f) { lowerFunc(f); },
               [&](Fortran::lower::pft::ModuleLikeUnit &m) { lowerMod(m); },
               [&](Fortran::lower::pft::BlockDataUnit &) { TODO(); },
           },
@@ -160,7 +158,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   mlir::Location getCurrentLocation() override final { return toLocation(); }
   mlir::Location genLocation() override final {
-    return builder->getUnknownLoc();
+    return mlir::UnknownLoc::get(&mlirContext);
   }
   mlir::Location
   genLocation(const Fortran::parser::CharBlock &block) override final {
@@ -232,66 +230,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return cat == Fortran::lower::CharacterCat;
   }
 
-  static bool inMainProgram(Fortran::lower::pft::Evaluation *cstr) {
-    return std::visit(Fortran::common::visitors{
-                          [](Fortran::lower::pft::FunctionLikeUnit *c) {
-                            return c->isMainProgram();
-                          },
-                          [&](Fortran::lower::pft::Evaluation *c) {
-                            return inMainProgram(c);
-                          },
-                          [](auto *) { return false; },
-                      },
-                      cstr->parentVariant.p);
-  }
-
-  static const Fortran::parser::SubroutineStmt *
-  inSubroutine(Fortran::lower::pft::Evaluation *cstr) {
-    return std::visit(
-        Fortran::common::visitors{
-            [](Fortran::lower::pft::FunctionLikeUnit *c) {
-              return c->getSubroutine();
-            },
-            [&](Fortran::lower::pft::Evaluation *c) { return inSubroutine(c); },
-            [](auto *) -> const Fortran::parser::SubroutineStmt * {
-              return nullptr;
-            },
-        },
-        cstr->parentVariant.p);
-  }
-
-  static const Fortran::parser::FunctionStmt *
-  inFunction(Fortran::lower::pft::Evaluation *cstr) {
-    return std::visit(
-        Fortran::common::visitors{
-            [](Fortran::lower::pft::FunctionLikeUnit *c) {
-              return c->getFunction();
-            },
-            [&](Fortran::lower::pft::Evaluation *c) { return inFunction(c); },
-            [](auto *) -> const Fortran::parser::FunctionStmt * {
-              return nullptr;
-            },
-        },
-        cstr->parentVariant.p);
-  }
-
-  static const Fortran::parser::MpSubprogramStmt *
-  inMpSubprogram(Fortran::lower::pft::Evaluation *cstr) {
-    return std::visit(
-        Fortran::common::visitors{
-            [](Fortran::lower::pft::FunctionLikeUnit *c) {
-              return c->getMpSubprogram();
-            },
-            [&](Fortran::lower::pft::Evaluation *c) {
-              return inMpSubprogram(c);
-            },
-            [](auto *) -> const Fortran::parser::MpSubprogramStmt * {
-              return nullptr;
-            },
-        },
-        cstr->parentVariant.p);
-  }
-
   void genFIRUnconditionalBranch(mlir::Block *targetBlock) {
     assert(targetBlock && "missing unconditional target block");
     builder->create<mlir::BranchOp>(toLocation(), targetBlock);
@@ -318,79 +256,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     genFIRConditionalBranch(cond, trueTarget->block, falseTarget->block);
   }
 
-  //===--------------------------------------------------------------------===//
-  // Function-like PFT entry and exit statements
-  //===--------------------------------------------------------------------===//
-
-  void
-  genFIR(const Fortran::parser::Statement<Fortran::parser::ProgramStmt> &stmt,
-         std::string &name, const Fortran::semantics::Symbol *&) {
-    setCurrentPosition(stmt.source);
-    name = uniquer.doProgramEntry();
-  }
-  void genFIR(
-      const Fortran::parser::Statement<Fortran::parser::EndProgramStmt> &stmt,
-      std::string &, const Fortran::semantics::Symbol *&) {
-    setCurrentPosition(stmt.source);
-    genFIRProgramExit();
-  }
-
-  void
-  genFIR(const Fortran::parser::Statement<Fortran::parser::FunctionStmt> &stmt,
-         std::string &name, const Fortran::semantics::Symbol *&symbol) {
-    setCurrentPosition(stmt.source);
-    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
-    symbol = n.symbol;
-    assert(symbol && "Name resolution failure");
-    name = mangleName(*symbol);
-  }
-  void genFIR(
-      const Fortran::parser::Statement<Fortran::parser::EndFunctionStmt> &stmt,
-      std::string &, const Fortran::semantics::Symbol *&symbol) {
-    setCurrentPosition(stmt.source);
-    assert(symbol);
-    genFIRFunctionReturn(*symbol);
-  }
-  void genFIR(
-      const Fortran::parser::Statement<Fortran::parser::SubroutineStmt> &stmt,
-      std::string &name, const Fortran::semantics::Symbol *&symbol) {
-    setCurrentPosition(stmt.source);
-    auto &n = std::get<Fortran::parser::Name>(stmt.statement.t);
-    symbol = n.symbol;
-    assert(symbol && "Name resolution failure");
-    name = mangleName(*symbol);
-  }
-  void
-  genFIR(const Fortran::parser::Statement<Fortran::parser::EndSubroutineStmt>
-             &stmt,
-         std::string &, const Fortran::semantics::Symbol *&) {
-    setCurrentPosition(stmt.source);
-    genFIRProcedureExit(
-        static_cast<const Fortran::parser::SubroutineStmt *>(nullptr));
-  }
-  void genFIR(
-      const Fortran::parser::Statement<Fortran::parser::MpSubprogramStmt> &stmt,
-      std::string &name, const Fortran::semantics::Symbol *&symbol) {
-    setCurrentPosition(stmt.source);
-    auto &n = stmt.statement.v;
-    symbol = n.symbol;
-    assert(symbol && "Name resolution failure");
-    name = mangleName(*symbol);
-  }
-  void
-  genFIR(const Fortran::parser::Statement<Fortran::parser::EndMpSubprogramStmt>
-             &stmt,
-         std::string &, const Fortran::semantics::Symbol *&symbol) {
-    setCurrentPosition(stmt.source);
-    assert(symbol);
-    if (symbol->get<Fortran::semantics::SubprogramDetails>().isFunction()) {
-      genFIRFunctionReturn(*symbol);
-    } else {
-      genFIRProcedureExit(
-          static_cast<const Fortran::parser::MpSubprogramStmt *>(nullptr));
-    }
-  }
-
   //
   // Termination of symbolically referenced execution units
   //
@@ -411,18 +276,17 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
     builder->create<mlir::ReturnOp>(toLocation(), r);
   }
-  template <typename A>
-  void genFIRProcedureExit(const A *) {
-    // FIXME: alt-returns
-    builder->create<mlir::ReturnOp>(toLocation());
-  }
-  void genFIR(const Fortran::parser::EndSubroutineStmt &) {
-    genFIRProcedureExit(
-        static_cast<const Fortran::parser::SubroutineStmt *>(nullptr));
-  }
-  void genFIR(const Fortran::parser::EndMpSubprogramStmt &) {
-    genFIRProcedureExit(
-        static_cast<const Fortran::parser::MpSubprogramStmt *>(nullptr));
+  void genFIRProcedureExit(const Fortran::semantics::Symbol &symbol) {
+    const auto &details = symbol.get<Fortran::semantics::SubprogramDetails>();
+    if (details.isFunction()) {
+      mlir::Value resultRef = localSymbols.lookupSymbol(details.result());
+      mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
+      builder->create<mlir::ReturnOp>(toLocation(), r);
+    } else if (Fortran::semantics::HasAlternateReturns(symbol)) {
+      TODO();
+    } else {
+      builder->create<mlir::ReturnOp>(toLocation());
+    }
   }
 
   //
@@ -1263,19 +1127,17 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   // gen expression, if any; share code with END of procedure
   void genFIR(Fortran::lower::pft::Evaluation &eval,
-              const Fortran::parser::ReturnStmt &) {
-    if (inMainProgram(&eval)) {
-      builder->create<mlir::ReturnOp>(toLocation());
-    } else if (auto *stmt = inSubroutine(&eval)) {
-      genFIRProcedureExit(stmt);
-    } else if (auto *stmt = inFunction(&eval)) {
-      auto *symbol = std::get<Fortran::parser::Name>(stmt->t).symbol;
-      assert(symbol);
-      genFIRFunctionReturn(*symbol);
-    } else if (auto *stmt = inMpSubprogram(&eval)) {
-      genFIRProcedureExit(stmt);
+              const Fortran::parser::ReturnStmt &stmt) {
+    const auto *funit{eval.getOwningProcedure()};
+    assert(funit && "not inside main program or a procedure");
+    if (funit->isMainProgram()) {
+      genFIRProgramExit();
     } else {
-      mlir::emitError(toLocation(), "unknown subprogram type");
+      if (stmt.v) {
+        // Alternate return
+        TODO();
+      }
+      genFIRProcedureExit(funit->getSubprogramSymbol());
     }
   }
 
@@ -1323,35 +1185,40 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   /// Prepare to translate a new function
-  void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit,
-                        llvm::StringRef name,
-                        const Fortran::semantics::Symbol *symbol) {
+  void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     assert(!builder && "expected nullptr");
+    // get mangled name
+    std::string name;
+    if (funit.isMainProgram()) {
+      name = uniquer.doProgramEntry();
+    } else {
+      name = mangleName(funit.getSubprogramSymbol());
+    }
     mlir::FuncOp func =
         Fortran::lower::FirOpBuilder::getNamedFunction(module, name);
+
     if (!func)
-      func = createNewFunction(name, symbol);
+      func = createNewFunction(name, funit.symbol);
     builder = new Fortran::lower::FirOpBuilder(func);
     assert(builder && "FirOpBuilder did not instantiate");
     func.addEntryBlock();
     builder->setInsertionPointToStart(&func.front());
 
     // plumb function's arguments
-    if (symbol) {
+    if (funit.symbol && !funit.isMainProgram()) {
       auto *entryBlock = &func.front();
-      auto *details =
-          symbol->detailsIf<Fortran::semantics::SubprogramDetails>();
-      assert(details && "details for semantics symbol must be subprogram");
+      const auto &details =
+          funit.symbol->get<Fortran::semantics::SubprogramDetails>();
       for (const auto &v :
-           llvm::zip(details->dummyArgs(), entryBlock->getArguments())) {
+           llvm::zip(details.dummyArgs(), entryBlock->getArguments())) {
         if (std::get<0>(v)) {
           localSymbols.addSymbol(*std::get<0>(v), std::get<1>(v));
         } else {
           TODO(); // handle alternate return
         }
       }
-      if (details->isFunction())
-        createTemporary(toLocation(), details->result());
+      if (details.isFunction())
+        createTemporary(toLocation(), details.result());
     }
 
     // Create most function blocks in advance.
@@ -1407,50 +1274,57 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
   }
 
-  /// Cleanup after the function has been translated
-  void endNewFunction() {
+  /// Helper to get location from FunctionLikeUnit begin/end
+  static Fortran::parser::CharBlock extractLocation(
+      Fortran::lower::pft::FunctionLikeUnit::FunctionStatement &fstmt) {
+    return std::visit([](const auto *stmt) { return stmt->source; }, fstmt);
+  }
+
+  /// Emit return and cleanup after the function has been translated.
+  void endNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
+    auto loc = extractLocation(funit.endStmt);
+    setCurrentPosition(loc);
+
+    if (funit.isMainProgram()) {
+      genFIRProgramExit();
+    } else {
+      genFIRProcedureExit(funit.getSubprogramSymbol());
+    }
+
     delete builder;
     builder = nullptr;
     localSymbols.clear();
   }
 
   /// Lower a procedure-like construct
-  void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &func,
-                 llvm::ArrayRef<llvm::StringRef> modules,
-                 llvm::Optional<llvm::StringRef> host = {}) {
-    std::string name;
-    const Fortran::semantics::Symbol *symbol = nullptr;
+  void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &funit) {
 
-    if (func.beginStmt) {
-      std::visit([&](auto *p) { genFIR(*p, name, symbol); }, *func.beginStmt);
+    if (funit.beginStmt) {
+      auto loc = extractLocation(funit.endStmt);
+      setCurrentPosition(loc);
     } else {
-      name = uniquer.doProgramEntry();
+      // TODO: get location of anonymous main program
     }
 
-    startNewFunction(func, name, symbol);
+    startNewFunction(funit);
 
     // lower this procedure
-    for (auto &eval : func.evaluationList) {
+    for (auto &eval : funit.evaluationList) {
       genFIR(eval);
     }
-    std::visit([&](auto *p) { genFIR(*p, name, symbol); }, func.endStmt);
 
-    endNewFunction();
+    endNewFunction(funit);
 
     // recursively lower internal procedures
-    llvm::Optional<llvm::StringRef> optName{name};
-    for (auto &f : func.nestedFunctions) {
-      lowerFunc(f, modules, optName);
+    for (auto &f : funit.nestedFunctions) {
+      lowerFunc(f);
     }
   }
 
   void lowerMod(Fortran::lower::pft::ModuleLikeUnit &mod) {
-    // FIXME: build the vector of module names
-    std::vector<llvm::StringRef> moduleName;
-
     // FIXME: do we need to visit the module statements?
     for (auto &f : mod.nestedFunctions) {
-      lowerFunc(f, moduleName);
+      lowerFunc(f);
     }
   }
 
diff --git a/lib/Lower/ConvertType.cpp b/lib/Lower/ConvertType.cpp
index 93cee1b7e480..dcf2b605e666 100644
--- a/lib/Lower/ConvertType.cpp
+++ b/lib/Lower/ConvertType.cpp
@@ -323,15 +323,19 @@ class TypeBuilder {
             symbol->detailsIf<Fortran::semantics::SubprogramDetails>()) {
       if (proc->isFunction())
         returnTys.emplace_back(gen(proc->result()));
-      // FIXME: handle alt-return
       for (auto *arg : proc->dummyArgs()) {
         // Nullptr args are alternate returns indicators
-        if (arg)
+        if (arg) {
           inputTys.emplace_back(genDummyArgType(*arg));
+        } else {
+          // Handle alt-return
+          TODO();
+        }
       }
     } else if (symbol->detailsIf<Fortran::semantics::ProcEntityDetails>()) {
       // TODO Should probably use Fortran::evaluate::Characteristics for that.
       TODO();
+    } else if (symbol->detailsIf<Fortran::semantics::MainProgramDetails>()) {
     } else {
       assert(false && "unexpected symbol details for function");
     }
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index c527d86b127e..8774f027387d 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -39,14 +39,6 @@ moduleNames(const Fortran::semantics::Scope &scope) {
 
 llvm::Optional<llvm::StringRef>
 hostName(const Fortran::semantics::Scope &scope) {
-  //  if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
-  //    auto &parent = scope.parent();
-  //    if (parent.kind() == Fortran::semantics::Scope::Kind::Subprogram)
-  //      if (auto *symbol = parent.symbol()) {
-  //        return {toStringRef(symbol->name())};
-  //      }
-  //  }
-  //  return {};
   if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
     assert(scope.symbol() && "subprogram scope must have a symbol");
     return {toStringRef(scope.symbol()->name())};
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 729cf2a8bf8c..735d5bc2e00e 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -865,6 +865,34 @@ static pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
       &std::get<parser::Statement<A>>(mod.t)};
 }
 
+static const semantics::Symbol *
+getSymbol(std::optional<pft::FunctionLikeUnit::FunctionStatement> &beginStmt) {
+  if (!beginStmt)
+    return nullptr;
+
+  const auto *symbol = std::visit(
+      common::visitors{
+          [](const parser::Statement<parser::ProgramStmt> *stmt)
+              -> const semantics::Symbol * { return stmt->statement.v.symbol; },
+          [](const parser::Statement<parser::FunctionStmt> *stmt)
+              -> const semantics::Symbol * {
+            return std::get<parser::Name>(stmt->statement.t).symbol;
+          },
+          [](const parser::Statement<parser::SubroutineStmt> *stmt)
+              -> const semantics::Symbol * {
+            return std::get<parser::Name>(stmt->statement.t).symbol;
+          },
+          [](const parser::Statement<parser::MpSubprogramStmt> *stmt)
+              -> const semantics::Symbol * { return stmt->statement.v.symbol; },
+          [](const auto *) -> const semantics::Symbol * {
+            assert(false && "unknown FunctionLike beginStmt");
+            return nullptr;
+          }},
+      *beginStmt);
+  assert(symbol && "parser::Name must have resolved symbol");
+  return symbol;
+}
+
 llvm::cl::opt<bool> clDisableStructuredFir(
     "no-structured-fir", llvm::cl::desc("disable generation of structured FIR"),
     llvm::cl::init(false), llvm::cl::Hidden);
@@ -877,6 +905,18 @@ bool pft::Evaluation::lowerAsUnstructured() const {
   return isUnstructured || clDisableStructuredFir;
 }
 
+pft::FunctionLikeUnit *pft::Evaluation::getOwningProcedure() const {
+  return std::visit(
+      Fortran::common::visitors{
+          [](Fortran::lower::pft::FunctionLikeUnit *c) { return c; },
+          [&](Fortran::lower::pft::Evaluation *c) {
+            return c->getOwningProcedure();
+          },
+          [](auto *) -> pft::FunctionLikeUnit * { return nullptr; },
+      },
+      parentVariant.p);
+}
+
 pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
                                         const pft::ParentVariant &parent)
     : ProgramUnit{func, parent} {
@@ -885,6 +925,7 @@ pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
   if (ps.has_value()) {
     const parser::Statement<parser::ProgramStmt> &statement{ps.value()};
     beginStmt = &statement;
+    symbol = getSymbol(beginStmt);
   }
   endStmt = getFunctionStmt<parser::EndProgramStmt>(func);
 }
@@ -893,20 +934,24 @@ pft::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,
                                         const pft::ParentVariant &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::FunctionStmt>(func)},
-      endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)} {}
+      endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)}, symbol{getSymbol(
+                                                                   beginStmt)} {
+}
 
 pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::SubroutineSubprogram &func, const pft::ParentVariant &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::SubroutineStmt>(func)},
-      endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)} {}
+      endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)},
+      symbol{getSymbol(beginStmt)} {}
 
 pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::SeparateModuleSubprogram &func,
     const pft::ParentVariant &parent)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
-      endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {}
+      endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)},
+      symbol{getSymbol(beginStmt)} {}
 
 pft::ModuleLikeUnit::ModuleLikeUnit(const parser::Module &m,
                                     const pft::ParentVariant &parent)
diff --git a/test/Lower/program-units-fir-mangling.f90 b/test/Lower/program-units-fir-mangling.f90
index d96a7c4b40af..b7bc7bcbfc55 100644
--- a/test/Lower/program-units-fir-mangling.f90
+++ b/test/Lower/program-units-fir-mangling.f90
@@ -1,11 +1,11 @@
-! RUN: bbc %s -emit-fir | FileCheck %s
+! RUN: bbc %s -o "-" -emit-fir | FileCheck %s
 
-!CHECK: func @_QPsub() {
+! CHECK-LABEL: func @_QPsub() {
 subroutine sub()
 ! CHECK: }
 end subroutine
 
-!CHECK: func @_QPasubroutine() {
+! CHECK-LABEL: func @_QPasubroutine() {
 subroutine AsUbRoUtInE()
 ! CHECK: }
 end subroutine
@@ -18,7 +18,7 @@ function foo()
 
 module testMod
 contains
-  !CHECK: func @_QMtestmodPsub() {
+  ! CHECK-LABEL: func @_QMtestmodPsub() {
   subroutine sub()
   ! CHECK: }
   end subroutine
@@ -31,28 +31,30 @@ function foo()
 end module
 
 
+! CHECK-LABEL: func @_QPfoo2()
 function foo2()
   real(4) :: foo2
 contains
-  !CHECK: func @_QFfoo2Psub() {
+  ! CHECK-LABEL: func @_QFfoo2Psub() {
   subroutine sub()
   ! CHECK: }
   end subroutine
 
-  !CHECK: func @_QFfoo2Pfoo() {
+  ! CHECK-LABEL: func @_QFfoo2Pfoo() {
   subroutine foo()
   ! CHECK: }
   end subroutine
 end function
 
+! CHECK-LABEL: func @_QPsub2()
 subroutine sUb2()
 contains
-  !CHECK: func @_QFsub2Psub() {
+  ! CHECK-LABEL: func @_QFsub2Psub() {
   subroutine sub()
   ! CHECK: }
   end subroutine
 
-  !CHECK: func @_QFsub2Pfoo() {
+  ! CHECK-LABEL: func @_QFsub2Pfoo() {
   subroutine Foo()
   ! CHECK: }
   end subroutine
@@ -60,9 +62,10 @@ subroutine Foo()
 
 module testMod2
 contains
+  ! CHECK-LABEL: func @_QMtestmod2Psub()
   subroutine sub()
   contains
-    !CHECK: func @_QMtestmod2FsubPsubsub() {
+    ! CHECK-LABEL: func @_QMtestmod2FsubPsubsub() {
     subroutine subSub()
     ! CHECK: }
     end subroutine
@@ -82,7 +85,7 @@ end module color_points
 
 submodule (color_points) color_points_a
 contains
-  !CHECK: func @_QMcolor_pointsScolor_points_aPsub() {
+  ! CHECK-LABEL: func @_QMcolor_pointsScolor_points_aPsub() {
   subroutine sub
   end subroutine
   ! CHECK: }
@@ -90,14 +93,15 @@ subroutine sub
 
 submodule (color_points:color_points_a) impl
 contains
+  ! CHECK-LABEL: func @_QMcolor_pointsScolor_points_aSimplPfoo()
   subroutine foo
     contains
-    !CHECK: func @_QMcolor_pointsScolor_points_aSimplFfooPbar() {
+    ! CHECK-LABEL: func @_QMcolor_pointsScolor_points_aSimplFfooPbar() {
     subroutine bar
     ! CHECK: }
     end subroutine
   end subroutine
-  !CHECK: func @_QMcolor_pointsPdraw() {
+  ! CHECK-LABEL: func @_QMcolor_pointsPdraw() {
   module subroutine draw()
   end subroutine
   !FIXME func @_QMcolor_pointsPerase() -> i32 {
@@ -107,7 +111,7 @@ module subroutine draw()
 end submodule
 
 
-! CHECK: func @MAIN_() {
+! CHECK-LABEL: func @MAIN_() {
 program test
 ! CHECK: }
 end program
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index c4121baaa010..c629290a5aed 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -56,12 +56,8 @@ static llvm::cl::opt<std::string> inputFilename(llvm::cl::Positional,
                                                 llvm::cl::desc("<input file>"));
 
 static llvm::cl::opt<std::string>
-    outputFilename("o", llvm::cl::desc("Specify the FIR output filename"),
-                   llvm::cl::value_desc("filename"), llvm::cl::init("-"));
-
-static llvm::cl::opt<std::string> LLVMOutputFilename(
-    "ll-file", llvm::cl::desc("Specify the LLVM IR output filename"),
-    llvm::cl::value_desc("filename"), llvm::cl::init("a.mlir.ll"));
+    outputFilename("o", llvm::cl::desc("Specify the output filename"),
+                   llvm::cl::value_desc("filename"), llvm::cl::init("a.mlir"));
 
 static llvm::cl::list<std::string>
     includeDirs("I", llvm::cl::desc("include search paths"));
@@ -199,10 +195,10 @@ static void convertFortranSourceToMLIR(
     // Continue to lower from MLIR down to LLVM IR. Emit LLVM and MLIR.
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
     std::error_code ec;
-    llvm::ToolOutputFile outFile(LLVMOutputFilename + ".ll", ec,
+    llvm::ToolOutputFile outFile(outputFilename + ".ll", ec,
                                  llvm::sys::fs::OF_None);
     if (ec) {
-      llvm::errs() << "can't open output file " + LLVMOutputFilename + ".ll";
+      llvm::errs() << "can't open output file " + outputFilename + ".ll";
       return;
     }
     pm.addPass(fir::createLLVMDialectToLLVMPass(outFile.os()));

From f159355fb3768d1a41cf10cff862c8bdef477f84 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Mon, 23 Mar 2020 14:09:27 -0700
Subject: [PATCH 262/345] [front-end changes] add HasAlternateReturns helper

---
 include/flang/Semantics/tools.h |  2 ++
 lib/Semantics/tools.cpp         | 10 ++++++++++
 2 files changed, 12 insertions(+)

diff --git a/include/flang/Semantics/tools.h b/include/flang/Semantics/tools.h
index e6a3a2eb53f1..0493ca4dd340 100644
--- a/include/flang/Semantics/tools.h
+++ b/include/flang/Semantics/tools.h
@@ -109,6 +109,8 @@ bool CanBeTypeBoundProc(const Symbol *);
 bool IsInitialized(const Symbol &);
 bool HasIntrinsicTypeName(const Symbol &);
 bool IsSeparateModuleProcedureInterface(const Symbol *);
+// Given a subroutine symbol, tells if the subroutine has alternate returns
+bool HasAlternateReturns(const Symbol &);
 
 // Return an ultimate component of type that matches predicate, or nullptr.
 const Symbol *FindUltimateComponent(const DerivedTypeSpec &type,
diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index 249dcb27b65a..0c7a6d96be67 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -1356,4 +1356,14 @@ void LabelEnforce::SayWithConstruct(SemanticsContext &context,
   context.Say(stmtLocation, message)
       .Attach(constructLocation, GetEnclosingConstructMsg());
 }
+
+bool HasAlternateReturns(const Symbol &sub) {
+  for (const auto *args : sub.get<SubprogramDetails>().dummyArgs()) {
+    if (!args) {
+      return true;
+    }
+  }
+  return false;
+}
+
 } // namespace Fortran::semantics

From ab359e4cee54a04baa4261e188d4f8a1ea2a1b38 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 24 Mar 2020 10:32:55 -0700
Subject: [PATCH 263/345] Clean-up in PFT, fixing analyzeIoBranches

---
 include/flang/Lower/Bridge.h     |   2 +-
 include/flang/Lower/Mangler.h    |   4 +-
 include/flang/Lower/PFTBuilder.h | 166 +++++++++---------
 lib/Lower/Bridge.cpp             |   9 +-
 lib/Lower/Mangler.cpp            |  49 +++---
 lib/Lower/PFTBuilder.cpp         | 292 +++++++++++++++----------------
 6 files changed, 258 insertions(+), 264 deletions(-)

diff --git a/include/flang/Lower/Bridge.h b/include/flang/Lower/Bridge.h
index e62eb465950a..213021622501 100644
--- a/include/flang/Lower/Bridge.h
+++ b/include/flang/Lower/Bridge.h
@@ -115,7 +115,7 @@ class AbstractConverter {
   /// Get the ModuleOp
   virtual mlir::ModuleOp &getModuleOp() = 0;
   /// Unique a symbol
-  virtual std::string mangleName(SymbolRef) = 0;
+  virtual std::string mangleName(const semantics::Symbol &) = 0;
 
   virtual ~AbstractConverter() = default;
 };
diff --git a/include/flang/Lower/Mangler.h b/include/flang/Lower/Mangler.h
index 2ee47d3adf99..b13b51355c81 100644
--- a/include/flang/Lower/Mangler.h
+++ b/include/flang/Lower/Mangler.h
@@ -30,12 +30,10 @@ class Symbol;
 }
 
 namespace lower {
-using SymbolRef = common::Reference<const semantics::Symbol>;
-
 namespace mangle {
 
 /// Convert a front-end Symbol to an internal name
-std::string mangleName(fir::NameUniquer &uniquer, const SymbolRef symbol);
+std::string mangleName(fir::NameUniquer &uniquer, const semantics::Symbol &);
 
 std::string demangleName(llvm::StringRef name);
 
diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index a0d57c273185..865f5d6d5417 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -13,6 +13,7 @@
 #ifndef FORTRAN_LOWER_PFTBUILDER_H
 #define FORTRAN_LOWER_PFTBUILDER_H
 
+#include "flang/Common/reference.h"
 #include "flang/Common/template.h"
 #include "flang/Parser/parse-tree.h"
 #include "llvm/ADT/DenseMap.h"
@@ -115,54 +116,81 @@ static constexpr bool isFunctionLike{common::HasMember<
                   parser::SeparateModuleSubprogram>>};
 
 using LabelSet = llvm::SmallSet<parser::Label, 5>;
-using SymbolLabelMap = std::map<semantics::Symbol *, LabelSet>;
-
-/// Function-like units contain lists of evaluations.  These can be simple
-/// statements or constructs, where a construct contains its own evaluations.
-struct Evaluation {
-  using EvaluationTuple = common::CombineTuples<ActionStmts, OtherStmts,
-                                                ConstructStmts, Constructs>;
-
-  /// Hide non-nullable pointers to the parse-tree node.
-  /// Build type std::variant<const A* const, const B* const, ...>
-  /// from EvaluationTuple type (std::tuple<A, B, ...>).
-  template <typename A>
-  using MakeRefType = const A *const;
-  using EvaluationVariant = common::CombineVariants<
-      common::MapTemplate<MakeRefType, EvaluationTuple>>;
-  template <typename A>
-  constexpr auto visit(A visitor) const {
-    return std::visit(common::visitors{
-                          [&](const auto *p) { return visitor(*p); },
-                          [&](auto &r) { return visitor(r); },
-                      },
-                      u);
+using SymbolLabelMap = llvm::DenseMap<const semantics::Symbol *, LabelSet>;
+
+/// Provide a variant like container that can holds constant references.
+/// It is used in the other classes to provide union of const references
+/// to parse-tree nodes.
+template <typename... A>
+class ReferenceVariant {
+public:
+  template <typename B>
+  using ConstRef = common::Reference<const B>;
+
+  ReferenceVariant() = delete;
+  template <typename B>
+  ReferenceVariant(const B &b) : u{ConstRef<B>{b}} {};
+
+  template <typename B>
+  constexpr const B &get() const {
+    return std::get<ConstRef<B>> > (u).get();
   }
-  template <typename A>
-  constexpr const A *getIf() const {
-    auto *ptr = std::get_if<MakeRefType<A>>(&u);
-    return ptr ? *ptr : nullptr;
+  template <typename B>
+  constexpr const B *getIf() const {
+    auto *ptr = std::get_if<ConstRef<B>>(&u);
+    return ptr ? &ptr->get() : nullptr;
   }
-  template <typename A>
+  template <typename B>
   constexpr bool isA() const {
-    return std::holds_alternative<MakeRefType<A>>(u);
+    return std::holds_alternative<ConstRef<B>>(u);
   }
+  template <typename VISITOR>
+  constexpr auto visit(VISITOR &&visitor) const {
+    return std::visit(
+        common::visitors{[&visitor](auto ref) { return visitor(ref.get()); }},
+        u);
+  }
+
+private:
+  std::variant<ConstRef<A>...> u;
+};
 
-  Evaluation() = delete;
-  Evaluation(const Evaluation &) = delete;
-  Evaluation(Evaluation &&) = default;
+template <typename A>
+struct MakeReferenceVariantHelper {};
+template <typename... A>
+struct MakeReferenceVariantHelper<std::variant<A...>> {
+  using type = ReferenceVariant<A...>;
+};
+template <typename... A>
+struct MakeReferenceVariantHelper<std::tuple<A...>> {
+  using type = ReferenceVariant<A...>;
+};
+template <typename A>
+using MakeReferenceVariant = typename MakeReferenceVariantHelper<A>::type;
+
+using EvaluationTuple =
+    common::CombineTuples<ActionStmts, OtherStmts, ConstructStmts, Constructs>;
+/// Hide non-nullable pointers to the parse-tree node.
+/// Build type std::variant<const A* const, const B* const, ...>
+/// from EvaluationTuple type (std::tuple<A, B, ...>).
+using EvaluationVariant = MakeReferenceVariant<EvaluationTuple>;
+
+/// Function-like units contain lists of evaluations.  These can be simple
+/// statements or constructs, where a construct contains its own evaluations.
+struct Evaluation : EvaluationVariant {
 
   /// General ctor
   template <typename A>
   Evaluation(const A &a, const ParentVariant &parentVariant,
              const parser::CharBlock &position,
              const std::optional<parser::Label> &label)
-      : u{&a}, parentVariant{parentVariant}, position{position}, label{label} {}
+      : EvaluationVariant{a},
+        parentVariant{parentVariant}, position{position}, label{label} {}
 
   /// Construct ctor
   template <typename A>
   Evaluation(const A &a, const ParentVariant &parentVariant)
-      : u{&a}, parentVariant{parentVariant} {
+      : EvaluationVariant{a}, parentVariant{parentVariant} {
     static_assert(pft::isConstruct<A>, "must be a construct");
   }
 
@@ -236,7 +264,6 @@ struct Evaluation {
   // The printIndex member is only set for statements.  It is used for dumps
   // and does not affect FIR generation.  It may also be helpful for debugging.
 
-  EvaluationVariant u;
   ParentVariant parentVariant;
   parser::CharBlock position{};
   std::optional<parser::Label> label{};
@@ -253,21 +280,20 @@ struct Evaluation {
   int printIndex{0}; // (ActionStmt, ConstructStmt) evaluation index for dumps
 };
 
+using ProgramVariant =
+    ReferenceVariant<parser::MainProgram, parser::FunctionSubprogram,
+                     parser::SubroutineSubprogram, parser::Module,
+                     parser::Submodule, parser::SeparateModuleSubprogram,
+                     parser::BlockData>;
 /// A program is a list of program units.
 /// These units can be function like, module like, or block data.
-struct ProgramUnit {
+struct ProgramUnit : ProgramVariant {
   template <typename A>
-  ProgramUnit(const A &ptr, const ParentVariant &parentVariant)
-      : p{&ptr}, parentVariant{parentVariant} {}
+  ProgramUnit(const A &p, const ParentVariant &parentVariant)
+      : ProgramVariant{p}, parentVariant{parentVariant} {}
   ProgramUnit(ProgramUnit &&) = default;
   ProgramUnit(const ProgramUnit &) = delete;
 
-  const std::variant<
-      const parser::MainProgram *, const parser::FunctionSubprogram *,
-      const parser::SubroutineSubprogram *, const parser::Module *,
-      const parser::Submodule *, const parser::SeparateModuleSubprogram *,
-      const parser::BlockData *>
-      p;
   ParentVariant parentVariant;
 };
 
@@ -276,14 +302,14 @@ struct ProgramUnit {
 struct FunctionLikeUnit : public ProgramUnit {
   // wrapper statements for function-like syntactic structures
   using FunctionStatement =
-      std::variant<const parser::Statement<parser::ProgramStmt> *,
-                   const parser::Statement<parser::EndProgramStmt> *,
-                   const parser::Statement<parser::FunctionStmt> *,
-                   const parser::Statement<parser::EndFunctionStmt> *,
-                   const parser::Statement<parser::SubroutineStmt> *,
-                   const parser::Statement<parser::EndSubroutineStmt> *,
-                   const parser::Statement<parser::MpSubprogramStmt> *,
-                   const parser::Statement<parser::EndMpSubprogramStmt> *>;
+      ReferenceVariant<parser::Statement<parser::ProgramStmt>,
+                       parser::Statement<parser::EndProgramStmt>,
+                       parser::Statement<parser::FunctionStmt>,
+                       parser::Statement<parser::EndFunctionStmt>,
+                       parser::Statement<parser::SubroutineStmt>,
+                       parser::Statement<parser::EndSubroutineStmt>,
+                       parser::Statement<parser::MpSubprogramStmt>,
+                       parser::Statement<parser::EndMpSubprogramStmt>>;
 
   FunctionLikeUnit(const parser::MainProgram &f,
                    const ParentVariant &parentVariant);
@@ -296,25 +322,8 @@ struct FunctionLikeUnit : public ProgramUnit {
   FunctionLikeUnit(FunctionLikeUnit &&) = default;
   FunctionLikeUnit(const FunctionLikeUnit &) = delete;
 
-  bool isMainProgram() {
-    return std::holds_alternative<
-        const parser::Statement<parser::EndProgramStmt> *>(endStmt);
-  }
-
-  const parser::FunctionStmt *getFunction() {
-    return getA<parser::FunctionStmt>();
-  }
-  const parser::SubroutineStmt *getSubroutine() {
-    return getA<parser::SubroutineStmt>();
-  }
-  const parser::MpSubprogramStmt *getMpSubprogram() {
-    return getA<parser::MpSubprogramStmt>();
-  }
-
   bool isMainProgram() const {
-    return !beginStmt ||
-           std::holds_alternative<
-               const parser::Statement<parser::ProgramStmt> *>(*beginStmt);
+    return endStmt.isA<parser::Statement<parser::EndProgramStmt>>();
   }
 
   /// Returns reference to the subprogram symbol of this FunctionLikeUnit.
@@ -336,27 +345,16 @@ struct FunctionLikeUnit : public ProgramUnit {
   /// The symbol has MainProgramDetails for named programs, otherwise it has
   /// SubprogramDetails.
   const semantics::Symbol *symbol{nullptr};
-
-private:
-  template <typename A>
-  const A *getA() {
-    if (beginStmt) {
-      if (auto p =
-              std::get_if<const parser::Statement<A> *>(&beginStmt.value()))
-        return &(*p)->statement;
-    }
-    return nullptr;
-  }
 };
 
 /// Module-like units contain a list of function-like units.
 struct ModuleLikeUnit : public ProgramUnit {
   // wrapper statements for module-like syntactic structures
   using ModuleStatement =
-      std::variant<const parser::Statement<parser::ModuleStmt> *,
-                   const parser::Statement<parser::EndModuleStmt> *,
-                   const parser::Statement<parser::SubmoduleStmt> *,
-                   const parser::Statement<parser::EndSubmoduleStmt> *>;
+      ReferenceVariant<parser::Statement<parser::ModuleStmt>,
+                       parser::Statement<parser::EndModuleStmt>,
+                       parser::Statement<parser::SubmoduleStmt>,
+                       parser::Statement<parser::EndSubmoduleStmt>>;
 
   ModuleLikeUnit(const parser::Module &m, const ParentVariant &parentVariant);
   ModuleLikeUnit(const parser::Submodule &m,
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 6303377578d1..9e4de3a205b9 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -179,7 +179,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   mlir::ModuleOp &getModuleOp() override final { return module; }
 
-  std::string mangleName(Fortran::lower::SymbolRef symbol) override final {
+  std::string
+  mangleName(const Fortran::semantics::Symbol &symbol) override final {
     return Fortran::lower::mangle::mangleName(uniquer, symbol);
   }
 
@@ -278,7 +279,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   void genFIRProcedureExit(const Fortran::semantics::Symbol &symbol) {
     const auto &details = symbol.get<Fortran::semantics::SubprogramDetails>();
-    if (details.isFunction()) {
+    if (Fortran::semantics::IsFunction(symbol)) {
       mlir::Value resultRef = localSymbols.lookupSymbol(details.result());
       mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
       builder->create<mlir::ReturnOp>(toLocation(), r);
@@ -1167,7 +1168,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                           ? eval.evaluationList->front().block
                           : eval.block);
     }
-    std::visit([&](const auto *p) { genFIR(eval, *p); }, eval.u);
+    eval.visit([&](const auto &stmt) { genFIR(eval, stmt); });
     if (unstructuredContext && eval.lowerAsUnstructured() &&
         eval.controlSuccessor && eval.isActionStmt() && blockIsUnterminated()) {
       // Exit from an unstructured IF or SELECT construct block.
@@ -1277,7 +1278,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   /// Helper to get location from FunctionLikeUnit begin/end
   static Fortran::parser::CharBlock extractLocation(
       Fortran::lower::pft::FunctionLikeUnit::FunctionStatement &fstmt) {
-    return std::visit([](const auto *stmt) { return stmt->source; }, fstmt);
+    return fstmt.visit([](const auto &stmt) { return stmt.source; });
   }
 
   /// Emit return and cleanup after the function has been translated.
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index 8774f027387d..ba916e7f0ea3 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -31,14 +31,16 @@ void moduleNames(const Fortran::semantics::Scope &scope,
 }
 
 llvm::SmallVector<llvm::StringRef, 2>
-moduleNames(const Fortran::semantics::Scope &scope) {
+moduleNames(const Fortran::semantics::Symbol &symbol) {
+  const auto &scope{symbol.owner()};
   llvm::SmallVector<llvm::StringRef, 2> result;
   moduleNames(scope, result);
   return result;
 }
 
 llvm::Optional<llvm::StringRef>
-hostName(const Fortran::semantics::Scope &scope) {
+hostName(const Fortran::semantics::Symbol &symbol) {
+  const auto &scope{symbol.owner()};
   if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
     assert(scope.symbol() && "subprogram scope must have a symbol");
     return {toStringRef(scope.symbol()->name())};
@@ -48,39 +50,46 @@ hostName(const Fortran::semantics::Scope &scope) {
 
 } // namespace
 
+static const Fortran::semantics::Symbol *
+findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
+  const auto &scope{symbol.owner()};
+  if (symbol.attrs().test(Fortran::semantics::Attr::MODULE) &&
+      scope.IsSubmodule()) {
+    // FIXME symbol from MpSubprogramStmt do not seem to have
+    // Attr::MODULE set.
+    const auto *iface{scope.parent().FindSymbol(symbol.name())};
+    assert(iface && "Separate module proc must be declared");
+    return iface;
+  }
+  return nullptr;
+}
+
 // Mangle the name of `symbol` to make it unique within FIR's symbol table using
 // the FIR name mangler, `mangler`
 std::string
 Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
-                                   const Fortran::semantics::SymbolRef symbol) {
+                                   const Fortran::semantics::Symbol &symbol) {
   return std::visit(
       Fortran::common::visitors{
           [&](const Fortran::semantics::MainProgramDetails &) {
             return uniquer.doProgramEntry().str();
           },
           [&](const Fortran::semantics::SubprogramDetails &) {
-            const auto *scope{&symbol->owner()};
-            auto &symbolName{symbol->name()};
+            auto &symbolName{symbol.name()};
             // Separate module subprograms must be mangled according to the
             // scope where they were declared (the symbol we have is the
             // definition).
-            if (symbol->attrs().test(Fortran::semantics::Attr::MODULE) &&
-                scope->IsSubmodule()) {
-              // FIXME symbol from MpSubprogramStmt do not seem to have
-              // Attr::MODULE set.
-              const auto *iface{scope->parent().FindSymbol(symbolName)};
-              assert(iface && "Separate module proc must be declared");
-              scope = &iface->owner();
-            }
-            auto modNames{moduleNames(*scope)};
-            return uniquer.doProcedure(modNames, hostName(*scope),
+            const auto *interface = &symbol;
+            if (const auto *mpIface = findInterfaceIfSeperateMP(symbol))
+              interface = mpIface;
+            auto modNames{moduleNames(*interface)};
+            return uniquer.doProcedure(modNames, hostName(*interface),
                                        toStringRef(symbolName));
           },
           [&](const Fortran::semantics::ProcEntityDetails &) {
-            const auto &scope{symbol->owner()};
-            auto &cb{symbol->name()};
-            auto modNames{moduleNames(scope)};
-            return uniquer.doProcedure(modNames, hostName(scope),
+            auto &cb{symbol.name()};
+            auto modNames{moduleNames(symbol)};
+            return uniquer.doProcedure(modNames, hostName(symbol),
                                        toStringRef(cb));
           },
           [](const auto &) -> std::string {
@@ -88,7 +97,7 @@ Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
             return {};
           },
       },
-      symbol->details());
+      symbol.details());
 }
 
 std::string Fortran::lower::mangle::demangleName(llvm::StringRef name) {
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 735d5bc2e00e..50ab72b86124 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -168,7 +168,7 @@ class PFTBuilder {
 
   void exitModule() {
     parentVariantStack.pop_back();
-    ResetFunctionList();
+    resetFunctionList();
   }
 
   /// Initialize a new function-like unit and make it the builder's focus.
@@ -195,7 +195,7 @@ class PFTBuilder {
     labelEvaluationMap = nullptr;
     assignSymbolLabelMap = nullptr;
     parentVariantStack.pop_back();
-    ResetFunctionList();
+    resetFunctionList();
   }
 
   /// Initialize a new construct and make it the builder's focus.
@@ -217,7 +217,7 @@ class PFTBuilder {
   }
 
   /// Reset functionList to an enclosing function's functionList.
-  void ResetFunctionList() {
+  void resetFunctionList() {
     if (!parentVariantStack.empty()) {
       std::visit(common::visitors{
                      [&](pft::FunctionLikeUnit *p) {
@@ -302,48 +302,49 @@ class PFTBuilder {
 
   /// Mark I/O statement ERR, EOR, and END specifier branch targets.
   template <typename A>
-  constexpr void analyzeIoBranches(pft::Evaluation &eval, const A &stmt) {
+  void analyzeIoBranches(pft::Evaluation &eval, const A &stmt) {
+    auto processIfLabel{[&](const auto &specs) {
+      using LableNodes =
+          std::tuple<parser::ErrLabel, parser::EorLabel, parser::EndLabel>;
+      for (const auto &spec : specs) {
+        const auto *label = std::visit(
+            [](const auto &label) -> const parser::Label * {
+              using B = std::decay_t<decltype(label)>;
+              if constexpr (common::HasMember<B, LableNodes>) {
+                return &label.v;
+              }
+              return nullptr;
+            },
+            spec.u);
+
+        if (label)
+          markBranchTarget(eval, *label);
+      }
+    }};
+
+    using OtherIOStmts =
+        std::tuple<parser::BackspaceStmt, parser::CloseStmt,
+                   parser::EndfileStmt, parser::FlushStmt, parser::OpenStmt,
+                   parser::RewindStmt, parser::WaitStmt>;
+
     if constexpr (std::is_same_v<A, parser::ReadStmt> ||
                   std::is_same_v<A, parser::WriteStmt>) {
-      for (const auto &control : stmt.controls) {
-        if (std::holds_alternative<parser::ErrLabel>(control.u) ||
-            std::holds_alternative<parser::EorLabel>(control.u) ||
-            std::holds_alternative<parser::EndLabel>(control.u)) {
-          markBranchTarget(eval, stmt->v);
-        }
-      }
-    }
-    if constexpr (std::is_same_v<A, parser::WaitStmt> ||
-                  std::is_same_v<A, parser::OpenStmt> ||
-                  std::is_same_v<A, parser::CloseStmt> ||
-                  std::is_same_v<A, parser::BackspaceStmt> ||
-                  std::is_same_v<A, parser::EndfileStmt> ||
-                  std::is_same_v<A, parser::RewindStmt> ||
-                  std::is_same_v<A, parser::FlushStmt>) {
-      for (const auto &spec : stmt.v) {
-        if (std::holds_alternative<parser::ErrLabel>(spec.u) ||
-            std::holds_alternative<parser::EorLabel>(spec.u) ||
-            std::holds_alternative<parser::EndLabel>(spec.u)) {
-          markBranchTarget(eval, stmt->v);
-        }
-      }
-    }
-    if constexpr (std::is_same_v<A, parser::InquireStmt>) {
-      for (const auto &spec :
-           std::get<std::list<parser::InquireSpec>>(stmt.u)) {
-        if (std::holds_alternative<parser::ErrLabel>(spec.u) ||
-            std::holds_alternative<parser::EorLabel>(spec.u) ||
-            std::holds_alternative<parser::EndLabel>(spec.u)) {
-          markBranchTarget(eval, stmt->v);
-        }
-      }
+      processIfLabel(stmt.controls);
+    } else if constexpr (std::is_same_v<A, parser::InquireStmt>) {
+      processIfLabel(std::get<std::list<parser::InquireSpec>>(stmt.u));
+    } else if constexpr (common::HasMember<A, OtherIOStmts>) {
+      processIfLabel(stmt.v);
+    } else {
+      // Always crash if this is instantiated
+      static_assert(!std::is_same_v<A, parser::ReadStmt>,
+                    "Unexpected IO statement");
     }
   }
 
   /// Set the exit of a construct, possibly from multiple enclosing constructs.
   void setConstructExit(pft::Evaluation &eval) {
     eval.constructExit = eval.evaluationList->back().lexicalSuccessor;
-    if (eval.constructExit->isNopConstructStmt()) {
+    if (eval.constructExit && eval.constructExit->isNopConstructStmt()) {
       eval.constructExit = eval.constructExit->parentConstruct->constructExit;
     }
     assert(eval.constructExit && "missing construct exit");
@@ -369,7 +370,7 @@ class PFTBuilder {
   /// from one or more enclosing constructs.
   pft::Evaluation *exitSuccessor(pft::Evaluation &eval) {
     pft::Evaluation *successor{eval.lexicalSuccessor};
-    if (successor->isNopConstructStmt()) {
+    if (successor && successor->isNopConstructStmt()) {
       successor = successor->parentConstruct->constructExit;
     }
     assert(successor && "missing exit successor");
@@ -383,51 +384,43 @@ class PFTBuilder {
 
   template <typename A>
   inline std::string getConstructName(const A &stmt) {
-    if constexpr (std::is_same_v<A, parser::BlockStmt *> ||
-                  std::is_same_v<A, const parser::CycleStmt *> ||
-                  std::is_same_v<A, const parser::ElseStmt *> ||
-                  std::is_same_v<A, const parser::ElsewhereStmt *> ||
-                  std::is_same_v<A, const parser::EndAssociateStmt *> ||
-                  std::is_same_v<A, const parser::EndBlockStmt *> ||
-                  std::is_same_v<A, const parser::EndCriticalStmt *> ||
-                  std::is_same_v<A, const parser::EndDoStmt *> ||
-                  std::is_same_v<A, const parser::EndForallStmt *> ||
-                  std::is_same_v<A, const parser::EndIfStmt *> ||
-                  std::is_same_v<A, const parser::EndSelectStmt *> ||
-                  std::is_same_v<A, const parser::EndWhereStmt *> ||
-                  std::is_same_v<A, const parser::ExitStmt *>) {
-      if (stmt->v) {
-        return stmt->v->ToString();
-      }
+    using MaybeConstructNameWrapper =
+        std::tuple<parser::BlockStmt, parser::CycleStmt, parser::ElseStmt,
+                   parser::ElsewhereStmt, parser::EndAssociateStmt,
+                   parser::EndBlockStmt, parser::EndCriticalStmt,
+                   parser::EndDoStmt, parser::EndForallStmt, parser::EndIfStmt,
+                   parser::EndSelectStmt, parser::EndWhereStmt,
+                   parser::ExitStmt>;
+    if constexpr (common::HasMember<A, MaybeConstructNameWrapper>) {
+      if (stmt.v)
+        return stmt.v->ToString();
     }
-    if constexpr (std::is_same_v<A, const parser::AssociateStmt *> ||
-                  std::is_same_v<A, const parser::CaseStmt *> ||
-                  std::is_same_v<A, const parser::ChangeTeamStmt *> ||
-                  std::is_same_v<A, const parser::CriticalStmt *> ||
-                  std::is_same_v<A, const parser::ElseIfStmt *> ||
-                  std::is_same_v<A, const parser::EndChangeTeamStmt *> ||
-                  std::is_same_v<A, const parser::ForallConstructStmt *> ||
-                  std::is_same_v<A, const parser::IfThenStmt *> ||
-                  std::is_same_v<A, const parser::LabelDoStmt *> ||
-                  std::is_same_v<A, const parser::MaskedElsewhereStmt *> ||
-                  std::is_same_v<A, const parser::NonLabelDoStmt *> ||
-                  std::is_same_v<A, const parser::SelectCaseStmt *> ||
-                  std::is_same_v<A, const parser::SelectRankCaseStmt *> ||
-                  std::is_same_v<A, const parser::TypeGuardStmt *> ||
-                  std::is_same_v<A, const parser::WhereConstructStmt *>) {
-      if (auto name{std::get<std::optional<parser::Name>>(stmt->t)}) {
+
+    using MaybeConstructNameInTuple = std::tuple<
+        parser::AssociateStmt, parser::CaseStmt, parser::ChangeTeamStmt,
+        parser::CriticalStmt, parser::ElseIfStmt, parser::EndChangeTeamStmt,
+        parser::ForallConstructStmt, parser::IfThenStmt, parser::LabelDoStmt,
+        parser::MaskedElsewhereStmt, parser::NonLabelDoStmt,
+        parser::SelectCaseStmt, parser::SelectRankCaseStmt,
+        parser::TypeGuardStmt, parser::WhereConstructStmt>;
+
+    if constexpr (common::HasMember<A, MaybeConstructNameInTuple>) {
+      if (auto name{std::get<std::optional<parser::Name>>(stmt.t)})
         return name->ToString();
-      }
     }
-    if constexpr (std::is_same_v<A, const parser::SelectRankStmt *> ||
-                  std::is_same_v<A, const parser::SelectTypeStmt *>) {
-      if (auto name{std::get<0>(stmt->t)}) {
+
+    // These statements have several std::optional<parser::Name>
+    if constexpr (std::is_same_v<A, parser::SelectRankStmt> ||
+                  std::is_same_v<A, parser::SelectTypeStmt>) {
+      if (auto name{std::get<0>(stmt.t)}) {
         return name->ToString();
       }
     }
     return {};
   }
 
+  /// \p parentConstruct can be null if this statement is at the highest
+  /// level of a program.
   template <typename A>
   void insertConstructName(const A &stmt, pft::Evaluation *parentConstruct) {
     std::string name{getConstructName(stmt)};
@@ -437,6 +430,8 @@ class PFTBuilder {
   }
 
   /// Insert branch links for a list of Evaluations.
+  /// \p parentConstruct can be null if the evaluationList contains the
+  /// top-level statements of a program.
   void analyzeBranches(pft::Evaluation *parentConstruct,
                        std::list<pft::Evaluation> &evaluationList) {
     pft::Evaluation *lastIfConstructEvaluation{nullptr};
@@ -444,7 +439,6 @@ class PFTBuilder {
     for (auto &eval : evaluationList) {
       eval.visit(common::visitors{
           // Action statements
-          [&](const parser::BackspaceStmt &s) { analyzeIoBranches(eval, &s); },
           [&](const parser::CallStmt &s) {
             // Look for alternate return specifiers.
             const auto &args{std::get<std::list<parser::ActualArgSpec>>(s.v.t)};
@@ -456,33 +450,24 @@ class PFTBuilder {
               }
             }
           },
-          [&](const parser::CloseStmt &s) { analyzeIoBranches(eval, &s); },
           [&](const parser::CycleStmt &s) {
-            std::string name{getConstructName(&s)};
+            std::string name{getConstructName(s)};
             pft::Evaluation *construct{name.empty() ? doConstructStack.back()
                                                     : constructNameMap[name]};
             assert(construct && "missing CYCLE construct");
             markBranchTarget(eval, construct->evaluationList->back());
           },
-          [&](const parser::EndfileStmt &s) { analyzeIoBranches(eval, &s); },
           [&](const parser::ExitStmt &s) {
-            std::string name{getConstructName(&s)};
+            std::string name{getConstructName(s)};
             pft::Evaluation *construct{name.empty() ? doConstructStack.back()
                                                     : constructNameMap[name]};
             assert(construct && "missing EXIT construct");
             markBranchTarget(eval, *construct->constructExit);
           },
-          [&](const parser::FlushStmt &s) { analyzeIoBranches(eval, &s); },
           [&](const parser::GotoStmt &s) { markBranchTarget(eval, s.v); },
           [&](const parser::IfStmt &) { lastIfStmtEvaluation = &eval; },
-          [&](const parser::InquireStmt &s) { analyzeIoBranches(eval, &s); },
-          [&](const parser::OpenStmt &s) { analyzeIoBranches(eval, &s); },
-          [&](const parser::ReadStmt &s) { analyzeIoBranches(eval, &s); },
           [&](const parser::ReturnStmt &) { eval.isUnstructured = true; },
-          [&](const parser::RewindStmt &s) { analyzeIoBranches(eval, &s); },
           [&](const parser::StopStmt &) { eval.isUnstructured = true; },
-          [&](const parser::WaitStmt &s) { analyzeIoBranches(eval, &s); },
-          [&](const parser::WriteStmt &s) { analyzeIoBranches(eval, &s); },
           [&](const parser::ComputedGotoStmt &s) {
             for (auto &label : std::get<std::list<parser::Label>>(s.t)) {
               markBranchTarget(eval, label);
@@ -495,10 +480,10 @@ class PFTBuilder {
           },
           [&](const parser::AssignStmt &s) { // legacy label assignment
             auto &label = std::get<parser::Label>(s.t);
-            auto sym = std::get<parser::Name>(s.t).symbol;
+            const auto *sym = std::get<parser::Name>(s.t).symbol;
             assert(sym && "missing AssignStmt symbol");
             pft::Evaluation *t{labelEvaluationMap->find(label)->second};
-            if (!std::get_if<const parser::FormatStmt *const>(&t->u)) {
+            if (!t->isA<parser::FormatStmt>()) {
               markBranchTarget(eval, label);
             }
             auto iter = assignSymbolLabelMap->find(sym);
@@ -519,24 +504,24 @@ class PFTBuilder {
 
           // Construct statements
           [&](const parser::AssociateStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
           },
           [&](const parser::BlockStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
           },
           [&](const parser::SelectCaseStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
             eval.lexicalSuccessor->isNewBlock = true;
           },
           [&](const parser::CaseStmt &) { eval.isNewBlock = true; },
           [&](const parser::ChangeTeamStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
           },
           [&](const parser::CriticalStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
           },
           [&](const parser::NonLabelDoStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
             doConstructStack.push_back(parentConstruct);
             auto &control{std::get<std::optional<parser::LoopControl>>(s.t)};
             // eval.block is the loop preheader block, which will be set
@@ -595,7 +580,7 @@ class PFTBuilder {
             }
           },
           [&](const parser::IfThenStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
             eval.lexicalSuccessor->isNewBlock = true;
             lastIfConstructEvaluation = &eval;
           },
@@ -619,12 +604,12 @@ class PFTBuilder {
             lastIfConstructEvaluation = nullptr;
           },
           [&](const parser::SelectRankStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
             eval.lexicalSuccessor->isNewBlock = true;
           },
           [&](const parser::SelectRankCaseStmt &) { eval.isNewBlock = true; },
           [&](const parser::SelectTypeStmt &s) {
-            insertConstructName(&s, parentConstruct);
+            insertConstructName(s, parentConstruct);
             eval.lexicalSuccessor->isNewBlock = true;
           },
           [&](const parser::TypeGuardStmt &) { eval.isNewBlock = true; },
@@ -649,7 +634,19 @@ class PFTBuilder {
           [&](const parser::SelectRankConstruct &) { setConstructExit(eval); },
           [&](const parser::SelectTypeConstruct &) { setConstructExit(eval); },
 
-          [](const auto &) { /* do nothing */ },
+          [&](const auto &stmt) {
+            using A = std::decay_t<decltype(stmt)>;
+            using IoStmts = std::tuple<parser::BackspaceStmt, parser::CloseStmt,
+                                       parser::EndfileStmt, parser::FlushStmt,
+                                       parser::InquireStmt, parser::OpenStmt,
+                                       parser::ReadStmt, parser::RewindStmt,
+                                       parser::WaitStmt, parser::WriteStmt>;
+            if constexpr (common::HasMember<A, IoStmts>) {
+              analyzeIoBranches(eval, stmt);
+            }
+
+            /* do nothing */
+          },
       });
 
       // Analyze construct evaluations.
@@ -780,33 +777,28 @@ class PFTDumper {
     std::string name{};
     std::string header{};
     if (functionLikeUnit.beginStmt) {
-      std::visit(
-          common::visitors{
-              [&](const parser::Statement<parser::ProgramStmt> *statement) {
-                unitKind = "Program";
-                name = statement->statement.v.ToString();
-              },
-              [&](const parser::Statement<parser::FunctionStmt> *statement) {
-                unitKind = "Function";
-                name =
-                    std::get<parser::Name>(statement->statement.t).ToString();
-                header = statement->source.ToString();
-              },
-              [&](const parser::Statement<parser::SubroutineStmt> *statement) {
-                unitKind = "Subroutine";
-                name =
-                    std::get<parser::Name>(statement->statement.t).ToString();
-                header = statement->source.ToString();
-              },
-              [&](const parser::Statement<parser::MpSubprogramStmt>
-                      *statement) {
-                unitKind = "MpSubprogram";
-                name = statement->statement.v.ToString();
-                header = statement->source.ToString();
-              },
-              [&](auto *) {},
+      functionLikeUnit.beginStmt->visit(common::visitors{
+          [&](const parser::Statement<parser::ProgramStmt> &statement) {
+            unitKind = "Program";
+            name = statement.statement.v.ToString();
+          },
+          [&](const parser::Statement<parser::FunctionStmt> &statement) {
+            unitKind = "Function";
+            name = std::get<parser::Name>(statement.statement.t).ToString();
+            header = statement.source.ToString();
           },
-          *functionLikeUnit.beginStmt);
+          [&](const parser::Statement<parser::SubroutineStmt> &statement) {
+            unitKind = "Subroutine";
+            name = std::get<parser::Name>(statement.statement.t).ToString();
+            header = statement.source.ToString();
+          },
+          [&](const parser::Statement<parser::MpSubprogramStmt> &statement) {
+            unitKind = "MpSubprogram";
+            name = statement.statement.v.ToString();
+            header = statement.source.ToString();
+          },
+          [&](const auto &) {},
+      });
     } else {
       unitKind = "Program";
       name = "<anonymous>";
@@ -856,13 +848,11 @@ class PFTDumper {
 
 template <typename A, typename T>
 static pft::FunctionLikeUnit::FunctionStatement getFunctionStmt(const T &func) {
-  return pft::FunctionLikeUnit::FunctionStatement{
-      &std::get<parser::Statement<A>>(func.t)};
+  return std::get<parser::Statement<A>>(func.t);
 }
 template <typename A, typename T>
 static pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
-  return pft::ModuleLikeUnit::ModuleStatement{
-      &std::get<parser::Statement<A>>(mod.t)};
+  return std::get<parser::Statement<A>>(mod.t);
 }
 
 static const semantics::Symbol *
@@ -870,25 +860,23 @@ getSymbol(std::optional<pft::FunctionLikeUnit::FunctionStatement> &beginStmt) {
   if (!beginStmt)
     return nullptr;
 
-  const auto *symbol = std::visit(
-      common::visitors{
-          [](const parser::Statement<parser::ProgramStmt> *stmt)
-              -> const semantics::Symbol * { return stmt->statement.v.symbol; },
-          [](const parser::Statement<parser::FunctionStmt> *stmt)
-              -> const semantics::Symbol * {
-            return std::get<parser::Name>(stmt->statement.t).symbol;
-          },
-          [](const parser::Statement<parser::SubroutineStmt> *stmt)
-              -> const semantics::Symbol * {
-            return std::get<parser::Name>(stmt->statement.t).symbol;
-          },
-          [](const parser::Statement<parser::MpSubprogramStmt> *stmt)
-              -> const semantics::Symbol * { return stmt->statement.v.symbol; },
-          [](const auto *) -> const semantics::Symbol * {
-            assert(false && "unknown FunctionLike beginStmt");
-            return nullptr;
-          }},
-      *beginStmt);
+  const auto *symbol = beginStmt->visit(common::visitors{
+      [](const parser::Statement<parser::ProgramStmt> &stmt)
+          -> const semantics::Symbol * { return stmt.statement.v.symbol; },
+      [](const parser::Statement<parser::FunctionStmt> &stmt)
+          -> const semantics::Symbol * {
+        return std::get<parser::Name>(stmt.statement.t).symbol;
+      },
+      [](const parser::Statement<parser::SubroutineStmt> &stmt)
+          -> const semantics::Symbol * {
+        return std::get<parser::Name>(stmt.statement.t).symbol;
+      },
+      [](const parser::Statement<parser::MpSubprogramStmt> &stmt)
+          -> const semantics::Symbol * { return stmt.statement.v.symbol; },
+      [](const auto &) -> const semantics::Symbol * {
+        llvm_unreachable("unknown FunctionLike beginStmt");
+        return nullptr;
+      }});
   assert(symbol && "parser::Name must have resolved symbol");
   return symbol;
 }
@@ -919,15 +907,15 @@ pft::FunctionLikeUnit *pft::Evaluation::getOwningProcedure() const {
 
 pft::FunctionLikeUnit::FunctionLikeUnit(const parser::MainProgram &func,
                                         const pft::ParentVariant &parent)
-    : ProgramUnit{func, parent} {
-  auto &ps{
+    : ProgramUnit{func, parent}, endStmt{
+                                     getFunctionStmt<parser::EndProgramStmt>(
+                                         func)} {
+  const auto &ps{
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t)};
   if (ps.has_value()) {
-    const parser::Statement<parser::ProgramStmt> &statement{ps.value()};
-    beginStmt = &statement;
+    beginStmt = ps.value();
     symbol = getSymbol(beginStmt);
   }
-  endStmt = getFunctionStmt<parser::EndProgramStmt>(func);
 }
 
 pft::FunctionLikeUnit::FunctionLikeUnit(const parser::FunctionSubprogram &func,

From acf11b23372c3be4372a200bfa2c111626b0b7d7 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Tue, 24 Mar 2020 10:35:18 -0700
Subject: [PATCH 264/345] remove useless assert

---
 lib/Optimizer/Dialect/FIROps.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 1910de08cc3b..f173cced30b7 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -1046,7 +1046,6 @@ mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
     return f;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   // Insert new function at the end of the current module.
-  assert(modBuilder.getInsertionBlock() && "builder must have insertion block");
   modBuilder.setInsertionPoint(modBuilder.getInsertionBlock()->getTerminator());
   return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
 }

From 78b6ff55933d19625f87151d3be54fd1d339f376 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 24 Mar 2020 16:53:58 -0700
Subject: [PATCH 265/345] fix a number of bugs that had crept in from rebasing,
 etc.

---
 include/flang/Optimizer/Dialect/FIROps.td | 103 +++++++++++-----------
 lib/Optimizer/Dialect/FIROps.cpp          |   6 +-
 lib/Optimizer/Transforms/CSE.cpp          |  11 +--
 lib/Optimizer/Transforms/MemToReg.cpp     |  28 +++---
 test/Lower/array-init-driver.c            |   3 +
 test/Lower/array-init.f90                 |  16 ++--
 tools/bbc/bbc.cpp                         |   4 +-
 tools/tco/tco.cpp                         |   4 +-
 8 files changed, 93 insertions(+), 82 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 02e8fc21309f..6979e40141fc 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -194,8 +194,8 @@ class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
   );
 }
 
-class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
-    fir_AllocatableBaseOp<mnemonic, !listconcat([NoSideEffect], traits)>,
+class fir_AllocatableOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_AllocatableBaseOp<mnemonic, traits>,
     fir_TwoBuilders<fir_AllocateOpBuilder, fir_NamedAllocateOpBuilder>,
     Arguments<(ins TypeAttr:$in_type, Variadic<AnyIntegerType>:$args)> {
 
@@ -301,7 +301,7 @@ class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
 
 // Memory SSA operations
 
-def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
+def fir_AllocaOp : fir_AllocatableOp<"alloca", [MemoryEffects<[MemAlloc]>]> {
   let summary = "allocate storage for a temporary on the stack given a type";
   let description = [{
     This primitive operation is used to allocate an object on the stack.  A
@@ -344,7 +344,7 @@ def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
   }];
 }
 
-def fir_LoadOp : fir_OneResultOp<"load", []> {
+def fir_LoadOp : fir_OneResultOp<"load", [MemoryEffects<[MemRead]>]> {
   let summary = "load a value from a memory reference";
   let description = [{
     Load a value from a memory reference into an ssa-value (virtual register).
@@ -402,7 +402,7 @@ def fir_LoadOp : fir_OneResultOp<"load", []> {
   }];
 }
 
-def fir_StoreOp : fir_Op<"store", []> {
+def fir_StoreOp : fir_Op<"store", [MemoryEffects<[MemWrite]>]> {
   let summary = "store an SSA-value to a memory location";
 
   let description = [{
@@ -459,7 +459,7 @@ def fir_StoreOp : fir_Op<"store", []> {
   }];
 }
 
-def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
+def fir_UndefOp : fir_OneResultOp<"undefined", []> {
   let summary = "explicit undefined value of some type";
   let description = [{
     Constructs an ssa-value of the specified type with an undefined value.
@@ -479,13 +479,13 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   let assemblyFormat = "type($intype) attr-dict";
 
   let verifier = [{
-    if (auto ref = getType().dyn_cast<fir::ReferenceType>())
-      return emitOpError("undefined values of type !fir.ref not allowed");
+    // allow `undef : ref<T>` since it is a possible from transformations
     return mlir::success();
   }];
 }
 
-def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
+def fir_AllocMemOp :
+    fir_AllocatableOp<"allocmem", [MemoryEffects<[MemAlloc]>]> {
   let summary = "allocate storage on the heap for an object of a given type";
 
   let description = [{
@@ -514,7 +514,7 @@ def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
   }];
 }
 
-def fir_FreeMemOp : fir_Op<"freemem", []> {
+def fir_FreeMemOp : fir_Op<"freemem", [MemoryEffects<[MemFree]>]> {
   let summary = "free a heap object";
 
   let description = [{
@@ -1048,7 +1048,7 @@ def fir_HasValueOp : fir_Op<"has_value", [Terminator, HasParent<"GlobalOp">]> {
 
 // Operations on !fir.box<T> type objects
 
-def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
+def fir_EmboxOp : fir_Op<"embox", [MemoryEffects<[MemAlloc]>]> {
   let summary = "boxes a given reference and (optional) dimension information";
 
   let description = [{
@@ -1142,7 +1142,7 @@ def fir_EmboxOp : fir_Op<"embox", [NoSideEffect]> {
   }];
 }
 
-def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
+def fir_EmboxCharOp : fir_Op<"emboxchar", [MemoryEffects<[MemAlloc]>]> {
   let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
   let results = (outs fir_BoxCharType);
 
@@ -1179,8 +1179,7 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
   }];
 }
 
-def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
-
+def fir_EmboxProcOp : fir_Op<"emboxproc", [MemoryEffects<[MemAlloc]>]> {
   let summary = "boxes a given procedure and optional host context";
 
   let description = [{
@@ -1269,7 +1268,7 @@ def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
   }];
 }
 
-def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
+def fir_UnboxOp : fir_SimpleOp<"unbox", []> {
   let summary = "unbox the boxed value into a tuple value";
 
   let description = [{
@@ -1297,7 +1296,7 @@ def fir_UnboxOp : fir_SimpleOp<"unbox", [NoSideEffect]> {
   );
 }
 
-def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]> {
+def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", []> {
   let summary = "unbox a boxchar value into a pair value";
 
   let description = [{
@@ -1315,7 +1314,7 @@ def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]> {
   let results = (outs fir_ReferenceType, AnyIntegerLike);
 }
 
-def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
+def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", []> {
   let summary = "unbox a boxproc value into a pair value";
 
   let description = [{
@@ -1340,7 +1339,7 @@ def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
   let results = (outs FunctionType, fir_ReferenceType:$refTuple);
 }
 
-def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
+def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", []> {
   let summary = "return a memory reference to the boxed value";
 
   let description = [{
@@ -1361,7 +1360,7 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
   let results = (outs AnyReferenceLike);
 }
 
-def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
+def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", []> {
   let summary = "return the LEN type parameter from a boxchar value";
 
   let description = [{
@@ -1378,7 +1377,7 @@ def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
   let results = (outs AnyIntegerLike);
 }
 
-def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
+def fir_BoxDimsOp : fir_Op<"box_dims", []> {
   let summary = "return the dynamic dimension information for the boxed value";
 
   let description = [{
@@ -1409,7 +1408,7 @@ def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
   }];
 }
 
-def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
+def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", []> {
   let summary = "return the size of an element of the boxed value";
 
   let description = [{
@@ -1430,7 +1429,7 @@ def fir_BoxEleSizeOp : fir_SimpleOneResultOp<"box_elesize", [NoSideEffect]> {
   let results = (outs AnyIntegerLike);
 }
 
-def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]> {
+def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", []> {
   let summary = "is the boxed value an ALLOCATABLE?";
 
   let description = [{
@@ -1453,7 +1452,7 @@ def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]> {
   let results = (outs BoolLike);
 }
 
-def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]> {
+def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", []> {
   let summary = "is the boxed value an array?";
 
   let description = [{
@@ -1474,7 +1473,7 @@ def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]> {
   let results = (outs BoolLike);
 }
 
-def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]> {
+def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", []> {
   let summary = "is the boxed value a POINTER?";
 
   let description = [{
@@ -1492,7 +1491,7 @@ def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]> {
   let results = (outs BoolLike);
 }
 
-def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]> {
+def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", []> {
   let summary = "returns the host instance pointer (or null)";
 
   let description = [{
@@ -1514,7 +1513,7 @@ def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]> {
   let results = (outs fir_ReferenceType);
 }
 
-def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
+def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", []> {
   let summary = "return the number of dimensions for the boxed value";
 
   let description = [{
@@ -1536,7 +1535,7 @@ def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
   let results = (outs AnyIntegerType);
 }
 
-def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
+def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", []> {
   let summary = "return the type descriptor for the boxed value";
 
   let description = [{
@@ -1556,7 +1555,7 @@ def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
 
 // Record and array type operations
 
-def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
+def fir_CoordinateOp : fir_Op<"coordinate_of", []> {
   let summary = "Finds the coordinate (location) of a value in memory";
 
   let description = [{
@@ -1601,7 +1600,7 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
   }];
 }
 
-def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
+def fir_ExtractValueOp : fir_OneResultOp<"extract_value", []> {
   let summary = "Extract a value from an aggregate SSA-value";
 
   let description = [{
@@ -1629,7 +1628,7 @@ def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
   }];
 }
 
-def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
+def fir_FieldIndexOp : fir_OneResultOp<"field_index", []> {
   let summary = "create a field index value from a field identifier";
 
   let description = [{
@@ -1715,7 +1714,7 @@ def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
   }];
 }
 
-def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
+def fir_GenDimsOp : fir_OneResultOp<"gendims", [MemoryEffects<[MemAlloc]>]> {
 
   let summary = "generate a value of type `!fir.dims`";
 
@@ -1751,7 +1750,7 @@ def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
   }];
 }
 
-def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
+def fir_InsertValueOp : fir_OneResultOp<"insert_value", []> {
   let summary = "insert a new sub-value into a copy of an existing aggregate";
 
   let description = [{
@@ -1780,7 +1779,7 @@ def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
   }];
 }
 
-def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
+def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", []> {
   let summary =
     "create a field index value from a LEN type parameter identifier";
 
@@ -1844,7 +1843,7 @@ def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
 
 def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
 
-def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
+def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator, RecursiveSideEffects]> {
   let summary = "generalized loop operation";
   let description = [{
     Generalized high-level looping construct. This operation is similar to
@@ -1989,7 +1988,8 @@ def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
   }];
 }
 
-def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
+def fir_WhereOp :
+    fir_Op<"where", [ImplicitFirTerminator, RecursiveSideEffects]> {
   let summary = "generalized conditional operation";
   let description = [{
     To conditionally execute operations (typically) within the body of a
@@ -2061,7 +2061,7 @@ def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
 
 // Procedure call operations
 
-def fir_CallOp : fir_Op<"call", []> {
+def fir_CallOp : fir_Op<"call", [MemoryEffects<[MemRead, MemWrite]>]> {
   let summary = "call a procedure";
 
   let description = [{
@@ -2091,7 +2091,7 @@ def fir_CallOp : fir_Op<"call", []> {
   }];
 }
 
-def fir_DispatchOp : fir_Op<"dispatch", []> {
+def fir_DispatchOp : fir_Op<"dispatch", [MemoryEffects<[MemRead, MemWrite]>]> {
   let summary = "call a type-bound procedure";
 
   let description = [{
@@ -2165,7 +2165,7 @@ def fir_DispatchOp : fir_Op<"dispatch", []> {
 
 // Constant operations that support Fortran
 
-def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]> {
+def fir_StringLitOp : fir_Op<"string_lit", []> {
   let summary = "create a string literal constant";
 
   let description = [{
@@ -2250,8 +2250,7 @@ def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]> {
 // Complex operations
 
 class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-    fir_Op<mnemonic,
-       !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
+    fir_Op<mnemonic, !listconcat(traits, [SameOperandsAndResultType])>,
     Results<(outs AnyType)> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
@@ -2261,8 +2260,7 @@ class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
 }
 
 class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
-      fir_Op<mnemonic,
-         !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
+      fir_Op<mnemonic, !listconcat(traits, [SameOperandsAndResultType])>,
       Results<(outs AnyType)> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
@@ -2276,7 +2274,7 @@ def FirRealAttr : Attr<CPred<"$_self.isa<fir::RealAttr>()">, "FIR real attr"> {
   let returnType = [{ llvm::APFloat }];
 }
 
-def fir_ConstfOp : fir_Op<"constf", [NoSideEffect]> {
+def fir_ConstfOp : fir_Op<"constf", []> {
   let summary = "create a floating point constant";
 
   let description = [{
@@ -2314,8 +2312,8 @@ def fir_DivfOp : RealArithmeticOp<"divf">;
 def fir_ModfOp : RealArithmeticOp<"modf">;
 // Pow is a builtin call and not a primitive
 
-def fir_CmpfOp : fir_Op<"cmpf",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
+def fir_CmpfOp :
+    fir_Op<"cmpf", [SameTypeOperands, SameOperandsAndResultShape]> {
   let summary = "floating-point comparison operator";
 
   let description = [{
@@ -2350,8 +2348,7 @@ def fir_CmpfOp : fir_Op<"cmpf",
   }];
 }
 
-def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]>,
-    Results<(outs fir_ComplexType)> {
+def fir_ConstcOp : fir_Op<"constc", []>, Results<(outs fir_ComplexType)> {
   let summary = "create a complex constant";
 
   let description = [{
@@ -2419,8 +2416,8 @@ def fir_MulcOp : ComplexArithmeticOp<"mulc", [Commutative]>;
 def fir_DivcOp : ComplexArithmeticOp<"divc">;
 // Pow is a builtin call and not a primitive
 
-def fir_CmpcOp : fir_Op<"cmpc",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
+def fir_CmpcOp :
+    fir_Op<"cmpc", [SameTypeOperands, SameOperandsAndResultShape]> {
   let summary = "complex floating-point comparison operator";
 
   let description = [{
@@ -2455,8 +2452,9 @@ def fir_CmpcOp : fir_Op<"cmpc",
 
 // Other misc. operations
 
-def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
+def fir_AddrOfOp : fir_OneResultOp<"address_of", []> {
   let summary = "convert a symbol to an SSA value";
+  
   let description = [{
     Convert a symbol (a function or global reference) to an SSA-value to be
     used in other Operations.
@@ -2473,8 +2471,9 @@ def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
   let assemblyFormat = "`(` $symbol `)` attr-dict `:` type($resTy)";
 }
 
-def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
+def fir_ConvertOp : fir_OneResultOp<"convert", []> {
   let summary = "encapsulates all Fortran scalar type conversions";
+  
   let description = [{
     Generalized type conversion. Convert the ssa value from type T to type U.
     Not all pairs of types have conversions. When types T and U are the same
@@ -2508,7 +2507,7 @@ def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
   let convertFromStorage = "$_self.getValue().cast<Type>()";
 }
 
-def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
+def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", []> {
   let summary = "generate a type descriptor for a given type";
   let description = [{
     Generates a constant object that is an abstract type descriptor of the
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index f173cced30b7..bee6ff98d8ae 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -1044,9 +1044,9 @@ mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                                llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
-  mlir::OpBuilder modBuilder(module.getBodyRegion());
-  // Insert new function at the end of the current module.
-  modBuilder.setInsertionPoint(modBuilder.getInsertionBlock()->getTerminator());
+  auto &region = module.getBodyRegion();
+  mlir::OpBuilder modBuilder(region);
+  modBuilder.setInsertionPoint(&region.front(), --region.front().end());
   return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
 }
 
diff --git a/lib/Optimizer/Transforms/CSE.cpp b/lib/Optimizer/Transforms/CSE.cpp
index 2db9c959db7a..9ef042be422a 100644
--- a/lib/Optimizer/Transforms/CSE.cpp
+++ b/lib/Optimizer/Transforms/CSE.cpp
@@ -34,10 +34,10 @@
 using namespace mlir;
 
 static llvm::cl::opt<bool>
-    ClLeaveEffects("keep-effects",
+    leaveEffects("keep-effects",
                    llvm::cl::desc("disable cleaning up effects attributes"),
                    llvm::cl::init(false), llvm::cl::Hidden);
-static llvm::cl::opt<bool> ClDisableCSE("disable-cse",
+static llvm::cl::opt<bool> disableCSE("disable-cse",
                                         llvm::cl::desc("disable CSE pass"),
                                         llvm::cl::init(false),
                                         llvm::cl::Hidden);
@@ -192,7 +192,8 @@ LogicalResult BasicCSE::simplifyOperation(ScopedMapTy &knownValues,
     // If we find one then replace all uses of the current operation with the
     // existing one and mark it for deletion.
     op->replaceAllUsesWith(existing);
-    opsToErase.push_back(op);
+    if (op->isKnownNonTerminator())
+      opsToErase.push_back(op);
 
     // If the existing operation has an unknown location and the current
     // operation doesn't, then set the existing op's location to that of the
@@ -288,7 +289,7 @@ void BasicCSE::simplifyRegion(ScopedMapTy &knownValues, DominanceInfo &domInfo,
 }
 
 void BasicCSE::runOnFunction() {
-  if (ClDisableCSE)
+  if (disableCSE)
     return;
 
   /// A scoped hash table of defining operations within a function.
@@ -297,7 +298,7 @@ void BasicCSE::runOnFunction() {
     simplifyRegion(knownValues, getAnalysis<DominanceInfo>(),
                    getFunction().getBody());
   }
-  if (!ClLeaveEffects) {
+  if (!leaveEffects) {
     cleanupRegion(getFunction().getBody());
   }
 
diff --git a/lib/Optimizer/Transforms/MemToReg.cpp b/lib/Optimizer/Transforms/MemToReg.cpp
index a9c0c78d6f14..a65973a70216 100644
--- a/lib/Optimizer/Transforms/MemToReg.cpp
+++ b/lib/Optimizer/Transforms/MemToReg.cpp
@@ -23,9 +23,9 @@ using namespace fir;
 using DominatorTree = mlir::DominanceInfo;
 
 static llvm::cl::opt<bool>
-    ClDisableMemToReg("disable-mem2reg",
-                      llvm::cl::desc("disable memory to register pass"),
-                      llvm::cl::init(false), llvm::cl::Hidden);
+    disableMemToReg("disable-mem2reg",
+                    llvm::cl::desc("disable memory to register pass"),
+                    llvm::cl::init(false), llvm::cl::Hidden);
 
 /// A generalized version of a mem-to-reg pass suitable for use with an MLIR
 /// dialect. This code was ported from the LLVM project. MLIR differs with its
@@ -175,6 +175,7 @@ struct MemToReg
   /// Contains a stable numbering of basic blocks to avoid non-determinstic
   /// behavior.
   llvm::DenseMap<mlir::Block *, unsigned> BBNumbers;
+  llvm::DenseMap<mlir::Block *, unsigned> bbInitialArgs;
 
   /// Reverse mapping of Allocas.
   llvm::DenseMap<mlir::Operation *, unsigned> allocaLookup;
@@ -516,14 +517,19 @@ struct MemToReg
                   std::vector<RenamePassData> &Worklist) {
   NextIteration:
     // Does this block take arguments?
-    if ((!BB->hasNoPredecessors()) && (BB->getNumArguments() > 0)) {
+    const auto aiEnd = BB->getNumArguments();
+    if ((!BB->hasNoPredecessors()) && (aiEnd > bbInitialArgs[BB])) {
       // add the values from block `Pred` to the argument list in the proper
       // positions
-      for (unsigned ai = 0, AI{BB->getNumArguments()}; ai != AI; ++ai) {
-        auto allocaNo = argToAllocaMap[std::make_pair(BB, ai)];
-        setParam(Pred, ai, IncomingVals[allocaNo], BB, AI);
+      for (std::remove_const_t<decltype(aiEnd)> ai = 0; ai != aiEnd; ++ai) {
+        auto iter = argToAllocaMap.find(std::make_pair(BB, ai));
+        if (iter == argToAllocaMap.end())
+          continue;
+        auto allocaNo = iter->second;
+        auto offset = bbInitialArgs[BB];
+        setParam(Pred, ai + offset, IncomingVals[allocaNo], BB, aiEnd + offset);
         // use the block argument, not the live def in the pred block
-        addValue(IncomingVals, allocaNo, BB->getArgument(ai));
+        addValue(IncomingVals, allocaNo, BB->getArgument(ai + offset));
       }
     }
 
@@ -626,8 +632,10 @@ struct MemToReg
       // so now.
       if (BBNumbers.empty()) {
         unsigned id = 0;
-        for (auto &BB : F)
+        for (auto &BB : F) {
           BBNumbers[&BB] = id++;
+          bbInitialArgs[&BB] = BB.getNumArguments();
+        }
       }
 
       // Keep the reverse mapping of the 'Allocas' array for the rename pass.
@@ -710,7 +718,7 @@ struct MemToReg
 
   /// run the MemToReg pass on the FIR dialect
   void runOnFunction() override {
-    if (ClDisableMemToReg)
+    if (disableMemToReg)
       return;
 
     auto f = this->getFunction();
diff --git a/test/Lower/array-init-driver.c b/test/Lower/array-init-driver.c
index abc3abf5d364..4cbdbde177b2 100644
--- a/test/Lower/array-init-driver.c
+++ b/test/Lower/array-init-driver.c
@@ -1,5 +1,8 @@
 #include <stdio.h>
 
+void _QPsetall(float (*)[20][10], float *);
+void _QPsub1(float (*)[20][10], float (*)[20][10], float (*)[20][10]);
+
 static float arr_a[20][10];
 static float arr_b[20][10];
 static float arr_c[20][10];
diff --git a/test/Lower/array-init.f90 b/test/Lower/array-init.f90
index f87042047c25..8377eb6ec845 100644
--- a/test/Lower/array-init.f90
+++ b/test/Lower/array-init.f90
@@ -7,16 +7,16 @@ subroutine setall(a, x)
   real :: x
   integer :: i, j
   do i = 2, 9
-!     a(i, 1) = 0.0
+     a(i, 1) = -1.0
      do j = 2, 19
         a(i, j) = x
      end do
-!     a(i, 20) = 0.0
+     a(i, 20) = -2.0
+  end do
+  do j = 1, 20
+     a(1, j) = 0.0
+     a(10, j) = -3.0
   end do
-!  do j = 1, 20
-!     a(1, j) = 0.0
-!     a(10, j) = 0.0
-!  end do
 end subroutine setall
 
 ! Two subroutines that mean the same thing semantically. sub1 has explicit
@@ -32,11 +32,11 @@ end subroutine setall
 ! CHECK: c(6,6) = 7.0
 
 subroutine sub1(a,b,c)
-  real :: a(10,20), b(10,20), c(10,20)
+  real :: a(10,20), b(10,20), c(2:11,20)
   integer :: i, j
   do i = 1, 10
      do j = 1, 20
-        a(i,j) = b(i,j) + c(i,j)
+        a(i,j) = b(i,j) + c(i+1,j)
      end do
   end do
 end subroutine sub1
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index c629290a5aed..522a139e1dfc 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -184,11 +184,11 @@ static void convertFortranSourceToMLIR(
   // Otherwise run the default passes.
   mlir::PassManager pm(mlirModule.getContext());
   mlir::applyPassManagerCLOptions(pm);
-  pm.addPass(fir::createMemToRegPass());
-  pm.addPass(fir::createCSEPass());
   pm.addPass(fir::createLowerToLoopPass());
   pm.addPass(fir::createFIRToStdPass(kindMap));
   pm.addPass(mlir::createLowerToCFGPass());
+  pm.addPass(fir::createMemToRegPass());
+  pm.addPass(fir::createCSEPass());
   pm.addPass(mlir::createCanonicalizerPass());
 
   if (emitLLVM) {
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 20a44a23ee44..322b766d04d1 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -91,8 +91,6 @@ static int compileFIR() {
   } else {
     // add all the passes
     // the user can disable them individually
-    pm.addPass(fir::createMemToRegPass());
-    pm.addPass(fir::createCSEPass());
     // convert fir dialect to affine
     pm.addPass(fir::createPromoteToAffinePass());
     // convert fir dialect to loop
@@ -100,6 +98,8 @@ static int compileFIR() {
     pm.addPass(fir::createFIRToStdPass(kindMap));
     // convert loop dialect to standard
     pm.addPass(mlir::createLowerToCFGPass());
+    pm.addPass(fir::createMemToRegPass());
+    pm.addPass(fir::createCSEPass());
     pm.addPass(fir::createFIRToLLVMPass(uniquer));
     pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
   }

From 05838a7bbcf83766fef52b4254dbba66cbf29b04 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 24 Mar 2020 17:45:35 -0700
Subject: [PATCH 266/345] change bbc to use the stem name of the file + ".mlir"
 for the default

---
 tools/bbc/bbc.cpp | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 522a139e1dfc..8b5197dbed2a 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -57,7 +57,7 @@ static llvm::cl::opt<std::string> inputFilename(llvm::cl::Positional,
 
 static llvm::cl::opt<std::string>
     outputFilename("o", llvm::cl::desc("Specify the output filename"),
-                   llvm::cl::value_desc("filename"), llvm::cl::init("a.mlir"));
+                   llvm::cl::value_desc("filename"));
 
 static llvm::cl::list<std::string>
     includeDirs("I", llvm::cl::desc("include search paths"));
@@ -170,9 +170,12 @@ static void convertFortranSourceToMLIR(
   burnside.lower(parseTree, nameUniquer);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
-  llvm::raw_fd_ostream out(outputFilename, ec);
+  std::string outputName = outputFilename;
+  if (!outputName.size())
+    outputName = llvm::sys::path::stem(inputFilename).str().append(".mlir");
+  llvm::raw_fd_ostream out(outputName, ec);
   if (ec) {
-    llvm::errs() << "could not open output file " << outputFilename << '\n';
+    llvm::errs() << "could not open output file " << outputName << '\n';
     return;
   }
   if (emitFIR) {
@@ -195,10 +198,10 @@ static void convertFortranSourceToMLIR(
     // Continue to lower from MLIR down to LLVM IR. Emit LLVM and MLIR.
     pm.addPass(fir::createFIRToLLVMPass(nameUniquer));
     std::error_code ec;
-    llvm::ToolOutputFile outFile(outputFilename + ".ll", ec,
+    llvm::ToolOutputFile outFile(outputName + ".ll", ec,
                                  llvm::sys::fs::OF_None);
     if (ec) {
-      llvm::errs() << "can't open output file " + outputFilename + ".ll";
+      llvm::errs() << "can't open output file " + outputName + ".ll";
       return;
     }
     pm.addPass(fir::createLLVMDialectToLLVMPass(outFile.os()));

From 5a13d32d3da97fd47293e94a022ea58ee6aabc7b Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 25 Mar 2020 02:51:59 -0700
Subject: [PATCH 267/345] [front-end change] Define llvm::DenseMapInfo for
 SymbolRef

---
 include/flang/Semantics/symbol.h | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/include/flang/Semantics/symbol.h b/include/flang/Semantics/symbol.h
index 037423399182..bfb0b99de15f 100644
--- a/include/flang/Semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -13,6 +13,7 @@
 #include "flang/Common/Fortran.h"
 #include "flang/Common/enum-set.h"
 #include "flang/Common/reference.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include <array>
 #include <list>
 #include <optional>
@@ -743,5 +744,30 @@ inline bool ProcEntityDetails::HasExplicitInterface() const {
 inline bool operator<(SymbolRef x, SymbolRef y) { return *x < *y; }
 using SymbolSet = std::set<SymbolRef>;
 
+// Define required  info so that SymbolRef can be used inside llvm::DenseMap.
+namespace llvm {
+template<> struct DenseMapInfo<Fortran::semantics::SymbolRef> {
+  static inline Fortran::semantics::SymbolRef getEmptyKey() {
+    auto ptr = DenseMapInfo<const Fortran::semantics::Symbol *>::getEmptyKey();
+    return *reinterpret_cast<Fortran::semantics::SymbolRef *>(&ptr);
+  }
+
+  static inline Fortran::semantics::SymbolRef getTombstoneKey() {
+    auto ptr =
+        DenseMapInfo<const Fortran::semantics::Symbol *>::getTombstoneKey();
+    return *reinterpret_cast<Fortran::semantics::SymbolRef *>(&ptr);
+  }
+
+  static unsigned getHashValue(const Fortran::semantics::SymbolRef &sym) {
+    return DenseMapInfo<const Fortran::semantics::Symbol *>::getHashValue(
+        &sym.get());
+  }
+
+  static bool isEqual(const Fortran::semantics::SymbolRef &LHS,
+      const Fortran::semantics::SymbolRef &RHS) {
+    return LHS == RHS;
+  }
+};
+
 } // namespace Fortran::semantics
-#endif // FORTRAN_SEMANTICS_SYMBOL_H_
+#endif  // FORTRAN_SEMANTICS_SYMBOL_H_

From e9fd97aaa732f533521fae5e5c043e3f905d2c99 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 25 Mar 2020 02:51:06 -0700
Subject: [PATCH 268/345] Editorial changes and use SymbolRef inside
 SymbolLabelMap

---
 include/flang/Lower/PFTBuilder.h |  3 ++-
 lib/Lower/Bridge.cpp             |  5 ++---
 lib/Lower/Mangler.cpp            | 18 +++++++++---------
 lib/Lower/PFTBuilder.cpp         |  5 +++--
 4 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 865f5d6d5417..f364becb23f9 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -116,7 +116,8 @@ static constexpr bool isFunctionLike{common::HasMember<
                   parser::SeparateModuleSubprogram>>};
 
 using LabelSet = llvm::SmallSet<parser::Label, 5>;
-using SymbolLabelMap = llvm::DenseMap<const semantics::Symbol *, LabelSet>;
+using SymbolRef = common::Reference<const semantics::Symbol>;
+using SymbolLabelMap = llvm::DenseMap<SymbolRef, LabelSet>;
 
 /// Provide a variant like container that can holds constant references.
 /// It is used in the other classes to provide union of const references
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 9e4de3a205b9..527c8a22a276 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -1190,11 +1190,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     assert(!builder && "expected nullptr");
     // get mangled name
     std::string name;
-    if (funit.isMainProgram()) {
+    if (funit.isMainProgram())
       name = uniquer.doProgramEntry();
-    } else {
+    else
       name = mangleName(funit.getSubprogramSymbol());
-    }
     mlir::FuncOp func =
         Fortran::lower::FirOpBuilder::getNamedFunction(module, name);
 
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index ba916e7f0ea3..b14841d74773 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -32,7 +32,7 @@ void moduleNames(const Fortran::semantics::Scope &scope,
 
 llvm::SmallVector<llvm::StringRef, 2>
 moduleNames(const Fortran::semantics::Symbol &symbol) {
-  const auto &scope{symbol.owner()};
+  const auto &scope = symbol.owner();
   llvm::SmallVector<llvm::StringRef, 2> result;
   moduleNames(scope, result);
   return result;
@@ -40,7 +40,7 @@ moduleNames(const Fortran::semantics::Symbol &symbol) {
 
 llvm::Optional<llvm::StringRef>
 hostName(const Fortran::semantics::Symbol &symbol) {
-  const auto &scope{symbol.owner()};
+  const auto &scope = symbol.owner();
   if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
     assert(scope.symbol() && "subprogram scope must have a symbol");
     return {toStringRef(scope.symbol()->name())};
@@ -52,12 +52,12 @@ hostName(const Fortran::semantics::Symbol &symbol) {
 
 static const Fortran::semantics::Symbol *
 findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
-  const auto &scope{symbol.owner()};
+  const auto &scope = symbol.owner();
   if (symbol.attrs().test(Fortran::semantics::Attr::MODULE) &&
       scope.IsSubmodule()) {
     // FIXME symbol from MpSubprogramStmt do not seem to have
     // Attr::MODULE set.
-    const auto *iface{scope.parent().FindSymbol(symbol.name())};
+    const auto *iface = scope.parent().FindSymbol(symbol.name());
     assert(iface && "Separate module proc must be declared");
     return iface;
   }
@@ -75,20 +75,20 @@ Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
             return uniquer.doProgramEntry().str();
           },
           [&](const Fortran::semantics::SubprogramDetails &) {
-            auto &symbolName{symbol.name()};
+            auto &symbolName = symbol.name();
             // Separate module subprograms must be mangled according to the
             // scope where they were declared (the symbol we have is the
             // definition).
             const auto *interface = &symbol;
             if (const auto *mpIface = findInterfaceIfSeperateMP(symbol))
               interface = mpIface;
-            auto modNames{moduleNames(*interface)};
+            auto modNames = moduleNames(*interface);
             return uniquer.doProcedure(modNames, hostName(*interface),
                                        toStringRef(symbolName));
           },
           [&](const Fortran::semantics::ProcEntityDetails &) {
-            auto &cb{symbol.name()};
-            auto modNames{moduleNames(symbol)};
+            auto &cb = symbol.name();
+            auto modNames = moduleNames(symbol);
             return uniquer.doProcedure(modNames, hostName(symbol),
                                        toStringRef(cb));
           },
@@ -101,6 +101,6 @@ Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
 }
 
 std::string Fortran::lower::mangle::demangleName(llvm::StringRef name) {
-  auto result{fir::NameUniquer::deconstruct(name)};
+  auto result = fir::NameUniquer::deconstruct(name);
   return result.second.name;
 }
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index 50ab72b86124..b6dfd4824c30 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -9,6 +9,7 @@
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Semantics/symbol.h"
 #include "llvm/Support/CommandLine.h"
 #include <algorithm>
 #include <cassert>
@@ -486,11 +487,11 @@ class PFTBuilder {
             if (!t->isA<parser::FormatStmt>()) {
               markBranchTarget(eval, label);
             }
-            auto iter = assignSymbolLabelMap->find(sym);
+            auto iter = assignSymbolLabelMap->find(*sym);
             if (iter == assignSymbolLabelMap->end()) {
               pft::LabelSet labelSet{};
               labelSet.insert(label);
-              assignSymbolLabelMap->try_emplace(sym, labelSet);
+              assignSymbolLabelMap->try_emplace(*sym, labelSet);
             } else {
               iter->second.insert(label);
             }

From 5e5ff060cfb9d51d16f739e8cd26ffc975906e9a Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 25 Mar 2020 08:14:46 -0700
Subject: [PATCH 269/345] add folders

---
 include/flang/Optimizer/Dialect/FIROps.td | 25 ++++++---
 lib/Optimizer/Dialect/FIROps.cpp          | 65 +++++++++++++++++++++++
 2 files changed, 84 insertions(+), 6 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 6979e40141fc..80bb121f50d8 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -1143,9 +1143,6 @@ def fir_EmboxOp : fir_Op<"embox", [MemoryEffects<[MemAlloc]>]> {
 }
 
 def fir_EmboxCharOp : fir_Op<"emboxchar", [MemoryEffects<[MemAlloc]>]> {
-  let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
-  let results = (outs fir_BoxCharType);
-
   let summary = "boxes a given CHARACTER reference and its LEN parameter";
 
   let description = [{
@@ -1167,6 +1164,10 @@ def fir_EmboxCharOp : fir_Op<"emboxchar", [MemoryEffects<[MemAlloc]>]> {
     This buffer and its LEN value (10) are wrapped into a pair in `%6`.
   }];
 
+  let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
+  
+  let results = (outs fir_BoxCharType);
+
   let assemblyFormat = [{
     $memref `,` $len attr-dict `:` functional-type(operands, results)
   }];
@@ -1358,6 +1359,8 @@ def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", []> {
   let arguments = (ins fir_BoxType:$val);
 
   let results = (outs AnyReferenceLike);
+
+  let hasFolder = 1;
 }
 
 def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", []> {
@@ -1375,6 +1378,8 @@ def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", []> {
   let arguments = (ins fir_BoxCharType:$val);
 
   let results = (outs AnyIntegerLike);
+
+  let hasFolder = 1;
 }
 
 def fir_BoxDimsOp : fir_Op<"box_dims", []> {
@@ -2305,9 +2310,15 @@ class RealArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_ArithmeticOp<mnemonic, traits>,
       Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)>;
 
-def fir_AddfOp : RealArithmeticOp<"addf", [Commutative]>;
-def fir_SubfOp : RealArithmeticOp<"subf">;
-def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]>;
+def fir_AddfOp : RealArithmeticOp<"addf", [Commutative]> {
+  let hasFolder = 1;
+}
+def fir_SubfOp : RealArithmeticOp<"subf"> {
+  let hasFolder = 1;
+}
+def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]> {
+  let hasFolder = 1;
+}
 def fir_DivfOp : RealArithmeticOp<"divf">;
 def fir_ModfOp : RealArithmeticOp<"modf">;
 // Pow is a builtin call and not a primitive
@@ -2492,6 +2503,8 @@ def fir_ConvertOp : fir_OneResultOp<"convert", []> {
   let assemblyFormat = [{
     $value attr-dict `:` functional-type($value, results)
   }];
+
+  let hasFolder = 1;
 }
 
 def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index bee6ff98d8ae..463a87fb3e0c 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -11,6 +11,7 @@
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/ADT/TypeSwitch.h"
+#include "mlir/Dialect/CommonFolders.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
@@ -57,6 +58,15 @@ static bool verifyRecordLenParams(mlir::Type inType, unsigned numLenParams) {
   return false;
 }
 
+//===----------------------------------------------------------------------===//
+// AddfOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::AddfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  return mlir::constFoldBinaryOp<FloatAttr>(
+      opnds, [](APFloat a, APFloat b) { return a + b; });
+}
+
 //===----------------------------------------------------------------------===//
 // AllocaOp
 //===----------------------------------------------------------------------===//
@@ -100,6 +110,33 @@ mlir::Type fir::AllocMemOp::wrapResultType(mlir::Type intype) {
   return HeapType::get(intype);
 }
 
+//===----------------------------------------------------------------------===//
+// BoxAddrOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::BoxAddrOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  if (auto v = val().getDefiningOp()) {
+    if (auto box = dyn_cast<fir::EmboxOp>(v))
+      return box.memref();
+    if (auto box = dyn_cast<fir::EmboxCharOp>(v))
+      return box.memref();
+  }
+  return {};
+}
+
+//===----------------------------------------------------------------------===//
+// BoxCharLenOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult
+fir::BoxCharLenOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  if (auto v = val().getDefiningOp()) {
+    if (auto box = dyn_cast<fir::EmboxCharOp>(v))
+      return box.len();
+  }
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // BoxDimsOp
 //===----------------------------------------------------------------------===//
@@ -267,6 +304,16 @@ mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
+//===----------------------------------------------------------------------===//
+// ConvertOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  if (value().getType() == getType())
+    return value();
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // DispatchOp
 //===----------------------------------------------------------------------===//
@@ -611,6 +658,15 @@ fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
   return dyn_cast_or_null<fir::LoopOp>(containingInst);
 }
 
+//===----------------------------------------------------------------------===//
+// MulfOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::MulfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  return mlir::constFoldBinaryOp<FloatAttr>(
+      opnds, [](APFloat a, APFloat b) { return a * b; });
+}
+
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
@@ -931,6 +987,15 @@ bool fir::StringLitOp::isWideValue() {
   return eleTy.cast<fir::CharacterType>().getFKind() != 1;
 }
 
+//===----------------------------------------------------------------------===//
+// SubfOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::SubfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  return mlir::constFoldBinaryOp<FloatAttr>(
+      opnds, [](APFloat a, APFloat b) { return a - b; });
+}
+
 //===----------------------------------------------------------------------===//
 // WhereOp
 //===----------------------------------------------------------------------===//

From 52572ea8d078b28c59f45ca262b2c925f719e1ca Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 25 Mar 2020 11:23:26 -0700
Subject: [PATCH 270/345] merging subroutine and function call, mangling test
 and fixes

---
 lib/Lower/Bridge.cpp              |  64 ++------------
 lib/Lower/ConvertExpr.cpp         | 140 ++++++++++++++++++------------
 lib/Lower/Mangler.cpp             |  17 ++--
 test/Lower/call-site-mangling.f90 |  52 +++++++++++
 4 files changed, 151 insertions(+), 122 deletions(-)
 create mode 100644 test/Lower/call-site-mangling.f90

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 527c8a22a276..b7585ca2a6b5 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -329,66 +329,16 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   /// Lowering of CALL statement
-  ///
-  /// 1. Determine what function is being called/dispatched to
-  /// 2. Build a tuple of arguments to be passed to that function
-  /// 3. Emit fir.call/fir.dispatch on arguments
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::CallStmt &stmt) {
-    llvm::SmallVector<mlir::Type, 8> argTy;
-    llvm::SmallVector<mlir::Type, 2> resTy;
-    llvm::StringRef funName;
-    std::vector<Fortran::semantics::Symbol *> argsList;
     setCurrentPosition(stmt.v.source);
-    std::visit(Fortran::common::visitors{
-                   [&](const Fortran::parser::Name &name) {
-                     auto *sym = name.symbol;
-                     auto n = sym->name();
-                     funName = llvm::StringRef{n.begin(), n.size()};
-                     auto &details =
-                         sym->get<Fortran::semantics::SubprogramDetails>();
-                     // TODO ProcEntityDetails?
-                     // TODO bindName()?
-                     argsList = details.dummyArgs();
-                   },
-                   [&](const Fortran::parser::ProcComponentRef &) { TODO(); },
-               },
-               std::get<Fortran::parser::ProcedureDesignator>(stmt.v.t).u);
-    for (auto *d : argsList) {
-      Fortran::semantics::SymbolRef sr = *d;
-      // FIXME:
-      argTy.push_back(fir::ReferenceType::get(genType(sr)));
-    }
-    auto funTy = mlir::FunctionType::get(argTy, resTy, builder->getContext());
-    // FIXME: mangle name
-    [[maybe_unused]] mlir::FuncOp func = getFunc(funName, funTy);
-    std::vector<mlir::Value> actuals;
-    for (auto &aa :
-         std::get<std::list<Fortran::parser::ActualArgSpec>>(stmt.v.t)) {
-      auto &kw = std::get<std::optional<Fortran::parser::Keyword>>(aa.t);
-      auto &arg = std::get<Fortran::parser::ActualArg>(aa.t);
-      mlir::Value fe;
-      std::visit(
-          Fortran::common::visitors{
-              [&](const Fortran::common::Indirection<Fortran::parser::Expr>
-                      &e) {
-                // FIXME: needs to match argument, assumes trivial by-ref
-                fe = genExprAddr(*Fortran::semantics::GetExpr(e));
-              },
-              [&](const Fortran::parser::AltReturnSpec &) { TODO(); },
-              [&](const Fortran::parser::ActualArg::PercentRef &) { TODO(); },
-              [&](const Fortran::parser::ActualArg::PercentVal &) { TODO(); },
-          },
-          arg.u);
-      if (kw.has_value()) {
-        TODO();
-        continue;
-      }
-      actuals.push_back(fe);
-    }
-
-    builder->create<fir::CallOp>(toLocation(), resTy,
-                                 builder->getSymbolRefAttr(funName), actuals);
+    assert(stmt.typedCall && "Call was not analyzed");
+    // The actual lowering is forwarded to expression lowering
+    // where the code is shared with function reference.
+    Fortran::semantics::SomeExpr expr{*stmt.typedCall};
+    auto res = createFIRExpr(toLocation(), &expr);
+    if (res)
+      TODO(); // Alternate returns
   }
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 4ab871a8d4c7..ba2d98a5cdb0 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -231,7 +231,10 @@ class ExprLowering {
   }
 
   mlir::Value genval(const Fortran::evaluate::BOZLiteralConstant &) { TODO(); }
-  mlir::Value genval(const Fortran::evaluate::ProcedureRef &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::ProcedureRef &procRef) {
+    llvm::SmallVector<mlir::Type, 1> resTy;
+    return genProcedureRef(procRef, resTy);
+  }
   mlir::Value genval(const Fortran::evaluate::ProcedureDesignator &) { TODO(); }
   mlir::Value genval(const Fortran::evaluate::NullPointer &) { TODO(); }
   mlir::Value genval(const Fortran::evaluate::StructureConstructor &) {
@@ -795,66 +798,89 @@ class ExprLowering {
   mlir::Value genval(const Fortran::evaluate::FunctionRef<A> &funRef) {
     TODO(); // Derived type functions (user + intrinsics)
   }
-  template <Fortran::common::TypeCategory TC, int KIND>
+
   mlir::Value
-  genval(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<TC, KIND>>
-             &funRef) {
-    if (const auto &intrinsic{funRef.proc().GetSpecificIntrinsic()}) {
-      mlir::Type ty = converter.genType(TC, KIND);
-      llvm::SmallVector<mlir::Value, 2> operands;
-      // Lower arguments
-      // For now, logical arguments for intrinsic are lowered to `fir.logical`
-      // so that TRANSFER can work. For some arguments, it could lead to useless
-      // conversions (e.g scalar MASK of MERGE will be converted to `i1`), but
-      // the generated code is at least correct. To improve this, the intrinsic
-      // lowering facility should control argument lowering.
-      auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, false);
-      for (const auto &arg : funRef.arguments()) {
-        if (auto *expr = Fortran::evaluate::UnwrapExpr<
-                Fortran::evaluate::Expr<Fortran::evaluate::SomeType>>(arg)) {
-          operands.push_back(genval(*expr));
-        } else {
-          operands.push_back(nullptr); // optional
-        }
+  genIntrinsicRef(const Fortran::evaluate::ProcedureRef &procRef,
+                  const Fortran::evaluate::SpecificIntrinsic &intrinsic,
+                  mlir::ArrayRef<mlir::Type> resultType) {
+    if (resultType.size() == 1)
+      TODO(); // Intrinsic subroutine
+
+    llvm::SmallVector<mlir::Value, 2> operands;
+    // Lower arguments
+    // For now, logical arguments for intrinsic are lowered to `fir.logical`
+    // so that TRANSFER can work. For some arguments, it could lead to useless
+    // conversions (e.g scalar MASK of MERGE will be converted to `i1`), but
+    // the generated code is at least correct. To improve this, the intrinsic
+    // lowering facility should control argument lowering.
+    auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, false);
+    for (const auto &arg : procRef.arguments()) {
+      if (auto *expr = Fortran::evaluate::UnwrapExpr<
+              Fortran::evaluate::Expr<Fortran::evaluate::SomeType>>(arg)) {
+        operands.push_back(genval(*expr));
+      } else {
+        operands.push_back(nullptr); // optional
       }
-      // Let the intrinsic library lower the intrinsic function call
-      llvm::StringRef name{intrinsic->name};
-      return intrinsics.genval(getLoc(), builder, name, ty, operands);
-    } else {
-      // implicit interface implementation only
-      // TODO: explicit interface
-      llvm::SmallVector<mlir::Type, 2> argTypes;
-      llvm::SmallVector<mlir::Value, 2> operands;
-      // Logical arguments of user functions must be lowered to `fir.logical`
-      // and not `i1`.
-      auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, false);
-      for (const auto &arg : funRef.arguments()) {
-        assert(arg.has_value() &&
-               "optional argument requires explicit interface");
-        const auto *expr = arg->UnwrapExpr();
-        assert(expr && "assumed type argument requires explicit interface");
-        if (const auto *sym =
-                Fortran::evaluate::UnwrapWholeSymbolDataRef(*expr)) {
-          mlir::Value argRef = symMap.lookupSymbol(*sym);
-          assert(argRef && "could not get symbol reference");
-          argTypes.push_back(argRef.getType());
-          operands.push_back(argRef);
-        } else {
-          // TODO create temps for expressions
-          TODO();
-        }
+    }
+    // Let the intrinsic library lower the intrinsic procedure call
+    llvm::StringRef name{intrinsic.name};
+    return intrinsics.genval(getLoc(), builder, name, resultType[0], operands);
+  }
+
+  mlir::Value genProcedureRef(const Fortran::evaluate::ProcedureRef procRef,
+                              mlir::ArrayRef<mlir::Type> resultType) {
+    if (const auto *intrinsic{procRef.proc().GetSpecificIntrinsic()}) {
+      return genIntrinsicRef(procRef, *intrinsic, resultType[0]);
+    }
+    // Implicit interface implementation only
+    // TODO: Explicit interface, we need to use Characterize here,
+    // evaluate::IntrinsicProcTable is required to use it.
+    llvm::SmallVector<mlir::Type, 2> argTypes;
+    llvm::SmallVector<mlir::Value, 2> operands;
+    // Logical arguments of user functions must be lowered to `fir.logical`
+    // and not `i1`.
+    auto restorer = Fortran::common::ScopedSet(genLogicalAsI1, false);
+    for (const auto &arg : procRef.arguments()) {
+      if (!arg.has_value())
+        TODO(); // optional arguments
+      const auto *expr = arg->UnwrapExpr();
+      if (!expr)
+        TODO(); // assumed type arguments
+      if (const auto *sym =
+              Fortran::evaluate::UnwrapWholeSymbolDataRef(*expr)) {
+        mlir::Value argRef = symMap.lookupSymbol(*sym);
+        assert(argRef && "could not get symbol reference");
+        argTypes.push_back(argRef.getType());
+        operands.push_back(argRef);
+      } else {
+        // TODO create temps for expressions
+        TODO();
       }
-      mlir::Type resultType = converter.genType(TC, KIND);
-      mlir::FunctionType funTy =
-          mlir::FunctionType::get(argTypes, resultType, builder.getContext());
-      mlir::FuncOp func = getFunction(applyNameMangling(funRef.proc()), funTy);
-      auto call = builder.create<mlir::CallOp>(getLoc(), func, operands);
-      // For now, Fortran return value are implemented with a single MLIR
-      // function return value.
-      assert(call.getNumResults() == 1 &&
-             "Expected exactly one result in FUNCTION call");
-      return call.getResult(0);
     }
+    mlir::FunctionType funTy =
+        mlir::FunctionType::get(argTypes, resultType, builder.getContext());
+    auto funName = applyNameMangling(procRef.proc());
+    ;
+    [[maybe_unused]] mlir::FuncOp func = getFunction(funName, funTy);
+    auto call = builder.create<fir::CallOp>(
+        getLoc(), resultType, builder.getSymbolRefAttr(funName), operands);
+
+    if (resultType.size() == 0)
+      return {}; // subroutine call
+    // For now, Fortran returned values are implemented with a single MLIR
+    // function return value.
+    assert(call.getNumResults() == 1 &&
+           "Expected exactly one result in FUNCTION call");
+    return call.getResult(0);
+  }
+
+  template <Fortran::common::TypeCategory TC, int KIND>
+  mlir::Value
+  genval(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<TC, KIND>>
+             &funRef) {
+    llvm::SmallVector<mlir::Type, 1> resTy;
+    resTy.push_back(converter.genType(TC, KIND));
+    return genProcedureRef(funRef, resTy);
   }
 
   template <typename A>
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index b14841d74773..3df2161fe48d 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -69,35 +69,36 @@ findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
 std::string
 Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
                                    const Fortran::semantics::Symbol &symbol) {
+  /// Resolve host and module association before mangling
+  const auto &ultimateSymbol = symbol.GetUltimate();
+  auto symbolName = ultimateSymbol.name();
   return std::visit(
       Fortran::common::visitors{
           [&](const Fortran::semantics::MainProgramDetails &) {
             return uniquer.doProgramEntry().str();
           },
           [&](const Fortran::semantics::SubprogramDetails &) {
-            auto &symbolName = symbol.name();
             // Separate module subprograms must be mangled according to the
             // scope where they were declared (the symbol we have is the
             // definition).
-            const auto *interface = &symbol;
-            if (const auto *mpIface = findInterfaceIfSeperateMP(symbol))
+            const auto *interface = &ultimateSymbol;
+            if (const auto *mpIface = findInterfaceIfSeperateMP(ultimateSymbol))
               interface = mpIface;
             auto modNames = moduleNames(*interface);
             return uniquer.doProcedure(modNames, hostName(*interface),
                                        toStringRef(symbolName));
           },
           [&](const Fortran::semantics::ProcEntityDetails &) {
-            auto &cb = symbol.name();
-            auto modNames = moduleNames(symbol);
-            return uniquer.doProcedure(modNames, hostName(symbol),
-                                       toStringRef(cb));
+            auto modNames = moduleNames(ultimateSymbol);
+            return uniquer.doProcedure(modNames, hostName(ultimateSymbol),
+                                       toStringRef(symbolName));
           },
           [](const auto &) -> std::string {
             assert(false);
             return {};
           },
       },
-      symbol.details());
+      ultimateSymbol.details());
 }
 
 std::string Fortran::lower::mangle::demangleName(llvm::StringRef name) {
diff --git a/test/Lower/call-site-mangling.f90 b/test/Lower/call-site-mangling.f90
new file mode 100644
index 000000000000..29c34568e1e3
--- /dev/null
+++ b/test/Lower/call-site-mangling.f90
@@ -0,0 +1,52 @@
+! RUN: bbc %s -o "-" -emit-fir | FileCheck %s
+
+subroutine sub()
+  real :: x
+  ! CHECK-LABEL: fir.call @_QPasubroutine()
+  call AsUbRoUtInE();
+  ! CHECK-LABEL: fir.call @_QPfoo()
+  x = foo()
+end subroutine
+
+module testMod
+contains
+  subroutine sub()
+  end subroutine
+
+  function foo()
+  end function
+end module
+
+subroutine sub1()
+  use testMod
+  real :: x
+  ! CHECK-LABEL: fir.call @_QMtestmodPsub()
+  call Sub();
+  ! CHECK-LABEL: fir.call @_QMtestmodPfoo()
+  x = foo()
+end subroutine
+
+subroutine sub2()
+  use testMod, localfoo => foo, localsub => sub
+  real :: x
+  ! CHECK-LABEL: fir.call @_QMtestmodPsub()
+  call localsub();
+  ! CHECK-LABEL: fir.call @_QMtestmodPfoo()
+  x = localfoo()
+end subroutine
+
+
+
+subroutine sub3()
+  real :: x
+  ! CHECK-LABEL: fir.call @_QFsub3Psub()
+  call sub();
+  ! CHECK-LABEL: fir.call @_QFsub3Pfoo()
+  x = foo()
+contains
+  subroutine sub()
+  end subroutine
+
+  function foo()
+  end function
+end subroutine

From 563ac02d6977edab7c51048c44e9b7c7d8dedeae Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 25 Mar 2020 12:58:56 -0700
Subject: [PATCH 271/345] merge in functional calls

---
 lib/Optimizer/Dialect/FIROps.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 463a87fb3e0c..15ac3943750e 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -1109,9 +1109,8 @@ mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                                llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
-  auto &region = module.getBodyRegion();
-  mlir::OpBuilder modBuilder(region);
-  modBuilder.setInsertionPoint(&region.front(), --region.front().end());
+  mlir::OpBuilder modBuilder(module.getBodyRegion());
+  modBuilder.setInsertionPoint(module.getBody()->getTerminator());
   return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
 }
 

From ab5e6fd10ec4c1660b021c9ec01aa354ef1f3167 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 25 Mar 2020 14:38:29 -0700
Subject: [PATCH 272/345] add location for new functions

---
 lib/Lower/Bridge.cpp | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index b7585ca2a6b5..7b4b3b6478a4 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -34,7 +34,7 @@
   {                                                                            \
     if (disableToDoAssertions)                                                 \
       mlir::emitError(toLocation(), __FILE__)                                  \
-          << ":" << __LINE__ << " not implemented";                            \
+          << ':' << __LINE__ << " not implemented";                            \
     else                                                                       \
       llvm_unreachable("not yet implemented");                                 \
   }
@@ -157,9 +157,14 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   mlir::Location getCurrentLocation() override final { return toLocation(); }
+
+  /// Generate a dummy location.
   mlir::Location genLocation() override final {
+    // Note: builder may not be instantiated yet
     return mlir::UnknownLoc::get(&mlirContext);
   }
+
+  /// Generate a `Location` from the `CharBlock`.
   mlir::Location
   genLocation(const Fortran::parser::CharBlock &block) override final {
     if (cooked) {
@@ -1126,13 +1131,18 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
   }
 
-  mlir::FuncOp createNewFunction(llvm::StringRef name,
+  mlir::FuncOp createNewFunction(mlir::Location loc, llvm::StringRef name,
                                  const Fortran::semantics::Symbol *symbol) {
     mlir::FunctionType ty =
         symbol ? genFunctionType(*symbol)
                : mlir::FunctionType::get(llvm::None, llvm::None, &mlirContext);
-    return Fortran::lower::FirOpBuilder::createFunction(toLocation(), module,
-                                                        name, ty);
+    return Fortran::lower::FirOpBuilder::createFunction(loc, module, name, ty);
+  }
+
+  static Fortran::parser::CharBlock functionStmtSource(
+      const Fortran::lower::pft::FunctionLikeUnit::FunctionStatement &stmt) {
+    return stmt.visit(
+        Fortran::common::visitors{[](const auto &x) { return x.source; }});
   }
 
   /// Prepare to translate a new function
@@ -1144,11 +1154,16 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       name = uniquer.doProgramEntry();
     else
       name = mangleName(funit.getSubprogramSymbol());
+
+    // FIXME: do NOT use unknown for the anonymous PROGRAM case. We probably
+    // should just stash the location in the funit regardless.
+    mlir::Location loc = funit.beginStmt.has_value()
+                             ? toLocation(functionStmtSource(*funit.beginStmt))
+                             : mlir::UnknownLoc::get(&mlirContext);
     mlir::FuncOp func =
         Fortran::lower::FirOpBuilder::getNamedFunction(module, name);
-
     if (!func)
-      func = createNewFunction(name, funit.symbol);
+      func = createNewFunction(loc, name, funit.symbol);
     builder = new Fortran::lower::FirOpBuilder(func);
     assert(builder && "FirOpBuilder did not instantiate");
     func.addEntryBlock();

From 7af343511c1a26a142e793fd52bc9da3da2524e0 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 26 Mar 2020 03:09:22 -0700
Subject: [PATCH 273/345] Last PR63 comments. Remove redundant extractLocation
 function.

---
 lib/Lower/Bridge.cpp      | 29 +++++------------------------
 lib/Lower/ConvertExpr.cpp |  3 +--
 lib/Lower/Mangler.cpp     |  2 +-
 3 files changed, 7 insertions(+), 27 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 7b4b3b6478a4..d5d59e7935b2 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -1139,6 +1139,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return Fortran::lower::FirOpBuilder::createFunction(loc, module, name, ty);
   }
 
+  /// Helper to get location from FunctionLikeUnit begin/end statements.
   static Fortran::parser::CharBlock functionStmtSource(
       const Fortran::lower::pft::FunctionLikeUnit::FunctionStatement &stmt) {
     return stmt.visit(
@@ -1149,11 +1150,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     assert(!builder && "expected nullptr");
     // get mangled name
-    std::string name;
-    if (funit.isMainProgram())
-      name = uniquer.doProgramEntry();
-    else
-      name = mangleName(funit.getSubprogramSymbol());
+    std::string name = funit.isMainProgram()
+                           ? uniquer.doProgramEntry().str()
+                           : mangleName(funit.getSubprogramSymbol());
 
     // FIXME: do NOT use unknown for the anonymous PROGRAM case. We probably
     // should just stash the location in the funit regardless.
@@ -1239,16 +1238,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
   }
 
-  /// Helper to get location from FunctionLikeUnit begin/end
-  static Fortran::parser::CharBlock extractLocation(
-      Fortran::lower::pft::FunctionLikeUnit::FunctionStatement &fstmt) {
-    return fstmt.visit([](const auto &stmt) { return stmt.source; });
-  }
-
   /// Emit return and cleanup after the function has been translated.
   void endNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
-    auto loc = extractLocation(funit.endStmt);
-    setCurrentPosition(loc);
+    setCurrentPosition(functionStmtSource(funit.endStmt));
 
     if (funit.isMainProgram()) {
       genFIRProgramExit();
@@ -1263,23 +1255,12 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   /// Lower a procedure-like construct
   void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &funit) {
-
-    if (funit.beginStmt) {
-      auto loc = extractLocation(funit.endStmt);
-      setCurrentPosition(loc);
-    } else {
-      // TODO: get location of anonymous main program
-    }
-
     startNewFunction(funit);
-
     // lower this procedure
     for (auto &eval : funit.evaluationList) {
       genFIR(eval);
     }
-
     endNewFunction(funit);
-
     // recursively lower internal procedures
     for (auto &f : funit.nestedFunctions) {
       lowerFunc(f);
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index ba2d98a5cdb0..4174f2cb44ef 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -860,8 +860,7 @@ class ExprLowering {
     mlir::FunctionType funTy =
         mlir::FunctionType::get(argTypes, resultType, builder.getContext());
     auto funName = applyNameMangling(procRef.proc());
-    ;
-    [[maybe_unused]] mlir::FuncOp func = getFunction(funName, funTy);
+    getFunction(funName, funTy);
     auto call = builder.create<fir::CallOp>(
         getLoc(), resultType, builder.getSymbolRefAttr(funName), operands);
 
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index 3df2161fe48d..03df71114f72 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -69,7 +69,7 @@ findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
 std::string
 Fortran::lower::mangle::mangleName(fir::NameUniquer &uniquer,
                                    const Fortran::semantics::Symbol &symbol) {
-  /// Resolve host and module association before mangling
+  // Resolve host and module association before mangling
   const auto &ultimateSymbol = symbol.GetUltimate();
   auto symbolName = ultimateSymbol.name();
   return std::visit(

From 4eff7977943be025f4fb85ad632dec0d4f252547 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Thu, 26 Mar 2020 10:38:34 -0700
Subject: [PATCH 274/345] add -dump-symbols to bbc

---
 tools/bbc/bbc.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 8b5197dbed2a..99cb858de2bc 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -94,6 +94,10 @@ static llvm::cl::opt<bool> warnIsError("Werror",
                                        llvm::cl::desc("warnings are errors"),
                                        llvm::cl::init(false));
 
+static llvm::cl::opt<bool> dumpSymbols("dump-symbols",
+                                       llvm::cl::desc("dump the symbol table"),
+                                       llvm::cl::init(false));
+
 //===----------------------------------------------------------------------===//
 
 namespace {
@@ -126,6 +130,8 @@ static void convertFortranSourceToMLIR(
       options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
     }
   }
+
+  // prep for prescan and parse
   options.searchDirectories = includeDirs;
   Fortran::parser::Parsing parsing{semanticsContext.allSources()};
   parsing.Prescan(path, options);
@@ -136,6 +142,8 @@ static void convertFortranSourceToMLIR(
     exitStatus = EXIT_FAILURE;
     return;
   }
+
+  // parse the input Fortran
   parsing.Parse(llvm::outs());
   parsing.messages().Emit(llvm::errs(), parsing.cooked());
   if (!parsing.consumedWholeFile()) {
@@ -151,6 +159,8 @@ static void convertFortranSourceToMLIR(
     exitStatus = EXIT_FAILURE;
     return;
   }
+
+  // run semantics
   auto &parseTree{*parsing.parseTree()};
   Fortran::semantics::Semantics semantics{semanticsContext, parseTree,
                                           parsing.cooked()};
@@ -161,6 +171,8 @@ static void convertFortranSourceToMLIR(
     exitStatus = EXIT_FAILURE;
     return;
   }
+  if (dumpSymbols)
+    semantics.DumpSymbols(llvm::outs());
 
   // MLIR+FIR
   fir::NameUniquer nameUniquer;

From a6e3c5d7cb602495e4588383e80f7cc9fdeef1e7 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Thu, 26 Mar 2020 15:42:22 -0700
Subject: [PATCH 275/345] add end-to-end hello world test

---
 include/flang/Optimizer/Support/InternalNames.h |  3 ++-
 lib/Lower/IO.cpp                                |  3 ++-
 lib/Optimizer/Support/InternalNames.cpp         | 12 +++++++++++-
 test/Examples/hello.f90                         |  8 ++++++++
 test/Examples/main.c                            | 14 ++++++++++++++
 test/Lower/program-units-fir-mangling.f90       |  2 +-
 6 files changed, 38 insertions(+), 4 deletions(-)
 create mode 100644 test/Examples/hello.f90
 create mode 100644 test/Examples/main.c

diff --git a/include/flang/Optimizer/Support/InternalNames.h b/include/flang/Optimizer/Support/InternalNames.h
index d9d204ffb93a..62724eea8fa4 100644
--- a/include/flang/Optimizer/Support/InternalNames.h
+++ b/include/flang/Optimizer/Support/InternalNames.h
@@ -110,7 +110,8 @@ struct NameUniquer {
                          llvm::StringRef name);
 
   /// Entry point for the PROGRAM (called by the runtime)
-  constexpr static llvm::StringRef doProgramEntry() { return "MAIN_"; }
+  /// Can be overridden with the `--main-entry-name=<name>` option.
+  static llvm::StringRef doProgramEntry();
 
   /// Decompose `uniquedName` into the parse name, symbol type, and scope info
   static std::pair<NameKind, DeconstructedName>
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 5f74e74877b9..5d54795538ce 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -232,7 +232,8 @@ void lowerPrintStatement(AbstractConverter &converter, mlir::Location loc,
 
   // Initiate io
   mlir::Value defaultUnit = builder.create<mlir::ConstantOp>(
-      loc, builder.getIntegerAttr(beginFuncTy.getInput(0), 1));
+      loc, builder.getIntegerAttr(beginFuncTy.getInput(0),
+				  Fortran::runtime::io::DefaultUnit));
   mlir::Value null =
       builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
   mlir::Value srcFileName =
diff --git a/lib/Optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
index 58ebb278a67e..20c52ef36000 100644
--- a/lib/Optimizer/Support/InternalNames.cpp
+++ b/lib/Optimizer/Support/InternalNames.cpp
@@ -9,6 +9,9 @@
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Support/CommandLine.h"
+
+static llvm::cl::opt<std::string> mainEntryName("main-entry-name", llvm::cl::desc("override the name of the default PROGRAM entry (may be helpful for using other runtimes)"));
 
 constexpr std::int64_t BAD_VALUE = -1;
 
@@ -186,6 +189,12 @@ fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules,
   return result.append(toLower(name));
 }
 
+llvm::StringRef fir::NameUniquer::doProgramEntry() {
+  if (mainEntryName.size())
+    return mainEntryName;
+  return "_QQmain";
+}
+
 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
 fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
   if (uniq.startswith("_Q")) {
@@ -229,7 +238,8 @@ fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
         break;
       case 'Q':
         nk = NameKind::GENERATED;
-        name = readName(uniq, i, i + 1, end);
+        name = uniq;
+	i = end;
         break;
       case 'T':
         nk = NameKind::DERIVED_TYPE;
diff --git a/test/Examples/hello.f90 b/test/Examples/hello.f90
new file mode 100644
index 000000000000..12fe0348b3dc
--- /dev/null
+++ b/test/Examples/hello.f90
@@ -0,0 +1,8 @@
+! RUN: bbc %s -o - | tco | llc --filetype=obj -o %t.o
+! RUN: cc -I%S/../.. %S/main.c -c -o %t.main.o
+! RUN: cc %t.o %t.main.o $(llvm-config --ldflags --libs) -L$(dirname $(which bbc))/../lib -lFortranRuntime -lFortranDecimal -lstdc++
+! RUN: ./a.out | FileCheck %s
+
+! CHECK: Hello, World!
+  print *, "Hello, World!"
+  end
diff --git a/test/Examples/main.c b/test/Examples/main.c
new file mode 100644
index 000000000000..9b26529bb730
--- /dev/null
+++ b/test/Examples/main.c
@@ -0,0 +1,14 @@
+#include "runtime/main.h"
+#include "runtime/stop.h"
+
+/* main entry into PROGRAM */
+void _QQmain();
+
+/* C main stub */
+int main(int argc, char **argv, char **envp)
+{
+  RTNAME(ProgramStart)(argc, argv, envp);
+  _QQmain();
+  RTNAME(ProgramEndStatement)();
+  return 0;
+}
diff --git a/test/Lower/program-units-fir-mangling.f90 b/test/Lower/program-units-fir-mangling.f90
index b7bc7bcbfc55..ee6461c78ee0 100644
--- a/test/Lower/program-units-fir-mangling.f90
+++ b/test/Lower/program-units-fir-mangling.f90
@@ -111,7 +111,7 @@ module subroutine draw()
 end submodule
 
 
-! CHECK-LABEL: func @MAIN_() {
+! CHECK-LABEL: func @_QQmain() {
 program test
 ! CHECK: }
 end program

From 93ad7bf55932c32b098f250331a7f56d62acc277 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Fri, 27 Mar 2020 11:10:59 -0700
Subject: [PATCH 276/345] remove test-lit

---
 test/lit.cfg.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index 72faae7ef36c..5ff0a505e8ac 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -34,7 +34,7 @@
 
 
 # test_exec_root: The root path where tests should be run.
-config.test_exec_root = os.path.join(config.flang_obj_root, 'test-lit')
+config.test_exec_root = os.path.join(config.flang_obj_root, 'test')
 
 config.substitutions.append(('%PATH%', config.environment['PATH']))
 

From fd7e1dbc9c070d653955938376d74afc0c42ea6d Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 27 Mar 2020 11:12:35 -0700
Subject: [PATCH 277/345] rebase of f18-llvm-project:mono changes

---
 include/flang/Optimizer/Dialect/FIRDialect.h |  4 +--
 lib/Lower/CMakeLists.txt                     |  2 +-
 lib/Lower/ConvertExpr.cpp                    |  2 +-
 lib/Optimizer/CodeGen.cpp                    |  2 +-
 lib/Optimizer/Transforms/RewriteLoop.cpp     | 36 ++++++++++----------
 5 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
index 31ca29536244..7a8fc18937fc 100644
--- a/include/flang/Optimizer/Dialect/FIRDialect.h
+++ b/include/flang/Optimizer/Dialect/FIRDialect.h
@@ -50,7 +50,7 @@ class FIROpsDialect final : public mlir::Dialect {
 inline void registerFIR() {
   // we want to register exactly once
   [[maybe_unused]] static bool init_once = [] {
-    mlir::registerDialect<mlir::AffineOpsDialect>();
+    mlir::registerDialect<mlir::AffineDialect>();
     mlir::registerDialect<mlir::LLVM::LLVMDialect>();
     mlir::registerDialect<mlir::loop::LoopOpsDialect>();
     mlir::registerDialect<mlir::StandardOpsDialect>();
@@ -65,7 +65,7 @@ inline void registerFIR() {
 inline void registerGeneralPasses() {
   mlir::createCanonicalizerPass();
   mlir::createCSEPass();
-  mlir::createVectorizePass({});
+  mlir::createSuperVectorizePass({});
   mlir::createLoopUnrollPass();
   mlir::createLoopUnrollAndJamPass();
   mlir::createSimplifyAffineStructuresPass();
diff --git a/lib/Lower/CMakeLists.txt b/lib/Lower/CMakeLists.txt
index 6e11725ef86e..3b89da9e997c 100644
--- a/lib/Lower/CMakeLists.txt
+++ b/lib/Lower/CMakeLists.txt
@@ -14,7 +14,7 @@ add_library(FortranLower
 
 target_link_libraries(FortranLower
   FIRSupport
-  MLIRAffineOps
+  MLIRAffine
   MLIRLLVMIR
   MLIRLoopToStandard
   MLIRStandardOps
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 4174f2cb44ef..60062b4abd00 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -21,7 +21,7 @@
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/type.h"
-#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Attributes.h"
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 7ad91624a056..1f6c2b8d1207 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -15,7 +15,7 @@
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
-#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/StandardTypes.h"
diff --git a/lib/Optimizer/Transforms/RewriteLoop.cpp b/lib/Optimizer/Transforms/RewriteLoop.cpp
index 7bbce631308c..c9e2fb148f2c 100644
--- a/lib/Optimizer/Transforms/RewriteLoop.cpp
+++ b/lib/Optimizer/Transforms/RewriteLoop.cpp
@@ -9,7 +9,7 @@
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Transforms/Passes.h"
-#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
@@ -19,15 +19,15 @@
 
 /// disable FIR to affine dialect conversion
 static llvm::cl::opt<bool>
-    ClDisableAffinePromo("disable-affine-promotion",
-                         llvm::cl::desc("disable FIR to Affine pass"),
-                         llvm::cl::init(false));
+    disableAffinePromo("disable-affine-promotion",
+                       llvm::cl::desc("disable FIR to Affine pass"),
+                       llvm::cl::init(false));
 
 /// disable FIR to loop dialect conversion
 static llvm::cl::opt<bool>
-    ClDisableLoopConversion("disable-loop-conversion",
-                            llvm::cl::desc("disable FIR to Loop pass"),
-                            llvm::cl::init(false));
+    disableLoopConversion("disable-loop-conversion",
+                          llvm::cl::desc("disable FIR to Loop pass"),
+                          llvm::cl::init(false));
 
 namespace fir {
 namespace {
@@ -57,14 +57,14 @@ class AffineDialectPromotion
     : public mlir::FunctionPass<AffineDialectPromotion> {
 public:
   void runOnFunction() override {
-    if (ClDisableAffinePromo)
+    if (disableAffinePromo)
       return;
 
-    auto *context{&getContext()};
+    auto *context = &getContext();
     mlir::OwningRewritePatternList patterns;
     patterns.insert<AffineLoopConv, AffineWhereConv>(context);
-    mlir::ConversionTarget target{*context};
-    target.addLegalDialect<mlir::AffineOpsDialect, FIROpsDialect,
+    mlir::ConversionTarget target = *context;
+    target.addLegalDialect<mlir::AffineDialect, FIROpsDialect,
                            mlir::loop::LoopOpsDialect,
                            mlir::StandardOpsDialect>();
     // target.addDynamicallyLegalOp<LoopOp, WhereOp>();
@@ -165,14 +165,14 @@ class LoopFirEndConv : public mlir::OpRewritePattern<FirEndOp> {
 class LoopDialectConversion : public mlir::FunctionPass<LoopDialectConversion> {
 public:
   void runOnFunction() override {
-    if (ClDisableLoopConversion)
+    if (disableLoopConversion)
       return;
 
-    auto *context{&getContext()};
+    auto *context = &getContext();
     mlir::OwningRewritePatternList patterns;
     patterns.insert<LoopLoopConv, LoopWhereConv, LoopFirEndConv>(context);
-    mlir::ConversionTarget target{*context};
-    target.addLegalDialect<mlir::AffineOpsDialect, FIROpsDialect,
+    mlir::ConversionTarget target = *context;
+    target.addLegalDialect<mlir::AffineDialect, FIROpsDialect,
                            mlir::loop::LoopOpsDialect,
                            mlir::StandardOpsDialect>();
     target.addIllegalOp<FirEndOp, LoopOp, WhereOp>();
@@ -187,16 +187,16 @@ class LoopDialectConversion : public mlir::FunctionPass<LoopDialectConversion> {
   }
 };
 } // namespace
+} // namespace fir
 
 /// Convert FIR loop constructs to the Affine dialect
-std::unique_ptr<mlir::Pass> createPromoteToAffinePass() {
+std::unique_ptr<mlir::Pass> fir::createPromoteToAffinePass() {
   return std::make_unique<AffineDialectPromotion>();
 }
 
 /// Convert `fir.loop` and `fir.where` to `loop.for` and `loop.if`.  This
 /// conversion enables the `createLowerToCFGPass` to transform these to CFG
 /// form.
-std::unique_ptr<mlir::Pass> createLowerToLoopPass() {
+std::unique_ptr<mlir::Pass> fir::createLowerToLoopPass() {
   return std::make_unique<LoopDialectConversion>();
 }
-} // namespace fir

From 49ed237ff162c89caf2cca25421ea90152ea8d47 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 27 Mar 2020 12:14:40 -0700
Subject: [PATCH 278/345] fix warning

---
 include/flang/Lower/PFTBuilder.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index f364becb23f9..da0619ed2ae8 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -130,7 +130,7 @@ class ReferenceVariant {
 
   ReferenceVariant() = delete;
   template <typename B>
-  ReferenceVariant(const B &b) : u{ConstRef<B>{b}} {};
+  ReferenceVariant(const B &b) : u{ConstRef<B>{b}} {}
 
   template <typename B>
   constexpr const B &get() const {

From b3c43d7b3e269f0f2574d342cddbea3ff1ce4461 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 27 Mar 2020 14:04:03 -0700
Subject: [PATCH 279/345] work around -Werror

---
 test/Examples/main.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/Examples/main.c b/test/Examples/main.c
index 9b26529bb730..7742730637c8 100644
--- a/test/Examples/main.c
+++ b/test/Examples/main.c
@@ -5,7 +5,7 @@
 void _QQmain();
 
 /* C main stub */
-int main(int argc, char **argv, char **envp)
+int main(int argc, const char *argv[], const char *envp[])
 {
   RTNAME(ProgramStart)(argc, argv, envp);
   _QQmain();

From 97072336e20cb47a26bcf4f4c2918d7d703b8033 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Fri, 27 Mar 2020 15:54:22 -0700
Subject: [PATCH 280/345] more work on hello.f90 test

---
 include/flang/Common/enum-set.h | 4 ++++
 runtime/CMakeLists.txt          | 8 +-------
 test/Examples/hello.f90         | 7 ++++++-
 test/lit.cfg.py                 | 1 +
 test/lit.site.cfg.py.in         | 1 +
 5 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/include/flang/Common/enum-set.h b/include/flang/Common/enum-set.h
index 185c48825621..279ad2ae7cc1 100644
--- a/include/flang/Common/enum-set.h
+++ b/include/flang/Common/enum-set.h
@@ -16,7 +16,9 @@
 
 #include "constexpr-bitset.h"
 #include "idioms.h"
+#ifndef FORTRAN_IN_RUNTIME
 #include "llvm/Support/raw_ostream.h"
+#endif
 #include <bitset>
 #include <cstddef>
 #include <initializer_list>
@@ -199,6 +201,7 @@ template <typename ENUM, std::size_t BITS> class EnumSet {
     }
   }
 
+#ifndef FORTRAN_IN_RUNTIME
   llvm::raw_ostream &Dump(
       llvm::raw_ostream &o, std::string EnumToString(enumerationType)) const {
     char sep{'{'};
@@ -208,6 +211,7 @@ template <typename ENUM, std::size_t BITS> class EnumSet {
     });
     return o << (sep == '{' ? "{}" : "}");
   }
+#endif
 
 private:
   bitsetType bitset_{};
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
index 9232d8095fc1..9f03848061fc 100644
--- a/runtime/CMakeLists.txt
+++ b/runtime/CMakeLists.txt
@@ -1,10 +1,4 @@
-#===-- runtime/CMakeLists.txt ----------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DFORTRAN_IN_RUNTIME")
 
 include(CheckCXXSymbolExists)
 include(CheckCXXSourceCompiles)
diff --git a/test/Examples/hello.f90 b/test/Examples/hello.f90
index 12fe0348b3dc..32b7e8b6ad6c 100644
--- a/test/Examples/hello.f90
+++ b/test/Examples/hello.f90
@@ -1,6 +1,11 @@
+! Note: The Fortran runtime libraries have dependences on the C++ runtime and
+! LLVM runtime.  To work around the former, this test explicitly links in
+! libstdc++.a.  To work around the latter, the source of Common/enum-set.h was
+! hacked to exclude references to llvm ADTs.
+
 ! RUN: bbc %s -o - | tco | llc --filetype=obj -o %t.o
 ! RUN: cc -I%S/../.. %S/main.c -c -o %t.main.o
-! RUN: cc %t.o %t.main.o $(llvm-config --ldflags --libs) -L$(dirname $(which bbc))/../lib -lFortranRuntime -lFortranDecimal -lstdc++
+! RUN: cc %t.o %t.main.o -L%L -lFortranRuntime -lFortranDecimal -lstdc++
 ! RUN: ./a.out | FileCheck %s
 
 ! CHECK: Hello, World!
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index 5ff0a505e8ac..9955f4036cd0 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -66,6 +66,7 @@
     llvm_config.with_environment('PATH', config.flang_llvm_tools_dir, append_path=True)
 
 config.substitutions.append(('%B', config.flang_obj_root))
+config.substitutions.append(("%L", config.llvm_lib_dir))
 
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index 189270127ba5..ee78024c4d5f 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -3,6 +3,7 @@
 import sys
 
 config.llvm_tools_dir = "@LLVM_TOOLS_BINARY_DIR@"
+config.llvm_lib_dir = "@LLVM_LIBS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"

From 6f4fcbaeaeeee1a7fef6ce9a3ef28b9a9a32600d Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Fri, 27 Mar 2020 15:55:28 -0700
Subject: [PATCH 281/345] changes to make coordinate_of work for simple pointer
 arithmetic add test char01.fir other misc. changes

---
 include/flang/Optimizer/Dialect/FIROps.td |  4 +-
 lib/Optimizer/CodeGen.cpp                 | 70 +++++++++++++++++++----
 test/Examples/hello.f90                   |  4 +-
 test/Fir/char01.fir                       | 13 +++++
 4 files changed, 75 insertions(+), 16 deletions(-)
 create mode 100644 test/Fir/char01.fir

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 80bb121f50d8..2ae89eacb47f 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -1576,8 +1576,8 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", []> {
 
     ```mlir
       %i = ... : index
-      %h = ... : !fir.heap<!fir.array<?:f32>>
-      %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
+      %h = ... : !fir.heap<!fir.array<100 x f32>>
+      %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<100 x f32>>, index) -> !fir.ref<f32>
     ```
 
     In the example, `%p` will be a pointer to the `%i`-th f32 value in the
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 1f6c2b8d1207..370f12118520 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -1260,6 +1260,9 @@ struct CoordinateOpConversion
     mlir::Value base = operands[0];
     auto firRef = coor.ref();
     auto firTy = firRef.getType();
+    mlir::Type cpnTy = getReferenceEleTy(firTy);
+    bool columnIsDeferred = false;
+    bool hasSubdimension = hasSubDimensions(cpnTy);
 
     // if argument 0 is boxed, get the base pointer from the box
     if (auto boxTy = firTy.dyn_cast<fir::BoxType>()) {
@@ -1287,13 +1290,22 @@ struct CoordinateOpConversion
       auto p = genGEP(loc, pty, rewriter, base, c0, c0_);
       // base = box->data : ptr
       base = rewriter.create<mlir::LLVM::LoadOp>(loc, pty, p);
-    }
 
-    mlir::Type cpnTy = getReferenceEleTy(firTy);
-
-    if (FIRToLLVMTypeConverter::dynamicallySized(cpnTy)) {
-      TODO();
+      // If the base has dynamic shape, it has to be boxed as the dimension
+      // information is saved in the box.
+      if (FIRToLLVMTypeConverter::dynamicallySized(cpnTy)) {
+	TODO();
+	return success();
+      }
+    } else {
+      if (FIRToLLVMTypeConverter::dynamicallySized(cpnTy))
+	return mlir::emitError(loc, "bare reference to unknown shape");
     }
+    if (!hasSubdimension)
+      columnIsDeferred = true;
+
+    if (!validCoordinate(cpnTy, operands.drop_front(1)))
+      return mlir::emitError(loc, "coordinate has incorrect dimension");
 
     // if arrays has known shape
     const bool hasKnownShape =
@@ -1301,9 +1313,8 @@ struct CoordinateOpConversion
 
     // If only the column is `?`, then we can simply place the column value in
     // the 0-th GEP position.
-    bool columnIsDeferred = false;
-    if (!hasKnownShape)
-      if (auto arrTy = cpnTy.dyn_cast<fir::SequenceType>()) {
+    if (auto arrTy = cpnTy.dyn_cast<fir::SequenceType>()) {
+      if (!hasKnownShape) {
         const auto sz = arrTy.getDimension();
         if (arraysHaveKnownShape(arrTy.getEleTy(),
                                  operands.drop_front(1 + sz))) {
@@ -1318,10 +1329,11 @@ struct CoordinateOpConversion
             columnIsDeferred = true;
         }
       }
+    }
 
     if (hasKnownShape || columnIsDeferred) {
       SmallVector<mlir::Value, 8> offs;
-      if (hasKnownShape)
+      if (hasKnownShape && hasSubdimension)
         offs.push_back(c0);
       const auto sz = operands.size();
       llvm::Optional<int> dims;
@@ -1329,6 +1341,9 @@ struct CoordinateOpConversion
       for (std::remove_const_t<decltype(sz)> i = 1; i < sz; ++i) {
         auto nxtOpnd = operands[i];
 
+	if (!cpnTy)
+	  return mlir::emitError(loc, "invalid coordinate/check failed");
+	    
         // check if the i-th coordinate relates to an array
         if (dims.hasValue()) {
           arrIdx.push_back(nxtOpnd);
@@ -1361,7 +1376,7 @@ struct CoordinateOpConversion
         } else if (auto strTy = cpnTy.dyn_cast<mlir::TupleType>()) {
           cpnTy = strTy.getType(getIntValue(nxtOpnd));
         } else {
-          llvm_unreachable("unhandled type");
+          cpnTy = nullptr;
         }
         offs.push_back(nxtOpnd);
       }
@@ -1412,6 +1427,11 @@ struct CoordinateOpConversion
     return failure();
   }
 
+  bool hasSubDimensions(mlir::Type type) const {
+    return type.isa<fir::SequenceType>() || type.isa<fir::RecordType>() ||
+      type.isa<mlir::TupleType>();
+  }
+  
   /// Walk the abstract memory layout and determine if the path traverses any
   /// array types with unknown shape. Return true iff all the array types have a
   /// constant shape along the path.
@@ -1430,10 +1450,36 @@ struct CoordinateOpConversion
       } else if (auto strTy = type.dyn_cast<mlir::TupleType>()) {
         type = strTy.getType(getIntValue(nxtOpnd));
       } else {
-        return false;
+	return true;
+      }
+    }
+    return true;
+  }
+
+  bool validCoordinate(mlir::Type type, OperandTy coors) const {
+    const auto sz = coors.size();
+    std::remove_const_t<decltype(sz)> i = 0;
+    bool subEle = false;
+    bool ptrEle = false;
+    for (; i < sz; ++i) {
+      auto nxtOpnd = coors[i];
+      if (auto arrTy = type.dyn_cast<fir::SequenceType>()) {
+	subEle = true;
+        i += arrTy.getDimension() - 1;
+        type = arrTy.getEleTy();
+      } else if (auto strTy = type.dyn_cast<fir::RecordType>()) {
+	subEle = true;
+        type = strTy.getType(getIntValue(nxtOpnd));
+      } else if (auto strTy = type.dyn_cast<mlir::TupleType>()) {
+	subEle = true;
+        type = strTy.getType(getIntValue(nxtOpnd));
+      } else {
+	ptrEle = true;
       }
     }
-    return i == sz;
+    if (ptrEle)
+      return (!subEle) && (sz == 1);
+    return subEle && (i == sz);
   }
 
   /// Returns the element type of the reference `refTy`.
diff --git a/test/Examples/hello.f90 b/test/Examples/hello.f90
index 32b7e8b6ad6c..10d713fd9c9a 100644
--- a/test/Examples/hello.f90
+++ b/test/Examples/hello.f90
@@ -1,11 +1,11 @@
 ! Note: The Fortran runtime libraries have dependences on the C++ runtime and
-! LLVM runtime.  To work around the former, this test explicitly links in
+! LLVM libraries.  To work around the former, this test explicitly links in
 ! libstdc++.a.  To work around the latter, the source of Common/enum-set.h was
 ! hacked to exclude references to llvm ADTs.
 
 ! RUN: bbc %s -o - | tco | llc --filetype=obj -o %t.o
 ! RUN: cc -I%S/../.. %S/main.c -c -o %t.main.o
-! RUN: cc %t.o %t.main.o -L%L -lFortranRuntime -lFortranDecimal -lstdc++
+! RUN: cc %t.o %t.main.o -L%L -lFortranRuntime -lFortranDecimal -lstdc++ -lm
 ! RUN: ./a.out | FileCheck %s
 
 ! CHECK: Hello, World!
diff --git a/test/Fir/char01.fir b/test/Fir/char01.fir
new file mode 100644
index 000000000000..4bf3771ff0c0
--- /dev/null
+++ b/test/Fir/char01.fir
@@ -0,0 +1,13 @@
+// RUN: tco -emit-fir %s | tco | FileCheck %s
+
+// CHECK-LABEL: @test
+func @test(%arg0 : !fir.ref<!fir.char<1>>, %arg1 : !fir.ref<!fir.char<1>>, %arg2 : i32) {
+  // CHECK: getelementptr i8, i8*
+  %1 = fir.coordinate_of %arg1, %arg2 : (!fir.ref<!fir.char<1>>, i32) -> !fir.ref<!fir.char<1>>
+  // CHECK: load i8, i8*
+  %2 = fir.load %1 : !fir.ref<!fir.char<1>>
+  // CHECK: store i8
+  fir.store %2 to %arg0 : !fir.ref<!fir.char<1>>
+  // CHECK: ret void
+  return
+}

From 9f5e5d197947a8678f9406f0e94614a7ef48877a Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 27 Mar 2020 18:29:46 -0700
Subject: [PATCH 282/345] add comment

---
 test/Examples/hello.f90 | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/Examples/hello.f90 b/test/Examples/hello.f90
index 10d713fd9c9a..120e5f279f56 100644
--- a/test/Examples/hello.f90
+++ b/test/Examples/hello.f90
@@ -2,6 +2,7 @@
 ! LLVM libraries.  To work around the former, this test explicitly links in
 ! libstdc++.a.  To work around the latter, the source of Common/enum-set.h was
 ! hacked to exclude references to llvm ADTs.
+! Note: On linux, the Fortran runtime wants to include libm as well.
 
 ! RUN: bbc %s -o - | tco | llc --filetype=obj -o %t.o
 ! RUN: cc -I%S/../.. %S/main.c -c -o %t.main.o

From 3479b7b941a850b5de232f326c1853a44a4d5024 Mon Sep 17 00:00:00 2001
From: V Donaldson <vdonaldson@nvidia.com>
Date: Fri, 27 Mar 2020 22:49:33 -0700
Subject: [PATCH 283/345] Fix a bug with unstructured else block control flow.
 Update the PFT for select statements.

---
 lib/Lower/Bridge.cpp     |  4 ++--
 lib/Lower/PFTBuilder.cpp | 46 ++++++++++++++++++++++++++++------------
 2 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index d5d59e7935b2..f73ee0c024c6 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -1124,8 +1124,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                           : eval.block);
     }
     eval.visit([&](const auto &stmt) { genFIR(eval, stmt); });
-    if (unstructuredContext && eval.lowerAsUnstructured() &&
-        eval.controlSuccessor && eval.isActionStmt() && blockIsUnterminated()) {
+    if (unstructuredContext && eval.isActionStmt() && eval.controlSuccessor &&
+        eval.controlSuccessor->block && blockIsUnterminated()) {
       // Exit from an unstructured IF or SELECT construct block.
       genFIRUnconditionalBranch(eval.controlSuccessor);
     }
diff --git a/lib/Lower/PFTBuilder.cpp b/lib/Lower/PFTBuilder.cpp
index b6dfd4824c30..e64f3dc4ae40 100644
--- a/lib/Lower/PFTBuilder.cpp
+++ b/lib/Lower/PFTBuilder.cpp
@@ -435,7 +435,7 @@ class PFTBuilder {
   /// top-level statements of a program.
   void analyzeBranches(pft::Evaluation *parentConstruct,
                        std::list<pft::Evaluation> &evaluationList) {
-    pft::Evaluation *lastIfConstructEvaluation{nullptr};
+    pft::Evaluation *lastConstructStmtEvaluation{nullptr};
     pft::Evaluation *lastIfStmtEvaluation{nullptr};
     for (auto &eval : evaluationList) {
       eval.visit(common::visitors{
@@ -513,8 +513,17 @@ class PFTBuilder {
           [&](const parser::SelectCaseStmt &s) {
             insertConstructName(s, parentConstruct);
             eval.lexicalSuccessor->isNewBlock = true;
+            lastConstructStmtEvaluation = &eval;
+          },
+          [&](const parser::CaseStmt &) {
+            eval.isNewBlock = true;
+            lastConstructStmtEvaluation->controlSuccessor = &eval;
+            lastConstructStmtEvaluation = &eval;
+          },
+          [&](const parser::EndSelectStmt &) {
+            eval.lexicalSuccessor->isNewBlock = true;
+            lastConstructStmtEvaluation = nullptr;
           },
-          [&](const parser::CaseStmt &) { eval.isNewBlock = true; },
           [&](const parser::ChangeTeamStmt &s) {
             insertConstructName(s, parentConstruct);
           },
@@ -583,26 +592,28 @@ class PFTBuilder {
           [&](const parser::IfThenStmt &s) {
             insertConstructName(s, parentConstruct);
             eval.lexicalSuccessor->isNewBlock = true;
-            lastIfConstructEvaluation = &eval;
+            lastConstructStmtEvaluation = &eval;
           },
           [&](const parser::ElseIfStmt &) {
             eval.isNewBlock = true;
             eval.lexicalSuccessor->isNewBlock = true;
-            lastIfConstructEvaluation->controlSuccessor = &eval;
-            lastIfConstructEvaluation = &eval;
+            lastConstructStmtEvaluation->controlSuccessor = &eval;
+            lastConstructStmtEvaluation = &eval;
           },
           [&](const parser::ElseStmt &) {
             eval.isNewBlock = true;
-            lastIfConstructEvaluation->controlSuccessor = &eval;
-            lastIfConstructEvaluation = &eval;
+            lastConstructStmtEvaluation->controlSuccessor = &eval;
+            lastConstructStmtEvaluation = nullptr;
           },
           [&](const parser::EndIfStmt &) {
             if (parentConstruct->lowerAsUnstructured()) {
               parentConstruct->constructExit->isNewBlock = true;
             }
-            lastIfConstructEvaluation->controlSuccessor =
-                parentConstruct->constructExit;
-            lastIfConstructEvaluation = nullptr;
+            if (lastConstructStmtEvaluation) {
+              lastConstructStmtEvaluation->controlSuccessor =
+                  parentConstruct->constructExit;
+              lastConstructStmtEvaluation = nullptr;
+            }
           },
           [&](const parser::SelectRankStmt &s) {
             insertConstructName(s, parentConstruct);
@@ -621,7 +632,10 @@ class PFTBuilder {
             // EndBlockStmt may have code.
             eval.constructExit = &eval.evaluationList->back();
           },
-          [&](const parser::CaseConstruct &) { setConstructExit(eval); },
+          [&](const parser::CaseConstruct &) {
+            setConstructExit(eval);
+            eval.isUnstructured = true;
+          },
           [&](const parser::ChangeTeamConstruct &) {
             // EndChangeTeamStmt may have code.
             eval.constructExit = &eval.evaluationList->back();
@@ -632,8 +646,14 @@ class PFTBuilder {
           },
           [&](const parser::DoConstruct &) { setConstructExit(eval); },
           [&](const parser::IfConstruct &) { setConstructExit(eval); },
-          [&](const parser::SelectRankConstruct &) { setConstructExit(eval); },
-          [&](const parser::SelectTypeConstruct &) { setConstructExit(eval); },
+          [&](const parser::SelectRankConstruct &) {
+            setConstructExit(eval);
+            eval.isUnstructured = true;
+          },
+          [&](const parser::SelectTypeConstruct &) {
+            setConstructExit(eval);
+            eval.isUnstructured = true;
+          },
 
           [&](const auto &stmt) {
             using A = std::decay_t<decltype(stmt)>;

From 7a200882a4fea263c9ffcb6872152f104dc48251 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Sat, 28 Mar 2020 11:04:29 -0700
Subject: [PATCH 284/345] clang-format

---
 lib/Optimizer/CodeGen.cpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 370f12118520..036dede61190 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -1294,12 +1294,12 @@ struct CoordinateOpConversion
       // If the base has dynamic shape, it has to be boxed as the dimension
       // information is saved in the box.
       if (FIRToLLVMTypeConverter::dynamicallySized(cpnTy)) {
-	TODO();
-	return success();
+        TODO();
+        return success();
       }
     } else {
       if (FIRToLLVMTypeConverter::dynamicallySized(cpnTy))
-	return mlir::emitError(loc, "bare reference to unknown shape");
+        return mlir::emitError(loc, "bare reference to unknown shape");
     }
     if (!hasSubdimension)
       columnIsDeferred = true;
@@ -1341,9 +1341,9 @@ struct CoordinateOpConversion
       for (std::remove_const_t<decltype(sz)> i = 1; i < sz; ++i) {
         auto nxtOpnd = operands[i];
 
-	if (!cpnTy)
-	  return mlir::emitError(loc, "invalid coordinate/check failed");
-	    
+        if (!cpnTy)
+          return mlir::emitError(loc, "invalid coordinate/check failed");
+
         // check if the i-th coordinate relates to an array
         if (dims.hasValue()) {
           arrIdx.push_back(nxtOpnd);
@@ -1429,9 +1429,9 @@ struct CoordinateOpConversion
 
   bool hasSubDimensions(mlir::Type type) const {
     return type.isa<fir::SequenceType>() || type.isa<fir::RecordType>() ||
-      type.isa<mlir::TupleType>();
+           type.isa<mlir::TupleType>();
   }
-  
+
   /// Walk the abstract memory layout and determine if the path traverses any
   /// array types with unknown shape. Return true iff all the array types have a
   /// constant shape along the path.
@@ -1450,7 +1450,7 @@ struct CoordinateOpConversion
       } else if (auto strTy = type.dyn_cast<mlir::TupleType>()) {
         type = strTy.getType(getIntValue(nxtOpnd));
       } else {
-	return true;
+        return true;
       }
     }
     return true;
@@ -1464,17 +1464,17 @@ struct CoordinateOpConversion
     for (; i < sz; ++i) {
       auto nxtOpnd = coors[i];
       if (auto arrTy = type.dyn_cast<fir::SequenceType>()) {
-	subEle = true;
+        subEle = true;
         i += arrTy.getDimension() - 1;
         type = arrTy.getEleTy();
       } else if (auto strTy = type.dyn_cast<fir::RecordType>()) {
-	subEle = true;
+        subEle = true;
         type = strTy.getType(getIntValue(nxtOpnd));
       } else if (auto strTy = type.dyn_cast<mlir::TupleType>()) {
-	subEle = true;
+        subEle = true;
         type = strTy.getType(getIntValue(nxtOpnd));
       } else {
-	ptrEle = true;
+        ptrEle = true;
       }
     }
     if (ptrEle)

From 353da0e8774de6340f8c92dac42e6d6ce3183e74 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Sat, 28 Mar 2020 12:36:32 -0700
Subject: [PATCH 285/345] add source loc to PROGRAM work on OPEN

---
 include/flang/Lower/PFTBuilder.h | 16 +++++-
 lib/Lower/Bridge.cpp             | 14 +----
 lib/Lower/IO.cpp                 | 98 +++++++++++++++++++++++++-------
 lib/Lower/RTBuilder.h            |  3 +-
 4 files changed, 99 insertions(+), 32 deletions(-)

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index da0619ed2ae8..01d24049bc1f 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -134,7 +134,7 @@ class ReferenceVariant {
 
   template <typename B>
   constexpr const B &get() const {
-    return std::get<ConstRef<B>> > (u).get();
+    return std::get<ConstRef<B>>> (u).get();
   }
   template <typename B>
   constexpr const B *getIf() const {
@@ -327,6 +327,15 @@ struct FunctionLikeUnit : public ProgramUnit {
     return endStmt.isA<parser::Statement<parser::EndProgramStmt>>();
   }
 
+  /// Get the starting source location for this function like unit
+  parser::CharBlock getStartingSourceLoc() {
+    if (beginStmt)
+      return stmtSourceLoc(*beginStmt);
+    if (evaluationList.size())
+      return evaluationList.front().position;
+    return stmtSourceLoc(endStmt);
+  }
+
   /// Returns reference to the subprogram symbol of this FunctionLikeUnit.
   /// Dies if the FunctionLikeUnit is not a subprogram.
   const semantics::Symbol &getSubprogramSymbol() const {
@@ -334,6 +343,11 @@ struct FunctionLikeUnit : public ProgramUnit {
     return *symbol;
   }
 
+  /// Helper to get location from FunctionLikeUnit begin/end statements.
+  static parser::CharBlock stmtSourceLoc(const FunctionStatement &stmt) {
+    return stmt.visit(common::visitors{[](const auto &x) { return x.source; }});
+  }
+
   /// Anonymous programs do not have a begin statement
   std::optional<FunctionStatement> beginStmt;
   FunctionStatement endStmt;
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index f73ee0c024c6..d9177264d700 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -1139,13 +1139,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return Fortran::lower::FirOpBuilder::createFunction(loc, module, name, ty);
   }
 
-  /// Helper to get location from FunctionLikeUnit begin/end statements.
-  static Fortran::parser::CharBlock functionStmtSource(
-      const Fortran::lower::pft::FunctionLikeUnit::FunctionStatement &stmt) {
-    return stmt.visit(
-        Fortran::common::visitors{[](const auto &x) { return x.source; }});
-  }
-
   /// Prepare to translate a new function
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     assert(!builder && "expected nullptr");
@@ -1156,9 +1149,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     // FIXME: do NOT use unknown for the anonymous PROGRAM case. We probably
     // should just stash the location in the funit regardless.
-    mlir::Location loc = funit.beginStmt.has_value()
-                             ? toLocation(functionStmtSource(*funit.beginStmt))
-                             : mlir::UnknownLoc::get(&mlirContext);
+    mlir::Location loc = toLocation(funit.getStartingSourceLoc());
     mlir::FuncOp func =
         Fortran::lower::FirOpBuilder::getNamedFunction(module, name);
     if (!func)
@@ -1240,7 +1231,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   /// Emit return and cleanup after the function has been translated.
   void endNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
-    setCurrentPosition(functionStmtSource(funit.endStmt));
+    setCurrentPosition(
+        Fortran::lower::pft::FunctionLikeUnit::stmtSourceLoc(funit.endStmt));
 
     if (funit.isMainProgram()) {
       genFIRProgramExit();
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 5d54795538ce..55b6f1c3e8d6 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -132,7 +132,8 @@ FormatItems lowerFormat(AbstractConverter &converter,
   return formatItems;
 }
 
-mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder, mlir::Type type) {
+mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
+                                  mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
     if (ty.getWidth() == 1)
       return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
@@ -157,7 +158,8 @@ mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder, mlir::T
 /// The I/O library interface requires that COMPLEX and CHARACTER typed values
 /// be extracted and passed as separate values.
 llvm::SmallVector<mlir::Value, 4>
-splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc, mlir::Value arg) {
+splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
+               mlir::Value arg) {
   mlir::Value zero;
   mlir::Value one;
   mlir::Type argTy = arg.getType();
@@ -202,8 +204,9 @@ splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc, mlir::
 
 /// Generate a call to an Output I/O function.
 /// The specific call is determined dynamically by the argument type.
-void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
-                          mlir::Type argType, mlir::Value cookie,
+void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
+                          mlir::Location loc, mlir::Type argType,
+                          mlir::Value cookie,
                           llvm::SmallVector<mlir::Value, 4> &operands) {
   int i = 1;
   llvm::SmallVector<mlir::Value, 4> actuals{cookie};
@@ -215,6 +218,19 @@ void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder, mlir::Location
   builder.create<mlir::CallOp>(loc, outputFunc, actuals);
 }
 
+mlir::Value getDefaultFilename(Fortran::lower::FirOpBuilder &builder,
+                               mlir::Location loc, mlir::Type toType) {
+  mlir::Value null =
+      builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
+  return builder.create<fir::ConvertOp>(loc, toType, null);
+}
+
+mlir::Value getDefaultLineNo(Fortran::lower::FirOpBuilder &builder,
+                             mlir::Location loc, mlir::Type toType) {
+  return builder.create<mlir::ConstantOp>(loc,
+                                          builder.getIntegerAttr(toType, 0));
+}
+
 /// Lower print statement assuming a dummy runtime interface for now.
 void lowerPrintStatement(AbstractConverter &converter, mlir::Location loc,
                          mlir::ValueRange args,
@@ -233,13 +249,9 @@ void lowerPrintStatement(AbstractConverter &converter, mlir::Location loc,
   // Initiate io
   mlir::Value defaultUnit = builder.create<mlir::ConstantOp>(
       loc, builder.getIntegerAttr(beginFuncTy.getInput(0),
-				  Fortran::runtime::io::DefaultUnit));
-  mlir::Value null =
-      builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
-  mlir::Value srcFileName =
-      builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(1), null);
-  mlir::Value lineNo = builder.create<mlir::ConstantOp>(
-      loc, builder.getIntegerAttr(beginFuncTy.getInput(2), 0));
+                                  Fortran::runtime::io::DefaultUnit));
+  auto srcFileName = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
+  auto lineNo = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
   llvm::SmallVector<mlir::Value, 3> beginArgs{defaultUnit, srcFileName, lineNo};
   mlir::Value cookie =
       builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
@@ -349,16 +361,64 @@ mlir::Value genRewindStatement(AbstractConverter &converter,
   return genPosOrFlushLikeStmt<mkIOKey(BeginRewind)>(converter, stmt);
 }
 
+static bool hasFileUnit(const Fortran::parser::OpenStmt &stmt) {
+  for (const auto &spec : stmt.v)
+    if (std::holds_alternative<Fortran::parser::FileUnitNumber>(spec.u))
+      return true;
+  return false;
+}
+
+static bool hasNewUnit(const Fortran::parser::OpenStmt &stmt) {
+  for (const auto &spec : stmt.v)
+    if (std::holds_alternative<Fortran::parser::ConnectSpec::Newunit>(spec.u))
+      return true;
+  return false;
+}
+
+static Fortran::runtime::io::ExternalUnit
+getFileUnit(const Fortran::parser::OpenStmt &stmt) {
+  for (const auto &spec : stmt.v)
+    if (auto *f = std::get_if<Fortran::parser::FileUnitNumber>(&spec.u))
+      return *Fortran::evaluate::ToInt64(*Fortran::semantics::GetExpr(f->v));
+  llvm_unreachable("must have a file unit");
+}
+
+static mlir::Value lowerErrorHandling(AbstractConverter &converter,
+                                      mlir::Value result) {
+  // FIXME - implement
+  return result;
+}
+
 mlir::Value genOpenStatement(AbstractConverter &converter,
-                             const Fortran::parser::OpenStmt &) {
+                             const Fortran::parser::OpenStmt &stmt) {
   auto builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
-  // if (...
-  beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
-  // else
-  beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(builder);
-  TODO();
-  return {};
+  llvm::SmallVector<mlir::Value, 4> beginArgs;
+  auto loc = converter.getCurrentLocation();
+  if (hasFileUnit(stmt)) {
+    auto unit = getFileUnit(stmt);
+    beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
+    mlir::FunctionType beginFuncTy = beginFunc.getType();
+    beginArgs.push_back(builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(beginFuncTy.getInput(0), unit)));
+    beginArgs.push_back(
+        getDefaultFilename(builder, loc, beginFuncTy.getInput(1)));
+    beginArgs.push_back(
+        getDefaultLineNo(builder, loc, beginFuncTy.getInput(2)));
+  } else {
+    assert(hasNewUnit(stmt));
+    beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(builder);
+    mlir::FunctionType beginFuncTy = beginFunc.getType();
+    beginArgs.push_back(
+        getDefaultFilename(builder, loc, beginFuncTy.getInput(0)));
+    beginArgs.push_back(
+        getDefaultLineNo(builder, loc, beginFuncTy.getInput(1)));
+  }
+  auto cookie =
+      builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
+  // TODO: handle the other specifiers in the list
+  auto endVal = genEndIO(builder, loc, cookie);
+  return lowerErrorHandling(converter, endVal);
 }
 
 mlir::Value genCloseStatement(AbstractConverter &converter,
@@ -374,7 +434,7 @@ void genPrintStatement(AbstractConverter &converter,
                        const Fortran::parser::PrintStmt &stmt) {
   llvm::SmallVector<mlir::Value, 4> args;
   for (auto &item : std::get<std::list<Fortran::parser::OutputItem>>(stmt.t)) {
-    if (auto *pe{std::get_if<Fortran::parser::Expr>(&item.u)}) {
+    if (auto *pe = std::get_if<Fortran::parser::Expr>(&item.u)) {
       auto loc = converter.genLocation(pe->source);
       args.push_back(
           converter.genExprValue(Fortran::semantics::GetExpr(*pe), loc));
diff --git a/lib/Lower/RTBuilder.h b/lib/Lower/RTBuilder.h
index 8750631c6c79..18591a7b7a87 100644
--- a/lib/Lower/RTBuilder.h
+++ b/lib/Lower/RTBuilder.h
@@ -22,7 +22,6 @@
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/SmallVector.h"
-#include <cstddef>
 #include <functional>
 
 // List the runtime headers we want to be able to dissect
@@ -176,6 +175,7 @@ struct RuntimeTableKey<RT(ATs...)> {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
 #endif
+
 // clang++ generates warnings about usage of a GNU extension, ignore them
 template <char... Cs>
 using RuntimeIdentifier = std::integer_sequence<char, Cs...>;
@@ -183,6 +183,7 @@ template <typename T, T... Cs>
 static constexpr RuntimeIdentifier<Cs...> operator""_rt_ident() {
   return {};
 }
+
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif

From 5e8d3f08a820087207a8512909a0ed00fd2f10fd Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Sat, 28 Mar 2020 16:25:01 -0700
Subject: [PATCH 286/345] more work on IO

---
 lib/Lower/IO.cpp | 400 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 272 insertions(+), 128 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 55b6f1c3e8d6..1f6fdc274e76 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -18,17 +18,15 @@
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 
-#define TODO() assert(false && "not yet implemented")
+#define TODO() llvm_unreachable("not yet implemented")
 
 using namespace Fortran::runtime::io;
 
-namespace Fortran::lower {
-namespace {
-
 #define NAMIFY_HELPER(X) #X
 #define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
 #define mkIOKey(X) mkKey(IONAME(X))
 
+namespace Fortran::lower {
 /// Static table of IO runtime calls
 ///
 /// This logical map contains the name and type builder function for each IO
@@ -60,13 +58,16 @@ static constexpr std::tuple<
     mkIOKey(OutputComplex64), mkIOKey(OutputComplex32), mkIOKey(OutputAscii),
     mkIOKey(InputAscii), mkIOKey(OutputLogical), mkIOKey(InputLogical),
     mkIOKey(SetAccess), mkIOKey(SetAction), mkIOKey(SetAsynchronous),
-    mkIOKey(SetEncoding), mkIOKey(SetEncoding), mkIOKey(SetForm),
-    mkIOKey(SetPosition), mkIOKey(SetRecl), mkIOKey(SetStatus),
-    mkIOKey(SetFile), mkIOKey(GetNewUnit), mkIOKey(GetSize),
-    mkIOKey(GetIoLength), mkIOKey(GetIoMsg), mkIOKey(InquireCharacter),
-    mkIOKey(InquireLogical), mkIOKey(InquirePendingId),
-    mkIOKey(InquireInteger64), mkIOKey(EndIoStatement)>
+    mkIOKey(SetEncoding), mkIOKey(SetForm), mkIOKey(SetPosition),
+    mkIOKey(SetRecl), mkIOKey(SetStatus), mkIOKey(SetFile), mkIOKey(GetNewUnit),
+    mkIOKey(GetSize), mkIOKey(GetIoLength), mkIOKey(GetIoMsg),
+    mkIOKey(InquireCharacter), mkIOKey(InquireLogical),
+    mkIOKey(InquirePendingId), mkIOKey(InquireInteger64),
+    mkIOKey(EndIoStatement)>
     newIOTable;
+} // namespace Fortran::lower
+
+using namespace Fortran::lower;
 
 /// Helper function to retrieve the name of the IO function given the key `A`
 template <typename A>
@@ -93,7 +94,7 @@ inline int64_t getLength(mlir::Type argTy) {
 
 /// Get (or generate) the MLIR FuncOp for a given IO runtime function.
 template <typename E>
-mlir::FuncOp getIORuntimeFunc(Fortran::lower::FirOpBuilder &builder) {
+static mlir::FuncOp getIORuntimeFunc(Fortran::lower::FirOpBuilder &builder) {
   auto name = getName<E>();
   auto func = builder.getNamedFunction(name);
   if (func)
@@ -106,8 +107,8 @@ mlir::FuncOp getIORuntimeFunc(Fortran::lower::FirOpBuilder &builder) {
 }
 
 /// Generate a call to end an IO statement
-mlir::Value genEndIO(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
-                     mlir::Value cookie) {
+static mlir::Value genEndIO(Fortran::lower::FirOpBuilder &builder,
+                            mlir::Location loc, mlir::Value cookie) {
   // Terminate IO
   auto endIOFunc = getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder);
   llvm::SmallVector<mlir::Value, 1> endArgs{cookie};
@@ -119,8 +120,8 @@ using FormatItems = std::optional<std::pair<mlir::Value, mlir::Value>>;
 
 /// Translate a list of format-items into a set of call-backs that can be
 /// emitted into the MLIR stream before each data item is processed
-FormatItems lowerFormat(AbstractConverter &converter,
-                        const Fortran::parser::Format &format) {
+static FormatItems lowerFormat(Fortran::lower::AbstractConverter &converter,
+                               const Fortran::parser::Format &format) {
   FormatItems formatItems;
   std::visit(Fortran::common::visitors{
                  [](const Fortran::parser::DefaultCharExpr
@@ -132,8 +133,8 @@ FormatItems lowerFormat(AbstractConverter &converter,
   return formatItems;
 }
 
-mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
-                                  mlir::Type type) {
+static mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
+                                         mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
     if (ty.getWidth() == 1)
       return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
@@ -157,7 +158,7 @@ mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
 
 /// The I/O library interface requires that COMPLEX and CHARACTER typed values
 /// be extracted and passed as separate values.
-llvm::SmallVector<mlir::Value, 4>
+static llvm::SmallVector<mlir::Value, 4>
 splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
                mlir::Value arg) {
   mlir::Value zero;
@@ -204,10 +205,10 @@ splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
 
 /// Generate a call to an Output I/O function.
 /// The specific call is determined dynamically by the argument type.
-void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
-                          mlir::Location loc, mlir::Type argType,
-                          mlir::Value cookie,
-                          llvm::SmallVector<mlir::Value, 4> &operands) {
+static void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
+                                 mlir::Location loc, mlir::Type argType,
+                                 mlir::Value cookie,
+                                 llvm::SmallVector<mlir::Value, 4> &operands) {
   int i = 1;
   llvm::SmallVector<mlir::Value, 4> actuals{cookie};
   auto outputFunc = getOutputRuntimeFunc(builder, argType);
@@ -218,25 +219,201 @@ void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
   builder.create<mlir::CallOp>(loc, outputFunc, actuals);
 }
 
-mlir::Value getDefaultFilename(Fortran::lower::FirOpBuilder &builder,
-                               mlir::Location loc, mlir::Type toType) {
+//===----------------------------------------------------------------------===//
+// Default argument generation.
+//===----------------------------------------------------------------------===//
+
+static mlir::Value getDefaultFilename(Fortran::lower::FirOpBuilder &builder,
+                                      mlir::Location loc, mlir::Type toType) {
   mlir::Value null =
       builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
   return builder.create<fir::ConvertOp>(loc, toType, null);
 }
 
-mlir::Value getDefaultLineNo(Fortran::lower::FirOpBuilder &builder,
-                             mlir::Location loc, mlir::Type toType) {
+static mlir::Value getDefaultLineNo(Fortran::lower::FirOpBuilder &builder,
+                                    mlir::Location loc, mlir::Type toType) {
   return builder.create<mlir::ConstantOp>(loc,
                                           builder.getIntegerAttr(toType, 0));
 }
 
+//===----------------------------------------------------------------------===//
+// Handle I/O statement specifiers.
+// These are threaded together for a single statement via the passed cookie.
+//===----------------------------------------------------------------------===//
+
+template <typename A>
+mlir::Value genIOOption(Fortran::lower::AbstractConverter &converter,
+                        mlir::Location loc, mlir::Value cookie, const A &spec);
+template <>
+mlir::Value genIOOption<Fortran::parser::FileNameExpr>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::FileNameExpr &spec) {
+  auto &builder = converter.getFirOpBuilder();
+  auto *expr = Fortran::semantics::GetExpr(spec);
+  auto filename = converter.genExprValue(expr, loc);
+  auto ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(builder);
+  mlir::FunctionType ioFuncTy = ioFunc.getType();
+  // FIXME: next two line are INCORRECT!
+  auto buffer = getDefaultFilename(builder, loc, ioFuncTy.getInput(1));
+  auto len = getDefaultLineNo(builder, loc, ioFuncTy.getInput(2));
+  // FIXME: assuming KIND=1 for now
+  auto kind = builder.create<mlir::ConstantOp>(
+      loc, builder.getIntegerAttr(ioFuncTy.getInput(3), 1));
+  llvm::SmallVector<mlir::Value, 4> ioArgs{cookie, buffer, len, kind};
+  return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+}
+
+template <>
+mlir::Value genIOOption<Fortran::parser::ConnectSpec::CharExpr>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::ConnectSpec::CharExpr &spec) {
+  auto &builder = converter.getFirOpBuilder();
+  mlir::FuncOp ioFunc;
+  switch (std::get<Fortran::parser::ConnectSpec::CharExpr::Kind>(spec.t)) {
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Access:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetAccess)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Action:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetAction)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Asynchronous:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetAsynchronous)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Blank:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetBlank)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Decimal:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetDecimal)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Delim:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetDelim)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Encoding:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetEncoding)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Form:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetForm)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Pad:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetPad)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Position:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetPosition)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Round:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetRound)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Sign:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetSign)>(builder);
+    break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Convert:
+    llvm_unreachable("CONVERT not part of the runtime::io interface");
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Dispose:
+    llvm_unreachable("DISPOSE not part of the runtime::io interface");
+  }
+  auto *charArg = Fortran::semantics::GetExpr(
+      std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t));
+  auto charLit = converter.genExprValue(charArg, loc);
+  charLit.dump();
+  mlir::Value buff{};
+  mlir::Value len{};
+  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, buff, len};
+  return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+}
+
+template <>
+mlir::Value genIOOption<Fortran::parser::MsgVariable>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::MsgVariable &spec) {
+  TODO();
+}
+template <>
+mlir::Value genIOOption<Fortran::parser::StatVariable>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::StatVariable &spec) {
+  TODO();
+}
+template <>
+mlir::Value genIOOption<Fortran::parser::ConnectSpec::Recl>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::ConnectSpec::Recl &spec) {
+  TODO();
+}
+template <>
+mlir::Value genIOOption<Fortran::parser::StatusExpr>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::StatusExpr &spec) {
+  TODO();
+}
+
+template <>
+mlir::Value
+genIOOption<Fortran::parser::ErrLabel>(Fortran::lower::AbstractConverter &,
+                                       mlir::Location loc, mlir::Value cookie,
+                                       const Fortran::parser::ErrLabel &) {
+  // see error handling
+  return cookie;
+}
+
+static bool hasFileUnit(const Fortran::parser::OpenStmt &stmt) {
+  for (const auto &spec : stmt.v)
+    if (std::holds_alternative<Fortran::parser::FileUnitNumber>(spec.u))
+      return true;
+  return false;
+}
+
+static bool hasNewUnit(const Fortran::parser::OpenStmt &stmt) {
+  for (const auto &spec : stmt.v)
+    if (std::holds_alternative<Fortran::parser::ConnectSpec::Newunit>(spec.u))
+      return true;
+  return false;
+}
+
+/// Get the file unit from the specifier list.
+template <typename A>
+const Fortran::semantics::SomeExpr *getFileUnit(const A &stmt) {
+  for (const auto &spec : stmt.v)
+    if (auto *f = std::get_if<Fortran::parser::FileUnitNumber>(&spec.u))
+      return Fortran::semantics::GetExpr(f->v);
+  llvm_unreachable("must have a file unit");
+}
+
+/// For each specifier, build the appropriate call, threading the cookie, and
+/// return the final ssa-value of the cookie.
+template <typename A>
+mlir::Value threadSpecs(Fortran::lower::AbstractConverter &converter,
+                        mlir::Location loc, mlir::Value cookie, const A &stmt) {
+  for (const auto &spec : stmt.v) {
+    cookie = std::visit(
+        Fortran::common::visitors{
+            [&](const Fortran::parser::FileUnitNumber &) { return cookie; },
+            [&](const Fortran::parser::ConnectSpec::Newunit &) {
+              return cookie;
+            },
+            [&](const auto &x) {
+              return genIOOption(converter, loc, cookie, x);
+            }},
+        spec.u);
+  }
+  return cookie;
+}
+
+template <typename A>
+mlir::Value threadErrors(Fortran::lower::AbstractConverter &converter,
+                         mlir::Location loc, mlir::Value cookie,
+                         const A &stmt) {
+  // FIXME -- implement!
+  return cookie;
+}
+
+//===----------------------------------------------------------------------===//
+
 /// Lower print statement assuming a dummy runtime interface for now.
-void lowerPrintStatement(AbstractConverter &converter, mlir::Location loc,
-                         mlir::ValueRange args,
-                         const Fortran::parser::Format &format) {
+static void lowerPrintStatement(Fortran::lower::AbstractConverter &converter,
+                                mlir::Location loc, mlir::ValueRange args,
+                                const Fortran::parser::Format &format) {
   mlir::FuncOp beginFunc;
-  Fortran::lower::FirOpBuilder &builder = converter.getFirOpBuilder();
+  auto &builder = converter.getFirOpBuilder();
   auto formatItems = lowerFormat(converter, format);
   if (formatItems.has_value()) {
     // has a format
@@ -252,41 +429,26 @@ void lowerPrintStatement(AbstractConverter &converter, mlir::Location loc,
                                   Fortran::runtime::io::DefaultUnit));
   auto srcFileName = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
   auto lineNo = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
-  llvm::SmallVector<mlir::Value, 3> beginArgs{defaultUnit, srcFileName, lineNo};
+  llvm::SmallVector<mlir::Value, 4> beginArgs{defaultUnit, srcFileName, lineNo};
   mlir::Value cookie =
       builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
 
   // Call data transfer runtime function
   for (mlir::Value arg : args) {
+    // need some special handling for COMPLEX and CHARACTER
     auto operands = splitArguments(builder, loc, arg);
     genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
   }
   genEndIO(builder, loc, cookie);
 }
 
-llvm::SmallVector<mlir::Value, 4> lowerBeginArgsPositionOrFlush(
-    AbstractConverter &converter, mlir::Location loc,
-    const std::list<Fortran::parser::PositionOrFlushSpec> &specs) {
-  llvm::SmallVector<mlir::Value, 4> args;
-  // 1. find the unit number expression and append it
-  for (auto &sp : specs)
-    if (auto *un = std::get_if<Fortran::parser::FileUnitNumber>(&sp.u)) {
-      auto *expr = Fortran::semantics::GetExpr(un->v);
-      args.push_back(converter.genExprValue(expr, loc));
-      break;
-    }
-  // 2 & 3. add the filename and line as extracted from `loc`
-  // FIXME
-  return args;
-}
-
 /// 3 of the 4 cases in a position (or flush) spec concern the error handling of
 /// the statement. We handle those 3 cases here.
-mlir::Value lowerErrorHandlingPositionOrFlush(
-    AbstractConverter &converter, mlir::Value endRes,
+static mlir::Value lowerErrorHandlingPositionOrFlush(
+    Fortran::lower::AbstractConverter &converter, mlir::Value endRes,
     const std::list<Fortran::parser::PositionOrFlushSpec> &specs) {
   mlir::Value result;
-  auto builder = converter.getFirOpBuilder();
+  auto &builder = converter.getFirOpBuilder();
   auto loc = converter.getCurrentLocation();
   for (auto &sp : specs) {
     std::visit(
@@ -325,82 +487,65 @@ mlir::Value lowerErrorHandlingPositionOrFlush(
   return result;
 }
 
-/// Generate IO calls for any of the "position or flush" like IO statements.
-/// This is templatized with a statement type `S` and a key `K` for genericity.
+//===----------------------------------------------------------------------===//
+// Generators for each I/O statement type.
+//===----------------------------------------------------------------------===//
+
 template <typename K, typename S>
-mlir::Value genPosOrFlushLikeStmt(AbstractConverter &converter, const S &stmt) {
-  auto builder = converter.getFirOpBuilder();
+static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
+                                  const S &stmt) {
+  auto &builder = converter.getFirOpBuilder();
   auto loc = converter.getCurrentLocation();
   auto beginFunc = getIORuntimeFunc<K>(builder);
-  auto args = lowerBeginArgsPositionOrFlush(converter, loc, stmt.v);
-  auto call = builder.create<mlir::CallOp>(loc, beginFunc, args);
-  // FIXME: add call to EnableHandlers as apropos
-  auto cookie = call.getResult(0);
+  mlir::FunctionType beginFuncTy = beginFunc.getType();
+  auto unit = converter.genExprValue(getFileUnit(stmt), loc);
+  auto un = builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit);
+  auto file = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
+  auto line = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
+  llvm::SmallVector<mlir::Value, 4> args{un, file, line};
+  auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
+  cookie = threadSpecs(converter, loc, cookie, stmt);
   auto endVal = genEndIO(builder, converter.getCurrentLocation(), cookie);
-  return lowerErrorHandlingPositionOrFlush(converter, endVal, stmt.v);
+  return threadErrors(converter, loc, endVal, stmt);
 }
-} // namespace
 
-mlir::Value genBackspaceStatement(AbstractConverter &converter,
-                                  const Fortran::parser::BackspaceStmt &stmt) {
-  return genPosOrFlushLikeStmt<mkIOKey(BeginBackspace)>(converter, stmt);
+mlir::Value Fortran::lower::genBackspaceStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::BackspaceStmt &stmt) {
+  return genBasicIOStmt<mkIOKey(BeginBackspace)>(converter, stmt);
 }
 
-mlir::Value genEndfileStatement(AbstractConverter &converter,
-                                const Fortran::parser::EndfileStmt &stmt) {
-  return genPosOrFlushLikeStmt<mkIOKey(BeginEndfile)>(converter, stmt);
+mlir::Value Fortran::lower::genEndfileStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::EndfileStmt &stmt) {
+  return genBasicIOStmt<mkIOKey(BeginEndfile)>(converter, stmt);
 }
 
-mlir::Value genFlushStatement(AbstractConverter &converter,
-                              const Fortran::parser::FlushStmt &stmt) {
-  return genPosOrFlushLikeStmt<mkIOKey(BeginFlush)>(converter, stmt);
+mlir::Value
+Fortran::lower::genFlushStatement(Fortran::lower::AbstractConverter &converter,
+                                  const Fortran::parser::FlushStmt &stmt) {
+  return genBasicIOStmt<mkIOKey(BeginFlush)>(converter, stmt);
 }
 
-mlir::Value genRewindStatement(AbstractConverter &converter,
-                               const Fortran::parser::RewindStmt &stmt) {
-  return genPosOrFlushLikeStmt<mkIOKey(BeginRewind)>(converter, stmt);
+mlir::Value
+Fortran::lower::genRewindStatement(Fortran::lower::AbstractConverter &converter,
+                                   const Fortran::parser::RewindStmt &stmt) {
+  return genBasicIOStmt<mkIOKey(BeginRewind)>(converter, stmt);
 }
 
-static bool hasFileUnit(const Fortran::parser::OpenStmt &stmt) {
-  for (const auto &spec : stmt.v)
-    if (std::holds_alternative<Fortran::parser::FileUnitNumber>(spec.u))
-      return true;
-  return false;
-}
-
-static bool hasNewUnit(const Fortran::parser::OpenStmt &stmt) {
-  for (const auto &spec : stmt.v)
-    if (std::holds_alternative<Fortran::parser::ConnectSpec::Newunit>(spec.u))
-      return true;
-  return false;
-}
-
-static Fortran::runtime::io::ExternalUnit
-getFileUnit(const Fortran::parser::OpenStmt &stmt) {
-  for (const auto &spec : stmt.v)
-    if (auto *f = std::get_if<Fortran::parser::FileUnitNumber>(&spec.u))
-      return *Fortran::evaluate::ToInt64(*Fortran::semantics::GetExpr(f->v));
-  llvm_unreachable("must have a file unit");
-}
-
-static mlir::Value lowerErrorHandling(AbstractConverter &converter,
-                                      mlir::Value result) {
-  // FIXME - implement
-  return result;
-}
-
-mlir::Value genOpenStatement(AbstractConverter &converter,
-                             const Fortran::parser::OpenStmt &stmt) {
-  auto builder = converter.getFirOpBuilder();
+mlir::Value
+Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
+                                 const Fortran::parser::OpenStmt &stmt) {
+  auto &builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   llvm::SmallVector<mlir::Value, 4> beginArgs;
   auto loc = converter.getCurrentLocation();
   if (hasFileUnit(stmt)) {
-    auto unit = getFileUnit(stmt);
     beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
     mlir::FunctionType beginFuncTy = beginFunc.getType();
-    beginArgs.push_back(builder.create<mlir::ConstantOp>(
-        loc, builder.getIntegerAttr(beginFuncTy.getInput(0), unit)));
+    auto unit = converter.genExprValue(getFileUnit(stmt), loc);
+    beginArgs.push_back(
+        builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit));
     beginArgs.push_back(
         getDefaultFilename(builder, loc, beginFuncTy.getInput(1)));
     beginArgs.push_back(
@@ -416,22 +561,20 @@ mlir::Value genOpenStatement(AbstractConverter &converter,
   }
   auto cookie =
       builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
-  // TODO: handle the other specifiers in the list
+  cookie = threadSpecs(converter, loc, cookie, stmt);
   auto endVal = genEndIO(builder, loc, cookie);
-  return lowerErrorHandling(converter, endVal);
+  return threadErrors(converter, loc, endVal, stmt);
 }
 
-mlir::Value genCloseStatement(AbstractConverter &converter,
-                              const Fortran::parser::CloseStmt &) {
-  auto builder = converter.getFirOpBuilder();
-  mlir::FuncOp beginFunc = getIORuntimeFunc<mkIOKey(BeginClose)>(builder);
-  (void)beginFunc;
-  TODO();
-  return {};
+mlir::Value
+Fortran::lower::genCloseStatement(Fortran::lower::AbstractConverter &converter,
+                                  const Fortran::parser::CloseStmt &stmt) {
+  return genBasicIOStmt<mkIOKey(BeginClose)>(converter, stmt);
 }
 
-void genPrintStatement(AbstractConverter &converter,
-                       const Fortran::parser::PrintStmt &stmt) {
+void Fortran::lower::genPrintStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::PrintStmt &stmt) {
   llvm::SmallVector<mlir::Value, 4> args;
   for (auto &item : std::get<std::list<Fortran::parser::OutputItem>>(stmt.t)) {
     if (auto *pe = std::get_if<Fortran::parser::Expr>(&item.u)) {
@@ -446,9 +589,10 @@ void genPrintStatement(AbstractConverter &converter,
                       std::get<Fortran::parser::Format>(stmt.t));
 }
 
-mlir::Value genReadStatement(AbstractConverter &converter,
-                             const Fortran::parser::ReadStmt &) {
-  auto builder = converter.getFirOpBuilder();
+mlir::Value
+Fortran::lower::genReadStatement(Fortran::lower::AbstractConverter &converter,
+                                 const Fortran::parser::ReadStmt &) {
+  auto &builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
@@ -457,9 +601,10 @@ mlir::Value genReadStatement(AbstractConverter &converter,
   return {};
 }
 
-mlir::Value genWriteStatement(AbstractConverter &converter,
-                              const Fortran::parser::WriteStmt &) {
-  auto builder = converter.getFirOpBuilder();
+mlir::Value
+Fortran::lower::genWriteStatement(Fortran::lower::AbstractConverter &converter,
+                                  const Fortran::parser::WriteStmt &) {
+  auto &builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
@@ -468,9 +613,10 @@ mlir::Value genWriteStatement(AbstractConverter &converter,
   return {};
 }
 
-mlir::Value genInquireStatement(AbstractConverter &converter,
-                                const Fortran::parser::InquireStmt &) {
-  auto builder = converter.getFirOpBuilder();
+mlir::Value Fortran::lower::genInquireStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::InquireStmt &) {
+  auto &builder = converter.getFirOpBuilder();
   mlir::FuncOp beginFunc;
   // if (...
   beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(builder);
@@ -481,5 +627,3 @@ mlir::Value genInquireStatement(AbstractConverter &converter,
   TODO();
   return {};
 }
-
-} // namespace Fortran::lower

From 6be8b0d36b9d2a3eda8f416f87ac3fbfe17fdd7c Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Sun, 29 Mar 2020 12:18:15 -0700
Subject: [PATCH 287/345] convert some assert(false) to llvm_unreachable

---
 lib/Lower/ConvertExpr.cpp | 41 ++++++++++++++-------------------------
 1 file changed, 15 insertions(+), 26 deletions(-)

diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 60062b4abd00..daa7515063f4 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -71,8 +71,7 @@ class ExprLowering {
     case Fortran::common::RelationalOperator::GE:
       return mlir::CmpIPredicate::sge;
     }
-    assert(false && "unhandled INTEGER relational operator");
-    return {};
+    llvm_unreachable("unhandled INTEGER relational operator");
   }
 
   /// Convert parser's REAL relational operators to MLIR.
@@ -100,7 +99,6 @@ class ExprLowering {
       return mlir::CmpFPredicate::OGE;
     }
     llvm_unreachable("unhandled REAL relational operator");
-    return {};
   }
 
   /// Generate an integral constant of `value`
@@ -173,8 +171,7 @@ class ExprLowering {
       inputs.push_back(output);
       return mlir::FunctionType::get(inputs, output, builder.getContext());
     } else {
-      assert(false);
-      return {};
+      llvm_unreachable("this category is not implemented");
     }
   }
 
@@ -257,7 +254,7 @@ class ExprLowering {
       } else if (descType.isa<fir::BoxType>()) {
         TODO();
       } else {
-        assert(false && "not a descriptor");
+        llvm_unreachable("not a descriptor");
       }
       break;
     default:
@@ -476,12 +473,11 @@ class ExprLowering {
       break;
     case Fortran::evaluate::LogicalOperator::Not:
       // lib/evaluate expression for .NOT. is Fortran::evaluate::Not<KIND>.
-      assert(false && ".NOT. is not a binary operator");
+      llvm_unreachable(".NOT. is not a binary operator");
       break;
     }
-    if (!result) {
-      assert(false && "unhandled logical operation");
-    }
+    if (!result)
+      llvm_unreachable("unhandled logical operation");
     return result;
   }
 
@@ -515,14 +511,12 @@ class ExprLowering {
       auto opt = con.GetScalarValue();
       if (opt.has_value())
         return genIntegerConstant<KIND>(builder.getContext(), opt->ToInt64());
-      assert(false && "integer constant has no value");
-      return {};
+      llvm_unreachable("integer constant has no value");
     } else if constexpr (TC == Fortran::lower::LogicalCat) {
       auto opt = con.GetScalarValue();
       if (opt.has_value())
         return genLogicalConstantAsI1(builder.getContext(), opt->IsTrue());
-      assert(false && "logical constant has no value");
-      return {};
+      llvm_unreachable("logical constant has no value");
     } else if constexpr (TC == Fortran::lower::RealCat) {
       auto opt = con.GetScalarValue();
       if (opt.has_value()) {
@@ -545,8 +539,7 @@ class ExprLowering {
           return genRealConstant<KIND>(builder.getContext(), floatVal);
         }
       }
-      assert(false && "real constant has no value");
-      return {};
+      llvm_unreachable("real constant has no value");
     } else if constexpr (TC == Fortran::lower::ComplexCat) {
       auto opt = con.GetScalarValue();
       if (opt.has_value()) {
@@ -557,13 +550,11 @@ class ExprLowering {
             Fortran::evaluate::Expr<TR>{
                 Fortran::evaluate::Constant<TR>{opt->AIMAG()}}});
       }
-      assert(false && "array of complex unhandled");
-      return {};
+      llvm_unreachable("array of complex unhandled");
     } else if constexpr (TC == Fortran::lower::CharacterCat) {
       return genCharLit<KIND>(con.GetScalarValue().value(), con.LEN());
     } else {
-      assert(false && "unhandled constant");
-      return {};
+      llvm_unreachable("unhandled constant");
     }
   }
 
@@ -577,8 +568,7 @@ class ExprLowering {
       auto res = builder.create<mlir::ConstantOp>(getLoc(), type, attr);
       return res.getResult();
     } else {
-      assert(false && "unhandled constant of unknown kind");
-      return {};
+      llvm_unreachable("unhandled constant of unknown kind");
     }
   }
 
@@ -918,9 +908,9 @@ class ExprLowering {
       } else if (auto seqType{type.dyn_cast_or_null<fir::SequenceType>()}) {
         // TODO: Conversions at array level should probably be avoided.
         // This depends on how array expressions will be lowered.
-        assert(false && "logical array loads not yet implemented");
+        llvm_unreachable("logical array loads not yet implemented");
       } else {
-        assert(false && "unexpected logical type in expression");
+        llvm_unreachable("unexpected logical type in expression");
       }
     }
     return result;
@@ -928,8 +918,7 @@ class ExprLowering {
 
   template <typename A>
   mlir::Value gendef(const A &) {
-    assert(false && "expression error");
-    return {};
+    llvm_unreachable("expression error");
   }
 
   std::string

From dff7980683c89861bb336bc258cdcd6f25975fd6 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Sun, 29 Mar 2020 12:41:47 -0700
Subject: [PATCH 288/345] add global builders error handling

---
 include/flang/Lower/Bridge.h     |   2 +
 include/flang/Lower/FIRBuilder.h |  24 ++-
 include/flang/Lower/IO.h         |   4 +
 lib/Lower/Bridge.cpp             |   7 +-
 lib/Lower/ConvertExpr.cpp        |   2 -
 lib/Lower/FIRBuilder.cpp         |   5 -
 lib/Lower/IO.cpp                 | 266 +++++++++++++++++++------------
 lib/Lower/Intrinsics.cpp         |   8 +-
 lib/Lower/Runtime.cpp            |   2 -
 9 files changed, 191 insertions(+), 129 deletions(-)

diff --git a/include/flang/Lower/Bridge.h b/include/flang/Lower/Bridge.h
index 213021622501..48a004292ec5 100644
--- a/include/flang/Lower/Bridge.h
+++ b/include/flang/Lower/Bridge.h
@@ -120,6 +120,8 @@ class AbstractConverter {
   virtual ~AbstractConverter() = default;
 };
 
+/// The lowering bridge converts the front-end parse trees and semantics
+/// checking residual to MLIR (FIR dialect) code.
 class LoweringBridge {
 public:
   static LoweringBridge
diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index 4924212e1b2b..737fa5c3e60d 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -17,6 +17,7 @@
 #define FORTRAN_LOWER_FIRBUILDER_H
 
 #include "flang/Common/reference.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
@@ -24,11 +25,6 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 
-namespace fir {
-class ExtractValueOp;
-class InsertValueOp;
-} // namespace fir
-
 namespace Fortran {
 namespace semantics {
 class Symbol;
@@ -62,6 +58,10 @@ struct CharValue {
   mlir::Value len;
 };
 
+//===----------------------------------------------------------------------===//
+// FirOpBuilder interface extensions
+//===----------------------------------------------------------------------===//
+
 // TODO: Used CRTP to extend the FirOpBuilder interface, but this leads to some
 // complex and downright ugly template code.
 
@@ -209,6 +209,20 @@ class FirOpBuilder : public mlir::OpBuilder,
     return createTemporary(getLoc(), fakeMap, type, shape);
   }
 
+  /// Create a global value.
+  fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
+                             llvm::StringRef name, mlir::Attribute value = {},
+                             mlir::StringAttr linkage = {},
+                             bool isConst = false);
+
+  /// Create a global constant (read-only) value.
+  fir::GlobalOp createGlobalConstant(mlir::Location loc, mlir::Type type,
+                                     llvm::StringRef name,
+                                     mlir::Attribute value = {},
+                                     mlir::StringAttr linkage = {}) {
+    return createGlobal(loc, type, name, value, linkage, /*isConst=*/true);
+  }
+
   mlir::Block *createBlock() {
     return OpBuilder::createBlock(getBlock()->getParent());
   }
diff --git a/include/flang/Lower/IO.h b/include/flang/Lower/IO.h
index d782e6a6f454..a366bef9acb7 100644
--- a/include/flang/Lower/IO.h
+++ b/include/flang/Lower/IO.h
@@ -34,6 +34,7 @@ struct OpenStmt;
 struct PrintStmt;
 struct ReadStmt;
 struct RewindStmt;
+struct WaitStmt;
 struct WriteStmt;
 } // namespace parser
 
@@ -72,6 +73,9 @@ mlir::Value genReadStatement(AbstractConverter &, const parser::ReadStmt &);
 /// Generate IO call(s) for REWIND; return the IOSTAT code
 mlir::Value genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
 
+/// Generate IO call(s) for WAIT; return the IOSTAT code
+mlir::Value genWaitStatement(AbstractConverter &, const parser::WaitStmt &);
+
 /// Generate IO call(s) for WRITE; return the IOSTAT code
 mlir::Value genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
 
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index d9177264d700..b5f0dd4a9461 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -16,14 +16,11 @@
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
-#include "mlir/IR/Builders.h"
 #include "mlir/Parser.h"
 #include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/CommandLine.h"
@@ -365,8 +362,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
-              const Fortran::parser::WaitStmt &) {
-    TODO();
+              const Fortran::parser::WaitStmt &stmt) {
+    genWaitStatement(*this, stmt);
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::WhereStmt &) {
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index daa7515063f4..385ce5ac1cb0 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -16,8 +16,6 @@
 #include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/type.h"
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index 3ac137291964..b42f08b8bce5 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -9,13 +9,8 @@
 #include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/ConvertType.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Semantics/symbol.h"
-#include "mlir/IR/Module.h"
-#include "mlir/IR/Value.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 
 void Fortran::lower::SymMap::addSymbol(Fortran::semantics::SymbolRef symbol,
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 1f6fdc274e76..8549e23b8fcd 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -12,11 +12,9 @@
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Runtime.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
-#include "mlir/IR/Builders.h"
 
 #define TODO() llvm_unreachable("not yet implemented")
 
@@ -236,6 +234,29 @@ static mlir::Value getDefaultLineNo(Fortran::lower::FirOpBuilder &builder,
                                           builder.getIntegerAttr(toType, 0));
 }
 
+template <typename A>
+static std::tuple<mlir::Value, mlir::Value, mlir::Value>
+lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+               const A &syntax, mlir::Type ty0, mlir::Type ty1,
+               mlir::Type ty2 = {}) {
+  auto &builder = converter.getFirOpBuilder();
+  auto *expr = Fortran::semantics::GetExpr(syntax);
+  auto buffer = converter.genExprValue(expr, loc);
+  auto buff = builder.create<fir::ConvertOp>(loc, ty0, buffer);
+  mlir::Type ty = buffer.getType();
+  auto lenVal = ty.cast<fir::SequenceType>().getShape()[0];
+  auto len = builder.create<mlir::ConstantOp>(
+      loc, builder.getIntegerAttr(ty1, lenVal));
+  if (ty2) {
+    mlir::Type eleTy = ty.cast<fir::SequenceType>().getEleTy();
+    auto kindVal = eleTy.cast<fir::CharacterType>().getFKind();
+    auto kind = builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(ty2, kindVal));
+    return {buff, len, kind};
+  }
+  return {buff, len, mlir::Value{}};
+}
+
 //===----------------------------------------------------------------------===//
 // Handle I/O statement specifiers.
 // These are threaded together for a single statement via the passed cookie.
@@ -249,17 +270,12 @@ mlir::Value genIOOption<Fortran::parser::FileNameExpr>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     mlir::Value cookie, const Fortran::parser::FileNameExpr &spec) {
   auto &builder = converter.getFirOpBuilder();
-  auto *expr = Fortran::semantics::GetExpr(spec);
-  auto filename = converter.genExprValue(expr, loc);
   auto ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(builder);
   mlir::FunctionType ioFuncTy = ioFunc.getType();
-  // FIXME: next two line are INCORRECT!
-  auto buffer = getDefaultFilename(builder, loc, ioFuncTy.getInput(1));
-  auto len = getDefaultLineNo(builder, loc, ioFuncTy.getInput(2));
-  // FIXME: assuming KIND=1 for now
-  auto kind = builder.create<mlir::ConstantOp>(
-      loc, builder.getIntegerAttr(ioFuncTy.getInput(3), 1));
-  llvm::SmallVector<mlir::Value, 4> ioArgs{cookie, buffer, len, kind};
+  auto tup = lowerStringLit(converter, loc, spec, ioFuncTy.getInput(1),
+                            ioFuncTy.getInput(2), ioFuncTy.getInput(3));
+  llvm::SmallVector<mlir::Value, 4> ioArgs{cookie, std::get<0>(tup),
+                                           std::get<1>(tup), std::get<2>(tup)};
   return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 
@@ -311,69 +327,107 @@ mlir::Value genIOOption<Fortran::parser::ConnectSpec::CharExpr>(
   case Fortran::parser::ConnectSpec::CharExpr::Kind::Dispose:
     llvm_unreachable("DISPOSE not part of the runtime::io interface");
   }
-  auto *charArg = Fortran::semantics::GetExpr(
-      std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t));
-  auto charLit = converter.genExprValue(charArg, loc);
-  charLit.dump();
-  mlir::Value buff{};
-  mlir::Value len{};
-  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, buff, len};
+  mlir::FunctionType ioFuncTy = ioFunc.getType();
+  auto tup = lowerStringLit(
+      converter, loc, std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t),
+      ioFuncTy.getInput(1), ioFuncTy.getInput(2));
+  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, std::get<0>(tup),
+                                              std::get<1>(tup)};
   return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 
-template <>
-mlir::Value genIOOption<Fortran::parser::MsgVariable>(
-    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
-    mlir::Value cookie, const Fortran::parser::MsgVariable &spec) {
-  TODO();
-}
-template <>
-mlir::Value genIOOption<Fortran::parser::StatVariable>(
-    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
-    mlir::Value cookie, const Fortran::parser::StatVariable &spec) {
-  TODO();
-}
 template <>
 mlir::Value genIOOption<Fortran::parser::ConnectSpec::Recl>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     mlir::Value cookie, const Fortran::parser::ConnectSpec::Recl &spec) {
-  TODO();
+  auto &builder = converter.getFirOpBuilder();
+  mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetRecl)>(builder);
+  mlir::FunctionType ioFuncTy = ioFunc.getType();
+  auto expr = converter.genExprValue(Fortran::semantics::GetExpr(spec.v), loc);
+  auto reclVal =
+      builder.create<fir::ConvertOp>(loc, ioFuncTy.getInput(1), expr);
+  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, reclVal};
+  return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 template <>
 mlir::Value genIOOption<Fortran::parser::StatusExpr>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     mlir::Value cookie, const Fortran::parser::StatusExpr &spec) {
-  TODO();
+  auto &builder = converter.getFirOpBuilder();
+  mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetStatus)>(builder);
+  mlir::FunctionType ioFuncTy = ioFunc.getType();
+  auto tup = lowerStringLit(converter, loc, spec.v, ioFuncTy.getInput(1),
+                            ioFuncTy.getInput(2));
+  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, std::get<0>(tup),
+                                              std::get<1>(tup)};
+  return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 
+template <>
+mlir::Value genIOOption<Fortran::parser::MsgVariable>(
+    Fortran::lower::AbstractConverter &, mlir::Location, mlir::Value cookie,
+    const Fortran::parser::MsgVariable &) {
+  // see error handling
+  return cookie;
+}
+template <>
+mlir::Value genIOOption<Fortran::parser::StatVariable>(
+    Fortran::lower::AbstractConverter &, mlir::Location, mlir::Value cookie,
+    const Fortran::parser::StatVariable &) {
+  // see error handling
+  return cookie;
+}
 template <>
 mlir::Value
 genIOOption<Fortran::parser::ErrLabel>(Fortran::lower::AbstractConverter &,
-                                       mlir::Location loc, mlir::Value cookie,
+                                       mlir::Location, mlir::Value cookie,
                                        const Fortran::parser::ErrLabel &) {
   // see error handling
   return cookie;
 }
 
-static bool hasFileUnit(const Fortran::parser::OpenStmt &stmt) {
-  for (const auto &spec : stmt.v)
-    if (std::holds_alternative<Fortran::parser::FileUnitNumber>(spec.u))
-      return true;
-  return false;
+namespace {
+struct ErrorHandling {
+  bool hasErrorHandlers() { return ioStat || err || end || eor || ioMsg; }
+  bool ioStat{};
+  bool err{};
+  bool end{};
+  bool eor{};
+  bool ioMsg{};
+};
+} // namespace
+
+template <typename A>
+void genErrorOption(ErrorHandling &handle, const A &) {}
+template <>
+void genErrorOption<Fortran::parser::MsgVariable>(
+    ErrorHandling &eh, const Fortran::parser::MsgVariable &) {
+  eh.ioMsg = true;
+}
+template <>
+void genErrorOption<Fortran::parser::StatVariable>(
+    ErrorHandling &eh, const Fortran::parser::StatVariable &) {
+  eh.ioStat = true;
+}
+template <>
+void genErrorOption<Fortran::parser::ErrLabel>(
+    ErrorHandling &eh, const Fortran::parser::ErrLabel &) {
+  eh.err = true;
 }
 
-static bool hasNewUnit(const Fortran::parser::OpenStmt &stmt) {
+template <typename SEEK, typename A>
+static bool hasMem(const A &stmt) {
   for (const auto &spec : stmt.v)
-    if (std::holds_alternative<Fortran::parser::ConnectSpec::Newunit>(spec.u))
+    if (std::holds_alternative<SEEK>(spec.u))
       return true;
   return false;
 }
 
-/// Get the file unit from the specifier list.
-template <typename A>
-const Fortran::semantics::SomeExpr *getFileUnit(const A &stmt) {
+/// Get the sought expression from the specifier list.
+template <typename SEEK, typename A>
+static const Fortran::semantics::SomeExpr *getMem(const A &stmt) {
   for (const auto &spec : stmt.v)
-    if (auto *f = std::get_if<Fortran::parser::FileUnitNumber>(&spec.u))
+    if (auto *f = std::get_if<SEEK>(&spec.u))
       return Fortran::semantics::GetExpr(f->v);
   llvm_unreachable("must have a file unit");
 }
@@ -381,8 +435,9 @@ const Fortran::semantics::SomeExpr *getFileUnit(const A &stmt) {
 /// For each specifier, build the appropriate call, threading the cookie, and
 /// return the final ssa-value of the cookie.
 template <typename A>
-mlir::Value threadSpecs(Fortran::lower::AbstractConverter &converter,
-                        mlir::Location loc, mlir::Value cookie, const A &stmt) {
+static mlir::Value threadSpecs(Fortran::lower::AbstractConverter &converter,
+                               mlir::Location loc, mlir::Value cookie,
+                               const A &stmt) {
   for (const auto &spec : stmt.v) {
     cookie = std::visit(
         Fortran::common::visitors{
@@ -399,10 +454,33 @@ mlir::Value threadSpecs(Fortran::lower::AbstractConverter &converter,
 }
 
 template <typename A>
-mlir::Value threadErrors(Fortran::lower::AbstractConverter &converter,
-                         mlir::Location loc, mlir::Value cookie,
-                         const A &stmt) {
-  // FIXME -- implement!
+static mlir::Value threadErrors(Fortran::lower::AbstractConverter &converter,
+                                mlir::Location loc, mlir::Value cookie,
+                                const A &stmt) {
+  ErrorHandling eh{};
+  for (const auto &spec : stmt.v)
+    std::visit(Fortran::common::visitors{[&](const auto &x) {
+                 genErrorOption(eh, x);
+               }},
+               spec.u);
+  if (eh.hasErrorHandlers()) {
+    auto &builder = converter.getFirOpBuilder();
+    mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(EnableHandlers)>(builder);
+    mlir::FunctionType ioFuncTy = ioFunc.getType();
+    auto hasIoStat = builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(ioFuncTy.getInput(1), eh.ioStat));
+    auto hasErr = builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(ioFuncTy.getInput(2), eh.err));
+    auto hasEnd = builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(ioFuncTy.getInput(3), eh.end));
+    auto hasEor = builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(ioFuncTy.getInput(4), eh.eor));
+    auto hasIoMsg = builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(ioFuncTy.getInput(5), eh.ioMsg));
+    llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, hasIoStat, hasErr,
+                                                hasEnd, hasEor,    hasIoMsg};
+    cookie = builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+  }
   return cookie;
 }
 
@@ -442,51 +520,6 @@ static void lowerPrintStatement(Fortran::lower::AbstractConverter &converter,
   genEndIO(builder, loc, cookie);
 }
 
-/// 3 of the 4 cases in a position (or flush) spec concern the error handling of
-/// the statement. We handle those 3 cases here.
-static mlir::Value lowerErrorHandlingPositionOrFlush(
-    Fortran::lower::AbstractConverter &converter, mlir::Value endRes,
-    const std::list<Fortran::parser::PositionOrFlushSpec> &specs) {
-  mlir::Value result;
-  auto &builder = converter.getFirOpBuilder();
-  auto loc = converter.getCurrentLocation();
-  for (auto &sp : specs) {
-    std::visit(
-        Fortran::common::visitors{
-            [](const Fortran::parser::FileUnitNumber &) {
-              // this is passed to the BeginFoo function
-              // do nothing here
-            },
-            [&](const Fortran::parser::MsgVariable &var) {
-              // call GetIoMsg, passing it the address of `var` and a length (in
-              // bytes, or?). Effectively, we have to decompose a boxchar here.
-              // TODO: this has to be a CHARACTER type, no?
-              mlir::Value varAddr =
-                  converter.genExprAddr(Fortran::semantics::GetExpr(var), loc);
-              mlir::FuncOp getIoMsg =
-                  getIORuntimeFunc<mkIOKey(GetIoMsg)>(builder);
-              llvm::SmallVector<mlir::Value, 1> ioMsgArgs{
-                  builder.create<fir::ConvertOp>(
-                      loc, getModel<char *>()(builder.getContext()), varAddr)
-                  /*, FIXME add length here */};
-              builder.create<mlir::CallOp>(loc, getIoMsg, ioMsgArgs);
-            },
-            [&](const Fortran::parser::StatVariable &var) {
-              /* store `endRes` to the variable `var` */
-              mlir::Value varAddr =
-                  converter.genExprAddr(Fortran::semantics::GetExpr(var), loc);
-              builder.create<fir::StoreOp>(loc, endRes, varAddr);
-            },
-            [&](const Fortran::parser::ErrLabel &label) {
-              /* pass the `endRes` value for `fir.switch` op */
-              result = endRes;
-            },
-        },
-        sp.u);
-  }
-  return result;
-}
-
 //===----------------------------------------------------------------------===//
 // Generators for each I/O statement type.
 //===----------------------------------------------------------------------===//
@@ -498,15 +531,16 @@ static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
   auto loc = converter.getCurrentLocation();
   auto beginFunc = getIORuntimeFunc<K>(builder);
   mlir::FunctionType beginFuncTy = beginFunc.getType();
-  auto unit = converter.genExprValue(getFileUnit(stmt), loc);
+  auto unit = converter.genExprValue(
+      getMem<Fortran::parser::FileUnitNumber>(stmt), loc);
   auto un = builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit);
   auto file = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
   auto line = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
   llvm::SmallVector<mlir::Value, 4> args{un, file, line};
   auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
+  cookie = threadErrors(converter, loc, cookie, stmt);
   cookie = threadSpecs(converter, loc, cookie, stmt);
-  auto endVal = genEndIO(builder, converter.getCurrentLocation(), cookie);
-  return threadErrors(converter, loc, endVal, stmt);
+  return genEndIO(builder, converter.getCurrentLocation(), cookie);
 }
 
 mlir::Value Fortran::lower::genBackspaceStatement(
@@ -540,10 +574,11 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
   mlir::FuncOp beginFunc;
   llvm::SmallVector<mlir::Value, 4> beginArgs;
   auto loc = converter.getCurrentLocation();
-  if (hasFileUnit(stmt)) {
+  if (hasMem<Fortran::parser::FileUnitNumber>(stmt)) {
     beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
     mlir::FunctionType beginFuncTy = beginFunc.getType();
-    auto unit = converter.genExprValue(getFileUnit(stmt), loc);
+    auto unit = converter.genExprValue(
+        getMem<Fortran::parser::FileUnitNumber>(stmt), loc);
     beginArgs.push_back(
         builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit));
     beginArgs.push_back(
@@ -551,7 +586,7 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
     beginArgs.push_back(
         getDefaultLineNo(builder, loc, beginFuncTy.getInput(2)));
   } else {
-    assert(hasNewUnit(stmt));
+    assert(hasMem<Fortran::parser::ConnectSpec::Newunit>(stmt));
     beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(builder);
     mlir::FunctionType beginFuncTy = beginFunc.getType();
     beginArgs.push_back(
@@ -561,9 +596,9 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
   }
   auto cookie =
       builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
+  cookie = threadErrors(converter, loc, cookie, stmt);
   cookie = threadSpecs(converter, loc, cookie, stmt);
-  auto endVal = genEndIO(builder, loc, cookie);
-  return threadErrors(converter, loc, endVal, stmt);
+  return genEndIO(builder, loc, cookie);
 }
 
 mlir::Value
@@ -572,6 +607,31 @@ Fortran::lower::genCloseStatement(Fortran::lower::AbstractConverter &converter,
   return genBasicIOStmt<mkIOKey(BeginClose)>(converter, stmt);
 }
 
+mlir::Value
+Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
+                                 const Fortran::parser::WaitStmt &stmt) {
+  auto &builder = converter.getFirOpBuilder();
+  auto loc = converter.getCurrentLocation();
+  bool hasId = hasMem<Fortran::parser::IdExpr>(stmt);
+  mlir::FuncOp beginFunc =
+      hasId ? getIORuntimeFunc<mkIOKey(BeginWait)>(builder)
+            : getIORuntimeFunc<mkIOKey(BeginWaitAll)>(builder);
+  mlir::FunctionType beginFuncTy = beginFunc.getType();
+  auto unit = converter.genExprValue(
+      getMem<Fortran::parser::FileUnitNumber>(stmt), loc);
+  auto un = builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit);
+  llvm::SmallVector<mlir::Value, 4> args{un};
+  if (hasId) {
+    auto id =
+        converter.genExprValue(getMem<Fortran::parser::IdExpr>(stmt), loc);
+    args.push_back(
+        builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(1), id));
+  }
+  auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
+  cookie = threadErrors(converter, loc, cookie, stmt);
+  return genEndIO(builder, converter.getCurrentLocation(), cookie);
+}
+
 void Fortran::lower::genPrintStatement(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::parser::PrintStmt &stmt) {
diff --git a/lib/Lower/Intrinsics.cpp b/lib/Lower/Intrinsics.cpp
index a535ed63dbf1..fa7eed501f30 100644
--- a/lib/Lower/Intrinsics.cpp
+++ b/lib/Lower/Intrinsics.cpp
@@ -17,14 +17,9 @@
 #include "flang/Lower/ConvertType.h"
 #include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/Runtime.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
-#include <string>
-#include <unordered_map> // FIXME: not allowed in LLVM?
+#include <unordered_map> // FIXME: must be removed
 #include <utility>
 
 namespace Fortran::lower {
@@ -540,7 +535,6 @@ static std::string typeToString(mlir::Type t) {
 
 static std::string getIntrinsicWrapperName(const llvm::StringRef &intrinsic,
                                            mlir::FunctionType funTy) {
-  // TODO: use Twine here?
   std::string name{"fir." + intrinsic.str() + "."};
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
   name += typeToString(funTy.getResult(0));
diff --git a/lib/Lower/Runtime.cpp b/lib/Lower/Runtime.cpp
index 9420dfc595e9..c407106ca1cb 100644
--- a/lib/Lower/Runtime.cpp
+++ b/lib/Lower/Runtime.cpp
@@ -8,12 +8,10 @@
 
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/FIRBuilder.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ErrorHandling.h"
-#include <cassert>
 
 namespace Fortran::lower {
 

From 1dbca9c72244fa0cf13fa27b67a460b953a347b8 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 30 Mar 2020 08:54:51 -0700
Subject: [PATCH 289/345] data transfer

---
 lib/Lower/IO.cpp      | 153 +++++++++++++++++++++++++++++++++++++-----
 lib/Lower/RTBuilder.h |   7 ++
 2 files changed, 142 insertions(+), 18 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 8549e23b8fcd..8948bd129b30 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -632,6 +632,134 @@ Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
   return genEndIO(builder, converter.getCurrentLocation(), cookie);
 }
 
+//===----------------------------------------------------------------------===//
+// Data transfer statements.
+//
+// There are several dimensions to the API with regard to data transfer
+// statements that need to be considered.
+//
+//   - input (READ) vs. output (WRITE, PRINT)
+//   - formatted vs. list vs. unformatted
+//   - synchronous vs. asynchronous
+//   - namelist vs. list
+//   - external vs. internal + default KIND vs. internal + other KIND
+//===----------------------------------------------------------------------===//
+
+template <typename A>
+static bool isDataTransferFormatted(const A &stmt) {
+  return true;
+}
+template <typename A>
+static bool isDataTransferList(const A &stmt) {
+  return true;
+}
+template <typename A>
+static bool isDataTransferInternal(const A &stmt) {
+  return false;
+}
+template <typename A>
+static bool isDataTransferInternalNotDefaultKind(const A &stmt) {
+  return false;
+}
+template <typename A>
+static bool isDataTransferAsynchronous(const A &stmt) {
+  return false;
+}
+template <typename A>
+static bool isDataTransferNamelist(const A &stmt) {
+  return false;
+}
+
+template <typename A>
+static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
+                                   const A &stmt, bool isInput,
+                                   bool hasIOCtrl) {
+  auto &builder = converter.getFirOpBuilder();
+  bool isFormatted = isDataTransferFormatted(stmt);
+  bool isList = isFormatted ? isDataTransferList(stmt) : false;
+  bool isIntern = hasIOCtrl ? isDataTransferInternal(stmt) : false;
+  bool isOtherIntern =
+      isIntern ? isDataTransferInternalNotDefaultKind(stmt) : false;
+  bool isAsynch = hasIOCtrl ? isDataTransferAsynchronous(stmt) : false;
+  bool isNml = hasIOCtrl ? isDataTransferNamelist(stmt) : false;
+
+  // Determine the correct IO API call to make.
+  mlir::FuncOp ioFunc;
+  if (isInput) {
+    if (isAsynch) {
+      ioFunc = getIORuntimeFunc<mkIOKey(BeginAsynchronousInput)>(builder);
+      llvm_unreachable("asynchronous not implemented in runtime");
+    } else if (isFormatted) {
+      if (isIntern) {
+        if (isNml) {
+          ioFunc =
+              getIORuntimeFunc<mkIOKey(BeginInternalNamelistInput)>(builder);
+        } else if (isOtherIntern) {
+          if (isList)
+            ioFunc =
+                getIORuntimeFunc<mkIOKey(BeginInternalArrayListInput)>(builder);
+          else
+            ioFunc =
+                getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedInput)>(
+                    builder);
+        } else if (isList) {
+          ioFunc = getIORuntimeFunc<mkIOKey(BeginInternalListInput)>(builder);
+        } else {
+          ioFunc =
+              getIORuntimeFunc<mkIOKey(BeginInternalFormattedInput)>(builder);
+        }
+      } else if (isNml) {
+        ioFunc = getIORuntimeFunc<mkIOKey(BeginExternalNamelistInput)>(builder);
+      } else if (isList) {
+        ioFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
+      } else {
+        ioFunc =
+            getIORuntimeFunc<mkIOKey(BeginExternalFormattedInput)>(builder);
+      }
+    } else {
+      ioFunc = getIORuntimeFunc<mkIOKey(BeginUnformattedInput)>(builder);
+    }
+  } else {
+    if (isAsynch) {
+      ioFunc = getIORuntimeFunc<mkIOKey(BeginAsynchronousOutput)>(builder);
+      llvm_unreachable("asynchronous not implemented in runtime");
+    } else if (isFormatted) {
+      if (isIntern) {
+        if (isNml) {
+          ioFunc =
+              getIORuntimeFunc<mkIOKey(BeginInternalNamelistOutput)>(builder);
+        } else if (isOtherIntern) {
+          if (isList)
+            ioFunc = getIORuntimeFunc<mkIOKey(BeginInternalArrayListOutput)>(
+                builder);
+          else
+            ioFunc =
+                getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedOutput)>(
+                    builder);
+        } else if (isList) {
+          ioFunc = getIORuntimeFunc<mkIOKey(BeginInternalListOutput)>(builder);
+        } else {
+          ioFunc =
+              getIORuntimeFunc<mkIOKey(BeginInternalFormattedOutput)>(builder);
+        }
+      } else if (isNml) {
+        ioFunc =
+            getIORuntimeFunc<mkIOKey(BeginExternalNamelistOutput)>(builder);
+      } else if (isList) {
+        ioFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
+      } else {
+        ioFunc =
+            getIORuntimeFunc<mkIOKey(BeginExternalFormattedOutput)>(builder);
+      }
+    } else {
+      ioFunc = getIORuntimeFunc<mkIOKey(BeginUnformattedOutput)>(builder);
+    }
+  }
+  return {};
+}
+
+// PRINT does not take an io-control-spec. It only has a format specifier, so it
+// is a simplified case of WRITE.
 void Fortran::lower::genPrintStatement(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::parser::PrintStmt &stmt) {
@@ -650,27 +778,16 @@ void Fortran::lower::genPrintStatement(
 }
 
 mlir::Value
-Fortran::lower::genReadStatement(Fortran::lower::AbstractConverter &converter,
-                                 const Fortran::parser::ReadStmt &) {
-  auto &builder = converter.getFirOpBuilder();
-  mlir::FuncOp beginFunc;
-  // if (...
-  beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
-  // else if (...
-  TODO();
-  return {};
+Fortran::lower::genWriteStatement(Fortran::lower::AbstractConverter &converter,
+                                  const Fortran::parser::WriteStmt &stmt) {
+  return genDataTransfer(converter, stmt, /*isInput=*/false,
+                         /*hasIOCtrl=*/true);
 }
 
 mlir::Value
-Fortran::lower::genWriteStatement(Fortran::lower::AbstractConverter &converter,
-                                  const Fortran::parser::WriteStmt &) {
-  auto &builder = converter.getFirOpBuilder();
-  mlir::FuncOp beginFunc;
-  // if (...
-  beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
-  // else if (...
-  TODO();
-  return {};
+Fortran::lower::genReadStatement(Fortran::lower::AbstractConverter &converter,
+                                 const Fortran::parser::ReadStmt &stmt) {
+  return genDataTransfer(converter, stmt, /*isInput=*/true, /*hasIOCtrl=*/true);
 }
 
 mlir::Value Fortran::lower::genInquireStatement(
diff --git a/lib/Lower/RTBuilder.h b/lib/Lower/RTBuilder.h
index 18591a7b7a87..8450115d66f4 100644
--- a/lib/Lower/RTBuilder.h
+++ b/lib/Lower/RTBuilder.h
@@ -72,6 +72,13 @@ constexpr TypeBuilderFunc getModel<const char *>() {
   return getModel<char *>();
 }
 template <>
+constexpr TypeBuilderFunc getModel<void **>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return fir::ReferenceType::get(
+        fir::PointerType::get(mlir::IntegerType::get(8, context)));
+  };
+}
+template <>
 constexpr TypeBuilderFunc getModel<std::int64_t>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
     return mlir::IntegerType::get(64, context);

From bf654b34b2544c9b98b74bc45625e364a9a76ce9 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Mon, 30 Mar 2020 18:07:23 -0700
Subject: [PATCH 290/345] more IO lowering

---
 lib/Lower/IO.cpp | 752 ++++++++++++++++++++++++++++++++++-------------
 1 file changed, 554 insertions(+), 198 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 8948bd129b30..00ea4c090eda 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -137,21 +137,22 @@ static mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
     if (ty.getWidth() == 1)
       return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
     return getIORuntimeFunc<mkIOKey(OutputInteger64)>(builder);
-  } else if (auto ty = type.dyn_cast<mlir::FloatType>()) {
+  }
+  if (auto ty = type.dyn_cast<mlir::FloatType>()) {
     if (ty.getWidth() <= 32)
       return getIORuntimeFunc<mkIOKey(OutputReal32)>(builder);
     return getIORuntimeFunc<mkIOKey(OutputReal64)>(builder);
-  } else if (auto ty = type.dyn_cast<fir::CplxType>()) {
+  }
+  if (auto ty = type.dyn_cast<fir::CplxType>()) {
     if (ty.getFKind() <= 4)
       return getIORuntimeFunc<mkIOKey(OutputComplex32)>(builder);
     return getIORuntimeFunc<mkIOKey(OutputComplex64)>(builder);
-  } else if (auto ty = type.dyn_cast<fir::LogicalType>()) {
+  }
+  if (auto ty = type.dyn_cast<fir::LogicalType>())
     return getIORuntimeFunc<mkIOKey(OutputLogical)>(builder);
-  } else if (auto ty = type.dyn_cast<fir::BoxType>()) {
+  if (auto ty = type.dyn_cast<fir::BoxType>())
     return getIORuntimeFunc<mkIOKey(OutputDescriptor)>(builder);
-  } else {
-    return getIORuntimeFunc<mkIOKey(OutputAscii)>(builder);
-  }
+  return getIORuntimeFunc<mkIOKey(OutputAscii)>(builder);
 }
 
 /// The I/O library interface requires that COMPLEX and CHARACTER typed values
@@ -217,6 +218,46 @@ static void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
   builder.create<mlir::CallOp>(loc, outputFunc, actuals);
 }
 
+static mlir::FuncOp getInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
+                                        mlir::Type type) {
+  if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
+    if (ty.getWidth() == 1)
+      return getIORuntimeFunc<mkIOKey(InputLogical)>(builder);
+    return getIORuntimeFunc<mkIOKey(InputInteger)>(builder);
+  }
+  if (auto ty = type.dyn_cast<mlir::FloatType>()) {
+    if (ty.getWidth() <= 32)
+      return getIORuntimeFunc<mkIOKey(InputReal32)>(builder);
+    return getIORuntimeFunc<mkIOKey(InputReal64)>(builder);
+  }
+  if (auto ty = type.dyn_cast<fir::CplxType>()) {
+    if (ty.getFKind() <= 4)
+      return getIORuntimeFunc<mkIOKey(InputReal32)>(builder);
+    return getIORuntimeFunc<mkIOKey(InputReal64)>(builder);
+  }
+  if (auto ty = type.dyn_cast<fir::LogicalType>())
+    return getIORuntimeFunc<mkIOKey(InputLogical)>(builder);
+  if (auto ty = type.dyn_cast<fir::BoxType>())
+    return getIORuntimeFunc<mkIOKey(InputDescriptor)>(builder);
+  return getIORuntimeFunc<mkIOKey(InputAscii)>(builder);
+}
+
+/// Generate a call to an Output I/O function.
+/// The specific call is determined dynamically by the argument type.
+static void genInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
+                                mlir::Location loc, mlir::Type argType,
+                                mlir::Value cookie,
+                                llvm::SmallVector<mlir::Value, 4> &operands) {
+  int i = 1;
+  llvm::SmallVector<mlir::Value, 4> actuals{cookie};
+  auto inputFunc = getInputRuntimeFunc(builder, argType);
+
+  for (auto &op : operands)
+    actuals.emplace_back(builder.create<fir::ConvertOp>(
+        loc, inputFunc.getType().getInput(i++), op));
+  builder.create<mlir::CallOp>(loc, inputFunc, actuals);
+}
+
 //===----------------------------------------------------------------------===//
 // Default argument generation.
 //===----------------------------------------------------------------------===//
@@ -234,6 +275,19 @@ static mlir::Value getDefaultLineNo(Fortran::lower::FirOpBuilder &builder,
                                           builder.getIntegerAttr(toType, 0));
 }
 
+static mlir::Value getDefaultScratch(Fortran::lower::FirOpBuilder &builder,
+                                     mlir::Location loc, mlir::Type toType) {
+  mlir::Value null =
+      builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
+  return builder.create<fir::ConvertOp>(loc, toType, null);
+}
+
+static mlir::Value getDefaultScratchLen(Fortran::lower::FirOpBuilder &builder,
+                                        mlir::Location loc, mlir::Type toType) {
+  return builder.create<mlir::ConstantOp>(loc,
+                                          builder.getIntegerAttr(toType, 0));
+}
+
 template <typename A>
 static std::tuple<mlir::Value, mlir::Value, mlir::Value>
 lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
@@ -262,14 +316,46 @@ lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
 // These are threaded together for a single statement via the passed cookie.
 //===----------------------------------------------------------------------===//
 
+template <typename A, typename B>
+mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter,
+                           mlir::Location loc, mlir::Value cookie,
+                           const B &spec) {
+  auto &builder = converter.getFirOpBuilder();
+  mlir::FuncOp ioFunc = getIORuntimeFunc<A>(builder);
+  mlir::FunctionType ioFuncTy = ioFunc.getType();
+  auto expr = converter.genExprValue(Fortran::semantics::GetExpr(spec.v), loc);
+  auto val = builder.create<fir::ConvertOp>(loc, ioFuncTy.getInput(1), expr);
+  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, val};
+  return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+}
+
+template <typename A, typename B>
+mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter,
+                            mlir::Location loc, mlir::Value cookie,
+                            const B &spec) {
+  auto &builder = converter.getFirOpBuilder();
+  mlir::FuncOp ioFunc = getIORuntimeFunc<A>(builder);
+  mlir::FunctionType ioFuncTy = ioFunc.getType();
+  auto tup = lowerStringLit(converter, loc, spec, ioFuncTy.getInput(1),
+                            ioFuncTy.getInput(2));
+  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, std::get<0>(tup),
+                                              std::get<1>(tup)};
+  return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+}
+
+// default case: do nothing
 template <typename A>
 mlir::Value genIOOption(Fortran::lower::AbstractConverter &converter,
-                        mlir::Location loc, mlir::Value cookie, const A &spec);
+                        mlir::Location loc, mlir::Value cookie, const A &spec) {
+  return {};
+}
+
 template <>
 mlir::Value genIOOption<Fortran::parser::FileNameExpr>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     mlir::Value cookie, const Fortran::parser::FileNameExpr &spec) {
   auto &builder = converter.getFirOpBuilder();
+  // has an extra KIND argument
   auto ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(builder);
   mlir::FunctionType ioFuncTy = ioFunc.getType();
   auto tup = lowerStringLit(converter, loc, spec, ioFuncTy.getInput(1),
@@ -340,50 +426,90 @@ template <>
 mlir::Value genIOOption<Fortran::parser::ConnectSpec::Recl>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     mlir::Value cookie, const Fortran::parser::ConnectSpec::Recl &spec) {
-  auto &builder = converter.getFirOpBuilder();
-  mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetRecl)>(builder);
-  mlir::FunctionType ioFuncTy = ioFunc.getType();
-  auto expr = converter.genExprValue(Fortran::semantics::GetExpr(spec.v), loc);
-  auto reclVal =
-      builder.create<fir::ConvertOp>(loc, ioFuncTy.getInput(1), expr);
-  llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, reclVal};
-  return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+  return genIntIOOption<mkIOKey(SetRecl)>(converter, loc, cookie, spec);
 }
+
 template <>
 mlir::Value genIOOption<Fortran::parser::StatusExpr>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     mlir::Value cookie, const Fortran::parser::StatusExpr &spec) {
+  return genCharIOOption<mkIOKey(SetStatus)>(converter, loc, cookie, spec.v);
+}
+
+template <>
+mlir::Value
+genIOOption<Fortran::parser::Name>(Fortran::lower::AbstractConverter &converter,
+                                   mlir::Location loc, mlir::Value cookie,
+                                   const Fortran::parser::Name &spec) {
+  // namelist
+  llvm_unreachable("not implemented");
+}
+
+template <>
+mlir::Value genIOOption<Fortran::parser::IoControlSpec::CharExpr>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::IoControlSpec::CharExpr &spec) {
   auto &builder = converter.getFirOpBuilder();
-  mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetStatus)>(builder);
+  mlir::FuncOp ioFunc;
+  switch (std::get<Fortran::parser::IoControlSpec::CharExpr::Kind>(spec.t)) {
+  case Fortran::parser::IoControlSpec::CharExpr::Kind::Advance:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetAdvance)>(builder);
+    break;
+  case Fortran::parser::IoControlSpec::CharExpr::Kind::Blank:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetBlank)>(builder);
+    break;
+  case Fortran::parser::IoControlSpec::CharExpr::Kind::Decimal:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetDecimal)>(builder);
+    break;
+  case Fortran::parser::IoControlSpec::CharExpr::Kind::Delim:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetDelim)>(builder);
+    break;
+  case Fortran::parser::IoControlSpec::CharExpr::Kind::Pad:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetPad)>(builder);
+    break;
+  case Fortran::parser::IoControlSpec::CharExpr::Kind::Round:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetRound)>(builder);
+    break;
+  case Fortran::parser::IoControlSpec::CharExpr::Kind::Sign:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetSign)>(builder);
+    break;
+  }
   mlir::FunctionType ioFuncTy = ioFunc.getType();
-  auto tup = lowerStringLit(converter, loc, spec.v, ioFuncTy.getInput(1),
-                            ioFuncTy.getInput(2));
+  auto tup = lowerStringLit(
+      converter, loc, std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t),
+      ioFuncTy.getInput(1), ioFuncTy.getInput(2));
   llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, std::get<0>(tup),
                                               std::get<1>(tup)};
   return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 
 template <>
-mlir::Value genIOOption<Fortran::parser::MsgVariable>(
-    Fortran::lower::AbstractConverter &, mlir::Location, mlir::Value cookie,
-    const Fortran::parser::MsgVariable &) {
-  // see error handling
-  return cookie;
+mlir::Value genIOOption<Fortran::parser::IoControlSpec::Asynchronous>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie,
+    const Fortran::parser::IoControlSpec::Asynchronous &spec) {
+  return genCharIOOption<mkIOKey(SetAsynchronous)>(converter, loc, cookie,
+                                                   spec.v);
 }
+
 template <>
-mlir::Value genIOOption<Fortran::parser::StatVariable>(
-    Fortran::lower::AbstractConverter &, mlir::Location, mlir::Value cookie,
-    const Fortran::parser::StatVariable &) {
-  // see error handling
-  return cookie;
+mlir::Value genIOOption<Fortran::parser::IdVariable>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::IdVariable &spec) {
+  llvm_unreachable("asynchronous ID not implemented");
 }
+
 template <>
-mlir::Value
-genIOOption<Fortran::parser::ErrLabel>(Fortran::lower::AbstractConverter &,
-                                       mlir::Location, mlir::Value cookie,
-                                       const Fortran::parser::ErrLabel &) {
-  // see error handling
-  return cookie;
+mlir::Value genIOOption<Fortran::parser::IoControlSpec::Pos>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::IoControlSpec::Pos &spec) {
+  return genIntIOOption<mkIOKey(SetPos)>(converter, loc, cookie, spec);
+}
+template <>
+mlir::Value genIOOption<Fortran::parser::IoControlSpec::Rec>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    mlir::Value cookie, const Fortran::parser::IoControlSpec::Rec &spec) {
+  return genIntIOOption<mkIOKey(SetRec)>(converter, loc, cookie, spec);
 }
 
 namespace {
@@ -414,18 +540,32 @@ void genErrorOption<Fortran::parser::ErrLabel>(
     ErrorHandling &eh, const Fortran::parser::ErrLabel &) {
   eh.err = true;
 }
+template <>
+void genErrorOption<Fortran::parser::EndLabel>(
+    ErrorHandling &eh, const Fortran::parser::EndLabel &) {
+  eh.end = true;
+}
+template <>
+void genErrorOption<Fortran::parser::EorLabel>(
+    ErrorHandling &eh, const Fortran::parser::EorLabel &) {
+  eh.eor = true;
+}
 
 template <typename SEEK, typename A>
-static bool hasMem(const A &stmt) {
-  for (const auto &spec : stmt.v)
+static bool hasX(const A &list) {
+  for (const auto &spec : list)
     if (std::holds_alternative<SEEK>(spec.u))
       return true;
   return false;
 }
+template <typename SEEK, typename A>
+static bool hasMem(const A &stmt) {
+  return hasX<SEEK>(stmt.v);
+}
 
 /// Get the sought expression from the specifier list.
 template <typename SEEK, typename A>
-static const Fortran::semantics::SomeExpr *getMem(const A &stmt) {
+static const Fortran::semantics::SomeExpr *getExpr(const A &stmt) {
   for (const auto &spec : stmt.v)
     if (auto *f = std::get_if<SEEK>(&spec.u))
       return Fortran::semantics::GetExpr(f->v);
@@ -435,30 +575,24 @@ static const Fortran::semantics::SomeExpr *getMem(const A &stmt) {
 /// For each specifier, build the appropriate call, threading the cookie, and
 /// return the final ssa-value of the cookie.
 template <typename A>
-static mlir::Value threadSpecs(Fortran::lower::AbstractConverter &converter,
-                               mlir::Location loc, mlir::Value cookie,
-                               const A &stmt) {
-  for (const auto &spec : stmt.v) {
-    cookie = std::visit(
-        Fortran::common::visitors{
-            [&](const Fortran::parser::FileUnitNumber &) { return cookie; },
-            [&](const Fortran::parser::ConnectSpec::Newunit &) {
-              return cookie;
-            },
-            [&](const auto &x) {
-              return genIOOption(converter, loc, cookie, x);
-            }},
-        spec.u);
+static void threadSpecs(Fortran::lower::AbstractConverter &converter,
+                        mlir::Location loc, mlir::Value cookie, const A &list) {
+  for (const auto &spec : list) {
+    [[maybe_unused]] auto ok =
+        std::visit(Fortran::common::visitors{[&](const auto &x) {
+                     return genIOOption(converter, loc, cookie, x);
+                   }},
+                   spec.u);
+    // TODO: if error handling, add check of `ok`
   }
-  return cookie;
 }
 
 template <typename A>
-static mlir::Value threadErrors(Fortran::lower::AbstractConverter &converter,
-                                mlir::Location loc, mlir::Value cookie,
-                                const A &stmt) {
+static void threadErrors(Fortran::lower::AbstractConverter &converter,
+                         mlir::Location loc, mlir::Value cookie,
+                         const A &list) {
   ErrorHandling eh{};
-  for (const auto &spec : stmt.v)
+  for (const auto &spec : list)
     std::visit(Fortran::common::visitors{[&](const auto &x) {
                  genErrorOption(eh, x);
                }},
@@ -479,45 +613,126 @@ static mlir::Value threadErrors(Fortran::lower::AbstractConverter &converter,
         loc, builder.getIntegerAttr(ioFuncTy.getInput(5), eh.ioMsg));
     llvm::SmallVector<mlir::Value, 4> ioArgs = {cookie, hasIoStat, hasErr,
                                                 hasEnd, hasEor,    hasIoMsg};
-    cookie = builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+    builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
   }
-  return cookie;
 }
 
+//===----------------------------------------------------------------------===//
+// Data transfer helpers
 //===----------------------------------------------------------------------===//
 
-/// Lower print statement assuming a dummy runtime interface for now.
-static void lowerPrintStatement(Fortran::lower::AbstractConverter &converter,
-                                mlir::Location loc, mlir::ValueRange args,
-                                const Fortran::parser::Format &format) {
-  mlir::FuncOp beginFunc;
-  auto &builder = converter.getFirOpBuilder();
-  auto formatItems = lowerFormat(converter, format);
-  if (formatItems.has_value()) {
-    // has a format
-    TODO();
-  } else {
-    beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
-  }
-  mlir::FunctionType beginFuncTy = beginFunc.getType();
+template <typename SEEK, typename A>
+static bool hasIOControl(const A &stmt) {
+  return hasX<SEEK>(stmt.controls);
+}
 
-  // Initiate io
-  mlir::Value defaultUnit = builder.create<mlir::ConstantOp>(
-      loc, builder.getIntegerAttr(beginFuncTy.getInput(0),
-                                  Fortran::runtime::io::DefaultUnit));
-  auto srcFileName = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
-  auto lineNo = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
-  llvm::SmallVector<mlir::Value, 4> beginArgs{defaultUnit, srcFileName, lineNo};
-  mlir::Value cookie =
-      builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
+template <typename SEEK, typename A>
+static const auto *getIOControl(const A &stmt) {
+  for (const auto &spec : stmt.controls)
+    if (const auto *result = std::get_if<SEEK>(&spec.u))
+      return result;
+  return static_cast<const SEEK *>(nullptr);
+}
 
-  // Call data transfer runtime function
-  for (mlir::Value arg : args) {
-    // need some special handling for COMPLEX and CHARACTER
-    auto operands = splitArguments(builder, loc, arg);
-    genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
+template <typename A>
+static bool isDataTransferFormatted(const A &stmt) {
+  return stmt.format || hasIOControl<Fortran::parser::Format>(stmt);
+}
+template <>
+constexpr bool isDataTransferFormatted<const Fortran::parser::PrintStmt &>(
+    const Fortran::parser::PrintStmt &stmt) {
+  // PRINT is always formatted
+  return true;
+}
+
+template <typename A>
+static bool isDataTransferList(const A &stmt) {
+  if (stmt.format.has_value())
+    return std::holds_alternative<Fortran::parser::Star>(stmt.format->u);
+  if (auto *mem = getIOControl<Fortran::parser::Format>(stmt))
+    return std::holds_alternative<Fortran::parser::Star>(mem->u);
+  return false;
+}
+template <>
+bool isDataTransferList<const Fortran::parser::PrintStmt &>(
+    const Fortran::parser::PrintStmt &stmt) {
+  return std::holds_alternative<Fortran::parser::Star>(
+      std::get<Fortran::parser::Format>(stmt.t).u);
+}
+
+template <typename A>
+static bool isDataTransferInternal(const A &stmt) {
+  if (stmt.iounit.has_value())
+    return std::holds_alternative<Fortran::parser::Variable>(stmt.iounit->u);
+  if (auto *unit = getIOControl<Fortran::parser::IoUnit>(stmt))
+    return std::holds_alternative<Fortran::parser::Variable>(unit->u);
+  return false;
+}
+
+template <typename A>
+static bool isDataTransferInternalNotDefaultKind(const A &stmt) {
+  // FIXME - same as isDataTransferInternal, but the KIND of the expression is
+  // not the default KIND.
+  return false;
+}
+
+template <typename A>
+static bool isDataTransferAsynchronous(const A &stmt) {
+  if (auto *asynch =
+          getIOControl<Fortran::parser::IoControlSpec::Asynchronous>(stmt)) {
+    // FIXME: should contain a string of YES or NO
+    llvm_unreachable("asynchronous transfers not implemented in runtime");
   }
-  genEndIO(builder, loc, cookie);
+  return false;
+}
+
+template <typename A>
+static bool isDataTransferNamelist(const A &stmt) {
+  // FIXME - is this a namelist?
+  return false;
+}
+
+template <typename A>
+mlir::Value getFormat(Fortran::lower::AbstractConverter &converter,
+                      mlir::Location loc, const A &stmt, mlir::Type toType) {
+  const Fortran::lower::SomeExpr *expr = {};
+  return converter.genExprValue(expr, loc);
+}
+
+template <typename A>
+mlir::Value getFormatLen(Fortran::lower::AbstractConverter &converter,
+                         mlir::Location loc, const A &stmt, mlir::Type toType) {
+  const Fortran::lower::SomeExpr *expr = {};
+  return converter.genExprValue(expr, loc);
+}
+
+template <typename A>
+mlir::Value getBuffer(Fortran::lower::AbstractConverter &converter,
+                      mlir::Location loc, const A &stmt, mlir::Type toType) {
+  const Fortran::lower::SomeExpr *expr = {};
+  return converter.genExprValue(expr, loc);
+}
+
+template <typename A>
+mlir::Value getBufferLen(Fortran::lower::AbstractConverter &converter,
+                         mlir::Location loc, const A &stmt, mlir::Type toType) {
+  const Fortran::lower::SomeExpr *expr = {};
+  return converter.genExprValue(expr, loc);
+}
+
+template <typename A>
+mlir::Value getDescriptor(Fortran::lower::AbstractConverter &converter,
+                          mlir::Location loc, const A &stmt,
+                          mlir::Type toType) {
+  const Fortran::lower::SomeExpr *expr = {};
+  return converter.genExprValue(expr, loc);
+}
+
+template <typename A>
+mlir::Value getIOUnit(Fortran::lower::AbstractConverter &converter,
+                      mlir::Location loc, const A &stmt, mlir::Type toType) {
+  const Fortran::lower::SomeExpr *expr = {};
+  return converter.genExprValue(expr, loc);
 }
 
 //===----------------------------------------------------------------------===//
@@ -532,14 +747,14 @@ static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
   auto beginFunc = getIORuntimeFunc<K>(builder);
   mlir::FunctionType beginFuncTy = beginFunc.getType();
   auto unit = converter.genExprValue(
-      getMem<Fortran::parser::FileUnitNumber>(stmt), loc);
+      getExpr<Fortran::parser::FileUnitNumber>(stmt), loc);
   auto un = builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit);
   auto file = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
   auto line = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
   llvm::SmallVector<mlir::Value, 4> args{un, file, line};
   auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
-  cookie = threadErrors(converter, loc, cookie, stmt);
-  cookie = threadSpecs(converter, loc, cookie, stmt);
+  threadErrors(converter, loc, cookie, stmt.v);
+  threadSpecs(converter, loc, cookie, stmt.v);
   return genEndIO(builder, converter.getCurrentLocation(), cookie);
 }
 
@@ -578,7 +793,7 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
     beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(builder);
     mlir::FunctionType beginFuncTy = beginFunc.getType();
     auto unit = converter.genExprValue(
-        getMem<Fortran::parser::FileUnitNumber>(stmt), loc);
+        getExpr<Fortran::parser::FileUnitNumber>(stmt), loc);
     beginArgs.push_back(
         builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit));
     beginArgs.push_back(
@@ -596,8 +811,8 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
   }
   auto cookie =
       builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
-  cookie = threadErrors(converter, loc, cookie, stmt);
-  cookie = threadSpecs(converter, loc, cookie, stmt);
+  threadErrors(converter, loc, cookie, stmt.v);
+  threadSpecs(converter, loc, cookie, stmt.v);
   return genEndIO(builder, loc, cookie);
 }
 
@@ -618,17 +833,17 @@ Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
             : getIORuntimeFunc<mkIOKey(BeginWaitAll)>(builder);
   mlir::FunctionType beginFuncTy = beginFunc.getType();
   auto unit = converter.genExprValue(
-      getMem<Fortran::parser::FileUnitNumber>(stmt), loc);
+      getExpr<Fortran::parser::FileUnitNumber>(stmt), loc);
   auto un = builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(0), unit);
   llvm::SmallVector<mlir::Value, 4> args{un};
   if (hasId) {
     auto id =
-        converter.genExprValue(getMem<Fortran::parser::IdExpr>(stmt), loc);
+        converter.genExprValue(getExpr<Fortran::parser::IdExpr>(stmt), loc);
     args.push_back(
         builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(1), id));
   }
   auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
-  cookie = threadErrors(converter, loc, cookie, stmt);
+  threadErrors(converter, loc, cookie, stmt.v);
   return genEndIO(builder, converter.getCurrentLocation(), cookie);
 }
 
@@ -645,121 +860,235 @@ Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
 //   - external vs. internal + default KIND vs. internal + other KIND
 //===----------------------------------------------------------------------===//
 
-template <typename A>
-static bool isDataTransferFormatted(const A &stmt) {
-  return true;
-}
-template <typename A>
-static bool isDataTransferList(const A &stmt) {
-  return true;
-}
-template <typename A>
-static bool isDataTransferInternal(const A &stmt) {
-  return false;
-}
-template <typename A>
-static bool isDataTransferInternalNotDefaultKind(const A &stmt) {
-  return false;
-}
-template <typename A>
-static bool isDataTransferAsynchronous(const A &stmt) {
-  return false;
+// Determine the correct BeginXyz{In|Out}put api to invoke.
+template <bool isInput>
+mlir::FuncOp getBeginDataTransfer(FirOpBuilder &builder, bool isFormatted,
+                                  bool isList, bool isIntern,
+                                  bool isOtherIntern, bool isAsynch,
+                                  bool isNml) {
+  if constexpr (isInput) {
+    if (isAsynch)
+      return getIORuntimeFunc<mkIOKey(BeginAsynchronousInput)>(builder);
+    if (isFormatted) {
+      if (isIntern) {
+        if (isNml)
+          return getIORuntimeFunc<mkIOKey(BeginInternalNamelistInput)>(builder);
+        if (isOtherIntern) {
+          if (isList)
+            return getIORuntimeFunc<mkIOKey(BeginInternalArrayListInput)>(
+                builder);
+          return getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedInput)>(
+              builder);
+        }
+        if (isList)
+          return getIORuntimeFunc<mkIOKey(BeginInternalListInput)>(builder);
+        return getIORuntimeFunc<mkIOKey(BeginInternalFormattedInput)>(builder);
+      }
+      if (isNml)
+        return getIORuntimeFunc<mkIOKey(BeginExternalNamelistInput)>(builder);
+      if (isList)
+        return getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
+      return getIORuntimeFunc<mkIOKey(BeginExternalFormattedInput)>(builder);
+    }
+    return getIORuntimeFunc<mkIOKey(BeginUnformattedInput)>(builder);
+  } else {
+    if (isAsynch)
+      return getIORuntimeFunc<mkIOKey(BeginAsynchronousOutput)>(builder);
+    if (isFormatted) {
+      if (isIntern) {
+        if (isNml)
+          return getIORuntimeFunc<mkIOKey(BeginInternalNamelistOutput)>(
+              builder);
+        if (isOtherIntern) {
+          if (isList)
+            return getIORuntimeFunc<mkIOKey(BeginInternalArrayListOutput)>(
+                builder);
+          return getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedOutput)>(
+              builder);
+        }
+        if (isList)
+          return getIORuntimeFunc<mkIOKey(BeginInternalListOutput)>(builder);
+        return getIORuntimeFunc<mkIOKey(BeginInternalFormattedOutput)>(builder);
+      }
+      if (isNml)
+        return getIORuntimeFunc<mkIOKey(BeginExternalNamelistOutput)>(builder);
+      if (isList)
+        return getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
+      return getIORuntimeFunc<mkIOKey(BeginExternalFormattedOutput)>(builder);
+    }
+    return getIORuntimeFunc<mkIOKey(BeginUnformattedOutput)>(builder);
+  }
 }
-template <typename A>
-static bool isDataTransferNamelist(const A &stmt) {
-  return false;
+
+template <bool hasIOCtrl, typename A>
+void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
+                       Fortran::lower::AbstractConverter &converter,
+                       mlir::Location loc, const A &stmt,
+                       mlir::FunctionType ioFuncTy, bool isFormatted,
+                       bool isList, bool isIntern, bool isOtherIntern,
+                       bool isAsynch, bool isNml) {
+  if constexpr (hasIOCtrl) {
+    if (isAsynch || !isFormatted) {
+      // unit
+      ioArgs.push_back(
+          getIOUnit(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+      if (isAsynch) {
+        // ?, [buff, LEN]
+        llvm_unreachable("not implemented");
+      }
+    }
+    assert(isFormatted);
+    if (!isIntern) {
+      if (isNml) {
+        // namelist group
+        llvm_unreachable("not implemented");
+      } else if (!isList) {
+        // [format, LEN]
+        ioArgs.push_back(
+            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+        ioArgs.push_back(getFormatLen(converter, loc, stmt,
+                                      ioFuncTy.getInput(ioArgs.size())));
+      }
+      // unit
+      ioArgs.push_back(
+          getIOUnit(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+    } else {
+      if (isNml || isOtherIntern) {
+        // descriptor
+        ioArgs.push_back(getDescriptor(converter, loc, stmt,
+                                       ioFuncTy.getInput(ioArgs.size())));
+        if (isNml) {
+          // namelist group
+          llvm_unreachable("not implemented");
+        }
+        if (isOtherIntern && !isList) {
+          // [format, LEN]
+          ioArgs.push_back(getFormat(converter, loc, stmt,
+                                     ioFuncTy.getInput(ioArgs.size())));
+          ioArgs.push_back(getFormatLen(converter, loc, stmt,
+                                        ioFuncTy.getInput(ioArgs.size())));
+        }
+      } else {
+        // [buff, LEN]
+        ioArgs.push_back(
+            getBuffer(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+        ioArgs.push_back(getBufferLen(converter, loc, stmt,
+                                      ioFuncTy.getInput(ioArgs.size())));
+        if (!isList) {
+          // [format, LEN]
+          ioArgs.push_back(getFormat(converter, loc, stmt,
+                                     ioFuncTy.getInput(ioArgs.size())));
+          ioArgs.push_back(getFormatLen(converter, loc, stmt,
+                                        ioFuncTy.getInput(ioArgs.size())));
+        }
+      }
+      // [scratch, LEN]
+      auto &builder = converter.getFirOpBuilder();
+      ioArgs.push_back(
+          getDefaultScratch(builder, loc, ioFuncTy.getInput(ioArgs.size())));
+      ioArgs.push_back(
+          getDefaultScratchLen(builder, loc, ioFuncTy.getInput(ioArgs.size())));
+    }
+  } else {
+    if (!isList) {
+      // [format, LEN]
+      ioArgs.push_back(
+          getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+      ioArgs.push_back(
+          getFormatLen(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+    }
+    // unit
+    ioArgs.push_back(
+        getIOUnit(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+  }
 }
 
 template <typename A>
+const std::list<Fortran::parser::OutputItem> &getOutputItems(const A &stmt) {
+  if constexpr (std::is_same_v<A, Fortran::parser::PrintStmt>) {
+    return std::get<std::list<Fortran::parser::OutputItem>>(stmt.t);
+  } else {
+    return stmt.items;
+  }
+};
+
+template <bool isInput, bool hasIOCtrl, typename A>
 static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
-                                   const A &stmt, bool isInput,
-                                   bool hasIOCtrl) {
+                                   const A &stmt) {
   auto &builder = converter.getFirOpBuilder();
-  bool isFormatted = isDataTransferFormatted(stmt);
-  bool isList = isFormatted ? isDataTransferList(stmt) : false;
-  bool isIntern = hasIOCtrl ? isDataTransferInternal(stmt) : false;
-  bool isOtherIntern =
+  auto loc = converter.getCurrentLocation();
+  const bool isFormatted = isDataTransferFormatted(stmt);
+  const bool isList = isFormatted ? isDataTransferList(stmt) : false;
+  const bool isIntern = hasIOCtrl ? isDataTransferInternal(stmt) : false;
+  const bool isOtherIntern =
       isIntern ? isDataTransferInternalNotDefaultKind(stmt) : false;
-  bool isAsynch = hasIOCtrl ? isDataTransferAsynchronous(stmt) : false;
-  bool isNml = hasIOCtrl ? isDataTransferNamelist(stmt) : false;
+  const bool isAsynch = hasIOCtrl ? isDataTransferAsynchronous(stmt) : false;
+  const bool isNml = hasIOCtrl ? isDataTransferNamelist(stmt) : false;
 
   // Determine the correct IO API call to make.
-  mlir::FuncOp ioFunc;
-  if (isInput) {
-    if (isAsynch) {
-      ioFunc = getIORuntimeFunc<mkIOKey(BeginAsynchronousInput)>(builder);
-      llvm_unreachable("asynchronous not implemented in runtime");
-    } else if (isFormatted) {
-      if (isIntern) {
-        if (isNml) {
-          ioFunc =
-              getIORuntimeFunc<mkIOKey(BeginInternalNamelistInput)>(builder);
-        } else if (isOtherIntern) {
-          if (isList)
-            ioFunc =
-                getIORuntimeFunc<mkIOKey(BeginInternalArrayListInput)>(builder);
-          else
-            ioFunc =
-                getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedInput)>(
-                    builder);
-        } else if (isList) {
-          ioFunc = getIORuntimeFunc<mkIOKey(BeginInternalListInput)>(builder);
-        } else {
-          ioFunc =
-              getIORuntimeFunc<mkIOKey(BeginInternalFormattedInput)>(builder);
-        }
-      } else if (isNml) {
-        ioFunc = getIORuntimeFunc<mkIOKey(BeginExternalNamelistInput)>(builder);
-      } else if (isList) {
-        ioFunc = getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(builder);
+  mlir::FuncOp ioFunc = getBeginDataTransfer<isInput>(
+      builder, isFormatted, isList, isIntern, isOtherIntern, isAsynch, isNml);
+  mlir::FunctionType ioFuncTy = ioFunc.getType();
+
+  // append BeginXyz arguments
+  llvm::SmallVector<mlir::Value, 8> ioArgs;
+  populateArguments<hasIOCtrl>(ioArgs, converter, loc, stmt, ioFuncTy,
+                               isFormatted, isList, isIntern, isOtherIntern,
+                               isAsynch, isNml);
+  // filename and line are universal and always last
+  ioArgs.push_back(
+      getDefaultFilename(builder, loc, ioFuncTy.getInput(ioArgs.size())));
+  ioArgs.push_back(
+      getDefaultLineNo(builder, loc, ioFuncTy.getInput(ioArgs.size())));
+
+  // args are done; call the BeginXyz function
+  mlir::Value cookie =
+      builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
+
+  if constexpr (hasIOCtrl) {
+    threadErrors(converter, loc, cookie, stmt.controls);
+    threadSpecs(converter, loc, cookie, stmt.controls);
+  }
+  // process the arguments
+  llvm::SmallVector<mlir::Value, 32> args;
+  if constexpr (isInput) {
+    for (auto &item : stmt.items) {
+      if (auto *pe = std::get_if<Fortran::parser::Variable>(&item.u)) {
+        auto loc = converter.genLocation(pe->GetSource());
+        args.push_back(
+            converter.genExprAddr(Fortran::semantics::GetExpr(*pe), loc));
       } else {
-        ioFunc =
-            getIORuntimeFunc<mkIOKey(BeginExternalFormattedInput)>(builder);
+        TODO(); // TODO implied do
       }
-    } else {
-      ioFunc = getIORuntimeFunc<mkIOKey(BeginUnformattedInput)>(builder);
+    }
+    for (mlir::Value arg : args) {
+      // need some special handling for COMPLEX and CHARACTER
+      TODO();
+      auto operands = splitArguments(builder, loc, arg);
+      genInputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
     }
   } else {
-    if (isAsynch) {
-      ioFunc = getIORuntimeFunc<mkIOKey(BeginAsynchronousOutput)>(builder);
-      llvm_unreachable("asynchronous not implemented in runtime");
-    } else if (isFormatted) {
-      if (isIntern) {
-        if (isNml) {
-          ioFunc =
-              getIORuntimeFunc<mkIOKey(BeginInternalNamelistOutput)>(builder);
-        } else if (isOtherIntern) {
-          if (isList)
-            ioFunc = getIORuntimeFunc<mkIOKey(BeginInternalArrayListOutput)>(
-                builder);
-          else
-            ioFunc =
-                getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedOutput)>(
-                    builder);
-        } else if (isList) {
-          ioFunc = getIORuntimeFunc<mkIOKey(BeginInternalListOutput)>(builder);
-        } else {
-          ioFunc =
-              getIORuntimeFunc<mkIOKey(BeginInternalFormattedOutput)>(builder);
-        }
-      } else if (isNml) {
-        ioFunc =
-            getIORuntimeFunc<mkIOKey(BeginExternalNamelistOutput)>(builder);
-      } else if (isList) {
-        ioFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
+    for (auto &item : getOutputItems(stmt)) {
+      if (auto *pe = std::get_if<Fortran::parser::Expr>(&item.u)) {
+        auto loc = converter.genLocation(pe->source);
+        args.push_back(
+            converter.genExprValue(Fortran::semantics::GetExpr(*pe), loc));
       } else {
-        ioFunc =
-            getIORuntimeFunc<mkIOKey(BeginExternalFormattedOutput)>(builder);
+        TODO(); // TODO implied do
       }
-    } else {
-      ioFunc = getIORuntimeFunc<mkIOKey(BeginUnformattedOutput)>(builder);
+    }
+    for (mlir::Value arg : args) {
+      // need some special handling for COMPLEX and CHARACTER
+      auto operands = splitArguments(builder, loc, arg);
+      genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
     }
   }
-  return {};
+
+  return genEndIO(builder, loc, cookie);
 }
 
-// PRINT does not take an io-control-spec. It only has a format specifier, so it
-// is a simplified case of WRITE.
+// PRINT does not take an io-control-spec. It only has a format specifier, so
+// it is a simplified case of WRITE.
 void Fortran::lower::genPrintStatement(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::parser::PrintStmt &stmt) {
@@ -773,21 +1102,48 @@ void Fortran::lower::genPrintStatement(
       TODO(); // TODO implied do
     }
   }
-  lowerPrintStatement(converter, converter.getCurrentLocation(), args,
-                      std::get<Fortran::parser::Format>(stmt.t));
+  auto loc = converter.getCurrentLocation();
+  auto &builder = converter.getFirOpBuilder();
+  const auto &format = std::get<Fortran::parser::Format>(stmt.t);
+  auto formatItems = lowerFormat(converter, format);
+  mlir::FuncOp beginFunc;
+  if (formatItems.has_value()) {
+    // has a format
+    TODO();
+  } else {
+    beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
+  }
+  mlir::FunctionType beginFuncTy = beginFunc.getType();
+
+  // Initiate io
+  mlir::Value defaultUnit = builder.create<mlir::ConstantOp>(
+      loc, builder.getIntegerAttr(beginFuncTy.getInput(0),
+                                  Fortran::runtime::io::DefaultUnit));
+  auto srcFileName = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
+  auto lineNo = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
+  llvm::SmallVector<mlir::Value, 4> beginArgs{defaultUnit, srcFileName, lineNo};
+  mlir::Value cookie =
+      builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
+
+  // Call data transfer runtime function
+  for (mlir::Value arg : args) {
+    // need some special handling for COMPLEX and CHARACTER
+    auto operands = splitArguments(builder, loc, arg);
+    genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
+  }
+  genEndIO(builder, loc, cookie);
 }
 
 mlir::Value
 Fortran::lower::genWriteStatement(Fortran::lower::AbstractConverter &converter,
                                   const Fortran::parser::WriteStmt &stmt) {
-  return genDataTransfer(converter, stmt, /*isInput=*/false,
-                         /*hasIOCtrl=*/true);
+  return genDataTransfer</*isInput=*/false, /*ioCtrl=*/true>(converter, stmt);
 }
 
 mlir::Value
 Fortran::lower::genReadStatement(Fortran::lower::AbstractConverter &converter,
                                  const Fortran::parser::ReadStmt &stmt) {
-  return genDataTransfer(converter, stmt, /*isInput=*/true, /*hasIOCtrl=*/true);
+  return genDataTransfer</*isInput=*/true, /*ioCtrl=*/true>(converter, stmt);
 }
 
 mlir::Value Fortran::lower::genInquireStatement(

From aceb4ac16e3d96cd2f821b2d567c8d4bb7ab4a78 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 26 Mar 2020 08:54:11 -0700
Subject: [PATCH 291/345] [front-end change] IsProcedure fix: follow host
 association

---
 lib/Semantics/tools.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/Semantics/tools.cpp b/lib/Semantics/tools.cpp
index 0c7a6d96be67..005e55fdf7c1 100644
--- a/lib/Semantics/tools.cpp
+++ b/lib/Semantics/tools.cpp
@@ -310,6 +310,7 @@ bool IsProcedure(const Symbol &symbol) {
           [](const GenericDetails &) { return true; },
           [](const ProcBindingDetails &) { return true; },
           [](const UseDetails &x) { return IsProcedure(x.symbol()); },
+          [](const HostAssocDetails &x) { return IsProcedure(x.symbol()); },
           // TODO: FinalProcDetails?
           [](const auto &) { return false; },
       },

From bbce47e49110bfc7c9aeede8ab147367ae1a2812 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 26 Mar 2020 08:52:24 -0700
Subject: [PATCH 292/345] Skeleton of specification handling and character
 assignement update

Go through function unit scope symbols and evaluate specification
expression before starting execution statements.

Current implementation only evaluate character length expression, and
hard TODO are added for other specification expressions.

CharacterOpsBuilder interface is cleaned up to support gettig stringLit.
Helper functions are also used in IO.cpp.

Conflicts:
	lib/Lower/Bridge.cpp
---
 include/flang/Lower/FIRBuilder.h            |  86 ++++-
 lib/Lower/Bridge.cpp                        | 140 ++++---
 lib/Lower/ConvertExpr.cpp                   |  52 +--
 lib/Lower/FIRBuilder.cpp                    | 405 ++++++++++++++++----
 lib/Lower/IO.cpp                            |  62 +--
 not-test/lower/test_character_assignment.sh |   2 +-
 test/Lower/pre-fir-tree02.f90               |   4 +-
 7 files changed, 525 insertions(+), 226 deletions(-)

diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index 737fa5c3e60d..b7ed5d5c5131 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -51,13 +51,6 @@ class SymMap {
   llvm::DenseMap<const semantics::Symbol *, mlir::Value> symbolMap;
 };
 
-/// Pair of ssa-values that compose a CHARACTER value. The buffer that holds the
-/// data and the LEN type parameter.
-struct CharValue {
-  mlir::Value buffer;
-  mlir::Value len;
-};
-
 //===----------------------------------------------------------------------===//
 // FirOpBuilder interface extensions
 //===----------------------------------------------------------------------===//
@@ -69,25 +62,76 @@ struct CharValue {
 template <typename T>
 class CharacterOpsBuilder {
 public:
-  fir::ReferenceType getReferenceType(const CharValue &pair);
-  fir::CharacterType getCharacterType(const CharValue &pair);
-
   // access the implementation
   T &impl() { return *static_cast<T *>(this); }
 
+  /// Unless otherwise stated, all mlir::Value inputs of these pseudo-fir ops
+  /// must be of type:
+  /// - fir.boxchar<kind> (dynamic length character),
+  /// - fir.ref<fir.array<len x fir.char<kind>>> (character with compile timeA
+  ///      constant length),
+  /// - fir.array<len x fir.char<kind>> (compile time constant character)
+
   /// Copy the \p count first characters of \p src into \p dest.
-  void createCopy(CharValue &dest, const CharValue &src, mlir::Value count);
+  /// \p count can have any integer type.
+  void createCopy(mlir::Value dest, mlir::Value src, mlir::Value count);
 
   /// Set characters of \p str at position [\p lower, \p upper) to blanks.
   /// \p lower and \upper bounds are zero based.
   /// If \p upper <= \p lower, no padding is done.
-  void createPadding(CharValue &str, mlir::Value lower, mlir::Value upper);
+  /// \p upper and \p lower can have any integer type.
+  void createPadding(mlir::Value str, mlir::Value lower, mlir::Value upper);
 
-  /// Allocate storage (on the stack) for character given the kind and length.
-  CharValue createCharacterTemp(fir::CharacterType type, mlir::Value len);
+  /// Create str(lb:ub), lower bounds must always be specified, upper
+  /// bound is optional.
+  mlir::Value createSubstring(mlir::Value str,
+                              llvm::ArrayRef<mlir::Value> bounds);
 
-protected:
+  /// Return blank character of given \p type !fir.char<kind>
   mlir::Value createBlankConstant(fir::CharacterType type);
+  /// Lower \p lhs = \p rhs where \p lhs and \p rhs are scalar characters.
+  /// It handles cases where \p lhs and \p rhs may overlap.
+  void createAssign(mlir::Value lhs, mlir::Value rhs);
+
+  /// Embox \p addr and \p len and return fir.boxchar.
+  /// Take care of type conversions before emboxing.
+  /// \p len is converted to the integer type for character lengths if needed.
+  mlir::Value createEmboxChar(mlir::Value addr, mlir::Value len);
+  /// Unbox \p boxchar into (fir.ref<fir.char<kind>>, getLengthType()).
+  std::pair<mlir::Value, mlir::Value> createUnboxChar(mlir::Value boxChar);
+
+  /// Allocate a temp of fir::CharacterType type and length len.
+  /// Returns related fir.ref<fir.char<kind>>.
+  mlir::Value createCharacterTemp(mlir::Type type, mlir::Value len);
+  /// Allocate a temp of compile time constant length.
+  /// Returns related fir.ref<fir.array<len x fir.char<kind>>>.
+  mlir::Value createCharacterTemp(mlir::Type type, int len);
+
+  /// Return buffer/length pair of character str, if str is a constant,
+  /// it is allocated into a temp, otherwise, its memory reference is
+  /// returned as the buffer.
+  /// The buffer type of str is of type:
+  ///   - fir.ref<fir.array<len x fir.char<kind>>> if str has compile time
+  ///      constant length.
+  ///   - fir.ref<fir.char<kind>> if str has dynamic length.
+  std::pair<mlir::Value, mlir::Value> materializeCharacter(mlir::Value str);
+
+  /// Return true if \p is a character literal (has type
+  /// fir.array<len x fir.char<kind>>).;
+  bool isCharacterLiteral(mlir::Value str);
+
+  /// Return true if \p val has one of the following type
+  /// - fir.boxchar<kind>
+  /// - fir.ref<fir.array<len x fir.char<kind>>>
+  /// - fir.array<len x fir.char<kind>>
+  bool isCharacter(mlir::Value val);
+
+  /// Extract the kind of character \p str.
+  int getCharacterKind(mlir::Value str);
+
+  /// Return the integer type that must be used to manipulate
+  /// Character lengths.
+  mlir::Type getLengthType();
 };
 
 /// Extension class to facilitate lowering of COMPLEX manipulations in FIR.
@@ -101,17 +145,21 @@ class ComplexOpsBuilder {
   // access the implementation
   T &impl() { return *static_cast<T *>(this); }
 
-  // Type helper. They do not create MLIR operations.
+  /// Type helper. They do not create MLIR operations.
   mlir::Type getComplexPartType(mlir::Value cplx);
   mlir::Type getComplexPartType(mlir::Type complexType);
   mlir::Type getComplexPartType(fir::KindTy complexKind);
 
-  // Complex operation creation helper. They create MLIR operations.
+  /// Complex operation creation helper. They create MLIR operations.
   mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
                             mlir::Value imag);
   mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart) {
     return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
   }
+  /// Returns (Real, Imag) pair of \p cplx
+  std::pair<mlir::Value, mlir::Value> extractParts(mlir::Value cplx) {
+    return {extract<Part::Real>(cplx), extract<Part::Imag>(cplx)};
+  }
   mlir::Value insertComplexPart(mlir::Value cplx, mlir::Value part,
                                 bool isImagPart) {
     return isImagPart ? insert<Part::Imag>(cplx, part)
@@ -281,12 +329,12 @@ class FirOpBuilder : public mlir::OpBuilder,
 
   using BodyGenerator = std::function<void(FirOpBuilder &, mlir::Value)>;
 
-  /// Build loop [\p lb, \p ub) with step \p step.
+  /// Build loop [\p lb, \p ub] with step \p step.
   /// If \p step is an empty value, 1 is used for the step.
   void createLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
                   const BodyGenerator &bodyGenerator);
 
-  /// Build loop [\p lb,  \p ub) with step 1.
+  /// Build loop [\p lb,  \p ub] with step 1.
   void createLoop(mlir::Value lb, mlir::Value ub,
                   const BodyGenerator &bodyGenerator);
 
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index b5f0dd4a9461..8763d4a2df45 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -841,45 +841,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     TODO();
   }
 
-  void genCharacterAssignment(const Fortran::evaluate::Assignment &assignment) {
-    // Helper to get address and length from an Expr that is a character
-    // variable designator
-    auto getAddrAndLength =
-        [&](const Fortran::lower::SomeExpr &charDesignatorExpr)
-        -> Fortran::lower::CharValue {
-      auto addr = genExprAddr(charDesignatorExpr);
-      const auto &charExpr =
-          std::get<Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
-              charDesignatorExpr.u);
-      auto lenExpr = charExpr.LEN();
-      assert(lenExpr.has_value() &&
-             "could not get expression to compute character length");
-      auto len =
-          genExprValue(Fortran::evaluate::AsGenericExpr(std::move(*lenExpr)));
-      return {addr, len};
-    };
-
-    builder->setLocation(toLocation());
-
-    // RHS evaluation.
-    // FIXME:  Only works with rhs that are variable reference.
-    // Other expression evaluation are not simple copies.
-    auto rhs = getAddrAndLength(assignment.rhs);
-    // A temp is needed to evaluate rhs until proven it does not depend on lhs.
-    auto tempToEvalRhs =
-        builder->createCharacterTemp(builder->getCharacterType(rhs), rhs.len);
-    builder->createCopy(tempToEvalRhs, rhs, rhs.len);
-
-    // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
-    auto lhs = getAddrAndLength(assignment.lhs);
-    auto cmpLen = builder->createHere<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
-                                                    lhs.len, rhs.len);
-    auto copyCount =
-        builder->createHere<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
-    builder->createCopy(lhs, tempToEvalRhs, copyCount);
-    builder->createPadding(lhs, copyCount, lhs.len);
-  }
-
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::AssignmentStmt &stmt) {
     assert(stmt.typedAssignment && stmt.typedAssignment->v &&
@@ -927,7 +888,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
                                                 genExprAddr(assignment.lhs));
                 } else if (isCharacterCategory(lhsType->category())) {
                   // Fortran 2018 10.2.1.3 p10 and p11
-                  genCharacterAssignment(assignment);
+                  // Generating value for lhs to get fir.boxchar.
+                  auto lhs{genExprValue(assignment.lhs)};
+                  auto rhs{genExprValue(assignment.rhs)};
+                  builder->createAssign(lhs, rhs);
                 } else {
                   assert(lhsType->category() == Fortran::lower::DerivedCat);
                   // Fortran 2018 10.2.1.3 p12 and p13
@@ -1136,6 +1100,82 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return Fortran::lower::FirOpBuilder::createFunction(loc, module, name, ty);
   }
 
+  /// Evaluate specification expressions of local symbol and add
+  /// the resulting mlir::value to localSymbols.
+  /// Before evaluating a specification expression, the symbols
+  /// appearing in the expression are gathered, and if they are also
+  /// local symbols, their specification are evaluated first. In case
+  /// a circular dependency occurs, this will crash.
+  void instantiateLocalVariable(
+      const Fortran::semantics::Symbol &symbol,
+      Fortran::lower::SymMap &dummyArgs,
+      llvm::DenseSet<Fortran::semantics::SymbolRef> attempted) {
+    if (localSymbols.lookupSymbol(symbol))
+      return; // already instantiated
+
+    if (IsProcedure(symbol))
+      return;
+
+    if (symbol.has<Fortran::semantics::UseDetails>() ||
+        symbol.has<Fortran::semantics::HostAssocDetails>())
+      TODO(); // Need to keep the localSymbols of other units ?
+
+    if (attempted.find(symbol) != attempted.end())
+      TODO(); // Complex dependencies in specification expressions.
+
+    attempted.insert(symbol);
+    mlir::Value localValue;
+    auto *type{symbol.GetType()};
+    assert(type && "expected type for local symbol");
+
+    if (type->category() == Fortran::semantics::DeclTypeSpec::Character) {
+      const auto &lenghtParam{type->characterTypeSpec().length()};
+      if (auto expr{lenghtParam.GetExplicit()}) {
+        for (const auto &requiredSymbol :
+             Fortran::evaluate::CollectSymbols(*expr)) {
+          instantiateLocalVariable(requiredSymbol, dummyArgs, attempted);
+        }
+        auto lenValue =
+            genExprValue(Fortran::evaluate::AsGenericExpr(std::move(*expr)));
+        if (auto actual = dummyArgs.lookupSymbol(symbol)) {
+          auto unboxed = builder->createUnboxChar(actual);
+          localValue = builder->createEmboxChar(unboxed.first, lenValue);
+        } else {
+          // TODO: propagate symbol name to FIR.
+          localValue = builder->createCharacterTemp(genType(symbol), lenValue);
+        }
+      } else if (lenghtParam.isDeferred()) {
+        TODO();
+      } else {
+        // Assumed
+        localValue = dummyArgs.lookupSymbol(symbol);
+        assert(localValue &&
+               "expected dummy arguments when length not explicit");
+      }
+      localSymbols.addSymbol(symbol, localValue);
+    } else if (!type->AsIntrinsic()) {
+      TODO(); // Derived type / polymorphic
+    } else {
+      if (auto actualValue = dummyArgs.lookupSymbol(symbol))
+        localSymbols.addSymbol(symbol, actualValue);
+      else
+        createTemporary(toLocation(), symbol);
+    }
+    if (const auto *details =
+            symbol.detailsIf<Fortran::semantics::ObjectEntityDetails>()) {
+      if (!details->shape().empty())
+        TODO(); // handle bounds specification expressions
+      if (!details->coshape().empty())
+        TODO(); // handle cobounds specification expressions
+      if (details->init())
+        TODO(); // init
+    } else {
+      assert(symbol.has<Fortran::semantics::ProcEntityDetails>());
+      TODO(); // Procedure pointers
+    }
+    attempted.erase(symbol);
+  }
+
   /// Prepare to translate a new function
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     assert(!builder && "expected nullptr");
@@ -1156,6 +1196,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     func.addEntryBlock();
     builder->setInsertionPointToStart(&func.front());
 
+    Fortran::lower::SymMap dummyAssociations;
     // plumb function's arguments
     if (funit.symbol && !funit.isMainProgram()) {
       auto *entryBlock = &func.front();
@@ -1164,13 +1205,26 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       for (const auto &v :
            llvm::zip(details.dummyArgs(), entryBlock->getArguments())) {
         if (std::get<0>(v)) {
-          localSymbols.addSymbol(*std::get<0>(v), std::get<1>(v));
+          dummyAssociations.addSymbol(*std::get<0>(v), std::get<1>(v));
         } else {
           TODO(); // handle alternate return
         }
       }
-      if (details.isFunction())
-        createTemporary(toLocation(), details.result());
+
+      // Go through the symbol scope and evaluate specification expressions
+      llvm::DenseSet<Fortran::semantics::SymbolRef> attempted;
+      assert(funit.symbol->scope() && "subprogram symbol must have a scope");
+      // TODO: This loop through scope symbols offers no stability guarantee
+      // regarding the order. This should not be a problem given how
+      // instantiateLocalVariable is implemented, but may harm reproducibility.
+      // A solution would be to sort the symbol based on their source location.
+      for (const auto &iter : *funit.symbol->scope()) {
+        instantiateLocalVariable(iter.second.get(), dummyAssociations,
+                                 attempted);
+      }
+
+      // if (details.isFunction())
+      //  createTemporary(toLocation(), details.result());
     }
 
     // Create most function blocks in advance.
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 385ce5ac1cb0..7f0fdc01d1eb 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -198,21 +198,13 @@ class ExprLowering {
                                 genval(ex.right()));
   }
 
+  /// Returns a reference to a symbol or its box/boxChar descriptor if it has
+  /// one.
   mlir::Value gen(Fortran::semantics::SymbolRef sym) {
     // FIXME: not all symbols are local
     auto addr = builder.createTemporary(
         getLoc(), symMap, converter.genType(sym), llvm::None, &*sym);
     assert(addr && "failed generating symbol address");
-    // Get address from descriptor if symbol has one.
-    auto type = addr.getType();
-    if (auto boxCharType = type.dyn_cast<fir::BoxCharType>()) {
-      auto refType = fir::ReferenceType::get(boxCharType.getEleTy());
-      auto lenType = builder.getIntegerType(64);
-      addr = builder.create<fir::UnboxCharOp>(getLoc(), refType, lenType, addr)
-                 .getResult(0);
-    } else if (type.isa<fir::BoxType>()) {
-      TODO();
-    }
     return addr;
   }
 
@@ -243,12 +235,9 @@ class ExprLowering {
     mlir::Value res{};
     switch (desc.field()) {
     case Fortran::evaluate::DescriptorInquiry::Field::Len:
-      if (auto boxCharType = descType.dyn_cast<fir::BoxCharType>()) {
-        auto refType = fir::ReferenceType::get(boxCharType.getEleTy());
-        auto lenType = mlir::IntegerType::get(64, builder.getContext());
-        res = builder
-                  .create<fir::UnboxCharOp>(getLoc(), refType, lenType, descRef)
-                  .getResult(1);
+      if (descType.isa<fir::BoxCharType>()) {
+        auto lenType{mlir::IntegerType::get(64, builder.getContext())};
+        res = builder.create<fir::BoxCharLenOp>(getLoc(), lenType, descRef);
       } else if (descType.isa<fir::BoxType>()) {
         TODO();
       } else {
@@ -581,37 +570,24 @@ class ExprLowering {
   mlir::Value genval(const Fortran::evaluate::ComplexPart &) { TODO(); }
 
   mlir::Value gen(const Fortran::evaluate::Substring &s) {
-    // Get base address
-    auto baseAddr = std::visit(
+    // Get base string
+    auto baseString = std::visit(
         Fortran::common::visitors{
             [&](const Fortran::evaluate::DataRef &x) { return gen(x); },
             [&](const Fortran::evaluate::StaticDataObject::Pointer &)
                 -> mlir::Value { TODO(); },
         },
         s.parent());
-    // Get a SequenceType to compute address with fir::CoordinateOp
-    auto charRefType = baseAddr.getType();
-    auto arrayRefType = Fortran::lower::getSequenceRefType(charRefType);
-    auto arrayView =
-        builder.create<fir::ConvertOp>(getLoc(), arrayRefType, baseAddr);
-    // Compute lower bound
-    auto indexType = mlir::IndexType::get(builder.getContext());
-    auto lowerBoundExpr = s.lower();
-    auto lowerBoundValue = builder.create<fir::ConvertOp>(
-        getLoc(), indexType, genval(lowerBoundExpr));
-    // FIR CoordinateOp is zero based but Fortran substring are one based.
-    auto one = builder.create<mlir::ConstantOp>(
-        getLoc(), indexType, builder.getIntegerAttr(indexType, 1));
-    auto offsetIndex =
-        builder.create<mlir::SubIOp>(getLoc(), lowerBoundValue, one)
-            .getResult();
-    // Get address from offset and base address
-    return builder.create<fir::CoordinateOp>(getLoc(), charRefType, arrayView,
-                                             offsetIndex);
+    llvm::SmallVector<mlir::Value, 2> bounds;
+    bounds.push_back(genval(s.lower()));
+    if (auto upperBound{s.upper()}) {
+      bounds.push_back(genval(*upperBound));
+    }
+    return builder.createSubstring(baseString, bounds);
   }
 
   mlir::Value gendef(const Fortran::evaluate::Substring &ss) { return gen(ss); }
-  mlir::Value genval(const Fortran::evaluate::Substring &) { TODO(); }
+  mlir::Value genval(const Fortran::evaluate::Substring &ss) { return gen(ss); }
   mlir::Value genval(const Fortran::evaluate::Triplet &trip) { TODO(); }
 
   mlir::Value genval(const Fortran::evaluate::Subscript &subs) {
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index b42f08b8bce5..a857f08b59ea 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -98,8 +98,9 @@ void Fortran::lower::FirOpBuilder::createLoop(
     mlir::Value count, const BodyGenerator &bodyGenerator) {
   auto indexType = getIndexType();
   auto zero = createIntegerConstant(indexType, 0);
-  auto one = createIntegerConstant(indexType, 1);
-  createLoop(zero, count, one, bodyGenerator);
+  auto one = createIntegerConstant(count.getType(), 1);
+  auto up = createHere<mlir::SubIOp>(count, one);
+  createLoop(zero, up, one, bodyGenerator);
 }
 
 mlir::Value
@@ -113,96 +114,356 @@ Fortran::lower::FirOpBuilder::convertToIndexType(mlir::Value integer) {
 // CharacterOpsBuilder implementation
 //===----------------------------------------------------------------------===//
 
+namespace {
+/// CharacterOpsBuilder implementation
+struct CharacterOpsBuilderImpl {
+  CharacterOpsBuilderImpl(Fortran::lower::FirOpBuilder &b) : builder{b} {}
+
+  /// Opened char box
+  /// Interchange format to avoid inserting unbox/embox everywhere while
+  /// evaluating character expressions.
+  struct Char {
+    /// Get fir.char<kind> type with the same kind as inside str.
+    static inline fir::CharacterType getCharacterType(mlir::Value str) {
+      auto type = str.getType();
+      if (auto boxType = type.dyn_cast<fir::BoxCharType>())
+        return boxType.getEleTy();
+      if (auto refType = type.dyn_cast<fir::ReferenceType>())
+        type = refType.getEleTy();
+      if (auto seqType = type.dyn_cast<fir::SequenceType>()) {
+        type = seqType.getEleTy();
+      }
+      if (auto charType = type.dyn_cast<fir::CharacterType>()) {
+        return charType;
+      }
+      llvm_unreachable("Invalid character value type");
+      return mlir::Type{}.dyn_cast<fir::CharacterType>();
+    }
+
+    fir::CharacterType getCharacterType() const {
+      return getCharacterType(data);
+    }
+    /// Get fir.ref<fir.char<kind>> type.
+    fir::ReferenceType getReferenceType() const {
+      return fir::ReferenceType::get(getCharacterType());
+    }
+
+    bool isConstant() const { return data.getType().isa<fir::SequenceType>(); }
+
+    /// Data must be of type:
+    /// - fir.ref<fir.char<kind>> (dynamic length)
+    /// - fir.ref<fir.array<len x fir.char<kind>>> (len compile time constant).
+    /// - fir.array<len x fir.char<kind>> (character constant)
+    mlir::Value data;
+    mlir::Value len;
+  };
+
+  Char materializeConstant(Char cst) {
+    assert(cst.isConstant() && "expected constant");
+    auto variable = builder.createHere<fir::AllocaOp>(cst.data.getType());
+    builder.createHere<fir::StoreOp>(cst.data, variable);
+    return {variable, cst.len};
+  }
+
+  Char toDataLengthPair(mlir::Value character) {
+    auto lenType = builder.getLengthType();
+    auto type = character.getType();
+    if (auto boxCharType = type.dyn_cast<fir::BoxCharType>()) {
+      auto refType = fir::ReferenceType::get(boxCharType.getEleTy());
+      auto unboxed =
+          builder.createHere<fir::UnboxCharOp>(refType, lenType, character);
+      return {unboxed.getResult(0), unboxed.getResult(1)};
+    }
+    if (auto refType = type.dyn_cast<fir::ReferenceType>())
+      type = refType.getEleTy();
+    if (auto seqType = type.dyn_cast<fir::SequenceType>()) {
+      assert(seqType.hasConstantShape() &&
+             "ssa array value must have constant length");
+      auto shape = seqType.getShape();
+      assert(shape.size() == 1 && "only scalar character supported");
+      // Materialize length for usage into character manipulations.
+      auto len = builder.createIntegerConstant(lenType, shape[0]);
+      return {character, len};
+    }
+    llvm_unreachable("unexpected character type");
+    return {};
+  }
+
+  mlir::Value createEmbox(Char str) {
+    // BoxChar require a reference.
+    if (str.isConstant())
+      str = materializeConstant(str);
+    auto kind = str.getCharacterType().getFKind();
+    auto boxCharType = fir::BoxCharType::get(builder.getContext(), kind);
+    auto refType = str.getReferenceType();
+    // So far, fir.emboxChar fails lowering to llvm when it is given
+    // fir.data<fir.array<len x fir.char<kind>>> types, so convert to
+    // fir.data<fir.char<kind>> if needed.
+    if (refType != str.data.getType())
+      str.data = builder.createHere<fir::ConvertOp>(refType, str.data);
+    // Convert in case the provided length is not of the integer type that must
+    // be used in boxchar.
+    auto lenType = builder.getLengthType();
+    if (str.len.getType() != lenType)
+      str.len = builder.createHere<fir::ConvertOp>(lenType, str.len);
+    return builder.createHere<fir::EmboxCharOp>(boxCharType, str.data, str.len);
+  }
+
+  mlir::Value createLoadCharAt(Char str, mlir::Value index) {
+    auto addr = builder.createHere<fir::CoordinateOp>(str.getReferenceType(),
+                                                      str.data, index);
+    return builder.createHere<fir::LoadOp>(addr);
+  }
+  void createStoreCharAt(Char str, mlir::Value index, mlir::Value c) {
+    assert(!str.isConstant() && "cannot store into constant");
+    auto addr = builder.createHere<fir::CoordinateOp>(str.getReferenceType(),
+                                                      str.data, index);
+    builder.createHere<fir::StoreOp>(c, addr);
+  }
+
+  void createCopy(Char dest, Char src, mlir::Value count) {
+    builder.createLoop(
+        count, [&](Fortran::lower::FirOpBuilder &handler, mlir::Value index) {
+          CharacterOpsBuilderImpl charHandler{handler};
+          auto charVal = charHandler.createLoadCharAt(src, index);
+          charHandler.createStoreCharAt(dest, index, charVal);
+        });
+  }
+
+  void createPadding(Char str, mlir::Value lower, mlir::Value upper) {
+    auto blank = createBlankConstant(str.getCharacterType());
+    builder.createLoop(
+        lower, upper,
+        [&](Fortran::lower::FirOpBuilder &handler, mlir::Value index) {
+          CharacterOpsBuilderImpl charHandler{handler};
+          charHandler.createStoreCharAt(str, index, blank);
+        });
+  }
+
+  Char createTemp(mlir::Type type, mlir::Value len) {
+    assert(type.isa<fir::CharacterType>() && "expected fir character type");
+    llvm::SmallVector<mlir::Value, 0> lengths;
+    llvm::SmallVector<mlir::Value, 3> sizes{len};
+    auto ref = builder.createHere<fir::AllocaOp>(type, lengths, sizes);
+    return {ref, len};
+  }
+
+  mlir::Value createTemp(mlir::Type type, int len) {
+    assert(type.isa<fir::CharacterType>() && "expected fir character type");
+    assert(len >= 0 && "expected positive length");
+    fir::SequenceType::Shape shape{len};
+    auto seqType = fir::SequenceType::get(shape, type);
+    return builder.createHere<fir::AllocaOp>(seqType);
+  }
+
+  void createAssign(Char lhs, Char rhs) {
+    Char safe_rhs{rhs};
+    if (rhs.isConstant()) {
+      // Need to materialize the constant to get its elements.
+      // (No equivalent of fir.coordinate_of for array value).
+      safe_rhs = materializeConstant(rhs);
+    } else {
+      // If rhs is in memory, always assumes rhs might overlap with lhs
+      // in a way that require a temp for the copy. That can be optimize later.
+      auto temp = createTemp(rhs.getCharacterType(), rhs.len);
+      createCopy(temp, rhs, rhs.len);
+      safe_rhs = temp;
+    }
+
+    // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
+    auto cmpLen = builder.createHere<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
+                                                   lhs.len, rhs.len);
+    auto copyCount =
+        builder.createHere<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
+    createCopy(lhs, safe_rhs, copyCount);
+    auto one = builder.createIntegerConstant(lhs.len.getType(), 1);
+    auto maxPadding = builder.createHere<mlir::SubIOp>(lhs.len, one);
+    createPadding(lhs, copyCount, maxPadding);
+  }
+
+  mlir::Value createBlankConstant(fir::CharacterType type) {
+    auto byteTy = mlir::IntegerType::get(8, builder.getContext());
+    auto asciiSpace = builder.createIntegerConstant(byteTy, 0x20);
+    return builder.createHere<fir::ConvertOp>(type, asciiSpace);
+  }
+
+  Char createSubstring(Char str, llvm::ArrayRef<mlir::Value> bounds) {
+    // Constant need to be materialize in memory to use fir.coordinate_of.
+    if (str.isConstant())
+      str = materializeConstant(str);
+
+    auto nbounds{bounds.size()};
+    if (nbounds < 1 || nbounds > 2) {
+      mlir::emitError(builder.getLoc(),
+                      "Incorrect number of bounds in substring");
+      return {mlir::Value{}, mlir::Value{}};
+    }
+    auto indexType = mlir::IndexType::get(builder.getContext());
+    auto lowerBound = builder.createHere<fir::ConvertOp>(indexType, bounds[0]);
+    // FIR CoordinateOp is zero based but Fortran substring are one based.
+    auto oneIndex = builder.createIntegerConstant(indexType, 1);
+    auto offsetIndex =
+        builder.createHere<mlir::SubIOp>(lowerBound, oneIndex).getResult();
+    auto substringRef = builder.createHere<fir::CoordinateOp>(
+        str.getReferenceType(), str.data, offsetIndex);
+
+    // Compute the length.
+    mlir::Value substringLen{};
+    if (nbounds < 2) {
+      substringLen = builder.createHere<mlir::SubIOp>(str.len, bounds[0]);
+    } else {
+      substringLen = builder.createHere<mlir::SubIOp>(bounds[1], bounds[0]);
+    }
+    auto one = builder.createIntegerConstant(substringLen.getType(), 1);
+    substringLen = builder.createHere<mlir::AddIOp>(substringLen, one);
+
+    // Set length to zero if bounds were reversed (Fortran 2018 9.4.1)
+    auto zero = builder.createIntegerConstant(substringLen.getType(), 0);
+    auto cdt = builder.createHere<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
+                                                substringLen, zero);
+    substringLen = builder.createHere<mlir::SelectOp>(cdt, zero, substringLen);
+
+    return {substringRef, substringLen};
+  }
+  Fortran::lower::FirOpBuilder &builder;
+};
+} // namespace
+
 template <typename T>
-void Fortran::lower::CharacterOpsBuilder<T>::createCopy(
-    Fortran::lower::CharValue &dest, const Fortran::lower::CharValue &src,
-    mlir::Value count) {
-  auto &b = impl();
-  auto refType = b.getReferenceType(dest);
-  // Cast to character sequence reference type for fir::CoordinateOp.
-  auto seqTy = getSequenceRefType(refType);
-  auto destRef = b.template createHere<fir::ConvertOp>(seqTy, dest.buffer);
-  auto srcRef = b.template createHere<fir::ConvertOp>(seqTy, src.buffer);
-
-  b.createLoop(count, [&](Fortran::lower::FirOpBuilder &b, mlir::Value index) {
-    auto destAddr = b.createHere<fir::CoordinateOp>(refType, destRef, index);
-    auto srcAddr = b.createHere<fir::CoordinateOp>(refType, srcRef, index);
-    auto val = b.createHere<fir::LoadOp>(srcAddr);
-    b.createHere<fir::StoreOp>(val, destAddr);
-  });
+void Fortran::lower::CharacterOpsBuilder<T>::createCopy(mlir::Value dest,
+                                                        mlir::Value src,
+                                                        mlir::Value count) {
+  CharacterOpsBuilderImpl bimpl{impl()};
+  bimpl.createCopy(bimpl.toDataLengthPair(dest), bimpl.toDataLengthPair(src),
+                   count);
 }
-template void
-Fortran::lower::CharacterOpsBuilder<Fortran::lower::FirOpBuilder>::createCopy(
-    Fortran::lower::CharValue &, const Fortran::lower::CharValue &,
-    mlir::Value);
+
+template void Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createCopy(mlir::Value, mlir::Value,
+                                              mlir::Value);
 
 template <typename T>
-void Fortran::lower::CharacterOpsBuilder<T>::createPadding(
-    Fortran::lower::CharValue &str, mlir::Value lower, mlir::Value upper) {
-  auto &b = impl();
-  auto loc = b.getLoc();
-  auto refType = b.getReferenceType(str);
-  auto seqTy = getSequenceRefType(refType);
-  auto strRef = b.template createHere<fir::ConvertOp>(seqTy, str.buffer);
-  auto blank = createBlankConstant(b.getCharacterType(str));
-
-  b.createLoop(lower, upper, [&](FirOpBuilder &b, mlir::Value index) {
-    auto strAddr = b.create<fir::CoordinateOp>(loc, refType, strRef, index);
-    b.create<fir::StoreOp>(loc, blank, strAddr);
-  });
+void Fortran::lower::CharacterOpsBuilder<T>::createPadding(mlir::Value str,
+                                                           mlir::Value lower,
+                                                           mlir::Value upper) {
+  CharacterOpsBuilderImpl bimpl{impl()};
+  bimpl.createPadding(bimpl.toDataLengthPair(str), lower, upper);
 }
 template void Fortran::lower::CharacterOpsBuilder<
-    Fortran::lower::FirOpBuilder>::createPadding(Fortran::lower::CharValue &,
-                                                 mlir::Value, mlir::Value);
+    Fortran::lower::FirOpBuilder>::createPadding(mlir::Value, mlir::Value,
+                                                 mlir::Value);
 
 template <typename T>
-mlir::Value Fortran::lower::CharacterOpsBuilder<T>::createBlankConstant(
-    fir::CharacterType type) {
-  auto &b = impl();
-  auto byteTy = b.getIntegerType(8);
-  auto asciiSpace = b.createIntegerConstant(byteTy, ' ');
-  return b.template createHere<fir::ConvertOp>(type, asciiSpace);
+mlir::Value Fortran::lower::CharacterOpsBuilder<T>::createSubstring(
+    mlir::Value str, llvm::ArrayRef<mlir::Value> bounds) {
+  CharacterOpsBuilderImpl bimpl{impl()};
+  return bimpl.createEmbox(
+      bimpl.createSubstring(bimpl.toDataLengthPair(str), bounds));
 }
 template mlir::Value Fortran::lower::CharacterOpsBuilder<
-    Fortran::lower::FirOpBuilder>::createBlankConstant(fir::CharacterType);
+    Fortran::lower::FirOpBuilder>::createSubstring(mlir::Value,
+                                                   llvm::ArrayRef<mlir::Value>);
 
 template <typename T>
-Fortran::lower::CharValue
-Fortran::lower::CharacterOpsBuilder<T>::createCharacterTemp(
-    fir::CharacterType type, mlir::Value len) {
-  auto buffer = impl().createTemporary(type, {len});
-  return CharValue{buffer, len};
+void Fortran::lower::CharacterOpsBuilder<T>::createAssign(mlir::Value lhs,
+                                                          mlir::Value rhs) {
+  CharacterOpsBuilderImpl bimpl{impl()};
+  bimpl.createAssign(bimpl.toDataLengthPair(lhs), bimpl.toDataLengthPair(rhs));
 }
-template Fortran::lower::CharValue Fortran::lower::CharacterOpsBuilder<
-    Fortran::lower::FirOpBuilder>::createCharacterTemp(fir::CharacterType,
-                                                       mlir::Value);
+template void Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createAssign(mlir::Value, mlir::Value);
 
 template <typename T>
-fir::ReferenceType Fortran::lower::CharacterOpsBuilder<T>::getReferenceType(
-    const Fortran::lower::CharValue &pair) {
-  auto refTy = pair.buffer.getType();
-  if (auto type = refTy.template dyn_cast<fir::ReferenceType>())
-    return type;
-  llvm_unreachable("expected reference type");
-  return {};
+mlir::Value
+Fortran::lower::CharacterOpsBuilder<T>::createEmboxChar(mlir::Value addr,
+                                                        mlir::Value len) {
+  return CharacterOpsBuilderImpl{impl()}.createEmbox(
+      CharacterOpsBuilderImpl::Char{addr, len});
 }
-template fir::ReferenceType
-Fortran::lower::CharacterOpsBuilder<Fortran::lower::FirOpBuilder>::
-    getReferenceType(const Fortran::lower::CharValue &);
+template mlir::Value Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createEmboxChar(mlir::Value, mlir::Value);
 
 template <typename T>
-fir::CharacterType Fortran::lower::CharacterOpsBuilder<T>::getCharacterType(
-    const Fortran::lower::CharValue &pair) {
-  auto eleTy = getReferenceType(pair).getEleTy();
-  if (auto type = eleTy.template dyn_cast<fir::CharacterType>())
-    return type;
-  llvm_unreachable("expected character type");
-  return {};
+std::pair<mlir::Value, mlir::Value>
+Fortran::lower::CharacterOpsBuilder<T>::createUnboxChar(mlir::Value boxChar) {
+  auto c{CharacterOpsBuilderImpl{impl()}.toDataLengthPair(boxChar)};
+  return {c.data, c.len};
 }
-template fir::CharacterType
-Fortran::lower::CharacterOpsBuilder<Fortran::lower::FirOpBuilder>::
-    getCharacterType(const Fortran::lower::CharValue &);
 
+template std::pair<mlir::Value, mlir::Value>
+    Fortran::lower::CharacterOpsBuilder<
+        Fortran::lower::FirOpBuilder>::createUnboxChar(mlir::Value);
+
+template <typename T>
+mlir::Value
+Fortran::lower::CharacterOpsBuilder<T>::createCharacterTemp(mlir::Type type,
+                                                            mlir::Value len) {
+  CharacterOpsBuilderImpl bimpl{impl()};
+  return bimpl.createEmbox(bimpl.createTemp(type, len));
+}
+template mlir::Value Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createCharacterTemp(mlir::Type, mlir::Value);
+template <typename T>
+mlir::Value
+Fortran::lower::CharacterOpsBuilder<T>::createCharacterTemp(mlir::Type type,
+                                                            int len) {
+  CharacterOpsBuilderImpl bimpl{impl()};
+  return bimpl.createTemp(type, len);
+}
+template mlir::Value Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createCharacterTemp(mlir::Type, int);
+
+template <typename T>
+std::pair<mlir::Value, mlir::Value>
+Fortran::lower::CharacterOpsBuilder<T>::materializeCharacter(mlir::Value str) {
+  CharacterOpsBuilderImpl bimpl{impl()};
+  auto c = bimpl.toDataLengthPair(str);
+  if (c.isConstant())
+    c = bimpl.materializeConstant(c);
+  return {c.data, c.len};
+}
+template std::pair<mlir::Value, mlir::Value>
+    Fortran::lower::CharacterOpsBuilder<
+        Fortran::lower::FirOpBuilder>::materializeCharacter(mlir::Value);
+
+template <typename T>
+bool Fortran::lower::CharacterOpsBuilder<T>::isCharacterLiteral(
+    mlir::Value str) {
+  if (auto seqType = str.getType().dyn_cast<fir::SequenceType>())
+    return seqType.getEleTy().isa<fir::CharacterType>();
+  return false;
+}
+template bool Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::isCharacterLiteral(mlir::Value);
+
+template <typename T>
+bool Fortran::lower::CharacterOpsBuilder<T>::isCharacter(mlir::Value str) {
+  auto type = str.getType();
+  if (type.isa<fir::BoxCharType>())
+    return true;
+  if (auto refType = type.dyn_cast<fir::ReferenceType>())
+    type = refType.getEleTy();
+  if (auto seqType = type.dyn_cast<fir::SequenceType>()) {
+    type = seqType.getEleTy();
+  }
+  return type.isa<fir::CharacterType>();
+}
+template bool Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::isCharacter(mlir::Value);
+
+template <typename T>
+int Fortran::lower::CharacterOpsBuilder<T>::getCharacterKind(mlir::Value str) {
+  return CharacterOpsBuilderImpl::Char::getCharacterType(str).getFKind();
+}
+template int Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::getCharacterKind(mlir::Value);
+
+template <typename T>
+mlir::Type Fortran::lower::CharacterOpsBuilder<T>::getLengthType() {
+  return mlir::IntegerType::get(64, impl().getContext());
+}
+template mlir::Type Fortran::lower::CharacterOpsBuilder<
+    Fortran::lower::FirOpBuilder>::getLengthType();
 //===----------------------------------------------------------------------===//
 // ComplexOpsBuilder implementation
 //===----------------------------------------------------------------------===//
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 00ea4c090eda..bc604d02947b 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -80,12 +80,6 @@ static constexpr FuncTypeBuilderFunc getTypeModel() {
   return std::get<A>(newIOTable).getTypeModel();
 }
 
-inline bool isCharacterLiteral(mlir::Type argTy) {
-  if (auto arrTy = argTy.dyn_cast<fir::SequenceType>())
-    return arrTy.getEleTy().isa<fir::CharacterType>();
-  return false;
-}
-
 inline int64_t getLength(mlir::Type argTy) {
   return argTy.cast<fir::SequenceType>().getShape()[0];
 }
@@ -160,44 +154,13 @@ static mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
 static llvm::SmallVector<mlir::Value, 4>
 splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
                mlir::Value arg) {
-  mlir::Value zero;
-  mlir::Value one;
-  mlir::Type argTy = arg.getType();
-  mlir::MLIRContext *context = argTy.getContext();
-  const bool isComplex = argTy.isa<fir::CplxType>();
-  const bool isCharLit = isCharacterLiteral(argTy);
-  const bool isBoxChar = argTy.isa<fir::BoxCharType>();
-
-  if (isComplex || isCharLit || isBoxChar) {
-    // Only create these constants when needed and not every time
-    zero = builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(0));
-    one = builder.create<mlir::ConstantOp>(loc, builder.getI64IntegerAttr(1));
-  }
-  if (isComplex) {
-    auto eleTy =
-        fir::RealType::get(context, argTy.cast<fir::CplxType>().getFKind());
-    mlir::Value realPart =
-        builder.create<fir::ExtractValueOp>(loc, eleTy, arg, zero);
-    mlir::Value imaginaryPart =
-        builder.create<fir::ExtractValueOp>(loc, eleTy, arg, one);
-    return {realPart, imaginaryPart};
-  }
-  if (isBoxChar) {
-    mlir::Type ptrTy =
-        fir::ReferenceType::get(mlir::IntegerType::get(8, context));
-    mlir::Type sizeTy = mlir::IntegerType::get(64, context);
-    mlir::Value pointerPart =
-        builder.create<fir::ExtractValueOp>(loc, ptrTy, arg, zero);
-    mlir::Value sizePart =
-        builder.create<fir::ExtractValueOp>(loc, sizeTy, arg, one);
-    return {pointerPart, sizePart};
+  if (builder.isCharacter(arg)) {
+    auto dataLen = builder.materializeCharacter(arg);
+    return {dataLen.first, dataLen.second};
   }
-  if (isCharLit) {
-    mlir::Value variable = builder.create<fir::AllocaOp>(loc, argTy);
-    builder.create<fir::StoreOp>(loc, arg, variable);
-    mlir::Value sizePart = builder.create<mlir::ConstantOp>(
-        loc, builder.getI64IntegerAttr(getLength(argTy)));
-    return {variable, sizePart};
+  if (arg.getType().isa<fir::CplxType>()) {
+    auto parts = builder.extractParts(arg);
+    return {parts.first, parts.second};
   }
   return {arg};
 }
@@ -295,15 +258,12 @@ lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
                mlir::Type ty2 = {}) {
   auto &builder = converter.getFirOpBuilder();
   auto *expr = Fortran::semantics::GetExpr(syntax);
-  auto buffer = converter.genExprValue(expr, loc);
-  auto buff = builder.create<fir::ConvertOp>(loc, ty0, buffer);
-  mlir::Type ty = buffer.getType();
-  auto lenVal = ty.cast<fir::SequenceType>().getShape()[0];
-  auto len = builder.create<mlir::ConstantOp>(
-      loc, builder.getIntegerAttr(ty1, lenVal));
+  auto str = converter.genExprValue(expr, loc);
+  auto dataLen = builder.materializeCharacter(str);
+  auto buff = builder.create<fir::ConvertOp>(loc, ty0, dataLen.first);
+  auto len = builder.create<fir::ConvertOp>(loc, ty1, dataLen.second);
   if (ty2) {
-    mlir::Type eleTy = ty.cast<fir::SequenceType>().getEleTy();
-    auto kindVal = eleTy.cast<fir::CharacterType>().getFKind();
+    auto kindVal = builder.getCharacterKind(str);
     auto kind = builder.create<mlir::ConstantOp>(
         loc, builder.getIntegerAttr(ty2, kindVal));
     return {buff, len, kind};
diff --git a/not-test/lower/test_character_assignment.sh b/not-test/lower/test_character_assignment.sh
index c16177a3c5ee..7181bce96f73 100755
--- a/not-test/lower/test_character_assignment.sh
+++ b/not-test/lower/test_character_assignment.sh
@@ -26,7 +26,7 @@ testObject=test.o
 testExec=./test_exec
 testLog=test.log
 llFile=a.mlir.ll
-$BBC -emit-llvm -disable-fir2std $F_SRC 2>$bbcLog
+$BBC -emit-llvm -disable-fir2std -o a.mlir $F_SRC 2>$bbcLog
 [[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
 sed -i 's/_QP//g' -i $llFile
 $LLC $llFile -o $assembly
diff --git a/test/Lower/pre-fir-tree02.f90 b/test/Lower/pre-fir-tree02.f90
index f2b6e47aa19e..0fc219ff9a88 100644
--- a/test/Lower/pre-fir-tree02.f90
+++ b/test/Lower/pre-fir-tree02.f90
@@ -157,7 +157,7 @@ module test
   function foo(x)
     real x(..)
     integer :: foo
-    ! CHECK: <<SelectRankConstruct>>
+    ! CHECK: <<SelectRankConstruct!>>
     ! CHECK: SelectRankStmt
     select rank(x)
       ! CHECK: SelectRankCaseStmt
@@ -178,7 +178,7 @@ function foo(x)
         foo = 2
     ! CHECK: EndSelectStmt
     end select
-    ! CHECK: <<End SelectRankConstruct>>
+    ! CHECK: <<End SelectRankConstruct!>>
   end function
 
   ! CHECK: Function bar

From 5aa9ce183fa49e0695c5a4f86d06ca25f9bba883 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 31 Mar 2020 11:24:14 -0700
Subject: [PATCH 293/345] switch over print to new code

---
 lib/Lower/IO.cpp | 198 +++++++++++++++++++++--------------------------
 1 file changed, 89 insertions(+), 109 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index bc604d02947b..480f5ff10edd 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -108,23 +108,7 @@ static mlir::Value genEndIO(Fortran::lower::FirOpBuilder &builder,
   return call.getResult(0);
 }
 
-using FormatItems = std::optional<std::pair<mlir::Value, mlir::Value>>;
-
-/// Translate a list of format-items into a set of call-backs that can be
-/// emitted into the MLIR stream before each data item is processed
-static FormatItems lowerFormat(Fortran::lower::AbstractConverter &converter,
-                               const Fortran::parser::Format &format) {
-  FormatItems formatItems;
-  std::visit(Fortran::common::visitors{
-                 [](const Fortran::parser::DefaultCharExpr
-                        &) { /* string expression */ },
-                 [](const Fortran::parser::Label &) { /* FORMAT statement */ },
-                 [](const Fortran::parser::Star &) {},
-             },
-             format.u);
-  return formatItems;
-}
-
+/// Get the OutputXyz routine to output a value with type `type`.
 static mlir::FuncOp getOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
                                          mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
@@ -181,6 +165,7 @@ static void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
   builder.create<mlir::CallOp>(loc, outputFunc, actuals);
 }
 
+/// Get the InputXyz routine to input a value with type `type`.
 static mlir::FuncOp getInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
                                         mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
@@ -251,6 +236,8 @@ static mlir::Value getDefaultScratchLen(Fortran::lower::FirOpBuilder &builder,
                                           builder.getIntegerAttr(toType, 0));
 }
 
+/// Lower a string literal. Many arguments to the runtime are conveyed as
+/// Fortran CHARACTER literals.
 template <typename A>
 static std::tuple<mlir::Value, mlir::Value, mlir::Value>
 lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
@@ -276,6 +263,7 @@ lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
 // These are threaded together for a single statement via the passed cookie.
 //===----------------------------------------------------------------------===//
 
+/// Generic to build an integral argument to the runtime.
 template <typename A, typename B>
 mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter,
                            mlir::Location loc, mlir::Value cookie,
@@ -289,6 +277,8 @@ mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter,
   return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 
+/// Generic to build a string argument to the runtime. This passes a CHARACTER
+/// as a pointer to the buffer and a LEN parameter.
 template <typename A, typename B>
 mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter,
                             mlir::Location loc, mlir::Value cookie,
@@ -303,10 +293,10 @@ mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter,
   return builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 
-// default case: do nothing
 template <typename A>
 mlir::Value genIOOption(Fortran::lower::AbstractConverter &converter,
                         mlir::Location loc, mlir::Value cookie, const A &spec) {
+  // default case: do nothing
   return {};
 }
 
@@ -472,6 +462,10 @@ mlir::Value genIOOption<Fortran::parser::IoControlSpec::Rec>(
   return genIntIOOption<mkIOKey(SetRec)>(converter, loc, cookie, spec);
 }
 
+//===----------------------------------------------------------------------===//
+// Gathering of I/O statement error specifiers (if any).
+//===----------------------------------------------------------------------===//
+
 namespace {
 struct ErrorHandling {
   bool hasErrorHandlers() { return ioStat || err || end || eor || ioMsg; }
@@ -518,6 +512,7 @@ static bool hasX(const A &list) {
       return true;
   return false;
 }
+
 template <typename SEEK, typename A>
 static bool hasMem(const A &stmt) {
   return hasX<SEEK>(stmt.v);
@@ -599,8 +594,8 @@ static bool isDataTransferFormatted(const A &stmt) {
   return stmt.format || hasIOControl<Fortran::parser::Format>(stmt);
 }
 template <>
-constexpr bool isDataTransferFormatted<const Fortran::parser::PrintStmt &>(
-    const Fortran::parser::PrintStmt &stmt) {
+constexpr bool isDataTransferFormatted<Fortran::parser::PrintStmt>(
+    const Fortran::parser::PrintStmt &) {
   // PRINT is always formatted
   return true;
 }
@@ -614,7 +609,7 @@ static bool isDataTransferList(const A &stmt) {
   return false;
 }
 template <>
-bool isDataTransferList<const Fortran::parser::PrintStmt &>(
+bool isDataTransferList<Fortran::parser::PrintStmt>(
     const Fortran::parser::PrintStmt &stmt) {
   return std::holds_alternative<Fortran::parser::Star>(
       std::get<Fortran::parser::Format>(stmt.t).u);
@@ -628,6 +623,11 @@ static bool isDataTransferInternal(const A &stmt) {
     return std::holds_alternative<Fortran::parser::Variable>(unit->u);
   return false;
 }
+template <>
+constexpr bool isDataTransferInternal<Fortran::parser::PrintStmt>(
+    const Fortran::parser::PrintStmt &) {
+  return false;
+}
 
 template <typename A>
 static bool isDataTransferInternalNotDefaultKind(const A &stmt) {
@@ -635,6 +635,11 @@ static bool isDataTransferInternalNotDefaultKind(const A &stmt) {
   // not the default KIND.
   return false;
 }
+template <>
+constexpr bool isDataTransferInternalNotDefaultKind<Fortran::parser::PrintStmt>(
+    const Fortran::parser::PrintStmt &) {
+  return false;
+}
 
 template <typename A>
 static bool isDataTransferAsynchronous(const A &stmt) {
@@ -645,12 +650,22 @@ static bool isDataTransferAsynchronous(const A &stmt) {
   }
   return false;
 }
+template <>
+constexpr bool isDataTransferAsynchronous<Fortran::parser::PrintStmt>(
+    const Fortran::parser::PrintStmt &) {
+  return false;
+}
 
 template <typename A>
 static bool isDataTransferNamelist(const A &stmt) {
   // FIXME - is this a namelist?
   return false;
 }
+template <>
+constexpr bool isDataTransferNamelist<Fortran::parser::PrintStmt>(
+    const Fortran::parser::PrintStmt &) {
+  return false;
+}
 
 template <typename A>
 mlir::Value getFormat(Fortran::lower::AbstractConverter &converter,
@@ -888,78 +903,82 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
                        bool isList, bool isIntern, bool isOtherIntern,
                        bool isAsynch, bool isNml) {
   if constexpr (hasIOCtrl) {
+    // READ/WRITE cases have a wide variety of argument permutations
     if (isAsynch || !isFormatted) {
-      // unit
+      // unit (always first), ...
       ioArgs.push_back(
           getIOUnit(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
       if (isAsynch) {
-        // ?, [buff, LEN]
+        // unknown-thingy, [buff, LEN]
         llvm_unreachable("not implemented");
       }
+      return;
     }
-    assert(isFormatted);
+    assert(isFormatted && "formatted data transfer");
     if (!isIntern) {
       if (isNml) {
-        // namelist group
+        // namelist group, ...
         llvm_unreachable("not implemented");
       } else if (!isList) {
-        // [format, LEN]
+        // | [format, LEN], ...
         ioArgs.push_back(
             getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
         ioArgs.push_back(getFormatLen(converter, loc, stmt,
                                       ioFuncTy.getInput(ioArgs.size())));
       }
-      // unit
+      // unit (always last)
       ioArgs.push_back(
           getIOUnit(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
-    } else {
-      if (isNml || isOtherIntern) {
-        // descriptor
-        ioArgs.push_back(getDescriptor(converter, loc, stmt,
-                                       ioFuncTy.getInput(ioArgs.size())));
-        if (isNml) {
-          // namelist group
-          llvm_unreachable("not implemented");
-        }
-        if (isOtherIntern && !isList) {
-          // [format, LEN]
-          ioArgs.push_back(getFormat(converter, loc, stmt,
+      return;
+    }
+    assert(isIntern && "internal data transfer");
+    if (isNml || isOtherIntern) {
+      // descriptor, ...
+      ioArgs.push_back(getDescriptor(converter, loc, stmt,
                                      ioFuncTy.getInput(ioArgs.size())));
-          ioArgs.push_back(getFormatLen(converter, loc, stmt,
-                                        ioFuncTy.getInput(ioArgs.size())));
-        }
-      } else {
-        // [buff, LEN]
+      if (isNml) {
+        // namelist group, ...
+        llvm_unreachable("not implemented");
+      } else if (isOtherIntern && !isList) {
+        // | [format, LEN], ...
         ioArgs.push_back(
-            getBuffer(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
-        ioArgs.push_back(getBufferLen(converter, loc, stmt,
+            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+        ioArgs.push_back(getFormatLen(converter, loc, stmt,
                                       ioFuncTy.getInput(ioArgs.size())));
-        if (!isList) {
-          // [format, LEN]
-          ioArgs.push_back(getFormat(converter, loc, stmt,
-                                     ioFuncTy.getInput(ioArgs.size())));
-          ioArgs.push_back(getFormatLen(converter, loc, stmt,
-                                        ioFuncTy.getInput(ioArgs.size())));
-        }
       }
-      // [scratch, LEN]
-      auto &builder = converter.getFirOpBuilder();
+    } else {
+      // | [buff, LEN], ...
       ioArgs.push_back(
-          getDefaultScratch(builder, loc, ioFuncTy.getInput(ioArgs.size())));
+          getBuffer(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
       ioArgs.push_back(
-          getDefaultScratchLen(builder, loc, ioFuncTy.getInput(ioArgs.size())));
+          getBufferLen(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+      if (!isList) {
+        // [format, LEN], ...
+        ioArgs.push_back(
+            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+        ioArgs.push_back(getFormatLen(converter, loc, stmt,
+                                      ioFuncTy.getInput(ioArgs.size())));
+      }
     }
+    // [scratch, LEN] (always last)
+    auto &builder = converter.getFirOpBuilder();
+    ioArgs.push_back(
+        getDefaultScratch(builder, loc, ioFuncTy.getInput(ioArgs.size())));
+    ioArgs.push_back(
+        getDefaultScratchLen(builder, loc, ioFuncTy.getInput(ioArgs.size())));
   } else {
     if (!isList) {
-      // [format, LEN]
+      // [format, LEN], ...
       ioArgs.push_back(
           getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
       ioArgs.push_back(
           getFormatLen(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
     }
-    // unit
-    ioArgs.push_back(
-        getIOUnit(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+    // unit (always last)
+    auto &builder = converter.getFirOpBuilder();
+    ioArgs.push_back(builder.create<mlir::ConstantOp>(
+        loc, builder.getIntegerAttr(ioFuncTy.getInput(ioArgs.size()),
+                                    Fortran::runtime::io::DefaultUnit)));
   }
 }
 
@@ -972,18 +991,18 @@ const std::list<Fortran::parser::OutputItem> &getOutputItems(const A &stmt) {
   }
 };
 
-template <bool isInput, bool hasIOCtrl, typename A>
+template <bool isInput, bool hasIOCtrl = true, typename A>
 static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
                                    const A &stmt) {
   auto &builder = converter.getFirOpBuilder();
   auto loc = converter.getCurrentLocation();
   const bool isFormatted = isDataTransferFormatted(stmt);
   const bool isList = isFormatted ? isDataTransferList(stmt) : false;
-  const bool isIntern = hasIOCtrl ? isDataTransferInternal(stmt) : false;
+  const bool isIntern = isDataTransferInternal(stmt);
   const bool isOtherIntern =
       isIntern ? isDataTransferInternalNotDefaultKind(stmt) : false;
-  const bool isAsynch = hasIOCtrl ? isDataTransferAsynchronous(stmt) : false;
-  const bool isNml = hasIOCtrl ? isDataTransferNamelist(stmt) : false;
+  const bool isAsynch = isDataTransferAsynchronous(stmt);
+  const bool isNml = isDataTransferNamelist(stmt);
 
   // Determine the correct IO API call to make.
   mlir::FuncOp ioFunc = getBeginDataTransfer<isInput>(
@@ -1047,63 +1066,24 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
   return genEndIO(builder, loc, cookie);
 }
 
-// PRINT does not take an io-control-spec. It only has a format specifier, so
-// it is a simplified case of WRITE.
 void Fortran::lower::genPrintStatement(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::parser::PrintStmt &stmt) {
-  llvm::SmallVector<mlir::Value, 4> args;
-  for (auto &item : std::get<std::list<Fortran::parser::OutputItem>>(stmt.t)) {
-    if (auto *pe = std::get_if<Fortran::parser::Expr>(&item.u)) {
-      auto loc = converter.genLocation(pe->source);
-      args.push_back(
-          converter.genExprValue(Fortran::semantics::GetExpr(*pe), loc));
-    } else {
-      TODO(); // TODO implied do
-    }
-  }
-  auto loc = converter.getCurrentLocation();
-  auto &builder = converter.getFirOpBuilder();
-  const auto &format = std::get<Fortran::parser::Format>(stmt.t);
-  auto formatItems = lowerFormat(converter, format);
-  mlir::FuncOp beginFunc;
-  if (formatItems.has_value()) {
-    // has a format
-    TODO();
-  } else {
-    beginFunc = getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(builder);
-  }
-  mlir::FunctionType beginFuncTy = beginFunc.getType();
-
-  // Initiate io
-  mlir::Value defaultUnit = builder.create<mlir::ConstantOp>(
-      loc, builder.getIntegerAttr(beginFuncTy.getInput(0),
-                                  Fortran::runtime::io::DefaultUnit));
-  auto srcFileName = getDefaultFilename(builder, loc, beginFuncTy.getInput(1));
-  auto lineNo = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
-  llvm::SmallVector<mlir::Value, 4> beginArgs{defaultUnit, srcFileName, lineNo};
-  mlir::Value cookie =
-      builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
-
-  // Call data transfer runtime function
-  for (mlir::Value arg : args) {
-    // need some special handling for COMPLEX and CHARACTER
-    auto operands = splitArguments(builder, loc, arg);
-    genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
-  }
-  genEndIO(builder, loc, cookie);
+  // PRINT does not take an io-control-spec. It only has a format specifier, so
+  // it is a simplified case of WRITE.
+  genDataTransfer</*isInput=*/false, /*ioCtrl=*/false>(converter, stmt);
 }
 
 mlir::Value
 Fortran::lower::genWriteStatement(Fortran::lower::AbstractConverter &converter,
                                   const Fortran::parser::WriteStmt &stmt) {
-  return genDataTransfer</*isInput=*/false, /*ioCtrl=*/true>(converter, stmt);
+  return genDataTransfer</*isInput=*/false>(converter, stmt);
 }
 
 mlir::Value
 Fortran::lower::genReadStatement(Fortran::lower::AbstractConverter &converter,
                                  const Fortran::parser::ReadStmt &stmt) {
-  return genDataTransfer</*isInput=*/true, /*ioCtrl=*/true>(converter, stmt);
+  return genDataTransfer</*isInput=*/true>(converter, stmt);
 }
 
 mlir::Value Fortran::lower::genInquireStatement(

From 179b26dbccb672c51af8dcf8543941cf80010b4c Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 31 Mar 2020 14:14:26 -0700
Subject: [PATCH 294/345] more IO work

---
 lib/Lower/IO.cpp    | 157 +++++++++++++++++++++++++++++---------------
 test/Lower/open.f90 |  10 +++
 2 files changed, 113 insertions(+), 54 deletions(-)
 create mode 100644 test/Lower/open.f90

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 480f5ff10edd..8ffc20e99c07 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -589,20 +589,29 @@ static const auto *getIOControl(const A &stmt) {
   return static_cast<const SEEK *>(nullptr);
 }
 
+template <typename A>
+static bool formatIsActuallyNamelist(const A &format) {
+  if (auto *e = std::get_if<Fortran::parser::DefaultCharExpr>(&format.u)) {
+    // TODO
+  }
+  return false;
+}
+
 template <typename A>
 static bool isDataTransferFormatted(const A &stmt) {
-  return stmt.format || hasIOControl<Fortran::parser::Format>(stmt);
+  if (stmt.format)
+    return !formatIsActuallyNamelist(*stmt.format);
+  return hasIOControl<Fortran::parser::Format>(stmt);
 }
 template <>
 constexpr bool isDataTransferFormatted<Fortran::parser::PrintStmt>(
     const Fortran::parser::PrintStmt &) {
-  // PRINT is always formatted
-  return true;
+  return true; // PRINT is always formatted
 }
 
 template <typename A>
 static bool isDataTransferList(const A &stmt) {
-  if (stmt.format.has_value())
+  if (stmt.format)
     return std::holds_alternative<Fortran::parser::Star>(stmt.format->u);
   if (auto *mem = getIOControl<Fortran::parser::Format>(stmt))
     return std::holds_alternative<Fortran::parser::Star>(mem->u);
@@ -629,10 +638,21 @@ constexpr bool isDataTransferInternal<Fortran::parser::PrintStmt>(
   return false;
 }
 
+static bool hasNonDefaultCharKind(const Fortran::parser::Variable &var) {
+  // TODO
+  return false;
+}
+
 template <typename A>
 static bool isDataTransferInternalNotDefaultKind(const A &stmt) {
-  // FIXME - same as isDataTransferInternal, but the KIND of the expression is
-  // not the default KIND.
+  // same as isDataTransferInternal, but the KIND of the expression is not the
+  // default KIND.
+  if (stmt.iounit.has_value())
+    if (auto *var = std::get_if<Fortran::parser::Variable>(&stmt.iounit->u))
+      return hasNonDefaultCharKind(*var);
+  if (auto *unit = getIOControl<Fortran::parser::IoUnit>(stmt))
+    if (auto *var = std::get_if<Fortran::parser::Variable>(&unit->u))
+      return hasNonDefaultCharKind(*var);
   return false;
 }
 template <>
@@ -658,8 +678,9 @@ constexpr bool isDataTransferAsynchronous<Fortran::parser::PrintStmt>(
 
 template <typename A>
 static bool isDataTransferNamelist(const A &stmt) {
-  // FIXME - is this a namelist?
-  return false;
+  if (stmt.format)
+    return formatIsActuallyNamelist(*stmt.format);
+  return hasIOControl<Fortran::parser::Name>(stmt);
 }
 template <>
 constexpr bool isDataTransferNamelist<Fortran::parser::PrintStmt>(
@@ -667,47 +688,71 @@ constexpr bool isDataTransferNamelist<Fortran::parser::PrintStmt>(
   return false;
 }
 
-template <typename A>
-mlir::Value getFormat(Fortran::lower::AbstractConverter &converter,
-                      mlir::Location loc, const A &stmt, mlir::Type toType) {
-  const Fortran::lower::SomeExpr *expr = {};
-  return converter.genExprValue(expr, loc);
+static std::tuple<mlir::Value, mlir::Value, mlir::Value>
+genFormat(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+          const Fortran::parser::Format &format, mlir::Type ty0,
+          mlir::Type ty1) {
+  if (auto *e = std::get_if<Fortran::parser::DefaultCharExpr>(&format.u))
+    return lowerStringLit(converter, loc, *e, ty0, ty1);
+  TODO(); // handle Label case
 }
 
 template <typename A>
-mlir::Value getFormatLen(Fortran::lower::AbstractConverter &converter,
-                         mlir::Location loc, const A &stmt, mlir::Type toType) {
-  const Fortran::lower::SomeExpr *expr = {};
-  return converter.genExprValue(expr, loc);
+std::tuple<mlir::Value, mlir::Value, mlir::Value>
+getFormat(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+          const A &stmt, mlir::Type ty0, mlir::Type ty1) {
+  if (stmt.format && !formatIsActuallyNamelist(*stmt.format))
+    return genFormat(converter, loc, *stmt.format, ty0, ty1);
+  return genFormat(converter, loc, *getIOControl<Fortran::parser::Format>(stmt),
+                   ty0, ty1);
 }
-
-template <typename A>
-mlir::Value getBuffer(Fortran::lower::AbstractConverter &converter,
-                      mlir::Location loc, const A &stmt, mlir::Type toType) {
-  const Fortran::lower::SomeExpr *expr = {};
-  return converter.genExprValue(expr, loc);
+template <>
+std::tuple<mlir::Value, mlir::Value, mlir::Value>
+getFormat<Fortran::parser::PrintStmt>(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    const Fortran::parser::PrintStmt &stmt, mlir::Type ty0, mlir::Type ty1) {
+  return genFormat(converter, loc, std::get<Fortran::parser::Format>(stmt.t),
+                   ty0, ty1);
 }
 
+static std::tuple<mlir::Value, mlir::Value, mlir::Value>
+genBuffer(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+          const Fortran::parser::IoUnit &iounit, mlir::Type ty0,
+          mlir::Type ty1) {
+  auto &var = std::get<Fortran::parser::Variable>(iounit.u);
+  TODO();
+}
 template <typename A>
-mlir::Value getBufferLen(Fortran::lower::AbstractConverter &converter,
-                         mlir::Location loc, const A &stmt, mlir::Type toType) {
-  const Fortran::lower::SomeExpr *expr = {};
-  return converter.genExprValue(expr, loc);
+std::tuple<mlir::Value, mlir::Value, mlir::Value>
+getBuffer(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+          const A &stmt, mlir::Type ty0, mlir::Type ty1) {
+  if (stmt.iounit)
+    return genBuffer(converter, loc, *stmt.iounit, ty0, ty1);
+  return genBuffer(converter, loc, *getIOControl<Fortran::parser::IoUnit>(stmt),
+                   ty0, ty1);
 }
 
 template <typename A>
 mlir::Value getDescriptor(Fortran::lower::AbstractConverter &converter,
                           mlir::Location loc, const A &stmt,
                           mlir::Type toType) {
-  const Fortran::lower::SomeExpr *expr = {};
-  return converter.genExprValue(expr, loc);
+  TODO();
+}
+
+static mlir::Value genIOUnit(Fortran::lower::AbstractConverter &converter,
+                             mlir::Location loc,
+                             const Fortran::parser::IoUnit &iounit,
+                             mlir::Type toType) {
+  TODO();
 }
 
 template <typename A>
 mlir::Value getIOUnit(Fortran::lower::AbstractConverter &converter,
-                      mlir::Location loc, const A &stmt, mlir::Type toType) {
-  const Fortran::lower::SomeExpr *expr = {};
-  return converter.genExprValue(expr, loc);
+                      mlir::Location loc, const A &stmt, mlir::Type ty) {
+  if (stmt.iounit)
+    return genIOUnit(converter, loc, *stmt.iounit, ty);
+  return genIOUnit(converter, loc, *getIOControl<Fortran::parser::IoUnit>(stmt),
+                   ty);
 }
 
 //===----------------------------------------------------------------------===//
@@ -902,6 +947,7 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
                        mlir::FunctionType ioFuncTy, bool isFormatted,
                        bool isList, bool isIntern, bool isOtherIntern,
                        bool isAsynch, bool isNml) {
+  auto &builder = converter.getFirOpBuilder();
   if constexpr (hasIOCtrl) {
     // READ/WRITE cases have a wide variety of argument permutations
     if (isAsynch || !isFormatted) {
@@ -921,10 +967,11 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
         llvm_unreachable("not implemented");
       } else if (!isList) {
         // | [format, LEN], ...
-        ioArgs.push_back(
-            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
-        ioArgs.push_back(getFormatLen(converter, loc, stmt,
-                                      ioFuncTy.getInput(ioArgs.size())));
+        auto pair =
+            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
+                      ioFuncTy.getInput(ioArgs.size() + 1));
+        ioArgs.push_back(std::get<0>(pair));
+        ioArgs.push_back(std::get<1>(pair));
       }
       // unit (always last)
       ioArgs.push_back(
@@ -941,27 +988,29 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
         llvm_unreachable("not implemented");
       } else if (isOtherIntern && !isList) {
         // | [format, LEN], ...
-        ioArgs.push_back(
-            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
-        ioArgs.push_back(getFormatLen(converter, loc, stmt,
-                                      ioFuncTy.getInput(ioArgs.size())));
+        auto pair =
+            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
+                      ioFuncTy.getInput(ioArgs.size() + 1));
+        ioArgs.push_back(std::get<0>(pair));
+        ioArgs.push_back(std::get<1>(pair));
       }
     } else {
       // | [buff, LEN], ...
-      ioArgs.push_back(
-          getBuffer(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
-      ioArgs.push_back(
-          getBufferLen(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+      auto pair =
+          getBuffer(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
+                    ioFuncTy.getInput(ioArgs.size() + 1));
+      ioArgs.push_back(std::get<0>(pair));
+      ioArgs.push_back(std::get<1>(pair));
       if (!isList) {
         // [format, LEN], ...
-        ioArgs.push_back(
-            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
-        ioArgs.push_back(getFormatLen(converter, loc, stmt,
-                                      ioFuncTy.getInput(ioArgs.size())));
+        auto pair =
+            getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
+                      ioFuncTy.getInput(ioArgs.size() + 1));
+        ioArgs.push_back(std::get<0>(pair));
+        ioArgs.push_back(std::get<1>(pair));
       }
     }
     // [scratch, LEN] (always last)
-    auto &builder = converter.getFirOpBuilder();
     ioArgs.push_back(
         getDefaultScratch(builder, loc, ioFuncTy.getInput(ioArgs.size())));
     ioArgs.push_back(
@@ -969,13 +1018,13 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
   } else {
     if (!isList) {
       // [format, LEN], ...
-      ioArgs.push_back(
-          getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
-      ioArgs.push_back(
-          getFormatLen(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size())));
+      auto pair =
+          getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
+                    ioFuncTy.getInput(ioArgs.size() + 1));
+      ioArgs.push_back(std::get<0>(pair));
+      ioArgs.push_back(std::get<1>(pair));
     }
     // unit (always last)
-    auto &builder = converter.getFirOpBuilder();
     ioArgs.push_back(builder.create<mlir::ConstantOp>(
         loc, builder.getIntegerAttr(ioFuncTy.getInput(ioArgs.size()),
                                     Fortran::runtime::io::DefaultUnit)));
diff --git a/test/Lower/open.f90 b/test/Lower/open.f90
new file mode 100644
index 000000000000..edeab584d14f
--- /dev/null
+++ b/test/Lower/open.f90
@@ -0,0 +1,10 @@
+! RUN: bbc %s -o - | FileCheck %s
+
+! CHECK-LABEL: _QQmain
+! CHECK: call {{.*}}BeginOpenUnit
+! CHECK-DAG: call {{.*}}SetFile
+! CHECK-DAG: call {{.*}}SetAccess
+! CHECK: call {{.*}}EndIoStatement
+
+  open(8, file="foo", access="sequential")
+end

From 68eaa34ab7635be7b00e92d584731321392617f5 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 31 Mar 2020 15:17:48 -0700
Subject: [PATCH 295/345] extend test

---
 test/Lower/open.f90 | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/Lower/open.f90 b/test/Lower/open.f90
index edeab584d14f..367b9c14bc62 100644
--- a/test/Lower/open.f90
+++ b/test/Lower/open.f90
@@ -7,4 +7,20 @@
 ! CHECK: call {{.*}}EndIoStatement
 
   open(8, file="foo", access="sequential")
+
+! CHECK: call {{.*}}BeginBackspace
+! CHECK: call {{.*}}EndIoStatement
+  backspace(8)
+  
+! CHECK: call {{.*}}BeginFlush
+! CHECK: call {{.*}}EndIoStatement
+  flush(8)
+  
+! CHECK: call {{.*}}BeginRewind
+! CHECK: call {{.*}}EndIoStatement
+  rewind(8)
+
+! CHECK: call {{.*}}BeginClose
+! CHECK: call {{.*}}EndIoStatement
+  close(8)
 end

From e556691e269840b298021dabfec74249629ad36e Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 31 Mar 2020 15:26:47 -0700
Subject: [PATCH 296/345] Get input working a bit. Extend test for trivial
 coverage of all IO statements except for INQUIRE.

---
 include/flang/Lower/FIRBuilder.h          |  3 ++
 include/flang/Optimizer/Dialect/FIRType.h |  1 +
 lib/Lower/FIRBuilder.cpp                  |  4 ++
 lib/Lower/IO.cpp                          | 65 +++++++++++++++--------
 lib/Optimizer/Dialect/FIRType.cpp         |  4 ++
 test/Lower/open.f90                       | 26 +++++++++
 6 files changed, 82 insertions(+), 21 deletions(-)

diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index b7ed5d5c5131..7c5b3c0763ad 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -231,6 +231,9 @@ class FirOpBuilder : public mlir::OpBuilder,
   /// Get the entry block of the current Function
   mlir::Block *getEntryBlock() { return &getFunction().front(); }
 
+
+  mlir::Type getRefType(mlir::Type eleTy);
+  
   /// Create an integer constant of type \p type and value \p i.
   mlir::Value createIntegerConstant(mlir::Type integerType, std::int64_t i);
 
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index c064895b02f8..0533bc164d4d 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -127,6 +127,7 @@ class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
 public:
   using Base::Base;
   static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
+  mlir::Type getEleTy() const;
   KindTy getFKind() const;
 };
 
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index a857f08b59ea..d779b3c91fbe 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -36,6 +36,10 @@ Fortran::lower::FirOpBuilder::getNamedFunction(mlir::ModuleOp modOp,
   return modOp.lookupSymbol<mlir::FuncOp>(name);
 }
 
+mlir::Type Fortran::lower::FirOpBuilder::getRefType(mlir::Type eleTy) {
+  return fir::ReferenceType::get(eleTy);
+}
+
 mlir::Value
 Fortran::lower::FirOpBuilder::createIntegerConstant(mlir::Type intType,
                                                     std::int64_t cst) {
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 8ffc20e99c07..ae0ff45d05c0 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -167,10 +167,11 @@ static void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
 
 /// Get the InputXyz routine to input a value with type `type`.
 static mlir::FuncOp getInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
-                                        mlir::Type type) {
+                                        mlir::Type type, int &intKind) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>()) {
     if (ty.getWidth() == 1)
       return getIORuntimeFunc<mkIOKey(InputLogical)>(builder);
+    intKind = ty.getWidth() / 8;
     return getIORuntimeFunc<mkIOKey(InputInteger)>(builder);
   }
   if (auto ty = type.dyn_cast<mlir::FloatType>()) {
@@ -193,17 +194,37 @@ static mlir::FuncOp getInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
 /// Generate a call to an Output I/O function.
 /// The specific call is determined dynamically by the argument type.
 static void genInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
-                                mlir::Location loc, mlir::Type argType,
-                                mlir::Value cookie,
-                                llvm::SmallVector<mlir::Value, 4> &operands) {
-  int i = 1;
-  llvm::SmallVector<mlir::Value, 4> actuals{cookie};
-  auto inputFunc = getInputRuntimeFunc(builder, argType);
-
-  for (auto &op : operands)
-    actuals.emplace_back(builder.create<fir::ConvertOp>(
-        loc, inputFunc.getType().getInput(i++), op));
-  builder.create<mlir::CallOp>(loc, inputFunc, actuals);
+                                mlir::Location loc, mlir::Type refType,
+                                mlir::Value cookie, mlir::Value &var) {
+  auto argType = refType.cast<fir::ReferenceType>().getEleTy();
+  int intKind = 0;
+  auto inputFunc = getInputRuntimeFunc(builder, argType, intKind);
+  if (auto ty = argType.dyn_cast<fir::CplxType>()) {
+    var = builder.create<fir::CoordinateOp>(
+        loc, builder.getRefType(ty.getEleTy()), var,
+        llvm::SmallVector<mlir::Value, 1>{builder.create<mlir::ConstantOp>(
+            loc, builder.getI32IntegerAttr(0))});
+  }
+  auto cvtTy = inputFunc.getType().getInput(1);
+  auto cvt = builder.create<fir::ConvertOp>(loc, cvtTy, var);
+  if (intKind != 0) {
+    auto kind = builder.create<mlir::ConstantOp>(
+        loc, builder.getI32IntegerAttr(intKind));
+    builder.create<mlir::CallOp>(
+        loc, inputFunc, llvm::SmallVector<mlir::Value, 3>{cookie, cvt, kind});
+  } else {
+    builder.create<mlir::CallOp>(
+        loc, inputFunc, llvm::SmallVector<mlir::Value, 2>{cookie, cvt});
+  }
+  if (auto ty = argType.dyn_cast<fir::CplxType>()) {
+    auto ptr = builder.create<fir::CoordinateOp>(
+        loc, builder.getRefType(ty.getEleTy()), var,
+        llvm::SmallVector<mlir::Value, 1>{builder.create<mlir::ConstantOp>(
+            loc, builder.getI32IntegerAttr(1))});
+    auto cst = builder.create<fir::ConvertOp>(loc, cvtTy, ptr);
+    builder.create<mlir::CallOp>(
+        loc, inputFunc, llvm::SmallVector<mlir::Value, 2>{cookie, cst});
+  }
 }
 
 //===----------------------------------------------------------------------===//
@@ -719,7 +740,7 @@ static std::tuple<mlir::Value, mlir::Value, mlir::Value>
 genBuffer(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
           const Fortran::parser::IoUnit &iounit, mlir::Type ty0,
           mlir::Type ty1) {
-  auto &var = std::get<Fortran::parser::Variable>(iounit.u);
+  [[maybe_unused]] auto &var = std::get<Fortran::parser::Variable>(iounit.u);
   TODO();
 }
 template <typename A>
@@ -742,8 +763,14 @@ mlir::Value getDescriptor(Fortran::lower::AbstractConverter &converter,
 static mlir::Value genIOUnit(Fortran::lower::AbstractConverter &converter,
                              mlir::Location loc,
                              const Fortran::parser::IoUnit &iounit,
-                             mlir::Type toType) {
-  TODO();
+                             mlir::Type ty) {
+  auto &builder = converter.getFirOpBuilder();
+  if (auto *e = std::get_if<Fortran::parser::FileUnitNumber>(&iounit.u)) {
+    auto ex = converter.genExprValue(Fortran::semantics::GetExpr(*e), loc);
+    return builder.create<fir::ConvertOp>(loc, ty, ex);
+  }
+  return builder.create<mlir::ConstantOp>(
+      loc, builder.getIntegerAttr(ty, Fortran::runtime::io::DefaultUnit));
 }
 
 template <typename A>
@@ -1089,12 +1116,8 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
         TODO(); // TODO implied do
       }
     }
-    for (mlir::Value arg : args) {
-      // need some special handling for COMPLEX and CHARACTER
-      TODO();
-      auto operands = splitArguments(builder, loc, arg);
-      genInputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
-    }
+    for (mlir::Value arg : args)
+      genInputRuntimeFunc(builder, loc, arg.getType(), cookie, arg);
   } else {
     for (auto &item : getOutputItems(stmt)) {
       if (auto *pe = std::get_if<Fortran::parser::Expr>(&item.u)) {
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index cb44fe878e7d..ca4f0877c344 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -906,6 +906,10 @@ CplxType fir::CplxType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_COMPLEX, kind);
 }
 
+mlir::Type fir::CplxType::getEleTy() const {
+  return fir::RealType::get(getContext(), getFKind());
+}
+
 KindTy fir::CplxType::getFKind() const { return getImpl()->getFKind(); }
 
 // REAL
diff --git a/test/Lower/open.f90 b/test/Lower/open.f90
index 367b9c14bc62..cceacc958931 100644
--- a/test/Lower/open.f90
+++ b/test/Lower/open.f90
@@ -20,7 +20,33 @@
 ! CHECK: call {{.*}}EndIoStatement
   rewind(8)
 
+! CHECK: call {{.*}}BeginEndfile
+! CHECK: call {{.*}}EndIoStatement
+  endfile(8)
+
+! CHECK: call {{.*}}BeginWaitAll
+! CHECK: call {{.*}}EndIoStatement
+  wait(unit=8)
+  
+! CHECK: call {{.*}}BeginExternalListInput
+! CHECK: call {{.*}}InputInteger
+! CHECK: call {{.*}}InputReal32
+! CHECK: call {{.*}}EndIoStatement
+  read (8,*) i, f
+
+! CHECK: call {{.*}}BeginExternalListOutput
+! 32 bit integers are output as 64 bits in the runtime API  
+! CHECK: call {{.*}}OutputInteger64
+! CHECK: call {{.*}}OutputReal32
+! CHECK: call {{.*}}EndIoStatement
+  write (8,*) i, f
+
 ! CHECK: call {{.*}}BeginClose
 ! CHECK: call {{.*}}EndIoStatement
   close(8)
+
+! CHECK: call {{.*}}BeginExternalListOutput
+! CHECK: call {{.*}}OutputAscii
+! CHECK: call {{.*}}EndIoStatement
+  print *, "A literal string"
 end

From b32f704ef196316b5e6eb253208f25bfffdbad1b Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 1 Apr 2020 13:04:06 -0700
Subject: [PATCH 297/345] warning removal

---
 lib/Lower/IO.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index ae0ff45d05c0..46bae7d664dd 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -1065,7 +1065,7 @@ const std::list<Fortran::parser::OutputItem> &getOutputItems(const A &stmt) {
   } else {
     return stmt.items;
   }
-};
+}
 
 template <bool isInput, bool hasIOCtrl = true, typename A>
 static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,

From ea4d4a24d42c410be75367263608a9c2c1fcb5dc Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 1 Apr 2020 13:05:26 -0700
Subject: [PATCH 298/345] changes

---
 lib/Lower/IO.cpp | 127 +++++++++++++++++++++++++++++++----------------
 1 file changed, 83 insertions(+), 44 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 46bae7d664dd..904103630a4e 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -65,6 +65,17 @@ static constexpr std::tuple<
     newIOTable;
 } // namespace Fortran::lower
 
+namespace {
+struct ErrorHandling {
+  bool hasErrorHandlers() const { return ioStat || err || end || eor || ioMsg; }
+  bool ioStat{};
+  bool err{};
+  bool end{};
+  bool eor{};
+  bool ioMsg{};
+};
+} // namespace
+
 using namespace Fortran::lower;
 
 /// Helper function to retrieve the name of the IO function given the key `A`
@@ -100,12 +111,30 @@ static mlir::FuncOp getIORuntimeFunc(Fortran::lower::FirOpBuilder &builder) {
 
 /// Generate a call to end an IO statement
 static mlir::Value genEndIO(Fortran::lower::FirOpBuilder &builder,
-                            mlir::Location loc, mlir::Value cookie) {
+                            mlir::Location loc, mlir::Value cookie,
+                            const ErrorHandling &eh) {
   // Terminate IO
   auto endIOFunc = getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder);
   llvm::SmallVector<mlir::Value, 1> endArgs{cookie};
   auto call = builder.create<mlir::CallOp>(loc, endIOFunc, endArgs);
-  return call.getResult(0);
+  // FIXME: gen code for ioStat and ioMsg cases
+  return eh.hasErrorHandlers() ? call.getResult(0) : mlir::Value{};
+}
+
+/// Make the next `call` in the IO statement conditional on the result `ok`.  If
+/// the current call returns `ok==false`, we do not continue to call the IO
+/// statement's suboperations. This will lend itself to deeply nested
+/// conditionals (and very branch heavy code) for statements with a large number
+/// of suboperations.
+static void makeNextConditionalOn(Fortran::lower::FirOpBuilder &builder,
+                                  mlir::Location loc, mlir::Value ok,
+                                  mlir::OpBuilder::InsertPoint &insertPt) {
+  if (!ok)
+    return;
+  auto where = builder.create<fir::WhereOp>(loc, ok, /*withOtherwise=*/false);
+  if (!insertPt.isSet())
+    insertPt = builder.saveInsertionPoint();
+  builder.setInsertionPointToStart(&where.whereRegion().front());
 }
 
 /// Get the OutputXyz routine to output a value with type `type`.
@@ -154,7 +183,8 @@ splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
 static void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
                                  mlir::Location loc, mlir::Type argType,
                                  mlir::Value cookie,
-                                 llvm::SmallVector<mlir::Value, 4> &operands) {
+                                 llvm::SmallVector<mlir::Value, 4> &operands,
+                                 mlir::OpBuilder::InsertPoint &insertPt) {
   int i = 1;
   llvm::SmallVector<mlir::Value, 4> actuals{cookie};
   auto outputFunc = getOutputRuntimeFunc(builder, argType);
@@ -162,7 +192,8 @@ static void genOutputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
   for (auto &op : operands)
     actuals.emplace_back(builder.create<fir::ConvertOp>(
         loc, outputFunc.getType().getInput(i++), op));
-  builder.create<mlir::CallOp>(loc, outputFunc, actuals);
+  auto ok = builder.create<mlir::CallOp>(loc, outputFunc, actuals);
+  makeNextConditionalOn(builder, loc, ok.getResult(0), insertPt);
 }
 
 /// Get the InputXyz routine to input a value with type `type`.
@@ -195,7 +226,8 @@ static mlir::FuncOp getInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
 /// The specific call is determined dynamically by the argument type.
 static void genInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
                                 mlir::Location loc, mlir::Type refType,
-                                mlir::Value cookie, mlir::Value &var) {
+                                mlir::Value cookie, mlir::Value &var,
+                                mlir::OpBuilder::InsertPoint &insertPt) {
   auto argType = refType.cast<fir::ReferenceType>().getEleTy();
   int intKind = 0;
   auto inputFunc = getInputRuntimeFunc(builder, argType, intKind);
@@ -210,11 +242,13 @@ static void genInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
   if (intKind != 0) {
     auto kind = builder.create<mlir::ConstantOp>(
         loc, builder.getI32IntegerAttr(intKind));
-    builder.create<mlir::CallOp>(
+    auto ok = builder.create<mlir::CallOp>(
         loc, inputFunc, llvm::SmallVector<mlir::Value, 3>{cookie, cvt, kind});
+    makeNextConditionalOn(builder, loc, ok.getResult(0), insertPt);
   } else {
-    builder.create<mlir::CallOp>(
+    auto ok = builder.create<mlir::CallOp>(
         loc, inputFunc, llvm::SmallVector<mlir::Value, 2>{cookie, cvt});
+    makeNextConditionalOn(builder, loc, ok.getResult(0), insertPt);
   }
   if (auto ty = argType.dyn_cast<fir::CplxType>()) {
     auto ptr = builder.create<fir::CoordinateOp>(
@@ -222,8 +256,9 @@ static void genInputRuntimeFunc(Fortran::lower::FirOpBuilder &builder,
         llvm::SmallVector<mlir::Value, 1>{builder.create<mlir::ConstantOp>(
             loc, builder.getI32IntegerAttr(1))});
     auto cst = builder.create<fir::ConvertOp>(loc, cvtTy, ptr);
-    builder.create<mlir::CallOp>(
+    auto ok = builder.create<mlir::CallOp>(
         loc, inputFunc, llvm::SmallVector<mlir::Value, 2>{cookie, cst});
+    makeNextConditionalOn(builder, loc, ok.getResult(0), insertPt);
   }
 }
 
@@ -487,17 +522,6 @@ mlir::Value genIOOption<Fortran::parser::IoControlSpec::Rec>(
 // Gathering of I/O statement error specifiers (if any).
 //===----------------------------------------------------------------------===//
 
-namespace {
-struct ErrorHandling {
-  bool hasErrorHandlers() { return ioStat || err || end || eor || ioMsg; }
-  bool ioStat{};
-  bool err{};
-  bool end{};
-  bool eor{};
-  bool ioMsg{};
-};
-} // namespace
-
 template <typename A>
 void genErrorOption(ErrorHandling &handle, const A &) {}
 template <>
@@ -549,25 +573,28 @@ static const Fortran::semantics::SomeExpr *getExpr(const A &stmt) {
 }
 
 /// For each specifier, build the appropriate call, threading the cookie, and
-/// return the final ssa-value of the cookie.
+/// returning the insertion point as to the initial context. If there are no
+/// specs, the insertion point is undefined.
 template <typename A>
-static void threadSpecs(Fortran::lower::AbstractConverter &converter,
-                        mlir::Location loc, mlir::Value cookie, const A &list) {
+static mlir::OpBuilder::InsertPoint
+threadSpecs(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+            mlir::Value cookie, const A &list) {
+  auto &builder = converter.getFirOpBuilder();
+  mlir::OpBuilder::InsertPoint insertPt;
   for (const auto &spec : list) {
-    [[maybe_unused]] auto ok =
-        std::visit(Fortran::common::visitors{[&](const auto &x) {
-                     return genIOOption(converter, loc, cookie, x);
-                   }},
-                   spec.u);
-    // TODO: if error handling, add check of `ok`
+    auto ok = std::visit(Fortran::common::visitors{[&](const auto &x) {
+                           return genIOOption(converter, loc, cookie, x);
+                         }},
+                         spec.u);
+    makeNextConditionalOn(builder, loc, ok, insertPt);
   }
+  return insertPt;
 }
 
 template <typename A>
 static void threadErrors(Fortran::lower::AbstractConverter &converter,
-                         mlir::Location loc, mlir::Value cookie,
-                         const A &list) {
-  ErrorHandling eh{};
+                         mlir::Location loc, mlir::Value cookie, const A &list,
+                         ErrorHandling &eh) {
   for (const auto &spec : list)
     std::visit(Fortran::common::visitors{[&](const auto &x) {
                  genErrorOption(eh, x);
@@ -800,9 +827,12 @@ static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
   auto line = getDefaultLineNo(builder, loc, beginFuncTy.getInput(2));
   llvm::SmallVector<mlir::Value, 4> args{un, file, line};
   auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
-  threadErrors(converter, loc, cookie, stmt.v);
-  threadSpecs(converter, loc, cookie, stmt.v);
-  return genEndIO(builder, converter.getCurrentLocation(), cookie);
+  ErrorHandling eh{};
+  threadErrors(converter, loc, cookie, stmt.v, eh);
+  auto insertPt = threadSpecs(converter, loc, cookie, stmt.v);
+  if (insertPt.isSet())
+    builder.restoreInsertionPoint(insertPt);
+  return genEndIO(builder, converter.getCurrentLocation(), cookie, eh);
 }
 
 mlir::Value Fortran::lower::genBackspaceStatement(
@@ -858,9 +888,12 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
   }
   auto cookie =
       builder.create<mlir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
-  threadErrors(converter, loc, cookie, stmt.v);
-  threadSpecs(converter, loc, cookie, stmt.v);
-  return genEndIO(builder, loc, cookie);
+  ErrorHandling eh{};
+  threadErrors(converter, loc, cookie, stmt.v, eh);
+  auto insertPt = threadSpecs(converter, loc, cookie, stmt.v);
+  if (insertPt.isSet())
+    builder.restoreInsertionPoint(insertPt);
+  return genEndIO(builder, loc, cookie, eh);
 }
 
 mlir::Value
@@ -890,8 +923,9 @@ Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
         builder.create<fir::ConvertOp>(loc, beginFuncTy.getInput(1), id));
   }
   auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
-  threadErrors(converter, loc, cookie, stmt.v);
-  return genEndIO(builder, converter.getCurrentLocation(), cookie);
+  ErrorHandling eh{};
+  threadErrors(converter, loc, cookie, stmt.v, eh);
+  return genEndIO(builder, converter.getCurrentLocation(), cookie, eh);
 }
 
 //===----------------------------------------------------------------------===//
@@ -1100,9 +1134,11 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
   mlir::Value cookie =
       builder.create<mlir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 
+  ErrorHandling eh{};
+  mlir::OpBuilder::InsertPoint insertPt;
   if constexpr (hasIOCtrl) {
-    threadErrors(converter, loc, cookie, stmt.controls);
-    threadSpecs(converter, loc, cookie, stmt.controls);
+    threadErrors(converter, loc, cookie, stmt.controls, eh);
+    insertPt = threadSpecs(converter, loc, cookie, stmt.controls);
   }
   // process the arguments
   llvm::SmallVector<mlir::Value, 32> args;
@@ -1117,7 +1153,7 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
       }
     }
     for (mlir::Value arg : args)
-      genInputRuntimeFunc(builder, loc, arg.getType(), cookie, arg);
+      genInputRuntimeFunc(builder, loc, arg.getType(), cookie, arg, insertPt);
   } else {
     for (auto &item : getOutputItems(stmt)) {
       if (auto *pe = std::get_if<Fortran::parser::Expr>(&item.u)) {
@@ -1131,11 +1167,14 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
     for (mlir::Value arg : args) {
       // need some special handling for COMPLEX and CHARACTER
       auto operands = splitArguments(builder, loc, arg);
-      genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands);
+      genOutputRuntimeFunc(builder, loc, arg.getType(), cookie, operands,
+                           insertPt);
     }
   }
 
-  return genEndIO(builder, loc, cookie);
+  if (insertPt.isSet())
+    builder.restoreInsertionPoint(insertPt);
+  return genEndIO(builder, loc, cookie, eh);
 }
 
 void Fortran::lower::genPrintStatement(

From b524b57361a1917ef94a6261d175ad1023713926 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 1 Apr 2020 13:30:17 -0700
Subject: [PATCH 299/345] add GlobalOp create method to FirOpBuilder

---
 lib/Lower/FIRBuilder.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index d779b3c91fbe..210553f8acec 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -74,6 +74,17 @@ mlir::Value Fortran::lower::FirOpBuilder::createTemporary(
   return ae;
 }
 
+fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(mlir::Location loc, mlir::Type type, llvm::StringRef name, mlir::Attribute value, mlir::StringAttr linkage, bool isConst) {
+  auto module = getInsertionBlock()->getParentOp()->getParentOfType<mlir::ModuleOp>();
+  auto insertPt = saveInsertionPoint();
+  if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
+    return glob;
+  setInsertionPoint(module.getBody()->getTerminator());
+  auto glob = create<fir::GlobalOp>(loc, name, isConst, type, value, linkage);
+  restoreInsertionPoint(insertPt);
+  return glob;
+}
+
 //===----------------------------------------------------------------------===//
 // LoopOp builder
 //===----------------------------------------------------------------------===//

From ddfdccfb155c070f6e9604d11d4946762ec1865d Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 1 Apr 2020 13:55:37 -0700
Subject: [PATCH 300/345] clang-format

---
 lib/Lower/FIRBuilder.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index 210553f8acec..8de532120ed8 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -74,8 +74,11 @@ mlir::Value Fortran::lower::FirOpBuilder::createTemporary(
   return ae;
 }
 
-fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(mlir::Location loc, mlir::Type type, llvm::StringRef name, mlir::Attribute value, mlir::StringAttr linkage, bool isConst) {
-  auto module = getInsertionBlock()->getParentOp()->getParentOfType<mlir::ModuleOp>();
+fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
+    mlir::Location loc, mlir::Type type, llvm::StringRef name,
+    mlir::Attribute value, mlir::StringAttr linkage, bool isConst) {
+  auto module =
+      getInsertionBlock()->getParentOp()->getParentOfType<mlir::ModuleOp>();
   auto insertPt = saveInsertionPoint();
   if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
     return glob;

From 77ae98ae1f087feb7b208f7665d810a25bd76cb8 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 1 Apr 2020 14:48:45 -0700
Subject: [PATCH 301/345] use getModule

---
 lib/Lower/FIRBuilder.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index 8de532120ed8..4e1c69b68397 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -77,8 +77,7 @@ mlir::Value Fortran::lower::FirOpBuilder::createTemporary(
 fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
     mlir::Location loc, mlir::Type type, llvm::StringRef name,
     mlir::Attribute value, mlir::StringAttr linkage, bool isConst) {
-  auto module =
-      getInsertionBlock()->getParentOp()->getParentOfType<mlir::ModuleOp>();
+  auto module = getModule();
   auto insertPt = saveInsertionPoint();
   if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
     return glob;

From f836f7f94fd66f8cb887f662a04634585a630281 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 1 Apr 2020 15:21:49 -0700
Subject: [PATCH 302/345] add WhereOp folder

---
 include/flang/Optimizer/Dialect/FIROps.td |  2 ++
 lib/Optimizer/Dialect/FIROps.cpp          | 13 +++++++++++++
 2 files changed, 15 insertions(+)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 2ae89eacb47f..4c67b8a028ea 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2062,6 +2062,8 @@ def fir_WhereOp :
       return mlir::OpBuilder(&body, std::prev(body.end()));
     }
   }];
+
+  let hasFolder = 1;
 }
 
 // Procedure call operations
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 15ac3943750e..c7d8e4454b1a 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -1042,6 +1042,19 @@ static mlir::ParseResult parseWhereOp(OpAsmParser &parser,
   return mlir::success();
 }
 
+mlir::LogicalResult fir::WhereOp::fold(llvm::ArrayRef<mlir::Attribute> opnds,
+ 		           llvm::SmallVectorImpl<mlir::OpFoldResult> &results) {
+  // If the WhereOp has no body, then just delete it
+  if ((whereRegion().empty() || whereRegion().front().empty() ||
+       isa<fir::FirEndOp>(whereRegion().front().front())) &&
+      (otherRegion().empty() || otherRegion().front().empty() ||
+       isa<fir::FirEndOp>(otherRegion().front().front()))) {
+    results.clear();
+    return mlir::success();
+  }
+  return mlir::failure();
+}
+
 //===----------------------------------------------------------------------===//
 
 mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {

From 076bb7819d594bfd7ecf7faa65c19d17282e2d0f Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 1 Apr 2020 13:55:37 -0700
Subject: [PATCH 303/345] use getModule add WhereOp folder

---
 lib/Optimizer/Dialect/FIROps.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index c7d8e4454b1a..2137c172694f 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -1042,8 +1042,9 @@ static mlir::ParseResult parseWhereOp(OpAsmParser &parser,
   return mlir::success();
 }
 
-mlir::LogicalResult fir::WhereOp::fold(llvm::ArrayRef<mlir::Attribute> opnds,
- 		           llvm::SmallVectorImpl<mlir::OpFoldResult> &results) {
+mlir::LogicalResult
+fir::WhereOp::fold(llvm::ArrayRef<mlir::Attribute> opnds,
+                   llvm::SmallVectorImpl<mlir::OpFoldResult> &results) {
   // If the WhereOp has no body, then just delete it
   if ((whereRegion().empty() || whereRegion().front().empty() ||
        isa<fir::FirEndOp>(whereRegion().front().front())) &&

From 7273a0b39b5d123bad9e24455b5530bbab988b16 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 1 Apr 2020 18:49:24 -0700
Subject: [PATCH 304/345] fix to lowering of sequence with constant interior
 shape

---
 include/flang/Optimizer/Dialect/FIRType.h |  9 +++++++++
 lib/Optimizer/CodeGen.cpp                 | 21 ++++++++++++++-------
 lib/Optimizer/Dialect/FIRType.cpp         | 17 +++++++++++++++++
 test/Fir/coordinate01.fir                 | 19 +++++++++++++++++++
 4 files changed, 59 insertions(+), 7 deletions(-)
 create mode 100644 test/Fir/coordinate01.fir

diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 0533bc164d4d..3f5cc6c4e865 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -330,6 +330,15 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
 
   /// Is the shape of the sequence constant?
   bool hasConstantShape() const { return getConstantRows() == getDimension(); }
+
+  /// Does the sequence have unknown shape? (`array<* x T>`)
+  bool hasUnknownShape() const { return getShape().empty(); }
+
+  /// Is the interior of the sequence constant? Check if the array is
+  /// one of constant shape (`array<C...xCxT>`), unknown shape
+  /// (`array<*xT>`), or rows with shape and ending with column(s) of
+  /// unknown extent (`array<C...xCx?...x?xT>`).
+  bool hasConstantInterior() const;
   
   /// The value `-1` represents an unknown extent for a dimension
   static constexpr Extent getUnknownExtent() { return -1; }
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 036dede61190..b34c77cba7d2 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -58,8 +58,8 @@ namespace fir {
 bool allConstants(OperandTy operands) {
   for (auto opnd : operands) {
     if (auto defop = opnd.getDefiningOp())
-      if (dyn_cast<mlir::LLVM::ConstantOp>(defop) ||
-          dyn_cast<mlir::ConstantOp>(defop))
+      if (isa<mlir::LLVM::ConstantOp>(defop) ||
+          isa<mlir::ConstantOp>(defop))
         continue;
     return false;
   }
@@ -235,7 +235,12 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
 
   template <typename A>
   mlir::LLVM::LLVMType convertPointerLike(A &ty) {
-    return unwrap(convertType(ty.getEleTy())).getPointerTo();
+    mlir::Type eleTy = ty.getEleTy();
+    if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
+      if (!seqTy.hasConstantShape() && seqTy.hasConstantInterior())
+	return unwrap(convertType(seqTy));
+    }
+    return unwrap(convertType(eleTy)).getPointerTo();
   }
 
   // convert a front-end kind value to either a std or LLVM IR dialect type
@@ -262,6 +267,8 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
 
   // fir.array<c ... :any>  -->  llvm<"[...[c x any]]">
   mlir::LLVM::LLVMType convertSequenceType(fir::SequenceType seq) {
+    if (!seq.hasConstantInterior())
+      llvm_unreachable("cannot lower type to LLVM IR");
     auto baseTy = unwrap(convertType(seq.getEleTy()));
     auto shape = seq.getShape();
     auto constRows = seq.getConstantRows();
@@ -338,12 +345,12 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
   /// Returns false iff the sequence type has a shape and the shape is constant.
   static bool unknownShape(fir::SequenceType::Shape shape) {
     // does the shape even exist?
-    if (!shape.size())
+    auto size = shape.size();
+    if (size == 0)
       return true;
     // if it exists, are any dimensions deferred?
-    const auto sz = shape.size();
-    for (std::remove_const_t<decltype(sz)> i = 0; i < sz; ++i)
-      if (shape[i] < 0)
+    for (decltype(size) i = 0, sz = size; i < sz; ++i)
+      if (shape[i] == fir::SequenceType::getUnknownExtent())
         return true;
     return false;
   }
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index ca4f0877c344..cf0af6df1528 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -1077,6 +1077,23 @@ unsigned fir::SequenceType::getConstantRows() const {
   return count;
 }
 
+// This test helps us determine if we can degenerate an array to a
+// pointer to some interior section (possibly a single element) of the
+// sequence. This is used to determine if we can lower to the LLVM IR.
+bool fir::SequenceType::hasConstantInterior() const {
+  if (hasUnknownShape())
+    return true;
+  auto rows = getConstantRows();
+  auto dim = getDimension();
+  if (rows == dim)
+    return true;
+  auto shape = getShape();
+  for (unsigned i{rows}, size{dim}; i < size; ++i)
+    if (shape[i] != getUnknownExtent())
+      return false;
+  return true;
+}
+
 mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
     mlir::Location loc, const SequenceType::Shape &shape, mlir::Type eleTy,
     mlir::AffineMapAttr map) {
diff --git a/test/Fir/coordinate01.fir b/test/Fir/coordinate01.fir
new file mode 100644
index 000000000000..e7553477a818
--- /dev/null
+++ b/test/Fir/coordinate01.fir
@@ -0,0 +1,19 @@
+// RUN: tco -emit-fir %s | tco | FileCheck %s
+
+// CHECK-LABEL: @foo1
+func @foo1(%i : i32, %j : i32, %k : i32) {
+  %1 = fir.alloca !fir.array<10 x 20 x 30 x f32>
+  %2 = fir.convert %1 : (!fir.ref<!fir.array<10 x 20 x 30 x f32>>) -> !fir.ref<!fir.array<10 x 20 x ? x f32>>
+  // CHECK: getelementptr [20 x [10 x float]], [20 x [10 x float]]* %
+  %3 = fir.coordinate_of %2, %i, %j, %k : (!fir.ref<!fir.array<10 x 20 x ? x f32>>, i32, i32, i32) -> !fir.ref<f32>
+  return
+}
+
+// CHECK-LABEL: @foo
+func @foo(%i : i32, %j : i32, %k : i32) {
+  %1 = fir.alloca !fir.array<10 x 20 x 30 x f32>
+  %2 = fir.convert %1 : (!fir.ref<!fir.array<10 x 20 x 30 x f32>>) -> !fir.ref<f32>
+  // CHECK: getelementptr float, float* %
+  %3 = fir.coordinate_of %2, %i : (!fir.ref<f32>, i32) -> !fir.ref<f32>
+  return
+}

From 5ce3bccf534748c8dd9e4e97fef82cc898548e44 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Wed, 1 Apr 2020 03:19:05 -0700
Subject: [PATCH 305/345] Whitelist constant shape arrays from TODO and
 character assignment tests

- Allow array with constant bounds (can be assumed) to lower
  Keep the rest as a TODO for now.
- Add builder.isComplex for both mlir and fir complex.
- Add character assignement lowering to FIR lit tests.
- Move end-to-end character assignement to lit.
---
 include/flang/Lower/FIRBuilder.h              |  10 +-
 lib/Lower/Bridge.cpp                          |  21 +++-
 lib/Lower/FIRBuilder.cpp                      |  24 ++--
 lib/Lower/IO.cpp                              |   2 +-
 not-test/lower/test_character_assignment.sh   |  45 --------
 test/Lower/character-assignement.f90          | 103 ++++++++++++++++++
 ...end-to-end-character-assignment-driver.cpp |   0
 .../Lower/end-to-end-character-assignment.f90 |   7 ++
 8 files changed, 154 insertions(+), 58 deletions(-)
 delete mode 100755 not-test/lower/test_character_assignment.sh
 create mode 100644 test/Lower/character-assignement.f90
 rename not-test/lower/test-character-assignment.cc => test/Lower/end-to-end-character-assignment-driver.cpp (100%)
 rename not-test/lower/character-assignment.f90 => test/Lower/end-to-end-character-assignment.f90 (84%)

diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index 7c5b3c0763ad..f6f6dd87460e 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -68,7 +68,7 @@ class CharacterOpsBuilder {
   /// Unless otherwise stated, all mlir::Value inputs of these pseudo-fir ops
   /// must be of type:
   /// - fir.boxchar<kind> (dynamic length character),
-  /// - fir.ref<fir.array<len x fir.char<kind>>> (character with compile timeA
+  /// - fir.ref<fir.array<len x fir.char<kind>>> (character with compile time
   ///      constant length),
   /// - fir.array<len x fir.char<kind>> (compile time constant character)
 
@@ -169,6 +169,11 @@ class ComplexOpsBuilder {
   mlir::Value createComplexCompare(mlir::Value cplx1, mlir::Value cplx2,
                                    bool eq);
 
+  static bool isComplex(mlir::Value val) {
+    auto ty = val.getType();
+    return ty.isa<fir::CplxType>() || ty.isa<mlir::ComplexType>();
+  }
+
 protected:
   template <Part partId>
   mlir::Value extract(mlir::Value cplx) {
@@ -231,9 +236,8 @@ class FirOpBuilder : public mlir::OpBuilder,
   /// Get the entry block of the current Function
   mlir::Block *getEntryBlock() { return &getFunction().front(); }
 
-
   mlir::Type getRefType(mlir::Type eleTy);
-  
+
   /// Create an integer constant of type \p type and value \p i.
   mlir::Value createIntegerConstant(mlir::Type integerType, std::int64_t i);
 
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 8763d4a2df45..b87b3e7e21ee 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -1100,6 +1100,20 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return Fortran::lower::FirOpBuilder::createFunction(loc, module, name, ty);
   }
 
+  /// Temporary helper to detect shapes that do not require evaluating
+  /// bound expressions at runtime or to get the shape from a descriptor.
+  static bool isConstantShape(const Fortran::semantics::ArraySpec &shape) {
+    for (const auto &susbcript : shape) {
+      const auto &lb = susbcript.lbound().GetExplicit();
+      const auto &ub = susbcript.ubound().GetExplicit();
+      if (!lb.has_value() || !Fortran::evaluate::IsConstantExpr(*lb) ||
+          !(susbcript.ubound().isAssumed() ||
+            (ub.has_value() && Fortran::evaluate::IsConstantExpr(*ub))))
+        return false;
+    }
+    return true;
+  }
+
   /// Evaluate specification expressions of local symbol and add
   /// the resulting mlir::value to localSymbols.
   /// Before evaluating a specification expression, the symbols
@@ -1163,8 +1177,11 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
     if (const auto *details =
             symbol.detailsIf<Fortran::semantics::ObjectEntityDetails>()) {
-      if (!details->shape().empty())
-        TODO(); // handle bounds specification expressions
+      // For now, only allow compile time constant shapes that do no require
+      // to evaluate bounds expression here. Assumed size are also supported.
+      if (!isConstantShape(details->shape()))
+        TODO();
+      // handle bounds specification expressions
       if (!details->coshape().empty())
         TODO(); // handle cobounds specification expressions
       if (details->init())
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index 4e1c69b68397..464ac5b09113 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -249,6 +249,8 @@ struct CharacterOpsBuilderImpl {
 
   void createPadding(Char str, mlir::Value lower, mlir::Value upper) {
     auto blank = createBlankConstant(str.getCharacterType());
+    // Always create the loop, if upper < lower, no iteration will be
+    // executed.
     builder.createLoop(
         lower, upper,
         [&](Fortran::lower::FirOpBuilder &handler, mlir::Value index) {
@@ -275,6 +277,13 @@ struct CharacterOpsBuilderImpl {
 
   void createAssign(Char lhs, Char rhs) {
     Char safe_rhs{rhs};
+    // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
+    // if needed.
+    auto cmpLen = builder.createHere<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
+                                                   lhs.len, rhs.len);
+    auto copyCount =
+        builder.createHere<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
+
     if (rhs.isConstant()) {
       // Need to materialize the constant to get its elements.
       // (No equivalent of fir.coordinate_of for array value).
@@ -282,16 +291,13 @@ struct CharacterOpsBuilderImpl {
     } else {
       // If rhs is in memory, always assumes rhs might overlap with lhs
       // in a way that require a temp for the copy. That can be optimize later.
-      auto temp = createTemp(rhs.getCharacterType(), rhs.len);
-      createCopy(temp, rhs, rhs.len);
+      // Only create a temp of copyCount size because we do not need more from
+      // rhs.
+      auto temp = createTemp(rhs.getCharacterType(), copyCount.getResult());
+      createCopy(temp, rhs, copyCount);
       safe_rhs = temp;
     }
 
-    // Copy the minimum of the lhs and rhs lengths and pad the lhs remainder
-    auto cmpLen = builder.createHere<mlir::CmpIOp>(mlir::CmpIPredicate::slt,
-                                                   lhs.len, rhs.len);
-    auto copyCount =
-        builder.createHere<mlir::SelectOp>(cmpLen, lhs.len, rhs.len);
     createCopy(lhs, safe_rhs, copyCount);
     auto one = builder.createIntegerConstant(lhs.len.getType(), 1);
     auto maxPadding = builder.createHere<mlir::SubIOp>(lhs.len, one);
@@ -539,3 +545,7 @@ mlir::Value Fortran::lower::ComplexOpsBuilder<T>::createComplexCompare(
   return eq ? b.template createHere<mlir::AndOp>(realCmp, imagCmp).getResult()
             : b.template createHere<mlir::OrOp>(realCmp, imagCmp).getResult();
 }
+template mlir::Value Fortran::lower::ComplexOpsBuilder<
+    Fortran::lower::FirOpBuilder>::createComplexCompare(mlir::Value cplx1,
+                                                        mlir::Value cplx2,
+                                                        bool eq);
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 904103630a4e..f7ef8c320ffa 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -171,7 +171,7 @@ splitArguments(Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
     auto dataLen = builder.materializeCharacter(arg);
     return {dataLen.first, dataLen.second};
   }
-  if (arg.getType().isa<fir::CplxType>()) {
+  if (builder.isComplex(arg)) {
     auto parts = builder.extractParts(arg);
     return {parts.first, parts.second};
   }
diff --git a/not-test/lower/test_character_assignment.sh b/not-test/lower/test_character_assignment.sh
deleted file mode 100755
index 7181bce96f73..000000000000
--- a/not-test/lower/test_character_assignment.sh
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-# Test Fortran character assignment/expression lowering by driving compilation
-# and executions of Fortran and C++ source codes.
-#
-# Usage: cmd bbc llc
-# To keep generated files, run `export KEEP=TRUE` before the test call.
-
-BBC=$1
-LLC=$2
-CPP=g++
-CPP_SRC=$PWD/test-character-assignment.cc
-F_SRC=$PWD/character-assignment.f90
-
-function die {
-  echo "$(basename $0): $*" >&2
-  exit 1
-}
-
-temp=`mktemp -d ./tmp.XXXXXX`
-cd $temp
-[[ $KEEP ]] || trap "cd .. && rm -rf $temp" EXIT
-
-bbcLog=bbc.log
-assembly=a.s
-testObject=test.o
-testExec=./test_exec
-testLog=test.log
-llFile=a.mlir.ll
-$BBC -emit-llvm -disable-fir2std -o a.mlir $F_SRC 2>$bbcLog
-[[ $? -ne 0 ]] && die "bbc test.f90 compilation failure"
-sed -i 's/_QP//g' -i $llFile
-$LLC $llFile -o $assembly
-[[ $? -ne 0 ]] && die "llc failed compiling bbc output"
-as $assembly -o $testObject
-[[ $? -ne 0 ]] && die "as failed compiling llc output"
-$CPP -std=c++17 $testObject $CPP_SRC -o $testExec
-[[ $? -ne 0 ]] && die "driver.f90 compilation/linking failure"
-$testExec > $testLog
-result=$?
-cat $testLog
-if [ $result -ne 0 ]; then
-  echo "FAIL"
-else
-  echo "PASS"
-fi
diff --git a/test/Lower/character-assignement.f90 b/test/Lower/character-assignement.f90
new file mode 100644
index 000000000000..8927b0541406
--- /dev/null
+++ b/test/Lower/character-assignement.f90
@@ -0,0 +1,103 @@
+! RUN: bbc %s -o "-" -emit-fir | FileCheck %s
+
+! Simple character assignment tests
+! CHECK-LABEL: assign1
+subroutine assign1(lhs, rhs)
+  character(*, 1) :: lhs, rhs
+  lhs = rhs
+  ! Unboxing
+  ! CHECK-DAG:[[lhs:%[0-9]+]]:2 = fir.unboxchar %arg0
+  ! CHECK-DAG:[[rhs:%[0-9]+]]:2 = fir.unboxchar %arg1
+
+  ! Compute minimum length
+  ! CHECK-DAG:[[cmp_len:%[0-9]+]] = cmpi "slt", [[lhs]]#1, [[rhs]]#1
+  ! CHECK-DAG:[[min_len:%[0-9]+]] = select %2, [[lhs]]#1, [[rhs]]#1
+
+  ! Allocate temp in case rhs and lhs may overlap
+  ! CHECK: [[tmp:%[0-9]+]] = fir.alloca !fir.char<1>, [[min_len]]
+
+  ! Copy of rhs into temp
+  ! CHECK: fir.loop [[i:%[[:alnum:]_]+]]
+    ! CHECK-DAG: [[rhs_addr:%[0-9]+]] = fir.coordinate_of [[rhs]]#0, [[i]]
+    ! CHECK-DAG: [[tmp_addr:%[0-9]+]] = fir.coordinate_of [[tmp]], [[i]]
+    ! CHECK-DAG: [[rhs_elt:%[0-9]+]] = fir.load [[rhs_addr]]
+    ! CHECK: fir.store [[rhs_elt]] to [[tmp_addr]]
+  ! CHECK: }
+
+  ! Copy of temp into lhs
+  ! CHECK: fir.loop [[i:%[[:alnum:]]+]]
+    ! CHECK-DAG: [[tmp_addr:%[0-9]+]] = fir.coordinate_of [[tmp]], [[i]]
+    ! CHECK-DAG: [[lhs_addr:%[0-9]+]] = fir.coordinate_of [[lhs]]#0, [[i]]
+    ! CHECK-DAG: [[tmp_elt:%[0-9]+]] = fir.load [[tmp_addr]]
+    ! CHECK: fir.store [[tmp_elt]] to [[lhs_addr]]
+  ! CHECK: }
+
+  ! Padding
+  ! CHECK: [[c32:%[[:alnum:]_]+]] = constant 32 : i8
+  ! CHECK: [[blank:%[0-9]+]] = fir.convert [[c32]] : (i8) -> !fir.char<1>
+  ! CHECK: fir.loop [[i:%[[:alnum:]_]+]]
+    ! CHECK-DAG: [[lhs_addr:%[0-9]+]] = fir.coordinate_of [[lhs]]#0, [[i]]
+    ! CHECK: fir.store [[blank]] to [[lhs_addr]]
+  ! CHECK: }
+end subroutine
+
+! Test substring assignment
+! CHECK-LABEL: assign_substring1
+subroutine assign_substring1(str, rhs, lb, ub)
+  character(*, 1) :: rhs, str
+  integer(8) :: lb, ub
+  str(lb:ub) = rhs
+  ! CHECK-DAG: [[lb:%[0-9]+]] = fir.load %arg2
+  ! CHECK-DAG: [[ub:%[0-9]+]] = fir.load %arg3
+  ! CHECK-DAG: [[str:%[0-9]+]]:2 = fir.unboxchar %arg0
+
+  ! Compute substring offset
+  ! CHECK-DAG: [[lbi:%[0-9]+]] = fir.convert [[lb]] : (i64) -> index
+  ! CHECK-DAG: [[c1:%[[:alnum:]_]+]] = constant 1
+  ! CHECK-DAG: [[offset:%[0-9]+]] = subi [[lbi]], [[c1]]
+  ! CHECK-DAG: [[lhs_addr:%[0-9]+]] = fir.coordinate_of [[str]]#0, [[offset]]
+
+
+  ! Compute substring length
+  ! CHECK-DAG: [[diff:%[0-9]+]] = subi [[ub]], [[lb]]
+  ! CHECK-DAG: [[c1:%[[:alnum:]_]+]] = constant 1
+  ! CHECK-DAG: [[pre_lhs_len:%[0-9]+]] = addi [[diff]], [[c1]]
+  ! CHECK-DAG: [[c0:%[[:alnum:]_]+]] = constant 0
+  ! CHECK-DAG: [[cmp_len:%[0-9]+]] = cmpi "slt", [[pre_lhs_len]], [[c0]]
+  ! CHECK-DAG: [[lhs_len:%[0-9]+]] = select [[cmp_len]], [[c0]], [[pre_lhs_len]]
+
+  ! CHECK: [[lhs_box:%[0-9]+]] = fir.emboxchar [[lhs_addr]], [[lhs_len]]
+
+  ! The rest of the assignment is just as the one above, only test that the
+  ! substring box is the one used
+  ! ...
+  ! CHECK: [[lhs:%[0-9]+]]:2 = fir.unboxchar [[lhs_box]]
+  ! ...
+  ! CHECK: fir.coordinate_of [[lhs]]#0, {{.*}}
+  ! ...
+end subroutine
+
+! CHECK-LABEL: assign_constant
+subroutine assign_constant(lhs)
+  character(*, 1) :: lhs
+  ! CHECK-DAG:[[lhs:%[0-9]+]]:2 = fir.unboxchar %arg0
+  lhs = "Hello World"
+  ! CHECK-DAG: [[cst:%[0-9]+]] = fir.string_lit "Hello World"(11) : !fir.char<1>
+  ! CHECK-DAG: [[tmp:%[0-9]+]] = fir.alloca !fir.array<11x!fir.char<1>>
+  ! CHECK: fir.store [[cst]] to [[tmp]]
+  ! CHECK: fir.loop [[i:%[[:alnum:]]+]]
+    ! CHECK-DAG: [[tmp_addr:%[0-9]+]] = fir.coordinate_of [[tmp]], [[i]]
+    ! CHECK-DAG: [[lhs_addr:%[0-9]+]] = fir.coordinate_of [[lhs]]#0, [[i]]
+    ! CHECK-DAG: [[tmp_elt:%[0-9]+]] = fir.load [[tmp_addr]]
+    ! CHECK: fir.store [[tmp_elt]] to [[lhs_addr]]
+  ! CHECK: }
+
+  ! Padding
+  ! CHECK: [[c32:%[[:alnum:]_]+]] = constant 32 : i8
+  ! CHECK: [[blank:%[0-9]+]] = fir.convert [[c32]] : (i8) -> !fir.char<1>
+  ! CHECK: fir.loop [[i:%[[:alnum:]_]+]]
+    ! CHECK-DAG: [[lhs_addr:%[0-9]+]] = fir.coordinate_of [[lhs]]#0, [[i]]
+    ! CHECK: fir.store [[blank]] to [[lhs_addr]]
+  ! CHECK: }
+end subroutine
+
diff --git a/not-test/lower/test-character-assignment.cc b/test/Lower/end-to-end-character-assignment-driver.cpp
similarity index 100%
rename from not-test/lower/test-character-assignment.cc
rename to test/Lower/end-to-end-character-assignment-driver.cpp
diff --git a/not-test/lower/character-assignment.f90 b/test/Lower/end-to-end-character-assignment.f90
similarity index 84%
rename from not-test/lower/character-assignment.f90
rename to test/Lower/end-to-end-character-assignment.f90
index 65550902e8d5..d7416440bec9 100644
--- a/not-test/lower/character-assignment.f90
+++ b/test/Lower/end-to-end-character-assignment.f90
@@ -1,3 +1,10 @@
+! RUN: bbc -emit-llvm -o - %s | tco | llc | sed 's/_QP//g' | as -o %t
+! RUN: c++ -std=c++17 %t %S/end-to-end-character-assignment-driver.cpp
+! RUN: ./a.out
+
+! This is an end-to-end test that is driven from a c++ program that builds
+! characters, pass them to this functions and checks expected results.
+
 ! Simple character assignment tests
 subroutine assign1(s1, s2)
   character(*, 1) :: s1, s2

From 38d0717492f46e5506865b2864611288fadc56e2 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Thu, 2 Apr 2020 08:45:28 -0700
Subject: [PATCH 306/345] fix assignement typo and more readable
 isConstantShape logic

---
 lib/Lower/Bridge.cpp                              | 15 +++++++++------
 ...r-assignement.f90 => character-assignment.f90} |  0
 2 files changed, 9 insertions(+), 6 deletions(-)
 rename test/Lower/{character-assignement.f90 => character-assignment.f90} (100%)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index b87b3e7e21ee..d1f938896659 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -1103,13 +1103,16 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   /// Temporary helper to detect shapes that do not require evaluating
   /// bound expressions at runtime or to get the shape from a descriptor.
   static bool isConstantShape(const Fortran::semantics::ArraySpec &shape) {
+    auto isConstant{[](const auto &bound) {
+      const auto &expr = bound.GetExplicit();
+      return expr.has_value() && Fortran::evaluate::IsConstantExpr(*expr);
+    }};
     for (const auto &susbcript : shape) {
-      const auto &lb = susbcript.lbound().GetExplicit();
-      const auto &ub = susbcript.ubound().GetExplicit();
-      if (!lb.has_value() || !Fortran::evaluate::IsConstantExpr(*lb) ||
-          !(susbcript.ubound().isAssumed() ||
-            (ub.has_value() && Fortran::evaluate::IsConstantExpr(*ub))))
-        return false;
+      const auto &lb = susbcript.lbound();
+      const auto &ub = susbcript.ubound();
+      if (isConstant(lb) && (isConstant(ub) || ub.isAssumed()))
+        break;
+      return false;
     }
     return true;
   }
diff --git a/test/Lower/character-assignement.f90 b/test/Lower/character-assignment.f90
similarity index 100%
rename from test/Lower/character-assignement.f90
rename to test/Lower/character-assignment.f90

From 8d088208db95dd1201dbbcf6d4abda2e40880cf5 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 2 Apr 2020 11:24:31 -0700
Subject: [PATCH 307/345] add sketches for ioMsg and ioStat

---
 lib/Lower/IO.cpp | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index f7ef8c320ffa..9ee104023402 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -73,6 +73,8 @@ struct ErrorHandling {
   bool end{};
   bool eor{};
   bool ioMsg{};
+  const Fortran::semantics::SomeExpr *ioStatExpr{};
+  const Fortran::semantics::SomeExpr *ioMsgExpr{};
 };
 } // namespace
 
@@ -110,14 +112,27 @@ static mlir::FuncOp getIORuntimeFunc(Fortran::lower::FirOpBuilder &builder) {
 }
 
 /// Generate a call to end an IO statement
-static mlir::Value genEndIO(Fortran::lower::FirOpBuilder &builder,
+static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
                             mlir::Location loc, mlir::Value cookie,
                             const ErrorHandling &eh) {
   // Terminate IO
+  auto &builder = converter.getFirOpBuilder();
+  if (eh.ioMsg) {
+    TODO(); // eh.ioMsgExpr is never set
+    auto getMsg = getIORuntimeFunc<mkIOKey(GetIoMsg)>(builder);
+    auto var = converter.genExprAddr(eh.ioMsgExpr, loc);
+    mlir::Value varLen{}; // FIXME
+    llvm::SmallVector<mlir::Value, 3> args{cookie, var, varLen};
+    builder.create<mlir::CallOp>(loc, getMsg, args);
+  }
   auto endIOFunc = getIORuntimeFunc<mkIOKey(EndIoStatement)>(builder);
   llvm::SmallVector<mlir::Value, 1> endArgs{cookie};
   auto call = builder.create<mlir::CallOp>(loc, endIOFunc, endArgs);
-  // FIXME: gen code for ioStat and ioMsg cases
+  if (eh.ioStat) {
+    TODO(); // eh.ioStatExpr is never set
+    auto ioStatVar = converter.genExprAddr(eh.ioStatExpr, loc);
+    builder.create<fir::StoreOp>(loc, call.getResult(0), ioStatVar);
+  }
   return eh.hasErrorHandlers() ? call.getResult(0) : mlir::Value{};
 }
 
@@ -832,7 +847,7 @@ static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
   auto insertPt = threadSpecs(converter, loc, cookie, stmt.v);
   if (insertPt.isSet())
     builder.restoreInsertionPoint(insertPt);
-  return genEndIO(builder, converter.getCurrentLocation(), cookie, eh);
+  return genEndIO(converter, converter.getCurrentLocation(), cookie, eh);
 }
 
 mlir::Value Fortran::lower::genBackspaceStatement(
@@ -893,7 +908,7 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
   auto insertPt = threadSpecs(converter, loc, cookie, stmt.v);
   if (insertPt.isSet())
     builder.restoreInsertionPoint(insertPt);
-  return genEndIO(builder, loc, cookie, eh);
+  return genEndIO(converter, loc, cookie, eh);
 }
 
 mlir::Value
@@ -925,7 +940,7 @@ Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
   auto cookie = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
   ErrorHandling eh{};
   threadErrors(converter, loc, cookie, stmt.v, eh);
-  return genEndIO(builder, converter.getCurrentLocation(), cookie, eh);
+  return genEndIO(converter, converter.getCurrentLocation(), cookie, eh);
 }
 
 //===----------------------------------------------------------------------===//
@@ -1174,7 +1189,7 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
 
   if (insertPt.isSet())
     builder.restoreInsertionPoint(insertPt);
-  return genEndIO(builder, loc, cookie, eh);
+  return genEndIO(converter, loc, cookie, eh);
 }
 
 void Fortran::lower::genPrintStatement(

From c608aa8061066ac5b97e360824beaa6629b53309 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Thu, 2 Apr 2020 11:52:45 -0700
Subject: [PATCH 308/345] assert false

---
 lib/Optimizer/CodeGen.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index b34c77cba7d2..1c3ce5db6735 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -1500,7 +1500,6 @@ struct CoordinateOpConversion
     if (auto ptrTy = refTy.dyn_cast<fir::HeapType>())
       return ptrTy.getEleTy();
     llvm_unreachable("not a reference type");
-    return {};
   }
 
   /// return true if all `Value`s in `operands` are not `FieldIndexOp`s
@@ -1523,8 +1522,7 @@ struct CoordinateOpConversion
       if (auto defop = val.getDefiningOp())
         if (auto constOp = dyn_cast<mlir::ConstantIntOp>(defop))
           return constOp.getValue();
-    assert(false && "must be a constant");
-    return 0;
+    llvm_unreachable("must be a constant");
   }
 };
 
@@ -1668,8 +1666,7 @@ struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
           pair.second.modules, pair.second.host, pair.second.name,
           pair.second.kinds);
     }
-    assert(false);
-    return {};
+    llvm_unreachable("no name found");
   }
 };
 

From ad42380548848f3cd25f86a16cdba0aaf210540e Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Thu, 2 Apr 2020 14:11:25 -0700
Subject: [PATCH 309/345] fix bug with rewriting step

---
 include/flang/Optimizer/Dialect/FIROps.td | 32 +++++++++++--
 lib/Optimizer/CodeGen.cpp                 |  3 +-
 lib/Optimizer/Dialect/FIROps.cpp          | 55 +++++++++++++++++++++++
 3 files changed, 85 insertions(+), 5 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 4c67b8a028ea..79fbae735ea7 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -1588,10 +1588,16 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", []> {
 
   let results = (outs fir_ReferenceType);
 
-  let assemblyFormat = [{
-    operands attr-dict `:` functional-type(operands, results)
-  }];
+  let parser = "return parseCoordinateOp(parser, result);";
 
+  let printer = [{
+    p << getOperationName() << ' ' << getOperation()->getOperands();
+    p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{baseType()});
+    p << " : ";
+    p.printFunctionalType(getOperation()->getOperandTypes(),
+        getOperation()->getResultTypes());
+  }];
+  
   let verifier = [{
     // Recovering a LEN type parameter only makes sense from a boxed value
     for (auto co : coor())
@@ -1601,8 +1607,28 @@ def fir_CoordinateOp : fir_Op<"coordinate_of", []> {
         if (!ref().getType().dyn_cast<BoxType>())
           return emitOpError("len_param_index must be used on box type");
       }
+    if (auto attr = getAttr(CoordinateOp::baseType())) {
+      if (!attr.isa<mlir::TypeAttr>())
+        return emitOpError("improperly constructed");
+    } else {
+      return emitOpError("must have base type");
+    }
     return mlir::success();
   }];
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "Type type, Value ref, ValueRange coor,"
+	      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "Type type, ValueRange operands,"
+	      "ArrayRef<NamedAttribute> attrs = {}">];
+	      
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef baseType() { return "base_type"; }
+    mlir::Type getBaseType();
+  }];
 }
 
 def fir_ExtractValueOp : fir_OneResultOp<"extract_value", []> {
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 1c3ce5db6735..3da1b90a9b96 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -1265,8 +1265,7 @@ struct CoordinateOpConversion
     auto loc = coor.getLoc();
     auto c0 = genConstantIndex(loc, lowering.indexType(), rewriter, 0);
     mlir::Value base = operands[0];
-    auto firRef = coor.ref();
-    auto firTy = firRef.getType();
+    auto firTy = coor.getBaseType();
     mlir::Type cpnTy = getReferenceEleTy(firTy);
     bool columnIsDeferred = false;
     bool hasSubdimension = hasSubDimensions(cpnTy);
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 2137c172694f..1598ad086d08 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -314,6 +314,61 @@ mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   return {};
 }
 
+//===----------------------------------------------------------------------===//
+// CoordinateOp
+//===----------------------------------------------------------------------===//
+
+static mlir::ParseResult
+parseCoordinateOp(mlir::OpAsmParser &parser, mlir::OperationState &result) {
+  llvm::ArrayRef<mlir::Type> allOperandTypes;
+  llvm::ArrayRef<mlir::Type> allResultTypes;
+  llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> allOperands;
+  if (parser.parseOperandList(allOperands))
+    return failure();
+  if (parser.parseOptionalAttrDict(result.attributes))
+    return failure();
+  if (parser.parseColon())
+    return failure();
+
+  mlir::FunctionType funcTy;
+  if (parser.parseType(funcTy))
+    return failure();
+  allOperandTypes = funcTy.getInputs();
+  allResultTypes = funcTy.getResults();
+  result.addTypes(allResultTypes);
+  if (parser.resolveOperands(allOperands, allOperandTypes, allOperandLoc,
+			     result.operands))
+    return failure();
+  if (funcTy.getNumInputs()) {
+    // No inputs handled by verify
+    result.addAttribute(fir::CoordinateOp::baseType(),
+			mlir::TypeAttr::get(funcTy.getInput(0)));
+  }
+  return success();
+}
+
+mlir::Type fir::CoordinateOp::getBaseType() {
+  return getAttr(CoordinateOp::baseType()).cast<mlir::TypeAttr>().getValue();
+}
+
+void fir::CoordinateOp::build(Builder *, OperationState &result, mlir::Type resType,
+			 ValueRange operands, ArrayRef<NamedAttribute> attrs) {
+  assert(operands.size() >= 1u && "mismatched number of parameters");
+  result.addOperands(operands);
+  result.addAttribute(fir::CoordinateOp::baseType(), mlir::TypeAttr::get(operands[0].getType()));
+  result.attributes.append(attrs.begin(), attrs.end());
+  result.addTypes({resType});
+}
+
+void fir::CoordinateOp::build(Builder *builder, OperationState &result,
+			      mlir::Type resType, mlir::Value ref, ValueRange coor,
+			 ArrayRef<NamedAttribute> attrs) {
+  llvm::SmallVector<mlir::Value, 16> operands{ref};
+  operands.append(coor.begin(), coor.end());
+  build(builder, result, resType, operands, attrs);
+}
+
 //===----------------------------------------------------------------------===//
 // DispatchOp
 //===----------------------------------------------------------------------===//

From 170c8bb9fde84e9f3c84982a07f0148e4022d4db Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 3 Apr 2020 06:48:37 -0700
Subject: [PATCH 310/345] fixes after rebase with f18 5b89dc7 head

---
 include/flang/Semantics/symbol.h | 16 ++++------------
 runtime/io-api.h                 |  8 ++++----
 test/lit.cfg.py                  |  2 +-
 test/lit.site.cfg.py.in          |  3 +--
 tools/f18/CMakeLists.txt         |  9 +++++----
 5 files changed, 15 insertions(+), 23 deletions(-)

diff --git a/include/flang/Semantics/symbol.h b/include/flang/Semantics/symbol.h
index bfb0b99de15f..addb699f2635 100644
--- a/include/flang/Semantics/symbol.h
+++ b/include/flang/Semantics/symbol.h
@@ -59,14 +59,6 @@ class MainProgramDetails {
 
 class SubprogramDetails {
 public:
-  SubprogramDetails() {}
-  SubprogramDetails(const SubprogramDetails &that)
-    : dummyArgs_{that.dummyArgs_}, result_{that.result_} {}
-  SubprogramDetails &operator=(const SubprogramDetails &) = delete;
-  ~SubprogramDetails() = default;
-  SubprogramDetails &operator=(SubprogramDetails &&) = default;
-  SubprogramDetails(SubprogramDetails &&) = default;
-
   bool isFunction() const { return result_ != nullptr; }
   bool isInterface() const { return isInterface_; }
   void set_isInterface(bool value = true) { isInterface_ = value; }
@@ -743,10 +735,11 @@ inline bool ProcEntityDetails::HasExplicitInterface() const {
 
 inline bool operator<(SymbolRef x, SymbolRef y) { return *x < *y; }
 using SymbolSet = std::set<SymbolRef>;
+} // namespace Fortran::semantics
 
 // Define required  info so that SymbolRef can be used inside llvm::DenseMap.
 namespace llvm {
-template<> struct DenseMapInfo<Fortran::semantics::SymbolRef> {
+template <> struct DenseMapInfo<Fortran::semantics::SymbolRef> {
   static inline Fortran::semantics::SymbolRef getEmptyKey() {
     auto ptr = DenseMapInfo<const Fortran::semantics::Symbol *>::getEmptyKey();
     return *reinterpret_cast<Fortran::semantics::SymbolRef *>(&ptr);
@@ -768,6 +761,5 @@ template<> struct DenseMapInfo<Fortran::semantics::SymbolRef> {
     return LHS == RHS;
   }
 };
-
-} // namespace Fortran::semantics
-#endif  // FORTRAN_SEMANTICS_SYMBOL_H_
+} // namespace llvm
+#endif // FORTRAN_SEMANTICS_SYMBOL_H_
diff --git a/runtime/io-api.h b/runtime/io-api.h
index c9eaea093d2b..fec71c7538d2 100644
--- a/runtime/io-api.h
+++ b/runtime/io-api.h
@@ -27,10 +27,9 @@ using Cookie = IoStatementState *;
 using ExternalUnit = int;
 using AsynchronousId = int;
 static constexpr ExternalUnit DefaultUnit{-1}; // READ(*), WRITE(*), PRINT
-}
+} // namespace Fortran::runtime::io
 
-using namespace Fortran::runtime;
-using namespace Fortran::runtime::io;
+namespace Fortran::runtime::io {
 
 extern "C" {
 
@@ -296,6 +295,7 @@ bool IONAME(InquireInteger64)(
 // rather than by terminating the image.
 enum Iostat IONAME(EndIoStatement)(Cookie);
 
-}  // extern "C"
+} // extern "C"
+} // namespace Fortran::runtime::io
 
 #endif
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index 9955f4036cd0..c7eaafd3c208 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -66,7 +66,7 @@
     llvm_config.with_environment('PATH', config.flang_llvm_tools_dir, append_path=True)
 
 config.substitutions.append(('%B', config.flang_obj_root))
-config.substitutions.append(("%L", config.llvm_lib_dir))
+config.substitutions.append(("%L", config.flang_lib_dir))
 
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index ee78024c4d5f..ef9bdf915138 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -3,12 +3,11 @@
 import sys
 
 config.llvm_tools_dir = "@LLVM_TOOLS_BINARY_DIR@"
-config.llvm_lib_dir = "@LLVM_LIBS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
 config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
-#config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
+config.flang_lib_dir = "@FLANG_BINARY_DIR@/lib"
 config.flang_llvm_tools_dir = "@FLANG_LLVM_TOOLS_DIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 
diff --git a/tools/f18/CMakeLists.txt b/tools/f18/CMakeLists.txt
index 5a65bdcc2bc8..f8357b33f92f 100644
--- a/tools/f18/CMakeLists.txt
+++ b/tools/f18/CMakeLists.txt
@@ -1,6 +1,3 @@
-file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
-file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include")
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
 
 add_llvm_tool(f18
@@ -41,11 +38,15 @@ foreach(filename ${MODULES})
     set(depends ${include}/__fortran_builtins.mod)
   endif()
   add_custom_command(OUTPUT ${include}/${filename}.mod
-    COMMAND f18 -fparse-only -fdebug-semantics -I${include}
+    COMMAND f18 -fparse-only -I${include}
       ${FLANG_SOURCE_DIR}/module/${filename}.f90
     WORKING_DIRECTORY ${include}
     DEPENDS f18 ${FLANG_SOURCE_DIR}/module/${filename}.f90 ${depends}
   )
+  add_custom_command(OUTPUT ${include}/${filename}.f18.mod
+    DEPENDS ${include}/${filename}.mod
+    COMMAND ${CMAKE_COMMAND} -E
+      copy ${include}/${filename}.mod ${include}/${filename}.f18.mod)
   list(APPEND MODULE_FILES ${include}/${filename}.mod)
   list(APPEND MODULE_FILES ${include}/${filename}.f18.mod)
   install(FILES ${include}/${filename}.mod DESTINATION include/flang)

From c8c8d546841aa952a3c8f85eded0cb4a2802c532 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 3 Apr 2020 11:35:30 -0700
Subject: [PATCH 311/345] documentation bug

---
 include/flang/Optimizer/Dialect/FIROps.td | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 79fbae735ea7..9119bc0efdc3 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2648,7 +2648,7 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
         %o = constant 1 : index
         %4 = fir.insert_value %3, %1, %z : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
         %5 = fir.insert_value %4, %2, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
-        fir.has_value %5
+        fir.has_value %5 : tuple<i32, f32>
       }
     ```
   }];

From e15b87a5811d4da8f05a2acd9a27449d7611ae02 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 3 Apr 2020 11:28:45 -0700
Subject: [PATCH 312/345] fix intree build test failure

---
 not-test/lower/test_expression_lowering.sh | 2 +-
 test/lit.site.cfg.py.in                    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/not-test/lower/test_expression_lowering.sh b/not-test/lower/test_expression_lowering.sh
index d39e5faccf00..5ef373ffe463 100755
--- a/not-test/lower/test_expression_lowering.sh
+++ b/not-test/lower/test_expression_lowering.sh
@@ -29,7 +29,7 @@ assembly=a.s
 testObject=test.o
 testExec=./test_exec
 testLog=test.log
-llFile=a.mlir.ll
+llFile=test.mlir.ll
 
 $CPP $SRC -std=c++17 -o $testGen
 [[ $? -ne 0 ]] && die "test generator compilation failure"
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index ef9bdf915138..8d0cc35c4ece 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -7,8 +7,8 @@ config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
 config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
-config.flang_lib_dir = "@FLANG_BINARY_DIR@/lib"
-config.flang_llvm_tools_dir = "@FLANG_LLVM_TOOLS_DIR@"
+config.flang_lib_dir = "@LLVM_LIBRARY_OUTPUT_INTDIR@"
+config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 
 # Support substitution of the tools_dir with user parameters. This is

From c985c86590b11e7382657272aab97f60e7d008f6 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier@nvidia.com>
Date: Fri, 3 Apr 2020 10:32:51 -0700
Subject: [PATCH 313/345] add scalar intrinsic operation tests (but complex)

---
 test/Lower/integer-operations.f90 | 111 ++++++++++++++++++++++++++++++
 test/Lower/logical-operations.f90 |  67 ++++++++++++++++++
 test/Lower/real-operations.f90    | 111 ++++++++++++++++++++++++++++++
 3 files changed, 289 insertions(+)
 create mode 100644 test/Lower/integer-operations.f90
 create mode 100644 test/Lower/logical-operations.f90
 create mode 100644 test/Lower/real-operations.f90

diff --git a/test/Lower/integer-operations.f90 b/test/Lower/integer-operations.f90
new file mode 100644
index 000000000000..f230d359cd94
--- /dev/null
+++ b/test/Lower/integer-operations.f90
@@ -0,0 +1,111 @@
+! RUN: bbc %s -o "-" | FileCheck %s
+
+! Test integer intrinsic operation lowering to fir.
+
+! CHECK-LABEL:eq0_test
+LOGICAL FUNCTION eq0_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = cmpi "eq", [[reg1]], [[reg2]] : i32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+eq0_test = x0 .EQ. x1
+END FUNCTION
+
+! CHECK-LABEL:ne1_test
+LOGICAL FUNCTION ne1_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = cmpi "ne", [[reg1]], [[reg2]] : i32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+ne1_test = x0 .NE. x1
+END FUNCTION
+
+! CHECK-LABEL:lt2_test
+LOGICAL FUNCTION lt2_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = cmpi "slt", [[reg1]], [[reg2]] : i32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+lt2_test = x0 .LT. x1
+END FUNCTION
+
+! CHECK-LABEL:le3_test
+LOGICAL FUNCTION le3_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = cmpi "sle", [[reg1]], [[reg2]] : i32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+le3_test = x0 .LE. x1
+END FUNCTION
+
+! CHECK-LABEL:gt4_test
+LOGICAL FUNCTION gt4_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = cmpi "sgt", [[reg1]], [[reg2]] : i32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+gt4_test = x0 .GT. x1
+END FUNCTION
+
+! CHECK-LABEL:ge5_test
+LOGICAL FUNCTION ge5_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = cmpi "sge", [[reg1]], [[reg2]] : i32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+ge5_test = x0 .GE. x1
+END FUNCTION
+
+! CHECK-LABEL:add6_test
+INTEGER(4) FUNCTION add6_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:addi [[reg1]], [[reg2]] : i32
+add6_test = x0 + x1
+END FUNCTION
+
+! CHECK-LABEL:sub7_test
+INTEGER(4) FUNCTION sub7_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:subi [[reg1]], [[reg2]] : i32
+sub7_test = x0 - x1
+END FUNCTION
+
+! CHECK-LABEL:mult8_test
+INTEGER(4) FUNCTION mult8_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:muli [[reg1]], [[reg2]] : i32
+mult8_test = x0 * x1
+END FUNCTION
+
+! CHECK-LABEL:div9_test
+INTEGER(4) FUNCTION div9_test(x0, x1)
+INTEGER(4) :: x0
+INTEGER(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:divi_signed [[reg1]], [[reg2]] : i32
+div9_test = x0 / x1
+END FUNCTION
+
+! End of generated test file
diff --git a/test/Lower/logical-operations.f90 b/test/Lower/logical-operations.f90
new file mode 100644
index 000000000000..50a037043a89
--- /dev/null
+++ b/test/Lower/logical-operations.f90
@@ -0,0 +1,67 @@
+! RUN: bbc %s -o "-" | FileCheck %s
+
+! Test logical intrinsic operation lowering to fir.
+
+! CHECK-LABEL:eqv0_test
+LOGICAL(1) FUNCTION eqv0_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = cmpi "eq", [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+eqv0_test = x0 .EQV. x1
+END FUNCTION
+
+! CHECK-LABEL:neqv1_test
+LOGICAL(1) FUNCTION neqv1_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = cmpi "ne", [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+neqv1_test = x0 .NEQV. x1
+END FUNCTION
+
+! CHECK-LABEL:or2_test
+LOGICAL(1) FUNCTION or2_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = or [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+or2_test = x0 .OR. x1
+END FUNCTION
+
+! CHECK-LABEL:and3_test
+LOGICAL(1) FUNCTION and3_test(x0, x1)
+LOGICAL(1) :: x0
+LOGICAL(1) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK-DAG:[[reg3:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK-DAG:[[reg4:%[0-9]+]] = fir.convert [[reg2]] {{.*}} -> i1
+! CHECK:[[reg5:%[0-9]+]] = and [[reg3]], [[reg4]]
+! CHECK:fir.convert [[reg5]] {{.*}} -> !fir.logical<1>
+and3_test = x0 .AND. x1
+END FUNCTION
+
+! CHECK-LABEL:not4_test
+LOGICAL(1) FUNCTION not4_test(x0)
+LOGICAL(1) :: x0
+! CHECK:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK:[[reg2:%[0-9]+]] = fir.convert [[reg1]] {{.*}} -> i1
+! CHECK:[[reg3:%[0-9]+]] = xor [[reg2]], %true
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<1>
+not4_test = .NOT. x0
+END FUNCTION
+
+! End of generated test file
diff --git a/test/Lower/real-operations.f90 b/test/Lower/real-operations.f90
new file mode 100644
index 000000000000..fa1bcace7675
--- /dev/null
+++ b/test/Lower/real-operations.f90
@@ -0,0 +1,111 @@
+! RUN: bbc %s -o "-" | FileCheck %s
+
+! Test real intrinsic operation lowering to FIR.
+
+! CHECK-LABEL:eq0_test
+LOGICAL FUNCTION eq0_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = fir.cmpf "oeq", [[reg1]], [[reg2]] : f32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+eq0_test = x0 .EQ. x1
+END FUNCTION
+
+! CHECK-LABEL:ne1_test
+LOGICAL FUNCTION ne1_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = fir.cmpf "une", [[reg1]], [[reg2]] : f32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+ne1_test = x0 .NE. x1
+END FUNCTION
+
+! CHECK-LABEL:lt2_test
+LOGICAL FUNCTION lt2_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = fir.cmpf "olt", [[reg1]], [[reg2]] : f32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+lt2_test = x0 .LT. x1
+END FUNCTION
+
+! CHECK-LABEL:le3_test
+LOGICAL FUNCTION le3_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = fir.cmpf "ole", [[reg1]], [[reg2]] : f32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+le3_test = x0 .LE. x1
+END FUNCTION
+
+! CHECK-LABEL:gt4_test
+LOGICAL FUNCTION gt4_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = fir.cmpf "ogt", [[reg1]], [[reg2]] : f32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+gt4_test = x0 .GT. x1
+END FUNCTION
+
+! CHECK-LABEL:ge5_test
+LOGICAL FUNCTION ge5_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:[[reg3:%[0-9]+]] = fir.cmpf "oge", [[reg1]], [[reg2]] : f32
+! CHECK:fir.convert [[reg3]] {{.*}} -> !fir.logical<4>
+ge5_test = x0 .GE. x1
+END FUNCTION
+
+! CHECK-LABEL:add6_test
+REAL(4) FUNCTION add6_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:fir.addf [[reg1]], [[reg2]] : f32
+add6_test = x0 + x1
+END FUNCTION
+
+! CHECK-LABEL:sub7_test
+REAL(4) FUNCTION sub7_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:fir.subf [[reg1]], [[reg2]] : f32
+sub7_test = x0 - x1
+END FUNCTION
+
+! CHECK-LABEL:mult8_test
+REAL(4) FUNCTION mult8_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:fir.mulf [[reg1]], [[reg2]] : f32
+mult8_test = x0 * x1
+END FUNCTION
+
+! CHECK-LABEL:div9_test
+REAL(4) FUNCTION div9_test(x0, x1)
+REAL(4) :: x0
+REAL(4) :: x1
+! CHECK-DAG:[[reg1:%[0-9]+]] = fir.load %arg0
+! CHECK-DAG:[[reg2:%[0-9]+]] = fir.load %arg1
+! CHECK:fir.divf [[reg1]], [[reg2]] : f32
+div9_test = x0 / x1
+END FUNCTION
+
+! End of generated test file

From 2719c6a223d6a806b5b829efc65829398ae9ec58 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 3 Apr 2020 12:31:02 -0700
Subject: [PATCH 314/345] [workaround] add --disable-pass-threading for now to
 get around crashes.  We need to figure out the root cause of the crashes,
 however.

---
 test/Lower/end-to-end-character-assignment.f90 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/Lower/end-to-end-character-assignment.f90 b/test/Lower/end-to-end-character-assignment.f90
index d7416440bec9..86d7d634356a 100644
--- a/test/Lower/end-to-end-character-assignment.f90
+++ b/test/Lower/end-to-end-character-assignment.f90
@@ -1,4 +1,4 @@
-! RUN: bbc -emit-llvm -o - %s | tco | llc | sed 's/_QP//g' | as -o %t
+! RUN: bbc --disable-pass-threading -emit-llvm -o - %s | tco | llc | sed 's/_QP//g' | as -o %t
 ! RUN: c++ -std=c++17 %t %S/end-to-end-character-assignment-driver.cpp
 ! RUN: ./a.out
 

From cf668814a0444678ed794b3e266bb1223041f770 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 3 Apr 2020 12:42:49 -0700
Subject: [PATCH 315/345] add a substitution to use the same C++ compiler as
 the build for test

---
 test/Lower/end-to-end-character-assignment.f90 | 2 +-
 test/lit.cfg.py                                | 1 +
 test/lit.site.cfg.py.in                        | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/Lower/end-to-end-character-assignment.f90 b/test/Lower/end-to-end-character-assignment.f90
index 86d7d634356a..9399fc00ddfa 100644
--- a/test/Lower/end-to-end-character-assignment.f90
+++ b/test/Lower/end-to-end-character-assignment.f90
@@ -1,5 +1,5 @@
 ! RUN: bbc --disable-pass-threading -emit-llvm -o - %s | tco | llc | sed 's/_QP//g' | as -o %t
-! RUN: c++ -std=c++17 %t %S/end-to-end-character-assignment-driver.cpp
+! RUN: %CXX -std=c++17 %t %S/end-to-end-character-assignment-driver.cpp
 ! RUN: ./a.out
 
 ! This is an end-to-end test that is driven from a c++ program that builds
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index c7eaafd3c208..b2b0844a638e 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -67,6 +67,7 @@
 
 config.substitutions.append(('%B', config.flang_obj_root))
 config.substitutions.append(("%L", config.flang_lib_dir))
+config.substitutions.append(("%CXX", config.cplusplus_executable))
 
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index 8d0cc35c4ece..93a90648d9f5 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -10,6 +10,7 @@ config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 config.flang_lib_dir = "@LLVM_LIBRARY_OUTPUT_INTDIR@"
 config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
+config.cplusplus_executable = "@CMAKE_CXX_COMPILER@"
 
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.

From 37cace49c6b22579993fd4d333a763ea4b1e96db Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 3 Apr 2020 16:15:42 -0700
Subject: [PATCH 316/345] misc. changes, code cleanup

---
 include/flang/Optimizer/Support/KindMapping.h | 12 ++---
 include/flang/Optimizer/Transforms/Passes.h   |  5 ++
 .../flang/Optimizer/Transforms/StdConverter.h | 27 -----------
 lib/Optimizer/StdConverter.cpp                | 48 +++++++++----------
 lib/Optimizer/Support/KindMapping.cpp         | 13 ++---
 ...end-to-end-character-assignment-driver.cpp | 48 +++++++++----------
 .../Lower/end-to-end-character-assignment.f90 |  2 +-
 tools/bbc/bbc.cpp                             |  1 -
 tools/tco/tco.cpp                             |  1 -
 9 files changed, 66 insertions(+), 91 deletions(-)
 delete mode 100644 include/flang/Optimizer/Transforms/StdConverter.h

diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
index dc89e1c2d267..d2ec04c6528f 100644
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -57,24 +57,24 @@ class KindMapping {
   explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map);
 
   /// Get the size in bits of !fir.char<kind>
-  Bitsize getCharacterBitsize(KindTy kind);
+  Bitsize getCharacterBitsize(KindTy kind) const;
 
   /// Get the size in bits of !fir.int<kind>
-  Bitsize getIntegerBitsize(KindTy kind);
+  Bitsize getIntegerBitsize(KindTy kind) const;
 
   /// Get the size in bits of !fir.logical<kind>
-  Bitsize getLogicalBitsize(KindTy kind);
+  Bitsize getLogicalBitsize(KindTy kind) const;
 
   /// Get the LLVM Type::TypeID of !fir.real<kind>
-  LLVMTypeID getRealTypeID(KindTy kind);
+  LLVMTypeID getRealTypeID(KindTy kind) const;
 
   /// Get the LLVM Type::TypeID of !fir.complex<kind>
-  LLVMTypeID getComplexTypeID(KindTy kind);
+  LLVMTypeID getComplexTypeID(KindTy kind) const;
 
   mlir::MLIRContext *getContext() const { return context; }
 
   /// Get the float semantics of !fir.real<kind>
-  const llvm::fltSemantics &getFloatSemantics(KindTy kind);
+  const llvm::fltSemantics &getFloatSemantics(KindTy kind) const;
 
 private:
   MatchResult badMapString(const llvm::Twine &ptr);
diff --git a/include/flang/Optimizer/Transforms/Passes.h b/include/flang/Optimizer/Transforms/Passes.h
index 4ead67874b3f..0c59689b2b62 100644
--- a/include/flang/Optimizer/Transforms/Passes.h
+++ b/include/flang/Optimizer/Transforms/Passes.h
@@ -20,6 +20,11 @@ class Pass;
 
 namespace fir {
 
+class KindMapping;
+
+/// Convert fir.select_type to the standard dialect
+std::unique_ptr<mlir::Pass> createFIRToStdPass(const KindMapping &);
+
 /// Effects aware CSE pass
 std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>> createCSEPass();
 
diff --git a/include/flang/Optimizer/Transforms/StdConverter.h b/include/flang/Optimizer/Transforms/StdConverter.h
deleted file mode 100644
index 335c28f99252..000000000000
--- a/include/flang/Optimizer/Transforms/StdConverter.h
+++ /dev/null
@@ -1,27 +0,0 @@
-//===-- Optimizer/Transforms/StdConverter.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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPTIMIZER_TRANSFORMS_STDCONVERTER_H
-#define OPTIMIZER_TRANSFORMS_STDCONVERTER_H
-
-#include <memory>
-
-namespace mlir {
-class Pass;
-}
-
-namespace fir {
-
-class KindMapping;
-
-/// Convert FIR to the standard dialect
-std::unique_ptr<mlir::Pass> createFIRToStdPass(KindMapping &);
-
-} // namespace fir
-
-#endif // OPTIMIZER_TRANSFORMS_STDCONVERTER_H
diff --git a/lib/Optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
index 3fc2ccc24444..ead2b4d38f12 100644
--- a/lib/Optimizer/StdConverter.cpp
+++ b/lib/Optimizer/StdConverter.cpp
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/Optimizer/Transforms/StdConverter.h"
+#include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
@@ -22,10 +22,11 @@
 // This module performs the conversion of some FIR operations.
 // Convert some FIR types to standard dialect?
 
-static llvm::cl::opt<bool>
-    ClDisableFirToStd("disable-fir2std",
-                      llvm::cl::desc("disable FIR to standard pass"),
-                      llvm::cl::init(false), llvm::cl::Hidden);
+static llvm::cl::opt<bool> disableFirToStd(
+    "disable-fir-to-std",
+    llvm::cl::desc("disable conversion of fir.select_type and affine dialect "
+                   "to the standard dialect pass"),
+    llvm::cl::init(false), llvm::cl::Hidden);
 
 namespace fir {
 namespace {
@@ -182,33 +183,30 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
 /// Convert affine dialect, fir.select_type to standard dialect
 class FIRToStdLoweringPass : public mlir::FunctionPass<FIRToStdLoweringPass> {
 public:
-  explicit FIRToStdLoweringPass(KindMapping &kindMap) : kindMap{kindMap} {}
+  explicit FIRToStdLoweringPass(const KindMapping &kindMap)
+      : kindMap{kindMap} {}
 
   void runOnFunction() override {
-    if (ClDisableFirToStd)
+    if (disableFirToStd)
       return;
 
-    auto *context{&getContext()};
-    // FIRToStdTypeConverter typeConverter{kindMap};
+    // FIRToStdTypeConverter tyConv{kindMap};
     mlir::OwningRewritePatternList patterns;
-    // patterns.insert<SelectTypeOpConversion>(context, typeConverter);
-    patterns.insert<SelectTypeOpConversion>(context);
-    mlir::populateAffineToStdConversionPatterns(patterns, context);
-    // mlir::populateFuncOpTypeConversionPattern(patterns, context,
-    // typeConverter);
-    mlir::ConversionTarget target{*context};
-    target.addLegalDialect<mlir::StandardOpsDialect, FIROpsDialect>();
+    // patterns.insert<SelectTypeOpConversion>(context, tyConv);
+    patterns.insert<SelectTypeOpConversion>(&getContext());
+    mlir::populateAffineToStdConversionPatterns(patterns, &getContext());
+    // mlir::populateFuncOpTypeConversionPattern(patterns, context, tyConv);
+    mlir::ConversionTarget target(getContext());
+    target.addLegalDialect<FIROpsDialect, mlir::loop::LoopOpsDialect,
+                           mlir::StandardOpsDialect>();
     // target.addDynamicallyLegalOp<mlir::FuncOp>([&](mlir::FuncOp op) {
-    //  return typeConverter.isSignatureLegal(op.getType());
+    //  return tyConv.isSignatureLegal(op.getType());
     //});
     target.addIllegalOp<SelectTypeOp>();
-    if (mlir::failed(mlir::applyPartialConversion(
-            // getModule(), target, std::move(patterns), &typeConverter))) {
-            getModule(), target, std::move(patterns)))) {
-      mlir::emitError(mlir::UnknownLoc::get(context),
-                      "error in converting to standard dialect\n");
+
+    if (mlir::failed(
+            mlir::applyPartialConversion(getFunction(), target, patterns)))
       signalPassFailure();
-    }
   }
 
   mlir::ModuleOp getModule() {
@@ -216,11 +214,11 @@ class FIRToStdLoweringPass : public mlir::FunctionPass<FIRToStdLoweringPass> {
   }
 
 private:
-  KindMapping &kindMap;
+  const KindMapping &kindMap;
 };
 } // namespace
 
-std::unique_ptr<mlir::Pass> createFIRToStdPass(KindMapping &kindMap) {
+std::unique_ptr<mlir::Pass> createFIRToStdPass(const KindMapping &kindMap) {
   return std::make_unique<FIRToStdLoweringPass>(kindMap);
 }
 } // namespace fir
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
index 8731c0bb087e..c3850ceea047 100644
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -219,26 +219,27 @@ MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
   return mlir::success();
 }
 
-Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) {
+Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) const {
   return getIntegerLikeBitsize<'a'>(kind, intMap);
 }
 
-Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) {
+Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) const {
   return getIntegerLikeBitsize<'i'>(kind, intMap);
 }
 
-Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) {
+Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) const {
   return getIntegerLikeBitsize<'l'>(kind, intMap);
 }
 
-LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) {
+LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) const {
   return getFloatLikeTypeID<'r'>(kind, floatMap);
 }
 
-LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) {
+LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) const {
   return getFloatLikeTypeID<'c'>(kind, floatMap);
 }
 
-const llvm::fltSemantics &fir::KindMapping::getFloatSemantics(KindTy kind) {
+const llvm::fltSemantics &
+fir::KindMapping::getFloatSemantics(KindTy kind) const {
   return getFloatSemanticsOfKind<'r'>(kind, floatMap);
 }
diff --git a/test/Lower/end-to-end-character-assignment-driver.cpp b/test/Lower/end-to-end-character-assignment-driver.cpp
index ef7da61f3f30..6e3a3c9ba466 100644
--- a/test/Lower/end-to-end-character-assignment-driver.cpp
+++ b/test/Lower/end-to-end-character-assignment-driver.cpp
@@ -176,9 +176,9 @@ extern "C" {
 //   CHARACTER(*, K) :: s1, s2
 //   s1 = s2
 // END SUBROUTINE
-void assign1(Fchar, Fchar);
-void assign2(Fchar, Fchar);
-void assign4(Fchar, Fchar);
+void _QPassign1(Fchar, Fchar);
+void _QPassign2(Fchar, Fchar);
+void _QPassign4(Fchar, Fchar);
 }
 
 template<int Kind, typename Func>
@@ -221,9 +221,9 @@ extern "C" {
 //   INTEGER :: lb, ub
 //   s1(lb:ub) = s2
 // END SUBROUTINE
-void assign_substring1(Fchar s1, Fchar s2, int *lb, int *ub);
-void assign_substring2(Fchar, Fchar, int *, int *);
-void assign_substring4(Fchar, Fchar, int *, int *);
+void _QPassign_substring1(Fchar s1, Fchar s2, int *lb, int *ub);
+void _QPassign_substring2(Fchar, Fchar, int *, int *);
+void _QPassign_substring4(Fchar, Fchar, int *, int *);
 }
 
 template<int Kind, typename Func>
@@ -257,9 +257,9 @@ extern "C" {
 //   INTEGER :: lb
 //   s1(lb:) = s2
 // END SUBROUTINE
-void assign_overlap1(Fchar s1, Fchar s2, int *lb);
-void assign_overlap2(Fchar, Fchar, int *);
-void assign_overlap4(Fchar, Fchar, int *);
+void _QPassign_overlap1(Fchar s1, Fchar s2, int *lb);
+void _QPassign_overlap2(Fchar, Fchar, int *);
+void _QPassign_overlap4(Fchar, Fchar, int *);
 }
 
 template<int Kind, typename Func>
@@ -290,9 +290,9 @@ extern "C" {
 //   CHARACTER(l2, K) :: s2
 //   s1 = s2
 // END SUBROUTINE
-void assign_spec_expr_len1(Fchar s1, Fchar s2, int *l1, int *l2);
-void assign_spec_expr_len2(Fchar s1, Fchar s2, int *l1, int *l2);
-void assign_spec_expr_len4(Fchar s1, Fchar s2, int *l1, int *l2);
+void _QPassign_spec_expr_len1(Fchar s1, Fchar s2, int *l1, int *l2);
+void _QPassign_spec_expr_len2(Fchar s1, Fchar s2, int *l1, int *l2);
+void _QPassign_spec_expr_len4(Fchar s1, Fchar s2, int *l1, int *l2);
 }
 
 template<int Kind, typename Func>
@@ -336,21 +336,21 @@ void TestSpecExprLenAssignement(Func testedSub, int &tests, int &passed) {
 int main(int, char **) {
   int tests{0}, passed{0};
 
-  TestNormalAssignement<1>(assign1, tests, passed);
-  TestNormalAssignement<2>(assign2, tests, passed);
-  TestNormalAssignement<4>(assign4, tests, passed);
+  TestNormalAssignement<1>(_QPassign1, tests, passed);
+  TestNormalAssignement<2>(_QPassign2, tests, passed);
+  TestNormalAssignement<4>(_QPassign4, tests, passed);
 
-  TestSubstringAssignement<1>(assign_substring1, tests, passed);
-  TestSubstringAssignement<2>(assign_substring2, tests, passed);
-  TestSubstringAssignement<4>(assign_substring4, tests, passed);
+  TestSubstringAssignement<1>(_QPassign_substring1, tests, passed);
+  TestSubstringAssignement<2>(_QPassign_substring2, tests, passed);
+  TestSubstringAssignement<4>(_QPassign_substring4, tests, passed);
 
-  TestOverlappingAssignement<1>(assign_overlap1, tests, passed);
-  TestOverlappingAssignement<2>(assign_overlap2, tests, passed);
-  TestOverlappingAssignement<4>(assign_overlap4, tests, passed);
+  TestOverlappingAssignement<1>(_QPassign_overlap1, tests, passed);
+  TestOverlappingAssignement<2>(_QPassign_overlap2, tests, passed);
+  TestOverlappingAssignement<4>(_QPassign_overlap4, tests, passed);
 
-  TestSpecExprLenAssignement<1>(assign_spec_expr_len1, tests, passed);
-  TestSpecExprLenAssignement<2>(assign_spec_expr_len2, tests, passed);
-  TestSpecExprLenAssignement<4>(assign_spec_expr_len4, tests, passed);
+  TestSpecExprLenAssignement<1>(_QPassign_spec_expr_len1, tests, passed);
+  TestSpecExprLenAssignement<2>(_QPassign_spec_expr_len2, tests, passed);
+  TestSpecExprLenAssignement<4>(_QPassign_spec_expr_len4, tests, passed);
 
   std::cout << passed << " tests passed out of " << tests << std::endl;
   return tests == passed ? 0 : -1;
diff --git a/test/Lower/end-to-end-character-assignment.f90 b/test/Lower/end-to-end-character-assignment.f90
index 9399fc00ddfa..444993ad3298 100644
--- a/test/Lower/end-to-end-character-assignment.f90
+++ b/test/Lower/end-to-end-character-assignment.f90
@@ -1,4 +1,4 @@
-! RUN: bbc --disable-pass-threading -emit-llvm -o - %s | tco | llc | sed 's/_QP//g' | as -o %t
+! RUN: bbc -emit-llvm -o - %s | tco | llc | as -o %t
 ! RUN: %CXX -std=c++17 %t %S/end-to-end-character-assignment-driver.cpp
 ! RUN: ./a.out
 
diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 99cb858de2bc..5d72d4812cbe 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -20,7 +20,6 @@
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Transforms/Passes.h"
-#include "flang/Optimizer/Transforms/StdConverter.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/message.h"
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 322b766d04d1..7d3207c497c7 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -16,7 +16,6 @@
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Transforms/Passes.h"
-#include "flang/Optimizer/Transforms/StdConverter.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"

From e8b684427dbec37bbc2b4beaf471dbd4e16aafc0 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Fri, 3 Apr 2020 17:20:58 -0700
Subject: [PATCH 317/345] add string test

---
 include/flang/Optimizer/Dialect/FIROps.td | 9 ++++++---
 test/Fir/global.fir                       | 6 ++++++
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 9119bc0efdc3..82737d98d516 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2225,7 +2225,8 @@ def fir_StringLitOp : fir_Op<"string_lit", []> {
     else if (auto v = val.dyn_cast<mlir::ArrayAttr>())
       result.attributes.push_back(builder.getNamedAttr(xlist(), v));
     else
-      return mlir::failure();
+      return parser.emitError(parser.getCurrentLocation(),
+                              "found an invalid constant");
     mlir::IntegerAttr sz;
     mlir::Type type;
     if (parser.parseLParen() ||
@@ -2233,9 +2234,11 @@ def fir_StringLitOp : fir_Op<"string_lit", []> {
         parser.parseRParen() ||
         parser.parseColonType(type))
       return mlir::failure();
+    if (!(type.isa<fir::CharacterType>() || type.isa<mlir::IntegerType>()))
+      return parser.emitError(parser.getCurrentLocation(),
+                              "must have character type");
     type = fir::SequenceType::get({sz.getInt()}, type);
-    if (!type ||
-        parser.addTypesToList(type, result.types))
+    if (!type || parser.addTypesToList(type, result.types))
       return mlir::failure();
     return mlir::success();
   }];
diff --git a/test/Fir/global.fir b/test/Fir/global.fir
index d04ca50a820f..822a8f3e5612 100644
--- a/test/Fir/global.fir
+++ b/test/Fir/global.fir
@@ -26,3 +26,9 @@ fir.global common @C_i511 (511:i32) : i32
 
 // CHECK: @w_i86 = weak global i32 86
 fir.global weak @w_i86 (86:i32) : i32
+
+// CHECK: @str1 = global [6 x i8] c"Hello!"
+fir.global @str1 : !fir.array<6 x !fir.char<1>> {
+  %1 = fir.string_lit "Hello!"(6) : !fir.char<1>
+  fir.has_value %1 : !fir.array<6 x !fir.char<1>>
+}

From e19311bcec9617a2dacf834b46d3c20f664e2e1c Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Sat, 4 Apr 2020 16:44:54 -0700
Subject: [PATCH 318/345] fix for end-to-end test on macos start adding some
 code to support global string literals

---
 include/flang/Lower/Bridge.h |  2 ++
 lib/Lower/Bridge.cpp         | 23 +++++++++++++++++++++++
 lib/Lower/ConvertExpr.cpp    |  3 +++
 lib/Lower/Mangler.cpp        |  9 +++------
 test/lit.cfg.py              |  5 ++++-
 test/lit.site.cfg.py.in      |  1 +
 6 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/include/flang/Lower/Bridge.h b/include/flang/Lower/Bridge.h
index 48a004292ec5..8c4263616d86 100644
--- a/include/flang/Lower/Bridge.h
+++ b/include/flang/Lower/Bridge.h
@@ -116,6 +116,8 @@ class AbstractConverter {
   virtual mlir::ModuleOp &getModuleOp() = 0;
   /// Unique a symbol
   virtual std::string mangleName(const semantics::Symbol &) = 0;
+  /// Unique a compiler generated identifier
+  virtual std::string uniqueCGIdent(llvm::StringRef name) = 0;
 
   virtual ~AbstractConverter() = default;
 };
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index d1f938896659..d00183b4e99a 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -25,6 +25,7 @@
 #include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MD5.h"
 
 #undef TODO
 #define TODO()                                                                 \
@@ -45,6 +46,12 @@ static llvm::cl::opt<bool>
                           llvm::cl::desc("disable burnside bridge asserts"),
                           llvm::cl::init(false), llvm::cl::Hidden);
 
+static llvm::cl::opt<std::size_t>
+    nameLengthHashSize("length-to-hash-string-literal",
+		       llvm::cl::desc("string literals that exceed this length"
+				      " will use a hash value as their symbol "
+				      "name"), llvm::cl::init(32));
+
 namespace {
 /// Information for generating a structured or unstructured increment loop.
 struct IncrementLoopInfo {
@@ -186,6 +193,22 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return Fortran::lower::mangle::mangleName(uniquer, symbol);
   }
 
+  std::string uniqueCGIdent(llvm::StringRef name) override final {
+    // TODO: check for special characters
+    if ((name.size() > nameLengthHashSize) || name.contains('\0')){
+      llvm::MD5 hash;
+      hash.update(name);
+      llvm::MD5::MD5Result result;
+      hash.final(result);
+      llvm::SmallString<32> str;
+      llvm::MD5::stringifyResult(result, str);
+      std::string hashName = "h.";
+      hashName.append(str.c_str());
+      return uniquer.doGenerated(hashName);
+    }
+    return uniquer.doGenerated(name);
+  }
+
 private:
   FirConverter() = delete;
   FirConverter(const FirConverter &) = delete;
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 7f0fdc01d1eb..1b46fe033b6c 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -475,6 +475,9 @@ class ExprLowering {
     auto valTag = mlir::Identifier::get(fir::StringLitOp::value(), context);
     // FIXME: for wider char types, use an array of i16 or i32
     // for now, just fake it that it's a i8 to get it past the C++ compiler
+    if constexpr (KIND == 1) {
+    [[maybe_unused]] auto globalName = converter.uniqueCGIdent(data);
+    }
     auto strAttr = mlir::StringAttr::get((const char *)data.c_str(), context);
     mlir::NamedAttribute dataAttr(valTag, strAttr);
     auto sizeTag = mlir::Identifier::get(fir::StringLitOp::size(), context);
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index 03df71114f72..78f4424ac586 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -16,10 +16,8 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
 
-namespace {
-
 // recursively build the vector of module scopes
-void moduleNames(const Fortran::semantics::Scope &scope,
+static void moduleNames(const Fortran::semantics::Scope &scope,
                  llvm::SmallVector<llvm::StringRef, 2> &result) {
   if (scope.kind() == Fortran::semantics::Scope::Kind::Global) {
     return;
@@ -30,7 +28,7 @@ void moduleNames(const Fortran::semantics::Scope &scope,
       result.emplace_back(toStringRef(symbol->name()));
 }
 
-llvm::SmallVector<llvm::StringRef, 2>
+static llvm::SmallVector<llvm::StringRef, 2>
 moduleNames(const Fortran::semantics::Symbol &symbol) {
   const auto &scope = symbol.owner();
   llvm::SmallVector<llvm::StringRef, 2> result;
@@ -38,7 +36,7 @@ moduleNames(const Fortran::semantics::Symbol &symbol) {
   return result;
 }
 
-llvm::Optional<llvm::StringRef>
+static llvm::Optional<llvm::StringRef>
 hostName(const Fortran::semantics::Symbol &symbol) {
   const auto &scope = symbol.owner();
   if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
@@ -48,7 +46,6 @@ hostName(const Fortran::semantics::Symbol &symbol) {
   return {};
 }
 
-} // namespace
 
 static const Fortran::semantics::Symbol *
 findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index b2b0844a638e..cce759f0334f 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -67,7 +67,10 @@
 
 config.substitutions.append(('%B', config.flang_obj_root))
 config.substitutions.append(("%L", config.flang_lib_dir))
-config.substitutions.append(("%CXX", config.cplusplus_executable))
+if len(config.macos_sysroot) > 0:
+  config.substitutions.append(("%CXX", config.cplusplus_executable + " -isysroot " + config.macos_sysroot))
+else:
+  config.substitutions.append(("%CXX", config.cplusplus_executable))
 
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index 93a90648d9f5..d84f0cf43f82 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -11,6 +11,7 @@ config.flang_lib_dir = "@LLVM_LIBRARY_OUTPUT_INTDIR@"
 config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.cplusplus_executable = "@CMAKE_CXX_COMPILER@"
+config.macos_sysroot = "@CMAKE_OSX_SYSROOT@"
 
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.

From 8528d00d038dbf1f3db7d9b43393b555b60d3205 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Sat, 4 Apr 2020 16:53:08 -0700
Subject: [PATCH 319/345] [cleanup] remove references to code no longer used,
 etc.

---
 include/flang/Optimizer/Dialect/FIRDialect.h    | 14 --------------
 include/flang/Optimizer/Support/InternalNames.h |  4 ----
 include/flang/Optimizer/Support/KindMapping.h   |  2 --
 lib/Optimizer/Dialect/FIRAttr.cpp               |  5 -----
 lib/Optimizer/Dialect/FIRDialect.cpp            |  2 --
 lib/Optimizer/Dialect/FIROps.cpp                |  2 --
 lib/Optimizer/Dialect/FIRType.cpp               |  4 ----
 lib/Optimizer/Support/InternalNames.cpp         |  1 -
 lib/Optimizer/Support/KindMapping.cpp           |  1 -
 9 files changed, 35 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIRDialect.h b/include/flang/Optimizer/Dialect/FIRDialect.h
index 7a8fc18937fc..92fd23b5044f 100644
--- a/include/flang/Optimizer/Dialect/FIRDialect.h
+++ b/include/flang/Optimizer/Dialect/FIRDialect.h
@@ -13,20 +13,6 @@
 #include "mlir/InitAllDialects.h"
 #include "mlir/InitAllPasses.h"
 
-namespace llvm {
-class raw_ostream;
-class StringRef;
-} // namespace llvm
-
-namespace mlir {
-class Attribute;
-class DialectAsmParser;
-class DialectAsmPrinter;
-class Location;
-class MLIRContext;
-class Type;
-} // namespace mlir
-
 namespace fir {
 
 /// FIR dialect
diff --git a/include/flang/Optimizer/Support/InternalNames.h b/include/flang/Optimizer/Support/InternalNames.h
index 62724eea8fa4..a8cf22e96845 100644
--- a/include/flang/Optimizer/Support/InternalNames.h
+++ b/include/flang/Optimizer/Support/InternalNames.h
@@ -14,10 +14,6 @@
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 
-namespace llvm {
-class Twine;
-} // namespace llvm
-
 namespace fir {
 
 /// Internal name mangling of identifiers
diff --git a/include/flang/Optimizer/Support/KindMapping.h b/include/flang/Optimizer/Support/KindMapping.h
index d2ec04c6528f..08ac14ca6d5f 100644
--- a/include/flang/Optimizer/Support/KindMapping.h
+++ b/include/flang/Optimizer/Support/KindMapping.h
@@ -14,8 +14,6 @@
 #include "llvm/IR/Type.h"
 
 namespace llvm {
-template <typename>
-class Optional;
 struct fltSemantics;
 } // namespace llvm
 
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index 1ba242b9484b..e4a87d7fb859 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -8,16 +8,11 @@
 
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/AttributeSupport.h"
-#include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
-#include "mlir/Parser.h"
 #include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 
 using namespace fir;
 
diff --git a/lib/Optimizer/Dialect/FIRDialect.cpp b/lib/Optimizer/Dialect/FIRDialect.cpp
index 9a56c6bc403e..6364c24137f2 100644
--- a/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -10,8 +10,6 @@
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/IR/StandardTypes.h"
 
 using namespace fir;
 
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 1598ad086d08..6256df0ff75a 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -16,8 +16,6 @@
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace fir;
diff --git a/lib/Optimizer/Dialect/FIRType.cpp b/lib/Optimizer/Dialect/FIRType.cpp
index cf0af6df1528..974344cd5478 100644
--- a/lib/Optimizer/Dialect/FIRType.cpp
+++ b/lib/Optimizer/Dialect/FIRType.cpp
@@ -9,12 +9,8 @@
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "mlir/ADT/TypeSwitch.h"
-#include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
-#include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Parser.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/ErrorHandling.h"
diff --git a/lib/Optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
index 20c52ef36000..c58d7da2f857 100644
--- a/lib/Optimizer/Support/InternalNames.cpp
+++ b/lib/Optimizer/Support/InternalNames.cpp
@@ -8,7 +8,6 @@
 
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "mlir/IR/Diagnostics.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
 
 static llvm::cl::opt<std::string> mainEntryName("main-entry-name", llvm::cl::desc("override the name of the default PROGRAM entry (may be helpful for using other runtimes)"));
diff --git a/lib/Optimizer/Support/KindMapping.cpp b/lib/Optimizer/Support/KindMapping.cpp
index c3850ceea047..122d59a6fe6b 100644
--- a/lib/Optimizer/Support/KindMapping.cpp
+++ b/lib/Optimizer/Support/KindMapping.cpp
@@ -8,7 +8,6 @@
 
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
 
 /// Allow the user to set the FIR intrinsic type kind value to LLVM type

From 9af040b383ba8c0bb9e16d6dce9ce4cdb14a9bff Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Mon, 6 Apr 2020 11:28:35 -0700
Subject: [PATCH 320/345] bug fixes for GlobalOp; fix breakage make string
 literals globals

---
 include/flang/Lower/FIRBuilder.h          | 29 ++++++++++++++++----
 include/flang/Optimizer/Dialect/FIROps.td | 32 ++++++++++++++--------
 lib/Lower/Bridge.cpp                      |  9 ++++---
 lib/Lower/ConvertExpr.cpp                 | 33 +++++++++++++++++++----
 lib/Lower/FIRBuilder.cpp                  | 30 ++++++++++++++++++++-
 lib/Lower/Mangler.cpp                     |  3 +--
 lib/Optimizer/CodeGen.cpp                 |  5 ++--
 lib/Optimizer/Dialect/FIROps.cpp          | 32 ++++++++++++----------
 8 files changed, 128 insertions(+), 45 deletions(-)

diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index f6f6dd87460e..2f52d9b09c35 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -266,16 +266,28 @@ class FirOpBuilder : public mlir::OpBuilder,
 
   /// Create a global value.
   fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
-                             llvm::StringRef name, mlir::Attribute value = {},
+                             llvm::StringRef name,
                              mlir::StringAttr linkage = {},
-                             bool isConst = false);
+                             mlir::Attribute value = {}, bool isConst = false);
+
+  fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
+			     llvm::StringRef name, bool isConst,
+			     std::function<void(FirOpBuilder&)> bodyBuilder,
+			     mlir::StringAttr linkage = {});
 
   /// Create a global constant (read-only) value.
   fir::GlobalOp createGlobalConstant(mlir::Location loc, mlir::Type type,
                                      llvm::StringRef name,
-                                     mlir::Attribute value = {},
-                                     mlir::StringAttr linkage = {}) {
-    return createGlobal(loc, type, name, value, linkage, /*isConst=*/true);
+                                     mlir::StringAttr linkage = {},
+                                     mlir::Attribute value = {}) {
+    return createGlobal(loc, type, name, linkage, value, /*isConst=*/true);
+  }
+
+  fir::GlobalOp createGlobalConstant(mlir::Location loc, mlir::Type type,
+			     llvm::StringRef name,
+			     std::function<void(FirOpBuilder&)> bodyBuilder,
+				     mlir::StringAttr linkage = {}) {
+    return createGlobal(loc, type, name, /*isConst=*/true, bodyBuilder, linkage);
   }
 
   mlir::Block *createBlock() {
@@ -291,6 +303,13 @@ class FirOpBuilder : public mlir::OpBuilder,
   static mlir::FuncOp getNamedFunction(mlir::ModuleOp module,
                                        llvm::StringRef name);
 
+  fir::GlobalOp getNamedGlobal(llvm::StringRef name) {
+    return getNamedGlobal(getModule(), name);
+  }
+
+  static fir::GlobalOp getNamedGlobal(mlir::ModuleOp module,
+				      llvm::StringRef name);
+
   /// Create a new FuncOp. If the function may have already been created, use
   /// `addNamedFunction` instead.
   mlir::FuncOp createFunction(mlir::Location loc, llvm::StringRef name,
diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 82737d98d516..7d72aca4ea08 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2658,13 +2658,14 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
 
   let arguments = (ins
     StrAttr:$sym_name,
+    SymbolRefAttr:$symref,
     TypeAttr:$type,
     OptionalAttr<AnyAttr>:$initVal,
     OptionalAttr<UnitAttr>:$constant,
     OptionalAttr<StrAttr>:$linkName
   );
 
-  let results = (outs fir_ReferenceType:$resultType);
+  let results = (outs fir_ReferenceType:$resval);
 
   let regions = (region AtMostRegion<1>:$region);
 
@@ -2674,19 +2675,17 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
     p << getOperationName();
     if (linkName().hasValue())
       p << ' ' << linkName().getValue();
-    auto varName = getAttrOfType<StringAttr>(
-      mlir::SymbolTable::getSymbolAttrName()).getValue();
-    p << " @" << varName;
+    p << ' ';
+    p.printAttributeWithoutType(getAttr(symbolAttrName()));
     if (auto val = getValueOrNull())
       p << '(' << val << ')';
     if (getAttr(constantAttrName()))
       p << " constant";
     p << " : ";
     p.printType(getType());
-    Region &body = getOperation()->getRegion(0);
-    if (!body.empty())
-      p.printRegion(body, /*printEntryBlockArgs=*/false,
-                          /*printBlockTerminators=*/true);
+    if (hasInitializationBody())
+      p.printRegion(getOperation()->getRegion(0), /*printEntryBlockArgs=*/false,
+                    /*printBlockTerminators=*/true);
   }];
 
   let skipDefaultBuilders = 1;
@@ -2714,6 +2713,7 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
   ];
 
   let extraClassDeclaration = [{
+    static constexpr llvm::StringRef symbolAttrName() { return "symref"; }
     static constexpr llvm::StringRef constantAttrName() { return "constant"; }
     static constexpr llvm::StringRef initValAttrName() { return "initVal"; }
     static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
@@ -2722,11 +2722,11 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
     mlir::Type getType() {
       return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
+
+    mlir::Type resultType() { return resval().getType(); }
     
     /// Return the initializer attribute if it exists, or a null attribute.
-    Attribute getValueOrNull() {
-      return initVal().getValueOr(Attribute());
-    }
+    Attribute getValueOrNull() { return initVal().getValueOr(Attribute()); }
 
     /// Append the next initializer value to the `GlobalOp` to construct
     /// the variable's initial value.
@@ -2740,6 +2740,16 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
 
     /// Determine if `linkage` is a supported keyword
     static mlir::ParseResult verifyValidLinkage(StringRef linkage);
+
+    bool hasInitializationBody() {
+      return (getOperation()->getNumRegions() == 1) && !getRegion().empty() &&
+        !isa<fir::FirEndOp>(getBlock().front());
+    }
+
+    mlir::FlatSymbolRefAttr getSymbol() {
+      return mlir::FlatSymbolRefAttr::get(getAttrOfType<mlir::StringAttr>(
+          mlir::SymbolTable::getSymbolAttrName()).getValue(), getContext());
+    }
   }];
 }
 
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index d00183b4e99a..d8e577c7c963 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -48,9 +48,10 @@ static llvm::cl::opt<bool>
 
 static llvm::cl::opt<std::size_t>
     nameLengthHashSize("length-to-hash-string-literal",
-		       llvm::cl::desc("string literals that exceed this length"
-				      " will use a hash value as their symbol "
-				      "name"), llvm::cl::init(32));
+                       llvm::cl::desc("string literals that exceed this length"
+                                      " will use a hash value as their symbol "
+                                      "name"),
+                       llvm::cl::init(32));
 
 namespace {
 /// Information for generating a structured or unstructured increment loop.
@@ -195,7 +196,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   std::string uniqueCGIdent(llvm::StringRef name) override final {
     // TODO: check for special characters
-    if ((name.size() > nameLengthHashSize) || name.contains('\0')){
+    if ((name.size() > nameLengthHashSize) || name.contains('\0')) {
       llvm::MD5 hash;
       hash.update(name);
       llvm::MD5::MD5Result result;
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 1b46fe033b6c..f6c8baee4f75 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -471,20 +471,43 @@ class ExprLowering {
   /// Construct a CHARACTER literal
   template <int KIND, typename E>
   mlir::Value genCharLit(const E &data, int64_t size) {
-    auto context = builder.getContext();
-    auto valTag = mlir::Identifier::get(fir::StringLitOp::value(), context);
+    auto type = fir::SequenceType::get(
+        {size}, fir::CharacterType::get(builder.getContext(), KIND));
     // FIXME: for wider char types, use an array of i16 or i32
     // for now, just fake it that it's a i8 to get it past the C++ compiler
     if constexpr (KIND == 1) {
-    [[maybe_unused]] auto globalName = converter.uniqueCGIdent(data);
+      auto globalName = converter.uniqueCGIdent(data);
+      auto global = builder.getNamedGlobal(globalName);
+      if (!global)
+        global = builder.createGlobalConstant(
+            getLoc(), type, globalName,
+            [&](Fortran::lower::FirOpBuilder &builder) {
+              auto context = builder.getContext();
+              auto strAttr = mlir::StringAttr::get(data.c_str(), context);
+              auto valTag =
+                  mlir::Identifier::get(fir::StringLitOp::value(), context);
+              mlir::NamedAttribute dataAttr(valTag, strAttr);
+              auto sizeTag =
+                  mlir::Identifier::get(fir::StringLitOp::size(), context);
+              mlir::NamedAttribute sizeAttr(sizeTag,
+                                            builder.getI64IntegerAttr(size));
+              llvm::SmallVector<mlir::NamedAttribute, 2> attrs{dataAttr,
+                                                               sizeAttr};
+              auto str = builder.create<fir::StringLitOp>(
+                  getLoc(), llvm::ArrayRef<mlir::Type>{type}, llvm::None,
+                  attrs);
+              builder.create<fir::HasValueOp>(getLoc(), str);
+            });
+      return builder.create<fir::AddrOfOp>(getLoc(), global.resultType(),
+                                           global.getSymbol());
     }
+    auto context = builder.getContext();
+    auto valTag = mlir::Identifier::get(fir::StringLitOp::value(), context);
     auto strAttr = mlir::StringAttr::get((const char *)data.c_str(), context);
     mlir::NamedAttribute dataAttr(valTag, strAttr);
     auto sizeTag = mlir::Identifier::get(fir::StringLitOp::size(), context);
     mlir::NamedAttribute sizeAttr(sizeTag, builder.getI64IntegerAttr(size));
     llvm::SmallVector<mlir::NamedAttribute, 2> attrs{dataAttr, sizeAttr};
-    auto type =
-        fir::SequenceType::get({size}, fir::CharacterType::get(context, KIND));
     return builder.create<fir::StringLitOp>(
         getLoc(), llvm::ArrayRef<mlir::Type>{type}, llvm::None, attrs);
   }
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index 464ac5b09113..30d2771c3176 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -36,6 +36,12 @@ Fortran::lower::FirOpBuilder::getNamedFunction(mlir::ModuleOp modOp,
   return modOp.lookupSymbol<mlir::FuncOp>(name);
 }
 
+fir::GlobalOp
+Fortran::lower::FirOpBuilder::getNamedGlobal(mlir::ModuleOp modOp,
+					     llvm::StringRef name) {
+  return modOp.lookupSymbol<fir::GlobalOp>(name);
+}
+
 mlir::Type Fortran::lower::FirOpBuilder::getRefType(mlir::Type eleTy) {
   return fir::ReferenceType::get(eleTy);
 }
@@ -76,7 +82,7 @@ mlir::Value Fortran::lower::FirOpBuilder::createTemporary(
 
 fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
     mlir::Location loc, mlir::Type type, llvm::StringRef name,
-    mlir::Attribute value, mlir::StringAttr linkage, bool isConst) {
+    mlir::StringAttr linkage, mlir::Attribute value, bool isConst) {
   auto module = getModule();
   auto insertPt = saveInsertionPoint();
   if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
@@ -87,6 +93,28 @@ fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
   return glob;
 }
 
+fir::GlobalOp
+Fortran::lower::FirOpBuilder::createGlobal(mlir::Location loc, mlir::Type type,
+			     llvm::StringRef name, bool isConst,
+			     std::function<void(FirOpBuilder &)> bodyBuilder,
+					   mlir::StringAttr linkage) {
+  auto module = getModule();
+  auto insertPt = saveInsertionPoint();
+  if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
+    return glob;
+  setInsertionPoint(module.getBody()->getTerminator());
+  auto glob = create<fir::GlobalOp>(loc, name, isConst, type, mlir::Attribute{},
+				    linkage);
+  auto &region = glob.getRegion();
+  region.push_back(new mlir::Block);
+  auto &block = glob.getRegion().back();
+  setInsertionPointToStart(&block);
+  bodyBuilder(*this);
+  restoreInsertionPoint(insertPt);
+  return glob;
+}
+
+
 //===----------------------------------------------------------------------===//
 // LoopOp builder
 //===----------------------------------------------------------------------===//
diff --git a/lib/Lower/Mangler.cpp b/lib/Lower/Mangler.cpp
index 78f4424ac586..36bf6aba9ee7 100644
--- a/lib/Lower/Mangler.cpp
+++ b/lib/Lower/Mangler.cpp
@@ -18,7 +18,7 @@
 
 // recursively build the vector of module scopes
 static void moduleNames(const Fortran::semantics::Scope &scope,
-                 llvm::SmallVector<llvm::StringRef, 2> &result) {
+                        llvm::SmallVector<llvm::StringRef, 2> &result) {
   if (scope.kind() == Fortran::semantics::Scope::Kind::Global) {
     return;
   }
@@ -46,7 +46,6 @@ hostName(const Fortran::semantics::Symbol &symbol) {
   return {};
 }
 
-
 static const Fortran::semantics::Symbol *
 findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
   const auto &scope = symbol.owner();
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index 3da1b90a9b96..db814eeed6f2 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -58,8 +58,7 @@ namespace fir {
 bool allConstants(OperandTy operands) {
   for (auto opnd : operands) {
     if (auto defop = opnd.getDefiningOp())
-      if (isa<mlir::LLVM::ConstantOp>(defop) ||
-          isa<mlir::ConstantOp>(defop))
+      if (isa<mlir::LLVM::ConstantOp>(defop) || isa<mlir::ConstantOp>(defop))
         continue;
     return false;
   }
@@ -238,7 +237,7 @@ class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
     mlir::Type eleTy = ty.getEleTy();
     if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
       if (!seqTy.hasConstantShape() && seqTy.hasConstantInterior())
-	return unwrap(convertType(seqTy));
+        return unwrap(convertType(seqTy));
     }
     return unwrap(convertType(eleTy)).getPointerTo();
   }
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 6256df0ff75a..20df703d3284 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -316,8 +316,8 @@ mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
 // CoordinateOp
 //===----------------------------------------------------------------------===//
 
-static mlir::ParseResult
-parseCoordinateOp(mlir::OpAsmParser &parser, mlir::OperationState &result) {
+static mlir::ParseResult parseCoordinateOp(mlir::OpAsmParser &parser,
+                                           mlir::OperationState &result) {
   llvm::ArrayRef<mlir::Type> allOperandTypes;
   llvm::ArrayRef<mlir::Type> allResultTypes;
   llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
@@ -336,12 +336,12 @@ parseCoordinateOp(mlir::OpAsmParser &parser, mlir::OperationState &result) {
   allResultTypes = funcTy.getResults();
   result.addTypes(allResultTypes);
   if (parser.resolveOperands(allOperands, allOperandTypes, allOperandLoc,
-			     result.operands))
+                             result.operands))
     return failure();
   if (funcTy.getNumInputs()) {
     // No inputs handled by verify
     result.addAttribute(fir::CoordinateOp::baseType(),
-			mlir::TypeAttr::get(funcTy.getInput(0)));
+                        mlir::TypeAttr::get(funcTy.getInput(0)));
   }
   return success();
 }
@@ -350,18 +350,20 @@ mlir::Type fir::CoordinateOp::getBaseType() {
   return getAttr(CoordinateOp::baseType()).cast<mlir::TypeAttr>().getValue();
 }
 
-void fir::CoordinateOp::build(Builder *, OperationState &result, mlir::Type resType,
-			 ValueRange operands, ArrayRef<NamedAttribute> attrs) {
+void fir::CoordinateOp::build(Builder *, OperationState &result,
+                              mlir::Type resType, ValueRange operands,
+                              ArrayRef<NamedAttribute> attrs) {
   assert(operands.size() >= 1u && "mismatched number of parameters");
   result.addOperands(operands);
-  result.addAttribute(fir::CoordinateOp::baseType(), mlir::TypeAttr::get(operands[0].getType()));
+  result.addAttribute(fir::CoordinateOp::baseType(),
+                      mlir::TypeAttr::get(operands[0].getType()));
   result.attributes.append(attrs.begin(), attrs.end());
   result.addTypes({resType});
 }
 
 void fir::CoordinateOp::build(Builder *builder, OperationState &result,
-			      mlir::Type resType, mlir::Value ref, ValueRange coor,
-			 ArrayRef<NamedAttribute> attrs) {
+                              mlir::Type resType, mlir::Value ref,
+                              ValueRange coor, ArrayRef<NamedAttribute> attrs) {
   llvm::SmallVector<mlir::Value, 16> operands{ref};
   operands.append(coor.begin(), coor.end());
   build(builder, result, resType, operands, attrs);
@@ -453,13 +455,12 @@ static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
   }
 
   // Parse the name as a symbol reference attribute.
-  SymbolRefAttr nameAttr;
-  if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
+  mlir::SymbolRefAttr nameAttr;
+  if (parser.parseAttribute(nameAttr, fir::GlobalOp::symbolAttrName(),
                             result.attributes))
     return failure();
-
-  auto name = nameAttr.getRootReference();
-  result.attributes.back().second = builder.getStringAttr(name);
+  result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                      builder.getStringAttr(nameAttr.getRootReference()));
 
   bool simpleInitializer = false;
   if (mlir::succeeded(parser.parseOptionalLParen())) {
@@ -506,9 +507,11 @@ void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
                           Attribute initialVal, StringAttr linkage,
                           ArrayRef<NamedAttribute> attrs) {
+  result.addRegion();
   result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       builder->getStringAttr(name));
+  result.addAttribute(symbolAttrName(), builder->getSymbolRefAttr(name));
   if (isConstant)
     result.addAttribute(constantAttrName(), builder->getUnitAttr());
   if (initialVal)
@@ -516,6 +519,7 @@ void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
+  result.addTypes({AllocaOp::wrapResultType(type)});
 }
 
 void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,

From a5cb96d70c8706ddbf865473693155faafff4357 Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Mon, 6 Apr 2020 20:41:22 -0700
Subject: [PATCH 321/345] fix test to reflect new lowering

---
 test/Lower/character-assignment.f90 | 35 ++++++++++++++++-------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/test/Lower/character-assignment.f90 b/test/Lower/character-assignment.f90
index 8927b0541406..d1633643e442 100644
--- a/test/Lower/character-assignment.f90
+++ b/test/Lower/character-assignment.f90
@@ -10,8 +10,8 @@ subroutine assign1(lhs, rhs)
   ! CHECK-DAG:[[rhs:%[0-9]+]]:2 = fir.unboxchar %arg1
 
   ! Compute minimum length
-  ! CHECK-DAG:[[cmp_len:%[0-9]+]] = cmpi "slt", [[lhs]]#1, [[rhs]]#1
-  ! CHECK-DAG:[[min_len:%[0-9]+]] = select %2, [[lhs]]#1, [[rhs]]#1
+  ! CHECK-DAG:%[[cmp_len:[0-9]+]] = cmpi "slt", [[lhs]]#1, [[rhs]]#1
+  ! CHECK-DAG:[[min_len:%[0-9]+]] = select %[[cmp_len]], [[lhs]]#1, [[rhs]]#1
 
   ! Allocate temp in case rhs and lhs may overlap
   ! CHECK: [[tmp:%[0-9]+]] = fir.alloca !fir.char<1>, [[min_len]]
@@ -78,26 +78,29 @@ subroutine assign_substring1(str, rhs, lb, ub)
 end subroutine
 
 ! CHECK-LABEL: assign_constant
+! CHECK: (%[[ARG:.*]]:{{.*}})
 subroutine assign_constant(lhs)
   character(*, 1) :: lhs
-  ! CHECK-DAG:[[lhs:%[0-9]+]]:2 = fir.unboxchar %arg0
+  ! CHECK-DAG: %[[lhs:.*]]:2 = fir.unboxchar %[[ARG]] :
+  ! CHECK-DAG: %[[tmp:.*]] = fir.address_of(@{{.*}}) :
   lhs = "Hello World"
-  ! CHECK-DAG: [[cst:%[0-9]+]] = fir.string_lit "Hello World"(11) : !fir.char<1>
-  ! CHECK-DAG: [[tmp:%[0-9]+]] = fir.alloca !fir.array<11x!fir.char<1>>
-  ! CHECK: fir.store [[cst]] to [[tmp]]
-  ! CHECK: fir.loop [[i:%[[:alnum:]]+]]
-    ! CHECK-DAG: [[tmp_addr:%[0-9]+]] = fir.coordinate_of [[tmp]], [[i]]
-    ! CHECK-DAG: [[lhs_addr:%[0-9]+]] = fir.coordinate_of [[lhs]]#0, [[i]]
-    ! CHECK-DAG: [[tmp_elt:%[0-9]+]] = fir.load [[tmp_addr]]
-    ! CHECK: fir.store [[tmp_elt]] to [[lhs_addr]]
+  ! CHECK: fir.loop %[[i:.*]] = %{{.*}} to %{{.*}} {
+    ! CHECK-DAG: %[[tmp_addr:.*]] = fir.coordinate_of %[[tmp]], %[[i]]
+    ! CHECK-DAG: %[[tmp_elt:.*]] = fir.load %[[tmp_addr]]
+    ! CHECK-DAG: %[[lhs_addr:.*]] = fir.coordinate_of %[[lhs]]#0, %[[i]]
+    ! CHECK: fir.store %[[tmp_elt]] to %[[lhs_addr]]
   ! CHECK: }
 
   ! Padding
-  ! CHECK: [[c32:%[[:alnum:]_]+]] = constant 32 : i8
-  ! CHECK: [[blank:%[0-9]+]] = fir.convert [[c32]] : (i8) -> !fir.char<1>
-  ! CHECK: fir.loop [[i:%[[:alnum:]_]+]]
-    ! CHECK-DAG: [[lhs_addr:%[0-9]+]] = fir.coordinate_of [[lhs]]#0, [[i]]
-    ! CHECK: fir.store [[blank]] to [[lhs_addr]]
+  ! CHECK-DAG: %[[c32:.*]] = constant 32 : i8
+  ! CHECK-DAG: %[[blank:.*]] = fir.convert %[[c32]] : (i8) -> !fir.char<1>
+  ! CHECK: fir.loop %[[j:.*]] = %{{.*}} to %{{.*}} {
+    ! CHECK: %[[jhs_addr:.*]] = fir.coordinate_of %[[lhs]]#0, %[[j]]
+    ! CHECK: fir.store %[[blank]] to %[[jhs_addr]]
   ! CHECK: }
 end subroutine
 
+! CHECK-LABEL: fir.global @"_QQhello world"
+! CHECK: %[[lit:.*]] = fir.string_lit "Hello World"(11) : !fir.char<1>
+! CHECK: fir.has_value %[[lit]] : !fir.array<11x!fir.char<1>>
+! CHECK: }

From e100de1cfa6b37ba3394e76b4d92d35d8a4c86de Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 08:38:53 -0700
Subject: [PATCH 322/345] fix hello example on ubuntu

---
 lib/Lower/Bridge.cpp                    | 7 ++++---
 lib/Lower/ConvertExpr.cpp               | 2 +-
 lib/Optimizer/Support/InternalNames.cpp | 2 +-
 test/CMakeLists.txt                     | 6 ++----
 test/Examples/hello.f90                 | 4 ++--
 test/Lower/character-assignment.f90     | 2 +-
 test/lit.cfg.py                         | 2 ++
 test/lit.site.cfg.py.in                 | 1 +
 8 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index d8e577c7c963..cdfb94a7c131 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -195,8 +195,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
 
   std::string uniqueCGIdent(llvm::StringRef name) override final {
-    // TODO: check for special characters
-    if ((name.size() > nameLengthHashSize) || name.contains('\0')) {
+    // For "long" identifiers use a hash value
+    if (name.size() > nameLengthHashSize) {
       llvm::MD5 hash;
       hash.update(name);
       llvm::MD5::MD5Result result;
@@ -207,7 +207,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       hashName.append(str.c_str());
       return uniquer.doGenerated(hashName);
     }
-    return uniquer.doGenerated(name);
+    // "Short" identifiers use a reversible hex string
+    return uniquer.doGenerated(llvm::toHex(name));
   }
 
 private:
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index f6c8baee4f75..9395f4a1f770 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -476,7 +476,7 @@ class ExprLowering {
     // FIXME: for wider char types, use an array of i16 or i32
     // for now, just fake it that it's a i8 to get it past the C++ compiler
     if constexpr (KIND == 1) {
-      auto globalName = converter.uniqueCGIdent(data);
+      std::string globalName = converter.uniqueCGIdent(data);
       auto global = builder.getNamedGlobal(globalName);
       if (!global)
         global = builder.createGlobalConstant(
diff --git a/lib/Optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
index c58d7da2f857..47b8504c0e14 100644
--- a/lib/Optimizer/Support/InternalNames.cpp
+++ b/lib/Optimizer/Support/InternalNames.cpp
@@ -113,7 +113,7 @@ fir::NameUniquer::doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
 
 std::string fir::NameUniquer::doGenerated(llvm::StringRef name) {
   std::string result = prefix();
-  return result.append("Q").append(toLower(name));
+  return result.append("Q").append(name);
 }
 
 std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b4ee48f992b9..758dfbbec75d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -19,12 +19,10 @@ set(FLANG_TEST_PARAMS
 
 set(FLANG_TEST_DEPENDS
   f18
+  tco
+  bbc
 )
 
-if (LINK_WITH_FIR)
-  list(APPEND FLANG_TEST_DEPENDS tco)
-endif()
-
 add_custom_target(flang-test-depends DEPENDS ${FLANG_TEST_DEPENDS})
 
 add_lit_testsuite(check-flang "Running the Flang regression tests"
diff --git a/test/Examples/hello.f90 b/test/Examples/hello.f90
index 120e5f279f56..62dff1f1ff23 100644
--- a/test/Examples/hello.f90
+++ b/test/Examples/hello.f90
@@ -5,8 +5,8 @@
 ! Note: On linux, the Fortran runtime wants to include libm as well.
 
 ! RUN: bbc %s -o - | tco | llc --filetype=obj -o %t.o
-! RUN: cc -I%S/../.. %S/main.c -c -o %t.main.o
-! RUN: cc %t.o %t.main.o -L%L -lFortranRuntime -lFortranDecimal -lstdc++ -lm
+! RUN: %CC -I%S/../.. %S/main.c -c -o %t.main.o
+! RUN: %CC %t.o %t.main.o -L%L -lFortranRuntime -lFortranDecimal -lstdc++ -lm
 ! RUN: ./a.out | FileCheck %s
 
 ! CHECK: Hello, World!
diff --git a/test/Lower/character-assignment.f90 b/test/Lower/character-assignment.f90
index d1633643e442..9c455ac1bae4 100644
--- a/test/Lower/character-assignment.f90
+++ b/test/Lower/character-assignment.f90
@@ -100,7 +100,7 @@ subroutine assign_constant(lhs)
   ! CHECK: }
 end subroutine
 
-! CHECK-LABEL: fir.global @"_QQhello world"
+! CHECK-LABEL: fir.global @_QQ48656C6C6F20576F726C64
 ! CHECK: %[[lit:.*]] = fir.string_lit "Hello World"(11) : !fir.char<1>
 ! CHECK: fir.has_value %[[lit]] : !fir.array<11x!fir.char<1>>
 ! CHECK: }
diff --git a/test/lit.cfg.py b/test/lit.cfg.py
index cce759f0334f..4d6e12154633 100644
--- a/test/lit.cfg.py
+++ b/test/lit.cfg.py
@@ -69,8 +69,10 @@
 config.substitutions.append(("%L", config.flang_lib_dir))
 if len(config.macos_sysroot) > 0:
   config.substitutions.append(("%CXX", config.cplusplus_executable + " -isysroot " + config.macos_sysroot))
+  config.substitutions.append(("%CC", config.c_executable + " -isysroot " + config.macos_sysroot))
 else:
   config.substitutions.append(("%CXX", config.cplusplus_executable))
+  config.substitutions.append(("%CC", config.c_executable))
 
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
diff --git a/test/lit.site.cfg.py.in b/test/lit.site.cfg.py.in
index d84f0cf43f82..c7a16f99d207 100644
--- a/test/lit.site.cfg.py.in
+++ b/test/lit.site.cfg.py.in
@@ -10,6 +10,7 @@ config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 config.flang_lib_dir = "@LLVM_LIBRARY_OUTPUT_INTDIR@"
 config.flang_llvm_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
+config.c_executable = "@CMAKE_C_COMPILER@"
 config.cplusplus_executable = "@CMAKE_CXX_COMPILER@"
 config.macos_sysroot = "@CMAKE_OSX_SYSROOT@"
 

From d94efce94e08d03bfd2272ff89926104e2a235cb Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 13:03:43 -0700
Subject: [PATCH 323/345] disambiguate alloca

---
 lib/Optimizer/Dialect/FIROps.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 20df703d3284..09332b99e87e 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -493,7 +493,7 @@ static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
       return failure();
   }
 
-  auto refTy = AllocaOp::wrapResultType(globalType);
+  auto refTy = fir::AllocaOp::wrapResultType(globalType);
   if (parser.addTypeToList(refTy, result.types))
     return failure();
   return success();
@@ -519,7 +519,7 @@ void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
-  result.addTypes({AllocaOp::wrapResultType(type)});
+  result.addTypes({fir::AllocaOp::wrapResultType(type)});
 }
 
 void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,

From 2669cacbf2fb286dc112e5adc3e1cc720017a088 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 15:11:26 -0700
Subject: [PATCH 324/345] rebase llvm-project/mono

---
 include/flang/Optimizer/Dialect/FIROps.td |  8 +++++---
 lib/Optimizer/CodeGen.cpp                 | 13 ++++++++++---
 lib/Optimizer/Dialect/FIROps.cpp          |  4 ----
 lib/Optimizer/StdConverter.cpp            | 11 +++++++++--
 4 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 7d72aca4ea08..8cdbf5b9527e 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -2665,8 +2665,6 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
     OptionalAttr<StrAttr>:$linkName
   );
 
-  let results = (outs fir_ReferenceType:$resval);
-
   let regions = (region AtMostRegion<1>:$region);
 
   let parser = "return parseGlobalOp(parser, result);";
@@ -2719,11 +2717,15 @@ def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
     static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
     static constexpr llvm::StringRef typeAttrName() { return "type"; }
 
+    /// The printable type of the global
     mlir::Type getType() {
       return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
 
-    mlir::Type resultType() { return resval().getType(); }
+    /// The semantic type of the global
+    mlir::Type resultType() {
+      return fir::AllocaOp::wrapResultType(getType());
+    }
     
     /// Return the initializer attribute if it exists, or a null attribute.
     Attribute getValueOrNull() { return initVal().getValueOr(Attribute()); }
diff --git a/lib/Optimizer/CodeGen.cpp b/lib/Optimizer/CodeGen.cpp
index db814eeed6f2..445117090fd5 100644
--- a/lib/Optimizer/CodeGen.cpp
+++ b/lib/Optimizer/CodeGen.cpp
@@ -510,6 +510,13 @@ class FIROpAndTypeConversion : public FIROpConversion<FromOp> {
 };
 } // namespace
 
+static Block *createBlock(mlir::ConversionPatternRewriter &rewriter,
+                          mlir::Block *insertBefore) {
+  assert(insertBefore && "expected valid insertion block");
+  return rewriter.createBlock(insertBefore->getParent(),
+                              mlir::Region::iterator(insertBefore));
+}
+
 /// Create an LLVM dialect global
 static void createGlobal(mlir::Location loc, mlir::ModuleOp mod, StringRef name,
                          mlir::LLVM::LLVMType type,
@@ -1778,7 +1785,7 @@ void genCaseLadderStep(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
                        llvm::Optional<OperandTy> destOps,
                        mlir::ConversionPatternRewriter &rewriter) {
   auto *thisBlock = rewriter.getInsertionBlock();
-  auto *newBlock = rewriter.createBlock(dest);
+  auto *newBlock = createBlock(rewriter, dest);
   rewriter.setInsertionPointToEnd(thisBlock);
   genCondBrOp(loc, cmp, dest, destOps, rewriter, newBlock);
   rewriter.setInsertionPointToEnd(newBlock);
@@ -1829,8 +1836,8 @@ struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
         auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
             loc, mlir::LLVM::ICmpPredicate::sle, caseArg, selector);
         auto *thisBlock = rewriter.getInsertionBlock();
-        auto *newBlock1 = rewriter.createBlock(dest);
-        auto *newBlock2 = rewriter.createBlock(dest);
+        auto *newBlock1 = createBlock(rewriter, dest);
+        auto *newBlock2 = createBlock(rewriter, dest);
         rewriter.setInsertionPointToEnd(thisBlock);
         rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, newBlock1, newBlock2);
         rewriter.setInsertionPointToEnd(newBlock1);
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 09332b99e87e..a007db7f1201 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -493,9 +493,6 @@ static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
       return failure();
   }
 
-  auto refTy = fir::AllocaOp::wrapResultType(globalType);
-  if (parser.addTypeToList(refTy, result.types))
-    return failure();
   return success();
 }
 
@@ -519,7 +516,6 @@ void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
-  result.addTypes({fir::AllocaOp::wrapResultType(type)});
 }
 
 void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
diff --git a/lib/Optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
index ead2b4d38f12..0398735234b9 100644
--- a/lib/Optimizer/StdConverter.cpp
+++ b/lib/Optimizer/StdConverter.cpp
@@ -6,12 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/StandardTypes.h"
@@ -93,6 +93,13 @@ class FIROpConversion : public mlir::ConversionPattern {
                           ctx) /*, lowering(lowering)*/
   {}
 
+  static Block *createBlock(mlir::ConversionPatternRewriter &rewriter,
+                     Block *insertBefore) {
+    assert(insertBefore && "expected valid insertion block");
+    return rewriter.createBlock(insertBefore->getParent(),
+                                mlir::Region::iterator(insertBefore));
+  }
+
 protected:
   // mlir::Type convertType(mlir::Type ty) const { return
   // lowering.convertType(ty); }
@@ -167,7 +174,7 @@ struct SelectTypeOpConversion : public FIROpConversion<SelectTypeOp> {
     auto cmp = rewriter.create<mlir::CallOp>(
         loc, fty, rewriter.getSymbolRefAttr(funName), actuals);
     auto *thisBlock = rewriter.getInsertionBlock();
-    auto *newBlock = rewriter.createBlock(dest);
+    auto *newBlock = createBlock(rewriter, dest);
     rewriter.setInsertionPointToEnd(thisBlock);
     if (destOps.hasValue())
       rewriter.create<mlir::CondBranchOp>(loc, cmp.getResult(0), dest,

From d04a5e6185211883bd2c4ead0f0b37dbcf399baa Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 16:42:27 -0700
Subject: [PATCH 325/345] fallout from parse tree changes

---
 lib/Lower/IO.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index 9ee104023402..c4013907a29e 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -654,8 +654,12 @@ static const auto *getIOControl(const A &stmt) {
 
 template <typename A>
 static bool formatIsActuallyNamelist(const A &format) {
-  if (auto *e = std::get_if<Fortran::parser::DefaultCharExpr>(&format.u)) {
-    // TODO
+  if (auto *e = std::get_if<Fortran::parser::Expr>(&format.u)) {
+    auto *expr = Fortran::semantics::GetExpr(*e);
+    if (Fortran::evaluate::IsVariable(*expr)) {
+      TODO();
+      // TODO: fish out the symbol and determine if it has namelist details
+    }
   }
   return false;
 }
@@ -755,7 +759,7 @@ static std::tuple<mlir::Value, mlir::Value, mlir::Value>
 genFormat(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
           const Fortran::parser::Format &format, mlir::Type ty0,
           mlir::Type ty1) {
-  if (auto *e = std::get_if<Fortran::parser::DefaultCharExpr>(&format.u))
+  if (auto *e = std::get_if<Fortran::parser::Expr>(&format.u))
     return lowerStringLit(converter, loc, *e, ty0, ty1);
   TODO(); // handle Label case
 }

From 240f25999cbd5585c94a2c620d8702b15ba8aace Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 16:43:12 -0700
Subject: [PATCH 326/345] add a simplified interface for SelectCaseOp building

---
 include/flang/Optimizer/Dialect/FIROps.td | 53 ++-------------
 lib/Optimizer/Dialect/FIROps.cpp          | 79 +++++++++++++++++++++++
 2 files changed, 86 insertions(+), 46 deletions(-)

diff --git a/include/flang/Optimizer/Dialect/FIROps.td b/include/flang/Optimizer/Dialect/FIROps.td
index 8cdbf5b9527e..6a473819a21f 100644
--- a/include/flang/Optimizer/Dialect/FIROps.td
+++ b/include/flang/Optimizer/Dialect/FIROps.td
@@ -785,54 +785,15 @@ def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
   }];
 
   let skipDefaultBuilders = 1;
-  let builders = [OpBuilder<
-    "Builder *builder, OperationState &result, Value selector,"
+  let builders = [
+    OpBuilder<"Builder *builder, OperationState &result, Value selector,"
     "ArrayRef<mlir::Attribute> compareAttrs, ArrayRef<ValueRange> cmpOperands,"
     "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}",
-    [{
-      result.addOperands(selector);
-      result.addAttribute(getCasesAttr(), builder->getArrayAttr(compareAttrs));
-      llvm::SmallVector<int32_t, 8> operOffs;
-      int32_t operSize = 0;
-      for (auto attr : compareAttrs) {
-        if (attr.isa<fir::ClosedIntervalAttr>()) {
-          operOffs.push_back(2);
-          operSize += 2;
-        } else if (attr.isa<mlir::UnitAttr>()) {
-          operOffs.push_back(0);
-        } else {
-          operOffs.push_back(1);
-          ++operSize;
-        }
-      }
-      for (auto ops : cmpOperands)
-        result.addOperands(ops);
-      result.addAttribute(getCompareOffsetAttr(),
-                          builder->getI32VectorAttr(operOffs));
-      const auto count = destinations.size();
-      for (auto d : destinations)
-        result.addSuccessors(d);
-      const auto opCount = destOperands.size();
-      llvm::SmallVector<int32_t, 8> argOffs;
-      int32_t sumArgs = 0;
-      for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
-        if (i < opCount) {
-          result.addOperands(destOperands[i]);
-          const auto argSz = destOperands[i].size();
-          argOffs.push_back(argSz);
-          sumArgs += argSz;
-        } else {
-          argOffs.push_back(0);
-        }
-      }
-      result.addAttribute(getOperandSegmentSizeAttr(),
-                          builder->getI32VectorAttr({1, operSize, sumArgs}));
-      result.addAttribute(getTargetOffsetAttr(),
-                          builder->getI32VectorAttr(argOffs));
-      result.addAttributes(attributes);
-    }]
-  >];
+    "ArrayRef<NamedAttribute> attributes = {}">,
+    OpBuilder<"Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<mlir::Attribute> compareAttrs, ArrayRef<Value> cmpOpList,"
+    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}">];
 
   let parser = "return parseSelectCase(parser, result);";
 
diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index a007db7f1201..4520b47b9294 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -900,6 +900,85 @@ unsigned fir::SelectCaseOp::targetOffsetSize() {
       getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
 }
 
+void fir::SelectCaseOp::build(mlir::Builder *builder,
+                              mlir::OperationState &result,
+                              mlir::Value selector,
+                              llvm::ArrayRef<mlir::Attribute> compareAttrs,
+                              llvm::ArrayRef<mlir::ValueRange> cmpOperands,
+                              llvm::ArrayRef<mlir::Block *> destinations,
+                              llvm::ArrayRef<mlir::ValueRange> destOperands,
+                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+  result.addOperands(selector);
+  result.addAttribute(getCasesAttr(), builder->getArrayAttr(compareAttrs));
+  llvm::SmallVector<int32_t, 8> operOffs;
+  int32_t operSize = 0;
+  for (auto attr : compareAttrs) {
+    if (attr.isa<fir::ClosedIntervalAttr>()) {
+      operOffs.push_back(2);
+      operSize += 2;
+    } else if (attr.isa<mlir::UnitAttr>()) {
+      operOffs.push_back(0);
+    } else {
+      operOffs.push_back(1);
+      ++operSize;
+    }
+  }
+  for (auto ops : cmpOperands)
+    result.addOperands(ops);
+  result.addAttribute(getCompareOffsetAttr(),
+                      builder->getI32VectorAttr(operOffs));
+  const auto count = destinations.size();
+  for (auto d : destinations)
+    result.addSuccessors(d);
+  const auto opCount = destOperands.size();
+  llvm::SmallVector<int32_t, 8> argOffs;
+  int32_t sumArgs = 0;
+  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+    if (i < opCount) {
+      result.addOperands(destOperands[i]);
+      const auto argSz = destOperands[i].size();
+      argOffs.push_back(argSz);
+      sumArgs += argSz;
+    } else {
+      argOffs.push_back(0);
+    }
+  }
+  result.addAttribute(getOperandSegmentSizeAttr(),
+                      builder->getI32VectorAttr({1, operSize, sumArgs}));
+  result.addAttribute(getTargetOffsetAttr(),
+                      builder->getI32VectorAttr(argOffs));
+  result.addAttributes(attributes);
+}
+
+/// This builder has a slightly simplified interface in that the list of
+/// operands need not be partitioned by the builder. Instead the operands are
+/// partitioned here, before being passed to the default builder. This
+/// partitioning is unchecked, so can go awry on bad input.
+void fir::SelectCaseOp::build(mlir::Builder *builder,
+                              mlir::OperationState &result,
+                              mlir::Value selector,
+                              llvm::ArrayRef<mlir::Attribute> compareAttrs,
+                              llvm::ArrayRef<mlir::Value> cmpOpList,
+                              llvm::ArrayRef<mlir::Block *> destinations,
+                              llvm::ArrayRef<mlir::ValueRange> destOperands,
+                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+  llvm::SmallVector<mlir::ValueRange, 16> cmpOpers;
+  auto iter = cmpOpList.begin();
+  for (auto &attr : compareAttrs) {
+    if (attr.isa<fir::ClosedIntervalAttr>()) {
+      cmpOpers.push_back(mlir::ValueRange({iter, iter + 2}));
+      iter += 2;
+    } else if (attr.isa<UnitAttr>()) {
+      // do nothing
+    } else {
+      cmpOpers.push_back(mlir::ValueRange({iter, iter + 1}));
+      ++iter;
+    }
+  }
+  build(builder, result, selector, compareAttrs, cmpOpers, destinations,
+        destOperands, attributes);
+}
+
 //===----------------------------------------------------------------------===//
 // SelectRankOp
 //===----------------------------------------------------------------------===//

From 04d412f237ceccb069bc12a37557b721198052d3 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 16:51:08 -0700
Subject: [PATCH 327/345] implement parens

---
 lib/Lower/ConvertExpr.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 9395f4a1f770..42774961f78f 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -426,8 +426,9 @@ class ExprLowering {
   }
 
   template <typename A>
-  mlir::Value genval(const Fortran::evaluate::Parentheses<A> &) {
-    TODO();
+  mlir::Value genval(const Fortran::evaluate::Parentheses<A> &op) {
+    auto input = genval(op.left());
+    return builder.create<fir::NoReassocOp>(getLoc(), input.getType(), input);
   }
 
   template <int KIND>

From 1f2846ad0f0a6e8c12869922d62ea511e45fe084 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 17:03:02 -0700
Subject: [PATCH 328/345] fix bug

---
 lib/Optimizer/Dialect/FIROps.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Optimizer/Dialect/FIROps.cpp b/lib/Optimizer/Dialect/FIROps.cpp
index 4520b47b9294..5242a17df922 100644
--- a/lib/Optimizer/Dialect/FIROps.cpp
+++ b/lib/Optimizer/Dialect/FIROps.cpp
@@ -969,7 +969,7 @@ void fir::SelectCaseOp::build(mlir::Builder *builder,
       cmpOpers.push_back(mlir::ValueRange({iter, iter + 2}));
       iter += 2;
     } else if (attr.isa<UnitAttr>()) {
-      // do nothing
+      cmpOpers.push_back(mlir::ValueRange{});
     } else {
       cmpOpers.push_back(mlir::ValueRange({iter, iter + 1}));
       ++iter;

From 773fca1a0ac07608f59637006a30cb271d79d3ea Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 17:15:19 -0700
Subject: [PATCH 329/345] add LAPACK bug report

---
 LAPACK-bugs.txt | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 LAPACK-bugs.txt

diff --git a/LAPACK-bugs.txt b/LAPACK-bugs.txt
new file mode 100644
index 000000000000..298e521b19e7
--- /dev/null
+++ b/LAPACK-bugs.txt
@@ -0,0 +1,11 @@
+Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
+
+error: 'std.return' op must be the last operation in the parent block
+
+UNREACHABLE executed at Bridge.cpp:1045!
+UNREACHABLE executed at Bridge.cpp:1211!
+UNREACHABLE executed at Bridge.cpp:1216!
+UNREACHABLE executed at ConvertExpr.cpp:403!
+UNREACHABLE executed at ConvertExpr.cpp:798!
+UNREACHABLE executed at ConvertExpr.cpp:848!
+UNREACHABLE executed at IO.cpp:760!

From 1ea735b6cc1f046c0e20e00332bccd710887a401 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 18:00:51 -0700
Subject: [PATCH 330/345] clang-format files

---
 include/flang/Lower/FIRBuilder.h          | 20 +++++++++++---------
 include/flang/Optimizer/Dialect/FIRType.h |  2 +-
 lib/Lower/FIRBuilder.cpp                  | 13 +++++--------
 lib/Optimizer/Dialect/FIRAttr.cpp         |  4 +---
 lib/Optimizer/StdConverter.cpp            |  2 +-
 lib/Optimizer/Support/InternalNames.cpp   |  7 +++++--
 lib/Optimizer/Transforms/CSE.cpp          |  9 ++++-----
 7 files changed, 28 insertions(+), 29 deletions(-)

diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index 2f52d9b09c35..d180a277f378 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -271,9 +271,9 @@ class FirOpBuilder : public mlir::OpBuilder,
                              mlir::Attribute value = {}, bool isConst = false);
 
   fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
-			     llvm::StringRef name, bool isConst,
-			     std::function<void(FirOpBuilder&)> bodyBuilder,
-			     mlir::StringAttr linkage = {});
+                             llvm::StringRef name, bool isConst,
+                             std::function<void(FirOpBuilder &)> bodyBuilder,
+                             mlir::StringAttr linkage = {});
 
   /// Create a global constant (read-only) value.
   fir::GlobalOp createGlobalConstant(mlir::Location loc, mlir::Type type,
@@ -283,11 +283,13 @@ class FirOpBuilder : public mlir::OpBuilder,
     return createGlobal(loc, type, name, linkage, value, /*isConst=*/true);
   }
 
-  fir::GlobalOp createGlobalConstant(mlir::Location loc, mlir::Type type,
-			     llvm::StringRef name,
-			     std::function<void(FirOpBuilder&)> bodyBuilder,
-				     mlir::StringAttr linkage = {}) {
-    return createGlobal(loc, type, name, /*isConst=*/true, bodyBuilder, linkage);
+  fir::GlobalOp
+  createGlobalConstant(mlir::Location loc, mlir::Type type,
+                       llvm::StringRef name,
+                       std::function<void(FirOpBuilder &)> bodyBuilder,
+                       mlir::StringAttr linkage = {}) {
+    return createGlobal(loc, type, name, /*isConst=*/true, bodyBuilder,
+                        linkage);
   }
 
   mlir::Block *createBlock() {
@@ -308,7 +310,7 @@ class FirOpBuilder : public mlir::OpBuilder,
   }
 
   static fir::GlobalOp getNamedGlobal(mlir::ModuleOp module,
-				      llvm::StringRef name);
+                                      llvm::StringRef name);
 
   /// Create a new FuncOp. If the function may have already been created, use
   /// `addNamedFunction` instead.
diff --git a/include/flang/Optimizer/Dialect/FIRType.h b/include/flang/Optimizer/Dialect/FIRType.h
index 3f5cc6c4e865..9f7f772d7d1e 100644
--- a/include/flang/Optimizer/Dialect/FIRType.h
+++ b/include/flang/Optimizer/Dialect/FIRType.h
@@ -339,7 +339,7 @@ class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
   /// (`array<*xT>`), or rows with shape and ending with column(s) of
   /// unknown extent (`array<C...xCx?...x?xT>`).
   bool hasConstantInterior() const;
-  
+
   /// The value `-1` represents an unknown extent for a dimension
   static constexpr Extent getUnknownExtent() { return -1; }
 
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index 30d2771c3176..8ff7f98c4cb2 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -38,7 +38,7 @@ Fortran::lower::FirOpBuilder::getNamedFunction(mlir::ModuleOp modOp,
 
 fir::GlobalOp
 Fortran::lower::FirOpBuilder::getNamedGlobal(mlir::ModuleOp modOp,
-					     llvm::StringRef name) {
+                                             llvm::StringRef name) {
   return modOp.lookupSymbol<fir::GlobalOp>(name);
 }
 
@@ -93,18 +93,16 @@ fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
   return glob;
 }
 
-fir::GlobalOp
-Fortran::lower::FirOpBuilder::createGlobal(mlir::Location loc, mlir::Type type,
-			     llvm::StringRef name, bool isConst,
-			     std::function<void(FirOpBuilder &)> bodyBuilder,
-					   mlir::StringAttr linkage) {
+fir::GlobalOp Fortran::lower::FirOpBuilder::createGlobal(
+    mlir::Location loc, mlir::Type type, llvm::StringRef name, bool isConst,
+    std::function<void(FirOpBuilder &)> bodyBuilder, mlir::StringAttr linkage) {
   auto module = getModule();
   auto insertPt = saveInsertionPoint();
   if (auto glob = module.lookupSymbol<fir::GlobalOp>(name))
     return glob;
   setInsertionPoint(module.getBody()->getTerminator());
   auto glob = create<fir::GlobalOp>(loc, name, isConst, type, mlir::Attribute{},
-				    linkage);
+                                    linkage);
   auto &region = glob.getRegion();
   region.push_back(new mlir::Block);
   auto &block = glob.getRegion().back();
@@ -114,7 +112,6 @@ Fortran::lower::FirOpBuilder::createGlobal(mlir::Location loc, mlir::Type type,
   return glob;
 }
 
-
 //===----------------------------------------------------------------------===//
 // LoopOp builder
 //===----------------------------------------------------------------------===//
diff --git a/lib/Optimizer/Dialect/FIRAttr.cpp b/lib/Optimizer/Dialect/FIRAttr.cpp
index e4a87d7fb859..09780d306fb8 100644
--- a/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -27,9 +27,7 @@ struct RealAttributeStorage : public mlir::AttributeStorage {
   RealAttributeStorage(const KeyTy &key)
       : RealAttributeStorage(key.first, key.second) {}
 
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_value(key);
-  }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_value(key); }
 
   bool operator==(const KeyTy &key) const {
     return key.first == kind &&
diff --git a/lib/Optimizer/StdConverter.cpp b/lib/Optimizer/StdConverter.cpp
index 0398735234b9..55285bd7b837 100644
--- a/lib/Optimizer/StdConverter.cpp
+++ b/lib/Optimizer/StdConverter.cpp
@@ -94,7 +94,7 @@ class FIROpConversion : public mlir::ConversionPattern {
   {}
 
   static Block *createBlock(mlir::ConversionPatternRewriter &rewriter,
-                     Block *insertBefore) {
+                            Block *insertBefore) {
     assert(insertBefore && "expected valid insertion block");
     return rewriter.createBlock(insertBefore->getParent(),
                                 mlir::Region::iterator(insertBefore));
diff --git a/lib/Optimizer/Support/InternalNames.cpp b/lib/Optimizer/Support/InternalNames.cpp
index 47b8504c0e14..61eac7b437c4 100644
--- a/lib/Optimizer/Support/InternalNames.cpp
+++ b/lib/Optimizer/Support/InternalNames.cpp
@@ -10,7 +10,10 @@
 #include "mlir/IR/Diagnostics.h"
 #include "llvm/Support/CommandLine.h"
 
-static llvm::cl::opt<std::string> mainEntryName("main-entry-name", llvm::cl::desc("override the name of the default PROGRAM entry (may be helpful for using other runtimes)"));
+static llvm::cl::opt<std::string> mainEntryName(
+    "main-entry-name",
+    llvm::cl::desc("override the name of the default PROGRAM entry (may be "
+                   "helpful for using other runtimes)"));
 
 constexpr std::int64_t BAD_VALUE = -1;
 
@@ -238,7 +241,7 @@ fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
       case 'Q':
         nk = NameKind::GENERATED;
         name = uniq;
-	i = end;
+        i = end;
         break;
       case 'T':
         nk = NameKind::DERIVED_TYPE;
diff --git a/lib/Optimizer/Transforms/CSE.cpp b/lib/Optimizer/Transforms/CSE.cpp
index 9ef042be422a..04c0ab8eec2d 100644
--- a/lib/Optimizer/Transforms/CSE.cpp
+++ b/lib/Optimizer/Transforms/CSE.cpp
@@ -35,12 +35,11 @@ using namespace mlir;
 
 static llvm::cl::opt<bool>
     leaveEffects("keep-effects",
-                   llvm::cl::desc("disable cleaning up effects attributes"),
-                   llvm::cl::init(false), llvm::cl::Hidden);
+                 llvm::cl::desc("disable cleaning up effects attributes"),
+                 llvm::cl::init(false), llvm::cl::Hidden);
 static llvm::cl::opt<bool> disableCSE("disable-cse",
-                                        llvm::cl::desc("disable CSE pass"),
-                                        llvm::cl::init(false),
-                                        llvm::cl::Hidden);
+                                      llvm::cl::desc("disable CSE pass"),
+                                      llvm::cl::init(false), llvm::cl::Hidden);
 
 namespace {
 

From ec9354bffebd10954a9b7e9a3cf25938588f7558 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 18:14:25 -0700
Subject: [PATCH 331/345] warning cleanup

---
 include/flang/Lower/FIRBuilder.h |  4 ----
 lib/Lower/Bridge.cpp             | 35 ++++++++++++++------------------
 2 files changed, 15 insertions(+), 24 deletions(-)

diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index d180a277f378..c18f5d65bfa0 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -292,10 +292,6 @@ class FirOpBuilder : public mlir::OpBuilder,
                         linkage);
   }
 
-  mlir::Block *createBlock() {
-    return OpBuilder::createBlock(getBlock()->getParent());
-  }
-
   /// Get a function by name. If the function exists in the current module, it
   /// is returned. Otherwise, a null FuncOp is returned.
   mlir::FuncOp getNamedFunction(llvm::StringRef name) {
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index cdfb94a7c131..de72f460e8d5 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -1070,7 +1070,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   // gen expression, if any; share code with END of procedure
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::ReturnStmt &stmt) {
-    const auto *funit{eval.getOwningProcedure()};
+    const auto *funit = eval.getOwningProcedure();
     assert(funit && "not inside main program or a procedure");
     if (funit->isMainProgram()) {
       genFIRProgramExit();
@@ -1098,9 +1098,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               bool unstructuredContext = true) {
-    if (eval.skip) {
+    if (eval.skip)
       return; // rhs of {Forall,If,Where}Stmt has already been processed
-    }
+
     setCurrentPosition(eval.position);
     if (unstructuredContext) {
       // When transitioning from unstructured to structured code,
@@ -1167,7 +1167,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
     attempted.insert(symbol);
     mlir::Value localValue;
-    auto *type{symbol.GetType()};
+    auto *type = symbol.GetType();
     assert(type && "expected type for local symbol");
 
     if (type->category() == Fortran::semantics::DeclTypeSpec::Character) {
@@ -1284,9 +1284,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       std::list<Fortran::lower::pft::Evaluation> &evaluationList) {
     for (auto &eval : evaluationList) {
       if (eval.isNewBlock)
-        eval.block = builder->createBlock();
+        eval.block = builder->createBlock(&builder->getRegion());
       for (size_t i = 0, n = eval.localBlocks.size(); i < n; ++i)
-        eval.localBlocks[i] = builder->createBlock();
+        eval.localBlocks[i] = builder->createBlock(&builder->getRegion());
       if (eval.isConstruct()) {
         if (eval.lowerAsUnstructured()) {
           createEmptyBlocks(*eval.evaluationList);
@@ -1295,7 +1295,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
           Fortran::lower::pft::Evaluation &constructStmt =
               eval.evaluationList->front();
           if (constructStmt.isNewBlock)
-            constructStmt.block = builder->createBlock();
+            constructStmt.block = builder->createBlock(&builder->getRegion());
         }
       }
     }
@@ -1303,7 +1303,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   /// Return the predicate: "current block does not have a terminator branch".
   bool blockIsUnterminated() {
-    mlir::Block *currentBlock = builder->getBlock();
+    auto *currentBlock = builder->getBlock();
     return currentBlock->empty() || currentBlock->back().isKnownNonTerminator();
   }
 
@@ -1312,17 +1312,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     assert(newBlock && "missing block");
     // If the current block does not have a terminator branch,
     // append a fallthrough branch.
-    if (blockIsUnterminated()) {
+    if (blockIsUnterminated())
       genFIRUnconditionalBranch(newBlock);
-    }
     builder->setInsertionPointToStart(newBlock);
   }
 
   /// Conditionally switch code insertion to a new block.
   void maybeStartBlock(mlir::Block *newBlock) {
-    if (newBlock) {
+    if (newBlock)
       startBlock(newBlock);
-    }
   }
 
   /// Emit return and cleanup after the function has been translated.
@@ -1345,27 +1343,24 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &funit) {
     startNewFunction(funit);
     // lower this procedure
-    for (auto &eval : funit.evaluationList) {
+    for (auto &eval : funit.evaluationList)
       genFIR(eval);
-    }
+
     endNewFunction(funit);
     // recursively lower internal procedures
-    for (auto &f : funit.nestedFunctions) {
+    for (auto &f : funit.nestedFunctions)
       lowerFunc(f);
-    }
   }
 
   void lowerMod(Fortran::lower::pft::ModuleLikeUnit &mod) {
     // FIXME: do we need to visit the module statements?
-    for (auto &f : mod.nestedFunctions) {
+    for (auto &f : mod.nestedFunctions)
       lowerFunc(f);
-    }
   }
 
   void setCurrentPosition(const Fortran::parser::CharBlock &position) {
-    if (position != Fortran::parser::CharBlock{}) {
+    if (position != Fortran::parser::CharBlock{})
       currentPosition = position;
-    }
   }
 
   //

From aaa6b46012d34e16fda3e95e123921bbecaecada Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 21:22:32 -0700
Subject: [PATCH 332/345] add canon to tco

---
 tools/tco/tco.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index 7d3207c497c7..c77fa74703e5 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -90,6 +90,7 @@ static int compileFIR() {
   } else {
     // add all the passes
     // the user can disable them individually
+    pm.addPass(mlir::createCanonicalizerPass());
     // convert fir dialect to affine
     pm.addPass(fir::createPromoteToAffinePass());
     // convert fir dialect to loop

From ed60e75e5d10e0412e4c2d26a92d2318f71d7592 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 19:53:57 -0700
Subject: [PATCH 333/345] lower RETURN statements correctly in SUBROUTINE

---
 include/flang/Lower/PFTBuilder.h |  2 ++
 lib/Lower/Bridge.cpp             | 61 ++++++++++++++++++++++----------
 test/Lower/control-flow.f90      | 25 +++++++++++++
 3 files changed, 70 insertions(+), 18 deletions(-)
 create mode 100644 test/Lower/control-flow.f90

diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 01d24049bc1f..1865b1ed4b97 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -360,6 +360,8 @@ struct FunctionLikeUnit : public ProgramUnit {
   /// The symbol has MainProgramDetails for named programs, otherwise it has
   /// SubprogramDetails.
   const semantics::Symbol *symbol{nullptr};
+  /// Terminal basic block (if any)
+  mlir::Block *finalBlock{};
 };
 
 /// Module-like units contain a list of function-like units.
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index de72f460e8d5..f6dea4dc218b 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -187,6 +187,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   Fortran::lower::FirOpBuilder &getFirOpBuilder() override final {
     return *builder;
   }
+
   mlir::ModuleOp &getModuleOp() override final { return module; }
 
   std::string
@@ -265,7 +266,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
 
   void
   genFIRUnconditionalBranch(Fortran::lower::pft::Evaluation *targetEvaluation) {
-    builder->create<mlir::BranchOp>(toLocation(), targetEvaluation->block);
+    genFIRUnconditionalBranch(targetEvaluation->block);
   }
 
   void genFIRConditionalBranch(mlir::Value &cond, mlir::Block *trueTarget,
@@ -291,30 +292,45 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   /// END of program
   ///
   /// Generate the cleanup block before the program exits
-  void genFIRProgramExit() { builder->create<mlir::ReturnOp>(toLocation()); }
+  void genExitRoutine() { builder->create<mlir::ReturnOp>(toLocation()); }
+  void genFIRProgramExit() { genExitRoutine(); }
   void genFIR(const Fortran::parser::EndProgramStmt &) { genFIRProgramExit(); }
 
   /// END of procedure-like constructs
   ///
   /// Generate the cleanup block before the procedure exits
-  void genFIRFunctionReturn(const Fortran::semantics::Symbol &functionSymbol) {
+  void genExitFunction(mlir::Value val) {
+    builder->create<mlir::ReturnOp>(toLocation(), val);
+  }
+  void genReturnSymbol(const Fortran::semantics::Symbol &functionSymbol) {
     const auto &details =
         functionSymbol.get<Fortran::semantics::SubprogramDetails>();
-    mlir::Value resultRef = localSymbols.lookupSymbol(details.result());
+    auto resultRef = localSymbols.lookupSymbol(details.result());
     mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
-    builder->create<mlir::ReturnOp>(toLocation(), r);
+    genExitFunction(r);
   }
-  void genFIRProcedureExit(const Fortran::semantics::Symbol &symbol) {
-    const auto &details = symbol.get<Fortran::semantics::SubprogramDetails>();
+
+  void genFIRProcedureExit(Fortran::lower::pft::FunctionLikeUnit &funit,
+                           const Fortran::semantics::Symbol &symbol) {
     if (Fortran::semantics::IsFunction(symbol)) {
-      mlir::Value resultRef = localSymbols.lookupSymbol(details.result());
-      mlir::Value r = builder->create<fir::LoadOp>(toLocation(), resultRef);
-      builder->create<mlir::ReturnOp>(toLocation(), r);
-    } else if (Fortran::semantics::HasAlternateReturns(symbol)) {
+      // FUNCTION
+      genReturnSymbol(symbol);
+      return;
+    }
+
+    // SUBROUTINE
+    if (Fortran::semantics::HasAlternateReturns(symbol)) {
+      // lower to a the constant expression (or zero); the return value will
+      // drive a SelectOp in the calling context to branch to the alternate
+      // return LABEL block
       TODO();
-    } else {
-      builder->create<mlir::ReturnOp>(toLocation());
+      mlir::Value intExpr{};
+      genExitFunction(intExpr);
+      return;
     }
+    if (funit.finalBlock)
+      builder->setInsertionPoint(funit.finalBlock, funit.finalBlock->end());
+    genExitRoutine();
   }
 
   //
@@ -1079,7 +1095,16 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         // Alternate return
         TODO();
       }
-      genFIRProcedureExit(funit->getSubprogramSymbol());
+      // an ordinary RETURN should be lowered as a GOTO to the last block of the
+      // SUBROUTINE
+      auto *subr = eval.getOwningProcedure();
+      assert(subr && "RETURN not in a PROCEDURE");
+      if (!subr->finalBlock) {
+        auto insPt = builder->saveInsertionPoint();
+        subr->finalBlock = builder->createBlock(&builder->getRegion());
+        builder->restoreInsertionPoint(insPt);
+      }
+      builder->create<mlir::BranchOp>(toLocation(), subr->finalBlock);
     }
   }
 
@@ -1171,8 +1196,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     assert(type && "expected type for local symbol");
 
     if (type->category() == Fortran::semantics::DeclTypeSpec::Character) {
-      const auto &lenghtParam{type->characterTypeSpec().length()};
-      if (auto expr{lenghtParam.GetExplicit()}) {
+      const auto &lengthParam = type->characterTypeSpec().length();
+      if (auto expr = lengthParam.GetExplicit()) {
         for (const auto &requiredSymbol :
              Fortran::evaluate::CollectSymbols(*expr)) {
           instantiateLocalVariable(requiredSymbol, dummyArgs, attempted);
@@ -1186,7 +1211,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
           // TODO: propagate symbol name to FIR.
           localValue = builder->createCharacterTemp(genType(symbol), lenValue);
         }
-      } else if (lenghtParam.isDeferred()) {
+      } else if (lengthParam.isDeferred()) {
         TODO();
       } else {
         // Assumed
@@ -1331,7 +1356,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     if (funit.isMainProgram()) {
       genFIRProgramExit();
     } else {
-      genFIRProcedureExit(funit.getSubprogramSymbol());
+      genFIRProcedureExit(funit, funit.getSubprogramSymbol());
     }
 
     delete builder;
diff --git a/test/Lower/control-flow.f90 b/test/Lower/control-flow.f90
new file mode 100644
index 000000000000..b9485f4315b3
--- /dev/null
+++ b/test/Lower/control-flow.f90
@@ -0,0 +1,25 @@
+! Tests for control-flow
+
+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! check the lowering of a RETURN in the body of a SUBROUTINE
+! CHECK-LABEL one
+subroutine one(a,b,c)
+  d = 1.0
+  if (a .ne. b) then
+    ! CHECK: call @_QPone_a
+    call one_a(d)
+    ! CHECK: cond_br %{{.*}}, ^bb[[TB:.*]], ^
+    if (d .eq. 1.0) then
+       ! CHECK-NEXT: ^bb[[TB]]:
+       ! CHECK-NEXT: br ^bb[[EXIT:.*]]
+       return
+    endif
+ else
+    e = 4.0
+    call one_b(c,d,e)
+ endif
+ ! CHECK: ^bb[[EXIT]]:
+ ! CHECK-NEXT: return
+end subroutine one
+    

From 06a56f5a7e15eb662b64aca79892ca9212250d2f Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Tue, 7 Apr 2020 21:32:59 -0700
Subject: [PATCH 334/345] update LAPACK bug list

---
 LAPACK-bugs.txt | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/LAPACK-bugs.txt b/LAPACK-bugs.txt
index 298e521b19e7..233d4e011fce 100644
--- a/LAPACK-bugs.txt
+++ b/LAPACK-bugs.txt
@@ -1,6 +1,8 @@
-Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
+NEED ATTENTION
+______________
 
-error: 'std.return' op must be the last operation in the parent block
+
+Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
 
 UNREACHABLE executed at Bridge.cpp:1045!
 UNREACHABLE executed at Bridge.cpp:1211!
@@ -9,3 +11,10 @@ UNREACHABLE executed at ConvertExpr.cpp:403!
 UNREACHABLE executed at ConvertExpr.cpp:798!
 UNREACHABLE executed at ConvertExpr.cpp:848!
 UNREACHABLE executed at IO.cpp:760!
+
+FIXED
+_____
+
+
+error: 'std.return' op must be the last operation in the parent block
+

From 5f372be5f2b45fe176ee96e4ea23791a7fc7618c Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 08:54:39 -0700
Subject: [PATCH 335/345] update list

---
 LAPACK-bugs.txt | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/LAPACK-bugs.txt b/LAPACK-bugs.txt
index 233d4e011fce..2f9ed0e02415 100644
--- a/LAPACK-bugs.txt
+++ b/LAPACK-bugs.txt
@@ -4,13 +4,13 @@ ______________
 
 Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
 
-UNREACHABLE executed at Bridge.cpp:1045!
-UNREACHABLE executed at Bridge.cpp:1211!
-UNREACHABLE executed at Bridge.cpp:1216!
-UNREACHABLE executed at ConvertExpr.cpp:403!
-UNREACHABLE executed at ConvertExpr.cpp:798!
-UNREACHABLE executed at ConvertExpr.cpp:848!
-UNREACHABLE executed at IO.cpp:760!
+UNREACHABLE executed at Lower/Bridge.cpp:1061!
+UNREACHABLE executed at Lower/Bridge.cpp:1236!
+UNREACHABLE executed at Lower/Bridge.cpp:1241!
+UNREACHABLE executed at Lower/ConvertExpr.cpp:403!
+UNREACHABLE executed at Lower/ConvertExpr.cpp:798!
+UNREACHABLE executed at Lower/ConvertExpr.cpp:848!
+UNREACHABLE executed at Lower/IO.cpp:764!
 
 FIXED
 _____

From 1d9e65d78355871e416cdf459f9a9b13c1a45332 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 09:39:51 -0700
Subject: [PATCH 336/345] document list

---
 LAPACK-bugs.txt | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/LAPACK-bugs.txt b/LAPACK-bugs.txt
index 2f9ed0e02415..3b9443cdb12f 100644
--- a/LAPACK-bugs.txt
+++ b/LAPACK-bugs.txt
@@ -4,13 +4,13 @@ ______________
 
 Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
 
-UNREACHABLE executed at Lower/Bridge.cpp:1061!
-UNREACHABLE executed at Lower/Bridge.cpp:1236!
-UNREACHABLE executed at Lower/Bridge.cpp:1241!
-UNREACHABLE executed at Lower/ConvertExpr.cpp:403!
-UNREACHABLE executed at Lower/ConvertExpr.cpp:798!
-UNREACHABLE executed at Lower/ConvertExpr.cpp:848!
-UNREACHABLE executed at Lower/IO.cpp:764!
+UNREACHABLE executed at Lower/Bridge.cpp:1061!  DATA
+UNREACHABLE executed at Lower/Bridge.cpp:1236!  adjustable array?
+UNREACHABLE executed at Lower/Bridge.cpp:1241!  local w/ initializer
+UNREACHABLE executed at Lower/ConvertExpr.cpp:403!  CHAR comparison
+UNREACHABLE executed at Lower/ConvertExpr.cpp:798!  intrinsic subroutine
+UNREACHABLE executed at Lower/ConvertExpr.cpp:848!  temps on call?
+UNREACHABLE executed at Lower/IO.cpp:764!       FORMAT
 
 FIXED
 _____

From c696c2419b3d4e3286018ed02baa339134d82acf Mon Sep 17 00:00:00 2001
From: Eric <eric.schweitz@gmail.com>
Date: Wed, 8 Apr 2020 12:17:05 -0700
Subject: [PATCH 337/345] fix nested if's bugs

---
 lib/Lower/Bridge.cpp | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index f6dea4dc218b..65fc9c776ddf 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -343,14 +343,18 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void switchInsertionPointToOtherwise(fir::WhereOp &where) {
     builder->setInsertionPointToStart(&where.otherRegion().front());
   }
+  
   template <typename A>
-  void genWhereCondition(fir::WhereOp &where, const A *stmt) {
+  mlir::OpBuilder::InsertPoint genWhereCondition(fir::WhereOp &where,
+						 const A *stmt) {
     auto cond = createLogicalExprAsI1(
         toLocation(),
         Fortran::semantics::GetExpr(
             std::get<Fortran::parser::ScalarLogicalExpr>(stmt->t)));
     where = builder->create<fir::WhereOp>(toLocation(), cond, true);
+    auto insPt = builder->saveInsertionPoint();
     switchInsertionPointToWhere(where);
+    return insPt;
   }
 
   mlir::Value genFIRLoopIndex(const Fortran::parser::ScalarExpr &x,
@@ -394,12 +398,11 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     }
 
     // Generate fir.where.
-    mlir::Block *ifStmtBlock = builder->getInsertionBlock();
     fir::WhereOp where;
-    genWhereCondition(where, &stmt);
+    auto insPt = genWhereCondition(where, &stmt);
     genFIR(*eval.lexicalSuccessor, /*unstructuredContext*/ false);
     eval.lexicalSuccessor->skip = true;
-    builder->setInsertionPointToEnd(ifStmtBlock);
+    builder->restoreInsertionPoint(insPt);
   }
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
@@ -602,25 +605,25 @@ class FirConverter : public Fortran::lower::AbstractConverter {
               const Fortran::parser::IfConstruct &) {
     if (eval.lowerAsStructured()) {
       // Structured fir.where nest.
-      fir::WhereOp where;
-      mlir::OpBuilder::InsertPoint insertionPoint =
-          builder->saveInsertionPoint();
+      fir::WhereOp underWhere;
+      mlir::OpBuilder::InsertPoint insPt;
       for (auto &e : *eval.evaluationList) {
         if (auto *s = e.getIf<Fortran::parser::IfThenStmt>()) {
           // fir.where op
-          genWhereCondition(where, s);
+          insPt = genWhereCondition(underWhere, s);
         } else if (auto *s = e.getIf<Fortran::parser::ElseIfStmt>()) {
           // otherwise block, then nested fir.where
-          switchInsertionPointToOtherwise(where);
-          genWhereCondition(where, s);
+          switchInsertionPointToOtherwise(underWhere);
+          genWhereCondition(underWhere, s);
         } else if (e.isA<Fortran::parser::ElseStmt>()) {
           // otherwise block
-          switchInsertionPointToOtherwise(where);
+          switchInsertionPointToOtherwise(underWhere);
+	} else if (e.isA<Fortran::parser::EndIfStmt>()) {
+	  builder->restoreInsertionPoint(insPt);
         } else {
           genFIR(e, /*unstructuredContext*/ false);
         }
       }
-      builder->restoreInsertionPoint(insertionPoint);
       return;
     }
 

From d30be81b138e2645c317e75edd057fc6c5033a68 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 14:06:49 -0700
Subject: [PATCH 338/345] update list

---
 LAPACK-bugs.txt | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/LAPACK-bugs.txt b/LAPACK-bugs.txt
index 3b9443cdb12f..83f9eb96b604 100644
--- a/LAPACK-bugs.txt
+++ b/LAPACK-bugs.txt
@@ -1,20 +1,22 @@
 NEED ATTENTION
 ______________
 
+[Eric] error: branch has N operands for successor #M, but target block has K
+[Eric] UNREACHABLE executed at Lower/ConvertExpr.cpp:848!  temps on call?
 
-Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
+[Varun] UNREACHABLE executed at Lower/Bridge.cpp:1061!  DATA
+[Varun] UNREACHABLE executed at Lower/Bridge.cpp:1241!  local w/ initializer
 
-UNREACHABLE executed at Lower/Bridge.cpp:1061!  DATA
 UNREACHABLE executed at Lower/Bridge.cpp:1236!  adjustable array?
-UNREACHABLE executed at Lower/Bridge.cpp:1241!  local w/ initializer
 UNREACHABLE executed at Lower/ConvertExpr.cpp:403!  CHAR comparison
 UNREACHABLE executed at Lower/ConvertExpr.cpp:798!  intrinsic subroutine
-UNREACHABLE executed at Lower/ConvertExpr.cpp:848!  temps on call?
 UNREACHABLE executed at Lower/IO.cpp:764!       FORMAT
 
 FIXED
 _____
 
 
+Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
+
 error: 'std.return' op must be the last operation in the parent block
 

From 08ff2f19913ab8c9952a123e66736bb4967f66f9 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 14:26:42 -0700
Subject: [PATCH 339/345] add code for namelist todo in IO.cpp

---
 lib/Lower/IO.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index c4013907a29e..a3613a0f50e2 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -652,14 +652,15 @@ static const auto *getIOControl(const A &stmt) {
   return static_cast<const SEEK *>(nullptr);
 }
 
+/// returns true iff the expression in the parse tree is not really a format but
+/// rather a namelist variable.
 template <typename A>
 static bool formatIsActuallyNamelist(const A &format) {
   if (auto *e = std::get_if<Fortran::parser::Expr>(&format.u)) {
     auto *expr = Fortran::semantics::GetExpr(*e);
-    if (Fortran::evaluate::IsVariable(*expr)) {
-      TODO();
-      // TODO: fish out the symbol and determine if it has namelist details
-    }
+    if (const Fortran::semantics::Symbol *y =
+            Fortran::evaluate::UnwrapWholeSymbolDataRef(*expr))
+      return y->has<Fortran::semantics::NamelistDetails>();
   }
   return false;
 }

From f40952aafa9b779542178174ddff50b50f71e7ab Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 15:07:55 -0700
Subject: [PATCH 340/345] fix expression passing, introduce temp

---
 LAPACK-bugs.txt           |  7 ++++---
 lib/Lower/ConvertExpr.cpp |  8 ++++++--
 test/Lower/arguments.f90  | 23 +++++++++++++++++++++++
 3 files changed, 33 insertions(+), 5 deletions(-)
 create mode 100644 test/Lower/arguments.f90

diff --git a/LAPACK-bugs.txt b/LAPACK-bugs.txt
index 83f9eb96b604..8d5476e1e3e7 100644
--- a/LAPACK-bugs.txt
+++ b/LAPACK-bugs.txt
@@ -2,13 +2,12 @@ NEED ATTENTION
 ______________
 
 [Eric] error: branch has N operands for successor #M, but target block has K
-[Eric] UNREACHABLE executed at Lower/ConvertExpr.cpp:848!  temps on call?
+[Eric] UNREACHABLE executed at Lower/ConvertExpr.cpp:403!  CHAR comparison
 
 [Varun] UNREACHABLE executed at Lower/Bridge.cpp:1061!  DATA
-[Varun] UNREACHABLE executed at Lower/Bridge.cpp:1241!  local w/ initializer
+[Varun] UNREACHABLE executed at Lower/Bridge.cpp:1241!  local w/ initializer (implied SAVE)
 
 UNREACHABLE executed at Lower/Bridge.cpp:1236!  adjustable array?
-UNREACHABLE executed at Lower/ConvertExpr.cpp:403!  CHAR comparison
 UNREACHABLE executed at Lower/ConvertExpr.cpp:798!  intrinsic subroutine
 UNREACHABLE executed at Lower/IO.cpp:764!       FORMAT
 
@@ -16,6 +15,8 @@ FIXED
 _____
 
 
+UNREACHABLE executed at Lower/ConvertExpr.cpp:848!  temps on call?
+
 Block.cpp:200: mlir::Operation *mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' failed.
 
 error: 'std.return' op must be the last operation in the parent block
diff --git a/lib/Lower/ConvertExpr.cpp b/lib/Lower/ConvertExpr.cpp
index 42774961f78f..193cd47c9caa 100644
--- a/lib/Lower/ConvertExpr.cpp
+++ b/lib/Lower/ConvertExpr.cpp
@@ -844,8 +844,12 @@ class ExprLowering {
         argTypes.push_back(argRef.getType());
         operands.push_back(argRef);
       } else {
-        // TODO create temps for expressions
-        TODO();
+        // create a temp to store the expression value
+        auto val = genval(*expr);
+        auto addr = builder.createTemporary(getLoc(), symMap, val.getType());
+        builder.create<fir::StoreOp>(getLoc(), val, addr);
+        argTypes.push_back(addr.getType());
+        operands.push_back(addr);
       }
     }
     mlir::FunctionType funTy =
diff --git a/test/Lower/arguments.f90 b/test/Lower/arguments.f90
new file mode 100644
index 000000000000..2478dc251c1f
--- /dev/null
+++ b/test/Lower/arguments.f90
@@ -0,0 +1,23 @@
+! RUN: bbc %s -o - | FileCheck %s
+
+! CHECK-LABEL: _QQmain
+program test1
+  ! CHECK-DAG: %[[TMP:.*]] = fir.alloca
+  ! CHECK-DAG: %[[TEN:.*]] = constant
+  ! CHECK: fir.store %[[TEN]] to %[[TMP]]
+  ! CHECK-NEXT: fir.call @_QPfoo
+  call foo(10)
+contains
+
+! CHECK-LABEL: func @_QPfoo
+subroutine foo(avar1)
+  integer :: avar1
+!  integer :: my_data, my_data2
+!  DATA my_data / 150 /
+!  DATA my_data2 / 150 /
+!  print *, my_data, my_data2
+  print *, avar1
+end subroutine
+! CHECK: }
+end program test1
+

From 52608f116c14bc55142fc5749bb4dff84d8a1f31 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 15:14:07 -0700
Subject: [PATCH 341/345] rename open.f90 to better reflect what it tests

---
 test/Lower/{open.f90 => io-stmt.f90} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename test/Lower/{open.f90 => io-stmt.f90} (100%)

diff --git a/test/Lower/open.f90 b/test/Lower/io-stmt.f90
similarity index 100%
rename from test/Lower/open.f90
rename to test/Lower/io-stmt.f90

From 0f98a25be3c717d8f9f760e0c84c87f556243518 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 18:09:33 -0700
Subject: [PATCH 342/345] implement format for data transfer statements

---
 include/flang/Lower/FIRBuilder.h |  4 ++
 include/flang/Lower/IO.h         | 26 ++++++++---
 include/flang/Lower/PFTBuilder.h |  4 +-
 lib/Lower/Bridge.cpp             | 20 ++++----
 lib/Lower/FIRBuilder.cpp         | 14 ++++++
 lib/Lower/IO.cpp                 | 78 +++++++++++++++++++++++---------
 6 files changed, 108 insertions(+), 38 deletions(-)

diff --git a/include/flang/Lower/FIRBuilder.h b/include/flang/Lower/FIRBuilder.h
index c18f5d65bfa0..c1cda690b8cf 100644
--- a/include/flang/Lower/FIRBuilder.h
+++ b/include/flang/Lower/FIRBuilder.h
@@ -292,6 +292,10 @@ class FirOpBuilder : public mlir::OpBuilder,
                         linkage);
   }
 
+  /// Convert a StringRef string into a fir::StringLitOp.
+  fir::StringLitOp createStringLit(mlir::Location loc, mlir::Type eleTy,
+                                   llvm::StringRef string);
+
   /// Get a function by name. If the function exists in the current module, it
   /// is returned. Otherwise, a null FuncOp is returned.
   mlir::FuncOp getNamedFunction(llvm::StringRef name) {
diff --git a/include/flang/Lower/IO.h b/include/flang/Lower/IO.h
index a366bef9acb7..4dd6715b258b 100644
--- a/include/flang/Lower/IO.h
+++ b/include/flang/Lower/IO.h
@@ -16,8 +16,10 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef FORTRAN_LOWER_IO_H_
-#define FORTRAN_LOWER_IO_H_
+#ifndef FORTRAN_LOWER_IO_H
+#define FORTRAN_LOWER_IO_H
+
+#include "llvm/ADT/DenseMap.h"
 
 namespace mlir {
 class Value;
@@ -25,6 +27,7 @@ class Value;
 
 namespace Fortran {
 namespace parser {
+using Label = std::uint64_t;
 struct BackspaceStmt;
 struct CloseStmt;
 struct EndfileStmt;
@@ -43,6 +46,11 @@ namespace lower {
 class AbstractConverter;
 class BridgeImpl;
 
+namespace pft {
+struct Evaluation;
+using LabelEvalMap = llvm::DenseMap<Fortran::parser::Label, Evaluation *>;
+} // namespace pft
+
 /// Generate IO call(s) for BACKSPACE; return the IOSTAT code
 mlir::Value genBackspaceStatement(AbstractConverter &,
                                   const parser::BackspaceStmt &);
@@ -65,10 +73,14 @@ mlir::Value genInquireStatement(AbstractConverter &,
 mlir::Value genOpenStatement(AbstractConverter &, const parser::OpenStmt &);
 
 /// Generate IO call(s) for PRINT
-void genPrintStatement(AbstractConverter &, const parser::PrintStmt &);
+void genPrintStatement(AbstractConverter &converter,
+                       const parser::PrintStmt &stmt,
+                       pft::LabelEvalMap &labelMap);
 
 /// Generate IO call(s) for READ; return the IOSTAT code
-mlir::Value genReadStatement(AbstractConverter &, const parser::ReadStmt &);
+mlir::Value genReadStatement(AbstractConverter &converter,
+                             const parser::ReadStmt &stmt,
+                             pft::LabelEvalMap &labelMap);
 
 /// Generate IO call(s) for REWIND; return the IOSTAT code
 mlir::Value genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
@@ -77,9 +89,11 @@ mlir::Value genRewindStatement(AbstractConverter &, const parser::RewindStmt &);
 mlir::Value genWaitStatement(AbstractConverter &, const parser::WaitStmt &);
 
 /// Generate IO call(s) for WRITE; return the IOSTAT code
-mlir::Value genWriteStatement(AbstractConverter &, const parser::WriteStmt &);
+mlir::Value genWriteStatement(AbstractConverter &converter,
+                              const parser::WriteStmt &stmt,
+                              pft::LabelEvalMap &labelMap);
 
 } // namespace lower
 } // namespace Fortran
 
-#endif // FORTRAN_LOWER_IO_H_
+#endif // FORTRAN_LOWER_IO_H
diff --git a/include/flang/Lower/PFTBuilder.h b/include/flang/Lower/PFTBuilder.h
index 1865b1ed4b97..ecf1f9c2432c 100644
--- a/include/flang/Lower/PFTBuilder.h
+++ b/include/flang/Lower/PFTBuilder.h
@@ -19,7 +19,6 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/raw_ostream.h"
-#include <memory>
 
 namespace mlir {
 class Block;
@@ -36,6 +35,7 @@ struct FunctionLikeUnit;
 // Using std::list for a list of Evaluations preserves the option to do
 // O(1) time insertions anywhere.
 using EvaluationList = std::list<Evaluation>;
+using LabelEvalMap = llvm::DenseMap<Fortran::parser::Label, Evaluation *>;
 
 struct ParentVariant {
   template <typename A>
@@ -352,7 +352,7 @@ struct FunctionLikeUnit : public ProgramUnit {
   std::optional<FunctionStatement> beginStmt;
   FunctionStatement endStmt;
   EvaluationList evaluationList;
-  llvm::DenseMap<parser::Label, Evaluation *> labelEvaluationMap;
+  LabelEvalMap labelEvaluationMap;
   SymbolLabelMap assignSymbolLabelMap;
   std::list<FunctionLikeUnit> nestedFunctions;
   /// Symbol associated to this FunctionLikeUnit.
diff --git a/lib/Lower/Bridge.cpp b/lib/Lower/Bridge.cpp
index 65fc9c776ddf..ac76a58a02df 100644
--- a/lib/Lower/Bridge.cpp
+++ b/lib/Lower/Bridge.cpp
@@ -343,7 +343,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   void switchInsertionPointToOtherwise(fir::WhereOp &where) {
     builder->setInsertionPointToStart(&where.otherRegion().front());
   }
-  
+
   template <typename A>
   mlir::OpBuilder::InsertPoint genWhereCondition(fir::WhereOp &where,
 						 const A *stmt) {
@@ -351,7 +351,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         toLocation(),
         Fortran::semantics::GetExpr(
             std::get<Fortran::parser::ScalarLogicalExpr>(stmt->t)));
-    where = builder->create<fir::WhereOp>(toLocation(), cond, true);
+        where = builder->create<fir::WhereOp>(toLocation(), cond, true);
     auto insPt = builder->saveInsertionPoint();
     switchInsertionPointToWhere(where);
     return insPt;
@@ -618,8 +618,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         } else if (e.isA<Fortran::parser::ElseStmt>()) {
           // otherwise block
           switchInsertionPointToOtherwise(underWhere);
-	} else if (e.isA<Fortran::parser::EndIfStmt>()) {
-	  builder->restoreInsertionPoint(insPt);
+        } else if (e.isA<Fortran::parser::EndIfStmt>()) {
+          builder->restoreInsertionPoint(insPt);
         } else {
           genFIR(e, /*unstructuredContext*/ false);
         }
@@ -865,11 +865,13 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::PrintStmt &stmt) {
-    genPrintStatement(*this, stmt);
+    genPrintStatement(*this, stmt,
+                      eval.getOwningProcedure()->labelEvaluationMap);
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::ReadStmt &stmt) {
-    genReadStatement(*this, stmt);
+    genReadStatement(*this, stmt,
+                     eval.getOwningProcedure()->labelEvaluationMap);
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::RewindStmt &stmt) {
@@ -877,7 +879,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::WriteStmt &stmt) {
-    genWriteStatement(*this, stmt);
+    genWriteStatement(*this, stmt,
+                      eval.getOwningProcedure()->labelEvaluationMap);
   }
 
   void genFIR(Fortran::lower::pft::Evaluation &eval,
@@ -1048,7 +1051,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::FormatStmt &) {
-    TODO();
+    // do nothing. FORMAT statements have no semantics. They may be lowered if
+    // used by a data transfer statement.
   }
   void genFIR(Fortran::lower::pft::Evaluation &eval,
               const Fortran::parser::EntryStmt &) {
diff --git a/lib/Lower/FIRBuilder.cpp b/lib/Lower/FIRBuilder.cpp
index 8ff7f98c4cb2..b02461100bf1 100644
--- a/lib/Lower/FIRBuilder.cpp
+++ b/lib/Lower/FIRBuilder.cpp
@@ -377,6 +377,20 @@ struct CharacterOpsBuilderImpl {
 };
 } // namespace
 
+fir::StringLitOp Fortran::lower::FirOpBuilder::createStringLit(
+    mlir::Location loc, mlir::Type eleTy, llvm::StringRef data) {
+  auto strAttr = mlir::StringAttr::get(data, getContext());
+  auto valTag = mlir::Identifier::get(fir::StringLitOp::value(), getContext());
+  mlir::NamedAttribute dataAttr(valTag, strAttr);
+  auto sizeTag = mlir::Identifier::get(fir::StringLitOp::size(), getContext());
+  mlir::NamedAttribute sizeAttr(sizeTag, getI64IntegerAttr(data.size()));
+  llvm::SmallVector<mlir::NamedAttribute, 2> attrs{dataAttr, sizeAttr};
+  auto arrTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, data.size()), eleTy);
+  return create<fir::StringLitOp>(loc, llvm::ArrayRef<mlir::Type>{arrTy},
+                                  llvm::None, attrs);
+}
+
 template <typename T>
 void Fortran::lower::CharacterOpsBuilder<T>::createCopy(mlir::Value dest,
                                                         mlir::Value src,
diff --git a/lib/Lower/IO.cpp b/lib/Lower/IO.cpp
index a3613a0f50e2..fe56f988c9dd 100644
--- a/lib/Lower/IO.cpp
+++ b/lib/Lower/IO.cpp
@@ -11,7 +11,9 @@
 #include "RTBuilder.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/FIRBuilder.h"
+#include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
+#include "flang/Lower/Utils.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
@@ -329,6 +331,24 @@ lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
   return {buff, len, mlir::Value{}};
 }
 
+/// Pass the body of the FORMAT statement in as if it were a CHARACTER literal
+/// constant. TODO: This feels dumb. Isn't there a front-end method to get this?
+/// If not, why not?
+static std::tuple<mlir::Value, mlir::Value, mlir::Value>
+lowerSourceTextAsStringLit(Fortran::lower::AbstractConverter &converter,
+                           mlir::Location loc, llvm::StringRef text,
+                           mlir::Type ty0, mlir::Type ty1) {
+  text = text.drop_front(text.find('('));
+  text = text.take_front(text.rfind(')') + 1);
+  auto &builder = converter.getFirOpBuilder();
+  auto lit = builder.createStringLit(
+      loc, /*FIXME*/fir::CharacterType::get(builder.getContext(), 1), text);
+  auto data = builder.materializeCharacter(lit);
+  auto buff = builder.create<fir::ConvertOp>(loc, ty0, data.first);
+  auto len = builder.create<fir::ConvertOp>(loc, ty1, data.second);
+  return {buff, len, mlir::Value{}};
+}
+
 //===----------------------------------------------------------------------===//
 // Handle I/O statement specifiers.
 // These are threaded together for a single statement via the passed cookie.
@@ -758,29 +778,37 @@ constexpr bool isDataTransferNamelist<Fortran::parser::PrintStmt>(
 
 static std::tuple<mlir::Value, mlir::Value, mlir::Value>
 genFormat(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
-          const Fortran::parser::Format &format, mlir::Type ty0,
-          mlir::Type ty1) {
+          const Fortran::parser::Format &format, mlir::Type ty0, mlir::Type ty1,
+          Fortran::lower::pft::LabelEvalMap &labelMap) {
   if (auto *e = std::get_if<Fortran::parser::Expr>(&format.u))
     return lowerStringLit(converter, loc, *e, ty0, ty1);
-  TODO(); // handle Label case
+  if (auto *lab = std::get_if<Fortran::parser::Label>(&format.u)) {
+    auto iter = labelMap.find(*lab);
+    assert(iter != labelMap.end() && "FORMAT not found in PROCEDURE");
+    return lowerSourceTextAsStringLit(
+        converter, loc, toStringRef(iter->second->position), ty0, ty1);
+  }
+  llvm_unreachable("* case should be handled elsewhere as transfer list");
 }
 
 template <typename A>
 std::tuple<mlir::Value, mlir::Value, mlir::Value>
 getFormat(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
-          const A &stmt, mlir::Type ty0, mlir::Type ty1) {
+          const A &stmt, mlir::Type ty0, mlir::Type ty1,
+          Fortran::lower::pft::LabelEvalMap &labelMap) {
   if (stmt.format && !formatIsActuallyNamelist(*stmt.format))
-    return genFormat(converter, loc, *stmt.format, ty0, ty1);
+    return genFormat(converter, loc, *stmt.format, ty0, ty1, labelMap);
   return genFormat(converter, loc, *getIOControl<Fortran::parser::Format>(stmt),
-                   ty0, ty1);
+                   ty0, ty1, labelMap);
 }
 template <>
 std::tuple<mlir::Value, mlir::Value, mlir::Value>
 getFormat<Fortran::parser::PrintStmt>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
-    const Fortran::parser::PrintStmt &stmt, mlir::Type ty0, mlir::Type ty1) {
+    const Fortran::parser::PrintStmt &stmt, mlir::Type ty0, mlir::Type ty1,
+    Fortran::lower::pft::LabelEvalMap &labelMap) {
   return genFormat(converter, loc, std::get<Fortran::parser::Format>(stmt.t),
-                   ty0, ty1);
+                   ty0, ty1, labelMap);
 }
 
 static std::tuple<mlir::Value, mlir::Value, mlir::Value>
@@ -1027,7 +1055,8 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
                        mlir::Location loc, const A &stmt,
                        mlir::FunctionType ioFuncTy, bool isFormatted,
                        bool isList, bool isIntern, bool isOtherIntern,
-                       bool isAsynch, bool isNml) {
+                       bool isAsynch, bool isNml,
+                       Fortran::lower::pft::LabelEvalMap &labelMap) {
   auto &builder = converter.getFirOpBuilder();
   if constexpr (hasIOCtrl) {
     // READ/WRITE cases have a wide variety of argument permutations
@@ -1050,7 +1079,7 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
         // | [format, LEN], ...
         auto pair =
             getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
-                      ioFuncTy.getInput(ioArgs.size() + 1));
+                      ioFuncTy.getInput(ioArgs.size() + 1), labelMap);
         ioArgs.push_back(std::get<0>(pair));
         ioArgs.push_back(std::get<1>(pair));
       }
@@ -1071,7 +1100,7 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
         // | [format, LEN], ...
         auto pair =
             getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
-                      ioFuncTy.getInput(ioArgs.size() + 1));
+                      ioFuncTy.getInput(ioArgs.size() + 1), labelMap);
         ioArgs.push_back(std::get<0>(pair));
         ioArgs.push_back(std::get<1>(pair));
       }
@@ -1086,7 +1115,7 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
         // [format, LEN], ...
         auto pair =
             getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
-                      ioFuncTy.getInput(ioArgs.size() + 1));
+                      ioFuncTy.getInput(ioArgs.size() + 1), labelMap);
         ioArgs.push_back(std::get<0>(pair));
         ioArgs.push_back(std::get<1>(pair));
       }
@@ -1101,7 +1130,7 @@ void populateArguments(llvm::SmallVector<mlir::Value, 8> &ioArgs,
       // [format, LEN], ...
       auto pair =
           getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
-                    ioFuncTy.getInput(ioArgs.size() + 1));
+                    ioFuncTy.getInput(ioArgs.size() + 1), labelMap);
       ioArgs.push_back(std::get<0>(pair));
       ioArgs.push_back(std::get<1>(pair));
     }
@@ -1122,8 +1151,9 @@ const std::list<Fortran::parser::OutputItem> &getOutputItems(const A &stmt) {
 }
 
 template <bool isInput, bool hasIOCtrl = true, typename A>
-static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
-                                   const A &stmt) {
+static mlir::Value
+genDataTransfer(Fortran::lower::AbstractConverter &converter, const A &stmt,
+                Fortran::lower::pft::LabelEvalMap &labelMap) {
   auto &builder = converter.getFirOpBuilder();
   auto loc = converter.getCurrentLocation();
   const bool isFormatted = isDataTransferFormatted(stmt);
@@ -1143,7 +1173,7 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
   llvm::SmallVector<mlir::Value, 8> ioArgs;
   populateArguments<hasIOCtrl>(ioArgs, converter, loc, stmt, ioFuncTy,
                                isFormatted, isList, isIntern, isOtherIntern,
-                               isAsynch, isNml);
+                               isAsynch, isNml, labelMap);
   // filename and line are universal and always last
   ioArgs.push_back(
       getDefaultFilename(builder, loc, ioFuncTy.getInput(ioArgs.size())));
@@ -1199,22 +1229,26 @@ static mlir::Value genDataTransfer(Fortran::lower::AbstractConverter &converter,
 
 void Fortran::lower::genPrintStatement(
     Fortran::lower::AbstractConverter &converter,
-    const Fortran::parser::PrintStmt &stmt) {
+    const Fortran::parser::PrintStmt &stmt,
+    Fortran::lower::pft::LabelEvalMap &labelMap) {
   // PRINT does not take an io-control-spec. It only has a format specifier, so
   // it is a simplified case of WRITE.
-  genDataTransfer</*isInput=*/false, /*ioCtrl=*/false>(converter, stmt);
+  genDataTransfer</*isInput=*/false, /*ioCtrl=*/false>(converter, stmt,
+                                                       labelMap);
 }
 
 mlir::Value
 Fortran::lower::genWriteStatement(Fortran::lower::AbstractConverter &converter,
-                                  const Fortran::parser::WriteStmt &stmt) {
-  return genDataTransfer</*isInput=*/false>(converter, stmt);
+                                  const Fortran::parser::WriteStmt &stmt,
+                                  Fortran::lower::pft::LabelEvalMap &labelMap) {
+  return genDataTransfer</*isInput=*/false>(converter, stmt, labelMap);
 }
 
 mlir::Value
 Fortran::lower::genReadStatement(Fortran::lower::AbstractConverter &converter,
-                                 const Fortran::parser::ReadStmt &stmt) {
-  return genDataTransfer</*isInput=*/true>(converter, stmt);
+                                 const Fortran::parser::ReadStmt &stmt,
+                                 Fortran::lower::pft::LabelEvalMap &labelMap) {
+  return genDataTransfer</*isInput=*/true>(converter, stmt, labelMap);
 }
 
 mlir::Value Fortran::lower::genInquireStatement(

From d4f86dd5ff56d4f5c7171dacaa07e477d9ed5066 Mon Sep 17 00:00:00 2001
From: Eric Schweitz <eschweitz@nvidia.com>
Date: Wed, 8 Apr 2020 18:56:54 -0700
Subject: [PATCH 343/345] update the list

---
 LAPACK-bugs.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LAPACK-bugs.txt b/LAPACK-bugs.txt
index 8d5476e1e3e7..b1da627c1127 100644
--- a/LAPACK-bugs.txt
+++ b/LAPACK-bugs.txt
@@ -9,11 +9,11 @@ ______________
 
 UNREACHABLE executed at Lower/Bridge.cpp:1236!  adjustable array?
 UNREACHABLE executed at Lower/ConvertExpr.cpp:798!  intrinsic subroutine
-UNREACHABLE executed at Lower/IO.cpp:764!       FORMAT
 
 FIXED
 _____
 
+UNREACHABLE executed at Lower/IO.cpp:764!       FORMAT
 
 UNREACHABLE executed at Lower/ConvertExpr.cpp:848!  temps on call?
 

From b25defe2513a48dcdf355c68c8cbb380e98402de Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Thu, 9 Apr 2020 12:02:04 -0700
Subject: [PATCH 344/345] disable memtoreg for now. needs to be reworked

---
 tools/bbc/bbc.cpp | 2 +-
 tools/tco/tco.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/bbc/bbc.cpp b/tools/bbc/bbc.cpp
index 5d72d4812cbe..79a05b834d51 100644
--- a/tools/bbc/bbc.cpp
+++ b/tools/bbc/bbc.cpp
@@ -201,7 +201,7 @@ static void convertFortranSourceToMLIR(
   pm.addPass(fir::createLowerToLoopPass());
   pm.addPass(fir::createFIRToStdPass(kindMap));
   pm.addPass(mlir::createLowerToCFGPass());
-  pm.addPass(fir::createMemToRegPass());
+  //pm.addPass(fir::createMemToRegPass());
   pm.addPass(fir::createCSEPass());
   pm.addPass(mlir::createCanonicalizerPass());
 
diff --git a/tools/tco/tco.cpp b/tools/tco/tco.cpp
index c77fa74703e5..de366f9db9e2 100644
--- a/tools/tco/tco.cpp
+++ b/tools/tco/tco.cpp
@@ -98,7 +98,7 @@ static int compileFIR() {
     pm.addPass(fir::createFIRToStdPass(kindMap));
     // convert loop dialect to standard
     pm.addPass(mlir::createLowerToCFGPass());
-    pm.addPass(fir::createMemToRegPass());
+    //pm.addPass(fir::createMemToRegPass());
     pm.addPass(fir::createCSEPass());
     pm.addPass(fir::createFIRToLLVMPass(uniquer));
     pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));

From 3906791df6a08f43b779726e4431161693f268e8 Mon Sep 17 00:00:00 2001
From: Eric <eschweitz@nvidia.com>
Date: Thu, 9 Apr 2020 12:04:09 -0700
Subject: [PATCH 345/345] change the readme to reflect the move

---
 README.md | 136 +-----------------------------------------------------
 1 file changed, 2 insertions(+), 134 deletions(-)

diff --git a/README.md b/README.md
index ce187954669c..9a37d50f2b66 100644
--- a/README.md
+++ b/README.md
@@ -8,138 +8,6 @@
 
 # FIR
 
-Working branch for FIR development.
+The FIR working branch has moved!
 
-## Monorepo now contains MLIR
-
-### In-tree build
-
-This is quite similar to the old way, but with a few subtle differences.
-
-1. Get the stuff.
-
-```
-  git clone git@github.com:flang-compiler/f18-llvm-project.git
-  git clone git@github.com:schweitzpgi/f18.git 
-```
-
-2. Get "on" the right branches.
-
-```
-  (cd f18-llvm-project ; git checkout mono)
-  (cd f18 ; git checkout mono)
-```
-             
-3. Setup the LLVM space for in-tree builds.
-   
-``` 
-  (cd f18-llvm-project ; ln -s ../f18 flang)
-```
-
-4. Create a build space for cmake and make (or ninja)
-
-```
-  mkdir build
-  cd build
-  cmake ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS="flang;mlir" -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DLLVM_INSTALL_UTILS=On <other-arguments>
-```
-
-5. Build everything
-
-One can, for example, do this with make as follows.
-
-```
-cd where/you/want/to/build/llvm
-git clone --depth=1 -b f18 https://github.com/flang-compiler/f18-llvm-project.git
-mkdir build
-mkdir install
-cd build
-cmake ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release \
-    -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 \
-    -DLLVM_INSTALL_UTILS=On \
-    -DCMAKE_INSTALL_PREFIX=../install
-make
-make install
-```
-
-Or, of course, use their favorite build tool (such as ninja).
-
-### Out-of-tree build
-
-1. Get the stuff is the same as above. Get the code from the same repos.
-
-2. Get on the right branches. Again, same as above.
-
-3. SKIP step 3 above. We're not going to build `flang` yet.
-
-4. Create a build space for cmake and make (or ninja)
-
-```
-  mkdir build
-  cd build
-  export CC=<my-favorite-C-compiler>
-  export CXX=<my-favorite-C++-compiler>
-  cmake -GNinja ../f18-llvm-project/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_ENABLE_PROJECTS=mlir -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DLLVM_INSTALL_UTILS=On -DCMAKE_INSTALL_PREFIX=<install-llvm-here> <other-arguments>
-```
-
-5. Build and install
-
-```
-  ninja
-  ninja install
-```
-
-6. Add the new installation to your PATH
-
-```
-  PATH=<install-llvm-here>/bin:$PATH
-```
-
-7. Create a build space for another round of cmake and make (or ninja)
-
-```
-  mkdir build-flang
-  cd build-flang
-  cmake -GNinja ../f18 -DLLVM_DIR=<install-llvm-here> -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86 -DCMAKE_CXX_STANDARD=17 -DLLVM_BUILD_TOOLS=On -DCMAKE_INSTALL_PREFIX=<install-flang-here> <other-arguments>
-```
-Note: if you plan on running lit regression tests, you should either:
-- Use `-DLLVM_DIR=<build-llvm-here>` instead of `-DLLVM_DIR=<install-llvm-here>`
-- Or, keep `-DLLVM_DIR=<install-llvm-here>` but add `-DLLVM_EXTERNAL_LIT=<path to llvm-lit>`.
-A valid `llvm-lit` path is `<build-llvm-here>/bin/llvm-lit`.
-Note that LLVM must also have been built with `-DLLVM_INSTALL_UTILS=On` so that tools required by tests like `FileCheck` are available in `<install-llvm-here>`.
-
-8. Build and install
-
-```
-  ninja
-  ninja check-flang
-  ninja install
-```
-
-### Running regression tests
-
-Inside `build` for in-tree builds or inside `build-flang` for out-of-tree builds:
-
-```
-  ninja check-flang
-```
-
-Special CMake instructions given above are required while building out-of-tree so that lit regression tests can be run.
-
-### Problems
-
-To run individual regression tests llvm-lit needs to know the lit
-configuration for f18. The parameters in charge of this are:
-flang_site_config and flang_config. And they can be set as shown bellow:
-```
-<path-to-llvm-lit>/llvm-lit \
- --param flang_site_config=<path-to-f18-build>/test-lit/lit.site.cfg.py \
- --param flang_config=<path-to-f18-build>/test-lit/lit.cfg.py \
-  <path-to-fortran-test>
-```
-
-# How to Generate FIR Documentation
-
-If f18 was built with `-DLINK_WITH_FIR=On` (`On` by default), it is possible to
-generate FIR language documentation by running `make flang-doc`. This will
-create `docs/Dialect/FIRLangRef.md` in f18 build directory.
+The work continues here: https://github.com/flang-compiler/f18-llvm-project/tree/fir-dev